封裝和內置函數（ property ， classmethod ，staticmethod *）

封裝好處：

【封裝】

         隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。

【好處】 

1. 將變化隔離； 

2. 便於使用；

3. 提升複用性； 

4. 提升安全性；

【封裝原則】

      1. 將不須要對外提供的內容都隱藏起來；

      2. 把屬性都隱藏，提供公共方法對其訪問。

定義：

封裝
# 廣義上的封裝 : 屬於一個類的靜態和動態屬性 老是出如今一個類中
                # 使用的使用永遠用類名或者對象名調用
# 狹義上的封裝 : 就是把變量\方法私有化,在類的外部以及子類中不能直接使用了

私有變量引用：
# class A:
#     STATIC = 'aaa'  # 靜態變量
#     __S = 'bbb'     # 私有的靜態變量
#     def wahaha(self):
#         print(A.__S) # _A__S
# print(A.STATIC)
# print(A.__dict__)
# print(A._A__S)      # 在類的外面調用私有的變量
# a = A()
# a.wahaha()
# A.__B = 'ccc'   #在類的外部添加了一個靜態變量
# print(A.__dict__)  #咱們不能在一個類的外部建立一個"私有的"變量
# print(A.__B)

 

一：裏面調用時候，能夠定義成方法，而後打印私有變量

在裏面調用私有屬性，寫一個函數
# class B:
#     def __init__(self,name,pwd):
#         self.name = name
#         self.__pwd = pwd   # 也能夠建立對象的私有屬性
#
#     def get_pwd(self):
#         print(self.__pwd)
# b = B('alex','alex3714')
# b.qqxing()
# print(b.name)
# print(b._B__pwd)  # 當在類外部的時候,咱們也不能直接使用對象的私有屬性
# b.get_pwd()

二： 私有變量小結：

 私有de 靜態變量 對象屬性 方法
    #私有的 只能在類的內部定義和使用
    # __名字
    # 在類外部使用私有靜態變量 _類名__私有的名字
    # 私有的名字 不能被子類繼承

Java跟Python對應關係

java
    # private 私有的  - __變量名
    # protect 保護的  - N/A
    # public 公共的   - 正常的變量

實例1：

房間類 : 全部人 價格 面積
# class Room:
#     def __init__(self,owner,price,length,width,height):
#         self.owner = owner
#         self.__price_single = price  #單價
#         self.__length = length
#         self.__width = width
#         self.height = height
#
#     def get_area(self):
#         return self.__length * self.__width
#
#     def get_price(self):
#         return self.__price_single * self.get_area()
#
# alex = Room('alex',1000000,2,1,0.8)
# print(alex.get_area())
# print(alex.get_price())

註釋：定義方法調用私有變量

將方法假裝成屬性

實例化時候實例類

可是調用的時候使用方法# print(wang.bmi)

類 可以計算人體的BMI指數
# class Person:
#     def __init__(self,name,height,weight):
#         self.name = name
#         self.__height = height
#         self.__weight = weight
#
#     @property   #將一個方法假裝成屬性
#     def bmi(self):
#         return self.__weight / (self.__height**2)
#
# wang = Person('王子',1.77,69)
# print(wang.bmi)

說白了就是將不要給用戶看的屬性假裝起來，而後調用方法

 

小應用：定義幾個方法調用，調用幾個加幾個@property

# 圓形類  : r   面積area 周長perimeter
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r = r
#     @property
#     def area(self):
#         return self.r*self.r*pi
#     @property
#     def perimeter(self):
#         return 2*pi*self.r
#
# c = Circle(10)
# print(c.area)
# print(c.perimeter)

 

@classmethod 將普通方法裝爲類方法，其實就是self啦，用仍是類方法調用，說白了就是當成一個參數

lass Goods:
    __discount = 0.8
    def  __init__(self,name,price):
        self.name = name
        self.__price = price

    @property
    def price(self):
        return self.__price*Goods.__discount

    @classmethod  #講一個普通方法裝飾爲一個類方法
    def change_discount(cls,new_dis):  # 類方法
        cls.__discount = new_dis        調用類方法  =後面參數
Goods.change_discount(1)
cig = Goods('cigrette',20)
print(cig.price)
cig.change_discount(0.2)
print(cig.price)
# cig.change_discount(1)
# print(cig.price)

註解：

#類方法是被@classmethod裝飾的特殊方法
    #被裝飾以後,方法默認接收一個 類 做爲參數
    # 以後全部的操做都只能和 類中的靜態變量相關 而不該該和對象相關
# 類名 和 對象名 均可以直接調用類方法

 

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

    @staticmethod    #裝飾一個不須要self參數 也不須要cls參數的函數
    def login(a,b,c):    # 普通的函數
        usr = input('username>>>')
        pwd = input('password>>>')
        if usr == 'alex' and pwd == '123':
            obj = Student(usr)
            return obj
# 學生 login
# 用戶名  密碼  屬性
ret = Student.login(1,2,3)
print(ret)

用這個函數可以將他假裝成函數