Python(第四章) 序列的应用

第四章

本章概览

在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 python


4.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='')

列表的练习&补充

定义
由一系列变量组成的可变序列容器。
基础操作

  1. 创建列表:
    列表名 = []
    列表名 = list(可迭代对象)
  2. 添加元素:
    列表名.append(元素)
    列表.insert(索引,元素)
  3. 定位元素:
    索引、切片
  4. 遍历列表:
    正向:
    for 变量名 in 列表名:
    变量名就是元素
    反向:
    for 索引名 in range(len(列表名)-1,-1,-1):
    列表名[索引名]就是元素
  5. 删除元素:
    列表名.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字符串

  1. 列表和字符串都是序列,元素之间有先后顺序关系。
  2. 字符串是不可变的序列,列表是可变的序列。
  3. 字符串中每个元素只能存储字符,而列表可以存储任意类型。
  4. 列表和字符串都是可迭代对象。
  5. 函数:
    将多个字符串拼接为一个。
    result = “连接符”.join(列表)

将一个字符串拆分为多个。
列表 = “a-b-c-d”.split(“分隔符”)

列表推导式

  1. 定义:
    使用简易方法,将可迭代对象转换为列表。
  2. 语法:
    变量 = [表达式 for 变量 in 可迭代对象]
    变量 = [表达式 for 变量 in 可迭代对象 if 条件]
  3. 说明:
    如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
    列表推导式嵌套
  4. 语法:
    变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
  5. 传统写法:
    result = []
    for r in [“a”, “b”, “c”]:
    for c in [“A”, “B”, “C”]:
    result.append(r + c)
  6. 推导式写法:
    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个红球1个蓝球].

(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个红球1个蓝球].

(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)
列表推导式
  1. 定义:
    使用简易方法,将可迭代对象转换为列表。
  2. 语法:
    变量 = [表达式 for 变量 in 可迭代对象]
    变量 = [表达式 for 变量 in 可迭代对象 if 条件]
  3. 说明:
    如果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)

列表推导式嵌套
  1. 语法:
    变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
  2. 传统写法:
    result = []
    for r in [“a”, “b”, “c”]:
    for c in [“A”, “B”, “C”]:
    result.append(r + c)
  3. 推导式写法:
    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. 不可变是指一但创建,不可以再添加/删除/修改元素。

    注释: 列表的扩容原理
    1:列表都会预留空间
    2:当预留空间不足时,会再创建新的列表(开一个更大的空间)
    3:将原有数据拷贝到新列表中
    4:替换引用(表头)

基本操作
  1. 创建空元组:
    元组名 = ()
    元组名 = tuple()
  2. 创建非空元组:
    元组名 = (20,)
    元组名 = (1, 2, 3)
    元组名 = 100,200,300
    元组名 = tuple(可迭代对象)
  3. 获取元素:
    索引、切片
  4. 遍历元组:
    正向:
    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])
作用
  1. 元组与列表都可以存储一系列变量,由于列表会预留内存空间,所以可以增加元素。
  2. 元组会按需分配内存,所以如果变量数量固定,建议使用元组,因为占用空间更小。
  3. 应用:
    变量交换的本质就是创建元组: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.54311.85
appleorangebananapeachpera

创建字典的时候,在“键”和“值” 之间使用冒号分割,相邻两个元素使用逗号分割,所有元素放在 “{}” 花括号中,语法格式如下:

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. 由一系列键值对组成的可变映射容器。
  2. 映射:一对一的对应关系,且每条记录无序。
  3. 键必须惟一且不可变(字符串/数字/元组),值没有限制。
字典的基本操作

基础操作

  1. 创建字典:
    字典名 = {键1:值1,键2:值2}
    字典名 = dict (可迭代对象)
  2. 添加/修改元素:
    语法:
    字典名[键] = 数据
    说明:
    键不存在,创建记录。
    键存在,修改映射关系。
  3. 获取元素:
    变量 = 字典名[键] # 没有键则错误
  4. 遍历字典:
    for 键名 in 字典名:
    字典名[键名]
    for 键名,值名 in 字典名.items():
    语句
  5. 删除元素:
    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 列表
  1. 都是可变容器。
  2. 获取元素方式不同,列表用索引,字典用键。
  3. 字典的插入,删除,修改的速度快于列表。
  4. 列表的存储是有序的,字典的存储是无序的。
# 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.(扩展)计算一个字符串中的字符以及出现的次数.
# 思想:
# 逐一判断字符出现的次数.
# 如果统计过则增加1,如果没统计过则等于1.

abcdefce
a 1
b 1
c 2
d 1
e 2
f 1
"""
# coding = utf-8
"""
3. 将1970年到2050年中的闰年,存入列表.

4. 存储全国各个城市的景区与美食(不用录入),在控制台中显示出来.
   北京:
        景区:故宫,天安门,天坛.
        美食: 烤鸭,炸酱面,豆汁,卤煮.
        {北京:{美食:~,景区:~}}
    四川:
        景区:九寨沟,峨眉山,春熙路.
        美食: 火锅,串串香,兔头.

5.(扩展)计算一个字符串中的字符以及出现的次数.
# 思想:
# 逐一判断字符出现的次数.
# 如果统计过则增加1,如果没统计过则等于1.

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 )

集合的补充与练习

定义

  1. 由一系列不重复的不可变类型变量组成的可变映射容器。
  2. 相当于只有键没有值的字典(键则是集合的数据)。

基础操作

  1. 创建空集合:
    集合名 = set()
    集合名 = set(可迭代对象)
  2. 创建具有默认值集合:
    集合名 = {1, 2, 3}
    集合名 = set(可迭代对象)
  3. 添加元素:
    集合名.add(元素)
  4. 删除元素:
    集合名.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)

  • 5
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值