python 高级语言特性_Python3(4) Python 高级特性

本系列主要学习Python的基本使用和语法知识，后续可能会围绕着AI学习展开。

Python3 (1) Python语言的简介

Python3 (2) Python语法基础

Python3 (3) Python函数

Python3 (4) Python高级特性

python 高级特性，主要是数据的迭代部分的知识，包括 切片、迭代、列表生成式、生成器、迭代器，整体来看比java等语言更加强大，方便。

切片

切片可以截取list的部分数据。查找数据更加方便，相当于java字符串subString()方法。

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

L = list(range(20))

print(L)

#取前三个数据

print(L[0:3])

#取下标1-3条数据

print(L[1:3])

#取倒数第一条数据

print(L[-1:])

#取倒数1-2条数据

print(L[-2:])

#每隔两个取一条数据

print(L[::2])

#前6个数据，每隔三个去一条

print(L[:6:3])

#复制一个list

print(L[:])

输出结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

[0, 1, 2]

[1, 2]

[19]

[18, 19]

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

[0, 3]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

以上就是切片的使用规则，由于tuple,str 可以看成list，也支持切片操作。

迭代

迭代指对数据的遍历，一般通过for循环来进行遍历，如list 、tuple。python中for循环不需要有下标，只要是可迭代对象，无论有无下标，都可以迭代。如dict:

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

D = {'张三': 16, '李四': 17, '王五': 18}

#遍历key

for key in D:

print(key)

#遍历 value

for value in D.values():

print(value)

#遍历 key,value

for k,v in D.items():

print(k,'=',v)

#遍历 下标，key，value

for i,(k,v) in enumerate(D.items()):

print(i,k,v)

输出结果：

张三

李四

王五

16

17

18

张三 = 16

李四 = 17

王五 = 18

0 张三 16

1 李四 17

2 王五 18

以上是对dict 的遍历，list、tuple 比 dict 更简单， 其中，如果要得到list下标，可以通过关键字 enumerate获取对应的下标，并且for 遍历支持多种返回值。

列表生成式

python中可以通过表达式来生成list ,可以方便的生成符合条件的list。

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

import os

L = [x * x for x in range(1, 11)]

print(L)

#增加条件限制

K = [x*x for x in range(1,11)if x%2 == 0]

print(K)

#多层嵌套

C = [a+b for a in "abc" for b in "ABC"]

print(C)

#生成两个变量组成的list

D = {'张三': 16, '李四': 17, '王五': 18}

M = [(k,v) for k,v in D.items()]

print(M)

#当前目录下的所有文件和目录名

O = [d for d in os.listdir('.')]

print(O)

输出结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

[4, 16, 36, 64, 100]

['aA', 'aB', 'aC', 'bA', 'bB', 'bC', 'cA', 'cB', 'cC']

[('张三', 16), ('李四', 17), ('王五', 18)]

['.idea', 'call_func.py', 'def_func.py', 'HelloWord.py', 'var_args.py']

这就是list 生成式的强大之处，可以通过各种表达式，生成需要的list。

生成器

生成器就是按动态的需求生成list，与列表生成式相比，不需要一次性生成完整的数据，可以节约内存。即：列表元素按照某种算法推算出来，边循环一边计算的机制的机制称为 generator,用()代替列表生成器的[]。

g = (x * x for x in range(5))

print(g)

print(next(g))

print(next(g))

print(next(g))

print(next(g))

print(next(g))

print(next(g))

输出结果：

Traceback (most recent call last):

at 0x000001BF3FD2A200>

File "F:/python/HelloWord/def_func.py", line 11, in

0

1

print(next(g))

4

StopIteration

9

16

直接打印g，输出的是 at 0x000001BF3FD2A200>，说明我们定义的是一个generator, 通过连续next(g)可以打印出对应的数据，但是超出范围会报Traceback (most recent call last): Stoplteration错误，由于generator也是可迭代对象

g = (x * x for x in range(5))

for n in g:

print(n)

输出结果：

0

1

4

9

16

如果上面的for 循环不能瞒住需求，我们可以通过函数来实现， 我们来写一个斐波拉契数列数列，这个数列就是根据前面数据来推断后面的数，在函数中使用关键字yield 可以转化成 generator

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

#用函数实现fib

def fib(max):

n, a, b = 0, 0, 1

while n < max:

print(b)

a, b = b, a + b

n = n + 1

return 'done'

fib(5)

print("-----------------")

#将函数转化成 generator

def generator_fib(max):

n, a, b = 0, 0, 1

while n < max:

yield b

a, b = b, a + b

n = n + 1

return 'done'

g = generator_fib(5)

print(g)

#输出generator：

while True:

try:

x = next(g)

print('g:', x)

except StopIteration as e:

print('Generator return value:', e.value)

break

输出结果：

1

1

2

3

5

-----------------

g: 1

g: 1

g: 2

g: 3

g: 5

Generator return value: done

这里我们要清楚yield的使用规则：函数中return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。写一个杨辉三角练练：

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

def triangles():

N = [1]

while True:

yield N

N.append(0)

N = [N[i] + N[i - 1] for i in range(len(N))]

n = 0

for t in triangles():

print(t)

n = n + 1

if n == 10:

break

输出结果：

[1]

[1, 1]

[1, 2, 1]

[1, 3, 3, 1]

[1, 4, 6, 4, 1]

[1, 5, 10, 10, 5, 1]

[1, 6, 15, 20, 15, 6, 1]

[1, 7, 21, 35, 35, 21, 7, 1]

[1, 8, 28, 56, 70, 56, 28, 8, 1]

[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

迭代器

理解迭代器generator要清楚一个概念，可以进行for 循环的为可迭代对象Iterable,并不是迭代器，迭代器是指以被next()函数调用并不断返回下一个值的对象，表示一个惰性计算的序列。是迭代器一定是可迭代对象，可迭代对象不一定是迭代器。

Python的for循环本质上就是通过不断调用next()函数实现的

可迭代对象：list、tuple、dict、set、str、generator、generator function

迭代器：generator、generator function 可以通过iter()函数获得一个Iterator对象

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

from collections import Iterable, Iterator

L = [1,2,3,4,5]

D = {"张三":15,"李四":16,"王五":17}

T = (1,2,3,4,5)

G = (n for n in range(5))

print(isinstance(L,Iterable))

print(isinstance(D,Iterable))

print(isinstance(T,Iterable))

print(isinstance(G,Iterable))

print("--------------------------------------")

print(isinstance(L,Iterator))

print(isinstance(D,Iterator))

print(isinstance(T,Iterator))

print(isinstance(G,Iterator))

print("--------------------------------------")

print(isinstance(iter(L),Iterator))

print(isinstance(iter(D),Iterator))

print(isinstance(iter(T),Iterator))

输出结果：

True

True

True

True

--------------------------------------

False

False

False

True

--------------------------------------

True

True

True

上面的代码验证了list、dict、tuple、generator是否是迭代器和可迭代对象，通过isinstance判断，可迭代对象可以通过iter()函数生成迭代器。

参考