Python 列表List的定义及操作

#   列表概念：有序的可变的元素集合

#   定义
#   直接定义
nums = [1,2,3,4,5]

#   通过range函数构造，python2 和python3 版本之间的差异；
#   python3 用的时候才会去构造
nums = range(1,101)

#   列表嵌套
#   注意和C语言中数组的区别,是否可以存放不同的数据类型
nums = [1,2,"ab","",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]) #

#     获取元素索引
#         index()
nums = [1, 2, 5, 3, 4]
print(nums.index(5))  #

#     获取指定元素个数
#         count()
nums = [1, 2, 5, 2, 3, 4]
print(nums.count(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]