015.Python函數名的使用以及函數變量的操作

一 函數名的使用

python中的函數可以像變量一樣,動態創建,銷毀,當參數傳遞,作為值返回,叫第一類對象.其他語言功能有限

1.1 函數名是個特殊的變量,可以當做變量賦值

def func():
        print("有志者，事竟成，破釜沉舟，百二秦關終屬楚")

res = 4+3j
res = func
# res()  =  func()
# 把func當成變量賦值給res ,此刻res也成為了函數,調用函數需要在res后面加上()
res()

執行

[root@node10 python]# python3 test.py
有志者，事竟成，破釜沉舟，百二秦關終屬楚

1.2 函數名可以作為容器類型數據的元素

def func1():
        print(11)
def func2():
        print(22)
def func3():
        print(33)


lst = [func1,func2,func3]
print(lst)
# 循環調用列表當中的每一個函數
for i in lst:
        i()

執行

[root@node10 python]# python3 test.py
[<function func1 at 0x7f7ceb47ee18>, <function func2 at 0x7f7ceb39e0d0>, <function func3 at 0x7f7ceb39e158>]
11
22
33

1.3 函數名可以作為函數的參數

def func1(func):
        # 函數的調用處
        res = func()
        print(res)

# 函數的定義處
def func2():
        return 123

func1(func2)

執行

[root@node10 python]# python3 test.py
123

1.4 函數名可作為函數的返回值

def func1(func2):
        # 返回到函數的調用處
        return func2
def func2():
        return 456

# 參數func2
res = func1(func2)
print(res)
print(res())

執行

[root@node10 python]# python3 test.py
<function func2 at 0x7fd007e460d0>
456

二 全局變量和局部變量

• 局部變量: 定義在函數里面的變量就是局部變量
• 全局變量: 定義在函數外面的變量或者在函數內部用global關鍵字聲明的變量是全局變量
• 局部變量的作用域: 只限定在函數內部
• 全局變量的作用域: 橫跨整個文件

2.1 局部變量的獲取和修改

def func(a):
        a += 5   # 修改局部變量
        print(a) # 獲取局部變量

func(1)

執行

[root@node10 python]# python3 test.py
6

2.2 全局變量的獲取和修改

b = 10
print(b)

# (2)在函數內部可以直接訪問到全局變量
def func2():
        # 在函數內部可以直接訪問全局變量,但是不能直接修改全局變量
        print(b)  # 獲取全局變量
        # b+=2      # 修改全局變量
        # print(b)
func2()

在函數內部可以通過global關鍵字修飾,進而修改全局變量

注意點:務必在函數這個代碼塊的開頭用global關鍵字聲明修飾

c = 12
def func3():
        global c
        c += 2
        print(c)

func3()

執行

[root@node10 python]# python3 test.py
14

2.3 在函數內部直接聲明一個全局變量

def func4():
        global d
        d = 90
        d+=10
        print(d)
func4()
print(d)

執行

[root@node10 python]# python3 test.py
100
100

• global 關鍵字如果在函數外面有該全局變量,用在函數中是修改全局變量
• global 關鍵字如果在函數外面沒有該全局變量,用在函數中是定義全局變量

三 函數的嵌套

• python中允許函數嵌套,嵌套在外層的是外函數,嵌套在里層的是內函數

def func1():

        a = 10
        def func2():
                print(a)

        func2()


func1()

執行

[root@node10 python]# python3 test.py
10

func2()

1. 內部函數可以直接在函數外部調用么 不行
2. 調用外部函數后,內部函數可以在函數外部調用嗎 不行
3. 內部函數可以在函數內部調用嗎 可以
4. 內部函數在函數內部調用時,是否有先后順序 有

定義一個三層嵌套函數,最外層的是outer 第二層是inner ,第三層是smaller,調用smaller

def outer():
        a = 90
        def inner():
                # a = 91
                def smaller():
                        print(a)
                        print(id)
                smaller()

        inner()

outer()

執行

[root@node10 python]# python3 test.py
90
<built-in function id>

找尋變量的調用順序采用LEGB原則(即就近原則)

B —— Builtin(Python)；Python內置模塊的命名空間      (內建作用域)
G —— Global(module)； 函數外部所在的命名空間        (全局作用域)
E —— Enclosing function locals；外部嵌套函數的作用域(嵌套作用域)
L —— Local(function)；當前函數內的作用域            (局部作用域)
依據就近原則,從下往上 從里向外 依次尋找

del刪除

a01 = 10
def func():
        a01 = 20
        print(a01)
func()

執行

[root@node10 python]# python3 test.py
20

使用del

a01 = 10
def func():
        a01 = 20
        del a01
        # 除非不定義,一旦定義過一次局部變量,刪除后,會默認認為找不到,報錯
        print(a01)
func()

執行報錯

 

四 nonlocal函數

nonlocal 專門用來修飾[局部變量] 符合LEGB原則

1. 用來修改當前作用域上一層的[局部變量]
2. 如果上一層沒有,繼續向上尋找
3. 直到再也找不到了,直接報錯

用來修改當前作用域上一層的[局部變量]

def outer():
        a = 1
        def inner():
                nonlocal a
                a += 2
                print(a)
        inner()
outer()

執行

[root@node10 python]# python3 test.py
3

如果上一層沒有,繼續向上尋找

def outer():
        a = 20
        def inner():
                a = 10
                def smaller():
                        nonlocal a
                        a+=2
                        print(a) #12
                smaller()
                print(a)     #12
        inner()
        print(a)         #20
outer()

執行

[root@node10 python]# python3 test.py
12
12
20

直到再也找不到了,直接報錯

a = 80  # 全局變量 nonlocal不能修飾
def outer():
        # a = 10
        def inner():
                def smaller():
                        nonlocal a
                        a+=2
                        print(a) #12
                smaller()
        inner()
outer()

執行