类与对象

类与对象

 

类与对象的定义　　

　　对象：特征与技能的结合体

　　　类：一系列对象相似的特征与相似的技能的结合体

　　强调：站在不同的分类，划分的分类不一定一样

 

先有类还是先有对象？

　　1.程序中：

　　　　必须先定义类，然后调用类产生对象

　　2.现实生活中：

　　　　先有对象，在有人类

语法定义类：

　　1.定义函数

　　　　def 函数名():

　　　　　　pass

　　2.定义类：

 　　　　class 类名():

　　　　　　pass

　　3.类名可以遵循变量名的命名规范

　　 　　1.驼峰体

　　　　　　大驼峰：UserName (类名推荐使用)

　　　　　　小驼峰：userName

　　 　　2.下划线 （类名中直接禁止使用）

　　4.定义类发生了什么事？ 　　　　

　　　　1.立即执行类体代码

　　　　2.产生一个类的名称空间，把类体里面执行的名字都扔到名称空间中(大字典)

　　　　3.把类的名称空间绑定给__dict__,（类名.__dict__）

　　5.查看类的名称空间

　　　　print（类名.__dict__）

# 类名一般情况首字母大写
class Student():
    # 定义一个属性
    school = 'SH'

    # 定义一个技能(函数)
    def choose_course(stu_dict, course):
        stu_dict['course'].append(course)
        print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

    print('>>>>>>')

# 查看类的名称空间
print(Student.__dict__)


# 产生对象
# 调用类产生对象，默认产生的就是一个空对象{}

stu1 = Student()
stu2 = Student()
stu3 = Student()

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__) 

调用类发生了几件事？

　　1.产生一个空对象

　　2.调用了Student.__init__(stu), 把自己当成第一个参数传到函数里面

　　3.得到一个初始化结果，并返回给对象

　　4.初始化方法__init__不能有返回值，如果非要返回，返回None

 

 对象的属性

# 版本3：
class Student():
    # 定义一个属性
    school = 'SH'

    # 初始化方法
    # 调用类自动触发的函数
    # 该方法不是一定要定义，需要用到就定义，不需要刻意不定义
    def __init__(stu_obj, name, age, gender):
        # 空对象.name = name
        # 空对象.age = age
        # 空对象.gender = gender
        stu_obj.name = name  # stu1.__dict__['name'] = 'jason'
        stu_obj.age = age  # stu1.__dict__['age'] = 18
        stu_obj.gender = gender  # stu1.__dict__['gender'] = 'male'、
        # return None # 在这个方法中不能有返回值，
    # 定义一个技能(函数)
    def choose_course(stu_dict, course):
        stu_dict['course'].append(course)
        print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))


# 调用类发生了几件事？
'''
    1. 得到一个空对象
    2. 调用了Student.__dict__(空对象,'ly', 18, 'male'),
    3. 得到一个初始化的结果。
'''
stu1 = Student('ly', 18, 'male')
stu2 = Student('jason', 18, 'male')
# stu1 = Student()
# print(stu1.__dict__)
# print(stu2.__dict__)

# print(stu1.name)
# print(stu2.name)

# 属性的查找：先从自己的对象中查找，然后在去产生对象的类中取找

stu1.school = 'aaaa'
print(stu1.school)

 

属性的查找顺序

　　属性的查找：

　　　　1.类属性： 在类中写的属性就称为类属性

　　　　2.对象属性：在对象自己的名称空间中的属性就是对象属性

 

　　类属性的查找

# 类属性的查找
# 1. 查
print(Student.school)

# 2. 增加
Student.country = 'China'

# 3. 改
Student.school = 'BJ'

# 4. 删除
del Student.school
print(Student.__dict__)

　　　　1.查

　　　　　　print(Student.school)

　　　　2.增加

　　　　　　Student.country = 'China'

　　　　3.改

　　　　　　Student.school = 'BJ'

　　　　4.删除　　　　　　

　　　　　　del Student.school

　　

　　实例化对象

stu = Student('ly', 18, 'male') # 实例化对象， stu就是一个实例　　

 

　　对象属性的查找

# 对象属性
# 1. 查
print(stu.name)
print(stu.age)
print(stu.gender)

# 2. 增
stu.aaa = 'aaa'

# 3. 改
stu.name = 'bbb'

# 4. 删除
del stu.name
print(stu.__dict__)

　　　　1.查

　　　　　　print(stu.name)

　　　　2.增

　　　　　　stu.aaa = 'aaa'

　　　　3.改

　　　　　　stu.name = 'bbb'

　　　　4.删除

　　　　　　del stu.name

　　

　　实例

 # 版本3：
class Student():
    # 定义一个属性
    school = 'SH'

    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        self.name = name  # stu1.__dict__['name'] = 'jason'
        self.age = age  # stu1.__dict__['age'] = 18
        self.gender = gender  # stu1.__dict__['gender'] = 'male'
        self.course = course
    def choose_course(self, course):
        # stu_dict => stu
        self.course.append(course)
        print('%s选课成功 %s' % (self.name, self.course))

    def func(self, name, age):
        pass

 

方法调用

　　类可以调用，对象也可以调用

　　类调用方法

　　　　Student.choose_course(stu, 'python')   # 类来调用，函数的参数有几个就要传几个

　　对象调用方法

　　　　stu.choose_course(self)   # 对象调用方法，会把自己当成第一个参数'''自动'''传到函数里面

stu.choose_course('python') # stu.choose_course(stu， 'python')

class Teacher():
    pass
print(isinstance(123, int))
print(isinstance(stu, Teacher))

 

 小练习

　　题目：
　　　　1.定义一个类，产生一堆对象

　　　　2.统计产生了多少个对象

　　思路：

　　　　定义一个计数器，每产生一个对象，计数器加1

class Student():
    school = 'SH'
    count = 0  # 专门用来计数

    def __init__(self, name, age):
        # self => stu => {'name':'ly', 'age': 18, 'count'：1}
        # self => stu1 => {'name':'ly1', 'age': 18, 'count'：1}
        # self => stu2 => {'name':'ly2', 'age': 18, 'count'：1}
        self.name = name
        self.age = age
        # self.count = self.count + 1
        # Student.count += 1
        # self.__class__  # Student
        self.__class__.count += 1

 

绑定方法

　　1.绑定给对象的

　　　　特点：让对象来调用

　　　　绑定给对象的方法，对象来调用，会把自己当成第一个参数传到函数里面self

class Student():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    # 绑定给对象的方法，对象来调用，会把自己当成第一个参数传到函数里面self
    def tell_info(self):
        print('name: %s，age:%s, gender:%s' % (self.name, self.age, self.gender))

stu = Student('ly', 18, 'male')

　　　　使用类里面的方法， 类里面的方法默认绑定给对象使用类里面的方法， 类里面的方法默认绑定给对象

stu.choose_course('python') #stu.choose_course(stu) 
stu1.choose_course('linux')

　　2.绑定给类的

　　　　特点：让类来调用

　　　　绑定给类了的方法，类来调用，会把类名当成第一个参数传到函数里面cls　

　　　　@classmethod

class Mysql():
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    @classmethod  # 该方法绑定给类了，以后有类来调用，会自动把类名当成第一个参数传过来，cls
    def from_conf(cls):  # cls: 类名
        # cls => Oracle
        # obj = Oracle(settings.IP, settings.PORT)
        obj = cls(settings.IP, settings.PORT)
        return obj
 Mysql.from_conf()

 　　　　如果方法里面即需要类，也需要对象，最好绑定给对象

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


        def func(self):
            print(self)
            print(self.__class__)

　　　　使用类里面的方法， 使用@classmethod装饰的函数都是绑定给类了

Student.from_conf()

 

静态方法（非绑定方法）

　　既不绑定给类，也不绑定给对象

class Student():
    school = 'SH'
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @staticmethod  # 静态方法  # def create_id(self) 
    def create_id():
        import uuid
        return uuid.uuid4()

stu = Student('ly', 18)

　stu.create_id() # 对象来调用
　Student.create_id() # 类来调用

 

END