Python 类印象

什么是类

具有相同属性和方法的一类事物（框架 模子） 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法，对象是类的实例

什么是对象

对象中类中一个具体的例子（具有具体的属性属性和具体的方法）
​ 对象就是类的实例化 类的实例

1
2
3
4
5
6
7
8
调用模子得到的结果 : 对象(具体的)
根据模子的规范,填上具体的值就是一个对象了

python中一切皆对象
什么是类什么是对象
整数是类 : 2,3,4,5是对象
列表是类 : [1,2,3],[3,4,5]

什么是实例

实例完全和对象一样

什么是实例化

是由类创建对象的过程

定义类的关键字

class 类名首字母大写

实例化的过程 ：对象名 = 类名（）

  1. 创建一个属于对象的空间

  2. 执行init 方法，将这个空间的地址和参数传递给init方法

  3. 将对象的空间地址作为返回值，返回给对象名，（对象变量）

在类中可以定义的内容

  • 静态属性 ：

所有的这个类的对象 都共有的属性

  • 动态属性:

    方法\ 定义在类中的函数,自带一个self,就是调用这个方法的对象本身

什么是对象的属性:

  1. 存储在实例化之后
  2. 创建的空间中的所有
  3. 变量都是对象的属性
    ​ 每一次实例化产生的空间都是独立，每一个对象都有自己的属性值

类名的作用

  • 实例化的时候 对象 = 类名（）
  • 操作（调用） 静态属性

对象名作用

  • 操作对象的属性

  • 调用类中的方法（动态属性）

闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def func(name):
    dic = {}

    def bite():
        print(dic['name'])

    dic['bite'] = bite # 把'bite' 函数的内存地址添加到字典
    dic['name'] = name
    return dic

inn1 = func('alex')
print(inn1)
inn2 = func('egon')
inn1['bite']() #inn1 现在就是一个字典，bite 的值 就是一个 函数地址 加()就是调用
inn2['bite']()



执行结果
egon
{'bite': <function func.<locals>.bite at 0x10f61b400>, 'name': 'alex'}
alex
egon

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


class Person:

    # self 是一块内存空间
    # 本身存在的内置方法
    # 类名加() 直接执行 __init__ 方法

    def __init__(self, name, gender, hp, mp, ad):
        print('self>>>>', self)
        print(name, gender, hp, mp, ad)


馒头 = Person('mantou', 'man', 10, 10, 0.1)

print('馒头>>>>', 馒头)
#执行结果

self>>>> <__main__.Person object at 0x1062a7978>
mantou man 10 10 0.1
馒头>>>> <__main__.Person object at 0x1062a7978>



# slef 和馒头 的关系?
# - Person 做了什么

# 1.开辟一块内存空间

# 2.调用__init__
			# 并且把开辟的空间地址 自动传递给__init__

# 3. 将self 所指向的内存空间 返回被对象 ‘馒头’ 接收了


class Person_:  # 类

    COUNTRY = 'China'  # 静态属性\类属性 属于类的。 所有属于 这个类所有对象的属性

    def __init__(self, name, gender, hp, mp, ad):
        self.name = name  # 属性，属于对象的值  - 对象属性
        self.gener = gender
        self.hp = hp
        self.mp = mp
        self.ad = ad

    def attack(self):  # 在类中的定义的函数，就是方法|
        # 动态属性 、方法
        print(self)


mantou = Person_('mantou', 'man', 10, 10, 0.1)  # 实例化
baozi = Person_('baozi', 'man', 100, 100, 10)  # 实例化

# mantou 实例\对象

print(mantou.name)
print(baozi.hp)

# 如何调用方法 # attack

baozi.attack()  # 对象加方法***

# Person_.attack(mantou) 类名加方法


# 调用一般则是对象名加方法,也可以类名加方法

# 这两个效果都是相同的。

# 对象能够完成的事情
# 操作对象的属性
# 调用对象的方法

对象属性的值的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

class Person:
    COUNTRY = 'China'  # 静态属性\类属性 属于类的。 所有属于 这个类所有对象的属性

    def __init__(self, name, gender, hp, mp, ad):
        self.name = name  #对象属性
        self.gender = gender
        self.hp = hp
        self.mp = mp
        self.ad = ad


#
mantou = Person_('mantou', 'man', 10, 10, 0.1)  # 实例化
baozi = Person_('baozi', 'man', 100, 100, 10)  # 实例化

print(Person_.__dict__)
print(mantou.__dict__)

# 可修改属性名
mantou.__dict__['name'] = 'tu_sb'
print(mantou.__dict__)

# 修改属性的值
# mantou.hp = 9
# print(mantou.hp)

# 可以查看属性名
print(mantou.__dict__)

#尝试
#调用这些对象的属性(能不能修改, 能不能在实例化之后再给对象添加新的属性)
#查看属性值
print(alex.hp)

#如何给一个对象添加属性
alex.level = 1
print(alex.level)

#删除属性的值
del alex.level
print(alex.level)