函数-内置函数,匿名函数,嵌套函数,高阶函数,序列化

函数简单说明

# 函数即"变量"
# 高阶函数
#     a.把一个函数名当做实参传给另一个函数(在不修改被装饰函数的源代码的情况下,为其添加功能)
#     b.返回值中包含函数名(不修改函数的调用方式)
‘‘‘
import  time
def bar():
    print("in the bar!")
    time.sleep(2)

def foo(func):
    start_time = time.time()
    func()                  #根据内存地址,执行代码
    stop_time = time.time()
    print("run time %s"  %(stop_time-start_time))
foo(bar)

#函数嵌套,是在一个函数内,用一个def来定义一个新的函数
def foo():
    print("in the foo")
    def bar():
        print("in the bar")
    bar()

#函数调用
def foo():
    print("in the foo")
    bar()

def bar():
    print("in the bar")

简单函数

匿名函数

 1 calc = lambda a,b :a+b
 2 print(calc(1,2))
 3
 4 calc = lambda n : 3 if n<5 else n*n
 5 print(calc(12))
 6
 7 res = filter(lambda n:n>5,range(10))
 8 res = map(lambda n:n*n,range(5))
 9 for i in res:
10     print(‘----‘,i)
11
12 res = [lambda i:i*2 for i in range(10)]

内置函数

  1 # -*- coding:utf-8 -*-
  2 # LC
  3 print(all([1,2,3,0,4]))     #all中的课迭代对象全为真则返回真
  4 print(any([1,2,3,0]))       #any中有一个为真则返回真
  5 print(bin(101))             #把数字转换成2进制
  6 print(bool({}))             #判断整数是否为真,列表,元组,字典如果为空,则返回False
  7
  8 a = bytes("abcde",encoding="utf-8")     #字符串默认是不能够修改的
  9 b = bytearray("abcde",encoding="utf-8")     #将原有数据变化成一个列表,并且可以改变
 10 b[1] = 100                          #改变列表中的值,但必须要赋值一个整型,为ASCII码表对应的数字,即d对应ASCII码中的100
 11 print("----",b)
 12
 13 callable([])      #判断是否为可调用对象,函数,类都是可以调用的,即是否有()调用
 14 print(callable([]))
 15 def hel():pass
 16 print(callable(hel))
 17
 18 chr(100)        #输入数字,返回数字对应的unicode表中的字符
 19 print("----",chr(97))
 20
 21 ord("i")       #输入字符,将字符对应的unicode表的数字返回
 22 print(ord("你"))
 23
 24 code = "for i in range(10):print(i)"
 25 exec(code)      #exec能够将字符串转换成可执行代码并执行
 26
 27 print(dir(code))   #查看一点对象具体有什么方法可以使用
 28
 29 print(divmod(10.2,2.2)) #查看两张相除的结果及余数
 30
 31 #enumerate([])         #将可迭代对象按着序列号排序
 32 list1 = [‘January‘,‘February‘,‘March‘,‘April‘,‘May‘,‘June‘,‘July‘,‘August‘,‘September‘,‘October‘,‘November‘,‘December‘]
 33 print(list(enumerate(list1,start=1)))               #表示从1开始计数,将list1中的对象分配一个序号
 34 for index,i in enumerate(list1,start=1):
 35     print(index,i)
 36
 37 #filter
 38 res = filter(lambda n:n>5,range(10))        #结合lambda,filter将lambda中为True的返回
 39 for i in res:
 40     print(i)
 41 #map
 42 res = map( lambda n:n*2,range(6))           #map将lambda range中所有的元素进行运算
 43 for i in res:
 44     print(i)
 45
 46 res = [lambda i:i*2 for i in range(10)]
 47 #reduce
 48 import functools
 49 rese = functools.reduce(lambda x,y:x+y,range(5))       #表示x,y默认从0,1开始,x+y结果传递给x,y每次+1,并把结果给x,(即列表中所有数字相加)
 50 print(rese)
 51
 52 res = functools.reduce(lambda x,y:x*y,range(1,10))      #列表中所有数字相乘
 53 print(‘----‘,res)
 54
 55 #frozeset
 56 a = frozenset([1,2,3,5,534,4,34,2])         #表示一个不可变集合,即默认集合拥有的方法将无法使用
 57 print(a)
 58
 59 #globals()          #将整个程序,仅这个文件的变量按着key,value的格式,字典的方式呈现
 60 print(globals())
 61
 62 #hash
 63
 64 #hex            #将数字转换成16进制
 65 #oct(x)         #将数字转换成8进制
 66 hex(152)
 67
 68 #id             #返回内存地址
 69 print(‘---‘,id(1))
 70
 71 #locals()           #寻找局部变量中的变量,仅在局部有效
 72
 73 #max()              #找出最大的值
 74 #min()
 75
 76 #pow
 77 print(pow(2,4,5))            #求x的y次方,然后使用z求余
 78
 79 #round
 80 print(round(1.232122322,5))              #表示保留小数点后几位
 81
 82 #sorted
 83 a = {5:2,8:0,1:4,-5:7,99:11}
 84 print(sorted(a.items()))                #将字典a变成列表,并排序,默认按着字典的key排序
 85 # 结果:[(-5, 7), (1, 4), (5, 2), (8, 0), (99, 11)]
 86 print(sorted(a.items(),key=lambda x:x[1]))      #按着字典value排序,使用lambda来指定转换后的列表中的第二个数字排序
 87 # 结果:[(8, 0), (5, 2), (1, 4), (-5, 7), (99, 11)]
 88
 89 #zip                #将多个可迭代对象进行相互柔和,以最短的算
 90 a = (1,2,3,4,5,6,7)
 91 b = (‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘)
 92 print(len(b))
 93 c = (‘+‘ for i in range(len(b)))        #使用生成器生成一个元组
 94 print(c)
 95 for i in zip(a,b,c):
 96     print(i)
 97
 98 #map                #将可迭代对象按着函数执行,即将可迭代对象的值传递给函数,并返回结果
 99 def hel(*args):
100
101     return args
102 for i in map(hel,a,b):
103     print(i)

内置函数

序列化

 1 #json序列化               #json能够将内存中的熟悉序列化值硬盘文件中,json只能序列号简单的,如列表,元组,字典等,函数不行
 2 import  json
 3 info = {
 4     ‘name‘:‘lc‘,
 5     ‘age‘:19
 6 }
 7 f = open("test.txt",‘w‘)
 8 f.write(json.dumps(info))
 9 f.close()
10
11 #json反序列化               #json返序列化能够将文件中的数据加载至内存中,保持原格式
12 f = open("test.txt","r")
13 data = json.loads(f.read())     #通过loads来实现
14 print(data["age"])              #可以直接读取
15 f.close()
16
17 #pickle序列化              #pickle能够序列化复杂的对象类型,如函数,pickle仅在python中有效,json是在各种语言中都有效
18 import pickle
19 import json
20 def hello(name):
21     print("hello,",name)
22 info = {
23     ‘name‘:‘lc‘,
24     ‘age‘:‘19‘,
25     ‘func‘:hello                    #函数
26 }
27 f = open("test.txt","wb")               #pickle序列化需要用字节格式
28 pickle.dump(info,f)              #等价于f.write(pickle.dumps(info))
29 f.close()
30
31 #pickle反序列化
32 f = open("test.txt","rb")
33 data = pickle.load(f)                                #等价于data = pickle.loads(f.read())
34 print(data["func"]("lvcheng"))
35 f.close()

高阶函数

转载:http://www.cnblogs.com/ghgyj/p/3997548.html

要理解“函数本身也可以作为参数传入”,可以从Python内建的map/reduce函数入手。

如果你读过Google的那篇大名鼎鼎的论文“MapReduce: Simplified Data Processing on Large Clusters”,你就能大概明白map/reduce的概念。

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

举例说明,比如我们有一个函数f(x)=x2,要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上,就可以用map()实现如下:

现在,我们用Python代码实现:

>>> 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]

请注意我们定义的函数f。当我们写f时,指的是函数对象本身,当我们写f(1)时,指的是调用f函数,并传入参数1,期待返回结果1。

因此,map()传入的第一个参数是f,即函数对象本身。

map()函数这种能够接收函数作为参数的函数,称之为高阶函数(Higher-order function)。

你可能会想,不需要map()函数,写一个循环,也可以计算出结果:

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print L

的确可以,但是,从上面的循环代码,能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗?

所以,map()作为高阶函数,事实上它把运算规则抽象了,因此,我们不但可以计算简单的f(x)=x2,还可以计算任意复杂的函数。

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

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

比方说对一个序列求和,就可以用reduce实现:

>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

当然求和运算可以直接用Python内建函数sum(),没必要动用reduce。

但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579,reduce就可以派上用场:

>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

这个例子本身没多大用处,但是,如果考虑到字符串str也是一个序列,对上面的例子稍加改动,配合map(),我们就可以写出把str转换为int的函数:

>>> 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()函数,你完全可以自己写一个把字符串转化为整数的函数,而且只需要几行代码!

lambda函数的用法在下一节介绍。

时间: 2024-10-09 06:45:16

函数-内置函数,匿名函数,嵌套函数,高阶函数,序列化的相关文章

Python学习笔记八:文件操作(续),文件编码与解码,函数,递归,函数式编程介绍,高阶函数

文件操作(续) 获得文件句柄位置,f.tell(),从0开始,按字符数计数 f.read(5),读取5个字符 返回文件句柄到某位置,f.seek(0) 文件在编辑过程中改变编码,f.detech() 获取文件编码,f.encoding() 获取文件在内存中的编号,f.fileno() 获取文件终端类型(tty.打印机等),f.isatty() 获取文件名,f.name() 判断文件句柄是否可移动(tty等不可移动),f.seekable() 判断文件是否可读,f.readable() 判断文件是

python内置常用高阶函数(列出了5个常用的)

原文使用的是python2,现修改为python3,全部都实际输出过,可以运行. 引用自:http://www.cnblogs.com/duyaya/p/8562898.html https://blog.csdn.net/cv_you/article/details/70880405 python内置常用高阶函数: 一.函数式编程 •函数本身可以赋值给变量,赋值后变量为函数: •允许将函数本身作为参数传入另一个函数: •允许返回一个函数. 1.map()函数 是 Python 内置的高阶函数,

内置高阶函数

1. map()map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回.注意:map()函数不改变原有的 list,而是返回一个新的 list.例如:def f(x): return x*x res = map(f,[1, 2, 3, 4, 5, 6, 7, 8, 9])print(list(res)) 2. reduce() reduce()函数也是Python内置的一个高阶函数.r

day12——Python高阶函数及匿名函数

高阶函数:就是把函数当成参数传递的一种函数,例如: def add(x,y,f): return f(x) + f(y) print(add(-8,11,abs)) 结果:19 解释: 1.调用add函数,分别执行abs(-8)和abs(11),分别计算出他们的值 2.最后再做和运算 map()函数 map函数时Python内置的一个高阶函数,它接受一个函数f和一个list,并把list的元素以此传递给函数f,然后返回一个函数f处理完所有list元素的列表,如下所示: def f2(x): re

高阶函数和装饰器

函数式:一种编程范式 纯函数式编程:没有变量,支持高阶函数编程 Python不是纯函数式编程语言,支持高阶函数编程 变量可以指向函数,函数名就是指向函数的一个变量,与普通变量没有区别 高阶函数:能接收函数做参数的函数. map():是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回. def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7

Python进阶:函数式编程(高阶函数,map,reduce,filter,sorted,返回函数,匿名函数,偏函数)...啊啊啊

函数式编程 函数是Python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单的任务,这种分解可以称之为面向过程的程序设计.函数就是面向过程的程序设计的基本单元. 而函数式编程(请注意多了一个"式"字)--Functional Programming,虽然也可以归结到面向过程的程序设计,但其思想更接近数学计算. 我们首先要搞明白计算机(Computer)和计算(Compute)的概念. 在计算机的层次上,CPU执行的是加减乘除的指令代码

5.初识python装饰器 高阶函数+闭包+函数嵌套=装饰器

一.什么是装饰器? 实际上装饰器就是个函数,这个函数可以为其他函数提供附加的功能. 装饰器在给其他函数添加功能时,不会修改原函数的源代码,不会修改原函数的调用方式. 高阶函数+函数嵌套+闭包 = 装饰器 1.1什么是高阶函数? 1.1.1函数接收的参数,包涵一个函数名. 1.1.2 函数的返回值是一个函数名. 其实这两个条件都很好满足,下面就是一个高阶函数的例子. def test1(): print "hamasaki ayumi" def test2(func): return t

python学习笔记之函数总结--高阶函数以及装饰器

python学习笔记之函数总结--高阶函数以及装饰器 Python特点: 1.不是纯函数式编程(允许变量存在): 2.支持高阶函数(可以传入函数作为变量): 3.支持闭包(可以返回函数): 4.有限度的支持匿名函数: 高阶函数: 1.变量可以指向函数: 2.函数的参数可以接收变量: 3.一个函数可以接收另一个函数作为参数: 下面我将示例一些函数的写法以及使用,并说明python中函数的特性: 1.基本的高阶函数示例: #!/usr/bin/env python def func():      

python中的高阶函数

高阶函数英文叫Higher-order function.什么是高阶函数?我们以实际代码为例子,一步一步深入概念. 变量可以指向函数 以Python内置的求绝对值的函数abs()为例,调用该函数用以下代码: >>> abs(-10) 10 但是,如果只写abs呢? >>> abs <built-in function abs> 可见,abs(-10)是函数调用,而abs是函数本身. 要获得函数调用结果,我们可以把结果赋值给变量: >>> x

【进阶 6-1 期】JavaScript 高阶函数浅析

引言   本期开始介绍 JavaScript 中的高阶函数,在 JavaScript 中,函数是一种特殊类型的对象,它们是 Function objects.那什么是高阶函数呢?本节将通过高阶函数的定义来展开介绍. 高阶函数 高阶函数英文叫 Higher-order function,它的定义很简单,就是至少满足下列一个条件的函数: 接受一个或多个函数作为输入 输出一个函数 也就是说高阶函数是对其他函数进行操作的函数,可以将它们作为参数传递,或者是返回它们. 简单来说,高阶函数是一个接收函数作为