python基础-------函数

Posted 2020-09-22

一 为何要有函数？
不加区分地将所有功能的代码垒到一起，

问题是：
代码可读性差
代码冗余
代码可扩展差

如何解决？
函数即工具，事先准备工具的过程是定义函数，拿来就用指的就是函数调用

结论：函数使用必须是：先定义，后调用

 二：函数的分类

1.内置函数:built-in
2.自定义函数:
def 函数名(参数1,参数2，...):
‘‘‘注释‘‘‘
函数体

三：函数的返回值

返回值：可以返回任意类型
没有return：None
return value: value
return val1,val2,val3 :(val1,val2,val3)

return的效果：只能返回一次值，终止函数的执行

四：函数参数的使用

ef fuck():
#     if 2>1
#         print(2)
# #定义阶段只检查代码的语法不会执行代码，所以该函数内有报错！
#
# def fuck():
#     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# #虽然语法没错误但是逻辑有问题，引用了一个不存在变量名。
# #定义的阶段
# def fuck():
#     print(‘fuck1‘)
# def fuck1():
#     print(fuck())
# fuck()#调用的阶段
# 函数的调用遵循先定义后使用的规则（调用）！
# def fuck2():
#     return   #返回值 可以返回多个值默认以元组的形式返回 只能返回一次值 ，并且会终止函数的执行，因而放与最后！
             #返回类型的值，没有return的话会默认返回None
# def fuck3():
#     return ‘a‘,‘b‘,‘c‘
# b=fuck3()
# print(b)
# def fuck3(x,y):#形参，按照位置定义的形参！ 遵循必须传入参数，多一个不行，少一个也不行！
#     print(‘x‘,‘y‘)
#
# fuck3(1,2) #位置实参  ，按照位置定义的实参！首先必须遵循形参的规则！并且按照位置与形参一一对应！
# fuck3(x=1,y=2) #关键字实参， 按照关键字对应形参！首先必须遵循形参的规则！指名道姓的于形参对应
# fuck3(1,y=2)  #混合型实参（既有位置实参，也有关键字形参！）首先必须遵循形参的规则！且遵循位置实参必须在关键字实参的前面

#可变长参数：实参参数个数不固定的情况！
#
#
# def fuck4(x,y,*mage): #用*来处理可变长的位置实参将多余出来的实参以元组的形式并且赋值给mage变量！*为位置参数遇到将其拆开！
#     print(x,y,mage)
# fuck4(1,2,3,4,5,6,7,8)
# def fuck5(x,y,**kmages):#用**来处理可变长的关键字实参将多余出来的实参以字典的形式并且赋值给kmages变量！
#     print(x,y,kmages)
# fuck5(x=1,y=2,z=12,ag=123)
默认参数
函数在定义时给参数进行了默认定义
def cout(a=1):#这个a=1就是默认函数

#默认参数需要注意的问题一：必须放在位置形参后面
#默认参数需要注意的问题二：默认参数通常要定义成不可变类型
#默认参数需要注意的问题三：默认参数只在定义阶段被赋值一次

#命名关键字参数:定义在*后的形参，这类形参，必须被传值，而且要求实参必须是以关键字的形式来传值

# def register(*args,name=‘egon‘,age):
# print(args)
# print(name)
# print(age)
#
# # register(name=‘egon‘,age=18)
# register(1,2,2,3,age=10

五：函数的嵌套使用

函数的嵌套调用
#
# def max2(x,y):
# if x > y:
# return x
# else:
# return y
#
# def max4(a,b,c,d):
# res1=max2(a,b) #23
# res2=max2(res1,c) #23
# res3=max2(res2,d) #31
# return res3
#
#
# print(max4(11,23,-7,31))

#函数的嵌套定义
def f1():
　　def f2():
　　　　def f3():
　　　　print(‘from f3‘)
　　print(‘from f2‘)
f3()
print(‘from f1‘)
f2()
# print(f1)
f1()

在函数定义阶段就进行函数内部逐层进行定义。

六：函数对象

#函数是第一类对象： 指的是函数可以被当做数据传递

def func():
print(‘from func‘)

#可被引用
# f=func

#可以当做函数的参数
# def func():
# print(‘from func‘)
# def foo(x):
# print(x)
# x()
#
# foo(func)

#可以当做函数的返回值
# def foo():
# print(‘from foo‘)
# def bar():
# return foo
# f=bar()
# print(f)
# print(foo)

# x=0
# def f1():
# x=1
# def f2():
# # x=2
# print(x)
# return f2
# f=f1()
# # print(f)
# f()

 

#可以当做容器类型的元素
# def select():
# print(‘select function‘)
#
# func_dic={
# ‘select‘:select,
# }
#
# # print(func_dic[‘select‘])
# func_dic[‘select‘]()

七：名称空间与作用域

#名字空间：存放名字与值的绑定关系

#名称空间分为三种

#内置名称空间：python解释器自带的名字，python解释器启动就会生成

 

#全局名称空间：文件级别定义的名字都会存放与全局名称空间，执行python文件时会产生

# x=1
# def func():
# pass
#
# class Foo:
# pass
#
# import os
#
# if 1 > 2 :
# y=3

#局部名称空间:定义在函数内部的名字，局部名称空间只有在调用函数时才会生效，函数调用结束则失效
# def func(x,y): #x=1,y=2
# z=3

# func(1,2)

#三者的加载顺序：内置名称空间->全局名称空间->局部名称空间

#取值：局部名称空间->全局名称空间->内置名称空间

# # max=10
# def func(): #x=1
# # max=20
# print(max)
#
#
# func()

 

# max=10
#
# def func(): #x=1
# max=20
# # print(max)
# func()
#
#
# print(max)
#

# # x=0
# def f1():
# # x=1
# def f2():
# # x=2
# def f3():
# # x=3
# print(x)
# f3()
# f2()
#
# f1()

#作用域：作用范围
#全局作用域：内置名称空间与全局名称空间的名字属于全局范围，
# 在整个文件的任意位置都能被引用，全局有效
#局部作用域：局部名称空间的名字属于局部范围，
#只在函数内部可以被引用，局部有效

 

# x=1
# def foo():
# def f2():
# print(x)
# f2()
# def bar():
# print(x)
#
# foo()
# bar()

# def f1():
# x=1
# def f2(): #f2=value
# # x=2
# print(x)
# f2()
# f1()

x=1
def func():
x=2
def f1():pass
# print(dir(globals()[‘__builtins__‘])) #全局作用域name
# print(locals()) #局部作用域name

func()

print(globals() is locals())

#取值查找顺序 局部作用域----->全局作用域