автордың кітабын онлайн тегін оқу Python с нуля
Петр Левашов
Python с нуля. — СПб.: Питер, 2024.
ISBN 978-5-4461-2145-8
© ООО Издательство "Питер", 2024
Все права защищены. Никакая часть данной книги не может быть воспроизведена в какой бы то ни было форме без письменного разрешения владельцев авторских прав.
Введение
Добро пожаловать в «Python с нуля»! Эта книга даст вам основные знания и инструменты, которые помогут стать опытным разработчиком на Python — универсальном, мощном и доступном языке программирования. Вы узнаете, почему Python стал одним из самых популярных языков программирования в мире и что делает его отличным выбором и для начинающих, и для опытных разработчиков.
Эта книга приглашает вас в путешествие по огромному миру Python и охватывает все — от самых основ до более продвинутых тем, таких как наука о данных, веб-скрапинг и программирование графических интерфейсов. Каждая глава снабжена примерами, заданиями для самопроверки и лучшими практиками, чтобы вы не только поняли материал, но и получили практический опыт его применения. Неважно, новичок вы или опытный разработчик, желающий расширить свои навыки, — в этой книге найдется что-то для всех.
В первых главах вы узнаете об истории Python, настройке среды разработки и о том, как написать свою первую программу. Затем погрузитесь в основные понятия Python: переменные, типы данных, управляющие структуры, функции и модули. Вы изучите мощные возможности встроенных структур данных Python — списков, кортежей и словарей.
По мере приобретения навыков работы с Python вы познакомитесь с более продвинутыми темами, включая объектно-ориентированное программирование, обработку исключений и регулярные выражения. Узнаете, как работать с библиотеками и API, что позволит еще больше расширить функциональность Python.
Отладка и тестирование — важнейшие аспекты любого процесса разработки программного обеспечения. Вы узнаете, как использовать популярные инструменты и фреймворки, например Pytest, для тестирования кода на Python, а также как обеспечить надежность и сопровождаемость кода.
В последних главах мы углубимся в специализированные темы: науку о данных, веб-скрапинг и программирование графических интерфейсов. Вы изучите наиболее популярные библиотеки: NumPy, Pandas, Matplotlib, Scikit-learn и Tkinter. К концу книги у вас будет прочная основа понимания Python, а также уверенность в применении полученных навыков в различных сценариях реального мира.
Python стал незаменимым языком в современном постоянно развивающемся технологическом ландшафте. Его универсальность, читабельность и обширная экосистема сделали его популярным выбором для широкого спектра приложений — от веб-разработки и науки о данных до искусственного интеллекта и робототехники. Эта книга — ваш ключ к раскрытию возможностей Python и достижению новых высот в программировании. Увлекательное путешествие по пути открытий, изучения и освоения Python начинается!
Об авторе
Петр Severa Левашов, бывший хакер, ставший специалистом по компьютерной безопасности, привносит в это исчерпывающее руководство по программированию на Python поистине уникальный взгляд. Имея более чем 15-летний опыт работы с Python, Петр использовал этот язык в различных приложениях, начиная от управления серверными ботнетами для распространения спама и заканчивая торговлей криптовалютами. Имея две степени магистра в области компьютерной безопасности и экономики, а также богатый опыт преподавания, Петр излагает сложную информацию в увлекательной и академически обоснованной манере.
Родился 13 августа 1980 года в Санкт-Петербурге и прошел увлекательный путь, который привел его к тому, что он стал всемирно известным экспертом в своей области. Под псевдонимом Peter Severa когда-то руководил тремя крупными ботнетами для рассылки p2p-спама — Storm Worm, Waledac и Kelihos (Hlux), был модератором нескольких хакерских и кардерских форумов, включая легендарный carderplanet.com. В 2017 году арестован в Испании и экстрадирован в США, где ему были предъявлены обвинения. Частично признал себя виновным в обмен на снятие более серьезных обвинений.
Из этого опыта Петр извлек ценные жизненные уроки и теперь полностью посвящает себя честным и законным занятиям. В частности, стал успешным криптотрейдером с собственным алгоритмом, включающим ценовое действие и искусственный интеллект. Более подробную информацию о его торговом подходе ищите на сайте SeveraDAO.ai. Будучи твердым приверженцем свободы распространения информации, Петр стремится поделиться своими обширными знаниями с другими.
В этой книге Петр объединяет свои уникальные знания и предоставляет всеобъемлющий и увлекательный опыт обучения. Умение автора объяснять сложные концепции простыми словами делает эту книгу бесценной для всех, кто хочет освоить программирование на Python.
Дополнительную информацию об авторе вы найдете на сайте www.SeveraDAO.ai.
Петр также хотел бы выразить благодарность своему сыну Никите, без пытливых вопросов которого эта книга вряд ли увидела бы свет, и своей любимой жене Марии за ее постоянную поддержку, заботу и любовь. А также великолепному адвокату Ольге Леонидовне Исянамановой за ее профессиональную работу. Потрясающее владение УК РФ и его правоприменительной практикой, огромный опыт, честное и открытое общение с клиентами и адекватный подход к ценообразованию — что еще нужно от адвоката? Проблемы? Лучше звоните Ольге!
От издательства
Ваши замечания, предложения, вопросы отправляйте по адресу comp@piter.com (издательство «Питер», компьютерная редакция).
Мы будем рады узнать ваше мнение!
На веб-сайте издательства www.piter.com вы найдете подробную информацию о наших книгах.
Глава 1. Введение в программирование на Python
Что такое Python
Python — это универсальный язык программирования высокого уровня, который легко изучать и читать и на котором просто писать. В 1991 году Гвидо ван Россум впервые опубликовал исходный код Python, и с тех пор он стал одним из самых популярных языков программирования в мире.
Python обладает рядом особенностей, которые делают его отличным выбором как для начинающих, так и для опытных программистов. Одна из ключевых особенностей Python — читаемость. Код на Python легко читается и понимается, что облегчает его изучение и сопровождение. Python также имеет простой и интуитивно понятный синтаксис, это означает, что разработчики могут писать код быстрее и с меньшим количеством ошибок.
Еще одна причина популярности языка — его универсальность. Python можно использовать для широкого спектра приложений, включая веб-разработку, научные вычисления, искусственный интеллект и анализ данных. Python также имеет большое и активное сообщество разработчиков, которые вносят свой вклад в создание различных библиотек и инструментов с открытым исходным кодом.
Python — интерпретируемый язык, а это означает, что его интерпретатор выполняет код напрямую, без необходимости компиляции. Это делает код Python легким для тестирования и отладки, а также позволяет разработчикам быстро повторять код и экспериментировать с ним.
Python — отличный выбор для всех, кто хочет научиться программированию. Его простота, читабельность и универсальность делают его отличным языком для начинающих, а мощные возможности и активное сообщество делают его ценным инструментом для опытных разработчиков.
История Python
История языка программирования Python началась в конце 1980-х. Гвидо ван Россум — голландский ученый-компьютерщик, который в то время работал в научно-исследовательском институте Centrum Wiskunde & Informatica в Амстердаме, начал работу над Python в качестве хобби. Он намеревался создать язык, который было бы легко читать и писать.
Первая версия Python, 0.9.0, была выпущена в феврале 1991 года. Это был простой язык с базовыми типами данных, управляющими структурами и функциями, но он быстро завоевал популярность среди небольшого сообщества разработчиков, которые его использовали.
В 1994 году была выпущена версия Python 1.0, где появились новые возможности: инструменты функционального программирования и система модулей. Эта версия Python также включала систему Python Enhancement Proposals (PEPs), которая позволяла разработчикам предлагать и обсуждать изменения в языке.
Python 2.0 был выпущен в 2000 году, в него были включены сборка мусора и поддержка Unicode. За Python 2.0 последовало несколько других релизов в серии 2.x, включая Python 2.7, который был выпущен в 2010 году и широко используется по сей день.
В 2008 году началась разработка Python 3.0, целью которой было устранение некоторых недостатков и несоответствий в Python 2.x. Python 3.0 был выпущен в 2008 году и внес в язык несколько серьезных изменений, включая новую функцию print, улучшенную поддержку Unicode и упрощенный синтаксис для определения классов.
Сегодня Python — один из самых популярных языков программирования в мире с большим и активным сообществом разработчиков, которые вносят свой вклад в создание различных библиотек и инструментов с открытым исходным кодом.
Установка Python и среды разработки
Для начала нужно установить Python на свой компьютер. Это бесплатный язык с открытым исходным кодом, его можно загрузить с официального сайта Python по адресу www.python.org.
Есть две основные версии Python: Python 2.x и Python 3.x. Хотя Python 2.x все еще используется в некоторых старых приложениях, для новых проектов рекомендую использовать Python 3.x, поскольку это последняя версия языка, имеющая несколько важных улучшений по сравнению с Python 2.x.
Вы можете загрузить программу установки с официального сайта и следовать инструкциям по установке. В процессе установки можно выбрать глобальную установку Python на своем компьютере или локальную в определенном каталоге.
Помимо самого Python вам может понадобиться установить среду разработки, которая поможет писать код Python и управлять им. Среда разработки — это приложение, которое предоставляет инструменты для написания, тестирования и отладки кода. Некоторые популярные среды разработки для Python включают PyCharm, Visual Studio Code и Sublime Text.
При выборе среды разработки следует учитывать ее простоту использования, поддержку библиотек и инструментов Python и совместимость с вашей операционной системой. Многие среды разработки предлагают автодополнение кода, подсветку синтаксиса и инструменты отладки, которые помогут писать код более эффективно и с меньшим количеством ошибок.
После установки Python и среды разработки можно приступать к написанию кода на Python! В следующем разделе рассмотрим основы написания и выполнения программ на Python.
Интерпретатор Python и REPL (Read-Eval-Print Loop)
Одна из уникальных особенностей Python — его интерактивный режим, который позволяет выполнять код и сразу же видеть результаты. Это возможно благодаря интерпретатору Python, который представляет собой программу, читающую и выполняющую код Python.
Когда вы устанавливаете Python на свой компьютер, он включает интерактивный интерпретатор цикл чтения-вывода-печати (REPL). REPL позволяет вводить код по одной строке за раз и сразу же видеть результаты. Чтобы запустить Python REPL, откройте терминал или командную строку и введите python.
Запустите интерпретатор Python, введите код и нажмите Enter, чтобы посмотреть результаты. Например, чтобы вывести на экране «Привет, мой новый друг», наберите такой код:
>>> print("Привет, мой новый друг!")
Привет, мой новый друг!
>>> — это подсказка, которую интерпретатор Python выводит на экран, чтобы показать, что он готов к вводу кода. Интерпретатор оценит код и выведет результат на следующей строке.
Помимо интерактивного режима, можно записать код в файл и выполнить его из командной строки. Для этого создайте новый текстовый файл и сохраните его с расширением .py (например, myprogram.py). Затем запустите программу, набрав python myprogram.py в командной строке.
Интерпретатор Python и REPL — это мощные инструменты для написания и тестирования кода Python. Используя интерактивный режим, можно быстро экспериментировать с различными фрагментами кода и сразу же видеть результаты. В следующем разделе рассмотрим основы написания кода в файле и его запуск из командной строки.
Ваша первая программа на Python
Теперь, когда у вас установлен Python и есть базовое понимание того, как использовать интерпретатор, напишем нашу первую программу на Python!
В Python программа — это набор операторов, которые выполняются по порядку. Оператор — это строка кода, которая выполняет определенное действие, например выводит сообщение на экране или вычисляет значение.
Откройте текстовый редактор (например, Notepad или Sublime Text) и создайте новый файл. Сохраните файл с расширением .py, которое указывает, что это программа на Python. Например, program.py.
Затем введите следующий код:
print("Я готов, хозяин!")
Код говорит Python вывести на экран сообщение «Я готов, хозяин!». Функция print — это встроенная функция в Python, позволяющая выводить текст на экран.
После того как вы ввели код, сохраните файл и выйдите из текстового редактора. Теперь откройте окно командной строки или терминала и перейдите в каталог, где сохранили файл. Введите python program.py и нажмите Enter.
Python выполнит код в файле и выведет на экран сообщение «Я готов, хозяин!». Поздравляю, вы только что написали и запустили свою первую программу на Python!
Конечно, это только начало того, что можно сделать с помощью Python. В следующем разделе рассмотрим некоторые основные концепции программирования в Python, включая переменные, типы данных и операторы.
Синтаксис и основные концепции программирования
Рассмотрим основные концепции программирования в Python, включая синтаксис, переменные, типы данных и операторы.
Синтаксис относится к правилам и рекомендациям по написанию кода Python. В этом языке утверждения обычно пишутся на отдельных строках, а для обозначения блоков кода используются отступы.
Например, следующий код создает переменную и присваивает ей значение:
x = 33
Знак равенства (=) используется для присвоения значения переменной. Переменные предназначены для хранения значений, которые могут быть использованы в программе позже.
Python поддерживает несколько типов данных, включая целые числа, числа с плавающей точкой, строки и булевы значения. Целочисленные данные — это целые числа (например, 1, 2, 3), числа с плавающей точкой — это десятичные числа (например, 9.99, 3.1415), а строки — это последовательности символов (например, «робот», «хозяин»). Булевы значения — True или False.
Операторы используются для выполнения операций над переменными и значениями. Python поддерживает несколько операторов, включая арифметические операторы (+, –, *, /), операторы сравнения (==, !=, <, >) и логические операторы (and, or, not). В следующем коде для выполнения вычислений используются арифметические операторы:
x = 30
y = 3
z = x + y
print(z) # Вывод: 33
В этом примере знак «плюс» (+) используется для сложения значений x и y, а результат сохраняется в переменной z. Затем функция print используется для вывода значения z на экран.
Изучив синтаксис, переменные, типы данных и операторы, вы сможете писать простые программы на Python, выполняющие полезные задачи. В следующем разделе рассмотрим управляющие структуры, которые позволяют управлять работой программы на основе условий и циклов.
Запуск программ на Python
После написания программы на Python ее нужно запустить, чтобы увидеть результаты. В этом разделе рассмотрим способы запуска программ.
Самый простой способ — использовать интерпретатор Python, о чем говорилось в предыдущем разделе. Откройте окно командной строки или терминала, перейдите в каталог, где сохранена программа на Python, и введите python program.py (замените program.py именем файла вашей программы). Интерпретатор Python выполнит код, содержащийся в файле, и выведет результат.
Другой способ — использовать интегрированную среду разработки (IDE), например PyCharm или Visual Studio Code. IDE предоставляет более совершенную среду для написания, отладки и тестирования кода. Чтобы запустить программу в IDE, откройте файл программы и воспользуйтесь командой IDE run или execute.
Если вы пишете программу для веб-приложения или сервера, может понадобиться запустить программу с помощью веб-сервера, например Apache или Nginx. В этом случае для обработки запросов и ответов от веб-сервера обычно используется веб-фреймворк, например Django или Flask.
Независимо от того, как вы решите запустить свою программу, важно тщательно протестировать ее и убедиться, что она работает так, как ожидается. Это включает в себя тестирование пограничных состояний, обработку ошибок и исключений, а также проверку входных и выходных данных.
Основные методы отладки
Отладка — важная часть программирования, поскольку позволяет находить и исправлять ошибки в коде. В этом разделе рассмотрим некоторые основные методы отладки, которые можно использовать для выявления и устранения проблем в программах на Python.
Первый шаг в отладке — понять суть проблемы. Часто это включает в себя изучение выходных данных программы и поиск ошибок или неожиданного поведения. Можно использовать ведение журналов и операторы print, чтобы вывести информацию о состоянии программы в разных местах кода.
Следующий шаг после определения проблемы — изолировать ее причину. Для этого часто используется процесс исключения, чтобы определить части кода, вызывающие проблему. Можно использовать точки останова и пошаговую отладку, чтобы построчно изучить код и увидеть, как изменяются переменные и значения.
Помимо изучения кода, можно использовать сообщения об ошибках и трассировку стека, чтобы точно определить местоположение проблемы. Сообщения об ошибках предоставляют информацию о типе и месте ошибки, а трассировка стека показывает последовательность вызовов функций, которые привели к ошибке.
После выявления причины проблемы ее нужно устранить. Для этого вносят изменения в код и снова тестируют программу, чтобы убедиться, что проблема решена. Можно использовать инструменты автоматизированного тестирования и код-ревью, чтобы убедиться, что изменения не приведут к появлению новых проблем.
Стиль кода Python и лучшие практики
Стиль кода и лучшие практики важны для написания читабельного, удобного и эффективного кода Python. В этом разделе рассмотрим ключевые принципы стиля и лучшие практики.
Во-первых, при написании кода на Python важно придерживаться последовательного стиля. PEP 8 — официальное руководство по стилю Python — содержит рекомендации по оформлению кода, отступам, соглашениям об именовании и т.д. Придерживаясь единого стиля, вы можете писать простой в чтении и понимании код.
Важно писать модульный и переиспользуемый код. Это предполагает разбиение кода на небольшие, независимые функции или модули, которые можно использовать в разных частях программы. Так вы облегчите тестирование и отладку кода, а также снизите риск ошибок.
Используйте описательные имена переменных и комментарии для пояснения кода. Это облегчает другим разработчикам понимание вашего кода и снижает риск путаницы или ошибок.
Тщательно тестируйте код, чтобы убедиться, что все работает так, как ожидается. Это включает использование инструментов автоматизированного тестирования и написание юнит-тестов для проверки отдельных функций или модулей.
Наконец, следите за последними возможностями Python и лучшими практиками. Сообщество Python постоянно развивается, регулярно выпускаются новые функции и инструменты. Оставаясь в курсе последних событий, вы сможете писать более эффективный и действенный код.
Ресурсы для изучения Python
Python — популярный и широко используемый язык программирования, есть множество ресурсов для его изучения и освоения. Рассмотрим некоторые из лучших ресурсов для изучения Python: от онлайн-туториалов и курсов до книг и документации.
Онлайн-туториалы и курсы — отличный способ начать изучение Python. Они обеспечивают структурированную среду обучения и часто включают интерактивные примеры и упражнения. Популярные онлайн-ресурсы для изучения Python — Codecademy, Coursera, Udemy и edX.
Книги — это тоже отличный вариант, поскольку они дают всестороннее и глубокое представление о языке и его возможностях. Вот некоторые популярные книги для изучения Python: Python Crash Course1 Эрика Мэтиза, Python for Everybody Чарльза Северанса и Learning Python Марка Лутца.
Документация — еще один важный ресурс для изучения, поскольку в ней содержится подробная информация о языке и его возможностях. Официальная документация Python доступна на сайте docs.python.org, и это всеобъемлющий ресурс для разработчиков Python всех уровней.
Наконец, сообщество Python — это ценный ресурс для освоения языка. Есть множество групп пользователей Python и онлайн-форумов, где разработчики общаются друг с другом, делятся знаниями и опытом, а также получают помощь по конкретным вопросам.
1 Мэтиз Э. Изучаем Python. Программирование игр, визуализация данных, веб-приложения. — СПб.: Питер, 2016.
Книги — это тоже отличный вариант, поскольку они дают всестороннее и глубокое представление о языке и его возможностях. Вот некоторые популярные книги для изучения Python: Python Crash Course1 Эрика Мэтиза, Python for Everybody Чарльза Северанса и Learning Python Марка Лутца.
Мэтиз Э. Изучаем Python. Программирование игр, визуализация данных, веб-приложения. — СПб.: Питер, 2016.
Глава 2. Переменные, типы данных и операторы
Переменные — важная часть программирования на Python, они позволяют хранить значения и манипулировать ими в коде. Переменная — это, по сути, именованный контейнер, в котором хранится значение. Оно может быть числом, строкой или любым другим типом данных.
Чтобы создать переменную в Python, достаточно выбрать имя переменной и присвоить ей значение с помощью знака равенства (=). Например, следующий код создает переменную с именем x и присваивает ей значение 33:
x = 33
В этом коде x — имя переменной, а 33 — значение, которое ей присваивается. После создания переменной ее можно использовать в коде для выполнения вычислений, хранения результатов или манипулирования данными.
Имена переменных в Python должны следовать определенным правилам и соглашениям. Например, имена переменных не могут начинаться с цифры и содержать пробелы. Хорошей практикой будет использование описательных имен переменных, которые отражают цель или смысл хранимого значения.
Переменные могут хранить различные типы данных в Python, включая числовые типы данных, — целые числа и числа с плавающей точкой, а также строковые типы и булевы значения. Далее рассмотрим некоторые распространенные типы данных в Python и работу с ними.
Соглашения об именовании переменных
Имена переменных в Python должны соответствовать определенным соглашениям, чтобы код был удобочитаемым и понятным другим разработчикам. Ниже приведены основные соглашения об именах, которым нужно следовать при создании переменных в Python.
1. Используйте описательные имена: имена переменных должны отражать цель или смысл хранимого значения. Это облегчает другим разработчикам понимание кода.
2. Используйте строчные буквы: в Python имена переменных следует писать строчными буквами, разделяя слова подчеркиванием. Например, my_variable_name — это правильное имя переменной в Python.
3. Избегайте использования зарезервированных слов: в Python есть набор зарезервированных слов, которые имеют особое значение в языке, например if, else и while. Не используйте эти слова в качестве имен переменных.
4. Используйте верблюжий регистр для имен классов: если вы создаете класс, имя должно быть написано в верблюжьем регистре, с заглавной первой буквой в каждом слове. Например, MyClassName — это правильное имя класса в Python.
5. Будьте последовательны: последовательность — важный момент в именовании переменных. Используйте одинаковые соглашения об именовании во всем коде, чтобы его было легко читать и понимать.
Основные типы данных
Python поддерживает несколько основных типов данных, включая числовые, строковые и булевы значения. Вот краткий обзор некоторых типов данных.
1. Целочисленные значения: целые числа, 1, 2, 3 и т.д. Они представлены с помощью типа данных int.
2. Числа с плавающей точкой: десятичные числа, 9,99 или 3,1415. Они представлены с помощью типа данных float.
3. Строка: последовательность символов, например "робот" или "хозяин". Они представлены с помощью типа данных str.
4. Булевы значения: True или False. Они представлены с помощью типа данных bool.
5. None: специальный тип данных, который представляет отсутствие значения. Он часто используется для представления переменных, которые еще не инициализированы или не имеют значения.
В Python переменные могут содержать различные типы данных в зависимости от значения, которое им присваивается. Например, следующий код создает две переменные, x и y, и присваивает им значения 33 и 3.1415 соответственно:
x = 33
y = 3.1415
В этом коде x — целочисленная переменная, а y — переменная с плавающей точкой.
Далее рассмотрим, как работать с этими типами данных, выполнять вычисления и манипулировать строками.
Числовые типы данных
Числовые типы данных используются для представления чисел. Python поддерживает несколько числовых типов данных, включая целые числа, числа с плавающей точкой и комплексные числа.
Целочисленные значения — это целые числа, такие как 1, 2, 3. Они представлены с помощью типа данных int. Над целыми числами можно выполнять арифметические операции: сложение (+), вычитание (–), умножение (*) и деление (/). Например, следующий код выполняет несколько основных арифметических операций над целыми числами:
x = 30
y = 3
print(x + y) # Вывод: 33
print(x — y) # Вывод: 27
print(x * y) # Вывод: 90
print(x / y) # Вывод: 10.0
Знак «плюс» (+) используется для сложения значений x и y, знак «минус» (-) — для вычитания значения y из x, звездочка (*) — для умножения, а слеш (/) — для деления x на y.
Числа с плавающей точкой — это десятичные числа. Они представлены с помощью типа данных float. Вы можете выполнять арифметические операции над числами с плавающей точкой так же, как и над целыми числами. Однако из-за того, как числа с плавающей точкой представлены в памяти, вы можете столкнуться с ошибками округления или неточностями в вычислениях.
Комплексные числа — это числа, которые имеют как действительную, так и мнимую часть. Они представлены с помощью типа данных complex. Вы можете создать комплексное число, указав действительную и мнимую части с помощью суффикса j. Например, следующий код создает комплексное число:
z = 30 + 3j
В этом коде z — комплексное число с действительной частью 30 и мнимой частью 3.
Строковый тип данных
Строка — это последовательность символов, например "робот" или "хозяин". В Python строки представлены с помощью типа данных str. Вы можете создать строку, заключив текст в одинарные или двойные кавычки. Например, следующий код создает строку:
string1 = "Привет, хозяин!"
В этом коде string1 — это строковая переменная, которая содержит значение Привет, хозяин!.
Строки в Python рассматриваются как объекты, это означает, что над ними можно выполнять операции и методы. Вот некоторые общие операции и методы, которые можно использовать со строками в Python:
• Конкатенация: можно объединить две строки или более вместе с помощью оператора «плюс» (+). Следующий код объединяет две строки:
first_name = "Петр"
last_name = "Левашов"
full_name = first_name + " " + last_name
print(full_name) # Вывод: Петр Левашов
• Длина: можно найти длину строки с помощью функции len(). Следующий код определяет длину строки:
string2 = "Привет, хозяин!"
length = len(string2)
print(length) # Вывод: 14
• Индексирование: можно получить доступ к отдельным символам в строке с помощью индексации. Индексация в Python начинается с 0, это означает, что первый символ в строке имеет индекс 0. Следующий код получает доступ ко второму символу в строке:
string3 = "Привет, робот!"
второй_знак = string3[1]
print(second_char) # Вывод: e
• Нарезка: можно извлечь подстроку из строки с помощью нарезки (слайсинга). Нарезка позволяет указать диапазон индексов для извлечения из строки. Следующий код извлекает подстроку из строки:
string4 = "Робот готов!"
substring = string4[0:5]
print(substring) # Вывод: Робот
Булев тип данных
Булево значение — это значение, являющееся либо истинным, либо ложным. Они представлены с помощью типа данных bool. Булевы значения часто используются в программировании для представления условий или состояний.
Например, можно использовать булево значение для представления того, является условие истинным или ложным. Следующий код создает булеву переменную is_robot и присваивает ей значение True:
is_robot = True
В этом коде is_robot — булева переменная, которая имеет значение True.
В Python можно выполнять булевы операции с помощью следующих операторов:
• Логическое И: логический оператор AND (И) возвращает значение True, если оба операнда равны True. Например:
a = True
b = False
print(a and b) # Вывод: False
• Логическое ИЛИ: логический оператор OR (ИЛИ) возвращает True, если хотя бы один операнд равен True. Например:
a = True
b = False
print(a or b) # Вывод: True
• Логическое НЕ: логический оператор NOT (НЕ) возвращает противоположный операнд. Например:
a = True
print(not a) # Вывод: False
Булевы значения также можно сравнивать с помощью операторов сравнения, таких как оператор равенства (==) или неравенства (!=). Например:
x = 30
y = 3
print(x == y) # Вывод: False
print(x != y) # Вывод: True
В этом коде оператор == возвращает False, потому что x не равен y, а оператор != возвращает True, потому что x не равен y.
Приведение типов
Приведение, или преобразование, типов — это процесс преобразования одного типа данных в другой. В Python преобразование типов можно выполнять с помощью встроенных функций, предназначенных для каждого типа данных.
string5 = "33"
int5 = int(string5)
В этом коде string5 — это строковая переменная, которая содержит значение 33, а int5 — целочисленная переменная, которая содержит преобразованное значение.
Аналогично можно преобразовать целое число в строку с помощью функции str(). Следующий код преобразует целочисленную переменную int6 в строку:
int6 = 33
string6 = str(int6)
В этом коде int6 — это целочисленная переменная, которая содержит значение 33, а string6 — строковая переменная, которая содержит преобразованное значение.
Можно выполнять преобразование типов между числовыми типами данных, например преобразовать целое число в число с плавающей точкой с помощью функции float().
Важно отметить, что не все преобразования типов являются действительными или осмысленными. Например, вы не cможете преобразовать строку, содержащую буквы, в целое число, поскольку она не имеет числового значения.
Преобразование типов в Python поможет манипулировать типами данных и преобразовывать их по мере необходимости. При этом важно знать ограничения и правила преобразования типов, чтобы избежать ошибок и неожиданного поведения в коде.
Арифметические операторы
Арифметические операторы используются для выполнения основных математических операций. Python поддерживает следующие арифметические операторы.
1. Сложение (+): складывает два значения вместе.
2. Вычитание (-): вычитает одно значение из другого.
3. Умножение (*): перемножает два значения вместе.
4. Деление (/): делит одно значение на другое.
5. Получение остатка от деления (%): возвращает остаток от операции деления.
6. Возведение в степень (**): возводит одно значение в степень другого значения.
Следующий код использует арифметические операторы для выполнения некоторых базовых вычислений:
x = 30
y = 3
# Сложение
result1 = x + y
print(result1) # Вывод: 33
# Вычитание
result2 = x — y
print(result2) # Вывод: 27
# Умножение
result3 = x * y
print(result3) # Вывод: 90
# Деление
result4 = x / y
print(result4) # Вывод: 10.0
# Остаток от деления
result5 = x % y
print(result5) # Вывод: 0
# Возведение в степень
result6 = x ** y
print(result6) # Вывод: 27000
В этом коде переменные x и y содержат значения 30 и 3 соответственно. Арифметические операторы используются для выполнения операций сложения, вычитания, умножения, деления, получения остатка от деления и возведения в степень. Результаты сохраняются в разных переменных.
Операторы сравнения
Операторы сравнения используются для сравнения двух значений и возвращают булево значение (True или False) на основе результата сравнения. Python поддерживает следующие операторы сравнения.
1. Равно (==): возвращает True, если два значения равны.
2. Не равно (!=): возвращает True, если два значения не равны.
3. Больше чем (>): возвращает True, если первое значение больше второго.
4. Меньше чем (<): возвращает True, если первое значение меньше второго.
5. Больше или равно (>=): возвращает True, если первое значение больше или равно второму.
6. Меньше или равно (<=): возвращает True, если первое значение меньше или равно второму.
В следующем коде используются операторы для сравнения двух значений и возврата булева значения:
x = 30
y = 3
# Равно
result1 = x == y
print(result1) # Вывод: False
# Не равно
result 2 = x != y
print(result2) # Вывод: True
# Больше, чем
result 3 = x > y
print(result3) # Вывод: True
# Меньше, чем
result 4 = x < y
print(result4) # Вывод: False
# Больше или равно
result 5 = x >= y
print(result5) # Вывод: True
# Меньше или равно
result6 = x <= y
print(result6) # Вывод: False
В этом коде переменные x и y имеют значения 30 и 3 соответственно. Операторы сравнения используются для сравнения значений и возвращают булево значение, основанное на результате сравнения.
Логические операторы
Логические операторы используются для выполнения логических операций над булевыми значениями. Python поддерживает следующие логические операторы.
1. Логическое И (AND): возвращает значение True, если оба операнда равны True.
2. Логическое ИЛИ (OR): возвращает True, если хотя бы один операнд равен True.
3. Логическое НЕ (NOT): возвращает противоположный операнд.
Например, в следующем коде логические операторы используются для выполнения логических операций над булевыми значениями:
a = True
b = False
# Логическое И
result = a and b
print(result) # Вывод: False
# Логическое ИЛИ
result = a or b
print(result) # Вывод: True
# Логическое НЕ
result = not a
print(result) # Вывод: False
В этом коде переменные a и b содержат булевы значения. Логические операторы используются для выполнения логических операций над этими значениями и возвращают булево значение, основанное на результате операции.
Можно использовать круглые скобки для группировки логических операций и управления порядком вычисления:
a = True
b = False
c = True
# Сгруппированные логические операции
result = (a and b) or c
print(result) # Вывод: True
Здесь круглые скобки используются для группировки логической операции AND между a и b и логической операции OR между результатом операции AND и переменной c.
Приоритет и ассоциативность операторов
Приоритет и ассоциативность операторов определяют порядок, в котором в Python выполняются операторы. Когда выражение содержит несколько операторов, Python использует правила приоритета операторов и ассоциативности, чтобы определить, какой оператор выполняется первым и как вычисляется выражение.
Приоритет операторов определяет порядок оценки операторов с разными приоритетами. Python следует тем же правилам, что и большинство языков программирования, где умножение, деление и получение остатка от деления имеют более высокий приоритет, чем сложение и вычитание. Например, в выражении 1 + 3 * 33 Python сначала делает умножение, а затем сложение, в результате чего получается значение 100.
Ассоциативность операторов определяет порядок выполнения операторов с одинаковым приоритетом. Для большинства операторов Python следует ассоциативности слева направо, это означает, что операторы с одинаковым приоритетом выполняются слева направо. Например, в выражении 33 – 3 – 3 сначала выполняется первая операция вычитания (в результате получается 30), а затем вторая (в результате получается 27).
Некоторые операторы имеют ассоциативность справа налево, например оператор возведения в степень (**). Это означает, что выражение 2 ** 3 ** 2 выполняется как 2 ** (3 ** 2), в результате чего получается 512.
Важно понимать правила приоритета и ассоциативности операторов в Python, чтобы избежать ошибок и неожиданного поведения в коде. Используйте круглые скобки, чтобы контролировать порядок вычислений и отменять правила по умолчанию. Например, выражение (33 – 3) * 4 даст значение 120, поскольку сложение внутри круглых скобок выполняется первым.
Задания для самопроверки
1. Назовите основные типы данных в Python. Приведите пример каждого из них.
2. Выберите подходящие имена переменных для следующих описаний:
а) имя пользователя;
б) общее количество товаров в корзине;
в) цена одного товара.
3. Определите типы данных переменных a, b, c и d в коде:
a = 44
b = 2.72
c = "Hasta la vista, Robot!"
d = True
4. Преобразуйте следующие значения в соответствующие им типы данных:
а) преобразуйте строку "911" в целое число;
в) преобразуйте целое число 55 в строку;
в) преобразуйте плавающее число 2.71828 в целое число.
5. Выполните следующие арифметические действия и представьте результаты:
а) 446 + 745
б) 76 * 88
в) 45 / 9
г) 56 % 5
д) 3 ** 3
6. Какой будет результат у следующих операций сравнения:
а) 6 > 4
б) 9 < 2
в) 11 == 11
г) 1986 != 1986
7. Используя логические операторы, определите истинность следующих выражений:
а) True and False.
б) True or False;
в) not True.
8. Что выведет этот код? Объясните приоритет оператора и ассоциативность.
result = 2 + 3 * 4 — 6 / 2 + 5 * 3 — 4 / 2 + 1
print(result)
9. Напишите код, который вычисляет и выводит площадь прямоугольника, учитывая его ширину w = 4 и высоту h = 9. Используйте соответствующие имена переменных и арифметические операторы.
10. Что выведет этот код? Почему?
a = 4
b = 6
c = 8
result = a < b and b < c or a > b
print(result)
Глава 3. Управляющие структуры: условные операторы и циклы
Условные операторы: if, elif и else
Условные операторы используются для управления ходом выполнения в программах. Они позволяют проверять наличие определенных условий и выполнять определенный код на основе результата выполнения условия.
Основной условный оператор в Python — if. Он проверяет условие и выполняет блок кода, если условие True.
Пример:
x = 33
i x > 3:
print("x больше 3")
# Вывод: x больше 3
Оператор if проверяет, больше ли x, чем 3, и если да, то выполняет оператор print, который выводит x больше 3.
Вы также можете использовать оператор else для выполнения блока кода, если условие в операторе if равно False.
Пример:
x = 1
if x > 3:
print("x больше 3")
else:
print("x меньше или равно 3")
# Вывод: x меньше или равно 3
В этом коде оператор if проверяет, больше ли x, чем 3, но поскольку это не так, выполняется оператор else, который выводит x меньше или равно 3.
Вы также можете использовать оператор elif для проверки дополнительных условий. Оператор elif сокращенно называется else if и позволяет проверить несколько условий в одном блоке кода. Пример:
x = 3
if x > 3:
print("x больше 3")
elif x < 3:
print("x меньше 3")
else:
print("x равно 3")
# Вывод: x равно 3
В этом коде оператор if проверяет, больше ли x, чем 3, но поскольку это не так, выполняется оператор elif, который проверяет, меньше ли x, чем 3. Поскольку он также не меньше 3, выполняется оператор else, который выводит x равно 3.
Булевы выражения и операторы сравнения
Булево выражение — это выражение, результатом которого является значение логического типа данных: True или False. Булевы выражения обычно используются в условных операторах и циклах для управления потоком выполнения на основе определенного условия.
Операторы сравнения используются для сравнения двух значений и возвращают булево значение, основанное на результате сравнения. Python поддерживает следующие операторы сравнения.
1. Равно (==): возвращает True, если два значения равны.
2. Не равно (!=): возвращает True, если два значения не равны.
3. Больше чем (>): возвращает True, если первое значение больше второго.
4. Меньше чем (<): возвращает True, если первое значение меньше второго.
5. Больше или равно (>=): возвращает True, если первое значение больше или равно второму.
6. Меньше или равно (<=): возвращает True, если первое значение меньше или равно второму.
В этом коде используются операторы сравнения для сравнения двух значений и возврата булева значения:
x = 30
y = 3
# Равно
result = x == y
print(result) # Вывод: False
# Не равно
result = x != y
print(result) # Вывод: True
# Больше, чем
result = x > y
print(result) # Вывод: True
# Меньше, чем
result = x < y
print(result) # Вывод: False
# Больше или равно
result = x >= y
print(result) # Вывод: True
# Меньше или равно
result = x <= y
print(result) # Вывод: False
Переменные x и y имеют значения 30 и 3 соответственно. Операторы сравнения используются для сравнения значений и возвращают булево значение, основанное на результате сравнения.
Можно использовать булевы операторы для объединения нескольких булевых выражений и создания более сложных условий. Python поддерживает следующие булевы операторы.
1. Логическое И (and): возвращает значение True, если оба операнда равны True.
2. Логическое ИЛИ (or): возвращает True, если хотя бы один операнд равен True.
3. Логическое НЕ (not): возвращает противоположный операнд.
В следующем коде используются булевы операторы для объединения нескольких булевых выражений:
x = 30
y = 3
# Логическое И
result = x > 20 and y < 10
print(result) # Вывод: True
# Логическое ИЛИ
result = x < 20 or y > 10
print(result) # Вывод: False
# Логическое НЕ
result = not (x > y)
print(result) # Вывод: False
В этом коде булевы выражения комбинируются с помощью булевых операторов and, or и not для создания более сложных условий.
Циклы: for и while
Циклы используются для многократного выполнения блока кода до тех пор, пока не будет выполнено определенное условие. В Python есть два типа циклов: циклы for и while.
Цикл for используется для итерации последовательности (например, списка, кортежа или строки) и выполнения блока кода для каждого элемента в последовательности. Пример:
colors = ["green", "yellow", "red"]
for color in colors:
print(color)
В этом коде цикл for проходит по списку colors и выполняет оператор print для каждого элемента списка, в результате чего получается вывод:
green
yellow
red
Цикл while используется для многократного выполнения блока кода до тех пор, пока определенное условие не будет равно True. Пример:
x = 0
while x < 3:
print(x)
x += 1
В этом коде цикл while выполняет оператор print до тех пор, пока значение x меньше 3. Оператор x += 1 увеличивает значение x на 1 на каждой итерации, что в конечном итоге делает условие x < 3 ложным, и цикл завершается:
0
1
2
В дополнение к циклам for и while Python также поддерживает операторы управления циклами, которые позволяют управлять потоком выполнения в циклах. Есть три оператора управления циклами:
• break — преждевременное завершение цикла;
• continue — пропускает текущую итерацию цикла и переходит к следующей итерации;
• pass — ничего не делает и используется в качестве заполнителя.
Операторы break, continue и pass
Операторы управления циклами используются для управления потоком выполнения в циклах. В Python есть три оператора управления циклами — break, continue и pass.
Оператор break используется для преждевременного завершения цикла. Когда внутри цикла встречается оператор break, цикл немедленно завершается, а выполнение программы продолжается после цикла.
Пример:
colors = ["green", "yellow", "red"]
for color in colors:
if color == "red":
break
print(color)
В этом коде цикл for проходит по списку colors и выполняет оператор print для каждого элемента списка. Но когда цикл встречает элемент red, выполняется оператор break, который преждевременно завершает цикл и останавливает выполнение программы после цикла:
green
yellow
Оператор continue используется для пропуска текущей итерации цикла и перехода к следующей итерации. Когда внутри цикла встречается оператор continue, цикл пропускает текущую итерацию и переходит к следующей. Пример:
colors = ["green", "yellow", "red"]
for color in colors:
if color == "yellow":
continue
print(color)
Цикл for проходит по списку colors и выполняет оператор print для каждого элемента списка. Когда цикл встречает элемент yellow, выполняется оператор continue, который пропускает текущую итерацию и переходит к следующей. Вывод:
green
red
Оператор pass используется в качестве заполнителя. Когда оператор pass встречается внутри цикла, он ничего не делает, и выполнение программы продолжается со следующей итерации. Пример:
colors = ["green", "yellow", "red"]
for color in colors:
if fruit == "yellow":
pass
else:
print(color)
В этом коде цикл for проходит по списку colors и выполняет оператор print для каждого элемента списка. Когда цикл встречает элемент yellow, выполняется оператор pass, который ничего не делает, и выполнение программы продолжается со следующей итерации. Вывод:
green
red
Вложенные циклы и условия
Вложенные циклы и условия используются для создания более сложных условий и итераций по многомерным структурам данных. Вложенный цикл — это цикл внутри другого цикла, а вложенное условие — это условие внутри другого условия.
Пример вложенного цикла:
cars = ["Mercedes", "BMW", "Audi"]
colors = ["red", "green", "blue"]
for car in cars:
for color in colors:
print(car, color)
В этом коде есть два вложенных цикла. Внешний цикл проходит по списку cars, а внутренний — по списку colors. Оператор print выполняется для каждой комбинации car и color:
Mercedes red
Mercedes green
Mercedes blue
BMW red
BMW green
BMW blue
Audi red
Audi green
Audi blue
Пример вложенного условия:
x = 30
y = 3
if x > 27:
if y > 1:
print("x is greater than 27 and y is greater than 1")
else:
print("x is greater than 27 but y is not greater than 1")
else:
print("x is not greater than 27")
В этом коде есть два вложенных условия. Внешнее условие проверяет, больше ли x, чем 27, и если да, то внутреннее условие проверяет, больше ли y, чем 1. В зависимости от результата условия выполняется соответствующий оператор print.
# Вывод: x is greater than 27 and y is greater than 1
Задания для самопроверки
1. Объясните назначение каждой из этих управляющих структур: if, elif и else. Приведите простой пример для каждой из них.
2. Напишите код, который использует условный оператор, чтобы определить, является число x = 33 четным или нечетным. Выведите результат.
3. Что выведет этот код? Почему?
x = 55
if x > 13:
print("x больше 13")
elif x > 51:
print("x больше 51")
else:
print("x меньше или равно 51")
4. Зачем нужен цикл в программировании? Объясните разницу между циклами for и while. Приведите простой пример для каждого из них.
5. Напишите код, который вычисляет сумму всех целых чисел от 13 до 1 с помощью цикла for.
6. Напишите код, который вычисляет факториал числа n = 6 с помощью цикла while.
7. Объясните назначение управляющих операторов цикла break, continue и pass. Приведите простой пример для каждого из них.
8. Что выведет этот код? Почему?
for i in range(3, 8):
if i % 2 == 0:
continue
print(i)
9. Используя вложенные циклы for, напишите код, который выводит таблицу умножения (от 1 до 20).
10. Что выведет этот код? Почему?
x = 0
while x < 6:
y = 0
while y < 3:
print(f "x: {x}, y: {y}")
y += 1
x += 1
Глава 4. Функции и модули
Функции — это фундаментальная концепция в программировании. Они используются для разбиения программы на более мелкие и управляемые части. Функция — это блок многократно используемого кода, который выполняет определенную задачу и может быть вызван из других частей программы.
Функции полезны по нескольким причинам:
• делают код более модульным и легко читаемым;
• уменьшают количество дублирования кода в программе;
• помогают разбить сложные задачи на мелкие управляемые части.
Определение и вызов функций
В Python функция определяется с помощью ключевого слова def, за которым следует имя функции, а параметры функции заключаются в круглые скобки. Пример:
def welcome(name):
print("Hello, my dear " + name + "!")
В этом коде функция welcome принимает один параметр, name, и выводит приветствие. Чтобы вызвать эту функцию, укажите значение параметра name, как показано ниже:
welcome("Peter")
Вывод:
Hello, my dear Peter!
Функции также могут возвращать значения с помощью ключевого слова return:
def square(a):
return a ** 2
В этом коде функция square принимает параметр a и возвращает квадрат этого значения. Чтобы вызвать эту функцию и получить результат, нужно присвоить вызов функции переменной:
res = square(5)
print(res)
Вывод:
25
Параметры и аргументы функции
В Python параметр функции — это переменная, которая определяется в заголовке функции и используется для получения входных значений при вызове функции. Аргумент — это значение, которое передается функции при ее вызове. Это может быть как переменная, так и литерал.
В Python есть три типа параметров функций.
Позиционные аргументы
Это наиболее распространенный тип параметров — они определяются в заголовке функции без значения по умолчанию. Позиционные аргументы должны быть предоставлены в том же порядке, в каком определены в заголовке функции при вызове функции.
Пример:
def add(x, y):
return x + y
В этом коде функция add принимает два позиционных аргумента, x и y, и возвращает их сумму с помощью ключевого слова return. Чтобы вызвать эту функцию, нужно предоставить значения для обоих аргументов в том же порядке, в каком они определены в заголовке функции:
res = add(30, 3)
print(res)
Вывод:
33
Параметры ключевых слов
Это параметры, которые определены в заголовке функции со значением по умолчанию, они могут быть предоставлены в любом порядке при вызове функции. Если для параметра ключевого слова не указано значение, то используется значение по умолчанию.
Пример:
def welcome(name="Robot"):
print("Hello, my dear " + name + "!")
Функция welcome принимает один параметр ключевого слова name со значением по умолчанию Robot. Чтобы вызвать эту функцию и задать значение параметра name, можно использовать имя параметра и оператор присваивания:
welcome(name="Peter")
Вывод:
Hello, my dear Peter!
Если вы не указали значение для параметра name, будет использовано значение по умолчанию:
welcome ()
Вывод:
Hello, my dear Robot!
Параметры переменной длины
Это параметры, которые позволяют функции принимать произвольное количество аргументов, как позиционных, так и ключевых. В Python есть два типа параметров переменной длины: *args и **kwargs.
*args используется для приема переменного количества позиционных аргументов. Пример:
def add(*args):
return sum(args)
В этом коде функция add принимает переменное количество позиционных аргументов, используя синтаксис *args, и возвращает их сумму, используя встроенную функцию sum. Чтобы вызвать эту функцию с несколькими аргументами, укажите их через запятую:
res = add(1, 2, 4, 8, 16)
print(result)
Вывод:
31
**kwargs используется для приема переменного числа аргументов ключевых слов. Пример:
def welcome_person(**kwargs):
for key, value в kwargs.items():
print(key + ": " + value)
В этом коде функция welcome_person принимает переменное количество аргументов ключевых слов, используя синтаксис **kwargs, и выводит их с помощью цикла for. Чтобы вызвать эту функцию с несколькими ключевыми аргументами, укажите их с помощью имени параметра и оператора присваивания, как показано ниже:
print_person(name="Peter", age="42", city="New Haven")
Вывод:
name: Peter
age: 42
city: New Haven
Операторы возврата и возвращаемые значения
В Python функция может возвращать значение с помощью ключевого слова return. Оператор return используется для выхода из функции и возврата значения вызывающей стороне. Когда выполняется оператор return, функция немедленно завершается, а значение, указанное в операторе return, передается вызывающей стороне.
Функция также может возвращать несколько значений, возвращая кортеж. Пример:
def sum_and_product(a, b):
return a + b, a * b
В этом коде функция sum_and_product принимает два параметра, a и b, и возвращает их сумму и произведение в виде кортежа. Чтобы вызвать эту функцию и получить результаты, вы можете присвоить вызов функции нескольким переменным, как показано ниже:
sum, prod = sum_and_product(30, 3)
print(sum)
print(prod)
Вывод:
33
99
Если функция не указывает возвращаемое значение с помощью ключевого слова return, то по умолчанию она возвращает None. Пример:
def say_something():
print("Something!")
В этом коде функция say_something не имеет оператора возврата, поэтому по умолчанию возвращает None. Вызовем эту функцию, чтобы получить результат:
say_something()
# Вывод:
Something!
Область действия функции и локальные переменные
В Python переменные, определенные внутри функции, считаются локальными для этой функции, и доступ к ним возможен только внутри функции. Это называется областью видимости функции — она помогает предотвратить конфликты имен между переменными в разных частях программы.
Пример:
def add(x, y):
res = x + y
return res
В этом коде функция add определяет переменную res внутри функции, которая доступна только внутри функции. Чтобы вызвать эту функцию и получить результат, необходимо присвоить вызов функции переменной, как показано ниже:
result = add(30, 3)
print(result)
Вывод:
33
Если вы попытаетесь получить доступ к переменной res вне функции, то получите ошибку NameError, поскольку переменная в этой области видимости не определена:
def add(x, y):
res = x + y
return res
add(30, 3)
print(res)
# Вывод: NameError: имя 'res' не определено
По умолчанию переменные, определенные вне функции, считаются глобальными переменными и к ним можно получить доступ из любого места программы.
Глобальные переменные и оператор global
Глобальные переменные полезны для хранения значений, которые используются в разных частях программы, но они также могут привести к конфликтам имен и сделать код трудным для чтения и отладки.
Пример:
counter = 0
def increment():
global counter
counter += 1
return counter
Здесь переменная counter определена вне функции и считается глобальной переменной. Функция increment использует ключевое слово global, чтобы указать, что она хочет изменить глобальную переменную counter, а не создавать новую локальную переменную с тем же именем. Чтобы вызвать эту функцию и получить результат, необходимо присвоить вызов функции переменной, например, так:
result = increment()
print(result)
Вывод:
1
Если вы попытаетесь получить доступ к глобальной переменной внутри функции без использования ключевого слова global, Python предположит, что вы пытаетесь создать новую локальную переменную с тем же именем:
counter = 0
def increment():
counter += 1
return counter
increment()
# Вывод: UnboundLocalError: local variable 'counter' referenced before assignment
Глобальные переменные и оператор global в Python помогут создавать более гибкие и мощные программы, которые могут хранить данные и манипулировать ими в разных частях программы. Хорошей практикой считается ограничивать использование глобальных переменных, поскольку они могут привести к конфликтам имен и сделать код сложным для чтения и отладки.
Лямбда-функции
В Python лямбда-функция — это небольшая анонимная функция, которая может принимать любое количество аргументов, но иметь только одно выражение. Лямбда-функции полезны для написания коротких одноразовых функций, которые не требуют полного определения функции и могут использоваться везде, где требуется функция.
Пример:
add = lambda x, y: x + y
В этом коде переменной add присвоена лямбда-функция, которая принимает два параметра, x и y, и возвращает их сумму с помощью оператора +. Чтобы вызвать эту лямбда-функцию и получить результат, укажем значения параметров:
result = add(30, 3)
print(result)
# Вывод: 33
Лямбда-функции также могут использоваться в качестве аргументов других функций, например функции map:
numbers = [5, 4, 3, 2, 1]
squares = map(lambda x: x ** 2, numbers)
print(list(squares))
В этом коде функция map принимает лямбда-функцию, которая возводит в квадрат каждое число в списке numbers и возвращает новый список с возведенными в квадрат значениями. Функция list используется для преобразования результата в список.
В результате будет выведено:
[25, 16, 9, 4, 1]
Лямбда-функции могут стать мощным инструментом для написания лаконичного и выразительного кода, но они также могут затруднить чтение и отладку кода, если ими злоупотреблять или использовать не по назначению. Поэтому важно использовать лямбда-функции разумно и осторожно.
Встроенные функции
Python поставляется с рядом встроенных функций, которые можно использовать для выполнения обычных операций: манипулирование строками, работа со списками и словарями и выполнение математических вычислений. Эти функции доступны без необходимости использования дополнительных библиотек или модулей и могут сэкономить много времени и усилий при написании кода.
Вот некоторые из наиболее часто используемых встроенных функций в Python:
• len() — возвращает количество элементов в списке, кортеже, строке или словаре;
• range() — возвращает последовательность чисел от начала до конца, с необязательным размером шага;
• str() — преобразует объект в строку;
• int() — преобразует строку или число с плавающей запятой в целое число;
• float() — преобразует строку или целое число в число с плавающей точкой;
• type() — возвращает тип объекта;
• max() — возвращает наибольший элемент в списке, кортеже или строке;
• min() — возвращает наименьший элемент в списке, кортеже или строке;
• sum() — возвращает сумму всех элементов в списке или кортеже;
• sorted() — возвращает отсортированный список элементов в списке, кортеже или строке.
Вот пример использования функции len() для получения длины строки:
text = "Привет, робот!"
length = len(text)
print(length)
Вывод:
14
Модули и оператор import
В Python модуль — это файл, содержащий определения и инструкции. Модули используются для группировки связанного кода и для обеспечения пространства имен, что помогает предотвратить конфликты имен между различными частями программы. Python поставляется с рядом встроенных модулей, и вы также можете создавать свои собственные модули.
Чтобы использовать модуль, импортируйте его с помощью оператора import. Оператор import дает команду Python загрузить модуль и сделать его содержимое доступным для использования в программе.
Вот пример импорта модуля math и использования функции sqrt для вычисления квадратного корня из числа:
import math
result = math.sqrt(36)
print(result)
# Вывод: 6.0
Вы также можете импортировать определенные функции или переменные из модуля с помощью ключевого слова from:
from math import sqrt
result = sqrt(9)
print(result)
# Вывод: 3.0
Когда вы импортируете модуль, Python выполняет код модуля и создает новое пространство имен для его содержимого. Это означает, что любые функции, классы или переменные, определенные в модуле, доступны в пространстве имен модуля.
Создание и использование модулей
В Python вы можете создавать собственные модули, чтобы сгруппировать связанный код вместе и обеспечить пространство имен для кода. Модуль — это файл, содержащий определения и операторы Python, который можно импортировать и использовать в других программах Python.
Чтобы создать модуль, нужно определить свой код в файле с расширением .py. Имя файла должно совпадать с именем модуля, и вы можете поместить файл в любой каталог, входящий в путь Python. Путь Python — это список каталогов, в которых Python ищет модули, и его можно задать с помощью переменной среды PYTHONPATH или с помощью списка sys.path в коде.
Вот пример простого модуля под названием my_own_module.py:
def add(x, y):
return x + y
def subtract(x, y):
return x — y
Чтобы использовать этот модуль в другой программе Python, импортируйте его с помощью оператора import:
import my_own_module
result = my_own_module.add(30, 3)
print(result)
# Вывод: 33
Стандартная библиотека Python
Стандартная библиотека Python — это набор модулей и пакетов. Они поставляются вместе с Python и обеспечивают широкий спектр функциональных возможностей для решения общих задач программирования. Стандартная библиотека включает в себя модули для работы с файлами, датами и временем, регулярными выражениями, сетями и многое другое. Эти модули используются без необходимости дополнительной установки.
Вот некоторые из наиболее часто используемых модулей стандартной библиотеки:
• os — обеспечивает взаимодействие с операционной системой, например доступ к файлам и каталогам;
• datetime — предоставляет классы для работы с датами и временем;
• re — обеспечивает поддержку регулярных выражений;
• urllib — предоставляет функции для работы с URL и HTTP;
• math — предоставляет математические функции и константы;
• random — предоставляет функции для генерации случайных чисел и значений;
• json — предоставляет функции для работы с данными JSON;
• csv — предоставляет функции для работы с файлами CSV.
Чтобы использовать модуль из стандартной библиотеки Python, импортируйте его с помощью оператора import.
Например, чтобы использовать модуль datetime, используйте следующий код:
import datetime
now = datetime.datetime.now()
print(now)
Это выведет текущую дату и время:
2023-03-03 17:22:33.593750
Использование стандартной библиотеки Python позволяет писать более эффективный код без дополнительных библиотек или модулей сторонних разработчиков. Стандартная библиотека — это мощный инструмент, который предоставляет широкий спектр возможностей для решения общих задач программирования.
Задания для самопроверки
1. Объясните разницу между параметрами и аргументами функции. Приведите простой пример.
2. Напишите функцию под названием add, которая принимает два позиционных параметра, param1 и param2, и возвращает сумму двух чисел. Вызовите функцию со значениями 18 и 39 и выведите результат.
3. Измените функцию add из второго задания так, чтобы она принимала параметры ключевых слов вместо позиционных параметров. Вызовите функцию с ключевыми аргументами param1=13 и param2=233 и выведите результат.
4. Напишите функцию под названием greet, которая принимает ключевой параметр name со значением по умолчанию Stranger и возвращает строку приветствия Hi, {name}.... Вызовите функцию без указания аргументов и выведите результат. Затем вызовите функцию с аргументом ключевого слова name="Severa" и выведите результат.
5. Объясните разницу между локальными и глобальными переменными. Приведите простой пример.
6. Что выведет этот код? Почему?
x = 1934
def modify_x():
global x
x = 2023
print(f"Inside the function: x = {x}")
modify_x()
print(f"Outside the function: x = {x}")
7. Напишите лямбда-функцию, которая вычисляет квадрат числа x. Назначьте лямбда-функцию переменной с именем square и вызовите ее со значением 11. Выведите результат.
8. Зачем нужна стандартная библиотека Python? Назовите три встроенные функции и объясните их назначение.
9. Объясните назначение модулей и оператора import. Приведите простой пример.
10. Создайте простой модуль с именем my_module1.py, содержащий функцию say_hi(name), которая принимает один параметр name и возвращает строку приветствия Hi, {name}.... В отдельном скрипте импортируйте функцию say_hi из модуля my_module1 и вызовите ее со значением Peter. Выведите результат.
Глава 5. Структуры данных: cписки, кортежи и словари
Структура данных — это способ хранения и организации данных в вашей программе. Структуры данных позволяют работать с коллекциями данных (списки, кортежи и словари) и выполнять операции над этими коллекциями, например сортировку, фильтрацию и поиск.
Python поставляется с несколькими встроенными структурами данных, каждая из которых имеет свои преимущества и варианты использования. Вот некоторые из наиболее часто используемых структур данных в Python.
• Список — упорядоченная коллекция элементов, представленная квадратными скобками ([]).
• Кортеж — упорядоченная, неизменяемая коллекция элементов, представленная круглыми скобками (()).
• Словарь — неупорядоченная коллекция пар «ключ — значение», представленная фигурными скобками ({}).
• Множество — неупорядоченная коллекция уникальных элементов, представленная фигурными скобками ({}).
Структуры данных — мощный инструмент, помогающий писать более эффективный код. В следующих разделах подробно рассмотрим каждую из структур данных и ее использование в программах.
Списки в Python
В Python список — это упорядоченная коллекция элементов, которые могут быть разных типов. Списки создаются с помощью квадратных скобок ([]) и могут содержать любое количество элементов, разделенных запятыми.
Вот пример создания списка чисел:
numbers = [5, 4, 3, 2, 1]
Списки являются изменяемыми, это означает, что вы можете изменять их после того, как они были созданы. Можно добавлять, удалять или изменять элементы в списке с помощью различных встроенных методов списка.
Вот пример добавления элемента в список с помощью метода append():
numbers = [5, 4, 3, 2, 1]
numbers.append(0)
Этот код добавляет число 0 в конец списка:
numbers = [5, 4, 3, 2, 1, 0]
Вы можете получить доступ к элементам списка, используя их индекс, который начинается с 0 для первого элемента списка. Вот как получить доступ к третьему элементу списка:
numbers = [5, 4, 3, 2, 1]
print(numbers[2])
Вывод:
3
Вы также можете использовать отрицательную индексацию для доступа к элементам с конца списка. Например, для доступа к последнему элементу списка можно использовать –1:
numbers = [5, 4, 3, 2, 1]
print(numbers[-1])
Вывод:
1
Списки — это мощный инструмент, позволяющий выполнять сортировку, фильтрацию и поиск. В следующих разделах подробно рассмотрим некоторые расширенные возможности списков.
Кортежи в Python
В Python кортеж — это упорядоченная коллекция элементов, подобная списку. Однако кортежи неизменяемы, это означает, что они не могут быть изменены после создания. Кортежи создаются с помощью круглых скобок (()), а элементы разделяются запятыми.
Пример создания кортежа чисел:
numbers = (5, 4, 3, 2, 1)
К кортежам можно обращаться с помощью индексирования и нарезки, как и к спискам. Поскольку кортежи неизменяемы, вы не можете изменить их после создания. Это может быть полезно для хранения данных, которые не подлежат изменению, например параметров конфигурации или постоянных значений.
Вот как получить доступ ко второму элементу кортежа:
numbers = (5, 4, 3, 2, 1)
print(numbers[1])
Вывод:
4
Вы также можете использовать отрицательную индексацию и нарезку с кортежами, как и со списками.
Кортежи могут использоваться для возврата нескольких значений из функции или для группировки связанных данных. Это полезный инструмент для работы с коллекциями данных, и их можно использовать вместе со списками и другими структурами данных для построения более сложных программ.
Словари в Python
В Python словарь — это неупорядоченная коллекция пар «ключ — значение». Словари создаются с помощью фигурных скобок ({}) и могут содержать любое количество элементов, разделенных запятыми. Каждый элемент словаря состоит из ключа и значения, разделенных двоеточием (:).
Вот пример создания словаря имен студентов и соответствующих им возрастов:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
Вы можете получить доступ к элементам словаря, используя их ключи, как показано ниже:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
print(ages["Ivan"])
Вывод:
32
Вы также можете использовать метод get() для доступа к элементам словаря, который позволяет указать значение по умолчанию, возвращаемое в случае, если ключ не существует:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
print(ages.get("Anatoly", 40))
Вывод:
40
Словари являются изменяемыми, это означает, что вы можете добавлять, удалять или изменять элементы после их создания. Вы можете добавить новый элемент в словарь, присвоив значение новому ключу, как показано ниже:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
ages["Anatoly"] = 40
Этот код добавляет новый элемент в словарь:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22, "Anatoly": 40}
Использование словарей в Python позволяет хранить и получать доступ к данным с использованием парадигмы «ключ — значение», что может быть полезно для широкого круга задач программирования.
В следующих разделах подробнее рассмотрим некоторые расширенные возможности словарей: словарное включение (генератор словарей) и сортировку.
Списковое включение
Списковое включение — это лаконичный способ создания нового списка путем преобразования или фильтрации существующего. Списки создаются с помощью квадратных скобок ([]) и состоят из трех частей.
1. Входная последовательность.
2. Переменная, представляющая каждый элемент входной последовательности.
3. Выходное выражение, которое преобразует или фильтрует каждый элемент входной последовательности.
Вот пример простого спискового включения, которое удваивает каждый элемент в списке чисел:
numbers = [5, 4, 3, 2, 1]
doubles = [num * 2 for num in numbers]
Это создаст новый список doubles, где каждый элемент списка numbers будет удвоенным:
[10, 8, 6, 4, 2]
Списковое включение может также включать условные операторы, которые позволяют фильтровать входную последовательность на основе условия. Вот пример спискового включения, который содержит только нечетные числа из списка чисел:
numbers = [5, 4, 3, 2, 1]
odds = [num for num in numbers if num % 2 != 0]
Этот код создает новый список под названием odds, который будет включать только нечетные числа из списка numbers:
[5, 3, 1]
Списковое включение — это мощный инструмент в Python, который позволяет создавать новые списки в краткой и читабельной форме.
Сортировка и поиск в структурах данных
В Python можно использовать встроенные функции для сортировки и поиска структур данных, таких как списки и словари. Сортировка и поиск часто используются при обработке данных, и Python предоставляет широкий спектр инструментов, позволяющих сделать решение этих задач простым и эффективным.
Для сортировки списка в Python используйте метод sort(). Он сортирует список на месте, то есть изменяет исходный список, а не создает новый, отсортированный.
Вот пример сортировки списка чисел:
numbers = [1, 2, 5, 7, 2, 3, 4, 9, 6]
numbers.sort()
Этот код сортирует список чисел в порядке возрастания:
[1, 2, 2, 3, 4, 5, 6, 7, 9]
Для того чтобы отсортировать список по убыванию, можно передать аргумент reverse=True в метод sort():
numbers = [1, 2, 5, 7, 2, 3, 4, 9, 6]
numbers.sort(reverse=True)
Этот код позволяет отсортировать список чисел в порядке убывания:
[9, 7, 6, 5, 4, 3, 2, 2, 1]
Для поиска элемента в списке можно использовать ключевое слово in. Оно возвращает True, если элемент находится в списке, и False в противном случае.
Вот пример поиска элемента в списке:
numbers = [5, 4, 3, 2, 1]
if 3 in numbers:
print("3 is in the list")
else:
print("3 is not in the list")
Вывод:
3 is in the list
Для поиска элемента в словаре можно использовать ключевое слово in с ключами словаря:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
if "Ivan" in ages:
print("Ivan's age is", ages["Ivan"])
else:
print("Ivan is not in the dictionary")
# Вывод: Ivan’s age is 32
Сортировка и поиск — это фундаментальные задачи в обработке данных, и Python предоставляет широкий спектр инструментов, позволяющих сделать их простыми и эффективными.
В следующих разделах подробно рассмотрим некоторые продвинутые методы, которые можно использовать для сортировки и поиска структур данных, например пользовательскую сортировку и поиск с помощью двоичного поиска.
Продвинутые методы работы со структурами данных
Копирование и клонирование структур данных
В Python можно копировать и клонировать структуры данных для создания новых независимых копий исходных данных. Копирование и клонирование полезны, когда нужно изменить структуру данных, не затрагивая исходные данные.
Чтобы создать копию списка в Python, можно использовать метод copy(). Он создает новый список с теми же элементами, что и в исходном.
Вот пример создания копии списка:
numbers = [5, 4, 3, 2, 1]
copy = numbers.copy()
Этот код создает новый список copy, содержащий те же элементы, что и список numbers:
[5, 4, 3, 2, 1]
Чтобы создать клон списка, используйте оператор нарезки (:). Он создает новый список с теми же элементами, что и в исходном.
Пример создания клона списка:
numbers = [5, 4, 3, 2, 1]
clone = numbers[:]
Это создаст новый список clone, который содержит те же элементы, что и список numbers:
[5, 4, 3, 2, 1]
Копирование и клонирование похожи, но у них есть несколько важных различий. При копировании создается новый объект, который является неглубокой (поверхностной) копией исходной структуры данных. Неглубокая копия означает, что новый объект имеет свою собственную область памяти, но разделяет те же внутренние объекты (например, вложенные списки или словари), что и исходная структура данных. Если какие-либо из внутренних объектов являются изменяемыми (например, списки), изменения этих объектов будут отражены как в исходной структуре данных, так и в копии.
При клонировании создается новый объект, который является глубокой копией исходной структуры данных. Глубокая копия означает, что новый объект имеет свою собственную область памяти и свои собственные внутренние объекты. Изменения внутренних объектов нового объекта не повлияют на исходную структуру данных, и наоборот.
Копирование и клонирование также применимы к другим структурам данных, таким как словари, множества и кортежи, с использованием метода
