#1
#类变量与实例变量的区别
class foo:
country='中国'
def __new__(cls, *args, **kwargs):
print('这是构造方法')
return object.__new__(cls) #返回开辟的内存空间地址
def __init__(self,name):
self.name=name
print('这个初始化方法')
#country 是类变量 name是实例变量
# country可以通过类名.变量的方式调用,也可以通过对象.变量的方式调用(对象中无此变量)
#name只能通过对象.变量的方式调用
obj=foo('alex')
print('类名调用类变量',foo.country)
print('对象调用类变量',obj.country)
print('对象调用实例变量',obj.name)
#2
#super().func()是找到func方法本类没有去父类找,继承多个父类,从左往右找
class f1:
pass
class f2:
def func1(self):
return 'func被调用'
class f3(f1,f2):
def func2(self):
print(super().func1())
obj1=f3()
obj1.func2()
#3
#isinstance和type的区别
class Animal:
pass
class Cat(Animal):
pass
class BlueCat(Cat):
pass
a=Animal()
cat=Cat()
blueCat=BlueCat()
print(isinstance(blueCat,Cat))
print(isinstance(blueCat,Animal))
print(type(blueCat))
""" if val == 'f1':
handler.f1()
elif val == 'f2':
handler.f2()
elif val == 'f3':
handler.f3()
elif val == 'f4':
handler.f4()
#4. issubclass/type/isinstance/
# issubclass
class Base(object):
pass
class Foo(Base):
pass
class Bar(Foo):
pass
print(issubclass(Bar,Base)) # 检查第一个参数是否是第二个参数的 子子孙孙类
type:获取当前对象是由那个类创建。
"""
class Foo(object):
pass
obj = Foo()
print(obj,type(obj)) # 获取当前对象是由那个类创建。
if type(obj) == Foo:
print('obj是Foo类型')
""""""
class Foo(object):
pass
class Bar(object):
pass
def func(*args):
foo_counter =0
bar_counter =0
for item in args:
if type(item) == Foo:
foo_counter += 1
elif type(item) == Bar:
bar_counter += 1
return foo_counter,bar_counter
# result = func(Foo(),Bar(),Foo())
# print(result)
v1,v2 = func(Foo(),Bar(),Foo())
print(v1,v2)
"""
isinstance,检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
class Base(object):
pass
class Foo(Base):
pass
obj1 = Foo()
print(isinstance(obj1,Foo)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
obj2 = Base()
print(isinstance(obj2,Foo)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
print(isinstance(obj2,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
"""
给你一个参数，判断对象是不是由某一个指定类？ type --> type(obj) == Foo
给你一个参数，判断对象是不是由某一个指定类或其父类？ isinstance --> instance(obj,Foo)
"""
2. 方法和函数
称谓：
类，方法
外，函数
到底方法函数？
对象.xxx --> xxx就是方法
类.xxx --> xxx就是函数
xxx --> xxx就是函数
打印查看：
function
method
代码检查：
from types import MethodType,FunctionType
def check(arg):
"""
检查arg是方法还是函数？
:param arg:
:return:
"""
if isinstance(arg,MethodType):
print('arg是一个方法')
elif isinstance(arg,FunctionType):
print('arg是一个函数')
else:
print('不知道是什么')
3. 反射
总结：
v = getattr(obj,"func") # 根据字符串为参数（第二个参数），去对象（第一个参数）中寻找与之同名的成员。
getattr # 根据字符串的形式，去对象中找成员。
hasattr # 根据字符串的形式，去判断对象中是否有成员。
setattr # 根据字符串的形式，动态的设置一个成员（内存）
delattr # 根据字符串的形式，动态的删除一个成员（内存）
应用一：
# by luffycity.com
from types import FunctionType
import handler
while True:
print("""
系统支持的函数有：
1. f1
2. f2
3. f3
4. f4
5. f5
""")
val = input("请输入要执行的函数：") # val = "f1"
if hasattr(handler,val):
func_or_val = getattr(handler,val) # 根据字符串为参数，去模块中寻找与之同名的成员。
if isinstance(func_or_val,FunctionType):
func_or_val()
else:
print(func_or_val)
else:
print('handler中不存在输入的属性名')
"""
应用二：
class Account(object):
func_list = ['login', 'logout', 'register']
def login(self):
"""
登录
:return:
"""
print('登录111')
def logout(self):
"""
注销
:return:
"""
print('注销111')
def register(self):
"""
注册
:return:
"""
print('注册111')
def run(self):
"""
主代码
:return:
"""
print("""
请输入要执行的功能：
1. 登录
2. 注销
3. 注册
""")
choice = int(input('请输入要执行的序号:'))
func_name = Account.func_list[choice-1]
# func = getattr(Account,func_name) # Account.login
# func(self)
# func = getattr(obj1,func_name) # obj1.login
func = getattr(self, func_name) # self.login
func()
obj1 = Account()
obj1.run()
obj2 = Account()
obj2.run()
#问题：你见过的什么后面可以加()?
- 类()
- 对象()
- 函数()
- 方法()
以上所有都可以被调用。
示例：
def func():
pass
class Foo(object):
def __call__(self, *args, **kwargs):
pass
def func(self):
pass
obj = Foo()
print(callable(func))
print(callable(Foo))
print(callable(obj))
print(callable(obj.func))
