Python容器：列表、元组、字典、集合

序言

• 此文章针对有一定基础的人，简明扼要的介绍字符串、列表、元组、字典、集合的概念和常用操作，以备复习巩固之用。

• 底层的基本数据类型：布尔型，整形，浮点型以及字符串类型。

• 基本数据类型组合起来称之为数据结构。

  • 数据结构：列表、元组、字典、集合。

序列

• 序列：一系列元素以它们所处的位置为索引，以第一个到最后一个依次编号就组成一个序列。
• 序列结构：字符串、元组和列表都是序列结构，但是它们又有各自的特点。
  • 元组和列表与字符串不同的是，元组和列表并不是求所含元素的种类相同，每个元素都可以是任何Python类型的对象。
  • 元组和列表不同的是，元组是不可变的，元组被赋值后，这些值就会被固定在元组中，不会被修改，而列表中的值还可以进行插入、删除等操作。

字符串（string）

• 字符串是我们首先要接触到的Python序列类型，其本质为字符序列，Python字符串不可改变，无法对原字符串进行修改，但是可以将字符串的一部分复制到新的字符串中。

创建字符串

• 1.1 单引号
  • 双引号
  • 三个单引号：创建多行字符串

'example1'
"example2"
'''example3,
example4
continue'''

• 1.2 使用str()转换

str(123)
'123'
#注意用print输出的差别,没有引号
print(str(123))
123

字符串的简单操作

• \转义
  • \n
  • \t
  • ’
  • "
• +拼接

#注意，one后面有个空格
使用 + 进行拼接
'one '+'two'
'one two'
直接写在后面也可以拼接
'one ''two'
'one two'

• *复制

• []中括号提取

#注意，偏移量不能超过字符串长度
vocabulary = 'transcendental'
vocabulary[0]
't'
vocabulary[-1]
'l'

• [start : end : step]字符串分片

#：引号不可省略，其他的都可以省略
#[:] 提取全部
#[:end] 开始到end - 1
#[start:end:step]定步长截取
#负号的使用可以带来许多有意思的操作，比如步长为-1，那么将会反向输出字符串
#在这里允许偏移量超过字符串长度
vocabulary = 'transcendental'

相关操作函数

• len()获取字符串函数
• split()分割
• join()合并
• replace()替换字符串
• startswith()判断字符串开始字符是否为某个字符串
• find()查询某个字符的开始的偏移量
• rfind()查询某个字符的最后的偏移量
• count()统计某个字符出现的次数
• title()所有单词开头字母变大写
• upper()所有字母大写
• lower()所有字母小写
• swapcase()大小写转换
• split()分割

#split基于分隔符分割字符串，分割成为列表
#逗号为分隔符，分割program_ex 
program_ex = 'hello,world'
program_ex.split('，')
['hello','world']

• join()合并

#与split逻辑相反
#调用顺序：首先指定粘合用的字符串，然后指定需要粘合的列表
#string.join(list)
crypto_list = "'Yeti', 'Bigfoot', 'Loch Ness Monster'"
ctypto_string = ','.join(crypto_list)
print('Found and signing book deals:',ctypto_string)
Found and signing book deals:Yeti, Bigfoot, Loch Ness Monster

• replace()替换字符串

#参数 需要被替换的子串，用于替换的子串，需要替换次数
#将三个o替换成X
crypto_list = "'Yeti', 'Bigfoot', 'Loch Ness Monster'"
crypto_list_replace = crypto_list.replace('o','X',3)
print(crypto_list_replace)
['Yeti', 'BigfXXt', 'LXch Ness Monster']

列表（list）

创建列表

• 1.1：中括号[ ]或者list( )创建列表

empty_list = []
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']

another_empty_list = list()

• 1.2：使用list()转换

#字符串转换
list('cat')
['c','a','a']

#元组转换
a_tuple = ('ready','fire','aim')
list(a_tuple)
['ready','fire','aim']

• 1.3 split分割，参见字符串中的split()
• 1.4(高级方式)：列表推式（一种从一个或者多个迭代器快速简洁地创建数据结构的一种方法，将循环和条件判断结合，避免语法冗长）
• 表达式：
  • [expression for item in iterable]
  • [expression for item in iterable if condition]

number_list = [number for number in range(1,6)]
number_list
[1,2,3,4,5]
a_list = [number for number in range(1,6) if number % 2 == 1]
a_list
[1,3,5]

• 循环嵌套
  • 创建一个元组，其中元组第一项由循环1控制，第二项由循环2控制。
  • [(iterable1,iterable2) for item in iterable1 for item in iterable2]
  • example:

列表推导模式
rows = range(1,4)
cols = range(1,3)
cells = [(row,col) for row in rows for col in cols]
	for cell in cells:
		print(cell)
(1 1)
(1 2)
(2 1)
(2 2)
(3 1)
(3 2)

普通模式
rows = range(1,4)
cols = range(1,3)
	for row in rows:
		for col in cols:
			print(row,col)
1 1
1 2
2 1
2 2
3 1
3 2

列表的简单操作

• 获取列表元素
  • 通过偏移量（offse）获取对应位置的元素
  • 表达式：list_number[offset]

#正偏移量
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly[0]
'Monday'
weekly[1]
'Tuesday'
#负偏移量，从尾数开始计数
weekly[-1]
'Friday'

• 列表的嵌套：列表中可以包含各类元素，也可包含其它列表。

#列表3中的元素类型包含整形，字符串，数组
list1 = ['Wednesday','Friday']
list2 = [3,'apple',4,'TV']
list3 = [list1,'helloworld',list2,8,5]
#访问列表3中第一元素
list3[0]
['Wednesday','Friday']
#通过列表3访问列表2中第一个元素
list3[2][1]
3

• 修改列表元素
  • 通过偏移量(offset)修改列表元素

#使用偏移量无法更改字符串中的指定字符，因为字符串本身不可变。
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly[1] = 'correct'
['Monday','Tuesday','correct','Thursday','Friday']

• 指定范围的列表切片

#获取子序列
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly[0:2]
['Monday','Tuesday']
#设置步长:每两个元素提取一个
weekly[::2]
['Monday','Wednesday','Friday']
#列表逆序，同样使用负号可以产生很有意思的事情
weekly[::-1]
['Friday','Thursday','Tuesday','Wednesday','Monday']

列表函数

• append()

• extend()

• insert()

• del()

• remove()

• pop()

• index()

• in()

• =赋值

• copy()

• append():列表后追加元素

# 插入Saturday
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.append('Saturday')
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']

• extend()或者+=：列表合并，将一个列表加入到另一个中，成为一个列表。

# 合并列表
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekend =['Saturday','Sunday']
weekly.extend(weekend)
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

weekly += weekend
weelkly
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

• insert()

# 插入Saturday
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.insert(5,'Saturday')
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']

• del()

# 删除Friday，del为Python语句，而不是list方法，所以不能用  .  调用
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
del weekly[4]
weekly
['Monday','Tuesday','Wednesday','Thursday']

• remove()

# 删除Friday,remove是list方法
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.remove('Friday')
weekly
['Monday','Tuesday','Wednesday','Thursday']

• pop()

# 获取元素后删除，且pop()的，默认只为-1，删除尾元素，因此pop(0)=pop(-1),可以用pop(0)获取并删除首元素
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.pop()
'Friday'
weekly
['Monday','Tuesday','Wednesday','Thursday']

• index()：插入特定值的元素位置

#返回指定值的位置信息
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.index('Monday')
0

• in()：判断存在

# 判断Sunday是否在weekly中
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
'Sunday' in weekly
False

• count()：统计特定值的出现次数

weekly.count('Wednesday')

• join()
  • 字符串方法的扩充，参见字符串方法中的join
• sort()和sorted()

# sort对原列表进行排序，sorted对原列表生成副本后排序，原列表内容不变
marxes = ['Groucho','Chico','Harpo']
sorted_marxes = sorted(marxes)
sorted_marxes
['Chico','Groucho','Harpo']

marxes = ['Groucho','Chico','Harpo']
marxes.sort()
marxes
['Chico','Groucho','Harpo']

• len()

weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
a = len(weekly)
print(a)
5

• in()

# 赋值后weekly = Weekly，改变其中一个，另一个随之改变
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
Weekly = weekly

• copy()

# copy()
# list()
#列表分片
#用以上方法产生的新列表和元列表没有内在联系，即改变其中任何一个，其它的不受影响
a = [1,2,3]
b = copy(a)
c= list(a)
d = a[:]

a[0] = '100000000000'
b = [1,2,3]
c = [1,2,3]
d = [1,2,3]

元组（tuple）

• 元组与序列类似，也是由任意元素组成的序列，但是元组一旦创建如同字符串，不可改变。

元组的创建

• 使用()创建空元组

#创建空元组
empty_tuple = ()
()

• 使用逗号’,'创建元组

#创建一个元素的元组，最后','不可省略
one_marx = 'martrix',
( 'martrix',)

#创建多个元素的元组，最后的','可省略
another_martx =  'martrix','array'
 ('martrix','array')

• 元组解包（元组赋值操作）

another_martx =  'martrix','array'
a,b = another_martx
a 
'martrix'
b
'array'
元组解包的经典操作，交换变量的值
one = 'martrix'
two =  'array'
two,one = one,two
one
'array'
two
'martrix'

• tuple创建

weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
tuple(weekly)
('Monday','Tuesday','Wednesday','Thursday','Friday')

• 元组的不可更改由其独特的优点，在以后的应用中可以用到，但是一般情况下多用列表和字典。

字典（dict）

• 字典中的元素顺序无关紧要，通过不同的键(key)进行访问，字典是可以改变的，和现实的字典类似。
• 字典在其它的语言中被称为关系型数组，哈希表，哈希图等。

字典的创建

• 使用大括号{key:value}创建

#空字典
empty_dic = {}
#键值对的字典
one_dict = {"day1":study
"day2":paly
"day3":sleep
}
empty_dic
{"day1":study
"day2":paly
"day3":sleep
}

• 使用dict()创建

#将包含双值的子序列的序列转换成字典,第一值为键，第二个值为值
one_list = [[1,'a'],[2,'b']]
dict(one_list)
{1:'a',2:'b'}
#可以将双值的，双字符，元组，列表化成字典。
tos = ('ab','cd','ef')
dict(tos)
{'c':'d','a':'b','e':'f'}

字典的相关操作

• [key]储存，访问，添加或者修改元素

#储存一个元素
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
   }
 d2 = d['three']
 d2
 ['three':3]
#访问一个元素,如果不存在会报错
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
   }
   d['one']
   123
#添加一个元素，然后修改这个元素
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
   }
#添加元素'try':55
d['try'] = '55'
d
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
    'try':55
   }
修改元素55为5
d['try'] = '5'

字典的函数

• update()合并字典
• del()删除具有指定键的元素
• clear()删除所有元素，变成空字典
• in()判断是否存在
• get()获取键对应元素，[key]不同是，不会报错
• keys()获取所有键
• values()获取所有值
• item()获取所有键值对
• =赋值
• copy()复制
  用法参见list

集合（set）

• 集合和只剩下的键的字典类似，键与键之间不允许重复，类似数学中的集合，主要包括并、交等运算，且集合是无序的。

集合的创建

• 用{}大括号将一系列用逗号隔开的值包裹起来。
• 用set函数创建
• 将其他类型转换成集合

#空集合
empty_set = set()
empty_set
set()
#偶数集合
even_numbers = {0,2,4,6,8}
even_numbers
{0,2,4,6,8}
#转换字符串,不包含重复的键
set('letters')
｛‘l’，‘e’，‘t’,'r','s'｝
#转换列表
set(['Dasher','Dancer','Prancer','Mason-Dixon'])
{'Dasher','Dancer','Prancer','Mason-Dixon'}
#转换元祖
set(('Monday','Tuesday','Wednesday','Thursday','Friday'))
{'Monday','Tuesday','Wednesday','Thursday','Friday'}
#转换字典，注意只保留键
set({'apple':'red','flower':'blue','tree':'green'})
{'apple','flower','tree'}

集合的相关函数

• 用in测试值是否存在

for name,contents in drinks.items():
	if 'vodka' in contents:
		print(name)

screwdriver
martini
black russin
white russin
#选择vodka，但是不要vermouth，且不是cream
for name,contents in drinks.items():
if 'vodka' in contents and not ('vermouth' in contents or 'cream' in contents):
	print(name)
screwdriver
black russin

• intersection() 或者& 获取交集

drinks = ｛
	'martini' : {'vodka','vermouth'}
	'black russin' : {'vodka','kahlua'}
	'white russin' : {'cream','kahlua','vodka'}
	'manhattan' : {'rye','vermouth','bitters'}
	'screwdriver' : {'orange juice','vodka'}
｝
for name,contents in drinks.items():
	if contents & {'vermouth','orange jucice'}
		print(name)
screwdriver
martini
manhattan

for name,contents in drinks.items():
	if 'vodka' in contents and not contents & {'vermouth','cream'}:
		print(name)
screwdriver
black russin

a和b的交集
a.intersection(b)

#bruss和wruss的交集
bruss = drinks['black russian']
wruss = drinks['white russian']
bruss & wruss
{'kahlua','vodka'}

• union() 或者 | 函数获取并集
• different() 或者 - 获得集合的并集
• symmetric_difference() 或者 ^ 获得异或集（只在两个集合中出现一次）
• issubset() 或者 <= 判断一个集合是否是另一个集合的子集
• < 判断真子集
• issupset() 或者 >= 判断超集（超集的概念与子集相反）

• 判断真超集

总结

• 使用方括号[]创建列表，使用逗号创建元祖，使用花括号｛｝创建字典，且都是通过方括号对单个元素进行访问。

marx_list = ['Groucho','Chico','Harpo']
marx_tuple = 'Groucho','Chico','Harpo'
marx_dict = {'Groucho' : 'banjo','Chico' : 'pinao','Harpo' : 'harp'}
marx_list[2]
'Chico'
marx_tuple[2]
'Chico'
marx_dict['banjo']
'Chico'