没有女朋友就自己new一个对象叭——python面向对象编程基础

前言

这应该才是大家心目中的面向对象编程叭（哈哈）

不过我们程序猿中很大一部分可能没有这个福利，当你真正学好了一门技术，能用他来赚钱养活自己，给身边的人更好的生活的时候，或许你就可以心安理得的“面向对象”了。
Python设计之初就是一门面向对象的语言，正因为如此，在Python中创建一个类的对象是很容易的，学过C++和Java的同学对面向对象应该比较了解，在面向对象编程中万物皆对象。更多具体的详细的信息大家可以查阅专业的书籍或者博文。

面向对象简介

• 类(class)：用来描述具有相同属性和方法的对象的集合。
• 对象：对象是类的实例。
• 方法：类中定义的函数。
• 实例化：创建一个类的实例，类的具体对象。
• 类变量：类变量在整个实例化对象中是公用的，类变量定义在类中且在函数体之外，类变量通常不作为实例变量使用
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关数据。
• 方法重写：如果父类方法不能满足子类要求，可以对父类的方法进行改写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个self修饰的变量。
• 继承：一个派生类继承基类的字段和方法，使用其属性和方法，也可以有自己特有的属性和方法。

第一个面向对象程序

Cat是一个类，里面有两个方法：eat()和drink()；tom是一个Cat的对象，他可以调用drink和eat方法。
在Python的类方法中，永远都有一个self参数。

class Cat:
    def eat(self):
        print("小猫爱吃鱼")
    def drink(self):
        print("小猫要喝水")
# 创建猫对象
tom = Cat()
tom.eat()
tom.drink()
print(tom)
addr = id(tom)
print(addr)

# 运行结果
小猫爱吃鱼
小猫要喝水
<__main__.Cat object at 0x7f4e631de828>
139974647081000

类的初始化方法

类的初始化方法是__init__()方法，使用类名创建对象时，会自动调用__init__()方法。__ init__()方法类似于C++中的构造函数，用于对象的初始化。

class Cat:
    def __init__(self, new_name):
        print("这是一个初始化方法")
         # self.属性名 = 属性的初始值
        # self.name = "Tom"
        self.name = new_name
    def eat(self):
        print("%s爱吃鱼" % self.name)
# 使用类名（）创建对象的时候，会自动调用初始化方法__init__
tom = Cat("Tom")
print(tom.name)
lazy_cat = Cat("大懒猫")
lazy_cat.eat()

# 运行结果
这是一个初始化方法
Tom
这是一个初始化方法
大懒猫爱吃鱼

类的对象回收方法和字符串方法

对象回收也就是：__ del __ ()方法，字符串方法是： __ str __ ()方法，这个名字可能起的不太对，但是就是这么个意思。__ del __ ()方法类似于析构函数，__ str __()方法是为了在开发中使用print输出对象变量时，能够打印自定义的内容。（__跟del中间没有空格的，这个编辑器有问题）

class Cat:
    def __init__(self, new_name):
        self.name = new_name
        print("%s来了" % self.name)
    def __del__(self):
        print("%s去了" % self.name)
    def __str__(self):
        # 必须返回一个字符串
        return "我是小猫[%s]" % self.name
tom = Cat("Tom")
print(tom)

# 运行结果
Tom来了
我是小猫[Tom]
Tom去了

私有属性和方法

面向对象的特性就是：继承，封装，多态。私有属性和方法就体现了其封装性，在属性和方法名前加上__，就表示这是一个私有属性和方法，在对象内部可以访问私有属性，外界不能访问。

class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18
    def secret(self):
        print("%s的年龄是%d" % (self.name, self.__age))
xiaofang = Women("小芳")
# 私有属性，在外界不能被直接访问
# print(xiaofang.__age)
# 私有方法，同样不允许在外界直接访问
# xiaofang.secret()

单数如果我想要访问的话应该怎么办呢？Python中允许使用"_+类名+私有属性方法名"的方式来访问私有属性和方法。不过为了保护类的封装性，大家还是尽量不要使用这种方式。

继承

Python继承是面向对象编程中一个很重要的特性，继承提高了代码的重用，使得我们在编写程序时能更加的省时省力，提高编程的效率。下面的代码中，Animal类是一个父类，Dog类是继承自Animal的一个子类，Dog类中有Animal类里面所有的属性和方法，所以当我们用Dog类创建一个对象时，可以调用Animal类里的方法。

class Animal:
    def eat(self):
        print("吃---")
    def drink(self):
        print("喝---")
    def run(self):
        print("跑---")
    def sleep(self):
        print("睡---")
class Dog(Animal):
    def bark(self):
        print("汪汪叫")
# 创建一个对象——狗对象
wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()

# 运行结果
吃---
喝---
跑---
睡---
汪汪叫

继承具有传递性，也就是说父类可以派生出子类，子类还可以派生出子类的子类，也就是父类的孙子类…孙子类继承有父类的所有属性和方法，也继承有父类的父类所有的属性和方法。需要注意的是：这种传递性是顺着一条线来传递的，假如父类派生出了另一个子类，他原先那个子类的子类就不能访问这个“叔叔类”里面特有的属性和方法。
重写父类方法：
子类中可以直接重写父类的方法，当用这个子类创建对象的时候，会直接调用子类中重写的方法，不会调用父类的方法。
扩展子类父类方法：
如果我觉得父类中的方法是可以被我再利用的，但是也要添加一些新的东西，这时候我们可以使用super()方法调用原本封装在父类中的方法，也可以使用父类名.方法名(self)的方式。
父类的私有属性和方法：
一般情况下，子类是不能直接调用父类的私有属性和方法的，但是可以通过其公有方法间接地访问父类的私有属性和方法。
多继承：
Python一个子类可以继承多个父类，叫做多继承，这样就涉及到调用顺序的问题了，在Python中子类先调用排在前面的父类，例如：A(B,C)，A类继承自B类和C类，A类对象会先调用B类中的方法。

class A:
    def test(self):
        print("A---test方法")
    def demo(self):
        print("A---demo方法")
class B:
    def test(self):
        print("B---test方法")
    def demo(self):
        print("B---demo方法")
class C(B, A):
    """多继承可以让子类对象，同事具有多个父类的属性和方法"""
    pass
# 创建子类对象
c = C()
c.test()
c.demo()
# 确定C类对象调用方法的顺序
print(C.__mro__)

# 运行结果
B---test方法
B---demo方法
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

多态

多态是不同的子类对象调用相同的父类方法，产生不同的执行结果。

• 多态可以增加代码的灵活度。
• 以继承和重写父类方法为前提。
• 是调用方法的技巧，不会影响到类的内部设计。

class Dog(object):
    def __init__(self,name):
        self.name = name
    def game(self):
        print("%s 蹦蹦跳跳的玩耍..." % self.name)
class XiaoTianQuan(Dog):
    def game(self):
        print("%s飞到天上去玩耍..." % self.name)
class Person(object):
    def __init__(self, name):
        self.name = name
    def game_with_dog(self, dog):
        print("%s和%s快乐的玩耍..." % (self.name, dog.name))
        # 让狗玩耍
        dog.game()
# 1.创建一个狗对象
# wangcai =  Dog("旺财")
wangcai = XiaoTianQuan("飞天旺财")
# 2.创建一个小明对象
xiaoming = Person("小明")
# 3.让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)

类属性，类方法和静态方法

类属性就是给类对象中定义的属性，何为类对象？Python中的类就是一个特殊的对象，类对象只有一个，然而类创建出来的对象有很多个。类属性通常用来记录与这个类相关的特征，不会记录具体对象的特征。类方法同理。一般使用类名.的方式访问类属性，不建议使用对象.的方式，对象.并不会改变类属性的值：

class Tool(object):
    # 使用赋值语句定义类属性，记录所有工具对象的数值
    count = 0
    def __init__(self, name):
        self.name = name
        # 让类属性的值+1
        Tool.count +=1
# 1.创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
# 2.输出工具对象的总数
tool3.count = 99
print("工具对象总数%d" % tool3.count)
print("===>%d" % Tool.count)

# 运行结果
工具对象总数99
===>3

使用类方法要加修饰器，具体参照下面的代码：

class Tool(object):
    # 使用赋值语句定义类属性，记录所有工具对象的数值
    count = 0
    @classmethod
    def show_tool_count(cls):
        print("工具对象的数量%d" % cls.count)
    def __init__(self, name):
        self.name = name
        # 让类属性的值+1
        Tool.count +=1
# 创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
# 调用类方法
Tool.show_tool_count()

# 运行结果
工具对象的数量2

静态方法是一个既不需要访问实例属性或者调用实例方法，也不需要访问类属性或者类方法的一个方法。其定义在@staticmethod之后。

class Dog(object):
    @staticmethod
    def run():
        # 不需要访问实例/类属性
        print("小狗要跑...")
# 通过类名，调用静态方法，不需要创建对象
Dog.run()

最后

有篇文章被推到首页了！希望和大家一起进步！！！有错的地方欢迎指正！