数据类型及内置方法2

一、元组

1. 作用：能够存储多个元素，元素与元素之间逗号隔开。元组可以是任意类型，元组不能被修改。

2. 定义

   t = (1, 2, 3, 'a', [1, 2, 3])
   t = tuple((1, 2, 3))
   t = tuple((1,))    # 内部只有一个元素的时候，也要加逗号。
   print(type（t）)
   

3. 有序or无序

   有序

4. 可变or不可变

   不可变

5. 常用操作和内置方法

   • 按索引取值（只能取不能存）

     t = (1, 2, [3, 4])
     print(t[0]    # 1
           
     t[-1][1] = 5
     print(t)    # (1, 2, [3, 5])    # 包含的可变类型能改
     

   • 切片（顾头不顾尾，步长）

     t = (1, 2, 3, 4)
     print(t[::2])    # (1, 3)
     

   • 长度

     t = (1, 2, 3, 4)
     print(len(t))    # 4
     

   • 成员运算

     t = (1, 2, 3)
     print(1 in t)    # True
     

   • 循环

     t = (1, 2, 3)
     for i in t:
         print(i)
     

   • 计数

     t = (1, 1, 3)
     print(t.count(1))    # 2
     

   • 查询索引

     t = (1, 2, 3)
     print(t.index(2))    # 1
     

二、字典

1. 作用：能存储多组键值对，key是不可变类型，value可以是任意类型

2. 有序or无序

   无序

3. 可变or不可变

   可变

4. 定义

   d = {'name': 'byx', 'age': 18}    # 第一种方法
   
   d = dict(name = 'byx', age = 18)    # 第二种方法
   
   l = [
   ['name', 'byx'],
   ['age', 18],
   ['hobby', 'read']
   ]
   d = {}
   for k, l in l:
   d[k] = v
   print(d)    # 第三种方法
   
   l = [
   ['name', 'byx'],
   ['age', 18],
   ['hobby', 'read']
   ]
   d = dict(l)
   print(d)    # 第四种方法
   
   d1 = {'name': 'byx', 'name': 'yxb'}
   print(d1)    # {'name': 'yxb'}    字典的key如果重复，会存入最后一组重复的键值对
   

5. 操作以及内置方法

   • 按key存取值（可存可取）

     d = {'name': 'byx', 'age': 18}
     print(d['name'])    # byx
     d['name'] = 'yxb'
     print(d['name'])    # yxb
     
     print(id(d))    # 1934832365856
     d['gender'] = 'male'
     print(d, id(d))    # {'name': 'byx', 'age': 18, 'gender': 'male'} 1934832365856
     

   • 成员运算

     d = {'name': 'byx', 'age': 18}
     print(i8 in d)    # False     只能判断键
     

   • 删除

     d = {'name': 'byx', 'age': 18}
     del d['name']    
     print(d)    # {'age': 18}
     
     d = {'name': 'byx', 'age': 18}
     res = d.pop('age')    # 弹出
     print(res)    # 18    返回值是值，键不存在时报错
     print(d)    # {'name': 'byx'}
     
     
     d = {'name': 'byx', 'age': 18}
     res = d.popitem()    # 尾部以元组形式弹出键值对
     print(res)    # ('age', 18)
     print(d)    # {'name': 'byx'}
     
     d = {'name': 'byx', 'age': 18}
     d.clear()    # 清空
     print(d)    # {}
     

   • 获取所有键、值、键值对

     d = {'name': 'byx', 'age': 18}
     
     print(d.keys())    # dict_keys(['name', 'age'])
     print(d.values())    # dict_values(['byx', 18])
     print(d.items())    # dict_items([('name', 'byx'), ('age', 18)])     ；列表套元组
     

   • 循环

     d = {'name': 'byx', 'age': 18}
     for i in d:
         print(i,end=" ")    # name age
     

   • get取值

     d = {'name': 'byx', 'age': 18}
     print(d.get('name'))    # byx
     print(d.get('hobby', '字典里没有hobby'))    # 字典里没有hobby 
     # get可以传第二个参数，key不存在时，返回第二个参数。不传参时返回None
     

   • dict.fromkeys()创造字典

     l1 = ['name', 'password', 'age']
     print(dict.fromkeys(l1, 123))    # {'name': 123, 'password': 123, 'age': 123}    
     

   • dict.setdefalt()增加键值对

     d = {'name': 'byx', 'pwd': 123}
     res1 = d.setdefault('name', 'ybx')    # 添加存在的键值对
     print(res1)    # byx    返回存在的值
     print(d)    # {'name': 'byx', 'pwd': 123}    不做修改
     
     res2 = d.setdefault('age', 18)    # 添加不存在的键值对
     print(res2)    # 18    返回添加的值
     print(d)    # {'name': 'byx', 'pwd': 123, 'age': 18}    添加成功
     

   • dict.update()字典拼接

     d1 = {'name': 'byx', 'pwd': 123}
     d2 = {'age': 18, 'hobby': 'read'}
     d1.update(d2)
     print(d1)    # {'name': 'byx', 'pwd': 123, 'age': 18, 'hobby': 'read'}
     

三、集合

1. 作用

   • 关系运算
   • 去重

2. 定义

   集合的元素遵循三原则：

   • 每个元素必须是不可变类型
   • 没有重复元素（自动去重）
   • 无序

   s = {1, 2, 3, 4, 5}
   s = set({1, 2, 3, 4, 5})
   print(type(s))
   
   x = {}
   print(type(x))    # 空字典
   
   s1 = set()
   print(type(s1))    # 空集合
   

3. 操作与内置方法

   • 长度

   s = {1, 2, 3, 4}
   print(len(s))
   

   • 成员运算

   • 集合运算

     group1 = {'a', 'b', 'c'}
     group2 = {'b', 'c', 'd'}
     print(group1 & group2)    # {'b', 'c'}    交集
     print(group1 - group2)    # {'a'}    差集
     print(group1 ^ group2)    # {'d', 'a'}    对称差
     print(group1 | group2)    # {'d', 'a', 'b', 'c'} 
     

   • 添加

     s = {1, 2, 3, 4}
     print(s.add(5))    # {1, 2, 3, 4, 5}
     

   • 删除

     s = {1, 2, 3}
     print((s.remove(4))    # 报错
           
     s = {1, 2, 3}
     print(s.discard(4))    # None    不报错