一天学会python？？
参考：https://www.runoob.com/python3/python3-tutorial.html
备忘
实用函数
- input ： 输入
a = input();
a = input("提示语");
- print ：打印到终端
默认是换行的；末尾加上 ,end=""，就可以取消换行。
print(a,end="")
打印多个数值
print(1, "aa")
- id 函数用于获取内存地址
a = 10
print(id(a))
一、基础
1.1 特点
- Python 是一种解释型语言
- Python 是交互式语言
- Python 是面向对象语言
- Python 是初学者的语言
- 易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
- 易于阅读：Python代码定义的更清晰。
- 易于维护：Python的成功在于它的源代码是相当容易维护的。
- 一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
- 互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
- 可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
- 可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
- 数据库：Python提供所有主要的商业数据库的接口。
- GUI编程：Python支持GUI可以创建和移植到许多系统调用。
- 可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。
1.2 基础语法
1.2.1 编码
默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。
# *-* condig: utf8 *-*
1.2.2 标识符
- 大小写敏感；
- 首位字符可以是字母、下划线，但是不能是数字；
- 其他位的字符可以是字母、下划线、数字；
- python3支持中文作为标识符
1.2.3 保留字
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if',
'import', 'in', 'is','lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
'while', 'with', 'yield']
1.2.4 注释
单行注释用 #
多行注释成对的 ... 或者 ""
例子：
print("OK")
...
这是多行注释
...
1.2.5 行缩进风格
用缩进代表代码块，而不用{}，例如：
if true
print("OK")
else
print("not OK")
缩进的小可变，但是同一代码块每行的缩进大小要一致。
1.2.6 多行合并为一行
用反斜杠
a = b+\
c+\
d
# 相当于 a = b+c+d
1.2.7 数字类型
四种数字类型
- int：整形
- boo：布尔
- float：浮点
- complex：复数类型，如1+2j
1.2.8 字符串
- 用单引号或者双引号括起来；
- 三个引号作为标记，可以多行字符串括起来，例如
a = ''' good
job
'''
print(a)
- 转义符 \ ，可以加上 r 让转义字符不生效，从而直接打印，例如：
a = r' goodjob\n'
- 字符串级联，例子：
a = "good" " job" //相当于 a = "good job"
- 用 + 连接两个字符串，用 * 使同一个字符串重复
a = ("look"+"a")*2
- 字符串索引从左到右，是从0开始递增；如果是从右到左，则是从-1开始递减；
- python没有单个字符的表示，一个字符也用字符串表示；
- 字符串截取方式：变量[头下表:尾下标:步长]。例子：
a = "Today is a sunny day"
print(a[0:3:2])
1.1.9 空行
函数之间或者类之间用空行隔开，空行也是代码的一部分。
1.1.10 同一行显示多条语句
用 ; 分隔
1.1.11 模块导入
- 在 python 用 import 或者 from...import 来导入相应的模块。
- 将整个模块(somemodule)导入，格式为： import somemodule
- 从某个模块中导入某个函数,格式为： from somemodule import somefunction
- 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
- 将某个模块中的全部函数导入，格式为： from somemodule import *
1.2 基础数据类型
- 在 Python 中，变量没有类型，这里的的"类型"是变量在内存中的存储类型；
1.2.1赋值：
a = 1
多个变量赋值
a = b = c =1
a, b, c = d, e, f
1.2.2 六种标准的数据类型
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
其中
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
1.2.3 数字及其运算
- Python3 支持 int、float、bool、complex（复数）。
- 类型判断函数 isinstance 和 type
print(isinstance(1, int))
print(type(1))
区别：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型
- 数值运算
a = 2
b =3
c1 = a + b
c2 = a - b
c3 = a * b
c4 = a / b #除法，得到浮点数
c5 = a // b #除法，得到整形数
c6 = a % b
c7 = a ** b #乘方
1.2.4 字符串
（参见前面）
1.2.5 列表
（1）定义
list = [1,4,5,7]
（2）截取
和字符串类似，语法为 ：变量[头下表:尾下标:步长]。其中步长可以省略，省略是，步长默认为1；如果步长是 -1 ，则代表的是逆向读取。
# 逆向读取
a = [1, 2, 3, 4]
print(a[-1:-5:-1])
（3）连接和重复操作
用 + 和 *，例子：
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = (a + b) * 2
print(c)
（4）取得其中的元素
类似于c语言的数组，用 [ ] 符号；和字符串不同的是，列表里的数值是可以更改的。
a = [1, 2, 3, 4]
a[1] = 10
1.2.6 元组（Tuple）
- 元组和列表类似，但是有个很大的区别是，元组的数值不能被更改；
- string、list 和 tuple 都属于 sequence（序列）；
（1）定义
t = (1, 2, 3, 4)
（2）元组操作
截取、连接、复制和列表类似
1.2.7 集合（set）
- 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员；
（1）定义 - 建立空集合用set()；建立非空集合可用set()，也可用{ }来创建；
- 建立空的 { }，代表的时建立空字典，而不是集合
（2）赋值、成员测试和集合运算
和数学的集合类似。例子：
a = {1, 2, 3, 4, 3}
c = {4, 5, 6, 7}
b = a #赋值会去掉重复的元素
c = a - b #a和b的差集
c = a + b #a和b的并集
c = a & b #a和b的交集
c = a ^ b #a和b不同时存在的元素集合
1.2.8 字典（Dictionary）
- 和列表有序对象集合特点相反，字典是无序对象的集合；字典通过 键值来存取，而不是通过有序下标来存取；
- 键(key)必须使用不可变类型；
- 在同一个字典中，键(key)必须是唯一的；
- 字典是一种映射类型，它的元素是键值对。
（1）定义
建立空字典：
dic = {}；
建立非空字典:
dic = {"key1":10, "key2":20}
（2）赋值
dic = {}
dic["key1"] = 10
（3）内置函数
clear()、keys()、values()等
dic = {}
dic["key1"] = 10
dic["key2"] = 20
print(dic.keys())
1.2.9 类型转换
| 函数 | 描述 |
|---|---|
| int(x [,base]) | 将x转换为一个整数 |
| float(x) | 将x转换到一个浮点数 |
| complex(real [,imag]) | 创建一个复数 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 |
| frozenset(s) | 转换为不可变集合 |
| chr(x) | 将一个整数转换为一个字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
1.3 运算符
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
- 运算符优先级
这些运算符与c语言类似，但有些不同：
（1）算术运算符的 // 和 **
/ : 除法，达到浮点值
// ： 除法，得到整形值
** ： 阶乘
（2）赋值运算符： 海象运算符
在这个示例中，赋值表达式可以避免调用 len() 两次:
if (n := len(a)) > 10:
print(f"List is too long ({n} elements, expected <= 10)")
（3）逻辑运算符
and：与
or：或
not：非
（4）成员运算符
in和not in，例子：
lst = [2, 4, 6, 8]
if( 4 in lst ):
print("true")
else:
print("false")
（5）身份运算符
is 和 not is，用于比较两个对象的存储单元。
a is b 相当于 id(a) == id(b)，其中id函数是取得内存的地址
a = 10
b = 10
print(a is b)
1.4 数字
（1）复数定义
a = 1 + j
（2）类型转换
- int(x) 将x转换为一个整数。
- float(x) 将x转换到一个浮点数。
- complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
- complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
（3）数学函数
| 函数 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1, x2,...) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,...) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| pow(x, y) | x**y 运算后的值。 |
| round(x [,n]) | 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。 |
| sqrt(x) | 返回数字x的平方根。 |
（4） 随机函数
| 函数 | 描述 |
|---|---|
| choice(seq) | 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 |
| randrange ([start,] stop [,step]) | 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1 |
| random() | 随机生成下一个实数，它在[0,1)范围内。 |
| seed([x]) | 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。 |
| shuffle(lst) | 将序列的所有元素随机排序 |
| uniform(x, y) | 随机生成下一个实数，它在[x,y]范围内。 |
（5）三角函数
| 函数 | 描述 |
|---|---|
| acos(x) | 返回x的反余弦弧度值。 |
| asin(x) | 返回x的反正弦弧度值。 |
| atan(x) | 返回x的反正切弧度值。 |
| atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。 |
| cos(x) | 返回x的弧度的余弦值。 |
| hypot(x, y) | 返回欧几里德范数 sqrt(xx + yy)。 |
| sin(x) | 返回的x弧度的正弦值。 |
| tan(x) | 返回x弧度的正切值。 |
| degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 |
| radians(x) | 将角度转换为弧度 |
（6）数学常量
pi：圆周率
e：自然对数
1.5 列表
list = [1, 2, 3, 4]
（1）删除列表元素
关键词 del
del list[2]
（2）列表相关的函数和方法
| 序号 | 函数 |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元组转换为列表 |
（3）list类下的方法
| 序号 | 方法 |
|---|---|
| list.append(obj) | 在列表末尾添加新的对象 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| list.insert(index, obj) | 将对象插入列表 |
| list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| list.reverse() | 反向列表中元素 |
| list.sort( key=None, reverse=False) | 对原列表进行排序 |
| list.clear() | 清空列表 |
| list.copy() | 复制列表 |
1.6 字典
（1）字典内置函数
| 函数 | 描述 |
|---|---|
| len(dict) | 计算字典元素个数，即键的总数。 |
| str(dict) | 输出字典，以可打印的字符串表示。 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
（2）字典内置方法
| 函数 | 描述 |
|---|---|
| radiansdict.clear() | 删除字典内所有元素 |
| radiansdict.copy() | 返回一个字典的浅复制 |
| radiansdict.fromkeys() | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| radiansdict.get(key, default=None) | 返回指定键的值，如果键不在字典中返回 default 设置的默认值 |
| key in dict | 如果键在字典dict里返回true，否则返回false |
| radiansdict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
| radiansdict.keys() | 返回一个迭代器，可以使用 list() 来转换为列表 |
| radiansdict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| radiansdict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| radiansdict.values() | 返回一个迭代器，可以使用 list() 来转换为列表 |
| pop(key[,default]) | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| popitem() | 随机返回并删除字典中的最后一对键和值。 |
1.7 集合
（1）元素删除
用的是内置方法 remove，例如
s = set((1, 4, 5, 7))
s.remove(5)
（2）集合的内置方法
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
二、拓展
2.1 流程控制语句
（1）条件判断
关键词 if， 例子：
a = 1
if a == 1:
print("a is 1")
elif a == 2:
print("a is 2")
else:
print("a is know")
（2）while循环
关键词while ，例子：
a = 0
while (a < 10):
print(a)
a += 1
（3）for循环
可以遍历任何的序列，例如列表、字符串。
例子：
for x in ["kubo", "is", "a", "stupid", "guy"]:
print(x, end=" ")
for语句和range函数的结合，例子：
for x in range(5):
print(x, end=" ")
for x in range(5, 9):
print(x, end=" ")
for x in range(5, 9, 2):
print(x, end=" ")
（4）break和continue
和c语言功能一样
（5）pass语句
pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句
例子：
while(True):
pass
2.2 迭代器和生成器
- 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。- 迭代器只能往前不会后退。
- 迭代器有两个基本的方法：iter() 和 next()。
- 字符串，列表或元组对象都可用于创建迭代器：
（1）创建迭代器对象，并使用next()函数
lst = ["OK", "I", "will", "watch", "out", "you"]
it = iter(lst)
print(next(it), end=" ")
print(next(it), end=" ")
print(next(it), end=" ")
使用for语句和迭代器来遍历序列
lst = ["OK", "I", "will", "watch", "out", "you"]
it = iter(lst)
for x in it:
print(x, end=" ")
（2）生成器
使用yield函数，例子：
import sys
lst = ["OK", "I", "will", "watch", "out", "you"]
def fun():
for x in lst:
a = x
yield a
re = fun()
while True:
try:
print(next(re), end=" ")
except StopIteration:
sys.exit()
在函数里调用yield函数， 返回一个迭代器
2.3 函数
关键字： def、return
（1）语法和定义
def fun(参数列表):
函数体
return 用于返回数值
（2）例子：
def fun(a, b = 10):
print(a, b)
fun(1, 2) #匹配传参
fun(1) #参数b为默认值
fun(b = 1, a = 2) #指定传参
（2）不定参数列表
def fun(*var):
print(var)
fun(1, 2, 3)
参数前面加* 代表传入的是元组
（3）匿名函数
关键字 lambda
用法：
lambda [arg1 [,arg2,.....argn]]:expression
例子：
sum = lambda arg1, arg2: arg1 + arg2
print(sum(1, 2))
2.4 模块
关键字：import、from ... import ...
（1）自定义模块并导入
自建一个 fun.py 文件，内容为：
def sum(a, b):
return a + b
再建立一个测试脚本t.py
import fun
print(fun.sum(1, 2))
结果表明，t.py可以调用导入模块里的函数
（2）__name__ 属性
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用name属性来使该程序块仅在该模块自身运行时执行。
例子:
if __name__ == '__name__':
print("自己在运行")
else:
print("模块在运行")
（3）内置函数dir()
可以找到模块里定义的所有名称
import fun
dir(fun)
如果dir()不带参数，那么得到的返回值是当前文档的所有定义名称
（4）包
- 包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
- 在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
- 目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。
例子：
sound/ 顶层包
__init__.py 初始化 sound 包
formats/ 文件格式转换子包
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ 声音效果子包
__init__.py
echo.py
surround.py
reverse.py
...
filters/ filters 子包
__init__.py
equalizer.py
vocoder.py
karaoke.py
2.5 打印
（1）
str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式。
（2）格式化用法
str.format() 方法，例如：
print('姓名：{} 年龄："{}"岁'.format("along", 20))
#结果==> 姓名：along 年龄："20"岁
{ }括号淋面也可以添加序号，代表后面的参数，例如：
print('姓名：{0} 年龄："{1}"岁'.format("along", 20))
print('姓名：{1} 年龄："{0}"岁'.format("along", 20))
'''结果
姓名：along 年龄："20"岁
姓名：20 年龄："along"岁
'''
{ } 里面可以指定对象名，例如：
print('姓名：{name} 年龄："{age}"岁'.format(name = "along", age = 20))
!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化，例如：
import math
print('圆周率：{!r}'.format(math.pi))
#结果==> 圆周率：3.141592653589793
可选项 : 可以定制小数的小数点后的位数，例如
import math
print('圆周率：{!r}'.format(math.pi))
# 结果==> 圆周率：3.142
或者保证某域的空格数一定：
# 这里用到了字典的内置方法 items()
dic = {"god":1, "people":2, "woman":3}
for x,y in dic.items():
print("{:10}{:10d}".format(x, y))
（3）类似于c风格的格式化
例子：
print("this is a %s" % "string")
2.6 文件操作
（1）文件读写
open(filename, mode)
（2）模式
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
| 模式 | r | r+ | w | w+ | a | a+ |
|---|---|---|---|---|---|---|
| 读 | + | + | + | + | ||
| 写 | + | + | + | + | + | |
| 创建 | + | + | + | |||
| 覆盖 | + | + | ||||
| 指针在开始 | + | + | + | + | ||
| 指针在结尾 | + | + |
（3）打开、写入、关闭例子：
注：若果文件不存在，那么系统会在当前路径下创建新的文件
f = open("a.txt", "w")
f.write("I write a setence on file which name is a.txt.");
f.close()
（4）文件读取
f = open("a.txt", "r")
str = f.read()
f.close()
print(str)
- f.read()
- f.readline() ：读取一行
- f.readlines() ： 读取多行，并且把每一行都分割
另一种行遍历方式：
f = open("a.txt", "r")
for line in f:
print(line, end="")
f.close();
- f.tell() ：返回文件指针当前位置
- f.seek()
（5）pickle 模块
可以将程序运行中的对象存到文件中去。
基本接口：
pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开:
x = pickle.load(file)
存入：
import pickle
dic = {'a':[1,2,3,4,5],\
'b':"good job",\
'c':20\
}
f = open("a.txt", 'wb')
pickle.dump(dic , f)
f.close()
取出：
import pickle
f = open("a.txt", "rb")
dic = dict(pickle.load(f))
for x,y in dic.items():
print(x,y)
（6）open的完整参数列表
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: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
（7）file对象方法一览表
| 方法 | 描述 |
|---|---|
| file.close() | 关闭文件。关闭后文件不能再进行读写操作。 |
| file.flush() | 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 |
| file.fileno() | 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。 |
| file.isatty() | 如果文件连接到一个终端设备返回 True，否则返回 False。 |
| file.next() | Python 3 中的 File 对象不支持 next() 方法。返回文件下一行。 |
| file.read([size]) | 从文件读取指定的字节数，如果未给定或为负则读取所有。 |
| file.readline([size]) | 读取整行，包括 "\n" 字符。 |
| file.readlines([sizeint]) | 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。 |
| file.seek(offset[, whence]) | 移动文件读取指针到指定位置 |
| file.tell() | 返回文件当前位置。 |
| file.truncate([size]) | 从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。 |
| file.write(str) | 将字符串写入文件，返回的是写入的字符长度。 |
| file.writelines(sequence) | 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 |
2.7 OS模块下的文件和目录操作
参考： https://www.runoob.com/python3/python3-os-file-methods.html
- os.getcwd() ：得到当前的路径
- os.listdir() ： 展开目录里的内容
2.8 异常处理
（1）try/except 语句
try:
测试代码
except ValueError:
异常处理
else:
其他异常情况
finally:
无论异常是否发生都会执行的代码
- 一个try对应多个except，对应的ValueError匹配，则执行此异常值下面的代码块
（2）用户自定义异常
【待续： https://www.runoob.com/python3/python3-errors-execptions.html】
（3）主动抛出异常
语法：
raise [Exception [, args [, traceback]]]
2.9 面向对象
相关概念：
类、方法、类变量、数据成员、方法重写局部变量、实例变量、继承、实例化、对象
（1）类定义
class ClassName:
.
.
.
（2）类对象
实例化，例子：
class Cl:
a = 1
b = 10
lst = [1, 2, 3, 4]
cl = Cl()
print(cl.a, cl.b, cl.lst)
（3）构造方法__init__()
class Cl:
def __init__(self, arg_a, arg_b):
self.a = arg_a
self.b = arg_b
lst = [1, 2, 3, 4]
cl = Cl(5, 6)
print(cl.a, cl.b, cl.lst)
其中 self 代表类的实例
（4）类的方法
和一般函数不同，类的方法要包含self这个参数
（5）类的继承
语法
class DerivedClassName(BaseClassName):
.
.
.
多继承语法：
class DerivedClassName(Base1, Base2, Base3):
.
.
.
（6）用子类对象调用父类已被覆盖的方法
用 super 函数
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
（7）类的成员私有属性
默认共有属性，成员名 __ 开头的，表示为私有属性，不能被类对象调用。
（8）类的方法
需要包含参数 self，也可以用this，用于表示当前类对象
（9）类的专有方法
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方
（10）运算符重载
例子：
class Sum:
def __init__(self, x, y):
self.a = x
self.b = y
def __str__(self):
return 'Sum(%d, %d)'%(self.a, self.b)
def __add__(self, other):
return Sum(self.a + other.a, self.b + other.b)
s1 = Sum(10, -4)
s2 = Sum(2, 4)
print(s1+s2)
2.10 命名空间和作用域
- Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的
（1）命名空间
- 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
- 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
- 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）
优先次序：局部 > 全局 > 内置名称
（2）作用域
- L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
- E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
- G（Global）：当前脚本的最外层，比如当前模块的全局变量。
- B（Built-in）： 包含了内建的变量/关键字等。，最后被搜索
规则顺序： L –> E –> G –>gt; B。
（3）global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
2.11 一些模块
- dir([模块名]) : 列出模块里包含的对象
- help([模块名]) ：返回模块的一些帮助信息
（1）os模块
- os.getcwd()：获得当前路径
- os.chdir()：修改当前路径
- os.system()：调用系统命令
（2）glob模块
通配符搜索例子：
import glob
print(glob.glob("*.py"))
（3）sys模块
- sys.argv ： 命令行参数
- sys.stderr.write() : 错误重定向
（4）re模块
- re.findall() : 字符串正则匹配
（5）math模块
包含各类数学函数的运算
（6）访问互联网：urlib模块
from urllib.request import urlopen
f = open("web.html", "wb")
for line in urlopen('https://baidu.com'):
f.write()
f.close()
（7）datetime模块
例子：
from datetime import date
print(date.today())
（8）zlib模块
压缩数据，例子：
import zlib
s = b"I just woder to know what is your tiny abacus"
print(len(s))
sz = zlib.compress(s)
print(len(sz))
print(zlib.decompress(sz))
print(zlib.crc32(s))
（9）时间度量（timeit）
from timeit import Timer
print(Timer('c = a; a = b; b = c', 'a = 1; b = 2').timeit())
print(Timer('a, b = b, a', 'a = 1; b = 2').timeit())
（10）测试模块（doctest）
例子：
def average(values):
"""Computes the arithmetic mean of a list of numbers.
>>> print(average([20, 30, 70]))
20.0
"""
return sum(values) / len(values)
import doctest
doctest.testmod()
结果报错，20, 30, 70的平均值是40.0，而非20.0
三、例子
3.1 斐波那契数列
a = 0
b = 1
while (a < 10):
print(a, end=",")
a, b = b, a+b
3.2 数字求和
# -*- coding: UTF-8 -*-
# Filename : test.py
# author by : www.runoob.com
# 用户输入数字
num1 = input('输入第一个数字：')
num2 = input('输入第二个数字：')
# 求和
sum = float(num1) + float(num2)
# 显示计算结果
print('数字 {0} 和 {1} 相加结果为： {2}'.format(num1, num2, sum))
3.3 秒表
import time
print('按下回车开始计时，按下 Ctrl + C 停止计时。')
while True:
input("")
starttime = time.time()
print('开始')
try:
while True:
print('计时: ', round(time.time() - starttime, 0), '秒', end="\r")
time.sleep(1)
except KeyboardInterrupt:
print('结束')
endtime = time.time()
print('总共的时间为:', round(endtime - starttime, 2),'secs')
break
3.4 快排
思想： 取其中一个数 num0 作为基准，让剩余的数与 num0，然后根据大小分列两侧；然后那两侧的数用同样的方法，进行分列两侧，直到不能再分。
【其他排序参考： https://www.runoob.com/python3/python3-examples.html】
def partition(arr,low,high):
i = ( low-1 ) # 最小元素索引
pivot = arr[high]
for j in range(low , high):
# 当前元素小于或等于 pivot
if arr[j] <= pivot:
i = i+1
arr[i],arr[j] = arr[j],arr[i]
arr[i+1],arr[high] = arr[high],arr[i+1]
return ( i+1 )
# arr[] --> 排序数组
# low --> 起始索引
# high --> 结束索引
# 快速排序函数
def quickSort(arr,low,high):
if low < high:
pi = partition(arr,low,high)
quickSort(arr, low, pi-1)
quickSort(arr, pi+1, high)
arr = [10, 7, 8, 9, 1, 5]
n = len(arr)
quickSort(arr,0,n-1)
print ("排序后的数组:")
for i in range(n):
print ("%d" %arr[i]),
3.5 抓取小说
##############################
# 获取网络小说 上门女婿叶辰 #
##############################
from urllib.request import urlopen
# 创建或清空文件
def createFile(name):
f = open(name, "w")
f.close();
#去掉二进制数据前面的空格
def deleteStrSpace(s):
s_len = len(s)
idx = 0;
for i in range(s_len):
if s[i] != ord(' '):
break
idx += 1
return s[idx:s_len]
#获取网页内容，并写入文件
def getWebContent(url, file_name):
f = open(file_name, "ab")
line_get_en = 0
for line in urlopen(url):
line_str = str(line)
if line_get_en == 0 and line_str.find('') != -1:
line_get_en = 1
continue
elif line_get_en == 1 and line_str.find('
') != -1:
line_get_en = 0
continue
elif line_get_en == 1:
f.write(deleteStrSpace(line))
f.close()
#网址： https://www.geilwx.com/book/30713/38589713.html
page = 38589713
noval_file = 'noval.txt'
createFile(noval_file)
for i in range(20):
getWebContent('https://www.geilwx.com/book/30713/' + str(page) + '.html', noval_file)
print('\rtotle page 20,now is ' + str(i + 1), end='')
page += 1
##############################
# 获取网络小说 天龙八部 #
##############################
from urllib.request import urlopen
# 创建或清空文件
def createFile(name):
f = open(name, "w")
f.close();
#网址：https://www.jinyongwang.net/tian/643.html
#获取网页内容，并写入文件
def webLinePro(s):
ch1 = '1'
ch2 = '2'
ch3 = '3'
ch4 = '4'
ret_s = ''
cnt = 0;
for ch in s:
cnt += 1;
if(cnt <= 2):
continue
ret_s += ch
length = len(ret_s)
if(ch2 == '<' and ch1 == 'p' and ch == '>'):
ret_s = ret_s[0: length - 3]
#print("match ", length)
elif(ch3 == '<' and ch2 == '/' and ch1 == 'p' and ch == '>'):
ret_s = ret_s[0: length - 4]
ret_s += '\n'
elif(ch4 == '<' and ch3 == 's' and ch2 == 'c' and ch1 == 'r' and ch == 'i'):
ret_s = ret_s[0: length - 5]
break;
ch4 = ch3
ch3 = ch2
ch2 = ch1
ch1 = ch
return ret_s
start_mark = "(adsbygoogle = window.adsbygoogle || []).push({});"
end_mark = "