第四章 序列

4.1 列表

列表是最常用的Python数据类型，列表的数据项不需要具有相同的类型。在形式上，只要把逗号分隔的不同的数据项使用方括号括起来，就可以构成一个列表。

4.1.1 列表的创建与删除

1.使用赋值运算符直接创建列表

student = ['小明', '男', 2010,10]

2.创建空列表

empty_list = [] 

3.创建数值列表

Python中的数值列表很常用，用于存储数值集合。Python提供了list()函数，它可以将range()对象、字符串、元组或其他可迭代类型的数据转换为列表

例，创建一个包含1到5的整数列表：
>>> num_list = list(range(1,6))
>>> print(num_list)
[1, 2, 3, 4, 5]

4.列表的删除

当列表不再使用时，可以使用del命令删除整个列表，如果列表对象所指向的值不再有其他对象指向，Python将同时删除该值。

4.1.2 访问列表元素

**使用for循环实现列表的遍历
list1 = ["hadoop", "spark", "flink", "storm“]
 for element in list1:
   print(element)

4.1.3 添加、删除、修改列表元素

1.列表元素的添加

（1）append()

列表对象的append()方法用于在列表的末尾追加元素。

（2）insert()

列表对象的insert()方法用于将元素添加至列表的指定位置。

（3）extend()

使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。

（4）“+”运算符

可以使用“+”运算符来把元素添加到列表中。

（5）“*”运算符

Python提供了“*”运算符来扩展列表对象。可以将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。

2.列表元素的删除

（1）使用del语句删除指定位置的元素

在Python中可以使用del语句删除指定位置的列表元素。

（2）使用**pop()**删除元素

pop()可删除列表末尾的元素。

（3）使用**remove()**根据值删除元素

可以使用remove()方法删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。

3.列表元素的修改

>>> books = ["hadoop","spark","flink"]
>>> books
['hadoop', 'spark', 'flink']

>>> books[2] = "storm"
>>> books
['hadoop', 'spark', 'storm']

4.1.4 对列表进行统计计算

1.获取指定元素出现的次数

可以使用列表对象的count()****方法来获取指定元素在列表中的出现次数。

2.获取指定元素首次出现的下标

使用列表对象的index()****方法可以获取指定元素首次出现的下标。

语法格式为：index(value,[start,[stop]])

注：start和stop用来指定搜索范围，start默认为0，stop默认为列表长度。如果列表对象中不存在指定元素，则会抛出异常。

3.统计数值列表的元素和

sum()****函数用于统计数值列表中各个元素的和。

语法格式如下：sum(aList[,start])

注：aList表示要统计的列表，start表示统计结果是从哪个数开始累加，如果没有指定，默认值为0。

4.1.5 对列表进行排序

1.使用列表对象的sort()****方法排序

使用列表对象的sort()方法对列表中的元素进行排序，排序后列表中的元素顺序将会发生改变。

具体语法格式如下：aList.sort(key=None,reverse=False)

注aList表示要排序的列表，key参数来指定一个函数，此函数将在每个元素比较前被调用，例如，可以设置“key=str.lower”来忽略字符串的大小写；reverse是一个可选参数，如果值为True，则表示降序，如果值为False**，则表示升序，默认为升序排序**。

当列表中的元素类型是字符串时，sort()函数排序的规则是，先对大写字母进行排序，然后再对小写字母进行排序。如果在排序时不考虑字母大小写，则需要设置“key=str.lower”。

2.使用内置的sorted()函数排序

Python提供了一个内置的全局sorted()方法，可以用来对列表排序生成新的列表，原列表的元素顺序保持不变。

语法格式如下：sorted(aList,key=None,reverse=False)

注：aList表示要排序的列表，key参数来指定一个函数，可以设置“key=str.lower”来忽略字符串的大小写；reverse是一个可选参数，如果值为True，则表示降序，如果值为False，则表示升序**，默认为升序排序**。

4.1.6 成员资格判断

如果需要判断列表中是否存在指定的值，可以采用四种不同的方式：in、not in、count()、index()。

（1）可以使用in****操作符判断一个值是否存在于列表中

（2）可以使用not in****操作符判断一个值是否不在列表中

（3）可以使用列表对象的count()**方法，如果指定的值存在，则返回大于0的数，如果返回0，则表示不存在。**

（4）可以使用index()****方法查看指定值在列表中的位置，如果列表中存在指定值，则会返回该值第一次出现的位置，否则会抛出错误

4.1.7 切片操作

切片操作是访问序列中元素的一种方法，不是列表特有的，Python中的有序序列（如字符串、元组）都支持切片操作。

切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列

通过切片操作可以生成一个新的列表（不会改变原列表）。

切片操作的语法格式如下：listname[start : end : step]

其中，listname表示列表名称；start是切片起点的索引，如果不指定，默认值为0；end是切片终点的索引（但是切片结果不包括终点索引的值），如果不指定，默认为列表的长度；step是步长，默认值是1，当省略步长时，最后一个冒号也可以省略。

切片操作的具体实例：
num_list[1::] #从索引1的位置开始取，取到列表尾部，步长为1
[54, 38, 93, 28, 74, 59, 92, 85, 66]
可以结合使用del命令与切片操作来删除列表中的部分元素，实例如下：

>>> num_list = [13,54,38,93,28,74,59,92,85,66]
>>> del num_list[:4]
>>> num_list
[28, 74, 59, 92, 85, 66]

4.1.8 列表推导式

列表推导式可以利用range对象、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。

列表推导式的语法格式如下：
	[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

其中，[if 条件表达式]不是必须的，可以使用，也可以省略。

4.1.9二维列表

所谓的“二维列表”，是指列表中的每个元素仍然是列表。

4.2 元组

4.2.1 创建元组

1.创建元组时则需要使用圆括号。元组的创建方法很简单，只需要在圆括号中添加元素，并使用逗号隔开即可。

tuple1 = ('hadoop','spark',2008,2009)

2.创建空元组的方法如下：

>>> tuple1 = ()

注：当元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

3.使用tuple()函数和range()函数来生成数值元组（同列表一致）

>>> tuple1 = tuple(range(1,10,2))
>>> tuple1
(1, 3, 5, 7, 9)

4.2.2 访问元组

1.使用下标索引来访问元组中的元素（同列表一致）

>>> tuple1 = ("hadoop", "spark", "flink", "storm")
>>> tuple1[0]
'hadoop'

2.采用切片的方式来获取指定的元素（同列表一致）

>>> tuple1 = (1,2,3,4,5,6,7,8,9)
>>> tuple1[2:5] 
 (3, 4, 5)

3.使用for循环实现元组的遍历（同列表一致）

tuple1 = ("hadoop", "spark", "flink", "storm")
 for element in tuple1:
   print(element)

4.2.3 修改元组

元组中的元素值是不允许修改的。

可以对元组进行连接组合和对元组进行重新赋值来改变元组的值

4.2.4 删除元组

元组属于不可变序列，无法删除元组中的部分元素，只能使用del****命令删除整个元组对象。（列表是可变序列，具体区别在4.2.7进行描述）

具体语法格式如下：del tuplename

注：tuplename表示要删除元组的名称。

4.2.5 元组推导式

元组推导式的语法格式如下：（同列表一致）
	(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )

其中，[if 条件表达式]不是必须的，可以使用，也可以省略。

使用元组推导式生成的结果并不是一个元组，而是一个生成器对象。

使用__next__()方法遍历生成器对象来获得各个元素，例如：
>>> tuple1 = (x for x in range(1,10))
>>> print(tuple1.__next__())
1

注：next()方法遍历对象获取元素，不是访问元素的值，而是取走元素，在原元组中取走的元素将不存在。

使用元组推导式获得新元组或新元组中的元素：

>>> tuple1 = tuple(tuple1)
>>> tuple1
(2,3, 4, 5, 6, 7, 8, 9)

4.2.6 元组的常用内置函数

元组的常用内置函数如下：
len(tuple)：计算元组大小，即元组中的元素个数；
max(tuple) ：返回元组中的元素最大值；
min(tuple) ：返回元组中元素最小值；
tuple(seq)： 将序列转为元组。

4.2.7 元组与列表的区别

元组和列表都属于序列，二者的区别主要体现在以下几个方面：

（1）列表属于可变序列，可以随时修改或删除列表中的元素。

元组属于不可变序列，不能修改其中的元素和从元组中删除元素。

（2）元组和列表都支持切片操作。

列表可以使用切片方式来修改其中的元素，元组则不能。

（3）元组的访问和处理速度比列表快。如果只是对元素进行遍历，而不需要对元素进行任何修改，那么一般建议使用元组而非列表。

（4）作为不可变序列，与整数、字符串一样，元组可以作为字典的键，而列表则不可以。

在实际应用中，经常需要在元组和列表之间进行转换，具体方法如下：

（1）tuple()函数可以接受一个列表作为参数，返回同样元素的元组；

（2）list()函数可以接受一个元组作为参数，返回同样元素的列表。

4.2.8 序列封包和序列解包

1.程序把多个值赋给一个变量时，Python会自动将多个值封装成元组，这种功能被称为“序列封包”。

2.程序允许将序列（元组或列表等）直接赋值给多个变量，此时序列的各元素会被依次赋值给每个变量（要求序列的元素个数和变量的个数相等），这种功能被称为“序列解包”。可以使用序列解包功能对多个变量同时赋值。

4.3 字典

字典也是Python提供的一种常用的数据结构，它用于存放具有映射关系的数据。

字典具有如下特性：

（1）字典的元素是“键值对”，由于字典中的键是非常关键的数据，而且程序需要通过键来访问值，因此字典中的键不允许重复，必须是唯一值，而且键必须不可变；

（2）字典不支持索引和切片，但可以通过“键”查询“值”；

（3）字典是无序的对象集合，列表是有序的对象集合，两者之间的区别在于，字典当中的元素是通过键来存取的，而不是通过偏移量存取；

（4）字典是可变的，并且可以任意嵌套。

4.3.1字典的创建与删除

1.字典用大括号****{}标识。在使用大括号语法创建字典时，大括号中应包含多个“键值对”，键与值之间用英文冒号隔开，多个键值对之间用英文逗号隔开。

 grade = {"语文":67, "数学":91, "英语":78}  #键是字符串

2.创建一个空字典

empty_dict = {} 

注：元组可以作为字典的键，但列表不能作为字典的键，因为字典要求键必须是不可变类型，但列表是可变类型，因此列表不能作为字典的键。

#内置函数dict()来创建字典，实例如下：

>>> books = [('hadoop', 132), ('spark', 563), ('flink', 211)]
>>> dict1 = dict(books)
>>> dict1
{'hadoop': 132, 'spark': 563, 'flink': 211}
#zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
>>> keys = ["语文","数学","英语"]
>>> values = [67,91,78]
>>> dict4 = dict(**zip(keys,values)**)
>>> dict4
{'语文': 67, '数学': 91, '英语': 78} 

3.使用del****命令删除字典

del grade 

4.字典对象的clear()****方法清空字典中的所有元素，让字典变成一个空字典

4.3.2 访问字典

1.通过键访问值

grade["语文"] 

2.使用字典对象的get()****方法获取指定键的值.其语法格式如下：

dictname.get(key[,default])

注：dictname表示字典对象，key表示指定的键，default是可选项，用于当指定的键不存在时返回一个默认值，如果省略，则返回None。

3.使用字典对象的items()****方法获取“键值对”列表，使用字典对象的keys()****方法获取“键”列表，使用字典对象的values()****方法获取“值”列表

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> items = grade.items()
>>> list(items)
[('语文', 67), ('数学', 91), ('英语', 78)]

>>> keys = grade.keys()
>>> list(keys)
['语文', '数学', '英语']

>>> values = grade.values()
>>> list(values)
[67, 91, 78]

4.通过for****循环对items()方法返回的结果进行遍历

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> for **item** in grade.items():
 print(item)
('语文', 67)
('数学', 91)
('英语', 78)
>>> for **key,value** in grade.items():
 print(key,value)
语文 67
数学 91
英语 78

5.pop()****方法用于获取指定键对应的值，并删除这个键值对。

4.3.3 添加、修改和删除字典元素

1.向列表中添加元素：dictname[key] = value

注：dictname表示字典对象的名称；key表示要添加的元素的键，可以是字符串、数字或者元组，但是键必须具有唯一性，并且是不可变的；value表示要添加的元素的值。

(补充：不可变序列：字符串，数字，元组

可变序列：列表，字典… )

2.修改字典对象某个元素的值时，可以直接为该元素赋予新值，新值会替换原来的旧值。

 grade["语文"] = 88

3.使用del****命令删除字典中的某个元素

4.使用字典对象的**update()**方法，用一个字典所包含的键值对来更新己有的字典。

在执行update()方法时，如果被更新的字典中己包含对应的键值对，那么原值会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

>>> grade = {"语文":67, "数学":91, "英语":78}
>>> grade.update({"语文":59,"数学":91,"英语":78,"计算机":98})
>>> grade
{'语文': 59, '数学': 91, '英语': 78, '计算机': 98} 

4.3.4 字典推导式

字典推导式的语法格式如下：
	{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}

其中，用[]括起来的部分是可选项，可以省略。

4.4集合

4.4.1 集合的创建与删除

1.集合（set）是一个无序的不重复元素序列。集合中的元素必须是不可变类型。 在形式上，集合的所有元素都放在一对大括号“{}”中，两个相邻的元素之间使用逗号分隔。

dayset = {'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'}

2.在创建集合时，如果存在重复元素，Python只会自动保留一个。

3.集合也支持集合推导式，实例如下：

>>> squared = {x**2 for x in [1, 2, 3]}
>>> squared  {1, 4, 9}

4.使用set()****函数将列表、元组、range对象等其他可迭代对象转换为集合。

语法格式如下：setname = set(iteration)

注：setname表示集合名称，iteration表示列表、元组、range对象等可迭代对象，或者也可以是字符串，如果是字符串，返回的是包含全部不重复字符的集合。

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

>>> empty_set = set() 

6.可以使用del****命令删除整个集合

4.4.2 集合元素的添加与删除

1.使用add()****方法向集合中添加元素，被添加的元素只能是字符串、数字及布尔类型的True或者False等，不能是列表、元组等可迭代对象。如果被添加的元素已经在集合中存在，则不进行任何操作。

2.可以使用pop()****、remove()****方法删除集合中的一个元素，使用clear()方法清空集合中的所有元素。

4.4.3 集合的并集、交集与差集操作

集合包括并集、交集、差集等操作。

>>> a = set('abc')
>>> b = set('cdef')

1.并集是指把两个集合中的元素合并在一起，并且去除重复的元素。

>>> a **|** b #并集
{'e', 'f', 'c', 'b', 'd', 'a'}

2.交集是指取出两个集合中相同的元素。

>>> a **&** b #交集
{'c'}
>>> a**.intersection(b)** #交集
{'c'} 

3.差集是指，对于集合A和B，集合A中的元素在集合B中有重复时，去掉重复元素后集合A中剩余的元素就是A与B的差集。

>>> a **-** b  #差集
{'b', 'a'}
>>> a**.difference(b)**  #差集
{'b', 'a'}