面向对象编程与类

目录

• 今日内容概要
  • 内容详细
    • 面向过程
    • 面向对象
    • 类的定义和对象的产生
    • 给对象定义自己独有的属性
    • 属性的查找顺序

今日内容概要

• 面向过程概念
• 面向对象概念
• 类的定义和对象的产生
• 属性的查找和方法的查找

内容详细

面向过程

面向过程核心是 '过程'
	即解决问题的流程
    先干什么 再干什么 最后干什么
    
# 实例
	1.洗衣服过程
    2.把大象放进冰箱里
    	'''
    	1.把冰箱门打开
    	2.把大象放进去
    	3.关上冰箱门
    	'''
    3.流水线的生产
    
# 优点
   复杂的问题流程化 进而简单化
# 缺点
    牵一发而动全身 扩展性差 可维护性差
 # 应用场景
    对扩展性要求不高的地方: 程序安装包的使用
            
# 实例
    员工注册功能
    '''
    1.获取用户输入的姓名和密码
    2.校验参数
    3.写入文件 注册成功
    '''

面向对象

面向对象的核心是 '对象'
	什么是对象:
        1.程序中:
            函数:盛放数据的容器
            对象:盛放数据与函数的容器        
        2.生活中:
            一切皆对象
    '''
    对象:
    	特征和功能(技能)的结合体
    '''
    
# 优点
    扩展性强,可维护性强
# 缺点
    编程复杂程度高
# 应用场景
	对扩展性要求较高的地方: 微信 qq

# 实例
    学生选课系统
    版本一
  
学生信息1
stu_name = 'jason'
stu_age = 18
stu_gender = 'male'
stu_courses = []  # 空列表用来存放选择的课程

学生信息2
stu1_name = 'ly'
stu1_age = 18
stu1_gender = 'male'
stu1_courses = []  # 空列表用来存放选择的课程

# 函数体代码中要用到的名字 全部从形参中获得 调用函数时传参即可
def choose_course(stu_name, stu_courses, course):
    stu_courses.append(course)
    print('%s选课成功 %s' % (stu_name, stu_courses))

choose_course(stu_name, stu_courses, 'python')  # jason选课成功 ['python']

choose_course(stu1_name, stu1_courses, 'linux')  # ly选课成功 ['linux']


 
# 版本2：
stu1 = {
    'name': 'jason',
    'age': 18,
    'gender': 'male',
    'course': [],
}

stu2 = {
    'name': 'ly',
    'age': 18,
    'gender': 'male',
    'course': []
}

def score():
    pass
def register():
    pass

def choose_course(stu_dict, course):  # stu1 = stu_dict 把整个学生信息字典作为参数传进来
    stu_dict['course'].append(course)
    print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

choose_course(stu1, 'python')  # jason选课成功 ['python']
choose_course(stu2, 'linux')  # ly选课成功 ['linux']


# 版本3：
def choose_course(stu_dict, course):
    stu_dict['course'].append(course)
    print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

stu1 = {
    'name': 'jason',
    'age': 18,
    'gender': 'male',
    'course': [],
    'choose_course': choose_course  # 把函数名作为字典的元素存进来
}

stu2 = {
    'name': 'ly',
    'age': 18,
    'gender': 'male',
    'course': [],
    'choose_course': choose_course  # 把函数名作为字典的元素存进来
}

stu1['choose_course'](stu1, 'python')  # 取字典元素加括号就是在调用函数了
stu2['choose_course'](stu2, 'python')  # 取字典元素加括号就是在调用函数了

类的定义和对象的产生

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

'''站在不同的分类 划分的分类也不一定一样'''
 
# 问题
	到底现有类 还是现有对象
    1.程序中
    	必须先定义类 然后调用类产生对象
    2.生活中
    	现有对象 再有人类
        
# 定义类

以 学生选课系统版本3为例
def choose_course(stu_dict, course):
    stu_dict['course'].append(course)
    print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

# 将相似的特征 'school': 'SH', 相似的技能 'choose_course': choose_course 组合成 '类' Student
Student = {
    'school': 'SH',
    'choose_course': choose_course
}    
    
stu1 = {
    #'school': 'SH',
    'name': 'jason',
    'age': 18,
    'gender': 'male',
    'course': [],
    #'choose_course': choose_course  # 把函数名作为字典的元素存进来
}

stu2 = {
    # 'school': 'SH',
    'name': 'ly',
    'age': 18,
    'gender': 'male',
    'course': [],
    #'choose_course': choose_course  # 把函数名作为字典的元素存进来
}

stu1['choose_course'](stu1, 'python')  # 取字典元素加括号就是在调用函数了
stu2['choose_course'](stu2, 'python')  # 取字典元素加括号就是在调用函数了


'''
专业的语法定义
	1.定义函数
		def 函数名():
			pass
	
	2.定义类
		class 类名():
			pass
'''

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

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

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

# 产生对象 类调用后的返回结果就是对象

# 调用类产生对象，默认产生的就是一个空对象 {}
# 接收类执行的结果 得到对象
stu1 = Student()
stu2 = Student()
stu3 = Student()

# 查看对象的名称空间
print(stu1.__dict__)  # {}
print(stu2.__dict__)  # {}
print(stu3.__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']))

stu1 = Student()  # 产生了对象1 {}
stu2 = Student()  # 产生了对象2 {}
stu3 = Student()  # 产生了对象3 {}

print(stu1.__dict__)  # 打印对象的内存地址 只有 {}
print(Student.__dict__)  # 打印类的内存地址 
'''对象的产生 其实就是指向了类的内存地址'''

# 版本1

stu1.__dict__  # 就是一个空字典
# 给字典加值(给对象定义自己独有的属性)
stu1.__dict__['name'] = 'jason'
stu1.__dict__['age'] = 18
stu1.__dict__['gender'] = 'male'
stu1.__dict__['course'] = []
# 取值
print(stu1.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male', 'course': []}
print(stu1.__dict__['name'])  # jason

### 在python中__dict__取值一般不建议使用 建议使用特殊语法
stu1.name = 'jason'
stu1.age = 18
stu1.gender = 'male'
stu1.course = []

print(stu1.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male', 'course': []}
print(stu1.name)  # jason
print(stu1.age)  # 18


# 版本2
# 类名一般情况首字母大写
class Student():
    # 定义一个属性
    school = 'SH'
    # 定义一个技能(函数)
    def choose_course(stu_dict, course):
        stu_dict['course'].append(course)
        print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

stu1 = Student()  # 产生了对象1 {}
stu2 = Student()  # 产生了对象2 {}

# 把学生信息也做成函数
def init(stu_obj, name, age, 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'

init(stu1 ,'ly', 18, 'male')
print(stu1.__dict__)  # {'name': 'ly', 'age': 18, 'gender': 'male'}
init(stu2 ,'jason', 18, 'male')
print(stu2.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}


# 版本3

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

    # 初始化方法__函数名__
    # 调用 类 时会自动触发函数！！！
    # 该方法不是一定要定义，需要用到就定义，不需要刻意不定义
    def __init__(stu_obj, name, age, gender):  # 被调用时 空对象本身会按位置传值给 stu_obj(该参数一般默认用 self)
        # 空对象.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') # stu1自己会作为位置实参传值
print(stu1.__dict__)  # {'name': 'ly', 'age': 18, 'gender': 'male'}

stu2 = Student('jason', 18, 'male')# stu2自己会作为位置实参传值
print(stu2.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}

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

# 属性的查找：先从自己的对象(名称空间)中查找，然后在去产生对象的类(名称空间)中取找
print(stu1.school)  # SH  
"""
类中已经定义了一个属性  school = 'SH'
. 点方法取值时 
	先从对象自己的名称空间中查找 
	如果没有 就到产生该对象的类的名称空间中查找
"""

print(stu1.__dict__['school'])  # 报错
"""
__dict__ 方法取值
	只会从对象自己名称空间中查找
	找不到会报错 不再去类空间中查找
"""


stu1 = Student('ly', 18, 'male')
stu1.school = 'aaaa'
print(stu1.school)  # aaaa
print(stu1.__dict__['school'])  # # aaaa

属性的查找顺序

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):  # self = stu
        self.course.append(course)
        print('%s选课成功 %s' % (self.name, self.course))

    def func(self, name, age):
        pass

# 属性的查找：
# 1. 类属性: 在类中写的属性就称为类属性
# 2. 对象属性：在对象自己的名称空间中的属性就是对象属性

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

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

# 3. 改
Student.school = 'BJ'

# 4. 删除
del Student.school

# 对象属性的查找
stu = Student('ly', 18, 'male')  # 调用函数称为:实例化对象， stu就是一个实例
# 1. 查
print(Student.school)
print(Student.__dict__)

# 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


# 类中的方法 类可以调用 对象也可以调用
# 类调用方法
Student.choose_course(stu, 'python') 
'''类来调用 函数的参数有几个就要传几个'''
print(Student.choose_course)

# 对象调用方法
'''
类中的方法 类可以调用 对象也可以调用
	但是 推荐对象来调用 
	因为对象来调用 会把自己当成第一个参数传递给函数
'''
stu.choose_course('python')  # 就相当于 stu.choose_course(stu， 'python')

# isinstance 判断对象是否为实例
class Teacher():
    pass

print(isinstance(123, int))  # True 对象123 是类int的实例
print(isinstance(stu, Teacher))  # False 对象stu 不是类Teacher的实例