python基礎-函數

函數

什麼是函數

函數是一種工具，能夠重複調用

爲何要使用函數

防止代碼冗餘；不使用函數，代碼的可讀性差

如何使用函數

• 函數的定義

  關鍵字(def) 函數名(index) 小括號():
  """函數描述：用於描述函數代碼體的功能"""

  def index():
      """打印一句話
      :return:
      """
      print("這是一個函數")

• 函數名的命名規範與變量是同樣

• 函數的種類

  • 無參函數

    def index():
        """打印一句話
        :return:
        """
        print("這是一個無參函數")

  • 空函數(只有函數名)

    def index():
        pass

  • 有參函數

    def login(username,password):
        print(username,password)

• 函數的調用

  • 直接調用

    # 定義register 函數 
    def register():
        """打印姓名，年齡
        :return:
        """
        print("註冊用戶：\n姓名：dawn\n年齡：37\n")
    # 直接調用register 函數
    register()

  • 定義變量接收

    # 定義register 函數
    def register():
        """打印姓名，年齡
        :return:
        """
        print("註冊用戶：\n姓名：dawn\n年齡：37\n")
    # 定義變量res ，給res 賦值爲register
    per = register
    # 使用res調用函數
    per()

  • 將函數看成參數使用

    # 定義max 函數
    def max(num1,nmu2):
        """
        比較兩個數的大小,返回最大數
        :param num1:
        :param nmu2:
        :return: max
        """
        # 若是num1 > num2，那麼返回num1，不然返回num2，再將結果賦值給max變量。至關於if…else…的縮寫
        max = num1 if num1 > nmu2 else nmu2
        return max
    # 使用了函數嵌套,將max() 看成一個參數再次傳入了max() 中
    print(max(187,max(89,233)))

• 函數的返回值

  返回用關鍵字return表示。return是函數結束的標誌，函數體代碼只要執行到return，函數執行結束

  函數的返回值分爲5種狀況：

  • 不寫return：也就是沒有返回值，默認返回None

    def foo():
        """用於演示沒有return的函數
        :return:
        """
        name = "dawn"
        age = 37
    
    print(foo())        # 打印結果：None

  • 只寫return：只有結束函數體代碼的效果，返回None

    def foo():
        """
        用於演示只寫return
        :return: None
        """
        for i in range(2):
            while True:
                i += 1
                print(i)
                if i == 1:
                    return
    
    print(foo())        # 打印結果：1和None 1是函數打印出來的記錄

  • return None：這種狀況跟只寫return None的效果相同

    def foo():
        """
        用於演示return None
        :return: None
        """
        for i in range(3,0,-1):
            for j in range(i-1,-1,-1):
                if j == 1:
                    return None
                print(j)
    
    print(foo())        # 打印結果：2和None 2是函數打印出來的記錄

  • return 單個值：可將返回的結果看成變量或賦值給變量使用

    def foo():
        """
        用於演示return 一個值
        :return: min
        """
        min = 0
        num1 = 123.04
        num2 = 233.333
        min = num1 if num1 < num2 else num2
        return min
    
    print(f"123.04和233.333之間，比較小的是{foo()}")

  • return 多個值：將返回的多個值，存入元組中返回（默認），也可自行指定返回的數據類型。存儲在元組中，是不想返回值被修改

    # 默認返回元組
    def foo():
        """
        用於演示return 多個值時，默認將多個值存儲在元組中返回
        :return: (name,age,hobby,animals)
        """
        name = "dawn"
        age = 37
        hobby = ["study","read","music"]
        animals = {"cat":"星期天","dog":"飯糰"}
        return name,age,hobby,animals
    
    print(foo())            # 打印結果元組類型記錄：('dawn', 37, ['study', 'read', 'music'], {'cat': '星期天', 'dog': '飯糰'})
    
    # 自定義返回值爲字典
    def foo1():
        """
        用於演示return 多個值時，設置以字典的形式返回多個值
        :return: {"name":name,"age":age,"hobby":hobby,"animals":animals}
        """
        name = "dawn"
        age = 37
        hobby = ["study", "read"]
        animals = {"cat": "星期天"}
        return {"name":name,"age":age,"hobby":hobby,"animals":animals}
    
    print(foo1())   # 打印結果字典類型：{'name': 'dawn', 'age': 37, 'hobby': ['study', 'read'], 'animals': {'cat': '星期天'}}

• 函數的參數

  從類型來說，參數分爲形參和實參。

  形參：函數定義階段就規定的參數。至關於定義變量時的變量名

  實參：函數調用階段傳入的參數。至關於賦值給變量的變量值

  # 這裏的username 和password 就是形參
  def get_xspar(username,password):
      """
        用於演示形參和實參
      :param username:姓名
        :param 和password:密碼
      :return:
        """
      print(f"姓名：{username}\t密碼：{password}")
  
  # 這裏傳入login 函數中的"dawn"和"123"就是實參
  get_xspar("dawn","123")

  從傳參方式來講，分爲四種。分別是：位置參數、關鍵字參數、默認參數、可變長參數

  • 位置參數：在調用函數時，直接經過函數中參數列表順序傳參的參數

    def w_par(name,pwd):
            """
            用於演示位置參數
            :param name:姓名
            :param pwd:密碼
            :return:
            """
            print(f"用戶名：{name}\t登陸密碼：{pwd}")
        w_par("dawn","123")  # "dawn","123"根據參數列表依次傳參，就是位置參數

  • 關鍵字參數：在調用函數時，指定參數名進行傳參的參數

    def g_par(name,pwd,age):
        """
        用於關鍵字參數
        :param name:姓名
        :param pwd:密碼
        :param age:年齡
        :return:
        """
        print(f"姓名：{name}\t密碼：{pwd}\t年齡：{age}")
    g_par(age=18,name="dawn",pwd="123") # 將值傳給指定參數的這種，就是關鍵字參數

    注意：

    位置參數和關鍵字參數能夠混用，位置參數必定要在關鍵字參數以前，混用的時候，不要對同一個形參重複賦值

    def g_par(name,pwd,age):
        """
        用於演示位置參數和關鍵字參數的混用
        :param name:姓名
        :param pwd:密碼
        :param age:年齡
        :return:
        """
        print(f"姓名：{name}\t密碼：{pwd}\t年齡：{age}")
    
    g_par(name="dawn","123",age=18)     # 錯誤示例，位置參數必定要在關鍵字參數以前
    g_par("123",name="dawn",age=18)     # 錯誤示例，程序運行時，默認將"123",name="dawn"都看成參數[name]的值
    g_par("dawn","123",age=18)          # 正確示例

  • 默認參數：在定義函數階段，對形參進行賦值（也就是設置了參數值）的參數。在調用時，若是不對這個參數傳值，系統會自動使用默認值；若是對這個參數，從新傳了參數，默認值將會被修改。請不要將可變類型看成參數傳遞

    def defult_par(name,age,gender="男"):
        """
        用於演示返回默認值參數
        :param name: 姓名
        :param age: 年齡
        :param gender: 性別，默認值爲[男]
        :return:
        """
        print(f"姓名：{name}，年齡：{age}，性別：{gender}")
    
    defult_par("egon",73)       # 沒有傳入[gender]參數，打印結果：姓名：egon，年齡：73，性別：男
    defult_par("dawn",37,"女")   # 傳了[gender]參數，打印結果：姓名：dawn，年齡：37，性別：女

  • 可變長參數：函數中參數列表數量能夠不固定

    *args：接收全部溢出的位置參數，接收的值都被存入一個元組中。

    其實，*args 是官方認證的表示，***** 後面的名稱能夠修改，**形參中只要有*就有可變長參數的效果**。

    def args_par(name,age,*args):
        """
        用於演示*args 的做用
        :param name:姓名
        :param age:年齡
        :param args:溢出參數
        :return:
        """
        print(f"姓名：{name}，年齡：{age}。溢出的參數：{args}")
    
    args_par("egon",73)         # 正常輸入參數，打印結果：姓名：egon，年齡：73。溢出的參數：()
    args_par("sean",18,"male","燙頭")     # 多傳了2個參數，打印結果：姓名：sean，年齡：18。溢出的參數：('male', '燙頭')

    須要注意的是：

    *****在形參中表示接收溢出參數，在實參中的表示將容器類型的數據打散。# 函數有幾個參數，實參的長度就是幾位，不然報錯。字典傳入的是key值

    def s_par(name,age,str):
        """
        用於演示在實參中，* 表示打算的意思
        :param str: 傳入的容器類型數據，str,list,tuple,dict,set
        :return:
        """
        print(name,age,str)
    
    s_par(*"sea")       # 打印結果：s e a
    s_par(*['sean','18','male'])  # 打印結果：sean 18 male
    s_par(*('a',1,'c'))           # 打印結果：a 1 c
    s_par(*{"name":"sean","age":18,"gender":"male"}) # 字典傳入的是key 打印結果：name age gender
    s_par(*{'1','a',233})         # 打印結果：a 233 1

    ** kwargs：接收全部溢出的關鍵字參數，接收的值都被存入一個字典中。輸出時，直接使用kwargs；若是是 *kwargs，表示打算輸出字典中的全部的key值

    def kwargs_par(name,age,**kwargs):
        """
        用於演示**kwargs 的做用
        :param name: 姓名
        :param age: 年齡
        :param kwargs: 溢出的關鍵字參數字典
        :return:
        """
        print(f"姓名：{name}，年齡：{age}，溢出的位置參數字典：{kwargs}")
        print(f"打散後的溢出位置參數：",end="")
        print(*kwargs)
    
    kwargs_par(age=18,gender="male",hobby="['study','read']",name="sean")
    # 打印結果：
    # 姓名：sean，年齡：18，溢出的位置參數字典：{'gender': 'male', 'hobby': "['study','read']"}
    # 打散後的溢出位置參數：gender hobby