天天看点
返回

函数式编程函数函数传递和引用

函数

  • 函数定义：

    函数是一段有特定功能、可以重复使用的代码。

  • 函数基本语法:

    def functionName(paraments): 以def开头

    “”"函数文档字符串”“” 用以说明函数用途

    function suite

    return [expression] 结束函数，返回一个值给调用方，不带表达

    式的return相当于返回None

  • 函数调用基本语法：

    [返回值] = 函数名[(形参值)]

def testDemo(demo):
	re = demo + 1
	return re
re = testDemo(1)
print(re)

函数传递和引用

  • 形式参数：定义函数时，函数名后面括号中的就是形参

  • 实际参数：调用函数时，函数名后面括号中的就是实参，也就是调用方给

    函数的参数

def testDemo(demo):   #形参
	re = demo + 1
	return re
re = testDemo(1)	 #实参
print(re)

可变参数和不可变参数

  • 不可变参数

    整数、字符串、元组

  • 可变参数

    字典、列表

ef changetuple(tu):
	tu = (1,2,3,4)
	print('体内',tu)
tu = (1,2,3,5)
changetuple(tu)
print(tu)

def testList(li1):
	li1.append(2)

	print('内',li1)
li1 = [1,2,3]
testList(li1)
print('外',li1)

函数参数 

#位置参数，根据位置匹配
def fun_a(a,b):
	print('a={},b={}'.format(a,b))
fun_a(1,2)

#关键字参数，根据参数名匹配
def fun_a(a,b):
	print('a={},b={}'.format(a,b))
fun_a(b=1,a=2)

#默认参数，有传参使用传参，不传值使用默认值，
def fun_a(a,b,c='test'):
	print('a={},b={},c={}'.format(a,b,c))
fun_a(a='he',b=2)
fun_a(1,2,3)

#可变参数（不定长参数）
#*a代表元组参数，**b代表字典参数
def fun_b(*a,**b):
	print('a={},b={}'.format(a,b))
fun_b(10,11,12,name='sz',age=28)

return函数

return语句指定返回值可以是任意类型，return语句可以在同一函数中出现多次，有一个return被执行，剩下的都不会被执行

语法：return [返回值]

返回值参数不写时返回空值None

def add(a,b):
	c = a + b
	return a,b,c
def add1():
	x,y,z = add(10,20)
	print(x,y,z)
add1()

变量作用域

  • 全局变量

    在所有函数外部定义的变量称为全局变量，作用域是整个程序，既可以在函数内部使用也可以在函数外部使用

  • 局部变量

    在函数内部定义的变量称为局部变量，作用域是函数内部

#局部变量
def funa():
	fun_str = '内部函数'
	print('函数体内：',fun_str)
funa()
#外部调用报错
#print(fun_str)

#函数参数，从外部传入的实参只能在函数内部生效
def funb(name,age):
	print('{}的年龄是{}'.format(name,age))
funb('小明',18)
#外部调用报错
#print(name,age)

#全局变量
test1 = 'hello'
def func():
	print('函数体内：',test1)
func()
print('函数体外：',test1)

#global在函数体内申明全局变量
def fund():
	global fun
	fun = 'all_in'
	print('函数体内：',fun)
fund()
print('函数体外：',fun)

获取指定作用域范围中的变量

  • globals()函数

    返回一个包含全局范围内所有变量的字典，键为变量名，值为变量值

    打印全局变量print(globals())

    打印某个全局变量的值print(globals()[‘demo’])

  • locals()函数

    返回一个包含当前作用域内所有变量的字典

    打印局部变量print(locals())

    打印某个局部变量的值print(locals()[‘test’])

  • vars()函数

    返回类中所有变量的字典，不加object参数和locals()作用一致

    print(vars())

#globals（）可以修改局部变量的值
#locals（）在函数体内获取的是局部变量，在函数体外获取的是全局变量
#不调用函数时locals()一直获取不到局部变量的值
kind = 'cook'
def testkind():
	food = 'pook'
	print(locals())
	globals()['food'] = 'beef'
testkind()
print(globals()['kind'])
print(locals())

#gloabls()打印出来是字典，通过for循环遍历出来里面的值
for k,v in dict(globals()).items():
	print(k,v)
class test2:
	name="李四"
	age=19
print(vars(test2))

局部函数用法(nonlocal)

含义：函数体内定义函数称之为局部函数

#局部函数，在外层函数调用局部函数
def funa():
	def funb():
		print('www.test.com')
	funb()
funa()
#将局部函数作为外层函数的返回值，可以扩大局部函数的作用域
def funa():
	age = 10
	def funb():
		name = '张三'
		print('{}的年龄时{}'.format(name,age))
	return funb()
func = funa() #类似于func=funb
func()

#局部函数有同名函数，会发生遮蔽，需要用nonlocal关键字申明
#在定义同名变量之前先打印或造成遮盖的问题
def outdef():
	name = 'zhangsan'
	def indef():
		nonlocal name
		print(name)
		name = 'lisi'
	indef()
outdef()

匿名函数用法(lambda)

不给函数起名称的函数叫匿名函数

语法：变量名=lambda 参数：表达式

参数可选，以逗号分隔

表达式不能包含循环return，可以包含if……else……

优势：省去定义函数的过程；单次使用逻辑简单可以使用匿名函数

def funa():
	return 1==2
	print(funa())
a = lambda:1==2
print(funa())

b=lambda x,y,z:x+y+z
print(b(1,3,4))

d = lambda x,y: x==y
e = d(1,2)
print(e)

递归函数

含义：函数调用函数本身的函数是递归函数，递归函数由基础部分和递归部分组成

"""
阶乘
1！=1*1
2！=1*2		  2!=1!*2
3！=1*2*3     3!=2!*3
4!=1*2*3*4    4!=3!*4
5!=1*2*3*4*5  5!=4!*5
n=(n-1)*n
"""

def fun_a(n):
	if n == 1:
		return n
	n = fun_a(n-1) * n
	return n
re = fun_a(5)
print(re)

"""
斐波那契数列
0
1
1
2
3
5
8
13
21
34
n > = 3
fn = (n-1)+(n-2)
"""
def testdemo(n):
	if n <= 2:
		v = 1
		return v
	v=testdemo(n-1)+testdemo(n-2)
	return v
m = testdemo(6)
print(m)

高阶函数

函数对象作为参数传递给函数或者函数对象作为函数的返回值叫做高阶函数，即函数的函数

  • 函数式编程 map()

    语法：map(function,iterable)

    传入一个函数和一个可迭代对象

#幂函数
def square(x):
	return x**2	
#列表
list1 = [1,2,3,4]
#用map进行幂计算
map1 = map(square, list1)
#map返回的是一个迭代器
print(map1)
#转换成list
map_list = list(map1)
print(map_list)

#规范命名，首字母大写，其余小写
list2 = ['MIKE', 'anna', 'WiNg', 'diNa']
#匿名函数
#写法一
map2 = map(lambda x: x[:1].upper() + x[1:].lower(), list2)
map_list2 = list(map2)
print(map_list2)
#写法二
def name(y):
	return y[:1].upper() + y[1:].lower()
map3 = map(name, list2)
map_list3 = list(map3)
print(map_list3)

#传入多个可迭代对象，长度不一致，取最短的

list_l = [1,2,3,4,5,6]
list_s = [1,4,5]
def add(x,y):
	return x+y
map4 = map(lambda x,y:x+y,list_l,list_s)
# map4 = map(add,list_l,list_s)
map_list4 = list(map4)
print(map_list4)

  • filter()函数

    语法：filter(function,iterable)

    由函数和可迭代对象组成，iterable中的每个元素都需要给function判断，最后所有返回true的组成一个新的可遍历的集合

def jishu(x):
	return x%2!=0
list1 = [1,2,3,4,5,6,7,8,9]
# filter1 = filter(lambda x:x%2==0,list1)
filter1 = filter(jishu,list1)
list_filter = list(filter1)
print(list_filter)

  • reduce()函数

    语法：reduce(function.iterable)

    function函数必须包含两个参数，iterable表示一个可迭代对象

    对集合做一些累积操作

#需要先导入functools模块
import functools

sentences = ['The Deep Learning textbook is a resource intended to help students and practitioners enter the field of machine learning in general and deep learning in particular. ']

#统计元素出现的次数
count1 = functools.reduce(lambda x,y:x+y.count('and'),sentences,0)
print(count1)

#对元素进行相加
def add(x, y):
    return x + y
list1 = [1, 2, 3, 45, 1]
# reduce1 = functools.reduce(add, list1)
reduce1 = functools.reduce(lambda x,y:x+y,list1)
print(reduce1)

zip()函数

语法：zip(iterable)

将可迭代对象作为参数，把参数打包成一个个元组，然后再把元组组成一个列表

zip(*iterable)把元组解压成列表

a = [1,2,3]
b = [4,5,6,9,1]
c = [7,8,9,0]
d = zip(a,b,c)
e = list(d)
print(e)
f = zip(*e)
f1 = list(f)
print(f1)
Python lambda filter
上一篇: Lambda函数式编程（一）
下一篇: 函数式编程与lamada表达式函数式接口lamada表达式

继续阅读