默认情况下,Python 3 源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串。
Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:
>>> import keyword>>> keyword.kwlist
Python中单行注释以 # 开头,多行注释可以用多个 # 号,还有 ''' 和 """
python最具特色的就是使用缩进来表示代码块,不需要使用大括号 {} 。
缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠(\)来实现多行语句,在 [], {}, 或 () 中的多行语句,不需要使用反斜杠(\),
标准数据类型
Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
Python3 中有六个标准的数据类型:
- Number(数字)
- String(字符串)
- List(列表)
- Tuple(元组)
- Set(集合)
- Dictionary(字典)
Python3 的六个标准数据类型中:
- 不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
- 可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。
数字(Number)类型
python中数字有四种类型:整数、布尔型、浮点数和复数。
- int (整数), 如 1, 只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
- bool (布尔), 如 True。到 Python3 中,把 True 和 False 定义成关键字了,但它们的值还是 1 和 0,它们可以和数字相加。
- float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型
内置的 type() 函数可以用来查询变量所指的对象类型。
可以使用del语句删除一些对象引用。del var_a, var_b
注意:
- 1、Python可以同时为多个变量赋值,如a, b = 1, 2。
- 2、一个变量可以通过赋值指向不同类型的对象。
- 3、数值的除法包含两个运算符:/ 返回一个浮点数,// 返回一个整数。
- 4、在混合计算时,Python会把整型转换成为浮点数。
数学函数
函数 |
返回值 ( 描述 ) |
返回数字的绝对值,如abs(-10) 返回 10 |
|
返回数字的上入整数,如math.ceil(4.1) 返回 5 |
|
cmp(x, y) |
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换。 |
返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
|
返回数字的绝对值,如math.fabs(-10) 返回10.0 |
|
返回数字的下舍整数,如math.floor(4.9)返回 4 |
|
如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
|
返回以10为基数的x的对数,如math.log10(100)返回 2.0 |
|
返回给定参数的最大值,参数可以为序列。 |
|
返回给定参数的最小值,参数可以为序列。 |
|
返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。 |
|
x**y 运算后的值。 |
|
返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。 |
|
返回数字x的平方根。 |
随机数函数
随机数可以用于数学,游戏,安全等领域中,还经常被嵌入到算法中,用以提高算法效率,并提高程序的安全性。
Python包含以下常用随机数函数:
函数 |
描述 |
从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。 |
|
从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1 |
|
随机生成下一个实数,它在[0,1)范围内。 |
|
改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。 |
|
将序列的所有元素随机排序 |
|
随机生成下一个实数,它在[x,y]范围内。 |
三角函数
Python包括以下三角函数:
函数 |
描述 |
返回x的反余弦弧度值。 |
|
返回x的反正弦弧度值。 |
|
返回x的反正切弧度值。 |
|
返回给定的 X 及 Y 坐标值的反正切值。 |
|
返回x的弧度的余弦值。 |
|
返回欧几里德范数 sqrt(x*x + y*y)。 |
|
返回的x弧度的正弦值。 |
|
返回x弧度的正切值。 |
|
将弧度转换为角度,如degrees(math.pi/2) , 返回90.0 |
|
将角度转换为弧度 |
数学常量
常量 |
描述 |
pi |
数学常量 pi(圆周率,一般以π来表示) |
e |
数学常量 e,e即自然常数(自然常数)。 |
字符串(String)
- python中单引号和双引号使用完全相同。
- 使用三引号('''或""")可以指定一个多行字符串。
- 转义符 '\',反斜杠可以用来转义,使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示,并不是换行。另外,反斜杠(\)可以作为续行符,表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
- 按字面意义级联字符串,如"this " "is " "string"会被自动转换为this is string。
- 字符串可以用 + 运算符连接在一起,用 * 运算符重复。
- Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。
- Python中的字符串不能改变。向一个索引位置赋值,比如word[0] = 'm'会导致错误。
- Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。
索引值以 0 为开始值,-1 为从末尾的开始位置。
Python字符串运算符
下表实例变量a值为字符串 "Hello",b变量值为 "Python":
操作符 |
描述 |
实例 |
+ |
字符串连接 |
a + b 输出结果: HelloPython |
* |
重复输出字符串 |
a*2 输出结果:HelloHello |
[] |
通过索引获取字符串中字符 |
a[1] 输出结果 e |
[ : ] |
截取字符串中的一部分,遵循左闭右开原则,str[0,2] 是不包含第 3 个字符的。 |
a[1:4] 输出结果 ell |
in |
成员运算符 - 如果字符串中包含给定的字符返回 True |
'H' in a 输出结果 True |
not in |
成员运算符 - 如果字符串中不包含给定的字符返回 True |
'M' not in a 输出结果 True |
r/R |
原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。 |
print( r'\n' )print( R'\n' ) |
python字符串格式化符号:
<tbody
符 号 |
描述 |
%c |
格式化字符及其ASCII码 |
%s |
格式化字符串 |
%d |
格式化整数 |
%u |
格式化无符号整型 |
%o |
格式化无符号八进制数 |
%x |
格式化无符号十六进制数 |
%X |
格式化无符号十六进制数(大写) |
%f |
格式化浮点数字,可指定小数点后的精度 |
%e |
用科学计数法格式化浮点数 |
%E |
作用同%e,用科学计数法格式化浮点数 |
%g |
%f和%e的简写 |
%G |
%f 和 %E 的简写 |
%p |
用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
符号 |
功能 |
* |
定义宽度或者小数点精度 |
- |
用做左对齐 |
+ |
在正数前面显示加号( + ) |
<sp> |
在正数前面显示空格 |
# |
在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
0 |
显示的数字前面填充'0'而不是默认的空格 |
% |
'%%'输出一个单一的'%' |
(var) |
映射变量(字典参数) |
m.n. |
m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。三引号让程序员从引号和特殊字符串的泥潭里面解脱出来,自始至终保持一小块字符串的格式是所谓的WYSIWYG(所见即所得)格式的。一个典型的用例是,当你需要一块HTML或者SQL时,这时用字符串组合,特殊字符串转义将会非常的繁琐。
在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。在Python3中,所有的字符串都是Unicode字符串。
Python 的字符串内建函数
Python 的字符串常用内建函数如下:
序号 |
方法及描述 |
1 |
capitalize() |
2 |
|
3 |
count(str, beg= 0,end=len(string))
|
4 |
bytes.decode(encoding="utf-8", errors="strict")
|
5 |
encode(encoding='UTF-8',errors='strict')
|
6 |
endswith(suffix, beg=0, end=len(string)) |
7 |
|
8 |
find(str, beg=0 end=len(string))
|
9 |
index(str, beg=0, end=len(string))
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
rfind(str, beg=0,end=len(string))
|
28 |
rindex( str, beg=0, end=len(string))
|
29 |
|
30 |
|
31 |
split(str="", num=string.count(str))
|
32 |
|
33 |
startswith(str, beg=0,end=len(string))
|
34 |
|
35 |
|
36 |
|
37 |
translate(table, deletechars="")
|
38 |
|
39 |
|
40 |
|
字符串的截取的语法格式如下:变量[头下标:尾下标],是从0开始的,能用-1,甚至可以不写,表示开头
List(列表)
List(列表) 是 Python 中使用最频繁的数据类型。list1 = ['Google', 'Runoob', 1997, 2000];你可以对列表的数据项进行修改或更新,你也可以使用append()方法来添加列表项,可以使用 del 语句来删除列表的的元素del list[2]
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。与Python字符串不一样的是,列表中的元素是可以改变的
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。
加号 + 是列表连接运算符,星号 * 是重复操作。
列表截取的语法格式如下:
变量[头下标:尾下标]
索引值以 0 为开始值,-1 为从末尾的开始位置。
注意:
- 1、List写在方括号之间,元素用逗号隔开。
- 2、和字符串一样,list可以被索引和切片。
- 3、List可以使用+操作符进行拼接。
- 4、List中的元素是可以改变的。
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([index=-1]]) |
7 |
list.remove(obj) |
8 |
list.reverse() |
9 |
|
10 |
list.clear() |
11 |
list.copy() |
Tuple(元组)
元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用
元组中的元素类型也可以不相同,元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
元组与字符串类似,可以被索引且下标索引从0开始,-1 为从末尾开始的位置。也可以进行截取(看上面,这里不再赘述)。其实,可以把字符串看作一种特殊的元组。
虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
tup1 = () # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号
string、list和tuple都属于sequence(序列)。
注意:
- 1、与字符串一样,元组的元素不能修改。
- 2、元组也可以被索引和切片,方法一样。
- 3、注意构造包含0或1个元素的元组的特殊语法规则。
- 4、元组也可以使用+操作符进行拼接。
Python元组包含了以下内置函数
序号 |
方法及描述 |
实例 |
1 |
len(tuple) |
>>> tuple1 = ('Google', 'Runoob', 'Taobao')>>> len(tuple1)3>>> |
2 |
max(tuple) |
>>> tuple2 = ('5', '4', '8')>>> max(tuple2)'8'>>> |
3 |
min(tuple) |
>>> tuple2 = ('5', '4', '8')>>> min(tuple2)'4'>>> |
4 |
tuple(seq) |
>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']>>> tuple1=tuple(list1)>>> tuple1('Google', 'Taobao', 'Runoob', 'Baidu') |
Set(集合)
集合(set)是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。创建格式:parame = {value01,value02,...}或者set(value)
s.add( x ),将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。
还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等,语法格式如下:s.update( x )x 可以有多个,用逗号分开。
s.remove( x ),将元素 x 添加到集合 s 中移除,如果元素不存在,则会发生错误。此外还有一个方法也是移除集合中的元素,且如果元素不存在,不会发生错误。格式如下所示:
s.discard( x )
我们也可以设置随机删除集合中的一个元素,语法格式如下:
s.pop()
计算集合元素个数语法格式:len(s)
清空集合语法格式:s.clear()
判断元素是否在集合中存在语法格式:x in s
集合内置方法完整列表
方法 |
描述 |
为集合添加元素 |
|
移除集合中的所有元素 |
|
拷贝一个集合 |
|
返回多个集合的差集 |
|
移除集合中的元素,该元素在指定的集合也存在。 |
|
删除集合中指定的元素 |
|
返回集合的交集 |
|
删除集合中的元素,该元素在指定的集合中不存在。 |
|
判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 |
|
判断指定集合是否为该方法参数集合的子集。 |
|
判断该方法的参数集合是否为指定集合的子集 |
|
随机移除元素 |
|
移除指定元素 |
|
返回两个集合中不重复的元素集合。 |
|
移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 |
|
返回两个集合的并集 |
|
给集合添加元素 |
Dictionary(字典)
字典(dictionary)是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典是一种映射类型,字典用"{ }"标识,它是一个无序的键(key) : 值(value)对集合。字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,d = {key1 : value1, key2 : value2 }
键(key)必须使用不可变类型。
在同一个字典中,键(key)必须是唯一的。键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行
构造函数 dict() 可以直接从键值对序列中构建字典
另外,字典类型也有一些内置的函数,例如clear()、keys()、values()等。
能删单一的元素也能清空字典,清空只需一项操作。显示删除一个字典用del命令
注意:
- 1、字典是一种映射类型,它的元素是键值对。
- 2、字典的关键字必须为不可变类型,且不能重复。
- 3、创建空字典使用 { }。
Python字典包含了以下内置函数:
序号 |
函数及描述 |
实例 |
1 |
len(dict) |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> len(dict)3 |
2 |
str(dict) |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> str(dict)"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}" |
3 |
type(variable) |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> type(dict)<class 'dict'> |
Python字典包含了以下内置方法:
序号 |
函数及描述 |
1 |
radiansdict.clear() |
2 |
radiansdict.copy() |
3 |
radiansdict.fromkeys() |
4 |
radiansdict.get(key, default=None) |
5 |
key in dict |
6 |
radiansdict.items() |
7 |
radiansdict.keys() |
8 |
radiansdict.setdefault(key, default=None) |
9 |
radiansdict.update(dict2) |
10 |
radiansdict.values() |
11 |
pop(key[,default]) |
12 |
popitem() |
空行
函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。
空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
记住:空行也是程序代码的一部分。
Python数据类型转换
有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。
函数 |
描述 |
将x转换为一个整数 |
|
将x转换到一个浮点数 |
|
创建一个复数 |
|
将对象 x 转换为字符串 |
|
将对象 x 转换为表达式字符串 |
|
用来计算在字符串中的有效Python表达式,并返回一个对象 |
|
将序列 s 转换为一个元组 |
|
将序列 s 转换为一个列表 |
|
转换为可变集合 |
|
创建一个字典。d 必须是一个序列 (key,value)元组。 |
|
转换为不可变集合 |
|
将一个整数转换为一个字符 |
|
将一个字符转换为它的整数值 |
|
将一个整数转换为一个十六进制字符串 |
|
将一个整数转换为一个八进制字符串 |
Python可以在同一行中使用多条语句,语句之间使用分号(;)分割,缩进相同的一组语句构成一个代码块,我们称之代码组。像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句(clause)。如下实例:
if expression :
suiteelif expression :
suite else :
suite
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end="":print( x, end=" " )
用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入,格式为: import somemodule
从某个模块中导入某个函数,格式为: from somemodule import somefunction
从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入,格式为: from somemodule import *
Python算术运算符
以下假设变量a为10,变量b为21:
运算符 |
描述 |
实例 |
+ |
加 - 两个对象相加 |
a + b 输出结果 31 |
- |
减 - 得到负数或是一个数减去另一个数 |
a - b 输出结果 -11 |
* |
乘 - 两个数相乘或是返回一个被重复若干次的字符串 |
a * b 输出结果 210 |
/ |
除 - x 除以 y |
b / a 输出结果 2.1 |
% |
取模 - 返回除法的余数 |
b % a 输出结果 1 |
** |
幂 - 返回x的y次幂 |
a**b 为10的21次方 |
// |
取整除 - 返回商的整数部分 |
9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
注意:在不同的机器上浮点运算的结果可能会不一样。
在整数除法中,除法 / 总是返回一个浮点数,如果只想得到整数的结果,丢弃可能的分数部分,可以使用运算符 //,// 得到的并不一定是整数类型的数,它与分母分子的数据类型有关系。
Python逻辑运算符
Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:
运算符 |
逻辑表达式 |
描述 |
实例 |
and |
x and y |
布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 |
(a and b) 返回 20。 |
or |
x or y |
布尔"或" - 如果 x 是 True,它返回 x 的值,否则它返回 y 的计算值。 |
(a or b) 返回 10。 |
not |
not x |
布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 |
not(a and b) 返回 False |
Python成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符 |
描述 |
实例 |
in |
如果在指定的序列中找到值返回 True,否则返回 False。 |
x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in |
如果在指定的序列中没有找到值返回 True,否则返回 False。 |
x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符 |
描述 |
实例 |
is |
is 是判断两个标识符是不是引用自一个对象 |
x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False |
is not |
is not 是判断两个标识符是不是引用自不同对象 |
x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。 |
注: id() 函数用于获取对象内存地址。
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符:
运算符 |
描述 |
** |
指数 (最高优先级) |
~ + - |
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // |
乘,除,取模和取整除 |
+ - |
加法减法 |
>> << |
右移,左移运算符 |
& |
位 'AND' |
^ | |
位运算符 |
<= < > >= |
比较运算符 |
<> == != |
等于运算符 |
= %= /= //= -= += *= **= |
赋值运算符 |
is is not |
身份运算符 |
in not in |
成员运算符 |
and or not |
逻辑运算符 |
Python中if语句的一般形式如下所示:
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
注意:
- 1、每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语句块。
- 2、使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。
- 3、在Python中没有switch – case语句。
Python中while语句的一般形式:
while 判断条件:
语句
同样需要注意冒号和缩进。另外,在Python中没有do..while循环。
可以使用 CTRL+C 来退出当前的无限循环。
在 while … else 在条件语句为 false 时执行 else 的语句块
Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串。
for循环的一般格式如下:
for <variable> in <sequence>:
<statements>
else:
<statements>
break 语句用于跳出当前循环体,循环语句可以有 else 子句,它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
如果你需要遍历数字序列,可以使用内置range()函数。它会生成数列,例如:
for i in range(5):
print(i)
你也可以使用range指定区间的值range(5,9),也可以使range以指定数字开始并指定不同的增量(甚至可以是负数,有时这也叫做'步长')range(0, 10, 3)
您可以结合range()和len()函数以遍历一个序列的索引range(len(a))
还可以使用range()函数来创建一个列表list(range(5))
Python pass是空语句,是为了保持程序结构的完整性。pass 不做任何事情,一般用做占位语句,
迭代器
迭代是Python最强大的功能之一,是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法:iter() 和 next()。
字符串,列表或元组对象都可用于创建迭代器:it = iter(list)
迭代器对象可以使用常规for语句进行遍历:for x in it:也可以使用 next() 函数:next(it)
创建一个迭代器
把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
__iter__() 方法返回一个特殊的迭代器对象, 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
__next__() 方法(Python 2 里是 next())会返回下一个迭代器对象。
创建一个返回数字的迭代器,初始值为 1,逐步递增 1:
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
StopIteration 异常用于标识迭代的完成,防止出现无限循环的情况,在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。raise StopIteration
生成器
在 Python 中,使用了 yield 的函数被称为生成器(generator)。
跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数,返回的是一个迭代器对象。
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
- 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始,并且缩进。
- return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
python 函数的参数传递:
不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响
加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。
声明函数时,参数中星号 * 可以单独出现,如果单独出现星号 * 后的参数必须用关键字传入。
加了两个星号 ** 的参数会以字典的形式导入。
匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
- lambda 只是一个表达式,函数体比 def 简单很多。
- lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda 函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda arg1, arg2: arg1 + arg2
msg 变量定义在 if 语句块中,但外部还是可以访问的。如果将 msg 定义在函数中,则它就是局部变量,外部不能访问,定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了。如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要 nonlocal 关键字了
列表方法使得列表可以很方便的作为一个堆栈来使用,堆栈作为特定的数据结构,最先进入的元素最后一个被释放(后进先出)。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。
元组在输出时总是有括号的,以便于正确表达嵌套结构。在输入时可能有或没有括号, 不过括号通常是必须的(如果元组是更大的表达式的一部分)。
在字典中遍历时,关键字和对应的值可以使用 items() 方法同时解读出来:
for k, v in knights.items():
在序列中遍历时,索引位置和对应值可以使用 enumerate() 函数同时得到:
for i, v in enumerate(['tic', 'tac', 'toe']):
同时遍历两个或更多的序列,可以使用 zip() 组合:
for q, a in zip(questions, answers):
要反向遍历一个序列,首先指定这个序列,然后调用 reversed() 函数:
for i in reversed(range(1, 10, 2)):
要按顺序遍历一个序列,使用 sorted() 函数返回一个已排序的序列,并不修改原值:
for f in sorted(set(basket)):
输出格式美化
如果你希望输出的形式更加多样,可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串,可以使用 repr() 或 str() 函数来实现。
- str(): 函数返回一个用户易读的表达形式。
- repr(): 产生一个解释器易读的表达形式。
字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。
还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。
另一个方法 zfill(), 它会在数字的左边填充 0
括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。在括号中的数字用于指向传入对象在 format() 中的位置,如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
'!a' (使用 ascii()), '!s' (使用 str()) 和 '!r' (使用 repr()) 可以用于在格式化某个值之前对其进行转化
可选项 ':' 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 在 ':' 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。
如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值
% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串
因为 str.format() 比较新的函数, 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().
Python提供了 input() 内置函数从标准输入读入一行文本,默认的标准输入是键盘。
input 可以接收一个Python表达式作为输入,并将运算结果返回。
读和写文件
open() 将会返回一个 file 对象,基本语法格式如下:
open(filename, mode)
- filename:包含了你要访问的文件名称的字符串值。
- mode:决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读(r)。
不同模式打开文件的完全列表:
模式 |
描述 |
r |
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
rb |
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。 |
r+ |
打开一个文件用于读写。文件指针将会放在文件的开头。 |
rb+ |
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
w |
打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb |
以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
w+ |
打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb+ |
以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
a |
打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
ab |
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
a+ |
打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。 |
ab+ |
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。 |
文件对象的方法
本节中剩下的例子假设已经创建了一个称为 f 的文件对象。
f.read()
为了读取一个文件的内容,调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
f.readline()
f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
f.readlines()
f.readlines() 将返回该文件中包含的所有行。
如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
f.write()
f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
f.tell()
f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
f.seek()
如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。
from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾,例如:
- seek(x,0) : 从起始位置即文件首行首字符开始移动 x 个字符
- seek(x,1) : 表示从当前位置往后移动x个字符
- seek(-x,2):表示从文件的结尾往前移动x个字符
from_what 值为默认为0,即文件开头。
f.close()
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源,如果尝试再调用该文件,则会抛出异常。
当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短
open() 方法
Python open() 方法用于打开一个文件,并返回文件对象,在对文件进行处理过程都需要使用到这个函数,如果该文件无法被打开,会抛出 OSError。
注意:使用 open() 方法一定要保证关闭文件对象,即调用 close() 方法。
open() 函数常用形式是接收两个参数:文件名(file)和模式(mode)。
完整的语法格式为:
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明:
- file: 必需,文件路径(相对或者绝对路径)。
- mode: 可选,文件打开模式
- buffering: 设置缓冲
- encoding: 一般使用utf8
- errors: 报错级别
- newline: 区分换行符
- closefd: 传入的file参数类型
- opener:
mode 参数有:
模式 |
描述 |
t |
文本模式 (默认)。 |
x |
写模式,新建一个文件,如果该文件已存在则会报错。 |
b |
二进制模式。 |
+ |
打开一个文件进行更新(可读可写)。 |
U |
通用换行模式(不推荐)。 |
r |
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
rb |
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
r+ |
打开一个文件用于读写。文件指针将会放在文件的开头。 |
rb+ |
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
w |
打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb |
以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。 |
w+ |
打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb+ |
以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。 |
a |
打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
ab |
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
a+ |
打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。 |
ab+ |
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。 |
默认为文本模式,如果要以二进制模式打开,加上 b 。
file 对象
file 对象使用 open 函数来创建,下表列出了 file 对象常用的函数:
序号 |
方法及描述 |
1 |
关闭文件。关闭后文件不能再进行读写操作。 |
2 |
刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 |
3 |
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。 |
4 |
如果文件连接到一个终端设备返回 True,否则返回 False。 |
5 |
返回文件下一行。 |
6 |
从文件读取指定的字节数,如果未给定或为负则读取所有。 |
7 |
读取整行,包括 "\n" 字符。 |
8 |
读取所有行并返回列表,若给定sizeint>0,返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。 |
9 |
设置文件当前位置 |
10 |
返回文件当前位置。 |
11 |
从文件的首行首字符开始截断,截断文件为 size 个字符,无 size 表示从当前位置截断;截断之后后面的所有字符被删除,其中 Widnows 系统下的换行代表2个字符大小。 |
12 |
将字符串写入文件,返回的是写入的字符长度。 |
13 |
向文件写入一个序列字符串列表,如果需要换行则要自己加入每行的换行符。 |
语法错误
Python 的语法错误或者称之为解析错,是初学者经常碰到的
SyntaxError: invalid syntax
异常处理
try语句按照如下方式工作;
- 首先,执行try子句(在关键字try和关键字except之间的语句)
- 如果没有异常发生,忽略except子句,try子句执行后结束。
- 如果在执行try子句的过程中发生了异常,那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符,那么对应的except子句将被执行。最后执行 try 语句之后的代码。
- 如果一个异常没有与任何的except匹配,那么这个异常将会传递给上层的try中。
一个 try 语句可能包含多个except子句,分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的try子句中的异常进行处理,而不是其他的 try 的处理程序中的异常。
一个except子句可以同时处理多个异常,这些异常将被放在一个括号里成为一个元组
最后一个except子句可以忽略异常的名称,它将被当作通配符使用。你可以使用这种方法打印一个错误信息,然后再次把异常抛出。
try except 语句还有一个可选的else子句,如果使用这个子句,那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。
使用 else 子句比把所有的语句都放在 try 子句里面要好,这样可以避免一些意想不到的、而except又没有捕获的异常。
异常处理并不仅仅处理那些直接发生在try子句中的异常,而且还能处理子句中调用的函数(甚至间接调用的函数)里抛出的异常。
抛出异常
Python 使用 raise 语句抛出一个指定的异常。
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类(也就是 Exception 的子类)。
如果你只想知道这是否抛出了一个异常,并不想去处理它,那么一个简单的 raise 语句就可以再次把它抛出。
类定义
语法格式如下:
class ClassName: <statement-1> . . . <statement-N>
类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性。
类对象
类对象支持两种操作:属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法:obj.name。
类有一个名为 __init__() 的特殊方法(构造方法),该方法在类实例化时会自动调用,当然, __init__() 方法可以有参数,参数通过 __init__() 传递到类的实例化操作上。
self代表类的实例,而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。self 不是 python 关键字,我们把他换成 runoob 也是可以正常执行的
在类的内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self, 且为第一个参数,self 代表的是类的实例。
继承
Python 同样支持类的继承,如果一种语言不支持继承,类就没有什么意义。派生类的定义如下所示:
class DerivedClassName(BaseClassName1): <statement-1> . . . <statement-N>
需要注意圆括号中基类的顺序,若是基类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时,从左到右查找基类中是否包含方法。
BaseClassName(示例中的基类名)必须与派生类定义在一个作用域内。除了类,还可以用表达式,基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):
多继承
Python同样有限的支持多继承形式。多继承的类定义形如下例:
class DerivedClassName(Base1, Base2, Base3): <statement-1> . . . <statement-N>
需要注意圆括号中父类的顺序,若是父类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时,从左到右查找父类中是否包含方法。
方法重写
如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法,super() 函数是用于调用父类(超类)的一个方法。
类属性与方法
类的私有属性
__private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类地内部,使用 def 关键字来定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数,self 代表的是类的实例。
self 的名字并不是规定死的,也可以使用 this,但是最好还是按照约定是用 self。
类的私有方法
__private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,不能在类地外部调用。self.__private_methods。
类的专有方法:
- __init__ : 构造函数,在生成对象时调用
- __del__ : 析构函数,释放对象时使用
- __repr__ : 打印,转换
- __setitem__ : 按照索引赋值
- __getitem__: 按照索引获取值
- __len__: 获得长度
- __cmp__: 比较运算
- __call__: 函数调用
- __add__: 加运算
- __sub__: 减运算
- __mul__: 乘运算
- __div__: 除运算
- __mod__: 求余运算
- __pow__: 乘方
运算符重载
Python同样支持运算符重载,我们可以对类的专有方法进行重载