面向对象

一切皆对象，宏观使用面向对象，微观使用面向过程

一、类的创建

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动态绑定性别
stu=Student("Jack",20)
stu.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.name)           #会打印无此属性
#若想要打印__这类属性，可先print(dir(stu))查看此属性的名称为_Student__age，再用如下方法打印
print(stu._Student__age)  #h会打印出 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(self.stu_no)
 
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(A,B)
  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(A,B)
  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(A,B)
  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(A,B)
  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(A,B)
  def__init__(self,name,age)
    self.name = name
    self.age = age
x=C("Jack",20)
classD(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__add__(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为：140717796113232
#Person这个类对象的id为:2690679899360
#__new__被调用执行了,cls的id值为2690679899360
#创建的对象的id为:2690436007104
#__init__被调用了，self的id值为:2690436007104
#pl这个Person类的实例对象的id:2690436007104

第一步，先将Person(‘张三’,20)传给new方法中的cls

第二步，cls传给object中的new方法创建对象(super().__new__)

第三步，将创建的obj对象给了初始化的self

第四步，self初始化后赋给p1

文章出处登录后可见！

已经登录？立即刷新

python类