zoukankan      html  css  js  c++  java
  • Python学习系列之面向对象

    概述

    一、Python编程方式

    1. 面向过程编程:根据业务逻辑从上到下磊代码
    2. 面向函数编程:将某功能代码封装到函数中,将来直接调用即可,无需重新写
    3. 面向对象编程:对函数进行分类、封装

    二、面向过程编程

    while True:
        if cpu利用率 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
     
        if 硬盘使用空间 > 90%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接
     
        if 内存占用 > 80%:
            #发送邮件提醒
            连接邮箱服务器
            发送邮件
            关闭连接

    三、面向函数编程

    def 发送邮件(内容)
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
     
    while True: 
        if cpu利用率 > 90%:
            发送邮件('CPU报警')
     
        if 硬盘使用空间 > 90%:
            发送邮件('硬盘报警')
     
        if 内存占用 > 80%:
            发送邮件('内存报警') 

    面向对象简单应用

    一、面向对象概述

    面向对象是一种编程方式,此编程方式落地需要"类"和"对象",面向对象其实就是对类和对象的操作

    二、创建一个类

    ##############创建类
    class Foo:
         
        def Bar(self):
            print('Bar')
     
        def Hello(self, name):
            print('i am %s' %name)
     
    ##############实例化
    obj = Foo()
    obj.Bar()                #执行Bar方法
    obj.Hello('wupeiqi')     #执行Hello方法

    三、面向对象的self详解

    self是一个形式参数,当执行obj1 = Foo('alex',19)时,self等于obj1 

                              当执行obj2 = Foo('eric',20)时,self等于obj2

    如图self=obj

    面向对象三大特征 

    一、面向对象之封装

    概述:

    封装就是将内容封装到某个地方,以后再去调用被封装的内容 

    简单的实例

    ###############代码
    class Foo:
        def __init__(self, name, age): #称之为构造方法,根据类创建对象时自动执行
            self.Name = name
            self.Age = age
        def info(self):
            print("""
                My name is: %s
                My age is: %d
            """ % (self.Name, self.Age))
    ansheng = Foo("alex", 18)  #将alex和18封装到name和age属性中
    ansheng.info()
    xiaoming = Foo("eric", 30) #将eric和30封装到name和age属性中
    xiaoming.info()
    
    ###############结果
    My name is: Ansheng
    My age is: 18
            
    My name is: xiaoming
    My age is: 30
            

    二、面向对象之继承

    概述:

    继承就是子可以继承父的内容,所以对于继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不需要一一实现每个方法

    简单的实例

    创建一个'人'信息的类,比如人都有四肢、头发、眼睛、耳朵,所以把这个写到一个类里;在创建一个中国人和外国人的类,中国人的语言是中文,皮肤是黄色;外国人的语言是英文,皮肤是黑色

    #######################代码
    class People:
        def __init__(self):
            print("""
            你的通用特征有:四肢、头发、眼、耳朵
            """)
    class China(People):
        def info(self):
            print("""
            你是中国人,你的语言是中文,皮肤是黄色
            """)
    class Us(People):
        def info(self):
            print("""
            你是美国人,你的语言是英文,皮肤是黑色
            """)
    c = China()
    c.info()
    m = Us()
    m.info()
    
    ########################结果
    你的通用特征有:四肢、头发、眼、耳朵       
    你是中国人,你的语言是中文,皮肤是黄色
            
    你的通用特征有:四肢、头发、眼、耳朵
    你是美国人,你的语言是英文,皮肤是黑色

    父类or子类

    基类or派生类

    1.派生类可以使用基类中的所有方法

    2.如果派生类和基类同时存在,优先找派生类

    继承中的多继承查找顺序

    顶类两个类没有父类的情况下

    顶类两个类有父类的情况下

    类的成员

    一、类的成员分类

    二、字段

    普通字段:属于对象,通过对象调用

    静态字段:属于类通过类调用

    ################代码:
    class Province:
        country = "中国"        #静态字段,作用就是把相同的字段 都写到这里,节省内存,通过类获取属性. 在代码加载时就已经创建了
        def __init__(self,name):
            self.name  = name  #普通字段
    
    
    
    hn = Province('河南')          #通过类创建对象
    print(hn.name)                 #调用普通字段
    print(Province.country)        #调用静态字段
    ################结果:
    河南
    中国

    三、方法

    普通方法:由对象调用,至少需要一个self参数

    静态方法:由类调用,无默认参数

      作用:如果只想写一个普通的函数的话,需要静态方法

    类方法:由类调用,至少需要一个cls参数

      作用:获取类名称

    ############################## 代码:
    class Province:
        def __init__(self,name):
            self.name  = name
        def show(self):  #普通方法,由对象调用执行
            print('普通方法')
        @staticmethod
        def f1(arg):     #静态方法,通过类调用执行.作用是:如果只想写一个普通的函数的话,就写静态方法,不需要self(这个就相当于普通函数)
            print(arg)
        @classmethod
        def f2(cls):     #类方法,通过类调用执行.作用是:能获取类名
            print(cls)
    
    
    
    
    hn = Province('河南')    #通过类创建对象
    hn.show()               #调用普通方法
    Province.f1('静态方法')  #调用静态方法
    Province.f2()           #调用类方法
    ########################## #####结果:
    普通方法
    静态方法
    <class '__main__.Province'>

    类的成员修饰符

    一、概述:

    对于每个类的成员都有两种

    • 公有成员:在任何地方都能访问
    • 私有成员:只有在类的内部能访问

    二、定义和调用私有静态字段

    ##########################################代码
    class Foo:
       
        __ClassMembers = "私有的"  # 私有的静态字段
        def Members(self):                # 通过类中的方法调用私有的静态字段进行输出
            print(Foo.__ClassMembers)
    
    obj = Foo()       # 创建一个对象
    obj.Members()     # 执行类中的Members方法
    ##########################################结果
    私有的

    三、定义和调用私有普通字段

    ###################################代码
    class Foo:
       
        def __init__(self, url):  #类的构造方法 
            self.__Blog = url     #私有普通字段
            print(self.__Blog)    #直接在狗仔方法没输出传入的URL
    
    obj = Foo("www.baidu.com")    #创建一个对象,传入一个值
    ###################################结果
    www.baidu.com
  • 相关阅读:
    NYOJ458
    NYOJ67
    NYOJ105
    NYOJ1071
    NYOJ463
    C语言练字用小软件 — Practise_Calligraphy_1.0(ANSI)
    NYOJ276
    NYOJ455
    NYOJ74
    Jzoj4458 密钥破解——Pollard-rho
  • 原文地址:https://www.cnblogs.com/chadiandianwenrou/p/6075887.html
Copyright © 2011-2022 走看看