巨蟒python全栈开发-第17天 核能来袭-成员

一.今日主要内容

    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()