序列

可变序列（序列中的元素可以改变）：

列表（list）

不可变序列（序列中的元素不能改变）：

字符串（str）
元组（tuple）

列表（list）

列表是Python中的一个对象
对象（object）就是内存中专门用来存储数据的一块区域
列表中可以保存多个有序的数据

#创建列表，通过[]来创建列表
my_list = [] # 创建了一个空列表
print(my_list,type(my_list))

#列表存储的数据，我们称为元素
# 一个列表可以存储多个元素，也可以在创建列表时，来指定列表中的元素
my_list = [10]
print(my_list)

# 当向列表中添加多个元素时，多个元素之间使用 ， 隔开
my_list = [10,20,30,40,50]
print(my_list)

# 可以使用索引（index)来获取列表中的元素,索引从0开始
# 语法： 列表名[索引] 
print(my_list[0])

# len()函数可以获取列表的长度
print(len(my_list))

切片

切片：指从现有列表中，获取一个子列表
一般创建链表时，变量的名字会使用复数

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

• 链表的索引可以是负数、

# 如果索引是负数，则从后往前获取元素，-1表示倒数第一个，-2表示倒数第二个
print(stus[-2])

• 通过切片来获取指定的元素

# 语法： 列表[起始:结束]
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
# 通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
# 做切片操作时，总会返回一个新的列表，不会影响原来的列表
# 起始和结束位置的索引都可以省略不写

print(stus[1:]) # 省略结束位置，则会一直截取到最后
print(stus[:3]) # 省略起始位置，则会从第一个元素开始截取
print(stus[:]) # 起始位置和结束位置全部省略，则相当于创建了一个列表的副本

• 步长：每次获取元素的间隔，默认值是1
  步长不能是0，但是可以是负数

# 语法：  列表[起始:结束:步长]
print(stus[0:5:3])
# 步长不能是0，但是可以是负数
# 如果是负数，则会从后往前取列表元素
print(stus[::-1])

通用操作

• + 和 *
• + 可以将两个列表拼接为一个列表

my_list = [1,2,3] + [4,5,6]
print(my_list)

• * 可以将列表重复指定的次数

my_list = [1,2,3] * 5
print(my_list)

• in 和 not in

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

print('牛魔王' in stus)
# in 用来检查指定元素是否存在于列表中
# 如果存在，返回True，否则返回False

print('牛魔王' not in stus)
# not in 用来检查指定元素是否不在列表中
# 如果不在，返回True，否则返回False

• len() ：获取列表中的元素的个数

# min() 获取列表中的最小值
# max() 获取列表中的最大值
arr = [12,34,565,32,1]
print(min(arr),max(arr))

• index() ：获取指定元素在列表中第一次出现时索引

# index()
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
print(stus.index('沙和尚'))

print(stus.index('沙和尚')) 
# 第二个参数表示查找的起始位置，第三个元素表示查找的结束位置

• count() ：统计指定元素在列表中出现的次数

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']
print(stus.count('沙和尚'))

修改元素

下面方式只适用于可变序列

• 直接通过索引修改

# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
print('修改前：',stus)
stus[0] = 'sunwukong'
stus[1] = 'zhubajie'
#通过del来删除元素
del stus[2] # 删除索引为2的元素
print('修改后：',stus)

• 通过切片来修改列表

# 给切片赋值，只能使用序列
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
print(stus)
# 使用新元素替换旧元素
stus[0:2] = ['牛魔王','红孩儿']
stus[0:2] = ['金角大王','银角大王','没角大王']
print('修改后：',stus)
# 向索引为0的位置插入元素
stus[0:0] = ['牛魔王']

# 设置步长，序列中元素的个数要和切片中元素个数一致
stus[::2] = ['niumowang','honghaier','erlangshen','baigujing']
print(stus)

# 通过切片来删除元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
del stus[0:2]
print('修改后：',stus)

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
del stus[::2]
print('修改后：',stus)

# 替换空序列来删除元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
stus[1:3] = []
print('修改后：',stus)

列表的方法

• append( ) ：向列表的最后添加一个元素

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.append('牛魔王')
print(stus)

• insert( i , x) ：向列表的指定位置插入一个元素。i ：插入的位置，x：插入的元素

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.insert(2,'牛魔王')
print(stus)

• extend() ：使用新的序列来扩展当前序列

# 需要一个序列作为参数，它会将参数序列的元素添加到当前序列中
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.extend(['金角大王','银角大王'])
print(stus)

t = ['牛魔王','红孩儿']
stus.extend(t)
print(stus)

• clear() ：清空序列

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.clear()
print(stus)

• pop() ：根据索引删除并返回被删除的元素

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
result = stus.pop(2) # 删除索引为2的元素
print(result)
print(stus)

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
result = stus.pop() # 删除最后一个元素
print(result)
print(stus)

• remove() ：删除指定值的元素，如果相同值的元素有多个，只删除第一个

stus = ['孙悟空','猪八戒','沙和尚','唐僧','猪八戒']
stus.remove('猪八戒')
print(stus)

• reverse() ：反转列表

stus = ['孙悟空','猪八戒','沙和尚','唐僧','猪八戒']
stus.reverse()
print(stus)

• sort() ：用来对列表中的元素进行排序，默认是升序排列；如果需要降序排列，则需要传递一个 reverse=True 作为参数

my_list = list('asnbdnbasdabd')
print(my_list)
my_list.sort()
print(my_list)

my_list1 = [10,1,20,3,4,5,0,-2]
print(my_list1)
my_list1.sort(reverse=True)
print(my_list1)

range() 函数

range() 可以用来生成一个自然数的序列
该函数需要三个参数：
1.起始位置（可以省略，默认为0）
2.结束位置
3.步长（可以省略，默认是1）

s = range(5) 
print(s)
print(list(s))

t = range(1,10,2)
print(list(t))

r = range(10,0,-1) # 
print(list(r))

range() 函数配合for循环

for i in range(30):
    print(i)

元组（tuple）

元组是一个不可变的序列
元组的操作与列表基本一致，一般希望数据不改变时，就使用元组

• 使用（）来创建元组

my_tuple = () # 创建了一个空元组
print(my_tuple,type(my_tuple))

my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组
# my_tuple[1] = 2 报错，元组是不可变对象，不能尝试为元组中的元素重新赋值

my_tuple = 10,20,30,40 # 当元组不是空元组时，括号可以省略
my_tuple = 40, # 元组里只有一个元素的时候，逗号 ， 不可省略

• 元组的解包（解构）：将元组当中每一个元素都赋值给一个变量

my_tuple = 10,20,30,40
a,b,c,d = my_tuple
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d) 

交换a 和 b的值，这时我们可以利用元组的解包

a = 100
b = 200
print(a,b)
a , b = b , a
print(a,b)

对一个元组进行解包，变量的数量必须和元组中的元素的数量一致；也可以在变量前加 * ，这样变量将会获取元组中所有剩余的元素（不可以同时出现两个或两个以上的 * 变量）

my_tuple = 10,20,30,40
a , b , *c = my_tuple
a , *b , c = my_tuple
*a , b , c = my_tuple
a , b , *c = [1,2,3,4,5,6,7]
a , b , *c = 'hello world'