Skr-Eric的Python课堂（六）——Python的列表介绍

列表 list

  问题:

    如何将计算机运算的数据临时保存在一个地方,同时又方便添加,删除和修改等操作

列表的定义:

  列表是一种容器

  列表是可以被改变的序列

  列表是由一系列特定元素组成的,元素与元素之间可能没有任何的关联关系,但他们之间有先后顺序关系

 

python3的中的序列类型:

  字符串 str

  列表 list

  元组 tuple

  字节串 bytes

  字节数组 bytearray

 

创建空列表的字面值表达式

  []  # 创建一个空列表

  L = []  变量L绑定一个新创建的空列表

 

创建非空的列表的字面值:

L = [1, 2, 3, 4]#L绑定一个新创建且含有四个元素的列表
L = ['Beijing', 'Shanghai', 'Shenzhen']
L = [1, 'Two', 3.14, '四']
L = [1, 2, [3.1, 3.2, 3.2], 4]  

 

列表的构造函数 list

  list()  生成一个空的列表,等同于 []

  list(iterable)  用可迭代对象创建一个列表

示例:

L = list()  # L = []
L = list("hello")  # L = ['h','e','l','l','o',]
L = list(range(5))  # L = [0, 1, 2, 3, 4]

 

列表的运算:

  算术运算:

    + += * *= (运算规则与字符串的运算规则相同)

 

+ 用于拼接列表,生成新的列表

x = [1, 2, 3]
y = [4, 5, 6]
z = x + y  # z = [1,2,3,4,5,6]

+= 用原列表与右侧可迭代对象追加来修改原列表

  语法:

     列表变量 += 可迭代对象

  示例:    

x = [1, 2, 3]
y = [4, 5, 6]
x += y  # x = [1, 2, 3, 4, 5, 6]
x += "ABC" # x = [1,2,3,4,5,6,'A','B','C']
x = [1, 2, 3]
x += range(4, 6)  # x = [1, 2, 3, 4, 5]
# += 是改变原来的列表对象,并不会创建新的列表
x = [1, 2, 3]
print(id(x))
x += [4, 5, 6]
print(id(x))

* 生成重复的列表

x = [1, 2] * 3  # x = [1,2,1,2,1,2]

*= 生成重复的列表,并改变对变量的绑定

x = [1, 2, 3]
x *= 4  # x = [1,2,3,1,2,3,1,2,3,1,2,3]

列表的比较运算:

  运算符:

    < <= > >= == !=

       比较规则与字符串的比较规则相同

 

  示例:   

[1,2,3] < [1, 2, 4]  # True
[1, 2, 3] < [3, 2, 1]  # True
[1, 2, 3] == [3, 2, 1]  # False
[2, 3] >= [1, 2, 3]  # True
[1, "2"] > ['2', 1]  # 报错
["ABC", 1, 2, 3] < ["123", 3, 2]  #

 

列表是可迭代对象

L = [1, 3, 5, 7]
for x in L:
    print(x)   # 1 3 5 7

 

列表的 in / not in 运算符

  判断一个值是否存在于列表中，如果存在返回True,否则返回 False

  同字符串的 in 运算符 用于检查一个值是否存在于列表中，如果存在返回True, 否则返回False

 

示例:

x = [1, 'Two', 3, '四']
3 in x  # 返回 True
'3' in x  # 返回 False
10 in x  # False
10 not in x  # True

 

列表的索引操作

  语法:

    列表[整数表达式]

  用法:

    与字符串索引的用法相同(分为正向索引和反向索引)

　示例:   

x = [1,3,5,7]
print(x[1])  # 3　　
print(x[-1])  # 7

 

列表的索引赋值:

  列表是可变的，可以通过索引赋值改变列表中的元素

  语法:

    列表[整数表达式] = 表达式

  作用:

    改变列表中索引的绑定关系

  示例:

x = [1, 2, 3, 4]    
x[2] = 3.14  # 改变了第三个元素的值

列表的切片

  列表[:]

  列表[::]

  列表的切片取值返回一个新的列表，规则等同于字符串切片规则

  示例:   

x = [1, 2, 3, 4, 5, 6, 7, 8]
x[::2]  # [1, 3, 5, 7]
y = [1::3]  # y = [2, 5, 8]

 

列表的切片赋值:

  作用:

    可以改变原列表的数据排列，可以插入和修改数据

    可以用切片改变列表的对应元素的值

  语法:

    列表[切片]　= 可迭代对象

　　说明:

    切片赋值的赋值运算符(=) 的右侧必须是一个可迭代对象

 示例:  

L = [2, 3, 4]
L[0:1] = [1.1, 2.2]  # L = [1.1, 2.2, 3, 4]
L[2:] = [3.3, 4.4, 5.5]  # L = [1.1, 2.2, 3.3, 4.4, 5.5]
L[:] = [3, 4] 　# L = [3, 4]
L[0:0] = [1, 2]  # L = [1, 2, 3, 4]
L = [3, 4]
L[1:1] = [3.14]  # L = [3, 3.14, 4]
L = [3, 4]
L[-1:-1] = [5, 6] # L = [3, 4, 5, 6]
L = [2, 3, 4]
L[1:2] = "ABC"  # L = [2, 'A', 'B', 'C', 4]
L = [2, -1, 7]
L[1:2] = range(3, 7)  # L=[2, 3, 4, 5, 6, 7]

切片的注意事项:

  对于步长不等于1的切片赋值,赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数

  示例:

L = [1, 2, 3, 4, 5, 6, 7, 8]
L[1::2] = "ABCD"  # 对的
L[1::2] = "ABCDEF"  # 错的

 

del 语句 用于删除列表的元素

  语法:

    del 列表[索引]

        如: del L[0]

    del 列表[切片]

        如: del L[1::2]

 

python 3中常用于序列的函数

  len(s)  返回序列的长度

  max(x)  返回序列的最大值元素

  min(x)  返回序列的最小值元素

  sum(x)  返回列中所有元素的和(元素必须是数值类型)

  any(x)  真值测试,如果列表中其中一个值为真值则返回True

  all(x)  真值测试,如果列表中所有值为真值返回True

 

示例: 

L = [3, 1, 9, 7, 5]
print(len(L))  # 5
print(max(L))  # 9
print(min(L))  # 1
print(sum(L))  # 25

 

深拷贝和浅拷贝

浅拷贝 shallow copy

  浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程

示例:

L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy()  # 浅拷贝
print(L1)  # [1, 2, [3.1, 3.2]]
print(L2)  # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1)  # [1, 2, [3.14, 3.2]]
print(L2)  # [1, 2, [3.14, 3.2]]

 

深拷贝 deep copy

  复制对象及对象关联的对象一起复制过程叫深拷贝

示例：

import copy  # 导入复制模块
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = copy.deepcopy(L1) 　# 深拷贝
print(L1)  # [1, 2, [3.1, 3.2]]
print(L2)  # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1)  # [1, 2, [3.1, 3.2]]　　<<< L1不变
print(L2)  # [1, 2, [3.14, 3.2]]

 

列表和字符串比较：

1. 都是序列，有先后顺序关系，有相同的运算操作

2. 列表是可变是，字符串是不可变的

3. 列表可以存任意类型的数据，字符串只能存字符

 

字符串的文本解析方法:

  S.split(sep=None) 将字符串，使用 sep作用分隔符分割S字符串，返回分割后的字符串列表，当不给定参数时，用空白字符作为分隔符分割

  S.join(iterable) 用可迭代对象中的字符串，返回一个中间用S进行分隔的字符串

 

示例:

s = 'Beijing is capital'
L = s.split(' ')  # L = ['hello', 'world', 'tarena']
s2 = "hello#world#tarena"
L = s2.split('#')  # L = ['hello', 'world', 'tarena']
L = ['aaa', 'bbbb', 'ccccc']
'$'.join(L) # 生成 'aaa$bbbb$ccccc'

 

列表推导式 list comprehension

  列表推导式是用可迭代对象创建列表的表达式

  作用:

    用简易方法生成列表

  语法:

    [表达式 for 变量 in 可迭代对象]

    或

    [表达式 for 变量 in 可迭代对象 if 真值表达式]

  示例:    

# 生成一个数值为1~9的平方的列表
# [1, 4, 9, 16, .... 81]
# 不用推导式:
L = []
for i in range(1, 10):
    L.append(i**2)
# 推导式实现
L = [i ** 2 for i in range(1, 10)]

 

用列表推导式生成 1~100以内奇数的列表

  结果是:[1, 3, 5, 7, ...., 99]

  答案:

    [i for i in range(1, 100, 2)]

    或

    [i for i in range(1, 100) if i % 2 == 1]

 

列表推导式的嵌套

  语法:

    [表达式

      for 变量1 in 可迭代对象1 if真值表达式1

        for 变量2 in 可迭代对象2 if 真值表达式2 ...]

 

  示例:    

#将列表[10, 20, 30] 中的元素与列表[1,2,3]元素分别相加,将得到的元素放于一个列表中

L = [x + y
          for x in [10, 20, 30]
            for y in [1,2,3]]
print(L)  #[11, 12, 13, 21, 22, 23, 31,32,33]

课后习题:

1. 有一些数存在列表中, 如: L = [1, 3, 2, 1, 6, 4, 2, ...., 98, 82] 1) 将列表L中出现的数字存于另一个列表L2中 要求: 重复出现多次的数字只在L2列表中保留一份(去重) 2) 将列表中出现两次的数字存于L3列表中(在L3列表中保留一份)
2.  计算出100以内的素数,将这些素数存于列表中,最后打印出列表中的这些素数
3. 生成前40个斐波那契数(Fibonacci) 1 1 2 3 5 8 13 21 ...... 要求将这数整数存于列表L中,最后打印出这些数 (斐波那契的前两个是1, 1, 之后的数是前两个数的和)

 

想要看更多的课程请微信关注SkrEric的编程课堂