day17 函數(二)

局部變量

<1>什麼是局部變量

如下圖所示:

<2>小總結

• 局部變量，就是在函數內部定義的變量
• 其作用範圍是這個函數內部，即只能在這個函數中使用，在函數的外部是不能使用的
• 因爲其作用範圍只是在自己的函數內部，所以不同的函數可以定義相同名字的局部變量（打個比方，把你、我是當做成函數，把局部變量理解爲每個人手裏的手機，你可有個iPhone8，我當然也可以有個iPhone8了， 互不相關）
• 局部變量的作用，爲了臨時保存數據需要在函數中定義變量來進行存儲
• 當函數調用時，局部變量被創建，當函數調用完成後這個變量就不能夠使用了

全局變量

<1>什麼是全局變量

如果一個變量，既能在一個函數中使用，也能在其他的函數中使用，這樣的變量就是全局變量

打個比方：有2個兄弟 各自都有手機，各自有自己的小祕密在手機裏，不讓另外一方使用（可以理解爲局部變量）；但是家裏的電話是2個兄弟都可以隨便使用的（可以理解爲全局變量）

demo如下:

# 定義全局變量
a = 100

def test1():
    print(a)  # 雖然沒有定義變量a但是依然可以獲取其數據

def test2():
    print(a)  # 雖然沒有定義變量a但是依然可以獲取其數據

# 調用函數
test1()
test2()

運行結果:

總結1:

• 在函數外邊定義的變量叫做全局變量
• 全局變量能夠在所有的函數中進行訪問

<2>全局變量和局部變量名字相同問題

看如下代碼:

總結2:

• 當函數內出現局部變量和全局變量相同名字時，函數內部中的 變量名 = 數據 此時理解爲定義了一個局部變量，而不是修改全局變量的值

<3>修改全局變量

函數中進行使用時可否進行修改呢？

代碼如下:

總結3:

• 如果在函數中出現global 全局變量的名字 那麼這個函數中即使出現和全局變量名相同的變量名 = 數據也理解爲對全局變量進行修改，而不是定義局部變量

• 如果在一個函數中需要對多個全局變量進行修改，那麼可以使用

       # 可以使用一次global對多個全局變量進行聲明
       global a, b
       # 還可以用多次global聲明都是可以的
       # global a
       # global b

多函數程序的基本使用流程

一般在實際開發過程中，一個程序往往由多個函數（後面知識中會講解類）組成，並且多個函數共享某些數據，這種場景是經常出現的，因此下面來總結下，多個函數中共享數據的幾種方式

1. 使用全局變量

g_num = 0

def test1():
    global g_num
    # 將處理結果存儲到全局變量g_num中.....
    g_num = 100

def test2():
    # 通過獲取全局變量g_num的值, 從而獲取test1函數處理之後的結果
    print(g_num)

# 1. 先調用test1得到數據並且存到全局變量中
test1()

# 2. 再調用test2，處理test1函數執行之後的這個值
test2()

2. 使用函數的返回值、參數

def test1():
     # 通過return將一個數據結果返回
     return 50

def test2(num):
    # 通過形參的方式保存傳遞過來的數據，就可以處理了
    print(num)

# 1. 先調用test1得到數據並且存到變量result中
result = test1()

# 2. 調用test2時，將result的值傳遞到test2中，從而讓這個函數對其進行處理
test2(result)

3. 函數嵌套調用

def test1():
    # 通過return將一個數據結果返回
    return 20

def test2():
    # 1. 先調用test1並且把結果返回來
    result = test1()
    # 2. 對result進行處理
    print(result)

# 調用test2時，完成所有的處理
test2()

函數返回值(二)

在python中我們怎樣返回多個值？

<1> 多個return?

def create_nums():
    print("---1---")
    return 1  # 函數中下面的代碼不會被執行，因爲return除了能夠將數據返回之外，還有一個隱藏的功能：結束函數
    print("---2---")
    return 2
    print("---3---")

總結1：

• 一個函數中可以有多個return語句，但是只要有一個return語句被執行到，那麼這個函數就會結束了，因此後面的return沒有什麼用處

• 如果程序設計爲如下，是可以的因爲不同的場景下執行不同的return

    def create_nums(num):
        print("---1---")
        if num == 100:
            print("---2---")
            return num+1  # 函數中下面的代碼不會被執行，因爲return除了能夠將數據返回之外，還有一個隱藏的功能：結束函數
        else:
            print("---3---")
            return num+2
        print("---4---")
  
    result1 = create_nums(100)
    print(result1)  # 打印101
    result2 = create_nums(200)
    print(result2)  # 打印202
  

<2> 一個函數返回多個數據的方式

def divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu  #默認是元組

result = divid(5, 2)
print(result)  # 輸出(2, 1)

總結2：

• return後面可以是元組，列表、字典等，只要是能夠存儲多個數據的類型，就可以一次性返回多個數據

        def function():
            # return [1, 2, 3]
            # return (1, 2, 3)
            return {"num1": 1, "num2": 2, "num3": 3}
  

• 如果return後面有多個數據，那麼默認是元組

        In [1]: a = 1, 2
        In [2]: a
        Out[2]: (1, 2)
  
        In [3]:
        In [3]: b = (1, 2)
        In [4]: b
        Out[4]: (1, 2)
  
        In [5]:

函數參數(二)

<1>. 缺省參數

調用函數時，缺省參數的值如果沒有傳入，則取默認值。

下例會打印默認的age，如果age沒有被傳入：

def printinfo(name, age=35):
   # 打印任何傳入的字符串
   print("name: %s" % name)
   print("age %d" % age)

# 調用printinfo函數
printinfo(name="miki")  # 在函數執行過程中 age去默認值35
printinfo(age=9 ,name="miki")

以上實例輸出結果：

name: miki
age: 35
name: miki
age: 9

總結：

• 在形參中默認有值的參數，稱之爲缺省參數
• 注意：帶有默認值的參數一定要位於參數列表的最後面

    >>> def printinfo(name, age=35, sex):
    ...     print name
    ...
      File "<stdin>", line 1
    SyntaxError: non-default argument follows default argument
  

<2>. 不定長參數

有時可能需要一個函數能處理比當初聲明時更多的參數, 這些參數叫做不定長參數，聲明時不會命名。

基本語法如下：

def functionname([formal_args,] *args, **kwargs):
   """函數_文檔字符串"""
   function_suite
   return [expression]

注意：

• 加了星號（*）的變量args會存放所有未命名的變量參數，args爲元組
• 而加**的變量kwargs會存放命名參數，即形如key=value的參數， kwargs爲字典.

>>> def fun(a, b, *args, **kwargs):
...     """可變參數演示示例"""
...     print("a =%d" % a)
...     print("b =%d" % b)
...     print("args:")
...     print(args)
...     print("kwargs: ")
...     for key, value in kwargs.items():
...         print("key=%s" % value)
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意傳遞的參數對應
a = 1
b = 2
args:
(3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d)    # 注意元組與字典的傳參方式
a = 1
b = 2
args:
(3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星號與上面的區別
a = 1
b = 2
args:
((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
kwargs:
>>>
>>>

<3>. 缺省參數在*args後面

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)

說明：

• 如果很多個值都是不定長參數，那麼這種情況下，可以將缺省參數放到 *args的後面， 但如果有**kwargs的話，**kwargs必須是最後的

拆包、交換變量的值

<1> 對返回的數據直接拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age


# result = get_my_info()
# print(result)

my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

總結：

• 拆包時要注意，需要拆的數據的個數要與變量的個數相同，否則程序會異常

• 除了對元組拆包之外，還可以對列表、字典等拆包

    In [17]: a, b = (11, 22)
    In [18]: a
    Out[18]: 11
    In [19]: b
    Out[19]: 22
  
    In [20]: a, b = [11, 22]
    In [21]: a
    Out[21]: 11
    In [22]: b
    Out[22]: 22
  
    In [23]: a, b = {"m":11, "n":22}  # 取出來的是key，而不是鍵值對
    In [24]: a
    Out[24]: 'm'
    In [25]: b
    Out[25]: 'n'
  

<2> 交換2個變量的值

# 第1種方式
# a = 4
# b = 5
# c = 0
#
# c = a
# a = b
# b = c
#
# print(a)
# print(b)

# 第2種方式
# a = 4
# b = 5
# a = a+b  # a=9, b=5
# b = a-b  # a=9, b=4
# a = a-b  # a=5, b=4
# print(a)
# print(b)

# 第3種方式
a, b = 4, 5
a, b = b, a

print(a)
print(b)

引用(一)

想一想

>>> a = 1
>>> b = a
>>> b
1
>>> a = 2
>>> a
2

請問此時b的值爲多少？

>>> a = [1, 2]
>>> b = a
>>> b
[1, 2]
>>> a.append(3)
>>> a
[1, 2, 3]

請問此時b的值又是多少？

引用

在python中，值是靠引用來傳遞來的。

我們可以用id()來判斷兩個變量是否爲同一個值的引用。 我們可以將id值理解爲那塊內存的地址標示。

>>> a = 1
>>> b = a
>>> id(a) 
13033816
>>> id(b)   # 注意兩個變量的id值相同
13033816
>>> a = 2
>>> id(a)   # 注意a的id值已經變了
13033792
>>> id(b)   # b的id值依舊
13033816

>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)       # 注意a與b始終指向同一個地址
139935018544808

總結：

• 之前爲了更好的理解變量，咱們可以把a=100理解爲變量a中存放了100，事實上變量a存儲是100的引用（可理解爲在內存中的一個編號）

可變、不可變類型

總結

• 所謂可變類型與不可變類型是指：數據能夠直接進行修改，如果能直接修改那麼就是可變，否則是不可變
• 可變類型有： 列表、字典、集合
• 不可變類型有： 數字、字符串、元組

  引用(二)

  引用當做實參

  • 可變類型與不可變類型的變量分別作爲函數參數時，會有什麼不同嗎？
  • Python有沒有類似C語言中的指針傳參呢？

  def test1(b):  # 變量b一定是一個局部變量，就看它指向的是誰？可變還是不可變
      b += b  # += 是直接對b指向的空間進行修改,而不是讓b指向一個新的
      # b = b+b  # xx = xx+yyy 先把=號右邊的結果計算出來,然後讓b指向這個新的地方,不管原來b指向誰
                  # 現在b一定指向這個新的地方
  
  # a = [11, 22]
  a = 100
  test1(a)
  print(a)
  

  總結：

  • Python中函數參數是引用傳遞（注意不是值傳遞）
  • 對於不可變類型，因變量不能修改，所以運算不會影響到變量自身
  • 而對於可變類型來說，函數體中的運算有可能會更改傳入的參數變量

  函數使用注意事項

  1. 自定義函數

  無參數、無返回值

  def 函數名():
      語句
  

  無參數、有返回值

  def 函數名():
      語句
      return 需要返回的數值
  

  注意:

  • 一個函數到底有沒有返回值，就看有沒有return，因爲只有return纔可以返回數據
  • 在開發中往往根據需求來設計函數需不需要返回值
  • 函數中，可以有多個return語句，但是隻要執行到一個return語句，那麼就意味着這個函數的調用完成

  有參數、無返回值

  def 函數名(形參列表):
      語句
  

  注意：

  • 在調用函數時，如果需要把一些數據一起傳遞過去，被調用函數就需要用參數來接收
  • 參數列表中變量的個數根據實際傳遞的數據的多少來確定

  有參數、有返回值

  def 函數名(形參列表):
      語句
      return 需要返回的數值
  

  函數名不能重複

  • 如果在同一個程序中出現了多個相同函數名的函數，那麼在調用函數時就會出現問題，所以要避免名字相同
  • 還有一點 不僅要避免函數名之間不能相同，還要避免 變量名和函數名相同的，否則都會出現問題
  • 詳細的講解在python就業班中進行學習，此階段只要注意這些問題即可

  2. 調用函數

  調用的方式爲：

  函數名([實參列表])
  

  調用時，到底寫不寫 實參

  • 如果調用的函數 在定義時有形參，那麼在調用的時候就應該傳遞參數

  調用時，實參的個數和先後順序應該和定義函數中要求的一致

  如果調用的函數有返回值，那麼就可以用一個變量來進行保存這個值

  3. 作用域

  在一個函數中定義的變量，只能在本函數中用(局部變量)

  在函數外定義的變量，可以在所有的函數中使用(全局變量)