python

list() new empty list

list(iterable) new list initialized from iterable’s items

The constructor builds a list whose items are the same and
in the same order as iterable’s items.

iterable may be either a sequence, a container that supports iteration,
or an iterator object. If iterable is already a list, a copy is made and returned,
similar to iterable[:]. e.g. list('abc') => ['a', 'b', 'c'],
list(range(2)) => [0, 1], list([0, 1]) => [0, 1].

Create

l.copy() # New in Python3

Return a shallow copy of l.
l.append(p_object)

Append object to the end of l.
l.insert(index, p_object)

Insert object before index.
l.extend(iterable)

Extend list by appending elements from iterable.

Delete

l.pop([index])

Remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
l.remove(value)

Remove first occurrence of value.
Raises ValueError if the value is not present.
l.clear() # New in Python3

Return a shallow copy of l.

Retrieve

l.count(value)

Return number of occurrences of value.
l.index(value, [start[, stop]])

Return first index of value.

Update

l.reverse()

Reverse IN PLACE. e.g.

l = [0, 1, 2]
l.reverse()   # No list return, but reverse in place
print(l)
[2, 1, 0]

l.sort([key, reverse])

Sorts the list l in place.

sort() accepts two arguments that can only be passed by keyword (keyword-only arguments).

Error: l.sort(lambda x: x == 2), l.sort(lambda x: x == 2, True)

True: l.sort(key=lambda x: x == 2), l.sort(key=lambda x: x == 2, reverse=True)

key, specifies a function of one argument that is used to extract a
comparision key from each list element (e.g. key=str.lower).

The smaller of the key function return value, the corresponding item is more forward.
And the True indicate int 1, False indicate int 0.
1
2
3
4
5
6
7
l = [5, 1, 2, 4, 0]
l.sort(key=lambda x: x == 2)
print(l)
[5, 1, 4, 0, 2]   # 2 => True(1); others => False(0)
l.sort(key=lambda x: x)
print(l)
[0, 1, 2, 4, 5]

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """
    def append(self, p_object):
        """ L.append(object) -> None -- append object to end """
        pass

    def clear(self): # New in Python3
        """ L.clear() -> None -- remove all items from L """
        pass

    def copy(self): # New in Python3
        """ L.copy() -> list -- a shallow copy of L """
        return []

    def count(self, value):
        """ L.count(value) -> integer -- return number of occurrences of value """
        return 0

    def extend(self, iterable):
        """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
        pass

    def index(self, value, start=None, stop=None):
        """
        L.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0

    def insert(self, index, p_object):
        """ L.insert(index, object) -- insert object before index """
        pass

    def pop(self, index=None):
        """
        L.pop([index]) -> item -- remove and return item at index (default last).
        Raises IndexError if list is empty or index is out of range.
        """
        pass

    def remove(self, value):
        """
        L.remove(value) -> None -- remove first occurrence of value.
        Raises ValueError if the value is not present.
        """
        pass

    def reverse(self):
        """ L.reverse() -- reverse *IN PLACE* """
        pass

    def sort(self, key=None, reverse=False):
        """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
        pass

    def __add__(self, *args, **kwargs):
        """ Return self+value. """
        pass

    def __contains__(self, *args, **kwargs):
        """ Return key in self. """
        pass

    def __delitem__(self, *args, **kwargs):
        """ Delete self[key]. """
        pass

    def __eq__(self, *args, **kwargs):
        """ Return self==value. """
        pass

    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, y):
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __ge__(self, *args, **kwargs):
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs):
        """ Return self>value. """
        pass

    def __iadd__(self, *args, **kwargs):
        """ Implement self+=value. """
        pass

    def __imul__(self, *args, **kwargs):
        """ Implement self*=value. """
        pass

    def __init__(self, seq=()):
        """
        list() -> new empty list
        list(iterable) -> new list initialized from iterable's items
        # (copied from class doc)
        """
        pass

    def __iter__(self, *args, **kwargs):
        """ Implement iter(self). """
        pass

    def __len__(self, *args, **kwargs):
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs):
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs):
        """ Return self<value. """
        pass

    def __mul__(self, *args, **kwargs):
        """ Return self*value.n """
        pass

    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs):
        """ Return self!=value. """
        pass

    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        pass

    def __reversed__(self):
        """ L.__reversed__() -- return a reverse iterator over the list """
        pass

    def __rmul__(self, *args, **kwargs):
        """ Return self*value. """
        pass

    def __setitem__(self, *args, **kwargs):
        """ Set self[key] to value. """
        pass

    def __sizeof__(self):
        """ L.__sizeof__() -- size of L in memory, in bytes """
        pass

    __hash__ = None

Create

Delete

Retrieve

Update

近期文章

近期评论

标签

热门

文章归档

分类目录

功能