Funktionsnutzung
Funktionsparametertyp
Unveränderliche Typparameter: numerisch, Zeichenfolge str, Tupel Tupel.
Variablentyp:
a ist in den Listen- und Wörterbuch-Diktierfunktionen unveränderlich. Fun (a) ändert den Wert von a intern, ändert jedoch nur ein anderes kopiertes Objekt, ohne a selbst zu beeinflussen.
1. Das Übergeben unveränderlicher Typparameter wirkt sich nicht auf den Parameter selbst aus.
2. Das Übergeben von Parametern vom Variablentyp wirkt sich auf den Parameter selbst aus
# Unveränderlicher Parametertyp
a = 1 print (id (a)) # 2009628784 def func (a): a = 10 print (a, id (a)) func (a) # 20 2009629392 def func (a): a = 1 print (a, id (a)) func (a) # 1 2009628784 print (a, id (a)) # 1 2009628784
# Variable Parameter Typ B = [10,20 ] Druck (ID (B)) # 2324968580360 DEF FUNC (B): b.append ( 30 ) Drucken (ID (B)) FUNC (B) # 2324968580360 Drucken (B, id (b)) # [10, 20, 30] 2324968580360
Funktionsparameter (obligatorische Parameter, Standardparameter, optionale Parameter, Schlüsselwortparameter)
# Obligatorischer Parameter def func1 (x): Rückgabe x * x func1 ( 2 ) # 4 # Standardparameter , #Hinweis: Der Standardparameter muss nach dem obligatorischen Parameter
# Defect:
funcX DEF (L = []): L.append ( „ am Ende “ zurück L funcX () # , wenn die Funktionsdefinitionen, Standardparameter durch die Adresse L hergestellt haben festgestellt , dass jeder Anruf den L Inhalt ändert.
def func2 (x, y = 10 ): Rückgabe x * y func2 ( 3 ) # 30 func2 ( 3 , 5 ) # 15
optionaler Parameter
def func3 (* nmbers):
sum = 0
für i in Zahlen:
sum = sum + i * i
return sum
func3 ([1,2,3])
# 14
Schlüsselwortparameter
def func4 (Name, ** kwargs):
print ("data:", kwargs)
Rekursive Funktion
Rekursive Funktion Wenn sich eine Funktion intern aufruft, ist diese Funktion eine rekursive Funktion.
Bedingungen für die Verwendung rekursiver Funktionen:
1. Der Ausgang muss verlassen werden.
2. Rufen Sie Ihren eigenen
Fall auf1:
# . Rekursive Funktion Auswertung 3 .... * 2 * 1 * 7 * 8 * 9 * 10.. DEF FUNC (X): IF . X == 1 : return X return X * func (. -X 1 ) Drucke (FUNC (10 )) # 3628800
Fall 2:
# Erweitern Sie die Liste alle
lst1 = [1,2, [3,4, [5, [6, [7], 8,9]], 10], 11,12,13 ] lst2 = [] def func (lst1 ): für i in LST1: IF isinstance (i, Liste): # wenn Liste func (i) ausgeführt wird func (i) die sonst : lst2.append (i) # wenn es nicht in lst2 Elementliste gesetzt wird func ( lst1) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
Fall 3:
# Verwenden Sie die rekursive Funktion, um die Fibonacci-Sequenz
# 1 1 # 2 2 # 3 2 + 1 = 3 # 4 3 + 2 = 5 # ... # nf (n-1) + f (n-2) def func zu finden (n): wenn n == 1 oder n == 2 : return n return func (n-1) + func (n-2 ) print (func (5 )) # 8
case3 ：
Ein Frosch kann 1 oder 3 oder 7 oder 10 Schritte gleichzeitig springen. F: Es gibt n Schritte. Auf wie viele Arten kann ein Frosch hochspringen? 1-2 1 n <= 2 f (n) = 1 3 2 f (2) + f (0) = 2 4 2 + 1 = 3 f (3) + f (1) = 4 5 3 + 1 = 4 6 4 + 2 = 6 ... nf (n - 1) + f (n - 3) + f (n - 7) + f (n - 10 ) def func (x): wenn 1 <= x <3 : return 1 elif x < 0: return 0 else : return func (x-1) + func (x-3) + func (x-7) + func (x-10 ) print (func (10 )) # 22
Funktionsnamensraum
Namespaces werden in drei Typen unterteilt: lokaler Namespace, globaler Namespace und integrierter
lokaler Namespace-Namespace: Jede Funktion verfügt über einen eigenen Namespace, den so genannten lokalen Space, der die Variablen der Funktion einschließlich Funktionsparameter und lokal aufzeichnet Definierte Variablen
def test (): a = 2 print (a) test () print (a) # 2 #NameError: Name ' a ' ist nicht definiert
Globaler Namespace: Jedes Modul verfügt über einen eigenen Namespace, den so genannten globalen Namespace, der die Variablen des Moduls aufzeichnet, einschließlich Funktionen, Klassen und anderer importierter Module.
a = 2 def test (): print (a) test () print (a) # 2 # 2
Eingebauter Namespace: Jedes Modul kann darauf zugreifen, es speichert eingebaute Funktionen und Ausnahmen.
print (), input () ...
Lokale und globale Variablen
Lokale Variablen: Innerhalb der Funktion definierte Variablen
Globale Variablen: Außerhalb der Funktion definierte Variablen. Wenn es sich um unveränderliche Typen handelt, können sie nicht innerhalb der Funktion geändert werden
name = ' zzq ' list1 = [ 10 ] def func (): name = ' johnson ' list1.append (name) print ( " inner " , name) func () print ( " äußere " , name) print (list1) # innerer Johnson # äußerer zzq name = ' zzq ' name = ' johnson ' def func (): globaler Name # 全局 变量 name = ' 123' func () print (name) # 123 name = ' zzq ' def func1 (): name = ' ls ' def func2 (): nichtlokaler Name # Wenn der lokale Funktionsbereich keine Variable finden kann, wird der Interpreter automatisch Suchen Sie in der äußeren Funktion nach name = ' abc ' func2 () print ( " --------- " , name) func1 () print (name)
- Funktionen definieren den lokalen Bereich, während Module den globalen Bereich definieren.
Wenn Sie den globalen Bereich in der Funktion definieren möchten, müssen Sie den globalen Modifikator hinzufügen.- Auflösung von Variablennamen: LEGB-Prinzip
Bei Verwendung nicht authentifizierter Variablennamen in Funktionen sucht Python nach 4 Bereichen [lokaler Bereich (L) (Funktionen, die intern deklariert werden, jedoch keine globalen Variablen verwenden), gefolgt von der Struktur der oberen Ebene Der lokale Bereich (E) von def oder Lambda, gefolgt vom globalen Bereich (G) (Variablen, die in der Funktion unter Verwendung von global oder auf Modulebene deklarierten Variablen deklariert wurden) und schließlich dem integrierten Bereich (B) (dh der integrierten Klasse von Python) Und Funktionen usw.)] und halten an der ersten Stelle an, an der der Variablenname gefunden werden kann. Wenn der Variablenname während des gesamten Suchvorgangs
nicht gefunden wird, meldet Python einen Fehler.- Nachdruck unter https://www.cnblogs.com/summer-cool/p/3884595.html