python基础：面向对象

面向对象：

面向对象就不像面向过程那样按照功能划分模块了，它所关注的是软件系统有哪些参与者，把这些参与者称为对象，找出这些软件系统的参与者也就是对象之后，分析这些对象有哪些特征、哪些行为，以及对象之间的关系，所以说面向对象的开发核心是对象

类

类是对象的类型，具有相同属性和行为事物的统称。类是抽象的，在使用的时候通常会找到这个类的一个具体存在

对象

万物皆对象，对象拥有自己的特征和行为。

类和对象的关系

类是对象的类型，对象是类的实例。类是抽象的概念，而对象是一个你能够摸得着，看得到的实体。二者相辅相成，谁也离不开谁

创建和使用类

定义类：
class 类名():
	#文档说明
	属性
	方法
注意：类名要满足标识符命名规则，同时要遵循大驼峰命名习惯
例如：
class Person():
	'''这是一个人类'''
	country = '中国'		#声明类属性，并且赋值
	#实例属性同构造方法来声明
	#self不是关键字，代表的是当前对象
	def __init__(self,name,age,sex):	#构造方法
		#构造方法不需要调用，在实例化的时候自动调用
		self.name = name
		self.age = age
		self.sex = sex
	#创建普通方法
	def getName(self):
		print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}')	#在方法里面使用实例属性
#实例化对象
people01 = Person('joe',18,'男')	#在实例化的时候传参
#通过对象调用实例方法
people01.getName()
结果为：
我的名字叫:joe,年龄是:18,性别是:男,我来自:中国

类的属性分类

访问属性

class Person():
    country = '中国'  

    def __init__(self,name,age,sex):
        self.name =name
        self.age = age
        self.sex = sex
    def getName(self):
       print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}')

people01 = Person('joe',18,'男')

print(people01.name)    #通过对象名.属性名，访问实例属性(对象属性)
print(people01.age)
print(people01.sex)
结果为：
joe
18
男

针对类的属性的一些方法

可以使用点实例化对象名+.来访问对象的属性，也可以使用以下函数的方式来访问属性

class Person():
    country = '中国'  

    def __init__(self,name,age,sex):
        self.name =name
        self.age = age
        self.sex = sex
    def getName(self):
       print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}')

people01 = Person('joe',18,'男')
1.访问对象的属性 getattr(obj, name[, default])
print(getattr(people01,'name'))
结果为：
joe
2.检查是否存在一个属性hasattr(obj,name)，存在为True，不存在为False
print(hasattr(people01,'name'))
结果为：
True
3.设置一个属性setattr(obj,name,value) 。如果属性不存在，会创建一个新属性
print(setattr(people01,'name','susan'))	#不存在返回None
print(people01.name)
结果为：
None
susan
4.删除属性delattr(obj, name) 
delattr(people01,'name')
print(people01.name) 	#在此print执行会报错

注意：name需要加单引号,obj为实例化对象名称

内置属性

class Person():
    country = '中国'  

    def __init__(self,name,age,sex):
        self.name =name
        self.age = age
        self.sex = sex
    def getName(self):
       print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}')

people01 = Person('joe',18,'男')
1.__dict__ : 类的属性（包含一个字典，由类的属性名:值组成） 实例化类名.__dict__
print(people01.__dict__)
结果为：
{'name': 'joe', 'age': 18, 'sex': '男'}
2.__doc__ :类的文档字符串   (类名.)实例化类名.__doc__
print(people01.__doc__)
结果为：
这是一个人类
3.__name__: 类名,实现方式 类名.__name__
print(Person.__name__)
结果为：
Person
4.__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
print(Person.__bases__) 
结果为：
(<class 'object'>,)

_ _ init _ _()构造方法和self

_ _ init _ ()是一个特殊的方法属于类的专有方法，被称为类的构造函数或初始化方法，方法的前面和后面都有两个下划线。
这是为了避免Python默认方法和普通方法名称的冲突。每当创建类的实例化对象的时候， _ init _ _（）方法都会默认被运行。作用就是初始化已实例化后的对象。
在方法定义中，第一个参数self是必不可少的。类的方法和普通的函数的区别就是self，self并不是Python的关键字，只是按照惯例和标准的规定，推荐使用self。

_ _ name _ _

_ _ name _ _:如果放在Modules模块中，表示的是模块的名字，如果放在class类中，表示的是类的名字
_ _ main _ _:模块，xxx.py文件本身被直接执行时，对应的模块名就是 _ _ main _ _了
可以在 if _ _ name _ _ == " _ _ main _ _":中添加自己想要的，用于测试模块，演示模块用法等代码作为模块，被别的Python程序导入时，模块名就是本身文件名了。

继承

程序中定义一个class的时候，可以从某个现有的class继承，新的class成为子类(Subclass)，而被继承的class称之为基类、父类或超类。子类继承了其父类所有属性和方法，同事还可以定义自己的属性和方法。

例如：
#声明一个父类
class Animal():
	def __init__(self,name,food):
		self.name = name
		self.food = food
	def eat(self):
		print('%s爱吃%s'%(self.name,self.food))
#声明一个子类继承Animal
class Dog(Animal):
	def __init__(self,name,food,drink):
		super(Dog,self).__init__(name,food)
		#子类自己的属性
		self.drink = drink
	#子类自己的方法
	def drinks(self):
		print('%s爱吃%s'(self.name,self.food,self.drink))
class Cat(Animal):
	def __init__(self,name,food,drink):
		super(Cat,self).__init__(name,food)
		#子类自己的属性
		self.drink = drink
	#子类自己的方法
	def drinks(self):
		print(f'%s爱吃%s'(self.name,self.food,self.drink))
	#重写父类的eat
	def eat(self):
		print('%s特别爱吃%s'%(self.name,self.food))
dog1 = Dog('金毛','骨头','可乐')
dog1.eat()
dog1.drinks()

cat1 = Cat('波斯猫','鱼','雪碧')
cat1.eat()
cat1.drinks()

结果为：
金毛爱吃骨头
金毛爱喝可乐
波斯猫特别爱吃鱼
波斯猫爱喝雪碧

多继承

语法格式如下：
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>
注意：圆括号中父类的顺序，如果继承的父类中有相同的方法名，而在子类中使用时未指定，python将从左到右查找父类中是否包含方法

class A():
    def a(self):
        print('我是A里面的a方法')

class B():
    def b(self):
        print('我是B里面的b方法')
    def a(self):
        print('我是B里面的a方法')

class C():
    def c(self):
        print('我是C里面的c方法')

class D(A,B,C):
    def d(self):
        print('我是D里面的d方法')

dd = D()
dd.d()      #调用自己的方法
dd.c()
dd.a()

结果为：
我是D里面的d方法
我是C里面的c方法
我是A里面的a方法

super()重写

class Animal():
    def __init__(self,name,food):
        self.name = name
        self.food = food
    def eat(self):
        print('%s喜欢吃%s'%(self.name,self.food))
    def shout(self):
        print(self.name,'喵喵')
#编写一个Dog类继承Animal
class Dog(Animal):
    def __init__(self,name,food):
        super().__init__(name,food)
    def shout(self):    #重写父类的shout方法，喵喵叫不适合dog的实际情况
        print(self.name,'汪汪')
#编写一个Cat类继承Animal
class Cat(Animal):
    def __init__(self,name,food):
        super().__init__(name,food)

#对于Dog和Cat来说Animal是他们的父类，而Dog和Cat是Animal的子类。
#子类获得了父类的全部功能，自动拥有了父类的eat()方法

dog = Dog('小狗','骨头')
dog.shout()

结果为：
小狗 汪汪

类方法用@classmethod装饰器来表示

类方法可以被类和对象一起访问，而对象方法只可以被对象方法访问
class Dog(object):
    tooth = 10      #定义一个类属性
    @classmethod        #装饰器，添加其他的功能：让对象方法变成类方法
    def info_print(self):
        print(1)
    @classmethod
    def info_print1(cls):   #cls表示类本身
        #在方法里面去使用类本身去调用方法时可以直接使用cls
        print(cls.tooth)
wangcai = Dog()
wangcai.info_print()        #类方法
Dog.info_print()
Dog.info_print1()       #10,用类去调用类属性得到的属性值

结果为：
1
1
10

静态方法

去掉不需要的参数传递，有利于减少不必要的内存占用和性能消耗

静态方法是可以被类和对象一起访问的
class Dog(object):
    @staticmethod
    def info_print():   #小括号中没有self，也没有cls
        print("这是一个静态方法！")

wangcai = Dog()
wangcai.info_print()
Dog.info_print() 
结果为：
这是一个静态方法！
这是一个静态方法！