序列指的是一块连续内存空间存放多个值，在python中，序列类型包括字符串、列表、字典、元组、集合。其中包括字符串、列表、元组为有序序列，字典、集合属于无序序列。例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print(name,type(name),sep=":")
print(classes,type(classes),sep=":")
print(teacher,type(teacher),sep=":")
print(gender,type(gender),sep=":")
print(cities,type(cities),sep=":")

上述输出结果为：

张三丰:<class 'str'>
['一班', '二班', '三班']:<class 'list'>
{'name': '张三丰', 'age': 105, 'gender': '男'}:<class 'dict'>
('男', '女'):<class 'tuple'>
{'广州', '北京', '上海', '杭州'}:<class 'set'>

（一）、索引下标

有序序列中每个元素都有自己的编号，这个编号就是索引下标。从左向右索引下标逐渐增大。若从左向右，则索引下标从0开始递增；若从右向左，则索引下标从-1开始递减。字典和集合属于无序序列，不存在索引下标。

（二）、和序列相关的通用内置函数

1、len()

该函数可以用来计算序列的长度，即获取序列中元素的个数。例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print("name长度为",len(name),sep=":")
print("classes长度为",len(classes),sep=":")
print("teacher长度为",len(teacher),sep=":")
print("gender长度为",len(gender),sep=":")
print("cities长度为",len(cities),sep=":")

上述输出结果为：

name长度为:3
classes长度为:3
teacher长度为:3
gender长度为:2
cities长度为:4

2、join()

该函数可以用来通过指定连接符连接序列中的元素，并返回连接后的序列，例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print(" ".join(name))
print("|".join(classes))
print(";".join(teacher))
print("?".join(gender))
print("~".join(cities))

上述输出结果为

张 三 丰
一班|二班|三班
name;age;gender
男?女
广州~北京~上海~杭州

注：利用该函数对字典运用连接符进行连接时，会对字典所有的键进行连接，而非键值对

3、max()

该函数可以用来获取序列中的最大元素，例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print("name中的最大值为：",max(name),sep=":")
print("classes中的最大值为：",max(classes),sep=":")
print("teacher中的最大值为：",max(teacher),sep=":")
print("gender中的最大值为：",max(gender),sep=":")
print("cities中的最大值为：",max(cities),sep=":")

上述输出结果为：

name中的最大值为：:张
classes中的最大值为：:二班
teacher中的最大值为：:name
gender中的最大值为：:男
cities中的最大值为：:杭州

注：利用该函数取得字典中最小值时，其本质是获取字典所有键的最大值。

另外，max()函数还可以通过参数key设置获取最大值的规则，可以是函数，也可以是lambda表达式，例如：

list1=[-4,-1,2,3] # 定义一个变量list1，并赋值为[-4,-1,2,3]

# 获取no2的值
def getnum(no):
    return no*2
print(max(list1,key=getnum)) # 指定key为getnum函数
print(max(list1,key=lambda x:abs(x))) # 指定key为lambda
print(max(list1,key=abs)) # 指定key为内置函数

上述输出结果为：

3
-4
-4

4、min()

该函数可以用来获取序列中的最小元素，例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print("name中的最大值为：",min(name),sep=":")
print("classes中的最大值为：",min(classes),sep=":")
print("teacher中的最大值为：",min(teacher),sep=":")
print("gender中的最大值为：",min(gender),sep=":")
print("cities中的最大值为：",min(cities),sep=":")

上述输出结果为：

name中的最大值为：:三
classes中的最大值为：:一班
teacher中的最大值为：:age
gender中的最大值为：:女
cities中的最大值为：:上海 

注：关于min()函数获取字典中的最小元素以及参数key的使用，可以参考max()函数的使用。

5、sorted()

该函数的可以用来对序列中的元素进行排序并以列表的形式返回，默认是升序，并且不会改变序列本身的顺序，可通过设置reverse=True将排序方式改为降序。例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print(name,sorted(name),sorted(name,reverse=True),sep="|")
print(classes,sorted(classes),sep="|")
print(teacher,sorted(teacher),sep="|")
print(gender,sorted(gender),sep="|")
print(cities,sorted(cities),sep="|")

上述输出结果为：

张三丰|['三', '丰', '张']|['张', '丰', '三']
['一班', '二班', '三班']|['一班', '三班', '二班']
{'name': '张三丰', 'age': 105, 'gender': '男'}|['age', 'gender', 'name']
('男', '女')|['女', '男']
{'杭州', '北京', '上海', '广州'}|['上海', '北京', '广州', '杭州']

注：关于sorted()函数对于字典进行排序时，其本质为对字典中的键进行排序。

7、reversed()

该函数可以用来对序列（集合除外）中的元素进行逆序排列，返回的是一个可迭代的reversed对象，且该函数不会改变序列本身的顺序，例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print(name," ".join(reversed(name)),sep="|") # 利用join()函数对reversed内部元素进行显示
print(classes," ".join(reversed(classes)),sep="|")
print(teacher," ".join(reversed(teacher)),sep="|")
print(gender," ".join(reversed(gender)),sep="|")

上述输出结果为：

张三丰|丰 三 张
['一班', '二班', '三班']|三班 二班 一班
{'name': '张三丰', 'age': 105, 'gender': '男'}|gender age name
('男', '女')|女 男

注：字典和集合同为无序列表，但是字典支持reversed()函数，而集合不支持，这是因为在字典内部是一个OrderedDict，该类型会保存插入键值对时键的添加顺序；而集合内部没有保存数据的添加顺序，所以无法进行逆序reversed()。

（三）、判断元素是否在序列中

1、in

python中提供了in关键字，用于判断某个元素或者子序列是否在序列中。如果在，返回True；如果不在，则返回False。例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print("张" in name) # 判断字符张是否在name中存在
print("一班" in classes) # 判断一班是否存在classes中
print("address" in teacher,"张三丰" in teacher) # 判断address和张三丰是否在teacher中
print("男" in gender) # 判断男是否存在gender中
print("郑州" in cities) # 判断郑州是否存在cities中

上述输出结果为：

True
True
False False
True
False

2、not in

python中提供了not in关键字，判断某个元素或者子序列是否在序列中，如果不在，返回True，如果在，则返回False。例如：

# 定义变量name，并赋值为字符串"张三丰"
name="张三丰"
# 定义变量classes，并赋值为列表['一班',"二班","三班"]
classes=['一班',"二班","三班"]
# 定义变量teacher，并赋值为字典{"name":"张三丰","age":105,"gender":"男"}
teacher={"name":"张三丰","age":105,"gender":"男"}
# 定义变量gender，并赋值为元组("男","女")
gender=("男","女")
# 定义变量cities，并赋值为集合{"北京","上海","广州","杭州"}
cities={"北京","上海","广州","杭州"}
print("张"  not in name) # 判断字符张是否在name中存在
print("一班" not in classes) # 判断一班是否存在classes中
print("address"not in teacher,"张三丰" not in teacher) # 判断address和张三丰是否在teacher中
print("男" not in gender) # 判断男是否存在gender中
print("郑州" not in cities) # 判断郑州是否存在cities中

上述输出结果为：

False
False
True True
False
True

注：in 和not in 关于字典的操作，键和值均会参与判断。

优秀的人永远都在提升自己