了解系列
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 world".expandtabs(1))
#把字符串中的 tab 符号(' ')转为空格，tab
符号(' ')默认的空格数是 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存储