目录
面向对象
一、类的创建
二、类的组成
三、对象的创建、属性的使用
四、动态绑定属性和方法
五、封装、继承(方法重写\object类)、多态、特殊方法和特殊属性
1、面向对象的三大特征
(1)封装:
(2)继承
(a)目的:提高代码的复用性
(b)语法格式
(c)方法重写
(d)object
(3)多态:
(4)特殊属性和特殊方法
面向对象
一切皆对象,宏观使用面向对象,微观使用面向过程
一、类的创建
class Student:
pass
二、类的组成
1、类的属性 2、实例方法 3、静态方法 4、类方法
class Student: native_pace ="吉林" #直接写在类里面的变量成为类属性 #初始化方法 def _init_(self,name,age): self.name = name self.age = age #写在类之外定义的成为函数,在类之内定义的成为方法 def eat(self): print("学生在吃饭") #静态方法,不可以写self @staticmethod def method(): print("我使用了staticmethod进行修饰,所以我是静态方法") #类方法,写cls @classmethod def cm(cls): print("我是类方法,因为我使用了classmethod进行修饰 ")
讯享网
三、对象的创建、属性的使用
实例名=类名()
讯享网stu1 = Student("张三",20) stu2 = Student("李四",33) print(stu1.native_pace) #打印的吉林 print(stu2.native_pace) #打印的吉林 Student.native_pace='天津' print(stu1.native_pace) #打印的天津 print(stu1.native_pace) #打印的天津 stu1.eat() #调用方法的方式一:对象名.方法名() Student.eat(stul) #调用方法的方式二: 类名.方法名()
四、动态绑定属性和方法
实例方法的两种调用方式 stu1.eat() stu2.eat() Student.eat(stu1) def show() print("定义在类之外的,称为函数") #为stu1动态绑定方法 stu1.show = show #为stu1动态绑定性别 stu1=Student("Jack",20) stu1.gender="男"
五、封装、继承(方法重写\object类)、多态、特殊方法和特殊属性
1、面向对象的三大特征
(1)封装:
提高安全性,一是可将属性(数据)和行为(方法)包装到类对象中,在方法内部对属性进行类对象的外部调用方法;二可通过在数据前使用两个“_”则不会在类对象中访问
讯享网class Student: def __init__(self,name,age): self.name=name self.__age=age def show(self): print(self.name,self.__age) stu=Student("张三",20) stu.show() #会打印出 张三 20 #在类的外使用name与age print(stu.age) #会打印无此属性 #若想要打印__这类属性,可先print(dir(stu))查看此属性的名称为_Student__age,再用如下方法打印 print(stu._Student__age) #会打印出 20 那封装的意义在于啥呢,程序员的自觉性哈哈
(2)继承
(a)目的:提高代码的复用性
(b)语法格式
class 子类类名(父类1,父类2...):
pass
class Person(): def __init__(self,name,age): self.name=name self.age=age def info(self): print('姓名:{0},‘年龄’:{1}'.format(self.name,self.age)) #定义子类 class Student(Person): def __init__(self,name,age,score): super().__init__(name,age) #用super调用父类方法 self.score=score #给子类新增属性 class Teacher(Person): def __init__(self,name,age,teachofyear): super().__init__(name,age) self.teachofyear=teachofyear stu=Student("张三",20,"1001") teacher=Teacher("李四",34,10) stu.info() teacher.info()
注:若一个类没有继承任何类,则默认继承object;且定义子类时,必须在其构造函数中调用父类的构造函数。
(c)方法重写
背景:若子类有自己的属性,沿用父类的方法时,子类的属性没办法显示完全,如上述的
stu.info()不能显示学生的学号,teacher.info()不能显示教龄
讯享网class Person(): def __init__(self,name,age): self.name=name self.age=age def info(self): print('姓名:{0},年龄:{1}'.format(self.name,self.age)) #定义子类 class Student(Person): def __init__(self,name,age,score): super().__init__(name,age) #用super调用父类方法 self.score=score #给子类新增属性 def info(self): super().__init__(name,age) #调用用父类的方法,并加上新的属性 print('姓名:{0},年龄:{1},分数:{2}'.format(self.name, self.age,self.score)) class Teacher(Person): def __init__(self,name,age,teachofyear): super().__init__(name,age) self.teachofyear=teachofyear
(d)object
所有对象的父类,有个方法__str__()经常用于print()
class Person(): def __init__(self,name,age): self.name=name self.age=age def __str__(self): print('姓名:{0},‘年龄’:{1}'.format(self.name,self.age)) stu=Person("张三",20)
(3)多态:
定义:就是多种形态,指的是不知道一个变量所引用的对象是什么类型,仍然通过这个变量调用方法 ,在运行过程中根据变量所引用的对象类型,动态决定调用哪个对象中的方法。
目的:提高程序的可扩展性和可维护性
例子:
讯享网class Animal(object): def eat(self): print("动物会吃") class Dog(Animal): def eat(self): print("狗吃骨头") class Cat(Animal): def eat(self): print("猫吃鱼") class Person(): def eat(self): print("人吃五谷杂粮") #定义一个函数 def fun(Animal): Animal.eat() #开始调用函数 fun(Cat()) fun(Dog()) fun(Animal()) print("————————————————") fun(Person()) #也可调用,即无需去关心Person是谁的子类,只关心是否有eat行为
(4)特殊属性和特殊方法
特殊属性如下[(a)---(c)],特殊方法
(a)__dict__
class C(): def __init__(self,name,age): self.name = name self.age = age x=C("Jack",20) print(x.__dict__) #对象的字典显示的是属性 print(C.__dict__) #类的字典显示的是属性和行为
(b)__class__
讯享网class C(): def __init__(self,name,age): self.name = name self.age = age x=C("Jack",20) print(x.__dict__) #对象的字典显示的是属性 print(x.__class__) #输出代码所属的类
(c)__bases__和__base__的方法
class C(): def __init__(self,name,age): self.name = name self.age = age x=C("Jack",20) print(C.__bases__) #输出的是父类类型的元组(<class'__main__.A'>,<class'__main__.B'>) print(C.__base__) #输出的第一个父类类型,也称为C的基类(<class'__main__.A'>)
(d)__mro__
讯享网class C(): def __init__(self,name,age): self.name = name self.age = age x=C("Jack",20) print(C.__bases__) #输出的是父类类型的元组(<class'__main__.A'>,<class'__main__.B'>) print(C.__mro__) #输出继承了哪些父类类型<class'__main__.A'>,<class'__main__.B'>,<class'object'>,
(c)__subclasses__
class C(): def__init__(self,name,age): self.name = name self.age = age x=C("Jack",20) class D(A): pass print(A.__subclasses__) #输出的是A的子类列表[<class'__main__.C'>,<class'__main__.D'>]
———————————————————————————————————————————(ⅰ)特殊方法__add__()之整数相加,和字符串相加的方法
讯享网#整数相加 a=20 b=100 c=a+b d=a.__add__(b) #+实则实行的是a中的方法a.__add__() print(c) print(d) #d和c结果相同 #实现两个自定义对象的加法运算,因为在Student中增加了__add__特殊方法 class Student(): def __init__(self,name): self.name = name def __add__(self,other): return self.name+other.name stu1=Student("张三") stu2=Student("李四") print(stu1+stu2) #打印出张三李四 #或者另一种实现对象加法运算的方法 s=stu1.__add__(stu2) print(s)
(ⅱ)__len__内置函数计算长度
lst=[11,22,33,44] print(len(lst)) #len是内置函数 print(lst.__len__()) #结果一样 #如果想输出长度,就要编写__len__的方法 class Student(): def __init__(self,name): self.name = name def __len__(self): return len(self.name) stu1=Student("张三") stu2=Student("李四") print(len(stu1))
(ⅲ)__new__用于创建对象、__init__用于对创建的对象的初始化
讯享网class Person(object): def __new__(cls,*args,kwargs): print('__new__被调用执行了,clsd的id值为{0}'.format(id(cls))) obj*super().__new__(cls) print('创建的对象的id为:{0}'.format(id(obj))) return obj def __init__(self,name,age): print('__init__被调用了,self的id值为:{0}'.format(id(self))) self.name = name self.age = age print('object这个类对象的id为:{0}'.format(id(object))) print('Person这个类对象的id为:{0}'.format(id(Person))) #创建Person类的实例对象 p1 = Person('张三',20) print('pl这个Person类的实例对象的id:{0}'.format(id(pl))) #打印结果如下: #object这个类的id为:3232 #Person这个类对象的id为:60 #__new__被调用执行了,cls的id值为60 #创建的对象的id为:04 #__init__被调用了,self的id值为:04 #pl这个Person类的实例对象的id:04
第一步,先将Person('张三',20)传给new方法中的cls
第二步,cls传给object中的new方法创建对象(super().__new__)
第三步,将创建的obj对象给了初始化的self
第四步,self初始化后赋给p1

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/115105.html