Python_类

面向对象的介绍
世界万物，皆可分类 。世界万物，皆为对象。是要是对象，就肯定是属于某种品种。只要是对象，就肯定有属性
特性
类 class ：对一类拥有相同属性的对象的抽象
object：对象

#class Person：        #经典类
class Role(object）：  #新式类
	n = 1  #类变量 存在类的内存里  先找实例本身n 再找类的n  类变量：大家共有的属性
	def __init__(self, name, role, weapon, life_value=100, money=15000):
	#构造函数，在实例化时做一些类的初始化工作，开头末尾各有两个下划线
		self.name = name    #实例变量（静态属性），作用域是实例本身  可以增加 修改 删除
		self.role = role   
		self.weapon = weapon
		self.life_value = life_value
		self.money = money

	def shot(self): #在类的内存里，没有copy给每一个对象
	print("shooting...")

	def got_shot(self）          #类的方法，
	print("ah...,I got shot...")

	def buy_gun(self, gun_name):  #类的方法，功能（动态属性）
	print("just bought %s" % gun_name)

r1 = Role('Alex', 'police', 'AK47') #把一个类变成具体对象的过程叫类的实例化（初始化一个类，造了一个对象）
r2 = Role('Jack', 'terrorist', 'B22')  #对象r2 又叫做Role的实例
r1.buy_gun('asd')   #访问属性方法可用 点.
print(r1.money)
#析构函数:在程序调用结束时使用 __del()__
#私有方法， 私有属性:前面加__
class Person():
	def __init__(self,name,age,):
		self.name = name
		self.age = age

	def eat(self):
		print('%s is eating'%self.name)

	def talk(self):
		print('%s is talking'%self.name)
	
	def sleep(self):
		print('%s is sleeping'%self.name)

class Man(Person):
	def piao(self):
		print('%s is piaoing....'%self.name)
	
	def sleep(self):
		Person.sleep(self) #重构了父类的方法
		print('Man is sleeping')

class Woman(Person):
	def get_birth(self):
		print('%s is borning a baby'%self.name)
		
p1 = Person('alex',23)
p1.talk()
p2 = Man('John',56)
p2.sleep()
#p2.piao()
p3 = Woman('Jack',23)
p3.get_birth()

#重构函数 普通继承
class Man(Person):  

	def __init__(self,name,age,money):
		Person.__init__(self,name,age)    #继承父类构造函数
		#super(Man,self).__init__(name,age)  两种方式都可以，下面更方便一些  
		self.money = money
		print('%s一出生就有%s元'%(self.name,self.money))

多继承：python2 的经典类是按着深度优先来继承的，新式类是按着广度优先来继承的 python3经典类和新式类都是统一按广度优先来继承的

class Person(object): #新式类
	def __init__(self,name,age,):
		self.name = name
		self.age = age
	
	def eat(self):
		print('%s is eating'%self.name)
	
	def talk(self):
		print('%s is talking'%self.name)
	
	def sleep(self):
		print('%s is sleeping'%self.name)
	
class Relation(object):
	def make_frineds(self,obj):
		print('%s and %s are friends'%(self.name,obj.name))

class Man(Person,Relation):

	def __init__(self,name,age,money):
		#Person.__init__(self,name,age) #经典类写法
		super(Man,self).__init__(name,age) #新式类写法
		self.money = money
		print('%s一出生就有%s元'%(self.name,self.money))
	def piao(self):
		print('%s is piaoing....'%self.name)
	
	def sleep(self):
		Person.sleep(self) #重构了父类的方法
		print('Man is sleeping')

class Woman(Person,Relation): #执行顺序默认从左到右
	def get_birth(self):
		print('%s is borning a baby'%self.name)
p1 = Person('alex',23)
p1.talk()
p2 = Man('John',56,10000)
p2.sleep()
#p2.piao()
p3 = Woman('Jack',23)
#p3.get_birth()
p3.make_frineds(p2)

#继承 学校练习集

```python
class School(object):
	def __init__(self,name,addr):
		self.name = name
		self.addr = addr
		self.students = []
		self.staffs = []
	def enroll(self,sut_obj):
		print('为学员%s办理注册手续'%sut_obj.name)
		self.students.append(sut_obj)
	def hire(self,tea_obj):
		print('雇佣新员工%s'%tea_obj.name)
		self.staffs.append(tea_obj)

class SchoolMember(object):
	def __init__(self,name,age,sex):
		self.name = name
		self.age = age
		self.sex = sex
	def tell(self):
		pass

class Teacher(SchoolMember):
	def __init__(self,name,age,sex,salary,course):
		super(Teacher, self).__init__(name,age,sex)
		self.salary = salary
		self.course = course
	
	def tell(self):
		print('''--------info of Teachers:%s----------
		Name:%s
		Age:%s
		Sex:%s
		Salary:%s
		Course:%s
		'''%(self.name,self.name,self.age,self.sex,self.salary,self.course))
	def teach(self):
		print('%s is teaching %s'%(self.name,self.course))

class Students(SchoolMember):
	def __init__(self, name, age, sex, stu_id, grade):
		super(Students, self).__init__(name, age, sex)
		self.stu_id = stu_id
		self.grade = grade
	
	def tell(self):
		print('''--------info of Stuents:%s----------
		Name:%s
		Age:%s
		Sex:%s
		Stu_in:%s
		Grade:%s
		'''%(self.name,self.name,self.age,self.sex,self.stu_id,self.grade))
	
	def Pay_tuition(self,amount):
		print('%s had paid tution for %s'%(self.name,amount))

school = School("老男孩IT",'沙河')
t1 = Teacher('Oldboy',23,'MF',20000,'linux')
t2 = Teacher('Alex',22,'M',300,'Python')
s1 = Students('ChenRonghau',12,'M',1001,'PythonCourse')
s2 = Students('徐两位',15,'w',1003,'LinuxCouse')

t1.tell()
s1.tell()

school.enroll(s1)
school.hire(t1)

school.staffs[0].teach()
for stu in school.students:
stu.Pay_tuition(5000)

多态:一种接口 多种实现 实现接口的重新使用

类：属性（实例变量和类变量 私有属性__var）和方法（构造函数、析构函数、）
对象：实例化一个类后得到的对象
封装：把一些功能的实现细节不对外暴露
继承：代码重用（单继承 多继承）
多态：接口重用，一种接口，多种实现

静态方法：只是 名义上归类管理，实际上在静态方法里面访问不了类或实例中的任何属性

class Dog(object):
	def __init__(self,name):
	self.name = name

	@staticmethod #实际上根类没有什么关系了，截断了与类的关系，单纯只是一个函数
	def eat(self,food):
	print('%s is eating %s...'%(self.name,food))
	 #类方法：只能访问类变量，不能访问实例变量
	@classmethod
	def eat(self,food):
	print('%s is eating %s...'%(self.name,food))

d = Dog('Alex')
d.eat(d,d.name)

#属性方法：把一个方法变成一个静态属性

```python
class Dog(object):
	name = 'asd'
	def __init__(self,name):
		self.name = name
		self.__food = None
		def eat(self,food):
		print('set to food',food)
	#@staticmethod #实际上根类没有什么关系了，截断了与类的关系，单纯只是一个函数
	@property #attribute 将一个方法变成的属性
	def eat(self):
		print('%s is eating %s...'%(self.name,self.__food))
	
	@eat.setter #对一个变成属性的方法赋值
	def eat(self, food):
		print('set to food', food)
		self.__food = food
	
	@eat.deleter #属性方法删除掉
	def eat(self):
		del self.__food
		print('删完了！')


d = Dog('Alex')
d.eat
d.eat = 'baozi'
d.eat

#类的特殊成员
class People(object):
	'''
	这个类是用来定义人这个对象的
	'''
	def __init__(self,name,age,addr):
		self.name = name
		self.age = age
		self.addr =addr
	def walking(self):
		print('%s is walking'%self.name)
class Student(People):
	def __init__(self,name,age,addr,grade):
		super(Student, self).__init__(name,age,addr)
		self.grade = grade
	def study(self):
		print('%s is a student,grade is %s'%(self.name,self.grade))

s1 = Student('alex',24,'沙河',5)
print(People.__doc__)   #表示类的描述信息 

#call方法
	def __call__(self, *args, **kwargs):
		print('__call__')

s1 = Student('alex',24,'沙河',5)
print(People.__doc__)
s1()
Student('alex',24,'沙河',5)()

dict方法
print(People.__dict__) #打印类里面的所有属性，不包括实例属性
print(s1.__dict__) #打印所有实例属性，不包括类属性

反射根据用户输入选择不同的方法 输入字符串 动态匹配

class Dog(object):

	def __init__(self,name):
		self.name = name

	def eat(self,name):
		print('%s is eating %s....'%(self.name ,name))
	
	def bulk(self):
	    print('%s is bulking...'%self.name)

d = Dog("Wang")
choice = input('>>:').strip()
# print(hasattr(d,choice)) #判断是否有该方法 判断一个对象obj里是否有对应的name_str字符串的方法映射
# print(getattr(d,choice))
if hasattr(d,choice):    
	getattr(d,choice)("Hambuger") #调用 根据字符串去获取obj对象里面对应的方法的内存地址

d = Dog("alex")
choice = input('>>:').strip()
# print(hasattr(d,choice)) #判断是否有该方法
# print(getattr(d,choice))
if hasattr(d,choice):
	getattr(d,choice)("Hambuger") #调用
else:
	# setattr(d,choice,bulk) #动态装一个方法
	# d.talk(d)
	setattr(d,choice,22) #动态装一个属性   setattr(obj,'y',z) is equivalent to  "x.y = v"
	print(getattr(d,choice))
#delattr(obj,choice)  #删掉obj中的一个属性或者方法

异常处理

name = ["alex",'jack']
data = {}

try:
	name[3]
	data['name']
except KeyError as e: #e就是错误的详细信息
	print('没有这个key',e)
except IndexError as e:
	print('列表操作错误',e)

except (KeyError,IndexError) as e: #e就是错误的详细信息
	print('没有这个key',e)

except Exception as e:    #抓住所有的错误，可以放在最后使用
	print('出错了',e)