Python verfügt über eine große Anzahl integrierter Funktionen (integrierte Funktionen), mit denen Sie verschiedene Aufgaben ausführen können, ohne die Bibliothek importieren zu müssen. Ich möchte auf die Grundlagen zurückkommen und die Verwendung der integrierten Funktionen organisieren.
Das Ausführungsbeispiel wird mit Python 3.7.5 erstellt, das unter Ubuntu 18.04 von Windows Subsystem für Linux 2 (WSL2) installiert ist.
(Vorsichtsmaßnahmen) Bitte beachten Sie, dass sich aufgrund des Aktualisierungszeitraums die Nebenversionen und die Ausführungsumgebung von Python von den Artikeln bis Teil 4 unterscheiden. Zum Zeitpunkt des Schreibens wurde Python 3.8.0 veröffentlicht. Da diese Serie jedoch in der Python 3.7-Serie geschrieben ist, beachten Sie dies bitte ebenfalls.
Erobern Sie 69 integrierte Funktionen von Python Teil 1 a bis b Erobern Sie 69 integrierte Funktionen von Python 2nd c ～ d Erobern Sie 69 integrierte Funktionen von Python 3rd e ～ g Eroberung von 69 integrierten Funktionen von Python h ～ i Erobern Sie 69 integrierte Funktionen von Python 5th l ～ o
Ich werde beschreiben, wie jede Funktion verwendet wird. Ich werde die detaillierte Verwendung anderen Artikeln überlassen, aber hier werde ich hauptsächlich einfache Verwendungsbeispiele veröffentlichen.
pow()
Es berechnet die Kraft des gegebenen Arguments. Wenn Sie zwei Argumente wie "pow (x, y)" angeben, entspricht dies x ** y.
>>> #Ganzzahlen
... pow(2, 3)
8
>>> #Das zweite Argument ist ein negativer Wert
... pow(10, -3)
0.001
>>> #Das zweite Argument ist ein Bruchteil
pow(3, 2.5)
15.588457268119896
Mit einem dritten Argument wird der Rest berechnet. Gemäß der Dokumentation ist "pow (x, y, z)" effizienter als "pow (x, y)% z".
>>> #2 bis 3. Potenz von 5 Rest
... pow(2, 3, 5)
3
>>> #Wenn das zweite Argument negativ ist, kann das dritte Argument nicht angegeben werden
... pow(2, -3, 5)
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
>>> #Für die Restberechnung müssen alle Argumente Ganzzahlen sein
... pow(2, 1/2, 3)
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: pow() 3rd argument not allowed unless all arguments are integers
Ab Python3.8 ist es übrigens möglich, den Rest zu berechnen, auch wenn der Exponent ein negativer Wert ist.
$ docker container run -it python:3.8
Python 3.8.1 (default, Dec 20 2019, 21:56:21)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> pow(2, -3, 5)
2
print()
Konvertiert das angegebene Objekt in eine Zeichenfolge und schreibt es in die Standardausgabe. Sie können mehrere Werte übergeben. Das Argument sep gibt das Trennzeichen an, und das Argument end gibt das Ende der Zeile an.
>>> #Berühmter Typ. Die Standardeinstellung für Ende ist das Zeilenvorschubzeichen(\n)
... print('Hello, world!')
Hello, world!
>>> #Wenn Sie mehr als eine bestehen. Die Standardeinstellung für sep ist Leerzeichen( )
... print('Good Bye', 'Python2')
Good Bye Python2
>>> #Sie können Trennzeichen und Zeilenvorschubzeichen festlegen.
... print('foo', 'bar', 'piyo', 'hoge', sep='!!!, ', end='!?\n')
foo!!!, bar!!!, piyo!!!, hoge!?
>>> #Numerischer Wert
... print(1, 1, 2, 3, 5, 8, 13)
1 1 2 3 5 8 13
>>> #aufführen
... print(['H', 'e', 'l', 'l', 'o'])
['H', 'e', 'l', 'l', 'o']
>>> #Homebrew-Klasse
... class MyClass1: pass
...
>>> print(MyClass1())
<__main__.MyClass1 object at 0x7f1c8720a450>
>>> # __str__Sie können den zu stringifizierenden Wert durch Implementierung steuern
... class MyClass2:
... def __str__(self):
... return 'This is ' + self.__class__.__name__
...
>>> print(MyClass2())
This is MyClass2
Standardmäßig schreibt die Funktion print () einen Wert in die Standardausgabe (sys.stdout), aber Sie können das Schreibziel mit dem Dateiargument ändern.
>>> #Schreiben Sie in die Standardfehlerausgabe
... print('Error has occured!!', file=sys.stderr)
Error has occured!!
>>> #In Datei schreiben
... with open('hello.txt', 'w') as f:
... print('Hello, my file', file=f)
...
>>> #Es ist sicherlich in die Datei geschrieben.
... with open('hello.txt', 'r') as f:
... f.read()
...
'Hello, my file\n'
>>> #In-Memory-Dateistream
... import io
>>> memfile = io.StringIO()
>>> print('Into the memory', file=memfile)
>>> memfile.getvalue()
'Into the memory\n'
Der von der Druckfunktion ausgegebene Wert kann gepuffert werden. Wenn der geschriebene Wert beispielsweise keinen Zeilenumbruch aufweist, wird er möglicherweise nicht sofort ausgegeben, da darauf gewartet wird, dass zusätzliche Daten oder Dateien geschlossen werden. Wenn Sie eine sofortige Ausgabe wünschen, z. B. ein Protokollierungstool, möchten Sie dem Argument möglicherweise "flush = True" geben, damit es sofort zur Laufzeit geschrieben wird.
$ cat counter.py
import time
def counter(n):
for i in range(1, n+1):
print(i, end=' ') # <==Zeile mit Leerzeichen anstelle von Zeilenumbruch beenden
time.sleep(1)
counter(10)
$ #Da es gepuffert wird, wird es nach 10 Sekunden sofort ausgegeben
$ python3 counter.py
1 2 3 4 5 6 7 8 9 10
$ cat counter2.py
import time
def counter2(n):
for i in range(1, n+1):
print(i, end=' ', flush=True) # <== flush=Die Ausgabe wird zwangsweise ausgeführt, indem sie auf True gesetzt wird
time.sleep(1)
counter2(10)
$ #Zahlen werden jede Sekunde angezeigt
$ python3 counter2.py
1 2 3 4 5 6 7 8 9 10
property()
Möglicherweise möchten Sie Getter-, Setter- und Deleter-Attribute implementieren, um eine Kapselung in der objektorientierten Programmierung zu erreichen. property () bietet eine bequeme Möglichkeit, diese einfach zu implementieren.
Eigenschaft (offizielles Dokument)
Im Folgenden wird die Eigenschaft verwendet, um den öffentlichen Zugriff auf das private Attribut "_name" zu implementieren.
$ cat book.py
class Book:
def __init__(self, name):
self._name = name
def _get_name(self):
"""getter"""
return self._name
def _set_name(self, name):
"""setter"""
self._name = name
def _delete_name(self):
"""deleter"""
del self._name
name = property(_get_name, _set_name, _delete_name, 'This is name property')
>>> from book import Book
>>> book = Book('Clean Code')
>>> # getter
... book.name
'Clean Code'
>>> # deleter
... del book.name
>>> book.name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/home/kotaro/book.py", line 8, in _get_name
return self._name
AttributeError: 'Book' object has no attribute '_name'
>>> # setter
... book.name = 'The Pragmatic Programmer'
>>> book.name
'The Pragmatic Programmer'
Der gleiche Vorgang kann unter Verwendung der Dekorationsnotation wie folgt beschrieben werden:
class Book:
def __init__(self, name):
self._name = name
@property
def name(self):
"""This is name property"""
return self._name
@name.setter
def name(self, name):
"""setter"""
self._name = name
@name.deleter
def name(self):
"""deleter"""
del self._name
Da das dem Argument der Eigenschaft angegebene Attribut eine Methode ist, können Sie auch die Datenkonvertierungsverarbeitung schreiben.
@property
def uppercase(self):
""" uppercase book name"""
return self._name.upper()
>>> book = Book('Clean Code')
>>> book.name
'Clean Code'
>>> book.uppercase
'CLEAN CODE'
range()
Aus dem angegebenen Argument wird ein Objekt vom Typ Bereichstyp erstellt und zurückgegeben. Der Bereichstyp verwendet drei ganzzahlige Argumente, Start, Stopp und Schritt, und stellt eine Folge von Ganzzahlen dar, die das Intervall von [Start, Stopp] in Schritten ändern. Wenn nur ein Argument angegeben wird, wird "start = 0" "step = 1" gesetzt und eine Sequenz, die von 0 auf 1 erhöht wird, wird bis zum Argumentwert -1 generiert.
>>> r1 = range(10)
>>> r1
range(0, 10)
>>> list(r1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> #Kann über den Index abgerufen werden
... r1[3]
3
>>> r1[-2]
8
>>> #Kann in Scheiben geschnitten werden. Ein neues Bereichsobjekt des angegebenen Bereichs wird erstellt.
... r1[2:6]
range(2, 6)
>>> r1[:]
range(0, 10)
>>> r1[100:10000]
range(10, 10)
>>> r1[0:0]
range(0, 0)
>>> #Unveränderliche Reihenfolge, also keine Änderungen
... r1[1] = 10000
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: 'range' object does not support item assignment
>>> #Gegeben ein negativer Wert, aber keine Endlosschleife
... list(range(-100))
[]
>>> #Es muss ein Wert sein, der als ganzzahliger Typ behandelt werden kann.
... range(1.1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
>>> #Beginnen Sie für 2 Argumente, stop
... list(range(3, 7))
[3, 4, 5, 6]
>>> #Beginnen Sie für 3 Argumente, stop, step
... list(range(1, 10, 2))
[1, 3, 5, 7, 9]
>>> #Absteigender Bereich
... list(range(10, -1, -1))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> #Vergleich ist möglich. Vergleichen Sie den Inhalt der Sequenz
... range(10) == range(10)
True
>>> range(10) == range(9)
False
>>> #Beide sind wahr, weil die Sequenzlänge 0 ist
... range(0) == range(-100)
True
>>> #Die Elemente der Sequenz sind[1, 3, 5, 7, 9]Also gleichwertig
... range(1, 10, 2) == range(1, 11, 2)
True
Das Bereichsobjekt wird auch häufig in Python verwendet, um eine bestimmte Anzahl von Schleifen zu erreichen.
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
repr()
Erzeugt und gibt die Zeichenfolge des übergebenen Objekts zurück. Wenn möglich, übergeben Sie es an eval (), um daraus eine Zeichenfolge zu machen, die als dasselbe Objekt wie das ursprüngliche Objekt behandelt werden kann.
>>> #String
... repr('Hello')
"'Hello'"
>>> eval(repr('Hello'))
'Hello'
>>> #Numerischer Wert
... repr(12345)
'12345'
>>> eval(repr(12345))
12345
>>> #aufführen
... repr(['This', 'is', 'a', 'list', 'object'])
"['This', 'is', 'a', 'list', 'object']"
>>> eval(repr(['This', 'is', 'a', 'list', 'object']))
['This', 'is', 'a', 'list', 'object']
>>> # range
... repr(range(1, 1000))
'range(1, 1000)'
Wenn eine Zeichenfolge, die von eval () ausgewertet werden kann, nicht zurückgegeben werden kann, werden die Informationen des in <> eingeschlossenen Objekts angezeigt.
>>> class MyClass1: pass
...
>>> repr(MyClass1())
'<__main__.MyClass1 object at 0x7f7659690690>'
Sie können den Rückgabewert von repr steuern, indem Sie die Methode __repr__ () implementieren.
>>> class MyClass2:
... def __repr__(self):
... return self.__class__.__name__ + '()'
...
>>> repr(MyClass2())
'MyClass2()'
>>> eval(repr(MyClass2()))
MyClass2()
reversed()
Durch Übergeben einer Sequenz wird ein Iterator zurückgegeben, der die Sequenz in umgekehrter Reihenfolge zurückgibt.
>>> reversed([1, 2, 3])
<list_reverseiterator object at 0x7f76596908d0>
>>> list(reversed([1, 2, 3]))
[3, 2, 1]
>>> reversed(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: reversed expected 1 arguments, got 3
>>> list(reversed(range(1, 10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> import string
>>> for char in reversed(string.ascii_lowercase):
... print(char, end=' ')
...
z y x w v u t s r q p o n m l k j i h g f e d c b a
Selbst wenn Sie Ihre eigene Klasse implementieren, können Sie reverse () verwenden, indem Sie reversed () implementieren.
>>> class MySequence:
... def __init__(self):
... self._data = []
... def append(self, value):
... self._data.append(value)
... def __iter__(self):
... return iter(self._data)
... def __reversed__(self):
... return reversed(self._data)
...
>>> sequence = MySequence()
>>> sequence.append(1)
>>> sequence.append(3)
>>> sequence.append(5)
>>> list(sequence)
[1, 3, 5]
>>> reversed(sequence)
<list_reverseiterator object at 0x7f7659699610>
>>> list(reversed(sequence))
[5, 3, 1]
round()
Wenn ein numerischer Wert angegeben wird, wird mit den angegebenen Bruchziffern gerundet.
>>> #Wenn es ein Argument gibt, machen Sie es zu einer Ganzzahl
... round(1.1)
1
>>> round(1.5)
2
>>> #3. Platz nach dem Komma
... round(3.14159265, 3)
3.142
>>> #5. Platz nach dem Komma
... round(2.71828182846, 5)
2.71828
Bitte beachten Sie, dass die integrierten Rundungsregeln ** nicht gerundet ** sind.
Auf das nächste Vielfache von 0 minus ndigits gerundet; wenn die beiden Vielfachen gleich nahe beieinander liegen, wählen Sie eine gerade Zahl (so sind beispielsweise rund (0,5) und rund (-0,5) beide). Auf 0 gerundet, auf 1,5 gerundet (1,5). Offizielles Dokument #float
>>> #Beachten Sie, dass es nicht gerundet ist
... round(0.5)
0
>>> round(-0.5)
0
>>> round(-1.5)
-2
Beachten Sie auch, dass der Rundungsprozess vom Typ Float einen Fehler verursacht.
>>> # 2.2 statt 68.Werden Sie 67
... round(2.675, 2)
2.67
Wenn Sie Dezimalbruchoperationen genauer ausführen möchten, sollten Sie die Standardbibliothek Dezimaltyp verwenden. Es kann sein.
Nächstes Mal von set ()
Recommended Posts