Создание списка в Python - что-то подлый?

Ответ 1

Нет, Python не вызывает list(), или вы можете повлиять на то, какой тип [] создается, назначив список, который вы не можете:

>>> import __builtin__
>>> __builtin__.list = set
>>> list()
set([])
>>> []
[]

[] - это синтаксис для создания списка. Это встроенный тип, и он имеет специальный синтаксис, точно так же, как dicts и строки и ints и float и множество других типов.

Создание экземпляров типов также можно выполнить, вызвав тип, например list() - который, в свою очередь, вызовет конструктор типов и инициализатор для вас. Вызов инициализатора (__init__) напрямую не создает новый экземпляр типа. Вызов конструктора (__new__) выполняется, но вы не должны вызывать его напрямую.

Ответ 2

Эти две конструкции обрабатываются совершенно по-другому:

>>> import dis
>>> def f(): return []
... 
>>> dis.dis(f)
  1           0 BUILD_LIST               0
              3 RETURN_VALUE        
>>> def f(): return list()
... 
>>> dis.dis(f)
  1           0 LOAD_GLOBAL              0 (list)
              3 CALL_FUNCTION            0
              6 RETURN_VALUE        
>>> 

Форма [] создает список с использованием кода операции BUILD_LIST, тогда как форма list() вызывает конструктор объекта list.

Ответ 3

Я начал изучать питон вчера. Я предполагаю, что вам придется сказать, что его внутренне отображенный

>>> a = []
>>> type(a)
<type 'list'>
>>> a = list()
>>> type(a)
<type 'list'>

Ответ 4

В дополнение к другим ответам, из Справочник по языку:

Отображение списка - это, возможно, пустая серия выражений, заключенных в квадратные скобки:

list_display        ::=  "[" [expression_list | list_comprehension] "]"
...

Отображение списка дает новый объект списка.

В нем явно не упоминается, как реализуется "создание нового объекта списка". Это может быть вызов конструктора list(), как вы упомянули. Или, может быть, списки, будучи настолько элементарными, получают специальное лечение, а list() фактически отображается на что-то совершенно другое.

В любом случае, [], конечно, не отображается на вызов конструктора типа с именем __builtins__.list, поскольку переопределение этого типа по-прежнему вызывает [] возврат фактического списка, как показали другие респонденты.

Ответ 5

Python, как и большинство языков программирования, имеет нечто, называемое литералами, что означает, что специальный синтаксис можно использовать для записи некоторых из наиболее важных типов значений. Очень мало этого необходимо, но это упрощает использование Python, что мы можем писать литералы.

>>> 0
0
>>> int()
0
>>> 5
5
>>> int('5') # I'm using a string literal here though!
5
>>> 0.0
0.0
>>> float()
0.0
>>> "" 
''
>>> str()
''
>>> u""
u''
>>> unicode()
u''
>>> ()
()
>>> tuple()
()
>>> {}
{}
>>> dict()
{}     

Когда мы создаем собственные типы (классы), мы создаем их экземпляры, используя их конструкторы, например list для списков. Когда мы используем литералы, это похоже на синтаксический сахар для вызова list, но на самом деле он называет те же самые основные вещи за сценой.

Ответ 6

Поскольку:

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable items
    """

Если элемент в ваших списках является iterable (т.е. str), то list() и [] не работают одинаково.

Так

>>> a = ['ab']
>>> b = list('ab')
>>> a[0]
'ab'
>>> b[0]
'a'

Ответ 7

Каковы основные различия между использованием списка() и []?

Наиболее очевидным и видимым ключевым отличием между списками() и [] является синтаксис. Отложив синтаксис в сторону на минуту, кто-то, чей новый или промежуточный доступ к python может утверждать, что они оба являются списками или происходят из одного класса; это правда. Это, кроме того, повышает важность понимания ключевых различий обоих, большинство из которых изложены ниже.

list() - это функция, а [] - литеральный синтаксис.

Давайте посмотрим, что произойдет, когда мы вызываем список() и [] соответственно через дизассемблер.

>>> import dis
>>> print(dis.dis(lambda: list()))
  1           0 LOAD_GLOBAL              0 (list)
              3 CALL_FUNCTION            0 (0 positional, 0 keyword pair)
              6 RETURN_VALUE
None
>>> print(dis.dis(lambda: []))
  1           0 BUILD_LIST               0
              3 RETURN_VALUE
None

Вывод из дизассемблера выше показывает, что версия синтаксиса буквального запроса не требует глобального поиска, обозначаемого операционным кодом LOAD_GLOBAL или вызовом функции, обозначаемым операционным кодом CALL_FUNCTION.

В результате литеральный синтаксис быстрее, чем его аналог. - Давайте возьмем секунду и посмотрим на тайминги ниже.

import timeit
>>> timeit.timeit('[]', number=10**4)
0.0014592369552701712
>>> timeit.timeit('list()', number=10**4)
0.0033833282068371773

В другой заметке его одинаково важно и стоит отметить, что буквальный синтаксис [] не распаковывает значения. Ниже приведен пример распаковки.

>>> list('abc') # unpacks value
['a', 'b', 'c']
>>> ['abc'] # value remains packed
['abc']

Что такое буквальный питон?

Литералы - это обозначения или способ записи постоянных или необработанных значений переменных, которые python распознает как встроенные типы.

Некоторые из перечисленных выше были скопированы из большой статьи PythonRight - какая разница между списком и [].