Ответ 1

Там проблема с "как python" , потому что не все интерпретируемые языки одинаковы.

С чисто интерпретируемым языком он будет иметь большее влияние, чем с одним, как Python, который имеет шаг до компиляции. Строго говоря, это не языковая разница (у вас может быть один Javascript-движок, который прекомпилирует, а другой - нет), но это влияет на ответ на этот вопрос.

Вытягивая "как python" , чтобы включить каждый интерпретируемый язык, я бы сказал, что ответ "да, для некоторых из них, по крайней мере, некоторое время". Следующий вопрос: "сколько".

В период с 1997 года по начало 1998 года я работал над некоторым довольно сложным кодом javascript, в котором использовались некоторые новые возможности Netscape Navigator 4 и Internet Explorer 4. Это был огромный файл javascript на тот момент - когда распространенность dial-up означает, что каждый килобайт считается с точки зрения скорости сайта.

По этой причине мы использовали минимизатор script. Главное, чтобы это было, чтобы переписать переменные короче (lastHeight становится a, userSel becmomes b и т.д.).

Это не только сократило время загрузки, но и сделало одну из более тяжелых функций заметно быстрее. Но только заметно, если бы вы были тем, кто провел весь свой рабочий день, не глядя ни на что другое, что в значительной степени означало меня и другого коллегу.

Итак, да, если мы поместим Javascript в категорию "как python" , насколько это интерпретация, то это может иметь значение при следующих условиях:

• Он работал на Pentium, Pentium Pro и 486 (тогда Pentium II был, но у нас их не было). Я получил новую машину частично через проект, а это значит, что я перешел с 133 МГц до 166 МГц.
• Это был довольно большой кусок неприятного цикла (большая часть script не имела заметной разницы).
• Он запускался на script -engine с 15 лет назад без каких-либо улучшений в производительности script -engine, которые были сделаны с тех пор.

И это все еще не так сильно отличалось.

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

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

Ответ 2

Нет. № Нет. Нет.

Нет.

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

$ python -m timeit "i = 5" "i *= i"
10000000 loops, best of 3: 0.0938 usec per loop

$ python -m timeit "is_there_anything_to_be_gained_from_short_variable_names = 5" "is_there_anything_to_be_gained_from_short_variable_names *= is_there_anything_to_be_gained_from_short_variable_names"
10000000 loops, best of 3: 0.0927 usec per loop

По иронии судьбы, при измерении на этом ПК длинное имя переменной было, следовательно, измерено на ~ 0,001 мкс быстрее за выполнение.

Ответ 3

Если вы имеете в виду интерпретируемые языки по замечанию "языки, такие как Python", то да, это будет иметь значение, поскольку синтаксический анализ может занять несколько больше времени. Разница незаметна, я бы сказал.

Я полностью согласен с ночным кошмаром; не делай этого. Сделайте свой код читаемым для человека. Пусть анализатор/компилятор обрабатывает читаемость для машины.

Помните правила оптимизации:

• Не делай этого.
• (Только для экспертов) еще не делайте этого.

Ответ 4

Вы должны использовать короткие имена переменных только для индексов коротких циклов и когда переменная короткая.

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

Ответ 5

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

Ответ 6

Следуя ответам orlps, я считал, что классы Python используют словарь для поиска, поэтому я задавался вопросом, есть ли какие-либо преимущества в этом отношении.

import timeit

A = """
class A_CLASS_WITH_A_LONG_NAME:
    def a_function_with_a_long_name(self):
        return 1

A_CLASS_WITH_A_LONG_NAME().a_function_with_a_long_name()
"""

B = """
class A:
    def a(self):
        return 1

A().a()
"""

print(timeit.timeit(stmt = A, number = 1000000))
print(timeit.timeit(stmt = B, number = 1000000))

Получаем цифры:

• Long = 12.362802280999858
• Short = 11.445085418999952

Что примерно на 8% отличается.

Запуск внутри модуля (number = 100000000) вместо использования timeit:

• Long = 24.87908697128296
• Short = 24.695187091827393

Что примерно на 1% отличается.

Я бы пришел к выводу, что может быть разница с встроенным кодом или сложностями профилировщика timeit (timeit, кажется, примерно на 50 раз медленнее), но Cpython, похоже, делает хорошую работу по оптимизации любых различий. Я не могу сказать, будет ли это справедливо для класса с большим количеством членов, поскольку dict будет иметь больше кодов.