Python基础内容训练3（常用的数据类型-----列表）

列表的操作

一 概念
列表是有序的可变的元素集合，字符串不能变

二 定义

方式1：【元素1，元素2…】
[name1,name2…]

列表是可以嵌套的

items = [12,121,]
name = [1,2,3,'zi',True,items]
print(name,type(name))
1
2
3

方式2 ：列表生成式
让你创建一个列表，1-99，不可能从1输入到99
python3进行了修改，不会直接生成列表为了节省空间


方式2 ：列表推导式
从一个列表推导出另一个列表

案例1.获取列表中的每个元素的平方，再次组成一个新的列表

以前的做法
nums = [1,2,3,4,5,6,7,8,9,10]
items = []
for num in nums:
    # print(num)
    # continue:
    num1 = num ** 2
    # print(num1)
    items.append(num1)
print(items)
1
2
3
4
5
6
7
8
9
10

案例2 ：获取奇数元素的平方形成一个新的列表

nums = [1,2,3,4,5,6,7,8,9,10]
items = []
for num in nums:
    if num % 2 != 0: #代表是奇数才进行平方操作
        # print(num)
        # continue:
        num1 = num ** 2
        # print(num1)
        items.append(num1)
print(items)
1
2
3
4
5
6
7
8
9
10

或者下面这个写法

nums = [1,2,3,4,5,6,7,8,9,10]
items = []
for num in nums:
    if num % 2 == 0: ##代表是奇数才进行平方操作
        continue
    # print(num)
    # continue:
    num1 = num ** 2
    # print(num1)
    items.append(num1)
print(items)
1
2
3
4
5
6
7
8
9
10
11

而用了列表推导式的写法如下：

案例1：输出每个元素的平方

nums = [1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10]
items = [num1 **2 for num1 in nums]
print(items)

1
2
3
4

案例2：

nums = [1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10]
items = [num1 **2 for num1 in nums if num1 % 2 != 0]
print(items)

1
2
3
4

三 列表的常用操作
主要包括：增删改查和一些额外的操作

增加操作

• append：在列表中，追加一个新的元素，在列表的最后面
• 语法：list.append.(objecr)
• 返回值;None，没有返回值
• 会修改原来列表的

num = [1,2,3,4,5]
print(num)
num.append(6)
print(num)
print(num.append(6))
1
2
3
4
5

• insert：在指定的位置插入一个元素，可以在任意位置插入，但是只能在指定索引的前面
• 语法：list.insert（index，object） index是指定的索引位置

num = [1,2,3,4,5]
print(num)

num.insert(0,6)
print(num)

num1 = [1,2,3,4,5]
num1.insert(1,6)
print(num1)


num2 = [1,2,3,4,5]  #这个虽然索引6已经没了，但是在索引6前面插入一个元素还是成立
num2.insert(6,6)
print(num2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• extend：在列表的后面追加一个可迭代对象（可以用for循环遍历的，如字符串列表元组等）
• 语法：list.extend(iterable)

num = [1,2,3,4,5]
print(num)
num1 = ['a','b','c']
num.extend(num1)
print(num)
1
2
3
4
5

• 乘法运算

num = [1,2]
print(num * 3)

1
2
3

• 加法运算
• 和extend的区别就是只能列表和列表相加；并且extend会改变列表的内容

num = [1,2,3]
num1 = ['a','b','c']
print(num + num1)

item = [1,2,3]
items = 'abcdef' #把字符串添加进列表
item.extend(items)
print(item)
1
2
3
4
5
6
7
8

删除操作

• del语句：可以删除一个指定元素，也可以删除整个列表
• del 指定元素

num = [1,2,3]
del num[0]
print(num)

del num
print(num)

1
2
3
4
5
6
7

num没定义就是num已经没了

• pop：移除并且返回指定元素
• list.pop(index=-1)：括号里面是指定的索引，默认是-1

num = [1,2,3,4,5]
result = num.pop()
print(result)
print(num)
nums = [1,2,3]
result1 = nums.pop(1)
print(result1)
print(nums)

1
2
3
4
5
6
7
8
9

• remove:删除指定元素
• list.remove(元素)：不再是根据索引删除了，返回值是None，并且如果元素不存在列表中会报错；如果元素存在多个，那么会删除最左边的相同元素
• 并且注意循环内删除列表元素带来的坑

num = [1,2,3,4]
num.remove(2)
print(num)
1
2
3

利用循环进行remove操作的时候

nums = [1,2,2,2,3,4,2]
for num in nums:
    if num == 2:
        nums.remove(2)
print(nums)
1
2
3
4
5

循环的时候始终删除最左边的2，所以说删除一个最左边的2之后，右边的开始往前移动，这时候指针在3的地方了，但是前面还有一个2没有移除，直到指针到了最后的位置，删除最左边的一个2，只剩下最右边的2了。

修改操作

找到指定的索引的值，直接赋值覆盖即可

num = [1,2,3,4,5]
num[1] = 6
print(num)
nums = [1,2,3,4,5]
nums[-1] = 6
print(nums)
1
2
3
4
5
6

查询操作

• 获取单个元素：list[index] 要注意负索引

num = range(10)
print(num[5])
num1 = [2,3,4,5]
print(num1[2])
1
2
3
4

• 获取元素索引
• list.index(要查找的元素，开始区间，结束区间):从左到右查找，查找到就立马结束了，所以有两个相同的元素的时候，会选择最左边的元素的索引

num = [1,2,3,4,1,2,3,9]
id = num.index(9)
id1 = num.index(2)
id2 = num.index(2,2,7)
print(id,id1,id2)

1
2
3
4
5
6

• 获取指定元素个数
• list.count(元素)

num = [1,2,3,4,1,2,3,9]
a = num.count(2)
print(a)

1
2
3
4

• 获取多个元素：切片操作
• list[start：end：step]

num = [1,2,3,4,2,4,16,8]
print(num[::])
print(num[::-1])
print(num[1:4:])
print(num[1:4:2])

1
2
3
4
5
6

遍历操作

• 方式一：根据元素进行遍历
• for num in nums
• print（num）

num = [1,2,3,4,5]
for i in num:
    print(i)
#我们还想要把对应的索引给输出
nums = [2,3,2,4]
for n in nums:
    print(n)
    print(nums.index(n))
1
2
3
4
5
6
7
8

我们看到当有相同的元素的时候，索引只会取最左边的一个，和字符串一样的道理

因为索引可以设置开始和结束的位置，所以我们可以给index获取开始位置，每次开始位置加一就可以不只是只取最左侧的了

nums = [2,3,2,4]
count = 0
for n in nums:
    print(n)
    print(nums.index(n,count))
    count +=1

1
2
3
4
5
6
7

• 方式二：根据索引开始遍历
• for index in range(len(list))
• print(index,list(index))

num = ['a','b','c','d','e']
#1. 造一个索引列表（我们要查询的，要遍历的索引列表）
for n in range(len(num)):
    print(n,num[n])
#2. 遍历整个的索引列表，每一个索引对应一个列表的元素

1
2
3
4
5
6

• 方式三：遍历一个枚举对象来间接的遍历一个整个列表
• 枚举对象：通过一个枚举函数生成的一个新的对象
• 作用：可以将一个可遍历的数据对象（列表元组字符串）组合成一个索引序列
• 索引序列就是指同时列出数据下标和数据（是个元组）
• 语法：enumerate(sequece,start=0) 一个序列、迭代器或者其他支持迭代的对象，start–下表起始位置

value = ['a','b','c','d','e']
#1. 先根据列表创建一个枚举对象
print(list(enumerate(value)))
1
2
3

value = ['a','b','c','d','e']
#1. 先根据列表创建一个枚举对象
print(list(enumerate(value)))
#遍历整个的枚举对象（枚举对象，可以直接被遍历）
for idx, val in enumerate(value):
    print(idx,val)
1
2
3
4
5
6

索引对象从1开始

• 方式四：使用迭代器进行遍历
  那么下面先介绍一下迭代的相关内容
  

迭代

• 迭代概念：是访问集合元素的一种方式，按照某种顺序逐个访问集合中的每一项（或者遍历？）
• 可迭代对象：能够被迭代的对象，称为可迭代对象，判断依据：能作用于for in循环，
• 判定方法：import collections, isinstance(obj,collections.Iterable)

num = [1,2,3]
import collections
result = isinstance(num,collections.Iterable)
print(result)

1
2
3
4
5
6

• 迭代器：是指可以记录遍历位置的对象，本质是一个对象，但是他有一些特性，比如说从第一个元素开始，往后通过next()函数，进行遍历，只能往后，不能往前
• 判断依据：能作用于next()函数
• 判定方法：import collections;isinstance(obj,collections.Iterator)

迭代器和迭代对象是相关联的，对于一个列表来说它是一个迭代对象，迭代器一开始在这个列表的最前面，当迭代去调用next函数的时候，迭代器会依次往下迭代
迭代器也是可迭代对象，所以也可以作用于for in循环

注意：Python3.9以后的版本这里改了

为什么要用迭代器呢？

1. 仅仅在迭代到某一个元素的时候才处理该元素，在此之前这个元素可以不存在，再次之后元素可以被销毁，特别适用于遍历一些巨大的或者是无限大的集合，比如斐波那契数列（任意一个数是前面两个数的和）节省内存
2. 提供了一个统一的访问集合的接口，可以把所有的可迭代对象，转换成迭代器反复使用
   iter(Iterable):里面填可迭代对象即可，因为list，字符串等遍历的方式不同，用迭代器可以统一起来

迭代器简单使用：使用next（）函数，从迭代器中取出下一个对象，从第一个元素开始

num = [1,2,3,4]
l = iter(num)
print(next(l))
print(next(l))
print(next(l))
print(next(l))
1
2
3
4
5
6

因为迭代器比较常用，所以在python中，可以直接作用于for in，内部会自动调用迭代器对象的next()，会自动处理迭代完毕的错误

注意事项：迭代器一版不能多次迭代，只能使用一次

num = [1,2,3,4]
l = iter(num)
for i in l:
    print(i)
print('------------')
for i in l:
    print(i)
1
2
3
4
5
6
7

常用操作：判定和比较

• 判定：某某元素是否在列表中

num = [1,2,3,4,5]
print(1 in num)
print(12 in num)
1
2
3

• 比较操作

• cmp()：内建函数，如果比较的是列表，则针对每个元素从左到右逐一比较（但是3以后不支持用下面的大于号小于号即可）

• 如果左>右 ----- 1，左==右— 0，左<右------ -1

列表的排序操作

• 方法一：内建函数，可以对所有可迭代对象进行排序
• 语法：sorted(可迭代对象，key=none，reverse=false)
• key是排序关键字，值为一个函数，次函数只有一个参数并且返回一个值用来比较
• reverse是反转的意思，表示用来控制升序还是降序，默认 是false升序
• 返回值：是一个已经排序好的列表

num = [1,3,6,2,8]
result = sorted(num)
result1 = sorted(num,reverse=True)
print(result)
print(result1)
1
2
3
4
5

对于下面这个列表里面的元组进行排序，我们可以看到是根据元素的第一个key进行排序的，如果想根据value进行排序我们就要改sorted的key

s = [('sz1',15),('sz',19),('sz3',18),('sz2',17)]
result = sorted(s)
print(result)
1
2
3

s = [('sz1',15),('sz',19),('sz3',18),('sz2',17)]

def getKey(x): #定义一个函数，讲列表里面的元组拿下来，并且返回value
    return x[1]

result = sorted(s,key=getKey) #讲value传进去，按照value进行排序
print(result)
1
2
3
4
5
6
7

• 方式二：列表对象方法
• list.sort(key=None,reverse=False) 这两个参数是可选的
• key和上面一样，是一个函数要自己进行定义，此函数只有一个参数并且返回一个值用来进行比较
• reverse是控制升序降序的，默认是升序False
• 返回值是None，并且把原本的列表给改变了

num = [1,2,5,3,4]
result = num.sort()
print(result)
print(num)
1
2
3
4

s = [('sz1',15),('sz',19),('sz3',18),('sz2',17)]
result = s.sort()
print(s)
1
2
3

s = [('sz1',15),('sz',19),('sz3',18),('sz2',17)]

def getKey(x):
    return x[1]
result = s.sort(key=getKey) #这里getKey不要加小括号，小括号是调用
print(s)
1
2
3
4
5
6

那么我们可以看出来方法一和方法二的区别：方法一是内建函数，可以对任何可迭代对象进行操作，而方法二是列表方法，只能针对于列表操作；方法一不会改变原列表或者原来的可迭代对象；而方法二则会改变原来的列表

• 列表的乱序及反转
• 乱序：把整个列表的元素随机打乱
• 导入random，用random的shuffle函数即可 （注意：会直接改变列表本身）

import random
l = [1,2,3,4,5]
random.shuffle(l)
print(l)
1
2
3
4
5

• 反转：指把整个列表的元素反转过来
• list.reverse() （也会改变原列表）
• 或者用切片反转list[::-1]

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