Denk aan het volgende:

items = []
items.append("apple")
items.append("orange")
items.append("banana")
# FAKE METHOD:
items.amount()  # Should return 3

Hoe kom ik aan het aantal elementen in de lijst items?

Antwoord 1, autoriteit 100%

De len()-functie kan worden gebruikt met verschillende typen in Python – zowel ingebouwde typen als bibliotheektypen. Bijvoorbeeld:

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

Antwoord 2, autoriteit 9%

Hoe krijg ik de grootte van een lijst?

Gebruik de ingebouwde functie om de grootte van een lijst te bepalen, len:

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

En nu:

len(items)

retourneert 3.

Uitleg

Alles in Python is een object, inclusief lijsten. Alle objecten hebben een soort kop in de C-implementatie.

Lijsten en andere soortgelijke ingebouwde objecten met een “grootte” in Python, in het bijzonder, hebben een attribuut genaamd ob_size, waar het aantal elementen in het object in de cache wordt opgeslagen. Het controleren van het aantal objecten in een lijst gaat dus erg snel.

Maar als u controleert of de lijstgrootte nul is of niet, gebruik dan geen len– in plaats daarvan zet de lijst in een booleaanse context – deze wordt behandeld als False indien leeg, anders True.

Van de docs

len(s)

Retourneer de lengte (het aantal items) van een object. Het argument kan een reeks zijn (zoals een string, bytes, tuple, lijst of bereik) of
een verzameling (zoals een woordenboek, set of bevroren set).

lenis geïmplementeerd met __len__, uit het datamodel docs:

object.__len__(self)

Geroepen om de ingebouwde functie len()te implementeren. Zou de lengte van het object moeten retourneren, een geheel getal >= 0. Ook een object dat niet
definieer een __nonzero__()[in Python 2 of __bool__()in Python 3] methode en waarvan de __len__()methode nul retourneert
wordt als onwaar beschouwd in een Booleaanse context.

En we kunnen ook zien dat __len__een methode van lijsten is:

items.__len__()

retourneert 3.

Ingebouwde typen kun je de len(lengte) van

. krijgen

En in feite zien we dat we deze informatie voor alle beschreven typen kunnen krijgen:

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

Gebruik lenniet om te testen op een lege of niet-lege lijst

Om op een bepaalde lengte te testen, kunt u natuurlijk gewoon testen op gelijkheid:

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

Maar er is een speciaal geval voor het testen op een lijst met een lengte van nul of het omgekeerde. Test in dat geval niet op gelijkheid.

Doe ook niet:

if len(items): 
    ...

Doe in plaats daarvan gewoon:

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

of

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

Ik leg hier uit waarommaar kortom, if not itemsof if not itemsis zowel leesbaarder als performanter.

Antwoord 3, autoriteit 3%

Hoewel dit misschien niet handig is vanwege het feit dat het veel logischer zou zijn als “out of the box”-functionaliteit, zou een vrij eenvoudige hack zijn om een klasse te bouwen met een lengtheigenschap:

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

Je kunt het als volgt gebruiken:

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

In wezen is het precies identiek aan een lijstobject, met het extra voordeel dat het een OOP-vriendelijke eigenschap lengthheeft.

Zoals altijd kan uw kilometerstand variëren.

Antwoord 4

En voor de volledigheid (voornamelijk educatief), is het mogelijk zonder de functie len()te gebruiken. Ik zou dit niet door de vingers zien als een goede optie PROGRAMMEER DIT NIET IN PYTHON, maar het dient een doel voor het leren van algoritmen.

def count(list):
    item_count = 0
    for item in list[:]:
        item_count += 1
    return item_count
count([1,2,3,4,5])

(de indexbediening met dubbele dikke colon in list[:]is impliciet en is daarom ook optioneel.)

De les hier voor nieuwe programmeurs is: u kunt het aantal items in een lijst niet krijgen zonder ze op een gegeven moment te tellen. De vraag wordt: wanneer is het een goed moment om ze te tellen? Bijvoorbeeld, hoogwaardige code zoals het CONNECT-SYSTEEM CALL for Sockets (geschreven in c) connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);, berekent de lengte van elementen niet ( die verantwoordelijkheid geven aan de roepcode). Merk op dat de lengte van het adres wordt doorgegeven om de stap te redden van het tellen van de lengte? Een andere optie: computationaal, het kan logisch zijn om het aantal items bij te houden terwijl u ze toevoegt binnen het object dat u passeert. Let op dat dit meer ruimte in het geheugen inneemt. Zie NAFTULI KAY’S ANTWOORD .

Voorbeeld van het bijhouden van de lengte om de prestaties te verbeteren tijdens het in beslag nemen van meer ruimte in het geheugen. Merk op dat ik de functie Len () nooit gebruiken omdat de lengte wordt gevolgd:

class MyList(object):
    def __init__(self):
        self._data = []
        self.length = 0 # length tracker that takes up memory but makes length op O(1) time
        # the implicit iterator in a list class
    def __iter__(self):
        for elem in self._data:
            yield elem
    def add(self, elem):
        self._data.append(elem)
        self.length += 1
    def remove(self, elem):
        self._data.remove(elem)
        self.length -= 1
mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
print(mylist.length) # 3
mylist.remove(3)
print(mylist.length) # 2

Antwoord 5

Uw vraag beantwoorden zoals de voorbeelden die ook eerder zijn gegeven:

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

Antwoord 6

Om het aantal elementen in een sequentieel object te krijgen, is uw goto-methode in Python len()bijv.

a = range(1000) # range
b = 'abcdefghijklmnopqrstuvwxyz' # string
c = [10, 20, 30] # List
d = (30, 40, 50, 60, 70) # tuple
e = {11, 21, 31, 41} # set

De

len()-methode kan werken op alle bovenstaande gegevenstypen omdat ze itereerbaar zijn, d.w.z. u kunt eroverheen herhalen.

all_var = [a, b, c, d, e] # All variables are stored to a list
for var in all_var:
    print(len(var))

Ruwe schatting van de len()-methode

def len(iterable, /):
    total = 0
    for i in iterable:
        total += 1
    return total

Antwoord 7

Er is een ingebouwde functie genaamd len() in python die in deze omstandigheden zal helpen.

a=[1,2,3,4,5,6]
print(len(a))     #Here the len() function counts the number of items in the list.

Uitvoer:

>>> 6

Dit werkt iets anders in het geval van string (hieronder):

a="Hello"
print(len(a)) #Here the len() function counts the alphabets or characters in the list.

Uitvoer:

>>> 5

Dit komt omdat variabele (a) een tekenreeks is en geen lijst, dus het telt het aantal tekens of alfabetten in de tekenreeks en drukt vervolgens de uitvoer af.

Antwoord 8

In termen van hoe len()eigenlijk werkt, is dit de C-implementatie:

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_tis de maximale lengte die het object kan hebben. PyObject_Size()is een functie die de grootte van een object retourneert. Als het de grootte van een object niet kan bepalen, retourneert het -1. In dat geval wordt dit codeblok uitgevoerd:

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

En als gevolg hiervan wordt een uitzondering gegenereerd. Anders wordt dit codeblok uitgevoerd:

   return PyLong_FromSsize_t(res);

res, een CInteger, wordt omgezet in een Python int(die nog steeds een “lang” in de C-code wordt genoemd Omdat Python 2 twee typen had voor het opslaan van gehele getallen) en geretourneerd.