Python学习笔记（五） 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本身就是一个特别的list

L=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=None

for h in H :
    if min==None or (h!=min and h<min) :#int 不能和None进行逻辑运算 ， 当min为None时  ， 先赋予初始值 。 
        min = h
    elif 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和value
    print(k , '=' , v)  

#使用列表生成式将dict 转换为list

L2 = [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 b
        a , 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 1
    print("step 2")
    yield 2
    print("step 3")
    yield 3

o=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 1
    print("step 2")
    yield 2
    print("step 3")
    yield 3

#使用迭代遍历获取generator函数返回的值
for r in odd() :
    print(r)

当generator以函数的形式定义，并且generator中含有return语句时，会发现拿不到return语句中的返回值，如果想要拿到返回值，则必须捕获StopIteration错误，返回值包含在StopIteration的value中：

def odd() :
    print("step 1")
    yield 1
    print("step 2")
    yield 2
    print("step 3")
    yield 3
    return "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;
```