Python之面向对象

前言

如果说要进入Python大项目的话，那么就不单单只需要入门知识就够了的，我们更要去了解Python的一个oop思想，也就是面向对象的思想

本章也就是去了解一个Python的封装，继承，多态。

---

封装

封装，也就是在类里面写属性，和方法。
然后去调用这个类就可以调用这个类里面的所有方法。

简单的类方法，和类属性

				class Person:
				    name = "李思"
				
				    """
				    方法
				    """
				    def eat(self):# self指的是调用此方法的对象
				        print(f"{self}在吃东西")
				


				"""
				实列化一个person
				"""
				person = Person()
				person2 = Person()
				print(person)
				
				"""
				调用属性
				"""
				print(person.name)
				
				
				"""
				调用方法
				"""
				person.eat() #<__main__.Person object at 0x0000024269B08348>在吃东西
				person2.eat() #<__main__.Person object at 0x0000024269B083C8>在吃东西
				
				# 与前面的打印不一样是因为对象不一样

欧克，我们来看一看类属性和对象属性的定义。

			"""
			根据类来说的话就有：
			1，类属性 :是那个类开始就具有的
			2，对象属性 :在实列化以后就只属于该单个对象的属性，包括类属性
			"""
			
			# 类属性（修改）
			Person.name = "张三" # 把类属性修改后就每个对象就改了
			print(person.name) #张三
			print(person2.name)#张三
			
			# 对象属性 (修改)
			person.name = "张三" # 把单个对象的对象属性修改后并不影响其他对象和类
			print(person.name) #张三
			print(person2.name)#李思
			
			
			# -----------------------------------------------------------------
			
			# 类属性 (增加)
			Person.age = 23 # 同理，把类增加一个其他靠这个类实例的也会有
			print(person.age) #23
			print(person2.age) #23
			
			
			# 对象属性 (增加)
			# person.age = 23 # 同理，把对象属性增加一个其他靠这个类实例的对象并不受影响
			# print(person.age)  # 23
			# print(person2.age) # 报错 ，该属性不存在

类里面的私有属性和私有方法

				class Person:
				
				    """
				    私有属性
				    """
				    
				    __play = "我才能玩游戏"
				
				    def setPlay(self, play):
				        self.__play = play
				
				    def getPlay(self):
				        return  self.__play
				
				    """
				    私有方法
				    """
				
				    def __Preeat(self):  # self指的是调用此方法的对象
				        print(f"{self}在吃东西")
					
				"""
				私有属性的调用,必须写一个setget方法，
				定义了私有方法后，此方法不能被自己的子类所继承
				"""
				#print(person.__play)  # 不能直接调用
				print(person.getPlay()) # 写了一个setget 方法就行

类里面的两种方法，和系统自带的魔方方法

					class Person:
					
					    # 类方法 可以带参数
					    @classmethod
					    def sleep(self):
					        print(f"{self.name}正在睡觉")
					
					    # 静态方法 不可以带参数
					    @staticmethod
					    def playDD():
					        print("打的豆豆")
					        
					
					    #魔方方法 __str__ 类似toString
					    def __init__(self, name):  # 构造方法
					        self.name = name
					
					    def __str__(self):
					        return f"名字为{self.name}"
					
					"""
					类方法
					"""
					# Person.sleep() # 可以
					# person.sleep() # 可以
					
					"""
					静态方法的调用
					"""
					# Person.playDD() # 可以但没有该对象参数
					# person.playDD() # 可以但没有该对象参数

全部代码：

"""
类
"""



class Person:
    name = "李思"

    """
    方法
    """
    def eat(self):# self指的是调用此方法的对象
        print(f"{self}在吃东西")

    """
    私有属性
    """


    __play = "我才能玩游戏"

    def setPlay(self, play):
        self.__play = play

    def getPlay(self):
        return  self.__play

    """
    私有方法
    """

    def __Preeat(self):  # self指的是调用此方法的对象
        print(f"{self}在吃东西")



    # 类方法 可以带参数
    @classmethod
    def sleep(self):
        print(f"{self.name}正在睡觉")

    # 静态方法 不可以带参数
    @staticmethod
    def playDD():
        print("打的豆豆")

    #魔方方法 __str__ 类似toString
    def __init__(self, name):  # 构造方法
        self.name = name

    def __str__(self):
        return f"名字为{self.name}"



"""
实列化一个person
"""
person = Person()
person2 = Person()
print(person)

"""
调用属性
"""
print(person.name)


"""
调用方法
"""
person.eat() #<__main__.Person object at 0x0000024269B08348>在吃东西
person2.eat() #<__main__.Person object at 0x0000024269B083C8>在吃东西

# 与前面的打印不一样是因为对象不一样

# -------------------------------------------------------------------
"""
根据类来说的话就有：
1，类属性 :是那个类开始就具有的
2，对象属性 :在实列化以后就只属于该单个对象的属性，包括类属性
"""

# 类属性（修改）
Person.name = "张三" # 把类属性修改后就每个对象就改了
print(person.name) #张三
print(person2.name)#张三

# 对象属性 (修改)
person.name = "张三" # 把单个对象的对象属性修改后并不影响其他对象和类
print(person.name) #张三
print(person2.name)#李思


# -----------------------------------------------------------------

# 类属性 (增加)
Person.age = 23 # 同理，把类增加一个其他靠这个类实例的也会有
print(person.age) #23
print(person2.age) #23


# 对象属性 (增加)
# person.age = 23 # 同理，把对象属性增加一个其他靠这个类实例的对象并不受影响
# print(person.age)  # 23
# print(person2.age) # 报错 ，该属性不存在


# -----------------------------------------------------------------

"""
私有属性的调用
"""
#print(person.__play)  # 不能直接调用
print(person.getPlay()) # 写了一个setget 方法就行


"""
类方法
"""
# Person.sleep() # 可以
# person.sleep() # 可以

"""
静态方法的调用
"""
# Person.playDD() # 可以但没有该对象参数
# person.playDD() # 可以但没有该对象参数

---

继承

就是意义上的继承，多个类之间是可以存在继承关系的，
通俗的讲就是父子关系。。

而每个类都默认的继承的是Object,这个是每一个类的父类,

那么继承有什么好处呢，父子之间遗传的是财产，而我们的父子继承关系遗传的是属性和方法。

看案例

				class Father(object):
				
				    maney = 2222
				
				    @staticmethod
				    def cook():
				        print("会下面条")
				
				    def a(self):
				        print("会武")
				
				
				class Mather(object):
				
				    maney = 33333
				
				    @staticmethod
				    def cook():
				        print("会做饭")
				
				    def b(self):
				        print("能文")
				
				
				class Author(Mather, Father):
				
				    @classmethod
				    def eat(cls):
				        Father.cook() # 根据类名来调用
				        super().cook() # 根据父亲的先后顺序来
				        print("会吃")
				
				
				author = Author()
				author.eat()
				# 父类的方法或属性都能继承
				author.a()
				author.b()
				
				
				# 继承的属性 ,如果两个父亲都有同名属性或同名方法，会先调用第一个
				
				print(author.maney)
				
				
			

扩展：
因为我们的python与java不太一样，java支持单继承，python支持多继承。

所以也就是上面所述，如果两个父类都有相同属性或方法，就优先调用第一个继承的，

当然也可以指名道姓的调用方法：Father.cook()

查看继承关系：

				# author的继承关系
				print(Author.__mro__)

---

多态

其实在大部分的开发项目过程中，我们基本是不会去使用到多态的概念的。
一般都能在别人的插件中能看到。

"""

多态

"""

class Water(object):
    def use(self):
        pass



class Gas(Water):
    def use(self):
        print("这是气体水")


class Liquid(Water):
    def use(self):
        print("这是液体水")


class Solid(Water):
    def use(self):
        print("这是固态水")


class Person(object):
    def cook(self, water):
        water.use()


person = Person()

# 用不同的水的子类去使用
gas = Gas()
person.cook(gas)

liquid = Liquid()
person.cook(liquid)

solid = Solid()
person.cook(solid)

如上所述，也就是定义一个使用总的一个方法，它的参数是water,
可我们传的是water的一个子类，并且有不同的结果，这就是多态

后言

多尝试尝试，才有结果ヽ(ー_ー)ノ