3、Python中 类的学习

python是面向对象编程，三大基本特征：封装、继承、多态。多态是在继承基础之上的。

1、封装

#===创建类
class Person:
	'''定义一个人的基类'''
	hair=1000
	nose=1
	__happy=1      #这是私有属性,不能在类外被调用。私有属性在变量名前加 两个下划线__

	def __private(self):   #私有方法在方法名前加 两个下划线__
		print("这是一个私有方法,不可在类外调用")

#---构造函数----主要用来完成对 对象属性的一些初始化工作.  构造函数【不允许】有返回值--
	def __init__(self,name,sex,age):#在实例化的时候系统就会调用该函数. 
                                    #第一个参数必须是self ,调用时不传值
		self.name = name
		self.sex = sex
		self.age = age

	def introduce(self):
		print("我叫%s,我是%s生,我%s 岁了"%(self.name,self.sex,self.age))

	def eat(self,food):  #定义类的方法时,第一个参数[必须是self ],代表类的实例.
		print("吃的是%s"%food)
		
#---创建实例对象==================================================================
p=Person("小明","女",19)   #--init__()函数中写参数了,在定义实例的时候需要上传对应的参数
p.introduce(); 
p.hand=3                   #对类的属性进行添加
del p.hand                 #只能删除实例化后 添加的属性
#del p.nose                #报错：Person' object has no attribute 'nose'
p.hair=199                 #修改类的属性.不会影响别的实例
p.eat("秋刀鱼")             #调用的时候不需要给self传值 .输出:吃的是秋刀鱼

Person.hair=888            #这是直接修改类的属性.会影响实例

2 、继承

1. 可以重用代码. 在python中,可以[继承多个]父类.继承几个叫单继承,继承多个叫多继承.
2. 方法重写:这是建立在继承上的.父类的方法不满足需求时,子类中可以重写实现不同的需求.

#=======单继承的代码结构===
# class SubClassName(ParentClassName):
# 	    pass
#-------------------------------------
class Animal:  #这是父类
	def __init__(self):
		print("这是父类的构造函数")
	eye=2
	def eat(self):
		print("吃秋刀鱼")

#====这是子类===
class Person(Animal):           #继承自Animal类
	def __init__(self):
		# super().__init__()
		Animal.__init__(self)
		print("这是子类的构造函数")
	hair=1000                   #子类中额外定义的变量
	def sound(self):
		print("唱一首幸福的歌把")
p=Person()
p.eat()
p.sound()
print(p.eye)

'''多继承'''
# 如果多个父类中有相同的方法名或者属性名,在子类中使用时没有指定父类名,python会在父类中从左往右按照顺序进行搜索.
class A:
	def eat(self):
		print("A 在吃")
class B:
	def eat(self):
		print("B 在吃")
class C(B,A):           #c继承顺序为B-A 的两个父类
	def do(self):
		self.eat()      #没有指定父类  按照顺序自动搜索,调用了B的方法  输出:B 在吃
		A.eat(self)     #指定父类A的方法  输出:A 在吃

c=C()  #实例化C对象
c.do() #调用do方法

# ========方法重写======静态方法==
class Father:
	def do(self):
		print("这是父类方法,不满足需求")
# -----子类-----------------
class WangMing(Father):
	def do(self):
		print("这是子类方法,我重写了")	

    #静态方法是类中的函数,不需要实例化就可以直接使用.一般静态函数中不会对类的属性和方法进行操作
	@staticmethod             # 定义静态方法.在函数前加上这个标识
	def eat():                #静态方法不需要self参数
		print("我是静态函数")

# ---调用子类----------------
c=WangMing()
c.do()          #输出:这是子类方法,我重写了
WangMing.eat()  #eat()方法是静态方法,可以直接用类名调用,无需实例化

 3 、内置类属性

前后两个下划线构成

class A:
	pass
print(A.__dict__)  #查看类的属性以字典形式展示
print(A.__name__)  #查看类名
print(A.__doc__)#None  查案类的文档
print(A.__bases__)#(<class 'object'>,)  当前类的所有父类
print(A.__module__)#__main__ 当前类所在模块

"""输出：-------------------
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
A
None
(<class 'object'>,)
__main__
"""

 4 、错误和异常

错误要修正,异常要处理  Exception:常见异常的基类

try:
	#程序主体
	pass
except ZeroDivisionError:
	print("除数不可以为0")
except (NameError,TypeError) as e:  #判断多个异常
	#触发异常的程序主体
	print(e)
	
else:  #可略
	##未触发异常的程序主体
	pass
finally: #可略
	#此处代码一定会执行
	pass