初学Python-反射装饰器面向对象编程异常处理断言-优快云博客

本文介绍了Python编程中的高级技巧，包括反射、装饰器及面向对象编程等核心概念的应用。通过实例展示了如何利用反射动态加载和执行模块，装饰器的多种用法，以及面向对象中静态字段、动态字段、私有字段等的使用。

1 反射

以字符串的形式导入模块

以字符串的形式执行模块

#!usr/bin/env python
#coding:utf-8
#反射
##网页链接 ,规范xxx/xxx
#account/login
data=raw_input('请输入地址：')
array=data.split('/')
#account[0]=account
userspance=__import__('backend.'+array[0])#读取文件夹
module=getattr(userspance,array[0])#读取文件夹下的模块
func=getattr(module,array[1])#读取文件夹下的模块的函数
func()
'''
accout.py

def login():
    print('login')
def logout():
    print('logout')
    
admin.py
def index():
    print('欢迎登陆后台管理')
'''

2 装饰器

#!usr/bin/env python
#coding:utf-8
#װ装饰器
#不带参数 不带返回值
def outer(fun):  #1   
    def wrapper():#   3   6
        '''
      在所有函数前加东西      7
        '''
        fun()        # 8
        '''
        在所有函数前后东西     10
        '''
    return wrapper  #4 此时Func1()里面是 wrapper函数
@outer    #2其实是传参数  fun=Func1
def Func1():
    print 'func1'   # 9
@outer    #2其实是传参数  fun=Func1
def Func2():
    print 'func2'   # 9
@outer    #2其实是传参数  fun=Func1
def Func3():
    print 'func3'   # 9   
      
'''
    此处省略N个函数
'''   
Func1()
Func2()
Func3()  #5
'''
Func1=
def wrapper():#   3   6  可以加参数
      #在所有函数前加东西      7
        fun()        # 8       
       # 在所有函数前后东西     10
'''







#带参数
def outer(fun):  #1   
    def wrapper(arg):#   3   6
        '''
      在所有函数前加东西      7
        '''
        fun(arg)        # 8
        '''
        在所有函数前后东西     10
        '''
    return wrapper  #4 此时Func1()里面是 wrapper函数
@outer    #2其实是传参数  fun=Func1
def Func1(arg):
    print 'func1' ,arg   # 9
      
'''
    此处省略N个函数
'''   


Func1('ffdfvdv')  #5
'''
Func1=
def wrapper(arg):#   3   6  可以加参数
      #在所有函数前加东西      7
        fun(arg)        # 8       
       # 在所有函数前后东西     10
'''




#带参数带返回值

def outer(fun):  #1   
    def wrapper(arg):#   3   6
        '''
      在所有函数前加东西      7
        '''
        result=fun(arg)        # 8
        '''
        在所有函数前后东西     10
        '''
        return result
    return wrapper  #4 此时Func1()里面是 wrapper函数
@outer    #2其实是传参数  fun=Func1
def Func1(arg):
    print 'func1' ,arg   # 9
    return 'return'
      
'''
    此处省略N个函数
'''   


response=Func1('ffdfvdv')  #5
print response
'''
Func1=
def wrapper(arg):#   3   6  可以加参数
      #在所有函数前加东西      7
        fun(arg)        # 8       
       # 在所有函数前后东西     10
       return result
'''

3 面向对象

#面向对象
#静态字段属于类，动态字段属于对象
class Province:
##字段
    memo='中国的23个省之一'##静态字段 
    def __init__(self,name,capital,leader):#类的方法
        self.Name=name#动态字段
        self.Capital=capital
        self.Leader=leader
#方法    #动态方法（对象访问）创建对象
    def sports_meet(self):
        print self.Name+'正在开运动会'  
    def eath_lunch(self):
        print self.Leader+'正在吃午饭'
    #静态方法（类访问）   (可以不用创建对象)
    @staticmethod
    def foo():
        print'每个省都在反腐' 
#特性（加装饰器）
    @property
    def Bar(self):
        print self.Name
        #return 'something'
sd=Province('山东','济南','王胜辉')
hb=Province('河北','石家庄','李亚')
##访问字段#################类（静态字段）对象（动态字段）
print Province.memo
#print Province.Capital#类不能访问动态字段
print hb.Capital
print hb.memo#对象可以访问静态字段
##访问方法################类（静态方法）对象（动态方法）
hb.sports_meet()
sd.sports_meet()
sd.eath_lunch()
Province.foo()#()类不能访问动态方法，加上@staticmethod再去掉self就是静态方法
##访问特性###############与访问字段方法一样
hb.Bar

#!usr/bin/env python
#coding:utf-8
#面向对象
#静态字段属于类，动态字段属于对象
class Province:
##字段
    memo='中国的23个省之一'##静态字段 
    def __init__(self,name,capital,leader,flag):#类的方法
        self.Name=name#动态字段
        self.Capital=capital
        self.Leader=leader
    #####私有字段 外部访问不到（得二次访问）    
        self.__Thailand=flag
#方法    #动态方法（对象访问）
    def sports_meet(self):
        print self.Name+'正在开运动会'  
    def eath_lunch(self):
        print self.Leader+'正在吃午饭'
    ###私有字段写入
    def show(self): 
        print self.__Thailand  
    ####私有方法
    def __sha (self):
        print'输出是'
    def show2(self):
        self.__sha() 
    
    #静态方法（类访问）   
    @staticmethod
    def foo():
        print'每个省都在反腐' 
#特性（加装饰器）
    @property
    def Bar(self):
        print self.Name
        #return 'something'
     #读私有字段
    @property
    def Thailand(self):
        print self.__Thailand
   
        
        
#sd=Province('山东','济南','王胜辉',gy)
#hb=Province('河北','石家庄','李亚',vhvg)
JP=Province('日本','fvsvsv','fcvz',True)
##访问字段#################类（静态字段）对象（动态字段）
#print Province.memo
###print Province.Capital#类不能访问动态字段
#print hb.Capital
#print hb.memo#对象可以访问静态字段
#print JP.__Thailand#私有字段 外部不能访问

##访问方法################类（静态方法）对象（动态方法）
#hb.sports_meet()
#sd.sports_meet()
#sd.eath_lunch()
JP.show()
#JP.sha()#外部不能访问私有方法
JP.show2()
#Province.foo()#类不能访问动态方法，加上@staticmethod再去掉self就是静态方法
##访问特性###############与访问字段方法一样
#hb.Bar





JP.Thailand
JP.Thailand=False
print  JP.Thailand

class test1:#可读可写(经典类)不常用
    def __init__(self):
        self.__pravite='1111'########一定是双_
        
    @property
    def show(self):
        return self.__pravite
t1=test1()
print t1.show
t1.show='11111111111111111'
print t1.show


class test2(object):##读写分开（新式类）常用
    def __init__(self):
        self.__pravite='2222'
    @property
    def show(self):
        return self.__pravite   
    @show.setter
    def show(self,value):
        self.__pravite=value
t2=test2()
print t2.show#########不能加括号
t2.show='22222222222222222222'
print t2.show

转载于:https://www.cnblogs.com/Eilleen/p/6754062.html