python的list使用

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

定义

直接定义

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?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]