列表和元组

  • 1. 列表是什么,元组是什么
  • 2. 创建列表
  • 3. 访问下标
  • 4. 切片操作
  • 5. 遍历列表元素
  • 6. 新增元素
  • 7. 查找元素
  • 8. 删除元素
  • 9. 连接元素
  • 10. 关于元组


1. 列表是什么,元组是什么

在编程中,变量就是内存空间,用来表示/存储数据。
如果表示的数据少,直接定义几个变量就可以了。如果表示的数据比较多,这个时候就需要用到列表和元组。
在 Python 中,列表和元组就可以用一个变量来表示很多个数据。

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

  • 列表是可变的:创建好之后,随时能改。
  • 元组是不可变的:创建好之后,改不了,要想改,只能丢弃旧的,搞个新的。

2. 创建列表

  • 创建列表主要有两种方式 [ ] 表示一个空表

# 1. 直接使用字面值来创建列表 a = [] print(type(a)) # 2. 使用 list() 来创建列表 b = list() print(type(b))

python中列表与元组 python中列表和元组_学习

  • 可以在创建列表的时候,在 [ ] 中指定列表的初始值,元组之间用 , 来分隔

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

python中列表与元组 python中列表和元组_python中列表与元组_02

  • 列表中存放的元素允许是不同的类型

a = [1, 'hello', True, [4, 5, 6, 7]] print(a)

python中列表与元组 python中列表和元组_学习_03

3. 访问下标

通过下标访问操作符 [ ] 来获取到列表中的任意元素。
把 [ ] 中填写的数字,称为下标 或者索引

  • 使用下标访问元素列表

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

python中列表与元组 python中列表和元组_python_04


注意:

下标是从 0 开始计算的

。因此下标为 2 对于的元素是3.

  • 通过下标不光能读取元素内容, 还能修改元素的值

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

python中列表与元组 python中列表和元组_python_05

  • 如果下标超出有效范围,会抛出异常
    由于下标是从 0 开始计算的,对于列表来说,下标的有效范围是从0到长度 -1。

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

python中列表与元组 python中列表和元组_开发语言_06

  • 可以使用内建函数 len 函数求取到列表的长度(元素个数),和字符串类似。

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

python中列表与元组 python中列表和元组_python_07

  • Python 中的下标还可以写成负数
    例如:写成 -1 其实等价于 len(a) -1
    -1 就是倒数第一个元素

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

python中列表与元组 python中列表和元组_元组_08

4. 切片操作

通过下标操作是一次取出里面的一个元素。
通过切片 则是一次取出一组连续的元素,相当于得到一个子列表。

  • 使用 [ : ] 的方式进行期望片操作

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

python中列表与元组 python中列表和元组_学习_09

  • 切片操作中,[ ] 里面有两个数字,表示了一段区间。1 表示区间开始的下标;3表示区间结束的下标。
  • a[1:3] 中的 1:3 表示的是 [1, 3) 这样的由下标构成的前闭后开区间
    也就是从下标为 1 的元素开始(2), 到下标为 3 的元素结束(4), 但是不包含下标为 3 的元素.所以最终结果只有 2, 3
  • 切片操作中可以省略前后边界

a = [1, 2, 3, 4] # 省略后边界,表示从开始位置,一直获取到整个列表结束 print(a[1:]) # 省略前边界,表示从列表中的 0 号元素开始获取,一直到结束的边界 print(a[:2]) # 此处切片中的下标也可以写成负数 print(a[:-1]) # 省略边界的两边,表示获取到整个列表 print(a[:])

python中列表与元组 python中列表和元组_学习_10

  • 切片操作还可以指定 “步长” , 也就是 "每访问一个元素后, 下标自增几步

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

python中列表与元组 python中列表和元组_开发语言_11

  • 切片操作指定的步长还可以是负数, 此时是从后往前进行取元素。 表示 "每访问一个元素之后, 下标自减几步。

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

python中列表与元组 python中列表和元组_元组_12

  • 当切片中的范围超出有效下标后,不会出现异常。而是尽可能的把符合要求的元素给获取到。

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

python中列表与元组 python中列表和元组_python中列表与元组_13

5. 遍历列表元素

“遍历” 指的是把一个列表里的每个元素都依次的取出来,再分别进行处理。遍历需搭配循环。

  • 使用 for 循环遍历列表

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

python中列表与元组 python中列表和元组_python中列表与元组_14

在遍历的过程中,循环里面写的不一定是打印也可以是别的操作。
elem 就代表了列表里的每个元素。elem 是 element 这个单词的缩写。

  • ** 使用 for 循环遍历,按照范围生成下标,按下标访问**

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

  • 使用 while 循环,通过下标遍历

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

6. 新增元素

  • 使用 append 方法,往列表末尾插入一个新增元素(尾插)

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

python中列表与元组 python中列表和元组_元组_15

此处的 append 是搭配列表对象 a 一起使用的,而不是作为一个独立的函数。
type,print,input,len,自定义函数等等都是独立函数。
像 append 这种要搭配对象来使用的"函数"(funtion), 也叫做"方法"(menthod)。在 Python 中对象可以视为变量。

  • 使用 insert 方法,往列表任意位置插入一个新增元素
    insert 第一个参数表示要插入元素的下标

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

python中列表与元组 python中列表和元组_开发语言_16

  • 如果 insert 方法 插入位置的下标越界访问了,则会直接插入在列表的末尾

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

python中列表与元组 python中列表和元组_python中列表与元组_17

7. 查找元素

  • 使用 in 操作符,判定元素是否在列表中存在。返回值是布尔类型
    not in 是 in 的反操作

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

python中列表与元组 python中列表和元组_python中列表与元组_18

  • 使用 index 方法,查找元素在列表中的下标. 返回值是一个整数. 如果元素不存在, 则会抛出异常

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

python中列表与元组 python中列表和元组_学习_19

8. 删除元素

  • 使用 pop 删除列表最末尾的元素

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

python中列表与元组 python中列表和元组_python中列表与元组_20

  • 使用 pop还能删除任意位置的元素,pop 的参数可以传一个下标过去

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

python中列表与元组 python中列表和元组_开发语言_21

  • 使用 remove 方法,按照值来进行删除元素

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

python中列表与元组 python中列表和元组_元组_22

9. 连接元素

  • 使用 + 能够把两个列表拼接在一起
    使用 + 拼接列表的结果会生成一个新的列表,而不会影响旧列表的内容。

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

python中列表与元组 python中列表和元组_元组_23

  • 使用 extend 方法,来进行拼接。这个拼接是把后一个列表的内容拼接到前一个列表的后面。

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

python中列表与元组 python中列表和元组_python_24


None 这是一个特殊的变量值,表示“啥都没有”。


extend 方法,其实是没有返回值的。这里是拿一个变量来接收一个没有返回值的方法的返回值,所以是None。

  • 使用 += 来进行拼接

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

python中列表与元组 python中列表和元组_python_25

  • a += b 等价于 a = a + b
  • a.extend(b) 则是直接把 b 的内容拼接到了 a 的后面
  • 对比于 a.extend(b) ,a += b 多了三步操作:
  1. 构造新的大列表
  2. 把大列表的值赋给 a 列表
  3. 把 a 列表中旧的值释放

10. 关于元组

元组的功能和列表相比,基本是一致的。
元组使用 ( ) 来表示

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

python中列表与元组 python中列表和元组_开发语言_26

元组不能修改里面的元素,列表则可以修改里面的元素

  • 因此, 像读操作,比如访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的.
  • 但是, 像写操作, 比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持

例如:修改元组元素,程序会报错

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

python中列表与元组 python中列表和元组_元组_27

另外, 元组在 Python 中很多时候是默认的集合类型.。
例如, 当一个函数返回多个值的时候。

def getPoint(): return 10, 20 result = getPoint() print(type(result))

python中列表与元组 python中列表和元组_学习_28


此处的 result 的类型,其实是元组。

既然已经有了列表, 为啥还需要有元组?
元组相比于列表来说, 优势有两方面:

  • 你有一个列表, 现在需要调用一个函数进行一些处理。 但是你有不是特别确认这个函数是否会把你的列表数据弄乱,那么这时候传一个元组就安全很多。
  • 接下来要讲的字典,,是一个键值对结构。 要求字典的键必须是 “可hash对象” (字典本质上也是一个hash表).。而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行。