python之对象基础

目录

• 面向对象
  • 1. 面向过程编程的优缺点
  • 2. 面向对象编程的优缺点
  • 3. 类
    • 类和函数的区别
    • 什么是类
    • 现实世界中先有对象，后有类
    • python中先有类，再有对象
  • 对象
    • 如何实例化一个对象
    • 对象属性查找顺序
  • 类与对象的绑定方法
  • 类与数据类型
  • 如何证明类中函数的参数self是实例对象本身
  • 对象的高度整合

面向对象

1. 面向过程编程的优缺点

优点：逻辑清晰

缺点：扩展性差（上一个函数的输出是下一个函数的输入）

2. 面向对象编程的优缺点

对象就是特征和技能的结合体

面向对象编程：一个个对象进行交互

优点：扩展性强

缺点：逻辑复杂

3. 类

类和函数的区别

1. 函数在定义阶段，只检查语法，不执行代码
2. 类在定义阶段，会运行代码

什么是类

类（类别）：一系列具有相同特征和技能的集合

现实世界中先有对象，后有类

# 定义学生

    # 姓名: 猪瑞星
    # 学号: 222222
    # 学校: wuda
        # 技能: 选课,三十六变


    # 姓名: 孔悟空
    # 学号: 111111
    # 学校: wuda
        # 技能: 选课,七十二变

    # 姓名: 雷公
    # 学号: 666666
    # 学校: wuda
        # 技能: 选课,电闪雷鸣,开车
        
# 定义老师

    # 姓名：tank
    # 学校：wuda
        # 技能：教课，piao

    # 姓名：nick
    # 学校：wuda
        # 技能：教课，看书

python中先有类，再有对象

class 类名(驼峰体):  # 定义类,会直接运行类体代码
    # 定义一系列特征
    # 定义一系列方法
    
对象1 = 类名()  # 实例化出对象

对象

如何实例化一个对象

class student(object):
    count = 0
    def __init__(self,name,Student_ID,school_name):
        self.name = name
        self.Student_ID = Student_ID
        self.school_name = school_name
    
    def xuanke(self):
        print(f'{self.name} 正在选课')

print(student.__dict__)		# 会显示student类的所有属性
a_stu = student('plf','11111','北大')		# 实例化时，第一个调用__init__方法
a_stu.xuanke()		# 调用选课系统

'''
{'__module__': '__main__', 'count': 0, '__init__': <function student.__init__ at 0x00000110AA7F0A60>, 'xuanke': <function student.xuanke at 0x00000110AA7F0AE8>, '__dict__': <attribute '__dict__' of 'student' objects>, '__weakref__': <attribute '__weakref__' of 'student' objects>, '__doc__': None}
plf 正在选课
'''

对象属性查找顺序

class OldBoyStudent:
    school = 'oldboy'
    name = 'c'
    
    def __init__(self, name ,age):
        self.name = name
        self.age = age

    def choose_course(self):
        print('is choosing course')
        
stu1 = OldBoyStudent('a',1) 
print(stu1.school)

stu2 = OldBoyStudent('b',2) 
print(stu2.scool)

先在实例对象本身的名称空间中查找，如果没有就会去类中查找，类中没有找到就会报错

类与对象的绑定方法

class OldBoyStudent:
    school = 'oldboy'
    
    def __init__(self, name ,age):
        self.name = name
        self.age = age

    def choose_course(self):
        print(id(self))  # 10000
        print(self.school)
        print(f'{self.name} is choosing course')
        
stu1 = OldBoyStudent('a',1) 
stu1.choose_course()  # self是对象本身
print(id(stu1))  # 10000

OldBoyStudent.choose_course(stu1)

类与数据类型

lis = list([1,2,3])
lis2 = list([1,2,3])

# 增加一个元素
lis.append(4)
# 换一种写法
list.append(lis,5)

# 总结：数据类型其实都是对象。数据类型的内置方法，都是对象的方法

如何证明类中函数的参数self是实例对象本身

分两种情况：1. 类的情况，2.实例本身

当实例去调用 "jiaoxue"函数时

class teacher():
    
    count =  0
    
    def __init__(self,name,school,age,sex):
        self.name = name
        self.school = school
        self.age = age
        self.sex = sex
        teacher.count += 1
    def jiaoxue(self):
        print(self)
        print(f'类中函数的self的内存地址为：{id(self)}')
        
one = teacher('plf','武大','23','男')
print(f"初始化对象的内存地址为：{id(one)}")
one.jiaoxue()

teacher.jiaoxue(111)

'''
初始化对象的内存地址为：1171091425992
<__main__.teacher object at 0x00000110AA7D0AC8>
类中函数的self的内存地址为：1171091425992
'''

当类去调用“jiaoxue” 函数时

class teacher():
    count =  0
    def __init__(self,name,school,age,sex):
        self.name = name
        self.school = school
        self.age = age
        self.sex = sex
        teacher.count += 1
        
        
    def jiaoxue(self):
        print(self)
        print(f'类中函数的self的内存地址为：{id(self)}')
teacher.jiaoxue(111)	# 随意传入一个数据，正常情况下我们可以传入teacher类的对象



'''
111
类中函数的self的内存地址为：1345944480

'''

总结：

1. 类中的函数self形参，当类调用时，self即表示传入的参数
2. 类中的函数self形参，当实例化对象调用时，self即表示实例化对象本身

对象的高度整合

对象有一大堆属性/数据，还会有一大堆方法来操作这些属性。然后对于不同的对象，这些属性又不同。