Python中类⽅法定义及常⽤的实现⽅式
1. python类的属性和⽅法查看
class Person_1:
mind ='有思想'
belif ='有信仰'
animal ='⾼级动物'
def tt():
pass
print(Person_1.__dict__)#查询类Person中所有的内容，表现形式是字典.
print(Person_1.__dict__['belif'])#查询类Person中的变量'belif'
class Person_2:
mind ='有思想'
belif ='有信仰'
animal ='⾼级动物'
def work():
print('666')
def money():
print('777')
print(Person_2.animal)#⾼级动物
print(Person_2.mind)#有思想
Person_2.mind ='没有思想'#修改变量'mind'的值，可以通过__dicy__查看修改后的内容
Person_2.pay ='货币交换'#增加变量'pay'和它的值，可以通过__dicy__查看增加后的内容
Person_2.say ='语⾔交流'
print(Person_2.work())#也可以调⽤类中的⽅法(函数),⼯作中不⽤类名去操作
print(Person_2.__dict__)#查看类中所有的内容
水浒传第七回运⾏：
{'__module__':'__main__','mind':'有思想','belif':'有信仰','animal':'⾼级动物','tt':<function at 0x10f243f28>,'__dict__':<attribute '__dict__' of 'Person_1' objects>,'__weakref__':<attribute '__weakref__' of 'Person_1' objects>,'__doc__':None}
有信仰
⾼级动物
有思想
666
None
{'__module__':'__main__','mind':'没有思想','belif':'有信仰','animal':'⾼级动物','work':<function Person_2.work at 0x1114429d8>,'money':<function Per at 0x1114421e0>,'__dict__':<attribute '__dict__' of 'Person_2' objects>,'__weakref__':<attribute '__weakref__' of 'Person_2' objects>,'__d oc__':None,'pay':'货币交换','say':'语⾔交流'}
2. python对象⽅法、类⽅法、静态⽅法：
下⾯是简单的⼏个例⼦：
class Person(object):
grade=6# 类变量白羊座上升星座
def__init__(lf):
lf.name ="king"
lf.age=20
def sayHi(lf):#加lf区别于普通函数
print('Hello, your name is?',lf.name)
def sayAge(lf):
print('My age is %d years old.'%lf.age)
@staticmethod# 静态⽅法不能访问类变量和实例变量，也不能使⽤lf
def sayName():
print("my name is king")
@classmethod#类⽅法可以访问类变量，但不能访问实例变量
def classMethod(cls):
#print('cls:',cls)
print('class grade:',ade)
#print("class method")
class Child(object):
def__init__(lf):
lf.name ="⼩明"
lf.age=20
def sayName(lf,obj):
表彰大会流程
print('child name is:',lf.name)
print(obj.sayName)
print(obj.sayName())# 这⾥要特别注意带括号和不带括号的区别：⼀个是对象，⼀个是⽅法p = Person()# 实例化对象
print('p.grade:',p.grade)# 实例对象调⽤类变量
print(p.classMethod(),p.grade)# 实例改变类变量时，其grade变量只会在实例中改变
print(Person().grade)# 类对象调⽤类变量
p.sayHi()# 实例对象调⽤类成员函数
Person().sayAge()# 类对象调⽤类成员函数
p.sayName()# 实例对象调⽤类静态⽅法
m=Person()
m.sayName()# 多个实例共享此静态⽅法
Person().sayName()# 类对象调⽤静态⽅法
p.classMethod()# 实例对象调⽤类⽅法
Person.classMethod()# 类对象调⽤类⽅法
# 调⽤类
tt=Child()
tt.sayName(Person())
运⾏结果：
class grade:6
刘禹锡有什么之称
None9
6
Hello, your name is? king
My age is20 years old.
my name is king
my name is king
my name is king
class grade:6
class grade:6
child name is:⼩明
<function Person.sayName at 0x10f1cc598>
my name is king
None
⼩⼩总结下：
python中实现静态⽅法和类⽅法都是依赖于python的装饰器来实现的。 对象⽅法有lf参数，类⽅法有cls参数，静态⽅法不需要这些附加参数。
静态⽅法
要在类中使⽤静态⽅法，需在类成员函数前⾯加上@staticmethod标记符，以表⽰下⾯的成员函数是静态函数。使⽤静态⽅法的好处是，不需要定义实例即可使⽤这个⽅法。另外，多个实例共享此静态
⽅法（静态⽅法⽆法访问类属性、实例属性，相当于⼀个相对独⽴的⽅法，跟类其实没什么关系，简单讲，静态⽅法就是放在⼀个类的作⽤域⾥的函数⽽已）。
类⽅法
类⽅法与普通的成员函数和静态函数有不同之处。定义： ⼀个类⽅法就可以通过类或它的实例来调⽤的⽅法, 不管你是⽤类来调⽤这个⽅法还是类实例调⽤这个⽅法，该⽅法的第⼀个参数总是定义该⽅法的类对象。 也即是⽅法的第⼀个参数都是类对象⽽不是实例对象. 按照习惯，类⽅法的第⼀个形参被命名为 cls。任何时候定义类⽅法都不是必须的（类⽅法能实现的功能都可以通过定义⼀个普通函数来实现，只要这个函数接受⼀个类对象做为参数就可以了）。同时，类⽅法可以访问类属性，⽆法访问实例属性。上述的变量grade，在类⾥是类变量，在实例中⼜是实例变量，所以使⽤的时候要注意，使⽤好的话功能很强⼤，使⽤不好容易混淆。
3. 类⽅法之间的调⽤
class Person(object):
# 不加任何参数直接定义，也是类⽅法
def Work():
print(" I am working！")
# 类⽅法第⼀种⽅法：加装饰器⽅法
@classmethod
def Think(cls,b):#类⽅法Think必须要带⾄少1个参数，第⼀个参数默认为类名，后⾯可以引⽤。
cls.Eat(b)#在类⽅法Think中，调⽤类⽅法Eat类⽅法。
cls.Work()#在类⽅法Think中，调⽤Work类⽅法。
print(b,",I am Thinking!")
机甲头像# 属于第⼆种⽅法，先定义类⽅法，⾄少1个参数，第⼀个默认为类名。
劝学翻译全文
def Eat(cls,b):
print(b+",I am eating")
Eat=classmethod(Eat)#第⼆种⽅法：通过内建函数classmethod()来创建类⽅法。
# 静态⽅法，引⽤时直接⽤类名.Sleep()即可。
@staticmethod
def Sleep():
print("I am sleeping")
# 这种⽅法是：实例对象调⽤⽅法
def__scolia__(lf):
print("scola")
return"scola"
# 实例对象可以访问的私有⽅法，在类⽅法中可以相互调⽤和使⽤。类不能直接访问或者外部访问。def__good(lf):
print("good")
return"good"
Person.Think("li")
Person.Eat("jcy")
Person.Work()
# a.Work() 报错，实例对象不能调⽤类⽅法
Person.Sleep()
a=Person()
a.__colia__()# 魔术⽅法，没有私有化。
#a.__good() # 私有⽅法：报错了！
运⾏：
li,I am eating
I am working！
li ,I am Thinking!
jcy,I am eating
I am working！
I am sleeping
scola
4. python使⽤@property @x.tter @x.deleter
只有@property表⽰只读。
同时有@property和@x.tter表⽰可读可写。
同时有@property和@x.tter和@x.deleter表⽰可读可写可删除。
making
⽅法必须要先经过 property()函数的装饰后，才有后⾯两个装饰器的⽤法。
直接看实例：
class student(object):#新式类
def__init__(lf,id):
lf.__id=id
@property#只读
def score(lf):
return lf._score
@ #只写
def score(lf,value):
if not isinstance(value,int):
rai ValueError('score must be an integer!')
if value<0or value>100:
rai ValueError('score must between 0 and 100')
lf._score=value
@property#只读
def get_id(lf):
return lf.__id
s=student('123456')
s.score=100# 写
print(s.score)#读
print(s.__dict__)
_id)#只读
#s.get_id=456 #只能读，不可写:AttributeError: can't t attribute
class A(object):# 新式类（继承⾃object类）
def__init__(lf):
lf.__name=None
def getName(lf):
return lf.__name
def tName(lf,value):
lf.__name=value
def delName(lf):
del lf.__name
name=property(getName,tName,delName)
a=A()
print(a.name)#读
a.name='python'#写
print(a.name)#读
del a.name #删除
#print a.name #a.name已经被删除 AttributeError: 'A' object has no attribute '_A__name'
运⾏结果：
100
水的来源{'_student__id':'123456','_score':100}
123456
None
python
