#Wenn Sie eine lange Zeichenfolge aus einer kleinen Zeichenfolge erstellen möchten, gibt es eine Methode, um sie nach und nach wie folgt zu erstellen.
>>> alphabet = ""
>>> alphabet +="abcdefg"
>>> alphabet +="hijklmnop"
>>> alphabet +="qrstuv"
>>> alphabet +="wxyz"
#Wenn Sie fortlaufende Zeichen verwenden, können Sie es in einem Schritt erstellen, ohne dass es schwierig ist, es zu sehen.
>>> alphabet = "abcdefg" + \
... "hijklmnop" +\
... "qrstuv"+\
... "wxyz"
#Leitungskontinuität ist auch erforderlich, wenn eine Leitung mehrere Leitungen umfasst.
>>> 1+2+
File "<stdin>", line 1
1+2+
^
SyntaxError: invalid syntax
>>> 1+2\
... 3
File "<stdin>", line 2
3
^
SyntaxError: invalid syntax
>>> 1+2+\
... 3
6
#Ein Programm, das den Inhalt einer Katastrophe überprüft und entsprechende Kommentare anzeigt
>>> disaster = True
>>> if disaster:
... print("Woe!")
... else:
... print("Whee!")
...
Woe!
>>> funny = True
>>> small = True
#Wenn wenn lustig wahr ist, geben Sie den wenn kleinen Test ein.
>>> if funny:
... if small:
... print(" It is a cat.")
... else:
... print(" It is a bear!")
... else:
... if small:
... print(" It is a skink!")
... else:
... print(" It is a human.Or a hairless bear.")
...
It is a cat.
#Wenn der Test in 3 oder mehr Typen unterteilt ist, wenn,elif(bedeutet sonst wenn),Verwenden Sie sonst.
>>> color ="puse"
>>> if color =="red":
... print(" It is a tomato")
... elif color =="green":
... print(" It is a green pepper")
... elif color =="bee purple":
... print("I don't know what it is,but only bees can see it")
... else:
... print("I've never heard of the color",color)
...
I've never heard of the color puse
>>> x =2
#Äquivalenztest
>>> x ==2
True
>>> x ==5
False
>>> 4 < x
False
>>> x<10
True
#Der Boolesche Operator hat eine niedrigere Priorität als das zu vergleichende Element.
#Der Boolesche Operator wird ausgeführt, nachdem das zu vergleichende Element zuerst berechnet wurde.
>>> 1<x and x <10
True
>>> 1<x or x <10
True
>>> 1<x and x >10
False
>>> 1<x and not x >10
True
>>> 1<x<10
True
>>> 1<x<10<377
True
| Was als falsch angesehen wird | Wert |
|---|---|
| Boolescher Wert | False |
| null | None |
| Ganzzahl Null | 0 |
| Null Schwimmer | 0.0 |
| Leerer String | " " |
| Leere Liste | [ ] |
| Leerer Taple | ( ) |
| Leeres Wörterbuch | { } |
| Leeres Set | set() |
>>> some_list = []
>>> if some_list:
... print("There's something in here")
... else:
... print("Hey,it's empty!")
...
Hey,it's empty!
--Verwenden Sie eine Schleife, wenn Sie dasselbe mehrmals ausführen möchten.
#Initialisierung der Zählung
#Vergleichen Sie den Wert von count mit 5
#Inkrementanzahl um 1(Hinzufügen)
>>> count =1
>>> while count <=5:
... print(count)
... count+=1
...
1
2
3
4
5
#Endlosschleife
#input()Verwenden Sie eine Funktion, um die Eingabezeile von der Tastatur zu lesen und sie dem Inhalt zuzuweisen
#Das Eingabezeichen ist"q":Wenn ja, verlassen Sie die Schleife.
#"q"Anders als oben wird das erste Zeichen der Eingabezeichenfolge in Großbuchstaben angezeigt.
>>> while True:
... stuff=input("String to capitalize[type q to quit]:")
... if stuff == "q":
... break
... print(stuff.capitalize())
...
String to capitalize[type q to quit]:type
Type
String to capitalize[type q to quit]:untitarou
Untitarou
String to capitalize[type q to quit]:q
#input()Verwenden Sie eine Funktion, um die Eingabezeile von der Tastatur zu lesen und dem Wert zuzuweisen
#Das Eingabezeichen ist"q":Wenn ja, verlassen Sie die Schleife.
#Setzen Sie den Wert auf int und weisen Sie ihn der Nummer zu
#Wenn es gerade ist, starten Sie die nächste Iteration
>>> while True:
... value=input("Integer,please [q to quit]:")
... if value == "q":
... break
... number =int(value)
... if number %2==0:
... continue
... print(number,"squared is",number*number)
...
Integer,please [q to quit]:1
1 squared is 1
Integer,please [q to quit]:2
Integer,please [q to quit]:3
3 squared is 9
Integer,please [q to quit]:q
#Initialisierung der variablen Position
#Wenn auch"Found even numbers"Und diese Nummer wird angezeigt und break beendet die while-Anweisung.
#Die else-Klausel wird ausgeführt, wenn der while-Teil beendet ist, das gewünschte Objekt jedoch nicht gefunden wurde.(Break Checker)
>>> number =[1,3,5]
>>> position =0
>>> while position <len(number):
... numbers=number[position]
... if numbers%2 ==0:
... print("Found even numbers",numbers)
... break
... position+=1
... else:
... print("No even number found")
...
No even number found
Python verwendet häufig ** Iteratoren (die für jede Iteration Elemente einzeln aus Listen, Wörterbüchern usw. abrufen und zurückgeben) **. Weil Sie jedes Element der Datenstruktur bearbeiten können, ohne die Datenstruktur zu kennen.
#while-Anweisung
>>> rabbits =["a","b","c","d"]
>>> current=0
>>> while current<len(rabbits):
... print(rabbits[current])
... current +=1
...
a
b
c
d
#zur Aussage
>>> for rabbit in rabbits:
... print(rabbit)
...
a
b
c
d
** Iterierbare (entsprechend Iteratoren) Objekte ** in Python zusammen mit ** Listen, Zeichenfolgen, Tapples, Wörterbüchern, Mengen usw. **.
--Wenn Sie einen Tipp oder eine Liste mit for verarbeiten, wird jeweils ein Element entfernt. --Wenn Sie eine Zeichenfolge mit for verarbeiten, wird jeweils ein Zeichen wie unten gezeigt generiert.
>>> word="cat"
>>> for letter in word:
... print(letter)
...
c
a
t
>>> accusation ={"a":"ballroom","b":"weapon","c":"kowai"}
>>> for card in accusation:
... print(card)
...
a
b
c
>>> for value in accusation.values():
... print(value)
...
ballroom
weapon
kowai
--Verwenden Sie die Funktion items (), wenn Sie sowohl den Schlüssel als auch den Wert in Form eines Taples zurückgeben möchten.
>>> for value in accusation.items():
... print(value)
...
('a', 'ballroom')
('b', 'weapon')
('c', 'kowai')
>>> for card,contents in accusation.items():
... print("Card",card,"has the contents",contents)
...
Card a has the contents ballroom
Card b has the contents weapon
Card c has the contents kowai
Wenn Sie eine break-Anweisung in die for-Anweisung einfügen, können Sie die Schleife auf dieselbe Weise wie while stoppen.
Wenn Sie in der for-Anweisung fortfahren, wird sowohl zur nächsten Iteration als auch während der nächsten Iteration gesprungen.
Wie während hat for ein optionales else, um zu überprüfen, ob es normal beendet wurde. Wenn break nicht aufgerufen wird, wird die else-Anweisung ausgeführt.
>>> cheeses=[]
>>> for cheese in cheeses:
... print("This shop has some lovely",cheese)
... break
... else:
... print("This is not much of a cheese shop,is it?")
...
This is not much of a cheese shop,is it?
#Liste erstellen
#Nur Desserts sind länger als die anderen Listen. Niemand bekommt Pudding, wenn die anderen Faktoren nicht verlängert werden.
>>> days =["Monday","Tuesday","Wednesday"]
>>> fruits=["coffee","tea","bear"]
>>> drinks=["coffee","tea","beer"]
>>> desserts=["tiamisu","ice cream","pie","pudding"]
#zip()Kann verwendet werden, um einen Taple aus Elementen mit einem gemeinsamen Versatz zu erstellen, indem mehrere Sequenzen verfolgt werden.
>>> for day,fruit,drink,dessert in zip(days,fruits,drinks,desserts):
... print(day,":drink",drink,"- eat",fruit,"-enjoy",dessert)
...
Monday :drink coffee - eat coffee -enjoy tiamisu
Tuesday :drink tea - eat tea -enjoy ice cream
Wednesday :drink beer - eat bear -enjoy pie
#zip()Der von zurückgegebene Wert ist kein Taple oder eine Liste, sondern ein iterierbarer Wert, der abgegriffen oder aufgelistet werden kann.
>>> english="Monday","Tuesday","Wednesday"
>>> french="Lundi","Mardi","Mercredi"
#Aufführen
>>> list(zip(english,french))
[('Monday', 'Lundi'), ('Tuesday', 'Mardi'), ('Wednesday', 'Mercredi')]
#Wörterbuch
>>> dict(zip(english,french))
{'Monday': 'Lundi', 'Tuesday': 'Mardi', 'Wednesday': 'Mercredi'}
#Erstellen Sie einen Bereich von 0 bis 3
>>> for x in range(0,3):
... print(x)
...
0
1
2
#Aufführen
>>> list(range(0,3))
[0, 1, 2]
#Erstellen Sie einen Bereich von 2 bis 0
>>> for x in range(2,-1,-1):
... print(x)
...
2
1
0
#Aufführen
>>> list(range(2,-1,-1))
[2, 1, 0]
#Nehmen Sie gerade Zahlen von 0 bis 10 heraus
>>> list(range(0,11,2))
[0, 2, 4, 6, 8, 10]
** Einschlussnotation ** ist ein Format, mit dem Sie eine Python-Datenstruktur aus einem oder mehreren Iteratoren kompakt erstellen können.
Eine Liste von Ganzzahlen von 1 bis 5 kann auch erstellt werden, indem Elemente einzeln hinzugefügt werden, wie unten gezeigt.
#append()Wird am Ende hinzugefügt.
>>> number_list=[]
>>> number_list.append(1)
>>> number_list.append(2)
>>> number_list.append(3)
>>> number_list.append(4)
>>> number_list.append(5)
>>> number_list
[1, 2, 3, 4, 5]
#range()Es kann auch mit einer Funktion und für erstellt werden.
>>> number_list=[]
>>> for number in range(1,6):
... number_list.append(number)
...
>>> number_list
[1, 2, 3, 4, 5]
#range()Sie können es auch machen, indem Sie die Ausgabe von direkt konvertieren.
>>> number_list = list(range(1,6))
>>> number_list
[1, 2, 3, 4, 5]
Der Code mit der ** Listeneinschlussnotation ** ist unten dargestellt.
#[expression for item in iterable]Grundformat von
#Die erste Zahlenvariable ist die Anzahl der Schleifenausführungsergebnisse_Zum Speichern in der Liste.
#Die zweite Zahl ist Teil der for-Anweisung
>>> number_list = [number for number in range(1,6)]
>>> number_list
[1, 2, 3, 4, 5]
#Sie können sehen, dass die erste Zahl ein Ausdruck ist.
>>> number_list = [number-1 for number in range(1,6)]
>>> number_list
[0, 1, 2, 3, 4]
>>> a_list=[]
>>> for number in range (1,6):
... if number%2 ==1:
... a_list.append(number)
...
>>> a_list
[1, 3, 5]
#[expression for item in iterable if condition]Format
>>> a_list = [number for number in range(1,6) if number %2 ==1]
>>> a_list
[1, 3, 5]
>>> rows =range(1,4)
>>> cols=range(1,3)
>>> for row in rows:
... for col in cols:
... print(row,col)
...
1 1
1 2
2 1
2 2
3 1
3 2
#Die Einschlussnotation kann auch verschachtelt werden.
#Es wird als Taple ausgegeben.
>>> rows =range(1,4)
>>> cols=range(1,3)
>>> cells = [(row,col) for row in rows for col in cols]
>>> for cell in cells:
... print(cell)
...
(1, 1)
(1, 2)
(2, 1)
(2, 2)
(3, 1)
(3, 2)
#Zeile vom Taple, während Sie die Zellenliste durchlaufen,Spalte herausziehen.
>>> for row,col in cells:
... print(row,col)
...
1 1
1 2
2 1
2 2
3 1
3 2
#"letters"Nehmen Sie die Buchstaben einzeln heraus"letters"Zählen Sie, wie viele davon enthalten sind, und schreiben Sie den Schlüssel und die Anzahl der Zählungen_In Zählungen speichern
>>> word ="letters"
>>> letter_counts={x:word.count(x)for x in word}
>>> letter_counts
{'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}
#Versuchen wir es mit Wörtern als Satz.
>>> word ="letters"
>>> letter_counts={x:word.count(x)for x in set(word)}
>>> letter_counts
{'e': 2, 'l': 1, 's': 1, 't': 2, 'r': 1}
>>> a_set={number for number in range(1,6) if number %3 ==1}
>>> a_set
{1, 4}
#Elemente zwischen () sind Notationen, die im Generator enthalten sind
>>> number_thing = (number for number in range(1,6))
#Gibt ein Generatorobjekt zurück.
>>> type(number_thing)
<class'generator'>
#Das Generatorobjekt kann mit der for-Anweisung verarbeitet werden.
>>> for number in number_thing:
... print(number)
...
1
2
3
4
5
#Notation zur Aufnahme des Listengenerators()Wenn Sie es in einen Anruf einschließen, kann es wie eine Notation mit Listeneintrag funktionieren.
>>> number_list=list(number_thing)
>>> number_list
[1, 2, 3, 4, 5]
#Der Generator kann nur einmal betrieben werden. Der Generator erstellt nacheinander Werte vor Ort und übergibt sie an den Iterator, sodass ich mich nicht an die erstellten Werte erinnere. Daher kann der Generator nicht wieder verwendet oder gesichert werden.
>>> number_list=list(number_thing)
>>>
>>> number_list
[]
Der Programmierer kann mit der Funktion zwei Dinge tun.
Um eine Python-Funktion zu definieren, geben Sie def ein, schreiben Sie den Funktionsnamen, setzen Sie die Eingabeargumente für die Funktion in Klammern und schreiben Sie (:) am Ende.
#make_a_sound()Wenn Sie eine Funktion aufrufen, führt Python den Code in der Definition aus. In diesem Fall wird ein Wort ausgegeben und die Steuerung an das Hauptprogramm zurückgegeben.
>>> def make_a_sound():
... print("quack")
...
>>> make_a_sound()
quack
#Eine Funktion, die keine Argumente hat, aber einen Wert zurückgibt
>>> def agree():
... return True
...
>>> agree()
True
#Testen Sie den Rückgabewert mit if.
>>> if agree():
... print("Splendid!")
... else:
... print("That was unexpected.")
...
Splendid!
>>> def echo(anything):
... return anything+' '+anything
...
#echo()Die Funktion ist"ss"Es wird mit dem eigentlichen Argument aufgerufen.
#Dieser Wert ist Echo()Es wird in das formale Argument "anithing" kopiert und an den Anrufer zurückgegeben.
>>> echo("ss")
'ss ss'
-Wenn Sie eine Funktion mit dem Argument ** aufrufen, werden diese Werte in den entsprechenden Parameter ** in der Funktion kopiert.
>>> def commtentary(color):
... if color == "red":
... return " It is a tomoato."
... elif color =="green":
... return " It is a green pepper"
... elif color =="bee purple":
... return "I don't know what it is,but only bees can see it."
... else:
... return "I've never heard of te color"+ color+"."
...
#"blue"Rufen Sie die Kommentarfunktion mit dem eigentlichen Argument auf.
>>> comment=commtentary("blue")
>>> print(comment)
I've never heard of te colorblue.
>>> def do_nothing():
... pass
...
>>> print(do_nothing())
None
--None wird verwendet, wenn nichts zu sagen ist. --None ist falsch, wenn es als Boolescher Wert ausgewertet wird, aber nicht identisch mit dem Booleschen Wert False.
>>> def is_none(thing):
... if thing is None:
... print(" It is nothing")
... elif thing:
... print(" It is True")
... else:
... print(" It is False")
...
>>> is_none(None)
It is nothing
>>> is_none(True)
It is True
>>> is_none(False)
It is False
#Null Ganzzahlen und Gleitkommazahlen, leere Zeichenfolgen, leere Listen, leere Tapples, leere Wörterbücher, leere Mengen sind falsch, aber nicht gleich Keine.
>>> is_none(0)
It is False
>>> is_none(0.0)
It is False
>>> is_none(())
It is False
>>> is_none([])
It is False
>>> is_none({})
It is False
>>> is_none(set())
It is False
--Positionsargumente sind Argumente, die von Anfang an in die formalen Argumente an den entsprechenden Positionen kopiert werden.
>>> def menu(x,y,z):
... return{"wine":x,"entree":y,"dessert":z}
...
>>> menu("aaa","bbb","ccc")
{'wine': 'aaa', 'entree': 'bbb', 'dessert': 'ccc'}
>>> def menu(x,y,z):
... return{"wine":x,"entree":y,"dessert":z}
...
>>> menu("beef","bagel","bordeaux")
{'wine': 'beef', 'entree': 'bagel', 'dessert': 'bordeaux'}
#Es wird ein formales Argument und ein tatsächliches Argument angegeben.
>>> menu(y="beef",z="bagel",x="bordeaux")
{'wine': 'bordeaux', 'entree': 'beef', 'dessert': 'bagel'}
#Wenn Sie sowohl Positions- als auch Schlüsselwortargumente verwenden möchten, geben Sie zuerst das Positionsargument an.
>>> menu("frontenac",z="flan",y="fish")
{'wine': 'frontenac', 'entree': 'fish', 'dessert': 'flan'}
#Angabe des Standardargumentwerts
>>> def menu(x,y,z="unchi"):
... return{"wine":x,"entree":y,"dessert":z}
...
#"dessert"Nur das Argument wird nicht angegeben, daher wird das Standardargument eingegeben.
>>> menu("dunkelfelder","chiken")
{'wine': 'dunkelfelder', 'entree': 'chiken', 'dessert': 'unchi'}
#Wenn Sie ein Argument angeben, wird es anstelle des Standardwerts verwendet.
>>> menu("dunkelfelder","duck","doughnut")
{'wine': 'dunkelfelder', 'entree': 'duck', 'dessert': 'doughnut'}
>>> def buggy(arg,result=[]):
... result.append(arg)
... print(result)
...
>>> buggy("a")
['a']
#['ab']ich will...
>>> buggy("ab")
['a', 'ab']
#buggy()Ergebnis jedes Mal, wenn eine Funktion aufgerufen wird[]Der Punkt ist, es zu initialisieren
>>> def buggy(arg):
... result=[]
... result.append(arg)
... return result
...
>>> buggy("a")
['a']
#Hat richtig funktioniert!!!!
>>> buggy("b")
['b']
#result=[]Das Ergebnis wird mit der if-Anweisung als initialisiert.
>>> def nonbuggy(arg,result=None):
... if result is None:
... result = []
... result.append(arg)
... print(result)
...
>>> nonbuggy("a")
['a']
>>> nonbuggy("b")
['b']
>>> def print_args(*args):
... print("Positional argument tuple:",args)
...
>>> print_args()
Positional argument tuple: ()
#Wird als Args Taple angezeigt
>>> print_args(3,2,1,"wait!","uh...")
Positional argument tuple: (3, 2, 1, 'wait!', 'uh...')
#Wenn ein erforderliches Argument vorhanden ist, am Ende des Positionsarguments*Durch das Schreiben von Argumenten können alle Positionsargumente außer den erforderlichen Argumenten zu einem kombiniert werden.
>>> def print_more(x1,x2,*args):
... print("Need this one",x1)
... print("Need this one too",x2)
... print("All the rest",args)
...
>>> print_more("cap","gloves","scarf","monocle","mustache wax")
Need this one cap
Need this one too gloves
All the rest ('scarf', 'monocle', 'mustache wax')
>>> def print_kwargs(**kwargs):
... print("Keyward arguments:",kwargs)
...
>>> print_kwargs(x="xx",y="yy",z="zz")
Keyward arguments: {'x': 'xx', 'y': 'yy', 'z': 'zz'}
**4.7.6 docstring
--Funktion Sie können der Funktionsdefinition ein Dokument hinzufügen, indem Sie eine Zeichenfolge am Anfang des Hauptthemas einbetten. Dies wird als Funktionsdokumentationszeichenfolge bezeichnet.
>>> def echo(anything):
... 'echo gibt das angegebene Eingabeargument zurück'
... return anything
...
#help()Wenn die Funktion aufgerufen wird, wird die Dokumentzeichenfolge der Funktion angezeigt.
>>> help(echo)
Help on function echo in module __main__:
echo(anything)
echo gibt das angegebene Eingabeargument zurück
(END)
--Funktionen sind auch Objekte. --Funktionen können als Elemente in Listen, Tapples, Sets und Wörterbüchern verwendet werden.
>>> def answer():
... print(43)
...
>>> answer()
43
>>> def run_something(func):
... func()
...
#answer()Wenn Sie stattdessen die Antwort übergeben, verwenden Sie die Funktion wie jeden anderen Datentyp als Datentyp.
>>> run_something(answer)
43
>>> def add_args(x1,x2):
... print(x1+x2)
...
>>> type(add_args)
<class'function'>
#Laufen Sie mit func als Objekt_something_with_An args übergeben.
>>> def run_something_with_args(func,arg1,arg2):
... func(arg1,arg2)
...
>>> run_something_with_args(add_args,5,9)
14
#Nehmen Sie eine beliebige Anzahl von Positionsargumenten und summieren Sie diese()Die Funktion berechnet und gibt die Summe davon zurück.
>>> def sum_args(*args):
... return sum(args)
...
>>> def run_with_positional_args(func,*args):
... return func(*args)
...
>>> run_with_positional_args(sum_args,1,2,3,4)
10
>>> def outer(a,b):
... def inner(c,d):
... return c+d
... return inner(a,b)
...
>>> outer(4,7)
11
>>> def knights(s):
... def inner(q):
... return "%s" % q
... return inner(s)
...
>>> knights("Ni!")
'Ni!'
#inner2()Fordert kein Argument an und verwendet das Argument s direkt für die äußere Funktion.
#knights2()Gibt den Funktionsnamen zurück, anstatt inner2 aufzurufen.
#inner2 fungiert als Verschluss.
>>> def knights2(s):
... def inner2():
... return "%s" % s
... return inner2
...
>>> a= knights2("Duck")
>>> b= knights2("Hasenpfeffer")
>>> type(a)
<class'function'>
>>> type(b)
<class'function'>
#Dies sind Funktionen, aber auch Verschlüsse.
>>> a
<function knights2.<locals>.inner2 at 0x1006d6ef0>
>>> b
<function knights2.<locals>.inner2 at 0x1006d60e0>
#Wenn diese aufgerufen werden, erinnern sich die beiden Verschlüsse an den Inhalt der s, die sie in Knights2 gemacht haben.
>>> a()
'Duck'
>>> b()
'Hasenpfeffer'
>>> def edit_story(words,func):
... for word in words:
... print(func(word))
...
>>> stairs = ["x","u","z","r"]
>>> def enliven(word):
... return word.capitalize()+"!"
...
#Jedes Zeichen wird aus der Liste entfernt und von belebt verarbeitet.
>>> edit_story(stairs,enliven)
X!
U!
Z!
R!
#enliven()Die Funktion ist so kurz, dass ich sie durch Lambda ersetze.
#Dieses Lambda braucht ein Argument, ein Wort.
#":"Der Teil von bis zum Ende ist eine Funktionsdefinition.
>>> edit_story(stairs,lambda word:word.capitalize()+"!")
X!
U!
Z!
R!
#Die Generatorfunktion gibt den Wert in einer Yield-Anweisung anstelle von return zurück.
>>> def my_range(first=0,last=10,step=1):
... number=first
... while number < last:
... yield number
... number +=step
...
#my_Reichweite ist eine normale Funktion.
>>> my_range
<function my_range at 0x1009364d0>
>>> ranger=my_range(1,5)
#Gibt ein Generatorobjekt zurück.
>>> ranger
<generator object my_range at 0x100636ed0>
#Die iterative Verarbeitung durch for kann für das Generatorobjekt durchgeführt werden.
>>> for x in ranger:
... print(x)
...
1
2
3
4
>>> def document_it(func):
... def new_function(*args,**kwargs):
... print("Running function:",func.__name__)
... print("Positional arguments:",args)
... print("Keyword arguments:",kwargs)
... result =func(*args,**kwargs)
... print("Result:",result)
... return result
... return new_function
...
>>> def add_ints(a,b):
... return a+b
...
>>> add_ints(1,2)
3
>>> cooler_add_ints =document_it(add_ints)
>>> ccler_add_ints(1,2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'ccler_add_ints' is not defined
>>> cooler_add_ints(1,2)
Running function: add_ints
Positional arguments: (1, 2)
Keyword arguments: {}
Result: 3
3
#Kurz vor der Funktion, die Sie dekorieren möchten@decorator_Im Namensformat hinzufügen.
>>> @document_it
... def add_ints(a,b):
... return a+b
...
>>> add_ints(1,2)
Running function: add_ints
Positional arguments: (1, 2)
Keyword arguments: {}
Result: 3
3
#Die Werte globaler Variablen können innerhalb der Funktion referenziert werden.
>>> animal="Z"
>>> def print_global():
... print("inside print_global:",animal)
...
>>> print("at the top level:",animal)
at the top level: Z
>>> print_global()
inside print_global: Z
#Beim Versuch, den Wert einer globalen Variablen in einer Funktion abzurufen und neu zu schreiben, tritt ein Fehler auf.
>>> def changed_and_print_global():
... print("inside change_and_print_global:",animal)
... animal="wombat"
... print("after the change:",animal)
...
>>> changed_and_print_global()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in changed_and_print_global
UnboundLocalError: local variable 'animal' referenced before assignment
#change_local()Die Funktion hat auch eine Variable namens animal, die im lokalen Namespace der Funktion vorhanden ist.
>>> animal="Z"
>>> def change_local():
... animal = "W"
... print("inside change_local:",animal,id(animal))
...
#change_local()Es ist ersichtlich, dass sich die Tiervariable in von der Tiervariablen im Programm unterscheidet.
>>> change_local()
inside change_local: W 4564475440
>>> animal
'Z'
>>> id(animal)
4564751344
#Um auf eine globale Variable zuzugreifen, müssen Sie das globale Schlüsselwort explizit verwenden.
>>> animal="Z"
>>> def change_and_print_global():
... global animal
... animal = "wombat"
... print("inside change_and_print_global:",animal)
...
>>> animal
'Z'
>>> change_and_print_global()
inside change_and_print_global: wombat
>>> animal
'wombat'
#Wenn Sie in der Funktion nicht global schreiben, verwendet Python den lokalen Namespace und die Tiervariablen sind lokal. Wenn die Funktion beendet ist, verschwinden die lokalen Variablen und verschwinden.
>>> animal="Z"
>>> def change_local():
... animal = "wombat"
... print("locals:",locals())
...
>>> animal
'Z'
#Gibt ein Wörterbuch zurück, das den Inhalt des lokalen Namespace anzeigt.
>>> change_local()
locals: {'animal': 'wombat'}
#Gibt ein Wörterbuch zurück, das den Inhalt des globalen Namespace anzeigt.
>>> print("globals:",globals())
globals: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class'_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'document_it': <function document_it at 0x110146290>, 'add_ints': 3, 'square_it': <function square_it at 0x110146440>, 'animal': 'Z', 'print_global': <function print_global at 0x1101464d0>, 'changed_and_print_global': <function changed_and_print_global at 0x1101465f0>, 'change_local': <function change_local at 0x110146950>, 'change_and_print_global': <function change_and_print_global at 0x110146830>}
>>> animal
'Z'
>>> def amazing():
... '''Dies ist eine großartige Funktion
...Wiedersehen'''
#Der Name der Funktion ist die Funktion der Systemvariablen_name__(Grundformat)
... print("Der Name dieser Funktion:",amazing.__name__)
#docstring ist eine Systemvariablenfunktion_doc__(Grundformat)
... print("docstring:",amazing.__doc__)
...
>>> amazing()
Der Name dieser Funktion: amazing
docstring:Dies ist eine großartige Funktion
Wiedersehen
#Programm erzwungene Beendigung
>>> short_list=[1,2,3]
>>> position = 5
>>> short_list[position]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
#Sie sollten versuchen, einzuschließen, wo Ausnahmen wahrscheinlich auftreten, und außer verwenden, um die Ausnahmebehandlung bereitzustellen.
#Der Code im try-Block wird ausgeführt, und wenn dort ein Fehler auftritt, wird eine Ausnahme generiert und der Code im Ausnahmeblock ausgeführt. Wenn keine Ausnahme auftritt, wird der Ausnahmeblock nicht ausgeführt.
>>> short_list=[1,2,3]
>>> position = 5
>>> try:
... short_list[position]
... except:
... print("Need a position between 0 and",len(short_list)-1,"but got",position)
...
Need a position between 0 and 2 but got 5
#Verwenden Sie außer, um alle Ausnahmen abzufangen.
#Wenn Sie die detaillierten Informationen wissen möchten, beschreiben Sie das Grundformat von Ausnahme-Ausnahmetyp als Name.
>>> short_list=[1,2,3]
>>> while True:
... value=input("Position[q to quit]?")
... if value =="q":
... break
... try:
... position=int(value)
... print(short_list[position])
... except IndexError as err:
... print("bad index:",position)
... except Exception as other:
... print("Something else broke:",other)
...
Position[q to quit]?1
2
Position[q to quit]?0
1
Position[q to quit]?2
3
Position[q to quit]?3
bad index: 3
Position[q to quit]?2
3
Position[q to quit]?two
Something else broke: invalid literal for int() with base 10: 'two'
Position[q to quit]?q
#Es liegt an der übergeordneten Klasse Exception, zu sehen, was angezeigt wird, wenn eine Ausnahme generiert wird.
>>> class OopsException(Exception):
... pass
...
>>> try:
... raise OopsException("panic")
... except OopsException as exc:
... print(exc)
...
panic
>>> if guess_me<7:
... print("too low")
... elif guess_me>7:
... print("too high")
... elif guess_me==7:
... print("just right")
...
just right
>>> while True:
... if start<guess_me:
... print("too low")
... elif start==guess_me:
... print("found it!")
... break
... elif start>guess_me:
... print("oops")
... break
... start+=1
...
too low
too low
too low
too low
too low
too low
found it!
>>> list=[3,2,1,0]
>>> for x in list:
... print(list[x])
...
0
1
2
3
>>> list=[number for number in range(10) if number%2==0]
>>> list
[0, 2, 4, 6, 8]
>>> squares={number:number*number for number in range(10)}
>>> squares
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
>>> odd= {number for number in range(10) if number%2==1}
>>> odd
{1, 3, 5, 7, 9}
>>> for thing in ("Got %s" %number for number in range(10)):
... print(thing)
...
Got 0
Got 1
Got 2
Got 3
Got 4
Got 5
Got 6
Got 7
Got 8
Got 9
>>> def good():
... print(["H","R","Hermione"])
...
>>> good()
['H', 'R', 'Hermione']
#Die Generatorfunktion gibt als Ausbeute zurück.
>>> def get_odds():
... for x in range(1,10,2):
... yield x
...
#enumerate()Mithilfe einer Funktion kann die Indexnummer (Anzahl, Reihenfolge) gleichzeitig mit den Elementen eines iterierbaren Objekts wie einer Liste (Array) in der for-Anweisung abgerufen werden. Indexnummer,Kann in der Reihenfolge der Elemente erhalten werden.
#Geben Sie den Versatz von 1 an.
>>> for count,number in enumerate(get_odds(),1):
... if count==3:
... print("The third number is",number)
... break
...
The third number is 5
>>> def test(func):
... def new_func(*args,**kwargs):
... print("start")
... result = func(*args,**kwargs)
... print("end")
... return result
... return new_func
...
>>> @test
... def greeting():
... print("Hello!")
...
>>> greeting()
start
Hello!
end
#Definition von OopseException
>>> class OopseException(Exception):
... pass
...
>>> raise OopseException()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
__main__.OopseException
>>> try:
... raise OopseException
... except OopseException:
... print("Caught an oops")
...
Caught an oops
>>> titles=["C","B","A"]
>>> plots=["D","W"]
>>> movies=dict(zip(titles,plots))
>>> movies
{'C': 'D', 'B': 'W'}
In Kapitel 4 gab es viel Rezensionsvolumen. Ich habe einen Tag gebraucht.
"Einführung in Python3 von Bill Lubanovic (veröffentlicht von O'Reilly Japan)"
Recommended Posts