python 3day 静态调用 继承 列表式 生成器 装饰器 闭包

一.静态调用

如果类中需要非该类成员存在,则可以使用静态调用的方法@staticmethod

class A(object):
    @staticmethod
    def is_valid(j):
        print(j)
    def hui(self):
        print('love')
a1 = A()
a1.is_valid('100')

100

 

输入四条边判断它是否为正方形，如果是计算面积：

class Fang(object):
    def __init__(self,a,b,c,d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d
    @staticmethod
    def is_valid(a,b,c,d):
        for i in [b,c,d]:
            if i != a:
                return Flase
            else:
                return True
    def area(self):
        if res == True:
            area_ = self.a * self.b
            return area_
fang = Fang(3,3,3,3)
res = fang.is_valid(3,3,3,3)
if res == True: 
    print(fang.area())

9

 

和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象。

"""
@classmethod:获取自身类(cls)中的属性,并且可以更改.
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等
"""
from time import time, localtime, sleep
class Clock(object):
    """数字时钟"""
    def __init__(self, hour=0, minute=0, second=0):
        self._hour = hour
        self._minute = minute
        self._second = second
    @classmethod
    def now(cls):
        ctime = localtime(time())
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0
    def show(self):
        """显示时间"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)
def main():
    # 通过类方法创建对象并获取系统时间
    clock = Clock.now()
    while True:
        print(clock.show())
        sleep(1)
        clock.run()
if __name__ == '__main__':
    main()


时间一直变化

 

二.继承

刚才我们提到了，可以在已有类的基础上创建新类，这其中的一种做法就是让一个类从另一个类那里将属性和方法直接继承下来，从而减少重复代码的编写。提供继承信息的我们称之为父类，也叫超类或基类；得到继承信息的我们称之为子类，也叫派生类或衍生类。子类除了继承父类提供的属性和方法，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力，在实际开发中，我们经常会用子类对象去替换掉一个父类对象

 

class A(object):
    def __init__(self):
        self.a = 520
        # self.a = a
    def A1(self):
        print('A1')
#在类名中写上继承的类
class B(A):
    def __init__(self):
        A.__init__(self)
        self.a = 1314
    def B1(self):
        print('B1')
b = B()
print(b.a)
b.A1()

1314
A1

 

 

创建一个父类，创一个子类，父类计算两个数字的和记为sum，子类打印这个sum.

class A(object):
    def __init__(self):
        self.a = 10
        self.b = 10
    def sum(self):
        SUM = self.a + self.b
        return SUM
class B(A):
    def __init__(self):
        A.__init__(self)
    def print(self):
        res = self.sum()
        print(res)
c = B()
c.print()

20

 

三.列表生成式

a = (x for x in range(10) if x % 2== 0)
for i in range(5):
    print(next(a))

0
2
4
6
8

 

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

 

四.生成器

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

五.函数闭包

将函数内部的嵌套函数引入到全局环境中使用

该包内的环境变量不受外部环境的影响

 

#带参数的闭包
def foo():
    l = []
    def bar(i):
        l.append(i)
        return l
    return bar
f1 = foo()
res1 = f1(1)
print(res1)

[1]

 

def foo():
    def bar():
        def bar2():
            return'huihuiya'
        return bar2
    return bar
f1 = foo()
print(f1)
f2 = f1()
print(f2())

huihuiya

 

六.装饰器

用于拓展原来函数功能的一种函数，目的是在不改变原函数名(或类名)的情况下，给函数增加新的功能。 

这个函数的特殊之处在于它的返回值也是一个函数，这个函数是内嵌“原“”函数的函数。

 

 

def deco(func):
    def warp():
        print('tutu')
        return func()
    return warp
@deco
def tutu():
    pass
tutu()

tutu

 

 

创建一个装饰器，包含1个函数（2个参数),用装饰器处理连个数的和，并打印这两个数

def hao(func):
    def warp(num1,num2):
        print('num1 + num2',num1 + num2)
        return func(num1,num2)
    return warp
@hao
def sum(num1,num2):
    print(num1,num2)
sum(111,222)

num1 + num2 333
111 222

装饰器将前两个数字求和，函数本身第三个参数乘钱两个数的和

def hao(func):
    def warp(num1,num2,num3):
        num = num1 + num2
        #print('num1 + num2',num1 + num2)
        return func(0,num,num3)
    return warp
@hao
def sum(num1,num2,num3):
    print(num1,num2,num3)
    print(num2 * num3)
sum(12,2,5)

0 14 5
70

 

转载于:https://www.cnblogs.com/liwenhui/p/11322776.html