python__魔法方法

魔法方法总是被双下划线包围：例：init
它们总能够在适合当的时侯被自动调用

构造和析构
init(self[,……]) ：对象初始化时会自动调用

class  Rectangel:
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def getPeri(self):
        return (self.x+self.y) *2

    def getArea(self):
        return self.x * self.y


rect = Rectangel(3,4)
print rect.getArea()
print rect.getPeri()

new(class[,……])：对象实例时会自动调用的第一个方法，传入的参数会原封不动的传给 init 方法 ，返回一个实例对象

#全部转为大写字母
class CapStr(str):
    def __new__(cls,string):
        string = string.upper()
        return str.__new__(cls,string)

a = CapStr("abck")

print a

del(self) :当对象被销毁的时侯，会自动调用这个方法，垃圾回收的时侯
而不是当用 del 方法调用

class A():
    def __str__(self):
        return "帅哥"

class B():
    def __repr__(self):
        return "小哥"

a = B()
print(a)
小哥

计时器
import time as t
class MyTime():

    def __init__(self):
        self.unit = ['年','月','天','小时','分','秒']
        self.prompt = "未开始计时"

        self.lasted =[]
        self.begin = 0
        self.end = 0  


    #实现直接输入对象引用来打印字符口串
    def __str__(self):
        return self.prompt

    __repr__ = __str__


    #计算加法：
    def __add__(self,other):
        prompt ="总共运行了"
        result =[]
        for index in range(6):
            result.append(self.lasted[index] + other.lasted[index])
            if result[index]:
                prompt +=(str(result[index])+self.unit[index])
        return prompt


    #开始计时
    def start(self):
        self.begin = t.localtime()
        self.prompt = "提示：请先调用 stop() 停止计时"
        print("计时开始")

    #停止计时：
    def stop(self):
        if not self.begin:
            print("提示：请先调用 start() 进行计时")
        else:
            self.end = t.localtime()
            self._calc()
            print("计时结束")

    #计算运行时间
    def _calc(self):
        self.lasted =[]
        self.prompt = "总共运行了"
        for index in range(6):
            self.lasted.append(self.end[index] - self.begin[index])
            if self.lasted[index]:
                self.prompt +=(str(self.lasted[index])) +self.unit[index]            

        #为下一轮计时初始化
        self.begin =0
        self.end = 0
>>> t1 = MyTime()
>>> t1.stop()
提示：请先调用 start() 进行计进
>>> t1.start()
计时开始
>>> t1.stop()
计时结束
>>> t1
总共运行了8秒
>>> t2 = MyTime()
>>> t2.start()
计时开始
>>> t2.stop()
计时结束

>>> t2+t1
'总共运行了14秒'

属性访问：

class Rectangle:
    def __init__(self,width=0,height=0):
        self.width = width
        self.height = height

    #重写设置 属性的方法:因为初始化时进行了赋值，所以会自动调用这个方法，也就是只要进行赋值就会调用这个方法
    def __setattr__(self,name,value):
        if name =='square':
            self.width = value
            self.height = value
        else:
            super().__setattr__(name,value)  
            //self.__dict__[name] = value

    def getArea(self):
        return self.width * self.height

>>> r = Rectangle(4,5)
>>> r.getArea()
20
>>> r.square =10
>>> r.getArea()
100

模拟property
class Myproperty:
    def __init__(self,fget=None,fset=None,fdel=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel

    def __get__(self,instance,owner):
        return self.fget(instance)

    def __set__(self,instance,value):
        self.fset(instance,value)

    def __del__(self,instance):
        self.fdel(instance)


class C:
    def __init__(self):
        self._x=None

    def getX(self):
        return self._x

    def setX(self,value):
        self._x = value

    def delX(self):
        del self._x

    x = Myproperty(getX,setX,delX)

>>> c=C()
>>> c.x
>>> c.x="x-min"
>>> c.x
'x-min'

#
class Celsius:
    def __init__(self,value =26.0):
        self.value = float(value)


    def __get__(self,instance,owner):
        return self.value

    def __set__(self,instance,value):
        self.value = float(value)


#多少华氏度
class Fashrenheit:
    def __get__(self,instance,owner):
        return instance.cel * 1.8 + 32

    def __set__(self,instance,value):

        #传入的instance 就是 Temperature 类的实例，这样就可以又将值赋给cel这个变量
        #从而又得到转化后的结果
        instance.cel = (float(value) - 32) / 1.8



class Temperature:
    cel = Celsius()     #描述符类
    fah = Fashrenheit() #描述符类

>>> temp =Temperature()
>>> temp.cel =30  #就会自动找Celsius()这个类的set方法，也就是类中的描述符方法
>>> temp.fah      #就会自动找Fashrenheit() 这个类的get 方法,得到转化后的结果
86.0

class CountList:
    #接收多个参数
    def __init__(self,*agrs):
        # 将列表中的每一个索引作为key，并填充相同的值 
        self.values = [ x for x in agrs]
        self.count = {}.fromkeys(range(len(self.values)),0) #记每一个下标的访问次数

     # 定义容器是不可变的   
    def __len__(self):
        return len(self.values)

    def __getItem(self,key):
        self.count[key] += 1
        return self.values[key]

字符即是容器又是序列

 string = "fishc"
>>> it = iter(string)  #获取迭代器
>>> it.net()
next(it)
'f'

#实现类似于 for的循环迭代
while True:
    try:
        each=next(it)
    except StopIteration:
        break
    print(each)


i
s
h
c

it ="java"
for each in it:
    print(each)


j
a
v
a

class Fibs:
    def __init__(self,n=10):
        self.a = 0
        self.b = 1
        self.n = n
    def __iter__(self):
        return self

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

        if(self.a>self.n):
            raise StopIteration
        return self.a

>>> fibs = Fibs()
for each in fibs:
    print(each)


1
2
3
5
8

生成器 是一种迭代器的一种

def myGen():
    print("生成器被执行了")
    yield 1
    yield 2

my = myGen()
>>> next(my)
生成器被执行了
1

>>> def libs():
    a = 0
    b = 1

    while True:
        a,b = b,a+b
        yield a


>>> for each in libs():
    if each > 100:
        break
    print(each,end=' ')


1123581321345589

列表推导式
>>> a = [i for i in range(100) if not(i%2) and i % 3]
>>> a
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]

字典推导式
>>> b ={i:i%2 == 0 for i in range(10)}
>>> b
#索引为偶数的都为true
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

#集合推导式
>>> a = {i for i in [1,1,2,3,4,4,4,5]}
>>> a
{1, 2, 3, 4, 5}

#函数推导式
{1, 2, 3, 4, 5}
>>> e = (i for i in range(10))
>>> next(e)
0
>>> next(e)
1

#元组推导式
>>> a = sum((i for i in range(100) if i % 2))
>>> a
2500