Python之面向对象(一)面向对象初识

6.2 面向对象初识

  1. 面向对象初识

    • 回顾面向过程编程VS函数式编程
    • 面向过程编程
    • # 面向过程编程 测量对象的元素个个数。
      s1 = 'fjdsklafsjda'
      count = 0
      for i in s1:
          count += 1
      
      l1 = [1,2,3,4]
      count = 0
      for i in l1:
          count += 1
      
      #面向过程编程
    • 函数式编程
    • def func(s):
          count = 0
          for i in s:
              count += 1
          return count
      func('fdsafdsa')
      func([1,2,3,4])
      
      #函数式编程
    • 通过对比可知,函数编程和面向过程编程明显有两个特点:1.减少代码的重复性。2.增强代码的可读性
    • 函数式编程VS面向对象编程
    • # 函数式编程
      
      # auth 认证相关
      def login():
          pass
      
      def regisgter():
          pass
      
      # account 账户相关
      def func1():
          pass
      
      def func2():
          pass
      
      # 购物车相关
      def shopping(username,money):
          pass
      def check_paidgoods(username,money):
          pass
      def check_unpaidgoods(username,money):
          pass
      def save(username,money):
          pass
      
      #函数式编程
      
      lass LoginHandler:
          def login(self):
              pass
      
          def regisgter(self):
              pass
      
      class Account:
          def func1(self):
              pass
      
          def func2(self):
              pass
      
      class ShoppingCar:
          def shopping(username,money):
              pass
          def check_paidgoods(username,money):
              pass
          def check_unpaidgoods(username,money):
              pass
          def save(username,money):
              pass
      
      #面向对象式编程
    • 通过对比可以看出面向对象第一个优点:面向对象编程是一类相似功能函数的集合,使你的代码更清晰化,更合理化
  2. 面向对象
    • 简介:什么是面向对象?面向对象的程序设计的核心是对象(上帝式思维),要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆对象,不存在的可以创造出来。 什么是类?什么是对象? 类:就是具有相同属性和功能的一类事物
  3. 类的结构
    • class Human:
          """
          此类主要是构建人类
          """
          mind = '有思想'  # 第一部分:静态属性 属性 静态变量 静态字段
          dic = {}
          l1 = []
          def work(self): # 第二部分:方法 函数 动态属性
              print('人类会工作')
      #class 是关键字与def用法相同,定义一个类。
      #Human是此类的类名,类名使用驼峰(CamelCase)命名风格,首字母大写,私有类可用一个下划线开头。
      #类的结构从大方向来说就分为两部分:
      #静态变量。
      #动态方法。
  4. 从类名的角度研究类
    • 类明操作静态属性
    • 第一种,查看类中所有的内容:类名.__dict__方式
    • class Human:
          """
          此类主要是构建人类
          """
          mind = '有思想'  # 第一部分:静态属性 属性 静态变量 静态字段
          dic = {}
          l1 = []
          def work(self): # 第二部分:方法 函数 动态属性
              # print(self)
              print('人类会工作')
      
      print(Human.__dict__)
      print(Human.__dict__['mind'])
      Human.__dict__['mind'] = '无脑'
      print(Human.__dict__)  # 错误
      #通过这种方式只能查询,不能增删改.
      
      # 第一种方式只用户查询全部内容(一般不用单独属性查询).
    • 第二种:万能的点
    • class Human:
          """
          此类主要是构建人类
          """
          mind = '有思想'  # 第一部分:静态属性 属性 静态变量 静态字段
          dic = {}
          l1 = []
          def work(self): # 第二部分:方法 函数 动态属性
              # print(self)
              print('人类会工作')
      print(Human.mind)  # 查
      Human.mind = '无脑'  # 改
      print(Human.mind)
      del Human.mind  # 删
      Human.walk = '直立行走'
      print(Human.walk)
      # 通过万能的点 可以增删改查类中的单个属性
    • **对以上两种做一个总结:如果想查询类中的所有内容,通过 第一种__dict__方法,如果只是操作单个属性则用万能的点的方式**
  5. 类名操作动态方法
    • 前提:除了两个特殊方法:静态方法,类方法之外,一般不会通过类名操作一个类中的方法。
    • class Human:
          """
          此类主要是构建人类
          """
          mind = '有思想'  # 第一部分:静态属性 属性 静态变量 静态字段
          dic = {}
          l1 = []
          def work(self): # 第二部分:方法 函数 动态属性
              # print(self)
              print('人类会工作')
          def tools(self):
              print('人类会使用工具')
      
      Human.work(111)
      Human.tools(111)
      下面可以做,但不用。
      Human.__dict__['work'](111)
  6. 从对象的角度研究类
    • 什么是对象
    • 对象是从类中出来的,只要是类名加上(),这个就会实例化一个对象
    • class Human:
          mind = '有思想'
          def __init__(self):
              print(666)
              print(self)  # <__main__.Human object at 0x00000191508AA828>
      
          def work(self):
              print('人类会工作')
      
          def tools(self):
              print('人类会使用工具')
      obj = Human() # 只要实例化对象,它会自动执行__init__方法
      print(obj)  # <__main__.Human object at 0x00000191508AA828>
      # 并且obj的地址与self的地址相同
    • 实例化一个对象总共发生了三件事:1.在内存中开辟一个对象空间 2.自动执行类中的init方法,并将这个对象空间(内存地址)传给了init方法的第一个位置参数self 3.在init方法中通过self给对象空间添加属性
    • class Human:
          mind = '有思想'
          def __init__(self):
              print(666)
              print(self)  # <__main__.Human object at 0x00000191508AA828>
      
          def work(self):
              print('人类会工作')
      
          def tools(self):
              print('人类会使用工具')
      obj = Human() # 只要实例化对象,它会自动执行__init__方法
      print(obj)  # <__main__.Human object at 0x00000191508AA828>
      # 并且obj的地址与self的地址相同
  7. 对象操作对象空间属性
    • 对象查询对象中所有对象。对象.__dict__
    • class Human:
      
          mind = '有思想'
          language = '实用语言'
          def __init__(self,name,sex,age,hobby):
              # self 和 obj 指向的是同一个内存地址同一个空间,下面就是通过self给这个对象空间封装四个属性。
              self.n = name
              self.s = sex
              self.a = age
              self.h = hobby
      
      obj = Human('barry','男',18,'运动')
      print(obj.__dict__)  # {'n': 'barry', 'h': '运动', 's': '男', 'a': 18}
    • 对象操作对象中的单个属性。万能的点
    • class Human:
      
          mind = '有思想'
          language = '实用语言'
          def __init__(self,name,sex,age,hobby):
              # self 和 obj 指向的是同一个内存地址同一个空间,下面就是通过self给这个对象空间封装四个属性。
              self.n = name
              self.s = sex
              self.a = age
              self.h = hobby
      
      obj = Human('barry','男',18,'运动')
      obj.job = 'IT'  # 增
      del obj.n  # 删
      obj.s = '女' # 改
      print(obj.s)  # 查
      print(obj.__dict__)
  8. 对象查看类中的属性
    class Human:
    
        mind = '有思想'
        language = '实用语言'
        def __init__(self,name,sex,age,hobby):
            self.n = name
            self.s = sex
            self.a = age
            self.h = hobby
    
    obj = Human('barry','男',18,'运动')
    print(obj.mind)
    print(obj.language)
    obj.a = 666
    print(obj.a)
  9. 对象操作类中的方法
    class Human:
    
        mind = '有思想'
        language = '实用语言'
        def __init__(self,name,sex,age,hobby):
            self.n = name
            self.s = sex
            self.a = age
            self.h = hobby
    
        def work(self):
            print(self)
            print('人类会工作')
    
        def tools(self):
            print('人类会使用工具')
    
    obj = Human('barry','男',18,'运动')
    obj.work()
    obj.tools()

    类中的方法一般都是通过对象执行的(除去类方法,静态方法外)并且对象执行这些方法都回自动将对象空间传给方法中的第一个参数self

    self是什么?

    self其实就是类中方法(函数)的第一个位置参数,只不过解释器自动调用这个函数对象传递给了self,所以咱们把类中的方法的第一个参数约定俗成设置成self,代表这个对象

  10. 一个类可以实例化多个对象
    obj1= Human('小胖','男',20,'美女')
    obj2= Human('相爷','男',18,'肥女')
    print(obj1,obj2)
    print(obj1.__dict__)
    print(obj2.__dict__)

原文地址:https://www.cnblogs.com/zhangdadayou/p/11415332.html

时间: 2024-10-06 16:38:58

Python之面向对象(一)面向对象初识的相关文章

8、python全栈之路-初识面向对象

八.初识面向对象 http://www.cnblogs.com/Eva-J/articles/7293890.html#_label1 1.楔子 #面向对象编程 #面向对象的思想 #对象就是一个实实在在的,可以准确描述出来的实体,比如说egg,alex #面向对象的编程是一种上帝视角的切换 #之前你使用的面向过程的编程是面向结果去编程,一个流水线下来有固定的结果 #好想  可扩展性差 容易引起代码的安全问题 #面向对象 #类:具有相同属性和方法的一类事物 #对象:具有具体的属性的事物 2.初识类

Python 2019/7/24 面向对象概念 类和对象 对象初始化__init__ 绑定与非绑定

面向对象 (Object Oriented Programming,简称OOP) 1.什么是面向对象:面向对象编程是一种思想,它指导程序员如何编写出更好的程序.它的核心是对象,此时程序员从操作者变成了指挥者. 2.为什么使用面向对象编程:当今时代背景下,通常应用程序对扩展性和维护性要求都是非常高的,为什么?想想qq,微信,是不是不断的在添加新功能?,也就是说一款应用程序诞生后,都需要不断的更新维护. 3.面向对象优缺点: 优点:拓展性  灵活性 重用性     缺点: 程序的复杂度提高了   无

Python学习系列之面向对象

概述 一.Python编程方式 面向过程编程:根据业务逻辑从上到下磊代码 面向函数编程:将某功能代码封装到函数中,将来直接调用即可,无需重新写 面向对象编程:对函数进行分类.封装 二.面向过程编程 while True: if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 三.面向函数编程

【python】对象和面向对象

类的定义 python支持多重继承,在类名后面的小括号中,可以列出多个类名,以逗号分割. __init__方法在类的实例创建后被立即调用,注意与c++中构造函数不一样,因为对象在调用__init__时已经被构造出来,__init__方法不返回值,__init__方法不是必须要定义的. 每个类方法的第一个参数,包括__init__,都是指向类的当前实例的引用.按照习惯这个参数被称为self.在__init__方法中,self指向新创建的对象,在其他的类方法中,它指向方法被调用的类的实例.尽管当定义

python笔记 - day7-1 之面向对象编程

python笔记 - day7-1 之面向对象编程 什么时候用面向对象: 多个函数的参数相同: 当某一些函数具有相同参数时,可以使用面向对象的方式,将参数值一次性的封装到对象,以后去对象中取值即可: sele是什么? self是一个python自动会给传值得参数: 哪个对象执行方法,self就是哪个对象: 构造方法: 类中有一个特殊的方法,__init__,类()自动执行: 面向对象,三大特性: 封装,继承,多态:  

python学习笔记12-python面向对象

python学习笔记12-python面向对象 python一切皆对象 一.基本概念 1.面向对象和面向过程 面向对象编程:C++,Java,Python 面向过程编程:函数式编程,C程序等 2.类和对象 类:是对事物的抽象,比如:人类,球类 对象:是类的一个实例,比如:足球,篮球,对象就是对类的实例化 属性:五官,眼,鼻子,理解为一个变量,静态属性 方法:对人来说,吃穿住行,理解为一个函数,动态方法 实例说明:球类可以对球的特征和行为进行抽象,然后可以实例化一个真实的球实体出来 3.为什么要使

Python之面向对象:面向对象基础

一.面向过程.面向对象对比 1.面向过程 根据业务逻辑从上到下写垒代码 2.函数式思想 将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 3.面向对象 对函数进行分类和封装 1.2.3一步一步抽象,函数式是走向面向对象的中间步骤 函数式的应用场景 --> 各个函数之间是独立且无共用的数据 面向对象编程的应用场景:各个函数公用一组数据 4.基于并发的编程 Erlang语言提出的并发, 单进程.单线程 多进程.多线程的编程方式 5.一般在Python开发中,全部使用面向对象 或 面向对象

python 模块和包 &nbsp; 面向对象

1.模块 何时使用模块: 1.代码越来越多的时候,放入一个py文件中,无法维护 拆分放入多个py文件,好处: 同一个名字的变量名互不影响 a.py                b.py x=5                 x='abc' def f1(x):             def f2(x): print(x)               print(x) 2.引入模块及第三方模块 如如引用第三方模块,import math math.cos /sin   math.ceil /

Python, Java, C++, Perl 面向对象思想比较

面对对象语言的设计哲学通常分为以下两种. 第一种思路是基类的作者定下一系列的规则,规定使用该基类的人(派生类的作者)可以干什么事,不能干什么事. C++,和 Java 就是这一阵营的主要代表.比如说,C++中类定义中的 public, protected, private, virtual 等关键字就是 所谓的规则,规定了类的用户可以使用的成员,必须继承接口,或者实现等等. 这些规则强制类的用户调用或使用基类作者所允许的成员. 这样的好处在于,当错误使用发生的时候,编译器会发出牢骚,进而阻止错误

十三、Python高级功能之面向对象编程

Python高级功能之面向对象编程(类和对象) 一.类和对象: 面向过程和面向对象的编程 面向过程的编程:函数式编程,C程序等 面向对象的编程:C++,Java,Python等 类和对象:是面向对象中的两个重要概念 类:是对事物的抽象,比如:汽车模型 对象:是类的一个实例,比如:QQ轿车.大客车 范例说明: 汽车模型可以对汽车的特征和行为进行抽象,然后可以实例话为一台真实的汽车实体出来 二.Python类定义 Python类的定义: 使用class关键字定义一个类,并且类名的首字母要大写: 当程