Ultimate Guide к Python: как отправиться от новичка до про

Автор оригинала: Sharvin Shah.

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

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

print("Hello folks")

Мы будем использовать Python3 В этом руководстве, как он широко используется. Большинство рамок и библиотек Python поддерживают эту версию.

Индекс:

1. Вступление
2. Монтаж
3. Python Shell.
4. Комментарий
5. Распечатать
6. Отступ
7. Переменные
8. Операторы
9. Условные заявления
10. Для петлей
11. В то время как петли
12. Пользовательский ввод
13. Опечатка
14. Словари
15. Списки
16. Кортежи
17. Набор
18. Функции и аргументы
19. Args.
20. Аргументы ключевых слов
21. Аргументы по умолчанию
22. kwargs.
23. Сфера
24. Обратование возврата
25. Лямбда выражение
26. Список понимания
27. Ой концепции
28. Классы
29. Методы
30. Объекты
31. Конструктор
32. Атрибут экземпляра
33. Класс атрибутов
34. Себя
35. Наследование
36. супер
37. Многократное наследование
38. Полиморфизм
39. Инкапсуляция
40. Декораторы
41. Исключения
42. Пакет импорт
43. JSON обработка

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

Вступление:

Согласно Github Октовертивные Python является вторым наиболее используемым языком разработчиками в 2019 году.

Прежде чем изучать любой язык, полезно знать, как этот язык появился. Ну, Python был разработан Гвидо Ван Россом , голландский программист и был выпущен в 1991 году.

Python – это интерпретированный язык. Он использует Cpython Переводчик для компиляции кода Python в байтовый код. Для новичка вам не нужно знать много о CPYthon, но вы должны знать, как Python работает внутри.

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

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

• Разработка на стороне сервера (Django, Flask)
• Наука данных (Pytorch, Tensor-fleat)
• Анализ/визуализация данных (MATPLOTLIB)
• Сценарии (красивый суп)
• Встроенная разработка

Монтаж

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

python3 --version

Вы увидите следующий вывод:

Python 3.7.0

Обратите внимание, что ваша версия Python может отличаться. Если у вас установлен Python, и версия выше 3.5.2, вы можете пропустить этот раздел.

Для тех, у кого нет Python, выполните следующие действия:

• Windows User.
• Пользователь Mac
• Linux user.

Пользователь Windows:

• Перейти к Официальный сайт Python Отказ
• Нажмите на кнопку загрузки (загрузка Python 3.8.2) [ Примечание: Версия может отличаться в зависимости от того, когда вы читаете эту статью]
• Перейдите на путь, в котором пакет загружен и дважды щелкните установщик.
• Установите флажок, указывающий на «Добавить Python 3.x на путь», а затем нажмите «Установить сейчас».
• После этого вы получите подсказку, что «настройка была успешной». Проверьте еще раз, если Python настроен правильно, используя вышеуказанную команду.
• Чтобы подтвердить, если Python установлен и настроен правильно, используйте команду Python3 --version Отказ

Пользователь Mac:

• Первая установка Xcode из приложенного магазина.
• Если вы хотите установить XCODE с помощью терминала, используйте следующую команду:

xcode-select --install

• После этого мы будем использовать диспетчер пакетов Brew для установки Python. Чтобы установить и настроить варить Используйте следующую команду:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

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

brew update

• Используйте следующую команду для установки Python:

brew install python3

• Чтобы подтвердить, если Python установлен и настроен правильно, используйте команду Python3 --version Отказ

Linux пользователь:

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

sudo apt install python3

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

sudo yum install python3

• Чтобы подтвердить, если Python установлен и настроен правильно, используйте команду Python3 --version Отказ

Python Shell:

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

Перейдите в клемму или командную строку Подскажите. Введите Python3 команда, и вы получите следующий вывод:

➜ python3.7
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24)
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

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

Чтобы узнать оставшиеся концепции, мы создадим файл под названием «тестирование» с расширением .py Отказ Чтобы запустить этот файл, мы будем использовать следующую команду:

python3 testing.py

Пойдем на раковину Python. Тип 10 + 12 после >>> отметка. Вы получите выход 22:

>>> 10 + 12
22

Комментирование:

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

# Stay Safe

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

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

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

Распечатать:

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

Так как это помогает в отладке вопроса? Ну, подумайте, что у вас есть модуль, и вы хотите проверить поток выполнения, чтобы понять или отладить его. Есть два варианта. Либо вы можете использовать отладчик или добавить оператор печати.

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

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

print("Stay safe...")

Отступ:

Еще одна интересная часть этого языка – отступ. Почему? Ну, ответ прост: он делает код читаемого и хорошо отформатированным. Обязательнее в Python следует следовать правилам отступа. Если правильные отступы не соблюдаются, вы получите следующую ошибку:

IndentationError: unexpected indent

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

Переменные:

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

Хорошо в большинстве языков программирования необходимо назначить тип к переменной. Но в Python вам не нужно. Например, чтобы объявить целое число в C, используется следующий синтаксис: int; Отказ В Python это Num Отказ

Перейдите на раковину Python и выполните операцию шаг за шагом:

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

>>> num = 5
>>> print(num)
5
>>> type(num)

Как вы можете видеть здесь, мы объявили Num переменная и назначена 5 в качестве значения. Встроенный Python Тип Метод можно использовать для проверки типа переменной. Когда мы проверяем тип Num Мы видим вывод <класс 'int'> Отказ На данный момент просто сосредоточиться на int в этом выходе. int представляет целое число.

• Плавать : Подобное целое число, но с одной незначительной разницей – поплавки – это числовое значение с десятичным местом.

>>> num = 5.0
>>> print(num)
5.0
>>> type(num)

Здесь мы присваиваем номер одним десятичным значением для Num Отказ Когда мы проверяем тип Num Мы видим, это плавать Отказ

• Строка : Образование персонажей или целых чисел. Их можно представить с помощью двойных или одиночных кавычек.

>>> greet = "Hello user"
>>> print(greet)
Hello user
>>> type(greet)

Здесь мы назначили строку в приветствовать Отказ Тип приветствия – это строка, на которую вы можете видеть с вывода.

• Логический : Бинарный оператор с истинным или ложным значением.

>>> is_available = True
>>> print(is_available)
True
>>> type(is_available)

Здесь мы присваивали истинное значение для is_available Отказ Тип этой переменной логический. Вы можете назначить только Правда или Ложь Отказ Помните T и F должен быть капиталом или оно даст ошибку следующим образом:

>>> is_available = true
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'true' is not defined

• Неточный : Это используется, когда у нас нет значения переменной.

>>> num = None
>>> print(num)
None
>>> type(num)

Операторы:

Посмотрите на изображение ниже, чтобы увидеть все арифметические операторы, доступные в Python:

Давайте перейдем на операторы один за другим.

Арифметические операторы

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

Во-первых, мы объявим две переменные, А и B Отказ

>>> a = 6 # Assignment
>>> b = 2

Давайте попробуем наши основные арифметические операции:

>>> a + b # Addition
8
>>> a - b # Subtraction
4
>>> a * b # Multiplication
12
>>> a / b # Division
3.0
>>> a ** b # Exponentiation
36

Чтобы проверить другие арифметические операции, давайте изменим значение А и B Отказ

>>> a = 7
>>> b = 3
>>> a % b # Modulus
1
>>> a // b # Floor division
2

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

Операторы сравнения

К ним относятся равные, больше, чем и меньше, чем.

>>> a = 5 # Assign
>>> b = 2 # Assign
>>> a > b # Greater than
True
>>> a < b # less then
False
>>> a == b # Equal to
False
>>> a >= 5 # Greater than or equal to
True
>>> b <= 1 # Less than or equal to
False

Логические операторы

Эти операторы включают в себя не, а также.

>>> a = 10
>>> b = 2
>>> a == 2 and b == 10 # and
False
>>> a == 10 or b == 10 # or
True
>>> not(a == 10) # not
False
>>> not(a == 2)
True

Условные заявления:

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

Много раз, когда вы разрабатываете приложение, вам нужно проверить определенное состояние и делать разные вещи в зависимости от результата. В таких сценариях условные заявления полезны. Если ELIF и остальные – условные операторы, используемые в Python.

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

Состояние № 1: У нас здесь целое число и 3 состояния. Первый – это Если условие. Он проверяет, равно ли число 10.

Второй – это Элиф условие. Здесь мы проверяем, если число меньше 10.

Последнее состояние – еще Отказ Это условие выполняется, когда ни один из вышеуказанных условий совпадает.

>>> number = 5
>>> if number == 10:
...     print("Number is 10")
... elif number < 10:
...     print("Number is less than 10")
... else:
...     print("Number is more than 10")
...

Выход:

Number is less than 10

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

Состояние № 2: Здесь у нас есть булева и 2 условия здесь. Вы заметили, как мы проверяем, правда ли условие? Если is_available Затем напечатайте «Да, это доступно», иначе печатать «недоступен».

>>> is_available = True
>>> if is_available:
...     print("Yes it is available")
... else:
...     print("Not available")
...

Выход:

Yes it is available

Состояние № 3: Здесь мы имеем обратное состояние № 2 с помощью не оператора.

>>> is_available = True
>>> if not is_available:
...     print("Not available")
... else:
...     print("Yes it is available")
...

Выход:

Yes it is available

Состояние № 4: Здесь мы объявляем данные не так и проверять, доступны ли данные или нет.

>>> data = None
>>> if data:
...     print("data is not none")
... else:
...     print("data is none")
...

Выход:

data is none

Состояние № 5: Вы также можете использовать встроенный, если в Python. Синтаксис для достижения этого является следующее:

>>> num_a = 10
>>> num_b = 5
>>> if num_a > num_b: print("num_a is greater than num_b")
...

Выход:

num_a is greater than num_b

Состояние № 6: Вы также можете использовать встроенный, если еще в Python. Синтаксис для достижения этого является следующее:

expression_if_true if condition else expression_if_false

Пример:

>>> num = 5
>>> print("Number is five") if num == 5 else print("Number is not five")

Выход:

Number is five

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

>>> num = 25
>>> if num > 10:
...     print("Number is greater than 10")
...     if num > 20:
...             print("Number is greater than 20")
...     if num > 30:
...             print("Number is greater than 30")
... else:
...     print("Number is smaller than 10")
...

Выход:

Number is greater than 10
Number is greater than 20

Состояние № 8: Вы также можете использовать и Оператор в условном заявлении. Он утверждает, что условия1 и условия2 и истины, то выполните его.

>>> num = 10
>>> if num > 5 and num < 15:
...     print(num)
... else:
...     print("Number may be small than 5 or larger than 15")
...

Выход:

10

Как наше число от 5 до 15 лет, мы получаем вывод 10.

Состояние № 9: Вы также можете использовать или Оператор в условном заявлении. Он утверждает, что если либо условие1 или условие 2 верно, выполните его.

>>> num = 10
>>> if num > 5 or num < 7:
...     print(num)
...

Выход:

10

Вы путаете, потому что ценность Num 10 и наше второе условие утверждают, что Num меньше 7? Так почему же мы получаем вывод как 10? Это из-за или условие. Как один из условий совпадает, он будет выполнен.

Для петлей:

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

print("Hello")
print("Hello")
print("Hello")

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

Здесь мы используем метод диапазона. Он указывает диапазон, пока петля должна быть повторена. По умолчанию отправная точка 0.

>>> for i in range(3):
...     print("Hello")
...

Выход:

Hello
Hello
Hello

Вы также можете указать диапазон таким образом Диапазон (1,3) Отказ

>>> for i in range(1,3):
...     print("Hello")
...

Выход:

Hello
Hello

«Привет» напечатано только в два раза, так как мы указываем здесь диапазон. Подумайте о диапазоне, как Номер справа - номер слева Отказ

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

>>> for i in range(3):
...     print("Hello")
... else:
...     print("Finished")

Выход:

Hello
Hello
Hello
Finished

Смотрите наш цикл, повторяющийся 3 раза (3 – 0), и как только это сделано, он выполнил оператор Else.

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

>>> for i in range(3):
...     for j in range(2):
...             print("Inner loop")
...     print("Outer loop")
...

Выход:

Inner loop
Inner loop
Outer loop
Inner loop
Inner loop
Outer loop
Inner loop
Inner loop
Outer loop

Как вы можете увидеть оператор печати внутреннего цикла, выполненное два раза. После этого выполняется оператор на внешнем петле. Опять же внутренняя цикла выполнена два раза. Так что здесь происходит? Если вы смущены, то рассмотрите это, чтобы решить это:

• Наш переводчик приходит и видит, что есть для петля. Спадет снова и проверяет, есть еще один для петля.
• Так что теперь это будет выполнять внутреннее для петля два раза и выйти. Как только он закончится, он знает, что внешняя для цикла проинструктировала его повторить еще два раза.
• Он начинается снова и видит внутреннюю силу для петли и повторяется.

Ну, вы также можете выбрать передать определенный для Условие петли. Что здесь значит пропуск? Хорошо, когда произойдет цикл, и переводчик видит пройти Заявление оно не будет выполнено и перейдет на следующую строку.

>>> for i in range(3):
...     pass
...

Вы не получите ни один вывод на оболочке.

Пока петли:

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

>>> i = 0
>>> while i < 5:
...     print("Number", i)
...     i += 1
...

Выход:

Number 0
Number 1
Number 2
Number 3
Number 4

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

Другой вариант – добавить Перерыв Заявление в в то время как петля. Это сломает петлю.

>>> i = 0
>>> while i < 5:
...     if i == 4:
...             break
...     print("Number", i)
...     i += 1
...

Выход:

Number 0
Number 1
Number 2
Number 3

Здесь мы ломаем в то время как петля, если мы найдем значение Я быть 4.

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

>>> i = 0
>>> while i < 5:
...     print("Number", i)
...     i += 1
... else:
...     print("Number is greater than 4")
...

Выход:

Number 0
Number 1
Number 2
Number 3
Number 4
Number is greater than 4

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

>>> i = 0
>>> while i < 6:
...     i += 1
...     if i == 2:
...             continue
...     print("number", i)
...

Выход:

number 1
number 3
number 4
number 5
number 6

Пользовательский ввод:

Представьте себе, что вы создаете приложение командной строки. Теперь вы должны взять пользовательский ввод и действовать соответственно. Чтобы сделать это, вы можете использовать встроенные Python вход метод.

Синтаксис для достижения этого заключается в следующем:

variable = input(".....")

Пример:

>>> name = input("Enter your name: ")
Enter your name: Sharvin

Когда вы используете вход Способ и нажмите Enter, вам будет предложено введите текст, который вы вводите в вход метод. Давайте проверим, работает ли наш задание или нет:

>>> print(name)
Sharvin

Там это! Это работает отлично. Здесь Шарвин имеет строку типа.

>>> type(name)

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

>>> date = input("Today's date: ")
Today's date: 12
>>> type(date)

Вы растеряны? Мы вошли в целое число 12, и он все еще дает нам свой тип в виде строки. Это не ошибка. Это как ввод предназначен для работы. Чтобы преобразовать строку в целое число, мы будем использовать типости.

Типопередача:

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

>>> date_to_int = int(date)
>>> type(date_to_int)

Здесь мы потратили дату, которую мы объявили выше в разделе ввода пользователя и преобразовали его в целое число, используя встроенные Python int метод. Это называется типости.

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

• Целое число для строки: ул.
• строка в целое число: int ()
• Целое число плавать: плавать()

>>> type(date)


# Converting from string to float
>>> date_to_float = float(date)
>>> type(date_to_float)


# Converting from float to string
>>> date_to_string = str(date_to_float)
>>> type(date_to_string)


# Converting from float to integer
>>> date_to_int = int(date_to_float)
>>> type(date_to_int)

Словари:

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

>>> fname = "Sharvin"
>>> lname = "Shah"
>>> profession = "Developer"

Для доступа к этому значению мы можем сделать следующее:

>>> print(fname)
Sharvin

Но это элегантный и оптимизированный способ получить доступ к нему? Ответ – нет. Чтобы сделать его более дружелюбным, давайте храним данные в словаре клавишных значений.

Что такое словарь? Словарь – это коллекция, которая является неупорядоченным и мультиремным (то есть она может быть обновлена).

Ниже приведен формат словаря:

data = {
	"key" : "value"
}

Давайте понять словарь дальше на примере:

>>> user_details = {
...     "fname": "Sharvin",
...     "lname": "Shah",
...     "profession": "Developer"
... }

Как получить доступ к значению в словаре

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

Метод 1: Для доступа к значению fname ключ от user_details Словарь Мы можем использовать следующий синтаксис:

>>> user_details["fname"]
'Sharvin'

Способ 2: Мы также можем получить доступ к значению fname ключ от user_details Словарь с использованием получить Отказ

>>> user_details.get("fname")
'Sharvin'

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

>>> user_details["age"]
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'age'

Мы получаем jeeRror, что указывает на то, что ключ недоступен. Давайте попробуем тот же сценарий с методом 2.

>>> user_details.get("age")

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

>>> age = user_details.get("age")
>>> print(age)
None

Так когда получить Не находит ключ, который он устанавливает значение никому. Из-за этого мы не получаем никакой ошибки. Теперь вам может быть интересно, какой из них прав. Большую часть времени, используя метод 2 имеет больше смысла, но для некоторых строгих условий проверки нам нужно использовать метод 1.

Как проверить, существует ли ключ

Вам может быть интересно, как проверить, имеет ли словарь определенный ключ или нет в нем. Python предоставляет встроенный метод Клавиши () решить эту проблему.

>>> if "age" in user_details.keys():
...     print("Yes it is present")
... else:
...     print("Not present")
...

Мы получим следующий вывод:

Not present

Что если мы хотим проверить, является ли словарь пустым или нет? Чтобы понять это, давайте объявляем пустой словарь следующим образом:

>>> user_details = {}

Когда мы используем, если-else на словаре напрямую его либо возвращает True, если данные присутствуют или ложь, если пусто.

>>> if user_details:
...     print("Not empty")
... else:
...     print("Empty")
...

Выход:

Empty

Мы также можем использовать встроенный метод Python Bool Чтобы проверить, является ли словарь пуст или нет. Помните, что Bool возвращает false, если словарь пуст и правда, если он заполнен.

>>> bool(user_details)
False

>>> user_details = {
...     "fname" : "Sharvin"
... }
>>> bool(user_details)
True

Как обновить значение существующего ключа

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

Объявите словарь следующим образом:

>>> user_details = {
...     "fname":"Sharvin",
...     "lname": "Shah",
...     "profession": "Developer"
... }

Чтобы обновить значение, используйте следующий синтаксис:

>>> user_details["profession"] = "Software Developer"
>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

Обновление значения ключа в словаре такое же, как назначение значения для переменной.

Как добавить пару на ключ

Следующий вопрос в том, как добавить новое значение в словарь? Давайте добавим возраст ключ со значением 100.

>>> user_details["age"] = "100"
>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer', 'age': '100'}

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

Как удалить параметр ключа

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

>>> user_details.pop("age")
'100'

>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

Это удаляет возраст Пара ключа-значений из user_details Словарь. Мы также можем использовать дель Оператор для удаления значения.

>>> del user_details["age"]

>>> print(user_details)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

дель Метод также может быть использован для Удалить полный словарь Отказ Используйте следующий синтаксис, чтобы удалить полный словарь del user_details Отказ

Как скопировать словарь

Словарь не может быть скопирован традиционным способом. Например, вы не можете скопировать значение DICTA к Dictb следующим образом:

dictA = dictB

Чтобы скопировать значения, необходимые для использования Скопировать метод.

>>> dictB = user_details.copy()

>>> print(dictB)
{'fname': 'Sharvin', 'lname': 'Shah', 'profession': 'Software Developer'}

Списки:

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

data = [ 1, 5, "xyz", True ]

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

Как получить доступ к элементам списка

Давайте попробуем получить доступ к первому элементу:

>>> data[1]
5

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

Индексирование списка начинается с нуля. Так что я имею в виду под этим? Индексирование положения элементов начинается с нуля. Синтаксис для доступа к элементу выглядит следующим образом:

list[position_in_list]

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

>>> data[0]
1

Вы также можете указать диапазон для доступа к элементу между этими позициями.

>>> data[2:4]
['xyz', True]

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

Как добавить элемент в список

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

>>> data.append("Hello")

>>> data
[1, 5, 'abc', True, 'Hello']

Как изменить значение элемента

Чтобы изменить значение элемента, используйте следующий синтаксис:

>>> data[2] = "abc"

>>> data
[1, 5, 'abc', True]

Как удалить элемент из списка

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

>>> data.remove("Hello")
>>> data
[1, 5, 'abc', True]

Как петлю через список

Мы также можем зацикливаться через список, чтобы найти определенный элемент и работать на нем.

>>> for i in data:
...     print(i)
...

Выход:

1
5
abc
True

Как проверить, существует ли элемент или нет

Чтобы проверить, существует ли конкретный элемент или нет в списке, мы можем использовать, если цикла следующим образом:

>>> if 'abc' in data:
...     print("yess..")
...
yess..

Как скопировать данные списка

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

>>> List2 = data.copy()
>>> List2
[1, 5, 'abc', True]

Как проверить длину списка

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

>>> len(data)
4

Как присоединиться к двум спискам

Чтобы присоединиться к двум списке, мы можем использовать + оператор.

>>> list1 = [1, 4, 6, "hello"]
>>> list2 = [2, 8, "bye"]
>>> list1 + list2
[1, 4, 6, 'hello', 2, 8, 'bye']

Что произойдет, если мы попытаемся получить доступ к позиции элемента, которая недоступна в списке? Мы получаем Индекс списка вне диапазона Ошибка в таком состоянии.

>>> list1[6]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range

Кортежи:

Tupple – это тип данных, который заказывается и неизменны (I.e. данные не могут быть изменены).

Давайте создадим кортеж:

>>> data = ( 1, 3 , 5, "bye")
>>> data
(1, 3, 5, 'bye')

Как получить доступ к элементу кортежа

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

>>> data[3]
'bye'

Мы можем получить доступ к диапазону индекса следующим образом:

>>> data[2:4]
(5, 'bye')

Как изменить значение Tuple

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

>>> data[1] = 8
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

Есть доступный обходной путь для изменения значения кортежа:

>>> data = ( 1, 3 , 5, "bye")
>>> data_two = list(data) # Convert data to list
>>> data_two[1] = 8 # Update value as list is mutable
>>> data = tuple(data_two) # Convert again to tuple
>>> data
(1, 8, 5, 'bye')

Все остальные методы, которые мы видели в списке, применимы для кортежа.

[Примечание. Как только кортеж создан, новое значение не может быть добавлено в него. ] Отказ

Наборы:

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

>>> data = { "hello", "bye", 10, 15 }
>>> data
{10, 15, 'hello', 'bye'}

Как получить доступ к значению

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

>>> for i in data:
...     print(i)
...

10
15
hello
bye

Как изменить значение

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

Как добавить товар

Чтобы добавить элемент на набор Python, обеспечивает встроенный метод, называемый Добавить Отказ

>>> data.add("test")
>>> data
{10, 'bye', 'hello', 15, 'test'}

Как проверить длину

Чтобы проверить длину множества, мы используем Лен метод.

>>> len(data)
5

Как удалить предмет

Чтобы удалить элемент, используйте Удалить Метод:

>>> data.remove("test")
>>> data
{10, 'bye', 'hello', 15}

Функции и аргументы:

Функции – это удобный способ объявить операцию, которую мы хотим выполнить. С помощью функций вы можете отделить логику в соответствии с операцией.

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

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

>>> def hello_world():
...     print("Hello world")
...

Здесь мы объявляем функцию, которая, когда вызывается, печатает заявление «Hello World». Чтобы вызвать функцию, мы используем следующий синтаксис:

>>> hello_world()

Мы получим следующий вывод:

Hello world

Помните, что () Кронштейны в функциональном вызове означает выполнить его. Удалите эти круглые кронштейны и попробуйте позвонить снова.

>>> hello_world

Вы получите следующий вывод:

Когда мы снимаем круглые кронштейны из функционального вызова, то это дает нам ссылку на функцию. Здесь выше, как вы можете увидеть ссылку на Функция hello_world Указывает на этот адрес памяти 0x1083eb510 Отказ

Подумайте, что вы должны выполнить операцию дополнения. Вы можете сделать это, заявив А и B а затем выполнять дополнение.

>>> a = 5
>>> b = 10
>>> a + b
15

Это один из способов пойти. Но теперь считай, что ценность А и B изменились, и вам нужно сделать это снова.

>>> a = 5
>>> b = 10
>>> a + b
15
>>> a = 2
>>> b = 11
>>> a + b
13

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

>>> def add(a,b):
...     print(a+b)
...

Здесь мы добавляем А и B как обязательный аргумент для Добавить функция. Чтобы вызвать эту функцию, мы будем использовать следующий синтаксис:

>>> add(10,5)

Выход:

15

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

>>> add()
Traceback (most recent call last):
  File "", line 1, in 
TypeError: add() missing 2 required positional arguments: 'a' and 'b'

Python бросает в систему типа и информирует нас, что функция требует двух аргументов.

Можете ли вы догадаться, что произойдет, если мы пройдем третий аргумент?

>>> add(10,5,1)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: add() takes 2 positional arguments but 3 were given

Ну, Python сообщит нам, что мы прошли 3 аргумента, но есть только 2 позиционных аргумента.

Итак, что мы можем сделать, когда мы не знаем, сколько аргументов могут взять функцию? Чтобы решить эту проблему, мы используем Args и Kwargs.

Args:

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

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

>>> def add(*num):
...     print(num)
...

Здесь * Num является примером аргументов. Теперь, когда мы называем функцию Добавить Мы можем передать число аргументов, и он не бросит Типеррор Отказ

>>> add(1,2,3)
(1, 2, 3)

>>> add(1,2,3,4)
(1, 2, 3, 4)

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

>>> def add(*num):
...     print(sum(num))
...

Теперь, когда мы вызываем функцию Add, мы получим следующий выход:

>>> add(1,2,3) # Function call
6
>>> add(1,2,3,4) # Function call
10

Аргументы ключевых слов:

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

>>> def user_details(username, age):
...     print("Username is", username)
...     print("Age is", age)
...

Давайте назовем эту функцию следующим образом:

>>> user_details("Sharvin", 100)

Мы получим следующий вывод:

Username is Sharvin
Age is 100

Ну, это выглядит правильно, но представь, если бы мы назвали нашу функцию таким образом:

>>> user_details(100, "Sharvin")

Мы получим следующий вывод:

Username is 100
Age is Sharvin

Это не выглядит правильно. Что случилось Имя пользователя взял ценность 100 во время возраст взял ценность “Шарвина”. В таких сценариях, как это, где мы не знаем порядок аргументов, мы можем использовать аргументы ключевых слов при вызове функции:

>>> user_details(age=100, username="Sharvin")

Выход:

Username is Sharvin
Age is 100

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

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

>>> def user_details(username, age = None):
...     print("Username is", username)
...     print("Age is", age)
...

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

Давайте назовем функцию:

>>> user_details("Sharvin")

Выход:

Username is Sharvin
Age is None

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

>>> user_details("Sharvin", 200)
Username is Sharvin
Age is 200

Но что произойдет, если мы назначаем первый аргумент в нашей функции по умолчанию, а второй как обязательный аргумент? Перейдите на раковину Python и попробуйте это:

>>> def user_details(username=None, age):
...     print("Username is", username)
...     print("Age is", age)
...

Вы получите следующую ошибку:

  File "", line 1
SyntaxError: non-default argument follows default argument

Kwargs:

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

Использовать kwargs, мы поставили ** перед аргументом.

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

>>> def user(**username):
...     print(username)
...

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

>>> user(username1="xyz",username2="abc")

Выход:

{'username1': 'xyz', 'username2': 'abc'}

Так что здесь происходит? Это выглядит так же, как args, верно?

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

Рассмотрим этот пример:

>>> def user(**user_details):
...     print(user_details['username'])
...

Давайте назовем нашу функцию:

>>> user(username="Sharvin",age="1000")

И вы получите следующий вывод:

Sharvin

Сфера:

Область охвата определяет, где доступна переменная или функция. В Python есть два типа области применения: Global и Local.

Глобальный спектр

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

>>> greet = "Hello world"
>>> def testing():
...     print(greet)
...
>>> testing()
Hello world

Вот переменная приветствовать Доступен во всем мире, потому что он объявлен в теле программы.

Местный спектр

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

>>> def testing():
...     greet = "Hello world"
...     print(greet)
...
>>> testing()
Hello world

Здесь приветствовать Создан внутри функции тестирования и там доступен только. Давайте попробуем получить доступ к нему в нашем главном корпусе и посмотреть, что произойдет:

>>> print(greet)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'greet' is not defined

Помните: Перезапустите консоль Python, нажав Ctrl + D и снова запускаю оболочку, используя Python3 командовать перед тестированием кода выше. Первый пример вы объявляете приветствовать Переменная в глобальном объеме, что означает, что она все равно будет доступна в памяти, когда вы запускаете второй пример.

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

Обратный оператор:

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

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

>>> def add(a, b):
...     return a + b
...
>>> add(1,3)
4

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

>>> sum = add(5,10)
>>> print(sum)
15

Лямбда выражение:

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

Так что же самое выражение лямбда? Это анонимная функция, и они ограничены одним выражением. Выражение лямбда может принимать число аргументов.

Синтаксис для экспрессии лямбда:

variable = lambda arguments: operation

Давайте понять его больше по примеру:

>>> sum = lambda a: a + 10

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

Давайте назовем нашу функцию:

>>> x(5)
15

Понимание списка:

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

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

Есть два способа достичь этого. Давайте понять их обоих.

>>> squares = list(map(lambda x: x**2, range(10)))
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

>>> squares = list(x**2 for x in range(10))
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Я предпочитаю таким образом, потому что легче понять более лаконично и легче понять.

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

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

>>> num_list = []
>>> for i in range(10):
...     for j in range(10):
...             if i == j:
...                     num_list.append((i,j))
...
>>> num_list
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]

Это много работы. И с точки зрения читабельности трудно понять.

Давайте использовать список списков для достижения того же результата.

>>> num_list = list((i,j) for i in range(10) for j in range(10) if i == j)

>>> num_list
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]

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

Ооос понятия:

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

Другой подход к решению проблемы заключается в создании классов и объектов. Это известно как объектно-ориентированное ориентированное программирование. Объект представляет собой набор данных (переменных) и методы, которые действуют на эти данные. И классы – это план для каждого объекта.

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

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

Преимущества объектно-ориентированного программирования

• Наследование: Это одна из самых полезных концепций в Оопе. Он указывает, что дочерний объект будет иметь все свойства и поведение родительского объекта. Таким образом, наследство позволяет нам определить класс, который наследует все методы и свойства из другого класса.
• Полиморфизм: Чтобы понять полиморфизм, давайте разделим слово на две части. Первая часть «поли» означает множество и «морфин» означает образование или форму. Таким образом, полиморфизм означает, что одна задача может быть выполнена во многих различных способах. Например, у вас есть класс животное И все животные говорят. Но они говорят по-другому. Здесь поведение «Говоря» является полиморфным и зависит от животного. Итак, концепция абстрактных «животных» на самом деле не «говорит», но у специфических животных (таких как собаки и кошки) имеют бетонную реализацию действия «говорят». Полиморфизм означает одинаковое имя функции или имя метода, используемое для разных типов.
• Инкапсуляция: В объектно-ориентированном программировании вы можете ограничить доступ к методам и переменным – мы можем сделать методы и переменные частные. Это может предотвратить изменение данных случайно и известна как инкапсуляция.

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

Классы:

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

Но что, если у нас есть более сложные данные? Если есть шаблон в повторении свойств этих данных, что мы можем сделать?

Предположим, у нас есть 100 разных животных. У каждого животного есть имя, возраст, ноги и т. Д. Что, если мы хотим добавить другие свойства для каждого животного, или еще одно животное добавляется в этот список? Для управления таком сложным сценарием нам нужны занятия.

Согласно официальному Документация Python :

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

Синтаксис класса:

class ClassName:

    
    .
    .
    .
    

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

class Car:
    pass

Методы:

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

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

Программа ниже предоставит нам лучшее представление о классах:

>>> class Car:
...     def engine(self):
...             print("Engine")
...

>>> Car().engine()
Engine

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

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

Объекты:

Объект является экземпляром класса. Давайте рассмотрим вышеприведенный пример автомобиля. Здесь машина наша Класс и Toyota это объект из машины. Мы можем создавать несколько копий объекта. Каждый объект должен быть определен с использованием класса.

Синтаксис для создания объекта:

toyota = Car()

Давайте рассмотрим наши Автомобиль Пример, чтобы понять объекты немного лучше:

class Car:

    def engine(self):
        print("Engine")

    def wheel(self):
        print("Wheel")

toyota = Car()

Вышеуказанное Toyota () это Класс объекта Отказ Объекты класса поддерживают два вида операций: атрибуты ссылки и создания института.

Эксирование классов использует обозначение функции. Операция по созданию инсультации («Вызов» объект класса) создает пустой объект.

Теперь мы можем назвать разные методы из нашего класса Автомобиль Использование объекта Toyota что мы создали. Давайте назовем метод двигатель и колесо Отказ

Откройте свой редактор и создайте файл с именем mycar.py Отказ В этом файле скопируйте код ниже:

class Car:

    def engine(self):
        print("Engine")

    def wheel(self):
        print("Wheel")

if __name__ == "__main__":
    toyota = Car()
    toyota.engine()
    toyota.wheel()

Сохранить вышеуказанный код. Теперь давайте посмотрим нашу программу.

Здесь мы создаем Toyota объект с помощью Автомобиль класс. Toyota.engine () это объект метода. Что именно происходит, когда вызывается объект метода?

В звонке Toyota.engine () Не принимает аргумент, но если вы видите декларацию метода, мы видим, что это займет Я аргумент

Вы можете смущать, почему он не бросает ошибку. Хорошо, когда мы используем объект метода, вызов Toyota.engine () преобразуется в Car.engine (Toyota) Отказ Мы будем больше понимать о себе в предстоящем разделе.

Запустите программу, используя следующую команду.

python mycar.py

Вы получите следующий вывод:

Engine
Wheel

Конструктор:

__init__ Метод является методом конструктора в Python. Метод конструктора используется для инициализации данных.

Перейдите на Shell Python и введите этот пример:

>>> class Car():
...     def __init__(self):
...             print("Hello I am the constructor method.")
...

Когда мы позвоним нашему классу, мы получим следующий вывод:

>>> toyota = Car()
Hello I am the constructor method.

Примечание: Вам никогда не придется позвонить в init () Метод – он автоматически вызывается при создании экземпляра класса.

Атрибуты экземпляра:

Все классы имеют объекты и все объекты имеют атрибуты. Атрибуты являются свойствами. Мы используем __init __ () Способ указать начальный атрибут объекта.

Давайте рассмотрим наш пример автомобиля:

class Car():
    def __init__(self, model): 
        self.model = model  #instance attribute

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

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

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

class Car():

    no_of_wheels = 4 #class attribute

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

Себя:

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

Давайте посмотрим на пример того, как Я может быть использован. Давайте создадим метод имени Бренд Под нашим классом Автомобиль Отказ

Внутри этого __init__ Способ, мы передадим модель, передавая название модели нашего автомобиля, когда мы создаем наш объект. Это имя можно получить в любом месте в классе, например Self.Model в нашем случае.

Перейти к файлу с именем mycar.py и заменить старый код с этим кодом:

class Car(): 

  def __init__(self, model): 
    self.model = model
  		
  def brand(self): 
    print("The brand is", self.model)  

if __name__ == "__main__":
  car = Car("Bmw")
  car.brand()

Теперь, когда мы запускаем нашу вышеуказанную программу, используя следующую команду:

python mycar.py

Мы получим следующий вывод:

The brand is Bmw

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

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

Наследование относится к, когда класс наследует свойство другого класса.

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

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

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

class DerivedClassName(BaseClassName):
    
    .
    .
    .
    

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

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

Мы создадим базовый класс по имени Автомобиль :

class Vehicle:
    def __init__(self, name):
        self.name = name
    
    def getName(self):
        return self.name

Мы создали класс Автомобиль и создал конструктор с Self.name который мы используем в getname метод. Всякий раз, когда этот метод будет вызван, он вернет Имя это было передано, когда объект создается для этого класса.

Теперь давайте создадим детский класс Автомобиль :

class Vehicle:
    def __init__(self, name):
        self.name = name
    
    def getName(self):
        return self.name

class Car(Vehicle):
  pass

Автомобиль это детский класс Автомобиль Отказ Он наследует весь метод и атрибуты родительского класса.

Теперь давайте использовать методы и атрибут из Автомобиль Класс в нашем детском классе Автомобиль Отказ

class Vehicle:

    def __init__(self, name, color='silver'):
        self.name = name
        self.color = color
    
    def get_name(self):
        return self.name
    
    def get_color(self):
        return self.color

class Car(Vehicle):
  pass

audi = Car("Audi r8")
print("The name of our car is", audi.get_name(), "and color is", audi.get_color())

Давайте понять, что мы здесь сделали.

Мы объявили класс по имени Автомобиль С конструктором, который принимает имя в качестве аргумента, а цвет имеет аргумент по умолчанию.

У нас есть два метода внутри него. get_name Возвращает имя пока get_color Возвращает цвет. Мы создали объект и передали название автомобиля.

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

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

python mycar.py

Выход:

The name of our car is Audi r8 and color is silver

Мы также можем переопределить родительский метод или атрибут. В приведенном выше примере мы определили, что наш цвет автомобиля имеет серебро. Но что, если цвет нашей машины черный?

Теперь для каждого дочернего класса мы не можем внести изменения в родительский класс. Наступает главная функциональность.

class Vehicle:

    def __init__(self, name, color='silver'):
        self.name = name
        self.color = color
    
    def get_name(self):
        return self.name
    
    def get_color(self):
        return self.color

class Car(Vehicle):

    def get_color(self):
        self.color = 'black'
        return self.color

audi = Car("Audi r8")
print("The name of our car is", audi.get_name(), "and color is", audi.get_color()

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

Теперь, когда мы запускаем вышеуказанную программу, мы получим следующий вывод:

The name of our car is Audi r8 and color is black

Супер:

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

Призывая ранее построенные методы с Super () Сохраняет нас от необходимости переписать эти методы в нашем подклассе и позволяет нам поменять суперкласс с минимальными изменениями кода. Таким образом супер расширяет функциональность унаследованного метода.

Давайте расширим наш пример автомобиля, используя Super () Отказ Мы создам создание конструктора с brand_name и цвет В родительском классе Автомобиль Отказ Теперь мы назовем этот конструктор из нашего детского класса ( автомобиль ), используя супер Отказ Мы создадим get_description Метод, который возвращает Self.Model от Автомобиль класс и Self.brand_name , Self.color от Автомобиль класс.

class Vehicle:
 
    def __init__(self, brand_name, color):
        self.brand_name = brand_name
        self.color = color
 
    def get_brand_name(self):
        return self.brand_name
 
class Car(Vehicle):
 
    def __init__(self, brand_name, model, color):  
        super().__init__(brand_name, color)       
        self.model = model
 
    def get_description(self):
        return "Car Name: " + self.get_brand_name() + self.model + " Color:" + self.color
 
c = Car("Audi ",  "r8", " Red")
print("Car description:", c.get_description())
print("Brand name:", c.get_brand_name())

Когда мы запускаем вышеуказанную программу, мы получаем следующий вывод:

Car description: Car Name: Audi r8 Color: Red
Brand name: Audi

Многократное наследование:

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

Общий синтаксис многократного наследования выглядит следующим образом:

class DerivedClassName(Base1, Base2, Base3):
    
    .
    .
    .
    

Давайте расширим наш пример автомобиля, используя свойство нескольких наследований. Вот в этом примере мы создадим 3 класса I.e. Автомобиль , Стоимость и Машина

Классы Автомобиль и Стоимость будет родительский класс. А Автомобиль Класс представляет собой общее свойство, пока Стоимость Класс представляет свои цены.

Как Автомобиль Общая недвижимость и стоимость будет иметь два родительских класса. Таким образом, мы наследуем несколько родительских классов.

class Vehicle:

    def __init__(self, brand_name):
        self.brand_name = brand_name
    
    def get_brand_name(self):
        return self.brand_name


class Cost:		

    def __init__(self, cost):
        self.cost = cost
    
    def get_cost(self):
        return self.cost

 
class Car(Vehicle, Cost):	

    def __init__(self, brand_name, model, cost): 
        self.model = model 
        Vehicle.__init__(self, brand_name) 
        Cost.__init__(self, cost) 

    def get_description(self):
        return self.get_brand_name() + self.model + " is the car " + "and it's cost is " + self.get_cost()
		
c = Car("Audi ",  "r8", "2 cr")
print("Car description:", c.get_description())

Здесь вы найдете одну вещь в вышеуказанной программе, которая отличается от всех других программ в этом руководстве. Я использовал Транспортное средство .__ init __ (self, brand_name) в конструкторе Автомобиль класс. Это один из способов вызовов атрибутов из родительского класса. Еще один был супер который я объяснил выше.

Когда мы запустим вышеуказанную программу, мы получим следующий вывод:

Car description: Audi r8 is the car and it's cost is 2 cr

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

Полиморфизм:

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

Расшируем нашу автомобильную программу с использованием полиморфизма. Мы создадим два класса, Автомобиль и Велосипед Отказ Обе классы имеют общий метод или функцию, но они печатают разные данные. Программа довольно неясно:

class Car: 

    def company(self): 
        print("Car belongs to Audi company.")
   
    def model(self): 
        print("The Model is R8.") 
   
    def color(self): 
        print("The color is silver.") 
   
class Bike: 

    def company(self): 
        print("Bike belongs to pulsar company.") 
   
    def model(self): 
        print("The Model is dominar.") 
   
    def color(self): 
        print("The color is black.") 
  
def func(obj): 
    obj.company() 
    obj.model() 
    obj.color() 
   
car = Car() 
bike = Bike() 
   
func(car) 
func(bike)

Когда мы запустим вышеуказанный код, мы получим следующий вывод:

Car belongs to Audi company.
The Model is R8.
The color is silver.
Bike belongs to pulsar company.
The Model is dominar.
The color is black.

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

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

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

Пример 1:

class Car:

  def __init__(self): 
    self.brand_name = 'Audi '
    self.model = 'r8'
    self.__engine = '5.2 L V10'
    
  def get_description(self):
        return self.brand_name + self.model + " is the car"
  
c = Car()
print(c.get_description)
print(c.__engine)

В этом примере Я .__ Двигатель является частным атрибутом. Когда мы запускаем эту программу, мы получим следующий вывод.

Audi r8 is the car
AttributeError: 'Car' object has no attribute '__engine'

Мы получаем ошибку, что Автомобиль Объект не имеет _Engine, потому что это частный объект.

Пример 2:

Мы также можем определить частный метод, добавив __ Перед именем метода. Ниже приведен пример того, как мы можем определить личный метод.

class Car:

  def __init__(self):
      self.brand_name = 'Audi '
      self.model = 'r8'

  def __engine(self):
      return '5.2 L V10'

  def get_description(self):
      return self.brand_name + self.model + " is the car"
    
    
c = Car()
print(c.get_description())
print(c.__engine()) 

В этом примере Def __engine (Self) является частным методом. Когда мы запускаем эту программу, мы получим следующий вывод.

Audi r8 is the car
AttributeError: 'Car' object has no attribute '__engine'

Теперь предположим, что мы хотим получить доступ к частным атрибуте или методу, мы можем сделать это следующим образом:

class Car:

  def __init__(self):
      self.brand_name = 'Audi '
      self.model = 'r8'
      self.__engine_name = '5.2 L V10'

  def __engine(self):
      return '5.2 L V10'

  def get_description(self):
      return self.brand_name + self.model + " is the car"
    
    
c = Car()
print(c.get_description())
print("Accessing Private Method: ", c._Car__engine()) 
print("Accessing Private variable: ", c._Car__engine_name)

Выход следующей программы:

Audi r8 is the car
Accessing Private Method:  5.2 L V10
Accessing Private variable:  5.2 L V10

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

Декоратор:

Представьте, что вы должны продлить функциональность нескольких функций. Как вы это сделаете?

Ну, в один из способов есть, вы можете сделать функциональные звонки и в этой функции вы можете справиться с ним. Внесение изменений в от 30 до 40 вызовов функций и запоминание, где разместить звонок – это грязная задача. Но более элегантный способ, предоставляемый Python, с декораторами.

Что такое декоратор? Декоратор – это функция, которая принимает функцию и расширяет его функциональность без изменений в нем явно. Ну, я понимаю, если вы все еще запутались о том, какие декораторы есть. Не волнуйтесь – у нас есть инструмент по имени пример, чтобы объяснить его.

Давайте попробуем пример, чтобы понять декоратор. Есть два способа написать декоратор.

Метод 1.

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

>>> def my_decorator(func):
...     def wrapper():
...             print("Line Number 1")
...             func()
...             print("Line Number 3")
...     return wrapper
...
>>> def say_hello():
...     print("Hello I am line Number 2")
...

Чтобы вызвать функцию, мы назначаем декоратор с Say_Hello как аргумент.

>>> say_hello = my_decorator(say_hello)

Мы также можем проверить ссылку, используя Say_Hello Отказ Мы получим вывод, который сообщает нам, что он был обернут my_decorator функция.

.wrapper at 0x10dc84598>

Давайте позвоним наше Say_Hello Функция:

>>> say_hello()
Line Number 1
Hello I am line Number 2
Line Number 3

Смотрите волшебную линию «Hello I A Mon Line Number 2» напечатана между строкой № 1 и 3, потому что вызов функции выполняется там.

Метод 1 – неуклюжий, и из-за того, что многие люди предпочитают другой подход.

Метод 2.

Здесь наша декораторская декларация остается той же, но мы изменяем, как вызов назначен на этот декоратор. Какая функция требует, чтобы декоратор охватил себя @decorator_name Отказ

>>> def my_decorator(func):
...     def wrapper():
...             print("Line Number 1")
...             func()
...             print("Line Number 3")
...     return wrapper
...
>>> @my_decorator
... def say_hello():
...     print("Hello I am line Number 2")
...
>>> say_hello()

Вывод такой же:

Line Number 1
Hello I am line Number 2
Line Number 3

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

• Настройка регистратора
• Настройка конфигурации
• Установка ошибки ловить
• Расширение общей функциональности для всех функций и классов

Исключения:

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

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

try:
	expression
except:
	catch error

Давайте понять это на примере:

>>> try:
...     print(value)
... except:
...     print("Something went wrong")
...

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

Something went wrong

Вы можете думать, что линия «что-то пошло не так», не так полезно. Так как мы можем знать, что пошло не так?

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

>>> try:
...     print(value)
... except Exception as e:
...     print(e)
...

И в результате есть:

name 'value' is not defined

WHOA! Это волшебство. Уведомление, что «ценность» не определена.

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

>>> i = 5
>>> if i < 6:
...     raise Exception("Number below 6 are not allowed")
...

Выход, который мы получаем следующим образом:

Traceback (most recent call last):
  File "", line 2, in 
Exception: Number below 6 are not allowed

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

Импорт пакета:

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

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

Создать два файла с именем main.py и Hello.py Отказ Помните, что оба файла должны быть в одном каталоге.

Под Hello.py Скопируйте вставку следующего кода:

def say_hello():
    print("Hello world")

Под main.py Скопируйте вставку следующего кода:

import hello

if __name__ == "__main__":
    hello.say_hello()

В Hello.py Мы объявили say_hello () Функция, которая печатает «Hello World». В main.py Вы увидите оператор импорта. Мы импортируем Hello модуль и позвонив say_hello () функционируйте из этого модуля.

Запустите нашу программу, используя следующую команду:

➜ python main.py

Выход:

Hello world

Теперь давайте понять, как импортировать модуль, который находится в другом каталоге.

Давайте создадим каталог с именем «Данные» и переместить наш Hello.py внутри этого каталога.

Перейти к main.py и изменить предыдущее утверждение импорта.

from data import hello

if __name__ == "__main__":
    hello.say_hello()

Есть два способа импорта из каталога.

• Метод 1: от импорта данных Hello
• Способ 2: Импорт data.hello.

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

Давайте запустим наше приложение, используя следующую команду:

➜ python main.py

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

Traceback (most recent call last):
  File "main.py", line 1, in 
    from data import hello
ImportError: No module named data

Ну, Python говорит нам, что он не распознает модуль с именем данных. Чтобы решить эту проблему Создать __init__.py Внутри каталога данных. Оставьте файл пустым и запустите программу снова, и вы получите следующий вывод:

Hello world

Хорошо Python по умолчанию не относится к каталогу как модуль. Чтобы сообщить Python для обработки каталога в качестве модуля, __init__.py требуется.

JSON обработка:

Если вы ранее работали в разработке веб-разработки или приложения, вы можете знать, что все вызовы API происходят в формате JSON. Пока Джосон выглядит похоже на словарь в Python, помните, что это совсем другое.

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

import json

Эта библиотека предоставляет два метода, которые помогают нам в обращении с JSON. Давайте понять их один за другим.

JSON Грузы:

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

>>> import json
>>> json_string = '{ "user_name":"Sharvin", "age":1000}' #JSON String
>>> type(json_string)

>>> data = json.loads(json_string)
>>> type(data)

>>> data
{'user_name': 'Sharvin', 'age': 1000}

JSON DUMPS:

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

>>> jsonString = json.dumps(data)
>>> type(jsonString)

>>> jsonString
'{"user_name": "Sharvin", "age": 1000}'

Чтобы узнать больше о манипуляции JSON, пройдите через Документация Python Отказ

Это оно!

И мы закончили! Я надеюсь, что теперь вы понимаете основы Python. Поздравляю! Это огромное достижение.

Обратная связь приветствуется. Также, если вы хотите узнать о любой другой теме, вы можете твитнуть название темы в Twitter и включить мою ручку Twitter. [ @ Sharvinshah26 Несомненно