Python unterstützt einen prozessorientierten Programmierstil . Wenn Sie mit der Sprache C vertraut sind , können Sie Python wie C schreiben

Python unterstützt einen objektorientierten Programmierstil . Zahlen , Strings , Funktionen , Module ... sind alles „ Objekte “.

Python unterstützt funktionale Programmierung . Tatsächlich gibt es auf der Welt nur zwei Programmiersprachen : C -ähnliche Sprache und Lisp- ähnliche Sprache . Python unterstützt auch funktionale Programmierung.

Lauf erklären

Python ist eine interpretierte Programmiersprache . Im Gegensatz zu C/C++ konvertiert es die Quellcodedatei nicht in eine ausführbare Datei, bevor es ausgeführt wird . Stattdessen liest der Python-Interpreter den Quellcode Zeile für Zeile . . Genau genommen jedoch Python ist eine „ halbkompilierte , halbinterpretierte “ Sprache . Einerseits liest der Python- Interpreter die Quellcodedatei Zeile für Zeile und konvertiert den Quellcode dann zur Interpretation in Python. Der “Bytecode„ . Führen Sie dann den Bytecode aus . Nachdem wir beispielsweise eine .py- Datei ausgeführt haben , wird eine .pyc- Datei mit demselben Namen generiert . Diese .pyc- Datei ist Python Die vom Interpreter generierte Bytecode-Datei . Wenn die .pyc- Datei bereits vorhanden ist , muss sie nicht erneut „ übersetzt “ werden , was auch die Ausführungseffizienz verbessert

Plattformübergreifend

Python wird basierend auf einem Python- Interpreter ausgeführt . Solange ein Python- Interpreter auf einem bestimmten Betriebssystem / einer bestimmten Plattform ausgeführt werden kann , kann er perfekt ausgeführt werden

Python- Quellcode . Mainstream- Windows, Linux, Mac und andere Betriebssysteme können Python sehr gut unterstützen

Skalierbar und stark

Python kann die Sprache C/C++ problemlos aufrufen . Wenn Sie der Meinung sind, dass die Logikleistung nicht den Anforderungen entspricht , können Sie diesen Teil des Moduls mit C/C++ rekonstruieren und mit Python aufrufen.

Einbettbar

Python- Code kann zur Ausführung auch einfach in C/C++ eingebettet werden

reichhaltige Bibliothek

Die Natur eines Gentlemans ist nicht anders , und er ist gut im Unwahrheiten .

Die Python- Standardbibliothek ist bereits sehr umfangreich und leistungsstark , und es gibt auch sehr große Bibliotheken von Drittanbietern . Sie kann fast Himmel und Erde erreichen und ich kann tun, was ich will~

Auswahl der Python- Version

Python hat derzeit zwei Hauptversionszweige :

Python2: Die neueste Version ist Python2.7.14

Python3: Die neueste Version ist Python3.6.2

Obwohl Python3 eine aktualisierte Version von Python2 ist , sind viele Grammatiken nicht kompatibel!

Zur Kompatibilität:

C++ ist sehr kompatibel mit der C- Sprache ( in der C-Sprache geschriebener Code kann direkt mit einem C++- Compiler kompiliert werden ), aber es bedeutet auch, dass C++ viele historische Merkmale der C-Sprache trägt .

Aber Python3 und Python2 sind an vielen Stellen inkompatibel (der in Python2 geschriebene Code kann auf dem Python3- Interpreter nicht reibungslos ausgeführt werden ).

Dies bedeutet, dass viele bereits in Python 2 geschriebene Codes nicht reibungslos auf Python 3 aktualisiert werden können .

Dies bedeutet jedoch auch, dass Python3 einige unvernünftige Stellen drastisch ändern kann , ohne die Last der Geschichte zu tragen .

Die offizielle Aussage besagt , dass Python2 bis spätestens 2020 nicht mehr aktualisiert wird .

Aber in einigen Unternehmen ist die Python -Version auch Python2.7 oder sogar Python2.6 ( zum Glück gibt es keinen großen Unterschied zwischen Python2.7 und 2.6 ).

Dieses Buch lernt hauptsächlich den Inhalt der Python3-Version

Aufbau einer Python- Entwicklungsumgebung

Windows/Linux: VSCode + Python -Plugin ( empfohlen )

Windows/Linux: PyCharm ( empfohlen )

Lernen Sie den Python- Interpreter kennen

Geben Sie einfach python in die Befehlszeile ein, um den Python- Interpreter aufzurufen . Zu diesem Zeitpunkt sehen wir eine Python- Shell .

Erstens können wir diesen Interpreter als einfachen Taschenrechner verwenden .

Natürlich können auch beliebige legale Python- Anweisungen ausgeführt werden

Drücken Sie Strg+D, um die Python-Shell zu verlassen.

Obwohl wir einige Python- Anweisungen über die Python-Shell ausführen können , müssen wir den Python- Code eher in eine Datei mit dem Suffix .py schreiben und die .py- Datei über den Python- Interpreter interpretieren , um den Code auszuführen

Schnellstart

Variablen und Zuweisungen

Variablen in Python müssen nicht deklariert werden , sie können direkt definiert werden . Der „ Typ “ der Variablen wird zum Zeitpunkt der Initialisierung bestimmt

Verwenden Sie = für Initialisierungs- und Zuweisungsvorgänge
>>> Zähler = 0

>>> Meilen = 1000,0

>>> name = 'Bob'

>>> Kilometer = 1,609 * Meilen

Operationen wie ++/-- werden in Python nicht unterstützt und können nur als geschrieben werden

>>> n += 1

dynamischer Typ

Der gleichen Variablen können unterschiedliche Wertetypen zugewiesen werden

>>> a = 100

>>> drucken a

100

>>> a = 'hehe'

>>> drucken a

hehe

Regeln für die Benennung von Variablen

Variablennamen müssen Buchstaben , Zahlen und Unterstriche sein . Sie dürfen jedoch nicht mit Zahlen beginnen ( die Regeln sind die gleichen wie in der Sprache C ).

Bei Variablennamen wird die Groß-/Kleinschreibung beachtet . case und Case sind zwei verschiedene Variablen .

Kennen Sie „ Zahlen“

In Python gibt es keine Schlüsselwörter wie „int“, „float “ usw. Tatsächlich besteht die Art der Zahl darin, zwischen Typen wie „int“ und „float“ zu unterscheiden . Verwenden Sie die integrierte Funktion „type“ , um den Typ der Variablen anzuzeigen .

>>> a = 1

>>> Typ(a)

<Typ 'int'>

>>> a = 1,0

>>> Typ(a)

<Typ 'float'>

Der Wertebereich der numerischen Variablen in Python ist nicht begrenzt ( er hängt ganz davon ab, wie viel Speicher Ihr Computer hat ) , anstatt durch 4 Bytes wie int in der C- Sprache dargestellt zu werden.

Es gibt auch einen Typ „ komplexe Zahl “ in Python . Es handelt sich um dasselbe Konzept wie „ komplexe Zahl “ in der Mathematik

>>> a = 10 + 5j

>>> drucken(a)

(10+5j)

Kennen Sie „ Zeichenfolge “

Einfache Anführungszeichen ('), doppelte Anführungszeichen (") und dreifache Anführungszeichen ('''/""") können in Python zur Darstellung von Zeichenfolgen verwendet werden . Die Unterschiede zwischen diesen drei Zeichenfolgen werden später erläutert.

>>> a = 'hehe'

>>> b = „hehe“

>>> c = '''hehe''''

Dies hat den Vorteil, dass es nicht nötig ist, lahm zu entkommen , wenn die Zeichenfolge Zeichen wie „ enthält

>>> a = 'Mein Name ist "tangzhong"'

>>> drucken a

Mein Name ist „tangzhong“

Einige unsichtbare Zeichen müssen jedoch immer noch maskiert werden , indem \ als Escapezeichen verwendet wird , beispielsweise das Zeilenumbruchzeichen \n

>>> a = 'Mein Name ist \n "tangzhong"'

>>> drucken(a)

Ich heiße

Verwenden Sie den Indexoperator [] oder den Slice-Operator [:] , um Teilzeichenfolgen abzurufen ( die Slice-Operation ist ein Intervall, bei dem vor dem Öffnen geschlossen wird ).

Die Indexierungsregeln für Zeichenfolgen lauten : Der erste Zeichenindex ist 0 und der letzte Zeichenindex ist -1 ( was als len-1 verstanden werden kann).

>>> pystr = 'hehe'

>>> pystr[0]

'H'

>>> pystr[-1]

'e'

>>> pystr[1:3]

'eh'

>>> pystr[1:-1]

'eh'

>>> pystr[1:]

'ehe'

>>> pystr[:2]

'Er'

>>> pystr[:]

'hehe'

+ für String-Verkettung , * für String-Wiederholung

>>> a = 'hehe'

>>> b = 'haha'

>>> c = a + b

>>> drucken(c)

hahahahaha

>>> d = a * 4

>>> drucken(d)

hehehehehehehe

>>> e = a * b

Traceback (letzter Anruf zuletzt):

Datei „<stdin>“, Zeile 1, in <module>

TypeError: Sequenz kann nicht mit Nicht-Int vom Typ „str“ multipliziert werden.

In Python gibt es kein Konzept wie „ Zeichentyp “ . Ein einzelnes Zeichen ist auch eine Zeichenfolge

>>> a = 'hehe'

>>> Typ(a[0])

<Typ 'str'>

Verwenden Sie die integrierte Funktion len , um die Länge einer Zeichenfolge zu ermitteln

>>> a = 'hehe'

>>> print(len(a))

4

Formatzeichenfolge , Sie können % verwenden , um das Format zu ersetzen .

>>> a = 100

>>> pystr = "a = %d"

>>> result = pystr % a

>>> drucken(Ergebnis)

a = 100

Es kann wie folgt vereinfacht werden

>>>print("a = %d" % a)

a = 100

Kennen Sie den „ Booleschen Typ “

>>> a = Wahr

>>> drucken a

WAHR

>>> print(type(a))

<Typ 'bool'>

Boolesche Variablen sind ebenfalls ein besonderer Ganzzahltyp . Bei der Arbeit mit Ganzzahlen wird True als 1 und False als 0 behandelt

Input-Output

Die Druckfunktion gibt das Ergebnis auf der Standardausgabe ( Monitor ) aus .

Die Eingabefunktion übernimmt Benutzereingaben von der Standardeingabe

>>> name = input('Namen eingeben:')

Geben Sie den Namen ein:aaa

>>> print(name)

aaa

Das von der Eingabe zurückgegebene Ergebnis ist nur eine Zeichenfolge . Wenn Sie eine Zahl benötigen , müssen Sie die int- Funktion verwenden , um die Zeichenfolge in eine Zahl umzuwandeln .

>>> num = input('Anzahl eingeben:')

Geben Sie die Zahl ein: 100

>>> print(num + 1)

Traceback (letzter Anruf zuletzt):

Datei „<stdin>“, Zeile 1, in <module>

TypeError: „str“- und „int“-Objekte können nicht verkettet werden

>>> print int(num) + 1

101

Notiz

Python verwendet # als einzeiligen Kommentar . Der Inhalt hinter # ist der Inhalt des Kommentars

a = 1,0 # definiere a

print(type(a))

Seien Sie vorsichtig , wenn Sie chinesische Kommentare verwenden ~~ Die direkte Verwendung kann beim Ausführen zu Fehlern führen (Python3 hat dieses Problem derzeit nicht , Python2 sollte darauf achten)

Der Quellcode von Python unterstützt standardmäßig nur ASCII . Wenn Sie also Chinesisch einbinden möchten , müssen Sie # - * - programming: UTF- 8 - *- ganz am Anfang der Codedatei angeben

Operator

Operatoren wie +-*/% werden in Python unterstützt . Ihr Verhalten ist das gleiche wie das der C- Sprache .

/ ist „ exakte Teilung “

>>> a = 1

>>> b = 2

>>> print(a / b)

0,5

// ist „ teilbar “. Das Ergebnis wird gerundet

>>> a = 1

>>> b = 2

>>> a // b drucken

0

Beachten Sie , dass in Python2 / die traditionelle Division ist , // die Bodendivision ist und die Semantik von Python3 völlig anders ist

** Zeigt den Leistungsvorgang an ( denken Sie daran, dass die Daten von Python keine Obergrenze haben ).

>>> a = 100

>>> b = 100

>>> a ** b drucken

1000000000000000000000000000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000000000000000000000000000000000000000000000000000000

00000000000000000

Python unterstützt auch Standardvergleichsoperatoren . > < >= <= == != Das Ergebnis des Ausdrucks dieser Operatoren ist ein boolescher Wert

>>> 2 < 4

WAHR

>>> 2 == 4

FALSCH

>>> 2 > 4

FALSCH

>>> 2 != 4

WAHR

Python unterstützt auch logische Operatoren . und oder nicht

>>> 2 < 4 und 2 == 4

FALSCH

>>> 2 > 4 oder 2 < 4

WAHR

>>> nicht 6,2 <= 6

WAHR

In Python entspricht 3 < 4 < 5 3 < 4 und 4 < 5 , was sich von den meisten anderen Programmiersprachen unterscheidet .

Es wird zwischen hoher und niedriger Priorität zwischen Operatoren unterschieden . Klammern sollten sinnvoll verwendet werden, um die Lesbarkeit des Codes zu verbessern .

Operatoren können auch zwischen Zeichenfolgen und Zeichenfolgen verwendet werden . Beispielsweise wird + zum Verbinden von Zeichenfolgen verwendet

>>> print 'haha' + 'hehe'

hahaha

Sie können == != zwischen Zeichenfolgen verwenden , um festzustellen, ob der Inhalt der Zeichenfolgen gleich ist

>>> 'haha' != 'hehe'

WAHR

Die Größe kann auch zwischen Zeichenfolgen verglichen werden . Das Ergebnis dieser Größe hängt von der „ lexikografischen Reihenfolge “ der Zeichenfolge ab

>>> 'haha' < 'hehe'

WAHR

Umfang und Lebenszyklus

In Python ändern def, class ( wir werden später darüber sprechen ) und lamda ( wir werden später darüber sprechen ) den Umfang von Variablen

if, else, elif, while, for, try/exclusive ( darüber sprechen wir später ) ändern den Umfang der Variablen nicht

für i im Bereich(0, 10):

        drucken(i)

print(i) #Auch wenn der for- Schleifen-Anweisungsblock nicht vorhanden ist , kann die Variable i immer noch auf die i- Variable zugreifen .

def func():

        x = 1

        drucken(x)

print(x) #Außerhalb des Def- Funktionsanweisungsblocks kann nicht mehr auf die Variable x zugegriffen werden

Die integrierte Funktion globals() gibt zurück, welche Variablen sich im globalen Gültigkeitsbereich befinden , und die integrierte Funktion locals() gibt zurück, welche Variablen im lokalen Gültigkeitsbereich liegen

a = 100

def Func():

x = 0

print(globals())

print(locals())

Drucken Sie 'In Gloabl'

print(globals())

print(locals())

print('In Func')

Func()

# Ausführungsergebnis

In Gloabl

{'a': 100, '__builtins__': <module '__builtin__' (integriert)>, '__file__': 'test.py',

'__package__': Keine, 'Func': <function Func at 0x7f9085d5b9b0>, '__name__': '__main__',

'__doc__': Keine}

{'a': 100, '__builtins__': <module '__builtin__' (integriert)>, '__file__': 'test.py',

'__package__': Keine, 'Func': <function Func at 0x7f9085d5b9b0>, '__name__': '__main__',

'__doc__': Keine}

In Func

{'a': 100, '__builtins__': <module '__builtin__' (integriert)>, '__file__': 'test.py',

'__package__': Keine, 'Func': <function Func at 0x7f9085d5b9b0>, '__name__': '__main__',

'__doc__': Keine}

{'x': 0}

Was den Lebenszyklus von Python -Variablen betrifft , müssen sich Programmierer keine Sorgen machen . Python bietet einen Garbage-Collection-Mechanismus, um automatisch zu erkennen, ob der Lebenszyklus einer Variablen zu Ende ist, und automatisch Speicherplatz freizugeben ( wir werden darüber sprechen). Details später ).

Python- Schlüsselwörter

Derzeit sind wir mit Schlüsselwörtern wie while, if, else, for, continue, break, return usw. in Berührung gekommen . Tatsächlich gibt es noch viele andere Schlüsselwörter

Liste / Tupel / Wörterbuch

Listen und Tupel ähneln Arrays in C.

Verwenden Sie [] für Listen und () für Tupel .

>>> alist = [1, 2, 3, 4]

>>> alist

[1, 2, 3, 4]

>>> atuple = (1, 2, 3, 4)

>>> atuple

(1, 2, 3, 4)

Listen und Tupel können eine beliebige Anzahl von Python- Objekten beliebiger Art enthalten

>>> a = [1, 'haha']

>>> a

[1, 'haha']

Sie können den Index verwenden, um auf die darin enthaltenen Elemente zuzugreifen . Der Index beginnt bei 0. Der letzte Index ist -1

>>> ein[0]

1

>>> ein[1]

'Haha'

>>> a[-1]

'Haha'

Sie können die Slice-Operation [:] verwenden , um eine Teilmenge der Liste oder des Tupels abzurufen . Diese Operation ist dieselbe wie die String-Operation

>>> ein[:]

[1, 'haha']

Der einzige Unterschied zwischen einer Liste und einem Tupel besteht darin , dass die Elemente in einer Liste geändert werden können , die Elemente in einem Tupel jedoch nicht

>>> a = [1, 2, 3, 4]

>>> a[0] = 100

>>> a

[100, 2, 3, 4]

>>> a = (1, 2, 3, 4)

>>> a[0] = 100

Traceback (letzter Anruf zuletzt):

Datei „<stdin>“, Zeile 1, in <module>

TypeError: Das „Tuple“-Objekt unterstützt keine Elementzuweisung

>>>

Ein Wörterbuch ist ein Mapping-Datentyp in Python . Es speichert Schlüssel-Wert-Paare (Schlüssel-Wert).

Als Schlüssel kann nahezu jede Art von Python- Objekt verwendet werden , am häufigsten werden jedoch Zahlen und Zeichenfolgen verwendet .

Verwenden Sie {} , um ein Wörterbuch darzustellen .

>>> a = { 'ip' : '127.0.0.1'} #Wörterbuch erstellen

>>> a['ip'] #Holen Sie sich die Elemente im Wörterbuch

'127.0.0.1'

>>> a['port'] = 80 #Fügen Sie ein neues Schlüssel-Wert-Paar ein

>>> a

{'ip': '127.0.0.1', 'port': 80}

„ Zitat “ verstehen

In Python können Sie die integrierte Funktion id verwenden , um die „ Adresse “ der Variablen anzuzeigen

>>> a = 100

>>> id(a)

24187568

>>> a = 200

>>> id(a)

24191144

>>> b = a

>>> id(b)

24191144

>>> b = 300

>>> id(b)

25094648

Die Neuzuweisung von a zu 200 entspricht dem Erstellen eines neuen Objekts wie 200 und dem anschließenden erneuten Binden des Variablennamens a an das Objekt 200 .

Das Zuweisen von a zu b entspricht tatsächlich dem Erstellen einer Variablen namens b und dem Binden des Namens b an das Objekt 200 .

Ändern Sie den Wert von b erneut , und Sie können sehen, dass tatsächlich ein Objekt wie 300 erstellt wird und b an das Objekt von 300 gebunden ist .

Variablennamen wie „a“ und „b“ sind eigentlich nur ein Alias eines Objekts oder werden als „ Referenz “ einer Variablen bezeichnet

Codeblöcke und Einrückung

Python verwendet Einrückungen zur Darstellung von Codeblöcken . Aus grammatikalischer Sicht entspricht dies der natürlichen Angabe des Codestils .

Einzigartig in Python ist die Verwendung von Einrückungen anstelle von { } , wodurch ein parteipolitischer Kampf vermieden wird ~

Es gibt keine geschweiften Klammern . Daher muss nicht darüber nachgedacht werden, wo die geschweiften Klammern platziert werden

if -Anweisung

Die Standardsyntax der if- bedingten Anweisung lautet wie folgt .

Wenn der Wert des Ausdrucks ungleich Null oder Boolean True ist, wird do_something ausgeführt , andernfalls wird die nächste Sprunganweisung ausgeführt .

wenn Ausdruck1:

        do_something1

elif Ausdruck2:

        do_something2

anders:

        do_something3

Python unterstützt keine Anweisungen wie „switch/case“ . Es besteht keine Notwendigkeit, sie zu unterstützen . Tatsächlich ist die switch/case- Syntax nicht elegant .

Wenn zu viele bedingte Verzweigungen vorhanden sind , können Sie die „ tabellengesteuerte “ Methode zum Organisieren des Codes in Betracht ziehen . Weitere Informationen finden Sie in Kapitel 18 von << Code-Enzyklopädie >> .

while- Schleife

Die While -Schleifenanweisung ähnelt der Syntax der If -Anweisung . Solange der Wert des Ausdrucks nicht 0 oder True ist, wird do_something in einer Schleife ausgeführt

während Ausdruck:

        etwas tun

# Schleife, um den Druck dreimal auszuführen

Zähler = 0

während Zähler < 3:

        print 'loop %d' % counter

        Zähler += 1

for -Schleife

Die for- Schleife in Python unterscheidet sich von der herkömmlichen for- Schleife .

Die for- Schleife empfängt ein iterierbares Objekt ( Sequenz oder Iterator ) als Parameter und iteriert jeweils ein Element

#Durchlaufen Sie jedes Zeichen in der Zeichenfolge

a = 'hehe'

für c in a:

Drucken c

# Ausführungsergebnis

H

e

H

e

#Durchlaufen Sie jedes Element in der Liste

a = [1, 2, 3, 4]

für Artikel in einem:

Artikel drucken

# Ausführungsergebnis

1z

2

3

4

#Durchlaufen Sie alle Schlüsselwerte im Wörterbuch

a = {'ip':'192.168.1.1', 'port':80}

für Schlüssel in a:

Druckschlüssel, ein[Schlüssel]

# Ausführungsergebnis

IP 127.0.0.1

Port 80

Der integrierte Funktionsbereich kann eine Zahlenliste generieren , was für das Durchlaufen der For-Schleife praktisch ist

# for- Schleife führt drei Ausdrucke aus

für i im Bereich(0, 3):

print 'loop %d' % i

# Ausführungsergebnis

Schleife 0

Schleife 1

Schleife 2

Die Bereichsfunktion verfügt tatsächlich über drei Parameter . Die ersten beiden Parameter stellen ein Intervall dar, das vor dem Öffnen geschlossen und dann geöffnet wird . Der dritte Parameter stellt den Schritt dar, die Schrittgröße jeder Iteration

# Durchlaufe die geraden Zahlen im Intervall [0, 100)

für i im Bereich(0, 100, 2):

Drucken Sie i

Pause und Weiter

Verwenden Sie die break- Anweisung, um aus der aktuellen Schleife auszubrechen

#Finden Sie das erste Vielfache von 3 in [0, 100)

für i im Bereich(0, 100):

wenn i % 3 == 0:

brechen

Verwenden Sie die continue- Anweisung , um zum Anfang der Schleife zurückzukehren und die Schleifenbedingung zu bestimmen .

Wenn die Schleifenbedingung erfüllt ist , wird die nächste Schleife ausgeführt .

pass- Anweisung

Manchmal ist es notwendig, das Konzept einer leeren Anweisung zu verwenden , die nichts bewirkt . Da es kein {} gibt, ist eine spezielle Anweisung erforderlich, um den Platz zu belegen , sonst wird es verwirrend.

wenn x % 2 == 0:

passieren

anders:

etwas tun

Listenverständnis

Es ist Zeit, das Wunder erneut zu erleben . Die leistungsstarke und prägnante Python-Syntax , die erste Show

Verwenden Sie eine for- Schleife, um die resultierenden Werte in eine Liste einzufügen

# Erzeugen Sie eine Folge von Zahlenquadraten in [0, 4)

quadriert = [x ** 2 für x im Bereich(4)]

im Quadrat drucken

# Ausführungsergebnis

[0, 1, 4, 9]

Dieser Vorgang kann auch mit der if- Anweisung verwendet werden

#Erhalten Sie alle ungeraden Zahlen im Intervall [0, 8 )

evens = [x für x in range(0, 8) if x % 2 == 1]

Abende drucken

Funktion

Einige Codes , die wiederverwendet werden können, können extrahiert und in eine Funktion eingefügt werden .

Python verwendet def , um eine Funktion zu definieren . Verwenden Sie return , um das Ergebnis zurückzugeben .

def Add(x, y):

        gib x + y zurück

Python verwendet () , um Funktionen aufzurufen

print(Add(1, 2))

Verstehen Sie „ formale Parameter “ und „ aktuelle Parameter “: Formale Parameter entsprechen dem Konzept der „ Unbekannten “ in der Mathematik . Tatsächliche Parameter dienen zur Bestimmung spezifischer Werte für Unbekannte .

In Python gibt es kein Konzept des „ Überladens “ . Bei Funktionen mit demselben Namen überschreibt letzteres das erstere

def Func():

        print('aaaa')

def Func():

        print('bbbb')

Func()

# Ausführungsergebnis

bbb

Python unterstützt Standardparameter . Funktionsparameter können Standardwerte haben

def Func(debug=True):

        wenn debug:

                print('im Debug-Modus')

        „Fertig“ drucken

Func()

Func(False)

Syntax zum Entpacken (Entpacken) von Python : Die Funktion gibt mehrere Werte zurück

def GetPoint():

        100, 200 zurückgeben

x, y = GetPoint()

Wenn ich nur auf y achte und nicht auf x achten möchte , kann ich _ als Platzhalter verwenden

_, y = GetPoint()

Funktionen sind ebenfalls „ Objekte “. Eine Funktion, wie eine Zahl oder eine Zeichenfolge , kann einen „ Alias “ definieren , um auf sie zu verweisen .

def Func():

                print('aaa')

func = Func

func()

Drucktyp (Funktion)

# Ausführungsergebnis

aaa

<Typ 'Funktion'>

Da eine Funktion ein Objekt ist , kann sie auch als Parameter und Rückgabewert einer anderen Funktion verwendet werden . Auf die Details gehen wir später ein .

Dateioperation

Öffnen Sie eine Datei mit der integrierten Funktion „Öffnen“ .

handle = open(file_name, access_mode='r')

Dateiname ist der Name der Datei . Es kann ein absoluter oder ein relativer Pfad sein

handle = open('text.txt', access_mode='r')

# oder

handle = open('/home/tangzhong/text.txt', access_mode='r')

access_mode ist die Möglichkeit, die Datei zu öffnen . Die Optionen sind wie folgt

'r': schreibgeschützt

'w': Nur schreiben

'a': Zum Schreiben anhängen

't': Als Text lesen und schreiben

'b': Lesen und Schreiben im Binärmodus

handle ist ein Dateihandle , bei dem es sich um ein iterierbares Objekt handelt . Sie können die for- Schleife direkt verwenden , um den Dateiinhalt Zeile für Zeile zu lesen .

für die Zeile im Handle :

        Druckzeile

Nachdem das Handle verwendet wurde , muss es geschlossen werden . Andernfalls kommt es zu einem Ressourcenverlust ( die Anzahl der Handles, die von einem Prozess geöffnet werden können, ist begrenzt ).

handle.close()

Ein vollständiges Beispiel : Zählen der Worthäufigkeit im Text

In einer Textdatei ist jede Zeile ein Wort . Es kann Wiederholungen geben . Zählen Sie, wie oft jedes Wort vorkommt .

Beispieldatei :

aaa

bbb

ccc

aaa

bb

C

aaa

Der Code ist wie folgt implementiert :

handle = open('text.txt', mode='r')

Wörter = {}

für Wort im Griff:

        Wort = Wort[:-1] # Entfernen Sie das \n am Ende

        wenn Wort nicht in Wörtern: # Verwenden Sie das Schlüsselwort in, um zu bestimmen, ob das Wort der Schlüssel des Wörterbuchs ist.

                Wörter[Wort] = 1

        anders:

                Wörter[Wort] += 1;

handle.close()

Wörter drucken

Modul

Wenn wir eine große Menge Code in einem Projekt haben , müssen wir den Code in mehreren verschiedenen .py- Dateien ablegen

Der Code in anderen .py- Dateien kann über das Schlüsselwort import referenziert werden .

Die importierte Codedatei wird als „ Modul “ bezeichnet .

Die importierte Datei , entfernen Sie das Suffix .py , ist der Modulname

Zum Beispiel :

# add.py -Inhalt

def Add(x, y):

gib x + y zurück

# test.py- Inhalt , Modulnamen direkt importieren

Import hinzufügen

print add.Add(1, 2)

# test2.py- Inhalt , nur der Name wird im Import-Add- Modul hinzugefügt .

aus hinzufügen importieren Hinzufügen

drucken Add(1, 2)

#test3.py- Inhalt , importieren Sie den Modulnamen und geben Sie dem Modulnamen einen Alias .

Import hinzufügen

a = hinzufügen

print a.Add(1, 2)

Die Reihenfolge, in der Module durchsucht werden, besteht darin, zuerst das aktuelle Verzeichnis und dann das Python- Installationsverzeichnis zu finden .

Importsystem

print sys.path #Drucken Sie den Pfad der Modulsuche aus

Utility-Funktion

Zuvor sind wir mit einigen sehr nützlichen integrierten Funktionen in Berührung gekommen . Hier fassen wir sie kurz zusammen

spezielle Kennung

Python verwendet Unterstriche (_) als Präfixe und Suffixe für Variablen, um spezielle Bezeichner zu kennzeichnen .

_xxx stellt eine „ private Variable “ dar, die nicht mit from module import * importiert werden kann

# add.py

def _Add(x, y):

        gib x + y zurück

# test.py

aus Import hinzufügen *

_Add(1, 2)

# Ausführungsergebnis

Traceback (letzter Anruf zuletzt):

        Datei „test.py“, Zeile 3, in <module>

          _Add(1, 2)

NameError: Name „_Add“ ist nicht definiert

_xxx_ ( ein Unterstrich davor und danach ), __xxx__ ( zwei Unterstriche davor und danach ) sind im Allgemeinen systemdefinierte Namen . Wir sollten diesen Stil bei der Benennung von Variablen vermeiden , um Konflikte mit Systemvariablen zu vermeiden .

Dokumentzeichenfolge

Das Schreiben von Kommentaren ist eine große Hilfe, um die Lesbarkeit des Programms zu verbessern .

Zuvor haben wir # eingeführt , um einzeilige Kommentare darzustellen .

Für mehrzeilige Kommentare können wir am Anfang der Funktion / Klasse dreifache Anführungszeichen ('''/""") verwenden . Dieses Ding wird auch Dokumentationszeichenfolge genannt

def Add(x, y):

        '''

                Definieren Sie die Funktion zum Addieren von zwei Zahlen

        '''

        return x + y
Verwenden Sie das doc- Attribut des Objekts, um dieses Hilfedokument anzuzeigen ( vergessen Sie nicht , dass Funktionen auch Objekte sind ) .

drucken(Add.__doc__)

# Ausführungsergebnis

Definieren Sie die Funktion zum Addieren von zwei Num

Oder nutzen Sie die integrierte Funktion help, um den gleichen Effekt zu erzielen

Hilfe(Hinzufügen)

# Ausführungsergebnis

Addiere(x, y)

Definieren Sie die Funktion zum Addieren von zwei Num

Der Dokumentationsstring muss am Anfang der Funktion / Klasse stehen , andernfalls kann er nicht über __doc__ oder help aufgerufen werden

Moduldokumentation

Nicht nur eine Funktion / Klasse kann einen Dokumentstring haben , sondern auch ein Modul

# add.py

'''

Definieren Sie eine Funktion zum Hinzufügen

'''

def Add(x, y):

        gib x + y zurück

# test.py

Import hinzufügen

print(add.__doc__)

# Ausführungsergebnis

Definieren Sie eine Funktion zum Hinzufügen

Unix- Startzeile

Für Unix -ähnliche Systeme wie Linux oder Mac können Sie der Python- Codedatei eine Startzeile hinzufügen , um den Ausführungsmodus des Programms anzugeben

#!/usr/bin/python

print('haha')

Speichern Sie den obigen Code als test.py. Fügen Sie dieser Datei ausführbare Berechtigungen hinzu : chmod +x test.py

Dann kann es von ./test.py ausgeführt werden .

Eine Einführung in Python

Einführung und Funktionen von Python

Python unterstützt mehrere Programmierstile

Lauf erklären

Plattformübergreifend

Skalierbar und stark

Einbettbar

reichhaltige Bibliothek

Auswahl der Python- Version

Aufbau einer Python- Entwicklungsumgebung

Lernen Sie den Python- Interpreter kennen

Schnellstart

Variablen und Zuweisungen

dynamischer Typ

Regeln für die Benennung von Variablen

Kennen Sie „ Zahlen“

Kennen Sie „ Zeichenfolge “

Kennen Sie den „ Booleschen Typ “

Input-Output

Notiz

Operator

Umfang und Lebenszyklus

Python- Schlüsselwörter

Liste / Tupel / Wörterbuch

„ Zitat “ verstehen

Codeblöcke und Einrückung

if -Anweisung

while- Schleife

for -Schleife

Pause und Weiter

pass- Anweisung

Listenverständnis

Funktion

Dateioperation

Modul

Utility-Funktion

spezielle Kennung

Dokumentzeichenfolge

Moduldokumentation

Unix- Startzeile

Ich denke du magst