精华内容
下载资源
问答
  • python class

    千次阅读 2011-01-27 20:58:00
    python class

    Python 的 Class 比较特别,和我们习惯的静态语言类型定义有很大区别。

    1. 使用一个名为 __init__ 的方法来完成初始化。
    2. 使用一个名为 __del__ 的方法来完成类似析购操作。
    3. 所有的实例方法都拥有一个 self 参数来传递当前实例,类似于 this。
    4. 可以使用 __class__ 来访问类型成员。

    >>> class Class1:
    def __init__(self):
    print "initialize..."
    def test(self):
    print id(self)

    >>> a = Class1()
    initialize...
    >>> a.test()
    13860176
    >>> id(a)
    13860176


    Class 有一些特殊的属性,便于我们获得一些额外的信息。

    >>> class Class1(object):
    """Class1 Doc."""
    def __init__(self):
    self.i = 1234


    >>> Class1.__doc__ # 类型帮助信息
    'Class1 Doc.'
    >>> Class1.__name__ # 类型名称
    'Class1'
    >>> Class1.__module__ # 类型所在模块
    '__main__'
    >>> Class1.__bases__ # 类型所继承的基类
    (<type 'object'>,)
    >>> Class1.__dict__ # 类型字典,存储所有类型成员信息。
    <dictproxy object at 0x00D3AD70>
    >>> Class1().__class__ # 类型
    <class '__main__.Class1'>
    >>> Class1().__module__ # 实例类型所在模块
    '__main__'
    >>> Class1().__dict__ # 对象字典,存储所有实例成员信息。
    {'i': 1234}


    继承

    Python 支持多继承,但有几点需要注意:

    1. 基类 __init__ / __del__ 需显示调用。
    2. 继承方法的调用和基类声明顺序有关。

    >>> class Base1:
    def __init__(self):
    print "Base1"

    def test(self):
    print "Base1 test..."

    >>> class Base2:
    def __init__(self):
    print "Base2"

    def test(self):
    print "Base2 test..."

    >>> class Class1(Base2, Base1):
    def __init__(self):
    Base1.__init__(self)
    Base2.__init__(self)
    print "Class1"

    >>> a = Class1()
    Base1
    Base2
    Class1
    >>> a.test()
    Base2 test...


    成员

    Python Class 同样包含类型和实例两种成员。

    >>> class Class1:
    i = 123 # Class Field
    def __init__(self):
    self.i = 12345 # Instance Field

    >>> print Class1.i
    123
    >>> print Class1().i
    12345


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

    有几个很 "特殊" 的 "规则" 需要注意。

    (1) 我们可以通过实例引用访问类型成员。因此下面的例子中 self.i 实际指向 Class1.i,直到我们为实例新增了一个成员 i。

    >>> class Class1:
    i = 123
    def __init__(self):
    print self.i
    print hex(id(self.i))


    >>> hex(id(Class1.i)) # 显示 Class1.i
    '0xab57a0'
    >>> a = Class1() # 创建 Class1 实例,我们会发现 self.i 实际指向 Class1.i。
    123
    0xab57a0
    >>> Class1.__dict__ # 显示 Class1 成员
    {'i': 123, '__module__': '__main__', '__doc__': None, '__init__': <function __init__ at 0x00D39470>}
    >>> a.__dict__ # 显示实例成员
    {}
    >>> a.i = 123456789 # 为实例新增一个成员 i
    >>> hex(id(a.i)) # 显示新增实例成员地址
    '0xbbb674'
    >>> a.__dict__ # 显示实例成员
    {'i': 123456789}


    (2) 调用类型内部方法,需要省略 self 参数。

    >>> class Class1:
    def __init__(self):
    self.__test("Hello, World!")
    def __test(self, s):
    print s


    >>> Class1()
    Hello, World!
    <__main__.Class1 instance at 0x00D37B48>


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

    我们可以在成员名称前添加 "__" 使其成为私有成员。

    >>> class Class1:
    __i = 123
    def __init__(self):
    self.__x = 0
    def __test(self):
    print id(self)

    >>> Class1.i
    Traceback (most recent call last):
    File "<pyshell#102>", line 1, in <module>
    Class1.i
    AttributeError: class Class1 has no attribute 'i'

    >>> Class1().__x
    Traceback (most recent call last):
    File "<pyshell#103>", line 1, in <module>
    Class1().__x
    AttributeError: Class1 instance has no attribute '__x'

    >>> Class1().test()
    Traceback (most recent call last):
    File "<pyshell#104>", line 1, in <module>
    Class1().test()
    AttributeError: Class1 instance has no attribute 'test'


    事实上这只是一种规则,并不是编译器上的限制。我们依然可以用特殊的语法来访问私有成员。

    >>> Class1._Class1__i
    123
    >>> a = Class1()
    >>> a._Class1__x
    0
    >>> a._Class1__test()
    13860376


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

    除了静态(类型)字段,我们还可以定义静态方法。

    >>> class Class1:
    @staticmethod
    def test():
    print "static method"

    >>> Class1.test()
    static method


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

    从设计的角度,或许更希望用属性(property)来代替字段(field)。

    >>> class Class1:
    def __init__(self):
    self.__i = 1234
    def getI(self): return self.__i
    def setI(self, value): self.__i = value
    def delI(self): del self.__i
    I = property(getI, setI, delI, "Property I")

    >>> a = Class1()
    >>> a.I
    1234
    >>> a.I = 123456
    >>> a.I
    123456


    如果只是 readonly property,还可以用另外一种方式。

    >>> class Class1:
    def __init__(self):
    self.__i = 1234
    @property
    def I(self):
    return self.__i

    >>> a = Class1()
    >>> a.I
    1234


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

    用 __getitem__ 和 __setitem__ 可以实现 C# 索引器的功能。

    >>> class Class1:
    def __init__(self):
    self.__x = ["a", "b", "c"]
    def __getitem__(self, key):
    return self.__x[key]
    def __setitem__(self, key, value):
    self.__x[key] = value


    >>> a = Class1()
    >>> a[1]
    'b'
    >>> a[1] = "xxxx"
    >>> a[1]
    'xxxx'


    重载

    Python 支持一些特殊方法和运算符重载。

    >>> class Class1:
    def __init__(self):
    self.i = 0
    def __str__(self):
    return "id=%i" % id(self)
    def __add__(self, other):
    return self.i + other.i

    >>> a = Class1()
    >>> a.i = 10
    >>> str(a)
    'id=13876120'
    >>> b = Class1()
    >>> b.i = 20
    >>> a + b
    30


    通过重载 "__eq__",我们可以改变 "==" 运算符的行为。

    >>> class Class1:
    pass

    >>> a = Class1()
    >>> b = Class1()
    >>> a == b
    False

    >>> class Class1:
    def __eq__(self, x):
    return True

    >>> a = Class1()
    >>> b = Class1()
    >>> a == b
    True


    Open Class

    这是个有争议的话题。在 Python 中,我们随时可以给类型或对象添加新的成员。

    1. 添加字段

    >>> class Class1:
    pass

    >>> a = Class1()
    >>> a.x = 10
    >>> a.x
    10
    >>> dir(a)
    ['__doc__', '__module__', 'x']
    >>> b = Class1()
    >>> dir(b)
    ['__doc__', '__module__']
    >>> del a.x
    >>> dir(a)
    ['__doc__', '__module__']


    2. 添加方法

    >>> class Class1:
    pass

    >>> def test():
    print "test"

    >>> def hello(self):
    print "hello ", id(self)

    >>> a = Class1()
    >>> dir(a)
    ['__doc__', '__module__']
    >>> Class1.test = test
    >>> dir(a)
    ['__doc__', '__module__', 'test']
    >>> b = Class1()
    >>> dir(b)
    ['__doc__', '__module__', 'test']
    >>> a.hello = hello
    >>> a.hello(a)
    hello 13860416
    >>> dir(a)
    ['__doc__', '__module__', 'hello', 'test']
    >>> dir(b)
    ['__doc__', '__module__', 'test']


    3. 改变现有方法

    >>> class Class1:
    def test(self):
    print "a"

    >>> def test(self):
    print "b"

    >>> Class1.test = test
    >>> Class1().test()
    b


    另外,有几个内建函数方便我们在运行期进行操作。

    >>> hasattr(a, "x")
    False
    >>> a.x = 10
    >>> getattr(a, "x")
    10
    >>> setattr(a, "x", 1234)
    >>> a.x
    1234


    Python Open Class 是如何实现的呢?我们看一下下面的代码。

    >>> class Class1:
    pass

    >>> a = Class1()
    >>> a.__dict__
    {}
    >>> a.x = 123
    >>> a.__dict__
    {'x': 123}
    >>> a.x
    123
    >>> a.test = lambda i: i + 1
    >>> a.test(1)
    2
    >>> a.__dict__
    {'test': <function <lambda> at 0x00D39DB0>, 'x': 123}


    原来,Python Class 对象或类型通过内置成员 __dict__ 来存储成员信息。

    我们还可以通过重载 __getattr__ 和 __setattr__ 来拦截对成员的访问,需要注意的是 __getattr__ 只有在访问不存在的成员时才会被调用。

    >>> class Class1:
    def __getattr__(self, name):
    print "__getattr__"
    return None
    def __setattr__(self, name, value):
    print "__setattr__"
    self.__dict__[name] = value


    >>> a = Class1()
    >>> a.x
    __getattr__
    >>> a.x = 123
    __setattr__
    >>> a.x
    123


    如果类型继承自 object,我们可以使用 __getattribute__ 来拦截所有(包括不存在的成员)的获取操作。
    注意在 __getattribute__ 中不要使用 "return self.__dict__[name]" 来返回结果,因为在访问 "self.__dict__" 时同样会被 __getattribute__ 拦截,从而造成无限递归形成死循环。

    >>> class Class1(object):
    def __getattribute__(self, name):
    print "__getattribute__"
    return object.__getattribute__(self, name)


    >>> a = Class1()
    >>> a.x
    __getattribute__

    Traceback (most recent call last):
    File "<pyshell#3>", line 1, in <module>
    a.x
    File "<pyshell#1>", line 4, in __getattribute__
    return object.__getattribute__(self, name)
    AttributeError: 'Class1' object has no attribute 'x'
    >>> a.x = 123
    >>> a.x
    __getattribute__
    123
    展开全文
  • python class 一点总结

    千次阅读 2017-04-13 14:00:12
    Python class 总结细数class中的 __**__ __init__(self, *values) 对象的初始化函数,初始化类的实例时,会调用这个方法 __str__(self) 返回 print对象时要打印的东西,pirnt(obj)时会调用这个方法 __iter__(self) 与...

    Python class 总结

    细数class中的 __**__

    • __init__(self, *values)
      对象的初始化函数,初始化类的实例时,会调用这个方法
    • __str__(self)
      返回 print对象时要打印的东西,pirnt(obj)时会调用这个方法
    • __iter__(self)__next__(self)
      将对象 变为可迭代对象,__iter__()用于iter(),__next__用于next()
    • __getitem__(self, key)
      使得对象可以向类表一样使用,obj[2], obj[2:4]
    • __setitem__(self, key, value)
      可以使对象的key被赋值
    obj['hello'] = 'world'
    • __getattr__(self, attr)
      如果对象没有所调用的属性的时候,就会把属性名送进这个方法,看看这个方法返回什么
    • __getattribute__(self, item)
      所有的属性访问都会经过这个接口
    class People(object):
        def __init__(self):
            self.name = "h"
    
        def __getattribute__(self, item):
            print("get->",item)
            return object.__getattribute__(self,item)
    
        def __getattr__(self, item):
            print("hello")
    
        def m(self):
            self.name = 'a'
    
    p = People()
    p.m()
    print(p.name)
    # get-> m
    # get-> name
    # a
    • __setattr__(self, name, value)
      当每次给一个属性赋值的时候,就会调用这个方法
    class People(object):
        def __init__(self):
            self.name = "h"
    
        def __setattr__(self, key, value):
            super(People, self).__setattr__(key,value)
            #self.__dict__[key] = value
            print("hello")
        def m(self):
            self.name = 'a'
    
    p = People()
    p.m()
    print(p.name)
    # hello
    # hello
    # a 
    • __call__(self, *value)
      使得类的实例可以像函数一样被调用

    • __len__(self)
      当执行len(obj)时,被调用

    • __slots__
      这个和前几个不太一样,它是个类的属性,不是方法,这个用来限制类的实例所能动态添加的属性

    细数用在class中的装饰器

    1. @property
      是一个装饰器,将一个方法当作属性调用
    2. @staticmethod
      将方法定义成静态方法,不需要传入self
    3. @classmethod
      将一个方法定义成类方法,传入cls而不是self
    4. @abstraction
      将一个方法声明成抽象方法

    参考资料

    http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143186739713011a09b63dcbd42cc87f907a778b3ac73000
    http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143186781871161bc8d6497004764b398401a401d4cce000
    http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319098638265527beb24f7840aa97de564ccc7f20f6000
    https://jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/
    http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
    https://docs.python.org/3/library/functions.html#setattr

    展开全文
  • 今天小编就为大家分享一篇对Python Class之间函数的调用关系详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧 假设有Class A 和 Class B两个类,Class A中定义了a(),Class B中定义了b(). ...

    今天小编就为大家分享一篇对Python Class之间函数的调用关系详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    假设有Class A 和 Class B两个类,Class A中定义了a(),Class B中定义了b().

    现在我想在Class B中调用 Class A中的函数a()。此处介绍三种调用方法:

    方法一:

    在Class B中所定义的fuction()中声明Class A的对象a,然后用对象a来调用Class A的函数a().

    最后在main中声明Class B的对象b,让b调用该类中的fuction()

    .#!/usr/bin/env python
    # -*- coding: utf-8 -*-
      
    class A():
     def __init__(self,parent):
     self.parent = parent
      
     def a(self):
     print 'Class A'
      
      
    class B():
     def fuction(self):
     a = A(None)
     a.a()
      
    if __name__ == '__main__':
     b = B()
     b.fuction()
    

    方法二:

    在Class B的__init__()中将Class A和Class B产生关联,具体方法如下code。

    首先在main中声明Class A的对象a,然后将对象a传入到Class B的__init__(self,object)中,这样self.object就指向Class A。

    就可以调用Class A中的函数了。

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
      
    class A():
     def __init__(self,parent):
     self.parent = parent
      
     def a(self):
     print "Class A"
      
    class B(object):
     def __init__(self,object):
     self.object = object
     self.object.a()
      
     def b(self):
     print "Class B"
      
    if __name__ == '__main__':
      
     a = A(None)
     b = B(a)
     b.b()
    

    方法三:

    直接在Class B中声明Class A的对象,该对象是Class B的self.A_object。

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
      
    class A():
      
     def a(self):
     print "Class A"
      
    class B(object):
     def __init__(self):
     self.A_object = A()
     self.A_object.a()
      
     def b(self):
     print "Class B"
      
    if __name__ == '__main__':
      
     b = B()
     b.b()
    

    以上这篇对Python Class之间函数的调用关系详解就是小编分享给大家的全部内容了,希望能给大家一个参考

    非常感谢你的阅读
    大学的时候选择了自学python,工作了发现吃了计算机基础不好的亏,学历不行这是
    没办法的事,只能后天弥补,于是在编码之外开启了自己的逆袭之路,不断的学习python核心知识,深入的研习计算机基础知识,整理好了,我放在我们的Python学习扣qun:774711191,如果你也不甘平庸,那就与我一起在编码之外,不断成长吧!
    其实这里不仅有技术,更有那些技术之外的东西,比如,如何做一个精致的程序员,而不是“屌丝”,程序员本身就是高贵的一种存在啊,难道不是吗?[点击加入]想做你自己想成为高尚人,加油!
    @本文来源于公众号:csdn2299,喜欢可以关注公众号 程序员学府

    展开全文
  • Google's Python Class  学习完了《The Python Tutorial》后,又学习了一下Google's python class,感觉比前者要好。关键是提供了一些习题,让你通过这些习题了解Python的特性,让你尽快用Python去解决一些...

    Google's Python Class


            学习完了《The Python Tutorial》后,又学习了一下Google's python class,感觉比前者要好。关键是提供了一些习题,让你通过这些习题了解Python的特性,让你尽快用Python去解决一些问题,做完这些习题,感觉比看完整本书还有感觉。这给我提了个醒,学完一个东西要主动找一些练习去做,不然看多少书都没有感觉。尤其是一些实践性很强的东西。下面是读的过程中记的一些简要的笔记。


    1 Python Introduction

    • 函数需要在使用前定义,所以main函数一般放在最后
    • 使用空格,而不是TAB来缩进,可以设置编辑器使用空格代替TAB.空格和TAB混用会带来语法错误, 尽管看起来缩进的距离是一样的。
    • 代码只有在运行时才会检查,如果你调用函数时写错了函数名,且从来没有执行到调用这个函数的地方, 那么python会运行良好,它不会像其它语言一样在编译时对代码进行检查。
    • 最好使用 import sys,然后调用sys模块时使用sys.argv,而不要使用 from sys import argv,然后调用 时使用 argv.前者会让我们一眼就看出argv来自哪里。
    • 可以使用help函数得到函数和模块的文档,例如help(len)

    2 Python String

    • String 方法:方法和函数类似,只不过方法是“运行在”对象上.
      • s.lower(),s.upper() – 大小写转换
      • s.trip() – 去掉字符串前后的空白
      • s.isalpha()/s.isdigit()/s.isspace() – 测试字符串是不是全部都是指定类型
      • s.startwith('other'), s.endwith('other') – 测试是否以指定字符串开始/结尾
      • s.find('other') – 查找子串,如果有,返回第一个下标,如果没有,返回-1
      • s.replace('old','new') – 将字符串中所有 'old' 替换为 'new'
      • s.split('delim') – 返回以'delim'分割的子串list
      • s.join(list) – 与split相反,将list中的元素以字符串s连接起来

    3 Python List

    • List赋值操作并不会创建一份新数据,例如 c是个List,b = c执行后,b 和 c 指向同一内存区域。
    • in: 可以用于判断一个元素是否在一个集合中。例如:
      • for num in squares:
      • if 'curly' in mlist:
      • if character in mstring:
    • List常用函数:
      • list.append(elem) – 在list的最后添加一个元素,注意,这会改变list,而不是返回新的list
      • list.insert(index,elem) – 在list的index处插入一个元素
      • list.extend(list2) – 将list2添加到list的最后,也可以使用+ 或+=得到同样结果
      • list.index(elem) – 搜索元素,返回下标
      • list.remove(elem) – 搜索元素,然后删除(如果不存在会返回ValueError)
      • list.sort() – 对list进行排序
      • list.pop(index) – 删除并返回指定位置的元素

    4 Python Sorting

    • sorted(list):list.sort() 只会对list排序,不会返回排序后的list. sorted(list)会返回排序后的list,而不改变list.
    • sorted(list, option):option可以定制排序:
      • option为'reverse=True'会给出逆序
      • option为'key=len'会根据元素长度排序,len会作用到list的每个元素上
      • 也可以定制自己的函数,再用key指定根据这个函数排序

    5 Dic and files

    • 读文件时可以一行一行读,如果一次全读过来,内存可能放不下
    • 写大程序时,要分一个个阶段写,把每个阶段完成的目标定下,一个阶段完成后,测试,再开始下一阶段, 不要一次全写了

    6 Python Regular Expression

    • match = re.search (pat, str)
    • 注意,pat写成r'words:\w\w\w'表示words后有三个字母,r表示raw.
    • 重复
      • + :1个或多个左边的模式: r'pi+' 可以匹配'piiig'中的'piii'
      • * :0个或多个
      • ? :0个或1个
    • 选择
      • [abc]:a或b或c
      • [\w.-]:一个字母或者一个点或者一个连字符
    • 分组
      • 模式:'([\w.-]+)@([\w.-]+)',得到一个match
        • match.group() :匹配整个模式
        • match.group(1):匹配第一个括号中的 ([\w.-]+),即@之前的部分
        • match.group(2):匹配第二个括号中的 ([\w.-]+),即@之后的部分
      • >>> str = 'purple alice-b@google.com monkey dishwasher'
        >>> import re
        >>> match = re.search('([\w.-]+)@([\w.-]+)', str)
        >>> print match.group()
        alice-b@google.com
        >>> print match.group(2)
        google.com
        >>> print match.group(1)
        alice-b
        >>> matchx = re.search('([\w.-]+)(@)([\w.-]+)', str)
        >>> print matchx.group()
        alice-b@google.com
        >>> print matchx.group(1)
        alice-b
        >>> print matchx.group(2)
        @
        >>> print matchx.group(3)
        google.com
        
    • findall
      • re.search只找第一个匹配的,findall找所有匹配的
        >>> str = 'purple alice@google.com, blah monkey bob@abc.com blah dishwasher'
        >>> emails = re.findall(r'[\w\.-]+@[\w\.-]+', str)
        >>> emails
        ['alice@google.com', 'bob@abc.com']
        
      • findall还可以用于在文件中查找
        • strings = re.findall(r'some pattern', f.read())
      • findall与group
        >>> str = 'purple alice@google.com, blah monkey bob@abc.com blah dishwasher'
        >>> tuples = re.findall(r'([\w\.-]+)@([\w\.-]+)', str)
        >>> tuples
        [('alice', 'google.com'), ('bob', 'abc.com')]
        
    • 选项:search()和findall()都有相应参数作为选项
      • IGNORECASE :匹配时忽略大小写
      • DOTALL :允许点号(.)匹配新行,默认情况.是不匹配新行的
      • MULTILINE: 如果一个字符串由多行组成,使^ $匹配每一行,而非整个字符串
    • 贪心匹配
      • '<.*>' 会匹配到最后一个,而非第一个'>',这叫做贪心匹配,如果想使用非贪心匹配,可以用?
        >>> str = '<b>foo</b> and <i>so on</i>'
        >>> match1 = re.search('(<.*>)', str)
        >>> match1.group()
        '<b>foo</b> and <i>so on</i>'
        >>> match2 = re.search('(<.*?>)', str)
        >>> match2.group()
        '<b>'
        
    • 替换:re.sub(pat, replacement, str)

    7 Python Utilities

    • File System–os,os.path,shutil
      • os.listdir(dir) :列出目录下的所有文件名,返回一个list
      • os.path.join(dir, filename) :把目录和文件名组合在一起,返回整个路径
      • os.path.abspath(path):返回全路径
      • os.path.dirname(path),os.path.basename(path):得到path中的目录,文件名
      • os.path.exists(path):指定路径是否存在
      • os.mkdir(dir_ path):建立一个目录
      • os.makedirs(dir_ path):建立整个路径上所有需要的目录
      • shutil.cpy(source_ path, dest_ path):复制文件
    • Running External Processes – command
      • (status, output) = commands.getstatusoutput(cmd) :运行命令,返回执行结果和输出结果
      • output = commands.getoutput(cmd) :同上,只是不返回执行结果
      • os.system(cmd) :同上,不返回执行结果和输出结果,但将结果输出到标准输出
    • HTTP – urllib 和 urlparse
      • ufile = urllib.urlopen(url) :返回与url相关的类文件对象 
      • text = ufile.read() :读取内容
      • info = ufile.info() :请求的 meta info, 例如 Content-Language,Data, Content-Type等信息
      • baseurl = ufile.geturl –得到请求的base url,由于有转向,可能和原来url不同
      • urllib.urlretrieve(url, filename) –从指定的url下载文件,存储在本地的filename路径中(包含新文件名)
      • urlparse.urljoin(baseurl,url) –得到全路径

    另外,这里还有一份Google Python Style Guide,描述了Google建议的Python编程风格




    展开全文
  • python class(object)

    千次阅读 2019-04-02 17:54:19
    实际上在python3中已经默认帮你加载了object(即便你没有写上object),就拥有了更多的可操作对象,这些...这里附上一个表格用于区分python 2.x 和 python 3.x 中编写一个class的时候带上object和不带上object的区...
  • 原博:https://www.cnblogs.com/liulipeng/p/7069004.html # -*- coding: utf-8 -*- # 经典类或者旧试类 class A: pass a = A() ...class B(object): ...# python2不支持 # print(A.__class__) p...
  • python class 方法传参

    千次阅读 2019-03-25 17:18:11
    class Bbq(object): ‘’‘这是实现烧烤类’’’ def init(self,level): self.level=level#这是生熟程度 self.flavour=[]#这是调料 self.levelstring=‘生’ def kao(self,time):#类里面的方法传参 ‘’‘这是实现烤...
  • Python class中的other

    千次阅读 2020-10-04 21:53:38
    定义了一个Point类,类中有计算两点距离的方法,self表示本类,other表示另一个类,可以直接使用属性。...classPoint(object): def__init__(self,x=0,y=0): self.x=x self.y=y deftest(self,other): prin...
  • Python class 抽象类

    千次阅读 2018-05-04 11:53:16
    简单的方法是: class Sheep(object): def get_size(self): raise NotImplementedError 任何从Sheep继承下来的子类必须实现get_size方法。否则就会产生一个错误。但这种实现方法有个缺点。定义的子类只有调用...
  • python class属性

    千次阅读 2012-12-26 20:08:52
    Class 有一些特殊的属性,便于我们获得一些额外的信息。 >>> class Class1(object): """Class1 Doc.""" def __init__(self): self.i = 1234 >>> Class1.__doc__ # 类型帮助信息 'Class1 Doc.' >>> Class1.__...
  • python class对象转json

    千次阅读 2019-05-08 18:07:53
    class AAA: def __init__(self): self.a = "a" self.b = {"b1": "b1"} if __name__ == '__main__': import json a = AAA() print json.dumps(a, default=lambda obj: obj.__dic...
  • python class的特殊方法

    千次阅读 2018-04-06 10:52:43
    __init__ 构造方法__str__ __def__ 析构方法__mro__ python3特有@classmethod 类方法
  • 6.3 Python class 运算符重载

    千次阅读 2016-12-15 20:24:39
    Python运算符重载.
  • 在面向对象的程序设计过程中有两个重要概念:类(class)和对象(object,也被称为实例,instance),其中...Python 定义类的简单语法如下: class 类名: 执行语句… 零个到多个类变量… 零个到多个方法… 类...
  • 始终提示 File "&lt;stdin&gt;..., line 1 python class.py ^SyntaxError: invalid syntax是因为始终在shell脚本下运行class.py需要退出到class.py所在的目录下运行class.py文件...
  • Python class类转字典

    千次阅读 2018-03-25 21:58:49
    有时候会需要从包装的类里面取出需要的数据,但有不能直接取出来:可以通过如下代码,把class转换成字典:# 将class转dict,以_开头的也要 def props_with_(obj): pr = {} for name in dir(obj): value = getattr...
  • 23 Python class 抽象类

    千次阅读 2016-12-23 17:51:17
    讲述了Python中的抽象类的使用以及示例.
  • python class中object关键字

    千次阅读 2019-06-14 17:33:50
    用关键词 type dir 可以去查看发现没有区别
  • python classclass(object)用法区别-(转)

    千次阅读 2017-12-14 14:13:27
    # -*- coding: utf-8 -*-# 经典类...class A: pass a = A() # 新式类class B(object): pass b = B()# python2不支持 # print(A.__class__) print(a.__class__) print(type(A)) print(type(a))# python2 # __main__.
  • Python class 与c++ 之类的区别

    千次阅读 2018-04-10 20:23:05
    1.类里每个方法第一个参数都是selfclass Foo: empCount def __init__(self, name, age): self.name = name self.age = age def detail(self): print(self.name) print(self.age)2. 构造函数的名字是 __init...
  • python Class 怎样传参数 实例化的时候

    千次阅读 2019-09-03 10:50:11
    在 __init__() 方法里面进行参数列举 Class AAA: ...如何理解Python中的类没有实现init方法,但是实例化的时候却可以传参数进去,具体代码如下 class User(db.Model): __tablename__ = "u...
  • python class 实现类属性的修改

    千次阅读 2019-03-27 16:18:20
    class Person(object): country = ‘China’#类属性 def init(self): self.name = ‘xiaoxiao’ self.age = 18 self.book = ‘我在银河等你’ if name == ‘main’: print(‘类属性:’,Person.country) zhang = ...
  • Google for Education 中 Python 教程的翻译。该教程比较通俗易懂,故翻译成中文。
  • 类的私有属性的访问方法: class Dog(object): def __init__(self, name, age): self.__name = name self.__age =age self.color = "黑色" def get_name(self): return self.__name ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,510
精华内容 52,204
关键字:

pythonclass

python 订阅