Серия «Вопросы собеседований - разработчик python 1 - 100»

• A. 1

• B. 5

• C. 120

• D. Вызовет ошибку переполнения стека.

Вопрос 83. Что произойдет, если не указать тип исключения в блоке except конструкции try-except в Python?

• A. Блок except пропустит все исключения.

• B. Блок except перехватит все исключения, независимо от их типа.

• C. Программа немедленно завершится с ошибкой.

• D. Блок except обработает только исключения типа Exception.

Вопрос 84. Какой результат будет получен при выполнении следующего кода Python?

• A. True True True True

• B. True False True False

• C. False True False True

• D. True True False True

Вопрос 85. Что делает ключевое слово continue в цикле?

• A. Немедленно выходит из цикла.

• B. Пропускает оставшуюся часть кода внутри цикла для текущей итерации.

• C. Приостанавливает выполнение цикла.

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

Вопрос 86. Как создать множество (set) в Python?

• A. set = {1, 2, 3}

• B. set = [1, 2, 3]

• C. set = (1, 2, 3)

• D. set = '123'

Вопрос 87. Что делает функция dict() в Python?

• A. Создает новый словарь.

• B. Преобразует кортеж в словарь.

• C. Преобразует список кортежей в словарь.

• D. Оба варианта A и C верны.

Вопрос 88. Каково назначение блока else в инструкции try...except?

• A. Выполнить код после блока try, если не было выброшено ни одного исключения.

• B. Обработать исключение, если блок except не смог его обработать.

• C. Всегда выполняться после блока try, независимо от того, было ли выброшено исключение или нет.

• D. Проверить дополнительное условие после блоков try и except.

Вопрос 89. Что такое "магические методы" (magic methods) в Python и для чего они нужны?

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

• B. Это методы, которые могут изменять внутреннее состояние объектов, но не видны при вызове.

• C. Это методы, имена которых начинаются и заканчиваются двойным подчеркиванием, и которые вызываются неявно встроенными функциями или синтаксическими конструкциями.

• D. Это методы, которые используются для отладки программ и вывода информации о переменных.

Вопрос 90. В чем разница между == и is в Python?

• A. == проверяет равенство по значению, тогда как is проверяет равенство в области памяти.

• B. == проверяет, указывают ли переменные на один и тот же объект, тогда как is проверяет равенство значения.

• C. == используется для строк, а is — для чисел.

• D. Разницы нет; оба используются взаимозаменяемо.

Ответы

81. Правильный ответ: B. Используя оператор +

Объяснение:

В Python для объединения двух списков в один новый список используется оператор +. Этот оператор создает новый список, содержащий все элементы первого списка, за которыми следуют все элементы второго списка.

• Оператор +:

  • Создает новый список, который является результатом объединения двух исходных списков.

  • Исходные списки не изменяются.

Разбор вариантов:

• Используя оператор *: Неправильно. Оператор * используется для повторения списка определенное количество раз.

• Используя оператор +: Правильно. Оператор + используется для конкатенации (объединения) списков.

• Используя метод append(): Неправильно. Метод append() добавляет один элемент в конец существующего списка, а не объединяет два списка.

• Используя метод concat(): Неправильно. В Python нет встроенного метода concat() для списков.

Пример конкатенации списков с оператором +:

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

• Оператор + является наиболее простым и распространенным способом объединения списков в Python.

• Исходные списки не изменяются, а создается новый список, который содержит все элементы двух исходных списков.

• Конкатенация списков через + может быть менее эффективной для больших списков.

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

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

Объяснение:

Данный код реализует рекурсивную функцию для вычисления факториала числа. Функция my_function(n) возвращает n! (факториал n).

• Базовый случай: Если n равно 0, функция возвращает 1 (факториал 0 равен 1).

• Рекурсивный случай: Если n больше 0, функция возвращает n умноженное на результат вызова самой себя с n-1.

Таким образом, вызов my_function(5) будет выполнен следующим образом:

my_function(5) = 5 * my_function(4)
my_function(4) = 4 * my_function(3)
my_function(3) = 3 * my_function(2)
my_function(2) = 2 * my_function(1)
my_function(1) = 1 * my_function(0)
my_function(0) = 1

Подставляя значения снизу вверх, получаем:

1 * 1 * 2 * 3 * 4 * 5 = 120

Следовательно, результат вызова print(my_function(5)) будет 120.

Дополнительные замечания:

• Рекурсивные функции должны иметь условие выхода из рекурсии, чтобы избежать бесконечного вызова функций и ошибки переполнения стека.

• Данная рекурсивная реализация факториала вполне подходит для небольших чисел, но для очень больших чисел может быть менее эффективна, чем итеративная реализация. Вот пример итеративной реализации факториала:

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

Объяснение:

Если вы не укажете тип исключения в блоке except, то он будет действовать как обработчик для всех исключений, которые могут возникнуть в блоке try. Это может быть полезно для отлова любых непредвиденных ошибок, но в некоторых ситуациях это может помешать в точной отладке кода, поскольку будет трудно определить тип произошедшей ошибки.

• Вариант A не верен: Блок except не пропускает исключения.

• Вариант B верен: Блок except без указания типа перехватывает любое исключение.

• Вариант C не верен: Программа не завершится при перехвате исключения.

• Вариант D не верен: Исключения класса Exception обрабатываются только, если они указаны явно.

Пример:

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

• В первом примере блок except перехватывает исключение ZeroDivisionError.

• Во втором примере, первое except перехватывает ValueError, а второе except не будет выполняться, так как исключение уже было обработано.

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

84. Правильный ответ: D

Объяснение:

Код проверяет, являются ли два слова анаграммами (состоят из одних и тех же букв, но в разном порядке).

1. Функция anagram(word1, word2):

   • Преобразует оба слова в нижний регистр (lower()).

   • Сортирует буквы каждого слова (sorted()).

   • Если отсортированные буквы одинаковы, возвращает True (слова - анаграммы), иначе False.

2. Результаты вызовов:

   • "cinema" и "iceman": Анаграммы. sorted("cinema") == sorted("iceman") -> True

   • "cool" и "loco": Анаграммы. sorted("cool") == sorted("loco") -> True

   • "men" и "women": Не анаграммы. sorted("men") != sorted("women") -> False

   • "python" и "pythno": Анаграммы. sorted("python") == sorted("pythno") -> True

Таким образом, вывод программы: True True False True.

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

Объяснение:

Ключевое слово continue в Python используется внутри циклов (например, for и while) для пропуска оставшейся части текущей итерации и перехода к следующей итерации цикла.

• Вариант A не верен: continue не прерывает цикл, а только текущую итерацию. Для прерывания цикла используется break.

• Вариант B верен: continue пропускает оставшийся код в текущей итерации и переходит к следующей.

• Вариант C не верен: continue не приостанавливает выполнение цикла.

• Вариант D не верен: Вариант B верен.

Как работает continue:

1. Когда интерпретатор Python встречает continue внутри цикла, он пропускает все оставшиеся операторы текущей итерации.

2. Выполнение программы переходит к следующей итерации цикла, то есть условие в while или следующему элементу в for цикле.

3. Пропуск итерации происходит только для текущей итерации, остальные итерации цикла работают как обычно.

Типичные примеры использования:

1. Пропуск определенной итерации: Когда нужно пропустить определенные итерации, основываясь на каком-то условии.

2. Фильтрация данных: Когда нужно пропустить некоторые элементы в итерируемой структуре.

Пример:

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

• В цикле for выводятся только нечетные числа, так как continue пропускает итерацию для четных чисел.

• В цикле while выводятся все числа, кроме тех что делятся на 3.

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

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

Объяснение:

В Python множество (set) создается с использованием фигурных скобок {}, в которые помещаются уникальные, хешируемые элементы.

• Вариант A верен: set = {1, 2, 3} - это корректный способ создания множества.

• Вариант B не верен: set = [1, 2, 3] - создает список (list), а не множество.

• Вариант C не верен: set = (1, 2, 3) - создает кортеж (tuple), а не множество.

• Вариант D не верен: set = '123' - создает строку (str), а не множество.

Ключевые характеристики множества (set):

1. Уникальность элементов: Множество содержит только уникальные элементы, дубликаты автоматически удаляются.

2. Неупорядоченность: Элементы в множестве не хранятся в каком-либо определенном порядке.

3. Мутабельность: Множества являются изменяемыми, что позволяет добавлять и удалять элементы после создания множества.

Пример:

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

• my_set = {1, 2, 3} создает множество, содержащее целые числа 1, 2 и 3.

• При создании множества my_set_dupl дубликаты автоматически удаляются.

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

87. Правильный ответ: D

Объяснение:

Функция dict() в Python используется для создания словаря. Она может принимать разные типы аргументов для этого.

• Вариант A верен: dict() может быть вызвана без аргументов и создаст пустой словарь.

• Вариант B не верен: Функция dict() не преобразует кортеж в словарь. Кортеж должен содержать пары ключ значение, чтобы был создан словарь.

• Вариант C верен: dict() может преобразовать список кортежей, где каждый кортеж представляет собой пару ключ-значение, в словарь.

• Вариант D верен: Так как и A, и C верны.

Как работает dict():

1. Без аргументов: Если dict() вызывается без аргументов, он создает пустой словарь.

2. С аргументами:

   • Если dict() вызывается с одним аргументом — списком кортежей, где каждый кортеж состоит из двух элементов (ключа и значения) то он создаст словарь из этих пар ключ-значение.

   • Можно передать и другие аргументы (именованные аргументы), которые станут ключами и значениями.

Примеры:

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

• dict() без аргументов создает пустой словарь.

• dict(my_list) создает словарь из списка кортежей.

• dict(a=1, b=2, c=3) создает словарь с ключами "a","b","c" и соответсвующими значениями.

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

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

Объяснение:

В Python блок else в конструкции try...except выполняется только в том случае, если блок try выполнился без возникновения исключений.

• Вариант A верен: else выполняется, если блок try завершился успешно без исключений.

• Вариант B не верен: Если except не может обработать исключение, программа аварийно завершится. else не предназначен для обработки исключений, которые не поймал except.

• Вариант C не верен: Для действий, которые выполняются всегда, независимо от наличия исключений, используется блок finally, а не else.

• Вариант D не верен: Блок else не проверяет дополнительные условия, он просто выполняется при успешном выполнении блока try.

Как работает try...except...else:

1. Сначала выполняется код в блоке try.

2. Если в блоке try возникает исключение, то управление переходит в блок except (если есть соответствующий тип исключения) или далее по цепочке.

3. Если в блоке try не возникает исключения, то выполняется блок else, который расположен после всех блоков except.

4. Блок finally выполняется всегда вне зависимости от того, было ли исключение или нет.

Пример:

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

• При вызове process_number(2) ошибок нет и выполняется блок else, выводя "Результат деления: 5.0".

• При вызове process_number(0) происходит ZeroDivisionError и код переходит в блок except, выводя "Ошибка: деление на ноль" и не выполняя блок else.

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

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

Объяснение:

"Магические методы" (также известные как "dunder methods" от "double underscore") в Python - это специальные методы, которые имеют предопределенные имена, начинающиеся и заканчивающиеся двумя подчеркиваниями (например, __init__, __len__, __add__). Они используются для определения поведения объектов при применении к ним встроенных функций, операторов или синтаксических конструкций.

• Определение:

  • Магические методы имеют имена вида __имя__.

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

• Назначение:

  • Позволяют объектам вести себя как встроенные типы данных.

  • Позволяют переопределять поведение операторов и функций для пользовательских типов.

  • Реализуют поддержку протоколов и концепций Python, таких как итерация, сложение, сравнение, строковое представление и т.д.

Примеры:

• __init__(self, ...): Вызывается при создании нового объекта (конструктор).

• __len__(self): Вызывается функцией len().

• __add__(self, other): Вызывается оператором сложения +.

• __str__(self): Вызывается функцией str() или при использовании print().

• __repr__(self): Вызывается функцией repr().

• __iter__(self) и __next__(self): Используются для реализации итераторов.

• __getitem__(self, key): Вызывается при доступе к элементу по индексу obj[key].

Разбор вариантов:

• A. Это методы, которые вызываются только в особых ситуациях, например, при обработке исключений: Неправильно. Хотя некоторые магические методы связаны с исключениями (__enter__, __exit__), их основное применение шире.

• B. Это методы, которые могут изменять внутреннее состояние объектов, но не видны при вызове: Неправильно. Магические методы не только могут изменять состояние, но и вызываются неявно, а не скрыты.

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

• D. Это методы, которые используются для отладки программ и вывода информации о переменных: Неправильно. Хотя __str__ и __repr__ могут использоваться для вывода информации, это не их основное назначение.

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

• Магические методы позволяют создавать гибкие и выразительные классы, которые могут взаимодействовать с Python как встроенные типы.

• Они лежат в основе многих возможностей Python, позволяя переопределять поведение объектов для различных операций.

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

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

Объяснение:

В Python операторы == и is используются для сравнения, но они делают это по-разному:

• == (равно): Этот оператор сравнивает значения объектов. Он возвращает True, если значения объектов равны, и False в противном случае.

• is (является): Этот оператор сравнивает идентичность объектов. Он возвращает True, если обе переменные указывают на один и тот же объект в памяти, и False в противном случае.

• Вариант A верен: == проверяет равенство значений, а is проверяет идентичность (указывают ли переменные на один и тот же объект в памяти).

• Вариант B не верен: Наоборот, == проверяет равенство значений, а is проверяет идентичность.

• Вариант C не верен: == и is используются для любого типа данных.

• Вариант D не верен: == и is не взаимозаменяемы, у них разное назначение.

Подробное объяснение:

• ==: Сравнивает значения объектов, используя метод __eq__(), который может быть переопределен для пользовательских классов.

• is: Сравнивает идентификаторы объектов, то есть адреса памяти. Если две переменные ссылаются на один и тот же объект в памяти, то is вернет True.

Пример:

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

• a и b содержат списки с одинаковыми значениями, поэтому a == b дает True, но это два разных объекта в памяти, поэтому a is b дает False.

• a и c ссылаются на один и тот же объект, поэтому a is c возвращает True

• Для небольших чисел Python может создавать одинаковые объекты в памяти, для оптимизации работы, поэтому для num3 и num4 оператор is вернул True.

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

Удачи!

Вопрос 93. Какой из следующих вариантов не является допустимым идентификатором Python?

• A. _myvar

• B. 2myvar

• C. my_var

• D. myVar

Вопрос 94. Каков вывод следующего фрагмента кода?

• A. Pythonisawesome

• B. Python is awesome

• C. ['Python', 'is', 'awesome']

• D. None

Вопрос 95. Как в Python управляется память?

• A. Только с помощью ручного управления памятью.

• B. С использованием частной кучи, содержащей все объекты Python и структуры данных.

• C. Исключительно через операционную систему.

• D. С помощью модели распределения памяти стека.

Вопрос 96. Что упрощает оператор with в Python?

• A. Обработку ошибок

• B. Операции чтения и записи файлов

• C. Синтаксис объявлений функций

• D. Реализацию циклов

Вопрос 97. Что делает ключевое слово yield в Python?

• A. Завершает функцию.

• B. Возвращает значение из функции и приостанавливает ее состояние.

• C. Предотвращает выполнение цикла.

• D. Пропускает текущую итерацию цикла.

Вопрос 98. Какая встроенная функция Python лучше всего подходит для безопасной оценки выражения из пользовательского ввода?

• A. eval()

• B. exec()

• C. input()

• D. ast.literal_eval()

Вопрос 99. В Python, что делает декоратор @classmethod с методом?

• A. Он преобразует метод в статический метод, который принадлежит классу.

• B. Он ограничивает метод, чтобы его нельзя было переопределить в подклассах.

• C. Он позволяет вызывать метод у самого класса, а не только у экземпляров класса.

• D. Он делает метод приватным, так что к нему нельзя получить доступ извне класса.

Вопрос 100. Каков результат следующей операции с использованием метода update() словаря Python?

Что будет содержать dict1 после обновления?

• A. {'a': 1, 'b': 2, 'c': 4}

• B. {'a': 1, 'b': 3, 'c': 4}

• C. {'b': 3, 'c': 4}

• D. {'a': 1, 'b': 2}

Ответы

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

Объяснение:

В Python, когда оператор * применяется к списку, он используется для создания нового списка путем повторения исходного списка указанное количество раз.

• Вариант A верен: Оператор * повторяет список указанное количество раз, создавая новый список.

• Вариант B не верен: Для удаления элементов используется clear(), del и другие методы, а не оператор *.

• Вариант C не верен: Для умножения каждого элемента списка используется списковое включение с использованием цикла.

• Вариант D не верен: Оператор * создает новый список, а не указатель.

Как работает * со списками:

1. Оператор * берет список (левый операнд).

2. Он повторяет его содержимое указанное число раз (правый операнд).

3. Возвращает новый список.

Пример:

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

• my_list * 2 повторяет элементы списка my_list дважды, создавая новый список [1, 2, 3, 1, 2, 3].

• my_list * 3 повторяет элементы списка my_list трижды, создавая новый список [1, 2, 3, 1, 2, 3, 1, 2, 3].

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

92, Правильный ответ: D

Объяснение:

Существует несколько способов преобразования списка целых чисел в список строк в Python.

• Вариант A верен: Функция str() может быть применена к каждому элементу списка по отдельности для преобразования в строку.

• Вариант B верен: Функция map() позволяет применить функцию str() к каждому элементу списка, что эффективно преобразует все элементы в строки.

• Вариант C не верен: Конкатенация с пустой строкой, не всегда будет корректно работать с числами (нужно использовать функцию str()).

• Вариант D верен: Так как варианты A и B верны.

Как это работает:

1. str(): Функция str() принимает на вход любой объект и преобразует его в строковое представление.

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

3. map(): Функция map() принимает функцию и итерируемый объект (список) и применяет эту функцию к каждому элементу списка.

4. Списковое включение: Также можно использовать списковое включение с преобразованием типов.

Примеры:

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

• Все три способа (цикл, map() и списковое включение) приведут к созданию списка строк.

• Конкатенация с пустой строкой работает, но выглядит менее читаемо.

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

93, Правильный ответ: B

Объяснение:

Идентификаторы в Python — это имена, используемые для обозначения переменных, функций, классов и других объектов. Существуют определенные правила для создания допустимых идентификаторов.

• Вариант A верен: _myvar является допустимым идентификатором. Он начинается с подчеркивания, за которым следуют буквы.

• Вариант B не верен: 2myvar является недопустимым идентификатором. Он начинается с цифры.

• Вариант C верен: my_var является допустимым идентификатором. Он начинается с буквы и содержит буквы и подчеркивания.

• Вариант D верен: myVar является допустимым идентификатором. Он начинается с буквы и может содержать буквы в разных регистрах.

Правила для идентификаторов Python:

1. Начинаются с буквы или подчеркивания: Идентификаторы должны начинаться с буквы (a-z, A-Z) или подчеркивания _.

2. Содержат буквы, цифры или подчеркивания: После первого символа идентификаторы могут содержать буквы, цифры (0-9) и подчеркивания.

3. Регистрозависимые: myVar, MyVar и MYVAR будут разными идентификаторами.

4. Не могут быть ключевыми словами: Нельзя использовать ключевые слова Python (например, if, else, for, while, def, class и т. д.) в качестве идентификаторов.

Пример:

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

_myvar, my_var и myVar являются допустимыми идентификаторами, а 2myvar вызывает ошибку синтаксиса, так как начинается с цифры.

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

94, Правильный ответ: A

Объяснение:

В Python метод join() используется для объединения элементов итерируемой структуры (например, списка строк) в одну строку с помощью разделителя. В данном случае метод join() вызывается у пустой строки '', что означает, что все элементы списка x будут соединены без каких-либо разделителей.

• Вариант A верен: join() без разделителя объединит все строки в одну: "Pythonisawesome"

• Вариант B не верен: join() с пробелом как разделителем выведет "Python is awesome", а не в данном примере.

• Вариант C не верен: Функция join() не вернет список, а строку.

• Вариант D не верен: Функция join() не вернет None.

Как работает join():

1. Метод join() вызывается у объекта строки (разделителя).

2. Он принимает итерируемый объект (список, кортеж, множество) в качестве аргумента.

3. Он объединяет все элементы итерируемого объекта в одну строку, используя строку, у которой вызывался метод, в качестве разделителя.

Пример:

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

• ''.join(x) объединяет элементы списка x в одну строку без пробелов.

• ' '.join(x) объединяет элементы списка x в одну строку с пробелами между элементами.

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

95, Правильный ответ: B

Объяснение:

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

• Вариант A не верен: Python не использует ручное управление памятью, как, например, язык C.

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

• Вариант C не верен: Python не передаёт управление памятью целиком операционной системе.

• Вариант D не верен: Python не использует модель распределения памяти стека.

Механизмы управления памятью в Python:

1. Частная куча (private heap): Python использует частную область памяти, где хранятся все объекты Python и структуры данных. Разработчики не имеют прямого доступа к этой памяти.

2. Автоматическая сборка мусора (automatic garbage collection): Python использует сборщик мусора для обнаружения и освобождения памяти, которая больше не используется. Сборщик мусора работает в автоматическом режиме.

3. Подсчет ссылок (reference counting): Python отслеживает количество ссылок на каждый объект в памяти. Когда количество ссылок достигает 0, объект удаляется из памяти.

4. Управление через менеджер памяти Python: Распределением памяти занимается внутренний менеджер памяти, который эффективно управляет выделением и освобождением памяти.

Пример:

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

• При создании my_list память выделяется в частной куче, и Python отслеживает эту память.

• Переменная my_list_2 также ссылается на эту область памяти.

• После удаления my_list, объект по прежнему доступен через ссылку my_list_2. Сборщик мусора (GC) освободит память, когда счетчик ссылок объекта станет равен 0.

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

96, Правильный ответ: B

Объяснение:

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

• Вариант A не верен: with упрощает процесс управления ресурсами, а не обработки ошибок. Хотя with может косвенно помочь в отлове ошибок при работе с ресурсами, но это не его основная задача.

• Вариант B верен: with упрощает операции ввода-вывода с файлами, а так же работу с другими ресурсами.

• Вариант C не верен: with не влияет на синтаксис объявлений функций.

• Вариант D не верен: with не используется для упрощения циклов.

Как работает with:

1. Менеджер контекста: Оператор with работает с объектами, которые реализуют протокол менеджера контекста (методы __enter__ и __exit__).

2. Управление ресурсами: Когда выполняется блок кода с with, вызывается метод __enter__ объекта, который подготавливает ресурс к использованию. После завершения блока кода (даже если возникло исключение), вызывается метод __exit__, который освобождает ресурс.

Основные применения with:

• Файлы: Гарантирует, что файл будет закрыт после его использования, даже если произойдет ошибка.

• Соединения с базами данных: Автоматическое закрытие соединений.

• Блокировки потоков: Управление блокировками в многопоточном коде.

Пример:

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

• Файл "my_file.txt" автоматически закрывается, как только выполнится код в блоке with, или возникнет исключение.

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

97, Правильный ответ: B

Объяснение:

Ключевое слово yield в Python используется для определения генераторов. Генераторы — это особый вид функций, которые позволяют ленивую итерацию, то есть возвращают значения по одному, приостанавливая свое выполнение между вызовами.

• Вариант A не верен: yield не завершает функцию, а приостанавливает ее выполнение.

• Вариант B верен: yield возвращает значение и приостанавливает состояние функции.

• Вариант C не верен: yield не предотвращает выполнение цикла.

• Вариант D не верен: yield не пропускает итерации цикла.

Как работает yield:

1. Функция, содержащая yield, становится генератором.

2. При вызове генератора, он не выполняет код функции сразу, а возвращает итератор.

3. Когда метод __next__ вызывается на итераторе, генератор выполняет код до оператора yield.

4. После yield функция возвращает значение и приостанавливает свое состояние, сохраняя все локальные переменные.

5. При повторном вызове __next__ или когда запрашивается следующий элемент в цикле for, выполнение функции продолжается с места приостановки.

Преимущества yield:

1. Ленивая генерация: Значения создаются по мере необходимости, что позволяет экономить память.

2. Поддержка больших наборов данных: Генераторы идеально подходят для работы с большими объемами данных, которые могут не поместиться в памяти.

3. Потоковая обработка данных: Генераторы могут эффективно обрабатывать данные по мере их поступления.

Пример:

В результате: Функция my_generator() использует yield для генерации значений по одному. Цикл for получает значения из генератора и обрабатывает их.

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

98, Правильный ответ: D

Объяснение:

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

• Вариант A не верен: eval() выполняет строку кода Python, что может быть небезопасно, если строка получена от пользователя (так как пользователь может ввести произвольный код)

• Вариант B не верен: exec() похожа на eval(), но выполняет произвольный код, также небезопасна при использовании пользовательского ввода.

• Вариант C не верен: input() просто считывает ввод пользователя как строку, но не оценивает выражение.

• Вариант D верен: ast.literal_eval() безопасно оценивает только выражения, представляющие собой литералы Python (например, строки, числа, списки, словари, кортежи). Он не позволяет выполнять произвольный код.

eval() vs. ast.literal_eval():

• eval():

  • Выполняет строку как код Python.

  • Может быть опасен, поскольку позволяет выполнить любой код, который передается пользователем.

• ast.literal_eval():

  • Безопасно оценивает только выражения, представляющие собой литералы Python.

  • Ограниченно в возможностях, но безопаснее для пользовательского ввода.

Пример:

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

• ast.literal_eval() безопасно преобразует строку в словарь.

• eval() выполняет строку "10 + 20" и выдает результат 30.

• Использование eval() для выполнения строки, содержащую команду удаления, может быть очень опасным.

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

99, Правильный ответ: C

Объяснение:

Декоратор @classmethod в Python используется для преобразования обычного метода класса в метод класса.

• Вариант A не верен: Он преобразует метод в метод класса, а не в статический метод.

• Вариант B не верен: Декораторы не влияют на возможность переопределения метода.

• Вариант C верен: @classmethod позволяет вызывать метод непосредственно у класса, а не только через экземпляр.

• Вариант D не верен: Декоратор не меняет видимость метода.

Ключевые свойства методов класса:

1. Связывание с классом: Метод класса связан с самим классом, а не с его экземплярами.

2. Аргумент cls: Метод класса автоматически получает ссылку на класс (conventionally named cls) в качестве первого аргумента, это отличие от обычных методов (self).

3. Доступ к атрибутам класса: Он может получать доступ к атрибутам класса и модифицировать их.

4. Вызов через класс или экземпляр: Метод класса можно вызывать как у самого класса ClassName.method(), так и у экземпляра instance.method().

Типичные применения методов класса:

• Фабричные методы: Методы класса часто используются для создания альтернативных конструкторов, то есть для создания объектов класса разными способами.

Пример:

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

• Метод create_with_default_value вызывается через класс и возвращает новый экземпляр.

• Метод instance_method выводится значение атрибута экземпляра и класса.

• Класс метод modify_class_variable изменяет переменную класса.

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

Подпишись, чтобы не пропустить следующие вопросы из интервью разработчика на pythpn

Удачи!

• A. Сначала добавить забытый файл командой git add , а затем выполнить git commit --amend --no-edit, чтобы обновить последний коммит.

• B. Выполнить git revert HEAD, чтобы отменить последний коммит, а затем создать новый, правильный коммит.

• C. Использовать git update для прямого добавления файла в уже существующий коммит.

• D. Создать новый коммит с этим файлом, а затем использовать git merge HEAD~1, чтобы объединить его с предыдущим.

Вопрос 503. Какую роль играет "staging area" (или "index") в рабочем процессе Git, и каково его основное предназначение?

• A. Это временное хранилище (аналогичное git stash) для незавершенных изменений, которые еще не готовы к коммиту.

• B. Это промежуточная область, куда разработчик помещает готовые изменения (git add), чтобы сформировать из них следующий коммит. Она позволяет включать в коммит только часть изменений из рабочего каталога.

• C. Это специальная ветка, в которой хранятся все конфликты слияния для их последующего разрешения.

• D. Это область, где Git хранит полную историю всех изменений в проекте, являясь синонимом локального репозитория.

Вопрос 504. В чем заключается принципиальное различие в результате применения команд git merge и git rebase для интеграции изменений из одной ветки в другую, и какой из подходов создает более линейную историю коммитов?

• A. git merge создает специальный "коммит слияния", который объединяет истории двух веток, сохраняя их параллельное развитие. git rebase переносит коммиты из одной ветки в начало другой, создавая линейную историю.

• B. git rebase создает коммит слияния, а git merge переносит коммиты одной ветки поверх другой, изменяя их хеши.

• C. git merge используется для слияния текстовых файлов, в то время как git rebase оптимизирован для работы с бинарными файлами.

• D. git rebase является более безопасной операцией, так как автоматически разрешает все конфликты, в отличие от git merge, который всегда требует ручного вмешательства.

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

• A. Использовать команду git stash, чтобы временно сохранить все отслеживаемые измененные файлы, переключиться на ветку main, а после исправления бага вернуться в свою ветку и применить изменения командой git stash pop.

• B. Создать временный коммит с сообщением "WIP" (Work In Progress), переключиться на main, а по возвращении отменить этот коммит командой git reset --soft HEAD~1, чтобы вернуть изменения в рабочий каталог.

• C. Использовать команду git checkout -f main для принудительного переключения на ветку main, что автоматически сохранит ваши изменения для последующего восстановления.

• D. Скопировать измененные файлы в другую папку на компьютере, отменить все локальные изменения командой git reset --hard, а после исправления бага скопировать файлы обратно.

Вопрос 506. Вы отправили важный коммит в общий удаленный репозиторий (git push), но позже обнаружили в нем ошибку. Какой командой следует "отменить" изменения этого коммита, сохранив при этом историю безопасной и понятной для всей команды?

• A. Использовать команду git revert <commit_hash>, которая создаст новый коммит, отменяющий изменения указанного коммита, и при этом не изменяет существующую историю.

• B. Использовать git reset --hard HEAD~1, чтобы удалить ошибочный коммит, а затем принудительно отправить изменения с помощью git push --force.

• C. Использовать git commit --amend, чтобы исправить ошибку и перезаписать последний коммит, после чего отправить его с помощью git push --force.

• D. Использовать команду git delete commit <commit_hash>, которая безопасно удаляет коммит из истории как локально, так и удаленно.

Вопрос 507. Для чего предназначена команда git cherry-pick и в каком сценарии ее использование будет наиболее оправданным?

• A. Она применяет один или несколько выбранных коммитов из одной ветки в другую. Это особенно полезно для переноса конкретных исправлений (hotfix) без необходимости слияния всей ветки.

• B. Она переносит все коммиты из текущей ветки поверх другой, создавая линейную и чистую историю коммитов.

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

• D. Она используется для сравнения содержимого одного конкретного коммита с файлами в текущем рабочем каталоге.

Вопрос 508. Вы случайно выполнили команду git reset --hard и потеряли несколько последних локальных коммитов, которые еще не были отправлены в удаленный репозиторий. Существует ли в Git механизм для восстановления этих "потерянных" коммитов, и если да, то какая команда для этого используется?

• A. Нет, команда git reset --hard необратима. Все потерянные коммиты удаляются навсегда без возможности восстановления.

• B. Да, можно использовать git reflog, чтобы найти хеши "потерянных" коммитов и восстановить их, создав новую ветку от нужного коммита.

• C. Да, можно использовать команду git restore --lost-commits, которая автоматически найдет и восстановит все удаленные коммиты.

• D. Восстановление возможно только путем клонирования репозитория заново с удаленного сервера, но локальные коммиты будут утеряны.

Вопрос 509. Что представляет собой команда git bisect, и какой основной алгоритм лежит в её основе для эффективного поиска коммита, который внес ошибку в код?

• A. Это инструмент, который автоматически выполняет бинарный поиск по истории коммитов, чтобы найти первый коммит, внесший ошибку. Разработчик помечает коммиты как «хорошие» (good) и «плохие» (bad), сужая диапазон поиска.

• B. Эта команда последовательно проверяет каждый коммит один за другим, начиная с последнего, и запускает автоматические тесты, пока не найдет сломанный коммит.

• C. Она анализирует указанный файл и показывает, какой коммит и какой автор последними изменяли каждую строку, помогая найти виновника ошибки в конкретном файле.

• D. Она разделяет (bisects) ветку на две новые ветки в указанном коммите для проведения A/B тестирования функциональности.

Вопрос 510. Как файл .gitignore влияет на файлы, которые уже отслеживаются системой контроля версий Git, и какая последовательность действий необходима, чтобы заставить Git перестать отслеживать такой файл, не удаляя его из локальной файловой системы?

• A. Добавления файла в .gitignore достаточно. Git автоматически перестанет отслеживать его при следующем коммите.

• B. .gitignore не влияет на уже отслеживаемые файлы. Чтобы перестать отслеживать файл, нужно сначала удалить его из индекса Git с помощью git rm --cached <file>, а затем закоммитить это изменение.

• C. Файл .gitignore предназначен только для игнорирования папок, а не отдельных файлов.

• D. Нужно использовать git reset <file>, чтобы убрать файл из staging area, после чего .gitignore начнет действовать.

Ответы с примерами и объяснением 10 вопросов по GIT (вопросы 501 - 510) Ответы
Подпишись, чтобы не пропустить

Удачи!

Разбор вариантов:

• A. Неверно. Определения перепутаны.

• B. Верно. Это наиболее точное описание разницы.

• C. Неверно. Команды не являются синонимами; git pull выполняет дополнительное действие (слияние).

• D. Неверно. Для отправки изменений используется git push.

• Ключевой аспект 1: Безопасность: git fetch считается более "безопасной" командой, потому что она не вносит автоматических изменений в вашу локальную рабочую ветку. Вы получаете возможность проанализировать изменения (git log main..origin/main) перед тем, как вручную их слить (git merge origin/main).

• Ключевой аспект 2: Рабочий процесс: git pull — это удобный шорткат, но он может скрыть от вас детали слияния. Использование git fetch + git merge дает больше контроля над процессом.

Пример:

Таким образом, ответ B является правильным, так как git fetch загружает изменения из удаленного репозитория, но не применяет их к локальной рабочей ветке, в то время как git pull загружает изменения и немедленно пытается их слить (merge) с текущей веткой, что делает git fetch более "безопасной" операцией.

Вопрос 502. Вы только что сделали коммит, но сразу поняли, что забыли добавить в него один важный файл. Какую последовательность команд следует использовать, чтобы добавить этот файл в самый последний коммит, не создавая при этом нового коммита в истории?

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

Объяснение:

Для модификации самого последнего коммита в Git предназначена команда git commit с флагом --amend. Это позволяет "дополнить" или "исправить" предыдущий коммит, добавив в него новые изменения или изменив его сообщение.

• git commit --amend: Эта команда берет все изменения, которые находятся в "staging area" (проиндексированные изменения), и объединяет их с изменениями из последнего коммита. Фактически, она не "изменяет" старый коммит, а создает новый коммит, который заменяет предыдущий.

• Флаг --no-edit: Этот полезный флаг позволяет выполнить amend без открытия редактора для изменения сообщения коммита. Сообщение останется таким же, как и у "исправляемого" коммита.

Разбор вариантов:

• A. Верно. Это стандартный и наиболее прямой способ решить поставленную задачу.

• B. Неверно. git revert не изменяет историю, а создает новый коммит, который является "анти-коммитом" и отменяет изменения указанного коммита. Это не подходит для исправления ошибки в последнем коммите.

• C. Неверно. Команды git update для этой цели не существует, это вымышленный вариант.

• D. Неверно. Этот подход излишне сложен и приведет к созданию лишних коммитов слияния, засоряя историю.

• Ключевой аспект 1: Перезапись истории: git commit --amend является командой, которая перезаписывает историю. Это означает, что хеш замененного коммита изменится. Поэтому её следует использовать только для локальных коммитов, которые еще не были отправлены (push) в общий репозиторий.

• Ключевой аспект 2: Staging Area: Перед вызовом git commit --amend необходимо добавить нужные изменения в staging area с помощью git add. Команда amend работает именно с этими проиндексированными изменениями.

Пример:

Таким образом, ответ A является правильным, так как сначала нужно добавить забытый файл командой git add <file>, а затем выполнить git commit --amend --no-edit, чтобы обновить последний коммит, не создавая нового.

Вопрос 503. Какую роль играет "staging area" (или "index") в рабочем процессе Git, и каково его основное предназначение?

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

Объяснение:

Staging area (также известная как "index" или "область подготовленных файлов") — это одна из трех фундаментальных "зон" в Git, наряду с рабочим каталогом (Working Directory) и репозиторием (Repository). Её основное предназначение — служить "черновиком" для вашего следующего коммита.

• Рабочий процесс:

  1. Вы вносите изменения в файлы в своем рабочем каталоге.

  2. С помощью команды git add <file> вы добавляете нужные изменения из рабочего каталога в staging area.

  3. С помощью команды git commit вы берете все, что находится в staging area, и сохраняете это как новый коммит в репозитории.

• Предназначение: Главная польза staging area заключается в том, что она дает вам полный контроль над тем, что войдет в следующий коммит. Вы можете изменить 10 файлов, но добавить в staging area только 3 из них, которые относятся к одной логической задаче, и сделать коммит только с ними. Это позволяет создавать атомарные, логически завершенные коммиты и поддерживать историю проекта чистой и понятной.

Разбор вариантов:

• A. Неверно. Для временного сохранения незавершенных изменений используется команда git stash. Staging area предназначена для изменений, которые готовы к коммиту.

• B. Верно. Это наиболее точное описание роли и предназначения staging area.

• C. Неверно. Конфликты слияния отображаются и разрешаются непосредственно в рабочем каталоге, а не в какой-то специальной ветке или области.

• D. Неверно. Полную историю хранит сам репозиторий (в папке .git), а staging area содержит лишь "снимок" для следующего коммита.

• Ключевой аспект 1: Контроль: Staging area позволяет отделить готовые к коммиту изменения от тех, которые еще находятся в процессе разработки.

• Ключевой аспект 2: Атомарные коммиты: Благодаря этой области можно группировать связанные изменения в один коммит, даже если одновременно в работе находятся и другие, не связанные с ними правки.

Пример:

Таким образом, ответ B является правильным, так как "staging area" - это промежуточная область, куда разработчик помещает готовые изменения (git add), чтобы сформировать из них следующий коммит, позволяя включать в коммит только часть изменений из рабочего каталога.

Вопрос 504. В чем заключается принципиальное различие в результате применения команд git merge и git rebase для интеграции изменений из одной ветки в другую, и какой из подходов создает более линейную историю коммитов?

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

Объяснение:

И git merge, и git rebase решают одну и ту же задачу — интеграцию изменений из одной ветки в другую, — но делают это совершенно разными способами, что приводит к разному виду истории коммитов.

• git merge (Слияние):

  • Эта команда берет все коммиты из указанной ветки и объединяет их с текущей веткой.

  • Результатом является создание нового, специального "коммита слияния" (merge commit), у которого есть два родительских коммита.

  • Результат: История коммитов сохраняется в точности так, как она происходила, со всеми параллельными ветвлениями. Это честный, но иногда "шумный" способ, так как в истории появляется много коммитов слияния.

• git rebase (Перебазирование):

  • Эта команда берет все коммиты из вашей текущей ветки и "перемещает" их, применяя по одному поверх указанной целевой ветки.

  • Результат: История коммитов становится линейной, как будто все изменения делались последовательно, одно за другим. Это делает историю более чистой и легкой для чтения. Важно понимать, что rebase перезаписывает историю, создавая новые коммиты с новыми хешами для каждого из перенесенных коммитов.

Разбор вариантов:

• A. Верно. Это наиболее точное и полное описание разницы между двумя подходами.

• B. Неверно. Определения перепутаны местами.

• C. Неверно. Обе команды работают с изменениями в коде на уровне коммитов, а не с конкретными типами файлов.

• D. Неверно. Это утверждение является полной противоположностью правды. git rebase часто сложнее в разрешении конфликтов (так как они могут возникать на каждом переносимом коммите) и считается "опасной" операцией для общих веток из-за перезаписи истории.

• Ключевой аспект 1: Линейность истории: git rebase создает чистую и линейную историю, в то время как git merge сохраняет нелинейную историю с явными точками слияния.

• Ключевой аспект 2: Золотое правило Rebase: Никогда не используйте git rebase для веток, на которые ссылаются другие разработчики (например, main, develop). Перезапись истории в общей ветке создаст хаос для всей команды. rebase безопасно использовать только для ваших локальных, еще не опубликованных веток.

Пример:

Допустим, у нас есть ветка main и ветка feature:

После git merge feature (находясь в main):

История сохранена, но она нелинейна.

После git rebase main (находясь в feature):

Коммиты A, B, C были пересозданы (A', B', C') и применены поверх main. История линейна.

Таким образом, ответ A является правильным, так как git merge создает специальный "коммит слияния", который объединяет истории двух веток, сохраняя их параллельное развитие, а git rebase переносит коммиты из одной ветки в начало другой, создавая линейную историю.

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

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

Объяснение:

Для решения именно такой задачи в Git существует специальный механизм — git stash (в переводе "спрятать" или "заначка"). Он позволяет временно сохранить все изменения в отслеживаемых файлах, которые еще не были закоммичены, возвращая ваш рабочий каталог в "чистое" состояние (соответствующее последнему коммиту HEAD).

• git stash: Эта команда берет ваши измененные отслеживаемые файлы и незавершенные проиндексированные изменения и сохраняет их в специальном стеке. После этого ваш рабочий каталог становится чистым.

• git stash pop: После того как вы закончили срочную работу и вернулись в свою ветку, эта команда берет последние сохраненные изменения из стека stash и применяет их к вашему рабочему каталогу, одновременно удаляя их из стека.

Разбор вариантов:

• A. Верно. Это стандартный, безопасный и наиболее эффективный способ решения данной проблемы, для которого и был создан git stash.

• B. Неверно. Хотя этот подход технически возможен, он считается плохой практикой. Он создает "грязные", неполноценные коммиты в истории, которые потом приходится удалять, что усложняет историю проекта.

• C. Неверно. Этот вариант очень опасен. Флаг -f (или --force) при переключении веток отбросит все ваши локальные изменения безвозвратно. Они не будут сохранены.

• D. Неверно. Это "ручной" и крайне неэффективный способ, который полностью игнорирует встроенные возможности Git. Он подвержен ошибкам (можно забыть скопировать файл) и не является версионируемым.

• Ключевой аспект 1: Чистый рабочий каталог: Git не позволяет переключаться между ветками, если у вас есть незакоммиченные изменения, которые могут конфликтовать с веткой назначения. git stash решает эту проблему, временно "очищая" ваш каталог.

• Ключевой аспект 2: Стек изменений: git stash может хранить несколько наборов изменений в виде стека. Вы можете просмотреть их с помощью git stash list и применить не только последний, но и любой другой.

Пример:

Таким образом, ответ A является правильным, так как использование команды git stash позволяет временно сохранить все отслеживаемые измененные файлы, переключиться на ветку main, а после исправления бага вернуться в свою ветку и применить изменения командой git stash pop.

Вопрос 506. Вы отправили важный коммит в общий удаленный репозиторий (git push), но позже обнаружили в нем ошибку. Какой командой следует "отменить" изменения этого коммита, сохранив при этом историю безопасной и понятной для всей команды?

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

Объяснение:

Когда "плохой" коммит уже попал в общий репозиторий, перезапись истории (которую делают git reset и git commit --amend) становится очень опасной, так как это может привести к серьезным проблемам у других членов команды, которые уже могли получить этот коммит. Для безопасной отмены изменений в таких случаях предназначена команда git revert.

• git revert <commit_hash>: Эта команда не удаляет и не изменяет существующую историю. Вместо этого она анализирует указанный коммит и создает новый коммит, который является его точной противоположностью. Если старый коммит добавлял строку, revert-коммит ее удалит. Если удалял — добавит обратно.

• Безопасность и прозрачность: Так как revert просто добавляет новый коммит, история проекта остается целостной и понятной. Все видят, что был сделан ошибочный коммит, а затем был сделан коммит, который его исправляет.

Разбор вариантов:

• A. Верно. git revert — это стандартный и безопасный способ отмены изменений в общих ветках.

• B. Неверно. Это крайне опасная практика для общих веток. git reset --hard и git push --force переписывают историю, что может сломать репозитории у ваших коллег и привести к потере данных.

• C. Неверно. git commit --amend также переписывает историю и применим только к самому последнему коммиту. Использовать его для уже опубликованных коммитов так же опасно, как и reset.

• D. Неверно. Команды git delete commit не существует в Git. Это вымышленный вариант.

• Ключевой аспект 1: Сохранение истории vs. Перезапись истории: git revert добавляет новые коммиты (сохраняет историю), в то время как git reset и git commit --amend удаляют или изменяют существующие (перезаписывают историю).

• Ключевой аспект 2: Публичная vs. Локальная история: Правило гласит: безопасно перезаписывать только ту историю, которая еще не была опубликована (не была отправлена через push). Для опубликованной истории следует использовать git revert.

Пример:

Таким образом, ответ A является правильным, так как команда git revert <commit_hash> создает новый коммит, отменяющий изменения указанного коммита, и при этом не изменяет существующую историю, что является безопасным для общих репозиториев.

Вопрос 507. Для чего предназначена команда git cherry-pick и в каком сценарии ее использование будет наиболее оправданным?

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

Объяснение:

Команда git cherry-pick (в переводе "срывать вишенку") — это мощный инструмент, который позволяет точечно применять изменения из конкретных коммитов. Она берет указанный коммит из любой ветки и применяет его в виде нового коммита поверх текущей ветки, в которой вы находитесь.

• Основное предназначение: Вместо того чтобы сливать целую ветку со всеми ее коммитами, cherry-pick позволяет вам выбрать только те "вишенки" (коммиты), которые вам нужны.

• Типичный сценарий использования:

  1. Hotfix: Разработчик находит и исправляет баг в своей feature-ветке. Этот фикс нужен в основной ветке main немедленно, но вся остальная feature-ветка еще не готова к слиянию. С помощью git cherry-pick можно взять только коммит с исправлением бага и применить его к main.

  2. Перенос небольшой функциональности: В одной ветке была реализована полезная утилитарная функция. Другой ветке нужна эта же функция, но не все остальные изменения из первой ветки. Коммит с этой функцией можно "перенести" с помощью cherry-pick.

Разбор вариантов:

• A. Верно. Это точное описание работы и основного предназначения команды.

• B. Неверно. Это описание команды git rebase.

• C. Неверно. cherry-pick не создает коммитов слияния; он создает обычный, новый коммит, который является копией выбранного.

• D. Неверно. Для сравнения коммита с рабочим каталогом используется команда git diff <commit_hash>.

• Ключевой аспект 1: Точечное применение: В отличие от merge или rebase, которые работают с целыми ветками, cherry-pick работает с отдельными коммитами.

• Ключевой аспект 2: Создание нового коммита: Важно понимать, что cherry-pick не "перемещает" коммит, а создает его копию. У нового коммита будет новый хеш, но тот же автор, дата и сообщение (если не указано иное).

Пример:

Таким образом, ответ A является правильным, так как git cherry-pick применяет один или несколько выбранных коммитов из одной ветки в другую, что особенно полезно для переноса конкретных исправлений (hotfix) без необходимости слияния всей ветки.

Вопрос 508. Вы случайно выполнили команду git reset --hard и потеряли несколько последних локальных коммитов, которые еще не были отправлены в удаленный репозиторий. Существует ли в Git механизм для восстановления этих "потерянных" коммитов, и если да, то какая команда для этого используется?

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

Объяснение:

Хотя команда git reset --hard кажется очень опасной, Git спроектирован так, чтобы данные не терялись легко. Большинство действий, изменяющих историю (такие как reset, rebase, amend), на самом деле не удаляют коммиты немедленно. Git хранит "журнал" всех состояний, на которые указывал HEAD, и этот журнал можно просмотреть с помощью команды git reflog.

• git reflog (Reference Log):

  • Эта команда выводит лог всех изменений ссылок в локальном репозитории (например, HEAD, имена веток). Каждая запись в reflog показывает, куда указывала ссылка в определенный момент времени.

  • Это локальный механизм, он не синхронизируется с удаленным репозиторием и предназначен для "спасения" от локальных ошибок. Записи в reflog хранятся ограниченное время (по умолчанию 90 дней).

• Процесс восстановления:

  1. Выполнить git reflog, чтобы увидеть список всех недавних действий и состояний HEAD.

  2. Найти в этом списке хеш коммита, который был последним до выполнения git reset --hard.

  3. Восстановить это состояние, создав новую ветку от этого коммита (git checkout -b recovered-branch <commit_hash>) или сбросив текущую ветку к нему (git reset --hard <commit_hash>).

Разбор вариантов:

• A. Неверно. Хотя reset --hard опасен, он не является абсолютно необратимым благодаря reflog.

• B. Верно. Это стандартный и правильный способ восстановления потерянных локальных коммитов.

• C. Неверно. Команды git restore --lost-commits не существует, это вымышленный вариант.

• D. Неверно. Клонирование репозитория не поможет восстановить коммиты, которых никогда не было на удаленном сервере.

• Ключевой аспект 1: Журнал ссылок: git reflog — это ваша "страховочная сетка" при выполнении опасных операций, изменяющих локальную историю.

• Ключевой аспект 2: Доступность коммитов: Коммит в Git не удаляется до тех пор, пока на него не перестанут указывать какие-либо ссылки (включая ссылки из reflog) и пока не сработает сборщик мусора Git (git gc).

Пример:

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

Вопрос 509. Что представляет собой команда git bisect, и какой основной алгоритм лежит в её основе для эффективного поиска коммита, который внес ошибку в код?

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

Объяснение:

git bisect — это чрезвычайно мощный инструмент для отладки, который помогает быстро найти коммит, который внёс ошибку в проект. Его основное преимущество — скорость, достигаемая за счет использования алгоритма бинарного поиска.

• Как это работает:

  1. Вы запускаете процесс командой git bisect start.

  2. Вы указываете "плохой" коммит, где ошибка уже точно есть (обычно это HEAD или последний известный коммит с ошибкой) — git bisect bad <commit>.

  3. Вы указываете "хороший" коммит, где ошибки еще точно не было (например, хеш старого коммита или тег версии) — git bisect good <commit>.

  4. Git автоматически переключается на коммит, находящийся посередине между "хорошим" и "плохим".

  5. Вы проверяете код на наличие ошибки в этом коммите и сообщаете Git результат: git bisect good (если ошибки нет) или git bisect bad (если ошибка есть).

  6. Git сужает диапазон поиска в два раза и повторяет шаг 4.

  7. Процесс продолжается до тех пор, пока не будет найден первый коммит, который был помечен как "плохой".

  8. Вы завершаете сессию командой git bisect reset.

Разбор вариантов:

• A. Верно. Это точное описание механизма работы git bisect и его основы — бинарного поиска.

• B. Неверно. Это описание линейного поиска, который был бы гораздо медленнее. git bisect использует более эффективный бинарный поиск.

• C. Неверно. Это описание команды git blame, которая используется для другого вида анализа.

• D. Неверно. git bisect не создает новые ветки для тестирования, а временно переключает HEAD на существующие коммиты. Это вымышленный сценарий.

• Ключевой аспект 1: Бинарный поиск: Вместо того чтобы проверять сотни коммитов по одному, git bisect позволяет найти нужный коммит за логарифмическое время. Например, для 1024 коммитов потребуется всего около 10 проверок.

• Ключевой аспект 2: Автоматизация: Весь процесс можно автоматизировать, передав команде git bisect run скрипт, который будет сам проверять наличие бага и возвращать код выхода (0 для "good", 1 для "bad").

Пример:

Таким образом, ответ A является правильным, так как git bisect - это инструмент, который автоматически выполняет бинарный поиск по истории коммитов, чтобы найти первый коммит, внесший ошибку, сужая диапазон поиска путем пометки коммитов как «хорошие» (good) и «плохие» (bad).

Вопрос 510. Как файл .gitignore влияет на файлы, которые уже отслеживаются системой контроля версий Git, и какая последовательность действий необходима, чтобы заставить Git перестать отслеживать такой файл, не удаляя его из локальной файловой системы?

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

Объяснение:

Это один из самых частых "подводных камней" при работе с .gitignore. Ключевой принцип заключается в том, что .gitignore указывает Git, какие файлы и папки игнорировать при добавлении в репозиторий, но он не влияет на файлы, которые уже отслеживаются.

• Как работает .gitignore: Он предотвращает попадание неотслеживаемых (untracked) файлов в staging area при использовании таких команд, как git add ..

• Что происходит с уже отслеживаемыми файлами: Если файл был когда-то добавлен (git add) и закоммичен, Git будет продолжать отслеживать изменения в нем, даже если вы позже добавите его в .gitignore.

• Решение проблемы: Чтобы заставить Git "забыть" про файл, но оставить его в вашем рабочем каталоге, необходимо:

  1. Удалить файл из индекса (staging area) Git. Для этого используется команда git rm --cached <file>. Флаг --cached критически важен, так как он предотвращает удаление файла из вашей файловой системы.

  2. Добавить имя файла в .gitignore (если это еще не сделано).

  3. Закоммитить эти изменения (.gitignore и удаление из индекса).

Разбор вариантов:

• A. Неверно. Это самое распространенное заблуждение. Git не перестанет отслеживать файл автоматически.

• B. Верно. Это полный и правильный порядок действий для решения задачи.

• C. Неверно. .gitignore прекрасно работает как для файлов, так и для папок.

• D. Неверно. git reset <file> уберет файл из индекса, но не остановит его отслеживание. При следующем git add . (если файл не в .gitignore) он снова будет добавлен. git rm --cached — это правильная команда для полного прекращения отслеживания.

• Ключевой аспект 1: Область действия .gitignore: Влияет только на неотслеживаемые файлы.

• Ключевой аспект 2: Команда git rm --cached: Это стандартный способ убрать файл из-под контроля версий, сохранив его локально.

Пример:

Таким образом, ответ B является правильным, так как .gitignore не влияет на уже отслеживаемые файлы, и чтобы перестать отслеживать файл, нужно сначала удалить его из индекса Git с помощью git rm --cached <file>, а затем закоммитить это изменение.

Блок вопросов на github

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

Удачи!