learn_Day14 内置函数补充、反射、初识面向对象

内置函数

__import__（）用于导入模块
getattr 用于寻找模块的指定对象
- a = __import__(‘b’) # b为模块名,b是字符串 ==>> 导入模块b并重新命名为a
- c = getattr(a,’d’) # d为模块中指定对象 ==>> 找到模块中命名为d的对象
- d() ==>> 执行d

# getattr(a,’b’, c)  # 从a模块中导入b。c参数可不写表示找不到报错；c为None表示找不到不报错，返回None。
# hasattr(a,’b’)  # 判断a中b模块是否存在。
# setattr(a,’b’, c)  # 在内存中我模块a创建b=c。
# delattr(a,’b’)  # 在内存中删除模块a中的b。

反射

定义：根据字符串去某个对象中去操作其成员

通过字符串形式导入模块
通过字符串形式去模块中寻找并执行

例1：导入lib/account中的a并执行

# /usr/local/bin/python
# -*- coding: utf-8 -*-
# Author: Ren Hang


def login():
    return "login"


def logout():
    return "logout"


def nb():
    return "niu"

lib/accoutn/a

例2：模拟web框架

# 模拟web框架
from lib.account import a
url = input("shuru：")
inp = url.split('/')[-1]
if hasattr(a, inp):
    target_func = getattr(a, inp)
    r = target_func()
    print(r)
else:
    print("404")

初识面向对象

# 面向对象：不是所有的情况都适用
# c#、java只能用面向对象进行编程，Python即可以用函数编程也可以用面向对象编程
# 函数编程比较繁琐，面向对象比较方便

# 面向对象编程过程
# 创建类（用于封装函数）
class xxx:
    def f1(self):
        print("f1")

    def f2(self):
        print("f2")

    def f3(self):
        print("f3")

    def f4(self):
        print("f4")


# 根据类创建对象，使用对象去执行类中的方法
a = xxx()
b = a.f1()

封装的应用场景：

1.当同一类型的方法具有相同的参数时直接封装到对象即可

2.以类当做模板，创建多个对象，对象可以封装不同的数据

# 方法1
class ooo:
    def o1(self):
        print(self.b1)

    def o2(self):
        print(self.b1)


obj1 = ooo()  # 创建对象
obj1.b1 = "abc"  # 在对象中封装数据
obj1.o1()  # 执行类的方法，在执行过程中可以根据self去obj1中去提取封装里面的数据

obj2 = ooo()
obj2.b1 = "xxx"
obj2.o2()

# 方法1

# 方法2：__init__构造方法
# 通过对象直接调用
class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age


obj1 = Foo("ooo", 18)
print(obj1.name, obj1.age)
obj2 = Foo("xxx", 19)
print(obj2.name, obj2.age)


# 通过self间接调用
class Foo:
    def __init__(self, name, age):
        self.n = name
        self.a = age

    def fo(self):
        print(self.n)
        print(self.a)


obj1 = Foo("ooo", 18)
obj1.fo()
obj2 = Foo("xxx", 19)
obj2.fo()

方法2

继承：

1.派生类可以继承基类的所有东西，如果基类与派生类同时存在这个东西，优先派生类

2.在Python中一个派生类可以继承多个基类，其他语言中只能继承一个基类

3.派生类在继承多个基类时，按照指定循序寻找，如图所示：

注：蓝色箭头为继承循序，红色箭头为继承关系

# 继承
class Animals:  # 基类
    def chi(self):
        print("吃")

    def he(self):
        print("喝")


class Dog(Animals):  # 派生类
    def __init__(self, name):
        self.na = name

    def jiao(self):
        print(self.na + "wang")


a = Dog("wangwnag")  # 创建派生类对象
a.chi()  # 执行基类方法
a.he()
a.jiao()

# 继承

多态：多种形态。Python本身支持多态

class Foo:
    def f1(self):
        print("Foo")


class Bar:
    def f1(self):
        print("Bar")


def func(arg):
    arg.f1()


func(Foo())
func(Bar())

扩展（其他语言）：

-重载：函数名相同，参数个数不同

-重写：在派生类中重新实现基类中的方法

　 -接口：Java、c#等其他语言（首字母为I），在Python中默认不存在，用于约束，不能实现任何功能，如果派生类继承接口则派生类必须实现接口内的每一个功能

练习

# /usr/local/bin/python
# -*- coding: utf-8 -*-
# Author: Ren Hang


"""
会员信息
会员A: 会员号:HY0001,积分：3
会员B: 会员号：HY0002,积分：5
会员C: 会员号：HY0003,积分：10

购买一次商品 + 1 分，退一次商品 - 1 分
"""


class Member:
    """Name：姓名, MemberNo：会员号, Integral：积分"""

    def __init__(self, Name, MemberNo, Integral):
        self.name = Name
        self.no = MemberNo
        self.integral = Integral

    def buy(self):
        """注释：购买商品"""

        self.integral = self.integral + 1

    def retreat(self):
        """注释：退货"""

        self.integral = self.integral - 1

    def detail(self):
        """注释：会员的详细信息"""

        temp = "姓名:%s ; 会员号:%s ; 积分:%s" % (self.name, self.no, self.integral)
        print(temp)


# 员工信息
HYA = Member('Aa', "HY0001", 3)  # 创建苍井井角色
HYB = Member('B', "HY0002", 5)  # 创建东尼木木角色
HYC = Member('C', "HY0003", 10)  # 创建波多多角色
# 输出原始信息
print("原始信息".center(30, "-"))
HYA.detail()
HYB.detail()
HYC.detail()
# 开始记录
print("第一次记录".center(30, "-"))
HYA.buy()  # 会员A买了一次
HYB.retreat()  # 会员B退了一次
HYC.buy()  # 会员C买了一次

# 输出当前所有人的详细情况
HYA.detail()
HYB.detail()
HYC.detail()

print("第二次记录".center(30, "-"))
HYA.buy()  # 会员A买了一次
HYB.buy()  # 会员B买了一次
HYC.retreat()  # 会员C退了一次

# 输出当前所有会员的详细信息
HYA.detail()
HYB.detail()
HYC.detail()