python中的面向对象的学习

Python中面向对象的介绍：

• 类（class）：用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外，通常不作为实例变量使用。
• 数据成员：类变量或者实例变量，用于处理类及其实例对象的下相关数据。
• 方法重写:如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫做方法覆盖。
• 实例变量：定义在方法中的变量，只作用与当前实例。
• 继承：指一个派生类继承基类的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
• 实例化：创建一个类的实例，一个类的具体对象。
• 方法：类中定义的函数。
• 对象:通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
  定义语法：
  == class 类名（参数）：
  语法块==
  1.定义一个类：

class EmptyClass:
	pass
以上例子中我们定义了一个空类，虽然表面上什么都没有做，但是也不影响它的存在。

2.类的使用：
在使用类之前我们需要实例化类，类实例化后会成为常见的对象。创建对象和创建变量类似，需要先声明对象是哪个类，同时指明变量名称。

class EmptyClass：
	pass
empty = EmptyClass()
print(type(empty))

输出：
<class '__main__.EmptyClass'>
这个例子创建了一个EmptyClass对象，变量名字为“empty”，同时在内存中为这个对象分配内存空间。 

3.类的构造方法
在创建实例时，很多类可能都需要有特定的初始状态。所以，一个类可以定义一个特殊的方法，叫做构造函数。在Python中，构造函数就是类__init__方法（init前后都是两个“_”）。

class Dog:
	def __init__(self):
		print("汪汪汪！")
dog = Dog()


输出：
汪汪汪！

当一个类定义了__init__方法，类在实例化时会自动调用__init__方法，用于创建新的类实例。用于创建新的类实例。在这个实例中，新的实例被创建，同时执行了构造方法，运行了print函数。注意：构造函数的第一个参数时“self”，不能漏掉。
还有一点需要注意，构造方法的返回值必须是None。在定义构造方法的时候解释器不会报错，但是在实例化的时候python会输出错误提示“TypeError：init()should return None”。
4.类的属性：

class Dog:
	def __init__(self,name):
		self.name = name
		self.age = 3
dog = Dog("旺柴")
print(dog.name)
print(dog.age)
执行结果：
旺柴
3
---------------------------------------------------
注意：属性（或者叫成员变量，类变量）必须要使用“self”加上点的方式赋值，不能直接定义变量。直接定义的变量的生命周期只会在函数内，函数执行完毕变量就会被销毁。例如：
class Dog:
	def __init__(self,name):
		self.name = name
		age = 3
dog = Dog("旺柴")
print(dog.name)
print(dog.age)
执行结果：
"AttributeError：'Dog'object has no attribute 'age'"
即“Dog”对象没有age这个属性。其实函数__init__的第一个参数“self”指的就是实例本身，在C++等语言中对应的就是this指针，可以理解为对实例的属性进行赋值。python在调用__init__函数的时候会自动地添加实例作为函数的第一个参数。

5.类中的方法：
在类中定义的函数我们称为方法。其实在前面的章节中我们已经多次调用过方法了，例如dict字典中的keys方法就是成员方法。自己定义成员方法也很简单，例如：

class Dog:
	def __init__(self,name):
	 self.name = name
	def play(self):
		print("汪汪汪！我是"，self.name)
dog = Dog()
dog.play()
执行结果：
汪汪汪！我是汪柴

6.私有属性：
定义私有属性：只要在变量名的前面使用两条下划线作为开头，python解释器会默认这个属性为私有的，外部不能直接访问这个属性。
例如：

class Dog:
	def __init__(self,name):
		self.__name = name
	def play(self):
		print("汪汪汪！我是",self.name)
dog = Dog("汪柴")
dog.play()
#错误
print(dog.__name)
执行这段代码，python解释器会输出一段错误的提示“AttributeError：“Dog”object has no attribute "__name"”。虽然我们在构造方法中给"__name"赋值了，但是在实例中不能直接访问到"__name"这个以两条下划线开头的成员变量。在平时的实际项目中，我们可以使用这个特性保护一些不想让用户随便修改的属性。例如：
class Dog:
	def __init__(self,name):
		self.__name = name
		self.__age = None
		print(self.__name,"生成成功")
	def set_age(self,age):
		if not isinstance(age,int):
			print("输入的年龄必须是数字！")
			return False
		if age <=0:
			print("年龄必须大于0！")
			return False
		self.age = age
	def play(self):
		print("汪汪汪！我今年"，self.__age)
dog= Dog("汪柴")
dog.set_age("hello")
dog.set_age(-20)
dog.set_age(3)
dog.play()
执行结果：
汪柴生成成功
输入的年龄必须是数字!
年龄必须大于0！
汪汪汪！我今年3

在这个例子中，”__age“是私有属性，实例化后只能通过set_age方法设置年龄。在set_age方法中，我们限制了”age“只能是int并且其值要大于0，有效地限制了实例化后数据的内容，保证了”__age“是一个有效的可用的数据。
7.私有方法
私有方法和私有属性一样，私有方法只能在内部被调用，实例不能直接被调用。例如：

class Dog:
	def __say(self,name):
		print(name)
	def play(self):
		self.__say("汪汪汪")
dog = Dog()
dog.play()
#错误
dog.__say()
执行这段代码可以发现play方法可以正常运行，但是__say方法不能直接被实例“dog”调用。python解释器会输出一段错误的提示“AttributeError：“Dog”object has no attribute "__say"”

继承

面向对象的编程具有三大特性————封装性，继承性和多态性，这些特性使程序具有良好的扩展性和健壮性。
继承是一种对类进行分层级划分的概念。继承的基本思想是在一个类的基础上制定出一个新的类，这个新的类不仅可以继承原来类的属性和方法，还可以增加新的属性和方法。原来的类被称为父类，新的类称为子类。
定义子类的语法：

class 子类名（父类名1，父类名2）：
	语法块

定义 要从那个父类继承，只需在定义子类的名字后面的括号中填入父类名字，如果有多个父类则用逗号隔开。

class Animal:
	def __init__(self,name):
		self.name = name
	def play(self):
		print("我是"，self.name)
class Dog(Animal)：
	pass
dog  = Dog("汪柴")
dog.play()
执行结果：
我是汪柴

从这个例子看，在Animal中我们定义了name属性和play方法，但是在Dog类中什么都没有定义。由于Dog是从Animal继承下来的子类，所以Dog同样拥有name属性和play方法。这个例子表明，类继承可以帮助我们重用方法，我们可以继续定义Cat ，Pig 等类并从Animal继承name属性和play方法，大大减少了代码量。
继承的时候有两点需要注意：（1）在继承中，如果子类定义了构造方法，则父类的构造方法“1__init__”不会被自动调用，需要在子类的构造方法中专门调用。例如

class Animal:
	def __init__(self,name):
		self.name = name
	def play(self):
		print("我是"，self.name)
class Dog(Animal):
	def __init__(self):
		print("汪柴")
dog=Dog()
dog.play()       会报错AttributeError：Dog object has no attribute name,说明“Aniaml”的构造方法没有执行。我们可以使用super函数调用“Aniaml”中的构造函数，例如：



class Animal：
	def __init__(self,name):
		self.name = name
	def play(self):
		print("我是"，self.name)
class Dog(Animal):
	def __init__(self):
		super(Dog,self).__init__("汪柴")
dog = Dog()
dog.play()
执行结果：
我是汪柴

super（class，object or class）.构造方法
（1）子类Dog中显示，在调用Animal的构造方法之后运行正确。（2）子类不能继承父类中的私有方法，也不能调用父类的私有方法。

class Aniaml:
	def __init__(self,name):
		self.__name= name
	def __play(self):
		print("Animal,__paly")
	def play(self):
		print("Aniaml,play")
class Dog(Aniaml):
	def __init__(self):
		super(Dog,self).__init__("汪柴")
	def say(self):
		self.play()-----------------------------》报错
dog= Dog()
dog.play()

在say方法中调用父类的play方法没有任何问题，但是在调用__play方法的时候会提示错误信息AttributeError： Dog object has no attribute “_Dog__play”,说明父类中的私有方法不会被子类继承。继承可以一级一级往下继承，就像从爷爷到爸爸再到儿子的关系，所有的类最终的父类都是object类，继承就像一颗倒着的树。

多态

继承可以帮助我们重复使用代码，但是有时侯子类的行为不一定完全和父类一样。例如：

class Animal:
	def say(self):
		print("Animal")
class Dog(Aniaml)：
	pass
class Cat(Animal):
	pass
dog = Dog()
dog.say()

cat = Cat()
cat.say()


执行结果：
Animal
Animal

在这个例子中，我们的目的是想让“Dog”和“Cat”在调用say方法时输出不同的 内容，其实实现起来也很简单。

class Animal:
	def say(self):
		print("Animal")
class Dog(Animal):
	def say(self):
		print("Dog")
class Cat(Animal):
	def say(self):
		print("Cat")
dog = Dog()
dog.say()

cat = Cat()
cat.say()


执行结果：
Dog
Cat

以上例子的执行结果中我们可以看到：“Dog”和 “Cat”分别调用了各自的say方法。当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，这样的代码在运行的时候总是调用子类的方法，这就是多态。
多态的意思就是多种状态。多种状态意味着即使不知道变量引用的对象是什么类型，也能对对象进行操作。多态会根据类的不同而表现出不同的行为。
判断一个实例对象是不是某个对象可以使用isinstance函数，
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法
以下是 isinstance() 方法的语法:
isinstance(object, classinfo)
参数
object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
实例
以下展示了使用 isinstance 函数的实例：

a = 2
isinstance (a,int)
True

isinstance (a,str)
False

isinstance (a,(str,int,list)) # 是元组中的一个返回 True
True