python------面向对象进阶

Posted 2021-01-10 bltstop

*面向对象高级语法部分   （不常用，了解）
     静态方法、类方法、属性方法
    类的特殊方法
    反射
*异常处理
*Socket开发基础

一.面向对象高级语法部分
1.静态方法 
    @staticmethod
   只是名义上归类管理，实际上在静态方法里访问不了类或者实例中的任何属性。
class Dog(object):
    def __init__(self,name):
        self.name = name

    @staticmethod   #实际上跟类没有什么关系了，也不用self.的属性。非要用的话，
                    #就不传d.eat = ("包子")，而是传对象d.eat = (d)，既然人家称为静态了，
                #就不要用self的方式。   不常用
    def eat(self,food):
        print("%s is eating %s" %(self.name,food))

d = Dog("xaiznlaizi")
d.eat = (d)

2.类方法 
     @classmethod
     类方法只能访问类变量，不能访问实例变量。（不常用）3.属性方法

@property


把一个方法变成一个静态属性。

class Dog(object):

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

    @property  # 属性方法不能传参数
    def eat(self):
        print("%s is eating %s" % (self.name, "包子"))

    @eat.setter  # 只能通过给属性赋值。
    def eat(self, food):
        print("set to food:", food)

        @eat.setter  # 删除属性

    def eat(self):
        del self.__food
        print("删完了")


d = Dog("xiaolaizi")
d.eat

4.
类的特殊方法（成员）

1)__doc__: 查看描述文档
2)__module__: 查看当前操作的对象在哪个模块
__class__: 查看当前操作的对象的类是什么
3)__init__: 构造方法，通过类创建对象时，自动触发执行
4)__del__: 析构方法，当对象在内存中被释放时，自动触发执行。
注: 此方法一般无须定义，python是一门高级语言，程序员在使用时无须关心内存的分配和释放
因为此工作都是交给python解释器来执行的，所以，析构函数的调用是由解释器在进行垃圾回收时
自动触发执行的。
5)__call__: 对象后面加括号，触发执行
注：构造方法的执行时由创建对象触发的，即：对象 = 类名();
而对于__call__方法的执行
是由对象后面加括号触发的，即：对象()
或者
类()()
6)__dict__: 查看类或对象中的所有成员。

类.__dict__: 打印类里的所有属性，不包括实例属性
对象.__dict__: 打印实例属性，不包括类的属性。
7)__str__: 如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值。
8)__getitem__ / __setitem__ / __delitem__: 用于索引操作，如字典。以上分别表示获取、设置、删除数据。
9)__new__ / __metaclass__:


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


f = Foo("xiaolaizi")
上述代码中，f是通过Foo实例化的对象，其实，不仅f是一个对象，Foo类本身也是一个对象，因为在Python中
一切事物都是对象， 那么问题来了：Foo对象后的类又是谁呢？？？（生命的本源）

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

f = Foo("xiaolaizi")
print(type(f))  
print(type(Foo))

运行结果：

<class ‘__main__.Foo‘>    #ojb对象由Foo类创建
<class ‘type‘>            #Foo类由type类创建

那么，创建类就有两种方式：

1）普通方式：（我们经常用的就是）

1 class Foo(object):
2     def __init__(self,name):
3         self.name = name
4         print("name : %s" ,%self.name)
5 
6 f = Foo("xiaolaizi")

2）特殊方式：

 

1 def func(self):
2     print("Hello xiaolaizi")
3 
4 Foo = type(‘Foo‘,(),{‘talk‘: func})   
5 f = Foo()
6 f.talk()
7 
8 print(type(Foo))

所以：类是由type类实例化产生。

def func(self):
    print("Hello xiaolaizi")
def __init__(self,name,age):
    self.name  = name
    self.age = age

Foo = type(‘Foo‘,(object,),{‘talk‘: func,‘__init__‘:__init__})  #(object,)加个逗号，认为是元组。
f = Foo("zahngsan",23)
f.talk()

print(type(Foo))         #注：这种我们基本不会用到（了解）。

　　那么，type类中如何实现的创建类？类又是如何创建对象？

     __mataclass__

详见：www.cnblogs.com/alex3714/articles/5213184.html