Premier Python ~ Codage 2 ~

Personne cible

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).

table des matières

[pour l'instruction et l'instruction while](# pour l'instruction et l'instruction while) - [for statement](#for statement) - [instruction while](instruction # while) - [Dessiner une fonction discontinue](# Dessiner une fonction discontinue) - [Gênant? ](#Gênant)

Liste de Python

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.

Qu'est-ce qu'une liste?

Commençons par une brève description de la liste.

list_sample.py

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.

Branchement conditionnel et traitement en boucle

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.

Instruction ʻIf`

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'instructionswitch` 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

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.

Instructions 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 ...

Déclaration for

D'abord à partir de l'instruction for.

for_sample.py

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`

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

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.

Déclaration while

Vient ensuite l'instruction «while».

while_sample.py

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 ~ while_error.gif

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 **.

Dessinons une fonction discontinue

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é. discontinuous.png

Gênant?

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. ** **

Premier article de la série Python

[^ 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'instructiontry` 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

Premier Python ~ Codage 2 ~
Premier Python
Premier Python 3 ~ Première comparaison ~
Premier python [O'REILLY]
Première 3e édition de Python
Premier traitement d'image Python
[Python] Premier SVM de Python / Scikit-learn
Premier mémo divers sur Python
[Python] Chapitre 01-01 À propos de Python (First Python)
First Fabric (outil de déploiement Python)
Python
Première simulation de cellule nerveuse avec NEURON + Python
Première analyse de régression simple en Python
First Python 3 ~ Le début de la répétition ~
Résumé du lien de la règle de codage R / Python
Web scraping avec Python Première étape
Premier Python 3 ~ Extra: Fantaisie aléatoire numérique ~
[GUI avec Python] PyQt5-La première étape-
Préparez votre premier environnement de développement Python
Conforme à la norme de codage Python PEP8
Python (de la première fois à l'exécution)
Un programmeur C / C ++ défie Python (première étape)
Voir python pour la première fois
Préférences Atom pour un codage Python confortable
La première étape de Python Matplotlib
python kafka
Les bases de Python ⑤
Résumé Python
Python intégré
Notation d'inclusion Python
Étudier Python
Compte à rebours Python 2.7
Mémorandum Python
Python FlowFishMaster
Service Python
astuces python
Premier flacon
Mémo Python
Jouez en continu le MV du premier Python Skusta
Notation d'inclusion Python
Python Singleton
Les bases de Python ④
Mémorandum Python 2
Incrément Python
atCoder 173 Python
[Python] fonction
Premier essai
Installation de Python
Installer Python 3.4.3.
Essayez Python
Mémo Python
Itératif Python
Algorithme Python
Python2 + mot2vec
[Python] Variables
Fonctions Python
Python sys.intern ()
Tutoriel Python