这里说一下，python不需要声明，直接赋值就可以
运算符
算术运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 31 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
| / | 除 - x 除以 y | b / a 输出结果 2.1 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 1 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的21次方 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
python2中!=和<>不同，python3中只有!=
python3中没有cmp，需要定义key，1、定义新函数，2、定义lambda 3、定义元组，ture的放到后面，false放到后面 https://blog.csdn.net/jason_cuijiahui/article/details/72771596
lambda表达式：https://blog.csdn.net/jason_cuijiahui/article/details/727706
重新定义：
这是int类的
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: int) -> bool: ...
def __le__(self, x: int) -> bool: ...
def __gt__(self, x: int) -> bool: ...
def __ge__(self, x: int) -> bool: ...
赋值运算符
#连续赋值
a,b,c,d='spam' #这里必须左边4个，不可以多，不可以少，否则报错 print("a: ",a) print("b: ",b) print("c: ",c) print("d: ",d) a,*b='spam' print("a: ",a) print("b: ",b) *a, b = 'spam' print("a: ", a) print("b: ", b) #答案如下 a: s b: p c: a d: m a: s b: ['p', 'a', 'm'] a: ['s', 'p', 'a'] b: m
#交换复制
a = 1 b = 2 a, b = b, a print("a: ",a) print("b: ",b) #输出如下 a: 2 b: 1
#+= 对象发生变化
a = 1 b = 2 print("id a: ",id(a)) print("id b: ",id(b)) a +=b print("id a: ",id(a)) b = a + b print("id b: ",id(b)) #输出如下 id a: 262813952 id b: 262813968 id a: 262813984 id b: 262814016
位运算符
下表中变量 a 为 60，b 为 13。
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
1 #输出是按照补码进行与 2 a = 1 3 b = 2 4 print("a&b: ", a & b) 5 a = -1 #原码是1000,0001 反码是1111,1110 补码是1111,1111 6 b = 2 #原码是0000,0010 反码是0000,0010 补码是0000,0010 7 print("a&b: ", a & b) 8 print("a|b: ", a | b) 9 print("a<<1: ", a<<1) #右边补0 10 print("a<<100", a<<32) #python没有位数限制 11 #输出如下： 12 a&b: 0 13 a&b: 2 14 a|b: -1 15 a<<1: -2 16 a<<100 -4294967296
逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
优先级not>and>or 先计算not 然后是and 然后是or
1 a = 1 2 b = 2 3 c = 0 4 print(b or c) #b为真直接返回2，不看c 5 print(b and a or b and c) #b and a b为真，返回第二个运算的a， a为1，所以不看后面的b and c 直接返回1 6 print(a and b or c) #a为真，a and b 返回b=2，不看c 7 print(c and b or a) #c为假，不看b，返回a的1, 8 #输出如下： 9 2 10 1 11 2 12 1
成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) 等于 id(y) , is 返回结果 1 |
| is not | is not是判断两个标识符是不是引用自不同对象 | x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1 |
返回是否相同，用id()来查看
is 表示两个是否同一个对象， == 表示值是否相等
getrefcount（sys包中）可以查看某个变量的引用数量，但是比实际多一个
整数无论多大都是使用同一个对象，只不过引用增加， 字符串超过4k就重新申请，这是python3的
1 a = 100 2 b = 100 3 c = a 4 d = "w"*4097 5 e = "w"*4097 6 f = d 7 print("a的id：",id(a)) 8 print("b的id：",id(b)) 9 print("c的id：",id(c)) 10 print("d的id：",id(d)) 11 print("e的id：",id(e)) # 这里e字符串超过4096就重新申请，没有超过4096，仍然使用原来的申请过的对象 12 print("f的id：",id(f)) 13 print("a 和 b 是否为同一个对象：",a is b, "a 和 b 是否相同：",a==b) 14 print("a 和 c 是否为同一个对象：",a is c, "a 和 b 是否相同：",a==c) 15 print("d 和 e 是否为同一个对象：",d is e, "d 和 e 是否相同：",d==e) 16 print("d 和 f 是否为同一个对象：",d is f, "d 和 f 是否相同：",d==f) 17 #输出如下： 18 a的id： 264650544 19 b的id： 264650544 20 c的id： 264650544 21 d的id： 21767192 22 e的id： 21835216 23 f的id： 21767192 24 a 和 b 是否为同一个对象： True a 和 b 是否相同： True 25 a 和 c 是否为同一个对象： True a 和 b 是否相同： True 26 d 和 e 是否为同一个对象： False d 和 e 是否相同： True 27 d 和 f 是否为同一个对象： True d 和 f 是否相同： True
运算符优先级
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
数字Number
常量
const.num1 = 22 #num1不可以更改了
数值类型
Python 支持四种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
- 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
- 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
整型在python3里面没有long，也没有long()函数，也没有位数限制
浮点型：2e2表示2乘以10的2次方，但是是浮点数，或者加小数点1.0
复数，第一种1+2j，第二种complex(2,3)
int(x [,base ]) 将x转换为一个整数 int(5)使用的构造函数，int("3",base=7)前面的必须是字符串， int函数
long(x [,base ]) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
bin(x ) 讲一个整数转换为一个二进制字符串
id(x ) 查看一个变量指向的对象
a = 0x12 ##16进制，以0x开头 print(a) a = 0o12 ##8进制以0o开头 print(a) a = 0b10 print(a) ##2进制以0b开头 a = 12 print("12的2进制bin(a)： ",bin(a)) print("12的8进制oct(a)： ",oct(a)) print("12的10进制int(a)： ",int(a)) print("12的8进制hex(a)： ",hex(a)) print("12的7进制： ",int("12", base=7)) print(repr('x31x32x61x62')) print(random()) print(choice(range(10))) print(type(2e2)) print(type(eval("2+3j"))) print(type(100000000000000000000000000)) #输出如下： 18 10 2 12的2进制bin(a)： 0b1100 12的8进制oct(a)： 0o14 12的10进制int(a)： 12 12的8进制hex(a)： 0xc 12的7进制： 9 '12ab' 0.13680982428672706 6 <class 'float'> <class 'complex'> <class 'int'>
math 模块、cmath 模块
第一个模块允许您访问实数的双曲线，三角函数和对数函数，而后者允许您使用复数。math和cmath常用函数 他的有些许错误，math常函数点进去看
| math模块 | 常亮 | pi | 3.14圆周率 |
| e | 2.73自然对数 | ||
| 常用函数 | sqrt(x) | 返回x的平方根 | |
| fabs(x) | 返回x的绝对值 | ||
| factorial(x ) | 返回x的阶乘 x! | ||
| fmod(x, y) | 返回x/y的余数 | ||
| pow(x, y) | 返回x**y次方 | ||
| isfinite(x) | x如果不是正负无穷，返回true，否则返回false | ||
| isinf(x ) | x如果是正负无穷，返回True，否则返回false | ||
| hypot(x, y) | 返回根号下x**2+y**2 | ||
| isnan(x) | x如果是非数，返回true，否则返回false | ||
| idexp(x,i) | 返回x*(2**i) | ||
| max(x1,x2...) | 返回x1，x2的最大值 | ||
| log(x,a) | 返回以x为底，a为自然对数，log10()以10位底数 | ||
| modf(x) | 返回x的整数和小数组成的元组，小数好像不太对 | ||
| trunc(x) | 返回x的整数 | ||
| ceil(x) | 返回大于等于x的整数 | ||
| floor(x) | 返回小于等于x的整数 | ||
| exp(x) | 返回e的x次方 | ||
| fsum(iter) | 迭代器求和 | ||
| gcd(x, y) | 返回x,y的最大公约数 | ||
| 三角函数 | sin(x) | 返回x的sin值，x表示弧度制 | |
| radians(x) | 返回x角度对应的弧度 | ||
| degree(x) | 返回x弧度对应的角度 |
cmath模块（复数）
笛卡尔积和极坐标互转
>>> import cmath >>> Z=1+2j >>> print cmath.polar(Z) (2.23606797749979, 1.1071487177940904) >>> a,b=cmath.polar(Z) >>> print cmath.rect(a,b) (1+2j)
随机模块random
| random | chioce(seq) | 从seq序列中抽取一个 |
| randrange([start,]stop[,step]) | 从范围内随机抽取一个数字 | |
| random() | 从0,1之间抽取一个实数 | |
| shuffle(lst) | 讲序列重新排序 | |
| uniform(x,y) | 从x,y之间取一个实数 |
字符串String
字符串不能改动，可以令指向字符串的变量重新指向别的字符串
str = "222"*10
查询
len() 字符串长度 in/not in 在不在其中 max(str) 查询字符串最大的字母，这个不是字符串函数，是内置函数 min(str) 查询字符串最小的字母，这个不是字符串函数，是内置函数 count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数 rfind,find(str, beg=0 end=len(string)) 找不到返回-1 rindex,index(str, beg=0, end=len(string)) 找不到报一个异常.
修改
capitalize 第一个单词变成大写字母开头 title 所有单词变成大写字母开头 upper 每个字母都变成大写字母 strip lstrip rstrip strip("x") 删除两边或者单边的 空格 replace(old,new,max) "{}".format("abc") 相当于%s，其占位符的作用 "{1}".format("abc","def") 按照索引对应值，与索引序列相关 "{name}".format(name="abc") 按照关键字对应值，只与key对应 center(width[,fillchar]) 居中对齐，补齐默认空格 ljust(width[,fillchar]) 左对齐，补齐默认空格 rjust(width[,fillchar]) 右对齐，补齐默认空格 zfill(width) 右对齐，左边补0 expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 bytes.decode(encoding="utf-8", errors="strict") 转为字符串 encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' maketrans(intab, outtab) 制作映射表 str.translate(trantab) 对应代换
del var 删除变量
判断
isdecimal 12 isdigit 12② isnumeric 12②二 isspace 全是空格 istitle 所有单词都是大写字母开头 isupper 所有字母都是大写字母 islower 所有字母都是小写字母 isalnum 是否是数字或者字符也可以是汉字，”二④αж”也可以，符号“！”不可以
isalpha 是否是中文或者字符，希腊字母也可以 isidentifier 是否是标识符 isprintable 判断是否为可打印字符串 startswith 以什么开头 endwith 以什么结尾
分合
split(seq,maxsplit), rsplit 以seq为分隔符，默认是 空格 和 ,最大分割maxsplit个 re.split("[.:]",text) 以多个分隔符进行分割 splitlines(1或者0) 只以 进行分割，1表示保留 ，0不保留 seq.join(str) seq为分隔符，str可以是字符串，列表，元组 s[a:b:c] 从a到b，每隔c，可以为负数
列表List
增
list1 = ['1',1,2] #赋值
list1[1:1] = [1,2] #在第一个位置上添加[1,2]
list2 = list1 #变量赋值，直接把list1对象赋值给list2，修改list1，list2也会发生变化
list2 = list1[:]
list2 = list1.copy()
list2 = copy.copy(list1) #以上3个都是浅赋值，只是赋值第一层值，比如list1[1]只赋值的是地址，如果修改list1[1]的内容，整个list1，list2的第二项都会变化
list2 = copy.deepcopy(list1) # 深赋值，把每一层都赋值
list1.insert(index,obj) #在哪一项添加obj，如果index超过list1长度，则在list1最后添加添加obj
删
del list[2] #删除第三项
list1.pop() #如果pop()中无参数，则抛出最后一项，没有项的时候会抛出异常，
list1.pop(1) #抛出第一项，没有则抛出异常
list1.remove(obj) #obj移除obj项的第一个，比如remove('e')把第一个'e'删除
list1.clear() #把list1所有项目清除,返回None
改
list1[2] = 2 #修改列表第三项，当超过列表长度会报异常
list1.append(obj) #把obj整体当做一项放到list1的后面
list1.extend(seq) #把seq中的每一项都放到list1的后面
list1 = list1 + list2 #list2必须为列表
#append比extend块20%左右，extend比‘+’快几百倍，尽量少用‘+’，append 比 index快50%左右
list1.reverse() #把list1全部反向
list1.sort(key=None,reverse=False) #默认reverse按照正序排列，True按照逆序排序， 没有cmp，按照key函数返回的数字或者字符进行排序
查
list1.index(obj) #删除第一个obj内容，没有则抛出异常
#list没有find方法
obj in list1 | obj not in list1 #是否在其中，没有返回false
list1.count(obj) #查询obj在list1的数量
list1[::] #所有元素,第一个是start位置，第二个是终止位置(不包含)，第三个是步长
list1[-1] #最后一个元素
函数
len(list) #返回列表长度
max(list) #返回list中最大值
min(list) #返回list中最小值
list(seq) #把seq转为列表
元组Tuple
元组和列表区别：不可以更改，只有index，count方法
函数有 len,max,min,tuple(seq)
元组不可以更改，但是变量可以重新赋值
- (1,2) + (3,4) 元组相加构成新元组
- (3,4)*10
- (3,4,) 元组最好在后面加上,
- del tuple1 删除元组
- msg = "1","2" 不用括号也表示元组
字典Dict
字典键值对没有顺序
增
dict1 = {one:1,two:2} #赋值
dict()函数
- dict("one"=1,"two"=2) #通过默认值，创建dict
- dict([("one",1),("two",2)]) #通过元组构成的列表
- dict(zip(["one","two","three"],[1,2,3])) #通过zip两个列表
y=dict1.copy() #浅赋值
dict1=dict.fromkeys(['one','two','three']) #从键值创建字典，默认值values为None，但是可以统一赋值，dict.fromkeys(['one','two','three']，"数字")
删
del dict1[1] #删除字典中1键的
dict1.clear() #清空字典 和del dict1 不一样 del是删除dict1变量，若要访问就要出错 相当于d = {}
dict1.pop(key) #返回key对应的value，没有则报错
dict1.popitems() #随机返回一个键值对，以元组类型返回
改
dict1[“one”]=“一” #重新赋值
dict1.setdefault('one',1) #如果‘one’没值，则设置为1，否则不变
dict1.update(dict2) #用字典2的键值对更新字典1的值，如果有更新，没有则添加
查
dict1.values() #返回dict_values([1, 2, 3, 4])
dict.keys() #返回dict_keys(['one', 'two', 'three', 'four'])
if 'one' in dict1: #python3中没有has_key 用if in 来表示 和 if 'one' in dict1.keys(): 一样
for k,v in d.items(): #字典中的每个条目，
if d.get('one') #找到返回对应的values的1，没有返回None
集合Set
元素不可以改变类型，但是本身是可以添加或者删除，如果本身也想不可以添加删除，用frozenset()
增
set1 = {value1, value2} #value1 只能是不可变类型，可以是数字，字符串，元组 se1 = set(values) #两种赋值方式，也可以是字符串用set(),如果是字典，用字典的keys创建字符
s.add(x) #增加某个元素，和update不同
set2 = set1.copy() #浅复制
删
s.pop() #删除一个集合第一个元素，但集合无序，所以相当于随机删除
s.remove(x) #删除某个字符串，或者列表，字典的keys，没有对应的x，则报错
s.discard(x) #只可以删除某个元素
s.clear() #清空
改
set1.update(x) # 更新字典，列表，如果是字典，只用keys
查
x in set1 #查询是否存在
x.difference(y) #相当于x-y, 不操作x, 返回x-y
x.difference_update(y) #相当于x = x-y ,返回None，直接操作x
x.intersection(y,z) #不操作x,返回x和y,z的交集 &也可以表示
x.intersection_update(y,z) #操作x，返回None，x=x∩Y∩y
x.symmetric_difference(u) #返回x和y不重复的元素 ^也可以表示
x.sysmmetric_difference_update(y) #x变为不重复元素
x.union(y) #返回并集 |也可以表示
x.isdisjoint(y) #判断x和y是否含有相同元素，有返回true，否则f
x.issubset(y) #判断x是否是y的子集
格式化输出
print("xxxx",seq="",end="")
python格式化字符串有%和{}两种 字符串格式控制符.
字符串输入数据格式类型(%格式操作符号)
%%百分号标记
%c字符及其ASCII码
%s字符串
%d有符号整数(十进制)
%u无符号整数(十进制)
%o无符号整数(八进制)
%x无符号整数(十六进制)
%X无符号整数(十六进制大写字符)
%e浮点数字(科学计数法)
%E浮点数字(科学计数法，用E代替e)
%f浮点数字(用小数点符号)
%g浮点数字(根据值的大小采用%e或%f)
%G浮点数字(类似于%g)
%p指针(用十六进制打印值的内存地址)
%n存储输出字符的数量放进参数列表的下一个变量中
字符串格式控制%[(name)][flag][width][.][precision]type
name:可为空，数字(占位),命名(传递参数名,不能以数字开头)以字典格式映射格式化，其为键名
flag:标记格式限定符号,包含+-#和0,+表示右对齐(会显示正负号),-左对齐,前面默认为填充空格(即默认右对齐)，0表示填充0，#表示八进制时前面补充0,16进制数填充0x,二进制填充0b
width:宽度(最短长度,包含小数点,小于width时会填充)
precision:小数点后的位数,与C相同
type:输入格式类型，请看上面
format_spec格式{[name][:][[fill]align][sign][#][0][width][,][.precision][type]}
用{}包裹name命名传递给format以命名=值 写法,非字典映射,其他和上面相同
fill = <any character> #fill是表示可以填写任何字符
align = "<" | ">" | "=" | "^" #align是对齐方式，<是左对齐， >是右对齐，^是居中对齐。
sign = "+" | "-" | " " #sign是符号， +表示正号， -表示负号
width = integer #width是数字宽度，表示总共输出多少位数字
precision = integer #precision是小数保留位数
type = "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%" #type是输出数字值是的表示方式，比如b是二进制表示；比如E是指数表示；比如X是十六进制表示
