Объектно-ориентированный Python — Введение

Языки программирования постоянно появляются, как и разные методологии. Объектно-ориентированное программирование является одной из таких методологий, которая стала довольно популярной за последние несколько лет.

В этой главе рассказывается об особенностях языка программирования Python, который делает его объектно-ориентированным языком программирования.

Схема классификации языкового программирования

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

Языковые классы	категории	Langauages
Парадигма программирования	процедурный	C, C ++, C #, Objective-C, Java, Go
	Scripting	CoffeeScript, JavaScript, Python, Perl, Php, Ruby
	функциональная	Clojure, Eralang, Haskell, Scala
Класс компиляции	статический	C, C ++, C #, Objective-C, Java, Go, Haskell, Scala
	динамический	CoffeeScript, JavaScript, Python, Perl, Php, Ruby, Clojure, Erlang
Тип Класс	сильный	C #, Java, Go, Python, Ruby, Clojure, Erlang, Haskell, Scala
	слабый	C, C ++, C #, Objective-C, CoffeeScript, JavaScript, Perl, Php
Класс памяти	Удалось	другие
	Неуправляемый	C, C ++, C #, Objective-C

Что такое объектно-ориентированное программирование?

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

Python, объектно-ориентированное программирование (ООП), представляет собой способ программирования, который фокусируется на использовании объектов и классов для проектирования и создания приложений. Основными столпами объектно-ориентированного программирования (ООП) являются наследование, полиморфизм, абстракция, инкапсуляция рекламы.

Объектно-ориентированный анализ (OOA) — это процесс изучения проблемы, системы или задачи и определения объектов и взаимодействий между ними.

Почему стоит выбрать объектно-ориентированное программирование?

Python был разработан с объектно-ориентированным подходом. ООП предлагает следующие преимущества —

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

• Облегчает простое обслуживание и модификацию существующего кода.

• Повышает модульность программы, поскольку каждый объект существует независимо, и новые функции можно легко добавлять, не нарушая существующие.

• Представляет хорошую основу для библиотек кода, где поставляемые компоненты могут быть легко адаптированы и изменены программистом.

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

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

Облегчает простое обслуживание и модификацию существующего кода.

Повышает модульность программы, поскольку каждый объект существует независимо, и новые функции можно легко добавлять, не нарушая существующие.

Представляет хорошую основу для библиотек кода, где поставляемые компоненты могут быть легко адаптированы и изменены программистом.

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

Процедурное и объектно-ориентированное программирование

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

В таблице на следующем рисунке показаны основные различия между подходами POP и OOP.

Разница между процедурно-ориентированным программированием (POP) и Объектно-ориентированное программирование (ООП).

	Процедурно-ориентированное программирование	Объектно-ориентированное программирование
На основе	В Pop все внимание сосредоточено на данных и функциях.	Упс основан на сценарии реального мира. Вся программа делится на небольшие части, называемые объектом
Повторное использование	Ограниченное повторное использование кода	Повторное использование кода
Подход	Нисходящий подход	Объектно-ориентированный дизайн
Спецификаторы доступа	Не любой	Государственный, частный и охраняемый
Движение данных	Данные могут свободно перемещаться от функций к функциям в системе	В Oops данные могут перемещаться и взаимодействовать друг с другом через функции-члены
Доступ к данным	В поп-музыке большинство функций использует глобальные данные для совместного использования, к которым можно свободно обращаться от функции к функции в системе	В Oops данные не могут свободно перемещаться от метода к методу, они могут храниться в публичном или частном порядке, чтобы мы могли контролировать доступ к данным.
Скрытие данных	В поп, такой специфический способ скрыть данные, так немного менее безопасный	Это обеспечивает сокрытие данных, гораздо более безопасный
перегрузка	Невозможно	Функции и перегрузка операторов
Пример-Языки	C, VB, Фортран, Паскаль	C ++, Python, Java, C #
абстракция	Использует абстракцию на уровне процедуры	Использует абстракцию на уровне класса и объекта

Принципы объектно-ориентированного программирования

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

Давайте кратко разберем каждый из столпов объектно-ориентированного программирования —

Инкапсуляция

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

наследование

Наследование, также называемое обобщением, позволяет нам фиксировать иерархические отношения между классами и объектами. Например, «фрукт» является обобщением «апельсина». Наследование очень полезно с точки зрения повторного использования кода.

абстракция

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

Полиморфизм

Полиморфизм означает много форм. То есть вещь или действие присутствует в разных формах или способах. Один хороший пример полиморфизма — перегрузка конструктора в классах.

Объектно-ориентированный Питон

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

Модули против Классов и Объектов

Модули похожи на «Словари»

При работе с модулями обратите внимание на следующие моменты:

• Модуль Python — это пакет для инкапсуляции многократно используемого кода.

• Модули находятся в папке с файлом __init__.py .

• Модули содержат функции и классы.

• Модули импортируются с использованием ключевого слова import .

Модуль Python — это пакет для инкапсуляции многократно используемого кода.

Модули находятся в папке с файлом __init__.py .

Модули содержат функции и классы.

Модули импортируются с использованием ключевого слова import .

Напомним, что словарь является парой ключ-значение . Это означает, что если у вас есть словарь с ключевым EmployeID, и вы хотите получить его, то вам придется использовать следующие строки кода:

employee = {“EmployeID”: “Employee Unique Identity!”}
print (employee [‘EmployeID])

Вам придется работать над модулями с помощью следующего процесса —

• Модуль — это файл Python с некоторыми функциями или переменными.

• Импортируйте нужный вам файл.

• Теперь вы можете получить доступ к функциям или переменным в этом модуле с помощью «.» (точка) Оператор.

Модуль — это файл Python с некоторыми функциями или переменными.

Импортируйте нужный вам файл.

Теперь вы можете получить доступ к функциям или переменным в этом модуле с помощью «.» (точка) Оператор.

Рассмотрим модуль с именем employee.py, в котором есть функция employee . Код функции приведен ниже —

# this goes in employee.py
def EmployeID():
   print (“Employee Unique Identity!”)

Теперь импортируйте модуль и затем получите доступ к функции EmployeID —

import employee
employee. EmployeID()

Вы можете вставить переменную с именем Age , как показано на рисунке —

def EmployeID():
   print (“Employee Unique Identity!”)
# just a variable
Age = “Employee age is **”

Теперь, доступ к этой переменной следующим образом —

import employee
employee.EmployeID()
print(employee.Age)

Теперь давайте сравним это со словарем —

Employee[‘EmployeID’] # get EmployeID from employee
Employee.employeID() # get employeID from the module
Employee.Age # get access to variable

Обратите внимание, что в Python есть общий шаблон —

• Возьмите ключ = значение стиля контейнера

• Получите что-нибудь из этого по имени ключа

Возьмите ключ = значение стиля контейнера

Получите что-нибудь из этого по имени ключа

При сравнении модуля со словарем оба они похожи, за исключением следующего:

• В случае словаря ключ является строкой, а синтаксис — [ключ].

• В случае модуля ключ является идентификатором, а синтаксис — .key.

В случае словаря ключ является строкой, а синтаксис — [ключ].

В случае модуля ключ является идентификатором, а синтаксис — .key.

Классы как Модули

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

Если вам нужно создать класс, похожий на модуль employee, вы можете сделать это, используя следующий код:

class employee(object):
   def __init__(self):
      self. Age = “Employee Age is ##”
   def EmployeID(self):
      print (“This is just employee unique identity”)

Примечание. Классы предпочтительнее модулей, потому что вы можете использовать их как есть и без особых помех. В то время как с модулями у вас есть только один со всей программой.

Объекты похожи на мини-импорт

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

Вы можете создать экземпляр объекта, аналогично вызову класса, такого как функция, как показано

this_obj = employee() # Instantiatethis_obj.EmployeID() # get EmployeId from the class
print(this_obj.Age) # get variable Age

Вы можете сделать это любым из следующих трех способов —

# dictionary style
Employee[‘EmployeID’]
# module style
Employee.EmployeID()
Print(employee.Age)
# Class style
this_obj = employee()
this_obj.employeID()
Print(this_obj.Age)

Объектно-ориентированный Python — настройка среды

В этой главе подробно объясняется настройка среды Python на вашем локальном компьютере.

Предпосылки и наборы инструментов

Прежде чем продолжить изучение Python, мы рекомендуем вам проверить, выполнены ли следующие условия:

• На вашем компьютере установлена ​​последняя версия Python

• IDE или текстовый редактор установлен

• У вас есть базовые знания по написанию и отладке в Python, то есть вы можете сделать следующее в Python:

  • Умеет писать и запускать программы на Python.

  • Отлаживать программы и диагностировать ошибки.

  • Работа с основными типами данных.

  • Пишите для циклов, циклов while и операторов if

  • Функции кода

На вашем компьютере установлена ​​последняя версия Python

IDE или текстовый редактор установлен

У вас есть базовые знания по написанию и отладке в Python, то есть вы можете сделать следующее в Python:

Умеет писать и запускать программы на Python.

Отлаживать программы и диагностировать ошибки.

Работа с основными типами данных.

Пишите для циклов, циклов while и операторов if

Функции кода

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

https://www.tutorialpoints.com/

Установка Python

Следующие шаги подробно покажут вам, как установить Python на локальный компьютер.

Шаг 1 — Зайдите на официальный веб-сайт Python https://www.python.org/ , щелкните меню « Загрузки» и выберите последнюю или любую стабильную версию по вашему выбору.

Шаг 2 — Сохраните exe-файл установщика Python, который вы загружаете, и, как только вы скачали его, откройте его. Нажмите « Выполнить» и выберите опцию « Далее» по умолчанию и завершите установку.

Шаг 3 — После установки вы должны увидеть меню Python, как показано на рисунке ниже. Запустите программу, выбрав IDLE (Python GUI).

Это запустит оболочку Python. Введите простые команды, чтобы проверить установку.

Выбор IDE

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

• Pycharm IDE
• Комодо IDE
• Эрик Питон IDE

Примечание. Eclipse IDE в основном используется в Java, однако имеет плагин Python.

PyCharm

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

Ссылка для скачивания

https://www.jetbrains.com/pycharm/download/#section=windows

Поддерживаемые языки — Python, HTML, CSS, JavaScript, Coffee Script, TypeScript, Cython, AngularJS, Node.js, шаблоны языков.

Скриншот

Почему выбрать?

PyCharm предлагает следующие функции и преимущества для своих пользователей —

• Кроссплатформенная IDE, совместимая с Windows, Linux и Mac OS
• Включает Django IDE, а также поддержку CSS и JavaScript
• Включает в себя тысячи плагинов, встроенный терминал и контроль версий
• Интегрируется с Git, SVN и Mercurial
• Предлагает интеллектуальные инструменты редактирования для Python
• Простая интеграция с Virtualenv, Docker и Vagrant
• Простая навигация и поиск
• Анализ кода и рефакторинг
• Настраиваемые инъекции
• Поддерживает тонны библиотек Python
• Содержит шаблоны и JavaScript-отладчики
• Включает отладчики Python / Django
• Работает с Google App Engine, дополнительными фреймворками и библиотеками.
• Имеет настраиваемый пользовательский интерфейс, эмуляцию VIM

Комодо IDE

Это IDE полиглот, которая поддерживает более 100 языков и в основном для динамических языков, таких как Python, PHP и Ruby. Это коммерческая среда IDE, доступная в течение 21 дня, с полной функциональностью. ActiveState — компания-разработчик программного обеспечения, управляющая разработкой Komodo IDE. Он также предлагает урезанную версию Komodo, известную как Komodo Edit, для простых задач программирования.

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

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

Ссылка для скачивания

Ссылки для скачивания для Komodo Edit (бесплатная версия) и Komodo IDE (платная версия) приведены здесь —

Комодо Править (бесплатно)

https://www.activestate.com/komodo-edit

IDE Комодо (платно)

https://www.activestate.com/komodo-ide/downloads/ide

Скриншот

Почему выбрать?

• Мощная IDE с поддержкой Perl, PHP, Python, Ruby и многих других.
• Кроссплатформенная IDE.

Он включает в себя основные функции, такие как встроенная поддержка отладчика, автозаполнение, просмотрщик Document Object Model (DOM), браузер кода, интерактивные оболочки, конфигурация точек останова, профилирование кода, интегрированное модульное тестирование. Одним словом, это профессиональная среда разработки с множеством функций для повышения производительности.

Эрик Питон IDE

Это IDE с открытым исходным кодом для Python и Ruby. Эрик — полнофункциональный редактор и IDE, написанный на Python. Он основан на кроссплатформенном наборе инструментов Qt GUI, объединяющем очень гибкий элемент управления редактора Scintilla. IDE очень настраиваемый, и можно выбрать, что использовать, а что нет. Вы можете скачать Eric IDE по ссылке ниже:

https://eric-ide.python-projects.org/eric-download.html

Почему выбрать

• Отличный отступ, подсвечивание ошибок.
• Помощь кода
• Завершение кода
• Очистка кода с помощью PyLint
• Быстрый поиск
• Интегрированный отладчик Python.

Скриншот

Выбор текстового редактора

Возможно, вам не всегда нужна IDE. Для таких задач, как обучение кодированию с Python или Arduino, или при работе над быстрым сценарием в сценарии оболочки, который поможет вам автоматизировать некоторые задачи, подойдет простой и легкий тексто-ориентированный текстовый редактор. Также многие текстовые редакторы предлагают такие функции, как подсветка синтаксиса и выполнение скриптов в программе, аналогично IDE. Некоторые из текстовых редакторов приведены здесь —

• Атом
• Возвышенный текст
• Notepad ++

Текстовый редактор Atom

Atom — это взломанный текстовый редактор, созданный командой GitHub. Это бесплатный текстовый и кодовый редактор с открытым исходным кодом, который означает, что весь код доступен для вас, чтобы читать, изменять для собственного использования и даже вносить улучшения. Это кроссплатформенный текстовый редактор, совместимый с macOS, Linux и Microsoft Windows с поддержкой плагинов, написанных на Node.js и встроенным Git Control.

Ссылка для скачивания

https://atom.io/

Скриншот

Поддерживаемые языки

C / C ++, C #, CSS, CoffeeScript, HTML, JavaScript, Java, JSON, Julia, Objective-C, PHP, Perl, Python, Ruby on Rails, Ruby, сценарий Shell, Scala, SQL, XML, YAML и многие другие.

Возвышенный текстовый редактор

Sublime text является проприетарным программным обеспечением и предлагает вам бесплатную пробную версию, чтобы протестировать его перед покупкой. По данным stackoverflow.com , это четвертая по популярности среда разработки.

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

Скриншот

Язык поддерживается

• Python, Ruby, JavaScript и т. Д.

Почему выбрать?

• Настройте привязки клавиш, меню, фрагменты, макросы, дополнения и многое другое.

• Функция автозавершения

• Быстрая вставка текста и кода с возвышенными текстовыми фрагментами с использованием фрагментов, маркеров полей и заполнителей

• Открывается Быстро

• Кроссплатформенная поддержка Mac, Linux и Windows.

• Переместите курсор туда, куда вы хотите пойти

• Выберите несколько строк, слов и столбцов

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

Функция автозавершения

Открывается Быстро

Кроссплатформенная поддержка Mac, Linux и Windows.

Переместите курсор туда, куда вы хотите пойти

Выберите несколько строк, слов и столбцов

Блокнот ++

Это бесплатный редактор исходного кода и замена Блокнота, который поддерживает несколько языков от ассемблера до XML и включая Python. Работает в среде MS Windows, его использование регулируется лицензией GPL. В дополнение к подсветке синтаксиса, Notepad ++ имеет некоторые функции, которые особенно полезны для программистов.

Скриншот

Ключевая особенность

• Подсветка синтаксиса и свертывание синтаксиса
• PCRE (Perl-совместимое регулярное выражение) Поиск / замена
• Полностью настраиваемый графический интерфейс
• Авто завершение
• Редактирование с вкладками
• Multi-View
• Многоязычная среда
• Запускается с разными аргументами

Язык поддерживается

• Почти все языки (более 60 языков), такие как Python, C, C ++, C #, Java и т. Д.

Объектно-ориентированный Python — Структуры данных

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

Списки

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

Структура данных — список

>>>
>>> # Any Empty List
>>> empty_list = []
>>>
>>> # A list of String
>>> str_list = ['Life', 'Is', 'Beautiful']
>>> # A list of Integers
>>> int_list = [1, 4, 5, 9, 18]
>>>
>>> #Mixed items list
>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>> # To print the list
>>>
>>> print(empty_list)
[]
>>> print(str_list)
['Life', 'Is', 'Beautiful']
>>> print(type(str_list))
<class 'list'>
>>> print(int_list)
[1, 4, 5, 9, 18]
>>> print(mixed_list)
['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']

Доступ к элементам в списке Python

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

>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>>
>>> # To access the First Item of the list
>>> mixed_list[0]
'This'
>>> # To access the 4th item
>>> mixed_list[3]
18
>>> # To access the last item of the list
>>> mixed_list[-1]
'list'

Пустые объекты

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

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

>>> #Empty objects
>>>
>>> obj = object()
>>> obj.x = 9
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
obj.x = 9
AttributeError: 'object' object has no attribute 'x'

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

Поэтому Python по умолчанию отключает произвольные свойства объекта и несколько других встроенных модулей.

>>> # Empty Objects
>>>
>>> class EmpObject:
    pass
>>> obj = EmpObject()
>>> obj.x = 'Hello, World!'
>>> obj.x
'Hello, World!'

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

Кортеж

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

Кортежи используются для хранения данных, а не поведения. Если вам требуется поведение для манипулирования кортежем, вам нужно передать кортеж в функцию (или метод другого объекта), которая выполняет действие.

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

>>> stock1 = 'MSFT', 95.00, 97.45, 92.45
>>> stock2 = ('MSFT', 95.00, 97.45, 92.45)
>>> type (stock1)
<class 'tuple'>
>>> type(stock2)
<class 'tuple'>
>>> stock1 == stock2
True
>>>

Определение кортежа

Кортежи очень похожи на список, за исключением того, что весь набор элементов заключен в квадратные скобки вместо квадратных скобок.

Точно так же, как когда вы нарезаете список, вы получаете новый список, а когда вы нарезаете кортеж, вы получаете новый кортеж.

>>> tupl = ('Tuple','is', 'an','IMMUTABLE', 'list')
>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl[0]
'Tuple'
>>> tupl[-1]
'list'
>>> tupl[1:3]
('is', 'an')

Методы кортежа Python

Следующий код показывает методы в кортежах Python —

>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl.append('new')
Traceback (most recent call last):
   File "<pyshell#148>", line 1, in <module>
      tupl.append('new')
AttributeError: 'tuple' object has no attribute 'append'
>>> tupl.remove('is')
Traceback (most recent call last):
   File "<pyshell#149>", line 1, in <module>
      tupl.remove('is')
AttributeError: 'tuple' object has no attribute 'remove'
>>> tupl.index('list')
4
>>> tupl.index('new')
Traceback (most recent call last):
   File "<pyshell#151>", line 1, in <module>
      tupl.index('new')
ValueError: tuple.index(x): x not in tuple
>>> "is" in tupl
True
>>> tupl.count('is')
1

Из приведенного выше кода мы можем понять, что кортежи неизменны и, следовательно, —

• Вы не можете добавлять элементы в кортеж.

• Вы не можете добавлять или расширять метод.

• Вы не можете удалить элементы из кортежа.

• У кортежей нет метода удаления или удаления.

• Count и index — методы, доступные в кортеже.

Вы не можете добавлять элементы в кортеж.

Вы не можете добавлять или расширять метод.

Вы не можете удалить элементы из кортежа.

У кортежей нет метода удаления или удаления.

Count и index — методы, доступные в кортеже.

толковый словарь

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

Определение словарей

Обратите внимание на следующий код, чтобы понять, как определить словарь:

>>> # empty dictionary
>>> my_dict = {}
>>>
>>> # dictionary with integer keys
>>> my_dict = { 1:'msft', 2: 'IT'}
>>>
>>> # dictionary with mixed keys
>>> my_dict = {'name': 'Aarav', 1: [ 2, 4, 10]}
>>>
>>> # using built-in function dict()
>>> my_dict = dict({1:'msft', 2:'IT'})
>>>
>>> # From sequence having each item as a pair
>>> my_dict = dict([(1,'msft'), (2,'IT')])
>>>
>>> # Accessing elements of a dictionary
>>> my_dict[1]
'msft'
>>> my_dict[2]
'IT'
>>> my_dict['IT']
Traceback (most recent call last):
   File "<pyshell#177>", line 1, in <module>
   my_dict['IT']
KeyError: 'IT'
>>>

Из приведенного выше кода мы можем наблюдать, что:

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

• Число 1 — это ключ, а msft — его значение. Точно так же 2 — это ключ, а ИТ — его ценность.

• Вы можете получить значения по ключу, но не наоборот. Таким образом, когда мы пробуем my_dict [‘IT’] , это вызывает исключение, потому что IT не является ключом.

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

Число 1 — это ключ, а msft — его значение. Точно так же 2 — это ключ, а ИТ — его ценность.

Вы можете получить значения по ключу, но не наоборот. Таким образом, когда мы пробуем my_dict [‘IT’] , это вызывает исключение, потому что IT не является ключом.

Модифицирующие словари

Обратите внимание на следующий код, чтобы понять о модификации словаря —

>>> # Modifying a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'IT'}
>>> my_dict[2] = 'Software'
>>> my_dict
{1: 'msft', 2: 'Software'}
>>>
>>> my_dict[3] = 'Microsoft Technologies'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}

Из приведенного выше кода мы можем наблюдать, что —

• Вы не можете иметь дубликаты ключей в словаре. Изменение значения существующего ключа приведет к удалению старого значения.

• Вы можете добавлять новые пары ключ-значение в любое время.

• Словари не имеют понятия порядка среди элементов. Это простые неупорядоченные коллекции.

Вы не можете иметь дубликаты ключей в словаре. Изменение значения существующего ключа приведет к удалению старого значения.

Вы можете добавлять новые пары ключ-значение в любое время.

Словари не имеют понятия порядка среди элементов. Это простые неупорядоченные коллекции.

Смешивание типов данных в словаре

Обратите внимание на следующий код, чтобы понять о смешивании типов данных в словаре —

>>> # Mixing Data Types in a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}
>>> my_dict[4] = 'Operating System'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>> my_dict['Bill Gates'] = 'Owner'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}

Из приведенного выше кода мы можем наблюдать, что —

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

• В отличие от значений словаря, ключи словаря более ограничены, но могут быть любого типа, например, строки, целые числа или любые другие.

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

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

Удаление элементов из словарей

Обратите внимание на следующий код, чтобы понять, как удалить элементы из словаря.

>>> # Deleting Items from a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}
>>>
>>> del my_dict['Bill Gates']
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>>
>>> my_dict.clear()
>>> my_dict
{}

Из приведенного выше кода мы можем наблюдать, что —

• del — позволяет удалять отдельные элементы из словаря по ключу.

• очистить — удаляет все элементы из словаря.

del — позволяет удалять отдельные элементы из словаря по ключу.

очистить — удаляет все элементы из словаря.

наборы

Set () — неупорядоченная коллекция без повторяющихся элементов. Хотя отдельные элементы являются неизменяемыми, сам набор является изменяемым, то есть мы можем добавлять или удалять элементы / элементы из набора. Мы можем выполнять математические операции, такие как объединение, пересечение и т. Д. С множеством.

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

Создание набора

Набор создается путем помещения всех элементов (элементов) в фигурные скобки {} , разделенных запятой или с помощью встроенной функции set () . Соблюдайте следующие строки кода —

>>> #set of integers
>>> my_set = {1,2,4,8}
>>> print(my_set)
{8, 1, 2, 4}
>>>
>>> #set of mixed datatypes
>>> my_set = {1.0, "Hello World!", (2, 4, 6)}
>>> print(my_set)
{1.0, (2, 4, 6), 'Hello World!'}
>>>

Методы для множеств

Обратите внимание на следующий код, чтобы понять методы для множеств —

>>> >>> #METHODS FOR SETS
>>>
>>> #add(x) Method
>>> topics = {'Python', 'Java', 'C#'}
>>> topics.add('C++')
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>>
>>> #union(s) Method, returns a union of two set.
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>> team = {'Developer', 'Content Writer', 'Editor','Tester'}
>>> group = topics.union(team)
>>> group
{'Tester', 'C#', 'Python', 'Editor', 'Developer', 'C++', 'Java', 'Content
Writer'}
>>> # intersets(s) method, returns an intersection of two sets
>>> inters = topics.intersection(team)
>>> inters
set()
>>>
>>> # difference(s) Method, returns a set containing all the elements of
invoking set but not of the second set.
>>>
>>> safe = topics.difference(team)
>>> safe
{'Python', 'C++', 'Java', 'C#'}
>>>
>>> diff = topics.difference(group)
>>> diff
set()
>>> #clear() Method, Empties the whole set.
>>> group.clear()
>>> group
set()
>>>

Операторы для множеств

Обратите внимание на следующий код, чтобы понять об операторах для множеств —

>>> # PYTHON SET OPERATIONS
>>>
>>> #Creating two sets
>>> set1 = set()
>>> set2 = set()
>>>
>>> # Adding elements to set
>>> for i in range(1,5):
   set1.add(i)
>>> for j in range(4,9):
   set2.add(j)
>>> set1
{1, 2, 3, 4}
>>> set2
{4, 5, 6, 7, 8}
>>>
>>> #Union of set1 and set2
>>> set3 = set1 | set2 # same as set1.union(set2)
>>> print('Union of set1 & set2: set3 = ', set3)
Union of set1 & set2: set3 = {1, 2, 3, 4, 5, 6, 7, 8}
>>>
>>> #Intersection of set1 & set2
>>> set4 = set1 & set2 # same as set1.intersection(set2)
>>> print('Intersection of set1 and set2: set4 = ', set4)
Intersection of set1 and set2: set4 = {4}
>>>
>>> # Checking relation between set3 and set4
>>> if set3 > set4: # set3.issuperset(set4)
   print('Set3 is superset of set4')
elif set3 < set4: #set3.issubset(set4)
   print('Set3 is subset of set4')
else: #set3 == set4
   print('Set 3 is same as set4')
Set3 is superset of set4
>>>
>>> # Difference between set3 and set4
>>> set5 = set3 - set4
>>> print('Elements in set3 and not in set4: set5 = ', set5)
Elements in set3 and not in set4: set5 = {1, 2, 3, 5, 6, 7, 8}
>>>
>>> # Check if set4 and set5 are disjoint sets
>>> if set4.isdisjoint(set5):
   print('Set4 and set5 have nothing in common\n')
Set4 and set5 have nothing in common
>>> # Removing all the values of set5
>>> set5.clear()
>>> set5 set()

Объектно-ориентированный Python — Строительные блоки

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

Классовые комплекты: поведение и состояние

Класс позволит вам связать воедино поведение и состояние объекта. Обратите внимание на следующую диаграмму для лучшего понимания —

Следующие пункты заслуживают внимания при обсуждении групповых классов —

• Слово « поведение» идентично функции — это кусок кода, который что-то делает (или реализует поведение)

• Слово состояние идентично переменным — это место для хранения значений в классе.

• Когда мы утверждаем поведение и состояние класса вместе, это означает, что класс упаковывает функции и переменные.

Слово « поведение» идентично функции — это кусок кода, который что-то делает (или реализует поведение)

Слово состояние идентично переменным — это место для хранения значений в классе.

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

Классы имеют методы и атрибуты

В Python создание метода определяет поведение класса. Метод word — это имя ООП, данное функции, определенной в классе. Подводя итог —

• Функции класса — это синоним методов

• Переменные класса — это синоним атрибутов имени.

• Класс — проект для экземпляра с точным поведением.

• Объект — один из экземпляров класса, выполняющий функциональность, определенную в классе.

• Тип — указывает класс, к которому принадлежит экземпляр

• Атрибут — значение любого объекта: object.attribute

• Метод — «вызываемый атрибут», определенный в классе

Функции класса — это синоним методов

Переменные класса — это синоним атрибутов имени.

Класс — проект для экземпляра с точным поведением.

Объект — один из экземпляров класса, выполняющий функциональность, определенную в классе.

Тип — указывает класс, к которому принадлежит экземпляр

Атрибут — значение любого объекта: object.attribute

Метод — «вызываемый атрибут», определенный в классе

Обратите внимание на следующий фрагмент кода, например:

var = “Hello, John”
print( type (var)) # < type ‘str’> or <class 'str'>
print(var.upper()) # upper() method is called, HELLO, JOHN

Создание и внедрение

Следующий код показывает, как создать наш первый класс, а затем его экземпляр.

class MyClass(object):
   pass
# Create first instance of MyClass
this_obj = MyClass()
print(this_obj)
# Another instance of MyClass
that_obj = MyClass()
print (that_obj)

Здесь мы создали класс MyClass, который не выполняет никаких задач. Объект аргумента в классе MyClass включает наследование класса и будет обсуждаться в следующих главах. pass в приведенном выше коде указывает, что этот блок пуст, то есть это определение пустого класса.

Давайте создадим экземпляр this_obj класса MyClass () и распечатаем его, как показано на рисунке —

<__main__.MyClass object at 0x03B08E10>
<__main__.MyClass object at 0x0369D390>

Здесь мы создали экземпляр MyClass. Шестнадцатеричный код относится к адресу, где хранится объект. Другой экземпляр указывает на другой адрес.

Теперь давайте определим одну переменную внутри класса MyClass () и получим переменную из экземпляра этого класса, как показано в следующем коде —

class MyClass(object):
   var = 9

# Create first instance of MyClass
this_obj = MyClass()
print(this_obj.var)

# Another instance of MyClass

that_obj = MyClass()
print (that_obj.var)

Выход

Вы можете наблюдать следующий вывод при выполнении кода, приведенного выше —

9
9

Как экземпляр знает, из какого класса он создан, так что при запросе атрибута из экземпляра экземпляр ищет атрибут и класс. Это называется поиском атрибутов.

Методы экземпляра

Функция, определенная в классе, называется методом. Метод экземпляра требует экземпляр для его вызова и не требует декоратора. При создании метода экземпляра первым параметром всегда является self. Хотя мы можем назвать его (self) любым другим именем, рекомендуется использовать self, так как это соглашение об именах.

class MyClass(object):
   var = 9
   def firstM(self):
      print("hello, World")
obj = MyClass()
print(obj.var)
obj.firstM()

Выход

Вы можете наблюдать следующий вывод при выполнении кода, приведенного выше —

9
hello, World

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

class MyClass(object):
   def firstM(self):
      print("hello, World")
      print(self)
obj = MyClass()
obj.firstM()
print(obj)

Выход

Вы можете наблюдать следующий вывод при выполнении кода, приведенного выше —

hello, World
<__main__.MyClass object at 0x036A8E10>
<__main__.MyClass object at 0x036A8E10>

Инкапсуляция

Инкапсуляция является одной из основ ООП. ООП позволяет нам скрыть сложность внутренней работы объекта, которая выгодна разработчику, следующими способами:

• Упрощает и облегчает понимание использования объекта, не зная внутренних органов.

• Любое изменение может быть легко управляемым.

Упрощает и облегчает понимание использования объекта, не зная внутренних органов.

Любое изменение может быть легко управляемым.

Объектно-ориентированное программирование сильно зависит от инкапсуляции. Термины инкапсуляция и абстракция (также называемые сокрытием данных) часто используются как синонимы. Они почти синонимичны, поскольку абстракция достигается за счет инкапсуляции.

Инкапсуляция предоставляет нам механизм ограничения доступа к некоторым компонентам объекта, это означает, что внутреннее представление объекта нельзя увидеть снаружи определения объекта. Доступ к этим данным, как правило, осуществляется с помощью специальных методов — геттеров и сеттеров.

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

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age

zack = MyClass()
zack.setAge(45)
print(zack.getAge())

zack.setAge("Fourty Five")
print(zack.getAge())

Выход

Вы можете наблюдать следующий вывод при выполнении кода, приведенного выше —

45
Fourty Five

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

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age

zack = MyClass()
zack.setAge(45)
print(zack.getAge())
zack.setAge("Fourty Five")
print(zack.getAge())

Ини Конструктор

Метод __ init __ вызывается неявно, как только создается экземпляр объекта класса. Это инициализирует объект.

x = MyClass()

Строка кода, показанная выше, создаст новый экземпляр и назначит этот объект локальной переменной x.

Операция создания экземпляра, которая вызывает объект класса , создает пустой объект. Многие классы любят создавать объекты с экземплярами, настроенными на конкретное начальное состояние. Следовательно, класс может определять специальный метод с именем __init __ (), как показано ниже.

def __init__(self):
   self.data = []

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

x = MyClass()

Метод __init __ () может иметь один или несколько аргументов для большей гибкости. Init обозначает инициализацию, поскольку инициализирует атрибуты экземпляра. Это называется конструктором класса.

class myclass(object):
   def __init__(self,aaa, bbb):
      self.a = aaa
      self.b = bbb

x = myclass(4.5, 3)
print(x.a, x.b)

Выход

4.5 3

Атрибуты класса

Атрибут, определенный в классе, называется «атрибуты класса», а атрибуты, определенные в функции, называются «атрибуты экземпляра». При определении эти атрибуты не имеют префикса self, так как они являются свойством класса, а не конкретного экземпляра.

Атрибуты класса могут быть доступны как самому классу (className.attributeName), так и экземплярам класса (inst.attributeName). Таким образом, экземпляры имеют доступ как к атрибуту экземпляра, так и к атрибутам класса.

>>> class myclass():
   age = 21
>>> myclass.age
21
>>> x = myclass()
>>> x.age
21
>>>

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

В Python есть путь поиска атрибутов. Сначала это метод, определенный в классе, а затем класс над ним.

>>> class myclass(object):
   classy = 'class value'
>>> dd = myclass()
>>> print (dd.classy) # This should return the string 'class value'
class value
>>>
>>> dd.classy = "Instance Value"
>>> print(dd.classy) # Return the string "Instance Value"
Instance Value
>>>
>>> # This will delete the value set for 'dd.classy' in the instance.
>>> del dd.classy
>>> >>> # Since the overriding attribute was deleted, this will print 'class
value'.

>>> print(dd.classy)
class value
>>>

Мы переопределяем классовый атрибут класса в экземпляре dd. Когда он переопределен, интерпретатор Python считывает переопределенное значение. Но как только новое значение удалено с помощью ‘del’, переопределенное значение больше не присутствует в экземпляре, и, следовательно, поиск поднимается на уровень выше и получает его из класса.

Работа с данными класса и экземпляра

В этом разделе давайте разберемся, как данные класса относятся к данным экземпляра. Мы можем хранить данные либо в классе, либо в экземпляре. Когда мы проектируем класс, мы решаем, какие данные принадлежат экземпляру и какие данные должны храниться в общем классе.

Экземпляр может получить доступ к данным класса. Если мы создадим несколько экземпляров, то эти экземпляры могут получить доступ к своим индивидуальным значениям атрибута, а также ко всем данным класса.

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

class InstanceCounter(object):
   count = 0 # class attribute, will be accessible to all instances
   def __init__(self, val):
      self.val = val
      InstanceCounter.count +=1 # Increment the value of class attribute, accessible through class name
# In above line, class ('InstanceCounter') act as an object
   def set_val(self, newval):
      self.val = newval

   def get_val(self):
      return self.val

   def get_count(self):
      return InstanceCounter.count
a = InstanceCounter(9)
b = InstanceCounter(18)
c = InstanceCounter(27)

for obj in (a, b, c):
   print ('val of obj: %s' %(obj.get_val())) # Initialized value ( 9, 18, 27)
   print ('count: %s' %(obj.get_count())) # always 3

Выход

val of obj: 9
count: 3
val of obj: 18
count: 3
val of obj: 27
count: 3

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

class myClass:
   class_attribute = 99

   def class_method(self):
      self.instance_attribute = 'I am instance attribute'

print (myClass.__dict__)

Выход

Вы можете наблюдать следующий вывод при выполнении кода, приведенного выше —

{'__module__': '__main__', 'class_attribute': 99, 'class_method': <function myClass.class_method at 0x04128D68>, '__dict__': <attribute '__dict__' of 'myClass' objects>, '__weakref__': <attribute '__weakref__' of 'myClass' objects>, '__doc__': None}

Атрибут экземпляра myClass .__ dict__ как показано —

>>> a = myClass()
>>> a.class_method()
>>> print(a.__dict__)
{'instance_attribute': 'I am instance attribute'}

Объектно-ориентированные ярлыки

В этой главе подробно рассказывается о различных встроенных функциях в Python, операциях файлового ввода-вывода и концепциях перегрузки.

Встроенные функции Python

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

ВСТРОЕННЫЕ ФУНКЦИИ
абс ()	DICT ()	Помогите()	мин ()	SetAttr ()
все()	DIR ()	гекс ()	следующий()	ломтик()
любой()	divmod ()	Я бы()	Объект ()	отсортировано ()
ASCII ()	перечислить ()	вход ()	Октябрь ()	STATICMETHOD ()
бен ()	Eval ()	Int ()	открыть()	ул ()
BOOL ()	Exec ()	isinstance ()	Ord ()	сумма ()
ByteArray ()	фильтр()	issubclass ()	POW ()	супер()
байт ()	плавать ()	ITER ()	Распечатать()	кортеж ()
вызываемый ()	формат()	LEN ()	имущество()	тип()
CHR ()	frozenset ()	список()	спектр()	вары ()
classmethod ()	GetAttr ()	местные ()	магнезии ()	застежка-молния ()
компиляции ()	глобалы ()	карта()	негативы ()	__Импортировать__()
сложный()	hasattr ()	Максимум()	круглый()
delattr ()	хэш ()	memoryview ()	задавать()

В этом разделе кратко обсуждаются некоторые важные функции —

функция len ()

Функция len () получает длину строк, списка или коллекций. Возвращает длину или количество элементов объекта, где объект может быть строкой, списком или коллекцией.

>>> len(['hello', 9 , 45.0, 24])
4

Функция len () внутренне работает как list .__ len __ () или кортеж .__ len __ () . Таким образом, обратите внимание, что len () работает только с объектами, которые имеют метод __len __ () .

>>> set1
{1, 2, 3, 4}
>>> set1.__len__()
4

Однако на практике мы предпочитаем len () вместо функции __len __ () по следующим причинам:

• Это более эффективно. И не обязательно, чтобы конкретный метод был написан для отказа в доступе к специальным методам, таким как __len__.

• Это легко поддерживать.

• Поддерживает обратную совместимость.

Это более эффективно. И не обязательно, чтобы конкретный метод был написан для отказа в доступе к специальным методам, таким как __len__.

Это легко поддерживать.

Поддерживает обратную совместимость.

Перевернутый (сло)

Возвращает обратный итератор. seq должен быть объектом, который имеет метод __reversed __ () или поддерживает протокол последовательности (метод __len __ () и метод __getitem __ ()). Обычно он используется для циклов for, когда мы хотим перебирать элементы сзади и вперед.

>>> normal_list = [2, 4, 5, 7, 9]
>>>
>>> class CustomSequence():
   def __len__(self):
      return 5
   def __getitem__(self,index):
      return "x{0}".format(index)
>>> class funkyback():
   def __reversed__(self):
      return 'backwards!'
>>> for seq in normal_list, CustomSequence(), funkyback():
      print('\n{}: '.format(seq.__class__.__name__), end="")
      for item in reversed(seq):
         print(item, end=", ")

Цикл for в конце печатает перевернутый список обычного списка и экземпляры двух пользовательских последовательностей. Вывод показывает, что reversed () работает на всех трех из них, но имеет совершенно разные результаты, когда мы определяем __reversed__ .

Выход

Вы можете наблюдать следующий вывод при выполнении кода, приведенного выше —

list: 9, 7, 5, 4, 2,
CustomSequence: x4, x3, x2, x1, x0,
funkyback: b, a, c, k, w, a, r, d, s, !,

перечислять

Метод enumerate () добавляет счетчик к итерируемому и возвращает объект перечисления.

Синтаксис enumerate () — это

enumerate(iterable, start = 0)

Здесь второй аргумент start является необязательным, и по умолчанию индекс начинается с нуля (0).

>>> # Enumerate
>>> names = ['Rajesh', 'Rahul', 'Aarav', 'Sahil', 'Trevor']
>>> enumerate(names)
<enumerate object at 0x031D9F80>
>>> list(enumerate(names))
[(0, 'Rajesh'), (1, 'Rahul'), (2, 'Aarav'), (3, 'Sahil'), (4, 'Trevor')]
>>>

Таким образом, enumerate () возвращает итератор, который выдает кортеж, который хранит количество элементов в переданной последовательности. Поскольку возвращаемое значение является итератором, прямой доступ к нему не очень полезен. Лучшим подходом для enumerate () является учет в цикле for.

>>> for i, n in enumerate(names):
   print('Names number: ' + str(i))
   print(n)
Names number: 0
Rajesh
Names number: 1
Rahul
Names number: 2
Aarav
Names number: 3
Sahil
Names number: 4
Trevor

В стандартной библиотеке много других функций, и вот еще один список некоторых более широко используемых функций:

• hasattr, getattr, setattr и delattr, которые позволяют атрибутам объекта манипулировать их строковыми именами.

• all и any, которые принимают итерируемый объект и возвращают True, если все или любые из элементов оцениваются как true.

• nzip, который принимает две или более последовательностей и возвращает новую последовательность кортежей, где каждый кортеж содержит одно значение из каждой последовательности.

hasattr, getattr, setattr и delattr, которые позволяют атрибутам объекта манипулировать их строковыми именами.

all и any, которые принимают итерируемый объект и возвращают True, если все или любые из элементов оцениваются как true.

nzip, который принимает две или более последовательностей и возвращает новую последовательность кортежей, где каждый кортеж содержит одно значение из каждой последовательности.

Файловый ввод / вывод

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

Встроенная функция open () используется для открытия файла и возврата объекта файла. Это наиболее часто используемая функция с двумя аргументами:

open(filename, mode)

Функция open () вызывает два аргумента, первый — имя файла, а второй — режим. Здесь режим может быть «r» для режима «только чтение», «w» только для записи (существующий файл с тем же именем будет удален), а «a» открывает файл для добавления, любые данные, записанные в файл, добавляются автоматически к концу. «r +» открывает файл для чтения и записи. Режим по умолчанию только для чтения.

В Windows добавленный в режим «b» открывает файл в двоичном режиме, поэтому существуют также режимы, такие как «rb», «wb» и «r + b».

>>> text = 'This is the first line'
>>> file = open('datawork','w')
>>> file.write(text)
22
>>> file.close()

В некоторых случаях мы просто хотим добавить к существующему файлу, а не перезаписать его, для этого мы можем предоставить значение «a» в качестве аргумента режима, чтобы добавить в конец файла, а не полностью перезаписывать существующий файл содержание.

>>> f = open('datawork','a')
>>> text1 = ' This is second line'
>>> f.write(text1)
20
>>> f.close()

Когда файл открыт для чтения, мы можем вызвать метод read, readline или readlines, чтобы получить содержимое файла. Метод read возвращает все содержимое файла в виде объекта str или bytes, в зависимости от того, является ли второй аргумент ‘b’.

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

>>> f = open('fileone','r+')
>>> f.readline()
'This is the first line. \n'
>>> f.readline()
'This is the second line. \n'

Запись в файл с помощью метода write для файловых объектов записывает в файл объект строки (байты для двоичных данных). Метод writelines принимает последовательность строк и записывает каждое из повторяющихся значений в файл. Метод writelines не добавляет новую строку после каждого элемента в последовательности.

Наконец, метод close () должен быть вызван, когда мы закончим чтение или запись файла, чтобы гарантировать, что все буферизованные записи будут записаны на диск, что файл был должным образом очищен и все ресурсы, связанные с файлом, возвращены обратно. операционная система. Это лучший подход для вызова метода close (), но технически это произойдет автоматически, когда скрипт существует.

Альтернатива перегрузке метода

Перегрузка метода означает наличие нескольких методов с одинаковым именем, которые принимают разные наборы аргументов.

Учитывая один метод или функцию, мы можем сами указать количество параметров. В зависимости от определения функции ее можно вызвать с нулем, одним, двумя или более параметрами.

class Human:
   def sayHello(self, name = None):
      if name is not None:
         print('Hello ' + name)
      else:
         print('Hello ')

#Create Instance
obj = Human()

#Call the method, else part will be executed
obj.sayHello()

#Call the method with a parameter, if part will be executed
obj.sayHello('Rahul')

Выход

Hello
Hello Rahul

Аргументы по умолчанию

Функции тоже объекты

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

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

def my_func():
   print('My function was called')
my_func.description = 'A silly function'
def second_func():

   print('Second function was called')

   second_func.description = 'One more sillier function'

def another_func(func):
   print("The description:", end=" ")
   print(func.description)
   print('The name: ', end=' ')
   print(func.__name__)
   print('The class:', end=' ')
   print(func.__class__)
   print("Now I'll call the function passed in")
   func()

another_func(my_func)
another_func(second_func)

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

The description: A silly function
The name: my_func
The class: 
Now I'll call the function passed in
My function was called
The description: One more sillier function
The name: second_func
The class: 
Now I'll call the function passed in
Second function was called

вызываемые объекты

Так же, как функции — это объекты, для которых могут быть установлены атрибуты, можно создать объект, который можно вызывать так, как если бы он был функцией.

В Python любой объект с методом __call __ () может быть вызван с использованием синтаксиса вызова функции.

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

Наследование и полиморфизм — это очень важная концепция в Python. Вы должны понимать это лучше, если вы хотите учиться.

наследование

Одним из основных преимуществ объектно-ориентированного программирования является повторное использование. Наследование является одним из механизмов достижения того же. Наследование позволяет программисту сначала создать общий или базовый класс, а затем расширить его до более специализированного класса. Это позволяет программисту писать лучший код.

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

В объектно-ориентированной терминологии, когда класс X расширяет класс Y, Y называется супер / родительским / базовым классом, а X называется подклассом / дочерним / производным классом. Здесь следует отметить, что дочерние классы доступны только тем полям данных и методам, которые не являются частными. Частные поля данных и методы доступны только внутри класса.

Синтаксис для создания производного класса —

class BaseClass:
   Body of base class
class DerivedClass(BaseClass):
   Body of derived class

Наследование атрибутов

Теперь посмотрим на приведенный ниже пример —

Выход

Сначала мы создали класс с именем Date и передали объект в качестве аргумента, здесь object-это встроенный класс, предоставляемый Python. Позже мы создали еще один класс с именем time и в качестве аргумента назвали класс Date. Посредством этого вызова мы получаем доступ ко всем данным и атрибутам класса Date в класс Time. Из-за этого, когда мы пытаемся получить метод get_date из объекта класса Time, который мы создали ранее, возможно.

Object.Attribute Lookup Hierarchy

• Экземпляр
• Класс
• Любой класс, от которого этот класс наследует

Примеры наследования

Давайте вкратце рассмотрим пример наследования —

Давайте создадим пару классов для участия в примерах —

• Животное — Класс имитации животного
• Кошка — подкласс животного
• Собака — Подкласс Животного

В Python конструктор класса используется для создания объекта (экземпляра) и присвоения значения атрибутам.

Конструктор подклассов всегда вызывается к конструктору родительского класса, чтобы инициализировать значение для атрибутов в родительском классе, затем он начинает присваивать значение своим атрибутам.

Выход

В приведенном выше примере мы видим атрибуты команды или методы, которые мы помещаем в родительский класс, чтобы все подклассы или дочерние классы наследовали это свойство от родительского класса.

Если подкласс попытается унаследовать методы или данные от другого подкласса, то это произойдет из-за ошибки, как мы видим, когда класс Dog пытается вызвать методы swatstring () из этого класса cat, он выдает ошибку (например, AttributeError в нашем случае).

Полиморфизм («МНОГО ФОРМ»)

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

Это позволяет функциям использовать объекты любого из этих полиморфных классов без необходимости знать различия между классами.

Полиморфизм может быть осуществлен посредством наследования, при этом подклассы используют методы базового класса или переопределяют их.

Давайте разберемся с концепцией полиморфизма в нашем предыдущем примере наследования и добавим один общий метод show_affection в обоих подклассах:

Из примера, который мы видим, это относится к дизайну, в котором объект разнородного типа может обрабатываться одинаковым образом или, более конкретно, два или более классов с методом с тем же именем или общим интерфейсом, потому что тот же метод (show_affection в примере ниже) вызывается с любым типом объектов.

Выход

Итак, все животные проявляют привязанность (show_affection), но они делают это по-разному. Таким образом, поведение «show_affection» является полиморфным в том смысле, что оно действует по-разному в зависимости от животного. Таким образом, абстрактное понятие «животное» на самом деле не «show_affection», но конкретные животные (например, собаки и кошки) имеют конкретную реализацию действия «show_affection».

У самого Python есть классы, которые являются полиморфными. Например, функция len () может использоваться с несколькими объектами, и все они возвращают правильный вывод на основе входного параметра.

Переопределение

В Python, когда подкласс содержит метод, который переопределяет метод суперкласса, вы также можете вызвать метод суперкласса, вызвав

Супер (подкласс, сам) .метод вместо self.method.

пример

class Thought(object):
   def __init__(self):
      pass
   def message(self):
      print("Thought, always come and go")

class Advice(Thought):
   def __init__(self):
      super(Advice, self).__init__()
   def message(self):
      print('Warning: Risk is always involved when you are dealing with market!')

Наследование конструктора

Если мы видим из нашего предыдущего примера наследования, __init__ был расположен в родительском классе в верхнем, потому что у дочернего класса собака или кошка не было метода __init__ в нем. Python использовал поиск атрибутов наследования, чтобы найти __init__ в классе животных. Когда мы создали дочерний класс, сначала он будет искать метод __init__ в классе dog, затем он не найдет его, затем заглянет в родительский класс Animal, найдет там и вызовет его там. Так как дизайн нашего класса стал сложным, мы можем захотеть инициализировать экземпляр, сначала обработав его через конструктор родительского класса, а затем через конструктор дочернего класса.

Выход

В приведенном выше примере — все животные имеют имя и все собаки определенной породы. Мы вызвали конструктор родительского класса с помощью super. Так что у собаки есть свой собственный __init__, но первое, что происходит, мы называем супер. Super является встроенной функцией и предназначен для связи класса с его суперклассом или его родительским классом.

В этом случае мы говорим, что получаем суперкласс dog и передаем экземпляр dog любому методу, который мы здесь называем конструктором __init__. Другими словами, мы вызываем родительский класс Animal __init__ с объектом dog. Вы можете спросить, почему мы не просто скажем Animal __init__ с экземпляром собаки, мы могли бы сделать это, но если бы название класса животных изменилось, когда-нибудь в будущем. Что если мы хотим перестроить иерархию классов, чтобы собака унаследовала от другого класса. Использование супер в этом случае позволяет нам сохранять модульность, легко изменять и поддерживать.

Таким образом, в этом примере мы можем объединить общие функции __init__ с более конкретными функциями. Это дает нам возможность отделить общие функциональные возможности от определенных функциональных возможностей, которые могут устранить дублирование кода и связать классы друг с другом таким образом, который отражает общий дизайн системы.

Заключение

• __init__ похож на любой другой метод; это может быть унаследовано

• Если класс не имеет конструктора __init__, Python проверит свой родительский класс, чтобы узнать, сможет ли он его найти.

• Как только он находит, Python вызывает его и перестает искать

• Мы можем использовать функцию super () для вызова методов в родительском классе.

• Мы можем захотеть инициализировать как в родительском, так и в нашем собственном классе.

__init__ похож на любой другой метод; это может быть унаследовано

Если класс не имеет конструктора __init__, Python проверит свой родительский класс, чтобы узнать, сможет ли он его найти.

Как только он находит, Python вызывает его и перестает искать

Мы можем использовать функцию super () для вызова методов в родительском классе.

Мы можем захотеть инициализировать как в родительском, так и в нашем собственном классе.

Множественное наследование и дерево поиска

Как видно из названия, множественное наследование — это когда Python наследует несколько классов.

Например, ребенок наследует черты личности от обоих родителей (матери и отца).

Синтаксис множественного наследования Python

Чтобы класс наследовал от нескольких родительских классов, мы записываем имена этих классов в круглых скобках в производный класс при его определении. Мы разделяем эти имена запятыми.

Ниже приведен пример этого —

>>> class Mother:
   pass

>>> class Father:
   pass

>>> class Child(Mother, Father):
   pass

>>> issubclass(Child, Mother) and issubclass(Child, Father)
True

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

Вот почему на приведенной ниже диаграмме Python сначала ищет метод dothis () в классе A. Таким образом, порядок разрешения метода в приведенном ниже примере будет

Mro- D → B → A → C

Посмотрите на диаграмму множественного наследования ниже —

Давайте рассмотрим пример, чтобы понять функцию «mro» в Python.

Выход

Пример 3

Давайте рассмотрим еще один пример множественного наследования в форме ромба.

Приведенная выше схема будет считаться неоднозначной. Из нашего предыдущего примера мы понимаем «порядок разрешения методов». То есть M → D → B → A → C → A, но это не так. Получив второй A от C, Python проигнорирует предыдущий A., поэтому в этом случае mro будет D → B → C → A.

Давайте создадим пример на основе приведенной выше диаграммы —

Выход

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

В заключение —

• Любой класс может наследовать от нескольких классов

• Python обычно использует порядок «в глубину» при поиске наследующих классов.

• Но когда два класса наследуют от одного и того же класса, Python исключает первые появления этого класса из mro.

Любой класс может наследовать от нескольких классов

Python обычно использует порядок «в глубину» при поиске наследующих классов.

Но когда два класса наследуют от одного и того же класса, Python исключает первые появления этого класса из mro.

Декораторы, статические и классовые методы

Функции (или методы) создаются оператором def.

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

Мы можем классифицировать методы на основе их поведения, например,

• Простой метод — определяется вне класса. Эта функция может получить доступ к атрибутам класса путем подачи аргумента экземпляра:

Простой метод — определяется вне класса. Эта функция может получить доступ к атрибутам класса путем подачи аргумента экземпляра:

def outside_func(():

• Метод экземпляра —

Метод экземпляра —

def func(self,)

• Метод класса — если нам нужно использовать атрибуты класса

Метод класса — если нам нужно использовать атрибуты класса

   @classmethod
def cfunc(cls,)

• Статический метод — не иметь никакой информации о классе

Статический метод — не иметь никакой информации о классе

      @staticmethod
def sfoo()

До сих пор мы видели метод экземпляра, сейчас самое время разобраться в двух других методах,

Метод класса

Декоратор @classmethod — это встроенный декоратор функций, передающий класс, к которому он был вызван, или класс экземпляра, к которому он был вызван, в качестве первого аргумента. Результат этой оценки затеняет определение вашей функции.

синтаксис

class C(object):
   @classmethod
   def fun(cls, arg1, arg2, ...):
      ....
fun: function that needs to be converted into a class method
returns: a class method for function

У них есть доступ к этому аргументу cls, он не может изменять состояние экземпляра объекта. Это потребует доступа к себе.

• Он связан с классом, а не с объектом класса.

• Методы класса могут по-прежнему изменять состояние класса, которое применяется ко всем экземплярам класса.

Он связан с классом, а не с объектом класса.

Методы класса могут по-прежнему изменять состояние класса, которое применяется ко всем экземплярам класса.

Статический метод

Статический метод не принимает ни параметр self, ни параметр cls (class), но он может принять произвольное количество других параметров.

синтаксис

class C(object):
   @staticmethod
   def fun(arg1, arg2, ...):
   ...
returns: a static method for function funself.

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

Когда использовать что

• Обычно мы используем метод класса для создания фабричных методов. Методы фабрики возвращают объект класса (аналог конструктора) для разных вариантов использования.

• Обычно мы используем статические методы для создания служебных функций.

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

Обычно мы используем статические методы для создания служебных функций.

Python Design Pattern

обзор

Современная разработка программного обеспечения должна соответствовать сложным бизнес-требованиям. Также необходимо учитывать такие факторы, как расширяемость и ремонтопригодность в будущем. Хороший дизайн программной системы жизненно необходим для достижения этих целей. Шаблоны проектирования играют важную роль в таких системах.

Чтобы понять шаблон дизайна, давайте рассмотрим пример ниже —

• Дизайн каждого автомобиля соответствует базовому шаблону дизайна, четырем колесам, рулевому колесу, основной системе привода, такой как сцепление-акселератор и т. Д.

Дизайн каждого автомобиля соответствует базовому шаблону дизайна, четырем колесам, рулевому колесу, основной системе привода, такой как сцепление-акселератор и т. Д.

Таким образом, все вещи, которые многократно строятся / производятся, неизбежно должны следовать схеме в своем дизайне … это автомобили, велосипед, пицца, банкоматы, все, что угодно … даже ваш диван-кровать.

Проекты, которые почти стали стандартным способом кодирования некоторой логики / механизма / техники в программном обеспечении, следовательно, стали известны как или изучены как Шаблоны проектирования программного обеспечения.

Почему шаблон дизайна важен?

Преимущества использования шаблонов проектирования —

• Помогает вам решать общие проблемы проектирования с помощью проверенного подхода.

• Нет двусмысленности в понимании, так как они хорошо документированы.

• Сократите общее время разработки.

• Помогает вам иметь дело с будущими расширениями и модификациями с большей легкостью, чем в противном случае.

• Может уменьшить количество ошибок в системе, поскольку они являются проверенными решениями распространенных проблем.

Помогает вам решать общие проблемы проектирования с помощью проверенного подхода.

Нет двусмысленности в понимании, так как они хорошо документированы.

Сократите общее время разработки.

Помогает вам иметь дело с будущими расширениями и модификациями с большей легкостью, чем в противном случае.

Может уменьшить количество ошибок в системе, поскольку они являются проверенными решениями распространенных проблем.

Классификация шаблонов проектирования

Шаблоны дизайна GoF (Gang of Four) подразделяются на три категории: креативные, структурные и поведенческие.

Образцы творчества

Шаблоны проектирования творчества отделяют логику создания объекта от остальной системы. Вместо того, чтобы создавать объекты, творческие шаблоны создают их для вас. Шаблоны для творчества включают Абстрактную фабрику, Строитель, Фабричный метод, Прототип и Синглтон

Шаблоны для творчества обычно не используются в Python из-за динамической природы языка. Кроме того, сам язык предоставляет нам всю гибкость, необходимую для создания достаточно элегантного способа, нам редко требуется реализовывать что-либо сверху, например, singleton или Factory.

Кроме того, эти шаблоны обеспечивают способ создания объектов, скрывая логику создания, вместо создания экземпляров объектов непосредственно с помощью оператора new.

Структурные паттерны

Иногда вместо того, чтобы начинать с нуля, вам нужно создавать более крупные структуры с использованием существующего набора классов. Вот где шаблоны структурных классов используют наследование для создания новой структуры. Структурные шаблоны объектов используют композицию / агрегацию для получения новой функциональности. Адаптер, Мост, Композит, Декоратор, Фасад, Лёгкий вес и Прокси — это Структурные паттерны. Они предлагают лучшие способы организации иерархии классов.

Поведенческие образцы

Поведенческие модели предлагают лучшие способы обработки коммуникации между объектами. Шаблоны подпадают под следующие категории: посетитель, цепь ответственности, команда, интерпретатор, итератор, посредник, мементо, наблюдатель, состояние, стратегия и метод шаблона — это поведенческие шаблоны.

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

Обычно используемые шаблоны проектирования

одиночка

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

Шаблон Singleton используется для,

• При ведении журнала необходимо реализовать. Экземпляр регистратора является общим для всех компонентов системы.

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

• Управление подключением к базе данных.

При ведении журнала необходимо реализовать. Экземпляр регистратора является общим для всех компонентов системы.

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

Управление подключением к базе данных.

Вот диаграмма UML,

class Logger(object):
   def __new__(cls, *args, **kwargs):
      if not hasattr(cls, '_logger'):
      cls._logger = super(Logger, cls).__new__(cls, *args, **kwargs)
return cls._logger

В этом примере Logger является Singleton.

Когда вызывается __new__, он обычно создает новый экземпляр этого класса. Когда мы переопределяем его, мы сначала проверяем, был ли создан наш экземпляр синглтона или нет. Если нет, мы создаем его с помощью супер-вызова. Таким образом, всякий раз, когда мы вызываем конструктор в Logger, мы всегда получаем один и тот же экземпляр.

>>>
>>> obj1 = Logger()
>>> obj2 = Logger()
>>> obj1 == obj2
True
>>>
>>> obj1
<__main__.Logger object at 0x03224090>
>>> obj2
<__main__.Logger object at 0x03224090>

Объектно-ориентированный Python — Расширенные возможности

В этом мы рассмотрим некоторые из расширенных функций, которые предоставляет Python

Основной синтаксис в нашем дизайне класса

В этом мы рассмотрим, как Python позволяет нам использовать преимущества операторов в наших классах. Python — это, в основном, объекты и вызовы методов для объектов, и это происходит даже тогда, когда он скрыт некоторым удобным синтаксисом.

>>> var1 = 'Hello'
>>> var2 = ' World!'
>>> var1 + var2
'Hello World!'
>>>
>>> var1.__add__(var2)
'Hello World!'
>>> num1 = 45
>>> num2 = 60
>>> num1.__add__(num2)
105
>>> var3 = ['a', 'b']
>>> var4 = ['hello', ' John']
>>> var3.__add__(var4)
['a', 'b', 'hello', ' John']

Так что, если нам нужно добавить магический метод __add__ к нашим собственным классам, мы могли бы сделать это тоже. Давайте попробуем сделать это.

У нас есть класс Sumlist, у которого есть конструктор __init__, который принимает список в качестве аргумента my_list.

class SumList(object):
   def __init__(self, my_list):
      self.mylist = my_list
   def __add__(self, other):
     new_list = [ x + y for x, y in zip(self.mylist, other.mylist)]

     return SumList(new_list)
   
   def __repr__(self):
      return str(self.mylist)

aa = SumList([3,6, 9, 12, 15])

bb = SumList([100, 200, 300, 400, 500])
cc = aa + bb # aa.__add__(bb)
print(cc) # should gives us a list ([103, 206, 309, 412, 515])

Выход

[103, 206, 309, 412, 515]

Но есть много методов, которые внутренне управляются другими магическими методами. Ниже приведены некоторые из них,

'abc' in var # var.__contains__('abc')
var == 'abc' # var.__eq__('abc')
var[1] # var.__getitem__(1)
var[1:3] # var.__getslice__(1, 3)
len(var) # var.__len__()
print(var) # var.__repr__()

Наследование от встроенных типов

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

В следующем примере мы наследуем от словаря, но затем мы реализуем один из его методов __setitem__. Это (setitem) вызывается, когда мы устанавливаем ключ и значение в словаре. Поскольку это магический метод, он будет вызываться неявно.

class MyDict(dict):

   def __setitem__(self, key, val):
      print('setting a key and value!')
      dict.__setitem__(self, key, val)

dd = MyDict()
dd['a'] = 10
dd['b'] = 20

for key in dd.keys():
   print('{0} = {1}'.format(key, dd[key]))

Выход

setting a key and value!
setting a key and value!
a = 10
b = 20

Давайте расширим наш предыдущий пример. Ниже мы назвали два магических метода __getitem__ и __setitem__, которые лучше вызывать, когда мы имеем дело с индексом списка.

# Mylist inherits from 'list' object but indexes from 1 instead for 0!
class Mylist(list): # inherits from list
   def __getitem__(self, index):
      if index == 0:
         raise IndexError
      if index > 0:
         index = index - 1
         return list.__getitem__(self, index) # this method is called when

# we access a value with subscript like x[1]
   def __setitem__(self, index, value):
      if index == 0:
         raise IndexError
      if index > 0:
      index = index - 1
      list.__setitem__(self, index, value)

x = Mylist(['a', 'b', 'c']) # __init__() inherited from builtin list

print(x) # __repr__() inherited from builtin list

x.append('HELLO'); # append() inherited from builtin list

print(x[1]) # 'a' (Mylist.__getitem__ cutomizes list superclass
               # method. index is 1, but reflects 0!

print (x[4]) # 'HELLO' (index is 4 but reflects 3!

Выход

['a', 'b', 'c']
a
HELLO

В приведенном выше примере мы устанавливаем список из трех элементов в Mylist и неявно вызывается метод __init__, а когда мы печатаем элемент x, мы получаем список из трех элементов ([‘a’, ‘b’, ‘c’]). Затем мы добавляем еще один элемент в этот список. Позже мы запрашиваем индекс 1 и индекс 4. Но если вы видите выходные данные, мы получаем элемент из (index-1) того, что мы просили. Как мы знаем, индексация списка начинается с 0, но здесь индексация начинается с 1 (поэтому мы получаем первый элемент списка).

Соглашения об именах

В этом мы рассмотрим имена, которые мы будем использовать для переменных, особенно частных переменных, и соглашений, используемых программистами Python по всему миру. Хотя переменные обозначены как приватные, но в Python нет конфиденциальности, и это сделано специально. Как и любые другие хорошо документированные языки, Python имеет соглашения об именах и стилях, которые он продвигает, хотя и не применяет их. Существует руководство по стилю, написанное « Гвидо ван Россумом», создателем Python, которое описывает лучшие практики и использование имени и называется PEP8. Вот ссылка для этого, https://www.python.org/dev/peps/pep-0008/

PEP расшифровывается как предложение по улучшению Python и представляет собой серию документации, которая распространяется сообществом Python для обсуждения предлагаемых изменений. Например, рекомендуется все,

• Имена модулей — all_lower_case
• Имена классов и имена исключений — CamelCase
• Глобальные и локальные имена — all_lower_case
• Функции и имена методов — all_lower_case
• Константы — ALL_UPPER_CASE

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

Зачем соответствовать конвенции?

Мы можем следовать рекомендации PEP, которую мы можем получить,

• Более знакомы подавляющему большинству разработчиков
• Понятнее для большинства читателей вашего кода.
• Будет соответствовать стилю других участников, которые работают на той же кодовой базе.
• Знак профессионального разработчика программного обеспечения
• Все вас примут.

Именование переменных — «Public» и «Private»

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

• Открытые атрибуты или переменные (предназначенные для использования импортером этого модуля или пользователем этого класса) — normal_lower_case

• Закрытые атрибуты или переменные (внутреннее использование модулем или классом) — _single_leading_underscore

• Закрытые атрибуты, которые не должны быть разделены на подклассы — __double_leading_underscore

• Магические атрибуты — __double_underscores__ (используйте их, не создавайте их)

Открытые атрибуты или переменные (предназначенные для использования импортером этого модуля или пользователем этого класса) — normal_lower_case

Закрытые атрибуты или переменные (внутреннее использование модулем или классом) — _single_leading_underscore

Закрытые атрибуты, которые не должны быть разделены на подклассы — __double_leading_underscore

Магические атрибуты — __double_underscores__ (используйте их, не создавайте их)

class GetSet(object):

   instance_count = 0 # public
   
   __mangled_name = 'no privacy!' # special variable

   def __init__(self, value):
      self._attrval = value # _attrval is for internal use only
      GetSet.instance_count += 1

   @property
   def var(self):
      print('Getting the "var" attribute')
      return self._attrval

   @var.setter
   def var(self, value):
      print('setting the "var" attribute')
      self._attrval = value

   @var.deleter
   def var(self):
      print('deleting the "var" attribute')
      self._attrval = None

cc = GetSet(5)
cc.var = 10 # public name
print(cc._attrval)
print(cc._GetSet__mangled_name)

Выход

setting the "var" attribute
10
no privacy!

Объектно-ориентированный Python — файлы и строки

Струны

Строки — самые популярные типы данных, используемые в каждом языке программирования. Зачем? Поскольку мы понимаем текст лучше, чем числа, поэтому при написании и разговоре мы используем текст и слова, так же как и в программировании мы используем строки. В строке мы анализируем текст, анализируем семантику текста и выполняем анализ данных — и все эти данные — текст, потребляемый человеком. Строка в Python неизменна.

Манипуляция строк

В Python строка может быть помечена несколькими способами, используя одинарные кавычки (‘), двойные кавычки (“) или даже тройные кавычки (‘ ») в случае многострочных строк.

>>> # String Examples
>>> a = "hello"
>>> b = ''' A Multi line string,
Simple!'''
>>> e = ('Multiple' 'strings' 'togethers')

Манипулирование строками очень полезно и очень широко используется в каждом языке. Часто программисты обязаны разбивать строки и внимательно их изучать.

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

Класс str имеет множество методов для упрощения работы со строками. Команды dir и help предоставляют руководство в интерпретаторе Python, как их использовать.

Ниже приведены некоторые из наиболее часто используемых строковых методов.

Sr.No.	Метод и описание
1	ISALPHA () Проверяет, все ли символы являются алфавитами
2	isdigit () Проверяет цифры символов
3	isdecimal () Проверяет десятичные символы
4	IsNumeric () проверяет числовые символы
5	находить() Возвращает самый высокий индекс подстрок
6	istitle () Проверяет наличие титульных строк
7	присоединиться() Возвращает объединенную строку
8	ниже () возвращает строку в нижнем регистре
9	Верхняя () возвращает строку в верхнем регистре
10	partion () Возвращает кортеж
11	ByteArray () Возвращает массив заданного размера байта
12	перечислить () Возвращает объект перечисления
13	isprintable () Проверяет печатный характер

ISALPHA ()

Проверяет, все ли символы являются алфавитами

isdigit ()

Проверяет цифры символов

isdecimal ()

Проверяет десятичные символы

IsNumeric ()

проверяет числовые символы

находить()

Возвращает самый высокий индекс подстрок

istitle ()

Проверяет наличие титульных строк

присоединиться()

Возвращает объединенную строку

ниже ()

возвращает строку в нижнем регистре

Верхняя ()

возвращает строку в верхнем регистре

partion ()

Возвращает кортеж

ByteArray ()

Возвращает массив заданного размера байта

перечислить ()

Возвращает объект перечисления

isprintable ()

Проверяет печатный характер

Давайте попробуем запустить несколько строковых методов,

>>> str1 = 'Hello World!'
>>> str1.startswith('h')
False
>>> str1.startswith('H')
True
>>> str1.endswith('d')
False
>>> str1.endswith('d!')
True
>>> str1.find('o')
4
>>> #Above returns the index of the first occurence of the character/substring.
>>> str1.find('lo')
3
>>> str1.upper()
'HELLO WORLD!'
>>> str1.lower()
'hello world!'
>>> str1.index('b')
Traceback (most recent call last):
   File "<pyshell#19>", line 1, in <module>
      str1.index('b')
ValueError: substring not found
>>> s = ('hello How Are You')
>>> s.split(' ')
['hello', 'How', 'Are', 'You']
>>> s1 = s.split(' ')
>>> '*'.join(s1)
'hello*How*Are*You'
>>> s.partition(' ')
('hello', ' ', 'How Are You')
>>>

Форматирование строк

В Python 3.x форматирование строк изменилось, теперь оно более логично и более гибко. Форматирование может быть выполнено с использованием метода format () или знака% (старый стиль) в строке формата.

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

синтаксис

str.format(*args, **kwargs)

Основное форматирование

>>> '{} {}'.format('Example', 'One')
'Example One'
>>> '{} {}'.format('pie', '3.1415926')
'pie 3.1415926'

Приведенный ниже пример позволяет изменить порядок отображения без изменения аргументов.

>>> '{1} {0}'.format('pie', '3.1415926')
'3.1415926 pie'

Обивка и выравнивание строк

Значение может быть дополнено до определенной длины.

>>> #Padding Character, can be space or special character
>>> '{:12}'.format('PYTHON')
'PYTHON '
>>> '{:>12}'.format('PYTHON')
' PYTHON'
>>> '{:<{}s}'.format('PYTHON',12)
'PYTHON '
>>> '{:*<12}'.format('PYTHON')
'PYTHON******'
>>> '{:*^12}'.format('PYTHON')
'***PYTHON***'
>>> '{:.15}'.format('PYTHON OBJECT ORIENTED PROGRAMMING')
'PYTHON OBJECT O'
>>> #Above, truncated 15 characters from the left side of a specified string
>>> '{:.{}}'.format('PYTHON OBJECT ORIENTED',15)
'PYTHON OBJECT O'
>>> #Named Placeholders
>>> data = {'Name':'Raghu', 'Place':'Bangalore'}
>>> '{Name} {Place}'.format(**data)
'Raghu Bangalore'
>>> #Datetime
>>> from datetime import datetime
>>> '{:%Y/%m/%d.%H:%M}'.format(datetime(2018,3,26,9,57))
'2018/03/26.09:57'

Строки Unicode

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

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

Преобразование текста в байты

Преобразование строк в байтовый объект называется кодированием. Существует множество форм кодирования, наиболее распространенными из которых являются: PNG; JPEG, MP3, WAV, ASCII, UTF-8 и т. Д. Также этот формат (кодирование) представляет собой формат для представления аудио, изображений, текста и т. Д. В байтах.

Это преобразование возможно с помощью encode (). В качестве аргумента используется техника кодирования. По умолчанию мы используем технику «UTF-8».

>>> # Python Code to demonstrate string encoding 
>>> 
>>> # Initialising a String 
>>> x = 'TutorialsPoint' 
>>> 
>>> #Initialising a byte object 
>>> y = b'TutorialsPoint'
>>> 
>>> # Using encode() to encode the String >>> # encoded version of x is stored in z using ASCII mapping 
>>> z = x.encode('ASCII') 
>>> 
>>> # Check if x is converted to bytes or not 
>>> 
>>> if(z==y): 
   print('Encoding Successful!') 
else: 
   print('Encoding Unsuccessful!') 
Encoding Successful!

Преобразование байтов в текст

Преобразование байтов в текст называется декодированием. Это реализуется через decode (). Мы можем преобразовать байтовую строку в символьную строку, если мы знаем, какая кодировка используется для ее кодирования.

Таким образом, кодирование и декодирование являются обратными процессами.

>>> 
>>> # Python code to demonstrate Byte Decoding 
>>> 
>>> #Initialise a String 
>>> x = 'TutorialsPoint' 
>>> 
>>> #Initialising a byte object 
>>> y = b'TutorialsPoint' 
>>> 
>>> #using decode() to decode the Byte object 
>>> # decoded version of y is stored in z using ASCII mapping 
>>> z = y.decode('ASCII')
>>> #Check if y is converted to String or not 
>>> if (z == x): 
   print('Decoding Successful!') 
else: 
   print('Decoding Unsuccessful!') Decoding Successful! 
>>>

Файловый ввод / вывод

Операционные системы представляют файлы в виде последовательности байтов, а не текста.

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

В Python файловая операция происходит в следующем порядке.

• Открыть файл
• Чтение или запись в файл (операция). Открытие файла
• Закройте файл.

Python оборачивает входящий (или исходящий) поток байтов соответствующими вызовами декодирования (или кодирования), чтобы мы могли иметь дело непосредственно с объектами str.

Открытие файла

В Python есть встроенная функция open () для открытия файла. Это создаст объект файла, также называемый дескриптором, поскольку он используется для чтения или изменения файла соответственно.

>>> f = open(r'c:\users\rajesh\Desktop\index.webm','rb')
>>> f
<_io.BufferedReader name='c:\\users\\rajesh\\Desktop\\index.webm'>
>>> f.mode
'rb'
>>> f.name
'c:\\users\\rajesh\\Desktop\\index.webm'

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

Классы исключений и исключений

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

Обработка исключений позволяет вам корректно обрабатывать ошибки и делать с ними что-то значимое. Обработка исключений состоит из двух компонентов: «выбрасывание» и «отлов».

Выявление исключения (ошибки)

Каждая ошибка, возникающая в Python, приводит к исключению, которое является условием ошибки, определяемым его типом ошибки.

>>> #Exception
>>> 1/0
Traceback (most recent call last):
   File "<pyshell#2>", line 1, in <module>
      1/0
ZeroDivisionError: division by zero
>>>
>>> var = 20
>>> print(ver)
Traceback (most recent call last):
   File "<pyshell#5>", line 1, in <module>
      print(ver)
NameError: name 'ver' is not defined
>>> #Above as we have misspelled a variable name so we get an NameError.
>>>
>>> print('hello)

SyntaxError: EOL while scanning string literal
>>> #Above we have not closed the quote in a string, so we get SyntaxError.
>>>
>>> #Below we are asking for a key, that doen't exists.
>>> mydict = {}
>>> mydict['x']
Traceback (most recent call last):
   File "<pyshell#15>", line 1, in <module>
      mydict['x']
KeyError: 'x'
>>> #Above keyError
>>>
>>> #Below asking for a index that didn't exist in a list.
>>> mylist = [1,2,3,4]
>>> mylist[5]
Traceback (most recent call last):
   File "<pyshell#20>", line 1, in <module>
      mylist[5]
IndexError: list index out of range
>>> #Above, index out of range, raised IndexError.

Исключение ловли / отлова

Когда в вашей программе происходит что-то необычное, и вы хотите обработать это с помощью механизма исключений, вы «выбрасываете исключение». Ключевые слова try и исключения используются для отлова исключений. Всякий раз, когда в блоке try возникает ошибка, Python ищет соответствующий блок, кроме как для его обработки. Если есть, выполнение прыгает туда.

синтаксис

try:
   #write some code
   #that might throw some exception
except <ExceptionType>:
   # Exception handler, alert the user

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

Если возникает исключение, оставшаяся часть блока try будет пропущена, и будет выполнено предложение исключений.

try:
   some statement here
except:
   exception handling

Давайте напишем некоторый код, чтобы увидеть, что происходит, когда вы не используете какой-либо механизм обработки ошибок в вашей программе.

number = int(input('Please enter the number between 1 & 10: '))
print('You have entered number',number)

Выше программа будет работать правильно, пока пользователь вводит число, но что произойдет, если пользователи попытаются поместить какой-либо другой тип данных (например, строку или список).

Please enter the number between 1 > 10: 'Hi'
Traceback (most recent call last):
   File "C:/Python/Python361/exception2.py", line 1, in <module>
      number = int(input('Please enter the number between 1 & 10: '))
ValueError: invalid literal for int() with base 10: "'Hi'"

Теперь ValueError является типом исключения. Попробуем переписать приведенный выше код с обработкой исключений.

import sys

print('Previous code with exception handling')

try:
   number = int(input('Enter number between 1 > 10: '))

except(ValueError):
   print('Error..numbers only')
   sys.exit()

print('You have entered number: ',number)

Если мы запустим программу и введем строку (вместо числа), мы увидим, что получаем другой результат.

Previous code with exception handling
Enter number between 1 > 10: 'Hi'
Error..numbers only

Возбуждение исключений

Чтобы повысить ваши исключения из ваших собственных методов, вам нужно использовать ключевое слово повышение, как это

raise ExceptionClass(‘Some Text Here’)

Давайте возьмем пример

def enterAge(age):
   if age<0:
      raise ValueError('Only positive integers are allowed')
   if age % 2 ==0:
      print('Entered Age is even')
   else:
      print('Entered Age is odd')

try:
   num = int(input('Enter your age: '))
   enterAge(num)
except ValueError:
   print('Only positive integers are allowed')

Запустите программу и введите положительное целое число.

Ожидаемый результат

Enter your age: 12
Entered Age is even

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

Ожидаемый результат

Enter your age: -2
Only positive integers are allowed

Создание пользовательского класса исключений

Вы можете создать пользовательский класс исключений, расширив класс BaseException или подкласс BaseException.

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

Создайте новый файл с именем NegativeNumberException.py и напишите следующий код.

class NegativeNumberException(RuntimeError):
   def __init__(self, age):
      super().__init__()
      self.age = age

Приведенный выше код создает новый класс исключений с именем NegativeNumberException, который состоит только из конструктора, который вызывает конструктор родительского класса с помощью super () __ init __ () и устанавливает возраст.

Теперь, чтобы создать свой собственный класс исключений, напишем некоторый код и импортируем новый класс исключений.

from NegativeNumberException import NegativeNumberException
def enterage(age):
   if age < 0:
      raise NegativeNumberException('Only positive integers are allowed')

   if age % 2 == 0:
      print('Age is Even')

   else:
      print('Age is Odd')

try:
   num = int(input('Enter your age: '))
   enterage(num)
except NegativeNumberException:
   print('Only positive integers are allowed')
except:
   print('Something is wrong')

Выход

Enter your age: -2
Only positive integers are allowed

Другой способ создать пользовательский класс Exception.

class customException(Exception):
   def __init__(self, value):
      self.parameter = value

   def __str__(self):
      return repr(self.parameter)
try:
   raise customException('My Useful Error Message!')
except customException as instance:
   print('Caught: ' + instance.parameter)

Выход

Caught: My Useful Error Message!

Иерархия исключений

Иерархия классов для встроенных исключений —

+-- SystemExit 
+-- KeyboardInterrupt 
+-- GeneratorExit 
+-- Exception 
+-- StopIteration 
+-- StopAsyncIteration 
+-- ArithmeticError 
| +-- FloatingPointError 
| +-- OverflowError 
| +-- ZeroDivisionError 
+-- AssertionError 
+-- AttributeError 
+-- BufferError 
+-- EOFError 
+-- ImportError 
+-- LookupError 
| +-- IndexError 
| +-- KeyError 
+-- MemoryError 
+-- NameError 
| +-- UnboundLocalError 
+-- OSError 
| +-- BlockingIOError 
| +-- ChildProcessError 
| +-- ConnectionError 
| | +-- BrokenPipeError 
| | +-- ConnectionAbortedError 
| | +-- ConnectionRefusedError 
| | +-- ConnectionResetError 
| +-- FileExistsError 
| +-- FileNotFoundError 
| +-- InterruptedError 
| +-- IsADirectoryError 
| +-- NotADirectoryError 
| +-- PermissionError 
| +-- ProcessLookupError 
| +-- TimeoutError 
+-- ReferenceError 
+-- RuntimeError 
| +-- NotImplementedError 
| +-- RecursionError 
+-- SyntaxError 
| +-- IndentationError
| +-- TabError 
+-- SystemError 
+-- TypeError 
+-- ValueError 
| +-- UnicodeError 
| +-- UnicodeDecodeError 
| +-- UnicodeEncodeError 
| +-- UnicodeTranslateError 
+-- Warning 
+-- DeprecationWarning 
+-- PendingDeprecationWarning 
+-- RuntimeWarning 
+-- SyntaxWarning 
+-- UserWarning 
+-- FutureWarning 
+-- ImportWarning 
+-- UnicodeWarning 
+-- BytesWarning 
+-- ResourceWarning

Объектно-ориентированный Python — Сериализация объектов

В контексте хранения данных сериализация — это процесс преобразования структур данных или состояния объекта в формат, который может быть сохранен (например, в буфере файла или памяти) или передан и восстановлен позже.

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

Соленый огурец

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

Рассол — это самый простой в эксплуатации способ хранения объекта. Модуль Python Pickle — это объектно-ориентированный способ хранения объектов непосредственно в специальном формате хранения.

Что оно может делать?

• Pickle может очень легко хранить и воспроизводить словари и списки.
• Сохраняет атрибуты объекта и восстанавливает их обратно в то же состояние.

Что рассол не может сделать?

• Это не сохраняет код объекта. Только это атрибуты значений.
• Он не может хранить файловые дескрипторы или сокеты подключения.

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

Чтобы засолить что-то, вы должны —

• импортный рассол
• Записать переменную в файл, что-то вроде

pickle.dump(mystring, outfile, protocol),

где протокол 3-го аргумента является необязательным.

Импортный рассол

Записать переменную в файл, что-то вроде

myString = pickle.load(inputfile)

методы

Интерфейс pickle предоставляет четыре различных метода.

• dump () — Метод dump () сериализуется в открытый файл (файлоподобный объект).

• dumps () — Сериализует в строку

• load () — Десериализуется из открытого объекта.

• load () — Десериализует из строки.

dump () — Метод dump () сериализуется в открытый файл (файлоподобный объект).

dumps () — Сериализует в строку

load () — Десериализуется из открытого объекта.

load () — Десериализует из строки.

На основе вышеописанной процедуры ниже приведен пример «травления».

Выход

My Cat pussy is White and has 4 legs
Would you like to see her pickled? Here she is!
b'\x80\x03c__main__\nCat\nq\x00)\x81q\x01}q\x02(X\x0e\x00\x00\x00number_of_legsq\x03K\x04X\x05\x00\x00\x00colorq\x04X\x05\x00\x00\x00Whiteq\x05ub.'

Итак, в приведенном выше примере мы создали экземпляр класса Cat, а затем выбрали его, преобразовав наш экземпляр «Cat» в простой массив байтов.

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

Также, если вы хотите создать файл с засоленным объектом, вы можете использовать метод dump () (вместо dumps * () * one), передавая также открытый двоичный файл, и результат засоления будет автоматически сохраняться в файле.

[….]
binary_file = open(my_pickled_Pussy.bin', mode='wb')
my_pickled_Pussy = pickle.dump(Pussy, binary_file)
binary_file.close()

Unpickling

Процесс, который принимает двоичный массив и преобразует его в иерархию объектов, называется расщеплением.

Процесс расщепления выполняется с помощью функции load () модуля pickle и возвращает полную иерархию объектов из простого массива байтов.

Давайте использовать функцию загрузки в нашем предыдущем примере.

Выход

MeOw is black
Pussy is white

JSON

JSON (JavaScript Object Notation) является частью стандартной библиотеки Python и представляет собой легкий формат обмена данными. Людям легко читать и писать. Это легко разобрать и сгенерировать.

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

Пример данных в формате JSON:

{"EmployID": 40203, "Name": "Zack", "Age":54, "isEmployed": True}

Python упрощает работу с файлами Json. Для этой цели используется модуль JSON. Этот модуль должен быть включен (встроен) в вашу установку Python.

Итак, давайте посмотрим, как мы можем преобразовать словарь Python в JSON и записать его в текстовый файл.

JSON в Python

Чтение JSON означает преобразование JSON в значение (объект) Python. Библиотека json анализирует JSON в словарь или список в Python. Для этого мы используем функцию load () (загрузка из строки) следующим образом:

Выход

Ниже приведен пример файла JSON,

data1.json
{"menu": {
   "id": "file",
   "value": "File",
   "popup": {
      "menuitem": [
         {"value": "New", "onclick": "CreateNewDoc()"},
         {"value": "Open", "onclick": "OpenDoc()"},
         {"value": "Close", "onclick": "CloseDoc()"}
      ]
   }
}}

Выше контент (Data1.json) выглядит как обычный словарь. Мы можем использовать pickle для хранения этого файла, но вывод его не в удобочитаемой форме.

JSON (Java Script Object Notification) — очень простой формат, и это одна из причин его популярности. Теперь давайте посмотрим на вывод json через программу ниже.

Выход

Выше мы открываем файл json (data1.json) для чтения, получаем обработчик файла и переходим к json.load и возвращаем объект. Когда мы пытаемся напечатать вывод объекта, он такой же, как файл json. Хотя типом объекта является словарь, он выступает в качестве объекта Python. Запись в JSON проста, как мы видели этот рассол. Выше мы загружаем файл json, добавляем еще одну пару ключ-значение и записываем ее обратно в тот же файл json. Теперь, если мы видим data1.json, он выглядит иначе. То есть не в том формате, в котором мы видели ранее.

Чтобы наш вывод выглядел одинаково (удобочитаемый формат), добавьте пару аргументов в нашу последнюю строку программы,

json.dump(conf, fh, indent = 4, separators = (‘,’, ‘: ‘))

Так же, как и pickle, мы можем напечатать строку с дампами и загрузить с нагрузками. Ниже приведен пример этого,

YAML

YAML может быть наиболее дружественным стандартом сериализации данных для всех языков программирования.

Python модуль yaml называется pyaml

YAML является альтернативой JSON —

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

• Компактный код — в YAML мы используем отступы для пробелов, чтобы обозначить структуру, а не скобки.

• Синтаксис для реляционных данных — для внутренних ссылок мы используем якоря (&) и псевдонимы (*).

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

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

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

Синтаксис для реляционных данных — для внутренних ссылок мы используем якоря (&) и псевдонимы (*).

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

Установка YAML

Поскольку yaml не является встроенным модулем, мы должны установить его вручную. Лучший способ установить yaml на Windows-машину — через pip. Запустите команду ниже на вашем терминале Windows, чтобы установить yaml,

pip install pyaml (Windows machine)
sudo pip install pyaml (*nix and Mac)

При выполнении команды выше, на экране отобразится что-то вроде ниже, в зависимости от текущей последней версии.

Collecting pyaml
Using cached pyaml-17.12.1-py2.py3-none-any.whl
Collecting PyYAML (from pyaml)
Using cached PyYAML-3.12.tar.gz
Installing collected packages: PyYAML, pyaml
Running setup.py install for PyYAML ... done
Successfully installed PyYAML-3.12 pyaml-17.12.1

Чтобы проверить это, перейдите в оболочку Python и импортируйте модуль yaml, импортируйте yaml, если ошибки не обнаружены, мы можем сказать, что установка прошла успешно.

После установки pyaml, давайте посмотрим на код ниже,

script_yaml1.py

Выше мы создали три разные структуры данных, словарь, список и кортеж. На каждой структуре мы делаем yaml.dump. Важным моментом является то, как вывод отображается на экране.

Выход

Вывод словаря выглядит чисто .ie. ключ: значение.

Пустое пространство для разделения разных объектов.

Список помечается тире (-)

Кортеж указывается сначала с помощью !! Python / tuple, а затем в том же формате, что и списки.

Загрузка файла yaml

Допустим, у меня есть один файл yaml, который содержит

---
# An employee record
name: Raagvendra Joshi
job: Developer
skill: Oracle
employed: True
foods:
   - Apple
   - Orange
   - Strawberry
   - Mango
languages:
   Oracle: Elite
   power_builder: Elite
   Full Stack Developer: Lame
education:
   4 GCSEs
   3 A-Levels
   MCA in something called com

Теперь давайте напишем код для загрузки этого файла yaml через функцию yaml.load. Ниже приведен код для того же.

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

Выход

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

PDB — отладчик Python

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

Чтобы установить точку останова, вставьте строку

pdb.set_trace()

пример

pdb_example1.py
import pdb
x = 9
y = 7
pdb.set_trace()
total = x + y
pdb.set_trace()

Мы вставили несколько точек останова в эту программу. Программа будет останавливаться на каждой точке останова (pdb.set_trace ()). Для просмотра содержимого переменных просто введите имя переменной.

c:\Python\Python361>Python pdb_example1.py
> c:\Python\Python361\pdb_example1.py(8)<module>()
-> total = x + y
(Pdb) x
9
(Pdb) y
7
(Pdb) total
*** NameError: name 'total' is not defined
(Pdb)

Нажмите c или продолжите, чтобы продолжить выполнение программ до следующей точки останова.

(Pdb) c
--Return--
> c:\Python\Python361\pdb_example1.py(8)<module>()->None
-> total = x + y
(Pdb) total
16

В конце концов вам нужно будет отлаживать гораздо большие программы — программы, которые используют подпрограммы. И иногда проблема, которую вы пытаетесь найти, лежит внутри подпрограммы. Рассмотрим следующую программу.

import pdb
def squar(x, y):
   out_squared = x^2 + y^2
   return out_squared
if __name__ == "__main__":
   #pdb.set_trace()
   print (squar(4, 5))

Теперь при запуске вышеуказанной программы,

c:\Python\Python361>Python pdb_example2.py
> c:\Python\Python361\pdb_example2.py(10)<module>()
-> print (squar(4, 5))
(Pdb)

Мы можем использовать ? чтобы получить помощь, но стрелка указывает строку, которая должна быть выполнена. На этом этапе полезно нажать s, чтобы перейти в эту строку.

(Pdb) s
--Call--
>c:\Python\Python361\pdb_example2.py(3)squar()
-> def squar(x, y):

Это вызов функции. Если вы хотите узнать, где вы находитесь в вашем коде, попробуйте l —

(Pdb) l
1 import pdb
2
3 def squar(x, y):
4 -> out_squared = x^2 + y^2
5
6 return out_squared
7
8 if __name__ == "__main__":
9 pdb.set_trace()
10 print (squar(4, 5))
[EOF]
(Pdb)

Вы можете нажать n, чтобы перейти к следующей строке. На данный момент вы находитесь внутри метода out_squared и имеете доступ к переменной, объявленной внутри функций .ie x и y.

(Pdb) x
4
(Pdb) y
5
(Pdb) x^2
6
(Pdb) y^2
7
(Pdb) x**2
16
(Pdb) y**2
25
(Pdb)

Таким образом, мы видим, что оператор ^ — это не то, что нам нужно, вместо этого нам нужно использовать оператор **, чтобы делать квадраты.

Таким образом, мы можем отлаживать нашу программу внутри функций / методов.

логирование

Модуль регистрации был частью стандартной библиотеки Python начиная с версии 2.3. Поскольку это встроенный модуль, все модули Python могут участвовать в ведении журнала, поэтому журнал нашего приложения может включать ваше собственное сообщение, интегрированное с сообщениями от стороннего модуля. Это обеспечивает большую гибкость и функциональность.

Преимущества ведения журнала

• Ведение журнала диагностики — записывает события, связанные с работой приложения.

• Журнал аудита — записывает события для бизнес-анализа.

Ведение журнала диагностики — записывает события, связанные с работой приложения.

Журнал аудита — записывает события для бизнес-анализа.

Сообщения пишутся и регистрируются на уровнях «серьезность» и минут

• DEBUG (debug ()) — диагностические сообщения для разработки.

• INFO (info ()) — стандартные сообщения о прогрессе.

• WARNING (warning ()) — обнаружена несерьезная проблема.

• ОШИБКА (error ()) — обнаружена ошибка, возможно, серьезная.

• КРИТИЧЕСКИЙ (критический ()) — обычно фатальная ошибка (программа останавливается).

DEBUG (debug ()) — диагностические сообщения для разработки.

INFO (info ()) — стандартные сообщения о прогрессе.

WARNING (warning ()) — обнаружена несерьезная проблема.

ОШИБКА (error ()) — обнаружена ошибка, возможно, серьезная.

КРИТИЧЕСКИЙ (критический ()) — обычно фатальная ошибка (программа останавливается).

Давайте рассмотрим ниже простую программу,

import logging

logging.basicConfig(level=logging.INFO)

logging.debug('this message will be ignored') # This will not print
logging.info('This should be logged') # it'll print
logging.warning('And this, too') # It'll print

Выше мы регистрируем сообщения на уровне серьезности. Сначала мы импортируем модуль, вызываем basicConfig и устанавливаем уровень ведения журнала. Уровень, который мы установили выше, это ИНФО. Тогда у нас есть три различных оператора: оператор отладки, оператор информации и оператор предупреждения.

Вывод logging1.py

INFO:root:This should be logged
WARNING:root:And this, too

Поскольку оператор info находится ниже оператора debug, мы не можем увидеть сообщение отладки. Чтобы получить оператор debug также в терминале вывода, все, что нам нужно изменить, — это уровень basicConfig.

logging.basicConfig(level = logging.DEBUG)

И в выводе мы можем видеть,

DEBUG:root:this message will be ignored
INFO:root:This should be logged
WARNING:root:And this, too

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

#logging.basicConfig(level = logging.DEBUG)

Выход

WARNING:root:And this, too

Python, встроенный в уровень ведения журнала, на самом деле является целым числом.

>>> import logging
>>>
>>> logging.DEBUG
10
>>> logging.CRITICAL
50
>>> logging.WARNING
30
>>> logging.INFO
20
>>> logging.ERROR
40
>>>

Мы также можем сохранить сообщения журнала в файл.

logging.basicConfig(level = logging.DEBUG, filename = 'logging.log')

Теперь все сообщения журнала будут отправляться в файл (logging.log) в текущем рабочем каталоге, а не на экран. Это гораздо лучший подход, так как он позволяет нам проводить пост-анализ полученных сообщений.

Мы также можем установить отметку даты с нашим сообщением журнала.

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

Выход получится примерно так:

2018-03-08 19:30:00,066 DEBUG:this message will be ignored
2018-03-08 19:30:00,176 INFO:This should be logged
2018-03-08 19:30:00,201 WARNING:And this, too

Бенчмаркинг

Тестирование или профилирование в основном для проверки того, насколько быстро выполняется ваш код и где узкие места? Основная причина сделать это для оптимизации.

timeit

Python поставляется со встроенным модулем под названием timeit. Вы можете использовать его для определения времени небольших фрагментов кода. Модуль timeit использует функции времени, специфичные для платформы, так что вы получите максимально точные сроки.

Таким образом, это позволяет нам сравнивать две партии кода, взятые каждым, а затем оптимизировать сценарии для повышения производительности.

Модуль timeit имеет интерфейс командной строки, но его также можно импортировать.

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

import timeit
print ( 'by index: ', timeit.timeit(stmt = "mydict['c']", setup = "mydict = {'a':5, 'b':10, 'c':15}", number = 1000000))
print ( 'by get: ', timeit.timeit(stmt = 'mydict.get("c")', setup = 'mydict = {"a":5, "b":10, "c":15}', number = 1000000))

Выход

by index: 0.1809192126703489
by get: 0.6088525265034692

Выше мы используем два разных метода .ie by subscript и получаем доступ к значению ключа словаря. Мы выполняем оператор 1 миллион раз, поскольку он выполняется слишком быстро для очень маленьких данных. Теперь мы можем видеть доступ к индексу намного быстрее по сравнению с get. Мы можем запустить код многократно, и время выполнения будет немного отличаться, чтобы лучше понять.

Другой способ — запустить вышеуказанный тест в командной строке. Давай сделаем это,

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydict['c']"
1000000 loops, best of 3: 0.187 usec per loop

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydict.get('c')"
1000000 loops, best of 3: 0.659 usec per loop

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

Ниже мы можем использовать модуль timeit, если мы хотим вызвать функцию. Как мы можем добавить несколько операторов внутри функции для тестирования.

import timeit

def testme(this_dict, key):
   return this_dict[key]

print (timeit.timeit("testme(mydict, key)", setup = "from __main__ import testme; mydict = {'a':9, 'b':18, 'c':27}; key = 'c'", number = 1000000))

Выход

0.7713474590139164

Объектно-ориентированный Python — Библиотеки

Запросы — Модуль Python Requests

Requests — это модуль Python, который представляет собой элегантную и простую HTTP-библиотеку для Python. При этом вы можете отправлять все виды HTTP-запросов. С помощью этой библиотеки мы можем добавлять заголовки, данные форм, многокомпонентные файлы и параметры и получать доступ к данным ответов.

Поскольку Requests не является встроенным модулем, поэтому нам нужно сначала установить его.

Вы можете установить его, выполнив следующую команду в терминале —

pip install requests

После того, как вы установили модуль, вы можете проверить успешность установки, введя приведенную ниже команду в оболочке Python.

import requests

Если установка прошла успешно, вы не увидите сообщение об ошибке.

Создание запроса GET

В качестве примера мы будем использовать «pokeapi»

Выход —

Делать POST-запросы

Методы библиотеки запросов для всех используемых в настоящее время HTTP-глаголов. Если вы хотите сделать простой запрос POST к конечной точке API, вы можете сделать это следующим образом:

req = requests.post(‘http://api/user’, data = None, json = None)

Это будет работать точно так же, как и в нашем предыдущем запросе GET, однако в нем есть два дополнительных параметра ключевого слова —

• данные, которые могут быть заполнены, скажем, словарем, файлом или байтами, которые будут переданы в теле HTTP нашего запроса POST.

• json, который может быть заполнен объектом json, который также будет передан в теле нашего HTTP-запроса.

данные, которые могут быть заполнены, скажем, словарем, файлом или байтами, которые будут переданы в теле HTTP нашего запроса POST.

json, который может быть заполнен объектом json, который также будет передан в теле нашего HTTP-запроса.

Панды: Python Library Pandas

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

Построенный на Numpy пакет и ключевая структура данных называется DataFrame. Эти кадры данных позволяют нам хранить и манипулировать табличными данными в строках наблюдений и столбцах переменных.

Есть несколько способов создать DataFrame. Одним из способов является использование словаря. Например —

Выход

Из выходных данных мы можем видеть новые brics DataFrame, Pandas назначил ключ для каждой страны в виде числовых значений от 0 до 4.

Если вместо того, чтобы указывать значения индексации от 0 до 4, мы бы хотели иметь разные значения индекса, скажем, двухбуквенный код страны, вы также можете сделать это легко —

Добавление ниже одной строки в приведенном выше коде, дает

brics.index = [‘BR’, ‘RU’, ‘IN’, ‘CH’, ‘SA’]

Выход

Индексирование фреймов данных

Выход

Pygame

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

обзор

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

Домашняя страница библиотеки Pygame находится по адресу https://www.pygame.org/news.

Чтобы создать приложение Pygame, выполните следующие действия:

Импортируйте библиотеку Pygame

import pygame

Инициализируйте библиотеку Pygame

pygame.init()

Создать окно.

screen = Pygame.display.set_mode((560,480))
Pygame.display.set_caption(‘First Pygame Game’)

Инициализировать игровые объекты

На этом этапе мы загружаем изображения, загружаем звуки, позиционируем объект, настраиваем некоторые переменные состояния и т. Д.

Запустите игровой цикл.

Это просто цикл, в котором мы постоянно обрабатываем события, проверяем ввод, перемещаем объекты и рисуем их. Каждая итерация цикла называется фреймом.

Давайте поместим всю вышеупомянутую логику в одну программу ниже,

Pygame_script.py

Выход

Красивый суп: веб-скребок с красивым супом

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

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

Поскольку BeautifulSoup не является встроенной библиотекой, мы должны установить ее, прежде чем пытаться ее использовать. Чтобы установить BeautifulSoup, запустите следующую команду

$ apt-get install Python-bs4 # For Linux and Python2 
$ apt-get install Python3-bs4 # for Linux based system and Python3.

$ easy_install beautifulsoup4 # For windows machine, 
Or 
$ pip instal beatifulsoup4 # For window machine

После завершения установки мы готовы запустить несколько примеров и подробно изучить Beautifulsoup.

Выход

Ниже приведены несколько простых способов навигации по этой структуре данных —

Одна из распространенных задач — извлечь все URL-адреса, найденные в тегах <a> страницы.

Другая распространенная задача — извлечь весь текст со страницы.