week7-python之面向对象
Python 面向对象
概述
- 面向过程：根据业务逻辑流水线的方式写代码
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对某些功能属性进行归类，数据封装，然后在进行实例化等提高开发效率等
类和实例
类(Class)和实例(Instance)是面向对象最重要的概念。
类是指抽象出的模板。实例则是根据类创建出来的具体的“对象”，每个对象都拥有从类中继承的相同的方法，但各自的数据可能不同。
在python中定义一个类:
class Student(object):
pass
关键字class后面跟着类名，类名通常是大写字母开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的。通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承下来的类。
定义好了 类，就可以根据Student类创建实例：
class Student(object):
pass
bar = Student() # bar是Student()的实例
类的数据属性和类的函数属性介绍
class OldboyStudent:
school = 'oldboy' #类的数据属性/类的变量 可以节约内存空间，每个实例都可以调用，数据存放类的内存空间，不需要在存放在每个实例的内存空间
def learn(self): #类的函数属性/类的方法
print('is learning')
def eat(self):
print('is eating')
print('======>')
# 类体的代码在类定义阶段就会执行,理所应当会产生类的名称空间，用__dict__属性查看
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
类的属性操作
print(OldboyStudent.school) print(OldboyStudent.learn) def func():pass print(func) OldboyStudent.learn(123) OldboyStudent.x=1111111111111111111111 OldboyStudent.school='Oldboy' del OldboyStudent.school print(OldboyStudent.__dict__) OldboyStudent.__dict__['x']=1111111111111111111111
产生程序中的对象：类名加括号，调用类，产生一个该类的实际存在的对象，该调用过程称为实例化，产生的结果又可以成为实例
class OldboyStudent:
school = 'oldboy' #类的变量 存放在类的内存空间，所有实例化的对象优先访问实例里面的变量，如果实例里面的内存空间没有找到再到 类的内存空间查找
#obj1,'李大炮',18,'女'
def __init__(self,name,age,sex): #在实例化时,产生对象之后执行
# if not isinstance(name,str):
# raise TypeError('名字必须是字符串类型')
self.name=name #实例变量，保存在调用实例的内存空间中，与其他实例内存空间是独立的，但是可以通过实例调用访问其他实例的内存空间
self.age=age
self.sex=sex
# return None #__init__方法必须返回None
#obj1.name='李大炮'
#obj1.age=18
#obj1.sex='女'
def learn(self):
print('is learning')
def eat(self):
print('is eating')
分析：
obj1=OldboyStudent('李大炮',18,'女') #
分两步：
第一步：先产生一个空对象obj1
第二步：OldboyStudent.__init__(obj1,'李大炮',18,'女')
print(obj1.__dict__)
obj2=OldboyStudent('张全蛋',28,'男')
obj3=OldboyStudent('牛榴弹',18,'女')
print(obj2.__dict__)
print(obj3.__dict__)
对象可以访问类的数据属性，结论：类的数据属性共享给所有对象使用，id对一样
class OldboyStudent:
# school = 'oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def learn(self):
print('%s is learning' %self.name)
def eat(self):
print('is eating')
obj1=OldboyStudent('李大炮',18,'女')
obj2=OldboyStudent('张全蛋',28,'男')
obj3=OldboyStudent('牛榴弹',18,'女')
print(obj1.name,obj1.age,obj1.sex)
print(obj1.school,id(obj1.school))
print(obj2.school,id(obj2.school))
print(obj3.school,id(obj3.school))
print(OldboyStudent.school,id(OldboyStudent.school))
类的函数属性是绑定给所有对象使用的，绑定给不同的对象是不同的绑定方法，绑定方法有特殊之处。
OldboyStudent.learn(obj1) OldboyStudent.learn(obj2) OldboyStudent.learn(obj3) print(obj1.learn) print(obj2.learn) print(obj3.learn) print(OldboyStudent.learn)
绑定方法：绑定给谁，就由谁来调用，谁来调用就把“谁”本身当做第一个参数传入
obj1.learn() #OldboyStudent.learn(obj1) obj2.learn() #OldboyStudent.learn(obj1) obj3.learn() #OldboyStudent.learn(obj1)
属性查找顺序：先从对象的__dict__中找，然后到类的__dict__中找，然后父类....
OldboyStudent.school='哈佛'
obj1.school='hahahahahahahhahahahahahah'
print(obj1.__dict__)
print(obj1.school)
print(obj2.school)
print(obj3.school)
class Foo:
count=0
def __init__(self,x,y,z):
self.x=x
self.y=y
self.z=z
Foo.count+=1
obj1=Foo(1,1,1)
obj2=Foo(1,2,1)
obj3=Foo(1,2,3)
print(obj1.count)
print(Foo.count)
class OldboyStudent:
# school = 'oldboy'
def __init__(self,name,age,sex='male'):
self.name=name
self.age=age
self.sex=sex
def learn(self):
print('%s is learning' %self.name)
def eat(self,y):
print('is eating')
obj1=OldboyStudent('李大炮',18)
OldboyStudent.eat()
obj1.eat(1)
obj1.learn()
classmethod和staticmethod使用
setting.py
HOST='192.168.31.1' PORT=3106
操作：
import settings
import uuid
class MySql:
def __init__(self,host,port):
self.host=host
self.port=port
self.id=self.create_id()
# @classmethod
# def from_conf(cls): #绑定给类的
# print(cls)
# # return cls(settings.HOST,settings.PORT)
#
# def func1(self): #绑定给对象的
# pass
@staticmethod
def create_id(): #非绑定方法
return str(uuid.uuid1())
conn1=MySql('127.0.0.1',3306)
conn2=MySql('127.0.0.2',3306)
conn3=MySql('127.0.0.3',3306)
# print(MySql.create_id)
# print(conn1.create_id)
print(conn1.id,conn2.id,conn3.id)
测试
import time
class Date:
def __init__(self,year,month,day):
self.year=year
self.month=month
self.day=day
# @staticmethod
# def now():
# t=time.localtime()
# return Date(t.tm_year,t.tm_mon,t.tm_mday)
@classmethod #改成类方法
def now(cls):
t=time.localtime()
return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化
class EuroDate(Date):
def __str__(self):
return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)
e=EuroDate.now()
print(e)
类的继承：
1 继承的功能之一：解决类与类之间的代码重复问题
2 继承是类与类之间的关系，是一种，什么是什么的关系
3 在子类派生出的新的属性，已自己的为准
4 在子类派生出的新的方法内重用父类的功能的方式：指名道姓法OldboyPeople.__init__ 这种调用方式本身与继承是没有关系
继承的基本形式：
class ParentClass1(object): #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass
print(SubClass1.__bases__)
print(SubClass2.__bases__)
print(ParentClass1.__bases__)
在python中有经典类与新式类的区别:
python2 经典类就按深度优先来继承的，新式类式按广度优先来继承的
python3 经典类和新式类都是统一广度优先来继承的
继承的实现原理演示:
#单继承
class A:
def f1(self):
print('A.f1')
def f2(self):
print('A.f2')
self.f1() #b.f1()
class B(A):
def f1(self):
print('B.f2')
b=B()
# b.f2=111111
b.f2()
#多继承
class J:
def test(self):
print('J')
class A(J):
# def test(self):
# print('A')
pass
class E(J):
def test(self):
print('E')
pass
class H(J):
def test(self):
print('H')
class G(H):
def test(self):
print('G')
pass
class B(A):
# def test(self):
# print('B')
pass
class D(E):
def test(self):
print('D')
pass
class F(G):
def test(self):
print('F')
pass
class C(B,D,F):
# def test(self):
# print('C')
pass
c=C()
# c.test=1111
# c.test()
#MRO列表
print(C.mro())
子类的方法重用父类的功能super
class OldboyPeople:
school = 'oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print('is eating')
def teach(self):
print('这是父类的teach')
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,salary,title):
# OldboyPeople.__init__(self,name,age,sex)
#在Python2中需要写全：super(OldboyTeacher,self)
super().__init__(name,age,sex)
self.salary=salary
self.title=title
def teach(self):
# OldboyPeople.teach(self)
super().teach()
print('%s is teaching' %self.name)
print(OldboyTeacher.mro())
egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河扛把子')
# print(egon_obj.title)
# print(egon_obj.__dict__)
egon_obj.teach()
class A:
def test(self):
super().test()
class B:
def test(self):
print('B')
class C(A,B):
pass
# a=A()
# a.test()
print(C.mro())
c=C()
c.test()
类的组合应用
class OldboyPeople:
school = 'oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print('is eating')
class OldboyStudent(OldboyPeople):
def __init__(self,name,age,sex):
OldboyPeople.__init__(self,name,age,sex)
self.course=[]
def learn(self):
print('%s is learning' %self.name)
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,salary,title):
OldboyPeople.__init__(self,name,age,sex)
self.salary=salary
self.title=title
self.course=[]
def teach(self):
print('%s is teaching' %self.name)
class Course:
def __init__(self,course_name,course_period,course_price):
self.course_name=course_name
self.course_period=course_period
self.course_price=course_price
def tell_info(self):
print('<课程名:%s 周期：%s 价格：%s>' %(self.course_name,self.course_period,self.course_price))
python=Course('Python','6mons',3000)
linux=Course('Lnux','3mons',2000)
bigdata=Course('BigData','1mons',1000)
# python.tell_info()
egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河霸道金牌讲师')
#
# egon_obj.course.append(python)
# egon_obj.course.append(linux)
#
# for obj in egon_obj.course:
# obj.tell_info()
yl_obj=OldboyStudent('yanglei',28,'female')
yl_obj.course.append(python)
for i in yl_obj.course:
# print(i.course_name,i.course_period,i.course_price)
i.tell_info()
志不强者智不达
浙公网安备 33010602011771号