面向对象（一）

面向对象

面向对象：面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

面向过程:就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象编程优点：1、是一类相似功能函数的集合,使你的代码更清晰化，更合理化；2、面向对象，要拥有上帝的视角看问题，类其实就是一个公共模板（厂房），对象就从具体的模板实例化出来

什么是类：就是具有相同属性和功能的一类事物

什么是对象：就是类的具体表现

• 类的结构

  类的结构从大方向来说可以分为两部分：静态变量和动态方法

# 定义一个具有人的部分属性的Person类，
class Person:
    speak='会说话'
    dic={'country':'China'}
    li=['河北']
    def work(self):
        print('人类会发明创造')

class 是关键字，用来定义一个类
Person 是类名，通常使用驼峰命名规则（私有类用一个下划线开头）
speak,dic,li这三个属性是静态变量
work():是动态方法

• 类名操作静态属性

查看类中的所有内容：类名.__dict__方式  （该方式只用户查询全部内容）
class Person:
    # 第一部分：静态属性 属性 静态变量 静态字段
    speak='会说话'
    dic={'country':'China'}
    li=['河北']
    # 第二部分：方法 函数 动态属性
    def work(self):
        print('人类会发明创造')
#
#该方式只能查询
print(Person.__dict__)
#输出一个字典：{'__module__': '__main__', 'speak': '会说话', 'dic': {'country': 'China'}, 'li': ['河北'], 'work': , '__dict__': , '__weakref__': , '__doc__': None}
print(Person.__dict__['speak'])#输出： 会说话

#通过  类名.__dict__方式  不能修改属性值
Person.__dict__['speak']='会说中文'
print(Person.__dict__['speak'])# TypeError

• 通过点操作属性

万能的点来增删改查静态属性
class Person:
    # 第一部分：静态属性 属性 静态变量 静态字段
    speak='会说话'
    dic={'country':'China'}
    li=['河北']
    # 第二部分：方法 函数 动态属性
    def work(self):
        print('人类会发明创造')
     
#查
print(Person.speak)
# 会说话

#改
Person.speak='我会说中文'
print(Person.speak)
# 我会说中文

#删
del Person.li
print(Person.__dict__)
# {'__module__': '__main__', 'speak': '我会说中文', 'dic': {'country': 'China'}, 'work': , '__dict__': , '__weakref__': , '__doc__': None}

#增
Person.walk='直立行走'
print(Person.walk)
# 直立行走

总结：如果想查询类中的所有内容，通过第一种__dict__方法；如果只是操作单个属性则用万能的点的方式

• 类名操作动态方法

class Person:
    speak='会说话'
    dic={'country':'China'}
    li=['河北']
    # 方法 函数 动态属性
    def work(self):
        print('人类会发明创造')
    def thought(self):
        print('人类进入高科技时代')
Person.work(11)		#人类会发明创造
Person.thought(1)	#人类进入高科技时代
Person.__dict__['work'](11)		#人类会发明创造

• 实例化对象

实例化一个对象的过程：

1. 在内存中开辟空间

2. 自动执行类中的__init__方法，构造函数，并将这个对象空间（内存地址）传给了__init__方法的第一个位置参数self。

3. 可以在构造函数中定义动态属性

类名加上（），这就是一个实例化过程，这个就会实例化一个对象。
class Person:
    speak = '会说话'
    def __init__(self):
        print(666)
        print(self)
    def work(self): 
        print('人类会发明创造')
obj = Person() # 只要实例化对象，它会自动执行__init__方法
print(obj)  
#输出：
666
<__main__.Person object at 0x0136D310>
<__main__.Person object at 0x0136D310>


class Person:
    speak = '会说话'
    language = '使用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。
        self.keyname = name
        self.keysex = sex
        self.keyage = age
        self.keyhobby = hobby
obj = Person('marry','男',18,'跑步')
print(obj.__dict__)  #{'keyname': 'marry', 'keysex': '男', 'keyage': 18, 'keyhobby': '跑步'}

实例化的对象可以通过点来操作对象中类的方法
#查
print(obj.speak)	#会说话

#增
obj.job='IT'	
print(obj.job)	#IT
print(obj.__dic__)	#{'keyname': 'marry', 'keysex': '男', 'keyage': 18, 'keyhobby': '跑步', 'job': 'IT'}

#改
obj.keysex='女'	
print(obj.__dic__)	#{'keyname': 'marry', 'keysex': '女', 'keyage': 18, 'keyhobby': '跑步', 'job': 'IT'}
obj.language='123'
print(obj.language) #123

#实例化对象可以通过点删除动态方法里的属性，但不能删除静态属性
#删
del obj.keyname  # 可以删除动态方法里的属性
del obj.language	# 抛出异常 ， 不能删除静态属性