【Python】内置 方法、语法 合集

本篇博客记录python各大内置方法以及常见语法，查漏补缺用，基于python3。
——持续更新ing

针对本博客形参命名的相关说明：

  • a：任意类型的变量
  • ch：字符变量
  • d：数据变量
  • str & str_开头的：字符串变量
  • v：列表某个元素的值
  • i & j：列表某个元素的下标
  • k：步长
  • l：列表变量
  • way：代表编码方式的字符串
  • file：文件对象
  • path：文件路径
  • m：读写模式
  • dict：字典变量
  • key_str：键字串

一、面向数据类型

id(a)

python所有的对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。

获取变量的id（下面的id值仅供参考，这个id相当于地址，所以在不同电脑，不同程序中运行结果可能不一样），我们用is运算符本质上是比较id值，在本篇博客的运算符模块下会详述。

>>>a=4
>>>id(a)
2583558121840

a.copy()

在python中，数据有两种类型：mutable（可变） 和 immutable （不可变）。对于inmutable object ，函数参数传递是值，对于mutable object，函数参数传递是指针。

  • list ,dict是mutable的；
  • int , string , float ,tuple是inmutable 的。

而.copy方法的一个很大用处就是，如果我们传入函数的形参是一个mutable型变量，那么我们需要先用.copy方法拷贝一份，之后的操作在备份上进行，这样便不会破坏原始数据。

.copy并不相当于给一个新的变量赋值，因为单纯把一个初始化的变量赋值给另一个变量时，对该两个变量的修改对另一个变量都有效，本质上这两个变量的id都是一样的（也就是说指针都指向一个内存单元），只不过两个不同的名字，如果不理解可以看下面的案例：

>>> a=[1,2,3,4,5]
>>> b=a
>>> b[0]=9
>>> b
[9, 2, 3, 4, 5]
>>> a
[9, 2, 3, 4, 5]
>>>#------------------------对比一下-----------------------
>>> a=[1,2,3,4,5]
>>> b=a.copy()
>>> b[0]=9
>>> b
[9, 2, 3, 4, 5]
>>> a
[1, 2, 3, 4, 5]

ord(ch)

将字符ch转为Unicode编码并返回，仅支持一个字符

>>> ord('我')
25105
>>> ord('A')
65
>>> ord('AB')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ord() expected a character, but string of length 2 found

chr(d)

返回d 所对应的 Unicode 字符，参数d必须是整数。

>>> chr(65)
'A'
>>> chr(8364)
'€'
>>> chr(0x1f496)
'💖'

hex(d)

转化成对应16进制字符串

>>>hex(12)        #将参数转化成16进制并以字符串形式表示
'0xc'

int(ch)

转化成对应十进制数据

>>>int('12')#字符串形式的十进制数直接转化成int型
12
>>>int('0x12',16)#字符串形式的16进制数需要额外指定base为16
18

list(str)

返回一个列表，参数多为字符串，list(a)等价于[i for i in a]

>>>a = 'abcd efg'
>>>b = list(a)       #字符串列表化
>>>c=[i for i in a]  
>>>d=list(('a', 'b', 'c', 'd', ' ', 'e', 'f', 'g'))

>>> print(b)
['a', 'b', 'c', 'd', ' ', 'e', 'f', 'g']
>>> print(c)
['a', 'b', 'c', 'd', ' ', 'e', 'f', 'g']
>>> print(d)
['a', 'b', 'c', 'd', ' ', 'e', 'f', 'g']

str.join(l)

把列表l的元素拼接成字符串放到str字符串的末尾

>>>a=['a','b','c']
>>>b = ''.join(a)    #列表字符串化
>>>> print(b)
abc

str.split(ch) & str.partition(ch)

以ch字符或者字符串为界限划分字符串str，转化成列表（不连同ch在内）

>>> a='abc abc'
>>> b=a.split(' ')
>>> print(b)
['abc', 'abc']
>>> c=a.split('a')
>>> print(c)
['', 'bc ', 'bc']

以ch字符或者字符串为界限划分字符串str，转化成三元元组（连同ch在内），第一个是ch左边的字串，第二个是ch本身，第三个是ch右边的字串

>>> a='abc abc abc'
>>> b=a.partition(' ')
>>>print(b)
('abc', ' ', 'abc abc')

二、面向列表

列表常用语法

1. v in l:
    返回true:如果列表l中有元素v
    返回false:如果没有元素v

2. v not in l:
    返回true：如果列表l中没有元素v
    返回false:如果有元素v

3. l1 + l2:
    将列表l1和列表l2连接起来。

4. l * n or n * l:
    将列表s重复n次

5. a,b,c=l
	用列表给变量赋值
	
>>> l=[1,2,3]
>>> a,b,c=l
>>> a
1
>>> b
2
>>> c
3

6. l.sort(*, key = None, reverse = False):
    对l中的元素进行排序，用比较符号'<'，如果元素是不可比较的会发生错误。reverse为True时，用比较符号'>'。

7. l.index(v[, i[, j]):
    返回l列表中第一个v的下标位置（或者下标为i和j之间，第一个v出现的位置的下标）

8. l[0],l[1]=l[1],l[0]
	交换两个元素的位置

9. l.insert

10.将字符串分成等长的若干字符串
>>> string='1234567890'
>>> l = [string[i:i+2] for i in range(0, len(string), 2)]
>>> l
['12', '34', '56', '78', '90']

切片

  • l[i:j]:
    截取下标从i到j的那部分，包括i，不包括j

  • del l[i:j]:
    删除列表l中i到j之间的元素。类似于l[i:j] = []

  • l[i:j:k]:
    截取下标从i到j的那部分，但是每一步跨越k个。

  • l1[i:j] = l2:
    用l2替换列表l1中从i到j之间的元素。

>>> a=[1,2,3,4,5,6]
>>> b=[7,8,9,0]
>>> a[1:1]=b
>>> print(a)
[1, 7, 8, 9, 0, 2, 3, 4, 5, 6]
  • l1[i:j:k] = l2:
    用l2中的元素代替列表l1中从i开始，步长尾k，直到j之间的元素。

l.index(v)

获取列表l中元素v的下标，索引返回第一个符合的下标值。

>>> a=['a','b','c','a']
>>> b=a.index('a')
>>> print(b)
0

l.reverse()

用于把列表l中元素倒置，它不返回任何值，不传入任何参数

>>> a=[1,2,3,4,5,6]
>>> a.reverse()
>>> print(a)
[6, 5, 4, 3, 2, 1]

l.remove(v) & l.insert(i, v) & l.count(v) & l.pop(i) & l.append(v) & l1.extend(l2) & l.clear:

  • l.remove(v)：删除列表l中的第一个v元素
  • l.insert(i, v)：在下标为i的元素前面插入值v，即l[i:i] = [v]
  • l.count(v)：返回列表l中元素v的数目
  • l.pop(i)：返回第i个位置的元素，并将该元素从l中删除
  • l.append(v)：向列表l的尾部追加元v,类似于l[len(l) : len(l)] = [v]
  • l1.extend(l2)：相当于l1+=l2
  • l.clear：清空l的所有元素，类似于 del l[:]
>>> a=[1,2,3,2,4,5]

>>> a.count(2)
2

>>> a.remove(2)
>>> print(a)
[1, 3, 2, 4, 5]

>>> a.insert(1,11)
>>> print(a)
[1, 11, 3, 2, 4, 5]

>> a.pop(1)
11
>>print(a)
[1, 3, 2, 4, 5]

>>>b=[6,7,8]
>>>a.extend(b)
>>>print(a)
[1, 3, 2, 4, 5, 6, 7, 8]

>>>a.clear()
>>>print(a)
[]

l.sort() & sorted(l)

两个都是给列表排序，但有所不同，仔细观察下面的几个代码片。

  • l.sort()：对l这个列表进行修改
>>> a=[1,3,2,5,4,6,8,7]
>>> b=a[:]          #a和b两个变量指向不同列表，对b修改不影响a（分片传入）
>>> b.sort()
>>> print(a)
[1, 3, 2, 5, 4, 6, 8, 7]
>>> print(b)
[1, 2, 3, 4, 5, 6, 7, 8]

>>> a=[1,3,2,5,4,6,8,7]
>>> b=a            #a和b两个变量指向同一个列表，对b修改即为对a修改
>>> b.sort()
>>> print(a)
[1, 2, 3, 4, 5, 6, 7, 8]
>>> print(b)
[1, 2, 3, 4, 5, 6, 7, 8]

sorted(l)：对l修改后返回新的列表，原传入的列表参数值不变

>>> a=[1,3,2,5,4,6,8,7]
>>> b=sorted(a)

>>> print(b)
[1, 2, 3, 4, 5, 6, 7, 8]
>>> print(a)
[1, 3, 2, 5, 4, 6, 8, 7]#a的值是不变的

（1）sorted(l,key=lambda x:x[key_str])

这个是对列表元素为字典（key-value：键值对）时的排序，需要指定按哪个key排序

>>> list_1=[{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
>>> sorted(list_1,key=lambda x:x['age'])  #直接指定键是什么
[{'name': 'a', 'age': 20}, {'name': 'c', 'age': 25}, {'name': 'b', 'age': 30}]

（2）sorted(l,key=lambda x:x[i])

这个是对列表元素为元组时的排序，需要指定第几个元素参与排序。

>>> listA=[('q',2),('c',3),('y',1)]
>>> sorted(listA,key=lambda x:x[-1])#指定每个元组元素的第二个（最后一个）元素参与排序
[('y', 1), ('q', 2), ('c', 3)]

min(l) & max(l)

返回列表l中最小值和最大值

>>> a=[1,2,3,4,5,6]
>>> min(a)
1
>>> max(a)
6

set(l)

取出列表l中唯一的元素并组成一个新的集合并返回

>>> list=['a','a','b','c']
>>> set(list)
{'c', 'b', 'a'}

enumerate(l)

用于获取列表元素及对应的索引值，但返回的并不是一个字典之类，而是一个对象

list=['E','m','0','s','_','E','r','1','t']
for index,column in enumerate(list):
	print(index,column)
#输出：
0 E
1 m
2 0
3 s
4 _
5 E
6 r
7 1
8 t

zip(l1,l2)

在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

三、面向字符和字符串

字符串同样也是满足切片的。

（一）字符串的逆置

>>> print('Em0s_Er1t'[::-1])
t1rE_s0mE

（二）字符串固定长度切割

将字符串s每length个为一组划分

[s[i:i+length] for i in range(0,len(s),length)]

>>> s="Em0s_Er1tEm0s_Er1tEm0s_Er1tEm0s_Er1tEm0s_Er1tEm0s_Er1tEm0s_Er1tEm0s_Er1tEm0s_Er1tEm0s_Er1t"
>>> [s[i:i+9] for i in range(0,len(s),9)]
['Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t', 'Em0s_Er1t']

（三）字节与其它数据类型的转换

1. b'xxxx'与'xxxx'的区别：

有的时候我们发现一些字符串在经过一些函数处理后输出来的值是b'xxxx'格式的，这是由于编码不同，b'xxxx'代表字符是以字节为单位的形式输出的，'xxxx'则是代表字符串以unicode编码的方式输出，有的时候如果要在网络上传输，或保存在磁盘上就需要把str变成以字节为单位的bytes。

——编码

最早的字符串编码是 ASCII 编码，它仅仅对 10 个数字、26 个大小写英文字母以及一些特殊字符进行了编码。ASCII 码做多只能表示 256 个符号，每个字符只需要占用 1 个字节。

随着信息技术的发展，各国的文字都需要进行编码，于是相继出现了 GBK、GB2312、UTF-8 编码等，其中 GBK 和 GB2312 是我国制定的中文编码标准，规定英文字符母占用 1 个字节，中文字符占用 2 个字节；而 UTF-8 是国际通过的编码格式，它包含了全世界所有国家需要用到的字符，其规定英文字符占用 1 个字节，中文字符占用 3 个字节。

2. 字节与字符串的相互转化：

str.encode(encoding=’<way>’)用于将 str 类型用way的方式转换成 bytes 类型，这个过程也称为“编码”。

str.decode(encoding=’<way>’)用于将bytes类型用way的方式转换成str类型，这个过程也称为“解码”。

#字符串转字节
>>> 'Em0s_Er1t'.encode('ascii')
b'Em0s_Er1t'
>>> bytes('Em0s_Er1t','utf-8')
b'Em0s_Er1t'

#字节转字符串
>> b'Em0s_Er1t'.decode()   #无参数时默认以unicode的方式编码
'Em0s_Er1t'
>> b'Em0s_Er1t'.decode('utf-8')
'Em0s_Er1t'

3. 字节与整型数据的相互转化：

整型转字节

>>> (123).to_bytes(4, 'big')
b'\x00\x00\x00{'
>> (123).to_bytes(4, 'little')
b'{\x00\x00\x00'
#to_bytes函数第1个参数表示得到的bytes对象的长度，第2个参数表示字节序。同样，这个转换函数也有signed参数。
#如果参数不对，会有OverflowError异常抛出
>>> (168).to_bytes(1, 'big', signed=False)
b'\xa8'
>>> (168).to_bytes(2, 'big', signed=True)
b'\x00\xa8'
>>> (168).to_bytes(1, 'big', signed=True)
Traceback (most recent call last):
File "", line 1, in
OverflowError: int too big to convert

字节转整型数据

>>> print(int.from_bytes(b'\xf1\xff', byteorder='little', signed=True))  #小端序有符号
-15
>>> print(int.from_bytes(b'\xf1\xff', byteorder='little', signed=False)) #小端序无符号
65521

str.isupper() & str.islower() & str.isnumeric() & str.isalpha()

判断字符串str的大小写

>>>str='abcd'
>>>str.isupper()    #检测字符串中所有的字母是否都为大写。如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回False
False
>>>str.islower()   #检测字符串中所有的字母是否都为小写。如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
True
>>> str.isalpha()   #判断是否全是字母
True
>>> str.isnumeric()   #判断是否全是数字
False

>>> str='a1bd'
>>> str.isalpha()
False
>>> str.isnumeric()
False

str.rjust(width,chr_fill) & str.ljust(width,chr_fill)

将str长度扩充至width，如果用rjust就右对齐，如果用ljust就左对齐，然后空下来的部分用chr_fill字符串变量填补，得到一个新的字符串并返回，而不对原始str做出改变。

注意：

  • 如果没有给chr_fill传入值就默认填入空格；
  • chr_fill参数必须是字符或长度为1的字符串，否则会报错
  • 当字符串本身的长度大于或等于参数width的值时，rjust()方法返回原字符串。
>>> str1="m0s_Er1"
>>> str2=str1.rjust(len(str1)+1,"E")
>>> str2
'Em0s_Er1'
>>> str3=str2.ljust(len(str2)+1,"t")
>>> str3
'Em0s_Er1t'
>>> str1
'm0s_Er1'

>>>str1='bc'
>>>str1.ljust(50,'d')
'bcdddddddddddddddddddddddddddddddddddddddddddddddd'
>>>str1.rjust(50,'a')
'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabc'

str1.strip(str2)

对于str1的头尾，将包含在字符串str2中的连续字符删除。

>>> str1='123321452136782231'
>>> str2='123'
>>> str1=str1.strip(str2)
>>> print(str1)
45213678

其实就相当于下面的代码。

str1='123321452136782231'
str2='123'

for i in (l:=list(str1)):
	if l[0] in str2:
		del l[0]
	if l[-1] in str2:
		del l[-1]
str1=''.join(l)

print(str1)  #45213678

str.format(d)

格式控制字符串

>>> "Em0s_Erit is {} {}".format('a','student')
'Em0s_Erit is a student'

>>> "Em0s_Erit is a {0}".format('student')
'Em0s_Erit is a student'

>>> "Em0s_Erit is {0}-year-old".format(19)
'Em0s_Erit is 19-year-old'

>>> "Em0s_Erit is a {0}-year-old {1}".format(19,'student')
'Em0s_Erit is a 19-year-old student'

>>> "Em0s_Erit is a {age}-year-old {job}".format(age=19,job='student')
'Em0s_Erit is a 19-year-old student'

#用一对大括号实现大括号转义
>>> "{{Em0s_Er1t}}{}".format("Em0s_Er1t")
'{Em0s_Er1t}Em0s_Er1t'

可以用于保留小数点位数

#返回一个字符型
>>>f = 1.216
>>>format(f, ".2f"))
'1.22'

这里再给出一些输出格式。

数字 格式 输出 描述
3.1415926 3.14 保留小数点后两位
3.1415926 3.14 带符号保留小数点后两位
-1 -1 带符号保留小数点后两位
2.71828 3 不带小数
1000000 1,000,000 以逗号分隔的数字格式
0.25 25.00% 百分比格式
1000000000 1.00E+09 指数记法
25 11001 转换成二进制
25 25 转换成十进制
25 31 转换成八进制
25 19 转换成十六进制
数字 格式 输出 描述
5 05 数字补零 (填充左边, 宽度为2)
5 5xxx 数字补x (填充右边, 宽度为4)
10 x10x 数字补x (填充右边, 宽度为4)
13 13 右对齐 (默认, 宽度为10)
13 13 左对齐 (宽度为10)
13 13 中间对齐 (宽度为10)

str.replace(str_old,str_new,times)

将str_old用str_new替代，最多替代times次，但并不对目标字符串本身做出改变

>>> str="Emos_Er1t"
>>> str.replace('o','0')
'Em0s_Er1t'
>>> str
'Emos_Er1t'

str.title()

将str以除字母外的字符为分隔，分割成几个单词，将这几个单词的首字母变成大写，其他字母变成小写

#'em0s_er1t'.title()就是把eM、s、er、t的首字母变成大写，其余的变成小写
>>> 'eM0s_er1t'.title()
'Em0S_Er1T'

str.lower()

将str所有字母转小写。

>>> 'EM0S_ER1T'.lower()
'em0s_er1t'

str.upper()

将str所有字母转大写。

>>> 'em0s_er1t'.upper()
'EM0S_ER1T'

repr(str)

将对象转化为供解释器读取的形式。

>>>s = 'Em0s_Er1t'
>>> repr(s)
"'Em0s_Er1t'"
>>> dict = {'baidu': 'baidu.com', 'google': 'google.com'}
>>> repr(dict)
"{'baidu': 'baidu.com', 'google': 'google.com'}"

f"xxxxxxx"

python的字符串前面加f表示格式化字符串，加f后可以在字符串里面使用用花括号括起来的变量和表达式，如果字符串里面没有表达式，那么前面加不加f输出应该都一样

>>> writer = {'name': 'Em0s_Er1t', 'age': 20}
>>> print(f"The writer is {writer['name']}, aged {writer['age']}.")
The writer is Em0s_Er1t, aged 20.

str.center(width,chr)

该方法返回一个原字符串居中，并使用chr字符填充至长度 width 的新字符串。

注意：width是返回的字符串的总长度

>>> s='Em0s_Er1t!'
>>> s.center(20,'!')
'!!!!!Em0s_Er1t!!!!!!'

四、面向文件读写

open(path，m) & file.close()

  • open(path，m)

关于文件路径

  • 相对路径：若要打开的文件在当前文件的同级文件夹中或者在其子文件夹中可以采用相对路径。. 表示py文件当前所处的文件夹的绝对路径，..表示py文件当前所处的文件夹上一级文件夹的绝对路径
    例如：a_file文件夹下的xxx.py想打开的是b_file下的文件，xxx.py和b_file都在文件目录之下，两者是同级目录，因此操作就是在当前目录向下搜索，因此就可以用下面8种打开方式任选其一即可。
#关于with open……后面会细述

#字符串前面加个`r`可以使字符串不转义
with open(r"b_file\a.txt","r") as file:
with open(r".\b_file\a.txtx", "r") as file:
#用/可以避免转义
with open("b_file/a.txt","r") as file:
with open("./b_file/a.txtx", "r") as file:
#双斜杠转义
with open("b_file\\a.txt","r") as file:
with open(".\\b_file\\a.txtx", "r") as file:

而下面这样打开是错误的，因为python会把\译为与后面的字符a搭配成为转义字符\a

with open("b_file\a.txt","r") as file:
with open(".\b_file\a.txtx", "r") as file:
  • 绝对路径：绝对路径只需要要打开的文件路径全名即可

以m的方式打开path路径的文件，返回这个文件的文件对象，m可取如下值：

模式（m） 说明 指针初始位置 如果文件不存在
r 以只读的方式打开文件 文件开头 报错
w 打开一个文件写入内容。注意：这种模式是从头写入，会覆盖之前已有的内容 文件开头 创建
a 与w一样是写入文件。不同之处在于它不是从头写入，而是在已有文件后面接着写 文件结尾 创建
rb 和r基本相同，不同之处在于以二进制的格式打开文件 文件开头 报错
wb 和w基本相同，不同之处在于以二进制的格式打开文件 文件开头 创建
ab 和a基本相同，不同之处在于以二进制的格式打开文件 文件结尾 创建
r+、w+、a+、rb+、wb+，ab+ 以可读可写的方式打开 r,w：开头。a：结尾 r：报错。w,a：创建

path的斜杠最好用‘/’，不要用‘\’，因为后者很容易被误识成转义符，有时候会报错

  • file.close()

关闭文件（虽然python会在一个文件不用后自动关闭文件，但不能保证）

  • with open(path,m) as file:

为了防止打开文件产生错误而导致不能关闭文件，可以试试这种方法，这样就不用额外进行关闭文件的操作。

file.read(n)

以byte为单位（输出是以b'xxx'的形式，后面不再赘述）读取长度为n的字符串。

五、面向字典

字典是无序集。

1.添加键值对

>>> dict={1:'Em0s',2:'_'}
>>> dict[3]='Er1t'
>>> dict
{1: 'Em0s', 2: '_', 3: 'Er1t'}

2.删除键值对

>>> dict={1:'Em0s',2:'_',3:'Er1t'}
>>> del dict[2]
>>> dict
{1: 'Em0s', 3: 'Er1t'}

3.遍历字典

  • 遍历所有键值对。
    for key,value in dict.items():
  • 遍历所有键。
    for key in dict.keys():

#或者for key in dict:
  • 遍历所有值。
    for key in dict.values():

4.创建字典

创建一个字典除了用赋值语句，也可以用dict函数

>>> dict(name="Em0s_Er1t")
{'name': 'Em0s_Er1t'}

5.清空字典

>>> dict={1:"a",2:"b",3:"c"}
>>> dict.clear()
>>>dict
{}

6.字典转列表

>>> dict={1:"a",2:"b",3:"c"}
>>> list(dict)
[1, 2, 3]
>>> list(dict.values())
['a', 'b', 'c']
>>> list(dict.keys())
[1, 2, 3]
>>> list(dict.items())
[(1, 'a'), (2, 'b'), (3, 'c')]

7.列表转字典

>>> key=[1, 2, 3]
>>> value=['a', 'b', 'c']
>>> dict(zip(key, value))
{1: 'a', 2: 'b', 3: 'c'}

8.字典排序

原理是创建一个新的字典。

  • 按值升序排
    dict = {'c':20,'a':12,'b':5}
sorted_dict = {key: value for key, value in sorted(dict.items(), key=lambda item: item[1])}
print(sorted_dict)
#输出：{'b': 5, 'a': 12, 'c': 20}
  • 按值降序排
    dict = {'c':20,'a':12,'b':5}
sorted_dict = {key: value for key, value in sorted(dict.items(), key=lambda item: item[1],reverse=True)}
print(sorted_dict)
#输出：{'c': 20, 'a': 12, 'b': 5}

9.dict.get(key, default=None)

返回指定键的值，如果键不在字典中返回 default 设置的默认值。

>>>dict={1:'Em0s',2:'_',3:'Er1t'}
>>>dict.get(1)
'Em0s'

六、模块导入机理

一个模块被导入时， PVM(Python Virtual Machine) 会在后台从一系列路径中搜索该模块，其搜索过程如下：

  • 在当前目录下搜索该模块
  • 在环境变量 PYTHONPATH 中指定的路径列表中依次搜索
  • 在 python 安装路径中搜索

事实上， PVM 通过变量 sys.path 中包含的路径来搜索，这个变量里面包含的路径列表就是上面提到的这些路径信息。

模块的搜索路径都放在了 sys.path 列表中，如果缺省的 sys.path 中没有含有自己的模块或包的路径，可以动态的加入 (sys.path.apend) 即可。

事实上， Python 中所有加载到内存的模块都放在 sys.modules 。当 import 一个模块时首先会在这个列表中查找是否已经加载了此模块，如果加载了则只是将模块的名字加入到正在调用 import 的模块的 Local 名字空间中。如果没有加载则从 sys.path 目录中按照模块名称查找模块文件，模块文件可以是 py 、 pyc 、 pyd ，找到后将模块载入内存，并加入到 sys.modules 中，并将名称导入到当前的 Local 名字空间。

A.py如何调用B.py内的add方法

  • B.py
def add(x,y):
 print('和为：%d'%(x+y))

class B:
 def __init__(self,xx,yy):
     self.x=xx
     self.y=yy
 def sub(self):
     print("x和y的差为：%d"%(self.x-self.y))

1. A.py和B.py在同一文件夹下

调用函数时A.py为

import B
B.add(1,2)

或者

from B import add
add(1,2)

调用类时A.py为

from B import B
b=B(2,3)
b.sub()

2. A.py和B.py在不同文件夹下

若B.py的路径是E:\Python\B.py

A.py为

import sys
sys.path.append(r'E:\Python')
'''python import模块时，是在sys.path里按顺序查找的。
sys.path是一个列表，里面以字符串的形式存储了许多路径。
使用B.py文件中的函数需要先将他的文件路径放到sys.path中'''
import B
b=B.B(2,3)
b.sub()

七、lambda

原型：lambda arguments : expression

  • lambda函数可接受任意数量的参数
  • lambda函数是一种小的匿名函数。

使用lambda函数可以帮助我们用一个函数定义生成两个函数，如下：

def myfunc(n):
	return lambda a : a * n

fun1 = myfunc(2)
fun2 = myfunc(3)

print(fun1(11)) 
#输出：22
print(fun2(11))
#输出：33

八、其他函数

[1] map(function,list/str/tuple)

对列表或者字符串或者元组中的每个元素使用function函数

#把字符串的各个字符转ASCII编码
>>> list(map(ord,"Em0s_Er1t"))
[69, 109, 48, 115, 95, 69, 114, 49, 116]

#把[1,2,3]里的元素转字符串
>>> list(map(str,[1,2,3]))
['1','2','3']

#自定义函数同样支持
def square(variable):
	return variable*variable
print(list(map(square,range(10))))
#输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[2] isinstance(variable,type)

检查variable变量是否是给定类型

>>> variable="Em0s_Er1t"
>>> isinstance(variable,str)
True

[3] assert

在程序中插入一个断点，如果跟在后面的相当于bool值False，就会抛出一个AssertionError异常。

例如下面的代码运行之后，由于list肯定不是str型，所以就不会接着向下运行，而是抛出一个AssertionError异常。

list=[1,2,3]
assert isinstance(list,str)
print("==========")

输出结果如下：

Traceback (most recent call last):
  File "XXXX", line 2, in <module>
    assert isinstance(list,str)
AssertionError

[4] round()

保留小数点位数。

>>> f=1.2169
>>> round(f,3)
1.217

九、运算符

（一）基本运算符

Python提供了很多有用的运算符，除去一些常用的，下面的是参考了一个博主的《python中的各种符号》整理一些相对冷门与需要进行区分的运算符罗列如下。
运算符 描述
:= 海象运算符，可以构建赋值表达式并写在语句中，一个很大的用处就是简化你的代码，比如
[y for x in names if (y := f(x))]
is&== python所有的对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。

  • is：用于判断两个对象的 id 是否相同，相当于 id(变量1)==id(变量2)。

  • ==：用于判断两个对象的 值 是否相同。

    通过下面的例子可以帮助我们了解工作原理：
    >>> x=[4,5,6]
    >>> y=x
    >>> z=[4,5,6]
    >>> x==y
    True
    >>> x==z
    True
    >>> x is y
    True
    >>> x is z
    False
    		•
    集合运算
    >>>a = set([1,2,3])
    >>>b = set([2,3,4,5,6])
    <> 不等于，比较两个对象是否不相等 (a <> b) 。这个运算符类似 != 。
    & 求交集，如print(a&b) #{2, 3}
    | 求并集，如print(a|b) #{1, 2, 3, 4, 5, 6}
    - 求差集，与交集取差，如print(a-b) #{1}
    ^ 求交集的补集，如print(a^b) #{1, 4, 5, 6}
    -> python函数定义的函数名后面，为函数添加元数据,描述函数的返回类型，从而方便开发人员使用

    （二）单下划线_

    参考：[【Python】单下划线与双下划线的区别 ](https://cloud.tencent.com/developer/article/1516883#:~:text=Python用下划线作为前缀和后缀指定特殊变量和定义方法，主要有如下四种形式： 1、在交互式解释器中，单下划线“_”代表的是上一条执行语句的结果。,如果单下划线前面没有语句执行，交互式解释器将会报单下划线没有定义的错误。 也可以对单下划线进行赋值操作，这时单下划线代表赋值的结果。)

    1. 在交互式解释器中代表上一条执行语句的结果。

    如果单下划线前面没有语句执行，交互式解释器将会报单下划线没有定义的错误。也可以对单下划线进行赋值操作，这时单下划线代表赋值的结果。但是一般不建议对单下划线进行赋值操作，因为单下划线内建标识符。

    >>> _
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '_' is not defined
>>> name='Em0s_Er1t'
>>> name
'Em0s_Er1t'
>>> _
'Em0s_Er1t'

    2. 作为特殊的临时变量。

    如果一个变量在后面不会再用到，并且不想给这个变量定义名称，这时就可以用单下划线作为临时性的变量。

    #对for循环语句遍历的结果元素并不感兴趣，此时就可以用单下划线表示。
for _ in range(5):
    print("Em0s_Er1t")

    3. 放在名称前代表私有属性或方法

    在属性和方法前面加上单下划线指定属性和方法是“私有”的。

    但是Python不像Java一样具有私有属性、方法、类，在属性和方法之前加单下划线，只是代表该属性、方法、类只能在内部使用，是API中非公开的部分。如果用from … import * 和 from … import * 时，这些属性、方法、类将不被导入，除非在__all__列表中包含了以单下划线开头的属性、方法以及类，

    关于\(\_\_all\_\_\)有个注意点：

    一旦定义了\(\_\_all\_\_\)，那么别的不在\(\_\_all\_\_\)列表内的变量，不管名称前面有没有下划线，如果在外部导入了该变量都会报错；如果没有定义，那么只有在导入了有下划线前缀的变量时才会报错。（如下）

    # Test.py 文件

#将普通属性、单下划线的属性、方法、和类加入__all__列表
__all__=["value"，"_otherValue","_otherMethod","_WClass"]

#普通属性
value="Java"

#单下划线属性
_otherValue="Python"

#普通方法
def method():
    print("我是普通方法")

#单下划线方法
def _otherMethod():
    print("我是单下划线方法")

#普通类
class PClass(object):
    def __init__(self):
        print("普通类的初始化")

#单下划线类
class _WClass(object):
    def __init__(self):
        print("单下划线类的初始化")

    >>> from Test import *
>>> value
'Java'
>>> _otherValue
'Python'
>>> method()      #
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    method()
NameError: name 'method' is not defined
>>> _otherMethod()
我是单下划线方法
>>> p=PClass()
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    p=PClass()
NameError: name 'PClass' is not defined
>>> w= _WClass()
单下划线类的初始化

    （三）双下划线__

    1. __name

    以双下划线开头的属性、方法表示避免父类的属性和方法被子类轻易的覆盖，一般不建议这样定义属性和方法，除非你自己将要做什么。

    2. __name__

    名称前后加双下划线表明是Python解释器自己调用的方法/类（魔法方法）。一般不建议在程序中调用。比如，当调用len()方法时，实际上调用了 Python中内部的 __len__方法.

    这类方法是Python内部定义的方法，程序员可以对这些方法重写，这样Python就可以转而调用这个重写的方法或者利用重写的操作符。

    class CrazyNumber(object):
    def __init__(self, n): 
        self.n = n 
    def __add__(self, other): 
        return self.n - other 
    def __sub__(self, other): 
        return self.n + other 
    def __str__(self): 
        return str(self.n+1) 

num = CrazyNumber(10) 
print(num)      # 10
print(num + 5)  # 5
print(num - 20) # 30
print(str(num)) # 11

    （四）@函数装饰器

    参考：http://c.biancheng.net/view/2270.html

    十、魔法方法

    我们在调用python内置的方法时，Python内部执行的其实是被双下划线包裹的魔法方法，我们也可以对这些方法进行重写、调用。

    参考：

    基本的魔法方法 含义
    __ new__(cls[, …]) 1. __ new__ 是在一个对象实例化的时候所调用的第一个方法2. 它的第一个参数是这个类，其他的参数是用来直接传递给 __ init__ 方法 3. __ new__ 决定是否要使用该 __ init__ 方法，因为 __ new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __ new__ 没有返回实例对象，则 __ init__ 不会被调用 4. __ new__ 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
    __ init__(self[, …]) 构造器，当一个实例被创建的时候调用的初始化方法
    __ del__(self) 析构器，当一个实例被销毁的时候调用的方法
    __ call__(self[, args…]) 允许一个类的实例像函数一样被调用：x(a, b) 调用 x.__ call__(a, b)
    __ len__(self) 定义当被 len() 调用时的行为
    __ repr__(self) 定义当被 repr() 调用时的行为
    __ str__(self) 定义当被 str() 调用时的行为
    __ bytes__(self) 定义当被 bytes() 调用时的行为
    __ hash__(self) 定义当被 hash() 调用时的行为
    __ bool__(self) 定义当被 bool() 调用时的行为，应该返回 True 或 False
    __ format__(self, format_spec) 定义当被 format() 调用时的行为
    有关属性的魔法方法 含义
    __ getattr__(self, name) 定义当用户试图获取一个不存在的属性时的行为
    __ getattribute__(self, name) 定义当该类的属性被访问时的行为
    __ setattr__(self, name, value) 定义当一个属性被设置时的行为
    __ delattr__(self, name) 定义当一个属性被删除时的行为
    __ dir__(self) 定义当 dir() 被调用时的行为
    __ get__(self, instance, owner) 定义当描述符的值被取得时的行为
    __ set__(self, instance, value) 定义当描述符的值被改变时的行为
    __ delete__(self, instance) 定义当描述符的值被删除时的行为
    比较操作符魔法方法 含义
    __ lt__(self, other) 定义小于号的行为：x < y 调用 x.__ lt__(y)
    __ le__(self, other) 定义小于等于号的行为：x <= y 调用 x.__ le__(y)
    __ eq__(self, other) 定义等于号的行为：x == y 调用 x.__ eq__(y)
    __ ne__(self, other) 定义不等号的行为：x != y 调用 x.__ ne__(y)
    __ gt__(self, other) 定义大于号的行为：x > y 调用 x.__ gt__(y)
    __ ge__(self, other) 定义大于等于号的行为：x >= y 调用 x.__ ge__(y)
    算数运算符魔法方法 含义
    __ add__(self, other) 定义加法的行为：+
    __ sub__(self, other) 定义减法的行为：-
    __ mul__(self, other) 定义乘法的行为：*
    __ truediv__(self, other) 定义真除法的行为：/
    __ floordiv__(self, other) 定义整数除法的行为：//
    __ mod__(self, other) 定义取模算法的行为：%
    __ divmod__(self, other) 定义当被 divmod() 调用时的行为
    __ pow__(self, other[, modulo]) 定义当被 power() 调用或 ** 运算时的行为
    __ lshift__(self, other) 定义按位左移位的行为：<<
    __ rshift__(self, other) 定义按位右移位的行为：>>
    __ and__(self, other) 定义按位与操作的行为：&
    __ xor__(self, other) 定义按位异或操作的行为：^
    __ or__(self, other) 定义按位或操作的行为：
    反运算魔法方法 含义
    __ radd__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rsub__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rmul__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rtruediv__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rfloordiv__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rmod__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rdivmod__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rpow__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rlshift__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rrshift__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rand__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ rxor__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    __ ror__(self, other) （与上方相同，当左操作数不支持相应的操作时被调用）
    增量赋值运算魔法方法 含义
    __ iadd__(self, other) 定义赋值加法的行为：+=
    __ isub__(self, other) 定义赋值减法的行为：-=
    __ imul__(self, other) 定义赋值乘法的行为：*=
    __ itruediv__(self, other) 定义赋值真除法的行为：/=
    __ ifloordiv__(self, other) 定义赋值整数除法的行为：//=
    __ imod__(self, other) 定义赋值取模算法的行为：%=
    __ ipow__(self, other[, modulo]) 定义赋值幂运算的行为：**=
    __ ilshift__(self, other) 定义赋值按位左移位的行为：<<=
    __ irshift__(self, other) 定义赋值按位右移位的行为：>>=
    __ iand__(self, other) 定义赋值按位与操作的行为：&=
    __ ixor__(self, other) 定义赋值按位异或操作的行为：^=
    __ ior__(self, other) 定义赋值按位或操作的行为：
    容器类型赋值运算魔法方法 含义
    __ len__(self) 定义当被 len() 调用时的行为（返回容器中元素的个数）
    __ getitem__(self, key) 定义获取容器中指定元素的行为，相当于 self[key]
    __ setitem__(self, key, value) 定义设置容器中指定元素的行为，相当于 self[key] = value
    __ delitem__(self, key) 定义删除容器中指定元素的行为，相当于 del self[key]
    __ iter__(self) 定义当迭代容器中的元素的行为
    __ reversed__(self) 定义当被 reversed() 调用时的行为
    __ contains__(self, item) 定义当使用成员测试运算符（in 或 not in）时的行为
    一元操作符魔法方法 含义
    __ pos__(self) 定义正号的行为：+x
    __ neg__(self) 定义负号的行为：-x
    __ abs__(self) 定义当被 abs() 调用时的行为
    __ invert__(self) 定义按位求反的行为：~x
    上下文管理（with 语句）魔法方法 含义
    __ enter__(self) 1.定义当使用 with 语句时的初始化行为2. __ enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
    __ exit__(self, exc_type, exc_value, traceback) 1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么2.一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作。
    类型转换魔法方法 含义
    __ complex__(self) 定义当被 complex() 调用时的行为（需要返回恰当的值）
    __ int__(self) 定义当被 int() 调用时的行为（需要返回恰当的值）
    __ float__(self) 定义当被 float() 调用时的行为（需要返回恰当的值）
    __ round__(self[, n]) 定义当被 round() 调用时的行为（需要返回恰当的值）
    __ index__(self) 1. 当对象是被应用在切片表达式中时，实现整形强制转换2.如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 __ index__3. 如果 __ index__ 被定义，则 __ int__ 也需要被定义，且返回相同的值

    （一）__doc__

    通常我们在编写完一个方法或者类的时候，为了方便使用它的人知道其功能，我们会在其内部开头位置写上帮助文档（本质是字符串），\(\_\_doc\_\_\)其实就是用于获取开发者提供的说明文档。

    help() 函数底层就是借助 doc 属性实现的。

    class Person(object):
    '''由Em0s_Er1t编写'''
    def __init__(self, first_name, last_name):
        '''构造函数'''
        self.first_name = first_name
        self.last_name = last_name
 

person = Person("Em0s", "Er1t")
print(person.__doc__)
print(person.__init__.__doc__)

#由Em0s_Er1t编写
#构造函数

    （二）__file__

    用于查看该模块或者包文件的具体存储位置，通过调用 __file__ 属性输出的绝对路径，我们可以很轻易地找到该模块（或包）的源文件。

    import os
print(os.__file__)
#D:\Python3.9\lib\os.py

    （三）__dict__

    __dict__用于查看对象内部所有属性名和属性值组成的字典

    • 在 Python 类的内部，类属性和实例属性都是以字典的形式进行存储，其中属性名作为键，而值作为该键对应的值。

    • 具有继承关系的父类和子类来说，父类有自己的 __dict__，同样子类也有自己的__dict__，它不会包含父类的 __dict__。

    • 借助由类实例对象调用 __dict__ 属性获取的字典，可以使用字典的方式对其中实例属性的值进行修改

    class Person(object):
    '''由Em0s_Er1t编写'''
    def __init__(self, first_name, last_name):
        '''构造函数'''
        self.first_name = first_name
        self.last_name = last_name

person = Person("Em0s", "Er1t")
print(person.__dict__)  #显示person实例的属性
print(Person.__dict__)  #显示Person类的属性
person.__dict__["first_name"]='yqc'
print(person.__dict__)  #显示person实例的属性

#{'first_name': 'Em0s', 'last_name': 'Er1t'}
#{'__module__': '__main__', '__doc__': '由Em0s_Er1t编写', '__init__': <function Person.__init__ at 0x0000029C98427D30>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
#{'first_name': 'yqc', 'last_name': 'Er1t'}

    （四）__name__

    我们知道，对于一个py文件，要么作为脚本文件直接运行，要么就被其他直接运行的py文件作为模块导入，而if __name__ == ‘main’:的作用就是被它包裹的语句只有在当前脚本文件被直接运行才执行。

    其实每个python模块都包含内置的变量 __name__，当该模块被直接执行的时候，__name__ 就被赋值等于 “__main__”，__name__ == 'main' 结果为真；而不直接执行的模块，变量 __name__始终指当前执行模块的名称。

    下面举个栗子：

    test.py文件如下
    在这里插入图片描述
    直接运行test.py的结果如下：
    在这里插入图片描述
    test1.py文件如下，两个都处于同一目录下，test1.py导入test模块。
    在这里插入图片描述
    直接运行test1.py的结果如下，因为print("__name__:{}".format(__name__))语句打印出的结果是所在文件的__name__值，由于test.py被test1.py作为模块导入，所以运行结果的第一行打印出的是test.py的__name__值，第二行是当前文件的__name__值。
    在这里插入图片描述

    十一、第三方模块

    （一）string

    1. 生成字符表

    string.digits          #数字0~9
string.ascii_letters   #所有字母（大小写）
string.lowercase       #所有小写字母
string.printable       #可打印字符的字符串
string.punctuation     #所有标点
string.uppercase       #所有大写字母

    （二）PIL（Pillow）

    Image 模块 — Pillow (PIL Fork) 8.4.0 文档 (osgeo.cn)

    关于坐标系

    python图像库使用笛卡尔像素坐标系，左上角有（0,0）。请注意，坐标指的是隐含的像素角；定位为（0，0）的像素的中心实际上位于（0.5，0.5）。

    坐标通常作为2元组（x，y）传递给库。矩形表示为4个元组，首先给出左上角。例如，覆盖800x600像素图像的矩形写为（0，0，800，600）。

    PIL.Image.size

    返回(width, height)

    PIL.Image.mode

    图片模式。图片使用的像素格式，典型的格式有 “1”, “L”, “RGB”, or “CMYK”。

    PIL.Image.new(mode, size, color=0)

    用于创建一个新的图片对象。

    参数

    1. mode：模式，通常用"RGB"这种模式，除此之外有其他格式

      • 模式“1”为二值图像，非黑即白。但是它每个像素用8个bit表示，0表示黑，255表示白。下面我们将lena图像转换为“1”图像。

      • 模式“L”为灰色图像，它的每个像素用8个bit表示，0表示黑，255表示白，其他数字表示不同的灰度。在PIL中，从模式“RGB”转换为“L”模式是按照下面的公式转换的：

        L = R * 299/1000 + G * 587/1000+ B * 114/1000

      • 模式“P”为8位彩色图像，它的每个像素用8个bit表示，其对应的彩色值是按照调色板查询出来的。

      • 模式“RGBA”为32位彩色图像，它的每个像素用32个bit表示，其中24bit表示红色、绿色和蓝色三个通道，另外8bit表示alpha通道，即透明通道。alpha通道全部设置为255，即完全不透明。

      • 模式“CMYK”为32位彩色图像，它的每个像素用32个bit表示。模式“CMYK”就是印刷四分色模式，它是彩色印刷时采用的一种套色模式，利用色料的三原色混色原理，加上黑色油墨，共计四种颜色混合叠加，形成所谓“全彩印刷”。四种标准颜色是：C：Cyan = 青色，又称为‘天蓝色’或是‘湛蓝’M：Magenta = 品红色，又称为‘洋红色’；Y：Yellow = 黄色；K：Key Plate(blacK) = 定位套版色（黑色）。
        从实例中可以得知PIL中“RGB”转换为“CMYK”的公式如下：

        C = 255 - R
M = 255 - G
Y = 255 - B
K = 0

      • 模式“YCbCr”为24位彩色图像，它的每个像素用24个bit表示。YCbCr其中Y是指亮度分量，Cb指蓝色色度分量，而Cr指红色色度分量。人的肉眼对视频的Y分量更敏感，因此在通过对色度分量进行子采样来减少色度分量后，肉眼将察觉不到的图像质量的变化。
        模式“RGB”转换为“YCbCr”的公式如下：

        Y= 0.257*R+0.504*G+0.098*B+16
Cb = -0.148*R-0.291*G+0.439*B+128
Cr = 0.439*R-0.368*G-0.071*B+128

      • 模式“I”为32位整型灰色图像，它的每个像素用32个bit表示，0表示黑，255表示白，(0,255)之间的数字表示不同的灰度。在PIL中，从模式“RGB”转换为“I”模式是按照下面的公式转换的：

        I = R * 299/1000 + G * 587/1000 + B * 114/1000

        模式“I”与模式“L”的结果是完全一样，只是模式“L”的像素是8bit，而模式“I”的像素是32bit。

      • 模式“F”为32位浮点灰色图像，它的每个像素用32个bit表示，0表示黑，255表示白，(0,255)之间的数字表示不同的灰度。在PIL中，从模式“RGB”转换为“F”模式是按照下面的公式转换的：

        F = R * 299/1000+ G * 587/1000 + B * 114/1000

    2. size：生成的图像大小

    3. color：生成图像的颜色，默认为0，即黑色。

    PIL.Image.resize(size,Image.ANTIALIAS)

    实现图片的裁剪缩放

    参数：

    • size ：请求的大小，以像素为单位，为一个二元组：（width，height）。
    • 重采样：可选的重采样过滤器。 这可以是PIL.Image.NEAREST（使用最近的邻居），PIL.Image.BILINEAR（线性插值），PIL.Image.BICUBIC（三次样条插值）或PIL.Image.LANCZOS（高质量的下采样滤波器）之一 ）。 如果省略，或者图像的模式为“ 1”或“ P”，则将其设置为PIL.Image.NEAREST。

    PIL.Image.getpixel(xy)

    用来获取图像中某一点的像素的RGB颜色值，getpixel的参数是一个像素点的坐标。对于图像的不同的模式，函数返回的值不同。

    PIL.Image.putpixel(xy,value)

    修改给定位置的像素。对于单波段图像，颜色以单个数值表示，对于多波段图像，颜色以元组表示。除此之外，p图像还接受rgb和rgba元组。

    （三）graphviz

    python3 graphviz入门教程_编程杂记-CSDN博客_graphviz python

    graphviz · PyPI

    python graphviz的使用(画图工具) - 我用python写Bug - 博客园 (cnblogs.com)

    posted @ 2021-09-20 13:12  Em0s_Erit  阅读(394)  评论(0)  编辑  收藏  举报