【Python】列表与元组操作详解

文章目录

概念

创建列表

访问下标

通过下标来修改列表元素

获取列表长度

下标可以写成负数

切片操作

省略后边界

省略前边界

省略前后边界

带有步长的切片

遍历列表元素

使用 for 循环

使用 for 循环访问下标的方式

使用 while 循环

新增元素

在末尾新增

在任意位置新增

查找元素

判定元素是否存在

判定元素的位置

删除元素

删除列表末尾元素

删除任意位置元素

按照值进行删除

列表拼接

使用“`+`”拼接

使用 `extend` 进行拼接

使用“`+=`”拼接

关于元组

创建元组

创建元组时指定初始值

元组中的元素可以使任意类型

通过下标进行访问

切片

遍历元组

查找元素

拼接元组

为什么要有元组

概念

变量就是内存空间，用来表示/存储数据
如果表示的数据少，直接定义几个变量就行了

num1
num2
num3

但有时候要表示的数据比较多

Python 中，列表和元组就是一种可以用一个变量来表示很多数据的机制（类似其他语言中的数组）

列表和元组，大部分功能都是差不多的，但是有一个功能有非常明显的区别：

列表是可变的，创建好了之后，随时可以改

元组是不可变的，创建好了之后改不了，若想改，只能丢弃旧的，再创建一个新的

列表就是买散装辣条，装好了袋子之后，随时可以把袋子打开，再往里多加辣条或者拿出去一些辣条
元组就是买包装辣条，厂家生产好了辣条之后，一包就是固定的这么多，不能变动了

创建列表

1. 直接使用字面值来创建

a = [1, 2, 3, 4]
print(type(a))
print(a)

"""
运行结果
<class 'list'>
[1, 2, 3, 4]
"""

[]就代表一个空的列表

可以在 [] 中指定列表的初始值，

2. 使用 list() 来创建

b = list()
print(type(b))

"""
运行结果
<class 'list'>
"""

C++/Java 中要求一个数组里只能存放相同的变量，但在 Python 中没有类型要求

a = [1, 'hello', True, [1, 2, 3]]  
print(a)

"""
运行结果
[1, 'hello', True, [1, 2, 3]]
"""

访问下标

通过下标访问的方式，来获取列表中的元素
把 [] 放到一个列表变量的后面，同时 [] 中写上一个整数，此时他就是下标访问运算符。[] 中间写的这个证书，就称为“下标”或者“索引”

a = [1, 2, 3, 4]
print(a[2])

"""
运行结果
3
"""

Python 中的下标，是从 0 开始计数的

---

通过下标来修改列表元素

a = [1, 2, 3, 4]
a[2] = 100
print(a)

"""
运行结果
[1, 2, 100, 4]
"""

这是列表的功能，如果是元组的话，就只能读，不能改

由于下标是从 0 开始计算的，那么对于列表来说，下标的有效范围是 0~长度-1。当我们的下标超出有效范围的时候，尝试访问就会报错 `

---

获取列表长度

a = [1, 2, 3, 4]
print(len(a))

"""
运行结果
4
"""

len 可以穿字符串、列表、元组、字典、自定义得嘞…（动态类型）

---

下标可以写成负数

a = [1, 2, 3, 4]
print(a[lem(a)-1])
print(a[-1])

"""
运行结果
3
3
"""

-1 就等价与 len(a) - 1

切片操作

切片操作是一个比较高效的操作，进行切片的时候，只是取出原有列表中的一个部分，并不涉及到“数据的拷贝”。假设有一个很大的列表进行切片，切片的范围也很大，即使如此，切片操作仍然非常高效

切片操作中，[] 中有两个数字，表示了一段区间

a = [1, 2, 3, 4]
print(a[1:3])

"""
运行结果
[2, 3]
"""

1 表示开始区间的下标；3 表示结束区间的下标

包含 1，不包含 3，[1, 3)

省略后边界

a = [1, 2, 3, 4]
print(a[1:])

"""
运行结果
[2, 3, 4]
"""

从 a[1] 开始，一直读取到整个列表结束

省略前边界

a = [1, 2, 3, 4]
print(a[:2])

"""
运行结果
[1, 2]
"""

从列表的 a[0] 开始读，一直读到结束的后边界

省略前后边界

a = [1, 2, 3, 4]
print(a[:])

"""
运行结果
[1, 2, 3, 4]
"""

省略前后边界就是打印整个列表

带有步长的切片

切片操作，还可以指定“步长”，range

a = [1, 2, 3, 4 ,5 , 6, 7 ,8]
print(a[::1])
print(a[::2])

"""
运行结果
[1, 2, 3, 4 ,5 , 6, 7 ,8]
[1, 3, 5, 7]
"""

多加一个 :，再多加一个数字，这个数字就是步长

这里表示：每隔两个元素，取一个列表元素

步长也可以设置为负数，当步长为负数时，意思是从后往前来取元素

遍历列表元素

“遍历” 指的是把元素一个一个的取出来，再分别进行处理

使用 for 循环

a = [1, 2, 3, 4, 5]  
for elem in a:  
    print(elem)

在这个遍历过程中，循环里面的逻辑不一定是打印，还可以是别的

elem 代表列表里的每个元素

for in 后面的这个东西，要求是一个可迭代对象

列表就是一个可迭代对象

使用 for 循环访问下标的方式

a = [1, 2, 3, 4, 5]
for i range(0, len(a)):
	print(a[i])

相比于上面的方式，这里不仅可以打印，还可以进行修改

使用 while 循环

a = [1, 2, 3, 4, 5]
i = 0
while i < len(a):
	print(a[i])
	i += 1

新增元素

在末尾新增

使用 append 往列表末尾新增一个元素

a = [1, 2, 3, 4, 5]  
a.append(77)  
a.append('hello')  
print(a)

"""
运行结果
[1, 2, 3, 4, 5, 77, 'hello']
"""

此处的 append 是搭配列表对象 a 一起使用的，而不是作为一个独立的函数

type、print、input、len… 都是独立的函数

这种要搭配对象来使用的函数（function）也叫做方法（method）

在 Python 中，对象就可以视为“变量”

在任意位置新增

可以使用 insert 方法，让列表的任意位置来新增元素

a = [1, 2, 3, 4, 5]
a.insert(1, 'hello')
print(a)

"""
运行结果
[1, 'hello', 2, 3, 4, 5]
"""

在 a[1] 的位置新增 ’ hello ’ 字符串

如果输入的 index 超过列表的长度，那就直接放在末尾

查找元素

判定元素是否存在

a = [1, 2, 3, 4]
print(1 in a)
print(10 in a)
print(1 not in a)
print(10 not in a)

"""
运行结果
True
False
False
True
"""

使用 in 来判定某个元素是否在列表中存在

使用 not in 来判断某个元素在列表中是否不存在

判定元素的位置

a = [1, 2, 3, 4]
print(a.index(2))

"""
运行结果
1
"""

使用 index 方法，来判定当前元素在列表中的位置，得到一个下标

找不到的时候就会直接报出异常

删除元素

删除列表末尾元素

a = [1, 2, 3, 4]  
a.pop()  
print(a)

"""
运行结果
[1, 2, 3]
"""

使用 pop 方法，删除列表中最末尾的元素

删除任意位置元素

a = [1, 2, 3, 4]  
a.pop(1)  
print(a)

"""
运行结果
[1, 3, 4]
"""

使用 pop 方法删除任意位置元素，pop 参数可以传一个下标过去

按照值进行删除

不需要知道下标是什么，只需要知道要删除的值是什么就可以了

a = ['aa', 'bb', 'cc', 'dd']  
a.remove('cc')  
print(a)

"""
运行结果
['aa', 'bb', 'dd']
"""

列表拼接

使用“+”拼接

使用 + 能够把两个列表拼接在一起

a = [1, 2, 3, 4]  
b = [5, 6, 7, 8]  
c = a + b  
d = b + a
print(c) 	
print(d)

"""
运行结果
[1, 2, 3, 4, 5, 6, 7, 8]
[5, 6, 7, 8, 1, 2, 3, 4]
"""

使用 + 拼接列表的时候，只是针对当前列表的内容生成了一个更大的新的列表

原有列表的内容是不变的

使用 extend 进行拼接

a = [1, 2, 3, 4]  
b = [5, 6, 7, 8]  
c = a.extend(b)  
print(a)  
print(b)  
print(c)
"""
运行结果
[1, 2, 3, 4, 5, 6, 7, 8]
[5, 6, 7, 8]
None
"""

这个拼接是把最后一个列表的内容拼接到前一个列表里面

None 是一个特殊的变量值，表示什么都没有

extend 方法，其实是没有返回值的，拿一个变量来接收一个没有返回值的方法的返回值

谁使用 extend 方法，就拼在谁的后面

使用“+=”拼接

a = [1, 2, 3, 4]  
b = [5, 6, 7, 8]  
a += b 
print(a)  
print(b)  
"""
运行结果
[1, 2, 3, 4, 5, 6, 7, 8]
[5, 6, 7, 8]
"""

和 extend 的效果是类似的

但执行过程是不一样的

a += b 等价于 a = a + b；又创建了一个大列表，然后将小的装进去，再将大列表的值赋给 a 里面，最后将 a 的旧值释放

a.extend(b) 则是直接把 b 的内容拼到了 a 的后面，更高效，省去了数据拷贝和释放的过程

关于元组

创建元组

a = ()
b = tuple()
print(type(a))
print(type(b))

"""
运行结果
<class 'tuple'>
<class 'tuple'>
"""

创建元组时指定初始值

a = (1, 2, 3, 4)
print(a)

"""
运行结果
(1, 2, 3, 4)
"""

元组中的元素可以使任意类型

a = (1, 2, 'hello', True, [])
print(a)

"""
运行结果
(1, 2, 'hello', True, [])
"""

通过下标进行访问

a = (1, 2, 3, 4, 5)
print(a[1])
print(a[-1])

"""
运行结果
2
5
"""

下标也是从 0 开始，len-1 结束

当访问的下标超过 len - 1，会报错

切片

通过切片来获取元组中的一个部分

a = (1, 2, 3, 4)
print(a[1:3])

这里的操作和列表是一摸一样的

遍历元组

a = (1, 2, 3, 4)
for elem in a:
	print(elem)

和前面列表操作一样

查找元素

a = (1, 2, 3, 4, 5)
print(3 in a)
print(22 in a)

和列表的操作一样

拼接元组

a = (1, 2, 3)
b = (4, 5, 6)
print(a + b)

和列表的操作一样

为什么要有元组

在协同开发的时候，一个程序员 A 实现一些功能，提供给程序员 B 使用。A 写好一些函数，让 B 去调用
期间函数肯定要传参
B 在传参的时候就可能会纠结一个问题“我把我的参数传过去了，A 的函数里面是否会把我的参数的内容给改了呢”，如果使用元组作为参数，就可以避免这样的纠结

元组不可修改==>不可变对象

不可变对象，是可以哈希的

作者：椰椰椰耶