一 面向对象介绍

  1. 面向过程:
    核心是:“过程”二字

    过程的终极奥义就是将程序流程化
    过程是“流水化”,用来分步骤解决问题的

    面向对象:
    核心是“对象”二字
    对象的终极奥义就是将程序“整合”
    对象是“容器”,用来盛放数据与功能的

    类也是“容器”,该容器用来存放同类对象共有的数据与功能

    python这门语言到底提供了什么语法来允许我们将数据与功能很好地整合到一起

  1. 程序=数据+功能

    学生的容器=学生的数据+学生的功能
    课程的容器=课程的数据+课程的功能
  1.   1、编程范式/思想
  2. 面向过程
  3. 介绍:
  4. 核心是“过程”二字
  5. 过程就是“流水化"
  6. 过程终极奥义是将程序流程化
  7.  
  8. 优点:
  9. 1、将程序流程化,进而程序的设计会变得简单化
  10.  
  11. 缺点:
  12. 1、可扩展性差
  13.  
  14. 面向对象
  15. 介绍:
  16. 核心是“对象”二字
  17. 对象就是“容器",用来盛放数据与功能
  18. 对象终极奥义是将程序进行高度整合
  19.  
  20. 优点:
  21. 1、提升程序的解耦合程度,进而增强程序的可扩展性
  22.  
  23. 缺点:
  24. 1、设计复杂
  25.  
  26. 2、面向对象编程
  27. 一:现实生活中:
  28. 1)先找出现实生活中的对象
  29. 2)然后总结归纳出现实生活中的类
  30.  
  31. 二:程序中:
  32. 1)先定义程序中的类
  33. 2)后调用类产生程序中的对象(调用类的过程又称之为实例化)

二 什么是面向对象的程序设计及为什么要有它

面向过程的程序设计:核心是过程二字,过程指的是解决问题的步骤,即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线,是一种机械式的思维方式。

优点是:复杂度的问题流程化,进而简单化(一个复杂的问题,分成一个个小的步骤去实现,实现小的步骤将会非常简单)

缺点是:一套流水线或者流程就是用来解决一个问题,生产汽水的流水线无法生产汽车,即便是能,也得是大改,改一个组件,牵一发而动全身。

应用场景:一旦完成基本很少改变的场景,著名的例子有Linux內核,git,以及Apache HTTP Server等。

面向对象的程序设计:核心是对象二字,(要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记,如来要解决的问题是把经书传给东土大唐,如来想了想解决这个问题需要四个人:唐僧,沙和尚,猪八戒,孙悟空,每个人都有各自的特征和技能(这就是对象的概念,特征和技能分别对应对象的数据属性和方法属性),然而这并不好玩,于是如来又安排了一群妖魔鬼怪,为了防止师徒四人在取经路上被搞死,又安排了一群神仙保驾护航,这些都是对象。然后取经开始,师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取),对象是特征与技能的结合体,基于面向对象设计程序就好比在创造一个世界,你就是这个世界的上帝,存在的皆为对象,不存在的也可以创造出来,与面向过程机械式的思维方式形成鲜明对比,面向对象更加注重对现实世界的模拟,是一种“上帝式”的思维方式。

优点是:解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。

缺点:

1. 编程的复杂度远高于面向过程,不了解面向对象而立即上手基于它设计程序,极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度,比如管理linux系统的shell脚本就不适合用面向对象去设计,面向过程反而更加适合。

2. 无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间的交互解决问题,即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏,新增一个游戏人物,在对战的过程中极容易出现阴霸的技能,一刀砍死3个人,这种情况是无法准确预知的,只有对象之间交互才能准确地知道最终的结果。

应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方

面向对象的程序设计并不是全部。对于一个软件质量来说,面向对象的程序设计只是用来解决扩展性。

三 实现面向对象编程

  1. # 一、先定义类
  2. # 类是对象相似数据与功能的集合体
  3. # 所以类中最常见的是变量与函数的定义,但是类体其实是可以包含任意其他代码的
  4. # 注意:类体代码是在类定义阶段就会立即执行,会产生类的名称空间
  5. # 类的命名应该使用“驼峰体”
  6. class Student:
  7. # 1、变量的定义
  8. school = '清华大学' # 数据
  9.  
  10. # 2、功能的定义
  11. def tell_stu_info(stu_obj):
  12. print('学生信息:名字:{} 年龄:{} 性别:{}'.format(
  13. stu_obj['stu_name'],
  14. stu_obj['stu_age'],
  15. stu_obj['stu_gender'],
  16. ))
  17.  
  18. def set_info(stu_obj, x, y, z):
  19. stu_obj['stu_name'] = x
  20. stu_obj['stu_age'] = y
  21. stu_obj['stu_gender'] = z
  22.  
  23. # print('---->') # 类的定义阶段,就会立即执行
  24.  
  25. print(Student.__dict__)
  26. print(Student.__dict__['school'])
  27. # 属性访问的语法
  28. # 1、访问数据属性
  29. print(Student.school) # 等同于Student.__dict__['school']
  30. # 2、访问函数属性
  31. print(Student.set_info) # 等同于Student.__dict__['set_info']
  32.  
  33. # 二、再调用类产生对象
  34. # 产生对象名称空间,并与类名称空间产生关联
  35. Stu1_obj = Student()
  36. Stu2_obj = Student()
  37. Stu3_obj = Student()
  38.  
  39. print(Stu1_obj.__dict__)
  40. print(Stu2_obj.__dict__)
  41. print(Stu2_obj.__dict__)
  42.  
  43. # 对象定制自己独有的属性
  44. # 问题1:代码重复
  45. # 问题2:属性的查找顺序
  46. Stu1_obj.stu_name = 'lq' # Stu1_obj.__dict__['stu_name']='lq'
  47. Stu1_obj.stu_age = 18 # Stu1_obj.__dict__['stu_age']=18
  48. Stu1_obj.stu_gender = 'female' # Stu1_obj.__dict__['stu_gender']='female'
  49. print(Stu1_obj.__dict__)
  50.  
  51. Stu2_obj.stu_name = 'zd'
  52. Stu2_obj.stu_age = 19
  53. Stu2_obj.stu_gender = 'male'
  54. print(Stu2_obj.__dict__)
  55.  
  56. Stu3_obj.stu_name = 'xiaobao'
  57. Stu3_obj.stu_age = 5
  58. Stu3_obj.stu_gender = 'female'
  59. print(Stu3_obj.__dict__)
  60.  
  61. # 解决问题:
  62. # 解决方案一:
  63. def init(obj, x, y, z):
  64. obj.stu_name = x
  65. obj.stu_age = y
  66. obj.stu_gender = z
  67.  
  68. init(Stu1_obj, 'lq', 18, 'male')
  69. print(Stu1_obj.__dict__)
  70.  
  71. # 解决方案二:
  72. # 一:先定义类
  73. class Student: # 类的命名应该使用“驼峰体”
  74. # 1、变量的定义
  75. school = '清华大学' # 数据
  76.  
  77. # 空对象,'egon',18,'male'
  78. def __init__(obj, x, y, z):
  79. obj.stu_name = x # 空对象.stu_name='egon'
  80. obj.stu_age = y # 空对象.stu_age=18
  81. obj.stu_gender = z # 空对象.stu_gender='male'
  82.  
  83. # 2、功能的定义
  84. def tell_stu_info(stu_obj):
  85. print('学生信息:名字:{} 年龄:{} 性别:{}'.format(
  86. stu_obj['stu_name'],
  87. stu_obj['stu_age'],
  88. stu_obj['stu_gender'],
  89. ))
  90.  
  91. def set_info(stu_obj, x, y, z):
  92. stu_obj['stu_name'] = x
  93. stu_obj['stu_age'] = y
  94. stu_obj['stu_gender'] = z
  95.  
  96. # 二:再调用类产生对象
  97. # 调用类的过程又称之为实例化,发生了三件事
  98. # 1、先产生一个空对象
  99. # 2、python会自动调用类中的__init__方法,然后将空对象已经调用类是括号内传入的参数一同传给__init__方法
  100. # 3、返回初始完的对象
  101.  
  102. Stu1_obj = Student('lq', 19, 'male')
  103. Stu2_obj = Student('zd', 19, 'male')
  104. Stu3_obj = Student('xiaobao', 18, 'male')
  105.  
  106. print(Stu1_obj.__dict__)
  107. print(Stu2_obj.__dict__)
  108. print(Stu3_obj.__dict__)
  109.  
  110. # 总结__init__方法
  111. # 1、会在调用类时自动触发执行,用来为对象初始化自己独有的数据
  112. # 2、__init__内应该存放是为对象初始化属性的功能,但是可以存放任意其他代码,想要在
  113. # 类调用时就立刻执行的代码都可以放到该方法内
  114. # 3、__init__方法必须返回None

四 属性查找

先查找对象名称空间中查找数据属性,找不到,再到类的名称空间里找

  1. class Student: # 类的命名应该使用“驼峰体”
  2. # 1、变量的定义
  3. school = '清华大学' # 数据
  4. count = 0
  5.  
  6. def __init__(self, x, y, z):
  7. Student.count += 1 # 实例化计数
  8. self.stu_name = x # 空对象.stu_name='egon'
  9. self.stu_age = y # 空对象.stu_age=18
  10. self.stu_gender = z # 空对象.stu_gender='male'
  11.  
  12. # 2、功能的定义
  13. def tell_stu_info(obj):
  14. print('学生信息:名字:{} 年龄:{} 性别:{}'.format(
  15. obj.stu_name,
  16. obj.stu_age,
  17. obj.stu_gender,
  18. ))
  19.  
  20. def set_info(obj, x, y, z):
  21. obj.stu_name = x
  22. obj.stu_age = y
  23. obj.stu_gender = z
  24.  
  25. Stu1_obj = Student('lq', 19, 'male')
  26. Stu2_obj = Student('zd', 19, 'male')
  27. Stu3_obj = Student('xiaobao', 18, 'male')
  28.  
  29. # 类中存放的是对象共有的数据与功能
  30. # 一、类可以访问:
  31. # 1、类的数据属性
  32. print(Student.school)
  33. # 2、类的函数属性
  34. print(Student.set_info)
  35. print(Student.tell_stu_info)
  36. # 二、但其实类中的东西是给对象用的
  37. # 1、类的数据属性是共享给所有对象用的,大家访问的地址都一样
  38. print(Student.school)
  39. print(Stu1_obj.school)
  40. print(Stu2_obj.school)
  41. print(Stu3_obj.school)
  42. Stu1_obj.school = '上海中学' # 对象Stu1,自己名称空间里建school数据属性
  43. print(Stu1_obj.school)
  44.  
  45. # 2、类中定义的函数主要是给对象使用的,而且是绑定给对象的,虽然所有对象指向的都是相同的功能,
  46. # 但是绑定到不同的对象就是不同的绑定方法,内存地址各不相同
  47.  
  48. # 类调用自己的函数属性必须严格按照函数的用法来
  49. Student.tell_stu_info(Stu1_obj)
  50. Student.tell_stu_info(Stu2_obj)
  51. Student.tell_stu_info(Stu3_obj)
  52. Student.set_info(Stu1_obj, 'LQ', 33, 'MALL')
  53. Student.set_info(Stu2_obj, 'ZD', 33, 'MALL')
  54. Student.set_info(Stu3_obj, 'XIAOBAO', 6, 'MALL')
  55. '''
  56. 学生信息:名字:lq 年龄:19 性别:male
  57. 学生信息:名字:zd 年龄:19 性别:male
  58. 学生信息:名字:xiaobao 年龄:18 性别:male
  59. 学生信息:名字:LQ 年龄:33 性别:MALL
  60. 学生信息:名字:ZD 年龄:33 性别:MALL
  61. 学生信息:名字:XIAOBAO 年龄:6 性别:MALL
  62. '''
  63.  
  64. # 绑定方法的特殊之处在于:谁来调用绑定方法就会将谁当做第一个参数自动传入,
  65. # 所以类中定义的函数第一个参数默认self,类中函数方法(无参函数,也需要有self的原因)
  66. print(Student.tell_stu_info)
  67. print(Stu1_obj.tell_stu_info) # 绑定方法,
  68. print(Stu2_obj.tell_stu_info)
  69. print(Stu3_obj.tell_stu_info)
  70. '''
  71. <function Student.tell_stu_info at 0x000001D76D422550>
  72. <bound method Student.tell_stu_info of <__main__.Student object at 0x000001D76D3C30A0>>
  73. <bound method Student.tell_stu_info of <__main__.Student object at 0x000001D76D3C3310>>
  74. <bound method Student.tell_stu_info of <__main__.Student object at 0x000001D76D3C9550>>
  75. '''
  76.  
  77. # 直接对象来调用函数方法,对象直接当第一个参数自动传入,不用再像类调用函数方法时,传对象参数
  78. # 比从类中调用,更简单,并且语意明确
  79. Stu1_obj.tell_stu_info()
  80. Stu2_obj.tell_stu_info()
  81. Stu3_obj.tell_stu_info()
  82. Stu1_obj.set_info('LQ', 33, 'MALL')
  83. Stu2_obj.set_info('ZD', 33, 'MALL')
  84. Stu3_obj.set_info('XIAOBAO', 6, 'MALL')
  85. '''
  86. 学生信息:名字:lq 年龄:19 性别:male
  87. 学生信息:名字:zd 年龄:19 性别:male
  88. 学生信息:名字:xiaobao 年龄:18 性别:male
  89. 学生信息:名字:LQ 年龄:33 性别:MALL
  90. 学生信息:名字:ZD 年龄:33 性别:MALL
  91. 学生信息:名字:XIAOBAO 年龄:6 性别:MALL
  92. '''
  93.  
  94. # Python中一切皆为对象,且Python3中类与类型是一个概念
  95. # 在上述介绍类与对象的使用过程中,我们更多的是站在底层原理的角度去介绍类与对象之间的关联关系,
  96. # 如果只是站在使用的角度,我们无需考虑语法“对象.属性
  97. # "中”属性“到底源自于哪里,只需要知道是通过对象获取到的就可以了,所以说,对象是一个高度整合的产物,
  98. # 有了对象,我们只需要使用“对象.xxx”的语法就可以得到跟这个对象相关的所有数据与功能,十分方便且解耦合程度极高。

五 练习

对象可以当参数传递

  1. # 整合---》解耦合---》扩展性增强
  2.  
  3. # 学校
  4. class School:
  5. school_name = 'OLDBOY'
  6.  
  7. def __init__(self, nickname, addr):
  8. self.nickname = nickname
  9. self.addr = addr
  10. self.classes = []
  11.  
  12. def related_class(self, grade_obj): # 传对象,在.'属性'
  13. self.classes.append(grade_obj)  # 列表存储的班级对象
  14. # self.classes.append(班级名称)
  15.  
  16. def class_tell_info(self):
  17. print(self.nickname)
  18. for grade_obj in self.classes:
  19. grade_obj.tell_course()
  20.  
  21. # 1、学校
  22. # 1)创建校区
  23. school_obj1 = School('上海校区', '上海')
  24. school_obj2 = School('北京校区', '北京')
  25.  
  26. # 2)为学校开设班级
  27. # school_obj1.related_class('脱产14期')
  28. # school_obj1.related_class('脱产15期')
  29. # school_obj2.related_class('脱产29期')
  30.  
  31. # 3)查看每个校区开设的班级
  32. # school_obj1.class_tell_info()
  33.  
  34. # 班级
  35. class Grade:
  36. def __init__(self, name):
  37. self.name = name
  38. self.course = None
  39.  
  40. def related_course(self, course_obj):
  41. self.course = course_obj # 变量名有,就是修改,没有,就是新建
  42.  
  43. def tell_course(self):
  44. print('班级名:{}'.format(self.name),end=' ')
  45. self.course.tell_info()
  46.  
  47. # 2、班级
  48. # 1)创建班级
  49. grade_obj1 = Grade('脱产14期')
  50. grade_obj2 = Grade('脱产15期')
  51. grade_obj3 = Grade('脱产29期')
  52.  
  53. # 2)为班级关联一个课程
  54. # grade_obj1.related_course('python全栈开发')
  55. # grade_obj2.related_course('linux运维')
  56. # grade_obj3.related_course('python全栈开发')
  57.  
  58. # 3)查看班级开设的课程信息
  59. # grade_obj1.tell_course()
  60. # grade_obj2.tell_course()
  61. # grade_obj3.tell_course()
  62.  
  63. # 4) 为学校开设办班级
  64. # 上海校区开了:脱产14期,上海校区开了脱产15期
  65. school_obj1.related_class(grade_obj1)
  66. school_obj1.related_class(grade_obj2)
  67.  
  68. # print(school_obj1.classes) # 课程列表里,是对象
  69.  
  70. # 北京校区开了:脱产29期
  71. school_obj2.related_class(grade_obj3)
  72.  
  73. # school_obj1.class_tell_info()
  74.  
  75. # 课程
  76. class Course:
  77. def __init__(self, name, period, price):
  78. self.name = name
  79. self.period = period
  80. self.price = price
  81.  
  82. def tell_info(self):
  83. print('<课程名:{},课程周期:{},课程价格{}>'.format(self.name, self.period, self.price))
  84.  
  85. # 1)创建课程
  86. course_obj1 = Course('python全栈开发', '6个月', 20000)
  87. course_obj2 = Course('linux运维', '5个月', 18000)
  88.  
  89. # 2) 查看课程的详细信息
  90. # course_obj1.tell_info()
  91. # course_obj2.tell_info()
  92.  
  93. # 3) 为班级关联课程对象
  94. grade_obj1.related_course(course_obj1)
  95. grade_obj2.related_course(course_obj2)
  96. grade_obj3.related_course(course_obj1)
  97.  
  98. # grade_obj1.tell_course()
  99. # grade_obj2.tell_course()
  100. # grade_obj3.tell_course()
  101.  
  102. school_obj1.class_tell_info()
  103. school_obj2.class_tell_info()
  104.  
  105. class Student:
  106. pass

python面向对象(基础)的更多相关文章

  1. Python 面向对象 基础

    编程范式概述:面向过程 和 面向对象 以及函数式编程 面向过程:(Procedure Oriented)是一种以事件为中心的编程思想. 就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现 ...

  2. python面向对象基础

    面向对象基础 1. 简述 编程方式: 面向过程: 根据代码在脚本的堆叠顺序,从上到下依次执行 函数式编程:将相同功能的代码封装到函数中,直接调用即可,减少代码重复性 面向对象:对函数进行分类和封装,将 ...

  3. Python 面向对象基础知识

    面向对象基础知识 1.什么是面向对象编程? - 以前使用函数 - 类 + 对象 2.什么是类什么是对象,又有什么关系? class 类: def 函数1(): pass def 函数2(): pass ...

  4. python 面向对象基础和高级复习

    面向对象基础 面向对象编程 面向过程编程:类似于工厂的流水线 优点:逻辑清晰 缺点:扩展性差 面向对象编程:核心是对象二字,对象属性和方法的集合体,面向对象编程就是一堆对象交互 优点:扩展性强 缺点: ...

  5. 十六、python面向对象基础篇

    面向对象基础: 在了解面向对象之前,先了解下变成范式: 编程范式是一类典型的编程风格,是一种方法学 编程范式决定了程序员对程序执行的看法 oop中,程序是一系列对象的相互作用 python支持多种编程 ...

  6. 1.Python面向对象基础

    面向对象(OOP) 面向对象编程--object oriented programming 简写 OOP   面向过程和面向对象的区别: 面向过程: 1.把完成某一个需求的所有步骤从头到尾逐步实现 2 ...

  7. [python面向对象]--基础篇

    1.#类 #类就是一个模板,模板里可以包含多个函数,函数里实现一些功能 #定义一个类 class bar: def foo(self,agr): print(self,agr) obj = bar() ...

  8. Python面向对象基础:编码细节和注意事项

    在前面,我用了3篇文章解释python的面向对象: 面向对象:从代码复用开始 面向对象:设置对象属性 类和对象的名称空间 本篇是第4篇,用一个完整的示例来解释面向对象的一些细节. 例子的模型是父类Em ...

  9. Python面向对象基础一

    公司可能过一两个月就要从深圳搬到东莞松山湖,项目组的现在有的在转Java或其他语言的,问我们要不要转java+hoodap+spark方向,我还是先不转,毕竟之前是从ios转回C#,这现在在转其他的那 ...

  10. python面向对象基础-01

    面向对象(OOP)基本概念 前言 话说三国时期曹军于官渡大败袁绍,酒席之间,曹操诗兴大发,吟道:喝酒唱歌,人生真爽! 众将直呼:"丞相好诗",于是命印刷工匠刻板印刷以流传天下; 待 ...

随机推荐

  1. 安装Electron时卡在install.js不动的解决方案

    问题来源,发现即使 源切换成淘宝的之后,安装 electron的时候还是慢死,郁闷,后来百度才发现,原来,还需要设置一个地方!!! 经过试验,果然快了 爽.... 之前在安装Electron的时候,经 ...

  2. Hive数据导入与导出

    数据导入 ● 本地文件导入 -- 本地文件导入(local) LOAD DATA local INPATH '/home/hadoop/sourceA.txt' INTO TABLE testA PA ...

  3. AI抠图神器RMBG下载介绍

    RMBG是一款先进的AI抠图工具,和其它同类型软件不同的是,RMBG不需要人工勾勒图形轮廓,可以自动识别图像的前景并去除背景,节省大量时间,效果非常惊艳 最新中文版下载: 百度网盘:https://p ...

  4. JS 这一次彻底理解选择排序

    壹 ❀ 引 我在 JS 这一次彻底理解冒泡排序 一文中介绍了十大经典排序中的冒泡排序,所谓冒泡排序就是不断比较相邻的两个元素,让较小的往前浮,较大的往后沉,直到所有元素找到自己对应的位置.那么现在我们 ...

  5. Buffer Queue原理

    BufferQueue详解 原理一.BufferQueue 简介在工作中,我们经常会和Surface,ImageReader,ImageWriter BufferQueue打交道,它们之间是什么关系呢 ...

  6. ARP(Address Resolution Protocol) Packet

    Address Resolution Protocol The Address Resolution Protocol (ARP) is a communication protocol used f ...

  7. Laravel入坑指南(番外)——任务调度

    Laravel提供了非常强劲的命令行工具(如果还不了解,传送到第8往篇),我们如果想要定期执行某个命令行,可以利用crontab进行定时设置.如果有多个定期的任务,很简单,我们设定多条crontab规 ...

  8. Spring Boot图书管理系统项目实战-9.归还图书

    导航: pre:  8.续借图书 next:10.借还统计 只挑重点的讲,具体的请看项目源码. 1.项目源码 需要源码的朋友,请捐赠任意金额后留下邮箱发送:) 2.页面设计 2.1 bookRetur ...

  9. FART 脱壳机原理分析

    FART是一个基于Android 源码修改的脱壳机 可以脱整体壳和抽取壳 FART脱壳的步骤主要分为三步: 1.内存中DexFile结构体完整dex的dump 2.主动调用类中的每一个方法,并实现对应 ...

  10. 【Azure Function】Azure Function中使用 Java 8 的安全性问题

    问题描述 使用Azure Function, 环境是Linux的Java8.目前 Oracle Java JDK8,11,17 和 OpenJDK 8/11/17 都在存在漏洞受影响版本的范围内. O ...