第四章
本章概览
在Python中序列是最基本的数据结构。它是一块用于存放多个值的连续内存空间。Python中内置了5个常用的序列结构，分别是：列表、元组、集合、字典、字符串，本章详细讲解列表、元组、集合和字典。
4.1 序列
1: 序列是是一块用于存放多个值的连续内存空间，并且按一定顺序排列，每一个值称为元素，都会分配一个数字，称为索引或位置，通过该索引可以取出相应的值。
2: 在Python中，序列结构主要有列表、元组、集合、字典、字符串、对于这些序列结构有一下通用操作，其中，集合和字典不支持索引、切片，相加和相乘操作。
4.1.1 索引
序列中的每一个元素都有一个编号，也称为索引，这个索引是从0开始递增的，即下标为0为第一个元素，下标为1表示第2个元素，以此类推。Python中的索引可以是负数。这个从右边向左边计数，也就是从最后一个元素开始计数，最后一个索引值为-1，倒数第二个为-2
-5 -4 -3 -2 -1
元素1 元素2 元素3 元素4 元素5
0 1 2 3 4通过索引可以访问序列中的任何元素。
verse = ["春眠不觉晓","Python不得了","夜来爬数据","好评知多少"]
print(verse[2]) # 输出第三个元素
print(verse[-1]) # 输出最后一个元素4.1.2 切片
切片操作是访问序列中元素的另外一种方法，它可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。实现切片操作的语法格式如下：
"""
切片格式
"""
string = "序列的应用之切片"
start = 0
end = len(string)
step = 1
print(string[start:end:step])1：string : 序列的名字
2：start : 表示切片的开始位置，如果不指定默认为0
3：end : 表示切片的截止位置（不包含该位置），如果不指定，默认序列的长度
4：step : 表示步长，如果忽略，则默认1，当默认忽略时，最后一个冒号也可以省略
# coding = utf-8
"""
通过切片先获取NBA历史上十大巨星列表中的第2个到第5个元素，
再获取第一个、第三个和第五个元素，可以使用下面的代码：
"""
nba = ["迈克尔.乔丹","比尔.拉塞尔","卡里姆.阿布都尔","维尔特.张伯伦",
"埃尔文.约翰逊","科比.布莱恩特","蒂姆.邓肯","勒布朗.詹姆斯","拉里.博得"
,"沙奎尔.奥尼尔"]
print(nba)
print(nba)
# 获取第二个到第五个元素
print(nba[1:5:1])
# 获取第一个、第三个、第五个
print(nba[:5:2])
# 倒叙获取全部
print(nba[::-1])
# 获取倒数第三个
print(nba[-3:-4:-1])注意：
如果想要复制整个序列，可以将start 和 end 参数都省略，但是中间的冒号需要保留。
4.1.3 序列相加
在Python中，支持两种相同的序列相加操作，即将两个序列进行连接，不会去除重复的元素。
# coding = utf-8
"""
序列相加
"""
nba = ["迈克尔.乔丹","比尔.拉塞尔","卡里姆.阿布都尔","维尔特.张伯伦",
"埃尔文.约翰逊"]
nba1 = ["科比.布莱恩特","蒂姆.邓肯","勒布朗.詹姆斯","拉里.博得" ,"沙奎尔.奥尼尔"]
print(nba + nba1)两个不同的序列相加合并成一个序列
# coding = utf-8
"""
不同序列相加
"""
nba = ["迈克尔.乔丹","比尔.拉塞尔","卡里姆.阿布都尔","维尔特.张伯伦",
"埃尔文.约翰逊","科比.布莱恩特","蒂姆.邓肯","勒布朗.詹姆斯","拉里.博得" ,"沙奎尔.奥尼尔"]
nba1 = [1,2,3,4,5,6]
print(nba + nba1)注意：
不能将列表和元组，也不能将列表和字符串相加，否则报错
4.1.4 乘法
在Python中，使用数字n 乘以任何序列会产生一个新的序列，新序列的内容为原来序列被重复N次的结果
# coding = utf-8
"""
序列的乘法:
"""
nba = ["迈克尔.乔丹","比尔.拉塞尔","卡里姆.阿布都尔","维尔特.张伯伦",
"埃尔文.约翰逊","科比.布莱恩特","蒂姆.邓肯","勒布朗.詹姆斯","拉里.博得" ,"沙奎尔.奥尼尔"]
print(nba * 3) # 序列的乘法在运行序列的乘法运算时，还可以实现初始化指定长度列表的功能：
emptylist = [None]*5
print(emptylist)
[None]4.1.5 检查某个元素是否是序列成员
python中通过成员运算符（身份运算符）（in、not in ）检查某个元素是否为序列的成员，即检查某个某个元素是否包含在序列中。
value in sequence# coding = utf-8
"""
检查是否是序列中的成员(in)
"""
nba = ["迈克尔.乔丹","比尔.拉塞尔","卡里姆.阿布都尔","维尔特.张伯伦",
"埃尔文.约翰逊","科比.布莱恩特","蒂姆.邓肯","勒布朗.詹姆斯","拉里.博得" ,"沙奎尔.奥尼尔"]
print("迈克尔.乔丹" in nba)# coding = utf-8
"""
检查是否是序列中的成员(not in )
"""
nba = ["迈克尔.乔丹","比尔.拉塞尔","卡里姆.阿布都尔","维尔特.张伯伦",
"埃尔文.约翰逊","科比.布莱恩特","蒂姆.邓肯","勒布朗.詹姆斯","拉里.博得" ,"沙奎尔.奥尼尔"]
print("保罗.加索尔" not in nba)4.1.6 计算序列的长度、最大值、最小值
python 中提供了内置函数计算序列的长度，最大值，最小值，分别是：使用len()函数计算序列的长度，即返回序列中包含多少个元素，使用max() 函数返回序列中的最大元素，使用min()返回序列中最小的元素。
# coding = utf-8
"""
计算序列中的长度，最大值，最小值
"""
num = [7,14,21,28,35,42,49,56,63]
# 序列的长度
print("序列num的长度%d"%(len(num)))
# 序列中最大值
print("序列最大值%d"%(max(num)))
# 序列中最小的值
print("序列最小值%d"%(min(num)))函数 | 作用 |
list() | 将序列转化为一个列表 |
str() | 将序列转化为字符串 |
sum() | 计算元素和 |
sorted() | 对元素进行排序 |
reversed() | 反向序列中的元素 |
enumerate() | 将序列组合为一个索引序列，多用在for循环中 |
4.2 列表
列表是Python中内置的可变序列，在形式上，列表的所有元素都放在一对中括号"[]“中，两个相邻的元素间使用逗号”，" 分割，在内容上可以将 整数、实数、字符串、列表、元组等任何类型的内容放在列表中，并且同一个列表中，元素的类型可以不同，因为它们之间没有任何关系。
4.2.1 列表的创建和删除
1：使用赋值运算符直接创建列表
listname = [element1 , element2, element3,element4]# coding = utf-8
"""
使用赋值运算符直接创建列表
"""
num = [7, 14, 21, 28, 35, 42, 49, 56, 63]
verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
untitle = ['python', 28, '人生苦短，我用Python', ["爬虫", "自动化运维", "云计算", "Web开发"]]
python = ['优雅', "明确", """简单""", ]
# 数字组成的列表
print(num)
# 字符串组成的列表
print(verse)
# 字符串、数字、列表 组成的列表
print(untitle)
# 字符串组成的列表
print(python)2：创建空列表
说明：在使用Python中，也可以创建空的列表，例如创建一个空列表
emptylist = []3：创建数值列表
说明：在python中，可以使用 list() 函数直接将 range() 函数循环出来的结果转化为列表：
格式如下:list(data) data可以表示转化为列表的数据，其类型可以是 range对象、字符串、元组、或者其他可迭代类型的数据: 例如：list(range(10,20,2))4：删除列表
对于已经创建的列表，不再使用时，可以通过 del 语句将其删除，语法格式如下：
del listname# coding = utf-8
"""
删除列表
"""
num = [7, 14, 21, 28, 35, 42, 49, 56, 63]
verse = ["自古逢秋悲寂寥", "我言秋日胜春朝", "晴空一鹤排云上", "便引诗情到碧霄"]
untitle = ['python', 28, '人生苦短，我用Python', ["爬虫", "自动化运维", "云计算", "Web开发"]]
python = ['优雅', "明确", """简单""", ]
# 数字组成的列表
print(num)
del num
# 字符串组成的列表
print(verse)
del verse
# 字符串、数字、列表 组成的列表
print(untitle)
del untitle
# 字符串组成的列表
print(python)
del python4.2.2 访问列表元素
Python中如果输出列表中的元素，可以直接使用 print() 函数即可
untitle = ['python', 28, '人生苦短，我用Python', ["爬虫", "自动化运维", "云计算", "Web开发"]]
print(untitle)也可以通过索引或者切片获取列表中的元素
untitle = ['python', 28, '人生苦短，我用Python', ["爬虫", "自动化运维", "云计算", "Web开发"]]
print(untitle[2]) # 索引获取元素
print(untitle[2:3:1]) # 切片获取元素# coding = utf-8
import datetime
"""
输出每日一贴：获取当前星期，最后将当前星期作为列表的索引，输出
元素
"""
# 定义一个列表
mot = ["今天是星期一：\n坚持下去不是因为我很坚强，而是因为我别无选择。",
"今天是星期二：\n含泪播种的人一定能笑着收获。",
"今天是星期三：\n做对的事情比把事情做对重要",
"今天是星期四：\n命运给予我们的不是失望之酒，而是机会之杯",
"今天是星期五：\n不要等到明天，明天太遥远，今天就行动",
"今天是星期六：\n求知若渴，虚心若愚",
"今天是星期日：\n成功将属于那些从不说\"不可能\"的人"]
day = datetime.datetime.now().weekday() # 获取当前星期
print(mot[day]) # 每日输出一贴4.2.3 遍历列表
遍历列表中所有元素是常用的一种操作，在遍历的过程中可以完成查询、处理等功能。
1：直接使用 for 循环实现
for item in listname:
#输出列表元素其中 item 用于保存获取到的元素值，要输出元素内容时，直接输出该变量即可：listname 为列表名称。
循环输出演示：
# coding = utf-8
import datetime
"""
输出每日一贴：获取当前星期，最后将当前星期作为列表的索引，输出
元素
"""
# 定义一个列表
mot = ["今天是星期一：\n坚持下去不是因为我很坚强，而是因为我别无选择。",
"今天是星期二：\n含泪播种的人一定能笑着收获。",
"今天是星期三：\n做对的事情比把事情做对重要",
"今天是星期四：\n命运给予我们的不是失望之酒，而是机会之杯",
"今天是星期五：\n不要等到明天，明天太遥远，今天就行动",
"今天是星期六：\n求知若渴，虚心若愚",
"今天是星期日：\n成功将属于那些从不说\"不可能\"的人"]
day = datetime.datetime.now().weekday() # 获取当前星期
for item in mot:
print(item)2：使用 for 循环和 enumerate() 函数实现
使用 for 循环和 enumerate() 函数可以实现同时输出索引值和元素内容，语法格式如下：
for index,item enumerate(listname):
# 输出index 和 item说明：
index:用于保存元素的索引
item: 用于保存获取的元素值，要输出元素内容时，直接输出该变量即可
listname:列表的名称
# coding = utf-8
import datetime
"""
输出每日一贴：获取当前星期，最后将当前星期作为列表的索引，输出
元素
"""
# 定义一个列表
mot = ["今天是星期一：\n坚持下去不是因为我很坚强，而是因为我别无选择。",
"今天是星期二：\n含泪播种的人一定能笑着收获。",
"今天是星期三：\n做对的事情比把事情做对重要",
"今天是星期四：\n命运给予我们的不是失望之酒，而是机会之杯",
"今天是星期五：\n不要等到明天，明天太遥远，今天就行动",
"今天是星期六：\n求知若渴，虚心若愚",
"今天是星期日：\n成功将属于那些从不说\"不可能\"的人"]
day = datetime.datetime.now().weekday() # 获取当前星期
for index, item in enumerate(mot):
print("索引是%d,---- 对应的元素值是%s" % (index, item))实例：分两列显示西部联赛前八名
# coding = utf-8
"""
分两列显示西北联赛前八名
"""
print("2017~2018 赛季NBA西部联盟前八名\n")
team = ["火箭", "勇士", "雷霆", "开拓者", "爵士", "鹧鸪", "马刺", "森林狼"]
for index, item in enumerate(team):
if index % 2 == 0:
print(item + "\t\t", end="")
else:
print(item + "\n")4.2.4 添加、修改和删除列表元素
1：添加元素
Python中可以通过 + 向列表添加元素但是该方法比较慢，建议使用 append() ,使用列表对象的append() 方法实现，列表对象的 append() 方法向该列表的末尾追加元素，语法格式如下,也可以用 insert() 方法插入元素
（列表相加、append(obj), insert(index,obj)）
listname.append(obj)
listname.insert(obj)# coding = utf-8
"""
列表添加元素
"""
phone = ["摩托罗拉", "诺基亚", "三星", "OPPO"]
print(len(phone))
new_phone = ["华为"] # 定义一个新列表
phone = phone + new_phone # 两个列表相加
print(phone)
phone.append("iphone") # 通过append()方法添加元素
print(phone)
phone.insert(len(phone), "小米") # 通过索引插入新元素
print(phone)“extend()” 方法向列表中添加一个元素，如果想要将一个列表中的全部元素添加到另外一个列表中，可以使用列表对象的extend() 方法实现
listname.extend(seq)# coding = utf-8
"""
列表添加元素 entend()方法
"""
old_list = ["摩托罗拉", "诺基亚", "三星", "OPPO"] # 初始列表
print(len(old_list))
new_list = ["华为", "小米", "金立"] # 新增列表
old_list.extend(new_list)
print(old_list)2：修改元素
修改列表中的元素只需要通过索引获取该位置的元素，然后重新赋值即可。
# coding = utf-8
"""
修改类标准红的元素
"""
old_list = ["摩托罗拉", "诺基亚", "三星", "OPPO"] # 初始列表
print(len(old_list))
new_list = ["华为", "小米", "金立"] # 新增列表
old_list.extend(new_list) # 将新增列表中的元素全部放到老列表中
old_list[2] = "iphone" # 修改列表中的元素
print(old_list)3：删除元素
删除元素主要通过两种方式，第一种是根据索引删除、另外一种是根据元素删除。
根据索引删除元素
# coding = utf-8
"""
根据索引删除元素
"""
old_list = ["摩托罗拉", "诺基亚", "三星", "OPPO"] # 初始列表
del old_list[2]
print(old_list)根据元素删除
# coding = utf-8
"""
根据元素删除
"""
old_list = ["摩托罗拉", "诺基亚", "三星", "OPPO"] # 初始列表
old_list.remove("OPPO")
print(old_list)注意：
使用remove() 函数删除元素之前首先要判断，该元素是否存在，不存在则会报错（使用 listname.count(“element”) 判断是否存在该元素）
# coding = utf-8
"""
根据元素删除
"""
old_list = ["摩托罗拉", "诺基亚", "三星", "OPPO"] # 初始列表
if old_list.count("iphone"): # 通过count函数判断是否有该元素
old_list.remove("iphone")
else:
old_list.remove("OPPO")
print(old_list)4.2.5 对列表统计和计算
Python 中的列表提供了内置的一些函数来实现统计、计算的功能。
1：获取指定元素出现的次数
使用列表对象的 count() 方法可以获取指定元素在列表中的出现的次数，基本语法如下：
listname.count(obj)# coding = utf-8
"""
功能：统计列表中元素出现的次数
"""
# 定义的列表
song = ["云在飞","我在诛仙逍遥间","送你一匹马","半壶纱","云在飞",
"遇见你","等你等了那么久"]
# 统计 "云在飞" 出现的次数
num = song.count("云在飞")
print(num)2：获取指定元素首次出现的下标
使用列表对象的 index() 方法可以获取指定元素在列表中首次出现的索引位置
listname.index("element")注意：element 必须是列表中的元素，只能进行精确匹配，如果指定的对象不存在，则抛出异常
# coding = utf-8
"""
功能：统计列表中元素出现的次数
"""
# 定义的列表
song = ["云在飞","我在诛仙逍遥间","送你一匹马","半壶纱","云在飞",
"遇见你","等你等了那么久"]
# 计算 "半壶纱" 出现的索引位置
if song.count("半壶纱")== 0: # 注意元素是否存在于列表中
print("没有该元素")
else:
num = song.index("半壶纱")
print(num)3：统计数值列表的元素和
在Python中提供了 sum() 函数用于计算 数值列表的各个元素合，语法格式如下：
sum(listname,start)listname: 表示要统计的列表
start: 表示统计结果 加上start 数值
# coding = utf-8
"""
功能：统计列表中元素出现的次数
"""
# 定义的列表
grade = [60,100,90,89,79,50,96] # 成绩列表
total = sum(grade) # 通过sum计算总分
print(total)
total2 = sum(grade,-500) # 通过第二个参数减数
print(total2)4.2.6 对列表进行排序
Python中提供了两种常用的对列表进行排序的方法，使用列表对象的sort() 方法 和 使用内置的 sorted() 函数
1： 使用列表对象的sort() 方法
列表对象提供了 sort() 方法用于对原列表中的元素进行排序，排序后的列表元素位置发生变化
listname.sort(key = None , reverse = False)listname:表示要进行排序的列表
key:用于指定排序规则（例如，设置 key = str.lower 表示在排序时不区分字母大小写）
reverse:可选参数，如果将其他值指定为 True 则表示降序排列，如果为False 则表示升序排列
# coding = utf-8
"""
列表的排序
"""
grade = [98, 97, 99, 100, 94, 95, 100]
print("原始成绩单%s:" % grade)
grade.sort()
print("升序成绩单%s:" % grade)
grade.sort(reverse=True)
print("降序成绩单%s:" % grade)注释：使用sort()方法对字符串进行排序，采用的规则是先对大写字母排序，然后再对小写字母排序，如果想要对字符串列表排序（不区分大小写时），需要指定其key参数
# coding = utf-8
"""
列表的排序（字符串排序）
"""
char = ["cat", "Tom", "Angela", "pet"]
print("原始列表值为：%s" % char)
char.sort() # 默认升序排列区分大小写字母
print("升序区分大小写字母：%s" % char)
char.sort(key=str.lower, reverse=True) # 默认升序排列区分大小写字母
print("降序不区分大小写字母：%s" % char) # 默认降序排列不区分大小写字母注意：采用sort() 方法对列表进行排序时，对中文支持不好，排序结果与我们常用的音序排序法或者笔画排序法不一致，如果需要实现对中文的排序吗，还需要重新编写对应的方法进行排序。
2： 使用内置的sorted() 函数实现
在Python中，提供的一个内置的 sorted() 函数，用于对列表进行排序，使用该函数后原列表的元素顺序不变
sorted(iterable,key=None,reverse = False)iterable : 表示要进行排序的列表
key : 用于指定排序规则
reverse : False 升序，True表示降序
# coding = utf-8
"""
列表的排序 sorted() 内置函数
"""
grade = [98, 97, 99, 100, 94, 95, 100]
print("原始成绩单%s:" % grade)
print("升序成绩单%s:" % sorted(grade, reverse=False))
print("降序成绩单%s:" % sorted(grade, reverse=True))4.2.7 列表的推导式
使用列表推导式可以快速生成一个列表，或者根据某个列表生成满足指定需要的列表，列表推导式通常有以下几种常用的语法格式
1：生成指定范围的数值列表，语法格式如下：
list = [experssion for item in range]# coding = utf-8
import random
"""
列表推导式：随机生成一个10个随机数的列表，要去在10 - 100 之间
"""
# 随机生成一个10个随机数的列表，要去在10 - 100 之间
random_number = [random.randint(10, 100) for i in range(10)]
print("生成的随机数列随机数为：%s" % random_number)2：根据列表生成指定需要的列表，语法格式如下：
newlist = [expression for var in list]# coding = utf-8
"""
列表推导式：定义一个记录商品价格的列表，然后应用与列表推导式生成一个将全部商品价格打五折的列表
"""
price = [1200, 5330, 2988, 6200, 1998, 8888]
sale = [item * 0.5 for item in price]
print("商品五折后的价格%s" % sale)3：从列表中选择符合条件的元素组成新列表，语法格式如下：
newlist = [expression for var in list of condition]# coding = utf-8
"""
列表推导式：定义一个记录商品价格的列表，然后应用列表推导式筛选出来一个商品介个小于5000 元的打折列表
"""
price = [1200, 5330, 2988, 6200, 1998, 8888]
sale = [item * 0.5 for item in price if item < 5000]
print("商品五折后的价格%s" % sale)4.2.8 二维列表的使用
二维列表中的信息以行和列的形式表示，第一个下标代表所有元素所在行，第二个下标表示元素所在行。
1：直接定义二维列表
在Python中，二维列表是包含列表的列表，即一个列表的每一个元素又都是一个列表。
# coding = utf-8
"""
二维列表：定义一个二维列表
"""
verse = [['千', '山', '鸟', '飞', '绝'],
['万', '径', '人', '踪', '灭'],
['孤', '舟', '蓑', '笠', '翁'],
['独', '钓', '寒', '江', '雪']
]2:使用嵌套循环 for 创建二维列表
# coding = utf-8
"""
二维列表：定义一个二维列表
"""
arr = [] # 创建一个空列表
for item in range(4):
arr.append([])
for j in range(5,-1,-1):
arr[item].append(j)
print(arr)3:使用列表推导式创建
arr = [ [j for j in range(4)] for i in range(4)]注意：获取二维列表中的元素：
arr[1][2]实例：打印古诗文
方法1
# coding = utf-8
"""
二维列表：横版竖版打印古诗文
"""
verse = [['千', '山', '鸟', '飞', '绝'],
['万', '径', '人', '踪', '灭'],
['孤', '舟', '蓑', '笠', '翁'],
['独', '钓', '寒', '江', '雪']
]
# 横版打印
for index, item in enumerate(verse):
print(item)
# 竖版打印
for j in range(0, 5, 1): # 第几列
for i in range(3, -1, -1): # 第几行
print(verse[i][j], end='')
print()方法2
# coding = utf-8
"""
二维列表：横版竖版打印古诗文
"""
str1 = "千山鸟飞绝"
str2 = "万径人踪灭"
str3 = "孤舟蓑笠翁"
str4 = "独钓寒江雪"
verse = [list(str1), list(str2), list(str3), list(str4)] # 定义一个列表
print('--打印横版--')
for i in range(0, len(verse), 1):
for j in range(len(verse[0])):
if j == 4:
print(verse[i][j])
else:
print(verse[i][j], end='')
print('--打印竖版--')
verse.reverse() # 对列表进行逆序排列
print(verse)
for i in range(0, 5):
for j in range(4):
if j == 3:
print(verse[j][i])
else:
print(verse[j][i], end='')列表的练习&补充
定义
由一系列变量组成的可变序列容器。
基础操作
- 创建列表：
列表名 = []
列表名 = list(可迭代对象) - 添加元素：
列表名.append(元素)
列表.insert(索引，元素) - 定位元素：
索引、切片 - 遍历列表：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素 - 删除元素：
列表名.remove(元素)
del 列表名[索引或切片]
# coding = utf-8
"""
列表的定义
"""
# 1：创建列表 创建空列表
list01 = [] # 通过默认值赋值创建列表
list01 = list() # 通过放序列转化为列表
# 默认值
list01 = ["悟空", 100, True]
list02 = list("我是齐天大圣")
print(list02)
# 2: 获取元素 （索引、切片）
# 索引
print(list02[2])
# 切片
print(list02[-4:]) # 打印后四位
# 3： 添加 （append,insert） 或者 列表相加
list02.append("八戒") # 通过append() 方法添加
print(list02) # 添加
list02.insert(1, True) # 索引位置添加
print(list02)
print(list02 + list01) # 列表相加
# 删除 根据元素删除，根据位置删除
list02.remove(True) # 通过元素删除
print(list02)
del list02[0:3:1] # 删除第一个(切片删除元素，修改元素)
print(list02)
# 定位元素（可以 增删改查元素）
# 切片
print(list02)
del list02[1:3]
print(list02)
# 修改值
list02[0:1:1] = ["MK"]
print(list02)
list02 = list("我是齐天大圣")
for 与列表结合使用 遍历列表
for item in list02:
print(item)
# 倒叙获取所有元素
# for item in list02[::-1]:
# print(item)
# 不建议，会生成一个新的列表 通过切片拿元素就会产生新列表
# 3 2 1 0
for item in range(len(list02) - 1, -1, -1):
print(list02[item])
# -1 - 2 -3 -4
for item in range(-1, -len(list02)-1, -1):
print(list02[item])练习：
# coding =utf-8
"""
列表练习
"""
# 在控制台中录入，在西游记中喜欢的人物，输入空字符串打印所有人物
list_name = []
while True:
element = input("请输入您喜欢的西游记人物（输入空字符结束）：")
if element == '':
break
else:
list_name.append(element)
for item in list_name:
print(item)
# 在控制台中录入所有学生的成绩，输入空字符串 打印所有成绩 ，打印成绩最高分，最低分，平均分
list_grade = []
times = 0
while True:
element = input("请输入学生成绩（输入空字符结束）：")
if element == "":
break
else:
list_grade.insert(times, float(element))
times += 1
print(list_grade)
print("最高分是%.2f" % max(list_grade))
print("最低分是%.2f" % min(list_grade))
print("平均分是%.2f" % (sum(list_grade) / len(list_grade)))
# 在控制台中录入，所有学生的姓名，如果姓名重复，则不添加到列表中并提示"姓名已存在"，如果录入空字符串则倒叙打印列表元素
list_stu_name = []
while True:
stu_name = input("请输入学生的姓名：")
if stu_name == "":
print("录入结束，end")
break
else:
if stu_name not in list_stu_name:
list_stu_name.append(stu_name)
else:
print("该学生已经录入")
for item in range(len(list_stu_name) - 1, -1, -1):
print(list_stu_name[item])
# 列表推导式
print([list_stu_name[item] for item in range(len(list_stu_name) - 1, -1, -1)])深拷贝和浅拷贝
浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个依懒的变量。
浅拷贝
# 浅拷贝 (切片创建新的列表后，复制只复制第一层)
list01 = [800, [1000, 500]]
list02 = list01[:] # 复制出来一个新列表（但只复制层）
list01[1][0] = 900
list01[0] = 400
print(list01)
print(list02)注释：python中 浅拷贝 list02 = list01[:] 等价于 list02 = list01.copy()
深拷贝
# coding = utf-8
import copy
"""
列表内存图，深拷贝
"""
# 浅拷贝 (切片创建新的列表后，复制只复制第一层)
list01 = [800, [1000, 500]]
list02 = list01[:] # 复制出来一个新列表（但只复制层）
list02 = list01.copy()
print(list02)
# 深拷贝
list02 = copy.deepcopy(list01)
list01[1][0] = 900
list01[0] = 400
print(list01)
print(list02)练习：
# coding = utf-8
"""
练习1：
将列表[54,25,12,42,35,17] 大于30 的数存入到另外一个列表中
练习2：
在控制台输入5个数，打印最大值
"""
# 方法1
list01 = [54, 25, 12, 42, 35, 17]
list02 = [item for item in list01 if item > 30]
print(list02)
# 方法2
list03 = []
for item in list01:
if item > 30:
list03.append(item)
print(list03)
# 打印最大值
# 第一种方式
temp = list01[0]
for item in list01:
if temp < item:
temp == item
print(temp)
# 第二种方式
for i in range(1, len(list01)):
if temp < list01[i]:
temp == list01[i]
print(temp)列表删除元素
# coding = utf-8
"""
在列表中[9,25,12,8] 删除大于10的数字
"""
list01 = [9, 25, 12, 8]
for item in range(len(list01)-1, -1, -1): # 倒叙删除
if list01[item] > 10:
list01.remove(list01[item])
print(list01)
# for item in range(0, len(list01)-1): # 按照从左到右删除有问题
# if list01[item] > 10:
# del list01[item]
# print(list01)列表VS字符串
- 列表和字符串都是序列,元素之间有先后顺序关系。
- 字符串是不可变的序列,列表是可变的序列。
- 字符串中每个元素只能存储字符,而列表可以存储任意类型。
- 列表和字符串都是可迭代对象。
- 函数：
将多个字符串拼接为一个。
result = “连接符”.join(列表)
将一个字符串拆分为多个。
列表 = “a-b-c-d”.split(“分隔符”)
列表推导式
- 定义：
使用简易方法，将可迭代对象转换为列表。 - 语法：
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件] - 说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
列表推导式嵌套 - 语法：
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2] - 传统写法：
result = []
for r in [“a”, “b”, “c”]:
for c in [“A”, “B”, “C”]:
result.append(r + c) - 推导式写法：
result = [r + c for r in list01 for c in list02]
练习：列表到字符串
# coding = utf-8
"""
1. 列表和字符串都是序列,元素之间有先后顺序关系。
2. 字符串是不可变的序列,列表是可变的序列。
3. 字符串中每个元素只能存储字符,而列表可以存储任意类型。
4. 列表和字符串都是可迭代对象。
5. 函数：
将多个字符串拼接为一个。
result = "连接符".join(列表)
将一个字符串拆分为多个。
列表 = “a-b-c-d”.split(“分隔符”)
"""
# 需求：根据逻辑，拼接一个字符串 1 2 3 4 5 6 7 8 9 "连接符".join(列表)
list_str = []
string = None
for item in range(10):
list_str.append(str(item))
string = "".join(list_str)
print(list_str)
print(string)
# 练习：在控制台中循环输入字符串如果输入空则停止。最后打印所有内容
string = None
list_str = []
while True:
temp = input("请输入一个字符串，输入空退出:")
if temp == "":
print("结束")
break
else:
list_str.append(temp)
string = "-".join(list_str)
print(string)练习：字符串到列表
# coding = utf-8
import random
"""
3. 计算列表中最小值(不使用min)．
4. 彩票 双色球：
红球:6个，1 -- 33 之间的整数 不能重复
蓝球:1个，1 -- 16 之间的整数
(1) 随机产生一注彩票[6个红球１个蓝球].
(2) 在控制台中购买一注彩票
提示：
"请输入第1个红球号码："
"请输入第2个红球号码："
"号码不在范围内"
"号码已经重复"
"请输入蓝球号码："
"""
# 计算列表中最小值(不使用min)．
list_min = [89, 100, 54, 78, 25, 10, 6, 88]
min_nbr = list_min[0]
for i in range(1, len(list_min), 1):
if list_min[i] < min_nbr:
min_nbr = list_min[i]
print(min_nbr)
"""
4. 彩票 双色球：
红球:6个，1 -- 33 之间的整数 不能重复
蓝球:1个，1 -- 16 之间的整数
(1) 随机产生一注彩票[6个红球１个蓝球].
(2) 在控制台中购买一注彩票
提示：
"请输入第1个红球号码："
"请输入第2个红球号码："
"号码不在范围内"
"号码已经重复"
"请输入蓝球号码："
"""
list_random = []
while True:
if len(list_random) == 7:
break
else:
if len(list_random) == 6:
r_nbr_blue = random.randint(1, 16)
list_random.append(r_nbr_blue)
else:
r_nbr = random.randint(1, 33)
if r_nbr not in list_random:
list_random.append(r_nbr)
print(list_random)
times = 1
list_input = []
while True:
if len(list_input) == 7:
print("输入结束，退出")
break
else:
if times == 7:
print("请输入蓝球号码：")
nbr = int(input("请输入最后一个号码:"))
if 1 <= nbr <= 15:
list_input.append(nbr)
times += 1
else:
continue
else:
nbr = int(input("请输入 RED 第:%d 个号码:" % times))
if 1 <= nbr <= 32:
if nbr not in list_input:
list_input.append(nbr)
times += 1
else:
print("号码已经重复或超出范围")
continue
print(list_input)冒泡排序法
# coding = utf-8
"""
冒泡排序法：
"""
# 冒泡排序
list_min = [89, 100, 54, 78, 25, 10, 6, 88]
for j in range(1, len(list_min), 1):
for i in range(0, len(list_min) - j, 1):
if list_min[i] > list_min[i + 1]:
list_min[i], list_min[i + 1] = list_min[i + 1], list_min[i]
print(list_min)列表推导式
- 定义：
使用简易方法，将可迭代对象转换为列表。 - 语法：
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件] - 说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
# coding = uft-8
"""
列表推导式
"""
# 将列表1中所有元素增加1以后存入list02 中
list01 = [56, 45, 78, 99, 45, 21, 15]
# list02 = []
# for i in list01:
# list02.append(i + 1)
list02 = [i + 1 for i in list01]
print(list02)
# 将list01 中大于20 的元素放在 list03 中
list03 = []
for i in list01:
if i > 20:
list03.append(i)
list03 = [i for i in list01 if i > 20]
print(list03)
"""
练习：使用range 生成1-10之间的数字，将数字的平方存入list04 中
"""
list04 = [i ** 2 for i in range(1, 10, 1)]
print(list04)
"""
练习：将list01 中所有偶数存入list01 中
"""
list04 = [i for i in list01 if i % 2 == 0]
print(list04)
"""
练习：将list01 中所有奇数存入list01 中
"""
list04 = [i for i in list01 if i % 2 != 0]
print(list04)
"""
练习：将list01 中所有偶数大于20 增加1后 的存入list01 中
"""
list04 = [i + 1 for i in list01 if i % 2 == 0 and i > 20]
print(list04)列表推导式嵌套
- 语法：
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2] - 传统写法：
result = []
for r in [“a”, “b”, “c”]:
for c in [“A”, “B”, “C”]:
result.append(r + c) - 推导式写法：
result = [r + c for r in list01 for c in list02]
4.3 元组
元组（tuple）是Python中一个重要的序列结构，由一些列按特定的顺序排列的元素组成，但是它是不可变序列。因此，元组也可以称为不可变的列表，形式上，元组的所有元素都放在一对 “()” 中，两个相邻的元素之间使用 “，” 分割，内容上可以将 整数、实数、字符串、列表，元组等任何类型的内容放在元组中。— 通常元组保存程序中不可修改的内容。
4.3.1 元组的创建和删除
1：使用赋值运算符直接创建元组
tuplename = (elelment1,elelment2，elelment3，elelment4)注意：创建元组的语法与创建列表的语法类型，只是创建列表时后使用的是“[]” 而创建元组的时候使用的是“()”
# coding = utf-8
"""
创建元组
"""
number = (7, 14, 21, 28, 35, 42, 49, 56, 63)
verse = ('渔舟唱晚', '高山流水', '出水莲花', '汉宫秋月')
untitle = ('python', 28, ("人生苦短", "我用python"), ["爬虫", "自动化运维", "云计算", "Web开发"])
python = ("优雅", "明确", "简单")在Python中，元组使用一对小括号将所有的元素括起来,但是小括号不是必须的只要将一组数值用逗号分隔开，Python视其为元组。
print('渔舟唱晚', '高山流水', '出水莲花', '汉宫秋月')如果要创建的元组只包括一个元素，则需要创建元组时，在元素后面加一个逗号“，”。例如，下面的代码定义的就是包括一个元素的元组：
verse = ("一片冰心在玉壶",) # 主要要在元素最后加一个 , 号# coding = utf-8
"""
创建元组
"""
verse = "一片冰心在玉壶",
print(type(verse))
# 结果：<class 'tuple'>说明：在Python中，可以使用 type() 函数测试变量的类型，如下代码：
# coding = utf-8
"""
type() 函数演示
"""
verse_tuple = ("一片冰心在玉壶",)
verse_str = ("一片冰心在玉壶")
print(type(verse_tuple),type(verse_str))2：创建空元组
在python中，可以创建空元组，格式如下：
emptytuple = () # 空元组空元组应用在为函数传递一个空值或者返回空值时，例如：定义一个函数必须传递一个元组类型的值，而我们还不想为塔传递一组数据，那么就可以创建一个空元组传递给它。
3：创建数值元组
在Python中，可以使用tuple() 直接将 range() 函数循环出来的结果转换为数值元组
tuple(data)其中，data表示可以转换为元组的数据，其类型可以是range 对象、字符串、元组或者其他可以迭代的数据
tuple(range(10,20,2))注意：使用tuple() 不仅能通过range() 对象创建元组，还可以通过其他对象创建元组
4：删除元组
对于已经创建的元组，不在使用时，可以使用del 语句将其删除
del tuplename()其中，tuplename 为元组的名称
# coding = utf-8
"""
删除元组
"""
verse_tuple = ("一片冰心在玉壶",)
print(verse_tuple)
del verse_tuple实例：使用元组保存咖啡名称
# coding = utf-8
"""
实例：使用元组保存咖啡名称
"""
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')
print(coffename)4.2.3 访问元组元素
访问元组中的元素，可以使用print() 直接打印或者使用索引以及切片的方式获取
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')
print(coffename)使用索引获取
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')
print(coffename[0]) # 索引索取元组元素使用切片方式获取元素
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')
print(coffename[0:3])使用for 循环获取元素
# coding = utf-8
"""
实例：使用元组保存咖啡名称
"""
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')
print("您好、还原光临 ~ 本小店，~ \n\n我店有： \n")
for item in coffename:
print(item + "咖啡 ", end="\t")实例：
# coding = utf-8
"""
实例：使用元组打印 NBA 联赛前八
"""
print("2017~2018 赛季NBA 西部联盟前八名\n")
team = ("火箭", "勇士", "开拓者", "雷霆", "爵士", "鹧鸪", "马刺", "森林狼")
for index, item in enumerate(team):
if index % 2 == 0:
print(item + "\t\t", end="")
else:
print(item + "\n")4.3.3 修改元组的元素
通过索引或者切片以及赋值的方式不可以修改元素,(因为元组不可变)可以通过 重新对元组进行赋值
# coding = utf-8
"""
实例：修改元组的元素
"""
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')
print(coffename)
coffename[4] = '拿铁' # 元组不支持修改元素
print(coffename)
# 报错
Traceback (most recent call last):
File "D:/Python_Study/Python_Project/code/07_tuple_statement/create_tuple.py", line 8, in <module>
coffename[4] = '拿铁'
TypeError: 'tuple' object does not support item assignment
Process finished with exit code 1通过重新给元组变量赋值获取新元组
# coding = utf-8
"""
实例：修改元组的元素
"""
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')
print(coffename)
coffename = ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '拿铁', '哥伦比亚')
print(coffename)元组可以重新组合（必须是两个元组相加）
# coding = utf-8
"""
实例：修改元组的元素
"""
coffename = ('蓝山', '卡布奇诺', '曼特宁')
print("原元组：", coffename)
coffother = ('摩卡', '麝香猫', '哥伦比亚')
print("新元组：", (coffename + coffother))4.3.4 元组推导式
使用元组推导式可以快速生成一个元组，它表现方式和列表类似，只是将列表推导式的 “[]” 修改为 “()”
1:生成十个随机数元组
# coding = utf-8
import random
"""
实例：元组推导式
"""
tuple_random = [random.randint(10, 100) for i in range(0, 10)]
print(tuple_random) # 列表使用可以直接打印出来
tuple_random = (random.randint(10, 100) for i in range(0, 10))
print(tuple(tuple_random)) # 元组推导式推导出来的是一个生成器 需要使用 tuple() 转换为元组4.3.5 元组与列表的区别
元组和列表都属于序列，而且他们又都可以按照特定的顺序存放一组元素，类型不受限制，只要是python支持的类型都可以，那么他们之间主要区别是列表类是可变序列，元组不可变
1.列表属于可变序列，它的元素可以随时修改或者删除；元组属于不可变序列，其中的元素不可以修改，除非整体替换
2.列表可以使用 append() 、extend()、insert()、remove()、pop() --元素出栈
3.列表可以使用切片访问和修改元素，元组也支持索引，切片，但是只能通过这些来访问，不能做修改
4.元组比列表的访问速度要快，所以当我们只需要访问数据时使用元组
5.列表不能作为字典的键，而元组可以
元组的补充学习与练习
定义
- 由一系列变量组成的不可变序列容器。
- 不可变是指一但创建，不可以再添加/删除/修改元素。
注释： 列表的扩容原理
1：列表都会预留空间
2：当预留空间不足时，会再创建新的列表（开一个更大的空间）
3：将原有数据拷贝到新列表中
4：替换引用（表头）
基本操作
- 创建空元组：
元组名 = ()
元组名 = tuple() - 创建非空元组：
元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象) - 获取元素：
索引、切片 - 遍历元组：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
元祖名[索引名]就是元素
# coding = utf-8
"""
元组的基本操作
"""
# 1. 创建元组
# 赋空值
tuple01 = ();
tuple01 = tuple();
# 具有默认值
tuple01 = (1, 2, 3);
print(tuple01)
# 特殊的写法
tuple01 = (100,)
print(type(tuple01))
# 2.列表元组转换
# 列表转元组
tuple01 = tuple(["a", "b"])
# 元组转列表
list01 = list(tuple01)
# 3:获取元素（索引、切片）
tuple02 = ("a", "b", "c", "d")
# 索引
ele01 = tuple02[1]
print(ele01, type(ele01)) # 索引拿到的是 str b <class 'str'>
# 切片
ele01 = tuple02[-2::1]
print(ele01, type(ele01)) # 元组切一片还是元组 ('c', 'd') <class 'tuple'>
# 小技能
tuple04 = (100, 200)
a, b = tuple04 # 等价于 a, b = (100,200)
print(a+b)
# 4：变量元组
# 正向
for item in tuple02:
print(item)
# 反向
for i in range(len(tuple02)-1,-1,-1):
print(tuple02[i])作用
- 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
- 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
- 应用：
变量交换的本质就是创建元组：x, y = ( y, x )
格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)
输入月份判断天数（使用元组）
# coding = utf-8
"""
使用容器判断月份天数
"""
# 方式1
month = int(input("请输入月份："))
if month > 12 or month < 1:
print("输入有误")
elif month in (4, 6, 9, 11):
print("30天")
elif month == 2:
print("28天")
else:
print("31天")
# 方式2 # 使用元组
tuple_day_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
if month > 12 or month < 1:
print("输入有误")
else:
print(tuple_day_month[month - 1], "天")输入年月日判断今年过了多少天
# coding = utf-8
"""
练习：在控制台中录入日期（年月） 计算这是一年的第几天
例如：3月5日 31+28+31+5
"""
tuple_day_month_p = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
tuple_day_month_r = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
string = input("请输入年月日,计算这是一年的第几天（格式：20210110）：")
year = int(string[0:4])
month = int(string[4:6:1])
day = int(string[6::1])
# 通过索引遍历元组
print("\n\n您输入的日期是: %d 年 %d 月 %d 日 \t" % (year, month, day))
days = 0
for index in range(0, month-1, 1):
if year % 4 == 0 and year % 100 != 0:
days += tuple_day_month_r[index]
else:
days += tuple_day_month_p[index]
print("\n\n您输入的日期是: %d 年 %d 月 %d 日 \t , 本年度过了[%d] 天" % (year, month, day, days + day))
# 方法2：切片
if year % 4 == 0 and year % 100 != 0:
print("\n\n您输入的日期是: %d 年 %d 月 %d 日 \t , 本年度过了[%d] 天"
% (year, month, day, sum(tuple_day_month_r[:month - 1], day)))
else:
print("\n\n您输入的日期是: %d 年 %d 月 %d 日 \t , 本年度过了[%d] 天"
% (year, month, day, sum(tuple_day_month_p[:month - 1] ,day)))4.4 字典
在Python中，字典与列表类似，也是可变序列，但是字典是无序序列，保存的内容是键值对的形式存放的，字典的特征如下：
- 通过建而不是索引来读取
- 字典是任意对象的无序集合
- 字典是可变的，并且可以任意嵌套
- 字典中的键必须唯一
- 字典中的键必须不可变
4.4.1 字典的创建和删除
定义字典时，每个元素都包含两个部分“键”和“值”
6.5 | 4 | 3 | 11.8 | 5 |
apple | orange | banana | peach | pera |
创建字典的时候，在“键”和“值” 之间使用冒号分割，相邻两个元素使用逗号分割，所有元素放在 “{}” 花括号中，语法格式如下：
dictionary = {'key1':'value1','key2 : value2','key3':'value3'}参数说明
- dictionary 字典名称
- key1/key2/key3 表示字典键值
- value1、value2、value3 表示元素的值
# coding = utf-8
"""
创建字典
"""
dictionary = {'qq': '912901363', 'name': '我是土豆又土又逗', '座右铭': '不混青年'}
print(dictionary)创建空字典
dictionary = {} or dictionary = dict{}Python 中的 dict() 方法除了可以创建一个空字典外，还可以通过已有的数据快速创建字典
快速创建字典
1：通过映射函数快速创建字典
dictionary = dict(zip(list1,list2))
----------------------------------
- dictionary : 字典的名字
- zip() :用于将多个列表或者元组对应位置的元素组合为元组，并返回包含这些内容的zip对象，如果想获取元组，可以将zip对象使用tuple()函数转换为元组：如果想获取列表，则可以使用list()函数将其转换为列表实例：创建一个保存女神星座的字典
# coding = utf-8
"""
创建一个保存女神的字典
"""
name = ['绮梦', '冷依依', '香凝', '戴兰']
sign = ["水瓶座", "射手座", "双鱼座", "双子座"]
dictionary = dict(zip(name, sign)) # 已键值对的形式存放到字典中
print(dictionary)
dictionary = list(zip(name, sign)) # 以元组的形式存放在列表中
print(dictionary)
dictionary = tuple(zip(name, sign)) # 以元组的形式存放在元组中
print(dictionary)
# {'绮梦': '水瓶座', '冷依依': '射手座', '香凝': '双鱼座', '戴兰': '双子座'}
# [('绮梦', '水瓶座'), ('冷依依', '射手座'), ('香凝', '双鱼座'), ('戴兰', '双子座')]
# (('绮梦', '水瓶座'), ('冷依依', '射手座'), ('香凝', '双鱼座'), ('戴兰', '双子座'))2：通过给定的关键字参数创建字典
dictionary = dict(key1 = value1 , key2 = value2 )
------------------------------------
dictionary 字典名称
key1 键值
value1 元素值dictionary = dict( name1 ='水瓶座', name2 ='射手座', name3='双鱼座')
print(dictionary)3: 通过fromkeys() 方法创建键值为None的字典
dictionary = dict.fromkeys(list1)dictionary = dict.fromkeys(["水瓶座", "射手座", "双鱼座", "双子座"])
print(dictionary)
# {'水瓶座': None, '射手座': None, '双鱼座': None, '双子座': None}4:通过已经存在的元组和者列表创建字典
tuple01 = ('绮梦', '冷依依', '香凝', '戴兰')
list01 = ["水瓶座", "射手座", "双鱼座", "双子座"]
dictionary = {tuple01:list01}
print(dictionary)注释：列表不能作为主键
tuple01 = ('绮梦', '冷依依', '香凝', '戴兰')
list01 = ["水瓶座", "射手座", "双鱼座", "双子座"]
dictionary = {list01: tuple01}
print(dictionary)删除字典
同列表和元组一样，不再需要的字典可以通过使用 del命令删除整个 字典
del dictionary注意：如果删除字典所有元素也可以使用
dictionary.clear()注意： 除了上面的方法删除字典，可以使用pop() 方法删除并返回指定的“键”的元素，以及使用字典对象的popitem() 方法删除并返回字典的一个元素
# coding = utf-8
"""
创建一个保存女神的字典
"""
name = ['绮梦', '冷依依', '戴兰', '香凝']
sign = ["水瓶座", "射手座", "双鱼座", "双子座"]
# pop("绮梦") 指定键值返回元素值并删除 popitem() 删除最后一个键值对
dictionary = dict(zip(name, sign))
print(dictionary)
print(dictionary.pop("绮梦"))
print(dictionary)
print(dictionary.popitem())
print(dictionary)
# {'绮梦': '水瓶座', '冷依依': '射手座', '戴兰': '双鱼座', '香凝': '双子座'}
# 水瓶座
# {'冷依依': '射手座', '戴兰': '双鱼座', '香凝': '双子座'}
# ('香凝', '双子座')
# {'冷依依': '射手座', '戴兰': '双鱼座'}4.4.2 通过键值对访问字典
Python中，打印字典可以直接通过print() 方法打印，但实际开发中直接打印的很少，通过使用键得到相应的结果
print(dictionary["戴兰"]) # 通过键值获取元素注意：如果键值不在字典中程序会报错，所以在使用键值获取元素时先判断
print('我是戴兰' if "戴兰" in dictionary else '没有该元素')Python中推荐的方法是使用 get() 方法获取指定键的值，如果没有的话使用默认值
dictionary.get('戴兰','冷依依')# coding = utf-8
"""
创建一个保存女神的字典
"""
name = ['绮梦', '冷依依', '戴兰', '香凝']
sign = ["水瓶座", "射手座", "双鱼座", "双子座"]
# pop("绮梦") 指定键值返回元素值并删除 popitem() 删除最后一个键值对
dictionary = dict(zip(name, sign))
print('我是戴兰' if "戴兰" in dictionary else '没有该元素') # 通过键值获取先判断
print(dictionary.get('戴兰', '冷依依')) # get() 方法先获取键值 如果不存在则默认打印 '默认值'练习 : 打印女神的性格
# coding = utf-8
"""
根据星座测试性格
"""
girl_name = ['lili', 'Mary', 'COTC', 'Pizze']
girl_sign = ['水瓶座', '射手座', '双鱼座', '双子座']
persion_dict = dict(zip(girl_name, girl_sign))
# 所有星座
sign_all = ['白羊座', '金牛座', '双子座', '巨蟹座', '狮子座', '处女座', '天秤座', '天蝎座', '射手座', '摩羯座', '水瓶座', '双鱼座']
nature = ['有一种让人看见就开心的感觉，阳光，乐观，坚强，性格上直来直往，就是有点小脾气',
'很保守，喜欢稳重，一旦有什么变化就会觉得心理不踏实，性格比较慢热，是个理财高手',
'喜欢追求新鲜感，有点小聪明，耐心不够，因为你的可爱性格会让横多人想和你做朋友',
'情绪容易敏感，缺乏安全，做事情坚持到底有毅力，为人重感情，对朋友和家人特别忠实',
'有着远大的理想，总想着靠自己努力来成为人上人，总是期待被崇拜的感觉',
'坚持追求自己的完美主义',
'追求平等和谐，交际能力强，因此朋友较多',
'精力旺盛',
'崇尚自由',
'是最有耐心的，做事小心，做事踏实，比较固执，不达目的不罢休，而且非常勤奋',
'人很聪明，最大的特点是创新，追求独一无二的生活，个人主义色彩很浓厚',
'集所有星座缺点于一生，最大的有点就是有一颗善良的心'
]
sign_nature = dict(zip(sign_all, nature))
print(sign_nature)
# 输出 lili 的星座和性格
print('%s 的星座是----# %s ' % (girl_name[0], persion_dict[girl_name[0]]))
print("\n %s 的性格特点是：\n\n %s" % (girl_name[0], sign_nature[persion_dict[girl_name[0]]]))4.4.3 遍历字典
字典以 “键 - 值 ” 形式存储数据，所以需要通过 取键值的方式遍历字典 item() 方法
dictioary.item()# coding =utf-8
"""
通过 item() 遍历字典
"""
dictionery = {"qq": '912901363', 'wx': 'cs912901363', 'name': '不混青年', 'CSDN': '我是土豆又土又逗'}
for key, value in dictionery.items(): # 通过key,value 形式输出键值对
print(key, value)
for item in dictionery: # 通过获取键 在通过字典[键]的形式输出元素
print(item, dictionery[item])
for item in dictionery.items(): # 元组形式输出
print(item)注意：字典提供了 keys() 和 values() 方法，使用方法也是通过 for 循环输出
# coding =utf-8
"""
keys() 与 values()
"""
for index in dictionery.keys(): # 输出键
print(index)
for value in dictionery.values(): # 输出键
print(value)4.4.4 添加、修改和删除字典元素
由于字典是可变序列，所以可以随时在字典中添加和删除元素
dictionary[key] = value # 定位元素# coding = utf-8
"""
添加和删除元素
"""
# 添加元素
dictionery = {"qq": '912901363', 'wx': 'cs912901363', 'name': '不混青年', 'CSDN': '我是土豆又土又逗'}
dictionery['age'] = 25
print(dictionery)
# {'qq': '912901363', 'wx': 'cs912901363', 'name': '不混青年', 'CSDN': '我是土豆又土又逗', 'age': 25}
# 如果键重复则替换
dictionery['age'] = 18
print(dictionery)
# {'qq': '912901363', 'wx': 'cs912901363', 'name': '不混青年', 'CSDN': '我是土豆又土又逗', 'age': 18}
# 修改元素
dictionery['name'] = "我是Slatar.cs" # 修改元素
print(dictionery)
# {'qq': '912901363', 'wx': 'cs912901363', 'name': '我是Slatar.cs', 'CSDN': '我是土豆又土又逗', 'age': 18}
# 删除元素
del dictionery["age"] # 通过键指定元素进行删除
print(dictionery)注意：删除元素先判断是否存在
# 删除元素
if "age" in dictionery:
del dictionery["age"] # 通过键指定元素进行删除
print(dictionery)
else:
print("不存在该元素")4.4.5 字典推导式
使用字典推导式可以快速生成一个字典。
# coding = utf-8
import random
"""
字典推导式
"""
# 列表推导式
list_infer = [random.randint(10, 100) for item in range(10)]
print(list_infer)
# 元组推导式
tuple_infer = (random.randint(10, 100) for item in range(10))
print(tuple(tuple_infer))
# 字典推导式
dict_infer = {index: random.randint(10, 100) for index in range(10)}
print(dict_infer)
# 将两个列表转换为字典
list_label = ['qq', 'wx', 'name', 'CSDN', 'age']
list_value = ['912901363', 'cs912901363', '不混青年', '我是土豆又土又逗', 18]
dict_infer = {label: value for label, value in zip(list_label, list_value)}
print(dict_infer) # 推导式
print(dict(zip(list_label, list_value))) # 同上字典补充&练习
- 由一系列键值对组成的可变映射容器。
- 映射：一对一的对应关系，且每条记录无序。
- 键必须惟一且不可变(字符串/数字/元组)，值没有限制。
字典的基本操作
基础操作
- 创建字典：
字典名 = {键1：值1，键2：值2}
字典名 = dict (可迭代对象) - 添加/修改元素：
语法:
字典名[键] = 数据
说明:
键不存在，创建记录。
键存在，修改映射关系。 - 获取元素：
变量 = 字典名[键] # 没有键则错误 - 遍历字典：
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句 - 删除元素：
del 字典名[键]
# coding = utf-8
"""
dict 字典
"""
# 1.创建 （创建空、默认值）
# 创建空字典
dictionary = {}
dictionary = dict()
# 默认值
dictionary = {"wj": "100", "zm": "80", "zr": "90"}
dictionary = dict([("a", "b"), ("c", "d")])
print([("a", "b"), ("c", "d")])
print(dictionary)
dictionary = {("a", "b"): ["a", "b"]}
print(dictionary)
# 2.查找
# 查找前先判断是否存在
if "a" in dictionary:
print(dictionary['a'])
# 2.1 修改元素
dictionary[('a', 'b')] = "BB"
# 3.添加
dictionary["e"] = "EE"
# 4.删除
del dictionary[('a', 'b')]
# 5.遍历
for item in dictionary:
print(item)
print(dictionary[item])
# 遍历字典获取值
for value in dictionary.values():
print(value)
# 遍历字典获取key value
for item in dictionary.items():
print(item)
# 直接湖区键值
for k,v in dictionary.items():
print(k,v)
# 获取键值
for key in dictionary.keys():
print(key)商品信息录入及打印
# coding = utf-8
"""
字典练习:在控制台循环录入商品信息（名称，单价）录入及打印
如果名称输入空字符，则停止录入，将所有信息逐行打印出来
"""
# mine
dict_shopping = {}
while True:
string = input("请输入商品名称以及价格：逗号分割开 e.g:(电视 7999)：")
if string == '':
print("\t\t录入结束，打印所有商品信息：\n\n")
break
else:
dict_shopping[string.split(" ")[0]] = string.split(" ")[1]
for key, value in dict_shopping.items():
print("商品信息如下---商品名称:%s\t商品价格:%s" % (key, value))
# teacher
dict_commodity_info = {}
while True:
name = input("请输入商品名称：")
if name == "":
break
price = int(input("请输入商品价格："))
dict_commodity_info[name] = price
# 输入相同键覆盖
for key, value in dict_shopping.items():
print("商品信息如下---商品名称:%s\t商品价格:%s" % (key, value))学生信息录入及打印
# coding = utf-8
"""
在控制台循环录入学生的信息（姓名、年龄、成绩、性别）
如果名称输入空字符，则停止录入
"""
# 字典内嵌列表
dict_student_info = {}
list_student_info = []
while True:
name = input("请输入学生姓名：")
if name == '':
print("录入结束")
break
age = int(input("请输入学生年龄："))
source = float(input("请输入学生成绩："))
sex = input("请输入学生性别：")
tuple_01 = (name, age, source, sex) # 使用元组
list_student_info = [name, age, source, sex] # 使用列表
# list_student_info.append(name)
# list_student_info.append(age)
# list_student_info.append(source)
# list_student_info.append(sex)
dict_student_info[name] = list_student_info
for k, v in dict_student_info.items():
print("学生信息~ 姓名：%s 年龄：%d 成绩：%.1f 性别：%s" % (k, v[1], v[2], v[3]))
print(tuple_01)
# 字典内嵌字典
while True:
name = input("请输入学生姓名：")
if name == '':
print("录入结束")
break
age = int(input("请输入学生年龄："))
source = float(input("请输入学生成绩："))
sex = input("请输入学生性别：")
dict_student_info[name] = {"name": name, "age": age, "source": source, "sex": sex}
for k, v in dict_student_info.items():
print("学生信息~ 姓名：%s 年龄：%d 成绩：%.1f 性别：%s" % (k, v["age"], v["source"], v["sex"]))
# 代码重命名 选择变量名 shift + F6
# 列表嵌套字典（可以按照序列输出）
list_student_info = []
while True:
name = input("请输入学生姓名：")
if name == '':
print("录入结束")
break
age = int(input("请输入学生年龄："))
source = float(input("请输入学生成绩："))
sex = input("请输入学生性别：")
list_student_info.append({"name": name, "age": age, "source": source, "sex": sex})
for i, v in enumerate(list_student_info):
print("第 %d 学生信息~ 姓名：%s 年龄：%d 成绩：%.1f 性别：%s" % (i, v["name"], v["age"], v["source"], v["sex"]))字典 VS 列表
- 都是可变容器。
- 获取元素方式不同,列表用索引,字典用键。
- 字典的插入,删除,修改的速度快于列表。
- 列表的存储是有序的,字典的存储是无序的。
# coding = utf-8
"""
容器的使用场景案例
"""
# 选择策略：根据具体需求，结合优缺点，综合考虑（两害相权取其轻）
"""
字典：
优点：读取速度快（根据键获取值）、代码可读性高、可变序列
缺点：内存占用大、无序
字典：
优点：有序、可变序列、根据索引/切片，获取元素更灵活，相比字典占用内存小
缺点：通过索引获取，可读性不高
"""
# 在控制台中录入多个人的多个个人喜好,
times = 1
list_user_fin = []
while True:
list_user_hobby = [] # 存放爱好
dict_user_hobby = {} # 存放键值
name = input("请输入姓名:")
if name == "":
print("录入结束~ \n")
break
while True:
hobby = input("请输入 " + str(times) + " 个喜好:")
if hobby == "":
print("\t%s 的喜好录入结束\n" % name)
break
times += 1
list_user_hobby.append(hobby)
dict_user_hobby[name] = list_user_hobby
list_user_fin.append(dict_user_hobby)
times = 1
print(list_user_fin)作业测试
# coding = utf-8
"""
3. 将1970年到2050年中的闰年，存入列表．
4. 存储全国各个城市的景区与美食(不用录入),在控制台中显示出来.
北京：
景区：故宫,天安门,天坛.
美食: 烤鸭,炸酱面,豆汁,卤煮.
{北京：｛美食：~，景区：~｝}
四川:
景区：九寨沟,峨眉山,春熙路．
美食: 火锅,串串香,兔头.
5.(扩展)计算一个字符串中的字符以及出现的次数.
# 思想：
# 逐一判断字符出现的次数.
# 如果统计过则增加１，如果没统计过则等于１.
abcdefce
a 1
b 1
c 2
d 1
e 2
f 1
"""
# coding = utf-8
"""
3. 将1970年到2050年中的闰年，存入列表．
4. 存储全国各个城市的景区与美食(不用录入),在控制台中显示出来.
北京：
景区：故宫,天安门,天坛.
美食: 烤鸭,炸酱面,豆汁,卤煮.
{北京：｛美食：~，景区：~｝}
四川:
景区：九寨沟,峨眉山,春熙路．
美食: 火锅,串串香,兔头.
5.(扩展)计算一个字符串中的字符以及出现的次数.
# 思想：
# 逐一判断字符出现的次数.
# 如果统计过则增加１，如果没统计过则等于１.
abcdefce
a 1
b 1
c 2
d 1
e 2
f 1
"""
# 3. 将1970年到2050年中的闰年，存入列表．
list_r_yrar = []
for i in range(1970, 2050, 1):
if (i % 4 == 0 and i % 100 != 0) or (i % 400 == 0):
list_r_yrar.append(i)
print(list_r_yrar)
# 练习4
dict_city = {}
while True:
city = input("请输入一个城市：")
if city == "":
print("输入结束退出~！")
break
dict_city_t = {}
list_food = []
list_view = []
while True:
food = input("请输入该城市的一个美食：")
if food == "":
print("事务录入结束：~！")
break
list_food.append(food)
dict_city_t["美食"] = list_food
while True:
view = input("请输入该城市的一个景区：")
if view == "":
print("事务录入结束：~！")
break
list_view.append(view)
dict_city_t["景区"] = list_view
dict_city[city] = dict_city_t
for key, value in dict_city.items():
print("该城市 %s:\t\t\t\n" % key)
for keys, values in value.items():
print("%s " % keys, end='/')
print("-".join(values), end=",")
print("\n\n")
# (扩展)计算一个字符串中的字符以及出现的次数
# 字符串方法
string = input("请输入一段字符串:")
string_flag = input("请输入你要判断出现多少次的字符:")
print(string.count(string_flag))
# 循环判断
times = 0
for i in string:
if string_flag == i:
times += 1
print(times)
# 判断每个字母出现的次数
string = input("请输入一段字符串:")
dict_string = {}
for i in string:
dict_string[i] = string.count(i)
print(dict_string)
# 遍历判断
string = input("请输入一段字符串:")
dict_string = {}
times = 0
for i in string:
for j in string:
if i == j:
times += 1
dict_string[i] = times
times = 0
print(dict_string)字典推导式
# coding = utf-8
"""
字典的推导式
"""
# 求 1 2 3 4 ... 10 的平方
dict_number = {item: item ** 2 for item in range(1, 11, 1)}
print(dict_number)
# 只记录大于5的数
dict_number = {item: item ** 2 for item in range(1, 11, 1) if item > 5}
print(dict_number)
# 练习1 ['张无忌','赵敏','周芷若'] --》 变成字典 名字作为键字符长度作为值
dict_string = {item: len(item) for item in ['张无忌', '赵敏', '周芷若']}
print(dict_string)
# 练习2 将两个列表放在字典中
list_name = ['张无忌', '赵敏', '周芷若']
list_number = [101, 102, 103]
# 方法1 zip
dict_string = dict(zip(list_name, list_number))
print(dict_string)
# 方法2 循环
dict_result = {list_name[i]: list_number[i] for i in range(0, len(list_name), 1)}
print(dict_result)
# 需求：字典如何根据value 查 key
# ---方法1 (键值颠倒) 不能重复
dict_result_re = {value: key for key, value in dict_result.items()}
print(dict_result_re)
# ---方法2 通过列表存放元组实现
list_name = ['张无忌', '赵敏', '周芷若']
list_number = [101, 102, 101]
dict_01 = dict(zip(list_name, list_number))
list_02 = [(value, key) for key, value in dict_01.items()]
print(list_02)4.5 集合
Python中集合与数学上的集合类似，也是用于保存不重复的元素，有可变集合set ,和不可变集合 frozenset 两种。形式上所有元素都放在一对 ｛｝ 中，两个相邻的元素之间使用 “ , ” 分割，集合最好的用处就是去掉重复的元素，集合中的每一个元素都是唯一的
集合的常用操作就是创建集合、集合的添加、删除、交集、并集、和差集、运算
4.5.1 集合的创建
在Python 中提供了两种创建集合的方法：第一种是使用｛｝创建，另外一种是通过set() 函数将列表，元组，等可迭代的对象转为集合
1：直接使用｛｝ 创建集合
python中，创建set 集合也可以像创建列表、字典、元组一样，直接将集合赋值给变量从而实现创建集合
setname = {element1 , element2 ,element3 ,element4}注意：在创建集合时，如果输入了重复的元素，Python会自动只保留一个,set集合中元素是无序排列的。
# coding = utf-8
"""
set 集合的创建
"""
set01 = {'水瓶座', '射手座', '双鱼座', '双子座'}
set02 = {3, 1, 2, 3, 5, 9, 2, 6}
set03 = {'python', 25, ('人生苦短', '我用python')}
print(set01)
print(set02)
print(set03)
# {'水瓶座', '射手座', '双子座', '双鱼座'}
# {1, 2, 3, 5, 6, 9}
# {('人生苦短', '我用python'), 'python', 25}2：使用set() 函数创建
在python中，可以使用set()函数将列表、元组、等其他可迭代对象转换为集合，set() 函数的语法格式如下：
setname = set(iteration)# coding = utf-8
"""
使用set() 创建集合
"""
set01 = set('命运给予我们的不是失望之酒，而是机会之杯')
set02 = set([1.4123, 2.456, 3.123, 1.1234])
set03 = set(('人生苦短','我用python'))
print(set01)
print(set02)
print(set03)
# {'会', '之', '的', '失', '望', '酒', '予', '，', '机', '杯', '不', '命', '我', '运', '而', '给', '是', '们'}
# {1.4123, 2.456, 3.123, 1.1234}
# {'人生苦短', '我用python'}注意：在创建空集合的时候不能使用 ｛｝ 来创建，只能使用 set() 函数来实现
4.5.2 集合的添加和删除
集合是可变序列，所以创建集合后可以添加元素或者删除元素
1：向集合中添加元素
setname.add(element)# coding = utf-8
"""
使用set() 创建集合
"""
set01 = set('命运给予我们的不是失望之酒，而是机会之杯')
set02 = set([1.4123, 2.456, 3.123, 1.1234])
set03 = set(('人生苦短','我用python'))
set03.add("创造辉煌")
print(set03)2：从集合中删除元素
python 中通过 del可以删除整个集合，也可以使用集合的pop()方法或者是 remove() 方法删除一个元素，或者使用集合对象的clear() 清空集合
# coding =utf-8
"""
集合的删除和元素删除
"""
mr = {'零基础学Java', '零基础学Python', '零基础学C', '零基础学PHP'}
mr.remove("零基础学C") # 移除指定的元素
print(mr)
mr.pop() # 删除一个元素
print(mr)
mr.clear() # 清空set集合
print(mr)
# {'零基础学PHP', '零基础学Java', '零基础学Python'}
# {'零基础学Java', '零基础学Python'}
# set()4.5.3 集合的交集、并集、差集运算
集合最常用的操作是进行交集、并集、差集和对称差集的运算。
符号 | 作用 |
& | 交集运算 |
\ | 并集运算 |
- | 差集运算 |
^ | 对称差集运算 |
# coding = utf-8
"""
集合运算
"""
python = set(["张三", "李四", "王麻子", "瓜皮"])
lung_c = set(['小王', '瓜皮', '李军', '张三'])
print(python)
print(lung_c)
# 输出及选择Python又选择 C 的同学
print("交集运算", python & lung_c)
# 输出参加所有选课的同学
print("并集运算", python | lung_c)
# 输出之选择了python的同学，没选择C的同学
print("差值运算", python - lung_c )
# 输出之选择了C的同学，没选择python的同学
print("差值运算", lung_c - python )集合的补充与练习
定义
- 由一系列不重复的不可变类型变量组成的可变映射容器。
- 相当于只有键没有值的字典(键则是集合的数据)。
基础操作
- 创建空集合：
集合名 = set()
集合名 = set(可迭代对象) - 创建具有默认值集合：
集合名 = {1, 2, 3}
集合名 = set(可迭代对象) - 添加元素：
集合名.add(元素) - 删除元素：
集合名.discard(元素)
交集、并集、补集、子集、超集 运算
# coding = utf-8
"""
集合的数学运算
"""
set01 = {1, 2, 3}
set02 = {2, 3, 4}
# 交集
print(set01 & set02) # {2, 3}
# 并集
print(set01 | set02) # {1, 2, 3, 4}
# 补给
print(set01 ^ set02) # {1, 4}
# 子集
set03 = {1, 2}
print(set03 < set01) # True 判断是否子集
# 超集
print(set02 > set01) # False 判断是否是超集集合练习
# coding = utf-8
"""
集合的练习
"""
# 在控制台中循环录入字符串，输入空字符停止 打印不重复的文字
set_string = set()
while True:
string = input("请输入一段字符：")
if string == "":
print("END~")
break
set_string.add(string)
print("".join(list(set_string)))
"""
经理 ： 曹操、刘备、孙权 技术：曹操、刘备、张飞、关羽
1：是经理也是技术的有谁
2：是经理不是技术的人员
3：是技术不是经理的人员
4：张飞是经理吗
5：身兼一职的有谁
6:经理和技术总共有多少人
"""
set_manager = {'曹操', '刘备', '孙权'}
set_skill = {'曹操', '刘备', '张飞', '关羽'}
# 1 是经理也是技术的有谁
print(set_manager & set_skill) # 求交集
# 2：是经理不是技术的人员
print(set_manager - set_skill) # 差集
# 3：是技术不是经理的人员
print(set_skill - set_manager) # 差集
# 4：张飞是经理吗
print({"张飞"} < set_manager ) # 子集
# 5：身兼一职的有谁
print(set_manager ^ set_skill) # 求补集 （两边多出来的）
# 6:经理和技术总共有多少人
print(set_manager | set_skill) # 并集固定集合 frozenset
定义
不可变的集合。
作用:固定集合可以作为字典的键,还可以作为集合的值。基础操作
创建固定集合：frozenset(可迭代对象)
运算:等同于set# coding = utf -8
"""
frozenset 不可变集合
"""
froz_set01 = frozenset([1, 2, 3, 4, 3, 2, 5])
print(list(froz_set01))4.6 列表、元组、字典、集合的区别
数据结构 | 是否可变 | 是否重复 | 是否有序 | 定义符号 |
列表 list() | 可变 | 可重复 | 有序 | [] |
元组 tuple() | 不可变 | 可重复 | 有序 | () |
字典 dict() | 可变 | 键不可重复,元素可以重复 | 无序 | {key:value} |
集合 | 可变 | 不重复 | 无序 | {} |
4.7 实战
输出王者荣耀的角色
# coding = utf - 8
"""
输出王者荣耀的游戏角色
英雄分为：法师、战士、坦克、刺客、射手、辅助，
要求：将列表存储不同类型的英雄，并遍历输出
"""
list_role = ["法师", "战士", "坦克", "刺客", "射手", "辅助"]
list_master = ['杨玉环', '女娲', '鬼谷子', '芈月']
list_soldier = ['狂铁', '孙悟空', '亚瑟', '关于']
list_tank = ['刘邦', '白起', '巨灵神', '猪八戒']
list_assassin = ['庞统', '花木兰', '兰陵王', '韩信']
list_shot = ['后裔', '刘备', '虞姬', '狄仁杰']
list_assist = ['孙斌', '蔡文姬', '梦奇', '明世隐']
tuple_name = (list_master, list_soldier, list_tank, list_assassin, list_shot, list_assist)
dict_wzry = dict(zip(list_role, tuple_name))
print("----王者荣耀，游戏角色----\t\t\n")
for key, value in dict_wzry.items():
print("====%s:====" % key)
for item in value:
print(item, end="\t")
print()
----王者荣耀，游戏角色----
====法师:====
杨玉环 女娲 鬼谷子 芈月
====战士:====
狂铁 孙悟空 亚瑟 关于
====坦克:====
刘邦 白起 巨灵神 猪八戒
====刺客:====
庞统 花木兰 兰陵王 韩信
====射手:====
后裔 刘备 虞姬 狄仁杰
====辅助:====
孙斌 蔡文姬 梦奇 明世隐模拟或者订票系统
# coding = utf - 8
# 模拟火车订票系统
list_01 = ['长春-北京', '00:12', '12:20', '12:08']
list_02 = ['长春-北京', '00:12', '12:20', '12:08']
list_03 = ['长春-北京', '00:12', '12:20', '12:08']
list_04 = ['长春-北京', '00:12', '12:20', '12:08']
dict_train = {"T40": list_01, "T298": list_02, "Z158": list_03, "Z62": list_04}
print("车次\t\t出发站-起始站\t\t出发时间\t\t到达时间\t\t历时")
for key, value in dict_train.items():
print(key, "\t", value[0], "\t\t", value[1], "\t\t", value[2], "\t\t", value[3])
车次 出发站-起始站 出发时间 到达时间 历时
T40 长春-北京 00:12 12:20 12:08
T298 长春-北京 00:12 12:20 12:08
Z158 长春-北京 00:12 12:20 12:08
Z62 长春-北京 00:12 12:20 12:08电视剧收视率排行榜
# 利用元组和列表排序电视收视率
list_itv = [("《give up never》", 1.4),
("《The private dishes》", 1.343),
("《My father-in-law》", 0.92),
("《Sparry》", 0.862)
]
list_itv.sort(reverse=True)
print(list_itv)# 利用元组和列表排序电视收视率
list_itv = [("《give up never》", 1.4),
("《The private dishes》", 1.343),
("《My father-in-law》", 0.92),
("《Sparry》", 0.862)
]
list_itv.sort(reverse=True)
print(list_itv)定制自己的手机套餐
# 定制自己的手机套餐
print("定制自己的手机套餐：")
list_voice = ["0分钟", "50分钟", "100分钟", "300分钟", "不限量"]
list_flow = ["0M", "500M", "1G", "5G"]
list_message = ["0条", "50条", "100条"]
list_result = []
print("A.请设置通话时长：")
for index, value in enumerate(list_voice):
print(index + 1, "\t", value)
select = int(input(":"))
list_result.append(list_voice[select - 1])
print("B.请设置流量时长：")
for index, value in enumerate(list_flow):
print(index + 1, "\t", value)
select = int(input(":"))
list_result.append(list_flow[select - 1])
print("C.请设置短信条数：")
for index, value in enumerate(list_message):
print(index + 1, "\t", value)
select = int(input(":"))
list_result.append(list_message[select - 1])
print("您的手机套餐已经定制成功，免费通话时长 %s /月，流量时长 %s /月，短信条数 %s /月 " \
% (list_result[0], list_result[1], list_result[2]))双 for 循环
# coding = utf-8
"""
for for 双重循环练习
"""
# 外出循环控制行
for r in range(4):
# 内存循环控制列
for c in range(6):
if c % 2 == 0:
print("*", end=" ")
else:
print("#", end=" ")
print()
# 画直角三角形
for r in range(0, 4, 1):
for c in range(0, r + 1):
print("*", end=' ')
print()
# 列表 [3,4,45,5,7,9,1] (升序、降序)
# --两两数据比较在在列表中切换位置，把最大的放在后面，挑最大
list_mp = [3, 4, 45, 5, 7, 9, 1]
for i in range(len(list_mp)):
for j in range(len(list_mp) - i - 1):
if list_mp[j] > list_mp[j + 1]: # 升序
list_mp[j], list_mp[j + 1] = list_mp[j + 1], list_mp[j]
print(list_mp)
# --第一次循环取出一个数，与列表中的第二个数开始做比较，如果大于则交换位置不满足则不动，排位置
list_mp = [80, 4, 45, 5, 7, 9, 1]
for r in range(len(list_mp)-1):
for c in range(r+1, len(list_mp)):
if list_mp[r] > list_mp[c]:
list_mp[r], list_mp[c] = list_mp[c], list_mp[r]
print(list_mp)冒泡查重列表嵌套推导式
# coding = utf-8
"""
for for 双重循环练习
"""
# 外出循环控制行
for r in range(4):
# 内存循环控制列
for c in range(6):
if c % 2 == 0:
print("*", end=" ")
else:
print("#", end=" ")
print()
# 画直角三角形
for r in range(0, 4, 1):
for c in range(0, r + 1):
print("*", end=' ')
print()
# 列表 [3,4,45,5,7,9,1] (升序、降序)
# --两两数据比较在在列表中切换位置，把最大的放在后面，挑最大
list_mp = [3, 4, 45, 5, 7, 9, 1]
for i in range(len(list_mp)):
for j in range(len(list_mp) - i - 1):
if list_mp[j] > list_mp[j + 1]: # 升序
list_mp[j], list_mp[j + 1] = list_mp[j + 1], list_mp[j]
print(list_mp)
# --第一次循环取出一个数，与列表中的第二个数开始做比较，如果大于则交换位置不满足则不动，排位置
list_mp = [80, 4, 45, 5, 7, 9, 1]
for r in range(len(list_mp) - 1):
for c in range(r + 1, len(list_mp)):
if list_mp[r] > list_mp[c]:
list_mp[r], list_mp[c] = list_mp[c], list_mp[r]
print(list_mp)
"""
练习：
判断列表中的元素是否具有相同的元素[3,80,45,5,80,3]
"""
list_distinct = [3, 80, 45, 5, 80, 3, 3, 3]
list_value = [1, 1, 1, 1, 1, 1]
dict_dictinct = dict(zip(list_distinct, list_value))
for r in range(len(list_distinct) - 1):
for c in range(r + 1, len(list_distinct)):
if list_distinct[r] == list_distinct[c]:
dict_dictinct[list_distinct[r]] += 1
break
print(dict_dictinct)
"""
列表操作
"""
list_tank = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
]
# 练习1：打印第二行第三个
flag = False
for r in range(len(list_tank)):
for c in range(len(list_tank)):
if r == 1:
print(list_tank[r][2])
flag = True
break
if flag:
break
# 练习2：打印第三行每个元素
for r in range(len(list_tank)):
for c in range(len(list_tank)):
if r == 2:
print(list_tank[r][c], end="/")
print()
# 练习3：打印第一列每个元素
for r in range(len(list_tank)):
for c in range(len(list_tank)):
if c == 0:
print(list_tank[r][c], end="/")
print()
print("""矩阵转置""")
"""
矩阵转置，将列变成行
"""
list_tank = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
]
list_tank_r = []
for r in range(len(list_tank)):
list_tank_r.append([])
for c in range(len(list_tank)):
list_tank_r[r].append(list_tank[c][r])
print(list_tank_r)
# ----列表推导式
list_tank_r = [list_tank[c][r] for r in range(len(list_tank)) for c in range(len(list_tank))]
print(list_tank_r)
"""
列表式嵌套
"""
list01 = ['a', 'b', 'c']
list02 = ['A', 'B', 'C']
list03 = []
for r in list01:
for c in list02:
list03.append(r + c)
print(list03)
# 等同于
list03 = [r + c for r in list01 for c in list02]
print(list03)
# 练习： ['香蕉','苹果','哈密瓜'] ['可乐','牛奶'] 列表全排列
list_all = [i + j for i in ['香蕉', '苹果', '哈密瓜'] for j in ['可乐', '牛奶']]
print(list_all)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
