第四章 Python数据类型

第四章 Python数据类型

4.1 list列表

• 列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素

4.1.1 定义

l1 = []  # 定义一个空列表
l2 = ["1", "a", 1, 2]  # 定义一个非空列表

4.1.2 独有方法

1. append追加元素

• 在列表尾追加一个元素

l1 = []
print(id(l1))   # 输出追加前的内存地址
l1.append("4")  # 在列表中尾部追加值
print(id(l1))  # 输出追加后的内存地址
print(l1)

2427070632320
2427070632320
[‘4’]

2. extend批量追加

将一个列表中的元素逐一添加到另一个列表

• for循环实现如下：

l1 = [1, 2]
l2 = ["a", "b"]
for i in l1:
    l2.append(i)
print(l2)

[‘a’, ‘b’, 1, 2]

• extend()方法实现如下：

l1 = [1, 2]
l2 = ["a", "b"]
l2.extend(l1)
print(l2)

[‘a’, ‘b’, 1, 2]

3. insert插入

• 在集合中插入一个对象，可以是字符串，列表等其他元素
• insert(n,m)，其中n代表要插入位置的索引号，m就表示想要插入的元素

l1 = [1, 2]
l2 = ["a", "b"]
l2.insert(1, l1)  # 将l1插入到l2的索引1的位置，元素后移在索引1的位置放入l1列表。
print(l2)

[‘a’, [1, 2], ‘b’]

4. remove删除

在原列表中根据值删除（从左到右找到第一个删除），如果列表中不存在该元素，会报错。

例1：

l1 = [1, 2]
l2 = ["a", "b", "a"]
l2.remove("a")
print(l2)

[‘b’, ‘a’]

例2：抽奖从奖池中删除奖品

import random
prize_list = ['apple', 'banana', 'cherry']
while prize_list:
    user_name = input('请输入姓名参与抽奖：').strip()
    prize = random.choice(prize_list)
    prize_list.remove(prize)
    print(f"恭喜{user_name}抽中{prize}！")
print("本次抽奖已经结束，欢迎下次再来")

请输入姓名参与抽奖：张三
恭喜张三抽中banana！
请输入姓名参与抽奖：李四
恭喜李四抽中apple！
请输入姓名参与抽奖：王二
恭喜王二抽中cherry！
本次抽奖已经结束，欢迎下次再来

5. pop删除

• 从已预约的人数中选出最先预约的指定数量的人

message = "欢迎来到温泉酒店"
print(message.center(50,"."))
user_list = []
while True:
    name = input("请输入姓名进行预约(Q/q退出)：")
    if name.upper() == "Q":
        break
    user_list.append(name)
num = 4  # 定义预约的人数
for i in range(num):  # 按照定义的次数4遍历，执行四次循环内的动作
    success_name = user_list.pop(0)  # 每次都删除第一个索引值，直到将列表中的名字删除完成
    print("恭喜{}同学预约成功".format(success_name))
fail_name = "、".join(user_list)
print("很遗憾{}同学没有抢到名额".format(fail_name))

…欢迎来到温泉酒店…
请输入姓名进行预约(Q/q退出)：张三
请输入姓名进行预约(Q/q退出)：李四
请输入姓名进行预约(Q/q退出)：王二
请输入姓名进行预约(Q/q退出)：赵大
请输入姓名进行预约(Q/q退出)：小哥哥
请输入姓名进行预约(Q/q退出)：小姐姐
请输入姓名进行预约(Q/q退出)：q
恭喜张三同学预约成功
恭喜李四同学预约成功
恭喜王二同学预约成功
恭喜赵大同学预约成功
很遗憾小哥哥、小姐姐同学没有抢到名额

6. clear清空列表

• 修改原有列表为空列表

v1 = [1, 2, 3, 4, 5]
print(id(v1))
v1.clear()  # 清空原列表，没有返回值
print(id(v1))
print(v1)

2321836200320
2321836200320
[]

• 给列表名复制一个新的空列表，这个方式修改了内存指针

v1 = [1, 2, 3, 4, 5]
print(id(v1))
v1 = []
print(id(v1))
print(v1)

2463539908992
2463539910848
[]

• for循环清空列表，该方式不实用，以下是错误示范

v1 = [1, 2, 3, 4, 5]
print(id(v1))
for i in v1:
    v1.remove(i)
    print(v1)
print(id(v1))
print(v1)

输出如下：第一次循环删除了索引0对应的1，第二次删除了索引1对应的3，第三次删除了索引2对应的5，最终结果是[2,4]

1731268366720
[2, 3, 4, 5]
[2, 4, 5]
[2, 4]
1731268366720
[2, 4]

• for循环删除，正确示范思路一：

v1 = [1, 2, 3, 4, 5]
print(id(v1))
for i in range(0, len(v1)):
    v1.remove(v1[0])
print(id(v1))
print(v1)

2390990967168
2390990967168
[]

• for循环删除，正确示范思路二：

v1 = [1, 2, 3, 4, 5]
print(id(v1))
for i in v1[::-1]:  # i是v1的倒序列表中的元素，然后赋值给i，在将i从正序列表中删除，相当于倒序删除，不会存在漏删
    v1.remove(i)
print(id(v1))
print(v1)

1310825697664
1310825697664
[]

7. reverse()翻转原列表

v1 = [1, 2, 3, 4, 5]
v1.reverse()  # 列表翻转，没有返回值，直接对列表操作
print(v1)

[5, 4, 3, 2, 1]

8. index 索引

根据挪个元素找到该元素在里表中对应的索引号，注意如果列表中不存在该元素会报错，从左到右找到第一个元素返回索引值

v1 =["a", "b", "c", "d"]
res = v1.index("c")
print(res)

2

4.1.3 公共功能

1. 相加

v1 = ["a", "b", "c", "d"]
v2 = [1, 2, 3, 4]
print(v1+v2)

[‘a’, ‘b’, ‘c’, ‘d’, 1, 2, 3, 4]

2. 相乘

v1 = ["a", "b", "c"]
v2 = 3
print(v1 * v2)

[‘a’, ‘b’, ‘c’, ‘a’, ‘b’, ‘c’, ‘a’, ‘b’, ‘c’]

3. 获取长度

v1 = ["a", "b", "c"]
v2 = len(v1)
print(v2)

3

4. 索引、切片

索引：索引值为负一表示从右向左取第一个

v1 = ["a", "b", "c"]
v2 = v1[0]
print(v2)

a

切片：实例显示从0开始到3索引，间隔两位取值

v1 = ["a", "b", "c"]
v2 = v1[0:3:2]
print(v2)

[‘a’, ‘c’]

5 . for循环遍历

ip_list = ['192.168.1.11', '192.168.3.11', '172.168.1.1', '172.16.31.10']
for i in ip_list[::-1]:
    if i.startswith('192'):
        ip_list.remove(i)
print(ip_list)

[‘172.168.1.1’, ‘172.16.31.10’]

4.1.4 转换

1. 整数和bool值无法转换为列表

n1 = 100
data_list = list(n1)
print(data_list)

n1 = True
data_list = list(n1)
print(data_list)

TypeError: ‘int’ object is not iterable

2. 将字符串转换成列表

n1 = "赵钱孙李"
data_list = list(n1)
print(data_list)

[‘赵’, ‘钱’, ‘孙’, ‘李’]

n1 = "赵钱孙李"
data_list = []
for i in n1:
    data_list.append(i)
print(data_list)

[‘赵’, ‘钱’, ‘孙’, ‘李’]

3. 元组转化为列表

t1 = (1, 2, 3)
data_list = list(t1)
print(data_list)

[1, 2, 3]

4. 字典转换为列表

d1 = {"name": "张三", "age": 18}
new_list = list(d1)
print(new_list)

[‘name’, ‘age’]

4.2 Tuple元组

元组（tuple），是一个有序，且不可变的容器，在里面的可以存放多个不同类型的元素。

4.2.1 定义

• 定义:建议在在元组的最后加一个逗号

v1 = (11, 22, 33)
v2 = ("张三", "李四")
v3 = (True, 123, "张三", [11, 22, 33])

• 比较下面三种定义的区别

v1 = (1)
v2 = 1
v3 = (1,)
print(type(v1))
print(type(v2))
print(type(v3))

<class ‘int’>
<class ‘int’>
<class ‘tuple’>

• 比较一下两种元组v1和v2的区别：v1元组中的都是整形(单个数字没有打逗号，被认为是整形），v2元组中的元素都是元组

v1 = ((1), (2), (3))
v2 = ((1,), (2,), (3,),)
print(type(v1))
print(type(v2))

• 元组本身不可变，但是如果在与元素中包含可变的数据类型，那么该数据类型可以正常添加或者删除

t1 = (1, 2, 3, [])
t1[3].append("a")
print(t1)
t1[3].append("b")
print(t1)

(1, 2, 3, [‘a’])
(1, 2, 3, [‘a’, ‘b’])

4.3 集合

集合是一个无序、可变、不允许数据重复的容器

4.3.1 定义

s1 = {1, 2, 3} # 定义个集合
s2 = {}  # 定义一个空字典
print(type(s1))
print(type(s2))

<class ‘set’>
<class ‘dict’>

• 无序

集合中的元素排列是没有顺序的，因此不能使用索引

s1 = {1, 2, 3, "a", "b", "c"}
print(s1)

{‘b’, 1, 2, 3, ‘c’, ‘a’}

{1, 2, 3, ‘b’, ‘a’, ‘c’}

从输出结果来看，第一次和第二次运行输出的结果顺序不一样，印证集合中的参数是无序的。

• 可变

可以针对结合进行元素的添加（add）和删除（discard），采用discard方法删除元素时，如果删除一个不存在的元素，不会报错。

1. 添加

s1 = {1, 2, 3, "a", "b", "c"}
print(s1)
s1.add("+d")
print(s1)

{1, 2, 3, ‘c’, ‘a’, ‘b’}
{1, 2, 3, ‘c’, ‘+d’, ‘a’, ‘b’}

2. discard删除：集合中不存在该与元素不会报错。

s1 = {1, 2, 3, "a", "b", "c"}
print(s1)
s1.discard(1)
print(s1)

{1, 2, 3, ‘c’, ‘b’, ‘a’}
{2, 3, ‘c’, ‘b’, ‘a’}

3.remove删除：集合中不存在该元素会报错。

s1 = {1, 2, 3, "a", "b", "c"}
print(s1)
s1.remove("d")
print(s1)

• 不允许数据重复

1. 集合中不存在重复的元素，因此集合的一个很大的用处是进行去重

data_list = [1, 1, 2, 2, 2, 3]
s1 = set(data_list)
print(s1)

{1, 2, 3}

2. for循环为列表去重

data_list = [1, 1, 2, 2, 2, 3]
new_list = []
for i in data_list:
    if i in new_list:
        pass
    else:
        new_list.append(i)
print(new_list)

[1, 2, 3]

4.3.2 存储原理

• 字典里面存储的元素，一定要可hash的数据类型，不然就会报错

  • 可hash的数据类型：int，float，tr，tuple等一些不可变的数据

  • 不可hash的数据类型：set，list，dict等一些可变的数据

• 查询速度快

  • 集合在存储内部元素时，首先会将元素进行hash计算，根据得出的结果将元素放在hash的某个特定的位置。
  • 这样当以后需要查找某个元素时，也会将该元素进行hash计算，之后直接到hash表相应的位置去进行查找。

4.4 字典

字典是无序，键不重复且元素只能是键值对的可变的容器

• 字典的元素必须是键值对

  这是为了更精确的索引，在自动中根据键来找对应的值

• 字典的键不能重复，重复会被覆盖

  字典中的值就像列表中一样，可以相同，且如果想要保持数据的唯一性，则需要为该数据添加独一无二的标识，而字典中的key就可以起到这个作用。

• 无序、有序

  在python3.6之前，字典是一种无序的数据类型，而在Python3.6之后，字典修正成了一种==有序==的数据类型。

4.4.1 定义

d1 = {"name": "张三", "age": 18}  # 定义给非空字典，元素是key和值的用冒号相连，例如"name":"张三"是一个元素
d2 ={}  # 定义一个空字典

• 字典中对于键和值的要求：
  • 键：必须是可hash的数据类型
  • 值：任意类型

d1 = {"name": "张三", "age": 18}
res = d1["name"]  # []内不使用数值作为索引，而是使用key作为索引
print(res)  # 显示key"name"对应的值为"张三"

张三

• 字典的使用场景：
  • 当我们想要表示一组固定信息的时候，用字典更加直观。

4.4.2字典的相关功能和方法

1. 由字符串生成字典

device_list = []
for i in range(1, 3):
    ip = f"192.168.1.{i}"
    device_info = {"ip": ip, "device_type": "Huawei"}
    device_list.append(device_info)
print(device_list)

[{‘ip’: ‘192.168.1.1’, ‘device_type’: ‘Huawei’}, {‘ip’: ‘192.168.1.2’, ‘device_type’: ‘Huawei’}]

2. 将参数提取出来

device_list = []
for i in range(1, 3):
    ip = f"192.168.1.{i}"
    device_info = {"ip": ip, "device_type": "Huawei"}
    device_list.append(device_info)
# print(device_list)  # 已注释
for i in device_list:
    ip = i["ip"]
    device_type = i["device_type"]
    print(f"交换机{ip}，设备型号{device_type}登录成功")

交换机192.168.1.1，设备型号Huawei登录成功
交换机192.168.1.2，设备型号Huawei登录成功

3. 获取所有的键

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
for i in device_info:
    print(i)

ip
device_type
role

4. 获取所有的值

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
for i in device_info.values():
    print(i)

192.168.1.1
Huawei
leaf

5. 获取所有的键值

• 获取键值对

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
for i in device_info.items():
    print(i)

(‘ip’, ‘192.168.1.1’)
(‘device_type’, ‘Huawei’)
(‘role’, ‘leaf’)

• 将键值对的值分开获取：

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
for i, j in device_info.items():
    print(i, j)

ip 192.168.1.1
device_type Huawei
role leaf

6. 根据键来修改值

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
device_info["ip"] = "192.168.1.2"
print(device_info)

{‘ip’: ‘192.168.1.2’, ‘device_type’: ‘Huawei’, ‘role’: ‘leaf’}

7. 删除集合

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
device_info.clear()
print(device_info)

{}

8. 获取值（get）

• 通过索引获取

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
if "ip" in device_info:
    print(device_info["ip"])
else:
    print("不存在")  # 如果"ip"键不存在则返回"不存在"。

192.168.1.1

• 通过get方法

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
res = device_info.get("ip", "不存在")  # 提取ip的值，如果不存在则返回“不存在”
print(res)

192.168.1.1

• 根据设备角色分类统计设备数量：通过for循环和if判断。

device_list = [{"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"},
               {"ip": "192.168.1.2", "device_type": "Huawei", "role": "spine"},
               {"ip": "192.168.1.3", "device_type": "Huawei", "role": "leaf"},
               {"ip": "192.168.1.4", "device_type": "Huawei", "role": "spine"},]
leaf_num = 0
spin_num = 0
for i in device_list:
    if i["role"] == "leaf":
        leaf_num += 1
    elif i["role"] == "spine":
        spin_num += 1
num_info = {"leaf_num": leaf_num, "spin_num": spin_num}
print(num_info)

• 根据设备角色分类统计设备数量：通过==get==方法实现

device_list = [{"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"},
               {"ip": "192.168.1.2", "device_type": "Huawei", "role": "spine"},
               {"ip": "192.168.1.3", "device_type": "Huawei", "role": "leaf"},
               {"ip": "192.168.1.4", "device_type": "Huawei", "role": "spin"}, ]
num_info = {}
for i in device_list:
    num = num_info.get(i["role"], 0)  # 如果num_info中没有这个角色，则num置0，下一步加1
    num += 1
    num_info[i["role"]] = num  # 在num_info集合中循环添加键值对
    print(num_info)  # 在每一个循环中打印，显示结果如下

{‘leaf’: 1}
{‘leaf’: 1, ‘spine’: 1}
{‘leaf’: 2, ‘spine’: 1}
{‘leaf’: 2, ‘spine’: 1, ‘spin’: 1}

9. 修改值（setdefault）

device_list = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
device_list.setdefault("neighbor", "1.1.1.1")  # 添加新的键值对
device_list.setdefault("ip", "myfault")  # 该键“ip”已存在在字典中，不修改值。
print(device_list)

{‘ip’: ‘192.168.1.1’, ‘device_type’: ‘Huawei’, ‘role’: ‘leaf’, ‘neighbor’: ‘1.1.1.1’}

添加的键值对，如果不存在，则添加；如果已经存在，则添加失败，不会报错。

• 根据角色统计出对应的IP地址，方案一：

  device_list = [{"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"},
                 {"ip": "192.168.1.2", "device_type": "Huawei", "role": "spine"},
                 {"ip": "192.168.1.3", "device_type": "Huawei", "role": "leaf"},
                 {"ip": "192.168.1.4", "device_type": "Huawei", "role": "spin"}, ]
  device_info = {"leaf": [], "spine": []}
  for i in device_list:
      if i["role"] == "leaf":
          device_info["leaf"].append(i["ip"])
      elif i["role"] == "spine":
          device_info["spine"].append(i["ip"])
  print(device_info)

{‘leaf’: [‘192.168.1.1’, ‘192.168.1.3’], ‘spine’: [‘192.168.1.2’]}

• 根据角色统计出对应的IP地址，方案二
  • setdefault()方法，如果字典中如果已有，则不添加，不报错，如果没有该键值对，则添加。

device_list = [{"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"},
               {"ip": "192.168.1.2", "device_type": "Huawei", "role": "spine"},
               {"ip": "192.168.1.3", "device_type": "Huawei", "role": "leaf"},
               {"ip": "192.168.1.4", "device_type": "Huawei", "role": "spin"}, ]
device_info = {}
for i in device_list:
    device_info.setdefault(i["role"], [])  # 在新字典中device_info中新加一个键值对，为角色和空列表
    device_info[i["role"]].append(i["ip"])  # 在对应的角色中的值（列表）中，添加IP地址
    print(device_info)

{‘leaf’: [‘192.168.1.1’]}
{‘leaf’: [‘192.168.1.1’], ‘spine’: [‘192.168.1.2’]}
{‘leaf’: [‘192.168.1.1’, ‘192.168.1.3’], ‘spine’: [‘192.168.1.2’]}
{‘leaf’: [‘192.168.1.1’, ‘192.168.1.3’], ‘spine’: [‘192.168.1.2’], ‘spin’: [‘192.168.1.4’]}

10. 更新字典键值对（update）

使用update方法可以更新字典中的键值对，如果更新的keys在字典当中不存在，则添加新的键值对，如果存在则会进行更新

device_list = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
device_list.update({"neighbor": "1.1.1.1"})  # 向字典中添加键值对，注意函数的参数是字典{"neighbor": "1.1.1.1"}
print(device_list)
device_list.update({"ip": "192.168.1.10"})  # 字典中以存在ip键值对，因此更新键值对的值
print(device_list)

{‘ip’: ‘192.168.1.1’, ‘device_type’: ‘Huawei’, ‘role’: ‘leaf’, ‘neighbor’: ‘1.1.1.1’}
{‘ip’: ‘192.168.1.10’, ‘device_type’: ‘Huawei’, ‘role’: ‘leaf’, ‘neighbor’: ‘1.1.1.1’}

11. 移除指定的键值对（pop）

device_list = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
print(device_list)
res = device_list.pop("ip")  # 根据key来移除键值对，并可以将移除键值对的值可以作为返回值复制给其他变量。
print(res)
print(device_list)

{‘ip’: ‘192.168.1.1’, ‘device_type’: ‘Huawei’, ‘role’: ‘leaf’}
192.168.1.1
{‘device_type’: ‘Huawei’, ‘role’: ‘leaf’}

12. 按顺序移除键值对（popitem）

按照顺序移除一个键值对，并将移除的键值对以元组的形式进行返回

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
k, v = device_info.popitem()  # 从右向左删除一个字典的元素
print(k, v)
print(device_info)

role leaf
{‘ip’: ‘192.168.1.1’, ‘device_type’: ‘Huawei’}

device_info = {"ip": "192.168.1.1", "device_type": "Huawei", "role": "leaf"}
res = device_info.popitem()  # 从右向左删除一个字典的元素
print(res)
print(device_info)

(‘role’, ‘leaf’)
{‘ip’: ‘192.168.1.1’, ‘device_type’: ‘Huawei’}

4.5 注意事项：

• []代表是列表
• {}代表是字典或者集合，如果大括号中没有元素，代表是一个空字典，如果有元素，那么看元素是否是键值对，如果是键值对类型，代表是字典，否则是集合。
• ()代表是元组，需要注意的时，在定义的时候加上一个逗号，否则可能会识别成其他的类型。