>>> a = iter([1,2,3,4,5])

>>> a

<list_iterator object at 0x101402630>

>>> a.__next__()

1

>>> a.__next__()

2

>>> a.__next__()

3

>>> a.__next__()

4

>>> a.__next__()

5

>>> a.__next__()

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration

def cash_out(amount):

    while amount >0:

        amount -= 1                                    #一次只能去1

        yield 1

        print("擦，又来取钱了。。。败家子！")

ATM = cash_out(5)                                  #银行卡里有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__()) #到这时钱就取没了,再取就报错了

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():

        time.sleep()

        print("做了2个包子!")

        c.send(i)

        c2.send(i)

producer("alex")

def w1(func):

    def inner():

        # 验证1

        # 验证2

        # 验证3

        return func()

    return inner

@w1

def f1():

    print 'f1'

@w1

def f2():

    print 'f2'

@w1

def f3():

    print 'f3'

@w1

def f4():

    print 'f4'

def w1(func):

    def inner():

        # 验证1

        # 验证2

        # 验证3

        return func()

    return inner

@w1

def f1():

    print 'f1'

def w1(func):

    def inner(arg):

        # 验证1

        # 验证2

        # 验证3

        return func(arg)

    return inner

@w1

def f1(arg):

    print 'f1'

一个参数

def w1(func):

    def inner(arg1,arg2):

        # 验证1

        # 验证2

        # 验证3

        return func(arg1,arg2)

    return inner

@w1

def f1(arg1,arg2):

    print 'f1'

两个参数

def w1(func):

    def inner(arg1,arg2,arg3):

        # 验证1

        # 验证2

        # 验证3

        return func(arg1,arg2,arg3)

    return inner

@w1

def f1(arg1,arg2,arg3):

    print 'f1'

三个参数

def w1(func):

    def inner(*args,**kwargs):

        # 验证1

        # 验证2

        # 验证3

        return func(*args,**kwargs)

    return inner

@w1

def f1(arg1,arg2,arg3):

    print 'f1'

def w1(func):

    def inner(*args,**kwargs):

        # 验证1

        # 验证2

        # 验证3

        return func(*args,**kwargs)

    return inner

def w2(func):

    def inner(*args,**kwargs):

        # 验证1

        # 验证2

        # 验证3

        return func(*args,**kwargs)

    return inner

@w1

@w2

def f1(arg1,arg2,arg3):

    print 'f1'

#!/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'

要求

def binary_search(data_source,find_n):

    mid = int(len(data_source)/2)

    if len(data_source) >=1 :

        if data_source[mid] > find_n:

            print('data in left of [%s]'% data_source[mid])

            print(data_source[:mid])

            binary_search(data_source[:mid],find_n)

        elif data_source[mid] < find_n:

            print('data in right of [%s]'% data_source[mid])

            print(data_source[mid:])

            binary_search(data_source[:mid],find_n)

        else:

            print ('found find_s',data_source[mid])

    else:

        print ("cannot find...")

if __name__ == '__main__':

    data = list(range(2,25))

    #print(data)

    binary_search(data,1)

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)

#!_*_coding:utf-8_*_

array=[[col for col in range(5)] for row in range(5)] #初始化一个4*4数组

#array=[[col for col in 'abcde'] for row in range(5)]

for row in array: #旋转前先看看数组长啥样

    print(row)

print('-------------')

for i,row in enumerate(array):

    for index in range(i,len(row)):

        tmp = array[index][i] #get each rows' data by column's index

        array[index][i] = array[i][index] #

        print tmp,array[i][index]  #= tmp

        array[i][index] = tmp

    for r in array:print r

    print('--one big loop --')

正则表达式

语法：

import re #导入模块名

 

p = re.compile("^[0-9]")  #生成要匹配的正则对象 ， ^代表从开头匹配，[0-9]代表匹配0至9的任意一个数字， 所以这里的意思是对传进来的字符串进行匹配，如果这个字符串的开头第一个字符是数字，就代表匹配上了

 

m = p.match('14534Abc')   #按上面生成的正则对象 去匹配 字符串， 如果能匹配成功，这个m就会有值， 否则m为None<br><br>if m: #不为空代表匹配上了

　　print(m.group())　　　　#m.group()返回匹配上的结果，此处为1，因为匹配上的是1这个字符<br>else:<br>　　print("doesn't match.")<br>

m = re.match("abc","bcdef")             #match是从头开始匹配m = re.match("[0-9]","6ab6cdef"m = re.match("[0-9]{0,10}","7565412121545545abc")      #以数字为开头，匹配接下来的数字0-10个

if m:
    print (m.group())
m = re.findall("[0-9]{1,10}","75654500004548780212ab74c")   #匹配所有数字，每个字符串最多10个数字，多余的另外生成一个字符串，中间有字母隔开再另外生成一个字符串
m = re.findall("[a-zA-Z]{0,10}","7565450000dfdsfds02124c")#匹配所有字母，但是有0次，所以会有很多['']

m = re.findall("[a-zA-Z]+","7565450000dfdsfds02124c")#匹配所有字母，+代表至少匹配1次，所以没有了
['']

m = re.findall(".*","75654500004548780212ab74c")    #匹配所有字符，结果会多一个[''],因为0次也包括

m = re.findall(".+","75654500004548780212ab74c")    #匹配所有字符，至少匹配一次，所以最后没有了['']

m = re.findall(".+","756-5.4@~5000 04 5487 80212ab74c")     #匹配任意非空的字符

m = re.search("^\d+$","1356545855") #匹配以数字开头数字结尾，中间如果不过是数字则匹配失败

m = re.search("\d+","756-5.4@~5000 04 5487 80212ab74c")     #search匹配第一个找到的数字，往后一直匹配到不是字符为止，不连续的数字不匹配后面的数字，需要用print(m.group())

m = re.sub("\d+","|","756-5.4@~5000 04 5487 80212ab74c")    #把所有的数字转换成|

m = re.sub("\d+","|","756-5.4@~5000 04 5487 80212ab74c",count=2) #将前面两段连续的数字替换成|，756和5被替换成|

if m:
    print(m)

上面的第2 和第3行也可以合并成一行来写：

m = p.match("^[0-9]",'14534Abc')

效果是一样的，区别在于，第一种方式是提前对要匹配的格式进行了编译（对匹配公式进行解析），这样再去匹配的时候就不用在编译匹配的格式，第2种简写是每次匹配的时候 都 要进行一次匹配公式的编译，所以，如果你需要从一个5w行的文件中匹配出所有以数字开头的行，建议先把正则公式进行编译再匹配，这样速度会快点。

匹配格式

正则表达式常用5种操作

re.match(pattern, string)　　　　 # 从头匹配

re.search(pattern, string)　　　　# 匹配整个字符串，直到找到一个匹配

re.split()　　　　　　　　　　　　# 将匹配到的格式当做分割点对字符串分割成列表

输出：　['alex', 'rain', 'jack', 'helen rachel', '']

re.findall()　　　　　　　　　　# 找到所有要匹配的字符并返回列表格式

>>>m = re.findall("[0-9]", "alex1rain2jack3helen rachel8")

特殊字符类

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

Regular Expression Modifiers: Option Flags

Regular expression literals may include an optional modifier to control various aspects of matching. The modifiers are specified as an optional flag. You can provide multiple modifiers using exclusive OR (|), as shown previously and may be represented by one of these −

几个常见正则例子：

匹配手机号

 phone_str = "hey my name is alex, and my phone number is 13651054607, please call me if you are pretty!"

 phone_str2 = "hey my name is alex, and my phone number is 18651054604, please call me if you are pretty!"

 m = re.search("(1)([358]\d{9})",phone_str2)

 if m:

     print(m.group())

匹配IP V4

ip_addr = "inet 192.168.60.223 netmask 0xffffff00 broadcast 192.168.60.255"

m = re.search("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", ip_addr)

print(m.group())

分组匹配地址

 contactInfo = 'Doe,John:555-1212'      #中间不能有空格，否则匹配不了

 match = re.search(r'(\w+), (\w+): (\S+)', contactInfo) #分组

 """

 >>> match.group(1)

   'Doe'

   >>> match.group(2)

   'John'

   >>> match.group(3)

   '555-1212'

 """

 match = re.search(r'(?P<last>\w+), (?P<first>\w+): (?P<phone>\S+)', contactInfo)

 """

  >>> match.group('last')

   'Doe'

   >>> match.group('first')

   'John'

   >>> match.group('phone')

   '555-1212'

 """

匹配email

 email = "alex.li@126.com   http://www.oldboyedu.com"

 m = re.search(r"[0-9.a-z]{0,26}@[0-9.a-z]{0,20}.[0-9a-z]{0,8}", email)   #r代表不转义

 print(m.group())

作业：计算器开发

• 实现加减乘除及拓号优先级解析
• 用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后，必须自己解析里面的(),+,-,*,/符号和公式，运算后得出结果，结果必须与真实的计算器所得出的结果一致