1. Объектно-ориентированный и процессно-ориентированный

объектно-ориентированное программирование（Object-Oriented Programming,аббревиатураOOP）ипроцессно-ориентированное программирование（Procedural Programming,аббревиатураPP）это два разныхпарадигма программирования。

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

иПроцессно-ориентированное программирование — это процессно-ориентированный подход к программированию.,Он разбивает проблему на ряд шагов.,Затем выполните следующие действия по порядку,для достижения цели решения проблем。существоватьпроцессно-ориентированное В программировании данные и действия разделены, а функция является основным средством обработки данных. процессно-ориентированное программирование уделяет больше внимания эффективности и скорости и подходит для небольших, простых программ или сценариев с высокими требованиями к производительности.

1. Что такое ориентация на процесс?

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

в соответствии сориентированный на процессмысли：Требуется три шага Шаг первый: откройте холодильник Шаг 2: Нафаршируйте слона Шаг 3: Закройте холодильник

Отсюда видно: ориентация процесса заключается в реализации чего-то шаг за шагом.

Реализация кода:

# Шаг первый: откройте холодильник Дверь
def open_door():
    print("Откройте дверцу холодильника")

# Шаг 2. Добавьте слон.
def put_elephant():
    print("Вставьте слон")

# Шаг 3. Закройте дверцу холодильника.
def close_door():
    print("Закройте дверцу холодильника")

# Выполните три шага
def put_elephant_in_fridge():
    open_door()
    put_elephant()
    close_door()

# процедура испытания
put_elephant_in_fridge()

Это конкретная реализация процедурного кода.

2. Что такое объектно-ориентированный?

объект：Это абстракция рассматриваемых вещей объект Можно сказать, что это что-то реальноеабстрактное картографирование。 Столкновение с объектом：Это значит абстрагировать все вещи реальности в“объект”。каждыйобъектединственный,И все может иметь свои свойства и поведение. Мы можем решить проблему, вызвав эти метод и свойство объекта.

Согласно объектно-ориентированному мышлению

В этом примере: мы можем поставитьслонрассматривается какобъект,холодильникрассматривается какобъект。 холодильник Некоторые функции：открыть дверь、устанавливать объекты、закрыть дверь

class Elephant:  # слондобрый
    def Eat(self):  # есть
        print('есть')

class Fridge:  # холодильникдобрый
    def open_door(self):  # Открытьхолодильник Дверь        print('Откройте дверцу холодильника')
    
    def Put_In(self):  # вставь что-нибудь
        print('вставь что-нибудь')
    
    def close_door(self):  # закрытиехолодильник Дверь        print('Закройте дверцу холодильника')

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

Столкновение с объектомобъект Характеристики：Имеет хорошую пластичность,напримеря даюслонучитываяестьфункция,Это можно сделать, позвонивсуществоватьхолодильник Зайти внутрьестьвещь。Столкновение с объектом — это абстрагировать реальные проблемы в объект,Решите задачу, вызвав функцию свойстваили каждого объекта.

2. Классы и объекты

1. Первое знакомство с объектом

Что такое объект? объектдаобъектно-ориентированное концепция в программировании,этодадобрыйодин изРезультат создания экземпляра (т.е. конкретизации)。объектдаспецифический、фактически существующий,Можетсуществоватьпрограммасерединаодеялосоздавать、действоватьиразрушать。 объектно-ориентированное программированиесередина,объектда Зависит отсвойство иметодсостоит из。Свойство представляет состояние и характеристики объекта, а метод представляет действия и поведение, которые может выполнять объект.。 каждыйобъектвсе принадлежат кому-тодобрый,добрый — это абстракция объекта,он определяетобъектодержимыйсвойствоиметодизструктура и поведение。объектпутем создания экземплярадобрый Приходитьсоздавать,И к свойству и методу можно получить доступ и вызвать в соответствии с определением доброго.

Вот простой пример:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print(f"Hello, меня зовут {self.name}.")

# Создайте два объекта Person
person1 = Человек("Чжан Сан", 25)
person2 = Person("Ли Си", 30)

# метод, вызывающий объект
person1.say_hello()  # Выход: Hello, меня зовут Чжан Сан.
person2.say_hello()  # Выход: Hello, меня зовут Джон Доу.

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

2. Методы членов класса

2.1 Определение и использование классов

на питоне,Используйте ключевые словаclassПриходитьопределениедобрый

# Определите добрый метод с членом
class Student:
    # членпеременная    name = None  # имя студента
    # Метод определения
    def say_hi1(self):
        print(f'Всем привет,меня зовут{self.name}')  # Чтобы получить доступ к переменной-члену в методе-члене, вы должны использовать ключевое слово self!

    def say_hi2(self, msg):
        print(f'Привет всем, я {self.name},{msg}')  # msg передается извне, поэтому вам не нужно использовать self!

stu1 = Student()
stu1.name = 'Чжан Сан'
stu1.say_hi1()
stu2 = Student()
stu2.name = «Джон Доу»
stu2.say_hi2('Пожалуйста, позаботьтесь обо мне')

Результаты запуска:

Как видно, в классе:

• Вы можете не только определить свойство для записи данных
• Также можно определить функцию,используется для записи поведения

в:

• свойство (переменная), определенное в добром, мы называем его: член переменная
• Поведение, определенное в добром (функция),Мы называем это: метод-член

2.2 Методы-члены

грамматика： Определение методов-членов в классе по сути аналогично определению функций, с небольшими отличиями:

Уведомление: Ключевое слово self используется при определении метода-члена.,Необходимыйиз。

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

Например:

class Student:
    # членпеременная    name = None  # имя студента
    # Метод определения
    def say_hi(self):
        print(f'Всем привет,меня зовут{self.name}')

class Student:
    # членпеременная    name = None  # имя студента
    def say_hi(self, msg):
        print(f'Привет всем, {msg}')  # msg передается извне, поэтому вам не нужно использовать self!
        
stu = Student()
stu.say_hi('Пожалуйста, позаботьтесь обо мне')

Вы можете видеть, что при передаче параметров self не передается, но об ошибках не сообщается.

3. Классы и объекты

на основе хорошего объектаизграмматика:

Имя Объекта = Хорошее Имя()

Почему вам нужно создать объект, прежде чем вы сможете его использовать?

добрый - это просто встроенная программа "Проектные чертежи”илиинструмент,Необходимость создания объектов на основе чертежей и слепков (объектов),Только тогда эта процедура сможет работать правильно,позвони это：объектно-ориентированное программирование

Приведите простой пример: добрыйэквивалентнода БудильникизПроектные чертежи,иобъектэквивалентнов соответствии с Будильникиз Проектные чертежипроизведено ПриходитьизБудильник。

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

4. Магические методы

Встроенный добрыйметод,Каждый имеет свои особые функции,Эти встроенныеметоднаспозвони это：магияметод Распространенные магические методы:

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

общийизмагический метод

1. _ _ inint _ _ конструктор

class Student:
    name = None  # Имя
    age = None  # возраст
    tel = None  # Номер телефона

stu1 = Student()
stu1.name = 'Чжан Сан'
stu1.age = 18
stu1.tel = "1686400001"
stu2 = Student()
stu2.name = «Джон Доу»
stu2.age = 19
stu2.tel = "163200002"

В приведенном выше коде,Присвоение значения свойству объекта должно выполняться последовательно.,Немного громоздкий。Можно ли напрямую присвоить значение свойству за один раз, как функция передает параметры? Отвечатьдаподтверждатьиз,Нужно использовать конструкциюметод：_ _ init _ _()

Pythonдобрый Можно использовать：_ _ init _ _() метод, называемый методом конструктора. Может быть достигнуто:

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

class Student:
    # Член объекта
    """
    Член переменная объявляется и назначается в методе структуры __init__.
    так Член объект здесь можно опустить
    """
    name = None
    age = None
    tel = None

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel
        print('Studentдобрыйсоздавать Понятнодобрыйобъект')  # Результат: Студент создает хороший объект.

stu1 = Student('Чжан Сан', '18', '13066660')
print(stu1.name)  # Результат: Чжан Сан
print(stu1.age)  # Выход: 18
print(stu1.tel)  # Выход: 13066660

Уведомление: Чтобы определить переменные-члены внутри конструктора, вам необходимо использовать ключевое слово self.

Это связано с тем, что переменная определена внутри конструктора. Если она хочет стать переменной-членом, ее необходимо представить как self.

2. _ _ str _ _ Строковый метод

• методимя：_ _ str _ _
• Возвращаемое значение: строка
• Содержание: Настройте самостоятельно

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

stu1 = Student('Чжан Сан', 18)
print(stu1)  # выход：<__main__.Student object at 0x000001EDFFB09FD0>
print(str(stu1))  # выход：<__main__.Student object at 0x000001EDFFB09FD0>

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

Адрес памяти мало что делает, мы можем пройти _ _ str _ _ Метод, управляющий поведением класса при преобразовании в строку.

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def __str__(self):
        return f'name:{self.name}, age:{self.age}'
        
stu1 = Student('Чжан Сан', 18)
print(stu1)  # Вывод: имя: Чжан Сан, age:18
print(str(stu1))  # Вывод: имя: Чжан Сан, age:18

3. _ _ lt _ _ Метод сравнения знаков меньше

• методимя：_ _ lt _ _
• Входящие параметры: другой, другой добрыйобъект
• Возвращаемое значение: True или False.
• Содержание: Настройте самостоятельно

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

stu1 = Student('Чжан Сан', 18)
stu2 = Student(«Джон Доу», 19)
print(stu1 < stu2)
print(stu1 > stu2)

Невозможно напрямую сравнить два объекта таким образом.

реализовано в классе _ _ lt _ _ Метод позволяет одновременно выполнить два сравнения: знак меньше и знак больше.

• методимя：_ _ lt _ _
• Входящие параметры: другой, другой добрыйобъект
• Возвращаемое значение: True или False.
• Содержание: Настройте самостоятельно

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # __lt__магический метод: Сравните два добрых объекта больше или меньше
    def __lt__(self, other):
        return self.age < other.age

stu1 = Student('Чжан Сан', 18)
stu2 = Student(«Джон Доу», 19)
print(stu1 < stu2)  # Вывод: правда
print(stu1 > stu2)  # Выход: Ложь

Сравнивать大于символ号измагияметодда：_ _ gt _ _, метод и _ _ lt _ _ Тоже самое, так это реализовано _ _ lt _ _ ,_ _gt _ _ Нет необходимости его реализовывать.

4. _ _ le _ _ Метод символа сравнения меньше или равен

Это и _ _ lt _ _ То же самое, с той лишь разницей, что _ _ lt _ _ является сравнением больше или меньше, и _ _ le _ _ Он сравнивает больше или равно и меньше или равно.

• методимя：_ _ le _ _
• Входящие параметры: другой, другой добрыйобъект
• Возвращаемое значение: True или False.
• Содержание: Настройте самостоятельно

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    # __lt__магический метод: Сравните два добрых объекта больше или меньше
    def __lt__(self, other):
        return self.age < other.age
        
stu1 = Student('Чжан Сан', 18)
stu2 = Student(«Джон Доу», 19)
print(stu1 <= stu2)
print(stu1 >= stu2)

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    # __lt__магический метод: Сравните два добрых объекта больше или меньше
    def __lt__(self, other):
        return self.age < other.age

	# __le__магический метод: Сравните два добрых объекта, которые больше или равны или меньше или равны
    def __le__(self, other):
        return self.age <= other.age

stu1 = Student('Чжан Сан', 18)
stu2 = Student(«Джон Доу», 19)
print(stu1 <= stu2)  # Вывод: правда
print(stu1 >= stu2)  # Выход: Ложь

5. _ _ eq _ _ Метод сравнения равенства

• методимя：eq
• Входящие параметры: другой, другой добрыйобъект
• Возвращаемое значение: True или False.
• Содержание: Настройте самостоятельно

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
stu1 = Student('Чжан Сан', 18)
stu2 = Student(«Джон Доу», 19)
print(stu1 == stu2)  # Выход: Ложь

Не реализовано _ _ eq _ _ метод,Сравнения также могут быть сделаны между объектом,нодада Сравниватьадрес памяти,Также сразуда：Сравнение различных объектов== должно давать ложный результат.。

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    # __eq__магический метод: Сравните два добрых объекта на равенство
    def __eq__(self, other):
        return self.age == other.age
stu1 = Student('Чжан Сан', 18)
stu2 = Student(«Джон Доу», 18)
print(stu1 == stu2)  # Вывод: правда

Осуществленный _ _ eq _ _ метод, вы можете решить, равны ли два объекта, в соответствии с вашими собственными представлениями.

3. Три основные характеристики объектно-ориентированного подхода: инкапсуляция, наследование, полиморфизм.

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

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

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

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

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

• частный членпеременная
• частный членметод

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

• частный членпеременная：переменнаяимяк__начало（2подчеркнуть）
• частный членметод: имя метода начинается с __ (2 подчеркивания)

class Phone:
    IMEI = None  # серийный номер
    producer = None  # Производитель
    # частный членпеременная
    __current_voltage = None  # Текущее напряжение

    def call_by_5g(self):
        print('Вызов 5G включен')
	
	# частный членметод
    def __keep_5g(self):
        print('держать 5g')

Частные методы не могут использоваться напрямую объектами класса.

phone = Phone()
phone.__keep_5g()

использоватьчастный член

class Phone:
    # структураметод    def __init__(self, __is_5g_enable):
        # Установить приватныйпеременная        self.__is_5g_enable = __is_5g_enable

    # Настроить частный метод
    def __check_5g(self):
        if self.__is_5g_enable == True:  # добрыйвнутренний доступчастный Использовать себя для члена
            печать('5G включен')
        else:
            print('5G выключен, используйте сеть 4G')

    def call_by_5g(self):
        self.__check_5g()
        print('Вызов...')

phone = Phone(False)
phone.call_by_5g()

2. Наследование

Наследование：наследоватьпозволятьдобрый（ребенокдобрый）наследовать Другойдобрый（отецдобрый）изсвойствоиметод,Дочерний добрый может повторно использовать код родительского доброго.,并且Можетсуществовать Не изменяйте исходный кодиз Развернуть в случаеи Исправлять。 Простой Приходить说Сразудадобрый,наследовать Другой участник доброго переменного и метода-члена

Приведите простой пример： Модернизация мобильных телефонов – это не полная перезагрузка, а добавление каких-то новых атрибутов и функций на основе исходных.

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

наследоватьразделен на：Единое наследованиеимножественное наследование

Единое наследованиеграмматика：

class добрыйимя(отецдобрый):
	добрыйтело контента

# Единое наследование Демо
# Определите родительский добрый
class Phone:
    IMEI = None  # серийный номер
    producer = 'APPLE'  # Производитель

    def call_by_4g(self):
        print('вызов 4G')

# Определение субдобрый
class Phone2022(Phone):
    face_id = '10001'

    def call_by_5g(self):
        print('вызов 5G')

phone = Phone2022()
phone.call_by_4g()  # Выход: звонок 4G.
print(phone.producer)  # Выход: ЯБЛОКО
phone.call_by_5g()  # Выход: звонок 5g.
print(phone.face_id)  # Выход: 10001

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

Синтаксис множественного наследования Классы Python также поддерживают множественное наследование, то есть один класс может наследовать несколько родительских классов.

class добрыйимя(отецдобрый1,отецдобрый2,отецдобрый3, ... ,отецдобрыйN):
	добрыйтело контента

Пример:

# множественное наследование Демо
# Определите родительский добрый
class Phone:
    IMEI = None  # серийный номер
    producer = 'HM'  # Производитель

    def call_by_4g(self):
        print('вызов 4G')

class NFCReader:
    nfc_type = «пятое поколение»
    producer = 'HM'

    def read_card(self):
        print('Читать карту NFC')

    def write_card(self):
        print('Запись на NFC-карту')

class RemoteControl:
    rc_type = «Инфракрасный пульт дистанционного управления»

    def control(self):
        print('Инфракрасный пульт дистанционного управления включен')

# Определение субдобрый
class MyPhone(Phone, NFCReader, RemoteControl):
    pass

phone = MyPhone()
print(phone.producer)  # Выход: ХМ
print(phone.nfc_type)  # Выход: пятое поколение
phone.read_card()  # Выход: прочитать NFC-карту.
phone.call_by_4g()  # Выход: звонок 4G.
phone.control()  # Выход: инфракрасный пульт дистанционного управления включен.

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

передать заявление passдазаявление-заполнитель,использовать ПриходитьгарантироватьПолнота определения функции (метода)илидобрый,выражатьНет содержания, то есть пусто。

Копировать После того как свойство-член и метод-член дочернего элемента добрый следуют родительскому доброму, если они «неудовлетворены», то можно выполнить Копирование. То есть: просто переопределить одноимённое свойство или метод в подклассе.

# Определите родительский добрый
class Phone:
    IMEI = None  # серийный номер
    producer = 'APPLE'  # Производитель

    def call_by_4g(self):
        print('вызов 4G')

# Определение субдобрый
class MyPhone(Phone):
    producer = 'HUAWEI'  # Копироватьотецдобрыйсвойство    def call_by_4g(self):  # Копироватьотецдобрыйметод        print('Доступны вызовы 5G')

phone = MyPhone()
print(phone.producer)  # Выход: HUAWEI
phone.call_by_4g()  # Вывод: доступны звонки 5G.

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

Способ первый:

• Позвонить родителю использоватьчленпеременная：отецдобрыйимя.членпеременная использоватьчленметод：отецдобрыйимя.членметод(self)

Способ второй:

• использоватьsuper()Позвонить родителю использоватьчленпеременная：super().членпеременная использоватьчленметод：super().членметод()

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

# Определите родительский добрый
class Phone:
    IMEI = None  # серийный номер
    producer = 'APPLE'  # Производитель

    def call_by_4g(self):
        print('вызов 4G')

# Определение субдобрый
class MyPhone(Phone):
    producer = 'HUAWEI'  # Копироватьотецдобрыйсвойство    def call_by_4g(self):  # Копироватьотецдобрыйметод        print('Доступны вызовы 5G')
        # 调использоватьотецдобрыйсвойствоиметод        # метододин        # print(f'调использоватьотецдобрыйсвойство[1]:{Phone.producer}')  # 调использоватьотецдобрыйсвойство        # Phone.call_by_4g(self)  # 调использоватьотецдобрыйметод        # методдва        print(f'调использоватьотецдобрыйсвойство[2]:{super().producer}')  # 调использоватьотецдобрыйсвойство        super().call_by_4g()  # 调использоватьотецдобрыйметодphone = MyPhone()
print(phone.producer)
phone.call_by_4g()

3. Полиморфизм

Полиморфизм：Полиморфизмделатьобъект Может根据上下文表现出不同из Поведение,Один и тот же метод может иметь разные реализации для разных объектов.。这样Может提高代码изгибкостьи可复использовать性。 То есть: несколько состояний, то есть при выполнении определенного поведения использование разных объектов приведет к разным состояниям.

Как понять?

Одно и то же поведение (функция), переходя в разные объекты, приводит к разным состояниям.

Полиморфизм часто работает с отношениями наследования. например

• функция(метод)Катасан Заявление о полученииотецдобрыйобъект
• Дочерний добрыйобъект родительского доброго фактически передается для работы.

Прямо сейчас:

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

Абстрактный класс (интерфейс) абстрактныйдобрый：содержатьабстрактныйметодиздобрыйпозвони этоабстрактныйдобрый абстрактныйметод：методтелодаПустая реализация (пройти) назовите это абстрактным методом

Пример：

# абстрактныйдобрый
# Определите родительский добрый
class AC:
    def cool_wind(self):
        """Охлаждение"""
        pass

    def hot_wind(self):
        """Обогрев"""
        pass

    def swing_l_r(self):
        """Раскачивание влево и вправо"""
        pass

class Midea_AC(AC):
    def cool_wind(self):
        print('Кондиционирование и охлаждение Midea')

    def hot_wind(self):
        print('Кондиционер и отопление Midea')

    def swing_l_r(self):
        print('Кондиционер Midea качает воздух влево и вправо')

class GREE_AC(AC):
    def cool_wind(self):
        print('Gree Кондиционеры и Холодильники')

    def hot_wind(self):
        print('Gree Кондиционер и Отопление')

    def swing_l_r(self):
        print('Кондиционер Gree качает воздух влево и вправо')

def cool_wind(ac: AC):
    ac.cool_wind()

# создаватьобъект
midea = Midea_AC()
gree = GREE_AC()
cool_wind(midea)  # Результат: кондиционирование и охлаждение Midea.
cool_wind(gree)  # Результат: Gree кондиционирование и охлаждение.

4. Введите аннотации

При написании кода в PyCharm мы часто видим следующие подсказки:

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

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

1. Введите аннотацию переменных

Базаграмматика: переменная: тип Установите аннотации для переменных. Определение отображаемой переменной обычно не требует аннотаций.

# переменнаяизтип Примечание
var1: int = 10
var2: str = 'Чжан Сан'
var3: bool = True

Как и выше: Даже если вы не пишете аннотацию, вы все равно четко знаете тип переменной.

2. Основные аннотации типов контейнеров

# Типнотация базового контейнера
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"name": «Чжан Сан»}

# Подробная аннотация типа контейнера
my_list1: list[int] = [1, 2, 3]
my_tuple1: tuple[int, str, bool] = (1, «Чжан Сан», True)
my_dict1: dict[str, str] = {"name": «Чжан Сан»}

Уведомление:

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

3. Аннотация типа объекта класса

# добрыйобъекттипаннотация
class Student:
    pass

stu: Student = Student()

4. Введите аннотации для параметров функции и возвращаемых значений.

функцияиметодиз Катасантипаннотацияграмматика:

def функцияимя(Катасан1: тип, Ката ссылка 2: тип, ..., Формальный параметр n: тип):
	pass

# функция Катасанизтипаннотация
def add(x: int, y: int):
    return x + y

Аннотация возвращаемого значения грамматика：

def функцияимя(Катасан1: тип, Ката ссылка 2: тип, ..., Формальный параметр n: тип) -> Тип возвращаемого значения:
	pass

# типнотация для формальных параметров и возвращаемых значений
def fnuc(data: list) -> list:
    return data

Помимо использования переменная: тип,Эта грамматика — Делатьаннотацияснаружи.,Также типнотация в комментариях。

грамматика：# type: тип

# типнотация в комментариях
var_1: random.randint(1, 10)  # type: int
var_2: json.loads('{"name": «Чжан Сан»}')  # type: dict

5. Аннотация типа объединения типа объединения

Union тип используется для обозначения переменной, которая может быть одним из нескольких типов. Unionсоединениетипаннотация,существоватьпеременнаяаннотация、функция（метод）Катасани Аннотация возвращаемого Может использоваться в значениях.

Как использовать Союз Пакет гида：from typing import Union грамматика:Union[тип, …, тип]

# Чтобы использовать Uniontype, вам необходимо сначала упаковать
from typing import Union

my_list: list[Union[int, str, dict]] = [1, 2, 'name', {"age": 18}]
my_dict: dict[str, Union[int, str, list]] = {"name": «Чжан Сан», "age": 18, "grade": [98, 97]}
my_list1: list[Union[int, str, dict[Union[str, int]]]] = [1, 2, 'name',{"age": 18}]

# функцияизUnionтип
def func(data: Union[int, str]) -> Union[int, str]:
    return data