python-day11

发布时间：2020-12-20 12:46:12 所属栏目：Python 来源：网络整理

导读：一、类方法： 1、普通方法: 定义格式: def 方法名(self,参数1，参数2): pass 调用：都要依赖对象调用方法对象名.方法名(参数) 注意：在调用过程中会默认传递self对象，self表示的是对象本身方法中访问对象属性： self.属性名 self.属性名= 值 ----》改

一、类

方法：

　　 1、普通方法:

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

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

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

class Bank_money:
    def __init__(self,card):
        self.card = card
        self.money = 0

    def cun_kuan(self,money):
        self.money += money
        print(‘{}存款成功，余额为：{}‘.format(self.card,self.money))
        self.show()
    def qu_kuan(self,money):
        if money<self.money:
            self.money -= money
            print(‘{}取款成功，余额为：{}‘.format(self.card,self.money))
            self.show()
        else:
            print(‘余额不足！！！‘)
    def show(self):
        print(‘卡号：{} 余额：{}‘.format(self.card,self.money))


a = Bank_money(‘001‘)
a.cun_kuan(20000)

card2 = Bank_money(‘002‘)
card2.cun_kuan(20000)
card2.qu_kuan(10000)

　　2、类方法

类方法：
    定义格式：
        @classmethod
        def 类方法名(cls,参数):
            pass
静态方法
    定义格式：
    @staticmethod
        def 方法名(self):
            pass
    使用：
        类名.方法名（）

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

    # 对象属性
    def __init__(self):
        self.id = ‘001‘

    # 类方法
    @classmethod
    def conn_db(cls):   # cls就是类对象本身
        print(‘加载数据库的驱动程序，当前版本号是‘,cls.version)
        print(‘数据库建立连接成功！！‘)
        # cls.select_add()

    @staticmethod
    def select_add():  # 参数：不依赖对象self，也不依赖类cls
        print(‘查询数据库的数据，当前版本号为:‘,Utils.version)
        Utils.conn_db()

    def add(self):
        print(‘添加成功！！！‘)

# Utils.conn_db()

# 类方法能否被对象调用？   能访问

# u = Utils()
# u.conn_db()   # 对象调用conn_db(cls)   ----cls  任然是类对象本身

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

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

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

# 类方法能否调用静态方法？   静态方法能否调用类方法？
print(‘-------------------------‘)
Utils.conn_db()

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

　　3、魔术方法

　　魔术方法就是一种类的特殊方法，普通方法需要调用，魔术方法由系统自己调用。

class Person(object):
    def __init__(self):
        print(‘------->init‘)

    def __new__(cls,*args,**kwargs):
        print(‘------->new‘)
        return object.__new__(cls)

　　def __del__(self):
    　　print(‘------del‘)

p = Person()
print(p)

__str__    魔术方法
 __repr__
 作用：都是讲对象转成字符串的表示形式
repr(obj):-----  __repr__

class Person(object):
    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,**kwargs):
        print(‘我被调用‘)

    def __len__(self):
        return 6


p = Person(‘gang‘,20)
print(p)
p()

p1 = Person(‘lisi‘,60)
print(p1)

r = repr(p1)   # 调用的时候自动触发
print(r)
print(len(p1))

list1 = [1,4,5,6,7,9]
print(len(list1))

__str__ __repr__ ?

运算相关的魔术方法：

__gt__          >
__lt__          <
__eq__          ==

__le__          <=
__ge__          >=

class Cat:
    def __init__(self,nickname,age):
        self.nickname = 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):
        return self.age == other.age

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

    def __int__(self):
        return self.age


c1 = Cat(‘小虎‘,2)
c2 = Cat(‘犊子‘,3)
c3 = Cat(‘犊子2‘,3)

# print(c1 > c2)
# print(c1 < c2)

print(c1 == c2)

result = c1 +c2 +int(c3)
print(result)

View Code

跟属性相关的魔术方法：
__getattr__
__setattr__

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

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

    # def __setattr__(self,key,value):
    #     print(key,value)
        # 不能进行赋值的操作，会出现递归的错误


p = Person(‘gang‘)
print(p.name)
print(p.age)
print(p.gender)

p.name = ‘飞蛾扑火‘
print(p.name)

View Code

4、私有化:只能类自身中进行调用，对象外部无法访问

实现属性或者私有化要通过：__属性名()__,__方法名__()

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)
# print(p.__age)
p.show_age()

p._Person__test()

View Code

?5、封装

1、属性和方法----封装到类中
2、属性封装：将属性私有化，并定义共有的set和get方法

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

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

    def __init__(self,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(‘没有这种人存在‘)


p = Person(‘lucy‘,20)
print(p.get_name())

p.set_name(‘steven‘)
print(p.get_name())

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

p.set_age(120)
print(p.get_age())

View Code

6、@property 装饰器是用来装饰类中方法的
步骤：
? ? 1、在get方法上面添加@property装饰器，函数名字最好更加简要，让使用者或访问的时候更加好用
? ? 2、装饰set方法：
? ? ? ? ? ? ? ?@属性名.setter
? ? ? ? ? ? ? ? ? ? ? def 属性名(self,参数)：
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?pass
? ? ?3、使用
? ? ? ?对象 = 类名（参数）
? ? ? ?print(对象.属性名) -----get方法
? ? ? ?对象.属性名 = 值 ------set方法

class Person:
    __slots__ = [‘__name‘,‘__flag‘,‘__password‘]

    def __init__(self,age):
        self.__name = name
        self.__password = ‘123‘
        self.__age = age
        self.__flag = False

    @property
    def name(self):
        if self.__flag:
            return self.__name
        else:
            return ‘没有权限查看用户名‘

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

    def get_age(self):
        return self.__age

    def set_age(self,age):
        if 125 > age > 0:
            self.__age = age
        else:
            print(‘没有这种人存在‘)

    def login(self,password):
        if self.__name == name and self.__password == password:
            print(‘登录成功‘)
            self.__flag = True
        else:
            print(‘登陆失败‘)


p = Person(‘jack‘,20)
p.login(‘jack‘,‘123‘)
print(p.name)

p.name = ‘jerryganng‘
print(p.name)

View Code

二、继承：
为什么要用继承：使代码更加简练，提高代码的可读性
实现继承：
class 子类名(父类)
pass
子类继承了父类的非私有的属性和方法
公有的属性和方法是可以直接在子类中访问的，但是私有的是无法访问的

# 父类  基类  超类
class Person:
    def __init__(self,age):
        self.name = name
        self.age = age
        self.__money = 10000

    def eat(self):
        print(‘去食堂吃饭！！‘)

    def sleep(self):
        print(‘想睡觉了！！‘)


# 子类
class Student(Person):
    def __init__(self):
        print(‘-------student init‘)


class Teacher(Person):
    def show(self):
        print(self.name)
        print(self.__money)  # self._Person__money


class Admin(Person):
    pass


s = Student()
print(s)


t = Teacher(‘zhangsan‘,45)
print(t)
t.eat()
t.sleep()
print(t.name)
print(t.age)
# print(t._Person__money)

t.show()

View Code

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!