乐趣区

关于python:学习Python列表只需这篇文章就够了

千里之行,始于足下。要练成一双洞悉所有的眼睛,还是得先把基本功扎扎实实地学好。明天,带大家认真复习一下 Python 的列表。温故而知新,不亦说乎。

当然,复习的同时也要发散思考,因为有些看似无关紧要的、约定俗成的语言习惯,例如数组索引为何从 0 开始,其背地可能大有来历。知其然,亦需知其所以然

最初,在基础知识之上,更要摸索进阶,例如学习生成器表达式,这样既能更扎实地把握根底,又能死记硬背,取得更全面的认知降级。

Python 的列表是怎么滴?
列表(list)是一种有序的汇合,能够随时增加、查找和删除元素。

列表反对退出不同数据类型的元素:数字、字符串、列表、元组等。

列表通过有序的索引可遍历所有的元素,从前往后数,索引是[0,n-1],从后往前数,索引是[-1, -n],其中 n 是列表的长度。

列表能够是不含元素的空列表,也能够蕴含超级多的元素(在内存大小反对的状况下)。

list_a = []   # 空列表,即 len(list_a) == 0
list_b = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]

# list_b 长度为 5,蕴含 2 个数字元素、1 个字符串元素、1 个列表元素和 1 个元组元素
len(list_b) == 5
list_b[0] == list_b[-5] == 2018
lits_b[3] == list_b[-2] == ['hi', 1, 2] 
lits_b[4] == list_b[-1] == (33, 44)

Python 中怎么操作列表?
1)创立列表:

用中括号 [] 包裹元素,元素应用逗号分隔。

用 list()办法,转化生成列表。

列表生成式 / 列表解析式 / 列表推导式,生成列表。

list_a = [1, 2, 3]
list_b = list("abc") # list_b == ['a', 'b', 'c']
list_c = list((4, 5, 6)) # list_c == [4, 5, 6]
list_d = [i for i in list_a]  # list_d == [1, 2, 3]
list_e = [i*j for i in list_a for j in list_c] # list_e == [4,5,6,10,12,12,15,18]
list_f = [i*j for i,j in zip(list_a,list_c)] # list_f == [4, 10, 18]
list_g = [i for i in list_a if i%2 == 0] # list_g == [2]

# 联合 range()函数,range(start, stop[, step])
list_h = list(range(3)) # list_h == [0, 1, 2]
list_i = list(range(3,7)) # list_i == [3, 4, 5, 6]
list_j = list(range(3,9,2)) # list_j == [3, 5, 7]

# 找出 100 以内的可能被 3 整除的正整数
list_k = list(range(3,100,3)) # list_k == [3, 6, 9, ..., 96, 99]

2)裁减列表:

用 append()办法,在列表尾部增加单个新元素。

用 insert()办法,在列表中指定地位增加元素。

用“+”运算符,将两个列表拼接出一个新列表。

用 extend()办法,在一个列表前面拼接进另一个列表。

# 以下别离增加 2 个元素
list_a = []
list_a.append('happy')  # list_a == ['happy']
list_a.insert(0, 'very') # list_a == ['very', 'happy']

# 以下两种裁减列表形式
list_1 = ['I', 'am']
list_2 = ['very', 'happy']
list_3 = list_1 + list_2  # 新列表 list_3 == ['I', 'am', 'very', 'happy']
list_1.extend(list_2)  # 原列表 1 裁减,list_1 == ['I', 'am', 'very', 'happy']

3)删减列表与销毁列表:

用 del list[m] 语句,删除指定索引 m 处的元素。

用 remove()办法,删除指定值的元素(第一个匹配项)。

用 pop()办法,取出并删除列表开端的单个元素。

用 pop(m)办法,取出并删除索引值为 m 的元素。

用 clear()办法,清空列表的元素。(杯子还在,水倒空了)

用 del list 语句,销毁整个列表。(杯子和水都没有了)

# 以下 4 种删除列表元素形式
list_1 = list_2 = list_3 = list_4 = ['I', 'am', 'very', 'happy']
del list_1[0]  # list_1 == ['am', 'very', 'happy']
list_2.remove('I') # list_2 == ['am', 'very', 'happy']
list_3.pop()  # list_3 == ['I', 'am', 'very']
list_4.pop(0)  # list_4 == ['am', 'very', 'happy']

# 清空与销毁
list_a = [1, 2, 3]
list_b = [1, 2, 3]
list_b.clear()   # list_b == []
del list_a   # 没有 list_a 了,再应用则会报错

4)列表切片:

根本含意:从第 i 位索引起,向右取到后 n 位元素为止,按 m 距离过滤

根本格局:[i : i+n : m];i 是切片的起始索引值,为列表首位时可省略;i+n 是切片的完结地位,为列表末位时可省略;m 能够不提供,默认值是 1,不容许为 0,当 m 为正数时,列表翻转。留神:这些值都能够大于列表长度,不会报越界。

li = [1, 4, 5, 6, 7, 9, 11, 14, 16]

# 以下写法都能够示意整个列表,其中 X >= len(li)
li[0:X] == li[0:] == li[:X] == li[:] == li[::] == li[-X:X] == li[-X:]

li[1:5] == [4,5,6,7] # 从 1 起,取 5 - 1 位元素
li[1:5:2] == [4,6] # 从 1 起,取 5 - 1 位元素,按 2 距离过滤
li[-1:] == [16] # 取倒数第一个元素
li[-4:-2] == [9, 11] # 从倒数第四起,取 -2-(-4)= 2 位元素
li[:-2] == li[-len(li):-2] == [1,4,5,6,7,9,11] # 从头开始,取 -2-(-len(li))= 7 位元素

# 留神列表先翻转,再截取
li[::-1] == [16,14,11,9,7,6,5,4,1] # 翻转整个列表
li[::-2] == [16,11,7,5,1] # 翻转整个列表,再按 2 距离过滤
li[:-5:-1] == [16,14,11,9] # 翻转整个列表,取 -5-(-len(li))= 4 位元素
li[:-5:-3] == [16,9] # 翻转整个列表,取 -5-(-len(li))= 4 位元素,再按 3 距离过滤

li[::0]  # 报错(ValueError: slice step cannot be zero)

5) 其它操作:

用 len()办法,统计全副元素的个数。

用 count()办法,统计指定值的元素的个数。

用 max()办法,统计元素中的最大值(要求元素类型雷同;数字类型间接比拟,其它类型比拟 id)

用 min()办法,统计元素中的最小值(要求元素类型雷同;数字类型间接比拟,其它类型比拟 id)

用 index()办法,查找指定值的元素的索引地位(第一个匹配项)。

用 reverse()办法,翻转列表中的元素。

用 copy()办法,浅拷贝并生成新的列表。

用 deepcopy()办法,深拷贝并生成新的列表。

用 sort()办法,在原列表根底上进行排序。

用 sorted()办法,将新列表根底上对原列表的元素进行排序。

list_1 = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
len(list_1) == 5
list_1.count(10) == 1 # 元素 10 的数量为 1
list_1.index(10) == 1 # 元素 10 的索引为 1
list_1.reverse() # list_1 == [(33, 44), ['hi', 1, 2], '2018-10-1', 10, 2018]

# 比拟浅拷贝与深拷贝
import copy
list_a = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
list_b = ['hi', 1, 2]
list_c = list_a.copy() # list_c == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
list_d = copy.deepcopy(list_a) # list_d == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]

# 扭转原列表中的可变对象元素
list_a[3].append('new') # list_a == [2018, 10, '2018-10-1', ['hi', 1, 2, 'new'], (33, 44)]

# 浅拷贝中的可变对象会随原列表变动而变动
list_c == [2018, 10, '2018-10-1', ['hi', 1, 2, 'new'], (33, 44)]

# 深拷贝中的可变对象不会随原列表变动而变动
list_d == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]

# 比拟 sort() 与 sorted()
list_1 = list_2 = [2,1,4,6,5,3]
list_1.sort() # 原列表变动:list_1 == [1,2,3,4,5,6]
list_3 = sorted(list_2) # 原列表不变:list_2 == [2,1,4,6,5,3]; list_3 == [1,2,3,4,5,6]

Python 列表索引为何从 0 始?
权威解释来自 Guido van Rossum(Python 之父)的博文:《Why Python uses 0-based indexing》

一句话总结:索引从 0 开始,切片用法很优雅。

翻译精髓如下:

我决定在 Python 中应用 0 -based 索引形式的一个起因,就是切片语法 (slice notation)。
让咱们来先看看切片的用法。可能最常见的用法,就是“取前 n 位元素”或“从第 i 位索引起,取后 n 位元素”(前一种用法,实际上是 i == 起始位的非凡用法)。如果这两种用法实现时能够不在表达式中呈现难看的 + 1 或 -1,那将会十分的优雅。
应用 0 -based 的索引形式、半开区间切片和缺省匹配区间的话(Python 最终采纳这样的形式),下面两种情景的切片语法就变得十分丑陋:a[:n]和 a[i:i+n],前者是 a[0:n]的缩略写法。
如果应用 1 -based 的索引形式,那么,想让 a[:n]表白“取前 n 个元素”的意思,你要么应用闭合区间切片语法,要么在切片语法中应用切片起始位和切片长度作为切片参数。半开区间切片语法如果和 1 -based 的索引形式联合起来,则会变得不优雅。而应用闭合区间切片语法的话,为了从第 i 位索引开始取后 n 个元素,你就得把表达式写成 a[i:i+n-1]。
……
特地是当两个切片操作地位邻接时,第一个切片操作的起点索引值是第二个切片的终点索引值时,太漂亮了,无奈舍弃。例如,你想将一个字符串以 i,j 两个地位切成三局部,这三局部的表达式将会是 a[:i],a[i:j]和 a[j:]。

其它编程语言的索引?
索引从 0 开始的编程语言:C、C++、Python、Java、PHP、Ruby、Javascript…

索引从 1 开始的编程语言:ABC、Matlab、VB、易语言、大部分 shell 语言 …

索引从其它值开始的编程语言:Pascal、Lua…

还有像示意星期、月份等序列构造的数据,各种编程语言也划分成了不同营垒。

它们出于何种思考?

C 语言:索引从 0 开始,能够大大晋升内存寻址计算的效率

大部分 shell 语言:大多数是从 1 开始

Pascal、Lua:默认从 1 开始,但反对扭转起始索引值,起因据说是对非专业的开发者更敌对

以上列举的起因是最审慎的、体面的解释,话题应该到此终结,因为“索引应该从几开始最好”这个问题的破坏性不亚于“哪种编程语言是最好的”……

优雅丑陋的结尾:生成器表达式

列表生成式是一种丑陋优雅的货色,然而它有一个致命的毛病:它一次性把所有元素加载到内存中,当列表过长的时候,便会占据过多的内存资源,而且,咱们通常仅须要应用多数的元素,这样未应用的元素所占据的绝大部分的内存,就成了不必要的收入。

生成器是一种更高级更优雅的货色,它应用“懒加载”的原理,并不生成残缺的列表,而是迭代地、即时地、按需地生成元素,这样不仅能极大地节俭内存空间,而且,在实践上,它能够生成一个无穷大的列表!

大多数生成器是以函数来实现的,然而,它并不返回(return)一个值,而是生成(yield)一个值,并挂起程序。而后,通过 next()办法生成并马上返回一个元素,或者通过 for 循环,逐个生成和返回全副元素。

next()效率太低,且调用次数越界时会抛出 StopIteration 的异样,而 for 循环会主动捕获这个异样,并进行调用,所以应用更佳。

# 计算斐波那契数列的生成器
def fibon(n):
a = b = 1
for i in range(n):
yield a  # 应用 yield
a, b = b, a + b

# 计算前 1000000 个数,通过 next()函数,按程序每次生成一个数
g = fibon(1000000)
next(g)  # 1
next(g)  # 1
next(g)  # 2
next(g)  # 3
next(g)  # 5
# 以此类推,但若调用超过 1000000 次,就会报异样 StopIteration

# 计算前 1000000 个数,通过 for 循环逐个打印生成数
for x in fibon(1000000):
print(x)

生成器表达式与列表生成式极其形似,只是把 [] 改成了(),但背地的原理大不相同。

l = [x*2 for x in range(5)]  # 列表生成式,4 以内整数的 2 倍数
g = (x*2 for x in range(5))  # 生成器表达式
type(l)   # 后果:<type 'list'>
type(g)   # 后果:<type 'generator'>

print(l)  # 后果:[0,2,4,6,8]
print(g)  # 后果:<generator object at 0x000002173F0EBC50>
next(g)   # 0
next(g)   # 2
next(g)   # 4
next(g)   # 6
next(g)   # 8
next(g)   # Traceback (most recent call last): ....StopIteration

for x in g:
print(x, end=' ')  # 后果:0 2 4 6 8

以上就是本次分享的所有内容,想要理解更多 python 常识欢送返回公众号:Python 编程学习圈 ,发送“J”即可收费获取,每日干货分享

退出移动版