[自学笔记]python基础2——容器类型

本文大纲

• 容器类型：列表和元祖
• 容器类型：字典
• 容器类型：集合
• 可变类型与不可变类型
• 建立复杂的数据结构
• 输入和输出
• 练习：容器类型操作

一、容器类型：列表和元祖

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是否存在