Есть ли разница между использованием литерала dict и конструктора dict?

Используя PyCharm, я заметил, что он предлагает преобразовать литерал dict :

d = { 'one': '1', 'two': '2', } 

в конструктор dict :

  • Удалить префикс из строки
  • Очистите веб-страницу, которая требует, чтобы они сначала открывали сессионный файл cookie
  • Как де-импортировать модуль Python?
  • Имитировать интерактивную сессию python
  • Использование профилирующей памяти в App Engine
  • Отключить отладку Django для сельдерея
  •  d = dict(one='1', two='2') 

    Различаются ли эти разные подходы каким-то значительным образом?

    (При написании этого вопроса я заметил, что использование dict() кажется невозможным указать числовой ключ. d = {1: 'one', 2: 'two'} возможно, но, очевидно, dict(1='one' ...) нет. Что-нибудь еще?)

  • Как обмениваться сеансами между модулями в приложении Python для приложения Google App Engine?
  • Функции Python вызывают по ссылке
  • Как получить более 1000?
  • Pycharm не может изменить интерпретатор от python 2.7 до 3.4
  • Загрузка сторонних библиотек Python
  • Как разбить файл на python?
  • 10 Solutions collect form web for “Есть ли разница между использованием литерала dict и конструктора dict?”

    Я думаю, вы указали на самую очевидную разницу. Кроме того,

    первый не нуждается в поиске dict который должен сделать его немного быстрее

    второй ищет dict в locals() а затем globals() и находит встроенный, поэтому вы можете переключать поведение, определяя локальный, называемый dict например, хотя я не могу придумать нигде, это было бы хорошей идеей, кроме возможно, при отладке

    Они выглядят примерно так же на Python 3.2.

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

     >>> def literal(): ... d = {'one': 1, 'two': 2} ... >>> def constructor(): ... d = dict(one='1', two='2') ... >>> import dis >>> dis.dis(literal) 2 0 BUILD_MAP 2 3 LOAD_CONST 1 (1) 6 LOAD_CONST 2 ('one') 9 STORE_MAP 10 LOAD_CONST 3 (2) 13 LOAD_CONST 4 ('two') 16 STORE_MAP 17 STORE_FAST 0 (d) 20 LOAD_CONST 0 (None) 23 RETURN_VALUE >>> dis.dis(constructor) 2 0 LOAD_GLOBAL 0 (dict) 3 LOAD_CONST 1 ('one') 6 LOAD_CONST 2 ('1') 9 LOAD_CONST 3 ('two') 12 LOAD_CONST 4 ('2') 15 CALL_FUNCTION 512 18 STORE_FAST 0 (d) 21 LOAD_CONST 0 (None) 24 RETURN_VALUE 

    Literal намного быстрее, поскольку использует оптимизированные коды операций BUILD_MAP и STORE_MAP, а не общие CALL_FUNCTION:

     > python2.7 -m timeit "d = dict(a=1, b=2, c=3, d=4, e=5)" 1000000 loops, best of 3: 0.958 usec per loop > python2.7 -m timeit "d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}" 1000000 loops, best of 3: 0.479 usec per loop > python3.2 -m timeit "d = dict(a=1, b=2, c=3, d=4, e=5)" 1000000 loops, best of 3: 0.975 usec per loop > python3.2 -m timeit "d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}" 1000000 loops, best of 3: 0.409 usec per loop 

    Эти два подхода создают идентичные словари, за исключением, как вы отметили, где мешают лексические правила Python.

    Словарные литералы – это немного более очевидные словари, и вы можете создать любой ключ, но вам нужно процитировать ключевые имена. С другой стороны, вы можете использовать переменные для ключей, если вам нужно по какой-то причине:

     a = "hello" d = { a: 'hi' } 

    Конструктор dict() дает вам большую гибкость из-за разнообразия форм ввода, которые он принимает. Например, вы можете предоставить ему итератор пар, и он будет рассматривать их как пары ключ / значение.

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

    Одна большая разница с python 3.4 + pycharm заключается в том, что конструктор dict () создает сообщение «синтаксическая ошибка», если количество ключей превышает 256.

    Теперь я предпочитаю использовать литерал dict.

    Из учебника python 2.7:

    Пара фигурных скобок создает пустой словарь: {}. Размещение разделенных запятыми списков ключей: пары значений в фигурных скобках добавляет пары начального ключа: значения в словарь; это также способ записи словарей на выходе.

     tel = {'jack': 4098, 'sape': 4139} data = {k:v for k,v in zip(xrange(10), xrange(10,20))} 

    В то время как:

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

     tel = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'jack': 4098, 'guido': 4127} data = dict((k,v) for k,v in zip(xrange(10), xrange(10,20))) 

    Когда ключи являются простыми строками, иногда проще указывать пары с использованием аргументов ключевого слова:

     dict(sape=4139, guido=4127, jack=4098) >>> {'sape': 4139, 'jack':4098, 'guido': 4127} 

    Таким образом, как {}, так и dict () создают словарь, но предоставляют несколько разных способов инициализации данных словаря.

    Я нахожу, что dict literal d = {'one': '1'} гораздо читабельнее, ваши определяющие данные, а не присваивает значения вещей и отправляет их в конструктор dict() .

    С другой стороны, я видел, как люди ошибались в dict literal как d = {'one', '1'} который в современном python 2.7+ создаст набор.

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

    Также учтите тот факт, что токены, которые соответствуют операторам, не могут использоваться в синтаксисе конструктора, то есть в ключах с ключами.

     >>> dict(foo-bar=1) File "<stdin>", line 1 SyntaxError: keyword can't be an expression >>> {'foo-bar': 1} {'foo-bar': 1} 

    Нет никакого литерала dict для создания унаследованных dict-классов, пользовательских классов dict с дополнительными методами. В этом случае следует использовать конструктор класса пользовательского типа, например:

     class NestedDict(dict): # ... skipped state_type_map = NestedDict(**{ 'owns': 'Another', 'uses': 'Another', }) 

    Литерал dict () хорош, когда вы копируете значения из чего-то другого (ни один python). Например, список переменных среды. если у вас есть файл bash, скажите

     FOO='bar' CABBAGE='good' 

    вы можете легко вставить его в литерал dict() и добавить комментарии. Это также упрощает выполнение противоположных действий, копируя их во что-то другое. В то время как синтаксис {'FOO': 'bar'} довольно уникален для python и json. Поэтому, если вы используете json много, вы можете использовать {} литералы с двойными кавычками.

    Python - лучший язык программирования в мире.