面向对象的进阶2

一、静态调用和类的调用

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

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

class Zfx (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 False
            else:
                return True 
    def area(self):
        if res == True:
            area_=self.a*self.b
            return area_
zfx=Zfx(8,8,8,8)
res = zfx.is_valid(8,8,8,8)
if res==True:
    print(zfx.area())

输出：64

2、@classmethod:获取自身类(cls)中的属性,并且可以更改.
      classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等

 例题：

class A(object):
    def __init__(self):
        self.jxh = 100
    @classmethod
    def a(cls):
        return cls()
c = A.a()
print (c.jxh)

输出：100

3、

from time import time,localtime,sleep
print(time())

输出：1565255554.80476

输出的是时间戳，是从1970年1月1号00.00.00秒到现在2019/8/817:18:25秒整理过的秒速

二、继承

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

输出:100
     A1

例题1：创建一个父类和一个子类

             父类计算两个数字的和为SUM_

              子类打印这个SUM_

class A(object):   #A父类
    def __init__(self):
        self.a=10
        self.a1=20
    def sum_(self):
        SUM_=self.a+self.a1
        return SUM_
class B(A):  #B继承A
    def __init__(self):
        A. __init__(self) #继承A中所有
    def B1(self):
        res = self.sum_()
        print(res)
b=B()
b.B1()

输出：30

三、

1、列表生成式----[ ]

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-
缺点: 占用内存

2、列表生成器----（ ）

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

四、函数闭包

 所谓的函数闭包本质是函数的嵌套和高阶函数。我们来看看要实现函数闭包要满足什么条件（缺一不可）：

1)必须嵌套函数
2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量
3)外部函数必须返回内嵌函数——必须返回那个内部函数

 闭包的作用：可以保持程序上一次运行后的状态然后继续执行。

实例如下：

 

def foo( ):
    def bar( ):
        return 'hello'
    return bar( )
a = foo( )
print (a)

输出：hello

 

五、装饰器
实例1：创建一个装饰器，一个函数（两个参数）
      用装饰器处理两个参数和，并打印

def deco(func):
    def warp(a1,a2):
        print('a1+a2',a1+a2)
        return func(a1,a2)
    return warp
@deco
def SUM(a1,a2):
    print(a1,a2)
SUM(100,100)

输出 a1+a2 200

 

实例2:

def jxh(func):
    def warp(n1,n2,n3):
        num = n1 + n2 
        return func(0,num,n3)
    return warp
#装饰器将前两个数字求和,函数本身第三个参数乘上这个和
@jxh
def SUM(num1,num2,num3):
    print(num1,num2,num3)
    print(num2 * num3)
    
SUM(10,2,3)

输出：0  12  3
     36