Функц ООП

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

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

Объект создается путем вызова класса. Например: my_object = MyClass().

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

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

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

person1 = Person("Иван", 30)

print(person1.name) # Вывод: Иван

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

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

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

class BankAccount:

def __init__(self, balance):

self.__balance = balance # Приватный атрибут

def get_balance(self):

return self.__balance

account = BankAccount(1000)

print(account.get_balance()) # Вывод: 1000

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

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

class Animal:

def make_sound(self):

pass

class Dog(Animal):

def make_sound(self):

print("Гав-гав!")

class Cat(Animal):

def make_sound(self):

print("Мяу!")

animals = [Dog(), Cat()]

for animal in animals:

animal.make_sound()

# Вывод: Гав-гав!

# Мяу!

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

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

class Laptop:

def __init__(self, brand, model):

self.brand = brand

self.model = model

my_laptop = Laptop("Apple", "MacBook Pro")

print(my_laptop.brand) # Вывод: Apple

Абстрактный класс создается с использованием модуля abc и декоратора @abstractmethod.

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

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

Магические методы (например, __init__, __str__, __add__) определяют поведение объектов и операций. Они вызываются автоматически в определенных ситуациях.

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

class Vector:

def __init__(self, x, y):

self.x = x

self.y = y

def __str__(self):

return f"Vector({self.x}, {self.y})"

def __add__(self, other):

return Vector(self.x + other.x, self.y + other.y)

v1 = Vector(1, 2)

v2 = Vector(3, 4)

print(v1) # Вывод: Vector(1, 2)

print(v1 + v2) # Вывод: Vector(4, 6)

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

Множественное наследование позволяет классу наследовать несколько родительских классов, например: class C(A, B).

Метод super() используется для вызова методов родительского класса из дочернего класса, что позволяет расширять или переопределять поведение родителя.

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

class Parent:

def greet(self):

print("Привет от родителя!")

class Child(Parent):

def greet(self):

super().greet() # Вызов метода родителя

print("Привет от ребенка!")

child = Child()

child.greet()

# Вывод: Привет от родителя!

# Привет от ребенка!

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

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

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

Приватные атрибуты в Python создаются с использованием двойного подчёркивания (__) перед именем атрибута, например: __private_var. Они скрыты от внешнего кода, что означает, что к ним нельзя обратиться напрямую за пределами класса.

Как это работает:

• Внутри класса к приватным атрибутам можно обращаться как обычно: self.__private_var.

• Снаружи класса прямой доступ к таким атрибутам невозможен, но их всё ещё можно "взломать" с помощью name mangling (подмена имени). Их можно получить через полное имя атрибута: _ClassName__attribute

Для открытия файла используется функция open(), которая возвращает файловый объект. Например, f = open('file.txt', 'r').

Для чтения данных используется метод read(), который возвращает содержимое файла в виде строки. Например, data = f.read().

Для работы с CSV-файлами в Python с помощью библиотеки pandas используются следующие основные функции:

1. read_csv() загружает данные из CSV-файла в DataFrame.

2. to_csv() сохраняет DataFrame в CSV-файл. Параметр index=False исключает индексы из записи.

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

• json.load(file): Загружает данные из JSON-файла и преобразует их в Python-объект (например, словарь или список).

• json.loads(string): Преобразует JSON-строку в Python-объект.

• json.dump(obj, file): Сохраняет Python-объект в JSON-файл.

• json.dumps(obj): Преобразует Python-объект в JSON-строку.

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

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

• Десериализация — это обратный процесс, который позволяет восстановить объект из байтовой строки. pickle.load()

import pickle

# Сериализация объекта

data = {"name": "Иван", "age": 30}

with open("data.pkl", "wb") as f:

pickle.dump(data, f)

# Десериализация объекта

with open("data.pkl", "rb") as f:

loaded_data = pickle.load(f)

print(loaded_data) # Вывод: {'name': 'Иван', 'age': 30}

Для работы с Excel используется модуль pandas. Метод pd.read_excel() позволяет загружать данные из Excel-файла в DataFrame.

Для записи в файл используется метод write(). Например, f.write('Hello, World!').

Менеджеры контекста (with open('file.txt', 'r') as f:) автоматически закрывают файл после завершения работы с ним.

Для работы с Excel-файлами используется модуль pandas. Метод pd.read_excel() считывает данные из файла Excel.

Для открытия файла в бинарном режиме используется режим 'rb' или 'wb', например, f = open('file.bin', 'rb').

Чтение больших файлов построчно выполняется с использованием итерации: for line in f:, что позволяет экономить память.

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

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

Пример

def add(a, b):

return a + b

print(add(2, 3)) # Вывод: 5

Lambda-функции создаются с помощью ключевого слова lambda и позволяют создавать анонимные функции на месте.

Простая lambda-функция

square = lambda x: x ** 2

print(square(5)) # Вывод: 25

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

Пример

def add(a):

def add_b(b):

return a + b

return add_b

add_5 = add(5)

print(add_5(3)) # Вывод: 8

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

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

Пример использования:

# Функция для удвоения числа

def double(x):

return x * 2

# Применяем map() к списку чисел

numbers = [1, 2, 3, 4, 5]

doubled_numbers = list(map(double, numbers))

print(doubled_numbers) # [2, 4, 6, 8, 10]

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

Шаблон декоратора:

def my_decorator(func):

def wrapper():

# Дополнительная логика до вызова функции

print("Декоратор начал выполнение.")

# Вызов оригинальной функции

func()

# Дополнительная логика после вызова функции

print("Декоратор завершил выполнение.")

return wrapper

Чтобы ваш декоратор мог работать с функциями, принимающими аргументы, нужно передать их внутрь wrapper(). (*args, **kwargs)

def my_decorator(func):

def wrapper(*args, **kwargs):

print("Декоратор начал выполнение.")

result = func(*args, **kwargs)

print("Декоратор завершил выполнение.")

return result

return wrapper

Функция functools.partial() позволяет зафиксировать некоторые аргументы функции, создавая новую функцию с предустановленными аргументами.

Пример использования:

from functools import partial

# Функция сложения двух чисел

def add(x, y):

return x + y

# Создаем новую функцию с предустановленным первым аргументом

add_five = partial(add, 5)

print(add_five(10)) # 15

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

Пример композиции функций:

# Две простые функции

def add_one(x):

return x + 1

def multiply_by_two(x):

return x * 2

# Функция композиции

def compose(f, g):

return lambda x: f(g(x))

# Создаем новую функцию путем композиции

new_function = compose(add_one, multiply_by_two)

print(new_function(3)) # 7, так как (3 * 2) + 1 = 7

Для создания JSON из словаря используется метод json.dumps(), например: json_string = json.dumps({'name': 'Alice'}).

Для обработки ошибок чтения файла используется блок try-except с исключением IOError или FileNotFoundError.

Для чтения строк по одной можно использовать метод readline() или итерацию по объекту файла с использованием for line in f.

Формат NPY используется библиотекой NumPy для сохранения и загрузки массивов. Для сериализации используется np.save(), а для десериализации — np.load().

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

1. Создание объекта BS4:

   • BeautifulSoup(xmldata, 'xml') - эта строка создает объект BeautifulSoup, указывая, что нужно использовать парсер для XML. xml_data - это ранее открытый файл.

2. Извлечение данных:

   • soup.find_all('book') - находит все теги <book> в XML-документе.

   • Внутри цикла можно обращаться к конкретным вложенным тегам с помощью find('tag_name'), чтобы получить их содержимое.

Основные методы работы с XML в BS4

• .find(tag_name): находит первый тег с указанным именем.

• .find_all(tag_name): находит все теги с указанным именем.

• .text: возвращает текстовое содержимое тега.

Таким образом, BS4 позволяет удобно и гибко извлекать данные из XML-документов.

Для конвертации JSON в DataFrame используется метод pd.json_normalize() в библиотеке Pandas, что позволяет обработать вложенные структуры JSON.

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

Пример

import pandas as pd

import glob

# Чтение всех CSV-файлов из директории

all_files = glob.glob('path/*.csv')

# Загрузка и объединение данных

df_list = [pd.read_csv(file) for file in all_files]

df = pd.concat(df_list, ignore_index=True)

print(df)

Для работы с двоичными файлами используется режим 'rb' или 'wb' в функции open(). Чтение и запись выполняются с использованием методов read() и write().