Python3.6.0 est sorti le 23 décembre 2016, avec quelques nouvelles mises à jour. What’s New In Python 3.6
Après tout, pour ceux qui programment en utilisant Python, les fonctions de grammaire nouvellement ajoutées peuvent être particulièrement préoccupantes. Donc cette fois, c'est une fonction de grammaire ajoutée dans 3.6.0,
--PEP 498: Chaîne littérale formatée --PEP 515: trait de soulignement en littéral numérique --PEP 526: syntaxe d'annotation variable --PEP 525: Générateur asynchrone --PEP 530: Notation d'inclusion asynchrone
Je vais présenter environ.
Python fournit une méthode format () dans la classe string (string), et vous pouvez utiliser str.format () pour effectuer des substitutions de variables et le formatage des valeurs. (En plus de ce str.format (), il existe% -formatting et string.Template comme méthodes de formatage et d'incorporation de variables.)
Cependant, la méthode existante est sujette à des erreurs, est inflexible et présente des problèmes en ce qu'elle nécessite une écriture redondante.
Cette fois, f-strings est une fonction équivalente à format (), et sa caractéristique est que vous pouvez incorporer des variables, des formats et des expressions d'exécution dans __character strings __str.format () C'est dans __ où vous n'avez pas à écrire de manière redondante comme .
Vous pouvez déclarer des chaînes f avec le préfixe f`` et utiliser {} `comme espace réservé. Un exemple est présenté ci-dessous.
python
#Expansion variable de base
hoge = 'hogehoge'
f'string value: {hoge}' #=> 'string value: hogehoge'
Dans str.format (), ce qui a été écrit comme suit peut maintenant être écrit comme ci-dessus.
python
'string value: {hoge}'.format(hoge='hogehoge')
Je vais vous montrer comment l'utiliser de différentes manières, mais il est intéressant que les f-strings puissent être écrites de manière simplifiée car .format (...) peut être omis. (Je suis très reconnaissant d'avoir souvent été en colère contre la ligne utilisant str.format () parce que l'évaluation du style de code de PEP8 dépassait 80 caractères.)
Les variables que vous souhaitez développer peuvent être imbriquées dans {}, et vous pouvez utiliser les valeurs développées pour spécifier le format.
python
#Format
float_val = 0.123456
size = 4
f'result: {float_val:.{size}}' #=> 'result: 0.1235'
Puisqu'elle est évaluée comme une expression d'exécution dans {}, vous pouvez développer la liste et le dictionnaire, ajouter et soustraire, etc. comme suit.
python
#liste
some_list = ['foo', 'bar', 'baz']
f'list item: {some_list[0]}' #=> 'list item: foo'
#dictionnaire
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'
Vous pouvez également appeler une fonction dans {}.
python
# function
def multi(a, b):
return a * b
x = 10
y = 20
f'multi value: {multi(x, y)}' #=> 'multi value: 200'
{} Peut être cassé car ils sont entre parenthèses implicites avant l'évaluation.
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'
Vous pouvez obtenir une sortie échappée en utilisant fr au lieu de f dans le préfixe.
# raw f-strings
fr'raw output\n' #=> 'raw output\\n'
C'est un petit ajout, mais vous pouvez maintenant utiliser le trait de soulignement _ pour les littéraux numériques.
Toutefois, la position de soulignement ne peut pas être utilisée au début, à la fin ou au formulaire contigu et peut être placée entre des nombres ou après le spécificateur de base.
Certes, si ça continue avec «000000 ...», ça peut être un peu difficile à voir, mais il semble que ça va être résolu.
#Nombre décimal
decimal = 10_000_000.0
print(decimal) #=> 10000000.0
#Hexadécimal
hexadecimal = 0xCAFE_F00D
print(hexadecimal) #=> 3405705229
#Nombre binaire
binary = 0b_0011_1111_0100_1110
print(binary) #=> 16206
# binary string => int casting
binary_string = int('0b_1111_0000', 2)
print(binary_string) #=> 240
La fonction d'indication de type ajoutée dans PEP484 (Python 3.5) fournit une syntaxe d'indication de type pour les arguments formels de fonction. C'était fait. La syntaxe d'indication de type pour les variables est ajoutée à ce PEP526. Les "variables" incluent des variables de classe et des variables d'instance en plus des variables régulières.
python
from typing import List
vectors: List[float] = [0.1, 0.2]
counts: Dict[str, int] = {
'foo': 10,
'bar': 20,
'baz': 30,
}
#Les variables de classe sont également disponibles
class Foo(object):
name: str = 'foo'
En passant, ces annotations ne sont pas affectées par le résultat de cette annotation dans l'interpréteur Python, il n'y a donc pas d'avertissement sur le runtime Python. Cette fonctionnalité est désormais un outil tiers (par exemple mypy, pytype, [PyCharm] Vous devez savoir que (https://www.jetbrains.com/pycharm/, etc.) est une fonctionnalité qui vous permet de vous référer facilement aux attributs d'annotation.
url: str = ''
url = 100 #=>
print(url) #=>S'affiche comme 100 sans avertissement, etc.
PEP492 (Python 3.5) a ajouté ʻawaitetyield à la même fonction dans la syntaxe async / await Cependant, depuis la version 3.6, des générateurs asynchrones ont été pris en charge dans lesquels ʻawait et yield peuvent être utilisés pour la même fonction.
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()
Depuis la version 3.6, l'utilisation de ʻasync for` dans les listes, les ensembles, les inclusions de dictionnaire et les expressions génératrices est prise en charge. C'est un petit changement, mais je pense que c'est plus facile à écrire.
python
import asyncio
async def aiter():
n = 10
for i in range(n):
yield i
await asyncio.sleep(0.5)
#Notation d'inclusion asynchrone
async def run():
result = [i async for i in aiter() if i % 2]
print(result)
#Courir au-dessus()Même syntaxe que
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()
Comme mentionné ci-dessus, je voudrais certainement l'utiliser dans un environnement où vous n'avez pas à vous soucier de la compatibilité.
Cette fois je n'ai introduit que le changement de grammaire, mais à partir de 3.6, il y en a d'autres
--Garder l'ordre des arguments de mot-clé
Il y a des changements tels que. Pour plus de détails, reportez-vous à Nouveautés de Python 3.6.
Recommended Posts