大灰羊
0%

面向对象

发表于
本文字数： 3.7k 阅读时长 ≈ 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
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
# -*- coding:utf-8 -*-
# @Time       :2022/6/19 9:38
# @SOFTWARE   :python基础


# 用几大特征表达一类事物称为一个类，类更像是一张图纸，表达的是一个抽象概念
# 对象是类的具体实现，更像是由这图纸产出的具体产品，类只有一个，但对象可以通过这个类实例化出多个
# 对象是类的实例，类是对象的模板
# 类中的成员只有方法和属性，不要裸露的把判断和循环直接写在类中（严禁使用，会破坏类中的结构），而是用方法包起来

# 类的定义
# 1.
class Car:
    pass
# 2.推荐
class Car():
    pass
# 3.
class Car(object):
    pass

# 类的实例化
obj = Car()
print(obj) # 返回一个内存地址

# 类的基本结构：成员属性和成员方法
class Car():
    # 成员属性
    color = "白色"
    # 成员方法
    def fun(self):
        print("燃油车")


# 类的命名—大驼峰命名法（每个单词首字母大写）


# 面向对象的三大特征：封装，继承，多态

# 封装：对类中成员属性和方法的保护，控制外界对内部成员的访问，修改，删除等操作
# 1.私有封装
# 在类内可以互相访问，类外不能
# 2.公有封装
# 在类内和类外都能访问
class MyCar():
    # 公有属性
    logo = "奥迪"
    # 私有属性
    __price = "2000万"
    # 公有方法
    def fun(self):
        print("百公里油耗7l")
    # 私有方法
    def __info(self):
        print("我的车")
# self -> 绑定方法：
# 1.绑定到对象：当对象调用类中的成员方法时，系统会默认把该对象作为参数传递给该方法
# 2.绑定到类：当对象或者类去调用类中成员方法时，系统会默认把该类作为参数传递给该方法

#（1）实例化对象
obj = MyCar()
# (2)实例化的对象访问成员属性和方法
# 公有
print(obj.logo)
obj.fun()

# （3）实例化的对象动态添加公有成员属性
obj.logo = "捷豹"
obj.color = "黑色"

# __dict__获取类对象的内部成员
print(obj.__dict__)
print(MyCar.__dict__)

# (4)实例化的对象动态添加公有成员方法

# 1.无参方法
def dhf():
    print("我叫大黄蜂")

# 2.有参方法
# 基本版
def qtz(name):
    print("我叫{}".format(name))
obj.qtz = qtz
obj.qtz("擎天柱")

# 升级版
def qtz1(obj,name):
    print("我叫{},我的颜色是{}".format(name,obj.color))
obj.qtz1 = qtz1
obj.qtz1(obj,"擎天柱")

# 终极版
def qtz2(obj,name):
    print("我叫{},我的颜色是{}".format(name, obj.color))

import types
# 创建绑定方法，系统自动把该对象当成参数传递给方法
# types.MethodType(方法，对象) => 绑定方法
res = types.MethodType(qtz2,obj)
print(res)
obj.qtz2 =types.MethodType(qtz2,obj)
obj.qtz2("擎天柱")

# lambda表达式
obj.wzt = lambda :print("我是威震天")
obj.wzt()

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
# -*- coding:utf-8 -*-
# @Time       :2022/6/20 8:53
# @SOFTWARE   :python基础

class Mycar():
    # 公有属性
    platnum = "晋ACK099"
    # 私有属性
    __salary = "10000元"
    # 公有成员方法
    def car_info(self):
        print("牌照信息公开")
    # 私有成员方法
    def __car_money(self):
        print("汽车成本不公开")

# 1.定义的类访问公有成员属性和方法
print(Mycar.platnum)
Mycar.car_info(Mycar)
# 2.定义的类动态添加公有成员属性
Mycar.oil = "1000l"
print(Mycar.oil, Mycar.__dict__)
# 3.定义的类动态添加公有成员方法 -》 只能添加公有成员方法
# （1）无参方法
def car_light():
    print("天使眼大灯")
Mycar.car_light = car_light
Mycar.car_light()

# （2）有参方法
def car_engine(name):
    print("{}牌发动机".format(name))
Mycar.car_engine = car_engine
Mycar.car_engine("三缸直列发动机")

# （3）lambda表达式
Mycar.car_logo = lambda name:print("{}牌汽车".format(name))
Mycar.car_logo("奥迪")

# 对比 对象和类的不同
# 1.类中无参方法
# 默认只能类来调用，对象无法调取
# 对象可以调用类中的成员，反过来，类不能调用对象中的成员
# 每创建一个对象都会在内存中占用一份空间，对象之间是彼此独立的


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
# -*- coding:utf-8 -*-
# @Time       :2022/6/20 9:22
# @SOFTWARE   :python基础

# 1.如何在类外访问私有成员
class Plane():
    __engine = "空客"
    air_sister = "3名空姐"
    def __sister_age(self):
        print("年龄保密")
    def earn(self):
        print("1000万")

obj = Plane()
print(Plane.__dict__)
"""
{'__module__': '__main__', 
'_Plane__engine': '空客', 
'air_sister': '3名空姐', 
'_Plane__sister_age': <function Plane.__sister_age at 0x000001FD8642A280>, 
'earn': <function Plane.earn at 0x000001FD8642A310>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}
"""
# 方法1：
# python私有化：采取了改名策略     _类名+方法名 -》 _Plane__engine': '空客'

# 方法2：使用类中的公有方法，间接访问类中的私有方法



# 删除成员属性和方法
# del + 方法名或者属性名（私有无法删除）

# 对象无法调用无参方法，且类可以调用对象的绑定方法