zoukankan      html  css  js  c++  java
  • 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)
     
     







  • 相关阅读:
    Windows配置深度学习环境详细教程(二):conda工具的使用
    Windows配置深度学习环境详细教程(一):安装Pycharm和Miniconda
    性能基准DevOps之如何提升脚本执行效率
    【Go语言绘图】图片添加文字(二)
    Cesium中用到的图形技术——Computing the horizon occlusion point
    Cesium中用到的图形技术——Horizon Culling
    Unity3D学习笔记3——Unity Shader的初步使用
    C++:异常处理
    mysql数据库备份
    编程小工具
  • 原文地址:https://www.cnblogs.com/1832921tongjieducn/p/10093822.html
Copyright © 2011-2022 走看看