So erstellen und rufen Sie Funktionen in Python auf

Eine Funktion erstellen

Eine Funktion wird mit der def-Anweisung erstellt. Die Syntax lautet wie folgt: def 语句创建，语法如下：

def 函数名(参数列表):  # 具体情况具体对待，参数可有可无
	"""函数说明文档字符串"""
    函数封装的代码
    ……

标题行由 def 关键字，函数的名字，以及参数的集合（如果有的话）组成

def 子句的剩余部分包括了一个虽然可选但是强烈推荐的文档字串，和必需的函数体

函数名称 的命名应该 符合 标识符的命名规则

• 可以由 字母、下划线 和 数字 组成

• 不能以数字开头

• 不能与关键字重名

def washing_machine():  # 洗衣机可以帮我们完成
    print("打水")
    print("洗衣服")
    print("甩干")

调用函数

使用一对圆括号 () 调用函数，如果没有圆括号，只是对函数的引用

任何输入的参数都必须放置在括号中

图例：

案例：加洗衣粉

def washing_machine():  # 洗衣机可以帮我们完成
    print("打水")
    print("加洗衣粉！！！")
    print("洗衣服")
    print("甩干")
# 早上洗衣服
washing_machine()
# 中午洗衣服
washing_machine()
# 晚上洗衣服
washing_machine()

总结

• 定义好函数之后，只表示这个函数封装了一段代码而已

• 如果不主动调用函数，函数是不会主动执行的

思考

• 能否将 函数调用 放在 函数定义 的上方？

• 不能！

• 因为在 使用函数名 调用函数之前，必须要保证 Python 已经知道函数的存在

• 否则控制台会提示 NameError: name 'menu' is not defined (名称错误：menu 这个名字没有被定义)

函数的参数

形参和实参

• 形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用

• 实参：调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的

问题

当我们想洗其他的东西，要手动改方法内部的代码：

def washing_machine():  # 洗衣机可以帮我们完成
    print("打水")
    print("加洗衣粉！！！")
    print("洗床单")  # 洗被套
    print("甩干")

在函数内部有一定的变化的值：

def washing_machine():  # 洗衣机可以帮我们完成
    print("打水")
    print("加洗衣粉！！！")
    print("洗衣服")
    print("甩干")
washing_machine()
def washing_machine():  # 洗衣机可以帮我们完成
    print("打水")
    print("加洗衣粉！！！")
    print("洗床单")
    print("甩干")
washing_machine()
......

思考一下存在什么问题

函数只能处理固定的数据

如何解决？

如果能够把需要处理的数据，在调用函数时，传递到函数内部就好了！

传递参数

• 在函数名的后面的小括号内部填写 参数

• 多个参数之间使用 , 分隔

• 调用函数时，实参的个数需要与形参个数一致，实参将依次传递给形参

def washing_machine(something):  # 洗衣机可以帮我们完成
    print("打水")
    print("加洗衣粉！！！")
    print("洗" + something)
    print("甩干")
# 洗衣服
washing_machine("衣服")
# 洗床单
washing_machine("床单")

图例

def washing_machine(xidiji,something):  # 洗衣机可以帮我们完成
    print("打水")
    print("加" + xidiji)
    print("洗衣服" + something)
    print("甩干")
#早上洗衣服
#按照参数位置顺序传递参数的方式叫做位置传参
#使用洗衣机，执行洗衣机内部的逻辑
washing_machine("洗衣液","衣服")#something = 衣服
#中午洗被罩
washing_machine("洗衣粉","被罩")# something = 被罩
#晚上洗床单
washing_machine("五粮液","床单")# something = 床单

作用

• 函数，把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用

• 函数的参数，增加函数的 通用性，针对 相同的数据处理逻辑，能够 适应更多的数据

1.在函数 内部，把参数当做 变量 使用，进行需要的数据处理

2.函数调用时，按照函数定义的参数顺序，把 希望在函数内部处理的数据，通过参数 传递

位置参数

与 shell 脚本类似，程序名以及参数都以位置参数的方式传递给 python 程序，使用 sys 模块的 argv 列表接收

图例

默认参数

默认参数就是声明了 默认值 的参数，因为给参数赋予了默认值，所以在函数调用时，不向该参数传入值也是允许的

函数的返回值

• 在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理

• 返回值 是函数 完成工作后，最后 给调用者的 一个结果

• 在函数中使用 return

  # 函数的返回值: return, 用于对后续逻辑的处理
  # 理解: 把结果揣兜里，后续想干啥干啥，想打印打印，想求和就求和
  # 注意:
  # a. 函数中如果没有return，那么解释器会自动加一个return None
  # b. return表示函数的终止，return后的代码都不会执行
  # 1 定义一个函数，计算两个数的和
  # 2 计算这两个数的和是不是偶数
  def get_sum(x, y=100):  # 默认参数
      he = x + y  # sum = 10 + 20
      return he   # return 30
      print("return表示函数的终止，return后的代码都不会执行")
  # 将函数return后的结果赋值给变量dc: dc = sum  ->  dc = 30
  dc = get_sum(10, 20)  # x = 10, y = 20
  print("dc:", dc)  # 30
  dc1 = get_sum(10)  # x = 10, y = 100
  print("dc1:", dc1)  # 110
  # if dc % 2 == 0:
  #     print("偶数")
  # else:
  #     print("奇数")

  Die Titelzeile besteht aus dem Schlüsselwort def Name der Funktion und der Parametersatz (falls vorhanden), der Rest der def-Klausel besteht aus einer optionalen, aber dringend empfohlenen Dokumentationszeichenfolge und einem erforderlicher Funktionskörper< /strong>🎜🎜Die Benennung des Funktionsnamens sollte den Benennungsregeln für Bezeichner entsprechen🎜
  • 🎜kann aus Buchstaben, Unterstrichen und Zahlen bestehen🎜
  • 🎜kann nicht mit einer Zahl beginnen🎜
  • 🎜kann nicht denselben Namen wie ein Schlüsselwort haben 🎜

  #默认参数
  #注意：具有默认值的参数后面不能跟没有默认值的参数
  def get_sum(a=20,b=5,c=10):
      he = a + b+ c
      return he
   
  dc = get_sum(1,2,3) #a=1 b=2 c=3
  print("dc:",dc) # 6
  dc1 = get_sum(1,2)  # a=1 b=2 c=10
  print("dc1:",dc1) # 13
  dc2 = get_sum(1)  # a=1 b=5 c=10
  print("dc2:",dc2) # 16
  dc3 = get_sum()
  print("dc3:",dc3) # 35

  Funktion aufrufen

  🎜Verwenden Sie ein Klammerpaar (), um eine Funktion aufzurufen. Wenn keine Klammern vorhanden sind, handelt es sich nur um einen Verweis auf die Funktion🎜🎜Beliebig Eingabeparameter müssen in Klammern gesetzt werden🎜🎜Legende:🎜🎜🎜🎜 Fall: Waschpulver hinzufügen🎜

  def new_fib(n=8):
      list01 = [0,1]  #定义列表，指定初始值
      for dc in range(n-2):
          list01.append(list01[-1]+list01[-2])
      return list01
   
  dc = new_fib()   #不加参数默认是8
  dc1 = new_fib(10)
  print("dc:",dc)
  print("dc1:",dc1)

  🎜🎜🎜Zusammenfassung🎜
  • 🎜 Nach der Definition der Funktion bedeutet dies lediglich, dass diese Funktion einen Codeabschnitt kapselt🎜
  • 🎜Wenn Sie die Funktion nicht aktiv aufrufen, wird die Funktion nicht aktiv ausgeführt🎜
  🎜Denken🎜
  • 🎜Kann ich Funktionsaufruf über Funktionsdefinition setzen? 🎜
  • 🎜Nein! 🎜
  • 🎜Denn bevor Sie den Funktionsnamen zum Aufrufen der Funktion verwenden, müssen Sie sicherstellen, dass Python die Existenz der Funktion bereits kennt🎜
  • 🎜 Andernfalls meldet die Konsole NameError: name 'menu' is not definiert (NameError: name 'menu' is not definiert)🎜
  🎜Funktionsparameter🎜

  Formale Parameter und tatsächliche Parameter

  • 🎜Formale Parameter : Definition Wenn eine Funktion verwendet wird, werden die Parameter in Klammern verwendet, um Parameter zu empfangen. Sie werden als Variablen innerhalb der Funktion verwendet🎜
  • 🎜< strong>tatsächliche Parameter: Beim Aufruf einer Funktion werden die Parameter in Klammern verwendet, um Daten innerhalb der Funktion🎜
  zu übergeben 🎜Problem🎜🎜Wenn wir andere Dinge waschen möchten, müssen wir den Code innerhalb der Methode manuell ändern: 🎜

  #练习：生成随机密码
  #创建 randpass.py 脚本，要求如下：
  #编写一个能生成8位随机密码的程序
  #使用 random 的 choice 函数随机取出字符
  #由用户决定密码长度
  import random
  def new_password():
      n = int(input("密码长度："))
      password = ""
      all = "0123456789zxcvbnmlkjhgfdsaqwertyuiopPOIUYTREWQASDFGHJKLMNBVCXZ" # 0-9 a-z A-Z
      random.choice(all)
      for i in range(n):
          dc = random.choice(all)
          password += dc
      # print("passwd:",password)
      return password
  # 调用函数，才能执行函数内部逻辑
  dc = new_password()
  print("dc:",dc)

  🎜Es gibt bestimmte sich ändernde Werte innerhalb der Funktion: 🎜

  #练习：生成随机密码
  #创建 randpass.py 脚本，要求如下：
  #编写一个能生成8位随机密码的程序
  #使用 random 的 choice 函数随机取出字符
  #由用户决定密码长度
  import random,string
  def new_password():
      n = int(input("密码长度："))
      password = ""
      all = string.ascii_letters + string.digits
      random.choice(all)
      for i in range(n):
          dc = random.choice(all)
          password += dc
      # print("passwd:",password)
      return password
  # 调用函数，才能执行函数内部逻辑
  dc = new_password()
  print("dc:",dc)

  🎜 Denken Sie über das Problem nach🎜🎜Die Funktion kann nur feste Daten verarbeiten🎜🎜Wie kann man es lösen? 🎜🎜Es wäre großartig, wenn die zu verarbeitenden Daten beim Aufruf der Funktion an die Funktion übergeben werden könnten! 🎜

  Übergeben Sie Parameter

  • 🎜Füllen Sie die Parameter in den Klammern nach dem Funktionsnamen ein🎜
  < li>🎜Verwenden Sie ,, um mehrere Parameter zu trennen🎜
  • 🎜Beim Aufrufen einer Funktion muss die Anzahl der tatsächlichen Parameter mit der Anzahl der formalen Parameter und der tatsächlichen Parameter übereinstimmen wird der Reihe nach übergeben. Geben Sie formale Parameter an🎜

  # test.py，将 file_copy.py 放在同级目录下
  # 需求：要将/etc/passwd复制到/tmp/passwd
  src_path = "/etc/passwd"
  dst_path = "/tmp/passwd"
  # 如何复制？
  # 调用已有模块中的方法
  #    - 很推荐，简单粗暴不动脑
  #    - 直接使用 file_copy.py的方法即可
   
  # 导入方法一：直接导入模块
  import file_copy  # 要注意路径问题
  file_copy.copy(src_path, dst_path)
   
  # 导入方法二：只导入 file_copy 模块的 copy 方法
  from file_copy import copy  # 如果相同时导入多个模块 from file_copy import *
  copy(src_path, dst_path)
   
  # 导入方法四：导入模块起别名 as
  import file_copy as fc
  fc.copy(src_path, dst_path)

  🎜Legend🎜🎜🎜

  # foo.py
  print(__name__)
   
  # bar.py
  import foo  # 导入foo.py，会将 foo.py 中的代码完成的执行一次，所以会执行 foo 中的 print(__name__)

  🎜Funktion🎜
  • 🎜 Funktion, mit unabhängigem Der Funktionscodeblock ist in einem kleinen Modul organisiert. Die Parameter der 🎜
  • 🎜-Funktion werden bei Bedarf aufgerufen, wodurch die Vielseitigkeit der Funktion erhöht wird An mehr Daten anpassen 🎜
  🎜1. Verwenden Sie innerhalb der Funktion die Parameter als Variablen, um die erforderliche Datenverarbeitung durchzuführen🎜🎜2. Befolgen Sie beim Aufruf der Funktion die durch die Funktion definierte Parameterreihenfolge Übergeben Sie die Daten, die Sie innerhalb der Funktion verarbeiten möchten, über die Parameter. Die Übergabe von 🎜

  Positionsparametern

  🎜 erfolgt ähnlich wie beim Shell-Skript an das Python-Programm in Form von Positionsparametern, mit Die <code>argv-Liste des sys-Moduls erhält 🎜🎜Legend🎜🎜 🎜

  Standardparameter< /h5>🎜Standardparameter sind Parameter mit einem deklarierten Standardwert. Da dem Parameter ein Standardwert zugewiesen ist, darf beim Aufruf der Funktion kein Wert an den Parameter übergeben werden. 🎜🎜Der Rückgabewert der Funktion🎜

  • 🎜In der Programmentwicklung Manchmal möchten Sie dem Aufrufer nach der Ausführung einer Funktion ein Ergebnis mitteilen, damit der Aufrufer es tun kann Nachfolgende Verarbeitung des spezifischen Ergebnisses🎜
  • 🎜Rückgabewert ist das Ergebnis, das dem Aufrufer gegeben wird, nachdem die Funktion ihre Arbeit abgeschlossen hat und finally Verwenden Sie das Schlüsselwort return, um Ergebnisse zurückzugeben🎜

  • 调用函数一方，可以 使用变量 来 接收 函数的返回结果

  案例：计算任意两个数字的和

  # 函数的返回值: return, 用于对后续逻辑的处理
  # 理解: 把结果揣兜里，后续想干啥干啥，想打印打印，想求和就求和
  # 注意:
  # a. 函数中如果没有return，那么解释器会自动加一个return None
  # b. return表示函数的终止，return后的代码都不会执行
  # 1 定义一个函数，计算两个数的和
  # 2 计算这两个数的和是不是偶数
  def get_sum(x, y=100):  # 默认参数
      he = x + y  # sum = 10 + 20
      return he   # return 30
      print("return表示函数的终止，return后的代码都不会执行")
  # 将函数return后的结果赋值给变量dc: dc = sum  ->  dc = 30
  dc = get_sum(10, 20)  # x = 10, y = 20
  print("dc:", dc)  # 30
  dc1 = get_sum(10)  # x = 10, y = 100
  print("dc1:", dc1)  # 110
  # if dc % 2 == 0:
  #     print("偶数")
  # else:
  #     print("奇数")

  #默认参数
  #注意：具有默认值的参数后面不能跟没有默认值的参数
  def get_sum(a=20,b=5,c=10):
      he = a + b+ c
      return he
   
  dc = get_sum(1,2,3) #a=1 b=2 c=3
  print("dc:",dc) # 6
  dc1 = get_sum(1,2)  # a=1 b=2 c=10
  print("dc1:",dc1) # 13
  dc2 = get_sum(1)  # a=1 b=5 c=10
  print("dc2:",dc2) # 16
  dc3 = get_sum()
  print("dc3:",dc3) # 35

  

  修改菲波那切数列

  def new_fib(n=8):
      list01 = [0,1]  #定义列表，指定初始值
      for dc in range(n-2):
          list01.append(list01[-1]+list01[-2])
      return list01
   
  dc = new_fib()   #不加参数默认是8
  dc1 = new_fib(10)
  print("dc:",dc)
  print("dc1:",dc1)

  

  生成随机密码：

  #练习：生成随机密码
  #创建 randpass.py 脚本，要求如下：
  #编写一个能生成8位随机密码的程序
  #使用 random 的 choice 函数随机取出字符
  #由用户决定密码长度
  import random
  def new_password():
      n = int(input("密码长度："))
      password = ""
      all = "0123456789zxcvbnmlkjhgfdsaqwertyuiopPOIUYTREWQASDFGHJKLMNBVCXZ" # 0-9 a-z A-Z
      random.choice(all)
      for i in range(n):
          dc = random.choice(all)
          password += dc
      # print("passwd:",password)
      return password
  # 调用函数，才能执行函数内部逻辑
  dc = new_password()
  print("dc:",dc)

  

  #练习：生成随机密码
  #创建 randpass.py 脚本，要求如下：
  #编写一个能生成8位随机密码的程序
  #使用 random 的 choice 函数随机取出字符
  #由用户决定密码长度
  import random,string
  def new_password():
      n = int(input("密码长度："))
      password = ""
      all = string.ascii_letters + string.digits
      random.choice(all)
      for i in range(n):
          dc = random.choice(all)
          password += dc
      # print("passwd:",password)
      return password
  # 调用函数，才能执行函数内部逻辑
  dc = new_password()
  print("dc:",dc)

  

  模块基础

  定义模块

  基本概念

  • 模块是从逻辑上组织python代码的形式

  • 当代码量变得相当大的时候，最好把代码分成一些有组织的代码段，前提是保证它们的 彼此交互

  • 这些代码片段相互间有一定的联系，可能是一个包含数据成员和方法的类，也可能是一组相关但彼此独立的操作函数

  导入模块 (import)

  • 使用 import 导入模块

  • 模块属性通过 “模块名.属性” 的方法调用

  • 如果仅需要模块中的某些属性，也可以单独导入

  为什么需要导入模块？

  可以提升开发效率，简化代码

  

  正确使用

  # test.py，将 file_copy.py 放在同级目录下
  # 需求：要将/etc/passwd复制到/tmp/passwd
  src_path = "/etc/passwd"
  dst_path = "/tmp/passwd"
  # 如何复制？
  # 调用已有模块中的方法
  #    - 很推荐，简单粗暴不动脑
  #    - 直接使用 file_copy.py的方法即可
   
  # 导入方法一：直接导入模块
  import file_copy  # 要注意路径问题
  file_copy.copy(src_path, dst_path)
   
  # 导入方法二：只导入 file_copy 模块的 copy 方法
  from file_copy import copy  # 如果相同时导入多个模块 from file_copy import *
  copy(src_path, dst_path)
   
  # 导入方法四：导入模块起别名 as
  import file_copy as fc
  fc.copy(src_path, dst_path)

  常用的导入模块的方法

  • 一行指导入一个模块，可以导入多行， 例如：import random

  • 只导入模块中的某些方法，例如：from random import choice, randint

  模块加载 (load)

  • 一个模块只被 加载一次，无论它被导入多少次

  • 只加载一次可以 阻止多重导入时，代码被多次执行

  • 如果两个文件相互导入，防止了无限的相互加载

  • 模块加载时，顶层代码会自动执行，所以只将函数放入模块的顶层是最好的编程习惯

  模块特性及案例

  模块特性

  模块在被导入时，会先完整的执行一次模块中的 所有程序

  案例

  # foo.py
  print(__name__)
   
  # bar.py
  import foo  # 导入foo.py，会将 foo.py 中的代码完成的执行一次，所以会执行 foo 中的 print(__name__)

  结果：

  # foo.py -> __main__ 当模块文件直接执行时，__name__的值为‘__main__’
  # bar.py -> foo 当模块被另一个文件导入时，__name__的值就是该模块的名字

  

  所以我们以后在 Python 模块中执行代码的标准格式：

  def test():
      ......
  if __name__ == "__main__":
      test()

  Das obige ist der detaillierte Inhalt vonSo erstellen und rufen Sie Funktionen in Python auf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!