python学习笔记四（基础篇）

时间：2016-01-26 00:24:36 阅读：191 评论：0 收藏：0 [点我收藏+]

迭代器

　 __iter__方法返回一个迭代器，它是具有__next__方法的对象。在调用__next__方法时，迭代器会返回它的下一个值，若__next__方法调用迭代器

没有值返回，就会引发一个StopIteration异常。

特点：

访问者不需要关心迭代器内部的结构，仅需通过__next__方法不断去取下一个内容
不能随机访问集合中的某个值，只能从头到尾依次访问
访问到一半时不能往回退
便于循环比较大的数据集合，节省内存

name = iter([‘koka‘,‘lolo‘,‘lala‘])
print(name.__next__())
print(name.__next__())
print(name.__next__())

生成器：

定义：一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator），任何包含yied语句的函数称为生成器。生成器是由两部分组成：

生成器的函数和生成器的迭代器。生成器的函数是def语句定义的，包含yield的部分，生成器的迭代器是这个函数返回的部分。

def cash_out(amount):
    print("欢迎登录ATM")
    while amount >0:
        amount -= 1
        yield 1
        print("欢迎来取钱！")

ATM = cash_out(5)
print("取到钱 %s 万" % ATM.__next__())
print("花掉花掉!")
print("取到钱 %s 万" % ATM.__next__())
print("取到钱 %s 万" % ATM.__next__())
print("花掉花掉!")
print("取到钱 %s 万" % ATM.__next__())
print("取到钱 %s 万" % ATM.__next__())
print("取到钱 %s 万" % ATM.__next__()) #到这时钱就取没了,再取就报错了

Traceback (most recent call last):
  File "D:/home/new.py", line 42, in <module>
    print("取到钱 %s 万" % ATM.__next__()) #到这时钱就取没了,再取就报错了
StopIteration

#使用yied语句，函数就会被冻结：即函数停在那点等待被激活。函数被激活后就从停止的那点开始执行。

li = [[1,2,],[3,4],[5]]
def flatten(li):
    for sublist in li:
        for item in sublist:
            yield item
for j in flatten(li):
    print(j)

递归生成器：
def flatten(li):
    try:
        #不要迭代类似字符串的对象,
        try:li + ‘‘
        except TypeError:pass
        else:raise TypeError
        for sublist in li:
            for item in flatten(sublist):
                yield item
    except TypeError:
        yield li

li = [[[1,2,3],[4,5],[6],[7],[8],[‘a‘],[[9,10],11],12]]
ok = flatten(li)
for i in ok:
    print(i)

生成器方法

生成器的属于表现为生成器和"外部世界"进行沟通交流的渠道注意如下两点：

外部作用域访问生成器的send方法，就像访问__next__方法，send需要一个参数。
在内部则挂起生成器，yield作为一个表达式而不是语句，即：当生成器重新运行的时候，yield方法返回值是接受到外部通过send方法发送的值。如果__next__方法被使用，yield方法返回None。

#使用yield实现在单线程的情况下实现并发运算的效果

import time
def consumer(name):
    print("%s 准备吃包子！"%name)
    while True:
        baozi = yield
        print("包子[%s]来了，被[%s]吃了！" %(baozi,name)

def producer(name):
    c = consumer(‘A‘)
    d = consumer(‘B‘)
    c.__next__()
    d.__next__()
    print("开始生产包子！")
    for i in range(5):
        time.sleep(1)
        print("做了2个包子！")
        c.send(i)
        d.send(i)
producer(‘koka‘)

装饰器：

装饰器的作用就是为已经存在的对象添加额外的功能。

装饰器：

def w1(func):
    def inner(arg):
        print("通过验证！！！")
        return func(arg)
    return inner

@w1
def f1(arg):
    print("欢迎%s来到TV页面" %arg)
f1(‘abc‘)

#调用过程；
#加载w1函数
#遇见@1，执行w1函数，将f1函数传入到w1函数，
#将执行完的w1函数的返回值赋值给f1 @w1 f1=w1(f1)
#调用重新赋值的f1(arg)时，即运行w1函数内部的inner(arg)函数。

详细过程如下：

当写完这段代码后（函数未被执行、未被执行、未被执行），python解释器就会从上到下解释代码，步骤如下：

def w1(func): ==>将w1函数加载到内存
@w1

没错，从表面上看解释器仅仅会解释这两句代码，因为函数在没有被调用之前其内部代码不会被执行。

从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章，@函数名 是python的一种语法糖。

如上例@w1内部会执行一下操作：

执行w1函数，并将 @w1 下面的函数作为w1函数的参数，即：@w1 等价于 w1(f1)
所以，内部就会去执行：
def inner(arg):
#验证
return f1(arg) # func是参数，此时 func 等于 f1
return inner # 返回的 inner，inner代表的是函数，非执行函数
其实就是将原来的 f1 函数塞进另外一个函数中
将执行完的 w1 函数返回值赋值给@w1下面的函数的函数名
w1函数的返回值是：
def inner(arg):
#验证
return 原来f1(arg) # 此处的 f1 表示原来的f1函数
然后，将此返回值再重新赋值给 f1，即：
新f1 = def inner(arg):
#验证
return 原来f1(arg)
所以，以后业务部门想要执行 f1 函数时，就会执行新f1 函数，在新f1 函数内部先执行验证，再执行原来的f1函数，然后将原来f1 函数的返回值返回给了业务调用者。
如此一来，即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值返回给业务调用者。

递归:

递归即在函数或过程中调用自身；

递归包含如下两个部分：

当函数直接返回值时，有基本实例（最小可能性问题）
递归实例，包括一个或者多个问题最小部分的递归调用

这里的关键就是将问题分解为小部分，递归不能永远继续下去，因为它总是以最小可能性问题结束，而这些问题又存储在基本实例中。

递归算法所体现的“重复”一般有三个要求：

每次调用在规模上都有所缩小(通常是减半)；
相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)；
在问题的可能性极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

阶乘：

    * 1的阶乘是1；
    * 大于1的数n的阶乘是n乘n-1的阶乘

def factorial(n):
     if n == 1:
          return 1
     else:
          return n * factorial(n-1)

阶幂：

    * 对于任何数字x来说，power(x,0)是1；
    * 对于任何大于0的数来说，power(x,n)是x乘以(x,n-1)的结果。

def power(x,n):
     if x == 0:
          return 1
     else:
          return x * power(x,n-1)

查看递归过程：

def cacl(n):
    print(n)
    if n/2 > 1:
        res = cacl(n/2)
        print("res:",res)
    print("N:",n)
    return n
cacl(18)

18
9.0
4.5
2.25
1.125
N: 1.125
res: 1.125
N: 2.25
res: 2.25
N: 4.5
res: 4.5
N: 9.0
res: 9.0
N: 18

二元查找：

def search(data,find_num):
    mid = int( len(data) / 2)
    mid_value = data[mid]
    if len(data) == 1 and data[0] == find_num: #当列表中只有一个数时，判断该数是否存在。

        print("find %s" %find_num)
    elif len(data) >1:
        if mid_value > find_num:
            return search(data[:mid],find_num)
        elif mid_value < find_num:
            return search(data[mid:],find_num)
        else:
            print("find %s" %data[mid])
    else:
        print("cannot find [%s] in data_list" %find_num)
if __name__ == "__main__":
    data = list(range(100))
    search(data,0)

python学习笔记四（基础篇）

原文：http://www.cnblogs.com/koka24/p/5159087.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)