Python day11

Python day11

今天学习了面向对象普通方法，魔术方法，类方法，静态方法,私有化，封装，继承

普通方法

普通方法:
定义格式:
def 方法名(self,参数1，参数2):
pass
调用：
都要依赖对象调用方法
对象名.方法名(参数)
注意： 在调用过程中会默认传递self对象，self表示的是对象本身

方法中访问对象属性：
self.属性名
self.属性名= 值 ----》 改变对象属性的值

方法中访问普通方法：
self.方法名(参数)

类方法,静态方法

类方法:
定义格式:
@classmethod
def 类方法名(cls,参数):
pass
使用：
类名.方法名()
也可以通过：
对象.方法名() (了解)
静态方法：类似类方法
定义格式：
@staticmethod
def 方法名():
pass
使用:
类名.方法名()

class Utils:
    # 类属性
    version = '1.0'



    # 类方法
    @classmethod
    def conn_db(cls):  # cls其实就是类对象本身
        print('classmethod---->', cls)
        print('加载数据库驱动程序，当前版本号是:', cls.version)
        print('数据库建立连接成功！')
     #静态方法
@staticmethod
    def select_data():  # 参数：不依赖对象self，也不依赖类cls
        print('查询数据库的数据，当前版本号是:', Utils.version)
        Utils.conn_db()
        # Utils.conn_db()   # 类方法的调用
# print('Utils:', Utils)
# # 类方法能否被对象调用？ 能访问
#
# u = Utils()
# u.conn_db()  # 对象调用conn_db(cls)  --->cls仍然是<class '__main__.Utils'>
# print('u===:', u)

# 类方法方法中能否访问对象属性？


# 静态方法的调用：
Utils.select_data()

# 静态方法能否被对象调用？ 能访问
u = Utils()
u.select_data()

# 类方法中能否调用静态方法？  静态方法中能否调用类方法？  都可以
print('-----------------------------------')
# Utils.conn_db()

# 类方法，静态方法中能调用普通方法？ 不能

魔术方法

魔术方法就是一个类的特殊方法，和普通方法唯一的不同时，普通方法需要调用！而魔术方法由系统自动调用
init;初始化对象，系统先执行__new__开辟一块空间后，执行__init__
new;
实例化对象是Object类底层实现，其他类继承了Object的__new__才能够实现实例化对象。
没事别碰这个魔术方法，先触发__new__才会触发__init__
str 魔术方法
repr
作用： 都是将对象转成字符串的表示形式

class Person:
    def __init__(self): #初始化
        print('----------->init')

    def __new__(cls, *args, **kwargs):#开辟空间，返回一个空间，不然__init__的self为None，实例化，
        print('----------->new')
        obj = object.__new__(cls)
        return obj

    def __del__(self):
        print('------------>del')


p = Person()
print(p)

*************************
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return self.name + '\t' + str(self.age)

    def __repr__(self):
        return 'helloworld'

    def __call__(self, *args, **kwargs):
        print('我被调用啦')

    def __len__(self):
        return 5


p = Person('zhangsan', 20)
print('---------------',p)
p()#__call__

r = repr(p1)#__repr__
print('---->', r)

运算相关魔术方法:
gt —> >
lt —> <
eq —> equals ==

le —> <=
ge —> >=

class Cat:
    def __init__(self, nickname, age):
        self.nickcname = nickname
        self.age = age

    def __gt__(self, other):
        return self.age > other.age

    # def __lt__(self, other):
    #     return self.age < other.age

    def __eq__(self, other):
        print('--->')
        return self.age == other.age

    def __add__(self, other):
        return self.age + other.age

    def __str__(self):
        return str(self.age)
c1 = Cat('花花', 2)
c2 = Cat('小猫1', 1)
c3 = Cat('小猫2', 4)
print(c1 > c2)
print(c1 < c2)

print(c1 == c2)#定义了一个方法就可以了，如果有其他的会优先考虑自身方法

result = c1 + c2
print(result)

跟属性相关的魔术方法：
getattr
setattr

class Person:
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        if item == 'age':
            return 20
        elif item == 'gender':
            return '男'
        else:
            return '不存在此属性{}'.format(item)

    def __setattr__(self, key, value):
        print(key, value)
        # self.key = value  # 递归操作
        if key == 'phone' and value.startswith('139'):
            object.__setattr__(self, key, value)



p = Person('老王')
print(p.name)
#
# print(p.age)
#
# print(p.gender)
#
# print(p.phone)

# p.name = '隔壁老王'
# print(p.name)
p.phone = '13910001897'
print(p.phone)
print('------')

print(p.__dict__)  # 获取p对象的自身属性，并以字典的形式返回

私有化

私有化：只能类自身中进行调用,对象在外部无法通过.访问
实现属性或者方法的私有化要通过： __属性名，__方法名（）
python中的私有化，底层对私有属性进行了改名操作： _类名__属性名 或者 _类名__方法名（）

class Person:
    def __init__(self, name):
        self.name = name
        self.__age = 20

    def show_age(self):
        print('我的年龄是:', self.__age)

    def __test(self):
        print('我是测试私有的test方法')


p = Person('jack')
print(p.name)

封装，继承（部分）

封装，继承，多态

1. 属性和方法—》封装到类中
2. 属性封装： 将属性私有化，并定义公有set和get方法

私有化作用：
1. 隐藏属性，只能在类中使用
2. 对私有属性的赋值和取值起到一定的限制作用
3. 通过set方法限制赋值，通过get限制取值

class Person:
    # 限制属性作用
    __slots__ = ['__name', '__age', '__flag']

    def __init__(self, name, age):
        self.__name = name
        self.__age = age
        self.__flag = True

    def get_name(self):
        if self.__flag:
            return self.__name
        else:
            return '没有权限查看用户名'

    def get_age(self):
        return self.__age

    def set_name(self, name):
        if len(name) >= 6:
            self.__name = name
        else:
            print('名字必须要大于等于6位')

    def set_age(self, age):
        if 125 > age > 0:
            self.__age = age
        else:
            print('年龄赋值失败，必须在0~125范围内')


p = Person('lucy', 20)

print(p.get_name())
print(p.get_age())

# p.name = 'abc'
# print(p.name)
p.set_name('steven')
print(p.get_name())

p.set_name('tom')
print(p.get_name())

p.set_age(10)
print(p.get_age())