Python基础知识list列表

# -*- coding:utf-8 -*-
# author:021王掌柜
import random
from itertools import chain
import copy

# 列表：可变的、类型不限、有序
# 列表可以存储(不同/相同)类型的数据、但是实际开发中、更多应用场景是：存储相同类型的数据
# 存储相同类型的数据、通过迭代遍历、在循环内部针对列表中每一项元素执行相同操作

names = ["张三", "李四", "王五", "赵六"]
length = len(names)  # len 也可以求列表元素的个数
i = 0

while i < length:  # 判断计算好的变量、比直接在这个地方计算在判断效率高
    print("names[%d]=%s" % (i, names[i]))
    i += 1

print("----华丽的分割线----")

for j in names:
    print("j=%s" % j)
print("-" * 30)

# 如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素
# 以此类推，可以获取倒数第2个、倒数第3个
print(names[0])
print(names[-1])
print(names[-2])

# 列表的常用操作 "增","删","改","查"
names.extend(['朱玲', '迷恋'])  # 将一个列表添加至列表尾部
# student_name = input("请输入新来同学姓名 ")
student_name = "请输入新来同学姓名"
names.append(student_name)  # 尾部追加
print(names)
names.insert(0, '首位添加来的')  # 指定位置插入(首位追加)
print(names)
# 改、 通过下标来确定要修改的是哪个元素，然后才能进行修改
names[0] = "王茂才"
print(names)
print("-" * 30)

# 查、 in（存在）,如果存在那么结果为true，否则为false
# not in（不存在）如果不存在那么结果为true，否则false
# student_name = input("请输入要查找同学姓名 ")
student_name = "请输入要查找同学姓名"
if student_name in names:
    print("我们班有这位同学")
else:
    print("这位同学不在我们班")
print("-" * 30)
# issubset()多个元素是否在列表中
result = {'a', 'c'}.issubset(['a', 'b', 'c'])
print('多个元素是否在列表中', result)

# 删除、 ("删"del、pop、remove)
# del() 根据下标进行删除
# pop() 删除最后一个元素(有返回值)
# remove() 根据元素的值进行删除
# reverse() 反转集合 (原地操作)

# 如果你需要对列表进行某种操作，比如添加或删除元素，或对列表进行排序，
# 但你还希望原始列表保持不变，这时这个功能就非常重要了
# [:] 完美复制：对 names 添加或删除元素，排序，而不会影响 new_names_list
new_names_list = names[:]  # 拷贝 不等同于list1=list2(赋值)
for item in names:
    print(item)
print("-" * 30)

del names[2]  # 下标
print('用pop删除', names.pop(3))  # 从最后一个元素开始、用pop(i)方法，其中i是索引位置，等同于del
name = names.pop()  # name就是被删除的元素
names.remove("王茂才")  # 实际项目中、删除前都需要判断一下、是否存在 if student_name in names:
for item in names:
    print(item)

list_1 = [1, 2, 3, 4, 5]
list_2 = ['a', 'b', 'c', 'd']
# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 打包为元组的列表,而且元素个数与最短的列表一致
# 在 Python 3.x 中为了减少内存 zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。
list_zip = zip(list_1, list_2)
print('zip函数的返回对象类型', type(list_zip), list_zip)  # 返回的是一个对象
# 遍历这个对象
for n in list_zip:
    print(n)  # 对象的每个元素是元组
for n, i in zip(list_1, list_2):
    print(n, i)

# 区间删除[起始:结束:间隔]
del list_2[0:-1:2]
print(list_2)

# 实际开发不用这种方式了、直接使用集合的取差集( ^ )交集( & )
# 打包列表，配对的、求交集、合并去重、差集
a = [1, 9, 2]
b = [0, 1, 3, 5, 7, 9, 2]
print('列表求交集', list((set(a).intersection(set(b)))))

c = list(zip(a, b))
print('打包2个列表、生成一个新列表，元素是元组', c)
print(c[1][0])  # 输出列表的某个元素的值、这可以看做是 多维元组

nc = a + b
print('2个列表相加返回一个全新列表', nc)
print('新列表去重', list(set(nc)))
a += b  # 等同于 extend()函数
# 这个函数用于在列表末尾一次性追加另一个序列中的多个值、 extend() 末尾追加
print("这种写法也是就地修改列表", a)
# 总结: 注意 列表(引用类型) a = a+b(返回全新列表)  和 a += b(原列表就地修改) 的区别

a = [1, 9, 2]
b = [0, 1, 3, 5, 7, 9, 2]
# b中有而a中没有的
print('列表求差集', list(set(b).difference(set(a))))

lst = list(range(1, 10))
print(lst)
max(lst)  # 返回最大值、max函数
min(lst)  # 返回最小值、min函数
print(sum(lst))  # 返回总和
print(sum([i for i in range(1, 101)]))  # 一行代码就可以搞定1+2+3+4+...求和

# 列表的内键函数
random.shuffle(lst)  # 就地洗牌、就是打乱原列表元素顺序
print(lst)
lst.sort()  # 从小到大排序(无返回值)
lst.sort(reverse=True)  # 从大到小排序、降序(无返回值)  reverse=False(默认升序、不需要给参数)
# sort(key=lambda x: x["code"])  # 列表里面如果是字典，可以按照指定键排序
print(lst)
#  sorted排序函数
lst = sorted(lst)  # sorted(lst,key=int/str) # key参数其实是个函数、可以强制转换指定类型比较大小排序、不改变元素本身
print('sorted重新排序后', lst)  # 默认按照(升序)排序
# 使用sorted()对一个列表集合按照列表中某个位置的元素进行排序
my_lists = [[1, 2, 3, 4], [4, 3, 2, 1], [2, 4, 1, 3], [3, 1, 4, 2]]
# my_lists_sorted_by_index_3 = sorted(my_lists)  # 默认按照第一个索引元素比较(升序)排序、降序 reverse=True
my_lists_sorted_by_index_3 = sorted(my_lists, key=lambda index_value: index_value[3])
print("Output #91: {}".format(my_lists_sorted_by_index_3))
# 上面案例是对一个列表集合按照每个列表中特定索引位置的值进行排序。关键字函数设置用于列表排序的关键字。
# 总结：sort就地修改、效率比sorted返回一个新列表优
# sort 与 sorted 区别：
# list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，
# 内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

# 导入 operator 模块中的 itemgetter 函数后，你可以使用每个列表中多个索引位置的值对列表集合进行排序：
# 使用itemgetter()对一个列表集合按照两个索引位置来排序
# my_lists = [[123, 2, 2, 444], [22, 6, 6, 444], [354, 4, 4, 678], [236, 5, 5, 678], [578, 1, 1, 290], [461, 1, 1, 290]]
# my_lists_sorted_by_index_3_and_0 = sorted(my_lists, key=itemgetter(3, 0))
# print("Output #92: {}".format(my_lists_sorted_by_index_3_and_0))
# 先按照索引位置 3 中的值对列表进行排序，然后在这个排序基础上，按照索引位置 0 中的值对列表进一步排序

# 列表数据取数
print(random.sample(lst, 1))  # 随机取N个不同索引的元素[1]、1一个元素也是返回列表
print(random.sample(lst, 1)[0])  # 返回元素本身的值
for i in range(9):
    print(random.choice(lst))  # 列表里面随机取一个元素

print('{x:=^30}'.format(x='列表推导式'))
# 列表推导式(列表解析式)
# 比标准的追加(append)性能会自动优化(适合数据量大的情况下)
# 语法：[返回值 for 元素 in 可迭代对象 if条件]  注意：只有单个if条件时、if在后面
new_list = [(x + 1) for x in [1, 2, 3, 4, 5, 6] if x < 5]
print(new_list)
# 使用中[],内部是for循环，if条件语句可选(if语句后面不需要冒号) 返回一个新的列表
# 推导式里面条件判断不能有else，（三元表达式可以）如果多个条件判断，直接跟在后面if即可
# Python 中的三元表达式与其他语言有所不同，
# 格式为：条件为真时的结果、 if 判段条件、 else 条件为假时的结果 注意：if else 时在前面
new_list = [(x + 1) ** 2 if x < 5 else 99999 for x in [1, 2, 3, 4, 5]]  # 返回值里面加三元表达式判断
print(new_list)

# 利用lambda+列表推导式
g = lambda x: x ** 2  # 语法 lambda后面跟着参数、“ ：”后面是返回值
print(list(map(g, range(10))))
# filter() 过滤函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
# 两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，
# 然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
print(list(filter(lambda x: x > 5, range(10))))
square = list(map(lambda x: x ** 2, range(10)))  # 简写方式 map 映射、会根据提供的函数对指定序列做映射
print(square)  # 打印出0-9的平方结果 x**2 平方 x***3 立方

# 删除列表元素、
# 1、操作原列表、思路：倒序删除、因为列表总是‘向前移’，所以可以倒序遍历，
# 即使后面的元素被修改了，还没有被遍历的元素和其坐标还是保持不变的
a = [1, 2, 3, 4, 5, 6, 7, 8]
print(id(a))
for i in range(len(a) - 1, -1, -1):
    if a[i] > 5:
        pass
    else:
        a.remove(a[i])
print(id(a))
print(a)
# 2、 filter() 过滤函数、操作的是新列表
b = filter(lambda x: x > 5, a)
# 3、列表解析、操作的是新列表
b = [i for i in a if i > 5]

# 嵌套列表、怎么 [压平嵌套列表]
lst = [[1, 2], [3, 4], [5, 6]]
new_lst = list(chain(*lst))  # [压平嵌套列表] from itertools import chain
print(new_lst)
# 使用列表推导式实现嵌套列表的平铺
vec = [[1, 2], [4, 5], [7, 8, 9]]
new_vec = [n for i in vec for n in i]
print(new_vec)
# 然后再转成字符串
new_vec = " ".join(str(n) for i in vec for n in i)
print(new_vec)
# 取索引
index = names.index('王五')  # 获取他在列表中对应的索引
print(names, index)
print('5第一次出现的位置在索引：', new_lst.index(5))  # 第一次出现的位置(索引)

# 列表转字符串
list1 = ['ak uk', 4, 'a']
list2 = [str(i) for i in list1]  # 使用列表推导式把列表中的单个元素全部转化为str类型
print(list2)  # 查看转化后的列表
list3 = ' '.join(list2)  # 把列表中的元素放在空串中，元素间用空格隔开
print(list3)  # 查看生成的长串
list4 = ' '.join(['ak uk'])  # 列表元素都是字符串类型、直接转
print(list4)  # 查看生成的长串

# 列表的浅拷贝和深拷贝
# 3.1 浅copy:是把原列表第一层的内存地址不加区分完全copy一份给新列表
list1 = ['egon', 'lxx', [1, 2]]
list3 = list1.copy()
print(id(list1[0]), id(list1[1]), id(list1[2]))
print(id(list3[0]), id(list3[1]), id(list3[2]))  # 2个列表的每个元素id一样
# 实验1：对于不可变类型的赋值，都是产生了新值，让原列表的索引指向新的，内存地址，并不会影响新列表
list1[0] = 'EGON'
list1[1] = 'LXX'
print(list1)
print(list3)  # 列表3 未改变
# 实验2：但对于可变类型，我们可以改变可变类型中包含的值，但内存地址不变
list1[2][0] = 111
list1[2][1] = 222
print(list1)
print('浅copy', list3)  # 列表3的后面一个元素被改变了(这个元素是可变类型)

# 3.2 深copy 需要引入模块 copy
list1 = ['egon', 'lxx', [1, 2]]
list3 = copy.deepcopy(list1)  # 或者 list3 = list1[:]
list1[0] = 'EEEE'
list1[1] = 'XXXX'
list1[2][0] = 100
list1[2][1] = 200
print(list1)
print('深copy', list3)

urls = ["http://www.netbian.com/mei/index_{}.htm".format(i) for i in range(2, 101)]  # 返回一个列表
url = "http://www.netbian.com/mei/index.htm"  # 第一页url
urls.insert(0, url)  # 列表首位插入元素
for url in urls:
    print("抓取列表页地址为：", url)

# 列表统计元素个数
import pandas as pd

data = [1, 2, 3, 4, 2, 3, 4, 2, 3, 4, 5, 6, 6, 4, 4, 5, 6, 7, 4]
# 内置函数count()
print(dir(data))  # 查看列表所有内置函数
print(data.count(6))  # 统计单个元素出现几次

# 在Python中可以使用 max( ) 函数并传递 list.count 作为key，即可找出列表list中重复次数最多的元素,代码如下:
lst = [1, 2, 3, 4, 3, 4, 4, 5, 6, 3, 1, 6, 7, 9, 4, 0]
most_repeated_item = max(lst, key=lst.count)
print(f'list中重复次数最多的元素{most_repeated_item}')

# 利用字典统计
data_dict = {}
for key in data:
    data_dict[key] = data_dict.get(key, 0) + 1
print("用字典统计:", data_dict)
# 字典中的value转换为列表
value_list = list(data_dict.values())
print(value_list)

# 利用pandas统计
result = pd.value_counts(data)
print("result:", result)

# 利用Counter类统计
from collections import Counter
result = Counter(data)
print("result:", result)

# 给定一个数组，按奇数在前升序，偶数在后降序排列，一行代码实现
nums = [1, 2, 3, 4, 5, 6, 7, 8]
new_nums = sorted([n for n in nums if n % 2]) + sorted([n for n in nums if not n % 2], reverse=True)
print(new_nums) # [1, 3, 5, 7, 8, 6, 4, 2]

# 有时我们在工作中,想要获得循环中元素的下标,一般来说,比较优雅的写法如下:
lst = ["blue", "lightblue", "pink", "orange", "red"]
for idx, item in enumerate(lst):
     print(idx, item)