python | 列表，元组，字符串，集合，字典

列表：

• 可以容纳任意数目不同类型的元素（支持我们学过的任意数据类型）
• 元素之间有先后顺序
• 用中括号包裹，每个元素用逗号隔开

例如：

students = [
  '林黛玉',
  '薛宝钗',
  '贾元春',
  '贾探春',
  '史湘云',
  '妙玉',
  '贾迎春',
  '贾惜春',
  '王熙凤',
  '贾巧姐',
  '李纨',
  '秦可卿'
]

列表可容纳任意个元素，当然也包括 0 个元素。这样的列表我们称为 空列表，只用一对中括号 [] 表示即可，中间不加逗号。

反向索引的数字和我们日常生活中的倒数数字是一样的，用 -1 表示倒数第一个，用 -2 表示倒数第二个。

正向索引 和 反向索引 （比如：students[-1]）都是通过位置，查找对应值的方法

快速获取列表索引值的方法：使用 列表.index(元素内容) 的形式

列表元素的修改：

通过 列表[索引] = 新值 的格式

# 第二个名字，索引为 1
students[1] = '贾宝玉'

列表元素的添加：

在列表末尾添加一个元素：append() 方法会在列表末尾新增一个元素，同时列表长度加一

students.append('贾宝玉')

在列表中间某个位置插入一个元素：insert() 方法

students.insert(9, '贾琏')

列表元素的删除：

用列表的 pop() 方法，pop() 的功能是：返回列表指定位置的元素，并删除这个元素。 pop() 可以传入一个参数，表示要删除的元素的索引，如果不传入，就默认为最后一个元素的索引。

students.pop()

可以使用更加便捷的 del 语句来操作列表，格式为：del 列表[索引]。

del students[0]

通过 列表.remove(值) 的方式，我们可以在列表中找到 第一个 指定的值，然后将它删除。

students.remove('王熙凤')

列表的分片：

列表分片用一对以冒号分隔的索引位置表示，格式为 列表[起始索引:结束索引]。比如要获取 students 中第三到第五个元素，也就是索引为 2，3，4 的元素，就要写成 students[2:5]。

on_duty = ['贾琏', '王熙凤', '林黛玉', '贾宝玉', '李纨', '薛宝钗', '妙玉']

# 打印周一周二值日的人
print(on_duty[:2])

# 打印周三到周五值日的人
print(on_duty[2:5])

# 打印周末值日的人
print(on_duty[-2:])

截取前三个元素，就写成 list[:3]；而截取最后四个元素，就写成 list[-4:]；截取中间部分 list[a:b]，分片长度就是 b - a。

列表常用方法：

统计元素出现的次数：count() 方法可以统计元素在列表中出现的次数

students = ['林黛玉', '贾宝玉', '薛宝钗', '贾宝玉']
print(students.count('贾宝玉'))
# 输出：2

排序：sort() 是一个很强大的方法，可以对列表内的元素进行排序。

str_list = ["lin", "jia", "xue"]
str_list.sort()
print(str_list)
# 输出：['jia', 'lin', 'xue']

num_list = [4, 2, 1, 9]
num_list.sort()
print(num_list)
# 输出：[1, 2, 4, 9]

• 字符串列表的排序按照每个元素首字母的顺序来排序，比如 j 在 l 前面，l 在 x 前面，可以简单地按照 26 个字母顺序表即可；
• 数值列表的排序是按照数值大小从小到大进行排序，比如 1 比 2 小，所以 1 在 2 前面。

反转、复制和清空：reverse()、copy()、clear() 方法

# reverse() 方法：将列表顺序反转
students = ["林黛玉", "贾宝玉", "薛宝钗"]
students.reverse()
print(students)
# 输出：['薛宝钗', '贾宝玉', '林黛玉']

# copy() 方法：复制一个同样的列表
students1 = ["林黛玉", "贾宝玉", "薛宝钗"]
students2 = students1.copy()
print(students2)
# 输出：['林黛玉', '贾宝玉', '薛宝钗']

# clear() 方法：清空列表
students = ["林黛玉", "贾宝玉", "薛宝钗"]
students.clear()
print(students)
# 输出：[]

列表的基本运算：

成员运算符 in：用来判断一个元素是否在一个列表中，格式为 元素 in 列表。这是一个布尔表达式，如果元素在列表中，结果为布尔值 True，反之为 False。

students = [
  '林黛玉',
  '薛宝钗',
  '贾元春',
  '妙玉',
  '贾惜春',
  '王熙凤',
  '秦可卿',
  '贾宝玉'
]
miaoyu_in = '妙玉' in students
print(miaoyu_in)
# 输出：True

xiangyun_in = '史湘云' in students
print(xiangyun_in)
# 输出：False

加法和乘法：

# 列表的加法
students = ['林黛玉', '薛宝钗', '贾元春', '贾探春', '史湘云', '妙玉', '贾迎春', '贾惜春', '王熙凤', '贾琏', '贾巧姐', '李纨', '秦可卿', '贾宝玉']

parents = ['贾敬', '贾政', '王夫人', '贾赦', '邢夫人']

meeting = students + parents

# 打印 meeting 的结果，以及最终人数
print(meeting)
print('与会人数为', len(meeting), '人')
# 输出：
# ['林黛玉', '薛宝钗', '贾元春', '贾探春', '史湘云', '妙玉', '贾迎春', '贾惜春', '王熙凤', '贾琏', '贾巧姐', '李纨', '秦可卿', '贾宝玉', '贾敬', '贾政', '王夫人', '贾赦', '邢夫人']
# 与会人数为 19 人


#列表的乘法
lag_behind = ['贾探春', '秦可卿', '贾惜春', '贾琏']
# 用乘法快速生成轮班表
recite_list = lag_behind * 5

print(recite_list)
# 输出：['贾探春', '秦可卿', '贾惜春', '贾琏', '贾探春', '秦可卿', '贾惜春', '贾琏', '贾探春', '秦可卿', '贾惜春', '贾琏', '贾探春', '秦可卿', '贾惜春', '贾琏', '贾探春', '秦可卿', '贾惜春', '贾琏']

列表的扩展操作：

zip() 函数：它的作用是将两个长度相同的列表合并起来，相同位置的元素会被一一组对，变成一个元组。结果返回一个组合好的打包对象，需要我们再用 list() 函数转换回列表。

midterm_rank = [
  '妙玉',
  '薛宝钗',
  '贾元春',
  '王熙凤',
  '林黛玉',
  '贾巧姐',
  '史湘云',
  '贾迎春',
  '贾宝玉',
  '李纨',
  '贾探春',
  '秦可卿',
  '贾惜春',
  '贾琏'
]

scores = [100, 92, 77, 85, 81, 90, 100, 86, 79, 93, 91, 96, 75, 84]

# 将 scores 元素从低到高排列
scores.sort()

# 倒转 scores 中的排列顺序
scores.reverse()

print(scores)
# 输出：[100, 100, 96, 93, 92, 91, 90, 86, 85, 84, 81, 79, 77, 75]

# 用 zip() 将两个列表合并
zipped = zip(midterm_rank, scores)

# 将结果转换回列表后，赋值给 zipped_rank
zipped_rank = list(zipped)

# 来看看结果
print(zipped_rank)
# 输出：[('妙玉', 100), ('薛宝钗', 100), ('贾元春', 96), ('王熙凤', 93), ('林黛玉', 92), ('贾巧姐', 91), ('史湘云', 90), ('贾迎春', 86), ('贾宝玉', 85), ('李纨', 84), ('贾探春', 81), ('秦可卿', 79), ('贾惜春', 77), ('贾琏', 75)]

enumerate() 函数：“enumerate”单词本身意思是“枚举、数数”。所以对应的函数功能，就是一个一个地将列表中的元素数出来。它返回的是一个枚举对象，也需要我们用 list() 函数转换回列表。

# 枚举原排名表后，再转回列表的形式
rank_with_id = list(enumerate(midterm_rank))

print(rank_with_id)
# 输出：[(0, '妙玉'), (1, '薛宝钗'), (2, '贾元春'), (3, '王熙凤'), (4, '林黛玉'), (5, '贾巧姐'), (6, '史湘云'), (7, '贾迎春'), (8, '贾宝玉'), (9, '李纨'), (10, '贾探春'), (11, '秦可卿'), (12, '贾惜春'), (13, '贾琏')]

# enumerate()中这次有两个参数，一个为排名列表，一个为起始数字。
rank_with_ID = list(enumerate(midterm_rank, 1))

print(rank_with_ID)
# 输出：[(1, '妙玉'), (2, '薛宝钗'), (3, '贾元春'), (4, '王熙凤'), (5, '林黛玉'), (6, '贾巧姐'), (7, '史湘云'), (8, '贾迎春'), (9, '贾宝玉'), (10, '李纨'), (11, '贾探春'), (12, '秦可卿'), (13, '贾惜春'), (14, '贾琏')]

元组：

元组和列表非常相似。不同之处在于，外观上：列表是被方括号包裹起来的，而元组是被 圆括号 包裹起来的。本质上：列表里的元素可修改，元组里的元素是 不可以“增删改” 的。

还有一个微妙的地方要注意，就是只有一个元素的元组，在格式上与列表是不同的。仅一个元素 x 的列表写成 [x], 但仅一个元素的元组要在括号内多写个逗号：(x,)。

对于仅一个元素的元组，我们要特意加个逗号来声明：这是个元组。

single = (1,)
print(type(single))
# 输出：<class 'tuple'>

元组不能用于增加、修改或删除语句。

由于查询与分片操作并不会改变数据，所以我们说的两种列表元素的查询方式以及分片操作，在元组中是可用的。列表运算符，元组也都支持，用 in 查询元素是否在元组内；用 + 将两个元组叠加生成新元组；用 * 生成元素重复循环多次的新元组。

如果真的有特殊需求，需要修改元组中的元素：可以先用 list() 函数把元组转换成列表，相当于给数据“解锁”，将元素修改完毕后，再用 tuple() 函数转换回元组，相当于“重新上锁”。

students = ('林黛玉', '贾宝玉', '薛宝钗')

# 用 list() 函数给数据“解锁”，生成一个相同元素的新列表
students_list = list(students)

# 在新列表中修改元素
students_list[0] = '妙玉'

# 两次给数据“上锁”
students = tuple(students_list)

print(students)
# 输出：('妙玉', '贾宝玉', '薛宝钗')

字符串：

Python 中的字符串是使用一对英文单引号（'）或英文双引号（"）包裹的任意文本。无论是用单引号还是用双引号，它俩的效果都是一样的，但需要保持前后引号的统一。

使用一对三引号（''' 或 """）来包裹多行字符串，三引号包裹的字符串和普通的字符串使用上没有区别，只是三引号支持多行字符串而已。

字符串拼接：

可以使用+或者*

str1 = '烦死了'
str2 = str1 + str1 + str1
print(str2)
# 输出：烦死了烦死了烦死了

str11 = '烦死了'
str22 = str11 * 3  # 相当于 str11 + str11 + str11
print(str22)
# 输出：烦死了烦死了烦死了

字符串格式化输出：

用+ 来拼接字符串：

def print_intro(name, age, city):
  intro = '我叫' + name + '，今年 ' + str(age) + ' 岁，来自' + city + '。'
  print(intro)

print_intro('贝壳', 18, '世界各地')
# 输出：我叫贝壳，今年 18 岁，来自世界各地。

提示：字符串类型和数字类型不能直接相加，需要用 str() 函数进行类型转换。

用字符串的格式化输出实现同样的功能：

def print_intro(name, age, city):
  intro = '我叫%s，今年 %d 岁，来自%s。' % (name, age, city)
  print(intro)

print_intro('贝壳', 18, '世界各地')
# 输出：我叫贝壳，今年 18 岁，来自世界各地。

提示：如果不太确定应该用什么占位符，%s 是万能的，它会把任何数据类型转换为字符串。

字符串索引：

str = 'Hello World'
print(str[6])  # 输出：W
print(str[-5])  # 输出：W

字符串分片：

str = 'Hello World'
# 下面两个效果一样
print(str[6:])  # 输出：World
print(str[-5:])  # 输出：World

1. 分片是半闭半开区间，即包含前面索引位置的元素，不包含后面索引位置的元素。比如：string[m:n] 获取的是字符串 string 中索引为 m 到 n-1 之间的元素（包括 m 和 n-1）；
2. 分片中前后索引的值是可以省略的，前索引省略默认为 0，后索引省略默认为序列长度。

字符串不可变性：

但字符串一旦创建后是不可改变的，这个属性和元组类似，通过索引来改变字符串中元素就会报错：

name = '张艺兴'
name[0] = '贾'
print(name)
# 报错：TypeError: 'str' does not support item assignment on line 2

字符串的相关方法：

upper()：用于将字符串中的小写字母转为大写字母。

'abcd'.upper()  # 'ABCD'

lower()：用于将字符串中的大写字母转为小写字母。

'ABCD'.lower()  # 'abcd'

capitalize()：用于将字符串的第一个字母变成大写，其他字母变小写。首字符如果是非字母则不变，其他字母变小写。

'ABCD'.capitalize()  # 'Abcd'
'aBcD'.capitalize()  # 'Abcd'
'1abcd'.capitalize()  # '1abcd'
'1aBcD'.capitalize()  # '1abcd'

title()：用于返回“标题化”的字符串——即所有单词的首字母转为大写，其余字母均为小写。注意：非字母后的第一个字母将转为大写字母。

'this is an example string'.title()   # This Is An Example String
'5g is coming'.title()  # 5G Is Coming

swapcase()：用于对字符串的大小写字母进行互相转换。

'abcd'.swapcase()  # 'ABCD'
'aBcD'.swapcase()  # 'AbCd'

分割、组合与移除方法：

split()：

用于通过指定分隔符对字符串进行分割。split() 方法有两个可选参数，第一个参数为分隔符，默认为所有的空字符，包括空格、换行（\n）、制表符（\t）等。第二个参数为最大分割次数，默认为 -1，即不限次数。

'好 运 连 连'.split()  # ['好', '运', '连', '连']
'好 运 连 连'.split(' ')  # ['好', '运', '连', '连']
'好-运-连-连'.split('-')  # ['好', '运', '连', '连']
'好运连连'.split('运连')  # ['好', '连']
'好 运 连 连'.split(' ', 1)  # ['好', '运 连 连']

join()：

用于将序列中的元素以指定的字符连接生成一个新的字符串。join() 方法接收一个序列（列表、元组、字符串等）作为参数，前面的字符串用于连接符。

# 列表
''.join(['好', '运', '连', '连'])  # 好运连连
'-'.join(['好', '运', '连', '连'])  # 好-运-连-连

# 元组
'-'.join(('好', '运', '连', '连'))  # 好-运-连-连

# 字符串
'-'.join('好运连连')  # 好-运-连-连

strip()：

用于移除字符串开头和结尾指定的字符（默认为空字符）或字符序列。当传入一个字符串时，会将传入字符串中每个字符依次移除。

'好运连连 '.strip() #'好运连连'
'~~好运连连~~'.strip('~') #'好运连连'
'~~好运~~连连~~'.strip('~') #'好运~~连连'
'_~_好运连连_~~'.strip('~_') #'好运连连'

定位与替换方法:

count():

用于统计字符串中某个字符串出现的次数。第一个参数为要统计次数的字符串，后两个可选参数为在字符串搜索的开始与结束索引。

'aabbcccd'.count('a')  # 2
'aabbcccd'.count('ab')  # 1
'aabbcccd'.count('e')  # 0

'aabbcccd'.count('a', 2, 6)  # 0
# 等同于 'bbcc'.count('a')

'aabbcccd'.count('c', 2, 6)  # 2
# 等同于 'bbcc'.count('c')

find():

用于检测字符串中是否包含子字符串，如果包含子字符串返回第一次出现的索引值，否则返回 -1。第一个参数为要查找的子字符串，后两个可选参数为在字符串搜索的开始与结束索引。

'abc'.find('b')  # 1
'abcabc'.find('b')  # 1
'abcabc'.find('d')  # -1
'abcbcdabc'.find('bcd')  # 3
'abcabc'.find('b', 1, 2)  # 1
'abcabc'.find('b', 2, 3)  # -1

replace():

用于将字符串中的指定字符串替换成别的字符串。第一个参数为被替换字符串，第二个参数为替换字符串，第三个可选参数为替换的最多次数，默认为无限次。

'abcd'.replace('b', 'e')  # 'aecd'
'abbbcbd'.replace('b', 'e')  # 'aeeeced'
'abbbcbd'.replace('bb', 'e')  # 'aebcbd'
'abbbcbd'.replace('b', 'e', 2)  # 'aeebcbd'

格式化输出方法:

可以使用字符串的 format() 方法:

'我叫{}，今年 {} 岁，来自{}'.format('贝壳', 18, '世界各地')
# 我叫贝壳，今年 18 岁，来自世界各地

集合：

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set()      # 使用 set() 函数创建集合

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

添加元素：

s.add( x )：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.update( x )：x 可以有多个，用逗号分开。

set1={1,2,3,4}
set1.add(5)
print(set1) #{1, 2, 3, 4, 5}
set1.update({6,7}) 
print(set1) #{1, 2, 3, 4, 5, 6, 7}

移除元素：

s.remove( x )：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.discard( x )：也是移除集合中的元素，且如果元素不存在，不会发生错误。

s.pop() ：随机删除集合中的一个元素

set1={1,2,3,4}
set1.remove(3)
print(set1) #{1, 2, 4}
set1.discard(4)
print(set1) #{1, 2}
set1.pop()
print(set1) #{2}

计算集合元素个数：

len(s)：计算集合 s 元素个数。

set1={1,2,3,4}
print(len(set1)) #4

清空集合：

s.clear()：清空集合 s。

set1={1,2,3,4}
print(set1.clear()) #None

字典：

字典 是由一对大括号（{}）包裹着的。和列表不同的是，字典的每个元素是 键值对

字典中的 键 需要是 唯一的，如果字典中有两个相同的 键，Python 只会保留后面那个。而 值 则没有限制，可以是任意类型的，也可以有相同的值。

scores = {
  '林黛玉': 95,
  '薛宝钗': 93,
  '贾宝玉': 78,
  '林黛玉': 78
}
print(scores)
# 输出：{'林黛玉': 78, '薛宝钗': 93, '贾宝玉': 78}

字典的取值：

和列表类似，访问字典中的元素也使用方括号 []。不同的是，列表中括号内的是 索引，字典中括号内的是 键。

scores = {
  '林黛玉': 95,
  '薛宝钗': 93,
  '贾宝玉': 78
}
print(scores['林黛玉'])
# 输出：95

字典元素的修改/添加/删除：

修改和添加都使用 字典名[键] = 值 的方式，如果 键 存在于字典中，就是修改，不存在就是添加。字典元素的删除和列表元素的删除一样也是使用 del 关键字进行删除。

scores = {
  '林黛玉': 95,
  '薛宝钗': 93,
  '贾宝玉': 78
}

# 修改
scores['林黛玉'] = 90
print(scores)
# 输出：{'林黛玉': 90, '薛宝钗': 93, '贾宝玉': 78}

# 添加
scores['袭人'] = 85
print(scores)
# 输出：{'林黛玉': 90, '薛宝钗': 93, '贾宝玉': 78, '袭人': 85}

# 删除
del scores['林黛玉']
print(scores)
# 输出：{'薛宝钗': 93, '贾宝玉': 78, '袭人': 85}

字典常用方法：

get()：

将字典的键作为参数传入 get() 方法中，它就会帮我们查询字典中有没有这个键。如果存在的话，返回键对应的值；不存在的话，默认返回 None。

students = {
  '林黛玉': 95,
  '薛宝钗': 93,
  '贾宝玉': 78,
  '袭人': 85
}
print(students.get('林黛玉'))
# 输出：95
print(students.get('张艺兴'))
# 输出：None

keys()：

keys() 方法则可以获取字典中所有的 键。

students = {
  '林黛玉': 95,
  '薛宝钗': 93,
  '贾宝玉': 78,
  '袭人': 85
}
names = students.keys()
print(names)
# 输出：dict_keys(['林黛玉', '薛宝钗', '贾宝玉', '袭人'])
print(type(names))
# 输出：<class 'dict_keys'>

values()：

与 keys() 方法相对应，我们可以通过 values() 方法获取字典中所有的 值。

students = {
  '林黛玉': 95,
  '薛宝钗': 93,
  '贾宝玉': 78,
  '袭人': 85
}
scores = students.values()
print(scores)
# 输出：dict_values([95, 93, 78, 85])
print(type(scores))
# 输出：<class 'dict_values'>
for score in scores:
  print(score)
# 输出：95 93 78 85

items()：

除了获取所有的键、值，我们也可以通过 items() 方法，一次性获取字典中所有的 键值对 ，其中每个键值对都是一个形如 (键, 值) 的元组。items() 方法返回的也是一个特殊类型，不可索引，可遍历。

students = {
  '林黛玉': 95,
  '薛宝钗': 93,
  '贾宝玉': 78,
  '袭人': 85
}
student = students.items()
print(student)
# 输出：dict_items([('林黛玉', 95), ('薛宝钗', 93), ('贾宝玉', 78), ('袭人', 85)])
print(type(items))
# 输出：<class 'dict_items'>

# 以 name, score 遍历 students 中键值对
for name, score in students.items():
  print('{}的分数是：{}'.format(name, score))

# 输出：
# 林黛玉的分数是：95
# 薛宝钗的分数是：93
# 贾宝玉的分数是：78
# 袭人的分数是：85

字典的嵌套：

列表中嵌套字典：

scores = [
  {'林黛玉': 95, '贾宝玉': 78},
  {'薛宝钗': 93, '袭人': 85}
]

print(scores[0])
# 输出：{'林黛玉': 95, '贾宝玉': 78}

print(scores[0]['林黛玉'])
# 输出：95

字典中嵌套列表：

students = {
  '第一': ['林黛玉', '贾宝玉'],
  '第二': ['薛宝钗', '袭人']
}

print(students['第一'])
# 输出：['林黛玉', '贾宝玉']
print(students['第一'][0])
# 输出：林黛玉

字典中嵌套字典：

dictionary = {
  'apple': {'释义': '苹果', '词性': '名词'},
  'grape': {'释义': '葡萄', '词性': '名词'}
}

print(dictionary['apple'])
# 输出：{'释义': '苹果', '词性': '名词'}
print(dictionary['apple']['释义'])
# 输出：苹果