[Notes d'étude Python] 09 ancêtre Yuan, dictionnaire, définir les opérations communes et les principes sous-jacents du dictionnaire

Cette série de notes pour apprendre Python par vous-même, s'il y a des erreurs, veuillez me corriger

Tuple d'origine

La liste est une séquence variable, et les éléments de la liste peuvent être utilisés arbitrairement depuis les temps anciens. Les éléments appartiennent à la séquence immuable et ne peuvent pas modifier les éléments de l'ancêtre d'origine. Par conséquent, l'ancêtre d'origine n'a pas de méthodes associées telles que l'ajout éléments, modification d'éléments et suppression d'éléments.

Yuanzu prend en charge les opérations suivantes:

Accès à l'index
Opération de tranche
Connecter l'opération
Opérations d'adhésion
Opération de comparaison
Count: la longueur de l'ancêtre d'origine len () valeur maximale max () valeur minimale min () somme somme ()

Création de Yuanzu

Créez l'ancêtre via (), les parenthèses peuvent être omises

a = (10,20,30) ou a = 10,20,30

Si l'ancêtre n'a qu'un seul élément, il doit être suivi d'une virgule, car l'interpréteur interprétera (1) comme l'entier 1 (1,) comme ancêtre.
```
a = (1,)
type(a)
```
Créée par tuple ()

tuple (un objet itérable)
```
a = tuple()
b = tuple("a,b,c")
c = tuple([2,3,4])
d = tuple(range(3))
```
Résumé: tuple () peut recevoir des listes, des chaînes, d'autres types de séquence et des itérateurs pour générer des primitives.

list () peut recevoir des primitives, des chaînes, d'autres types de séquences, des itérateurs, etc. pour générer des listes

Accès aux éléments et comptage de l'ancêtre

L'élément de l'ancêtre ne peut pas être modifié

a = (10,20,30,40)
a[3] = 15 #报错 TypeError

L'accès à l'élément de l'ancêtre est le même que celui de la liste, mais l'objet retourné est toujours l'objet ancêtre
```
a = (10,20,30)
a[1]
a[0:2]
```
La méthode de tri de la liste list.sorted () consiste à modifier l'objet de liste d'origine, mais l'ancêtre d'origine n'a pas cette méthode. Si vous souhaitez trier l'ancêtre d'origine, vous ne pouvez utiliser que la fonction intégrée triée (tupleObj ) et générer un nouvel objet liste

Zip *: français

zip (List 1, List 2 ...) combine les éléments aux positions correspondantes de plusieurs listes en un ancêtre primitif et renvoie cet objet zip.

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
list(d)#[(10,40,70),(20,50,80),(30,60,90)]

Générateur de création déductive

D'un point de vue formel, la compréhension du générateur est similaire à la compréhension de la liste, sauf que la compréhension du générateur utilise des parenthèses, et la compréhension de la liste génère directement un objet liste. La compréhension du générateur ne génère pas une liste ou un ancêtre primitif, mais un générateur objet.

Nous pouvons utiliser l'objet générateur pour le convertir en liste ou ancêtre primitif, ou utiliser la __next__()méthode de l' objet générateur pour le parcourir, ou l'utiliser directement comme objet itérateur. Quelle que soit la méthode, une fois l'accès à l'élément terminé, si vous devez revoir l'élément, vous devez recréer l'objet générateur de l'élément.

s = (x*2 for x in range(5))#迭代器对象
s
tuple(s)
list(s) #此时为空 因为只能访问一次
s = (x*2 for x in range(5))
s.__next__() #访问下一个元素

Résumé de Yuan Zu

Le noyau de Yuanzu est une séquence immuable
La vitesse d'accès et de traitement de l'ancêtre d'origine est plus rapide que le bloc de liste
Comme les entiers et les chaînes, l'ancêtre peut être utilisé comme clé d'un dictionnaire, et la liste ne peut jamais être utilisée comme clé d'un dictionnaire.

dictionnaire

Un dictionnaire est une séquence variable non ordonnée de paires clé-valeur. Chaque élément du dictionnaire est une "paire clé-valeur", comprenant: "objet clé" et "objet valeur". L'objet clé peut être utilisé pour obtenir et supprimer rapidement , et mettez à jour l'objet de valeur correspondante.

Dans la liste, nous trouvons l'objet correspondant via le numéro d'indice, et dans le dictionnaire, nous trouvons l'objet de valeur correspondant via l'objet clé. Les clés sont des objets immuables arbitraires, tels que des ancêtres de chaîne de nombres entiers à virgule flottante, mais les listes, dictionnaires et activations de ces objets variables ne peuvent pas être utilisés comme «clés» et les «clés» ne peuvent pas être répétées.

La valeur peut être n'importe quelle donnée et peut être répétée.

Création de dictionnaire

Nous pouvons créer un objet dictionnaire par {} dict ()

a = {
      
      'name':'slp','age':18,'job':'teacher'}
b = dict(name='slp',age=18,job='teacher')
a = dict([("name","18"),("age",18)])
c = {
      
      } #空字典对象
d = dict() #空字典对象

Créer un objet dictionnaire via zip ()

k = ['name','age','job']
v = ['slp',18,'teacher']
d = dict(zip(k,v))

Créée par fromkeysLa valeur est videDictionnaire S
```
a = dict.fromkeys(['name','age','job'])
```

Accès aux éléments du dictionnaire

Obtenez la valeur via la clé, si la clé n'existe pas, lancez une exception

a = {
      
      'name':'slp','age':18}
a['name'] #slp
a['job'] #KeyError

Obtenez la valeur via la méthode get (), il est recommandé d'utiliser, le point est: la clé spécifiée n'existe pas, retourne None, vous pouvez également définir l'objet de retour par défaut lorsque la clé spécifiée n'existe pas
```
a = {
      
      'name':'slp','age':18}
a.get('name')
```
Répertorier plusieurs paires clé-valeur
```
a.items()
```
Lister toutes les clés, lister toutes les valeurs
```
a.keys()
a.values()
```
len () le nombre de paires clé-valeur
Vérifier si une clé est dans le dictionnaire
```
'name' in a
```

Ajout, modification, suppression d'éléments de dictionnaire

Ajoutez des "paires clé-valeur" au dictionnaire. Si la "clé" existe déjà, écrasez l'ancienne valeur, si elle n'existe pas, ajoutez une nouvelle paire clé-valeur
```
a = {
      
      'name','slp'}
a['address']='sx'
```
Utilisez update () pour ajouter toutes les paires clé-valeur du nouveau dictionnaire à l'ancien dictionnaire. Si la clé est répétée, elle sera directement écrasée
```
a = {
      
      'name':'slp','age':18}
b = {
      
      'name':'hp','address':'sx'}
a.update(b)
```
Pour supprimer des éléments du dictionnaire, vous pouvez utiliser la méthode del () ou clear () pour supprimer toutes les paires clé-valeur; pop () supprime la paire clé-valeur spécifiée et renvoie l '"objet valeur" correspondant
```
a={
      
      'name':'slp',
 	'age':18}
del(a['name'])
```
popitem (): supprime et renvoie au hasard la paire clé-valeur. Le dictionnaire est une séquence de variables non ordonnée, il n'y a donc pas de concept du premier élément et du dernier élément. popitem () fait apparaître des éléments aléatoires, car le dictionnaire n'a pas le dernier élément ou d'autres concepts d'ordre, si vous souhaitez supprimer un par un, c'est très efficace
```
a = {
      
      'name':'slp','age':18}
a.popitem()
```

Déballage de séquence

Le déballage de séquence peut être utilisé pour les ancêtres, les listes et les dictionnaires. Le déballage de séquence nous permet d'attribuer facilement des valeurs à plusieurs variables,

x,y,z = (20,30,10)
x #20
(a,b,c)=(9,8,10)
a #9
[a,b,c]=[10,20,30]
c #30

Lorsque le déballage de séquence est utilisé dans un dictionnaire, la valeur par défaut est d'opérer sur les clés; si vous avez besoin d'opérer sur des valeurs de clé, vous devez utiliser items (), si vous avez besoin d'opérer sur des valeurs, vous devez utiliser values ()

s = {
    
    'name':'slp','age':18}
name,age = s
name #'name'
name,age=s.items()
name#{'name','slp'}

exemple

Les données de table sont stockées dans des dictionnaires et des listes, et accessibles

Nom	âge	Un salaire	ville
Gao Xiaoyi	18	30000	Pékin
Gao Xiaoer	19	20000	Shanghai
Gao Xiaowu	20	10 000	Shenzhen

# -*- coding: utf-8 -*-
"""
Created on Fri Jan 15 14:06:22 2021

@author: sangliping
"""

r1 = {
    
    'name':'高小一','age':18,'salary':30000,'city':'北京'}
r2 = {
    
    'name':'高小二','age':19,'salary':10000,'city':'上海'}
r3 = {
    
    'name':'高小五','age':20,'salary':10000,'city':'深圳'}
tb = [r1,r2,r3]
print(tb)
# 获得第二行人的薪资
print(tb[1].get('salary'))
#打印表中所有的薪资
for i in range(len(tb)):
    print(tb[i].get('salary'))
    
# 打印表的所有数据
for i in range(len(tb)):    
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

Les principes fondamentaux sous-jacents du dictionnaire

Le noyau de l'objet dictionnaire est la table de hachage. La table de hachage est une matrice éparse. Chaque unité du tableau est appelée un compartiment. Chaque compartiment comprend deux parties: l'une est une référence à un objet clé et l'autre est une référence à un objet de valeur.

Étant donné que tous les buckets ont la même structure et la même taille, nous pouvons lire le bucket spécifié par offset
Insérez la description de l'image ici

Mettre une paire clé-valeur dans le processus sous-jacent du dictionnaire

a = {
    
    }
a['name']='slp'

Supposons qu'après la création d'un objet du dictionnaire, la longueur du tableau soit 8:
Insérez la description de l'image ici

Nous devons mettre la paire clé-valeur 'nom' = 'slp' dans l'objet dictionnaire a. La première étape consiste à calculer la valeur de hachage de la clé, qui peut être calculée par hash () en python bin(hash('name'))

Puisque la longueur du tableau est de 8, nous pouvons prendre les 3 chiffres les plus à droite de la valeur de hachage calculée comme offset, c'est-à-dire 101, la décimale est 5. Nous vérifions si le bucket correspondant à l'offset 5 est vide, s'il est vide , Insérez la paire clé-valeur. Si elle n'est pas vide, prenez les 3 bons chiffres à tour de rôle comme décalage, qui est de 100. Vérifiez si le compartiment avec le décalage 4 est vide, jusqu'à ce que vous trouviez un compartiment vide et mettez la clé -valeur paire Entrez.
Insérez la description de l'image ici

Processus sous-jacent de recherche de "paires clé-valeur" en fonction des clés

Lorsque nous appelons a.get ('name'), nous trouvons la paire clé-valeur en fonction du nom et trouvons l'objet. La première étape consiste toujours à calculer la valeur de hachage.

Conformément à l'algorithme de processus de stockage sous-jacent, les nombres à différentes positions de la valeur de hachage sont également pris séquentiellement. En supposant que la longueur du tableau est de 8, nous pouvons prendre les 3 chiffres les plus à droite de la valeur de hachage calculée comme décalage et vérifier si le compartiment correspondant à la position décimale est vide. S'il est vide, renvoyez Aucun. Si c'est le cas pas vide, puis comparer S'ils sont égaux, ils seront renvoyés sous forme de valeurs. S'ils ne sont pas égaux, ils seront comparés à d'autres bits à tour de rôle. S'il n'est toujours pas trouvé à la fin, il renvoie None.
Insérez la description de l'image ici

Pour résumer:

La clé doit être hachable
- Les ancêtres des chaînes numériques sont tous hachables
- Les objets personnalisés doivent prendre en charge les trois points suivants
  - Fonction de hachage de support ()
  - Soutenir les __eq__()méthodes pour détecter l'égalité
  - Si c'est a==bvrai, alors hash(a)==hash(b)aussi vrai
Le dictionnaire a une énorme surcharge en mémoire, un espace typique pour le temps
La requête clé est rapide
L'ajout d'une nouvelle clé au dictionnaire peut entraîner une expansion et modifier l'ordre des clés dans la table de hachage. Par conséquent, il n'est pas nécessaire de modifier le dictionnaire tout en parcourant le dictionnaire.

ensemble

La collection est désordonnée et variable, et les éléments ne peuvent pas être répétés. En fait, la couche inférieure de la collection est implémentée par un dictionnaire. Tous les éléments de la collection sont des objets clés dans le dictionnaire, ils ne peuvent donc pas être répétés et uniques.

Création et suppression de collection

Utilisez {} pour créer un objet de collection et utilisez la méthode add () pour ajouter des éléments
```
a = {
      
      3,5,7}
a.add(9)
```
Utilisez set () pour convertir des objets itérables tels que des listes et des tuples en plusieurs. S'il y a des valeurs en double dans les données, une seule est conservée.
```
a = ['a','b']
b = set(a)
```
remove () supprime l'élément spécifié, clear () efface toute la collection

Opérations liées à la collecte

Comme les concepts en mathématiques, python fournit également des opérations telles que l'union, l'intersection et la différence pour les ensembles

a = {
    
    1,2}
b={
    
    's','l'}
a|b #并集
a&b #交集
a-b #差集
a.union(b) #并集
a.intersection(b) #交集
a.difference(b) #差集

Recherchez [Zixin] sur WeChat ou scannez le code QR ci-dessous pour vous faire des amis et progresser ensemble. L'article est mis à jour en permanence. Actuellement, j'organise les notes d'étude des cent batailles Python, et j'attends avec impatience d'autres mises à jour dans le futur.