Инкапсуляция как слово, услышанное впервые, кажется очень причудливой, технической и сложной вещью в мире программирования, особенно если вы новичок. Когда я пытался узнать об инкапсуляции из разных источников, мне хотелось, чтобы кто-то мог облегчить понимание в повествовательной форме. Итак, здесь я пытаюсь объяснить инкапсуляцию так, как я ее понял, просмотрев тонны материалов как онлайн, так и офлайн.
- Поскольку вы здесь, чтобы узнать об инкапсуляции, я предполагаю, что у вас уже есть некоторые знания об ООП (объектно-ориентированном программировании).
Если мы пойдем по определению в Google, оно указывает инкапсуляцию как:
« Инкапсуляция — это механизм объединения данных (переменных) и кода, воздействующего на данные (методы) вместе как единое целое »
Само по себе это определение кажется довольно опасным. позволяет понять это простым способом.
Предположим, что вы старший программист стартапа и у вас есть команда, которая отвечает за создание механизма, позволяющего пользователям создавать учетные записи в приложении вашего стартапа. Предположим, на данный момент вы хотите, чтобы учетная запись была настроена только с использованием имени и пароля пользователя, и единственные пароли, которые вы разрешаете, являются числовыми. Да! Я знаю, что в реальном мире нецелесообразно использовать только числовые пароли, но давайте просто предположим это для понимания темы. Будучи старшим программистом, вы будете нести ответственность за создание класса учетной записи, а младшие программисты будут нести ответственность за использование этого класса.
предположим, вы создали класс следующим образом:
class Account:
# constructor
def __init__(self):
self.user = ''
self.password = 0
self.menu()
# display option
def menu(self):
user_input = input("""
Select to Enter the following details:
1. set account
2. login
5. Exit
""")
if user_input == '1':
self.set_account()
elif user_input == '2':
self.login()
else:
exit()
# To set account
def set_account(self):
user_name = input("set user id: ")
self.user = user_name
user_password = int(input("Set Password: "))
self.password = user_password
# To login
def login(self):
user_input = input("enter User id: ")
if user_input == self.user:
user_pass = int(input("enter password: "))
if user_pass == self.password:
return "Welcome {}".format(self.user)
else:
return "wrong password"
else:
return "user not found"
Теперь класс готов. Я знаю, что это далеко не идеально, но просто для понимания давайте предположим, что класс Account позволяет пользователям создавать и входить в свою учетную запись.
скажем, «Rohit» — это пользователь, и он создал учетную запись с помощью следующей команды:
rohit = Account()
# after running the above code we get the prompt and add the following detail
"""
Select to Enter the following details:
1. set account
2. login
5. Exit
1
set user id: rohit
Set Password: 123
"""
Теперь предположим, что это хакер, пытающийся войти в аккаунт Рохита. И, к нашему удивлению, он легко смог войти в чей-то аккаунт. Как? Просто запустив следующую строку кода:
rohit.password
в шоке? да, так легко получить чей-то пароль. Это огромный недостаток приложения, поскольку любой может войти в вашу учетную запись, просто зная ваш идентификатор пользователя.
Теперь, чтобы справиться с такими ситуациями, инкапсуляция становится нашим супергероем, чтобы сохранить наши рабочие места и удостоверения наших пользователей.
Что делает инкапсуляция, так это то, что она позволяет вам сделать ваши переменные личными. Вот что означает обтекание переменных (данных). Как мы можем сделать это в питоне. Просто добавьте двойное подчеркивание в префикс данных, которые вы хотите сделать приватными ( __data ).
Теперь, в случае нашего класса Account, мы не хотим, чтобы кто-то еще знал пароль наших пользователей. поэтому мы внесем изменения в наш код следующим образом:
class Account:
def __init__(self):
self.user = ''
self.__password = 0
self.menu()
def menu(self):
user_input = input("""
Select to Enter the following details:
1. set account
2. login
5. Exit
""")
if user_input == '1':
self.set_account()
elif user_input == '2':
self.login()
else:
exit()
def set_account(self):
user_name = input("set user id: ")
self.user = user_name
user_password = int(input("Set Password: "))
self.__password = user_password
def login(self):
user_input = input("enter User id: ")
if user_input == self.user:
user_pass = int(input("enter password: "))
if user_pass == self.__password:
return "Welcome {}".format(self.user)
else:
return "wrong password"
else:
return "user not found"
Что мы сделали? просто изменил переменную «пароль» на «__password» везде. просто внесение этого небольшого изменения в наш код гарантирует, что никто извне не сможет изменить или перезаписать наши объявленные переменные.
Теперь, если кто-то попытается получить доступ к переменной пароля, он/она получит следующую ошибку:
rohit.password # running the above piece of code will output the following error """ --------------------------------------------------------------------------- AttributeError Traceback (most recent call last) <ipython-input-4-7ddf6c297392> in <module> ----> 1 rohit.password AttributeError: 'Account' object has no attribute 'password' """
Но что, если я скажу, что вы все еще можете получить доступ к этой переменной «пароль». Не верите мне? Запустите следующий фрагмент кода, и вы сами все увидите
rohit._Account__password # Output # 1234
Просто используя «_className__privateVariable», вы можете получить доступ к закрытым переменным. Расстроенный ? ну, это то, что есть. Честно говоря, в питоне нет ничего по-настоящему частного, и я был разочарован, узнав об этом факте. Но почему python разрешает доступ к частной переменной? Ответ, который я нашел на этот вопрос, заключался в следующем: «Python — это язык программирования, созданный для профессионалов».
Но зачем вообще существует концепция инкапсуляции, если ничего не является приватным? Я знаю, это то, что происходит в твоей голове, верно? Итак, дело в том, что инкапсуляция нужна, когда вы не хотите, чтобы другие (младшие программисты, пользователи) знали или вносили изменения в важные переменные, методы. До тех пор, пока они не получат доступ к исходному коду, они не смогут узнать, какие переменные или методы являются закрытыми, и, следовательно, не смогут получить к ним доступ или изменить их.
Но что, если Рохит забыл свой пароль и хочет восстановить или изменить его? Соглашение заключается в том, что мы создаем 2 метода в нашем классе, которые позволят получить доступ и изменить закрытую переменную, известную как методы Getter и Setter. как сделать это? используйте следующий код:
class Account:
def __init__(self):
self.user = ''
self.__password = 0
self.menu()
# GETTER
def get_pass(self):
return self._Account__password
# SETTER
def set_pass(self,newpass):
if type(newpass) == int:
self.__password = newpass
else: return "Password should only be numeric"
def menu(self):
user_input = input("""
Select to Enter the following details:
1. set account
2. login
5. Exit
""")
if user_input == '1':
self.set_account()
elif user_input == '2':
self.login()
else:
exit()
def set_account(self):
user_name = input("set user id: ")
self.user = user_name
user_password = int(input("Set Password: "))
self.__password = user_password
def login(self):
user_input = input("enter User id: ")
if user_input == self.user:
user_pass = int(input("enter password: "))
if user_pass == self.__password:
return "Welcome {}".format(self.user)
else:
return "wrong password"
else:
return "user not found
Теперь использование «rohit.get_pass()» позволит вам получить доступ к вашему паролю, а «rohit.set_pass(3456)» позволит вам изменить свой пароль на 3456.
Не только переменные, python даже позволяет вам сделать ваши методы приватными. Процесс такой же, просто измените имя метода на «__method», и ваш метод станет приватным.
Вся эта концепция создания приватных переменных, доступа к приватным переменным с помощью методов получения и изменения значения частной переменной с помощью методов установки известна как инкапсуляция. .
Надеюсь, что этот блог может помочь вам в чем-то. отписываюсь! пока👋
