Python 【类与对象】
类与对象
把类的个例就叫做实例 (instance),可理解为“实际的例子”
类是某个特定的群体,实例是群体中某个具体的个体
Python中的对象等于类和实例的集合:即类可以看作是对象,实例也可以看作是对象,
比如列表list是个类对象,[1,2]是个实例对象,它们都是对象
“万事万物,皆为对象”
类的创建和调用
类的创建
类名的首字母要大写
class Chinese: # 创建一个类
eye = 'black' def eat(self): #参数self的特殊之处:在定义时不能丢,在调用时要忽略
print('吃饭,选择用筷子。') wu = Chinese() # 类的实例化
print(wu.eye) # 实例调用类属性
wu.eat() # 调用类中的方法(传参不用管self)
print(type(wu))
<class '__main__.Chinese'> #验证了wufeng属于Chinese这个类
print(wu)
<__main__.Chinese object at 0x7f295682d400> #Chinese类的一个实例对象(object),后面的一串字符表示这个对象的内存地址
#类中创建的属性和方法可以被其所有的实例调用,
而且,实例的数目在理论上是无限的。
我们可以同时“新建”多个实例
类也被称为“实例工厂”,因其为所有实例提供了一套蓝图(即预先设定好有什么属性和方法)
创建类的两个关键点
一 。特殊参数:self
那么如果想在类的内部调用类属性,而实例又还没创建之前,我们就需要有个变量先代替实例接收数据,这个变量就是参数self。
class Chinese: name = '吴' # 类属性name def say(self):
print(self.name + '是中国人') person = Chinese() # 创建Chinese的实例person
person.say() # 调用实例方法
当最后一行代码运行时,实例person会像参数一样传给self,替换掉self,self.name等价于person.name
person.name就相当于调用了类属性name(即'吴'),然后跑完整个方法
相当于以下:
class Chinese: name = '吴' # 类属性name def say(person):
print(person.name + '是中国人') person = Chinese() # 创建Chinese的实例person
person.say() # 调用实例方法
吴是中国人
如果想在类的方法内部调用其他方法时,我们也需要用到self来代表实例
class Chinese: def greeting(self):
print('很高兴遇见你') def say(self):
self.greeting()
print('我来自中国') person = Chinese() # 创建实例person person.say() # 调用say()方法
很高兴遇见你
我来自中国
self代表的是类的实例本身,方便数据的流转
对此,我们需要记住两点
第一点:只要在类中用def创建方法时,就必须把第一个参数位置留给 self,并在调用方法时忽略它(不用给self传参)。
第二点:当在类的方法内部想调用类属性或其他方法时,就要采用self.属性名或self.方法名的格式。
##############################################################################################
二。特殊方法:初始化方法 (也叫构造函数)
定义初始化方法的格式是def __init__(self),是由init加左右两边的【双】下划线组成
初始化方法的作用在于:当每个实例对象创建时,该方法内的代码无须调用就会自动运行。
class Chinese: def __init__(self):
print('很高兴遇见你,我是初始化方法') person = Chinese()
很高兴遇见你,我是初始化方法
编写习惯上,我们会在初始化方法内部完成类属性的创建,为类属性设置初始值,
这样类中的其他方法就能直接、随时调用
class Chinese:
def __init__ (self):
self.mouth = 1 # self.不能丢
self.eye = 2 def body(self):
print('我有%s张嘴巴' % self.mouth)
print('我有%s只眼睛' % self.eye) person = Chinese()
person.body()
我有1张嘴巴
我有2只眼睛
除了设置固定常量,初始化方法同样可以接收其他参数
class Chinese: def __init__(self, name, birth, region):
self.name = name # self.name = '吴'
self.birth = birth # self.birth = '广东'
self.region = region # self.region = '深圳' def born(self):
print(self.name + '出生在' + self.birth) def live(self):
print(self.name + '居住在' + self.region) person = Chinese('吴','广东','深圳') # 传入初始化方法的参数
#初始化方法有多个参数的时候,在实例化的时候就要传入相应的值
person.born()
person.live()
吴出生在广东
吴居住在深圳
#其实还可以不用初始化方法也能实现
但是此方法比不上初始化方法
初始化优点:
至少不必重复传参,传入的数据还可以被多次调用
class Chinese: def born(self, name, birthplace):
print(name + '出生在' + birthplace) def live(self, name, region):
print(name + '居住在' + region) #不建议用此方法 person = Chinese()
person.born('吴','广东')
person.live('吴','深圳')
一次性调用
class Chinese:
def __init__(self,hometown,region):
self.hometown = hometown
self.region = region
print('程序持续更新中……') def born(self):
print('我生在%s。'%(self.hometown)) def live(self):
print('我在%s。'%(self.region)) # 新建方法,调用上面的两个方法(注:方法名可自定义)。
def citys(self):
self.born()
self.live() wu = Chinese('广东', '深圳')
wu.citys()
# 调用方法后,程序运行方法中的代码(即依次调用方法`born`和`live`)。
程序持续更新中……
我生在广东。
我在深圳。
#####################################################################################################
面向对象编程
与面向对象编程相对应的是面向过程编程
面向过程编程:首先分析出解决问题所需要的步骤(即“第一步做什么,第二步做什么,第三步做什么”),
然后用函数实现各个步骤,再依次调用。
面向对象编程,将代码具体的数据和处理方法都封装在类中,让我们不用完全了解过程也可以调用类中的各种方法。
这个优势让我们可以在 Python 中轻松地调用各种标准库、第三方库和自定义模块(可以简单理解成别人写好的类)
#类编写一个直观的好处就是参数的传递会比普通函数要省事很多,也不必考虑全局变量和局部变量,因为类中的方法可以直接调用属性。
#####################################################################################################################
综合例子
class Robot:
def __init__(self):
self.name = input('我现在刚诞生,还没有名字,帮我起一个吧。')
self.master = input('对了,我要怎么称呼你呢?')
print('你好%s,我叫%s。很开心,遇见你~'%(self.master,self.name)) def say_wish(self):
wish = input('告诉我一个你的愿望吧:')
print(self.master+'的愿望是:')
# 这里也可以用字符串的格式化,不过,用循环语句的话,之后改复述次数会方便些。
for i in range(3):
print(wish) robot1 = Robot()
robot1.say_wish()
#############################################################################################################################
类的继承和定制
A类属于B类,自然也拥有了B类的所有属性和方法。
这句话在编程里就是:A类继承了B类。
Python中,我们的习惯表述是:A类是B类的子类,而B类是A类的父类(或超类)
定制
子类也可以在继承的基础上进行个性化的定制
(1)创建新属性、新方法;
(2)修改继承到的属性或方法。
————————————————————————————————————————————
继承的基础语法
class Chinese:在运行时相当于class Chinese(object):。
而object,是所有类的父类,我们将其称为根类(可理解为类的始祖)。
#函数isinstance(),判断某个实例是否属于某个类
print(isinstance(1,int)) ## 判断1是否为整数类的实例
True
print(isinstance(1,str))
False
print(isinstance(1,(int,str))) # 判断实例是否属于元组里几个类中的一个
True
class Chinese:
pass class Cantonese(Chinese):
pass gonger = Chinese()
yewen = Cantonese() print('\n验证1:子类创建的实例同时也属于父类')
print(isinstance(gonger,Chinese))
print(isinstance(yewen,Chinese)) print('\n验证2:父类创建的实例不属于子类。')
print(isinstance(gonger,Cantonese)) print('\n验证3:类创建的实例都属于根类。')
print(isinstance(gonger,object))
print(isinstance(yewen,object)) 验证1:子类创建的实例同时也属于父类
True
True 验证2:父类创建的实例不属于子类。
False 验证3:类创建的实例都属于根类。
True
True
————————————————————————————————————————————
类的继承之多层继承
子类创建的实例可调用所有层级父类的属性和方法
class Earthman:
eye_number = 2 # 中国人继承了地球人
class Chinese(Earthman):
eye_color = 'black' # 广东人继承了中国人,同时也继承了地球人。
class Cantonese(Chinese):
pass yewen = Cantonese()
print(yewen.eye_number)
print(yewen.eye_color)
2
black
####################################################################
类的继承之多重继承
一个类,可以同时继承多个类,
语法为 class A(B,C,D):
就近原则:
越靠近子类(即越靠左)的父类,越亲近,越优先考虑。子类调用属性和方法时,会先在靠左的父类里找,找不到才往右找。
class Su:
born_city = 'Jiangsu'
wearing = 'thick' def diet(self):
print('我们爱吃甜。') class Yue:
settle_city = 'Guangdong'
wearing = 'thin' def diet(self):
print('我们吃得清淡。') class Yuesu(Yue,Su):
pass xiaoming = Yuesu()
print(xiaoming.wearing) # 先在 Yue类找,找到了,打印出来。
print(xiaoming.born_city) # Yue类没有born_city,才去Su类找。
xiaoming.diet() # 方法调用,和属性调用一样,也符合就近原则。 thin
Jiangsu
我们吃得清淡。
类的定制
定制,可以新增代码
class Chinese:
eye = 'black' def eat(self):
print('吃饭,选择用筷子。') class Cantonese(Chinese): # 类的继承
native_place = 'guangdong' # 类的定制 def dialect(self): # 类的定制
print('我们会讲广东话。') yewen = Cantonese()
print(yewen.eye) # 父类的属性能用
print(yewen.native_place) # 子类的定制属性也能用
yewen.eat() # 父类的方法能用
yewen.dialect() # 子类的定制方法也能用 black
guangdong
吃饭,选择用筷子。
我们会讲广东话。
定制,也可重写代码
在子类中,对父类代码的修改
子类继承父类方法的操作是在def语句后接父类.方法(参数)
class Chinese: def land_area(self,area):
print('我们居住的地方,陆地面积是%d万平方公里左右。'% area) class Cantonese(Chinese):
# 间接对方法进行重写
def land_area(self, area, rate = 0.0188):
Chinese.land_area(self, area * rate)
# 直接继承父类方法,再调整参数。 gonger = Chinese()
yewen = Cantonese()
gonger.land_area(960)
yewen.land_area(960)
提示:初始化方法的定制,和一般的实例方法的定制是一样的。
class Chinese:
def __init__(self, greeting='你好', place='中国'):
self.greeting = greeting
self.place = place def greet(self):
print('%s!欢迎来到%s。' % (self.greeting, self.place)) # 请为子类完成定制,代码量:两行。
class Cantonese(Chinese):
def __init__(self, greeting='雷猴', place='广东'): #重写代码最好是在继承方法的基础上通过代码的调整完成定制
Chinese.__init__(self, greeting ,place) yewen = Cantonese()
yewen.greet()
雷猴!欢迎来到广东。
###################################################################################################################
列子
class Student:
def __init__(self, name, job=None, time=0.00, time_effective=0.00):
self.name = name
self.job = job
self.time = time
self.time_effective = time_effective def count_time(self, hour, rate):
self.time += hour
self.time_effective += hour * rate class Programmer(Student):
def __init__(self, name): #此处为啥只留name参数,因为没有给出默认值,需要传入参数,不能省略,然后其他都是默认参数
Student.__init__(self, name, job='programmer', time=0.00, time_effective=0.00) def count_time(self, hour, rate=1):
Student.count_time(self, hour, rate) student1 = Student('韩梅梅')
student2 = Programmer('李雷') print(student1.job)
print(student2.job) student1.count_time(10, 0.8)
student2.count_time(10) print(student1.time_effective)
print(student2.time_effective)
Python 【类与对象】的更多相关文章
- python类与对象各个算数运算魔法方法总结
1.python类与对象各个算术运算魔法方法总结: 2.各个魔法方法应用举例: 3.实例训练: (1)我们都知道在 Python 中,两个字符串相加会自动拼接字符串,但遗憾的是两个字符串相减却抛出异常 ...
- python 类和对象的属性
python类和对象的属性分为类属性和对象属性两大类,类属性属于类,而对象属性属于对象. 1. 父类的对象属性会被子类的对象继承. 2. 父类的类属性会被子类继承,还是作为类属性,如果父类改变了类属性 ...
- 一文讲全了Python 类和对象内容
摘要:这是一个关于 Python 类和对象的全部内容. 本文分享自华为云社区<从零开始学python | Python 类和对象-面向对象编程>,原文作者:Yuchuan . Pytho ...
- python类、对象
python类.对象 学习完本篇,你将会深入掌握 什么是类,对象 了解类和对象之间的关系 能独立创建一个People(人类),属性有姓名.性别.年龄.提供一个有参的构造方法,编写一个show方法,输出 ...
- python 类、对象、方法、属性
在python中,一个对象的特征也称为属性(attribute).它所具有的行为也称为方法(method) 结论:对象=属性+方法 在python中,把具有相同属性和方法的对象归为一个类(class) ...
- python类、对象、方法、属性之类与对象笔记
python中一切皆为对象,所谓对象:我自己就是一个对象,我玩的电脑就是对象,坐着的椅子就是对象,家里养的小狗也是一个对象...... 我们通过描述属性(特征)和行为来描述一个对象的.比如家里的小狗, ...
- python类与对象基本语法
面向对象编程的2个非常重要的概念:类和对象. 对象是面向对象编程的核心,在使用对象的过程中,为了将具有共同特征和行为的一组对象抽象定义,提出了另外一个新的概念--类. 类就相当于制造飞机时的图纸,用它 ...
- python 类和对象
类和对象 类 1.类的组成 数据和函数,二者是类的属性 2.两个作用: 实例化 属性引用 属性引用:类名.属性(增删改查) 实例化: 类名加括号就是实例化,会自动出发__init__的运行 ...
- Python类和对象
目录 类与对象 其他方法 继承 经典类和新式类 派生 组合 接口.归一化设计与抽象类 继承实现的原理 子类中调用父类的方法 指名道姓 super()方法 多态与多态性 封装 单下划线开头 双下划线开头 ...
- python类与对象的组合与继承
1.把类的对象实例化放到一个新的类里面叫做类的组合,组合就是指几个横向关系的类放在一起,纵向关系的类放在一起是继承,根据实际应用场景确定.简单的说,组合用于“有一个”的场景中,继承用于“是一个”的场景 ...
随机推荐
- Linux 系统监控shell脚本
比较粗略的一个脚本:主要监控系统磁盘.CPU.内存.网络流量.tcp连接数等 代码如下: [root@test system_monitor_shell_script]# cat system_mon ...
- 走进JavaWeb技术世界8:浅析Tomcat9请求处理流程与启动部署过程
谈谈 Tomcat 请求处理流程 转自:https://github.com/c-rainstorm/blog/blob/tomcat-request-process/reading-notes &l ...
- java权限管理与用户角色权限设计
java权限管理与用户角色权限设计 实现业务系统中的用户权限管理 B/S系统中的权限比C/S中的更显的重要,C/S系统因为具有特殊的客户端,所以访问用户的权限检测可以通过客户端实现或通过客户端+服务器 ...
- Flutter移动电商实战 --(48)详细页_详情和评论的切换
增加切换的效果,我们主要是修改这个地方 这样我们的评论的内容就显示出来了 最终代码 details_web.dart import 'package:flutter/material.dart'; i ...
- CRF 初步了解
国外有一个很著名的条件随机场的教程,是英文的,原文: http://blog.echen.me/2012/01/03/introduction-to-conditional-random-fields ...
- centos6.6 ftp 配置 修改默认端口等
常规下21端口容易遭到别人的扫描.带来了一定程度的不安全.所以,最好的就是把21端口修改掉. 默认修改为6069 一.修改vsftp的配置文件 vi /etc/vsftpd/vsftpd.conf 在 ...
- python wmi远程数据获取
- Tosca Connection Validation error:40 - Could not open a connection to SQL Server (不知道怎么解决)
谁知道下面这个错怎么解决,请给我留言,谢谢. 数据库能正常链接,服务也是 normal running
- cin中的注意事项
猎豹网校C++ Primer学习笔记 - ostartech - 博客园 https://www.cnblogs.com/wxl845235800/p/11396323.html 在VS中使用cin& ...
- Greenwich.SR2版本的Spring Cloud Config+BUS实例
Spring Cloud Config统一的配置中心同注册中心Eureka一样,也分服务端和客户端.服务端用来保存配置信息,客户端用来读取.它的优势是基于Git仓库,支持多环境.多分支配置.动态刷新. ...