实例方法:在类的内部,使用def关键字来定义 第一个参数默认是self[名字标识可以是其他的名字,但是这个位置必须被占用]
实例方法是归于 类的实例所有
属性:在类的内部定义的变量[类属性]
定义在方法里面使用self引用的属性称之为实例属性
属性:在类的内部定义的变量[类属性]
在方法内部定义的[通过类似于self,变量名] 变量,是实例属性
class Person: #单词的首字母全部大写
'''
对应人的特征
'''
# name='小明' #类属性
age=20
'''
对应人的特征
'''
def __init__(self):
self.name='小明' #实例属性
pass
def eat(self):
print('大口的吃饭')
pass
def run(self):
print('飞快地跑')
pass
pass
# 创建对象 [类的实例化]
xm=Person() #声明一个对象
xm.eat() #调用函数
xm.run()
_init_
class People:
def __init__(self): #凡是由双下划线包裹的函数是python中内置好的函数
# 统一声明实例属性
self.name='消息'
self.sex='female'
self.age=20
pass
def eat(self): #默认参数self
'''
吃的行为
:return:
'''
print('喜欢吃榴莲,并不')
pass
pass
xp=People() #创建出来的
xp.name='小p' #添加实例属性
xp.sex='male'
xp.age=103
xp.eat()
print(xp.name,xp.sex,xp.age)
xm=People() #此时已具备初始化实例属性
print(xm.name)
# 如果有n个这个对象被实例化,那么就需要添加很多次这样的属性了,麻烦
# 使用__init__函数
xm=People() #此时已具备初始化实例属性
print(xm.name)
xm.name='小明'
print(xm.name)
数据被写死,不利于使用 使用参数解决这个问题
# init传参改进
class People:
def __init__(self,name,sex,age): #凡是由双下划线包裹的函数是python中内置好的函数
# 统一声明实例属性
self.name=name #将参数传给它,使之更加通用
self.sex=sex
self.age=age
pass
def eat(self): #默认参数self
'''
吃的行为
:return:
'''
print('喜欢吃榴莲,并不')
pass
pass
zp=People('sarah','male',30)
print(zp.name,zp.sex ,zp.age )
wx=People('joe','female',18)
print(wx.age ,wx.name ,wx.sex ) #传参并输出
# init传参改进
class People:
def __init__(self,name,sex,age): #凡是由双下划线包裹的函数是python中内置好的函数
# 统一声明实例属性
self.name=name #将参数传给它,使之更加通用
self.sex=sex
self.age=age
pass
def eat(self,food): #默认参数self
'''
吃的行为
:return:
'''
print(self.name+'喜欢吃'+food)
pass
pass
zp=People('sarah','male',30)
zp.eat('香蕉')
print(zp.name,zp.sex ,zp.age )
wx=People('joe','female',18)
wx.eat('orange')
print(wx.age ,wx.name ,wx.sex ) #传参并输出
总结 _init_
1.python自带的内置函数,具有特殊的函数 使用双下划线 包起来的[魔术方法]
2.是一个初始化的方法 用来定义实例属性和初始化数值的在创建对象的时候自动调用的 不用手动调用
3. 利用传参机制可以让定义功能更加强大并且更方便的类
理解self
class Person: #可以省略object 注意加注释,方便阅读
'''
定义类
'''
# 定义类属性,类方法,实例属性
def eat(self):
'''
实例方法
:return:
'''
print('self=%s'%id(self)) #打印self,
pass
pass
xw=Person() #创建实例对象
print('xw=%s'%id(xw)) #xw的实例地址和self的地址相同,即self就指向实例本身
xw.eat() #self是一个对象,会自动指向,无需传递任何参数吧
class Person: #可以省略object 注意加注释,方便阅读
'''
定义类
'''
# 定义类属性,类方法,实例属性
def eat(self,name,food): #可以发现self不需要传递,self本身就是对象,会自动将对象填充过来,直接使用
'''
实例方法
:return:
'''
# print('self=%s'%id(self)) #打印self
print('%s 喜欢吃 %s'%(name,food))
pass
pass
xw=Person() #创建实例对象
# print('xw=%s'%id(xw)) #xw的实例地址和self的地址相同
xw.eat('小王','留恋') #self是一个对象,会自动指向,无需传递任何参数吧
小结
self特点 self只有在类中定义 实例方法的时候才有意义,在调用时候不必传入相应的参数,而是由解释器自动的去指向
self的名称是可以更改的 可以定义成其他的名字,只是约定俗成的定义成self
self指的是 类实例对象本身 相当于Java中的 this
class Person: #可以省略object 注意加注释,方便阅读
def __init__(self,pro): #定义实例属性
'''
专业
'''
self.pro=pro #实例属性的定义
pass
'''
定义类
'''
# 定义类属性,类方法,实例属性
def eat(a,name,food): #可以发现self不需要传递,self本身就是对象,会自动将对象填充过来,直接使用
'''
实例方法
:return:
'''
# print('self=%s'%id(self)) #打印self
print('%s 喜欢吃 %s 修的专业是%s'%(name,food,a.pro))
pass
pass
xw=Person('心理学') #创建实例对象
# print('xw=%s'%id(xw)) #xw的实例地址和self的地址相同
xw.eat('小王','留恋') #self是一个对象,会自动指向,无需传递任何参数吧
魔法方法
class Person: #可以省略object 注意加注释,方便阅读
def __init__(self,pro,name,food): #定义实例属性
'''
专业
姓名
食物
'''
self.pro=pro #实例属性的定义
self.name=name
self.food=food
pass
'''
定义类
'''
# 定义类属性,类方法,实例属性
def eat(self,name,food): #可以发现self不需要传递,self本身就是对象,会自动将对象填充过来,直接使用
'''
实例方法
:return:
'''
# print('self=%s'%id(self)) #打印self
print('%s 喜欢吃 %s 修的专业是%s'%(self.name,self.food,self.pro))
pass
pass
def __str__(self):
'''
打印对象 自定义对象的内容格式
:return:
'''
return '%s 喜欢吃 %s 修的专业是%s'%(self.name,self.food,self.pro)
pass
xw=Person('心理学','rain','banana') #创建实例对象
# print('xw=%s'%id(xw)) #xw的实例地址和self的地址相同
# xw.eat('小王','留恋') #self是一个对象,会自动指向,无需传递任何参数吧
print(xw)
class Person: #可以省略object 注意加注释,方便阅读
def __init__(self,pro,name,food): #定义实例属性
'''
专业
姓名
食物
'''
self.pro=pro #实例属性的定义
self.name=name
self.food=food
print('--------init---------函数执行')
pass
'''
定义类
'''
# 定义类属性,类方法,实例属性
def eat(self,name,food): #可以发现self不需要传递,self本身就是对象,会自动将对象填充过来,直接使用
'''
实例方法
:return:
'''
# print('self=%s'%id(self)) #打印self
print('%s 喜欢吃 %s 修的专业是%s'%(self.name,self.food,self.pro))
pass
pass
def __str__(self):
'''
打印对象 自定义对象的内容格式
:return:
'''
return '%s 喜欢吃 %s 修的专业是%s'%(self.name,self.food,self.pro)
pass
def __new__(cls,*args,**kwargs): #在实例化的过程中会首先执行new函数,NOne代表函数并未
# 创建成功,因为再此函数中,只是让其打印,并未创建函数
'''
创建实例对象的方法 每调用一次就会声明一个新的对象 cls就是class的缩写
:param args:
:param kwargs:
'''
print('------------new函数的执行------------')
pass
xw=Person('心理学','rain','banana') #创建实例对象
# print('xw=%s'%id(xw)) #xw的实例地址和self的地址相同
# xw.eat('小王','留恋') #self是一个对象,会自动指向,无需传递任何参数吧
print(xw)
class Person: #可以省略object 注意加注释,方便阅读
def __init__(self,pro,name,food): #定义实例属性
'''
专业
姓名
食物
'''
self.pro=pro #实例属性的定义
self.name=name
self.food=food
print('--------init---------函数执行')
pass
'''
定义类
'''
# 定义类属性,类方法,实例属性
def eat(self,name,food): #可以发现self不需要传递,self本身就是对象,会自动将对象填充过来,直接使用
'''
实例方法
:return:
'''
# print('self=%s'%id(self)) #打印self
print('%s 喜欢吃 %s 修的专业是%s'%(self.name,self.food,self.pro))
pass
pass
def __str__(self):
'''
打印对象 自定义对象的内容格式
:return:
'''
return '%s 喜欢吃 %s 修的专业是%s'%(self.name,self.food,self.pro)
pass
def __new__(cls,*args,**kwargs): #在实例化的过程中会首先执行new函数,NOne代表函数并未
# 创建成功,因为再此函数中,只是让其打印,并未创建函数
'''
场景:可以控制创建对象的一些属性限定 经常用来做单例模式时使用
创建实例对象的方法 每调用一次就会声明一个新的对象 cls就是class的缩写
:param args:
:param kwargs:
'''
print('------------new函数的执行------------')
return object.__new__(cls) #cls代表当前类,即Person 是真正创建实例对象的位置
pass
xw=Person('心理学','rain','banana') #创建实例对象
# print('xw=%s'%id(xw)) #xw的实例地址和self的地址相同
# xw.eat('小王','留恋') #self是一个对象,会自动指向,无需传递任何参数吧
print(xw)
__new__和__init__函数的区别
__new__类的实例化方法,必须要返回该实例,否则对象就创建不成功
__init__用来做数据属性的初始化工作 也可以认为是实例的构造方法 接受类的实例 self 并对其进行构造
__new__至少有一个参数是cls 代表要实例化的类,此参数在实例化时由python解释器自动提供
__new函数执行要早于__init__函数