В Python список (list) — одна из наиболее часто используемых структур данных, известная своей способностью хранить последовательность элементов. Что происходит, когда вы используете метод append() в списке, чтобы добавить новый элемент, а затем пытаетесь использовать метод extend(), чтобы добавить другую последовательность к тому же списку?
A. Метод append() добавит каждый символ нового элемента отдельно, а метод extend() создаст новый список внутри существующего списка.
B. Метод append() добавит новый элемент как один элемент в конец списка, а метод extend() будет итерировать по элементам и добавлять каждый из них по отдельности к исходному списку.
C. Оба метода append() и extend() добавят их содержимое одинаковым образом, создав вложенный список внутри исходного списка.
D. Метод append() заменяет существующий список, а метод extend() очищает список перед добавлением новой последовательности.
В Python цикл for очень гибок для итерации по различным итерируемым объектам. Рассмотрим ситуацию, когда у вас есть словарь со строковыми ключами и целочисленными значениями. Какой из следующих вариантов правильно итерирует как по ключам, так и по значениям этого словаря?
A. for key, value in dictionary.items(): print(key, value)
B. for key in dictionary: print(key, dictionary[key])
C. for value in dictionary.values(): print(value)
D. for key in dictionary.keys(): print(key)
Вопрос 3.
В Python области видимости переменных играют важную роль в понимании того, как переменные доступны или изменяются внутри вложенных блоков кода. Если переменная с одним и тем же именем определена как внутри функции, так и вне ее, что произойдет, когда функция попытается изменить эту переменную без какого-либо дополнительного ключевого слова?
A. Функция напрямую изменит глобальную переменную без какой-либо ошибки.
B. Python вызовет ошибку SyntaxError из-за конфликтующих областей видимости переменных.
C. Функция создаст новую локальную переменную с тем же именем, что и глобальная переменная, оставив глобальную переменную без изменений.
D. Глобальная переменная будет перекрыта, и ее значение изменится только тогда, когда функция завершит свою работу.
Вопрос 4.
Python поддерживает несколько типов данных, и строки являются одним из наиболее часто используемых типов данных. Какой из следующих способов является правильным для конкатенации трех строк в Python, гарантируя, что результатом будет одна строка без каких-либо дополнительных пробелов между ними?
A. "Python" + "is" + "awesome"
B. "Python", "is", "awesome"
C. "Python" + " " + "is" + " " + "awesome"
D. "Python".join(["is", "awesome"])
Вопрос 5.
При определении функции в Python можно установить значения параметров по умолчанию, что обеспечивает большую гибкость при вызове функции. Каков будет результат вызова следующей функции: def multiply(a, b=2): return a * b, если функция вызывается как multiply(5)?
B. Функция вызовет TypeError из-за отсутствующего аргумента.
C. Функция вернет 10, так как будет использовано значение по умолчанию b.
D. Функция вернет None, поскольку предоставлен только один параметр.
Вопрос 6.
В Python, какой метод можно использовать для замены частей строки другой строкой, и каков синтаксис этого метода, если вы хотите заменить 'cat' на 'dog' в строке s = "The cat sat on the mat"?
A. s.replaceString('cat', 'dog')
B. s.replace('cat', 'dog')
C. s.stringReplace('cat', 'dog')
D. s.replaceAll('cat', 'dog')
Вопрос 7.
При создании функции в Python, которая вычисляет факториал числа с использованием рекурсии, какое из следующих определений функции реализовано правильно и соответствует принципам рекурсии?
A. def factorial(n): return n * factorial(n-1) if n > 1 else 1
B. def factorial(n): return factorial(n-1) * n if n == 0 else 1
C. def factorial(n): factorial(n-1) * n
D. def factorial(n): return n * factorial(n) if n > 1 else 1
Вопрос 8.
Какое из следующих утверждений о списках Python является истинным, особенно когда речь идет о гибкости типов элементов, которые может содержать список?
A. Списки Python могут содержать только элементы одного и того же типа данных, такие как все целые числа или все строки.
B. Списки Python могут содержать элементы разных типов данных, такие как целые числа, строки и объекты, в одном и том же списке.
C. Списки Python не могут содержать другие типы коллекций, такие как другие списки или словари.
D. Списки Python являются неизменяемыми, то есть после создания их элементы не могут быть изменены.
Вопрос 9.
В Python, как можно эффективно объединить несколько строк, хранящихся в списке с именем strings = ["Python", "is", "awesome"], чтобы сформировать одну строку "Python is awesome"?
C. concatenate(" ", strings)
D. strings.concatenate(" ")
Вопрос 10. Рассмотрите блок кода Python для обработки исключений при попытке преобразовать целое число из пользовательского ввода, используя функцию input(). Какая реализация правильно обрабатывает ввод, который может быть недействительным целым числом, например 'пять', и выводит сообщение об ошибке?
ОТВЕТЫ
Правильный ответ: B
Объяснение:
Метод append(): добавляет свой аргумент как единый элемент в конец списка. Даже если аргументом является другой список или последовательность, они будут добавлены как один вложенный элемент.
Метод extend(): итерирует по элементам своего аргумента и добавляет каждый элемент по отдельности к концу исходного списка. Это означает, что если аргументом является список, каждый элемент этого списка будет добавлен как отдельный элемент в исходный список.
Пример:
append() добавляет 4 и [5, 6] как отдельные элементы.
extend() добавил 7 и 8 как отдельные элементы, а затем разбил строку "910" на символы и добавил их по отдельности.
Таким образом, ответ B является правильным, так как он точно описывает разницу в поведении методов append() и extend() при добавлении элементов в список.
Метод items(): метод словаря items() возвращает view object, который отображает список пар ключ-значение в виде кортежей. Это позволяет одновременно итерировать по ключам и значениям в цикле for.
Метод keys(): метод keys() возвращает view object, содержащий только ключи словаря.
Метод values(): метод values() возвращает view object, содержащий только значения словаря.
Вариант A for key, value in dictionary.items(): print(key, value) правильно итерирует по парам "ключ-значение" словаря, используя метод items().
Вариант B for key in dictionary: print(key, dictionary[key]) работает, но использует прямой доступ к значению через ключ в словаре, а не итерируется по кортежам (key, value).
Варианты C и D итерируют либо только по значениям, либо только по ключам.
Таким образом, ответ A является правильным, поскольку он позволяет одновременно получить доступ и к ключам, и к значениям в цикле for.
Локальные переменные: В Python переменные, объявленные внутри функции, по умолчанию считаются локальными для этой функции. Это означает, что они существуют и доступны только внутри этой функции.
Глобальные переменные: Глобальные переменные - это переменные, объявленные вне функций (на уровне модуля), и они доступны во всем коде модуля.
Изменение глобальных переменных: Если внутри функции используется имя переменной, которое также существует в глобальной области видимости, и при этом не используется ключевое слово global, то Python автоматически создаст локальную переменную с тем же именем внутри этой функции. Это означает, что изменения, произведенные с этой переменной внутри функции, не повлияют на глобальную переменную.
Внутри функции modify_variable создается локальная переменная global_variable со значением 5. Она перекрывает глобальную переменную с тем же именем, но не изменяет её.
Когда функция завершает свою работу, локальная переменная перестает существовать.
После вызова функции, глобальная переменная global_variable сохраняет свое первоначальное значение 10.
Таким образом, ответ C является правильным, так как он точно описывает механизм создания локальной переменной внутри функции при наличии глобальной переменной с тем же именем.
Оператор +: В Python оператор + используется для конкатенации строк. При использовании + между строками они просто объединяются в одну строку без добавления каких-либо дополнительных символов, если они явно не добавлены.
Запятая,: Если строки разделены запятыми, как в варианте B, это создаст кортеж строк, а не конкатенированную строку.
Добавление пробелов: В варианте C пробелы явно добавляются при конкатенации, что приводит к включению пробелов между словами.
Метод join(): Метод join() используется для объединения элементов итерируемого объекта (например, списка) в одну строку, используя строку, к которой применяется метод, в качестве разделителя.
Вариант A "Python" + "is" + "awesome" приводит к правильной конкатенации строк без добавления пробелов между ними.
Вариант B "Python", "is", "awesome" создает кортеж, а не строку.
Вариант C "Python" + " " + "is" + " " + "awesome" добавляет пробелы между строками, что не соответствует условию задания.
Вариант D "Python".join(["is", "awesome"]) использует join, но в данном примере он будет добавлять пробел между is и awesome, и к тому же нужно будет добавить строку "Python" в начало.
Таким образом, ответ A является правильным, так как он точно конкатенирует строки в одну без дополнительных пробелов.
Параметры по умолчанию: В Python можно задавать значения по умолчанию для параметров функции. Это означает, что если при вызове функции аргумент для этого параметра не указан, то будет использовано значение по умолчанию.
Применение значения по умолчанию: Если функция multiply вызывается с одним аргументом, например multiply(5), то переданное значение 5 будет присвоено параметру a, а для параметра b будет использовано значение по умолчанию, которое равно 2.
Результат: Функция вернет результат умножения переданного значения a на значение по умолчанию b, то есть 5 * 2 = 10.
При вызове multiply(5) значение 5 присваивается параметру a, а параметр b принимает свое значение по умолчанию 2. Функция возвращает 5 * 2 = 10.
При вызове multiply(5, 3) значение 5 присваивается параметру a, значение 3 присваивается параметру b. Функция возвращает 5 * 3 = 15.
Таким образом, ответ C является правильным, поскольку он точно описывает результат вызова функции multiply(5) с использованием значения по умолчанию для параметра b.
Метод replace(): Метод replace() в Python используется для замены одной подстроки в строке на другую. Его синтаксис: строка.replace(старая_строка, новая_строка).
Неправильные методы: Методы replaceString(), stringReplace(), и replaceAll() не являются стандартными методами строк в Python.
Вариант B s.replace('cat', 'dog') правильно использует метод replace() для замены подстроки 'cat' на 'dog' в строке s.
Варианты A, C, и D используют несуществующие методы, и при их использовании будет вызвана ошибка AttributeError.
Таким образом, ответ B является правильным, поскольку он демонстрирует корректное использование метода replace() и его синтаксис.
Рекурсивная функция: Рекурсивная функция — это функция, которая вызывает саму себя. Важной частью рекурсивной функции является наличие базового случая (base case), который прерывает рекурсию, и рекурсивного случая, который вызывает функцию с измененными входными данными для приближения к базовому случаю.
Факториал: Факториал числа n (обозначается как n!) — это произведение всех натуральных чисел до n. Например, 5! = 5 * 4 * 3 * 2 * 1 = 120.
Правильная реализация рекурсии:
Базовый случай: Для факториала базовым случаем является n = 1 (или n <= 1, включая 0!). В этом случае факториал равен 1.
Рекурсивный случай: Для n > 1, факториал вычисляется как n * factorial(n-1), то есть текущее число умножается на факториал числа, меньшего на единицу.
Проверка условия: Важно чтобы вызов factorial(n-1) был только при n>1, иначе будет бесконечная рекурсия.
Вариант A def factorial(n): return n * factorial(n-1) if n > 1 else 1 правильно реализует рекурсивную функцию для вычисления факториала, с корректным базовым случаем и рекурсивным вызовом.
Вариант B def factorial(n): return factorial(n-1) * n if n == 0 else 1 имеет неправильный базовый случай, который не будет обрабатывать положительные значения n.
Вариант C def factorial(n): factorial(n-1) * n не имеет базового случая и не возвращает значения, что приведет к бесконечной рекурсии и ошибке.
Вариант D def factorial(n): return n * factorial(n) if n > 1 else 1 имеет бесконечную рекурсию, так как вызывает факториал от того же числа а не n-1.
Таким образом, ответ A является правильным, поскольку он содержит корректное определение рекурсивной функции, с базовым случаем и рекурсивным шагом, который уменьшает входные данные и приближает их к базовому случаю.
Списки в Python обладают высокой гибкостью в отношении типов данных, которые они могут содержать. В отличие от массивов в некоторых других языках программирования, списки Python не ограничивают вас хранением только одного типа данных.
Вариант A не верен, потому что в списке могут быть элементы разных типов.
Вариант B верен, поскольку он верно отражает гибкость списков Python.
Вариант C не верен, поскольку списки могут содержать другие коллекции, включая списки и словари.
Вариант D не верен, поскольку списки являются изменяемыми (mutable), то есть после их создания можно изменять их содержимое.
В этом примере мы создали список my_list, который содержит элементы разных типов данных: целое число, строку, другой список и словарь. Кроме того, мы успешно изменили элемент списка, что подтверждает его мутабельность.
Таким образом, вариант B является единственно верным ответом.
В Python для объединения элементов итерируемой структуры (например, списка, кортежа) в одну строку используется метод join() объекта строки. Метод join() принимает в качестве аргумента итерируемый объект и возвращает новую строку, где все элементы объекта соединены строкой, на которой вызывается метод join().
Вариант A является правильным, так как " ".join(strings) корректно использует пробел " " в качестве разделителя для объединения строк в списке strings.
Вариант B некорректен, так как метод join() вызывается у строки-разделителя, а не у списка.
Варианты C и D также некорректны, поскольку в Python нет методов concatenate() у строк или списка.
Метод join() используется для объединения всех строк из списка strings, вставляя между ними пробел. Метод вызывается на строке " ", которая выступает в качестве разделителя. Результатом является строка "Python is awesome".
Таким образом, вариант A является единственным правильным способом объединения строк из списка в одну строку с пробелами в качестве разделителей.
Для обработки исключений, возникающих при попытке преобразования неверного ввода пользователя в целое число (например, при вводе слова вместо числа), используется конструкция try...except.
try блок: содержит код, который может вызвать исключение. В данном случае это попытка преобразования строки, полученной от пользователя, в целое число с помощью функции int().
except блок: содержит код, который выполняется, если в блоке try возникает указанное исключение. В нашем случае это исключение ValueError, которое возникает при неудачной попытке преобразования строки в целое число.
Теперь разберем каждый вариант:
Вариант A: try: num = int(input("Введите число: ")) except ValueError: print("Это не является действительным числом!") - это правильная реализация. Она корректно пытается преобразовать ввод в число, и если возникает ошибка ValueError (например, если пользователь введет "пять"), программа перехватывает исключение и выводит соответствующее сообщение об ошибке.
Вариант B: try: num = int(input("Введите число: ")) if not num: print("Это не является действительным числом!") - содержит синтаксическую ошибку и не сможет обработать исключение. if not num: не будет выполнено, если возникает исключение ValueError, поскольку переменной num не будет присвоено значения.
Вариант C: num = int(input("Введите число: ")) except ValueError: print("Это не является действительным числом!") - отсутствует ключевое слово try для начала блока, который может вызывать исключение, поэтому возникает синтаксическая ошибка.
Вариант D: try: num = int(input("Введите число: ")) catch (ValueError): print("Это не является действительным числом!") - содержит синтаксическую ошибку: ключевое слово catch не используется в Python для обработки исключений, используется except.
В первом примере если ввести "123" - выведется "Вы ввели число: 123". Во втором примере если ввести "пять" - будет перехвачено исключение ValueError, и выведется сообщение "Это не является действительным числом!".
Таким образом, только вариант A корректно обрабатывает исключение ValueError и выводит соответствующее сообщение об ошибке.
