Python для начинающих
1.11K subscribers
365 photos
3 videos
232 files
67 links
Python для начинающих
Download Telegram
Привет, друзья! Меня зовут Иван, и сегодня я расскажу вам, как начать автоматизировать проверку вашего Python-кода с помощью встроенного модуля unittest. Даже если вы только начинаете свой путь в программировании, поверьте — тесты быстро станут вашими лучшими помощниками!

## Зачем нужны автоматические тесты?

Пока проект маленький, ошибки найти просто. Но как только код начинает разрастаться, простая проверка глазами становится неэффективной. Тут и приходит на помощь unittest: вы пишете специальные функции, которые автоматически запускаются и проверяют поведение вашего кода.

## Ваш первый тест

Допустим, у вас есть функция, которая складывает числа:

def add(a, b):
return a + b


Напишем к ней тест:

import unittest

class TestAddFunction(unittest.TestCase):
def test_add_positive(self):
self.assertEqual(add(2, 3), 5)

def test_add_zero(self):
self.assertEqual(add(0, 0), 0)

def test_add_negative(self):
self.assertEqual(add(-1, -1), -2)

if __name__ == '__main__':
unittest.main()


Что здесь происходит? Мы наследуемся от unittest.TestCase и определяем методы, начинающиеся с test_. Каждый такой метод — отдельная проверка. Если что-то пошло не так, unittest сразу об этом сообщит.

## Как работает unittest

- assertEqual(a, b): проверяет, что a и b равны.
- assertTrue(expr): выражение истинно.
- assertRaises: ожидается исключение.

Давайте добавим пример с ошибкой:

def divide(a, b):
return a / b

class TestDivideFunction(unittest.TestCase):
def test_divide_by_zero(self):
with self.assertRaises(ZeroDivisionError):
divide(1, 0)


Этот тест пройдет, если функция действительно выбрасывает ZeroDivisionError при делении на ноль.

## Полезные советы

- Один тест — одна логика. Это облегчает поиск багов.
- Давайте тестам говорящие имена: test_sum_with_zero, test_divide_by_negative.
- Запускать тесты можно командой python my_test.py.
- Не бойтесь писать тесты даже для простых функций!

Автоматическое тестирование — это ваш надежный щит против багов. Начните использовать unittest прямо сегодня и почувствуйте разницу: код становится чище, а жизнь — спокойнее.
👍1
- Как установить и использовать библиотеку Pillow для базовой обработки изображений.
Привет! С вами Иван, и сегодня мы научимся работать с изображениями в Python, используя библиотеку Pillow. Если вам когда-либо хотелось быстро изменить размер изображения, повернуть его или преобразовать в черно-белое — этот пост для вас! Всё просто, красиво и, конечно, на Python.

### Установка Pillow

Для начала поставим Pillow — это «переосмысленный» PIL, классическая библиотека для обработки изображений в Python. Открываем терминал и набираем:

pip install pillow


Вуаля! Теперь у нас есть весь инструментарий для базовых (и не только!) манипуляций с картинками.

### Открываем и сохраняем изображение

Сначала посмотрим, как просто загрузить файл:

from PIL import Image

img = Image.open('example.jpg')
img.show()


Метод show() откроет картинку в просмотрщике по умолчанию. Чтобы сохранить копию в другом формате:

img.save('example_copy.png')


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

Очень часто нужно «ужать» картинку до нужных размеров. Делается это одной строчкой:

resized_img = img.resize((200, 200))
resized_img.save('resized_example.jpg')


### Поворот изображения

А как насчет вращения? Вот так:

rotated_img = img.rotate(90)
rotated_img.save('rotated_example.jpg')


Угол указываем в градусах, против часовой стрелки.

### Перевод в черно-белое

Бывает, требуется сделать изображение черно-белым — например, для аватара или стикера.

bw_img = img.convert('L')
bw_img.save('bw_example.jpg')


Аргумент 'L' означает градации серого (8-bit).

### Кадрирование (crop)

Хочется урезать лишнее? Используем crop, указав координаты прямоугольника:

cropped_img = img.crop((50, 50, 300, 300))
cropped_img.save('cropped_example.jpg')


### Лёгкая обработка на лету

Комбинировать операции легко. Например, уменьшим и повернём картинку:

new_img = img.resize((100, 100)).rotate(45)
new_img.save('combo_example.jpg')


### На заметку

Pillow поддерживает множество форматов: JPEG, PNG, BMP, GIF и даже ICO. Всё, о чём мечтал начинающий Python-разработчик-графоман! Главное — не забывайте всегда открывать файлы в режиме чтения байтов, если работаете с потоками или web, но это уже тема для следующего поста.

Так что, вооружайтесь Python, пробуйте Pillow и создавайте свои шедевры из любых изображений — быстро и просто.
До новых встреч!
👍1
- Работа с API OpenAI: основы GPT и генерация текста.
Привет, друзья! С вами Иван, и сегодня мы окунемся в захватывающий мир искусственного интеллекта: поговорим о том, как работать с API OpenAI и создавать свой собственный генератор текста на Python. Готовьте свои токены!

## Что такое OpenAI API и зачем он нужен?

OpenAI API — это облачный сервис, который позволяет взаимодействовать с моделями семейства GPT напрямую из вашего приложения. С его помощью можно не только генерировать тексты, но и реализовать чат-бота, автодополнение или даже писать стихи по заданной теме!

## Начинаем: регистрация и установка

Для начала понадобится API-ключ. Зарегистрируйтесь на platform.openai.com, получите ключ и установите библиотеку:

pip install openai


## Первый пример: переводим идеи в текст

Воспользуемся модулем openai и создадим простейшую функцию генерации:

import openai

openai.api_key = "your-api-key-here"

def generate_text(prompt):
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo", # Бесплатная и шустрая модель
messages=[{"role": "user", "content": prompt}],
max_tokens=100 # Ограничим длину ответа
)
return response.choices[0].message['content']

output = generate_text("Suggest three creative project ideas for Python beginners.")
print(output)


Этот небольшой скрипт превращает вашу команду (prompt) в связный английский текст. Пример выше попросит ИИ предложить три идеи проектов.

## Немного магии параметров

- model — выбирайте актуальную модель (сейчас популярны gpt-3.5-turbo, gpt-4).
- messages — можно вести полноценный диалог с ИИ: передавайте цепочку сообщений.
- max_tokens — ограничивает длину генерируемого ответа.
- temperature (по умолчанию 1) — регулирует креативность: ниже — ответы строже и предсказуемей, выше — более неожиданные.

## Делаем помощника-программиста

Как насчёт на лету генерировать сниппеты кода?

query = "Write Python code to print all prime numbers up to 50"
print(generate_text(query))


GPT сам напишет нужный фрагмент — экономьте время и силы!

---

Всем успехов в покорении сил мощного искусственного интеллекта. С помощью OpenAI API и Python ваши идеи быстро превратятся в настоящие умные приложения!
👍1🔥1
- Использование модуля hashlib для создания хэшей.
Привет! С вами Иван, и сегодня мы окунёмся в мир хэшей в Python, познакомившись с модулем hashlib. Вопрос безопасности и хранения паролей — один из самых частых на практике, и здесь на помощь приходит этот мощный инструмент. Как именно? Сейчас расскажу!

### Что такое хэш?

Хэш-функции преобразуют любые данные в фиксированной длины строку байт (обычно в виде шестнадцатеричной строки). Особенность — малейшее изменение исходных данных радикально меняет результат. Это идеальный способ проверки целостности информации и хранения паролей.

### Быстрый старт с hashlib

Модуль hashlib — это стандартная библиотека, никакой установки не требуется. Давайте попробуем посчитать хэш обычной строки:

import hashlib

data = "I love Python!"
hash_object = hashlib.sha256(data.encode())
hex_dig = hash_object.hexdigest()
print(hex_dig)


Вывод — длинная строка из цифр и букв. Это SHA-256 хэш вашей строки. Важно: если вы попробуете изменить хотя бы один символ в исходной строке, результат будет совершенно другим!

### Зачем это нужно?

1. Проверка целостности файлов: скачали файл и хотите убедиться, что он не повреждён? Считайте хэш и сравните.
2. Хранение паролей: сохранять пароли в «чистом» виде — плохая идея! Лучше храните хэши и сравнивайте их при проверке.
3. Генерация уникальных идентификаторов: иногда удобно быстро получить короткий “отпечаток” больших данных.

### Пример: проверка целостности файла

import hashlib

def file_hash(filename):
hash_md5 = hashlib.md5()
with open(filename, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
hash_md5.update(chunk)
return hash_md5.hexdigest()

print(file_hash("example.txt"))


### Коротко о популярных алгоритмах

- MD5 — быстро, но уже не считается безопасным.
- SHA-1 — тоже устарел в плане криптографии.
- SHA-256, SHA-512 — намного надёжнее и чаще используются.

### Работа с паролями

import hashlib

def hash_password(password):
return hashlib.sha256(password.encode()).hexdigest()

# Сохраняем только значение функции hash_password


На этом всё! Применяйте hashlib для защиты своих данных, это просто, быстро и современно.
👍2
- Как создавать контекстные менеджеры с использованием ключевого слова with.
Друзья, всем привет! С вами Иван — и сегодня мы погружаемся в волшебный мир контекстных менеджеров Python. Если вы когда-нибудь открывали файлы с помощью конструкции with, то вы уже их встречали в «дикой природе». Но что, если ваши задачи требуют создать свой собственный менеджер? Давайте разбираться, как это сделать!

### Почему это круто?

Контекстные менеджеры позволяют элегантно управлять ресурсами: открытием и закрытием файлов, подключениями к базам данных, блокировкой потоков и даже временными изменениями настроек. Всё это — без лишнего кода, «разруливания» ошибок и необходимости помнить делать "уборку" вручную.

### Пример 1: Файловый менеджер, только свой

Ручное открытие файла = шанс забыть его закрыть. А вот так — забудь о заботах:

class CustomFile:
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
self.file = None

def __enter__(self):
self.file = open(self.filename, self.mode)
return self.file

def __exit__(self, exc_type, exc_val, exc_tb):
if self.file:
self.file.close()


Используем наш менеджер:

with CustomFile('example.txt', 'w') as file:
file.write('Hello, context!')


### Пример 2: Управляем ресурсами без классов

Иногда нужен менеджер "по-быстрому". Здесь спасает модуль contextlib с его декоратором @contextmanager:

from contextlib import contextmanager

@contextmanager
def temporary_switch(val):
print('Switch ON')
yield val
print('Switch OFF')

with temporary_switch('something'):
print('Working inside the context')


### Как это работает?

- В первом примере __enter__ запускается при входе в блок, возвращая нужный объект (например, сам файл).
- __exit__ срабатывает на выходе из блока (даже если случилась ошибка!) и заботится о закрытии или любой другой очистке.
- В декораторе всё просто: до yield — вход, после — выход.

### Где применить?

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

Экспериментируйте! Создайте свой менеджер для каких-нибудь временных изменений или аккуратного подключения к сервису. Ваш Python-код скажет вам за это спасибо.
🥰2
- Создание простого REST API с Flask и Python.
Привет! На связи Иван, и сегодня мы вместе сделаем свой первый REST API на Python с помощью Flask. REST API — это такой способ строительства интерфейса, чтобы разные приложения могли общаться друг с другом по сети на понятном и логичном языке “запрос-ответ”. Flask идеально подходит для начинающих: он легкий, лаконичный и очень “человечный”.

## Установка Flask

Начнем с минимума – установка одной командой:

pip install flask


## Скелет приложения

Создадим простой API для управления списком книг (CRUD: создать, прочитать, обновить, удалить). Код будет коротким, но покажет основные приёмы.

from flask import Flask, jsonify, request

app = Flask(__name__)

books = [
{"id": 1, "title": "1984", "author": "George Orwell"},
{"id": 2, "title": "Brave New World", "author": "Aldous Huxley"}
]


## Выдаём все книги

@app.route('/books', methods=['GET'])
def get_books():
return jsonify(books)


## Добавляем книгу

@app.route('/books', methods=['POST'])
def add_book():
data = request.get_json()
new_book = {
"id": books[-1]["id"] + 1 if books else 1,
"title": data["title"],
"author": data["author"]
}
books.append(new_book)
return jsonify(new_book), 201


## Получить книгу по id

@app.route('/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
book = next((b for b in books if b['id'] == book_id), None)
if book:
return jsonify(book)
return jsonify({"error": "Not found"}), 404


## Удаление книги

@app.route('/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
global books
books = [b for b in books if b['id'] != book_id]
return '', 204


## Запуск сервера

if __name__ == '__main__':
app.run(debug=True)


Теперь можно “пощупать” API: проверить через Postman или curl, как он реагирует на разные запросы.

## Итоги

С Flask можно за 10 минут сделать работающий API, который примет запросы с любого устройства и вернет аккуратный JSON-ответ. Если чувствуешь вкус к этому — впереди Flask-Restful, JWT, SQLAlchemy и еще гора крутых инструментов. А пока рад, что ты сделал свой первый REST API!
👍5
- Разработка чат-ботов с использованием Telegram API и библиотеки python-telegram-bot.
Привет! С вами Иван, и сегодня мы отправимся в захватывающее путешествие в мир чат-ботов для Telegram. Если вы хоть раз получали от бота погоду, смешную гифку или уведомление из любимого приложения — поздравляю, вы уже на правильном пути! А теперь давайте посмотрим, как создать своего собственного Telegram-бота на Python с помощью великолепной библиотеки python-telegram-bot.

## Почему именно python-telegram-bot?

Библиотека python-telegram-bot — это удобная "обертка" над Telegram Bot API: она избавляет вас от рутины работы с HTTP-запросами, помогает обрабатывать команды, текст, кнопки и много-много всего.

## Первый шаг: заводим бота

Создайте нового бота через @BotFather в Telegram — он даст вам токен. Храните его в секрете, иначе ваш бот может стать жертвой хулиганов!

## Установка библиотеки

pip install python-telegram-bot --upgrade


## Простой пример: Эхо-бот

Создадим бота, который будет отвечать пользователю тем же текстом:

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
await update.message.reply_text("Привет! Я эхо-бот. Напиши мне что-нибудь.")

async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE):
await update.message.reply_text(update.message.text)

app = Application.builder().token("YOUR_BOT_TOKEN").build()
app.add_handler(CommandHandler("start", start))
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))
app.run_polling()


И всё — у вас уже есть работоспособный бот! Просто вставьте ваш токен и запустите скрипт.

## Добавим команду

Чат-боты отлично справляются с различными командами. Например, добавим простую команду /help:

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
await update.message.reply_text("Напиши что-нибудь, и я повторю это за тобой!")

app.add_handler(CommandHandler("help", help_command))


## Почему это круто?

С помощью python-telegram-bot вы можете создавать настоящие мини-приложения в Telegram: интерактивные меню с Inline кнопками, опросы, присылать картинки, аудио, документы — и всё это буквально в пару строк кода.

## Вдохновляйтесь и экспериментируйте!

Посмотрите документацию: https://python-telegram-bot.readthedocs.io. Попробуйте добавить обработку фото или кнопки, или присылать случайное число по команде.

Создавать Telegram-ботов на Python удобно, весело и весьма полезно для тренировки своих навыков программирования. Удачного кода!
👍1
- Введение в типизацию Python: использование библиотеки typing.
Привет, друзья! С вами Иван, и сегодня мы поговорим об одной важной, но часто пугающей теме — типизации в Python. Если вы воспринимаете Python как язык “без заморочек”, то, возможно, удивитесь, что строгая типизация здесь тоже возможна — и даже может реально облегчить жизнь!

Python — динамический язык: переменные “перехватывают” типы данных на лету. Но в больших проектах это может сыграть злую шутку: слишком просто ошибиться и получить головную боль при отладке. Поэтому с версии 3.5 в Python появилась библиотека typing, которая позволяет явно указывать, какие типы данных характерны для ваших функций и переменных.

Зачем это нужно? Аннотации типов делают код читабельнее и позволяют “умным” редакторам (VSCode, PyCharm), а также инструментам типа mypy, находить ошибки ДО выполнения программы.

Рассмотрим пример — пишем функцию для сложения чисел:

def add(a: int, b: int) -> int:
return a + b


Теперь сразу видно: оба аргумента — это числа, и возвращать мы тоже планируем число. Попробуйте подставить строку — mypy сработает: “Так нельзя!”

typing раскрывается особенно удобно с коллекциями. Пусть у нас есть список чисел:

from typing import List

def average(numbers: List[float]) -> float:
return sum(numbers) / len(numbers)


Всё прозрачно: функция ждет список чисел с плавающей точкой, возвращает тоже “флоат”.

Что если функция возвращает или число, или None? Для этого есть аннотация Optional:

from typing import Optional

def find_value(data: List[int], target: int) -> Optional[int]:
for x in data:
if x == target:
return x
return None


А если функция возвращает несколько значений — используем Tuple:

from typing import Tuple

def min_max(values: List[int]) -> Tuple[int, int]:
return min(values), max(values)


typing поддерживает и дженерики, и словари (Dict), и объединение нескольких типов через Union — их возможности огромны! А с Python 3.9 стало удобно просто писать list[int], dict[str, int].

Используйте аннотации не только ради погони за “строгостью”, а чтобы ваши функции были понятнее — вам самим и коллегам в будущем. Свой код вы наверняка переспрашивали: “Что тут вообще возвращается?” — теперь такой проблемы не будет.

Вот и всё на сегодня. Используйте силу типизации, и пусть баги обходят ваш код стороной!
👍1
- Как работать с файлами JSON: чтение, запись и преобразование данных.
Привет! Иван на связи. Сегодня у нас в меню — JSON: тот самый формат, в котором весь современный мир хранит данные. Его едят бэкендеры, фронтендеры и даже базы данных! Пора научиться ловко читать, записывать и трансформировать JSON-файлы на Python. Всё просто, давайте разбираться на примерах.

### Читаем JSON как профи

Предположим, у вас есть файл data.json с содержимым:

{
"name": "Alice",
"age": 25,
"languages": ["English", "German"]
}


Загрузим его так:

import json

with open('data.json', 'r') as file:
data = json.load(file)
print(data)


Теперь data — обычный Python-словарь. Можно обращаться к полям: data['name'], data['languages'].

### Сохраняем свои данные в JSON

Допустим, мы хотим создать базу супергероев:

heroes = [
{"name": "Spider-Man", "power": "Spider-sense"},
{"name": "Iron Man", "power": "Genius intellect"},
]

with open('heroes.json', 'w') as file:
json.dump(heroes, file, indent=4)


Параметр indent добавляет "красоту" в ваш JSON — удобно для глаз и ревью.

### Преобразование: JSON <-> строка

Иногда данные нужно не только читать-записывать из файла, но и гонять их по сети или хранить в БД. Для этого JSON можно превращать в строку:

heroes_str = json.dumps(heroes)
print(heroes_str)


А можно обратно:

new_heroes = json.loads(heroes_str)
print(new_heroes)


### Лайфхаки и подводные камни

- Python не может сериализовать некоторые типы данных (например, объекты, set) напрямую — используйте списки и словари.
- Не забывайте про исключения: JSONDecodeError спасёт от "кривого" файла.

Коротко: модуль json — один из самых удобных инструментов Python. Учитесь его использовать, и обмениваться данными станет гораздо проще!
👍1
- Основы сериализации с модулем pickle в Python.
Привет, друзья! На связи Иван, и сегодня я расскажу о модуле, который обязательно пригодится всем, кто начинает программировать на Python. Встречайте — модуль pickle, магический инструмент для сериализации!

### Что такое сериализация?

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

### Когда нужен pickle?

- Сохранять сложные объекты (например, список диктов, пользовательские классы) для последующего использования.
- Передавать данные между процессами.
- Кэшировать результаты вычислений.

### Короче, давайте к делу!

#### Сохраняем объект

Вот как легко сериализовать объект с помощью pickle:

import pickle

data = {'name': 'Alice', 'age': 30, 'friends': ['Bob', 'Eve']}
with open('data.pickle', 'wb') as f:
pickle.dump(data, f)

Вуаля! Теперь у вас есть файл с объектом в байтовом формате.

#### Восстанавливаем объект

Достаём объект обратно:

import pickle

with open('data.pickle', 'rb') as f:
recovered_data = pickle.load(f)
print(recovered_data)

И снова получаем родной словарь, как ни в чем не бывало.

### Сериализация собственных классов

pickle умеет работать даже с пользовательскими объектами:

class User:
def __init__(self, username):
self.username = username

user = User('Ivan')
with open('user.pickle', 'wb') as f:
pickle.dump(user, f)

with open('user.pickle', 'rb') as f:
loaded_user = pickle.load(f)
print(loaded_user.username)


### Что важно помнить?

- Файлы, созданные pickle, нельзя читать обычным текстовым редактором.
- pickle не гарантирует совместимость между разными версиями Python.
- Никогда не открывайте чужие pickle-файлы, если не доверяете их источнику — это небезопасно.

### Альтернатива?

Для обмена данными между разными языками вместо pickle чаще используют json, но json не умеет всё то, что pickle — например, сериализовать пользовательские объекты.

---

Попробуйте познакомиться с pickle поближе — возможно, это упростит вашу работу с Python в несколько раз!
👍1
- Создание шаблонов веб-приложений с использованием Jinja2.
Привет! С вами Иван, и сегодня мы поговорим о небольшой, но весьма мощной библиотеке — Jinja2. Если вы хоть раз задумывались о создании веб-приложений на Python, этот инструмент просто незаменим для красивого и удобного шаблонирования.

## Что такое Jinja2?

Jinja2 — это движок шаблонов, который позволяет отделить логику вашего приложения от его внешнего вида. Вы описываете структуру HTML в отдельных файлах, а данные подставляете прямо из Python-кода. Такой подход используют как маленькие проекты, так и гиганты, вроде Flask или даже Django в своих шаблонизаторах.

## Как это работает?

Установить Jinja2 очень просто:

pip install Jinja2


Минимальный пример кода — создаём шаблон, передаём в него данные, и получаем готовый HTML:

from jinja2 import Template

template_str = "Hello, {{ name }}!"
template = Template(template_str)
result = template.render(name="World")

print(result) # Выведет: Hello, World!


Выглядит просто? На деле возможности Jinja2 куда шире. Допустим, вам нужно отобразить таблицу пользователей:

from jinja2 import Template

users = [
{"username": "alice", "score": 100},
{"username": "bob", "score": 95}
]

template_str = """
<table>
{% for user in users %}
<tr>
<td>{{ user.username }}</td>
<td>{{ user.score }}</td>
</tr>
{% endfor %}
</table>
"""

template = Template(template_str)
result = template.render(users=users)
print(result)


Jinja2 поддерживает условные конструкции, фильтры, макросы, наследование шаблонов — чем не миниязык для автогенерации контента? Например, вывод разных сообщений в зависимости от числа баллов:

template_str = """
{% if score >= 100 %}
<p>Вы победитель!</p>
{% else %}
<p>Пробуйте еще!</p>
{% endif %}
"""

print(Template(template_str).render(score=55))


## Использование с Flask

Jinja2 интегрирован в Flask "под капотом". Вот пример рендеринга шаблона:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def index():
return render_template("index.html", name="Ivan")


А в index.html:

<h1>Привет, {{ name }}!</h1>


## Итог

Jinja2 — это быстрая и удобная отправная точка для разделения логики и представления в ваших python-проектах. Он даёт гибкость и порядок там, где чистый HTML превращается в сплошную «кашу» из форматирования и данных. Попробуйте, и ваши веб-приложения станут не только красивее, но и проще в поддержке!

— Иван
🔥2