面向对象 详

最新推荐文章于 2024-10-03 09:02:12 发布
最新推荐文章于 2024-10-03 09:02:12 发布
阅读量276 收藏
点赞数
文章标签： python 数据结构与算法 设计模式
原文链接：http://www.cnblogs.com/zhaohaiyu/p/11321724.html
版权

第六章 面向对象

6.1对象初始

  • 面向的过程编程 vs 函数
s1 = "dasdasd"
count = 0
for i in s1:
    count += 1
    print(count)

l1 = [i for i in range(10)]
count = 0
for i in l1:
    count += 1
print(count)

l1 = [i for i in range(10)]
def my_len(argv):
    count = 0
    for i in argv:
        count += 1
    print(count)
my_len(11)
# 减少了重复代码 增强了可读性
  • 函数式编程 vs 面向对象编程
def login():
    pass
def register():
    pass
def shoping_car():
    pass
def change_pwd():
    pass

def check_paid_goods():
    pass
def check_unpaid_goods():
    pass
class Auth:

    def login(self):
        pass

    def register(self):
        pass

    def change_pwd(self):
        pass


class Shopping:

    def shopping_car(self):
        pass

    def check_paid_goods(self):
        pass

    def check_unpaid_goods(self):
        pass
# 面向对象第一个优点: 对相似功能的函数,同一个业务下的函数进行归类,分类.
"""
想要学习面向对象必须站在一个上帝的角度去分析考虑问题.
    类: 具有相同属性和功能的一类事物.
    对象:某个类的具体体现.

汽车: 汽车类, 楼下停着一个车牌号为9nb11的奥迪对象.
猫科类: 类. 陈硕家的养的那个大橘.对象.
鸡类: 一个类. 家里养的一只鸡.
男神:是一类. 太白对象.

面向对象的第二优点: 你要站在上帝的角度构建代码,类就是一个公共的模板,
对象就是从模板实例化出来的.
得到对象就得到了一切.
"""

6.1.1类的结构

class Human:
    """
    类的具体结构
    """
    # 第一部分:静态属性
    mind = '有思想'   # 类的属性  (静态属性, 静态字段)
    language = '使用语言'

    # 第二部分: 动态方法
    def work(self):
        print('人类都会工作')

    def eat(self):
        print('人类都需要吃饭')

6.1.2从类名的角度研究类

# class Human:
#     """
#     类的具体结构
#     """
#     # 第一部分:静态属性
#     mind = '有思想'   # 类的属性  (静态属性, 静态字段)
#     language = '使用语言'
#
#     # 第二部分: 动态方法
#     def work(self):
#         print('人类都会工作')
#
#     def eat(self):
#         print('人类都需要吃饭')

# 1. 类名操作类中的属性
#     1. 类名查看类中所有的内容
# print(Human.__dict__)
#     2. 类名操作类中的静态属性  万能的点.

# 增:
# Human.body = '有头和四肢'
# 删:
# del Human.mind
# 改:
# Human.mind = 'liye脑残'
# 查:
# print(Human.language)
# print(Human.__dict__)

# 2. 类名调用类中的方法(一般类中的(静态方法,类方法)方法不会通过类名调用)
# Human.work(111)

# 总结:
# 一般类名就是操作类中的属性.

6.13从对象角度研究类

# class Human:
#     """
#     类的具体结构
#     """
#     # 第一部分:静态属性
#     mind = '有思想'   # 类的属性  (静态属性, 静态字段)
#     language = '使用语言'
#
#     def __init__(self):
#         # print(f'self---->: {self}')
#         # print(666)
#         self.name = '李业'
#         self.age = 18
#
#     # 第二部分: 动态方法
#     def work(self):
#         print('人类都会工作')
#
#     def eat(self):
#         print('人类都需要吃饭')
#
# obj = Human()  # 实例化过程
# 得到一个返回值,这个返回值就是 对象,实例.
# print(f'obj---> {obj}')
# 实例化一个对象发生了三件事:
'''
    1. 开辟一个对象空间.
    2. 自动执行__init__方法,并且将对象地址传给self.
    3. 运行__init__方法内的代码,给对象空间封装属性.

'''



class Human:
    """
    类的具体结构
    """
    # 第一部分:静态属性
    mind = '有思想'   # 类的属性  (静态属性, 静态字段)
    language = '使用语言'

    def __init__(self, name, age):
        # print(f'self---->: {self}')
        # print(666)
        self.n = name
        self.a = age


    # 第二部分: 动态方法
    def work(self):
        # print(f'self---> {self}')
        print(f'{self.n}都会工作')


    def eat(self):
        print(f'{self.n}都需要吃饭')

# obj = Human('李业',18)  # 实例化过程
# print(obj.n)
# print(obj.a)
# print(obj.__dict__)

# 一:对象操作对象空间的属性

# 1. 对象查看对象的空间的所有属性
# obj = Human('李业',18)
# print(obj.__dict__)

# 2. 对象操作对象空间的属性
# obj = Human('李业',18)
# 增:
# obj.sex = 'laddy_boy'
# 删:
# del obj.a
# 改:
# obj.a = 1000
# 查:
# print(obj.n)
# print(obj.__dict__)

# 二 对象查看类中的属性
# obj = Human('李业',18)
# # print(obj.mind)
# obj.mind = '无脑的'
# print(obj.mind)
# print(Human.mind)

# 三 对象调用类中的方法
# obj = Human('孙戴维', 23)
# # print(f'obj---> {obj}')
# obj.work()
# obj.eat()

# 一个类可以实例化多个对象
# obj1 = Human('李业',18)
# obj2 = Human('小可爱', 16)
# obj3 = Human('怼姐', 18)

# 变量,函数名:
# age_of_oldboy = 73
# Ageofoldboy

6.2类的空间问题

6.2.1从空间角度研究类

  • 何处可以添加对象属性?
    1. 在类的__init__可以添加, 在类的方法中也可以添加,在类的外部也可以添加
  • 何处添加类的属性?
    1. 类的内部
    2. 类的外部
  • 查询顺序:
    • 对象.名字: 对象空间 _类对象指针 ------> 类空间 --->父类空间
    • 类名,名字 ----> 父类空间

6.3类与类之间的关系

  1. 依赖关系
    • 将一个类的类名或者对象传入另一个类的方法中.
class Elephant:
    def __init__(self,name):
        self.name = name


    def open(self,obj):
        print(f"{self.name}默念开门")
        obj.beopen()

    def close(self,obj):
        print(f"{self.name}默念关门")
        obj.beclose()

class Refrigerator:
    def __init__(self,name):
        self.name = name
    def beopen(self):
        print(f"{self.name}被打开了")
    def beclose(self):
        print(f"{self.name}被关闭了")

xiang = Elephant("琪琪")
haier = Refrigerator("海尔")
xiang.open(haier)
xiang.close(haier)
  1. 组合关系
    • 给一个类的对象封装一个属性,次属性为另一个类的对象
class GameRole:
    def __init__(self,name,hp):
        self.name = name
        self.hp = hp
    def equipment(self,wea):
        self.weapon = wea
class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def weapon_attack(self,p1,p2):
        p2.hp -= self.ad
        print(f"{p1.name}利用{self.name}给了{p2.name}一下子,{p2.name}掉了{self.ad}血,还剩{p2.hp}血")

gailun = GameRole("盖伦",80)
zhaoxin = GameRole("赵信",70)
sword = Weapon("大保健",15)
musket = Weapon("红缨枪",30)
gailun.equipment(sword)
zhaoxin.equipment(musket)
gailun.weapon.weapon_attack(gailun,zhaoxin)
zhaoxin.weapon.weapon_attack(zhaoxin,gailun

6.4继承

6.4.1单继承

class Animal:
    def __init__(self,name,sex,age):
        self.name = name
        self.age = age
        self.sex = sex
class Human(Animal):
    pass
class Dog(Animal):
    pass
  • Human Dog 子类 派生类
  • Animal 父类 基类 超类
class Animal:
    live = "有生命的"
    def __init__(self,name,sex,age):
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self):
        print("动物都需要进食")
class Human(Animal):
    live = "活着"

  1. 类名执行父类实行方法

    print(Huamn.live)
Human.eat(111)
class Animal:
    live = "有生命的"
    def __init__(self,name,sex,age):
        self.name = name
        self.age = age
        self.sex = sex
    def eat(self):
        print("动物都需要进食")
class Human(Animal):
    body = "有头有脸"

  1. 派生类对象 执行父类的属性方法

    obj = Human("qq","nan",18)
a1 = Animal('汪洋', '男', 48)
print(a1.body)
print(obj.live)
obj.eat()
print(obj)

    查询顺序单向不可逆: 子类使用父类的属性方法,父类不能使用子类的属性方法.

  2. 既要执行子类的方法,又要执行父类的方法

    • 方法一: 不依赖继承的
class Animal:

    def __init__(self, name, sex, age):

        self.name = name
        self.age = age
        self.sex = sex


class Human:

   def __init__(self,name, sex, age, hobby):
       '''

       :param name: 李业
       :param sex: 男
       :param age: 18
       :param hobby: 旅游 
       '''
       # self = obj
       # Animal.__init__(人类对象,姓名,性别,年龄)
       Animal.__init__(self,name,sex,age)
       self.hobby = hobby


class Dog(Animal):
    pass


class Cat(Animal):
    pass

obj = Human('驴友')
obj2 = Human('抽烟')
print(obj.__dict__)
obj = Human('李业','男',18,'旅游')
print(obj.__dict__)
def func(self):
    self = 666
    print(self)

self = 3
func(self)
func(666)


def func1(a,b):
    print(a,b)


def func2(argv1,argv2,x):
    func1(argv1,argv2)
    print(x)

func2(1,2,666)
  • 方法二: 依赖于继承 super()执行父类方法
class Animal:

    def __init__(self, name, sex, age):

        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('动物都需要吃饭')

class Human(Animal):

    def __init__(self, name, sex, age, hobby):

       # Animal.__init__(self,name,sex,age)
       # super(Human,self).__init__(name, sex, age)  #完整的写法
        super().__init__(name,sex,age)  # 执行父类的__init__方法,重构父类方法.
        self.hobby = hobby

    def eat(self):
        print(f'{self.name}都需要吃饭')


# class Dog(Animal):
#     pass
#
#
# class Cat(Animal):
#     pass
#
obj = Human('李业','男',18,'旅游')
obj.eat()
# print(obj.__dict__)

6.4.2多继承

  • python 类分

  1. 经典类: 不继承object类, 深度优先原则.

    1565092758175

  2. 新式类:继承object类. mro(C3)算法

    1565092795458

  3. 经典类的深度优先

    • 从左找 找到最深

  4. 新式类的mro算法

    mro(A(B,C)) = [A] + merge(mro(B),mro(C),[B,C])

mro(B(D,E)) = [B] + merge(mro(D),mro(E),[D,E])

mro(B(D,E)) = [B] + merge([D,O],[E,O],[D,E])
mro(B(D,E)) = [B,D] + merge([O],[E,O],[E])
mro(B(D,E)) = [B,D,E] + merge([O],[O])
mro(B(D,E)) = [B,D,E,O]

mro(C) = [C,E,F,O]

mro(A(B,C)) = [A] + merge([B,D,E,O],[C,E,F,O],[B,C])
            = [A,B] + merge([D,E,O],[C,E,F,O],[C])
            = [A,B,D] + merge([E,O],[C,E,F,O],[C])
            = [A,B,D,C] + merge([E,O],[E,F,O])
            = [A,B,D,C,E] + merge([O],[F,O])
            = [A,B,D,C,E,F,O]

6.5封装 多态 鸭子类型

class Student:
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
liye = Student("李业","boy")
print(liye.sex)

6.5.1多态

  • python 一个变量可以指向多种数据

    a = [1,2,3]
a = "sdasd"

6.5.2 鸭子类型

class A:

    def login(self):
        print('登录')

    def register(self):
        print('注册')

    def func1(self):
        pass

    def func2(self):
        pass


class B:

    def login(self):
        print('登录')

    def register(self):
        print('注册')

    def func3(self):
        pass

  • A B互为鸭子.

  • 虽然A,B两个类没有关系,但是我统一两个类中相似方法的方法名,在某种意义上统一的标准.

    # index ,index, index,

# str
# list
# a = [1,2,3]
# a = list('123')
# print(a)

6.6类的约束

版本1:
class QQpay:

     def pay(self,money):  # 鸭子类型
​        print(f'使用qq支付了{money}')

class Alipay:

​    def pay(self,money):
​        print(f'使用阿里支付了{money}')

obj1 = QQpay()
obj1.pay(100)  # 支付接口

obj2 = Alipay()
obj2.pay(200)

版本2: 要做到统一接口

class QQpay:

​    def pay(self,money):  # 鸭子类型
​        print(f'使用qq支付了{money}')

class Alipay:

​    def pay(self,money):
​        print(f'使用阿里支付了{money}')

def pay(obj,money):  # 归一化设计 :统一接口
    obj.pay(money)

obj1 = QQpay()
obj2 = Alipay()

pay(obj1,100)
pay(obj2,200)

版本3: 招了程序员,完善支付功能.



class QQpay:

​    def pay(self,money):  # 鸭子类型
​        print(f'使用qq支付了{money}')

class Alipay:

​    def pay(self,money):
​        print(f'使用阿里支付了{money}')

class Wechat:
    def fuqian(self,money):
        print(f'使用微信支付了{money}')

def pay(obj,money):  # 归一化设计 :统一接口
    obj.pay(money)

obj1 = QQpay()
obj2 = Alipay()

pay(obj1,100)
pay(obj2,200)

obj3 = Wechat()
obj3.fuqian(300)

版本4: 制定约束.约定俗称,没有做到完全强制.

class Payment:

​    def pay(self,money):
​        pass

class QQpay(Payment):

​    def pay(self,money):  # 鸭子类型
​        print(f'使用qq支付了{money}')

class Alipay(Payment):

​    def pay(self,money):
​        print(f'使用阿里支付了{money}')

class Wechat(Payment):
    def fuqian(self,money):
        print(f'使用微信支付了{money}')

def pay(obj,money):  # 归一化设计 :统一接口
    obj.pay(money)

obj1 = QQpay()
obj2 = Alipay()

pay(obj1,100)
pay(obj2,200)

obj3 = Wechat()
obj3.fuqian(300)

#版本五 :做到强制约束.
#方法1: python语言惯于使用的一种约束方式,在父类主动抛出错误.
#方法2: 借鉴于Java语言,定义抽象类的概念,做到真正的强制约束.

方法一:
前提,你的项目已经上线了,之前完成的QQpay,Alipay 以及 pay函数这个接口都成型.
如果此时新添加一个微信支付,其他的py文件引用支付功能时还是直接引用pay.
class Payment:

​    def pay(self,money):
​        raise Exception('你的子类需要定义pay方法')

class QQpay(Payment):

​    def pay(self,money):  # 鸭子类型
​        print(f'使用qq支付了{money}')

class Alipay(Payment):

​    def pay(self,money):
​        print(f'使用阿里支付了{money}')

class Wechat(Payment):

​    def fuqian(self,money):
​        print(f'使用微信支付了{money}')

def pay(obj,money):  # 归一化设计 :统一接口
    obj.pay(money)

obj1 = QQpay()
obj2 = Alipay()

pay(obj1,100)
pay(obj2,200)

obj3 = Wechat()
obj3.fuqian(300)

raise Exception('主动报错!')
print(111)

方法二:
from abc import ABCMeta,abstractmethod

抽象类,接口类: 强制指定规则(规范).

6.6super的深度解析

  • 严格按照mro的执行顺序去执行
class A:
    def f1(self):
        print('in A f1')

    def f2(self):
        print('in A f2')


class Foo(A):
    def f1(self):
        super(Foo,self).f2()  # 按照self对象从属于类的mro的顺序,执行Foo类的下一个类.
        print('in A Foo')


obj = Foo()
obj.f1()




class A:
    def f1(self):
        print('in A')

class Foo(A):
    def f1(self):
        super(Foo,self).f1()
        print('in Foo')

class Bar(A):
    def f1(self):
        print('in Bar')

class Info(Foo, Bar):
    def f1(self):
        super(Info,self).f1()  #  按照self对象从属于类的mro的顺序,执行Info类的下一个类.
        print('in Info f1')
print(Info.mro())
# [Info'>, Foo'>, Bar'>, A',  'object'>]
obj = Info()0
obj.f1()
class A:
    def f1(self):
        print('in A')

class Foo(A):
    def f1(self):
        super().f1()
        print('in Foo')

class Bar(A):
    def f1(self):
        print('in Bar')  # 1

class Info(Foo,Bar):
    def f1(self):
        super(Foo,self).f1()
        print('in Info f1')  # 2
# [Info Foo Bar A]
obj = Info()
obj.f1()

6.7类的私有成员

6.7.1私有类的属性

class A:
    name = "李业"
    __name = "钢哥"
    
    def func(self):
        print(self.name)
        print(self.__name)
obj = A()
obj.func()
  • 类的外部不能访问
class A:
    name = "李业"
    __name = "钢哥"
obj = A()
print(obj.name)
print(A.__name)
print(obj.__name)
  • 类的派生类 不能访问
class A:
    name = '李业'
    __name = '钢哥'

class B(A):
    def func(self):
        print(self.__name)
obj = B()
print(obj.__name)
obj.func()

6.7.2私有对象属性

  • 只能在类的内部使用,不能再类外部以及派生类使用.
class A:
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd
    def dm5(self):
        self.__pwd = self.__pwd + "123"
obj = A("李业","liyedsb")
print(obj.__pwd)

6.7.3私有类方法

 class A:
    def func(self):
        self.__func()
        print('in A func')

    def __func(self):
        print('in A __func')
obj = A()
obj.func()
obj.__func()
  • 私有成员来说: 当你遇到重要的数据,功能,(只允许本类使用的一些方法,数据)设置成私有成员.
  • python所有的私有成员都是纸老虎,形同虚设.
  • 类从加载时,只要遇到类中的私有成员,都会在私有成员前面加上_类名 .
class A:
     name = '李业'
     __name = '钢哥'  # 私有类的属性

    def __func(self):
        print('in __func')
print(A.__dict__)
print(A._A__name)

6.8类的其他方法

6.8.1类方法

  • 类方法: 一般就是通过类名去调用的方法,并且自动将类名地址传给cls,

    但是如果通过对象调用也可以,但是传的地址还是类名地址.

class A:

    def func(self):
        print('实例方法')


    @classmethod
    def cls_func(cls):
        print(f'cls---->{cls}')
        obj = cls()
        print(obj)
        print('类方法')

print(A)
A.cls_func()
obj = A()
obj.cls_func()
  • 类方法有什么用?
    1. 得到类名可以实例化对象.
    2. 可以操作类的属性.
  • 简单引用
  • 创建学生类,只要实例化一个对象,写一个类方法,统计一下具体实例化多少个学生?
class Student:
    count = 0
    def __init__(self,name):
        self.name = name
        Student.addnum()
    @classmethod
    def addnum(cls):
        cls.count += 1
    @classmethod
    def getnum(cls):
        return cls.count
obj1 = Student('liye', 12343243243)
obj1 = Student('liye', 12343243243)
obj1 = Student('liye', 12343243243)
obj1 = Student('liye', 12343243243)
obj1 = Student('liye', 12343243243)

6.8.2静态属性

  • 态方法是不依赖于对象与类的,其实静态方法就是函数.
  • 保证代码的规范性,合理的划分.后续维护性高.
class A:
    def func(self):
        print("实例方法")
    @classmethod
    def cls_func(cls):
        pass
    @staticmethod
    def static_func():
        print("静态方法")
import time

class TimeTest(object):

    area = '中国'
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    def change_time(self):
        print(f'你想调整的时间: {self.hour}时{self.minute}分{self.second}秒')

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())


def showTime():
    return time.strftime("%H:%M:%S", time.localtime())

def time1():
    pass

def time2():
    pass

6.8.3属性

  • 结果虽然实现了,但是逻辑上感觉不合理.bmi应该是类似于name,age,height,等名词,
  • 但是你把它当做方法使用了.
lass BMI:
    def __init__(self,height,weight):
        self.height = height
        self.weight = weight

    @property
    def get_bmi(self):
        return self.weight / self.height ** 2

    @get_bmi.setter
    def get_bmi(self,values):
        print("更改",values)

    @get_bmi.deleter
    def get_bmi(self):
        print("删除")


zhy = BMI(1.83,65)
print(zhy.get_bmi)
zhy.get_bmi = 777
del zhy.get_bmi
  • property 将执行一个函数需要函数名()变换成直接函数名.
  • 将动态方法 伪装 成了一个属性,虽然在代码级别上没有什么提升,但是让你看起来

property 他是一个组合.

  • 尝试更改伪装属性的值时 执行.setter装饰的函数
  • 尝试删除伪装属性的值时 执行.deleter装饰的函数

应用场景:

  • 工作中如果遇到了一些类似于属性的方法名,可以让其伪装成属性.

设置属性的两种方式:

  1. 利用装饰器设置属性.
class Foo:
    @property
    def bmi(self):
        print('get的时候运行我啊')

    @bmi.setter
    def bmi(self,value):
        print(value)
        print('set的时候运行我啊')
        # return 111  # 无法得到返回值

    @bmi.deleter
    def bmi(self):
        print('delete的时候运行我啊')
        # return 111  # 无法得到返回值
  1. 利用实例化对象的方式设置属性.
class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')

    AAA = property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

6.9 内置函数isinstance issubclass

  • isinstaance(a,b) 判断的是 a是否是b类 或者 b类派生类 实例化的对象.
  • iossubclass(a,b)判断的是 a类是否是b类 子孙类.
class A:
    pass

class B(A):
    pass

class C(B):
    pass
print(issubclass(B,A))
print(issubclass(C,A))

obj1 = A()
obj2 = B()
print(isinstance(obj1,obj2))

6.10元类type

  • python 中一切皆对象, 类在某种意义上也是一个对象,python中自己定义的类,
  • 以及大部分内置类,都是由type元类(构建类)实例化得来的.
  • type 与 object 的关系:
    1. object类是type类的一个实例.
    2. object类是type类的父类.

6.11反射

  • 程序对自己内部代码的一种自省方式.
  • 反射是什么? 通过字符串去操作对象的方式
  • 可以反射的对象: 实例对象.类.本模块.其他模块.
class A:
    def __init__(self):
        self.lst = []

obj1 = A()
obj2 = A()
print(id(obj1.lst))
print(id(obj2.lst))

class A:

    country = '中国'

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def func(self):
        print('in A func')

obj = A('赵海狗',47)

hasattr
print(hasattr(obj,'name'))
print(hasattr(obj,'country'))
print(hasattr(obj,'func'))

print(getattr(obj,'name'))
print(getattr(obj,'func'))
f = getattr(obj,'func')
f()
print(getattr(obj,'sex',None))
if hasattr(obj,'name'):
    getattr(obj,'name')

setattr,delattr 用的很少
obj.sex = '公'
print(obj.sex)
setattr(obj,'sex','公')
print(obj.__dict__)
delattr(obj,'name')
print(obj.__dict__)
  1. hasattr
  2. getattr
  3. setattr
  4. delattr

6.12函数与方法的区别

  1. 通过打印函数名的方式区别什么是方法,什么是函数. (了解)

    通过类名调用的类中的实例方法叫做函数.

    通过对象调用的类中的实例方法叫方法.

  2. 可以借助模块判断是方法还是函数.

rom types import FunctionType
from types import MethodType

def func():
    pass


class A:
    def func(self):
        pass

obj = A()

总结: python 中一切皆对象, 类在某种意义上也是一个对象,python中自己定义的类,以及大部分内置类,都是由type元类(构建类)实例化得来的.python 中一切皆对象, 函数在某种意义上也是一个对象,函数这个对象是从FunctionType这个类实例化出来的.python 中一切皆对象, 方法在某种意义上也是一个对象,方法这个对象是从MethodType这个类实例化出来的.

总结: 如何判断类中的是方法还是函数.

  • 函数都是显性传参,方法都是隐性传参.

6.13特殊的双下方法

  • 特殊的双下方法: 原本是开发python这个语言的程序员用的.源码中使用的.
  • str : 我们不能轻易使用.慎用.
  • 双下方法: 你不知道你干了什么就触发某个双下方法.

定义：双下方法是特殊方法，他是解释器提供的 由爽下划线加方法名加双下划线 __方法名__的具有特殊意义的方法,双下方法主要是python源码程序员使用的，我们在开发中尽量不要使用双下方法，但是深入研究双下方法，更有益于我们阅读源码。

调用：不同的双下方法有不同的触发方式，就好比盗墓时触发的机关一样，不知不觉就触发了双下方法，例如：init

6.13.1 __len__

class B:
    def __len__(self):
        print(666)
b = B()
len(b) # len 一个对象就会触发 __len__方法。

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)
a = A()
print(len(a))

6.13.2 __hsah__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a)

6.13.3 __str__

  • 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
class A:
    def __init__(self):
        pass
    def __str__(self):
        return '太白'
a = A()
print(a)
print('%s' % a)

6.13.4 __repr__

  • 如果一个类中定义了__repr__方法，那么在repr(对象) 时，默认输出该方法的返回值。
class A:
    def __init__(self):
        pass
    def __repr__(self):
        return '太白'
a = A()
print(repr(a))
print('%r'%a)

6.13.5 __call__

  • 对象后面加括号，触发执行。
  • 注：构造方法__new__的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

6.13.6__eq__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
print(a == b)

6.13.7 __del__

  • 析构方法，当对象在内存中被释放时，自动触发执行。
  • 注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

6.13.8 __new__

class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        print('in new function')
        return object.__new__(A, *args, **kwargs)

a = A()
print(a.x)
  • 单例模式
class A:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance
  • 单利模式具体分析
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
【采用单例模式动机、原因】
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。
【单例模式优缺点】
【优点】
一、实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
二、灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程。
【缺点】
一、开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
二、可能的开发混淆
使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
三、对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用

单例模式具体分析

6.13.9__item__

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

6.13.10__iter__

class A:
   def __init__(self,name):
       self.name = name
 
   def __iter__(self):
       for i in range(10):
           yield i
   def __next__(self):
        pass
obj = A('李业')  # obj 一个可迭代对象
print('__iter__' in dir(obj))
for i in obj:
    print(i)
print(obj.name)
o = iter(obj)
print(next(o))
print(next(o))
print(next(o))
print(next(o))
print(next(o))
print(next(o))

6.13.11__enter__ __exit__

# 如果想要对一个类的对象进行with  as 的操作 不行。
class A:
    def __init__(self, text):
        self.text = text

with A('大爷') as f1:
    print(f1.text)
    
    
class A:
    
    def __init__(self, text):
        self.text = text
    
    def __enter__(self):  # 开启上下文管理器对象时触发此方法
        self.text = self.text + '您来啦'
        return self  # 将实例化的对象返回f1
    
    def __exit__(self, exc_type, exc_val, exc_tb):  # 执行完上下文管理器对象f1时触发此方法
        self.text = self.text + '这就走啦'
        
with A('大爷') as f1:
    print(f1.text)
print(f1.text)
class Diycontextor:
    def __init__(self,name,mode):
        self.name = name
        self.mode = mode
 
    def __enter__(self):
        print "Hi enter here!!"
        self.filehander = open(self.name,self.mode)
        return self.filehander
 
    def __exit__(self,*para):
        print "Hi exit here"
        self.filehander.close()
 
 
with Diycontextor('py_ana.py','r') as f:
    for i in f:
        print i

6.14异常处理

6.14.1错误分类

  1. 语法错误
  2. 逻辑错误

6.14.2结构

  1. 单分支
try:
    num = int(input('>>>'))  # 出现ValueError错误之后,直接跳转到except语句.
    dic = {'name': '嘉欣'}
    print(dic['age'])

    print(111)
except ValueError:
    print(666)
  1. 多分支
try:
    num = int(input('>>>'))  # 出现ValueError错误之后,直接跳转到except语句.
    dic = {'name': '嘉欣'}
    print(dic['age'])
    l1 = [1, 2]
    print(l1[100])
    print(111)
except ValueError:
    print('输入的有非数字元素')
except KeyError:
    print('没有此键')
except IndexError:
    print('没有此下标')
print(666)
  1. 万能异常: 处理所有python识别的异常.
try:
#
    dic = {'name': '嘉欣'}
    # print(dic['age'])
    l1 = [1, 2]
    print(l1[100])
    print(111)
    for i in 123:
        pass
#
except Exception as e:
    print(e)
print(666)
  • 什么时候用万能? 什么时候用多分支?
    1. 如果你对错误信息不关心,只是想要排除错误让程序继续运行. 用万能异常.
    2. 你对错误信息要进行明确的分流,让你的程序多元化开发.
  1. 多分支+万能异常
def func():
    pass


def func1():
    pass


dic = {
    1: func,
    2: func1,
}

try:
    num = int(input('请输入序号'))
    dic[num]()
except ValueError:
    print('请输入数字')
except KeyError:
    print('请输入范围内的序号')
except Exception:
    print('程序出现意料之外的错误....')
  1. try else finally
try:
    dic = {'name': '嘉欣'}
    # print(dic['age'])
    l1 = [1, 2]
    # print(l1[100])
    print(111)
except KeyError:
    print('没有此键')
except IndexError:
    print('没有此下标')
else:
    print('如果没有出现异常则执行这里')
finally:
    print('finally 666')

  • except 必须依赖于try, else必须依赖于except和try

  • finally只是依赖于try.
  • finally : 在异常出现之前,执行finally语句.
  • finally 用在 关闭数据库连接,文件句柄关闭,数据保存等,用到finally.

  • 在return结束函数之前,执行finally代码.

  1. 主动触发异常.
raise ValueError('出现了value错误')
  1. 断言: 展现出一种强硬的态度.
assert 条件
name = 'alex'
n1 = input('请输入:')
assert name == n1
print(111)
print(222)
  1. 自定义异常
  • python中给你提供的错误类型很多,但是不是全部的错误.
class LiYeError(BaseException):
    def __init__(self,msg):
        self.msg=msg
    def __str__(self):
        return self.msg

try:
    raise LiYeError('socket.connent.....')
except LiYeError as e:  # e = LiYeError('类型错误')
    print(e)

转载于:https://www.cnblogs.com/zhaohaiyu/p/11321724.html

auen52882
关注
Python面向对象之类和实例用法分析
12-31
至于何为面向对象，在此就不详说了。面向对象程序设计本身就很值得深入学习，如要了解，请参阅网上其他的资料。 面向对象最重要的概念就是类（Class）和实例（Instance），牢记 类 是抽象的模板，比如Student类，而...
02.面向对象编程
shujuboke的博客
07-22 246
01. 面向对象编程(上) 一、面向对象编程（OOP） 面向对象和面向过程： 面向过程：强调的是功能行为 面向对象：将功能行为封装进对象，强调的是具备了功能行为的对象 （理解）把大象装冰箱一共分几步？ ①打开冰箱   ②把大象装进去（存储大象）  ③关闭冰箱 如何使用面向对象思想思考上述问题呢？ 人｛
面向对象（二）
weixin_44387195的博客
10-21 161
抽象类和接口的区别 声明方法的存在而不去实现它的类被叫做抽象类，它用于创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建抽象类的实例。然而可以创建一个变量，其类型是抽象类，并让他指向具体子类的一个实例。不能有抽构造函数或抽象静态方法。抽象类的子类为它们父类中的所有抽象方法提供实现，否则他们也是抽象类。取而代之，在子类中实现该方法，知道其行为的其他类可以在类中实现这些方法。 接口是抽象类的变体。在接口中，所有的方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有
2011年6月面向对象分析与设计试题B卷.doc附有详答案
12-06
### 2011年6月面向对象分析与设计试题B卷知识点解析 #### 一、单项选择题解析 **1. 面向对象分析与设计是面向对象软件开发过程中的两个重要阶段，下列活动中，____不属于面向对象分析阶段。** - **A．构建分析...
tcs.zip_C#_whatgpg_简单_贪吃蛇_面向对象入门
09-21
【标题】"tcs.zip" 是一个包含C#编程语言实现的简单贪吃蛇游戏的压缩包，旨在帮助初学者理解和应用面向对象编程概念。"whatgpg"可能是指作者或者某个开发工具的名字，但在这里具体含义不详。这个项目为初学者提供了...
基于面向对象协议的终端安全模块产品手册V1.1.2
03-20
手册版本历史部分记录了从V1.0.0到V1.1.2各版本号的修改日期以及修改内容的详单，反映了手册从初稿到最终版本的逐步完善过程，确保了内容的准确性和实用性。 9. 封装尺寸及联系方式 封装尺寸部分提供了TESAM模块的...
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 460
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
遥感影像-实例分割数据集：iSAID 从切图到YOLO格式数据集制作详细介绍
GIS潮流
09-30 1141
开源数据集isaid标注包含实例分割，但是原始影像太大，很吃显存，一般显卡无法用原始影像直接训练，所以需要对影像进行裁剪，并生成对应的标签，因为想用yolo系列跑模型，所以将标签需要转为txt格式。
酷炫音乐盒: 使用Python和Tkinter配合Pygame打造自己的音乐播放器
宇宙第一小趴菜的博客
09-29 1221
Tkinter是一个功能强大且简单易用的库，适合构建轻量级的GUI应用程序。它在不同的操作系统上具有相同的外观和行为，因此可以实现跨平台的应用程序。当然，Tkinter还有更多的功能和细节，通过阅读官方文档和教程，你可以更深入地了解和学习如何运用Tkinter来创建各种GUI应用程序。
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 399
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Python编写的贪吃蛇小游戏
最新发布
WwLK123的博客
10-03 364
Python编写贪吃蛇小游戏。
合并两个有序数组
Sudo_Wang的学习记录
09-30 427
我们可以使用双指针法从后向前遍历，避免将已经排序的数组打乱。这个方法的核心思路是从。的末尾开始填充较大的元素，因为末尾是用零填充的空闲区域，这样我们可以避免覆盖。这个方法能够高效地解决问题，并且符合进阶要求的 O(m + n) 复杂度。
训练常用API函数及方法
weixin_51277037的博客
09-28 232
self.folder_path = folder_path # 图像文件夹路径self.transform = transform # 可选的转换self.image_files = os.listdir(folder_path) # 获取文件夹中所有文件return len(self.image_files) # 返回图像数量img_name = os.path.join(self.folder_path, self.image_files[idx]) # 构建图像路径。
yjs10——pandas的基础操作
元气少女硕硕子的博客
09-30 380
data = pd.机器学习datasalary")注意：1.是pd.read_cvs，不要顺手写成np.read_cvs2.路径的斜杠方向是/，不是\，如果直接从电脑粘贴路径，路径写法是\，要自己换成/
AI驱动TDSQL-C Serverless数据库技术实战营--- 操作与电商可视分析
chasemydreamidea的博客
09-27 781
本文将基于腾讯云的高性能应用服务HAI和TDSQL-C MYSQL Serverless版构建AI电商数据分析系统。HAI作为一个面向AI和科学计算的GPU应用服务产品，它具有强大的计算能力，让复杂的AI模型的快速部署和运行的可行性加大，进而支持自然语言处理和图形生成等高级任务。TDSQL-C MYSQL版是一款云原生关系型数据库，其100%的MySQL兼容性，以及极致的弹性、高性能和高可用性，是电商业务中处理海量数据存储和查询的理想选择。本文实践除了使用TDSQL-C MYSQL外，通过python语言和
opencv-如何获取图像区域特定像素区域大小
qq_44157835的博客
09-28 590
通过鼠标框选某个区域，返回这个区域的像素大小。
如何用Python监控本股市的方法
全世界的博客
09-30 1258
量化交易，顾名思义，是通过数学模型和计算机算法来进行交易决策的一种交易方式。它不仅仅是简单的自动化交易，而是基于大量的历史数据和统计分析，通过算法来识别市场中的交易机会，并自动执行交易策略。量化交易的核心在于“量化”，即通过数据和模型来量化市场行为和交易机会。布林线（Bollinger Bands）是一种广泛使用的技术分析工具，由约翰·布林格（John Bollinger）在1980年代初开发。布林线策略的核心思想是通过计算股票价格的标准差来确定价格波动的上下限，从而判断股票的买入和卖出时机。
Python使用pandas读取Excel文件
xs_2012的专栏
09-29 471
上篇说到要求实现读取excel数据填写到表单中，selenium库学了点皮毛，接下来学学怎么操作Excel。网上一搜，操作Excel的库有很多，作为一个python新人咱也不了解哪个好用，这里就用pandas吧。例如：以上就是Python使用pandas读取Excel的简单应用，更多使用方法后面继续探索。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值