Je vais vous présenter la grammaire python dont vous pourrez peut-être vous débarrasser si vous connaissez principalement les nouvelles fonctions.
Il s'agit d'une nouvelle syntaxe ajoutée à partir de python3.8. C'est bon de savoir quelque chose de nouveau.
Les expressions de substitution sont écrites dans la syntaxe : =, et les expressions conditionnelles et les instructions d'affectation peuvent être utilisées en même temps.
Par exemple, les expressions conditionnelles courantes suivantes
text = 'Hello New Expression!!'
text_length = len(text)
if text_length > 10:
print(f"String is too long!!({text_length} length, expected <= 10)")
Il peut être abrégé comme suit en utilisant «: =». Vous pouvez voir que ʻif (text_length: = len (text))> 10: `lit les expressions d'affectation et conditionnelles.
text = 'Hello New Expression!!'
if (text_length := len(text)) > 10:
print(f"String is too long!!({text_length} length, expected <= 10)")
refs Formule de substitution: https://www.python.org/dev/peps/pep-0572/
Je pense qu'une notation d'inclusion courante consiste à générer une liste comme celle-ci:
numbers = [1,2,3]
dubble_numbers = [x*2 for x in numbers]
print(dubble_numbers)
#[2, 4, 6]
Bien que rarement utilisées, il existe également des notations inclusives pour les dictionnaires, les ensembles et les générateurs. C'est un point du visage de doya.
--Notation d'inclusion de dictionnaire
L'écriture d'une valeur-clé comme x: x * 2 dans {} générera un dictionnaire.
numbers = [1,2,3]
dubble_number_dict = {x:x*2 for x in numbers}
print(dubble_number_dict)
#{1: 2, 2: 4, 3: 6}
Si vous n'écrivez qu'une valeur dans {} comme x, un ensemble sera généré.
numbers = [1,2,3,1,1]
dubble_number_set = {x for x in numbers}
print(dubble_number_set)
# set([1, 2, 3])
--Type de générateur
Si vous écrivez dans () comme la notation d'inclusion de liste, un générateur sera généré à la place du tuple.
numbers = [1,2,3]
dubble_number_generator = (x for x in numbers)
print(dubble_number_generator)
# <generator object <genexpr> at 0x10d7779b0>
refs Structure des données: https://docs.python.org/3.9/tutorial/datastructures.html
À partir de python3.5, il est possible de déclarer (pour être exact, annoter) le type dans le code comme un langage typé statiquement. J'ai l'impression d'abandonner les mérites d'un langage typé dynamiquement, mais quand il s'agit d'un développement compliqué, je pense que beaucoup de gens sont prudemment inquiets si les types ne sont pas explicitement déclarés. Précautions lors de l'utilisation
Le code source spécifique est le suivant.
Il est plus facile à maintenir, mais c'est une extension des commentaires et n'est pas vérifié à l'exécution.
text: str = 123 # Assignment int passe également sans erreur.
def greeting(name: str) -> str:
return f'Hello {name}'
text: str = 'Python!!'
print(greeting(text))
# Hello Python!!
text: str = 123 # Assignment int
print(greeting(text)) # No error
# Hello 123
Les outils de vérification ne sont pas fournis par défaut, vous devez donc utiliser un outil externe. Le plus célèbre est probablement «mypy». http://www.mypy-lang.org/
Il existe diverses autres règles telles que la façon de déclarer des classes définies par l'utilisateur avec des indices de type, mais je les omettrai ici.
refs: Indice de type: https://docs.python.org/3.9/library/typing.html
@ dataclass.__init__ (Correctement, le décorateur crée une méthode spéciale)Un exemple d'utilisation concret est le suivant.
from dataclasses import dataclass,asdict,astuple
@dataclass
class Person:
name: str
age: int = 0
def greeting(self) -> str:
return f"My name is {self.name}, {self.age} years old."
tanaka = Person('tanaka',18)
print(tanaka.greeting())
# My name is tanaka, 18 years old.
baby = Person('taro') # Use default value
print(baby.greeting())
# My name is taro, 0 years old.
print(asdict(baby)) # To dict object
# {'name': 'taro', 'age': 0}
print(astuple(baby)) # To tuple object
# ('taro', 0)
Il y a aussi des fonctions comme en faire un objet immuable et étendre le processus d'initialisation avec __post_init__, mais il est omis ici.
refs: dataclass: https://docs.python.org/3/library/dataclasses.html
C'est un modèle de chaîne de caractères ajouté à partir de python3.6.
C'est plus simple et plus sophistiqué que les méthodes de chaîne précédentes format () et % operator.
Plus précisément, mettez «f» »au début de la chaîne de caractères et utilisez-la comme suit.
a,b = 1000,2000
print(f'a is {a},b is {b}')
# a is 1000,b is 2000
print(f'sum of ab is {a+b}') # can be calculated
# sum of ab is 3000
print(f'a: {a:,}') # separated by comma
# a: 1,000
Comme mentionné ci-dessus, le fait que le calcul dans la chaîne de caractères est possible et le point que le formatage flexible est possible sont les points qui peuvent être ridicules.
De plus, depuis python3.8, la fonction a été étendue pour le débogage des variables.
a,b = 1000,2000
print(f'a={a},b={b}') # before 3.8
# a=1000,b=2000
print(f'{a=},{b=}') # after 3.8
# a=1000,b=2000
En insérant = après la variable, vous pouvez voir que la valeur et le nom de la variable sont affichés.
refs: Format: https://docs.python.org/3/tutorial/inputoutput.html Débuggable: https://docs.python.org/3/whatsnew/3.8.html#f-strings-support-for-self-documenting-expressions-and-debugging
Quand je travaille sur le terrain, je pense qu'il est difficile d'utiliser python2 et d'autres dettes passées, donc je suis enthousiasmé par les nouvelles fonctionnalités et je veux le réparer avec un visage burlesque.
Recommended Posts