学习笔记☞python 基础☞列表（python3）

列表(list)：

列表的定义：

    列表是由一系列元素组成的，元素与元素之间可能没有任何的关联关系，但他们之间有先后顺序关系
    列表是一种容器
    列表是一种序列
    列表是可以被改变的序列    

创建空列表的字面值：

L = []    #L绑定空列表

创建非空列表的字面值：

L = [1, 2, 3, 4]
L = ['beijing', 'shanghai', 'shenzhen']
L = [1, 'two', 3.3, '四']
L = [1, 2, [3.1, 3.2, 3.3], 4]

列表的构造函数

    函数                 说明
    list()             # 生成一个空的列表 等同于[]
    list(iterable)     # 用可迭代对象创建一个列表   
示例：

>>> list()
[]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

列表的运算：

    运算符：

        + += * *=      

    + 用于拼接列表

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

    += 用原列表与右侧列表拼接，并用变量绑定新列表

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

    * 生成重复的列表       

x = [1, 2] * 3    #x=[1, 2, 1, 2, 1, 2]
y = 3 * [5, 6]    #y=[5, 6, 5, 6, 5, 6] 

    *= 生成重复的列表，并给原变量赋值       

x = [3, 4]
x *= 2            #x=[3, 4, 3, 4]
y = 3
y *= [7, 8]        #y=[7, 8, 7, 8, 7, 8]        

列表的比较运算：

    运算符：
        < <= > >= == !=
    示例：

[1, 2, 3] < [1, 2, 4]            #True
[1, 3] > [1, 2, 4]                #True
[5] < [5, 0]                    #True
['ABC', '123'] > ['abc', '456']    #False
[1, 'two'] > ['two', 1]            #报错 

列表的in / not in运算符

    in 判断一个对象是否存在于容器内,如果存在返回True,否则返回False
    用法同字符串in相同
    语法:
        数据对象 in 容器
    示例:

L = [1, 'Two', 3.3, '四']
1 in L    # True
2 in L    # False
3.3 in L  # ???
'4' in L  # True

列表的索引:

    语法:
        列表[整数表达式]
    用法:
        取值时,等同于字符串的索引操作
        索引分为正向索引和反向索引,规则与字符串索引规则完全相同

    列表的索引赋值

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

>>> L = [1, 2, 3, 4]
>>> L[2] = 3.3	#将第三个元素改为3.3
>>> L
[1, 2, 3.3, 4]

列表的切片

     语法:
         列表[:]
         列表[::]
         列表的切片取值时,返回一个列表,规则等同于字符串切片规则

    列表的切片赋值:

         作用:
             可以改变原列表的排序,可以插入和修改数据
             可以用切片改变列表的对应元素的值
         语法:
             列表[切片] = 可迭代对象
             注:赋值运算符的右侧必须是一个可迭代对象
         示例:

>>> L = [2, 3, 4]
>>> L[0:1] = [1.1, 2.2]
>>> L
[1.1, 2.2, 3, 4]

>>> L = [2, 3, 4]
>>> L[1:] = [3.3, 4.4, 5.5]
>>> L
[2, 3.3, 4.4, 5.5]

>>> L = [2, 3, 4]
>>> L[:] = [0, 1]
>>> L
[0, 1]

>>> L = [2, 4]
>>> L[1:1] = [3]
>>> L
[2, 3, 4]

>>> L = [2, 4]  # 实现在中间插入[3.1, 3.2]
>>> L[1:1] = [3.1, 3.2]
>>> L
>>> [2, 3.1, 3.2, 4]

>>> L = [2, 3, 4]  # 实现在前面插入0, 1]
>>> L[0:0] = [0, 1]
>>> L
>>> [0, 1, 2, 3, 4]

>>> L = [2, 3, 4]  # 实现在后面插入0, 1]
>>> L[3:3] = [5, 6]
>>> L
>>> [2, 3, 4, 5, 6]

>>> L = [1, 4]  # 用range函数生成的可迭代对象赋值
>>> L[1:1] = range(2, 4)  #
>>> L
>>> [1, 2, 3, 4]

>>> L = [2, 3, 4]
>>> L = [1:2]='ABCD'  # 'ABCD'也是可迭代对象
>>> L
>>> [2, 3, 'ABCD']

    切片赋值的注意事项:

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

L = [1, 2, 3, 4, 5, 6]
L[::2] = 'ABC'  # 对的
# 以下切除三段,但给出5个元素填充是错的
L[::2] = 'ABCDE'

python3常用于序列的函数:

    len(seq)        返回容器的元素个数
    max(x)            返回序列的最大值元素
    min(x)            返回序列的最小值元素
    sum(x)            返回序列中所有元素的和(元素必须为数值类型)
    any(x)            真值测试,如果容器内其中一个值为True则返回True,否则返回False
    all(x)            真值测试,容器内所有元素的布尔值为True才返回True

python3 中常用的列表的方法(method)   

方法	意义
L.index(v [, begin[, end]])	返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误
L.insert(index, obj)	将某个元素插放到列表中指定的位置
L.count(x)	返回列表中元素的个数
L.remove(x)	从列表中删除第一次出现在列表中的值
L.copy()	复制此列表（只复制一层，不会复制深层对象)
L.append(x)	向列表中追加单个元素
L.extend(lst)	向列表追加另一个列表
L.clear()	清空列表,等同于 L[:] = []
L.sort(reverse=False)	将列表中的元素进行排序，默认顺序按值的小到大的顺序排列
L.reverse()	列表的反转，用来改变原列表的先后顺序
L.pop([index])	删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系

浅拷贝 shallow copy 和 深拷贝 deep copy

浅拷贝:

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

    示例:

L = [3.1, 3.2]
L1 = [1, 2, L]  # [1, 2, [3.1, 3.2]]
L2 = L1.copy()  # [1, 2, [3.1, 3.2]] 浅拷贝
L[0] = 3.14
L1  # [1, 2, [3.14, 3.2]]
L2  # [1, 2, [3.14, 3.2]]  # L1和L2共同拥有L绑定的对象

深拷贝:

    示例：

import copy  # 导入copy模块

L = [3.1, 3.2]
L1 = [1, 2, L]  # [1, 2, [3.1, 3.2]]
L2 = copy.deepcopy(L1)  # [1, 2, [3.1, 3.2]] 深拷贝
L[0] = 3.14
L1  # [1, 2, [3.14, 3.2]]
L2  # [1, 2, [3.1, 3.2]] 此列表不受影响

注:深拷贝通常只对可变对象进行深层复制,不可变对象通常不会被复制

理解:

L1 = [1, 2, [3.1, 3.2]]
L2 = L1  # 会发生什么
L3 = L1.copy  # 会发生什么
L4 = copy.deepcopy(L1)  # 会发生什么
问题:
    如何把L1里的3.1改为3.14
    L1[2][0] = 3.14

列表与字符串比较:

    1、列表和字符串都是序列,元素之间有先后关系
    2、字符串是不可变的序列,而列表是可变的序列
    3、字符串中每个元素只能存储字符,而列表可以存储任意类型的元素
    4、列表和字符串都是可迭代对象

字符串文本解析方法 split 和 join

    s.split(sep=None)        

        将字符串使用sep作为分隔符分割s字符串，返回分割后的字符串列表，当不给定参数时，用空白字符作为分隔符分割

    s.join(iterable)

        用可迭代对象中的字符串，返回一个中间用s进行分割的字符串
   

示例split：
>>> s = 'Beijing is capital'
>>> l = s.split(' ')  
>>> l
['Beijing', 'is','capital']

示例join:
>>> l = ['C:', 'Programe files', 'Python3']
>>> s = '\\'.join(l)
>>> s
'C:\\Programe files\\Python3'

列表推导式(list comprehension)：

    列表推导式是用可迭代对象一次生成带有多个元素的列表的表达式
    作用：
        用简易方法生成列表
    语法：
        [表达式 for 变量 in 可迭代对象]
        或
        [表达式 for 变量 in 可迭代对象 if 真值表达式]

'''
问题：
    如何生成下列列表？
    [1, 4, 9, 16, 25, ……, 81]
'''
l = []
for i in range(1, 10):
    l.append(i ** 2)

    # 用列表推导式生成：
    l = [i ** 2 for i in range(1, 10)]

示例：

'''
生成[1,9,25,49,81]列表，跳过所有的偶数
'''

l = [x ** 2 for x in range(1, 10) if x % 2 == 1]

列表推导式的嵌套：

    语法：    
        [表达式1
            for 变量1 in 可迭代对象1 if 真值表达式1
                for 变量2 in 可迭代对象2 if 真值表达式2]
    示例：

'''
想生成
['a1', 'a2', 'a3','b1', 'b2', 'b3','c1', 'c2', 'c3',]
'''
l = [x + y for x in 'abc' for y in '123']