面向对象编程——基于此思想写程序，初始化方法，属性查找

一、面向过程编程VS面向对象编程

面向过程编程：
    核心是过程二字，过程是解决问题的步骤，即先干啥再干啥后干啥
    基于该思想写程序就是在设计一条条的流水线

    优点：复杂的问题流程化、进而简单化
    缺点：扩展性差

面向对象编程：
    核心是对象二字，对象是一个用来盛放数据与功能的容器
    基于该思想写程序就是在整合程序

    优点：可扩展性强
    缺点：编程的复杂度高
软件不止于面向对象程序设计（解决可扩展性），还有其他方方面面

二、如何基于面向对象的思想写程序

# 例1
# 学生的数据
stu_name = "egon"
stu_age = 18
stu_gender = "male"

# 学生的功能
def choose(name, age, gender):
    print('%s:%s:%s 正在选课' % (name, age, gender))

choose(stu_name,stu_age,stu_gender)

 

# 例2：基于对象式的思想进行改写
def choose(stu_self):
    print('%s:%s:%s 正在选课' % (stu_self["stu_name"], stu_self["stu_age"],stu_self["stu_gender"],))

stu_obj = {
    "stu_name": "egon",
    "stu_age": 18,
    "stu_gender": "male",
    "choose":choose
}

print(stu_obj["stu_name"])
stu_obj["choose"](stu_obj)

python提供专门的语法来更漂亮地实现面向对象编程

'''
学生对象1
    数据：

        名字 = "冯疯子"
        年龄 = 18
        性别 = "female"

学生对象2
    数据：

        名字 = "郭靖"
        年龄 = 19
        性别 = "male"

学生对象3
    数据：
        名字 = "大雕"
        年龄 = 200
        性别 = "male"

学生的类
    相同的数据
        学校 = "oldboy"
    相同的功能
        选课
'''

三、初始化方法

对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体

在程序中：务必保证先定义类，后产生对象

调用函数会执行函数体代码返回的是函数体执行的结果，而调用类会产生对象，返回的是对象

#例1
# 类体代码会在类定义阶段立刻执行，然后将产生的名字都丢到类的名称空间中
class Student:
    # 相同的数据
    school = "oldboy"
    # 相同的功能
    def choose(self):
        print("正在选课")

    # print('====>')

stu_obj1=Student()
stu_obj2=Student()
stu_obj3=Student()

stu_obj1.name = "冯疯子"  # stu1_obj1.__dict__["name"] = "冯疯子"
stu_obj1.age = 18
stu_obj1.gender = "female"

stu_obj2.name = "郭靖"
stu_obj2.age = 19
stu_obj2.gender = "male"

stu_obj3.name = "大雕"
stu_obj3.age = 200
stu_obj3.gender = "male"

print(stu_obj1.name) #冯疯子
stu_obj1.school = "xxx"#重新赋值
print(stu_obj1.school) #xxx

# print(Student.__dict__)
print(stu_obj1.__dict__)#{'name': '冯疯子', 'age': 18, 'gender': 'female', 'school': 'xxx'}
print(stu_obj2.__dict__)#{'name': '郭靖', 'age': 19, 'gender': 'male'}
print(stu_obj3.__dict__)#{'name': '大雕', 'age': 200, 'gender': 'male'}

 

#例2
class Student:
    school = "oldboy"

    def choose(self):
        print("正在选课")
    print('===>')

stu_obj1 = Student()
stu_obj2 = Student()
stu_obj3 = Student()

def init(obj, x, y, z):
    obj.name = x
    obj.age = y
    obj.gender = z

init(stu_obj1, "冯疯子", 18, "female")
init(stu_obj2, "郭靖", 19, "male")
init(stu_obj3, "大雕", 200, "male")
print(stu_obj1.__dict__)
print(stu_obj2.__dict__)
print(stu_obj3.__dict__)

 

class Student:
    school = "oldboy"

    #             空对象
    def __init__(obj, x, y, z):
        obj.name = x
        obj.age = y
        obj.gender = z
        # return None # 只能返回None,所以就不要写return了

    def choose(self):
        print("正在选课")

# 调用类：
# 1、创建一个空对象与类相关
# 2、把空对象、"冯疯子", 18, "female"一起传给__init__方法，完成对象的初始化
# 3、赋值符号把初始化好的对象的内存地址绑定变量名stu_obj1
stu_obj1 = Student("冯疯子", 18, "female")
stu_obj2 = Student("郭靖", 19, "male")
stu_obj3 = Student("大雕", 200, "male")

print(Student.__dict__)
print(stu_obj1.__dict__)
print(stu_obj2.__dict__)
print(stu_obj3.__dict__)

四、属性查找

# 优先级
# 先从对象的字典里找，没有，再去类的字典中找
class Student:
    school = "oldboy"

    def __init__(obj, x, y, z):
        obj.name = x
        obj.age = y
        obj.gender = z

    def choose(self):
        print("%s 正在选课" %self.name)

stu_obj1 = Student("冯疯子", 18, "female")
stu_obj2 = Student("郭靖", 19, "male")
stu_obj3 = Student("大雕", 200, "male")

# 1、类中定义的数据是直接共享给所有对象使用的
# print(id(stu_obj1.school))#地址相同
# print(id(stu_obj2.school))#地址相同
# print(id(stu_obj3.school))#地址相同
# print(id(Student.school))#地址相同

# Student.school="xxx"
# print(stu_obj1.school)#xxx
# print(stu_obj2.school)#xxx
# print(stu_obj3.school)#xxx

# print(Student.choose)#地址不同
# print(stu_obj1.choose)#>地址不同
# print(stu_obj2.choose)#>地址不同
# print(stu_obj3.choose)#>地址不同

# 2、类中定义的函数是绑定给所有对象用的，绑定给谁就应该由哪个对象来调用
# 对象.绑定方法()会把对象当作第一个参数传入
#  类.函数()就是一个函数的玩法，没有自动传参的效果


Student.choose(123123123)
stu_obj3.choose()
stu_obj2.choose()
stu_obj1.choose()