Python-Funktion, Iteration

1. Funktion

1. Verschachtelung von Funktionen

. 1  DEF Huangwei ():   # Funktion nicht im Inneren können , die nicht durchführen außerhalb 
2      name = ' Huang ' 
3.      Print (name)
 4.  
5.      DEF : Liuyang ()
 6.          Name = ' Liuyang ' 
7.          Print (name)
 8.  
9.          DEF nulige ():
 10              name = ' fahsfha ' 
11              print (name)
 12  
13          print (name)
 14          nulige ()
 15          return nulige
 16 
17      liuyang ()
 18      print (name)
 19      return liuyang

 

(1) Nur die Reihenfolge huangwei () lautet 1-2-3-17-5-6-7-13-14-9-10-11-15-18-19

(2) huangwei () = liuyang, also sollte liuyang huangwei () () sein

(3) huangwei () () = nulige, um hart zu laufen, sollte der Bruder huangwei () () () sein

2. Selbstschleife der Funktion

1 person_list = [ ' a ' , ' b ' , ' v ' , ' d ' , ' vd ' ]
 2  
3  def ask_way (person_list):
 4      print ( ' - ' * 60 )
 5      if person_list == 0:
 6          return  ' 根本 没 人 知道' 
7      person = person_list.pop (0)
 8      if person == ' d ':
 9          return  ' So ist es. . . . . ' 
10      Print ( ' hallo% S, wissen Sie, wie Sie xx ' % der Person)
 11      Druck ( ' % S Ich bin nicht sicher , kann ich Ihnen helfen, fragen S% ' % (die Person, person_list))
 12      Import Zeit
 13      der time.sleep ( 0)   # Zeit zum Importieren 
14      res = ask_way (person_list)
 15      return res
 16  "" " ----------------------------- -------------------------------
 17  Hallo, kennst du xx Straße 18 ?
 a Ich weiß es nicht, lass mich dich fragen ['b', 'v', 'd', 'vd']
 19  ----------------------- -------------------------------------
 20  hi b, kennst du xx weg
 21  b ich nicht Wisse, dass ich dir helfen kann, ['v', 'd', 'vd'] zu fragen
 22  ------------------------------ ------------------------------
 23  hi v, weißt du xx Weg
 24  v Ich weiß nicht, ich werde dich fragen [ 'd', 'vd']
 25  ------------------------------------- -------------------
 26  So ist es. . . . .
27  "" "

3. Lambda-Funktion

(1) Anonyme Funktionen verwenden im Allgemeinen Lambda x: x + 1: x als formalen Parameter in Verbindung mit anderen Funktionen. X + 1 ist der Rückgabewert 

  (2) Funktionale Programmierung, es sollte keine Zuordnung im Funktionskörper geben, keine Variablendefinition

 

Zweitens Iteration

y = x .__ iter __ () konvertiert x in ein iterierbares Objekt, das in einen Iterator konvertiert werden kann

y .__ next __ () / next (y) Iterieren Sie die Ausgabe jedes Elements. Eine Codezeile gibt eine aus. Wenn zu viel ausgegeben wird, wird ein Fehler gemeldet

Die Rendite-Rendite-Funktion entspricht der Rendite, aber die Rendite kann nur einmal ausgeführt werden, die Rendite kann mehrmals ausgeführt werden

def test ():
     Ausbeute S   # Ausbeute entspricht Rückgabe 
    Ausbeute 1
     Ausbeute 2
     Ausbeute 3   # Ausbeute kann mehrfach ausgeführt werden, Rückgabe kann jedoch nur einmal ausgeführt werden 
g = test ()
 print (g)
 print ((g. __next__ ()))
 drucken ((G. __next__ ()))
 drucken ((G. __next__ ()))
 drucken ((G. __next__ ()))
 # Ergebnisse 
# <Generator Object Test bei 0x10e240f20> 
# {. 1, 2 ,. 3} 
# . 1 
# 2
# 3