Le site de programmation du concours AtCoder a "AtCoder Programming Guide for beginners (APG4b)" comme matériel de programmation d'introduction. Il y a. C'est un matériel de programmation très complet et d'introduction et utilise C ++, le langage courant de la programmation compétitive. Donc, dans cet article, j'ai écrit une version Python d'APG4b basée dessus. En gros, veuillez lire APG4b et reportez-vous à cet article pour les parties uniques à Python.
La plupart d'entre eux sont basés sur APG4b, donc si vous trouvez cet article problématique, supprimez-le immédiatement.
Le titre de chaque section est un lien vers la famille principale. Étant donné que les titres de section sont adaptés à la famille d'origine, il existe quelques différences par rapport à la terminologie Python.
1.00. Introduction [1.01. Résultats et commentaires](https://qiita.com/saba/items/b9418d7b54cce4b106e4#101%E5%87%BA%E5%8A%9B%E3%81%A8%E3%82%B3%E3% 83% A1% E3% 83% B3% E3% 83% 88) [1.02. Comment écrire un programme et les erreurs](https://qiita.com/saba/items/b9418d7b54cce4b106e4#102%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9% E3% 83% A0% E3% 81% AE% E6% 9B% B8% E3% 81% 8D% E6% 96% B9% E3% 81% A8% E3% 82% A8% E3% 83% A9% E3% 83% avant JC) [1.03. Quatre règles et priorité](https://qiita.com/saba/items/b9418d7b54cce4b106e4#103%E5%9B%9B%E5%89%87%E6%BC%94%E7%AE%97% E3% 81% A8% E5% 84% AA% E5% 85% 88% E9% A0% 86% E4% BD% 8D) 1.04. Variables et types [1.05. Ordre d'exécution et saisie](https://qiita.com/saba/items/b9418d7b54cce4b106e4#105%E5%AE%9F%E8%A1%8C%E9%A0%86%E5%BA%8F%E3 % 81% A8% E5% 85% A5% E5% 8A% 9B) [Instruction 1.06.if / opérateur de comparaison / opérateur logique](https://qiita.com/saba/items/b9418d7b54cce4b106e4#106if%E6%96%87%E6%AF%94%E8%BC%83%E6 % BC% 94% E7% AE% 97% E5% AD% 90% E8% AB% 96% E7% 90% 86% E6% BC% 94% E7% AE% 97% E5% AD% 90) [1.07. Résultat de l'expression conditionnelle et type booléen](https://qiita.com/saba/items/b9418d7b54cce4b106e4#107%E6%9D%A1%E4%BB%B6%E5%BC%8F%E3%81% AE% E7% B5% 90% E6% 9E% 9C% E3% 81% A8bool% E5% 9E% 8B) [1.08. Portée des variables](https://qiita.com/saba/items/b9418d7b54cce4b106e4#108%E5%A4%89%E6%95%B0%E3%81%AE%E3%82%B9%E3% 82% B3% E3% 83% BC% E3% 83% 97) [1.09. Opérateur d'affectation composite](https://qiita.com/saba/items/b9418d7b54cce4b106e4#109%E8%A4%87%E5%90%88%E4%BB%A3%E5%85%A5%E6 % BC% 94% E7% AE% 97% E5% AD% 90) [1.10. while statement](https://qiita.com/saba/items/b9418d7b54cce4b106e4#110 while%E6%96%87) 1.11.for phrase / break / continue [1.12. Chaîne de caractères (et caractères)](https://qiita.com/saba/items/b9418d7b54cce4b106e4#112%E6%96%87%E5%AD%97%E5%88%97%E3%81%A8 % E6% 96% 87% E5% AD% 97) [1.13. Liste (séquence)](https://qiita.com/saba/items/b9418d7b54cce4b106e4#113%E3%83%AA%E3%82%B9%E3%83%88%E9%85%8D%E5 % 88% 97) [1.14. Fonctions intégrées de la bibliothèque standard (fonctions STL)](https://qiita.com/saba/items/b9418d7b54cce4b106e4#114%E6%A8%99%E6%BA%96%E3%83%A9%E3 % 82% A4% E3% 83% 96% E3% 83% A9% E3% 83% AA% E3% 81% AE% E7% B5% 84% E3% 81% BF% E8% BE% BC% E3% 81 % BF% E9% 96% A2% E6% 95% B0stl% E3% 81% AE% E9% 96% A2% E6% 95% B0) 1.15. Fonctions Conclusion
Le chapitre 1 décrit la grammaire de base.
L'APG4b original traite d'un langage de programmation appelé C ++. Cet article traite d'un langage de programmation appelé Python.
Il est bon de créer un environnement Python à portée de main, mais les tests de code d'AtCoder sont suffisamment bons pour être écrits.
Cet article contient la version Python du code, mais veuillez utiliser la section d'envoi d'origine pour soumettre vos questions. Le champ de soumission se trouve au bas de la page d'accueil.
Tout d'abord, changez le "Langue" dans le champ de soumission en "Python3 (3.4.3)". Après avoir apporté des modifications, essayez de copier et coller le code suivant.
print("Hello, world!")
Après avoir collé, cliquez sur le bouton «Soumettre». Si la page est commutée et que la colonne de résultat est verte «AC», la soumission est réussie.
print (" chaîne de caractères ")Le programme suivant est un programme qui ne fait rien.
En d'autres termes, contrairement au C ++, il n'est pas nécessaire d'écrire la fonction principale. Le programme fonctionne simplement en écrivant directement le contenu du traitement. Vous pouvez écrire la fonction principale, mais vous n'avez pas à l'écrire pour une petite échelle telle que la programmation de compétition.
Jetons un coup d'œil au programme que nous avons soumis en premier. Ce programme est un programme qui génère la chaîne de caractères "Hello, world!"
print("Hello, world!")
Résultat d'exécution
Hello, world!
print()
Utilisez print () pour imprimer une chaîne en Python.
La partie qui spécifie la chaîne de caractères à afficher est la partie de «Hello, world!» . Vous pouvez imprimer une chaîne en l'écrivant dans ()deprint ()`.
Lorsqu'il s'agit de chaînes dans les programmes Python, elles doivent être placées entre "" " De plus, un saut de ligne est automatiquement ajouté à la fin de la phrase.
En C ++, vous avez besoin d'un ; à la fin de la ligne, mais en Python, vous n'avez rien à écrire. (Même si vous l'écrivez, cela fonctionnera sans problème)
Si vous souhaitez afficher une autre chaîne de caractères, modifiez le contenu de «» »comme suit.
print("Bonjour le monde")
Résultat de sortie
Bonjour le monde
Vous pouvez également produire plusieurs fois.
print("a")
print("b")
print("c", "d")
Résultat d'exécution
a
b
c d
Comme je l'ai mentionné plus tôt, «print ()» de Python s'arrête automatiquement à la fin d'une phrase. Par conséquent, «b» est affiché sur la ligne suivant «a».
Ensuite, en écrivant plusieurs caractères séparés par ,, ils seront affichés séparés par des blancs comme c d.
Lors de la sortie d'une valeur numérique, vous pouvez également la sortir en l'écrivant directement sans utiliser " ".
print(2525)
Résultat d'exécution
2525
Les commentaires servent à laisser des notes pour expliquer le fonctionnement du programme, et leur écriture n'affecte pas le fonctionnement du programme. Regardons un exemple de commentaire en Python.
print("Hello, world!") # Hello, world!S'affiche comme
#Commentez également ici
Résultat d'exécution
Hello, world!
En écrivant «#», le commentaire sera après «#» sur cette ligne.
En Python, contrairement au C ++, même si des "caractères pleine largeur" sont inclus dans le programme, cela fonctionne essentiellement sans problème. Cependant, il est difficile à lire, il est donc recommandé d'écrire en "caractères demi-largeur".
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX1. Test de code et pratique de sortie
Exemple de programme
print("Hello, world!")
print("Hello, AtCoder!")
print("Hello, Python!")
Résultat d'exécution de l'exemple de programme
Hello, world!
Hello, AtCoder!
Hello, Python!
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
--Python a une signification dans les espaces, les sauts de ligne et les retraits --Python a une norme de codage appelée "PEP8" --Python est un langage interprété, donc aucune erreur de compilation ne se produit.
Décrit les espaces, les sauts de ligne et les retraits dans votre programme. Il décrit également PEP8, la convention de codage Python.
En Python, les espaces peuvent être omis, mais les sauts de ligne sont significatifs et ne peuvent pas être omis.
En C ++, ; signifie la fin de la ligne, mais en Python, le saut de ligne signifie la fin de la ligne.
En C ++, l'indentation est faite pour la lisibilité, mais en Python, l'indentation a également du sens.
Jetons un coup d'œil à la différence entre C ++ et Python en utilisant l'instruction if décrite ci-dessous à titre d'exemple.
C++(Avec indentation)
#include <bits/stdc++.h>
using namespace std;
int main() {
if (Expression conditionnelle) {
En traitement
}
}
C++(Aucune indentation)
#include <bits/stdc++.h>
using namespace std;
int main() {
if (Expression conditionnelle) {
En traitement
}
}
En C ++, il n'y a aucune différence de comportement avec ou sans indentation dans {} comme décrit ci-dessus.
Python
si expression conditionnelle:
En traitement
L'indentation est requise car Python utilise «:» et l'indentation au lieu de «{}» pour indiquer qu'elle est dans une instruction if.
PEP8 PEP8 est une norme de codage Python. Les conventions de codage sont des règles définies pour la lisibilité.
Si vous ne suivez pas PEP8, le programme fonctionnera correctement, mais si vous le suivez, vous pouvez écrire un programme facile à lire.
Il serait long de les présenter tous, alors en voici quelques-uns.
-Indent est de 4 espaces demi-largeur --Jusqu'à 79 caractères par ligne ――Ne mettez pas d'espace supplémentaire
Les détails peuvent être trouvés à https://pep8-ja.readthedocs.io/ja/latest/.
Fondamentalement, c'est comme écrit dans l'APG4b original, mais comme Python est un langage interprété, aucune erreur de compilation ne se produit.
Un langage interprété ne compile pas comme C ++, mais est exécuté phrase par phrase. Par conséquent, s'il y a une erreur grammaticale, vous obtiendrez une ** erreur d'exécution ** au lieu d'une ** erreur de compilation **.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX2. Correction des erreurs
Programme écrit par M. A
print("Toujours)
print("2525"
print(AtCoder)
Sortie d'erreur standard
File "./Main.py", line 1
print("Toujours)
^
SyntaxError: EOL while scanning string literal
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
| opérateur | Contenu du calcul |
|---|---|
| + | une addition |
| - | soustraction |
| * | multiplication |
| / | division |
| // | Division de la troncature |
| % | Reste |
| ** | Équitation |
Voyons comment faire un calcul simple avec un programme Python. Les programmes suivants exécutent "addition", "soustraction", "multiplication", "division" et "division de troncature" dans l'ordre à partir du haut.
print(1 + 1) # 2
print(3 - 4) # -1
print(2 * 3) # 6
print(7 / 3) # 2.3333333333333335
print(7 // 3) # 2
Résultat d'exécution
2
-1
6
2.3333333333333335
2
Ces symboles «+», «-», «*», «/» sont appelés ** opérateurs arithmétiques **.
Des valeurs négatives peuvent également être calculées, car «3-4» devient «-1».
* ** est une multiplication et ** / ** est une "division". ** **
En Python, / est une division normale et le résultat est une fraction. Utilisez «//» pour les divisions tronquées après la virgule décimale.
De plus, «//» est toujours arrondi à ** moins l'infini **. C ++ / est également tronqué, mais C ++ / est toujours arrondi à 0, donc ** C ++ / et Python // sont différents **. Si vous voulez toujours arrondir à 0 en Python, écrivez ʻint (a / b) `.
print(10 // 3, -10 // 3)
print(int(10 / 3), int(-10 / 3))
Résultat d'exécution
3 -4
3 -3
% calcule le "reste une fois divisé".
print(7 % 3) # 1
print(4 % 5) # 4
Résultat d'exécution
1
4
7 $ ÷ 3 = 2 $ Pas beaucoup 1 $ $ 4 $ ÷ 5 = 0 $ Trop 4 $ $ Par conséquent, la sortie de ce programme sera "1" et "4".
Python fournit également un opérateur puissant. La puissance est un nombre exprimé sous la forme $ a ^ b $.
print(3 ** 4) # 81
print(25 ** 0.5) # 5.0
print(1.5 ** 2) # 2.25
Résultat d'exécution
81
5.0
2.25
Comme mentionné ci-dessus, ʻa ** b` peut être utilisé pour calculer $ a ^ b $. Vous pouvez également calculer des fractions telles que «25 ** 0,5» et «1,5 ** 2».
La priorité des quatre règles est la même que celle du C ++, veuillez donc vous référer à l'accueil d'origine.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX3. Problème de calcul
Exemple de programme
print("""Écrivez la formule ici""")
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
=est une affectation
—— «Type de données» est appelé un type| Moule | Type de données à écrire |
|---|---|
| int | entier |
| float | Fraction |
| str | Chaîne |
Jetons un coup d'œil à une fonctionnalité appelée ** variables **. Considérez une variable comme un «mémo».
Regardons un exemple.
name = 10
print(name) # 10
print(name + 2) # 10 + 2 → 12
print(name * 3) # 10 * 3 → 30
Résultat d'exécution
10
12
30
En Python, la déclaration et l'affectation se font en même temps. Il peut être plus exact de dire qu'aucune déclaration n'est nécessaire.
name = 10
Dans cette partie, nous déclarons une variable appelée «nom» et lui affectons «10».
Notez que le symbole = signifie "attribuer (écrire)" et non "égal".
Veuillez vous référer au chef de famille pour l'explication du «type» et de la «valeur».
Dans le cas de C ++, il est nécessaire d'écrire ʻint` pour spécifier que le type de la variable est "entier", mais dans le cas de Python, le "10" attribué est un entier, donc le "nom" est automatiquement attribué. Cela rend le type int.
La valeur notée dans la variable dans les 3 dernières lignes du programme est lue et sortie.
print(name) # 10
print(name + 2) # 10 + 2 → 12
print(name * 3) # 10 * 3 → 30
Si vous écrivez variable 1 = variable 2, la valeur de la variable elle-même sera copiée.
Les modifications ultérieures de la valeur de l'une des variables n'affecteront pas l'autre.
a = 10
b = a
a = 5
print(a) # 5
print(b) # 10
Résultat d'exécution
5
10
Notez que la variable «b» reste à 10.
Les détails du traitement sont expliqués dans un diagramme facile à comprendre pour le chef de famille. En Python, les déclarations et les affectations sont faites en même temps, donc la déclaration b est faite dans la partie b = a.
Vous pouvez affecter plusieurs variables sur une seule ligne en insérant , entre elles lors de l'affectation de variables.
a, b = 10, 5
print(a)
print(b)
Résultat d'exécution
10
5
Le programme ci-dessus a la même signification que si vous aviez écrit:
a = 10
b = 5
Vous pouvez donner n'importe quel nom de variable, mais si vous essayez d'utiliser certains noms comme noms de variable, une erreur se produira.
Les noms qui remplissent les conditions suivantes ne peuvent pas être des noms de variables.
--Noms commençant par un nombre --Noms avec des symboles autres que «_»
Voici un exemple de nom qui ne peut pas être utilisé comme nom de variable. ʻInt` utilisé dans l'exemple original peut être utilisé comme nom de variable en Python (... non recommandé).
100hello = 10 #Ne peut pas être un nom commençant par un chiffre
na+me = "AtCoder" #Dans le nom de la variable+Ne peut pas être utilisé
not = 100 #not peut être un nom de variable car c'est un mot-clé
Les noms suivants peuvent être des noms de variables.
hello10 = 10 #Le deuxième caractère et les suivants peuvent être des nombres
hello_world = "Hello, world" # _Peut être utilisé pour les noms de variables
Variable 1= 1 #Caractères chinois
Hensu 2= 2 #Hiragana
Dans le cas de Python, contrairement au C ++, kanji et hiragana peuvent également être utilisés pour les noms de variables. Vous pouvez trouver une liste de mots-clés Python en effectuant une recherche.
Outre ʻint`, il existe différents types de Python. Seuls trois types importants sont présentés ici. En C ++, la fraction est «double», mais en Python c'est «float». De même, la chaîne est «str».
| Moule | Type de données à écrire |
|---|---|
| int | entier |
| float | Fraction (nombre réel) |
| str | Chaîne |
i = 10 #10 est un entier
f = 0.5 # 0.5 est une fraction
s = "Hello" # "Hello"Est une chaîne
print(i, type(i)) # type(variable) でvariableの型がわかる
print(f, type(f))
print(s, type(s))
Résultat d'exécution
10 <class 'int'>
0.5 <class 'float'>
Hello <class 'str'>
** La conversion de type ** est effectuée pour les calculs entre différents types. Par exemple, le résultat du calcul du type int et du type float est le type float.
Cependant, ** les calculs entre les types qui ne peuvent pas être convertis entraîneront une erreur **.
i = 30
d = 1.5
s = "Hello"
print(i + d, type(i + d)) # 31.5
print(i * d, type(i * d)) # 45.0
"""
Le traitement suivant est une erreur
print(s + i) #Ajout du type str et du type int
print(s + d) #Ajout du type str et du type float
"""
Résultat d'exécution
31.5 <class 'float'>
45.0 <class 'float'>
Dans le cas de Python, il est possible de calculer str type * int type.
i = 5
s = "Hello"
print(s * i) # "Hello" * 5 → ???
Quels sont les résultats du programme ci-dessus? Voyons le résultat de l'exécution.
Résultat d'exécution
HelloHelloHelloHelloHello
«« Hello »est une chaîne qui se répète 5 fois.
En Python, le type de variable dépend de ce qu'il contient. Par conséquent, le programme suivant fonctionne normalement.
i = 10
s = "Hello"
i = s
print(i)
print(type(i))
Résultat d'exécution
Hello
<class 'str'>
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX4. ◯ Combien de secondes est l'année?
Exemple de programme
#Nombre de secondes par an
seconds = 365 * 24 * 60 * 60
#Les commentaires suivants""" """Effacer et ajouter
print("""Combien de secondes par an""")
print("""2 ans, c'est quelques secondes""")
print("""Combien de secondes font 5 ans""")
print("""Combien de secondes font 10 ans""")
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
--Le programme fonctionne de haut en bas
--Vous pouvez recevoir une entrée avec variable = input ()
Fondamentalement ** les programmes sont exécutés dans l'ordre de haut en bas **.
Jetez un œil au programme suivant.
name = 10
print(name) # 10
name = 5
print(name) # 5
Résultat d'exécution
10
5
La structure de base est la même que celle de la famille principale, veuillez donc vous référer à la diapositive de la famille principale pour l'exécution.
Voyons comment recevoir une entrée de données lorsque le programme s'exécute. En utilisant la "fonction d'entrée", vous pouvez effectuer divers calculs sans réécrire le programme.
Utilisez ʻinput () `pour recevoir des entrées. Le programme suivant est un programme qui multiplie la valeur numérique reçue en entrée par 10 et la sort.
a = int(input())
print(a * 10)
contribution
5
Résultat d'exécution
50
ʻInput () prend une ligne d'entrée comme chaîne. Par conséquent, pour le recevoir en tant que type int, il doit être converti en type int par ʻint () .
a = input()
print(a, type(a))
a = int(a) #Convertir en type int
print(a, type(a))
contribution
5
Résultat d'exécution
5 <class 'str'>
5 <class 'int'>
Si vous souhaitez recevoir des données non entières, vous devez également les convertir dans le type requis.
text = input()
f = float(input())
print(text, f)
contribution
Hello
1.5
Résultat d'exécution
Hello 1.5
Comme mentionné précédemment, ʻinput () `prend une seule ligne d'entrée sous forme de chaîne.
a = input()
print(a)
print(type(a))
contribution
10 20 30
Résultat d'exécution
10 20 30
<class 'str'>
Par conséquent, si vous recevez juste une entrée séparée par des espaces, elle sera affectée à la variable ʻa` comme la chaîne "" 10 20 30 "" comme indiqué ci-dessus.
Par conséquent, vous devez diviser la chaîne en ajoutant .split () après ʻinput () `.
a, b, c = input().split()
print(a)
print(type(a))
contribution
10 20 30
Résultat d'exécution
10
<class 'str'>
Ce faisant, «10 20 30» a été divisé en trois parties, «10», «20» et «30».
Après cela, si vous le convertissez en entier en utilisant ʻint () ʻ comme auparavant, vous pouvez recevoir l'entrée séparée par des blancs comme un entier.
a, b, c = input().split()
a = int(a)
b = int(b)
c = int(c)
print(a)
print(type(a))
contribution
10 20 30
Résultat d'exécution
10
<class 'int'>
Dans le programme ci-dessus, j'ai écrit la conversion en type int à chaque fois autant que le nombre de variables, mais vous pouvez également l'écrire sur une ligne.
a, b, c = map(int, input().split())
print(a)
print(type(a))
contribution
10 20 30
Résultat d'exécution
10
<class 'int'>
En écrivant map (type, input (). Split ()), vous pouvez convertir toutes les chaînes de caractères divisées au type spécifié en même temps.
ʻInput () `reçoit une ligne d'entrée, donc s'il y a plusieurs lignes d'entrée, vous devez écrire autant de lignes qu'il y a de lignes.
s = input()
a = int(input())
print(s, a)
contribution
Hello
10
Résultat d'exécution
Hello 10
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. Problème EX5.A Addition B
Exemple de programme
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
si expression conditionnelle 1:
Processus 1
expression conditionnelle elif 2:
Processus 2
else:
Processus 3
--Opérateur de comparaison
| opérateur | sens |
|---|---|
x == y |
x et y sont égaux |
x != y |
x et y ne sont pas égaux |
x > y |
x est supérieur à y |
x < y |
x est inférieur à y |
x >= y |
x est supérieur ou égal à y |
x <= y |
x est inférieur ou égal à y |
--Opérateur logique
| opérateur | sens | Quand être vrai |
|---|---|---|
expression non conditionnelle |
Inversion du résultat de l'expression conditionnelle | L'expression conditionnelle est fausse |
Expression conditionnelle 1 et expression conditionnelle 2 |
L'expression conditionnelle 1 est vraie et l'expression conditionnelle 2 est vraie | L'expression conditionnelle 1 et l'expression conditionnelle sont toutes deux vraies |
Expression conditionnelle ou expression conditionnelle 2 |
L'expression conditionnelle 1 est vraie ou l'expression conditionnelle 2 est vraie | Au moins l'une des expressions conditionnelles 1 et 2 est vraie |
En utilisant l'instruction ** if **, vous pouvez écrire un programme appelé ** qui ne traite que lorsque certaines conditions sont correctes. La méthode d'écriture est la suivante.
si expression conditionnelle:
En traitement
Lorsque l '** expression conditionnelle ** est correcte, le traitement de la partie où le retrait après : est abaissé de un est exécuté, et lorsque l'expression conditionnelle est incorrecte, le traitement est ignoré.
Dans l'exemple suivant, si la valeur d'entrée est inférieure à 10, "x est inférieur à 10" est sorti, puis "end" est sorti. De plus, si la valeur d'entrée n'est pas inférieure à 10, seule "Fin" est sortie.
x = int(input())
if x < 10:
print("x est inférieur à 10")
print("Fin")
Entrée 1
5
Résultat d'exécution 1
x est inférieur à 10
Fin
Entrée 2
15
Résultat d'exécution 2
Fin
Dans cet exemple, nous entrons d'abord des données entières dans la variable x.
x = int(input())
Alors c'est important.
if x < 10:
print("x est inférieur à 10")
Cette partie signifie "si" x <10 "(x est inférieur à 10)," x est affiché comme inférieur à 10 "".
Enfin, lancez print (" end ") pour imprimer ʻend` et le programme se fermera.
Si x n'est pas inférieur à 10
print("x est inférieur à 10")
Le traitement est ignoré. Par conséquent, dans le deuxième exemple d'exécution, seul ʻEnd` est sorti.
L'exécution du traitement sous certaines conditions comme l'instruction if est appelée ** branche conditionnelle **. De plus, «l'expression conditionnelle est correcte» est appelée ** l'expression conditionnelle est vraie **, et «l'expression conditionnelle est incorrecte» est appelée ** l'expression conditionnelle est fausse **.
Les opérateurs de comparaison de Python sont les mêmes que ceux de C ++, consultez donc la section d'origine de cette section.
| opérateur | sens |
|---|---|
x == y |
x et y sont égaux |
x != y |
x et y ne sont pas égaux |
x > y |
x est supérieur à y |
x < y |
x est inférieur à y |
x >= y |
x est supérieur ou égal à y |
x <= y |
x est inférieur ou égal à y |
Le programme suivant est un programme qui génère les conditions auxquelles la valeur entière d'entrée satisfait.
x = int(input())
if x < 10:
print("x est inférieur à 10")
if x >= 20:
print("x est égal ou supérieur à 20")
if x == 5:
print("x vaut 5")
if x != 100:
print("x n'est pas 100")
print("Fin")
Entrée 1
5
Résultat d'exécution 1
x est inférieur à 10
x vaut 5
x n'est pas 100
Fin
Entrée 2
100
Résultat d'exécution 2
x est égal ou supérieur à 20
Fin
Vous pouvez également écrire des conditions plus complexes dans l'expression conditionnelle. Pour ce faire, utilisez ** l'opérateur logique **.
| opérateur | sens | Quand être vrai |
|---|---|---|
expression non conditionnelle |
Inversion du résultat de l'expression conditionnelle | L'expression conditionnelle est fausse |
Expression conditionnelle 1 et expression conditionnelle 2 |
L'expression conditionnelle 1 est vraieEtL'expression conditionnelle 2 est vraie | L'expression conditionnelle 1 et l'expression conditionnelle sont toutes deux vraies |
Expression conditionnelle ou expression conditionnelle 2 |
L'expression conditionnelle 1 est vraieOuL'expression conditionnelle 2 est vraie | Au moins l'une des expressions conditionnelles 1 et 2 est vraie |
x, y = map(int, input().split())
if not x == y:
print("x et y ne sont pas égaux")
if x == 10 and y == 10:
print("x et y valent 10")
if x == 0 or y == 0:
print("x ou y vaut 0")
print("Fin")
Entrée 1
2 3
Résultat d'exécution 1
x et y ne sont pas égaux
Fin
Entrée 2
10 10
Résultat d'exécution 2
x et y valent 10
Fin
Entrée 3
0 8
Résultat d'exécution 3
x et y ne sont pas égaux
x ou y vaut 0
Fin
En écrivant la clause ** else ** après l'instruction if, le traitement peut être effectué "lorsque la condition de l'instruction if est fausse". La méthode d'écriture est la suivante.
si expression conditionnelle 1:
Processus 1
else:
Processus 2
Le programme suivant génère "x est inférieur à 10" si la valeur d'entrée est inférieure à 10, sinon "x n'est pas inférieur à 10".
x = int(input())
if x < 10:
print("x est inférieur à 10")
else:
print("x n'est pas inférieur à 10")
Entrée 1
5
Résultat d'exécution 1
x est inférieur à 10
Entrée 2
15
Résultat d'exécution 2
x n'est pas inférieur à 10
elif Dans ʻelif`, le traitement est effectué lorsque "la condition de l'instruction if précédente est fausse" et "la condition d'elif est vraie" ". La méthode d'écriture est la suivante.
si expression conditionnelle 1:
Processus 1
expression conditionnelle elif 2:
Processus 2
Le processus 2 est exécuté lorsque "l'expression conditionnelle 1 est fausse et l'expression conditionnelle 2 est vraie". Regardons un exemple.
x = int(input())
if x < 10:
print("x est inférieur à 10")
elif x > 20:
print("x n'est pas inférieur à 10 mais supérieur à 20")
elif x == 15:
print("x n'est pas inférieur à 10 ni supérieur à 20 et est égal à 15.")
else:
print("x n'est pas inférieur à 10, ni supérieur à 20, ni égal à 15.")
Entrée 1
5
Résultat d'exécution 1
x est inférieur à 10
Entrée 2
30
Résultat d'exécution 2
x n'est pas inférieur à 10 mais supérieur à 20
Entrée 3
15
Résultat d'exécution 3
x n'est pas inférieur à 10 ni supérieur à 20 et est égal à 15.
Entrée 4
13
Résultat d'exécution 4
x n'est pas inférieur à 10, ni supérieur à 20, ni égal à 15.
Vous pouvez également écrire elif ou bien après elif, comme dans cet exemple.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX6. Faisons une calculatrice
Exemple de programme
a, op, b = input().split()
a = int(a)
b = int(b)
if op == "+":
print(a + b)
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
| représentation de type int | représentation de type booléen | |
|---|---|---|
| vrai | 1 | True |
| faux | 0 | False |
En Python, la vérité est représentée par «True» et le faux est représenté par «False». Notez que contrairement au C ++, le début est en majuscule. Si le "résultat du calcul" de l'expression conditionnelle est également vrai, il sera "Vrai", et s'il est faux, ce sera "Faux".
Le programme suivant produit le résultat de l'expression conditionnelle tel quel et vérifie quelle valeur il prend quand il est vrai et quand il est faux.
print(5 < 10)
print(5 > 10)
Résultat d'exécution
True
False
Si vous regardez la sortie, vous pouvez voir qu'elle est «True» lorsque la condition est vraie et «False» lorsqu'elle est fausse.
Dans le cas de Python, true et false sont généralement représentés par «True» et «False», donc ce titre peut ne pas être correct, mais il correspond à l'original.
Vous pouvez également écrire «True» ou «False» directement dans la partie expression conditionnelle. Le programme suivant est un exemple.
#True représente vrai, donc il est affiché comme bonjour
if True:
print("hello")
#False représente faux, donc ceci si n'est pas exécuté
if False:
print("world")
Résultat d'exécution
hello
Dans le type int, «True» est représenté par «1» et «False» est représenté par «0».
print(int(True))
print(int(False))
Résultat d'exécution
1
0
Il existe un type de données appelé ** type booléen **. Les variables de ce type ne peuvent contenir que «True» ou «False».
x = int(input())
a = True
b = x < 10 #Vrai si x est inférieur à 10 Faux sinon
c = False
if a and b:
print("hello")
if c:
print("world")
contribution
3
Résultat d'exécution
hello
De cette façon, si vous souhaitez gérer les données de vérité en tant que variables, telles que le résultat d'une expression conditionnelle, utilisez le type booléen. Jusqu'à présent, il était écrit comme «si expression conditionnelle», mais fondamentalement c'est «si valeur de type booléen».
Le tableau suivant résume l'histoire à ce jour.
| représentation de type int | représentation de type booléen | |
|---|---|---|
| vrai | 1 | True |
| faux | 0 | False |
Veuillez vous référer au chef de famille.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. Puzzle de valeur EX7.bool
Exemple de programme
#Variable a, b,Remplacez True ou False par c afin qu'il soit généré en tant que AtCoder
a = #Vrai ou faux
b = #Vrai ou faux
c = #Vrai ou faux
#Ne changez pas à partir d'ici
if a:
print("At", end="") # end=""Ne brisera pas la fin
else:
print("Yo", end="")
if (not a) and b:
print("Bo", end="")
elif (not b) and c:
print("Co", end="")
if a and b and c:
print("foo!")
elif True and False:
print("yeah!")
elif (not a) or c:
print("der")
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
--La partie avec un retrait commun est appelée ** bloc ** --La plage dans laquelle les variables peuvent être utilisées est appelée ** scope **
Jusqu'à présent, j'ai écrit : après l'instruction if et je l'ai mis en retrait sur la ligne suivante. La partie avec ce retrait est appelée ** bloc **.
Le chef de famille dit "
Regardons un exemple concret.
x = 5
if x == 5:
y = 10
print(x + y)
print(x)
print(y)
Résultat d'exécution
15
5
10
Il s'agit du même contenu que le programme répertorié dans la famille d'origine. Comme je travaille avec C ++ à la maison, cela est montré comme un exemple d'erreur, mais en Python, l'erreur ne se produit pas comme ci-dessus et cela fonctionne bien.
Pour plus d'informations sur la portée, veuillez vous référer à la famille principale.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX8. Ensemble Takoyaki
Programme écrit par M. A
p = int(input())
#modèle 1
if p == 1:
price = int(input())
#Motif 2
if p == 2:
text = input()
price = int(input())
n = int(input())
print(text + "!")
print(price * n)
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
--x = x + y peut être écrit aussi court que x + = y
--Python n'a pas d'incréments ou de décrémentations
Les instructions d'affectation dans lesquelles le même nom de variable apparaît deux fois, comme «x = x + 1», peuvent être rédigées plus courtes à l'aide de ** l'opérateur d'affectation composé **.
Le programme suivant ajoute simplement (1 + 2) à la variable x et la produit.
x = 5
x += 1 + 2
print(x) # 8
Résultat d'exécution
8
x += 1 + 2
Est
x = x + (1 + 2)
A la même signification que.
Vous pouvez faire de même pour les autres opérateurs arithmétiques.
a = 5
a -= 2
print(a) # 3
b = 3
b *= 1 + 2
print(b) # 9
c = 5
c /= 2
print(c) # 2.5
d = 5
d //= 2
print(d) # 2
e = 5
e %= 2
print(e) # 1
f = 3
f **= 4
print(f) # 81
Résultat d'exécution
3
9
2.5
2
1
81
C ++ a des incréments et des décrémentations, mais pas Python. Si vous souhaitez connaître les incréments, veuillez vous référer à la maison d'origine.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX9. Utilisons l'opérateur d'assignation composé
Exemple de programme
x, a, b = map(int, input().split())
# 1.Sortie de
x += 1
print(x)
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
tandis que l'expression conditionnelle:
En traitement
i = 0 #Variable de compteur
while i < N:
En traitement
i += 1
L'instruction ** while ** peut être utilisée pour effectuer un "traitement répétitif" (traitement en boucle), ce qui est très important parmi les fonctions du programme.
Le programme suivant est un programme qui répète "le processus de sortie" "Bonjour" ", coupant la ligne, puis sortie" "AtCoder" "" indéfiniment.
while True:
print("Hello")
print("AtCoder")
Résultat d'exécution
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
...(Infiniment)
L'instruction while est écrite comme suit et le processus est répété lorsque l'expression conditionnelle est vraie.
tandis que l'expression conditionnelle:
En traitement
Dans le programme précédent, «True» est écrit dans la partie expression conditionnelle, de sorte que le processus se poursuit indéfiniment. Ce type de répétition infinie s'appelle ** boucle infinie **.
Le programme suivant continue de produire des entiers à partir de 1.
i = 1
while True:
print(i)
i += 1 #Augmenter de 1 pour chaque boucle
Résultat d'exécution
1
2
3
4
5
6
7
8
...(Augmentation infinie de 1)
Pour changer le programme qui compte par 1 en "un programme qui produit des nombres de 1 à 5", procédez comme suit.
i = 1
#Boucle uniquement tant que j'ai 5 ans ou moins
while i <= 5:
print(i)
i += 1
Résultat d'exécution
1
2
3
4
5
Considérez un programme qui génère cinq fois «Hello». Tout d'abord, je présenterai le style d'écriture peu courant (le style d'écriture qui devrait être arrêté), puis le style d'écriture général (style d'écriture recommandé).
#commencer i à partir de 1
i = 1
#Boucle uniquement tant que j'ai 5 ans ou moins
while i <= 5:
print("Hello")
i += 1
Résultat d'exécution
Hello
Hello
Hello
Hello
Hello
Lors de l'écriture d'un programme qui "traite $ N $ fois" avec une instruction while, il a été écrit au format "commençant ʻi` à partir de 1 et bouclant pour moins de $ N $".
i = 1
while i <= N:
En traitement
i += 1
Ce format peut sembler simple à première vue. Cependant, ce style d'écriture n'est pas très courant et doit être écrit comme suit.
#commencer i à partir de 0
i = 0
#Boucle uniquement tant que i est inférieur à 5
while i < 5:
print("Hello")
i += 1
Résultat d'exécution
Hello
Hello
Hello
Hello
Hello
Lors de l'écriture d'un programme qui "traite $ N $ fois", il est courant d'écrire dans le format suivant ** "Démarrer ʻi à partir de 0 et faire une boucle lorsque ʻi est plus petit que $ N $" Il est **.
i = 0
while i < N:
En traitement
i += 1
Cela peut sembler déroutant au début, mais il sera de plus en plus simple d'écrire un programme plus tard, alors habituons-nous.
Notez que les variables qui gèrent le "nombre de boucles", comme la variable ʻi dans ce programme, sont parfois appelées ** variables de compteur **. Il est courant d'utiliser ʻi comme variable de compteur, et de le nommer j, k, l, ... si ʻi` ne peut pas être utilisé.
Créons un programme pour trouver le score total de $ N $ personnes. Le programme suivant reçoit comme entrées «nombre d'entrées $ N $» et «nombres entiers $ N $ représentant des points» et produit le total des points.
n = int(input())
sum = 0 #Variable représentant le score total
i = 0 #Variable de compteur
while i < n:
x = int(input())
sum += x
i += 1
print(sum)
contribution
3
1
10
100
Résultat d'exécution
111
J'ai créé une variable «sum» qui représente le score total, je la mets dans la variable d'entrée «x» à chaque fois que je boucle et je l'ajoute à «sum». Il y a une diapositive expliquant le contenu du traitement à la famille principale.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX10. Sortie du graphique à barres
Si vous n'utilisez que print (), un saut de ligne sera automatiquement inséré à la fin, vous pouvez donc utiliser print (output content, end =" ") pour empêcher le saut de ligne de fin.
Exemple de programme
a, b = map(int, input().split())
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
pour la variable compteur dans la colonne:
En traitement
--Il est courant d'écrire le processus itératif de $ N $ fois avec l'instruction for suivante.
for i in range(N):
En traitement
** for statement ** est une syntaxe pour écrire des modèles qui sont courants dans le traitement itératif tel que "process $ N $ times" plus court que l'instruction while.
Si vous écrivez un programme qui se répète trois fois avec une instruction while et une instruction for, ce sera comme suit.
j = 0
while j < 3:
print("Hello while:", j)
j += 1
for i in range(3):
print("Hello for:", i)
Résultat d'exécution
Hello while: 0
Hello while: 1
Hello while: 2
Hello for: 0
Hello for: 1
Hello for: 2
L'instruction for est écrite comme suit.
pour la variable compteur dans la colonne:
En traitement
Nous parlerons plus en détail des colonnes dans une section ultérieure, mais il y a des nombres (listes) comme [3, 1, 4, 1, 5] et des chaînes comme " abcdef ".
Jetons un œil au programme suivant.
for i in [3, 1, 4, 1, 5]:
print("i:", i)
Résultat d'exécution
i: 3
i: 1
i: 4
i: 1
i: 5
Vous pouvez voir que le contenu de la liste «[3, 1, 4, 1, 5]» est extrait depuis le début et assigné à «i».
Si vous voulez répéter un traitement tel que "traiter $ N $ fois", il est plus facile d'utiliser range (). L'écriture de range (a, b) générera une séquence de [a, a + 1, a + 2, ..., b-1].
for i in range(0, 5): # [0, 1, 2, 3, 4]
print(i)
Résultat d'exécution
0
1
2
3
4
Le ʻaderange (a, b)peut être omis quand il vaut 0, et peut être écrit commerange (b)`. Par conséquent, les deux styles d'écriture suivants ont la même signification.
for i in range(0, 5):
print(i)
for i in range(5):
print(i)
Résultat d'exécution
0
1
2
3
4
0
1
2
3
4
En d'autres termes, si vous voulez écrire "Itérer $ N $ fois", vous pouvez écrire comme suit. Pour l'instant, commençons par apprendre cette manière simple d'écrire.
for i in range(N):
En traitement
Lorsque vous utilisez l'instruction for de "Iterate $ N $ times", ne pensez pas à l'opération détaillée de "assignation à la variable de compteur dans l'ordre à partir du début de la colonne". En gros, il est plus facile d'écrire un programme qui utilise l'instruction for si vous pensez à l'instruction ** for comme une fonction qui répète le traitement de $ N $ fois tout en augmentant $ i $ de 1.
Il y a ** break ** et ** continue ** comme instructions pour contrôler les instructions while et for.
break break est une instruction pour briser la boucle au milieu. Ceci est un exemple de programme qui utilise break.
#Sans briser cette boucle serait je==Répétez jusqu'à 4
for i in range(5):
if i == 3:
print("Sortez")
break # i ==Sortez de la boucle à 3
print(i)
print("Fin")
Résultat d'exécution
0
1
2
Sortez
Fin
Lorsque ʻi == 3devient vrai dans l'instruction if, la boucle for est quittée en exécutant l'instruction debreak, et end` est affiché.
continue continue est une instruction pour sauter le traitement suivant et passer à la boucle suivante. Ceci est un exemple de programme qui utilise continue.
for i in range(5):
if i == 3:
print("Sauter")
continue # i ==Lorsqu'il est 3, ignorez le traitement après cela
print(i)
print("Fin")
Résultat d'exécution
0
1
2
Sauter
4
Fin
Dans le programme ci-dessus, lorsque ʻi == 3devient vrai dans l'instruction if, la partie ci-dessous continue est ignorée en exécutant l'instruction decontinue`, et la boucle suivante est entrée.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX11. Faisons une calculatrice 2
En écrivant print (" {} ". Format (variable)) comme suit, le contenu de la variable sera incorporé dans la partie de {}.
a = 1
b = "Hello"
print("{}:{}".format(a, b)) #Premier{}À une seconde{}À b
Résultat d'exécution
1:Hello
Exemple de programme
n = int(input())
a = int(input())
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
len (variable de chaîne)variable de chaîne [i]
-- ʻi de la variable chaîne de caractères [i] ʻest appelée ** indice **
--Les abonnements commencent à 0Les chaînes de caractères, telles que «abc» et «hello», sont celles dans lesquelles les caractères sont classés dans l'ordre. C ++ fait la distinction entre les chaînes et les caractères (longueur 1), mais Python ne le fait pas et les traite comme des chaînes (type str).
str1 = input()
str2 = ", world!"
print(str1 + str2)
contribution
Hello
Résultat d'exécution
Hello, world!
La longueur (nombre de caractères) de la chaîne de caractères peut être obtenue avec len (variable de chaîne de caractères).
s = "Hello"
print(len(s))
Résultat d'exécution
5
Vous pouvez obtenir le caractère $ i $ en écrivant comme suit.
Chaîne[i]
Ce «i» est appelé ** indice **.
Notez que les indices commencent à 0.
s = "hello"
print(s[0]) # h
print(s[4]) # o
Résultat d'exécution
h
o
s [0] obtient le premier caractère et s [4] obtient le cinquième caractère.
Pour la chaîne «bonjour», la correspondance entre les indices et les caractères est indiquée dans le tableau suivant.
| Indice | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| lettre | h | e | l | l | o |
Habituons-nous à l'indice à partir de 0, tout comme nous démarrons la variable compteur de la boucle à partir de 0.
En combinant la chaîne de caractères avec la syntaxe de la boucle, divers processus peuvent être décrits. Le programme suivant compte le nombre de caractères «O» inclus dans les caractères saisis.
s = input()
count = 0
for i in range(len(s)):
if s[i] == "O":
count += 1
print(count)
contribution
LOOOOL
Résultat d'exécution
4
Vous pouvez également écrire en Python comme suit: Étant donné que l'instruction for examine le début de la colonne dans l'ordre, elle prend également en charge les chaînes de caractères. Dans le cas d'une chaîne de caractères, elle examine chaque caractère dans l'ordre à partir du premier caractère.
s = input()
count = 0
for i in s:
if i == "O":
count += 1
print(count)
contribution
LOOOOL
Résultat d'exécution
4
Si la valeur de l'indice n'est pas dans la plage correcte, une erreur d'exécution se produit. Le programme suivant provoque une erreur car il tente d'accéder à une chaîne de 5 caractères appelée «bonjour» (les indices valides sont «0» à «4») dans le nombre de caractères inexistants dans «[10]». Faire.
x = "hello"
print(x[10])
Erreur d'exécution
Traceback (most recent call last):
File "./Main.py", line 2, in <module>
print(x[10])
IndexError: string index out of range
Code de sortie
256
Une erreur lorsque l'indice est hors plage est caractérisée par le message d'erreur `` index de chaîne hors plage '' à la ligne 4.
Contrairement au C ++, Python peut gérer les caractères pleine largeur.
s = "Bonjour"
print(s[0])
print(s[2])
Résultat d'exécution
Cette
À
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX12. Ajouter ou soustraire
Exemple de programme
s = input()
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
--Python utilise des listes au lieu de tableaux
nom de la variable de liste = [élément 1, élément 2, ...]len (list variable)Les chaînes de caractères étaient une fonction de gestion des "chaînes de caractères". ** Liste ** est une fonctionnalité très importante qui peut gérer non seulement des caractères mais également diverses colonnes de données.
C ++ traite des tableaux (vecteurs), tandis que Python traite des listes (listes). Les principales différences sont les suivantes.
| la différence | |
|---|---|
| C++Vecteur | Un seul type peut être dans un tableau |
| Liste Python | Vous pouvez mettre différents types de données dans une seule liste |
Les chaînes et les listes sont utilisées de la même manière dans une certaine mesure.
Le programme suivant a une chaîne de lettres ""a"," b ", "" c ", "d" "" et "" 25 "," 100 "," 64 "". Nous avons affaire à une colonne d'entiers.
#Chaîne
s = "abcd" # "a", "b", "c", "d"Entrez la chaîne de caractères
print(s[0]) #La première"a"Production
print(len(s)) #Sortie 4 qui est la longueur de la chaîne de caractères
#liste
a = [25, 100, 64] # 25, 100,Remplacez une colonne d'entiers (int) appelée 64
print(a[0]) #Sortir les 25 premiers
print(len(a)) #Sortie de la longueur de la liste de 3
Résultat d'exécution
a
4
25
3
La variable de liste est générée comme suit.
Nom de la variable de liste= [Élément 1,Élément 2, ...]
Chaque donnée de la liste est appelée un ** élément **.
Si vous écrivez ʻa = [25, 100, 64] , la chaîne de données" 25, 100, 64 "est affectée à la variable de liste ʻa.
Comme les chaînes, les listes peuvent utiliser «[i]» pour accéder à l'élément $ i $ th.
Variable de liste[i]
Les indices commencent également à 0 dans la liste.
Pour la variable de liste ʻaʻa = [25, 100, 64], le tableau des valeurs d'indice et de la correspondance des caractères est le suivant:
| Indice | 0 | 1 | 2 |
|---|---|---|---|
| élément | 25 | 100 | 64 |
Comme les chaînes, les listes peuvent utiliser len () pour obtenir le nombre d'éléments (longueur).
len(Variable de liste)
Pour la variable de liste ʻaavec ʻa = [25, 100, 64], la valeur delen (a)est 3.
J'ai utilisé ʻinput (). Split () `pour recevoir une entrée séparée par des blancs, mais je la reçois en fait sous forme de liste.
a = input().split()
print(a)
contribution
3 1 4 1 5
Résultat d'exécution
['3', '1', '4', '1', '5']
Si c'est la seule chose, il sera reçu en tant que type str, donc utilisez map () pour le recevoir en tant que type int. Vous pouvez utiliser map () pour effectuer une conversion de type sur tous les éléments de la liste.
a = list(map(int, input().split()))
print(a)
contribution
3 1 4 1 5
Résultat d'exécution
[3, 1, 4, 1, 5]
Si seulement map () est utilisé, ce sera un objet de carte, donc il est converti en une liste en l'enfermant dans list ().
Vous souhaiterez peut-être également recevoir l'entrée délimitée par saut de ligne suivante:
3
1
4
1
5
Dans ce cas, créez d'abord une liste vide, puis ajoutez les éléments dans l'ordre. Une liste vide peut être créée en n'écrivant aucun élément.
Variable de liste= [] #Liste vide
Pour ajouter un élément à la liste, utilisez .append.
Variable de liste.append(Éléments à ajouter)
En les combinant avec l'instruction for, vous pouvez recevoir des entrées séparées par des sauts de ligne.
n = int(input()) #Si la première ligne d'entrée est le nombre d'éléments
a = []
for i in range(n):
a.append(int(input()))
print(a)
Entrée (la première ligne est le nombre d'éléments)
5
3
1
4
1
5
Résultat d'exécution
[3, 1, 4, 1, 5]
En combinant la liste et l'instruction for, vous pouvez écrire un programme qui gère une grande quantité de données. Voir l'exemple suivant.
Veuillez consulter le chef de famille pour l'énoncé du problème.
Si $ N $ est petit, il est possible de résoudre ce problème avec uniquement des variables de type int sans utiliser de liste. Cependant, si $ N $ est grand, écrire sans liste peut être très difficile. Par exemple, si $ N = 1000 $, vous devez déclarer 1000 variables.
Les listes et les instructions for vous permettent d'écrire des processus de manière concise quelle que soit la taille de $ N $.
n = int(input())
#Recevoir des données de score en mathématiques et en anglais
math = list(map(int, input().split()))
english = list(map(int, input().split()))
#Total des points de sortie
for i in range(n):
print(math[i] + english[i])
Comme les chaînes, les listes entraîneront une erreur si les valeurs d'indice ne sont pas dans la plage correcte.
Le programme suivant essaie d'accéder à un élément inexistant avec «[10]» par rapport à une liste de trois éléments «[1, 2, 3]» (les indices valides sont «0» à «2»). Une erreur se produira.
a = [1, 2, 3]
print(a[10])
Erreur d'exécution
Traceback (most recent call last):
File "./Main.py", line 2, in <module>
print(a[10])
IndexError: list index out of range
Code de sortie
256
Comme pour la chaîne, la quatrième ligne affiche le message d'erreur `` IndexError: list index out of range ''.
C'est une petite histoire, vous pouvez donc la sauter et résoudre le problème.
En Python, vous pouvez le voir de derrière en utilisant un signe moins dans l'indice.
a = [1, 2, 3, 4, 5]
print(a[-1]) #D'abord de l'arrière
print(a[-3]) #Troisième à l'arrière
Résultat d'exécution
5
3
Vu de derrière, comptez le dos comme «-1», le deuxième depuis l'arrière comme «-2» et le troisième comme «-3».
Dans les listes Python, il existe une opération appelée ** slice ** pour obtenir une partie de la liste. Les tranches sont utilisées comme suit.
Variable de liste[Indice du point de départ:Indice du point final]
En partant de l'indice du point de départ, la liste est obtenue jusqu'à celle qui précède l'indice du point final.
Si la variable de liste ʻaest ʻa = [1, 2, 3, 4, 5], alors ʻa [1: 3]devient[2, 3]`. Si vous omettez l'indice, vous obtiendrez du début pour le point de départ et jusqu'à la fin pour le point final.
Vous pouvez également spécifier les étapes (combien de fois vous souhaitez voir la tranche).
Variable de liste[Indice du point de départ:Indice du point final:Étape]
Par exemple, si vous spécifiez «2» pour l'étape, vous pouvez obtenir l'élément en sautant un élément.
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[::2]) #Sautez un depuis le début → nombre pair
print(a[1::2]) #Odd th
Résultat d'exécution
[0, 2, 4, 6, 8]
[1, 3, 5, 7, 9]
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX13. Différence par rapport au score moyen
Exemple de programme
n = int(input())
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
nom de fonction (argument 1, argument 2, ...)
--La valeur passée à la fonction avec () est appelée ** argument **| une fonction | min(a, b) | max(a, b) |
|---|---|---|
| une fonction | Renvoie la plus petite valeur de a et b(3 ou plus possible) | Renvoie la plus grande valeur de a et b(3 ou plus possible) |
| une fonction | sorted(list) | reversed(list) |
|---|---|---|
| une fonction | Trier la liste (trier les éléments par ordre croissant) | Inverser l'ordre des éléments dans la liste |
** Les fonctions ** facilitent l'utilisation des fonctions d'un programme.
Prenons "un programme qui produit la plus petite des valeurs de deux variables" comme exemple.
Lorsque vous écrivez sans utiliser de fonction, cela ressemble à ceci:
a = 10
b = 5
if a < b:
answer = a
else:
answer = b
print(answer)
Résultat d'exécution
5
Si vous utilisez la "fonction min", vous pouvez écrire comme suit.
a = 10
b = 5
answer = min(a, b) #fonction min
print(answer)
Résultat d'exécution
5
Le «min» qui apparaît dans le programme est une fonction qui trouve la plus petite des deux valeurs. Puisque la valeur la plus petite de «a» et «b» peut être obtenue comme «résultat du calcul» de «min (a, b)», elle est affectée à la variable «réponse».
En plus de min, Python a diverses fonctions, et vous pouvez utiliser de nombreuses fonctions sans écrire votre propre programme.
Une collection de fonctions, etc. fournie par Python est appelée une ** bibliothèque standard **. De plus, les fonctions fournies dans la bibliothèque standard sont appelées ** fonctions intégrées **.
Vous pouvez également créer vos propres fonctions. Ceci sera expliqué dans "1.15. Fonctions".
L'utilisation d'une fonction s'appelle ** appel de fonction **.
La notation de l'appel de fonction est la suivante.
Nom de la fonction(Argument 1,Argument 2, ...)
** Argument ** est la valeur transmise à la fonction. Dans min (a, b), la variable a et la variable b lui correspondent.
La fonction min avait deux arguments, mais le nombre d'arguments dépend de la fonction.
La valeur du résultat du calcul de la fonction est appelée ** valeur de retour (valeur de retour) ** ou ** valeur de retour (valeur de retour) **. ʻAnswer = min (a, b) `affecte la valeur de retour de la fonction min à la variable answer.
Les règles de type pour les arguments et les valeurs de retour sont déterminées par la fonction, et si vous faites une erreur, une erreur se produit.
Le programme suivant essaie de passer des types int et string comme arguments à la fonction min et obtient une erreur.
s = "hello"
a = min(10, s)
print(a)
Erreur
Traceback (most recent call last):
File "./Main.py", line 3, in <module>
a = min(10, s)
TypeError: unorderable types: str() < int()
Je vais présenter deux des fonctions intégrées. ** Vous n'êtes pas obligé de les mémoriser **, mais il est important de se souvenir et de rechercher: "J'ai l'impression que ce processus a été fait avec une fonction intégrée."
La fonction min renvoie le plus petit des arguments. Il prend également en charge 3 arguments ou plus.
answer = min(10, 5)
print(answer) # 5
Résultat d'exécution
5
Le type de l'argument et la valeur de retour peuvent être n'importe quel type numérique (ou un type qui peut être comparé en magnitude) tel que «int »ou« float ». Vous pouvez également prendre une liste comme argument.
answer = min(1.5, 3.1)
print(answer) # 1.5
Résultat d'exécution
1.5
Vous pouvez également comparer le type int et le type float.
a = 1.5
print("a:", type(a))
b = 10
print("b:", type(b))
answer = min(a, b)
print(answer) # 1.5
Résultat d'exécution
a: <class 'float'>
b: <class 'int'>
1.5
La fonction max renvoie le plus grand des arguments. Il prend également en charge 3 arguments ou plus.
answer = max(10, 5)
print(answer) # 10
Résultat d'exécution
10
Les types d'arguments et les valeurs de retour sont les mêmes que min.
Voici deux fonctions intégrées qui passent une liste en argument.
Vous pouvez utiliser la fonction inversée pour inverser l'ordre des éléments dans la liste.
a = [1, 5, 3]
a = list(reversed(a)) # [3, 5, 1]
print(a)
Résultat d'exécution
[3, 5, 1]
Puisque l'itérateur est retourné, je le convertis en une liste en utilisant list ().
Vous pouvez également obtenir une liste dans l'ordre inverse en utilisant des tranches.
a = [1, 5, 3]
a = a[::-1]
print(a)
Résultat d'exécution
[3, 5, 1]
Le tri des colonnes de données dans l'ordre s'appelle ** tri **. Vous pouvez utiliser la fonction triée pour trier les éléments de la liste par ordre croissant.
a = [2, 5, 2, 1]
a = sorted(a) # [1, 2, 2, 5]
print(a)
Résultat d'exécution
[1, 2, 2, 5]
De plus, la fonction triée peut être triée par ordre décroissant en spécifiant reverse = True comme deuxième argument.
a = [2, 5, 2, 1]
a = sorted(a, reverse=True) # [5, 2, 2, 1]
print(a)
Résultat d'exécution
[5, 2, 2, 1]
La fonction sum renvoie la somme de tous les éléments de la liste d'arguments.
a = [2, 5, 2, 1]
print(sum(a))
Résultat d'exécution
10
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX14. Différence de hauteur entre les trois frères
Exemple de programme
a, b, c = map(int, input().split())
#Ajoutez le programme ici
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
--Créer une fonction s'appelle ** définir ** une fonction
nom de la fonction def(Nom de l'argument 1,Nom de l'argument 2, ...):
En traitement
--La valeur de retour de la fonction est spécifiée par return return value en utilisant ** return statement **.
--Il est possible de ne pas écrire la valeur de retour de la fonction
() dans la définition et appeler si aucun argument de fonction n'est nécessaire
--Le traitement de la fonction se termine lorsque le traitement atteint la ligne de l'instruction de retour.Créer une fonction s'appelle ** définir ** une fonction.
L'exemple suivant définit une fonction my_min qui a des fonctionnalités similaires à la fonction min intégrée.
#Définition des fonctions
def my_min(x, y):
if x < y:
return x
else:
return y
answer = my_min(10, 5)
print(answer)
Résultat d'exécution
5
Il y a une diapositive dans la famille principale qui explique le fonctionnement de l'ensemble du programme.
La fonction est définie avant la ligne qui appelle la fonction.
La notation de la définition de fonction est la suivante.
nom de la fonction def(Nom de l'argument 1,Nom de l'argument 2, ...):
En traitement
Comme nous l'avons vu dans la section précédente, l'argument est la "valeur à passer à la fonction" et la valeur de retour est la "valeur du résultat de la fonction".
La fonction my_min prend deux arguments, donc la définition ressemble à ceci:
def my_min(x, y):
La méthode d'appel est la même que la fonction intégrée. Si vous l'appelez comme suit, «10» est affecté à l'argument «x» et «5» est affecté à l'argument «y».
my_min(10, 5)
La valeur de retour de la fonction est spécifiée par la ** instruction return **.
return Valeur de retour
La fonction my_min renvoie le plus petit des deux arguments x et y, alors écrivez:
if x < y:
return x
else:
return y
Il peut n'y avoir aucune valeur de retour pour la fonction. Dans ce cas, il n'est pas nécessaire d'écrire une instruction return.
def hello(text):
print("Hello, " + text)
hello("Tom")
hello("Python")
Résultat d'exécution
Hello, Tom
Hello, Python
Si vous n'avez pas besoin d'arguments de fonction, écrivez simplement () dans la définition et appelez.
def int_input():
x = int(input())
return x
num = int_input()
print(num, type(num))
contribution
10
Résultat d'exécution
10 <class 'int'>
Veuillez vous référer au chef de famille.
Le traitement de la fonction se termine lorsque le traitement atteint l'instruction de retour.
Peu importe qu'il y ait plusieurs instructions return dans une fonction, mais sachez que le traitement écrit après l'instruction return ne sera pas exécuté.
Dans le programme suivant, «return» est écrit sur la ligne suivant la sortie de «Hello», donc aucun autre traitement n'est effectué.
def hello():
print("Hello, ", end="")
return #Seulement courir jusqu'à cette ligne
print("world!")
return
hello()
Résultat d'exécution
Hello,
Comme pour l'attribution de valeurs à d'autres variables, la valeur transmise à l'argument est essentiellement copiée.
La fonction add5 dans le programme suivant ajoute «5» à l'argument de la fonction, mais la valeur de la variable d'appel num ne change pas.
def add5(x):
x += 5
print(x)
num = 10
add5(num)
print(num)
Résultat d'exécution
15
10
Les fonctions ne peuvent être appelées qu'après la ligne déclarée.
Dans le programme suivant, l'erreur se produit car la fonction hello est appelée avant la ligne qui définit la fonction hello.
hello()
def hello():
print("hello!")
Erreur
Traceback (most recent call last):
File "./Main.py", line 1, in <module>
hello()
NameError: name 'hello' is not defined
Puisqu'il est lu et exécuté dans l'ordre du haut, au moment de la première ligne, l'erreur "bonjour la fonction n'est pas encore définie" s'affiche.
Vous pouvez trouver l'énoncé du problème sur le lien ci-dessous. EX15. Cadeau pour trois frères
Programme écrit par M. A
#Une fonction qui calcule et renvoie le score total à partir d'une liste qui représente le score d'un test
#Scores d'argumentation: scores[i]Contient le score du i-ème test
#Valeur de retour:Score total d'un test
def sum_scores(scores):
#Ajoutez le programme ici
#Une fonction qui calcule et sort le budget cadeau à partir du total des points de trois personnes
#Somme des arguments_a:Score total du test de M. A
#Somme des arguments_b:Score total du test de M. B
#Somme des arguments_c:Score total du test de M. C
#Valeur de retour:Aucun
def output(sum_a, sum_b, sum_c):
#Ajoutez le programme ici
# ---------------------
#Ne changez pas d'ici
# ---------------------
#Une fonction qui reçoit une entrée avec une ligne d'entiers séparés par des espaces, la place dans une liste et la renvoie.
#Arguments:Entrée sur une ligne, séparée par des blancs
#Valeur de retour:Liste des entrées reçues
def list_int_input(s):
a = list(map(int, s.split()))
return a
#Recevoir N nombre de sujets
n = int(input())
#Recevez des points pour chaque test
a = list_int_input(input())
b = list_int_input(input())
c = list_int_input(input())
#Budget du cadeau de sortie
output(sum_scores(a), sum_scores(b), sum_scores(c))
** Assurez-vous d'essayer le problème vous-même avant de le voir. ** ** Exemple de réponse
C'est la fin du chapitre 1. Cet article a couvert uniquement le chapitre 1 d'APG4b. Si j'en ai envie, j'écrirai sur le chapitre 2 et au-delà.
Comme je l'ai écrit au début, je supprimerai cet article s'il y a un problème.
Recommended Posts