python之列表

1.概述

线性的数据结构

有序的队列，可以使用下标进行索引

可变的序列

列表中的个体称为元素，多个元素组成列表

列表的语法是[],多个元素使用逗号分隔

列表中的元素类型可以不同

2.定义列表

 使用【】方法，多个元素之间使用逗号进行分隔

使用list()函数

可以将元组、字符串、range对象所有迭代的数据结构转换为列表

3.删除列表

使用del删除

删除之后会抛出异常

 4.访问列表

1.访问元素

列表[下标]

2.修改元素

列表[下标] = 赋的值

3.len()获取列表的长度

用法：len(列表对象)

4.count()统计指定元素出现的次数

用法： 列表对象.count()  

5.index()  指定元素的下标索引值

用法： 列表对象.index() 

语法格式：index（元素值：起点：终点）

5.遍历列表

 对列表中的每一个元素执行一次访问

1.while 语句

语法格式

i =0 

while i < len(列表对象)：

        代码块处理

        i += 1

使用whlie()遍历，将小写字母转换为大写字母

l = ["p","y","t","h","o","n"]
i = 0
while i < len(l):
    #遍历列表l的每一个元素
    l[i] = l[i].upper()
    i += 1
print(l)

2.for 语句（如果两个值相同，则遍历的是第一个）

语句格式

for  i  in  列表对象：

        代码块

使用for()遍历，将小写字母转换为大写字母

l = ["p","y","t","h","o","n"]
for i in l:
    l[l.index(i)] = i.upper()
print(l)

3.enumerate()

可以将一个可迭代的对象组合为一个索引的对象

语法格式：

enumerate(列表对象，起点)

l = ["p","y","t","t","o","n"]
for index,value in enumerate(l):
    print(index,value)
    l[index] = value.upper()
print(l)

6.添加元素

1.append()

可以在当前列表对象尾部添加元素，仅修改原列表对象。

语法格式：

        列表对象.append(obj)

l = [1,2,3,4,5,6,7]
l.append(89)
print(l)

2.extend()

可以在当前列表对象的尾部添加一个可迭代的列表对象，仅修改原来的列表对象

语法格式：

        列表对象.extend(obj)

l1 = [1,2,3,4,5,6,7]
l2 = [5,56,7,8,9,10]
l1.extend(l2)
print(l1)

3.insert()

可以在当前列表对象的指定下标位置插入对象，仅修改原来的列表对象

语法格式：

        列表对象.insert(index,obj)

l1 = [1,2,3,4,5,6,7]
print(id(l1))
l1.insert(4,666)
print(id(l1))
print(l1)

注：

如果insert（）超出索引范围，不会触发异常。

如果是正索引，超出索引范围，等价于append()

如果是负索引，超出索引范围，等价于insert(0,obj)

4.+运算符

合并列表，产生新的列表对象

l1 = [1,2,3,4,5,6,7]
l2 = [2,3,4,5,6,8,9,8,9]
print(l1+l2)

5.*运算符

重复列表并合并，产生新的列表对象

7.删除元素

1.del语句

语法格式

        del  列表对象[下标]

删除第四位数

l1 = [1,2,3,4,5,6,7]
del l1[3]
print(l1)

2.pop语句

可以删除指定位置的元素，并返回删除后的结果

可在原列表对象进行操作

语法格式：

        删除的元素=列表对象.pop(下标)   下标默认为-1

l1 = [1,2,3,4,5,6,7]
n = l1.pop(2)
print(l1)
print(n)

3.remove语句

可以删除指定值的元素，在原列表对象进行操作

语法格式

        列表对象.remove(元素的值)

删除列表中首次出现的那个值的元素，如果删除列表中不存在值的元素，则抛出异常

删掉值为三的元素

l1 = [1,2,3,3,3,34,5,6,7]
for i in l1:
    if 3 == i:
        l1.remove(i)
print(l1)

当出现多个值相同时会出错

可以使用切片的方法避免这个问题

8.检测元素

in      not  in 

过滤元素是否在列表中，如果不在则添加到列表中

l1 = [1,2,3,4,5,6,7]
l2 = []
for  i in l1:
    if i not in l2:
        l2.append(i)
print(l2)

9.切片操作

基本语法：

[起点：终点：步长]

切片赋值，只能通过序列，否则会抛出异常

1.使用切片读取元素

返回所有元素的新列表

l = list(range(10))
print(l)
#返回包含所有元素的新列表
print(l[::])

反序读取所有元素

l = list(range(10))
print(l)
print(l[::-1])

读取偶数位元素（步长为2）

l = list(range(10))
print(l)
print(l[::2])

读取奇数位元素（第二个元素开始，步长为2）

l = list(range(10))
print(l)
print(l[1::2])

读取从下标三开始的所有元素

l = list(range(10))
print(l)
print(l[3::])

读取下标三到六之间所有的元素

l = list(range(10))
print(l)
print(l[3:6])

读取前一百个数

l = list(range(10))
print(l)
print(l[0:100:1])

读取100之后的元素

l = list(range(10))
print(l)
print(l[100::])

2.使用切片修改列表

在尾部追加元素

l = list(range(10))
print(l)
l[len(l):] = [3]

替换前三个元素

l = list(range(10))
print(l)
l[:3] = [1,2,3]
print(l)

删除前三个元素

l = list(range(10))
print(l)
l[:3] = []
print(l)

使用0替换偶数位元素

l = list(range(10))
print(l)
l[::2] = [0]*5
print(l)

3.使用切片删除元素

删除前三位元素

l = list(range(10))
print(l)
del l[:3]
print(l)

10.复制列表

使用切片生成新的列表副本，副本与原列表值相同，但是地址不同

包含浅复制和深复制

浅复制：生成一个新的列表，并把原列表的值复制给新的列表

深复制：使用copy模块

浅复制

import copy
x = [1,12,[3,4]]
y = copy.copy(x)
x[0] = 3
print(x)
print(y)
x[2].append(9)
print(x)
print(y)

深复制

import copy
x = [1,12,[3,4]]
y = copy.deepcopy(x)
x[0] = 3
print(x)
print(y)
x[2].append(9)
print(x)
print(y)

11.打包和解包

打包的语法格式：

        zip(一个或多个迭代对象)

解包的语法格式：

        zip(*zip对象)

把ab两个列表打包为一个zip对象，使用list()函数转换列表，在显示出来

如果可迭代对象的个数不一致时，返回zip对象的长度与最短的对象相同

把ab两个列表打包为一个zip对象，使用zip(*)函数解包显示

12.列表排序

reverse()

列表对象的方法

反向排列列表对象的元素

没有参数，没有返回值，作用于原列表对象，改变原列表对象的排序

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

也可以用切片来表示

a = [1,2,3,4,5,6]
b = a[::-1]
print(b)

renersed()

python的内置函数

反向排列可迭代对象的元素

包含一个参数：可迭代对象，返回一个顺序反转的反转对象

a = "python"
b = reversed(a)
print(list(b))

sort（）

列表对象的方法

根据指定的关键字对列表进行排序

语法格式：

         列表对象.sort(key=None,reverse=False)

可以不传递参数，默认按升序排序，没有返回值，改变原序列对象的排序

sorted（）

python内置函数

根据指定的关键字对可迭代对象进行排序

语法格式：

        sorted(可迭代对象，key=none,reverse=false)

必须包含一个参数：可迭代的对象，返回一个排序后的列表对象

(key  键值，定义比较函数。reverse  排序规则，false是降序，true是升序)

a = [1,2,3,4,5,6]
b = sorted(a,key=lambda x:-x)
print(b)

例子1：把一个句子中每一个单词分开为一个列表，然后以小写字母形式进行排序

a = "This  is  a  test  string"
b = sorted(a.split())
c = sorted(a.split(), key=str.lower)
print(b)
print(c)

例子二：学生的成绩单，分为姓名、年级、成绩，对成绩进行降序排列和对年级进行升序排列

a = ["zhangsan","lisi","wangwu"]
b = [1,3,2]
c =[95,99,89]
d = zip(a,b,c)
print(d)
e = list(d)
print(e)
#对成绩进行降序排列
f = sorted(e,key=lambda t:t[2],reverse=True)
print(f)
#对年级进行升序排列
g = sorted(e,key=lambda t:t[1],reverse=False)
print(g)

13.列表推导式

也称列表解析式

推导式可以从一个序列推导出一个新的序列，包括：列表推导式、字典推导式、集合推导式

列表推导式的语法：

        [表达式  for 临时变量  in  列表变量 ]

        [表达式  for 临时变量  in  列表变量   if过滤条件]

例一：使用range()函数生成一个10以内数字的列表，根据这个列表推导出新列表b,b中的每个元素都是a的二倍

a = range(1,10)
b = [i*2 for i in a]
print(b)

例二：使用range()函数生成一个10以内数字的列表，根据这个列表推导出新列表b,b中的元素只有值为偶数的可以乘二

a = range(1,10)
b = [i*2 for i in a if i%2==0]
print(b)

列表推导式也可以嵌套使用

语法格式：

        [表达式  for  临时变量1  in 列表对象   for  临时变量2  in  临时变量1]

结构化表示：

        for  临时变量1  in 列表对象

        for  临时变量2  in 临时变量1

a = [[1,2,3],[4,5,6],[7,8,9]]
b = [i for n in a for i in n]
print(b)