Python学习记录（1）
先从一份来自我的高中的python教程学起
python3
基本输入输出
1 | name = input("请输入一个人名") |
通过 input()函数接收到的数据是字符串型，如果想要获得数值型的数据，需要使用转
换函数进行转换，如：eval() 是一个字符串处理函数，它的作用是去掉字符串外面的双（单）引号。float()转换成浮点型。int()转换成整型。
例：
1 | num1 = eval(input("请输入第一个数字")) |
print()函数自带分行效果。
例：
1 | x=1 |
输出效果
x=1
y=2
若要实现不分行的效果：
1 | x=1 |
输出效果
x=1 , y=2
也可以：print("x=",x," , ","y=",y)
占位符
%d 整数型(int)占位符
%s 字符串型(str)占位符
%f 浮点型(float)占位符 （%.nf 自主保留n位小数）
例 1：%2d 表示输出两位数字，空格补位；%02d’表示输出两位数字，0 补位
1 | print('%2d-%02d' % (3,1)) |
3-01
例 2：保留两位小数，四舍五入
1 | print('%.2f' % 3.141926) |
3.14
例 3：把所有的类型都转为字符串
1 | print('Age: %s. Gender:%s' % (25,True)) |
Age: 25. Gender: True
例 4：字符串里面的%是一个普通字 符，输出%,用%%来表示一个%
注意事项：
- 单引号’’
- True
- %
format()函数：格式化输出
该函数把字符串当成一个
模板，通过传入的参数进行格式化，并且使用大括号 {}作为特殊字符代替%’。位置匹配：
- 不带编号,即“{}”。
- 芾数字编号,可调换顺序,即“{1}”、“{2}”。
- 带关键字,即“{a}”、“{tom}”。
例子：
1 | print('{} {}'.format('hello','world')) |
hello world
1 | print('{0} {1} {0}'.format('hello','world')) |
hello world hello
1 | print('{a} {tom} {a}'.format(tom='hello',a='world')) |
world hello world
1 | print("请戴好口罩！"*5) |
请戴好口罩！请戴好口罩！请戴好口罩！请戴好口罩！请戴好口罩！
Python 变量、常量和数值类型
变量
常用保留字如下表：
False None True and as while with yield
assert break class continue def or pass raise
del elif else except finally return try not
for from global if import in is lamb
在定义变量时，是不用指定类型的，因此，Python 被称为是动态语言。在定义了变量之后，也可以随时改变其类型。例：
a=1
a=’hello’
运算符：
- ** 幂
- % 取模
- // 整除
常量
Python 中没有专门的语法来说明常量，一般是用全部大写的变量名来表示常量。
Python 中的数值类型
Python 数值类型用于存储数值，它支持三种不同的数值类型。
整型 int：不带小数的整数。
浮点型 float：带小数点的数，相当于实数。
复数 complex：数学中的复数，由实数部分和虚数部分组成。（例：1+2j）
1 | a=5+6j |
type()函数可以用来查看变量或常量的数据类型，如下图所示
1 | a1='china' |
<class ‘str’>
1 | b1=123 |
<class ‘int’>
1 | type([1,2,3]) |
<class ‘list’>
Q: str(1) + "1" 和 int("1") + 1 有什么区别？
- str(1) + “1”
这个表达式中，str(1) 将数字 1 转换成字符串 “1”。然后，使用 + 操作符将两个字符串 “1” 和 “1” 连接在一起。因此，这个表达式的结果是一个字符串 “11”。 - int(“1”) + 1
这个表达式中，int(“1”) 将字符串 “1” 转换成整数 1。得到 2
Python 字符串
- 可以用单引号’ ‘或双引号” “来创建字符串。
- 可以用切片进行截取
- 字符串可以进行一系列的运算。例：
s1=’hello,’ s2=’python’+连接。
* 复制，如：s1*2 表示重复输出字符串，后面的数字表示重复输出几次。
in 用来判断某个字符是否在字符串中，若在返回 True。
not in 用来判断某个字符是否不在字符串中。
>>> s1=’hello’
>>> s2=’python’
>>> s1+s2
‘hellopython’
>>> s1*2
‘hellohello’
>>> ‘h’ in s1
True
>>> ‘h’ not in s1
False
>>> len(s1)
5
- 字符串函数
与字符串相关的函数有 40 来个，需要时可以查阅相关资料。
如：
len(s1) 用来计算字符串的长度。
split(sep=None, maxsplit=-1)，以 sep 为分割符截取字符串，如果 maxsplit 有指定值, 就截取 maxsplit 个子字符串.
>>> w1=’www.baidu.com‘
>>> w1.split(‘.’)
[‘www’, ‘baidu’, ‘com’]
>>> s2=’hello I am fine’
>>> s2.split(‘ ‘,2)
[‘hello’, ‘I’, ‘am fine’]
- 转义字符
Python 不支持 char 字符类型，只有字符串类型，哪怕只有一个字符也要把它作为字符串类型来处理。在字符串中需要用到一些特殊字符时，就是转义字符，用反斜杠‘\’来表示转义字符。比较常用的如：
\n 换行
\\ 反斜杠
\r 回车
\t 横向制表符
\v 纵向制表符
Python 切片
- 访问全部
1
2s='hello world'
print(s) - 访问具体位置
- 切片
1
2
3
4
5
6s='hello world'
print(s[0:3]) #前三个
print(s[1:3])
print(s[2:]) #三个之后全部
print(s[:3]) #前三个
print(s[-1]) #倒一个
>>> l=’adsaa’
>>> l
‘adsaa’
>>> print(l)
adsaa
Python中单引号，双引号，3个单引号及3个双引号的区别
I’m a big fans of Python.
str3 = 'I\'m a big fan of Python.'str3 = "I'm a big fan of Python."
同时若字符串中有双引号可以用单引号表示字符串。用双引号定义字符串的时候，就会认为你字符串里面的单引号是普通字符无需转义。三个单引号 or 双引号
1
2
3
4
5
6
7
8
9
10
11
12
13str1="""
list of name:
huali # lihua
chaodeng # dengchao
"""
str1
'\nlist of name:\nhuali # lihua\nchaodeng # dengchao\n'
print(str1)
list of name:
huali # lihua
chaodeng # dengchao
Python 列表
列表 list 是 Python 中最常用的数据类型，列表可以看作是一个数据容器，用于存储各种各样的数据，它们的数据类型可以不同，这些数据称为列表的元素。
在 Python 中，用方括号[]来表示列表，并用逗号来分割其中的元素。
列表的创建
创建一个列表，只要用方括号把数据项括起来即可。例：
list1=[1,2,3,4,5,6]
list2=[1986,’中国’,20.5,’北京’]
list3=[]
访问列表中的值
与字符串相似（全部、具体位置、切片）
删除列表元素
(1)del 按下标删除，例： del list1[1]
(2)remove 按值删除，例： list2.remove(1986)
(3)pop 按指定位置删除，例：list2.pop(1)
1
2
3
4
5
6
7
8numbers = [1, 2, 3, 4, 5]
# Using the pop() method to remove and return the last element of the list
last = numbers.pop() #默认删除最后一个
# Printing the removed element and the modified list
print("The popped element is:", last)
print("The remaining list is:", numbers)
# Output: The popped element is: 5
# The remaining list is: [1, 2, 3, 4]
>\>>> my_list=[1,2,3,4,5]
\>>> poped_element=my_list.pop(1)
\>>> print(poped_element)
2
\>>> print(my_list)
[1, 3, 4, 5]
添加列表元素
用 append 在列表末尾添加元素。例：
1
2
3
4
list1=[]
for i in range(10):
list1.append(i)
print(list1)
上段代码的输出结果为：
>[1,2,3,4,5,6,7,8,9,10]
列表生成式
可以用列表生成式来生成列表。其形式为：X=[x for x in range(10)]
=左边为列表名，右边为列表生成式，用一个 for 循环来生成列表。
多维列表
也可以将列表定义为多维的。例：定义一个二维列表如下。list1=[[1,2,3,4],['中国','China'],['Hello','Python']]
多维列表的使用方法和一维列表是一样的，只是下标要多一个，如:list1[0][0]。
列表运算
列表可以做一些运算，比如：
1
2
l1=[1,2,3]
l2=[3,4,5]
l1+l2 表示将 l1 和 l2 组合成将的列表，其输出为：[1,2,3,3,4,5]。
l1*3 表示将 l1 重复 3 次输出：[1，2，3，1，2，3，1，2，3]。
1 in l1 判断 1 是否在列表l1中
data=[[2]*3]+[[2]*3]+[[2]*3]
1 | dat=[[2]*3]*3 |
在这段代码中，首先对 data 和 dat 进行了定义，它们的赋值方式略有不同：
data 是由三个 [2, 2, 2] 组成的列表，每个子列表都是独立的对象。
dat 是由对同一个 [2, 2, 2] 的引用重复三次组成的列表，实际上这三个引用指向同一个对象。
接着进行比较和操作：
if data==dat: 这里比较的是 data 和 dat 是否相等。由于它们的结构不同，所以结果为 False。
data[1][0]=45 这一行将 data 中第二个子列表的第一个元素修改为 45。
打印 data 和 dat 的结果，可以看到 data 中的第二个子列表被修改了，而 dat 中对应位置也发生了变化，因为 dat 中的三个子列表其实指向同一个对象。
函数
序号|函数|介绍
----|----|--------
1 |cmp(list1, list2)|比较两个列表的元素
2 |len(list)|列表元素个数
3 |max(list)|返回列表元素最大值
4 |min(list)|返回列表元素最小值
5 |list(seq)|将元组转换为列表
6 |len(list)|长度
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 |list.sort(cmp=None, key=None, reverse=False) |对原列表进行排序
list.sort(cmp=None,key=None,reverse=False)
Python中的sort()方法是用于对列表进行原地排序的方法。原地排序意味着该方法会直接修改原始列表，而不会创建一个新的排序后的副本。
sort()方法有两个可选参数：key和reverse。
key参数用于指定一个函数，该函数将作为排序的依据。例如，如果列表中的元素是字符串，可以使用 key=str.lower来实现不区分大小写的排序。
reverse参数是一个布尔值，默认为False。如果设置为True，则列表将以降序进行排序；如果设置为False，则以升序进行排序。
下面是一些示例：
1 | numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5] |
请注意，sort()方法会直接修改原始列表，而不会返回任何值。如果你想要获取一个新的排序后的列表，可以使用sorted()函数，该函数会返回一个新的已排序的列表。
Python 元组
元组 tuple 也是 Python 常用的一种数据类型，与列表类似，唯一不同的是元组中的元素是不允许修改的。元组使用的是小括号（），列表使用的是中括号[]。
元组是不可变的，不能进行任何的增删改操作，因而也被称之为不可变的列表。
- 创建
[] 变为 （）t2=('abc',1,2)
元组中只包含一个元素时，需要在元素后面添加逗号
· - 访问
t2[0] - 删除
不能删除单个，可以整体删除：
del t2 - 运算
一样 - Python元组包含了以下内置函数
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | cmp(tuple1, tuple2) | 比较两个元组元素。 |
| 2 | len(tuple) | |
| 3 | max(tuple) | 返回元组中元素最大值。 |
| 4 | min(tuple) | 返回元组中元素最小值。 |
| 5 | tuple(seq) | 将列表转换为元组 |
| 6 | list(tuple) | 元组转换成列表 |
Python 字典
字典在 Python 中也是一种常用的数据类型。它是一种可变容器模型，可用来存储任意类型的对象，如：字符串、数字、元组等。
字典的创建
字典由键和对应值这样的键/值对所组成。每个键/值对里面的键和值之间用冒号：分隔开，键/值对之间是由逗号，隔开，整个字典包括在花括号中。例：
1 | d1={"name":"lay","age":18} |
要注意的是，字典中的键不允许重复出现。就是说冒号左边的键的名字只能出现一次，
但值可以重复。键名也不能用列表：如果 d3={[1,2,3,4]:1234}这样是会报错的。值可以是列表。
访问字典里的值
要访问整个字典，直接用字典名就行。但如果要访问字典里某个键的值，就需要把相应的键放在方括号里。当然，访问的时候，要访问键存在的那个值。也可以用 values()返回字典中的所有值。
>>>d4={(‘name’,’age’):(‘llay’,18)}
d4
{(‘name’, ‘age’): (‘llay’, 18)}
d4[(‘name’,’age’)]
(‘llay’, 18)
d1={‘name’:’lay’,’age’:18}
{‘name’: ‘lay’, ‘age’: 18}
d1.values()
dict_values([‘lay’, 18])
修改字典
字典里的键是不能修改的，但其值可以修改。
可以增加或删除键/值对。
可以清空整个字典，用 clear()。
可以删除整个字典，用 del
1 | >>>d2={'abc':18,'money':80,1974:74} |
字典键的特性
字典值可以没有限制地取任何 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
1
2
3tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': 'Manni'}
print "tinydict['Name']: ", tinydict['Name']以上实例输出结果：
tinydict[‘Name’]: Manni
键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下：
unhashable type: 'list'
内置函数方法
Python字典包含了以下内置函数：
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | cmp(dict1, dict2) | 比较两个字典元素。 |
| 2 | len(dict) | 计算字典元素个数，即键的总数。 |
| 3 | str(dict) | 输出字典可打印的字符串表示。 |
| 4 | 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.has_key(key) | 如果键在字典dict里返回true，否则返回false。Python3 不支持。 |
| 6 | dict.items() | 以列表返回可遍历的(键, 值) 元组数组（2.x） Python3以列表返回一个视图对象 |
| 7 | dict.keys() | 以列表返回一个字典所有的键（2.x版本） Python3 字典 keys() 方法返回一个视图对象。 |
| 8 | dict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| 10 | dict.values() | 以列表返回字典中的所有值（2.x） Python3 返回一个视图对象 |
| 11 | pop(key[,default]) | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() | 返回并删除字典中的最后一对键和值。 |
pop(key[,default])
1 | site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'} |
不存在的 key
{‘name’: ‘菜鸟’, ‘alexa’: 10000, ‘url’: ‘www.runoob.com'}
Python 集合
集合(set)同样是 Python 中的一种数据类型。集合与列表、元组的区别在于，它是一种无序的不重复的元素的序列。无序的意思是，它里面的数据元素是没有顺序的，所以不能用下标来访问它。不重复的意思是，集合里面的元素都是唯一的，不存在重复的数据元素。
创建
可以用大括号｛｝或者 set()函数创建一个集合。例：s={‘lay’,’xi’,’zhang’} another_set = set([3, 4, 5, 6, 7])
但要注意的是，空集合只能用 set()函数来创建。s=set() # 表示创建一个空集合
空集合不能用｛｝来创建，因为｛｝是用来创建一个空字典。
访问
因为集合是无序的，所以不能像之前的类型一样来访问集合中的元素。如下所示：
1 | s={'a','c','h','d','e','hi','li'} |
直接输出集合 s 的值时，它与创建 s 时的顺序是不一样的。而如果要用下标来访问集合中的某一个值，它会报错误。
成员测试
可以判断某个元素是否在集合中，用 in 或 not in。
集合可以进行的运算
在 Python 中，可以用集合实现集合的并、交、差等运算，其含义与数学里的类似。
对于集合 s1 和 s2：
并集用“｜”
s1|s2 求集合 s1 或 s2 中包含的所有元素。交集用“&”
s1&s2 求集合 s1 和
s2 中都包含了的元素。差集用“-”
s1-s2 求集合 s1 中包含而集合 s2 中不包含的元素不同时存在的元素用“^”
s1^s2 求不同时包含于 s1 和 s2
集合的基本操作
设s为一个集合名
添加元素
s.update( x )s.add( x )
add() 方法适用于向集合中添加单个元素，而 update() 方法适用于向集合中添加多个元素。参数可以是列表，元组，字典等删除
s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。s.discard( x )此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。s.pop()我们也可以设置随机删除集合中的一个元素。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
计算集合元素个数用 len。
清空集合用 clear（）。
删除集合用 del。
拷贝一个集合用 copy。
集合内置方法完整列表
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
| len() | 计算集合元素个数 |
选择结构
if
关键词：if else elif
1 | if 表达式 1: |
注意缩进，对齐
逻辑运算用：and or not
match…case
Python 3.10 新增
match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，**_ 可以匹配一切**。
语法格式如下：
1 | match subject: |
case _: 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。
实例
1 | def http_error(status): |
以上是一个输出 HTTP 状态码的实例，输出结果为：
Bad request
一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开，例如：
1 |
|
循环结构
wile
1 | while 判断条件: |
例：
辗转相除法
原理：（A，B）=（B，Q）
1 | x=int(input()) |
while 循环使用 else 语句
如果 while 后面的条件语句为 false 时，则执行 else 的语句块。
语法格式如下：
1 | while <expr>: |
for
1 | for <variable> in <sequence>: |
可以遍历列表、元组、集合、字典等
整数范围值可以配合 range() 函数使用：
实例
1 | # 1 到 5 的所有数字： |
以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体，不会执行 else 子句：
1 | sites = ["Baidu","Google","Runoob","Taobao"] |
range()函数介绍
函数语法range(stop) range(start, stop[, step])
参数说明：
- start: 计数从 start 开始。默认是从 0 开始。例如 range(5) 等价于 range(0， 5)
- stop: 计数到 stop 结束，但不包括 stop。例如：range(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
- step：步长，默认为 1。例如：range(0， 5) 等价于 range(0, 5, 1)
break\continue
pass 语句
Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句，如下实例
实例
1 | while True: |
最小的类:
实例
1 | class MyEmptyClass: |
以下实例在字母为 o 时 执行 pass 语句块:
实例
1 | for letter in 'Runoob': |
执行以上脚本输出结果为：
当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!
Python 函数
函数的定义
在 Python 中，函数的声明和定义是一体的。其基本形式如下：
1 | def 函数名（函数参数）： |
注意：
- def 其实就是 define 定义一个函数。
- Python 中的函数声明时不需要返回类型，由 return 来决定返回值是什么类型。
- 函数体不是大括号包起来，而是缩进。
- 函数的参数可以是一个，也可以是多个，同样，参数也不用指定类型。
- 如果没有 return，函数会自动返回 None。
例：求字符串中大、小写字母的个数。可以定义函数来求字符串中字母的个数，主程序
用来输入字符串。函数定义如下所示：说明：1
2
3
4
5
6
7
8def count_Aa(s):
count=0
for i in s:
if i>='a' and i<='z':
count+=1
if i>='A' and i<='Z':
count+=1
print('字母个数有：',count,'个')（1）本函数是没有返回值的。
（2）本函数的参数只有一个，数据类型根据传入的类型
决定。
（3）可以在主程序中无限次调用本函数。
函数的调用
函数永远写在程序的最前面！！！
空两行！！！
即 Python 函数的定义一定要在函数的调用之前。接上例：求字符串中大、小写字母的个数。可以在主程序中通过函数名直接调用函数，如：
1 | s=input("请输入字符串:") |
Python 函数进阶
关键字参数
Python 中调用函数时，函数参数的传递是比较灵活的，可以按照位置来匹配，也可以按
照参数来匹配。
1 | #函数定义 |
可以看出：
第一种匹配方式，test(x,y)是常用的按位置匹配，把 x 传递给 a，把 y 传递给 b。
第二种匹配方式，test(b=y,a=x)与 test(x,y)的作用是一样的，也是把 x 的值传递给 a，把 y 的值传递给 b，但可以看到，这种方式与第一种方式不同，它是把形参名也放在这里了，在调用时就明确哪个值给哪个形参。这种叫关键字参数。
默认值参数
1 | def test(a='hello',b='cj'): |
任意个数参数
有时候，在定义函数时，不能确定到底有多少个参数，可以用任意个数参数。任意个数参数，只需要在参数前面加*或者**。
1 | def test(*par):#def test(**par) |
*表示将没有匹配的值都放在同一个元组中。**表示将没有匹配的值都放在一个字典中。
全局变量
关键字：global
**global aba**
要用在哪个函数内就在哪个函数内写
Python 模块
模块：将一组功能相关的代码写入一个单独的.py 文件中，需要时进行导入，这个文件
就是模块。
包：有层次的文件目录结构，内部有多个模块或多个子包，一般要有 init.py 这个文件
库：完成一定功能代码的集合，完成的功能一般更加广泛，可以是模块，也可以是包。
导入模块
import xxx
用模块中的函数的时候要注意，一定要加上模块名：如：模块名.函数名
如果只调用某个模块的某个函数，可以只引入该函数，此时可以通过语句：from 模块名 import 函数名 1，函数名 2....
用这种方式引入函数后，在调用时就可以直接用函数名，而不需要加模块名了
自定义模块
在 Python 中，其实每定义一个 Python 文件就是一个模块，可以直接导入，但要注意导入时它的位置最好跟你的文件在同一个文件夹下，否则可能会找不到。
模块别名
有时候模块名字过长，在调用的时候就可以将其替换为简单易记的名字。用关键字 as 来
替换名字。如：import matplot.pyplot as plt
在调用模块 matplot.pyplot 的函数 plot 时就不用 matplot.pyplot.plot()了，可以简单写为plt.plot()。
查询模块内容
用 dir（模块名）函数，它会返回一个排好序的字符串列表，列表中即为模块里定义的变量和函数。
1 | >>>import math |
先 import math 模块，然后再用函数 dir(math)，即返回一个列表。列表中前后有下划线的，像__doc__这些是 math 中的变量，没有下划线的，像 acos 这些是 math 中的函数。
Python random 模块
1 | >>>import random |
常用函数
randint(a,b)，该函数用于生成一个指定范围内的整数。其中参数 a 是下限，参数
b 是上限，生成的随机数 n: a <= n <= b。
多次运行，每次生成的数是不一样的，并且都是整数。randrange([start],stop[,step])，该函数从指定范围内，按指定基数递增的集合中获取一个随机数。函数参数中，[]里的内容可以省。如：
randrange(10,20,2)
是生成从 10 到 20 以内的某一个偶数，即是从[10,12,14,16,18]中随机抽一个数。random()，该函数的功能是随机生成一个[0，1）内的小数。
uniform(x,y)，该函数用于随机生成一个实数，范围在[x,y）以内。
如：uniform(1,10)就是随机生成一个 1～10 之间的实数。choice(sequence)，该函数的功能是从序列 sequence 中任取一个值。这个序列可以是列表、元组等。
random.choice(['123',1,'啊啊啊'])shuffle(x[,random])，该函数的功能是用于将一个列表中的元素打乱，即将列表内的元素随机排列。
sample(sequence,k)，该函数的功能是在序列
sequence中取 k 个元素并随机排列。
Python 文件操作
创建
Python 使用 open() 函数创建或打开文件，格式如下所示：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明如下所示：
file：表示将要打开的文件的路径，也可以是要被封装的整数类型文件描述符。
mode：是一个可选字符串，用于指定打开文件的模式，默认值是 ‘r’（以文本模式打开
并读取）。可选模式如下：
| 模式 | 描述 |
|---|---|
| r | 读取（默认） |
| w | 写入，并先截断文件 |
| x | 排它性创建，如果文件已存在则失败 |
| a | 写入，如果文件存在则在末尾追加 |
| b | 二进制模式 |
| t | 文本模式（默认） |
| + | 更新磁盘文件（读取并写入） |
buffering：是一个可选的整数，用于设置缓冲策略。
encoding：用于解码或编码文件的编码的名称。
errors：是一个可选的字符串，用于指定如何处理编码和解码错误（不能在二进制模式下使用）。
newline：区分换行符。
closefd：如果 closefd 为 False 并且给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态；如果给出文件名，closefd 为 True （默认值），否则将引发错误。
opener：可以通过传递可调用的 opener 来使用自定义开启器。
以 txt 格式文件为例，不用手动创建文件，通过代码方式来创建，如下所示：open('test.txt', mode='w',encoding='utf-8')
执行完上述代码，就为我们创建好了 test.txt 文件。
写入
上面创建好的文件 test.txt 没有任何内容，我们向这个文件中写入一些信息，对于写
操作，Python 文件对象提供了两个函数，如下所示：
| 函数 | 描述 |
|---|---|
| write(str) | 将字符串写入文件，返回写入字符长度 |
| writelines(s) | 向文件写入一个字符串列表 |
我们使用这两个函数向文件中写入一些信息:
1 | ef = open('text.txt,'w',encoding='utf-8') |
上面我们使用了 close() 函数进行关闭操作，如果打开的文件忘记了关闭，可能会对程序造成一些隐患，为了避免这个问题的出现，可以使用 with as 语句，通过这种方式，程序执行完成后会自动关闭已经打开的文件。如下所示：
1 | with open('test.txt', 'w', encoding='utf-8') as wf:# |
读取
之前我们已经向文件中写入了一些内容，现在我们读取一下，对于文件的读操作，Python 文件对象提供了三个函数，如下所示：
| 函数 | 描述 |
|---|---|
| read(size) | 读取指定的字节数（字数？？？），参数可选，无参或参数为负时读取所有 |
| readline() | 读取一行 |
| readlines() | 读取所有行并返回列表 |
我们使用上面三个函数读取一下之前写入的内容，如下所示：
1 | with open('text.txt','r',encoding='utf-8') af rf: |
定位
Python 提供了两个与文件对象位置相关的函数，如下所示：
| 函数 | 描述 |
|---|---|
| tell() | 返回文件对象在文件中的当前位置 |
| file.seek(offset[,whence]) | 将文件对象移动到指定的位置；offset 表示移动的偏移量；whence 为可选参数，值为 0 表示从文件开头起算（默认值）、值为 1 表示使用当前文件位置、值为 2 表示使用文件末尾作为参考点 |
| 示例： |
1 | with open('test.txt','rb+') as f： |
FIFO 队列
First In First Out
1 | q = [] # 新建一个空队列 |
