Structure et fonctionnement des données Python (mémo d'apprentissage Python ③)

Cette fois est un mémo d'apprentissage sur la structure de données des objets manipulés par Python

Méthodes pouvant être utilisées dans les listes

Ajouter un élément

list.append(x) Ajouter un élément à la fin de la liste Équivaut à une [liste (a):] = [x]

list.extend(L) Étendre la liste en ajoutant tous les éléments de la liste donnée L à la fin de la liste Équivalent à a [len (a):] = L

list.insert(i, x) Insère un élément à la position spécifiée. Le premier argument est l'index de l'élément. L'insertion se fait avant cet élément. a.insert (0, x) l'insérera au début de la liste a.insert (len (a), x) équivaut à a.append (x)

Supprimer et récupérer des éléments

list.remove(x) Supprimer le premier élément avec la valeur x Erreur si non présente

list.pop([i]) Supprime l'élément à la position spécifiée de la liste et renvoie cet élément Si aucun index n'est spécifié, retournez le dernier élément et supprimez-le de la liste

• [] Signifie facultatif. Ne décrit pas réellement «[]»

list.clear() Supprimer tous les éléments de la liste Équivalent à del a [:]

Autres opérations

list.index() Renvoie l'index du premier élément avec une valeur de x. Erreur si aucun élément de ce type n'existe

list.count(x) Renvoie le nombre de x dans la liste

list.sort(key=None, reverse=False) Trier les objets de liste directement (apporter des modifications directement sans faire une copie de la liste) Le tri peut être personnalisé avec des arguments

list.reverse() Inverser directement l'objet de liste

list.copy() Renvoie une copie superficielle de la liste Équivalent à un [:]

a = [66.25, 333, 333, 1, 1234.5]

print(a.count(333), a.count(66.25), a.count('x'))
# 2 1 0

a.insert(2, -1)
a.append(333)
print(a)
# [66.25, 333, -1, 333, 1, 1234.5, 333]

print(a.index(333))
# 1

a.remove(333)
print(a)
# [66.25, -1, 333, 1, 1234.5, 333]

a.reverse()
print(a)
# [333, 1234.5, 1, 333, -1, 66.25]

a.sort()
print(a)
# [-1, 1, 66.25, 333, 333, 1234.5]

print(a.pop())
# 1234.5

print(a)
# [-1, 1, 66.25, 333, 333]

Utilisez la liste comme une pile

point

• Les méthodes de liste facilitent l'utilisation des listes sous forme de pile

Exemple de dernier entré, premier sorti

stack = [3, 4, 5]

stack.append(6)
stack.append(7)

print(stack)
# [3, 4, 5, 6, 7]

print(stack.pop())
# 7

print(stack)
# [3, 4, 5, 6]

print(stack.pop())
# 6

Utiliser la liste comme file d'attente

point

• Peut être utilisé comme une file d'attente similaire
• Cependant, contrairement à append et pop, insérer et pop au début de la liste sont lents, vous devez donc utiliser collection.deque pour implémenter la file d'attente.

collection.File d'attente avec deque(Premier entré, premier sorti)Implémentation de

from collections import deque

queue = deque(["Bill", "Earl", "Sam"])
queue.append("Andy")
queue.append("Chris")
print(queue.popleft())
# Bill
print(queue.popleft())
# Earl
print(queue)
# deque(['Sam', 'Andy', 'Chris'])

Inclusion de liste

point

• Se compose d'une expression suivie d'une clause for
• Ajoutez 0 ou plus de clauses for and if à la fin, et mettez le tout entre []
• Vous obtiendrez une nouvelle liste de valeurs qui évaluent la première expression dans les clauses for et if suivantes.
• Également utile lorsque vous souhaitez effectuer un traitement commun pour tous les éléments de la liste.

Un exemple simple de génération d'une liste de carrés

#Générer une liste de carrés
squares = []
for x in range(10):
    squares.append(x**2)
    
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

#Le processus ci-dessus laisse une variable appelée x
print(x)

#Vous pouvez créer une liste sans effets secondaires en procédant comme suit
squares = list(map(lambda x: x**2, range(10)))

#Si vous écrivez ↑ dans la liste, ce sera comme suit
squares = [x**2 for x in range(10)]

Un exemple un peu plus compliqué

combs = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(combs)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

#Cela équivaut à
combs = []
for x in [1, 2, 3]:
    for y in [3, 1, 4]:
        if x != y:
            combs.append((x, y))

print(combs)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Autre utilisation pratique

vec = [-4, -2, 0, 2, 4]
#Générer une nouvelle liste avec des valeurs doublées
double = [x*2 for x in vec]

print(double)
# [-8, -4, 0, 4, 8]

#Filtrer pour supprimer les nombres négatifs
positive_list = [x for x in vec if x >= 0]
print(positive_list)
# [0, 2, 4]

Inclusion de liste imbriquée

point

• Vous pouvez utiliser n'importe quelle expression au début de l'inclusion de liste, et vous pouvez mettre d'autres inclusions de liste ici.

Permuter les lignes et les colonnes dans un tableau

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]

#Permuter les lignes et les colonnes
reversed_matrix = [[row[i] for row in matrix] for i in range(4)]
print(reversed_matrix)
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

• En réalité, les flux complexes devraient utiliser des fonctions intégrées

Exemple de fonction zip

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]

print(list(zip(*matrix)))
# [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

déclaration del

point

• Lors de la suppression d'éléments de la liste, il existe un moyen de spécifier par index au lieu de valeur
• Contrairement à la méthode pop () en ce qu'elle ne renvoie pas de valeur
• L'instruction del peut également être utilisée pour découper une liste ou effacer la liste entière

Exemple utilisant l'instruction del

a = [-1, 1, 66.25, 333, 333, 1234.5]

#Spécifié par index
del a[0]

print(a)
# [1, 66.25, 333, 333, 1234.5]

#Spécifié par tranche
del a[2:4]

print(a)
# [1, 66.25, 1234.5]

#Effacer toute la liste
del a[:]

print(a)
# []

#Supprimer la variable entière (après cela, référencer a entraînera une erreur)
del a

Tapez et séquence

point

• Impossible d'attribuer aux éléments de tapple
• Il est possible de générer des tuples contenant des objets mutables tels que des listes
• Les taples sont immuables et se succèdent généralement avec des éléments dissemblables
• Il est habituel d'accéder à chaque élément par décompression, index ou attribut.
• Similaire aux listes, mais les listes sont modifiables, généralement constituées d'éléments similaires, et accessibles en itérant sur la liste.

Opération Taple

#Les taples se composent de valeurs séparées par des virgules (tapple packing)
t = 12345, 54321, 'hello!'

#Le déballage est également possible par la méthode suivante(Déballage de séquence)
x, y, z = t
print(x) # 12345
print(y) # 54321
print(z) # hello!

print(t)
# (12345, 54321, 'hello!')

#Les taples peuvent être imbriqués
u = t, (1, 2, 3, 4, 5)

print(u)
# ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

#Taple ne peut pas être changé
# t[0] = 88888

#Les objets modifiables peuvent être stockés
v = ([1, 2, 3], [3, 2, 1])
print(v)
# ([1, 2, 3], [3, 2, 1])

#Taple vide
empty = ()

#Taple avec 1 élément
singleton = 'hello', <-Ajouter une virgule à la fin

Ensemble

point

• Un ensemble est une collection d'éléments qui ne se chevauchent pas sans ordre particulier.
• Les utilisations de base comprennent l'évaluation de l'existence et l'élimination des entrées en double.
• Les objets agrégés prennent en charge les opérations mathématiques telles que les sommes, les intersections, les différences et les différences symétriques
• Utilisez la fonction entre parenthèses du milieu {} ou set () pour générer l'ensemble
• Vous devez utiliser set () au lieu de {} pour générer un ensemble vide (le premier générera un dich vide)

donner l'exemple

basket = {'apple', 'orage', 'apple', 'pear', 'orange', 'banana'}
print(basket)
# {'banana', 'pear', 'apple', 'orage', 'orange'}

print('orange' in basket) #Jugement d'existence à grande vitesse
# True
print('crabgrass' in basket)
# False

#Définir l'opération en prenant un caractère unique de deux mots
a = set('abracadabra')
b = set('alacazam')

#Caractère unique d'un
print(a)
# {'r', 'a', 'c', 'b', 'd'}

#Caractères qui existent dans a mais pas dans b
print(a - b)
{'r', 'b', 'd'}

#Caractères présents dans a ou b
print(a | b)
# {'z', 'r', 'a', 'c', 'b', 'd', 'l', 'm'}

#Caractères qui existent à la fois dans a et b
print(a & b)
# {'c', 'a'}

#Caractères inhabituels dans a ou b
print(a ^ b)
# {'m', 'b', 'l', 'z', 'd', 'r'}

#Les inclusions définies qui sont similaires aux inclusions de liste sont également prises en charge
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
# {'r', 'd'}

dictionnaire

point

• Index clé
• Tout type immuable peut être utilisé pour la clé
• Les chaînes de caractères et les nombres peuvent toujours être utilisés comme clés
• Tapple peut également être utilisé comme clé (à condition qu'il ne contienne que des chaînes, des nombres et des tapples)
• Les tapples qui contiennent directement ou indirectement des objets mutables ne peuvent pas être utilisés comme clés
• La liste ne peut pas être utilisée comme clé
• La clé du dictionnaire est unique
• Si vous écrivez la parenthèse du milieu, ce sera un dictionnaire vide {}

Exemple de type de dictionnaire

#Initialisation
tel = {'jack': 4098, 'sape': 4139}

#ajouter à
tel['guido'] = 4127
print(tel) # {'jack': 4098, 'sape': 4139, 'guido': 4127}
print(tel['jack']) # 4098

#Effacer
del tel['sape']
tel['irv'] = 4127
print(tel)
# {'jack': 4098, 'guido': 4127, 'irv': 4127}

#Obtenez une liste de clés
print(list(tel.keys()))
# ['jack', 'guido', 'irv']

#Trier par clé
print(sorted(tel.keys()))
# ['guido', 'irv', 'jack']

#Contrôle d'existence
print('guido' in tel) # True
print('jack' not in tel) # False

# dict()Le constructeur est la clé:À partir d'une séquence de tuples de paires de valeurs
#Construire un dictionnaire
tel2 = dict([('sape', 4139), ('guide', 4127), ('jack', 4098)])
print(tel2)
# {'sape': 4139, 'guide': 4127, 'jack': 4098}

#Les dictionnaires peuvent être générés à partir d'expressions arbitraires qui donnent des clés et des valeurs à l'aide d'inclusions de dictionnaire
print({x: x**2 for x in (2, 4, 6)})
# {2: 4, 4: 16, 6: 36}

#Si la clé est une chaîne, il peut être plus facile de spécifier la paire avec l'argument mot-clé
tel3 = dict(sape=4139, guido=4127, jack=4098)
print(tel3)
# {'sape': 4139, 'guido': 4127, 'jack': 4098}

Technique de boucle

point

• Lorsque vous bouclez le dictionnaire, utilisez la méthode ʻitems () `pour obtenir la clé et la valeur correspondante en même temps.

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

# gallahad the pure
# robin the brave

• Lorsque vous bouclez une séquence, utilisez la fonction ʻenumerate () `pour obtenir l'index de position et la valeur correspondante en même temps.

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

# 0 tic
# 1 tac
# 2 toe

• Lorsque vous bouclez deux séquences ou plus en même temps, vous pouvez utiliser la fonction zip () pour jumeler les deux entrées.
• Au fait, si le nombre de séquences est différent et qu'une paire ne peut pas être créée, la plus grande est omise.

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']

for q, a in zip(questions, answers):
    print('What is your {0}? It is {1}.'.format(q, a))
    
# What is your name? It is lancelot.
# What is your quest? It is the holy grail.
# What is your favorite color? It is blue.

• Pour boucler la séquence dans l'ordre inverse, spécifiez d'abord la séquence dans l'ordre avant, puis appelez la fonction reverse ().

for i in reversed(range(1, 10, 2)):
    print(i)
    
# 9
# 7
# 5
# 3
# 1

• Utilisez la fonction sorted () pour boucler la séquence dans l'ordre trié. Cette fonction ne touche pas la séquence d'origine et renvoie une liste nouvellement triée

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

for f in sorted(set(basket)):
    print(f)
    
# apple
# banana
# orange
# pear

• Si vous souhaitez modifier le contenu de la liste, il est plus facile et plus sûr de créer une nouvelle liste.

import math

raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
filtered_data = []
for value in raw_data:
    if not math.isnan(value):
        filtered_data.append(value)
        
print(filtered_data)
# [56.2, 51.7, 55.3, 52.5, 47.8]

À propos des conditions utilisées pour comparer des objets

point

• Les opérateurs de comparaison «est» et «n'est pas» comparent deux objets pour voir s'ils sont exactement les mêmes
• Tous les opérateurs de comparaison ont la même priorité, tous inférieurs à tous les opérateurs numériques
• Les comparaisons peuvent être combinées par les opérateurs booléens ʻand et ʻor
• La conclusion de la comparaison (et toutes les autres expressions booléennes) peut être refusée par «not».
• Et, ou, n'ont pas une priorité moindre que les opérateurs de comparaison
• La priorité n'est pas> et> ou
• A et non B ou C équivaut à (A et (pas B)) ou C
• et et ou sont appelés opérateurs de court-circuit
• Et et ou sont évalués de gauche à droite, et l'évaluation est arrêtée lorsque la conclusion est décidée.
• Lorsque A et B et C sont donnés, C n'est pas évalué si B est faux.
• Si une valeur générale est utilisée à la place d'une valeur booléenne, la valeur de retour de l'opérateur de court-circuit sera le dernier argument évalué.

string1, string2, string3 = '', 'Tronbheim', 'Hammer Dance'
non_null = string1 or string2 or string3
print(non_null)
# Tronbheim

Comparaison de séquence, comparaison d'autres types

point

• Les objets de séquence peuvent être comparés à des objets du même type de séquence
• Utilisez l'ordre lexical pour cette comparaison
• L'ordre de comparaison est le suivant
• Commencez par comparer les premiers éléments, s'ils sont différents, la taille est utilisée en guise de conclusion, s'ils sont identiques, passez à la comparaison entre les seconds éléments
• Si le même élément continue, la comparaison continuera jusqu'à ce que l'une ou l'autre des séquences soit épuisée
• Si les deux éléments comparés sont également du même type de séquence, une comparaison par dictionnaire sera effectuée de manière récursive.
• Si les éléments des deux séquences sont tous identiques, les deux séquences sont considérées comme identiques.
• Les deux sont fondamentalement la même séquence, et quand l'un est plus court, ce plus court est plus petit.
• Utilisez le numéro de point de code Unicode de chaque caractère pour l'ordre du dictionnaire des chaînes

Comparaison d'objets

(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)