16.面向对象程序设计入门 ——02

时间:2021-08-24
本文章向大家介绍16.面向对象程序设计入门 ——02,主要包括16.面向对象程序设计入门 ——02使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

绑定方法

# 绑定方法分为两种:
	1. 绑定给对象的  # 就是让对象来调用的
    2. 绑定给类的	# 就是让类来调用的
    
# 1. 绑定给对象的
class Student():
    school = 'SH'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 在类中书写方法,默认绑定给对象使用的
    def tell_info(self):
        print("%s-%s" % (self.name, self.age))

    def func(self):
        print("func")

obj = Student('egon', 18)
obj.tell_info()
obj.func()
    
# 2. 

import settings
class Mysql:
    school = 'SH'

    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    @classmethod # 意味着该方法绑定给类了,类来调用,会把类型当成第一个参数传过来
    def func(cls):
        # class_name => Mysql
        print(cls)
        return cls(settings.IP, settings.PORT)
        # return self.__class__(settings.IP, settings.PORT)
        # return Oracle(settings.IP, settings.PORT)

obj = Mysql(settings.IP, settings.PORT)

"""
总结:
    1. 绑定给对象的
        对象来调用,把对象自己当成第一个参数传递
    2. 绑定给类的方法
        @classmethod
        类来调用,把类名当成第一个参数传递
"""

非绑定方法

"""
非绑定方法:即不绑定给对象,也不绑定给类
"""

# import uuid
# print(uuid.uuid4())


class Test():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.id = self.create_id()

    @staticmethod  # 静态方法
    def create_id():
        import uuid
        return uuid.uuid4()


obj = Test('egon', 18)
print(obj.id)

# 用类调用
# print(Test.create_id())

# 用对象调用
print(obj.create_id())

如何隐藏属性

Python的Class机制采用双下划线开头的方式将属性隐藏起来(设置成私有的),但其实这仅仅只是一种变形操作,类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成“_类名__属性名”的形式:

class Foo:
    __N=0 # 变形为_Foo__N

    def __init__(self): # 定义函数时,会检测函数语法,所以__开头的属性也会变形
        self.__x=10 # 变形为self._Foo__x

    def __f1(self): # 变形为_Foo__f1
        print('__f1 run')

    def f2(self):  # 定义函数时,会检测函数语法,所以__开头的属性也会变形
        self.__f1() #变形为self._Foo__f1()

print(Foo.__N) # 报错AttributeError:类Foo没有属性__N

obj = Foo()
print(obbj.__x) # 报错AttributeError:对象obj没有属性__x

这种变形需要注意的问题是:

1、在类外部无法直接访问双下滑线开头的属性,但知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如Foo._A__N,所以说这种操作并没有严格意义上地限制外部访问,仅仅只是一种语法意义上的变形。

>>> Foo.__dict__
mappingproxy({..., '_Foo__N': 0, ...})

>>> obj.__dict__
{'_Foo__x': 10}

>>> Foo._Foo__N
0
>>> obj._Foo__x
10
>>> obj._Foo__N
0

2、在类内部是可以直接访问双下滑线开头的属性的,比如self.__f1(),因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。

>>> obj.f2()
__f1 run

3、变形操作只在类定义阶段发生一次,在类定义之后的赋值操作,不会变形。

>>> Foo.__M=100
>>> Foo.__dict__
mappingproxy({..., '__M': 100,...})
>>> Foo.__M
100

>>> obj.__y=20
>>> obj.__dict__
{'__y': 20, '_Foo__x': 10}
>>> obj.__y
20

property装饰器

property装饰器: 就是将函数功能封装成数据属性

class Student():
    __school = 'SH'  # _Student__school
    __name = 'egon'
    def __init__(self, name):
        self.__name = name  # self._Student__name

    def __func(self):  # _Student__func
        print('func')

    # @property  # 这个函数已经变成了属性
    # def get_name(self):
    #     return self.__name  # self._Student__school\

    @property  # 这个函数已经变成了属性
    def name(self):
        return self.__name  # self._Student__school

    @name.setter
    def name(self, v):
        self.__name = v

    @name.deleter
    def name(self):
        del self.__name

原文地址:https://www.cnblogs.com/hhf1751342707/p/15180936.html