一、列表

列表可以修改，字符串和元组不能修改

1、列表中的方法

方法	描述
list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x)
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误
list.count(x)	返回 x 在列表中出现的次数
list.sort()	对列表中的元素进行排序
list.reverse()	倒排列表中的元素
list.copy()	返回列表的浅复制，等于a[:]

2、列表当堆栈使用

堆栈：最先进入的元素最后一个被释放(后进先出、先进后出)

列表使用append()方法实现将一个元素添加到堆栈顶部，使用不指定索引的pop()方法可将元素从堆栈顶部释放出来

"""
堆栈：最先进入的元素最后一个被释放(后进先出、先进后出)
列表使用append()方法实现将一个元素添加到堆栈顶部，使用不指定索引的pop()方法可将元素从堆栈顶部释放出来
"""
stack = [1 , 2 , 3]print("添加元素前stack列表为：" , stack )
# append()方法实现将一个元素添加到堆栈顶部
stack.append(4)
stack.append(5)
stack.append(5)
print("添加元素后stack列表为：" , stack )print("删除元素前stack列表为：" , stack )
# 使用不指定索引的pop()方法可将元素从堆栈顶部释放出来
stack.pop()
stack.pop()
print("删除元素后stack列表为：" , stack )

添加元素前stack列表为： [1, 2, 3]
添加元素后stack列表为： [1, 2, 3, 4, 5, 5]
删除元素前stack列表为： [1, 2, 3, 4, 5, 5]
删除元素后stack列表为： [1, 2, 3, 4]

3、列表当队列使用

队列：最先进入的元素最先一个被释放(先进先出、后进后出)

列表当队列使用的效率较低，在列表的最后位置添加或者弹出元素时速度较快，而在列表中间插入或者从头部弹出元素时速度却不快（因为所有其他的元素都得一个一个地移动）

列表当队列使用时，只能在头部或最后位置添加/删除元素

"""
列表当队列使用
列表当队列使用时，只能在头部或最后位置添加/删除元素
"""from collections import deque
# 定义列表listA
listA = ['Kobe' , 'TD' , 'KG' , 'Curry']
# 列表转化为队列
queueA = deque(listA)
print("队列queueA添加元素前：" , queueA )
# 队列添加元素
queueA.append('Tmac')
print("队列queueA使用append()添加元素后：" , queueA )
queueA.appendleft('CP3')
print("队列queueA使用appendleft()添加元素后：" , queueA )
# 队列删除最左边元素
queueA.popleft()
print("队列queueA使用popleft()删除元素后：" , queueA )
queueA.pop()
print("队列queueA使用pop()删除元素后：" , queueA )

队列queueA添加元素前： deque(['Kobe', 'TD', 'KG', 'Curry'])
队列queueA使用append()添加元素后： deque(['Kobe', 'TD', 'KG', 'Curry', 'Tmac'])
队列queueA使用appendleft()添加元素后： deque(['CP3', 'Kobe', 'TD', 'KG', 'Curry', 'Tmac'])
队列queueA使用popleft()删除元素后： deque(['Kobe', 'TD', 'KG', 'Curry', 'Tmac'])
队列queueA使用pop()删除元素后： deque(['Kobe', 'TD', 'KG', 'Curry'])

4、列表推导式

语法：[表达式 for 变量 in 序列或迭代对象]，以方括号包括推导式

列表推导式在逻辑上相当于一个循环，只是形式更加简洁

列表推导式的执行顺序：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，左边第一条语句是最后一层

[x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]

等价于：

for x in range(1,5)if x > 2for y in range(1,4)if y < 3x*y

1）、使用列表推导式实现嵌套列表的平铺

# 1、使用列表推导式实现嵌套列表的平铺
listA = [[1 ,2 ,3 ] , [4 , 5 , 6] , [7 , 8 ,9 ]]
# for num in list1是内循环；for list1 in listA是外循环；num是参数
print("使用列表推导式实现嵌套列表的平铺：" , [num for list1 in listA for num in list1])# 列表推导式等价于如下代码
listA = [[1 ,2 ,3 ] , [4 , 5 , 6] , [7 , 8 ,9 ]]
list2 = []
for list1 in listA:for num in list1:list2.append(num)
print("for循环实现嵌套列表的平铺：" , list2)

使用列表推导式实现嵌套列表的平铺： [1, 2, 3, 4, 5, 6, 7, 8, 9]
for循环实现嵌套列表的平铺： [1, 2, 3, 4, 5, 6, 7, 8, 9]

2）、 过滤不符合条件的元素

a、列出当前文件夹下所有Python的源文件

# 2.1、列出当前文件夹下所有Python的源文件
"""
说明：
1、endswith() 方法用于判断字符串是否以指定后缀结尾，语法：str.endswith(suffix[, start[, end]])
2、os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表，语法：os.listdir(path)
"""
import os
print("当前目录下所有.py文件为：" , [filename for filename in os.listdir('.') if filename.endswith('.py')])

当前目录下所有.py文件为： ['ZX_01_列表当堆栈使用.py', 'ZX_02_列表当队列使用.py', 'ZX_03_列表推导式.py', '__init__.py']

b、选择所有大于0的数字组成新表

# 2.2、选择所有大于0的数字组成新表
print ("列表中大于0的元素为：" , [i for i in [1 , 5 , 3 , -2 , -5 , -120 , 4 , 10 , -23] if i > 0 ] )

列表中大于0的元素为： [1, 5, 3, 4, 10]

c、操作字典

# 2.3、字典操作
person = {'Kobe':24 , "Curry":30 , "KD":35 , "KG":21 , "TD":21 , 'CP3':3 , "WADE":3 }
print ("输出字典中球员号码为3的球员名字：" , [ name for name , number in person.items() if number == 3 ])
print ("输出字典中kobe的球衣号码：" , [ number for name , number in person.items() if name == 'Kobe' ])

输出字典中球员号码为3的球员名字： ['CP3', 'WADE']
输出字典中kobe的球衣号码： [24]

d、找出列表中元素最大值的位置

# 2.4、找出列表中元素最大值的位置
#从random模块中导入randint(随机生成整数)
from random import randint
list_A = [randint(1 , 10) for i in range(20)]
#随机输出20次1和10之间的整数
print ("列表中最大元素为：" , [value for index , value in enumerate(list_A) if value == max(list_A)])
print ("列表中最大元素的索引为：" , [index for index , value in enumerate(list_A) if value == max(list_A)])

列表中最大元素为： [10]
列表中最大元素的索引为： [1]

3）、在列表推导式中使用多个循环，实现多序列元素的任意组合，并且可以结合条件语句过滤特定元素

print([ (x ,y) for x in [1 ,3 ,5 ,7 ,9] for y in [2 ,4 ,6 ,8 ,10] if x < 7 if y > 4 ])

[(1, 6), (1, 8), (1, 10), (3, 6), (3, 8), (3, 10), (5, 6), (5, 8), (5, 10)]

4）、使用列表推导式实现矩阵转置

# 4、使用列表推导式实现矩阵转置
list_B = [[1 ,2 ,3 ,4 ,5] ,[6 ,7 ,8 ,9 ,10] , [11 ,12 ,13 ,14 ,15] , [16 ,17 ,18 ,19 ,20]]
# 方法一：
print("方法一：" , [[raw[i] for raw in list_B]  for i in range(len(list_B[0]))])
print("raw[i] for raw in list_B不加[]：" , [raw[i] for raw in list_B for i in range(len(list_B[0]))])
# 方法二：
print("zip(* list_B)：" , zip(* list_B) ) # 返回一个zip对象
print("list(zip(* list_B))：" , list(zip(* list_B)) ) # 返回列表对象，列表元素嵌套的是元组
print("map(list,zip(* list_B))：" , map(list,zip(* list_B)) ) # 返回map对象
print("map(set,zip(* list_B))：" , map(set,zip(* list_B)) ) # 返回map对象
print("list(map(set,zip(* list_B)))：" , list(map(set,zip(* list_B))) ) # 返回列表对象，列表元素嵌套的是集合
print("方法二，list(map(list,zip(* list_B)))：" , list(map(list,zip(* list_B)))) # 返回列表对象，列表元素嵌套的是列表
# 方法三：
list_c = []
for i in range(len(list_B[0])):list_temp = []for raw in list_B:list_temp.append(raw[i])list_c.append(list_temp)
print("方法三：" , list_c)

方法一： [[1, 6, 11, 16], [2, 7, 12, 17], [3, 8, 13, 18], [4, 9, 14, 19], [5, 10, 15, 20]]
raw[i] for raw in list_B不加[]： [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
zip(* list_B)： <zip object at 0x000001F4B01F2BC8>
list(zip(* list_B))： [(1, 6, 11, 16), (2, 7, 12, 17), (3, 8, 13, 18), (4, 9, 14, 19), (5, 10, 15, 20)]
map(list,zip(* list_B))： <map object at 0x000001F4B01F2BC8>
map(set,zip(* list_B))： <map object at 0x000001F4B01F2C08>
list(map(set,zip(* list_B)))： [{16, 1, 11, 6}, {17, 2, 12, 7}, {8, 18, 3, 13}, {9, 19, 4, 14}, {10, 20, 5, 15}]
方法二，list(map(list,zip(* list_B)))： [[1, 6, 11, 16], [2, 7, 12, 17], [3, 8, 13, 18], [4, 9, 14, 19], [5, 10, 15, 20]]
方法三： [[1, 6, 11, 16], [2, 7, 12, 17], [3, 8, 13, 18], [4, 9, 14, 19], [5, 10, 15, 20]]

5）、列表推导式可以使用函数或复杂表达式

# 5、列表推导式可以使用函数或复杂表达式
def func(x):if x%2 == 0:x = x * 2else:x = x +1return x
print("列表推导式调用func(x)函数：" , [func(i) for i in [1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10] if i >= 3])
print("列表推导式使用复杂表达式：" , [i * 2 if i%2 == 0 else i + 1 for i in [1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10] if i >= 3])

列表推导式调用func(x)函数： [4, 8, 6, 12, 8, 16, 10, 20]
列表推导式使用复杂表达式： [4, 8, 6, 12, 8, 16, 10, 20]

6）、列表推导式支持文件对象迭代

# 6、列表推导式支持文件对象迭代
file = open("G:\Python\Runoob\ZX_14_数据结构\ZX_文件.txt" , 'r' , encoding='UTF-8') #只读的方法打开指定路径下文件
print("指定路径下文件内容为：" , [line.strip('\n') for line in file]) # line.strip('\n')去掉每行末尾的换行符'\n'
file.close()

指定路径下文件内容为： ['科比：24', '麦迪：1', '库里：30', '邓肯：21']

7）、使用列表推导式生产100以内的所有素数

# 7、使用列表推导式生产100以内的所有素数
# 判断素数方法一：一个大于1的自然数，除了1和它自身外，不能被其他自然数整除
# 判断素数方法二：自然数number除以2~根号下number再加1，求余数，不等于0说明该数为素数
from math import sqrt
print("判断素数方法一：" , [number for number in range(2 , 100) if number not in [number for i in range(2 , number) if number % i == 0]])
print("判断素数方法二：" , [number for number in range(2 , 100) if 0 not in [number%i for i in range(2 , int(sqrt(number))+1)]])

判断素数方法一： [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
判断素数方法二： [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

5、嵌套列表解析

方法一：使用列表推导式实现嵌套列表解析
方法二：使用zip()和map()函数实现嵌套列表解析
方法三：for循环实现嵌套列表解析

"""
嵌套列表解析
"""list_B = [[1 ,2 ,3 ,4 ,5] ,[6 ,7 ,8 ,9 ,10] , [11 ,12 ,13 ,14 ,15] , [16 ,17 ,18 ,19 ,20]]# 方法一：使用列表推导式实现嵌套列表解析
print("方法一：" , [[raw[i] for raw in list_B]  for i in range(len(list_B[0]))])
print("raw[i] for raw in list_B不加[]：" , [raw[i] for raw in list_B for i in range(len(list_B[0]))])# 方法二：使用zip()和map()函数实现嵌套列表解析
print("zip(* list_B)：" , zip(* list_B) ) # 返回一个zip对象
print("list(zip(* list_B))：" , list(zip(* list_B)) ) # 返回列表对象，列表元素嵌套的是元组
print("map(list,zip(* list_B))：" , map(list,zip(* list_B)) ) # 返回map对象
print("map(set,zip(* list_B))：" , map(set,zip(* list_B)) ) # 返回map对象
print("list(map(set,zip(* list_B)))：" , list(map(set,zip(* list_B))) ) # 返回列表对象，列表元素嵌套的是集合
print("方法二，list(map(list,zip(* list_B)))：" , list(map(list,zip(* list_B)))) # 返回列表对象，列表元素嵌套的是列表# 方法三：for循环实现嵌套列表解析
list_c = []
for i in range(len(list_B[0])):list_temp = []for raw in list_B:list_temp.append(raw[i])list_c.append(list_temp)
print("方法三：" , list_c)

方法一： [[1, 6, 11, 16], [2, 7, 12, 17], [3, 8, 13, 18], [4, 9, 14, 19], [5, 10, 15, 20]]
raw[i] for raw in list_B不加[]： [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
zip(* list_B)： <zip object at 0x000002A6E328AE08>
list(zip(* list_B))： [(1, 6, 11, 16), (2, 7, 12, 17), (3, 8, 13, 18), (4, 9, 14, 19), (5, 10, 15, 20)]
map(list,zip(* list_B))： <map object at 0x000002A6E328AD88>
map(set,zip(* list_B))： <map object at 0x000002A6E328ADC8>
list(map(set,zip(* list_B)))： [{16, 1, 11, 6}, {17, 2, 12, 7}, {8, 18, 3, 13}, {9, 19, 4, 14}, {10, 20, 5, 15}]
方法二，list(map(list,zip(* list_B)))： [[1, 6, 11, 16], [2, 7, 12, 17], [3, 8, 13, 18], [4, 9, 14, 19], [5, 10, 15, 20]]
方法三： [[1, 6, 11, 16], [2, 7, 12, 17], [3, 8, 13, 18], [4, 9, 14, 19], [5, 10, 15, 20]]

6、del语句

a、根据列表索引值删除某个特定的列表元素

b、删除一个列表切片

c、清空一个列表中的所有元素

d、删除列表（删除一个列表后输出列表，报错）

listA = [1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9]
# 根据索引删除特定元素
del listA[1]
del listA[2:5]
del listA[:]
print("listA为：" , listA)
del listA
print("listA为：" , listA)

Traceback (most recent call last):File "G:/Python/Runoob/ZX_14_数据结构/ZX_05_del语句.py", line 14, in <module>print("listA为：" , listA)
NameError: name 'listA' is not defined
listA为： []

7、元组和序列

• 元组由小括号()包含，元素之间使用逗号分隔开来；
• 元组是不可变数据，因此不支持元组内元素的增删改等操作，仅能通过索引查询元组元素；
• 可以使用del语句删除整个元组（删除后输出报错）；
• 序列以连续的整数为索引；
• 元组不支持推导式；使用小括号包裹推导式会生成生成器对象，而不是元组；
• 元组不可变，若元组的成员是可变类型，则元组成员可编辑

"""
元组和序列
"""
tupA = (1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9)
# 元组支持通过索引访问特定元素
print("tupA[1] -- " , tupA[1])
print("tupA为：" , tupA)
# 元组不支持通过索引删除特定元素
del tupA[1]
del tupA
print("listA为：" , tupA)
# 元组不可变，若元组的成员是可变类型，则元组成员可编辑
a , b , c = [1 , 2 , 3] , [4 , 5 , 6] , [7 ,8 , 9]
tupB = (a , b ,c)
print("tupB前:" , tupB)
b.append(10)
print("tupB后:" , tupB)
# 使用小括号包裹推导式会生成生成器对象，而不是元组
value = (2*x for x in range(2))
print("使用小括号包裹推导式会生成生成器对象，而不是元组:" , type(value))
print(next(value))
print(next(value))
print(next(value))

tupA[1] --  2
tupA为： (1, 2, 3, 4, 5, 6, 7, 8, 9)
Traceback (most recent call last):File "G:/Python/Runoob/ZX_14_数据结构/ZX_06_元组.py", line 9, in <module>del tupA[1]
TypeError: 'tuple' object doesn't support item deletion
Traceback (most recent call last):File "G:/Python/Runoob/ZX_14_数据结构/ZX_06_元组.py", line 11, in <module>print("listA为：" , tupA)
NameError: name 'tupA' is not defined
tupB前: ([1, 2, 3], [4, 5, 6], [7, 8, 9])
tupB后: ([1, 2, 3], [4, 5, 6, 10], [7, 8, 9])
Traceback (most recent call last):File "G:/Python/Runoob/ZX_14_数据结构/1.py", line 8, in <module>print(next(value))
StopIteration
使用小括号包裹推导式会生成生成器对象，而不是元组: <class 'generator'>
0
2

8、集合

• 集合由大括号{}包含，元素之间使用逗号分隔开来；
• 集合是可变数据，因此支持集合内元素的增删改查等操作；
• 可以使用del语句删除整个集合（删除后输出报错）；
• 集合支持集合推导式，语法为{表达式 for 变量 in 序列或迭代对象}，注意以大括号包括推导式
• 集合是一个无序不重复元素的集，基本功能包括关系测试和消除重复元素；
• 如果要创建一个空集合，必须用 set() 而不是 {} ，因为后者用于创建一个空的字典；

"""
集合：
1、集合由大括号{}包含，元素之间使用逗号分隔开来；
2、集合是可变数据，因此支持集合内元素的增删改查等操作；
3、可以使用del语句删除整个集合（删除后输出报错）；
4、集合支持集合推导式；
5、集合是一个无序不重复元素的集，基本功能包括关系测试和消除重复元素；
6、如果要创建一个空集合，必须用 set() 而不是 {} ，因为后者用于创建一个空的字典；
"""
setA = {1 , 2 , 3 ,4 ,6 ,5 ,9 ,7 ,8 ,9 ,4 ,10 , 'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
setB = set()
setC = {1 ,5 ,3 ,9 ,7 ,11 ,8}
# 集合去重
print("setA：" , setA)
# 判断成员
print("apple是否在setA中：" , 'apple' in setA)
# 两个集合的运算
print("setA - setC，在集合A中，但不在集合C中的元素为：" , setA - setC)
# 集合推导式实现setA - setC
print("集合推导式实现setA - setC，在集合A中，但不在集合C中的元素为：" , {x for x in setA if x not in setC})
print("交集：setA & setC，即在集合A中，又在集合C中的元素为：" , setA & setC)
# 集合推导式实现setA & setC
print("集合推导式实现setA & setC，即在集合A中，又在集合C中的元素为：" , {x for x in setA if x in setC})
print("并集：setA | setC，在集合A中，或在集合C中的元素为：" , setA | setC)
print("setA ^ setC，等于并集减交集，在集合A或C中，但不同时在集合A和C中的元素为：" , setA ^ setC)

setA： {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'apple', 'orange', 'pear', 'banana'}
apple是否在setA中： True
setA - setC，在集合A中，但不在集合C中的元素为： {'apple', 2, 4, 6, 10, 'orange', 'pear', 'banana'}
集合推导式实现setA - setC，在集合A中，但不在集合C中的元素为： {'apple', 2, 4, 6, 10, 'orange', 'pear', 'banana'}
交集：setA & setC，即在集合A中，又在集合C中的元素为： {1, 3, 5, 7, 8, 9}
集合推导式实现setA & setC，即在集合A中，又在集合C中的元素为： {1, 3, 5, 7, 8, 9}
并集：setA | setC，在集合A中，或在集合C中的元素为： {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'orange', 11, 'banana', 'apple', 'pear'}
setA ^ setC，等于并集减交集，在集合A或C中，但不同时在集合A和C中的元素为： {'apple', 2, 4, 6, 10, 11, 'orange', 'pear', 'banana'}

9、字典

• 字典以关键字key为索引，关键字可以是任意不可变类型，通常使用字符串或数值；
• 同一个字典内，关键字key必须互不相同；
• 一对大括号创建一个空的字典：{}
• 字典支持内部键值对的增删改查操作，可以使用del 字典名[key名]删除字典中key对应的value值，也可以使用del 字典名删除整个字典；
• 判断字典的key是否在字典内可以直接使用key in dict，而判断value是否在字典内，需使用value in dict.values()，因为字典的索引就是key；
• 构造函数 dict() 直接从键值对元组列表中构建字典
• 字典也有字典推导式，字典推导式可以用来创建任意键和值的表达式词典，语法：{表达式:表达式 for 变量 in 序列或迭代对象}，注意以大括号包括推导式，且for之前必须是一个键值对
• 如果字典的关键字key只是简单的字符串，可以使用关键字参数指定键值对；

"""
字典
1、字典以关键字key为索引，关键字可以是任意不可变类型，通常使用字符串或数值；
2、同一个字典内，关键字key必须互不相同；
3、一对大括号创建一个空的字典：{}
4、字典支持内部键值对的增删改查操作，可以使用del 字典名[key名]删除字典中key对应的value值，也可以使用del 字典名删除整个字典；
5、判断字典的key是否在字典内可以直接使用key in dict，而判断value是否在字典内，需使用value in dict.values()，因为字典的索引就是key；
6、构造函数 dict() 直接从键值对元组列表中构建字典
7、字典也有字典推导式，字典推导式可以用来创建任意键和值的表达式词典，语法：{表达式:表达式 for 变量 in 序列或迭代对象}，注意以大括号包括推导式，且for之前必须是一个键值对
8、如果字典的关键字key只是简单的字符串，可以使用关键字参数指定键值对；
"""
dictA = {"科比":24 ,"杜兰特":35 ,"库里":30 ,"乔丹":23 , "汤普森":11 }# 输出整个字典
print("字典dictA：" , dictA)# 输出字典某个key对应的value
print("字典dictA中dictA['科比']：" , dictA['科比'] )# 字典添加一个键值对
dictA['加内特'] = 21
print("字典添加一个键值对：" , dictA)# 字典删除一个键值对
del dictA['汤普森']
print("字典删除一个键值对：" , dictA)# 字典更新一个键值对
dictA['杜兰特'] = 7
print("字典更新一个键值对：" , dictA)# 输出字典中所有的key
print("字典dictA中所有的key为：" , (dictA.keys()))
# 输出字典中所有的key
print("字典dictA中所有的value为：" , (dictA.values()))# 判断元素是否在字典内
print("key科比是否在字典dictA中：" ,"科比" in dictA)
print("value24是否在字典dictA中：" ,24 in dictA.values())# 输出字典的键值对
print("字典dictA的键值对为：" , dictA.items())# 构造函数 dict() 直接从键值对元组列表中构建字典
listA = [("科比" , 24) ,("杜兰特" , 35) ,("库里" , 30) ,("乔丹" , 23) , ("汤普森" , 11)] # 列表listA元素为一个个的元组，元组子元素为键值对
print("构造函数 dict() 直接从键值对元组列表中构建字典:" , dict(listA))# 字典推导式可以用来创建任意键和值的表达式词典
print({i : i * i for i in range(1 , 20) if i % 2 == 0 })
# 字典推导式实现快速交换key和value
print("dictA交换key和value后：" , {key:value for value , key in dictA.items()})
print("dictA交换key和value前：" , dictA)# 如果字典的关键字key只是简单的字符串，可以使用关键字参数指定键值对
print("字典的关键字key是简单的字符串，可以使用关键字参数指定键值对:" , dict(sape=4139, guido=4127, jack=4098))

字典dictA： {'科比': 24, '杜兰特': 35, '库里': 30, '乔丹': 23, '汤普森': 11}
字典dictA中dictA['科比']： 24
字典添加一个键值对： {'科比': 24, '杜兰特': 35, '库里': 30, '乔丹': 23, '汤普森': 11, '加内特': 21}
字典删除一个键值对： {'科比': 24, '杜兰特': 35, '库里': 30, '乔丹': 23, '加内特': 21}
字典更新一个键值对： {'科比': 24, '杜兰特': 7, '库里': 30, '乔丹': 23, '加内特': 21}
字典dictA中所有的key为： dict_keys(['科比', '杜兰特', '库里', '乔丹', '加内特'])
字典dictA中所有的value为： dict_values([24, 7, 30, 23, 21])
key科比是否在字典dictA中： True
value24是否在字典dictA中： True
字典dictA的键值对为： dict_items([('科比', 24), ('杜兰特', 7), ('库里', 30), ('乔丹', 23), ('加内特', 21)])
构造函数 dict() 直接从键值对元组列表中构建字典: {'科比': 24, '杜兰特': 35, '库里': 30, '乔丹': 23, '汤普森': 11}
{2: 4, 4: 16, 6: 36, 8: 64, 10: 100, 12: 144, 14: 196, 16: 256, 18: 324}
dictA交换key和value后： {24: '科比', 7: '杜兰特', 30: '库里', 23: '乔丹', 21: '加内特'}
dictA交换key和value前： {'科比': 24, '杜兰特': 7, '库里': 30, '乔丹': 23, '加内特': 21}
字典的关键字key是简单的字符串，可以使用关键字参数指定键值对: {'sape': 4139, 'guido': 4127, 'jack': 4098}

10、遍历技巧

A）、遍历字典，使用items()方法可以同时输出key和value；

注意：遍历字典 dict 使用.items() 方法配合 for 循环时，当使用 k 和 v 两个变量时，将键与值分别赋予 k 和 v；当使用 k 一个变量时，将键值对作为一个整体赋给 k；

B）、遍历单个列表、元组和集合时，使用列举函数enumerate() 可以同时输出索引和对应的元素；

C）、遍历多个列表、元组和集合时，可以使用 zip() 组合；

D）、反向遍历一个序列(序列可以是元组、 列表、字符串、range)，首先指定这个序列，然后调用 reversed() 函数；

E）、按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原序列的值；

"""
10、遍历技巧
A）、遍历字典，使用items()方法可以同时输出key和value；
B）、遍历单个列表、元组和集合时，使用列举函数enumerate() 可以同时输出索引和对应的元素；
C）、遍历多个列表、元组和集合时，可以使用 zip() 组合；
D）、反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数；
E）、按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原序列的值；
"""
dictA = {"科比":24 , "乔丹":23 }
listA = ["科比" ,"乔丹" ]
tupA = ("科比" ,"乔丹" )
SetA = {"科比" ,"乔丹" }
# A）、遍历字典，使用items()方法可以同时输出key和value；
for key , value in dictA.items():print("遍历字典，使用items()方法可以同时输出key和value：" , key , '---' , value)# 遍历字典 dict 使用.items() 方法配合 for 循环时，当使用 k 和 v 两个变量时，将键与值分别赋予 k 和 v；当使用 k 一个变量时，将键值对作为一个整体赋给 k；
dictA = {"科比":24 , "乔丹":23 }
# 使用两个参数
for name , number in dictA.items():print(name , number)# 使用一个参数
for name in dictA.items():print(name)# B）、遍历单个列表、元组和集合时，使用列举函数enumerate() 可以同时输出索引和对应的元素；
for key , value in enumerate(listA):print("enumerate(listA)获取列表对应的索引和值" , key , '---' , value )
for key , value in enumerate(tupA):print("enumerate(tupA)获取元组对应的索引和值" , key , '---' , value )
for key , value in enumerate(SetA):print("enumerate(SetA)获取集合对应的索引和值" , key , '---' , value )
for key , value in enumerate(dictA):print("enumerate(dictA)获取字典对应的索引和值" , key , '---' , value )# C）、遍历多个列表、元组和集合时，可以使用 zip() 组合；
# 场景一：将两个列表的对应元素重新组成一个个元组
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
# zip(questions , answers)返回[('name' , 'lancelot') , ('quest' , 'the holy grail') , ('favorite color' , 'blue')]
for question , answer in zip(questions , answers):print("what is your {0} ？ It is {1} ".format(question , answer) )print("what is your %s ？ It is %s " % (question , answer) )# 场景二：实现矩阵转置
listB = [[1 , 2 ,3 ,4 ] , [5 ,6 ,7 ,8] , [9 ,10 ,11 ,12]]
print("zip()实现矩阵转置:" , list(map(list , zip(* listB))))# D）、反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数；
# 反向遍历序列（序列可以是元组、 列表、字符串、range）
listB = [1 , 4 , 5 , 3 , 7 , 9 , 10 , -12 , 21 , -29 ]
listA = []
for n in reversed(listB):listA.append(n)
print("反向遍历序列listB:" , listA)listC = []
for i in reversed(range(-10, 10, 2)):listC.append(i)
print("反向遍历序列range(-10, 10, 2):" , listC)# E）、按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原序列的值；
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
listD = []
for i in sorted(basket):listD.append(i)
print("按顺序遍历一个序列" , listD)

遍历字典，使用items()方法可以同时输出key和value： 科比 --- 24
遍历字典，使用items()方法可以同时输出key和value： 乔丹 --- 23
科比 24
乔丹 23
('科比', 24)
('乔丹', 23)
enumerate(listA)获取列表对应的索引和值 0 --- 科比
enumerate(listA)获取列表对应的索引和值 1 --- 乔丹
enumerate(tupA)获取元组对应的索引和值 0 --- 科比
enumerate(tupA)获取元组对应的索引和值 1 --- 乔丹
enumerate(SetA)获取集合对应的索引和值 0 --- 科比
enumerate(SetA)获取集合对应的索引和值 1 --- 乔丹
enumerate(dictA)获取字典对应的索引和值 0 --- 科比
enumerate(dictA)获取字典对应的索引和值 1 --- 乔丹
what is your name ？ It is lancelot
what is your name ？ It is lancelot
what is your quest ？ It is the holy grail
what is your quest ？ It is the holy grail
what is your favorite color ？ It is blue
what is your favorite color ？ It is blue
zip()实现矩阵转置: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
反向遍历序列listB: [-29, 21, -12, 10, 9, 7, 3, 5, 4, 1]
反向遍历序列range(-10, 10, 2): [8, 6, 4, 2, 0, -2, -4, -6, -8, -10]
按顺序遍历一个序列 ['apple', 'apple', 'banana', 'orange', 'orange', 'pear']

Python3之数据结构相关推荐

1. Python3常用数据结构

   Python3中有三种组合数据类型,分别为: 序列类型:字符串(str).元组(tuple).列表(list) 集合类型:集合(set) 映射类型:字典(map) 序列类型 Python序列类似于其他 ...

2. python 单链表是否有回路_（Python3）数据结构--单链表之判断链表是否有环

   前言 有Python基础 有数据结构单链表基础,没接触过的可以看下面链接 https://blog.csdn.net/sf9898/article/details/104946291 原理和实现 有一 ...

3. python_ 学习笔记（hello world）

   python中的循环语句 循环语句均可以尾随一个else语句块,该块再条件为false后执行一次 如果使用break跳出则不执行. for it in [1,2,3,4]:print(it,end=& ...

4. Mac下python2.7 升级到3.7

   博客 学院 下载 图文课 论坛 APP 问答 商城 VIP会员 活动 招聘 ITeye GitChat 写博客 赚零钱 消息 原 Mac下升级python2.7到python3.6 2017年04月0 ...

5. python3菜鸟教程中文-Python3 数据结构

   Python3 数据结构 本章节我们主要结合前面所学的知识点来介绍Python数据结构. 列表 Python中列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而字符串 ...

6. Python3数据结构总结（列表list，元组tuple，集合set，字典dict，堆栈stack，队列queue和遍历技巧）

   文章目录 6种标准数据类型(列表,元组,集合,字典)的对比和初始化 列表增删改查等常用操作的方法总结 列表当做堆栈stack使用 列表当做队列queue使用 序列(字符串+列表+字典)的遍历技巧 字符 ...

7. Python3实现常用的数据结构

   Python3实现常用的数据结构 之前学习Python的时候当做练习的代码.实现了栈.队列.树.图等的常用数据结构,并给出了一些常用算法,比如BFS.DFS.最短路等. Github链接:https: ...

8. 3.Python3标准库--数据结构

   (一)enum:枚举类型 import enum''' enum模块定义了一个提供迭代和比较功能的枚举类型.可以用这个为值创建明确定义的符号,而不是使用字面量整数或字符串 ''' 1.创建枚举 imp ...

9. Python3 入门教程｜｜Python3 数据结构｜｜Python3 模块

   Python3 数据结构 本章节我们主要结合前面所学的知识点来介绍 Python 数据结构. 列表 Python 中列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而 ...

10. Python3入门教程｜｜Python3 数据结构｜｜Python3 模块

    Python3 数据结构 本章节我们主要结合前面所学的知识点来介绍 Python 数据结构. 列表 Python 中列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而 ...

最新文章

1. LLVM一些编程语法语义特性
2. 设置VSCode隐藏菜单栏快捷键Alt+T(头部)、隐藏状态栏快捷键Alt+B(底部)，为单屏开发者腾出更多编码空间
3. 如何安排vixta之三-Installing来源劈脸安排
4. 32位微处理器的虚拟技术，是“坑爹”么！
5. leetcode518. 零钱兑换 II
6. linux 磁盘科隆,Linux中ln命令用法详解（硬链接）
7. python空列表添加_Python列表的简单操作
8. qt代码中判断windows/linux/arm等系统
9. java定时器与ThreadLocal编程陷阱
10. python调用qt动态库_QT开发——动态库（.so文件）的生成与调用
11. 2015 Objective-C 新特性
12. win10家庭版系统安装SQL2005
13. POI导出echarts统计报表到Excel
14. 数据采集与埋点简介之 代码埋点、可视化埋点与无痕埋点
15. 10步搞定App内测发布（蒲公英内测平台）
16. 安卓仿Toasty消息弹框
17. Win7电脑上如何增加磁盘分区？
18. HM编码学习——数据处理与批处理
19. OpenStack Juno 版本发布——支持Spark和NFV[转]
20. VMware16安装过程分享

热门文章

1. Hbase Locality
2. react-native获取农历日期和二十四节气
3. LowB三人组--选择排序原理和实现
4. vivos9桌面字体样式怎样修改
5. 全国计算机英语四六级准考证打印,周六开考！2020年11月四六级口语考试准考证打印通知！...
6. 自然语言处理入门理论知识
7. 安卓手机管理器_安卓如何看撤回的微信
8. APP内搜索：下一代搜索属于百度还是微信?
9. 某享瘦app登录逆向
10. 008 使用MyBatis,easyUI实现CRUD操作样例-CUD(CRUD完毕)