一、面向对象介绍

注意：在使用面向对象编程的时候，第一步就是思考需要什么样的对象，对象具备什么样的特征和行为。从而根据这些信息总结出需要的类型

　　　在程序中：用变量来表示对象的特征，用函数来表示对象的技能。将这些变量和函数结合在一起，形成一个整体，就是对象，这是面向对象的精髓。

二、创建类和对象

　　定义类的固定语法：定义类通过class关键字：class后面紧接着是类名。类是对象相似数据与功能的集合体

　　注意：类体代码是在类定义阶段就会立即执行，会产生类的名称空间。

　　创建类：

class Student:
    # 1、变量的定义
    stu_school='oldboy'
 
    # 空对象,'aaa',18,'male'
    def __init__(obj,x,y,z):
        obj.stu_name=x # 空对象.stu_name='aaa　　'
        obj.stu_age=y  # 空对象.stu_age=18
        obj.stu_gender=z # 空对象.stu_gender='male'
        # return None
 
    # 2、功能的定义
    def tell_stu_info(stu_obj):
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            stu_obj['stu_name'],
            stu_obj['stu_age'],
            stu_obj['stu_gender']
        ))
 
    def set_info(stu_obj,x,y,z):
        stu_obj['stu_name']=x
        stu_obj['stu_age']=y
        stu_obj['stu_gender']=z

　　再调用类产生对象

　　　　调用类的过程又称为实例化，调用过程发生了三件事

　　　　　　1、先产生一个空对象

　　　　　　2、python会自动调用类中的__init__方法然将空对象已经调用类时括号内传入的参数一同传给__init__方法

stu1_obj=Student('aaa',18,'male') # Student.__init__(空对象,'aaa',18,'male')
# stu2_obj=Student('bbb',19,'female')
# stu3_obj=Student('ccc',20,'male')

# print(stu1_obj.__dict__)
# print(stu2_obj.__dict__)
# print(stu3_obj.__dict__)

　　__init__方法总结

# 1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
# 2、__init__内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，想要在
#    类调用时就立刻执行的代码都可以放到该方法内
# 3、__init__方法必须返回None

三、属性查找

　　1、类中存放的是对象共有的数据与功能　　

　　比如此时定义一个学生类

class Student:
    # 1、变量的定义
    stu_school='ddd'
    count=0
 
    # 空对象,'aaa',18,'male'
    def __init__(self,x,y,z):
        Student.count += 1
 
        self.stu_name=x # 空对象.stu_name='aaa'
        self.stu_age=y  # 空对象.stu_age=18
        self.stu_gender=z # 空对象.stu_gender='male'
        # return None
 
    # 2、功能的定义
    def tell_stu_info(self):
        print('学生信息：名字：%s 年龄：%s 性别：%s' %(
            self.stu_name,
            self.stu_age,
            self.stu_gender
        ))
 
    def set_info(self,x,y,z):
        self.stu_name=x
        self.stu_age=y
        self.stu_gender=z
 
    def choose(self,x):
        print('正在选课')
        self.course=x
 
stu1_obj=Student('aaan',18,'male') # Student.__init__(空对象,'aaa',18,'male')
stu2_obj=Student('bbb',19,'female')
stu3_obj=Student('ccc',20,'male')
 
# print(stu1_obj.count)
# print(stu2_obj.count)
# print(stu3_obj.count)

# 1、类的数据属性
# print(Student.stu_school)
# 2、类的函数属性
# print(Student.tell_stu_info)
# print(Student.set_info)

　　2、类中的东西是给对象用的

# 1、类的数据属性是共享给所有对象用的，大家访问的地址都一样

# print(id(stu1_obj.stu_school))
# print(id(stu2_obj.stu_school))

# Student.stu_school='ddd'
# stu1_obj.stu_school='ddd'
# print(stu1_obj.stu_school)
 
# print(Student.stu_school)
# print(stu2_obj.stu_school)

# 2、类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同
 
# 类调用自己的函数属性必须严格按照函数的用法来
# print(Student.tell_stu_info)
# print(Student.set_info)
 
# Student.tell_stu_info(stu1_obj)
# Student.tell_stu_info(stu2_obj)
# Student.tell_stu_info(stu3_obj)
 
# Student.set_info(stu1_obj,'aaa',19,'male')
# Student.tell_stu_info(stu1_obj)
 
# 绑定方法的特殊之处在于：谁来调用绑定方法就会将谁当做第一个参数自动传入
# print(Student.tell_stu_info)
# print(stu1_obj.tell_stu_info)
# print(stu2_obj.tell_stu_info)
# print(stu3_obj.tell_stu_info)
 
# stu1_obj.tell_stu_info() #tell_stu_info(stu1_obj)
# stu2_obj.tell_stu_info() #tell_stu_info(stu2_obj)
# stu3_obj.tell_stu_info() #tell_stu_info(stu3_obj)
 

# stu1_obj.choose('开发')
# print(stu1_obj.course)
#
# stu2_obj.choose('运维')
# print(stu2_obj.course)
#
# stu3_obj.choose('测试')
# print(stu3_obj.course)
 

　　3、属性查找顺序

　　　　如果类和对象中存在同样的属性，则先访问对象，如果没有再访问类。优先查找对象自己的名称空间,如果没有则在类中找,如果类中也没有则到父类中找,直到找到为止,如果父类中也没有则抛出异常

　　　　对象->类->父类

三、对象与类的绑定方法

　　绑定到对象的方法：没有被任何装饰器装饰的方法。在类中定义的函数默认都是绑定到对象的方法。特点:方法参数的第一个必须是self 表示当前对象本身,使用对象来调用,调用时会自动传入对象

　　绑定到类的方法：用classmethod装饰器装饰的方法。特点:函数方法参数的第一个必须是cls表示当前类本身,使用类名来调用,调用时会自动传入类

　　1、默认情况下类中的方法都是对象绑定方法：

class Student:
    def __init__(self,name):
        self.name=name

    def say_hi(self):
            print("hello my name is %s" %self.name)

#都是绑定到对象的方法
#先类实例化一个对象，且传入参数，自动执行init方法，此时对象.name就是传入的参数
stu1=Student("jsaon")
stu1.say_hi()                     #对象调用函数属性，执行函数

Student.say_hi(stu1)  #类调用函数。相互之间的传参

结果：类与对象输出结果一样
hello my name is jsaon
hello my name is jsaon   #绑定到对象的方法

　　2、类的绑定关系

　　　　类绑定的方法用@classmethod 来装饰

class DddStudent:
    school = "ddd"
    def __init__(self,name):
        self.name = name

    @classmethod                #类绑定的方法
    def show_school(cls):
        # print(self.school)
        print(cls)

    @staticmethod              #非绑定方法或叫做静态方法,就是不需访问类的数据,.也不需要访问对象的数据
    def print_hello():
        print("hello world")

总结：

什么时候绑定给对象:当函数逻辑需要访问对象中的数据时

什么时候绑定给类:当函数逻辑需要访问类中的数据时