Contrairement aux listes, les tapples sont immuables. Par conséquent, il n'est pas possible d'ajouter, de supprimer ou de modifier des éléments après avoir défini le tapple.
Un taple est défini par une virgule qui passe par la valeur. Il est habituel de placer la valeur entière entre (), car l'utilisation de () n'entraîne pas d'erreur.
#Vous pouvez utiliser des tapples pour affecter plusieurs variables à la fois.
>>> marx_tuple = ("Groucho","Choico","Harpo")
>>> marx_tuple
('Groucho', 'Choico', 'Harpo')
>>> a,b,c=marx_tuple
>>> a
'Groucho'
>>> b
'Choico'
>>> c
'Harpo'
>>> password = "aaaa"
>>> icecream = "bbbb"
>>> password,icecream =icecream,password
>>> password
'bbbb'
>>> icecream
'aaaa'
#Tuple de fonction variable()Vous pouvez utiliser pour créer un taple à partir d'autre chose.
>>> marx_list=["Groucho","Choico", 'Haapo']
>>> tuple(marx_list)
('Groucho', 'Choico', 'Haapo')
Caractéristiques de tapple --Taple consomme moins d'espace --Taple peut être utilisé comme clé de dictionnaire --Il n'y a aucun risque de réécrire accidentellement les éléments du taple
Les dictionnaires sont similaires aux listes mais n'utilisent pas de décalages tels que 0 et 1 lors de la sélection d'éléments car l'ordre des éléments n'est pas contrôlé. Au lieu de cela, attribuez à chaque valeur une ** clé unique **. La clé peut être de n'importe quel type immuable.
Pour créer un dictionnaire, séparez les paires clé: valeur par des virgules et placez-les entre {}.
>>> empty_dict ={}
>>> empty_dict
{}
>>> bierce ={
... "day":"A period of twenty-four hours,mostly misspent",
... "positive":"Mistaken at the top of one's voice",
... "misfortune":"The kind of fortune tha never misses",
... }
>>> bierce
{'day': 'A period of twenty-four hours,mostly misspent', 'positive': "Mistaken at the top of one's voice", 'misfortune': 'The kind of fortune tha never misses'}
Vous pouvez utiliser la fonction dict () pour convertir une séquence de deux valeurs en un dictionnaire. Le premier élément de la séquence est la clé et le deuxième élément est la valeur.
#Liste des taples à deux éléments
>>> lol = [["a","b"],["c","d"],["e","f"]]
>>> dict(lol)
{'a': 'b', 'c': 'd', 'e': 'f'}
>>> lol = [("a","b"),("c","d"),("e","f")]
#Tapple de liste à deux éléments
>>> dict(lol)
{'a': 'b', 'c': 'd', 'e': 'f'}
>>> lol = (["a","b"],["c","d"],["e","f"])
>>> dict(lol)
{'a': 'b', 'c': 'd', 'e': 'f'}
#Liste des chaînes de deux caractères
>>> los = ["ab","cd","ef"]
>>> dict(los)
{'a': 'b', 'c': 'd', 'e': 'f'}
#Taple de chaîne de deux lettres
>>> los = ("ab","cd","ef")
>>> dict(los)
{'a': 'b', 'c': 'd', 'e': 'f'}
Utilisez la touche pour faire référence à l'élément et attribuer la valeur. Si la clé existe déjà dans le dictionnaire, la valeur existante sera remplacée par la nouvelle valeur. ** Si la clé n'existe pas déjà, elle sera ajoutée au dictionnaire avec la valeur. ** **
#La clé n'existe pas et est ajoutée au dictionnaire sous la forme d'un ensemble de clés et de valeurs
#Remplacez la valeur car la clé existe déjà
>>> pythons
{'Chapman': 'Graham', 'Takada': 'Takashi', 'Atushi': 'Kataoka', 'Palin': 'Michael'}
>>> pythons["Gilliam"] = "Gerry"
>>> pythons
{'Chapman': 'Graham', 'Takada': 'Takashi', 'Atushi': 'Kataoka', 'Palin': 'Michael', 'Gilliam': 'Gerry'}
#Si plusieurs clés sont utilisées, la dernière valeur reste.
>>> pythons["Gilliam"] = "Terry"
>>> pythons
{'Chapman': 'Graham', 'Takada': 'Takashi', 'Atushi': 'Kataoka', 'Palin': 'Michael', 'Gilliam': 'Terry'}
#"Chapman"À la clé"Graham"Après avoir remplacé"Tatuo"Est remplacé par.
>>> some_pythons = {
... "Chapman":"Graham",
... "Takada":"Takashi",
... "Palin":"Michael",
... "Chapman":"Tatuo",
... }
>>> some_pythons
{'Chapman': 'Tatuo', 'Takada': 'Takashi', 'Palin': 'Michael'}
Vous pouvez utiliser la fonction update () pour copier une clé et une valeur de dictionnaire dans un autre dictionnaire.
>>> pythons = {
... "Chapman":"Graham",
... "Takada":"Takashi",
... "Palin":"Michael",
... "Atushi":"Kataoka",
... }
>>> pythons
{'Chapman': 'Graham', 'Takada': 'Takashi', 'Palin': 'Michael', 'Atushi': 'Kataoka'}
#Si le second dictionnaire a les mêmes clés que celles du premier dictionnaire, les valeurs du second dictionnaire restent.
>>> others = {"Marx":"Gerge",'Takada': 'Takakakakakkakka'}
>>> pythons.update(others)
>>> pythons
{'Chapman': 'Graham', 'Takada': 'Takakakakakkakka', 'Palin': 'Michael', 'Atushi': 'Kataoka', 'Marx': 'Gerge', 'Howard': 'Moe'}
>>> del pythons["Marx"]
>>> pythons
{'Chapman': 'Graham', 'Takada': 'Takakakakakkakka', 'Palin': 'Michael', 'Atushi': 'Kataoka', 'Howard': 'Moe'}
Pour supprimer toutes les clés et valeurs du dictionnaire, utilisez clear () ou remplacez le nom du dictionnaire par un dictionnaire vide {}.
>>> pythons.clear()
>>> pythons
{}
>>> pythons = {}
>>> pythons
{}
>>> pythons = {'Chapman': 'Graham', 'Takada': 'Takashi', 'Palin': 'Michael', 'Atushi': 'Kataoka', 'Marx': 'Gerge', 'Howard': 'Moe'}
#"key" in "Nom du dictionnaire"Grammaire
>>> "Chapman" in pythons
True
>>> "Chaaaaan" in pythons
False
Spécifiez le dictionnaire et la clé pour récupérer la valeur correspondante.
>>> pythons = {'Chapman': 'Graham', 'Takada': 'Takashi', 'Palin': 'Michael', 'Atushi': 'Kataoka', 'Marx': 'Gerge', 'Howard': 'Moe'}
>>> pythons["Howard"]
'Moe'
#Une exception se produit si la clé n'est pas dans le dictionnaire
>>> pythons["Howaaa"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Howaaa'
#3 façons de vérifier si la clé existe à l'avance pour éviter les exceptions
#utiliser dans
>>> "Howaaa" in pythons
False
#Obtenir pour le dictionnaire uniquement()Utiliser des fonctions Passer des dictionnaires, des clés et des valeurs d'options
#Renvoie la valeur de la clé, le cas échéant
>>> pythons.get("Marx")
'Gerge'
#S'il n'y a pas de clé, la valeur d'option spécifiée est renvoyée.(Deuxième argument)
>>> pythons.get("Howaaa","Not a Python")
'Not a Python'
#Si vous ne faites pas d'option, ce sera Aucune
>>> pythons.get("Howaaa")
Vous pouvez obtenir toutes les clés du dictionnaire en utilisant les touches (). En Python3, vous devez également utiliser la fonction list () lorsque vous voulez que les valeurs de retour de values () et items () soient des listes Python régulières.
>>> signals = {"green":"go","yellow":"go faster","red":"smile for the camera"}
#Obtenez toutes les clés du dictionnaire
>>> signals.keys()
dict_keys(['green', 'yellow', 'red'])
#Valeurs pour obtenir toutes les valeurs du dictionnaire()utilisation
>>> list(signals.values())
['go', 'go faster', 'smile for the camera']
#Toutes les clés du dictionnaire/Si vous souhaitez récupérer des paires de valeurs, des éléments()Utiliser une fonction
>>> list(signals.items())
[('green', 'go'), ('yellow', 'go faster'), ('red', 'smile for the camera')]
Comme pour les listes, les modifications apportées à un dictionnaire affectent tous les noms qui font référence à ce dictionnaire.
#save_Affecté car les signaux se réfèrent également au même objet
>>> signals = {"green":"go","yellow":"go faster","red":"smile for the camera"}
>>> save_signals = signals
>>> signals["blue"]="confuse everyone"
>>> save_signals
{'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera', 'blue': 'confuse everyone'}
>>> signals
{'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera', 'blue': 'confuse everyone'}
#Clé d'un autre dictionnaire/Si vous souhaitez copier la copie de valeur()utilisation.
>>> signals = {"green":"go","yellow":"go faster","red":"smile for the camera"}
>>> original_signals = signals.copy()
>>> signals["blue"]="confuse everyone"
>>> signals
{'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera', 'blue': 'confuse everyone'}
#Non affecté
>>> original_signals
{'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera'}
Un ensemble est comme un dictionnaire qui jette des valeurs et ne laisse que les clés. Utilisez un dictionnaire si vous souhaitez ajouter une valeur à une clé.
Pour créer un ensemble, utilisez la fonction set () ou placez une ou plusieurs valeurs séparées par des virgules dans {} et attribuez-les.
#Un ensemble vide est un ensemble sans éléments
>>> empty_set = set()
>>> empty_set
set()
>>> even_numbers = {0,2,4,6,8}
>>> even_numbers
{0, 2, 4, 6, 8}
Vous pouvez créer un ensemble en supprimant les valeurs en double des listes, des chaînes, des tapples et des dictionnaires.
#"t","e"Sont dupliqués, mais l'ensemble n'en contient qu'un.
>>> set("letters")
{'l', 's', 't', 'r', 'e'}
#Créer un ensemble à partir d'une liste
>>> set(["Danger","Dancer","Prancer","Mason-Dixon"])
{'Mason-Dixon', 'Danger', 'Prancer', 'Dancer'}
#Créer un ensemble à partir de taples
>>> set(("Ummaguma","Echoes","Atom Heart Mother"))
{'Echoes', 'Ummaguma', 'Atom Heart Mother'}
#set()Si vous passez le dictionnaire à, seule la clé sera utilisée.
>>> set({'apple':"red", 'orange':"orange", 'cherry':"red"})
{'apple', 'orange', 'cherry'}
#Les deux ensembles et dictionnaires{}Bien qu'il soit entouré de, l'ensemble n'est qu'une séquence, tandis que le dictionnaire est la clé:C'est une séquence de paires de valeurs.
>>> drinks = {
... "martini":{"vodka","vermouth"},
... "black russian":{"vodka","kahlua"},
... "manhattan":{"cream","kahlua","vodka"},
... "white russian":{"rye","vermouth","bitters"},
... "screwdriver":{"orange juice","vodka"}
... }
#Clé du dictionnaire boissons/Sortez les paires de valeurs dans l'ordre et nommez chacune/Attribuer au contenu et au contenu"vodka"La valeur de la clé incluse est sortie.
>>> for name,contents in drinks.items():
... if "vodka" in contents:
... print(name)
...
martini
black russian
manhattan
screwdriver
#Clé du dictionnaire boissons/Sortez les paires de valeurs dans l'ordre et nommez chacune/Attribuer au contenu et au contenu"vodka"Comprenant"vermouth"Ou"cream"La valeur de la clé qui n'inclut pas est sortie.
>>> for name,contents in drinks.items():
... if "vodka" in contents and not ("vermouth" in contents or
... "cream" in contents):
... print(name)
...
black russian
screwdriver
Le résultat de l'opérateur & est un ensemble qui contient tous les éléments contenus dans les deux ensembles.
#au contenu"vermouth"、"orange juice"Si les deux ne sont pas inclus&L'opérateur est un ensemble vide{}rends le.
>>> for name,contents in drinks.items():
... if contents & {"vermouth","orange juice"}:
... print(name)
...
martini
white russian
screwdriver
#3.5.3 Réécriture du code en bas
>>> for name,contents in drinks.items():
... if "vodka" in contents and not contents & {"vermouth","cream"}:
... print(name)
...
black russian
screwdriver
#Regardons tous les opérateurs d'ensemble
>>> bruss = drinks["black russian"]
>>> wruss = drinks["white russian"]
>>> a={1,2}
>>> b={2,3}
#Ensemble de produits:&Ou intersection()Utiliser une fonction
>>> a & b
{2}
>>> a.intersection(b)
{2}
>>> bruss & wruss
set()
#Ensemble de somme:|Ou union()Utiliser une fonction
>>> a | b
{1, 2, 3}
>>> a.union(b)
{1, 2, 3}
>>> bruss | wruss
{'cream', 'kahlua', 'vodka'}
#Ensemble de différences:-Ou différence()Utilisez une fonction.(Un ensemble d'éléments qui sont inclus dans le premier ensemble mais pas dans le second ensemble)
>>> a-b
{1}
>>> a.difference(b)
{1}
>>> bruss-wruss
set()
>>> wruss-bruss
{'cream'}
#OU exclusif:^Ou symétrique_difference()Utiliser une fonction (éléments contenus dans l'un ou l'autre)
>>> a ^ b
{1, 3}
>>> a.symmetric_difference(b)
{1, 3}
>>> bruss^wruss
{'cream'}
#Sous-ensemble:<=Ou issubset()utilisation.
>>> a <=b
False
>>> a.issubset(b)
False
>>> bruss<=wruss
True
#Chaque ensemble est un sous-ensemble de lui-même.
>>> a<=a
True
>>> a.issubset(a)
True
#Si le premier ensemble est un véritable sous-ensemble du second ensemble.
#Le deuxième ensemble doit avoir un autre élément en plus de tous les éléments du premier ensemble.<Peut être calculé avec.
>>> a < b
False
>>> a<a
False
>>> bruss<wruss
True
#Superset: relation dans laquelle tous les éléments du deuxième ensemble sont également des éléments du premier ensemble, ce qui est l'opposé du sous-ensemble.
# >=Ou est un surensemble()Vérifiez avec une fonction.
>>> a>=b
False
>>> a.issubset(b)
False
>>> wruss >= bruss
True
#Tous les ensembles sont des sur-ensembles d'eux-mêmes.
>>> a>=a
True
>>> a.issuperset(a)
True
#Vrai sur-ensemble: si le premier ensemble contient tous les éléments du deuxième ensemble et d'autres éléments
>>> a > b
False
>>> wruss > bruss
True
#L'ensemble n'est pas un sur-ensemble direct en lui-même
>>> a>a
False
Représenté par
La méthode de référence est la suivante. --Pour les listes et les taples, les nombres entre crochets sont décalés --Pour les dictionnaires, la clé
>>> marx_list=["akagi","Takasuka","Syuda"]
>>> marx_tuple="akagi","Takasuka","Syuda"
>>> marx_dict={"akagi","Takasuka","Syuda"}
>>> marx_list=[2]
>>> marx_list=["akagi","Takasuka","Syuda"]
>>> marx_list[2]
'Syuda'
>>> marx_tuple[2]
'Syuda'
>>> marx_dict={"akagi":"banjo","Takasuka":"help","Syuda":"harp"}
>>> marx_dict["Syuda"]
'harp'
>>> marxs=["akagi","Takasuka","Syuda"]
>>> pythons=["Gilliam","Cleese","Gilliam"]
>>> stooges=["Moe","Curly","Larry"]
#Créer des taples à partir de listes individuelles
>>> tuple_of_lists=marxs,pythons,stooges
>>> tuple_of_lists
(['akagi', 'Takasuka', 'Syuda'], ['Gilliam', 'Cleese', 'Gilliam'], ['Moe', 'Curly', 'Larry'])
#Créer une liste comprenant une liste
>>> list_of_lists=[marxs,pythons,stooges]
>>> list_of_lists
[['akagi', 'Takasuka', 'Syuda'], ['Gilliam', 'Cleese', 'Gilliam'], ['Moe', 'Curly', 'Larry']]
#Créer un dictionnaire de liste
#Les listes, dictionnaires et ensembles ne peuvent pas être des clés pour d'autres dictionnaires car les clés de dictionnaire doivent être immuables.
>>> dict_of_lists ={"Marxes":marxes,"Pythons":pythons,"Stooges":stooges}
>>> dict_of_lists
{'Marxes': ['Groucho', 'Choico', 'Haapo'], 'Pythons': ['Gilliam', 'Cleese', 'Gilliam'], 'Stooges': ['Moe', 'Curly', 'Larry']}
#Les listes, dictionnaires et ensembles ne peuvent pas être des clés d'autres dictionnaires car les clés de dictionnaire doivent être immuables, mais les touches peuvent être des clés.
>>> houses={
... (44.79,-43.55,373):"My House"}
>>> years_list=[1994,1995,1996,1997,1998,1999]
#Notez que le décalage commence à 0
>>> years_list[4]
1998
#décalage-L'extrémité droite peut être sélectionnée en spécifiant comme 1
>>> years_list[-1]
1999
>>> things=["mozzarella","cinderella","salmonella"]
>>> things
['mozzarella', 'cinderella', 'salmonella']
#capitalize()Mettez en majuscule le premier caractère de la chaîne avec la fonction.
>>> things[1]=things[1].capitalize()
>>> things
['mozzarella', 'Cinderella', 'salmonella']
#upper()Utilisez la fonction pour mettre en majuscule la chaîne d'élément.
>>> things[2]=things[2].upper()
>>> things
['mozzarella', 'Cinderella', 'SALMONELLA']
#Vous pouvez supprimer un élément avec del
>>> del things[2]
>>> things
['mozzarella', 'Cinderella']
>>> surprize=["Groucho","Chico","Harpo"]
>>> surprize
['Groucho', 'Chico', 'Harpo']
#Rendre la dernière chaîne plus basse.
>>> surprize[2]=surprize[2].lower()
#Remplacez le dernier élément dans l'ordre inverse
>>> surprize[2]=surprize[-1][::-1]
#Mettez en majuscule la première lettre du dernier élément.
>>> surprize[2]=surprize[2].capitalize()
>>> surprize[2]
'Oprah'
>>> e2f={"dog":"chien","cat":"chat","walrus":"morse"}
>>> e2f
{'dog': 'chien', 'cat': 'chat', 'walrus': 'morse'}
#C'est la clé"walrus"Pour afficher la valeur
>>> e2f["walrus"]
'morse'
#N'oubliez pas d'initialiser f2e
>>> f2e={}
#items()Utilisez pour améliorer chaque clé et valeur,Boutique en français
>>> for english,french in e2f.items():
... f2e[french] = english
...
>>> f2e
{'chien': 'dog', 'chat': 'cat', 'morse': 'walrus'}
#C'est la clé"chien"Pour afficher la valeur
>>> f2e["chien"]
'dog'
#La création de l'ensemble est définie()Utiliser.
>>> set(e2f.keys())
{'walrus', 'dog', 'cat'}
>>> life={"animals":{"cats":["Henry","Grumpy","Lucy"],"octpi":{},"emus":{}},"plants":{},"other":{}}
#key()Est utilisé pour afficher la clé de la vie de plusieurs dictionnaires
>>> print(life.keys())
dict_keys(['animals', 'plants', 'other'])
#key()Vie de dictionnaires multiples en utilisant["animals"]Affiche la clé de
>>> print(life["animals"].keys())
dict_keys(['cats', 'octpi', 'emus'])
#Vie de dictionnaires multiples["animals"]["cats"]Affiche la valeur de
>>> print(life["animals"]["cats"])
['Henry', 'Grumpy', 'Lucy']
Jusqu'à présent, le commentaire était écrit à côté de la déclaration d'exécution, mais quand j'ai regardé en arrière, il s'est avéré très difficile à voir. C'est plus facile à voir en l'écrivant au-dessus de l'instruction d'exécution, donc corrigeons la précédente.
"Introduction à Python3 par Bill Lubanovic (publié par O'Reilly Japon)"
Recommended Posts