本文大纲
- 容器类型:列表和元祖
- 容器类型:字典
- 容器类型:集合
- 可变类型与不可变类型
- 建立复杂的数据结构
- 输入和输出
- 练习:容器类型操作
一、容器类型:列表和元祖
1、数据收纳盒
- 用来收纳数据对象的数据类型
- 以一种规则的下标索引方式(收纳盒名字+数字序号)访问到每个数据
- 这种收纳盒是一种序列
- 列表可以删除、添加、替换、重排序列中的元素(可变类型)
- 元祖是不能再更新(不可变)序列
元祖在保留列表大多数功能的同时,去掉一些灵活性以换取更高的处理性能
2、列表和元祖的创建
- 创建列表
方括号法[],指明类型法list() - 创建元祖
圆括号法(),指明类型法tuple() - 列表或元祖中保存的各个数据称作元素(element),类型没有限制
3、列表的操作:增长/缩减
- 增长列表
append 操作/insert 操作/extend 操作 - 缩减列表
pop 操作/remove 操作/clear 操作 - 列表是一种可变容器,可以随意增减
- 但并不是所有的数据容器都能像列表这样可以继续添加新元素
4、列表的操作:重新组织
- reverse/sort 操作
reverse:把列表中的数据元素头尾反转重新排列
sort :把列表中的数据元素按照大小顺序重新排列
num=[1,2,7,4,3,9,0]
num.reverse()
num
Out[4]: [0, 9, 3, 4, 7, 2, 1]
num.sort()
num
Out[6]: [0, 1, 2, 3, 4, 7, 9]
num.sort(reverse=True) #从大到小排序
num
Out[8]: [9, 7, 4, 3, 2, 1, 0]
- reversed/sorted 操作
得到重新排列的列表,而不影响原来的列表
5、列表的方法
方法名称 | 使用列子 | 说明 |
---|---|---|
append | alist.append(item) | 列表某尾添加元素 |
insert | alist.insert(i,item) | 列表中i位置插入元素 |
pop | alist.pop() | 删除最后一个元素,并返回其值 |
pop | alist.pop(i) | 删除第i 个元素,并返回其值 |
sort | alist.sort() | 将表中元素排序 |
reverse | alist.reverse() | 将表中元素反向排列 |
del | del alist[i] | 删除第i个元素 |
index | alist.index(item) | 找到item的首次出现位置 |
count | alist.count(item) | 返回item 在列表中出现的次数 |
remove | alist.remove(item) | 将item 的首次出现删除 |
6、列表和元祖的操作
- 合并
加法运算+:连接两个列表/元祖
乘法运算*:复制n次,生成新列表/元祖 - 列表/元祖大小
len():列表/元祖中元素的个数 - 索引
alist[n] 或 atuple[n]
可以用赋值语句给列表中的任何一个位置重新赋值
但元祖属于不可变类型,索引只能获取对应位置中的数据值,不可重新赋值 - 切片
alist[start🔚step]
atuple[start🔚step] - 查找
in 操作:判断某个元素是否存在于列表/元祖中
index操作:指定的数据在列表/元祖的哪个位置
count操作:指定的数据在列表/元祖中出现过几次 - 计算
sum函数:将列表中所有的数据元素累加
min/max 函数:返回列表中最小/最大的数据元素
二、容器类型:字典
1、“贴标签的数据”
- “标签收纳盒”
给数据贴上标签,就可以通过具有特定含义的名字或者别的记号来获取数据 - “现实生活中的字典”
通过标签(或者关键字)来索引数据,区别于列表或元祖通过连续的整数来索引 - 标签(key)和数据值(value)
字典容器中保存着一系列的key-value对
通过键值key来索引元素value
2、创建一个字典
- 花括号法和指明类型法
student={}
student=dict() - 数据项(item)
字典中保存的各个标签-数据值(key-value)
标签和数据值之间用冒号“:”连接 - 批量添加数据项
student=dict.fromkeys((“name”,“age”)) - 字典是可变类型,可以添加、删除、替换元素
- 字典中的元素value没有顺序,可以是任意类型,甚至也可以是字典
- 字典的键值key可以是任意不可变类型(数值/字符串/元祖)
bands={'Marxes':['Moe','Curly'],'kk':[True,'moon']}
bands['kk'][0]
Out[10]: True
poi={(100,100):'Zhongguancun',(123,23):'Pizza'}
poi[(100,100)]
Out[12]: 'Zhongguancun'
3、更新一个字典
- 合并字典
update方法 - 增长字典
“关联”操作
update操作:以key=value的形式批量添加数据项 - 缩减字典
del 操作:删除指定标签的数据项
pop 操作:删除指定标签的数据项并返回数据值(不加key,默认最后一个)
popitem操作:删除并返回任意一个数据项
clear操作:清空字典 - 字典大小
len()函数 返回有多少个键值对
student={}
student['name']="Tom"
student['age']="20"
student['gender']="male"
student
Out[17]: {'name': 'Tom', 'age': '20', 'gender': 'male'}
#增加一个course
bar={'course':["数学","英语"]}
student.update(bar)
student
Out[20]: {'name': 'Tom', 'age': '20', 'gender': 'male', 'course': ['数学', '英语']}
#增加一个friends
student.update(friends=["Mike","Alice"])
student
Out[22]:
{'name': 'Tom',
'age': '20',
'gender': 'male',
'course': ['数学', '英语'],
'friends': ['Mike', 'Alice']}
#删除关键字 age
del student['age']
student
Out[24]:
{'name': 'Tom',
'gender': 'male',
'course': ['数学', '英语'],
'friends': ['Mike', 'Alice']}
#随机删除关键字,并返回改关键字
student.popitem()
Out[25]: ('friends', ['Mike', 'Alice'])
student
Out[26]: {'name': 'Tom', 'gender': 'male', 'course': ['数学', '英语']}
#清空字典
student.clear()
student
Out[28]: {}
4、访问字典的数据项
- 标签索引
dict[key]
获取字典中指定标签的数据值
更新指定标签的数据项 - get 操作
- 获取字典的标签、数据值和数据项
keys 函数:返回字典中的所有标签
values 函数:返回字典中的所有数据值
items 函数:将每个数据项表示为二元元组,返回所有数据项
student={'name': 'Tom','age':20, 'gender': 'male'}
student['age'] #索引该key
Out[31]: 20
student['age']=24 #若不存在即为新增key-value,存在为替换
student
Out[33]: {'name': 'Tom', 'age': 24, 'gender': 'male'}
#get 操作能获取变量但无法更新键值对
student.get('age')
Out[34]: 24
student={'name': 'Tom','age':20, 'gender': 'male'}
student.keys() #返回所有key
Out[36]: dict_keys(['name', 'age', 'gender'])
student.values() #返回所有value
Out[37]: dict_values(['Tom', 20, 'male'])
student.items() #返回所有数据项
Out[38]: dict_items([('name', 'Tom'), ('age', 20), ('gender', 'male')])
5、在字典中查找
- in 操作
判断字典中是否存在某个标签 - in 操作和values 函数的组合
判断字典中是否存在某个数据值
student={'name': 'Tom','age':20, 'gender': 'male'}
'name' in student
Out[40]: True
'city' in student
Out[41]: False
20 in student.values()
Out[42]: True
三、容器类型:集合
1、标签的容器
- “标签袋”
通过改造字典类型,去掉关联数据值,只留下标签的新容器类型 - 集合是不重复元素的无序组合
2、创建一个集合
- 创建集合:{}或者set()
用set()创建空集
可用set()从其它序列转换生成集合 - 集合会自动忽略重复的数据
- 集合中不能加入可变类型数据
3、更新一个集合
- 增长集合
add:添加一个数据
update:批量添加数据 - 缩减集合
remove/discard:删除指定数据(若删除指定数据不存在remove会报错,但discard不会)
pop:删除任意数据并返回值
clear:清空集合 - 集合大小
len() 函数
aset={'a','b','c'}
aset
Out[3]: {'a', 'b', 'c'}
aset.add(1.23)
aset
Out[5]: {1.23, 'a', 'b', 'c'}
aset.remove('b')
aset
Out[7]: {1.23, 'a', 'c'}
aset.pop()
Out[8]: 'a'
aset
Out[9]: {1.23, 'c'}
aset.clear()
aset
Out[12]: set()
4、访问集合中的元素
- in
判断元素是否属于集合 - pop
删除数据元素的同时,返回它的值
取遍所有数据元素之后,集合成为一个空集
可以用copy操作先给集合制作一个“替身” - 迭代循环
for a in aset:
5、集合运算
- 生成新集合运算
- 关系判定
<=,=,>;子集/真子集/超集/真超集 - 交集
isdisjoint():两集合交集是否为空
set()
Out[13]: set()
aset=set('abc')
aset
Out[15]: {'a', 'b', 'c'}
'a' in aset
Out[16]: True
aset | set('bcd') #取并集
Out[17]: {'a', 'b', 'c', 'd'}
aset & set(['b','c','d']) #取交集
Out[18]: {'b', 'c'}
aset - set(['b','c','d']) #取差集
Out[19]: {'a'}
aset ^ set(['b','c','d']) #取对称差
Out[20]: {'a', 'd'}
aset <= set('abcd')
Out[21]: True
aset > set('abcd')
Out[22]: False
6、什么时候用集合
- 快速去除重复值的数据项
- 判断元素是否在一组数据中,如果这些数据的次序不重要,使用集合可以获取比例更好的性能
四、可变类型和不可变类型
1、数据收纳的灵活性
- 列表——可以接长、拆短的积木式收纳盒
- 元祖——固定长短的收纳盒
2、数据类型
- 不可变(immutable)类型:一旦创建就无法修改数据值的数据类型
整数、浮点数、复数、字符串、复数、字符串、逻辑值、元祖 - 可变(mutable)类型:可以随时改变的数据类型
列表、字典、集合 - 灵活性强会花费一些计算或者存储的代价去维持这些强大的功能
3、可变类型的变量引用
- 变量的引用特性
可变类型的变量操作需要注意,多个变量通过赋值引用同一个类型对象时,通过其中任何一个变量改变了可变类型对象,其它变量也随之改变
a=[1,2,3,4]
a
Out[24]: [1, 2, 3, 4]
b=a
b
Out[26]: [1, 2, 3, 4]
id(a)
Out[27]: 146579784
id(b)
Out[28]: 146579784
a[0]='hello'
a
Out[30]: ['hello', 2, 3, 4]
b
Out[31]: ['hello', 2, 3, 4]
4、可变类型的变量引用:初学者常见错错误
#python赋值是引用地址
#修改 mylist ,由于 A 引用的是 mylist 的值,所以Mylist 的值改变时,A 也改变
mylist=[1,2,3,4]
A=[mylist]*3
print(A)
[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
mylist[2]=45
print(A)
[[1, 2, 45, 4], [1, 2, 45, 4], [1, 2, 45, 4]]
五、建立复杂的数据结构
1、比较几种数据结构
- 使用方括号[]创建列表
- 使用圆括号()创建元祖
- 使用花括号{}创建字典
- 每种类型中,都可以通过方括号[]对单个元素进行访问
对于列表和元组,方括号里是整型的偏移量
对于字典,方括号里的是键
都返回元素的值
2、建立大型数据结构
将这些内置的数据结构自由地组合成更大、更复杂的结构。
创建自定义数据结构的过程中,唯一的限制来自于这些内置数据类型本身。
(1)列表/元组
- 建立3个不同的列表
alist=[1,2,3]
blist=[‘Hello’,‘python’]
clist=[True,False] - 嵌套列表/元组
list_of_lists=[[1,2,3],[‘Hello’,‘python’],[True,False]]
tuple_of_lists=([1,2,3],[‘Hello’,‘python’],[True,False])
(2)字典 - 嵌套字典
dict_of_lists={‘num’:[1,2,3],‘word’:[‘Hello’,‘python’],‘bool’:[True,False]} - 字典的元素可以是任意类型,甚至也可以是字典
- 字典的键值可以是任意不可变类型
例如:用元组来作为坐标,索引元素
poi={(100,100):‘bus stop’}
六、输入和输出
1、来料加工:input函数
用户会给程序提供什么值是无法预测的
因此在编写程序的时候,不知道变量的具体值
解释器最终要怎么知道变量的值呢?
- input(prompt)
显示提示信息prompt,由用户输入内容 - input()返回值是字符串
通过int()函数将字符串类型强制转换为整数类型
x=input('x:')
x:5
y=input('y:')
y:6
x+y
Out[8]: '56' #input 默认返回的是字符串
int(x)+int(y)
Out[9]: 11
2、产品展示:print 函数
- 打印各变量的值输出
print ( [object,…] [,sep=’ ‘] [,end=’\n’] [,file=sys.stdout] ) - sep:表示变量之间用什么字符串隔开,缺省是空格
- end:表示以这个字符串结尾,缺省为换行
- file:指定了文本将 要发送到的文件、标准流或其它类似的文件的对象;默认是sys.stdout
3、格式化字符串
- print 函数默认把对象打印到stdout流,并且添加了一些自动的格式化(可以自定义分隔符和行末符)
- 格式化字符串
‘%d %s’ % (v1,v2)
yname=input("Please input your name: ")
Please input your name: Tom Hanks
print(1,23,'Hello')
1 23 Hello
print(1,23,'Hello',end=' ')
1 23 Hello
print(1,23,'Hello',sep=',')
1,23,Hello
'%d %s'% (23,'Hello')
Out[14]: '23 Hello'
'%d '% (23)
Out[15]: '23 '
'%d '% (23,)
Out[16]: '23 '
'(%4d):K:%s' % (12,'Hello')
Out[17]: '( 12):K:Hello'
'(%04d):K:%10s' % (12,'Hello')
Out[18]: '(0012):K: Hello'
七、容器类型操作
- 列表、元祖基本操作
+,*,len(),[],in - 列表、元祖高级操作
mylist=[1,2,3,4,5]
切片:获得[2,3,4],获得[3,4,5],获得[3,2,1],获得[1,3,5]
mytpl=[1,2,3,4,5] 同上操作
t=‘Mike and Tom’
split 拆分、join 合成为 ‘Mike/and/Tom’ - 集合基本操作
a=set([1,2,3,4,5])
b=set([12,4,6,8,10])
并、交、差、异或、子集
添加、删除。是否空集 - 字典基本操作
mydict={1:‘Mon’,‘line1’:3332}
添加、删除、是否空字典
取字典所有的key 、value
判断key是否存在