Python 面向对象基础（一）

1
2
面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想。

1
2
3
4
5
# 1.定义洗衣机的类
class Washer():
    def wash(self):
        print("能洗衣服")

1
2
		haier = Washer()

1
2
		haier.wash()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 需求：洗衣机  功能：洗衣服
# 1.定义洗衣机的类
class Washer():
    def wash(self):
        print("能洗衣服")

# 2.创建对象
# 对象名 = 类名()
haier = Washer()
# 3.验证功能

# 打印海尔对象
print(haier)

#使用wash的功能--实例方法/对象方法
### 调用实例方法/对象方法  对象名.wash（）

haier.wash()

1
2
3
self指的是调用该函数的对象。
由于打印对象和打印self得到的内存地址是一样的，self指的是调用该函数的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# --coding:utf-8--
class Washer():
    def wash(self):
        print("我洗衣服")
        print(self)

haier = Washer()
print(haier) ##打印haier的内存地址

haier.wash()


#由于打印对象和打印self得到的内存地址是一样的，self指的是调用该函数的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# --coding:utf-8--
# 1.一个类是否能创建多个对象？
# 同一个类创建对象：haier1 和haier2 

class Washer:
    def wash(self):
        print("洗衣服")
        print(self)


print("haier1：")
haier1 = Washer()
haier1.wash()

# 2. 多个对象都调用函数时，self地址是否相同？   self地址不同
# 这两个对象的内存地址是不一样的 ==》两个类   

print("haier2：")
haier2 = Washer()
haier2.wash()

1
2
3
4
print("haier1：")
haier1 = Washer()
haier1.wash()

1
2
3
4
print("haier2：")
haier2 = Washer()
haier2.wash()

1
2
3
属性即是特征，比如︰洗衣机的宽度、高度、重量...
对象属性既可以在类外面添加和获取，也能在类里面添加和获取。

1
2
3
	haier1.width=500
	haier1.height=800

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# --coding:utf-8--
class Washer:
    def wash(self):
        print("洗衣服")
        print(self)

haier1 = Washer()

#对象属性 =   对象名.属性名 = 值
haier1.width=500
haier1.height=800

print(haier1.width)
print(haier1.height)

1
2
3
print(haier1.width)
print(haier1.height)

1
2
3
 print(f'洗衣机的宽度是{self.width}')
 print(f'洗衣机的宽度是{self.height}')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# --coding:utf-8--
#定义类
class Washer:
    def wash(self):
        print("洗衣服")

    #类里面获取实例属性
    def print_info(self):
        #self.属性名
        print(f'洗衣机的宽度是{self.width}')
        print(f'洗衣机的宽度是{self.height}')
#创建对象
haier1 = Washer()

#添加实例属性

#对象属性 =   对象名.属性名 = 值
haier1.width=500
haier1.height=800

#对象调用实例方法 = 对象名.实例方法
haier1.print_info()

1
2
3
4
5
__init__()方法作用：初始化对象

__init__(）方法,  在创建—个对象时默认被调用,不需要手动调用
__init__(self)中的self参数，不需要开发者传递,python解释器会自动把当前的对象引用传递过去。

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
# --coding:utf-8--
#1.定义类
        #1.1 定义_init_,添加实例属性~宽度+高度
        #1.2 添加实例方法，访问init方法的属性
#2. 创建对象
#3. 调用实例方法 ，打印init方法里面的实例属性值


#定义类
class Washer:

    #1.定义_init_,添加实例属性~宽度+高度
    def __init__(self):
        self.width=400
        self.height=900

    #1.2 定义实例方法print_info，访问init方法的实例属性
    def print_info(self):
        #类里面调用实例属性
        print(f"洗衣机的高度是{self.height}，宽度是{self.width}")

#2.创建对象
haier = Washer()

#3. 调用实例方法 ，打印init方法里面的实例属性值
haier.print_info()

1
2
3
4
 def __init__(self,width,height):
    self.width = width
    self.height = height

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# --coding:utf-8--
class Washer:
    #1.定义_init_,width，height 为形参
    def __init__(self,width,height):
        self.width = width
        self.height = height

    #1.2 定义实例方法print_info，访问init方法的实例属性
    def print_info(self):
        #类里面调用实例属性
        print(f"洗衣机的高度是{self.height}，宽度是{self.width}")

#2.创建对象
haier1 = Washer(10,20)
#3. 调用实例方法 ，打印init方法里面的实例属性值
haier1.print_info()


haier2 = Washer(900,1000)
haier2.print_info()

1
2
3
4
当使用print输出对象的时候，默认打印对象的内存地址。

如果类定义了_str_方法，那么就会打印从在这个方法中return的数据。

1
2
3
4
5
 # 定义__str__()方法
    def __str__(self):
        return '这是海尔洗衣机的说明书'
        #return ：解释说明，返回的是类的说明或者对象状态的说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# --coding:utf-8--
class Washer:
    def __init__(self,width,height):
        self.width = width
        self.height = height

   # 定义__str__()方法
    def __str__(self):
        return '这是海尔洗衣机的说明书'
        #return ：解释说明，返回的是类的说明或者对象状态的说明

#2.创建对象
haier1 = Washer(10,20)

#这是海尔洗衣机的说明书

print(haier1)

1
2
当删除对象时,python解释器也会默认调用_del__()方法。

1
2
3
4
 # 定义__del__()方法
    def __del__(self):
        print("对象已经删除")

1
2
3
4
5
6
7
8
9
10
11
12
13
# --coding:utf-8--
# --coding:utf-8--
class Washer:
    def __init__(self):
        self.width=500

   # 定义__del__()方法
    def __del__(self):
        print("对象已经删除")

haier = Washer()