面向过程和面向对象 ， 面向对象基础

目录

• 面向过程和面向对象编程
• 对象的产生（类的定义）
• 1. 类
  • 1. 什么是类
  • 2. 类的定义：
  • 3. 类的操作
• 2. 对象
  • 1. 对象的产生
  • 2. 对象的名称空间
  • 3. 调用类时发生的事：
  • 4. 当对象与对象之间的特征和技能一样
  • 5. 对象与类的查找顺序
  • 6. 对象调用类里面的方法的特殊之处

1|0面向过程和面向对象编程

    什么是面向对象编程？
        指的是一门编程思想，它是对着一个具有某种特征和技能的事物进行编程，实现这些对象与对象之间的交互。
    面向过程编程:
        核心是“过程”二字。
        过程指的是做事情的步骤，即先做什么再做什么
        基于该编程思想编写程序，就好比一条工厂流水线，一种机械式的思维方式。
        优点:
            逻辑清晰，复杂的问题流程化，进而简单化。

        缺点:
            可扩展性差。

    面向对象编程:
        核心是“对象”二字。
        对象指的是特征与技能的结合体。
        基于该编程思想编写程序，就好比在创造世界，一种上帝式的思维方式。

        优点:
            可扩展性高。

        缺点:
            编写程序的复杂程度要远高于面向过程编程思想。

    优先使用面向过程还是面向对象（谁好谁坏）？
        没有谁好谁坏，他们都是一种编程思想。具体问题具体分析。一般是面向过程和面向对象结合，一起使用。
 

2|0对象的产生（类的定义）

• 定义对象的前提是先定义类。先定义类，后调用类产生对象。

• 现实世界中，现有对象再有类。

• 在程序中，必须遵循，先有类，再有对象。

• 什么是类：

  对象是特征和技能的结合体，类是一系列对象相同的特征与技能的结合体。

• 如何定义类：

  1. 先从现实世界中，基于一个个的对象，抽取出类

  2. 再定义类

3|01. 类

3|11. 什么是类

• 对象是特征与技能的结合体，类就是一系列对象相同的特征和技能的结合体。 在程序里特征就是属性，技能就是方法（函数）

3|22. 类的定义：

# 语法
class 类名：
	code
#  注意: 类名必须要遵循驼峰命名法，python在定义变量与函数时不推荐使用，但在定义类时推荐使用。
 

• 定义类发生的事：

  1. 类在定义时，会开辟一个名为类名的空的名称空间。
  2. 会把类内部所有名字，扔进类的名称空间中。
  注意: 类在定义阶段就已经产生好了名称空间，执行python文件时会执行类内部的代码。  
  函数是在调用的时候才产生名称空间，执行函数里的代码。
  

3|33. 类的操作

• 修改属性和方法：

类名.变量名或方法名的方式对类内部的内容进行修改。"."会指向类内部的名称空间，从而获取类内部的变量名和方法名。

class OldboyStudent:
    # 特征
    school = 'oldboy'
    print('tank is handsome...')

    # 技能
    def learn(self):
        print('learn python...')

    def choose_course(self):  # self = None
        print('choose_course ....')
        
# 修改属性和方法：类名.变量名或方法名的方式对类内部的内容进行修改。
# "."会指向类内部的名称空间，从而获取类内部的变量名和方法名。

**************************类的操作***********************
# 查
print(OldboyStudent.school)  # oldboy

# 改
OldboyStudent.school = 'oldgirl'
print(OldboyStudent.school)

# 增
print(OldboyStudent.address)  # 报错，特征也称之为属性
OldboyStudent.address = '上海'
print(OldboyStudent.address) # 上海

# 删
del OldboyStudent.address
print(OldboyStudent.address) # 报错
OldboyStudent.choose_course(123) # choose_course ....

4|02. 对象

4|11. 对象的产生

语法：

	类名 + () #调用类产生对象

4|22. 对象的名称空间

• 类的名称空间在定义类阶段就已经产生了
• 对象的名称空间，在调用类时产生

4|33. 调用类时发生的事：

'''
******调用类发生的事情:
    1.首先会产生一个空的对象，就是产生“对象的名称空间”。
    2.会自动触发__init__。
    3.会把对象本身以及括号内的参数一并传给__init__函数。
    
******总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例.
'''

4|44. 当对象与对象之间的特征和技能一样

# 解决方法: 
在类内部定义__init__函数。
# 中文翻译: 为对象初始化某些属性。
__init__: 会在调用类时，自动触发该函数。

• 实例：

  # 学生类
  class OldboyStudent:
      # 若__init__中有self以外的参数，调用类时必须在括号内传入参数。
      def __init__(self, x, y, z):  # self --> 就是对象本身  x = 高峰峰  y=93   z=female
          # print(self, x, y, z)
          # print('此处时__init__。。。。')
          # 给对象添加特征的方式二：
          self.name = x
          self.age = y
          self.sex = z
  
      # 特征
      school = 'oldboy'
      # print('tank is handsome...')
  
      # 技能
      def learn(self):
          print('learn python...')
  
      def choose_course(self):  # self = None
          print('choose_course ....')
  
  
  stu1 = OldboyStudent('高峰峰', 93, 'female')  # OldboyStudent()---> 学生对象
  stu2 = OldboyStudent('小丁丁', 84, 'female')  # OldboyStudent()---> 学生对象
  stu3 = OldboyStudent('大丁丁', 18, 'male')  # OldboyStudent()---> 学生对象
  
  '''
  ******调用类发生的事情:
      1.首先会产生一个空的对象，就是产生“对象的名称空间”。
      2.会自动触发__init__。
      3.会把对象本身以及括号内的参数一并传给__init__函数。
      
  ******总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例.
  '''
  
  *********# 对对象的操作与对类的操作相同。******************
  
  

4|55. 对象与类的查找顺序

• '''
  对象与类的查找顺序:
      1.对象.属性，若对象本身有，则优先查找对象自己的。
      2.若对象本身没有，则去类里面找，若类没有，则报错。
  '''
  

4|66. 对象调用类里面的方法的特殊之处

'''
类内部的函数主要是给对象用的:
    1.由类来调用类内部的函数，该函数只是一个普通的函数，
    普通函数需要接收几个参数就得传入几个参数。

    2.由对象来调用称之为对象的绑定方法,
    不同的对象调用该绑定方法,则会将不同的对象传入该绑定方法中.

    *******对象的绑定方法,是由对象来调用的,
        特殊之处就是把对象当作第一个参数传入该方法中.
'''

• 在类调用类里面的方法时，该方法就是普通的函数。有形参就要传值。

• 当对象调用类里面的方法时，该方法就变成了了绑定方法。方法里的self形参不需要传值，默认接收的实参是该对象名。且类和不同的对象调用同一函数时，他们的内存地址都不同，相当于是把该方法分别复制给了调用它的类和对象。

• 实例：

  class OldboyStudent:
      def __init__(self, name, age, sex):
          self.name = name
          self.age = age
          self.sex = sex
      # 特征
      school = 'oldboy'
      # 技能
      def learn(self):  # 普通函数
          # print('stu:', self)
          print('learn python...')
  
      def choose_course(self, course):  # self =
          print(f'[{self.name}]choose_course {course} ....')
  
  # print(OldboyStudent.learn)  # function
  # OldboyStudent.learn(123)
  
  
  stu1 = OldboyStudent('高凤凤1', 73, 'female')
  stu2 = OldboyStudent('高凤凤2', 84, 'male')
  
  # 对象之间与类的方法功能是一样的
  OldboyStudent.learn(123)
  stu1.learn() 
  
  *****************类与不同对象分别伪调用****************
  print(OldboyStudent.learn)
  # <function OldboyStudent.learn at 0x0000000009FF0E18>
  print(stu1.learn)
  # <bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x0000000009FBA278>>
  print(stu2.learn)
  #<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x0000000009FBA2B0>>
  

__EOF__

本文作者：BigSun丶
本文链接：https://www.cnblogs.com/Mcoming/p/11642484.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！