# -*- coding: utf-8 -*-
# @Time :
# @Author : chris
# @Email : yellwonfin@outlook.com
# @File : 01.py
# @Software: PyCharm
# 类可以被调用，对象不可以被调用
class Foo:pass
foo = Foo()
print(dir(foo)) # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
print(foo.__dict__) # 对象的属性字典 ，显示的内容，没有dir(foo)的全
print(foo.__class__)
def func1():pass
def func2():pass
class Foo:
def test():
pass
def test2():
pass
foo1 = Foo()
foo2 = Foo()
from types import FunctionType,MethodType
def func(*args):
function_count = 0
method_count = 0
f_obj_count = 0
for item in args:
if isinstance(item,FunctionType):
function_count += 1
elif isinstance(item,MethodType):
method_count += 1
elif isinstance(item,Foo):
f_obj_count += 1
return {'function_count':function_count,'method_count':method_count,'f_obj_count':f_obj_count}
ret = func(func1,func2,foo1,foo2,foo1.test,foo2.test,Foo.test)
print(ret)
# 类方法 将类和cls参数绑定，即自动传参
# 实例方法 都是绑定 将对象和self参数绑定，主动参数
# 类 调用 类中的普通方法 ，打印 类名.普通函数名 ，是一个函数，不会自动传参，因此，不是绑定方法
# 反射模块中的变量
a01 = 1
import os
os.rename('a.txt','b.txt')
getattr(os,"rename")('b.txt','a.txt')
print(__name__) # __main___ # 缩进为文件的顶层，全局名称空间
print(type(__name__)) # <class 'str'> __name__ 是一个内置变量，不需要你创建
def func_name():
set = "aaa"
print(__name__)
func_name()
# 反射文件中的变量
import sys
print(sys.modules) # 返回的是一个字典 '__main__': <module '__main__' from 'C:/Users/jiayong/PycharmProjects/knight_schema/day21/01.py'>
# from a2 import a02
# print(a02)
import a2
print(a2.a02)
print(sys.modules)
# class A:pass
# a = A()
# print(A) # <class '__main__.A'>
# print(type(A)) # <class 'type'>
# print(type(A) is type) # True
# print(type(a)) # <class '__main__.A'>
# print(type(a) is type) # False
#
# #反射
# 3w 1h
# what 是什么？
# 反射 使用字符串数据类型的 变量名 来获取 这个变量的值
a = 1
b = 2
name = "chris"
# why 为什么？三个场景
# input
# 用户输入的如果是a,那么就打印1，如果输入的是b就打印2，如果输入的是name,就打印chris
# 文件
# 从文件中读出的字符串，想转换成变量的名字
# 网络
# 将网络传输的字符转换成变量的名字
# where 在哪儿用
# How 怎么用
# 反射 ******
# hasattr *****
# getattr ******
# 反射类中的变量： 静态属性，类方法，静态方法
class Foo:
school = "oldboy"
country = "china"
language ="Chinese"
@classmethod
def class_method(self):
print("in class_method")
@staticmethod
def static_method():
print("in static_method")
def normal_method():
print("in normal_method")
foo = Foo()
# print(Foo.static_method) # <function Foo.static_method at 0x00000212F8791950>
#
# print(foo.static_method) # <function Foo.static_method at 0x0000013F1E441950>
# 可见，对于静态函数，无论是类名调用 还是对象调用 ，都是一个普通方法，它不会自动传参，就没有把函数和类或对象动态绑定，因此不叫方法
# print(Foo.school)
# print(Foo.language)
# print(Foo.country)
# 判断实现
# if input(">>>") == "school": print(Foo.shcool)
# elif input(">>>>") == "language": print(Foo.language)
# elif input(">>>>") == "country": print(Foo.country)
# else:print("bye,bye")
# 反射实现
# while 1:
# inp = input(">>>")
# print(getattr(Foo,inp,"没有此属性"))
# 解析 getattr()方法
# getattr(变量名：名称空间，字符串： 属于一个名称空间内的变量名）
print(getattr(Foo,"school"))
print(getattr(Foo,"class_method")) # <bound method Foo.class_method of <class '__main__.Foo'>> 类方法是绑定方法
print(getattr(Foo,"static_method")) # <function Foo.static_method at 0x000001DD5C040AE8>
print(getattr(Foo,"normal_method")) # <function Foo.normal_method at 0x000001DB894A0B70>
getattr(Foo,"normal_method")() # 类 调用 类中 的普通函数时，不主动传参，所以此时普通函数是函数，而不是动态方法
# foo.normal_method() # TypeError: normal_method() takes 0 positional arguments but 1 was given
# 对象调用 类中的方法时，会自动 把 对象 当实参 传递给 函数的第一个参数，若函数没有定义形参，报错
# 反射对象中的变量
# 对象属性
# 普通方法
# class Employee:
# def __init__(self,name,age):
# self.name = name
# self.age = age
#
# def eating(self):
# print("%s 在吃饭" % self.name)
# chris = Employee("chris",28)
# print(getattr(chris, "name"))
# print(getattr(chris, "age"))
# getattr(chris, "eating")()
# 反射模块中的变量
# import os
# # os.rename("src.txt","dst.txt")
# print(os.rename) # <built-in function rename>
# getattr(os,"rename")("src.txt","dst.txt")
# 反射文本文件中的变量 分析过程
a = 1
b = 2
name = "chris"
def qqxing():
print("qqxing")
# cls.xxx cls, obj , os 都叫名称空间
# obj.xxx
# os.xxx
import sys
print(sys.modules) # 返回一个字典，所有模块信息，文件也是一个模块
# 返回的字典中，有一个键值对 ： '__main__': <module '__main__' from 'C:/Users/jiayong/PycharmProjects/knight_schema/day21/01.py'>,
# 键__main__,的值，就对应当前文件名，当前文件名，就是全局名称空间名
print(getattr(sys.modules['__main__'],"a")) # 1
print(getattr(sys.modules['__main__'],"qqxing")) #
# 在内置变量 __name__,默认存在，不需要创建
print(__name__) # __main__ # 是当前全局名称间，即当前运行的入口文件名，在系统字典中 对应的键名
import a2 # 导入同目录下的a2.py文件，不要加文件后缀名
## a2.py ## 有以下内容
def myprint():
print(__name__)
###########
a2.myprint() # a2
# setattr 通过字符串数据类型的 变量名 ，对 对象 添加 或修改 变量
# class Foo:
# Country = "China"
#
# def func(self):
# print("陈爱")
# # Foo.School = "youngGirl"
# print(Foo.__dict__)
# setattr(Foo,"School","youngGirl") # 接受三个参数 命令空间 "变量名" 变量值
# print(Foo.__dict__)
# print(Foo.School) # youngGirl
# delattr 删除对象的变量
# class Foo:
# country = "Korean"
# def func(self):
# print("in in in ")
# print(Foo.__dict__)
# delattr(Foo,"country")
# print(Foo.__dict__)
# 反射类中的变量
# 反射对象中的变量
# 反射模块中的变量
# 反射本文件中的变量
# 用反射的场景
# input
# 网络
# 文件
浙公网安备 33010602011771号