15. Кортежи и диапазоны: простые неизменяемые последовательности

# Кортеж с результатами тестов студентов
scores = (85, 92, 78, 95)
print(scores)  # Output: (85, 92, 78, 95)
print(type(scores))  # Output: <class 'tuple'>
 
# Кортеж со смешанными типами данных
student_info = ("Alice", 20, "Computer Science", 3.8)
print(student_info)  # Output: ('Alice', 20, 'Computer Science', 3.8)
 
# Пустой кортеж
empty = ()
print(empty)  # Output: ()
print(len(empty))  # Output: 0

# Все эти варианты создают один и тот же кортеж
coordinates_1 = (10, 20)
coordinates_2 = 10, 20  # Скобки не нужны!
print(coordinates_1)  # Output: (10, 20)
print(coordinates_2)  # Output: (10, 20)
print(coordinates_1 == coordinates_2)  # Output: True
 
# Важна именно запятая
x = (42)  # Это просто целое число 42 в скобках
y = (42,)  # Это кортеж, содержащий один элемент
print(type(x))  # Output: <class 'int'>
print(type(y))  # Output: <class 'tuple'>
print(y)  # Output: (42,)

# Без скобок это выглядело бы неоднозначно
def get_dimensions():
    return 1920, 1080  # Returns a tuple
 
width, height = get_dimensions()
print(f"Screen: {width}x{height}")  # Output: Screen: 1920x1080
 
# Скобки нужны при передаче кортежей как аргументов функции
print((1, 2, 3))  # Output: (1, 2, 3)
# Без скобок Python увидел бы три отдельные аргумента
 
# Скобки нужны в сложных выражениях
result = (10, 20) + (30, 40)  # Конкатенация кортежей
print(result)  # Output: (10, 20, 30, 40)

# Частая ошибка: забыть запятую
not_a_tuple = ("Python")
print(type(not_a_tuple))  # Output: <class 'str'>
print(not_a_tuple)  # Output: Python
 
# Правильно: добавьте завершающую запятую
is_a_tuple = ("Python",)
print(type(is_a_tuple))  # Output: <class 'tuple'>
print(is_a_tuple)  # Output: ('Python',)
 
# Запятая работает даже без скобок
also_a_tuple = "Python",
print(type(also_a_tuple))  # Output: <class 'tuple'>
print(also_a_tuple)  # Output: ('Python',)

# Кортеж с информацией о студенте
student = ("Bob", 22, "Physics", 3.6)
 
# Доступ к отдельным элементам (индексация с нуля)
name = student[0]
age = student[1]
major = student[2]
gpa = student[3]
 
print(f"{name} is {age} years old")  # Output: Bob is 22 years old
print(f"Major: {major}, GPA: {gpa}")  # Output: Major: Physics, GPA: 3.6
 
# Отрицательная индексация тоже работает
last_item = student[-1]
print(f"Last item: {last_item}")  # Output: Last item: 3.6
 
# Срез извлекает новый кортеж
first_two = student[:2]
print(first_two)  # Output: ('Bob', 22)
print(type(first_two))  # Output: <class 'tuple'>

# Упаковка значений в кортеж
coordinates = 10, 20, 30
print(coordinates)  # Output: (10, 20, 30)
 
# Упаковка разных типов
user_data = "Alice", 25, "alice@example.com"
print(user_data)  # Output: ('Alice', 25, 'alice@example.com')
 
# Упаковка возвращаемых значений функции
def get_statistics(numbers):
    total = sum(numbers)
    count = len(numbers)
    average = total / count
    return total, count, average  # Упаковывает три значения в кортеж
 
stats = get_statistics([85, 90, 78, 92, 88])
print(stats)  # Output: (433, 5, 86.6)

# Базовая распаковка
point = (100, 200)
x, y = point
print(f"x = {x}, y = {y}")  # Output: x = 100, y = 200
 
# Распаковка работает с любой последовательностью, не только с кортежами
name, age, email = ["Bob", 30, "bob@example.com"]
print(f"{name} is {age} years old")  # Output: Bob is 30 years old
 
# Распаковка возвращаемых значений функции напрямую
total, count, average = get_statistics([95, 88, 92, 85])
print(f"Average of {count} scores: {average}")  # Output: Average of 4 scores: 90.0

# Это вызовет ошибку
coordinates = (10, 20, 30)
# x, y = coordinates  # ValueError: too many values to unpack (expected 2)
 
# Это тоже вызовет ошибку
point = (5, 10)
# x, y, z = point  # ValueError: not enough values to unpack (expected 3, got 2)

# Традиционный обмен с использованием временной переменной
a = 10
b = 20
temp = a
a = b
b = temp
print(f"a = {a}, b = {b}")  # Output: a = 20, b = 10
 
# Элегантный обмен в Python с помощью распаковки кортежа
x = 100
y = 200
x, y = y, x  # Swap in one line!
print(f"x = {x}, y = {y}")  # Output: x = 200, y = 100
 
# Обмен более чем двух переменных
first = "A"
second = "B"
third = "C"
first, second, third = third, first, second
print(first, second, third)  # Output: C A B

# Распаковка с переменной для "остатка"
scores = (95, 88, 92, 85, 90, 87)
first, second, *rest = scores
print(f"Top two: {first}, {second}")  # Output: Top two: 95, 88
print(f"Others: {rest}")  # Output: Others: [92, 85, 90, 87]
print(type(rest))  # Output: <class 'list'>
 
# Звёздочка может стоять где угодно
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(f"First: {first}")  # Output: First: 1
print(f"Middle: {middle}")  # Output: Middle: [2, 3, 4]
print(f"Last: {last}")  # Output: Last: 5
 
# Захват начала
*beginning, second_last, last = numbers
print(f"Beginning: {beginning}")  # Output: Beginning: [1, 2, 3]
print(f"Last two: {second_last}, {last}")  # Output: Last two: 4, 5

# Когда захватывать нечего
a, b, *rest = (10, 20)
print(rest)  # Output: []
 
# В одной распаковке допускается только одна звёздочка
# first, *middle, *end = (1, 2, 3, 4)  # SyntaxError: multiple starred expressions

# Разбор строки даты
date_string = "2024-03-15"
year, month, day = date_string.split("-")
print(f"Month: {month}")  # Output: Month: 03
 
# Если нас интересует только месяц
_, month, _ = date_string.split("-")
print(f"Month: {month}")  # Output: Month: 03
 
# С расширенной распаковкой
data = ("Alice", 25, "Engineer", "New York", "alice@example.com")
name, age, *_, email = data
print(f"{name} ({age}): {email}")  # Output: Alice (25): alice@example.com

# Возврат нескольких значений из вычислений
def calculate_rectangle_properties(width, height):
    """Вычислить площадь и периметр прямоугольника."""
    area = width * height
    perimeter = 2 * (width + height)
    return area, perimeter  # Упаковка
 
# Распаковка результатов
rect_area, rect_perimeter = calculate_rectangle_properties(5, 3)
print(f"Area: {rect_area}, Perimeter: {rect_perimeter}")  # Output: Area: 15, Perimeter: 16
 
# Итерация с распаковкой
students = [
    ("Alice", 85),
    ("Bob", 92),
    ("Carol", 78)
]
 
for name, score in students:  # Распаковка в цикле
    print(f"{name}: {score}")
# Output:
# Alice: 85
# Bob: 92
# Carol: 78

# Создание кортежа
coordinates = (10, 20, 30)
print(coordinates)  # Output: (10, 20, 30)
 
# Попытка изменить вызывает ошибку
# coordinates[0] = 15  # TypeError: 'tuple' object does not support item assignment
 
# Попытка добавить элементы вызывает ошибку
# coordinates.append(40)  # AttributeError: 'tuple' object has no attribute 'append'
 
# Попытка удалить элементы вызывает ошибку
# del coordinates[1]  # TypeError: 'tuple' object doesn't support item deletion

# Списки изменяемы — вы можете их менять
shopping_list = ["milk", "bread", "eggs"]
shopping_list[1] = "butter"  # Изменить элемент
shopping_list.append("cheese")  # Добавить элемент
print(shopping_list)  # Output: ['milk', 'butter', 'eggs', 'cheese']
 
# Кортежи неизменяемы — вы не можете их менять
product_dimensions = (10, 20, 5)  # width, height, depth in cm
# product_dimensions[0] = 12  # TypeError: cannot modify
# product_dimensions.append(3)  # AttributeError: no append method
 
# Чтобы "изменить" кортеж, нужно создать новый
new_dimensions = (12, 20, 5)  # Создать полностью новый кортеж
print(new_dimensions)  # Output: (12, 20, 5)

def calculate_distance(point1, point2):
    """Вычислить расстояние между двумя точками 2D."""
    x1, y1 = point1
    x2, y2 = point2
 
    dx = x2 - x1
    dy = y2 - y1
    
    # Даже если бы мы захотели, мы не можем изменить входные кортежи
 
    return (dx**2 + dy**2) ** 0.5
 
start = (0, 0)
end = (3, 4)
distance = calculate_distance(start, end)
print(f"Distance: {distance}")  # Output: Distance: 5.0
print(f"Start point unchanged: {start}")  # Output: Start point unchanged: (0, 0)

# Кортежи могут быть ключами словаря
locations = {
    (0, 0): "Origin",
    (10, 20): "Point A",
    (30, 40): "Point B"
}
print(locations[(10, 20)])  # Output: Point A
 
# Списки не могут быть ключами словаря
# locations_bad = {
#     [0, 0]: "Origin"  # TypeError: unhashable type: 'list'
# }

# Значения цветов RGB — они не должны меняться
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
 
# Параметры подключения к базе данных — фиксированная конфигурация
DB_CONFIG = ("localhost", 5432, "myapp", "production")
 
# Географические координаты — местоположение не меняется
EIFFEL_TOWER = (48.8584, 2.2945)  # latitude, longitude

import sys
 
# Кортежи используют меньше памяти, чем эквивалентные списки
tuple_data = (1, 2, 3, 4, 5)
list_data = [1, 2, 3, 4, 5]
 
print(f"Tuple size: {sys.getsizeof(tuple_data)} bytes")  # Output: Tuple size: 80 bytes (may vary by Python version)
print(f"List size: {sys.getsizeof(list_data)} bytes")    # Output: List size: 104 bytes (may vary by Python version)
 
# Создание кортежа быстрее
import timeit
 
tuple_time = timeit.timeit("(1, 2, 3, 4, 5)", number=1000000)
list_time = timeit.timeit("[1, 2, 3, 4, 5]", number=1000000)
 
print(f"Tuple creation: {tuple_time:.4f} seconds")
print(f"List creation: {list_time:.4f} seconds")
# Example output: Tuple creation: 0.0055 seconds, List creation: 0.0292 seconds

# Кортеж, содержащий список
student_data = ("Alice", 20, [85, 90, 78])  # name, age, scores
print(student_data)  # Output: ('Alice', 20, [85, 90, 78])
 
# Мы не можем переназначать элементы кортежа
# student_data[0] = "Bob"  # TypeError: 'tuple' object does not support item assignment
 
# Но мы МОЖЕМ изменить список внутри кортежа
student_data[2].append(92)  # Добавить новый балл
print(student_data)  # Output: ('Alice', 20, [85, 90, 78, 92])
 
student_data[2][0] = 88  # Изменить существующий балл
print(student_data)  # Output: ('Alice', 20, [88, 90, 78, 92])

# Структура кортежа фиксирована
data = ("Python", [1, 2, 3])
 
# Это пытается изменить то, на что ссылается кортеж — НЕЛЬЗЯ
# data[1] = [4, 5, 6]  # TypeError
 
# Это изменяет список, на который ссылается кортеж — МОЖНО
data[1].append(4)
print(data)  # Output: ('Python', [1, 2, 3, 4])
 
# Кортеж по-прежнему ссылается на тот же объект списка
# Изменилось только содержимое списка, а не то, на какой список указывает кортеж

# Кортеж, содержащий словарь
user_profile = ("alice", {"email": "alice@example.com", "age": 25})
print(user_profile)  # Output: ('alice', {'email': 'alice@example.com', 'age': 25})
 
# Нельзя изменить, на какой словарь ссылается кортеж
# user_profile[1] = {"email": "newemail@example.com"}  # TypeError
 
# Но МОЖНО изменить сам словарь
user_profile[1]["age"] = 26
user_profile[1]["city"] = "New York"
print(user_profile)  # Output: ('alice', {'email': 'alice@example.com', 'age': 26, 'city': 'New York'})

# Это работает, но опасно
tuple_with_list = ("key", [1, 2, 3])
# data = {tuple_with_list: "value"}  # TypeError: unhashable type: 'list'

# Полностью неизменяемый кортеж — только неизменяемые типы
point_3d = (10, 20, 30)  # Все целые числа
rgb_color = (255, 128, 0)  # Все целые числа
coordinates = ((10, 20), (30, 40))  # Кортеж кортежей
 
# Их безопасно использовать как ключи словаря
color_names = {
    (255, 0, 0): "Red",
    (0, 255, 0): "Green",
    (0, 0, 255): "Blue"
}
 
# Вложенные кортежи остаются неизменяемыми
nested = ((1, 2), (3, 4))
# nested[0][0] = 5  # TypeError: 'tuple' object does not support item assignment

# Запись студента с фиксированной идентичностью, но меняющимися оценками
def create_student(name, student_id):
    """Создать запись студента с пустым списком оценок."""
    return (name, student_id, [])  # name и ID фиксированы, grades могут меняться
 
student = create_student("Alice", "S12345")
print(student)  # Output: ('Alice', 'S12345', [])
 
# Идентичность студента фиксирована
print(f"Student: {student[0]} (ID: {student[1]})")  # Output: Student: Alice (ID: S12345)
 
# Но мы можем добавлять оценки по мере их получения
student[2].append(85)
student[2].append(92)
student[2].append(78)
print(f"Grades: {student[2]}")  # Output: Grades: [85, 92, 78]
 
# Структура кортежа защищает name и ID от случайных изменений,
# одновременно позволяя списку оценок расти

# Запись студента: имя, возраст, специальность, средний балл
student = ("Alice", 20, "Computer Science", 3.8)
 
# Географические координаты: широта, долгота
location = (40.7128, -74.0060)  # New York City
 
# Цвет RGB: красный, зелёный, синий
color = (255, 128, 0)
 
# Подключение к базе данных: host, port, database, username
db_connection = ("localhost", 5432, "myapp", "admin")
 
# Дата: год, месяц, день
date = (2024, 3, 15)

# Список покупок — элементы одного типа (строки)
shopping_list = ["milk", "bread", "eggs", "butter"]
shopping_list.append("cheese")  # Добавлять элементы по мере необходимости
shopping_list.remove("bread")   # Удалять элементы
 
# Результаты тестов — элементы одного типа (числа)
test_scores = [85, 92, 78, 95, 88]
test_scores.append(90)  # Добавить новый балл
test_scores.sort()      # Переупорядочить баллы
 
# Имена пользователей — элементы одного типа (строки)
active_users = ["alice", "bob", "carol"]
active_users.extend(["dave", "eve"])  # Добавить несколько пользователей

def get_user_info(user_id):
    """Получить информацию о пользователе из базы данных."""
    # Имитация поиска в базе данных
    return "Alice", "alice@example.com", 25, "New York"
 
# Распаковать возвращаемый кортеж
name, email, age, city = get_user_info(101)
print(f"{name} from {city}")  # Output: Alice from New York
 
def calculate_statistics(numbers):
    """Вычислить min, max и среднее для чисел."""
    if not numbers:
        return None, None, None
    
    minimum = min(numbers)
    maximum = max(numbers)
    average = sum(numbers) / len(numbers)
    return minimum, maximum, average
 
# Распаковать результаты
min_val, max_val, avg_val = calculate_statistics([85, 92, 78, 95, 88])
print(f"Range: {min_val} to {max_val}, Average: {avg_val}")
# Output: Range: 78 to 95, Average: 87.6

# Оценки студентов по курсу и семестру
grades = {
    ("CS101", "Fall2023"): 85,
    ("CS101", "Spring2024"): 90,
    ("MATH201", "Fall2023"): 88,
    ("MATH201", "Spring2024"): 92
}
 
# Найти конкретную оценку
course = "CS101"
semester = "Spring2024"
grade = grades[(course, semester)]
print(f"Grade in {course} ({semester}): {grade}")  # Output: Grade in CS101 (Spring2024): 90
 
# Координаты сетки в качестве ключей словаря
grid = {
    (0, 0): "Start",
    (5, 3): "Obstacle",
    (10, 10): "Goal"
}
 
position = (5, 3)
if position in grid:
    print(f"At {position}: {grid[position]}")  # Output: At (5, 3): Obstacle

# Настройки приложения, которые должны оставаться постоянными
APP_CONFIG = (
    "MyApp",           # Application name
    "1.0.0",          # Version
    "production",     # Environment
    True,             # Debug mode
    8080              # Port
)
 
# Палитра цветов для UI — эти цвета фиксированы
COLOR_PALETTE = (
    (255, 0, 0),      # Primary red
    (0, 128, 255),    # Primary blue
    (255, 255, 255),  # White
    (0, 0, 0)         # Black
)
 
# Эндпоинты API — эти URL не меняются
API_ENDPOINTS = (
    "https://api.example.com/users",
    "https://api.example.com/products",
    "https://api.example.com/orders"
)

# Используйте КОРТЕЖИ, когда:
# 1. Данные представляют одну запись с фиксированной структурой
employee = ("E001", "Alice", "Engineering", 75000)
 
# 2. Возвращаете несколько значений из функции
def divide_with_remainder(a, b):
    return a // b, a % b
 
# 3. Нужно использовать в качестве ключей словаря
cache = {(5, 10): 50, (3, 7): 21}
 
# 4. Данные не должны изменяться
SCREEN_RESOLUTION = (1920, 1080)
 
# Используйте СПИСКИ, когда:
# 1. Коллекция похожих элементов, которая может меняться
tasks = ["Write code", "Test code", "Deploy code"]
tasks.append("Document code")
 
# 2. Нужно добавлять, удалять или переупорядочивать элементы
scores = [85, 90, 78]
scores.sort()
scores.append(92)
 
# 3. Все элементы служат одной цели
usernames = ["alice", "bob", "carol"]
 
# 4. Размер коллекции заранее неизвестен
results = []
for i in range(10):
    results.append(i * 2)

# Один аргумент: range(stop)
# Генерирует числа от 0 до stop (не включая stop)
numbers = range(5)
print(list(numbers))  # Output: [0, 1, 2, 3, 4]
 
# Два аргумента: range(start, stop)
# Генерирует числа от start до stop (не включая stop)
numbers = range(2, 7)
print(list(numbers))  # Output: [2, 3, 4, 5, 6]
 
# Три аргумента: range(start, stop, step)
# Генерирует числа от start до stop, увеличивая на step
numbers = range(0, 10, 2)
print(list(numbers))  # Output: [0, 2, 4, 6, 8]
 
# Отрицательный шаг для обратного счёта
numbers = range(10, 0, -1)
print(list(numbers))  # Output: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

r = range(5)
print(r)  # Output: range(0, 5)
print(type(r))  # Output: <class 'range'>

import sys
 
# Диапазон, представляющий миллион чисел
large_range = range(1000000)
print(f"Range size: {sys.getsizeof(large_range)} bytes")  # Output: Range size: 48 bytes (may vary by Python version)
 
# Список, содержащий миллион чисел
large_list = list(range(1000000))
print(f"List size: {sys.getsizeof(large_list)} bytes")  # Output: List size: 8000056 bytes (approximately 8MB)
 
# Диапазон крошечный; список огромный!

# Счёт от 0 до 4
for i in range(5):
    print(f"Count: {i}")
# Output:
# Count: 0
# Count: 1
# Count: 2
# Count: 3
# Count: 4
 
# Счёт от 1 до 10
for i in range(1, 11):
    print(i, end=" ")
print()  # Output: 1 2 3 4 5 6 7 8 9 10
 
# Счёт по два
for i in range(0, 20, 2):
    print(i, end=" ")
print()  # Output: 0 2 4 6 8 10 12 14 16 18
 
# Обратный отсчёт
for i in range(5, 0, -1):
    print(f"T-minus {i}")
# Output:
# T-minus 5
# T-minus 4
# T-minus 3
# T-minus 2
# T-minus 1

# Создание range
numbers = range(10, 50, 5)  # 10, 15, 20, 25, 30, 35, 40, 45
 
# Индексация
print(numbers[0])   # Output: 10
print(numbers[3])   # Output: 25
print(numbers[-1])  # Output: 45
 
# Срез возвращает новый range
subset = numbers[2:5]
print(subset)  # Output: range(20, 35, 5)
print(list(subset))  # Output: [20, 25, 30]
 
# Длина
print(len(numbers))  # Output: 8

# Чётные числа от 0 до 20
evens = range(0, 21, 2)
 
print(10 in evens)  # Output: True
print(15 in evens)  # Output: False
print(20 in evens)  # Output: True
 
# Это очень эффективно — Python не генерирует все числа
# Он вычисляет, могло ли число быть в последовательности
large_range = range(0, 1000000, 3)
print(999999 in large_range)  # Output: True (instant, no iteration needed)

# Пустой диапазон — stop равен start
empty = range(5, 5)
print(list(empty))  # Output: []
print(len(empty))   # Output: 0
 
# Пустой диапазон — невозможно дойти до stop с заданным шагом
impossible = range(1, 10, -1)  # Нельзя считать вверх с отрицательным шагом
print(list(impossible))  # Output: []
 
# Обратный диапазон
backwards = range(10, 0, -1)
print(list(backwards))  # Output: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
 
# Обратный диапазон с отрицательными числами
negative_range = range(-5, -15, -2)
print(list(negative_range))  # Output: [-5, -7, -9, -11, -13]

# Используйте range, когда:
# 1. Нужна последовательность чисел для итерации
for i in range(100):
    # Обработать что-то 100 раз
    pass
 
# 2. Нужны индексы для последовательности
items = ["a", "b", "c", "d"]
for i in range(len(items)):
    print(f"Index {i}: {items[i]}")
 
# 3. Важна экономия памяти на больших последовательностях
# Это использует минимальную память
for i in range(1000000):
    if i % 100000 == 0:
        print(i)
 
# Используйте списки, когда:
# 1. Нужно хранить реальные значения
squares = [1, 3, 5, 7, 10]
 
# 2. Нужно изменять последовательность
numbers = list(range(5))
numbers[2] = 100  # Изменить значение
numbers.append(200)  # Добавить значение
 
# 3. Нужно использовать последовательность многократно с разными операциями
data = list(range(10))
print(sum(data))
print(max(data))
print(sorted(data, reverse=True))

# Кортеж в список
student_tuple = ("Alice", 20, "CS")
student_list = list(student_tuple)
print(student_list)  # Output: ['Alice', 20, 'CS']
print(type(student_list))  # Output: <class 'list'>
 
# Теперь мы можем его изменить
student_list[1] = 21
student_list.append(3.8)
print(student_list)  # Output: ['Alice', 21, 'CS', 3.8]
 
# Range в список
numbers = range(5)
numbers_list = list(numbers)
print(numbers_list)  # Output: [0, 1, 2, 3, 4]
 
# Строка в список (каждый символ становится элементом)
text = "Python"
chars = list(text)
print(chars)  # Output: ['P', 'y', 't', 'h', 'o', 'n']

# Список в кортеж
scores_list = [85, 90, 78, 92]
scores_tuple = tuple(scores_list)
print(scores_tuple)  # Output: (85, 90, 78, 92)
print(type(scores_tuple))  # Output: <class 'tuple'>
 
# Теперь он неизменяемый
# scores_tuple[0] = 88  # TypeError: 'tuple' object does not support item assignment
 
# Range в кортеж
numbers = range(1, 6)
numbers_tuple = tuple(numbers)
print(numbers_tuple)  # Output: (1, 2, 3, 4, 5)
 
# Строка в кортеж
text = "Hi"
chars_tuple = tuple(text)
print(chars_tuple)  # Output: ('H', 'i')

# Строки
text = "Python"
print(len(text))  # Output: 6
print(min(text))  # Output: P (smallest character by Unicode value)
print(max(text))  # Output: y (largest character by Unicode value)
 
# Списки
numbers = [45, 12, 78, 23, 56]
print(len(numbers))  # Output: 5
print(min(numbers))  # Output: 12
print(max(numbers))  # Output: 78
 
# Кортежи
scores = (85, 92, 78, 95, 88)
print(len(scores))  # Output: 5
print(min(scores))  # Output: 78
print(max(scores))  # Output: 95
 
# Диапазоны
nums = range(10, 50, 5)
print(len(nums))  # Output: 8
print(min(nums))  # Output: 10
print(max(nums))  # Output: 45

mixed = [1, "hello", 3]
# print(min(mixed))  # TypeError: '<' not supported between instances of 'str' and 'int'

# Положительная индексация (с 0)
text = "Python"
numbers = [10, 20, 30, 40, 50]
coords = (5, 10, 15)
values = range(0, 100, 10)
 
print(text[0])      # Output: P
print(numbers[2])   # Output: 30
print(coords[1])    # Output: 10
print(values[3])    # Output: 30
 
# Отрицательная индексация (с конца)
print(text[-1])     # Output: n (last character)
print(numbers[-2])  # Output: 40 (second from end)
print(coords[-3])   # Output: 5 (third from end, which is first)
print(values[-1])   # Output: 90 (last value in range)

# Строки — проверка подстрок
text = "Python Programming"
print("Python" in text)      # Output: True
print("Java" in text)        # Output: False
print("gram" in text)        # Output: True (substring)
print("PYTHON" not in text)  # Output: True (case-sensitive)
 
# Списки
fruits = ["apple", "banana", "cherry", "date"]
print("banana" in fruits)    # Output: True
print("grape" in fruits)     # Output: False
print("apple" not in fruits) # Output: False
 
# Кортежи
coordinates = (10, 20, 30, 40)
print(20 in coordinates)     # Output: True
print(25 in coordinates)     # Output: False
print(50 not in coordinates) # Output: True
 
# Диапазоны — очень эффективно, без итерации
numbers = range(0, 100, 2)  # Even numbers 0 to 98
print(50 in numbers)         # Output: True
print(51 in numbers)         # Output: False (odd number)
print(100 in numbers)        # Output: False (stop is exclusive)

# Конкатенация с +
text1 = "Hello"
text2 = " World"
print(text1 + text2)  # Output: Hello World
 
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 + list2)  # Output: [1, 2, 3, 4, 5, 6]
 
tuple1 = (10, 20)
tuple2 = (30, 40)
print(tuple1 + tuple2)  # Output: (10, 20, 30, 40)
 
# Повторение с *
print("Ha" * 3)           # Output: HaHaHa
print([0] * 5)            # Output: [0, 0, 0, 0, 0]
print((1, 2) * 3)         # Output: (1, 2, 1, 2, 1, 2)

r1 = range(5)
r2 = range(5, 10)
# combined = r1 + r2  # TypeError: unsupported operand type(s) for +: 'range' and 'range'
 
# Чтобы объединить диапазоны, сначала преобразуйте их в списки или кортежи
combined = list(r1) + list(r2)
print(combined)  # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Строки — считает вхождения подстроки
text = "Mississippi"
print(text.count("s"))   # Output: 4
print(text.count("ss"))  # Output: 2
print(text.count("i"))   # Output: 4
 
# Списки
numbers = [1, 2, 3, 2, 4, 2, 5]
print(numbers.count(2))  # Output: 3
print(numbers.count(6))  # Output: 0
 
# Кортежи
grades = (85, 90, 85, 92, 85, 88)
print(grades.count(85))  # Output: 3
print(grades.count(95))  # Output: 0
 
# У диапазонов нет метода count(), но можно сначала преобразовать
nums = range(0, 20, 2)
nums_list = list(nums)
print(nums_list.count(10))  # Output: 1

# Строки
text = "Python Programming"
print(text.index("P"))      # Output: 0 (first P)
print(text.index("Pro"))    # Output: 7 (substring position)
# print(text.index("Java"))  # ValueError: substring not found
 
# Списки
fruits = ["apple", "banana", "cherry", "banana"]
print(fruits.index("banana"))  # Output: 1 (first occurrence)
print(fruits.index("cherry"))  # Output: 2
# print(fruits.index("grape"))  # ValueError: 'grape' is not in list
 
# Кортежи
coordinates = (10, 20, 30, 20, 40)
print(coordinates.index(20))  # Output: 1 (first occurrence)
print(coordinates.index(40))  # Output: 4
 
# У диапазонов нет метода index(), но можно сначала преобразовать
nums = range(10, 50, 5)
nums_list = list(nums)
print(nums_list.index(25))  # Output: 3

fruits = ["apple", "banana", "cherry"]
search_fruit = "grape"
 
if search_fruit in fruits:
    position = fruits.index(search_fruit)
    print(f"{search_fruit} found at position {position}")
else:
    print(f"{search_fruit} not found")
# Output: grape not found

# Строки — итерация по символам
for char in "Python":
    print(char, end=" ")
print()  # Output: P y t h o n
 
# Списки
for fruit in ["apple", "banana", "cherry"]:
    print(f"I like {fruit}")
# Output:
# I like apple
# I like banana
# I like cherry
 
# Кортежи
for score in (85, 90, 78):
    print(f"Score: {score}")
# Output:
# Score: 85
# Score: 90
# Score: 78
 
# Диапазоны
for i in range(1, 6):
    print(f"Count: {i}")
# Output:
# Count: 1
# Count: 2
# Count: 3
# Count: 4
# Count: 5

# Равенство
print([1, 2, 3] == [1, 2, 3])      # Output: True
print((1, 2, 3) == (1, 2, 3))      # Output: True
print("abc" == "abc")               # Output: True
 
# Неравенство
print([1, 2, 3] != [1, 2, 4])      # Output: True
print((1, 2) != (1, 2))            # Output: False
 
# Лексикографическое сравнение (поэлементно)
print([1, 2, 3] < [1, 2, 4])       # Output: True (3 < 4)
print([1, 2, 3] < [1, 3, 0])       # Output: True (2 < 3)
print("apple" < "banana")           # Output: True (alphabetical)
print((1, 2) < (1, 2, 3))          # Output: True (shorter is less if equal so far)
 
# Сравнение разных типов
print([1, 2, 3] == (1, 2, 3))      # Output: False (different types)

# Базовые срезы со строками
text = "Python Programming"
print(text[0:6])    # Output: Python
print(text[7:18])   # Output: Programming
print(text[7:])     # Output: Programming (from index 7 to end)
print(text[:6])     # Output: Python (from start to index 6)
 
# Базовые срезы со списками
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:7])   # Output: [2, 3, 4, 5, 6]
print(numbers[:5])    # Output: [0, 1, 2, 3, 4]
print(numbers[5:])    # Output: [5, 6, 7, 8, 9]
 
# Базовые срезы с кортежами
coordinates = (10, 20, 30, 40, 50, 60)
print(coordinates[1:4])  # Output: (20, 30, 40)
print(coordinates[:3])   # Output: (10, 20, 30)
print(coordinates[3:])   # Output: (40, 50, 60)
 
# Базовые срезы с диапазонами
nums = range(0, 100, 10)
print(list(nums[2:5]))   # Output: [20, 30, 40]

# Каждый второй элемент
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[::2])     # Output: [0, 2, 4, 6, 8]
print(numbers[1::2])    # Output: [1, 3, 5, 7, 9]
 
# Каждый третий элемент
text = "abcdefghijklmnop"
print(text[::3])        # Output: adgjmp
 
# Шаг со start и stop
print(numbers[2:8:2])   # Output: [2, 4, 6]
print(text[1:10:2])     # Output: bdfhj

# Разворот целых последовательностей
text = "Python"
print(text[::-1])       # Output: nohtyP
 
numbers = [1, 2, 3, 4, 5]
print(numbers[::-1])    # Output: [5, 4, 3, 2, 1]
 
coordinates = (10, 20, 30, 40)
print(coordinates[::-1])  # Output: (40, 30, 20, 10)
 
# Разворот с шагом
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[::-2])    # Output: [9, 7, 5, 3, 1] (every second, backwards)
 
# Разворот части
text = "Python Programming"
print(text[7:18][::-1])  # Output: gnimmargorP (reverse "Programming")

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
# При отрицательном шаге start должен быть больше stop
print(numbers[7:2:-1])   # Output: [7, 6, 5, 4, 3] (from 7 down to 3)
print(numbers[8:3:-2])   # Output: [8, 6, 4] (from 8 down to 4, step -2)
 
# Пропуск start/stop при отрицательном шаге
print(numbers[:5:-1])    # Output: [9, 8, 7, 6] (from end down to 6)
print(numbers[5::-1])    # Output: [5, 4, 3, 2, 1, 0] (from 5 down to start)

text = "Python Programming"
# Последние 11 символов
print(text[-11:])        # Output: Programming
 
# Всё кроме последних 11 символов
print(text[:-11])        # Output: Python
 
# От -15 до -5
print(text[-15:-5])      # Output: hon Progra
 
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Последние 5 элементов
print(numbers[-5:])      # Output: [5, 6, 7, 8, 9]
 
# Всё кроме последних 3 элементов
print(numbers[:-3])      # Output: [0, 1, 2, 3, 4, 5, 6]
 
# От -7 до -2
print(numbers[-7:-2])    # Output: [3, 4, 5, 6, 7]

# Срезы диапазонов
numbers = range(0, 100, 5)  # 0, 5, 10, 15, ..., 95
print(numbers)  # Output: range(0, 100, 5)
 
# Срез возвращает новый range
subset = numbers[5:10]
print(subset)  # Output: range(25, 50, 5)
print(list(subset))  # Output: [25, 30, 35, 40, 45]
 
# Со step
every_other = numbers[::2]
print(list(every_other))  # Output: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
 
# Отрицательный шаг
reversed_range = numbers[::-1]
print(list(reversed_range))  # Output: [95, 90, 85, ..., 5, 0]

numbers = [1, 2, 3, 4, 5]
 
# Пустые срезы (start >= stop при положительном step)
print(numbers[3:3])    # Output: []
print(numbers[5:10])   # Output: [] (stop beyond length)
print(numbers[10:20])  # Output: [] (both beyond length)
 
# Срезы за границами последовательности безопасны
print(numbers[-100:100])  # Output: [1, 2, 3, 4, 5] (entire sequence)
print(numbers[2:100])     # Output: [3, 4, 5] (from 2 to end)
 
# Отрицательный шаг с несовместимыми start/stop
print(numbers[2:7:-1])    # Output: [] (can't go forward with negative step)
 
# Шаг 0 недопустим
# print(numbers[::0])  # ValueError: slice step cannot be zero

# Копирование с помощью среза
original = [1, 2, 3, 4, 5]
copy = original[:]  # Срез от начала до конца
print(copy)  # Output: [1, 2, 3, 4, 5]
 
# Изменение копии не влияет на оригинал
copy[0] = 100
print(f"Original: {original}")  # Output: Original: [1, 2, 3, 4, 5]
print(f"Copy: {copy}")          # Output: Copy: [100, 2, 3, 4, 5]
 
# Это работает и для кортежей (создаёт новый кортеж)
original_tuple = (1, 2, 3, 4, 5)
copy_tuple = original_tuple[:]
print(copy_tuple)  # Output: (1, 2, 3, 4, 5)
 
# Для строк
text = "Python"
text_copy = text[:]
print(text_copy)  # Output: Python

# Ограничение поверхностной копии
original = [[1, 2], [3, 4]]
copy = original[:]
 
# Изменение вложенного списка влияет на оба
copy[0][0] = 100
print(f"Original: {original}")  # Output: Original: [[100, 2], [3, 4]]
print(f"Copy: {copy}")          # Output: Copy: [[100, 2], [3, 4]]