Day 4 Python之循序渐进4

1.迭代器原理及使用

迭代器原理：

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

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

#! /usr/bin/env python
# -*- coding:utf-8 -*-

# linux中的cat就类似于迭代的形势，读一行显示一行，减少内存利用率，速度快

names = iter(['leon','jack','list','offer'])
print(names)
print(names.__next__())
print(names.__next__())
print(names.__next__())
print(names.__next__())
# print(names.next())  2.7这么写此方法

迭代器
作为遍历集合 ===，一般通过for循环间接使用

循环
1.while
索引，下标取数据，随意取值
2.for
a）执行迭代器，获取一个对象
b) 执行对象的next方法

引出：
iter(迭代器)，获得一个具有next方法的对象
--->顺序去取

需求：
  li = [11,22,33,44,55]
  打印元素
  
i = len(li)
# i = 0 -->False,其他为Ture
start = 0
while i>start
    print(li[start])
    start += 1
#while 使用索引(下标随意取数据)，start为变量，所有的语言几乎都支持while循环的方式,但写起来麻烦

#于是出现for：

for item in li:
    print(item)
    
obj = iter(li)
print(obj._next_())
#使用本质，创建一个for循环

obj = iter(li)
while True:
    try:
        item = obj._next_()
        print(item)
    except Exception:
        pass
    

#for循环的本质：
1.创建一个特殊的东西（迭代器），获取到一个具有next方法的对象
2.依据这个东西去操作列表li中的内容


迭代器 = iter()
执行迭代器返回一个对象，对象是含有next方法（操作列表中的内容）

2.生成器的使用

生成器generator

定义：一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator），如果函数中包含yield语法，那这个函数就会变成生成器

代码：

#! /usr/bin/env python
# -*- coding:utf-8 -*-

# 定义：一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator），如果函数中包含yield语法，那这个函数就会变成生成器
def cash_out(amount):
    while amount >0:
        amount -= 1
        yield 1  # 注意与return的区别，yield退出循环又能再进去
        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__()) #到这时钱就取没了,再取就报错了
print("取到钱 %s 万" % ATM.__next__())

#! /usr/bin/env python
# -*- coding:utf-8 -*-

def cash_money(amount):
    while amount >0:
        amount -=100
        yield 100
        print("又来取钱了")
# 注意与return的区别，yield退出循环又能再进去
atm = cash_money(500)
print(type(atm))
print(atm.__next__())
print(atm.__next__())
print("断点插入，嘻哈测试")
print(atm.__next__())

生成器yield  (解决内存消耗)
"""
*******************************************************
python 2.7 
    range, xrange
    
range(10)  -->会在内存中create 0-9
xrange(10) -->

for i in xrange(10):
    # 第一次循环内存中会创建0
    # i = 0
    # 第二次循环内存中会创建1
    # i = 1
    # 一直循环创建到9 
    print i 
    
    
python 3
    range

*******************************************************
"""    
"""
*******************************************************
redis

n1 --> k1 = v1
       k2 = v2
       
n2 --> k11 = v11
       k12 = v12
       
监控：api  http://baidu.com/p1   -->1,10 (1点的时候访问量是10)
                                 -->2,30
redis -> hash

# 服务器缓存 100G
dic = {"k1":"v1","k2":"v2"}

# 本地电脑 2G


# 文件
f = open('f1.log')
# 把日志全部拿到内存
for line in f:
    print(line)
*******************************************************
"""

def show():
    yield 123
i = show()
print(i)

# 回想，文件操作 100G
f = open('f1.log')
for line in f:
    print(line)
*******************************************************    
def show():
    yield 'line1'
    yield 'line2'
    yield 'line3'
my_f = show()
for line in my_f:
    print(line)
# 函数如果含有yield，函数返回值就是特殊的东西（必须和for一起使用）
# for,函数返回的特殊值，函数内部执行代码，如果遇到yeild关键字，冻结当前状态，跳出函数回到for和特殊值位置

# 必须迭代方式执行生成器
# yield冻结状态（基础上一次执行位置），也具有next方法

3.使用yield实现单线程中的异步并发效果

作用：

yield的主要效果就是可以使函数中断，并保存中断状态，中断后，代码可以继续往下执行，过一段时间还可以再重新调用这个函数，从上次yield的下一句开始执行。

另外，还可通过yield实现在单线程的情况下实现并发运算的效果

#! /usr/bin/env python
# -*- coding:utf-8 -*-

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))

def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)  # 通过send方法传给yield接收
        c2.send(i)

producer("leon")

4.装饰器原理介绍和基本实现

 装饰器的作用是给已经实现的功能再扩展新的功能

# 无参数执行
def login(func):  # func = tv
    print("passed user verification...")
    # func()
    return func #tv
    # return None

def home(name):
    print("Welcome [%s] to home page" %name)
# def tv(name):
def tv():
    print("Welcome [%s] to tv page")
def moive(name):
    print("Welcome [%s] to moive page")

tv = login(tv)
tv()

5.装饰器实现

# 带参数执行
def login(func):  # func = tv
    def inner(arg):
        print("passed user verification...")
        func(arg)
    return inner

def home(name):
    print("Welcome [%s] to home page" %name)
# def tv(name):
@login  #这种表示方法叫装饰器，也称语法堂
def tv(name):
    print("Welcome [%s] to tv page"%name)
def moive(name):
    print("Welcome [%s] to moive page")

# tv = login(tv)
tv("leon")

 

6.实现带参数的复杂装饰器

 这个有点难理解

#!/usr/bin/env python
#coding:utf-8
  
def Before(request,kargs):
    print 'before'
      
def After(request,kargs):
    print 'after'
  
  
def Filter(before_func,after_func):
    def outer(main_func):
        def wrapper(request,kargs):
              
            before_result = before_func(request,kargs)
            if(before_result != None):
                return before_result;
              
            main_result = main_func(request,kargs)
            if(main_result != None):
                return main_result;
              
            after_result = after_func(request,kargs)
            if(after_result != None):
                return after_result;
              
        return wrapper
    return outer
      
@Filter(Before, After)
def Index(request,kargs):
    print 'index'

 

7.递归原理及实现

#! /usr/bin/env python
# -*- coding:utf-8 -*-

def calc(n):
    print(n)
    if n/2 > 1:
        res = calc(n/2)
        print('res',res)
    print("N:",n)
    return n
calc(10)

 

8.通过递归实现斐波那契数列

# 通过递归实现斐波那契数列

def func(arg1,arg2,stop):
    if arg1 == 0:
        print(arg1,arg2)
    arg3 = arg1 + arg2
    print(arg3)
    if arg3 < stop:
        func(arg2,arg3,stop)

func(0,1,30)

 

9.算法基础之二分查找

#! /usr/bin/env python
# -*- coding:utf-8 -*-

def binary_seach(data_soure,find_n):
    mid = int(len(data_soure)/2)
    if len(data_soure) >= 1:
        if data_soure[mid] > find_n:  # 要找的值在左边
            print("data in left of [%s]" %data_soure)
            binary_seach(data_soure[:mid],find_n)
        elif data_soure[mid] < find_n:
            print("data in right of [%s]" %data_soure)
            binary_seach(data_soure[mid:],find_n)
        else:
            print("found find_s,",data_soure[mid])
    else:
        print("cannot find data")

if __name__ == '__main__':
    data = list(range(1,6000000))
    # print(data)
    binary_seach(data,65535)

 

10.算法基础之2维数组90度旋转

 基础代码：

#! /usr/bin/env python
# -*- coding:utf-8 -*-

# a = [i for i in range(10)] = a.append(i)

data = [[col for col in range(4)] for row in range(4)]
for row in data:
    print(row)
"""
输出：（二维数组）
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]
"""

旋转90°解析思路： 

 

实现：

 

11.正则表达式基础

正则表达式 import re
处理字符串

规则：
\s --> 空格
\d --> 数字

如：找到所有数字。1,2,3,4,5,6
\d 替换：所有数字 "alex"
分割: "adskfjaksdjfisad98sdf"

a)字符规则
b)次数规则
c)方法
match:从头开始匹配
search:从任意位置开始匹配
-->匹配结果：如果没有匹配到，范围None
-->匹配到了，则有两个方法group和groups:
group：
groups:

findall:
sub:替换
split:分组

#! /usr/bin/env python
# -*- coding:utf-8 -*-

import re

m = re.match("abc","abcdefg")
m = re.match("[0-9][0-9]","651abd3cdefg")
m = re.match("[0-9]{0,10}","651abd3cdefg")
m = re.match("[0-9]{10}","651abd3cdefg")
m = re.findall("[0-9]{1,10}","651abd3cdefg")
m = re.findall("[a-zA-z]{1,10}","651abd3cdefg")
m = re.findall(".*","651abd3cdefg")
m = re.findall(".+","651abd3cdefg")
m = re.findall("[a-zA-z]+","651abd3cdefg")
m = re.search("def","651abd3cdefg")
m = re.search("\d+","651abd3cdefg")
m = re.sub("\d+","|","651abd3cdefg")
m = re.search("^\d+$","651abd3cdefg")
m = re.search("^\d+$","14234812309482")
if m:
    # print(m)
    print(m.group())
# 输出：
# <_sre.SRE_Match object; span=(0, 3), match='abc'>

# n = re.match("abc","defg")
# print(n)
# 输出：None