Python记录14：面向对象编程 类和对象

'''
现在主流的编程思想有两种，一种是面向对象，一种是面向过程
面向过程编程
    核心是过程二字，过程指的是解决问题的步骤，即先干什么、再干什么、最后干什么。。。
    基于该思想编写程序就好比再设计一条流水线，是一种机械式的思维方式
    优点：复杂的问题流程化、进而简单化
    缺点：可扩扩展性差
面向对象编程：
    核心对象二字，对象是特征（变量）与技能（函数）的结合体，
    基于该思想编写程序就好比创造一个世界，你就是这个世界的上帝，
    在上帝眼里一切存在的事物都是对象，任何不存在的对象也都可以造出来
    是一种上帝式的思维方式
    优点：扩展性强
    缺点：编程的复杂度高
'''

'''
类：如果说对象是特征与技能的结合体，那么类就是一系列对象相似的特征与技能的结合体
    ps：站在不同的角度总结出的类是截然不同的
在现实世界中：一定是先有对象，再有分类的概念
在程序中，务必记住：一定要先定义类，后调用类来产生对象
在现实世界中（站在老男孩选课系统角度）
对象1：
    特征
        school='Oldboy'
        name='李泰迪'
        sex='male'
        age=18
    技能
        选课
对象2：
    特征
        school='Oldboy'
        name='牛榴弹'
        sex='female'
        age=38
    技能
        选课

对象3：
    特征
        school='Oldboy'
        name='张随便'
        sex='male'
        age=38
    技能
        选课

对象4：
    特征
        name='Egon'
        sex='male'
        age=18
        level=10
    技能
        打分
        点名

现实世界中老男孩学生类
    相似的特征
        school='Oldboy'
    相似的技能
        选课

'''
#在程序中
#先定义类
class OldboyStudent:
    school = 'Oldboy'
    def choose_course(self):
        print('is choosing course')

# 后调用类来产生对象，调用类的过程又称之为实例化
# stu1=OldboyStudent()  # stu1可称为一个对象，也可以称为一个实例
####上面这个语句就是调用类产生一个对象
#  print(type(stu1))

#在类定义阶段就会立刻执行类体代码，会产生类的名称空间，用于将类体代码执行过程中产生的名字都存放与类的名称空间中
#在调用类的时候会产生对象，这就是一个实例化的过程，从抽象的类到具体的实例的过程
#这一点和函数定义有很大的不同，函数在定义的阶段代码不会执行，只有在调用的时候才会执行
# class OldboyStudent:
#     school = 'Oldboy'
#     def choose_course(self):
#         print('is choosing course')
#     # print('====>')
#类有两种用途
#用途一：类本身就一个容器（名称空间），所以可以增删改查类的属性
# print(OldboyStudent.__dict__)
# print(OldboyStudent.__dict__['school'])
# print(OldboyStudent.__dict__['choose_course'])
# OldboyStudent.__dict__['choose_course'](123)

# print(OldboyStudent.school) #OldboyStudent.__dict__['school']
# print(OldboyStudent.xxx) #OldboyStudent.__dict__['xxx']
# print(OldboyStudent.choose_course)
# OldboyStudent.choose_course(123)

# OldboyStudent.country='China'
# OldboyStudent.school='Oldgirl'
# print(OldboyStudent.__dict__)
# del OldboyStudent.school
# print(OldboyStudent.__dict__)
#用途二：调用类来产生对象，调用类的过程又称之为实例化
x=1
# class OldboyStudent:
#     school = 'Oldboy'
#
#     def choose_course(self):
#         print('is choosing course')
# stu1=OldboyStudent()  # stu1可称为一个对象，也可以称为一个实例
# stu2=OldboyStudent()  # stu1可称为一个对象，也可以称为一个实例
# stu3=OldboyStudent()  # stu1可称为一个对象，也可以称为一个实例

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

#对象1 独有的特征
# name = '李泰迪'
# sex = 'male'
# age = 18
# stu1.name='李泰迪'
# stu1.sex='male'
# stu1.age=18
#
# init(stu1,'李泰迪','male',18)

#对象2 独有的特征
# name = '牛榴弹'
# sex = 'female'
# age = 38
# stu2.name='牛榴弹'
# stu2.sex='female'
# stu2.age=38

# init(stu2,'牛榴弹','female',38)
#对象3 独有的特征
# name = '张随便'
# sex = 'male'
# age = 38
# stu3.name='张随便'
# stu3.sex='male'
# stu3.age=38

# init(stu3,'张随便','male',38)

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

# ！！！！对象的属性查找是先从对象自己的名称空间中找，找不到则取类中查找。。。。,类中存放的数据是所有对象共有的，内存地址都一样
# print(stu1.x)
# print(stu1.school,id(stu1.school))
# print(stu2.school,id(stu2.school))
# print(stu3.school,id(stu3.school))
# print(stu1.choose_course,id(stu1.choose_course))
# print(stu2.choose_course,id(stu2.choose_course))
# print(stu3.choose_course,id(stu3.choose_course))

# ##初始化方法
# class OldboyStudent:
#     school = 'Oldboy'
#
#     # stu1, '李泰迪', 'male', 18
#     def __init__(self, x, y, z):
#         self.name = x #stu1.name = '李泰迪',
#         self.sex = y  #stu1.sex ='male'
#         self.age = z  #stu1.age = 18
#
#     def choose_course(self):
#         print('is choosing course')
#
#
# # 会在类调用时，或者叫实例化时自动触发__init__(stu1,'李泰迪','male',18)
# stu1=OldboyStudent('李泰迪','male',18)
# stu2=OldboyStudent('牛榴弹','female',38)
# stu3=OldboyStudent('张随便','male',38)
#
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)

# 绑定方法
# class OldboyStudent:
#     school = 'Oldboy'
#
#     # stu1, '李泰迪', 'male', 18
#     def __init__(self, x, y, z):
#         self.name = x #stu1.name = '李泰迪',
#         self.sex = y  #stu1.sex ='male'
#         self.age = z  #stu1.age = 18
#
#     def choose_course(self):
#         print('%s is choosing course' %self.name)
#
#
# # 会在类调用时，或者叫实例化时自动触发__init__(stu1,'李泰迪','male',18)
# stu1=OldboyStudent('李泰迪','male',18)
# stu2=OldboyStudent('牛榴弹','female',38)
# stu3=OldboyStudent('张随便','male',38)
#
# # OldboyStudent.school='Oldgirl'
# # stu1.school='Oldgirl'
# # print(stu1.__dict__)
# # print(stu1.school)
# # print(stu2.school)
# # print(stu3.school)
#
# # print(OldboyStudent.choose_course)
# # print(stu1.choose_course)
# # print(stu2.choose_course)
# # print(stu3.choose_course)
#
# # OldboyStudent.choose_course(123)
# # OldboyStudent.choose_course(stu1)
#
# # 绑定方法的特殊之处：
# #1、绑定给谁就应该由谁来调用
# #2、谁来调用，就会将谁当做第一个参数自动传入
# stu1.choose_course() # choose_course(stu1)
# stu2.choose_course()
# stu3.choose_course()

# 总结对象的好处
# #1、在没有学习类这个概念时，数据与功能是分离的
# # HOST=‘127.0.0.1’
# # PORT=3306
# # DB=‘db1’
# # CHARSET=’utf8‘
# #
# # def exc1(host,port,db,charset,sql):
# #     conn=connect(host,port,db,charset)
# #     conn.execute(sql)
# #     return xxx
# #
# #
# # def exc2(host,port,db,charset,proc_name)
# #     conn=connect(host,port,db,charset)
# #     conn.call_proc(sql)
# #     return xxx
# #
# # #每次调用都需要重复传入一堆参数
# # exc1('select * from tb1;')
# # exc1('select id,name from tb2;')
# # exc1('select id,name from tb3;')
# # exc1('select id,name from tb4;')
# # exc2('存储过程的名字1')
# # exc2('存储过程的名字2')
# # exc2('存储过程的名字3')
# #
# #
# # x=1
# # y=2
# # z=3
# #
# # def func1():
# #     pass
# #
# # def func2():
# #     pass
# #
# #
# # class Mysql:
# #     def __init__(self,h,p,d,c):
# #         self.host=h
# #         self.p=p
# #         self.d=d
# #         self.c=c
# #
# #     def exc1(self,sql):
# #         conn=connect(self.h,self.,self.d,charset)
# #         conn.execute(sql)
# #         return xxx
# #
# #
# #     def exc2(self,proc_name)
# #         conn = connect(self.h, self., self.d, charset)
# #         conn.call_proc(proc_name)
# #         return xxx
# #
# #
# # obj=Mysql('127.0.0.1',3306,'db1','utf-8')
# #
# #
# #
# #
# # # obj.exc1('select * from t1')
#
#
# # 在python3中统一了类与类型的概念，类就是类型
# import pickle
# class OldboyStudent:
#     school = 'Oldboy'
#
#
#     def __init__(self, x, y, z):
#         self.name = x #stu1.name = '李泰迪',
#         self.sex = y  #stu1.sex ='male'
#         self.age = z  #stu1.age = 18
#
#     def choose_course(self):
#         print('%s is choosing course' %self.name)
#
#     def save(self):
#         with open('%s.pkl' %self.name,'wb') as f:
#             pickle.dump(self,f)
#
# stu1=OldboyStudent('李泰迪','male',18)
# stu1.save()
#
# # print(OldboyStudent)
# # print(list)
# # print(dict)
# # print(int)
#
# l1=list([1,2,3])
# l2=list(['a','b'])
# # print(type(l1))
# # print(type(stu1))
#
# # print(l1.append)
# # l1.append(4) #list.append(l1,4)
# # list.append(l1,4)
# # print(l1)
# # print(l2)