当然,温习的同时也要发散思考,因为有些看似无关紧要的、约定俗成的语言习惯,例如数组索引为何从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',2] lits_b[4] == list_b[-1] == (33,44)
Python中怎么操作列表?
1)创建列表:
用中括号[]包裹元素,元素使用逗号分隔。
list_a = [1,2,3] list_b = list("abc") # list_b == ['a','b','c'] list_c = list((4,5,6)) # list_c == [4,6] list_d = [i for i in list_a] # list_d == [1,3] list_e = [i*j for i in list_a for j in list_c] # list_e == [4,6,12,15,18] list_f = [i*j for i,j in zip(list_a,list_c)] # list_f == [4,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,2] list_i = list(range(3,7)) # list_i == [3,4,6] list_j = list(range(3,9,2)) # list_j == [3,7] # 找出100以内的能够被3整除的正整数 list_k = list(range(3,100,3)) # list_k == [3,...,96,99]
2)扩充列表:
用 “+” 运算符,将两个列表拼接出一个新列表。
用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','happy']
3)删减列表与销毁列表:
用del list[m] 语句,删除指定索引m处的元素。
用clear()方法,清空列表的元素。(杯子还在,水倒空了)
用del list 语句,销毁整个列表。(杯子和水都没有了)
# 以下4种删除列表元素方式 list_1 = list_2 = list_3 = list_4 = ['I','happy'] del list_1[0] # list_1 == ['am','happy'] list_2.remove('I') # list_2 == ['am','happy'] list_3.pop() # list_3 == ['I','very'] list_4.pop(0) # list_4 == ['am','happy'] # 清空与销毁 list_a = [1,3] list_b = [1,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,7,11,14,16] # 以下写法都可以表示整个列表,其中 X >= len(li) li[0:X] == li[0:] == li[:X] == li[:] == li[::] == li[-X:X] == li[-X:] li[1:5] == [4,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,11] # 从头开始,取-2-(-len(li))=7位元素 # 注意列表先翻转,再截取 li[::-1] == [16,1] # 翻转整个列表 li[::-2] == [16,1] # 翻转整个列表,再按2间隔过滤 li[:-5:-1] == [16,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,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),2018] # 比较浅拷贝与深拷贝 import copy list_a = [2018,44)] list_b = ['hi',2] list_c = list_a.copy() # list_c == [2018,44)] list_d = copy.deepcopy(list_a) # list_d == [2018,44)] # 改变原列表中的可变对象元素 list_a[3].append('new') # list_a == [2018,'new'],44)] # 浅拷贝中的可变对象会随原列表变化而变化 list_c == [2018,44)] # 深拷贝中的可变对象不会随原列表变化而变化 list_d == [2018,44)] # 比较sort() 与 sorted() list_1 = list_2 = [2,3] list_1.sort() # 原列表变化:list_1 == [1,3,6] list_3 = sorted(list_2) # 原列表不变:list_2 == [2,3]; list_3 == [1,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开始,可以大大提升内存寻址计算的效率,详细分析参考《[C语言数组元素下标为何从0开始](https://blog.csdn.net/bufanq/article/details/51330197)》
大部分shell语言:大多数是从1开始,来源参考[stackexchange这篇问答](https://unix.stackexchange.com/questions/252368/is-there-a-reason-why-the-first-element-of-a-zsh-array-is-indexed-by-1-instead-o)
Pascal、Lua:默认从1开始,但支持改变起始索引值,原因据说是对非专业的开发者更友好,来源参考[这篇知乎问答](https://www.zhihu.com/question/19675689/answer/19174752)
以上列举的原因是最审慎的、体面的解释,话题应该到此终结,因为“索引应该从几开始最好”这个问题的破坏性不亚于“哪种编程语言是最好的”......
优雅漂亮的结尾:生成器表达式
列表生成式是一种漂亮优雅的东西,然而它有一个致命的缺点:它一次性把所有元素加载到内存中,当列表过长的时候,便会占据过多的内存资源,而且,我们通常仅需要使用少数的元素,这样未使用的元素所占据的绝大部分的内存,就成了不必要的支出。
生成器是一种更高级更优雅的东西,它使用“懒加载”的原理,并不生成完整的列表,而是迭代地、即时地、按需地生成元素,这样不仅能极大地节省内存空间,而且,在理论上,它可以生成一个无穷大的列表!
大多数生成器是以函数来实现的,然而,它并不返回(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,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