Python （五）高级特性

Python高级特性

一、切片

python中提供了切片（Slice）操作符，可以方便的获取list或tuple中的某一段元素。

# -*-  coding : utf-8 -*-  #Python 切片#生成0~99的元组或list都是可以进行切片操作的
L=tuple(range(100))#输出
print(L)#使用且前截取
#使用 L[startIndex : endIndex] 的形式
#startIndex表示 开始截取的位置  endIndex表示结束截取的位置  含左不含右
print(L[10:20])
print(L[:10])  # 没有起始位置时 ， 默认从0开始
print(L[10:])  # 没有结束位置时 ， 默认截取剩余部分#指定截取时的步数
print(L[:10:2]) # 截取0~10的元素 ， 每两个取一个
print(L[::5])  #所有的数 ， 每五个取一个

示例

#去除字符串首尾的空格
def trim(s):if(s[0] == " "):s = s[1:]trim(s)elif s[len(s)-1] == " " :s = s[:len(s)-1]trim(s)else:print("***"+s+"***")s = input("请输入要处理的字符串：")
trim(s)

二、迭代

python中的迭代遍历不仅仅可以用在list和tuple上，而且可以用在dict上。

示例

# -*-  coding : utf-8 -*- #python 中的迭代遍历 #1. 迭代list 或 tuple
#为什么是 一个列子？   因为tuple本身就是一个特别的listL=tuple(range(100))
J=list(range(100))for i in J :print(i)#2. 迭代一个dict
# 在迭代dict时 ，  默认迭代的是dict 的key 的集合 ， 随后可以拿着key从dict 中取到value
D = {'a':1 , 'b':2 , 'c':3}
#遍历Key
for d in D :print(d)
#遍历value 方式一
for d in D : print(D[d])#遍历value 方式二
for d in D.values() :print(d)

当我们在python 中使用for遍历时，只要作用于一个可迭代对象， for循环就可以正常运行，而不用太关心被迭代的元素类型。

如何判断一个对象是一个可迭代对象？

from collections import Iterable#python   判断一个对象是否是一个可迭代对象
D = {'a':1 , 'b':2 , 'c':3}
flag = isinstance(D , Iterable)
print("是否是一个可迭代的对象呢： "+str(flag))

遍历二维list

#python遍历二维列表K=((1,1) , (2,2) , (3,3) , (4,4))for x , y in K :print(x , y)

练习

#python 迭代练习
#查找list中的最大值和最小值
print("查找list中的最大值和最小值：")
H=(1,6,33,7,8,5,3,7,75,3,7,32,6,8,8,4,3,88,5,33,5,11111)
min=None
max=Nonefor h in H :if min==None or (h!=min and h<min) :#int 不能和None进行逻辑运算 ， 当min为None时  ， 先赋予初始值 。 min = helif max==None or (h!=max and h>max) :max = h
print("min=" , min)
print("max=" , max)

三、列表生成式

列表生成式即List Comprehensions ，是Python内置的非常简单却强大的可以用来创建List 的生成式。

举个例子
要想生成[1,2,3,4,5,6,7,8,9,10] , 可以用list(range(1,11))但是想要生成[1x1 , 2x2 , 3x3 , 4x4, 5x5] 怎么做？ 只能使用原始的for循环么？？
1. 可以用list(x*x for x in range(1, 6))
2. 可以使用判断 ， 筛选出仅偶数的平方
list(x*x for x in range(1,11) if x%2==0)
3. 可以使用循环嵌套生成全排列
list(m+n for m in 'ABC' for n in 'XYZ')

示例

# -*- conding:utf-8 -*-import os #导入os模块
#利用列表生成式列出当前目录下所有的目录和文件名L = [d for d in os.listdir('.')]#.代表当前目录
print(L)#遍历dict的第三中方式
D={'1':'a' , '2':'b' , '3':'c'}
for k,v in D.items():#使用for循环遍历dict 时 ， 默认遍历keys ， 可以通过D.values()仅遍历value ， 可以通过items()同时遍历key和valueprint(k , '=' , v)  #使用列表生成式将dict 转换为listL2 = [k+"="+v for k , v in D.items()]
print(L2)   #把list中的所有字符串转换为小写并输出L3=['AAA',"BBB",18,'CCC','adfFFFF']L3c=[s.lower() for s in L3 if isinstance(s , str)]
print(L3c)

四、生成器

通过列表生成式，我们可以直接创建一列表，但是虽然理论上list 的长度是无限的，由于受内存限制，实际上list的长度也是受限的的。当我创建出一个包含100万个元素的list却只取其中的某几个元素使用一次时，这就显得非常的浪费。
所以，如果列表中的元素如果可以按照某种算法推算出来，我们就不必创建大量占用内存的list而使用list 中的元素了。在python中这样以便循环一边计算的机制叫做生成器generator 。

生成一个generator最简单的办法就是把一个列表生成式的[]改为() ，就创建了一个generator 。

# -*- conding:utf-8 -*-#generator生成器
L=[x for x in range(10)] #列表生成式 用于比较
G=(x for x in range(10)) #生成器print("列表" , L)
print("生成器" , G )

遍历generator的元素之前说过generator保存的是数据生成的算法，不断调用next(g)的方式太麻烦，由于generator也是可迭代对象，所以可以使用for循环。
```
G=(x for x in range(10)) #生成器
for g in G :print(g)
```

generator非常强大，如果推算的算法比较复杂，用上述的方法无法实现的时候，还可以用函数来实现。

#函数的形式实现generator#比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：
#1, 1, 2, 3, 5, 8, 13, 21, 34, ...
#斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：def fib(max) :n , a , b  = 0 , 0 , 1#n控制循环次数 ， a为假设的第0个数 b为第一个数while n<max :print(b)a , b = b , a+b # 相当于a=b , b=a+b n = n + 1 print('done')#调用
fib(6)

定义generator的另一种形式：如果一个函数中包含了yield关键字，那么这个函数就不再是一个普通函数，而是一个generator 。

#从上面的例子可以看出和generator非常类似 ， 可以从第一个元素开始推算出后续的任意元素 。
#想要把fib()函数变为generator ， 其实只要将print(b) 变为yield b 就可以了def fib(max) :n , a , b  = 0 , 0 , 1#n控制循环次数 ， a为假设的第0个数 b为第一个数while n<max :yield ba , b = b , a+b # 相当于a=b , b=a+b n = n + 1 print('done')f=fib(6)
print(f)

需要注意的是：generator和函数的执行流程是不一样的，函数时顺序执行，从上至下，遇到return语句或函数最后一句时就返回。但是generator在每次调用next()函数时执行，遇到yield语句返回，再次执行时从上次返回的yield处继续执行。

#generator函数的执行顺序
#generator遇到yield之后返回结果 ， 下次执行时从上次的yield出执行
def odd() :print("step 1")yield 1print("step 2")yield 2print("step 3")yield 3o=odd()
r1 = next(o)
print(r1)
r2 = next(o)
print(r2)
r3 = next(o)#当顺序执行完yield关键字之后 ， 再执行next()函数就会报错
print(r3)

即使generator是以函数的形式定义的，我们也几乎不会用next()函数获取返回值，而是使用迭代遍历

def odd() :print("step 1")yield 1print("step 2")yield 2print("step 3")yield 3#使用迭代遍历获取generator函数返回的值
for r in odd() :print(r)

当generator以函数的形式定义，并且generator中含有return语句时，会发现拿不到return语句中的返回值，如果想要拿到返回值，则必须捕获StopIteration错误，返回值包含在StopIteration的value中：
```
def odd() :print("step 1")yield 1print("step 2")yield 2print("step 3")yield 3return "done"o=odd()
while True:try:x=next(o)print(x)except StopIteration as e:print("return：" , e.value)break
```
总结
1. generator 是非常强大的工具，在Python中，可以简单的把列表生成式改为generator，也可以通过函数形式实现复杂李玉偶记的generator
2. generator工作时的原理： generator在for循环的过程中不断的计算下一个元素，并在适当的条件结束for循环。对于普通函数改成的generator来说，遇到return语句或者执行到函数最后一行语句，就是结束generator的指令， for循环随之结束。

五、迭代器

通过以上的学习已经知道，可以使用for循环的数据类型有以下几种：

集合数据类型： list 、 tuple 、 dict 、 set 、 str 。
generator ：包括生成器和带yield的generator function

这些可以直接作用于for循环的对象统统成为可迭代对象

# -*-  coding : utf-8-*-
#判断数据类型是否是一个可迭代类型
from collections import Iterable flag = isinstance([] , Iterable)
print("list是否是可迭代对象：" , flag)flag = isinstance(() , Iterable)
print("tuple是否是可迭代对象：" , flag)flag = isinstance({} , Iterable)
print("dict 、 set 是否是可迭代对象：" , flag)flag = isinstance("" , Iterable)
print("str是否是可迭代对象：" , flag)

生成器不但可以用for循环遍历，还可以被next()函数不断电泳并返回下一个值，知道最后抛出一个StopItreator 错误表示无法继续返回下一个值了。
可以被next()函数调用并不断返回下一个值的对象称之为迭代器
1. 生成器是Iterator对象，但是list 、 dict 、 str虽然是Iterable ，却不是Iteraor
2. 想要把Iterable转换为Iterator可以使用iter()函数
思考： list 、 dict 、 str为什么不是Iterator对象？
1. 因为pyhton 中Iterator对象表示的是一个数据流， Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误，可以把这个数据流看作是一个有序序列，但是我们不能提前知道序列的长度，只能不断的通过next()函数实现按需计算下一个数据，所以Iterator的计算时惰性的，只有在需要返回下一个数据时他才会计算。
2. Iterator甚至可以表示一个无限大的数据流，列如：全体自然数，而使用list永远不可能存储全部自然数。
迭代器总结：
1. 凡是可用作与for循环的对象都是Iterable类型
2. 凡是可以作用于next()函数的对象都是Iterator类型，他们表示一个惰性的计算的序列。
3. 集合数据类型如： list 、 dict 、tuple 、 set 、 str都不是Iterator类型的数据，但是可以通过iter()函数转换为一个Iterator类型的对象。
4. Python的for循环本质上就是通过不断调用next()函数实现的。如：
```
# -*- conding : utf-8-*-#迭代器
#Python中的for循环实质上是通过不断调用next()函数实现的 。L = [1,32,3,4,5,6,7,8,89,9,]for l in L:pass#等同于
it = iter(L)
while True:try :#获取下一个值x = next(it)except StopIteration as e :#遇到异常break;
```