101 игра на python. Вопросы собеседований. 11 - 20⁠⁠

Вопросы 👉 1 - 10

Вопрос 11.

В Python имена переменных чувствительны к регистру, что означает, что variable и Variable считаются интерпретатором разными. Учитывая эту информацию, какое из следующих утверждений будет верным, если variable и Variable были определены как целые числа в сценарии Python?

A. print(variable) и print(Variable) выведут одинаковое значение, если обе переменные имеют одно и то же значение.

B. Произойдет ошибка, сообщающая, что имена переменных не могут быть похожими, за исключением их регистра.

C. Python автоматически перезапишет значение первой переменной (variable) значением второй (Variable) во всем сценарии.

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

Вопрос 12.

Python поддерживает несколько типов данных, и строки являются одним из наиболее часто используемых. При рассмотрении целого числа (int), числа с плавающей точкой (float) и строкового (str) типов данных, какой из следующих фрагментов кода правильно преобразует строковое представление числа в число с плавающей точкой и впоследствии добавляет его к целому числу перед выводом результата?

Вопрос 13.

Учитывая динамическую систему типизации Python, какой из следующих фрагментов кода демонстрирует гибкость присваивания типов в Python, позволяя переназначать переменные на различные типы данных в пределах одного и того же сценария?

Вопрос 14.

Функции Python определяются с помощью ключевого слова def, за которым следует имя функции и круглые скобки. Какое из следующих определений включает параметр по умолчанию, позволяя вызывать функцию с меньшим количеством аргументов, чем определено параметров?

Вопрос 15.

При итерировании по списку в Python для вычисления суммы его элементов, какая из следующих конструкций цикла правильно сформулирована, чтобы избежать ошибки IndexError и успешно вычислить общую сумму?

Вопрос 16.

Каков будет вывод следующего фрагмента кода Python при его выполнении?

A. Welcome to Python programming where the value of y is 15 э

B. Ошибка из-за несовместимых типов данных

C. Welcome to Python programming where the value of y is y

D. Ничего из вышеперечисленного

Вопрос 17.

Каково будет поведение следующей Python функции?

A. Функция возвращает "Even" только если n делится на 2 и 3.

B. Функция возвращает "Divisible by 3" для всех чисел, делящихся на 3, независимо от того, являются ли они четными.

C. Функция возвращает "Even" для всех четных чисел, и "Divisible by 3" для чисел не четных, но делящихся на 3.

D. Функция не может вернуть "Other".

Вопрос 18.

Дан следующий код модификации списка Python, каков будет окончательный вывод?

A. [5, 7, 9, 11, 13]

B. [2, 4, 6, 8, 10]

C. [3, 6, 9, 12, 15]

D. [5, 7, 9, 11, 15]

Вопрос 19.

Рассмотрите выполнение следующих операций над словарем Python. Каково состояние словаря person после завершения всех операций?

A. {'name': 'Alice', 'age': 26, 'city': 'New York'}

B. {'age': 26}

C. {'age': 26, 'city': 'New York'}

D. {'name': 'Alice', 'city': 'New York'}

Вопрос 20.

Каков будет результат выполнения следующего цикла Python и условных операторов?

A. ['2 is even', '4 is divisible by 4', '6 is even', '8 is divisible by 4', '10 is even']

B. ['1 is odd', '2 is even', '3 is odd', '4 is divisible by 4', '5 is odd', '6 is even', '7 is odd', '8 is divisible by 4', '9 is odd', '10 is even']

C. ['2 is even', '4 is even', '6 is even', '8 is even', '10 is even']

D. ['2 is divisible by 4', '4 is divisible by 4', '6 is divisible by 4', '8 is divisible by 4', '10 is divisible by 4']

Ответы

• 11. Правильный ответ: A

  Объяснение:

  В Python идентификаторы (включая имена переменных) чувствительны к регистру. Это означает, что variable и Variable воспринимаются интерпретатором как две совершенно разные переменные.

  • Вариант A верен: Если обе переменные, variable и Variable, имеют одно и то же числовое значение, их вывод функцией print() покажет это значение, не зависимо от имени переменной. Python не будет рассматривать их как одну и ту же переменную из-за различий в регистре.

  • Вариант B не верен: Python не выдаст ошибку, что имена переменных не могут быть похожими, за исключением их регистра. Python интерпретирует их как две отдельные переменные.

  • Вариант C не верен: Python не будет автоматически перезаписывать значение variable значением Variable . Они будут существовать как две отдельные переменные.

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

  Пример:

В результате:

Как видно из примера, variable и Variable являются двумя разными переменными, даже если они имеют похожее написание с разными регистрами и вначале содержали одинаковое значение. Когда мы меняем значение Variable, значение переменной variable не изменяется.

Таким образом, вариант A является верным, потому что он точно описывает поведение Python в отношении переменных, чувствительных к регистру.

• 12. Правильный ответ: B

Объяснение:

• Преобразование типов: Python позволяет преобразовывать значения из одного типа данных в другой с помощью специальных функций.

• int(): Преобразует строку или число в целое число.

• float(): Преобразует строку или число в число с плавающей точкой.

• str(): Преобразует значение любого типа в строку.

Теперь проанализируем каждый вариант:

• Вариант A: result = int("10.5") + 5; print(result) - Неправильный вариант, потому что функция int() не может напрямую преобразовать строку "10.5" в целое число, так как она содержит десятичную часть. Это вызовет ошибку ValueError.

• Вариант B: result = float("10.5") + 5; print(result) - Это правильный вариант. Функция float() корректно преобразует строку "10.5" в число с плавающей точкой 10.5. Затем к этому числу добавляется целое число 5, и результат (число с плавающей точкой 15.5) выводится на экран.

• Вариант C: result = str(10.5 + 5); print(result) - Неправильный вариант, потому что здесь сначала складываются 10.5 и 5, а затем результат 15.5 преобразуется в строку. Вместо числа с плавающей точкой мы получим строку "15.5".

• Вариант D: result = "10.5" + str(5); print(result) - Неправильный вариант, потому что здесь строка "10.5" конкатенируется со строкой "5", в результате получается строка "10.55". Не происходит ни преобразования в число с плавающей точкой, ни сложения.

Пример:

В результате:

• Вариант B успешно преобразует строку "10.5" в float, складывает с 5 и выводит результат как 15.5 с типом float.

• Вариант A вызывает ошибку, так как невозможно преобразовать строку "10.5" в int.

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

• 13. Правильный ответ: A

Объяснение:

Динамическая типизация в Python означает, что тип переменной не нужно объявлять явно, и он может изменяться в процессе выполнения программы. Это позволяет переменной сначала хранить значение одного типа (например, целое число), а затем значение другого типа (например, строку) без ошибок.

• Вариант A: x = 10; x = "ten"; print(x) - Это правильный вариант. Сначала переменной x присваивается целое число 10, а затем ей же присваивается строка "ten". Python позволяет это, демонстрируя гибкость динамической типизации.

• Вариант B: x = 10; x = x + "10"; print(x) - Этот вариант приведет к ошибке, потому что вы пытаетесь сложить целое число со строкой. Python не выполняет неявное преобразование типов, поэтому возникнет ошибка TypeError.

• Вариант C: x = "10"; x = int(x); x = x + 10; print(x) - Этот вариант сначала присваивает строковое значение "10" переменной x, затем преобразует его в целое число и присваивает переменной x новое значение, а затем складывает с целым числом 10. Это не демонстрирует изменение типа в течение времени, так как x будет int на протяжении 2х последних операций.

• Вариант D: x = "10"; x = int(x); x = x + "10"; print(x) - Этот вариант похож на вариант C, но последняя операция снова использует строку, что приведет к ошибке TypeError, поскольку вы пытаетесь сложить целое число со строкой.

Пример:

В результате:

• Вариант A успешно демонстрирует, как переменная x меняет тип с int на str в процессе выполнения программы.

• Вариант B вызывает TypeError, так как Python не может автоматически сложить целое число со строкой.

Таким образом, только вариант A корректно демонстрирует гибкость динамической типизации в Python.

• 14. Правильный ответ: A

Объяснение:

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

• Вариант A: def print_value(x="Hello"): print(x) - это правильное определение функции с параметром по умолчанию. Если при вызове функции print_value() не передать аргумент, переменная x будет использовать значение по умолчанию "Hello".

• Вариант B: def print_value(x, y): print(x) - Это определение функции, которое требует два обязательных параметра.

• Вариант C: def print_value(x, y="Hello", z): print(x + y + z) - Это определение функции содержит синтаксическую ошибку. Параметры со значениями по умолчанию (y) должны стоять после всех параметров без значений по умолчанию (x, z).

• Вариант D: def print_value(x): y = "Hello"; print(x + y) - Это определение функции с одним параметром, но в теле функции создаётся переменная y со строковым значением.

Пример:

В результате:

• В варианте A, функция print_value() может быть вызвана без аргументов, и тогда будет использовано значение "Hello" по умолчанию. Если же передать аргумент, то значение по умолчанию переопределится.

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

Таким образом, вариант A является единственным правильным определением функции с параметром по умолчанию.

• 15. Правильный ответ: B

Объяснение:

Для итерации по элементам списка в Python существует несколько способов. Важно правильно выбрать способ, чтобы избежать ошибок, таких как IndexError, которая возникает при попытке обратиться к несуществующему индексу.

• Вариант A: list_values = [1, 2, 3, 4, 5]; total = 0; for i in range(len(list_values) + 1): total += list_values[i]; print(total) - Неправильный вариант. Цикл for в этом варианте пытается перебрать индексы от 0 до len(list_values), включительно, что приведет к IndexError на последней итерации, потому что индексы списка начинаются с 0 и заканчиваются на len(list_values) - 1.

• Вариант B: list_values = [1, 2, 3, 4, 5]; total = 0; for value in list_values: total += value; print(total) - Это правильный вариант. Цикл for в этом варианте итерирует напрямую по элементам списка, а не по их индексам. Это простой, эффективный и идиоматичный способ итерации по спискам в Python, при котором автоматически перебираются все элементы списка без необходимости использовать индексы.

• Вариант C: list_values = [1, 2, 3, 4, 5]; total = 0; for i in range(1, len(list_values)): total += list_values[i]; print(total) - Неправильный вариант. Этот цикл пропустит первый элемент списка (с индексом 0), поскольку он итерирует по диапазону от 1 до len(list_values) - 1.

• Вариант D: list_values = [1, 2, 3, 4, 5]; total = 0; for i in range(len(list_values) - 1): total += list_values[i]; print(total) - Неправильный вариант. Этот цикл пропустит последний элемент списка (с индексом len(list_values) - 1), поскольку он итерирует до len(list_values) - 2.

Пример:

В результате:

• Вариант B успешно итерирует по всем элементам списка, суммирует их и выводит результат 15.

• Вариант A вызовет ошибку IndexError при попытке обратиться к индексу 5, которого нет в списке.

Таким образом, только вариант B корректно и эффективно вычисляет сумму элементов списка.

16. Правильный ответ: A

Объяснение:

В Python оператор + используется для конкатенации (объединения) строк. Однако, он не может быть использован для прямого объединения строк с другими типами данных (например, с целыми числами). В данном коде переменная y является целым числом, поэтому ее необходимо преобразовать в строку, чтобы можно было конкатенировать ее со строковыми литералами и переменной x. Для этого используется функция str().

Разберем код по шагам:

1. x = "Python": переменной x присваивается строковое значение "Python".

2. y = 15: переменной y присваивается целочисленное значение 15.

3. print("Welcome to " + x + " programming where the value of y is " + str(y)):

   • Создается строка "Welcome to ".

   • К этой строке прибавляется строка из переменной x ("Python"), используя оператор +.

   • К полученной строке прибавляется строка " programming where the value of y is ".

   • Переменная y (которая является целым числом) преобразуется в строку с помощью str(y), и далее конкатенируется с предыдущей строкой

   • Итоговая строка выводится на экран.

• Вариант A: Welcome to Python programming where the value of y is 15 - это правильный вывод, так как переменная y правильно преобразована в строку.

• Вариант B: Ошибка из-за несовместимых типов данных. Этот вариант был бы верен, если бы str(y) не было использовано для преобразования integer в строку.

• Вариант C: Welcome to Python programming where the value of y is y - неверный вариант, поскольку переменная y должна быть преобразована в строку, и выведется ее значение, а не имя.

• Вариант D: Ничего из вышеперечисленного - неверный вариант, поскольку вариант А верный

Пример:

В результате:

Код выполнится без ошибок, поскольку целое число y преобразуется в строку перед конкатенацией, и выведет на экран строку Welcome to Python programming where the value of y is 15.

Таким образом, вариант A является правильным ответом.

• 17. Правильный ответ: C

Объяснение:

Функция check_number(n) проверяет число n на соответствие определенным условиям и возвращает строку в зависимости от результата проверки.

• if n % 2 == 0:: Проверяет, является ли число n четным (то есть, делится ли оно на 2 без остатка). Если условие истинно, функция немедленно возвращает строку "Even" и прекращает выполнение.

• elif n % 3 == 0:: Если предыдущее условие ложно (т.е. число n не является четным), проверяется, делится ли n на 3 без остатка. Если это условие истинно, функция возвращает строку "Divisible by 3" и прекращает выполнение.

• else:: Если ни одно из предыдущих условий не выполнилось (т.е. число n не является ни четным, ни кратным 3), функция возвращает строку "Other".

Давайте проанализируем варианты ответов:

• Вариант A не верен: Функция возвращает "Even" если число делится только на 2, а не на 2 и 3.

• Вариант B не верен: Если число четное (делится на 2), то ветка if n % 2 == 0: выполняется первой и функция возвращает "Even", не проверяя делимость на 3.

• Вариант C верен: Именно так работает функция, проверяя сначала на четность и потом на делимость на 3.

• Вариант D не верен: Функция может вернуть "Other", если число не соответствует ни одному из первых двух условий.

Примеры:

В результате:

• check_number(4) возвращает "Even", так как 4 делится на 2.

• check_number(9) возвращает "Divisible by 3", так как 9 нечетное, но делится на 3.

• check_number(7) возвращает "Other", так как 7 не делится ни на 2, ни на 3.

• check_number(6) возвращает "Even", так как 6 делится на 2, и последующие условия не проверяются.

Таким образом, вариант C является единственным верным.

• 18. Правильный ответ: A

Объяснение:

Этот код демонстрирует изменение списка items с помощью цикла for. Вот как работает этот код:

1. Инициализация списка: items = [2, 4, 6, 8, 10] создает список с начальными значениями.

2. Цикл for: for i in range(len(items)): этот цикл итерируется по индексам списка items. Функция range(len(items)) создает последовательность целых чисел от 0 до длины списка минус 1 (0, 1, 2, 3, 4 в данном случае).

3. Изменение элементов: items[i] += 3 добавляет 3 к значению элемента списка по текущему индексу i.

4. Вывод: print(items) выводит измененный список на экран.

Теперь разберем каждый шаг цикла:

• i = 0: items[0] = 2 + 3 = 5

• i = 1: items[1] = 4 + 3 = 7

• i = 2: items[2] = 6 + 3 = 9

• i = 3: items[3] = 8 + 3 = 11

• i = 4: items[4] = 10 + 3 = 13

Пример:

В результате:

Каждый элемент исходного списка items увеличится на 3, что приведет к формированию нового списка [5, 7, 9, 11, 13].

Таким образом, вариант A является верным.

• 19. Правильный ответ: C

Объяснение:

В этом коде происходят следующие операции со словарем person:

1. Инициализация: person = {'name': 'Alice', 'age': 25} - Создается словарь person с начальными ключами-значениями: name: 'Alice' и age: 25.

2. Обновление значения: person['age'] = 26 - Значение ключа 'age' изменяется с 25 на 26.

3. Добавление элемента: person.update({'city': 'New York'}) - Добавляет новую пару ключ-значение 'city': 'New York' в словарь.

4. Удаление элемента: del person['name'] - Удаляет пару ключ-значение с ключом 'name' из словаря.

Давайте проследим за состоянием словаря person после каждой операции:

• Начальное состояние: {'name': 'Alice', 'age': 25}

• После изменения age: {'name': 'Alice', 'age': 26}

• После добавления city: {'name': 'Alice', 'age': 26, 'city': 'New York'}

• После удаления name: {'age': 26, 'city': 'New York'}

Пример:

В результате:

После выполнения всех операций словарь person будет содержать пары ключ-значение {'age': 26, 'city': 'New York'}. Ключ 'name' будет удален, а значение ключа 'age' будет обновлено.

Таким образом, вариант C является верным.

• 20. Правильный ответ: A

Объяснение:

Код выполняет итерацию по списку чисел и добавляет строки в список output в зависимости от условных проверок.

1. Инициализация: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] создает список чисел, а output = [] создает пустой список для хранения строк.

2. Цикл for: for number in numbers: перебирает каждое число в списке numbers.

3. Вложенные условные операторы:

   • if number % 2 == 0:: Проверяет, является ли число четным (делится на 2 без остатка).

   • Если число четное: if number % 4 == 0:: Проверяет, делится ли число на 4.

     • Если число делится на 4, в output добавляется строка вида "{number} is divisible by 4".

     • Если число четное, но не делится на 4, в output добавляется строка вида "{number} is even".

4. Вывод: print(output) выводит список строк.

Теперь проследим как работает код для каждого числа:

• 1: Нечетное, внутренние проверки пропускаются.

• 2: Четное, не делится на 4, добавляется "2 is even".

• 3: Нечетное, внутренние проверки пропускаются.

• 4: Четное, делится на 4, добавляется "4 is divisible by 4".

• 5: Нечетное, внутренние проверки пропускаются.

• 6: Четное, не делится на 4, добавляется "6 is even".

• 7: Нечетное, внутренние проверки пропускаются.

• 8: Четное, делится на 4, добавляется "8 is divisible by 4".

• 9: Нечетное, внутренние проверки пропускаются.

• 10: Четное, не делится на 4, добавляется "10 is even".

Таким образом, список output будет содержать строки, основанные на этих условиях.

• Вариант А: ['2 is even', '4 is divisible by 4', '6 is even', '8 is divisible by 4', '10 is even'] - является правильным ответом, точно отражающим работу кода

• Вариант B не верен: Этот вариант добавляет сообщения для всех чисел, а не только четных.

• Вариант C не верен: Этот вариант добавляет только "is even" для всех четных, и не проверяет делимость на 4.

• Вариант D не верен: Этот вариант добавляет "is divisible by 4" для всех четных, что не правильно.

Пример:

В результате:

Код выведет список строк, как в варианте A: ['2 is even', '4 is divisible by 4', '6 is even', '8 is divisible by 4', '10 is even'].

Таким образом, вариант A является правильным.

Продолжение следует ... Подпишись, чтобы не пропустить

Удачи!