Python基础知识笔记（二）——序列、元组

码农圈

已于 2022-04-21 11:25:30 修改

阅读量500

点赞数

文章标签： python

于 2022-03-30 19:43:48 首次发布

本文链接：https://blog.csdn.net/m0_51216771/article/details/123846805

版权

序列

序列是一种数据储存方式，用来存储一系列数据，序列里面存储的是对象的地址（id）。

一、字符串

字符串是字符序列。

二、列表

1、列表的创建

（1）基础语法创建

a=[1,2,3,4]

（2）list( ) 创建

a=list()
a
>>>[]

a=list(range(10))
a
>>>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a=list("liquanquanxiaopengyou")
a
>>>['l', 'i', 'q', 'u', 'a', 'n', 'q', 'u', 'a', 'n', 'x', 'i', 'a', 'o', 'p', 'e', 'n', 'g', 'y', 'o', 'u']

(3)range() 创建整数列表，语法格式：range（[start][end][step]）

python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其

转换成列表对象。

list(range(0,15,5))
>>>[0, 5, 10]

list(x*2 for x in range(100))       #循环创建多个元素
>>>[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198]

list(x*2 for x in range(100) if x%9==0)  #过滤元素
>>>[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

2、列表的增加

当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这

个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素

或删除元素，这会大大提高列表的操作效率。

（1）append()方法：默认尾部增加元素

a=[1,2]
a
>>>[1, 2]

a.append(100)
a
>>>[1, 2, 100]

a.append(200)
a
>>>[1, 2, 100, 200]

a.append(500)
a
>>>[1, 2, 100, 200, 500]

（2）+运算符：创建新的列表对象

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次

复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

（3）extend() 方法扩展列表

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

a = [20,40] 
id(a) 
>>>46016072 

a.extend([50,60]) 
id(a) 
>>>46016072

a
>>>[20，40，50，60]

（4）insert() 方法插入元素

a=[1, 2, 100, 200, 500]
a.insert(2,888)
a
>>>[1, 2, 888, 100, 200, 500]

（5）乘法扩展——多次重复

a=[1, 2, 888, 100, 200, 500]
b=a*3
b
>>>[1, 2, 888, 100, 200, 500, 1, 2, 888, 100, 200, 500, 1, 2, 888, 100, 200, 500]

3、列表元素的删除

列表的增加和删除本质上就是列表元素的拷贝。

（1）del删除

a=[1, 2, 888, 100, 200, 500]
del a[2]
a
>>>[1, 2, 100, 200, 500]

(2)pop() 方法

pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素，默认弹出最后一个元素。

a=[1, 2, 100, 200, 500]
a.pop()
>>>500

a.pop(1)
>>>2

a
>>>[1, 100, 200

(3)remove() 方法

删除首次出现的指定元素，若不存在该元素抛出异常。

b=[1, 2, 888, 100, 200, 500, 1, 2, 888, 100, 200, 500, 1, 2, 888, 100, 200, 500]
b.remove(100)
b
>>>[1, 2, 888, 200, 500, 1, 2, 888, 100, 200, 500, 1, 2, 888, 100, 200, 500]

b.remove(1000)
>>>Traceback (most recent call last):
      File "<pyshell#37>", line 1, in <module>
        b.remove(1000)
    
    ValueError: list.remove(x): x not in list

3、列表元素的访问和计数

（1）通过索引直接访问元素

我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则

会抛出异常。

a = [10,20,30,40,50,20,30,20,30]
a[2]
>>>30

a[100]

>>>Traceback (most recent call last):
      File "<pyshell#40>", line 1, in <module>
        a[100]
    IndexError: list index out of range

（2）index() 方法获得指定元素在列表中首次出现的索引

语法：index(value,[start,[end]])。其中， start 和 end 指定了搜索的范围。

a=[10, 20, 30, 40, 50, 20, 30, 20, 30]

a.index(20)
>>>1
a.index(20,5)
>>>5
a.index(20,6)
>>>7

（3）count() 方法获得指定元素在列表中出现的次数

a = [10,20,30,40,50,20,30,20,30] 
a.count(20) 
>>>3

（4）len() 方法返回列表长度

a = [10,20,30] 
len(a) 
>>>3

（5）成员资格判断

判断列表中是否存在指定的元素，我们可以使用 count()方法，返回 0 则表示不存在，返回

大于 0 则表示存在。但是，一般我们会使用更加简洁的 in 关键字来判断，直接返回布尔值。

4、列表的切片操作

我们在前面学习字符串时，学习过字符串的切片操作，对于列表的切片操作和字符串类似。

切片是 Python 序列及其重要的操作，适用于列表、元组、字符串等等。

切片的格式如下：切片 slice 操作可以让我们快速提取子列表或修改。

标准格式为：[起始偏移量 start:终止偏移量 end[:步长 step]]

注：当步长省略时顺便可以省略第二个冒号

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。

起始偏移量小于 0 则会当做 0，终止偏移量大于“长度-1”会被当成”长度-1”。

[10,20,30,40]
[1:30]
>>>[20, 30, 40]

#我们发现正常输出了结果，没有报错。

5、列表的遍历

a=[10, 20, 30, 40, 50, 20, 30, 20, 30]

for x in a :print(x)

>>>
10
20
30
40
50
20
30
20
30

6、复制列表所有元素到新的列表对象

list1 = [30,40,50]

list2 = list1

只是将 list2 也指向了列表对象，也就是说 list2 和 list2 持有地址值是相同的，列表对象本身的元素并没有复制。

我们可以通过如下简单方式，实现列表元素内容的复制：

list1 = [30,40,50]

list2 = [] + list1

注：我们后面也会学习 copy 模块，使用浅复制或深复制实现我们的复制操作。

7、列表排序

（1）修改原列表，不建新列表的排序

a=[10, 20, 30, 40, 50, 20, 30, 20, 30]
a.sort()
a
>>>[10, 20, 20, 20, 30, 30, 30, 40, 50]

a.sort(reverse=True)
a
>>>[50, 40, 30, 30, 30, 20, 20, 20, 10]

import random
random.shuffle(a)
a
>>>[10, 20, 30, 50, 40, 30, 30, 20, 20]

（2）建新列表的排序

a=[10, 50, 40, 30]
id(a)
>>>2200645656320

b=sorted(a)
b
>>>[10, 30, 40, 50]
id(b)
>>>2200645622784

c=sorted(a,reverse=True)
c
>>>[50, 40, 30, 10]

#b,c都是完全新的列表对象

（3）reversed()返回迭代器

内置函数 reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数

reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

a = [20,10,30,40] 
c = reversed(a) 
c 
>>>
    <list_reverseiterator object at 0x0000000002BCCEB8>

#返回的值是一个迭代器不是对象，只能使用一次。

list(c) 
>>>[40, 30, 10, 20] 

list(c) 
>>>[]

（4）最大最小值及求和

a = [3,10,20,15,9] 
max(a) 
>>> 20

min(a) 
>>> 3

a = [3,10,20,15,9] 
sum(a) 
>>> 57

8、二维列表

一维列表可以帮助我们存储一维、线性的数据。

二维列表可以帮助我们存储二维、表格的数据。

a=[

    ["高小一",18,30000,"北京"],
    ["高小二",19,20000,"上海"],
    ["高小一",20,10000,"深圳"], 
  ]

print(a[1][0],a[1][1],a[1][2]) 

>>>高小二 19 20000

三、元组 tuple

列表属于可变序列，可以任意修改列表中的元素。

元组属于不可变序列，不能修改元组中的元素。

因此，元组没有增加元素、修改元素、删除元素相关的方法。

因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。

元组支持如下操作：

1. 索引访问

2. 切片操作

3. 连接操作

4. 成员关系操作

5. 比较运算操作

6. 计数：元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。

1、元组的创建

（1）通过（）创建，（）可以省略

a = (10,20,30)  #或者 
a = 10,20,30 

#如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数 1，(1,) 解释为元组。 

a = (1) 
type(a) 
>>>  <class 'int'> 

a = (1,) #或者 
a = 1, 
type(a) 

>>>  <class 'tuple'>

（2）通过tuple()创建元组——tuple(可迭代的对象)

b = tuple()
b
>>>()

b = tuple("abc")
b
>>>('a', 'b', 'c')

b = tuple(range(3))
b
>>>(0, 1, 2)

b = tuple([2,3,4])
b
>>>(2, 3, 4)

tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。

list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

2、元组元素的访问和计数

元组的元素访问和列表一样，只不过返回的仍然是元组对象。

列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。

a = (20,10,30,9,8)
a[1]
>>>10

a[1:3]
>>>(10, 30)

a[:4]
>>>(20, 10, 30, 9)

sorted(a)
>>>[8, 9, 10, 20, 30]

3、元组的拼接zip()方法

zip(列表 1，列表 2，...)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d=zip(a,b,c)
list(d)
>>>[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

4、生成器推导式创造元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__() 方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

s = (x*2 for x in range(5))
s
>>> <generator object <genexpr> at 0x000001D40E8CE340>   #生成器

tuple(s)
>>>(0, 2, 4, 6, 8)

list(s)
>>>[]

s
>>> <generator object <genexpr> at 0x000001D40E8CE340>

tuple(s)
>>>()                  #生成器只能遍历一次，第二次就空了，要再创建一次

s = (x*2 for x in range(5))
s.__next__()
0
s.__next__()
2
s.__next__()
4
s.__next__()
6
s.__next__()
8
s.__next__()

Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    s.__next__()
StopIteration