Python入门笔记2 - 列表和元组

Posted 2022-11-22

• 很久以前就像学python了，还写过一篇文章​​Python入门笔记1-基本数据类型​​，但是后来各种事情耽搁就没怎么看了，现在开始继续学习
• 参考书《Python基础教程（第三版）》—— Magnus Lie Hetland

---

文章目录

• ​​一、序列​​

• ​​1. 序列概述​​
• ​​2. 序列的通用操作​​

• ​​（1）索引​​
• ​​（2）切片​​
• ​​（3）相加​​
• ​​（4）乘法​​
• ​​（5）成员资格​​

• ​​二、列表（list）​​

• ​​1. 创建列表​​
• ​​2. 序列转换为列表list(x)​​
• ​​3. 列表基本操作​​

• ​​（1）给元素赋值​​
• ​​（2）删除元素​​
• ​​（3）切片赋值​​

• ​​4. 列表方法​​

• ​​（1）append(x): None方法​​
• ​​（2）clear(): None方法​​
• ​​（3）copy(): list方法​​
• ​​（4）count(x): integer方法​​
• ​​（5）extend(x): None方法​​
• ​​（6）index(x): integer方法​​
• ​​（7）insert(n,object): None方法​​
• ​​（8）pop(): object方法​​
• ​​（9）remove(obj): None方法​​
• ​​（10）reverse(): None方法​​
• ​​（11）sort(): None方法​​
• ​​（12）高级排序​​
• ​​（13）小结​​

• ​​三、元组（tuple）​​

• ​​1、创建一个元组​​
• ​​2、序列转换为元组​​
• ​​3、元组相关操作​​
• ​​4、元组的作用​​

一、序列

• Python中最基本的数据结构为序列（这是一个统称，包含​​列表​​​/​​元组​​​/​​字符串​​等多种结构），序列中每个元素都有索引编号，从0开始。Python也支持从队尾找起的负索引。

1. 序列概述

• 列表、元组、字符串都属于序列
• 列表是可以修改的，但元组不行。
• 列表/元组中可以放不同类型的变量，也可以包含其他列表/元组

>>> data1 = [NO.1,1]   #列表
>>> data2 = [NO.2,2]   #列表
>>> dataSet = [data1,data2]  #列表
>>> dataSet
[[NO.1, 1], [NO.2, 2]]

2. 序列的通用操作

• 所有序列都支持以下操作：索引、切片、相加、相乘、成员资格检查、迭代。还有一些内置函数可以用来找出序列中的最大最小值、序列长度等

（1）索引

1. 序列中所有元素都有编号，左起第一个为0，右起第一个为-1

>>> data1=[NO.1,1]
>>> data1[0]
NO.1
>>> data1[-1]
1
>>> data1[1]
1
>>> data1[-2]
NO.1

2. 对于序列字面量，可以直接进行索引，不用把它赋给变量

>>> [Hello,1,World,2][-2]
World
>>> "World"[-1]
d

3. 如果函数返回一个序列，可以在调用的时候直接索引

>>> X = input("year:")[3]  # input读取键盘输入并返回一个字符串
year:2019         # 输入2019
>>> X
9

（2）切片

1. 切片用于访问特定范围内的元素，需要两个索引
2. 形式​​序列[begin,end,(step)]：序列​​，begin和end是两个索引，返回一个新序列，值为原序列下标[begin,end)区间。步长参数step可以不写，缺省步长为1

>>> num = "0123456789"
>>> num[2:5]
234
>>> num[-3:-1]
78

3. 要切片结束于末尾，省略第二个索引；要切片起始于开头，省略第一个索引

>>> num = "0123456789"
>>> num[2:]
23456789
>>> num[:3]
012
>>> num[:]
0123456789

4. 步长：切片时添加元素的间隔，默认为1，但也可以显式指定

1. 也可以有负数步长，这时从右往左取数
2. 注意步长不能是0，否则报错

>>> num = "0123456789"
>>> num[::2]
02468
>>> num[2:7:3]
25
>>> num[8:3:-1]  #可以有负数步长
87654
>>> num[1:5:-2]

（3）相加

1. 可以用加法拼接同型的序列，但是一般不能拼接不同型序列
2. 返回一个新列表，不是原地修改

>>> data1 = [NO.1,1]
>>> data2 = [NO.2,2]
>>> data1 + data2    #拼接两个列表
[NO.1, 1, NO.2, 2]

（4）乘法

1. 序列与数字x相乘，表示重复这个序列x次
2. 返回一个新列表，不是原地修改

>>> data1 = [NO.1,1]
>>> data1*3
[NO.1, 1, NO.1, 1, NO.1, 1]
>>> [32]*10
[32, 32, 32, 32, 32, 32, 32, 32, 32, 32]

2. 可以用乘法来初始化列表。Python中用​​none​​表示“什么都没有”，因此可按如下方法把列表长度初始化为10

>>> sequence = [None]*5  #sequence长度为5
>>> sequence
[None, None, None, None, None]

（5）成员资格

1. 要检查特定的值是否在序列中，可以使用运算符​​in​​，返回bool值True/False

>>> num = 0123456789
>>> 1in num
True
>>> ain num
False
>>> input(Enter a number: )in num
Enter a number: 3
True

二、列表（list）

• 列表是序列的一种，这里主要讨论列表不同于元组和字符串的地方

1. 列表是可变的，可以修改其内容
2. 列表有很多特有方法

1. 创建列表

1. 将元素用‘,’分割，加个方括号

>>> lst = [1,2,A,string]
>>> lst
[1,2,A,string]

2. 序列转换为列表list(x)

1. ​​List(x)​​：List函数可以把任何序列x转换为列表。（list实际是一个类，这个其实是列表的构造函数之一）

>>> list("1234567890")
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> list([1,"10"])
[1, 10]

2. 可以用​​.join(list)​​把字符列表list还原为字符串

• list中的元素必须都是char
• 这个join方法其实是把list中每个char放到str前面重复，这里放了一个空串，所以看起来是把list中字符拼成字符串了

>>> .join([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
1234567890

>>> string = ABC.join([1,2,3,4,5])
>>> string
1ABC2ABC3ABC4ABC5

3. 列表基本操作

（1）给元素赋值

1. 使用​​[]​​索引找到列表中一个元素并重新赋值（注意不要越界）

（2）删除元素

1. 删除元素：使用​​del list[n]​​来删除列表list中第n个元素（字典类型也支持这个）

>>> list = [1,2,3]
>>> list[1] = 103  #赋值
>>> list
[1, 103, 3]

>>> del list[1]    #删除
>>> list
[1, 3]

（3）切片赋值

1. 通过给切片赋值，可以将切片替换为长度不同的序列
2. 可以在不删除原有元素的情况下插入新元素
3. 可以用来删除元素

>>> name = list("12345") #切片赋值
>>> name[2:4]="abcd"
>>> name
[1, 2, a, b, c, d, 5]

>>> name = [1,5]     #插入元素（本质是切片赋值）
>>> name[1:1] = [2,3,4]
>>> name
[1, 2, 3, 4, 5]

>>> name = [1,5]     #删除元素（本质是切片赋值）
>>> name[0:1] = []
>>> name
[5]

4. 列表方法

• 列表list本身是一个类，这个类提供了若干方法。调用方法类似C/C++语言

（1）append(x): None方法

1. 添加一个对象到列表末尾
2. append方法就地修改列表，不会返回新列表

>>> num = list("12345")
>>> num
[1, 2, 3, 4, 5]
>>> num.append(6)
>>> num.append(“ABC”)
>>> num
[1, 2, 3, 4, 5, 6,ABC]

#下面这个程序不好，因为list是一个内置函数，如果用list起名，会导致list函数不能使用
>>> list = ["a",1]
>>> list.append("Hello")
>>> list
[a, 1, Hello]

（2）clear(): None方法

1. 方法clear就地清空列表，类似切片语句​​lst[:]=[]​​

>>> lst = list("Hello")
>>> lst
[H, e, l, l, o]
>>> lst.clear()
>>> lst
[]

（3）copy(): list方法

1. 常规赋值（如下）只是将另一个名字关联到列表（类似C中typedef别名）

>>> lst_A = []
>>> lst_B = lst_A
>>> lst_B
[]
>>> lst_B.append("abc")
>>> lst_A
[abc]

2. 方法copy复制列表，返回一个新列表，它是原列表的副本，这样就能把新列表变量关联到新列表，从而让列表副本和原本独立

>>> lst = []
>>> lst_ = lst.copy()
>>> lst_.append("123")
>>> lst_
[123]
>>> lst
[]

（4）count(x): integer方法

1. 方法count统计指定元素再列表中出现了几次

>>> [1,2,3,3,3,4,5,6].count(3)
3

（5）extend(x): None方法

1. 方法extend同时添加多个值到列表末尾也就是说在列表末尾添加另一个列表
2. extend类似列表拼接”+”，区别在于extend是在原表上修改，”+”返回了新列表
3. ​​a = a + b​​​比​​a.extend(b)​​效率低
4. 还可以用切片实现extend效果，但是可读性差

#extend方法
>>> lst = [1,2,3,4]
>>> lst.extend(list("abcde"))
>>> lst
[1, 2, 3, 4, a, b, c, d, e]

#用切片实现
>>> lst = [1,2,3,4]
>>> lst[len(lst):] = list("abcde")
>>> lst
[1, 2, 3, 4, a, b, c, d, e]

#用+运算实现
>>> lst = [1,2,3,4]
>>> lst += list("abcde")
>>> lst
[1, 2, 3, 4, a, b, c, d, e]

（6）index(x): integer方法

1. index查找列表中指定值第一次出现的索引，如果不存在指定值会报错

>>> [1,2,3,4].index(1)
0

（7）insert(n,object): None方法

1. ​​list.insert(n,object)​​用于将一个对象插入列表，位置为n
2. 用切片也可以实现类似效果，但可读性不好

#insert
>>> a = [1,2,3]
>>> a.insert(2,"a")
>>> a
[1, 2, a, 3]

#切片实现
>>> a = [1,2,3]
>>> a[2:2]="a"
>>> a
[1, 2, a, 3]

（8）pop(): object方法

1. pop从列表末尾删除一个元素，并把它返回
2. pop是唯一一个即修改原列表，又返回非none值的方法

>>> a = [1,2,3]
>>> b = a.pop()
>>> a
[1, 2]
>>> b
3

（9）remove(obj): None方法

1. ​​list.remove(obj)​​删除列表中第一个为obj的元素，如果表中不存在此元素会报错
2. 就地修改列表且无返回

>>> a = [1,2,3,4,5]
>>> a.remove(3)
>>> a
[1, 2, 4, 5]

（10）reverse(): None方法

• 就地修改列表且不返回值，将列表就地反向排列

>>> a = [1,2,3,4,5]
>>> a.reverse()
>>> a
[5, 4, 3, 2, 1]

（11）sort(): None方法

1. 对列表就地排序（默认从小到大），不返回值。从python2.7开始这个是稳定的排序算法

>>> a = [1,3,2,5,4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]

#不要这样做，这样只会对a排序，b为none
>>> a = [1,3,2,5,4]
>>> b = a.sort()

#先把b关联（=）到a的副本，再sort
>>> a = [1,3,2,5,4]
>>> b = a.copy()
>>> b.sort()
>>> b
[1, 2, 3, 4, 5]

2. 还可以使用内置函数​​sorted(object):list​​达到类似的效果。 Sorted函数可以用于任何序列（实际上，适用于任何可迭代对象），总是返回一个列表

>>> a = [1,3,2,5,4]
>>> b = sorted(a)
>>> b
[1, 2, 3, 4, 5]

#sorted函数可用于任何可迭代对象
>>>sorted(“Python”)
>>>[‘P’, ’h’ , ’n’ , ’o’ , ’t’ , ’y’]

（12）高级排序

1. sort方法和sorted函数都可以接受两个可选参数：key和reverse，它们是按名称指定的，称为关键字参数

1. Key指定排序的标准，类似C++中sort函数的cmp参数，区别在于，cmp函数直接判断元素相对大小，Key参数则是用来对每个元素创建一个键，再根据这些键排序。Key可以设置为自定义函数（后面再讲）
2. Reverse指定从小到大还是从大到小，只需将其指定为True或False，代表要不要按相反的顺序进行排序

#Key参数
>>> X = [‘123’ , ‘12’ , ‘1’ ]
>>> X.sort(Key = len)  #假设Key的函数已经写好了
>>> X
[‘1’ , ‘12’ , ‘123’]

#reverse参数
>>> X = [1,2,3,4]
>>> X.sort(reverse = True)
>>> X
[4,3,2,1]

（13）小结

1. 无返回值的方法：
   ​​​append / clear / extend / insert / remove / reverse / sort​​
2. 有返回值的方法：
   ​​​copy​​​：返回副本列表
   ​​​count​​​：返回指定元素出现次数
   ​​​index​​​：返回指定元素首次出现的索引
   ​​​pop​​：返回表中最后一个元素
3. 对列表进行就地修改的方法：
   ​​​append / clear / extend / pop / remove / reverse / sort​​

三、元组（tuple）

• 元组和列表一样都是序列，区别在于元组不可以修改
• 
  

1、创建一个元组

1. 将元素用‘,’分割即可，也可以加个圆括号

>>> 1,2,3
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)

2. 空元组：用空括号表示

>>> ()

3. 只有一个元素的元组：在值后加一个逗号

#注意不能(1)这样，要加括号只能写成(1,)
>>> 1, 
(1,) 

>>>(42)      #一个值直接加括号是没用的
>>>42
>>> 3*(40+2) #这样不能创建元组
126
>>> 3*(40+2,)  #创建了元组，逗号至关重要
(42, 42, 42)

2、序列转换为元组

1. 类似list类，tuple类可以把序列转为元组

#字符串 -> 元组
>>> a = tuple("Hello")
>>> a
(H, e, l, l, o)

#列表 -> 元组
>>> a = list("1234")
>>> a
[1, 2, 3, 4]
>>> b = tuple(a)
>>> b
(1, 2, 3, 4)

3、元组相关操作

1. 元组的创建和访问方法和列表完全类似
2. 因为元组不可修改，其他没有什么可以对元组进行的操作了

4、元组的作用

1. 用作映射中的键（以及集合的成员）
2. 有些内置函数返回元组
3. 一般而言只用列表就可以满足要求了，几乎所有情况下都可以用列表代替元组（除非元组用作字典键，这是不可以修改的）