Ich habe einige andere Sprachen angesprochen, aber ich bin eine neue Einführung in Python. Während des Lernprozesses habe ich einige Funktionen, die mich im Vergleich zu anderen Sprachen interessierten, aufgegriffen und in 12 Elemente zusammengefasst (+ 1 extra).
Jedes Element ist nahezu unabhängig, sodass Sie es überspringen und lesen können. (Qiita hat ein Inhaltsverzeichnis, so dass das Lesen leicht übersprungen werden kann!)
Die Operation wurde mit dem Interpreter von Python 3.5.1 bestätigt.
Wenn es sich bei der Definition einer leeren Funktion usw. um eine Sprache handelt, die gewellte Klammern ({}) verwendet, um den Hauptteil der Funktion einzuschließen, besteht kein Zweifel, aber Python drückt Blöcke mit Einzügen aus, ohne Klammern zu verwenden. Ich weiß also nicht intuitiv, was ich tun soll.
Verwenden Sie abschließend die Anweisung "pass". Übrigens, obwohl hier nicht geschrieben, gilt das Gleiche für ** leere Klassen **.
7.4. Pass-Anweisung (7. einfache Anweisung - Python 3.5.1-Dokumentation) http://docs.python.jp/3/reference/simple_stmts.html#the-pass-statement
>>> def foo():
... pass
...
>>> foo()
>>>
Selbst wenn Sie eine leere Zeile mit einem Einzug in die zweite Zeile schreiben, tritt der folgende Fehler auf. Sie erhalten den gleichen Fehler, ohne die zweite Zeile zu schreiben. (Im Beispiel weiß ich nicht, ob es leer ist, also habe ich einen Kommentar abgegeben.)
>>> def foo():
... #
...
File "<stdin>", line 3
^
IndentationError: expected an indented block
>>>
Wenn Sie nur den entsprechenden Wert schreiben, ohne "return" zu schreiben, scheint dies auf die gleiche Weise zu funktionieren wie im Fall der "pass" -Anweisung. Da jedoch die Bedeutung einer leeren Funktion nicht klar ist, lautet die Methode × Schätze ich.
>>> def foo():
... pass
...
>>> foo()
>>> def bar():
... 0
...
>>> type(foo())
<class 'NoneType'>
>>> type(bar())
<class 'NoneType'>
>>>
Natürlich ist pass eine ** Anweisung **, daher kann es nicht als Objekt verwendet werden.
>>> o = pass
File "<stdin>", line 1
o = pass
^
SyntaxError: invalid syntax
>>>
Angenommen, Sie haben eine Datei mit dem Namen "foo / bar.py", die folgendermaßen aussieht: (Die Beschreibung am Anfang wird weggelassen)
import inspect
def baz():
print('module=', __name__, ', func=', inspect.currentframe().f_code.co_name)
def qux():
print('module=', __name__, ', func=', inspect.currentframe().f_code.co_name)
(Inspect.currentframe (). F_code.co_name ist der Code, mit dem der Funktionsname aus der Funktion abgerufen werden kann.)
Hinweis: Es scheint, dass Sie eine Datei mit dem Namen "__init __. Py" in das Verzeichnis "foo /" legen müssen, um dieses "foo" als Paket zu verwenden, da es leer sein kann. Dieses Beispiel funktioniert jedoch ohne "__init __. Py".
Und wenn Sie die Funktion darin aufrufen möchten, muss es der vollständige Name sein. Es wird nur das Modul importiert, nicht der Namespace.
>>> import foo.bar
>>> bar.baz()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'bar' is not defined
>>> foo.bar.baz()
module= foo.bar , func= baz
>>> foo.bar.qux()
module= foo.bar , func= qux
>>>
So importieren Sie "bar" als Namespace aus "foo"
from foo import bar
Wird besorgt.
Außerdem sind lange Namen schwierig zu verwenden, sodass Sie "as" verwenden können, um ihnen einen Alias zu geben.
Natürlich können Sie auch beides kombinieren.
>>> from foo import bar
>>> import foo.bar as fb
>>> from foo import bar as b
>>> bar.baz()
module= foo.bar , func=baz
>>> bar.qux()
module= foo.bar , func=qux
>>> fb.baz()
module= foo.bar , func=baz
>>> fb.qux()
module= foo.bar , func=qux
>>> b.baz()
module= foo.bar , func=baz
>>> b.qux()
module= foo.bar , func=qux
>>>
Wenn Sie "from foo.bar import baz" verwenden, können Sie die Funktion "baz" direkt importieren. In der Regel ist es jedoch besser, sie nicht zu verwenden, da der Namespace bis auf einige Standardfunktionen verwirrt ist. Es wird gut sein. (Übrigens wird die Funktion qux in diesem Fall nicht importiert.)
In diesem Abschnitt wird beschrieben, wie Sie Ihr eigenes (lokales) Modul aufrufen. Selbst wenn Sie die installierte Bibliothek verwenden, besteht der Unterschied darin, dass Sie die relative Position des Modul-Suchpfads aus jedem Verzeichnis angeben, aber auch andere Dinge Wird auf die gleiche Weise angegeben.
In einem Modul definierte Variablen, die nicht in Blöcken geschlossen sind, sind globale Variablen.
(Ich bin mir über die genaue Definition dieses Bereichs nicht sicher. Ich frage mich, ob der Standard-Namespace das Hauptmodul ist.)
Wenn Sie eine Variable mit demselben Namen wie die globale Variable in der Funktion neu definieren, wird sie zu einer lokalen Variablen. Dies bedeutet, dass wenn Sie versuchen, eine globale Variable in einer Funktion neu zu schreiben (neu zuzuweisen), diese als lokale Variable behandelt wird.
Was ist, wenn ich globale Variablen in einer Funktion neu schreiben möchte?
>>> gv = 'global'
>>> def foo():
... gv = 'local'
... print(gv)
...
>>> gv
'global'
>>> foo()
local
>>> gv
'global'
>>>
Mit dem Schlüsselwort "global" können Sie deklarieren, dass Sie globale Variablen in diesem Bereich verwenden möchten.
>>> gv = 'global'
>>> def foo():
... global gv
... gv = 'reassign'
... print(gv)
...
>>> gv
'global'
>>> foo()
reassign
>>> gv
'reassign'
>>>
Bonus:
Die Funktionen globals () undlocal ()geben Wörterbücher globaler bzw. lokaler Variablen zurück.
Es gibt viele globale Variablen, also probieren Sie sie bitte aus.
In Python können Sie einen Wert in ein formales Argument schreiben und einen Standardwert festlegen.
>>> def foo(arr=[]):
... arr.append('A')
... print(arr)
...
>>> foo(['X', 'Y'])
['X', 'Y', 'A']
>>> foo()
['A']
>>>
Bisher denke ich, dass das Verhalten wie erwartet ist.
Rufen wir anschließend die Funktion "foo" auf und lassen das Argument ebenfalls weg.
>>> foo()
['A', 'A']
>>> foo()
['A', 'A', 'A']
>>>
Nicht das was ich erwartet habe ...
Anscheinend wird in Python der für das formale Argument angegebene Standardwert beim Deklarieren der Funktion initialisiert, sodass immer dieselbe Instanz verwendet wird, unabhängig davon, wie oft sie aufgerufen wird. Wenn Sie also ein veränderbares Objekt angeben, sieht es folgendermaßen aus.
Wenn Sie einen Standardwert angeben, müssen Sie ein unveränderliches Objekt angeben.
In Referenz 1 wurde die Methode zur Beurteilung anhand der if-Anweisung unter Verwendung von None als Standardwert eingeführt. (Setzen Sie den Standardwert auf ein leeres Taple und verwenden Sie die Funktion "Liste", um es aufzulisten, nicht wahr?)
Dies ist kein Problem und wie erwartet ein normaler Schließvorgang.
Es scheint, dass die Referenz der erfassten Variablen gemeinsam genutzt wird.
>>> def foo():
... a = []
... def bar():
... a.append(1)
... def baz():
... a.append(2)
... return a, bar, baz
...
>>> a, bar, baz = foo()
>>> bar()
>>> a
[1]
>>> baz()
>>> a
[1, 2]
>>> bar()
>>> a
[1, 2, 1]
>>>
Ich möchte einer Funktion, die ein Argument mit variabler Länge verwendet, ein neues Argument hinzufügen. Selbst wenn ich es danach hinzufüge, wird es als Argument mit variabler Länge übergeben. Wenn ich es zuvor hinzufüge, wird die Kompatibilität merkwürdig. Was soll ich also tun?
Dies kann einfacher sein, wenn Sie die anderen unterstützten Sprachen kennen (ich weiß nicht genau, welche).
Die Antwort ist, ** ein Argument mit einem Standardwert hinzuzufügen und es beim Aufruf ** im "Schlüsselwortformat" anzugeben.
Sie können das Beispiel nur mit der eingebauten Funktion max sehen.
max Funktion (2. Integrierte Funktion - Python 3.5.1 Dokumentation)
http://docs.python.jp/3/library/functions.html?highlight=%E7%B5%84%E3%81%BF%E8%BE%BC%E3%81%BF#max
max Funktion (2. Integrierte Funktion - Python 2.7.x Dokumentation)
http://docs.python.jp/2/library/functions.html?highlight=%E7%B5%84%E3%81%BF%E8%BE%BC%E3%81%BF#max
In der Funktion "max" konnte die Ordnungsfunktion "key" nicht in weniger als Python2.5 angegeben werden, dies ist jedoch in Python2.5 oder höher möglich.
key kann nur im Schlüsselwortformat angegeben, aber unter Beibehaltung der Kompatibilität erweitert werden.
Aber gut, die Schnittstelle einer Funktion wie "max" wird im Schlüsselwortformat angegeben, selbst wenn sie von Anfang an "Schlüssel" hat.
Der folgende Code ist ein Beispiel für die Deklaration einer Funktion mit einer Argumentstruktur ähnlich der Funktion "max".
>>> def foo(*args, opt=None):
... print('args=', args, ', opt=', opt)
...
>>> foo(1, 2, 3)
args= (1, 2, 3) , opt= None
>>> foo(1, 2, 3, opt='hello')
args= (1, 2, 3) , opt= hello
>>>
Sie können den Zugriff auf Klassenattribute (Elementvariablen) wie C # -Eigenschaften, Accessoren in Java-Beans usw. verknüpfen.
Wenn die Foo-Klasse ein Attribut namens text hat, können Sie Eigenschaften mit der Funktion property deklarieren.
>>> class Foo:
... def __init__(self, text):
... self.__text = text
... def get_text(self):
... print('get_text')
... return self.__text
... def set_text(self, text):
... print('set_text')
... self.__text = text
... text = property(get_text, set_text)
...
>>> foo = Foo('foo')
>>> foo.text
get_text
'foo'
>>> foo.text = 'FOO'
set_text
>>> foo.text
get_text
'FOO'
>>>
Wenn Sie am Anfang des Namens zwei Unterstriche (__) einfügen, können Sie übrigens nicht mit demselben Namen darauf zugreifen.
Es kann nicht vollständig verborgen werden wie ein privates Mitglied einer zugriffsgesteuerten Sprache, aber es kann die Absicht vermitteln, es nicht preiszugeben.
>>> foo.__text
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute '__text'
>>> foo._Foo__text
'FOO'
>>>
Eigenschaften können auch im Dekorator festgelegt werden. Dies ist ** ein neuer Stil **.
Nur ein bisschen über Dekorateure. Der Dekorator ähnelt C # -Attributen und Java-Annotationen, aber ich denke, er ähnelt eher einem Makro oder AOP. Bitte googeln Sie für Details.
>>> class Bar:
... def __init__(self, text):
... self.__text = text
... @property
... def text(self):
... print('property')
... return self.__text
... @text.setter
... def text(self, text):
... print('text.setter')
... self.__text = text
...
>>> bar = Bar('bar')
>>> bar.text
property
'bar'
>>> bar.text = 'BAR'
text.setter
>>> bar.text
property
'BAR'
>>>
Da Python eine dynamisch typisierte Sprache ist, können beide im Prinzip wie Sequenzen verwendet werden, außer dass Listen variabel und Taples unveränderlich sind.
Übrigens können Python-Taples ohne Klammern geschrieben werden, mit Ausnahme leerer Taples. Es ist jedoch besser, Klammern zu setzen, um deutlich zu machen, dass es sich um Taples handelt.
>>> t1 = (1, 2, 3)
>>> t2 = 1, 2, 3
>>> t1
(1, 2, 3)
>>> t2
(1, 2, 3)
>>> type(t1)
<class 'tuple'>
>>> type(t2)
<class 'tuple'>
>>>
Listen und Taples können mit den Funktionen list und tuple ineinander konvertiert werden.
>>> a = [1, 2, 3]
>>> type(a)
<class 'list'>
>>> aa = tuple(a)
>>> aa
(1, 2, 3)
>>> type(aa)
<class 'tuple'>
>>> b = (4, 5, 6)
>>> type(b)
<class 'tuple'>
>>> bb = list(b)
>>> bb
[4, 5, 6]
>>> type(bb)
<class 'list'>
>>>
Das sogenannte "printf" -Stilformat scheint alt zu sein. Alte Stile sind jedoch nicht veraltet. Es scheint, dass alte Stile nur in ihrer Funktionalität eingefroren sind und neue Stile flexibler zu schreiben sind.
Alte Stile werden als format string``% `` value taple geschrieben.
>>> 'x=%d, y=%d' % (10, 20)
'x=10, y=20'
>>>
Der neue Stil verwendet die Formatierungsmethode "Zeichenfolgen". Dieser Stil kann flexibel auf verschiedene Arten verwendet werden, z. B. durch Ändern der Reihenfolge der Übergabe und Übergabe eines Wörterbuchs als Argument.
>>> dict = {'x': 10, 'y': 20, 'z': 30}
>>> 'z={z:d}, y={y:d}, x={x:d}'.format(**dict)
'z=30, y=20, x=10'
>>>
Es gibt auch eine Vorlagenzeichenfolge, aber ich wusste nicht, wie ich sie verwenden soll.
>>> from string import Template
>>> s = Template('--- $foo --- $bar ---')
>>> s.substitute(foo='Foo', bar='Bar')
'--- Foo --- Bar ---'
>>> d = {'foo': 100, 'bar': 200}
>>> s.substitute(d)
'--- 100 --- 200 ---'
>>>
Weitere Informationen finden Sie in der folgenden Referenz.
6.1.3.2. Beispiel für eine Formatspezifikation (6.1. Zeichenfolge - allgemeine Zeichenfolgenoperationen - Python 3.5.1-Dokumentation) http://docs.python.jp/3/library/string.html#format-examples
6.1.4. Vorlagenzeichenfolge (6.1. Zeichenfolge - allgemeine Zeichenfolgenmanipulation - Python 3.5.1-Dokumentation) http://docs.python.jp/3/library/string.html#template-strings
Wie definiere ich Methoden wie "to_s" in Ruby und "toString" in Java und JavaScript?
Python-Klassen haben spezielle Methoden, str und repr, die Sie implementieren können, um eine Zeichenfolgendarstellung eines Objekts zu definieren.
__str__ definiert die Zeichenfolgendarstellung beim Konvertieren in eine Zeichenfolge mit der Funktion str oder beim Drucken mit der Funktion print.
__repr__ ist einzigartig in Python und definiert eine Zeichenfolgendarstellung auf dem Interpreter. (Abkürzung für Darstellung?)
>>> class Foo:
... def __init__(self, text):
... self.text = text
... def __str__(self):
... return self.text
... def __repr__(self):
... return '%s(\'%s\')' % (self.__class__.__name__, self.text)
...
>>> Foo('foo')
Foo('foo')
>>> print(Foo('foo'))
foo
>>> str(Foo('foo'))
'foo'
>>>
Zunächst wird das Ergebnis der Methode "repr" als Darstellung auf dem Interpreter ausgegeben.
Die zweite ist die Zeichenfolgendarstellung von "Foo ()", dh das Ergebnis der "str" -Methode wird von der "print" -Funktion ausgegeben.
Drittens wird das Ergebnis der Methode __str__ von der Funktion str ebenfalls in eine Zeichenfolge konvertiert und als Darstellung auf dem Interpreter ausgegeben.
Sie können die Funktion "repr" verwenden, um das Ergebnis der Methode "repr" als Zeichenfolge abzurufen.
>>> s = repr(Foo())
>>> s
"Foo('foo')"
>>>
```
## Ausleihmuster (bei geöffneter Datei)
Verwenden Sie die Anweisung `with`.
Sie können es mit `try-finally` tun, aber` with` ist prägnanter.
8.5. Mit Anweisung (8. zusammengesetzte Anweisung - Python 3.5.1-Dokumentation)
[http://docs.python.jp/3/reference/compound_stmts.html#with](http://docs.python.jp/3/reference/compound_stmts.html#with)
Die folgenden Daten
```
1,2,3
4,5,6
7,8,9
```
Bei einer Textdatei mit dem Namen "data.txt" konvertieren wir diese in eine Liste numerischer Taples.
```pycon
>>> with open('data.txt', 'r') as f:
... a = [tuple(map(int, line.split(','))) for line in f.read().split()]
...
>>> a
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
>>>
```
→ Mir wurde beigebracht, wie man diese beiden Zeilen präziser schreibt. Bitte beachten Sie den Kommentarbereich.
Vielen Dank, @shiracamus.
Ich habe viel gepackt, aber ich werde nicht jeden erklären.
Beachten Sie die Zeile der "with" -Anweisung.
## Ich möchte ein Wörterbuch verwenden, das die registrierte Reihenfolge beibehält
Wenn Sie ein Wörterbuch benötigen, das in der von Ihnen registrierten Reihenfolge wiederholt werden kann, z. B. "LinkedHashMap" in Java
Verwenden Sie anstelle des integrierten Wörterbuchs das "OrderedDict" des Moduls "Sammlungen".
```pycon
>>> from collections import OrderedDict
>>> d = dict([('y', 0), ('e', 0)])
>>> d
{'e': 0, 'y': 0}
>>> d['s'] = 0
>>> d
{'s': 0, 'e': 0, 'y': 0}
>>> for x in d:
... print(x)
...
s
e
y
>>> od = OrderedDict([('y', 0), ('e', 0)])
>>> od
OrderedDict([('y', 0), ('e', 0)])
>>> od['s'] = 0
>>> od
OrderedDict([('y', 0), ('e', 0), ('s', 0)])
>>> for x in od:
... print(x)
...
y
e
s
>>>
```
Wenn Sie mehr über andere Sammlungen erfahren möchten, lesen Sie die Dokumentation zum Modul "Sammlungen".
8.3. Sammlungen - Container-Datentyp - Python 3.5.1-Dokumentation
[http://docs.python.jp/3/library/collections.html](http://docs.python.jp/3/library/collections.html)
## Bonus
Ein bisschen über Python-Ideen und -Regeln.
PEP 8
Es gibt eine Codierungsregel namens PEP 8. Sie sollten dies vorerst befolgen.
~~ (Dies ist keine Standardfunktion.) ~~
→ Sie haben darauf hingewiesen, dass PEP 8 selbst eine Richtlinie (ein Dokument) ist, und es ist seltsam zu sagen, dass es sich nicht um eine Standardfunktion handelt.
"Pep8", das die PEP 8-Regeln überprüft, und "autopep8", das später beschrieben wird, müssen mit "pip" usw. installiert werden, daher sollten diese Tools als "keine Standardfunktionen" geschrieben worden sein.
Vielen Dank für den Hinweis, @ryunix.
Einführung - pep8-ja 1.0 Dokumentation
[https://pep8-ja.readthedocs.io/ja/latest/](https://pep8-ja.readthedocs.io/ja/latest/)
Beachten Sie den Python-Codierungsstandard PEP8 - Qiita
[http://qiita.com/ynakayama/items/8616f4c0c6e372de9a42](http://qiita.com/ynakayama/items/8616f4c0c6e372de9a42)
Es kann auch automatisch mit einem Tool namens "autopep8" angewendet werden.
(Solange du keine Arbeit machst, die Menschen nicht machen müssen.)
Nachtrag: Es scheint, dass der Befehl `pep8` in` pycodestyle` umbenannt wurde.
Weitere Informationen finden Sie im Kommentarbereich.
Vielen Dank, @matobaa.
PEP 20
PEP 20 ist etwas in einer poetischen Form, die die Idee von Python ausdrückt. Details sind unten.
Ideen zu Python: PEP 20 - Leben mit Python
[http://www.lifewithpython.com/2013/01/pep-20-the-zen-of-python.html](http://www.lifewithpython.com/2013/01/pep-20-the-zen-of-python.html)
### Was ist PEP?
PEP steht für Python Enhancement Proposal.
Weitere Informationen finden Sie im Abschnitt "Entwicklung" von Python in der englischen Version von Wikipedia.
Python (programming language) - Wikipedia, the free encyclopedia
#Development
[https://en.wikipedia.org/wiki/Python_(programming_language)#Development](https://en.wikipedia.org/wiki/Python_(programming_language)#Development)
### Kompatibilität mit Python 2
Python2-Serie und Python3-Serie sind nicht kompatibel.
Nach meiner noch flachen Erfahrung hatte ich das Gefühl, dass sich der Umgang mit Zeichenketten erheblich geändert hat.
Bitte beachten Sie, dass im Web eine Menge Beispielcode verstreut ist, von dem Sie nicht wissen, welcher Python2 und welcher Python3 ist.
## abschließend
Das Schreiben dieses Artikels ist zu einer Menge Übung geworden.
Die hier erwähnten Funktionen sind nur die grundlegenden Teile von Python. Daher möchte ich von nun an mit vielen Bibliotheken, Tools und Frameworks ringen und Python ernsthaft verwenden.
Bis zum Ende Danke fürs Lesen.
## Verweise
#1
Erste Schritte Python3 (O'REILLY)
#2
Python 3.5.1-Dokumentation
[http://docs.python.jp/3/](http://docs.python.jp/3/)
Viele andere
Recommended Posts