概念
变量就是内存空间，用来表示/存储数据
如果表示的数据少，直接定义几个变量就行了
代码语言：python代码运行次数：0复制num1
num2
num3但有时候要表示的数据比较多
Python 中，列表和元组就是一种可以用一个变量来表示很多数据的机制（类似其他语言中的数组）
列表和元组，大部分功能都是差不多的，但是有一个功能有非常明显的区别：
- 列表是可变的，创建好了之后，随时可以改
- 元组是不可变的，创建好了之后改不了，若想改，只能丢弃旧的，再创建一个新的
列表就是买散装辣条，装好了袋子之后，随时可以把袋子打开，再往里多加辣条或者拿出去一些辣条
元组就是买包装辣条，厂家生产好了辣条之后，一包就是固定的这么多，不能变动了
创建列表
- 直接使用字面值来创建a = [1, 2, 3, 4] print(type(a)) print(a) """ 运行结果 <class 'list'> [1, 2, 3, 4] """
[]就代表一个空的列表- 可以在
[]中指定列表的初始值， - 使用
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开始计数的
通过下标来修改列表元素
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
a[2] = 100
print(a)
"""
运行结果
[1, 2, 100, 4]
"""- 这是列表的功能，如果是元组的话，就只能读，不能改
由于下标是从 0 开始计算的，那么对于列表来说，下标的有效范围是 0~长度-1。当我们的下标超出有效范围的时候，尝试访问就会报错 `
获取列表长度
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
print(len(a))
"""
运行结果
4
"""- len 可以穿字符串、列表、元组、字典、自定义得嘞...（动态类型）
下标可以写成负数
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
print(a[lem(a)-1])
print(a[-1])
"""
运行结果
3
3
"""-1就等价与len(a) - 1
切片操作
切片操作是一个比较高效的操作，进行切片的时候，只是取出原有列表中的一个部分，并不涉及到“数据的拷贝”。假设有一个很大的列表进行切片，切片的范围也很大，即使如此，切片操作仍然非常高效
切片操作中，[] 中有两个数字，表示了一段区间
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
print(a[1:3])
"""
运行结果
[2, 3]
"""1表示开始区间的下标；3表示结束区间的下标- 包含
1，不包含3，[1, 3)
省略后边界
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
print(a[1:])
"""
运行结果
[2, 3, 4]
"""- 从
a[1]开始，一直读取到整个列表结束
省略前边界
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
print(a[:2])
"""
运行结果
[1, 2]
"""- 从列表的
a[0]开始读，一直读到结束的后边界
省略前后边界
代码语言：python代码运行次数：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 循环
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4, 5]
for elem in a:
print(elem)- 在这个遍历过程中，循环里面的逻辑不一定是打印，还可以是别的
elem代表列表里的每个元素for in后面的这个东西，要求是一个可迭代对象 - 列表就是一个可迭代对象
使用 for 循环访问下标的方式
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4, 5]
for i range(0, len(a)):
print(a[i])- 相比于上面的方式，这里不仅可以打印，还可以进行修改
使用 while 循环
代码语言：python代码运行次数：0复制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 方法，让列表的任意位置来新增元素
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4, 5]
a.insert(1, 'hello')
print(a)
"""
运行结果
[1, 'hello', 2, 3, 4, 5]
"""- 在
a[1]的位置新增 'hello' 字符串 - 如果输入的
index超过列表的长度，那就直接放在末尾
查找元素
判定元素是否存在
代码语言：python代码运行次数：0复制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来判断某个元素在列表中是否不存在
判定元素的位置
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
print(a.index(2))
"""
运行结果
1
"""- 使用
index方法，来判定当前元素在列表中的位置，得到一个下标 - 找不到的时候就会直接报出异常
删除元素
删除列表末尾元素
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
a.pop()
print(a)
"""
运行结果
[1, 2, 3]
"""- 使用
pop方法，删除列表中最末尾的元素
删除任意位置元素
代码语言：python代码运行次数：0复制a = [1, 2, 3, 4]
a.pop(1)
print(a)
"""
运行结果
[1, 3, 4]
"""- 使用
pop方法删除任意位置元素，pop参数可以传一个下标过去
按照值进行删除
不需要知道下标是什么，只需要知道要删除的值是什么就可以了
代码语言：python代码运行次数：0复制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 进行拼接
代码语言：python代码运行次数：0复制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方法，就拼在谁的后面
使用“ =”拼接
代码语言：python代码运行次数：0复制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的后面，更高效，省去了数据拷贝和释放的过程
关于元组
创建元组
代码语言：python代码运行次数：0复制a = ()
b = tuple()
print(type(a))
print(type(b))
"""
运行结果
<class 'tuple'>
<class 'tuple'>
"""创建元组时指定初始值
代码语言：python代码运行次数：0复制a = (1, 2, 3, 4)
print(a)
"""
运行结果
(1, 2, 3, 4)
"""元组中的元素可以使任意类型
代码语言：python代码运行次数：0复制a = (1, 2, 'hello', True, [])
print(a)
"""
运行结果
(1, 2, 'hello', True, [])
"""通过下标进行访问
代码语言：python代码运行次数：0复制a = (1, 2, 3, 4, 5)
print(a[1])
print(a[-1])
"""
运行结果
2
5
"""- 下标也是从
0开始，len-1结束 - 当访问的下标超过
len - 1，会报错
切片
通过切片来获取元组中的一个部分
代码语言：python代码运行次数：0复制a = (1, 2, 3, 4)
print(a[1:3])- 这里的操作和列表是一摸一样的
遍历元组
代码语言：python代码运行次数：0复制a = (1, 2, 3, 4)
for elem in a:
print(elem)- 和前面列表操作一样
查找元素
代码语言：python代码运行次数：0复制a = (1, 2, 3, 4, 5)
print(3 in a)
print(22 in a)- 和列表的操作一样
拼接元组
代码语言：python代码运行次数：0复制a = (1, 2, 3)
b = (4, 5, 6)
print(a b)- 和列表的操作一样
为什么要有元组
在协同开发的时候，一个程序员 A 实现一些功能，提供给程序员 B 使用。A 写好一些函数，让 B 去调用
期间函数肯定要传参
B 在传参的时候就可能会纠结一个问题“我把我的参数传过去了，A 的函数里面是否会把我的参数的内容给改了呢”，如果使用元组作为参数，就可以避免这样的纠结
元组不可修改==>不可变对象
不可变对象，是可以哈希的
