导图社区 Python资料整理
- 335
- 55
- 8
- 举报
Python资料整理
此思维导图为董付国老师《python程序设计》一书的学习资料整理，总结了最最要和最常用的知识点，方便你快速入门。其中numpy更是总结了与matlab相似的数组用法。对于熟悉matlab的人来说，可以快速上手。
编辑于2020-07-10 18:53:24
- 相似推荐
- 大纲
Python资料整理
I. 运算符、表达式与内置对象
常用内置对象
在python中处理的一切都是对象
内置对象可直接使用，如数字、字符串、列表、del等。
非内置对象需要导入模块才能使用，如正弦函数sin(x)
变量
在Python中，不需要事先声明变量名及其类型
Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。
id()函数用来查看对象的内存地址
数字
Python内置支持复数类型及其运算，并且形式与数学上的复数完全一致
x = 3 + 4j #使用j或J表示复数虚部
数字中间位置使用单个下划线作为分隔来提高数字的可读性（"_"不能出现字开头和结尾，也不能连续出现）
>>> 1_000_000 1000000
标准库fractions中的Fraction对象支持分数及其运算
>>> from fractions import Fraction
>>> x = Fraction(3, 5) #创建分数对象 3/5
>>> x.numerator #查看分子 3
>>> x.denominator #查看分母 5
>>> x + y #支持分数之间的四则运算，自动进行通分 Fraction(36, 35)
标准库fractions和decimal中提供的Decimal类实现了更高精度实数的运算
>>> from fractions import Decimal
>>> 1 / 9 #内置的实数类型
0.1111111111111111
>>> Decimal(1/9) #高精度实数
Decimal('0.111111111111111104943205418749130330979824066162109375')
字符串
在Python中，没有字符常量和变量的概念，只有字符串类型的常量和变量，单个字符也是字符串
使用单引号、双引号、三单引号、三双引号作为定界符（delimiter）来表示字符串
不同的定界符之间可以互相嵌套
加号运算符 "+"连接字符串
字符串与字节串
对str类型的字符串调用其encode()方法进行编码得到bytes字节串，对bytes字节串调用其decode()方法并指定正确的编码格式则得到str字符串。
>>> type('Hello world') #默认字符串类型为str
<class 'str'>
>>> type(b'Hello world') #在定界符前加上字母b表示字节串
<class 'bytes'>
>>> 'Hello world'.encode('utf8') #使用utf8编码格式进行编码
b'Hello world'
>>> 'Hello world'.encode('gbk') #使用gbk编码格式进行编码
b'Hello world'
>>> '董付国'.encode('utf8') #对中文进行编码
b'\xe8\x91\xa3\xe4\xbb\x98\xe5\x9b\xbd'
>>> _.decode('utf8') #一个下划线表示最后一次正确输出结果
'董付国'
>>> '董付国'.encode('gbk')
b'\xb6\xad\xb8\xb6\xb9\xfa'
>>> _.decode('gbk') #对bytes字节串进行解码
'董付国'
列表、元组、字典、集合

>>> x_list = [1, 2, 3] #创建列表对象
>>> x_tuple = (1, 2, 3) #创建元组对象
>>> x_dict = {'a':97, 'b':98, 'c':99} #创建字典对象
>>> x_set = {1, 2, 3} #创建集合对象
>>> print(x_list[1]) #使用下标访问指定位置的元素
2
>>> print(x_tuple[1]) #元组也支持使用序号作为下标
2
>>> print(x_dict['a']) #字典对象的下标是“键”
97
>>> 3 in x_set #成员测试
True
运算符优先级
算术运算符优先级最高>其次是位运算符>成员测试运算符>关系运算符>逻辑运算符等。
算术运算符遵循“先乘除，后加减”的基本运算原则。
技巧：弄不清就用括号
算术运算符
“+”可用于算术加法，还可以用于列表、元组、字符串的连接（但不支持不同类型的对象之间相加或连接）
>>> [1, 2, 3] + [4, 5, 6] #连接两个列表
[1, 2, 3, 4, 5, 6]
>>> (1, 2, 3) + (4,) #连接两个元组
(1, 2, 3, 4)
>>> 'abcd' + '1234' #连接两个字符串
'abcd1234'
>>> 'A' + 1 #不支持字符与数字相加，抛出异常
TypeError: Can't convert 'int' object to str implicitly
>>> True + 3 #Python内部把True当作1处理
4
>>> False + 3 #把False当作0处理
3
“*”可用于算术乘法，以及列表、元组、字符串的复制式增加操作。（字典和集合不支持与整数的相乘，因为其中的元素是不允许重复的）
/ 除法运算 3/2 =1.5
// 求整数商 15//4=3 15.0//4=3.0 -15//4=-4 (向下取整)
% 求余数
**运算符表示幂乘
>>> 3 ** 2 #3的2次方，等价于pow(3, 2)
9
关系运算符最大的特点是可以连用
>>> 1 < 3 < 5 #等价于1 < 3 and 3 < 5 True
in 用于测试成员是否在其中
>>> 3 in [1, 2, 3] #测试3是否存在于列表[1, 2, 3]中
True
>>> for i in (3, 5, 7): #循环，成员遍历
print(i, end='\t')
3 5 7
is 比较两对象的内存地址是否一致
位运算符只能用于整数
其内部执行过程为：首先将整数转换为二进制数，然后右对齐，必要的时候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字返回。
位与运算规则为1&1=1、1&0=0&1=0&0=0，位或运算规则为1|1=1|0=0|1=1、0|0=0，位异或运算规则为1^1=0^0=0、1^0=0^1=1。
左移位时右侧补0，每左移一位相当于乘以2；右移位时左侧补0，每右移一位相当于整除以2。
交集 &
>>> {1, 2, 3} & {3, 4, 5} #交集 {3}
并集 |
>>> {1, 2, 3} | {3, 4, 5} #并集，自动去除重复元素 {1, 2, 3, 4, 5}
注意，并集运算符不是加号
对称差集 -
>>> {1, 2, 3} - {3, 4, 5} #差集 {1, 2}
逻辑运算符and、or、not
运算符and和or并不一定会返回True或False，而是得到最后一个被计算的表达式的值，但是运算符not一定会返回True或False
矩阵相乘运算符@
还有赋值运算符=和+=、-=、*=、/=、//=、**=、|=、^=
Python不支持++和--运算符 （即使存在，意思仅是正负号而已）
常用内置函数（重点）
abs(x)
求x的绝对值或复数x的模
all(x)
若所有元素x都为真，则 返回True 也就是对于所有元素x都有bool(x)等于True，则返回True。对于空的可迭代对象也返回True
any(x)
只要x中有元素为真，则回True
ascii(obj)
转换为ASCII码
bin(x)
把整数x转换为二进制
bool(x)
测试是否为真 （True或False）
bytes(x)
转换为字节串
callable(obj)
测试对象obj是否可调用
compile()
用于把Python代码编译成可被exec()或eval()函数执行的代码对象
complex(real, [imag])
返回复数
chr(x)
返回Unicode编码为x的字符
delattr(obj, name)
删除属性，等价于del obj.name
dir(obj)
返回指定对象或模块obj的成员列表，如果不带参数则返回当前作用域内所有标识符
divmod(x, y)
返回包含整商和余数的元组((x-x%y)/y, x%y)
enumerate(iterable[, start])
函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。
>>> list(enumerate('abcd')) #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
eval(s[, globals[, locals]])
计算并返回字符串s中表达式的值
exec(x)
执行代码或代码对象x
filter(func, seq)
返回filter对象，其中包含序列seq中使得单参数函数func返回值为True的那些元素，如果函数func为None则返回包含seq中等价于True的元素的filter对象
float(x)
把整数或字符串x转换为浮点数并返回
getattr(obj, name[, default])
获取对象中指定属性的值，等价于obj.name，如果不存在指定属性则返回default的值，如果要访问的属性不存在并且没有指定default则抛出异常
globals()
返回包含当前作用域内全局变量及其值的字典
hasattr(obj, name)
测试对象obj是否具有名为name的成员
hash(x)
返回对象x的哈希值，如果x不可哈希则抛出异常
help(obj)
返回对象obj的帮助信息
hex(x)
把整数x转换为十六进制串
id(obj)
返回对象obj的标识（内存地址）
input([提示])
显示提示，接收键盘输入的内容，返回字符串
input()一律返回字符串对待
可以用int()、float()或eval()对输入内容进行类型转换
int(x[, d])
返回实数（float）、分数（Fraction）或高精度实数（Decimal）x的整数部分，或把d进制的字符串x转换为十进制并返回，d默认为十进制
isinstance(obj, class-or-type-or-tuple)
测试对象obj是否属于指定类型（如果有多个类型的话需要放到元组中）的实例
type(obj)
返回对象obj的类型
iter(...)
返回指定对象的可迭代对象
len(obj)
返回对象obj包含的元素个数，适用于列表、元组、集合、字典、字符串以及range对象和其他可迭代对象
list([x])、set([x])、tuple([x])、dict([x])
把对象x转换为列表、集合、元组或字典并返回，或生成空列表、空集合、空元组、空字典
frozenset([x]))
创建不可变的集合对象
locals()
返回包含当前作用域内局部变量及其值的字典
map(func, *iterables)
map对象中每个元素是原序列中元素经过函数func处理后的结果
>>> list(map(str, range(5))) #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add5(v): #单参数函数
return v+5
>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
如果函数是两个输入参数，那么就要输入那个可迭代对象
max(x)、 min(x)
next(iterator[, default])
返回可迭代对象x中的下一个元素，允许指定迭代结束之后继续迭代时返回的默认值
oct(x)
把整数x转换为八进制串
open(name[, mode])
以指定模式mode打开文件name并返回文件对象
ord(x)
返回1个字符x的Unicode编码
pow(x, y, z=None)
返回x的y次方，等价于x ** y或(x ** y) % z
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
基本输出函数
sep参数用于指定数据之间的分隔符，默认为空格
end参数用于指定输出完数据之后再输出什么字符
file参数用于指定输出位置，默认为标准控制台，也可以重定向输出到文件
quit()
退出当前解释器环境
range([start,] end [, step] )
生成一组start,] end [, step]的数
注意：区间左闭右开，即最后一个数小于end
reduce(func, sequence[, initial])
将双参数的函数func以迭代的方式从左到右依次应用至序列seq中每个元素，最终返回单个值作为结果
在Python 3.x中需要从functools中导入reduce函数再使用， from functools import reduce

>>> from functools import reduce
>>> seq = list(range(1, 10))
>>> reduce(lambda x, y: x+y, seq)
45
repr(obj)
返回对象obj的规范化字符串表示形式，对于大多数对象有eval(repr(obj))==obj
reversed(seq)
返回seq（可以是列表、元组、字符串、range以及其他可迭代对象）中所有元素逆序后的迭代器对象
round(x [, 小数位数])
对x进行四舍五入，若不指定小数位数，则返回整数
sorted(iterable, key=None, reverse=False)
返回排序后的列表
iterable表示要排序的序列或迭代对象，
key用来指定排序规则或依据，
reverse用来指定升序或降序。
该函数不改变iterable内任何元素的顺序
str(obj)
把对象obj直接转换为字符串
sum(x, start=0)
返回序列x中所有元素之和，返回start+sum(x)
zip(seq1 [, seq2 [...]])
把多个可迭代对象中的元素压缩到一起
压缩后的元素为(seq1[i], seq2[i], ...)形式的元组
最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个
>>> list(zip('123', 'abc', ',.!')) #压缩3个序列 [('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]
II. Python序列结构详解

列表 [ , ]
列表的特点
列表式包含若干元素的有序连续内存空间
当列表增加或删除元素时，列表对象自动进行内存的扩展或收缩
插入和删除非尾部元素时涉及到列表中大量元素的移动，会严重影响效率
应尽量从列表尾部进行元素的追加与删除操作
同一个列表中元素的数据类型可以各不相同, 可以同时包含整数、实数、字符串等基本类型的元素
也可以包含列表、元组、字典、集合、函数以及其他任意对象。
[{3}, {5:6}, (1, 2, 3)]
列表的生成
直接赋值 “=”
a_list = [1, 2, 3]
list()函数
使用list()函数把元组、range对象、字符串、字典、集合或其他可迭代对象转换为列表。
列表的访问
支持下标元素访问，下标用[ ]
>>> x[0] #下标为0的元素，第一个元素 'P'
支持使用负整数作为下标
-1表示最后1个元素，-2表示倒数第2个元素
列表常用方法
append(x)
将元素x追加至列表尾部
extend(L)
将列表L中所有元素追加至列表尾部
insert(index, x)
在列表index位置处插入元素x
若index大于列表长度，则尾部追加x
若index为负数且小于列表长度的相反数，则在头部插入元素x
remove(x)
删除第一个值为x的元素
pop([index])
删除并返回列表中下标为index的元素
如果不指定index则默认为-1，弹出最后一个元素
如果弹出中间位置的元素则后面的元素索引减1
如果index不是[-L, L]区间上的整数则抛出异常
clear()
清空整个列表，删除列表中所有元素，保留列表对象
index(x)
返回列表中第一个值为x的元素的索引，若不存在值为x的元素则抛出异常
count(x)
返回x在列表中的出现次数
reverse()
反向
sort(key=None, reverse=False)
对列表中的元素进行原地排序，key用来指定排序规则，
reverse为False表示升序，True表示降序
copy()
返回列表的浅复制
加法运算符+
加法运算符+也可以实现列表增加元素的目的，但不属于原地操作，而是返回新列表
复合赋值运算符+=
复合赋值运算符+=实现列表追加元素时属于原地操作，与append()方法一样高效
乘法运算符*
用于列表和整数相乘，表示序列重复，返回新列表
运算符*=
运算符*=也可以用于列表元素重复，属于原地操作
列表操作
del命令可将删除列表
max()
求最大值
注意：求字符串时，是按从左到右依次比较字符的
min()
求最小值
sum()
求和
len()
求列表长度
zip()
enumerate()
返回包含若干下标和值的迭代对象
map()
函数把函数映射到列表上的每个元素
filter()
filter()函数根据指定函数的返回值对列表元素进行过滤；
all()
测试列表中是否所有元素都等价于True
any()
用来测试列表中是否有等价于True的元素
标准库functools中的reduce()
列表推导式
for exprN in sequenceN if conditionN
>>> aList = [] >>> for x in range(10): aList.append(x*x)
切片操作
[start : end : step] ， 就是下标从start开始，步长为step, 到end(但不包含end) 的部分列表
>>> aList[3:6] #指定切片的开始和结束位置 [6, 7, 9]
返回所有元素 [::]
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> aList[::] #返回包含原列表中所有元素的新列表
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
逆序返回 [::-1]
>>> aList[::-1] #返回包含原列表中所有元素的逆序列表
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
获取偶数位置的元素 [::2]
>>> aList[::2] #隔一个取一个，获取偶数位置的元素
[3, 5, 7, 11, 15]
获取奇数位置的元素[1::2]
>>> aList[1::2] #隔一个取一个，获取奇数位置的元素
[4, 6, 9, 13, 17]
使用切片为列表增加元素
>>> aList = [3, 5, 7]
>>> aList[len(aList):]
[ ]
>>> aList[len(aList):] = [9] #在列表尾部增加元素
>>> aList[:0] = [1, 2] #在列表头部插入多个元素
>>> aList[3:3] = [4] #在列表中间位置插入元素
>>> aList
[1, 2, 3, 4, 5, 7, 9]
使用切片替换和修改列表中的元素
替换列表元素，等号两边的列表长度相等
>>> aList = [3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3]
>>> aList
[1, 2, 3, 9]
切片连续，等号两边的列表长度可以不相等
>>> aList[3:] = [4, 5, 6]
>>> aList
[1, 2, 3, 4, 5, 6]
隔一个修改一个
>>> aList[::2] = [0]*3
>>> aList
[0, 2, 0, 4, 0, 6]
>>> aList[::2] = ['a', 'b', 'c']
>>> aList
['a', 2, 'b', 4, 'c', 6]
使用切片删除列表中的元素
删除列表中前3个元素
>>> aList = [3, 5, 7, 9]
>>> aList[:3] = []
>>> aList
[9]
使用del命令与切片结合来删除列表中的部分元素，并且切片元素可以不连续
>>> aList = [3, 5, 7, 9, 11]
>>> del aList[:3]
>>> aList
[9, 11]
>>> aList = [3, 5, 7, 9, 11]
>>> del aList[::2]
>>> aList
[5, 9]
元组 （ ， ）
元组特点
如果元组中只有一个元素则必须在最后增加一个逗号
访问速度比列表更快。如果定义了一系列常量值，主要用途仅是对它们进行遍历或其他类似用途，而不需要对其元素进行任何修改，那么一般建议使用元组而不用列表
元组的生成
直接把元组赋值给一个变量
>>> x = (1, 2, 3)
空元组
x = ()
x = tuple()
tuple可以将其他迭代对象转换为元组
>>> tuple(range(5)) (0, 1, 2, 3, 4)
很多内置函数的返回值也是包含了若干元组的可迭代对象
例如enumerate()、zip()等等。
>>> list(enumerate(range(5)))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
>>> list(zip(range(3), 'abcdefg'))
[(0, 'a'), (1, 'b'), (2, 'c')]
元组的访问
元组支持使用下标访问特定位置的元素
下标用[ ]
元组的操作
元组与列表的异同点
相同点
列表和元组都属于有序序列，都支持使用双向索引访问其中的元素，以及使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引
len()、map()、filter()等大量内置函数和+、+=、in等运算符也都可以作用于列表和元组。
不同点
元组属于不可变（immutable）序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。
元组没有提供append()、extend()和insert()等方法，无法向元组中添加元素；同样，元组也没有remove()和pop()方法，也不支持对元组元素进行del操作
不能从元组中删除元素，而只能使用del命令删除整个元组
元组也支持切片操作，但是只能通过切片来访问元组中的元素
生成器和推导式
生成器
使用圆括号（parentheses）作为定界符
生成器推导式的结果是一个生成器对象
生成器对象类似于迭代器对象，具有惰性求值的特点，只在需要时生成新元素
只在需要时生成新元素
尤其适合大数据处理的场合
使用生成器对象的元素时，可以根据需要将其转化为列表或元组
使用生成器对象的__next__()方法或者内置函数next()进行遍历
或者直接使用for循环来遍历其中的元素
>>> g = ((i+2)**2 for i in range(10))
>>> for item in g:
print(item, end=' ')
4 9 16 25 36 49 64 81 100 121
没有任何方法可以再次访问已访问过的元素
>>> x = filter(None, range(20)) #filter对象也具有类似的特点
>>> 5 in x
True
>>> 2 in x #不可再次访问已访问过的元素
False
不支持使用下标访问其中的元素
如果需要重新访问其中的元素，必须重新创建该生成器对象
>>> g = ((i+2)**2 for i in range(10)) #创建生成器对象
>>> g
<generator object <genexpr> at 0x0000000003095200>
>>> tuple(g) #将生成器对象转换为元组
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g) #生成器对象已遍历结束，没有元素了
[]
>>> g = ((i+2)**2 for i in range(10)) #重新创建生成器对象
>>> g.__next__() #使用生成器对象的__next__()方法获取元素
4
>>> g.__next__() #获取下一个元素
9
>>> next(g) #使用函数next()获取生成器对象中的元素
16
推导式
列表推导式所使用的方括号（square brackets）。
字典 { ：，： }
字典的特点
键:值
无序可变序列
字典中的“键”不允许重复，而“值”是可以重复的
字典创建
空字典
x = dict()
x = {}
赋值运算符“=”
aDict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}
zip()
>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dictionary = dict(zip(keys, values)) #根据已有数据创建字典
字典的访问
get()方法
用来返回指定“键”对应的“值”
>>> aDict.get('age') #如果字典中存在该“键”则返回对应的“值” 39
并且允许指定该键不存在时返回特定的“值”
>>> aDict.get('address', 'Not Exists.') #指定的“键”不存在时返回指定的默认值 'Not Exists.'
items() 方法
返回字典的键、值对
keys()方法
返回字典的键
values()方法
返回字典的值
下标用 [ ]
若该“键”存在，则表示修改该“键”对应的值
若不存在，则表示添加一个新的“键:值”对，也就是添加一个新元素
update()方法
总结： 键已存在就更新，键不存在就添加
>>> aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict.update({'a':97, 'age':39}) #修改’age’键的值，同时添加新元素’a’:97
>>> aDict
{'score': [98, 97], 'sex': 'male', 'a': 97, 'age': 39, 'name': 'Dong'}
del 删除
del aDict['age']
pop()和popitem()方法弹出并删除指定的元素
collections.OrderedDict()
生成有序字典
>>> import collections
>>> x = collections.OrderedDict() #有序字典
>>> x['a'] = 3
>>> x['b'] = 5
>>> x['c'] = 8
>>> x
OrderedDict([('a', 3), ('b', 5), ('c', 8)])
集合 {， }
集合特点
无序可变序列
大括号作为定界符
逗号分隔
集合的创建
直接赋值
a = {3, 5}
set()
将列表、元组、字符串、range对象等其他可迭代对象转换为集合
集合的访问
集合的操作
.add()
增加新元素
.pop()
方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常
.remove()
方法用于删除集合中的元素，如果指定元素不存在则抛出异常
.discard()
用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作；
III. 流程控制
False
0（或0.0、0j等）、空值None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象
总结： 0或空就是False
if
if 表达式: 语句块1 else: 语句块2
if 表达式1: 语句块1 elif 表达式2: 语句块2 elif 表达式3: 语句块3 else: 语句块4
while
while 条件表达式: 循环体 [else: else子句代码块]
for
for 取值 in 序列或迭代对象: 循环体 [else: else子句代码块]
break 与continue与其他语言用法一致
IV. 函数
def 函数名([参数列表]): '''注释''' 函数体
函数形参不需要声明类型，也不需要指定函数返回值类型
函数名后始终一对圆括号
括号后面的冒号必不可少
Python允许嵌套定义函数
实参和形参的顺序必须严格一致，并且实参和形参的数量必须相同
总结习惯用法
定义函数：
def add6(v): x = v+6 y = v+8 return [x, y]
调用函数：
[q, w] = add6(1)
V. lambda表达式
用来声明匿名函数，也就是没有函数名字的临时使用的小函数，尤其适合需要一个函数作为另一个函数参数的场合。也可以定义具名函数。
lambda表达式只可以包含一个表达式
该表达式的计算结果可以看作是函数的返回值
不允许包含复合语句，但在表达式中可以调用其他函数
>>> f = lambda x, y, z: x+y+z #可以给lambda表达式起名字 >>> f(1,2,3) #像函数一样调用 6
VI. 几个常用库
random库
random()
生产一个[0.0,1.0)之间的随机小数
randint(a,b)
生成一个[a,b]之间的整数
randrange(m,n[,k])
生成一个[m,n)之间以k为步长的随机整数
uniform(a,b)
生成一个[a,b]之间的随机小数
numpy库
a.shape
查看矩阵尺寸
[c, f] = a.shape 查看矩阵a的行列数 cxf
array([[1.,2.,3.], [4.,5.,6.]])
2X3的矩阵
a[-1]
1xn矩阵的最后一个元素
a[1,4]
第2行第5列的元素
a[1] or a[1,:]
第2行元素
a[0:5] or a[:5] or a[0:5,:]
前5行元素
a[0:3][:,4:9]
行1到3，列5到9的一个块元素
a[[1, 2], [1]]
2,3行与第2列相交的元素
max(a.shape)
求矩阵最大的维度
a @ b
矩阵乘法
a * b
对应元素相乘
a/b
对应元素相除
a**3
对应元素的立方
a>0.5
结果是False和True的数组。
np.nonzero(a>0.5)
找到其中（a> 0.5）的索引
返回的是一个元组，需用c[0]形式继续访问
zeros((3,4))
zeros((3,4,5))
ones((3,4))
eye(3)
diag(a)
np.random.rand(3,4)
随机3x4矩阵
linspace(1,3,4)
1至3（含1和3）之间的4个等距样本
mgrid[0:9.,0:6.]
生成两个网格2D数组
c_[a,b] 或hstack((a,b))
横着把两个数组放在一起
r_[a,b]或vstack((a,b))
竖着把两个数组放在一起
unique(a)
math
sqrt(a)
log(a)
log10(a)
log(a, 2)
exp(a)
around(a)
ceil(a)
向上取整
floor(a)
向下取整
fix(a)
向0取整
pi
pi=3.141592
e
2.718281
nan
非数
inf
无穷大
arange(1,11,3)
1,4,7,10
arange(10,0,-1)
a[:] = 3
数组全部赋值为3
matplotlib
开一张画图窗口
plt.figure( )
num
默认None则创建一个图形，图形标号自动递增；
如果提供了一个数，并且与已有id重合，激活它并返回索引；
如果提供的数不存在，创建并返回。
吐过提供的是str，就返回到窗口标题上。
提供的num参数存放在figure对象的number属性里
figsize
英寸单位的宽和高，默认为 rcParams["figure.figsize"] = [6.4, 4.8].
dpi
图像的分辨率，默认 rcParams["figure.dpi"] = 100.
facecolor
背景颜色，默认 rcParams["figure.facecolor"] = 'w'.
edgecolor
边的颜色，默认 rcParams["figure.edgecolor"] = 'w'.
frameon
如果设为False, 禁止绘制图形边框.
FigureClass
Optionally use a custom Figure instance.
clear
如果是True，并且图形已经存在，则清除该图形
画线
plot
plot(x,y2,color='green', marker='o', linestyle='dashed', linewidth=1, markersize=6)
plot(x,y3,color='#900302',marker='+',linestyle='-')
坐标范围
# 设置横轴的上下限 plt.xlim(-1, 6)
# 设置纵轴的上下限 plt.ylim(-2, 10)
坐标标签
plt.xlabel("X")
plt.ylabel("Y")
图例
plot中写 label="y1"
图例位置
plt.legend(loc="upper right")
upper left
upper right
lower left
lower right
图像显示
plt.show()
保存图片
savefig("D:/1.jpg")
savefig(fname, dpi=None, facecolor='w', edgecolor='w', orientation='portrait', papertype=None, format=None, transparent=False, bbox_inches=None, pad_inches=0.1, frameon=None, metadata=None)
主要用到的参数就两个，fname——保存路径；dpi——每英寸像素数
VII. 面向对象程序设计
特点
面向对象程序设计的关键就是如何合理地定义这些类并且组织多个类之间的关系
类名的首字母一般要大写，当然也可以按照自己的习惯定义类名
class Car(object): #定义一个类，派生自object类
def infor(self): #定义成员方法
print("This is a car")
类的使用
并通过“对象名.成员”的方式来访问其中的数据成员或成员方法
isinstance()
测试一个对象是否为某个类的实例，或者使用内置函数type()查看对象类型
>>> isinstance(car, Car) True
私有成员与公有成员
私有成员在类的外部不能直接访问
两个下划线开头但是不以两个下划线结束则表示是私有成员
Python并没有对私有成员提供严格的访问保护机制，通过一种特殊方式“对象名._类名__xxx”也可以在外部程序中访问私有成员，但这会破坏类的封装性，不建议这样做
在Python中，以下划线开头的变量名和方法名有特殊的含义，尤其是在类的定义中
_xxx：受保护成员；
__xxx__：系统定义的特殊成员；
__xxx：私有成员，只有类对象自己能访问，子类对象不能直接访问到这个成员，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。
注意：Python中不存在严格意义上的私有成员
数据成员
属于对象的数据成员一般在构造方法__init__()中定义，当然也可以在其他成员方法中定义
在定义和在实例方法中访问数据成员时以self作为前缀，同一个类的不同对象（实例）的数据成员之间互不影响
在主程序中或类的外部，对象数据成员属于实例(对象)，只能通过对象名访问
而类数据成员属于类，可以通过类名或对象名访问

方法
方法一般指与特定实例绑定的函数，通过对象调用方法时，对象本身将被作为第一个参数自动传递过去，普通函数并不具备这个特点
成员方法大致可以分为公有方法、私有方法、静态方法、类方法和抽象方法这几种类型
•公有方法、私有方法和抽象方法一般是指属于对象的实例方法
私有方法的名字以两个开始
抽象方法一般定义在抽象类中并且要求派生类必须重新实现。
每个对象都有自己的公有方法和私有方法，
在这两类方法中都可以访问属于类和对象的成员。
公有方法通过对象名直接调用，私有方法不能通过对象名直接调用，只能在其他实例方法中通过前缀self进行调用或在外部通过特殊的形式来调用。
•静态方法和类方法都可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。
•静态方法和类方法不属于任何实例，不会绑定到任何实例，当然也不依赖于任何实例的状态，与实例方法相比能够减少很多开销。
•类方法一般以cls作为类方法的第一个参数表示该类自身，在调用类方法时不需要为该参数传递值，静态方法则可以不接收任何参数。
VIII. Python语言概述
缩进
冒号表示缩进的开始，也就是代码块的开始标志；
缩进结束就表示一个代码块结束了
同一个级别的代码块的缩进量必须相同
一般而言，以4个空格为基本缩进单位
info(func) or help(func) 查看帮助
import
一个import只引入一个模块
最好按标准库、扩展库、自定义库的顺序依次导入
使用的三种格式：
import 模块名 [as 别名]
例：import math #导入标准库math
from 模块名 import 对象名[ as 别名]
例： from math import sin #只导入模块中的指定对象，访问速度略快
from 模块名 import *
from math import * #导入标准库math中所有对象
空行与空格
最好在每个类、函数定义和一段完整的功能代码之后增加一个空行，
在运算符两侧各增加一个空格，逗号后面增加一个空格。
在pycharm定义函数前需留两个空行
长句
如果语句太长可用续行符“\”，或者使用圆括号将多行代码括起来表示是一条语句

也可以用圆括号理清关系
复杂运算优先级
如果运算优先级复杂，可用括号去理清一下
注释
单行注释用 #
多行注释用一对三引号'''...'''
单多行注快捷键 Ctrl+/ （取消注释也是这组快捷键）
根据运算特点选择最合适的数据类型
代码荣辱观
以动手实践为荣，以只看不练为耻。
以打印日志为荣，以单步跟踪为耻。
以空格分隔为荣，以制表分隔为耻。
以单元测试为荣，以手工测试为耻。
以代码重用为荣，以复制粘贴为耻。
以多态应用为荣，以分支判断为耻。
以Pythonic为荣，以冗余拖沓为耻。
以总结思考为荣，以不求甚解为耻。
pip安装扩展库
pip download SomePackage[==version] 下载扩展库的指定版本，不安装
pip freeze [> requirements.txt] 以requirements的格式列出已安装模块
pip list 列出当前已安装的所有模块
pip install SomePackage[==version] 在线安装SomePackage模块的指定版本
pip install SomePackage.whl 通过whl文件离线安装扩展库
pip install package1 package2 ... 依次（在线）安装package1、package2等扩展模块
pip install -r requirements.txt 安装requirements.txt文件中指定的扩展库
pip install --upgrade SomePackage 升级SomePackage模块
pip uninstall SomePackage[==version] 卸载SomePackage模块的指定版本