python基础（07函数）

python系列文章目录

python基础（01变量&数据类型&运算符）
python基础（02序列共性）
python基础(03列表和元组)
python基础（04字符串&字典）
python基础（05集合set）
python基础（06控制语句）

---

---

前言

函数看这一篇就够了！

---

一、定义

1.def定义函数

1.hello是指这个函数对象，hello()是调用这个函数

>>> def hello(name):
... print('hello',name)
...
>>> hello
<function hello at 0x0000000003D02708>
>>> hello('derek')
hello derek

2.函数赋值给一个变量，这个变量就指向了这个函数名对应的函数体，加上（）才会执行

>>> def hi():
... print('hi')
>>> a = hi
>>> a
<function hi at 0x1031b0d08>
>>> hi
<function hi at 0x1031b0d08> # a 和 hi 指向同⼀个对象
>>> a()
hi
>>> hi()
hi

3.定义一个空函数

def func1():
 pass//代替语句块

2.callable()判断函数是否可以被调用

y='hello'
print(callable(y))  #false
x=1
print(callable(x))  #false

3、记录函数，给函数写注释

• 单三引号
• 双三引号

4.所有函数都有返回值，没指定返回值，默认none

5.return两个作用

• 返回值
• 作为结束

6.fun.doc

对象的帮助文档，打印出当前函数的注释

def fun ():
    '''这是一个注释'''
    print('jiajia')
    
print(fun.__doc__)
----------------------------------
这是一个注释

二、参数详解

1.参数

1、可变参数

• 列表、字典、集合，本质是指向同一个对象，都变

2、不可变参数

• 数字、元组、字符串，内部改变对外部没影响
• 不可变参数含有可变的子参数（本质是浅拷贝）

2.参数类型

（1）位置参数

//传入的值和参数需要匹配，不然报错
//严格按照参数顺序读取，一一对应
def f1(a,b,c):
     print(a,b,c)
 f1(2,3,4)
------------------------->
2 3 4

（2）默认值参数

//传入的值和参数需要匹配，不然报错
//严格按照参数顺序读取，一一对应
def f1(a,b,c):
     print(a,b,c)
 f1(2,3,4)
------------------------->
2 3 4

//位置可变
 def f1(a,b,c):
     print(a,b,c)
 f1(2,3,4)
 f1(c=20,a=30,b=40)
------------------------------->
2 3 4
30 40 20

（3）可变参数

*param（一个星号），将多个参数收集到一个“元组”对象中。

//位置参数a,b必须在可变参数*c前面
def f1(a,b,*c):
     print(a,b,c)
 f1(2,3,4,5)   #2 3 (4, 5)

（4）关键字参数

**param（两个星号），将多个参数收集到一个“字典”对象中。

def f2(a,*b,**c):
     print(a,b,c)
 f2(2,3,4,name='jiajia',age=18) #2 (3, 4) {'name': 'jiajia', 'age': 18}

（5）强制命名参数

def f1(*a,b,c):
    print(a,b,c)
#f1(2,3,4) #会报错。由于 a 是可变参数，将 2,3,4 全部收集。造成b 和c 没有赋值。f1(2,b=3,c=4)
f1(2,b=3,c=4)

（6）解析顺序

• 位置参数、默认参数、可变参数、关键字参数
• 不然报错

三、作用域

1、函数内是可以正常读取全局变量的

 a=1
 def fun1():
     print(a)

 fun1()    #1 读取全局

2、同名时屏蔽全局变量：函数内的变量只在函数内起作用

 a=1
 def change():
     a=2
     print(a)

 change()    #2 函数内同名 屏蔽全局获取局部
 print(a)    #1 函数内的只在函数内起作用

3、函数内调用全局变量：globals()[‘变量名’]，不加变量名，获取的是全量

name1='jiajia'
name2='li'
def change2(value):
    print(value,globals()['name1'])
change2(name2) #li jiajia，传入的参数，属于局部变量

4、函数内改变全局变量的值：global

• 不可变变量，需要global定义

 x=1
 def change_global():
     global x
     x+=2
     print(x)        

 change_global()       #3 调用全局变量成功
 print(x)             #3 全局变量也被改变成功

• 可变序列，局部修改全局变量会生效,不需要global声明

x=[1]
def change_global():
    x.append(2)
    print(x)
change_global()#[1,2]
print(x)   #[1,2]  变量为可变序列时 局部变量修改全局变量会生效

5、嵌套：函数内定义函数

def foo():
    def bar():
        print("hello")
    bar()  #需要调用一下
---------------------------------->  
foo()           #hello 调用成功

6、输出全部的全局变量和局部变量

print(locals())
print(globals())

四、LEGB

解释：局部作用域（local()）、全局作用域(globals())、函数内部和嵌套之间的范围（enclosing()）、内置作用域（build_in）

顺序：
1、局部L
2、之间范围E
3、全局G
4、内置B

passline=60

def fun(sore):
    passline=90
    if sore>=passline:
        print("pass")
    else:
        print("fail")
    def fun1():
        print(sore)
    return fun1

f=fun(70)   #fail  调用第一层成功，第二层进行了定义，但是没调用，return将fun1返回给了f,f指向了第二层函数
print(f)  #<function fun.<locals>.fun1 at 0x102a619e0>
f() #70,先找局部，没sore数据，其次找enclosing作用域（第一层的局部作用域），也就是传入的参数70
f=fun(70)()#fail  70  ,先执行fun(),打印fail，指向了fun1，加上(),相当于，调用了fun1(),打印70，将返回值none给了f
print(f) #none

五、匿名函数lambda（了解）

f=lambda x,y:x-y
print(f)   #打印f  一个函数对象
print(f(7,2) )      #调用f函数 打印结果5

-------------------------------------------
s =  [1,2,3]
f = lambda x:x+2
print([f(x) for x in s])  #[3, 4, 5]
----------------------------------
num1=(lambda a,b:a if a>b else b)(4,5)
print(num1) #5

---

总结

动手敲一遍，理解即可！