软件网站建设的目的,免费自己设计房子的软件,为某网站做网站推广策划方案,企业建设网站的好处# 列表概念#xff1a;有序的可变的元素集合# 定义
# 直接定义
nums [1,2,3,4,5]# 通过range函数构造#xff0c;python2 和python3 版本之间的差异#xff1b;
# python3 用的时候才会去构造
nums range(1,101)# 列表嵌套
# 注意和C语言中数组的区别,是否可… # 列表概念有序的可变的元素集合# 定义
# 直接定义
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] 666nums [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, [start0])
# 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 collectionsnums [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, keyNone, reverseFalse)
# 参数
# 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, keygetKey)
print(result) #[(a1, 13), (a2, 14), (a, 16)]# 方式2
# 列表对象方法
# 语法
# list.sort(keyNone, reverseFalse)
# 参数
# 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
