Вопросы и задачки для подготовки к собеседованиям и прокачки навыков Разместить рекламу: @tproger_sales_bot Правила общения: https://tprg.ru/rules Другие каналы: @tproger_channels Другие наши проекты: https://tprg.ru/media
Объяснение:
Здесь происходит распаковка списка 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
изначально является вещественным числом, как в данном случае, то результат этой операции также будет вещественным числом
Объяснение:
Команда assert
в Python используется для проверки истинности утверждения. Если утверждение истинно, выполнение программы продолжается, если нет — возникает исключение AssertionError
В данном случае, утверждение True
является истинным, поэтому assert True, False
не вызовет ошибки и программа будет выполнена без прерываний
Вторая часть после запятой (False
) в этом контексте — это сообщение об ошибке, которое будет показано в случае, если утверждение ложно, но поскольку утверждение истинно, это сообщение игнорируется
Объяснение:
Внутри функции num_print()
, цикл while
продолжает выполняться, пока num
больше 0
. Однако, уменьшение значения num
(num -= 1
) расположено вне блока цикла while
, из-за чего num
никогда не уменьшается внутри цикла
Это означает, что условие num > 0
всегда остается истинным и цикл продолжает выполняться бесконечно, печатая Hi
на каждой итерации
Объяснение:
В 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)
до и после модификации списка будет одинаковым
Объяснение:
Ответ False
для числа 20
и True
для числа 21
В данном коде лямбда-функция проверяет, является ли число нечетным, возвращая True
, если остаток от деления числа на 2
равен 1
(что означает, что число нечетное), и False
, если остаток равен 0
(что означает, что число четное)
Число 20
— четное, поэтому остаток от деления на 2
равен 0
, а число 21
нечетное, поэтому остаток равен 1
Объяснение:
В этом коде переменная color
инициализируется шестнадцатеричным значением 0x2B_52_75
В Python шестнадцатеричные числа начинаются с 0x
, а символ _
используется для удобства чтения и не влияет на значение числа
Когда функция print(hex(color))
вызывается, она конвертирует это шестнадцатеричное число обратно в строковое шестнадцатеричное представление
Поскольку подчеркивания (_
) игнорируются при интерпретации числа, результатом будет строка '0x2b5275'
, представляющая исходное шестнадцатеричное число без подчеркиваний и в нижнем регистре
Объяснение:
В этом коде переменные x
и y
меняются местами, но с использованием дополнительного шага
Сначала создается кортеж (y, x)
, который равен (-5, 5)
. Затем этот кортеж инвертируется с использованием среза [::-1]
, что приводит к (5, -5)
После этого переменным x
и y
присваиваются значения этого инвертированного кортежа, таким образом x
становится равным 5 и y равным -5