列表相关操作以及元组

列表和元组

1，列表相关操作

• 数学运算符：+， *

①列表1 + 列表2 ---- 将两个列表合并成为一个新的列表。

list1 = [12, 23, 43, 53]
list2 = [1, 2, 3, 4]
print(list1 + list2)

②列表 * N ---- 将列表中的元素重复N次产生一个新的列表。

list2 = [1, 2, 3, 4]
list2 * 2
print(list2)

• 比较运算符：<, >, >=, <=, ==, !=

①比较相等：==， !=。

②比较大小：<, >, >=, <=。

列表比较大小，比较的是第一段（相同位置）不相等的元素的大小。

• in和not in

元素 in列表 ---- 判断指定列表中是否存在指定的元素。

元素 not in 列表 ---- 判断指定列表中是否不存在指定的元素。

2，列表相关函数

• sum(列表) ---- 对列表中的所有元素求和，列表必须是纯数字列表。

• max(列表) ---- 求列表中的最大值。

• min(列表) ---- 求列表中的最小值。

• len(列表) ---- 求列表长度。

• sorted(列表) ---- 产生新的列表，将列表中的元素按照从小到大排序。

• sorted(列表, reverse = True) ---- 产生新的列表，将列表中的元素按照从大到小排顺序。

• list() ---- 将其他数据转换为列表

3，列表相关方法

• 列表.clear() ---- 清空列表。

• 列表.copy() ---- 复制指定列表，产生一个新列表，将新的列表返回（列表[:], 列表 * 1, 列表 + []和列表.copy的功能相同）。

• 列表.count(元素) ---- 统计列表中指定元素的个数。

• 列表.extend(序列) ---- 将序列中的所有元素都添加到指定列表中。

• 列表.index(元素) ---- 获取元素在列表中对应的下标（返回0开始的下标）。

①如果元素不存在会报错。

②列表中存在多个相同元素时，只返回最前面的那个元素的下标。

• reverse

①列表.reverse() ---- 倒序。

②列表[::-1] 和功能相近，但不同的是“列表[::-1]”没有改变原列表，reverse是改变原列表。

• sort

①列表.sort() ---- 将列表元素从小到大排序，改变的是原列表。

②列表.sort() ---- 将列表元素从大到小排序。

注：sorted是产生新列表，原列表不变。

4，列表推导式

列表推导式：创建列表的表达式式，主要用于对元素进行筛选和变换。

• [表达式 for 变量 in 序列]

原理：创建一个列表，让变量去序列中取值，一个一个取，取一个值就代入表达式，并将结果放入列表。

作用：将原序列中的元素按照指定规则（表达式）进行统一变换得到一个新的列表。

• [表达式 for 变量 in 序列 if 条件语句]

原理：创建一个列表，让变量去序列中取值，一个一个取，取一个值就判断一次条件语句条件成立才代入表达式，并将结果放入列表。

#示例
# 练习1：基于nums得到[8, 0, 1, 1, 2]
result1 = [x % 10 for x in nums]
# 练习3： 基于nums得到[10, 1, 9, 4, 4]
result2 = [x % 10 + x % 100 // 10 + x // 100 for x in nums]  # 全部当做三位数来计算
# 练习4： 基于nums得到 [True, True, False, False, True]
result3 = [x % 2 == 0 for x in nums]
print(result1, result2, result3)

# 练习5：基于nums得到: [81, 301]
result4 = [x for x in nums if x > 50]
print(result4)

list1 = [10, '12.3', 1.23, 20, 'abc', True]
# 练习6：基于list1，得到 [10, 20]
result5 = [x for x in list1 if type(x) == int]

# # 练习7：已经一个分数列表，提取列表中所有及格分数 (删除不及格)[89, 67, 90, 89]
scores = [18, 89, 67, 90, 45, 34, 12, 89]
result6 = [x for x in scores if x >= 60]
print(result5, result6)

5,元组

• 认识元组（tuple）

①是容器：将()作为容器标志，里面多个元素用逗号隔开(元素1, 元素2, …)。

②元组是不可变的（不支持增改删）；有序。

③单个元素的元组：必须在哪个唯一的元素后面加逗号。

• 元组就是不可变的列表

列表中和增删改无关的操作，元组都支持 ---- 参考列表。

①查，②切片，③遍历，④相关操作，⑤相关函数，⑥部分相关方法

• 元组不只是不可变的列表

①单个元素的元组：(元素,)

②在没有歧义的情况下，元组的()可以省略

③获取元素的时候，可以让变量的个数等于元组中元素的个数

6，相关练习

1，创建一个列表，列表中有10个数字, 保证列表中元素的顺序，对列表进行排重,并对列表使用进行降序排序

num = [70, 88, 91, 70, 107, 234, 91, 177, 282, 107, 234, 197]
for _ in range(len(num)):
    num1 = num.pop()
    if num1 not in num:
        num.insert(0, num1)     # 列表.insert(下标,元素)
num.sort(reverse=True)          # 列表.sort(reverse = True) 从大到小排序
print(num)

2，a. 生成一个存放1-100中个位数为3的数据列表

result = [x for x in range(3, 100, 10)]
print(result)

2，b. 利用列表推导式将列表中的整数提取出来

num1 = [True, 17, "hello", "bye", 98, 34, 21]
result1 = [x for x in num1 if type(x) == int]
print(result1)

2，c.利用列表推导式 存放指定列表中字符串的长度

num3 = ["good", "nice", "see you", "bye"]
result2 = [len(x) for x in num3]
print(result2)

2，d. 利用列表推导式删除列表中整数个位数小于5的元素

num4 = [24, 'abc', 99, True, 21, 38, 'hello']
result3 = [x for x in num4 if type(x) != int or x % 10 > 5]
print(result3)

2，e. 利用列表推导式获取元素是元组的列表中每个元组的最后一个元素

num5 = [(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]
result4 = [x[-1] for x in num5]
print(result4)

2，f.利用列表推导式将数字列表中所有的奇数乘以2，所有的偶数除以2

num6 = [23, 4, 67, 88, 90, 21]
result5 = [x*2 for x in num6 if x % 2] + [int(x / 2)for x in num6 if not x % 2]  # 三目运算符，结果二选一
print(result5)

3，已知一个列表获取列表中指定元素所有的下标 列表.index(元素)

num7 = [10, 20, 34, 10, 9, 78]
num = int(input("请指定列表[10, 20, 34, 10, 9, 78]中的元素："))
sub = []
if num in num7:
    for x, y in enumerate(num7):
        if num == y:
            sub.append(x)
    print(num, "的下标为：", sub)
else:
    print(num, "的下标为：", sub)

4，已知一个数字列表，写程序判断这个列表是否是连续递增列表

A = [1, 2, 3, 4, 5]
B = sorted(A)
print(A == B)

5，已知两个列表，将两个列表按照下面的规律交叉合并

A = [10, 20, 30, 40, 50]
B = [100, 200, 300]
c = []
for x in range(len(A)):
    c.append(A[x])
    y = len(B)-1
    if x <= y:
        c.append(B[x])
print(c)

6，已知两个有序列表，将两个列表合并，合并后的新列表中元素仍然是递增列表

A = [10, 20, 30, 40, 50]
B = [25, 44, 60]
C = A + B
C.sort()
print(C)