对象与类的初始

#面向过程：重过程
#重过程：解决问题，考虑的是解决问题的流程
#解决问题的思路清晰，但拓展性不强
#面向对象
#重对象：解决问题，找到解决问题的对象
#解决问题的思路可能不止一条（理解解决问题的难度），但拓展性强
#python: 面向对的语言
#python用面向过程与面向对象的两种方式解决问题
#函数与方法：都是解决问题的功能
#函数：通过函数名直接调用
#方法：通过附属者。语法来调用
import re
print(re.S)
import test
print(test.num)

#名称空间
#内置、全局、局部
print(test.__dict__)
def func():
    a= 10
    print(locals())
func()
print(func.__dict__)

# 能够产生名称空间的有：文件、函数、类
# 能够产生名称空间的对象有__dict__这个值，通过该值访问到名字与地址的对应关系
print(globals())
#名称空间的使用
import test
print(test.num)
print(test.__dict__['num'])
test.__dict__['fn']()
test.fn()


def func():
    pass

func.__dict__['index'] = 1000
func.__dict__['age'] = 123
print(func.__dict__)
print(func.__dict__['index'])
print(func.index)

for i in func.__dict__.items():
    k,v=i
    print(k,v,end = ' ')

func.add = lambda n1 ,n2:n1+n2
print()
print(func.__dict__)

print(func.add(10,20))

#类与对象
#寻求一个类似函数与文件的文件对象，可以额外添加功能与属性的对象
#类：具有相似特征与行为的个体集合的抽象
#对象：有特征、行为的具体个体，就是类的具体体现
#语法：
#类的说明： class类名 定义语法的关键字
#对象的产生：对象的实例化
#自定义类的实例化对象
class Student:
    pass
stu = Student()
print(id(Student))
print(id(stu))
print(Student)
print(stu)
print(stu.__dict__)
print(Student.__dict__)
stu.__dict__['name']= 'bob'
print(stu.name)
def fn ():
    print('吃饭睡觉')
stu.study = fn
stu.study()
print(stu.study)

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__,s2.__dict__)
print(s1.name,s2.name)
#类拥有自己的名称空间，类的对象有也拥有自己的名称空间
#所以可以通过。语法添加或使用属性和方法
#定义类能不能初始设置属性与方法

#类一旦被加载（随着文件的加载而加载），就会进入类的内部执行类中的所有代码
class People:
    identify ='人类'
    class Teacher:
        identify = '教书匠'
        def sleep(self):
            print('睡觉')
        print('技术')
    print(456)
print(People.__dict__)
print(People.Teacher.identify)
p1=People()
p2=People()
print(p1.Teacher.identify)
print(p2.identify)