Dieser Artikel bietet Ihnen eine detaillierte Einführung in Funktionsparameter in Python (mit Beispielen). Ich hoffe, dass er für Freunde hilfreich ist.
Pythons Funktionsdefinition ist relativ einfach und wird mit Hilfe des Schlüsselworts def implementiert, aber die Parameter sind sehr flexibel. Zusätzlich zu den normalerweise definierten erforderlichen Parametern können Sie auch Standardparameter, variable Parameter, Schlüsselwortparameter, benannte Schlüsselwortparameter und Parameterkombinationen verwenden. Dadurch kann die von der Funktion definierte Schnittstelle nicht nur komplexe Parameter verarbeiten, sondern auch Aufrufe vereinfachen. Der Code des Operators
Wenn die Funktion definiert ist, geben Sie die Positionsreihenfolge der Parameter an. Positionsparameter müssen in der genauen Reihenfolge in der Definition der aufgerufenen Funktion übergeben werden.
Zum Beispiel: Berechnen Sie die n-te Potenz von x
def powern(x,n): s = 1 while n >0: s = s * x n = n -1 return s
Die beiden Parameter x und n sind Positionsparameter. Beim Aufruf einer Funktion müssen die beiden übergebenen Werte übergeben und den Parametern x und n in der Reihenfolge ihrer Position zugewiesen werden. Werden sie standardmäßig weggelassen, wird ein Fehler gemeldet. Zum Beispiel:
>>> powern(5) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: powern() missing 1 required positional argument: 'n'
In der Funktionsdefinition sind Standardwerte für die Parameter vordefiniert. Wenn beim Aufruf einer Funktion kein angegebener Wert für einen Parameter angegeben wird, wird der Standardwert verwendet.
Beispiel: Finden Sie immer noch x, erhöht auf die n-te Potenz, aber der Standardwert ist x, erhöht auf die dritte Potenz.
def powern( x,n = 3): s = 1 while n >0: s = s * x n = n -1 return s
Ausführung: powern(2), was dem Aufruf von powern(2,3) entspricht
Wenn die vierte Potenz von 2 erforderlich ist, müssen Sie ausführen: powern(2,4)
Welche Vorteile bietet das Festlegen von Standardparametern?
Standardparameter können Funktionsaufrufe vereinfachen und die Schwierigkeit beim Aufrufen von Funktionen verringern. Unabhängig davon, ob es sich um einen einfachen oder einen komplexen Aufruf handelt, muss nur eine Funktion definiert werden.
Wenn beispielsweise im obigen Beispiel von powern() andere Werte von n übergeben werden, können andere n-te Potenzen von x realisiert werden.
Aber bei der Verwendung von Standardparametern kann es bei unsachgemäßer Verwendung zu Fallstricken kommen. Lassen Sie uns zunächst den Unterschied zwischen variablen Parametern und unveränderlichen Parametern als Funktionsparameter verstehen:
Unveränderliche Parameter als Funktionsparameter
>>> a = 1
>>> def func(a):
... print('func_id:',id(a))
... a = 2
... print('after_func_id:',id(a),'id(2):',id(2))
...
>>> print('out_of_func_id:',id(a),'id(1):',id(1))
out_of_func_id: 501962480 id(1): 501962480 # 全局变量a的id
>>> func(a) # 将全局参数a传入函数
func_id: 501962480 # a=1 的id
after_func_id: 501962496 id(2): 501962496
>>> print(a) # 退出函数，a的值仍为1
1Bei der Übergabe des globalen a an die Funktion Anschließend wird der Die Funktion kopiert automatisch eine Referenz. Nach der Ausführung von a=2 ändert sich die Speicheradresse von id(a). Aber es hat nichts mit dem äußeren a zu tun.
Variablenobjekt als Funktionsparameter
>>> a = []
>>> def func2(a):
... print('func2_id:',id(a))
... a.append(1)
...
>>> print('out_of_func2_id',id(a))
out_of_func2_id 59694296
>>> func2(a)
func2_id: 59694296
>>> print(a)
[1]Der Typ der Variablen a ist Liste, bei der es sich um ein Variablenobjekt handelt. Die Referenz der Funktion zeigt auf ein veränderliches Objekt, und die Adresse ändert sich nicht, sodass sich der Inhalt von a nach der Funktionsoperation ändert.
Wenn also die Funktion func2(a) erneut ausgeführt wird, wird ein anderes Ergebnis als erwartet erzeugt:
>>> func2(a) func2_id: 59694296 # a地址不变 >>> print(a) [1, 1] # 因为第一次执行func2(a)时，已经修改了a=[1]，再次调用时，在[1]里新增
Zum Beispiel:
def add_end( L=[] ): # 设置为一个list变量L（对象可变）
L.append('end')
return L
>>> add_end( )
['end']
>>> add_end()
['end', 'end']Bei wiederholtem Aufruf mit Standardparametern lautet das Ergebnis falsch.
Wenn die Python-Funktion definiert ist, wird der Wert des Standardparameters L berechnet, der [] ist. L ist auch eine Variable, die auf das Objekt [] zeigt. Wenn bei jedem Aufruf der Funktion der Inhalt von L geändert wird, ändert sich der Inhalt des Standardparameters beim nächsten Aufruf, und dies ist nicht mehr der Fall das [], als die Funktion definiert wurde.
kann geändert werden in:
def add_end( L=None ): # L为不变对象
if L is None:
L = []
L.append('end')
return L Dann gibt es kein Problem, egal wie oft es aufgerufen wird.
Bei der Definition von Standardparametern ist also eines zu beachten: Standardparameter müssen auf unveränderliche Objekte verweisen! Denn sobald ein unveränderliches Objekt erstellt wurde, können die Daten im Objekt nicht mehr geändert werden, wodurch Fehler reduziert werden, die durch die Änderung der Daten verursacht werden. Da das Objekt außerdem unverändert bleibt, ist für das gleichzeitige Lesen von Objekten in einer Multitasking-Umgebung keine Sperre erforderlich.
Beim Festlegen von Standardparametern gibt es einige Dinge zu beachten
1. Erforderliche Parameter stehen an erster Stelle und Standardparameter an letzter Stelle, andernfalls meldet der Python-Interpreter einen Fehler.
2. Wie stelle ich Standardparameter ein? Wenn eine Funktion mehrere Parameter hat, platzieren Sie die Parameter mit größeren Änderungen vorne und die Parameter mit kleineren Änderungen am Ende. Parameter mit kleinen Änderungen können als Standardparameter verwendet werden.
3. Verwenden Sie keine veränderlichen Objekte als Standardparameter.
Variable Parameter, d. h. die Anzahl der übergebenen Parameter ist variabel, von 0 bis zu einer beliebigen Zahl.
Da die Anzahl der Parameter ungewiss ist, können Sie sie mithilfe einer Liste oder eines Tupels übergeben. Es wird dann beim Aufruf der Funktion automatisch zu einem Tupel zusammengesetzt.
Zum Beispiel:
def calc(numbers): # 变量 sum = 0 for n in numbers: sum = sum + n * n return sum >>> calc( [1,2,3] ) # 传入的是一个list 14
Verwendung variabler Parameter *args:
def calc( *numbers ): sum = 0 for n in numbers: # 在函数内部，numbers组装成一个tuple sum = sum + n * n return sum >>> calc( ) # 0个参数 0 >>> calc( 1,3,5,7 ) # 多个参数 84 >>> num = [1,2,3] # list >>> calc( *num ) # *list –> tuple 14 >>> t = (1,3,5) >>> calc( t ) # tuple(错误) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in calc TypeError: can't multiply sequence by non-int of type 'tuple' >>> calc( *t ) 35
Der Funktionscode bleibt völlig unverändert. Beim Aufruf dieser Funktion können jedoch beliebig viele Parameter übergeben werden, darunter auch 0 Parameter.
Schlüsselwortparameter **kw ermöglicht die Übergabe von 0 an eine beliebige Anzahl von Parametern, die Parameternamen enthalten dict innerhalb der Funktion. Zum Beispiel:
def person(name , age , **kw ):
print('name:',name,'age:',age,'other:',kw)
>>> person('xiong',18)
name: xiong age: 18 other: {}
>>> person('xiong',18,city = 'SH') # city是原本没有的参数，但是因为有**kw
name: xiong age: 18 other: {'city': 'SH'}Wofür werden die Schlüsselparameter verwendet? Die Funktionsfunktionalität kann erweitert werden. Beispielsweise erhält sie in der Funktion person() garantiert die beiden Parameter Name und Alter. Werden aber weitere Parameter bereitgestellt, können diese auch empfangen werden. Natürlich können Sie auch zuerst ein Diktat zusammenstellen und es dann in Schlüsselwortparameter umwandeln und übergeben:
>>> extra ={'city':'shanghai','job':'SET'} # dict的定义
>>> person('xiong',18,city = extra['city'],job=extra['job']) # dict的使用
name: xiong age: 18 other: {'city': 'shanghai', 'job': 'SET'} # dict的内容
>>> person('xiong',18,**extra)
name: xiong age: 18 other: {'city': 'shanghai', 'job': 'SET'}[Zusammenfassung] **extra bedeutet, dass alle Schlüsselwerte des zusätzlichen Diktats übergeben werden in Schlüsselwortparameter. kw erhält ein Diktat. Beachten Sie, dass das durch kw erhaltene Diktat eine Kopie von extra ist.
如果要限制关键字参数的名字，就可以用命名关键字参数。需要一个特殊分隔符“”，“”后面的参数被视为命名关键字参数。如果缺少“*”，Python解释器则无法识别位置参数和命名关键字参数。在调用时，必须指定参数名字与参数值。
例如，只接收city和job作为关键字参数，可以使用如下定义：
def person( name ,age,*,city,job):
print(name , age , city , job )
>>> person('xiong', 18, city='shanghai', job='tester')
xiong 18 shanghai tester如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
>>> def person( name,age,*args,city,job ): # 此处city和job也是命名关键字参数 ... print(name, age, city, job)
命名关键字参数必须传入参数名，如果没有传入参数名，调用将会报错：
>>> person('xlp',18,'shanghai','tester') # 错误调用
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'
>>> person('xlp',18,city='shanghai',job='tester') # 正确调用
xlp 18 shanghai tester命名关键字参数可以有缺省值，从而简化调用：
>>> def person1(name,age,*,city='shanghai',job):
... print(name,age,city,job)
...
>>> person1('xlp',18,job='engineer')
xlp 18 shanghai engineer在Python中定义函数，可以用位置参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。
但是要注意，参数定义的顺序必须是：位置参数、默认参数、可变参数、命名关键字参数和关键字参数。
（1）定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个list、tuple;
**kw是关键字参数，kw接收的是一个dict；
（2）调用函数时如何传入可变参数和关键字参数的语法：
可变参数直接传入：func(1,2,3)
可变参数间接传入：先组装成list或tuple，l=(1,2,3)，再通过args传入，func(l)
关键字参数直接传入：func(a=1,b=2)
关键字参数间接传入：先组装成dict，d={‘a’:1,’b’:2}，再通过kw传入，func(d)
（3）命名关键字参数 是为了限制调用者可以传入的参数名，同时可以提供默认值。
（4）定义命名的关键字参数在没有可变参数的情况下，不要忘记写分隔符*，否则定义的将是位置参数
相关推荐：
Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in Funktionsparameter in Python (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
