Liste divisée en plus petites listes (coupé en deux)

Je suis à la recherche d'un moyen de partager facilement une liste python de moitié.

De sorte que si j'ai un tableau:

A = [0,1,2,3,4,5]

Je voudrais être en mesure d'obtenir:

B = [0,1,2]

C = [3,4,5]

InformationsquelleAutor corymathews | 2009-04-15

193
```
A = [1,2,3,4,5,6]
B = A[:len(A)//2]
C = A[len(A)//2:]
```
Si vous voulez une fonction:
```
def split_list(a_list):
    half = len(a_list)//2
    return a_list[:half], a_list[half:]

A = [1,2,3,4,5,6]
B, C = split_list(A)
```
- Vous avez besoin de force int division en Python 3. // est nécessaire.
- Solution sympa, merci. Il travaille également avec les fractions comme des 80/20 en Python3 B = A[:(len(A) // 10) * 8] C = A[(len(A) // 10) * 8:]
InformationsquelleAutor Jason Coon
76

Un peu plus de solution générique (vous pouvez spécifier le nombre de pièces que vous voulez, et pas seulement split "à la moitié"):

MODIFIER: mise à jour de la poste à la poignée impair de la liste de longueurs

EDIT2: mise à jour du post sur la base de Brians des commentaires et des informations
```
def split_list(alist, wanted_parts=1):
    length = len(alist)
    return [ alist[i*length // wanted_parts: (i+1)*length // wanted_parts] 
             for i in range(wanted_parts) ]

A = [0,1,2,3,4,5,6,7,8,9]

print split_list(A, wanted_parts=1)
print split_list(A, wanted_parts=2)
print split_list(A, wanted_parts=8)
```
- Lorsque la liste n'est pas répartir uniformément (par exemple split_list([1,2,3], 2) ) ce sera fait, retournez wanted_parts+1 listes.
- C'est correct, j'étais dans le doute que ce qui devrait être la bonne approche (qui ont une plus grande partie ou la dernière de la liste ont un élément de plus). Je vais mettre à jour mon post, merci pour les commentaires.
- En fait, cela ne fonctionne toujours pas: vous pouvez avoir un reste > 1. split_list(range(5),3) donner 5 listes à l'aide du code ci-dessus. Traitant de ces cas est aussi plus délicat, car vous avez besoin de diffuser de la liste de façon égale (par exemple. pour un 19 de l'élément de liste en 10 parties, vous ne voulez pas 9*1 point et une avec 9.)
- Une meilleure façon, je pense que ce serait: longueur = len(accédez à la liste); return [ accédez à la liste[i*longueur // wanted_parts: (i+1)*longueur // wanted_parts] for i in range(wanted_parts) ]. De cette façon, vous obtenez même une possible distribution, et de toujours obtenir exactement wanted_parts éléments (même les plaquettes avec [] si wanted_parts > len(A))
- Très belle solution, merci beaucoup. Beaucoup plus court aussi la façon dont je pense... je vais mettre à jour mon post.
- salut.. ce que le symbole "//" signifie??
- Sa signifie qu'en ligne de commentaire. Ignorer "// wanted_parts" et "// wanted_parts" pour faire un script à exécuter.
- // signifie division entière. Ils ne devraient pas être laissé de côté, comme ils sont tout à fait essentielle à la réalisation de ce travail.
InformationsquelleAutor ChristopheD
39
```
f = lambda A, n=3: [A[i:i+n] for i in range(0, len(A), n)]
f(A)
```
n - la longueur prédéterminée de résultat tableaux
- Cela fonctionne très bien dans ma situation, il est toutefois en ajoutant tous les autres les derniers index de chaque liste dans une liste. Dur à expliquer. Merci de répondre si vous pouvez l'aider et je vais vous expliquer plus.
- Incroyable, je vous remercie.
InformationsquelleAutor Jaro
30
```
def split(arr, size):
     arrs = []
     while len(arr) > size:
         pice = arr[:size]
         arrs.append(pice)
         arr   = arr[size:]
     arrs.append(arr)
     return arrs
```
Test:
```
x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
print(split(x, 5))
```
résultat:
```
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]
```
- J'ai vraiment apprécié la façon dont vous avez formaté cette réponse comme "fonction" + "test" + "résultat"!
- aussi utile pour convertir la liste de la matrice
- Cela fonctionne, mais pas tout à fait. Je suis à l'aide de cette fonction dans une boucle, et les longueurs varient. En d'autres termes: for i,j in zip(list,lengths): print(split(i,j)). Le list et lengths listes ont la même longueur. j est l'alternance: 5,4,5,4,5, et la fonction de répartition fonctionne sur les deux premières alternances, c'est à dire qu'il divise le premier i de liste par 5 et 4, MAIS sur la prochaine itération, il se divise à 4,4,1. :\ Merci de répondre si vous désirez m'expliquer plus (poster une nouvelle question)
- c'est la bonne réponse!!!
InformationsquelleAutor Siamand
12

B,C=A[:len(A)/2],A[len(A)/2:]
- Je crois que vous avez oublié la division par 2 de l'étape. 🙂
- Yep, je l'ai fait. Édité deux secondes après l'affichage...
- de points pour être en une seule ligne
InformationsquelleAutor John Montgomery
11

Voici une solution commune, split arr dans le comte de la partie
```
def split(arr, count):
     return [arr[i::count] for i in range(count)]
```
- Ce perd de l'ordre de la liste
InformationsquelleAutor Chris Song
10

Si vous ne se soucient pas de l'ordre...
```
def split(list):  
    return list[::2], list[1::2]
```
list[::2] obtient chaque deuxième élément dans la liste à partir de la 0e élément.

list[1::2] obtient chaque deuxième élément dans la liste, en commençant à partir du 1er élément.
- Attention de nommage de l'arg list avec de l'ombre à la list(...) intégré. J'ai vu lst et list_ utilisé couramment pour l'éviter.
- ce sent plus pythonic (en ignorant le mauvais nommage)
InformationsquelleAutor sentythee
7
```
def splitter(A):
    B = A[0:len(A)//2]
    C = A[len(A)//2:]

 return (B,C)
```
J'ai testé, et le double slash est nécessaire pour forcer l'int division en python 3. Mon premier post était correct, bien que wysiwyg a éclaté à l'Opéra, pour une raison quelconque.
- il ne gère pas bizarre len(A) - avez-vous une solution pour cela ?
InformationsquelleAutor Stefan Kendall

Il y a un officiel de Python recette pour le plus généralisé au cas de division d'un tableau en petits tableaux de taille n.

from itertools import izip_longest
def grouper(n, iterable, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

Ce bout de code est à partir de la python itertools page de doc.

InformationsquelleAutor Jonathan Berger

4

À l'aide de liste de découpage. La syntaxe est fondamentalement my_list[start_index:end_index]
```
>>> i = [0,1,2,3,4,5]
>>> i[:3] # same as i[0:3] - grabs from first to third index (0->2)
[0, 1, 2]
>>> i[3:] # same as i[3:len(i)] - grabs from fourth index to end
[3, 4, 5]
```
Pour obtenir la première moitié de la liste, vous la tranche dans le premier index de len(i)//2 (où // est la division entière - si 3//2 will give the floored result of1, instead of the invalid list index ofde 1,5`):
```
>>> i[:len(i)//2]
[0, 1, 2]
```
..et le swap, les valeurs autour pour obtenir la seconde moitié:
```
>>> i[len(i)//2:]
[3, 4, 5]
```
- qu'en est impair len listes)
- Le code doit encore travailler; vous avez juste à la fin avec un nombre différent d'éléments de chaque liste. Donc, dire que la liste est de trois articles de long, l'opérateur de division étages, le résultat 3//2 donne 1, puis vous obtenez des i[:1] qui vous donne [0] et et i[1:] qui donne [1, 2]
InformationsquelleAutor dbr
2

Même si les réponses ci-dessus sont plus ou moins corrects, vous risquez de rencontrer des problèmes si la taille de votre tableau n'est pas divisible par 2, comme le résultat de a /2, un être bizarre, est un flotteur en python 3.0, et dans la version antérieure si vous spécifiez from __future__ import division au début de votre script. Vous êtes en tout cas mieux de passer pour la division entière, c'est à dire a //2, afin d'obtenir "l'avant" de la compatibilité de votre code.

InformationsquelleAutor user91259

Si vous avez une grande liste, Il est préférable d'utiliser itertools et écrire une fonction pour un rendement de chaque partie en fonction des besoins:

from itertools import islice

def make_chunks(data, SIZE):
    it = iter(data)
    # use `xragne` if you are in python 2.7:
    for i in range(0, len(data), SIZE):
        yield [k for k in islice(it, SIZE)]

Vous pouvez l'utiliser comme:

A = [0, 1, 2, 3, 4, 5, 6]

size = len(A) // 2

for sample in make_chunks(A, size):
    print(sample)

La sortie est:

[0, 1, 2]
[3, 4, 5]
[6]

Grâce à @thefourtheye et @Bède Constantinides

InformationsquelleAutor M.A. Heshmat Khah

10 ans plus tard.. j'ai pensé pourquoi ne pas en ajouter une autre:

arr = 'Some random string' * 10; n = 4
print([arr[e:e+n] for e in range(0,len(arr),n)])

InformationsquelleAutor RoyM

Avec des notes de @ChristopheD

def line_split(N, K=1):
    length = len(N)
    return [N[i*length/K:(i+1)*length/K] for i in range(K)]

A = [0,1,2,3,4,5,6,7,8,9]
print line_split(A,1)
print line_split(A,2)

InformationsquelleAutor PunjCoder

Ceci est similaire à d'autres solutions, mais un peu plus vite.

# Usage: split_half([1,2,3,4,5]) Result: ([1, 2], [3, 4, 5])

def split_half(a):
    half = len(a) >> 1
    return a[:half], a[half:]

InformationsquelleAutor Ruslanas Balčiūnas

#for python 3
    A = [0,1,2,3,4,5]
    l = len(A)/2
    B = A[:int(l)]
    C = A[int(l):]

InformationsquelleAutor SuperGuy10

Vous devez vous connecter pour publier un commentaire.