Python的列表、元组、字典篇（中）

目录

一、列表推导式

二、嵌套列表

三、元组

四、字典

---

一、列表推导式

1、说明：用非常简洁的方式对列表或其他可迭代对象的元素进行遍历、过滤或再次计算，快速生成满足特定需求的新列表

2、格式：[expression for expr1 on squence1 if condition1

                                    for expr2 on squence2 if condition2

                                    ...]

3、在逻辑上等价于一个循环语句

4、代码例子：

（1）

data = [num for num in range(20) if num%2==1]
等价于
data = []
for num in range(20):
    if num%2 == 1:
        data.append(num)

（2）

data = [(x,y) for x in range(3) for y in range(2)]
等价于
data = []
for x in range(3):
    for y in range(2):
        data.append((x,y))

（3）

from random import random

data = [[random() for j in range(5)] for i in range(3)]
等价于
from random import random

data = []
for i in range(3):
    temp = []
    for j in range(5):
        temp.append(random())
    data.append(temp)

5、综合应用与例题解析

使用列表推导式，输入一个包含若干整数的列表，输出由其中的奇数组成的新列表。例如，输入[1,2,3,4,5,6,7,8]，输出[1, 3, 5, 7]。

data = eval(input('请输入一个包含若干整数的列表：'))
print([num for num in data if num%2==1])

---

二、嵌套列表

1、概念：列表中存储的元素也是列表

2、创建方式：与普通列表的创建方式相同

a = [[0],[1],[2,3]]

以上代码创建了一个嵌套列表，包含3个列表类型的元素，其中索引为0的元素是[0]，索引为1的元素是[1]，索引为2的元素是[2, 3]

3、获取

（1）若希望访问嵌套的内层列表中的元素，需要先使用索引获取内层列表，再使用索引访问内层列表中的元素

 （2）获取嵌套的第一个内层列表中的第一个元素的示例代码如下：

nesting_li = [['李瑶', '王濯'], ['李蒙'], ['张宝', '李清']]
print(nesting_li[0][0])

 （3）若希望向嵌套的内层列表中添加元素，需要先获取内层列表，再调用相应的方法往指定的列表中添加元素

nesting_li = [['hi'], ['Python']]
nesting_li[0].append('Python')
print(nesting_li)

---

三、元组

1、性质：

（1）通过把若干个元素放在一对圆括号中创建元组

注意：如果只有一个元素，需要多加一个逗号，比如：(3,)

（2）通过使用tuple()函数把列表、字典、集合、字符串以及range对象、map对象、zip对象或其他类似对象转换为元组

2、相同点：元组可以看作是轻量级列表，元组与列表的相似之处

（1）都属于有序序列

（2）支持双向索引和切片操作

（3）支持运算符+、*和in，也支持内置函数

3、元组与列表的区别

（1）元组是不可变的，不能直接修改元组中元素的值，也不能为元组增加或删除元素。因此，元组没有提供append()、extend()和insert()等方法，也没有remove()和pop()方法

（2）元组的访问速度比列表更快，开销更小。如果定义了一系列常量值，主要用途只是对进行遍历或其他类似操作，则建议使用元组而不用列表

（3）元组可以使得代码更加安全。例如，调用函数时使用元组传递参数可以防止在函数中修改元组，而使用列表则无法保证这一点

（4）元组可用作字典的键，也可以作为集合的元素，但列表不可以，包含列表的元组也不可以

4、序列解包

（1）对多个变量同时进行赋值，即把一个序列或可迭代对象中的多个元素的值同时赋值给多个变量

注意：等号左侧变量的数量和等号右侧值的数量必须一致

（2）序列解包也可以用于列表、元组、字典、集合、字符串及enumerate对象、filter对象、zip对象、map对象等

（3）注意：用于字典时，默认是对字典的“键”进行操作

①如果需要对字典的“键：值”元素进行操作，需要使用字典的items()方法明确说明

②如果需要对字典的“值”元素进行操作，需要使用字典的values()方法明确说明

x, y, z = 1, 2, 3                 # 多个变量同时赋值
x, y, z = (False, 3.5, 'exp')     # 元组支持序列解包
x, y, z = [1, 2, 3]               # 列表支持序列解包
x, y = y, x                       # 交换两个变量的值
x, y, z = map(int, '123')         # map对象支持序列解包
data = {'a': 97, 'b': 98}
x, y = data.values()              # 使用字典的“值”进行序列解包

---

四、字典

1、概念

（1）属于容器对象，包含若干元素，每个元素包含“键”和“值”两部分，两部分用冒号分隔，不是一种对应关系

（2）不同元素之间用逗号分隔，所有元素放在一个大括号中

（3）“键”可以是任意不可变数据，如：整数、浮点数、复数、字符串、元组等类型，但不可以是列表、集合、字典或其他可变类型，包含列表等可变数据的元组也不能

（4）“键”不可以重复，“值”可以重复

（5）字典的元素是无序的

data = {'name':'张三', 'age':18, 'sex':'M'}
print(data)
data = dict(name='张三', age=18, sex='M')
print(data)
data = dict.fromkeys([1, 2, 3, 4])    # 以指定的数据为“键”，“值”为空
print(data)
data = dict(zip('abcd', [97,98,99,100]))
print(data)

 2、添加、修改字典元素

（1）添加：字典对象的update()方法可以将另一个字典的元素一次性全部添加到当前字典中

add_dict = {'stu1': '小明'}
add_dict.update(stu2='小刚')  
add_dict['stu3'] = '小兰' 
print(add_dict)

（2）修改：当两个字典中存在相同的“键”，则以另一个字典中的“值”为准，对当前字典进行更新

①代码例子：

modify_dict = {'stu1': '小明', 'stu2': '小刚', 'stu3': '小兰'}
modify_dict.update(stu2='张强')   	
modify_dict['stu3'] = '刘婷'       	
print(modify_dict)

 ②代码例子：

sock = {'IP':'127.0.0.1','port':80}
#更新了一个元素的“值”，增加了一个新元素
sock.update({'IP':'192.168.9.62','protocol':'TCP'})
print(sock)

 3、删除字典元素

（1）pop()方法：可以根据指定的“键”删除字典中的指定元素，若删除成功则返回目标元素的“值”

per_info = {'001': '张三', '002': '李四', '003': '王五', '004': '赵六', }
per_info.pop('001')
print(per_info)

（2）popitem()方法：可以随机删除字典中的元素，若删除成功则返回目标元素（删除并返回一个包含两个元素的元组，其中两个元素分别是字典元素的“键”和“值”）

per_info = {'001': '张三', '002': '李四', '003': '王五', '004': '赵六'}
per_info.popitem() 
print(per_info)

（3）del：删除指定的“键”对应的元素

sock ={'IP':'192.168.9.62','port':'80','protocol':'TCP'}
print(sock.pop('IP'))
print(sock.popitem())
del sock['port']
print(sock)

（4）clear方法：清空字典中的元素

per_info = {'001': '张三', '002': '李四', '003': '王五', '004': '赵六', }
per_info.clear()
print(per_info)

4、查询字典元素

（1）查看指定的所有元素

①items()方法：可以查看字典的所有元素，该方法会返回一个dict_items对象

per_info = {'001': '张三', '002': '李四', '003': '王五'}
print(per_info.items())

②dict_items对象：支持迭代操作，结合for循环可遍历其中的数据，并将遍历后的数据以(key, value)的形式显示

per_info = {'001': '张三', '002': '李四', '003': '王五'}
for i in per_info.items():
      print(i)

 （2）查看字典中的所有键

①keys()方法：可以查看字典中所有的键，该方法会返回一个dict_keys对象

per_info = {'001': '张三', '002': '李四', '003': '王五'}
print(per_info.keys())

 

②dict_keys对象：支持迭代操作，通过for循环遍历输出字典中所有的键

per_info = {'001': '张三', '002': '李四', '003': '王五'}
for i in per_info.keys():
     print(i)

 （3）查看字典中的所有值

①values()方法：可以查看字典的所有值， 该方法会返回一个dict_values对象

per_info = {'001': '张三', '002': '李四', '003': '王五'}
print(per_info.values())

 

②dict_values对象：支持迭代操作，可以使用for循环遍历输出字典中所有的值

per_info = {'001': '张三', '002': '李四', '003': '王五'}
for i in per_info.values():
     print(i)

 5、字典元素的访问

（1）字典支持下标运算，把“键”作为下标可以返回对应的“值”，不存在该“键”时，会抛出异常

（2）get()方法：获取指定“键”对应的“值”，不存在该“键”时，则返回空值或指定的值

（3）字典对象支持元素迭代，可以将其转换为列表或元组，也可以用for循环遍历其中的元素，默认情况下是遍历字典的“键”，具体遍历方法看上面第4点查询字典元素

data = dict(name='张三', age=18, sex='M')
print(data['name'])                         # 使用“键”作为下标，访问“值”
print(data.get('age'))
print(data.get('address', '不存在这个键'))   # “键”不存在，返回默认值
print(list(data))                           # 把所有的“键”转换为列表
print(list(data.values()))                  # 把所有的“值”转换为列表
print(list(data.items()))                   # 把所有的元素转换为列表
for key, value in data.items():             # 遍历字典的“键：值”元素
    print(key, value, sep='\t')