一、通用序列操作
Python中有六种内置序列（有些内置函数也能返回一些特殊序列，可以对它进行一些通用序列操作），其中有三种基本序列类型比较常见:列表、元组和字符串。
1、索引
索引就是根据下标来取出数据的值，列表和元组都可以利用下标索引来取值，下标索引从零开始。
# 列表
x1 = [1,2,3,4]
print("列表")
# 根据下标取值，下标从零开始
print(x1[0])
print(x1[1])
print('---------')
# 元组
x2 = (1,2,3,4)
print('元组')
# 根据下标取值，下标从零开始
print(x2[0])
print(x2[2])2、切片
切片就是利用索引下标进行数据的截取操作。
# 一、列表
x1 = [1,2,3,4]
print('列表')
print(x1[::-1]) # 切片方法的逆序输出
print(x1.reverse()) # 内置函数方法进行逆序输出
'''
拓展：
这里的逆序输出也可以利用Python中的内置函数来实现
例如：print(x1.reverse())
'''
# 列表的排序
x1.sort()
print(x1) # 默认升序
x1.sort(reverse=True) # 带上参数reverse=True则是降序
print(sorted(x1)) # 默认升序
print(soted(x1,reverse=True)) # 降序，带上参数reverse=True则是降序
print(x1[-1]) # 打印输出最后一个数据
print(x2[-2]) # 打印输出倒数第二个数据
# 列表的切片
'''
x1[z1,z2,z3],切片z1~z2代表的是打印输出的下标索引区间数据值，z3表示步长，间隔一个步长就是间隔一个数据打印输出，具体操作如下所示
'''
print(x1[1:3:1]) # 打印输出[2,4]
print(x1[-3:3]) # 打印输出[2,3]
# 二、元组(元组切片与列表相同)
x2 = (1,2,3,4)
'''排序切片方法与列表相同，只是这里元组数据类型不能够修改，一次创建终生使用原则，除非创建一个新元组，否则修改不了'''
x2.sort()
print(x2) # 默认升序
print(sorted(x2)) # 默认升序
print(sorted(x2,reverse=Truye)) # 降序
del x2 # 删除元组
# 元组的切片
print(x2[1:3:1]) # 打印输出(2,3)
print(x2[-3:3]) # 打印输出(2,3)
# 三、字符串(字符串切片与列表相同)
x3 = "1234"
print('字符串')
# 字符串的切片
print(x3[1:3])
print(x3[0:3])
print(x3[-3:3]) # 打印输出: 23
3、序列相加和重复
序列之间可以使用“+”号进行连接操作。（注意：只能在同种数据类型下使用）
我们还可以使用''*''号做乘法，进行序列重复。
# 1、序列相加
# 列表
x1 = [1,2,3,4]
print('列表')
x2 = [5,6,7]
print(x1+x2) # 打印输出[1,2,3,4,5,6,7]
# 元组
x3 = (1,2,3)
print('元组')
x4 = (4,5)
print(x3+x4) # 打印输出(1,2,3,4,5)
# 字符串
z1 = 'abc'
print('字符串')
z2 = 'def'
print(z1+z2) # 打印输出:abcdef
# 2、序列重复
# 列表
li = [1,2]
print(li*2) # 打印输出[1,2,1,2]
# 元组
y = (1,2,3)
print(y*3) # 打印输出(1,2,3,1,2,3,1,2,3)
# 字符串
z = 'abc'
print(z*2) # 打印输出: abcabc
4、长度、最大或最小值和求和
python中提供了不少方法可以给存储数字的序列使用。
# 列表
x1 = [1,2,3]
print('列表')
print('最大值为：'，max(x1))
print('最小值为：',min(x1))
print('求和的值为：',sum(x1))
print('列表长度：'，len(x1))
# 元组
x2 = (1,2,3)
print('元组')
print('最大值为：'，max(x2))
print('最小值为：',min(x2))
print('求和的值为：',sum(x2))
print('元组长度：'，len(x2))
# 字符串
x3 = '123'
print('元组')
print('最大值为：'，max(x3))
print('最小值为：',min(x3))
print('求和的值为：',sum(x3))
print('字符串长度：'，len(x3))
二、列表的基本操作
1、列表的更新
a1 = [1,2,3,4,5]
print(a1[2])
a1[2] = 'hello'
print(a1) # 打印输出：[1,2,'hello',4,5]2、添加列表中的元素
a1 = [1,2,3]
print(a1)
a1.append('hello') # 增加列表的元素
print(a1) # 打印输出[1,2,3,'hello']
a2 = [1,2,3]
a2.extend([4,5]) # extend函数增加列表的元素里面增加存放的是可迭代对象itemable
print(a1) # 打印输出[1,2,3,4,5]
a3 = [1,2,3]
a3.append([4,5])
'''
这里我们可以看一下这个插入的元素，append()函数会把这个列表看成一个整体元素直接插入a3列表中
'''
print(a3) # 打印输出 [1,2,3,[4,5]]
"""
append()和extend()函数都是插入在列表最后面的插入函数，下面我们来看一下指定位置插入函数insert()
"""
'''
insert(z1,z2)函数中第一个参数z1表示插入元素下标索引，第二个参数z2表示插入元素的数据内容
'''
a1.insert(3,'hello')
print(a1)
3、删除列表中的元素
a1 = [1,2,3,4,5]
print(a1)
'''
pop()函数有返回值，返回的是删除的元素。默认情况下删除最后一个元素，可以根据
'''
r1 = a1.pop()
print(r1) # r1是返回的删除的元素
print(a1) # 删除完元素之后的列表
a2 = [1,2,3,4,5]
print(a2)
r2 = a2.pop(2) # 根据下标索引删除元素
print(r2)
print(a2)
'''
remove(r1,r2)参数r1表示查找要删除的元素，r2参数代表如果该元素存在多个，删除这个元素几遍
未指定默认情况下会删除查找到的第一个元素，并且没有返回值
'''
a2 = [1,2,3,4,5]
print(a2)
print(a2.remove(2)) # 根据查找到的元素进行删除，删除查找到的第一个元素
'''
del 不仅可以删除列表中的元素，还可以删除其他的元素，后面会详细讲到
'''
a3 = [4,5,6]
del a2[0] # 删除下标索引为0的元素4、查找列表中的元素
a1 = ['hello','beijing','shanghai','QQ','weixing']
print(a1.index("QQ")) # 打印输出数据所在列表的下标索引值
5、队列的其他操作
a1 = [1,2,3,4]
print(a1)
print("reverse反转列表")
a1.reverse()
print(a1) # 打印输出[4,3,2,1]
a2 = ["hello","Tenxun","QQ","hello"]
print(a2.count("hello")) # 统计出现“hello”这个元素的次数
# 排序一般用于列表中全为数字时，进行排序
a = [34,51,22,12]
a.sort() # 默认升序
print(a) # 打印输出[12,22,34,51]
a.sort(reverse=True) # 加上参数reverse=True表示降序操作
print(a) # 打印输出[51,34,22,12]
# 拓展：或者使用sorted函数进行排序
print(sorted(a)) # 默认情况下为升序
print(sorted(a,reverse=True)) # 降序三、元组的基本操作
1、定义元组
a = (1)
print(type(a)) # <class 'int'>
a1 =(1,) # 创建元组时，如果只有一个元素，后面要加上一个逗号
print(type(a1)) # <class 'tuple'> 2、删除元组
a = (1,2,3)
del a
print(a) # 报错，(NameError:name 'a' is not definel)表示不存在该数据，该数据没有定义
a1 = (3,4,5)
del a1[2] # 根据下标索引删除元组中的元素
print(a1) # 打印输出(3,4）
3、元组的其他操作
a1 = ('hello','beijing','shanghai','QQ','weixing')
print(a1.index("QQ")) # 打印输出数据所在列表的下标索引值
a2 = ('hello','beijing','shanghai','QQ','weixing','hello')
print(a2.count('hello')) # 打印输出: 2 (count查找该元素在元组中出现的次数)注意：元组不能进行修改，一次创建，终生使用。
四、字符串的基本操作
字符串一般使用单引号或双引号括起来。str = "hello"或者str = ‘TTT’.(其实三个单引号三个双引号也行，但没必要这么麻烦的创建，小编这里就不做展示了)
# S.find()-->返回该元素的最小索引值
s = 'hello python'
print(s.find('e')) # 1
print(s.find('o')) # 4，返回最小索引
print(s.find('b')) # -1，没有不报错，返回-1
print(s.index('o')) # index()函数作用在列表中找到该元素并返回其位置，没有找到会报错
# S.replace(old,new[,count])-->替换列表中的元素
s1 = 'hello old old girl'
print(s1.replace('old', 'beautiful')) # 默认全部替换
print(s1.replace('old', 'beautiful', 1)) # 替换一次
print(s1) # 在进行替换时，先进行了一次复制，之后再做操作
# S.split()-->以sep来分割字符串，并返回列表。sep默认为None,分割默认为空格
s2 = 'hello，everyone'
print(s2.split('o')) # []返回的是列表，返回结果是：['hell', '，every', 'ne']
# S.startswith(prefix[,start[,end]])-->判断字符串是否以某前缀开始，返回值为bool值
s3 = 'hello，everyone'
print(s3.startswith('h')) # True
print(s3.startswith('hel')) # True
print(s3.startswith('o', 4)) # True
# S.endswith(suffix[,start[,end]])-->判断字符串是否以某尾缀结束，返回值为bool值
s4 = 'hello world!'
print(s4.endswith('ld!')) #
print(s4.endswith('o', 1, 5)) # ello[1,4)
# S.lower()-->将字符串全部转化为小写
# s5 = 'ABC'
# print(s5.lower())
# S.upper()-->将字符串全部转化为大写
# s6 = 'abc'
# print(s6.upper())
# 链式调用
# print(s6.upper().lower()) # 只针对英文的大小写
# S.strip([chars])-->默认去掉字符串左右的字符，默认是空格
# s7 = '%逻辑 教育%'
# print(s7.strip('%')) # 默认去除空格
# print(s7.replace(' ', '')) # 替换
# print(s7.split(' ')) # 分割
# S.isalpha()-->判断字符串是否全为字母，返回的是bool值
# s8 = 'abc'
# print(s8.isalpha())
# S.isdigit()-->判断字符串是否全为数字，返回的是bool值
# s9 = '123a'
# print(s9.isdigit())
# S.isalnum()-->判断字符串是否由数字或字母组成，不存在特殊字符，返回的是bool值
# s10 = '123a'
# print(s10.isalnum())
# S.join(iterable)-->将序列中的元素以指定的字符连接生成一个新的字符串
sss = 'hello world'
print(sss[0])
print('*'.join(sss)) # iterable 可迭代———可以将元素一个个取出
# 字符串的切片
# 语法：slice(start,stop[,step)) # start表示起始位置，默认为0，stop结束位置默认最后一个元素，可选参数：步长，默认为1
# 字符串的切片
name = "hello world"
# print(len(name)) # 字符串长度
# print(name[6:10:]) # 范围是半闭半开区间 [6:10)
print(name[6:11:]) # 取完整个字符串
print(name[::2]) # 间隔两个输出
print(name[::-1]) # 逆序输出五、字典的基本操作
1、定义字典
字典类型就和它的名字一样，可以像查找字典一样去查找。其他语言里也有一些类似的类型，如PHP中的Array,Java中的HashMap。其实创建字典很简单，例如：
english = {"we":"我们","world":"世界","company":"公司"}
print("english",type(english))从上面的例子中我们可以看出，字典其实是成对出现的，每个元素都是由“：”和键值对（左边key值,右边values值构成），元素和元素之间用冒号“：”分隔开，整个字典用{}花括号包裹。字典里面的键必须唯一且不重复，如果是空字典（一个元素都没有），则可以用{}表示
empty = {}
print("empty",type(empty))2、使用字典
english = {"we":"我们","world":"世界","company":"公司"}
print("world",english["world"])3、字典的其他操作
english = {"we":"我们","world":"世界","company":"公司"}
print(english)
english.clear() # clear()清空字典
print(english)
english1 = english.copy()
print(english1) # 浅拷贝，复制
print(english.keys) # key值
print(english.values) # values值
print(english.items) # 同时查看key和values值
由于字典不能直接应用于for循环里，所以我们可以使用items方法来遍历字典。例如：
english = {"we":"我们","world":"世界","company":"公司"}
for k,v in english.items():
print(k,"=>",v)
六、集合的基本操作
python中有一种内置类型叫做集合（Set）,它是一个非常有用的数据结构，它与列表（List）的行为类似，唯一区别在于集合不会包含重复的元素。
1、集合的创建
# 创建空集合，这里需要注意的是空集合不能使用{}定义
s = set()
print("空集合："，s)
# 创建数字集合
s1 = {1,2,3}
print("数字集合：",s1)
# 创建混合类型集合
s2 = set([1,"您好！",3.14])
print("混合类型集合：",s2)2、添加集合的元素
num = {1,2,3}
print(num)
num.add(4)
print(num) # {1,2,3,4}
num.add(5)
print(num) # {1,2,3,4,5}
3、删除集合中的元素
num = {1,2,3}
print(num)
num.remove(2)
print(num) # {1,3}
n1 = {1,3,5}
n2 = {2,7,,1,3}
# 交集
print("交集",n1 & n2)
# 并集
print("并集",n1 | n2)
# 差集
print("差集",n1-n2)
# 对称差集
print("对称差集",n1 ^ n2)
七、列表、字典和集合的推导式
Python中支持三种推导式（或者称为解析式），分别对应列表、字典和集合。它能够以非常自然、简单的方式构建列表、字典或集合，就像数学家哪样。
列表推导式的语法：用中括号括起来，中间使用for语句，后面跟着if语句用作判断，满足条件的传到for语句前面用作构建的列表。(列表推导式最擅长的就是对整个列表分别做相同的操作，并且返回得到一个新的列表)
a1 = [x for x in range(5)]
print(a1) # 打印结果：[0,1,2,3,4]
odd = [x for x in range(10) if x % 2 != 0 ]
print(odd) # 打印结果：[1,3,5,7,9]第二种是字典推导式，字典推导式和列表推导式类似。字典的元素是成对出现的，所以推导式定义的时候也是成对生成键值对。例如：
d1 = {n : n**2 for n in range(5)}
print(d1) # 打印结果:{0:0,1:1,2:4,3:9,4:16}
d2 = {v : k for k,v in d1.items()}
print(d2) # 打印结果:{0:0,1:1,4:2,9:3,16:4}
最后一种，就是集合推导式。集合推导式和列表推导式没有什么太大的区别，但是集合推导式会帮我们去除重复的元素，并且不使用中括号，而是使用花括号。例如：
s1 = {i**2 for i in [-1,-5,1,2,-2]}
print(s1) # 打印结果为：{1,4,25}
3273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
