2019年8月8日（面向对象编程进阶2）

1、静态方法和类方法

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

# 静态方法和类方法都是通过给类发消息来调用的

# 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数

class A(object):
    @staticmethod
    def a():
        print('a')
a1 = A()
a1.a()
 
a

案例1：

#输入四条边，判断它是否是一个正方形

#如果是：计算面积

class zhengfangxing(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):
            area_ = self.a * self.b
            return area_
def amin():          
    zhengfangxing = zhengfangxing(2,2,2,2)
    res = zhengfangxing.is_valid(2,2,2,2)
    if res == True:
        print(zhengfangxing.area())
amin()

"""

from time import time,localtime,sleep

#时间戳，从1970年1月1号00.00.00秒开始到现在经历过的秒速。
print(localtime(time()))

"""

2、继承和多态

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

案例2：

#创建一个父类，创建一个子类

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

#子类打印这个SUM_

class A(object):
    def __init__(self):
        self.a = 100 self.a1 = 200 def sum_(self): SUM_ = self.a + self.a1 return SUM_ class B(A): def __init__(self): A.__init__(self) def Print(self): res = self.sum_() print(res) b = B() b.Print() 300

class A(object):
    def __init__(self,a1):
        self.a = 100
        self.a1 = a1
    def sum_(self):
        SUM_ = self.a + self.a1
        return SUM_
class B(A):
    def __init__(self,a1,b1):
        A.__init__(self,a1)#supper(A,self),_init(a1)
    def Print(self):
        res = self.sum_()
        print(res)
b = B(1000,'100')
b.Print()

1100

#用类方法就可以改变类的属性

class A(object):
    def __init__(self):
        self.joker = 100
    @classmethod
    def a(cls):
        return cls()
joker = A.a()
print(joker)
joker2 = A()
joker2.joker_1 = 1000
print(joker2)


<__main__.A object at 0x000001FC2D822E10>
<__main__.A object at 0x000001FC2D822F28>

案例3：

#用类封装3个功能

wxpy:用Python玩微信

1、对于特定好友自动回复文本和图片

2、封装一个统计微信中性别数量和总人数的比例，男生的比例，女生的比例，未知性别比例

3、统计你的好友都属于哪个省份并绘制直方图

3、列表生成式

1）解耦合

test：

def foo():
    l = []
    def bar(i):
        l.append(i)
        return l
    return bar
f1 = foo()
res1 = f1(1)
print(res1)
res2 = f1(2)
print(res2)

test1：

ef deco(func):
    def warp(H):
        print('Joker')
        return func(H)
    return warp
@deco
def Joker(name):
    print('hello %s'%name)

Joker('huwang')

2）装饰器

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)

3）列表生成式

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

优点: 计算速度快,因为一次性已经全部加载到内存中了,适合数据量不是太大的情况10000- 2000-
缺点: 占用内存

4）生成器

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

5）函数闭包

案例4：

#创建一个装饰器，三个函数（两个参数）
#装饰器处理这两个参数的和，并打印

#每一个函数打印这两个参数

def Joker(func):
    def warp(num1,num2):
        print('num1+num2=',num1 + num2)
        return func(num1,num2)
    return warp
@Joker
def SUM(num1,num2):
    print(num1,num2)
SUM(100,200)


num1+num2= 300
100 200

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)


0 12 3
36

2019年8月8日（面向对象编程进阶2）

猜你喜欢