容器数据类型及其内置方法

• 元组（Tuples）

• 作用：能够存储多组数据的容器类型，形式跟List差不多，只不过是小括号不是中括号，并且其中的数据不能被修改

• 内部原理：当定义了元祖时，内存开辟了新的区域来存放元祖中的数据元素，其中每个不同元素都占据着元祖中的内存空间及地址，如果该数据是不可变类型，一旦确定下来内存地址后，该数据就动弹不得，一生一世都居住在这个内存地址中。如果该数据是可变类型，由于修改其内容并不会变动内存地址，因此可变类型的数据在元组中是可以修改的。

• 图示    大原则就是不允许修改内存元组中每个数据的内存地址，至于你是可变还是不可变，列表字典里面的数变出花来，也不关我事，               只要内存地址不变。

•  

• 定义

• n = ('Messi',10,'Barcelona','Agentina','football',[2022,2008])
  print(type(n))      # 输出<class 'tuple'> 表明其是元组数据类型
  a = 'Messi'
  print(tuple(a))     # 输出字符串每个字符作为元素的元组

• 切片以及按索引取值

• n = ('Messi',10,'Barcelona','Agentina','football',[2022,2008])
  print(n[0:4])       # 切片取值 从索引0到索引4之间取值输出元组，顾头不顾尾: ('Messi', 10, 'Barcelona', 'Agentina')
  print(n[3])         # 同样也是切片取值，但是取得某一个索引值，输出字符串: Agentina
  n[5][0] = '2018'    # 修改元组中列表的数据,由于列表是可变类型,因此修改其中数据并不会改变其内存，也就不存在所谓修改元组的事情存在
  print(n)            # 输出 ('Messi', 10, 'Barcelona', 'Agentina')
  n[0] = 'cluo'       # 修改元组中的字符串等一些不可变类型的数据的时候，已经导致了内存地址的变化。
  print(n)            # 报错 TypeError: 'tuple' object does not support item assignment

• 成员in or not in 运算和长度

• print('cluo' in n)      # 判断'cluo'在不在元祖当中如果不在则输出False   
  print('Messi' in n)     # 输出True
  print(len(n))           # 输出元组中有几个数据

• 循环和常用操作

• x = (1,2,3,4,4,5,6,3,2)
  print(x.count(5))       # 统计元组中有多少个5 记数工具
  print(x.index(2,0,4))   # 在索引值范围(0到4)中输出2第一次出现的索引值
  print(x.index(3,0,4))   # 在索引值范围(0到4)中输出3第一次出现的索引值
  
  for item in x:
      print(item)         # 依次输出元组中的元素作为字符串

  值得注意的是：元组是一个不可变类型的数据，并且数据存储在元组之中是有序的。

• 字典

• 定义：用{}存放多个key:value值，其中key值必须是不可变类型（可hash）一般通常都用字符串类型，而value值可以是任意类型

• dic={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  print(dic,type(dic))        # 输出dic的数据类型 dict
  print(dic['name'])          # 索引为key值，输出value值
  dic={(1,2):'football'}      # 将另一个新字典赋到原字典的地址中
  print(dic)
  dic={[1,2]:'aaa'}           # 由于该key值是不可变类型也就是可hash类型 所以会报错 unhashable type: 'list'
  print(dic[(1,2)])           # 输出key值为(1,2)的value值

• 建立一个新字典的两种方式

• 方法1

• dic2 = dict(name = 'messi', nationality = 'agentina', carrer = 'barcelona')
  print(dic2)

• 方法2

• dic3 = [['name','messi'],['nationality','agentina'],['carrer','barcelona']]
  dic4 = {}
  for k,v in dic3:        # 利用for循环将列表中数据按照key和value的形式赋值到字典中
      dic4[k] = v
  print(dic4)
  
  #与下方等价

  dic5 = dict(dic3)       # 将key和value值按照字典中的形式存放列表中然后通过dict方法输出字典
  print(dic5)

• 按索引存取值

• dic={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  print(dic['name'])              # 通过key值对字典进行取值操作
  dic['career'] = 'FC'            # 进行修改value值得操作
  print(dic)
  dic['championship'] = 'many'    # 通过key值对字典进行存值操作  与list一样可存可取 
  print(dic)

• 成员运算以及长度

  dic={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  print(dic['name'])              # 通过key值对字典进行取值操作
  dic['career'] = 'FC'            # 进行修改value值得操作
  print(dic)
  dic['championship'] = 'many'    # 通过key值对字典进行存值操作  与list一样可存可取 
  print(dic)

• 删除元素

• del方法

• dic={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  del dic['name']     # 删除该key值所对应的键值对
  print(dic)
  del dic['xxx']      # 如果指定的key值不存在于字典之中，则报错

• pop方法

• ret1 = dic.pop('name')      # 返回key所对应的的value值
  print(dic)                  # 输出弹出即删除所对应的键值对的字典
  print(ret1)
  # 若key值不存在 则报错

• popitem方法

• res = dic.popitem()         # 返回的是最后一个键值对，返回的是元组类型  
  print(res)
  print(dic)                  # 输出{'name': 'Messi', 'career': 'Barcelona'}

• 键值keys，values值和键值对的输出

• print(dic.keys())
  l1 = []
  for k in dic.keys():
      l1.append(k)
  print(l1)                   # 输出所有keys的列表数据
  print(list(dic.keys()))     # 与上面的方法完全等价    
  print(list(dic.values()))   # 输出所有values值的列表
  print(list(dic.items()))    # 输出所有键值对元组的列表  [('name', 'Messi')。。。。]

• 循环方法

• dic={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  for k in dic:
      print(k,dic[k])         # 输出键值对字符串
  
  for b in dic.keys():
      print(b,dic[b])         # 同样与上面的方法等价
  
  for v in dic.values():      # 输出values值的字符串
      print(v)
  
  for k,v in dic.items():     # 与输出键值对的方法等价
      print(k,v)

• 根据key值获取value

• dic={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  
  v = dic.get('name')         # 根据其中的keys值来返回value值 如果不存在此key值则放回None        
  print(v)

• 快速创建一个字典

• li1 = ['name','nationality','career']      
  print(dict.fromkeys(li1,'messi'))       # 快速的创建一个字典，字典所对应的values统统是messi

• update方法

• dic1={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  newdic = {'name':'messi','age':32,'nationality':'spanish'}
  dic1.update(newdic)                 # 更新dic1中的键值对 如果新的字典中存在旧字典中没有的键值，就在旧字典中增加没有的键值对。
  print(dic1)

• setfault方法

  dic1={'name':'Messi','career':'Barcelona','nationality':'agentina'}
  res = dic1.setdefault('name','messi')       # 如果字典中有该keys值只不过value值不一样，那么就不修改字典，并且返回原字典的values值
  res2 = dic1.setdefault('sex','male')        # 如果字典中没有该keys值那么就在原来字典中添加该键值对，并且返回的是新键值对的values值
  print(res2)
  print(res)
  print(dic1)
  # 有则不改 无则加冕

• 值得注意的是字典是一个无序类型的数据，因此只能通过键值对的一一对应来取值存值

• 集合

• 三原则

1. 集合里面的元素必须是不可变类型即可hash类型
2. 集合里面不允许存在重复的数据，虽然不会报错但是集合会自动去重
3. 集合是一个无序的数据类型

• 定义

• na = {1,2,3,4,5,6,7,8}
  odd = {1,3,5,7,9}
  a = set((1,))       # 一种定义集合的方式就是用set方法输入元组
  print(a)

• 集合的数学运算（交并集等）

• 

• na = {1,2,3,4,5,6,7,8}
  odd = {1,3,5,7,9}
  
  print(na & odd)             # 返回两者的交集
  print(na | odd)             # 返回两者的合集
  print(na ^ odd)             # 返回两者的合集-交集
  print(na - odd)             # 返回na中除odd有的元素
  print(odd - na)             # 返回odd中na没有的元素

• 父集、子集和是否相等的运算

• na = {1,2,3,4,5,6,7,8}
  odd = {1,3,5,7,9}
  
  na1 = {1,2,3,4,5,6,7,8,9}
  print(na1 >= odd)           # 判断na1是否为odd的父集 如果是的话则返回布尔值True
  print(odd <= na1)           # 判断odd是否为na1的子集
  print(na == na1)            # 判断两者的元素是否一模一样

   

• 常用的操作

• update操作

• odd = {1,3,5,7}
  odd.update({9,11,13})       # 更新原集合中没有指定集合的元素，即在原集合中增加没有的元素
  print(odd)

• 去除值的操作

• odd = {1,3,5,7}
  print(odd.pop())        # 返回的是集合中的第一个元素
  print(odd)

• odd = {1,3,5,7}
  
  print(odd.remove(3))      # 返回的None 就只是单纯的删除而已
  print(odd)

• odd = {1,3,5,7}
  
  print(odd.discard(3))      # 返回的None 就只是单纯的删除而已
  print(odd)

• discard和remove两者的区别是，假如删除了集合中不存在的元素，discard方法不会报错，而remove方法会报错