######高阶特性######
1. 递归函数
# # n! = 1x2x3x4x.......(n-1)xn= (n-1)!xn = (n-2)!x(n-1)xn # # 1! = 1 # 2! = (2-1)! x 2 = fact(2-1) x 2 # 3! = (3-1)! x 3 = (2-1)! x 2 x 3 = fact(3-1) x 3 = fact(1)x 2 x3 def fact(n): if not isinstance(n,int): print 'input int num' if n == 1: return 1 return fact(n-1)*n print fact(3) # # 1. 在写递归函数时要有一个明确的结束条件； # 2. 在递归时，问题规模要越来越小； # 3. 递归函数效率不高，函数调用是通过栈的数据结构实现的， # 每调用依次，栈就会多一层，最多999层，否则会出现栈溢出。 # 实现二分的效果 # n = 10 # 返回值为: # 5 # 2 # 1 def fun(n): if not isinstance(n,int): print 'Error Type' print n b = int(n/2) if b > 0: return fun(b)fun(18)
2. 函数式编程 # 面向对象编程语言:java,c++, python # 面向过程编程语言:c # 面向函数编程语言(lisp,erlang): f = y(x,y) (13+10)*2-8 面向过程: a = 13 + 10 b = a * 2 c = b -8 面向函数: result = jian(multipy(add(13,10),2),8)
3. 高阶函数
# 函数可以当作参数去传递 def fun1(x,y,fun): return fun(1,2)print fun1(1,2,max)
4.列表生成式
要生成 list [1, 2, 3, 4, 5, 6, 7] 可以用 range(1, 8) 但如果要生成 [1x1, 2x2, 3x3, ..., 7x7] 怎么做?
# [1,2,3,4,5,6,7] range(1,8) # [1,4,9,16,25,36,49] def fun(): li = [] for i in range(1,8): # print i li.append(i*i) return li print fun()
print [ i*i for i in range(1,8)] # 1~20,所有偶数的平方 print [ i*i for i in range(0,20,2)] print [ i*i for i in range(0,20) if i %2 == 0] # 写一个列表生成式，返回'123' 'ABC'两个字符串的结合，如下: # ['1A','1B','1C','2A','2B','2C','3A','3B','3C']
print [ i+j for i in '123' for j in 'ABC'] # li = [] # for i in range(0,20): # # if i % 2 == 0: # # li.append(i*i) #生成字典的的内容,格式为‘key=value’,返回其列表格式; d = {'name':'hello','age':'5'} # for k,v in d.items(): # print k,v print [ k+'='+v for k,v in d.items()] '''
# 练习:
将list中所有的字符串变为小写字母; # li = ['HEllo','World'] # 返回:['hello','world'] li = ['HEllo', 'World', 1] print [i.lower() for i in li if isinstance(i, str)] print [i for i in range(1000000)];
5.迭代
1># 判断数据类型是否为可迭代数据类型 In [25]: from collections import Iterable In [26]: isinstance('hello',Iterable) Out[26]: True In [27]: isinstance([1,2,3],Iterable) Out[27]: True In [28]: isinstance(1,Iterable) Out[28]: False In [29]: isinstance({1,2,3},Iterable) Out[29]: True In [30]: isinstance({"name":"fentiao"},Iterable) Out[30]: True In [31]: isinstance((1,2,3),Iterable) Out[31]: True 2>. 枚举方法，显示为索引-元素对 shopinfo = [ ('Iphone',1000), ('book',200), ('fentiao',3500) ] for i,v in enumerate(shopinfo): print i,v 3>. 在for循环里面引用两个变量 shopinfo = [ ('Iphone',1000), ('book',200), ('fentiao',3500) ] for k,v in shopinfo: print k,v
6.生成器generator # 1). 列表生成式受到内存的限制，列表容量是有限的； # 2). 列表生成式如果只需要前几个元素，浪费内存空间。 # 3). 访问生成式: # - for循环 # - g.next()方法 l = [i for i in range(1000)] # 列表生成式 g = (i for i in range(1000)) # 生成器 g.next() for i in g: print i # 4. 手动实现生成器 #定义一函数fib，实现斐波那契数列(Fibonicci): # 1, 1, 2, 3, 5, 8, 13, 21.......... # # def fib(n): # # 执行:fib(3) 输出:1,1,2 # 执行:fib(4) 输出:1,1,2,3 def fib(max): n,a,b = 0,0,1 while n < max: yield b a, b = b, a+b n += 1 for i in fib(4): print i def hello(): print 'a' yield 1 print 'b' yield 2 print 'c' yield 3 a = hello() a.next() a.next() a.next() # 通过yield实现单线程的并发运算 # 异步I/O模型epoll http nginx tomcat import time def consumer(name): print '%s 准备吃粉条了!' % (name) while True: fentiao = yield print ('粉条[%s]做出来了，被[%s]吃了') % (fentiao, name) # g = consumer('肖遥') # g.next() # g.send('孜然味') def producer(name): c1 = consumer('肖遥') c2 = consumer('韩窑') c1.next() c2.next() print '开始制作粉条晚餐了........' for i in ['清蒸','油炸','爆炒']: time.sleep(1) print '[%s] 做了两份粉条,两个人一块吃' %(name) c1.send(i) c2.send(i) producer('杨佳晨')
#######高阶函数######
1.函数 函数本身也可以赋值给变量,即:变量可以指向函数。
函数名其实就是指向函数的变量!
上述操作发现:abs为函数名,给abs=1重新赋值后,abs已不是函数,而是一个整数。
高阶函数 变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。
2.map函数 map() 函数接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元素,并把结果作为新的 list 返回。 不需要 map() 函数,写一个循环,也可以计算出结果.
map() 作为高阶函数,把运算规则抽象了. 练习: 把这list列表中的所有数字转为字符串;([1,2,3]---['1','2','3'])
3.reduce函数 reduce 把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce 把结果继续和序列的下一个元素做累积计算。
综合编程:写出把 str 转换为 int 的函数(eg:'12345'--12345)
map/reduce练习题 •利用 map() 函数,把用户输入的不规范的英文名字,变为首字母大写,其他小写的规范名字。输入: ['adam', 'LISA', 'barT'] ,输出: ['Adam', 'Lisa','Bart'] 。
•Python 提供的 sum() 函数可以接受一个 list 并求和,请编写一个 prod()函数,可以接受一个 list 并利用 reduce() 求积。
4.filter函数 filter() 也接收一个函数和一个序列。和 map() 不同的时, filter() 把传入的函数依次作用于每个元素,然后根据返回值是 True还是 False 决定保留还是丢弃该元素。 在一个 list 中,删掉偶数,只保留奇数:
把一个序列中的空字符串删请尝试用 filter() ;
• 用 filter()删除 1~100 的素数;
5.sorted函数
• 排序也是在程序中经常用到的算法。 无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。
通常规定如下:
x < y, return -1
x == y, return 0
x > y, return 1
• python内置的 sorted() 函数就可以对 list 进行排序;
• 如果要倒序排序呢?
• 如果要对字符串进行排序呢?sorted函数倒序排序
In [1]: t=(12,56,432,56,954) ##定义一个元组
In [2]: sorted(t) ##内置函数 :默认从小到大排列
Out[2]: [12, 56, 56, 432, 954]
In [4]: def reversed_cmp(x,y): ##自己定义函数：从大到小排列。（整数）
if x>y :
...: return -1
...: elif x<y :
...: return 1
...: else:
...: return 0
...:
In [5]: sorted(t,reversed_cmp) ##高阶函数
Out[5]: [954, 432, 56, 56, 12]
In [6]: li=["xiaoming","huangrong"] ##定义一个列表
In [7]: sorted(li) ##内置函数 :默认从小到大排列，按字母所对应的acsii码大小排列。
Out[7]: ['huangrong', 'xiaoming']
In [20]: li=['xiaoming', 'huangrong', 'Huangrong']
In [24]: "huangrong">"Huangrong"
Out[24]: True
In [17]: def ignore_case_cmp(x,y):##自己定义函数：从大到小排列（字母）
lower1=x.lower()
lower2=y.lower()
if lower1<lower2:
return -1
elif lower1>lower2:
....: return 1
....: else:
....: return 0
....:
In [21]: sorted(li,ignore_case_cmp) ###高阶函数
Out[21]: ['huangrong', 'Huangrong', 'xiaoming']
6.函数作为返回值
高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。
1>调用 warp_sum() 时,返回的并不是求和结果,而是求和函数f()
#调用函数 f 时,才真正计算求和的结果
def warp_sum(*args): ##定义一个把求和函数作为内置函数的函数：执行显示表达式（闭包）
def my_sum(): ##定义一个求和的函数：执行直接求和
sum_num=0
for i in args:
if not isinstance(i,(int,float)):
print "type error"
sum_num = sum_num +i
return sum_num
return my_sum
f = warp_sum(1,4,2) ##给函数赋值
print f() ##打印f
2>def count(): ##定义一个函数
fs=[] ##定义一个空列表
for i in range(1,4): ##循环遍历
def f():
return i*i
fs.append(f) ####将f添加到fs列表，f是函数的存储地址
return fs
f1,f2,f3,=count()
print f1 ##显示函数的存储地址
print f2
print f3
print f1,f2,f3() ##显示的是数值，数值都为9
解决方法：
def count():
fs=[]
for i in range(1,4):
def f(j):
def g(): ##在f函数里嵌套一个g函数
return j*j
return g
fs.append(f(i))
return fs
f1,f2,f3,=count()
print f1() ##返回的是各自对应值；1，4，9
print f2()
print f3()
7.匿名函数
# [1,2,3...10]
# [1,4,9,....100]
# 匿名函数的优势:
# 1). 匿名函数不需要函数名，可以避免函数名的冲突；
# 2). 匿名函数可以跳过给函数分配栈空间；
def pow1(x):
return x*x
print map(pow1,range(1,11))
print map(lambda x:x*x, range(1,11))
# 匿名函数可以赋值给一个变量，需要运行时，变量名()
f = lambda x : x*x
print f(2)
4
# 匿名函数传递必选参数和默认参数
f = lambda x,y=2:x**y
print f(2,3)
print f(2)
8
4
# 匿名函数传递可变参数
f = lambda *x:map(lambda x:x*x,x)
print f(1,2,3,4)
[1,4,9,16]
# 匿名函数传递关键字参数
f = lambda **kwargs:kwargs.items()
print f(name="fentiao",age=5)
[('age',5),('name','fentiao')]
#练习:利用匿名函数和字典重新编辑计算器的代码。
from __future__ import division
x = input('num1:')
oper = raw_input('operator:')
y = input('num2:')
d = {
"+": lambda x, y: x + y,
"-": lambda x, y: x - y,
"*": lambda x, y: x * y,
"/": lambda x, y: x / y
}
if oper not in d.keys():
print 'input +,-,*,/'
print d[oper](x,y)
8.装饰器
# 装饰器：用来装饰函数的一个函数
def timmer(func):
def deco():
start_time = time.time()
func()
stop_time = time.time()
return stop_time-start_time
return deco
def hello():
start_time = time.time()
time.sleep(1)
print 'hello....'
stop_time = time.time()
return stop_time-start_time
def hello1():
print 'hello1....'
@timmer
def hello2():
print 'hello2....'
time.sleep(2)
@timmer
def hello3():
print 'hello3....'
time.sleep(3)
print hello()
print hello1()
print hello2()
print hello3()
# 实例1： 理解函数即变量
def hello():
print 'hello.....'
hello1()
hello()
def hello1():
print 'hello1...'
# 实例2：
# 装饰器:添加功能，装饰函数；
# 1). 不修改函数的源代码；
# 2). 函数的调用方式没有改变
import time
def timmer(func):
def dec():
start_time = time.time()
func()
stop_time = time.time()
return "%s run %f s"%(func.__name__ ,stop_time-start_time)
return dec
@timmer #hello2=timmer(hello2),语法糖
def hello2():
print 'hello2....'
time.sleep(2)
print hello2()
