Что такое Python?

Python — это высокоуровневый язык программирования, который славится своей простотой и читаемостью. Он был создан Гвидо ван Россумом и впервые выпущен в 1991 году.

Основные преимущества Python:

• Простой и понятный синтаксис
• Большое количество библиотек и фреймворков
• Кроссплатформенность
• Активное сообщество разработчиков

Области применения:

1. Веб-разработка (Django, Flask)
2. Data Science и Machine Learning
3. Автоматизация и скриптинг
4. Разработка игр

Ваша первая программа:

print("Hello, World!")

Эта простая команда выводит текст "Hello, World!" на экран. Именно с такой программы традиционно начинается изучение любого языка программирования.

Переменные в Python

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

Создание переменных:

name = "Иван"
age = 25
height = 1.75
is_student = True

Основные типы данных:

• int — целые числа (1, 42, -7)
• float — числа с плавающей точкой (3.14, -0.5)
• str — строки ("Hello", 'Python')
• bool — логические значения (True, False)

Проверка типа данных:

x = 42
print(type(x))  # <class 'int'>

name = "Python"
print(type(name))  # <class 'str'>

Преобразование типов:

# Строка в число
age_str = "25"
age_int = int(age_str)

# Число в строку
count = 100
count_str = str(count)

# Число в логический тип
x = 0
bool(x)  # False (любое ненулевое число = True)

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

Условные конструкции if-elif-else

Условные операторы позволяют программе принимать решения и выполнять разные действия в зависимости от условий.

Оператор if:

age = 18

if age >= 18:
    print("Вы совершеннолетний")
    print("Добро пожаловать!")

if-else конструкция:

temperature = 25

if temperature > 30:
    print("Жарко!")
else:
    print("Нормальная температура")

if-elif-else для множественных условий:

score = 85

if score >= 90:
    print("Отлично!")
elif score >= 75:
    print("Хорошо")
elif score >= 60:
    print("Удовлетворительно")
else:
    print("Нужно подтянуться")

Операторы сравнения:

• == — равно
• != — не равно
• > — больше
• < — меньше
• >= — больше или равно
• <= — меньше или равно

Логические операторы:

age = 20
has_license = True

if age >= 18 and has_license:
    print("Можете водить машину")

is_weekend = False
is_holiday = True

if is_weekend or is_holiday:
    print("Сегодня выходной!")

Циклы в Python

Циклы позволяют выполнять один и тот же код многократно. В Python есть два основных типа циклов: for и while.

Цикл for:

Используется для перебора элементов последовательности (списка, строки, диапазона).

# Перебор чисел от 0 до 4
for i in range(5):
    print(i)

# Перебор элементов списка
fruits = ["яблоко", "банан", "апельсин"]
for fruit in fruits:
    print(fruit)

# Перебор символов строки
for char in "Python":
    print(char)

Цикл while:

Выполняется, пока условие истинно.

count = 0
while count < 5:
    print(f"Счет: {count}")
    count += 1

# Бесконечный цикл с break
while True:
    answer = input("Продолжить? (да/нет): ")
    if answer == "нет":
        break
    print("Продолжаем...")

Операторы break и continue:

# break - прерывает цикл
for i in range(10):
    if i == 5:
        break
    print(i)  # Выведет 0, 1, 2, 3, 4

# continue - пропускает текущую итерацию
for i in range(5):
    if i == 2:
        continue
    print(i)  # Выведет 0, 1, 3, 4

Функция range():

# range(stop)
range(5)  # 0, 1, 2, 3, 4

# range(start, stop)
range(2, 7)  # 2, 3, 4, 5, 6

# range(start, stop, step)
range(0, 10, 2)  # 0, 2, 4, 6, 8

Что такое React?

React — это JavaScript-библиотека для создания пользовательских интерфейсов. Разработана Facebook (Meta) и является одним из самых популярных инструментов фронтенд-разработки.

Основные концепции React:

• Компонентный подход — UI разбивается на переиспользуемые компоненты
• Виртуальный DOM — оптимизация обновления интерфейса
• Однонаправленный поток данных — данные передаются сверху вниз
• JSX — синтаксис для описания UI в JavaScript

Первый компонент:

function Welcome() {
  return <h1>Привет, мир!</h1>;
}

// Использование
<Welcome />

Почему React?

• Высокая производительность благодаря Virtual DOM
• Переиспользуемые компоненты
• Огромное сообщество и экосистема библиотек
• Используется в крупных проектах (Facebook, Instagram, Netflix)

Установка React:

# Создание нового проекта
npx create-react-app my-app
cd my-app
npm start

После запуска откроется браузер с вашим первым React-приложением на http://localhost:3000

Компоненты в React

Компоненты — это независимые, переиспользуемые блоки кода, которые возвращают React-элементы для отображения на странице.

Функциональные компоненты:

function UserCard(props) {
  return (
    <div className="card">
      <h2>{props.name}</h2>
      <p>{props.email}</p>
    </div>
  );
}

// Использование
<UserCard name="Иван" email="ivan@example.com" />

Props (свойства):

Props — это объект с данными, которые передаются компоненту сверху вниз. Props доступны только для чтения (read-only).

function Welcome(props) {
  return <h1>Привет, {props.name}!</h1>;
}

// Несколько props
function Product(props) {
  return (
    <div>
      <h3>{props.title}</h3>
      <p>Цена: {props.price} руб.</p>
      <button>{props.buttonText}</button>
    </div>
  );
}

<Product
  title="Ноутбук"
  price={50000}
  buttonText="Купить"
/>

Деструктуризация props:

// Более чистый синтаксис
function UserCard({ name, email, age }) {
  return (
    <div>
      <h2>{name}</h2>
      <p>{email}</p>
      <p>Возраст: {age}</p>
    </div>
  );
}

Композиция компонентов:

function App() {
  return (
    <div>
      <UserCard name="Иван" email="ivan@example.com" age={25} />
      <UserCard name="Мария" email="maria@example.com" age={22} />
      <UserCard name="Петр" email="petr@example.com" age={30} />
    </div>
  );
}

State (состояние)

State — это объект с данными, которые могут изменяться во время работы компонента. В отличие от props, state управляется внутри компонента.

Хук useState:

import { useState } from 'react';

function Counter() {
  // Создаем state переменную count со значением 0
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>Счетчик: {count}</p>
      <button onClick={() => setCount(count + 1)}>
        Увеличить
      </button>
    </div>
  );
}

Множественный state:

function Form() {
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');
  const [age, setAge] = useState(0);

  return (
    <form>
      <input
        value={name}
        onChange={(e) => setName(e.target.value)}
        placeholder="Имя"
      />
      <input
        value={email}
        onChange={(e) => setEmail(e.target.value)}
        placeholder="Email"
      />
      <input
        type="number"
        value={age}
        onChange={(e) => setAge(Number(e.target.value))}
        placeholder="Возраст"
      />
    </form>
  );
}

State с объектами:

function UserProfile() {
  const [user, setUser] = useState({
    name: '',
    email: '',
    age: 0
  });

  const updateName = (newName) => {
    setUser({ ...user, name: newName });
  };

  return (
    <input
      value={user.name}
      onChange={(e) => updateName(e.target.value)}
    />
  );
}

Хук useEffect:

useEffect позволяет выполнять побочные эффекты (запросы к API, подписки, изменение DOM).

import { useState, useEffect } from 'react';

function Timer() {
  const [seconds, setSeconds] = useState(0);

  useEffect(() => {
    const interval = setInterval(() => {
      setSeconds(s => s + 1);
    }, 1000);

    // Cleanup функция
    return () => clearInterval(interval);
  }, []); // Пустой массив = выполнить один раз

  return <p>Прошло секунд: {seconds}</p>;
}

Что такое алгоритм?

Алгоритм — это конечная последовательность чётко определённых инструкций для решения задачи. Любая программа по сути является реализацией одного или нескольких алгоритмов.

Свойства алгоритма:

• Определённость — каждый шаг чётко определён
• Результативность — алгоритм должен завершаться за конечное число шагов
• Массовость — применим к различным наборам входных данных
• Дискретность — алгоритм разбит на отдельные шаги

Пример простого алгоритма:

Алгоритм поиска максимального элемента в массиве:

def find_max(arr):
    max_value = arr[0]  # Предполагаем, что первый элемент - максимальный

    for num in arr:
        if num > max_value:
            max_value = num  # Обновляем максимум

    return max_value

numbers = [3, 7, 2, 9, 1, 5]
print(find_max(numbers))  # 9

Почему алгоритмы важны?

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

Типы алгоритмов:

1. Поисковые алгоритмы (линейный поиск, бинарный поиск)
2. Алгоритмы сортировки (пузырьковая, быстрая, сортировка слиянием)
3. Рекурсивные алгоритмы
4. Жадные алгоритмы
5. Динамическое программирование

Временная сложность (Big O)

Временная сложность показывает, как растёт время выполнения алгоритма при увеличении размера входных данных. Обозначается как O(n), где n — размер данных.

Основные классы сложности:

• O(1) — константная (доступ к элементу массива по индексу)
• O(log n) — логарифмическая (бинарный поиск)
• O(n) — линейная (проход по массиву)
• O(n log n) — линейно-логарифмическая (эффективная сортировка)
• O(n²) — квадратичная (вложенные циклы)
• O(2ⁿ) — экспоненциальная (некоторые рекурсивные алгоритмы)

Примеры:

# O(1) - константное время
def get_first_element(arr):
    return arr[0]

# O(n) - линейное время
def find_element(arr, target):
    for item in arr:
        if item == target:
            return True
    return False

# O(n²) - квадратичное время
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

# O(log n) - логарифмическое время
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

Пространственная сложность:

Показывает, сколько дополнительной памяти требуется алгоритму. Например, сортировка слиянием требует O(n) дополнительной памяти, а быстрая сортировка — O(log n).

Массивы

Массив — это структура данных, хранящая элементы одного типа в непрерывной области памяти. Доступ к элементам осуществляется по индексу за O(1).

Операции с массивами:

# Создание массива
arr = [1, 2, 3, 4, 5]

# Доступ по индексу - O(1)
print(arr[0])  # 1

# Добавление в конец - O(1) амортизированное
arr.append(6)

# Вставка по индексу - O(n)
arr.insert(2, 10)

# Удаление по значению - O(n)
arr.remove(10)

# Удаление по индексу - O(n)
del arr[2]

# Поиск элемента - O(n)
if 3 in arr:
    print("Найдено")

Связные списки:

В отличие от массива, элементы связного списка хранятся в разных участках памяти и связаны указателями.

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return

        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

Сравнение:

Основные алгоритмы сортировки

Сортировка — одна из самых частых задач в программировании. Существует множество алгоритмов сортировки с различной эффективностью.

1. Пузырьковая сортировка (Bubble Sort)

Сложность: O(n²). Простой, но медленный алгоритм.

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

numbers = [64, 34, 25, 12, 22]
print(bubble_sort(numbers))  # [12, 22, 25, 34, 64]

2. Сортировка выбором (Selection Sort)

Сложность: O(n²). Находит минимальный элемент и ставит его на первую позицию.

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

3. Быстрая сортировка (Quick Sort)

Сложность: O(n log n) в среднем. Один из самых эффективных алгоритмов.

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]

    return quick_sort(left) + middle + quick_sort(right)

numbers = [3, 6, 8, 10, 1, 2, 1]
print(quick_sort(numbers))  # [1, 1, 2, 3, 6, 8, 10]

Сравнение алгоритмов:

Что такое Git?

Git — это распределённая система контроля версий, которая позволяет отслеживать изменения в файлах и координировать работу над ними нескольких людей.

Основные концепции:

• Репозиторий (Repository) — хранилище вашего проекта и всей его истории
• Коммит (Commit) — снимок состояния файлов в определённый момент времени
• Ветка (Branch) — независимая линия разработки
• Удалённый репозиторий (Remote) — версия проекта на сервере (GitHub, GitLab)

Установка и настройка Git:

# Проверка версии
git --version

# Настройка имени и email
git config --global user.name "Ваше Имя"
git config --global user.email "your@email.com"

# Просмотр настроек
git config --list

Создание репозитория:

# Инициализация нового репозитория
git init

# Клонирование существующего репозитория
git clone https://github.com/username/repo.git

Базовые команды:

# Просмотр статуса файлов
git status

# Добавление файлов в индекс (staging area)
git add filename.txt
git add .  # Добавить все изменённые файлы

# Создание коммита
git commit -m "Описание изменений"

# Просмотр истории коммитов
git log
git log --oneline  # Краткий формат

Жизненный цикл файла в Git:

1. Untracked — файл не отслеживается Git
2. Modified — файл изменён, но не добавлен в индекс
3. Staged — файл добавлен в индекс и готов к коммиту
4. Committed — изменения сохранены в репозитории

Работа с ветками

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

Создание и переключение веток:

# Просмотр всех веток
git branch

# Создание новой ветки
git branch feature-login

# Переключение на ветку
git checkout feature-login

# Создание и переключение одной командой
git checkout -b feature-signup

# Новый синтаксис (Git 2.23+)
git switch feature-login
git switch -c feature-new

Слияние веток (Merge):

# Переключитесь на ветку, В КОТОРУЮ хотите влить изменения
git checkout main

# Слияние ветки feature-login в main
git merge feature-login

# Удаление ветки после слияния
git branch -d feature-login

Конфликты слияния:

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

<<<<<<< HEAD
Код из текущей ветки
=======
Код из вливаемой ветки
>>>>>>> feature-branch

Разрешение конфликта:

# 1. Откройте файл и вручную разрешите конфликт
# 2. Удалите маркеры (<<<, ===, >>>)
# 3. Сохраните исправленный файл

# 4. Добавьте файл в индекс
git add filename.txt

# 5. Завершите слияние
git commit -m "Resolve merge conflict"

Rebase:

Rebase — альтернатива merge, которая переносит коммиты на верхушку другой ветки, создавая линейную историю.

# Переключитесь на ветку с фичей
git checkout feature-branch

# Перебазируйте на main
git rebase main

# Если возникли конфликты:
git add .
git rebase --continue

# Отмена rebase
git rebase --abort

Когда использовать merge vs rebase:

• Merge — сохраняет полную историю, подходит для публичных веток
• Rebase — создаёт чистую линейную историю, используйте только для локальных веток

GitHub — платформа для хостинга кода

GitHub — это веб-сервис для хостинга IT-проектов и их совместной разработки. Основан на Git и предоставляет дополнительные возможности для командной работы.

Работа с удалённым репозиторием:

# Добавление удалённого репозитория
git remote add origin https://github.com/username/repo.git

# Просмотр удалённых репозиториев
git remote -v

# Отправка изменений на GitHub
git push origin main

# Получение изменений с GitHub
git pull origin main

# Скачивание изменений без слияния
git fetch origin

Pull Request (PR):

Pull Request — это запрос на включение ваших изменений в основную ветку проекта. Это основной механизм совместной разработки на GitHub.

1. Создайте новую ветку для вашей фичи
2. Внесите изменения и создайте коммиты
3. Отправьте ветку на GitHub: git push origin feature-branch
4. На сайте GitHub нажмите "New Pull Request"
5. Опишите изменения и создайте PR
6. Дождитесь ревью и одобрения
7. Влейте изменения кнопкой "Merge"

Форки (Forks):

Форк — это копия чужого репозитория в вашем аккаунте. Используется для внесения изменений в проекты, где у вас нет прав на запись.

# 1. Нажмите "Fork" на странице репозитория
# 2. Клонируйте свой форк
git clone https://github.com/YOUR-USERNAME/repo.git

# 3. Добавьте оригинальный репозиторий как upstream
git remote add upstream https://github.com/ORIGINAL-OWNER/repo.git

# 4. Синхронизация с оригинальным репозиторием
git fetch upstream
git checkout main
git merge upstream/main

Issues и Projects:

• Issues — система отслеживания задач и багов
• Projects — канбан-доски для управления задачами
• Wiki — документация проекта
• Actions — CI/CD автоматизация

Полезные команды:

# Просмотр изменений перед коммитом
git diff

# Отмена изменений в файле
git checkout -- filename.txt

# Отмена последнего коммита (с сохранением изменений)
git reset --soft HEAD~1

# Просмотр истории одного файла
git log -- filename.txt