Fermer

janvier 8, 2023

Formatage de chaînes en Python

Formatage de chaînes en Python


Comment les littéraux de modèle JavaScript se comparent-ils au formatage de chaîne Python ? Nous allons jeter un coup d’oeil!

Je suis super excité d’apprendre Python. Il semble assez naturel de comparer Python aux langages que je connais (JavaScript et TypeScript) et de remarquer les similitudes et les différences dans leur syntaxe et leurs fonctionnalités.


Crédit image : @Dakar_Jaxtyn

Dans cette série d’articles en deux parties, nous examinerons le formatage des chaînes en Python et le comparerons aux littéraux de modèle en JavaScript. Le formatage de chaîne fait référence à la possibilité de remplacer des parties d’une chaîne par des valeurs contenues dans des variables ou des expressions.

Chaînes en Python

Avant de parler du formatage des chaînes, il convient de souligner quelques éléments concernant les chaînes en général en Python. N’hésitez pas à sauter cette section si vous êtes déjà familiarisé avec les chaînes en Python.

Nous pouvons créer des littéraux de chaînes de différentes manières. On peut utiliser:

  1. Guillemets simples
name = 'Monty'
  1. Double citation
name = "Python"
  1. Citations triples
trivia = """
Question: Which BBC commedy series is the Python language named after?

Answer: Monty Python's Flying Circus.
"""

Nous utilisons des guillemets triples pour créer des chaînes multilignes et également pour créer docstrings.

  1. Les str() méthode

Nous utilisons str() pour obtenir une représentation sous forme de chaîne d’un objet.

>>> 'Hello, Number ' + str(5)
'Hello, Number 5'

Contrairement à JavaScript, nous ne pouvons pas concaténer un entier à une chaîne en Python, sinon nous obtiendrons une TypeError : can only concatenate str (not « int ») to str.

  1. Les repr() méthode

Semblable à str()nous utilisons repr() pour obtenir une représentation sous forme de chaîne d’un objet. Typiquement, le repr() renvoie une chaîne qui peut être exécutée et donne la même valeur que l’objet. Cela signifie qu’une chaîne sera mise entre guillemets.

>>> print(f"Hello, {repr('Monty')} Python!")
Hello, 'Monty' Python!

Les chaînes, comme toutes les autres variables, sont des objets en Python. Les variables de chaîne que nous avons créées ci-dessus sont des objets de classe str.

print(type('Hi')).

Les str la classe a beaucoup de méthodes utilesencore plus que JavaScript.

Formatage de chaînes à l’aide de la syntaxe %

« %” est la syntaxe originale pour formater les chaînes en Python. Nous utilisons %s comme espace réservé pour une variable dans le littéral de chaîne et fournissez la variable après la chaîne en utilisant % variable_name.

Dans notre exemple de code simple ci-dessous, nous demandons à l’utilisateur d’entrer une saveur et de stocker son entrée dans une variable. Nous affichons ensuite cette variable dans le cadre d’une chaîne.

milkshake_flavours = ['strawberry', 'tropical fruit', 'chocolate', 'bubblegum']
order = input('Please choose a flavour: ')
 
print('Here is you %s milkshake. Enjoy!' % order)

Le code semble assez soigné avec une seule variable. Et si nous voulions permettre à nos clients de choisir différentes saveurs pour créer leurs propres coupes glacées ? Nous aurions besoin de plus de variables, une pour chaque sélection.

C’est très bien – nous pouvons inclure plusieurs %s comme espaces réservés dans la chaîne et fournissez les variables entre parenthèses après le % pancarte.

Ceci est illustré par le code suivant :

icecream_selection = ['strawberry', 'vanilla', 'chocolate']
jelly_selection = ['lime', 'orange', 'strawberry', 'raspberry', 'blackcurrant']
fruit_selection = ['peaches', 'raspberries', 'blueberries', 'blackberries', 'bananas', 'crushed pineapple', 'mixed fruits']
nut_selection = ['hazelnut', 'peanut', 'pistachio']
sauce_selection = ['chocolate', 'strawberry', 'caramel', 'hot fudge', 'butterscotch']
topping_selection = ['marachino cherry', 'sprinkles', 'marshmallows']

print("""Create your sundae.
Please enter your selections for:""")

icecream =  input('Icecream: ')
fruit = input('Fruits: ')
jelly = input('Jelly: ')
sauce = input('Sauce: ')
nuts = input('Nuts: ')
topping = input('Toppings: ')

print("""
Here's your sundae:

%s icecream with: 
%s, 
%s jelly, 
%s sauce, 
%s, 
and %s on top. 

Enjoy!
""" % (icecream, fruit, jelly, sauce, nuts, topping))

Cependant, l’affichage d’un certain nombre de variables dans notre chaîne a rendu sa lecture et sa maintenance plus difficiles. De plus, nous devons nous assurer que les variables sont fournies dans le bon ordre pour correspondre à leurs correspondants. %s dans la chaîne. Avec autant de variables, c’est une tâche plus fastidieuse et sujette aux erreurs.

Formatage des chaînes à l’aide de str.format() Méthode

Les string.format() a été introduit dans Python 2.6 comme une amélioration de la %s syntaxe. Nous utilisons {} comme espaces réservés dans notre littéral de chaîne, puis appelez le format() méthode passant des expressions. Les
format() La méthode renvoie une version formatée de la chaîne en remplaçant les espaces réservés par les valeurs de ses arguments.

Par example:

print("""
Here is your sundae:
	{} icecream with 
	{}, 
	{} jelly, 
	{} sauce, 
	{}, and
	{} on top
""".format(icecream, fruit, jelly, sauce, nuts, topping))

On peut aussi référencer les variables par leur indice. Cela nous permet d’afficher les variables dans un ordre différent de celui dans lequel elles ont été transmises. Notez que dans le code ci-dessus, lorsque nous n’avons pas fourni l’index, la valeur par défaut est {0}, {1}, {2}, {3 }, {4}, {5}.

print("""
Here is your sundae:
	{0} icecream with 
	{4}, 
	{2} jelly, 
	{3} sauce, 
	{1},
	topped with cream and {5}.
""".format(icecream, nuts, jelly, sauce, fruit, topping))

Même si spécifier des index nous permet d’utiliser les arguments dans un ordre différent de celui dans lequel ils ont été passés, si nous avons pas mal d’arguments, la chaîne est plus difficile à lire.

Nous pouvons résoudre ce problème en passant à la place des arguments de mots clés nommés.

print("""
Here is your sundae:
	{icecream} icecream with 
	{fruit}, 
	{jelly} jelly, 
	{sauce} sauce, 
	{nuts},
	with cream and {topping} on top.
""".format(icecream=icecream, nuts=nuts, fruit=fruit, jelly=jelly, sauce=sauce,  topping=topping))

Nous pouvons rendre le code ci-dessus encore plus lisible en plaçant nos options dans un dictionnaire, puis en utilisant ** syntaxe pour déstructurer (décompresser) les paires clé-valeur du dictionnaire en arguments de mots-clés. Le code ci-dessous illustre ceci :

order = {
	'icecream': icecream,
	'topping': topping,
	'sauce': sauce,
	'fruit': fruit,
	'jelly': jelly,
	'nuts': nuts,
}

print("""
Here is your sundae:
	{icecream} icecream with 
	{fruit}, 
	{jelly} jelly, 
	{sauce} sauce, 
	{nuts},
	cream, and 
	{topping} on top.
""".format(**order))

Donc format(**order) devient format(icecream=icecream, topping=topping, sauce=sauce, fruit=fruit, jelly=jelly, nuts=nuts).

Si vous trouvez qu’il est difficile de voir pourquoi cela fonctionne, rappelez-vous que nous passons dans les expressions à la format() méthode. Par example:

>>> my_string = '{} * {} = {}'.format(3, 6, 3 * 6)
>>> my_string
'3 * 6 = 18'

Les format() méthode est certainement une amélioration par rapport à la %s syntaxe de formatage des chaînes. Cependant, ce n’est ni le dernier ni le meilleur. Néanmoins, il est important de connaître les format() car nous rencontrerons probablement du code qui l’utilise. Quelle est la dernière façon de formater une chaîne en Python alors ? Découvrons ensuite.

Formatage de chaînes à l’aide des littéraux de chaîne formatés (f)

Les littéraux de chaîne formatés introduits dans Python 3 constituent le moyen le plus récent et le plus simple de formater des chaînes en Python.

Nous mettons la lettre f ou alors F devant un littéral de chaîne et spécifiez des expressions entre accolades {} dans la chaîne. Les expressions dans les littéraux formatés peuvent accéder directement aux variables dans l’espace de noms. Ce qui signifie que nous n’avons plus besoin de transmettre d’arguments ni de nous soucier de faire correspondre les espaces réservés aux arguments. En conséquence, notre code est plus concis, plus facile à lire et plus facile à maintenir. Yay! Les littéraux de chaîne formatés sont similaires aux littéraux de modèle en JavaScript.

print(f"""
icecream =  input('Icecream: ')
fruit = input('Fruits: ')
jelly = input('Jelly: ')
sauce = input('Sauce: ')
nuts = input('Nuts: ')
topping = input('Toppings: ')

Here is your sundae:
	{icecream} icecream with 
	{fruit}, 
	{jelly} jelly, 
	{sauce} sauce, 
	{nuts},
	cream, and 
	{topping} on top.
""")

Bien sûr, si nous avons utilisé un nom de variable dans une expression qui n’est pas dans l’espace de noms, nous obtiendrons une erreur.

Notez également que nous pouvons utiliser des littéraux de chaîne formatés avec :

  • Guillemets simples f'expression',
  • Double citation f"{expression}"ou alors
  • Citations triples f"""{expression}"""

Mais ce n’est pas tout! En plus de l’interpolation de chaîne, nous pouvons formater les valeurs dans les littéraux de chaîne à l’aide du mini-langage de spécification de format de Python. Regardons cela ensuite.

Mini-langage de spécification de format

Nous pouvons éventuellement spécifier la conversion de type et format_spec options dans une chaîne formatée ou une chaîne avec format() méthode.

Exemple:

>>> price = 0.30
>>> price
0.3

>>> f'{price:.2f}'
'0.30'

>>> '{:.2f}'.format(price)
'0.30'

Un point d’exclamation indique une conversion et deux-points indique une format_spec option.

f'{expression!conversion:format_spec}'

La conversion de type est effectuée avant le formatage de la chaîne. !s applique la str(value) méthode à une valeur, tandis que !r applique la repr(value) méthode.

Par exemple, si nous voulions formater une chaîne entre guillemets, nous utiliserions le !r modificateur. Dans le code ci-dessous, nous avons défini le __str__() méthode. Cela nous permet d’imprimer les détails d’une instance de classe d’une manière plus lisible. Nous avons utilisé
!r dans une chaîne littérale formatée pour mettre des guillemets autour du texte « crème fraîche ».

class Sundae:
	def __init__(self, icecream, sauce, topping):
		self.icecream = icecream
		self.sauce = sauce
		self.topping = topping

	def __str__(self):
		return f'{self.icecream.capitalize()} icecream with {'fresh cream'!r}, {self.sauce} sauce and {self.topping} on top.'

order1 = Sundae('strawberry', 'chocolate', 'cherries')
print(f'{order1}')


"Strawberry icecream with 'fresh cream', chocolate sauce and cherries on top."

Les format_spec les options incluent :

f'{expression:[[fill]align][sign][#][0][width][grouping_option][.precision][type]}'

L’exemple de code ci-dessous illustre l’utilisation des options fill, align, width, precision et type format_spec.

width = 50
price_list = [
	{'item': 'Milkshake', 'price': 5.70}, 
	{'item': 'Wafles and Cookie Dough', 'price': 5.50}, 
	{'item': 'Create your Own', 'price': 9.95}, 
	{'item': 'Waffle Pop', 'price': 4.00}
]

price_message = f"""
{'-':-^{width}}
{'Mayas Treats':^{width}}
{'-':-^{width}}

Price List:

"""

for product in price_list:
	price_message += f"\n{product['item']:.<45}£{product['price']:.2f}"

Impressions :

--------------------------------------------------
                   Mayas Treats                   
--------------------------------------------------

Price List:
Milkshake....................................£5.70
Wafles and Cookie Dough......................£5.50
Create your Own..............................£9.95
Waffle Pop...................................£4.00

Voici une explication du mini-langage utilisé dans le code ci-dessus :

  • f'{'-':-^{width}}' – dit de centrer le texte « – » dans la largeur spécifiée (50) et de remplir l’espace avec le texte donné (également « -« ). Le résultat est de 50 tirets (tirets occupant 50 caractères).

  • f'{'Mayas Treats':^{width}}' – centre « Mayas Treats » dans une largeur de 50. Comme je n’ai pas spécifié de caractère de remplissage, nous obtenons l’espace par défaut.

  • f'{product['price']:.2f}' – affiche le prix sous forme de flotteur avec une précision de 2 chiffres après la virgule. La précision par défaut est de 6 chiffres.

Prière de se référer à Documents Python pour apprendre plus.

J’espère que cet article a été utile ou inspirant d’une manière ou d’une autre.



Le meilleur outil 2023 pour ta croissance Instagram !



Source link

janvier 8, 2023