Python学习笔记 列表（list）DAY4

列表（list）

在学习列表前我觉得有必要先简述一下序列：

一.序列（sequence）

• 序列是Python中最基本的一种数据结构
• 数据结构指计算机中数据存储的方式
• 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引
• 序列的分类：
  可变序列（序列中的元素可以改变）：
  > 列表（list）
  不可变序列（序列中的元素不能改变）：
  > 字符串（str）
  > 元组（tuple）

列表前述：

• 列表是Python中的一个对象
• 对象（object）就是内存中专门用来存储数据的一块区域
• 之前我们学习的对象，像数值，它只能保存一个单一的数据
• 列表中可以保存多个有序的数据
• 列表是用来存储对象的对象
• 列表的使用：
  1.列表的创建
  2.操作列表中的数据

二. 列表的定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, ..., 元素n]。

• 关键点是「中括号 []」和「逗号 ,」

• 中括号 把所有元素绑在一起

• 逗号 将每个元素一一分开

三.创建列表

创建列表的方法：

• 直接创建一个普通列表

• 利用range()创建列表

• 利用推导式来创建列表

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

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

# 当向列表中添加多个元素时，多个元素之间使用,隔开
my_list = [10,20,30,40,50] # 创建了一个保护有5个元素的列表

# 列表中可以保存任意的对象
my_list = [10,'hello',True,None,[1,2,3],print]

# 列表中的对象都会按照插入的顺序存储到列表中，
#   第一个插入的对象保存到第一个位置，第二个保存到第二个位置

注： 由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。

x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。

1.range()

• range()是一个函数，可以用来生成一个自然数的序列（之前学习过，这里回顾一下）

# range()是一个函数，可以用来生成一个自然数的序列
r = range(5) # 生成一个这样的序列[0,1,2,3,4]
r = range(0,10,2)
r = range(10,0,-1)
# 该函数需要三个参数
#   1.起始位置（可以省略，默认是0）
#   2.结束位置
#   3.步长（可以省略，默认是1）

# print(list(r))

# 通过range()可以创建一个执行指定次数的for循环
# for()循环除了创建方式以外，其余的都和while一样，
#   包括else、包括break continue都可以在for循环中使用
#   并且for循环使用也更加简单
# 将之前使用while循环做的练习，再使用for循环完成一次！
for i in range(30):
    print(i)

# for s in 'hello':
#     print(s)

四.向列表中添加元素

• list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
• list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
• list.insert(index, obj) 在编号 index 位置插入 obj。

# 向列表中添加元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# print('原列表：',stus)

# append()
# 向列表的最后添加一个元素
stus.append('唐僧')
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧']

# insert()
# 向列表的指定位置插入一个元素
# 参数：
#   1.要插入的位置
#   2.要插入的元素
stus.insert(2,'唐僧')
# ['孙悟空', '猪八戒', '唐僧', '沙和尚', '唐僧']

# extend()
# 使用新的序列来扩展当前序列
# 需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精'])
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
stus += ['唐僧','白骨精']
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
print(stus)

注： 注意append()和extend()的区别；在append()中，此元素如果是一个 list，那么这个 list 将作为一个整体进行追加；严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。

# append()和extand()的区别
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.extend(['唐僧','白骨精'])
# 将新列表的元素合并到原列表中
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']

stus.append(['唐僧','白骨精'])
# 将新列表作为一个整体追加到原列表中
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', ['唐僧', '白骨精']]
print(stus)

五.删除列表中的元素

• list.remove(obj) 移除列表中某个值的第一个匹配项
• list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
• del var1[, var2 ……] 删除单个或多个对象。
• list.clear() 清空列表

##删除列表中的元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# clear()
# 清空序列
stus.clear()
# []

# del stus[val1:val2]
del stus[0:2]
# ['沙和尚', '唐僧']

# pop()
# 根据索引删除并返回被删除的元素
result = stus.pop(2) # 删除索引为2的元素
result = stus.pop() # 删除最后一个
print('result =',result)
# result = 唐僧

# remove()
# 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
stus.remove('猪八戒')
# ['孙悟空', '沙和尚', '唐僧']
print(stus)

注： 如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

六. 获取列表中的元素

• 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
• 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

1.切片

切片指从现有列表中，获取一个子列表；

# 切片
# 创建一个列表，一般创建列表时，变量的名字会使用复数
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# 列表的索引可以是负数
# 如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
print(stus[-2]) # 蜘蛛精

# 通过切片来获取指定的元素
# 语法：列表[起始:结束]
#   通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
#   做切片操作时，总会返回一个新的列表，不会影响原来的列表
#   起始和结束位置的索引都可以省略不写
#   如果省略结束位置，则会一直截取到最后
#   如果省略起始位置，则会从第一个元素开始截取
#   如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
print(stus[1:]) # ['猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
print(stus[:3]) # ['孙悟空', '猪八戒', '沙和尚']
print(stus[:]) # ['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
print(stus) #['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']

# 语法：列表[起始:结束:步长]
# 步长表示，每次获取元素的间隔，默认值是1
print(stus[0:5:3]) # ['孙悟空', '唐僧']
# 步长不能是0，但是可以是负数
print(stus[::0]) # ValueError: slice step cannot be zero
# 如果是负数，则会从列表的后部向前边取元素
print(stus[::-1]) # ['白骨精', '蜘蛛精', '唐僧', '沙和尚', '猪八戒', '孙悟空']

• 情况 1 - “start :”

  以 step 为 1 (默认) 从编号 start 往列表尾部切片。

• 情况 2 - “: stop”

  以 step 为 1 (默认) 从列表头部往编号 stop 切片。

• 情况 3 - “start : stop”

  以 step 为 1 (默认) 从编号 start 往编号 stop 切片。

• 情况 4 - “start : stop : step”

  以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。

• 情况 5 - " : "

  复制列表中的所有元素（浅拷贝）。

也可通过切片来修改和删除元素：

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

# 通过切片来修改列表
# 在给切片进行赋值时，只能使用序列
stus[0:2] = ['牛魔王','红孩儿']  # 使用新的元素替换旧元素
stus[0:2] = ['牛魔王','红孩儿','二郎神']
stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素
# 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致
stus[::2] = ['牛魔王','红孩儿','二郎神']

# 通过切片来删除元素
del stus[0:2]
del stus[::2]
stus[1:3] = []

print('修改后：',stus)

# 以上操作，只适用于可变序列

2.浅拷贝和深拷贝

将一个列表的数据复制到另一个列表中。使用列表[:]，可以调用copy模块。

import copy

A = [21,22,23,24,['a','b','c','d'],25,26]
B = A                                       #直接赋值
C = A[:]                                    #浅拷贝
D = copy.copy(A)                            #浅拷贝
E = copy.deepcopy(A)                        #深拷贝

# 看看深拷贝与浅拷贝的区别
# 在A数组的最尾处加一个数
A.append(99)
#在A数组里面的数组最尾处加一个数
A[4].append(66)

print("起始列表A------------>",A)
print("直接把A列表赋值给B---->",B)
print("直接浅拷贝A列表给C---->",C)
print("直接浅拷贝A列表给D---->",D)
print("直接深拷贝A列表给E---->",E)

'''
输出结果：
起始列表A------------> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26, 99]
直接把A列表赋值给B----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26, 99]
直接浅拷贝A列表给C----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26]
直接浅拷贝A列表给D----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26]
直接深拷贝A列表给E----> [21, 22, 23, 24, ['a', 'b', 'c', 'd'], 25, 26]
'''

浅拷贝和深拷贝的区别：

1、直接赋值,其实就是默认浅拷贝传递对象的引用而已,原始列表改变，被赋值的B也会做相同的改变；

2、浅拷贝，没有拷贝子对象，所以原始数据改变，子对象也会改变；

3、深拷贝，包含对象里面的子对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变。

七. 列表的常用操作符

• 等号操作符：==
• 连接操作符 +
• 重复操作符 *
• 成员关系操作符 in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

# + 和 *
# +可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6]  # [1, 2, 3, 4, 5, 6]

# * 可以将列表重复指定的次数
my_list = [1,2,3] * 5  # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
print(my_list)

# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

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

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

# min() 获取列表中的最小值
# max() 获取列表中的最大值
arr = [10,1,2,5,100,77]
print(min(arr) , max(arr)) # 1 100

八.列表的其它方法

• list.count(obj) 统计某个元素在列表中出现的次数
• list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置
• list.reverse() 反向列表中元素
• list.sort(key=None, reverse=False) 对原列表进行排序。
  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
  • 该方法没有返回值，但是会对列表的对象进行排序。

# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

# 两个方法（method），方法和函数基本上是一样，只不过方法必须通过 对象.方法() 的形式调用
# xxx.print() 方法实际上就是和对象关系紧密的函数
# s.index() 获取指定元素在列表中的第一次出现时索引
print(stus.index('沙和尚')) # 2

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

# 如果要获取列表中没有的元素，会抛出异常
print(stus.index('牛魔王'))  # ValueError: '牛魔王' is not in list

# s.count() 统计指定元素在列表中出现的次数
print(stus.count('牛魔王')) # 0

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# print('原列表：',stus)

# reverse()
# 用来反转列表
# stus.reverse()

# sort()
# 用来对列表中的元素进行排序，默认是升序排列
# 如果需要降序排列，则需要传递一个reverse=True作为参数
my_list = list('asnbdnbasdabd')
my_list = [10,1,20,3,4,5,0,-2]

print('修改前',my_list)

my_list.sort(reverse=True)
print('修改后',my_list)
print('修改后：',stus)

'''
原列表： ['孙悟空', '猪八戒', '沙和尚', '唐僧']
修改前 [10, 1, 20, 3, 4, 5, 0, -2]
修改后 [20, 10, 5, 4, 3, 1, 0, -2]
修改后： ['唐僧', '沙和尚', '猪八戒', '孙悟空']
'''

x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]

x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]

x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]

九.练习题

1、列表操作练习

列表lst 内容如下

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]

请写程序完成下列操作：

1. 在列表的末尾增加元素15
2. 在列表的中间位置插入元素20
3. 将列表[2, 5, 6]合并到lst中
4. 移除列表中索引为3的元素
5. 翻转列表里的所有元素
6. 对列表里的元素进行排序，从小到大一次，从大到小一次

答：

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
# 在列表的末尾增加元素15
lst.append(15)
print(lst) # 
# 在列表的中间位置插入元素20
lst.insert(len(lst) // 2,20)
print(lst) # 
# 将列表[2, 5, 6]合并到lst中
newLst = [2, 5, 6]
lst.extend(newLst)
print(lst) # 
# 移除列表中索引为3的元素
lst.pop(3)
print(lst) # 
# 翻转列表里的所有元素
lst.reverse()
print(lst) # 
# 对列表里的元素进行排序，从小到大一次，从大到小一次
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)
'''
输出结果：
[2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
[2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
[20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]
'''

2、修改列表

问题描述：

lst = [1, [4, 6], True]

请将列表里所有数字修改成原来的两倍

答：

def DoubleNum(lst):
    for index, value in enumerate(lst):
        if isinstance(value, bool):
            pass
        elif isinstance(value, (int, float)):
            lst[index] *= 2
        elif isinstance(value, list):
            DoubleNum(value)
        else:
            pass


lst = [1, [4, 6], True]
DoubleNum(lst)
print(lst)
'''
结果为：
[2, [8, 12], True]
'''

3、leetcode 852题 山脉数组的峰顶索引

如果一个数组k符合下面两个属性，则称之为山脉数组

数组的长度大于等于3

存在$i$i，$i$i >0 且$i<\operatorname{len}(k)-1$i<len(k)−1， 使得$\mathrm{k}[0]<\mathrm{k}[1]<\ldots<\mathrm{k}[\mathrm{i}-1]<\mathrm{k}[\mathrm{j}]>\mathrm{k}[\mathrm{i}+1] \ldots>\mathrm{k}[\operatorname{len}(\mathrm{k})-1]$k[0]<k[1]<…<k[i−1]<k[j]>k[i+1]…>k[len(k)−1]

这个$i$i就是顶峰索引。

现在，给定一个山脉数组，求顶峰索引。

示例:

输入：[1, 3, 4, 5, 3]

输出：True

输入：[1, 2, 4, 6, 4, 5]

输出：False

答：

# 山脉数组
def MountainList(lst):
    left = 0
    right = len(lst) - 1
    while left <= right:  # 二分法找顶峰索引
        mid = (left + right) // 2
        if lst[mid] > lst[mid + 1] and lst[mid] > lst[mid - 1]:  # 找到顶峰索引
            midToMin = mid
            midToMax = mid
            while midToMin > 0:
                if lst[midToMin] > lst[midToMin - 1]:
                    midToMin -= 1
                else:
                    return False
            while midToMax < len(lst) - 1:
                if lst[midToMax] > lst[midToMax + 1]:
                    midToMax += 1
                else:
                    return False
            return True  # 遍历结束，是山脉数组
        elif lst[mid] < lst[mid - 1]:
            right = mid - 1
        elif lst[mid] < lst[mid + 1]:
            left = mid + 1


lst1 = [1, 3, 4, 5, 3]
result = MountainList(lst1)
print(result)
lst2 = [1, 2, 4, 6, 4, 5]
result = MountainList(lst2)
print(result)
'''
输出结果：
True
False
'''