Python для новичков: 15 примеров кода от простого к сложному

Для кого эта статья:

• Новички в программировании без опыта
• Студенты и взрослые, стремящиеся сменить профессию на IT

• Люди, желающие освоить Python для практического применения в различных областях

  Python — язык, который сокращает путь от новичка до программиста в разы быстрее других технологий. Его код читается как английский текст, что делает его идеальным первым языком для тех, кто никогда не писал ни строчки кода. Я собрал 15 базовых примеров Python-кода, которые позволят вам с нуля понять логику программирования и создать свои первые работающие скрипты — от простой математики до автоматизации рутинных задач. 🐍 Готовы превратить компьютер в инструмент, выполняющий ваши команды?

Хотите за 9 месяцев пройти путь от нуля до востребованного Python-разработчика? Обучение Python-разработке от Skypro даёт реальную практику с первых недель: вы создадите собственное портфолио из 15 проектов под руководством действующих разработчиков. Программа построена на основе запросов от 100+ IT-компаний, поэтому 85% выпускников находят работу в течение 3 месяцев после окончания. Нет тестирований при поступлении — только ваше желание учиться!

Почему Python идеален для новичков в программировании

Python создан с прицелом на доступность и простоту использования — это фундамент его философии. Когда другие языки требуют сложного синтаксиса с множеством скобок и точек с запятой, Python позволяет писать код почти как обычный английский текст.

Сравним простую задачу вывода текста на экран на Python и C++:

Разница очевидна — Python требует всего одну строку кода, тогда как C++ нуждается в нескольких строках с дополнительными конструкциями. Эта простота позволяет сосредоточиться на алгоритмическом мышлении, а не на синтаксических особенностях.

Python также отличается обширной экосистемой библиотек для любых задач, от анализа данных и машинного обучения до веб-разработки и автоматизации. Это делает его универсальным инструментом, который можно применять в различных областях:

• Анализ данных и наука о данных (pandas, NumPy)
• Машинное обучение и искусственный интеллект (TensorFlow, PyTorch)
• Веб-разработка (Django, Flask)
• Автоматизация (Selenium, PyAutoGUI)
• Разработка игр (Pygame)

Ещё одно преимущество Python — высокий спрос на рынке труда. По данным HackerRank 2023, Python занимает второе место среди языков, которые работодатели ищут в кандидатах, уступая только JavaScript. Средняя зарплата Python-разработчика в России колеблется от 120 000 до 350 000 рублей, что делает его привлекательным выбором для начала карьеры. 💼

Максим Петров, преподаватель программирования

Когда я начал преподавать программирование в 2018 году, мои студенты постоянно спотыкались о синтаксические конструкции Java и C++. Часто они не могли сосредоточиться на алгоритмической части из-за ошибок в скобках или точках с запятой. Переход на Python в качестве первого языка для обучения изменил ситуацию кардинально — количество успешно завершивших курс выросло на 40%.

Особенно запомнился случай с Анной, 45-летним бухгалтером, решившей сменить профессию. Она пыталась изучать программирование самостоятельно по C++, но отчаялась через месяц. После перехода на Python она создала свой первый работающий скрипт для анализа финансовых данных уже через неделю занятий. Сейчас Анна работает аналитиком данных и использует Python ежедневно.

Базовые Python-коды для работы с переменными и типами данных

Переменные — это основа любой программы. В Python их создание максимально интуитивно — вам не нужно заранее объявлять тип данных, что упрощает процесс обучения. Ниже представлены 5 базовых python кодов для начинающих, демонстрирующих работу с различными типами данных.

Пример 1: Создание переменных и базовые операции

# Создание числовых переменных
x = 10
y = 5

# Базовые математические операции
сумма = x + y # 15
разность = x – y # 5
произведение = x * y # 50
деление = x / y # 2.0
остаток = x % y # 0
степень = x ** y # 100000

print(f"Сумма: {сумма}, Произведение: {произведение}, Степень: {степень}")

Обратите внимание, что Python позволяет использовать кириллические имена переменных, хотя в профессиональной разработке это не рекомендуется. f-строки (f"текст {переменная}") — удобный способ форматирования текста, появившийся в Python 3.6.

Пример 2: Работа со строками

# Создание строковых переменных
имя = "Алексей"
фамилия = "Иванов"

# Конкатенация (сложение) строк
полное_имя = имя + " " + фамилия # "Алексей Иванов"

# Повторение строки
приветствие = "Привет! " * 3 # "Привет! Привет! Привет! "

# Методы строк
нижний_регистр = полное_имя.lower() # "алексей иванов"
верхний_регистр = полное_имя.upper() # "АЛЕКСЕЙ ИВАНОВ"
замена = полное_имя.replace("Иванов", "Петров") # "Алексей Петров"

print(f"Полное имя: {полное_имя}")
print(f"Приветствие: {приветствие}")

Строки в Python обладают множеством методов, которые позволяют легко манипулировать текстом без написания сложных алгоритмов. Это важное преимущество для начинающих. 📝

Пример 3: Списки и их методы

# Создание списка
фрукты = ["яблоко", "банан", "апельсин", "груша"]

# Доступ к элементам
первый_фрукт = фрукты[0] # "яблоко"
последний_фрукт = фрукты[-1] # "груша"

# Изменение элемента
фрукты[1] = "киви" # Список станет: ["яблоко", "киви", "апельсин", "груша"]

# Методы списков
фрукты.append("манго") # Добавление в конец
фрукты.insert(1, "ананас") # Вставка на позицию 1
фрукты.remove("апельсин") # Удаление по значению
длина = len(фрукты) # Получение длины списка

print(f"Обновленный список: {фрукты}")
print(f"Количество фруктов: {длина}")

Списки — одна из самых гибких и часто используемых структур данных в Python. Они позволяют хранить коллекции объектов и манипулировать ими с помощью встроенных методов.

Пример 4: Словари для хранения пар ключ-значение

# Создание словаря
студент = {
"имя": "Мария",
"возраст": 20,
"курсы": ["Python", "Data Science", "Web Development"],
"средний_балл": 4.8
}

# Доступ к значениям
имя_студента = студент["имя"] # "Мария"
первый_курс = студент["курсы"][0] # "Python"

# Добавление новой пары ключ-значение
студент["группа"] = "А-101"

# Методы словарей
все_ключи = студент.keys() # Получение всех ключей
все_значения = студент.values() # Получение всех значений

print(f"Студент: {имя_студента}, изучает: {студент['курсы']}")

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

Пример 5: Преобразование типов данных

# Преобразование строки в число
строка_число = "42"
число = int(строка_число) # 42 (целое число)
число_с_плавающей_точкой = float(строка_число) # 42.0

# Преобразование числа в строку
обратно_в_строку = str(число) # "42"

# Преобразование между типами коллекций
список_чисел = [1, 2, 3, 4, 5]
кортеж_чисел = tuple(список_чисел) # (1, 2, 3, 4, 5) – неизменяемый список
список_из_кортежа = list(кортеж_чисел) # [1, 2, 3, 4, 5]

# Создание множества (уникальные элементы)
числа_с_дубликатами = [1, 2, 2, 3, 4, 4, 5]
уникальные_числа = set(числа_с_дубликатами) # {1, 2, 3, 4, 5}

print(f"Преобразованное число: {число + 8}") # 50
print(f"Уникальные числа: {уникальные_числа}")

Преобразование типов — важный навык при работе с данными из разных источников. Python предлагает простые функции для конвертации между типами, что делает обработку данных интуитивно понятной. 🔄

Python-алгоритмы с условиями и циклами для начинающих

Условные конструкции и циклы — это основа алгоритмического мышления в программировании. Python предлагает интуитивно понятный синтаксис для реализации различных логических ветвлений и повторений. Разберём 5 примеров python кодов для начинающих, которые демонстрируют эти ключевые концепции.

Пример 6: Условный оператор if-elif-else

# Запрос возраста пользователя
возраст = 17

# Проверка возрастной категории
if возраст < 18:
категория = "Несовершеннолетний"
доступ = "Ограниченный доступ"
elif 18 <= возраст < 65:
категория = "Взрослый"
доступ = "Полный доступ"
else:
категория = "Пенсионер"
доступ = "Специальный доступ"

print(f"Категория: {категория}")
print(f"Уровень доступа: {доступ}")

Обратите внимание на уникальную особенность Python: вы можете использовать составные условия, как 18 <= возраст < 65, что делает код более читаемым по сравнению с другими языками, где пришлось бы писать (возраст >= 18 && возраст < 65).

Пример 7: Цикл for для перебора элементов

# Список городов
города = ["Москва", "Санкт-Петербург", "Новосибирск", "Екатеринбург", "Казань"]

# Перебор элементов с использованием цикла for
print("Список крупных городов России:")
for город in города:
print(f"- {город}")

# Использование функции enumerate для получения индекса
print("\nГорода с рейтингом:")
for индекс, город in enumerate(города, 1): # 1 – начальное значение индекса
print(f"{индекс}. {город}")

# Использование range() для создания последовательности чисел
print("\nТаблица умножения на 5:")
for число in range(1, 11): # от 1 до 10 включительно
результат = число * 5
print(f"5 × {число} = {результат}")

Цикл for в Python удобен тем, что позволяет напрямую перебирать элементы коллекции, не требуя работы с индексами, хотя при необходимости можно использовать enumerate() для доступа и к индексу, и к значению.

Пример 8: Цикл while для повторения с условием

# Инициализация переменных
число = 1
сумма = 0

# Цикл выполняется, пока число меньше или равно 10
while число <= 10:
сумма += число # Добавляем текущее число к сумме
число += 1 # Увеличиваем число на 1

print(f"Сумма чисел от 1 до 10: {сумма}") # 55

# Пример с break для преждевременного выхода из цикла
попытки = 0
пин_код = "1234"
успех = False

while попытки < 3:
ввод = "1235" # В реальном коде здесь был бы input()
попытки += 1

if ввод == пин_код:
успех = True
print("Доступ разрешен!")
break # Выход из цикла
else:
print(f"Неверный PIN. Осталось попыток: {3 – попытки}")

if not успех:
print("Доступ заблокирован. Слишком много неудачных попыток.")

Цикл while полезен, когда количество итераций заранее неизвестно и зависит от некоторого условия. Ключевые слова break и continue (не показано в примере) позволяют управлять выполнением цикла. 🔁

Антон Сидоров, разработчик Python

Я помню свой первый серьезный проект на Python — парсер данных для небольшого интернет-магазина. Заказчик хотел автоматизировать мониторинг цен конкурентов, и я взялся за задачу, имея лишь базовые знания языка.

Начал с простого скрипта с циклом for, который перебирал ссылки и извлекал информацию. Всё работало, но когда список товаров вырос до 5000 наименований, процесс занимал часы. Тогда я переписал код с использованием асинхронного подхода и многопоточности.

Ключевым моментом стало понимание, что даже сложные задачи можно решать, начиная с простых циклов и условий, а затем оптимизировать. Заказчик был в восторге — скрипт стал работать в 20 раз быстрее, а я получил ценный опыт и свой первый крупный контракт как фрилансер.

Пример 9: Вложенные циклы

# Генерация таблицы умножения с помощью вложенных циклов
print("Таблица умножения от 1 до 5:")

for i in range(1, 6):
строка = ""
for j in range(1, 6):
произведение = i * j
строка += f"{произведение:2d} " # :2d обеспечивает выравнивание
print(строка)

# Поиск всех пар чисел, дающих в сумме 10
пары = []
числа = [3, 7, 2, 8, 5, 1, 9, 4, 6]

for i in range(len(числа)):
for j in range(i + 1, len(числа)): # начинаем с i+1, чтобы не повторять пары
if числа[i] + числа[j] == 10:
пары.append((числа[i], числа[j]))

print(f"Пары чисел, дающие сумму 10: {пары}")

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

Пример 10: Понимание списков (List comprehensions)

# Традиционный способ создания списка квадратов
квадраты = []
for число in range(1, 11):
квадраты.append(число ** 2)
print(f"Квадраты чисел (традиционный способ): {квадраты}")

# Тот же результат с использованием понимания списков
квадраты_кратко = [число ** 2 for число in range(1, 11)]
print(f"Квадраты чисел (понимание списков): {квадраты_кратко}")

# Понимание списков с условием
четные_квадраты = [число ** 2 for число in range(1, 11) if число % 2 == 0]
print(f"Квадраты четных чисел: {четные_квадраты}")

# Создание словаря с помощью понимания словарей
словарь_квадратов = {число: число ** 2 for число in range(1, 6)}
print(f"Словарь квадратов: {словарь_квадратов}")

Понимание списков (list comprehensions) — это мощная и элегантная конструкция Python, которая позволяет создавать списки одной строкой кода. Она часто делает код более читаемым и компактным, заменяя традиционные циклы с накоплением результатов. 🧠

Создаём первые функции и классы в Python с нуля

Функции и классы — это строительные блоки для организации кода. Они помогают избежать повторений, делают код модульным и более поддерживаемым. Рассмотрим 5 примеров python кодов для начинающих, которые помогут освоить эти концепции.

Пример 11: Создание и использование функций

# Простая функция без параметров
def приветствие():
"""Выводит стандартное приветствие"""
print("Привет, мир!")

# Функция с параметрами
def персональное_приветствие(имя):
"""Выводит персонализированное приветствие"""
print(f"Привет, {имя}!")

# Функция с параметрами по умолчанию
def приветствие_с_временем(имя, время_суток="день"):
"""Выводит приветствие с учетом времени суток"""
print(f"Добрый {время_суток}, {имя}!")

# Функция, возвращающая значение
def сумма_чисел(a, b):
"""Возвращает сумму двух чисел"""
return a + b

# Вызов функций
приветствие()
персональное_приветствие("Анна")
приветствие_с_временем("Иван")
приветствие_с_временем("Мария", "вечер")

результат = сумма_чисел(5, 3)
print(f"Сумма чисел: {результат}")

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

Пример 12: Область видимости переменных

# Глобальная переменная
счетчик = 0

def увеличить_счетчик():
"""Увеличивает глобальный счетчик"""
global счетчик # Указываем, что используем глобальную переменную
счетчик += 1
print(f"Счетчик внутри функции: {счетчик}")

def локальный_счетчик():
"""Демонстрирует локальную переменную"""
счетчик = 10 # Это локальная переменная, не связанная с глобальной
счетчик += 1
print(f"Локальный счетчик: {счетчик}")

# Вызов функций
print(f"Глобальный счетчик до: {счетчик}")
увеличить_счетчик()
локальный_счетчик()
print(f"Глобальный счетчик после: {счетчик}")

Понимание области видимости (scope) переменных критически важно для избежания трудно отслеживаемых ошибок. По умолчанию переменные, объявленные внутри функции, имеют локальную область видимости и не влияют на одноименные переменные вне функции. Для изменения глобальных переменных необходимо использовать ключевое слово global. 🔍

Пример 13: Создание базового класса

# Определение класса Автомобиль
class Автомобиль:
"""Базовый класс для представления автомобиля"""

def __init__(self, марка, модель, год, пробег=0):
"""Инициализация атрибутов автомобиля"""
self.марка = марка
self.модель = модель
self.год = год
self.пробег = пробег
self.работает = False

def завести_двигатель(self):
"""Запуск двигателя"""
if not self.работает:
print(f"{self.марка} {self.модель} заведен!")
self.работает = True
else:
print(f"{self.марка} {self.модель} уже работает.")

def заглушить_двигатель(self):
"""Остановка двигателя"""
if self.работает:
print(f"{self.марка} {self.модель} заглушен.")
self.работает = False
else:
print(f"{self.марка} {self.модель} уже заглушен.")

def проехать(self, расстояние):
"""Поездка на определенное расстояние"""
if self.работает:
self.пробег += расстояние
print(f"{self.марка} {self.модель} проехал {расстояние} км. Общий пробег: {self.пробег} км.")
else:
print(f"Сначала заведите {self.марка} {self.модель}!")

def информация(self):
"""Вывод информации об автомобиле"""
состояние = "работает" if self.работает else "заглушен"
print(f"Автомобиль: {self.марка} {self.модель}, {self.год} года.")
print(f"Пробег: {self.пробег} км. Состояние: {состояние}")

# Создание экземпляра класса
моя_машина = Автомобиль("Toyota", "Corolla", 2020)
моя_машина.информация()
моя_машина.завести_двигатель()
моя_машина.проехать(150)
моя_машина.заглушить_двигатель()
моя_машина.информация()

Классы позволяют создавать собственные типы данных, объединяя связанные атрибуты и методы. Метод __init__ — это специальный метод, который вызывается при создании объекта класса (конструктор). Параметр self ссылается на экземпляр класса и обязателен для всех методов класса.

Пример 14: Наследование и полиморфизм

# Базовый класс Животное
class Животное:
"""Базовый класс для всех животных"""

def __init__(self, имя, возраст):
self.имя = имя
self.возраст = возраст

def голос(self):
"""Издать звук (будет переопределен в подклассах)"""
print("Какой-то звук животного")

def информация(self):
"""Вывод информации о животном"""
print(f"{self.__class__.__name__} по имени {self.имя}, возраст: {self.возраст} лет")

# Подкласс Собака
class Собака(Животное):
"""Класс для представления собаки"""

def __init__(self, имя, возраст, порода):
# Вызов конструктора родительского класса
super().__init__(имя, возраст)
self.порода = порода

def голос(self):
"""Переопределение метода для собаки"""
print(f"{self.имя} говорит: Гав-гав!")

def информация(self):
"""Расширение метода информации для собаки"""
super().информация()
print(f"Порода: {self.порода}")

# Подкласс Кошка
class Кошка(Животное):
"""Класс для представления кошки"""

def голос(self):
"""Переопределение метода для кошки"""
print(f"{self.имя} говорит: Мяу!")

# Создание экземпляров классов
животные = [
Собака("Барон", 3, "Лабрадор"),
Кошка("Мурка", 5),
Животное("Нечто", 1)
]

# Демонстрация полиморфизма – вызов одного метода для разных типов
for животное in животные:
животное.информация()
животное.голос()
print("---")

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

Практические задачи с готовыми кодами на Python

Теоретические знания превращаются в практические навыки только через решение реальных задач. Ниже представлены python коды для начинающих, демонстрирующие применение изученных концепций для решения типичных задач.

Пример 15: Калькулятор с функциями

def сложение(a, b):
return a + b

def вычитание(a, b):
return a – b

def умножение(a, b):
return a * b

def деление(a, b):
if b == 0:
return "Ошибка: деление на ноль"
return a / b

def калькулятор():
print("Простой калькулятор")
print("Доступные операции: +, -, *, /")

# В реальном приложении используйте input()
первое_число = 10
второе_число = 5
операция = "+"

if операция == "+":
результат = сложение(первое_число, второе_число)
elif операция == "-":
результат = вычитание(первое_число, второе_число)
elif операция == "*":
результат = умножение(первое_число, второе_число)
elif операция == "/":
результат = деление(первое_число, второе_число)
else:
результат = "Неизвестная операция"

print(f"{первое_число} {операция} {второе_число} = {результат}")

# Запуск калькулятора
калькулятор()

Этот пример демонстрирует организацию кода с использованием функций для отдельных операций, что делает код модульным и легко расширяемым.

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

• Обработка и анализ данных (статистические расчеты, визуализация)
• Автоматизация рутинных задач (работа с файлами, отправка электронной почты)
• Веб-скрапинг (извлечение данных с веб-страниц)
• Создание графического интерфейса с помощью библиотеки Tkinter
• Обработка изображений и компьютерное зрение
• Разработка игр с Pygame
• Создание веб-приложений с Django или Flask

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

Приведенные примеры кодов охватывают базовые концепции Python и демонстрируют его синтаксис и возможности. Для дальнейшего изучения рекомендуется работать над собственными проектами, изучать документацию библиотек и практиковаться в решении задач на таких платформах, как LeetCode, HackerRank или CodeWars.

Освоение Python открывает перед вами обширные возможности в мире программирования. Ключ к успеху — регулярная практика и постепенное усложнение задач. Даже если ваша конечная цель — сложные проекты в области искусственного интеллекта или веб-разработки, путь начинается с понимания базовых конструкций и принципов, которые мы рассмотрели. Начните с малого, экспериментируйте с кодом и не бойтесь ошибок — они лучшие учителя в программировании.

Читайте также

• Python: универсальный язык программирования для веб, данных и ИИ
• Простые программы на Python для начинающих: учимся писать код
• Заработок на Python: 5 направлений для высокой зарплаты в IT
• 5 проверенных способов определить текущий путь в Python
• Превращаем Python-код в автономные приложения: инструкция по компиляции
• Инкапсуляция в Python: защита данных через принципы ООП
• Как обновить Python: увеличение производительности до 60% и новые функции
• Управление путями в Python: os.path или pathlib для файловых операций
• 15 лучших бесплатных PDF-учебников Python для начинающих программистов
• Наследование в Python: создание гибких и масштабируемых решений