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 总结



细数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中的装饰器

@property 

是一个装饰器,将一个方法当作属性调用
@staticmethod 

将方法定义成静态方法,不需要传入self了
@classmethod 

将一个方法定义成类方法,传入cls而不是self
@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().
现在我想在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去解决一些问题，做完这些习题，感觉比看完整本书还有感觉。这给我提了个醒，学完一个东西要主动找一些练习去做，不然看多少书都没有感觉。尤其是一些实践性很强的东西。下面是读的过程中记的一些简要的笔记。


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编程风格