Comment puis-je obtenir le nombre d'éléments dans une liste?

De considérer les éléments suivants:

items = []
items.append("apple")
items.append("orange")
items.append("banana")

# FAKE METHOD:
items.amount()  # Should return 3

Comment puis-je obtenir le nombre d'éléments dans la liste items?

InformationsquelleAutor y2k | 2009-11-11
  1. 2500

    La len() fonction peut être utilisée avec différents types de Python - à la fois intégré dans les types et les types de bibliothèques. Par exemple:

    >>> len([1,2,3])
3

    Officiel 2.x la documentation est ici: len()

    Officiel 3.x la documentation est ici: len()

    InformationsquelleAutor gnud
  2. 213

    Comment obtenir la taille d'une liste?

    Pour trouver la taille d'une liste, utilisez la fonction builtin, len:

    items = []
items.append("apple")
items.append("orange")
items.append("banana")

    Et maintenant:

    len(items)

    renvoie 3.

    Explication

    Tout en Python est un objet, y compris les listes. Tous les objets ont un en-tête de la sorte dans le C mise en œuvre.

    Listes et d'autres semblables builtin objets avec une "taille" en Python, en particulier, ont un attribut appelé ob_size, où le nombre d'éléments dans l'objet est mis en cache. Par conséquent, en vérifiant le nombre d'objets dans une liste est très rapide.

    Mais si vous vérifiez si la taille de la liste est égal à zéro ou pas, n'utilisez pas de len - au lieu de cela, mettre la liste dans un contexte booléen - elle traitée comme Fausse si vide, True sinon.

    De la docs

    len(s)

    Retour de la longueur (nombre d'éléments) d'un objet. L'argument peut être une séquence (comme une chaîne d'octets, tuple, une liste ou une plage) ou
    une collection (comme un dictionnaire, un jeu, ou un ensemble figé).

    len est mis en œuvre avec __len__, à partir du modèle de données docs:

    object.__len__(self)

    Appelés à mettre en œuvre la fonction intégrée len(). Doit retourner la longueur de l'objet, integer >= 0. Aussi, un objet qui n'est pas
    définir un __nonzero__() [en Python 2 ou __bool__() en Python 3] méthode et dont __len__() méthode renvoie zéro
    est considéré comme faux dans un contexte Booléen.

    Et nous pouvons également voir que __len__ est une méthode de listes:

    items.__len__()

    renvoie 3.

    Builtin types que vous pouvez obtenir le len (longueur) de

    Et, en fait, nous voyons que nous pouvons obtenir cette information pour tous les types décrits:

    >>> all(hasattr(cls, '__len__') for cls in (str, bytes, tuple, list, 
                                            xrange, dict, set, frozenset))
True

    Ne pas utiliser len pour tester un vide ou non vide liste

    De test pour une longueur donnée, bien sûr, il suffit de tester l'égalité:

    if len(items) == required_length:
    ...

    Mais il y a un cas particulier du test d'un zéro de la longueur de la liste, ou l'inverse. Dans ce cas, ne pas tester l'égalité.

    Aussi, ne pas le faire:

    if len(items): 
    ...

    Au lieu de cela, il suffit de faire:

    if items:     # Then we have some items, not empty!
    ...

    ou

    if not items: # Then we have an empty list!
    ...

    Je expliquer pourquoi ici mais en bref, if items ou if not items est à la fois plus lisible et plus performant.

    InformationsquelleAutor Aaron Hall
  3. 72

    Même si cela peut ne pas être utile en raison du fait qu'il avait de faire beaucoup plus de sens que d'être "hors de la boîte" fonctionnalité, assez simple hack serait de construire une classe avec un length propriété:

    class slist(list):
    @property
    def length(self):
        return len(self)

    Vous pouvez l'utiliser comme ceci:

    >>> l = slist(range(10))
>>> l.length
10
>>> print l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    Essentiellement, c'est exactement identique à un objet de la liste, avec l'avantage d'avoir une programmation orientée objet-friendly length propriété.

    Comme toujours, votre kilométrage peut varier.

    • comme vous le savez, vous pouvez faire length = property(len) et sauter une ligne en fonction wrapper et de conserver la documentation / l'introspection de len avec votre propriété.
    InformationsquelleAutor Naftuli Kay
  4. 15

    Outre len vous pouvez également utiliser opérateur.length_hint (nécessite Python 3.4+). Pour une normale de list les deux sont équivalents, mais length_hint permet d'obtenir la longueur d'une liste itérateur, qui pourrait être utile dans certaines circonstances:

    >>> from operator import length_hint
>>> l = ["apple", "orange", "banana"]
>>> len(l)
3
>>> length_hint(l)
3

>>> list_iterator = iter(l)
>>> len(list_iterator)
TypeError: object of type 'list_iterator' has no len()
>>> length_hint(list_iterator)
3

    Mais length_hint est, par définition, qu'une "astuce", donc la plupart du temps len est mieux.

    J'ai vu plusieurs réponses, ce qui suggère l'accès __len__. C'est tout droit lorsque vous traitez avec des classes intégrées comme list, mais elle pourrait conduire à des problèmes de classes personnalisées, car len (et length_hint) mettre en place certains contrôles de sécurité. Par exemple, les deux ne permettent pas négatif des longueurs ou des longueurs qui dépassent une certaine valeur (la sys.maxsize valeur). Donc, il est toujours plus sûr d'utiliser le len fonction de la place de la __len__ méthode!

    InformationsquelleAutor MSeifert
  5. 6

    De répondre à votre question, comme les exemples donnés précédemment:

    items = []
items.append("apple")
items.append("orange")
items.append("banana")

print items.__len__()
    • En Python, les noms qui commencent par des caractères de soulignement sont sémantiquement non-public des méthodes et ne doit pas être utilisé par les utilisateurs.
    • 1. __foo__: c'est juste une convention, d'une manière pour le Python système à utiliser des noms qui n'entre pas en conflit avec des noms d'utilisateur. 2. _foo: c'est juste une convention, d'une manière pour le programmeur d'indiquer que la variable est privé (quoi que cela signifie en Python). 3. __foo: cela a un vrai sens: l'interprète remplace ce nom par _classname__foo comme un moyen de s'assurer que le nom ne se chevauchent pas avec un nom similaire dans une autre classe. * Aucune autre forme de souligne un sens à l'Python monde. * Il n'y a pas de différence entre la classe, une variable globale, etc dans ces conventions.
    • Cette Q&A, explique pourquoi vous ne devriez pas utiliser des méthodes spéciales directement en tant qu'utilisateur: stackoverflow.com/q/40272161/541136
    • mais pour la fonction len c'est presque la même. Il pourrait être plus rapide que pour les très grandes variables. Cependant, je reçois votre point et nous devrions utiliser len(obj) et pas d'obj.__len__().
    InformationsquelleAutor Shai Alon
  6. 6

    Et pour être complet, il est possible sans l'aide de la len() fonction (je ne tolère pas que c'est une bonne option N'PROGRAMME de CE genre EN PYTHON):

    def count(list):
  item_count = 0
  for item in list[:]:
    item_count += 1
  return item_count

count([1,2,3,4,5])

    (Le côlon dans list[:] est implicite et est donc également en option.)

    La leçon ici pour les nouveaux programmeurs est: Vous ne pouvez pas obtenir le nombre d'éléments dans une liste sans compter à un certain point. De calcul, il est préférable de garder une trace du nombre d'éléments que vous ajoutez. Voir Naftuli Kay réponse.

    • D'où vient l'OP dire qu'il ne veut pas utiliser la fonction len ()?
    • Où est votre pensée créative de la pac? Ma réponse répond à l'OP, quoique différemment. Nous accordons une multiplicité de réponses ici à StackExchange, droit?
    • D'accord. Mais la chose est, dans ce cas, il n'y a pas de raison d'utiliser votre code v. le un paquebot. Il calcul le plus rapide? Est-il plus facile de programmer de cette façon? Plusieurs réponses sont les bienvenues si elles montrent une nouvelle dimension.
    • Je suis d'accord. Mais ce n'est pas une raison pour downvote cette réponse. Je maintiens mon argument de la diversité.
    • Komar je suis en désaccord, si l'OP a été à la recherche pour les créations de la non-efficacité des moyens de le faire, il l'aurait précisé. Certaines questions peuvent être répondues 1 million de différentes façons, mais personne ne veut lire à 1 millions de réponses différentes
    • Vous avez droit à cet avis. Qu'est ce que le système de vote est pour. Vous avez fait une déclaration audacieuse cependant: “personne ne veut...” Peut-être que certaines personnes veulent plusieurs approches pour mieux comprendre la meilleure solution.
    • Permettez-moi de reformuler. Les gens viennent à cette question pour le même objectif de l'OP. Si les gens voulaient des façons créatives pour résoudre la question, il serait sans doute passer sous une autre question ou un forum. Des solutions alternatives sens quand ils sont la meilleure réponse a un certain type de limitation. Quand cette réponse jamais faire de bon sens sur la meilleure réponse? Pourquoi ne pas simplement donner une réponse écrite en binaire?
    • Personnellement, je suis heureux de trouver l'exemple qui contient la liste[:], j'ai trouvé cette réponse, tout en essayant de savoir pourquoi un exemple de code utilisé la syntaxe exacte avec le colon. Merci Jonathan REMARQUE: les personnes se retrouvent dans cette page, pour toutes sortes de raisons, et pas seulement pour répondre à l'OP demandé
    • Pourquoi for item in list[:]:? Pourquoi ne pas for item in list:? Aussi, je ne l'utiliserais += 1 à incrémenter.
    • J'ai mentionné explicitement l'option du côlon (gamme prescripteur). J'ai quitté la gamme spécificateur de il y à des fins éducatives-il est utile de savoir qu'il est implicite. Une liste type [] est déduit ainsi, comme vous le suggérez-l'équivalent de mon code. L'opérateur d'incrémentation est également équivaut à ajouter 1 à un existant variable, encore plus courte dans tous les cas. Oui, je serais d'accord qu'il devrait être utilisé si c'est votre raisonnement. Ce code ne doit pas être mis en production, n'importe où, de toute façon (sauf lors de l'apprentissage de la programmation).

    InformationsquelleAutor Jonathan Komar
  7. -1

    En termes de la façon dont len() fonctionne réellement, c'est sa C de la mise en œuvre:

    static PyObject *
builtin_len(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=fa7a270d314dfb6c input=bc55598da9e9c9b5]*/
{
    Py_ssize_t res;

    res = PyObject_Size(obj);
    if (res < 0) {
        assert(PyErr_Occurred());
        return NULL;
    }
    return PyLong_FromSsize_t(res);
}

    Py_ssize_t est la longueur maximale que l'objet peut avoir. PyObject_Size() est une fonction qui renvoie la taille d'un objet. Si il ne peut pas déterminer la taille d'un objet, il renvoie -1. Dans ce cas, ce bloc de code sera exécuté:

    if (res < 0) {
        assert(PyErr_Occurred());
        return NULL;
    }

    Et une exception est levée comme un résultat. Sinon, ce bloc de code sera exécuté:

    return PyLong_FromSsize_t(res);

    res qui est un C entier, est converti en un python long et retourné. Toutes python entiers sont stockés en tant que longs depuis Python 3.

    • Pourquoi le fait de connaître ou connaître le C de la mise en œuvre?
    InformationsquelleAutor Alec Alameddine