1.字符串类型
# 1、find,rfind,index,rindex,count
# x = "hello egon egon egon"
# res=x.find("egon") # 会从左向右找到此字符串第一个字符的位置
# res=x.find("egon123") # -1代表没有找到
# print(res)
# res=x.rfind("egon") #这个是从右向左找
# print(res) # 输出的位置信息还是正序的
# res=x.find("egon",0,3) # 可以限定一个范围
# print(res)
# res = x.index("egon") # 跟find差不多但是找不到则报错
# print(res)
# 2、center,ljust,rjust,zfill
# x = "egon"
# res=x.center(50,'*') # 居中填充
# print(res)
# print(x.ljust(50,"*")) # 居左填充
# # print(x.rjust(50,"*")) # 居右填充
# print(x.zfill(50)) # 效果和下面一条一样
# print(x.rjust(50,"0"))
# 3、expandtabs
# print("hello\tworld".expandtabs(1)) # 控制制表符的空格数
# 4、captalize,swapcase,title
# print("hello world egon".capitalize()) # 将此字符串的第一个英文字母变成大写
# print("aBcDeF".swapcase()) # 字符串里英文字母大小写翻转
# print("hello world egon".title()) # 将标题首字母都变成大写
# 5、is其他
# name='egon123'
# print(name.isalnum()) #判断字符串由字母或数字组成
# print(name.isalpha()) #判断字符串只由字母组成
#
# name="aaainputbbbbb"
# print(name.isidentifier()) # 判断是否为一个合法的标识符
# name="abc123"
# print(name.islower()) # 判断字符串里的英文字母是不是都是小写
# print(name.isupper()) # 判断是不是都是大写
# name=" "
# print(name.isspace()) # 判断是不是都是空格
# name="My Name Is Egon"
# print(name.istitle()) # 判断开头是不是都是大写
# 6、is数字系列
# 在python3中
num1 =b'4' # bytes
num2 =u'4' # unicode,python3中无需加u就是unicode
num3 ='四' # 中文数字
num4 ='Ⅳ' # 罗马数字
# 1、 bytes、unicode
# print(num1.isdigit()) #num1只能用这个方法识别
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())
# 2、unicode、中文数字、罗马数字
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())
# 3、unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())
# ======================================该类型总结====================================
# 存一个值
# 有序
# 不可变
# x="hello"
# x[0]="H"
2.列表类型
# ======================================基本使用======================================
# 1、用途：按照索引存放多个任意类型的值，索引反映的是位置/顺序
# 2、定义方式：在[]内用逗号分割开多个任意类型的元素
# l=[111,1.1,"aaa",[2222,3333]] # l=list([111,1.1,"aaa",[2222,3333]])
# print(type(l))
# 数据类型转换
# res=list("hello")
# res=list({"k1":1,"k2":2,"k3":3})
# print(res)
# 3、常用操作+内置的方法
# ===============3.1 优先掌握的操作：
# 1、按索引存取值(正向存取+反向存取)：即可以取可以改值,不能加值
# l1 = [11,22,33,44,55]
# print(l1[0])
# print(l1[10])
# print(l1[-1])
# print(id(l1))
# l1[0] = 100
# print(id(l1))
# l1[5] = 11111 # 不能加值 这个操作会报错
# d = {'k1':2}
# d['kkkk']=22222 # 但是字典可以直接加值
# print(d)
# 2、切片(顾头不顾尾，步长)
# l1 = [11,22,[66,77]]
# res=l1[2:4]
# print(res)
# print(l1)
# 了解：
# res=l1[-1:-4:-1]
# res=l1[::-1]
# print(res) # 倒切
# 浅拷贝
# l1 = [111,222,[33,44]]
# l2 =l1[:] # 和下面一条操作相同
# l2= l1.copy()
# print(id(l1[0]))
# print(id(l2[0]))
# print(id(l2[2][0]))
#
# l1[0]=1000
# print(id(l1[0]))
# print(id(l2[0])) # l2的ID并没有改变 l1里不可变类型的值的变化改动不会影响l2
#
# l1 [-1][0] = 666
# print(l1)
# print(l2) # 这里改变l1的值 却影响到了l2 因为已知list是可变类型 这里子列表对于l1和l2是同一块内存地址 所以牵一发而动全身 这就是浅拷贝
# print(id(l2[2][0]))
#
# from copy import deepcopy # 调用深拷贝的模块
# l3= deepcopy(l1)
# l1[2][0]=777
# print(l1) # [1000, 222, [777, 44]]
# print(l3) # [1000, 222, [666, 44]] 这里l3没有改变 因为深拷贝在遇见可变类型的时候 会生成一块新的内存地址来单独存放
# print(id(l3[2][0]))
# print(id(l1[2][0]))
# 3、长度
# l1 = [11,22,[66,77]]
# print(len(l1))
# 4、成员运算in和not in
# l1 = [111,22,[66,77]]
# print([66,77] in l1)
# print(66 in l1)
# print(66 not in l1)
# 5.追加
l1 = [11, 22]
l1.append(33)
l1.append(44)
l1.append([55, 66])# 可以追加任意类型的值
l1.append((77, 88))
print(l1)
l1.insert(1, 'aaa')# 在指定位置插入
print(l1)
# 6.删除
l1 = [11, 22, [33, 44]]
# 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)
print(l1.count(333))# 看指定元素有几个
# l2=[444,555]
# for item in l2:
# # l1.append(item)
# l1.extend(l2) # 与上面的for循环操作一样
l1.extend("hello")
print(l1)# [11, 22, 333, 333, 333, 'h', 'e', 'l', 'l', 'o']
# l1=[11,22,333,333,333]
# res=l1.index(333,0,)
# res=l1.index(444) #在列表中查找某个元素并输出对应的索引值 找不到就报错
# print(res)
# l1=[11,22,"aaa",'bbb']
# l1.reverse() # 翻转
# # l1=l1[::-1] # 跟上面方法一样
# print(l1)
# l1 = [11, 22, "aaa", 'bbb']
# l1 = [-3,99,12,-5,93]
# l1.sort(reverse=True) # 从小到大排序 在进行翻转
# print(l1)
# ======================================该类型总结====================================
# 存一个值or存多个值
# 有序or无序
# 可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
3.元组类型
# 什么是元组？
# 元组就是一个不可变的列表
#
# ======================================基本使用======================================
# 1、用途: 按照索引存放多个任意类型的值，索引反应的是位置/顺序
# 2、定义方式：在()内用逗号分隔开多个任意类下的值/元素
# t=(10)
# print(type(t))
# 强调:当元组内只有一个元素时，必须加逗号
# t=(10,)
# print(type(t))
# t=(10,1.1,"aaa",[11,22])
# print(t[-1][0])
# t[0]=11111 # 不可变 会报错
# t[-1]=333333
# t=(11,22,[33,44])
# print(id(t[0]),id(t[1]),id(t[2]))
#
# t[2][0]=333333333
# # print(t)
# print(id(t[0]),id(t[1]),id(t[2]))
# t=(11,22) # t=tuple(...)
# print(type(t))
# 类型转换
# tuple(所有可以被for循环遍历的类型)
# t=() # 空元组
# print(t)
# print(type(t))
# 3、常用操作+内置的方法
# 优先掌握的操作：
# 1、按索引取值(正向取+反向取)：只能取
# t=(10,1.1,"aaa",[11,22])
# print(t[0])
# 2、切片(顾头不顾尾，步长)
# t=(11,22,33,44,55)
# print(t[0:3])
# 3、长度
# t=(11,22,33,44,55)
# print(len(t))
# 4、成员运算in和not in
# t=(11,22,33,44,55)
# print(11 in t)
# 5、循环
# for x in t:
# print(x)
# 需要掌握的操作：
# t=(11,22,33,44,55)
# ======================================该类型总结====================================
# 存多个值
# 有序
# 不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
4.字典类型
# ======================================基本使用======================================
# 1、用途：按key:value的形式存放多个任意类型的value，key反映的是value的属性
# 2、定义方式：在{}内用逗号分隔开多个key:value，其中value可以是任意类型
# 而key必须是不可变的类型，通常是字符串类型
# d={'k1':111,'k1':222,'k1':3333} # key重复，只保留一个
# print(d)
# d={1:"aaa",3.1:'bbbb',[1,2]:"ccc"}
# d={1:"aaa",3.1:'bbbb',():"ccc"} # d=dict(...)
# print(type(d))
# print(d[()]) # 也可以用空列表来当key ，但是拿来自己玩玩就行了
# 类型转换
# l=[("name","egon"),("age",18),["gender","male"]]
# res=dict(l) # 变成字典
# print(res)
# d=dict(x=1,y=2,z=3) # 变成字典2
# print(d)
# 空字典
# d={}
# print(type(d))
# dic={}.fromkeys(["name",'age',"gender"],None) # 可以用于初始化字典
# dic={}.fromkeys("hello",None)
# print(dic)
# 3、常用操作+内置的方法
# ==========>优先掌握的操作：
# 1、按key存取值：可存可取
# d={'k1':111}
# print(d['k1'])
# d['k2']=222
# print(d)
# 2、长度len
# d={'k1':111,'k2':222}
# print(len(d))
# 3、成员运算in和not in
# d={'k1':111,'k2':222}
# print('k1' in d)
# print(111 in d)
# 4、删除
d = {'k1':111, 'k2':222}
# 6.1 万能删除，没有返回值，代表的是单纯的删除
# del d['k1']
# print(d)
# 6.2 随机删,返回一个元组
# res=d.popitem()
# print(d)
# print(res)
# 6.3 指定key删除，有返回值，代表的是取走操作
# res=d.pop('k1')
# print(d)
# print(res)
# 5、键keys()，值values()，键值对items()
"""
>>> d={'k1':111,'k2':222}
>>> d.keys()
['k2', 'k1']
>>> d.values()
[222, 111]
>>> d.items()
[('k2', 222), ('k1', 111)] 这是在python2中"""
# 6、循环
d={'k1':111,'k2':222}
# for k in d:
# print(k) # 只打印key
#
# for v in d.values():
# print(v) # 只打印value
#
# for k,v in d.items():
# print(k,v) # 提供两个变量名可以打印key和value
# keys=[]
# for k in d.items(): # items方法是将字典中所有的项以列表的形式返回，列表中的每一项都是以键值对的形式表现的。但其返回的次序可能不一样。
# keys.append(k)
# print(keys) # 返回值[('k1', 111), ('k2', 222)]
#
# keys = list(d.keys()) # 把key转换成列表打印
# print(keys)
# ======================================该类型总结====================================
# 存一个值or存多个值
# 有序or无序
# 可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
