打发打发

Posted 2021-11-25 doner

#__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