6.列表相关操作

6.列表

可变的有序序列
可变-元素的地址可变，长度可变
底层基于数组

6.1.列表的操作

列表是python中最常用的数据结构之一，非常好用，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型

6.1.1. 定义的操作

代码示例:

# 使用list() 的形式来进行列表的定义
l1 = list()
print(l1)  # []

# 将其他序列的元素存放在列表中
l1 = list('abcd')
print(l1)  # ['a', 'b', 'c', 'd']

# 使用字面量
l2 = []  # 效率比上面的快一些
print(l2)

nums = [12, 34, 56, 78, 90]
print(nums)

6.1.2. 列表中的可用的运算符

def __add__  这种双下划线叫做魔术方法  不需要手动调用 会在对应的时机自主调用的

+  两个列表相加 生成了一个新的列表 将两个列表中的元素进行了合并
*  乘以的是正整数n  生成了一个新的列表 存放的是原列表中的元素重复n次
+= 可以和序列相加 将序列中的元素合并到当前列表中
*= 乘以的是正整数n  将列表中的元素重复n次 存放于列表中
in 成员运算符
下面是简单的比较运算符
>=
>
<=
<
==
!=
	运算特点: 相同位置的元素进行比较 直到比较出来结果

l1 = [12, 34, 56]
l2 = [22, 33, 44]
new_list = l1 + l2
print(new_list, l1, l2)  # [12, 34, 56, 22, 33, 44] [12, 34, 56] [22, 33, 44]

new_list = l1 * 3
print(new_list, l1)  # [12, 34, 56, 12, 34, 56, 12, 34, 56] [12, 34, 56]

l1 += 'abc'
print(l1)  # [12, 34, 56, 'a', 'b', 'c']

l1 *= 3
print(l1)  # [12, 34, 56, 'a', 'b', 'c', 12, 34, 56, 'a', 'b', 'c', 12, 34, 56, 'a', 'b', 'c']


l3 = [12, 34, 21]
l4 = [12, 33, 19]
print(l3 > l4)  # True

l3 = ['hello', 'hear']
l4 = ['happy', 'head']
print(l3 >= l4)  # True

6.1.3.索引和切片

nums = [76, 27, 19, 33, 52, 48]
# 获取前3个数
sub_nums = nums[:3]
print(sub_nums)  # [76, 27, 19]

# 舍头去尾 不要第一个与最后一个
sub_nums = nums[1:-1]
print(sub_nums)  # [27, 19, 33, 52]

# 列表反转
sub_nums = nums[::-1]
print(sub_nums)  # [48, 52, 33, 19, 27, 76]

# 获取倒数第三个数据
ele = nums[-3]
print(ele)  # 33

# 根据索引和切片修改列表中的元素
# 修改单个位置的元素
nums[-3] = 44
print(nums)  # [76, 27, 19, 44, 52, 48]

# 修改元素 使用切片修改元素的时候  赋值的时候必须得是序列
# nums[:3] = 12  # TypeError: can only assign an iterable
# print(nums)

# nums[:3] = [12]
# print(nums)  # [12, 44, 52, 48]

nums[:3] = [12] * 3
print(nums)

6.1.4.列表中常用的操作

增加元素

# 在末尾追加
nums.append(77)
print(nums)  # [12, 12, 12, 44, 52, 48, 77]
# 在指定位置添加
nums.insert(0, 44)
print(nums)  # [44, 12, 12, 12, 44, 52, 48, 77]
# 合并其他序列
nums.extend((66, 77, 98, 24))
print(nums)  # [44, 12, 12, 12, 44, 52, 48, 77, 66, 77, 98, 24]

删除元素

# 删除指定元素 -- 移除的是查找到的第一个
nums.remove(77)
print(nums)
# 注意点：这个元素不存在会报错
# nums.remove(99)  # ValueError: list.remove(x): x not in list

# 移除指定位置的元素
pop_ele = nums.pop()  # 不设置位置 默认移除的是最后一个元素  并把移除的这个元素返回
print(nums)
print(pop_ele)  # [44, 12, 12, 12, 44, 52, 48, 66, 77, 98]

# 设置位置
pop_ele = nums.pop(-1)  # [44, 12, 12, 12, 44, 52, 48, 66, 77]
print(nums)

# 另一种方式
del nums[0]
print(nums)  # [12, 12, 12, 44, 52, 48, 66, 77]

# 清空
# nums.clear()
# print(nums)  # []

6.1.5.其他的操作

# 获取指定元素第一次出现的位置
pos = nums.index(77)
print(pos)  # 7

# 统计元素出现的次数
count = nums.count(12)
print(count)  # 3

# 反转列表  影响的是原列表   列表[::-1] 生成的是新的  原来的没有影响
nums.reverse()
print(nums)  # [77, 66, 48, 52, 44, 12, 12, 12]

6.1.6.浅拷贝与深拷贝

# 浅拷贝
'''
拷贝： 复制一份 出现一份新的
浅拷贝： 外层的数据复制一份新的  内层的数据没有被赋值 
深拷贝： 里外都会赋值出来一份新的
'''
l1 = [12, 34]
l2 = [33, 35]
values = [l1, l2]
print(values)  # [[12, 34], [33, 35]]

# 浅拷贝 --- 列表自身提供了一个方法
new_values = values.copy()
print(id(new_values), id(values))  # 2097648614152 2097648613896
print(id(new_values[0]), id(l1))  # 1785334184648 1785334184648

# 拷贝模块 copy
import copy
# copy.copy(数据)  浅拷贝
deep_values = copy.deepcopy(values)
print(id(deep_values), id(values))  # 2604096666504 2604096666376
print(id(deep_values[0]), id(l1))  # 2604096667080 2604096666696

排序

# nums.sort()  # 对列表中的元素 按照元素大小进行比较 完成升序排序
# print(nums)  # [12, 12, 12, 44, 48, 52, 66, 77]

nums.sort(reverse=True)  # 升序之后 反转就是降序  reverse这个参数问的是 排序之后是否反转 默认是False  降序是True
print(nums)  # [77, 66, 52, 48, 44, 12, 12, 12]


values = ['hello', 'good', 'nice', 'bye']
values.sort()
print(values)  # ['bye', 'good', 'hello', 'nice']

key的操作:

'''
获取最大值

自己去实现获取最大值：
    逻辑：
        声明一个变量 记录最大值  假设第一个是最大的
        遍历
        将元素与假设的进行对比 直到真正的最大值
'''
values = ['hello', 'Good', 'Nice', 'bye']

# 假设一个
# max_value = values[0]
# # 遍历
# for ele in values[1:]:
#     if ele > max_value:
#         max_value = ele
# print(max_value)  # nice

# 获取指定序列中的最大值
def get_max(seq):
    max_value = seq[0]
    # 遍历
    for ele in seq[1:]:
        if ele > max_value:
            max_value = ele
    return max_value


print(get_max(values))


# 长度最大的字符串
def get_max(seq):
    max_value = seq[0]
    # 遍历
    for ele in seq[1:]:
        if len(ele) > len(max_value):
            max_value = ele
    return max_value

print(get_max(values))  # hello


# 获取某个字符串的大写模式
def get_upper(src):
    return src.upper()

# 忽略大小写的情况下 获取最大值
def get_max(seq):
    max_value = seq[0]
    # 遍历
    for ele in seq[1:]:
        if get_upper(ele) > get_upper(max_value):
            max_value = ele
    return max_value


def get_max(seq, key=None):
    # key 为None 比较的元素的大小  key有值的时候 根据key这个功能获取比较的状态值
    if key is None:
        max_value = seq[0]
        # 遍历
        for ele in seq[1:]:
            if ele > max_value:
                max_value = ele
        return max_value
    else:
        max_value = seq[0]
        # 遍历
        for ele in seq[1:]:
            if key(ele) > key(max_value):
                max_value = ele
        return max_value


print(get_max(values))

print(get_max(values, key=get_upper))  # Nice

'''
如果形参中有key这个函数
作用的位置是在 比较的位置  作用：就是根据功能获取数据进行比较的状态值 根据这个状态值参与比较的操作  
获取这种状态下的最值
'''

其他操作示例:

# 获取最大值
max_ele = max(values)
print(max_ele)  # nice

# 获取长度最大的元素呢
max_ele = max(values, key=len)  # key接受的是一个函数 用于获取元素比较的状态值 按照这个状态值获取最值
print(max_ele)  # hello

# 排序 也有一个key 接受的是函数  排序比较元素时获取元素的状态值的 按照这个状态值比较排序
values.sort(key=len, reverse=True)
print(values)  # ['hello', 'good', 'nice', 'bye']


# 有序序列的遍历
for ele in values:
    print(ele)

# 根据编号遍历序列
for i in range(len(values)):
    print(i)
    print(values[i])

print(list(enumerate(values)))

枚举

'''
enumerate 枚举
    会将有序序列的元素重组  根据位置和元素进行组合 将每个位置及其元素组合成一个小元组
'''
a = 10, 11
print(type(a))  # <class 'tuple'>
a, b = 10, 11
for item in enumerate(values):
    print(item)

# 既有索引 又有元素
for index, ele in enumerate(values):
    print(f'第{index + 1}处的元素是{ele}')

6.2列表推导式

快速根据需求情况生成一个列表 --> 理解成某种筛选或者 映射的快捷方式

格式:
	[数据 数据的来源 数据的筛选]
	数据的筛选是按照需求判定有或者没有的

代码示例:

# 1.长度为4的单词
values = ['hello', 'good', 'nice', 'bye']
print([n for n in values if len(n) == 4])

# 2.包含云字的名字
names = ['岳云鹏', '曹鹤翔', '张云雷', '张晓云', '郭麒麟']
print([n for n in names if '云' in n])

# 3.将列表元素转成字符串
num = [12, 52, 13, 41]
print([str(n) for n in num])

6.3列表排序算法

6.3.1冒泡排序

规则:
每一次遍历序列的时候都是从下标为0的位置开始提取元素将相邻的两个元素两两进行比较直到顺序排出
比较相邻的两个元素如果前者大于后者两者交换位置
每经过一次遍历都出现一个较大值 这个值不需要参与下一次遍历

代码示例:

# 降序排列
def bull_des(arg_list):
    arg_len = len(arg_list)
    for i in range(1, arg_len):
        for j in range(arg_len - i):
            if arg_list[j] < arg_list[j + 1]:
			# 升序排列
			# if arg_list[j] > arg_list[j + 1]:
                arg_list[j], arg_list[j + 1] = arg_list[j + 1], arg_list[j]
    return arg_list

6.3.2选择排序

比较直观一些
第一次遍历使用第一个位置的元素与之后的每一个位置的元素进行比较这个位置的元素大于后面位置的两者交换位置
第二次遍历使用第二个位置的元素与之后的每一个位置的元素进行比较这个位置的元素大于后面位置的两者交换位置
直到排序完成

代码示例:

# 选择排序-升序
def select_sort_asc(obj_list):
    obj_len = len(obj_list)
    for i in range(obj_len - 1):
        for j in range(i, obj_len):
            if obj_list[i] > obj_list[j]:
			# 选择排序-降序
			# if obj_list[i] < obj_list[j]:
                obj_list[i], obj_list[j] = obj_list[j], obj_list[i]
    return obj_list

6.3.3插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

1. 算法步骤

   1将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

   2从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

代码示例:

def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i - 1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex + 1] = arr[preIndex]
            preIndex -= 1
        arr[preIndex + 1] = current
    return arr

6.3.4快速排序(快排)

对冒泡的一种改进

需要找基准值，使用这个基准值把列表分成两部分
把小于基准值的放在左部分 大于基准值的放在右部分中
再一次对于左右的各自找到一个对应的基准值 比基准值小的 再放在左边 比基准值大的放在基准值的右边

这个基准值只要是列表中的就行 一般情况就是用的第一个当做基准值

使用递归 + 分而治之 来完成快排

代码示例:

nums = [23, 19, 44, 28, 32, 17, 36, 51, 45]

# 对指定的列表进行排序
def sort(src_list):
    # 入口和出口
    if len(src_list) >= 2:
        # 设置基准值
        mid = src_list[0]
        # 定义两个列表 一个来存放大的  一个来存放小的
        big = []
        small = []
        # 因为自己没有必要和自己进行比较 删除
        src_list.remove(mid)
        # 遍历列表 与 基准值进行对比
        for ele in src_list:
            if ele > mid:
                big.append(ele)
            else:
                small.append(ele)
        # 返回值
        return sort(small) + [mid] + sort(big)
    else:
        return src_list
print(sort(nums))