面向对象初识

一、面向对象导入

1、含义：

①面向过程：

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

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

②面向对象：

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

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

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

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

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

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

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

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

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

3、方法和函数的区别

函数要手动传self，方法不用传
如果是一个函数，用类名去调用，如果是一个方法，用对象去调用

# 判断是方法还是函数
from types import FunctionType, MethodType


class Foo(object):
    def __init__(self):
        self.name = "jerry"

    def func(self):
        print(self.name)


obj = Foo()
print(isinstance(obj.func, MethodType))    # True 说明这是一个方法
print(isinstance(Foo.func, FunctionType))  # True 说明这是一个函数。

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

 

二、名称空间

内置 | 全局 | 局部


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

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

1、能产生名称空间的有

文件 | 函数 | 类

2、名称空间操作

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

3、名称空间的使用

def func():
    pass
func.__dict__['index'] = 100
print(func.__dict__)            # {'index': 100}

print(func.__dict__['index'])   # 100
print(func.index)               # 100

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

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))  # 6732072
print(id(stu))      # 32076744
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))    # 35616304 35617424 5749032

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(456)
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)    # {} 人类