функция

определение функции

Функция начинается с ключевого слова def, за которым следует имя функции и круглые скобки ().
Код, выполняемый функцией, начинается с двоеточия и имеет отступ.
return [выражение] Завершает функцию, при необходимости возвращая значение вызывающей стороне. return без выражения эквивалентен возврату None

грамматика

def functionname (parameters):
       "函数文档字符串"
        functionsuite
        return [expression]

вызов функции

def printme(str):
    print(str)


printme("我要调用用户自定义函数!")  # 我要调用用户自定义函数!
printme("再次调用同一函数")  # 再次调用同一函数
temp = printme('hello') # hello
print(temp)  # None

функциональная документация

def MyFirstFunction(name):
    "函数定义过程中name是形参"
    # 因为Ta只是一个形式，表示占据一个参数位置
    print('传递进来的{0}叫做实参，因为Ta是具体的参数值！'.format(name))


MyFirstFunction('老马的程序人生')  
# 传递进来的老马的程序人生叫做实参，因为Ta是具体的参数值！

print(MyFirstFunction.__doc__)  
# 函数定义过程中name是形参

help(MyFirstFunction)
# Help on function MyFirstFunction in module __main__:
# MyFirstFunction(name)
#    函数定义过程中name是形参

параметр функции

позиционный аргумент

def functionname(arg1):
       "函数文档字符串"
       functionsuite
       return [expression]

arg1 - позиционные аргументы, которые нужно зафиксировать в позиции при вызове функции

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

def functionname(arg1, arg2=v):
       "函数文档字符串"
       functionsuite
       return [expression]

arg2 = v - параметр по умолчанию = значение по умолчанию.При вызове функции значение параметра по умолчанию считается значением по умолчанию, если оно не передано.
Параметры по умолчанию должны быть размещены после позиционных параметров, иначе программа сообщит об ошибке.
Python позволяет вызывать функции в другом порядке, чем они объявлены, потому что интерпретатор Python может сопоставлять значения параметров с именами параметров

переменный аргумент

def functionname(arg1, arg2=v, *args):
       "函数文档字符串"
       functionsuite
       return [expression]

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

аргумент ключевого слова

def functionname(arg1, arg2=v, args, *kw):
       "函数文档字符串"
       functionsuite
       return [expression]

**kw - аргументы ключевых слов, могут быть от нуля до любых, автоматически собираются в словарь

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

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

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

имя ключевое слово аргумент

def functionname(arg1, arg2=v, args, *, nkw, *kw):
       "函数文档字符串"
       functionsuite
       return [expression]

*, nkw — именованные аргументы ключевого слова, аргументы ключевого слова, которые пользователь хочет ввести, определяемые добавлением разделителя * перед nkw
Если вы хотите ограничить имена аргументов ключевого слова, вы можете использовать «именованные аргументы ключевого слова».
При использовании именованных аргументов ключевого слова будьте осторожны, чтобы не пропустить имя аргумента.
Имя параметра nwk не пишется, поэтому 10 считается "позиционным параметром", а исходная функция имеет только 1 позиционную функцию, а теперь вызывается 2, поэтому программа сообщит об ошибке

комбинация параметров

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

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

Обратите внимание на синтаксис для определения аргументов с переменным числом аргументов и ключевых слов:

*args — переменный параметр, и args получает кортеж
**kw — параметр ключевого слова, а kw получает dict

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

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

возвращаемое значение функции

def add(a, b):
    return a + b
print(add(1, 2))  # 3
print(add([1, 2, 3], [4, 5, 6]))  # [1, 2, 3, 4, 5, 6]

# 例2
def back():
    return [1, '小马的程序人生', 3.14]
print(back())  # [1, '小马的程序人生', 3.14]

# 例3
def back():
    return 1, '小马的程序人生', 3.14
print(back())  # (1, '小马的程序人生', 3.14)

# 例4
def printme(str):
    print(str)
temp = printme('hello') # hello
print(temp) # None
print(type(temp))  # <class 'NoneType'>

переменная область видимости

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

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)  # 1
    num = 123
    print(num)  # 123
fun1()
print(num)  # 123

встроенная функция

def outer():
    print('outer函数在这被调用')
    def inner():
        print('inner函数在这被调用')
    inner()  # 该函数只能在outer函数内部被调用
outer()
# outer函数在这被调用
# inner函数在这被调用

Закрытие

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

def funX(x):
    def funY(y):
        return x * y

    return funY


i = funX(8)
print(type(i))  # <class 'function'>
print(i(5))  # 40

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

def outer():
    num = 10
    def inner():
        nonlocal num  # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

# 100
# 100

рекурсия

Функция является рекурсивной, если она внутренне вызывает сама себя

Факториал п! = 1 х 2 х 3 х ... х п

# 利用循环
n = 5
for k in range(1, 5):
    n = n * k
print(n)  # 120

# 利用递归
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)
print(factorial(5)) # 120

Последовательность Фибоначчи

# 利用循环
i = 0
j = 1
lst = list([i, j])
for k in range(2, 11):
    k = i + j
    lst.append(k)
    i = j
    j = k
print(lst)  
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

# 利用递归
def recur_fibo(n):
    if n <= 1:
        return n
    return recur_fibo(n - 1) + recur_fibo(n - 2)
lst = list()
for k in range(11):
    lst.append(recur_fibo(k))
print(lst)  
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Установите количество рекурсивных уровней, рекурсивный уровень Python по умолчанию равен 100.

import sys
sys.setrecursionlimit(1000)

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

Определение анонимных функций

В Python есть два типа функций:

Обычные функции, определенные с помощью ключевого слова def
Анонимные функции, определенные с помощью ключевого слова lambda

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

lambda argument_list: expression

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

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

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

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

Использование анонимных функций

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

# 非函数式编程
def f(x):
    for i in range(0, len(x)):
        x[i] += 10
    return x
x = [1, 2, 3]
f(x)
print(x)
# [11, 12, 13]

# 函数式编程
def f(x):
    y = []
    for item in x:
        y.append(item + 10)
    return y
x = [1, 2, 3]
f(x)
print(x)
# [1, 2, 3]

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

Аргументы - это функции (фильтр, карта)
Возвращаемое значение является функцией (закрытие)

Например, применение в функциях фильтра и карты:

filter(function, iterable) фильтровать последовательность, отфильтровывать элементы, которые не соответствуют условиям, и возвращать объект итератора.Если вы хотите преобразовать в список, вы можете использовать list() для преобразования

odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

map(function, *iterables) Сопоставить указанную последовательность в соответствии с предоставленной функцией

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))  
# [1, 4, 9, 16, 25]
m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))  
# [3, 7, 11, 15, 19]

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

def apply_to_list(fun, some_list):
    return fun(some_list)

lst = [1, 2, 3, 4, 5]
print(apply_to_list(sum, lst))
# 15

print(apply_to_list(len, lst))
# 5

print(apply_to_list(lambda x: sum(x) / len(x), lst))
# 3.0

класс и объект

Свойства и методы составляют объекты

объект = свойство + метод

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

Инкапсуляция: технология сокрытия информации

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

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

что такое я?

Self в Python эквивалентен указателю this в C++.

class Test:
    def prt(self):
        print(self)
        print(self.__class__)


t = Test()
t.prt()
# <__main__.Test object at 0x000000BC5A351208>
# <class '__main__.Test'>

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

Волшебный метод Python

В классе есть магический метод __init__(self[ param1, param2...]), который автоматически вызывается при создании экземпляра класса.

class Ball:
    def __init__(self, name):
        self.name = name

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)

a = Ball("球A")
b = Ball("球B")
c = Ball("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

общественное и частное

Чтобы определить приватную переменную, вам нужно всего лишь добавить два символа подчеркивания «__» перед именем переменной или именем функции, тогда функция или переменная будут приватными.

частный экземпляр класса

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)

counter = JustCounter()
counter.count()  # 1
counter.count()  # 2
print(counter.publicCount)  # 2

# Python的私有为伪私有
print(counter._JustCounter__secretCount)  # 2 
print(counter.__secretCount)  
# AttributeError: 'JustCounter' object has no attribute '__secretCount'

частный экземпляр метода класса

class Site:
    def __init__(self, name, url):
        self.name = name  # public
        self.__url = url  # private

    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)

    def __foo(self):  # 私有方法
        print('这是私有方法')

    def foo(self):  # 公共方法
        print('这是公共方法')
        self.__foo()


x = Site('老马的程序人生', 'https://blog.csdn.net/LSGO_MYP')
x.who()
# name  :  老马的程序人生
# url :  https://blog.csdn.net/LSGO_MYP

x.foo()
# 这是公共方法
# 这是私有方法

x.__foo()
# AttributeError: 'Site' object has no attribute '__foo'

наследовать

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

class DerivedClassName(BaseClassName):
       statement-1
              .
              .
              .
       statement-N

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

class DerivedClassName(modname.BaseClassName):
       statement-1
              .
              .
              .
       statement-N

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

# 类定义
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('小马的程序人生', 10, 60, 3)
s.speak()
# 小马的程序人生 说: 我 10 岁了，我在读 3 年级

Если приведенная выше программа удаляет: people.__init__(self, n, a, w), вывод: Допустим: мне 0 лет, я учусь в 3-м классе, потому что конструктор подкласса переопределяет конструктор родительского класса.

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

комбинация

class Turtle:
    def __init__(self, x):
        self.num = x


class Fish:
    def __init__(self, x):
        self.num = x


class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)

    def print_num(self):
        print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))


p = Pool(2, 3)
p.print_num()
# 水池里面有乌龟2只，小鱼3条

Классы, объекты классов и объекты экземпляров

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

class A(object):
       pass

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

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

class A():
    a = 0  #类属性
    def __init__(self, xx):
        A.a = xx  #使用类属性可以通过 （类名.类属性）调用。

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

# 创建类对象
class Test(object):
    class_attr = 100  # 类属性

    def __init__(self):
        self.sl_attr = 100  # 实例属性

    def func(self):
        print('类对象.类属性的值:', Test.class_attr)  # 调用类属性
        print('self.类属性的值', self.class_attr)  # 相当于把类属性 变成实例属性
        print('self.实例属性的值', self.sl_attr)  # 调用实例属性


a = Test()
a.func()

# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

b = Test()
b.func()

# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

a.class_attr = 200
a.sl_attr = 200
a.func()

# 类对象.类属性的值: 100
# self.类属性的值 200
# self.实例属性的值 200

b.func()

# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

Test.class_attr = 300
a.func()

# 类对象.类属性的值: 300
# self.类属性的值 200
# self.实例属性的值 200

b.func()
# 类对象.类属性的值: 300
# self.类属性的值 300
# self.实例属性的值 100

Свойство имеет то же имя, что и метод, свойство переопределяет метод

Что является обязательным?

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

Атрибуты данных объектов Python обычно хранятся в словаре с именем .__dict__, мы можем получить доступ к __dict__ напрямую или использовать встроенную функцию Python vars() для получения .__dict__

Некоторые связанные встроенные функции (BIF)

Метод issubclass(class, classinfo) используется для определения того, является ли класс параметра подклассом параметра типа classinfo.
Класс считается подклассом самого себя.
classinfo может быть кортежем объектов класса, возвращает True, если класс является подклассом любого из классов-кандидатов.
Метод isinstance(object, classinfo) используется для определения того, относится ли объект к известному типу, аналогично type().
type() не считает подкласс типом суперкласса и не рассматривает наследование.
isinstance() будет рассматривать подкласс как тип суперкласса и учитывать отношения наследования.
Возвращает False навсегда, если первый аргумент не является объектом.
Если второй аргумент не является классом или кортежем объектов класса, будет выдано исключение TypeError.
hasattr(object, name) используется для определения того, содержит ли объект соответствующий атрибут
getattr(object, name[ default]) используется для возврата значения атрибута объекта
setattr(object, name, value) соответствует функции getattr(), которая используется для установки значения атрибута, атрибут не обязательно существует
delattr(object, name) используется для удаления атрибутов
class property([fget[ fset[ fdel[ doc]]]]) используется для возврата значений свойств в классах нового стиля.
- fget -- функция для получения значения атрибута
- fset -- функция для установки значения свойства
- fdel -- удалить функцию значения атрибута
- doc -- информация описания атрибута

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

Магические методы всегда окружены двойным подчеркиванием, например, __init__.

Волшебные методы — это все в объектно-ориентированном Python.Если вы не знаете магических методов, вы не осознали всю мощь объектно-ориентированного Python.

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

Первый параметр магического метода должен быть либо cls (метод класса), либо self (метод экземпляра).

cls: представляет имя класса
self: представляет имя экземпляра объекта

основной магический метод

__init__(self[ ...]) конструктор, метод инициализации вызывается при создании экземпляра
__new__(cls[ ...]) Первый метод, вызываемый при создании экземпляра объекта. Перед вызовом инициализации __init__ сначала вызовите __new__.
- new__ должен иметь по крайней мере один параметр cls, который представляет класс, который должен быть создан.Этот параметр автоматически предоставляется интерпретатором Python во время создания экземпляра, а следующие параметры передаются непосредственно в __init.
- new__ создает экземпляр текущего класса и возвращает экземпляр себе из __init__. Однако выполняется __new, не обязательно входит в __init__, только когда __new__ возвращает экземпляр текущего класса cls, войдет __init__ текущего класса
- Если __new__ неправильно возвращает экземпляр текущего класса cls, то __init__ вызываться не будет, даже если это экземпляр родительского класса, __init__ вызываться не будет
Метод __new__ в основном предоставляет вам способ настроить процесс создания экземпляров этих классов, когда вы наследуете некоторые неизменяемые классы (такие как int, str, tuple)
del(self) деструктор, метод, вызываемый, когда объект собирается быть переработанным системой
str(self):
- Когда вы печатаете объект, запускайте __str__
- Инициировать __str__ при форматировании с помощью %s
- Когда str принудительно преобразует тип данных, срабатывает __str__
repr(себя):
- repr - запасное колесо ул.
- Выполнить __str__, когда __str__ присутствует, и выполнить __repr__, когда __str__ не реализовано
- Результат, соответствующий встроенной функции repr(obj), является возвращаемым значением __repr__.
- Инициировать __repr__ при форматировании с помощью %r

strВозвращаемый результат (self) легко читается. Это,strСмысл в том, чтобы получить информацию, которую людям легко читать, например «2019-10-11» ниже.

reprВозвращаемый результат (self) должен быть более точным. Как сказать,reprЦель существования - отладка, которой удобно пользоваться разработчикам

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

Введите фабричные функции, что означает "создавать объекты не через классы, а через функции"

class C:
    pass


print(type(len))  # <class 'builtin_function_or_method'>
print(type(dir))  # <class 'builtin_function_or_method'>
print(type(int))  # <class 'type'>
print(type(list))  # <class 'type'>
print(type(tuple))  # <class 'type'>
print(type(C))  # <class 'type'>
print(int('123'))  # 123

# 这个例子中list工厂函数把一个元祖对象加工成了一个列表对象。
print(list((1, 2, 3)))  # [1, 2, 3]

add(я, другой) определяет поведение добавления: +
sub(я, другой) определяет поведение вычитания: -
mul(я, другой) определяет поведение умножения: *
truediv(я, другой) определяет поведение истинного деления:/
floordiv(self, other) определяет поведение целочисленного деления: //
mod(self, other) определяет поведение алгоритма по модулю: %
divmod(self, other) определяет поведение при вызове divmod()
divmod(a, b) объединяет результаты операций делителя и остатка и возвращает кортеж, содержащий частное и остаток (a // b, a % b)
pow(self, other[ module]) определяет поведение при вызове power() или ** оценивается
lshift(self, other) определяет поведение побитового сдвига влево:
rshift(self, other) определяет поведение побитового сдвига вправо: >>
and(self, other) определяет поведение побитовой операции AND: &
xor(self, other) определяет поведение побитовой операции XOR: ^
or(self, other) определяет поведение операции побитового ИЛИ: |

обратный арифметический оператор

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

radd(я, другой) определяет поведение добавления: +
rsub(я, другой) определяет поведение вычитания: -
rmul(я, другой) определяет поведение умножения: *
rtruediv(я, другой) определяет поведение истинного деления:/
rfloordiv(self, other) определяет поведение целочисленного деления: //
rmod(self, other) определяет поведение алгоритма по модулю: %
rdivmod(self, other) определяет поведение при вызове divmod()
rpow(self, other[ module]) определяет поведение при вызове power() или ** оценивается
rlshift(self, other) определяет поведение побитового сдвига влево:
rrshift(self, other) определяет поведение побитового сдвига вправо: >>
rand(self, other) определяет поведение побитовой операции AND: &
rxor(self, other) определяет поведение побитовой операции XOR: ^
ror(self, other) определяет поведение операции побитового ИЛИ: |

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

iadd(self, other) определяет поведение добавления присваивания: +=
isub(self, other) определяет поведение присваивания-вычитания: -=
imul(self, other) определяет поведение умножения присваивания: *=
itruediv(self, other) определяет поведение присваивания истинного деления: /=
ifloordiv(self, other) определяет поведение целочисленного деления присваивания: //=
imod(self, other) определяет поведение алгоритма присваивания по модулю: %=
ipow(self, other[ modulo]) определяет поведение возведения в степень присваивания: **=
ilshift(self, other) определяет поведение присваивания побитового сдвига влево:
irshift(self, other) определяет поведение присваивания побитового сдвига вправо: >>=
iand(self, other) определяет поведение операций побитового И присваивания: &=
ixor(self, other) определяет поведение присваивания побитового XOR: ^=
ior(self, other) определяет поведение побитового ИЛИ присваиваний: |=

унарный оператор

neg(self) определяет поведение положительного знака: +x
pos(self) определяет поведение знака минус: -x
abs(self) определяет поведение при вызове abs()
invert(self) определяет поведение побитового отрицания: ~x

доступ к собственности

getattr(я, имя): определяет поведение, когда пользователь пытается получить несуществующее свойство.
getattribute(я, имя): определяет поведение при доступе к атрибуту класса (сначала вызовите этот метод, чтобы узнать, существует ли атрибут, если нет, затем вызовите __getattr__).
setattr(я, имя, значение): определяет поведение при установке свойства.
delattr(я, имя): определяет поведение при удалении атрибута.

Дескриптор

Дескриптор — это экземпляр класса свойств определенного типа, присвоенный другому классу.

get(я, экземпляр, владелец) используется для доступа к свойству, он возвращает значение свойства.
set(self, instance, value) будет вызываться в операции присвоения свойства, ничего не возвращая.
del(self, instance) управляет операцией удаления и ничего не возвращает.

пользовательская последовательность

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

Протокол типа контейнера

Если вы хотите, чтобы ваш пользовательский контейнер был неизменным, вам нужно только определить методы __len__() и __getitem__().
Если вы хотите, чтобы пользовательский контейнер был изменяемым, в дополнение к методам __len__() и __getitem__() вам также необходимо определить методы __setitem__() и __delitem__()
len(self) определяет поведение при вызове len() (возвращает количество элементов в контейнере).
getitem(self, key) определяет поведение получения элементов в контейнере, эквивалентное self[key].
setitem(self, key, value) определяет поведение установки указанного элемента в контейнере, эквивалентное self[key] = value.
delitem(self, key) определяет поведение удаления указанного элемента в контейнере, эквивалентное del self[key]

итератор

Итерация — одна из самых мощных функций Python, способ доступа к элементам коллекции.
Итератор — это объект, который запоминает, где проходить.
Доступ к объектам Iterator осуществляется с первого элемента коллекции до тех пор, пока не будут доступны все элементы.
Итераторы могут идти только вперед, а не назад.
Объекты String, List или tuple могут использоваться для создания итераторов.
Итераторы имеют два основных метода: iter() и next().
Функция ITER (Object) используется для генерации итератора.
next(iterator[ default]) возвращает следующий элемент итератора.
iterator -- итерируемый объект
default -- необязательный, используется для установки значения по умолчанию, которое будет возвращено, когда нет следующего элемента, если не задано и нет следующего элемента, будет запущено исключение StopIteration
iter(self) определяет поведение при переборе элементов в контейнере, возвращая специальный объект итератора, который реализуетnext() и сигнализировать о завершении итерации с помощью исключения StopIteration.
next() возвращает следующий объект итератора.
Исключение StopIteration используется для отметки завершения итерации и предотвращения бесконечных циклов.next() мы можем установить исключение StopIteration для завершения итерации после завершения заданного количества циклов

Строитель

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