class Person:

    __key = 123456                  # 私有的静态属性

    def __init__(self,name,passwd):

        self.name = name

        self.__passwd = passwd      # 私有的属性

    def __test(self):                # 私有方法

        print(self.__dict__)

        print('私有方法内部调用')        ## 只要在类的内部使用私有属性，就会自动带上_类名

    def test2(self):

        return self.__test            # 私有方法只能在内部调用

    def get_pwd(self):

        # return self.get_pwd

        return self.__passwd

alex = Person('alex',123456)

alex.__high = 170

# print(alex.getwd())             # 程序定义__私有属性，保存为了(_类__属性)的形式

print(alex.__high)              ## 在类的外部定义的双下划线方法，可以被调用，格式也有变化。

print(alex.get_pwd())

ret = alex.test2()

print(ret)

ret()
###############
170

123456

<bound method Person.__test of <__main__.Person object at 0x00000200B052EC50>>

{'name': 'alex', '_Person__passwd': 123456, '__high': 170}

私有方法内部调用

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)
##################

78.53981633974483

31.41592653589793

class Foo:

    @property

    def AAA(self):

        print('get的时候运行我啊')

    @AAA.setter

    def AAA(self,value):

        print('set的时候运行我啊')

    @AAA.deleter

    def AAA(self):

        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter

f1=Foo()

f1.AAA

f1.AAA='aaa'

del f1.AAA

#########

get的时候运行我啊

set的时候运行我啊

delete的时候运行我啊

class Goods:

    def __init__(self):

        # 原价

        self.original_price = 100

        # 折扣

        self.discount = 0.8

    @property

    def price(self):

        # 实际价格 = 原价 * 折扣

        new_price = self.original_price * self.discount

        return new_price

    @price.setter

    def price(self, value):　　　　　　　　# setter要在self，后面加入一个参数，设置得参数

        self.original_price = value

    @price.deleter

    def price(self):

        del self.original_price

obj = Goods()

obj.price         # 获取商品价格

obj.price = 200   # 修改商品原价

print(obj.price)

del obj.price     # 删除商品原价

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　　# 返回折扣价格

    # def change_discount(self,new_discount):     # 修改一个新的折扣

    #     Goods.__discount = new_discount

    @classmethod        　　　　　　　　　　　　　　　　# 把一个方法变成类的方法，这个方法可以被类直接调用。不需要依赖任何对象

    def change_discount(cls,new_discount):　　　　  # 这里在定义类方法得时候，还需要再传入一个参数

        cls.__discount = new_discount

apple = Goods('apple',5)

# apple.change_discount(0.5)      # 这里我们使用苹果去定义整个商品的折扣是不合理的

# print(apple.price)

Goods.change_discount(0.5)

print(apple.price)

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()

class Teacher:

    dic = {'显示课程':'数学','显示班级':'2014届'}

    def show_price(self):

        print('工资5000快')

    @classmethod

    def func(cls):

        print('体育老师')

ret = getattr(Teacher,'dic')         # 1.调用静态属性：类的静态属性可以直接获取

print(ret)

tom = Teacher()

ret2 = getattr(tom,'show_price')    # 2.调用对象属性：实例化一个类对象然后再获取其对象属性

# print(ret2)

ret2()

if hasattr(Teacher,'func'):              # 一般 hasattr 和 getattr 一起使用,不存在则不报错

    ret3 = getattr(Teacher,'func')       # 3.调用类方法：类方法的调用，直接调用需要实例化

    ret3()

{'显示课程': '数学', '显示班级': '2014届'}

工资5000快

体育老师