Python函数

最新推荐文章于 2021-02-03 14:56:51 发布

小七月搬砖记

最新推荐文章于 2021-02-03 14:56:51 发布

阅读量153

点赞数

分类专栏：【Python】文章标签： python

本文链接：https://blog.csdn.net/weixin_40408952/article/details/108617665

版权

【Python】专栏收录该内容

15 篇文章 0 订阅

订阅专栏

> 函数简介（function）
	- 函数也是一个对象
	- 对象是内存中专门用来存储数据的一块区域
	- 函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用
	- 创建函数：
    	def 函数名([形参1,形参2,...形参n]) :
        	代码块
    - 函数名必须要符号标识符的规范
        （可以包含字母、数字、下划线、但是不能以数字开头）    
	- 函数中保存的代码不会立即执行，需要调用函数代码才会执行
	- 调用函数：
    	函数对象()
	- 定义函数一般都是要实现某种功能的

> 函数的参数
	- 在定义函数时，可以在函数名后的()中定义数量不等的形参，多个形参之间使用","隔开
	- 形参（形式参数），定义形参就相当于在函数内部声明了变量，但是并不赋值
	- 实参（实际参数）
    - 如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，实参将会赋值给对应的形参，简单来说，有几个形参就得传几个实参

> 定义一个函数
	- def fn() :
		print('这是我的第一个函数！')
		print('hello')
		print('今天天气真不错！')
		fn是函数对象  fn()调用函数
	-  定义一个函数求任意两个数的和
		def sum(a,b) :
			print(a,"+",b,"=",a+b)
			sum(8,8)

> 实参的传递方式
	- 位置参数
		位置参数就是将对应位置的实参复制给对应位置的形参
		第一个实参赋值给第一个形参，第二个实参赋值给第二个形参 。
		fn(1 , 2 , 3)
	- 关键字参数
		关键字参数，可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数
		fn(b=1 , c=2 , a=3)
		- print('hello' , end='')
			位置参数和关键字参数可以混合使用
			混合使用关键字和位置参数时，必须将位置参数写到前面

> 不定长的参数
	- 定义一个函数，可以求任意个数字的和
		def sum(*nums):
			# 定义一个变量，来保存结果
			result = 0
			# 遍历元组，并将元组中的数进行累加
			for n in nums :
    			result += n
			print(result)
		sum(123,456,789,10,20,30,40)
	- 在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参
	- 它将会将所有的实参保存到一个元组中
	- *a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）
		def fn(*a):
			print("a =",a,type(a))
		fn(1,2,3,4,5)
		输出：a = (1, 2, 3, 4, 5) <class 'tuple'>
	- 带星号的形参只能有一个
	- 带星号的参数，可以和其他参数配合使用
		# 第一个参数给a，第二个参数给b，剩下的都保存到c的元组中
		def fn2(a,b,*c):
			print('a =',a)
			print('b =',b)
			print('c =',c)
		- 可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递
			# 第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数
			def fn2(a,*b,c):
				print('a =',a)
				print('b =',b)
				print('c =',c)

			# 所有的位置参数都给a，b和c必须使用关键字参数
			def fn2(*a,b,c):
				print('a =',a)
				print('b =',b)
				print('c =',c)
			# 如果在形参的开头直接写一个*,则要求我们的所有的参数必须以关键字参数的形式传递
			def fn2(*,a,b,c):
				print('a =',a)
				print('b =',b)
				print('c =',c)
			fn2(a=3,b=4,c=5)
			# *形参只能接收位置参数，而不能接收关键字参数
			def fn3(*a) :
				print('a =',a)
	- **形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
	- 字典的key就是参数的名字，字典的value就是参数的值
	- **形参只能有一个，并且必须写在所有参数的最后
		def fn3(b,c,**a) :
			print('a =',a,type(a))
			print('b =',b)
			print('c =',c)
		fn3(b=1,d=2,c=3,e=10,f=20)
		输出：
			a = {'d': 2, 'e': 10, 'f': 20} <class 'dict'>
			b = 1
			c = 3

		# 参数的解包（拆包）
		def fn4(a,b,c):
			print('a =',a)
			print('b =',b)
			print('c =',c)	
		# 创建一个元组
		t = (10,20,30)
		# 传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
		# 这里要求序列中元素的个数必须和形参的个数的一致
		fn4(*t)   
		输出：
			a = 10
			b = 20
			c = 30
		# 创建一个字典
		d = {'a':100,'b':200,'c':300}
		# 通过 **来对一个字典进行解包操作
		fn4(**d)
		输出：
			a = 100
			b = 200
			c = 300

> help()是Python中的内置函数
	- 通过help()函数可以查询python中的函数的用法
	- 语法：help(函数对象)
		help(print) # 获取print()函数的使用说明
>文档字符串（doc str）
	- 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明
	- 当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明
	- 文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串
	- def fn(a:int,b:bool,c:str='hello') ->int:
		'''
		这是一个文档字符串
		'''
		return 10
	help(fn)
	结果：
		Help on function fn in module __main__:
		fn(a:int, b:bool, c:str='hello') -> int
		这是一个文档字符串

> 作用域（scope）
	> 在Python中一共有两种作用域
		全局作用域
			- 全局作用域在程序执行时创建，在程序执行结束时销毁
			- 所有函数以外的区域都是全局作用域
			- 在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问
		函数作用域
			- 函数作用域在函数调用时创建，在调用结束时销毁
			- 函数每调用一次就会产生一个新的函数作用域
			- 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问
		变量的查找
			- 当我们使用变量时，会优先在当前作用域中寻找该变量，如果有则使用，如果没有则继续去上一级作用域中寻找，如果有则使用，如果依然没有则继续去上一级作用域中寻找，以此类推直到找到全局作用域，依然没有找到，则会抛出异常
     		 NameError: name 'a' is not defined
     > 例子:
     	a = 20
		def fn3():
			# a = 10 # 在函数中为变量赋值时，默认都是为局部变量赋值
			# 如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量
			global a # 声明在函数内部的使用a是全局变量，此时再去修改a时，就是在修改全局的a
			a = 10 # 修改全局变量
			print('函数内部：','a =',a)
		fn3()
		print('函数外部：','a =',a)
		结果：
			函数内部： a = 10
			函数外部： a = 10

> 命名空间（namespace）
	- 命名空间指的是变量存储的位置，每一个变量都需要存储到指定的命名空间当中
	- 每一个作用域都会有一个它对应的命名空间
	- 全局命名空间，用来保存全局变量。函数命名空间用来保存函数中的变量
	- 命名空间实际上就是一个字典，是一个专门用来存储变量的字典
	> locals()用来获取当前作用域的命名空间
		如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间,返回的是一个字

 > 函数式编程
	- 在Python中，函数是一等对象
	- 一等对象一般都会具有如下特点：
    	① 对象是在运行时创建的
    	② 能赋值给变量或作为数据结构中的元素
    	③ 能作为参数传递
    	④ 能作为返回值返回
	- 高阶函数[高阶函数例子](https://blog.csdn.net/weixin_40408952/article/details/108732762)
    	- 高阶函数至少要符合以下两个特点中的一个
			① 接收一个或多个函数作为参数
			② 将函数作为返回值返回
	> filter()
		filter()可以从序列中过滤出符合条件的元素，保存到一个新的序列中
		参数：
		1.函数，根据该函数来过滤序列（可迭代的结构）
		2.需要过滤的序列（可迭代的结构）
		返回值：
		过滤后的新序列（可迭代的结构）
	> 匿名函数 lambda 函数表达式 （语法糖）
		lambda函数表达式专门用来创建一些简单的函数，他是函数创建的又一种方式
		语法：lambda 参数列表 : 返回值
		匿名函数一般都是作为参数使用，其他地方一般不会使用
		- def fn5(a , b):
			return a + b
		- (lambda a,b : a + b)(10,20)
	> map()
		map()函数可以对可跌倒对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回
		l = [1,2,3,4,5,6,7,8,9,10]
		r = map(lambda i : i ** 2 , l)
		print(list(r))
	> sort()
		该方法用来对列表中的元素进行排序
		sort()方法默认是直接比较列表中的元素的大小
		在sort()可以接收一个关键字参数 ， key
		key需要一个函数作为参数，当设置了函数作为参数
		每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小
		例子：
			l = ['bb','aaaa','c','ddddddddd','fff']
			l.sort(key=len)
			print(l)
			结果：['c', 'bb', 'fff', 'aaaa', 'ddddddddd']
			
			l = [2,5,'1',3,'6','4']
			l.sort(key=int)
			print(l)
			结果：['1', 2, 3, '4', 5, '6']
	> sorted()
		这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序
		并且使用sorted()排序不会影响原来的对象，而是返回一个新对象
		例子：
			l = [2,5,'1',3,'6','4']
			l = "123765816742634781"
			print('排序前:',l)
			print(sorted(l,key=int))
			print('排序后:',l)
			结果：
				排序前: [2, 5, '1', 3, '6', '4']
				['1', 2, 3, '4', 5, '6']
				排序后: [2, 5, '1', 3, '6', '4']

> 将函数作为返回值返回，也是一种高阶函数
> 这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量
	例子：
	def fn():
		a = 10
		# 函数内部再定义一个函数
		def inner():
    		print('我是fn2' , a)
		# 将内部函数 inner作为返回值返回   
		return inner
	# r是一个函数，是调用fn()后返回的函数
	# 这个函数实在fn()内部定义，并不是全局函数
	# 所以这个函数总是能访问到fn()函数内的变量
	r = fn() 
> 形成闭包的要件
	① 函数嵌套
	② 将内部函数作为返回值返回
	③ 内部函数必须要使用到外部函数的变量
	例子：
	def make_averager():
	# 创建一个列表，用来保存数值
	nums = []
		# 创建一个函数，用来计算平均值
		def averager(n) :
    		# 将n添加到列表中
    		nums.append(n)
    		# 求平均值
    		return sum(nums)/len(nums)
		return averager
	averager = make_averager()
	print(averager(10))
	print(averager(20))
	print(averager(30))