Python笔记

Python笔记

基本数据类型

概述

Numbers 数值类型主要分为 整型-int 浮点型-float 复数类型complex 字符串类型-string 布尔类型-bool 容器类型-list 字典类型-dictionary

面向对象语言：所有的基本数据类型都是类：对数据进行了封装，具备对数据进行工作的已经封装在该数据类中的函数。

函数：function 普通函数

方法：method 封装在类中的函数

所有变量不需要声明，可以直接使用

Python对变量名和常量名均区分大小写

运算符号

运算符号：+ - * / // %

// : 整除 / : 除法 % : 求余 复数：a + bj

#IPYTHON的terminal操作窗口结果
In [3]: 7 // 2
Out[3]: 3
# 整除
In [4]: 7 / 2
Out[4]: 3.5
# 除法
In [5]: 123.34 % 1.2
Out[5]: 0.9400000000000079
# 取余 （此时存在深入误差）
In [6]: x = 123.45 * 2.3
In [7]: eps = 1e-6
In [8]: eps
Out[8]: 1e-06
# 将变量eps取值为1的负6次方
In [9]: y = 123.45 + 123.45 + 123.45 * 0.3
In [10]: abs(x - y) < eps
Out[10]: True
# abs为Python内置函数，对数据取绝对值
In [12]: 486464646464565555555555*1000084499942544
Out[12]: 486505752699241498617731365837500031920
# Python可以计算较大的数字（仅仅受限于64位的字长）
In [15]: x * y
Out[15]: (18-1j)
In [16]: x / y
Out[16]: (0.24+0.68j)
In [17]: x + y
Out[17]: (7-1j)
#复数运算

字符串概述

#IPYTHON的terminal操作窗口结果
In [18]: s = 'abc'
In [19]: s
Out[19]: 'abc'
In [20]: s = "abc"
In [21]: s
Out[21]: 'abc'
# 字符串中单引号与双引号效果相同
In [23]: s = """abc"""
In [24]: s
Out[24]: 'abc'
In [25]: s = """abc\ndef"""
In [26]: s
Out[26]: 'abc\ndef'
In [28]: s = """abc
    ...: def"""
In [29]: s
Out[29]: 'abc\ndef'
# 三个引号的用法，三引号通常的程序的开始写大段的注释，写明程序功能，末尾写明作者、属性等等

Python编码

ASCII码，每个字符占据一个字节，0-127 共128个字符位ASCII码字符，而128-255不足以表达各种其他语言的字符

GB2312编码（GB：国标）：ASCII码仅仅一个字节8位，其最高位为0（共127个），中文字符为2个字节，每个字节的首位均为1

由于GB2312不太全，后来提出了GB18030，但是使用范围不广，现在Windows使用了GBK中文编码。港澳台对繁体中文采用BIG5编码，在制定过程中与国标编码未进行匹配，无法一对一转换，当年需要一些转码工具才能正确转换繁体与简体。过去的乱码有时候就是因为编码不兼容。

CJKY（中国、日本、朝鲜、越南），多用方块字形，但是编码复杂多样。UNICODE统一了语言编码。

GBK编码中汉字字符占据两个字节，ASCII码字符占据一字节，对中文字符长度规定为2

Python中字符串的默认编码为UNICODE，对单个中文字符长度规定为1

UNICODE中：

• UTF16 ：所有字符全部使用16位二进制位，中文字符16位全用，ASCII码使用16位(前8位为0，后8位起作用)

• UTF8 ：ASCII码占据一个字节，中文字符占据2-3个字节（Python3.x)

  类型转化

字符串与整型不能直接相加，需要将字符串转化为数据类型

类型转化函数： int（） str（） float（）bool（）

将字符串转化为布尔类型，只有空字符串为 False

将数据转化为布尔类型，0 为 False

In [31]: s = "12345"
In [33]: s = s + "65"
# + 字符串拼接
In [34]: s
Out[34]: '1234565'
In [35]: s + 65
---------------------------------------------------------------------

TypeError                           Traceback (most recent call last)

Input In [35], in <cell line: 1>()
----> 1 s + 65
TypeError: can only concatenate str (not "int") to str
# 字符串与整型 不能直接相加
In [36]: 12 + int("3434")
Out[36]: 3446
In [37]: float("34")
Out[37]: 34.0
# 转化为浮点型
In [38]: bool('True')
Out[38]: True
In [39]: bool('ddfa')
Out[39]: True
In [40]: bool('')
Out[40]: False
# 空串转化为布尔类型为FALSE
In [41]: bool(1)
Out[41]: True
In [42]: bool(0)
Out[42]: False
# 0转化为布尔类型为FALSE
In [43]: bool(1.6899)
Out[43]: True
In [44]: s = s + str(22)
In [45]: s
Out[45]: '123456522'
#数据转化为字符串类型并拼接
In [46]: int(s)
Out[46]: 123456522

相等判断

相等判断：1、是否同值 2、是否是同一个东西

Python中所有的变量所保存的都是一个引用

所以说Python中没有指针，因为一切都是指针，这里的名字叫做引用

由于Python的机制为引用 ，所以可以让变量A历次引用整型、浮点型、布尔型、字符型等等任意数据类型的对象，只需要保存 id 到 变量A，即可以把不同数据类型赋给 变量（查看变量的内置函数id()可以确定不同变量是否为同一对象的引用）

In [47]: isinstance(s,int)。
Out[47]: False
In [48]: isinstance(s,str)
Out[48]: True
# 判断变量类型
In [50]: 2 + 1 == 3
Out[50]: True
In [51]: s1 = "Hello"
In [52]: s2 = "Hello"
In [53]: s1 == s2
Out[53]: True
# 判断值相等
In [54]: s1 is s2
Out[54]: True
# 判断s1与s2是否引用同一对象
In [55]: x = 1
In [56]: y = x  ## 
In [57]: y
Out[57]: 1
In [58]: x is y
Out[58]: True
In [59]: x == y
Out[59]: True
# x 与 y 同时引用 数据 1
In [60]: x = 1
In [61]: y = 1
In [62]: x is y
Out[62]: True
In [63]: x == y
Out[63]: True
# Python中，由于第一次已经创建了常量 1 并将其引用赋给 x 
# 第二次需要执行y = 1的时候不再重新创建 数据 1 而是直接将 数据 1 的引用再赋给 y
In [81]: id(x)
Out[81]: 1979748935984
In [82]: id(y)
Out[82]: 1979748935984
# 内置函数id()，查看编号，标号相同为同一引用
In [64]: y = 2
In [65]: x is y
Out[65]: False
In [66]: x == y
Out[66]: False
# 创建 常量 2 ，其引用赋给 y
# x 与 y 不再相同

序列类型

List 列表

元素的个数可以直接添加扩充，不论元素类型

In [1]: x = [1,2,3]
In [2]: type(x)
Out[2]: list
In [3]: x.append(4)
In [4]: x
Out[4]: [1, 2, 3, 4]
In [5]: x.append(5)
In [6]: x
Out[6]: [1, 2, 3, 4, 5]

创建三个数据 1、2、3

创建一个线性表 X，三个元素分别为数据1-3的引用

In [9]: x = [1,2,3,2]
In [10]: x[1] is x[3]
Out[10]: True #三个元素均为引用

in 与 not in

In [11]: x
Out[11]: [1, 2, 3, 2]
In [12]: 1 in x
Out[12]: True
In [13]: 4 not in x
Out[13]: True
In [14]: [1,2] in x #拿列表[1,2]与列表[1,2,3,2]的每一个元素相比较
Out[14]: False

list列表中可以存放不同类型数据。

因为列表的元素指向对应的数据对象，所以可以存放不同类型数据

In [19]: x
Out[19]: [1, 2, 3, 2]
In [20]: y
Out[20]: ['abc', 'def']
In [21]: t = x + y
In [22]: t
Out[22]: [1, 2, 3, 2, 'abc', 'def']

当某个列表元素不再引用原数据，且原数据现在无任何元素引用它时，自动将该数据从内存中释放，释放的时机由python决定（GC机制，garbage collection）

直接 * 乘法，扩大两倍

List列表的元素中保存的是数据元素的ID

In [25]: t
Out[25]: [1, 2, 3, 2, 'abc', 'def']
In [26]: z = t * 2
In [27]: z
Out[27]: [1, 2, 3, 2, 'abc', 'def', 1, 2, 3, 2, 'abc', 'def']
In [28]: z[0] is z[6]
Out[28]: True
In [29]: z[5] is z[11]
Out[29]: True
In [30]: In [30]: id(z[0])
Out[30]: 2535134030128
In [31]: id(z[6])
Out[31]: 2535134030128

##### 空列表
In [34]: x
Out[34]: [[]]
In [35]: y = []
In [36]: y.append(1)
In [37]: y
Out[37]: [1]
In [38]: x[0] = [1,2,3,"dddd"]
In [39]: x
Out[39]: [[1, 2, 3, 'dddd']]

##### 引用机制
In [50]: x = [[]]
In [51]: x = x * 3
In [52]: x
Out[52]: [[], [], []]
# 三个元素引用同一个[]，其id全部相同
In [53]: x[1].append("中国")
In [54]: x
Out[54]: [['中国'], ['中国'], ['中国']]
# 所以当对空列表加数据的时候，三个同时加数据

# 只对其中一个添加数据，直接对X赋值三个空列表，其id各不相同
In [55]: x = [[],[],[]]
In [56]: x[1].append("中国")
In [57]: x
Out[57]: [[], ['中国'], []]
In [58]: id(x[0])
Out[58]: 2535203227392
In [59]: id(x[2])
Out[59]: 2535234990720
In [60]: id(x[1])
Out[60]: 2535235811712

#### 下标从-1开始倒着访问数据
In [61]: x = [1,2,3,4]
In [62]: x[-1]
Out[62]: 4
In [63]: x[-2]
Out[63]: 3

#### 切片运算是构造了新列表，对原始列表不产生影响
In [64]: t = x[1:3]
In [65]: t
Out[65]: [2, 3]
In [67]: t[1] = 4
In [68]: x
Out[68]: [1, 2, 3, 4]
In [69]: t
Out[69]: [2, 4]

#### 规定步长切片
In [70]: x[0:4:1]
Out[70]: [1, 2, 3, 4]
In [71]: x[0:4:2]
Out[71]: [1, 3]

# 全为数据元素的时候的简单计算函数，如果其中存在其他数据类型，不可比较的时候报错
In [72]: min(x)
Out[72]: 1
In [73]: max(x)
Out[73]: 4
In [74]: sum(x)
Out[74]: 10
In [75]: x.index(3) # 根据数据找索引
Out[75]: 2
### 关于索引
In [82]: x = ['abc','abc','abc']
In [83]: x[2] is x[0]
Out[83]: True
In [84]: id(x[2]) == id (x[1])
Out[84]: True
In [85]: x.count('abc')
Out[85]: 3
In [86]: x.index('abc')
Out[86]: 0

Tuple 元组

In [87]: x = (1,2,3)
In [88]: y = ["abc","bcd",12,45]
In [89]: y = tuple(y)
In [90]: y
Out[90]: ('abc', 'bcd', 12, 45)

如果引用的是只读对象，则元组中的元素不可变

In [104]: y = (1,2,3)

In [105]: y[0] = 5
---------------------------------------------------------------------

TypeError                           Traceback (most recent call last)

Input In [105], in <cell line: 1>()
----> 1 y[0] = 5

TypeError: 'tuple' object does not support item assignment

如果元组中的元素指向的是可写的对象，则其可变

In [95]: x1
Out[95]: [1, 2]
In [96]: x2
Out[96]: [2, 3]
In [97]: x3
Out[97]: [5, 6]
In [98]: x = [x1,x2,x3]
In [99]: x
Out[99]: [[1, 2], [2, 3], [5, 6]]
#### 
In [100]: x = tuple(x)
In [101]: x
Out[101]: ([1, 2], [2, 3], [5, 6])
In [102]: x[0].append('ddd')
In [103]: x
Out[103]: ([1, 2, 'ddd'], [2, 3], [5, 6])

字符串类型

字符串类型只能读取，不能重新写入

In [1]: "I'm batman"
Out[1]: "I'm batman"
#### 双引号做界定的时候，字符串之中可以使用单引号
In [3]: "\'"
Out[3]: "'"
In [4]: "I\'m batman"
Out[4]: "I'm batman"
####
In [3]: "\'"
Out[3]: "'"
In [4]: "I\'m batman"
Out[4]: "I'm batman"

In [5]: print("\\")
\
In [7]: print("\\t")
\t

#### 前面加 r 则不再对\当做转义字符 
In [9]: print(r"d:\dir\a.txt")
d:\dir\a.txt 

允许字符串之间直接使用 + 拼接，但是不允许字符串与数字拼接，如要拼接，需先使用str函数将数字转换为字符串

由于字符串类型为只读类型，所以用 + 拼接的时候，创建了新字符串（新拼接的），然后旧的两个或者多个串，如果没有再被其他变量引用的话，将会被垃圾回收机制在某个时间回收（GC机制 garbage collection）

所有能生成新字符串的函数都会创建一个新对象

In [10]: 'abc' + 12
-------------------------------------------------

TypeError       Traceback (most recent call last)

Input In [10], in <cell line: 1>()
----> 1 'abc' + 12

TypeError: can only concatenate str (not "int") t
o str

In [11]: 'abc' + str(12)
Out[11]: 'abc12'

% 格式化字符串

In [14]: pattern  = "%s is %d years old."
In [15]: name = "Mike"
In [16]: age = 12
In [17]: msg = pattern % (name,age)
In [19]: msg
Out[19]: 'Mike is 12 years old.'

#### 10s 从Mike前面补足10位
In [20]: pattern  = "%10s is %d years old."
In [21]: msg = pattern % (name,age)
In [22]: msg
Out[22]: '      Mike is 12 years old.'

#### -10s 从Mike后面补足10位
In [23]: pattern  = "%-10s is %d years old."
In [24]: msg = pattern % (name,age)
In [25]: msg
Out[25]: 'Mike       is 12 years old.'

" ", format( , ,) format之中为一组参数

In [26]: pattern = "{:4d} + {:-4d} = {:5.3f}" 
#### 此时+-4都一样，在数字前补足位数
#### 5.3f 共5位，小数点后3位
In [27]: msg = pattern.format(12,24,12+24)
In [28]: msg
Out[28]: '  12 +   24 = 36.000'

In [29]: pattern = "{:1d} + {:0d} = {:2d}"
In [30]: msg = pattern.format(1,9,10)
In [31]: msg
Out[31]: '1 + 9 = 10'
#### 1d 与 0d 的效果相同
In [32]: pattern = "{:1d} + {:1d} = {:2d}"
In [33]: msg = pattern.format(1,9,10)
In [34]: msg
Out[34]: '1 + 9 = 10'

#### * 运算
In [35]: "hello" * 3
Out[35]: 'hellohellohello'

f ’ {变量名} , {} … ’

In [36]: age = 12
In [37]: name = "Mike"
In [38]: f'{name} is {age} years old'
Out[38]: 'Mike is 12 years old'

结构控制语句

IF 语句

多条语句保持相同缩进，包含在同一IF中，尽量减少函数中代码量的长度，提高可读性

In [43]: score = int(input('Plz input score: '))
    ...: 
Plz input score: 60

In [44]: if score >= 60:
    ...:     print('OK')
    ...: 
OK

回车+换行	CRLF \r\n	这两个ACSII字符不会在屏幕有任何输出，但在Windows中广泛使用来标识一行的结束。而在Linux/UNIX系统中只有换行符。
换行	LF \n	代表一行文本的结束unix and macos
回车	CR \r	将光标移动到当前行的开头

else 、 if 、 elif

In [47]: score = int(input('Plz input score: '))
    ...: 
Plz input score: 55

In [48]: if score >= 60:
    ...:     print('pass')
    ...: elif score < 50:
    ...:     print('fail')
    ...: else:
    ...:     print('D')
    ...: 
D

与、或、非 ：and、for、 not

in 、notin、is、 isnot

==== 比较值； is 比较是非为同一对象==

由于存在舍入误差，所以不要对浮点数进行 == 比较

While 语句

In [51]: idx = 0
In [52]: while idx < len(scores):
    ...:     if scores[idx] >= 60:
    ...:         print('Pass')
    ...:     else:
    ...:         print('Fail')
    ...:     idx += 1
    ...: 
Pass
Pass
Pass
Fail
Fail

for循环

对于集合对象，C语言中采用下标访问（数组）

而如果集合对象为链表，则无法使用下标表示；如果为哈希表，数据离散存储，则无法使用下标表示；

如果集合对象为树形数据结构，使用左子树优先可以进行先序遍历，但是依然没有下标（此时考虑一般树，完全二叉树有规律所以可以使用下标访问）

所以在Python中使用迭代器 iterator : 1、判断当前集合中还有无未访问元素；2、给出 next ，下一个可访问元素

Python中for循环为集合对象实现了迭代器

Ctrl + \ 对选中代码集体注释（Pycharm中）

In [49]: scores = [78,66,93,45,34]

In [50]: for score in scores:
    ...:     if score >= 60:
    ...:         print('Pass')
    ...:     else:
    ...:         print('Fail')
    ...: 
Pass
Pass
Pass
Fail
Fail

Range 生成范围的迭代 range(start, stop, step)

#### range(stop)
In [54]: for i in range(10):
    ...:     print(i)
    ...: 
0
1
2
3
4
5
6
7
8
9
#### range(start,stop,step)
In [55]: for i in range(3,0,-1):
    ...:     print(i)
    ...: 
3
2
1
#### 到 从start开始，到 stop 的前一个元素结束 ，步长为+向右，步长为-向左
In [56]: for i in range(3,-1,-1):
    ...:     print(i)
    ...: 
3
2
1
0
#### 同时取得下标与数据 enumerate() 将会把索引与对应值打包成一个元组
In [57]: scores = [78,66,93,45,34]

In [58]: for score in enumerate(scores):
    ...:     print(score)
    ...: 
(0, 78)
(1, 66)
(2, 93)
(3, 45)
(4, 34)
#### 其中score[0]为索引值， score[1]为该索引对应的数据
In [59]: for score in enumerate(scores):
    ...:     print("idx: ", score[0],"value: ",s
    ...: core[1])
    ...: 
idx:  0 value:  78
idx:  1 value:  66
idx:  2 value:  93
idx:  3 value:  45
idx:  4 value:  34
#### 元组的小tips
In [60]: x = (1,2)
In [61]: a,b = x
In [62]: a
Out[62]: 1
In [63]: b
Out[63]: 2
#### 利用元组的性质；enumerate(列表，数字X) 所有索引的值全部 +X
In [64]: for idx,score in enumerate(scores,2):
    ...:     print("idx: ", idx,"value: ",score)
    ...: 
    ...: 
idx:  2 value:  78
idx:  3 value:  66
idx:  4 value:  93
idx:  5 value:  45
idx:  6 value:  34
#### zip “拉链”，将数据对应起来；两组数据个数不同，依照个数少的一方一一对应
In [65]: scores = [78,66,93,45,34]
In [66]: names = ["Alice","Clark","D","Ellen"]
In [67]: for name,score in zip(names,scores):
    ...:     print(name,score)
    ...: 
Alice 78
Clark 66
D 93
Ellen 45

字典

键值对 key — value 对列表中的数据集，进行某种查询。用key作为查询依据（关键字）来查询对应值的数据

现在构建姓名与成绩的键值对（字典）

字典用花括号创建

In [68]: scores = {'Mike':78,'Jack':50}
In [69]: len(scores)
Out[69]: 2
In [70]: scores["Jack"]
Out[70]: 50
In [71]: scores["Mike"]
Out[71]: 78
In [72]: scores["Bob"]
-------------------------------------------------

KeyError        Traceback (most recent call last)

Input In [72], in <cell line: 1>()
----> 1 scores["Bob"]

KeyError: 'Bob'

#### get方法
In [78]: x = scores.get('Mike')
In [79]: x
Out[79]: 78
In [80]: x = scores.get('Bob')
In [81]: print(x)
None
#### 如果没有该key，则返回空引用给x
In [82]: x = scores.get('Bob',80)
In [83]: print(x)
80
#### 如果没有该key，则返回指定的默认值给x，不影响原字典的数据
In [84]: scores
Out[84]: {'Mike': 78, 'Jack': 50}

#### 
In [94]: scores
Out[94]: {'Jack': 50, 'Mike': 100}
#### del删除
In [95]: del scores['Mike']
In [96]: scores
Out[96]: {'Jack': 50}
#### 直接添加
In [97]: scores["Mike"] = 90
In [98]: scores
Out[98]: {'Jack': 50, 'Mike': 90}
#### items返回键值对组成的新视图
In [100]: scores.items()
Out[100]: dict_items([('Jack', 50), ('Mike', 90)]
)
#### 返回字典键组成的新视图
In [101]: scores.keys()
Out[101]: dict_keys(['Jack', 'Mike'])
#### 验证items键值对
In [102]: for name,score in scores.items():
     ...:     print(name,score)
     ...: 
Jack 50
Mike 90
#### 验证keys键
In [103]: for name in scores.keys():
     ...:     print(name)
     ...: 
Jack
Mike
#### list()将字典转换为列表
In [104]: scores = list(scores)
In [105]: scores
Out[105]: ['Jack', 'Mike']

函数

def 函数名( 参数 ) :

​ 缩进

​ 缩进

#### 极简HelloWorld函数
In [106]: def foobar():
     ...:     print("Helloworld")
In [107]: foobar()
Helloworld

#### 函数参数为列表
In [108]: def foobar(x):
     ...:     x[1] = 100 
In [109]: x = [1,2,3]
In [110]: foobar(x)
In [111]: print(x)
[1, 100, 3]
#### 函数参数为整数
In [119]: x = 100
In [120]: def foobar(x):
     ...:     x = 20
     ...:     print(x)
     ...:     return x
In [121]: y = foobar(x)
20
In [122]: x
Out[122]: 100
#### x 没有变动

In [128]: def foobar(x):
     ...:     return x ** 2 + 3 * x - 2
    #### x ** 2 x的二次方
In [129]: y = foobar(x)
In [130]: y
Out[130]: 10298



In [144]: def foobar(x,y,*args):
     ...:     print(x,y,args)
     ...: 
#### 参数长度任意，有命名的参数例外，剩余的元素打成一个元组
In [145]: foobar(1,2,'hello',39.8,False)
1 2 ('hello', 39.8, False)


In [146]: def foobar(x,y,*args,**kwargs):
     ...:     print(args)
     ...:     print(kwargs)
#### 不带参数名的传递，args（可以自取名字，不比拘泥于args的拼写）打包成元组
#### 带参数名的传递，打包成字典格式
In [147]: foobar(1,2,'hello',39.8,False, arg1 = 23,arg2 = 32)
('hello', 39.8, False)
{'arg1': 23, 'arg2': 32}

#### 皆为对象，函数也是对象，可以被变量所引用（注意这里不是调用）
In [148]: def f(x):
     ...:     return 3 * x ** 2 + 2 * x - 5
In [149]: y = f
In [150]: print(type(y))
<class 'function'>
In [151]: print(y(1.0))
0.0
In [152]: print(type(y(1.0)),type(y(1)))
<class 'float'> <class 'int'>
#### 函数名是对函数对象的引用；计算3x^2 + 2x - 5这个函数在x = 1的位置的差分（微分）
In [153]: def diff(x,func) :
     ...:     delta = 1e-6
     ...:     return (func(x+ delta) - func(x)) / delta
In [154]: print(diff(1,f))
8.000002999608569


In [157]: def f2(x):
     ...:     return x**2
In [158]: def f3(x):
     ...:     return x**3
In [159]: def f4(x):
     ...:     return x**4
In [160]: funs = [f2,f3,f4]
#### 函数对象可以加入到集合对象funs中，被遍历访问
In [161]: for f in funs:
     ...:     print(f(5))
25
125
625


#### 嵌套函数（关于函数闭包的概念）
In [163]: def fun1(x):
     ...:     def fun2 (y):
     ...:         return x + y
     ...:     return fun2
#### fun2中可以访问到fun1的x
In [164]: a = fun1(3)
In [165]: type(a)
Out[165]: function
####  a为函数的引用
In [166]: a(5)
Out[166]: 8
In [167]: fun1(3)(15)
Out[167]: 18


#### 临时定义函数可以使用lambda表达式
def diff(x,func) :
     ...:     delta = 1e-6
     ...:     return (func(x+ delta) - func(x)) / delta
#### func作为函数对象
In [169]: diff(2,lambda x : 2 * x ** 2 + 3)
Out[169]: 8.000002001296025
In [170]: diff(2,lambda y : 2 * x ** 2 + 3)
Out[170]: 0.0
In [171]: diff(2,lambda y : 2 * y ** 2 + 3)
Out[171]: 8.000002001296025
#### x对应x , y对应y

异常

语法错误 ：编译器反馈存在语法错误

语义错误 ：执行的时候可能代码实现与原本设计存在差异 通过调试器观察，代码执行结果与预期结果的过程与结果的差异

运行时错误 ： 代码执行的时候出现的错误，比如打开文件时缺少读写权限或者该文件不存在；代码要求输入数据格式与执行者所输入的不同；执行者执行除以零的操作等等 要提前设置异常的捕获，防止程序崩溃

In [173]: try:
     ...:     x = float("abc")
     ...: except:
     ...:     print("Can not convert.")
     ...: 
Can not convert.
#### 自主处理异常，不再给python解释器处理

In [174]: try:
     ...:     x = float("abc")
     ...: except Exception as e:
     ...:    print(e.args)
     ...: 
("could not convert string to float: 'abc'",)

#### 发生异常
In [175]: try:
     ...:     x = float("abc")
     ...: except Exception as e:
     ...:     print(e.args)
     ...: finally:
     ...:     x = 0
     ...: print(x)
("could not convert string to float: 'abc'",)
0
#### 不发生异常；
#### finally无论是否发生异常都会执行
In [176]: try:
     ...:     x = float("1.2")
     ...: except Exception as e:
     ...:     print(e.args)
     ...: finally:
     ...:     x = 0
     ...: print(x)
0

try 可以跟多个except子句，如果首个except为 except Exception as e : 则后面的的所有异常都不会被触发，因为Exception为其他所有异常的父类

不过它可以放到最后一个except

#### 顺序执行exception
In [177]: try:
     ...:     x = float("dsfsd")
     ...: except ValueError as e:
     ...:     x = 0
     ...: except FileNotFoundError as e:
     ...:     pass
In [178]: x
Out[178]: 0
#### 顺序执行exception
In [179]: try:
     ...:     x = float("dsfsd")
     ...: except ValueError as e:
     ...:     x = 0
     ...: except FileNotFoundError as e:
     ...:     print("File not found")
     ...: except Exception as e:
     ...:     pass
     ...: 
In [180]: x
Out[180]: 0
#### 首个except为 except Exception as e :
In [181]: try:
     ...:     x = float("dsfsd")
     ...: except Exception as e:
     ...:     x = 15
     ...:     pass
     ...: except ValueError as e:
     ...:     x = 35
     ...: 
In [182]: x
Out[182]: 15

In [183]: def askUser():
     ...:     while True:
     ...:         try:
     ...:             x = float(input("plz inpout a floating number:
     ...:  "))
     ...:             return x
     ...:         except ValueError as e:
     ...:             print("Errors: " + e.args[0])
#### 如果x的赋值语句报错为valueError，则直接执行except部分代码，然后重新开始循环
#### 当x的赋值语句不报错的时候，返回x的值，然后退出循环
In [184]: askUser()
plz inpout a floating number: abc
Errors: could not convert string to float: 'abc'
plz inpout a floating number: dlaja;
Errors: could not convert string to float: 'dlaja;'
plz inpout a floating number: jfoaf;af
Errors: could not convert string to float: 'jfoaf;af'

plz inpout a floating number: 15
Out[184]: 15.0

文件处理

通常会使用 try except 的语句进行处理，来防范异常

In [206]: f = open('test.txt','r',encoding = 'utf-8')

In [207]: lines = f.readlines()

In [208]: print(lines)
['  大酒店剧烈的了解到了大家都来觉得觉得京东快递京东快递看到的打开的看看快点快点肯定会发不出人了捡垃圾第六届地接部\n', '的点点滴滴多的二二二\n',
'聊了几句\n', '对对对对\n']

In [209]: f.close()


#### 使用WITH语句
In [213]: with open('test.txt','r',encoding = 'utf-8') as f:
     ...:     f = open('test.txt','r',encoding = 'utf-8')
     ...:     lines = f.readlines()
     ...: 
#### 把open的返回值放到f中，然后自动进行try，在执行之后自动执行close
#### 
In [214]: sents = []
In [215]: for line in lines:
     ...:     line = line.strip() #### 删掉空格
     ...:     tokens  = line.split('。') #### 以句号分割为列表
     ...:     for token in tokens:
     ...:         if len(token) > 0:
     ...:             sents.append(token)
     ...: 
In [216]: print(sents)
['大酒店剧烈的了解到了大家', '都来觉得觉得京东快递京东快递看到的打开
的看看', '快点快点肯定会发不出人了捡垃圾第六届地接部', '的点点滴滴多
的二二二', '聊了几句', '对对对对']

 
 #### filter( 函数， 可迭代对象)
 In [226]: numbers = [1,2,3,4,5]
In [227]: filter(lambda x : x % 2 == 0, numbers)
Out[227]: <filter at 0x1ec297442e0>
In [228]: list(filter(lambda x : x % 2 == 0, numbers))
Out[228]: [2, 4]

#### 每个line以换行符\n分割，每个line以句号分割为tokens，对tokens进行filter处理：只取出长度大于0的token组成filter，再将filter转换为列表，所以每个tokens进行filter处理后组成一个列表
In [229]: for line in lines:
     ...:     line = line.strip()
     ...:     tokens = line.split('。')
     ...:     tmp =  list(filter(lambda x: len(x) > 0, tokens))
     ...:     print(tmp)
     ...: 
['大酒店剧烈的了解到了大家', '都来觉得觉得京东快递京东快递看到的打开
的看看', '快点快点肯定会发不出人了捡垃圾第六届地接部']
['的点点滴滴多的二二二']
['聊了几句']
['对对对对']


#### 每个line以换行符\n分割，每个line以句号分割为tokens，对tokens进行filter处理：只取出长度大于0的token组成filter，再将filter转换为列表，所以每个tokens进行filter处理后组成一个列表
#### extend将列表中的元素拆出，并入同一个列表
In [230]: sents = []
In [231]: for line in lines:
     ...:     line = line.strip()
     ...:     tokens = line.split('。')
     ...:     sents.extend(list(filter(lambda x: len(x)>0 , tokens))
     ...: )
     ...: 
In [232]: print(sents)
['大酒店剧烈的了解到了大家', '都来觉得觉得京东快递京东快递看到的打开
的看看', '快点快点肯定会发不出人了捡垃圾第六届地接部', '的点点滴滴多
的二二二', '聊了几句', '对对对对']

 
#### 每个line以换行符\n分割，每个line以句号分割为tokens，对tokens进行filter处理：只取出长度大于0的token组成filter，再将filter转换为列表，所以每个tokens进行filter处理后组成一个列表
#### append直接将这些列表集成到一个列表中
In [235]: sents = []
In [236]: for line in lines:
     ...:     line = line.strip()
     ...:     tokens = line.split('。')
     ...:     sents.append(list(filter(lambda x: len(x)>0 , tokens))
     ...: )
     ...: 

In [237]: print(sents)
[['大酒店剧烈的了解到了大家', '都来觉得觉得京东快递京东快递看到的打开
的看看', '快点快点肯定会发不出人了捡垃圾第六届地接部'], ['的点点滴滴
多的二二二'], ['聊了几句'], ['对对对对']]

#### 普通循环
In [238]: lens = []

In [239]: for sent in sents:
     ...:     lens.append(len(sent))
     ...: 

In [240]: print(lens)
[3, 1, 1, 1]

#### 列表生成式
In [241]: lens = []

In [242]: lens = [len(sent) for sent in sents]

In [243]: print(lens)
[3, 1, 1, 1]

#### 列表生成式
In [248]: [(x,y) for x in range(1,4) for y in range(2,8)]
Out[248]: 
[(1, 2),
 (1, 3),
 (1, 4),
 (1, 5),
 (1, 6),
 (1, 7),
 (2, 2),
 (2, 3),
 (2, 4),
 (2, 5),
 (2, 6),
 (2, 7),
 (3, 2),
 (3, 3),
 (3, 4),
 (3, 5),
 (3, 6),
 (3, 7)]