1、类与对象：
类 是一种抽象的概念:具有某一类共同属性和特性的事物
类一般包含属性以及方法，但不是都必须包含的
类的划分标准：由写代码的人来定
类的语法： 关键字：class
类名规范：数字、字母、下划线组成，不能以数字开头，首字母大写，驼峰命名
类属性：放在类里面的变量值
类方法/类函数：写在类里面的函数
属性和方法只能实例调用
class类名:
类属性
类方法/类函数
# 创建一个男朋友类：
class BoyFriend:
#类属性
height=175
weight=130
money='会赚钱'
#类函数/类方法
# self是一个固定的占坑符，类里面的方法都必须带self这个参数
# 传这个参数说明这是一个类方法/函数，实例可以调用
def msg(self):
print(self)
def cooking(self): #self是实例本身，传递实例
print(self.money+'会做饭的男盆友')
def earn(self):
print('会赚钱的男盆友')2、类里面的方法分为三种
（1）实例方法：意味着这个方法只能实例来调
1-1创建实例： 实例/对象 具体的一个例子 类名()
实例具有类里面的所有属性和方法的使用权限
调用属性 > 实例.属性名
调用方法/函数 > 实例.函数/方法名() ,def开头的才是函数
class BoyFriend:
#类属性
height=175
weight=130
money='会赚钱'
#类函数/类方法
# self是一个固定的占坑符，类里面的方法都必须带self这个参数
# 传这个参数说明这是一个类方法/函数，实例可以调用
def msg(self):
print(self)
def cooking(self): #self是实例本身，传递实例
print(self.money+'会做饭的男盆友')
def earn(self):
print('会赚钱的男盆友')
#创建一个实例/对象，一个具体的例子：类名()
BoyFriend()
#用变量bf存储实例
bf=BoyFriend()
#打印类 <__main__.BoyFriend object at 0x00000214A8234820>，object是一个实体对象，0x00000214A8234820是内存地址，说明创建的对象存在内存地址里
print(bf)
print('*'*30)
# 调用msg函数/方法并打印，可以看出self就是实例本身，也就是说实例本身在调用这个函数/方法且self参数可以修改
bf.msg()
#调用属性：实例.属性名
bf.height
#调用函数/方法：实例.函数名/方法名()
bf.cooking()1-2：不创建实例，直接以类对象进行访问 > 此种方法不推荐使用
# 创建一个男朋友类：
class BoyFriend:
#类属性
height=175
weight=130
money='会赚钱'
def cooking(self): #self是实例本身，传递实例
print(self.money+'会做饭的男盆友')
#不创建实例，直接以类对象进行访问
BoyFriend.cooking()此时运行报错TypeError: BoyFriend.cooking() missing 1 required positional argument: 'self'
在1-1中打印self可以看到“self是实例本身，传递实例”，要解决TypeError: BoyFriend.cooking() missing 1 required positional argument: 'self'问题，需要在函数中传递实例
# 创建一个男朋友类：
class BoyFriend:
#类属性
height=175
weight=130
money='会赚钱'
def cooking(self): #self是实例本身，传递实例
print(self.money+'会做饭的男盆友')
#1、创建实例
bf=BoyFriend()
#2、不创建实例，直接以类对象进行访问，函数名中传递实例
BoyFriend.cooking(bf) #显示的传递实例
#3、创建实例
bf=BoyFriend()
bf.cooking() #隐藏的传递实例以上可以看出，传递实例分为隐藏式的传递和显示的传递，创建实例，使用实例调用属性（方法）属于隐藏的传递，不使用实例，直接以类对象进行访问，在函数名中传递实例属于显示传递
（2）类方法
@classmethod可以直接调用，同时实例也可以
类方法不可以调用类里面的属性值，如果要参数请自己传递
class BoyFriend:
#类属性
height=175
weight=130
money='会赚钱'
@classmethod # 类方法
def swimming(cls):
print('男盆友还要回游泳')
# 类方法不可以调用类里面的属性值，如果要参数请自己传递
# print(self.money+'男盆友还要回游泳') #报错NameError: name 'self' is not defined
#类方法类名调用
BoyFriend.swimming()
#实例调用
b=BoyFriend()
b.swimming()
3、静态方法
@staticmethod 可以直接调用，同时实例也可以
静态方法不可以调用类里面的属性值，如果要参数请自己传递
class BoyFriend:
#类属性
height=175
weight=130
money='会赚钱'
@staticmethod #静态方法
def sing():
print( '男朋友还可以会唱歌来哄女朋友开心的呦')
# 静态方法不可以调用类里面的属性值，如果要参数请自己传递
#print(self.money+'男朋友还可以会唱歌来哄女朋友开心的呦') #报错NameError: name 'self' is not defined
BoyFriend.sing() #静态方法类名调用
bf=BoyFriend()
bf.sing() #实例调用4、 总结：
（1）相同点：
实例方法self、类方法cls、静态方法（普通方法，可传可不传），实例和类名都可以直接调用
（2）不同点：
1.静态方法和类方法不可以调用类里面的属性值，如果要参数请自己传递
2.什么时候去定义为静态方法和类方法？
当你的某个函数与其他的类函数、类属性没有任何关系的时候就可以定义静态方法和类方法
3、初始化函数
1、初始化函数
什么是初始化函数？
class 类:
def __init__(self):
print('实例化成功！')实例 = 类()
初始化函数的意思是，当你创建一个实例的时候，这个函数就会被调用。上面的代码在执行实例 = 类()的语句时，就自动调用了__init__(self)函数。
初始化函数的写法是固定的格式：中间是“init”，这个单词的中文意思是“初始化”，然后前后都要有【两个下划线】，然后__init__()的括号中，第一个参数一定要写上self，不然会报错。
同时，这个初始化函数照样可以传递参数
初始化函数
class TestingEngineer:
#类属性
# name='暖暖'
# age=28
# height=150
# weight=100
# 初始化函数（将固定值的类属性写为初始化函数，可以随时修改值）
def __init__(self,name,age,height,weight): #实例方法
self.name=name
self.age=age
self.height=height
self.weight=weight
#类方法
def work_experience(self):
# print(self.name+'今年'+self.age+'岁,'+'体重'+self.weight+',身高'+self.height+',具有五年的测试工作经验')
print('{0}今年{1}岁,体重{2},身高{3},具有五年的测试工作经验'.format(self.name,self.age,self.weight,self.height))
def tool(self):
print('{0}今年{1}岁,体重{2},身高{3},可以使用jmeter、python等工具'.format(self.name,self.age,self.weight,self.height))
# 初始化函数
t1=TestingEngineer('暖暖','28','150','100')
t1.work_experience()2、所有函数里面的方法，类函数里面都可以有
class TestingEngineer:
#初始化函数
def __init__(self,name,age,height,weight): #实例方法
self.name=name
self.age=age
self.height=height
self.weight=weight
#类方法
# language位置参数,lines默认参数，位置参数要在默认参数前面
def coding(self,language,lines=1000):
print('会{0}语言,已经写了{1}行'.format(language,lines))
#不定长参数
def cooking(self,*agr):
for item in agr:
# print('{0}会做{1}'.format(self.name,item))
print(self.name+'会做{0}'.format(item))
# 返回值
def play(self,play_game):
return(self.name+'会玩{0}'.format(play_game)) #返回值
# 如果类里面有初始化函数，创建实例的时候，就必须要在实例里面传递对应的参数值
实例存储到变量里面去调用
t=TestingEngineer('华华','28','159','100')
t.coding('python')
直接创建实例调用方法
TestingEngineer('华华','28','159','100').coding('python')
t.cooking('西红柿鸡蛋','清炒西蓝花')
#打印出输出的返回值数据
print(t.play('王者荣耀')) 3、初始化函数可以给出默认值或者直接将值写死
class TestingEngineer:
# 初始化函数没有return返回值
# 实例方法，初始化函数可以有默认值参数，一般不传动态参数和不定长参数
def __init__(self,name,age=25):
self.name=name
self.age=age
self.height=160 #身高写死
#类方法
def work_experience(self):
print('{0}今年{1}岁,身高{2},具有五年的测试工作经验'.format(self.name,self.age,self.height))
t=TestingEngineer('华华','180')
t.work_experience()4、类函数之间可以相互调用
class TestingEngineer:
def __init__(self,name,age,height,weight): #实例方法
self.name=name
self.age=age
self.height=height
self.weight=weight
#类方法
#不定长参数
def cooking(self,*agr):
for item in agr:
# print('{0}会做{1}'.format(self.name,item))
print(self.name+'会做{0}'.format(item))
# language位置参数,lines默认参数，位置参数要在默认参数前面
def coding(self,language,*args,lines=1000):
# 函数之间可以相互调用
# self.cooking() #可以不传参
# self.cooking('蛤蜊汤') #此时参数是写死的
self.cooking(*args) #不想写死可以在该函数中传不定长参数
print('会{0}语言,已经写了{1}行'.format(language,lines))
t=TestingEngineer('joy','23','180','120')
t.coding('python','巴巴鱼','草鱼')
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
