便宜VPS测评
@classmethod
整个方法中没有用到对象命名空间中的名字，且用到了类的命名空间中的名字（普通方法和属性property除外）
类方法的默认参数：cls 调用这个发方法的类
类方法的调用方式：通过类名调用
通过类名调用的本质是方法
@statimethod
将一个普通函数放到类中来就给这个函数加一个@staticmethod装饰器
这个函数就不需要传默认的参数：self，cls
静态方法的调用方式：通过类名调用
通过类名调用本质是函数
from types import MethodType,FunctionType 配合isinstance使用，判断是方法还是函数
通过类名调用，@classmethod的是方法，@statimethod的是函数
from types importFunctionType,MethodType
classFoo:
@classmethod
def func1(cls):pass
@staticmethod
def func2():pass
print('Foo.func1-Function:',isinstance(Foo.func1,FunctionType)) #判断类方法是否函数
print('Foo.func1-Method:',isinstance(Foo.func1,MethodType)) #判断类方法是否方法
print('----------------------------------------')
print('Foo.func2-Function:',isinstance(Foo.func2,FunctionType)) #判断静态方法是否函数
print('Foo.func2-Method:',isinstance(Foo.func2,MethodType)) #判断静态方法是否方法
'''Foo.func1-Function: False
Foo.func1-Method: True
----------------------------------------
Foo.func2-Function: True
Foo.func2-Method: False
'''
通过对象调用，@classmethod的是方法，@statimethod的是函数
from types importFunctionType,MethodType
classFoo:
@classmethod
def func1(cls):pass
@staticmethod
def func2():pass
f =Foo()
print('Foo.func1-Function:',isinstance(f.func1,FunctionType)) #判断对象类方法是否函数
print('Foo.func1-Method:',isinstance(f.func1,MethodType)) #判断对象类方法是否方法
print('----------------------------------------')
print('Foo.func2-Function:',isinstance(f.func2,FunctionType)) #判断对象静态方法是否函数
print('Foo.func2-Method:',isinstance(f.func2,MethodType)) #判断对象静态方法是否方法
'''Foo.func1-Function: False
Foo.func1-Method: True
----------------------------------------
Foo.func2-Function: True
Foo.func2-Method: False
'''
类可以被调用，对象不能被调用
deffunc(args):
ifcallable(args):
print(args())
else:
print('not callable:',args)
class Foo:pass
f =Foo()
func(Foo) #类 <__main__.Foo object at 0x0000016AE645C278>
func(f) #对象 not callable: <__main__.Foo object at 0x0000016AE645C320>
总结：
需要明确传递参数的是function（函数），不需要明确传递参数的是method（方法）。类直接调用是function（函数），类的实例调用的是method（方法）
静态方法：类调用和对象调用都是function（函数）
#判断函数、方法、对象
from types importMethodType,FunctionType
def func(*args):
function_count =0
method_count =0
foo_obj =0
for item inargs:
if isinstance(item,FunctionType):function_count += 1
elif isinstance(item,MethodType):method_count += 1
elif isinstance(item,Foo):foo_obj += 1
return {'function_count': function_count, 'method_count': method_count, 'foo_obj': foo_obj}
def func1():pass
classFoo:
def method1(self):pass
f1 =Foo()
ret =func(func1,f1.method1,Foo.method1,Foo(),func,f1)
print(ret)
'''{'function_count': 3, 'method_count': 1, 'foo_obj': 2}
'''
类、对象内存机制的解析
反射作用：使用字符串数据类型的变量名来获取这个变量的值
使用反射的三个场景：
① input
② 文件：从文件中读出的字符串，想转化成变量的名字
③ 网络：将网络传输的字符串转化成变量的名字，函数名是变量，类名也是变量，直接执行变量
反射变量的方式：
① 反射类中的变量（反射静态变量，类方法，静态方法）
② 反射对象中的变量（反射对象中的对象属性，普通方法）
③ 反射模块中的变量
④ 反射本文件中的变量
反射使用的常用函数：
① hasattr() 用于判断对象是否包含对应的属性
②getattr() 获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。
需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，
可以在后面添加一对括号。
getattr(变量名：命名空间，字符串：属于一个命名类的变量名)
③ setattr() 给对象的属性赋值，若属性不存在，先创建再赋值
setattr() 接收三个参数，命名空间，‘变量名’，变量值
④ delattr()删除 object对象 中的 name属性
① 反射静态变量
classA:
city = 'Shenzhen'
if hasattr(A,'city'): #判断类中是否存在该变量名，变量名字符串格式，相当于 A.city in A
ret = getattr(A,'city') #getattr(类名，变量名的字符串格式),相当于 ret = A.city
print(ret) #Shenzhen
② 反射类方法
classB:
@classmethod
def func(cls): #类方法
return 666
if hasattr(B,'func'): #判断类中是否存在该变量名，变量名字符串格式，相当于B.func in B
ret = getattr(B,'func') #getattr(类名，变量名的字符串格式)，相当于 ret = B.func
print(ret) #<bound method B.func of <class '__main__.B'>>
print(ret()) #执行B.func() 666
③ 反射静态方法
classC:
@staticmethod
def func(): #静态方法
return 333
if hasattr(C,'func'): #判断类中是否存在该变量名，变量名字符串格式，相当于C.func in C
ret = getattr(C,'func') #getattr(类名，变量名的字符串格式)，相当于 ret = C.func
print(ret) #<function C.func at 0x000001D058918BF8>
print(ret()) #执行C.func() 333
① 反射对象属性
classA:
name = 'gg'
def __init__(self,city):
self.city = city #对象属性
a = A('广州')
if hasattr(a,'city'):
ret = getattr(a,'city') #相当于 ret = a.city
print(ret) #广州
print(a.city) #广州
② 反射普通方法
classB:
deffunc(self):
print(666)
b =B()
if hasattr(b,'func'):
ret = getattr(b,'func') #相当于 ret = b.func
print(ret) #<bound method B.func of <__main__.B object at 0x00000242F27DC5F8>>
ret() #666
b.func() #666
importos
getattr(os,'rename')('a.txt','b.txt') #相当于 os.rename('a.txt','b.txt')#os.rename('a.txt','b.txt')
importsys city = '北京' print(sys.modules['__main__']) #本文件的命名空间 print(sys.modules['__main__'].city) #相当与 print(city) print(sys.modules[__name__]) #本文件的命名空间(默认使用此方式)#__name__ == '__main__' ret = getattr(sys.modules[__name__],'city') #相当于 ret = city , 相当于 sys.modules['__main__'].city ret = getattr(sys.modules[__name__],'city') #相当于本文件中的city变量 print(ret)
setattr(object, name, value)
object — 对象。
name — 字符串，对象属性。
value — 属性值。
class A:pass setattr(A,'city','广州') #相当于 A.city = '广州' print(A.__dict__) print(A.city) #广州
delattr(object, name)
object — 对象。
name — 必须是对象的属性。
classB:
city = '上海'
delattr(B,'city') #相当于 del B.city
内置方法：不是需要程序员定义，本身就存在在类中的方法就是内置方法
内置方法的形式： __名字__
名字——双下方法，魔术方法，内置方法
__init__ 类的初始化方法，不需要主动调用，而是在类的实例化的时候内部自动调用的
所有的双下方法，都不需要直接去调用，都是有另一种自动触发它的语法
__str__
__str__的方法，必须return str类型
①当打印一个对象的时候触发__str__，打印的是__方法的返回值
②当使用%s格式化的时候，触发__str__
③str强转数据类型的时候，触发__str__
classA:
def __init__(self,city,province):
self.city =city
self.province =province
def __str__(self):
return '%s在%s内' %(self.city,self.province)
a = A('广州市','广东省')
print(a)
print('%s' %a)
print(str(a))
'''广州市在广东省内
广州市在广东省内
广州市在广东省内
'''
__repr__
__repr__的方法，必须return str类型
__repr__相当于__str__的备胎，有__str__的时候执行__str__，没有__str__的时候，执行__repr__
repr()内置函数对应的结果是__repr__的返回值
① 当使用repr()的时候触发__repr__
② 当使用%r格式化输出的时候触发__repr__
③ 当打印一个对象的时候触发__repr__，打印的是__方法的返回值
④ 当使用%s格式化的时候，触发__repr__
⑤ str强转数据类型的时候，触发__repr__
classA:
def __init__(self,city,province):
self.city =city
self.province =province
def __repr__(self):
return '%s在%s内' %(self.city,self.province)
a = A('深圳市','广东省')
print(a)
print('%s' %a)
print(str(a))
print(repr(a))
print('%r' %a)
'''深圳市在广东省内
深圳市在广东省内
深圳市在广东省内
深圳市在广东省内
深圳市在广东省内
'''
继承关系中，__str__和__repr__的优先级：
结论：子类的__str__ >>> 父类的__str__ >>>子类的__repr__ >>>父类的__repr__
