J'ai appris un peu plus sur Python, donc je vais le résumer brièvement.
Je ne sais pas parce que c'est mon propre mémo.
Vous pouvez utiliser print pour imprimer des caractères sur la console.
example.py
print('Hello World')
#Résultat de sortie-> Hello World
Écrivez le caractère que vous souhaitez afficher dans ().
** Chaîne de caractères ** est le caractère «Hello World» dans la partie supérieure.
La chaîne doit être entourée de '', `.
Il n'y a pas de différence de sortie quel que soit celui qui est utilisé.
example.py
#Lorsqu'il est entouré de guillemets simples
print('Hello World')
#Résultat de sortie-> Hello World
#Lorsqu'il est entouré de guillemets doubles
print("Hello World")
#Résultat de sortie-> Hello World
Vous pouvez gérer des ** nombres ** ainsi que des chaînes.
Si vous souhaitez afficher un nombre, ** vous n'avez pas besoin de le mettre entre guillemets **.
S'il est placé entre guillemets, il sera affiché sous forme de chaîne de caractères.
example.py
#Numéros de sortie sous forme de nombres
print(14)
#Résultat de sortie->14 (valeur numérique)
#Numéros de sortie sous forme de chaînes
print('7')
#Résultat de sortie->7 (chaîne de caractères)
Addendum J'ai fait remarquer que je vais le corriger.
La fonction d'impression appelle la fonction str pour convertir l'argument donné en une chaîne et génère le résultat avec les guillemets supprimés. Citation: * Voir la section commentaire de cet article *
En d'autres termes, toutes les valeurs sorties par print sont de type chaîne. Je ne savais pas du tout.
Les valeurs numériques peuvent être ajoutées ou soustraites en utilisant «+» et «-». En guise de mise en garde, ** tous les nombres et symboles doivent être écrits en demi-largeur **.
Supprimons les symboles de calcul.
| symbole | En traitement |
|---|---|
| + | une addition |
| - | soustraction |
| * | Multiplier |
| / | division |
| % | Afficher le reste de la division |
example.py
#une addition
print(5 + 3)
#Résultat de sortie-> 8
#soustraction
print(10 - 8)
#Résultat de sortie-> 2
#Multiplier
print(2 * 5)
#Résultat de sortie-> 10
#division
print(6 / 2)
#Résultat de sortie-> 3
#Calcul du reste
print(10 % 3)
#Résultat de sortie-> 1
Lors de la sortie du résultat du calcul, vous devez faire attention à la présence ou à l'absence de cotations.
example.py
print(2 + 4)
#Résultat de sortie-> 6
print('2 + 4')
#Résultat de sortie-> 2 + 4
S'il n'est pas inclus entre guillemets, le résultat du calcul sera affiché. En revanche, lorsqu'il est placé entre guillemets, «2 + 4» est interprété comme une chaîne de caractères et affiché tel quel.
Les données peuvent être affectées à des ** variables **.
Les variables sont définies avec nom de variable = valeur. Les noms de variables n'ont pas besoin d'être placés entre «» «ou« »».
En Python, = signifie affecter le côté droit au côté gauche.
Il y a quelques points à garder à l'esprit lors de la dénomination des variables.
_example.py
#Affectation de chaîne
name = 'Fukumoto Taichi'
#Substitution numérique
age = 22
#Lorsque le nom de la variable comprend 2 mots ou plus
first_name = 'Taï chi'
Dans l'exemple ci-dessus, "Taichi" est attribué au "nom" et "22 est attribué à" l'âge ".
Récupérons maintenant les variables définies dans l'exemple ci-dessus.
Lors de l'impression d'une valeur utilisant un nom de variable, utilisez print (variable name). Les noms de variable n'ont pas besoin d'être inclus entre `` '' '.
example.py
name = 'Fukumoto Taichi'
#Sortie des variables
print(name)
#Résultat de sortie->Fukumoto Taichi
De cette manière, la valeur affectée à la variable est sortie.
En utilisant des variables, il devient clair ce que représente le contenu des données que vous traitez. Cela rend le code plus facile à lire. Il présente également l'avantage que les mêmes données peuvent être utilisées à plusieurs reprises, et il y a peu de corrections lors des corrections telles que des valeurs numériques.
La valeur de la variable peut être mise à jour.
Vous pouvez remplacer la valeur d'une variable en faisant nom de variable = nouvelle valeur.
example.py
age = 22
print(age)
#Résultat de sortie-> 22
#Mettre à jour la valeur d'âge
age = 30
print(age)
#Résultat de sortie-> 30
Vous pouvez également mettre à jour la valeur en ajoutant ou en soustrayant les nombres déjà définis.
example.py
age = 22
print(age)
#Résultat de sortie-> 22
age = age + 8
print(age)
#Résultat de sortie-> 30
Il existe des abréviations lors de la mise à jour des nombres. Les abréviations sont résumées ci-dessous.
| la norme | Abréviation |
|---|---|
| x = x + 1 | x += 1 |
| x = x – 1 | x -= 1 |
| x = x * 1 | x *= 1 |
| x = x / 1 | x /= 1 |
| x = x %1 | x %= 1 |
Il existe différents types de données à gérer.
Ici, vous apprendrez "** type de chaîne " et " type numérique **".
Ce qui a été affiché en le mettant entre `` '' est ** type chaîne de caractères **.
D'autre part, les nombres tels que «2» et «14» sont appelés ** type numérique **.
example.py
print(100)
#Résultat de sortie-> 100
print('100')
#Résultat de sortie-> 100
Le résultat de sortie n'est pas visible, mais le premier est un type numérique et le second est un type chaîne de caractères.
De là, nous allons en apprendre davantage sur la concaténation de chaînes.
Vous pouvez concaténer des chaînes en utilisant «+».
example.py
first_name = 'Taï chi'
last_name = 'Fukumoto'
#Concaténer les chaînes de caractères et la sortie
print('Mon nom complet est' + last_name + first_name + 'est')
#Résultat de sortie->Mon nom complet est Taichi Fukumoto
En écrivant comme dans l'exemple ci-dessus, vous pouvez concaténer des chaînes, des chaînes et des variables, ou des combinaisons de variables.
Une chose à noter ici est que ** les variables doivent être de type string **.
En d'autres termes, ** ne peut être concaténé qu'avec le même type de données **.
Regardons l'exemple suivant.
example.py
print(3 + 7)
#Résultat de sortie-> 10
print('3' + '7')
#Résultat de sortie-> 37
print('3' + 7)
#Résultat de sortie-> Type Error
Puisque le code de la première ligne est écrit en caractères numériques, le résultat de la formule de calcul est sorti. Puisque le code de la deuxième ligne est écrit en type chaîne de caractères, «37», qui est une concaténation de la chaîne de caractères «3» et de la chaîne de caractères «7», est affiché. Le code de la troisième ligne utilise un type de chaîne de caractères et un type de colonne numérique, une erreur s'est donc produite.
J'ai appris que la concaténation ne peut être effectuée qu'entre les types de chaînes.
Alors, comment concaténer des variables auxquelles un type numérique a été attribué sous forme de chaîne?
example.py
name = 'Taï chi'
age = 22
Apprenez à utiliser ces variables pour afficher «Taichi a 22 ans».
La conversion de type est effectuée lors de la concaténation de variables de type numérique sous forme de chaîne de caractères.
Utilisez str pour convertir un type numérique en type chaîne.
Vous pouvez le convertir en type numérique en le définissant sur str (type numérique).
example.py
name = 'Taï chi'
age = 22
print(name + 'Est' + str(age) + 'Je suis vieux.')
#Résultat de sortie->Taichi a 22 ans
La variable «age» a été convertie en un type de chaîne par «str», donc la sortie s'est faite sans erreur.
Contrairement à l'exemple précédent, utilisez int pour convertir un type chaîne en type numérique.
Comme str, vous pouvez le convertir en type numérique en utilisant int (type de chaîne).
Regardons un exemple.
example.py
count = '5'
price = 200
total_price = price * int(count)
print(total_price)
#Résultat de sortie-> 1000
Puisque «5» est assigné comme type de chaîne de caractères à «count», le processus est exécuté sans provoquer d'erreur en le convertissant en type numérique et en le calculant.
Nous en apprendrons davantage sur le branchement conditionnel, qui ne traite que lorsqu'une certaine condition est remplie.
Avant d'apprendre la syntaxe de branchement conditionnel, découvrons "** booléen " et " opérateur de comparaison **".
Tout d'abord, nous allons découvrir la ** valeur de vérité **.
Exécutez un code similaire à ce qui suit.
example.py
age = 20
print(age == 20)
#Résultat de sortie-> True
== est un opérateur de comparaison qui compare si les deux côtés sont égaux. Les opérateurs de comparaison sont expliqués ensemble.
Alors quelle est exactement la sortie "True" à ce moment?
Ce "True" est ce qu'on appelle une valeur booléenne. Les types de données qui gèrent les valeurs booléennes sont classés en «** type booléen **», et il existe deux types, «True» et «False». Si la partie de l'expression conditionnelle utilisant l'opérateur de comparaison est vérifiée, elle devient «True», et si elle ne l'est pas, elle devient «False».
Jetons un coup d'œil à l '"** opérateur de comparaison **" qui est sorti plus tôt.
L '** opérateur de comparaison ** est un symbole ** utilisé pour comparer l'égalité et la magnitude des valeurs **.
Les opérateurs de comparaison suivants existent.
| opérateur | sens |
|---|---|
| a == b | Vrai quand a est égal à b |
| a != b | Vrai quand a n'est pas égal à b |
| a > b | Vrai quand a est supérieur à b |
| a < b | Vrai quand a est inférieur à b |
| a >= b | Vrai quand a est supérieur ou égal à b |
| a <= b | Vrai quand a est inférieur ou égal à b |
Cet opérateur de comparaison apparaît dans l'instruction conditionnelle au moment du branchement conditionnel, assurez-vous donc de le supprimer.
Regardons maintenant le code de branchement conditionnel.
Avec ** if **, il est possible ** de traiter uniquement sous certaines conditions **.
Regardons la syntaxe.
si expression conditionnelle:
En traitement
Spécifiez l '«expression conditionnelle» après le «if» et écrivez le «processus» à exécuter lorsque la condition est satisfaite sur la ligne suivante. Veuillez noter que ** le traitement doit être indenté **.
Regardons un exemple.
example.py
age = 22
if age >= 20:
print('Vous pouvez boire')
#Résultat de sortie->Vous pouvez boire
Dans l'exemple ci-dessus, la partie de age> = 20 est l'expression conditionnelle.
Dans l'expression conditionnelle ci-dessus, "** Si la valeur de l'âge est de 20 ou plus **" devient "True".
Puisque «22» est attribué à «age» et que l'expression conditionnelle devient «True», le traitement suivant «print (« you can drink »)» est exécuté. Regardons l'exemple suivant.
example.py
age = 19
if age >= 20:
print('Vous pouvez boire')
#Résultat de sortie->Vous pouvez boire
Dans l'exemple ci-dessus, il n'y a pas de retrait dans la partie de traitement. En conséquence, un traitement qui n'aurait pas dû être effectué a été effectué.
Attention aux indentations.
else
En combinant ** else ** avec l'instruction if, vous pouvez" effectuer un autre processus ** si les conditions de l'instruction ** if ne sont pas remplies ** ".
La syntaxe est la suivante:
si expression conditionnelle:
En traitement
else:
En traitement
Après avoir traité if, écrivez else: et écrivez traitement sur la ligne suivante.
N'oubliez pas que vous avez besoin de «:» après «else». Faites également attention à l'indentation ainsi qu'à l'instruction if.
Regardons un exemple concret.
example.py
age = 19
if age >= 20:
print('Vous pouvez boire')
else:
print('Depuis que j'ai 20 ans')
#Résultat de sortie->Depuis que j'ai 20 ans
Dans l'exemple concret, «19» est affecté à «age», donc la condition du bloc «if» n'est pas satisfaite.
Par conséquent, le processus décrit dans «else» est exécuté.
elif
Utilisez ** elif ** si vous souhaitez définir plusieurs ** expressions conditionnelles qui ne tiennent pas dans l'instruction if.
La syntaxe est la suivante:
si expression conditionnelle:
En traitement
expression conditionnelle elif:
En traitement
else:
En traitement
Ajoutez un bloc elif entre le if et le else.
La méthode d'écriture est la même que pour if, write expression conditionnelle: after` elif ', et écris le processus sur la ligne suivante.
Vous pouvez écrire autant de elifs que vous le souhaitez.
Cependant, il est jugé si les conditions sont satisfaites dans l'ordre à partir du haut, et seule la partie qui remplit les conditions est traitée en premier **.
Lorsque vous écrivez des conditions en utilisant elif, vous devez faire attention à l'ordre des conditions.
Regardons un exemple concret.
example.py
number = 0
if number > 0:
print('Est positif')
elif number == 0:
print('0')
else:
print('Négatif')
#Résultat de sortie->0
Puisque «0» est attribué à «nombre», la condition de «elif», «nombre == 0», est satisfaite.
Par conséquent, le processus décrit dans «elif» est exécuté.
Puisque le traitement de «elif» a été exécuté, le traitement se termine ici.
and
En combinant plusieurs expressions conditionnelles à l'aide de et, il est possible d'exécuter le processus lorsque" ** La condition 1 et la condition 2 sont satisfaites ** ".
si expression conditionnelle 1 et expression conditionnelle 2:
En traitement
Lorsque «et» est utilisé, lorsque toutes les expressions conditionnelles sont «True», le tout devient «True» et le processus est exécuté.
or
En combinant plusieurs expressions conditionnelles à l'aide de ou, vous pouvez exécuter le processus lorsque" ** La condition 1 ou la condition 2 est satisfaite ** ".
si expression conditionnelle 1 ou expression conditionnelle 2:
En traitement
Lorsque «ou» est utilisé, si même l'une des multiples expressions conditionnelles est «True», le tout devient «True» et le processus est exécuté.
not
Vous pouvez utiliser not pour ** annuler une condition **.
Le traitement est exécuté lorsque l'expression conditionnelle n'est pas «True». En d'autres termes, si vous faites quelque chose comme «expression non conditionnelle», ** si l'expression conditionnelle est «Vrai», l'ensemble sera «Faux» **.
sinon expression conditionnelle:
En traitement
Utilisez «** List **» pour gérer plusieurs données.
Les listes sont créées en utilisant «[]», comme «[〇〇, △△,…]». Chaque valeur de la liste est appelée un "** élément **".
De plus, comme la liste est également une valeur unique, elle peut être affectée à une ** variable **.
example.py
names = ['Yamada', 'Tanaka', 'Suzuki']
print(names)
#Résultat de sortie-> ['Yamada', 'Tanaka', 'Suzuki']
Lorsque vous sortez, la liste est sortie telle quelle. En outre, il est courant d'utiliser des formes plurielles pour les variables.
Les éléments de la liste sont numérotés "** 0, 1, 2, ... " dans l'ordre de face. Ceci est appelé " numéro d'index **".
Dans l'exemple ci-dessus, `` Yamada '' est l'élément avec le numéro d'index 0.
Chaque élément de la liste peut être obtenu en utilisant la liste nom de la liste [numéro d'index].
example.py
names = ['Yamada', 'Tanaka', 'Suzuki']
print('Il' + names[0] + 'M. est.')
#Résultat de sortie->C'est M. Yamada.
Dans names [0], l'élément avec le numéro d'index 0 de l'élément est récupéré, donc Yamada est entré.
Vous pouvez mettre à jour les éléments de la liste en définissant ** list [numéro d'index] = valeur **.
C'est comme spécifier l'emplacement que vous souhaitez mettre à jour et réaffecter.
Regardons un exemple concret.
example.py
names = ['Yamada', 'Tanaka', 'Suzuki']
names[2] = 'Sato'
print(names)
#Résultat de sortie-> ['Yamada', 'Tanaka', 'Sato']
Mise à jour de l'élément avec le numéro d'index 2. Vous pouvez voir que les valeurs ont été mises à jour dans la liste de sortie.
Ensuite, ajoutons une valeur à la liste.
** Il est possible d'ajouter un nouvel élément à la liste déjà définie ** en le définissant sur list.append (value) **.
Regardons un exemple concret.
example.py
names = ['Yamada', 'Tanaka', 'Suzuki']
names.append('Sato')
print(names)
#Résultat de sortie-> ['Yamada', 'Tanaka', 'Suzuki', 'Sato']
L'élément est ajouté à la ** fin de la liste **.
Même dans l'exemple concret, vous pouvez voir que la liste avec Sato ajouté à la fin de la liste est sortie.
«** Dictionary **» est également utilisé pour gérer plusieurs données ensemble.
Contrairement aux listes, les dictionnaires gèrent les numéros d'index en leur donnant à la place un nom appelé «** key **».
Le dictionnaire est défini comme ** {clé 1: valeur 1, clé 2: valeur 2,…} **.
En général, une chaîne de caractères est utilisée pour la clé.
example.py
names = {'Yamada': 22, 'Tanaka': 40, 'Suzuki': 33}
print(names)
#Résultat de sortie-> {'Yamada': 22, 'Tanaka': 40, 'Suzuki': 33}
Puisque les éléments du dictionnaire n'ont pas d'ordre, l'ordre des éléments peut être différent de ce que vous avez défini lors de la sortie.
Vous pouvez récupérer les éléments du dictionnaire en utilisant la clé que vous voulez récupérer et en utilisant le nom du dictionnaire ['clé'].
example.py
names = {'Yamada': 22, 'Tanaka': 40, 'Suzuki': 33}
print('Il' + str(names['Tanaka']) + 'Je suis vieux.')
#Résultat de sortie->Il a 40 ans
C'est fondamentalement la même chose que la mise à jour de la liste.
Utilisez ** clé ** au lieu du numéro d'index.
example.py
names = {'Yamada': 22, 'Tanaka': 40, 'Suzuki': 33}
#Mettre à jour la valeur
names['Tanaka'] = 50
print('Il' + str(names['Tanaka']) + 'Je suis vieux.')
#Résultat de sortie->Il a 50 ans
J'ai pu confirmer que la valeur a été mise à jour.
Lors de l'ajout d'un élément à un dictionnaire, définissez une nouvelle clé et attribuez-lui une valeur, telle que nom du dictionnaire ['nouvelle clé'] = valeur.
example.py
names = {'Yamada': 22, 'Tanaka': 40, 'Suzuki': 33}
names['Sato'] = 15
#Dictionnaire de sortie
print(names)
#Résultat de sortie-> {'Yamada': 22, 'Tanaka': 40, 'Suzuki': 33, 'Sato': 15}
#Sortie des éléments nouvellement ajoutés
print('Il' + str(names['Sato']) + 'Je suis vieux.')
#Résultat de sortie->Il a 15 ans
Des éléments ont été ajoutés et peuvent être spécifiés et récupérés.
Nous en apprendrons davantage sur "** for statement " et " while statement **" qui sont des processus itératifs de Python.
Si vous souhaitez récupérer tous les éléments de la liste un par un, spécifier les numéros d'index un par un peut être très fastidieux.
En utilisant "** for statement ", vous pouvez effectuer un " traitement itératif **".
L'instruction for est décrite comme ** for variable name in list name: **.
Les éléments de la liste sont entrés dans le nom de la variable un par un à partir du début, puis le traitement dans l'instruction for est exécuté.
Regardons un exemple concret.
example.py
names = ['Yamada', 'Tanaka', 'Suzuki']
for name in names:
print('Il' + name + 'M. est.')
#Résultat de sortie->
C'est M. Yamada.
C'est M. Tanaka.
C'est M. Suzuki.
De cette manière, le traitement de sortie dans l'instruction for est effectué dans l'ordre à partir du haut de la liste. En outre, les noms de variables sont généralement sous la forme singulière de noms de liste.
De même, en utilisant l'instruction for dans le dictionnaire, il est possible de récupérer les éléments un par un et d'exécuter le processus itératif.
Dans le cas d'un dictionnaire, l'instruction for est décrite comme ** for 〇〇_key dans le nom du dictionnaire: **.
Regardons un exemple concret.
example.py
names = {'Yamada': 22, 'Tanaka': 40, 'Suzuki': 33}
for name_key in names:
print(name_key + 'Est' + str(names[name_key]) + 'Je suis vieux.')
#Résultat de sortie->
M. Yamada a 22 ans.
M. Tanaka a 40 ans.
Suzuki a 33 ans.
De cette manière, les éléments du dictionnaire pourraient également être récupérés avec l'instruction for.
Un autre processus itératif est l'instruction "** while **".
Vous pouvez utiliser l'instruction while pour "** répéter le processus pendant qu'une certaine condition est remplie **".
Regardons la syntaxe.
example.py
tandis que l'expression conditionnelle:
Traitement avec mise à jour de la valeur
Écrivez comme «while expression conditionnelle:», puis indentez et écrivez le processus. La partie traitement inclut toujours le traitement pour mettre à jour la valeur.
Regardons un exemple concret.
example.py
x = 1
while x <= 5:
print(x)
x += 1
#Résultat de sortie->
1
2
3
4
5
En regardant l'exemple, la partie de l'expression conditionnelle est "" x "est inférieur ou égal à" 5 "". Le traitement dans l'instruction while est "** x value ** output ** "puis" ** x plus" 1` ** ".
Après la sortie de «5», «1» est ajouté, la valeur de «x» devient «6» et la condition n'est plus satisfaite, le processus se termine donc.
Par conséquent, le processus est répété jusqu'à ce que «x» devienne «5».
Dans l'instruction while, si vous oubliez de mettre à jour la valeur de la variable à la fin du processus, ou si le retrait est incorrect, l'expression conditionnelle sera toujours «True», et ** elle sera répétée indéfiniment **.
Faites attention.
break
En utilisant break, il est possible de" ** forcer l'arrêt ** "du processus itératif.
break est utilisé en combinaison avec des branches conditionnelles telles que l'instruction if.
Regardons un exemple concret.
example.py
numbers = [1, 2, 3, 4, 5]
for number in numbers:
print(number)
if number == 4:
break
#Résultat de sortie->
1
2
3
4
Jetons un coup d'œil au code.
L'expression conditionnelle de l'instruction if est "quand elle devient 4". Il est exécuté lorsque «break» est écrit dans le bloc «if» et que la condition est remplie.
Par conséquent, le traitement est terminé sans afficher "5".
continue
Vous pouvez utiliser ** continue ** pour ignorer le traitement si ** les conditions sont remplies **.
Il est utilisé en combinaison avec une ramification conditionnelle comme «break».
example.py
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for number in numbers:
if number % 2 == 0:
continue
print(number)
#Résultat de sortie->
1
3
5
7
9
Puisque la partie d'expression conditionnelle de if est" ** lorsque le nombre est divisible par 2 ** ", ** le traitement pair est ignoré et seuls les nombres impairs sont affichés **.
J'ai essayé de résumer tout de suite. Le code en Python est simple et facile à lire.
Merci d'avoir lu jusqu'à la fin.