python入门函数,python函数基础知识

　　这篇文章给大家带来了一些关于python的知识，主要介绍了如何使用高级函数，包括函数的命名和作用域，函数的嵌套和作用域链，函数名的性质等等。下面就来看看吧，希望对你有帮助。

　　推荐：python视频教程

　　00-1010

一、函数的命名空间和作用域

1、函数的命名空间

　　def f():

　　a=1

　　返回a

　　打印(一份)

　　输出结果：

　　回溯(最近呼叫):

　　文件“E:/python code /11/file1.py”，第4行，在模块中

　　打印(一份)

　　错误：名称“a”未定义报告了一个错误！错误是“名称‘a’未定义”。变量未定义。为什么？我明确定义了a=1！

　　然后我们需要知道Python代码在运行时遇到函数时会做什么：

　　首先从python解释器开始执行之后，就在内存中开辟了一个空间每当遇到一个变量的时候，就把变量名和值之间的对应关系记录下来。但是当遇到函数定义的时候解释器只是象征性的将函数名读入内存，表示知道这个函数的存在了，至于函数内部的变量和逻辑解释器根本不关心。等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟出来的内存中。函数中的变量只能在函数的内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。

　　我们将这个空间命名为“存储名称和值之间的关系”——作为名称空间。

　　在代码的开头，存储“变量名和值之间的关系”的空间被称为全局命名空间,在函数内部操作中开辟的临时空间被称为局部命名空间.

　　00-1010函数名称空间分为三类。

　　1.内置命名空间—— python解释器

　　#就是python解释器一启动就可以使用的名字存储在内置的名称空间里。

　　#解释器启动时，内置名称被加载到内存中。

　　2.全局命名空间——我们写的代码，而不是函数中的代码。

　　#是在程序自上而下执行的过程中依次装入内存的。

　　#把我们设置的所有变量名和函数名

　　3.本地命名空间3354函数

　　#是函数内部定义的名称。

　　#这个命名空间是调用函数时生成的，执行函数时消失。

　　#您可以在local 3360的全局内置命名空间中使用名称。

　　#内置命名空间中的名称可以在全局：中使用，但不能在本地使用。

　　#在：不能使用本地和全局名称的内置命名空间中：内置命名空间存储Python解释器提供的名称(函数)。我们不需要定义它们，但是打开解释器就可以直接使用，比如：input，print，str，set…….

　　00-1010加载顺序：内置命名空间(程序运行前加载全局命名空间(程序运行时：自上而下)和本地命名空间(程序运行时：只有被调用时才加载)

　　在本地调用时：本地命名空间全局命名空间gt

　　; 内置命名空间

　　 在全局调用时：全局命名空间 > 内置命名空间

　　例子：

a = 10
　　def f():
　　 a = 1
　　 print(a)
　　f()
　　print(a)
　　输出结果：
　　1
　　10

2、函数的作用域

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

　　全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效

　　局部作用域：局部名称空间，只能在局部范围内生效

　　

• globals和locals方法

locals()：函数会以字典类型返回当前位置的全部局部变量。
globals()：函数会以字典类型返回当前位置的全部全局变量。

　　

def func():
　　 a = 1
　　 print(locals())
　　 print(globals())
　　 print('========================分割线==========================')
　　func()
　　print(locals())
　　print(globals())

输出结果：

　　

• global关键字

1、global是Python中的全局变量关键字。
2、变量分为局部变量与全局变量，局部变量又可称之为内部变量。
3、由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。
4、全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
5、global关键字的作用是可以使得一个局部变量为全局变量

　　例子：

　　在my函数中，在 x 前面加 global，my函数将 x 赋为8，此时全局变量中的 x 值改变。需要注意的是 global 需要在函数内部声明，若在函数外声明，则函数依然无法操作 x 。

　　

x = 4
　　def my():
　　 global x
　　 x = 8
　　 print("x = ", x)
　　print("x = ", x)
　　my()
　　print("x = ", x)
　　输出结果是：
　　x = 4
　　x = 8
　　x = 8

二、函数的嵌套和作用域链

• 函数的嵌套调用

def max2(x,y):
　　 m = x if x>y else y
　　 return m
　　def max4(a,b,c,d):
　　 res1 = max2(a,b)
　　 res2 = max2(res1,c)
　　 res3 = max2(res2,d)
　　 return res3
　　ret = max4(1,2,4,3)
　　print(ret)
　　输出结果：
　　4

• 函数的嵌套定义

def f1():
　　 print("in f1")
　　 def f2():
　　 print("in f2")
　　 f2()
　　f1()
　　输出结果：
　　in f1
　　in f2
　　def f1():
　　 def f2():
　　 def f3():
　　 print("in f3")
　　 print("in f2")
　　 f3()
　　 print("in f1")
　　 f2()
　　f1()
　　输出结果：
　　in f1
　　in f2
　　in f3

• 函数的作用域链

a = 1
　　def outer():
　　 a = 5
　　 def inner():
　　 a = 2
　　 def inner2():
　　 nonlocal a
　　 a += 1
　　 print('inner2',a)
　　 inner2()
　　 print('##a##:',a)
　　 inner()
　　 print('**a**:',a)
　　outer()
　　print('全局:',a)
　　输出结果：
　　inner2 3
　　##a##: 3
　　**a**: 5
　　全局: 1

• nonlocal关键字

#nonlocal 只能用于局部变量，找上层中离当前函数最近一层的局部变量且外部必须有这个变量
　　#声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量
　　#对全局无效，在内部函数声明nonlocal变量之前不能再出现同名变量
　　#对局部也只是对最近一层有影响

def f1():
　　 a = 1
　　 def f2():
　　 nonlocal a
　　 a = 2
　　 f2()
　　 print('a in f1 : ',a)
　　f1()
　　输出结果：
　　a in f1 : 2

• global关键字

# 对于不可变数据类型 在局部可是查看全局作用域中的变量
　　# 但是不能直接修改
　　# 如果想要修改，需要在程序的一开始添加global声明
　　# 如果在一个局部（函数）内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效

三、函数名的本质

1. 函数名就是内存地址

2. 函数名可以被赋值

3. 函数名可以作为容器类型的元素

4. 函数名可以作为函数的返回值

5. 函数名可以作为函数的参数

def func():
　　 print(123)
　　func()
　　print(func)
　　# 函数名就是内存地址
　　# 函数名可以被赋值
　　func2 = func
　　func2()
　　#函数名可以作为容器类型的元素
　　l = [func,func2]
　　for i in l:
　　 i()
　　def func():
　　 print(123)
　　def wahaha(f):
　　 f()
　　 return f #函数名可以作为函数的返回值
　　qqxing = wahaha(func) #函数名可以作为函数的参数
　　qqxing()
　　输出结果：
　　123
　　<function func at 0x000001ADF9946280>
　　123
　　123
　　123
　　123
　　123

• 思考

如果我自己定义了一个input函数（作用：调用该函数就打印'在下周周ovo'），会不会与内置的input函数有冲突呢？

　　

def input(a):
　　 print('在下周周ovo')

那么接下来的代码怎么运行呢？

　　

def input(a):
　　 print('在下周周ovo')
　　def func():
　　 input('请输入')
　　 print(input)
　　func()

答案：

　　

四、闭包

• 闭包函数的概念

内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数
#函数内部定义的函数称为内部函数

　　由于有了作用域的关系，我们就不能拿到函数内部的变量和函数了。如果我们就是想拿怎么办呢？返回呀！

　　如果函数内的变量我们要想在函数外部用，可以直接返回这个变量，那么如果我们想在函数外部调用函数内部的函数呢？那就直接将函数名字作为返回值就好

　　

def outer():
　　 a = 1
　　 def inner():
　　 print(a) #内部函数调用了外部变量a
　　 return inner
　　inn = outer()
　　inn()
　　输出结果：
　　1

• 闭包函数的判断方法

判断闭包函数的方法__closure__

　　当运行后，如果有cell的话，就表示是闭包函数。如果没有就不是。

　　

#输出的__closure__有cell元素 ：是闭包函数
　　def func():
　　 name = 'eva'
　　 def inner():
　　 print(name)
　　 print(inner.__closure__)
　　 return inner
　　f = func()
　　f()
　　#输出的__closure__为None ：不是闭包函数
　　name = 'egon'
　　def func2():
　　 def inner():
　　 print(name)
　　 print(inner.__closure__)
　　 return inner
　　f2 = func2()
　　f2()
　　输出结果：
　　(<cell at 0x000001E935CB0FA0: str object at 0x000001E935CC2CB0>,)
　　eva
　　None
　　egon

• 闭包嵌套

顾名思义是两个或以上的闭包函数嵌套在一起

　　

def wrapper():
　　 money = 10
　　 def func():
　　 name = 'zhou' 
　　 def inner():
　　 print(name,money) #引用了func()函数中name变量引用了wrapper()函数中money变量
　　 return inner
　　 return func
　　f = wrapper()
　　i = f()
　　i()
　　输出结果：
　　zhuo 10

小结

#func(一个函数名) --->>对应函数的内存地址
　　#函数名（）---函数调用
　　#函数的内存地址----（）函数的调用
　　# 作用域两种
　　# 全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域 ——globals()
　　# 局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——#locals()globals() : 永远打印全局的名字
　　#locals() : 输出什么 根据locals所在位置
　　#在代码中要尽量少定义全局变量，多使用返回值和接收返回值
　　#函数的嵌套：
　　 嵌套调用
　　 嵌套定义：定义在内部的函数无法直接在全局被调用
　　#函数名的本质：
　　 就是一个变量，保存了函数所在的内存地址
　　#闭包：
　　 内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。