简介
◆ 序列是一维元素向量，元素类型可以不同
◆ 类似数学上的序列

◆ 元素间由序号引导，通过下标访问序列的特定元素

◆ 主要类型包括：字符串类型、元祖类型、列表类型

通用的操作符

◆ s + t            连接两个序列s和t
◆ s*n或n*s      将序列s复制n次

◆ s[i]               索引序列s中的i元素

◆ s[i:j:k]           索引序列s中从i到j，不包含j，以k为步长的元素
◆ s.index(x,i,j)  返回序列从i到j中第一次出现x的位置

◆ s.count(x)     返回序列s中x出现的次数

元组类型
◆ 是一种序列类型，一旦创建就不能被修改，因此没有特殊操作
◆ 使用小括号()或tuple()创建，元素间用逗号分隔

◆ 可以使用或不使用小括号

◆ 继承了序列类型的全部通用操作

列表类型
◆ 是一种序列类型，创建后可以随意更改
◆ 使用方括号[]或list()创建，元素间用逗号分隔

◆ 可以使用或不使用小括号

列表类型的操作符

◆ ls[i]=x                       将列表ls中的i索引元素替换成x
◆ ls[i:j:k]=lt                  将列表ls切片的元素替换成lt中的元素

◆ del ls[i]或del ls[i:j:k]   删除元素或者切片

◆ ls +=lt                      将ls加上lt并更新ls

◆ ls *=n                       将ls复制n次

◆ ls.append(x)              在ls列表后面增加元素x

◆ ls.clear()                    清空列表ls

◆ ls.copy()                    将ls中的元素复制到新的列表中
◆ ls.insert(i,x)                在列表ls索引i处增加元素x

◆ ls.pop(i)                     删除列表ls索引i处的元素

◆ ls.remove(x)               将列表ls中第一次出现的x删除

◆ ls.reverse()                 将列表ls翻转

序列类型数据的应用

◆  遍历元素
使用的主要的结构为： for i in ls :     <语句块>
◆  数据保护

对于不想改变的数据或者想要保护的数据，可以将他们转换成元组类型的
s=[1,2,3,4,5]
ls=tuple(s)
print(ls)
# RUN->(1, 2, 3, 4, 5)

有序序列有：列表、元组、字符串
 无序序列有：字典、集合
 
可变序列有：列表、字典、集合
 不可变序列有：字符串、元组

单元概述
 主要解决问题：让程序更好地处理一组数据
 三类重要组合数据类型：集合类型、序列类型和字典类型
 
学完本章，我们能够在头脑中建立集合、序列和字典的模式来表达对一组数据的表达和处理
 
1. 定义
 
序列是具有先后关系的一组元素
 -序列是一维元素向量，元素可以相同，元素类型可以不同
 -类似数学元素序列：S0,S1,…,Sn
 -元素间由序号引导，可通过下标访问特定元素
 
序列是一个基类类型，一般不会被直接使用
 其衍生类型：字符串类型、元组类型、列表类型
 
其有两种编号体系
 
 
2. 序列处理函数及方法
 
① 六个通用操作符
 
 
例
ls = ["python",123,".io"]
print(ls[::-1])
输出
['.io', 123, 'python']
 
② 五个函数和方法
 
 
例
ls = ["python",123,".io"]
print(len(ls))

s = "python123.io"
print(max(s))
输出
3
y//最大字母序
 
3. 元组类型及操作
 
元组是序列类型的拓展，特点是一旦创建、不可修改。
 
表示：使用()或者tuple()创建，元素间用逗号分隔
 
使用时小括号可有可无
 
例1
def func():
    return 1,2
这里虽返回了两个值，但在python内部认为是一个元组类型值

例2
creature = "dog","cat","tiger","human"
print(creature)
输出
('dog', 'cat', 'tiger', 'human')

例3
color = (0x001100,"blue",creature)
print(color)
输出
(4352, 'blue', ('dog', 'cat', 'tiger', 'human'))
 
元组类型继承了序列类型全部通用操作，没有特殊操作
 
例
print(color[-1][1])
输出
cat
 
4. 列表类型及操作
 
列表是序列类型的一种拓展，十分常用，创建后可以任意被修改
 
使用[]或list()创建，元素间用逗号分隔
 
列表中元素类型可以不同，长度无限制
 
例
ls = ["cat","dog","yoyo",123]
lt = ls
注：此处lt和ls仍指向同一个列表，相当于起了个别名
 
操作函数及方法
 
 
例
ls = ["cat","dog","yoyo",123]
ls[1:2] = [1,2,3,4]
print(ls)
输出
['cat', 1, 2, 3, 4, 'yoyo', 123]

例
del ls[::3]
print(ls)
输出
[1, 2, 4, 'yoyo']

例
print(ls*2)
输出
[1, 2, 4, 'yoyo', 1, 2, 4, 'yoyo']
 
 
序列类型应用场景
 ① 数据表示，即表示一组有序数据，进而操作它们
 -元组用于元素不改变的应用场景，更多用于固定搭配场景（如函数返回值return）
 -列表更加灵活，是更常用的序列类型
 
元素遍历
 for item in ls(列表):
 <语句块>
 for item in tp(元组):
 <语句块>
 
② 数据保护
 如果不希望数据被修改，就将其转换成元组类型
 
例
ls = ["cat","dog","yoyo",123]
lt = tuple(ls)
print(lt)
输出
('cat', 'dog', 'yoyo', 123)
 
出处：北理工Python慕课

集合
 
集合是多个元素的无序组合
 
集合元素之间无序
 
集合由不可变数据类型元素组成，如整数、浮点数、复数，字符串、元组类型等
 
集合用大括号{}组成，元素之间用逗号隔开
 
每个元素唯一，不存在相同元素
 
 
 
一、集合间操作
 
并（S|T ）
 
S-T
 
S&T
 
S^T  返回一个新集合，包括集合S和T中的非相同元素
 
S<=T或S<T
 
S>=T或S>T
 
集合处理方法
 
S.add(x)
 
S.discard(x)
 
S.remove(x)
 
S.clear()
 
S.pop()
 
S.copy()
 
len(S)
 
x in S
 
x not in S
 
set(x)   将其他类型的元素转变为集合类型
 
集合类型应用场景
 
1，包含关系的比较   
 
2，数据去重 例 ls=["p","p","y","y",123]   s=set(ls)   lt=list(s)
 
二、序列类型
 
序列是一维向量元素，元素类型可以不同，元素间序号引导
 
延伸：字符串类型、元祖类型、列表类型。
 
序列处理函数及方法：
 
6个操作符
 
x in S
 
x not in S
 
s+t
 
s*n或n*s
 
s[i]
 
s[i:j]或S[i,j,k]
 
5个函数和方法
 
len(s)
 
min(s)
 
max(s)
 
s.index(x)或s.index(x,i,j)     返回序列s从i开始到j位置中第一次出现元素x的位置
 
s.count(x)   s中出现x的总次数
 
元祖类型及操作
 
元祖可以被看做是不能改变的列表。
 
元祖是一种序列类型一旦创建就不能修改，使用小括号（）或tuple创建，元素间用逗号隔开，
 
元祖类型继承了序列类型的全部通用操作
 
因为元祖创建后不能修改，因此没有特殊操作
 
列表类型
 
列表是一种数据类型，创建后可以随意修改
 
使用中括号[]或list创建
 
列表类型的操作函数及方法
 
ls[i]=x
 
ls[i:j:k]=lt
 
del ls[i]
 
del ls[i:j:k]
 
ls+=lt   更新列表ls,将列表lt元素增加到列表ls中
 
ls*=n   更新列表ls，其元素重复n次
 
ls.append(x)    表示在列表
 
ls.clear()
 
ls.copy()
 
ls.insert(i,x)
 
ls.pop(i)   取出第i位置的元素取出并删除该元素
 
ls.remove(x)   将列表ls中出现的第一个元素x删除
 
ls.reverse（）将列表ls中的元素反转
 
访问列表中所有元素
 
如果列表中有上百万个元素，你只需要三行就能访问到所有的元素。
 
dogs=['border collie','australian cattle dog','lamdba']
 
for dog in dogs:
 
      print(dog)b
 
穷举列表
 
循环一个列表的时候，你可能想获取当前元素的索引。你可以采用list.index(value）的方式获取，或者采取一个更简单的方法。enumerate（）函数可以帮助你跟踪每项元素的索引，如下所示：
 
dogs=['border collie','australian cattle dog','lamdba']
 
for index，dog in enumerate（dogs）:
 
place=str(index)
 
print("place:"+place+"dog:"+dog)
 
列表推导式
 
数字列表的推导式
 
回顾上节知识，我们可以创建一个包含前10个数字的列表，如下所示：
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
# Store the first ten square numbers in a list.
 
# Make an empty list that will hold our square numbers.
 
squares = []
 
# Go through the first ten numbers, square them, and add them to our list.
 
for number in range(1,11):
 
new_square = number**2
 
squares.append(new_square)
 
# Show that our list is correct.
 
for square in squares:
 
print(square)
 
上述代码中我们实现了创建包含10个数字的列表，对每个数字作平方操作并将它们存储进新的数组的功能。代码略显冗长，我们可以省略 for 循环中的 new_square 参数，简化代码。使用列表推导式就可以进一步简化代码，如下所示：
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
# Store the first ten square numbers in a list.
 
squares = [number**2 for number in range(1,11)]
 
# Show that our list is correct.
 
for square in squares:
 
print(square)
 
平方操作和生成新列表的过程都浓缩进了一行代码。你是不是已经晕头转向了，让我们来看看这行代码发生了什么。
 
首先我们定义了一个列表，名字为 squares 。
 
接下来看看列表中括号中的代码：
 
for number in range(1, 11)
 
它在1-10之间创建一个循环，把每个数字存储到变量 number 中。接下来我们看一看对每次循环中的 number 作了哪些操作。
 
 number**2
 
每个 number 都作了平方操作，并将结果存储在了定义好的队列中。我们可以用如下语言来阅读这行代码：
 
squares = [raise number to the second power, for each number in the range 1-10]、
 
其他例子
 
上个例子是对数字作平方操作，下列代码是对数字作乘操作，仔细阅读代码，体会数字列表表达式的用法。
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
# Make an empty list that will hold the even numbers.
 
evens = []
 
# Loop through the numbers 1-10, double each one, and add it to our list.
 
for number in range(1,11):
 
evens.append(number*2)
 
# Show that our list is correct:
 
for even in evens:
 
print(even)
 
简化后代码如下所示：
 
 
 
 
1
 
2
 
3
 
4
 
5
 
# Make a list of the first ten even numbers.
 
evens = [number*2 for number in range(1,11)]
 
for even in evens:
 
print(even)
 
非数字列表的推导式
 
我们也可以在非数字列表中运用推导式。在下面的例子中，我们会创建一个非数字列表，然后利用推导式生成一个新的列表。不运用推导式的源代码如下所示：
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
# Consider some students.
 
students = ['bernice', 'aaron', 'cody']
 
# Let's turn them into great students.
 
great_students = []
 
for student in students:
 
great_students.append(student.title() + " the great!")
 
# Let's greet each great student.
 
for great_student in great_students:
 
print("Hello, " + great_student)
 
我们想写下如下所示的推导式：
 
great_students = [add 'the great' to each student, for each student in the list of students]
 
代码如下所示：
 
 
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
# Consider some students.
 
students = ['bernice', 'aaron', 'cody']
 
# Let's turn them into great students.
 
great_students = [student.title() + " the great!" for student in students]
 
# Let's greet each great student.
 
for great_student in great_students:
 
print("Hello, " + great_student)
 
动手试一试
 
 
 
 
 
 
 
 
 
三、字典类型
 
键值对
 
采用大括号和dict()创建，键值对间用：分割
 
字典处理函数及方法
 
del d[k]  删除字典d中键k对应的数据值
 
k in d  判断键k是否在字典中，如果在返回True,否则False
 
d.keys()  返回字典d中所有的键信息
 
d.values()
 
d.items()
 
d.get(k,<default>)    键K存在，则返回相应值，不在则返回<default>
 
d.pop(k,<default>)    键K存在，则取出相应值，不在则返回<default>
 
d.popitem()   随机从字典中取出一个键值对，以元祖形式返回
 
d.clear()
 
len(d)