函数，无大括号啊

def example_function(x,y,z=1.4):
    if z > 1:
        return z*(x+y)
    else:
        return z/(x+y)
#位置参数和关键字参数，关键字参数必须位于位置参数之后，不论是定义的时候还是调用的时候
print example_function(2,1,z=3)

a = None
def bind_a_variable():
    global a
    a = []
bind_a_variable()
print a
#可以在任何位置进行函数声明，即使是在局部函数
def outer_function(x,y,z):
    def inner_function(a,b,c):
        pass
    pass
#各个嵌套的内层函数可以访问其上层函数的局部命名空间，但是不能绑定新变量
#返回多个值，元组打包和拆包功能，让函数返回一个元组对象，然后将元组拆包到各个变量中
def f():
    a = 5
    b = 4
    c = 6
    return a,b,c
a,b,c=f()
#返回的是一个元组包
return_value = f()
print a,b,c,return_value
#返回字典
def g():
    a = 5
    b = 6
    c = 7
    return {'a':a,'b':b,'c':c}
return_dic = g()
print return_dic```

#进行数据清理

states = [' Alabama','Georgia!','Georgia','georgia','FLOrIda','south carolina###','West virginia?']

使用正则函数

import re
def clean_strings(strings):
#用于存储处理后的字符串
result = []
for value in strings:
value = value.strip()
value = re.sub('[!#?]','',value)
value = value.title()
result.append(value)
return result
print clean_strings(states)```

另一种方法，将所有的运算做成一个列表

def remove_punctuation(value):
    return re.sub('[!#?]','',value)
#将所有函数的名称做一个列表以便将来调用
clean_ops = [str.strip,remove_punctuation,str.title]
def clean_strings1(strings,ops):
    result = []
    for string in strings:
        for function in ops:
            string = function(string)
        #三个操作执行完之后将处理后的string存入result
        result.append(string)
    return result
print clean_strings1(states,clean_ops)```

#函数式编程，maps()函数

将function应用到后面的序列或者对象上

print map(remove_punctuation,states)```

匿名函数lambda

#声明该函数是匿名函数，单条语句组成，语句的结果就是返回值
equiv = lambda x : x*2
print equiv(2)
#使用函数做参数的时候用lambda会很方便
#一些例子
def apply_to_list(some_list,f):
    return [f(x) for x in some_list]
ints = [4,0,1,5,6]
print apply_to_list(ints,lambda x:x**2)
#python中乘方是**,按位异或是^
print [ x^2 for x in ints]```

#根据各字符串不同字母的数量进行排序，set()创建集合，只保存唯一的字母

strings = ['foo','card','bar','aaaa','abab']

向sort()方法中传入lambda函数,通过key参数

strings.sort(key=lambda x : len(set(list(x))))
print strings```

闭包，返回函数的函数

#闭包就是由其他函数动态生成并且返回的函数，被返回的函数可以访问其创建者的局部命名空间的变量
def make_closure(a):
    def closure():
        print ("I know the secret: %d" % a)
    return closure()
closure = make_closure(5)
#闭包即使其创建者已经执行完毕，闭包仍然能够继续访问创建者的局部命名空间
#闭包的内部状态一般都是静态的，但是也允许使用可变对象，字典，列表，集合等
def make_watch():
    have_seen = {}
    def has_been_seen(x):
        if x in have_seen:
            return True
        else :
            have_seen[x] = True
            return False
    return has_been_seen
#注意闭包函数的调用形式
watcher = make_watch()
vals = [4,3,4,5,23]
print [watcher(x) for x in vals]
#闭包可以修改任何内部状态对象，但是不能绑定外层函数作用域中的变量，必须这样做
def make_counter():
    count = [0]
    def counter():
        #使用列表而不是变量
        count[0] += 1
        return count[0]
    return counter
#make_counter()函数返回counter函数，所以调用形式是这样
counter = make_counter()
print counter()
#闭包的用处在于可以编写带有大量选项的非常一般化的函数，再组装出更加简单和专门化的函数，如下面的例子
def format_and_pad(template,space):
    def formatter(x):
        #Python rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。
        # 如果指定的长度小于字符串的长度则返回原字符串。
        return (template % x).rjust(space)
    return formatter
fmt = format_and_pad('%.4f',15)
print fmt(1.756)
#格式化字符串
print ('%.4f' % 1.756).rjust(15)```

#扩展调用语法和*args，**kwargs

位置和关键字参数分别是被打包成元组和字典的，函数实际接收到的是一个元组args和字典kwargs

a,b,c=args

d=kwargs.get("d",d_default_value)

e=kwargs.get("e",e_default_value)

一个例子

def say_hello_then_call_f(f,args,kwargs):
print "args is ",args
print "kwargs is ",kwargs
print ("hello! now i'm going to call %s" % f)
return f(args,**kwargs)
def g(x,y,z=1):
return (x+y)/z

使用say_hello_then_call_f来调用g

call_g = say_hello_then_call_f(g,1,2,z=5.0)
print call_g```

currying部分参数应用

#通过部分参数应用从现有的函数派生出新函数的技术
def add_numbers(x,y):
    return x+y
#通过这个函数派生出一个新的只有一个参数的函数
add_five = lambda y: add_numbers(5,y)
#所以add_numbers的第二个参数就是称为currying的
#functools模块可以用partial函数将此简化
from functools import partial
add_five1 = partial(add_numbers,5)
print add_five1(6)```

#生成器

以一致的方式对序列进行迭代(比如列表中的对象或者文件中的行),通过迭代器协议实现的，它是一种使得对象可迭代的通用方式

some_dict = {'a':1,'b':2,'c':3}
for key in some_dict:
print key,

迭代器是一种特殊对象，他可以在诸如for循环之类的上下文中向Python解释器输送对象

生成器generator是构造新的可迭代对象的另一种方式，生成器是以延迟的方式返回一个值序列

即每返回一个值后暂停，直到下一个值被请求时候再继续

要创建一个生成器，就是把函数中的return替换为yield就行，所以也是应用到函数上的。

def squares(n=10):
print "generating squares from 1 to %d" % (n 2)
for i in xrange(1,n+1):
#从1到n+1，生成一个逐一产生整数的迭代器
yield i2

调用该生成器的时候，没有任何代码会立即被执行

gen = squares(100)

当从该生成器中请求元素的时候，才会开始执行其代码

for x in gen:
print x```

找零钱的程序

def make_change(amount,coins=[1,5,10,25],hand=None):
    #三元表达式
    hand = [] if hand is None else hand
    #递归结束点，不断在hand列表生成元素
    if amount == 0:
        yield hand
        #最后amount==0生成的hand将作为返回值进行迭代，然后不断的迭代返回
    for coin in coins:
        #确保我们给出的硬币没有超出总额，且组合是唯一的
        if coin > amount or (len(hand) >0 and hand[-1] < coin):
            #如果coins里的元素大于要分配的美分，进行下一次循环。
            # 或者hand处理方法的长度大于0并且处理方法的最后一个元素比现在的coin元素下，尝试进行下一个coin的比较
            continue
        for result in make_change(amount - coin,coins=coins,hand=hand+[coin]):
            yield result
for way in make_change(100,coins=[10,25,50]):
    print way```

#生成器表达式

把列表推导式两端的方括号改成圆括号

gen = (x ** 2 for x in range(100))
print gen

生成器表达式可以用于任何接受生成器的Python函数

print sum(gen)
print dict((i,i**2) for i in range(10))```

文件

path = 'test.txt'
f = open(path,'a')
f.write("i love you  ")
f.close()
f = open(path,'r')
for line in f:
    print "\n",line
f.close()
lines = [x.rstrip() for x in open(path)]
print lines
#使用with语句
with open(path,'w') as handle:
    handle.writelines(x for x in open(path))```