基础面向对象与面向过程

　　1.面向过程：

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

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

　　2.面向对象：

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

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

　　　　　

　　补充：python语言：面向对象的语言

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

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

　　函数：通过函数直接调用

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

　　

import re
print(re.S) 可以将
匹配
print(re.I) 不区分大小写
print(re.M) 匹配多行

class 类名:  # class定义类语法的关键字
    pass

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

　　学习的重点：自定义累的实例化对象

　　

 

　　3.名称空间

　　----内置---全局----局部

　　

import test
print(test.__dict__)  系统内置属性
{'__name__': 'test', '__doc__': None, '__package__': “”“”“”’

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

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

能产生名称空间的对象有__dict___ 这个值，通过这个值访问到名字与内存地址的对应关系

print（global())
{'__name__': '__main__', '__doc__': '
名称空间
', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001FE1729E128>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/类与对象/类与对象.py', '__cached__': None}

　　名称空间的使用

　　

def func():
    pass
func.__dict__["index"]=1000

{'index': 1000}

def func():
    pass
func.__dict__["index"]=1000
print(func.__dict__)
print(func.__dict__["index"])
print(func.index)

1000
1000

def func():
    pass
func.__dict__["index"]=1000
print(func.__dict__)
print(func.__dict__["index"])
print(func.index)
func.add = lambda n1,n2 :n1+n2
print(func.__dict__)
print(func.add(100,200))

》》》{'index': 1000, 'add': <function <lambda> at 0x000001A1B35E52F0>}
》》》300

　　4.类与对象

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

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

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

　　1.2语法

　　

# 学习重点：自定义类的实例化对象

　　

　　

lass Student:
    pass
stu=Student()
1.print(id(Student))
2.print(id(stu))
3.print(Student.__dict__)
4.print(stu.__dict__)
5.stu.__dict__["name"]="bor"

　　

　　

1. 2154075301048
2. 2154076607488
3.{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
4.{}
5.{'name': 'bor'}

　　

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

s1.name = "fujin"
s1.studay = fn
s2.name = "liuxx"
s2.studay = fn
print(s1.__dict__)
# {'name': 'fujin', 'studay': <function fn at 0x0000023857F65158>}

print(s2.__dict__)
# {'nmae': 'liuxx', 'studay': <function fn at 0x00000233DF2F5158>}
print(s1.name, s2.name)
# fujin liuxx

　　

# 小结：
# 类拥有自己的名称空间，类的对象也拥有自己的名称空间，
# 所以可以通过.语法添加或使用属性和方法

# 定义类能不能初始设置属性与方法
# 类一旦被加载(随着所属文件的加载就加载)，就会进入类的内部执行类中的所有代码

　　

lass People:
    identify="人类"
    def sleep(self):
        print("睡觉")

print(People.__dict__)
p1=People() 直接调用类下面的方法
MOMO=People()
print(p1.identify)
print(MOMO.identify)

{'__module__': '__main__', 'identify': '人类', 'sleep': <function People.sleep at 0x00000239E71452F0>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
人类
人类

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

# p1修改的并不是People的identify，相对于给自己添加一个identify属性
p1.identify = '新人类'  对象可以自己修改自己的属性
print(p1.__dict__, p1.identify)
p1.__dict__.clear()
print(p1.identify)
# p2自己没有，还是访问的类的
print(p2.identify)

　　

 属性的访问顺序：优先加载自身的名字，如果没有再考虑类的