【Python零基础快速入门系列 10】类的设计哲学：自然法则的具现

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

pass

p1和p2是基于同一个类创建的两个不同的实例

p1 = Person()
p2 = Person()

变量的地址是不一样的，指向2个不同的对象

print(id(p1), id(p2))

2225665760280 2225665760224

## 3. 类的定义


* 定义类的关键字为class
* class后跟的是类名
* 类名后小括号中的是父类，这是类的继承特性，可以继承父类的属性和方法，不继承时可不添加小括号
* 类中可定义对象的属性、类的属性、自定义方法、对象私有属性等

class class_name:
desc = “自定义类” # 类的属性，所有对象共有

def __init__(self, arg1, arg2, name):
    self.arg1 = arg1        # 对象的属性
    self.arg2 = arg2
    self.__name = name      # 对象的私有属性

# 自定义方法
def user_defined_func(self, ...):
    pass

### 3.1 特殊方法：\_\_init\_\_函数


* 类的初始化函数，创建对象的时候就会被执行
* 必须存在，函数名不可更改，双下划线开始双下划线结束；
* 所有类方法的第一个参数必定为self；
* 目的是挂载类的属性，self.开始的属性是对象的属性，其它属性为类的属性，所有对象共有

class menu:
desc = “自定义类” # 类的属性，所有对象共有

def __init__(self, arg1, arg2): # 初始化方法，创建对象时调用
    self.arg1 = arg1        # 对象的属性
    self.arg2 = arg2

# 自定义方法
def user_defined_func():
    pass

### 3.2 属性


#### 3.2.1 实例属性


使用self定义的属性都是实例属性。

class dish:
def __init__(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

menu = []
menu.append(d1)
menu.append(d2)

for dish_item in menu:
print(dish_item.id, dish_item.name, dish_item.price)

1 青椒肉丝 22.9
2 新疆大盘鸡 89.9

#### 3.2.2 类属性


在类中定义的非self属性属于类的属性，它属于类，类创建的所有实例对象都拥有这个属性，且值一样

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

menu = []
menu.append(d1)
menu.append(d2)

print(dish.desc) # 类调用类属性
print(d1.desc) # 对象d1调用类属性
print(d2.desc) # 对象d2调用类属性

菜品销售信息
菜品销售信息
菜品销售信息

#### 3.2.3 动态属性-实例属性


python支持类在创建实例对象动态扩展属性，该属性仅属于该对象，不属于类，其它对象也不存在

动态属性仅属于当前实例对象，其它实例对象无该属性

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

d1.star = 5 # 动态属性：客户评分，仅属于d1实例对象

d2.star # 之前创建的实例对象无star属性

---

AttributeError Traceback (most recent call last)

in ()
12 d1.star = 5 # 动态属性：客户评分，仅属于d1实例对象
13
—> 14 d2.star

AttributeError: ‘dish’ object has no attribute ‘star’

动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

d1.star = 5 # 动态属性：客户评分，仅属于d1实例对象

以类创建新的实例对象

d3 = dish(3, “皮蛋豆腐”, 18.0)
d3.star # 新创建的对象没有star属性

---

AttributeError Traceback (most recent call last)

in ()
16 # 以类创建新的实例对象
17 d3 = dish(3, “皮蛋豆腐”, 18.0)
—> 18 d3.star # 新创建的对象没有star属性

AttributeError: ‘dish’ object has no attribute ‘star’

#### 3.2.4 动态属性-类属性


python支持类动态扩展属性，该属性仅属于该类，该类之前和之后创建的对象均会拥有该类属性。该属性修改时会影响到该类的所有实例对象

动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

dish.restaurant_name = “秦王阁” # 动态类属性：属于类

之前创建的实例对象拥有该属性

print(f"d1:{d1.restaurant_name}")

之后创建的实例对象拥有该属性

d3 = dish(3, “皮蛋豆腐”, 18.0)
print(f"d3:{d3.restaurant_name}")

修改动态类属性会影响该类的所有实例对象

dish.restaurant_name = “秦王阁总店”
print(f"d1:{d1.restaurant_name}, d3:{d3.restaurant_name}")

d1:秦王阁
d3:秦王阁
d1:秦王阁总店, d3:秦王阁总店

#### 3.2.5 私有属性


在实际开发中，对象的某些属性或方法可能只希望在对象内部使用，而不希望在外部被访问到，将没有必要展示的属性隐藏到类的内部


私有属性就是对象不希望公开的属性


定义方法：双下划线+变量名

__[var_name]

如下代码中的`__freshness`就是私有属性，在类的外部无法访问该属性。python的实现原理是将属性改名以实现隐藏的目的,在下面的例程中`__freshness`被重命名为`_dish__freshness`。

动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性
    self.__freshness = 0    # 私有属性

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

d1.__freshness

---

AttributeError Traceback (most recent call last)

in ()
13 d2 = dish(2, “新疆大盘鸡”, 89.9)
14
—> 15 d1.__freshness

AttributeError: ‘dish’ object has no attribute ‘__freshness’

查看__freshness是否暴露出来，可以看到无__freshness，属性改名为_dish__freshness

dir(d1)

[‘class’,
‘delattr’,
‘dict’,
‘dir’,
‘doc’,
‘eq’,
‘format’,
‘ge’,
‘getattribute’,
‘gt’,
‘hash’,
‘init’,
‘init_subclass’,
‘le’,
‘lt’,
‘module’,
‘ne’,
‘new’,
‘reduce’,
‘reduce_ex’,
‘repr’,
‘setattr’,
‘sizeof’,
‘str’,
‘subclasshook’,
‘weakref’,
‘_dish__freshness’,
‘desc’,
‘id’,
‘name’,
‘price’]

### 3.3 方法


#### 3.3.1 实例方法


类的方法用来描述对象的行为。


类的方法定义和普通函数稍微有点不一样，第一个参数必须为self，表示对象自身

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性

# 实例方法的定义
def display\_dish(self):     # 自定义函数
    print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

menu = []
menu.append(d1)
menu.append(d2)

for dish_item in menu: # 类的自定义方法
# 实例方法的调用
dish_item.display_dish()

id:1 name:青椒肉丝 price:22.9
id:2 name:新疆大盘鸡 price:89.9

#### 3.3.1 动态实例方法


python支持类在创建实例对象动态扩展方法，该属性仅属于该对象，不属于类，其它对象也不存在

from types import MethodType # 动态方法需要引入模块

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性

def display\_dish(self):     # 自定义函数
    print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

def update_price(self, price):
self.price = price

动态加载方法，需要MethodType配合使用

d1.update_price = MethodType(update_price, d1)

d1.update_price(36.9)
print(f"d1.price:{d1.price}")

其它实例对象无此方法

d2.update_price(69.9)

d1.price:36.9

---

AttributeError Traceback (most recent call last)

in ()
25
26 # 其它实例对象无此方法
—> 27 d2.update_price(69.9)

AttributeError: ‘dish’ object has no attribute ‘update_price’

#### 3.3.2 私有方法


私有方法就是对象不希望公开的方法,只可以在类的内部使用，外部无法访问。下面代码中的\_\_update\_price就是私有方法，从dir的输出来看，\_\_update\_price也被python改名了，改为\_dish\_\_update\_price了。

from types import MethodType # 动态方法需要引入模块

class dish:
desc = “菜品销售信息”

def \_\_init\_\_(self, id, name, price):
    self.id = id            # 实例属性
    self.name = name        # 实例属性 
    self.price = price      # 实例属性

def display\_dish(self):     # 自定义函数
    print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")

def \_\_update\_price(self, price): 
    self.price = price

def update(self, price):
    self.__update_price(price)

d1 = dish(1, “青椒肉丝”, 22.9)
d2 = dish(2, “新疆大盘鸡”, 89.9)

实例对象访问

print(dir(d1)) #

d1.____update_price(39.2)

[‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘_dish__update_price’, ‘desc’, ‘display_dish’, ‘id’, ‘name’, ‘price’, ‘update’]

---

AttributeError Traceback (most recent call last)

in ()
24 print(dir(d1)) #
25
—> 26 d1.____update_price(39.2)

AttributeError: ‘dish’ object has no attribute ‘____update_price’

## 4. 类的继承和多态


面向对象三大特征：


* 封装:根据职责将属性和方法封装到一个抽象的类中
* 继承:实现代码的重用，相同的代码不需要重复的写
* 多态:以封装和继承为前提，不同的子类对象调用相同的方法，产生不同的执行结果

class Chinese:
def __init__(self, name, age):
self.name = name
self.age = age

def eat(self):
    print(f"{self.name}喜欢吃中餐")

def sleep(self):
    print(f"{self.name}正在睡觉")

class Southern(Chinese):
def __init__(self, name, age, height):# 子类Southern重载了__init__方法，和父类有差异，新增了height属性
self.name = name
self.age = age
self.height = height

def eat(self, favorate):              # 子类Southern重载了eat方法，和父类的参数数量不一样
    print(f"{self.name}喜欢吃米饭, 尤其喜欢{favorate}")
    return True

class Northern(Chinese):
def eat(self): # 子类Northern重载了eat方法，参数数量和父类一样
print(f"{self.name}喜欢吃面食")

p1 = Chinese(“张三”, 18)
p1.eat()

s1 = Southern(“李四”, 20, 190)
s1.eat(“黄焖鸡米饭”)
s1.sleep()

n1 = Northern(“王五”, 22)
n1.eat()
n1.sleep()

张三喜欢吃东西
李四喜欢吃米饭, 尤其喜欢黄焖鸡米饭
李四正在睡觉
王五喜欢吃面食
王五正在睡觉

**上面的例子展现了以下知识点：**


* 类的方法函数第一个参数必须为self, 否则会报错"TypeError: eat() takes 0 positional arguments but 1 was given",实例的方法调用时默认会将自己作为第一个参数传递进去
* Southern、Northern子类会继承父类的\_\_init\_\_方法和sleep方法，如果与父类有差异，也可以重载方法，这是类的多态
* 子类在重载父类的方法时，参数的数量可以和父类不一样，返回值也可以不一样，函数名一致即可。
* 有些父子类，子类在定义\_\_init\_\_方法时需要调用父类的\_\_init\_\_方法，因为子类重载了父类的\_\_init\_\_方法，因此父类的\_\_init\_\_方法不会被执行，有时父类有一些子类没有的属性需要初始化，那么可以这样调用父类的\_\_init\_\_方法：

super(ChildClassName, self).init()

就像例子一样，南方人普遍喜欢吃米饭，北方人普遍喜欢面食，但是南方人和北方人都拥有中国人的特性，喜欢吃中餐、会睡觉。


**类的继承和多态特性，抽象了子类公共的部分，又保留了子类的多样性**，精简了代码，又降低了代码耦合度，提高了代码质量，更容易实现代码复用。


**类，完美体现了一致性和多样性共同存在并相互作用，而这就是自然法则！**




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/145c9725e5afbc523dfc37d822a29b8f.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

，子类在定义\_\_init\_\_方法时需要调用父类的\_\_init\_\_方法，因为子类重载了父类的\_\_init\_\_方法，因此父类的\_\_init\_\_方法不会被执行，有时父类有一些子类没有的属性需要初始化，那么可以这样调用父类的\_\_init\_\_方法：

super(ChildClassName, self).init()

就像例子一样，南方人普遍喜欢吃米饭，北方人普遍喜欢面食，但是南方人和北方人都拥有中国人的特性，喜欢吃中餐、会睡觉。


**类的继承和多态特性，抽象了子类公共的部分，又保留了子类的多样性**，精简了代码，又降低了代码耦合度，提高了代码质量，更容易实现代码复用。


**类，完美体现了一致性和多样性共同存在并相互作用，而这就是自然法则！**




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
[外链图片转存中...(img-Q7KCdH4G-1713349924519)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**