列表内置方法
""" 列表在调用内置方法之后不会产生新的值，而是修改本身，如果重新定义一个变量来接受修改
后的列表，返回值就为null"""
# l1 = ['jason', 'mack', 'tom', 'lux']
# l2 = [11, 33, 55, 66, 88]
# 1.统计列表的元素的个数
# print(len(l1)) # 4
# print(len(l2)) # 5
'''增删改查：占据了程序的90%以上的核心操作'''
# 2.增
# 2.1 尾部追加数据append() 括号内无论写什么都当成一个数据值追加到列表最后一个元素
# res = l1.append('xunfei')
# print(res) # none:列表l1追加一个元素后修改的是本身，并不会产生一个新的变量
# print(l1) # ['jason', 'mack', 'tom', 'lux', 'xunfei']
# s1 = '$hello$'
# res=s1.strip('$')
# print(res,s1) # hello $hello$:因为字符串是不可变类型，所以当修改字符串的值后会返回一个新的值
# l1.append([1,2,3,4,5]) # ['jason', 'mack', 'tom', 'lux', [1, 2, 3, 4, 5]]
# print(l1)
# 2.2 任意位置插入数据值insert() 括号内无论写什么数据类型 都是当成一个元素插入
# l1.insert(0,'插队')
# print(l1) # ['插队', 'jason', 'mack', 'tom', 'lux']
# 2.3 扩展列表(将new_l2的元素添加到new_l1)
# new_l1 = [11,22,33,44,55]
# new_l2 = [1,2,3,4]
# 方式1：(推荐使用，为内置方法）
# new_l1.extend(new_l2)
# print(new_l1) # [11, 22, 33, 44, 55, 1, 2, 3, 4]
# 方式2：
# for i in new_l2:
# new_l1.append(i)
# print(new_l1) # [11, 22, 33, 44, 55, 1, 2, 3, 4]
# 方式3：但是此方式性能较差
# print(new_l1 + new_l2) # [11, 22, 33, 44, 55, 1, 2, 3, 4]
# 3.查询数据与修改数据
# l1 = ['jason', 'mack', 'tom', 'lux']
# l2 = [11, 33, 55, 66, 88]
# print(l1)
# print(l1[0])
# print(l1[1:4]) # ['mack', 'tom', 'lux']: 将l1进行切片，从索引1到3，打印出来
# l1[0] = 'xunfei'
# print(l1[0]) # xunfei 通过索引l1的值修改为'xunfei'
# 4.删除数据
# 4.1 通用删除数据
# del l1[0] # 通过索引即可
# print(l1) # ['mack', 'tom', 'lux']
# 4.2 指名道姓删除
# l1.remove('jason')
# print(l1) # ['mack', 'tom', 'lux']
# 4.3 先取出数据值再删除
# res = l1.pop(0)
# print(res, l1) # jason ['mack', 'tom', 'lux']
# 5.查看数据值对应的索引值
# print(l1.index('jason')) # 0
# 6.统计某个值出现的次数
# print(l1.count('jason')) # 1
# 7.排序
# l2.sort()
# print(l2) # [11, 33, 55, 66, 88]:默认为升序
# l2.sort(reverse=True)
# print(l2) # [88, 66, 55, 33, 11]：降序
# 8.翻转
# l2.reverse()
# print(l2) # [88, 66, 55, 33, 11]
# 9.比较运算
# new_1 = [89,11]
# new_2 = [88,99,44,55]
# print(new_1>new_2) # True
# new_1 = ['a',11]
# new_2 = [11,22,33,44]
# print(new_1>new_2) # 报错 不同数据类型之间无法做比较
# new_1 = ['a',11] # a 97
# new_2 = ['A',33,44,12323] # A 65
# print(new_1>new_2) # True
可变与不可变类型
"""
为什么字符串调用内置方法是产生新的值，列表调用内置方法是改变本身
"""
# 1.可变类型 list(还有 集合 字典)
'值改变(内置方法) 内存地址可以不变'
# l1 = [11,22,33]
# print(id(l1)) # 4516293760
# l1.append(44)
# print(id(l1)) # 4516293760
# 2.不可变类型 str int float tuple
'值改变(内置方法) 内存地址肯定变'
# s1 = '$hello$'
# print(id(s1)) # 4377090096
# s1 = s1.strip('$')
# print(id(s1)) # 4377090992
a =2234 # 此处不要忘记int的小整数池概念
print(id(a)) # 4374711728
a =5555
print(id(a)) # 4374711664
元组内置方法
# 类型转换
# print(tuple(123)) # 报错
# print(tuple(123.11)) # 报错
# print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
'''支持for循环的数据类型都可以转元组'''
# t1 = ()
# print(type(t1)) # <class 'tuple'>
# t2 = (1)
# print(type(t2)) # <class 'int'>
# ...
"""
当元组内只有一个数据值的时候，逗号不能省略
如果省略了 那么括号里面是什么数据类型就是什么数据类型
建议 ：编写元组 逗号加上 哪怕就只有一个元素
(1,) ('jason',)
ps: 以后遇到可以存储多个数据值的数据类型 如果里面只有一个数据 逗号也乘机加上
"""
t1 = (11,22,33,44,55,66)
# 1.索引相关操作
# 2.统计元组内数据值的个数
# print(len(t1)) # 6
# 3.查与改
# print(t1[0]) # 11 :可以查
# t1[0]=222 # 不可以改
'''元组的索引不能该表绑定的地址'''
t1 = [11,22,33,[11,22]]
t1[-1].append(33)
print(t1) # [11, 22, 33, [11, 22, 33]] ：元素的索引只是不能修改，但如果索引指向的值为列表，那么可以操作列表
字典内置方法
# 类型转换
dict1 = [('name','jason'),('pwd','123')]
# print(dict(dict1))
'''字典很少涉及到类型转换，都是直接定义调用'''
info = {
'username':'jason',
'age':'18',
'hobby':['read','run']
}
"""
K是对V的描述性性质的信息一般是字符串 K其实只要是不可变类型都可以
"""
# 1.字典内k:v键值对是无序的
# 2.取值操作
# print(info['username']) # 不推荐使用，键不存在直接报错
# print(info.get('username')) # jason
# print(info.get('xxx')) # None 如果获取不到key，返回none
# print(info.get('xxx','键不存在返回的值，默认返回none')) # 键不存在返回的值，默认返回none
# 3.统计字典中键值对的个数
# print(len(info)) # 3
# 4.修改数据
# info['username'] = 'xunfei' # 键存在，就修改；若不存在，则新增key-value键值对
# print(info) # # {'username': 'xunfei', 'age': '18', 'hobby': ['read', 'run']}
# 5.新增数据
# info['salary'] = 6
# print(info) # {'username': 'jason', 'age': '18', 'hobby': ['read', 'run'], 'salary': 6}
# 6.删除数据
# 方式1
# del info['username']
# print(info)
# 方式2
# res = info.pop('username')
# print(res,info)
# 方式3
# info.popitem() # 随即删除
# print(info) # {'username': 'jason', 'age': '18'}
# 7.快速获取键 值 键值对数据 ? 如果通过keys()获取到了值，如何访问里面的某个值:list(info.keys())
# print(info.keys()) # dict_keys(['username', 'age', 'hobby']):获取字典所有的k值，结果当成是列表即可
# print(info.values()) # dict_values(['jason', '18', ['read', 'run']])
# print(info.items())
# 获取字典kv键值对数据，组织成列表套元组dict_items([('username', 'jason'), ('age', '18'), ('hobby', ['read', 'run'])])
# 8.修改字典数据，键存在则修改，键不存在则新增
# info.update({'username':'hongdou'})
# print(info) # {'username': 'hongdou', 'age': '18', 'hobby': ['read', 'run']}
# info.update({'xxxx':'cv'})
# print(info) # {'username': 'jason', 'age': '18', 'hobby': ['read', 'run'], 'xxxx': 'cv'}
# 9.快速构造字典，给所有的key默认共享一个键的地址
# res = info.fromkeys([1,2,3],None)
# print(res)
# res= dict.fromkeys(['username','password','age'],[])
# print(res) # {'username': [], 'password': [], 'age': []}
# 如果如上在随便哪个的空列表添加，所有的键都会有这个数据，那么我们该如何解决这个重复的问题
# res['username'] = [] # 给username的键重新申明一个空间，解除之间的地址绑定
# res['username'].append('xunfei')
# res['password'] = []
# res['password'].append('123')
# res['age'] = []
# res['age'].append('18')
# print(res) # {'username': ['xunfei'], 'password': ['123'], 'age': ['18']}
# res =dict.fromkeys([1,2,3],334455)
# print(res[1]) # 334455
# 10.键存在则返回获取键对应的值，不存在则设置 并返回设置的新值
res = info.setdefault('username','xxx1')
print(res,info) # jason {'username': 'jason', 'age': '18', 'hobby': ['read', 'run']}
res = info.setdefault('uuu','jjj')
print(res,info) # jjj {'username': 'jason', 'age': '18', 'hobby': ['read', 'run'], 'uuu': 'jjj'}
集合内置方法
# set()
# 类型方法
# 支持for循环的，并且数据必须都是不可变类型
# 1.定义空集合需要使用关键字才可以
# 2.集合内数据必须是不可变类型(整型，浮点型，字符串，元组，布尔值)
'''去重'''
# s1 = {1,2,3,4,4,5,2,2,3,4,4,5}
# print(s1) # {1, 2, 3, 4, 5}
'''关系运算'''
# print({1,2,[1,2]}) # 报错，里面含有可变类型：列表
# print({1,3,{'name':'jason'}}) # 报错，里面含有可变类型：字典
'''模拟两个人的好友集合
主要知识点：交集，并集，异或集，等
'''
f1 = {'jason','tony','luc','jack'}
f2 = {'kevin','jason','jack','lili'}
# 1.求f1和f2的共同好友
# print(f1&f2) # {'jack', 'jason'}
# 2.求f1和f2各自的独特好友
# print(f1-f2) # {'luc', 'tony'}
# print(f2-f1) # {'kevin', 'lili'}
# 3.求f1和f2的所有好友
# print(f1 | f2) # {'jason', 'tony', 'luc', 'jack', 'kevin', 'lili'}
# 4.求f1 和f2的各自好友
# print(f1 ^f2) # {'kevin', 'lili', 'luc', 'tony'}
# 5.父集、子集
s1 = {1,2,3,4,5,6}
s2 = {3,2,1}
print(s1>s2) # True 即判断 s1是否是s2的父集
s3= {0,1}
print(s1>s3) # False 即 不是
