Method Python

У меня появилась идея! Кому интересно начать изучать Python? Можно собрать группу людей и вместе учиться по видеосвязи. Я в этом могу помочь. Я сам нахожусь в стадии обучения, но мне одному скучно, можно делать это вместе.

Методы словарей (dict) в Python:

Добавление и обновление

dct[key] = value — добавить новую пару или перезаписать существующую.

python
dct = {'a': 1}
dct['b'] = 2 # {'a': 1, 'b': 2}
dct['a'] = 99 # {'a': 99, 'b': 2}
Зачем: самый частый способ записать или обновить значение по ключу.

dct.update(other) — добавить или перезаписать сразу несколько пар из другого словаря или итерируемого объекта пар.

python
dct = {'a': 1}
dct.update({'b': 2, 'c': 3}) # {'a': 1, 'b': 2, 'c': 3}
dct.update([('d', 4)]) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dct.update(a=100) # {'a': 100, 'b': 2, 'c': 3, 'd': 4}
Зачем: быстро «склеить» словари или массово обновить значения.

dct.setdefault(key, default=None) — если ключа нет, добавляет его со значением default и возвращает это значение; если есть — возвращает текущее.

python
dct = {'a': 1}
dct.setdefault('b', 2) # 2, dct = {'a': 1, 'b': 2}
dct.setdefault('a', 99) # 1 ← ключ уже есть, значение не меняется
Зачем: задать значение по умолчанию, не перезаписывая существующее.

Удаление и извлечение

dct.pop(key, default=None) — удалить ключ и вернуть его значение; если ключа нет — возвращает default.

python
dct = {'a': 1, 'b': 2}
dct.pop('a') # 1, dct = {'b': 2}
dct.pop('x', 0) # 0 ← ключа нет, ошибки не будет
Важно: без default при отсутствии ключа — ошибка KeyError.

dct.popitem() — удалить и вернуть последнюю добавленную пару (key, value).

python
dct = {'a': 1, 'b': 2}
dct.popitem() # ('b', 2), dct = {'a': 1}
Зачем: использовать словарь как стек (LIFO).

dct.clear() — полностью очистить словарь.

python
dct = {'a': 1, 'b': 2}
dct.clear() # {}
Доступ и поиск

dct.get(key, default=None) — вернуть значение по ключу; если ключа нет — default.

python
dct = {'a': 1}
dct.get('a') # 1
dct.get('x') # None
dct.get('x', 0) # 0
Зачем: безопасный доступ без риска KeyError.

key in dct — проверить, есть ли ключ в словаре.

python
'a' in dct # True
'x' in dct # False
Зачем: быстрая проверка перед обращением.

Получение ключей, значений и пар

dct.keys() — вернуть все ключи.

python
dct = {'a': 1, 'b': 2}
dct.keys() # dict_keys(['a', 'b'])
dct.values() — вернуть все значения.

python
dct.values() # dict_values([1, 2])
dct.items() — вернуть все пары (key, value).

python
dct.items() # dict_items([('a', 1), ('b', 2)])
Зачем: перебор в цикле: for k, v in dct.items():

Копирование

dct.copy() — поверхностная копия словаря.

python
a = {'a': 1, 'b': 2}
b = a.copy() # b — отдельный словарь
Зачем: чтобы менять копию и не трогать оригинал.

🧠 Словарь (dict) — это упорядоченная по порядку вставки, изменяемая коллекция пар «ключ — значение». В словаре ключи должны быть неизменяемыми (например, строки, числа, кортежи), а значения могут быть любыми объектами Python.

Как создать: в фигурных скобках, пары «ключ: значение» через запятую:

scores = {'Alice': 95, 'Bob': 88}
mixed = {'count': 10, 'active': True, 'tags': ['python', 'data']}
empty = {}

Главные особенности:

Изменяемый: можно добавлять, удалять, менять значения «на месте».
Доступ по ключу: не по индексу, а по уникальному ключу.
Ключи уникальны: если добавить ключ повторно — перезапишется значение.
Гибкий по типам значений: в одном словаре могут быть разные типы данных в качестве значений.
Длина: узнать количество пар можно через len(dct).

dct = {'a': 1, 'b': 2, 'c': 3}
len(dct) # 3
dct['a'] # 1
dct.get('b') # 2 (безопасный доступ — вернёт None, если ключа нет)
dct['c'] = 10 # ✅ Можно менять: {'a': 1, 'b': 2, 'c': 10}
dct['d'] = 4 # ✅ Можно добавить новый ключ: {'a': 1, 'b': 2, 'c': 10, 'd': 4}
del dct['a'] # ✅ Можно удалить ключ: {'b': 2, 'c': 10, 'd': 4}

🧩 Плейсхолдеры (заполнители) в методе str.format() — это места в строке, куда подставляются значения. Они обозначаются фигурными скобками {}, а метод потом «заполняет» их переданными аргументами.

Базовые плейсхолдеры

name = "Алекс"
age = 25
s = "Привет, {}! Тебе {} лет.".format(name, age)
# Результат: "Привет, Алекс! Тебе 25 лет."
Здесь {} — плейсхолдеры: первый берёт name, второй — age, по порядку.

Позиционные плейсхолдеры (с индексами)

s = "{1}, {0}!".format("мир", "Привет")
# "Привет, мир!"
Это полезно, если нужно использовать один аргумент несколько раз или менять порядок вывода без перестановки аргументов:
s = "{0} {1} {0}".format("Hello", "world")
# "Hello world Hello"

Именованные плейсхолдеры

s = "Меня зовут {name}, я из {city}.".format(name="Мария", city="Москвы")
# "Меня зовут Мария, я из Москвы."

❗️Форматирование внутри плейсхолдера
После двоеточия можно указать формат: сколько знаков, тип числа, выравнивание и т.д.

Числа

pi = 3.14159

s = "Число π ≈ {:.2f}".format(pi)
# "Число π ≈ 3.14"
. (точка) — начинается спецификатор точности.
2 — сколько знаков оставить после запятой (будет округление).
f — число с плавающей точкой (float), формат: обычное десятичное число.

s = "{:>10}".format(42) # выравнивание вправо в поле шириной 10
s = "{:<10}".format(42) # влево
s = "{:^10}".format(42) # по центру

Проценты, целые, экспоненциальный формат

ratio = 0.1234

s = "{:.1%}".format(ratio) # "12.3%"
s = "{:d}".format(100) # "100" (целое)
s = "{:e}".format(12345) # "1.234500e+04"

Примеры с разными типами данных

data = { "user": "ivan", "score": 98.765, "level": 5 }
s = "Игрок {user}, уровень {level}, счёт {score:.1f}".format(**data)
# "Игрок ivan, уровень 5, счёт 98.8"
Распаковка словаря через **data — удобный приём: ключи совпадают с именами плейсхолдеров.

🧩 List comprehension (генератор списка) — это компактный способ создать список на основе другого итерируемого объекта (списка, строки, диапазона и т. д.) в одну строку.
Это не новый тип данных, а синтаксический сахар: он делает код короче и часто читаемее, чем цикл for.

Базовый синтаксис
[выражение for элемент in итерируемый_объект]

С условием
[выражение for элемент in итерируемый_объект if условие]

Примеры:

Квадраты чисел от 0 до 4
squares = [x**2 for x in range(5)]
# [0, 1, 4, 9, 16]

Только чётные числа
evens = [x for x in range(10) if x % 2 == 0]
# [0, 2, 4, 6, 8]

Вложенные циклы
pairs = [(x, y) for x in [1, 2] for y in ['a', 'b']]
# [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
Порядок циклов такой же, как в обычных вложенных циклах: сначала внешний, потом внутренний.

Методы списков (list) в Python:

Добавление элементов

lst.append(x) — добавить один элемент в конец.
lst = [1, 2]
lst.append(3) # [1, 2, 3]
Зачем: самый частый способ «накопить» результаты в цикле.

lst.extend(iterable) — добавить сразу несколько элементов из итерируемого объекта.
lst = [1, 2]
lst.extend([3, 4]) # [1, 2, 3, 4]
lst.extend('ab') # [1, 2, 3, 4, 'a', 'b'] ← строка распакуется посимвольно
Зачем: быстро «склеить» списки или добавить много элементов разом.

lst.insert(i, x) — вставить элемент x на позицию i.
lst = ['a', 'c']
lst.insert(1, 'b') # ['a', 'b', 'c']
Зачем: когда нужно вставить ровно в нужное место, а не только в конец.

Удаление и извлечение

lst.remove(x) — удалить первое вхождение x.
lst = [1, 2, 2, 3]
lst.remove(2) # [1, 2, 3]
Важно: если элемента нет — будет ошибка ValueError.

lst.pop([i]) — удалить элемент по индексу i и вернуть его. Если индекс не указан — удаляет последний.
lst = [10, 20, 30]
x = lst.pop() # x = 30, lst = [10, 20]
y = lst.pop(0) # y = 10, lst = [20]
Зачем: нужно и удалить, и использовать удалённый элемент (например, «взять и обработать»).

lst.clear() — полностью очистить список.
lst = [1, 2, 3]
lst.clear() # []

Поиск и подсчёт

lst.index(x[, start[, end]]) — вернуть индекс первого вхождения x.
lst = ['a', 'b', 'c', 'b']
lst.index('b') # 1
lst.index('b', 2) # 3 ← ищем начиная с индекса 2
Важно: если нет элемента — ошибка ValueError.

lst.count(x) — сколько раз встречается x.
[1, 2, 2, 3].count(2) # 2
Зачем: быстрая проверка дубликатов, валидация.

Изменение порядка и сортировка

lst.reverse() — развернуть список на месте.
lst = [1, 2, 3]
lst.reverse() # [3, 2, 1]
Важно: ничего не возвращает, меняет сам список.

lst.sort(key=None, reverse=False) — отсортировать список на месте.
lst = [3, 1, 2]
lst.sort() # [1, 2, 3]
lst.sort(reverse=True) # [3, 2, 1]
Зачем: упорядочить данные. Для сортировки «без изменения оригинала» используют sorted(lst) — он возвращает новый список.

Копирование

lst.copy() — поверхностная копия списка.
a = [1, 2, 3]
b = a.copy() # b — отдельный список
Зачем: чтобы менять копию и не трогать оригинал.

Важное отличие от строк: большинство методов списка (append, extend, sort, reverse и т.д.) меняют список на месте и возвращают None.
Поэтому нельзя писать lst = lst.append(x) — так ты получишь None. Правильно: просто lst.append(x).

🧠 Список (list) — это упорядоченная изменяемая коллекция элементов. В одном списке могут быть числа, строки, другие списки, словари — любые объекты Python.
Как создать: в квадратных скобках, элементы через запятую:

nums = [1, 2, 3]
words = ['apple', 'banana']
mixed = [1, 'text', True, [10, 20]]
empty = []

Главные особенности:

Изменяемый: можно добавлять, удалять, менять элементы «на месте».

Упорядоченный: у каждого элемента есть индекс (начиная с 0), порядок сохраняется.

Гибкий по типам: в одном списке можно хранить разные типы данных.

Длина: узнать количество элементов можно через len(lst).

lst = ['a', 'b', 'c']
len(lst) # 3
lst[0] # 'a'
lst[-1] # 'c'
lst[1] = 'X' # ✅ Можно менять: ['a', 'X', 'c']

Срезы строк (slicing) в Python

Срез — это способ взять из строки подстроку по диапазону индексов. Работает везде: в строках, списках, кортежах.

Синтаксис: s[start:stop[:step]]
start — индекс начала (включительно). Если не указан — с начала строки.
stop — индекс конца (не включительно!). До этого символа, но не включая его.
step — шаг (по умолчанию 1). Можно пропускать символы или идти назад.

s = 'Python'
s[0:3] # 'Pyt' ← символы с 0 по 2
s[:3] # 'Pyt' ← то же, start можно опустить
s[3:] # 'hon' ← от 3 до конца
s[1:-1] # 'ytho' ← без первого и последнего символа

Важно: stop не включается. Это частая ошибка новичков.

Шаг (step)
s[::2] # 'Pto' ← каждый второй символ
s[::-1] # 'nohtyP' ← развернуть строку (очень популярный приём!)
s[1:5:2] # 'yt' ← с 1 по 4, шаг 2

Заменить первый символ

s = 'Python'
s = 'J' + s[1:] # 'Jython'

Убрать первые N символов

s = 'abcdef'
s = s[3:] # 'def'

Убрать последний символ

s = 'hello!'
s = s[:-1] # 'hello'

Вставить текст в середину

s = 'Pyon'
s = s[:2] + 'th' + s[2:] # 'Python'

Методы строк (str) в Python:

Регистр

s.lower() — всё в нижний регистр.
Пример: 'Hello'.lower() → 'hello'
Зачем: сравнивать текст без учёта регистра (ввод пользователя, поиск).

s.upper() — всё в верхний.
Пример: 'hello'.upper() → 'HELLO'
Зачем: коды, идентификаторы, унификация.

s.title() - каждое слово начинается с заглавной буквы.
Пример: 'привет мир'.title() → 'Привет Мир'
Зачем: форматирование заголовков - книг, статей, фильмов, обработка имен и фамилий, названия городов/стран.

s.casefold() — «агрессивное» приведение к нижнему регистру (лучше для международных текстов).
Пример: 'Straße'.casefold() → 'strasse'
Зачем: надёжное сравнение в многоязычных данных.

Очистка и выравнивание

s.strip() — убрать пробелы/табуляции/переносы с обоих концов.
Пример: ' abc \n'.strip() → 'abc'
Зачем: очистка ввода, чтение файлов.

s.lstrip(), s.rstrip() — только слева/справа.
Пример: '---abc---'.lstrip('-') → 'abc---'
Зачем: убрать конкретный символ по краям.

Поиск и проверка

s.startswith(prefix[, start[, end]]) / s.endswith(suffix...) — начинается/заканчивается ли строка.
Пример: 'python_file.pу'.endswith('.py') → True
Зачем: проверка расширений, префиксов.

s.find(sub[, start[, end]]) — индекс первого вхождения или -1, если не найдено.
Пример: 'banana'.find('na') → 2
Зачем: безопасный поиск (не кидает ошибку).

s.index(sub...) — то же, но кидает ValueError, если не найдено.
Пример: 'abc'.index('b') → 1
Зачем: когда отсутствие подстроки — это ошибка логики.

s.count(sub[, start[, end]]) — сколько раз встречается подстрока.
Пример: 'banana'.count('a') → 3
Зачем: статистика, валидация.

Изменение и разбиение

s.replace(old, new[, count]) — заменить подстроку.
Пример: 'cat cat cat'.replace('cat', 'dog', 2) → 'dog dog cat'
Зачем: нормализация текста, маскирование.

s.split(sep=None, maxsplit=-1) — разбить строку на список.
Пример: 'a,b,c'.split(',') → ['a', 'b', 'c']
Зачем: парсинг CSV, логов, аргументов.

sep.join(iterable) — собрать строку из списка.
Пример: '-'.join(['2024', '05', '10']) → '2024-05-10'
Зачем: формировать пути, даты, команды.

Проверка содержимого

s.isalpha(), s.isdigit(), s.isalnum() — буквы/цифры/буквы+цифры.
Пример: '123'.isdigit() → True
Зачем: валидация ввода (номер, имя, код).

s.isspace() — состоит ли строка только из пробельных символов.
Пример: ' '.isspace() → True
Зачем: отличать «пустую строку» от «строки из пробелов».

🧠 Строка (str) — это упорядоченная последовательность символов (букв, цифр, знаков, эмодзи) в кодировке Unicode.
Как создать: просто взять текст в кавычки.
Строки в Python неизменяемы: любой метод возвращает новую строку, оригинал не трогает.

s = 'Python'
len(s) # 6
s[0] # 'P'
s[-1] # 'n'

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

s[1:3] = 'XY' # ❌ TypeError: 'str' object does not support item assignment

Чтобы «изменить» строку, создают новую, например:
new_s = 'J' + s[1:] # ✅ 'Jython'
или через переприсваивание
s = 'Python'
s = 'J' + s[1:] # 'Jython'

Склеить строки (конкатенация) через +:
'Hello, ' + 'Python' # 'Hello, Python'

Повторить строку через *:
'ha' * 3 # 'hahaha'