模块中
函数：运行层面
变量
类 ---- 抽象的概念
类的初步理解：变量，函数的封装--------用于刻画一个类型的人或事物的特征和行为的变量和函数的分装。就像一个模板。
类只能用于刻画，描述，而不是执行函数
类中的函数称为方法方法：设计层面 用于刻画行为
数据成员（变量）:用于刻画特征
类是面向对象的，通过创立对象将类实例化
init()称为构造函数（特殊实例方法），初始化对象的属性。一旦创立一个对象，构造函数会自动调用。
class Teachers():
age = 0 #两个特征
name = 'J' #构造函数不是必须的，它起一个初始化的作用
def teacher_intro(self): #一个行为
print(self.age,self.name)
miss_wu = Teachers() #类的实例化 变为一个对象
miss_wu.teacher_intro() #具体对象的一个行为，self.age为实例变量，实际上没有赋值，因此最后搜索到类变量age=0，输出0
teacher_1 = Teachers()
teacher_2 = Teachers() #id不同
#%%
#%%
class Teachers_1():
name= 'universal'
age = 0
def __init__(self):
#构造函数，创立实例后自动执行，self代表的实例对象
print('Hi,I am a teacher.')
# return 'object' 错误 构造函数只能返回NONE
def teacher_intro(self):
print(self.age,self.name)
miss_wu = Teachers_1()
miss_wu.teacher_intro()
miss_wu.name = 'Jake'
miss_wu.life = '123' #由于python的动态性，实例变量可以在局外定义
miss_wu.teacher_intro()
print(miss_wu.life)
Teachers_1.life = '123' #类变量可以在局外定义
#%%
class Teachers_1():
name= 'universal' #类变量
age = 0
def __init__(self,name,age):
name = name #这里是局部变量不影响全局类变量
age = age
print('Hi,I am a teacher.')
def teacher_intro(self):
print(self.age,self.name)
miss_wu = Teachers_1('Jack',11)
#仍然为universal 和 0，因为输出实例变量没有赋值为none，因此搜索类变量得出‘universal’，0，若类变量仍不存在，就会寻找父类变量
miss_wu.teacher_intro()
Print(Teachers_1.name) #在类外调用类变量
类变量：和类相关的变量
实例变量self.name：与对象相关的变量
实例函数function（self）：
class Teachers_1():
name= 'universal' #类变量（在方法外面定义）
age = 0 #不适合具体变量的定义
def __init__(self,name,age):
#name = name
#age = age
self.name = name #实例变量（在方法里面定义）
self.age = age
print('Hi,I am a teacher.')
# return 'object' 错误 构造函数没有返回值
#类中其他函数用到全局变量和构造函数变量时候，要加self.
def teacher_intro(self):
print(self.age,self.name)
miss_wu = Teachers_1('Jack',11)
miss_wu.teacher_intro()
########################
class Teachers_1():
name= 'universal' #类变量
age = 0
def __init__(self,name1,age1): #name1，name2是形参
self.name = name1 #定义实例变量
age = age1 #局部变量
print('Hi,I am a teacher.')
# return 'object' 错误 构造函数没有返回值
print(self.__class__.name) #类方法内调用类变量的方法2
def teacher_intro(self): #实例方法
name = ' Jake' #局部变量 非实例变量
self.age = '10' #实例变量，说明在哪个方法里都可以定义实例变量
#分别是结构函数中定义的实例变量，在本方法中定义的实例变量，在本方法中定义的局部变量name ，类变量name，以及未定义的变量age
print(self.age,self.name,name,Teachers_1.name,age)
miss_wu = Teachers_1('Jack',11)
#miss_wu.name = 'Jake'
miss_wu.teacher_intro()
print(Teachers_1.name) #调用类变量
#Hi,I am a teacher.
#10 Jack Jake
#类变量的正确用法
class Teachers():
sum = 0 #类变量的正确用法
def __init__(self,name1,age1):
Teachers.sum += 1
self.name = name1
self.age = age1
print('The number of teachers is :'+str(self.__class__.sum)) #类方法内调用类变量的方法2
teacher1 = Teachers('Jack',11)
teacher2 = Teachers('Mary',11)
teacher3 = Teachers('Amy',11)
#实例方法括号中的self可以任意更换
class Teachers():
sum = 0 #类变量的正确用法
def __init__(self,name1,age1):
Teachers.sum += 1
self.name = name1
self.age = age1
print('The number of teachers is :'+str(self.__class__.sum)) #类方法内调用类变量的方法2
def homework(this): #实例方法括号中的self可以任意更换
print(this.name)
teacher1 = Teachers('Jack',11)
teacher2 = Teachers('Mary',11)
teacher3 = Teachers('Amy',11)
teacher3.homework() #输出值相同
##类方法的应用
class Teachers():
sum = 0 #类变量
def __init__(self,name1,age1): #实例方法关联的是实例对象
Teachers.sum += 1
self.name = name1
self.age = age1
print('The number of teachers is :'+str(self.__class__.sum)) #类方法内调用类变量的方法2
def homework(this):
print(this.name)
@classmethod #类方法的定义 取决于装饰器，括号里面可以是其它字符
def plus_sum(cls): #类方法关联的是类
cls.sum += 1 #这种类变量的表示方式仅限于类方法中
print(cls.sum)
teacher1 = Teachers('Jack',11)
teacher2 = Teachers('Mary',11)
teacher3 = Teachers('Amy',11)
Teachers.sum #调用类变量
Teachers.plus_sum() #调用类方法
teacher3.plus_sum() #对象可以调用类方法，但不推荐
##静态方法的应用
class Teachers():
sum = 0
def __init__(self,name1,age1):
Teachers.sum += 1
self.name = name1
self.age = age1
print('The number of teachers is :'+str(self.__class__.sum))
def homework(this):
print(this.name)
@classmethod
def plus_sum(cls):
cls.sum += 1
print(cls.sum)
# print(self.name) #类方法中不可调用对象变量
@staticmethod #和类、对象没有太大关系
def add_up(x, y): #和类、对象方法的区别在于不需要括号里的self,cls
print('This is a staticmethod.\n'+str(Teachers.sum))
#静态方法可以调用类变量，但不可以调用对象变量
# print(self.name) #静态方法不可调用类方法
teacher1 = Teachers('Jack',18)
teacher1.add_up(1,2) #对象调用静态方法
Teachers.add_up(1,2) #类调用静态方法
teacher1.plus_sum()
总结
变量:类变量，实例变量
方法:类方法，静态方法，实例方法
特殊：构造函数
类变量：
定义：在方法外，局外，类、实例方法内都可
范围：可以在整个类中调用
调用方法：cls.sum（仅限于类方法内） self.class.sum （仅限于实例方法）Teachers.sum（通用）
实例变量
定义：在实例方法内以及由于动态语言设定可以局外定义
范围：仅限于实例方法中调用
调用方法：self.name 其中的self在不同实例函数中可以改 变
类方法
定义：@classmethod 其中cls可以替换
调用方法：Teachers.plus_sum() ， teacher1.plus_sum()
实例方法
定义：无特殊，其中self可以替换
调用方法：teacher1.homework（）
提示：方法不分前后，在创立对象时，会先捋一一遍所有成员的声明，相当于已经知道所有成员
静态方法
定义：@staticmethond 其中没有self、clc地要求
调用方法：teahcer1.add_up() Teachers.add_up() 注意参数
静态方法与实例和类的关系不大
#建议通过方法对对象的参数进行修改。
#成员的可见性 public 、private
方法、变量前面加__双下划线变为私有方法、和私有变量，无法在外部调用、修改。
class Students():
def __init__(self,name,age,score):
self.name = name
self.age = age
self.__score = score
def marking(self):
if self.name == 'Jack':
self.__score = 58
print(self.name+"'s socre is: "+str(self.__score))
def __testing(self): #私有方法，无法在外部调用
print('Private method cannot be used outside.')
student1 = Students('Jake',18,60)
student2 = Students('Jack',18,60)
student1.marking()
student2.marking()
print()
student2.__score = 59
#由于python动态语言的特性，这其实是一个新的实例变量，与实例方法内的self.__score不同
print(student2.name+'\'s score is: '+str(student2.__score)) #实际是新定义的实例变量与实例方法中的__score不同
student2.marking() #分数仍然没有变化
print(student2.__dict__) #{* , '_Students__score': 58, '__score': 59}
print(student2._Students__score) #看到私有变量的形式后，就可以通过魔术方法实现外部读取，修改私有变量
student2.__testing() #不可在外部调用
print(student1.__score) #在外部不可读取
扫一扫
450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
