运算符
(1) "+" , 两个对象相加python
(2) "-" ,两个对象相减git
(3) " * " ,两个对象相乘api
(4) "/" ,两个对象相除app
(5) "%" ,相除返回商的余数ide
(6) "//" ,返回商的整数部分(整除)函数
(7) " ** ",返回x的y次方幂结果spa
比较运算
(1)"=",等于 , 用于比较两个对象是否相等code
(2)">",大于,用于比较大于号左边的对象是否大于右边的对象orm
(3)"
(4)"!=",不等于,用于比较两个对象是否不相等
(5)"<>",不等于,同!=
(6)">=",大于等于,用于比较左边对象是否大于等于右边对象
(7)"<="小于等于,用于比较左边对象是否小于等于右边对象
布尔值 >>> bool
(1)True:表示结果成立,为真,用"1"表示
(2)False:表示结果不成立,为假,用"0"表示
注意:(None," ",(),{},[],0) 用bool断定都为False
逻辑运算
(1) "和">>>>>>>用and表示,and两边条件都成立则返回true,只有一个成立或两个都不成立则返回False(a and b[a为非零,则返回b,a为零,返回a])
(2) "或">>>>>>>用or表示,or两边至少有一个成立则返回true(a or b,a为非零返回a,a为零返回b)
(3) not 非真即假
注意:先算not,and和or运算没有前后顺序,在python中遵循从左向右的顺序作判断,若是有括号,括号里的运算优先
(4)in>>>>>>>>>表示在, a in b,表示a在b里
(5)not in >>>>>>表示不在, a not in b,表示a不在b里
基本数据类型
(1)数据>>>>int类型
注意:数据不可迭代
1,int(x,base=10)表示将x字符串转换为十进制数字表示
num =a
v= int(num,base=16)#int(x,base=10)表示将x字符串转换为十进制数字表示
print(v)>>>>>11
2,bit_length(self)表示当前数字用二进制表示须要多少位数
num = 11v= num.bit_length() #bit_length(self)表示当前数字用二进制表示须要多少位数
print(v)>>>>#4
(2)字符串>>>>str类型
########字符串一旦建立,不可修改(不可变)
########能够迭代,有序
字符串用法:
1.capitalize(self)表示将字符串首字母变大写
n1 = "aaabbbccc"n2= "apple"v= n1.capitalize() #capitalize(self)表示将字符串首字母变大写
print(v)>>>>>>>#Aaabbbccc
2.casefold(self)表示将字符串中的大写字母所有转换为小写
1 n1 = "aaabBBccc"
2 n2 = "apple"
3 v1 = n1.casefold()#casefold(self)表示将字符串中的大写字母所有转换为小写
4 print(v)#>>>>>aaabbbccc
3.center表示设置宽度,并将内容居中
1 n1 = "aaabBBccc"
2 n2 = "apple"
3 v=n1.center(20,"*")#center表示设置宽度,并将内容居中,20表明字符串总位数,*表示空位用它表示
4 print(v)#>>>>>>*****aaabBBccc******
4.count表示统计字符串中有多少子序列
1 n1 = "aaabBBccc"
2 n2 = "apple"
3 v=n1.count("a",1,7)#count表示统计字符串中有多少子序列,后面参数表示起始位置与结束位置
4 print(v)#>>>>>2
5.endswith表示以什么结尾,参数表示起始位置与结束位置,若存在,返回true,不然返回false
同理,startswith表示以什么开始
1 n1 = "aaabBBccc"
2 n2 = "apple"
3 v=n1.endswith("c",1,8)#endswith表示以什么结尾,参数表示起始位置与结束位置,若存在,返回true,不然返回false
4 print(v)#>>>>True
6.find表示字符串从开始日后找,找到第一个以后,获取其位置,参数表示起始位置与结束位置,若没找到返回“-1”
1 n1 = "aaabBBccc"
2 n2 = "apple"
3 v=n1.find("b",1,7)#find表示字符串从开始日后找,找到第一个以后,获取其位置,参数表示起始位置与结束位置,若没找到返回“-1”
4 print(v)#>>>>>>3
7.index表示字符串从开始日后找,找到第一个以后,获取其位置,参数表示起始位置与结束位置,若没找到会报错
1 n1 = "aaabBBccc"
2 n2 = "apple"
3 v=n1.index("b",1,8)#index表示字符串从开始日后找,找到第一个以后,获取其位置,参数表示起始位置与结束位置,若没找到会报错
4 print(v)#>>>>>>3
8.format表示格式化,将一个字符串中的占位符替换为指定的值
1 test = 'i am {name}, age {a}'
2 v = test.format(name='tom',a=19)#format表示格式化,将将一个字符串中的占位符替换为指定的值
3 print(v)#>>>>>i am tom, age 19
1 test = 'i am {0}, age {1}'
2 v = test.format('tom',19)#用下标也可替换为指定的值
3 print(v)#>>>>>>>i am tom, age 19
9.format_map表示格式化,将指定的值替换为字符串中的占位符
1 test = 'i am {name}, age {a}'
2 v2 = test.format_map({"name": 'tom', "a": 19})#format_map表示格式化,将指定的值替换为字符串中的占位符
3 print(v2)#>>>>>>i am tom, age 19
10.isalnum表示字符串中是否只含有字母和数字或汉字,若结果为真则返回True,不然False
1 test = "123"
2 v = test.isalnum()#isalnum表示字符串中是否只含有字母和数字或汉字,若结果为真则返回True,不然False
3 print(v)#>>>>>>True
11.isalpha判断字符串中是否只含有字母
1 n1="aaa"
2 v=n1.isalpha()#isalpha判断字符串中是否只含有字母
3 print(v)#>>>>>>>True
12.isdecimal判断当前输入字符串是不是数字
isdigit判断字符串是否为二进制数字及特殊符号表示的数字,但不能识别文字形式数字
isnumeric判断字符串是否为数字,能够识别各类形式表示的数字
1 n1="二"
2 n2="2②"
3 n3="2②二"
4 v1=n1.isdecimal()#isdecimal判断当前输入字符串是不是数字,只能判断是不是十进制形式数字
5 v2=n2.isdigit()#isdigit判断字符串是否为二进制数字及特殊符号表示的数字,但不能识别文字形式数字
6 v3=n3.isnumeric()#isnumeric判断字符串是否为数字,能够识别各类形式表示的数字
7 print(v1)#>>>>>>>>False
8 print(v2)#>>>>>>>True
9 print(v3)#>>>>>>>>True
13.isprintable判断是否存在不可显示的字符,若存在返回False,不然True,("\n"为换行符,“\t”为制表,都为不可显示字符)
1 n1="fjkajfk\nafkfj"
2 v1=n1.isprintable()#isprintable判断是否存在不可显示的字符,若存在返回False,不然True
3 print(v1)#》》》》False
14.isspace判断是否全是空格
1 n1=" "
2 v1=n1.isspace()#isspace判断是否全是空格
3 print(v1)#>>>>>>>True
15.istitle判断是不是标题,即每一个子序列是不是大写字母开头
title将字符串转换成标题,即每一个子序列都是大写字母开头
1 n1="Afjkdjf ejfiejf mkejfkejfk"
2 v1=n1.istitle()#istitle判断是不是标题,即每一个子序列是不是大写字母开头
3 v2=n1.title()#title将字符串转换成标题,即每一个子序列都是大写字母开头
4 print(v1)#》》》》False
5 print(v2)#》》》》Afjkdjf Ejfiejf Mkejfkejfk
16.join将字符串中的每个元素按照指定分隔符进行拼接
1 n1="今天是星期几"
2 v1="*".join(n1)#join将字符串中的每个元素按照指定分隔符进行拼接
3 print(v1)#>>>>>>今*天*是*星*期*几
17.islower判断字符串是否都是小写
lower将字符串全转换成小写
isupper判断字符串是否全为大写
upper将字符串所有转换成大写
1 test = "Apple"
2 v1 = test.islower()#islower判断字符串是否都是小写
3 v2 = test.lower()#lower将字符串全转换成小写
4 print(v1, v2)#>>>>>>>>>False apple
5 v1 = test.isupper()#isupper判断字符串是否全为大写
6 v2 = test.upper()#upper将字符串所有转换成大写
7 print(v1,v2)#》》》False APPLE
18.lstrip从左边移除指定字符串,有限最多匹配,能够移除空白
rstrip从右边移除指定字符串,有限最多匹配
strip从两边边移除指定字符串,有限最多匹配
1 test = "aexxxxaxa"
2 v1= test.lstrip('xa')#lstrip从左边移除指定字符串,有限最多匹配
3 v2 = test.rstrip('axx')#lstrip从右边移除指定字符串,有限最多匹配
4 v3 = test.strip('xa')#lstrip从两边边移除指定字符串,有限最多匹配
5 print(v1)#》》》》》exxxxaxa
6 print(v2)#>>>>ae
7 print(v3)#》》》》》e
19.maketrans建立对应关系
1 v = "asidufkasd;fiuadkf;adfkjalsdjf"
2 m = str.maketrans("aeiou", "12345")#maketrans建立对应关系
3 new_v =v.translate(m)4 print(new_v)
20.partition从左边以指定字符将字符串分割三部分
rpartition从右边以指定字符将字符串分割三部分
1 test = "testasdsddfg"
2 v = test.partition('s')#partition从左边以指定字符将字符串分割三部分
3 print(v)#》》》》》('te', 's', 'tasdsddfg')
4 v = test.rpartition('s')#rpartition从右边以指定字符将字符串分割三部分
5 print(v)#》》》》》('testasd', 's', 'ddfg')
21.split以指定字符将字符串从左往右分割为几部分,输出结果不包含分割字符,为列表形式
rsplit以指定字符将整个字符串分割,不包含分割字符
1 test = "testasdsddfg"
2 v = test.split('s',2)#split以指定字符将字符串从左往右分割为几部分,输出结果不包含分割字符,为列表形式
3 print(v)#>>>>>['te', 'ta', 'dsddfg']
4 v2=test.rsplit("s")#rsplit以指定字符将整个字符串分割,不包含分割字符
5 print(v2)#》》》》》['te', 'ta', 'd', 'ddfg']
22.splitlines分割,只能根据,true,false:是否保留换行
1 test = "asdfadfasdf\nasdfasdf\nadfasdf"
2 v = test.splitlines(False)#splitlines分割,只能根据,true,false:是否保留换行
3 print(v)#>>>>>['asdfadfasdf', 'asdfasdf', 'adfasdf']
23.swapcase大小写转换
1 test = "appLE"
2 v = test.swapcase()#swapcase大小写转换
3 print(v)#>>>>>APPle
24.isidentifier判断字符串是否以字母、下划线开头
1 a = "a_ajajf"
2 v = a.isidentifier()#isidentifier判断字符串是否以字母、下划线开头
3 print(v)#>>>>True
25.replace表示将指定字符串替换,参数表示要替换的数量,默认从左往右所有替换,参数表示须要替换的数量
1 test = "appleppal"
2 v = test.replace("pp",'www')#replace表示将指定字符串替换,参数表示要替换的数量,默认从左往右所有替换,参数表示须要替换的数量
3 print(v)#>>>>>awwwlewwwal
26.expandtabs表示断句,以参数为宽度从头至尾开始断句,遇到"\t"则空格补全一段宽度,没有出现"\t"则继续开始下一段
1 n1="ajkajkajk\tjkjqiqjijqi"
2 v=n1.expandtabs(13)#expandtabs表示断句,以参数为宽度从头至尾开始断句,遇到"\t"则空格补全一段宽度,没有出现"\t"则继续开始下一段
3 print(v)#》》》》》》ajkajkajk jkjqiqjijqi,结果说明后一段j前面一段长度为13,k后用空格补全
(3)列表>>>>>list
######列表用[]表示,里面的每一个元素用",'隔开,列表建立完能够进行修改,列表元素在内存中以链表形式存在(可变类型)
######列表中的元素能够是 数字,字符串,列表,布尔值..全部的都能放进去
######列表有序,元素能够被修改,删除,增长
列表用法:
(1) 循环 for
1 li = ["a","faaaa",11132,["jfakjfkalj","jfkjfk",454545],44444]2 for i inli:3 print(i)#循环输出列表中每个元素
4 print(li[2:3] )#切片输出的结果是列表
(2)索引取值,对象[下标]
(3)索引修改,对象[下标]=新值
(4)索引删除 del.对象[下标]
(5)切片取值,对象[下标:下标]
(6)切片删除,对象[下标:下标]
(7)切片修改,对象[下标:下标] = [新值,新值]
注意:切片时顾头不顾尾
in用法v="a" in li #判断元素在不在列表里面,注意元素只用逗号隔开的整个元素
列表内置方法
(1) append追加,表示将值做为一个元素追加到列表最后一个元素后面
1 li = [11,22,33,44,55]2 li.append(33)#append追加,表示将值做为一个元素追加到列表最后一个元素后面
3 print(li)#》》》》》[11, 22, 33, 44, 55, 33]
(2) clear清空列表
1 li = [11, 22, 33, 44, 55]2 li.clear()#clear清空列表
3 print(li)#》》》》》[]
(3) copy拷贝 (浅拷贝)
li = [11, 22, 33, 44, 55]
v=li.copy()#copy拷贝(浅拷贝)
print(v)#>>>>>[11, 22, 33, 44, 55]
(4)count计算元素出现的次数
1 li = [11, 22, 33, 44,33,55]2 v=li.count(33)#count计算元素出现的次数
3 print(v)#>>>>>>>2
(5)extend拓展原列表,拓展元素必须能够迭代,且对象会以元素形式添加到原列表后面
1 li = [11, 22, 33, 44,33,.55]2 li.extend("abcd")#extend拓展原列表,拓展元素必须能够迭代,且对象会以元素形式添加到原列表后面
3 print(li)#>>>>>>>>.[11, 22, 33, 44, 33, 0.55, 'a', 'b', 'c', 'd']
1 li = [1,2,3,4]2 l = [6,7,8,9]3 li.extend(l)4 print(li) #[1, 2, 3, 4, 6, 7, 8, 9]
(6) index查找对象并输出对象在列表中的下标,从左边开始,参数表明起始位置与结束位置
1 li = [11, 22, 33, 44,33,.55]2 v=li.index(33)#index查找对象并输出对象在列表中的下标,从左边开始,参数表明起始位置与结束位置
3 print(v)#>>>>>>>2
(7)insert在指定位置插入元素
1 li = [11, 22, 33, 44,33,.55]2 li.insert(2,123)#insert在指定位置插入元素
3 print(li)#>>>>>>>>>[11, 22, 123, 33, 44, 33, 0.55]
(8)pop删除指定下标对应的元素,默认删除最后一个元素
1 li = [11, 22, 33, 44,33,.55]2 li.pop(3)#pop删除指定下标对应的元素,默认删除最后一个元素
3 print(li)#>>>>>>>>>>[11, 22, 33, 44, 33]
(9)remove删除指定元素,从左边开始
1 li = [11, 22, 33, 44, 33, .55]2 li.remove(33)#remove删除指定元素,从左边开始
3 print(li)#》》》》》》》[11, 22, 44, 33, 0.55]
(10)reverse反转列表
1 li = [11, 22, 33, 44, 33,55]2 li.reverse()#reverse反转列表
3 print(li)#>>>>>>>>>>[55, 33, 44, 33, 22, 11]
(11)sort将列表排序,默认从小往大排,在参数位置加入reverse=True,列表将从大往小排
注意,列表中各元素为同一类型时候才能够排序
1 li = [11, 22, 33, 44, 33,55]2 li.sort()#sort将列表排序,默认从小往大排,在参数位置加入reverse=True,列表将从大往小排
3 print(li)#>>>>>>>>[11, 22, 33, 33, 44, 55]
(4)元组 >>>> tuple
#########元组由()组成,各元素由“,”隔开,元素能够是数字,字符串,列表等
#########元组一经建立,一级元素不可修改,增长,删除
#########元组有序,能够迭代
#########元组也可经过索引查找其元素位置,,可切片
1 tu=(11,22,33,44,["aa",(11,"bb")],123,23)2 tu[2]=12
3 print(tu)4 tu[4][0]=11
5 print(tu)#>>>>>>>>>(11, 22, 33, 44, [11, (11, 'bb')], 123, 23)
6 tu[4][1]="abc"#元组中一级元素不可被修改、删除、添加
7 print(tu)#>>>>>>>(11, 22, 33, 44, ['aa', 'abc'], 123, 23)
8 tu[4][1][0]=123
9 print(tu)#元组中一级元素不可被修改、删除、添加
元组内置方法:
(1) count统计元组中指定元素的个数
1 tu=(11,22,33,44,["aa",(11,"bb")],22,123,23)2 v=tu.count(22)#count统计元组中指定元素的个数
3 print(v)#>>>>>>>2
(2) index寻找指定元素的下标,参数表示起始位置与结束位置
1 tu=(11,22,33,44,["aa",(11,"bb")],22,123,23)2 v=tu.index(22,0,-1)#index寻找指定元素的下标,参数表示起始位置与结束位置
3 print(v)#>>>>>>>>1
(5)字典 >>>> dict
#########字典是无序的,支持增删改查,key:value一一对应,value能够是任意值,不能用列表,字典作key(字典的key是可哈希的,不可变的)
#########字典能够迭代
字典内置方法:
(1) clear清空字典
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 dic.clear()#clear清空字典
13 print(dic)#>>>>{}
(2) copy浅拷贝字典
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 v=dic.copy()#copy浅拷贝字典
13 print(v)#>>>>{10: 'aaa', 3: '123', 6: {123: [], 222: (), 'abcd': {'a': 123}}}
(3) dict.fromkeys根据序列,建立指定的字典
1 v=dict.fromkeys([1111,22222])#dict.fromkeys根据序列,建立指定的字典
2 print(v)#>>>>{22222: None, 1111: None}
(4)get根据key找到对应的value
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 v=dic.get(3)#get根据key找到对应的value
13 print(v)#>>>>123
(5)keys经过for循环输出全部的key,根据key获取值,key不存在时,能够指定默认值(None)
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 for i in dic.keys():#>>>>keys经过for循环输出全部的key
13 print(i)#>>>>>10
14 3
15 6
(6)values经过for循环输出全部的values
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 for i in dic.values():#>>>>values经过for循环输出全部的values
13 print(i)#>>>>>aaa
14 123
15 {123: [], 'abcd': {'a': 123}, 222: ()}
(7)items经过循环表示输出全部的key及其对应Values
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 for i,v in dic.items():#>>>>items经过循环表示输出全部的key及其对应values
13 print(i,v)#>>>>>10 aaa
14 3 123
15 6 {'abcd': {'a': 123}, 123: [], 222: ()}
(8)pop根据Key删除指定的values,若字典中没有,则返回参数值
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 v=dic.pop(15,1111)#pop根据key删除指定的values,若字典中没有,则返回参数值
13 print(v)#>>>>>1111
(9)popitem随机删除字典中的一组值
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 v=dic.popitem()#popitem随机删除字典中的一组值
13 print(v)#>>>>>(10, 'aaa')
(10)设置值,已存在,不设置,获取当前key对应的值,不存在,设置,获取当前key对应的值
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 v=dic.setdefault(10,5555)#setdefault设置值,已存在,不设置,获取当前key对应的值,不存在,设置,获取当前key对应的值
13 print(v)#>>>>>aaa
(11)update,更新,若key已存在,则将values更换,若不存在,则将新组添加到字典中
1 dic={2 3:"123",3 10:"aaa",4 6:{5 123:[],6 222:(),7 "abcd":{8 "a":123
9 }10 }11 }12 dic.update({10:5555})#update,更新,若key已存在,则将values更换,若不存在,则将新组添加到字典中
13 print(dic)#>>>>>{10: 5555, 3: '123', 6: {123: [], 222: (), 'abcd': {'a': 123}}}
(6)集合 >>>>> set
集合特色:是一个无序且不重复的元素集合,元素不可变
经过内置函数set可将对象转换为集合,会自动去重
1 s = {1,2,3,4,5,5,6,2,2,23}2 s = set(s)#set将元素转换成集合,会自动去重
3 print(s)#{1, 2, 3, 4, 5, 6, 23}
集合内置函数
s = {1,2,3,4,5,5,6,2,2,23}
s.add("abc")#添加元素到随机位置
print(s)#{1, 2, 3, 4, 5, 6, 23, 'abc'}
s.clear()#清空集合
print(s)#set()
s1 = s.copy()#拷贝集合
print(s1)#{1, 2, 3, 4, 5, 6, 'abc', 23}
s.pop()#随机删除元素
print(s)#{1, 2, 3, 4, 5, 6, 23}
s.remove(8)#指定元素删除,若不存在,会报错
print(s)
s.discard(8)#指定元素删除,若不存在不会报错
print(s)
print(s.union(s2))#union求两个集合并集,用“|"表示,即两个集合相加去重
print(s.intersection(s2))#intersection求两个集合交集,用“&”表示,即求两个集合共有部分
print(s.difference(s2))#difference求两个集合差集,用“-”表示,即求s中有的元素而s2中没有
print(s.symmetric_difference(s2))#symmetric_difference求交叉补集,即减去两个集合共有的元素,剩下的即为交叉补集
s.difference_update(s2)#difference_update差集更新
print(s.isdisjoint(s2))#isdisjoint判断是否有交集,若是没有交集,返回True,不然返回False"
print(s.issubset(s2))#issubset判断是不是子序列
print(s.issuperset(s2))#issuperset判断是不是父序列
s.symmetric_difference_update(s2)#对称差集,并更新到a中
数据转换
字符串(str) , 列表(list) , 元组(tuple) , 字典(dict) 可经过for循环或者join等方法相互转换
(1)字符串与列表的转换
#字符串转换列表 li = list("asdfasdfasdf"), 内部使用for循环
s = "pouaskdfauspdfiajsdkfj"new_li=list(s)print(new_li)#>>>>>>>>>>['p', 'o', 'u', 'a', 's', 'k', 'd', 'f', 'a', 'u', 's', 'p', 'd', 'f', 'i', 'a', 'j', 's', 'd', 'k', 'f', 'j']
列表转换成字符串
1 #列表转换成字符串,
2 #既有数字又有字符串,须要本身写for循环一个一个处理
3 li = [11,22,33,"123","321"]4 r = str(li)#若是列表中含数字元素,不能直接转换,会报错,由于数字不可迭代
5 print(r)#》》》》》》》报错
#############################################
6 li = [11,22,33,"123","321"]7 s = ""
8 for i in li:#经过for循环,先将列表中一个个元素单个转换成字符串,再进行字符串的叠加
9 s = s +str(i)10 print(s)#112233123321
#################################################
#列表中的元素只有字符串,直接使用字符串join方法
li = ["123","567"]
v= "".join(li)print(v)#》》》》》》》123567
(2)字符串,元组,列表间的相互转换
字符串转换元组
字符串转换为元组
s= "asdfasdf0"v=tuple(s)print(v)#》》》》》》('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0')
列表转换元组
1 li = ["asdf","asdfasdf"]2 v =tuple(li)3 print(v)#》》》》》》('asdf', 'asdfasdf')
元组转换列表
1 tu = ("asdf","asdf")2 v =list(tu)3 print(v)#》》》》》》['asdf', 'asdf']
元组转换字符串
1 tu = ("asdf","asdf")2 v = "_".join(tu)3 print(v)#》》》》》》asdf_asdf