Python入门第六天-列表和元组

最新推荐文章于 2022-04-10 08:57:06 发布

李家半仙儿

最新推荐文章于 2022-04-10 08:57:06 发布

阅读量453

点赞数

分类专栏： python初学文章标签：列表 python 数据结构 java 数据分析

本文链接：https://blog.csdn.net/LJBXE/article/details/111240628

版权

python初学专栏收录该内容

31 篇文章 0 订阅

订阅专栏

本文详细介绍了Python中列表和元组的相关操作，包括数学运算、比较运算、成员运算、函数应用，以及列表的方法。还探讨了列表推导式和元组的特性，如元组的不可变性、切片、遍历等。通过实例讲解了如何使用这些操作进行数据处理。

摘要由CSDN通过智能技术生成

day6 列表和元组

一、列表相关操作

1、数学运算：+、*（只支持这两个，别的不支持）

（1）列表1+列表2 - 将两个列表合并成一个新的列表

list1 = [1, 2, 3]
list2 = [100, 200]
print(list1 + list2)   # [1, 2, 3, 100, 200]

（2）列表*N - 列表中的元素重复N次产生一个新的列表（N是>=0的整数）

list3 = list1 * 3
print(list3)    # [1, 2, 3, 1, 2, 3, 1, 2, 3]

2、比较运算符

（1）比较是否相等：==、!=

必须对应位置的数据是一样的

print([1, 2, 3] == [1, 2, 3])  # True
print([1, 2, 3] == [1, 3, 2])   # False

（2）is的用法

数据1 is 数据2 - 判断两个数据是否相等（判断数据的地址）
数据1 == 数据2 - 判断两个数据是否相等（判断数据的值）
注意：如果给不同的变量赋相同的可变值，地址不一样（列表、字典）
赋相同不可变的值，地址相同(元祖，数字，字符串)

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
print(list1 == list2)   # True
print(list1 is list3)   # True
print(list1 == list3)  # True

列表可变

print(list1 is list2)   # False

元祖不可变

x = (10, 20)
y = (10, 20)
print(x is y)   # True

（3）比较大小：>. < . >= . <= . - 比较相同位置元素的大小

两个列表比较大小，是比较第一对不想等的元素的大小

print([1, 2, 3, 4] > [10, 20])  # False
print([1, 2, 3, 4] > [-1, 20])  # True
print([1, 2, 3, 4] > [1, 20])   # False
print([1, 2, 3, 4] > [1, 1])    # True

3、in 和not in - 判断某个列表中是否有指定的元素

元素 in 列表 - 判断某个列表中是否有指定的元素结果是布尔值

print(100 in [100, 200])    # True
print(10 in [100, 200])     # False
print([1, 2] in [1, 2, 3])   # False
# 有一个长度是10的列表，数组内有10个人名，要求去掉重复的(用添加的方式去重）
# 例如:names = ['张三', '李四', '大黄', '张三'] -> names = ['张三', '李四', '大黄']
names = ['张三', '李四', '小明', '张三', '小红', '李四', '小白', '校长', '小黄', '小兰']
new_names = []
for x in names:
    if x not in new_names:
        new_names.append(x)
print(new_names)

# 有两个列表A和B，使用列表C来获取两个列表中公共的元素
# 例如: A = [1, 'a', 4, 90]  B = ['a', 8, 'j', 1] --> C = [1, 'a']
A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for item in A:
    if item in B:
        C.append(item)
print(C)

4、相关函数

sum 、 max 、 min 、 sorted 、 len 、 list

（1）sum（序列） - 求序列中所有元素的和，要求序列中的元素必须是数字

scores = [90, 89, 79, 9, 99, 100]
print(sum(scores))    # 466

（2）max（序列）/ min(序列) - 获取序列中最大的元素/获取序列中最小的元素

要求序列中的元素支持比较运算，并且类型一致

scores = [90, 89, 79, 9, 99, 100]
print(max(scores))
print(min(scores))
# print(max([23, 'abs']))  # TypeError: '>' not supported between instances of 'str' and 'int'

（3）sorted

sorted(序列) - 将序列中的元素从小到大排序，返回排序之后的新列表

new_scores = sorted(scores)
print(scores)  # 不会修改原列表[90, 89, 79, 9, 99, 100]
print(new_scores)  # [9, 79, 89, 90, 99, 100]

sorted(序列，reverse = True) - 将序列中的元素从大到小降序排序，返回排序之后的新列表

scores = [90, 89, 79, 9, 99, 100]
new_scores = sorted(scores, reverse=True)
print(new_scores)   # [100, 99, 90, 89, 79, 9]

（4）len(序列) - 获取序列中元素的个数

（5）list(数据) - 将数据转换成列表

哪些能转：所有序列都可以转换成列表（字符串、range、元祖。。。。）
将序列中的元素作为列表的元素

print(list('abc'))  # ['a', 'b', 'c']

二、列表相关方法

1、列表.clear() - 清空列表（删除列表中所有的元素）

注意clear和deal之间的差别：clear是清除列表中的元素，盒子变成空的，deal是将盒子也清除，连盒子都没有了

nums = [1, 34, 67]
nums.clear()
print(nums)   # []

2、列表.copy() - 复制原列表，产生一个相同的新列表（数据相同，地址不同）

nums = [1, 2, 'abg']
new_nums = nums.copy()
print(new_nums)

id(变量) - 获取变量中保存的数据的地址

print(id(nums), id(new_nums))

直接赋值和拷贝的区别：直接赋值的数据相同地址也相同，对原来列表进行修改，直接赋值的列表也会进行相应的修改；拷贝的列表数据相同，地址不同，对原来的列表进行修改，拷贝的新列表不会有修改

list1 = [1, 2, 3]
list2 = list1
print(list2)          # [1, 2, 3]
list3 = list1.copy()  # [1, 2, 3]
print(list3)
list4 = list1[:]
list5 = list1*1
list6 = list1+[]
print(list4)          # [1, 2, 3]
print(list5)          # [1, 2, 3]
print(list6)          # [1, 2, 3]
list1.append(100)
print(list2)      # [1, 2, 3, 100]
print(list3)      # [1, 2, 3]
print(list4)          # [1, 2, 3]
print(list5)          # [1, 2, 3]
print(list6)          # [1, 2, 3]

3、列表.count(元素) - 统计指定元素在列表中出现的次数或者个数

scores = [23, 67, 89, 90, 100, 89, 76, 100, 34, 85]
scores.count(100)
print(scores.count(100))   # 2

# 10.获取列表中出现次数最多的元素
# 例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3]   —> 打印:3
nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3]
max_count = 0
for item in nums:
    count = nums.count(item)
    if count > max_count:
        max_count = count
print(max_count)

4、列表.extend(序列) - 将序列中所有的元素都添加到列表中

注意extend和append的区别，两者都是添加，但是添加方式有不同
extend添加是将序列中的元素一个一个添加
append添加是将序列整个直接添加

nums = [1, 2]
nums.extend('abc')
print(nums)         # [1, 2, 'a', 'b', 'c']
nums.extend([10, 20, 30])
print(nums)         # [1, 2, 'a', 'b', 'c', 10, 20, 30]
nums = [1, 2]
nums.append('abc')
print(nums)         # [1, 2, 'abc']

5、列表.index(元素) - 获取指定元素在列表中的下标（0~长度-1）

如果获取的元素在列表中有多个重复的，只返回第一个元素的下标
如果元素在列表中不存在，程序会报错

song = ['晴天', '大不了重头再来', '只因你太美', '成都', '阳光总在风雨后', '晴天']
print(song.index('成都'))    # 3
print(song.index('晴天'))    # 0
# print(song.index('当'))     #  ValueError: '当' is not in list

6、列表.reverse() - 将列表倒序

不会产生新的列表，直接在原列表中修改顺序

song = ['晴天', '大不了重头再来', '只因你太美', '成都', '阳光总在风雨后', '晴天']
song.reverse()
print(song)

7、列表.sort() - 排序

列表.sort() - 将列表中的元素从小到大排序（不会产生新的列表，直接修改原列表中元素的顺序）
列表.sort(reverse = True) - 将列表中的元素从大到小排序（不会产生新的列表，直接修改原列表中元素的顺序）

nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3]
nums.sort()
print(nums)   # [1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 7]
nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3]
nums.sort(reverse=True)
print(nums)    # [7, 4, 3, 3, 3, 3, 2, 2, 1, 1, 1]

三、列表推导式

1、什么是列表推导式 - 用来快速产生一个列表的表达式

（1）基本语法：[表达式 for 变量 in 序列]

产生元素的原理：让变量对序列中取值，一个一个的取，每取一个值就将表达式的结果作为列表中的一个元素

a = []

for 变量 in 序列：

a.append(表达式)

返回 a

list1 = [1 for x in range(4)]  # [1,1,1,1]
list2 = [x for x in range(4)]  # [0,1,2,3]
list3 = [x+y for x, y in enumerate([10, 20, 30])]  # [10, 21, 32]

(2)带条件语句的推导式：[表达式 for 变量 in 序列 if 条件语句]

相当于：
a = []

for 变量 in 序列：

if 条件语句：

a.append(表达式)

返回 a

list5 = [x for x in range(10, 20) if x % 3 == 0] # [12, 15,18]
list6 = [x for x in range(10, 20) if x % 2]
print(list6)

x%2的结果不是布尔值，要转换成布尔值再进行判断，非0时就成立，不是0就不成立
例如：x = 10 ,if x != 0 相当于if x

scores = [23, 67, 89, 90, 100, 89, 76, 100, 34, 85]
new_scores = [x for x in scores if x >= 60]
print(new_scores)  # [67, 89, 90, 100, 89, 76, 100, 85]

# 将列表中所有元素乘以二
nums = [2, 4, 5, 7, 9]
new_nums = [x*2 for x in nums]
print(new_nums)  # [4, 8, 10, 14, 18]

(3)双重循环或者多重循环：[表达式 for 变量1 in 序列1 for 变量2 in 序列2]

相当于：
a = []
for 变量1 in 序列;
for 变量2 in 序列2：
a.append(表达式)
返回a

result = [x+y for x in range(3) for y in range(10, 13)]
print(result)  # [10, 11, 12, 11, 12, 13, 12, 13, 14]
'''
x = 0
    y = 10
    y = 11
    y = 12
x = 1
    y = 10
    y = 11
    y = 12
'''

四、元组

1、什么是元组

元组是容器型数据类型：将()作为容器标志，多个元素用逗号隔开：（元素1，元素2，元素3 ，…)
元组元素的要求和列表一样
特点：a 不可变性：不支持增删改的操作，只支持查；b有序性：支持下标操作
空列表有意义，空元祖是没有意义的，原来是0个，就永远是0个

t1 = (10, 20, 'abc')
print(type(t1))

2、列表中适用于元组的操作

(1)列表的查操作元祖都支持（查、切片、遍历…)

获取单个元素

t1 = (10, 20, 'abc')
print(t1[0], t1[1])  # 10 20

获取部分元素（元组切片）- 同时获取元组的多个元素，

t1 = (10, 20, 'abc', 45, 78, 90, 100, '李家半仙儿')
print(t1[0:5:2])  # (10, 'abc', 78)
print(t1[0:6:1])  # (10, 20, 'abc', 45, 78, 90)
print(t1[:4:2])   # (10, 'abc')

遍历

for item in t1:
    print('item:', item)

(2)列表的相关操作全部适用于元祖（数学运算、比较运算、in和not in 、相关函数）

3、元组特有的内容

（1）单个元素的元组 - 唯一的那个元素后面必须加逗号

tuple1 = (10)
tuple2 = (10,)
print(type(tuple1))   # <class 'int'>
print(type(tuple2))   # <class 'tuple'>

（2）元组的括号在没有歧义的情况下可以省略（多个数据直接用逗号隔开表示的也是一个元组）

t3 = 10, 23, 45
print(type(t3), t3)  # <class 'tuple'> (10, 23, 45)

（3）用多个变量获取元组中元素的值（也适用于列表）

可以通过下标获取元素
可以通过用变量来获取元素，变量的个数可以小于等于元组中元素的个数

t4 = (18, '余婷', '女')
# a. 通过下标获取元素
print(t4[1], t4[1:])   # 余婷 ('余婷', '女')

# b.让变量的个数和元组中元素的个数保持一致
x, y, z = t4
print(x, y, z)  # 18 余婷 女

# c.让变量的个数小于元组中元素的个数，但是必须有一个变量带*
t4 = (18, '余婷', '女', 67, 9)
x, y, *z = t4
print(x, y, z)  # 18 余婷 ['女', 67, 9]
x, *y, z = t4
print(x, z, y)  # 18 9 ['余婷', '女', 67]