python __init__

def init(self)

先实例化，再赋值

class Student_Grade:  
    def __init__(self):  # 对象的属性
        self.name = None
        self.grade = None
        
s1 = Student()  # 创建对象
s1.name = "Tom"
s1.grade = 8

def init(self, 参数1，参数2，···，参数n)

若参数无初始值 实例化的同时要赋值

class Student_Grade: 
    def __init__(self, name, grade):  #类似于C++中的有参构造函数
        self.name = name
        self.grade = grade

s1 = Student("Tom", 8)  # 创建对象s1

若参数有初始值 实例化的同时可不赋值

class Student_Grade: 
    def __init__(self, name='lily', grade=90):  #类似于C++中的有参构造函数
        self.name = name
        self.grade = grade

s1 = Student()  # 创建对象s1

面向对象技术简介

python 面向对象
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

#类定义
class people:  # people类
    # 类变量在整个实例化的对象中是公用的
    #定义基本属性
    name = ''
    age = 0
    #前加下划线定义私有属性,私有属性在类外部无法直接进行访问
    # 私有方法定义类似 def __speak(self):
    __weight = 0  
    #定义构造方法__init__()  在类实例化时会自动调用
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
# 子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。
# BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。
class student(people):  # 父类放在括号内
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):  # 两个父类
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)        
 
# 实例化类
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法
# 若子类中的方法在子类中未找到时，从左到右查找父类中是否包含方法。
输出:我叫 Tim，我是一个演说家，我演讲的主题是 Python


# ---方法重写
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法  子类的myMethod
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法  父类的myMethod  super机制
输出：
调用子类方法
调用父类方法
例：
class FooParent:  #定义父类FooParent
    def bar(self,message):  #定义父类的方法bar
        print(message)
class FooChild(FooParent):  #定义子类FooChild
    def bar(self,message):  #定义子类的方法bar
        FooParent.bar(self,message)  #方法一：在子类中直接调用父类的方法，此时需将“对象调用”转换为“类调用”
        #或者
        super(FooChild,self).bar(message)  #方法二：直接调用super()机制
                                     #此时self参数需要显式传递
FooChild().bar("Hello,Python.")
>>>
Hello,Python.