python成员函数定义

‘壹’ python的成员函数问题

1. join() 是str类中的一个成员函数，它是类成员。
   

   
   

2. python中视一切为对象，所以a其实是一个字符串对象，具有成员函数join，可以用dir(a)查看。

3. a.join() 就是字符对象a调用其成员函数 join()

‘贰’ python中的函数和类的区别

楼上说错了哦，类可以有类方法（查查什么是classmethod），不需实例化也可以使用的。python的类和函数的区别主要在于类可以有变量和各种方法，而函数没有。函数只能被运行，返回或者不返回值都可以。模块如果没有把类声明为私有，其他模块就可以使用这个类，方法是import这个模块，然后用"模块名.类名"来调用。

‘叁’ Python中类的定义规是什么

类的概念：

类 Class: 用来描述具体相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象是类的示例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

实例变量：定义在方法中的变量，只作用于当前实例的类。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关数据。

方法：类中定义的函数。在类内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

构造函数：即__init()__，特殊的方法，在对象创建的时候被自动调用。

析构函数：即__del()__，特殊的方法，在对象被销毁时被自动调用。

实例化：创建一个类的实例，类的具体对象。就是将创建的类赋值给另一个变量。理解为赋值即可，a = class()，这个过程，就叫做实例化

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其 进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

————————————————

原文链接：https://blog.csdn.net/f156207495/article/details/81166252

网页链接

‘肆’ python如何在类外定义成员函数

类的外面可以定类的属性值。按理也可以定义类外定义函数。一定可以。比如

class a:
pass

def hello(self,name):
print "Hello %s"%name

a.hello=hello
a().hello("somebody")

这个代码测试通过。

‘伍’ python类和函数的区别

一、主体不同

1、类：是面向对象程序设计实现信息封装的基础。

2、函数：是指一段在一起的、可以做某一件事儿的程序。也叫做子程序、（OOP中）方法。

二、特点不同

1、类：是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。

2、函数：分为全局函数、全局静态函数；在类中还可以定义构造函数、析构函数、拷贝构造函数、成员函数、友元函数、运算符重载函数、内联函数等。

三、规则不同

1、类：实质是一种引用数据类型，类似于byte、short、int(char)、long、float、double等基本数据类型，不同的是它是一种复杂的数据类型。

2、函数：函数必须声明后才可以被调用。调用格式为：函数名（实参）调用时函数名后的小括号中的实参必须和声明函数时的函数括号中的形参个数相同。

‘陆’ python 函数是不是描述符

在Python中，访问一个属性的优先级顺序按照如下顺序:
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.__getattr__()方法。这个方法的完整定义如下所示:

[python] view plain
def __getattr__(self,attr) :#attr是self的一个属性名
pass;

先来阐述下什么叫数据描述符。

数据描述符是指实现了__get__,__set__,__del__方法的类属性(由于Python中，一切皆是对象，所以你不妨把所有的属性也看成是对象)

PS:个人觉得这里最好把数据描述符等效于定义了__get__,__set__,__del__三个方法的接口。

阐述下这三个方法:

__get__的标准定义是__get__(self,obj,type=None)，它非常接近于JavaBean的get

第一个函数是调用它的实例，obj是指去访问属性所在的方法，最后一个type是一个可选参数，通常为None(这个有待于进一步的研究)

例如给定类X和实例x，调用x.foo，等效于调用:

type(x).__dict__["foo"].__get__(x,type(x))

调用X.foo，等效于调用:

type(x).__dict__["foo"].__get__(None,type(x))

第二个函数__set__的标准定义是__set__(self,obj,val)，它非常接近于JavaBean的set方法，其中最后一个参数是要赋予的值

第三个函数__del__的标准定义是__del__(self,obj)，它非常接近Java中Object的Finailize()方法，指
Python在回收这个垃圾对象时所调用到的析构函数，只是这个函数永远不会抛出异常。因为这个对象已经没有引用指向它，抛出异常没有任何意义。

接下来，我们来一一比较这些优先级.

首先来看类属性

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''
class A(object):
foo=3

print A.foo
a=A()
print a.foo
a.foo=4
print a.foo
print A.foo

上面这段代码的输出如下：

3
3
4
3

从输出可以看到，当我们给a.foo赋值的时候，其实与类实例的那个foo是没有关系的。a.foo=4 这句话给a对象增加了一个属性叫foo。其值是4。

最后两个语句明确的表明了，我们输出a.foo和A.foo的值，他们是不同的。

但是为什么a=A()语句后面的print
a.foo输出了3呢？这是因为根据搜索顺序找到了类属性。当我们执行a.foo=4的时候，我们让a对象的foo属性指向了4这个对象。但是并没有改变
类属性foo的值。所以最后我们print A.foo的时候，又输出了3。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''
class A(object):
foo=3

a=A()
a.foo=4
print a.foo
del a.foo
print a.foo

上面的代码，我给a.foo赋值为4，在输出一次之后就del了。两次输出，第一次输出的是a对象的属性。第二次是类属性。不是说类属性的优先级比
实例属性的高吗。为啥第一次输出的是4而不是3呢？还是上面解释的原因。因为a.foo与类属性的foo只是重名而已。我们print
a.foo的时候，a的foo指向的是4，所以输出了4。

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

然后我们来看下数据描述符这一全新的语言概念。按照之前的定义，一个实现了__get__,__set__,__del__的类都统称为数据描述符。我们来看下一个简单的例子。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):

def __get__(self,obj,type=None):
pass

def __set__(self,obj,val):
pass

def __del__(self,obj):
pass

class A(object):
foo=simpleDescriptor()

print str(A.__dict__)
print A.foo
a=A()
print a.foo
a.foo=13
print a.foo

上面例子的输出结果如下：

[plain] view plain
{'__dict__': <attribute '__dict__' of 'A' objects>, '__mole__': '__main__', 'foo': <__main__.simpleDescriptor object at 0x005511B0>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
None
None
None

从输出结果看出，print语句打印出来的都是None。这说明a.foo都没有被赋值内容。这是因为__get__函数的函数体什么工作都没有做。直接是pass。此时，想要访问foo，每次都没有返回内容，所以输出的内容就是None了。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):

def __get__(self,obj,type=None):
return "hi there"

def __set__(self,obj,val):
pass

def __del__(self,obj):
pass

class A(object):
foo=simpleDescriptor()

print str(A.__dict__)
print A.foo
a=A()
print a.foo
a.foo=13
print a.foo

把__get__函数实现以下，就可以得到如下输出结果：

[plain] view plain
{'__dict__': <attribute '__dict__' of 'A' objects>, '__mole__': '__main__', 'foo': <__main__.simpleDescriptor object at 0x00671190>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
hi there
hi there
hi there

为了加深对数据描述符的理解，看如下例子：

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __init__(self):
self.result = None;
def __get__(self, obj, type=None) :
return self.result - 10;
def __set__(self, obj, val):
self.result = val + 3;
print self.result;
def __del__(self, obj):
pass
class A(object):
foo = simpleDescriptor();
a = A();
a.foo = 13;
print a.foo;

上面代码的输出是

16

6

第一个16为我们在对a.foo赋值的时候，人为的将13加上3后作为foo的值，第二个6是我们在返回a.foo之前人为的将它减去了10。

所以我们可以猜测，常规的Python类在定义get,set方法的时候，如果无特殊需求，直接给对应的属性赋值或直接返回该属性值。如果自己定义类，并且继承object类的话，这几个方法都不用定义。

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

在这里看一个题外话。

看代码

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __init__(self):
self.result = None;
def __get__(self, obj, type=None) :
return self.result - 10;
def __set__(self, obj, val):
if isinstance(val,str):
assert False,"int needed! but get str"
self.result = val + 3;
print self.result;
def __del__(self, obj):
pass
class A(object):
foo = simpleDescriptor();
a = A();
a.foo = "13";
print a.foo;

上面代码在__set__ 函数中检查了参数val，如果val是str类型的，那么要报错。这就实现了我们上一篇文章中要实现的，在给属性赋值的时候做类型检查的功能。

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

下面我们来看下实例属性和非数据描述符。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class B(object):
foo = 1.3
b = B()
print b.__dict__
b.bar = 13
print b.__dict__
print b.bar

上面代码输出结果如下：

{}
{'bar': 13}
13

那么什么是非数据描述符呢？

简单的说，就是没有实现get,set,del三个方法的所有类。

让我们任意看一个函数的描述：

def call():

pass

执行print dir(call)会得到如下结果：

[plain] view plain
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__mole__', '__name__', '__new__', '__rece__', '__rece_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

先看下dir的帮助。

dir列出给定对象的属性或者是从这个对象能够达到的对象。

回到print dir(call)方法的输出，看到，call方法，有输出的那么多个属性。其中就包含了__get__函数。但是却没有__set__和__del__函数。所以所有的类成员函数都是非数据描述符。

看一个实例数据掩盖非数据描述符的例子：

[python] view plain
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __get__(self,obj,type=None) :
return "get",self,obj,type

class D(object):
foo=simpleDescriptor()
d=D()
print d.foo
d.foo=15
print d.foo

看输出：

('get', <__main__.simpleDescriptor object at 0x02141190>,
<__main__.D object at 0x025CAF50>, <class '__main__.D'>)
15

可见，实例数据掩盖了非数据描述符。

如果改成数据描述符，那么就不会被覆盖了。看下面：

[python] view plain
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __get__(self,obj,type=None) :
return "get",self,obj,type
def __set__(self,obj,type=None) :
pass
def __del__(self,obj,type=None) :
pass

class D(object):
foo=simpleDescriptor()
d=D()
print d.foo
d.foo=15
print d.foo

代码的输出如下：

[plain] view plain
('get', <__main__.simpleDescriptor object at 0x01DD1190>, <__main__.D object at 0x0257AF50>, <class '__main__.D'>)
('get', <__main__.simpleDescriptor object at 0x01DD1190>, <__main__.D object at 0x0257AF50>, <class '__main__.D'>)

由于是数据描述符，__set __函数体是pass，所以两次输出都是同样的内容。

最后看下__getatrr__方法。它的标准定义是:__getattr__(self,attr)，其中attr是属性名

‘柒’ python class成员函数没有实现

pythonclass成员函数没有实现是因为：
def是定义函数,就是封装一段代码,执行特定功能。class是定义对象,对象有自己的成员变量和成员函数。