Python3.6.0 wurde am 23. Dezember 2016 mit einigen neuen Updates veröffentlicht. What’s New In Python 3.6
Für diejenigen, die mit Python programmieren, können die neu hinzugefügten Grammatikfunktionen von besonderer Bedeutung sein. Diesmal handelt es sich also um eine Grammatikfunktion, die in 3.6.0 hinzugefügt wurde.
--PEP 498: Formatiertes String-Literal --PEP 515: Unterstrich im numerischen Literal --PEP 526: Syntax für variable Annotationen --PEP 525: Asynchroner Generator --PEP 530: Asynchrone Einschlussnotation
Ich werde ungefähr vorstellen.
Python bietet eine format () -Methode in der string (string) -Klasse, und Sie können str.format () verwenden, um Variablen und Formatwerte zu ersetzen. (Zusätzlich zu diesem str.format () gibt es% -Formatierung und string.Template als Methoden zum Formatieren und Einbetten von Variablen.)
Das vorhandene Verfahren ist jedoch fehleranfällig, unflexibel und weist insofern Probleme auf, als es redundantes Schreiben erfordert.
Diesmal sind f-Strings eine Funktion, die format () entspricht, und ihre Funktion besteht darin, dass Sie Variablen, Formate und Ausführungsausdrücke in __character strings __str.format () einbetten können. Es ist in __, wo Sie nicht redundant schreiben müssen wie .
Sie können F-Strings mit dem Präfix "f" deklarieren und "{}" als Platzhalter verwenden. Ein Beispiel ist unten gezeigt.
python
#Grundlegende Variablenerweiterung
hoge = 'hogehoge'
f'string value: {hoge}' #=> 'string value: hogehoge'
In str.format () kann das, was wie folgt geschrieben wurde, jetzt wie oben geschrieben werden.
python
'string value: {hoge}'.format(hoge='hogehoge')
Ich werde Ihnen zeigen, wie Sie es auf verschiedene Arten verwenden können, aber es ist attraktiv, dass F-Strings auf vereinfachte Weise geschrieben werden können, da ".format (...)" weggelassen werden kann. (Ich bin sehr dankbar, dass ich mich oft über die Zeile mit "str.format ()" geärgert habe, weil die Codestilbewertung von PEP8 80 Zeichen überschritten hat.)
Die Variablen, die Sie erweitern möchten, können in {} verschachtelt sein, und Sie können die erweiterten Werte verwenden, um das Format anzugeben.
python
#Format
float_val = 0.123456
size = 4
f'result: {float_val:.{size}}' #=> 'result: 0.1235'
Da es in {} als Ausführungsausdruck ausgewertet wird, können Sie die Liste und das Wörterbuch wie folgt erweitern, addieren und subtrahieren usw.
python
#aufführen
some_list = ['foo', 'bar', 'baz']
f'list item: {some_list[0]}' #=> 'list item: foo'
#Wörterbuch
some_dict = {'foo': 'foofoo', 'bar': 'barbar'}
f'dict item: {some_dict["foo"]}' #=> 'dict item: foofoo'
# operation
some_value = 10
f'add ops: {some_value + 20}' #=> 'add ops: 30'
f'list length: {len(some_list)}' #=> 'list length: 3'
Sie können auch eine Funktion in {} aufrufen.
python
# function
def multi(a, b):
return a * b
x = 10
y = 20
f'multi value: {multi(x, y)}' #=> 'multi value: 200'
{} Kann unterbrochen werden, da sie vor der Auswertung in impliziten Klammern stehen.
python
class Foo(object):
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
f'''Instance method call: {Foo("foo").get_name(
)}'''
#=> 'Instance method call: foo'
Sie können eine Escape-Ausgabe erhalten, indem Sie im Präfix "fr" anstelle von "f" verwenden.
# raw f-strings
fr'raw output\n' #=> 'raw output\\n'
Es ist eine kleine Ergänzung, aber Sie können jetzt den Unterstrich "_" für numerische Literale verwenden. Die Unterstrichposition kann jedoch nicht am Anfang, am Ende oder in einer zusammenhängenden Form verwendet werden und kann zwischen Zahlen oder nach dem Radix-Bezeichner platziert werden. Wenn es mit "000000 ..." weitergeht, ist es zwar etwas schwierig zu sehen, aber es scheint, dass es gelöst wird.
#Dezimalzahl
decimal = 10_000_000.0
print(decimal) #=> 10000000.0
#Hexadezimal
hexadecimal = 0xCAFE_F00D
print(hexadecimal) #=> 3405705229
#Binärzahl
binary = 0b_0011_1111_0100_1110
print(binary) #=> 16206
# binary string => int casting
binary_string = int('0b_1111_0000', 2)
print(binary_string) #=> 240
Die in PEP484 (Python 3.5) hinzugefügte Funktion für Typhinweise bietet eine Syntax für Typhinweise für formale Funktionsargumente. Wurde gemacht. In diesem PEP526 wurde die Syntax für Typhinweise für Variablen hinzugefügt. "Variablen" umfassen neben regulären Variablen auch Klassenvariablen und Instanzvariablen.
python
from typing import List
vectors: List[float] = [0.1, 0.2]
counts: Dict[str, int] = {
'foo': 10,
'bar': 20,
'baz': 30,
}
#Klassenvariablen sind ebenfalls verfügbar
class Foo(object):
name: str = 'foo'
Diese Annotationen sind übrigens nicht vom Ergebnis dieser Annotation im Python-Interpreter betroffen, daher gibt es keine Warnung zur Python-Laufzeit. Diese Funktion ist jetzt ein Tool von Drittanbietern (z. B. mypy, pytype, [PyCharm]. Sie müssen wissen, dass (https://www.jetbrains.com/pycharm/ usw.) eine Funktion ist, mit der Sie einfach auf Anmerkungsattribute verweisen können.
url: str = ''
url = 100 #=>
print(url) #=>Wird ohne Vorwarnung usw. als 100 angezeigt.
Die in PEP492 (Python 3.5) hinzugefügte asynchrone / warten-Syntax erlaubt nicht, dass "warten" und "ergeben" für dieselbe Funktion verwendet werden. Seit 3.6 gibt es jedoch Unterstützung für asynchrone Generatoren, bei denen "Warten" und "Ertrag" für dieselbe Funktion verwendet werden können.
python
import asyncio
async def ticker(delay, to):
for i in range(to):
yield i
await asyncio.sleep(delay)
async def run():
async for i in ticker(1, 10):
print(i)
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(run())
finally:
loop.close()
Ab 3.6 wird die Verwendung von "async for" in Listen, Mengen, Wörterbucheinschlüssen und Generatorausdrücken unterstützt. Es ist eine kleine Änderung, aber ich denke, es ist einfacher zu schreiben.
python
import asyncio
async def aiter():
n = 10
for i in range(n):
yield i
await asyncio.sleep(0.5)
#Asynchrone Einschlussnotation
async def run():
result = [i async for i in aiter() if i % 2]
print(result)
#Laufen Sie oben()Gleiche Syntax wie
async def run():
result = []
async for i in aiter():
if i % 2:
result.append(i)
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(run())
finally:
loop.close()
Wie oben erwähnt, möchte ich es definitiv in einer Umgebung verwenden, in der Sie sich keine Sorgen um die Kompatibilität machen müssen.
Dieses Mal habe ich nur die Änderung der Grammatik eingeführt, aber ab 3.6 gibt es noch andere
Es gibt Änderungen wie. Weitere Informationen finden Sie unter Was ist neu in Python 3.6.
Recommended Posts