Дилемма с переменными

Так вот, вопрос: с точки зрения производительности

Производительности не хватает? Замерял разницу?

Делать локальными. Зачем их делать глобальными?

Можно, конечно. Но мне проще у вас спросить, чем что-то тестить.

Хотя ладно, щас отпишусь

С какой стати локальные переменные медленнее?

Я просто уверен что ты на пустом месте суетишься.

Расскажи нам, как у тебя появился класс с глобальными переменными.

Смысл класса с кучей глобальных переменных? Вот есть у тебя класс, окей, теперь ты хочешь увеличить производительность, сделав их глобальными, но что изменится-то? Логика вся - в классе, все вычисления в методах у тебя и узкое место(если оно вообще есть) - именно там.

Но и не забывай главное правило - преждевременные оптимизации - это зло.

с точки зрения производительности, имеет смысл делать все эти переменные локальными или оставлять их глобальными

Это всё экономия на спичках, делай как удобнее.

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

kramh: память бывает автоматическая, динамическая, статическая локальная, статическая глобальная.
Что из этого ты имеешь ввиду под «локальными»?

Я провел 2 немного разных теста для большей объективности, в обоих случаях вычисления non self оказывались в 3-3.5 раза быстрее, чем с self.

from datetime import *

class Name(object): 
    def __init__(self):
        self.NonSelf()
        self.Self()
    
        time_dfr_non_self = self.non_self_2 - self.non_self_1
        print('NonSelf: ', time_dfr_non_self)
        
        time_dfr_self = self.self_2 - self.self_1
        print('Self: ', time_dfr_self)
    
    def NonSelf(self):
        a = 0
        b = 1
        self.non_self_1 = datetime.now()
        while a != 100000000:
            a = a + b
        if a == 100000000:
            self.non_self_2 = datetime.now()

    
    def Self(self):
        self.a = 0
        self.b = 1
        self.self_1 = datetime.now()
        while self.a != 100000000:
            self.a = self.a + self.b
        if self.a == 100000000:
            self.self_2 = datetime.now() 

Name()
______
Output:

NonSelf:  0:00:06.368238
Self:  0:00:20.357640

Да, думаю, не на пустом. Если учиться оптимизировать код, то с самого начала, ибо потом переучиваться и/или исправлять свои говнопроекты будет геморно, особенно если ты работаешь над чем-то серьезным.

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

Если учиться оптимизировать код, то с самого начала, ибо потом переучиваться и/или исправлять свои говнопроекты будет геморно, особенно если ты работаешь над чем-то серьезным.

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

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

NonSelf: 0:00:06.368238
Self: 0:00:20.357640

Ha-ha. В этом весь питон.

В твоем случае я бы сделал функцию вычислений, тебе вроде объекты не нужны. Питон, в конце концов, и процедурный язык тоже.

Нужны питон и производительность → запускай много процессов.

Твой «nonSelf» держит переменные в locals(), там же где переменную «self», потому и быстрее.

 Нужны питон и производительность → запускай много процессов.

Не совсем понимаю, что ты имеешь ввиду под множеством процессов. Можно по подробнее?

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

Use NumPy, Luke!

Наверное, разница в этом:

doSomething(someVariable);
doSomething(self->someVariable);

Обращение через точку это dictionary lookup, и естественно это медленно. Пистон не годится для числодробилок.

Напиши модуль на Си.

Как вы уже надоели!

Дилема | Лемма

Сишные вставки будут значительно уступать по производительности чистому сикоду?

множеством процессов. Можно по подробнее

Питонская программа работает медленно - слишком много накладных расходов. И разогнать его трудно. В общем случае, добиваться достаточной производительности стоит методами в порядке уменьшения потенциального выигрыша: 1. замена алгоритма менее ресурсоёмким, 2. параллельный запуск нескольких экземпляров программ с мелкими кусками задачи, 3. устранение накладных расходов за счёт переписывание на непитонах,... то, о чём ты спрашивал, где-то во втором десятке, т.е. вообще не стоит рассмотрения.

в чем разница-то

google python namespaces

Чегойто вдруг? Оно компилится так же как и обычно.

Как я уже писал, это увеличивает производительность в 3-3.5 раз. Так что я сомневаюсь, что это стоит игнорировать

Думаю, в самом лучшем раслкладке производительность процентов на >50 будет страдать.

с точки зрения производительности
питон

ну ты понял, да.

добавь рутнон в теги, чудила.