python 基础 day3. 列表与元组

python 基础 day3. 列表与元组

列表

数组把多个数据挨个存储到一起，通过数组下标可以访问数组中的各个元素。但是要求各元素类型一致，而在python中有功能更强的列表

创建列表

• 从形式上看，列表会将所有元素都放在一对中括号 [] 中，相邻元素之间用逗号分隔

[element1,element2,element3,…,elementn]

number=[1,2,3,4]

• 使用list()函数创建列表用于将元组、区间（range）等对象转换为列表

a = ('c', 2, -1)
# 将元组转换成列表
a_list = list(a)
print(a_list)
#['c',2,-1]

访问列表元素

• 打印列表直接使用 print() 函数即可

name = ["C",1]
print(name)

• 通过列表的索引获取指定的元素`

name =['c',2,3,4]
print(name[0])   #c

• 在输出单个列表元素时，是不带中括号的，且如果是字符串，还不包括左右的引号。

删除列表

• 可以使用 del 语句将其删除

del 的语法格式为：

del listname
#listname为列表名

向列表中添加元素

• 使用append()方法在列表的末尾追加元素

listname.append(obj)
#其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。但是不能添加多个对象

number=[1,2,3,4]
number.append(5)
print(number)   #[1, 2, 3, 4, 5]

• extend()方法向列表末尾添加多个元素，事实上使用一个列表来扩充另一个列表，所以它的参数应该是一个列表或者元组

b_list = ['a', 30]
# 追加元组中的所有元素
b_list.extend((-2, 3.1))
print(b_list)     #['a', 30, -2, 3.1]
# 追加列表中的所有元素
b_list.extend(['C', 'R', 'A'])
print(b_list)     #['a', 30, -2, 3.1, 'C', 'R', 'A']
# 追加区间中的所有元素
b_list.extend(range(97, 100))
print(b_list)     #['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

但是

a=[1,2,3]
a.extend(7,8)
print(a)
#TypeError: extend() takes exactly one argument (2 given)

严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。

• insert()方法插入元素

在列表中间增加元素

基本语法
listname.insert(a,b)

第一个参数代表在列表的位置，第二个参数代表在这个位置插入的元素
使用 insert() 方法向列表中插入元素，和 append() 方法一样，无论插入的对象是列表还是元组，都只会将其整体视为一个元素。

a=[1,2,3,4]
a.insert(3,['a',4])#在3位置插入一个列表
print(a)  #[1, 2, 3, ['a', 4], 4]

列表删除元素

• 根据索引值删除元素

和删除列表类似，用del语句

a_list=[20,2.4,(3,4)]
del a_list[-1]   #删除第三个元素
print(a_list)    #[20, 2.4]

• 根据元素值进行删除

remove() 方法根据元素本身的值来执行删除操作，删除第一个和指定值相同的元素，如果找不到该元素，该方法将会引发 ValueError 错误

c_list = [20, 'crazyit', 30,30, -4, 'crazyit', 3.4]
# 删除第一次找到的30
c_list.remove(30)
print(c_list)   #[20, 'crazyit', -4, 'crazyit', 3.4]
# 删除第一次找到的'crazyit'
c_list.remove('crazyit')
print(c_list)    #[20, -4, 'crazyit', 3.4]
#再次尝试删除 30，会引发 ValueEroor 错误
c_list.remove(30) #ValueError: list.remove(x): x not in list

• 删除列表所有元素

clear() 方法，正如它的名字所暗示的，该方法用于清空列表的所有元素

c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
c_list.clear()
print(c_list)  #[]

列表修改元素

• 程序可以对列表的元素赋值，修改列表的元素

a_list = [2, 4, -3.4, 'crazyit', 23]
# 对第3个元素赋值
a_list[2] = 'fkit'
print(a_list) # [2, 4, 'fkit', 'crazyit', 23]
# 对倒数第2个元素赋值
a_list[-2] = 9527
print(a_list) # [2, 4, 'fkit', 9527, 23]

• 也可通过 slice 语法对列表其中一部分赋值

在执行这个操作时，并不要求新赋值的元素个数与原来的元素个数相等。这意味着通过这种方式既可为列表增加元素，也可为列表删除元素。

• 对列表中间一段赋值

b_list = list(range(1, 5))
print(b_list)
# 将第2个到第4个（不包含）元素赋值为新列表的元素
b_list[1: 3] = ['a', 'b']
print(b_list) # [1, 'a', 'b', 4]

• 对列表中空的 slice 赋值，就变成了为列表插入元素

# 将第3个到第3个（不包含）元素赋值为新列表的元素，就是插入
b_list[2: 2] = ['x', 'y']
print(b_list) # [1, 'a', 'x', 'y', 'b', 4]

• 将列表其中一段赋值为空列表，就变成了从列表中删除元素

# 将第3个到第6个（不包含）元素赋值为空列表，就是删除
b_list[2: 5] = []
print(b_list) # [1, 'a', 4]

• 对列表使用 slice 语法赋值时，不能使用单个值；如果使用字符串赋值，Python
  会自动把字符串当成序列处理，其中每个字符都是一个元素。

 Python会自动将str分解成序列
 b_list[1: 3] = 'Charlie'
 print(b_list) # [1, 'C', 'h', 'a', 'r', 'l', 'i', 'e']

• 在使用 slice 语法赋值时，也可指定 step 参数。但如果指定了 step参数，则要求所赋值的列表元素个数与所替换的列表元素个数相等

c_list = list(range(1, 10))
# 指定step为2，被赋值的元素有4个，因此用于赋值的列表也必须有4个元素
c_list[2: 9: 2] = ['a', 'b', 'c', 'd']
print(c_list) # [1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']

常用方法（count、index、pop、reverse和sort）

• count()此方法用于统计列表中某个元素出现的次数，其基本语法格式

listname.count(obj)

a= [2, 30, 'a', [5, 30], 30]# 计算列表中30的出现次数
print(a.count(30))   #2
# 计算列表中[5, 30]的出现次数
print(a.count([5, 30]))  #1

• index()用于定位某个元素在列表中出现的位置（也就是索引），如果该元素没有出现，则会引发 ValueError 错误。此方法的基本语法格式

listname.index(obj,start,end)

a = [2, 30, 'a', 'b', 'crazyit', 30]
# 定位元素30的出现位置
print(a.index(30))#1
# 从索引2处开始、定位元素30的出现位置
print(a.index(30, 2))#5
 # 从索引2处到索引4处之间定位元素30的出现位置，因为找不到该元素，会引发 ValueError 错误
print(a.index(30, 2, 4))

• pop()移除列表中指定索引处的元素，如果不指定，默认会移除列表中最后一个元素。此方法的基本语法格式

listname.pop(index)

a_list=[1,2,3]
#移除列表的元素 3
print(a_list.pop())#3
print(a_list)#[1,2]
#移除列表中索引为 0 的元素1
print(a_list.pop(0))#1
print(a_list)[2]

• reverse()会将列表中所有元素反向存放

a=list(range(1,8))
print(a)#[1, 2, 3, 4, 5, 6, 7]
a.reverse()
print(a)#[7, 6, 5, 4, 3, 2, 1]

• sort()用于对列表元素进行排序，排序后原列表中的元素顺序会方发生改变。sort() 方法的语法格式如下：

listname.sort(key=None, reverse=False)

• key 参数用于指定从每个元素中提取一个用于比较的键。例如，使用此方法时设置 key=str.lower 表示在排序时不区分字母大小写。
• reverse 参数用于设置是否需要反转排序，默认 False 表示从小到大排序；如果将该参数设为 True，将会改为从大到小排序。

a_list = [3, 4, -2, -30, 14, 9.3, 3.4]
# 对列表元素排序
a_list.sort()
print(a_list)#[-30, -2, 3, 3.4, 4, 9.3, 14]
b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
# 对列表元素排序：默认按字符串包含的字符的编码大小比较
b_list.sort()
print(b_list) # ['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']

列表分片

• 列表分片的通用说法

listname[start :] stop [: step]

• start,step默认值为1 `
• 一般运行到stop结束，但不包括stop的数值

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

令list1=list2就相当于创建了一个新的列表list1
改变list2，不影响list1

list2=[1,2]
list1=list2
del list2
print(list1)#[1, 2]

一些常用操作符（>,=,<,+,*,in）

• 连接操作符 +
• 逻辑操作符
• 重复操作符*
• 比较操作符
• 成员关系操作符

list1 = [123, 456]
list2 = [234, 123]
print(list1 > list2)  # False
list3 = [123, 456]
print((list1 < list2) and (list1 == list3))  # True
list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 234, 123]
list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]
print(123 in list3)  # True
print(456 not in list3)  # False

元组

和列表类似，也是由一系列按特定顺序排序的元素组成。和列表不同的是，列表可以任意操作元素，是可变序列；而元组是不可变序列，即元组中的元素不可以单独修改。

• 元组可以看做是不可变的列表。通常情况下，元组用于保存不可修改的内容。

创建访问元组

a=(1,3,'as')
print(a)#(1, 3, 'as')
print(tuple(range(1,9)))#(1, 2, 3, 4, 5, 6, 7, 8)

• 当创建的元组中只有一个元素时，此元组后面必须要加一个逗号“,”，否则 Python 解释器会将其误认为字符串,或者整数

a=('a')
print(type(a))#<class 'str'>
b=(1,)
print(type(b))#<class 'tuple'>

创建二维数组

a = (1,2, 3), (1, 2)
print(a)
# ((1, 2, 3), (1, 2))
print(a[0][0])#1
print(a[0])#(1,2,3)

访问元组元素

a=(1,2,'a')
print(a[1])#2

• 在此基础上，元组也支持采用切片方式获取指定范围内的元素

更新删除元组

• 对元组重新赋值来更新元组
• 通过连接多个元组的方式向元组中添加新元素

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

• 使用 del 语句将其删除

a=(1,)
del a
print(a)#NameError: name 'a' is not defined

内置方法

元组大小和内容都不可更改，因此只有 count 和 index 两种方法。

t = (1, 10.31, 'python')
print(t.count('python'))  # 1
print(t.index(10.31))  # 1

• count(‘python’) 是记录在元组 t 中该元素出现几次，显然是 1 次
• index(10.31) 是找到该元素在元组 t 的索引，显然是 1

元组操作运算符

与列表类似
（+,*,>,<,=）

解压元组

• 解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

• 解压二维元组（按照元组里的元组结构来定义变量）

t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python

• 如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了rest 变量。

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]

• 如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」，例子如下

a, b, *_ = t
print(a, b)  # 1 2