数据类型的基本使用

数据类型：dict、tuple、set 的基本使用及内置方法，数据类型总结 - 图1

字典dict的基本使用

  • 用途：按照key:value的方式存放多个值，其中key对value应该有描述性的效果


  • 定义方式：在{}内用逗号分隔开多个元素，每个元素都是key:value的组合，其中value可以是任意类型但是key必须是不可变类型，通常是字符串类型，并且key不能重复 ```python d={1:11111, 1.1:22222, “k1”:333333, (1,2,3):44444, [1,2,3]:5555} # d=dict(…) print(d[1]) # 报错 TypeError: unhashable type: ‘list’

dict数据类型转换 (数据类型的转换比较狭窄)

res = dict([(“name”, “jack”), [“age”, 18], [“gender”, “male”]]) print(res) # {‘name’: ‘egon’, ‘age’: 18, ‘gender’: ‘male’}

res = dict(a=1, b=2, c=3) # 可以用这种方式造字典 print(res) # {‘a’:1, ‘b’:2, ‘c’:3}

d = {} # 造空字典 d = dict() print(type(d)) #

{} + fromkeys 可以快速初始化字典

res = {}.fromkeys([‘name’, “age”, “gender”], None) # 前面每一个值都跟None配对 res = {}.fromkeys([‘name’, “age”, “gender”], 11) # 前面每一个值都跟11配对 res[“name”] = 666 # 只有name值变了，其余的都不变

key先准备好，value值先置空None，保证初始状态之后再赋值给value

通常都是None

res = {}.fromkeys([‘name’, “age”, “gender”], [])

res[“name”] = 666 print(res) # {‘name’: 666, ‘age’: [], ‘gender’: []}

res[“name”].append(111) print(res) # {‘name’: [111], ‘age’: [111], ‘gender’: [111]}

  2. <a name="c288f7d5"></a>
  3. ### dict 常用操作
  4. **优先掌握的操作**
  6. **1、按key存取值：**可存可取，key不存在会直接报错
  7. ```python
  8. d = {"k1": 111, 'k2': 222}
  10. print(d['k1'])  # 111
  12. d['k1'] = 6666  # key存在为修改值
  13. d['k3'] = 6666  # 字典是可以根据不存在的key往里面加值的
  15. print(d)  # {'k1': 6666, 'k2': 222, 'k3': 6666}

2、统计字典内部键值对的个数 len

  1. d = {"k1": 111,'k2':222}
  3. print(len(d))  # 2

3、成员运算in和not in: 判断的是key

  1. d = {"name": "jack",'age':18}
  3. print("jack" in d)  # False
  4. print("name" in d)  # True

4、删除元素

  1. d = {"name": "jack", 'age': 18}
  3. # 方式一：万能删除法
  4. del d["name"]
  5. print(d)  # {'age': 18}
  7. # 方式二：指定k弹出键值对 给出v
  8. v = d.pop("name")  # 指定key删除
  9. print(d)  # {'age': 18} 显示key已经删除
  10. print(v)  # jack  pop删除功能会把删除key对应的value值返回 
  12. # 方式三：弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
  13. item = d.popitem()
  14. print(item)  # ('age', 18) popitme删除法会把删除的key和value值存成元组返回
  15. print(d)  # {}

5、键keys()，值values()，键值对items()

  1. # keys() values() items() 在python2中是列表 在python3中是迭代器(老母猪)
  3. d = {"name": "jack", 'age': 18, "gender": "male"}
  5. # 获取字典所有的键 看成列表即可
  6. print(d.keys())  # dict_keys(['name', 'age', 'gender'])
  8. # 获取字典所有的值 看成列表即可
  9. print(d.values())  # dict_values(['jack', 18, 'male'])
  11. # 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v
  12. print(d.items())  # dict_items([('name', 'jack'), ('age', 18), ('gender', 'male')])

6、循环

  1. d={"name":"jack",'age':18,"gender":"male"}
  2. for k in d.keys():
  3.     print(k)
  5. for k in d:  # 同上，不加.keys()默认就是
  6.     print(k)    
  7. '''
  8. name
  9. age
  10. gender
  11. '''
  13. for v in d.values(): # 只遍历value
  14.     print(v)
  15. '''
  16. jack
  17. 18
  18. male
  19. '''
  20. for k,v in d.items():  # k,v = ('gender', 'male'),
  21.     print(k,v)
  22. '''
  23. name jack
  24. age 18
  25. gender male
  26. '''
  28. # 用list的方式还原成Python 2 的样子
  29. print(list(d.keys()))  # ['name', 'age', 'gender']
  30. print(list(d.values()))  # ['egon', 18, 'male']
  31. print(list(d.items()))  # [('name', 'jack'), ('age', 18), ('gender', 'male')]

7、d.get()（取值方式）

  1. d={"name": "jack", 'age': 18, "gender": "male"}
  2. # 方式一：
  3. print(d["name"])  # jack 
  4. print(d["xxx"])  # key不存在直接报错，按k取值不太推荐使用该方式
  6. # 方式二：
  7. print(d.get("name"))  # jack
  9. # 没取到key返回None，key值不存在的时候采用此种方式
  10. print(d.get("xxx", '哈哈哈'))  # None 第二个参数 可以在k不存在的时候自定义返回信息

dict 内置的方法

需要掌握的操作

  1. d = {"name": "egon", 'age': 18, "gender": "male"}
  3. # clear()：清空字典里面的key和value值
  4. d.clear()  # 清空字典
  5. print(d)  # {}
  7. # copy()：浅copy 复制
  8. d.copy()
  9. print(d) # {'name': 'jack', 'age': 18, 'gender': 'male'}
  11. d = {"name": "jack", 'age': 18}
  12. if "gender" not in d:
  13.     d['gender'] = "male"
  14. print(d)  # {'name': 'jack', 'age': 18, 'gender': 'male'}
  16. # setdefault()：key不存在则添加key:value,key如果存在则什么都不做
  17. d.setdefault("gender","male")  # 与上面if 同种功能
  19. print(d)  # {'name': 'jack', 'age': 18, 'gender': 'male'}
  22. # update()  # 更新字典，不相同的加入老字典，相同的新替旧
  23. d = {"name": "jack", 'age': 18, "gender": "male"}
  24. d.update({"k1": 111, "name": "xxx"}) 
  26. print(d)  # {'name': 'xxx', 'age': 18, 'gender': 'male', 'k1': 111}
  • 该类型总结
    • 存多个值
    • 无序
    • 可变

元组tuple 的基本使用

  • 用途：元组就相当于一种不可变的列表，所以说元组也是按照位置存放多个任意类型的元素


  • 定义方式：在 () 内用逗号分隔开多个任意类型的元素，但是元组内元素不支持‘修改’(索引指向的元素的内存地址不能改变) ```python x = (11) print(x, type(x)) # 11

整型 浮点型 字符串 列表

t = (11, 11.33, “xxx”, [44,55]) print(t[-1][0]) # 44 print(type(t)) #

tuple数据类型转换:只要是可迭代的(支持for循环)数据类型都可以转换成元组tuple

print(tuple(111)) # TypeError: ‘int’ object is not iterable

print(tuple(11.11)) # TypeError: ‘int’ object is not iterable

print(tuple(‘hello’)) # (‘h’, ‘e’, ‘l’, ‘l’, ‘o’)

print(tuple([11, 22, 33])) # (11, 22, 33)

print(tuple({‘name’: ‘jason’, ‘pwd’: 123})) # (‘name’, ‘pwd’)

注意：如果元组内只有一个元素，那么必须用逗号分隔

t = (11,) print(type(t)) # 

  2. <a name="57818ca7"></a>
  3. ### tuple 常用操作
  4. **优先掌握的操作**
  6. **1、按索引取值（正向取+反向取）：**只能取，不能改
  7. ```python
  8. t = (11, 22, 33)
  9. print(t[1])  # 22
  10. print(t[-1])  # 33
  12. # t[0] = 7777  # 元组不支持赋值操作

2、切片（顾头不顾尾，步长）

  1. t = (11, 22, 33, 44, 55, 666)
  2. # 切片
  3. print(t[1:5])  # (22, 33, 44, 55)
  4. # 步长
  5. print(t[0:4:2])  # (11, 33)

3、长度

  1. t = (11, 22, 33, 44, 55, 666)
  3. print(len(t))  # 6

4、成员运算in和not in

  1. t = (11, 22, 33, [44, 55, 666])
  3. print([44, 55, 666] in t) # True

5、循环

  1. t = (11, 22, 33, [44, 55, 666])
  2. for x in t:
  3.     print(x)
  4. '''
  5. 11
  6. 22
  7. 33
  8. [44, 55, 666]
  9. '''

tuple 内置方法

需要掌握的操作

  1. t = (33, 22, 33, [44, 55, 666])
  2. # count()：统计某个元素出现的个数
  3. print(t.count(33))  # 2  
  5. # index()：指定范围从1开始找
  6. print(t.index(33, 1, 4)) # 2 
  8. """
  9. 元组指的不可变，是元组索引对应的内存地址不可变，
  10. 如果元组内子元素是列表的话是可以改的
  11. """
  • 该类型总结
    • 存多个数
    • 有序
    • 不可变

数据类型：dict、tuple、set 的基本使用及内置方法，数据类型总结 - 图2

集合类型set的基本使用

  • 用途：去重和关系运算
    • （1）无法保证顺序 ```python msg = “hello” res = set(msg) print(res) # 去重且无序，得到是集合类型 print(‘’.join(res)) # 转换回字符串得到的是乱序

names = [‘jason’, ‘lxx’, ‘lili’, “jason”, “jason”] print(set(names)) # {‘jason’, ‘lili’, ‘lxx’} 转集合后，去重无序 print(list(set(names))) # [‘lxx’, ‘jason’, ‘lili’] 去重转回列表类型，去重且无法保证原始顺序

  2.    - （2）只能针对不可变类型元素的去重
  3. ```python
  4. students_info = [
  5.     {"name":"jason", "age":18, "gender":"male"},
  6.     {"name":"tom", "age":19, "gender":"male"},
  7.     {"name":"jack", "age":38, "gener":"female"},
  8.     {"name":"jason", "age":18, "gender":"male"},
  9.     {"name":"jason", "age":18, "gender":"male"},
  10. ]
  11. new_l = []
  12. for info in students_info:
  13.     if info not in new_l:
  14.         new_l.append(info)  # 用l.append一点一点的遍历
  15. print(new_l)  # 达到去重效果并且保证顺序，此种方式是去重常用

  • 定义方式：在{ }内用逗号分隔开多个元素，集合内元素的特点有三个

    1.       ** (1）集合内元素必须是不可变类型**<br />**     （2）集合内元素不能重复**<br />**     （3）集合内元素无序**
  1. #   整型 浮点型  字符串    元组     
  2. s = {11, 3.1, "xxx", (1, 2, 3)}
  3. print(s)  # {3.1, (1, 2, 3), 11, 'xxx'}
  5. s = {11, 11, 11, 11, 11, 22, 33}  # s = set(...)
  6. print(s)  # {33, 11, 22} 重复元素只能留一个
  7. print(type(s))  # <class 'set'>
  10. # 1.定义空集合需要使用关键字set
  11. s1 = set()  # 定义空集合,必须得用set()
  12. print(s, type(s))  # set()  <class 'set'>
  14. # 2.类型转换:能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
  15. res = set("hello")
  16. print(res)  # {'o', 'h', 'l', 'e'} 注意：去重且无序
  18. name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
  19. # 先将列表转换成集合
  20. s1 = set(name_list)
  21. # 再将去重之后的集合转换成列表
  22. l1 = list(s1)
  23. print(l1)  # ['jason', 'kevin']
  25. # 小练习
  26. ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
  27. # 1.基本要求:去重即可
  28. s1 = set(ll)
  29. ll1 = list(s1)
  30. print(ll1)  # [33, 66, 11, 44, 77, 22, 55]
  32. # 2.拔高要求:去重并保留原来的顺序
  33. # 1).先定义一个新列表
  34. new_list = []
  35. # # 2).for循环ll列表
  36. for i in ll:
  37.     # 3).判断当前元素是否在新列表中
  38.     if i not in new_list:
  39.         # 3.1) 如果不在 则添加到新列表
  40.         new_list.append(i)
  41.     # 3.2) 如果在 则不管
  42. print(new_list)  # [33, 22, 11, 44, 55, 66, 77]

set 常用操作

优先掌握的操作

（1）交集：取两个集合的共同部分：求两个用户的共同好友

  1. friends1 = {"tom", "jack", "kevin", "jason", "goff"}
  2. friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}
  4. # 方式一
  5. print(friends1 & friends2)  # {'goff', 'jason'}
  6. # 方式二
  7. print(friends1.intersection(friends2))  
  10. # 将两个集合的交集结果赋值给 friends1
  11. friends1 = friends1 & friends2  
  12. # 方式一
  13. print("friends1")
  14. # 方式二
  15. friends1.intersection_update(friends2)
  16. print("friends1")

（2）并集：两个集合并到一起：求两个用户所有的好友

  1. friends1 = {"tom", "jack", "kevin", "jason", "goff"}
  2. friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}
  4. # 方式一
  5. print(friends1 | friends2)   
  6. # 方式二
  7. print(friends1.union(friends2)） 
  8. # {'cindy', 'mary', 'Jerry', 'ricky', 'tom', 'kevin', 'goff', 'jack', 'jason'}

（3）差集： 一个集合减掉与另外一个集合共同的部分

  1. friends1 = {"tom", "jack", "kevin", "jason", "goff"}
  2. friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}
  4. # 用户1独有的好友
  5. # 方式一
  6. print(friends1 - friends2)  # {'jack', 'tom', 'kevin'}
  7. # 方式二
  8. print(friends1.difference(friends2))     
  10. # 求用户2独有的好友
  11. # 方式一
  12. print(friends2 - friends1)  # {'mary', 'ricky', 'cindy', 'Jerry'}
  13. # 方式二 
  14. print(friends2.difference(friends1))

(4) 交叉补集/对称差集：两个集合互相减，然后再并到一起：用户1和用户2各自的好友

  1. friends1 = {"tom", "jack", "kevin", "jason", "goff"}
  2. friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}
  4. # 方式一: ^ 与 | 方式更简单 
  5. res = (friends1 - friends2)| (friends2- friends1) 
  6. res = friends1 ^ friends2   
  7. print(res)  # ('mary', 'jack', 'cindy', 'tom', 'ricky', 'Jerry', 'kevin'}  
  9. # 方式二
  10. print(friends1.symmetric_difference(friends2)

（5）父子集合：当一个集合完全包含了另外一个集合，该集合才能称爹

  1. s1 = {1, 2, 3}
  2. s2 = {3, 4, 5}
  3. # 没有包含关系，s1不包含s2所以无法成立，只能说明s1不是s2它爹
  4. print(s1 >= s2)  # False 
  6. # 大于等于和小于等于指的不是传统认知的比大小，指的是包含关系
  7. print(s2 <= s1)  # False 
  10. s1 = {1, 2, 3}
  11. s2 = {1, 2}
  12. # 有包含关系，集合成立说明s1包含s2，s1是s2它爹  
  13. # 方式一
  14. print(s1 >= s2)  # Ture 
  15. # 方式二
  16. print(s1.issuperset(s2)) # Ture 
  18. # 有包含关系，集合成立说明s2继承自s1，s2是s1它儿子 
  19. # 方式一               
  20. print(s2 <= s1)  # Ture  
  21. # 方式二
  22. print(s2.issubset(s1))  # Ture

set 内置方法

需要掌握的操作

1、update()：更新，把两个集合并到一起，去重

  1. s1 = {1, 2, 3}
  2. s1.update({3, 4, 5})
  4. print(s1)  # {1, 2, 3, 4, 5} 相当于可以一次性加多个值

2、add()：加值，一次加一个值

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

3、删除

  1. # 方式一：remove（）
  2. s1 = {1, 2, 3}
  3. s1.remove(3)  # 指定元素删除
  4. print(s1) # {1, 2}
  6. # 方式二：discard（）
  7. s1 = {11, 22, 33, "xx", "yy", "zz"}
  8. s1.remove(33333)  # 删除元素不存在 报错
  9. s1.discard(33333)  # 删除元素不存在 啥事都不会做，不会报错
  10. print(s1)
  12. s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
  13. res=s1.pop()  
  14. print(s1)  # 随机删除元素
  15. print(res)  # 返回删除值，相当于pop取走的值
  17. s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
  18. s1.clear()  # 整个清空掉
  19. print(s1)  # set() 空集合

4、copy()：复制集合，无序

  1. s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
  2. s1.copy()
  4. print(s1)  # {33, 'aa', 'yy', 11, 44, 'zz', 22, 55, 'xx'}

5、isdisjoint()：判断两个集合完全没有共同部分，毫不相干

  1. # 没有相同部分
  2. s1 = {1, 2, 3}
  3. s2 = {4, 5, 6}
  4. print(s1.isdisjoint(s2))  # True  
  6. # 有相同部分
  7. s1 = {1, 2, 3}
  8. s2 = {3, 4, 5, 6}
  9. print(s1.isdisjoint(s2))  # False
  • 该类型总结
    • 存多个值
    • 无序
    • 可变
  1. s1 = {1,2,3}
  2. print(id(s1))    # 2048402597696
  3. s1.add(4)      
  4. print(s1)     # {1, 2, 3, 4}
  5. print(id(s1))    # 2423667894080 id没变
  6. # 集合本身纯粹的元素应该是不可变类型，但集合本身就是一个可变类型。

数据类型总结

  • 按存储空间的占用分（从低到高）

    1. 整型
    2. 浮点型
    3. 字符串
    4. 集合：无序，即无序存索引相关信息
    5. 元组：有序，需要存索引相关信息，不可变
    6. 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
    7. 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

  • 按存值个数区分

    • 标量／原子类型（不可再分，只能存一个值）：整型，浮点型，字符串
    • 容器类型（能存多个值）：列表，元组，字典，集合

  • 按可变不可变区分

    • 可变：列表，字典，集合
    • 不可变：整型，浮点型，字符串，元组

  • 按访问顺序区分

    • 直接访问：整型，浮点型
    • 顺序访问（序列类型）：字符串，列表，元组
    • key值访问（映射类型）：字典