精华内容
下载资源
问答
  • 1 类中的方法第一个参数为self,它表示当前的类的对象 1 类的属性和对象属性   类中用两个下划线开始的标识 私有属性或方法  1)类属性,在类中直接声明的变量,变量可以直接用类名称调用 Student.cName  2...

    1 类中的方法第一个参数为self,它表示当前的类的对象

    1 类的属性和对象属性 

       类中用两个下划线开始的标识 私有属性或方法

      1)类属性,在类中直接声明的变量,变量可以直接用类名称调用 Student.cName

      2)self开头的变量属于对象属性或实例属性,变量属于实例所有

      

    2 @property ,@birth.setter @staticmethod @classmethod 

     3 __dict__  

       用对象调用则返回 对象的字典属性 

       用类直接调用,返回类的字典属性列表

     

     

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    import sys
    '''
    @property 可以将python定义的函数“当做”属性访问,从而提供更加友好访问方式,
                         但是有时候setter/getter也是需要的,访问的时候直接用对象.方法名称直接调用
    @birth.setter 设置属性的setter方法
    @staticmethod 定义类中的静态方法,可以直接用类名.方法名 调用 
    @classmethod 类方法注解定义,此方法第一个参数是类名称
    
    '''
    class Student(object):
        
       
        @property
        def birth(self):
            return self._birth
    
        @birth.setter
        def birth(self, value):
            self._birth = value
    
        @property
        def age(self):
            
            hasattr(self, "_birth")#判断对象是否有某个属性
            getattr(self, "_birth")#获取属性的值
            setattr(self,'name','wang')# 设置属性的值
            print(getattr(self, "name") ) #
            
            return 2014 - self._birth
        
       
        @staticmethod
        def f1( ):
    #         print(__dict__)
            print('2222222')
            
        @classmethod
        def f2(cls,a):
            print(cls)
            print( a )
    
        
    if __name__ == '__main__':
           
        s = Student();
        s.birth=2015
    #     print(s.age)
    #     print(sys.path)
    #     print(sys.modules)
        Student.f1()
        Student.f2('1111111')
        
        print(sys.modules)
        Student.birth 
        
        Student.cName
        #__dict__是对象属性的字典
        print(s.__dict__ )
        #类 字典属性 列表 
        print(Student.__dict__ )
        
    
    

     

     

    展开全文
  • python--super关键字

    2019-04-01 01:41:28
    在pytorch库中nn.Module模块,声明继承Model是有提示可以按照这样书写 class Model(nn.Module): def __init__(self): super(Model,self).__init__() 其中super是作用是继承时候,调用含有super各个基类...

    在pytorch库中nn.Module模块,声明继承Model类是有提示可以按照这样书写

    class Model(nn.Module):
    
        def __init__(self):
            super(Model,self).__init__()

    其中super类是作用是继承的时候,调用含有super各个基类的__init__函数,如果不使用super,就不会调用__init__函数,使用super可以避免基类被重复调用。

    使用print(Model.__mro__)打印搜索顺序或者祖先树

    super的典型用法:

    在具有单一继承结果的类层级中,super可以指代父类而不需要显示声明,这样对更改父类有帮助的。

    class A():
        def fortest(self):
            print('Call class A')
            print('Leave class A')
    class B(A):
        def fortest(self):
            print('Call class B')
            A.fortest(self)
            print('Leave class B')
    sample=B()
    sample.fortest()
    print(B.__mro__)
    运行的结果:
    Call class B
    Call class A
    Leave class A
    Leave class B
    (<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

    如果需要修改B的基类A为D,那么不仅需要修改声明Class B(D),函数体中的函数也需要进行修改,如果调用A的地方多,修改起来会比较麻烦,加上super则会简单很多

    class A():
        def fortest(self):
            print('Call class A')
            print('Leave class A')
    class B(A):
        def fortest(self):
            print('Call class B')
            super(B,self).fortest()#等同于super().fortest()
            print('Leave class B')
    sample=B()
    sample.fortest()
    print(B.__mro__)
    运行的结果:
    Call class B
    Call class A
    Leave class A
    Leave class B
    (<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

    加上super后,修改基类只需要修改声明,不需要修改函数体内的东西,所以super可以代替父类而不需要显示的声明,这对更改基类是有帮助的,使得代码更加容易维护。

    class A():
        def __init__(self):
            print('Call class A')
            print('Leave class A')
    class B(A):
        def __init__(self):
            print('Call class B')
            print('Leave class B')
    class C(A):
        def __init__(self):
            print('Call class C')
            super(C,self).__init__()
            print('Leave class C')
    class D(A):
        def __init__(self):
            print('Call class D')
            super(D, self).__init__()
            print('Leave class D')
    class E(B,C):
        def __init__(self):
            print('Call class E')
            B.__init__(self)
            C.__init__(self)
            print('Leave class E')
    sample=E()
    print(E.__mro__)
    运行的结果:
    Call class E
    Call class B
    Leave class B
    Call class C
    Call class A
    Leave class A
    Leave class C
    Leave class E
    (<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
    

    B和C类都继承的A,但是由于B没有使用super,这里调用B的时候没有调用A,只有C自动调用了A

    class A():
        def __init__(self):
            print('Call class A')
            print('Leave class A')
    class B(A):
        def __init__(self):
            print('Call class B')
            print('Leave class B')
    class C(A):
        def __init__(self):
            print('Call class C')
            super(C,self).__init__()
            print('Leave class C')
    class D(A):
        def __init__(self):
            print('Call class D')
            super(D, self).__init__()
            print('Leave class D')
    class E(B,C,D):
        def __init__(self):
            print('Call class E')
            B.__init__()
            C.__init__()
            D.__init__()
            print('Leave class E')
    sample=E()
    print(E.__mro__)
    运行的结果:
    Call class E
    Call class B
    Leave class B
    Call class C
    Call class D
    Call class A
    Leave class A
    Leave class D
    Leave class C
    Call class D
    Call class A
    Leave class A
    Leave class D
    Leave class E
    (<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>)
    

    这里的A和D都重复调用了一次,尤其是调用C的时候,也调用了D

    class A():
        def __init__(self):
            print('Call class A')
            super(A, self).__init__()
            print('Leave class A')
    class B(A):
        def __init__(self):
            print('Call class B')
            super(B,self).__init__()
            print('Leave class B')
    class C(A):
        def __init__(self):
            print('Call class C')
            super(C,self).__init__()
            print('Leave class C')
    class D(A):
        def __init__(self):
            print('Call class D')
            super(D, self).__init__()
            print('Leave class D')
    class E(B,C,D):
        def __init__(self):
            print('Call class E')
            super(E, self).__init__()
            print('Leave class E')
    sample=E()
    print(E.__mro__)
    运行结果是:
    Call class E
    Call class B
    Call class C
    Call class D
    Call class A
    Leave class A
    Leave class D
    Leave class C
    Leave class B
    Leave class E
    (<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>)
    

    都加super以后每个基类都只调用一次,且是从左到右依次调用。

    -----------------------------------------------------------------------------------

    加super是对父类函数进行调用,但是传入参数是子类的,相当于重写了,如果没有传参那么就是直接调用父类函数。

    class animal(object):
    
        def __init__(self,name):
            self.name = name 
        def greet(self):
            print("hello i am %s"%self.name)
    
    class dog(animal):
        def greet(self):
            # super(dog,self).greet() 效果等价
            animal.greet(self)
            print("wang wang...")
    
    ani = animal('sb')
    ani.greet()
    d = dog('sb2')
    d.greet()
    
    hello i am sb
    hello i am sb2
    wang wang...

    参考:

    https://blog.csdn.net/shiheyingzhe/article/details/83051471

    https://www.cnblogs.com/kex1n/p/5983237.html

     

    展开全文
  • 本章简要介绍了各种...while: while-loop 关键字,后跟循环条件 as: 通常和import叠加使用,代表以某个其他名称加载某个模块。 elif: if分支控制一部分。 global: 声明一个变量为全局变量。 or:[布尔运算]...

    本章简要的介绍了各种关键词:

    and:[布尔运算]且

    del: 删除变量(函数,类)

    from: 从某一个库或者文件读取

    not:[布尔运算]非

    while: while-loop 关键字,后跟循环条件

    as: 通常和import类叠加使用,代表以某个其他名称加载某个模块。

    elif: if分支控制的一部分。

    global: 声明一个变量为全局变量。

    or:[布尔运算]或

    with:执行一个动作,通常和as一起使用,使用with后,完成动作后,必定关闭或者退出。

    assert: 声明一个错误。使用方法,assert 后跟布尔运算。

    else:if分支控制的一部分,代表其他条件不成立时的状况。

    if: if控制分支

    pass:啥都不干,通常就是占座使用。

    yield: 迭代器生成器,我这里也不明白。回头有空填坑。

    break:停止循环的一种方法,在while,for循环中使用。

    except:try调试方法的一个异常捕获的方法。

    import: 引入module.

    print:输出

    class:声明一个类

    exec:把后面的内容重新执行,exec("print 'hello world'"),可以作为命令重构。例如把获取的变量作为变量等。

    in:检查一个元素是否在一个列表,元组,字典也可以,如果检查的是字典的话,通常检查的是key。

    raise:抛出一个自定义的异常。

    continue:继续循环,而不进行后续步骤。

    finally: try调试时的最终执行。

    is: 判断俩个对象是否一致的ID.

    return:通常用于函数体内的返回,可以通过赋值捕获。

    def:定义一个函数。

    for: for-loop

    lambda:是一个表达式的书写方法,他的主体是一个表达式。

    try:尝试。

    转载于:https://www.cnblogs.com/sageskr/p/4083947.html

    展开全文
  • 【判断题】用美蓝对酵母活细胞进行染色时,由于细胞新陈代谢作用,细胞内具有较强还原能力,能使美蓝由蓝色氧化型变为无色还原型。【多选题】侵权行为类型主要有哪几种?【判断题】皮肤是人体最重要散热气管...

    【判断题】在热环境下锻炼,空气中的高湿度较温度更易对人体产生危害。

    【单选题】酵母菌死活细胞的判定中,美蓝的浓度不易过高,一般以()浓度为宜。

    【判断题】用美蓝对酵母的活细胞进行染色时,由于细胞的新陈代谢作用,细胞内具有较强的还原能力,能使美蓝由蓝色的氧化型变为无色的还原型。

    【多选题】侵权行为类型主要有哪几种?

    【判断题】皮肤是人体最重要的散热气管。

    【多选题】以下哪些行为会受到知识产权的处罚

    【判断题】社会健康水平低对人的身心健康会产生消极的影响。

    【判断题】在热环境中检测身体所受影响最好的方法是测心率。

    【简答题】教科书的作用是什么?

    【判断题】美蓝是一种有毒的弱氧化剂染料。

    【单选题】买家提出纠纷后,卖家需在 ____ 天之内响应。

    【判断题】海拔高度越高,人的最大吸氧量和锻炼的耐久力下降越明显。

    【判断题】根据实验显示:人体的头部散热与气温成反比。

    【判断题】冬季人体锻炼时,身体周围的空气流速与身体热量散发成正比。

    【判断题】心理放松时,骨骼肌也会自然放松。

    【判断题】在冷环境中进行体育锻炼,主要用嘴呼吸。

    【单选题】a=0x12 print(a) 结果:

    【判断题】力量练习可防止钙的丢失以及推迟骨质疏松症的发生。

    【单选题】卖家 H 与 2015 年 9 月 2 日因知识产权违规 , 被扣除 2 分 . 那么这个 2 分何时会被清零。

    【判断题】人体新陈代谢过程中,机体内的各种生物化学反应都需要在酶的催化下进行。

    【判断题】除了晚上睡民外,白天午休15-30分钟也是减少应激的一种有效疗法。

    【判断题】钙的缺乏将导致骨质疏松。

    【判断题】长跑可以培养人的意志品质。

    【判断题】身体运动时呼吸频率加快,以摄入更多的氧和呼出更多的二氧化碳。

    【判断题】可以利用酵母菌死活细胞的鉴定原理,检测啤酒发酵过程中酵母菌的活菌率。

    【判断题】短期处在中等海拔地区,减少体育锻炼持续时间或频率是没有必要的。

    【判断题】食品中最易引起高血压的营养元素是糖 。

    【判断题】盖盖玻片时,应用镊子取一块盖玻片,先将一边与菌液接触,然后慢慢将盖玻片放下;避免产生气泡。

    【判断题】心理紧张并不会导致骨骼肌紧张。

    【多选题】广告活动研究有

    【判断题】企业接受投资者作价投入的房屋、建筑物、机器设备等固定资产,应按投资合同或协议约定的价值确定固定资产价值。

    【判断题】对违规卖家的处罚将采取警告、冻结账户以及关闭账户的惩罚,同时违规行为将会被记录到卖家档案。

    【填空题】类的成员函数必须有一个参数(),而且位于参数列表的开头,它就代表类的实例对象自身。

    【单选题】卖家 F 店铺因为严重违规,被扣除 48 分,会受到哪种处罚?

    【单选题】酵母菌死活细胞的判定,可以通过( )染色完成。

    【判断题】销售未经授权的产品或者拷贝他人产品的图片及描述内容都是不允许的

    【判断题】无氧运动可以较好的降低全身脂肪比例。

    【判断题】随着海拔高度的升高,锻炼者从大气中获得的氧气量不会减少。

    【判断题】单纯的节食或禁食只是使脂肪组织丢失。

    【判断题】单纯的节食或禁食会丢失许多脂肪组织和相当的肌肉组织。

    【判断题】平衡膳食是指膳食中的营养素能满足人体的需要,既不缺乏,又不过剩。

    【判断题】将制好地水浸片放置3min后镜检的目的是给活细胞还原美兰创造时间。

    【判断题】运动处方中的每次锻炼都应包括以下三个主要组成部分:准备活动、锻炼模式和整理活动。

    【判断题】肌肉力量和肌肉的生理横截面积没有关系。

    【判断题】在高海拔地区进行体育锻炼,不应该减小运动强度。

    【判断题】任何会计核算程序的第一步必须将所有的原始凭证都汇总编制为汇总原始凭证。

    【填空题】在Python中可以使用()关键字来声明一个类。

    【判断题】测量心率被认为是确定运动强度的标准方法之一。

    【多选题】广告学与传播学不同之处

    【判断题】只要坚持体育锻炼就能达到理想的体重和体脂比例。

    展开全文
  • RobotFramework 之 Python扩展关键字Python函数作为关键字Python类作为测试库使用Python类里的函数Python扩展库的搜索规则声明导包Python库中的class类的初始化类的继承 Python函数作为关键字 前面简要了解了RF中可...
  • python编程关键字

    2016-04-21 17:45:00
    (带有操作含义的关键字) for:循环 in:成员比较运算符 if :如果分支 elif:如果分支 else:其他分支 while:循环 def:定义函数 class:定义 global:全局变量声明 from :导入包 import:导入包...
  • False: 布尔类型值,表示假,与True想反 None : None比较特殊,表示什么也没有,他有自己数据类型 -NoneType True: 布尔类型值,表示真,与...用于定义 continue: 跳出本次循环,继续执行下一次循环 def:
  • python变量总结: 全局变量、局部变量、变量、实例变量以及global和nonlocal关键字的使用示例 前言:Python也同多数编程语言一样,也有全局变量与局部变量概念, 但是与其他编程语言又有所不同: 全局变量与局部...
  • 定义类 在Python中,类的定义使用class关键字来实现 语法如下: class className: "类的注释" 类的实体 (当没有实体时 使用pass代替) 下面定义一个鸟类; class flyBord: """鸟类""" pass #这里我们并...
  • Python的类

    2020-02-27 20:58:15
    1、嵌套函数定义: def f1(): print('f1 running……') def f2(): print('f2 running……') ...2、nonlocal关键字 ...(1)nonlocal用来声明外层局部变量。 (2)global用来声明全局变量。...
  • 一、类定义:class :类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性。...在类内部的方法中使用时 self.__private_attrs类的方法在类地内部,使用def关键字可以为类定义一个方法,与...
  • 标识符是允许作为变量(函数、等)名称有效字符串。其中,有一部分是关键字(语言本身保留...Python 是动态类型语言, 也就是说不需要预先声明变量类型。 变量类型和值在赋值那一刻被初始化。变量赋值通...
  • python class

    2018-07-05 20:24:30
    python中类定义:类的声明和函数的声明形式是差不多的,开始都是关键字+自定义名称 定义实例变量:可以在定义方法的时候直接定义,也可以使用实例来定义 可以使用dir(ClassName) ClassName.__dict__来查看有哪些类...
  • nonlocal 用来声明外层局部变量 global用来声明全局变量 三、对象进化 简单数据-数组-结构体-对象 四、面向对象编程 Python支持面向过程、面向对象、函数式变成等多种编程范式。支持继承、多态、封装等。 ...
  • self不是关键字,但是python强烈推荐。当然,你也可以使用其他字母,例如a,b。 self就相当于java中或C++中this指针 self在实例化对象时会自动传入,不需要声明该参数 1. 预备知识 python的类有三个相关概念:...
  • 类的关键字是class,这在几乎所有的高级编程语言里都是一样的。在Python中,如果无明确继承的类需要在声明的类里添加object参数 class hero(object): obejct类似于一种公类。 但其实缺省也是可以的: class hero...
  • 我们在python声明类的关键词是class,类还有功能和属性,属性就是这类事物的特征,而功能就是它能做什么,也是就是方法或者函数。我们仍然用例子来说明问题。声明类用class来声明一个类,也就是创建了一个类。使用...
  • python 抽象

    千次阅读 2018-04-09 23:36:53
    python 抽象 &nbsp;&nbsp;...1.在python中并没有interface这个关键字声明这是个接口,如果非要模仿接口概念就用到了第三方模块,比如:abs模块。 2、接口就是只定义了一些方法...
  • python类定义讲解

    2020-12-24 04:43:10
    在类内部的方法中使用时 self.__private_attrs类的方法 在类地内部,使用def关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数self,且为第一个参数私有的类方法 __private_method 两个下划线...
  • Python 类的私有成员

    2019-05-05 22:20:35
    比如 C++ 或者 Java 的 private 关键字就是用来声明类的私有成员的,如果一个属性或者方法被 private 声明,那么这个成员就只能在类里面才能直接使用,这样做的目的是为了封装。和很多面向对象的语言一样,Python 也...
  • Python的类与对象

    2018-12-11 16:16:03
     1类的关键字:  从第一天第一个项目起我们就接触过关键字,比如False True is not None return for while elif else import等等,这是语言中内定的一个语法规则吧,通过关键字告诉电脑下面一个字母或一段 代码...
  • Python抽象

    2018-11-30 22:37:53
    抽象 抽象是一个特殊的类...1.在python中并没有interface这个关键字声明这是个接口,如果非要模仿接口概念就用到了第三方模块,比如:abs模块。 2.接口就是只定义了一些方法,而没有实现。【(这些方法被...
  • 广告关闭2017年12月,云+社区对外发布,从最开始的技术博客到现在拥有多个社区产品。... ③类的私有方法__private_method:两个下划线开头,声明该方法为私有方法,不能在类的外部调用。 在类的内部调用时:...
  • 类的私有属性: __private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。 在类内部的方法中使用时 self.__private_attrs。 1 2 类的方法: 在类地内部,使用def关键字可以为类...
  • 因为python2不支持中文字符集,所以需要声明,而python3则不需要 注释分类:单行注释和多行注释 以 "#" 和 """"""来实现 #我是注释,可以在此写一些关于以下代码说明 print("helloworld") """ 这个是 ...
  •  1类的关键字:  从第一天第一个项目起我们就接触过关键字,比如False True is not None return for while elif else import等等,这是语言中内定的一个语法规则吧,通过关键字告诉电脑下面一个字母或一段 代码...
  • python的类

    千次阅读 2013-06-25 11:16:06
    类的私有属性: __private_attrs 两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问 在类内部的方法中使用时 self.__private_attrs 类的方法 在类地内部,使用def关键字可以为类定义一个方法...
  • self并不是python的关键字,这是一种约定俗成的写法 self在声明的时候,它一定要声明在参数列表中第一个位置 注意:self在声明的时候必须要声明,传参的时候我们无需传递,使用 对象来调用函数的时候,它会自动将...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 230
精华内容 92
关键字:

python声明类的关键字

python 订阅