Python的平凡之路

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python的平凡之路相关的知识,希望对你有一定的参考价值。

一、面向对象高级语法部分
 
1、静态方法、类方法、属性方法                                                                         
a 静态方法名字上归类管,实际上在静态方法里访问不了类或实例中的任意属性       
静态方法.py
 #!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-

#静态方法
class Dog(object):
    def __init__(self,name):
        self.name = name

    @staticmethod #把eat方法变为静态方法,1 调用时主动传实例本身到eat 2 去掉eat()方法中的self参数
    def eat():  #例子中取的是第二种方法
        print("chenronghua  is eating")

d = Dog("chenronghua")
#d.eat(d)也是可行的,但是eat方法中要传self参数
d.eat()
                                       
 b 类方法只能访问类变量,不能访问实例变量。    
类方法.py
#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
#类方法
#类方法只能访问类变量,不能访问实例变量
class Dog(object):
    name = "我是类变量!"
    def __init__(self,name):
         self.name = name

    @classmethod #注意缩进,要和上边的构造函数保持一致
    def eat(self):
        print("%s is eating" % self.name)

d = Dog("chenronghua")
d.eat()
                                                         
 c 属性方法就是通过@property把一个方法变成一个静态属性
 #!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
class Dog(object):
    name = ‘alex‘
    def __init__(self,name):
        self.name = name
    @property #加上此方法,可以把下边的方法看成Dog类的一个属性,一次装饰有效
    def eat(self):
        print("%s is eating" %self.name)
    @classmethod #类方法
    def drink(self):
        print("%s is drinking" %self.name)
    @staticmethod
    def full(self):
        print("%s is full up" %self.name)

d = Dog("chenronghua")
#调用属性方法下的eat属性
d.eat
#调用类方法下的drink方法
d.drink()
#调用静态方法下的eat方法
d.full(d)
 
  flight.py
#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
#对属性方法进行练习
class Flight(object):
    def __init__(self,name):
        self.flight_name = name

    def checking_status(self):
        print("checking flight %s status..." %self.flight_name)
        #return 1

    @property #静态属性
    def flight_status(self,status):
        #status = self.checking_status() #把上边的属性传递到下边?
        if status == 0:
            print("flight got canceled...")

        elif status == 1:
            print("flight is arrived...")

        elif status == 2:
            print("flight has departured already...")

        else:
            print("cannot confirm the fight status...please check later")
    @flight_status.setter #修改
    def flight_status(self,status):
        status_dic = {
         0:"canceled",
         1:"arrived",
         2:"departured"
        }
        print("\033[31;1mHas changed the flight status to \033[0m",status_dic.get(status) )
    @flight_status.deleter #删除
    def flight_status(self):
        print("status got removed...")
f = Flight("CA980")
f.checking_status()
f.flight_status = 1 #触发flight_status.setter
del f.flight_status #触发flight_status.deleter
                                                             
 2、类的特殊成员方法                                                                            
a __doc__
#__doc__表示类的描述信息,对于类下的方法是无效的。
class film(object):
    """谍影重重5已经上映了,非常不错"""
    def __init__(self,name):
        self.name = name
    def func(self):
        """这个功能还没定义,只是占个位子"""
        print("it‘s about %s" %self.name)

print(film.__doc__)
t = film(‘spy‘)
t.func()
 
b __module__和 __class__ ,前者表示当前操作的对象在那个模块,后者表示当前操作的对象的类是什么 
c __init__ 构造方法,通过类创建对象时,自动触发执行
e __del__析构方法,当对象在内存中被释放时,自动触发执行
f __call__对象后面加括号,触发执行
class Foo:
    def __init__(self):
        pass

    def __call__(self, name,*args, **kwargs):
        self.name = name
        print(‘This is __call__方法:%s‘ %self.name)
obj = Foo()  # 执行 __init__
obj(‘www.we.com‘)  # 执行 __call__
 
g __dict__
#__dict__查看类或对象中的所有成员
class Province:
    country = ‘China‘

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print(‘func‘)
# 获取类的成员,即:静态字段、方法、
print(Province.__dict__)
# 输出:{‘country‘: ‘China‘, ‘__module__‘: ‘__main__‘, ‘func‘: <function func at 0x10be30f50>, ‘__init__‘: <function __init__ at 0x10be30ed8>, ‘__doc__‘: None}
obj1 = Province(‘HeBei‘, 10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员
# 输出:{‘count‘: 10000, ‘name‘: ‘HeBei‘}
obj2 = Province(‘HeNan‘, 3888)
print(obj2.__dict__)
# 获取 对象obj1 的成员
# 输出:{‘count‘: 3888, ‘name‘: ‘HeNan‘} 
 
h __str__
#__str__表示如果类中定义了此方法,那么在打印对象的时候,默认输出该方法的返回值
class Foo:
    def __str__(self):
        return ‘这是要返回的值!‘

obj = Foo()
print(obj)
# 输出:这是要返回的值
 
i __getitem__ __setittm__ __delitem__
#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-

class Foo(object):
    def __getitem__(self,key):
        print(‘__getitem__‘,key)

    def __setitem__(self,key,value):
        print(‘__setitem__‘,key,value)

    def __delitem__(self,key):
        print(‘___delitem__‘,key)

obj = Foo()

result = obj[‘k1‘]
obj[‘k2‘] = ‘alex‘
del obj[‘k1‘]
 
j __new__\ __metaclass__
(略)
 
k  动态导入模块
import importlib
 
__import__(‘import_lib.metaclass‘#这是解释器自己内部用的
#importlib.import_module(‘import_lib.metaclass‘) #与上面这句效果一样,官方建议用这个
 
l 反射
#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
#hasattr 和 getattr都是内建函数
class A:
def __init__(self):
self.name = ‘zhangjing‘
#self.age = 24

def method(self):
print("method print")

Instance = A()
print(getattr(Instance,‘name‘,‘not find‘)) #如果Instance对象中有属性
#name则打印self.name的值,否则就打印‘not find
print(getattr(Instance,‘age‘,‘not find‘)) #如果Instance对象中有属性age则打印self.age的值,否则打印‘not find‘
print(getattr(A,‘method‘,‘default‘)) #如果有方法method,就打印其地址,否则打印default
#print(getattr(A,‘method‘,‘default‘))() #如果有方法method,运行函数并打印None否则打印default

#hasattr getattr setattr练习
class Employee:
‘所有员工的基类‘
empCount = 0

def __init__(self, name, salary):
self.name = name
self.salary = salary
#加1
Employee.empCount += 1

def displayCount(self):
print("Total Employee %d" % Employee.empCount)

def displayEmployee(self):
print("Name : ", self.name, "\nSalary: ", self.salary)

Xiaoxiao = Employee(‘Xiaoxiao‘, 2000)
setattr(Xiaoxiao, ‘age‘, 21)

Tiny = Employee("Tiny", 5000)
setattr(Tiny, ‘age‘, 23)

print("实例类的第一个对象 Xiaoxiao ");
print(‘Xiaoxiao 是否存在age属性:‘, hasattr(Xiaoxiao, ‘age‘))
Xiaoxiao.displayEmployee();
print("Age:", getattr(Xiaoxiao, ‘age‘, ‘not find‘));
#对象中是否有SEX属性,有就返回值,没有就返回not find
print("Sex:", getattr(Xiaoxiao, ‘sex‘, ‘not find‘));
print("\n")

print("实例类的第二个对象 Tiny")
print(‘Tiny 是否存在age属性:‘, hasattr(Tiny, ‘age‘))
Tiny.displayEmployee()
print("Age: ", getattr(Tiny, ‘age‘, ‘not find‘));

print("\n")
print("Total Employee number: %d" % Employee.empCount)
print("\n")
总结:                                                                      
   1 hasattr(object,name_str) 判断一个对象里是否有对应的字符串的方法                                      
   2 getattr(),根据字符串去获取obj对象里的对应的XX方法、                                                 
   3 setattr()                                                                         
   4 dela ttr()                                                                        
 
 3、异常处理(异常是Python对象,表示一个错误)   
   try的工作原理是,当开始一个try语句后,python就在当前程序的上下文中作标记,这样当异常出现时就可以回到这里,try子句先执行,接下来会发生什么依赖于执行时是否出现异常。try子句中的代码块放置可能出现异常的语句,except子句中的代码块处理异常
如果当try后的语句执行时发生异常,python就跳回到try并执行第一个匹配该异常的except子句,异常处理完毕,控制流就通过整个try语句(除非在处理异常时又引发新的异常)。
  • 如果在try后的语句里发生了异常,却没有匹配的except子句,异常将被递交到上层的try,或者到程序的最上层(这样将结束程序,并打印缺省的出错信息)。
  • 如果在try子句执行时没有发生异常,python将执行else语句后的语句(如果有else的话),然后控制流通过整个try语句
异常处理.py
 #!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
"""import sys,traceback
try:
    a = 1
    b = a
    c = w
except Exception as e:
    print(Exception,":",e)

try:
    a = b
    b = c
except:
    f = open(‘log.txt‘,‘a‘)
    traceback.print_exc(file=f)
    f.flush()
    f.close()
"""
try:
    fh = open(‘testfile‘,‘w‘)
    fh.write("这是一个测试文件,用于测试异常!")
except IOError:  #捕获IO异常
    #testfile的权限已经变了,所以会报错
    print("Error: 没有找到文件或读取文件失败")
else:
    print("内容写入文件成功")
    fh.close()
 
#使用raise抛出异常
#当程序出现错误,python会自动引发异常,也可以通过raise显示地引发异常。一旦执行了raise语句,raise后面的语句将不能执行。
#演示raise用法
try:
     s = None
     if s is None:
         print "s 是空对象"
         raise NameError     #如果引发NameError异常,后面的代码将不能执行
     print(len(s))
except TypeError:
     print "空对象没有长度"
 
#自定义异常
#python允许程序员自定义异常,用于描述python中没有涉及的异常情况,自定义异常必须继承Exception类,自定义异常按照命名规范##以"Error"结尾,显示地告诉程序员这是异常。自定义异常使用raise语句引发,而且只能通过人工方式触发。
from __future__ import division
 
class DivisionException(Exception):
      def __init__(self, x, y):
            Exception.__init__ (self, x, y)       #调用基类的__init__进行初始化
            self.x = x
            self.y = y
 
if __name__ == "__main__":
      try:
            x = 3
            y = 2
      if x % y > 0:                               #如果大于0, 则不能被初始化,抛出异常
            print x/y
            raise DivisionException(x, y)
except DivisionException,div:                     #div 表示DivisionException的实例对象
      print "DivisionExcetion: x/y = %.2f" % (div.x/div.y)

以上是关于Python的平凡之路的主要内容,如果未能解决你的问题,请参考以下文章

Python的平凡之路(22)

Python的平凡之路(16)

Python的平凡之路

Python的平凡之路

平凡之路2:python基础知识

平凡之路之小美