面向对象的介绍
世界万物,皆可分类 。世界万物,皆为对象。是要是对象,就肯定是属于某种品种。只要是对象,就肯定有属性
特性
类 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)