学习某培训教材的记录:
变量及赋值:
Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。
将一个值赋给变量的操作被称为赋值。如:
a = 101
b = 102
print(a+b)
多重赋值与多元赋值:
多重赋值:可以同时给多个变量赋予相同内容的操作。如:
a = b = c = 200
多元赋值:可同时给多个变量赋予不同内容的操作。如:
a,b,c = 1,2,3
标准数据类型:Python有5个标准的数据类型:
Numbers(数字)
String(字符串)
List (列表)
Tuple(元组)
Dictionary(字典)
数字:数字数据类型用于存储数值。其为不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。
Python支持多种不同的数据类型:
int (有符号整型):200,600
float(浮点型): 0.2,69.8
complex(复数):3.14j,0.897j
变量使用注意事项:
a:变量使用前需要对其进行赋值;
b:变量名可以包括字母,数字,下划线,但不能以数字开头;
变量命名原则:
a:模块名:小写字母,单词之间用下划线“_”分割。如:
ad_stats.py
b:类名:单词首字母大写。如:AdStats
c:普通变量:小写字母,单词之间用下划线“_”分割。如:
app_stats
d:实例变量(指跟类的具体实例相关联的变量):以下划线“_”开头,小写字母,单词之间用下划线“_”分割。如:
_price
_instance_var
不会被语句"from module import *" 语句加载。
e:普通函数:小写字母,单词之间用下划线“_”分割。如:
get_age()
f:私有函数:
以两个下划线"_"开头,小写字母,单词之间用下划线“_”分割。如:
__get_age()
外部访问会报错。
函数:函数是一种方法,可以用来实现特定的功能。
内建函数:Python有很多函数,这种Python自带的函数称为内建函数。如:
input() 获取用户输入。
int(object) 将字符串和数字转换为整数。
str(object) 将值转换为字符串。
创建函数:是组织程序的关键,创建并使用函数可以减少程序中重复的代码,使主程序更抽象,结构更清晰。创建函数格式如下:
def 函数名称():
函数内的语句
如:
def say_hello():
print("hi")
print("My name is LiLei")
括号内可以填入参数,也可以不填,或填入多个参数,用逗号隔开即可。如果需要返回参数,可在需要返回的内容前加return。
def 函数名称(参数1,参数2,参数3,......):
函数内的语句
.........
return 返回内容
如:
def add(a,b):
sum_number = a+b
return sum_number
数据类型:
数字:Python提供了常用的数字类型:整数,浮点数,布尔型,复数:
整数:int,以十进制数字的字符串写法出现。
浮点数:实数在Python中称作浮点数(Float)。
布尔型:bool,仅有两个值:True 和 False,分别表示“真”和“假” 。
复数:Python的复数常量写成实部 + 虚部的写法,这里的虚部是以j或J结尾。
序列:在Python这包含6种内建序列,即列表,元组,字符串等;
列表:
列表的各个元素通过逗号分隔,写在方括号中。如:
test_ad = ['Abb',123]
序列中也可以包括其他序列:如:
test_ad = ['Abb',123]
test_ad2 = ['sd',456]
database = [test_ad,test_ad2 ]
print(database )
字符串:是由数字,字母,下划线组成的一串字符。它是编程语言中表示文本的数据类型。如下:
name = "ixusy"
字符串可以是文本或符号等。字符串可以用单引号'',双引号"",三引号''' '''括起来创建。加了引号的数字一定是字符 串
元组:
元组由简单的对象组构成,是一种不可变系列。元组与列表非常相似,只不过元组不能在原处修改,并且通常写成圆
括号"()"中的一系列项。虽然元祖不支持任何方法调用,但元祖与列表相同,可以嵌入到任何类别的对象中。
元组的意义在于:元组可以在映射(和集合的成员)中当作键来使用,列表不行。元组作为很多内建函数和
方法的返回值存在。如:
t = (1,2,3,4,"pass")
字典:字典是一种无序列表,用 "{}" 进行创建。字典中的每个成员由两部分组成:一部分是键,一部分是值;如:
grad = {"abc":"85","cc":"99"}
字典中的键是唯一的,但值不唯一。
集合:
在Python中,集合由内置的set类型定义。要创建集合,需要将所有项元素放在花括号“{}”内,以逗号","分隔,如:
a = {10,20,30,40,50,60}
b = {20,40,60}
在Python中,集合可以分成两类:一类是可变集合,及可以原地修改;一类是不可变集合,即不可原地修改。
集合可以有任意数量的元素,它们可以是不同的类型,例如:数字,元组,字符串等。但是,集合不能有可
变元素,例如:列表,集合,字典。如:
a = {10,20,30,40,50,60}
b = {20,40,60}
print(a - b)
程序输出结果是:
{10,30,50}
字符串:字符串是一个有序的字符的集合,用来存储和表现基于文本的信息。所有标准的序列操作都适用于字符串,但是字符串不可变。创建字符串可以使用单引号,双引号,这两种引号没有区别。三引号可以输出多行的长字符串,此功能是单引号和双引号不能实现的。
使用索引“[]”可以获取字符串中特定的元素。使用切片操作“[:]”可以提取子字符串。字符有2种提取顺序:
a:从左到右索引默认0开始的,最大范围是字符串长度少1;
b:从右到左索引默认-1开始,最大范围是字符串开头;
在Python中不能让字符串与数字相加。需要使用转换工具进行预处理:
int:把字符串转换为数字;
str:把数字转换为字符串;如下:
num = 15
int(num) #将字符串转换为数字
str(num) #将数字转换为字符串
修改字符串:
字符串是不可变的,因此不能在原处直接对其修改。可以使用通过分片与合并来建立新的字符串;如果是想替换字符串中的一个字符,可以使用字符串的replace方法实现。
字符串的使用:
访问字符串的值:
Python里面没有字符这个类型,而是用长度为1的字符串来表示这个概念,用方括号加一个或者多于一个索引的方式来 获得子串;
字符串的操作符:
a:检查符: in,not in :可以用来判断一个字符或者一个子串是否出现在另一个字符串中,检验结果会以布尔值的形式返回,出现则返回True,否则返回False。
b:连接符:“+” 可以用来连接字符串,从而获得一个新的字符串。用“*”可以将一个系列重复n次;
c:长度,最小值,最大值:函数len()可以返回序列中所包含的数量,min函数和max函数可以分别返回序列中的最小值与最大值。
d:读取用户输入:input():Python内建的input函数可以使用给定字符串提示用户输入并将这个输入返回。
条件判断:
if语句:可以用于判断结果真假的条件表达式,以布尔值的方式显示结果;
else 语句:else语句依附于if语句存在,为if语句提供了另外一种选择;
elif语句:如果需要检查多个条件,就可以使用elif语句,即else if的简写;
常用运算符:
算术运算符:(a = 10,b = 21)
+:加法运算,将运算符两边的操作数相加。(a + b = 31)
- :减法运算,将运算符左边的操作数减去右边的操作数。(a - b = -11)
* :乘法运算,将运算符两边的操作数相乘。(a * b = 210)
/ :除法运算,用右操作数除左操作数。( b / a = 2.1) (取整使用 int(b/a))
%:模运算,用右操作数除左操作数并返回余数。(b % a = 1)
** :对运算符进行指数(幂)运算。(10**21 表示10的21次幂)
比较(关系)运算符:(a = 10,b = 21)
== :如果两个操作数的值相等,则条件为真。 (a == b)求值结果为False
!= :如果两个操作数的值不相等,则条件为真。 (a != b)求值结果为True
> :如果左操作数的值大于右操作数的值,则条件为真。 (a > b)求值结果为False
< :如果左操作数的值小于右操作数的值,则条件为真。 (a < b)求值结果为True
>= :如果左操作数的值大于或等于右操作数的值,则条件为真。(a >= b)求值结果为False
<= :如果左操作数的值小于或等右操作数的值,则条件为真。 (a <= b)求值结果为True
赋值运算符:(a = 10,b = 21)
= :将右操作数的值分配给左操作数。
+=:将右操作数相加到左操作数,并将结果分配给左操作数。
-=: 从左操作数中减去右操作数,并将结果分配给左操作数。
*=:将右操作数与左操作数相乘,并将结果分配给左操作数。
/=:将左操作数除以右操作数,并将结果分配给左操作数。
%=:将左操作数除以右操作数的模数,并将结果分配给左操作数。
**=:执行指数(幂)计算,并将结果分配给左操作数。
//= :运算符执行地板除运算,并将结果分配给左操作数。
逻辑运算符:
and: 如果两个操作数都为真,则条件成立。
or : 如果两个操作数中的任何一个非零,则条件成为真。
not : 用户反转操作数的逻辑状态。
身份运算符:
身份运算符比较两个对象的内存位置。
is : 如果运算符任一侧的变量指向相同的对象,则返回True,否则返回False。
is not : 如果运算符任一侧的变量指向相同的对象,则返回False,否则返回True。
运算符优先级:
序号 | 运算符 | 描述 |
1 | ** | 指数(次幂)运算 |
2 | ~ + - | 补码,一元加减(最后两个的方法名称是+@ 和 -@) |
3 | * / % // | 乘法,除法,模数和地板除 |
4 | + - | |
5 | >> << | 向右 和向左位移 |
6 | & | 按位与 |
7 | ^ | | 按位异或 和 常规的‘OR’ |
8 | < = < > >= | 比较运算符 |
9 | <> == != | 等于运算符 |
10 | = %= /= //= -= += *= **= | 赋值运算符 |
11 | is is not | 身份运算符 |
12 | in not in | 成员运算符 |
13 | not ir and | 逻辑运算符 |
循环:
while循环:
cnt = 0
while cnt < 10:
print("The Cnt is",cnt)
cnt += 1
print("end")
for循环:
for循环可以遍历然后系列和其他可迭代对象(可以按次序获取的对象)的集合,如一个列表或者一个字符串。其语法格式如下:
for 可重复变量 in 系列:
statements(s)
for i in "ixusy88":
print(i)
退出循环:
break 用户退出循环,
跳出循环:
continue,用户终止当前循环(即跳过循环当前剩下的语句),继续执行下一次循环
列表:
列表是Python中最具灵活性的有序集合对象类型。与字符串不同的是,列表可以包含任何种类的对象:数字,字符串甚至是其它列表。同样,与字符串不同,列表都是可变对象,它们都支持在原处修改的操作,可以通过指定的值和分片,列表方法调用,删除语句等方法来实现。
列表有以下几个特征:
1:是任意对象的有序集合;
2:可以进行分片和合并
3:可变长度,异构(可包含任意类型对象)以及任意嵌套
4:属于可变序列的分类
5:对象引用数组
通用列表操作:
表达式 | 描述 |
L1=[] | 创建一个空列表 |
L2=[1,2,3,4,5,6] | 创建一个有成员的列表 |
L3=['abc',['def','ghi']] | 创建一个嵌套的子列表 |
L2[i] | 索引 |
L1+L2 | 合并 |
L1*4 | 重复 |
更新列表:
你可以对列表的数据项进行修改或更新,你也可以使用append()方法来添加列表项,如下所示:
list = []
list.append('1234')
list.append('4567')
print(list)
删除列表元素:
可以使用del语句来删除列表的元素:
list1 = ['a','b',1,2]
print(list1)
del list1[2]
print(list1)
Python列表脚本操作符:
列表对 + 和 * 的操作符与字符串相似。
使用方法如下所示:
Python表达式 | 结果 | 描述 |
len([1,2,3]) | 3 | 长度 |
[1,2,3]+[4,5,6] | [1,2,3,4,5,6] | 组合 |
['Hi']*4 | ['Hi','Hi','Hi','Hi'] | 重复 |
3 in [1,2,3] | True | 元素是否存在于列表中 |
for i in [1,2,3]: print(i) |
1 2 3 | 迭代 |
Python列表函数 和 方法
Python包含以下函数:
序号 | 函数 | 描述 |
1 | len(list) | 列表元素个数 |
2 | max(list) | 返回列表元素最大值 |
3 | min(list) | 返回列表元素最小值 |
4 | list(seq) | 将元祖转换为列表 |
Python包含以下方法:
序号 | 方法 | 描述 |
1 | list.append(obj) | 在列表末尾添加新的对象 |
2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index,obj) | 将对象插入列表 |
6 | list.pop(obj=list[-1]) | 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
8 | list.reverse() | 反向列表中的元素 |
9 | list.sort([func]) | 对原列表进行排序 |
字典:
字典是另一种可变容器模型,且可存储任意类型对象,字典是Python中唯一内建的映射类型,映射是指通过名字来引用值的数据结构。
字典的每个键值对"key:value" 用冒号“:”分割,每个键值对之间用“,”分割,整个字典包括在花括号“{}”中,格式如下所示:
d={key1:value1,key2:value2}
键一般是唯一的,可以是数字,字符串甚至是元祖,如果重复最后的一个键值对会替换前面的,值不需要唯一,且可以是任何数据类型。字典中的值并没有特殊的顺序。
访问字典中的值:
可以直接使用print语句输出字典键对应的值,例如:
dict = {"Name":"zara"}
print("Name: ",dict['Name'])
修改字典:
向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对,例如:
dict = {'Name':'Zara','Age':7,'class':'First'}
dict['Age'] = 8
dict['Scholl'] = "DPS School"
print("dict['Age']:",dict['Age'])
print("dict['School']:",dict['School'])
删除字典元素:
能删单一的元素也能清空字典,清空只需一项操作。
student_dict = {'Name':'Zara','Age':7,'Class':'First'}
del student_dict['Name']
print(student_dict)
student_dict.clear()
print(student_dict)
字典键的特性:
字典值可以没有限制地取任何python对象,既可以是标准的对象,也可以是用户定义的,但键不行。两个重要的点需要记住:
1:不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住。
2:键必须不可变,所以可以用数字,字符串或元祖充当,所以用列表就不行。
字典内置函数和方法:
Python字典包含了以下内置函数:
序号 | 方法 | 描述 |
1 | len(dict) | 计算字典元素个数,即键的总数 |
2 | str(dict) | 输出字典可打印的字符串表示 |
3 | type(variable) | 返回输入的变量类型,如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法:
序号 | 函数 | 描述 |
1 | dict.clear() | 删除字典内所有元素 |
2 | dict.copy() | 返回一个字典的浅复制 |
3 | dict.fromkeys(seq[,val]) | 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值 |
4 | dict.get(key,default=None) | 返回指定键的值,如果值不在字典中返回default值 |
5 | dict.items() | 以列表返回可遍历的(键,值)元祖数组 |
6 | dict.keys() | 以列表返回一个字典所有的键 |
7 | dict.setdefault(key,default=None) | 和get()类似,但如果键不存在于字典中,将会添加键并将值设为default |
8 | dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
9 | dict.values() | 以列表返回字典中的所有值 |
10 | dict.pop(key[,default]) | 删除字典给定键key所对应的值,返回值为被删除的值。key值必须给出。否则,返回default值。 |
11 | dict.popitem() | 随机返回并删除字典中的一对键和值 |
类:
类(Class)是用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。所有的对象都属于某一个类,称为类的实例,对象是类的实例。
创建类:可以使用class语句来创建一个新类,class之后为类的名称并以冒号结尾,例如:
class 类的名称(): #命名类时类名的单词首字母要大写,使用驼峰命名法
class Student():
def say_hi(self):
print("Hi!")
li = Student()
li.say_hi
创建实例对象:
在Python 中,类的实例化类似函数调用方式,通过__init__方法接收参数(init前后各有两个下划线)。例如:
class Student():
def __init__(self,name):
self.name = name
def say_hi(self):
print("Hi {} !".format(self.name))
li = Student("li")
li.say_hi()
han = Student("han")
han.say_hi()
Python内置类属性:
序号 | 名称 | 描述 |
1 | __dict__ | 类的属性(包含一个字典,由类的数据属性组成) |
2 | __doc__ | 类的文档字符串 |
3 | __name__ | 类名 |
4 | __module__ | 类定义所在的模块(类的全名是'__naib__.className',如果类位于一个导入模块mymod中,那么className.__module__等于mymod) |
5 | __bases__ | 类的所有父类构成元素(包含了一个由所有父类组成的元组) |
class Student():
StuCount = 0
def __init__(self,name,grade):
self.name = name
self.grade = grade
Student.StuCount += 1
def displayCount(self):
print("Total Student {}".format(Student.StuCount))
def displayStudent(self):
print("Name:{},grade:{}".format(self.name,self.grade))
print("Student.__doc__:",Student.__doc__)
print("Student.__name__:",Student.__name__)
print("Student.__module__:",Student.__module__)
print("Student.__bases__",Student.__bases__)
print("Student.__dict__",Student.__dict__)
类的继承:
继承完全可以理解成类之间的类型和子类型关系。如果你已经有了一个类,而又想建立一个非常类似的类,例如只想添加几个方法,而在编写新类时,又不想把旧类的代码全部复制过去,就可以用继承的方法。
继承语法:
class 子类名(父类名):
在python继承中的一些特点:
1:在继承中父类的构造(__init__()方法)不会被自动调用,它需要在其子类的构造中亲自专门调用。
2:在调用父类的方法时,需要加上父类的类名前缀,且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数
3:Python总是首先查找对应类型的方法,如果它不能在子类中找到对应的方法,它才开始到父类中逐个查找。(先在本类中查找调用方法,找不到才去父类中找)。
如果在继承元组中有一个以上的类,那么它就被称作“多重继承”。
语法表示:
子类的声明,与他们的父类类似,继承的父类列表跟在类名之后,如下所示:
class 子类名(父类1[,父类2,......]):
'类文档字符串'
class_suite
例如:
class Parent():
"""docstring for Parent"""
parent_attr = 100
def __init__(self):
print("调用父类的构造函数")
def parent_method(self):
print("调用父类方法")
def set_attr(self,attr):
Parent.parent_attr = attr
def get_attr(self):
print("父类属性:",Parent.parent_attr)
class Child(Parent):
def __init__(self):
#Parent.__init__(self)
print("调用子类的构造函数")
def child_method(self):
print("调用子类方法")
li = Child()
li.parent_method()
li.child_method()
li.set_attr(50)
li.get_attr()