了解系列
str.strip() 默认移除首位空白符(空格、换行、制表符) 括号内指定字符,移除首位指定的字符
str.lstrip() 只移除左边的字符
str.rstrip() 只移除右边的字符
str.lower() 将字符串全变为小写
str.upper() 将字符串全变为大写
str.startwith 判断以什么开头
str.endswith 判断以什么结尾
str.jion 从可迭代对象中取出多个字符串,然后按照指定的分隔符进 行拼接,拼接的结果为字符串
str.replace 用新的字符替换字符串中旧的字符 可以指定修改的个数
str.split() 切分 括号内不指定以空格作为切割符,括号内指定,则按照指定分隔符分隔
str.split() 从右到左切分
str.isdigitstr 判断字符串是否是纯数字组成,返回结果为True或False
了解:
字符串剩余
1、find,rfind,index,rindex,count
x = "qwe asd zxc "
res=x.find(“asd”)#对应的是索引的值2,如果找没有的返回值为-1
x.find(‘zxc’,0,9) #在指定范围内查找
x.rfind #返回字符串最后一次出现的位置(从右向左查询),如果没有匹配,则返回-1
x.index(‘zxc’) #找索引值,没有则报错
x.rindex(‘zxc’) #从右向左找,没有会报错
2、center,ljust,rjust,zfill
x = “yxh”
res=x.center(50,’*’)
print(res)
print(x.ljust(50,"*")) #左对齐,剩下用字符串填充到指定宽度
print(x.rjust(50,"*"))#右对齐,剩下用字符串填充到指定宽度
print(x.zfill(50))#返回指定长度的字符串,原字符串右对齐,前面填充0
print(x.rjust(50,"0"))#返回指定长度的字符串,原字符串左对齐,前面填充0
center #center() 方法返回一个指定的宽度 width 居中的字符串,如果width 小于字符串宽度,
直接返回字符串,不会截断,fillchar 为填充的字符,默认为空格
3、expandtabs
print("hello\tworld".expandtabs(1))
#把字符串中的 tab 符号('\t')转为空格,tab
符号('\t')默认的空格数是 8
4、captalize,swapcase,title
print("hello world egon".capitalize()) 首字母大写
print("aBcDeF".swapcase()) 大小写反转
print("hello world egon".title()) 所有单词首字母大写
is系列
#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit()
False
#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal()
True
>>> num3.isdecimal()
False
>>> num4.isdecimal()
False
#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric()
True
>>> num3.isnumeric()
True
>>> num4.isnumeric()
True
# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
列表常用操作及内置方法
用途:按照索引存放多个任意类型的值,索引反映的是位置/顺序
定义方式:在[]内用逗号分割开多个任意类型的元素
数据类型转换 xxx=list()*
res=list(“hello”)
res=list({“k1”:1,“k2”:2,“k3”:3})
print(res)
1、常用操作+内置的方法
1.1 优先掌握的操作:
1、按索引存取值(正向存取+反向存取):即可以取可以改值,不能加值
l1 = [11,22,33,44,55]
print(l1[0]) 正向取值
print(l1[-1]) 反向取值
l1[0] = 100 修改指定索引位置的值
l1[5] = 11111 添加
append()列表尾部追加元素
extend()一次性在列表尾部添加多个元素
insert()在指定位置插入元素
2、切片(顾头不顾尾(前取后不取),步长)
l1 = [11,22,[66,77]]
res=l1[2:4:1] 步长一般不填写默认就是1
2.1 浅copy:
l1 = [11,22,[66,77]]
l2=l1[:]
l2=l1.copy()
print(id(l1[0]),id(l1[1]),id(l1[2])) # id都相同
print(id(l2[0]),id(l2[1]),id(l2[2])) # id都相同 第一个列表内的元素不会改变但是嵌套在内的元素改变会影响到浅copy的改变。
from copy import deepcopy #深度copy 相当于另外创建一个内存。
l3=deepcopy(l1)
print(id(l3[0]),id(l3[1]),id(l3[2])) # id都相同
l1[2][0]=6666
print(l1) # 改变
print(l2) # 改变
print(l3) # 不变
示范1:
l1[0]=1000
print(l1) # 改变
print(l2) # 不变
print(l3) # 不变
示范2:
l1[-1][0]=666
print(l1) # 改变
print(l2) # 改变
print(l3) # 不变
3、长度
l1 = [11,22,[66,77]]
print(len(l1))
#4、成员运算in和not in
l1 = [111,22,[66,77]]
print([66,77] in l1) 是在l1内 在则是Ture
print(66 in l1)
print(66 not in l1) 不在l1内 不在则是 False
5、追加 append
l1=[11,222]
l1.append(33)
l1.append(44)
l1.append([55,66])
l1.insert(1,"aaa")
print(l1)
6、删除
l1=[11,222,[1,2]]
6.1 万能删除,没有返回值,代表的是单纯的删除
del l1[0]
print(l1)
6.2 指定元素删除,没有返回值,代表的是单纯的删除
res=l1.remove([1,2])
print(l1)
print(res)
6.3 指定索引删除,有返回值,代表的是取走操作
res=l1.pop(1)
print(l1)
print(res)
7、循环
l1=[11,222,[1,2]]
for x in l1:
print(x)
3.2 需要掌握的操作:
l1=[11,22,333,333,333,]
l1.clear() 空格化
print(l1)
l1=[11,22,333,333,333,]
res=l1.index(333,) 报错 查找第一个出现的索引位置有则输出位置,没有则是报错
print(res)
l1=[11,22,"aaa",'bbb']
l1.reverse() 倒过来
l1=l1[::-1]
print(l1)
sort 排序 默认reverse = false,则从小到大
l1 = [11, 22, "aaa", 'bbb']
l1 = [-3,99,12,-5,93]
l1.sort(reverse=True)
print(l1)
元组
一般可以被循环的元素才能转换成元组
其本身不可被修改,但其可变的子子类可被修改
元组的最后多加一个逗号,用于标识他是一个元组
len(),切片,步长,索引,for,嵌套
v1 = [1,2,3] #添加
v1.append(4)
v1 =[1,2,3]
v2 =[4,5,6]
v1.extend(v2) #将v2中的值逐一加到v1中[1,2,3,4,5,6]
v1 =[1,2,1,3]
v1.remove('1') #[2,1,3]
v1 = [123,1232,43453]
v2 = v1.pop(1)
v1 = [1,2,3]
v1.clear
v2 =[2,3,4]
v2.reverse
v1= [1,3,2,4]
v1.sort(reverse = false) #[1,2,3,4]
v1 =(1,2,3,[4,5])
v1[3][0] = 1
比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别?
比较值 v1 = ((1),(2),(3)) 和 v2 = ((1,),(2,),(3,),) 有什么区别?
字典
在Python3.6+字典就是有序了,之前的字典都是无序。 键值对 {key: value}
字典的键必须不可更改,值可以是任意类型
转换时必须要有特定的格式 满足能转换成键值对的形式
更新键值对
移除键值对
根据字典获取值
len(), 通过键可以找到字典中的值,通过键也可以对字典进行添加和更新操作,如果键不存在,则会添加
键值对,如果存在,则会更新键对应的值 for,可以循环键,值,及键值对
在嵌套和对内部数据操作时要注意: 元组子元素不能变 、 不可哈希的list、dict不能做字典的键
(1,) == 1,
Out: (False,)
a = (1,)
b = 1,
a==b
Out: True
#原本1, 就是一个元组: (1,)但是 (1,) == 1, 在解析的时候,变成了这样 ((1,) == 1),
于是 便有了结果 (False,)
.keys
date ={1:2,'a':2}
data = date.keys()
在Python2中 字典.keys()直接获取到的是列表,
而Python3中返回的是高仿列表,这个高仿的列表可以被循环显示。
.values
data = date.values()
#在Python2中 字典.values()直接获取到的是列表,而Python3中返回的是高仿列表,这个高仿的列表可以被循环显示
.items
date = date.items() ## item是一个元组 (键,值)
for key,value in date.items(): #解压赋值法
print(key,value) # key代表键,value代表值,将直接从元组中直接拆分出来了
.update
info = {"age":12, "status":True}
info.update({"age":14,"name":"ppp"}) # info中没有的键直接添加;有的键则更新值
print(info) # 输出:{"age":14, "status":True,"name":"ppp"}
.pop
info = {"age":12, "status":True,"name":"ppp"}
data = info.pop("age")
print(info) # {"status":True,"name":"ppp"} 结果
print(data) # 12 返回值,pop做取值操作
.get
info = {"age":12, "status":True,"name":"ppp"}
data = info.get("name",None) # 根据name为键去info字典中获取对应的值,如果不存在则返回None,存在则返回值。
print(data) # 输出:ppp 一般直接用键去获取值容易报错,所以用get
字典根据键的查找速度非常快,远远大于列表或元组通过索引查找的速度,因为字典内部是基于hash存储