大一第二次培训——上

序列

序列综述

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

注意，在使用负值作为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始。

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。

序列实现切片操作的语法格式如下：

sname[start : end : step]

其中，各个参数的含义分别是：
sname：表示序列的名称；
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。

下面是例子

	str="C语言中文网"
	#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
	print(str[:2])
	#隔 1 个字符取一个字符，区间是整个字符串
	print(str[::2])
	#取整个字符串，此时 [] 中只需一个冒号即可
	print(str[:])

Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。例如：

	str="abc"
	print(str*3)

输出结果为：

‘abcabcabc’

比较特殊的是，列表类型在进行乘法运算时，还可以实现初始化指定长度列表的功能。例如如下的代码，将创建一个长度为 5 的列表，列表中的每个元素都是 None，表示什么都没有。

	#列表的创建用 []，后续讲解列表时会详细介绍
	list = [None]*5
	print(list)

输出结果为：

[None, None, None, None, None]

Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：

value in sequence

其中，value 表示要检查的元素，sequence 表示指定的序列。

例如，检查字符‘k’是否包含在字符串“custkdxf”中，可以执行如下代码：

	str="custkdxf"
	print('k' in str)

运行结果为：

True

和 in 关键字用法相同，但功能恰好相反的，还有 not in 关键字，它用来检查某个元素是否不包含在指定的序列中。

Python提供了几个内置函数，用于序列。如下图：

列表

Python创建列表

在 Python 中，创建列表的方法可分为两种，下面分别进行介绍。

使用 [ ] 直接创建列表
使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：

	listname = [element1 , element2 , element3 , ... , elementn]

其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

另外，使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有，例如：
emptylist = [ ]
这表明，emptylist 是一个空列表。

使用 list() 函数创建列表
除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。例如：

	#将字符串转换成列表
	list1 = list("hello")
	print(list1)
	#将元组转换成列表
	tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
	list2 = list(tuple1)
	print(list2)
	#将字典转换成列表
	dict1 = {
     'a':100, 'b':42, 'c':9}
	list3 = list(dict1)
	print(list3)
	#将区间转换成列表
	range1 = range(1, 6)
	list4 = list(range1)
	print(list4)
	#创建空列表
	print(list())

访问列表元素

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

元素的增删改查

使用+运算符可以将多个序列连接起来；列表是序列的一种，所以也可以使用+进行连接，这样就相当于在第一个列表的末尾添加了另一个列表。

例：

	language = ["Python", "C++", "Java"]
	birthday = [1991, 1998, 1995]
	info = language + birthday
	print("language =", language)
	print("birthday =", birthday)
	print("info =", info)

运行结果：
language = [‘Python’, ‘C++’, ‘Java’]
birthday = [1991, 1998, 1995]
info = [‘Python’, ‘C++’, ‘Java’, 1991, 1998, 1995]

从运行结果可以发现，使用+会生成一个新的列表，原有的列表不会被改变。
+更多的是用来拼接列表，而且执行效率并不高，如果想在列表中插入元素，应该使用下面的方法。

append() 方法用于在列表的末尾追加元素，该方法的语法格式为：

	listname.append(obj)

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

Python extend()方法添加元素
extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
extend() 方法的语法格式如下：

	listname.extend(obj)

其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。

append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。
insert() 的语法格式如下：

	listname.insert(index , obj)

其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。

当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。
注意，有的函数并不返回任何值，请大家自己尝试。
这3个函数本身不难，但同学们一定要自己去实验。

在 Python 列表中删除元素主要分为以下 3 种场景：

根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。

del：根据索引值删除元素
del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

del 可以删除列表中的单个元素，格式为：

	del listname[index]

其中，listname 表示列表名称，index 表示元素的索引值。

del 也可以删除中间一段连续的元素，格式为：

	del listname[start : end]

其中，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。

pop()：根据索引值删除元素
Python pop() 方法用来删除列表中指定索引处的元素，具体格式如下：

	listname.pop(index)

其中，listname 表示列表名称，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。

大部分编程语言都会提供和 pop() 相对应的方法，就是 push()，该方法用来将元素添加到列表的尾部，类似于数据结构中的“入栈”操作。但是 Python 是个例外，Python 并没有提供 push() 方法，因为完全可以使用 append() 来代替 push() 的功能。

remove()：根据元素值进行删除
除了 del 关键字，Python 还提供了 remove() 方法，该方法会根据元素本身的值来进行删除操作。

需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

clear()：删除列表所有元素
Python clear() 用来删除列表的所有元素，也即清空列表，没什么好说的。

需要注意的是，在使用 del 关键字时，一定要搞清楚，删除的到底是变量还是数据。
例如，下面代码演示和删除变量的方法：

	tt = 'hello'
	#定义一个包含多个类型的 list
	list1 = [1,4,tt,3.4,"yes",[1,2]]
	l2 = list1
	print(id(l2),id(list1))
	del list1
	print(l2)
	print(list1)

运行结果如下：
1765451922248 1765451922248
[1, 4, ‘hello’, 3.4, ‘yes’, [1, 2]]
Traceback (most recent call last):
File “C:\Users\mengma\Desktop\demo.py”, line 8, in
print(list1)
NameError: name ‘list1’ is not defined

第一行输出的内容是 l2 和 list1 的地址，可以看到它们是相同的，说明 l2 和 list1 之间的赋值仅仅是传递内存地址。接下来将 list1 删掉，并打印 l2，可以看到，l2 所指向的内存数据还是存在的，这表明 del 删除 list1 时仅仅是销毁了变量 list1，并没有删除指定的数据。

除了删除变量，其他的删除都是删除数据，比如将列表中数据全部清空，实现代码如下：

	tt = 'hello'
	#定义一个包含多个类型的 list
	list1 = [1,4,tt,3.4,"yes",[1,2]]
	l2 = list1
	l3 = l2
	del l2[:]
	print(l2)
	print(l3)

输出结果为：
[]
[]

可以看到，l3 和 l2 执行同样的内存地址，当 l2 被清空之后，l3 的内容也被清空了。这表明内存中的数据真正改变了。

另外，在实际过程中，即便使用 del 关键字删除了指定变量，且该变量所占用的内存再没有其他变量使用，此内存空间也不会真正地被系统回收并进行二次使用，它只是会被标记为无效内存。

Python 提供了两种修改列表（list）元素的方法，你可以每次修改单个元素，也可以每次修改一组元素（多个）。

修改单个元素
修改单个元素非常简单，直接对元素赋值即可。请看下面的例子：

	nums = [40, 36, 89, 2, 36, 100, 7]
	nums[2] = -26  #使用正数索引
	nums[-3] = -66.2  #使用负数索引
	print(nums)

运行结果：

[40, 36, -26, 2, -66.2, 100, 7]

使用索引得到列表元素后，通过=赋值就改变了元素的值。

修改一组元素
Python 支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素。

下面的代码演示了如何修改一组元素的值：

	nums = [40, 36, 89, 2, 36, 100, 7]
	#修改第 1~4 个元素的值（不包括第4个元素）
	nums[1: 4] = [45.25, -77, -52.5]
	print(nums)

运行结果：

[40, 45.25, -77, -52.5, 36, 100, 7]

如果对空切片（slice）赋值，就相当于插入一组新的元素：

	nums = [40, 36, 89, 2, 36, 100, 7]
	#在4个位置插入元素
	nums[4: 4] = [-77, -52.5, 999]
	print(nums)

运行结果：

[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]

*使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：

nums[4: 4] = -77

但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，请看下面的代码：

	s = list("Hello")
	s[2:4] = "XYZ"
	print(s)

运行结果：

[‘H’, ‘e’, ‘X’, ‘Y’, ‘Z’, ‘o’]

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如：

	nums = [40, 36, 89, 2, 36, 100, 7]
	#步长为2，为第1、3、5个元素赋值
	nums[1: 6: 2] = [0.025, -99, 20.5]
	print(nums)

运行结果：

[40, 0.025, 89, -99, 36, 20.5, 7]

Python 列表（list）提供了 index() 和 count() 方法，它们都可以用来查找元素。

index() 方法
index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

index() 的语法格式为：

	listname.index(obj, start, end)

其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。
start 和 end 参数用来指定检索范围：
start 和 end 可以都不写，此时会检索整个列表；
如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

index() 方法会返回元素所在列表中的索引值。

count()方法
count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：

	listname.count(obj)

其中，listname 代表列表名，obj 表示要统计的元素。
如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

range()

在讲其它内容之前，先给大家讲一下range()的用法

range(start, end, step)

Python range() 函数能够轻松地生成一系列的数字。
例如：

for i in range(1, 10):
	print(i, end = ' ')

输出结果:1 2 3 4 5 6 7 8 9

同时还可以指定步长。
例如：

for i in range(1, 10， 2):
	print(i, end = ' ')

输出：1 3 5 7 9

for流程控制接下来会讲，看不懂先不要着急。

tuple元组

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。

元组和列表（list）的不同之处在于：
列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。

从形式上看，元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔，如下所示：

(element1, element2, ... , elementn)

其中 element1~elementn 表示元组中的各个元素，个数没有限制，只要是 Python 支持的数据类型就可以。

我们不妨通过 type() 函数来查看一下元组的类型：

	type( ("c.biancheng.net",1,[2,'a'],("abc",3.0)) )

输出：

Python 提供了两种创建元组的方法，下面一一进行介绍。
使用 ( ) 直接创建
通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：

	tuplename = (element1, element2, ..., elementn)

其中，tuplename 表示变量名，element1 ~ elementn 表示元组的元素。

注意：在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组。当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。

使用tuple()函数创建元组
除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。

tuple() 的语法格式如下：

	tuple(data)

其中，data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。

tuple() 使用示例：

	#将字符串转换成元组
	tup1 = tuple("hello")
	print(tup1)
	#将列表转换成元组
	list1 = ['Python', 'Java', 'C++', 'JavaScript']
	tup2 = tuple(list1)
	print(tup2)
	#将字典转换成元组
	dict1 = {
     'a':100, 'b':42, 'c':9}
	tup3 = tuple(dict1)
	print(tup3)
	#将区间转换成元组
	range1 = range(1, 6)
	tup4 = tuple(range1)
	print(tup4)
	#创建空元组
	print(tuple())

运行结果为：
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
(‘Python’, ‘Java’, ‘C++’, ‘JavaScript’)
(‘a’, ‘b’, ‘c’)
(1, 2, 3, 4, 5)
()

Python访问元组元素
和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。

使用索引访问元组元素的格式为：

	tuplename[i]

其中，tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数。

使用切片访问元组元素的格式为：

	tuplename[start : end : step]

其中，start 表示起始索引，end 表示结束索引，step 表示步长。

Python修改元组
前面我们已经说过，元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。
另外，还可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素。

Python删除元组
当创建的元组不再使用时，可以通过 del 关键字将其删除，例如：
Python 自带垃圾回收功能，会自动销毁不用的元组，所以一般不需要通过 del 来手动删除。

dict字典

Python 字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。

Python创建字典

创建字典的方式有很多。
使用 { } 创建字典
由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。

使用{ }创建字典的语法格式如下：

	dictname = {
     'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

其中 dictname 表示字典变量名，keyn : valuen 表示各个元素的键值对。需要注意的是，同一字典中的各个键必须唯一，不能重复。

通过 fromkeys() 方法创建字典
Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：

	dictname = dict.fromkeys(list，value=None)

其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。

请看下面的例子：

	knowledge = ['语文', '数学', '英语']
	scores = dict.fromkeys(knowledge, 60)
	print(scores)
	运行结果为：
	{
     '语文': 60, '英语': 60, '数学': 60}

可以看到，knowledge 列表中的元素全部作为了 scores 字典的键，而各个键对应的值都是 60。这种创建方式通常用于初始化字典，设置 value 的默认值。

通过 dict() 映射函数创建字典

Python 访问字典
列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。

Python 访问字典元素的具体格式为：

	dictname[key]

其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

请看下面的例子：

	tup = (['two',26], ['one',88], ['three',100], ['four',-59])
	dic = dict(tup)
	print(dic['one'])  #键存在
	print(dic['five'])  #键不存在

运行结果：
88
Traceback (most recent call last):
File “C:\Users\mozhiyan\Desktop\demo.py”, line 4, in
print(dic[‘five’]) #键不存在
KeyError: ‘five’

除了上面这种方式外，Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。

get() 方法的语法格式为：

	dictname.get(key[,default])

其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

Python删除字典
和删除列表、元组一样，手动删除字典也可以使用 del 关键字，例如：

	a = dict(two=0.65, one=88, three=100, four=-59)
	print(a)
	del a
	print(a)

运行结果：
{‘two’: 0.65, ‘one’: 88, ‘three’: 100, ‘four’: -59}
Traceback (most recent call last):
File “C:\Users\mozhiyan\Desktop\demo.py”, line 4, in
print(a)
NameError: name ‘a’ is not defined

Python 自带垃圾回收功能，会自动销毁不用的字典，所以一般不需要通过 del 来手动删除。

由于字典属于可变序列，所以我们可以任意操作字典中的键值对（key-value）。

Python 中，常见的字典操作有以下几种：
向现有字典中添加新的键值对。
修改现有字典中的键值对。
从现有字典中删除指定的键值对。
判断现有字典中是否存在指定的键值对。
初学者要牢记，字典是由一个一个的 key-value 构成的，key 是找到数据的关键，Python 对字典的操作都是通过 key 来完成的。

Python字典添加键值对
为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：

	dictname[key] = value

对各个部分的说明：
dictname 表示字典名称。
key 表示新的键。
value 表示新的值，只要是 Python 支持的数据类型都可以。

Python字典修改键值对
Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。

字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。请看下面的代码：

	a = {
     '数学': 95, '语文': 89, '英语': 90}
	print(a)
	a['语文'] = 100
	print(a)

运行结果：
{‘数学’: 95, ‘语文’: 89, ‘英语’: 90}
{‘数学’: 95, ‘语文’: 100, ‘英语’: 90}

Python字典删除键值对
如果要删除字典中的键值对，还是可以使用 del 语句。例如：

	# 使用del语句删除键值对
	a = {
     '数学': 95, '语文': 89, '英语': 90}
	del a['语文']
	del a['数学']
	print(a)

运行结果为：
{‘英语’: 90}

判断字典中是否存在指定键值对
如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。
需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

例如如下代码：

	a = {
     '数学': 95, '语文': 89, '英语': 90}
	# 判断 a 中是否包含名为'数学'的key
	print('数学' in a) # True
	# 判断 a 是否包含名为'物理'的key
	print('物理' in a) # False

运行结果为：
True
False

通过 in（或 not in）运算符，我们可以很轻易地判断出现有字典中是否包含某个键，如果存在，由于
通过键可以很轻易的获取对应的值，因此很容易就能判断出字典中是否有指定的键值对。
python dict还有很多方法，篇幅限制，不再一一列举。请大家自己查阅相关资料。

set集合

即和使用较少，也比较好理解，这里不再讲解。清同学们查阅资料。