第三章 列表与元组

版权声明：版权声明：本文为博主原创文章，转载请注明出处。 https://blog.csdn.net/qq_26489189/article/details/82459023

Python 3.5笔记

第三章 列表与元组

通用序列操作

索引

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字，代表它在序列中的位置（索引），从0开始。获取元素的方式为：在变量后加中括号，在中括号中输入所取元素的编号值。索引的位置可以从左到右，也可以从右到左。从左到右时从0开始，从右到左时从-1开始。

greeting = "Hello"
print(greeting[0])
print(greeting[-1])

输出：

H
o

对于字符串，不定义变量，直接使用索引也是可以的

print("hello"[1])

输出

e

分片

索引用来对单个元素进行访问，使用分片可以对一定范围内的元素进行访问。分片通过冒号相隔的两个索引实现。

分片操作即支持正数索引，也支持负数索引。分片中最左面的元素必须比最右面的元素早出现在序列中。（并不是指左面的索引比右面的元素数值小），否则就返回一个空序列。

分片操作的实现需要提供两个索引作为边界。第一个索引的元素包含在分片内，第二个索引的元素不包含在分片内。像数学中的a<=x<b，x是我们需要得到的元素，a是分片操作的第一个索引，b是第二个索引，b不包含在x的范围内。

number = [1,2,3,4,5,6,7,8,9,10]
print(number[0:3])
print(number[-1:-3])#分片中最左面的元素必须比最右面的元素早出现在序列中
# （并不是指左面的索引比右面的元素数值小），否则就返回一个空序列
print(number[-3:-1])
print(number[-3:0])#比如这个时候就会返回空置，所以注意理解上面那句话，
#即：最左面的元素必须比最右面的元素早出现在序列中
# （并不是指左面的索引比右面的元素数值小）

输出：

[1, 2, 3]
[]
[8, 9]
[]

如果需要取得的分片包括序列结尾的元素，只需将第二个索引设置为空即可。

#如果需要取得的分片包括序列结尾的元素，只需将第二个索引设置为空即可
print(number[-3:])
print(number[0:])
print(number[:0])#最后一个元素为第一个，输出为空
print(number[:3])
print(number[:])#输出整个数组

输出

[8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10
[]
[1, 2, 3]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

步长

分片中使用步长用于取序列中不连续的元素。没有设置步长时，也可以理解为默认步长是1。

print(number[0:10:1])
print(number[0:10:2])
print(number[2:5:3])
print(number[::3])

输出

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 5, 7, 9]
[3]
[1, 4, 7, 10]

输入的步长不能为0

print(number[0:10:0]) #输入的步长不能为0

输出

Traceback (most recent call last):
  File Chapter3.py, line 29, in <module>
    print(number[0:10:0])
ValueError: slice step cannot be zero

输入的步长也可以是负数，当步长是负数时，从右往左进行。

对于正数步长，python会从序列的头部开始向右提取元素，直到最后一个元素；对于负数步长，则是从序列的尾部开始向左提取元素，直到第一个元素。正数步长必须让开始点小于结束点，而负数步长必须让开始点大于结束点。

print(number[10:0:-2])
print(number[:5:-2])#这个要注意理解一下
print(number[10:0:-1])#注意number的最大索引应该是9，索引10指向的是第11个元素，是不存在的。
#但是由于在最后一个元素之后，因此在分片中能得到最后一个元素，这样做是没问题的。
#第二个索引为0，取不到序列中的第一个元素
#print(number[10])#但是直接访问的话是不可以的
print(number[10::-1])#设置number的第二个索引为空，可以取到序列的一个元素。
print(number[2::-1])#设置number的第二个索引为空，可以取到序列的一个元素。
print(number[2:0:-1])#第二个索引为0，取不到序列中的第一个元素

输出

[10, 8, 6, 4, 2]
[10, 8]
[10, 9, 8, 7, 6, 5, 4, 3, 2]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[3, 2, 1]
[3, 2]

序列相加

使用加号可以进行序列的连接操作。数字序列和数字序列相加后，得到还是数字序列。字符串或字符串序列和字符串或字符串序列相加后，得到的还是字符串或字符串序列。但是，只有类型相同的序列才能通过加号进行序列连接操作，不同类型的序列不能通过加号进行序列连接操作。

#序列相加
a = [1,2,3]
b = [4,5,6]
print(a + b)
c = ["hello"]
d = ["python"]
print(c + d)
e = "hello,"
f = "python"
print(e + f)
print(a + e)

输出

[1, 2, 3, 4, 5, 6]
['hello', 'python']
hello,python
Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 50, in <module>
    print(a + e)
TypeError: can only concatenate list (not "str") to list

序列乘法

用一个数字x乘以一个序列会生成新的序列。在新的序列中，原来的序列将被重复x次，这就是序列中的乘法。

如果要创建一个重复序列，就可以使用序列的乘法快速达到需要的列表。

#序列的乘法
print("序列的乘法")
print("hello"*5)
print([7]*10)

输出

序列的乘法
hellohellohellohellohello
[7, 7, 7, 7, 7, 7, 7, 7, 7, 7]

python中可以使用None代表空值，None是Python的内建值，确切的含义是这里什么也没有。

#空置相乘
aa = [None]*5
print(aa)#长度是5的空置
aa = []*5
print(aa)#只有一个元素是空值，即长度是1的空置

[None, None, None, None, None]
[]

成员资格，in操作符的用法

in运算符用于检验某个条件是否为真，并返回检验结果，检验结果为真返回True，结果为假返回False

#成员资格
print("成员资格")
greeting = "hello,world"
print('w' in greeting)
print('a' in greeting)
users = ["C罗","梅西","姆巴佩"]
print("C罗" in users)
print("卡卡" in users)
number = [1,2,3,4,5]
print(1 in number)
print(6 in number)
print(3 in greeting)#数字类型不能在字符串类型中通过in进行成员资格检测

成员资格
True
False
True
False
True
False
    print(3 in greeting)
TypeError: 'in <string>' requires string as left operand, not int

长度、最小值和最大值

#长度、最小值和最大值
print("长度、最小值和最大值")
numbers = [300,200,100,800,500]
print(len(numbers))
print(max(numbers))
print(min(numbers))

输出

长度、最小值和最大值
5
800
100

列表

更新列表

元素赋值

通过对元素赋值，可以更新列表的值。可以对列表中的元素赋不同类型的值。对列表中的元素赋值时，不能超过列表的最大编号

#元素赋值
print("元素赋值")
a = [1,2,3,2,1]
a[1] = 10
print(a)
a[2] = "hello"#可以对列表中的元素赋不同类型的值
print(a)
a[5] = 'abc'#对列表中的元素赋值时，不能超过列表的最大编号
print(a)

输出

元素赋值
[1, 10, 3, 2, 1]
[1, 10, 'hello', 2, 1]
    a[5] = 'abc'
IndexError: list assignment index out of range

增加元素

append()方法是一个用于在列表末尾添加新对象的方法。该方法的语法如下：

list.append(obj)

此语法中list代表列表，obj代表需要添加到list列表末尾的对象

#####删除元素

print("删除元素")
str = ["a","b","c","d","e"]
print(len(str))
del str[0]
print(str)
print(len(str))

输出

删除元素
5
['b', 'c', 'd', 'e']
4

分片赋值

可以通过分片赋值直接对列表进行变更。分片赋值不仅能对列表赋值，还可以使用与原序列不等长的序列将分片替换，并改变列表的长度。

list()函数

list()函数可以直接将字符串转换为列表。list()函数不仅适用于字符串，所有类型的序列都适用。

#分片赋值
print("分片赋值")
show = list("2018世界杯法国夺冠了")
print(show)
show[7:9] = list("中国")
print(show)
greeting = list("hi")
print(greeting)
greeting[1:] = list("ello")
print(greeting)

输出

分片赋值
['2', '0', '1', '8', '世', '界', '杯', '法', '国', '夺', '冠', '了']
['2', '0', '1', '8', '世', '界', '杯', '中', '国', '夺', '冠', '了']
['h', 'i']
['h', 'e', 'l', 'l', 'o']

分片赋值可以在不替换任何原有元素的情况下，在任意位置插入新元素。

与append()函数的区别，append()函数只能在末尾增加列表的长度

#分片赋值可以在不替换任何原有元素的情况下，在任意位置插入新元素
field = list("ae")
print(field)
field[1:1] = list("bcd")
print(field)
field2 = list("法国夺冠了")
field2[0:0] = list("2018世界杯")
print(field2)

['a', 'e']
['a', 'b', 'c', 'd', 'e']
['2', '0', '1', '8', '世', '界', '杯', '法', '国', '夺', '冠', '了']

分片赋值同样支持类似删除的功能

#分片赋值同样支持类似删除的功能
field = list("abcde")
print(field)
field[1:4] = []
print(field)
field2 = list("2018世界杯法国夺冠了")
del field2[0:7]
print(field2)

['a', 'b', 'c', 'd', 'e']
['a', 'e']
['法', '国', '夺', '冠', '了']

嵌套列表

在列表中可以嵌套列表，嵌套的列表取出后还是列表

#嵌套列表
field = list("abc")
print(field)
number = [1,2,3]
mix = [field,number]
print(mix)
print(mix[0])
print(mix[1])

输出

['a','b','c']
[['a', 'b', 'c'], [1, 2, 3]]
['a', 'b', 'c']
[1, 2, 3]

列表方法

1.append

这个方法前面已经讲过了，用于在列表末尾增加元素。格式为

list.append(obj)

2.count

count()方法用于统计某个元素在列表中出现的次数。语法如下

list.count(obj)

3.extend

extend()方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。语法如下：

list.append(seq)

seq代表元素列表

使用序列相加的方法也能达到extend（)方法的效果，但是并没有改变原来列表的值，这就是extend()方法和拼接的区别。

同样可以使用分片赋值的方法达到同样的效果，但是不如extend()方法易于理解

#list方法，extend()方法
print("list方法，extend()方法")
a = ["hello","world"]
b = ["python","is","funny"]
print(a.extend(b))#extend()方法的返回值是None
print(a)#但是extend()方法改变了列表a的值
a = ["hello","world"]
print(a + b)#a + b的返回值是将a和b做了拼接
print(a)#但是并没有改变a的值，这就是extend()方法和拼接的区别
a[len(a):] = b
print(a)

输出

list方法，extend()方法
None
['hello', 'world', 'python', 'is', 'funny']
['hello', 'world', 'python', 'is', 'funny']
['hello', 'world']
['hello', 'world', 'python', 'is', 'funny']

append与extend的区别

print("append()与extend()的区别")
a = ["hello"]
b = ["python","is","funny"]
a.append(b)#将b做为一个列表追加到a中
print(a)
a = ["hello"]
c = "python,is,funny"
a.append(c)#将b做为一个字符串追加到a中
print(a)
a = ["hello"]
a.extend(b)
print(a)#将b中的元素分别追加到a中
a = ["hello"]
c = "python,is,funny"
a.extend(c)
print(a)

输出

append()与extend()的区别
['hello', ['python', 'is', 'funny']]
['hello', 'python,is,funny']
['hello', 'python', 'is', 'funny']
['hello', 'p', 'y', 't', 'h', 'o', 'n', ',', 'i', 's', ',', 'f', 'u', 'n', 'n', 'y']

4.index

index()方法，用于返回元素在列表的索引位置。语法格式如下：

list.index(obj)

#index()方法
print("index()方法")
field = ["hello","world","python","is","funny"]
print(field)
print(field.index("hello"))
print(field.index("python"))
print(field.index("abc"))#不存在时会报错

index()方法
['hello', 'world', 'python', 'is', 'funny']
0
2
Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 169, in <module>
    print(field.index("abc"))
ValueError: 'abc' is not in list

5.insert

insert()方法用于将对象插入列表。格式如下

list.insert(index,obj)

index代表对象obj需要插入的索引位置，obj代表插入的对象

#insert()方法
print("insert()方法")
number = [1,2,3]
print(number)
print(number.insert(2,"插入在2之后3之前"))#insert方法并没有返回值，而是直接该表了列表的值
print(number)
number = [1,2,3]
number[2:2] = ["插入在2之后3之前"]#使用分片赋值也能实现同样的功能，但是不如使用insert()方法好理解
print(number)

输出

insert()方法
[1, 2, 3]
None
[1, 2, '插入在2之后3之前', 3]
[1, 2, '插入在2之后3之前', 3]

6.pop

pop()方法用于移除列表中的一个元素（默认是最后一个元素），并且返回该元素的值。语法格式为：

list.pop() #默认是移除最后一个元素
list.pop(index) #或者移除指定序列的元素，并且返回指定序列的元素

code

#pop()方法
field = ["hello","world","python","is","funny"]
print(field.pop())
print(field)
print(field.pop(1))
print(field)

输出

funny
['hello', 'world', 'python', 'is']
world
['hello', 'python', 'is']

7.remove

remove()方法用于移除列表中某个值的第一个匹配项。语法格式如下

list.remove(obj)

obj为将要remove的元素。remove返回None值，但是会改变原list的值

#remove()方法
field = ["hello","python","how","funny","python","is"]
print(field.remove("python"))
print(field)#注意只会删除匹配上的第一个元素

None
['hello', 'how', 'funny', 'python', 'is']

8.reverse

reverse()方法用于方向列表中的元素。语法格式如下

list.reverse()

code

#reverse()方法
print("reverse()方法")
number = [1,2,3]
print(number.reverse())#注意reverse()方法的返回值是None
print(number)#但是reverse()方法会改变list的值

输出

reverse()方法
None
[3, 2, 1]

9.sort

sort()方法用于对原列表进行排序，如果指定了参数，就使用参数指定的比较方法进行排序。语法格式如下

list.sort(func)

sort()方法不会改变返回值（返回None），而是直接改变列表的值。

使用sorted()方法，则会直接返回列表反转后的结果

#sort()方法
print("sort()方法")
number = [5,8,7,2,4,3]
print(number.sort())#sort()方法并不会返回值
print(number)#而是直接改变列表的值
print(sorted(number))#使用sorted()方法，则会直接返回列表反转后的结果

输出

sort()方法
None
[2, 3, 4, 5, 7, 8]
[2, 3, 4, 5, 7, 8]

10.clear

clear()方法用于清空列表，类似于del list[:]。语法格式为：

list.clear()

code

#clear()方法
print("clear()方法")
field = ["hello","python","how","funny","python","is"]
field.clear()
print(field)

输出

clear()方法
[]

11.copy

copy()方法用于复制列表，类似于a[:]。语法格式为:

list.copy()

code

#copy()方法
print("copy()方法")
field = ["hello","python"]
field2 = field.copy()
print(field2)

输出

copy()方法
['hello', 'python']

12.高级排序

sort()方法有两个可选参数，即key和reverse。key代表关键字，reverse为布尔值，True代表反转，False代表不反转。

#sort()方法
print("sort()方法")
field = ["hello","python","funny","python","is"]
print(field.sort(key=len,reverse=True))
print(field)

输出

sort()方法
None
['python', 'python', 'hello', 'funny', 'is']

元组

Python的元组于列表相似，不同之处在于元组的元素不能修改。创建元组的方式很简单，如果你用逗号分隔了一些值，就会自动创建元组。

1. 定义元组时，加上括号和不加括号的效果是一样的
2. 但是定义元组时必须得有逗号

#元组
print("元组的定义")
number = 1,2,3
print(number)#这样打印出的是元组
print(1,2,3)#注意，有意思的是，这样打印时，打印的并不是一个元组。这样打印出来的是什么？
number = (1,2,3)#加上括号和不加括号的效果是一样的
print(number)
field = "hello","world"
print(field)
field = ("hello","world")
print(field)
field = ()
print(field)
field = ("hello",)#定义元组时必须得有逗号
print(field)
field = ("hello")#如果没有逗号，则仅仅是一个字符串
print(field)

元组的定义
(1, 2, 3)
1 2 3
(1, 2, 3)
('hello', 'world')
('hello', 'world')
()
('hello',)
hello

tuple函数

tuple函数的作用就是以一个序列作为参数，并把它转换为元组。这点和list函数的性质基本一样。如果参数是元组，则会被原样返回。

#tuple函数
print("tuple函数")
print(tuple(["hello","python"]))
print(tuple("hello"))
print(tuple(("hello",)))#如果参数是元组，则会被原样返回。

输出

tuple函数
('hello', 'python')
('h', 'e', 'l', 'l', 'o')
('hello',)

元组的基本操作

1. 访问元组

直接使用元素的下标访问即可，支持分片

#访问元组
number = (1,2,3)
print(number)
print(number[0])
print(number[0:2])

输出

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

2. 修改元组

之前说过，元组是不可以修改的。但是可以对元组进行连接。

#修改元组
number = (1,2,3)
number2 = (4,5,6)
print(number + number2)

输出

(1, 2, 3, 4, 5, 6)

3. 删除元组

元组是不可以修改的，因此元组的值当然也是不可以删除的。但是可以删除整个元组

#删除元组
number2 = (1,2,3)
del number2
print(number2)

输出

Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 263, in <module>
    print(number2)
NameError: name 'number2' is not defined

元组内置函数

1. len(tuple)函数

2. max()函数

3. min()函数

number2 = (1,2,3)
print(len(number2))
#max()函数
print(max(number2))
#min()函数
print(min(number2))

输出

3
3
1

列表与元组的区别

嵌套列表

嵌套列表指的是，一个列表中包含另一个列表，即二维数组，甚至还有三维、四维等多维数组。

t = (1,2,["hello","python"])
print(t[2][1])

输出

python

列表元组的区别

区别在于，元组的值不可以修改，列表的值可以修改。

number2 = (1,2,3)
#number2[1] = 4 #元组的值不可以改变

#嵌套列表
t = (1,2,["hello","python"])
print(t[2][1])
t[2][1] = "world" #元组中列表的值可以改变
print(t)
t[1] = "abc"
print(t) #元组的值不可以改变

输出

python
(1, 2, ['hello', 'world'])
Traceback (most recent call last):
  File "D:/pyspace/hellopython/HellloWorld.py", line 282, in <module>
    t[1] = "abc"
TypeError: 'tuple' object does not support item assignment

习题

1. 用负数步长对列表和元组进行分片

#用负数步长对列表和元组进行分片
number2 = list("123465")
print(number2)
#将列表的顺序变为123456
#number2[:-3:-1] = ["6","5"] #用分片赋值的方式实现
number2.sort(reverse=False) #用sort()函数实现
print(number2)
#输出5,3
print(number2[-2:-5:-2])
number2 = tuple(['1', '2', '3', '4', '5', '6'])
print(number2)
#输出5,3
print(number2[-2:-5:-2])

输出

['1', '2', '3', '4', '6', '5']
['1', '2', '3', '4', '5', '6']
['5', '3']
('1', '2', '3', '4', '5', '6')
('5', '3')

2.用索引取出下面list的指定元素

#打印出hello
field = [["hello", "world", "welcome"], ["study", "Python", "is", "funny"], ["good", "better", "best"]]
print(field[0][0])
#打印出Python
print(field[1][1])
#打印出best
print(field[2][2])

输出

hello
Python
best