Ceci est une continuation de l'article précédent (https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5). Dans cet article, nous allons déplacer le sujet vers les listes Python, le branchement conditionnel et le traitement en boucle sur la base de l'article précédent [graph_plot.py](https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#draw graph). .. Si cela ne vous dérange pas de tout sauter, allez dans [Dessiner une fonction discontinue](#Dessiner une fonction discontinue).
Dans l'article précédent (https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#How to use numpy), j'ai mentionné qu'il n'y a pas de tableaux en Python. Au lieu de cela, Python est livré en standard avec une structure de données appelée List. Cette fois, j'y reviendrai un peu.
Commençons par une brève description de la liste.
list_sample.py
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x)
x.append(10)
print(x)
#print(x + 3)
#TypeError se produit
print(x + [3])
print(x * 3)
x = np.array(x)
print(x)
x = list(x)
print(x)
Le concept des listes est similaire à celui des tableaux et peut être utilisé comme suit:
list_sample.py
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x)
Avez-vous remarqué que le résultat de sortie est le même que le «x» défini dans ce «x», [numpy_calc.py](https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#numpy usage)? En d'autres termes, vous pouvez voir que les listes et les tableaux ont des structures de données similaires. La plus grande différence est que la ** taille des données est variable **.
list_sample.py
x.append(10)
print(x)
10 a été ajouté. Cette méthode ʻappend` est une fonction [^ 1] que possède la structure de données de type liste, et sert à ajouter un élément. Bien sûr, essayer de faire la même chose avec un tableau numpy ne donnera qu'une erreur. Dans numpy, vous devez le copier quelque part (en interne) pour changer la taille du tableau une fois défini. En allouant une grande quantité de mémoire à la liste de points à l'avance, vous pouvez économiser le temps nécessaire pour allouer de la mémoire lors de l'ajout d'éléments. ** En bref, chacun a ses avantages / inconvénients. ** ** Il existe d'autres fonctions dans la liste qui suppriment des éléments. En outre, la liste n'a pas la capacité de diffuser des tableaux numpy.
list_sample.py
#print(x + 3)
#TypeError se produit
Cependant, vous pouvez effectuer les opérations suivantes:
list_sample.py
print(x + [3])
print(x * 3)
S'il s'agit d'un ajout entre des listes, un élément sera ajouté. Multiplier une liste avec des nombres naturels est une liste qui répète la liste elle-même par le nombre de nombres. [^ 2] ** Les autres opérations ne peuvent pas être de typeError ** De plus, les tableaux et listes numpy peuvent être convertis les uns aux autres.
list_sample.py
x = np.array(x)
print(x)
x = list(x)
print(x)
Ceci conclut l'introduction de la connaissance de liste requise dans cet article. En résumé
Cet article est OK si vous le savez seulement.
La ramification conditionnelle est le processus de ** "○○ si certaines conditions sont remplies, XX sinon" **. (Ce processus est similaire à la prise de décision humaine) Le traitement en boucle est un processus qui ** "répète le même processus jusqu'à ce qu'une certaine condition soit remplie" **. (C'est un processus semblable à une machine)
Faisons en fait comment écrire le code concrètement.
En parlant de branchement conditionnel en Python, seule l'instruction ʻifest [^ 3]. Les gens qui ont fait du langage C, etc. peuvent se demander: "Eh bien, n'y a-t-il pas un" commutateur "? Il n'y a pas d'instruction
switch` en Python. Vous devez l'écrire un par un. ~~ C'est gênant. ~~
Pour la première fois, il peut être chanceux de se souvenir moins.
Pour le moment, utilisons cette branche conditionnelle.
if_sample.py
x = 5
if x > 0:
#Expression conditionnelle x>Si 0 est vrai, le processus ici
print("x est supérieur à 0.")
else:
#Expression conditionnelle x>Si 0 est faux, le processus ici
#Autrement dit, x<=Si c'est 0, c'est le processus ici
if x == 0:
#Expression conditionnelle x==Si 0 est vrai, le processus ici
# <note>
# ==Est une expression conditionnelle que les deux côtés de l'expression sont égaux
#Au contraire, le calcul de savoir si les deux côtés de l'expression ne sont pas égaux!=est
print("x est égal à 0.")
else:
#Expression conditionnelle x==Si 0 est faux, le processus ici
#Autrement dit, x!=Si c'est 0, c'est le processus ici
print("x est inférieur à 0.")
if x > 0:
print("x est supérieur à 0.")
elif x == 0:
print("x est égal à 0.")
else:
print("x est inférieur à 0.")
Ces deux instructions ʻif ont exactement le même comportement. Le supérieur est écrit en utilisant uniquement «if else», et le inférieur est écrit en utilisant la grammaire «if elif else». Comme vous pouvez le voir, vous pouvez écrire une instruction ʻif
dans une instruction ʻif` (appelée ** nesting **).
Bien sûr, vous pouvez imbriquer davantage, mais ce sera difficile à lire, alors essayez de ** minimiser autant que possible l'imbrication **.
En d'autres termes, le code ci-dessous est plus facile à lire.
Résumé grammaire
if_grammer_summary.py
if (Expression conditionnelle 1):
# (Expression conditionnelle 1)Est vrai(True)Exécutez ensuite le processus décrit ici
#-----d'ici-----
elif (Expression conditionnelle 2):
# (Expression conditionnelle 1)Est faux(False)alors(Expression conditionnelle 2)Est vrai(True)Exécutez ensuite le processus décrit ici
elif (Expression conditionnelle 3):
...
else:
#Toutes les expressions conditionnelles sont fausses(False)Exécutez ensuite le processus décrit ici
#-----Jusque là-----
#Tous sont facultatifs. En d'autres termes, seul le premier si est OK.
for
et while
Vient ensuite le traitement en boucle.
Il existe deux types de traitement de boucle en Python: for
et while
.
Il y a deux raisons, parce que parfois je veux les utiliser correctement, mais je l'aime parce que je peux convertir l'instruction for
en instruction while
et l'instruction while
en instruction for
afin qu'ils effectuent un traitement équivalent. Je voudrais dire ... mais je recommande personnellement d'utiliser la déclaration ** fondamentalement for
. ** **
La raison sera plus tard ...
for
D'abord à partir de l'instruction for
.
for_sample.py
for i in range(10):
print(i)
print("----------")
for i in range(1, 10):
print(i, end=" ")
if i > 5:
print("\n{} > 5".format(i))
print("Sortez de la boucle")
break
else:
print("Cette déclaration n'est pas imprimée.")
À propos, l'instruction supérieure for
est sortie verticalement de 0 à 9.
En bas, jusqu'à 6 doivent être émis côte à côte et doivent se terminer par «6> 5» et «Boucle de sortie».
(En passant, j'utilise certaines fonctions que je n'ai pas introduites. Si vous êtes curieux, allons sur Google.)
L'instruction for
est plus facile à comprendre si vous regardez la grammaire.
for_grammer_summary.py
for (Nom de variable) in (Tableaux, listes, etc.):
(Écrivez le processus que vous souhaitez répéter ici)
else:
(Écrivez ici le traitement lorsque la boucle se termine normalement et le traitement que vous voulez faire lorsque la boucle n'est jamais exécutée)
La fonction range
renvoie quelque chose comme une liste jusqu'à un nombre spécifié [^ 5].
L'instruction break
est pour forcer la rupture de la boucle.
Dans l'instruction for
, les valeurs numériques spécifiées par ** (tableau, liste, etc.) ** sont assignées séquentiellement à ** (nom de la variable) ** et traitées.
Dans la première boucle de for_sample.py
--0
est affecté à la variable ʻi`
print
imprime 0
--1
est affecté à la variable ʻi`impression
imprime 1
Le processus se déroule comme ceci.
La deuxième boucle a été écrite pour introduire l'instruction for else
.
Vous pouvez utiliser ʻelse pour la boucle, ce qui est rare dans d'autres langages en Python. Dans ʻelse
, écrivez le traitement que vous voulez exécuter lorsque la boucle se termine normalement.
En d'autres termes, si l'instruction ** break
termine de force la boucle, ce processus ne sera pas exécuté. ** **
Il n'est pas utilisé de manière très agressive, mais vous pouvez écrire du code plus propre lorsque vous voulez vous débarrasser de toutes les instructions for
imbriquées.
nested_for.py
#avec d'autre
for i in range(10):
for j in range(10):
print(i, j)
if i * j > 10:
# i = 2, j =Entrez ici au 6
break
else:
continue
break
#sans autre
flag = False
for i in range(10):
for j in range(10):
print(i, j)
if i * j > 10:
# i = 2, j =Entrez ici au 6
flag = True
break
if flag:
break
L'instruction continue
sert à passer par le traitement suivant et à passer à la boucle suivante.
while
Vient ensuite l'instruction «while».
while_sample.py
i = 0
while i < 10:
print(i)
i += 1
print("----------")
i = 0
while i < 10:
print(i, end=" ")
if i > 5:
print("\n{} > 5".format(i))
break
i += 1
else:
print("Cette déclaration n'est pas imprimée")
Vous pouvez voir que ce while_sample.py est un processus en boucle équivalent à for_sample.py. La syntaxe de l'instruction «while» est la suivante:
while_grammer_summary.py
while (Expression conditionnelle):
(Écrivez le processus que vous souhaitez répéter ici)
else:
(Écrivez ici le traitement lorsque la boucle se termine normalement et le traitement que vous voulez faire lorsque la boucle n'est jamais exécutée)
La caractéristique de l'instruction while
est que ** le traitement en boucle est effectué tant que l'expression conditionnelle est satisfaite **.
** La grande différence est que l'instruction for
détermine le nombre de boucles à l'avance, tandis que l'instruction while
peut être indéfinie. ** **
Cela explique pourquoi je ne veux personnellement pas utiliser l'instruction «while».
Si vous modifiez la première boucle de while_sample.py comme suit et que vous l'exécutez, une grande quantité de «0» continuera à être sortie. ** << Attention >> ** ** Veuillez garder à l'esprit comment arrêter lors de l'exécution. ** **
while_sample.py
i = 0
while i < 10:
print(i)
#i += 1
** << Comment arrêter >> ** Cliquez sur ■ en haut pour arrêter. Le notebook jupyter est pratique car vous pouvez interrompre l'exécution avec une simple opération ~
Cela se produit parce que la valeur de la variable ʻi ne change pas, donc l'expression conditionnelle ʻi <10
continue d'être satisfaite, et le traitement est effectué indéfiniment.
Cette situation est appelée ** boucle infinie **.
Cette fois, l'erreur est facile à comprendre car elle est générée par la fonction print
, mais que se passe-t-il si cela se produit dans 1000 lignes de code sans la sortie par la fonction print
?
Le code que j'ai écrit si dur ne fonctionne pas en raison d'une erreur pour une raison quelconque! ne pas Le code que j'ai écrit si dur ne répond pas même s'il n'y a pas d'erreur!
Ce sera la situation.
Lorsque vous êtes débutant, vous ne remarquez pas si facilement des boucles infinies, vous pouvez donc avoir des ennuis tout le temps.
Pour les raisons ci-dessus, il y a peu de boucles qui ne peuvent être écrites qu'avec une instruction while
, alors utilisons ** essentiellement une instruction for
**.
Cela fait longtemps, mais écrivons une fonction discontinue en utilisant le branchement conditionnel et le traitement en boucle!
Modifions la fonction f
partie de [graph_plot.py](https://qiita.com/kuroitu/items/8542b88d486d1dbf92a5#draw graph) comme suit.
graph_plot.py
#Version de la liste
def f(x):
result = []
for i in x:
if i < 0:
result.append(i + 3)
else:
result.append(i ** 2)
return result
graph_plot.py
#Version utilisant le tableau numpy
def f(x):
result = np.zeros(len(x))
for i in range(len(x)):
if x[i] < 0:
result[i] = x[i] + 3
else:
result[i] = x[i] ** 2
return result
Ce n'est pas grave si un graphique comme celui-ci est tracé.
Est-ce ennuyeux? sans aucun doute. Je vais donc également présenter une manière intelligente d'écrire.
graph_plot.py
def f(x):
return np.where(x < 0, x + 3, x ** 2)
La fonction where
de numpy est ce que l'on appelle l'opérateur ternaire.
Let's google pour plus de détails.
À propos, si vous faites de votre mieux, même le style d'écriture standard sera intelligent tel quel.
graph_plot.py
def f(x):
return [i + 3 if i < 0 else i ** 2 for i in x]
C'est une combinaison de notation d'inclusion de liste et d'opérateur ternaire de l'instruction ʻif`.
list_comprehension_grammer.py
[(En traitement) for (Nom de variable) in (Tableaux, listes, etc.)]
ternary_operator_grammer.py
(Traitement lorsque l'expression conditionnelle est vraie) if (Expression conditionnelle) else (Expression conditionnelleが偽の時の処理)
Cependant, il est difficile à lire et compliqué. ** Vous pouvez voir la grandeur du package. ** **
[^ 1]: Pour être exact, c'est la méthode ʻappendde la classe de type liste. [^ 2]: les valeurs entières inférieures ou égales à 0 renvoient une liste vide. essayez-le. [^ 3]: L'instruction
try` peut être considérée comme une branche conditionnelle.
[^ 4]: Lorsque la limite gauche et la limite droite à ce point correspondent, et que la valeur à ce point correspond à la valeur limite, on dit que la fonction est continue. En d'autres termes, si les fonctions sont connectées proprement, c'est continu.
[^ 5]: renvoie en fait un objet itérateur (bouclable).
Recommended Posts