类方法与静态方法

class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day =  day
    # echo普通方法, 默认情况下会传递对象给echo
    def echo(self):
        return "%s %s %s" %(self.year, self.month, self.day)
    # 默认传递类本身给这个方法;
    @classmethod
    def as_string(cls, s):
        print(cls)
        month, day, year = s.split('/')
        d = cls(year, month, day)
        return d
    #  默认python解释器不会传递任何参数
    @staticmethod
    def is_vaild(s):
        # 批量将年月日转换成整形(列表生成式， map)
        # month, day, year = s.split('/')
        # month, day, year = [int(i) for i in s.split('/')]
        month, day, year = map(int, s.split('/'))
        return 0 < month <= 12 and 0 < day <= 31 and 1 < year < 9999
d = Date(2018, 10, 10)
d.echo()

s = '10/10/2018'
print(Date.as_string(s).echo())

s = '10/10/2018'
print(Date.is_vaild(s))
d = Date(2018, 10, 10)
print(d.is_vaild('13/10/2019'))

with语句

上下文管理协议
1). 当with语句开始运行的时候，执行什么方法;
2). 当with语句执行结束之后出发某个方法的运行;
with open(‘/etc/passwd’) as f:
print(f.read())

class Myopen(object):
    def __init__(self,filename,mode='r'):
        self._name=filename
        self._mode=mode
    #当with语句开始运行的时候，执行什么方法
    def __enter__(self):
        self.f=open(self._name,self._mode)
        return self.f
    #当with语句执行结束之后触发某个方法的运行
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

    @property
    def name(self):
        return self._name
    @property
    def mode(self):
        return self._mode
with Myopen('/etc/passwd') as f:
    print(f.closed)
    print(f.read(5))
print(f.closed)

面向对象的反射机制

1.如果知道对象拥有的属性和方法.

 print(dir(str))
 f=open('/tmp/passwd')
 print(dir(f))

2.判断对象所属的类

print(type('hello'))
class Student(object):
    """
    这是Student类的帮助文档
    """
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def get_score(self):
        return 'score'
    def get_grade(self):
        return 'grade'
s1=Student('lijia',20)
print(type(s1))
print(isinstance(s1,Student))
print(isinstance('lijia',Student))

3.根据对象可以获取的内容

print(s1.__class__)
print(s1.__dict__)
print(s1.__doc__)

4.hasattr,getattr,setattr,delattr

#hasattr:判断对象是否包含对应的属性或者方法名

 print(hasattr(s1,'name'))
 print(hasattr(s1,'__age')) #私有属性和私有方法不能判断
 print(hasattr(s1,'score'))
 print(hasattr(s1,'get_score'))
 print(hasattr(s1,'set_score'))

getattr:用于返回对象的属性值或者方法名对应的方法体

print(getattr(s1,'name'))
print(getattr(s1,'__age','no attr'))
print(getattr(s1,'get_score','no method'))#获取方法名，如果要执行，直接调用即可
print(s1,'set_score','no method')

setattr：修改某个属性的值

setattr(s1,'name','westos')
print(getattr(s1,'name'))

添加某个属性及对应的值

setattr(s1,'score',90)
print(getattr(s1,'score'))

修改方法

def get_score1():
    return '这是修改的方法内容'
setattr(s1,'get_score','get_score1')
print(getattr(s1,'get_score'))

def set_score():
    return '这是添加的方法'

添加方法

setattr(s1,'set_score',set_score)
print(getattr(s1,'set_score'))
print(getattr(s1,'set_score')())

delattr

delattr(s1,'name')
print(hasattr(s1,'name'))
print(hasattr(s1,'set_score'))
delattr(s1,'set_score')
print(hasattr(s1,'set_score'))

反射机制的应用场景

class Web(object):
    def newarticles(self):
        return '<h1>newarticles</h1>'
    def watchers(self):
        return '<h1>watchers</h1>'
    def news(self):
        return '<h1>news</h1>'
    def ai(self):
        return '<h1>ai</h1>'
flask=Web()
def run():
    url=input('url:')
    # if url=='news':
    #     return flask.news()
    # elif url=='ai':
    #     return flask.ai()
    # else:
    #     return '<h1>404<h1>'
    #如果方法多的话，以上方法比较麻烦，以下操作比较简单
    if hasattr(flask,url):
        return getattr(flask,url)()
    else:
        return '<h1>404</h1>'
if __name__=='__main__':
    while True:
        print(run())

反射机制与动态导入

def run():
    #'/bbs/index';  modules='bbs,  func='index'
    modules,func=input('url:').split('/')[-2:]
    #导入一个包含变量的模块名，其中obj是模块的别名
    obj=__import__('lib.'+module)
    # 判断模块中是否有指定的方法， 如果有， 则执行代码， 如果没有， 404报错;
    print(obj)
    print(modules)
    print(obj.index())

    if hasattr(obj, func):
        fun = getattr(obj, func)
        return fun()
    else:
        return "404： 页面找不到"

        import lib.bbs
        import lib.bbs as obj
        obj.index()
        lib.bbs.index()
        if hasattr(flask, url):
            return getattr(flask, url)()
        else:
            return "<h1>404</h1>"
if __name__ == "__main__":
    while True:
        print(run())

python的常见异常处理

 print(a)
 NameError

 li=[1,2,3,4]
 print(li[4])
 IndexError:索引错误

 d=dict(a=1,b=2)
 print(d['c'])
 KeyError

print(10/(2-2))
ZeroDivisionError:除0错误

 class Student(object):
    def __init__(self,name,age):
       self.name=name
        self.age=age
    def echo(self):
        print(self.name,self.age)
 s1=Student('westos',10)
 print(s1.scores)
s1.echo()
 AttributeError:对象没有该属性

 with open('/tmp/passwd9') as f:
    print(f.read(5))
FileNotFoundError:没有该文件

总结: 在程序运行过程中影响程序正常运行的内容， 称为异常.

try-except语句

try:
     print(a)
   **#如果出现NameError时,不报错,只显示except语句里面执行的内容.**
 except NameError:
    print('name error')
    print('hello')
    print('hello1')
**#捕获异常**
try:
    f=open('hello.txt','w')
    f.write('这是一个测试文件')
**注意：except语句不一定会执行，只有在try语句中出现IOError报错时，才会执行**
except IOError as e:
    print(e)
    print('没有找到文件或者文件读取失败')
**#如果没有捕获到异常，则执行else语句的内容**
else:
    print('文件内容写入成功')
**#无论是否捕获到异常，都执行的语句**
finally:
    f.close()
    print('文件已经关闭')

不指定异常类型的except语句

try:
    f=open('hello.txt')
    f.write('这是一个测试文件')
    f.read()
 #不建议捕获所有的异常， 因能不能定位错误的位置.
except:
    print('捕获所有的异常')
else:
    print('如果没有捕获到异常，执行else语句')
finally:
    f.close()
    print('有无异常都会执行')

捕获多个异常

异常处理

assert(断言)

NameError,KeyError

 #try:
     #d=dict(a=1,b=2)
     #print(a)
     #print(d['f'])
 #except KeyError as e:
     #print(e)
 #except NameError as e:
     #print(e)
 #else:
     #print('没有产生异常')
 #finally:
     #print('无论是否产生异常的清理操作')
 #print('new start')

try:
    d = dict(a=1, b=2)
    print(d['f'])  # KeyError
    print(a)  # NameError
except (KeyError, NameError) as e:
    print(e)
else:
    print("没有产生异常")
finally:
    print("无论是否产生异常的清理操作")
print("new start")

抛出异常和触发异常

raise:关键字，用来抛出异常

raise 抛出异常的名称，抛出异常的详细显示

def get_age(age):
    if 0<age<=200:
        print(age)
    else:
        #如果raise抛出异常，程序后面的代码不会在执行
        raise Exception('invaild age')
get_age(100)
get_age(1000)

自定义异常类

所有的异常实际上是一个类，所以异常的父类都是BaseException

IOError,IndexError,KeyError,FileExistsError

class AgeError(BaseException):
    pass
def get_age(age):
    if 0<age<=200:
        print(age)
    else:
    # 如果raise抛出异常， 程序后面的代码不会再执行.
        raise AgeError('invaild age')
#get_age(1000)
#get_age(100)

抛出异常与继承

class B(Exception):
    pass
class C(B):
    pass
class D(C):
    pass
for cls in [B, C, D]:
    try:
        # 抛出异常
        raise cls()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

扫描二维码关注公众号，回复： 3344795 查看本文章

logging模块

import logging
s='0'
n=int(s)
#### 配置日志的信息:
####  1). 日志级别: debug, info, warning, error, critical
####   2). level: 指日志级别为info及以上的日志信息会被记录到文件中;
####   3). format： 指定日志的格式， 可以去logging.Formatter查看参考信息
logging.basicConfig(filename='hello.log',level=logging.INFO,
                    format='%(asctime)s - %(filename)s[%(lineno)d] - %(levelname)s:%(message)s')
logging.debug('this is a debug info ')
logging.info('this is a info')
logging.warning('this is a warning info')
logging.info('n=%d' %n)
print(10/n)

pdb调试代码

import  sys
print(sys.argv)
import  logging
logging.Formatter