Aperçu

Reportez-vous à «Introduction à Python 3» d'O'Reilly Japan et au document de traduction japonais Python suivant. Étudiez la grammaire de base du système Python3. J'espère que cela sera utile pour ceux qui veulent étudier Python de la même manière.

Documentation Python 3.6.1 https://docs.python.jp/3/index.html

Type de séquence

Le type de séquence est une structure de données permettant de gérer 0 ou plusieurs éléments. Le type de séquence de base correspond à liste, tuple, plage, etc.

Type de liste (liste)

Les listes conviennent aux séquences mutables dont l'ordre et le contenu peuvent changer. En outre, la même valeur peut apparaître plusieurs fois dans la liste. (Si vous ne vous souciez pas de la commande si vous pouvez gérer des valeurs uniques, vous pouvez utiliser un ensemble)

Créé par [] ou list ()

>>> #Créer un tableau vide[]
>>> empty_list1 = []
>>> empty_list1
[]

>>> #Création de liste[]
>>> str_list1 = ['A','B','C']
>>> str_list1
['A', 'B', 'C']

>>> #Création d'une liste de tableaux vide()
>>> empty_list2 = list()
>>> empty_list2
[]

>>> #Liste de création de liste()
>>> str_list2 = list(['A','B','C'])
>>> str_list2
['A', 'B', 'C']

Conversion d'autres types de données en types de listes

>>> #Convertir des chaînes en listes
>>> list('ABC')
['A', 'B', 'C']

>>> #Convertir les taples en listes
>>> tuple_sample = ('A','B','C')
>>> list(tuple_sample)
['A', 'B', 'C']

>>> #Convertir le résultat du fractionnement en une liste
>>> today = '2017/07/01'
>>> today.split('/')
['2017', '07', '01']

>>> #Convertir le résultat de la division de la division en liste (lorsqu'un élément de caractère vide est inclus)
>>> target = 'A//B/C/DE///F'
>>> target.split('/')
['A', '', 'B', 'C', 'DE', '', '', 'F']
>>> target.split('//')
['A', 'B/C/DE', '/F']

Extraire l'élément avec [offset] spécifié

>>> target = ['A','B','C']

>>> #Spécifiez un indice positif
>>> target[0]
'A'
>>> target[1]
'B'
>>> target[2]
'C'

>>> #Spécifiez un index négatif (comptez dans l'ordre inverse à partir de la fin)
>>> target[-1]
'C'
>>> target[-2]
'B'
>>> target[-3]
'A'

>>> #Erreur si un décalage hors plage est spécifié
>>> target[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Liste des listes

Le type de liste peut stocker des éléments de différents types (y compris d'autres types de liste).

>>> str_upper = ['A','B','C']
>>> str_lower = ['a','b','c']
>>> str_number = [1 ,'2','3',4]
>>> all_str = [str_upper, str_lower, str_number]

>>> #Liste des listes
>>> all_str
[['A', 'B', 'C'], ['a', 'b', 'c'], [1, '2', '3', 4]]

>>> #Premier élément de la liste dans la liste
>>> all_str[0]
['A', 'B', 'C']

>>> #Le deuxième élément de la liste dans la liste
>>> all_str[1]
['a', 'b', 'c']

>>> #Troisième élément de la liste dans la liste
>>> all_str[2]
[1, '2', '3', 4]

>>> #Si vous spécifiez deux index, seuls les éléments de la liste intégrée seront renvoyés.
>>> all_str[1][0]
'a'

Réécriture de l'élément avec [offset] spécifié

Comme la liste est modifiable, vous pouvez réécrire la valeur en spécifiant le décalage.

>>> target = ['A','B','C']
>>> target
['A', 'B', 'C']

>>> target[1] = 'V'
>>> target
['A', 'V', 'C']

>>> #L'ajout d'éléments à la liste est un ajout()Faire par
>>> target[3] = 'D'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range

Extraction par tranche avec la plage spécifiée de [offset]

>>> target = ['A','B','C']
>>> target
['A', 'B', 'C']

>>> #Depuis le début
>>> target[0:]
['A', 'B', 'C']

>>> #2 caractères depuis le début
>>> target[0:2]
['A', 'B']

>>> #Inverser les éléments de la liste
>>> target[::-1]
['C', 'B', 'A']

Ajouter un élément à la fin avec append ()

>>> target = ['A','B','C']
>>> target.append('D')
>>> target
['A', 'B', 'C', 'D']

Ajouter un élément avec insert ()

La fonction append () ajoute un élément à la fin, utilisez donc ceci si vous souhaitez ajouter un élément en spécifiant un décalage et une position supplémentaire. De plus, si un décalage qui dépasse la fin est spécifié, il sera ajouté à la fin de la liste. (Aucune exception ne peut être levée pour des décalages incorrects)

>>> target = ['A','B','C']

>>> #Ajouté au 3ème personnage
>>> target.insert(2,'Q')
>>> target
['A', 'B', 'Q', 'C']

>>> #Si vous spécifiez un décalage qui dépasse la fin
>>> target.insert(10,'Z')
>>> target
['A', 'B', 'Q', 'C', 'Z']

>>> #En comptant à partir de la fin
>>> target.insert(-2,'V')
>>> target
['A', 'B', 'Q', 'V', 'C', 'Z']

Supprimer des éléments avec del

Puisque del est une instruction Python, pas une méthode de liste, nous n'écrivons pas del ().

>>> target = ['A','B','C','D','E']

>>> #Supprimer le troisième caractère
>>> del target[2]
>>> target
['A', 'B', 'D', 'E']

>>> #Supprimer la fin
>>> del target[-1]
>>> target
['A', 'B', 'D']

Supprimer l'élément avec remove ()

Si vous souhaitez spécifier un élément et le supprimer au lieu de spécifier un décalage, utilisez ceci au lieu de del.

>>> target = ['A','B','C','D','E']
>>> target.remove('B')
>>> target
['A', 'C', 'D', 'E']

Extraire et supprimer des éléments avec pop ()

Vous pouvez utiliser pop () pour récupérer un élément de la liste et le supprimer de la liste en même temps. Si aucun argument n'est spécifié, -1 (fin) est spécifié comme décalage.

>>> target = ['A','B','C','D','E','F','G']
>>> #Pop le troisième personnage
>>> target.pop(2)
'C'
>>> target
['A', 'B', 'D', 'E', 'F', 'G']

>>> #Pop le dernier personnage
>>> target.pop()
'G'
>>> target
['A', 'B', 'D', 'E', 'F']

>>> #Pop le premier personnage
>>> target.pop(0)
'A'
>>> target
['B', 'D', 'E', 'F']

Combinez des listes en utilisant extend () ou + =

>>> # extend()Combiner la liste par
>>> target1 = ['A','B','C']
>>> target2 = ['D','E']
>>> target1.extend(target2)
>>> target1
['A', 'B', 'C', 'D', 'E']

>>> # +=Combiner la liste par
>>> target1 = ['A','B','C']
>>> target2 = ['D','E']
>>> target1 += target2
>>> target1
['A', 'B', 'C', 'D', 'E']

Vérifier le décalage de l'élément par index ()

>>> target = ['A','B','C','D','E','F','G']
>>> target.index('D')
3

Jugement de valeur de présence / absence à l'aide de ()

>>> target = ['A','B','C','D','E','F','G']
>>> 'A' in target
True
>>> 'Z' in target
False

Compter le nombre de valeurs à l'aide de count ()

>>> target = ['A','A','A','B','B','C']
>>> target.count('A')
3
>>> target.count('B')
2
>>> target.count('C')
1

Conversion en chaîne par join ()

join () est une méthode de chaîne, pas une méthode de liste.

>>> target = ['A','B','C','D','E','F','G']
>>> ','.join(target)
'A,B,C,D,E,F,G'

Obtenez le nombre d'éléments avec len ()

>>> target = ['A','B','C','D','E','F','G']
>>> len(target)
7

Tri des éléments par sort () (supplémentaire lors de l'utilisation de fonctions générales)

>>> #Fonction générique triée()Tri croissant par
>>> target = ['C','E','A','D','B','F']
>>> sorted_target = sorted(target)
>>> sorted_target
['A', 'B', 'C', 'D', 'E', 'F']

>>> #Fonction générique triée()Tri décroissant par
>>> target = ['C','E','A','D','B','F']
>>> sorted_target = sorted(target, reverse=True)
>>> sorted_target
['F', 'E', 'D', 'C', 'B', 'A']

>>> #Tri des fonctions de liste()Tri croissant par
>>> target = ['C','E','A','D','B','F']
>>> target.sort()
>>> target
['A', 'B', 'C', 'D', 'E', 'F']

>>> #Tri des fonctions de liste()Tri décroissant par
>>> target = ['C','E','A','D','B','F']
>>> target.sort(reverse=True)
>>> target
['F', 'E', 'D', 'C', 'B', 'A']

Copie de la liste avec copy () (Supplément à d'autres méthodes de copie)

>>> target = ['A','B','C']

>>> #Copie de liste()Copier par fonction
>>> target1 = target.copy()
>>> target1
['A', 'B', 'C']

>>> # list()Copie par fonction de conversion
>>> target2 = list(target)
>>> target2
['A', 'B', 'C']

>>> #Copier par tranche de liste
>>> target3 = target[:]
>>> target3
['A', 'B', 'C']

Type de tuple

Contrairement aux listes, les taples sont des séquences immuables, vous ne pouvez donc pas ajouter, supprimer ou modifier des éléments après avoir défini un tapple. De plus, comme il n'y a pas de fonctions telles que append () et insert (), il y a moins de fonctions que de listes.

Pour utiliser correctement, utilisez tapple pour gérer une liste de constantes. Les autres points à considérer sont les suivants.

--Taple consomme moins d'espace.

Il n'y a aucun danger que les éléments du tuple soient réécrits. --Taple peut être utilisé comme clé de dictionnaire.
Les taples nommés peuvent être utilisés comme une simple alternative aux objets.
Les arguments de fonction sont passés sous forme de tapples.

Créer un taple

>>> #Créer un taple vide
>>> empty_tuple = ()
>>> empty_tuple
()

>>> #Tapez avec un élément (avec une virgule à la fin)
>>> target1 = 'A',
>>> target1
('A',)

>>> #Plusieurs éléments (la virgule de fin peut être omise)
>>> target2 = 'A','B','C'
>>> target2
('A', 'B', 'C')

>>> #Il est plus facile de comprendre s'il s'agit d'un taple car cela ne provoque pas d'erreur même si vous mettez des parenthèses
>>> target3 = ('A','B','C')
>>> target3
('A', 'B', 'C')

Conversion en taple par tuple ()

>>> str_list = ['A','B','C']
>>> tuple(str_list)
('A', 'B', 'C')

Autre

Déballage de la séquence

>>> #Répertorier les devoirs non emballés
>>> str_list = ['A','B','C']
>>> s1, s2, s3 = str_list
>>> s1
'A'
>>> s2
'B'
>>> s3
'C'

>>> #Affectation de déballage Taple
>>> str_tuple = ('A','B','C')
>>> s1, s2, s3 = str_tuple
>>> s1
'A'
>>> s2
'B'
>>> s3
'C'

Grammaire de base de la série Python3 (liste, tapple)