Python面向对象Day1
一、面向对象初始
面向过程变成属于流水式
面向对象是一种思想
结构上理解面向对象：两部分
class A: # 类
name = '小明' # 静态属性，静态变量，静态字段，或者属性、变量、字段
def func(self): # 函数、动态属性、方法
pass
函数和面向对象的区别：
①.函数封装一个功能，而面向对象封装多个功能
②.面向对象比较抽象，它是一种思想，要站在上帝的角度去理解它
③.程序可扩展，对象都是一个个独立的。既有耦合性又有差异性
二、类、对象
类：具有相同属性或者功能的一类事物，类包含属性和方法。例如：人类、猫类、狗类；
对象：对象是类的具体体现（独一无二），例如：具体到事物，每个事物是独立的。
三、类名的使用
类：类似于一个公共框架，一个公共模型
定义类：
class 类名：
属性
方法
① 查看类中的所有属性及方法__dict__
主要用途：类名.__dict__ 查看类的所有方法和属性
返回的是字典，__dict__只有一个功能，就是查看所有的属性和方法，也能查看单独的属性及方法，但是不能增删改
使用：类名.__dict__
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
print(Person.__dict__) # 查看类的所有属性和方法，以字典的形式返回
# 结果
{'__module__': '__main__', 'name': '小明', 'age': 18, 'eat': <function Person.eat at 0x0000021D7A978AE8>, 'sleep': <function Person.sleep at 0x0000021D7A978950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
单独查看属性（不建议使用）
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
print(Person.__dict__['name']) # 单独查看属性
# 结果
小明
② 查看类中单独的属性或者方法，用万能的点
使用：类名.属性（方法）
除了查看属性，还能对属性增删改
查：
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
print(Person.age) # 单独查看类的属性
print(Person.__dict__) # 查看类的所有属性和方法，以字典的形式返回
# 结果
18
{'__module__': '__main__', 'name': '小明', 'age': 18, 'eat': <function Person.eat at 0x000001B497B98AE8>, 'sleep': <function Person.sleep at 0x000001B497B98950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
增：
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
Person.hoppy = 'football' # 在类中增加一个属性
print(Person.__dict__) # 查看类的所有属性和方法，以字典的形式返回
# 结果
{'__module__': '__main__', 'name': '小明', 'age': 18, 'eat': <function Person.eat at 0x000002019FFD8AE8>, 'sleep': <function Person.sleep at 0x000002019FFD8950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, 'hoppy': 'football'}
改：
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
Person.name = '小白' # 修改属性
print(Person.name)
print(Person.__dict__)
# 结果
小白
{'__module__': '__main__', 'name': '小白', 'age': 18, 'eat': <function Person.eat at 0x00000196D23A8AE8>, 'sleep': <function Person.sleep at 0x00000196D23A8950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
删：
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
del Person.age # 删除属性
print(Person.__dict__)
# 结果
{'__module__': '__main__', 'name': '小明', 'eat': <function Person.eat at 0x000002312E698AE8>, 'sleep': <function Person.sleep at 0x000002312E698950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
③ 类内的方法的操作
一般不通过类名操作！！使用类的实例化对象来操作
使用：类名.方法(参数)
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
Person.eat(1) # 调用类的方法，需要实参
# 结果
在吃饭
类名.__dict__[方法名](参数) 不建议使用
class Person:
name = '小明' # 属性
age = 18
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
Person.__dict__['eat'](1) # 用__dict__的key调用方法，不建议使用
# 结果
在吃饭
类中的特殊方法，用于实例化对象
def __init__(self):
pass
def __init__(self): # 类中的特殊方法，用于实例化对象
pass
类的实例化对象
class Person:
name = '小明' # 属性
age = 18
def __init__(self): # 类中的特殊方法，用于实例化对象
pass
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person() # 实例化对象
类名() 这个过程就是实例化过程，它会实例化一个对象（它会给内存实例化一个对象空间）
obj = 类名() 把内存实例化的空间赋值给obj
实例化过程内部进行了三个阶段：
① 在内存中开辟一个类对象空间，产生一个类对象指针
② 它会根据指针找到类的__init__的方法，自动执行类中的__init__方法，并且将对象空间自动传给self参数，其他参数手动传入
③ 执行__init__的方法，给类对象空间封装相应的属性
def __init__(self): 功能：给对象封装属性的
四、对象
对象里不能定义方法，对象只能封装静态属性
①对象操作对象空间
对象.__dict__ 以字典的形式返回封装的属性，查看对象的所有属性
class Person:
name = '小明' # 属性
age = 18
def __init__(self,hobby,job): # 给实例化对象定义属性，必须提供参数才能实例化
self.hobby = hobby
self.job = job
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person('football','IT') # 实例化对象
print(obj.__dict__) # 查看对象的所有属性
# 结果
{'hobby': 'football', 'job': 'IT'}
对象操作对象的属性方式：增删改查
增（属性不存在与对象空间）：
class Person:
name = '小明' # 属性
age = 18
def __init__(self,hobby,job): # 给实例化对象定义属性，必须提供参数才能实例化
self.hobby = hobby
self.job = job
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person('football','IT') # 实例化对象
obj.age = 20 # 对象创建一个属性
print(obj.__dict__) # 查看对象的所有属性
# 结果
{'hobby': 'football', 'job': 'IT', 'age': 20}
改（属性存在与对象空间）：
class Person:
name = '小明' # 属性
age = 18
def __init__(self,hobby,job): # 给实例化对象定义属性，必须提供参数才能实例化
self.hobby = hobby
self.job = job
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person('football','IT') # 实例化对象
obj.age = 20 # 对象创建一个属性
print(obj.__dict__) # 查看对象的所有属性
obj.age = 15 # 修改对象的属性
print(obj.__dict__) # 查看对象的所有属性
# 结果
{'hobby': 'football', 'job': 'IT', 'age': 20}
{'hobby': 'football', 'job': 'IT', 'age': 15}
删：
class Person:
name = '小明' # 属性
age = 18
def __init__(self,hobby,job): # 给实例化对象定义属性，必须提供参数才能实例化
self.hobby = hobby
self.job = job
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person('football','IT') # 实例化对象
print(obj.__dict__) # 查看对象的所有属性
del obj.hobby # 删除对象的属性
print(obj.__dict__) # 查看对象的所有属性
# 结果
{'hobby': 'football', 'job': 'IT'}
{'job': 'IT'}
查：
class Person:
name = '小明' # 属性
age = 18
def __init__(self,hobby,job): # 给实例化对象定义属性，必须提供参数才能实例化
self.hobby = hobby
self.job = job
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person('football','IT') # 实例化对象
print(obj.job) # 查看某一属性的值
# 结果
IT
②对象操作类空间的属性
只能通过对象查询类空间的属性，不能修改，因为一旦修改就是给对象增加属性
class Person:
name = '小明' # 属性
age = 18
def __init__(self,hobby,job): # 给实例化对象定义属性，必须提供参数才能实例化
self.hobby = hobby
self.job = job
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person('football','IT') # 实例化对象
print(Person.__dict__)
print(obj.__dict__)
obj.name = '小白'
print(Person.__dict__)
print(obj.__dict__)
# 结果
{'__module__': '__main__', 'name': '小明', 'age': 18, '__init__': <function Person.__init__ at 0x000001DB42518AE8>, 'eat': <function Person.eat at 0x000001DB42518950>, 'sleep': <function Person.sleep at 0x000001DB42518A60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
{'hobby': 'football', 'job': 'IT'}
{'__module__': '__main__', 'name': '小明', 'age': 18, '__init__': <function Person.__init__ at 0x000001DB42518AE8>, 'eat': <function Person.eat at 0x000001DB42518950>, 'sleep': <function Person.sleep at 0x000001DB42518A60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
{'hobby': 'football', 'job': 'IT', 'name': '小白'}
③ 对象操作类空间的方法：
对象.类空间的方法()
类名.类空间方法(对象)
class Person:
name = '小明' # 属性
age = 18
def __init__(self,hobby,job): # 给实例化对象定义属性，必须提供参数才能实例化
self.hobby = hobby
self.job = job
def eat(self): # 方法
print('在吃饭')
def sleep(self):
print('在睡觉')
obj = Person('football','IT') # 实例化对象
obj.sleep() # 调用类空间的方法
# 结果
在睡觉
五、类名称空间、对象名称空间
实例化对象调用类中的属性与方法（内存级别）
类对象指针：对象与类的指向关系
① 对象能调用类中的属性与方法
obj.属性名 先从自己的空间去找，没有此属性它会通过类对象指针从类中去找，类中找不到，会从父类去找属性
② 类不能调用对象的属性
类不存在指向对象的值，找不到值；类只是公共的模板，对象的不同在__init__体现
对象能操作模板，模板不能操控类
③ 对象与对象之间不能互相调用
两个独立的空间是互相不能访问的，同一类实例化的对象之间是不能互相访问，不同类实例化的对象有可能访问
给对象封装属性：__init__或者任意位置增加；但是属性一般都封装在__init__
