打发打发
作者：互联网
#__author : 'liuyang'
#date : 2019/4/1 0001 上午 10:31
#知识点
#所有的a.b 都可以变成 getattr(a,'b')
#用字符串数据类型的变量名 来获取实际的变量值
#使用对象反射
# obj.属性名()
# obj.方法名()
#使用类反射
#cls.静态变量名
#cls.类方法名（）
#cls.静态方法名（）
# 使用模块反射
#反射当前文件
# import time
# time.time()
# 调用函数和方法 地址+（）
'''
def func():
print(1)
#func()
a = func
a()
#getattr # Address获得地址
# 1,使用对象反射
class Manager: #管理员用户
def __init__(self,name):
self.name = name
def create_course(self):#创建课程
print('in Manager create_course')
def create_student(self):
print('in Manager create_student')
def show_courses(self):
print('in Manager show_courses')
def show_students(self):
print('in Manager show_students')
alex = Manager('alex')
operate_lst = [('创建课程','create_course'),('创建学生帐号','create_student'),('查看所有课程','show_courses'),
('查看学生','show_students')]
for index , opt in enumerate(operate_lst,1):
print(index, opt[0])
num = input('请输入您要做的操作：')
if num.isdigit():
num = int(num)
# getattr(alex,num)
# print(operate_lst[num-1][1])
if hasattr(alex,operate_lst[num-1][1]):
getattr(alex,operate_lst[num-1][1])()
#如何使用反射 地址+（）调用 所以 两个地址一样 可以成功使用类
alex = Manager('alex')
a = getattr(alex,'create_course')
b = alex.create_course
print(a)
print(b)
#方法名+（） 字符串getattr()之后 的地址
# 用户输入的
# 两种方式
#对象名.属性名/对象名.方法名() 可以直接使用对象的属性和方法
#当我们只有字符串数据类型的内容的时候
#getattr(对象名,'方法名')() #反射方法多
#getattr(对象名,'属性名')() #反射属性少
funcname = 'create_course'
# a.b <------> getattr(a,b)
'''
#stop 买东西 类
#1 .浏览商品 scan_goods
#2. 选择商品，添加到购物车 choose_goods
#3. 删除商品， delete_goods
class Stop:
def __init__(self):
pass
def scan_goods(self):
print('浏览商品')
def choose_goods(self):
print('选择商品，添加到购物车')
def delete_goods(self):
print('删除商品')
# opt_lst = [choose_goods,()] #不能写方法名只能写字符串
lis = [('浏览商品' ,'scan_goods' ),
('选择商品，添加到购物车', 'choose_goods'),
('删除商品', 'delete_goods'),
]
for i,opt in enumerate(lis,1): #枚举从1开始
print(i, opt[0])
dic= {i:opt[1]}
'''inpu = int(input('输入'))
if hasattr(Stop(),lis[inpu-1][1]): #判断对象有没有方法
getattr(Stop(),lis[inpu-1][inpu-1])() #使用对象找到方法对应的内存地址
#hasattr 和 getattr 是一对好兄弟 一样
# Stop().choose_goods()
# a.b
# 打印商品列表
for i in Stop.__dict__.keys():
if not i.startswith('__'):
print(i)
# print(Stop.__dict__.keys())
'''
#使用类反射
class A:
Country = '中国'
@classmethod
def show(cls):
print('国:',cls.Country)
print(getattr(A,'Country'))
A.show() #国: 中国
getattr(A,'show')() #国: 中国
#反射模块中的方法
import re
ret = re.findall('\d+','23eqwretq')
print(ret)
print(getattr(re,'findall'))
print(re.findall)
print(getattr(re,'findall')('\d+','23eqwretq'))
import time
time.time()
'time'
print(getattr(time,'time')())
# time.sleep(1)
# print(getattr(time,'sleep')(1))
# 只要是a,b这种结构，都可以使用反射
# 对象、类、模块反射，都只有以下场景
# 这种结构有两种情境
#a.b b是属性或者变量值
#a.b()
#getattr(a,'b')()
#a.b(arg1,arg2)
#getattr(a,'b')(arg1,arg2)
#a.b(*arg1,**kwargs)
# getattr(a,'b')(*arg1,**kwargs)
#
# a =1
# b =2
# c =3
# print(a)
# print(b)
# print(c)
from sys import modules
print(modules) #DICT key是模块的名字 value 就是这个模块内存地址
import re
print(re) #<module 're' from 'D:\\Python\\安装\\lib\\re.py'>
# <module 're' from 'D:\\Python\\安装\\lib\\re.py'>
print(re.findall)
# print(<module 're' from 'D:\\Python\\安装\\lib\\re.py'>.f)
'''
print(modules['re'].findall)
a = 1
b = 2
while 1: #__main__当前空间__name__当前空间
name = input('变量名：')
print(__name__)#__main__
print(getattr(modules[__name__], name))
'''
# print(modules['__main__'].a)# 换字符串的
# print(modules['__main__'].b)
# print(getattr(modules['__main__'],'a'))
#语法
#a = 1
#b = 2
# getattr(modules[__name__],'变量名')
#函数名
def func():
print('in func')
# print(getattr([__name__],'func'))
# print(getattr([__name__],'func'))
getattr(modules[__name__],'func')
getattr(modules[__name__],'func')()
# getattr(modules[__name__],'func')()
#反射本文件中的内容：只要是出现在全局变量中的名字
#都可以通过 getattr(modules)
#类名
class Course:
def func(self):
print('in func')
print(Course)
print(getattr(modules[__name__],"Course"))#拿到了类
print(getattr(modules[__name__],"Course")()) #实例化的过程
#hasattr 和 getattr
# 只要是a,b这种结构，都可以使用反射
# 对象、类、模块反射，都只有以下场景
# 这种结构有两种情境
#a.b b是属性或者变量值
#a.b()
#getattr(a,'b')()
#a.b(arg1,arg2)
#getattr(a,'b')(arg1,arg2)
#a.b(*arg1,**kwargs)
# getattr(a,'b')(*arg1,**kwargs)
# 如果是本文件中的内容，不符合a.b这种结构
#直接调用func()
#getattr(sys.modules[__name__],'func')()
#直接使用类名Person()
#getattr(sys.modules[__name__],'Person')()
#直接使用变量名print(a)
# getattr(sys.modules[__name__],'a')
#反射本文件 getattr(sys.)
#所有的getattr都应该和hasattr 一起使用
#if hasattr():
#getattr()
# setattr 只用来修改或添加属性\变量
#a.b = value
#setattr(a,'b',value)
# delattr
#删除属性 del a.b 相当于删除了a对象当中的b属性
""
class A:
def q(self):
print('qijgia')
alex = A()
# alex.name ='sb'
# print(alex.name)
print('A的F',A.__dict__)
#可以通过方法给对象绑属性 不能绑一个方法
# setattr 能够通过字符串数据类型的变量名 给一个对象创建一个新的属性
setattr(alex,'name','sb')
print(alex.name)
print(alex.__dict__)
A().q()
def haha():
print('wh')
setattr(alex,'haha',haha)
alex.haha()
print(alex.__dict__)
#delattr()
del alex.name #一般删除属性 不删除方法
print(alex.__dict__)
# del alex.haha
# print(alex.__dict__)
del A().haha
print(A().__dict__)
View Code
#__author : 'liuyang'
#date : 2019/4/1 0001 上午 10:12
#两个内置函数说起
# issubclass()
# 判断类与类之前是否有 继承关系
# issubclass(疑似子类，疑似父类)
# issubclass(Son，Fon)
class Foo(object):pass
class Son(object):pass
ret = issubclass(Foo,Son)
ret = issubclass(Son,Foo)
ret = issubclass(Foo,Son)
print(ret)
# isinstance()
a = 1
ret1 = type(a) is int
ret2 = isinstance(a,int)
print(ret1,ret2)
class User(object):pass
class VIPUser(User):pass
alex = VIPUser()
ret1 = type(alex) is User
ret2 = isinstance(alex,User)
print(ret1,ret2) #
# ret1 = type(alex) #两代的继承用 isinstance
# isinstance(obj,类) 判断对象与类之间的关系，这个类也包扩父类
#承认继承关系的
# 类 = type(obj)
#只承认实例化这个对象的那个类 （不承认所有的继承关系）
View Code
#
#反射
#反射对象中的内容
#反射类中的内容
#反射本文件中内容
#反射模块的内容
#内置方法
#能学多少学多少 with
View Code
#1.面向对象 #2.logging 模块 + 异常处理 #3.模块和包 +考试 #4.模块和包 +软件开发规范 #网络编程4天 #编发编程6天View Code
#__author : 'liuyang'
#date : 2019/4/1 0001 上午 9:01
#继承 多态 封装(面向对象本身有封装，不能在内部外部用，不能被继承，私有化)
#property classmethod staticmethod
#把一个方法 变成一个属性
#封装
#；面向对象语言本身 就具有封装的特性：属性和方法都放在它所属的类中
#私有化： __名字
#静态属性\对象属性
#方法
#私有的方法
#私有的类方法
#私有的静态方法
#
#如何实现的
#通过在类的内部定义或者使用的时候会自动添加_类名来进行变形
#在类的外部使用时候由于python
#如果我们一定要在外部使用，也可以自己加上_类名来进行
#十分不建议你再类的外部直接使用私有的名字
#私有的：
#不能再类的外不适用
#也不能被继承
class A:
@classmethod
def __func(self): #私有的类方法#'_A__func'
print('asga')
@classmethod
def f(cls): #私有的静态方法
cls.__func()
print(A.__dict__) #可以用
A.f()
#清晰的分类 把功能
#property 把一个方法 变成一个属性
# c.area()
# c.area #get 获取某个值
# c.area =1 #set 给某一个属性赋值
# del c.area #del 删除某个属性
# class Box: #盒子
#def __init__(self,length,width,height):
#self.__len = length
#self.__width = width
#self.__height = height
# @property
#def len(self):
#return self.__len
# @len.setter
# def len(self,value):
# if type(value) is int or type(value) is float:
# self.__len = value
# @len.deleter
#def len(self):
#del self.__len
# b1 = Box(10,20,30)
# ret = b1.len()
# print(ret)
# @property
# def area(self):
# pass
# @area.setter
# def area(self,value)
# pass
#1.基础的方法和语法能不能记住：
# 基础的数据类型 函数（内置函数\匿名函数的语法\普通函数）
# 面向对象的基础语法 定义类 实例化 对象使用方法 查看属性
# 继承的语法 多态的概念 封装的语法
# 几个装饰器 ：对应的功能 方法长什么样
#2.基础的需求能不能完成
#3.进阶的知识点 ：装饰器 生成器 递归函数 各种知识点的活学活用
class File: #盒子
def __init__(self,path):
self.__path = path
@property
def f(self):
self.__f = open(self.__path,'w',encoding='utf-8')
return self.__f
@f.deleter
def f(self):
self.__f.close()
del self.__f
# obj = File()
# obj.f #文件句柄
# obj.f.write('balabala')
# del obj.f
#删除的时候 归还一些资源
# # @classmethod
# cls.静态属性名
# cls.静态方法 #def func(): pass
# cls.类方法
View Code
#__author : 'liuyang' #date : 2019/4/1 0001 上午 8:41 #学练改管测 #听别人说 读input #自己说 自己写 output #1.解决语法错误 #2.解决逻辑错误View Code
标签：__,alex,打发,getattr,print,self,def 来源： https://www.cnblogs.com/Doner/p/10635682.html