7011
Вопросы и задачки для подготовки к собеседованиям и прокачки навыков Разместить рекламу: @tproger_sales_bot Правила общения: https://tprg.ru/rules Другие каналы: @tproger_channels Другие наши проекты: https://tprg.ru/media
Объяснение:
После выполнения кода a = 3/2, переменная a будет иметь тип данных float
Это происходит потому, что операция деления / всегда возвращает результат с плавающей точкой, даже если оба числа (в данном случае 3 и 2) являются целыми числами
Объяснение:
Здесь lst[:] создаёт новый список, который является копией исходного списка lst
Оператор is, в свою очередь, проверяет, ссылаются ли две переменные на один и тот же объект в памяти
Поскольку lst и lst[:] ссылаются на разные объекты (несмотря на то, что их содержимое одинаково), результатом будет False
Объяснение:
Здесь список l в функции func() является изменяемым объектом и инициализируется только один раз при первом вызове функции
При последующих вызовах, если не передается другой список, используется уже существующий список l, который сохраняет свое состояние между вызовами
В первом вызове func(2) в список добавляются элементы 0 и 1. Во втором вызове func(3, [3,2,1]) используется новый список [3,2,1], к которому добавляются 0, 1, 4
В третьем вызове func(3) снова используется исходный список l, который уже содержит 0 и 1, и к нему добавляются еще 0, 1, 4
Объяснение:
В Python операторы try и except используются для обработки исключений
Код, который может вызвать исключение, помещается в блок try, а код для обработки исключения — в блок except. Это позволяет программе элегантно справляться с ошибками и продолжать выполнение, вместо того чтобы полностью останавливаться при их возникновении
Объяснение:
Функция ord() в Python возвращает числовое представление указанного символа. Например, в ASCII символ 'a' имеет значение 97, а 'c' — значение 99
Когда вычитаем ord('a') из ord('c'), мы фактически вычитаем 97 из 99, что дает 2
Объяснение:
В Python float("nan") создает специальное значение с плавающей точкой, обозначающее "Not a Number" (не число).
При преобразовании любого числа с плавающей точкой, включая NaN (не число), в булев тип (bool), результат всегда будет True, за исключением случая, когда число равно 0.0
Поскольку NaN не является нулем, bool(var) возвращает True
Объяснение:
Когда мы используем print(*lst, sep="1", end="3") с распакованным списком lst, который содержит элементы [1, 2, 3], каждый элемент списка печатается поочерёдно с разделителем 1 между ними
Это даёт 11213
После этого, параметр end="3" добавляет 3 в конец вывода, что делает окончательный результат 112133
Объяснение:
В Python нельзя напрямую складывать переменные разных типов, в данном случае целое число (int) и строку (str)
Переменная var_int является целым числом (2000), а var_str — строкой ("23")
Попытка выполнить операцию var_int + var_str приведет к ошибке, так как Python не знает, как сложить эти два разных типа данных
Объяснение:
В данном форматировании строки с помощью метода .format(), {0:*^9} определяет формат вывода0 указывает на индекс аргумента, который будет подставлен (1234567), * является символом, используемым для заполнения дополнительного пространства, ^ указывает на центрирование значения, а 9 определяет общую ширину поля
Поскольку число 1234567 состоит из 7 цифр и общая ширина поля установлена равной 9, с каждой стороны числа добавляется по одному символу * для достижения общей ширины в 9 символов, в результате чего получается *1234567*
Объяснение:
Логический оператор and возвращает первый операнд, если он ложен (в контексте булевой логики), или второй операнд, если первый истинен
В данном случае, поскольку var1 (который равен 1) является истинным значением (любое ненулевое число в Python считается истинным), результатом выражения var1 and var2 будет значение var2, которое равно 2
Объяснение:
В Python аргументы функций по умолчанию инициализируются только один раз при определении функции
Здесь аргумент itm инициализируется как пустой список [] при первом вызове функции. Поскольку списки являются изменяемыми объектами, каждый вызов hmm() без аргументов приводит к добавлению числа 1 в этот же список
Поэтому после двух вызовов hmm() в цикле for, список содержит два элемента [1, 1]. При третьем вызове hmm() в список добавляется еще одна 1, что приводит к результату [1, 1, 1]
Объяснение:
В данном коде используется оператор распаковки словарей (**) для объединения двух словарей a и b в словарь c
При этом если в обоих словарях есть ключи с одинаковыми значениями, как в данном случае ключи 1 и 2, значение из последнего словаря (b) перезаписывает значение из предыдущего словаря (a)
Поэтому значение c[2], соответствующее ключу 2, будет взято из словаря b, и это значение d
Объяснение:
Вызов функции func() в первом случае (func("Заяц, ты меня слышишь?", times=1)) приведет к выводу строки "Заяц, ты меня слышишь?" один раз, так как аргумент times установлен равным 1
Во втором вызове (func("Слышу ")) аргумент times не указан, поэтому используется значение по умолчанию, равное 2
Это приведет к двойному выводу строки "Слышу ", то есть "Слышу Слышу "
Объяснение:
Здесь переменная num инициализируется значением 100. Затем определяются две функции: func_one() и func2()Обе функции объявляют num как глобальную переменную, но только func2() фактически изменяет её значение на 80Однако ни одна из этих функций не вызывается перед тем, как выводится значение num. Поскольку num не была изменена ни одной из функций (так как они не вызваны), её значение остаётся равным начальному значению 100это значение и будет напечатано
И
Объяснение:
Здесь список lst создается сначала как список целых чисел от 0 до 4. Затем, используя выражение lst[:] = [x for x in lst if x % 2], список модифицируется так, чтобы он содержал только нечетные числа из первоначального списка
Важно отметить, что операция lst[:] = ... изменяет содержимое списка lst на месте, не изменяя сам объект списка, то есть его идентификатор id остается прежним.
Следовательно, id(lst) до и после модификации списка будет одинаковым
Объяснение:
Ключевое слово yield в Python используется в функциях для создания генераторов
Когда функция достигает yield, она возвращает значение и «замораживает» своё состояние
При следующем вызове функции-генератора выполнение продолжается с того места, где оно было приостановлено, позволяя функции последовательно генерировать серию значений, экономя при этом память
Объяснение:
Здесь все до смешного просто: т.к нет print() (или подобного оператора), нет и вывода кода на экран
Объяснение:
Здесь происходит распаковка списка lst, который содержит элементы 1, 2, 3, по переменным a, b, c
Это значит, что a принимает значение 1, b — 2, а c — 3. Затем происходит сложение a + b + c, что равно 1 + 2 + 3 = 6
Таким образом, правильный ответ — 6
Объяснение:
Правильный ответ «список, словарь» связан с тем, что в качестве ключей словаря в Python могут использоваться только неизменяемые (immutable) типы данных
Неизменяемые типы данных не могут быть изменены после их создания. Это обеспечивает стабильность хеша ключа, который используется для определения местоположения значения в словаре
Списки и словари являются изменяемыми (mutable) типами, что означает, что их содержимое может изменяться. И поэтому они не подходят для использования в качестве ключа
Объяснение:
Список lst, содержащий строки '1', '2' и '3', соединяется с помощью метода join() и строки '4'
Этот метод используется для соединения элементов списка в одну строку, разделяя их указанным разделителем. В данном случае разделителем является строка '4'
Объяснение:
Здесь у нас определяется класс TempClass с атрибутом класса var, который инициализирован значением None. В Python None используется для представления отсутствия значения или нулевого состояния
Когда мы обращаемся к атрибуту класса TempClass.var, мы получаем значение этого атрибута, которое в данном случае является None
Это значение было установлено при определении класса и не изменялось, поэтому при печати print(TempClass.var) выводится None
Объяснение:
Функция set() в Python создает множество, которое содержит только уникальные элементы, причем порядок элементов в множестве не гарантирован и не важен
Когда мы преобразуем строки "new" и "wen" в множества, получаем множества с элементами {'n', 'e', 'w'} для обеих строк
Поскольку оба множества содержат одинаковые элементы, они считаются равными, и оператор сравнения == возвращает True
Объяснение:
Злесь создается экземпляр класса Empty, который сохраняется в переменной obj
В Python, экземпляры пользовательских классов по умолчанию всегда считаются истинными (то есть bool(obj) возвращает True), если только в классе не определен специальный метод, который изменяет это поведение
В списке ['new', 'old'] значение по индексу 0 - это new, соответствующее False, а значение по индексу 1 - это old, соответствующее True
Так как bool(obj) возвращает True, выбирается элемент с индексом 1, то есть old
Объяснение:
Здесь мы создаем список lst, который изначально содержит элементы [0, 1, 2]
Затем метод .append(3) добавляет число 3 в конец списка, делая его [0, 1, 2, 3]
После этого метод .extend([4, 5]) расширяет список lst, добавляя элементы списка [4, 5] в его конец. Это приводит к окончательному списку [0, 1, 2, 3, 4, 5]
Объяснение:
Ответ будет "Шла". В данном примере tup = "Шла", "Саша", "по Шоссе" создает кортеж (tuple) из трех элементов
Когда эти элементы распаковываются в переменные var1, var2, var3, каждой переменной присваивается соответствующий элемент кортежаvar1 получает первый элемент кортежа, который является строкой "Шла". Поэтому при выводе print(var1), отображается значение "Шла"
Объяснение:
Тут все достатоно просто: int(21) преобразует число 21 в целое число (что не изменяет его значение, так как оно уже является целым), а float(21) * 0 преобразует 21 в вещественное число и умножает его на 0, что дает 0.0.
Сумма 21 (целое число) и 0.0 (вещественное число) в Python дает вещественное число 21.0
Объяснение:
В Python 3.6 и более поздних версиях, подчеркивания (_) действительно могут использоваться как визуальные разделители для улучшения читаемости чисел, включая как целые числа, так и числа с плавающей точкой
В таком случае строка "20_23" будет интерпретироваться как 2023.0 при преобразовании во вещественное число с помощью функции float()
Это происходит потому, что подчеркивание игнорируется, и строка интерпретируется как 2023, которое затем конвертируется в вещественное число 2023.0
Объяснение:
Этот код вызовет ошибку из-за использования оператора break вне цикла
В Python оператор break используется для выхода из цикла (for или while), и его нельзя использовать вне этих контекстов
Объяснение:
В первой строке переменным var1, _, var2 присваиваются значения 3, 2 и 1 соответственно
Здесь _ является просто именем переменной и получает значение 2. При вычислении выражения (var1 + var2) / _, мы имеем (3 + 1) / 2, что равно 4 / 2, что в итоге даёт 2.0
Объяснение:
Вызов функции func(3.0) приведет к ошибке типа TypeError, так как передается вещественное число (с плавающей запятой), а функция range в Python требует целочисленного аргумента
В данной функции seq += 1 увеличивает значение аргумента seq на 1, но если seq изначально является вещественным числом, как в данном случае, то результат этой операции также будет вещественным числом