list（列表）
概念：存放零个或者多个数据的有序的可变的序列
列表数据的标识是
[]，是在[]存储元素，元素之间使用,隔开列表中是可以存放不同类型的数据作为元素的，但是为了数据的统一性，所以我们一般来存储的时候类型就是统一的
1. 列表的定义
- 采用
[]字面量定义法- 采用
list()构造
l0 = [] # 空列表
print(l0) # []
l1 = [19, 28, 44, 56, 38]
print(l1)
# list()构造
l2 = list()
print(l2) # []
# 把其他序列类型转化为列表类型 【构造一个列表 把其他序列中的元素添加在列表中】
l3 = list('10')
print(l3) # ['1', '0']
l4 = list(range(1, 100, 10))
print(l4) # [1, 11, 21, 31, 41, 51, 61, 71, 81, 91]
2. 列表中的运算符
l1 = [19, 27, 83, 56]
l2 = [77, 55, 43]
# + 合并两个列表中的数据 把数据添加到一个新的列表中
new_li = l1 + l2
print(new_li) # [19, 27, 83, 56, 77, 55, 43]
# * 将列表中的元素重复n次 放在一个新的列表中
new_li = l1 * 3
print(new_li, l1) # [19, 27, 83, 56, 19, 27, 83, 56, 19, 27, 83, 56]
# += 将当前列表的基础上追加其他序列中的元素
l1 += range(1, 10)
print(l1) # [19, 27, 83, 56, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# *= 将当前列表的元素重复n次
l1 *= 2
print(l1) # [19, 27, 83, 56, 1, 2, 3, 4, 5, 6, 7, 8, 9, 19, 27, 83, 56, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#比较运算符【> >= < <= == !=】相同位置的元素进行比较 直到产生结果 比较结束
l3 = ['good', 'nice']
l4 = ['god', 'look']
print(l3 > l4) # True --》 good 和 god 比较
# 成员运算符 in 和 not in 判断元素是否在或者不在列表中
print(19 in l1) # True
print(19 not in l1) # False
# 身份运算符 id 、is 和 not is
print(id(l1)) # 获取地址
print(id(l2)) # 获取地址
print(l1 is l2) # 判断地址是否一致
print(not l1 is l2)# 判断地址是否不一致
3. 索引和切片
索引
python索引分为正向索引和负向索引
正向索引的范围是[0, 长度N - 1] 从左向右
负向索引的范围是[-1, -长度N] 从右向左
通过索引定位到对应位置，修改或者获取该位置的元素
nums = [19, 27, 38, 41, 25]
# 获取第2个元素
ele = nums[1]
print(ele)
# 获取倒数第二个
ele = nums[-2]
print(ele)
# 修改
nums[0] = 87
print(nums) # [87, 27, 38, 41, 25]
nums[-1] = 65
print(nums) # [87, 27, 38, 41, 65]
切片
切片类似于字符串
列表[start:stop:step]
正向切片步长step为正数 表示从左向右取值
负向切片步长step为负数 表示从右向左取值
start和stop只是来定位取数据的范围
start省略 正向切片的时候 表示从最左边开始 负向切片表示从最右边开始
stop省略 正向切片的时候 表示到最右边结束 负向切片表示到最左边结束
# 切片
sun_nums = nums[::2]
print(sun_nums) # [87, 38, 65]
sun_nums = nums[::-1]
print(sun_nums) # [65, 41, 38, 27, 87]
sun_nums = nums[:]
print(sun_nums) # [87, 27, 38, 41, 65] 备份了一份
'''
切片：根据索引以及步长定位到列表的多个位置
因为列表是可变的 也可以通过切片对这些位置的数据进行修改 【赋值得是一个序列型数据】
切片定位的下标范围是连续的 赋值的个数可以随便
但是位置是跳跃的 定位到几个位置 就得赋予几个值
'''
nums[:2] = [19, 33]
print(nums) # [19, 33, 38, 41, 65]
nums[:2] = [19]
print(nums) # [19, 38, 41, 65]
nums[:2] = [19, 99, 78, 36]
print(nums) # [19, 99, 78, 36, 41, 65]
# nums[::2] = [99]
# print(nums) # ValueError: attempt to assign sequence of size 1 to extended slice of size 3
nums[::2] = [99] * 3
print(nums) # [99, 99, 99, 36, 99, 65]
4. 列表的遍历
方式1：直接遍历获取元素
for 变量名 in 列表: 操作方式2：使用range生成下标数列，根据下标获取元素
for 变量名 in range(len(列表)): 操作方式3：enumerate枚举遍历序列
对序列操作完成时候 会生成一个新的序列，这个序列中的元素是一个二元组
(下标, 元素)
# 直接遍历元素
words = ['hello', 'enumerate', 'length', 'operator', 'expression', 'sort']
for w in words:
print(w)
# 过滤 要获取长度在6以上的单词
'''
肯定要接收结果的，由于结果是有多个的 肯定得定义一个容器来接收
1. 定义一个空列表
2. 遍历列表
3. 按照需求判断 找到符合要求的数据 把数据添加在列表中
+= 在当前列表的基础上 追加其他序列中的元素
'''
greatest_6 = []
# 遍历
for w1 in words:
if len(w1) > 6:
# greatest_6 += [w1] # 加上中括号的原因 是因为得把w1当做整体数据 追加在greatest_6中 w1得放在一个序列中
# append
greatest_6.append(w1) # 列表中提供的追加元素的操作
print(greatest_6)
# 转换 把列表中的每个单词 转换成首字母大写 其他字母小写
new_words = []
for w2 in words:
new_words.append(w2.title())
print(new_words)
# ['Hello', 'Enumerate', 'Length', 'Operator', 'Expression', 'Sort']
nums = [18, 29, 33, 56]
# 将nums中元素 通过+拼接在一起
str_nums = []
for ele in nums:
str_nums.append(str(ele))
print(str_nums) # ['18', '29', '33', '56']
res = '+'.join(str_nums)
print(res) # 18+29+33+56
nums1 = [77, 56, 39, 28, 41, 63, 55]
# 质数【在大于1的自然数中 只有1和本身这两个因数的数据为质数】
'''
在2到本身-1之间不存在因数 这种数是质数
'''
# 找到nums1中质数的下标 【列表是可以通过下标定位到元素的】
for i in range(len(nums1)):
# print(nums1[i]) # 判断nums1[i]是不是质数
# 设置一个标记 假设是
flag = True
# 遍历获取2-本身-1之间的数据
for v in range(2, int(nums1[i] ** 0.5) + 1):
if nums1[i] % v == 0:
# 这里就找到了1和本身之外的因数了
flag = False
break
# 结束验证 看一下flag标记的值
# 假设没有被推到 假设成立 这个数据就是质数
if flag is True:
print(i)
for pos, ele1 in enumerate(nums1):
# 设置一个标记 假设ele1持有的数据是质数
flag = True
# 遍历获取2-本身-1之间的数据
for v in range(2, int(ele1 ** 0.5) + 1):
if ele1 % v == 0:
# 这里就找到了1和本身之外的因数了
flag = False
break
# 结束验证 看一下flag标记的值
# 假设没有被推到 假设成立 这个数据就是质数
if flag is True:
print(pos)
5. 列表的操作
nums = [23, 71, 29, 77, 83, 23, 14, 51, 79, 23]
# 1. 添加数据的操作
# 在末尾追加数据
res = nums.append(17)
print(res) # None 列表是一个可变的数据 相关操作没有产生新的内容 影响的都是原数据 所以拿到的是None
print(nums) # 看操作有没有影响 看原数据
# [23, 71, 29, 77, 83, 23, 14, 51, 79, 23, 17]
# 在指定下标的位置添加数据 该位置及其之后的数据会向后移动一位
nums.insert(1, 80)
print(nums) # [23, 80, 71, 29, 77, 83, 23, 14, 51, 79, 23, 17]
nums.insert(-2, 77)
print(nums) # [23, 80, 71, 29, 77, 83, 23, 14, 51, 79, 77, 23, 17]
# 合并其他序列的元素 等同于+=
nums.extend(range(7, 100, 7))
print(nums)
# [23, 80, 71, 29, 77, 83, 23, 14, 51, 79, 77, 23, 17, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]
# 2. 删除的操作
# 删除末尾的元素 返回的是被删掉的数据
value = nums.pop()
print(value) # 98
print(nums) # [23, 80, 71, 29, 77, 83, 23, 14, 51, 79, 77, 23, 17, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91]
# 删除指定索引位置的元素 【删除该位置的元素 后面的元素会补位】
value = nums.pop(1)
print(nums, value)
# [23, 71, 29, 77, 83, 23, 14, 51, 79, 77, 23, 17, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91] 80
# 删除指定元素 【如果没有这个元素 会报错 如果这个元素是重复的 删除是查找到第一个】
# nums.remove(99) # ValueError: list.remove(x): x not in list
nums.remove(23)
print(nums)
# [71, 29, 77, 83, 23, 14, 51, 79, 77, 23, 17, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91]
# 清空列表
# nums.clear()
# print(nums) # []
# 3. 获取相关的操作
# 3.1 获取元素在指定的范围内第一个出现的位置
'''
列表数据.index(数据, 起始位置, 结束位置)
如果找不到 报错
'''
pos = nums.index(23)
print(pos) # 4
pos = nums.index(23, 5)
print(pos) # 9
# pos = nums.index(23, 5, 9)
# print(pos) # ValueError: 23 is not in list
# 3.2 获取元素在列表中出现的次数
'''
列表数据.count(数据)
'''
count = nums.count(23)
print(count) # 2
# 3.3 获取列表中元素的最大值
'''
max(序列) --- 获取序列中最大的元素
打包这个名词 多个数据用逗号分开 会把数据打包成元组
'''
print(max(nums)) # 91
print(max('good')) # o
# 获取多个数据中的最大值 最小值
print(max(19, 34, 56, 72, 38)) # 72
# 3.4 获取列表中元素的最小值
'''
min(序列) --- 获取序列中最小的元素
'''
print(min(nums)) # 7
print(min(19, 34, 56, 72, 38)) # 19
# 4.其他的操作
# 4.1拷贝列表
copy_nums = nums.copy()
print(copy_nums)
print(id(nums), id(copy_nums))
# 4.2 对列表的元素按照大小进行排序
# nums.sort() # 升序排序
# print(nums)
# # [7, 14, 14, 17, 21, 23, 23, 28, 29, 35, 42, 49, 51, 56, 63, 70, 71, 77, 77, 77, 79, 83, 84, 91]
# nums.sort(reverse=True) # 升序之后是否反转 是的话 就变成降序了 默认是False
# print(nums)
# [91, 84, 83, 79, 77, 77, 77, 71, 70, 63, 56, 51, 49, 42, 35, 29, 28, 23, 23, 21, 17, 14, 14, 7]
# 4.3 对列表的内容进行反转
'''
和切片反转的区别:
切片反转生成是新的列表
而这个操作是影响的原列表
'''
new_nums = nums[::-1]
print(new_nums)
print(id(new_nums), id(nums))
nums.reverse()
print(nums)
5. 列表推导式
理解成对列表过滤或者转换格式的简化，虽然说是简化，但是它要比
append操作效率要高对数据进行过滤
[变量 for 变量 in 序列 if 判断条件]对数据进行转换
[对变量转换之后数据 for 变量 in 序列]
'''
2. 已知一个数字列表`nums = [1, 2, 3, 4, 5]`， 编写程序将列表中所有元素乘以2
'''
nums = [1, 2, 3, 4, 5]
pow_nums = []
for ele in nums:
pow_nums.append(ele * 2)
print(pow_nums) # [2, 4, 6, 8, 10]
# 列表推导式
new_nums = [ele * 2 for ele in nums]
print(new_nums)
nums = [19, 23, 45, 67]
# 用+号把数据拼在一起 使用的是字符串的join
res = '+'.join([str(ele) for ele in nums])
print(res)
'''
3. 列表中存储学生的成绩`scores = [98, 67, 56, 77, 45, 81, 54]`，去除掉不及格的成绩
'''
scores = [98, 67, 56, 77, 45, 81, 54]
# 保留及格
pass_scores = []
for sc in scores:
if sc >= 60:
pass_scores.append(sc)
print(pass_scores)
# 列表推导式
pass_scores1 = [sc for sc in scores if sc >= 60]
print(pass_scores1)
'''
1. `There is no denying that successful business lies in a healthy body and mind`提取这句话中包含`i`的**单词**
'''
s = 'There is no denying that successful business lies in a healthy body and mind'
# 切割
words = s.split()
print(words)
i_words = [w for w in words if 'i' in w]
print(i_words)
'''
5. `names = ['lucy', 'lulu', 'john', 'rose', 'hanmeimei', 'lili', 'rosum']`
1. 查找列表中包含`o`的名字
2. 查找列表中以`r`开头的名字
3. 查找列表中长度在4个以上的名字
'''
names = ['lucy', 'lulu', 'john', 'rose', 'hanmeimei', 'lili', 'rosum']
o_names = [name for name in names if 'o' in name]
r_names = [name for name in names if name.startswith('r')]
greatest_4_names = [name for name in names if len(name) > 4]
print(o_names, r_names, greatest_4_names)
总结：
列表：可以容纳多个元素（上限为2**63-1、9223372036854775807个）、可以容纳不同类型的元素（混装）、数据是有序存储的（有下标序号）、允许重复数据存在、可以修改（增加或删除元素等）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
