Einzug
import os
def function():
#Einzug ist PEP8(*)Entsprechend 4 halbbreiten Räumen
print('Hello world')
(*)PEP8(Python Enhancement Proposal) https://www.python.org/dev/peps/pep-0008/ Indentation Use 4 spaces per indentation level.
Variable Aussage
#Numerischer Wert
num = 1
#String
name = 'Tanaka'
#aufführen
list = [1, 2, 3, 4, 5]
#Explizite Typdeklaration
num: int = 1
name: str = 'Tanaka'
#Typkonvertierung
old_num = '1' #Zeichenfolgentyp
new_num = int(num) #In Integer-Typ konvertieren und neu_Zuweisen zu num
Kommentar
#Zeile für Zeile Kommentar
"""
Mehrere Zeilen
sammeln
Kommentar
"""
Docstring
def test_function(param1, param2):
"""Test, der zwei Argumente hinzufügt und zurückgibt_function
Args:
param1(int):Erklärung des ersten Arguments
param2(int):Erklärung des zweiten Arguments
Returns:
Gibt das Additionsergebnis von param1 und param2 zurück
"""
return param1 + param2
Numerische Berechnung
#Addition von ganzen Zahlen
>>> 1 + 1
2
#Ganzzahlige Subtraktion
>>> 2 - 1
1
#Ganzzahlen multiplizieren
>>> 5 * 6
30
#Teilen einer ganzen Zahl * Das Teilen gibt immer einen Gleitkomma zurück
>>> 6 / 5
1.2
#Die Bewertungsreihenfolge entspricht der Mathematik
>>> 50 - 5 * 6
20
>>> (50 - 5 * 6) / 4
5.0
#Standard Division gibt float zurück
>>> 17 / 3
5.666666666666667
# 「//": Rundungsdivision rundet nach dem Dezimalpunkt ab
>>> 17 // 3
5
# 「%": Gibt den Rest zurück (Rest der Teilung)
>>> 17 % 3
2
>>>
#5 im Quadrat
>>> 5 ** 2
25
#2 bis zur 7. Potenz
>>> 2 ** 7
128
#Rund nach dem Dezimalpunkt(Nach dem Dezimalpunkt um 2 Stellen runden)
>>> pie = 3.1415926535
>>> pie
3.1415926535
>>> round(pie, 2)
3.14
String
#Umgeben Sie mit einem einfachen Anführungszeichen
>>> print('Hello world')
Hello world
#Mit doppelten Anführungszeichen umgeben
>>> print("Hello world")
Hello world
#Als Zeichenkette "'Beim Benutzen(Mit doppelten Anführungszeichen umgeben)
>>> print("I'm from Japan.")
I'm from Japan.
'
#Als Zeichenkette "'Beim Benutzen(Flucht)
>>> print('I\'m from Japan.')
I'm from Japan.
'
#Beginnen Sie mit einer neuen Zeile(\n)
>>> print('Hello! \nHow are you doing?')
Hello!
How are you doing?
#Verhindern Sie die Interpretation als Sonderzeichen(「\Da der Teil "n" als Zeilenumbruch interpretiert wird, wird er als Rohdaten verarbeitet.)
>>> print(r'C:\name\name')
C:\name\name
#Mehrzeiliger Ausgang(「"""Umgeben von)
>>> print("""
... line1
... line2
... line3
... """)
line1
line2
line3
#Nicht kaputtmachen(「\Beschreiben)
>>> print("""\
... line1
... line2
... line3\
... """)
line1
line2
line3
#Zeichen wiederholen
>>> print('Yes.' * 3 + '!!!')
Yes.Yes.Yes.!!!
#String-Verkettung(Literale sind "+Ist OK ohne)
>>> print('Py''thon')
Python
#String-Verkettung(Variable+Das wörtliche ist "+"Ist notwendig)
>>> prefix = 'Py'
>>> print(prefix + 'thon')
Python
String-Index/Schneiden
#Variablendefinition
>>> word = 'Python'
#Holen Sie sich das Zeichen an die 0. Position des Wortes
>>> print(word[0])
P
#Bringen Sie den Charakter an die 5. Stelle des Wortes
>>> print(word[5])
n
#Holen Sie sich das Zeichen an die erste Position am Ende des Wortes(Von Anfang an 0,1,2 ... vom Ende-1,-2,-3 ...)
>>> print(word[-1])
n
#Holen Sie sich das Zeichen an der dritten Position vom Ende des Wortes(Von Anfang an 0,1,2 ... vom Ende-1,-2,-3 ...)
>>> print(word[-3])
h
#Wort 0(Einschließlich 0)Ab 2(2 ist nicht enthalten)Holen Sie sich Zeichen auf die Position von
>>> print(word[0:2])
Py
#Wort 2(2 einschließlich)Ab 5(5 nicht enthalten)Holen Sie sich Zeichen auf die Position von
>>> print(word[2:5])
tho
#2 vom Wortanfang(2 einschließlich)Holen Sie sich Zeichen auf die Position von
>>> print(word[:2])
Py
#Wort 2(2 einschließlich)Holen Sie sich den Charakter von der Position bis zum Ende
>>> print(word[2:])
thon
#Holen Sie sich die Zeichen vom Anfang bis zum Ende des Wortes
>>> print(word[:])
Python
Methode in Bezug auf Zeichen
#String s definieren
>>> s = 'Hello Tom. How are you doing.'
>>> print(s)
Hello Tom. How are you doing.
#Überprüfen Sie, ob die Zeichenfolge eine bestimmte Zeichenfolge enthält
>>> print(s.startswith('Hello'))
True
>>> print(s.startswith('Tom'))
False
#Bestimmte Zeichen in der Zeichenfolge(oder Zeichenkette)Überprüfen Sie die Position wo(Von Anfang an)
>>> print(s.find('o'))
4
#Bestimmte Zeichen in der Zeichenfolge(oder Zeichenkette)Überprüfen Sie die Position wo(Vom Ende)
>>> print(s.rfind('o'))
24
#Bestimmte Zeichen in der Zeichenfolge enthalten(oder Zeichenkette)Überprüfen Sie die Anzahl der
>>> print(s.count('o'))
5
#Konvertieren Sie den ersten Buchstaben der Zeichenfolge in Großbuchstaben
>>> print(s.capitalize())
Hello tom. how are you doing.
#Konvertieren Sie den ersten Buchstaben jedes Wortes in der Zeichenfolge in Großbuchstaben
>>> print(s.title())
Hello Tom. How Are You Doing.
#Konvertieren Sie Zeichenfolgen in Großbuchstaben
>>> print(s.upper())
HELLO TOM. HOW ARE YOU DOING.
#String in niedriger konvertieren
>>> print(s.lower())
hello tom. how are you doing.
#Ersetzen Sie eine bestimmte Zeichenfolge
>>> print(s.replace('Tom', 'Bob'))
Hello Bob. How are you doing.
Bedingte Verzweigung(if-Anweisung)
wenn bedingter Ausdruck 1:
Verarbeitung, die ausgeführt werden soll, wenn der bedingte Ausdruck 1 wahr ist
elif bedingter Ausdruck 2:
Verarbeitung, die ausgeführt werden soll, wenn der bedingte Ausdruck 1 falsch und der bedingte Ausdruck 2 wahr ist
else:
Verarbeitung, die ausgeführt werden soll, wenn alle bedingten Ausdrücke falsch sind
--if wird in der Reihenfolge von oben ausgewertet und die Verarbeitung der ersten true-Klausel ausgeführt. Wenn der bedingte Ausdruck 1 wahr ist, wird die Verarbeitung des bedingten Ausdrucks 2 nicht ausgeführt, selbst wenn das Ergebnis des bedingten Ausdrucks 2 wahr ist.
Ein Wert, der im bedingten Ausdruck falsch ist
- None
- False
-Numerischer Typ Null, 0, 0.0 、 0j(Komplexe Zahl)
-Leeren Sie Objekte von Containerobjekten wie Zeichenfolgen, Listen, Wörterbücher, Mengen usw.
-Methode__bool__()Gibt False zurück
-Methode__bool__()Ist nicht definiert und die Methode__len__()Objekt, das 0 zurückgibt
Numerischer Vergleich
#Richtig, wenn gleichwertig
>>> 1 == 1
True
#Richtig, wenn nicht gleichwertig
>>> 1 != 1
False
#Richtig, wenn die linke Seite groß ist
>>> 1 > 0
True
#Richtig, wenn die rechte Seite groß ist
>>> 1 < 0
False
#True, wenn die linke Seite groß oder gleichwertig ist
>>> 1 >= 0
True
#Richtig, wenn die rechte Seite groß oder gleichwertig ist
>>> 1 <= 0
False
# x < y and y <Entspricht z
>>> x, y, z = 1, 2, 3
>>> x < y < z
True
Objektvergleich
>>> x = 'red'
>>> y = 'green'
#Richtig, wenn gleichwertig
>>> x == y
False
#Richtig, wenn nicht gleichwertig
>>> x != y
True
#True für dasselbe Objekt
>>> x is None
False
#True, wenn nicht dasselbe Objekt
>>> x is not None
True
>>> items = ['pen', 'note', 'book']
#In Artikeln'book'True wenn enthalten ist
>>> 'book' in items
True
#In Artikeln'note'True, wenn nicht enthalten
>>> 'note' not in items
False
zur Aussage
>>> items = [1, 2, 3]
>>> for i in items:
... print(f'Der Wert der Variablen i ist{i}')
...
Der Wert der Variablen i ist 1
Der Wert der Variablen i ist 2
Der Wert der Variablen i ist 3
# range()Funktion
>>> for i in range(3):
... print(f'{i}Zweiter Prozess')
...
0. Prozess
Erster Prozess
Zweiter Prozess
# enumerate()Funktion
>>> chars = 'word'
>>> for count, char in enumerate(chars):
... print(f'{count}Das zweite Zeichen ist{char}')
...
Das 0. Zeichen ist w
Der erste Buchstabe ist o
Das zweite Zeichen ist r
Das dritte Zeichen ist d
#Wörterbuchschleife(items()Methode)
>>> sports = {'baseball': 9, 'soccer': 11, 'tennis': 2}
>>> for k, v in sports.items():
... print(k, v)
...
baseball 9
soccer 11
tennis 2
#Gleichzeitige Schleife zweier Sequenzen(zip()Funktion)
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue' ]
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
Verhalten der else-Klausel der for-Anweisung
>>> nums = [2, 4, 6, 8]
>>> for n in nums:
... if n % 2 == 1:
... break
... else:
... print('Es gibt keine ungeraden')
...
Es gibt keine ungeraden
try-Anweisung
try:
Verarbeitung, die eine Ausnahme verursachen kann
mit Ausnahme der Ausnahmeklasse, die Sie abfangen möchten:
Was passiert, wenn die Ausnahme auftritt, die Sie abfangen möchten?
else:
Verarbeitung, die nur ausgeführt wird, wenn keine Ausnahme auftritt
finally:
Der Prozess, den Sie ausführen möchten, unabhängig davon, ob eine Ausnahme auftritt
--try-Klausel: Beschreiben Sie die Verarbeitung, die eine Ausnahme zwischen den try-exception-Klauseln verursachen kann.
try-außer Klausel
#Greifen Sie auf ein Element zu, das kein Array enthält, lösen Sie eine Ausnahme aus und fangen Sie es in der Except-Klausel ab.
>>> l = [1, 2, 3]
>>> i = 5
>>> try:
... l[i]
... except:
... print('It is no problem')
...
It is no problem
#Fangen Sie eine bestimmte Ausnahme in der Ausnahmeklausel ab
>>> try:
... l[i]
... except IndexError:
... print('You got an IndexError')
...
You got an IndexError
#Geben Sie die Ursache der Ausnahme aus
>>> try:
... l[i]
... except IndexError as ex:
... print('You got an IndexError : {}'.format(ex))
...
You got an IndexError : list index out of range
#Fange alle Ausnahmen ab
>>> try:
... () + l
... except IndexError:
... print('You got an IndexError')
... except BaseException as ex:
... print('You got an Exception : {}'.format(ex))
...
You got an Exception : can only concatenate tuple (not "list") to tuple
Ausnahmeklassenhierarchie https://docs.python.org/ja/3/library/exceptions.html#exception-hierarchy
--else-Klausel: Beschreiben Sie die Verarbeitung, die ausgeführt werden soll, wenn in der else-Klausel keine Ausnahme auftritt.
sonst Klausel
#Beschreiben Sie die Verarbeitung, die ausgeführt werden soll, wenn in der else-Klausel keine Ausnahme auftritt.
>>> try:
... 1 + 1
... except BaseException:
... print('You got an Exception.')
... else:
... print('There are no Exceptions!')
...
2
There are no Exceptions!
--finally-Klausel: Beschreiben Sie in der finally-Klausel den auszuführenden Prozess, unabhängig davon, ob eine Ausnahme auftritt oder nicht.
Endlich Klausel
#Beschreiben Sie in der finally-Klausel den auszuführenden Prozess, unabhängig davon, ob eine Ausnahme auftritt oder nicht.
>>> try:
... raise NameError('It is a NameError!!!')
... except NameError as ne:
... print(ne)
... finally:
... print('NameError Program finished!!!')
...
It is a NameError!!!
NameError Program finished!!!
Aussage erheben
#Sie können eine Ausnahme erneut auslösen, indem Sie einfach Raise erwähnen. (Wenn Sie wissen möchten, wie eine Ausnahme gesendet wird, diese jedoch nicht sofort verarbeitet wird)
>>> try:
... raise NameError('It is a NameError!!!')
... except NameError:
... print('Name Error.')
... raise
...
Name Error.
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
NameError: It is a NameError!!!
Listentyp
#Definition der Liste "l"
>>> l = [1, 2, 3, 4, 5]
>>> print(l)
[1, 2, 3, 4, 5]
#Holen Sie sich ein bestimmtes Element der Liste
>>> print(l[0])
1
>>> print(l[-1])
5
#Dritter vom Anfang der Liste(0., 1., 2 ..)Bis zum Element von(Enthält nicht die dritte)Erhalten
>>> print(l[:3])
[1, 2, 3]
#Dritter vom Ende der Liste(3 beinhaltet)Vom Element zum Ende gelangen
>>> print(l[-3:])
[3, 4, 5]
#Holen Sie sich alle Elemente der Liste
>>> print(l[:])
[1, 2, 3, 4, 5]
#Beitrittsliste
>>> l2 = [6, 7, 8, 9, 10]
>>> print(l + l2)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#Listenelemente ändern
>>> l[2] = 300
>>> print(l)
[1, 2, 300, 4, 5]
Liste bearbeiten
#Listenelemente hinzufügen(Am Ende hinzufügen)
>>> l.append(600)
>>> print(l)
[1, 2, 300, 4, 5, 600]
#Listenelemente hinzufügen(Am Anfang hinzufügen: Fügen Sie "0" zum 0. Index hinzu)
>>> l.insert(0, 0)
>>> print(l)
[0, 1, 2, 300, 4, 5, 600]
#Listenelemente abrufen(Holen Sie sich das letzte Element, verschwinden Sie aus der Liste)
>>> l.pop()
600
>>> print(l)
[0, 1, 2, 300, 4, 5]
#Listenelement abrufen (0. Element löschen, aus Liste verschwinden)
>>> l.pop(0)
0
>>> print(l)
[1, 2, 300, 4, 5]
#Listenelemente löschen(Löschen Sie das zweite Element)
>>> del l[2]
>>> print(l)
[1, 2, 4, 5]
#Liste löschen (gesamte Liste löschen)
>>> del l
>>> print(l)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'l' is not defined
#Löschen Sie alle Elemente der Liste (löschen Sie die Liste nicht)
>>> print(l)
[['A', 'B', 'C'], [1, 2, 3]]
>>> l.clear()
>>> print(l)
[]
#Löscht Elemente, die dem angegebenen Wert in der Liste entsprechen
>>> l = [0, 1, 2, 3, 3, 3, 4, 5]
>>> l.remove(3)
>>> print(l)
[0, 1, 2, 3, 3, 4, 5]
#Löschen Sie das Element, das dem angegebenen Wert in der Liste entspricht (ein Fehler tritt auf, wenn kein übereinstimmendes Element vorhanden ist).
>>> l.remove(3)
>>> l.remove(3)
>>> l.remove(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> print(l)
[0, 1, 2, 4, 5]
#Holen Sie sich die Anzahl der Elemente in der Liste
>>> print(len(l))
5
#Verschachtelungslisten (Erstellen von Listen mit Listen als Elementen)
>>> l1 = ['A', 'B', 'C']
>>> l2 = [1, 2, 3]
>>> l = [l1, l2]
>>> print(l)
[['A', 'B', 'C'], [1, 2, 3]]
#Index mit dem angegebenen Wert abgleichen (Fehler, wenn Element nicht vorhanden ist)
>>> l = [1, 2, 3, 4, 5]
>>> l.index(3)
2
>>> l.index(6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 6 is not in list
#Ermitteln Sie die Anzahl der Elemente, die dem angegebenen Wert entsprechen
>>> l.count(4)
1
#Listenelemente in umgekehrter Reihenfolge ändern
>>> print(l)
[1, 2, 3, 4, 5]
>>> l.reverse()
>>> print(l)
[5, 4, 3, 2, 1]
#Sortieren Sie die Elemente der Liste in aufsteigender Reihenfolge
>>> l = [4, 5, 2, 1, 3]
>>> print(l)
[4, 5, 2, 1, 3]
>>> l.sort(key=None, reverse=False)
>>> print(l)
[1, 2, 3, 4, 5]
#Sortieren Sie die Elemente der Liste in absteigender Reihenfolge
>>> l = [4, 5, 2, 1, 3]
>>> print(l)
[4, 5, 2, 1, 3]
>>> l.sort(key=None, reverse=True)
>>> print(l)
[5, 4, 3, 2, 1]
#In einer durch bestimmte Zeichen getrennten Liste speichern
>>> s = 'Hi, Tom. How are you doing?'
>>> print(s.split(' '))
['Hi,', 'Tom.', 'How', 'are', 'you', 'doing?']
>>> print(s.split('.'))
['Hi, Tom', ' How are you doing?']
Taple-Typ
#Tupple-Erklärung(Definiert als Tapple mit oder ohne Klammern)
>>> t = (1, 2, 3, 4, 5)
>>> print(t)
(1, 2, 3, 4, 5)
>>> t2 = 1, 2, 3
>>> print(t2)
(1, 2, 3)
#Tapple-Erklärung (am Ende der Definition "",Beachten Sie, dass es als Taple definiert ist, falls vorhanden
#Auch wenn es nur ein Element gibt, ",Es ist notwendig zu beschreiben.
>>> t3 = 1,
>>> t3
(1,)
>>> type(t3)
<class 'tuple'>
#Im Gegensatz zu Listen können Taples ihre Werte nicht ändern
>>> t[0] = 100
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
#Speichern Sie die Liste in einem Taple und ändern Sie den Wert der Liste
>>> t = ([1, 2, 3], [4, 5, 6])
>>> t
([1, 2, 3], [4, 5, 6])
>>> t[0][0]
1
>>> t[0][0] = 100
>>> t
([100, 2, 3], [4, 5, 6])
Taple auspacken
#Weisen Sie den Wert des Taples einer Variablen zu
>>> t = (1, 2, 3)
>>> t
(1, 2, 3)
>>> x, y, z = t
>>> print(x, y, z)
1 2 3
#Wirksam beim Austausch der Werte bestimmter Variablen usw.
>>> X = 100
>>> Y = 200
>>> print(X, Y)
100 200
>>> X, Y = Y, X
>>> print(X, Y)
200 100
Wörterbuchtyp (Wörterbuchtyp)
#Deklaration des Wörterbuchtyps (Wörterbuchtyp) ①
>>> d = {'x': 10, 'y': 20, 'z': 30}
>>> d
{'x': 10, 'y': 20, 'z': 30}
#Deklaration des Wörterbuchtyps (Wörterbuchtyp) ②
>>> dict(a=100, b=200, c=300)
{'a': 100, 'b': 200, 'c': 300}
#Abrufen des Werts eines bestimmten Schlüssels vom Wörterbuchtyp (Wörterbuchtyp)
>>> d['y']
20
#Hinzufügen von Schlüsseln und Werten zum Wörterbuchtyp (Wörterbuchtyp)
>>> d['a'] = 40
>>> d
{'x': 10, 'y': 20, 'z': 30, 'a': 40}
#Löschen bestimmter Schlüssel des Wörterbuchtyps (Wörterbuchtyp)
>>> del d['a']
>>> d
{'x': 10, 'y': 20, 'z': 30}
Operation "Wörterbuchtyp" (Wörterbuchtyp)
#Erfassung der Schlüsselliste des Wörterbuchtyps (Wörterbuchtyp)
>>> d
{'x': 10, 'y': 20, 'z': 30}
>>> d.keys()
dict_keys(['x', 'y', 'z'])
>>> list(d.keys())
['x', 'y', 'z']
#Aktualisierung des Wörterbuchtyps (Wörterbuchtyp) (Kombination)
#Aktualisieren Sie den Wert für den Artikel mit dem Schlüssel, fügen Sie den Schlüssel und den Wert für den Artikel ohne Schlüssel hinzu
>>> d
{'x': 10, 'y': 20, 'z': 30}
>>> d2
{'x': 100, 'a': 1, 'b': 2}
>>> d.update(d2)
>>> d
{'x': 100, 'y': 20, 'z': 30, 'a': 1, 'b': 2}
#Holen Sie sich den Wert eines bestimmten Schlüssels
>>> d.get('x')
100
#Abrufen des Werts eines bestimmten Schlüssels (der abgerufene Schlüssel und der abgerufene Wert sind nicht mehr in der Wörterbuchdefinition enthalten).
>>> d
{'x': 100, 'y': 20, 'z': 30, 'a': 1, 'b': 2}
>>> d.pop('a')
1
>>> d.pop('b')
2
>>> d
{'x': 100, 'y': 20, 'z': 30}
#Überprüfen Sie, ob ein bestimmter Schlüssel im Wörterbuch enthalten ist
>>> d
{'x': 100, 'y': 20, 'z': 30}
>>> 'x' in d
True
Typ einstellen
>>> items = {'note', 'notebook', 'pen'}
>>> type(items)
<class 'set'>
>>> items
{'notebook', 'note', 'pen'}
#Doppelte Elemente werden eins sein
>>> items = {'note', 'notebook', 'pen', 'pen', 'note'}
>>> items
{'notebook', 'note', 'pen'}
#Element hinzufügen
>>> items.add('book')
>>> items
{'notebook', 'note', 'pen', 'book'}
#Element löschen
>>> items.remove('pen')
>>> items
{'notebook', 'note', 'book'}
#Extrahieren Sie Elemente und löschen Sie sie aus dem Set
#Da es keine Reihenfolge gibt, sind die abzurufenden Elemente unbestimmt
>>> items.pop()
'notebook'
>>> items
{'note', 'book'}
gefrorener Set-Typ
>>> items = frozenset(['note', 'notebook', 'pen'])
>>> type(items)
<class 'frozenset'>
>>> items
frozenset({'notebook', 'note', 'pen'})
#Kann nicht geändert werden, da es sich um einen unveränderlichen Typ handelt
>>> items.add('book')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
Berechnung einstellen
>>> set_a = {'note', 'notebook', 'pen'}
>>> set_b = {'note', 'book', 'file'}
#Summensatz
>>> set_a | set_b
{'notebook', 'note', 'file', 'book', 'pen'}
>>> set_a.union(set_b)
{'notebook', 'note', 'file', 'book', 'pen'}
#Differenz gesetzt
>>> set_a - set_b
{'notebook', 'pen'}
>>> set_a.difference(set_b)
{'notebook', 'pen'}
#Produktset
>>> set_a & set_b
{'note'}
>>> set_a.intersection(set_b)
{'note'}
#Symmetrieunterschied
>>> set_a ^ set_b
{'notebook', 'book', 'file', 'pen'}
>>> set_a.symmetric_difference(set_b)
{'notebook', 'book', 'file', 'pen'}
#Beurteilung, ob es sich um eine Teilmenge handelt
>>> {'note', 'pen'} <= set_a
True
>>> {'note', 'pen'}.issubset(set_a)
True
Listeneinschlussnotation(Liste erstellen)
#Erstellen einer Liste mit der for-Anweisung
>>> numbers = []
>>> for i in range(10):
... numbers.append(str(i))
...
>>> numbers
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
#Erstellen einer Liste mit Listeneinschlussnotation
>>> [str(v) for v in range(10)]
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
#Inklusive Notation der verschachtelten Liste
#Beschreibung mit for-Anweisung
>>> tuples = []
>>> for x in [1, 2, 3]:
... for y in [4, 5, 6]:
... tuples.append((x, y))
...
>>> tuples
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
#Erstellen einer verschachtelten Liste mithilfe der Listeneinschlussnotation
>>> [(x, y) for x in [1, 2, 3] for y in [4, 5, 6]]
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
#Einschlussnotation mit if-Anweisung
#Beschreibung mit for-Anweisung
>>> even = []
>>> for i in range(10):
... if i % 2 == 0:
... even.append(i)
...
>>> even
[0, 2, 4, 6, 8]
#Beschreibung mit Einschlussnotation
>>> [x for x in range(10) if x % 2 == 0]
[0, 2, 4, 6, 8]
Funktionsdefinition
#Funktionsdefinition (kein Argument)
>>> def say_hello():
... print('Hello')
...
>>> say_hello()
Hello
#Funktionsdefinition (mit Argumenten)
>>> def say_something(str):
... print(str)
...
>>> say_something('Good morning')
Good morning
#Funktionsdefinition (mit Argumenten, mit Standardargumenten)
>>> def say_something(str='Hi!'):
... print(str)
...
#Wenn kein Argument angegeben wird, wird das Standardargument verwendet
>>> say_something()
Hi!
#Wenn ein Argument angegeben wird, wird dieses Argument verwendet.
>>> say_something('Hello')
Hello
#Funktionsdefinition (mit Rückgabewert)
>>> def increment(num):
... return num + 1
...
>>> increment(1)
2
--Wenn die return-Anweisung in der Funktion ausgeführt wird, endet die Verarbeitung dort, sodass die nachfolgende Verarbeitung nicht ausgeführt wird.
Funktionsargumente
#Positionsargument->In Variablen in der Reihenfolge gespeichert, in der sie beim Aufrufen der Funktion übergeben wurden(Fehler, wenn die Anzahl der Argumente unterschiedlich ist)
>>> def increment(num1, num2):
... return num1 + num2
...
>>> increment(2, 4)
6
#Schlüsselwortargument->Geben Sie beim Aufruf Schlüsselwortargumente an(Die Reihenfolge spielt keine Rolle)
>>> def greeting(name, str):
... print(str + ', ' + name + '!')
...
>>> greeting(str='Hello', name='Tom')
Hello, Tom!
#Standardargument->Für das formale Argument kann ein Standardwert angegeben werden (das formale Argument mit dem Standardwert muss jedoch nach dem formalen Argument ohne den Standardwert beschrieben werden).
>>> def greeting(name, str='Hi'):
... print(str + ', ' + name + '!')
...
>>> greeting('Tom')
Hi, Tom!
#Positionsargument mit variabler Länge->Kann beliebig viele Argumente akzeptieren (angegebene Position befindet sich am Ende des Positionsarguments und vor dem Argument mit dem Standardwert)
>>> def say_something(name, *args):
... for str in args:
... print("I'm " + name + ". " + str + "!")
...
>>> say_something('Tom', 'Hello', 'Hi', 'Good morning')
I'm Tom. Hello!
I'm Tom. Hi!
I'm Tom. Good morning!
'
#Schlüsselwortargument mit variabler Länge->Empfängt Schlüsselwortargumente, die formalen Argumenten im Wörterbuchtyp nicht zugewiesen wurden (angegebene Position ist die letzte)
>>> def print_birthday(family_name, **kwargs):
... print("Birthday of " + family_name + " family")
... for key, value in kwargs.items():
... print(f'{key}: {value}')
...
>>> print_birthday('Smith', Nancy='1990/1/1', Tom='1993/1/1', Julia='2010/1/1')
Birthday of Smith family
Nancy: 1990/1/1
Tom: 1993/1/1
Julia: 2010/1/1
#Positions- und Schlüsselwortargumente mit variabler Länge->Kann jeden Argumentaufruf verarbeiten
>>> def say_something(*args, **kwargs):
... for s in args:
... print(s)
... for key, value in kwargs.items():
... print(f'{key}: {value}')
...
>>> say_something('Hello', 'Hi', 'Bye', Nancy='29 years old', Tom='26 years old')
Hello
Hi
Bye
Nancy: 29 years old
Tom: 26 years old
#Nur-Schlüsselwort-Argument->Argumente, für die beim Aufruf ein formaler Argumentname erforderlich ist
# 「*Nur Schlüsselwörter sind Argumente nach "
>>> def increment(num, lsat, *, ignore_error=False):
... pass
...
#Bei einem Positionsargument tritt ein Fehler auf
>>> increment(1, 2, True)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: increment() takes 2 positional arguments but 3 were given
#Kann nur mit Schlüsselwortargumenten angegeben werden
>>> increment(1, 2, ignore_error=True)
>>>
#Nur Argument positionieren->Argumente, für die zum Zeitpunkt des Aufrufs kein formaler Argumentname angegeben werden kann
# 「/Nur die Position ist das Argument vor. Wenn in der abs-Funktion ein formaler Argumentname angegeben wird, tritt ein Fehler auf.
>>> help(abs)
abs(x, /)
Return the absolute value of the argument.
>>> abs(x=-1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: abs() takes no keyword arguments
Argumentliste entpacken
#Übergeben Sie den in der Liste gespeicherten Wert als Argument
>>> def greeting(x, y, z):
... print(x)
... print(y)
... print(z)
...
>>> contents = ['Hello', 'Good morning', 'Bye']
#Beim Aufrufen einer Funktion "*Erweitern Sie Argumente aus der Liste mit dem Operator
>>> greeting(*contents)
Hello
Good morning
Bye
#Übergeben Sie den im Wörterbuch gespeicherten Wert als Argument
>>> def say_something(name, greeting):
... print(name)
... print(greeting)
...
>>> dict = {'greeting': 'Hello'}
#Beim Aufrufen einer Funktion "**Erweitern Sie Argumente aus dem Wörterbuch mit dem Operator
>>> say_something('Julia', **dict)
Julia
Hello
Lambda-Ausdruckssyntax
Lambda-Argument 1,Argument 2,Argument 3, ...:Ausdruck, der zum Rückgabewert wird
Beispiel für einen Lambda-Ausdruck
>>> increment = lambda num1, num2: num1 + num2
>>> increment(1, 2)
3
#Synonym zu
>>> def increment(num1, num2):
... return num1 + num2
...
>>> increment(1, 2)
3
#Es bleiben nur diejenigen übrig, deren erste Argumentfunktion wahr ist.
>>> nums = ['one', 'two', 'three']
>>> filterd = filter(lambda x: len(x) == 3, nums)
>>> list(filterd)
['one', 'two']
Syntax zur Angabe von Typinformationen
def Funktionsname(arg1:Art von arg1, arg2:Art von arg2, ...) ->Rückgabetyp:
#Der Prozess, den Sie mit der Funktion ausführen möchten
return Rückgabewert
>>> def say_something(name: str, age: int) -> str:
... print(name)
... print(age)
... return name
...
>>> say_something('Tom', 29)
Tom
29
'Tom'
Klassendefinition
Klasse Klassenname(Name der Basisklasse):
def Methodenname(Argument 1,Argument 2, ...):
Der Prozess, den Sie in der Methode ausführen möchten
return Rückgabewert
>>> class Person(object):
... def say_something(self):
... print('Hello!!!')
...
#Klasse instanziieren
>>> person = Person()
#Aufruf der Instanzmethode
>>> person.say_something()
Hello!!!
Instanzinitialisierung
>>> class Person:
... def __init__(self):
... print('Init completed!')
... def say_something(self):
... print('Hello!!!')
...
#Initialisierungsprozess beim Erstellen einer Instanz(__init__Verarbeitung definiert in)Wird genannt
>>> person = Person()
Init completed!
>>> person.say_something()
Hello!!!
@property(setter)
>>> class Person:
... @property
... def name(self):
... return self._name
... @name.setter
... def name(self, name):
... self._name = name
...
>>> person = Person()
>>> person.name = 'Tom'
>>> person.name
'Tom'
--Attribut beginnend mit Unterstrich (_name): Drückt aus, dass es sich um ein privates Attribut handelt.
Klassenvererbung
>>> class Person:
... def greeting(self):
... print('Hello')
... def say_something(self):
... print('I am human')
...
>>> class Man(Person):
... #Methodenüberschreibung
... def say_something(self):
... print('I am a man')
...
>>> man = Man()
>>> man.say_something()
I am a man
#Basisklasse(Personenklasse)Methode ist ebenfalls verfügbar
>>> man.greeting()
Hello
Erstellen eines Moduls (Modulname: Beispiel.py）
import sys
def say_something_upper(s):
#In Großbuchstaben konvertieren
upper_s = s.upper()
return upper_s
str = sys.argv[1]
print(say_something_upper(str))
Modul(sample.py)Anruf
$ python sample.py hello
HELLO
$
Schreiben von Code, der nur funktioniert, wenn er direkt ausgeführt wird
import sys
def say_something_upper(s):
#In Großbuchstaben konvertieren
upper_s = s.upper()
return upper_s
def main():
str = sys.argv[1]
print(say_something_upper(str))
if __name__ == '__main__':
main()
__init__.py
#Leere Datei ist OK
python_programming/sample.py
from python_package import hello
def say_hello():
print(hello.return_hello())
def main():
say_hello()
if __name__ == '__main__':
main()
python_programming/python_package/hello.py
def return_hello():
return 'Hello!!!'
Ausführungsergebnis
$ python sample.py
Hello!!!
$
Wie schreibe ich Import
#Paket importieren
Paketname importieren
import sample_package
#Importieren Sie ein bestimmtes Modul aus einem Paket(von nicht angegeben)
Paketname importieren.Modulname
import sample_package.greeting
#Importieren Sie ein bestimmtes Modul aus einem Paket(von angegeben)
vom Paketnamen Importmodulname
from sample_package import greeting
#Importieren Sie nur bestimmte Attribute aus Paketen und Modulen
vom Paketnamen/Modulname importieren Funktionsname
from sample_package.greeting import say_something
#Importiertes Paket/Modul/Geben Sie der Funktion einen Alias
aus Paketname Importmodulname als Alias
from sample_package.greeting import say_something as s
Massenimport
#Platzhalter (*) Zum Batch-Import
vom Paketnamenimport*
from sample_package import *
__init__.py
__all__ = ["morning", "evening", "night"]
Prämisse: Es gibt viele Module, einschließlich" Morgen "," Abend "," Nacht "in sample_package
Integrierte Funktionen sind in Python integrierte Funktionen, die ohne Import verwendet werden können.
--isinstance (): Gibt True zurück, wenn das im ersten Argument übergebene Instanzobjekt zu der im zweiten Argument übergebenen Klasse gehört.
isinstance()
>>> d = {}
#Das erste Argument ist ein Instanzobjekt
>>> isinstance(d, dict)
True
#Wenn das zweite Argument ein Taple ist, wird es in mehreren Klassen gleichzeitig verglichen.
>>> isinstance(d, (list, int, dict))
True
--issubclass (): Fast identisch mit isinstance (), verwendet jedoch ein Klassenobjekt als erstes Argument.
issubclass()
#Das erste Argument ist ein Klassenobjekt
>>> issubclass(dict, object)
True
#Der Bool-Typ ist eine Unterklasse vom Typ int
>>> issubclass(bool, (list, int, dict))
True
--callable (): Beurteilt aufrufbare Objekte (Funktionen, Klassen, Methoden usw., die mit () aufgerufen werden können)
callable()
>>> callable(isinstance) #Funktion
True
>>> callable(Exception) #Klasse
True
>>> callable(''.split) #Methode
True
--getattr () / setattr () / delattr (): Objektattribute bearbeiten
getattr()/setattr()/delattr()
#Beispielklassendefinition
>>> class Mutable:
... def __init__(self, attr_map):
... for k, v in attr_map.items():
... setattr(self, str(k), v)
...
#Setzen Sie die Attribute auf m
>>> m = Mutable({'a': 1, 'b': 2})
>>> m.a
1
>>> attr = 'b'
#Wert erhalten
>>> getattr(m, attr)
2
#Wert löschen
>>> delattr(m, 'a')
>>> m.a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Mutable' object has no attribute 'a'
# getattr()Kann auch Methoden bekommen
>>> str = 'python'
>>> instance_method = getattr(str, 'upper')
>>> instance_method()
'PYTHON'
--zip (): Gibt mehrere iterierbare Elemente gleichzeitig zurück
zip()
#Fassen Sie die i-ten Elemente jeder Iterable zusammen
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> zip(a, b)
<zip object at 0x10827a7d0>
>>> list(zip(a, b))
[(1, 4), (2, 5), (3, 6)]
# zip()Gibt Ergebnisse nur bis zur kürzesten iterierbaren Länge zurück
>>> d = [1, 2, 3]
>>> e = [4, 5, 6, 7, 8]
>>> f = [9, 10]
>>> zip(d, e, f)
<zip object at 0x10827a7d0>
>>> list(zip(d, e, f))
[(1, 4, 9), (2, 5, 10)]
#Wenn Sie die längste iterable anpassen möchten, verwenden Sie die Standardbibliothek itertools.zip_longest()Funktion verwenden
>>> from itertools import zip_longest
>>> list(zip_longest(d, e, f, fillvalue=0))
[(1, 4, 9), (2, 5, 10), (3, 6, 0), (0, 7, 0), (0, 8, 0)]
--sort (): Sortiert die Elemente der Iterable
sorted()
>>> a = [3, 2, 5, 1, 4]
>>> b = [2, 1, 4, 5, 3]
# list.sort()Sortiert sich
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
# sorted()Gibt eine neue Liste zurück
>>> sorted(b)
[1, 2, 3, 4, 5]
>>> b
[2, 1, 4, 5, 3]
# reverse=Wenn True angegeben ist, wird die Reihenfolge umgekehrt.
>>> sorted(b, reverse=True)
[5, 4, 3, 2, 1]
Da sorted () Elemente direkt vergleicht, tritt ein Fehler auf, wenn Zahlen und Zeichenfolgen gemischt werden
Weitere integrierte Funktionen finden Sie weiter unten
Liste der in Python integrierten Funktionen https://docs.python.org/ja/3/library/functions.html
Eine spezielle Methode ist eine Methode mit zwei Unterstrichen (__) vor und nach dem Methodennamen und wird implizit von Python aufgerufen.
Spezielle Methode
#In der Klasse "Word", eine spezielle Methode, "__init__」「__str__」「__len__Definieren
>>> class Word(object):
... def __init__(self, text):
... self.text = text
... def __str__(self):
... return 'Word!!!'
... def __len__(self):
... return len(self.text)
#Klasse instanziieren
>>> w = Word('test')
#Wenn Sie versuchen, w implizit als Zeichenfolge zu behandeln, "__str__Wird genannt
>>> print(w)
Word!!!
#Wenn ich versuche, "len" auszuführen, um die Länge von w zu erhalten, sage ich implizit "__len__Wird genannt
>>> print(len(w))
4
#Ursprüngliche Beschreibungsmethode (greifen Sie auf den Attributtext der Instanz w zu und erhalten Sie den Wert von len)
>>> print(len(w.text))
4
Weitere spezielle Methoden finden Sie weiter unten
Name der speziellen Python-Methode https://docs.python.org/ja/3/reference/datamodel.html#special-method-names
open()Schreiben einer Datei mit
#Das erste Argument ist der Dateiname und das zweite Argument ist der Modus
#Modus (Argument ist optional, für "r" weggelassen)
#"R": schreibgeschützt
#"W": Nur exportieren
#"A": Hinzufügung (Hinzufügung zum Ende der Datei)
# 「r+": Lesen und Schreiben
>>> f = open('test.txt', 'w')
>>> f.write('Test!')
>>> f.close()
#Wie folgt "Test."txt" wird generiert und "Test"!"Ist geschrieben.
[localhost]$ cat test.txt
Test!
[localhost]$
#Es ist auch möglich, mit print in eine Datei zu schreiben
>>> f = open('test.txt', 'w')
>>> print('Print!', file=f)
>>> f.close()
#Wie folgt "Test."txt" wird generiert und "Print"!"Ist geschrieben.
[localhost]$ cat test.txt
Print!
[localhost]$
#Optionen bei Verwendung von Druck
>>> f = open('test.txt', 'w')
>>> print('My', 'name', 'is', 'Tom', sep='###', end='!!!', file=f)
>>> f.close()
#Das Trennzeichen wird im September angegeben.###(Standard ist ein Raum mit halber Breite) und schließlich "" bis zum Ende angegeben!!!"Ist geschrieben.
[localhost]$ cat test.txt
My###name###is###Tom!!!
[localhost]$
read()Dateien lesen mit
#Als vorläufige Vorbereitung "Test.txt "vorbereitet
>>> f = open('test.txt', 'w')
>>> print('My', 'name', 'is', 'Tom', end='!\n', file=f)
>>> print('My', 'name', 'is', 'Nancy', end='!\n', file=f)
>>> print('My', 'name', 'is', 'Julia', end='!\n', file=f)
>>> f.close()
[localhost]$ cat test.txt
My name is Tom!
My name is Nancy!
My name is Julia!
[localhost]$
# read()Lesen Sie den Inhalt der Datei mit
>>> f = open('test.txt', 'r')
>>> f.read()
'My name is Tom!\nMy name is Nancy!\nMy name is Julia!\n'
>>> f.close()
# readline()Lesen Sie Zeile für Zeile mit
>>> f = open('test.txt', 'r')
>>> f.readline()
'My name is Tom!\n'
>>> f.readline()
'My name is Nancy!\n'
>>> f.readline()
'My name is Julia!\n'
>>> f.close()
Bearbeiten von Dateien mit der with-Anweisung
# with open()Wenn Sie eine Datei mit bearbeiten()Es ist keine Verarbeitung erforderlich.
>>> with open('test.txt', 'a') as f:
... print('with open statement!', file=f)
...
>>>
[localhost]$ cat test.txt
My name is Tom!
My name is Nancy!
My name is Julia!
with open statement!
[localhost]$
Recommended Posts