Когда я должен использовать классы в Python?

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

во-первых, отказ от ответственности: ООП частично в отличие от Функциональное Программирование, который является другой парадигмой, используемой много в Python. Не все, кто программирует на Python (или, Конечно, большинство языков) использует ООП. Вы можете сделать много в Java 8, который не очень ориентирован на объект. Если вы не хотите использовать ООП, то не надо. Если вы просто пишете одноразовые сценарии для обработки данных, которые вы никогда не будете использовать снова, то продолжайте писать так, как вы есть.

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

некоторым причинам:

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

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

• инкапсуляция: При инкапсуляции процедура и данные хранятся вместе. Методы (термин ООП для функций) определяются правильно наряду с данными, над которыми они работают и производят. На таком языке, как Java, который позволяет контроль доступа, или в Python, в зависимости от того, как вы описываете свой публичный API, это означает, что методы и данные могут быть скрыты от пользователя. Это означает, что если вам нужно или вы хотите изменить код, вы можете делать все, что хотите для реализации кода, но сохранить общедоступные API-интерфейсы одинаковыми.

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

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

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

пример использования студента (нет гарантии качества кода, только пример):

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

class Student(object):
    def __init__(self, name, age, gender, level, grades=None):
        self.name = name
        self.age = age
        self.gender = gender
        self.level = level
        self.grades = grades or {}

    def setGrade(self, course, grade):
        self.grades[course] = grade

    def getGrade(self, course):
        return self.grades[course]

    def getGPA(self):
        return sum(self.grades.values())/len(self.grades)

# Define some students
john = Student("John", 12, "male", 6, {"math":3.3})
jane = Student("Jane", 12, "female", 6, {"math":3.5})

# Now we can get to the grades easily
print(john.getGPA())
print(jane.getGPA())

Стандартные Дикт

def calculateGPA(gradeDict):
    return sum(gradeDict.values())/len(gradeDict)

students = {}
# We can set the keys to variables so we might minimize typos
name, age, gender, level, grades = "name", "age", "gender", "level", "grades"
john, jane = "john", "jane"
math = "math"
students[john] = {}
students[john][age] = 12
students[john][gender] = "male"
students[john][level] = 6
students[john][grades] = {math:3.3}

students[jane] = {}
students[jane][age] = 12
students[jane][gender] = "female"
students[jane][level] = 6
students[jane][grades] = {math:3.5}

# At this point, we need to remember who the students are and where the grades are stored. Not a huge deal, but avoided by OOP.
print(calculateGPA(students[john][grades]))
print(calculateGPA(students[jane][grades]))