day 22 二十二、面向对象导入、名称空间、类与对象

一、面向对象导入

1、含义：

①面向过程：

重过程：解决问题，考虑的是解决问题的流程

解决问题的思路清晰，但拓展性不强

②面向对象：

重对象：解决问题，找到解决问题的对象

解决问题的思路可能不止一条（理解解决问题的难度增加），但拓展性强

2、python语言：面向对象的语言

python用面向过程和面向对象两种方式解决问题

函数与方法：都是解决问题的功能

函数：通过函数名直接调用

方法：通过附属者.语法来调用

变量：通过变量名访问变量值

属性：通过附属者.语法来访问变量值

3、重点：面向对象的核心体现是将数据和处理数据的程序分装到对象中

二、名称空间

# 内置 | 全局 | 局部

# import test
# print(test.__dict__)

# def func():
#     a =
#     print(locals())      # {}
# func()
# print(func.__dict__)     # {}

# a =
# print(a.__dict__)   # 会报错
# ls = [, ]
# print(ls.__dict__)  # 会报错

1、能产生名称空间的有：文件 | 函数 | 类

2、名称空间操作：所有能产生名称空间对应的对象（存放地址的变量）有__dict__这个值， 通过这个值访问到名字与地址的对应关系，__dict__指向的就是附属对象的名称空间

3、名称空间的使用

import test
print(test.num)               #
print(test.__dict__[

test.__dict__['fn']()  # fn run
test.fn()              # fn run

def func():
    pass
func.__dict__[
print(func.__dict__)            # {}

print(func.__dict__[
print(func.index)               # 

func.add = lambda x, y: x + y
print(func.__dict__)
print(func.add(, ))       # 

import re
# print(re.__dict__)

re.__dict__['name'] = 're模块'
print(re.__dict__['name'])    # re模块

re.__dict__['action'] = lambda x: x
print(re.__dict__[))    # 

def fn():
    pass
print(fn.__dict__)   # {}

fn.name = 'fn函数'
print(fn.name)     # fn函数

def test():
    print('可以成为fn功能的函数')
fn.action = test
fn.action()       # 可以成为fn功能的函数

三、类

1、类与对象的概念：

寻求一个类似函数与文件对象，可以额外添加功能与属性的对象

①类：具有相同特征与行为个体集合的抽象

②对象：有特征、行为的具体个体，就是类的具体体现

2、语法：

类和对象都拥有自己独立的名称空间，类的对象也拥有自己的名称空间，所以类和对象都可以通过.语法添加或使用属性（变量）和方法（函数）
重点：类一旦被加载(随着所属文件的加载就加载)，就会进入类的内部执行类中的所有代码

# ①类的声明：
"""
class 类名：    # class定义 类 语法的关键字
    pass
"""

# ②对象的产生：对象的实例化
"""
对象1 = 类名（）
对象2 = 类名（）
对象3 = 类名（）
"""

# ③学习重点：自定义类的实例化对象
class Student:
    pass
stu = Student()
print(id(Student))  #
print(id(stu))      # 

print(Student.__dict__)
print(stu.__dict__)

stu.__dict__['name'] = 'Bob'
print(stu.name)     # Bob

def fn():
    print('学习')
stu.study = fn
stu.study()   # 学习
"""
"""

# ④例子：
# 实例化一个Egon同学，有学习功能
# 实例化一个Liu某同学，有学习功能

class Student:
    pass
def fn():
    print('学习')

s1 = Student()
s2 = Student()
# print(id(s1), id(s2), id(Student))    #   

s1.name = 'Egon'
s1.study = fn

s2.name = 'Liu某'
s2.study = fn

print(s1.__dict__)  # {'name': 'Egon', 'study': <function fn at 0x0000000002051E18>}
print(s2.__dict__)  # {'name': 'Liu某', 'study': <function fn at 0x0000000002051E18>}

print(s1.name)   # Egon
print(s2.name)   # Liu某

3、对象查找属性的顺序：优先加载自身的名字，如果没有再考虑类的

class People:
    identify = '人类'
    def sleep(self):
        print('睡觉')
    print()
print(People.__dict__)

p1 = People()
p2 = People()

# p1,p2虽然能访问identify，但identify属于People类，只有一份
print(p1.identify)   # 人类
print(p2.identify)   # 人类

# p1修改的并不是People的identify，相对于给自己添加一个identify属性
p1.identify = '新人类'

print(p1.identify)   # 新人类    # 访问自己的
print(p1.__dict__)   # {'identify': '新人类'}

p1.__dict__.clear()   # 删除自己后
print(p1.__dict__, p1.identify)    # {} 人类  # 访问类的

# p2自己没有，还是访问类的
print(p2.__dict__, p2.identify)    # {} 人类