python面向对象总结

一.面向对象思想得由来：

什么是面向对象

面向对象是对函数的封装 , 是以人认识事物来编写代码 万物皆对象

举个例子：，就比如我们日常生活中经常用到的热水器，每次洗澡就可以直接使用热水，但是如果没有热水器，我们需要去用壶接水，然后将其倒入锅中，还需要寻找加热方式，比如烧柴或者煤气灶，
然后烧开之后将开水和凉水混合我们才可以洗个舒服的热水澡，但是，后来有人将这一系列操作封装成热水器，我们只需要直接打开开关，无需思考任何流程就可以直接洗澡了，无疑这种封装将复杂的事情简单化，
我们从执行者变成了指挥者。这其中，关于如何将水烧开一系列的操作都是面向过程的，直接控制热水器是面向对象的思想。

二. 面向对象的基本语法：

2.1 类的创建和实例化

语法格式如下:
class MyClass:
    """一个简单的类"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

"""执行以上程序输出结果为："""

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

2.2 self的讲解

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()


"""以上实例执行结果为："""

<__main__.Test instance at 0x100771878>
__main__.Test

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

2.3常用的魔法函数

2.3.1 什么是魔法函数:

就是在特定的场景自动触发的函数 例:

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)  

 " 输出结果：3.0 -4.5"

常用的魔法函数有四个分别是:

2.4 魔法函数的实例:

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

三. 面向对象的三大特征

3.1 封装:

封装是对类属性和方法的数据安全性提高

class Site:
	__sex="男"	#私有类属性
	
    def __init__(self, name,url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site("笑得好虚伪","https://blog.csdn.net/qq_48082548")
x.who()        # 正常输出
x.foo()        # 正常输出
x.__sex		   # 报错
x.__foo()      # 报错

3.2 继承:

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

总结：继承就是你的就是我的，我的还是我的，

注意：
当本类和多重继承的时候方法名相同，默认调用的是本类中的方法

当多重继承的时候方法名相同，默认调用的是在括号中排前地父类的方法

当继承类有私有属性是不能继承的

3.3 多态:

3.3.1多态的特点:

1、只关心对象的实例方法是否同名，不关心对象所属的类型；

2、对象所属的类之间，继承关系可有可无；

3、多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；

4、多态是调用方法的技巧，不会影响到类的内部设计。

3.3.2 实例:

class Duck(object):                                  # 鸭子类
    def fly(self):
        print("鸭子沿着地面飞起来了")

class Swan(object):                                  # 天鹅类
    def fly(self):
        print("天鹅在空中翱翔")

class Plane(object):                                 # 飞机类
    def fly(self):
        print("飞机隆隆地起飞了")

def fly(obj):                                        # 实现飞的功能函数
    obj.fly()

duck = Duck()
fly(duck)

swan = Swan()
fly(swan)

plane = Plane()
fly(plane)

"""运行结果："""

鸭子沿着地面飞起来了

天鹅在空中翱翔

飞机隆隆地起飞了

四. 元类

类方法:(静态属性@classmethod)

类对象和实例对象都能调用
例:

class Swan(object):                                  # 天鹅类
    @classmethod
    def fly(cls):
        cls.Swan=print("天鹅在空中翱翔")

Swan.fly()

@property

将函数调用方法( a.函数名() )设置成调用属性的形式例:a.函数名不加括号

class Swan(object):                                  # 天鹅类
    @property
    def fly(self):
        print("天鹅在空中翱翔")

a=Swan()
a.fly