AI产品经理Python必读技术之序列的应用

在学习数学的时候，我们学习到过等差数列、等比数列以及比较有名的斐波那契数列等，其中斐波那契数列又称为兔子数列，有兴趣的朋友可以去百度一下，这里不做详细。

而在我们Python当中又分为 序列->数据存储方式->数据结构，其中在Java或C语言中以数组为主，而Python当中则又可分为列表、元组、字典、集合、字符串几类。

一、序列的概述

1）索引

概念：序列是一块用于存放多个值的连续的内存空间，并且按照一定顺序排列，可通过索引取值。

比如，我们可以把酒店的每一个房间比作内存的空间，而房间号就是索引，而这整个房间排序的概念则称为序列。

索引：索引在序列中就是一个编号，是从0开始数。在这里我们需要编程思维，因为计算机把0当做了我们日常生活中的1。因为计算机只识别0和1，所以无论我们输入什么都会被转化称为0或1。

代码：string = “失望之酒，希望之杯！”

print(string[1])

输出：望

在Python中索引的值还可以是负数，例如：

元素1 元素2 元素3 元素4 元素5

-5  -4  -3  -2  -1

代码：string = “失望之酒，希望之杯！”

print(string[-1])

输出：杯

2）切片

概念：切片又称为分片，就像我们生活当中据木头一样，左边砍一节，右边砍一节，最后中间就是我们想要的木头。

在序列中如下：

元素1 元素2 元素3 元素4 元素5

如果我们想要：元素2 元素3 元素4

想要取出来，我们就可以使用：sname[start:end:step]

其中，start是起始位置，end结束位置，step为步长

代码：

nba = [“乔丹”,”拉塞尔”,”张伯伦”,”邓肯”,”拉塞”,”波塞冬”]

print(nba[1:5])

输出:[‘拉塞尔’,’张伯伦’,’邓肯’,’拉塞’]

print(nba[0:5:2])

输出：[‘乔丹’,’张伯伦’,’拉塞’]

print(nba[5])  #获取索引值为5，此处不是切片应用

输出：波塞冬

print(nba[:5])

输出： [“乔丹”,”拉塞尔”,”张伯伦”,”邓肯”,”拉塞”]

print(nba[:])

输出:[“乔丹”,”拉塞尔”,”张伯伦”,”邓肯”,”拉塞”,”波塞冬”]

print(nba[5:]) #输出索引值为5后面的所有

输出:[‘波塞冬’]

3）序列相加

序列1 + 序列2 = 序列1序列2

代码：

nba1 = [“乔丹”,”陈涛”]

nba2 = [“麦当娜”,”杰克逊”]

nba = nab1 + nba2

print(nba)

输出：[“乔丹”,”陈涛”，“麦当娜”,”杰克逊”]

序列相加需注意：只能是同类型的序列相加，列表+列表、元组+元组、字符串+字符串，而不能是不同类型的：列表+元组、字符串+元组、字符串+列表，都是错误的。

代码----不用类型序列相加：

nba1 = [“乔丹”,”陈涛”]

print(“我要相加” + nba1)

输出：错误。

代码----相同类型不同元素类型相加

nba1 = [“乔丹”,”陈涛”]

nba2 = [1,2,3]

print(nba1 + nba2)

输出： [“乔丹”,”陈涛”，1,2,3]

4）序列的乘法

在数学中，我们常见的乘法如下：乘数 * 乘数 = 积

在Python中的序列中，我们也可以如此运用：序列 * 乘数 = 重复n次的序列

代码：

phone = [“HuaWei”,”ChenTao”,”Lisi”,”Libai”]

print(phone * 3)

输出：[“HuaWei”,”ChenTao”,”Lisi”,”Libai”，“HuaWei”,”ChenTao”,”Lisi”,”Libai”，“HuaWei”,”ChenTao”,”Lisi”,”Libai”]

代码：

number = [1,2,3]

print(number * 3)

输出：[1,2,3,1,2,3,1,2,3]

代码：

emptylist = [None] * 5

print(emyptylist)

输出：[None,None,None,None,None]

代码：

print(“*” * 10)

输出：**********

4) 检查某个元素是否是序列的成员在Python中，检查某个元素是否在序列中可通过in进行查看，语法如下：

value in sequence

代码:

nba = [“陈涛”,”李绮文”,”张三”]

print(“科比” in  nba)

输出：False

print(“陈涛” in nba)

输出：True

print(“科比” not in  nba)

输出:True

5) 计算序列的长度

在Python当中提供了len（）来计算序列的函数。

代码：

number = [1,2,3,4,5,6]

print(len(number))

输出：6

代码：

string = “我是陈涛”

print(len(string))

输出:4

注意：len()统计，不区分字母或者汉字

在Python当中max()函数找出序列当中的最大值。

代码：

number = [1,2,3,4,5,6]

print(max(number))

输出：6

在Python中min()函数找出序列当中的最小值。

代码：

number = [1,2,3,4,5,6]

print(min(number))

输出：1

一、列表

列表相当于酒店房间的排序，在列表中可以放入：对象、整数、序列、实数、布尔值、字符串。在Python中，列表是内置的可变序列->[元素1，元素2，元素3,......，元素n]。列表的使用共包含：访问列表元素、列表的创建和删除、遍历列表、添加修改和删除列表元素、对列表进行统计计算、对列表进行排序、列表推导式、二维列表的使用。

1）列表的创建和删除

（1）使用赋值运算符直接创建列表

语法：listname = [元素1，元素2，元素3,......,元素n]

代码：

number = [2，4，6，8，10]

verse = [“春眠不觉晓”,”处处蚊子咬”]

python = [‘优雅’,’自由’,”简单”,’’’温柔’’’]

untile = [“Python”, 28 ,”人生苦短，我用Python”,[“爬虫”,”云计算”,”Web开发”]]

（2）创建空列表

emptylist = []

注意：比如有一个函数需要传递一个列表函数，那么我们可以使用空列表进行传递。

（3）创建数值列表

学生成绩列表：[11,100,23,53]

玩家得分情况列表：[111,232,343,12321,343434]

代码：

list(range(2,21,2))  #list()函数，将数值转化为列表

输出：[2，4，6，8，10，12，14，16，18，20]

代码:

string = “远航科技”

list(string)

输出：[“远”,”航”,”科”,”技”]

(4) 删除列表

代码：

number = [2，4，6，8，10]

del number

输出：删除成功

注意Python自带垃圾处理回收机制，会自动销毁不用的列表，所以即使我们不手动删除，Python也会自动将其销毁。

2）访问列表元素

代码：

python = [“Python”,28，“人生苦短，我用Python”,[“爬虫”，“自动化运维”，“云计算”,“Web开发”]]

print(python)

输出：[“Python”,28，“人生苦短，我用Python”,[“爬虫”，“自动化运维”，“云计算”,“Web开发”]]

print(python[2])

输出：人生苦短，我用Python

print(python[1：3])

输出：[28,“人生苦短,我用Python”]

代码：import datetime #导入日期时间类

mot = [“今天星期一：\n坚持下去不是因为我很坚强，而是因为我别无选择。”,”今天星期二：\n含泪播种的人一定能笑着收获。”,”今天星期三：\n做对的事情比把事情做对重要”,”今天星期四：\n命运给予我们的不是失望之酒，而是希望之杯。”，“今天星期五：\n不要等到明天，明天太遥远，今天就行动。”，“今天星期六：\n求知若渴，虚心若愚。”，“今天星期日：\n成功将属于那些从不说“不可能”的人。”]

day = datetime.datetime.now().weekday()  #获取当前的星期

print(mot[day]) #输出每日一贴

输出：今天星期三，

做对的事情比把事情做对重要

3）遍历列表

遍历是指，从头到尾都访问一遍。

（1）使用for循环遍历

for item in listname： #输出item

代码

print(“2018年NBA常规赛西部排名：”)

team = [“火箭队”，“勇士队”，“雷霆队”，“爵士队”] #定义一个列表

for item in team:

print(item) #输出每一个球队的名称

输出：

2018年NBA常规赛西部排名：

火箭队

勇士队

雷霆队

爵士队

（2）使用for循环和enumerate()函数实现

for item in enumerate(listname):   #输出index和item

代码：

print(“2018年NBA常规赛西部排名：”)

team = [“火箭队”，“勇士队”，“雷霆队”，“爵士队”] #定义一个列表

for index,item in enumerrate(team):

print(index + 1，item) #输出每一个球队的名称

输出：

2018年NBA常规赛西部排名：

1，火箭队

2，勇士队

3，雷霆队

4，爵士队

实例代码：

print(“输入2017~2018赛季NBA西部联盟排名：\n”)

team = [“火箭队”，“勇士队”，“雷霆队”，“爵士队”,”马刺队”，“深林狼”，“狐狸队”，“七匹马”]

for index,item in enumerater(team):

if index % 2 == 0：

print(item + “\t\t”,end = ‘’)

else:

print(item) #换行输出

4）添加、修改和删除列表元素

}

（1）添加元素

可以通过append()函数添加元素：列表1.appened(新元素) = 列表1中的元素，新元素

phone = [“摩托罗拉”,“诺基亚”,”三星”，“OPPO”] #定义列表

print(len(phone))

输出：4

phone.appened（“iPhone”) #新添加的元素

print(len(phone))

输出：5

秘籍：列表对象提供了insert()方法向列表的指定位置插入元素。

代码：

phone = [“摩托罗拉”,“诺基亚”,”三星”，“OPPO”] #定义列表

phone.insert(0,”没有手机”)

print(phone)

输出：[“没有手机”，“摩托罗拉”,“诺基亚”,”三星”，“OPPO”]

可以使用extend()方法，将一个表的数据全部添加到另一个表中，listname.extend(seq)。

代码：

oldlist = [“贾巴尔”,”乔丹”,”奥拉朱旺”,”巴克利”，“姚明”] #NBA名人堂原有人员列表

newlist = [“基德”,”纳什”,”希尔”,”拿破仑”] #新增加人员

oldlist.extend(newlist) #追加新球星

print(oldlist)

输出：[“贾巴尔”,”乔丹”,”奥拉朱旺”,”巴克利”，“姚明”,“基德”,”纳什”,”希尔”,”拿破仑”]

总结：

append()方法是追加元素，而extend()方法是添加列表。

（2）修改元素

代码：

list1 = [“长亭外”,”古道边”,”芳草碧连天”]

list1[2] = “一行白鹭上青天” #修改元素

print(list)

输出: [“长亭外”,”古道边”,“一行白鹭上青天”]

（3）删除元素有两种方法可以进行删除，一种是：根据索引进行删除，还有一种是根据元素值进行删除。

代码：

list1 = [“长亭外”，“古道边”,”芳草碧连天”]

list1[2] = “一行白鹭上青天” #修改元素

print(list1)

del list1[2]

print(“删除后:”，list)

输出：[“长亭外”，“古道边”]

根据元素值进行删除。

代码：

list1 = [“长亭外”，“古道边”,”芳草碧连天”]

list1.remove(“芳草碧连天”)

print(“删除后:”，list1)

输出：[“长亭外”，“古道边”]

注意：如果删除的元素不存在，则会返回错误信息,此时可加入语句进行判断：

list1 = [“长亭外”，“古道边”,”芳草碧连天”]

if “芳草碧连天” in list1:

list1.remove(“芳草碧连天”)

print(“删除后:”，list1)

输出：[“长亭外”，“古道边”]

1）对列表进行统计计算

Python有三个函数来进行列表统计，分别是：count()、index()、sum()。

count()函数格式：listname.count(obj)

代码：

song = [“云在飞”,”后来”，“送你一匹马”，“马在叫”，“云在飞”]

number = song.count(“云在飞”)

print(number)

输出：2

index()函数格式:listname.index(obj)

代码:

song = [“云在飞”,”后来”，“送你一匹马”，“马在叫”，“云在飞”]

position = song.index(“云在飞”)

print(position)

输出:0

如果查找的不存在，将显示错误。为了防止查找的不存在，可以提前进行预防：

代码：

song = [“云在飞”,”后来”，“送你一匹马”，“马在叫”，“云在飞”]

if “送你一匹” in song:

position  = song.index(“送你一匹”)

print(position)

输出:无结果

sum()方法格式：sum(iterable[,start])

代码：

grade = [12,23,43,100,89,21,32,12]

total = sum(grade)

total2 = sum(grade，1000)

print(total)

print(total2)

输出：

332

1332

2）对列表进行排序

排序分为两种：降序和升序。分为两种方法：sort()方法、

使用sort()方法实现排序后，原列表中的元素顺序将会被改变。

语法是：listname.sort(key = None,rever = False) 其中key为是否区分字母大小写，rever用来指定是升序还是降序来进行排列。

代码:

grade = [81,12,12,23,42,12,32,100,12] #保存成绩的列表

print(“原列表:”，grade)

grade.sort() #进行升序排列

print(“升序:”,grade)

输出：

原列表：[81,12,12,23,42,12,32,100,12]

升序：[12,12,12,12,23,32,42,81,100]

代码：

char = [“cat”,”Tome”,”Angle”,”pet”]

print(“原列表:”,char)

char.sort() #进行序列排序

print(“升序:”,char) #先排序大写，再排序小写

输出：原列表：['cat', 'Tome', 'Angle', 'pet']

升序：['Angle', 'Tome', 'cat', 'pet']

代码：

char = [“cat”,”Tome”,”Angle”,”pet”]

print(“原列表:”,char)

char.sort(key = str.lower)   #不区分大小写进行升序排列

print(“升序:”,char) #先排序大写，再排序小写

输出：原列表：['cat', 'Tome', 'Angle', 'pet']

升序：['Angle', 'cat', 'pet', 'Tome']

使用内置的sorted()函数实现排序后原列表的元素顺序不变。

sorted(iterable,key = None,reverse = False),其中 key设置排序的大小，reverse设置按升序排列还是按降序排列。

代码：

char = [“cat”,”Tome”,”Angle”,”pet”]

print(“原列表:”,char)

char1 = sorted(char) #进行升序排列

print(“升序:”,char1) #先排序大写，再排序小写

char2 = sorted(char,reverse = True) #进行降序排列

print(“降序:”,char2)

print(“原列表：”，cahr)

输出：

原列表：[‘cat’,’Tome’,’Angle’,’pet’]

升序:[‘Angle’,’Tome’,’cat’,’pet’]

降序：[‘pet’,’cat’,’Tome’,’Angle’]

原列表：[‘cat’,’Tome’,’Angle’,’pet’]

总结：可使用列表对的sort()方法来实现，内置的sorted()函数来实现，这两个方法的基本作用基本相同，所不同的是使用sort()方法会改变原列表的顺序，而使用sorted（）函数方法将不会改变原列表的顺序。

7）列表推导式

在Python中，列表推导式是指，可以快速生成一个列表，或者根据某个列表生成满足指定需求的列表。

格式：list = [Expression for var in range]

代码：

import random #导入生成随机数的模块

list1 = []  #定义一个空列表

for i in range(10)：

list1.appened(random.randint(10,100)) #向列表当中添加随机数

print(list1)

输出:[12,12,43,23,12,32,12,32,98,12]

代码(列表推导式)：

import random    #导入生成随机数的模块

list1 = [random.randint(10,100) for i in range(10)]     #定义一个空列表

print(list1)

输出:[12,12,43,23,12,32,12,32,98,12]

代码：

list1 = [i * i for i in range(2,11,2)]

print(list1)

输出：[4,16,36,64,100]

根据列表生成指定需求的格式

newlist = [Expression for var in list]

代码：

price = [1000,500,800,888,666]

sale = [int(x * 0.5) for x in price]

print(“原价格:”,price)

print（“打折后的：”,sale）

输出：

原价格:[1000,500,800,888,666]

打折后的:[500,250,400,444,333]

格式：newlist = [Expression for var in list if condition]

代码：

price = [1000,500,800,888,666]

sale = [x for x in price if x > 800]

print(“原价格:”,price)

print（“大于800元的：”,sale）

输出:

原价格:[1000,500,800,888,666]

大于800元的：[1000,888]

8)二维列表

二维列表以行和列组合而成，格式：room[行下标][列下标]。

代码：

room = [[1101,1102,1103,1104,1105,1106,1107],

[2101,2102,2103,2104,2105,2106,2107],

[3101,3102,3103,3104,3105,3106,3107],

[4101,4102,4103,4104,4105,4106,4107]]

print(room)

代码（for循环生成）:

room = []

for i in range(1,5): #楼层

room.append([]) #添加一个空列表

for j in range(1,8): #每一层的房间数

room[i-1].append(i * 1000 + 100 + j) #为每一层的列表添加元素

print(room)

输出：[[1101,1102,1103,1104,1105,1106,1107],[2101,2102,2103,2104,2105,2106,2107],

[3101,3102,3103,3104,3105,3106,3107],[4101,4102,4103,4104,4105,4106,4107]]

代码（列表推导式）:

room = [[i * 1000 + 100 + j for j in range(1,8)] for i in range(1,5)]

print(room)

输出：

[[1101,1102,1103,1104,1105,1106,1107],[2101,2102,2103,2104,2105,2106,2107],

[3101,3102,3103,3104,3105,3106,3107],[4101,4102,4103,4104,4105,4106,4107]]

一、元组

元组和列表相似，也可以放置各种类型的值，但是元组是不可以改变的。

元组格式：（元素1，元素2,.....,元素n）

1) 元组的创建和删除

符合运算符直接创建元组，格式：tuplename = (元素1，元素2，元素3，....，元素n)

代码：

number = (7,14,21,28,35,42)

print(number)

data = （“爱我中华”，“渔舟唱晚”，“爱在北京”）

print(data)

untile = (“python”,28,(“人生苦短”,”我用Python”),[“爬虫”，“云计算”，“游戏”])

print(untile)

verse = (“一片冰心在玉壶”) #此处verse不是元组，而是一组字符串

verse1 = （“一片冰心在玉壶”，) #此处多加了一个， 可以做单个元组

print(verse)

print(verse1)

输出：(7,14,21,28,35,42)

（“爱我中华”，“渔舟唱晚”，“爱在北京”）

(“python”,28,(“人生苦短”,”我用Python”),[“爬虫”，“云计算”，“游戏”])

一片冰心在玉壶

（“一片冰心在玉壶”，)

代码：

coffeename = (‘蓝山’，‘卡布奇诺’，“曼特宁”，“摩卡”，“麝香猫”，“哥伦

比亚”)

print（coffeename）

输出：(‘蓝山’，‘卡布奇诺’，“曼特宁”，“摩卡”，“麝香猫”，“哥伦

比亚”)

代码（创建空的元组）：

emptytuple = ()

print(emptytuple)

输出:()

创建数值元组：

代码：

tuple1 = tuple(range（2，21，2）)

print(tuple1)

输出：(2,4,6,8,10,12,14,16,18,20)

删除元组，格式：del tuplename

代码：

tuple = tuple（range（2，21，2））

print(tuple)

del tuple1

print(tuple1)

输出：错误提示，因为已没有元组已被删除

1) 访问元组元素

访问元组元素可以直接使用print()函数输出，也可以使用索引输出，或者使用切片输出。

代码：

untile = (“Python”,28,(“人生苦短”，“我用Python”)，[“爬虫”,”云计算”,”

游戏”])

print(untile)

print(untile[2])

print(untile[1:3]) #在结束的时候，不包括结束的索引的

输出：

(“Python”,28,(“人生苦短”，“我用Python”)，[“爬虫”,”云计算”,”游戏”])

(“人生苦短”，“我用Python”)

代码：

coffeename = (“蓝山”,”卡布奇诺”,”曼特宁”,”摩卡”,”麝香猫”,”哥伦比

亚”) #定义一个元组print(“你好，欢迎光临~薏米咖啡馆\n我店有：”)

for name in coffeename:

print(name + “咖啡” , end = “”)

输出：

你好，欢迎光临~薏米咖啡馆

我店有：

蓝山咖啡 卡布奇诺咖啡 曼特宁咖啡 摩卡咖啡 麝香猫咖啡 哥伦比亚咖啡

代码：

print(“2017~2018赛季NBA西部联盟前八名的球队：”)

team = (“火箭”,”勇士”,”雷霆”,”马刺”，“森林狼”，“爵士”，“开拓者”，

“陈涛”) #定义一个

for index,item in enumbertate(team):

if index % 2 == 0:

print(item + “\t\t” , end = ‘’) #不换行

else:

print(item) #换行

输出：

2017~2018赛季NBA西部联盟前八名的球队：

火箭 勇士

雷霆 马刺

森林狼 爵士

开拓者 陈涛

2) 修改元组

代码：

coffeename = (“1”,”2”,”3”,”4”,”5”,”6”)

coffeename[4] = ”五”

print(coffeename)

输出：显示错误

代码：

coffeename = (“1”,”2”,”3”,”4”,”5”,”6”)

coffeename = (“1”,”2”,”3”,”4”,”五”,”6”)

newcoffeename = (”5”,”维也纳”）

allcoffeename = coffeename + newcoffeename

print(coffeename)

print(allcoffeename)

输出：

(“1”,”2”,”3”,”4”,”五”,”6”)

(“1”,”2”,”3”,”4”,”五”,”6”,”5”,”维也纳”)

3) 元组推导式

元组推导式和列表推导式是相似的，元组推导式可以快速生成一个元组，或者根据某个元组生成满足指定需求的元组。

代码：

import random #导入随机数模块

randomnumber = (random.randint(10,100) for i in range(10))

print(randomnumber) #此处和列表不同，此处只生成一个生成器对象，而不是像列表一样直接生成列表

print(tuple(randomnumber))

输出：

(62, 79, 57, 45, 27, 51, 74, 73, 17, 18)

代码：

import random #导入随机模块

randomnumber = (random.randint(10,100) for i in range(10))

for i in randomnumber: #如果要将元组生成器里面的元素取出，可以采取这种方法

print(i,end = ‘’) #输出每个元素的值

代码：

randomnumber = (random.randint(10,100) for i in range(10))

print(randomnumber.__next__()) #输出的是第一个元素

print(randomnumber.__next__())  #输出的是第二个元素

print(randomnumber.__next__())  #输出的是第三个元素

注意：元组生成器被使用过就会被销毁。

4) 元组与列表的区别

元组   列表

不可变序列：   可变序列：

（不能添加、修改和删除元素，可整体替换）   （随时添加、修改或者删除）

支持切片的操作                                  支持切片的操作

（只能访问元组中的元素）         （可以访问、修改元组中的元素）

元组访问速度快   列表访问速度慢

元组可以作为字典的键   不能作为字典的键

一、字典

新华字典的使用方法是先找到索引，然后再找到具体的字。那么在Python中，也是同样的意思，Python中的字典是采用键值对来进行组合的，其中键有只有一个而值可以有多个。

1）字典的创建和删除

怎么创建这个字典？

dictionary = {‘key1’:’value1’,’key2’:’value2’,....,’keyn’:’valuen’}

代码：word = {‘che’:’车’，’chen’:’陈’，’cheng’:’称’} #定义一个字典print(word)

输出：{‘che’:’车’，’chen’:’陈’，’cheng’:’称’}

代码：

key = [‘che’,’chen’,’cheng’,’chi’]

value = [‘车’,’陈’,’称’，‘吃’]

zip1 = zip(key,value) #转化为zip对象

print(zip1)

word = dict(zip1) #转化为字典

print(word)

输出：

{'che': '车', 'chen': '陈', 'cheng': '称', 'chi': '吃'}

代码：

name = [“绮梦”,”冷伊一”,”香凝”,”黛兰”]

sign = [“水瓶座”，“射手座”，“双鱼座”，“双子座”]

dictionary = dict(zip(name,sign))

print(dictionary)

输出：创建名称和星座对应的字典注意：如果把name换成元组也是可以创建字典的

创建空字典：

代码：

word = ｛｝

print(word)

代码：

word = dict()

print(word)

代码：

dictionary = dict(绮梦 = ‘水瓶座’，陈涛 = ‘金牛座’，夏心语 = ‘牛座’)

print(dictionary)

输出：

｛‘绮梦’：“水瓶座”,”陈涛”：“金牛座”，“夏心语”：“牛座”｝

代码：

name = [“绮梦”,”冷伊一”,”香凝”,”黛兰”]

dictionary = dict.fromkeys(name)

print(dictionary)

del dictionary #把字典进行删除

dictionary.clear() #把字典进行清空

2）访问字典

代码，通过指定的键访问：

name = [“绮梦”,”冷伊一”,”香凝”,”黛兰”]

sign = [“水瓶座”，“射手座”，“双鱼座”，“双子座”]

dictionary = dict(zip(name,sign)) #转换为字典

print(dictionary[“冷伊一”])

输出：射手座

代码，如果用不存在的键进行访问:

name = [“绮梦”,”冷伊一”,”香凝”,”黛兰”]

sign = [“水瓶座”，“射手座”，“双鱼座”，“双子座”]

dictionary = dict(zip(name,sign)) #转换为字典

print(dictionary[“冷伊”]) #键值不存在

输出：错误提示

代码，对不存在的情况进行判断：

name = [“绮梦”,”冷伊一”,”香凝”,”黛兰”]

sign = [“水瓶座”，“射手座”，“双鱼座”，“双子座”]

dictionary = dict(zip(name,sign)) #转换为字典

print(dictionary[“冷伊”] if “冷伊” in  dictionary  else “我的字典里没有此人”)

输出：我的字典里没有此人

代码：

name = [“绮梦”,”冷伊一”,”香凝”,”黛兰”]

sign = [“水瓶座”，“射手座”，“双鱼座”，“双子座”]

dictionary = dict(zip(name,sign)) #转换为字典

print(dictionary.get(“冷伊一”))

输出：射手座

代码，不进行键值是否存在的情况，进行判断：

name = [“绮梦”,”冷伊一”,”香凝”,”黛兰”]

sign = [“水瓶座”，“射手座”，“双鱼座”，“双子座”]

dictionary = dict(zip(name,sign)) #转换为字典

print(dictionary.get(“冷伊”))

输出：None

代码：

name = ["1","2"]sign = ["3",'4']dictionary = dict(zip(name,sign))name1 = ["3","4"]sign1 = ["7","8"]dictionary1 = dict(zip(name1,sign1))out = dictionary1.get(dictionary.get("1"))print(out)

输出：7

3）遍历字典

代码：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}print(sign.items())

输出:dict_items([('绮梦', '水瓶座'), ('冷伊一', '射手座'), ('香凝', '双鱼座'), ('黛兰', '双子座')])

代码：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}for item in sign.items():    print(item)

输出：

('绮梦', '水瓶座')

('冷伊一', '射手座')

('香凝', '双鱼座')

('黛兰', '双子座')

代码：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}for key,value in sign.items():    print(key,"的星座是",value)

输出：

绮梦 的星座是 水瓶座

冷伊一 的星座是 射手座

香凝 的星座是 双鱼座

黛兰 的星座是 双子座

代码，获取字典当中的所有键：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}for key in sign.keys():    print(key)

输出：

绮梦

冷伊一

香凝

黛兰

代码，获取字典当中的所有值：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}for value in sign.values():    print(value)

输出：

水瓶座

射手座

双鱼座

双子座

4）添加、修改和删除字典元素

dictionary[key] = value

在字典中添加键和值，代码：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}sign["陈涛"] = "金牛座"print(sign)

输出：

{'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座', '陈涛': '金牛座'}

在字典中修改键和值，代码：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}sign["陈涛"] = "金牛座"sign["陈涛"] = "牛座"print(sign)

输出：

{'绮梦': '水瓶座', '冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座', '陈涛': '牛座'}

删除一个元素，代码：

sign = {"绮梦":"水瓶座","冷伊一":"射手座","香凝":"双鱼座","黛兰":"双子座"}sign["陈涛"] = "金牛座"sign["陈涛"] = "牛座"del sign["绮梦"]   #删除元素print(sign)

输出：

{'冷伊一': '射手座', '香凝': '双鱼座', '黛兰': '双子座', '陈涛': '牛座'}

5）字典推导式

字典推导式类似于列表推导式，只不过是将列表的[]改变为字典的{}。

代码：

import randomrandomdict = {i:random.randint(10,100) for i in range(1,5)}print(randomdict)

输出：

{1: 11, 2: 42, 3: 70, 4: 41}

字典推导式，实现输出的代码：

name = ["陈涛","夏文娱"]sign = ["金牛座","双子座"]dict1 = { i:j  for i,j in zip(name,sign)}   #字典推导式print(dict1)

输出：

{'陈涛': '金牛座', '夏文娱': '双子座'}

二、集合（set）

在Python中有两种集合，一种是可变集合set，一种是不可变集合frzenset。

在数学中，把一些能够确定的不同对象看成一个整体，那么这个整体是由这些对象构成的集合。

在Python中，也和数学中的集合类似，用于保存不重复元素，最好的应用就是去重。

在定义字典的时候，我们使用的是{}，那么在定义集合的时候我们还是使用{}，那我们应该怎么区分呢？

代码：

set1 = {"水瓶座","射手座","双鱼座","双子座"}    #定义一个集合print(set1)set2 = {"水瓶座","射手座","双鱼座","双子座","水瓶座"}  #出现两个水瓶座，只保留一个print(set2)

输出：

{'射手座', '水瓶座', '双子座', '双鱼座'}

{'射手座', '水瓶座', '双子座', '双鱼座'}

1、集合是无序的

2、集合是不重复的

代码：

set1 = {"水瓶座","射手座","双鱼座","双子座"}    #定义一个集合print(set1)set2 = {"水瓶座","射手座","双鱼座","双子座","水瓶座"}print(set2[1]｝)

输出：

File "C:/Users/Administrator/PycharmProjects/Python/第一章/1.py", line 4

print(set2[1]｝)

^

SyntaxError: invalid character in identifier

//集合中，不能通过索引来获取某一个元素

1) 创建集合

代码：

python = {"绮梦","冷伊一","香凝","紫萱"}  #选择Python同学的集合c = {"冷伊一","零语","三圣母"}  #选择C语言同学的集合print("选择Python学生名字集合:",python)print("选择C学生名字集合:",c)

输出：

选择Python学生名字集合: {'绮梦', '香凝', '紫萱', '冷伊一'}

选择C学生名字集合: {'冷伊一', '三圣母', '零语'}

集合和字典的区别，集合的格式：{元素1，元素2，元素3,....，元素n}，字典的格式：{‘键1’：‘值1’，‘键2’：‘值2’，......,’键n’：‘值n’}

因为在定义空字典的时候，我们使用的是{}实现的，哪么在创建空集合的时候便不能再以{}来实现，于是我们采取：set()表示空集合。

创建空集合，代码：

set1 = set()print(set1)

输出：

set()

将其他序列转化为集合，代码：

name = ["绮文","冷伊一","香凝"]print("列表：",name)set1 = set(name) #转化为集合print("集合:",set1

输出：

列表： ['绮文', '冷伊一', '香凝']

集合: {'绮文', '香凝', '冷伊一'}

如果列表存在重复的元素，那么转化为集合会怎样？代码：

name = ["绮文","冷伊一","香凝","绮文"]print("列表：",name)set1 = set(name) #转化为集合print("集合:",set1)

输出：

列表： ['绮文', '冷伊一', '香凝', '绮文']

集合: {'绮文', '香凝', '冷伊一'}

2) 集合的添加和删除

向集合当中添加元素可使用add()来实现，格式如下：setname.add(element),其中element不能是列表、元组等可迭代的对象。

使用add向集合中添加元素：

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合mr.add("零基础学Python")print(mr)

输出：

{'零基础学PHP', '零基础学Python', '零基础学安卓', '零基础学C', '零基础学Java'}

//集合不能添加 重复的元素，就算多次添加，也只不能重复

使用remove()删除指定元素，使用pop()随机删除一个元素,使用clear()删除全部元素。

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合mr.add("零基础学Python")print(mr)mr.remove("零基础学Java")   #删除一个指定的元素print(mr)

输出:{'零基础学C', '零基础学Python', '零基础学安卓', '零基础学PHP', '零基础学Java'}

{'零基础学C', '零基础学Python', '零基础学安卓', '零基础学PHP'}

如果想删除的元素不存在，则会报错：

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合mr.add("零基础学Python")mr.remove("1")   #删除一个指定的元素print(mr)

输出：

Traceback (most recent call last):

File "C:/Users/Administrator/PycharmProjects/Python/第一章/1.py", line 3, in

mr.remove("1")   #删除一个指定的元素

KeyError: '1'

判断是否想删除的元素是否存在在当前集合中，代码：

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合mr.add("零基础学Python")if "1" in mr:    mr.remove("1")   #删除一个指定的元素print(mr)

输出：

{'零基础学Python', '零基础学C', '零基础学Java', '零基础学安卓', '零基础学PHP'}

如何通过pop()方法来移除一个元素：

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合mr.pop() #随机移除一个元素print(mr)

输出：

{'零基础学C', '零基础学安卓', '零基础学PHP'}

//pop()元素为随机删除集合的方法

使用clear()方法清空集合：

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合mr.clear()print(mr)

输出：

set()

使用del删除整个集合：

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合del clear()print(mr)

输出：

File "C:/Users/Administrator/PycharmProjects/Python/第一章/1.py", line 2

del clear()

添加集合、删除集合：

mr = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合ms = set(['冷伊一','零语','新词','圣博'])mr.add("零语")    #添加一个元素ms.remove("零语")  #移除一个元素print(mr)print(ms)

输出：

{'零基础学C', '零基础学PHP', '零语', '零基础学安卓', '零基础学Java'}

{'新词', '圣博', '冷伊一'}

1) 集合的交集、并集和差集运算

交集：& 并集：| 差集：- 对称差集：^

代码：

python = set(["零基础学Java","零基础学安卓","零基础学C","零基础学PHP"])   #定义一个集合c = set(['冷伊一','零语','新词','圣博'])print("选择Python语言的学生名字：",python)print("选择C语言的学生名字:",c)print("交集运算：",python & c)print("并集运算：",python | c)print("差集运算：",python - c)print("对称差集：",python^c)

输出：

选择Python语言的学生名字： {'零基础学PHP', '零基础学安卓', '零基础学Java', '零基础学C'}

选择C语言的学生名字: {'零语', '圣博', '冷伊一', '新词'}

交集运算： set()

并集运算： {'冷伊一', '零基础学C', '圣博', '零基础学Java', '新词', '零语', '零基础学安卓', '零基础学PHP'}

差集运算： {'零基础学PHP', '零基础学Java', '零基础学安卓', '零基础学C'}

对称差集： {'冷伊一', '零基础学C', '圣博', '零基础学Java', '新词', '零语', '零基础学安卓', '零基础学PHP'}

总结----列表、元组、字典和集合的区别：

list tuple dictionary set

[] () {key:value} {}

可变：list、dictionary、set；    不可变：tuple；

可重复：list、tuple、dictionary；   不可重复：set；

有序：list、tuple； 无序:dictionary、set;