作为一个Python的初学者来说，深入理解Python中函数的概念是一件重要的事情。
重点1：如何理解函数是第一类对象（一等公民）
函数是第一类对象的概念：
第一：函数的名字是对函数的引用
第二：函数作为第一类对象可以赋值给其他的变量
第三：可以作为函数的参数传递给其他的函数
第四：可以作为函数的返回值
第五：函数可以作为容器类型的一个元素
简单来说，在python当中,函数可以当做数据来进行传递，即变量有什么特性，函数就有什么特性。函数名字实际上就是一个指针变量，里面存放着函数体内存空间的地址
def foo():
"""
关键:foo就是C语言当中的指针变量,里面存放着内存空间的地址
"""
print('我爱吃大刀肉')
print('我爱吃涮羊肉')
print('我爱吃土豆肉')
fun = foo
print(fun,foo)
#此时此刻fun和foo这两个指针变量指向同一块的内存空间
fun()
def foo():
"""
关键:foo就是C语言当中的指针变量,里面存放着内存空间的地址
"""
print('我爱吃大刀肉')
print('我爱吃涮羊肉')
print('我爱吃土豆肉')
def g(func):
#我们将func作为一个函数的参数进行传递
print(func)
func()
g(foo)
def foo():
"""
关键:foo就是C语言当中的指针变量,里面存放着内存空间的地址
"""
print('我爱吃大刀肉')
print('我爱吃涮羊肉')
print('我爱吃土豆肉')
def g(func):
#我们将func作为函数的返回值进行使用
print(func)
return func
f = g(foo)
print(f)
f()
接下来我们将对最后一个进行深入讲解：
示例1：普通版程序
def select(sql):
print('=========>select')
def insert(sql):
print('=========>insert')
def update(sql):
print('=========>update')
def delete(sql):
print('=========>delete')
if __name__ == '__main__':
while True:
sql = input('>>').strip()
if not sql:continue
l = sql.split()
cmd = l[0]
if cmd == 'select':
select(sql)
elif cmd == 'insert':
insert(sql)
elif cmd == 'update':
update(sql)
elif cmd == 'delete':
delete(sql)
else:
pass
上面的这个程序看似没有什么问题，但是如果有20个类型的话，难道你要写20个if…else…吗？
修改版：
def select(sql):
print('=========>select')
def insert(sql):
print('=========>insert')
def update(sql):
print('=========>update')
def delete(sql):
print('=========>delete')
if __name__ == '__main__':
#作为第一类对象,函数可以作为容器类型的元素
dict_func = {
'select':select,
'insert':insert,
'update':update,
'delete':delete,
}
while True:
sql = input('>>').strip()
if not sql:continue
l = sql.split()
cmd = l[0]
if cmd in dict_func:
dict_func[cmd](sql)
经过上面一折腾，是不是代码上升了一个档次。
实际业务版：普通版程序
def handle_async(tag_id,tag_type):
"""
:param tag_id: DDL id
:param tag_type: 具体类型
content:if...else...后续这里要继续优化
"""
if '数据库自助化上线' in tag_type:
handle_service(tag_id,tag_type)
elif '普通上线申请流程' in tag_type:
handle_common(tag_id, tag_type)
elif '空库初始化' in tag_type:
handle_empty(tag_id, tag_type)
elif 'DBChange确认流程' in tag_type:
handle_dbchange(tag_id, tag_type)
elif 'DDL变更申请流程' in tag_type:
handle_ddl(tag_id, tag_type)
else:
pass
改进版：
def handle_async(tag_id,tag_type):
dict_func = {
'数据库自助化上线':handle_service,
'普通上线申请流程':handle_common,
'空库初始化':handle_empty,
'DBChange确认流程':handle_dbchange,
'DDL变更申请流程':handle_ddl,
}
for key in dict_func:
if key in tag_type:
dict_func[key](tag_id,tag_type)
后来因为代码我又改了一次：普通版如下
def handle_async(tag_id,tag_type):
"""
:param tag_id: DDL id
:param tag_type: 具体类型
content:if...else...后续这里要继续优化
"""
if '数据库自助化上线' in tag_type:
url = url_list['service'] + tag_id
handle_service(tag_id,tag_type,url=url)
elif '普通上线申请流程' in tag_type:
url = url_list['common'] + tag_id
handle_common(tag_id, tag_type,url=url)
elif '空库初始化' in tag_type:
url = url_list['empty'] + tag_id
handle_empty(tag_id, tag_type,url=url)
elif 'DBChange确认流程' in tag_type:
handle_dbchange(tag_id, tag_type)
elif 'DDL变更申请流程' in tag_type:
url = url_list['ddl'] + tag_id
handle_ddl(tag_id, tag_type,url=url)
else:
pass
改进版如下：
def handle_async(tag_id,tag_type):
dict_func = {
'数据库自助化上线':['service',handle_service],
'普通上线申请流程':['common',handle_common],
'空库初始化':['empty',handle_empty],
'DBChange确认流程':['dbchange',handle_dbchange],
'DDL变更申请流程':['ddl',handle_ddl],
}
for key,value in dict_func.items():
if key in tag_type:
url = url_list[item[0]]+tag_id
item[1](tag_id,tag_type,url=url)
OK，基本上就是这么一个套路。
重点2：函数的嵌套
函数嵌套调用和嵌套定义的概念：
函数的嵌套调用:在一个函数的内部调用另外一个函数,叫做函数的嵌套调用
函数的嵌套定义:在一个函数的内部定义另外一个函数,叫做函数的嵌套定义
示例程序1：
def max2(x1,x2):
max_value = x1 if x1 > x2 else x2
return max_value
def max4(x1,x2,x3,x4):
x12 = max2(x1,x2)
x34 = max2(x3,x4)
max_value = x12 if x12 > x34 else x34
return max_value
print(max4(130,20,30,40))
示例程序2：
def fun1():
"""
contention:函数的定义相当于变量的定义,是没有任何实际打印效果的
"""
print('大刀肉....')
def fun2():
print('涮羊肉....')
def fun3():
print('土豆肉....')
fun3()
fun2()
fun1()
重点3：Python中名称空间与作用域的概念
在python当中，名称空间与作用域是一个比较难理解的概念，希望在这里给大家讲清楚。
名称空间与作用域的概念：
名称空间:描述的就是名字与数值的绑定关系,可以理解为存放名字(标识符)的地方；作用域:名字起作用的区域，范围
注意：
1、名称空间与名称空间彼此之间是互相隔离的
2、不同namespace的创建/销毁时间也不同
3、两个不同namespace中的两个相同名字的变量之间没有任何联系
Python中名称空间的分类：
在Python当中,名称空间分为3种：局部名称空间（locals）、全局名称空间（globals）和内置名称空间（builtins）
局部名称空间：即在函数内部定义的名称空间,包括局部变量和形式参数以及在函数内部定义的函数
全局名称空间：即在文件级别定义的名称空间，在文件级别定义的名字都会放入该空间
内置模块的名称空间：builtins
简单来说：
局部名称空间:存函数内部定义的名字
全局名称空间:存文件级别定义的名字
内置名称空间:存内置的名字
Python中名称空间的加载顺序以及名字的查找顺序：
加载顺序：
内置模块的名称空间====>全局名称空间====>局部名称空间
名字的查找顺序：
局部名称空间=====>全局名称空间====>内置模块的名称空间
Python中名称空间与作用域 的关系：
作用域:全局作用域和局部作用域
其中全局作用域包括内置名称空间与全局名称空间定义的名字;局部作用域包括在局部名称空间定义的名字。
注意：默认情况下在局部作用域内不能修改全局作用域范围内的变量，只能调用数值，如果想修改，只能通过global关键字进行修改。
示例程序1：
def outer():
a = 0
b = 1
def inner():
print(a)
print(b)
inner()
return 20
outer()
示例程序2：
def outer():
a = 0
b = 1
def inner():
print(a)
print(b)
b = 4
inner()
outer()
错误信息：变量b在赋值前被引用。
0
Traceback (most recent call last):
File "D:/Python Work Location/Core2/Test3.py", line 16, in <module>
outer()
File "D:/Python Work Location/Core2/Test3.py", line 14, in outer
inner()
File "D:/Python Work Location/Core2/Test3.py", line 10, in inner
print(b)
UnboundLocalError: local variable 'b' referenced before assignment
请继续关注我
共同学习，写下你的评论
评论加载中...
作者其他优质文章
