一.今日主要内容
1.成员
在类中你能写的所有内容都是类的成员
2.变量
(1)实例变量:昨天写的就是实例变量,由对象去访问的变量.
(2)类变量(静态变量):此时,这个变量属于类,但是对象也可以访问
3.方法
(1)实例方法:昨天写的就是实例方法,使用 对象.方法() 进行调用
特点:在声明的时候,需要给出self,self必须放在第一个位置
在调用的时候,自动的会把对象传递给形参的self
(2)类方法(@classmethod):类方法是属于类的.
特点:在声明的时候需要给出一个能够接收类名的参数,cls,也必须放在参数的第一个
在调用的时候,自动的把xx对象的类传递给cls
(3) 静态方法(@staticmethod):静态方法也是属于类的,静态方法就好比,我们在类中定义了一个函数
静态方法一般和类方法差不多,使用类名去访问
4.属性(这个是比较有用的)
#为了在难受的时候舒服一点
在方法上添加一个@property,可以把一个方法变成一个属性,但是这个属性不可以被赋值
当我们某一个属性必须经过计算才能得到结果的时候
#我的理解:本质是方法,但是可以当成属性来用
5.私有
所有已双下划綫开头的方法,变量都是私有内容,外界无法访问//除非你主动暴露这些内容
你想保护就把他私有化
#总结:强化面向对象(今天量稍微大一些)
二.今日内容大纲
1.实例化变量
2.实例方法
3.类变量
4.类方法
5.静态方法
6.属性
7.私有
三.今日内容详解
1.实例变量
class Person: def __init__(self,name,id,gender,birth): self.name=name #实例变量 对象里的变量 self.id=id self.gender=gender self.birth=birth p=Person('wusir','10086','不详','1900-12-15') print(p.birth) p.birth='1840-5-6' #实例变量可以进行修改 print(p.birth) #实例变量一般使用 对象.属性 print(p.name)
2.实例方法
(1)
class Computer(object): #实例方法 def play(self): print('电脑可以扫雷') #在定义实例方法的时候,必须给出一个参数 self #形参的第一个参数,自动的把对象给传递进来 def work(self): #self 就是个形参,随便写,中文也行 print(self) #self 是当前类的对象 print('电脑用来工作') c=Computer() c.work() #调用的时候不需要手动给出self print(c)
(2)
回顾之前
字符串操作. 列表操作. 字典操作. 元组操作.....
s = "你好啊"
s.replace("你", "我")
之前讲解的所有方法都是实例方法
3.类变量
class Person: # country='中国' #类变量, 类变量是属于类的 country = '大清' #类变量不是特别特别常用 def __init__(self,name,gender): self.name=name self.gender=gender p=Person('武sir','未知') print(p.name) #实例变量 print(p.gender) print(p.country) #类变量可以给对象使用 p2=Person('太白','两性') print(p2.gender) print(p2.country) #大坑:没有修改类变量 p.country='大清' #没有修改类变量,只是在自己的实例化空间内创建了一个country p2.country='大明' print(p.country) #类变量可以给对象使用 print(p2.country) Person.country='大元' #类变量最好是使用类名来访问 print(p.country) print(p2.country)
4.类方法
class Person: #实例方法 def chi(self): print('人会吃') @classmethod #装饰器,此时这个方法是一个类方法,固定方法 def he(cls): #此时接收到的cls是类名 print(cls) print('人会喝') #用对象访问 p=Person() p.he() #解释:在调用类方法的时候. 默认的把类名传递给类方法 #<class '__main__.Person'> #人会喝 print(Person) #<class '__main__.Person'> # 类方法一般用类名去访问 Person.he() # 类方法 # Person.chi() #这句话就会报错 # 总结:带类的最好用类来访问
5.静态方法
class Person: @staticmethod #静态方法 def yue(): print('SKT') #静态方法可以使用对象访问, # 也可以使用类名访问, # 但是一般推荐使用类名访问 p=Person() p.yue() Person.yue() #知识点回顾: #fromkeys共用value,返回新字典,不是原来的字典
6.属性
(1)引子
#怎么解决,每过一年都要加一年,把age 替换成 birth class Person: def __init__(self,name,gender,birth): self.name=name self.gender=gender self.birth=birth #2000 2018 #年龄这一项,本来就应该是算出来的,而不是直接存储的 p1=Person('武sir','未知',2000) age=2018-p1.birth #每个人都有年龄这个属性,但是又没办法存储 print(age)
(2)@property
class Person: def __init__(self,name,gender,birth): self.name=name self.gender=gender self.birth=birth #2000 2018 #年龄这一项,本来就应该是算出来的,而不是直接存储的 @property #把一个方法更改成一个属性,每次拿属性的时候都会自动的去执行这个方法 #方法的返回值就是属性值 def age(self): #实例方法 print('我是方法') return 2018-self.birth #注意:这里的属性是不能赋值的,方法不是变量 p1=Person('武sir','未知',2000) print(p1.age) #看着像一个变量一样使用,实际上这里是调用的一个方法 print(p1.age) # p1.age=99 #不可以修改的,因为age是一个方法,不是一个变量 #这句话修改会报错
7.私有 __
class Person: __qie='潘潘' #私有类变量(或者叫做私有静态变量) def __init__(self,name,mimi): self.name=name self.__mimi=mimi #__mimi代表的是 私有内容 实例变量 def gaosu(self): print(f'把秘密告诉了太白,第二天所有人都知道了"{self.__mimi}"') print(Person.__qie) #私有的类变量只能在类中调用,可以用类名调用 print(self.__qie) #私有的类变量只能在类中调用,可以用对象名调用 def __yue(self): #私有的实例方法 print('我要和宝宝约') @staticmethod def __koujiao(): print('韩志远希望和嫂子一起抠脚') p=Person('wusir','和嫂子的故事') p.gaosu() # print(p.__mimi) #私有的内容只能在类里面调用,这里写会报错 #除非主动暴露自己的秘密,否则,不会 # print(Person.__qie) #这句话也会报错 # p.__koujiao() #也会报错 # Person.__koujiao() #也会报错
作业:
1. 简述⾯面向对象三⼤大特性并⽤用示例例解释说明？【背写】
封装:对属性和方法的封装,以便随时调用
继承:子类除了本身之外还可以使用父类的方法和属性
多态:鸭子模型,同一个对象拥有多种形态
2.⾯向对象中的变量分为哪几种？并用示例说明区别？【背写】
(1)实例变量: 说白了,就是每个实例变量都应该拥有的变量,比如,人的名字,人的爱好
每个人的个人信息都属于实例变量..给对象用的
(2) 类变量(静态变量): 直接写在类中的变量就是类变量,需要用类名来访问,可以改变,多个对象共享的
3.⾯向对象中方法有哪几种？并用示例说明区别？【背写】
1. 类方法 类名.方法 调用
2. 实例方法 对象.方法 调用
3. 静态方法 类名.方法 调用
4.面向对象中的属性有什么？并⽤用示例例说明？
重点记忆(这个 没有理解好)
(1)@property 把方法转换成属性
(2)对象.属性(self.name)
5.简述静态方法和类方法的区别？
记忆!!!
静态方法: 不用传递参数,没有继承
类方法: 需要传递参数,可以继承;访问类方法,默认传递的是类;
6.⾯向对象的⽅法中哪个无需传参数？
记忆!!!
静态方法
7.面向对象中公有和私有成员，在编写和调用时有哪些不同？
记忆!!!
编写,公有成员编写时,没有什么特别的要求,私有成员在成员名字前面需要加上__,双下划线,
公有成员在内部和外部都可以调用,私有成员只能在内部使用
网友:
公有使用: __xx__ 两端使用__
私有使用__xx 左端使用
8.
class Foo(object): a1=11 a2=12 def __init__(self): self.a1=1 obj=Foo() print(obj.a1) print(obj.a2) 结果: 1 12 分析:应该先找__init__里面的实例变量信息,再找类变量信息
9.
class Foo(object): a1=11 def __init__(self,num): # self.a2=num self.a2=1 obj=Foo(999) print(obj.a2) print(obj.a1) print(Foo.a1) # print(Foo.a2) #因为第四行里是用类调用初始化方法里的变量,自然调用不到 #报错原因是,类中没有属性a2 结果: 999 11 11 第四行报错
10.
class Foo(object): a1=1 __a2=2 a2=2 def __init__(self,num): self.num=num self.__salary=1000 # self.salary=1000 def get_data(self): print(self.num+self.a1) obj=Foo(666) print(obj.num) print(obj.a1) # print(obj.__salary) #结果:Foo' object has no attribute '__salary' # print(obj.salary) #自己测试结果:1000 # print(obj.__a2) # print(obj.a2) #自己测试结果:2 print(Foo.a1) #结果:1 print(Foo.__a2) # print(Foo.a2) #自己测试结果:2 结果: 666 1 找不到 找不到 1 找不到
11.
# 没问题,但是做这样的题目一定要仔细 class Foo(object): a1=1 __a2=2 def __init__(self,num): self.num=num self.__salary=1000 def get_data(self): print(self.num+self.a1) obj1=Foo(666) obj2=Foo(999) print(obj1.num) #666 print(obj1.a1) #1 obj1.num=18 obj1.a1=99 print(obj1.num) #18 print(obj1.a1) #99 print(obj2.a1) #1 print(obj2.num+Foo.a1) #1000 print(obj2.num+obj1.a1) #1098
12.
#注意下面的四种玩法 class Foo(object): hobby='大保健' def __init__(self,num): self.num=num self.__salary=1000 def f1(self): print(Foo.hobby) @staticmethod # def f2(self): def f2(): #注意这个静态方法不能有self，有self不会调用 print(Foo.hobby) @classmethod def f3(cls): print(cls.hobby) @property def f4(self): print(Foo.hobby) # print(self.hobby) f=Foo(200) f.f1() f.f2() f.f3() f.f4
13.
class Foo(object): @classmethod def f3(cls): print(cls) Foo.f3() #结果:<class '__main__.Foo'>
14.
class Foo(object): @classmethod def f3(cls): print(cls) obj=Foo() obj.f3() #结果:<class '__main__.Foo'>
15.
#我认为是一样的 #结果是一样的,和我推测的一样 class Foo(object): @classmethod def f3(cls): print(cls) def f2(self): self.f3() #<class '__main__.Foo'> Foo.f3() #<class '__main__.Foo'> obj=Foo() obj.f2()
16.
class Base(object): @classmethod def f3(cls): print(cls) def f1(self): print('base.f1') self.f3() #子类中有的话,用子类的,没有则用父类的 class Foo(Base): # def f3(self): # print('123') def f2(self): print('foo.f2') self.f1() obj=Foo() obj.f2() #结果: foo.f2 base.f1 <class '__main__.Foo'>
17.请编写一个私有的静态方法，并通过代码证明私有方法不能再外部方法但可以在内部访问。
#注意,我们可以在内部通过,自己的类和未私有化的方法来调用私有化的静态方法 class Person: __qie='潘潘' #私有类变量 def __init__(self,name,mimi): self.name=name self.__mimi=mimi #__mimi代表的是 私有方法 # @staticmethod def __donggua(self): # def donggua(self): print('你好啊!') def gaosu(self): # __donggua() Person.__donggua(self) print(f'把秘密告诉了太白,第二天所有人都知道了"{self.__mimi}"') p=Person('wusir','和嫂子的故事') # print(p.__mimi) #私有的内容只能在类里面调用 #除非主动暴露自己的秘密,否则,不会 p.gaosu()