1、类中内容:应该具有两个内容
- 表明事物的特征、叫做属性(变量)
- 表明事物功能或动作,称为成员方法(函数)
2、类的基本实现
- 类的命名方法
- 遵守变量命名规范
- 大驼峰(由一个或者多个单词构成,每个单词首字母大写,单词跟单词直接相连)
- 尽量避开跟系统命名相似的命名
- 如何声明一个类
- 必须用class关键字
- 类由属性和方法构成,其他不允许出现
- 成员属性定义可以直接使用变量赋值,如果没有值,可用None
- 实例化类
- 变量 = 类名( ) #实例化了一个对象
- 访问对象成员
- 使用点操作符
- obj.成员属性名称
- obj.成员方法
- 使用点操作符
#定义一个学生类,用来形容学生
#定义一个空的类
class Student():
#一个空类,pass代表直接跳过,此处pass必须有
pass
#定义一个对象
mingyue = Student()
#再定义一个类,用来描述听python的学生
class PythonStudent():
#用None給不确定的值赋值
name = None
age = 18
course = "python"
#需要注意
#1、def dohomework的缩进层级
#系统默认由一个self参数
def doHomework(self):
print("我在做作业")
#推荐在函数末尾使用return语句
return None
#实例化一个叫yueyue的学生是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)
#注意成员函数的调用没有传递参数
yueyue.doHomework()
- 可以通过默认内置变量检查类和对象的所有成员
- 对象所有成员检查
- obj._dict_ #dict前后各有两个下划线
- 类的所有成员
- class_name._dict_ #dict前后各有两个下划线
- 对象所有成员检查
class Student():
name = "haha"
age = 18
print(Student.__dict__)
#实例化
yueyue = Student()
print(yueyue.__dict__) #运行结果没有显示,但是下面打印名字确实存在
print(yueyue.name)
运行结果:
{'__module__': '__main__', 'name': 'haha', 'age': 18, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
{}
haha
3、类和对象的成员分析
- 类和对象都是可以存储成员,成员可以归类所有,也可以归对象所有
- 类存储成员时使用的是与类关联的一个对象
- 独享存储成员是存储在当前对象中
- 对象访问一个成员时,如果对象中没有该成员,尝试访问类中的同名成员;如果对象中有此成员,一定使用对象中的成员
- 创建对象时,类中的成员不会放入对象当中,而是得到一个空对象,没有成员
- 通过对象对类中的成员重新赋值或者通过对象添加成员时,对应成员会保存在对象中,而不会修改类成员
class A():
name = "dana"
age = 19
#注意say的写法,参数有一个self,相当于C++里的this
def say(self):
self.name = "aa"
self.age = 20
#此时,A称为类实例
print(A.name)
print(A.age)
#id可以鉴别一个变量是否和另一个变量是同一个变量
print(id(A.name))
print(id(A.age))
print("*" * 20)
a=A()
print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))
a.name = "lala"
print(a.__dict__)
print(a.name)
print(id(a.name))
运行结果: 类实例的属性和其对象的实例的属性在不对对象实例属性赋
dana 值的前提下,指向同一个变量
19
2271742027008
140715391256064
********************
dana
19
2271742027008
140715391256064
{'name': 'lala'} 类实例对象赋值后,有自己存储的变量
lala
2660405365536
4、关于self
- self在对象的方法中表示当前对象本身,如果通过对象调用一个方法,那么该对象会自动传入该方法的第一个参数中
- self并不是关键字,只是一个用于接收对象的普通参数,理论上可以用任何一个普通变量名代替
- 方法中有self形参的方法成为非绑定类的方法 ,可通过对象访问,没有self的是绑定类 方法,只能通过类访问
- 用类访问绑定类的方法时,如果类方法中需要访问当前类的成员,可以通过__class__(两个_ _不要少了)成员名来访问
class Student():
name = "dana"
age = 19
#注意say的写法,参数有一个self,写成其他的也行
def say(self):
self.name = "aa"
self.age = 20
print("My name is {0}".format(self.name))
print("My age is {0}".format(__class__.age)) #可访问类中成员变量
def sayAgain():
print(__class__.name)
print(__class__.age)
print("hello")
st = Student()
st.say()
#st.sayAgain() 会报类型错误,如果没有参数,怎么办呢?
#调用绑定类函数(没有传入形参)使用类名调用
Student.sayAgain()
实例:
class Student():
name = "dana"
age = 19
def __init__(self): #构造参数
self.name = "lala"
self.age = 13
def say(self):
print(self.name)
print(self.age)
class B():
name = 'bbb'
age = 23
a = Student()
#此时,系统会默认把a作为第一个参数传入函数
a.say()
'''Student.say()报错TypeError: say() missing 1 required positional argument: 'self',
Student类名不会被当作self参数传进函数,只有实例对象可以
'''
#此时,self被a替代,手动把a传进去
Student.say(a)
#同样可以把A作为参数传入
Student.say(Student)
#此时,传入的是类实例B,因为B具有name和age属性,所以不会报错
Student.say(B)
#以上代码,利用了鸭子模型(传进来可以用就行,不管是谁)
运行结果:
lala
13
lala
13
dana
19
bbb
23
5、面向对象的三大特性
- 封装、继承、多态
(1)封装
- 封装就是对对象的成员进行访问限制
- 封装的三个级别
- 公开:public
- 受保护的:protected
- 私有的:private
- public、private、protected不是关键字
- 判别对象的位置
- 对象内部、对象外部、子类中
- 私有
- 私有成员是最高级别的封装,只能在当前类或对象中访问
- 在成员前面添加两个下划线即可
- python的私有不是真私有,是一种成为name mangling的改名策略,可以使用对象._classname__attributename访问
class Person():
#name是共有的成员
name = "kaka"
#__age就是私有成员
__age = 13
p = Person()
print(p.name)
# AttributeError: 'Person' object has no attribute '__age'
#print(p.__age) 对象不能这样访问私有变量
print(Person.__dict__)
p._Person__age =12 #改个名访问,但是都私有化不想让访问了就别访问了
print(p._Person__age)
运行:
kaka
{'__module__': '__main__', 'name': 'kaka', '_Person__age': 13, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
12
- 受保护的封装 protected
- 受保护的封装是将对象成员进行一定级别的封装,然后在类中或者子类中都可以进行访问,但是在外部不可以
- 封装方法:在成员名称前添加一个下划线即可
- 公开的,公共的 public
- 公共的封装实际对成员没有任何操作,任何地方都可以访问
(2)继承
- 继承就是一个类可以获得另一个类中的成员属性和成员方法
- 作用:减少代码,增加代码的复用功能,同时可以设置类与类直接的关系
- 继承与被继承的概念:
- 被继承的类叫父类,也叫基类、超类
- 用于继承的类,叫子类、派生类
- 继承与被继承一定存在一个is-a关系
- 继承的语法
#在python中,任何类都有一个共同的父类叫object
class Person():
name = "NoName"
age = 19
_petname = "sec" #小名,是保护的,子类可以用,但不能公用
__score = 0 #考试成绩是私有
def sleep(self):
print("Sleeping。。。。")
#父类写在括号里
class Teacher(Person):
name = "dada"
teacher_id = "3451"
def make_test(self):
print("attention")
t = Teacher()
#就近调用
print(t.name)
print(Teacher.name)
print(t._petname)
t.make_test()
t.sleep()
- 继承的特征
- 所有的类都继承object类,即所有的类都是object类的子类
- 子类一旦继承父类,则可以使用父类中除私有成员外的所有内容
- 子类继承父类后并没有将父类成员完全赋值到子类中,而是通过引用关系访问调用
- 子类中可以定义独有的成员属性和方法
- 子类中定义的成员和父类成员如果相同,则优先使用子类成员
- 子类如果想扩充父类的方法,可以在定义新方法的同时访问父类成员来进行代码复用。可以使用 父类名.父类成员 的格式来调用父类成员,也可以使用 super().父类成员的格式来调用
#子类扩充父类
class Person():
def sleep(self):
print("Sleeping。。。。")
def work(self):
print("make money")
#父类写在括号里
class Teacher(Person):
def make_test(self):
print("attention")
def work(self):
#扩充父类的功能只需要调用父类相应的函数就可以了
#一种:Person.work(self)
#扩充父类的另一种方法,super代表父类
super().work()
self.make_test()
t = Teacher()
#就近调用
t.work()
运行结果:
make money
attention
- 继承变量函数的查找顺序问题
- 优先查找自己的变量,没有则查找父类
- 构造函数如果本类中没有定义,则自动查找调用父类构造函数;如果本类有定义,则不在继续向上查找
- 构造函数
- 是一类特殊的函数,在类进行实例化之前进行调用
- 如果定义了构造函数,则实例化时使用构造函数,不查找父类构造函数。如果没定义,则按照MRO顺序自动查找父类构造函数
- 如果子类没定义,父类的构造函数带参数,则构造队形应该按父类参数构造
#构造函数的概念
class Dog():
#__init__就是构造函数
#每次实例化对象时,第一个被自动调用
#因为主要工作是进行初始化,所以得名
def __init__(self):
print("I am init in dog")
#实例化的时候,括号内的参数需要跟构造函数参数匹配,此时kaka作为参数被丢进去
kaka =Dog()
运行结果:I am init in dog
#继承中的构造函数
class Animal():
def __init__(self):
print("Animel")
class PaxingAni(Animal):
def __init__(self,name):
print("Paxing Dongwu {0}".format(name))
class Dog(PaxingAni):
#__init__就是构造函数
#每次实例化对象时,第一个被自动调用
#因为主要工作是进行初始化,所以得名
def __init__(self):
print("I am init in dog")
#实例化时自动调用了Dog的构造函数
#因为找到了构造函数,则不在查找父类的构造函数
kaka =Dog()
#猫没有写构造函数
class Cat(PaxingAni):
pass
#此时应该自动调用构造函数,因为Cat没有构造函数,所以查找父类的构造函数
#因为PaxingAni的构造函数需要两个参数,实例化时给了一个,报错
#c = Cat()
运行结果:
I am init in dog
- super
- super不是关键字,而是一个类
- super的作用是获取MRO (MethodRestionOrder)列表中的第一个类
- super于父类没有任何实质性关系,但通过super可以调用父类
- super常见的两个方法参见在构造函数中调用父类的构造函数
class A():
pass
class B(A):
pass
print(A.__mro__)
print(B.mro())
print(C)
运行结果:
(<class '__main__.A'>, <class 'object'>)
[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
- 单继承和多继承(子类可以直接拥有父类的属性和方法,私有属性和方法除外)
- 单继承:每个类只能继承一个类;多继承:每个类允许继承多个类
- 优缺点:
- 单继承:传承有序逻辑清晰语法简单隐患少;功能不能无限扩展,只能在当前唯一的继承链中扩展
- 多继承:类的功能扩展方便;继承关系混乱
- 菱形继承/钻石继承问题
- 多个子类继承同一个父类,这些子类由同一个类继承,于是继承关系图形形成一个菱形
- 【MRO】http://www.cnblogs.com/whatisfantasy/p/6046991.html
- 关于多继承的MRO(MRO就是多继承中,用于保存继承顺序的一个列表)
- MRO列表计算原则:
- 如果多个类继承了同一个父类,孙子类中只会选取继承语法括号中第一个父类的父类
- 如果多个父类,则根据继承语法中括号内类的书写顺序存放
- 子类永远在父类前面
- python本身采用C3算法来多继承的菱形继承进行计算的结果
- MRO列表计算原则:
class Fish():
def __init__(self,name):
self.name = name
def swim(self):
print("I am swimming....")
class Bird():
def __init__(self,name):
self.name = name
def fly(self):
print("I am flying")
class Person():
def __init__(self,name):
self.name = name
def work(self):
print("Working...")
#注意多继承顺序,从左往右,第一、二、三...个父亲
class SuperMan(Person,Bird,Fish):
def __init__(self, name):
self.name = name
s = SuperMan("yueyue")
s.fly()
s.swim()
#单继承
class Student(Person):
def __init__(self,name):
self.name = name
stu = Student("haha")
stu.work()
运行:
I am flying
I am swimming....
Working...
- 多态:就是同一个对象在不同情况下有不同的状态出现
- 多态不是语法,是一种设计思想(python中)
- 多态性:一种调用方式,不同的执行效果
- 多态:同一事物的多种形态,动物分为人类、狗类、猪类
- 多态和多态性:http://www.cnblogs.com/luchuangao/p/6739557.html
- Mixin设计模式(多继承+相应规则)
- 主要采用多继承方式对类的功能进行扩展()
- 我们使用多继承语法来实现MInxin,使用Mixin实现多继承的时候非常小心首先她必须表示某一单一功能(鸟就是飞,me'y),而不是某个物品
- 职责必须单一,如果多个功能,则写多个Mixin
- Mixin不能依赖于子类的实现
- 子类即使没有继承这个Mixin类,也能照样工作,只是缺了某个功能
- 优点
- 使用Mixin可以不对类进行任何修改的情况下,扩充功能
- 可以方便组织和维护不同功能组件的划分
- 可以根据需要任意调整功能类的组合
- 可以避免创建很多新的类,导致类的继承混乱
class Person():
name = "haha"
age = 28
def eat(self):
print("eat...")
def drink(self):
print("drink...")
def sleep(self):
print("sleep...")
class Teacher(Person):
def work(self):
print("work")
class Student(Person):
def study(self):
print("Study...")
class Tutor(Teacher,Student):
pass
t = Tutor()
print(Tutor.mro())
print(t.__dict__)
print(Tutor.__dict__)
print("*"*20)
class TeacherMixin():
def work(self):
print("work")
class StudentMixin():
def study(self):
print("Study...")
class TutorM(Person,TeacherMixin,StudentMixin):
pass
tt = Tutor()
print(TutorM.mro())
print(tt.__dict__)
print(TutorM.__dict__)
运行结果:
[<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
{}
{'__module__': '__main__', '__doc__': None}
********************
[<class '__main__.TutorM'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>]
{}
{'__module__': '__main__', '__doc__': None}