python继承

私有属性：

会用到私有属性这个概念的场景

1.隐藏起一个属性 不想让类的外部调用

2.想保护这个属性，不想让让属性被随意修改

3.想保护这个属性，不被子类继承

class Room:
    def __init__(self,name,length,width):
        self.__name = name
        self.__length = length
        self.__width = width
    def get_name(self):
        return self.__name
    def set_name(self,newName):
        if type(newName) is str and newName.isdigit() == False:
            self.__name = newName
        else:
            print('不合法的姓名')
    def area(self):
        return self.__length * self.__width

jin = Room('金',2,1)
print(jin.area())
jin.set_name('2')
print(jin.get_name())

property（）：

把类的方法伪装成属性

from math import pi


class Circle:
    def __init__(self, r):
        self.r = r

    @property
    def perimeter(self):
        return 2 * pi * self.r

    @property
    def area(self):
        return self.r ** 2 * pi

c1 = Circle(5)
print(c1.area)     # 圆的面积
print(c1.perimeter) # 圆的周长

　　把一个属性设为私有方法，再用property()装饰一个方法在外部调用

.setter  (改)

class Person:
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return self.__name + '大王'
    @name.setter    #name 为要改的方法的名字
    def name(self,new_name):
        self.__name = new_name

tiger = Person('老虎')
print(tiger.name)
tiger.name = '狮子'
print(tiger.name)

.deleter(删)

# class Person:
#     def __init__(self,name):
#         self.__name = name
#         self.price = 20
#     @property
#     def name(self):
#         return self.__name
#     @name.deleter
#     def name(self):
#         del self.__name
#     @name.setter
#     def name(self,new_name):
#         self.__name = new_name
# brother2 = Person('狮子')
# del Person.price
# brother2.name = 'newName'
# brother2
# del brother2.name
# print(brother2.name)

classmethod　(类方法)

# 类的操作行为
# class 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_discount):  # 修改折扣
#         cls.__discount = new_discount
# apple = Goods('苹果',5)
# print(apple.price)
# Goods.change_discount(0.5)   # Goods.change_discount(Goods)
# print(apple.price)
# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

　

staticmethod(静态方法)

class Login:
    def __init__(self, name, password):
        self.name = name
        self.pwd = password

    def login(self): pass

    @staticmethod
    def get_usr_pwd():  # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr, pwd)


Login.get_usr_pwd()
# 在完全面向对象的程序中，
# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法