疯狂Python讲义学习笔记（含习题）之 列表、元组和字典

列表和元组都按顺序保持元素，每个元素都有自己的索引。字典以key-value形式保存数据。

一、序列简介

序列是指一种包含多项数据的数据结构，序列包好的多个数据项（也叫成员）按顺序排列，可以通过索引来访问成员。

（一）Python的序列

常见序列：字符串、列表、元组。

序列和元组的关系就是可变和不可变的关系。

（二）创建列表和元组

创建列表使用方括号，创建元组使用圆括号，并在括号中列出元素，元素之间以英文逗号隔开。

 

二、列表和元素的通用用法

只要不涉及改变元素的操作，列表和元组的用法是通用的。

（一）通过索引使用元素

列表和元组的索引都是从0开始，同时也支持负数索引，倒数第1个元素的索引为-1.

列表的元素相当于一个变量，程序即可以使用它的值，也可以对元素赋值；元组的元素相当于一个常量，程序只能使用它的值，不能重新赋值。

a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
print(a_tuple)
# 访问第一个元素
print(a_tuple[0])    # crazyit
# 访问第二个元素
print(a_tuple[1])    # 20
# 访问倒数第一个元素
print(a_tuple[-1])    # -17
# 访问倒数第二个元素
print(a_tuple[-2])    # fkit

（二）子序列

slice（分片或切片）语法格式：

[start: end: step]

start、end两个索引值都可以使用正数或负数，step表示步长。

a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
# 访问从第2个到第4个（不包含）的所有元素
print(a_tuple[1:3])    # (20, 5.6)
# 访问从倒数第3个到倒数第1个（不包含）的所有元素
print(a_tuple[-3:-1])    # (5.6, 'fkit')
# 访问从第2个到倒数第2个（不包含）的所有元素
print(a_tuple[1:-2])    # (20, 5.6, 'fkit')
# 访问从倒数第3个到第5个（不包含）的素有元素
print(a_tuple[-3:4])    # (5.6, 'fkit')

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

（三）加法

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

列表只能和列表相加；元素只能和元组相加；元组不能直接和列表相加。

a_tuple = ('crazyit', 20, -1.2)
b_tuple = (127, 'carzyit', 'fkit', 3.33)
# 计算元组相加
sum_tuple = a_tuple + b_tuple
print(sum_tuple)    # ('crazyit', 20, -1.2, 127, 'crazyit', 'fkit', 3.33)
print(a_tuple)    # a_tuple没有变化
print(b_tuple)    # b_tuple没有变化

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']

（四）乘法

列表和元组可以和整数执行乘法运算，结果就是把他们包含的元素重复N次——N被乘的倍数。

（五）in运算符

in运算符用于判断列表或元组是否包含某个元素。如果包含返回True，否则返回False。

（六）长度、最大值和最小值

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

传给max()、min()函数的元组列表必须是相同类型且可以比较大小的。

默认情况下，Python依次按字符串中每个字符对应的编码来比较字符串的大小。

（七）序列封包和序列解包

● 程序把多个值赋给一个变量时，Python会自动将多个值封装成元素。——序列封包（Sequence Packing）

● 将序列（元组或列表）直接赋值给多个变量，序列的个元素会一次赋值给每个变量（元素个数和变量个数必须相等）——序列解包（Sequence Unpacking）

Python允许在左边被赋值的变量之前添加“*”，表示该变量是一个列表，可以保存多个集合元素。

# first、sencond保存前两个元素，rest列表包含剩下的元素
first, sencond, *rest = range(10)
print(first)    # 0
print(sencond)    # 1
print(rest)    # [2, 3, 4, 5, 6, 7, 8, 9]

# last保存最后一个元素，begin保存前面剩下的元素
*begin, last = range(10)
print(begin)    # [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(last)     # 9

# first保存第一个元素，last保存最后一个元素，middle保存剩下的元素
first, *middle, last = range(10)
print(first)    # 0
print(middle)    # [1, 2, 3, 4, 5, 6, 7, 8]
print(last)    # 9

三、使用列表

（一）创建列表

可以使用方括号创建列表之外，还可以使用list()函数来创建列表，list()函数可以将元组、区间（range）等对象转换为列表。

a_tuple = ('crazyit', 20, -1.2)
# 将元组转换为列表
a_list = list(a_tuple)
print(a_list)
# 使用range()函数创建区间（range）对象
a_range = range(1, 5)
print(a_range)    # rane(1, 5)
# 将区间转换为列表
b_list = list(a_range)
print(b_list)    # [1, 2, 3, 4]
# 创建区间时还指定了步长
c_list = list(range(4, 20, 3))
print(c_list)    # [4, 7, 10, 13, 16, 19]

※ python2.x提供了一个xrange()函数，该函数与Python3.x中的range()函数基本相同。Python2.x也提供了range()函数，但是该函数返回列表。

Python也提供了一个tuple()函数，可以将列表、区间（range）等对象转换为元组。

（二）增加列表元素

调用列表的append()方法会把传入的参数追加到列表的最后。该方法可以接收单个值，也可以接收元组、列表等，注意，如果传入的是元组或列表，该方法只会将元组、列表当成单个元素，这样就会形成列表中嵌套列表或元组的情况。如果希望不将被追加的列表当成一个整体，而只是追加列表中的元素，则可以使用extend()方法。如果希望在列表中间添加元素，可以使用insert()方法，指定将元素插入列表的哪个位置。

（三）删除列表元素

使用del语句可以删除列表元素，既可以删除列表中的单个元素，也可以直接删除列表的中间一段。

使用del语句不仅可以删除列表元素，也可以删除普通变量。

Python还提供了remove()方法来删除列表元素，该方法并不是根据索引来删除元素的，而是根据元素本身来执行删除操作的，该方法只删除第一个找到的元素，如果找不到该元素，就引发ValueError异常。

列表还包含一个clear()方法，用于清空列表的所有元素。

（四）修改列表元素

直接对相应的列表元素重新赋值即可修改对应的列表元素。

（五）列表的其他常用方法

● count()：用于统计列表中某个元素出现的次数

● index()：用于判断某个元素在列表中出现的位置

● pop()：用于将列表当成“栈”使用，实现元素的出栈功能。

● reverse()：用于将列表中的元素反向存放

● sort()：用于对列表元素排序。

 

四、使用字典

字典用于存放具有映射关系的数据。

（一）字典入门 

(二）创建字典

可以使用花括号语法来创建字典，也可以使用dict()函数来创建字典。

使用花括号语法创建字典时，花括号中应包含多个key-value对，key与value之间用英文冒号隔开；多个key-value对之间用英文逗号隔开。

元组可以作为dict的key而列表不行。

使用dict()函数创建字典时，可以传入多个列表或元组参数作为key-value对，每个列表或元组将被当成一个key-value对，因此这些列表或元组只能包含两个元素。

可以通过为dict指定关键字参数创建字典，此时字典的key不允许使用表达式。

（三）字典的基本用法

如果要为dict添加key-value对，只需为不存在的key赋值即可。

如果要删除字典中的key-value对，可以使用del语句。

对已存在的key-value对赋值，会修改原key-value对。

要判断字典是否包含指定的key，可以使用in或not in运算符。

列表不允许对不存在的索引赋值，但字典则允许直接对不存在的key赋值。

（四）字典的常用方法

● clear()：用于清空字典中所有的key-value对，对一个字典执行clear()方法后，该字典就会变为一个空字典。

● get()：根据key来获取value，相当于方括号语法的增强版——使用方括号语法访问不存在的key会引发KeyError异常，使用get()访问不存在的key会返回None值。

● update()：使用一个字典所包含的key-value对来更新已有字典，如果被更新的字典中已包含对应的key-value对，则原value会被覆盖，如果不包含对应的key-value对，则该key-value对被添加进去。

● items()、keys()、values()分别用于获取字典中的所有key-value对、所有key、所有value。依次返回dicit_items、dict_keys和dict_value对象，Python不希望用户直接操作这几个方法，但可通过list()函数把他们转换成列表。

※ 在Python2.x中，以上三个方法的返回值本来就是列表，完全可以不用list()函数进行处理，当然，使用list()也可以，列表被处理后依然是列表。

● pop()：用于获取指定key对应的value，并删除这儿key-value对。

● popitem()：随机弹出字典中的一个key-value对。

● setdefault()：根据key来获取对应的value值，当程序要获取的key在字典中不存在时，该方法会先为这个不存在的key设置一个默认的value，然后再返回该key对应的value。

● fromkeys()：使用给定的多个key创建字典，这些key对应的value默认都是None；也可以额外传入一个参数作为默认的value。该方法一般不会使用字典对象调用，通常会使用dict类直接调用。

（五）使用字典格式化字符串

# 在字符串模板中使用key
temp = '书名是:%(name)s, 价格是:%(price)010.2f, \
出版社是:%(publish)s'
book = {'name': '疯狂Python讲义', 'price': 88.9, 'publish': '电子社'}
# 使用字典为字符串模板中的key传入值
print(temp % book)
book = {'name': '疯狂Kotlin讲义', 'price': 78.9, 'publish': '电子社'}
# 使用字典为字符串模板中的key传入值
print(temp % book)

 

习题：

1. 提示用户输入N 个字符串，将它们封装成元组，然后计算并输入该元组乘以3 的结果，再计算并输出该元组加上（’fkjava’，’crazyit＇）的结果。

a_tuple = tuple(input('请输入N个字符串，以空格隔开：').split())
b_tuple = a_tuple * 3
c_tuple = b_tuple + ('fkjava', 'crazyit')
print('用户输入元组为：', a_tuple)
print('乘以3后的结果为：', b_tuple)
print("加上('fkjava', 'crazyit')的结果为：", c_tuple)

2. 给定一个list，将该列表的从start 到end 的所有元素复制到另一个list 中。

a_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
start = int(input('请输入start值（0-9）：'))
end = int(input('请输入end值（0-9）：'))
copy_list = a_list[start: end]
print(copy_list)

3. 用户输入一个整数n ，生成长度为n 的列表，将n 个随机数放入列表中。

import random


n = int(input('请输入N值：'))
a_list = []
for i in range(n):
    num = random.random()
    a_list.append(num)
print(a_list)
a_list = [random.randint(0, 100) for i in range(n)]
print(a_list)

4. 用户输入一个整数n ，生成长度为n 的列表，将n 个随机的奇数放入列表中。

import random


n = int(input('请输入N值：'))
a_list = []
for i in range(n):
    num = random.randint(0, 100) * 2 + 1
    a_list.append(num)
print(a_list)
a_list = [random.randint(0, 100) * 2 + 1 for i in range(n)]
print(a_list)

5. 用户输入一个整数n ，生成长度为n 的列表，将n 个随机的大写字符放入列表中。

import random


n = int(input('请输入N值：'))
a_list = []
for i in range(n):
    a_char = random.randint(65, 65 + 25)
    a_list.append(chr(a_char))
print(a_list)
a_list = [chr(random.randint(65, 65+25)) for i in range(n)]
print(a_list)

6. 用户输入N 个字符串，将这些字符串收集到列表中，然后去除其中重复的宇符串后输出列表。

a_list = input('请输入多个字符串，以空格分隔：').split()
# 使用集合可以快速清除重复项
a_set = set(a_list)
b_list = list(a_set)
print(b_list)

# 使用比较的方法去除重复项
b_list = []
for i in a_list:
    if i not in b_list:
        b_list.append(i)
print(b_list)

# 使用字典的fromkeys方法
b_list = list({}.fromkeys(a_list).keys())
print(b_list)

7. 用户输入以空格分隔的多个整数，程序将这些整数转换成元组元素，并输出该元组及其Hash值（使用内置的hash 函数）。

num_list = input('请输入以空格分隔的多个整数：').split()
# 将元组中的元素转换为数值类型
num_tuple = tuple(int(x) for x in num_list)
print(num_tuple)
print(hash(num_tuple))

8 . 用户随机输入N 个大写字母，程序使用dict 统计用户输入的每个字母的次数。

char_list = input('请输入N个大写字母，以空格分隔:').split()
char_dict = {}.fromkeys(char_list)
# print(char_dict)
for char in char_dict.keys():
    char_dict[char] = char_list.count(char)
for key, value in char_dict.items():
    print('%s 出现了 %d次' % (key, value))