[005]Python的函数_基础_全栈基础

您好！此笔记的文本和代码以网盘形式分享于文末！

因个人能力有限，错误处欢迎大家交流和指正！基础部分内容简单，但多且零散！

python 函数功能和特性
1、定义与创建
定义：函数是一段组织好的，可重复使用的，用来实现某些功能的代码段
概念	形式	栗子
基本形式	def  函数名(参数1，参数2):     代码块	# 函数的定义 def my_lens():     """计算字符串的长度"""     s1 = 'hello function'     length = 0     for i in s1:         length = length + 1     print(length)     return # 函数调用 my_lens()
函数名	只能包含字符串、下划线和数字且不能以数字开头， 一般用_下划线间隔单词
注释	对功能和参数进行说明，写在函数下面第一行。 """ 这个函数实现了什么功能 参数1： 参数2： :return: 是字符串或者列表的长度 """
调用	函数名(实参1, 实参2)
2、函数的返回值：return
用法	栗子	结果
返回一个值	def ret_demo1():     """返回一个值"""     return "a" ret1 = ret_demo1() print(ret1)	a <class 'str'>
返回多个值 1个变量接收	def ret_demo2():     """返回多个值，一个变量接收"""     return 1, 2, 3, 4 def ret_demo3():     """返回多个任意类型的值"""     return 1, 'aB7', [1, '5v'], {'a': '王', } ret2 = ret_demo2() ret3 = ret_demo3() print(ret2, type(ret2)) print(ret3, type(ret3))	(1, 2, 3, 4) <class 'tuple'> (1, 'aB7', [1, '5v'], {'a': '王'}) <class 'tuple'>
返回多个值 多个变量接收 有几个返回值 就用几个变量接收	def ret_demo3():     """返回多个任意类型的值"""     return 1, 'aB7', [1, '5v'], {'a': '王', } a, b, c, d = ret_demo3() print(a, type(a), '\n', b, type(b), '\n', c, type(c), '\n', d, type(d))	1 <class 'int'> aB7 <class 'str'> [1, '5v'] <class 'list'> {'a': '王'} <class 'dict'>
3、函数的参数：顺序：位置参数，*args、默认参数、**kwargs
用法	栗子	结果
没有参数	不再举例
一个参数	def my_lens(s1):     """计算字符串的长度"""     length = 0     for i in s1:         length = length + 1     return length # 函数调用 s2 = 'hello function' ret1 = my_lens(s2) print("字符串长度：%s" % ret1)	字符串长度：14
多个参数   位置参数   按位置   按关键字   混合传参	def my_max(x, y):     """比较最大值"""     the_max = x if x > y else y     return the_max m1 = my_max(7, 8) m2 = my_max(y=9, x=10) m3 = my_max(15, y=12) print(m1, m2, m3)	8 10 15
默认参数	def stu_info(name, sex = "Female"):     """     打印狮群的信息，由于狮群母狮较多     所以默认性别值为‘Female’     """     print(name, sex) stu_info("simba", 'Male') stu_info("Nala")	simba Male Nala Female
默认参数    参数陷阱1	# 默认参数是一个可变数据类型 def fun_trap1(k, l=[]):     l.append(k)     print(l) fun_trap1('Lion') fun_trap1('Nala')	['Lion'] ['Lion', 'Nala']
默认参数    参数陷阱2	# 默认参数是一个可变数据类型 def fun_trap2(k, l={}):     """ """     l[k] = 'v'     print(l) fun_trap2(1) fun_trap2(3) fun_trap2(4)	{1: 'v'} {1: 'v', 3: 'v'} {1: 'v', 3: 'v', 4: 'v'}
动态参数  *args	# *args 接收的是按照位置传参的值，组织成一个元组 def my_sum(*args):     """     for实现求和函数     参数*args：动态参数     return ：返回和，数值     """     print(args, type(args))     the_sum = 0     for i in  args:         the_sum += i     return the_sum sum1 = my_sum(1, 3, 5, 7) print(sum1)	(1, 3, 5, 7) <class 'tuple'> 16
动态参数 **kwargs args必须在kwargs之前	# **kwargs 接受的是按照关键字传参的值，组织成一个字典 def stu_info(**kwargs):     print(kwargs, type(kwargs))     print(kwargs['name'], kwargs['sex']) stu_info(name='simba', sex='Male', name2='Nala', sex2="Female")	{'name': 'simba', 'sex': 'Male', 'name2': 'Nala', 'sex2': 'Female'} <class 'dict'> simba Male
动态参数   不一样的传参	def func_different1(*args):     print(args) def func_different2(**kwargs):     print(kwargs) l1 = [1, 'a', '王', 'B7'] d2 = {"a": 1, 'b': 2, } func_different1(1, 'a', '王', 'B7') func_different1(*l1) func_different2(a=1, b=2) func_different2(**d2)	(1, 'a', '王', 'B7') (1, 'a', '王', 'B7') {'a': 1, 'b': 2} {'a': 1, 'b': 2}
4、命名空间和作用域
命名空间的本质：存放名字与值的绑定关系
三种命名空间的加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)
作用域：作用范围，按照生效范围可以分为全局作用域和局部作用域；
全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域：局部名称空间，只能在局部范围内生效
用法	栗子	结果
globals和locals方法	c = 55 def func():     a = 12     b = 20     print(locals())     print(globals()) func()	{'b': 20, 'a': 12} {'__name__': '__main__',…………，“c”:55,……}
global关键字	a = 10 def func():     global a     a = 20 print(a) func() print(a)	10 20
5、 函数的嵌套 和作用域链
函数嵌套调用	def my_max2(x, y):     the_max = x if x > y else y     return  the_max def my_max4(a, b, c, d):     ret1 = my_max2(a, b)     ret2 = my_max2(ret1, c)     ret3 = my_max2(ret2, d)     return ret3 print(my_max4(10, 6, 77, 8))	77
函数嵌套	def func1():     print('01 in func1')     def func2():         def func3():             print('003 in func3')         print('004 in func2')         func3()     print('005 in func1')     func2() func1()	01 in func1 005 in func1 004 in func2 003 in func3
函数作用域链	def f1():     a = 1         def f2():         a = 2         print('in f2 a:', a)     f2()     print('in f2 a:', a) f1()	in f2 a: 2 in f2 a: 1
nonlocal关键字	# 函数的外部必须已声明变量 # nonlocal之前，函数内部不能出现同名变量 def f1():     a = 1     def f2():         nonlocal a         a = 2     f2()     print('in f1 a:', a) f1()	in f1 a: 2
6、函数名的本质和闭包：闭包会一直存在内存当中,不会因为函数执行结束而被释放
pythonTutor 编程在线视图：http://pythontutor.com/visualize.html#mode=edit
用法	栗子	结果
函数名的本质 函数名被引用	# 函数名的本质就是函数的内存地址 def f1():     print('Hello') f = f1 print(f)	<function f1 at 0x00000202C6112E18>
函数名作为 容器类型的元素	def f2():     print('This f2()') def f3():     print('This f3()') l1 = [f2, f3] d1 = {'a': f2, 'b': f3, } # 调用 l1[1]() d1['a']()	This f3() This f2()
闭包函数的创建 借助函数名本质	def func():     name = 'simba'     def inner():         print(name)     return inner f = func() f()	simba
判断是否为闭包函数	# 出的__closure__有cell元素 ：是闭包函数 def func():     name = 'simba'     def inner():         print(name)     print(inner.__closure__)     return inner f = func() f() # 输出的__closure__为None ：不是闭包函数 def func2():     def inner():         name = 'Nala'         print(name)     print(inner.__closure__)     return inner f1 = func2() f1()	“闭包”的作用——保存函数的状态信息，使函数的局部变量信息依然可以保存下来 (<cell at 0x00000174FC8C76A8: str object at 0x00000174FE51E8B8>,) simba None Nala
闭包的嵌套	def wrapper():     age = 8     def func():         name = 'simba'         def inner():             print(name, 'age:%d' % age)         return inner     return func f = wrapper() i = f() i()	simba age:8
闭包获取网页源码	from urllib.request import urlopen def index(url):     def get():         return urlopen(url).read()     return get # 返回的是get函数的地址 python = index("http://www.python.org") # 执行get函数《并且将返回的结果打印出来 print(python())

愿有更多的朋友，在网页笔记结构上分享更逻辑和易读的形式：

链接：暂无
提取码：暂无