三、python数据序列1-列表

一. 列表的格式

[数据1, 数据2, 数据3, 数据4......]

列表可以一次性存储多个数据，且可以为不同数据类型。

二. 列表的常用操作

列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。

2.1 查找

2.1.1 下标

name_list = ['python', 'c++', 'java']
print(name_list[0])  # python
print(name_list[1])  # c++
print(name_list[2])  # java

list1 = ['蜘蛛侠', '环太平洋', '海王', '复仇者联盟']
print(list1[2], list1[-2])
# 正向下标，从0开始
# 负向下标,从-1开始

2.1.2 函数

• index()：返回指定数据所在位置的下标 。

1. 语法

列表序列.index(数据, 开始位置下标, 结束位置下标)

2. 快速体验

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2))  # 1

注意：如果查找的数据不存在则报错。

• count()：统计指定数据在当前列表中出现的次数。

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily'))  # 1

• len()：访问列表长度，即列表中数据的个数。

name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list))  # 3

• sum()，对列表求和，sum(list)
• max()，求最大值，列表里面必须是同类型。max(list)
• min()，求最小值。

2.1.3 判断是否存在

• in：判断指定数据在某个列表序列，如果在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)

• not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)

• 体验案例

需求：查找用户输入的名字是否已经存在。

name_list = ['Tom', 'Lily', 'Rose']

name = input('请输入您要搜索的名字：')

if name in name_list:
    print(f'您输入的名字是{name}, 名字已经存在')
else:
    print(f'您输入的名字是{name}, 名字不存在')

2.2 增加

作用：增加指定数据到列表中。

• append()：列表结尾追加数据。

1. 语法

列表序列.append(数据)

2. 体验

list1 = ['python', 'c++', 'java']
list1.append('go')
print(list1)

运行结果：

D:\ProjectSoftware\anacode\python.exe D:/ProjectFile/千峰/02-day/class.py
['python', 'c++', 'java', 'go']

进程已结束,退出代码0

列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。

3. 注意点

如果append()追加的数据是一个序列，则追加整个序列到列表

list1 = ['python', 'c++', 'java']
list1.append(['go','HTML'])
print(list1)

#运行结果：['python', 'c++', 'java', ['go', 'HTML']]

• extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。

1. 语法

列表序列.extend(数据)

2. 快速体验

   2.1 单个数据

name_list = ['Tom', 'Lily', 'Rose']

name_list.extend('xiaoming')

# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)

​ 2.2 序列数据

list1 = ['python', 'c++', 'java']
list1.extend(['go','HTML'])
print(list1)
# 运行结果：['python', 'c++', 'java', 'go', 'HTML']

• insert()：指定位置新增数据。

1. 语法

列表序列.insert(位置下标, 数据)

2. 快速体验

list1 = ['python', 'c++', 'java']
list1.insert(0,'go')
print(list1)

2.3 删除

• del

1. 语法

del 目标

2. 快速体验

   2.1 删除列表

list1 = ['python', 'c++', 'java']
# 结果：报错提示：name 'name_list' is not defined
del list1
print(list1)

​ 2.2 删除指定数据

list1 = ['python', 'c++', 'java']
del list1[0]
print(list1)

• pop()：删除指定下标的数据(默认为最后一个)，并返回该数据。

1. 语法

列表序列.pop(下标)

2. 快速体验

list1 = ['python', 'c++', 'java']
del_list = list1.pop(1)
print(del_list)
print(list1)

'''
运行结果：
c++
['python', 'java']
''' 

• remove()：移除列表中某个数据的第一个匹配项。

1. 语法

列表序列.remove(数据)

2. 快速体验

list1 = ['python', 'c++', 'java','python']
list1.remove('python')
print(list1)

# 运行结果：['c++', 'java', 'python']

• clear()：清空列表

list1 = ['python', 'c++', 'java','python']
list1.clear()
print(list1)

# []

2.4 修改

• 修改指定下标数据

list1 = ['python', 'c++', 'java','python']
list1[0]='CSS'
print(list1)

# ['CSS', 'c++', 'java', 'python']

• 逆置：reverse()

num_list = [1, 5, 2, 3, 6, 8]

num_list.reverse()

# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)

• 排序：sort()

1. 语法

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

注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

2. 快速体验

num_list = [1, 5, 2, 3, 6, 8]

num_list.sort()

# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)

• 排序：sorted()

1. 语法

sorted(列表,revers = False)

sorted()不会修改原列表，而会创建一个新列表

2.5 复制

函数：copy()

name_list = ['Tom', 'Lily', 'Rose']

name_li2 = name_list.copy()

# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)

2.6 切片

变量[M:N:step]
M：起始范围（不写M，默认从头开始取）
N：结束范围（不写，默认取到尾）
step：步长（step=1，可以不写）

• 左闭右开区间，从原来的容器中提取元素组成新的容器.切片可以越界。

• 起始范围和结束范围不写的时候，冒号必须存在；步长不写时，冒号不用写。

• 步长控制获取的元素，每间隔步长-1个元素获取一个元素（获取的当前元素+步长=下一个要获取的元素）

• M和N必须同符号时：step>0，MN。

• 正向下标和负向下标可以组合使用

movies = ['阿甘正传', '肖申克的救赎', '霸王别姬', '三傻大闹宝莱坞', '环太平洋', '猿人泰山']
# 练习：
# a.获取['阿甘正传'、'霸王别姬'、'环太平洋']
print(movies[:5:2])
print(movies[:-1:2])
print(movies[::2])
# b.获取['肖申克的救赎'、'环太平洋']
print(movies[1:5:3])
print(movies[1:-1:3])
print(movies[1::3])
# c.获取['环太平洋'、'霸王别姬'、'阿甘正传']
print(movies[-2::-2])
# d.获取['猿人泰山'、'阿甘正传']
print(movies[::-5])
# e.获取['霸王别姬']
print(movies[2:3])
a = []
a.append(movies[2])
print(a)
b = [movies[2]]
print(b)

2.7 列表拼接

list1 = [1,2,3,4]
list2 = [5,6,7,8]
print(list1 + list2)

'''
运算结果：
[1,2,3,4,5,6,7,8]
'''

2.8 成员运算

print(3 in [1, 2, 3])
print([3] in [1, 2, 3])
print([3] in [1, 2, 3, [3]])
'''
True
False
True
'''

2.9 比较大小

同类型元素比较大小，比较的是第一对不相等元素的大小（容器），数字正常比较大小。

list1 = [1, 2, 3, 4]
list2 = [1, 2, 4, 5]
print(list1 < list2)

list1 = [1, 2, '3', 4]
list2 = [1, 2, '4', 5]
print(list1 < list2)

'''
True
True
'''

三. 列表的循环遍历

# 循环（遍历）
movies = ['阿甘正传', '肖申克的救赎', '霸王别姬', '三傻大闹宝莱坞', '环太平洋', '猿人泰山']
# 1.直接遍历
for i in movies:
    print(i)

# 2.间接遍历
# len()能够查看容器的长度
print(len(movies))
for i in range(len(movies)):
    print(movies[i])

# 3.enumerate():将列表转换为一个可迭代对象
print(enumerate(movies))
for i in enumerate(movies):
    print(i)

练习：将下方列表中的元素从小到大排序。

list1 = [23, 56, 10, 55, 76, 100, 30]
# [23, 56, 10, 55, 76, 100, 30]
# [23, 10, 55, 56, 76, 30, 100]
# [10, 23, 55, 56, 30, 76, 100]
# 每趟排序，排序次数 + 1 = 本趟排序的元素个数
# 外层循环控制趟数
for i in range(1, len(list1)):
    print(f'这是第{i}趟排序')
    print('每趟排序开始前：', list1)
    for j in range(0, len(list1) - i):
        print('每次排序的两个元素', list1[j], list1[j + 1])
        if list1[j] > list1[j + 1]:
            list1[j], list1[j + 1] = list1[j + 1], list1[j]
        # 打印每一趟排序的结果
        print(list1)

四. 列表嵌套

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]

思考： 如何查找到数据"李四"？

# 第一步：按下标查找到李四所在的列表
print(name_list[2])

# 第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])

五. 列表推导式（列表生成式）

6.1 语法一：[表达式 for 变量 in 容器]

for循环每执行一次，表达式就会将其生成的结果添加到列表中。

num = [i for i in range(1, 101)]
print(num)
num_2 = [1 for _ in range(10)]
print(num_2)

列表推导式性能优于append()

6.2 语法二：[表达式 for 变量 in 容器 if 条件]

for循环执行一次，if分支判断一次，条件成立时表达式执行。

list3 = [i for i in range(1, 101) if i % 2 == 0]
print(list3)

6.3 语法三：[表示式 for 变量 in 容器 for 变量 in 容器]

list4 = [i for _ in range(3) for i in range(1, 11)]
print(list4)

六. 列表去重

7.1 方法一

print('方法一：')
names = ['张三', '李四', '大黄', '张三', '张三']
name_list = []
for i in names:
    if i not in name_list:
        name_list.append(i)
print(name_list)

7.2 方法二

names = ['张三', '李四', '大黄', '张三', '张三', '李四', '李四']
for i in range(len(names) - 1, -1, -1):
    print(i, names)
    if names.count(names[i]) > 1:
        del names[i]
print(names)

7.3 方法三

names = ['张三', '李四', '大黄', '张三', '张三', '李四', '李四']
index = 0
while index <= len(names) - 1:
    if names.count(names[index]) > 1:
        del names[index]
    else:
        index += 1
print(names)

七. 随机模块

• randint(a,b) -> 从[a,b]闭区间中随机获取一个整数。
• randrange() -> 约等于randint + range
• choice() -> 从容器中随机获取一个元素
• choices() -> 从容器中随机获取K个元素,有放回的抽取元素。
• sample() -> 从有序容器中无放回的抽取K个元素
• shffule() -> 将有序容器随机打乱顺序,无返回值，修改序列本身。

print(random.randrange(1, 4, 2)) 
print(random.choice([1, 2, 3, 4]))
print(random.choices([1, 2, 3, 4], k=5))
print(random.sample([1, 2, 3, 4], k=3)) #如果k > 容器长度，会报错

list1 = [1, 2, 3, 4]
print(random.shuffle(list1))
print(list1)

八. 总结

• 列表的格式

[数据1, 数据2, 数据3]

• 常用操作方法
  • index()
  • len()
  • append()
  • pop()
  • remove()
• 列表嵌套

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
name_list[2][1]

九. 练习题

10.1 课堂点名器

names = ['付永康', '廖宇', '罗梦佳', '夏博琳']
random.shuffle(names)
# 设置内幕
while True:
    result = random.sample(names, k=1)
    if result == ['付永康']:
        break
print(f'被抽中的同学为:{result}')

10.2 已知一个数字列表，求列表中心元素

num_list = [10, 68, 90, 40]
if len(num_list) % 2 != 0:
    print(num_list[len(num_list) // 2])
else:
    left = len(num_list) // 2 - 1
    right = len(num_list) // 2
    print(num_list[left], num_list[right])

10.3 已知一个数字列表，求所有元素和，不能使用sum()。

num_list = [10, 68, 90, 40]
total = 0
for i in num_list:
    total += i
print(total)

10.4 已知一个数字列表，求出所有奇数下标元素

num_list = [10, 68, 90, 40]
for i in range(1, len(num_list), 2):
    print(num_list[i])

10.5 已知一个数字列表，将所有元素乘2，nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]

nums = [1, 2, 3, 4]
for i in range(len(nums)):
    nums[i] *= 2
print(nums)

10.6 用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)

list1 = [10, 99, 20, 45, 78, 98, 95]
for i in range(1,len(list1)):
    for j in range(len(list1) - i):
        if list1[j] > list1[j + 1]:
            list1[j],list1[j + 1] = list1[j + 1],list1[j]
for i in list1[1:-1]:
    total += i
print('平均分是：',total / (len(list1) -2))

10.7 有两个列表A和B，使用列表C来获取两个列表中公共的元素

A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for i in A:
    if i in B:
        C.append(i)
print(C)

10.8 有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)

nums = [19, 89, 90, 600, 1]
for j in range(len(nums)-1):
    if nums[j] > nums[j + 1]:
        nums[j], nums[j + 1] = nums[j + 1], nums[j]
print('最大值为：',nums[-1])

10.9 生成一个存放1-100中个位数为3的数据列表

new_list = []
for i in range(1,101):
    if i % 10 == 3:
        new_list.append(i)
print(new_list)

10.10 不使用index(),查找第二个a的下标

num1 = [90, 78, 23, 0, 'a', 'b', 'c', 'd', 'e', 'a', 1, 2, 3]
a_count = 0
for i in range(len(num1)):
    if num1[i] == 'a':
        a_count += 1
        if a_count == 2:
            print(i)
            break

10.11 孪生数：两个素数的差等于2。找出100以内所有的孪生数。

方法一：
new_list = []
for i in range(2,101):
    if i == 2:
        print('2是素数')
        new_list.append(2)
    else:
        # 判断[2,x-1]中有没有能将x整除的元素
        for j in range(2, i):
            if i % j == 0:
                print(f'{i}不是素数')
                break
        else:
            print(f'{i}是素数')
            new_list.append(i)
print(new_list)
for x in range(len(new_list) - 1):
    if new_list[x + 1] - new_list[x] == 2:
        print(f'{new_list[x]}和{new_list[x + 1]}是孪生数')


方法二：
num1 = [i for i in range(2,100) for j in range(2,i) if i % j == 0]
num2 = [i for i in range(2,101) if i not in num1]
num = [[num2[i],num2[i + 1]] for i in range(len(num2) - 1) if num2[i + 1] - num2[i] == 2]
print('孪生数为：',end = ' ')
for i in num:
    print(f'{i[0]}和{i[1]}' , end = ' ')

10.12 生成50-300之间可重复的 10个数据 存放于列表中, 保证列表中元素的顺序，对列表进行排重,并对列表使用排序算法进行降序排序

import random

result = random.choices(range(50, 301), k=10)
print(result)
# num = [70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
new_list = []
for i in result:
 if i not in new_list:
     new_list.append(i)
print(new_list)
# 排序趟数
for x in range(1, len(new_list)):
 # 每次排序的元素
 for y in range(0, len(new_list) - x):
     if new_list[y] > new_list[y + 1]:
         new_list[y], new_list[y + 1] = new_list[y + 1], new_list[y]
print(new_list)

10.13 用列表推导式, 完成以下需求

生成一个存放1-100中各位数为3的数据列表
利用列表推到是将列表中的整数提取出来 .
例如：[True, 17, “hello”, “bye”, 98, 34, 21] — [17, 98, 34, 21]

new_list = [i for i in range(1, 101) if i % 10 == 3]
print(new_list)
list1 = [True, 17, "hello", "bye", 98, 34, 21]
num = [i for i in list1 if type(i) == int]
print(num)

10.14 获取列表中出现次数最多的元素

例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:[3]
例如：nums = [1, 2, 2, 3, 3] —> 打印:[2, 3]

nums = [1, 2, 2, 3, 3, 5, 5, 5, 6, 6, 6]
counts = [nums.count(i) for i in nums]
nums = [i for i in set(nums) if nums.count(i) == max(counts)]
print(nums)