静态类及列表生成式

列表生成式

# 列表生成式

a = (x for x in range(100000000000) if x % 2== 0)
for i in range(100):
    print(next(a))
"""
列表生成式

# 列表生成式

a = [x for x in range(100000000000) if x % 2== 0]
优点: 计算速度快,因为一次性已经全部加载到内存中了,适合数据量不是太大的情况10000- 2000-
缺点: 占用内存

# 生成器

a = (x for x in range(100000000000) if x % 2== 0)
优点: 节约内存空间
缺点: 计算速度慢,因为要生成.
"""
import os

path = '/Users/joker/jokers/DataSet/stanford-dogs-dataset/Annotation'
res = os.listdir(path)
print(res)
genter = (dir_ for dir_ in res)
print(next(genter))

# 装饰器

def Joker(func):

​    def warp(n1,n2,n3):

​        num = n1 + n2

​        return func(0,num,n3)

​    return warp



*装饰器将前两个数字求和,函数本身第三个参数乘上这个和*

@Joker

def SUM(num1,num2,num3):

​    print(num1,num2,num3)

​    print(num2 * num3)



SUM(10,2,3)

静态方法和类方法

	之前，我们在类中定义的方法都是对象方法，也就是说这些方法都是发送给对象的消息。实际上，我们写在类
	中的方法并不需要都是对象方法，例如我们定义一个“三角形”类，通过传入三条边长来构造三角形，并提供计算
	周长和面积的方法，但是传入的三条边长未必能构造出三角形对象，因此我们可以先写一个方法来验证三条边
	长是否可以构成三角形，这个方法很显然就不是对象方法，因为在调用这个方法时三角形对象尚未创建出来（因为都不知道三条边能不能构成三角形），所以这个方法是属于三角形类而并不属于三角形对象的。我们可以
	使用静态方法来解决这类问题，代码如下所示。

	from math import sqrt

	class Triangle(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

    def perimeter(self):
        return self._a + self._b + self._c

    def area(self):
        half = self.perimeter() / 2
        return sqrt(half * (half - self._a) *
                    (half - self._b) * (half - self._c))


def main():
    a, b, c = 3, 4, 5
    # 静态方法和类方法都是通过给类发消息来调用的
    if Triangle.is_valid(a, b, c):
        t = Triangle(a, b, c)
        print(t.perimeter())
        # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
        # print(Triangle.perimeter(t))
        print(t.area())
        # print(Triangle.area(t))
    else:
        print('无法构成三角形.')


if __name__ == '__main__':
    main()
 

案例1

"""
输入三个数字（私有）,求三个数字的和，
尝试更改其中两个数字
"""
class Number(object):
    def __init__(self,num1,num2,num3):
        self._num1  = num1
        self.__num2  = num2
        self.__num3  = num3
    
    @property
    def num1(self):
        print(self._num1)
    
    @num1.setter
    def(self,num):
        self._num1 = num
    
    def SUM(self):
        print(self._num1 + self.__num2 + self.__num3)


number = Number(1,2,3)
# number.num1 = 10000
number.num1 = 1000
number.SUM()

__slots__魔法

我们讲到这里，不知道大家是否已经意识到，Python是一门动态语言。通常，动态语言允许我们在程序运行时给对象绑定新的属性或方法，当然也可以对已经绑定的属性和方法进行解绑定。但是如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义__slots__变量来进行限定。需要注意的是__slots__的限定只对当前类的对象生效，对子类并不起任何作用。

class Person(object):

    # 限定Person对象只能绑定_name, _age和_gender属性
    __slots__ = ('_name', '_age', '_gender')

    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


def main():
    person = Person('王大锤', 22)
    person.play()
    person._gender = '男'
    # AttributeError: 'Person' object has no attribute '_is_gay'
    # person._is_gay = True