第三章

列表，元组和字典

• 列表和元组
• 通过索引使用元素
• 通过索引获取子序列
• 列表和元组支持的运算
• 列表和元组的长度、最大值和最小值
• 为列表增加元素
• 为列表删除元素
• 为列表修改元素
• 列表的其他常用方法
• 字典入门和创建字典的方法
• 字典的基本用法
• 字典的常用方法
• 使用字典格式化字符串

---

序列介绍
序列是一种包含多项数据的数据结构，序列包含多个数据项（也叫成员）按顺
排列，可通过索引来访问成员。
Python的常见序列类型包括字符串 、列表和元组等
1.1创建列表和元组

• 列表(list):专门用于存储一串信息,列表用中括号[]定义,数据之间使用逗号,分隔
• 元组(Tuple):与列表类似,不同之处在于元组的元素不能修改,元组的定义使用小括号()定义,数据之间使用逗号,分隔

my_list = ['crazy ',20,'python']
my_tuple = ('crazy ',20,'python')
print(my_list)
# ['crazy ', 20, 'python']
print(my_tuple)
# ('crazy ', 20, 'python')

1.2通过索引使用元素
列表和元组都可通过索引来访问元素，它们的索引都是从0开始的，第1元素的索引为0,第2个元素的索引为1 ...... 依此类推，还支持使用负数索引 ，倒数第1个元素的索引为-1，倒数第2个元素的索引为-2 ……依此类推

print(my_list[0])
# crazy
print(my_tuple[0])
# crazy
print(my_list[-1])
# python
print(my_tuple[-1])
# python

1.3切片
除了通过索引来获取当个元素外，我们也可以通过切片来获取一定范围内的元素。比如获取从索引值为2到索引值为7的元素。使用两个索引并用冒号分隔。且遵循包前不包尾的规则。
列表

month=["january","february","match","aprill","may","june","july","august","september","october","november","december"]
#包头不包尾
number=month[2:3]
#而要访问包括最后一个元素，可以使用
number_end=month[2:12]
number_nege=month[-3:-1]
print("number:{}".format(number))
# number:['match']
print("number_end:{}".format(number_end))
# number_end:['match', 'aprill', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december']
print("number_nega:{}".format(number_nege))
# number_nega:['october', 'november']

元组

tuple = (1, 2 , 3 , 4 , 5 , 6 , 7 , 8, 9) 
print(tuple[2 : 8 : 2]) 
# (3 , 5 , 7) 
# 访问从第3个到第8个（不包含）、 间隔为2的所有元素
print (tuple [2 : 8 : 3]) 
# (3 , 6 ) 
# 访问从第3个到第8个（不包含）、间隔为3的所有元素
print (tuple [2 : - 2 : 2] ) 
# (3, 5 , 7 )
# 访问从第3个到倒数第2个〈不包含）、间隔为2的所有元素

1.4加法
列表和元组支持加法运算，加法的和就是两个列表或元组所包含的元素的总和

a_tuple=('crazyit' , 20 , 1.2)
b_tuple=(127 ,'crazyit','fkit', 3.33)

sum_tuple = a_tuple + b_tuple
print (sum_tuple) 
# ('crazyit', 20, 1.2, 127, 'crazyit', 'fkit', 3.33)print(a_tuple) 

print (a_tuple)
# ('crazyit', 20, 1.2)
# a_tuple 并没有改变

print(b_tuple) 
# (127, 'crazyit', 'fkit', 3.33)
# b_tuple 并没有改变

print (a_tuple + (- 20 , -30)) 
# ('crazyit', 20, 1.2, -20, -30)

a_list = [20 , 30 , 50 , 100]
b_list = [ 'a ','b ','c ' ]

sum_list = a_list + b_list
print (sum_list)
# [20, 30, 50, 100, 'a ', 'b ', 'c ']
print(a_list + [ 'fk']) 
# [20 , 30 , 50 , 100 , 'fk' ]

注意：元组和列表不能直接相加

print(a_tuple + [- 20 , - 30])

TypeError: can only concatenate tuple (not "list") to tuple

1.5乘法
列表和元组可以和整数执行乘法运算，列表和元组乘法的意义就是把它们包含的元素重复n次，n就是被乘的倍数。

a_tuple = ('crazyit', 20)
mul_tuple = a_tuple * 3
print(mul_tuple)
# (’ crazyit’, 20,’crazyit ’, 20,’crazyit ’, 20 )
a_list = [30 , 'Python', 2]
mul_list = a_list * 3
print(mul_list)
# [30, 'Python', 2, 30, 'Python', 2, 30, 'Python', 2]

也可以对列表、元组同时进行加法、乘法运算
1.6 in 运算符

a_tuple = ('c', 20, 1.2)
print(20 in a_tuple) 
# True
print(12.2 in a_tuple) 
# False
print('fk' not in a_tuple) 
# True

1.7长度、最大值和最小值
Python 提供了内置的len(), max(), min()全局函数来获取元组或列表的长度、最大值和最小值

# 元素都是数值的元组
a_tuple= (20 , 10 , -2 , 15.2 , 102 , 50)
# 计算最大值
print(max(a_tuple)) # 102
# 计算最小值
print(min(a_tuple)) # -2
# 计算长度
print(len(a_tuple)) # 6
# 元素都是字符串的列表
b_list = ['crazyit', 'fkit', 'Python','Kotli']
# 计算最大值（依次比较每个字符的ASCII码值，先比较第1个字符，若相同，再比较第2个字符,依此类推）
print(max(b_list)) # fkit 
# 计算最小值
print(min (b_list)) # Kotli 
# 计算长度
print(len(b_list)) # 4

1.8序列封包和序列解包
Python提供了序列封包和序列解包功能，可以实现：
将多个值赋给一个变量时，Python会自动将多个值封装成元组。这个功能就称为序列封包；
允许将序列（元组或者列表等）直接赋值给多个变量，此时序列的各元素被依次赋值给每一个变量，此处要求序列的元素个数和变量个数相等，这个功能就成为序列解包。
序列封包示例，将1、2、3封装成元组后赋值给nums

nums = 1, 2, 3
print(nums)
# (1, 2, 3)
print(nums[0])
# 1

序列解包，将tuple_temp的各元素依次赋值给a, b, c, d, e

tuple_temp = tuple(range(1, 10, 2))
print(tuple_temp)
# (1, 3, 5, 7, 9)
a, b, c, d, e = tuple_temp
print(a, b, c, d, e)
# 1 3 5 7 9

将序列封包和序列解包同时运用，就可以让赋值运算符支持同时将多个值赋值给多个变量

a, b, c = 1, 2, 3
print(a, b, c)
# 1 2 3
# 先进行序列封包，将a、b、c封装到元组abc中
abc = a, b, c
print(abc)
# (1, 2, 3)

序列解包时，可以解出部分变量，剩下的依然使用列表变量保存。为了这样操作，Python允许在左边被赋值的变量之前添加“*”，那么该变量就代表一个列表，可以保存多个集合元素

a, b, *restnum = range(10)
print(a)
# 0
print(b)
# 1
print(restnum)
# [2, 3, 4, 5, 6, 7, 8, 9]

*frontnum, lastnum = range(10)
print(frontnum)
# [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(lastnum)
# 9
frontnum, *middlenum, lastnum = range(10)
print(frontnum)
# 0
print(middlenum)
# [1, 2, 3, 4, 5, 6, 7, 8]
print(lastnum)
# 9

2.1列表操作
列表与元组最大的区别在于：元组是不可改变的，列表是可改变的 。元组支持
的操作，列表基本上都支持 ；列表支持对元素的修改，而元组则不支持。

• 增加列表元素
  列表增加元素可调用列表的append()方法，该方法会把传入的参数追加到列表的最后面

list = [ 'crazyit' , 20 , - 2]
# 追加元素
list.append('fif')
print(list)
# ['crazyit', 20, -2, 'fif']
tuple= (3.4, 5.6)
# 追加元组，元组被当成一个元素
list.append(tuple)
print(list)
# ['crazyit', 20, -2, 'fif', (3.4, 5.6)]
# 追加列表，列表被当成一个元素
list.append ( ['a', 'b'])
print(list) 
# ['crazyit', 20, -2, 'fif', (3.4, 5.6), ['a', 'b']]

从上面代码可以看出，为列表追加另一个列表时，Python 会将被迫加的列表当成一个整体的元素，而不是追加目标列表中的元素。
如果希望不将被追加的列表当成一个整体，而只是追加列表中的元素，则可使用列表的 extend() 方法

b_list = ['a', 30]
# 追加元组中的所有元素
b_list.extend((-2, 3.1))
print(b_list)
# ['a', 30, -2, 3.1]
# 追加列表中的所有元素
b_list.extend(['C', 'R', 'A'])
print(b_list)
# ['a', 30, -2, 3.1, 'C', 'R', 'A']
# 追加区间中的所有元素
b_list.extend(range(97, 100))
print(b_list)
# ['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

此外，如果希望在列表中间增加元素，则可使用列表的 insert() 方法，使用 insert() 方法时要指定将元素插入列表的哪个位置

list= list(range(1 , 6))
print(list)
# [l , 2 , 3 , 4 , 5]
# 在索引３处插入字符串
list.insert(3,'CRAZY')
print(list)
# [1, 2, 3, ’CRAZY’, 4, 5]
# 在索引3处插入元组，元组被当成一个元素
list.insert(3, tuple ('crazy' ))
print (list)
# [1 , 2 , 3 , (’ c ',’r ’,’a ’,’ z ’ , ’ y’ ) ,’CRAZY ’ , 4 , 5]

• 删除列表元素
  删除列表元素使用del语句，del语句是python的一种语句，专门用于执行删除操作，不仅可以用于删除列表的元素，也可用于删除变量等

list= [1 , 2 , 3 , ('c', 'B' ) , 4 , 5]
del list[3]
#删除第四个元素
print(list)
# [1, 2, 3, 4, 5]
del list[3:6]
#删除第四个到第六个（不包含〉元素
print(list)
# [1, 2, 3]

• 修改列表元素
  列表的元素相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素

service = ['https','ftp','ssh','mysql']
# 通过索引，重新赋值
service[0] = 'http'
print(service)
# ['http', 'ftp', 'ssh', 'mysql']
# 通过切片赋值
service[:2] = ['samba','dns','firewalld']
print(service)
# ['samba', 'dns', 'firewalld', 'ssh', 'mysql']

• 列表的其他常用方法
  使用dir查看list方法

print(dir(list))
# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', 
#  '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', 
#  '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
#  '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 
#  'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

常用方法
1.count：统计列表中某个元素出现的次数

alist = [1, 1, 3, 2, 1, 4, 5]
print(alist.count(1))
# 3

2.index：判断某个元素在列表中出现的位置

print(alist.index(4))
# 5

3.pop：将在列表中移除指定索引位置的元素，且会返回移除元素的值

print(alist.pop(5))
# 4

4.reverse：将列表中的元素反向排列，返回空

alist = [1, 1, 3, 2, 1, 4, 5]
alist.reverse()
print(alist)
# [5, 4, 1, 2, 3, 1, 1]

5.sort：对列表按进行排序
该方法除支持默认排序之外，还可传入 key，reverse 两个参数，而且这两个参数必须通过参数名指定

alist.sort()
print(alist)
# [1, 1, 1, 2, 3, 4, 5]
a=['a', 'bb', 'dddd', 'ccc']
a.sort(key=len)
print(a)
#a输出结果[‘a’, ‘bb’, ‘ccc’, ‘dddd’]

2.2使用字典
Python中的字典属于散列类型，其数据内容是以键值对的形式存在。{key:value}的形式，其中，key值是不可变类型，value是可变类型。key值不能相同，但是value可以相同，若key值相同，则无法存入字典，可以通过key值修改字典value，直接通过键值添加。

d = {'a': 1233, 'b':3555, 'c':56644}
print(d)
# {'a': 1233, 'b': 3555, 'c': 56644}
empty_dict = {}
# 空的花括号代表空的
d2 = {(20, 30): 'good', 30 :'bad'}
# 使用元组作为key
print(d2)
# {(20, 30): 'good', 30: 'bad'}

需要指出的是，元组可以作为 key ，但列表不能作为元组的 key
这是由于字典要求 key必须是不可变类型，但列表是可变类型，因此列表不能作为元组的 key

• 字典的基本用法
  通过 key 访问 value

d = {'a': 1233, 'b':3555, 'c':56644}
print(d['a'])
# 1233

通过 key 添加 key value

d['aa'] = 45678
print(d)
# {'a': 1233, 'b': 3555, 'c': 56644, 'aa': 45678}

通过 key 删除 key value 对

del d['b']
print(d)
{'a': 1233, 'c': 56644, 'aa': 45678}

通过 key 修改 key value

d = {'a': 1233, 'b':3555, 'c':56644}
d['a'] = 0
print(d)
# {'a': 0, 'b': 3555, 'c': 56644}

通过 key 判断指定 key value对是否存在

print('b' in d)
# True

• 字典的常用方法
  1.clear()方法
  clear()方法，用于清除字典中所有的项。

d = {'a': 1233, 'b':3555, 'c':56644}
d.clear()
print(d)
# {}

2.get()方法
get()方法，用于访问字典项的方法，当访问一个不存在的键时，没有任何异常，而得到一个默认值None，也可以自定义默认值

print(d.get('r'))
# None

3.update()方法
update()方法，将一个字典更新到另一个字典中

d = {'a': 1233, 'b':3555, 'c':56644}
d.update({'f':897654, 'c':3})
print(d)
# {'a': 1233, 'b': 3555, 'c': 3, 'f': 897654}

4. items()方法
   items()方法, 获取字典中所有的key value，返回dict_items对象

d.items()
print(d.items())
# dict_items([('a', 1233), ('b', 3555), ('c', 3), ('f', 897654)])

5.keys()方法
keys()方法，获取字典中所有的key

print(d.keys())
# dict_keys(['a', 'b', 'c', 'f'])

6.values()方法
values()方法, 获取字典中所有的values

print(d.values())
# dict_values([1233, 3555, 3, 897654])

7.pop()方法
pop()方法, 用于获取指定key 对应的value ，并删除这个key value对

print(d.pop('c'))
print(d)
# {'a': 1233, 'b': 3555, 'f': 897654}

8.popitem()方法
popitem()方法，用于随机移除字典中项，并返回被移除的项,因为字典中没有最后一项的说法，所有的项都是随机排序。

print(d.popitem())
# ('f', 897654)
print(d)
# {'a': 1233, 'b': 3555}

9.setdefault()方法
setdefault()方法，用于获取字典指定键的值，与get方法类似，不过，如果字典中无该键，则将其添加到字典中

d = {'a': 1233, 'b':3555, 'c':56644}
d.update({'f':897654, 'c':3})
d.setdefault('er')
print(d)
# {'a': 1233, 'b': 3555, 'c': 3, 'f': 897654, 'er': None}
# 如果没有则将添加到字典中，值默认为None

10.fromkeys()方法
fromkeys()方法，用于给定的键，建立新的字典，因此每个键都对应一个默认的值None

d1 = dict.fromkeys(['a', 'b'])
print(d1)
# {'a': None, 'b': None}