面向对象(OOP)基本概念

面向对象编程———— Object Oriented Programming 简写 OOP

根据职责在一个对象中封装多个方法

类和对象

01 类和对象的概念

1.1 类

类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
- 特征被称为属性
- 行为被称为方法
类负责创建对象

1.2 对象

对象是由类创建出来的一个具体存在，可以直接使用
由哪一个类创建出来的对象，就拥有在哪一个类的定义中
- 属性
- 方法

先有类，再有对象

02 类和对象的关系

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

03 类的设计

三个要素：

类名满足大驼峰命名法
属性这类事物具有什么样的特征
方法这类事物具有什么样的行为

大驼峰命名法

CapWords

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

3.1 类名的确定

名词提炼法 分析 整个业务流程，出现的名词，通常就是要找的类

3.2 属性和方法的确定

对对象的特征描述，通常定义成属性
对象具有的行为(动词)，通常可以定义成方法

提示：需求中没有涉及的属性或者方法在设计类时，不需要考虑

面向对象基础语法

01.dir内置函数

使用内置函数 dir传入标识符/数据，可以查看对象内的所有属性及方法
提示：__方法名__格式的方法时Python提供的内置方法/属性

方法名	类型	作用
`__new__`	方法	创建对象时，会被自动调用
`__init__`	方法	对象初始化时，会被自动调用
`__del__`	方法	对象被从内存中销毁前，会被自动调用
`__str__`	方法	返回对象的描述信息，`print`函数输出使用

02.定义简单的类

2.1 定义只包含方法的类

class 类名:def 方法1(self, 参数列表):passdef 方法2(self, 参数列表):pass

注意：类名的命名规则要符合 大驼峰命名法

2.2 创建对象

对象变量 = 类名()

2.3 第一个面向对象程序

需求

小猫爱吃鱼,小猫要喝水
分析

定义猫类 Cat
定义两个方法eat和drink
按照需求不需要定义属性

class Cat:def eat(self):print('小猫爱吃鱼')def drink(self):print('小猫要喝水')# 创建猫对象tom = Cat()tom.eat()
tom.drink()

在Python中使用类创建对象之后，tom变量中仍然记录的是对象在内存中的地址
即tom变量引用了新建的猫对象
使用print输出对象变量，默认情况下，是能够输出这个变量引用的对象是由哪一个类创建的对象，以及在**内存中的地址（十六进制）

案例进阶–使用Cat类再创建一个对象

lazy_cat = Cat()
lazy_cat.eat()
lazy_cat.drink()

03.方法中的self参数

3.1 案例改造–给对象增加属性

在python中，给对象设置属性非常容易，但不推荐使用
- 因为对象的属性应该封装在类内部
这种情况下只需要在类的外部代码设置一个属性即可

注意：方法简单但是不推荐使用

tom.name = "TOM"
...
lazy_cat.name = "大懒猫"

3.2 使用self在方法内部输出每一只猫的名字

由哪一个对象对用的方法，方法内的self就是哪一个对象的引用

在类封装的方法内部，self就表示当前调用方法的对象自己
调用方法时，程序员不需要传递self参数
在方法内部
- 可以通过self，访问对象属性
- 也可以通过self,调用对象中其他的方法
在类的外部，通过变量名，访问对象的属性和方法
在类封装的方法中，通过self.，访问对象的属性和方法

self就是具体对象的引用,改造代码如下：

class Cat:def eat(self):print('%s爱吃鱼'%self.name)def drink(self):print('%s要喝水'%self.name)# 创建猫对象tom = Cat()
tom.name = "Tom"
tom.eat()
tom.drink()

04.初始化方法

4.1在类外部给对象增加属性的问题

在日常开发中，不推荐在类的外部给对象增加属性
- 如程序运行时，没有找到相应属性，程序会报错
对象包含的所有属性应封装在类的内部

4.2初始化方法

当使用类名()创建对象时，会自动执行下列操作
- 1.为对象在内存中分配空间–创建对象
- 2.为对象的属性设置初始值–初始化方法(init)
初始化方法__init__方法，__init__是对象的内置方法

__init__方法是专门用来定义一个类具有哪些属性的方法

在Cat中增加__init__方法，验证该方法在创建对象时会被自动调用

class Cat:def __init__(self):print("初始化方法")tom = Cat()>>>
初始化方法

4.3 在初始化方法内部定义属性

在__init__方法内部使用self.属性名 = 属性的初始值就可以定义属性
定义属性之后，再用Cat类创建的对象，都会拥有该属性

class Cat:def __init__(self):print("这是一个初始化方法")self.name = "Tom"def eat(self):print("%s 爱吃鱼"%self.name)tom = Cat()tom.eat()

4.4 改造初始化方法–初始化的同时设置初始值

希望在创建对象的同时，设置对象的属性，可以对__init__方法进行改造
1. 把希望设置的属性值，定义成__init__方法的参数
2. 在方法内部使用self.属性 = 形参接收外部传递的参数
3. 在创建对象时，使用类名(属性1,属性2,...)调用

class Cat:def __init__(self, name):print("初始化方法")self.name = name...
tom = Cat("Tom")
...
lazy_cat = Cat("lily")
...

05.内置方法

方法名	类型	作用
`__del__`	方法	对象被从内存中销毁前，会被自动调用
`__str__`	方法	返回对象的描述信息，`print`函数输出使用

5.1 del方法

在Python中
- 当使用类名()创建对象时，为对象分配空间完成后，自动调用__init__方法
- 当一个对象被从内存中销毁前，会自动调用__del__方法
应用场景
- __init__改造初始化方法，让创建对象更加灵活
- __del__如果希望在对象被销毁前，再做一些事情，可以考虑改造__del__方法
生命周期
- 一个对象从调用类名()创建，生命周期开始
- 一个对象的__del__方法一旦被调用，生命周期结束
- 在对象生命周期内，可以访问对象属性，或者让对象调用方法

5.2str方法

在Python中，使用print输出对象变量，默认情况下，会输出这个变量引用对象是由哪一个类创建的对象，以及在内存中的地址（十六进制）
希望使用print输出对象变量打印自定义内容，可以用__str__内置方法

注意：__str__方法必须返回一个字符串

Class Cat:def __init__(self,name):self.name = nameprint("%s 来了" %self.name)def __del__(self):print("%s 走了" %self.name)def __str__(self):return "我是 %s"%self.nametom = Cat("Tom")
print(tom)

面向对象封装案例

01.封装

1.封装是面向对象编程的一大特点
2.面向对象编程的第一步–将属性和方法封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

02.小明爱跑步

需求
1.小明体重75.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重会增加1公斤

####在对象的方法内部，可以直接访问对象属性

class Person:def __init__(self, name, weight):# self.属性 = 形参self.name = nameself.weight = weightdef __str__(self):return "我的名字叫%s 体重是 %.2f 公斤" % (self.name, self.weight)def run(self):print("%s爱跑步，跑步锻炼身体"% self.name)self.weight -= 0.5def eat(self):print("%s是吃货，吃完再说"% self.name)self.weight += 1xiaoming = Person("小明", 75)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

2.1扩展小美也爱跑步

同上

03.摆放家具

需求
1.房子有户型、面积和家具名称列表（新房子没有任何家具）
2.家具有名字和占地面积，其中床4平方米，衣柜2平方米，桌子1.5平方米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表

计算剩余面积时，先让剩余面积等于初始总面积
调用添加家具方法时，添加家具时剩余面积 -= 家具面积

class HouseItem:def __init__(self, name, area):self.name = nameself.area = areadef __str__(self):return "[%s] 占地 %.2f 平米"% (self.name, self.area)class House:def __init__(self, house_type, area):self.house_type = house_typeself.area = area#剩余面积self.free_area = area#家具名称列表self.item_list = []def __str__(self):# Python可以将一对括号内部代码连接在一起return ("户型: %s\n总面积:%2.f平米[剩余:%.2f平米]\n家具:%s"% (self.house_type, self.area,self.free_area, self.item_list))def add_item(self, item):print("要添加 %s"% item)#1.判断家具的面积if item.area > self.free_area:print("%s面积太大，无法添加"% item.name)return#2.将家具的名称添加到列表中self.item_list.append(item.name)#3.计算剩余面积self.free_area -= item.area# 1.创建家具
bed = HouseItem("席梦思", 40)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 20)
print(bed)
print(chest)
print(table)# 2.创建房子对象
my_home = House("两室一厅", 60)my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)print(my_home)

面向对象封装案例II

封装

> 一个对象的属性可以是另外一个类创建的对象

01士兵突击

开发枪类

class Gun:def __init__(self, model):# 1.枪的型号self.model = model# 2.子弹的数量self.bullet_count = 0def add_bullet(self, count):self.bullet_count += countdef shoot(self):# 1.判断子弹数量if self.bullet_count <= 0:print("[%s] 没有子弹了..."% self.model)return# 2.发射子弹，-1self.bullet_count -= 1#3.提示发射信息print("[%s] 突突突...[%d]"% (self.model,self.bullet_count))# 1.创建枪对象
ak47 = Gun("AK47")
ak47.add_bullet(50)
ak.47.shoot()>>>
========== RESTART:
[AK47] 突突突...[49]

1.2开发士兵类

class Soilder:def __init__(self, name):# 1.姓名self.name = name# 2.枪 - 新兵没有枪self.gun = Nonedef fire(self):# 1.判断士兵是否有枪if self.gun is None:print("[%s]还没有枪"% self.name)return# 2.口号print("[%s]冲啊..."% self.name)# 3.装填子弹self.gun.add_bullet(50)# 4.发射子弹self.gun.shoot()# 1.创建枪对象
ak47 = Gun("AK47")# 2.创建许三多
xusanduo = Soilder("许三多")xusanduo.gun = ak47
xusanduo.fire()
print(xusanduo.gun)

在定义属性时，如果不知道设置什么初始值，可以设置为None

02 身份运算符

身份运算符用于比较两个对象的内存地址是否一致–是否是对同一个对象的引用

在Python中对None比较时，建议使用is判断

运算符	描述	实例
is	is 是判断两个标识符是不是引用同一个对象	x is y 类似 id(x)==id(y)
is not	is not 是判断两个标识符是不是引用不同对象	x is not y 类似 id(a)!=id(b)

is 和 == 区别

is 用于判断两个变量引用对象是否为同一个
== 用于判断引用变量的值是否相等

>>> a = [1,2,3]
>>> b = [1,2,3]
>>> a is b
False
>>> a == b
True

私有属性和私有方法

01.应用场景及定义方式

应用场景

在实际开发中，对象的 某些属性或方法 可能只希望 在对象的内部被使用 ，不希望在外部被访问到
私有属性 就是对象不希望公开的属性
私有方法 就是对象不希望公开的方法

定义方式

在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是私有属性或方法

class Women:def __init__(self, name):self.name = nameself.__age = 18def __secret(self):# 在对象的方法内部，可以访问对象的私有属性print("%s的年龄是%d"%(self.name, self.__age))xiaoyang = Women("小杨")# 私有属性在外界不能直接访问
# print(xiaoyang.__age)
# 私有方法不允许在外界直接访问
# xiaoyang.secret()

02.伪私有属性和私有方法(科普)

> 提示：在日常开发中，不要使用这种方式，访问对象的私有属性或私有方法

python中，没有真正意义的私有

在给 属性、方法 命名时，实际是对名称做了一些特殊处理，使得外界无法访问到
处理方式：在名称前加上 _类名=>_类名__名称

# 私有属性，外部不能直接访问到
print(xiaoyang._Women__age)
# 私有方法，外部不能直接调用
xiaoyang._Women__secret()

继承

面向对象三个特性

封装根据职责将属性和方法封装到一个抽象的类中
继承实现代码的重用，相同的代码b不需要重复编写
多态不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

1.1 继承的概念、语法和特点

继承的概念：子类拥有父类的所有方法和属性
1）继承的语法

class 类名(父类名):pass

子类继承自父类，可以直接使用父类封装好的方法，不需要再次开发
子类中应该根据职责，封装子类特有的方法和属性

专业术语
子类父类类继承
派生类基类类派生

3）继承的传递性
子类拥有父类以及父类的父类中封装的所有属性和方法

class Animal:def eat(self):print("eat---")def drink(self):print("drink---")def run(self):print("run")def sleep(self):print("sleep")class Dog(Animal):def bark(self):print("bark")class Cat(Animal):def catch(self):print("catch mouse")class XiaoTianQuan(Dog):def fly(self):print("fly")gouzi = XiaoTianQuan()gouzi.eat()
gouzi.drink()
gouzi.run()
gouzi.sleep()
gouzi.bark()
gouzi.fly()

1.2方法重写

子类拥有父类的所有 方法和属性
子类可以直接使用父类封装好的方法属性
当父类的方法实现不满足子类需求时，可以对方法进行重写

重写父类方法两种情况：

覆盖父类的方法
对父类方法进行扩展

1）覆盖父类的方法

父类与子类方法实现完全不同
用覆盖的方法在子类中重新编写父类的方法

具体实现方式，在子类中定义了一个和父类同名的方法实现

重写之后运行中只会调用 子类重写的方法，而不再调用 父类封装的方法

class Animal:def eat(self):print("eat---")def drink(self):print("drink---")def run(self):print("run")def sleep(self):print("sleep")class Dog(Animal):def bark(self):print("bark")class XiaoTianQuan(Dog):# 如果子类中，重写了父类方法# 使用子类对象调用方法时，会调用子类中重写的方法def bark(self):print("speaking")def fly(self):print("fly")gouzi = XiaoTianQuan()gouzi.bark()

对父类方法进行扩展

如果在开发中， 子类的方法实现 中包含 父类方法实现
- 父类原本封装的方法实现 是 子类方法的一部分
可以使用扩展
1. 在子类中重写 父类的方法
2. 在需要的位置使用super().父类方法来调用父类方法的执行
3. 代码其他的位置针对子类的需求，编写 子类特有的代码实现

关于super

在Python中super是一个 特殊的类
super()就是使用super类创建出来的对象
最常使用的场景就是在 重写父类方法时，调用 在父类中封装的方法实现

class Animal:def eat(self):print("eat---")def drink(self):print("drink---")def run(self):print("run")def sleep(self):print("sleep")class Dog(Animal):def bark(self):print("bark")class XiaoTianQuan(Dog):def fly(self):print("fly")def bark(self):# 1.针对子类特有的需求编写代码print("god!")# 2. 使用super().调用原本在父类中封装的方法super().bark()# 3. 增加其他子类的代码print("!!!???")
gouzi = XiaoTianQuan()gouzi.bark()

调用父类方法的另一种方式

在Python 2.x时，如果需要调用父类的方法，还可以使用以下方式:
父类名.方法(self)

这种方式，目前在
Python 3.x
还支持这种方式
这种方法 不推荐使用，因为一旦 父类发生变化 ，方法调用位置的类名同样需要修改

提示

开发时，父类名和 super()两种方式不要混用
如果使用 当前子名 调用方法，会形成递归调用，出现死循环

多重继承

class Base1:def foo1(self)：print('foo1, Base1')class Base2:def foo2(self):print('foo2, Base2')class C(Base1, Base2):passc = C()
c.foo1()
>>>foo1, Base1
c.foo2()
>>>foo2, Base2

组合

class Turtle:def __init__(self,x):self.num = xclass Fish:def __init__(self,x):self.num = xclass Pool:def __init__(self,x,y):self.turtle = Turtle(x)self.fish = Fish(y)def print_num(self):print("水池有乌龟%d只，鱼%d只"%(self.turtle.num,self.fish.num))>>> pool = Pool(1,2)   # 先初始化
>>> pool.print_num()   # 再调用类函数
水池有乌龟1只，鱼2只

类类对象实例对象

>>> a = C()
>>> b = C()
>>> c = C()
>>> print(a.count, b.count, c.count)
0 0 0
>>> c.count += 10
>>> print(a.count, b.count, c.count)
0 0 10
>>> C.count += 100
>>> print(a.count, b.count, c.count)
100 100 10对实例对象c的count属性进行赋值后，就相当于覆盖了类对象C的count属性，
如果没有赋值覆盖，那么引用的是类对象的count属性。

绑定

>>> class CC:def setXY(self,x,y):self.x = xself.y = ydef setprintXY(self):print(self.x,self.y)>>> dd = CC()
>>> dd.__dict__
{}
>>> CC.__dict__
mappingproxy({'__module__': '__main__',
'setXY': <function CC.setXY at 0x000001EE484BD678>,
'setprintXY': <function CC.setprintXY at 0x000001EE484BD708>,
'__dict__': <attribute '__dict__' of 'CC' objects>,
'__weakref__': <attribute '__weakref__' of 'CC' objects>,
'__doc__': None})>>> dd.setXY(2,3)
>>> dd.__dict__
{'x': 2, 'y': 3}完全归功于self参数：当实例对象dd去调用setXY方法的时候，
它传入的第一个参数就是dd，那么self.x = 4，self.y = 5也就相当于dd.x = 4,dd.y = 5，
所以在实例对象甚至类对象中，都看不到x和y，因为这两个属性是只属于实例对象dd的。
如果把类实例删除掉，实例对象dd还能调用printXY方法

内置函数

issubclass(class, classinfo)如果第一个参数（class）是第二个参数（classinfo）的一个子类，则返回True，否则返回False。
（1）一个类被认为是其自身的子类。
（2）classinfo可以是类对象组成的元组，只要class是其中任何一个候选类的子类，则返回True。
（3）在其他情况下，会抛出一个TypeError异常。

>>> class A:pass>>> class B(A):pass>>> issubclass(B,A)
True
>>> issubclass(B,B)
True
>>> issubclass(B,object) # object是所有类的基类
True
>>> class C:pass>>> issubclass(B,C)
False

2）isinstance(object, classinfo)如果第一个参数（object）是第二个参数（classinfo）的实例对象，则返回True，否则返回False。
（1）如果object是classinfo的子类的一个实例，也符合条件。
（2）如果第一个参数不是对象，则永远返回False。
（3）classinfo可以是类对象组成的元组，只要object是其中任何一个候选类的子类，则返回True。
（4）如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常。

>>> b1 = B()
>>> isinstance(b1,B)
True
>>> isinstance(b1,C)
False
>>> isinstance(b1,A)
True
>>> isinstance(b1,(A,B,C))
True

3）hasattr(object, name)
attr即attribute的缩写，属性的意思。接下来将要介绍的几个BIF都是与对象的属性有关系的，例如hasattr()函数的作用就是测试一个对象里是否有指定的属性。第一个参数（object）是对象，第二个参数（name）是属性名（属性的字符串名字）。

>>> class C:def __init__(self, x=0):self.x = x>>> c1 = C()
>>> hasattr(c1,'x') # 属性名要用''括起来
True

4）getattr(object, name[, default])
返回对象指定的属性值，如果指定的属性不存在，则返回default（可选参数）的值；若没有设置default参数，则抛出ArttributeError异常。

>>> getattr(c1,'x')
0
>>> getattr(c1,'y')
Traceback (most recent call last):File "<pyshell#7>", line 1, in <module>getattr(c1,'y')
AttributeError: 'C' object has no attribute 'y'
>>> getattr(c1,'y','访问不存在')
'访问不存在'

5）setattr(object, name, value)
与getattr()对应，setattr()可以设置对象中指定属性的值，如果指定的属性不存在，则会新建属性并赋值。

>>> setattr(c1, 'y', 'Y')
>>> getattr(c1, 'y')
'Y'

6）delattr(object, name)
与setattr()相反，delattr()用于删除对象中指定的属性，如果属性不存在，则抛出AttributeError异常。

>>> delattr(c1, 'y')
>>> delattr(c1, 'z')
Traceback (most recent call last):File "<pyshell#12>", line 1, in <module>delattr(c1, 'z')
AttributeError: z

7）property(fget=None, fset=None, fdel=None, doc=None)


class C:def __init__(self, size = 10):self.size = sizedef getSize(self):return self.sizedef setSize(self, value):self.size = valuedef delSize(self):del self.sizex = property(getSize, setSize, delSize)>>> c = C()
>>> c.x
10
>>> c.x = 12
>>> c.x
12
>>> c.size
12
>>> del c.x
>>> c.size
Traceback (most recent call last):File "<pyshell#19>", line 1, in <module>c.size
AttributeError: 'C' object has no attribute 'size'

property()返回一个可以设置属性的属性，当然如何设置属性还是需要人为来写代码。第一个参数是获得属性的方法名（例子中是getSize），第二个参数是设置属性的方法名（例子中是setSize），第三个参数是删除属性的方法名（例子中是delSize）。property()有什么作用呢？举个例子，在上面的例子中，为用户提供setSize方法名来设置size属性，并提供getSize方法名来获取属性。但是有一天你心血来潮，突然想对程序进行大改，就可能需要把setSize和getSize修改为setXSize和getXSize，那就不得不修改用户调用的接口，这样的体验非常不好。有了property()，所有问题就迎刃而解了，因为像上面例子中一样，为用户访问size属性只提供了x属性。无论内部怎么改动，只需要相应地修改property()的参数，用户仍然只需要去操作x属性即可，没有任何影响。

构造与析构

__init__(self[, ...])
# 相当于其他面向对象编程语言的构造方法，也就是类在实例化成对象的时候首先会调用的一个方法。class Rectangle:def __init__(self,x,y):self.x = xself.y = ydef getPeri(self):return (self.x + self.y) * 2def getArea(self):return self.x * self.y>>> rec = Rectangle(2,3)
>>> rec.getPeri()
10
>>> rec.getArea()
6
>>>

_ init _()方法的返回值一定是None,不能是其他：

只有在需要进行初始化的时候才重写__init__()方法。

__new__(cls[, ...])

__new__()
才是在一个对象实例化的时候调用的第一个方法,
它的第一个参数不是self而是这个类(cls)，而其他的参数会直接传递给
__init__()
方法。

__new__()
方法需要返回一个实例对象，通常是cls这个类实例化的对象，当然也可以返回其他对象。
new()方法平时很少去重写它，一般让Python用默认的方案执行就可以了。但是有一种情况需要重写这个魔法方法，就是当继承一个不可变的类型的时候，它的特性就显得尤为重要了。

>>> class CapStr(str):def __new__(cls, string):string = string.upper()return str.__new__(cls, string)>>> c = CapStr("you win!")
>>> c
'YOU WIN!'str._ _new_ _(cls, string)
这种做法是值得推崇的，只需要重写我们关注的那部分内容

__del__(self)

当对象将要被销毁的时候，这个方法就会被调用。但一定要注意的是，并非del x就相当于自动调用
x.__del__()，__del__()
方法是当垃圾回收机制回收这个对象的时候调用的。

>>> class C:def __init__(self):print("__init__")def __del__(self):print("__del__")>>> c1 = C()    # 对象初始化时候调用init
__init__
>>> c2 = c1
>>> c3 = c2
>>> del c1
>>> del c2
>>> del c3      # 对象销毁时调用del
__del__

main的作用

if __name__ == "__main__":
这个内置函数的主要作用是将import中的其他模块放在该部分之下，进行运行

11 Python 类和对象相关推荐

Python类与对象实验
一.任务描述本实验任务主要对Python类与对象进行一些基本操作,通过完成本实验任务,要求学生熟练掌握Python类与对象的关系,并对Python类与对象的基本操作进行整理并填写工作任务报告. ...
python类包含对象的个数_python类与对象各个算数运算魔法方法总结
1.python类与对象各个算术运算魔法方法总结: 2.各个魔法方法应用举例: 3.实例训练: (1)我们都知道在 Python 中,两个字符串相加会自动拼接字符串,但遗憾的是两个字符串相减却抛出异常 ...
【Python基础入门系列】第10天：Python 类与对象
首先,我已经假定你是个萌新或已经看了无数遍的垃圾文章,然后依然搞不懂类和对象,但是呢起码知道有类和对象这么两个玩意儿,我觉得有必要找一篇生动形象的示例来讲解. 由于你可能没有编程经验, 所以无法从学过 ...
一文讲全了Python 类和对象内容
摘要:这是一个关于 Python 类和对象的全部内容. 本文分享自华为云社区<从零开始学python | Python 类和对象-面向对象编程>,原文作者:Yuchuan . Pytho ...
python类和对象_Python类和对象
python类和对象 Python is an object-oriented programming language. Python Classes and Objects are the cor ...
python中对象的特性_python中类与对象之继承，python类和对象理解,面对对象的三大特性之...
python中类与对象之继承,python类和对象理解,面对对象的三大特性之面对对象的三大特性之继承 1.什么是继承? 在程序中,继承指的是class与class之间的关系继承是一种关系,必须存在 ...
python类和对象介绍_Python开发基础-Day17面向对象编程介绍、类和对象
面向对象变成介绍面向过程编程核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西.主要应用在一旦完成很少修改的地方,如linux ...
Python类和对象使用
Python学习的第N天类和对象一.定义类 class 类名 :变量方法 1.1 def 方法名(self,参数):内容 (self.name=name) 注意:self不是参数,而是必须带的,相 ...
九 Python 类与对象详解，这是软件工程师的分水岭
目录 1 为什么要面向对象编程 2 核心思想 3 初次体验 4 初始化方法 5 类专用的方法 6 继承(有点像生物的基因传递) 7 灵活的Python,属性自由 8 一切皆是对象 9 OOP的设计方法 ...

11 Python 类和对象