index
Lisez ce qui suit pour l'installer et apprendre à l'utiliser. Indispensable pour l'analyse des données! Comment utiliser Jupyter Notebook [Pour les débutants]
Lors de la création d'une chaîne, placez-la entre guillemets simples ou doubles. De plus ** Python ne nécessite pas de déclaration de type variable. ** Vous pouvez l'utiliser simplement en attribuant une valeur.
msg = 'test'
print(msg) #production:test
data = 1
print(data) #production: 1
data = data + 10
print(data) #production: 11
** List ** permet de gérer plusieurs valeurs en tant que groupe. Identique au ** array dans d'autres langues. ** **
data_list = [1,2,3,4,5,6,7,8,9,10]
print(data_list) #production: [1,2,3,4,5,6,7,8,9,10]
print('Deuxième numéro:', data_list[1]) #production:Deuxième numéro:2
print('Nombre d'éléments:', len(data_list)) #production: Nombre d'éléments:10
#Multiplier la liste par 2 ne fait que répéter la liste entière à nouveau. Si vous voulez doubler, utilisez for statement ou Numpy
print(data_list * 2) #production: [1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10]
Utilisez ʻappendpour ajouter des éléments de liste,remove, pop, del`, etc. pour les supprimer.
data_list2 = [1,2,3,4,5]
print(data_list2) #production: [1,2,3,4,5]
#Recherche le même élément que la valeur spécifiée entre parenthèses et supprime le premier élément
data_list2.remove(1)
print(data_list2) #production: [2,3,4,5]
data_list3 = [1,2,3]
data_list3.append(10)
print(data_list3) #production: [1, 2, 3, 10]
Dans le type de dictionnaire, ** les clés et les valeurs peuvent être associées pour gérer plusieurs éléments **.
Pour représenter un dictionnaire en Python, utilisez un délimiteur conro tel que {key: value}.
Il est utilisé lorsque vous souhaitez conserver la valeur d'une clé spécifiée, telle que «apple is 100» ou «banana is 200», comme dans l'exemple suivant.
dic_data = {'apple':100, 'banana':200}
print(dic_data['banana']) #production: 200
dic_data["banana"] #production: 200
Si vous souhaitez ajouter un élément de dictionnaire, target dictionary [clé] = élément
dic_data ["orange"] = 300
print(dic_data) #production: {'apple': 100, 'banana': 200, 'orange': 300}
Si vous voulez supprimer les éléments du dictionnaire del target dictionary [clé]
del dic_data["apple"]
print(dic_data) #production: {'banana': 200, 'orange': 300}
[Une addition]
Si vous voulez récupérer uniquement les clés et les valeurs sous forme de ** liste **, utilisez .keys () ou .values ().
Les listes acquises sont acquises comme «dict_keys» et «dict_values», respectivement.
dic_data = {'apple':100, 'banana':200}
dic_data.keys() #production: dict_keys(['apple', 'banana'])
dic_data.values() #production: dict_values([100, 200])
L'instruction for suivante utilise également keys () et values () pour récupérer, mais l'instruction for vous permet de récupérer toutes les clés et valeurs dans l'ordre au lieu d'une liste.
C'est un type qui peut stocker plusieurs valeurs comme une liste, mais la différence est que ** ne peut pas être modifié ** et ** la vitesse d'exécution est un peu plus rapide **. Explication de l'utilisation des tapples et des différences par rapport aux listes
list_sample = [1, 2, 3, 4, 5]
tuple_sample = (1, 2, 3, 4, 5)
#Vous n'avez pas besoin de parenthèses
tuple_sample2 = 1, 2, 3, 4, 5
print(list_sample) #production: [1, 2, 3, 4, 5]
print(tuple_sample) #production: (1, 2, 3, 4, 5)
print(tuple_sample2) #production: (1, 2, 3, 4, 5)
Un ensemble est également un type qui peut stocker plusieurs valeurs comme une liste, mais la différence est que ** les éléments en double sont ignorés ** points et ** les éléments sont dans le désordre ** points. [Introduction à Python] Facile à comprendre! Résumé de base du type d'ensemble (type d'ensemble)
set_data1 = set([1,2,3])
set_data2 = set([1,2,3,3,2,1])
print(set_data1) #production: {1, 2, 3}
print(set_data2) #production: {1, 2, 3}
if [Expression conditionnelle]:
[Traitement à effectuer lorsque l'expression conditionnelle est True]
else:
[Traitement à effectuer lorsque l'expression conditionnelle est False]
ʻEl if est ʻelse if dans d'autres langues
if [Expression conditionnelle 1]:
[Traitement à effectuer lorsque l'expression conditionnelle est True]
elif [Expression conditionnelle 2]:
[Traitement à effectuer lorsque l'expression conditionnelle 2 d'elif est True]
else:
[Traitement à effectuer lorsque l'expression conditionnelle 1 de l'instruction if et l'expression conditionnelle 2 de elif sont toutes deux fausses]
data_list4 = [1,2,3,4,5,6]
findvalue = 10
if findvalue in data_list4:
print('{0}A été trouvé.' .format(findvalue))
else:
print('{0}N'a pas été trouvé.' .format(findvalue))
#production:10 n'a pas été trouvé.
La `` chaîne de caractères'.format (valeur, ...) `utilisée pour afficher le résultat est appelée le format de chaîne de caractères, et le {0} spécifié ci-dessus est la valeur spécifiée au début des crochets de format. C'est une spécification à intégrer.
print('{0}Quand{1}を足すQuand{2}est.' .format(2,3,5))
#production:Ajoutez 2 et 3 pour obtenir 5.
Il se comporte comme n'importe quelle autre langue. Reportez-vous à ce qui suit pour savoir comment écrire.
data_list5 = [1,2,3,4,5]
total = 0
for num in data_list5:
total += num
print('total:',total) #production: total: 15
Lors de la récupération d'éléments à l'aide de l'instruction for dans le type de dictionnaire
méthode key (): récupérer la clé
méthode values (): Récupère les valeurs. '' Méthode ʻItems (): extraire les deux. Il y a trois de .
dic_data2 = {'apple':100, 'banana':200, 'orange':300}
for all_data in dic_data2:
print(all_data)
#production: apple
# banana
# orange
for all_data in dic_data2.keys():
print(all_data)
#production: apple
# banana
# orange
for all_data in dic_data2.values():
print(all_data)
#production: 100
# 200
# 300
for all_data in dic_data2.items():
print(all_data)
#production: ('apple', 100)
# ('banana', 200)
# ('orange', 300)
for all_data1,all_data2 in dic_data2.items():
print(all_data1,all_data2)
#production: apple 100
# banana 200
# orange 300
Une fonction à utiliser lorsque vous souhaitez créer une liste continue d'entiers. Notez que lorsque «range (N)» est défini, un entier de 0 à N-1 est émis.
for i in range(10):
print(i)
production
0
1
2
3
4
5
6
7
8
9
De plus, la fonction de plage vous permet de spécifier «première valeur», «dernière valeur-1» et «sauter valeur» entre parenthèses.
#Passer 2 pièces de 1 à 9
for i in range(1,10,2):
print(i)
production
1
3
5
7
9
Comment créer un résultat comme une autre liste des données récupérées à l'aide de l'instruction for.
#Extraire la valeur des données et la stocker dans la variable i. Doublez ce chiffre par data1
data = [1,2,3,4,5]
data1 = []
data1 = [i * 2 for i in data]
print(data1) #production: [2, 4, 6, 8, 10]
Vous pouvez également spécifier des conditions et inclure uniquement celles qui remplissent les conditions dans la nouvelle liste. On voit que seul «i» qui remplit les conditions est retiré en premier et doublé.
data = [1,2,3,4,5]
[i * 2 for i in data if i % 2 ==0] #production: [4, 8]
Exécute le processus de récupération de différentes listes en même temps. Par exemple, si vous avez deux listes, [1,2,3] et [11,12,13], elles seront affichées avec le même index.
for x , y in zip([1,2,3], [11,12,13]):
print(x, 'Quand', y)
production
1 et 11
2 et 12
3 et 13
num = 1 #valeur initiale
while num <= 10:
print(num)
num = num + 1
production
1
2
3
4
5
6
7
8
9
10
Un mécanisme pour mettre en place une série de processus. Pour écrire, s'il y a un nom de fonction et un argument après def, décrivez le nom de l'argument entre (). Cet argument devient une entrée et return renvoie le résultat (valeur de retour), qui est la sortie.
def calc_multi(a,b):
return a*b
calc_multi(3,10) #production: 30
Certaines fonctions sont appelées fonctions anonymes, qui peuvent être utilisées pour simplifier le code. Pour écrire une fonction anonyme, utilisez le mot-clé «lambda». Les fonctions anonymes sont souvent utilisées lorsque vous souhaitez exécuter une fonction sur un élément tel qu'une liste.
(lambda a,b: a*b)(3,10) #production: 30
Ici, lambda a, b: est la partie correspondant au nom de la fonction (a, b).
La manière de base d'écrire une fonction anonyme est de décrire le traitement de la fonction (ici, return a * b) en la séparant par:.
map
Si vous voulez faire quelque chose avec un élément, utilisez la fonction map.
Fonction qui utilise une fonction comme argument ou valeur de retour, et qui est utilisée lorsque vous souhaitez traiter ou opérer sur chaque élément.
def calc_double(x):
return x * 2
#Lors de l'utilisation pour
for num in [1,2,3,4]:
print(calc_double(num)) #production: ①
#Lors de l'utilisation de la fonction de carte
list(map(calc_double, [1,2,3,4])) #production: ②
production
Sortie de ①
2
4
6
8
Sortie de ②[2, 4, 6, 8]
Si vous utilisez une fonction anonyme, vous pouvez décrire directement le traitement de la fonction sans préparer une fonction distincte.
list(map(lambda x : x * 2, [1,2,3,4])) #production: [2, 4, 6, 8]
Recommended Posts