python中的类

类 和 对象 是面向对象编程的两个核心概念

类的概念

类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
特征 被称为 属性
行为 被称为 方法
类 就相当于制造飞机时的图纸，是一个 模板，是 负责创建对象的

对象的概念

对象 是 由类创建出来的一个具体存在，可以直接使用
由哪一个类创建出来的对象，就拥有在哪一个类中定义的：
属性
方法
对象 就相当于用 图纸 制造 的飞机
在程序开发中，应该 先有类，再有对象

类和对象的关系

类是模板，对象 是根据 类 这个模板创建出来的，应该 先有类，再有对象
类只有一个，而对象可以有很多个
不同的对象 之间 属性 可能会各不相同
类 中定义了什么 属性和方法，对象 中就有什么属性和方法，不可能多，也不可能少

类的设计

在使用面相对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类！

在程序开发中，要设计一个类，通常需要满足一下三个要素：
1. 类名 这类事物的名字，满足大驼峰命名法
2. 属性 这类事物具有什么样的特征
3. 方法 这类事物具有什么样的行为

大驼峰命名法

1. 每一个单词的首字母大写
   2. 单词与单词之间没有下划线
   

   类的结构

   class MianGuan:
   '''注释位置，说明类的作用'''
   flag = "镇江锅盖面"
   def fun1(self):
       print("测试使用!")

class 是关键字与def用法相同，定义一个类。
Human是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开
头。
类的结构从大方向来说就分为两部分：

静态变量
动态方法

从类名的角度研究类

类名操作静态属性

查看类中的所有内容：类名.dict方式。

class Human:
    mind = '有思想'
    dic = {}
    l1 = []
    def work(self):
        print('会工作')
print(Human.__dict__)
print(Human.__dict__['mind'])
Human.__dict__['mind'] = '高智慧'
print(Human.__dict__)
# 通过这种方式只能查询，不能增删改

万能的点 ‘.’

class Human:
mind = '有思想'
dic = {}
l1 = []
def work(self):
print('会工作')
print(Human.mind)
Human.mind = '高智慧'
print(Human.mind)
del Human.mind
Human.walk = '用脚走'
print(Human.walk)
# 通过万能的点 可以增删改查类中的单个属性

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

类名操作动态方法

class Human:
    mind = '有思想'
    dic = {}
    l1 = []
    def work(self):
        print(self,'会工作')    
Human.work('chensong')
Human.__dict__['work']('chensong')

从对象的角度研究类

对象

对象是从类中出来的，只要是类名加上()，这就是一个实例化过程，这个就会实例化一个对象。

class Human:
    mind = '有思想'
    dic = {}
    l1 = []
    def work(self):
        print(self,'会工作')
obj = Human()
# 只要实例化对象，它会自动执行__init__方法
print(obj)

其实实例化一个对象总共发生了三件事：
1. 在内存中开辟了一个对象空间。
2. 自动执行类中的init方法，并将这个对象空间（内存地址）传给了init方法的第一个位置参数self。
3. 在init 方法中通过self给对象空间添加属性。

class Human:
    mind = '有思想'
    work = '用两只腿走'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('chensong','男'，'18','男')

对象操作对象空间属性

对象查询对象中所有属性。 对象.dict

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间
        封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('chensong','男',18,'男')
print(obj.__dict__)

对象操作对象中的单个属性。 万能的点.

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间
        封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('chensong','男',18,'男')
# 添加属性
obj.job = 'IT'
# 删除属性
del obj.n
# 修改属性
obj.s = '女'
print(obj.s)
# 查看属性
print(obj.__dict__)

对象查看类中的属性

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间
        封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('chensong','男',18,'男')
print(obj.mind)
print(obj.language)
obj.a = 666
print(obj.a)

对象操作类中的方法

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间
        封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
    def work(self):
        print(self)
        print(self.n,'会工作')
    def tools(self):
        print(self.n,'会使用工具')
obj = Human('chensong','男',18,'男')
obj.work()
obj.tools()

类的内置函数