Comprenez les listes Python, les dictionnaires, etc.

list

list()

Générer / convertir une liste. «Chaîne de caractères → liste» et «tuple → liste» sont possibles.

produire

hoge = []
hoge = list()  #Comme ci-dessus

conversion

list('cat')
# ['c','a','t']

Offset

tranche

hoge = ['a','b','c','d']
hoge[::2]
# ['a','c']
hoge[::-2]
# ['d','b'] #De l'opposé
hoge[::-1]
# ['d','c','b','a'] #Dans le sens inverse

append() extend()

Ajouter et combiner

hoge = ['a','b','c','d']
fuga = ['e']

hoge.append('e')
hoge.extend(fuga)
hoge += fuga
# ['a','b','c','d','e'] #Tout le même résultat

insert()

piyo = ['a','b','d','e']
piyo.insert(2, 'c')
# ['a','b','c','d','e']

remove() pop()

hoge = ['a','b','c','d','e']
hoge.remove('d') #Supprimer en spécifiant l'élément lui-même
hoge.pop(3) #Supprimer en spécifiant un décalage(Pour être exact, sortez)
# hoge = ['a','b','c','e'] #Même résultat

Contrôle d'existence

hoge = ['a','b','c','d','e']
if 'a' in hoge:
    print("exist")
else
    print("not exist")
# exist

split() join()

fuga = 'a,b,c,d'
fuga.split(',')
# ['a','b','c','d']

hoge = ['a','b','c','d']
','.join(hoge)    #hoge.join(',')Notez que ce n'est pas le cas!
# 'a,b,c,d'

copy()

python est essentiellement passé par référence.

hoge = ['a','b','c','d']
fuga = hoge
#Si vous changez de hoge après cela, fuga reflétera également le changement.=fuga fait référence à hoge.

fuga = hoge.copy()
fuga = list(hoge)
fuga = hoge[:]
#Tous ces éléments génèrent une copie plutôt qu'une référence, donc fuga conserve la liste d'origine même si vous modifiez le hofge.

Obtenir le décalage et la valeur enumerate ()

hoge = ['a','b','c','d']
for i, val in enumerate(hoge):
    print(i, val)

Taple

La différence avec la liste est qu'elle est immuable, c'est-à-dire que les modifications ne fonctionnent pas.

Créer

hoge = 4, 10, 5
hoge = (4, 10, 5)
hoge = tuple(4, 10, 5)  #Tous les mêmes.

Déballer

Le contenu du taple peut être affecté à chaque variable sans utiliser de variables temporaires.

Déballer

hoge = tuple(4, 10, 5)
a, b, c = hoge

dictionnaire

dict()

produire

hoge = {}
hoge = dict()

conversion

fuga = [('a', 'b'), ('c', 'd')] #Les listes de listes peuvent également être converties
hoge = dict(fuga)
# {
#     'a': 'b',
#     'c': 'd'
# }

piyo = list(hoge.items()) #Converti avec une liste de taples.(De plus, listez()Si vous ne mordez pas le dict_Retours sous forme d'articles.)
# [('a', 'b'), ('c', 'd')]

#De plus, la raison pour laquelle appliquer ce qui suit est qu'elle utilise la propriété de déballage de taple.
for key, item in hoge.items():
    pass

Ajouter et combiner

hoge = {
    'a': 'b',
    'c': 'd'
}
hoge['e'] = 'f' #Vous pouvez le spécifier sans autorisation

fuga = {
    'g': 'h'
}
hoge.update(fuga) #Joindre

Contrôle d'existence

Identique à la liste.

hoge = {
    'a': 'b',
    'c': 'd'
}
if 'a' in hoge:
    print("exist")
else
    print("not exist")
# exist

keys() values()

hoge = {
    'a': 'b',
    'c': 'd'
}
hoge.keys()
# dict_keys(['a', 'c'])→ Renvoie une vue clé itérable. liste()Besoin de mordre et de se convertir en liste.
list(hoge.keys())
# ['a', 'c']

values () est le même que ci-dessus.

copy()

Identique à la liste. Lorsqu'il ne passe pas par référence.

ensemble

Lorsque vous ne vous souciez pas de la commande. La forme est représentée par «{0, 2, 7, 1, 4}».

Créer

hoge = set()           #Ensemble vide
hoge = {0, 2, 7, 1, 4} #Un ensemble qui définit également le contenu
hoge = {}              #Ceci est un dictionnaire

hoge = set( ["hoge", "fuga", "piyo"] ) #Outre les listes, les taples, les chaînes de caractères et les dictionnaires sont également pris en charge.(Seule la clé est extraite dans le dictionnaire)
# {"piyo", "hoge", "fuga"}

Chaîne d'octets

bytes → Quelque chose comme un taple d'octets, immuable. bytearray → Quelque chose comme une liste d'octets, mutable.

Autres fonctions

zip()

Remettez le taple. Il peut être utilisé comme suit en déballant avec l'instruction for.

hoge = ["a", "b", "c"]
fuga = ["A", "B", "C", "D"]

for small, large in zip(hoge, fuga):
    print("small:", small, "large:", large)

# small: a large: A
# small: b large: B
# small: c large: C  #Terminez selon le plus court,"D"Ça ne sort pas.

range()

Créer une séquence. La syntaxe «range (start, end, step)». Jusqu'au nombre immédiatement avant ʻend`.

range(0, 3)
# 0, 1, 2

Notation d'inclusion

Notation d'inclusion de liste

Écrivez une boucle for sans le «[]» dans la liste.

Syntaxe 1

 [Expression de variable dans un objet itérable]

Exemple

hoge = [num for num in range(0, 3)]
# [0, 1, 2]

fuga = [num * 2 for num in range(0, 3)]
# [0, 2, 4]

piyo = [(a, b) for a in range(0, 2) for b in range(0, 3)]
#[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]

Syntaxe 2

 [Expression de la variable dans un objet itérable si condition]

Exemple

hoge = [num for num in range(0, 3) if num % 2 == 0]
# [0, 2]

Notation d'inclusion de dictionnaire

syntaxe

 {formule:formulefor 変数 in イテラブルオブジェクト }

Exemple

word = "letter" #Vous pouvez garder une liste ou un ensemble
hoge = { let : word.count(let) fot let in word }
# { "l": 1, "e": 2, "t": 2, "r": 1}

Définir la notation d'inclusion

le même. réduction

× Notation d'inclusion Taple ○ Type de générateur

→ Il n'y a pas de notation d'inclusion dans le taple! L'écriture dans le même format que ci-dessus renvoie un objet générateur.