Что такое if

# файл example.py
print(f"Значение __name__: {__name__}")

if __name__ == "__main__":
print("Этот код выполнится только при прямом запуске файла")
else:
print("Этот код выполнится только при импорте файла как модуля")

Значение __name__: __main__
Этот код выполнится только при прямом запуске файла

# файл another_script.py
import example
print("Код в another_script.py")

Значение __name__: example
Этот код выполнится только при импорте файла как модуля
Код в another_script.py

# data_processor.py
def process_data(data):
"""Обрабатывает данные и возвращает результат."""
return [x * 2 for x in data]

def filter_data(data, threshold):
"""Фильтрует данные по пороговому значению."""
return [x for x in data if x > threshold]

# Код для демонстрации и тестирования
if __name__ == "__main__":
test_data = [1, 5, 10, 15, 20]
print("Тестирование функций обработки данных:")
print(f"Исходные данные: {test_data}")
processed = process_data(test_data)
print(f"После обработки: {processed}")
filtered = filter_data(processed, 15)
print(f"После фильтрации (порог > 15): {filtered}")

# main_app.py
import data_processor

my_data = [3, 6, 9, 12]
result = data_processor.process_data(my_data)
print(f"Обработанные данные: {result}")

# csv_processor.py
import csv
import sys
from datetime import datetime

def read_csv(filename):
"""Читает CSV файл и возвращает данные в виде списка словарей."""
data = []
try:
with open(filename, 'r', newline='', encoding='utf-8') as f:
reader = csv.DictReader(f)
for row in reader:
data.append(row)
return data
except Exception as e:
print(f"Ошибка при чтении CSV файла: {e}")
return None

def write_csv(filename, data, fieldnames=None):
"""Записывает данные в CSV файл."""
if not fieldnames and data:
fieldnames = data[0].keys()

try:
with open(filename, 'w', newline='', encoding='utf-8') as f:
writer = csv.DictWriter(f, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(data)
return True
except Exception as e:
print(f"Ошибка при записи CSV файла: {e}")
return False

def process_sales_data(data):
"""Обрабатывает данные о продажах, добавляя итоговую сумму."""
processed = []
for row in data:
new_row = row.copy()
new_row['total'] = float(row.get('price', 0)) * float(row.get('quantity', 0))
processed.append(new_row)
return processed

if __name__ == "__main__":
# Код, который выполняется только при прямом запуске файла
if len(sys.argv) < 2:
print("Использование: python csv_processor.py <input_file> [output_file]")
sys.exit(1)

input_file = sys.argv[1]
output_file = sys.argv[2] if len(sys.argv) > 2 else f"processed_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"

print(f"Обработка файла {input_file}...")
data = read_csv(input_file)

if data:
processed_data = process_sales_data(data)
if write_csv(output_file, processed_data):
print(f"Обработанные данные сохранены в {output_file}")
else:
print("Не удалось сохранить обработанные данные")
else:
print("Данные не были загружены. Обработка прервана.")

# image_resizer.py
import argparse
from PIL import Image

def resize_image(image_path, output_path, width, height):
"""Изменяет размер изображения до указанных размеров."""
try:
img = Image.open(image_path)
resized_img = img.resize((width, height))
resized_img.save(output_path)
return True
except Exception as e:
print(f"Ошибка при изменении размера изображения: {e}")
return False

def batch_resize(images, output_dir, width, height):
"""Обрабатывает пакет изображений."""
results = []
for img_path in images:
filename = img_path.split("/")[-1]
output_path = f"{output_dir}/{filename}"
success = resize_image(img_path, output_path, width, height)
results.append((img_path, success))
return results

if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Изменение размера изображений')
parser.add_argument('images', nargs='+', help='Пути к изображениям')
parser.add_argument('--output-dir', '-o', default='.', help='Директория для сохранения результатов')
parser.add_argument('--width', '-w', type=int, default=800, help='Ширина (в пикселях)')
parser.add_argument('--height', '-h', type=int, default=600, help='Высота (в пикселях)')

args = parser.parse_args()

results = batch_resize(args.images, args.output_dir, args.width, args.height)

# Вывод результатов
for path, success in results:
status = "успешно" if success else "с ошибкой"
print(f"Обработка {path}: {status}")

python image_resizer.py image1.jpg image2.png --width 1024 --height 768 -o resized

import image_resizer

# Программное использование функций
images = ["path/to/image1.jpg", "path/to/image2.png"]
image_resizer.batch_resize(images, "output_folder", 1920, 1080)

# math_utils.py
def factorial(n):
"""
Вычисляет факториал числа n.

Аргументы:
n (int): Неотрицательное целое число

Возвращает:
int: n! = n * (n-1) * ... * 1

Примеры:
>>> factorial(5)
120
>>> factorial(0)
1
"""
if n < 0:
raise ValueError("Факториал определен только для неотрицательных чисел")
result = 1
for i in range(2, n + 1):
result *= i
return result

def fibonacci(n):
"""
Возвращает n-ое число Фибоначчи.

Аргументы:
n (int): Позиция в последовательности (начиная с 0)

Возвращает:
int: n-ое число последовательности Фибоначчи

Примеры:
>>> fibonacci(0)
0
>>> fibonacci(1)
1
>>> fibonacci(10)
55
"""
if n < 0:
raise ValueError("Индекс должен быть неотрицательным")
if n <= 1:
return n
a, b = 0, 1
for _ in range(2, n + 1):
a, b = b, a + b
return b

if __name__ == "__main__":
# Демонстрация работы функций и примеры использования
print("Демонстрация математических утилит\n")

print("1. Факториал")
test_values = [0, 1, 5, 10]
for n in test_values:
print(f"factorial({n}) = {factorial(n)}")

print("\n2. Числа Фибоначчи")
for n in range(11):
print(f"fibonacci({n}) = {fibonacci(n)}")

print("\nПример вычисления больших значений:")
try:
large_factorial = factorial(20)
print(f"factorial(20) = {large_factorial}")
except Exception as e:
print(f"Ошибка: {e}")

try:
large_fibonacci = fibonacci(30)
print(f"fibonacci(30) = {large_fibonacci}")
except Exception as e:
print(f"Ошибка: {e}")

# string_processor.py
import re
import time

def clean_text(text):
"""Очищает текст от специальных символов и лишних пробелов."""
# Удаляем специальные символы
text = re.sub(r'[^\w\s]', '', text)
# Заменяем множественные пробелы на один
text = re.sub(r'\s+', ' ', text)
return text.strip()

def count_words(text):
"""Подсчитывает количество слов в тексте."""
if not text:
return 0
words = text.split()
return len(words)

def find_most_common_words(text, limit=10):
"""Находит наиболее часто встречающиеся слова в тексте."""
if not text:
return []

# Очищаем и приводим к нижнему регистру
clean = clean_text(text.lower())
words = clean.split()

# Считаем частоту слов
word_counts = {}
for word in words:
word_counts[word] = word_counts.get(word, 0) + 1

# Сортируем по частоте (по убыванию)
sorted_words = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)

# Возвращаем наиболее частые слова
return sorted_words[:limit]

if __name__ == "__main__":
# Тестирование функций и измерение производительности
print("Тестирование и бенчмаркинг функций обработки строк\n")

# Тестовые данные
test_text = """Python — это высокоуровневый язык программирования общего назначения. 
Его философия дизайна подчёркивает читаемость кода с заметным использованием
значительного количества пробелов. Python использует динамическую типизацию 
и сборку мусора."""

# Тест 1: clean_text
print("Тест функции clean_text:")
messy_text = "Hello, world!!! This is a test... with multiple spaces."
cleaned = clean_text(messy_text)
print(f"Исходный текст: {messy_text}")
print(f"Очищенный текст: {cleaned}")
print()

# Тест 2: count_words
print("Тест функции count_words:")
word_count = count_words(test_text)
print(f"Количество слов: {word_count}")
print()

# Тест 3: find_most_common_words
print("Тест функции find_most_common_words:")
common_words = find_most_common_words(test_text, 5)
print("Топ-5 наиболее часто встречающихся слов:")
for word, count in common_words:
print(f"- '{word}': {count} раз")
print()

# Бенчмарк
print("Бенчмарк производительности:")

# Генерируем более длинный текст для тестирования производительности
long_text = test_text * 1000

# Измеряем время выполнения каждой функции
print("Очистка длинного текста...")
start = time.time()
clean_text(long_text)
clean_time = time.time() – start
print(f"Время выполнения: {clean_time:.4f} секунд")

print("Подсчет слов в длинном тексте...")
start = time.time()
count_words(long_text)
count_time = time.time() – start
print(f"Время выполнения: {count_time:.4f} секунд")

print("Поиск частых слов в длинном тексте...")
start = time.time()
find_most_common_words(long_text, 10)
find_time = time.time() – start
print(f"Время выполнения: {find_time:.4f} секунд")

# bad_module.py
if __name__ == "__main__":
def important_function():
return "This is an important result"

CONSTANT = 42

# good_module.py
def important_function():
return "This is an important result"

CONSTANT = 42

if __name__ == "__main__":
# Тестирование или демонстрация
result = important_function()
print(result)
print(f"Константа: {CONSTANT}")

if __name__ == '__main__': # Одинарные кавычки вместо двойных (работает, но не соответствует стандарту)
if __name__ = "__main__": # Использование = вместо == (синтаксическая ошибка)
if __name__ == "__main__": # Пропущено двоеточие (синтаксическая ошибка)
if __name__ == "__Main__": # Неправильный регистр (никогда не будет True)
if __name__ == "__main__" : # Лишний пробел перед двоеточием (работает, но не соответствует стилю PEP 8)

if __name__ == "__main__":
# Код для выполнения при прямом запуске

# messy_script.py
def helper_function(data):
return [x * 2 for x in data]

if __name__ == "__main__":
import sys
import json

if len(sys.argv) < 2:
print("Usage: python script.py <filename>")
sys.exit(1)

filename = sys.argv[1]

try:
with open(filename, 'r') as f:
data = json.load(f)
except Exception as e:
print(f"Error loading file: {e}")
sys.exit(1)

processed_data = []
for item in data:
if 'value' in item:
processed = helper_function(item['value'])
processed_data.append({
'id': item.get('id', 'unknown'),
'processed_value': processed
})

output_filename = f"processed_{filename}"
try:
with open(output_filename, 'w') as f:
json.dump(processed_data, f, indent=2)
print(f"Processed data saved to {output_filename}")
except Exception as e:
print(f"Error saving processed data: {e}")

# organized_script.py
import sys
import json

def helper_function(data):
return [x * 2 for x in data]

def process_data(data):
processed_data = []
for item in data:
if 'value' in item:
processed = helper_function(item['value'])
processed_data.append({
'id': item.get('id', 'unknown'),
'processed_value': processed
})
return processed_data

def load_data(filename):
try:
with open(filename, 'r') as f:
return json.load(f)
except Exception as e:
raise ValueError(f"Error loading file: {e}")

def save_data(data, filename):
try:
with open(filename, 'w') as f:
json.dump(data, f, indent=2)
return True
except Exception as e:
raise ValueError(f"Error saving data: {e}")

def main():
if len(sys.argv) < 2:
print("Usage: python script.py <filename>")
return 1

filename = sys.argv[1]

try:
data = load_data(filename)
processed_data = process_data(data)
output_filename = f"processed_{filename}"
save_data(processed_data, output_filename)
print(f"Processed data saved to {output_filename}")
return 0
except ValueError as e:
print(str(e))
return 1

if __name__ == "__main__":
sys.exit(main())

# config.py
import logging

# Глобальная настройка, которая влияет на все приложение
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s – %(levelname)s – %(message)s')

def get_config():
return {'debug': True, 'log_level': 'DEBUG'}

if __name__ == "__main__":
config = get_config()
print("Configuration:", config)

# config.py
import logging

def setup_logging():
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s – %(levelname)s – %(message)s')

def get_config():
return {'debug': True, 'log_level': 'DEBUG'}

if __name__ == "__main__":
setup_logging()
config = get_config()
print("Configuration:", config)