Python开发第五篇

面向对象程序设计

面向过程编程：就是分析问题的解决步骤，按部就班的编写代码解决问题

函数式编程：就是把代码封装到函数中，然后在使用时调用封装好的函数

面向对象编程：把一类事物所共有的属性和行为提取出来，从而增加程序的扩展性

一、什么是面向对象程序设计？

　　面向对象程序设计（Object-oriented programming，OOP）是一种程序设计范型，也是一种程序开发方法。将一类事物的动作和特征整合到一起就是面向对象程序设计

二、什么是类？什么是对象？

　　类：一类事物共有的特征和行为

　　对象：某个具有类中属性和行为的个体

三、类的声明

class Foo(object):#新式类,
    pass

class Foo():#经典类
    pass
"""
在Python 2及以前的版本中，由任意内置类型派生出的类（只要一个内置类型位于类树的某个位置），都属于“新式类”，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，则称之为“经典类”。

“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。
"""

四、类的属性

　　数据属性：类中的变量

　　函数属性：类中定义的方法

五、类内置方法

　　①__dict__属性字典

　　　　对象的属性字典只有数据属性，因为对象之间是共享类的函数属性的

　　　　类的属性字典，包括类的数据属性和函数属

class Foo(object):
    x = 10
    def __init__(self,a):
        self.a = a
    def show_a(self):
        print(self.a)

f1 = Foo(2)
print(f1.__dict__)
print(Foo.__dict__)


{'a': 2}
{'__module__': '__main__', 'x': 10, '__init__': <function Foo.__init__ at 0x000002A051CC4AE8>, 'show_a': <function Foo.show_a at 0x000002A051CC4B70>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}

　　②__name__类名

print(Foo.__name__)

Foo

　　③__bases__基类

class Foo():
    pass

class Boo(Foo):
    pass

print(Boo.__bases__)#返回元组形式

(<class '__main__.Foo'>,)

　　④__init__() 初始化方法

class Foo():
    def __init__(self):
        print("创建类对象时执行初始化方法")

f1 = Foo()#实例化类，也就是创建类对象

创建类对象时执行初始化方法

六、对象访问类中的变量的顺序　

　　实例化的对象访问类中的变量时，先访问初始化方法init中的属性，如若没有就会访问init方法外的类里的，再没有就会报错

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

f1 = Foo(2)
print(f1.a)


2

class Foo(object):
    x = 10
    def __init__(self,a):
        self.a = a
    def show_a(self):
        print(self.a)

f1 = Foo(2)
print(f1.x)

10

class Foo(object):
    x = 10
    def __init__(self,a):
        self.a = a
    def show_a(self):
        print(self.a)

f1 = Foo(2)
print(f1.q)

AttributeError: 'Foo' object has no attribute 'q'

七、实例化对象只会保存init方法中的变量，只含有数据属性，需要调用类的函数属性

八、类调用类方法需要指定self参数，参数任意

class Foo():
    def show(self):
        print("show")


#Foo.show(1)
#Foo.show(“sunqi”)
#Foo.show([1,2,3])


show

九、实例增加方法时需要需要传self参数

class Foo():
    def __init__(self,a):
        self.a = a
    def show(self):
        print("show")

f1 = Foo("111")
def hello(self):
    print("hello")

f1.fun = hello
f1.fun("sss")#必须指定self参数（可以是任意对象）
print(f1.__dict__)

hello

 十、property 方法

　　property方法会将类中的定义的方法变成变量，直接返回结果，隐藏逻辑

　　加括号调用时会报错　　　　

class Foo():
    def __init__(self,a,b):
        self.a = a
        self.b = b
    # @property
    def cal(self):
        return self.a + self.b
f1 = Foo(1,2)
print(f1.cal)


<bound method Foo.cal of <__main__.Foo object at 0x0000019C642E2128>>

class Foo():
    def __init__(self,a,b):
        self.a = a
        self.b = b
    @property
    def cal(self):
        return self.a + self.b
f1 = Foo(1,2)
print(f1.cal)


3

十一、类方法classmethod

 　当我们想要用类调用类中定义的方法且不希望指定self对象是，我们就可以 采用classmethod声明一个类方法

@classmethod
def tell_info(cls,[name,x])：可用更多参数
    pass

class Foo():
    def func1(self):
        print("类中的方法")

    @classmethod
    def func3(cls,x):#类方法cls参数python自动指定类名，其他参数必须传值
        print("cls--name",cls.__name__)
        print("-->",x)


f1 = Foo()
f1.func3(1)
print("*"*10)
Foo.func3(1)
print(f1.func3)
print(Foo.func3)


cls--name Foo
--> 1
**********
cls--name Foo
--> 1
<bound method Foo.func3 of <class '__main__.Foo'>>
<bound method Foo.func3 of <class '__main__.Foo'>>

十二、静态方法staticmethod

　　类中的没有修饰符，没有self，没有cls的普通方法实例是不能调用的，因为会默认给该方法穿第一个self参数，会报错

class Foo():
    def func():
        print("func1")
f1 = Foo()
f1.func()

默认传参self
TypeError: func() takes 0 positional arguments but 1 was given

　　那么我们如何用实例调用这种方法。这时候就需要用staticmethod声明一个普通方法

class Foo():
    @staticmethod
    def func():
        print("func1")
f1 = Foo()
f1.func()

func1

 十三、getattr，hasattr，setattr，delattr反射

hasattr（b1,"name"） 检测object中有没有一个name字符串对应的属性
getattr(b1,"name"),default 得到属性的值，设置default时 即使没有参数不会报错
setattr(b1,"name"," ")设置对象属性值，也可以添加函数属性 可以是匿名函数
delattr(b1,"name")删除对象的属性

class B():
    c = 1
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def func(self):
        print(self.a)
        print(self.b)

def fun():
    print("fun")

b1 = B(1,2)
# print(hasattr(b1,"func"))#判断对象是否有name属性
# print(getattr(b1,"func","not exist"))#存在就会返回该对象
# print(getattr(b1,"sun","not exist"))#不存在返回设置的默认值
# print(getattr(b1,"a"))#1
# print(setattr(b1,"func1",lambda x:x+1))
# print(setattr(b1,"func1",fun))#增加属性，函数和变量皆可 无返回值
# print(b1.__dict__)
# delattr(b1,"a")#删除属性
# print(b1.__dict__)
# print(hasattr(B,"a"))
# print(hasattr(B,"func"))
# getattr(B,"func")(b1)
# print(B.__dict__)
# print(getattr(B,"a"))#找不到实例变量
# delattr(B,"a")
# delattr(B,"c")#可以找到类变量
# print(getattr(B,"c","not exist"))

十四、__setattr__(),__getattr__(),__delattr__()属性字典操作

__setattr__()设置对象属性时会触发setattr，写入属性字典
__getattr__()调用一个对象不存在的属性时才会用
__delattr__()删除对象属性的时候会触发

三者都是直接操作属性字典

class B():
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def __setattr__(self, key, value):
        self.__dict__[key] = value
        # self.key = value
    def __getattr__(self, item):
        print("__getattr__")
        return "not exist"
    def __delattr__(self, item):
        del self.__dict__[item]
    def func(self):
        print(self.a+self.b)
b1 = B(1,2)

# print(b1.__dict__)

# b1.__setattr__("sun","qi")#直接操作属性字典__dict__
# print(b1.__dict__)
# print(b1.a)#1
# print(b1.c)#调用不存在的变量时才会触发getattr方法


# print(b1.__dict__)#{'a': 1, 'b': 2}
# b1.__delattr__("a")
# print(b1.__dict__)#{''b': 2}

十五、__getitem__(),__setitem__(),__delitem__()中括号调用属性时操作

__xxxitem__:使用 [''] 的方式操作属性时被调用
__setitem__:每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name         = value 会死循环
__getitem__:当访问不存在的属性时会调用该方法
__delitem__:当删除属性时调用该方法

class B():
    c = 1
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def __getitem__(self, item):
        print("get %s"%item)
        return self.__dict__[item]
    def __setitem__(self, key, value):
        print("key %s  value %s"%(key,value))
        self.__dict__[key] = value
    def __delitem__(self, key):
        print("del %s"%key)
        del self.__dict__[key]

b1 = B(1,2)
def func():
    print("func")
# print(b1["a"])#访问存在的变量时会调用getitem方法
# print(b1["d"])#访问不存在的变量时也会触发getitem方法
# b1["d"] = 3#设置属性时会触发setitem方法
# b1["func"] = func
# print(b1.__dict__)
# del b1["a"]
# print(b1.__dict__)#删除属性时会触发delitem方法