# 列表概念：有序的可变的元素集合
# 定义
# 直接定义
nums = [1,2,3,4,5]
# 通过range函数构造，python2 和python3 版本之间的差异；
# python3 用的时候才会去构造
nums = range(1,101)
# 列表嵌套
# 注意和C语言中数组的区别,是否可以存放不同的数据类型
nums = [1,2,"ab","1",True,["a","b","c"]]
# 列表赋值给另外一个列表
# 原始的方式
nums = [1,2,3,4,5]
resultList = []
for num in nums:
resultList.append(num ** 2)
print(resultList) # [1, 4, 9, 16, 25]
# 列表推导式
nums = [1,2,3,4,5]
# [表达式 for 变量 in 列表]
resultList = [num ** 2 for num in nums]
print(resultList) # [1, 4, 9, 16, 25]
# [表达式 for 变量 in 列表 if 条件]
resultList = [num ** 2 for num in nums if num % 2 != 0]
print(resultList) # [1, 9, 25]
# 列表的增，删，改，插
#-------------------------------------增------------------------------------#
# append
# 作用
# 往列表中, 追加一个新的元素
# 在列表的最后
# 语法
# l.append(object)
# 参数
# object
# 想要添加的元素
# 返回值
# None
# 注意
# 会直接修改原数组
nums = [1, 2, 3, 4]
nums.append(5) # 无返回值 none
print(nums) # [1, 2, 3, 4, 5]
# insert
# 作用
# 往列表中, 追加一个新的元素
# 在指定索引前面
# 语法
# l.insert(index, object)
# 参数
# index
# 索引, 到时会插入到这个索引之前
# object
# 想要添加的元素
# 返回值
# None
# 注意
# 会直接修改原数组
nums = [1, 2, 3, 4]
nums.insert(2, 5)
print(nums) # [1, 2, 5, 3, 4]
# extend
# 作用
# 往列表中, 扩展另外一个可迭代序列
# 语法
# l.extend(iterable)
# 参数
# iterable
# 可迭代集合
# 字符串
# 列表
# 元组
# ...
# 返回值
# None
# 注意
# 会直接修改原数组
# 和append之间的区别
# extend可以算是两个集合的拼接
# append是把一个元素, 追加到一个集合中
nums = [1, 2, 3, 4]
nums2 = ["a", "b", "c"]
nums.extend(nums2)
print(nums) # [1, 2, 3, 4, ‘a‘, ‘b‘, ‘c‘]
# 乘法运算
# ["a"] * 3
# =
# [‘a‘, ‘a‘, ‘a‘]
nums = [1, 2]
print(nums * 2) # [1, 2, 1, 2]
# 加法运算
# ["a"] + ["b", "c"]
# =
# ["a", "b", "c"]
# 和extend区别
# 只能列表类型和列表类型相加
n1 = [1, 2]
n2 = ["a", "b"]
n3 = ["abc", "cdf"]
print(n1 + n2); #[1, 2, ‘a‘, ‘b‘]
print(n1 + n3); #[1, 2, ‘abc‘, ‘cdf‘]
# ------------------------------------------删------------------------------#
# del 语句
# 作用
# 可以删除一个指定元素(对象)
# 语法
# del 指定元素
# 注意
# 可以删除整个列表
# 删除一个变量
# 也可以删除某个元素
nums = [1, 2, 3, 4]
del nums[1]
print(nums) # [1, 3, 4]
#del nums #这样也行
#print(nums)#程序会报错
# pop
# 作用
# 移除并返回列表中指定索引对应元素
# 语法
# l.pop(index=-1)
# 参数
# index
# 需要被删除返回的元素索引
# 默认是-1
# 也就对应着列表最后一个元素
# 返回值
# 被删除的元素
# 注意
# 会直接修改原数组
# 注意索引越界
nums = [1, 2, 3, 4]
nums.pop() #默认-1
print(nums)
# remove
# 作用
# 移除列表中指定元素
# 语法
# l.remove(object)
# 参数
# object
# 需要被删除的元素
# 返回值
# None
# 注意
# 会直接修改原数组
# 如果元素不存在
# 会报错
# 若果存在多个元素
# 则只会删除最左边一个
# 注意循环内删除列表元素带来的坑
nums = [1, 2, 2, 3, 4]
nums.remove(2) #则只会删除最左边一个
print(nums) #[1, 2, 3, 4]
# ---------------------------------------------改----------------------------------------#
# names[index] = 666
nums = [1, 2, 3]
nums[1] = 5
print(nums) #[1, 5, 3]
#--------------------------------------------- 查----------------------------------------#
# 获取单个元素
# items[index]
# 注意负索引
nums = [1, 2, 3]
print(nums[-1]) # 3
# 获取元素索引
# index()
nums = [1, 2, 5, 3, 4]
print(nums.index(5)) # 2
# 获取指定元素个数
# count()
nums = [1, 2, 5, 2, 3, 4]
print(nums.count(2) ) #2
# 获取多个元素
# 切片
# items[start:end:step]
# 遍历
# 方式1
# 根据元素进行遍历
# for item in list:
# print(item)
# 方式2
# 根据索引进行遍历
# for index in range(len(list)):
# print(index, list[index])
# 方式3(了解)
# 创建对应的枚举对象
# 概念
# 通过枚举函数, 生成的一个新的对象
# 作用
# 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
# 同时列出数据下标和数据
# 语法
# enumerate(sequence, [start=0])
# sequence -- 一个序列、迭代器或其他支持迭代对象。
# start -- 下标起始位置。
# 举例
# l = ["a", "b", "c"]
# enumerate(l, 1)
# 一个待枚举的对象
# 转换成为list之后, 具体数据如下
# [(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]
# 遍历枚举对象
# for index, value in 枚举对象:
# print(index, value)
# 方式4(了解)
# 使用迭代器进行遍历
# iterL = iter(list)
# for item in iterL:
# print(item)
# 访问集合的方式-迭代器
# 概念
# 迭代
# 是访问集合元素的一种方式
# 按照某种顺序逐个访问集合中的每一项
# 可迭代对象
# 能够被迭代的对象, 称为可迭代对象
# 判定依据
# 能作用于for in
# 判定方法
# import collections
# isinstance(obj, collections.Iterable)
# 迭代器
# 是可以记录遍历位置的对象
# 从第一个元素开始, 往后通过next()函数, 进行遍历
# 只能往后, 不能往前
# 判定依据
# 能作用于next()函数
# 判定方法
# import collections
# isinstance(obj, collections.Iterator)
# 注意
# 迭代器也是可迭代对象, 所以也可以作用于for in
# 为什么会产生迭代器?
# 1. 仅仅在迭代到某个元素时才处理该元素
# 在此之前, 元素可以不存在
# 在此之后, 元素可以被销毁
# 特别适合用于遍历一些巨大的或是无限的集合
# 例如 "菲波那切数列"
# 2. 提供了一个统一的访问集合的接口
# 可以把所有的可迭代对象, 转换成迭代器进行使用
# iter(Iterable)
# iter(str)
# iter(list)
# iter(tuple)
# iter(dict)
# ...
# 迭代器简单使用
# 使用next()函数, 从迭代器中取出下一个对象, 从第1个元素开始
# 因为迭代器比较常用, 所以在Python中, 可以直接作用于for in
# 内部会自动调用迭代器对象的next()
# 会自动处理迭代完毕的错误
# 注意事项
# 如果取出完毕,再继续取, 则会报错
# StopIteration
# 迭代器一般不能多次迭代
import collections
nums = [1, 2, 3]
result = isinstance(nums, collections.Iterable)
print(result) # True
result = isinstance(nums, collections.Iterator)
print(result) # Flase
# 转为迭代器
it = iter(nums)
for v in it:
print(v)
# 判定
# 元素 in 列表
# 元素 not in 列表
# 比较
# cmp()
# 内建函数
# 如果比较的是列表, 则针对每个元素, 从左到右逐一比较
# 左 > 右
# 1
# 左 == 右
# 0
# 左 < 右
# -1
# Python3.x不支持
# 比较运算符
# ==
# >
# <
# ...
# 针对每个元素, 从左到右逐一比较
# 排序
# 方式1
# 内建函数
# 可以对所有可迭代对象进行排序
# 语法
# sorted(itrearble, key=None, reverse=False)
# 参数
# itrearble
# 可迭代对象
# key
# 排序关键字
# 值为一个函数，此函数只有一个参数且返回一个值用来进行比较
# reverse
# 控制升序降序
# 默认False
# 升序
# 返回值
# 一个已经排好序的列表
# 列表类型
s = "cdefga"
result = sorted(s);
print(result) #[‘a‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘]
s = [2,3,1,4,5]
result = sorted(s, reverse = True)
print(result) #[5, 4, 3, 2, 1]
s = [("a", 16), ("a1",13), ("a2", 14)]
result = sorted(s)
print(result) #[(‘a‘, 16), (‘a1‘, 13), (‘a2‘, 14)]
#按元组的第一个元素来排序
def getKey(x):
return x[1]
result = sorted(s, key=getKey)
print(result) #[(‘a1‘, 13), (‘a2‘, 14), (‘a‘, 16)]
# 方式2
# 列表对象方法
# 语法
# list.sort(key=None, reverse=False)
# 参数
# key
# 排序关键字
# 值为一个函数，此函数只有一个参数且返回一个值用来进行比较
# reverse
# 控制升序降序
# 默认False
# 升序
s = [2,3,1,4,5]
res = s.sort()
print(res, s) # None [1, 2, 3, 4, 5] 注意和内建函数的方法不同点；
# 乱序
# 可以随机打乱一个列表
# 导入random模块
# import random
# random.shuffle(list)
import random
list = [1, 2, 3, 4, 5]
res = random.shuffle(list)
print(res, list) #None [4, 3, 5, 2, 1] 后面序列随机，修改原序列的本身
# 反转
# l.reverse()
list = [1, 2, 3, 4, 5]
res = list.reverse()
print(res, list) #None [5, 4, 3, 2, 1]
# 切片反转
# l[::-1]
list = [1, 2, 3, 4, 5]
res = list[::-1]
print(res, list) #[5, 4, 3, 2, 1] [1, 2, 3, 4, 5]
原文地址：https://www.cnblogs.com/delphiclub/p/8460575.html
时间： 2024-11-08 07:38:42