python语言基础（六）列表、元组、字典、集合

列表（list）

列表介绍(掌握)

列表好比是盒子，把班级的学生的名字都放到盒子里。
列表是 Python 中最基本也是最常用的数据结构之一，它是一个 有序可重复的元素集合，是序列。从数据结构角度看，Python 的列表是一个 可变长度 的顺序存储结构，每一个位置存放的都是对象的指针。用[]定义，内的元素用“,”隔开
我们可对列表进行 修改、切片、追加、删除、嵌套、迭代、成员判断 等操作。

列表创建(掌握)

创建一个列表，只要把 逗号 分隔的 不同的数据元素 使用 方括号 括起来即可 。
除此之外，我们还可以直接通过 list() 来进行创建列表

# 方式1：以英文状态下的 一对方括号 创建空的列表
li_1 = []
print(type(li_1))  # --> <class 'list'>

li_2 = ["clara", 21, 20.5, True, 21]   # -->元素可以是任意类型的,可以重复
print(type(li_2),li_2)   # --><class 'list'> ['clara', 21, 20.5, True, 21]

#方式2：list()
print(list())     # --> []  空的列表
# list(iterable)   # --> 可迭代的意味着可以将元素逐个取出
print(list("hello"))  # --> ['h', 'e', 'l', 'l', 'o']
print(list(1234567))   # --> 报错，整数不是序列类型，是整体存储，不是可迭代的。
print(list("1234567"))   # --> ['1', '2', '3', '4', '5', '6', '7']

注意：

• 变量名最好不使用 list
• 列表里的 元素 可以是 任意类型
• iterable 表示 可迭代的对象，简单来说就是可以一个一个元素取出来的。比如：str

访问(查)列表内的元素(掌握)

查的方法跟字符串一样，下标默认从0开始，超过索引范围会报错。
列表 从0开始 为它的每一个元素顺序创建 下标索引，直到 总长度减一 。要访问它的某个元素，以方括号加下标值的方式即可。
注意要确保索引不越界，一旦访问的 索引超过范围，会抛出异常。所以，一定要记得最后一个元素的索引是 len(list)-1。
思考：
li = [1,2] 是如何取出元素的呢？print(li[0])，print(li[1])

修改列表内的元素(掌握)

直接 取出元素 进行 重新赋值
思考：
li = [‘a’,‘b’,‘c’] 是怎么将 ‘a’ 改为 ‘A’。
列表是可变的序列，从列表中取出a，再把A赋值给li[0]。

li = list('abc') # --> ['a', 'b', 'c'] 
li[0] = 'A'
print(li)  # --> ['A', 'b', 'c']

删除列表内的元素(掌握)

直接 取出元素，再通过 del语句 或者 list.remove() 或者 list.pop() 进行删除
列表大多数都是改变列表本身的。
del.li[索引]，若无索引，则删除列表
li.remove(‘元素’)，改变列表本身，没有返回值，打印查看
li.pop(索引)，若无索引，默认从最后一个删除，打印查看

li = list('abcde')
del li[1]   # -->按照索引删除，['a', 'c', 'd', 'e']
del li      # -->删除整个列表。NameError: name 'li' is not defined
print(li)
# renmove 以值来删除，改变的是列表本身，没有返回值
li.remove('c')  # -->print(li.remove('c'))，没有返回值
print(li)   # -->按照元素删除，['a', 'b', 'd', 'e']

print(li.pop(3))  # -->d，按照索引删除
print(li.pop())    # -->e，默认从最后一个删除
print(li)    # -->删除最后一个元素后，返回的列表['a', 'b', 'c', 'd']

列表的特殊操作(熟悉)

列表相加，注意：不是对应位置相加，而是拼接。
与整数相乘，扩展列表，重复列表的内容，注意：是列表与列表不能相乘。
列表只能是拼接和倍数的展开，不能相加减、相除等等。
成员判断
元素是否在列表内，in，not in
迭代，for遍历列表中的每一个元素，
for i in li
print i，快速的取出每一个元素。

常用内置函数(熟悉)

len()，返回长度
max()，返回最大值
min()，返回最小值

python内置的方法或函数：
print(type(len))  #--> builtin_function_or_method
print(type(max))  #--> builtin_function_or_method
print(type(min))  #--> builtin_function_or_method

li = list("abcde")
print(len(li))  #--> 5,返回长度，也可以理解为元素的个数

# 字符串与字符串比较ascii，逐个比较
print(max(li))    # e

print(min(li))    # a


li_2 = ['a','c', 2, 1]
print(max(li_2))    # 报错：int 与 str 不能使用>或者<进行比较

小贴士：

• 字符串与字符之间比较转为 ascii
• 字符串与整数比较报错
• 以上方法都是 python 内置方法

列表的排序与反转(熟悉)

list.reverse()；list.[::-1]，将列表反转
list.sort(reverse=Fasle),排序，默认升序
list.sort(reverse=True),排序，降序

逆序与排序
li_3 = [1, 2, 34, 4, 5, 6, 4, 7, 10]

# 将整个列表逆序取出
print(li_3[::-1])  # --> [10, 7, 4, 6, 5, 4, 34, 2, 1]
# L.reverse()-->逆序取出，没有返回值
li_3.reverse()  # --> 没有返回值
print(li_3)		# --> [10, 7, 4, 6, 5, 4, 34, 2, 1]

# 需求：将li_3进行排序
# L.sort()默认是升序
li_3.sort()   # --> [1, 2, 4, 4, 5, 6, 7, 10, 34]
li_3.reverse() # --> 升序后的结果反转
# print(li_3[::-1])  # 将升序后的结果用切片进行逆序，也得到降序的结果
print(li_3)   # --> 得到降序的结果[34, 10, 7, 6, 5, 4, 4, 2, 1]

# L.sort(reverse=True) 将升序排序后的结果反过来-->降序
li_3.sort(reverse=True)
print(li_3)   # --> 得到降序的结果[34, 10, 7, 6, 5, 4, 4, 2, 1]

列表的切片(重点掌握)

slice(start, stop[, step])，切片，左闭右开，步长不能位浮点数，也不能位0。

思考：
li = [1,2,3,4,5,6,7] 取 [2,3,4] 以及取出 [2,4,6]

li = list("1234567")

# [2,3,4]
# 切片的话是以英文状态下的冒号进行分开，L[start:stop:step]
# 起始位置为0，结束位置默认取到最后一位。取值为左闭右开。步长默认为1，不能为浮点数不能为0
print(li[1:3])     # --> ['2', '3']
print(li[1:4:1])   # --> [2,3,4]，或者 print(li[1:4]) 

# [2,4,6]
print(li[1:6:2])  # --> [2,4,6]
print(li[1::2])   # --> [2,4,6]
多重列表取值
li_2 = [1, 2, 3, ["amy", 1]]

# 从li_2中取出"amy"
print(li_5[3][0])  # --> amy

列表常见操作(熟悉)

增加：
L.append(object) --> 在列表末尾添加新的对象，改变列表本身，需要打印列表
L.insert(index, object) --> 在指定位置将对象插入列表
L.extend(iterable) --> 用新列表扩展原来的列表，只能传递可迭代的对象（列表、字符串），不能传入单个值
L.copy() --> 复制列表
修改：
L[索引] = 数据 --> 修改指定索引的数据
删除
L.pop([index]) --> 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
L.remove(value) --> 移除列表中某个值的第一个匹配项
L.clear() --> 清空列表
del L[索引] --> 删除指定索引的数据，删除后数据不存在了；如果没有索引，删除整个列表
查找：
L.index(value） --> 从列表中找出某个值第一个匹配项的索引位置
统计：
L.count(object) --> 统计某个元素在列表中出现的次数，列表里嵌套列表，则嵌套的列表作为整体，里面的元素不做统计
len(L) --> 列表长度
排序：
L.reverse() --> 反向，逆序列表中元素
L.sort(reverse=False) --> 对原列表进行降序排序
L.sort() --> 对原列表进行升序排序

li = list('12345')
li.append(4)  # ['1', '2', '3', '4', '5', 4]
li.append([5, 5, 6])  # ['1', '2', '3', '4', '5', [5, 5, 6]],追加元素
li.extend([5, 5])  # ['1', '2', '3', '4', '5', 5, 5]，扩展列表，传入可迭代对象
print(li)
# 列表中插入元素
li3 = ["happy","year"]
li3.insert(1, "new")  # ['happy', 'new', 'year'，先放位置，再放插入的内容
print(li3)

# 统计3出现的次数
li1 = [1, 2, 3, [3, 3]]
print(li1.count(3))  # 1，列表是个整体，元素3只出现1次，返回整数
# 元素的索引位置
li2 = [1, 2, 3, 2, 3, 2]   # 2，返回3在列表中的最小的索引位置
print(li2.index(3))

li4 = [1, 2, 3]
del li4   #  name 'li4' is not defined，删除列表，整个列表不存在了
del li4[1]  #  [1, 3]，删除元素
li4.clear()  # [] ，清空列表，返回的是个空列表
print(li4)

元组(tuple)

元组介绍(掌握)

元组也是 序列结构，但是是一种 不可变序列，你可以简单的理解为内容不可变的列表。除了在内部元素不可修改的区别外，元组和列表的用法差不多。

元组创建(掌握)

创建一个元组，只要把 逗号 分隔的 不同的数据元素 使用 小括号 括起来即可。我们还可以直接通过 tuple() 来进行创建元组。

tu = ()
print(type(tu))  # <class 'tuple'>，空元组
tu1 = (123)
print(type(tu1), tu1)  # <class 'int'> 123，传入的是可迭代对象，整数不行
tu2 = (223,)
print(type(tu2), tu2)  # <class 'tuple'> (223,)，只有1个元素的时候，必须加上逗号，
tu3 = tuple("1234")
print(type(tu3), tu3)  # <class 'tuple'> ('1', '2', '3', '4')，传入可迭代(iterable)的对象

元组与列表相同的操作(熟悉)

• 使用 方括号加下标 访问元素
• 切片（形成新元组对象）
• 只有两种方法：tuple.count() / tuple.index()
• 使用python内置函数：reversed()，sorted()来实现排序和反转
• 加法及乘法，跟列表一样，实现的是拼接和扩展，元组间不能相加减乘除

tu = tuple("123454545")
print(tu[1])  # 2 下标索引取值
print(tu[2:4])  # ('3', '4') 切片取值
print(tu.count('5'))  # 3 数字5出现的次数
print(tu.index('5'))  # 4 第一个数字5的索引

# 元组只有 count和index方法，如何实现反转也逆序呢？
tu1 = (4, 3, 2, 5)
print(tu1[::-1])     # 反转 (5, 2, 3, 4)
print(tuple(reversed(tu1)))  # 反转 (5, 2, 3, 4)
print(list(reversed(tu1)))  # 反转 [5, 2, 3, 4],返回列表
print(sorted(tu1))   # 排序，返回的是列表 [2, 3, 4, 5]，默认是False，从小到大
print(sorted(tu1, reverse=True))   # 排序，返回的是列表 [5, 4, 3, 2]，从大到小

tu2 = (1, 2, 3)
tu3 = (3, 4, 5)
print(tu2 + tu3)  # (1, 2, 3, 3, 4, 5) 拼接
print(tu2 * 3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3) 扩展

元组中不允许的操作(熟悉)

元组是不可变类型，只能进行访问，查找。数据分析时需要传入不可变的参数。元组所消耗的内存比列表要小，当传入的元素不需要改变的时候，推荐使用元组；传入的元素需要改变的时候使用列表。

• 不允许 修改 、新增 元素。(一级元素是元组时候不可修改)，可以拼接成新元组
• 不允许 删除 某个元素（但可以删除整个元组）

tu = (1, 2, 3, 4)
tu[1] = 2  # 不可修改元素
print(tu)

tu1 = tu + (5,)
print(tu1)   # (1, 2, 3, 4, 5) 可以进行拼接，组成一个新的元组，而不能修改元组中的元素
print(id(tu))  # 1815815693560
print(id(tu1))  # 1815813796440 内存地址不一样，相当于新建了一个元组


tu1 = (1, 2, 3, ["name", 6])  # 可以修改，仅在一级元素是元组的时候不允许修改。
tu1[3][0] = 5
print(tu1)  # (1, 2, 3, [5, 6])

tu1 = (1, 2, 3, ("name", 6))  # 不可以修改
tu1[3][0] = 5
print(tu1)  # TypeError: 'tuple' object does not support item assignment

del tu1[1]  # 不支持删除元素，TypeError: 'tuple' object doesn't support item deletion
del tu1   # 删除了整个元组，元组就不存在了。NameError: name 'tu1' is not defined
print(tu1)

实际上，元组没有任何会对内部元素发生 修改 动作的方法。例如，元组没有remove，append，pop 等方法

元组与列表之间的转换(掌握)

#元组转为列表
tu = (1, 2, 3)
print(list(tu))  # [1, 2, 3]

# 列表转元组
li = [0, 1, 2, 3]
print(tuple(li))  #(0, 1, 2, 3)

字典(dict)

字典介绍(掌握)

Python 的字典数据类型是基于 hash 散列算法实现的，采用 键值对 (key:value) 的形式，根据 key 的值计算 value 的地址，具有非常快的查取和插入速度。它是一种 可变对象 ，所以支持修改、插入、删除等操作。

字典创建(掌握)

第一种方法：
test = {}
test = { key1 : value1, key2 : value2}

cpt = {"name": "小明", ('hight'): 180, "hobbit": ["xuexi", "游戏"]}
print(type(cpt), cpt)  # <class 'dict'> {'name': '小明', 'hight': 180, 'hobbit': ['xuexi', '游戏']}
cpt1 = {"addr": "henan", "addr": "hebei", "addr": "北京"}
print(cpt1)  # {'addr': '北京'}

注意：

• 在 Python3.6 开始，字典对象会保持键值插入时的 顺序，并且其包含的 元素个数不限，value值的类型也可以是其它任何数据类型，列表，整数，元组等均可。
• 字典的 key 必须是 不可变的对象，例如整数、字符串、bytes 和元组，但使用最多的还是字符串。 列表、字典、集合等就不可以作为 key。同时，同一个字典内的 key 必须是唯一 的，但值则不必，有重复值时，进行覆盖。
  第二种方法：
  dict()
  dict(**kwargs) 键值对的方法
  dict(mapping) 映射的关系

dic1 = dict(name="xiaoming", age=18)
dic2 = dict([("name", "xiaoming"), ("age", 18)])
dic3 = {"name": "xiaoming", "age":18}
print(dic1, dic2, dic3, sep="\n")  # {'name': 'xiaoming', 'age': 18}
print(dic1 == dic2 == dic3)  # True

拓展：
map(func,*iterables)：
将 iterables 里面的元素逐个传到 func 里面做处理
zip(iter1 [,iter2 […]])：
zip对象，打包，将可迭代对象里面一一对应的元素打包成元组返回，将iter1 iter2 中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
练习题：

• 1.list(‘1234’) --> [1,2,3,4] --> 将li中的每一个元素转为int

# 需求： list('1234') --> [1,2,3,4]  --> 将li中的每一个元素转为int
li = list('1234')
print(type(li[0]), li)  # <class 'str'>,['1', '2', '3', '4']，元素是字符串的形式
print(type(list(map(int, li))[0]),list(map(int, li)))  #<class 'int'> [1, 2, 3, 4]，元素是整数
# map(func,*iterables),映射，将li中可迭代的每一个元素传到int中

• 2.将输入的1 3 5 9 转化为整数，以列表的形式呈现

ipt = input("请输入：") # 1 3 5 7
print(ipt.split(" "))  # ['1', '3', '5', '7']， 字符串的分割
print(list(map(int, ipt.split(" "))))  # [1, 3, 5, 7]，转化后存放到列表中

• 3.li_k = [‘name’,‘age’] 与 li_v = [‘xiaoming’, 18] 怎么组合成 键值对 的字典

li_k = ['name','age']
li_v = ['xiaoming', 18]
print(zip(li_k, li_v))  # <zip object at 0x0000019E3B8E0348>,zip对象
print(list(zip(li_k, li_v)))  # [('name', 'xiaoming'), ('age', 18)],列表的形式
print(dict(list(zip(li_k, li_v))))  # {'name': 'xiaoming', 'age': 18},字典的形式
print(dict(zip(li_k, li_v)))  # {'name': 'xiaoming', 'age': 18},也可以直接以字典的形式呈现

访问字典(掌握)

字典是 集合类型，不是序列类型，因此 没有索引下标 的概念，更 没有切片 的说法。但是，与 list 类似，字典采用把 相应的键(key) 放入 方括号 内获取 对应值(value) 的方式取值。
如：dic[exit_key]，当 key 值不存在时，访问会报错

dic = {'name': 'xiaoming', 'age': 18}
# print(dic[0])  # 报错，KeyError
print(dic['name'])  # xiaoming
print(dic['sex'])   # 访问不存在的key值，会报错KeyError

字典的增加与修改(掌握)

• 增加 就是往字典 插入新的键值对
• 修改 就是给 原有的键赋予新的值。由于一个 key 只能对应一个值，所以，多次对一个 key 赋值，后面的值会把前面的值 覆盖 掉

dic = {'name': 'xiaoming', 'age': 18}
# 增加值，取出赋值
dic["sex"] = "famal"  # {'name': 'xiaoming', 'age': 18, 'sex': 'famal'}
# 修改值，取出重新赋值
dic["age"] = 22  # {'name': 'xiaoming', 'age': 22, 'sex': 'famal'}
print(dic)

一系列删除(掌握)

• 删除字典元素：del dic[exit_key] 或 dic.pop(exit_key)
• 删除整个字典：del dic
• 清空整个字典：dic.clear()

# 删除指定的值
dic = {'name': 'xiaoming', 'age': 18, 'sex': 'famal'}
del dic['name']   # {'age': 18, 'sex': 'famal'}，用key值去删除value
print(dic)
# 用pop删除，必须要传入参数，pop删除的值可以打印处理
print(dic.pop('age'),dic)  # 18 {'name': 'xiaoming', 'sex': 'famal'}

del dic  # 删除整个字典
print(dic)

print(dic.clear(),dic)  # None {}，清空字典

字典常见操作(熟悉)

D.get(k[,d]) --> 返回指定键的值，如果值不在字典中，则返回none
D.items() --> 以列表返回可遍历的(键, 值) 元组对，返回映射关系，用for循环遍历
D.keys() --> 以列表返回字典所有的键
D.values() --> 以列表返回字典所有的值

dic = {'name': 'xiaoming', 'age': 18, 'sex': 'famal'}
print(dic.get('age'))  # 18
print(dic.get('gender'))  # None
# 通过[]获取不存在key的值会报错，而get方法会返回None
print(dic.items())  # 映射关系，dict_items([('name', 'xiaoming'), ('age', 18), ('sex', 'famal')])
for key, value in dic.items():
    print(key, value)  # name xiaoming ; age 18 ; sex famal

# 获取所有的key
print(dic.keys())  # dict_keys(['name', 'age', 'sex'])
# 获取所有的value
print(dic.values())  # dict_values(['xiaoming', 18, 'famal'])

作业练习：

1. 将lis1 和 lis2 以键值对的形式呈现

# 第一种方法
lis1 = ['name', 'author', 'introduce']
lis2 = ['NORWEGIAN WOOD', 'Harry Murakami', ' It"s a secret']
print(dict(zip(lis1, lis2)))

# 第二种方法：
def f_map(a, b):
    return (a, b)
print(dict(map(f_map, lis1, lis2)))

# 第三种方法
print(zip(lis1, lis2))  # 可迭代的对象 <zip object at 0x000002CB92960508>
dic = {}
for k, v in zip(lis1, lis2):
    # print(k, v)  # name NORWEGIAN WOOD ; author Harry Murakami ; introduce  It"s a secret
    dic[k] = v  #字典中添加元素
print(dic)

2. 获取xiaom_info的key，value值

第一种方法：
xiaom_info = {'name': 'xiaoming', 'addr': 'henan', 'weight': 110}
print(xiaom_info.keys())  # ['name', 'addr', 'weight']
print(xiaom_info.values())  # ['xiaoming', 'henan', 110]

第二种方法：
for k, v in xiaom_info.items():
    print(f'key值为：{k}')
    print(f'value值为：{v}')

集合(set)

集合介绍(掌握)

集合( set )是一个 无序不重复 元素的集，基本功能包括关系测试和消除重复元素。是可变数据类型(增删改查)。
集合数据类型的 核心 在于 自动去重。

集合创建(掌握)

集合使用 大括号 {} 框定元素，并以 逗号 进行分隔。
s = {ele1,ele2,ele3…}
s = set()
s = set(iterable)，iterable可迭代的（列表，字符串）
{} 并 不是 创建 空集合，而 是空字典。创建 空集合 需使用 set()

s = {}
print(type(s), s)  # 空字典 class 'dict'> {}
s = set()
print(type(s), s)  # 空集合 class 'set'> set()

s1 = set([1, 2, 3, 1, 2, 12, 13])
print(s1)  # 自动去重，{1, 2, 3, 12, 13}

s2 = set('hello world')
print(s2)  # {'e', 'h', ' ', 'r', 'l', 'o', 'd', 'w'}
# 把字符串全部拆开，去重，无序

添加元素(熟悉)

通过 set.add(key) 方法可以 添加元素 到 set 中
注意：

• 可以重复添加，但是会 自动去重，所以无效果
• 不能添加可变对象

s1 = set([1, 2, 3, 4, 5, 12, 13])
s1.add(3)  # 自动去重{1, 2, 3, 4, 5, 12, 13}
s1.add(8)  # 添加成功{1, 2, 3, 4, 5, 8, 12, 13}
s1.add('xiaoming')  # 添加的元素为不可变数据类型.{1, 2, 3, 4, 5, 8, 12, 13, 'xiaoming'}
s1.add([1, 2, 3])  # 只能添加不可变对象，同字典的key一样。TypeError: unhashable type: 'list'
print(s1)  # 自动去重，{1, 2, 3, 4, 5, 12, 13}

集合更新(熟悉)

可以通过 set.update() 方法，将另一个对象 更新 到 已有的集合中，这一过程同样会进行 去重

s1 = set([1, 2, 3, 4, 5, 12, 13])
s1.update('hello')  # {'h', 1, 2, 3, 4, 5, 12, 13, 'l', 'o', 'e'}
# 更新，好比列表的extend，扩展集合，仍然去重，将hello每个都拆开添加到s1中
print(s1)

删除元素(熟悉)

• set.remove(key)：删除指定元素，元素不存在的时候报错
• set.pop()：随机删除元素(注意：无参数)

s1 = set([1, 2, 3, 4, 5])
s1.remove(3)  # {1, 2, 4, 5} 删除指定元素
s1.remove('xiaoming')  # 元素不存在时报错
s1.pop()  # 随机删除元素，在ipython中演示
print(s1)

注意：
集合不能取出某个元素（无序的，没有下标的概念），因为集合既不支持下标索引也不支持字典那样的通过键值对获取。

可变类型与不可变类型

用id()查看
可变类型：改变数据本身，内存地址不变，进行增删改查
list()，dict()，set()（存放字符串，元组，数值）
不可变类型：改变数据，内存地址改变
数值，字符串，字节，元组（只能查）