Python 列表学习

Python list

列表的定义

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

• 关键点是「中括号 []」和「逗号 ,」
• 中括号 把所有元素绑在一起
• 逗号 将每个元素一一分开

列表的创建

Fruits = ['apples', 'bananas', 'pears', 'peaches',]
numbers = ['1', '2', '3', '4', '5',]
numbers = [1, 2, 3, 4, 5,]

利用range()创建列表

numbers = list(range(10))  # numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers = list(range(1, 11, 2)) # numbers = [1, 3, 5, 7, 9]
numbers = list(range(10, 1, -2)) # numbers = [10, 8, 6, 4, 2] 

利用推导式创建列表

x = [0] * 5   #  x = [0, 0, 0, 0, 0]
x = [0 for i in range(5)]  # x = [0, 0, 0, 0, 0]
x = [i for i in range(10)]  #  x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
x = [[col+row for col in range(3)] for row in range(4)]
print(x, type(x))
'''
[0, 1, 2] <class 'list'>
[1, 2, 3] <class 'list'>
[2, 3, 4] <class 'list'>
[3, 4, 5] <class 'list'>
'''

注意：

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

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

a = [1]  # a 为可变对象
x = [a]*3
print(x, type(x))  #  [[1], [1], [1]] <class 'list'>
a.append(2)
print(x, type(x))  #  [[1, 2], [1, 2], [1, 2]] <class 'list'>

a = 'hell'  # a 为不可变对象
x = [a]*3
print(x, type(x))  #  ['hell', 'hell', 'hell'] <class 'list'>
a += 'o'
print(x, type(x))  #  ['hell', 'hell', 'hell'] <class 'list'>

python可变/不可变对象

创建一个混合列表

mix = [1, 'lsgo', 3.14, [1, 2, 3]]  # [1, 'lsgo', 3.14, [1, 2, 3]]

列表操作

• list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。

• list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

• list.insert(index, obj) 在编号 index 位置前插入 obj。

• list.remove(obj) 移除列表中某个值的第一个匹配项

• list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

• remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。

• del var1[, var2 ……] 删除单个或多个对象。

获取列表中的元素

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

切片

切片的通用写法是 start : stop : step

• 情况 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，相当于将列表反向排列。

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

• 直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变，被赋值的b也会做相同的改变 (a = b)
• copy浅拷贝，没有拷贝子对象，所以原始数据改变，子对象会改变 b = a.copy()
• 深拷贝，包含对象里面的自对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变

# 浅拷贝 b = a.copy()  b=a   b = a[:]
a = [1, [1, 2, 3], 'A']
b = a.copy()
print(a, b)			# [1, [1, 2, 3], 'A'] [1, [1, 2, 3], 'A']
a[1].append(0)
print(a, b)			# [1, [1, 2, 3, 0], 'A'] [1, [1, 2, 3, 0], 'A']
b.append('B')
print(a, b) 		# [1, [1, 2, 3, 0], 'A'] [1, [1, 2, 3, 0], 'A', 'B']
a.append('C')
print(a, b)			# [1, [1, 2, 3, 0], 'A', 'C'] [1, [1, 2, 3, 0], 'A', 'B']

列表的常用操作符

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

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

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

将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

列表的其它方法

list.count(obj) 统计某个元素在列表中出现的次数

list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置

list.reverse() 反向列表中元素

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

list.sort(key=None, reverse=False) 对原列表进行排序。

练习题：

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]
lst.append(15)
lst.insert(len(lst)//2, 20)
# lst.append([2, 5, 6])    # [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, [2, 5, 6]]
lst.extend([2, 5, 6])      # [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
lst.pop(3)
lst.reverse()
lst.sort(reverse=False)
lst.reverse()

2、修改列表

问题描述：

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

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

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

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

数组的长度大于等于3

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

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

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

示例:

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

输出：True

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

输出：False

class Solution:
    def peakIndexInMountainArray(self, A: List[int]) -> int:
        return A.index(sorted(A,reverse=True)[0])

index:从零开始

1. 切片：
   语法[start:stop:step]
   step代表切片步长；切片区间为[start,stop),左闭右开
   1.step > 0 从左往右切
   2.step < 0 从右往左切
   3.start,stop默认值为列表的头和尾,step默认值为1
   4.start,stop小于零 表示倒数的第几个元素
2. li.count(1) # 查找元素1出现多少次
   li.index(1) # 查找元素1索引
   li.append(2) # 列表末尾添加元素2
   li.insert(0, ‘a’) # 列表指定位置插入元素
   删除元素：del,pop,remove
   清空元素：clear
   列表翻转：reverse
   列表排序：sort(key=None, reverse=False) 默认升序，sort(reverse = True) 降序
   key指定排序规则 li.sort(key = lambda item:len(str(item))) # 转换成字符串的长度进行升序排序
   列表合并：a.extend(b),将b列表添加到a列表中 / c = a + b
   用in来判断一个值在不在list里面

li = [1, 2, 3, 4, 5, 6, 7]
print(li[-2:-1:])  # [6]
print(li[-2::])  # [6, 7]
print(li[-2::-1])  # [6, 5, 4, 3, 2, 1]
print(li[-2:2:-1])  # [6, 5, 4]
print(li[::-1])  # [7, 6, 5, 4, 3, 2, 1]
print(li[-1::-1])  # [7, 6, 5, 4, 3, 2, 1]

2. li.count(1) # 查找元素1出现多少次
   li.index(1) # 查找元素1索引
   li.append(2) # 列表末尾添加元素2
   li.insert(0, ‘a’) # 列表指定位置插入元素
   删除元素：del,pop,remove
   清空元素：clear
   列表翻转：reverse
   列表排序：sort(key=None, reverse=False) 默认升序，sort(reverse = True) 降序
   key指定排序规则

   li.sort(key = lambda item:len(str(item)))  # 转换成字符串的长度进行升序排序 
   

   列表合并：a.extend(b),将b列表添加到a列表中 / c = a + b
   用in来判断一个值在不在list里面