python面向对象概念_Python 面向对象

1.构造函数

构造函数：__init__(参数列表) ：在使用类创建对象时自动调用。

注意：如果自己不写构造函数，系统默认也会加上一个空的构造函数。

对象属性的优先级高于类属性，当对象调用属性时，如果有对象属性时，先获取对象属性的值；如果没有对象属性，会去找同样名字的类属性；如果没有同样名字的类属性，返回一个错误。

class Person():

# 直接写在class中的属性叫类属性(可以通过类名直接调用)

# name = ""

# age = 0

# 默认的构造函数(在init方法中的属性叫对象属性)

# __init__函数没有返回值，不能写return

# def __init__(self):

# pass

# 自己重新写构造函数时，只能更改参数列表及函数体，不能写return这条语句

# def __init__(self):

# print("我显示的是init函数")

def __init__(self, name, age, weight=30.0):

print("小兔子乖乖")

# 对象属性(定义在构造函数中的属性为对象属性)

self.name = name

self.age = age

self.weight = weight

# 建议：一个类中最好只有一个init函数，如果写了多个，程序不会报错，

# 但是只会执行最后一个写的init函数

def eat(self):

print("person--eat")

def sleep(self, hours):

print("我睡了%d小时" % hours)

# 建议使用关键字 实例化对象

per1 = Person(name="Lily", age=30, weight=50.0)

2.self和__class__

self:当前类的实例对象，但是在类中用self表示。

哪个对象调用带有self参数的方法时，self就指向哪一个对象。

__class__: 代表当前类的类名。

self:不是关键字，换成其他的词语也可以，只要类中的成员方法至少有一个形参即可，第一个形参就代表当前类的实例对象

3.析构函数

析构函数：__del__() : 释放对象时调用，销毁对象时调用。

class Person():

# 构造函数

def __init__(self, name):

self.name = name

def __del__(self):

print('析构函数' + self.name)

per1 = Person('tom')

per2 = Person('lucy')

per3 = Person('lily')

# del per3.name 删除对象属性

# del per3 # 手动删除优先级高 先删除lily 然后执行类里的析构函数，系统的自动回收

def fun1():

per4 = Person('Json') # 局部变量

print(per4.name)

fun1() # Json 析构函数Json 用完函数后 per4 被析构函数回收

4.__str__函数

在使用print打印对象时会自动调用，这个方法是给用户使用的，是描述对象的方法。

class Person():

def __init__(self, name, age, sex):

self.name = name

self.sex = sex

self.age = age

# 可以在类中重新写__str__方法

# 要求必须有返回值，返回值类型str类型

def __str__(self):

sexStr = ""

if self.sex == 1:

sexStr = "女"

elif self.sex == 0:

sexStr = "男"

return "姓名为%s, 年龄为%d，性别为%s" %(self.name, self.age, sexStr)

5.访问限制

私有属性子类不能继承，子类的对象不能使用

实例对象不能直接访问私有属性__age,因为python解释器把__age私有属性变成了_Person__age， 我们就可以通过_Person__age访问私有属性__age。强烈建议：不要这么干

class Person():

def __init__(self, name, age, weight, height):

# 公有属性：能够在当前类、当前类的实例对象、子类中均能使用

self.name = name

# 私有属性: 只能在当前类中使用

# 格式：__属性名(只在属性名前面加两个下划线)

self.__age = age

# 格式：__变量名__：在python中属于特殊变量，可以直接访问，类似公有属性

self.__weight__ = weight

# 格式: _变量名:在python中能够正常访问，类似公有属性，但是，当我们

# 看到这种属性时，把它当成是私有属性使用。

# _变量名(虽然我现在能直接访问并使用，但请把我当成私有属性，不要用

# 对象直接访问)

self._height = height

# set方法：赋值

def setAge(self, age):

if age < 0:

self.__age = 20

else:

self.__age = age

# get方法: 取值

def getAge(self):

return self.__age + 20

def setName(self, name):

self.name = name

def getName(self):

return self.name

6.继承

class Animal():

def __init__(self, name, color, age):

self.name = name

self.age = age

# 私有属性

self.__color = color

def run(self):

print(self.__color)

print("run")

def eat(self):

print("eat")

class Cat(Animal):

def __init__(self, name, age, color, miao):

# 调用父类的__init__方法

# 父类名称.__init__(self, 根据父类形参赋值实参)

Animal.__init__(self, name, color, age)

# 使用super关键字调用init方法(同上)

# super(Cat, self).__init__(name, color, age)

# 子类可以有自己独有的属性

self.miao = miao

7.多重继承和多继承

单继承：一个子类只有一个父类

多重继承：子类有父类，父类又有父类 ： 父类->子类->子子类。。。。。

多继承： Son -> Father,Mother

注意：如果父类们中的方法名相同，默认调用小括号中排在前面的父类中的方法(就近原则)

8.类方法及静态方法

类方法 @classmethod

类方法一般来说使用类名调用。

类方法类和对象均能调用，但是不管是类还是对象调用，cls都代表类；比如当前例子中，cls就代表Person，cls不是关键字，使用其他形参名称也可以，总之，类方法的第一个形参就代表类。

静态方法 @staticmethod

静态方法一般来说不是给对象是用的，一般使用类名调用

静态方法就是一个普通函数，不会默认需要传参数

类和对象均能调用，但一般使用类名调用

class Person():

# 对象方法，使用实例对象调用

def eat(self):

print("eat")

# 类方法 @classmethod

@classmethod

def play(cls, a, b):

print("类方法", a+b)

print(cls)

# 静态方法 @staticmethod

@staticmethod

def run(num1, num2):

print(num1 + num2)

9.动态添加属性及方法及__slots__属性

from types import MethodType

class Person():

def run(self):

print("run")

pass

# 动态添加属性

per1 = Person()

per1.name = "Lily"

print(per1.name)

# 动态添加方法

def say(self):

print("say")

# MethodType(函数名称, 当前实例对象的名称)

# 把当前的实例对象传递给函数的第一个形参

per1.saying = MethodType(say, per1)

per1.saying()

思考：如果我们要限制动态添加属性或方法的个数及名称怎么办？比如我们只能动态添加name及age属性，run方法。为了达到要求，python允许在定义类时，定义一个特殊的属性__slots__属性变量，__slots__属性可以限制动态添加的属性及方法的名称。

__slots__ :使用元组的方式赋值

注：__slots__定义的属性只对当前类有效，对它继承的子类无效；

如果子类中也定义了__slots__属性，这样定义的属性的个数为子类本身的内容加上父类中定义的内容。

class Student():

__slots__ = ("name", "age", "run")

pass

stu1 = Student()

stu1.name = "Tom"

# stu1.weight = 56.7 # 错误，不允许添加

def run(self, a, b):

print("run", a+b)

stu1.run = MethodType(run, stu1)

stu1.run(2,3)

10.@property

@property 装饰器

@property: 可以使对象通过点方法访问私有属性。

class Person():

def __init__(self, name, age):

# 公有属性

self.name = name

# 私有属性

self.__age = age

@property

def age(self):

return self.__age

@age.setter

def age(self, age):

if age < 0:

age = 1

self.__age = age

per1 = Person(name="二胖", age=1)

# 如果属性为公有属性，对象可以直接调用进行更改或使用

# 这样，不安全，数据可以直接被重新赋值，而且没有任何限制条件。

# 相当于调用set方法，现在调用的是加了@age.setter装饰器的方法

per1.age = 99

# 相当于调用get方法，现在调用的是加了@property装饰器的方法

print(per1.age)

11.运算符重载

class Person():

def __init__(self, num):

self.num = num

# 打印对象时调用

def __str__(self):

return "目前num为：" + str(self.num)

# 运算符重载

def __add__(self, other):

return Person(self.num + other.num)

def __mul__(self, other):

return Person(self.num * other.num)

p1 = Person(100)

print(p1)

p2 = Person(266)

print(p2)

print(p1 + p2) # p1.__add__(p2) __add__(self, other)

Person(111)

Person(111)

print(p1 * p2)

__init__: 构造函数

__del__:析构函数

__str__:打印对象

__add__:加运算

__mul__:乘运算

__sub__:减运算

__mod__:余运算

__div__:除运算

__pow__:幂运算

12.抽象类

在开发中，我们遇到的所有事物都是对象，对象是通过类创建的。但是不是所有的类都是用来描述对象的。如果一个类中没有足够的条件信息来描述一个具体的事物/对象，而需要其他具体的类来辅助他，那么，这样的类我们称之为抽象类。

抽象类中可以有抽象方法，一般包含抽象方法的类都是抽象类。

抽象方法可以不包含任何方法实现的代码，只有一个方法名字，但是，在子类中要求必须实现该抽象方法，否则，子类也为抽象类。

类是从一堆对象中抽取相同的属性及方法得出的，抽象类就是从一堆类中抽取相同的属性及方法得出的。

抽象类不能实例化对象。

1、定义抽象类

在定义抽象类之前，我们需要导入模块abc中的ABCMeta类(抽象基类的元类)(Metaclass for defining Abstract BaseClass)。在定义抽象类时，我们需要在代码中加入 metaclass=ABCMeta,指定该类的元类为ABCMeta元类：创建一个类的类。

抽象类不能实例化对象。

抽象类一般都用作父类。

2、定义抽象方法

在定义抽象方法之前，我们需要导入模块abc中的abstractmethod类。

在定义抽象方法时，我们需要在方法前面加上@abstractmethod修饰词。

因为抽象方法一般不需要在抽象类中实现，我们只需要在抽象方法的函数体中写一条pass语句即可。

3、实现类

实现类为抽象类的子类。

如果实现类不实现父类(抽象类)中的抽象方法，那么该类也是抽象类；

如果实现类实现了父类(抽象类)中的抽象方法，那么该类就是普通类，可以实例化对象。

from abc import ABCMeta, abstractmethod

# 定义抽象类

class Animal(metaclass=ABCMeta):

# 定义属性

def __init__(self, color):

self.color = color

# 对象方法

def eat(self):

print("Animal--eat")

# 定义抽象方法

@abstractmethod

def play(self):

pass

# 创建实现类(以一个抽象类为父类)

class Cat(Animal):

def __init__(self, color, name):

Animal.__init__(self, color)

self.name = name

# 子类实现父类的抽象方法

def play(self):

print("cat--play")

cat1 = Cat(color="black", name="旺财")

print(cat1.color)

13.接口

真正的接口中不能定义变量，接口中只能有抽象方法。

1.什么是接口 interface，接口都是当作父类使用。

子类实现接口中的抽象方法。

在python中没有interface这个关键字，我们目前所写的接口只是通过抽象类仿写，

所以，目前，接口可以认为就是一个类，一个只包含抽象方法并且不能实例化对象的类。其子类如果想要实例化对象，必须实现接口中所有的抽象方法。

2.为什么要使用接口？

接口本身就是一系列方法的声明，一些特殊方法的集合，一个接口中只有方法的声明，但是没有方法的实现，这些特殊的方法要在不同的类之间进行不同的实现。接口本身是用于封装代码的。

例子：鸟类和昆虫类都有飞行的行为，功能相同，但实现内容不同，二者如果抽象出一个类不太方便，但可以抽象一个接口，用于飞行行为的封装。

3.注意：一般在接口中只有方法的声明，没有方法的实现。在接口中不能出现变量。

from abc import abstractmethod

# 定义接口

class Interface: # 仿写接口

# 定义抽象方法

@abstractmethod

def fly(self):

pass

# ...

# 定义接口的实现类

class Bird(Interface):

def __init__(self, leg):

self.leg = leg

def egg(self):

print("鸟生蛋")

def fly(self):

print("小鸟飞的高")

class Insect(Interface):

def __init__(self, leg):

self.leg = leg

def spawn(self):

print("昆虫产卵")

def fly(self):

print("昆虫飞的低")

b1 = Bird(2)

b1.fly()

i1 = Insect(6)

i1.fly()

14.多态

面向对象的三大特征： 封装，继承，多态

多态：一种事物的多种形态，子类可以认为是父类的不同形态的实现

python是弱类型语言,声明变量时，不要求数据类型，根据赋值的类型去确定该变量的类型。c，Java强类型语言，声明变量时，已经确定该变量的数据类型，如果赋值的类型与声明的类型不一致，程序会报错。在强类型语言中：子类对象可以强转为父类类型的对象，但父类类型的对象不能强转为子类类型的对象。在强类型语言中：子类对象可以强转为父类类型的对象，父类类型的对象也能强转为子类类型的对象。

class Animal():

def __init__(self, name):

self.name = name

def eat(self):

print(self.name + "eat")

class Cat(Animal):

def __init__(self, name):

Animal.__init__(self, name)

def run(self):

print(self.name + "run")

class Dog(Animal):

def __init__(self, name):

Animal.__init__(self, name)

class Person():

# def feedAnimalCat(self, cat):

# print("人喂了" + cat.name)

# def feedAnimalDog(self, dog):

# print("人喂了" + dog.name)

def feedAnimal(self, animal):

print("人喂了" + animal.name)

per = Person()

cat1 = Cat('喵')

# per.feedAnimalCat(cat1)

dog1 = Dog("汪")

# per.feedAnimalDog(dog1)

per.feedAnimal(cat1)

per.feedAnimal(dog1)

class Animal(object):

def run(self):

print('animal is running')

class Dog(object):

def run(self):

print('dog is running')

class Cat(object):

def run(self):

print('cat is running')

def run_twice(animal):

animal.run()

animal.run()

run_twice(Animal())

run_twice(Cat())

run_twice(Dog())

class Tortoise(Animal):

def run(self):

print('Tortoise is running slowly...')

run_twice(Tortoise())