02 python 要点(容器部分开始)

第6章 容器类型的数据

Python内置的数据类型如序列（列表、元组等 ）、集合、字典等可以容纳多项数据，我们称它们为容器类型的数据。

6.1 序列简介

序列（sequence）是一种可迭代的、元素有序的容器类型的数据, 包括列表（list）、字符串（str）、元组（tuple）、字节序列（bytes）等。

6.1.1 序列的索引操作

序列中的元素都是有序的，每一个元素都带有序号，这个序号叫作索引。索引有正值索引、负值索引之分，正值索引为左到右，从（0 – > N-1）(比如单词)。

list= [1, 2, 2, 4]
len(list)  # len()  用于获取序列的长度

6.1.2 加和乘操作

加（+）和乘（）运算符也可以用于序列中的元素操作。加（+）运算符可以将两个序列连接起来，乘（）运算符可以将两个序列重复多次。

6.1.3 切片操作

序列的切片（Slicing）就是从序列中切分出小的子序列。

lst = [1, 2, 3, 6, 2]
lst[0:2]     # [1, 2]    # 使用“冒号”做切片操作   
'''切片运算符的语法形式为[start：end：step].   其中，start是开始索引，end是结束索引，step是步长.
切片时获取的元素的间隔，可以为正整数(0开始)，也可以为负整数，反向切片时列表顺序会进行颠倒, 步长设置为-1时,元素顺序会颠倒. 
切下的小切片包括start位置的元素，但不包括end位置的元素.'''

6.1.4 成员测试

成员测试运算符有两个：in、not in，in用于测试是否包含某一个元素，not in用于测试是否不包含某一个元素。

6.2 列表

列表（list）是一种可变序列类型，我们可以追加、插入、删除、替换列表中的元素。

6.2.1 创建列表

创建列表有两种方法:

list1 = list([10,20,30,10,20,50])   # list（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）
list2 = [10,20,30,10,20,50]         # [元素1，元素2，元素3，⋯]：指定具体的列表元素，元素之间以逗号分隔。
[i*i for i in range( a , b )]       # 列表的生成公式
lst = [],   lst1 = list()           # 空列表的创建

6.2.2 追加元素

列表是可变的序列对象，列表可以追加元素。

lst = [1, 2, 5, 3]
lst.append(4)  # 在列表中追加单个元素时，可以使用列表的append（x）方法。   
lst += [6, 7]  # 在列表中追加多个元素时，可以使用加(+)运算符或列表的extend()方法。 
lst.extend([8, 9])   # 结果:[1, 2, 5, 3, 4, 6, 7, 8, 9]

6.2.3 插入元素

lst = [1, 2, 5, 3]  # 想向列表中插入元素时，可以使用列表的list.insert（i，x）方法.
lst.insert(1, 9)    # 结果: [1, 9, 2, 5, 3]  其中，i指定索引位置，x是要插入的元素.

6.2.4 替换元素

lst = [1, 2, 5, 3]  # 想替换列表中的元素时，将列表下标索引元素放在赋值符号（=）左边，进行赋值即可.
lst[2] = 100        # 结果: [1, 2, 100, 3]

6.2.5 删除元素

lst = [1, 2, 5, 3, 2]   # 想在列表中删除元素时，可使用列表的list.remove（x）方法，如果找到匹配的元素x，则删除该元素.
lst.remove(2)   # 结果: [1, 5, 3, 2]   # 如果找到多个匹配的元素，则只删除第一个匹配的元素.
lst.pop(2)      # 结果: [1, 5, 2]  # X.pop() 根据索引移除元素，移除的某个位置的元素. 
lst[1:2] = []   # 结果: [1, 2]     # 用切片的方式进行替换.
del(lst)        # 结果: name 'lst' is not defined  # del()命令，直接删除列表.

6.2.6 查询元素位置

lst = [1, 2, 5, 3, 2]  # index() 可以查询元素的位置.
lst.index(5)   # 结果: 2  # 列表不可以使用find函数进行查询，字符串可以用 find 和 index
'''如果有多个元素只能输出第一个元素的位置,
可以在指定区间查找, index中可以指定start 和 stop'''

6.2.7 列表元素的排序操作

lst = [1, 2, 5, 3, 2]
lst.sort(cmp=None, key=None, reverse=False)  # 语法  [1, 2, 2, 3, 5] 
'''参数解析:
cmp ：可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key ： 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素.
reverse ：排序规则，reverse = True 降序， reverse = False 升序（默认）'''

# 调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变    
new_list = sorted(lst,reverse = True)    # [5, 3, 2, 2, 1]  

# 可以通过关键字进行排序

6.2.8 获取列表中的元素

lst = [1, 2, 5, 3, 2]
lst[1: 4]     # 正向索引  从0到 N-1   # [2, 5, 3]
lst[-3: -1]   # 逆向索引 从-N 到-1    # [5, 3]
lst[-1: -4: -1]  # 获取反向列表       # [2, 3, 5]
lst[3]   # 获取某个列表某个位置的值的方法，直接在后面加上[]及其位置  # 结果: 3

6.3 元组

元组（tuple）是一种不可变序列类型，不可以执行替换操作。

6.3.1 创建元组

创建元组时有两种方法:

tup=tuple(('python','world',36))   # tuple（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合、字典等）      (注意后面为双括号)
tup = (1, 2, 3, 5)   # （元素1，元素2，元素3，⋯）：指定具体的元组元素，元素之间以逗号分隔。对于元组元素，可以使用小括号括起来，也可以省略小括号
tup = ('python',)    # 只包含一个元组的元素需要使用逗号和小括号, 没有逗号时直接会将元组内部值赋值给变量
print(type(tup))     # type() 查看变量类型  # <class 'tuple'>
t1 = ()              # 空元组的两种创建方式
t2 = tuple() 

6.3.2 元组拆包

创建元组，并将多个数据放到元组中，这个过程被称为元组打包,
与元组打包相反的操作是拆包，就是将元组中的元素取出，分别赋值给不同的变量。

a,b,c,d=1,2,3,4   # 解包赋值, 

6.3.3 元组的遍历

tup = (1, 2, 5, 3, 2)     # enumerate: 枚举
for i in tup:      # 可以使用for循环进行遍历 
'''enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中,enumerate()是python的内置函数，默认序号为从0开始计数'''
for index,item in enumerate(coffee_name):    # 前面的index为输出的序号

6.4 集合

集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据。

6.4.1 创建集合

set_1 = set([1, 2, 4, 5])    # set（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）
set_1 = {1, 2, 3, 5}         # {元素1，元素2，元素3，⋯}：指定具体的集合元素，元素之间以逗号分隔。对于集合元素，需要使用大括号括起来。
set_1 = set()     # 空集合的创建   
{i*i for i in range(a, b)}   # 集合的生成公式

6.4.2 修改集合

修改集合类似于修改列表，可以向其中插入和删除元素。修改可变集合有如右所示的常用方法。

set_1 = {1, 2, 3, 5} 
# 集合的新增操作：
set_1.add(9)      # add（elem）：添加元素，如果元素已经存在，则不能添加，不会抛出错误。  # {1, 2, 3, 5, 9}
set_1.update({4, 6, 8})  # update( )：添加多个元素   # {1, 2, 3, 4, 5, 6, 8, 9}
set_1.remove(4)    # remove（elem）：删除元素，如果元素不存在，则抛出错误。  # {1, 2, 3, 5, 6, 8, 9}
set_1.discard(5)   # discard：一次删除一个指定元素，如果指定的元素不存在不抛异常  # {1, 2, 3, 6, 8, 9}
print(len(set_1))  # 可以使用len()统计集合内部元素的多少    # 6
set_1.pop()     # pop( )：一次只删除一个任意元素     # {2, 3, 6, 8, 9}
set_1.clear()   # 清除集合。   # set()
del(set_1)      # 可以使用del 进行删除集合

集合的数学操作：

s1 = {1, 2, 3, 5} 
s2 = {2, 3, 4, 6}
print(s1.intersection(s2))  # 求两个集合的交集 print(s1 & s2)  # {2, 3}
print(s1.union(s2))         # 求两个集合的并集 print(s1 | s2)  # {1, 2, 3, 4, 5, 6}
print(s1.difference(s2))    # print(s2 - s1) 求两个集合的差集  # {1, 5}
print(s1.symmetric_difference(s2))   # 求集合的对称差集, print(s1 ^ s2)  # {1, 4, 5, 6}

6.4.3 判断操作

in / not in          # 判断集合中是否存在该元素

6.4.4 集合间的关系

s1 = {2, 4} 
s2 = {2, 3, 4, 6}
print(s2.issubset(s1))    # False  # 一个集合是否是另一个集合的子集，可以调用方法issubset进行判断  
print(s2.issuperset(s1))  # True   # 一个集合是否是另一个集合的超集，可以调用方法issuperset进行判断 
print(s2.isdisjoint(s1))  # False  # 两个集合是否没有交集，可以调用方法isdisjoint进行判断     

6.4.5 set集合

基本特点：(1) 无序性 (2) 确定性 (3) 不重复性, set( ) 实质：内部进行 可迭代性的 for 循环.
在python3中按数据类型的可变与不可变大致分为如下几种类型，前面已经介绍了另外几种了。今天讲讲set。
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
python中，用set来表示一个无序不重复元素的序列。set的主要作用就是用来给数据去重。
可以使用大括号 { } 或者 set() 函数创建集合，但是注意如果创建一个空集合必须用 set() 而不是 { }，因为{}是用来表示空字典类型的.

6.5 字典

字典（dict）是可迭代的、通过键（key）来访问元素的可变的容器类型的数据，字典是一个无序的序列。
字典由两部分视图构成：键视图和值视图。键视图 （key，类似索引,可以只含数字）不能包含重复的元素，值视图能（values 类似存储空间）。在键视图中，键和值是成对出现的。
字典、列表、集合都是可以增、删、改的可变序列，元组为不可变序列。

6.5.1 创建字典

dic = dict(name='jack',age = 20)  # dict()函数   # {'name': 'jack', 'age': 20}
dic =  {'key1':'value1', 'key2': 'value2'}  # 指定具体的字典键值对，键值对之间以逗号分隔，最后用大括号括起来。
dic = {}      # dict   空字典的创建 , 设置为集合需要 set1 = set({})
dic = dict()  # dict 

6.5.2 修改字典

字典可以被修改，但都是针对键和值同时操作的，对字典的修改包括添加、替换和删除。

scores['张三'] = 63   # 通过'[]'进行新增操作，如果已存在就执行修改动作
scores.pop('王麻子')  # 使用字典中”pop”的方法删除
scores.clear()       # 通过‘clear’清空字典 
del scores['张三']   # 通过‘del’命令进行删除某元素，同时删除其键和值  

6.5.3 访问字典视图

我们可以通过字典中的三种方法访问字典视图。

scores = {'李四': 30, '张三': 90}
items = scores.items()       # items()：返回字典的所有键值对视图。 # dict_items([('李四', 30), ('张三', 90)])
keys = list(scores.keys())   # keys()：返回字典键视图。   # ['李四', '张三'] 
values = scores.values()     # values()：返回字典值视图。   # dict_values([30, 90])

6.5.4 获取字典中的元素

scores = {'李四': 30, '张三': 90}
print(scores['李四'])   # []如果字典中不存在指定的key，抛出keyError异常。  # 30
print(scores.get('王六',96))  # get( )方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的value（如举例里的96），以便指定的key不存在时返回。     # 96
print('张三' in scores)  # True  # 通过‘in’和‘not in’判断是否存在该元素，只会对前面的键进行判断，与后面的值无关

6.5.6 字典元素的遍历

scores = {'李四': 30, '张三': 90}
print(scores['李四'])  # print(scores.get(items))  # 输出字典的'values'值     # 30
print(items)  # 输出字典的 'key'值, items是关键字列表

6.5.7 字典生成第三种方式

dic = zip(items,prices)    # 内置函数 ‘zip’ 
b = {items:prices for items,prices in zip(items, prices)}  # 方式二

第7章 字符串

eval()   # 将“input”输入的函数直接转换为真实的数据类型
round(a,x)  # 数学函数进行四舍五入，其中a是对象，x是四舍五入保留小数，count()统计元素数量
count()  # 函数, 统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。 
str.count("char", start,end)  # 或 str.count("char")    # -> int    返回整数