这里说一下，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放到后面 /jason_cuijiahui/article/details/72771596
重新定义：
这是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 = 1b= 2a, b=b, aprint("a:",a)print("b:",b)#输出如下
a: 2b:1
#+= 对象发生变化
a = 1b= 2
print("id a:",id(a))print("id b:",id(b))
a+=bprint("id a:",id(a))
b= a +bprint("id b:",id(b))#输出如下
id a: 262813952id b:262813968id a:262813984id 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， 在一个有符号二进制数的补码形式。
<<
左移动运算符：运算数的各二进位全部左移若干位，由"<
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: 013 a&b: 2
14 a|b: -1
15 a<<1: -2
16 a<<100 -4294967296
View Code
逻辑运算符
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 =04 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 =a4 d = "w"*4097
5 e = "w"*4097
6 f =d7 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 是否相同： True25 a 和 c 是否为同一个对象： True a 和 b 是否相同： True26 d 和 e 是否为同一个对象： False d 和 e 是否相同： True27 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=0b10print(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('\x31\x32\x61\x62'))print(random())print(choice(range(10)))print(type(2e2))print(type(eval("2+3j")))print(type(100000000000000000000000000))#输出如下：
18
10
212的2进制bin(a)： 0b1100
12的8进制oct(a)： 0o14
12的10进制int(a)：1212的8进制hex(a)：0xc12的7进制：9
'12ab'
0.13680982428672706
6
math 模块、cmath 模块
第一个模块允许您访问实数的双曲线，三角函数和对数函数，而后者允许您使用复数。math和cmath常用函数他的有些许错误，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模块(复数)
笛卡尔积和极坐标互转
>>> importcmath>>> Z=1+2j
>>> printcmath.polar(Z)
(2.23606797749979, 1.1071487177940904)>>> a,b=cmath.polar(Z)>>> printcmath.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)) 找不到返回-1rindex,index(str, beg=0, end=len(string)) 找不到报一个异常.
修改
capitalize 第一个单词变成大写字母开头
title 所有单词变成大写字母开头
upper 每个字母都变成大写字母
strip lstrip rstrip strip("x") 删除两边或者单边的\t 空格 \n
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 12isdigit12②
isnumeric12②二
isspace 全是空格
istitle 所有单词都是大写字母开头
isupper 所有字母都是大写字母
islower 所有字母都是小写字母
isalnum 是否是数字或者字符也可以是汉字，”二④αж”也可以，符号“！”不可以
isalpha 是否是中文或者字符，希腊字母也可以 isidentifier 是否是标识符 isprintable 判断是否为可打印字符串 startswith 以什么开头 endwith 以什么结尾
分合
split(seq,maxsplit), rsplit 以seq为分隔符，默认是\t 空格 和\n ,最大分割maxsplit个
re.split("[.:]",text) 以多个分隔符进行分割
splitlines(1或者0) 只以\n进行分割，1表示保留\n，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=#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是十六进制表示
python 新运算符定义_【python第二日】运算符 数据类型(数字 字符串 列表 元组 字典 集合) 重新定义比较大小...
