第一节 集合类型(两判断+246)
判断集合与集合之间关系与判断元素与集合之间关系,两个操作函数,四个操作符,六个操作方法(其中一个增加集合元素方法,一个复制集合元素方法和四个集合元素删除方法)
1 集合的定义
集合是多个元素的无序组合
1.集合用大括号{}表示,元素之间用逗号分隔
2.建立集合类型用{} / set()
3.若建立空集合类型,必须使用set()1
- 集合类型与数学中的集合概念一致
- 集合元素之间无序,每个元素唯一,不存在相同元素
- 要求放入集合中的元素均为不可变数据类型,也就是说集合中的元素一旦被放到集合中,这个元素是不能被修改的
**注:**非可变数据类型:整数,浮点数,复数,字符串类型,元组类型等
a={''python'',123,(''python'',123)} #使用{}建立集合
print(a)
b=set("pypy123") #使用set()建立集合
print(b)
c={'python',123,'python',123} #证明集合中不存在相同元素
print(c)
输出:
{('python', 123), 123, 'python'}
{'p', 'y', '1', '3', '2'}
{123, 'python'}
2 集合的操作符(4+一个判断)
数学语言 | 操作符 | 描述 |
---|---|---|
并 | S|T | 返回一个新集合,包括在集合S和T中的所有元素 |
差 | S-T | 返回一个新集合,包括在集合S中但不在T中的元素 |
交 | S&T | 返回一个新集合,包括同时在在集合S和T中的元素 |
补 | S^T | 返回一个新集合,包括在集合S和T中的非相同元素 |
子集 | S<= / <T | 返回True则表示,S为T的子集,返回False,则不是 |
子集 | S>= / >T | 返回True则表示,T为S的子集,返回False,则不是 |
增强操作符(4)
通过四种操作符与赋值符号的组合来实现对集合S的更新
增强操作符 | 要表达的意思 |
---|---|
S|=T | S=S|T |
S-=T | S=S-T |
S&=T | S=S&T |
S^=T | S=S^T |
a={'p','y',123}
b=set("py123")
a-b
b-a
a&b
a^b
a|b
输出:
{123}
{'2', '1', '3'}
{'p', 'y'}
{'1', '3', '2', 123}
{'p', 'y', '1', '3', '2', 123}
3 集合处理方法及函数 (一个判断+26)
操作方法 | 描述 |
---|---|
S.add(x) | 如果x不在集合S中,则将X增加到S(增加元素),且X位置随机 |
S.discard(x) | 删除集合S中的元素x,如果x不在集合S中,不会报错(删除元素) |
S.remove(x) | 删除集合S中的元素x,如果x不在集合S中,则产生KeyError异常(删除元素) |
S.clear() | 删除集合S中的所有元素(删除元素) |
S.pop() | 随机取出2S的一个元素,若S为空,则产生KeyError异常(删除元素),括号中不能加东西 |
S.copy() | 返回集合S的一个副本(复制元素) |
a={'p','y',123,'1','2','3'}
a.add('123')
print(a)
a.discard('1')
print(a)
a.remove(1) #因为集合a中没有元素1,这里会直接报错,出现KeyError异常
a.pop() #首先会随机打印出一个集合a中的元素,然后打印集合a时发现集合中前面打印的元素已被删除#
print(a)
a.clear() #此时集合a中元素全被删除,接下来打印的集合a为空集合
print(a)
输出:
{'2', '123', '1', 'p', '3', 'y', 123}
{'2', '123', 'p', '3', 'y', 123}
#下面四行是.remove()引起的异常
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
a.remove(1)
KeyError: 1
'2' #随机返回的元素
{'123', 'p', '3', 'y', 123}
set() #空集合
操作函数 | 描述 |
---|---|
len(S) | 返回集合S的元素个数 |
set(x) | 将其他类型变量x转变为集合类型 |
判断元素与集合关系的操作符 | 描述 |
---|---|
X in S | 判断S中元素x,x在集合中,返回True,否则返回False |
X not in S | 判断S中元素x,x不在集合中,返回True,否则返回False |
4 集合类型应用场景
4.1 包含关系的比较
集合与集合包含关系的比较与集合与元素包含关系的比较
'p' in {'p','y',123}
输出:
True
{'p','y'}>={'p','y',123}
输出:
False
4.2 数据去重
利用集合数据类型中所有元素不能重复的特点,对一组数据中的重复元素进行删除,留下不重复/不相同的元素
ls=['p','y','p','y',123]
s=set(ls) #利用集合元素不能重复的特点,进行数据去重
print(s)
lt=list(s) #将集合转换成列表
print(lt)
输出:
{123, 'p', 'y'}
[123, 'p', 'y']
第二三节 序列类型(基本6+6 列表的1234 元组的不变)
序列基本的六个操作符和六个操作函数(方法)
访问与修改列表元素的一种操作,两个增加列表元素的方法,三个改变列表元素排序的方法(函数),四个删除列表元素的方法(函数)
定义:具有先后关系的一组元素(说明元素之间是有序的)
-
序列是一维元素向量,元素类型可以不同
-
由于元素之间存在先后关系,所以元素之间可以相同
-
类似于数学元素序列:S0 , S1 , … , SN-1
-
元素之间有序号引导,通过下标访问序列的特定元素
-
在序列类型中,元素存在正向递增序号的索引关系和反向递减序号的索引关系
我们一般使用的时候,不会直接使用序列类型,而是使用序列类型衍生出的几种数据类型:
- 字符串类型
- 列表类型
- 元组类型
注:序列类型的所有操作在衍生出的几种类型中都是适用的,同时各种衍生类型又有各自独特的操作能力
序列通用函数及方法(6+6)
此处用列表来表示序列,所以此处序列用[]表示
操作符(6)
操作符 | 描述 |
---|---|
x in s | 判断 |
x not in s | 判断 |
s+t | 连接两个序列s和t |
s * n / n * s | 将序列s复制n次 |
s[i] | 索引,与字符串索引相同 |
s[i:j:k] | 切片,与字符串切片相同 |
ls=['python',123,'.io']
ls=[::-1]
['.io',123,'python']
注:,当要返回序列s中的第几个元素时,此时索引的序号为:元素位置-1
函数和方法(6)
函数和方法 | 描述 |
---|---|
len(s) | 返回序列s的长度 |
min(s) /max (s) | 返回序列s的最小 / 最大 元素,当序列中元素可比较时 |
s.index(x) / s.index(x,i,j) | 返回序列s从索引i开始,到索引j中第一次出现元素x的索引序号 |
s.count(x) | 返回序列s中出现元素x的总次数 |
s=[2,3,466,78,-5.35,2,45,2,9,72,2]
len(s)
11
min(s)
-5.35
s.index(2,2,9)
5 #返回为在索引2和9之间第一次出现元素2的索引序号
s.count(2)
4
字符串,列表和元组类型的比较
数据类型 | 字符串 | 列表 | 元组 |
---|---|---|---|
索引结果 | 字符串类型 | 元素本身类型 | 元素本身类型 |
切片结果 | 字符串类型 | 列表类型 | 元组类型 |
元素类型(针对组合数据类型) | 字符 | 任何数据类型 | 任何数据类型 |
元素是否能被改变 | 不能 | 能 | 不能 |
转换函数 | str()) | list() | tuple() |
2.1 列表类型(1+2+3+4)
- 列表是一种序列类型,十分常用
- 使用[] / list()创建,元素之间用逗号分隔
- 列表会随着每次运算发生改变,与元组不同
- 只有切片/ list()/.copy()方法才是真正创建了一个列表,赋值仅表示传递引用
- list()函数是列表的转换函数,可将其他类型数据转换为列表,如字符串。
ls=[2,3,467,466,44,1]
print(ls)
[2,3,467,466,44,1]
lt=ls #此处并未创建一个新列表,只是将列表ls的值赋给了变量lt
print(lt)
[2,3,467,466,44,1]
ls.clear()
print(lt)
[] #因为lt=ls只是代表将列表ls引用给了变量lt,即变量ls与lt表示的是同一个列表,既然通过ls将这个列表给清空了,那lt打印出来 的自然就是空列表。
#使用copy方法/切片(即<列表变量>[:])是真正的创建了一个新的列表,不会出现上面这种情况
s="python" #将字符串类型转换为列表类型
ls=list(s)
print(ls)
['p','y','t','h','o','n']
2.1.1 访问列表元素
方法与字符串中索引相同
格式:list[i]
注:访问列表元素时,要注意列表元素顺序与索引的关系,索引=列表元素顺序-1
例如,访问列表的第三个元素就是访问索引(位置)为2处的元素,应使用list[2]
2.1.2 修改及复制列表元素(2种操作)
操作 | 描述 |
---|---|
ls.copy() | 产生列表ls的一个副本,即产生了一个新列表,但元素和原列表相同,这与列表赋值不同 |
ls[i]=x | 用x(任意数据类型)替换列表ls索引为i的元素 |
ls[i:j:k]=x | 用x(任意数据类型)替换ls切片后所对应的元素子列表 |
ls=['one','two','three',3,2,1]
ls[3]='three'
print(ls)
['one','two','three','three',2,1]
ls[2:4]=[1,2,3,4,5,6]
print(ls)
['one','two',1,2,3,4,5,6,2,1]
**注:**通过上述程序可知,列表是动态的,随着程序的运行,列表会发生相应的改变。
2.1.3 添加列表元素(2个方法)
函数/方法 | 描述 |
---|---|
ls.append(x) | 在列表最后增加一个元素x |
ls.insert(i,x) | 在列表索引为i处增加元素x,即在索引i处插入x,原来索引i处元素向后退一位。 |
1.在列表末尾添加元素
利用.append()方法在列表末尾添加元素
ls=[1,2]
ls.append('end')
print(ls)
[1, 2, 'end']
ls.append(4)
print(ls)
[1, 2, 'end', 4]
2.在列表中插入元素
利用.insert()方法在列表中插入元素
ls=['cat','dog','tiger',1024]
ls.insert(3,'human')
print(ls)
['cat', 'dog', 'tiger', 'human', 1024]
2.1.4 删除列表元素(3个方法和1个操作符)
操作符及方法 | 描述 |
---|---|
del ls[i] | 删除列表ls中索引为i的元素 |
del ls[i:j:k] | 删除列表ls中切片的元素 |
ls.pop(i) | 将列表ls中索引为i的元素从列表ls中取出,返回为被取出的元素,i默认为-1 |
ls.remove(x) | 删除列表ls中第一次出现的元素x |
ls.clear() | 删除列表ls中所有元素 |
注:
- 将元素删除后,不使用已删除元素:del语句
- 将元素删除后,需要使用已删除元素:.pop(),.remove(),需要先给被删除的元素赋值,再使用被删除元素,这两种方法的赋值还有点不一样,具体看下方代码
ls=[1,2,3,4,5]
poped_ls=ls.pop() #ls.pop()就是被删除的元素,现在把被删除的元素赋值给poped_ls
print(ls)
print(poped_ls)
[1, 2, 3, 4]
5
shan=4 #我们先给要删除的元素赋值,此时的4是元素值,不是索引,需要注意
ls.remove(shan) #删除赋值后的变量
print(ls)
[1, 2, 3]
适用情况 | 方法 |
---|---|
知道删除元素的值时 | .remove() |
知道删除元素的索引 | del语句,.pop() |
1.使用del语句删除列表元素
ls=[2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2]
del ls[2]
print(ls)
[2, 3, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]
del ls[2:12:3]
print(ls)
[2, 3, 6, 7, 9, 10, 8, 7, 5, 4, 3, 2]
2.使用.pop()方法取出列表元素
ls=[1,2,3,4,5]
ls.pop()
5
print(ls)
[1, 2, 3, 4]
ls.pop(3)
4
print(ls)
[1, 2, 3]
3.使用.remove()方法删除列表元素
ls=['one','two','three','four','five']
lll='four'
ls.remove(lll)
print(ls)
['one', 'two', 'three', 'five']
4.使用.clear()方法删除列表中所有元素
ls=[1,2,3,4,5]
ls.clear()
print(ls)
[]
2.1.5 列表元素排序(两个方法和一个函数)
方法 | 描述 |
---|---|
ls.sort() | 使列表元素按首字母顺序排序显示列表**(永久)** |
sorted(ls) | 使列表元素按首字母顺序排序显示列表**(临时)** |
ls.reverse() | 使列表元素倒序 |
注:.sort()方法与sorted()函数中可加参数reverse=True,表示按元素首字母顺序逆序显示列表
1.使用.sort()方法对列表元素进行永久排序
ls=['cba','nbc','abc','dbc']
ls.sort()
print(ls)
['abc', 'cba', 'dbc', 'nbc'] #证明了.sort()方法的永久性
ls.sort(reverse=True) #使用参数reverse=True使列表ls按元素首字母顺序逆序
print(ls)
['nbc', 'dbc', 'cba', 'abc']
2.使用sorted()函数对列表元素进行临时排序
ls=['cba','nbc','abc','dbc']
print(sorted(ls))
['abc', 'cba', 'dbc', 'nbc']
print(ls)
['cba', 'nbc', 'abc', 'dbc'] #证明sorted()函数的排序是临时的
3.使用.reverse()方法对列表元素进行逆序
ls=['cba','nbc','abc','dbc']
ls.reverse()
print(ls) #证明.reverse()方法的永久性
['dbc', 'abc', 'nbc', 'cba']
ls.reverse()
print(ls)
['cba', 'nbc', 'abc', 'dbc'] #证明了.reverse()方法永久性的可逆性
**注:**虽然.reverse()方法也是永久性的,但是我们可以再次使用.reverse()方法让列表元素变会原序列
2.2 元组类型
2.2.1 对于元组的介绍
元组是序列类型的一种扩展,就是将元素进行有序的排列,用()来组织。
元组是一种序列类型,一旦创建就不能被修改
使用() / tuple()创建,元素之间用逗号分隔
创建的元组中只有一个元素时,需要在最后加一个逗号
在使用的时候,元组可以有圆括号,也可以不用圆括号
比如:
creature='cat','dog','tiger','human' #建立元组时未使用圆括号
print(creature)
('cat', 'dog', 'tiger', 'human')
color=(0x001100,'blue',creature) #用圆括号建立元组
print(color)
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))
2.2.2 元组类型的操作
元组继承序列类型的全部通用操作,即六个操作符和六个处理函数及方法
元组类型因为创建后不能修改,因此没有特殊操作
**注:**在对元组进行切片时,并不改变原有元组的值,而是生成了一个新的元组值
比如:
#继上例
creature[::-1]
('human', 'tiger', 'dog', 'cat') #生成的新元组
color[-1][2] #[-1]使索引到creature这个元素上,由于该元素是元组,所以还可以使用索引
'tiger' #说明creature[::-1]未改变原来元祖的值
2.3 序列类型应用场景
2.3.1 数据表示
数据表示指的是我们要用元组 / 列表来表达一组有序数据,通过这样的类型表达有序数据,进而操作他们
- 元组用于表示元素不改变的应用场景,更多用于固定搭配场景
- 列表用于需要处理数据且需要处理功能比较多样的场景
2.3.2 元素遍历
#列表元素遍历:
for item in ls:
#语句块
#元组元素遍历
for item in tuple:
#语句块
2.3.3 数据保护
如果不希望数据被程序所改变,将数据转换成元组
ls=['cat','dog','tiger',1024]
lt=tuple(ls)
print(lt)
('cat', 'dog', 'tiger', 1024)
第三节 字典数据类型 (1+1+2+3+4+4)
一种操作符+访问,增加,修改+两种删除方法+三种遍历+4个操作函数+4个操作方法
1 字典类型的定义
- 理解映射
1 映射是一种键(索引)和值(数据)的对应关系
2 映射表达某一个属性跟他对应的值
3 映射本身就是一种索引/属性与数据的之间的对应关系
**注:**序列类型由0…N整数作为数据的默认索引,映射类型则由用户为数据定义索引 - 字典类型是映射的体现
1 字典是一系列键值对,可以使用键来访问与之相关联的值。键为不可变数据类型,值可以是任意数据类型。
2 字典是放在{}中的一系列键值对,键和值之间用冒号分隔,而键值对之间用逗号分隔,键值对之间无序且键不能重复
字典:{<键1>:<值1>,<键2>:<值2>,…,.<键N>:<值N>}
2 字典的建立
采用大括号{}和dict()来创建字典,空{}可以创建空字典
**注:**python不关心键值对的存储顺序,而只跟踪键和值之间的关联关系
#用dict()函数建立一个空字典
d=dict()
print(d)
{}
#用{}创建一个字典类型
de={'中国':'北京','美国':'华盛顿','英国':'伦敦'}
#另一种字典的建立(键值对前四个空格)
de={
1:'一',
2:'二',
3:'三',
}
print(de)
{1: '一', 2: '二', 3: '三'}
3 访问,添加与修改字典中键值对
通用格式:<字典变量>[<键>]=<值>
**访问字典中的值:**指定字典名和放在方括号中的键
**添加键值对:**指定字典名,用方括号括起来的新建和相关联的值
**修改字典中值:**指定字典名,用方括号括起的键以及与该键相关联的新值
比如
#创建了一个字典类型
de={'中国':'北京','美国':'华盛顿','英国':'伦敦'}
#访问字典中的值
de['中国']
'北京'
#向字典中添加键值对
de["法国"]="巴黎"
print(de)
{'中国': '北京', '美国': '华盛顿', '英国': '伦敦', '法国': '巴黎'}
#修改字典中的值
de['美国']='洛杉矶'
print(de)
{'中国': '北京', '美国': '洛杉矶', '英国': '伦敦', '法国': '巴黎'}
4 删除键值对
del语句
**格式:**del <字典变量>[<键>]
使用del语句删除的是语句中的键与相对应的值
注:del语句也可以直接删除一个字典,格式为del <字典变量>
de={'中国':'北京','美国':'华盛顿','英国':'伦敦'}
del de['英国']
print(de)
{'中国': '北京', '美国': '华盛顿'}
del de
print(de)
报错(因为此时没有de这个变量了,被del语句删除了)
clear()方法
格式:<字典变量>.clear()
使用clear()方法清空字典变量中的所有键值对,使其变为一个空字典
注:clear()方法是使字典变量变为一个空字典,del <字典变量>是直接删除字典
5 遍历字典
方法 | 描述 |
---|---|
<字典变量名>.items() | 返回字典中所有键值对的信息 |
<字典变量名>.keys() | 返回字典中所有的键信息 |
<字典变量名>.values() | 返回字典中所有的值信息 |
de={'中国':'北京','美国':'华盛顿','英国':'伦敦'}
#返回字典de中的所有键值对的信息
de.items()
dict_items([('中国', '北京'), ('美国', '华盛顿'), ('英国', '伦敦')])
#返回字典de中的所有键的信息
de.keys()
dict_keys(['中国', '美国', '英国'])
#返回字典de中的所有值的信息
de.values()
dict_values(['北京', '华盛顿', '伦敦'])
**注:**dict_items,dict_keys和dict_values并不返回列表类型,他返回的是一种字典的items/keys/values类型,可以用for…in的方式做遍历,但是不能当列表类型来操作
5.1 遍历字典中所有的键值对
**遍历语句:**for <键变量>,<值变量> in <字典变量>.items():
de={'one':'java','two':'python','three':'hip'}
for key,value in de.items():
print("\nkey:" + key)
print("value:" + value)
#输出结果如下
key:one
value:java
key:two
value:python
key:three
value:hip
5.2 遍历字典中的所有键
**遍历语句:**for <键变量> in <字典变量>.keys():
de={'one':'java','two':'python','three':'hip'}
for key in de.keys():
print("key:" + key)
#输出结果如下
key:one
key:two
key:three
5.3 按顺序遍历字典中的所有键
**遍历语句:**for <键变量> in sorted(<字典变量>.keys()):
de={'one':'java','two':'python','three':'hip'}
for key in sorted(de.keys()):
print("key:" + key)
#输出结果如下
key:one
key:three
key:two
5.4 遍历字典中的所有值
**遍历语句:**for <值变量> in <字典变量>.values():
de={'one':'java','two':'python','three':'hip'}
for value in de.values():
print("value:" + value)
#输出结果如下
value:java
value:python
value:hip
6 嵌套
嵌套的定义
将一系列字典储存在列表中,或将列表作为值储存在字典中
在列表中储存字典
将每个字典作为列表的元素(所有字典的结构要相同)
在字典中储存列表
将列表作为值放入字典中
**适用范围:**每当需要在字典中将一个键关联到多个值时,都可以在字典中嵌套一个列表
在字典中储存字典
将一系列字典作为值放入一个新的字典中
7 对字典的处理(1+4+4)
一种操作符,4个处理函数,四个处理方法
操作符/方法/函数 | 描述 |
---|---|
<键名> in <字典变量名> | 判断键是否在字典中,如果在返回True,否则False |
len(<字典变量名>) | 返回字典中键值对的个数 |
<字典变量名>.get(<键名>,) | 若键存在,则返回相应值,反之则返回值,默认为None |
<字典变量名>.pop(<键名>,) | 若键存在,则取出相应值,反之则返回值,默认为None |
<字典变量名>.popitem() | 随机从字典中取出一个键值对,以(<键>,<值>)元组形式返回 |
<字典变量名>.clear() | 删除字典中所有的键值对 |
min(d) /max (d) | 返回字典d中最小 / 最大键所对应的值 ,当字典中所有键可比较时 |
dict() | 生成一个空字典 |
注:因为字典类型中键值对的关系,其他类型无法转换成字典类型。所以可看为字典类型没有转换函数。
de={'中国':'北京','美国':'华盛顿','英国':'伦敦'}
'one' in de #判断键one是否在字典de中
len(de) #返回字典de中键值对的个数
de.get('英国','巴黎')
de.pop('法国','巴黎')
de.popitem() #以元组形式随机返回一个键值对
de.clear()
print(de) #用来验证.clear方法是否将键值对全部删除
#输出结果为
False
3
'伦敦'
'巴黎'
('英国', '伦敦')
{}
补充内容 列表的扩展式
能看懂代码就行了
注:列表扩展式的作用就是少建立了一个列表变量,节约了内存
#下面是比较简单的
ls=[]
for i in range(5):
ls.append(i)
print(ls)
# 下面的就是列表扩展式,等价于上面的一段代码,
print([i for i in range(5)])
##下面是比较复杂的
ls=[]
for i in range(5):
if i>3:
ls.append(i)
else:
ls.append(0)
print(ls)
# 下面的就是列表扩展式,等价于上面的一段代码,有点类似于二分支结构的紧凑形式
print([i if i>3 else 0 for i in range(5)])