List
基础知识
- 有序集合和无序集合
- 含义： 有序或者无序并不是指顺序或者排序，而是指集合中的每一个元素都有自己的位置，有自己的位置意味着我们可以通过元素的位置来直接访问这个元素，这个所谓的位置就是下标，要注意下标是从0开始的（大多数情况下是这样的，因为你是程序员）
- python中的有序集：list(列表); tuple(元组)
- python中的无序集：set(集合);dictionary(字典)
- list 的基本特性
- 1)list是Python中常用的一个变量类型,一个list是指一个用 [ ] 将所有元素括起来的集合体(包含中括号本身和中括号内的所有元素)
- 2)一个list中的不同元素之间使用 逗号 隔开
- 3)同一个list中的元素类型可以相同,也可以不同
str1 = "abc" # 字符串变量
str2 = 'a' # 字符串
tuple1 = ('a','b','c') # 元组
dic = {'a':'1','b':'2'} # 字典
set1 = {"a",1,2,3} # 集合
list0 = [1, 2, 3] # 列表
# 前面提到同一个list中的元素类型可以是不相同的
# 通常,list中可以存放的类型有 字符串, 字符, 整形, 浮点型, list, tuple, set, dictionary 及 这些类型的变量.
list1 = [str1, str2, tuple1, dic, set1] #把上面提到的所有类型的变量存放在同一个list中
print(list1)
#输出结果
#['abc', 'a', ('a', 'b', 'c'), {'a': '1', 'b': '2'}, {'a', 1, 2, 3}]
list2 = ["abc", 'a', 1, 2.0, str1, ('a','b','c'), {'a':'1','b':'2'}, {"a",1,2,3}, [1, 2, 3]] # 将上面的所有类型的非变量形式 + 一个变量 存放在同一个list中;这个变量可以是上面提到的所有类型的变量,数目也可以更多
print(list2)
#输出结果
#['abc', 'a', 1, 2.0, 'abc', ('a', 'b', 'c'), {'a': '1', 'b': '2'}, {'a', 1, 2, 3}, [1, 2, 3]]
# 通过上面的实例可以看出
# 一般情况下,只要某种类型的数据可以存放在list中,那么这种类型的变量也可以存放在list中.
# 变量和非变量可以混着来.
函数
- list()
- 简介: 使用list()函数可以创建list
- 使用: list1 = list(var)
- list 的参数可以为列表(list),元组(tuple),集合(set),字典(dictionary),字符,字符串,不能是单独的整数和浮点数
- 和list()函数对应的创建列表的方法就是直接使用中括号创建a = [var]; [var]中的var就是列表中可以存放的类型的元素,上面已经提到过.
a = list() # 如果参数为空就是创建空列表
b = list([1,2,3]) # 参数可以是列表
c = list((1,2,3)) # 参数可以是元组
d = list({1,2,3}) # 参数可以是集合
e = list({'1':1,2:'2'}) # 参数可以是字典
print(a,'\n',b,'\n',c, '\n', d, '\n', e)
# 输出结果
# []
# [1, 2, 3]
# [1, 2, 3]
# [1, 2, 3]
# ['1', 2] 这个可能是会比较迷惑的,这个是将字典传入list()中的输出结果,字典为:{'1':1,2:'2'};{}中的逗号是元素之间的分割符,也就是说{'1':1,2:'2'}中有两个元素,每一个元素由一个键(key)(冒号前面的),一个冒号,一个值(value)(冒号之后的)组成;具体有关字典的将会在以后的Blog里介绍.
# 言归正传,当参数为字典时,会把字典的键输出.
--------------------------------------------------------------------------------------
# 下面的是直接使用[]创建列表
a1 = [] # 空列表
b1 = [(1, 2, 3)]
c1 = [{1, 2, 3}]
d1 = [{'1':1, 2:'2'}]
print(a1, '\n', b1, '\n', c1, '\n', d1)
# 输出
# []
# [(1, 2, 3)]
# [{1, 2, 3}]
# [{'1': 1, 2: '2'}]
# 使用[]创建列表时,基本都会讲元素原貌输出.
--------------------------------------------------------------------------------------
# 需要注意的几个点
a2 = list(1)
print(a2)
# 输出报错
# TypeError: 'int' object is not iterable
a3 = list(1.0)
print(a3)
# 输出报错
# TypeError: 'float' object is not iterable
# 根据报错的提示看,int和float类型不能作为list() 的参数,因为它们是不可迭代的.
# 可迭代就是可以遍历的,每次可以返回其中的几个元素,例如list, tuple等就是.
# 它们一般都具有__getitem__()等内置的函数.
a4 = list('a')
a5 = list("abc")
b2 = ['a']
b3 = ["abc"]
print(a4, '\n', a5, '\n', b2, '\n', b3)
# 输出结果
# ['a']
# ['a', 'b', 'c'] 一个字符串包含很多字符,list(string)会将字符串中的每个字符都作为列表的一个元素.
# ['a']
# ['abc'] 对比就可以发现,[] 还是像上面说的会按照原样输出.
- append()
- 简介: append()函数的作用是将一个元素添加到列表的末尾处
- 使用: a.append(var)
a = [1, 2, 3]
a.append(1)
print(a)
# [1, 2, 3, 1] 将1添加在a的末尾
b = a.append(2)
print(b)
# None
# 因为append函数是讲元素添加到原列表的末尾,所以没有返回值,所以上面给b赋值时,并不是用新的列表a来给b赋值.
- extend()
- 简介: 将一个列表拼接到另一个列表上
- 使用: a.extend(b)
a = [1, 2, 3]
print(id(a))
b = [1, 2, 3]
a.extend(b)
print(id(a))
print(a)
# 输出
# 140249465492016
# 140249465492016 a的地址没有改变,所以是在列表a的原存储位置添加新元素,并不是开辟新的空间创建新的列表,所以也没有返回值
# [1, 2, 3, 1, 2, 3]
- insert()
- 简介: 在指定的位置处插入指定元素, 如果下标超出范围将会报错
- 使用: a.insert(index, num)
a = [1, 2, 3]
a.insert(0, 0)
print(a)
# [0, 1, 2, 3] 仍旧是在原列表中,不会创建新的列表,无返回值
- remove()
- 简介:删除指定元素,如果不存在指定的元素就报错
- 使用: a.remove(num)
a = [1, 2, 3]
a.remove(1)
print(a)
# [2, 3] 仍旧是在原列表中,不会创建新的列表,无返回值
- pop()
- 简介: 指定下标处的值从列表中删除,并且将删除的这个值作为返回值,不指定时,默认删除列表最后一个值
- a.pop(index)
a = [1, 2, 3]
b = a.pop() # 将末尾的3删除,并且将3返回
print(a)
# [1, 2]
print(b)
# 3
a.pop(1)
print(a)
# [1] 指定index,删除指定位置的值,并将其作为返回值
- clear()
- 简介:将列表的元素全部删除,只剩下一个空列表,也是在原地址处修改,没有返回值
- 使用: a.clear()
a = [1, 2, 3]
b = a.clear()
print(a)
print(b)
# []
# None
- index()
- 简介: 返回指定值的下标,如果有多个相同的值,只返回第一个出现的下标
- 使用: a.index(num)
a = [3, 2, 1, 1, 1]
index = a.index(1)
print(index)
# 2 最早出现的1的下标为2
- count()
- 简介:计算列表中某个元素出现的次数
- 使用: a.count(num)
a = [1, 2, 3, 4, 5, 1, 2, 3, 1]
b = a.count(1)
print(b)
# 3
- sort()
- 简介: 将列表排序
- 使用: a.sort()
# 注意:int和str类型之间不能排序
a = [3, 2, 1, 5, 5.0]
a.sort()
print(a)
# [1, 2, 3, 5, 5.0]
a.sort(reverse=True) # reverse默认为False表示升序,True为降序
print(a)
# [5, 5.0, 3, 2, 1]
b = ['a', 'b', 'c']
b.sort()
print(b)
# ['a', 'b', 'c']
- reverse()
- 简介:将列表倒序,但不会进行排序操作.
- 使用: a.reverse()
a = [1, 2, 3, 1, 2, 3]
a.reverse()
print(a)
# [3, 2, 1, 3, 2, 1]
切片
- 在一开始说过,列表是可以使用索引来获取列表中的某个值,既然可以获取一个值,那么就可以同时获取几个值,所以列表切片就来了.
# [start:end:step]
# start:起始的下标; end:终止的下标; step:步长(默认为1)
a = [1, 2, 3, 4, 5] # 创建一个列表
b = a[0] # 获取第一个元素
print(b)
# 1
c = a[-1] # 获取最后一个元素
print(c)
# 5
# 下标(索引)从左到右为0,1,2...; 从右到左为-1,-2,-3...
a1 = a[1:3]
a2 = a[1:3:1]
print(a1, '\n', a2)
# [2, 3]
# [2, 3] step默认为1;
a3 = a[1:4:1]
print(a3)
# 输出
# [2, 3, 4] 可以看出只会输出从下标从1-3的值,而下标为end的值不会输出,切片时不会包括下标为end的值
a4 = a[1:4:2]
print(a4)
# 输出
# [2, 4] step为2,第一步为下标1,下一步下标就是3,so
a5 = a[4:1:-1]
print(a5)
# 输出
# [5, 4, 3] 当step为负数时,start必须大于等于end,当step为正数时(同号,因为允许正负数同时使用,所以不同号时转化成同号再判断是否合理),start必须小于等于end,否则会输出空列表[];
# 以step为负数解释:
# a = [1, 2, 3, 4, 5]
# 下标 0 1 2 3 4
# 下标 -5 -4 -3 -2 -1
# 每一个位置都对应两个唯一的下标
# 所以当step为负数时,要从右到左读,所以先读下标为4的值,再读下标为3的值,如果是下面的a5_2的这种形式,要从下标为1往左读,但是我们要取的值要往右读才行.所以这种情况下就会输出[];
a5_2 = a[1:4:-1]
print(a5_2)
# 输出
# []
a6 = a[:]
print(a6)
# 输出
# [1, 2, 3, 4, 5]
a7 = a[::]
print(a7)
# 输出
# [1, 2, 3, 4, 5]
# 发现a6,a7都是输出列表的所有元素,因为不给start和end赋值时,默认最开头和最结尾,而且包括结尾处的值
# a6, a7 之所以输出结果相同,是因为它们都采用了默认的值
a8 = a[:-1]
print(a8)
# 输出
# [1, 2, 3, 4]
a9 = a[::-1]
print(a9)
# 输出
# [5, 4, 3, 2, 1]
# 观察a8,a9可能会有小小的疑问,为什么输出不同,那是因为a8的-1在第一个冒号之后,是赋值给end的值,而a9中的-1是赋值给step的值.
拷贝
赋值拷贝
import copy # 要用到这个库里的函数
a1 = [1, 2, 3]
b1 = a1
print(a1, ":", id(a1), '\n', b1, ":", id(b1))
#[1, 2, 3] : 139883440293840
# [1, 2, 3] : 139883440293840
# 可以看到b1和b2的地址是相同的,赋值拷贝就是这样,共享内存,不再重新为b1分配空间
a2 = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
b2 = a2
print(a2, ":", id(a2), "\n", b2, ":", id(b2))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139883412640944
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139883412640944
print(a2[2], ":", id(a2[2]), "\n", b2[2], ":", id(b2[2]))
# [7, 8, 9] : 139883412641744
# [7, 8, 9] : 139883412641744
# 对于嵌套列表(二维或者多为数组),不仅最外层的列表的地址相同,内部的每一个列表的地址也是相同的,也就是a2和b2是共享内存的.
浅层拷贝
# 使用下面这三种方式进行拷贝属于浅层拷贝,其特点就是: 对于一维列表,是重新分配空间的,但是多维列表(数组)只有最外层是重新分配的,但是内部的其他层就还是共享内存空间的.
a1 = [1, 2, 3]
c1 = a1[::]
print(a1, ":", id(a1), '\n', c1, ":", id(c1))
# [1, 2, 3] : 139691770415216
# [1, 2, 3] : 139691770619456 地址不同
h1 = copy.copy(a1)
print(a1, ":", id(a1), '\n', h1, ":", id(h1))
# [1, 2, 3] : 139691770415216
# [1, 2, 3] : 139691770620336 地址不同
f1 = a1.copy()
print(a1, ":", id(a1), "\n", f1, ":", id(f1))
# [1, 2, 3] : 139691770415216
# [1, 2, 3] : 139691770620416 地址不同
a2 = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
c2 = a2[::]
print(a2, ":", id(a2), "\n", c2, ":", id(c2))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139691770619936
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139691770620656 # (浅层)最外层地址不同
print(a2[2], ":", id(a2[2]), "\n", c2[2], ":", id(c2[2]))
# [7, 8, 9] : 139691770620496
# [7, 8, 9] : 139691770620496 # 深层地址相同(多维类推)
# 可以a2这样考虑:
# a2 = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]
# 地址1 地址1_1 地址1_2 地址1_3
# 上面所说的就是a2和b2的地址1不同, 而地址1_1,1_2,1_3相同
h2 = copy.copy(a2)
print(a2, ":", id(a2), "\n", h2, ":", id(h2))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139691770619936
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139691770620816
print(a2[2], ":", id(a2[2]), "\n", h2[2], ":", id(h2[2]))
# [7, 8, 9] : 139691770620496
# [7, 8, 9] : 139691770620496
f2 = a2.copy()
print(a2, ":", id(a2), "\n", f2, ":", id(f2))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139691770619936
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139691770620896
print(a2[2], ":", id(a2[2]), "\n", f2[2], ":", id(f2[2]))
# [7, 8, 9] : 139691770620496
# [7, 8, 9] : 139691770620496
深层拷贝
# 深层拷贝需要用到函数copy.deepcopy(), 所有层的地址都不同,全部重新分配
a3 = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
b3 = copy.deepcopy(a3)
print(a3, ":", id(a3), "\n", b3, ":", id(b3))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139762690648016
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]] : 139762690648096 地址不同
print(a3[1], ":", id(a3[1]), "\n", b3[1], ":", id(b3[1]))
# [4, 5, 6] : 139762690647136
# [4, 5, 6] : 139762690648256 地址不同
a4 = [1, 2, 3]
b4 = copy.deepcopy(a4)
print(a4, ":", id(a4), "\n", b4, ":", id(b4))
# [1, 2, 3] : 139762690648416
# [1, 2, 3] : 139762690648336 地址不同
概括
- 赋值拷贝—>浅层拷贝—>深层拷贝
- 全相同----->部分相同----->全不同
列表推导式
- 简单介绍: 列表表达式是创建列表的一种方式,这种方式创建列表代码更加简洁,主要使用循环语句和条件语句.
# range(start, end, step) 不包含end,start默认为0, step默认为1
a = [x for x in range(1, 10)]
print(a)
# [1, 2, 3, 4, 5, 6, 7, 8, 9] 不包括最后一个值10,从1-9
# 上面的列表表达式等价于
# a = []
# for x in range(1, 10):
# a.append(x)
b = [x for x in range(1,10) if x % 2 == 0]
print(b)
# [2, 4, 6, 8]
# 上面的表达式等价于
# a = []
# for x in range(1, 10):
# if x % 2 == 0:
# b.append(x)
c = [x if x % 2 == 0 else 0 for x in range(1, 10)]
print(c)
# [0, 2, 0, 4, 0, 6, 0, 8, 0]
# if在for之前.必须指定else
# 上面的表达式等价于
# a = []
# for x in range(1, 10):
# if x % 2 == 0:
# c.append(x)
# else:
# c.append(0)
d = [x for x in range(5) for y in range(3)]
print(d)
# 当有多个for循环时,从前之后的嵌套
# 上面的表达式等价于
# d = []
# for x in range(5):
# for y in range(3):
# d.append(x)
# [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]
e = [(x, y) for x in range(5) for y in range(3)]
print(e)
# 上面的表达式等价于
# e = []
# for x in range(5):
# for y in range(3):
# e.append((x, y))
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2)]
f = [[x for x in range(y, 5)] for y in range(3)]
print(f)
# 当列表嵌套时,相当于从外层列表到内层列表嵌套,相当于创建多为列表
# 上面的表达式等价于
# f = [[],[],[]]
# for y in range(3):
# for x in range(y, 5):
# f[y].append(x)
# [[0, 1, 2, 3, 4], [1, 2, 3, 4], [2, 3, 4]]
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
