PythonMan（十）

标签：

Hello Python ：）

内置函数（BIF）：
　　issubclass(class , classinfo)
　　　　a）一个类可以被认为是自己的子类
　　　　b）classinfo可以是一个有类对象组成的元组，只要class与其任意一个候选类有继承关系，则返回True，否则False

　　isinstance(object , classinfo)
　　　　a）如果第一个参数不是对象。则永远False
　　　　b）第二个不是类或者类组成的元组，也是永远False

　　hasattr(object , name)
　　　　检测一个对象里面是否有指定的属性,name要用字符串，即引号包裹一下

　　getattr(object , name[,default])
　　　　...

　　setattr(object , name , value)
　　　　...

　　delattr(object , name)
　　　　...

　　property()
　　　　通过属性来设置属性，比较变态的BIF
　　　　　　class Test:
　　　　　　　　def __init__(self ,size = 10):
　　　　　　　　　　self.size = size
　　　　　　　　def getSize(self):
　　　　　　　　　　return self.size
　　　　　　　　def setSize(self , value):
　　　　　　　　　　self.size = value
　　　　　　　　def delSize(self):
　　　　　　　　　　del self.size
　　　　　　　　x = property(getSize , setSize , delSize)
　　　　　　　　

　　　　　　test = Test()
　　　　　　test.x #获取size的值
　　　　　　test.x = 15 #通过x设置size的值
　　　　　　del test.x #通过x来删除size的值

　　　　综上，这个property函数依次传入get，set，del参数，并且返回一个属性，通过这个返回的属性可以操控这个类中的属性。
　　　　　　用法：
　　　　　　　　Test类慢慢复杂起来了，要进行大改（比如改函数名字），那这样提供给user的名字就要更改，这样就很不好，那这时候property函数就有了很大用途。

构造和析构：
　　构造：__init__(self[,...]) 、 __new__(cls[,...])
　　　　Python在实例化一个对象时，第一时间是调用__new__()这个方法，第一个参数是类，后面如果有参数的话，这些参数会原封不动的传递给__init__()。一般来说这个方法我们没有重写的必要，但在有些特定场合下，需要对它进行重写，比如：我们继承了一个不可改变的类，又要进行更改的时候。例子：
　　　　　　class CapStr(str):
　　　　　　　　def __new__(cls,string):
　　　　　　　　　　string = string.upper()
　　　　　　　　　　return str.__new__(cls,string)

　　　　　　a = CapStr("kepler")
　　　　　　print(a)
　　　　　　#输出KEPLER

析构：__del__(self)
　　当对象被垃圾回收器回收时，会调用这个方法。
　　细节：del x 不等于 x.__del__()

魔法方法：__str__()、__repr__():

　　class A:
　　　　def __str__(self):
　　　　　　return "Kepler"
　　a = A()
　　print(a) #输出Kepler

　　class B:
　　　　def __repr__(self):
　　　　　　return "Kepler"

　　b = B()
　　b #输出Kepler

计时器代码：
　　细节：要引入Time模块 以下代码是import Time as t

迭代：
　　每次从容器中拿出一个数据，这就是迭代，for语句可以触发迭代功能，字典、文件、字符串都是支持迭代功能的。

　　　　iter()、next()
　　　　　　string = "Kepler"
　　　　　　it = iter(string)
　　　　　　next(it)
　　　　　　#返回K

　　　　所以，for的工作原理：
　　　　　　string = "Kepler"
　　　　　　it = iter(string)
　　　　　　while:
　　　　　　　　try:
　　　　　　　　　　each = next(it)
　　　　　　　　except StopIteration:
　　　　　　　　　　break
　　　　　　　　print(each)

　　想要自定义的类实现迭代，就要实现__iter__() , __next__():
　　　　实现斐波那契数列：
　　　　　　class Fibs:
　　　　　　　　def __init__(self):
　　　　　　　　　　self.a = 0
　　　　　　　　　　self.b = 1

　　　　　　　　def __iter__(self):
　　　　　　　　　　return self

　　　　　　　　def __next__(self):
　　　　　　　　　　self.a , self.b = self.b , self.a + self.b
　　　　　　　　　　return self.a

　　　　　　test = Fibs()
　　　　　　　　for data in test:
　　　　　　　　　　if data < 100 :
　　　　　　　　　　　　print(each)
　　　　　　　　　　else:
　　　　　　　　　　　　break

　　　　　　#这样就会输出100以内的斐波那契数列

生成器：yield,是特殊的迭代器
　　　yield使得Python的协同程序得以实现，所谓协同程序：可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始
　　　　案例代码：
　　　　　　def myGen():
　　　　　　　　print("Begin")
　　　　　　　　yield 1
　　　　　　　　yield 2

　　　　　　>>> my = myGen()
　　　　　　>>> next(my)
　　　　　　Begin
　　　　　　1
　　　　　　>>> next(my)
　　　　　　2
　　　　　　>>> next(my)
　　　　　　Traceback (most recent call last):
　　　　　　File "<pyshell#8>", line 1, in <module>
　　　　　　next(my)
　　　　　　StopIteration

列表推导式：
　　　　>>> a = [data for data in range(10)]
　　　　>>> a
　　　　[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

字典推导式：
　　　　>>> dic = {i : i % 2 == 0 for i in range(10)}
　　　　>>> dic
　　　　{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

集合推导式：
　　...

细节：注意没有字符串推导式：）

PythonMan（十）

标签：

原文地址：http://www.cnblogs.com/AirStark/p/5722854.html