Python的面向对象2

2019-07-24 09:26:06来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

1、面向对象

  1、面向对象的结构

class A:

    company_name = ''  # 静态变量(静态字段)
    __iphone = ''  # 私有静态变量(私有静态字段)


    def __init__(self,name,age): #特殊方法

        self.name = name  #对象属性(普通字段)
        self.__age = age  # 私有对象属性(私有普通字段)

    def func1(self):  # 普通方法
        pass

    def __func(self): #私有方法
        print("哈哈")


    @classmethod  # 类方法
    def class_func(cls):
        """ 定义类方法,至少有一个cls参数 """
        print('类方法')

    @staticmethod  #静态方法
    def static_func():
        """ 定义静态方法 ,无默认参数"""
        print('静态方法')

    @property  # 属性
    def prop(self):
        pass

  2、面向对象的私有与公有

#对于每一个类的成员而言都有两种形式:
#    公有成员,在任何地方都能访问,
#    私有成员,只有在类的内部才能方法
#私有成员和公有成员的访问限制不同:
#静态字段(静态变量)
#    公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
#    私有静态字段:仅类内部可以访问;
#总结:
#对于这些私有成员来说,他们只能在类的内部使用,不能再类的外部以及派生类中使用.
#ps:非要访问私有成员的话,可以通过 对象._类__属性名,但是绝对不允许!!!
#为什么可以通过._类__私有成员名访问呢?因为类在创建时,如果遇到了私有成员(包括私有静态字段,私有普通字段,私有方法)它会将其保存在内存时自动在前面加上_类名.

2、方法

  方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。

class Student:
    def __init__(self,name,age):
        self.__name = name  #对象的私有方法
        self.__age = age
    #普通的实例方法
    def play(self):
        print(self.__name+"来玩啊")
    #类方法,在不需要对象参与的方法中,可以使用类方法
    @classmethod
    def high(cls):
        print("你身高多高?")
  #静态方法,该方法和对象和类都没有关系,就是一个普通的函数
    @staticmethod
    def wahahaha():
        print("谁都管不着我")

3、属性

  1、property是一种特殊的属性,访问它时会执行一段功能(函数)然后返回值

  2、将一个类的函数定义成特性以后,对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的,这种特性的使用方式遵循了统一访问的原则

  3、由于新式类中具有三种访问方式,我们可以根据他们几个属性的访问特点,分别将三个方法定义为对同一个属性:获取、修改、删除

class Foo:
    @property
    def HAHA(self):
        print('get的时候运行我啊')

    @HAHA.setter
    def HAHA(self,value):
        print('set的时候运行我啊')

    @HAHA.deleter
    def HAHA(self):
        print('delete的时候运行我啊')

#只有在属性HAHA定义property后才能定义HAHA.setter,HAHA.deleter
f1=Foo()
f1.HAHA
f1.HAHA='aaa'
del f1.HAHA

或者:
class Foo:
    def get_HAHA(self):
        print('get的时候运行我啊')

    def set_HAHA(self,value):
        print('set的时候运行我啊')

    def delete_HAHA(self):
        print('delete的时候运行我啊')
    HAHA=property(get_HAHA,set_HAHA,delete_HAHA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.HAHA
f1.HAHA='aaa'
del f1.HAHA

4、面相对象的特殊成员及相关内置函数

  1、isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class A: pass

class B(A): pass

abj = B()
print(isinstance(abj,B))  #True
print(isinstance(abj,A))  #True

#isinstance检查abj是否是B的时候,会考虑继承关系
#type(abj,B)和isinstance用法相同,当时不会考虑继承关系

  2、issubclass(sub, super)检查sub类是否是 super 类的派生类

class A: pass

class B(A): pass

abj = B()

print(issubclass(B,A)) #True

  3、enumerate函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列

语法:enumerate(sequence, [start=0])
#sequence -- 一个序列、迭代器或其他支持迭代对象。
#start -- 下标起始位置。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

i = 0
seq = ['one', 'two', 'three']
for element in seq:
...     print i, seq[i]
...     i +=1
... 
#结果:0 one
#1 two
#2 three

5、反射

  1、python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)

class Foo:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性
print(hasattr(obj,'name'))
print(hasattr(obj,'say_hi'))

#获取属性
n=getattr(obj,'name')
print(n)
func=getattr(obj,'say_hi')
func()

print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

#设置属性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'sb')
print(obj.__dict__)
print(obj.show_name(obj))

#删除属性
delattr(obj,'age')
delattr(obj,'show_name')
delattr(obj,'show_name111')#不存在,则报错

print(obj.__dict__)

 6、内置方法(魔术方法)

  1、__call__(self, *args, **kwargs)

    对象后面加括号,触发执行。注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

class Foo:
    def __init__(self):
        pass    
    def __call__(self, *args, **kwargs):
        print('__call__')

obj = Foo() # 执行 __init__
obj()       # 执行 __call__

   2、__len__(self):长度方法

    len(对象)函数,执行实际调用的是对象内的__len__函数,如果该对象没有__len__方法,则会报差错

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)
a = A()
print(len(a))

  3、__init__(self):初始化方法

#初始化方法
#1、首先开辟一块内存空间
#2、把对象空间传给self,执行init
#3、把这个对象的空间返回给该对象

  4、__new__(cls, *args, **kwargs):构造方法

    4.1、__new__方法在实例化之后,__init__之前调用

#__new__方法在实例化之后,__init__之前调用
class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        print('in new function')
        return object.__new__(A)

a = A()
print(a.x)

    4.2、单例模式

#单例模式
class A:
    __ISINSTANCE = None

    def __new__(cls,*args,**kwargs):
        if not cls.__ISINSTANCE:
            cls.__ISINSTANCE = object.__new__(cls)
        return cls.__ISINSTANCE

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


a = A("张三",20)
b = A("李四",25)
print(a.name)
print(b.name)
print(a,b)

  5、__str__(self)

class A:
    def __init__(self):
        pass
    def __str__(self):
        return '太白'
a = A()
print(a)
print('%s' % a)

#print方法相当于调用__str__
#str()相当于调用__str__
#'%s'%obj相当于调用__str__

   6、__repr__(self)

class A:
    def __init__(self):
        pass
    def __repr__(self):
        return 'haha'
a = A()
print(repr(a))
print('%r'%a)

  7、__del__(self)

析构方法,当对象在内存中被释放时,自动触发执行。

注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

  8、item系列

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

  9、hash(self)

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))

 


原文链接:https://www.cnblogs.com/jknote/p/11212027.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Python习题001

下一篇:1.日期时间字符串转时间戳