python高级特性与高阶函数

最新推荐文章于 2022-11-23 16:26:46 发布

原创最新推荐文章于 2022-11-23 16:26:46 发布 · 681 阅读

1 ·

CC 4.0 BY-SA版权

python 专栏收录该内容

13 篇文章

订阅专栏

本文深入讲解了递归函数、函数式编程、高阶函数等高级编程概念，并通过具体实例介绍了列表生成式、迭代器、生成器等高效编程技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

######高阶特性######

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)

# 匿名函数传递必选参数和默认参数

f = lambda x,y=2:x**y

print f(2,3)

print f(2)

# 匿名函数传递可变参数

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