pytnon中的元组

• 定义:元组(tuple) 是Python中常用的一种数据结构。由不同的元素组成，每个元素可以存储不同类型的数据，如字符串、数字、甚至元组。元组是‘写保护'的，即元组中元素作为一个整体， 创建后不能再做任何修改操作。
• 元组表达符为: ()
• 类型:tuple
• 元组是不可变的(定义好元组后不能够直接去修改元组中元素)
• 元组中的元素只有1个的时候，一定 要在后面加上一- 个逗号,如果不加原始元素是什么类型它就是什么类型
• *
  
  • t1=(1)
    
  • print(type(t1))#<class 'int'>
    
  • t2=(1,)#在元素后加逗号
    
  • print(type(t2))#<class 'tuple'>
    
  • t=(1,2,3,4,5,6)#定义元组
    
  • print(type(t))#<class 'tuple'>
    
  • t.pop
    
  • print(t)#异常
    
• 元组中的常见操作
  
  • 
    
  • 
    
    • *
      
      • #往元组中添加元素
        
      • t=(1,2,3,4,5,6)#定义元组
        
      • print(type(t))#<class 'tuple'>
        
      • t1=list(t)#通过list把元组转换为列表
        
      • print(type(t1))#<class 'list'>
        
      • print(t1)#[1, 2, 3, 4, 5, 6]
        
      • t1.append(7)#往列表中插入元素
        
      • print(t1)#[1, 2, 3, 4, 5, 6, 7]
        
      • t2=tuple(t1)#把列表转换为元组
        
      • print(type(t2))#<class 'tuple'>
        
      • print(t2)#(1, 2, 3, 4, 5, 6, 7)
        
  • 
    
  • 元组和列表的区别？
    
    • 1 类型不同 list  tuple
      
    • 2 定义不同 列表通过[]定义，元组通过（）定义
      
    • 3.列表定义后是不可随意增删改（元素不受保护）
      
    • 4.元组定义后
      
  • 字符串转元组
    
    • a='hello'#定义字符串
      
    • a1=tuple(a)
      
    • print(a1)#('h', 'e', 'l', 'l', 'o')
      
  • #元组转换字符串
    
    • t=(1,2,3,4,5,6)#定义元组
      
    • t1=t.__str__()
      
    • print(type(t1))#<class 'str'>
      
    • print(t1)#(1, 2, 3, 4, 5, 6)
      
  • 元组也是支持切片操作
    
    • t=(1,2,3,4,5,6)#定义元组
      
    • print(t[5])#6
      
• pytnon中的字典
  
  • 定义：{} 花括号 （大括号）
    
  • 类型：dict
    
  • 字典中：键值对，键是唯一值可以不唯一
    
  • 键和值用冒号分割；
    
  • 键值对之间用逗号分割
    
  • *
    
    • d={}#定义空字典
      
    • print(type(d))#<class 'dict'>
      
    • d1={'name':'ym','age':'18'}#定义字典,里面有一个键值对
      
    • print(d1)#{'name': 'ym', 'age': '18'}
      
    • d2={'name':''}#定义字典，字典中没有值一定要加上引号，否则会抛异常
      
    • print(d2)
      
  • *
    
    • # t=('a',1)#定义元组
      
    • # print(type(t))#
      
    • # d=dict(t)#转换为字典
      
    • # print(type(d))#不能转换字典
      
  • *
    
    • t1=[('a',1)]#定义列表
      
    • print(type(t1))#
      
    • d=dict(t1)#转换为字典
      
    • print(type(d))#
      
    • print(d)#{'a': 1}
      
  • 
    
    • 1、#原字典中没有相同的键，则会将键值添加到字典中
      
      • d1={'name':'zhangsan','age':18}#定义字典
        
      • d1["score"]=100#设置键值对
        
      • print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}
        
      • d2={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • #原字典中有此键，会执行替换
        
      • d2["score"]=90#设置键值对
        
      • print(d2)#{'name': 'zhangsan', 'age': 18, 'score': 90}
        
    • 2、#键 keys
      
      • d2={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • k=d2.keys()#取出当前字典中所有键
        
      • print(k)#dict_keys(['name', 'age', 'score'])
        
      • print(type(k))#<class 'dict_keys'>
        
    • 3、#值values
      
      • d3={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • v=d3.values()#取出当期字典中所有的值
        
      • print(v)#dict_values(['zhangsan', 18, 100])
        
  • 
    
    • 4、#取指定键的值
      
      • d3={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • value=d3["name"]#获取name这个键对应的值
        
      • print(value)#zhangsan
        
    • 5、#设置键值对
      
      • 注：此方法执行后会进行判断，如果发现字典中没有此键则会把键值对设置到字典中，如果原字典中有此键则不会执行
        
      • d3={'name': 'zhangsan', 'age': 18, }#定义字典
        
      • d3.setdefault("score",100)#添加键值对
        
      • print(d3)#{'name': 'zhangsan', 'age': 18, 'score': 100}
        
      • #不会替换
        
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • d4.setdefault("score",93)#添加键值对
        
      • print(d4)#{'name': 'zhangsan', 'age': 18, 'score': 100}
        
    • 6、#删除字典
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • del d4#删除整个字典
        
      • print(d4)#抛异常，因为字典已被删除
        
    • 7、删除指定键值对
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • del d4['score']#删除指定的键和对应的值
        
      • print(d4)#{'name': 'zhangsan', 'age': 18}
        
  • 
    
    • 8、字典遍历 ：for 变量名 in 字典名  当前变量获取到的值为键，值不显示
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • for i in d4:#
        
      •     print(i)#name age score
        
    • #获取值
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • for i in d4:
        
      •     #print(i)
        
      •     print(d4)#zhangsan 18 100
        
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • for i in d4:
        
      •     #print(i)
        
    • 9、通过items函数实现变量获取键值对
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • for k,v in d4.items():
        
      •     print(k,v)
        
  • 
    
    • 10、pop（key）函数
      
      • 4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • d5=d4.pop('score')#删除scroe这个键，返回对应键的值
        
      • print(d5)
        
    • 12、clear函数 清空字典
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • d4.clear()#把字典中的键值都清空掉
        
      • print(d4)#{} 空字典
        
    • 13、get函数： 获取指定键的值
      
      • 如果没有指定的键则返回none
        
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • d5=d4.get('name')#获取name这个键对应的值
        
      • print(d5)#zhangsan
        
      • print（d4.get('name')）#zhangsan
        
      • print（d4.get('aa')）#none
        
  • 
    
    • 14、给键指定的值
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • #不指定值
        
      • print({}.fromkeys(['name','age']))#{'name': None, 'age': None}
        
      • #指定值
        
      • print({}.fromkeys(['name','age'],'dcs'))#{'name': 'dcs', 'age': 'dcs'}
        
    • 15、python2  has_key 函数检查指点是否有指定的键存在
      
      • python3  __contains__函数检查字典是否有指定的键存在
        
      • 有存在返回true  反之返回false
        
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • print(d4.__contains__('name'))#True
        
      • print(d4.__contains__('sex'))#False
        
  • 
    
    • 16、删除字典中的键值对，并返回删除的数据（默认删除末尾）
      
      • d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
        
      • print(d4.popitem())#('score', 100)
        
      • print(d4.popitem())#('age', 18)
        
    • 17、更新把两个字典拼接形成新的字典
      
      • d1={'name': 'zhangsan', 'age': 18}#定义字典
        
      • d2={'score': 100}#定义字典
        
      • d1.update(d2)
        
      • print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}
        
    • #存在相同的键，则执行替换
      
      • d3={'name': 'zhangsan', 'age': 18,'score': 90}#定义字典
        
      • d4={'score': 100}#定义字典
        
      • d3.update(d4)
        
      • print(d3)#{'name': 'zhangsan', 'age': 18, 'score': 100}
        
    • 把两个列表设置为字典
      
      • a=['a','b','c']#定义列表
        
      • c=[1,2,3]#定义列表
        
      • l=zip(a,c)#把列表拼接形成多个元组，索引值相同的为一个整体如('a',1)
        
      • d=dict(l)#转换为字典
        
      • print(d)#{'a': 1, 'b': 2, 'c': 3}
        
      • print(type(d))#
        
• pytnon中的集合
  
  • 可变集合: set
    
  • 不可变集合: frozenset
    
  • 区别点:
    
    • 相同点都能够去重
      
  • 不同点:
    
    • 可变集合去重后可以实现增删改
      
    • 不可变集合去重后不可以进行增删改