Куча говна / Говнокод #27166 Ссылка на оригинал

0

  1. 1
IT Оффтоп #75

#46: (vanished) https://govnokod.xyz/_26654
#47: https://govnokod.ru/26671 https://govnokod.xyz/_26671
#48: https://govnokod.ru/26707 https://govnokod.xyz/_26707
#49: https://govnokod.ru/26750 https://govnokod.xyz/_26750
#49: https://govnokod.ru/26776 https://govnokod.xyz/_26776
#50: https://govnokod.ru/26804 https://govnokod.xyz/_26804
#51: https://govnokod.ru/26809 https://govnokod.xyz/_26809
#52: https://govnokod.ru/26817 https://govnokod.xyz/_26817
#53: https://govnokod.ru/26833 https://govnokod.xyz/_26833
#54: https://govnokod.ru/26840 https://govnokod.xyz/_26840
#55: https://govnokod.ru/26844 https://govnokod.xyz/_26844
#56: https://govnokod.ru/26862 https://govnokod.xyz/_26862
#57: https://govnokod.ru/26890 https://govnokod.xyz/_26890
#58: https://govnokod.ru/26916 https://govnokod.xyz/_26916
#59: https://govnokod.ru/26934 https://govnokod.xyz/_26934
#60: https://govnokod.ru/26949 https://govnokod.xyz/_26949
#61: https://govnokod.ru/26980 https://govnokod.xyz/_26980
#62: https://govnokod.ru/26999 https://govnokod.xyz/_26999
#63: https://govnokod.ru/27004 https://govnokod.xyz/_27004
#64: https://govnokod.ru/27020 https://govnokod.xyz/_27020
#65: https://govnokod.ru/27027 https://govnokod.xyz/_27027
#66: https://govnokod.ru/27040 https://govnokod.xyz/_27040
#67: https://govnokod.ru/27049 https://govnokod.xyz/_27049
#68: https://govnokod.ru/27061 https://govnokod.xyz/_27061
#69: https://govnokod.ru/27071 https://govnokod.xyz/_27071
#70: https://govnokod.ru/27097 https://govnokod.xyz/_27097
#71: https://govnokod.ru/27115 https://govnokod.xyz/_27115
#72: https://govnokod.ru/27120 https://govnokod.xyz/_27120
#73: https://govnokod.ru/27136 https://govnokod.xyz/_27136
#74: https://govnokod.ru/27160 https://govnokod.xyz/_27160

Запостил: nepeKamHblu_nemyx nepeKamHblu_nemyx, (Updated )

Комментарии (537) RSS

  • Добрый вечер.

    Этот оффтоп сгенерирован автоматически.

    Индекс оффтопов: https://index.gcode.space/.
    Зеркала Говнокода и полезные ресурсы:
    * https://govnokod.xyz/ (альтернативный Говнокод)
    * https://gcode.space/ (read-only зеркало Говнокода)
    * https://t.me/GovnokodBot (Говнокод-бот в «Telegram»)
    * https://t.me/GovnokodChannel (Тематический канал в «Telegram»)
    * https://vorec.space/ (глоссарий Говнокода)
    * https://app.element.io/#/room/#govnokod:matrix.org (резервный чат)
    Ответить
    • Привет, nepeKamHblu_nemyx! Как жизнь, как себя чувствуешь?
      Ответить
      • Одиноко ли перекатному петуху? Есть ли у него nepeKamHa9l_Kypo4Ka?
        Ответить
        • Снятся ли перекатным петухам электрокуры?
          Ответить
          • Послушайте!
            Ведь, если делают перекаты —
            ‎    значит — это кому-нибудь нужно?
            Значит — кто-то хочет, чтобы они были?
            Значит — кто-то называет эти говнокоды
                                              ‎жемчужиной?
            Ответить
            • Все перекаты, да перекаты -
              Послать бы их по адресу!
              На это место уж нету карты -
              Плывем вперед по абрису.
              Ответить
              • Молчит он. Не хрукнул. Видать, несоответствие типов...

                Для того, чтобы петушок хрукнул,нужно было сперва перекастовать его в поросёнка
                Ответить
  • питон неюзабельное говнище, придуманное наркоманами

    Попробуйте мне поймать эксепшен, и вывести строку, на которой он был кинут по трейсу вместе со стектом
    Ответить
    • def g():
          raise ValueError
      
      
      def f():
          g()
      
      
      def main():
          try:
              f()
          except ValueError as e:
              tb = e.__traceback__
              while tb.tb_next is not None:
                  tb = tb.tb_next
              print(f'Filename: {tb.tb_frame.f_code.co_filename}; line number: {tb.tb_frame.f_lineno}')
      
      
      if __name__ == '__main__':
          main()

      А что, собственно говоря, неюзабельное? Нейминг, конечно, наркоманский, да и документация печалит, но совсем уж упоротых подходов я тут не вижу.
      Ответить
      • Упопрость заключается в том, что самый первый __traceback__ будет указывать на строку, в которой ты поймал исключение.

        А, стоп. Ввыведи мне весь трейс-то, чтобы там были main() -> f -> g -> Exception
        Ответить
        • > в том, что самый первый __traceback__ будет указывать на строку, в которой ты поймал исключение.
          Фрейм в нём будет указывать на строку, в которой ты к нему обращаешься. Но, повторюсь, что здесь не так? Что стек в другую сторону растёт?

          > Ввыведи мне весь трейс-то
          Ну print в цикл перемести. Это обычный обход односвязного списка, это не питонья магия.
          except ValueError as e:
              tb = e.__traceback__
              while tb is not None:
                  print(f'Filename: {tb.tb_frame.f_code.co_filename}; function name: '
                        f'{tb.tb_frame.f_code.co_name}; line number: {tb.tb_frame.f_lineno}')
                  tb = tb.tb_next
          Ответить
          • >Фрейм в нём будет указывать на строку, в которой ты к нему обращаешься.

            зачем он будет показывать туда у пойманного исключения? Ислючение должно иметь трейс того места, откуда его кинули, нет?
            Ответить
            • Потому что это конец трейса. Можно ещё строку брать не из фрейма, а из трейсбека (tb.tb_lineno), тогда первой будет строка «f()».
              Ответить
              • трейса чего? зачем мне в исключении вообще строка ее поимки?
                Ответить
                • def g():
                      raise ValueError  # <--------------- 2
                  
                  def f():
                      try:
                          g()  # <--------------- 7
                      except ValueError as e:
                          print('f() try')
                          raise KeyError().with_traceback(e.__traceback__)  # <--------------- 10
                  
                  
                  def main():
                      try:
                          f()  # <--------------- 15
                      except KeyError as e:
                          tb = e.__traceback__
                          while tb is not None:
                              print(tb.tb_frame.f_code.co_filename, tb.tb_frame.f_code.co_name, tb.tb_lineno)
                              tb = tb.tb_next
                  
                  
                  if __name__ == '__main__':
                      main()

                  $ python C:\...\exc_test.py
                  f() try
                  C:\...\exc_test.py main 15
                  C:\...\exc_test.py f 10
                  C:\...\exc_test.py f 7
                  C:\...\exc_test.py g 2

                  Что тут неясного?
                  Ответить
      • или вот еще задачка:
        Я заманкипатчил системную функцию, чтобы поймать ее исключение, и что-то с ним сделать.
        Вопрос: как мне кинуть исключение так, чтобы там в стеке меня не было?
        #
        def some_sys_func():
            raise AssertionError()
        
        
        real = some_sys_func
        
        
        def patched():
            try:
                real()
            except AssertionError as err:
                raise
        
        
        some_sys_func = patched
        
        some_sys_func()


        вероятно, можно дактайпнуть traceback, попррбую.

        Как вообще собрать вручную эксепшен с нужным трейсом? трейсбек вручную не сделать, а при кидании исключения туда всегда насирается текущая строка
        Ответить
        • > там в стеке меня не было

          А нефиг наёбывать систему. Юзай chaining, выведутся оба трейса -- твой и оригинальный.
          Ответить
          • >А нефиг наёбывать систему.
            охуительная логика.

            "всё ненужно, что сломлось
            всё ненужно, чего нет"
            Ответить
            • Я как бы не против фишек, которые облегчают жизнь...

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

              А редактирование бектрейса не просто не нужно... оно опасно, вредно и вообще по-пидорски.
              Ответить
            • Хорошо: дать юзеру возможность осознанно скрыть часть сообщений, примерно как с уровнями логирования. При этом юзер должен понимать, что часть сообщений скрыта. Т.е., к примеру, в гуйне должна быть кнопочка "показать всё что скрыто", а в сосноли что-то в духе "включите -v чтобы увидеть трейс целиком".

              Хуёво: необратимо испортить бектрейс и дать юзеру возможность поебаться с отладчиком.

              Теперь моя логика понятна, я надеюсь?
              Ответить
              • поебаться с отладчиком - бесценно. И пусть весь мир подож... уйдет бля от меня не трогайте я занят.
                Ответить
              • > Хорошо: дать юзеру возможность осознанно скрыть часть сообщений, примерно как с уровнями логирования. При этом юзер должен понимать, что часть сообщений скрыта. Т.е., к примеру, в гуйне должна быть кнопочка "показать всё что скрыто", а в сосноли что-то в духе "включите -v чтобы увидеть трейс целиком".

                Я компилирую в emacs буффер, делаю на нём `M-x occur' и теку.
                Ответить
        • К слову, с raise без параметров он оригинальный трейс и показывает. Как и в джавке вроде.
          Ответить
        • > Я заманкипатчил системную функцию
          Сам себе злобный Буратино, дальнейшие претензии к «Питону» полностью бессмысленны.

          > Вопрос: как мне кинуть исключение так, чтобы там в стеке меня не было?
          Зачем ты хочешь наебать читающего твои логи? Это очень хуёвая практика, плохой Макака!

          > Как вообще собрать вручную эксепшен с нужным трейсом?
          Это уже вообще какая-то наркомания. Приведи реальный пример задачи, которая требует исключения с вручную собранным трейсом.

          К слову, если f() из моего примера заменить на:
          def f():
              try:
                  g()
              except:
                  print('f() try')
                  raise

          То итоговый трейс будет полностью правильным:
          $ python C:\...\exc_test.py
          f() try
          Filename: C:\...\exc_test.py; function name: main; line number: 19
          Filename: C:\...\exc_test.py; function name: f; line number: 10
          Filename: C:\...\exc_test.py; function name: g; line number: 2


          Правда, я душе не ебу, зачем нужно это делать вручную, когда есть вменяемый logging.exception() или, на худой конец, стандартный мудуль traceback с нормальными, высокоуровневыми абсракциями вроде print_traceback().
          Ответить
          • P. S. Можно ещё проще (если всё же нужно вручную):
            import traceback
            
            
            def g():
                raise ValueError
            
            
            def f():
                try:
                    g()
                except:
                    print('f() try')
                    raise
            
            
            def main():
                try:
                    f()
                except ValueError as e:
                    for frame, line_no in traceback.walk_tb(e.__traceback__):
                        print(frame.f_code.co_filename, line_no)

            Выведет строки с вызовами f() -> g() -> raise.
            Ответить
          • Вот тебе реальный пример: есть функция из стандартной библиотеки. Мне нужно ее манкипатчнуть, вызвать оригинальную (она кидает исключение), поймать исключение, добавить в него кое-какую информацию (или заменить на наследника), и кинуть дальше

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

            Сделать это в питоне невозможно, потому что если я не сделаю raise без параметров (А кину что-то свое) то стек будет неверным

            А собрать исключение вручную с верным стектом я тоже не могу
            Ответить
            • > Мне нужно ее манкипатчнуть
              Ты же понимаешь, что манкипатчинг функций из стандартной библиотеки — это пиздецки адовый костыль, и что делать так — очень хуёво само по себе?

              > Сделать это в питоне невозможно
              RTFM.
              def f():
                  try:
                      g()
                  except ValueError as e:
                      print('f() try')
                      raise KeyError().with_traceback(e.__traceback__)

              $ python C:\...\exc_test.py
              f() try
              Filename: C:\...\exc_test.py; function name: main; line number: 18
              Filename: C:\...\exc_test.py; function name: f; line number: 13  # raise KeyError
              Filename: C:\...\exc_test.py; function name: f; line number: 10  # g()
              Filename: C:\...\exc_test.py; function name: g; line number: 5
              Ответить
              • >RTFM
                лол, ну ты же сам выделил зелененьким 13-ю и 10-ю строки, а нужно, чтобы выброшенное из "g" исключение только его трейс и содержало.

                > это пиздецки адовый костыль
                да, но у меня нет выбора.

                на самом деле я решил уже проблему тем, что поклал нужную инфу в thread local storage, и сделал raise без параметров, убрав таким образом следы своего пребывания, но сам факт того, что я не могу сделать это в динамической скриптушне без костыля это же пиздец
                Ответить
                • > только его трейс и содержало
                  Ещё раз: это наёб того, кто будет читать трейс. Именно ты хочешь сделать пиздец, выдав ловящему исключение некорректный стектрейс.
                  Ответить
                  • Угу, только коммента в духе "удачной отладки, пидоры" не хватает. Сам же потом забудет, что функция замакачена.
                    Ответить
                  • я видимо не очень смог донести мысль, давай попробую снова.

                    Запусти вот такое говно с помощью pytest.
                    Ты увидишь красивое сообщение об ошибке.

                    Теперь раскоментируй строчку с манкипачтем.

                    Казалось бы: я делаю with_traceback, и разницы быть не должно. но она есть.

                    from unittest import TestCase
                    
                    
                    class MyError(AssertionError):
                        pass
                    
                    real_fun = TestCase.assertEqual
                    def custom_assert_eq(*args, **kwargs):
                        try:
                            real_fun(*args, **kwargs)
                        except AssertionError as e:
                            raise MyError().with_traceback(e)
                    # TestCase.assertEqual =custom_assert_eq
                    
                    
                    class MyTest(TestCase):
                        def test_test(self):
                            self.assertEqual(1, 2)


                    >некорректный
                    ну как и было написано выше "всё не нужно, что сломалось"
                    Ответить
                    • Ну да, манкипатчишь системные функции — получаешь полный набор граблей, на которые можно наступить. ССЗБ.

                      Фиксим:
                      from unittest import TestCase
                      
                      
                      class MyError(AssertionError):
                          pass
                      
                      real_fun = TestCase.assertEqual
                      def custom_assert_eq(*args, **kwargs):
                          try:
                              real_fun(*args, **kwargs)
                          except AssertionError as e:
                              raise MyError().with_traceback(e.__traceback__)
                      TestCase.assertEqual =custom_assert_eq
                      
                      
                      class MyTest(TestCase):
                          def test_test(self):
                              self.assertEqual(1, 2)


                      Получаем хорошее, годное сообщение об ошибке:
                      ==================================================================== FAILURES =====================================================================
                      ________________________________________________________________ MyTest.test_test _________________________________________________________________
                      
                      self = <exc_test.MyTest testMethod=test_test>
                      
                          def test_test(self):
                      >       self.assertEqual(1, 2)
                      
                      exc_test.py:18:
                      _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ exc_test.py:12: in custom_assert_eq
                          raise MyError().with_traceback(e.__traceback__)
                      exc_test.py:10: in custom_assert_eq
                          real_fun(*args, **kwargs)
                      E   exc_test.MyError

                      Всё замечательно работает.
                      Ответить
                      • > raise MyError().with_traceback(e.__traceback__ )
                        > real_fun(*args, **kwargs)
                        да где оно годное то?

                        в стеке все равно ненужное говно же
                        Ответить
                        • В нём видно и оригинальное исключение и твоё. Т.е. трейс честный и полноценный.

                          Кого ты наебать пытаешься то, заметая свои следы?
                          Ответить
                          • там еще и
                            During handling of the above exception, another exception occurred написано

                            пиздец) я вам говорю: "вот нерешаемая задача в питоне", а вы меня спрашиваете, кого я хочу наебать))
                            Ответить
                            • > нерешаемая задача

                              Я не вижу смысла в обмане самого себя и своих коллег. Сейчас у тебя честный трейс, в котором видно, что assertEquals заменён на какую-то хуйню. Коллеги тебе за это спасибо скажут, если в твоей заплатке какой-то косяк.

                              > и все равно получил бы
                              > During handling of the above exception, another exception occurred же

                              Ты хочешь сказать, что это не так? Что ты не кидал исключение во время обработки другого? )))
                              Ответить
                              • Я не могу изменять клиента, вот пайтест отличный пример: я не могу его изменять. А передать какую-то информацию (например, его плагину) я могу хотеть.

                                Рассуждать о смысле, имхо, вообще странно. Программисты на го не видят смысла в обобщенном программировании. Это же все субъективно


                                >Ты хочешь сказать, что это не так?
                                я хочу сказать, что клиенту про это знать не нужно

                                вон, пайтест сломался от этого, и высрал тонну говна
                                Ответить
                                • > сломался от этого

                                  Где он сломался то? Сообщение о фейле теста есть, в статистику фейл засчитался. Формат сообщения не изменился. Ну трейс чуть длиннее стал.

                                  У тебя какая-нибудь гуйня что ли не может это показать?
                                  Ответить
                                  • в аутпуте куча мусора и кусок левого кода

                                    сравни аутпут с патчинком и без: там просто три страницы говнища

                                    вот тебе дифф.
                                    https://pastebin.com/tapbVcFd
                                    Ответить
                                    • > и кусок левого кода

                                      Дык... Этот левый код реально исполнялся во время теста. И в нём потенциально может быть баг. Почему его не должно быть в трейсе? Сам же потом спасибо скажешь, что трейс честный и полный.
                                      Ответить
                                      • потому что когда я пишу with_traceback(e.__traceback__) я прошу скопировать оттуда трейс, нет?
                                        Ответить
                                        • > нет

                                          Нет. Добавить его к текущему, насколько я помню.
                                          Ответить
                                            • Да, доки питона такие доки питона...

                                              Оно таки sets (т.е. вписывает в соотв. поле исключения этот бектрейс, можешь проверить), но потом raise туда ещё текущий трейс дописывает.
                                              Ответить
                                    • > в аутпуте куча мусора и кусок левого кода

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

                                        Хотя впадать в другую крайность: логгировать каждый чих и получать сотни гигабайт логов тоже не кошерно.

                                        Так же бывают ситуации предусмотренных логикой кода исключений, для которых трейсы можно не логгировать. Например мы хотим отдать посредством исключения какой-то http-код.
                                        Ответить
                                    • > кусок левого кода
                                      Да, а потом в этом куске левого кода ты допускаешь мелкую ошибку, которая через год начинает выкидывать GovnoError… И какой-то несчастный программист будет неделю ебаться, пытаясь понять, почему TestCase.assertEqual() бросает непредусмотренное документацией говно при совершенно корректном тесте.
                                      За такое надо шею жать.
                                      Ответить
                            • Ну да, а ещё в «Питоне» нельзя (как в ЙАЖЕ) заманкипатчить числа, чтобы «2 * 2» возвращало «6». Вот ведь говно неюзабельное, придуманное наркоманами, а!
                              Ответить
                              • А ещё нельзя насрать в память и запороть стек, как в сишке (хотя можно, ctypes умеет).
                                Ответить
                              • итого:

                                * сделать исключение с кастомным трейсом нельзя: в нем все равно будут твои следы
                                * но вы считаете, что это и не надо

                                так?
                                Ответить
                                • Нельзя. И слава богу.

                                  Любители "исправленных" трейсов потом в аду битые сишные дампы читают.
                                  Ответить
                                  • >Нельзя. И слава богу.
                                    понятно, в общем.

                                    Я такое регулярно слышу.

                                    --В вашем языке нельзя $FOO
                                    --Нельзя. И слава богу.
                                    Ответить
                                    • Я не любитель питона, но править стек - это говно.

                                      Единственное, когда подобное может пригодиться - это когда ты делаешь ВМ, и там надо печатать исключения в терминах ВМ. Но там достаточно просто использовать MyException, которое не будет исключением с точки зрения языка реализации, его нельзя будет бросить в исходниках, это объект на уровне абстракции ВМ.

                                      Программисты (особенно - после времён, когда не было структурного программирования, и программа сразу записывалась целиком, и можно было грепнуть и понять) придумали 1000 и 1 способ испоганить понимание кода -
                                      1. Складирование значений в переменных.
                                      2. Использование функций.
                                      3. Рекурсия.
                                      4. Динамический полиморфизм.
                                      Единственная возможность понять, что происходит - посмотреть, что произошло в отладчике и посмотреть стектрейс. Потому, что по коду (особенно - с динамическим полипитухом) нельзя понять, что делает программа.

                                      И ваша секта хочет убить эту возможность разобраться, что произошло, когда программа сломалась.
                                      Ответить
                                    • Короче, смотри, как манкипатчат настоящие макаки:
                                      from unittest import TestCase
                                      
                                      
                                      class MyError(AssertionError):
                                          pass
                                      
                                      def real_fun(*args, **kwargs):
                                          pass
                                      
                                      real_fun.__code__ = TestCase.assertEqual.__code__.replace()
                                      real_fun.__name__ = TestCase.assertEqual.__name__
                                      real_fun.__defaults__ = TestCase.assertEqual.__defaults__
                                      
                                      def custom_assert_eq(*args, **kwargs):
                                          try:
                                              real_fun(*args, **kwargs)
                                          except AssertionError as e:
                                              raise MyError(*e.args) from None
                                      
                                      TestCase.assertEqual.__globals__['real_fun'] = real_fun
                                      TestCase.assertEqual.__globals__['MyError'] = MyError
                                      original_names = set(('co_name', 'co_filename', 'co_firstlineno'))
                                      TestCase.assertEqual.__code__ = custom_assert_eq.__code__.replace(
                                          **{k: getattr(TestCase.assertEqual.__code__, k) for k in original_names}
                                      )
                                      
                                      
                                      class MyTest(TestCase):
                                          def test_test(self):
                                              self.assertEqual(1, 2)

                                      Вывод pytest:
                                      self = <exc_test.MyTest testMethod=test_test>
                                      
                                          def test_test(self):
                                      >       self.assertEqual(1, 2)
                                      E       exc_test.MyError: 1 != 2
                                      
                                      exc_test.py:30: MyError
                                      ============================================================================== short test summary info ==============================================================================
                                      
                                      FAILED exc_test.py::MyTest::test_test - exc_test.MyError: 1 != 2


                                      Когда коллеги тебя будут убивать за это — на ГК помощи не проси.
                                      Ответить
                                      • И смотри ещё какой божественный стектрейс, если test_test() вызвать напрямую:
                                        Traceback (most recent call last):
                                          File "exc_test.py", line 34, in <module>
                                            test.test_test()
                                          File "exc_test.py", line 30, in test_test
                                            self.assertEqual(1, 2)
                                          File "C:\Program Files\Python38\lib\unittest\case.py", line 911, in assertEqual
                                            assertion_func = self._getAssertEqualityFunc(first, second)
                                        __main__.MyError: 1 != 2


                                        Просто конфетка! Идеальное преступление. Коллеги в обе щёки расцелуют.
                                        Ответить
                                        • Кстати, интересно как unittest скрывает кусок бектрейса. Просто скипает свой фрейм при выводе?
                                          Ответить
                                          • _code/code.py:
                                            def filter_traceback(entry: TracebackEntry) -> bool:
                                                """Return True if a TracebackEntry instance should be removed from tracebacks:
                                                * dynamically generated code (no code to show up for it);
                                                * internal traceback from pytest or its internal libraries, py and pluggy.
                                                """
                                                # entry.path might sometimes return a str object when the entry
                                                # points to dynamically generated code
                                                # see https://bitbucket.org/pytest-dev/py/issues/71
                                                raw_filename = entry.frame.code.raw.co_filename
                                                is_generated = "<" in raw_filename and ">" in raw_filename
                                                if is_generated:
                                                    return False
                                                # entry.path might point to a non-existing file, in which case it will
                                                # also return a str object. see #1133
                                                p = py.path.local(entry.path)
                                                return (
                                                    not p.relto(_PLUGGY_DIR) and not p.relto(_PYTEST_DIR) and not p.relto(_PY_DIR)
                                                )
                                            Ответить
                                          • Ну и потом в python.py ещё хуйня унылая:
                                            def _prunetraceback(self, excinfo: ExceptionInfo) -> None:
                                                    if hasattr(self, "_obj") and not self.config.getoption("fulltrace", False):
                                                        code = _pytest._code.Code(get_real_func(self.obj))
                                                        path, firstlineno = code.path, code.firstlineno
                                                        traceback = excinfo.traceback
                                                        ntraceback = traceback.cut(path=path, firstlineno=firstlineno)
                                                        if ntraceback == traceback:
                                                            ntraceback = ntraceback.cut(path=path)
                                                            if ntraceback == traceback:
                                                                ntraceback = ntraceback.filter(filter_traceback)
                                                                if not ntraceback:
                                                                    ntraceback = traceback
                                            
                                                        excinfo.traceback = ntraceback.filter()
                                                        # issue364: mark all but first and last frames to
                                                        # only show a single-line message for each frame
                                                        if self.config.getoption("tbstyle", "auto") == "auto":
                                                            if len(excinfo.traceback) > 2:
                                                                for entry in excinfo.traceback[1:-1]:
                                                                    entry.set_repr_style("short")
                                            Ответить
                                            • Хм, у вас какой-то другой юниттест?

                                              Я вот не вижу 3 страницы говна с кусками функций, которые на пастбине макаки. Просто FAIL и компактный бектрейс.

                                              А в исходниках нашёл. Оно тупо скипает фреймы в начале (код, который запускает тест) и в конце трейса (кишки ассёртов), если они относятся к самому модулю unittest.

                                              Причём делает это... по наличию глобалки __unittest. И если макакопатчить в модуле с глобалкой __unittest, то он волшебным образом пропадает из трейса.

                                              Какой бектрейс )))
                                              Ответить
                                              • А, да, MAKAKA же тесты запускает через pytest — я из него привёл пример. Он же там красивые трейсы с кодом рисует, даже подсветка есть.
                                                Ответить
                                                • Блядь, какое же багорище... Я в начале monkey.py написал __unittest = True и теперь трейсы от перехвата больше не выводятся. Только сам вызов assertEqual в тесте видно.
                                                  Ответить
                                                • З.Ы. А вот с рутестом походу эта фишка не катит, он по путям проверяет если верить твоему коду.
                                                  Ответить
                                            • Какое же питон говнище. Вместо pituh.grebeshok нужно писать hasattr(pituh, "grebeshok"), бесит.
                                              Еще эти ебаные двойные подчеркивания.
                                              Ответить
                                              • > Вместо pituh.grebeshok
                                                Особенно хорошо это работает, когда grebeshok имеет тип bool.

                                                В этом году, кстати, на ГК обсирали одного жаваскриптуха, который писал кэширование чистых функций, и наличие аргумента в кэше проверял как «if (cache[arg])». Надо ли говорить, как прекрасно эта хуйня работала с функциями, возвращающими false, null, undefined, 0 или ''?
                                                Ответить
                                                • Это проблема джаваскриптуха.
                                                  Ответить
                                                • [сделали бы отдельный оператор, например pituh$grebeshok
                                                  Ответить
                                              • Во, нашёл: https://govnokod.ru/26691#comment549591.
                                                >>> 5 интересных JavaScript-находок, сделанных в исходном коде Vue
                                                >>>
                                                function cached(fn){
                                                  // Создаём объект для хранения результатов, возвращаемых целевой функцией после её выполнения
                                                  const cache = Object.create(null);
                                                
                                                  // Возвращаем целевую функцию в соответствующей обёртке
                                                  return function cachedFn (str) {
                                                
                                                    // Если в кеше нет подходящих результатов - функция будет выполнена
                                                    if ( !cache[str] ) {
                                                        let result = fn(str);
                                                
                                                        // Сохраняем результат выполнения функции в кеше
                                                        cache[str] = result;
                                                    }
                                                
                                                    return cache[str]
                                                  }
                                                }
                                                Ответить
                                                • > как прекрасно эта хуйня работала с функциями, возвращающими false, null, undefined, 0 или ''
                                                  > в исходном коде Vue
                                                  Ну это же внутренняя питушня для конкретных случаев? Покрытие всех случаев сделало бы нечитаемый код и превратило бы Vue в анскильную тормозящую питушню. Есть же баланс между абстрактной теоретической всеприменимостью и здравым смыслом!
                                                  А если наружная питушня, то он, вероятно, написал в документации, как её использовать.

                                                  > false, null, undefined, 0 или ''
                                                  Как прекрасно эта хуйня работала с x={pitux: f=>x} (контейнер, содержащий в себе функцию, которая содержит этот контейнер в своём замыкании).

                                                  > возвращающими false, null, undefined, 0 или ''
                                                  Принимающими false, null, undefined, 0 или ''.

                                                  P.S. Нет, это не я писал эту функцию. Но это питушня для пирфоманса, не надо к ней строго относиться. Если сериализация аргумента делается дольше вызова функции, мемоизация становится не нужна.
                                                  Ответить
                                                  • > покрытие всех случаев сделало бы нечитаемый код

                                                    Да, if (str in cache) читается намного хуже, чем if (!cache[str]).

                                                    > превратило бы в анскилльную тормозящую питушню

                                                    Ну тут согласен, я не знаю как в js сделать проверку на существование ключа без оверхеда... Итераторы то не завезли.

                                                    Но блин, в оригинальном коде то тоже джва обращения!

                                                    З.Ы. Лол, пишут что in на порядки медленнее обращения со скобочками... Какой багор )))
                                                    Ответить
                                                    • > как в js сделать проверку на существование ключа без оверхеда... Итераторы то не завезли.
                                                      Одна надежда на жит.

                                                      > З.Ы. Лол, пишут что in на порядки медленнее обращения со скобочками... Какой багор )))
                                                      Как? Как, Карл? Если размышлять логически, алгоритм внутри in должен быть частью исходного кода алгоритма []. Или это так дорого конструировать true/false? Какой анскилл.
                                                      Хотя, дяденька ПИ скажет, что это всё питушня и измерение производительности конкретного интерпретатора, в другой версии баланс сил сместится.
                                                      Ответить
                                                      • Я не знаю, вполне возможно, что хреново бенчили.
                                                        Ответить
                                                        • Проверил на https://jsbench.me, особой разницы не обнаружил: https://i.imgur.com/AnTpVLl.png (даже наоборот, «in» оказался на 15% быстрее скобочек). Впрочем, возможно, это так из-за распределения совпадений/несовпадений, надо бы рандому добавить…

                                                          Прикладываю исходники для повторимости, пидоры не хотят без регистрации сохранять:
                                                          // setup
                                                          let obj = {};
                                                          for (let i = 0; i < 1000000; i++) {
                                                          	obj[i] = i * 100500;
                                                          }
                                                          
                                                          // brackets
                                                          let res = {};
                                                          for (let i = 500000; i < 1500000; i++) {
                                                          	if (obj[i]) {
                                                          		res[i] = true;
                                                          	}
                                                          }
                                                          
                                                          // in
                                                          let res = {};
                                                          for (let i = 500000; i < 1500000; i++) {
                                                          	if (i in obj) {
                                                          		res[i] = true;
                                                          	}
                                                          }
                                                          
                                                          // hasOwnProperty
                                                          let res = {};
                                                          for (let i = 500000; i < 1500000; i++) {
                                                          	if (obj.hasOwnProperty(i)) {
                                                          		res[i] = true;
                                                          	}
                                                          }
                                                          Ответить
                                                          • > даже наоборот, «in» оказался на 15% быстрее скобочек
                                                            Звучит логично.

                                                            > из-за распределения совпадений/несовпадений
                                                            Есть мысль, что там как-то могут влиять ещё протопитухи.

                                                            Кстати, пришла мысль: а что, если дело в крестухах/питоняшах, которые проверяли перед тем, как войти?
                                                            if (i in obj) { obj[i]; }
                                                            if (obj[i]) { obj[i]; }
                                                            if (obj[i] !== undefined) { obj[i]; }

                                                            Скажем, был тупой жид, который плохо соптимизировал первое, а на втором/третьем понял, что одно и то же написано?

                                                            if (i in obj && obj[i])
                                                            if (obj[i])

                                                            Или скажем сравнивали эти два варианта вообще?
                                                            Ответить
                                                            • > Скажем, был тупой жид, который плохо соптимизировал первое, а на втором/третьем понял, что одно и то же написано?
                                                              Да хуй знает, вполне мог. Я специально длительные циклы сделал, там по идее жид должен был сработать на первых сотнях итераций.

                                                              Кстати, лучше бы нахрюкнул про отсутствие в «Питоне» ЖИДа, это действительно печально. Йажасцриптовый ЖИД работает очень и очень круто (хотя отсутствие хвостовых оптимизаций — это таки анскилл).
                                                              Ответить
                                                              • > нахрюкнул про отсутствие в «Питоне» ЖИДа
                                                                Так я абстрактушок, пирфоманс-хеви питушнёй особо не занимаюсь, для моих задач интерпретатор питона не тормозил (максимум тормозил только сам код за счёт простого алгоритма с неудачной асимптотикой).
                                                                Ответить
                                                                • Не знаю, я в каком-то обсуждении на ГК замерял идентичные алгоритмы и очень впечатлился, когда «Йажасцрипт» от сишки отстал всего в несколько раз. Там, конечно, хардкорных векторных оптимизаций не было, но всё же. По сравнению с «Питоном», который на тех же размерах пыхтел чуть ли не десятки минут против секунд…
                                                                  Ответить
                                                      • >Хотя, дяденька ПИ скажет, что это всё питушня и измерение производительности конкретного интерпретатора, в другой версии баланс сил сместится

                                                        Это как раньше паттерн str.split('').reverse().join('') жутко тупил.

                                                        Но жс-макаки упорно продолжали писать.
                                                        В какой-то момент оказалось что проще допилить JITы, под этот конкретный идиоматчиный кейс.

                                                        В итоге оно стало работать быстро. В некоторых браузерах даже быстрее скучного for.

                                                        Но я за эстетику. Код с in очень красиво выглядит.
                                                        Ответить
                                                    • > З.Ы. Лол, пишут что in на порядки медленнее обращения со скобочками...
                                                      А как там с hasOwnProperty() обстоит вопрос?
                                                      Ответить
                                                    • > Лол, пишут что in на порядки медленнее обращения со скобочками...
                                                      По-моему из-за багров с обходов прототипов. Хотя странно.

                                                      Но тут-то как раз прототипного наследования нет!
                                                      > const cache = Object.create(null);

                                                      in только с nullовым прототипом и хорош.
                                                      Ответить
                                                      • Чтобы достать поле, нужно обойти прототипы.
                                                        Чтобы дать результат in, нужно обойти прототипы.
                                                        Ответить
                                              • Вот кстати да. Когда перехожу с ЖС на питон, сразу становится больно. Нет эквивалентности x['y'] и x.y, в ассоциативных массивах надо писать кавычки как в ЖСОНе ({"xxxx": "yyyy"} вместо {xxxx: "yyyy"}), нет значений по умолчанию (try: z = x['y']; except: pass или z = x.get('y') вместо z = x['y']), питушни с ".?" для доступа вглубь нет.
                                                Вроде скриптушня, а пердолиться надо как с крестами.
                                                Ответить
                                                • > Нет эквивалентности x['y'] и x.y
                                                  Потому что это ненужная и опасная хуйня, сто раз уже обсуждали.

                                                  > в ассоциативных массивах надо писать кавычки как в ЖСОНе
                                                  Потому что это тоже ненужная (хоть и не столь опасная) хуйня, в ЖСе работающая до крайности хуёво:
                                                  > const x = {xxx: 1, 42: 2};
                                                  > x['xxx']
                                                  < 1
                                                  > x[42]
                                                  < 2
                                                  > x['42']
                                                  < 2

                                                  Впрочем, если уж так хочется — в «Питоне» тоже можно не писать кавычки:
                                                  >>> x = dict(xxx='yyy')
                                                  >>> x['xxx']
                                                  'yyy'

                                                  И, заметь, никаких неоднозначностей или неявных преобразований. Заебись!

                                                  > нет значений по умолчанию
                                                  И слава Гвидо! Если мне нужны какие-то умолчания — я сам об этом напишу, а в общем случае отсутствие затребованного ключа — это ошибка в программе. Эйх же был не очень умным, и вменяемую обработку ошибок (хотя бы в виде исключений) запилить не осилил, а теперь толпы жаваскриптухов жрут undefined говно и просят добавки. Отвратительно.

                                                  > питушни с ".?"
                                                  Вот единственный нахрюк по делу! Тут поддержу: «.?» — хорошее, годное и, главное, явное решение, его отсутствие печалит.

                                                  Доброе утро, Uncaught SyntaxError: Invalid left-hand side expression in postfix operation.
                                                  Ответить
                                                  • А я плюсану 1024 по всем пунктам

                                                    >Потому что это ненужная и опасная хуйня, сто раз уже обсуждали.

                                                    Что опасного?
                                                    Зачем скриптушку писать foo['bar'] вместо foo.bar?
                                                    в Groovy, JS и LUA такой хуйни нет

                                                    >Потому что это тоже ненужная
                                                    зачем писать лишние кавчки? в перле вот не пишут для ключей (А так же в JS и lua), и ничего

                                                    >И слава Гвидо!
                                                    тебе нравится ловить исключение про отсутствие ключа или писать монструозный getattr?
                                                    Ответить
                                                    • Мне нравится, что я получаю исключение про отсутствие ключа если я накосячил. А если я ожидаю, что ключа может не быть -- я пишу d.get("key", "default") и теку.

                                                      Мне нравится, что по-умолчанию поля и скобочки не смешиваются. А если мне реально хочется скрестить структуру и дикт -- для этого есть namedtuple.

                                                      В js же я не могу явно выразить свои намерения, там всё выглядит одинаково.
                                                      Ответить
                                                      • А мне нравится, что код не компилируется если я накосячил.

                                                        Мне нравится, что массивы и листы не смешиваются, как в Java.

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

                                                          Но от скриптушни мне тоже хочется какой-то минимальной выразительности, а не typeof(x) == 'undefined'.
                                                          Ответить
                                                    • о чём вы спорите?

                                                      любая скриптушня это сорта говна
                                                      Ответить
                                                      • Это правда.

                                                        но если уж мы берем скриптушню чтобы легко и быстро накидать скриптец на 10 строк, то нафиг нам завозить туда сложности статически типизированных языков?
                                                        Ответить
                                                    • > Что опасного?
                                                      В «Питоне» я могу полностью безопасно сделать «obj = json.loads(user_input)» и потечь. В «ЙажаСцрипте», написав что-то подобное, я получу дырень, в лучшем случае просто поломающую дальнейший код, в худшем — какой-нибудь XSS.

                                                      > зачем писать лишние кавчки?
                                                      Затем, чтобы была консистентность и понятность. Когда я в «Питоне» вижу {x: y} — я сразу понимаю, что в качестве ключа я получаю значение x по тем же самым правилам, что и в любом другом месте языка: если это переменная — ключом будет значение переменной, если число — ключом будет число, если строка — ключом будет строка, и так далее. В сраном ЖСе я получаю хуй знает что, сделанное по хуй знает каким запутанным правилам (одно только преобразования ключей в строки чего стоит… пиздец полнейший). И это хуёво.

                                                      Про монструозный obj.get('key') bormand уже ответил.
                                                      Ответить
                                                      • всегда есть трейдофф между кол-вом букв и безопасностью.

                                                        В питоне целый модуль напилил ради json , а в JS оно из коробки.

                                                        В Java6 у меня куда больше консистенности и понятности, чем в питоне со всеми его getattr и getattribute, но мы же не говорим, что шестая джава лучше питона?

                                                        В 90% случаев мне удобнее написать foo.bar.buz (как я пишу например в щаблонах джанго) и не думать про какие-то кавычки

                                                        В JS правда много г-на с преобразованием, давайте сравним лучше с груви или lua
                                                        Ответить
                                                        • > всегда есть трейдофф между кол-вом букв и безопасностью.
                                                          Так вот в случае x['key'] == x.key он полностью проёбан. Поясню: в языках, поддерживающих такую хуйню по-умолчанию, нельзя класть в ассоциативные массивы ключи, пришедшие от пользователя. Это полнейший пиздец, на уровне «mysql_query("SELECT ... id = " + $_GET["id"])». Не понимаю, почему макаки от такого текут.

                                                          > В 90% случаев мне удобнее написать foo.bar.buz
                                                          Так сделай датакласс и потеки! Это ёбанных две строчки оверхеда.
                                                          Хранение данных в ассоциативных массивах без схемы — признак пиздеца в архитектуре. Ну или джаваскриптера.
                                                          Ответить
                                                          • > Это ёбанных две строчки оверхеда.
                                                            Иметь for x in range(10): или даже for x in 0..10: лучше, чем каждый раз писать двустрочные костыли в ES5.
                                                            Это же скриптушня, хочется выразительности в мелочах.
                                                            Ответить
                                                        • > В питоне целый модуль напилил ради json

                                                          Эм, лолшто. Он же изкоробки, как и в жс. Просто в жс модулей и неймспейсов не было, поэтому всё валили в глобальный скоп, лол.

                                                          > а в JS оно изкоробки

                                                          Ты про то, что json -- это валидный js? Ну да, странно было бы не иметь JavaScript Object Notation изкоробки в JavaScript.
                                                          Ответить
                                                      • > безопасно сделать «obj = json.loads(user_input)» и потечь. В «ЙажаСцрипте», написав что-то подобное, я получу дырень
                                                        Погодите, если делать JSON.parse, а не eval, то всё должно быть в порядке. В JSON нельзя пихать функции и самоссылки. Как ещё через JSON.parse можно что-то сломать?

                                                        А, ну разве что user_input = "{hasOwnProperty: 1}", и тогда user_input.hasOwnProperty('aaa') выбросит исключение, т.к. единицу нельзя вызвать, она не ответит. Но функцию свою подставить уже не получится, только число, строку, массив, объект или null.

                                                        Если есть схема уязвимости - сообщите, пожалуйста. Я только про eval слышал пока.
                                                        Ответить
                                                        • > то всё должно быть в порядке
                                                          За исключением того, что в дальнейшем весь код, использующий объект, может попросту сломаться. А чтобы не ломался — надо писать «Object.prototype.method(obj, args)» или как там правильно. Очень удобно!

                                                          Более сложные уязвимости, конечно, требуют более специфических вещей — ну там обхода проверки типов через obj.toString() и так далее.
                                                          Ответить
                                                  • > Если мне нужны какие-то умолчания — я сам об этом напишу, а в общем случае отсутствие затребованного ключа — это ошибка в программе.
                                                    Питно-сектанты!

                                                    Ладно ещё когда идёт речь об объектах - питухах, которые имеют заранее описанный интерфейс. Тогда может быть ненайденное поле или ненайденный метод - это баг.
                                                    Но если речь идёт о ключе ассоциативного массива, то почему? Я ищу питушню. Если нет - скажите мне об этом.

                                                    Хаскелешня возвращает Maybe, с которым ты пердолишься сам. Кресты позволяют как найти итератор, чтоб два раза не лукавпить, так и использовать скобочки, с которыми несуществующий ключ создаётся. Подход STL со скобочками - почти что скриптушковый, и никто не умер от него, и типизация не очень сильно сдулась.
                                                    Ответить
                                                    • > Я ищу питушню. Если нет - скажите мне об этом.
                                                      А «Йажасцрипт» тебе не говорит, что питушня не найдена, «Йажасцрипт» тебе просто возвращает какую-то хуйню. Была ли эта хуйня в объекте изначально, или «Йажасцрипт» эту хуйню выдумал — тебе неведомо. Это хуёвый подход.

                                                      > Кресты
                                                      Да-да, это одно из самых хуёвых и неудобных решений в интерфейсе местной std::map.
                                                      void f(const std::map<std::string, Petuh> & petuhis) {
                                                          auto petya = petuhis["Petya"];  // Пошёл нахуй!
                                                      }
                                                      Ответить
                                                      • Ох да, бесит. Почему они не могут добавить operator[]()const в карту?
                                                        Ответить
                                                        • Согласен!

                                                          Хотя, наверно это от отсутствия ГЦ.
                                                          Там можно было бы создать новый экземпляр значения с конструктором по умолчанию и просто его вернуть.
                                                          Но тогда надо либо возвращать копию имеющегося значения, либо делать хитрые хаки.
                                                          Ответить
                                                      • > Да-да, это одно из самых хуёвых и неудобных решений в интерфейсе местной std::map.
                                                        Чтобы не быть голословным, правильный поиск Пети выглядит вот так:
                                                        void f(const std::map<std::string, Petuh> & petuhis) {
                                                            auto it = petuhis.find("Petya");
                                                            if (it != petuhis.end()) {
                                                                auto petya = *it;
                                                            }
                                                        }

                                                        Охуенно, блядь, удобно.
                                                        Ответить
                                                        • Там Борманд тебе набросил.
                                                          Ответить
                                                          • > Там Борманд тебе набросил.

                                                            Это я тебе набросил. Но at исключение кидает, как питоньи скобки. А вот аналога питоньего get нету к сожалению, только с итераторами пердолиться. Запилить то его несложно, просто изкоробки хотелось бы.
                                                            Ответить
                                                            • Почему не сделать
                                                              TValue operator [](TKey k) const {
                                                                 auto it = find(k);
                                                                 return it == end() ? TValue() : it->second;
                                                              }

                                                              ?
                                                              Ответить
                                                              • дефолтный конструктор?

                                                                а он в крестах есть у любого типа что ли?

                                                                ну и семантически это подстава конечно
                                                                Ответить
                                                                • А неконстантные скобки тогда как создают объект в мапе, если не с помощью него?
                                                                  Ответить
                                                                • Что-то же он добавляет, если ключа нет.
                                                                  Ответить
                                                              • Потому что неконстантные скобочки уже зашкварены. А иметь совершенно разный эффект для const и не const -- это уже клиника.

                                                                Тут только новый метод делать, в духе std::optional<V> get(K k) const.
                                                                Ответить
                                                                • А нахуя тогда существует возможность делать разные константные и неконстантные скобочки?
                                                                  Ответить
                                                                  • Чтобы для константного контейнера получать const T &, а для неконстантного — T &, например. А когда у тебя «auto petuh = petuhis["Petya"]» для неконстантного контейнера добавляет новый ключ, а для константного молча не добавляет — это просто идеальный подарок для стрельбы в ногу.
                                                                    Ответить
                                                                    • Честно говоря, автодобавление - это тоже сомнительная фича. Её бы как-то параметром шаблона сделать. Лично я бы хотел просто лукапить и мапу не портить.

                                                                      Но автодобавление тоже нужно, и в том же жс его мне после крестона (setdefault и operator []) не хватает.
                                                                      Ответить
                                                                      • > автодобавление - это тоже сомнительная фича

                                                                        Им каскадить удобно: a[5][42] = 100500 или m[key]++. В пёрле вроде так же работает, но более правильно -- не вставляет если просто почитать решили.
                                                                        Ответить
                                                                • А я не хочу optional. Я хочу как в моем примере.
                                                                  Ответить
                                                                  • > Я хочу как в моем примере

                                                                    Тогда можно так сделать: V get(K k, V v = V()).

                                                                    Но опшенал лучше если у типа нет специальных значений, которые прокатят за "не найдено". Именно поэтому я за опшенал.
                                                                    Ответить
                                                                  • Далеко не каждый TValue вообще можно создать без аргументов. Тут бы лучше подошло что-то вроде
                                                                    template<typename... Args>
                                                                    TValue get(const Tkey & key, Args && default_args...)
                                                                    {
                                                                        auto it = find(k);
                                                                        return it == end() ? TValue(std::forward<Args...>(default_args...)) : it->second;
                                                                    }

                                                                    (За правильность расстановки многоточий без IDE не ручаюсь)
                                                                    Ответить
                                                                    • Но operator [] как-то питушню создаёт, так что там внутри дефолтушня всё равно используется.
                                                                      Ответить
                                                                      • Он просто не компилится для объектов, у которых нету дефолта. Поэтому вариант с монадой optional более универсален, ему дефолт не нужен.
                                                                        Ответить
                                                                        • Круто бы тогда было сделать вореант
                                                                          Value get(..., Value default_ = Value())

                                                                          который бы компилился для всех, если последний аргумент подставлен, но не компилился бы для тех, у кого нет дефолтного, если не подставлен.

                                                                          Если кресты так не умеют, то стоит их научить так делать, ведь все эти карты хорошо складываются на этапе компиляции.
                                                                          Ответить
                                                                          • Ну вот хочу я держать мапу из файлов. При этом у меня труъ RAII и объект файла может существовать только если с ним реально можно работать. Дефолта у такого объекта нет и быть не может. Поэтому передать в default_ юзер ничего не сможет и твой метод работать не будет.

                                                                            Но в общем-то можно поддержать и std::optional<V> get(K k) и V get_or_default(K k, V default_ = V()) одновременно. Я не против.
                                                                            Ответить
                                                                            • имхо дефолты при чтении нужны только при мапе, содержащей другие коллекции, когда после чтения может идти запись в конкретный элемент
                                                                              Ответить
                                                                            • > std::optional<V> get(K k)
                                                                              std::optional<std::ref<V>> тогда уж. Ну или V *const.
                                                                              Ответить
                                                                            • > передать в default_ юзер ничего не сможет
                                                                              Я бы сделал в таком диалекте файловый NULL - какой-нибудь файл, который не смог открыться, бездну вроде виртуального /dev/null и т.п.
                                                                              Ответить
                                                                              • > файловый NULL

                                                                                Ну не... Так делают, конечно. И довольно часто. Но из-за этого у тебя пропадёт замечательная компайл-тайм гарантия "если объект существует, то его можно юзать".
                                                                                Ответить
                                                                                • Если реализовать питушню, которая ничего не делает при записи и считывает нули при чтении, либо делает вид, что она пустая, то можно будет юзать.
                                                                                  Ответить
                                                                                  • > которая ничего не делает при записи

                                                                                    Это уже скриптушня головного мозга какая-то...

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

                                                                                    А ты предлагаешь реальные баги под ковёр заметать, как в пхп каком-нибудь.
                                                                                    Ответить
                                                                          • > Value default_ = Value()
                                                                            От такого лучше отказаться в пользу perfect forwarding'а, как я чуть выше привёл пример. Суть в том, что если питушня с key таки найдётся, то никаких лишних объектов сконьструировано не будет, и, более того, аргументы никуда не мувнутся и останутся валидными. На этом принцимпе построены всякие новые (и очень удобные, по сравнению со старьём) «try_emplace()».
                                                                            Ответить
                                                                            • > perfect forwarding'а

                                                                              Да, он лучше, но мне было настолько лень его писать, что я передал просто по значению.
                                                                              Ответить
                                                                            • Эх, крестушня... Без продумывания того, где лежат байты, нельзя написать даже самую абстрактную функцию.
                                                                              Ответить
                                                                              • Тред начали с яваскрипта, а закончили на том, что опять выяснили какое кресты заумное и нелогичное говнище.

                                                                                И вроде читаешь пояснения лучших крестоводов — всё звучит логично.
                                                                                Итераторы, автовставка, сопзты, типабезопасность, пирформанс.

                                                                                А в реальном коде срань полнейшая: минное поле с граблями и кучами говна.
                                                                                Ответить
                                                                • >Потому что неконстантные скобочки уже зашкварены.
                                                                  Им нужно было сделать для автодобавления дефолтных значений новый оператор ?[].
                                                                  По аналогии с сишарпным сахарком.

                                                                  https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/member-access-operators#null-conditional-operators--and-

                                                                  We?.love?["C++"];

                                                                  Тогда бы фейл превратился в вин.
                                                                  И крестухов новыми значками уже не испугать. И 1024-- заапрувил бы.
                                                                  Может быть даже перешёл на С++.
                                                                  Ответить
                                                          • С at() не лучше. Мало того, что исключение надо ловить (пирфоманс!), так ещё и с областью видимости придётся ебаться: «auto & petya = petuhis.at("Petya")» будет видим только в try-блоке, так что дальше с ним либо внутри try и работать, либо как-то вытаскивать наверх через optional или уко-ко-козатель. Говно.
                                                            Ответить
                                                        • Да, вернули бы optional какой-нибудь... Понятно что скобочки уже не переделать, но новый метод то можно добавить.
                                                          Ответить
                                                        • > Чтобы не быть голословным, правильный поиск Пети выглядит вот так

                                                          Какое говнище )))

                                                          В Новом Стандарте™ починят?
                                                          Ответить
                                                          • Вроде не планируют. Лучше добавить ещё функций Бесселя, да выпить констэкспров.

                                                            Добрый день, 3.14159265. С возвращением! Где пропадал?
                                                            Ответить
                                                            • Добрый день, gost.

                                                              Да я же периодически то набигаю на ГК, то отбигаю в сторону.
                                                              Ответить
                                                    • > Я ищу питушню

                                                      А вот и неправда. 99% реальных примеров кода, который шарится по всяким жсонами, ожидает что там все поля на месте и ничего не проверяет после поиска. А потом "на ваш номер undefined было отправлено сообщение".

                                                      Бросать исключение в таком случае правильнее, имхо. Ошибку быстрее заметят и исправят.
                                                      Ответить
                      • Я бы сделал тупо raise MyError() from e чтобы зачейнить без пердолинга с бектрейсами.
                        Ответить
                        • и все равно получил бы
                          During handling of the above exception, another exception occurred же
                          Ответить
                • Продемонстрирую на примере:
                  import logging
                  
                  
                  def f():
                      raise ValueError
                  
                  
                  f.__code__ = f.__code__.replace(co_names=('KeyError',))
                  
                  
                  def main():
                      try:
                          f()
                      except Exception as e:
                          logging.exception('pizdec')
                  
                  
                  if __name__ == '__main__':
                      main()

                  $ python C:\...\exc_test.py
                  ERROR:root:pizdec
                  Traceback (most recent call last):
                    File "C:\...\exc_test.py", line 14, in main
                      f()
                    File "C:\...\exc_test.py", line 6, in f
                      raise ValueError
                  KeyError

                  Так и чувствую всю охуенность отладки такого кода.
                  Ответить
        • > MAKAKA
          > заманкипатчил

          Всё с тобой ясно.
          Ответить
          • А, может быть, в клиенте проверяют if e.stack_trace == "....":
            Поэтому стектрейс должен быть ровно такой же, как у не манкипатченной функции.
            Ответить
            • if len(str(e.stack_trace == "....")) == 4 and str(e.stack_trace == "....") == "true":
              Ответить
            • Выше уже обнаружили, оно просто проверяет, в каком файле находится функция из очередного кадра.
              Ответить
            • Это уже война брони и снаряда в говнокодинге!

              Кстати, в пистоне же модуль может быть файлом, а может - мемтухом или зожатиком. Или это в ЙАЖА, не помню.
              Так что в стеке всё равно может быть питушня в зависимости от обстоятельств.
              Ответить
    • > Попробуйте мне поймать эксепшен, и вывести строку, на которой он был кинут по трейсу вместе со стектом

      Каноничный способ:
      try:
          # делаем что-то там
      except Exception as e:
          logging.exception(e)
      Ответить
    • Браво, нашёлся по крайней мере один герпетофоб на этой ссаной помойке.
      Аплодисменты, кися.
      Ответить
  • Вот вам задачка, питухи.

    Даны 2 прямоугольника со сторонами параллельными осям, с целыми координатами. Нужно найти манхеттенское расстояние между ними (если пересекаются, то расстояние равно нулю). Как бы вы решали?
    Ответить
    • Моё решение:

      -
      -
      -
      -
      -
      -
      -
      -
      -
      Сводим задачу к "найти расстояние от точки до прямоугольника": ифаем все 9 вариантов расположения.
      Дальше перебираем 4 угла одного прямоугольника и находим минимальное расстояние до другого алгоритмом выше.
      Ответить

    • Поскольку расстояние манхеттенское, можно отдельно посчитать его по вертикали и по горизонтали, а потом сложить.
      int v = 0, h = 0;
      if (p1.left > p2.right)
          h = p1.left - p2.right;
      else if (p2.left > p1.right)
          h = p2.left - p1.right;
      if (p1.top > p2.bottom)
          h = p1.top - p2.bottom;
      else if (p2.top > p1.bottom)
          h = p2.top - p1.bottom;
      return h + v;


      Как-то так, наверное.


      Блядь, невидимые чернила просвечивают (
      Ответить
        • Именно поэтому я за coq. Или хотя бы юнит тесты.

          errata: в строках 6-9 h читать как v.
          Ответить
      • На пересечение ещё надо проверить.
        (p1.left - p2.left) * (p1.left - p2.right) <= 0 => есть пересечение, и для оставшихся трёх сторон по аналогии.
        Плюс особый случай, когда один прямоугольник целиком внутри другого: там надо проверить, что (p1_i.x - p2_i.x) * (p1_i.y - p2_i.y) >= 0 для всех четырёх точек в упорядоченном виде (p1_1 — левый нижний угол первого прямоугольника, etc).
        Ответить
        • > на пересечение ещё надо проверить
          > плюс особый случай

          Зачем? Приведи реальный пример, на котором код выдаёт неправильный ответ (с учётом ерраты выше).
          Ответить
          • @dataclasses.dataclass
            class Rect:
                left: int
                right: int
                top: int
                bottom: int
            
            
            def distance(p1: Rect, p2: Rect) -> int:
                v, h = 0, 0
                if (p1.left > p2.right):
                    h = p1.left - p2.right
                elif (p2.left > p1.right):
                    v = p2.left - p1.right
                if (p1.top > p2.bottom):
                    v = p1.top - p2.bottom
                elif (p2.top > p1.bottom):
                    v = p2.top - p1.bottom
                return h + v
            
            
            assert distance(Rect(1, 2, 3, 1), Rect(1, 4, 5, 2)) == 0

            https://i.imgur.com/UVXoy5U.png
            >>> если пересекаются, то расстояние равно нулю
            Ответить
            • Я писал под "экранную" систему координат, а не под "ма-те-ма-ти-чес-ку-ю":

              assert(p.left < p.right)
              assert(p.top < p.bottom)
              Ответить
              • А, понял, у тебя же расстояния вычисляются только для осей, по которым прямоугольники не пересекаются, а иначе инициализируются нулём. Хитро, хитро.
                Ответить
                • Можно ещё так наверное:
                  return max(p1.left - p2.right, 0) +
                         max(p2.left - p1.right, 0) +
                         max(p1.top - p2.bottom, 0) +
                         max(p2.top - p1.bottom, 0)
                  
                  Ответить
                • def distance(a, b):
                      f = lambda a, b: max(a.left - b.right, 0) + max(a.top - b.bottom, 0)
                      return f(a, b) + f(b, a)
                  
                  Ответить
  • Кстати, насчёт джейсонов и схемы:
    from dataclasses import dataclass
    import json
    
    
    @dataclass
    class User:
        name: str
        id: int
        
    
    u1 = User(**json.loads('{"name": "john", "id": 42}'))
    # ok
    
    u2 = User(**json.loads('{"name": "john"}'))
    # TypeError: __init__() missing 1 required positional argument: 'id'
    
    u3 = User(**json.loads('{"name": "john", "id": 42, "password": "123"}'))
    # TypeError: __init__() got an unexpected keyword argument 'password'

    До чего же охуенно! И никаких тебе проёбов в виде «отправили login, приняли name».
    Ответить
    • Красиво, хотя как-то сильно жёстко. Есть возможность лишнее игнорировать, нужное задефолчивать, а необходимое генерировать на лету?

      Ну, скажем, сериализованный наследник такого класса через LSP пройдёт, а через got an unexpected keyword argument не пройдёт.
      Ответить
      • По-умолчанию можно только значения по-умолчанию делать.
        from dataclasses import dataclass, field
        import uuid
        import json
        
        
        @dataclass
        class User:
            name: str = 'Anonymous'
            id: uuid.UUID = field(default_factory=uuid.uuid4)
            
        
        # Типы не проверяются
        u1 = User(**json.loads('{"name": "john", "id": 42}'))
        # User(name='john', id=42)
        
        # Ник по-умолчанию — просто значение
        u2 = User(**json.loads('{"id": 265}'))
        # User(name='Anonymous', id=265)
        
        # Фабричное значение по-умолчанию: вызывает соответствующую функцию
        u3 = User(**json.loads('{"name": "random_nemyx"}'))
        # User(name='random_nemyx', id=UUID('050d704a-afe3-4636-8eaf-e1b467bd8441'))


        Более сложную логику — с проверками типов и прочей питушнёй — нужно делать вручную, например:
        def __post_init__(self):
            if not isinstance(self.id, uuid.UUID):
                raise ValueError('noweJl Haxyu')
        Ответить
      • Ну и там ещё несколько крутых штук есть, можешь проверить https://docs.python.org/3/library/dataclasses.html.
        Наследников надо создавать через их конструкторы, да, сериализованного наследника в конструктор родителя засунуть не получится. Тут, увы, ничего не поделаешь: в сериализованном виде тип не сохраняется, а duck typing по-умолчанию запиливать было бы слишком хардкорно и нестабильно.
        Ответить
      • Ну шо поделать, зассали питонухи сделать проверку типов. Можно в __post_init__() пробежаться по dataclasses.fields(self) и проверить, благо всё нужное есть и займёт не больше пары-другой строк:
        >>> dataclasses.fields(User)
        (Field(name='name',type=<class 'str'>,default='Anonymous',...), ...)
        Ответить
        • А как вообще этот синтаксис с id: int работает?

          З.Ы. А, оно в User.__annotations__ падает.
          Ответить
          • > З.Ы. А, оно в User.__annotations__ падает.
            Ага, причём эти магические поля меняют чуть ли не в каждой минорной версии. Лучше на них не завязываться, конечно, пока стабильными не объявят.
            Ответить
            • Хм, т.е. это вообще недокументировано и неюзабельно и свой @dataclass я не смогу запилить?

              Какой багор )))
              Ответить
              • ЕМНИП, документировано, но только для конкретных версий. Во всяком случае, так где-то между 3.0 — 3.5 было, как сейчас — хз, искать в питоновской доке что-либо — то ещё удовольствие.
                Ответить
            • а, ну то есть опциональный параметр попадает под "прочую питушню", если я правильно понял
              Ответить
              • Что ты имеешь в виду под понятием «опциональный параметр»?
                Ответить
                  • @dataclass
                    class User:
                        name: str = 'Anonymous'
                        id: int = -1
                        
                    
                    u1 = User(**json.loads('{"name": "john"}'))  # aka u1 = User(name='john')
                    u2 = User(**json.loads('{"id": 42}'))  # aka u2 = User(id=42)
                    u3 = User(**json.loads('{}'))  # aka u3 = User()
                    
                    
                    >>> u1, u2, u3
                    >>> (User(name='john', id=-1), User(name='Anonymous', id=42), User(name='Anonymous', id=-1))

                    https://www.youtube.com/watch?v=-rTlo0ompmY
                    Ответить
                      • Типы, как я уже сказал, не проверяются, поэтому можно. Но лучше, конечно, сделать
                        from typing import Optional
                        # ...
                        id: Optional[int] = None
                        Ответить
                          • Да, но обрати внимание, что рекурсивно оно конструкторы не вызывает, поэтому работает только для базовых типов. Чтобы можно было правильно десериализовывать сложные объекты (class Post -> user: User), придётся либо писать логику вручную (в __post_init__() рекурсию запускать, например), либо использовать что-то мощнее («pydantic», например).
                            Ответить
                        • > Optional[int]

                          Блин, они так скоро бутафорские шаблоны придумают...

                          Какой карго-культ )))
                          Ответить
                          • Так давно уже.
                            T = TypeVar('T')
                            def squares(nums: Iterable[T]) -> List[T]:
                                return [x ** 2 for x in nums]
                            Ответить
                              • Нет, это по которому можно делать «for x in iterable». Перегруженный __iter__(), ЕМНИП.
                                Оператор [] (и len()) — это Sequence.
                                Ответить
                                • Синтаксически, а не сёмантически.

                                  Optional[T] -- это вызов оператора [] у typing.Optional?
                                  Ответить
                                  • А, тьфу, ну да.
                                    >>> type(Optional)
                                    <class 'typing._SpecialForm'>
                                    >>> type(Optional[int])
                                    <class 'typing._GenericAlias'>
                                    >>> dir(Optional)
                                    ['__call__', ...,  '__getitem__', ...]
                                    Ответить
                              • Это потуги на стат типизацию и обобщённое программирование

                                коко-вариантность (или контр, я забыл)
                                Ответить
                                • Тебе не придётся думать про ко- и контрвариантность, если ты не сделаешь механизмов проверки соответствия обобщённых типов.
                                  https://i.imgur.com/TuRVdje.png
                                  >>> isinstance([1, 2, 3], typing.Sequence)
                                  True
                                  >>> isinstance([1, 2, 3], typing.Sequence[int])
                                  TypeError: Subscripted generics cannot be used with class and instance checks

                                  Соснули.
                                  Ответить
                                  • ко ко
                                    T_co = TypeVar('Petih', covariant=True)

                                    PEP-484

                                    Вечно путаю эти "int", "out" и пр
                                    Ответить
                                    • Дык в том-то и смех, что искаробочных механизмов проверки обобщённых типов они не завезли. Можно проверить, что переданная тебе переменная — List, а проверить, что она List[int] — нельзя. Придётся вручную разбирать эти недодженериники и вручную же сверять типы, не забывая про вореантность.
                                      Ответить
                                      • А для функций они типы могут вывести по этим аннотациям?
                                        Ответить
                                              • Можно сделать компайл-тайм интерпретатор «Racket» на шоблонах и потечь.
                                                Ответить
                                                • > и потечь

                                                  И потечь памятью, угу. Компайлтайм гц ведь нету.
                                                  Ответить
                                                  • Дак и гц нахуярить можно! Сделать пул под память и оттуда выделять по необходимости.

                                                    UPD: template<Memory> new -> <Memory::block(Memory::allocate_block(): :block), Memory::allocate_block()::new_memory_sta te> или что-то вроде того.
                                                    Ответить
                                                    • Эээ, а как? constexpr'ы же иммутабельны, типы тоже. Можно только новые добавлять, а старые ни поменять ни удалить.
                                                      Ответить
                                                      • А, ну да, нам же в любом случае придётся весь граф исполнения в памяти держать. Там не переменные, там весь стейт будет течь на каждом шаге.
                                                        Ответить
                                                • s-expr можно нахуевертить даже без спирта, я уверен
                                                  Ответить
                                                  • Да. http://govnokod.ru/26308. На полноценный «Лисп» инструментов не хватило: очень не хочется компайлтайм-строки делать через препроцессор, а по-другому нельзя.
                                                    Ответить
                                        • В смысле? Функции там как Callable[[Arg1, Arg2, ...], RetType] обозначены, а автовыводом (чтобы у «x = 'hello world'» сразу был тип str) должны заниматься сторонние тайпчекеры
                                          Ответить
                                      • mypy проверяет вроде, а PyCharm точно должен уметь

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

                                          > а в рантайме ничего проверять вообще ничего надо, они же для стат проверки
                                          Надо. Да вон хотя бы для только что обсуждавшегося dataclass. Было бы куда удобнее, если бы оно гарантировало соблюдение типов полей (хотя бы опциональным флагом, типа check_types=True), но увы.
                                          Ответить
                                          • It should also be emphasized that Python will remain a dynamically typed language, and the authors have no desire to ever make type hints mandatory, even by convention.
                                            (c)
                                            Ответить
                                            • Динамичность не отменяет типизацию. Наличие isinstance(object, class) никак не делает «Питон» менее динамическим. Точно так же и возможность проверки вида isinstance(object, Union[str, List[int]]) никак не повлияла бы на динамические качества «Питона». Другое дело, конечно, что эффективно и обобщённо реализовать подобную проверку было бы очень сложно, но когда это проблемы программистов волновали пользователей?
                                              Ответить
                                              • имелось ввиду, что использование типов опционально, и заявзываться на них -- харам

                                                В рантайме нету знания о том, чем паразитирован твой list.
                                                Как можно в рантайме понять Iterable[int] он или Iterable[Svinokur]?
                                                Ответить
                                                • Вовсе нет, я вполне могу требовать наличия аннотаций для работы своего мудуля. Взять тот же стандартный (!) dataclasses: ты никак не сможешь сделать поле без аннотации, максимум — поставить Any.

                                                  Или вон, тот же «pydantic», https://pydantic-docs.helpmanual.io:
                                                  class User(BaseModel):
                                                      id: int
                                                      name = 'John Doe'
                                                      signup_ts: Optional[datetime] = None
                                                      friends: List[int] = []
                                                  
                                                  
                                                  external_data = {
                                                      'id': '123',
                                                      'signup_ts': '2019-06-01 12:22',
                                                      'friends': [1, 2, '3'],
                                                  }
                                                  user = User(**external_data)
                                                  print(user.id)
                                                  #> 123
                                                  print(repr(user.signup_ts))
                                                  #> datetime.datetime(2019, 6, 1, 12, 22)

                                                  Рекурсивный пример:
                                                  >>> class X(BaseModel):
                                                  ...     points: List[Tuple[int, int]]
                                                  ...
                                                  >>> x1 = X(points=[(1, 2), (3, 4)])
                                                  >>> x1
                                                  X(points=[(1, 2), (3, 4)])
                                                  
                                                  >>> x2 = X(points=[(1, 2), (3, 'x')])
                                                  Traceback (most recent call last):
                                                    File "<stdin>", line 1, in <module>
                                                    File "pydantic\main.py", line 362, in pydantic.main.BaseModel.__init__
                                                  pydantic.error_wrappers.ValidationError: 1 validation error for X
                                                  points -> 1 -> 1
                                                    value is not a valid integer (type=type_error.integer)
                                                  Ответить
                                                  • >Вовсе нет,
                                                    ты хочешь поспорить с pep-484 и 526?
                                                    https://www.python.org/dev/peps/pep-0484/#non-goals
                                                    https://www.python.org/dev/peps/pep-0526/#non-goals

                                                    "no desire to ever make type hints mandatory, even by convention."

                                                    Пайдантик это внешняя тула, она может чего угодно требовать.

                                                    В dataclass ты можешь написать Any, но типы все равно же не проверяются:

                                                    from dataclasses import dataclass
                                                    
                                                    @dataclass
                                                    class Spam:
                                                        name: str
                                                    
                                                    
                                                    print(Spam(1).name)
                                                    Ответить
                                                    • > no desire to ever make type hints mandatory, even by convention
                                                      Но как так получилось, что в dataclass они именно что mandatory? Ты не можешь сделать датакласс без аннотаций, не предусмотрено такого. Any — это тоже аннотация.

                                                      Но я так и не понял, как «no desire to ever make type hints mandatory, even by convention» мешает наличию встроенного инструмента для рантайм проверки типов. Вот как сложность разработки такого инструмента мешает — понял, как необязательность тайпхинтов — не понял.

                                                      Ещё раз: ты можешь в «Питоне» проверить, что переданный тебе объект является, например, коллекцией:
                                                      >>> isinstance(range(999), typing.Sequence)
                                                      True
                                                      >>> isinstance(42, typing.Sequence)
                                                      False

                                                      А вот проверить (провалидировать, если угодно), что переданный тебе объект является, например, коллекцией целых чисел, не можешь:
                                                      >>> isinstance(range(42), typing.Sequence[int])
                                                      Traceback (most recent call last):
                                                          ...
                                                      TypeError: Subscripted generics cannot be used with class and instance checks

                                                      И вот это — говнище.
                                                      Ответить
                                                      • > dataclass они именно что mandatory?
                                                        питонисты соснули, пушо: сами запутались в своих пепах

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


                                                        >А вот проверить (провалидировать, если угодно),

                                                        Проверить, что что-то является коллекцией, ты мог и до аннотаций. Это знание есть в рантайме.

                                                        >>> import collections
                                                        >>> isinstance([], collections.Sequence)
                                                        True
                                                        >>> isinstance((), collections.Sequence)
                                                        True
                                                        >>> isinstance(23, collections.Sequence)
                                                        False


                                                        А знания о том, каоко типа данные там могут лежать -- нету.

                                                        Аннотации не сущестувуют в рантайме. Никакой информации о них нет.
                                                        Твои проверки это просто алиасы для тех же collections.
                                                        from typing import List
                                                        
                                                        a: str = "A" #a -- строка по аннотациям
                                                        a = []
                                                        
                                                        print(isinstance(a, List)) #True
                                                        Ответить
                                                        • > Но скорее всего имелось ввиду, что питон никогда не заставит тебя соблюдать аннотации: в датаклассах они тоже для красоты
                                                          Да.

                                                          > Аннотации не сущестувуют в рантайме. Никакой информации о них нет.
                                                          Неверно. Аннотации в рантайме вполне себе существуют:
                                                          >>> def sqr(x: int) -> int:
                                                          ...     return x**2
                                                          ...
                                                          >>> typing.get_type_hints(sqr)
                                                          {'x': <class 'int'>, 'return': <class 'int'>}

                                                          Соблюдать их тебя заставляют, это верно.

                                                          Выше я наглядно продемонстрировал, что «pydentic» прекрасно справляется с рекурсивной проверкой типов исключительно языковыми средствами, и List[int] от List[str] отличить способен. И именно такую валидацию я хочу искаропки.
                                                          Ответить
                                                          • >Аннотации в рантайме вполне себе существуют
                                                            А забери мне аннотацию у переменной?

                                                            >исключительно языковыми средствами,
                                                            я не знаю, как он работает: он сам AST не строит?
                                                            Ответить
                                                            • > А забери мне аннотацию у переменной?
                                                              У переменных их нет, но в контексте разговора это совершенно неважно.

                                                              > я не знаю, как он работает: он сам AST не строит?
                                                              Вообще нет, он берёт аннотации и долго и уныло приходящие на вход данные проверяет на соответствие. Это не внешняя утилита, это просто библиотека.
                                                              Ответить
                                                              • >У переменных их нет
                                                                как так нет?
                                                                https://www.python.org/dev/peps/pep-0526/

                                                                >Это не внешняя утилита, это просто библиотека.
                                                                в чем разница? важно, что это не часть сипайтон

                                                                Пайшарм вон умеет вывод типов, но мы же не говорим, что в питоне есть вывод типов
                                                                Ответить
                                                                • В рантайме нет, ну. Ты же об этом писал.

                                                                  > в чем разница?
                                                                  В том, что в «Питоне» уже сейчас есть все средства для создания вменяемого инструмента проверки обобщённых типов. Грубо говоря, авторы «pydantic» осилили написать функцию, которая работает примерно вот так:
                                                                  is_valid_type([1, 2, 3], List[int]) == True
                                                                  is_valid_type([1, 2, 'x']) == False

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

                                                                    is_valid_type([1, 2, 3], List[int]) == True
                                                                    is_valid_type([1, 2, 3], List[float]) == True


                                                                    ?
                                                                    Ответить
                                                                    • По версии «pydantic» — будет, он там неявные преобразования проводит:
                                                                      >>> class X(BaseModel):
                                                                      ...     x: List[float]
                                                                      ...
                                                                      >>> X(x=[1, 2, 3])
                                                                      X(x=[1.0, 2.0, 3.0])
                                                                      >>> X(x=[1, 2, 3.1])
                                                                      X(x=[1.0, 2.0, 3.1])
                                                                      Ответить
                                                                  • А typing.get_type_hints умеет вернуть List[int]? или только List?
                                                                    Ответить
                                                                    • Умеет, разумеется, иначе бы магия не получилась.
                                                                      >>> def sqr(nums: Iterable[int]) -> Sequence[int]:
                                                                      ...     return [x ** 2 for x in nums]
                                                                      ...
                                                                      >>> typing.get_type_hints(sqr)
                                                                      {'nums': typing.Iterable[int], 'return': typing.Sequence[int]}
                                                                      Ответить
                                                                      • >Умеет
                                                                        тогда я не понимаю, на что ты жалуешься.

                                                                        На то, что isinstance не работает?
                                                                        так еще раз обращаю внимание на то, что isinstance ничего не знает об аннотациях
                                                                        Ответить
                                                                        • > На то, что isinstance не работает?
                                                                          Или на то, что нет отдельной функции validate_typehint() или что-то в этом духе.

                                                                          > так еще раз обращаю внимание на то, что isinstance ничего не знает об аннотациях
                                                                          О коллекциях она, ВНЕЗАПНО, тоже ничего не знает. Смотри:
                                                                          >>> isinstance([1, 2, 3], collections.abc.Iterable)
                                                                          True
                                                                          >>> issubclass(list, collections.abc.Iterable)  # Тот же isinstance, только в профиль
                                                                          True
                                                                          >>> inspect.getmro(list)
                                                                          (<class 'list'>, <class 'object'>)

                                                                          Вот не наследуется list от Iterable — и всё. А issubclass говорит, что наследуется. Вот такие вот питоньи чудеса.
                                                                          Ответить
                                                                        • Более наглядный пример:
                                                                          >>> class X:  # Наследуемся только от object!
                                                                          ...     def __iter__(self): pass
                                                                          ...
                                                                          >>>
                                                                          >>> inspect.getmro(X)
                                                                          (<class '__main__.X'>, <class 'object'>)
                                                                          >>> issubclass(X, collections.abc.Iterable)
                                                                          True
                                                                          >>> isinstance(X(), collections.abc.Iterable)
                                                                          True

                                                                          Чудо новогоднее, блять!
                                                                          Ответить
                                                                          • Ну и наконец, развенчание чуда новогоднего, блять:
                                                                            >>> class Metapetuh(type):
                                                                            ...     def __subclasscheck__(cls, C):
                                                                            ...             return True
                                                                            ...     def __instancecheck__(self, other):
                                                                            ...             return True
                                                                            ...
                                                                            >>> class Petuh(metaclass=Metapetuh):
                                                                            ...     pass
                                                                            ...
                                                                            >>> issubclass(object, Petuh)
                                                                            True
                                                                            >>> isinstance(42, Petuh)
                                                                            True

                                                                            Мы зашкварили весь «Питон», и теперь все классы в нём — петухи.

                                                                            Мораль сей басни такова: для isinstance() совершенно не обязательно что-то знать про тайпхинты, коллекции и прочую поебень. Реализация isinstance(x, List[int]) остаётся исключительно на совести автора List[int].
                                                                            Ответить
                                                                      • Какая же уёбищная нотация типов.
                                                                        Ответить
                                                                        • > Какая же уёбищная нотация типов.

                                                                          А мне норм. В сишке/крестах синтаксис ещё более уёбищный в этом плане.
                                                                          Ответить
                                                                        • А что уёбищного?

                                                                          Вроде общеизвестно, что

                                                                          Petuh createPetuh(Kurochka kurochka)

                                                                          отчаянно сосёт с проглотом у
                                                                          createPetuh(kurochka:Kurochka) -> Kurochka

                                                                          разве нет?
                                                                          Ответить
                                                                          • > отчаянно сосёт с проглотом

                                                                            Угу, в крестах вон даже это признали и сделали:
                                                                            using foo = bar;
                                                                            // вместо typedef bar foo;
                                                                            
                                                                            auto func() -> int { ... }
                                                                            // вместо int func() { ... }
                                                                            Ответить
                                                                            • В крестах совместиили два подхода, чтобы программисту было чем размять память

                                                                              Кстати, постоянная тренировка памяти помогает избежать деменции и склероза, так что С++ программисты будут иметь светлую голову до девяноста лет
                                                                              Ответить
                                                                            • Ну хуй знает, между именно var type и type var я как-то не особенно разницу вижу. «auto func() -> int» сделали по большей части для того, чтобы можно было писать что-то вроде
                                                                              auto func(auto a, auto b) -> decltype(a + b) { return a + b; }

                                                                              И течь. Потому что если бы они просто вынесли доступность параметров функции «налево» — парсер бы окончательно охуел и вышел в окно.
                                                                              Ответить
                                                                            • ну разумеется нет. Во всех современных языках это давно уже признали, везде var:Type. Использование нотации Type var было ошибкой
                                                                              Ответить
                                                                  • Ну и чтобы зря не пиздеть — PoC:
                                                                    >>> def is_valid_collection(obj, hint):
                                                                    ...     if not isinstance(obj, hint.__origin__):
                                                                    ...             return False
                                                                    ...     return all((isinstance(x, hint.__args__[0]) for x in obj))
                                                                    ...
                                                                    >>> is_valid_collection([1, 2, 3], List[int])
                                                                    True
                                                                    >>> is_valid_collection([1, 2, 3], Sequence[int])
                                                                    True
                                                                    >>> is_valid_collection([1, 2, 'x'], Sequence[int])
                                                                    False

                                                                    Вот примерно такая же хуйня, только на много-много строк, и делается в «Pydantic». Что делать с Iterable — хуй его знает, думать надо. А в идеале думать надо было авторам «Питона».
                                                                    Ответить
                                                          • Интересно, что в моём Пистоне выводит просто

                                                            {'return': int, 'x': int}
                                                            Ответить
                                                      • > ты можешь в «Питоне» проверить, что переданный тебе объект является, например, коллекцией

                                                        - так это ж всегда можно было, к аннотациям и тайпихинтингу не имеет отношения

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

                                                            Смотри:
                                                            Есть тип выражения, а есть аннотации некоторых символов.

                                                            Они вообще никак между собой не связаны, питон никак не их не связывает

                                                            Какие-то левые тулы (пайдантик, mypy, pycharm) связывают, а питону пофиг.
                                                            Ответить
                                                            • Блядь, именно на это я и нахрюкиваю. Питонухи не осилили сделать нормальной валидации (похуй на эффективность даже) обобщённых типов и гордо назвали это фичей. Отвратительно.

                                                              > левые тулы (пайдантик
                                                              Это не тула, это библиотека. Она работает исключительно в рантайме и исключительно за счёт внутриязыковых средств.
                                                              Ответить
                                                              • > Питонухи не осилили сделать нормальной валидации
                                                                питонухи не делали валидации же, разве сам питон умеет что-то валидировать?
                                                                Ответить
                                                                • Так в том-то и дело, что да, базовую валидацию они осилили. isinstance(obj, Iterable) — это в чистом, рафинированном виде валидация, к, собственно, наследованию не имеющая ни малейшего отношения. Она берёт объект и проверяет его на соответствие каким-то произвольным критериям, в данном случае — на наличие каких-то магических методов.

                                                                  Доброе утро, MAKAKA.
                                                                  Ответить
                                                                  • доброе, гост.

                                                                    Приведенная тобой базовая валидация была в питоне издревле, и я не понимаю, почему мы смешиваем её с аннотациями.

                                                                    Раньше в питоне было принято указывать тип в докстроке.

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

                                                                    Но isinstance на твою докстроку срал, верно?

                                                                    Вот аннотации это по сути такая же хень, как и докстроки, просто формализованная.

                                                                    И питону, и isintanceу на них плевать.

                                                                    Не плеваить только тулам типа пайдантика.

                                                                    Сначала в питоне вообще все текли от УТИНОЙ типизации:

                                                                    "мой класс string-like класс, ведь у него есть почти все методы строки".

                                                                    Потом они завезли abstact base classes, чтобы стало можно сказать "я файл" или "я строка".

                                                                    А потом появились аннотации, но это совершенно параллельная конструкция, ни к instance, ни к ABC не относящаяся.

                                                                    Вообще это всё говно конечно.

                                                                    Нужно было изначально сделать как в TypeScript, или добавить ключик для проверки типов в рантайме
                                                                    Ответить
                                                                    • Я совершенно не понимаю, причём здесь вообще аннотации. Я хочу очень простой вещи: чтобы «isinstance(obj, Sequence[int])» работала точно так же, как и «isinstance(obj, Sequence)». Покажи мне, где здесь аннотации типов?
                                                                      Ответить
                                                                      • Но что такое

                                                                        >Sequence[int]
                                                                        ?

                                                                        Разве ABC классы вообще поддерживают обобщенное программирование?

                                                                        Мне казалось, что синтаксис Class[Type] есть только в аннотациях, не?
                                                                        Ответить
                                                                        • А, так вот в чём проблема! Sequence[int] — это обычный метакласс, собирающийся метушнёй, это не специальный синтаксис:
                                                                          >>> type(typing.Sequence), type(typing.Sequence[int])
                                                                          (<class 'typing._GenericAlias'>, <class 'typing._GenericAlias'>)

                                                                          А делается он простым перегруженным оператором []:
                                                                          @_tp_cache
                                                                          def __getitem__(self, params):
                                                                              if self.__origin__ in (Generic, Protocol):
                                                                                  # Can't subscript Generic[...] or Protocol[...].
                                                                                  raise TypeError(f"Cannot subscript already-subscripted {self}")
                                                                              if not isinstance(params, tuple):
                                                                                  params = (params,)
                                                                              msg = "Parameters to generic types must be types."
                                                                              params = tuple(_type_check(p, msg) for p in params)
                                                                              _check_generic(self, params)
                                                                              return _subs_tvars(self, self.__parameters__, params)
                                                                          Ответить
                                                • Ещё охуенный пример:
                                                  from typing import List
                                                  from pydantic import BaseModel
                                                  
                                                  
                                                  class Comment(BaseModel):
                                                      text: str
                                                      rating: int
                                                  
                                                  
                                                  class User(BaseModel):
                                                      name: str
                                                      id: int
                                                  
                                                  
                                                  class Post(BaseModel):
                                                      text: str
                                                      user: User
                                                      comments: List[Comment]
                                                  
                                                  
                                                  post = Post(**json.loads(
                                                      '{"text": "Hello World",'
                                                      ' "user": {"name": "john", "id": 42},'
                                                      ' "comments": [{"text": "vanished", "rating": -999}, {"text": "какой багор )))", "rating": 100500}]}'
                                                  ))
                                                  
                                                  
                                                  >>> post
                                                  >>> Post(text='Hello World', user=User(name='john', id=42), comments=[Comment(text='vanished', rating=-999), Comment(text='какой багор )))', rating=100500)])
                                                  
                                                  
                                                  
                                                  
                                                  >>> Post(**json.loads(
                                                  ...     '{"text": "Hello World",'
                                                  ...     ' "user": {"name": "john", "id": 42},'
                                                  ...     ' "comments": [{"text": "vanished", "rating": "плохой рейтинг"}, {"text": "какой багор )))", "rating": 100500}]}'
                                                  ... ))
                                                  Traceback (most recent call last):
                                                    File "<stdin>", line 1, in <module>
                                                    File "pydantic\main.py", line 362, in pydantic.main.BaseModel.__init__
                                                  pydantic.error_wrappers.ValidationError: 1 validation error for Post
                                                  comments -> 0 -> rating
                                                    value is not a valid integer (type=type_error.integer)

                                                  Полностью автоматическая генерация моделей с поддержкой рекурсивного парсинга и строгой валидацией — это же просто охуенно! И вся эта прелесть — исключительно на аннотациях.
                                                  Ответить
                • Когда новая версия парсит старый обратно совместимый пакет.

                  Либо когда разрешаем клиенту экономить трафик и не передавать часть полей.
                  Ответить
        • >пенсионеров
          у вас опечатка в словосочетании "программистов на нормальных технологиях"
          Ответить
    • Вложенные структуры не сможет распарсить же, раз типы игнорятся?
      Ответить
    • 11.03.99 В разделе Юмор появились страници Факты о Пиве и Програма Любителя Пива написанная на Си. Можете попытаться откомпилировать 🙂

      http://nubo.ru/humor/beerprogram.html

      // Програма Партии Любителей Пива
      // Версия 0.1.17  21/10/96
      
      // Реализация этих функций выполняется каждым членом партии самостоятельно!
      extern float GetMoney(void);
      extern float TwoBeer(float money);
      extern float OneMore(float money);
      extern float Full(float beer);
      extern void Drink(float beer);
      extern void Go00(float beer);
      extern void Talk(void);
      
      #define err_NoMoney 1
      #define err_NoBeer  2
      #define BeerCost 3200           // Конкретное значение зависит от региона!
      
      int main(void)
       {
        float money=0;
        float beer=0;
        float cap;
        int count;
      
        while ((money+=GetMoney())>=BeerCost*2)
         for (cap=TwoBeer(BeerCost*2),money-=BeerCost*2
             ;money>=BeerCost
             ;cap=OneMore(BeerCost),money-=BeerCost)
          {
           if (!cap) return err_NoBeer;  // :-(~
           if (Full(beer)) Go00(beer);
           for (count=50;count-->0;)
            {
             Drink(0.02*cap);
             Talk();
            }
           beer+=cap;
          }
        return err_NoMoney;  // :~(
       }

      флоат -- мани
      фу таким быть
      Ответить
    • >http://nubo.ru/pavel_egorov/new99.html
      блядь, циферки на этикекте
      а
      аа
      Ответить
    • http://nubo.ru/humor/prick-05.html
      Что было-бы, если бы Билл Гейтс занялся пивом, а не операционками...

      После выпития очередной бутылки Пива Ваш организм выдавал бы одно из следующих сообщений:

      1) Некорректный организм. Проведите инсталляцию Пива на другом организме.

      2) Инсталляция Пива прошла неудачно. Пиво будет деинсталлировано немедленно.

      3) Ваш организм не позволяет настройку инсталлируеммого Пива на выставленный градус. По умолчанию принято безалкогольное пиво.

      4) Не хватает емкости организма для инсталляции указанного количества Пива.

      5) Переполнение мочевого пузыря. Произведен немедленный сброс его содержимого.

      6) Инсталлированное Пиво не поддерживает корректной работы Вашей периферии. Джойстик в системе не обнаружен...

      7) Пиво, которое Вы инсталлировали, судя по его серийному номеру, было продано владельцу из Калифорнии для единичной (однократной!) инсталляции! Вы инсталлируете пятый раз ранее инсталлированное другими Пиво!

      8) Заплатите деньги за инсталлированное Пиво!

      9) Инсталляция Вашего Пива успешно завершена! Теперь Вы каждое утро будете созерцать облака на фоне зарешеченного окошечка!

      10) Подождите, пока Ваше Пиво завершит работу...

      11) Приобретите и установите дополнительный драйвер для корректной работы Джойстика.

      12) В почтовом ящике есть сообщение: "Вася! Благодаря нашей совместной инсталляции Пива и использованию тобой джойстика без предварительной установки драйвера, мой организм допускает 3 возможных варианта продолжения работы: Abort, Retry, Ignore..."

      13) Ваш организм завис. Выгрузите все ранее загруженные сорта Пива и загрузите их заново.
      Ответить
  • Помогите Desktop'у собрать ПеКа.

    Требования к машинке: способная переваривать игры уровня RDR2 пусть не на ультре, но хотя бы на высоких настройках; актуальная для разработки в прожорливых IDE уровня VS, ну собсно и всё (?)
    Ответить
    • Как мы недавно выяснили, брать сейчас нужно AMD рязань, но про них лучше у Д++ спросить, я особо в них не вникал.

      Если хочется именно интел, то comet lake не меньше i5 (лучше i7, все таки ты хочешь тяжелые ide). Постарайся выбрать без GPU (ты же будешь внещнюю брать)
      ищи N/A в графе GPU:
      https://en.wikipedia.org/wiki/Comet_Lake_(microprocessor)

      Память DDR4 лучше 16 (можно 32, если позволяют средства). Брать набор из минимум двух планок (чтобы завёлся дуал ченнел). В идеальном мире выбирать из списка, предложенного производителем мамки.

      Мамку я обычно беру Asus. конкретная модель зависит от твоих потребностей в колве PCI-E и USB, но совсем маленькие лучше не брать, бо там будет все слишком близко.
      Чипсет зависит от твоего выбора проца)

      SSD на NVME разумеется!
      Я сторонник Samsung 980 pro (не младше pro!!)

      По GPU не подскажу, нужно читать обзоры.

      Если будет очень мощная видео, то БП наверное лучше взять отдельно от корпуса, выбрав его по мощности (чтобы примерно совпадало с общей мощностью всего г-на, что ты туда поставишь), ну и не ноунеймовое говно, бо у него будет плохая кросс-нагрузочная.
      Как минимум что-то типа https://www.ixbt.com/supply/corsair-rm650-2019-review.html#n7
      Ответить
      • Спасибо!

        > БП наверное лучше взять отдельно от корпуса
        - а есть корпуса сразу с БП? а то я не в курсе
        Ответить
          • я думаю, это не вариант, просто удивился, потому что раньше про такое не слышал
            Ответить
            • странно) Почти все офисные компы, и многие домашние, которые я видел, были снабжены встроенным БП. Во времена AT я даже и не знал, что блоки можно менять.

              У меня сейчас корпус восемнадцатилетней примерно давности, его БП давно ушел в небытие (он и питание-то современное не умеет, atx 2.2 или как там оно), и был заменен каким-то кодегеном
              Ответить
                • Это правда

                  Я собрал комп в 2002-м году на Penitum 4 Northwood. У меня был корпус InWin (тогда они еще были хорошие, крепкие, в отличие от хлипкого говна, которое тогда было вокруг меня).

                  В 2013-м я перешел на i7 Ivy Bridge, и поменял БП.

                  Я обычно работаю на рабочем компе (из дома -- удалённо), так что от слабой машины я не очень-то и страдал
                  Ответить
              • > встроенным БП

                Прям намертво? Или просто в комплекте с корпусом зачем-то прилагается БП?
                Ответить
                • В комплекте, конечно.

                  У меня шел в комплекте, но я его потом вывернул, и вставил другой, когда апгрейтился
                  Ответить
                  • Ну для офисной сборки это норм, наверное.

                    Для игровой всяко не вариант, вряд ли они туда блок с хорошим КПД воткнут. А на дешёвом говне можно будет яишницу жарить.
                    Ответить
                    • Да, именно для офисов они обычно и идут.

                      Когда тебе нужно собрать тридцать рабочих мест для операторов 1С, но нет смысла ставить туда специальные БП:)

                      Дело и в КПД, и в мощности, и в перекосоёбах на кросс-нагрузочном, насколько я понимаю.
                      Ответить
                      • Угу, 300Вт+ на 12В линиях -- это не шутка. У дешевого блока банально провода греться будут, потому что на них тоже сэкономили.
                        Ответить
                        • "Cэкономили" это типа провода с хуёвым сопротивлением, и потому они рассеивают больше тепла?

                          Это как я себе дома в проводку поставлю тоненький аллюминевый провод, и буду греть стенку?

                          Кстати, проц питается от 12, но вроде ядро питается от куда мЕньшего напряжения, там этот VRM или как его?
                          Ответить
                          • Да, там вокруг проца десяток VRM модулей (обычный понижающий шим с дросселем).
                            Ответить
                            • глупый может вопрос: а нахуя ему 12? почему не 3.3, например? БП же и их выдает.

                              или ему не хватит выдаваемого там тока?
                              Ответить
                              • Потому что если на 12В тебе надо передать "всего" 25А, то на 3В -- уже сотню. Провода на 100А явно будут толще.

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

                                З.Ы. 3.3 и 5 на современных бп совсем слабенькие, почти вся мощность идёт на 12.
                                Ответить
                                • Ну да, понял: проще передать высокое напряжение, чем ебаться с пиздецовым током.

                                  5.5 вроде вообще мало кто использует, а 3.3 наверное едят какие-нить куллеры?
                                  Ответить
                                  • Кулеры на 12 вроде.

                                    5 для усб и дисков.

                                    3.3 и -5 скорее всего никто и не юзает уже. Может на какую-нибудь слаботочку на материнке, х.з.
                                    Ответить
                                    • я вот там написал про кулер на молексе и понял, что да: molex же 12, и куллер значит тоже 12.

                                      я думал, что sata 3.3


                                      Блядь, все перепутал, нужно почитать
                                      Ответить
                                      • На молексах 5 и 12. Сату можно питать от молекса, значит там тож самое.
                                        Ответить
                                        • точно: у меня был переходник с двумя всего проводами в молексе.

                                          Судя по раскладке, там было только 12в на кулер

                                          https://i.stack.imgur.com/IA43b.jpg

                                          Попиздиш тут с вами, и начинается стояк на железо.
                                          Сразу хочется ремонтировать и собирать компы, лол
                                          Ответить
                                          • Кстати кулер можно и от 5 запитать. Они тише становятся, но не все могут нормально стартануть.
                                            Ответить
                                            • Так а зачем это нужно, если можно втынкуть его в мамку, и отдать на откуп ospm? Она будет и скоростью управлять (чтобы не шумел)
                                              Ответить
      • > про gpu

        Что-нибудь из 20хх-30хх серии нвидий. Всё что до этого морально устарело и не умеет в рейтрейсинг и DLSS. У амд на это пока ответа нету, насколько я знаю.
        Ответить
        • Что скажешь про ATI?
          >У амд на это пока ответа нету, насколько я знаю.
          вопрос снят

          забавно: проц лучше брать AMD, а карту -- нвидиа, так?
          Ответить
          • RX 6000 таки с рейтрейсингом, отстал я от жизни немного.
            Ответить
            • Когда-то была такая питушня, что например nvidia умел какие-то фишки только на своем чипсете (SLI например). Сейчас все чипсеты у интела -- интел.

              Но не может быть такого, что RX 6000 будет лучше работать с AMDшным чипсетом (для их процов же и чипсеты ихние?)
              Или я хуйню сказал?

              Иными словами, не может так оказаться, что к процессору AMD лучше и карту взять AMD?
              Ответить
              • С видюхами пофиг по идее. PCIe оно и есть PCIe. Разве что в дровах какую-нибудь оптимизацию прикрутят под свои процы.
                Ответить
                  • Хех, я не шарю в SLI/crossfire... Тут одна то карта стоит как самолёт. Может быть какая-то фишка в духе бродкаста данных на обе карты нужна была в те годы, agp же не особо шустрое.

                    Сейчас насколько помню на любой материнке работает и sli и crossfire. Ну если есть 2 слота под видюхи, конечно.
                    Ответить
                      • Если места в корпусе хватает и хочется тишины -- можешь водянку въебать на проц. Мне понравилось.

                        Если нету -- классическую байду на пару килограмм цветмета.

                        Желательно еще хотя бы по одной вертушке на входе и выходе системника. Без них летом может не хватить охлаждения.

                        И да, если новый корпус берёшь -- смотри чтобы места побольше и можно было кабели спрятать с обратной стороны, чтобы эти джунгли потоку воздуха не мешали.
                        Ответить
                      • Правильныый выдув должен идти так

                        https://3dnews.ru/assets/external/illustrations/2018/01/24/964587/vozduh.jpg

                        На жопу БП можно поставить куллер (обычно хорошие материнки умеют его сами выключать в зависимости от температуры на thermal zone, разъем "sys fan" или как-то так)

                        Кулера бывают sleeve (на сопле) и ball (на подшипнике)
                        Я за подшипник (правда, я свои знания лет десять не обновлял).

                        Потом запускаешь PowerMax, он нагружает тебе CPU и GPU, потом берешь CoreTemp или HWInfo, и смотришь температуры.
                        Если они близки к критическим -- нужно ставить куллер еще и на морду, и связывать провода жгутами, чтобы не мешать воздухку
                        Ответить
                        • > связывать провода жгутами

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

                          А вертушку на морду лучше сразу взять. Они большие и тихие же. С хорошим потоком видюха с процом будут свои кулера поменьше крутить. В итоге меньше шума будет.
                          Ответить
                          • Кстати, это хороший повод взять и мамку побольше

                            * Чтобы там было много sys fan (иначе будешь пихать неуправляемый куллер прямо в БП через переходник)
                            * чтобы расстояние между девайсами было побольше
                            Ответить
                            • У меня в корпусе тупо сплиттер для сис фан прилагался.
                              Ответить
                              • У меня на старой мамке куллер висел прямо на питании HDD (molex или как оно), но конечно нихуя не выключался програмно.
                                Ответить
                                • Да тож норм, большие низкооборотные вертушки очень тихие.
                                  Ответить
                                  • ну просто нахуй они нужны, если прохладно.
                                    Кстати, за этим же OSPM следит в ACPI? или сама прошивка?

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

                                    Нормальные корпуса, когда закрыты, не дрожат, и там даже шумные куллеры не так страшны
                                    Ответить
                                    • А, кроме tower'ов, имеет смысл смотреть на какой-то форм-фактор корпусов?
                                      Ответить
                                      • Нет конечно.

                                        Компактный и мощный комп очень сложно собрать. Больше воздуха -- меньше ёбли.
                                        Ответить
                                      • Да нет, в пизду, если ты не берешь готовый.

                                        В целом чем больше у тебя корпус и мамка, тем тебе проще
                                        Ответить
                                        • Угу. А то купят себе пигмейский корпус, а потом видюху через удлинитель подключают. Потому что по-другому она туда не лезет.

                                          Нафиг так жить.
                                          Ответить
                                          • Ну а «лежачих» больших корпусов сегодня нет? В стиле 80-х лол
                                            Ответить
                                            • Приклей ножки на бок и положи, лол. Но башня меньше места занимает так то.
                                              Ответить
                                            • И вообще не экономь на корпусе, ты же его лет на 10 берешь, в отличие от остального фарша.

                                              Возьми что-то тяжёлое, просторное и из хорошего металла, а не консервную банку.
                                              Ответить
                                              • А как можно с пользой занять место для приводов? Они-то нафиг не нужны
                                                Ответить
                                                • Выдрать шасси для приводов и воткнуть туда еще одну вертушку.
                                                  Ответить
                                                • чем больше места -- тем больше воздуха, и тем меньше одно говно греет другое
                                                  Ответить
                                            • ну ты скажи еще CRT мон сверху поставить, лол

                                              есть горизонтальные корпуса, но они чаще брендовые, и потом туда что-то не влезет
                                              Ответить
                                              • > что-то туда не влезет

                                                Видюха. Она и в tower то еле-еле. Кажется золотой хуй тут недавно обсуждал упихивание видюхи в компактный корпус и совместимость pci-e удлинителей.
                                                Ответить
                                                • В тяжелых случаях брендовый корпус настолько брендовый, что обычный atx туда не станет (нужна своя специфичная мама) так что в этом говно я бы не полез без необходимости
                                                  Ответить
                                                    • зы: на рубеже веков была эпидемия хуёвых корпусов.

                                                      У них БП стоял вертикально, и занимал пол корпуса, а сам корпус был сделан из говна, которое сразу гнулось. Закрыть второй раз такой корпус было невозможно. Зато руки он резал только в путь.

                                                      На фоне крепеньких AT корпусов (с кожухом, состоящим из крышки и двух стенок) всё выглядело, как говно.

                                                      Потому мой InWin на том фоне выглядел няшно
                                                      Ответить
                                                    • выглядит няшно, но

                                                      спереди панель не открывается что ли?
                                                      Ответить
                                                      • обычно открывается. Там просто металлический корпус, на который сверху нащелкнута пластмасса, которую можно снять.

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

                                                        https://www.ixbt.com/supply/corsair-275r-airflow-review.html
                                                        Ответить
                                                        • не, я имел в виду, не открывается ли он как дверца

                                                          но после того, как я увидел, что разъёмы под аудио и USB сверху, всё стало понятно

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

                                                                Алсо, на некоторых материнках есть экран, который показывает или пост коды при загрузке, или темепературу, и им это нравится.

                                                                Если они ставят стекло то это еще пол беды. А если питух ставит прозрачный пластик, то сразу нахуй.

                                                                Ну вот у inwin c200 корпус не прозрачный
                                                                Ответить
                                                              • Да, я всего один нормальный корпус нашёл чтобы ничего не светилось и не торчало. Просто чорный параллелепипед.
                                                                Ответить
                                                                    • я могу вообще взять свой старый кулер мастер и в него всё поставить кмк

                                                                      два допкулера там уже есть, спереди и сзади, можно пришпандорить ещё один здоровый на боковую стенку и будет збс
                                                                      Ответить
                                                                      • так это самое заебись тогда, БП только поменять и всё
                                                                        Ответить
                                                                    • Ого, настоящий чёрный гроб! Тяжесть — это хорошо, тяжесть — это надёжно.

                                                                      Добрый день, bormand.
                                                                      Ответить
                                                                      • На хуя такие здоровые огромные за лупы, в которых 99% за нимаемого внутренего пространства будет во з дух? По этому я за компактные корпуса, у меня на данный момент fractal node 202. Могло быть и меньше конечно если БП вытащить наружу
                                                                        Ответить
                                                                        • > По этому я за компактные корпуса, у меня на данный момент fractal node 202.
                                                                          Любитель жарить яичницу на троттлящемся проце?
                                                                          Ответить
                                                                          • Ну а серьёзно — в такой пенал современная видеокарта тупо не влезет, а даже если каким-то чудом и влезет, то всё равно всеми вентиляторами будет дуть в сплошной металл.
                                                                            Ответить
                                                                            • Турбины для кого придумали? Смысле не влезет? там места дохуя под видяху. RX 5700 у меня влез и дохуя места еще осталось (Я туда 2 ссдшника в те места ебанул)
                                                                              Ответить
                                                                                  • > С Какой температурой?

                                                                                    Ну в 3дмарке например или в какой-нибудь современной игрушке.
                                                                                    Ответить
                                                                                  • Видеокарты.
                                                                                    Для сравнения, с небольшими твиками моя 1660 под полной нагрузкой греется на 54 градуса и практически не вертит вентиляторами (1250 RPM, треть от максимума). Именно поэтому я за «гроб».
                                                                                    Ответить
                                                                                    • Я против гробов, потому что эта скучная и унылая коробка. Я всю жизнь такое дерьмо видел и меня уже блевать тянет от этих корпусов. Еще по напихают радушные переливающиеся говно и радуются. Я радуюсь компакности и мне достаточно его взять в подмышку и не надо пердолится с переносом его. а размер как консоль. и мне даже не стыдно за скриншоты и иконки на рабочем столе.
                                                                                      https://i.imgur.com/7LAwTUH.png
                                                                                      https://i.imgur.com/rXZKuIl.png
                                                                                      Ответить
                                                                                      • Ну вот, а я против «шума», потому что у меня от гула вентиляторов болит голова и хочется убивать. Для бесшумных (и бульмень мощных, а не чтоб «Excel» работал) сборок гробы подходят лучше всего.
                                                                                        Ответить
                                                                                        • Я тоже против шума, по этому у меня наушники KZ AS12 и вообще похуй, не один внешний шумовой раздражитель тебе не будет слышен.
                                                                                          Ответить
                                                                                          • Всё время сидеть за компом в наушниках? Да ты же поехавший!
                                                                                            Ответить
                                                                                            • Не все время, но обычно когда ты не в наушниках - значит ты не пользуешься компом в полную силу.
                                                                                              Ответить
                                                                                              • Ты что, и играть предпочитаешь в наушниках? Точно поехавший.
                                                                                                Ответить
                                                                                                    • ушам пиздец, да

                                                                                                      но звук бывает разный. в нормальных наушниках нормальный и звук
                                                                                                      Ответить
                                                                                                      • Любые наушники всё равно сосут даже у обычны