Vous serez ingénieur dans 100 jours ――Jour 30 ―― Python ―― Bases du langage Python 6

Cette fois est une continuation des bases de Python. Il est déjà 30 jours au plus tôt. Je n'ai pas l'impression que c'est fini www.

Cliquez ici pour la dernière fois [Vous deviendrez ingénieur dans 100 jours - Jour 29 - Python - Bases du langage Python 5] (https://qiita.com/otupy/items/22d4ab97b33c989ab284)

À propos des fonctions intégrées

En tant que fonctionnalité standard en python Il a une fonction intégrée.

Je l'utilise depuis le début de ce cours La fonction print () est également une fonction intégrée.

Parce que c'est une fonction indispensable pour le programme Apprenons à utiliser les fonctions intégrées.

** Comment utiliser la fonction **

Nom de la fonction (argument, ...)

Ce qui est spécifié entre parenthèses () après le nom de la fonction est appelé ʻargument`. Il peut y avoir plusieurs «arguments» selon la fonction.

Dans ce cas, séparez-les par des virgules ,. Vous pouvez spécifier à quel «argument» il correspond.

Le résultat de l'exécution de la fonction peut renvoyer une valeur. Cette valeur retournée est appelée la «valeur de retour».

** Diverses fonctions intégrées **

*** fonction abs ***

Renvoie la valeur absolue du nombre. ʻAbs (valeur numérique) `

print(abs(2.5))
print(abs(-12.2))

2.5 12.2

** fonction int ** Remplacez les chaînes et les points décimaux par des valeurs entières. Dans le cas d'une chaîne de caractères, seuls les nombres et uniquement les entiers, les points décimaux sont des erreurs Dans le cas de valeurs numériques, les valeurs après la virgule décimale sont tronquées.

print(int(12.3))
print(int('13'))
print(int(0.9))

12 13 0

*** fonction float ***

Passer d'une valeur de caractère ou d'entier à une valeur à virgule flottante. Les lettres doivent être des chiffres. Seulement des lettres et des chiffres.

float (chaîne de caractères) float (valeur entière)

print(float(13))
print(float('15.5'))

13.0 15.5

*** fonction oct ***

Convertir des nombres en valeurs octadécimales ʻOct (valeur numérique) `

print(oct(8))
print(oct(2))

0o10 0o2

*** fonction hexadécimale ***

Convertir des nombres en chaînes hexadécimales hex (valeur numérique)

print(hex(255))
print(hex(16))

0xff 0x10

0x est attaché en notation hexadécimale À partir de 0 et atteignant 16, les chiffres sont incrémentés.

Si vous voulez convertir des nombres hexadécimaux avec ou sans début 0x Ceci peut être réalisé en utilisant la fonction «format».

print(format(255 , 'x'))
print(format(255 , 'X'))
print(format(255 , '#x'))

ff FF 0xff

*** fonction d'entrée ***

Un champ de saisie sort Vous pouvez entrer dans le programme.

ʻInput ('chaîne de caractères') `

s = input('--> ') 
print(s)

-> je suis entré

Je suis entré

*** fonction len *** Renvoie la longueur de l'objet spécifié dans l'argument. len (objet)

a = 'Salut, c'est Matt Damon.'
#Renvoie le nombre de caractères
print(len(a))

17

b = [1,2,3,4,5]
#Renvoie le nombre d'éléments de la liste
print(len(b))

5

*** fonction de liste *** Convertit l'objet spécifié dans l'argument en un type de liste

liste (objet)

#Définir le type de dictionnaire
d1 = {1:2,3:4,5:6}
print(d1)

#Convertir la clé en liste
print(list(d1.keys()))

#Convertir les valeurs en liste
print(list(d1.values()))

#Convertir en une liste avec des éléments de type tuple de clés et de valeurs
print(list(d1.items()))

{1: 2, 3: 4, 5: 6} [1, 3, 5] [2, 4, 6] [(1, 2), (3, 4), (5, 6)]

*** fonction dict ***

Toute combinaison d'une clé et d'une valeur peut être convertie en un type de dictionnaire.

dict (objet)

#Convertir une liste avec des éléments de type tapple en dictionnaire
d2 = dict([('k1', 1), ('k2', 2), ('k3', 4)])
print(d2)

{'k1': 1, 'k2': 2, 'k3': 4}

*** fonction max, min ***

La fonction max renvoie le plus grand des multiples objets spécifiés. La fonction min est l'opposé, renvoyant la plus petite valeur.

max (objet) min (objet)

sample_list = [1,2,3,4,5,6]
#Renvoie la valeur maximale
print(max(sample_list))
#Renvoie la valeur minimale
print(min(sample_list))

6 1

sample_st= 'apple'
#Renvoie la valeur maximale
print(max(sample_st))
#Renvoie la valeur minimale
print(min(sample_st))

p a

*** fonction ouverte ***

Une fonction qui ouvre un fichier et crée un objet fichier. Ceci n'est qu'une introduction et sera expliqué en détail dans une conférence ultérieure.

ʻOpen (chemin du fichier) `

*** fonction de plage ***

Crée des objets pour le nombre de fois spécifié dans l'argument.

plage (nombre de fois) plage (début, fin) plage (début, fin, intervalle)

#Générer 4 entiers
print(list(range(4)))

[0, 1, 2, 3]

*** fonction ronde ***

Arrondit la virgule décimale et renvoie l'entier le plus proche. round (valeur numérique)

print(round(3.499)) 
print(round(3.5))

3 4

Lorsqu'un chiffre est ajouté au deuxième argument, il est arrondi par le nombre de chiffres de la virgule décimale.

print(round(3.5187,3))
print(round(3.5187,1))

3.519 3.5

*** fonction triée ***

Trie les éléments de l'objet spécifié dans l'argument. Pour plus de détails sur l'utilisation de la fonction triée, consultez la conférence sur le tri plus tard. trié (objet)

*** fonction str *** Convertit ce qui est spécifié dans l'argument en une chaîne de caractères str (objet)

#Convertir des valeurs entières en chaînes
print(str(12))

12

*** fonction somme ***

Renvoie la valeur totale des éléments de type liste. L'élément doit être numérique

li =[1,2,3,4]
print(sum(li))

10

*** fonction zip *** *** fonction énumérer ***

Les détails seront donnés dans une conférence ultérieure.

Les fonctions peuvent être utilisées en combinaison

#Convertit un caractère en point décimal, puis le convertit en une valeur entière pour en faire une valeur absolue.
print(abs(int(float('-3.14'))))

3

Lorsqu'il est combiné, celui entre parenthèses est traité en premier.

Dans les fonctions, il est courant d'utiliser plusieurs combinaisons comme celle-ci, Le processus se complique et devient difficile à suivre.

Tout d'abord, recherchez la pièce qui sera traitée en premier et le résultat est-il correct? Je pense qu'il vaut mieux suivre cela un par un.

fonction énumérer

Eh bien, j'ai fait l'écriture répétée avec for sentence, vous vous souvenez? Ceci est un examen de la façon d'écrire une «pour phrase».

Dans l'instruction for, le nombre de répétitions a été spécifié à l'aide de la fonction range et ainsi de suite.

for i in range(5):
    print(i)

0 1 2 3 4

Cela générera un nombre de 0 à 4 dans la fonction range, En tant que «instruction for», le processus est répété 5 fois.

La fonction ʻenumerate gère ceci pour l'instruction Vous pouvez ajouter unevariable qui compte le nombre de fois`.

#Génère un entier de 5 à 9 et itère.
for i , j in enumerate(range(5,10)):
    print(i , j)

0 5 1 6 2 7 3 8 4 9

Quand l'utiliser, c'est compter le nombre de fois que le processus a été effectué Il est souvent utilisé lorsque le processus est quitté par le nombre de fois.

count = 0
for i in range(5):
    print(i)
    if i>=3:
        break
    count+=1

0 1 2 3

for i , j in enumerate(range(5)):
    print(i,j)
    if i>=3:
        break

0 0 1 1 2 2 3 3

Vous pouvez simplifier votre code en éliminant les affectations inutiles aux variables. L'avantage de cette fonction est qu'elle permet de réduire les bogues.

Comptez le nombre de répétitions avec pour instruction etc., ou comme valeur Parce que c'est une fonction utile à utiliser C'est une fonction pratique lors de l'écriture d'un traitement itératif.

fonction zip

La fonction zip utilise deux types de liste et est utilisée dans les répétitions, etc. Une fonction qui vous permet de les utiliser en même temps.

zip (objet, objet)

Tout d'abord, préparez deux variables de type liste Nous utiliserons ceci dans l'instruction for.

a = [1,2,3,4,5]
b = [6,7,8,9,0]

for i , j in zip(a,b):
    print(i,j)

1 6 2 7 3 8 4 9 5 0

Les valeurs des variables de type liste d'origine se trouvent respectivement dans les variables «i» et «j». Il sera stocké.

Si vous essayez d'utiliser deux listes sans utiliser la fonction zip Il ressemblera à ceci.

a = [1,2,3,4,5]
b = [6,7,8,9,0]

count=0
for i in a:
    print(i , b[count])
    count+=1

1 6 2 7 3 8 4 9 5 0

Bien sûr, cela peut être une source de bugs S'il peut être résumé comme un processus Il est plus facile et plus propre d'utiliser la fonction zip.

Aussi, pour les données de type liste qui peuvent être utilisées avec la fonction zip Doit avoir le même nombre d'éléments.

Trier

Trier trie les données. C'est un processus qui est assez souvent utilisé dans les programmes.

** Tri par type de chaîne (ordre inverse) **

Vous pouvez utiliser l'index pour retourner la chaîne.

Chaîne de caractères [:: -1]

a1 = 'abcde Aiueo 123 Secrétaire!'
# [::-1]Tournez-le à l'envers
print(a1[::-1])

! Secrétaire 321 Oevia edcba

Pour trier les caractères utilisés dans une chaîne En convertissant en «type de liste», en triant et en retournant à la «chaîne de caractères» Vous pouvez réorganiser les chaînes de caractères.

Utilisez la fonction sorted pour diviser et trier la chaîne. Si vous spécifiez «True» pour le deuxième argument «reverse», il sera dans l'ordre décroissant. Si «False» est spécifié ou s'il n'y a pas de deuxième argument, l'ordre est croissant.

a2 = 'abcde Aiueo 123 Secrétaire!'
#Convertir en liste avec la fonction triée et trier par ordre croissant
print(sorted(a2,reverse=False))

#Convertir en liste avec la fonction triée et trier par ordre décroissant
print(sorted(a2,reverse=True))

['!', '1', '2', '3', 'a', 'b', 'c', 'd', 'e', 'a', 'i', 'u', ' D ',' o ',' chose ',' coffre '] ['Stem', 'Thing', 'O', 'E', 'U', 'I', 'A', 'e', 'd', 'c', 'b', 'a', ' 3 ',' 2 ',' 1 ','! ']

Utilisez la fonction join pour concaténer les types de liste un par un Cela peut être une chaîne.

`` 'Join string'.join (type de liste) `

a3 = 'abcde Aiueo 123 Secrétaire!'
print(''.join(sorted(a3 , reverse=True)))

Secrétaire Oevia edcba321!

Tri uniquement par chaînes de caractères Vous n'avez peut-être pas la chance de l'utiliser, mais c'est une technique utile en cas d'urgence.

** Tri par type de liste **

Comment utiliser la fonction de tri, qui est une fonction de type liste Il existe une méthode utilisant la fonction triée.

*** fonction de tri ***

Ordre croissant: variable name.sort () Décroissant: variable name.sort (reverse = True)

*** fonction triée ***

Ordre croissant: trié (nom de la variable) Décroissant: trié (nom de la variable, reverse = True)

Les deux sont similaires La fonction de tri trie la liste et modifie l'ordre du type de liste. La fonction triée effectue un tri temporaire, elle n'affecte donc pas l'ordre de la liste d'origine.

lis1= [3,1,2,4,5,7,6]
print(lis1)

#Tri croissant
print(sorted(lis1))

#L'ordre ne change pas même si vous l'appelez à nouveau après la fonction triée
print(lis1)

[3, 1, 2, 4, 5, 7, 6] [1, 2, 3, 4, 5, 6, 7] [3, 1, 2, 4, 5, 7, 6]

lis2= [3,1,2,4,5,7,6]
print(lis2)

#Trier par ordre décroissant
lis2.sort(reverse=True)
#Si vous l'appelez après la fonction de tri, l'ordre changera.
print(lis2)

[3, 1, 2, 4, 5, 7, 6] [7, 6, 5, 4, 3, 2, 1]

Soyez prudent si la commande a un impact significatif sur votre programme.

Que ce soit pour conserver la forme d'origine ou la trier avant de l'utiliser Considérez comment le traiter et l'utiliser correctement.

** Tri par type de dictionnaire **

Tri par type de dictionnaire "Ordre croissant des clés" et "Ordre décroissant des clés" «Ordre croissant par valeur» et «ordre décroissant par« valeur » Il y a quatre manières.

Ordre croissant des clés: trié (variable de type dictionnaire .items ()) Ordre croissant des valeurs: trié (variable de type dictionnaire .items (), clé = lambda x: x [1]) Clé décroissante: triée (variable de type dictionnaire .items (), reverse = True) Ordre décroissant des valeurs: trié (variable de type dictionnaire .items (), key = lambda x: x [1], reverse = True)

#Ordre croissant des clés
dct = { 2:3, 3:4, 1:2, 0:8, 4:2 }
for k, v in sorted(dct.items()):
    print(k,':',v)

0 : 8 1 : 2 2 : 3 3 : 4 4 : 2

#Ordre décroissant des clés
dct = { 2:3, 3:4, 1:2, 0:8, 4:2 }
for k, v in sorted(dct.items(), reverse=True):
    print(k,':',v)

4 : 2 3 : 4 2 : 3 1 : 2 0 : 8

#Valeur par ordre croissant
dct = { 2:'3', 3:'4', 1:'2', 0:'8', 4:'2' }
for k, v in sorted(dct.items(), key=lambda x:x[1]):
    print(k,':',v)

1 : 2 4 : 2 2 : 3 3 : 4 0 : 8

#Ordre décroissant des valeurs
dct = { 2:'3', 3:'4', 1:'2', 0:'8', 4:'2' }
for k, v in sorted(dct.items(), key=lambda x:x[1],reverse=True):
    print(k,':',v)

0 : 8 3 : 4 2 : 3 1 : 2 4 : 2

lambda est lu comme lambda, En python, c'est un «mot réservé» qui représente une «fonction anonyme».

Je parlerai plus de lambda dans une conférence ultérieure, donc Je vais l'omettre ici, mais pour trier par valeur de dictionnaire, Vous devez écrire de cette façon.

Puisque le type de dictionnaire lui-même est un type de données dont l'ordre n'a pas une grande signification Il est courant de ne trier que lors de son utilisation.

Par exemple, affichez finalement uniquement le top 1 Dans un tel cas, la sortie est triée par ordre décroissant.

dct = { 2:'3', 3:'4', 1:'2', 0:'8', 4:'2' }

#Triez d'abord le dictionnaire dans l'ordre décroissant des valeurs, puis intégrez-le dans la fonction enumrate
for i , d  in enumerate(sorted(dct.items(), key=lambda x:x[1],reverse=True)):
    if i>=1:
        #Quittez le processus la deuxième fois
        break
    print(i,d[0],d[1])

0 0 8

Lors de l'itération, triez d'abord le dictionnaire par ordre décroissant de valeurs. Regardez le nombre de décomptes retourné par la fonction ʻenumerate` et quittez le processus itératif.

Ce faisant, lorsqu'il y a une grande quantité de données, il est possible de sortir jusqu'au nombre supérieur Vous pourrez également le faire.

En guise de mise en garde, si vous utilisez la fonction ʻenumerate et le type de dictionnaire ʻitems Veuillez noter que les types de données renvoyés sont de type numérique et de type tapple.

En python, en utilisant la fonction sorted, Vous pouvez trier les données sous différentes formes.

Je pense que cela vous aidera à créer un programme qui traite de choses où l'alignement est important.

Notation d'inclusion

La notation d'inclusion est un style d'écriture spécifique à Python C'est une méthode pour écrire simplement un certain processus.

** Comment écrire la notation d'inclusion **

Liste: [valeur de la variable dans l'objet itérable] Dictionnaire: {key: value for variable in iterable object} Définir: {valeur de la variable dans l'objet itérable}

** Faites une liste en utilisant la notation d'inclusion **

[Valeur de la variable dans un objet itérable]

#Stocker le type de liste dans la variable en notation d'inclusion
lis1 = [i for i in range(10)]
print(lis1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Si vous n'utilisez pas la notation d'inclusion

lis2 = []
for i in range(10):
    lis2.append(i)
print(lis2)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La notation inclusive peut combiner un traitement qui couvre plusieurs lignes en une seule ligne.

** Créez un dictionnaire en utilisant la notation d'inclusion **

{Clé: valeur de la variable dans l'objet itérable}

#Énumérer la clé avec la notation d'inclusion,Créer un type de dictionnaire à la suite de la valeur de plage
num_dict = {k:v for k,v in enumerate(range(2,30,3))}
print(num_dict)

{0: 2, 1: 5, 2: 8, 3: 11, 4: 14, 5: 17, 6: 20, 7: 23, 8: 26, 9: 29}

Un type de dictionnaire peut être créé s'il existe une clé et une valeur correspondantes. Vous pouvez également utiliser l '«instruction IF» dans la notation d'inclusion.

** Notation d'inclusion + instruction IF **

Liste: [valeur de la variable dans l'objet itérable si condition] Dictionnaire: {key: value if condition for variable in iterable object}`

** Notation d'inclusion + IF, instruction else **

Liste: [valeur 1 si condition sinon valeur 2 pour la variable dans l'objet itérable] Dictionnaire: {key 1 if condition else key 2: value 1 if condition else value 2 for variable in iterable object}

#Notation d'inclusion de liste+Instruction IF
num_list = [i for i in range(15) if i%2==0]
print(num_list)

[0, 2, 4, 6, 8, 10, 12, 14]

#Notation d'inclusion de liste+ IF ,autre déclaration
num_list = [i if i%2==0 else 0 for i in range(15) ]
print(num_list)

[0, 0, 2, 0, 4, 0, 6, 0, 8, 0, 10, 0, 12, 0, 14]

#Notation d'inclusion de dictionnaire+Instruction IF
num_dict = {k:v for k,v in enumerate(range(2,30,3)) if k%2==0}
print(num_dict)

{0: 2, 8: 26, 2: 8, 4: 14, 6: 20}

#Notation d'inclusion de dictionnaire+ IF ,autre déclaration
num_dict = {k if k%2==0 else 0 : v if k%2==0 else 0  
for k,v in enumerate(range(2,30,3)) }
print(num_dict)

{0: 0, 8: 26, 2: 8, 4: 14, 6: 20}

Le type de dictionnaire est la fonction zip sans utiliser la fonction ʻenumerate`. Vous pouvez également le créer en utilisant deux listes.

lis_a = [1,2,3,4,5]
lis_b = ['a','b','c','d','e']
d2 = {k:v for k,v in zip(lis_a,lis_b)}
print(d2)

{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

Vous pouvez également créer un dictionnaire à partir de l'instruction IFELSE de notation d'inclusion de liste.

#De la notation d'inclusion de liste au dictionnaire
num_dict = dict((str(i),i) if i%2==0 else (i,str(i)) for i in range(10))
print(num_dict)

{9: '9', 1: '1', 3: '3', '8': 8, 5: '5', '0': 0, '2': 2, '4': 4, '6': 6, 7: '7'}

Vous pouvez écrire plusieurs «instructions for» dans la notation incluse.

[Valeur de la variable 1 dans un objet itérable pour la variable 2 dans un objet itérable]

#Notation à double inclusion
print([i*j for i in range(1,5) for j in range(1,4) ])

[1, 2, 3, 2, 4, 6, 3, 6, 9, 4, 8, 12]

Écrivons ceci dans une instruction for normale.

a5 = []
for i in range(1,5):
    for j in range(1,4):
        a5.append(i * j)
print(a5)

[1, 2, 3, 2, 4, 6, 3, 6, 9, 4, 8, 12]

Celui écrit plus tard correspond à la déclaration for interne.

Il est possible d'écrire des choses qui s'étendent sur plusieurs lignes sur une seule ligne comme ceci. C'est un bon point de la notation d'inclusion.

Commencez par écrire correctement le processus normal, S'il y a une partie qui peut la simplifier, changez-la en notation d'inclusion Si vous faites quelque chose comme ça, vous pourrez bien vous en souvenir.

Résumé

Python a de nombreuses fonctions en tant que fonctions standard Faites de même sans écrire beaucoup de code inutile Cela peut être fait avec une petite quantité de code.

En combinant des fonctions Vous pouvez également réduire la quantité de code Il est utile de se souvenir du comportement des fonctions couramment utilisées.

Parce que le tri est toujours effectué lors du tri des données Comment réorganiser et comment écrire du code Maintenons-le.

La notation incluse est une notation spécifique à Python Vous pouvez écrire un processus qui s'étend sur plusieurs lignes sur une seule ligne Cela entraînera une réduction de la quantité de code et une réduction du temps d'exécution.

Une petite quantité de code supprime l'apparition de bogues Cela raccourcira également le temps de débogage. Apprenons à écrire spécifiquement à Python.

70 jours jusqu'à ce que vous deveniez ingénieur

Informations sur l'auteur

HP d'Otsu py: http://www.otupy.net/

Youtube： https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw

Twitter： https://twitter.com/otupython