python开发函数进阶:命名空间,作用域,函数的本质,闭包,内置方法(globales)

一,命名空间

#局部命名空间
#全局命名空间
#内置命名空间

#三者的顺序
#加载顺序 硬盘上——内存里
#内置-->全局(从上到下顺序加载进来的)-->局部(调用的时候加载)

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 #全局命名空间
 5 a = 5
 6 b = 8
 7 #局部命名空间(函数)
 8 def my_max():
 9     c = a if a > b else b
10     return c
11 m = my_max()
12 print(m)

二,作用域

#命名空间+作用域是分不开的
#两种
#全局作用域:全局命名空间、内置命名空间
#局部作用域:局部命名空间

#站在全局看:
#使用名字:
#如果全局有:用全局的
#如果全局没有:用内置的

#为什么要有作用域的概念:
#为了函数内的变量不会影响到全局

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 def max(a,b):
 5     a = 10  #局部
 6     b = 20
 7 a = 2    #全局
 8 b = 3    #
 9 max(30,50)
10 print(a,b)

总结:

#小范围的可以用大范围的
#但是大范围的不能用小范围的
#在小范围内,如果要用一个变量,是当前这个小范围有的,就用自己的
#如果在小范围内没有,就用上一级的,上一级没有就用上上一级的,以此类推。
#如果都没有,报错

三,作用域链,小范围的可以用大范围的

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 x = 1
 5 def heihei():
 6     def inner1():
 7         def inner2():
 8             print(x)
 9         inner2()
10     inner1()
11 heihei()

四,函数的嵌套

#为了保护内部函数,确定内部函数只能在外部函数中被调用

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 #函数嵌套
 5 def animal():
 6     def tiger():
 7         print(‘bark‘)
 8     print(‘eat‘)
 9     tiger()
10 animal()
11
12 #函数嵌套使用
13 def f1():
14     print(a)  #无法获取f2的a的值,注意执行顺序
15     print(‘f1‘)
16 def f2():
17     a = 10
18     f1()
19 f2()

五,函数名的本质就是内存地址

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 def func():
 5     print(‘func‘)
 6 print(func)   #函数func内存地址
 7 f = func    #就是函数的内存地址
 8 print(f)   #函数func内存地址
 9 f()  #执行代码
10 #############
11 l = [f]     #还是函数内存地址
12 print(l)
13 l[0] == f  #用索引取值
14 l[0]()
15
16 #可以用作函数的参数
17 def func():
18     print(‘func‘)
19 def func2(f):
20     print(f)   #func的内存地址
21     f()        #执行func函数
22     print(‘func2‘)
23 func2(func)
24
25 #可以作为函数的返回值
26 def func():
27     print(‘func‘)
28 def func2(f):   #1 接收func函数的内存地址
29     print(‘func2‘)
30     return f    #2 返回给fu函数func函数的内存地址
31 fu = func2(func)
32 fu()    #3  执行函数func
33
34 #如果我想在全局使用内部的函数

六,闭包

#1.闭 :内部的函数
#2.包 :包含了对外部函数作用域中变量的引用

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 #闭包函数:内部函数,包含了对外部作用域中变量的引用
 5 def hei():
 6     x = 20
 7     def inner():
 8         ‘‘‘
 9         闭包函数
10         ‘‘‘
11         print(x)
12
13 #闭包的常用形式
14 def hei():
15     x = 20
16     def inner():
17         print(x)  #局部的
18     return inner
19 i = hei()
20 i()  #全局
21
22
23 #闭包的例子,爬网页,函数执行完就会消失,但是在调用的时候又会打开,闭包解决了这个问题
24 from urllib.request import urlopen
25 # def index():
26 #     url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
27 #     return urlopen(url).read()
28 # index()
29
30 def index():
31     url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
32     def inner():
33         return urlopen(url).read()
34     print(inner.__closure__)
35     return inner
36 # u = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
37 get = index()
38 print(get())

7,内置方法

#locals,globals方法,只有globals方法,作用是局部可以更改全局的变量

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 a = 20
 5 b = 50
 6 def haha():
 7     x = 1
 8     y = 2
 9     print(globals())  #全局作用域中的名字
10     print(locals())   #局部作用域中的名字
11 haha()
12 print(globals())  #全局作用域中的名字
13 print(locals())   #全局的局部还是全局

nonlocal
# 1.外部必须有这个变量
# 2.在内部函数声明nonlocal变量之前不能再出现同名变量
# 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

 1 #!/usr/bin/env python
 2 #_*_coding:utf-8_*_
 3
 4 def f():
 5     a = 3
 6     def f1():
 7         a = 1
 8         def f2():
 9             nonlocal a   #可以将上一层的变量更改赋值
10             a = 2
11         f2()
12         print(‘a in f1 : ‘, a)    #此时a是内部函数的a
13     f1()
14     print(‘a in f : ‘,a)    #此时a是局部函数的a
15 f()
16 #a in f1 :  2
17 #a in f :  3
时间: 07-26

python开发函数进阶:命名空间,作用域,函数的本质,闭包,内置方法(globales)的相关文章

python全栈开发【第十七篇】面向对象反射和内置方法

一.静态方法(staticmethod)和类方法(classmethod) 类方法:有个默认参数cls,并且可以直接用类名去调用,可以与类属性交互(也就是可以使用类属性) 静态方法:让类里的方法直接被类调用,就像正常调用函数一样 类方法和静态方法的相同点:都可以直接被类调用,不需要实例化 类方法和静态方法的不同点: 类方法必须有一个cls参数表示这个类,可以使用类属性 静态方法不需要参数 绑定方法:分为普通方法和类方法 普通方法:默认有一个self对象传进来,并且只能被对象调用-------绑定

python循环之for循环与基本的数据类型以及内置方法

一.循环之for循环 1.1  for循环的语法与基本使用 什么是for循环?为何要有for循环?如何使用for循环? 循环就是重复做某件事,for循环是python提供的第二种循环:一般for循环能做的,while循环都能做,之所以有for循环是因为在循环取值中比while更简洁.(for取值也叫遍历取值) 语法: for 变量名 in 可迭代对象:    #可迭代对象可以是列表.字典.字符串.元组.集合 代码1 代码2 ... 小结:for循环与while循环的相同与不同之处 相同之处:都是

[Python]小甲鱼Python视频第014课(字符串:各种奇葩的内置方法)课后题及参考解答

# -*- coding: utf-8 -*- """ Created on Tue Mar 5 23:23:41 2019 @author: fengs """ """ 测试题: 0. 还记得如何定义一个跨越多行的字符串吗(请至少写出两种实现的方法)? 方法1:三引号运算符 方法2:() 小括号 1. 三引号字符串通常我们用于做什么使用? 定义跨行长字符串 2. file1 = open('C:\windows\t

函数的递归,二分法,三元表达式,列表生成式,字典生成式,匿名函数,内置方法

1 递归函数 函数在调用阶段,直接或间接的调用了自身 递归函数不应该一直递归下去,我们不考虑它到底循环多少次,我们只考虑它的结束条件 递归函数分为两个阶段 1 回溯:就是一次次重复的过程,这个重复的过程,每一次都应该比上一次简单 2 地推:一次次往回推导的过程 2 二分法 可以在一个有序的序列,快速的查找一个元素: b = [1,2,3,4,5,6] a = 3 def func(l,n): if not l: return ret = len(l) // 2 if n > l[ret]: li

Python 教程——String的内置方法

Python为String类型提供了很多很有用的内置方法,这篇文章主要针对Python2.7的内置方法做一个测试列举,展示一下用途. 如果大家想看原版的,可以去这个网址看(https://docs.python.org/2/library/stdtypes.html#string-methods),但是这里是我自己的实践以及一些理解. 1. str.capitalize() 返回第一个字母大写的str str = "a string" str.capitalize()'A string

python之路---10 *args **kwargs 命名空间 作用域 函数的嵌套

二十八.函数进阶 1.   "*"  和  "**" ① 在形参位置时   都是聚合的作用 *args    位置参数→元组 **kwargs   关键字参数→字典 混合时顺序为: 位置  , *args ,  默认值 , **kwargs ② 在实参位置时    都是打散的作用 *args      字符串,元组,字典 → 位置参数 **kwargs     字典 → 关键字参数 2.名称空间    用来存放名字(变量, 函数名, 类名, 引入的模块名)的 1.

python学习笔记4--装饰器、生成器、迭代器、匿名函数、内置方法、数据序列话

一.装饰器 1.意义:当需要给程序中某些函数新增某项功能时,为了避免直接修改函数源代码和函数调用方式,所以引入装饰器. 2.定义:装饰器用于装饰其他函数,就是为其他函数提供附加功能. 3.原则: 1)不修改被装饰的函数的源代码 2)不修改被装饰的函数的调用方式 4.装饰器储备知识: 1)函数即变量 2)高阶函数 a.把函数当做参数传递给另一个函数(在不修改被修饰函数源代码的情况下为该函数添加功能) b.返回值中包含函数名(在不修改被修饰的函数的调用方式的情况下为该函数添加功能) 3)嵌套函数:在

第二模块·函数编程-第1章 函数、装饰器、迭代器、内置方法

01-鸡汤之人丑就要多读书 02-三元运算 03-文件处理 04-文件处理-二进制模式 05-文件处理-智能检测编码的工具 06-文件处理-写模式操作文件 07-文件处理-追加模式操作文件 08-文件处理-混合操作文件 09-文件操作其他功能 10-文件处理-文件修改功能 11-函数-基本介绍 12-函数-默认参数 13-函数-关键参数 14-函数-非固定参数 15-函数-非固定参数2 16-函数-返回值 17-函数-局部变量 18-函数-在函数里修改全局变量 19-函数-在函数里修改列表数据

1、面向对象内置函数 2、反射 3、内置方法

1.isinstance()    判断对象所属类型,包括继承关系 2.issubclass() 判断类与类之间的继承关系 class A:pass class B(A): pass print(isinstance(b,B))   # o,t print(isinstance(b,A))  #  o,t class mystr(str): pass ms = mystr("alex") print(type(ms) is str)  # 不包含继承关系,只管一层 print(isin