python alpha函数_python函数(day4)

函数

如果定义了一个变量使用了函数的名，可以在使用完变量后，del 变量，释放内存中的变量，使函数可用。

def function_name(arg1,arg2[,...]):

'''Print sth .

print the dcostring''' #文档字符串首行以大写字母开头，句号结尾，第二行空行，第三行开始是详细描述。可以使用__doc__

statement

[return value] #return不是必须的，如果没有return则返回none，如果要让函数返回多个值，可以使用元组。

定义函数define

def my_abs(x): #多个参数使用逗号分隔

"""this is function use help to show """ #使用print my_abs.__doc__可以打印出这部分doc内容

if x >= 0:

return x #返回多个值会集合成元祖tuple的形式,若没有return语句则返回None

else:

return -x

如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():

pass

实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

默认参数

定义函数的时候，默认参数(一般必选参数在前，默认参数在后)，默认参数必须指向不变对象

def power(x, n=2):

s = 1

while n > 0:

n = n - 1

s = s * x

return s

print power(x=1,n=3)

可变参数

可以利用可变参数调用，即迭代元祖的值

def calc(*numbers):

sum = 0

for n in numbers:

sum = sum + n * n

return sum

函数参数中带**，返回字典，若是*返回元组

def t(**kr):

return kr

print t(a=1,b=2,c=3,d=4)

输出 {'a': 1, 'c': 3, 'b': 2, 'd': 4}

def t(*kr):

return kr

print t(1,2,3,4)

输出 (1, 2, 3, 4)

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

def person(name, age, **kw):

print 'name:', name, 'age:', age, 'other:', kw

输出结果如下

>>> person('Bob', 35, city='Beijing')

name: Bob age: 35 other: {'city': 'Beijing'}

>>> person('Adam', 45, gender='M', job='Engineer')

name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

函数组合

函数的参数位置按照 位置匹配=》关键字匹配=》收集元祖参数=》收集匹配的关键字参数

函数的作用域：在函数内部优先使用内部变量，也可以使用全局变量，函数之间的局部变量互不影响。如果函数中的变量使用global则该变量全局可用，大多数名字引用在三个作用域中查找：先局部(Local)，次之全局(Global)，再次之内置(Build-in)。

a=42

b=13

def foo():

global a #a位于全局namespace中

a=1

b=2

foo() #a的值改变了，b没有变

使用函数传入的参数不要是可变类型，可能会影响值，如下示例：

def fun1(arg):

arg[0]=5

return arg

print fun1([1,2,3])

结果为[5, 2, 3]，其中第一个值被改掉了，需要特别注意

自省与函数 func.code

print dir(fun1.code)

print fun1.code.co_filename

高级特性

Slice 切片

左包含，右不包含，左右值一样，则空

>>> L[0:3]

>>> ['Michael', 'Sarah', 'Tracy'] #从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，步长为1

L = range(100)

L

L[:10]

L[-10:]

L[:10:2]依次取10个数，再每两个取一个

Iteration迭代

任何可迭代对象都可以作用于for循环，包括我们自定义的数据类型，只要符合迭代条件，就可以使用for循环。

通过collections模块的Iterable类型来判断一个对象是否可迭代

from collections import Iterable

isinstance('abc', Iterable) # str是否可迭代

isinstance([1,2,3], Iterable) # list是否可迭代

isinstance(123, Iterable) # 整数是否可迭代

List Comprehensions列表生成式

print [x * x for x in range(1, 11)]

[x * x for x in range(1, 11) if x % 2 == 0]

Generator 生成器

任何使用yield的函数称为生成器，调用生成器函数将创建一个对象，该对象通过连续调用next()的方法(python3种是__next__())生成结果序列。

def countDown(n):

print "now counting down!"

while n > 0:

yield n

n -=1

c = countDown(10)

c.next()

c.next()

将列表生成式的[] 变为() ，保存的是算法而不是值

g = (x * x for x in range(10))

g.next()

Generator也是可迭代，所以可以用for进行调用

g = (x * x for x in range(10))

for n in g:

print n

def fib(max): #define斐波拉契数列

n, a, b = 0, 0, 1

while n < max:

print b

a, b = b, a + b

n = n + 1

def fib(max):

n, a, b = 0, 0, 1

while n < max:

yield b #如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator

a, b = b, a + b

n = n + 1

生成器是基于处理管道、流或数据流编写程序的一种极其强大的方式。

示例：模拟tail -f

import time

def tail(f):

f.seek(0,2) #移动到EOF

while True:

line = f.readline() #尝试读取一个新的文本行

if not line: #如果没有内容，暂时休眠并在此尝试

time.sleep(0,1)

continue

yield line

lambda

lambda是一个表达式.它没有名称，存储的也不是代码块,它被用作执行很小的功能，不能在里面使用条件语句

d = lamdba x:x+1

print d(2)

print d(4)

函数式编程

传入函数

def add(x, y, f):

return f(x) + f(y)

当我们调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs

map/reduce

Python内建了map()和reduce()函数。

map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

def f(x):

return x * x

map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

map和reduce配合

>>> def fn(x, y):

... return x * 10 + y

...

>>> def char2num(s):

... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

...

>>> reduce(fn, map(char2num, '13579'))

13579

整理成一个str2int的函数就是：

def str2int(s):

def fn(x, y):

return x * 10 + y

def char2num(s):

return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

return reduce(fn, map(char2num, s))

还可以用lambda函数进一步简化成：

def char2num(s):

return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

def str2int(s):

return reduce(lambda x,y: x*10+y, map(char2num, s))

也就是说，假设Python没有提供int()函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！

filter

和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

def is_odd(n):

return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])

结果: [1, 5, 9, 15]

sorted

Python内置的sorted()函数就可以对list进行排序

传入自定义的比较函数reversed_cmp，就可以实现倒序排序

Closure 闭包

def f1(a):

def f2(b):

return a+b

return f2

q=f1(10)

print q