Depuis http://www.amazon.co.jp/dp/4873117380

tranche

Tout d'abord, l'idée de trancher

-- [:] `` `` extrait la séquence entière du début à la fin -- [début:] ʻextrait la séquence du décalage de début à la fin --``` [: end] ʻextrait la séquence du début à la fin-1 offset --[début: fin]extrait la séquence du décalage de début au décalage de fin 1 --[début: fin: étape]extrait la séquence du décalage de début au décalage de fin 1 pour chaque caractère de pas

Le décalage est 0, 1, ... de zéro vers la droite et -1, -2, ... de la fin vers la gauche. Si start n'est pas spécifié, la tranche utilisera 0 (début).

Exemple

In [9]: sample_list = ['a','b','c','d','e']

In [10]: sample_list[0]
Out[10]: 'a'

In [11]: sample_list[0:]
Out[11]: ['a', 'b', 'c', 'd', 'e']

In [12]: sample_list[0:-1]
Out[12]: ['a', 'b', 'c', 'd']

In [13]: sample_list[0:4]
Out[13]: ['a', 'b', 'c', 'd']

In [19]: sample_list[-3:]
Out[19]: ['c', 'd', 'e']

In [22]: sample_list[-3:-1]
Out[22]: ['c', 'd']

#Lors du retournement de la liste
In [14]: sample_list[::-1]
Out[14]: ['e', 'd', 'c', 'b', 'a']

append() Utilisez la méthode ʻappend () `lorsque vous voulez ajouter un élément à la fin de la liste

In [23]: sample_list.append('f')

In [24]: sample_list
Out[24]: ['a', 'b', 'c', 'd', 'e', 'f']

Combinez des listes en utilisant extend () ou + =

Vous pouvez utiliser extend () pour combiner les deux listes en une seule. C'est une opération destructrice.

In [27]: sample_list.extend(number_list)

In [28]: sample_list
Out[28]: ['a', 'b', 'c', 'd', 'e', 'f', 1, 2, 3]

# sample_Initialiser la liste
In [33]: sample_list = ['a','b','c','d','e']

In [34]: sample_list += number_list

In [35]: sample_list
Out[35]: ['a', 'b', 'c', 'd', 'e', 1, 2, 3]

Au fait, append () est traité comme un élément, donc

In [36]: sample_list = ['a','b','c','d','e']
In [37]: sample_list.append(number_list)

In [38]: sample_list
Out[38]: ['a', 'b', 'c', 'd', 'e', [1, 2, 3]]

Ajouter un élément avec le décalage spécifié par insert ()

La fonction append () peut uniquement ajouter un élément à la fin de la liste. Utilisez insert () lorsque vous souhaitez spécifier le décalage de la liste et ajouter un élément avant celui-ci. Si l'offset 0 est spécifié, il sera inséré au début. Si vous spécifiez un décalage qui dépasse la fin, il sera inséré à la fin de la liste de la même manière que append ().

In [42]: sample_list = ['a','b','c','d','e']

In [43]: sample_list.insert(1,1)

In [44]: sample_list
Out[44]: ['a', 1, 'b', 'c', 'd', 'e']

In [45]: sample_list.insert(10,10)

In [46]: sample_list
Out[46]: ['a', 1, 'b', 'c', 'd', 'e', 10]

Supprimer l'élément du décalage spécifié par del

Notez que del est une instruction, pas une méthode.

In [46]: sample_list
Out[46]: ['a', 1, 'b', 'c', 'd', 'e', 10]

In [48]: del sample_list[-1]

In [49]: sample_list
Out[49]: ['a', 1, 'b', 'c', 'd', 'e']

(Les implémentations Del, len et non uniformes sont assez déroutantes.)

Supprimer les éléments en fonction de la valeur avec remove ()

Si vous ne connaissez pas le décalage ou si vous ne vous souciez pas de son emplacement, vous pouvez utiliser remove () pour spécifier une valeur pour supprimer l'élément.

In [49]: sample_list
Out[49]: ['a', 1, 'b', 'c', 'd', 'e']

In [50]: sample_list.remove(1)

In [51]: sample_list
Out[51]: ['a', 'b', 'c', 'd', 'e']

Comment récupérer et supprimer un élément en spécifiant un décalage avec pop ()

Vous pouvez utiliser pop () pour faire sortir un élément de la liste et le supprimer de la liste en même temps. L'appel de pop () avec un décalage renvoie l'élément correspondant à ce décalage. Si aucun argument n'est donné, -1 est utilisé comme décalage.

In [51]: sample_list
Out[51]: ['a', 'b', 'c', 'd', 'e']

In [52]: sample_list.pop()
Out[52]: 'e'

In [53]: sample_list
Out[53]: ['a', 'b', 'c', 'd']

In [54]: sample_list.pop(1)
Out[54]: 'b'

In [55]: sample_list
Out[55]: ['a', 'c', 'd']

Comment connaître le décalage de l'élément à partir de la valeur de l'élément par index ()

In [56]: sample_list = ['a','b','c','d','e']

In [57]: sample_list.append('a')

In [58]: sample_list
Out[58]: ['a', 'b', 'c', 'd', 'e', 'a']

In [60]: sample_list.index('b')
Out[60]: 1

#S'il y en a plusieurs, celui avec le plus petit décalage
In [61]: sample_list.index('a')
Out[61]: 0

Tester la présence ou l'absence de valeurs en utilisant in

Utilisez pour tester si la liste a une valeur.

In [64]: sample_list
Out[64]: ['a', 'b', 'c', 'd', 'e']

In [65]: 'a' in sample_list
Out[65]: True

In [66]: 'g' in sample_list
Out[66]: False

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

Utilisez count () pour compter le nombre de valeurs spécifiques dans la liste.

In [64]: sample_list
Out[64]: ['a', 'b', 'c', 'd', 'e']

In [67]: sample_list.count('a')
Out[67]: 1

In [68]: sample_list.count('g')
Out[68]: 0

In [69]: sample_list.append('a')

In [70]: sample_list
Out[70]: ['a', 'b', 'c', 'd', 'e', 'a']

In [71]: sample_list.count('a')
Out[71]: 2

Tri des éléments par tri ()

Il existe deux sortes --La méthode sort () est une opération destructive --La fonction générique triée () est une opération non destructive --Renvoie une copie de la liste triée

In [76]: names = [ 'Ryoma', 'Toshimichi', 'Tomoatsu']

In [77]: sorted_named = sorted(names)

In [78]: sorted_named
Out[78]: ['Ryoma', 'Tomoatsu', 'Toshimichi']

In [79]: names.sort()

In [80]: names
Out[80]: ['Ryoma', 'Tomoatsu', 'Toshimichi']

Les entiers et les flottants peuvent être utilisés ensemble car Python les convertit automatiquement dans l'expression.

In [81]: numbers = [2, 1, 4.0, 3]

In [82]: numbers.sort()

In [83]: numbers
Out[83]: [1, 2, 3, 4.0]

Par défaut, il est dans l'ordre croissant,```reverse=True``Cela peut également être fait par ordre décroissant.

In [84]: numbers = [2, 1, 4.0, 3]

In [85]: numbers.sort(reverse=True)

In [86]: numbers
Out[86]: [4.0, 3, 2, 1]

=Substitution et copie par()Copier par

=Notez ensuite que la destination de référence est la même.

In [87]: a = [1, 2, 3]

In [88]: b = a

In [89]: b[0] = 'why'

In [90]: b
Out[90]: ['why', 2, 3]

In [91]: a
Out[91]: ['why', 2, 3]

Utilisez l'un des éléments suivants pour copier -Copie de liste()une fonction

list()Fonction de conversion -Tranche de poignet[:]

In [92]: a = [1, 2, 3]

In [93]: b = a.copy()

In [94]: c = list(a)

In [95]: d = a[:]

In [96]: a
Out[96]: [1, 2, 3]

In [97]: b
Out[97]: [1, 2, 3]

In [98]: c
Out[98]: [1, 2, 3]

In [99]: d
Out[99]: [1, 2, 3]

In [100]: a[0] = 'why'

In [101]: a
Out[101]: ['why', 2, 3]

In [102]: b
Out[102]: [1, 2, 3]

In [103]: c
Out[103]: [1, 2, 3]

In [104]: d
Out[104]: [1, 2, 3]

list()À propos de la fonction de conversion

list()La fonction de conversion génère une liste lorsqu'elle est utilisée seule, mais lors de la prise d'une liste ou d'un tapple comme argument, la partie la plus externe du contenu est développée et répertoriée.

In [107]: a = [1, 2, 3]

In [108]: b = (1, 2, 3)

In [109]: c = list(a)

In [110]: c
Out[110]: [1, 2, 3]

In [111]: d = list(b)

In [112]: d
Out[112]: [1, 2, 3]

In [113]: a.append(b)

In [114]: a
Out[114]: [1, 2, 3, (1, 2, 3)]

In [115]: c = list(a)

In [116]: c
Out[116]: [1, 2, 3, (1, 2, 3)]

Résumé des opérations de liste Python3