python面向对象----成员

私有属性与私有方法

私有属性

私有属性：就是对象不希望公开的属性

定义方式：在属性名前面增加两个下划线 （例如：__name）

class People:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def print_info(self):
        # 私有属性在类的内部方法是可以访问的
        print(self.name, self.__age)  # __代表私有属性

    def get_age(self):
        return self.__age #vip通道，用以获取私有属性值

    def set_age(self,new_age):
        self.__age = new_age
zs = People('zs', 20)
print(zs.name)
print(zs.get_age())
# print(zs.__age) #'People' object has no attribute '__age'
zs.print_info()  # 在类的外部访问私有属性会报错，
zs.set_age(21)
print(zs.get_age())

私有方法

私有方法：就是对象不希望公开的方法

定义方式：在方法名前面增加两个下划线（例如：__test）

注意：

在python中，并没有真正意义上的私有，只有伪私有。当我们在访问时，以对象._类名__私有属性即可访问，私有方法同理。但是不建议使用。

class Demo:
    def test1(self):
        print('1')

    def __test2(self):
        print('2')

    def test3(self):
        self.__test2()#私有公开，可当做vip通道


d = Demo()
d.test1()
# d.__test2()#'Demo' object has no attribute '__test2'
d.test3()

类的成员：属性，方法

属性：实例属性，类属性

方法：实例方法，类方法，静态方法

 实例属性

实例属性 属于对象，只能通过对象访问

定义：self.属性名称

访问：self.属性名称 或 对象.属性名称

类属性

类属性 属于类，保存在类中。在创建时，仅创建一份，并且所有对象都共享静态属性。执行时可以是类访问也可以是对象访问。

定义：直接在类中定义

访问：类名.属性名称 或 self.属性名称 或 对象.属性名称

练习：定义一个省份类，打印输出班级每位同学所在国家与省份

class Province:
    country = '中国'#类属性

    def __init__(self,name):  # country(国家) name(省份)
        # self.country = country
        self.name = name

    def print_info(self):
        print(self.country, self.name)  # 类属性可以通过对象去访问
        # print(Province.country,self.name)#类属性可以通过类名去访问


zs = Province('江苏')  # 创建对象
zs.print_info()
ls = Province('台湾')
ls.print_info()

#类属性做修改
Province.country = 'China'#通过类名更改类属性
print(Province.country)#类属性只能类对象去修改，不能通过实例对象做修改
zs.country = 'zhongguo'#实例对象对类属性做修改实际上是创建了一个实例属性，赋值操作

实例方法

普通方法保存在类中，在实例化对象后，一般通过对象调用。第一个参数必须系统自建参数，默认为self，代指对象本身。

class Demo:
    def __init__(self):
        self.name= 'zs'

    #实例方法：通常也需要使用实例属性
    def test_one(self):
        print(self.name)
d = Demo()
d.test_one()

类方法

类方法通过在方法上面添加@classmethod装饰器，保存在类中；

注意：

~类方法不需要传入self。但有一个系统自建参数为cls，cls代指类本身；

class Demo:
    def __init__(self):
        self.name= 'zs'

    #实例方法：通常也需要使用实例属性
    def test_one(self):
        print(self.name)#实例属性
    @classmethod
    def cls_md(cls): #cls 代表的demo类
        print(cls)
        cls.test = 'ls'
        print('类方法')
d = Demo()
d.test_one()
d.cls_md()
print(Demo.test)

静态方法

静态方法通过在方法上面添加@staticmethon装饰器定义，保存在类中；

class Demo:
    def __init__(self):
        self.name= 'zs'

    #实例方法：通常也需要使用实例属性
    def test_one(self):
        print(self.name)#实例属性
    @classmethod
    def cls_md(cls): #cls 代表的demo类
        print(cls)
        cls.test = 'ls'
        print('类方法')
    @staticmethod
    def stat_md():
        print('静态方法')#单纯的函数的使用
d = Demo()
d.test_one()
d.cls_md()
print(Demo.test)
d.stat_md()

面向对象三大特征

封装

封装是面向对象编程的一大特点，将属性和方法放到类的内部，通过对象访问属性或者方法，隐藏功能的实现细节，也可以设置访问权限。

import requests
requests.get('http://www.baidu.com')#封装
class Student:
    def __init__(self,name,age):
        self.name = name  #将属性封装到类的内部
        self.age = age

    def print_info(self):
        print(self.name,self.age)

#在同一个类创建多个对象，对象之间的属性互不干扰
xm = Student('xiaoming',20)
ls = Student('ls',19)
xm.print_info()
ls.print_info()

继承

继承是一种创建新类的方式，如果子类需要复用父类的属性或者方法时，就可以使用继承。当然，子类也可以提供自己的属性和方法。

class Father:
    pass
class Son(Father):#继承了上一个父类的功能
    pass

class GrandFather:
    def Hose(self):
        print(self)
        print('有房')
class Father(GrandFather):
    def Car(self):
        print('有车')
    def Money(self):
        print('有钱')
class Son(Father):
    def Study_python(self):
        print('python')
    def Hose(self):
        super(Son, self).Hose()#调用父类的方法
        print('son的房子')
s = Son()
s.Study_python()
s.Hose()
s.Car()#通过子类的对象可以使用父类的方法，子类没用可以去父类去找，父类没有可以去父类的父类去找
s.Money()

'''
#通过子类的对象可以使用父类的方法，子类没用可以去父类去找，父类没有可以去父类的父类去找
当子类有跟父类名字相同的方法，重写了父类的方法
super(Son, self).Hose()#调用父类的方法
'''

单继承

​
# class Father:
#     def __init__(self):
#         print('father')
#
# class Son(Father):
#     pass
# s = Son()
class Father:
    def __init__(self):
        self.name = 'name'
        self.__age = 'age'

    def test1(self):
        print('1')

    def __test2(self):
        print('2')

#通过第三方 方法可以继承
    def test3(self):
        self.__test2()#私有公开，可当做vip通道
class Son(Father):
    def get_test(self):
        print(self.name)
        # print(self.__age)#私有属性是不被继承的
        self.test1()
        self.test3()#私有方法是不被继承的

s = Son()
s.get_test()

​