《Python 3 面向对象》第1,2,3章

偏执的太偏执、 2022-05-14 00:56 155阅读 0赞

### 第1章：面向对象设计   第2章:Python对象： ###

\_\_init\_\_ 方法和 \_\_new\_\_ 方法：

**\_\_init\_\_是在类实例创建之后调用，而 \_\_new\_\_方法正是创建这个类实例的方法。**

class Person(object):
        """Silly Person"""
     
        def __new__(cls):   # 返回Person 的一个实例
            print( '__new__ called.')
            return super(Person, cls).__new__(cls)
     
        def __init__(self):
            print( '__init__ called.')
    
     
        def __str__(self):
            return 'hello class'
     
    piglei = Person()
    print(piglei)
    # __init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法。
    # __new__ called.
    # __init__ called.
    # hello class

> **\_\_init\_\_ 和 \_\_new\_\_ 最主要的区别在于：  
> 1.\_\_init\_\_ 通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性， 做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。  
> 2.\_\_new\_\_ 通常用于控制生成一个新实例的过程。它是类级别的方法。**

class PositiveInteger():
    #     def __new__(cls, value):
    #         return super(PositiveInteger, cls).__new__(cls, abs(value))
        def __init__(self, value):
            self.value = abs(value)
        def get_value(self):
            return self.value
    p = PositiveInteger(-3)
    print(p.get_value())    #3

实例方法、类方法和静态方法：

>     实例方法
>         定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；
>         调用：只能由实例对象调用。
>     类方法
>         定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法
>         （不能传实例的属性和方法）；
>         调用：实例对象和类对象都可以调用。
>     静态方法
>         定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；
>         调用：实例对象和类对象都可以调用。

静态方法 @staticmethod 和 类方法 @classmethod

#coding=gbk
    import random
    class Student():
        sum = 0 
        def __init__(self, name, age):
            self.name = name 
            self.age = age 
    #     def sum(self):
    #         self.sum += 1
    #         return self.sum     #实例方法不能调用 类的属性
        def get_name(self):
            print(self.name)    #实例的方法能获得实例方法的参数
        @classmethod
        def sum_add(cls):
            cls.sum += 1
            return cls.sum 
        @staticmethod
        def get():  #没有参数
    #         print(name) #不能获取实例方法
            print('打印一个随机数：%d'%(random.randint(1,10)))
    s = Student('zhangsan', 12)
    print(Student.sum_add())    #1
    s.get_name()    #zhangsan
    Student.get()   #打印一个随机数：5
    # print(s.sum())
    s1 = Student('zhao', 18)
    print(Student.sum_add())    #2

> \#静态方法可以通过类名和实例 方式进行调用,使用修饰符@staticmethod, 静态方法没有参数
> 
> \# 静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，主要是一些逻辑属于类，但是和类本身没有交互，  
> \# 即在静态方法中，不会涉及到类中的方法和属性的操作。可以理解为将静态方法存在此类的名称空间中。

import time 
    class Time():
        def __init__(self, hour, minute, second):
            self.hour = hour 
            self.minute = minute 
            self.second = second
            
        @staticmethod
        def get_time():
            print(time.strftime('%H:%M:%S', time.localtime()))
    Time.get_time() # 16:11:24
    t = Time(16, 10, 10)
    t.get_time()    # 16:11:24
    # 使用静态函数，既可以将获得时间的函数功能与实例解绑，我想获得当前时间的字符串时，并不一定需要实例化对象，此时更像是一种名称空间。
    # 
    # 我们可以在类外面写一个简单的方法来做这些，但是这样做就扩散了类代码的关系到类定义的外面，这样写就会导致以后代码维护的困难。

> 类方法：  
> 类方法是将类本身作为对象进行操作的方法。他和静态方法的区别在于：不管这个方式是从实例调用还是从类调用，它都用第一个参数把类传递过来。

class Class():
        __num = 0
        @classmethod
        def setNum(cls):
            cls.__num += 1
        @classmethod
        def getNum(cls):
            print(cls.__num)
            
        def __new__(cls):
            Class.setNum()
            return super(Class, cls).__new__(cls)
    class Student1(Class):
        def __init__(self):
            self.name = ''
    
    s1 = Student1()
    # s1.setNum()
    s2 = Student1()
    # s2.setNum()
    Class.getNum()  # 2

类名的命名规则：以大写字母开头，并随后的每一个单词都要以大写字母开头

class NotFirstClass:#创建一个类，不做任何特殊的操作
        pass
    
    class Point:
        def reset(self):
            self.x = 0
            self.y = 0
    p = Point()
    p.reset()
    print(p.x, p.y)#0,0
    #在类中调用这个函数，并且明确把这个对象做为self参数传给对象
    #上述等同于:
    Point.reset(p)
    print(p.x, p.y)

小栗子：计算两点间的距离

#计算两点的距离
    from math import sqrt 
    class Point1:
        def move(self, x, y):
            self.x = x 
            self.y = y 
        def reset(self):
            '''
                docstring用于初始化坐标轴,如果在方法中撰写注释， 可以使用help 来查看该注释
            '''
            return self.move(0, 0)
        def calculate_distance(self, other_point):
            return sqrt((self.x - other_point.x) ** 2 + 
                        (self.y - other_point.y) ** 2)
    p1 = Point1()
    p2 = Point1()
    p1.move(5, 0)
    p2.reset()
    print(p1.calculate_distance(p2))#5.0
    assert (p1.calculate_distance(p2) == p2.calculate_distance(p1))#assert 函数是简单的测试方法， 如果为False则退出
    print(p2.calculate_distance(p1)) # 5.0

help（）方法：

关于模块和包中的from Module import \* ,最好不要使用这种语法， 对于代码的理解是不使适用的，代码维护不方便，可能还会导入一些意想不到的对象

from Object_oriented.test1 import Point1
    p3 = Point1()
    p4 = Point1()
    p3.reset()
    p4.move(3,5)
    print(p3.calculate_distance(p4))#5.830951894845301

方法出现在类中， 类出现在模块中，模块出现在包中，其实类可以定义在任意的地方，可以在一个函数或者一个方法内部：

def format_string(string, formatter= None): #默认formatter 是 None
        class DefaultFormatter:
            def format(self, string):
                return str(string).title()
            
        if not formatter:
            formatter = DefaultFormatter()
        return formatter.format(string)
    hello_string = 'hello world, how are you today?'
    print(hello_string)
    print(format_string(hello_string)) 
    # hello world, how are you today?
    # Hello World, How Are You Today?
    
    #name mangling
    class SecretString:
        def __init__(self, plain_string, pass_pharse):
            self.__plain_string = plain_string #私有属性
            self.__pass_pharse = pass_pharse 
        def decrypt(self, pass_pharse):
            if pass_pharse == self.__pass_pharse:
                return self.__plain_string
            else:
                return ' '
    secret = SecretString('welcome you !', 'www')
    print(secret.decrypt('www'))    # welcome you !
    #secret.__plain_string 私有属性，外部不能访问
    
    print(secret._SecretString__plain_string)   # 属性增加 _<classname> 就可以正常访问了。

有关于global关键字的使用：

h = 1
    def g():
        h = 2
        print(h)
    g = g() # 2
    print(h)    # 1

在函数内定义全局变量，需要使用global关键符  
如果我可能在函数使用某一变量后又对其进行修改（也即再赋值），怎么让函数里面使用的变量是模块层定义的那个全局变量而不是函数内部的局部变量呢？  
这时候global修饰符就派上用场了。

number = 12
    def function():
        global number 
        print(number)
        number = 66
    f = function()
    print(number)
    # 12
    # 66

案例学习：构建一个简单的命令行笔记本应用  
定义Note类,属性有：memo备忘录，tags标签，creation\_date创建日期,每一个备注需要唯一的整数id，这样用户可以通过菜单接口选择  
match方法：以字符串作为输入参数

import datetime
    last_id = 0
    class Note:
        def __init__(self, memo, tags =' '):
            """属性有：memo备忘录，tags标签，creation_date创建日期"""
            self.memo = memo 
            self.tags = tags
            self.creation_date = datetime.date.today()
            global last_id
            last_id += 1
            self.id = last_id
        def match(self, filter):
            """返回True 或者 False"""
            return filter in self.memo or filter in self.tags 
    # n1 = Note('first')
    # n2 = Note('Second,haha,this')
    # print(n1.id)    # 1
    # print(n2.id)    # 2
    # print(n2.match('Second')) # True
    
    #创建NoteBook类， 属性有：notes 作为列表
    #方法：search方法，new_note, modify_memo, modify_tags 方法
    class NoteBook:
        def __init__(self):
            self.notes = []
        def new_note(self, memo, tags=' '):
            self.notes.append(Note(memo, tags))
        def _find_note(self, note_id):
            for note in self.notes:
                if note.id == note_id:
                    return note 
            return None
        def modify_memo(self, note_id, memo):
            note = self._find_note(note_id)
            if note:
                note.memo = memo 
                print('modify memo ok')
                return True 
            return False
        def modify_tags(self, note_id, tags):
            note = self._find_note(note_id)
            if note:
                note.tags = tags 
                print('modify tags ok')
                return True 
            return False
                    
    #     def modify_memo(self, note_id, memo):
    #         """依据id号， 修改备忘录memo"""
    #         for note in self.notes:
    #             if note.id == note_id:
    #                 note.memo = memo 
    #                 break
    #     def modify_tags(self, note_id, tags):
    #         for note in self.notes:
    #             if note.id == note_id:
    #                 note.tags = tags
    #                 break
        def show(self):
            for note in self.notes:
                print('id: %d, tags: %s, memo: %s'%(note.id, note.tags, note.memo))
        def search(self, filter):
            return [note for note in self.notes if note.match(filter)]
        
    # no = NoteBook()
    # no.new_note('first')
    # no.new_note('second')
    # print(no.notes) # [<__main__.Note object at 0x0000000002226B70>, <__main__.Note object at 0x0000000002226BE0>]
    # no.show()
    #     
    # print(no.notes[0].id)   #3
    # print(no.notes[1].id)   #4
    # print(no.notes[0].memo)  #first
    # print(no.search('first'))   # [<__main__.Note object at 0x0000000002226B70>]
    # no.modify_memo(1, 'hello world')
    # no.modify_tags(1, 'hahaha')
    # print(no.notes[0].memo)  # hello world  
    # no.show()
    
    # #定义菜单接口
    import sys 
    class Menu:
        def __init__(self):
            '''构造函数， 初始化 NoteBook类'''
            self.notebook = NoteBook()
            self.choices = {
                '1':self.show_notes,
                '2':self.search_notes,
                '3':self.add_note,
                '4':self.modify_note,
                '5':self.quit
                }
        def display_memu(self):
            print("""
            NoteBook Menu:
            1. Show all Notes
            2. Search Notes
            3. Add note
            4. Modify Note
            5. Quit
            """
            )
        def run(self):
            while True:
                self.display_memu()
                choice = input('请输入一个数字；')
                action = self.choices.get(choice)
                if action:
                    action()
                else:
                    print('输入数字是无效的')
        def show_notes(self):
            self.notebook.show()
        def search_notes(self):
            filter = input('search for : ')
            notes = self.notebook.search(filter)
            self.show_notes(notes)
        def add_note(self):
            memo = input('Enter a memo:')
            tags = input('Enter tags:')
            self.notebook.new_note(memo, tags)
            print('Your note has been added')
        def modify_note(self):
            id = input('Enter a note id:')
            memo = input('Enter a memo:')
            tags = input('Enter tags:')
            if memo:
                self.notebook.modify_memo(id, memo)
                print('ok')
            if tags:
                self.notebook.modify_tags(id, tags)
                print('ok')
        def quit(self):
            print('Thank you for using this notebook taday')
            sys.exit(0)
    if __name__ == '__main__':
        Menu().run()

### 第3章：当对象是相似的 ###

继承允许我们在两个或者多个类之间创建一种“是一个” 的关系  
重点：基本继承，从内置的类继承，多态和动态类型

self表示创建的实例本身

class MyClass:
        def pri(self):
            print(self)
    m = MyClass()
    #self 实例的地址
    m.pri()   #<__main__.MyClass object at 0x0000000001EA6E10>
    print(id(m)) # 32140816
    print(int(0x0000000001EA6E10))  #32140816

参数cls，静态方法和类方法

class A:
        def pri1(self):
            print('hello:', self)
        @staticmethod
        def pri2(): # 静态方法可以不传入 self
            print('hello')
        @classmethod 
        def pri3(cls):
            print('hello:', cls)    #cls是类本身
    a = A()
    a.pri1()    # hello: <__main__.A object at 0x000000000229C198> 普通方法
    A.pri1(a)   # 与上式是一样的，self 指向 实例a
    A.pri2()    # hello 静态方法
    A.pri3()    # hello: <class '__main__.A'>  类方法

# ins
    class Desc:
        def __get__(self, ins, cls):
            print('self is in Decs : %s'%self)
            print(self, ins, cls)
    class Test:
        d = Desc()
        def prt(self):
            print('self in Test: %s'%self)
    t = Test()
    t.prt() # self in Test: <__main__.Test object at 0x00000000026A3518>
    t.d # self is in Decs : <__main__.Desc object at 0x00000000026A34E0>
        # <__main__.Desc object at 0x00000000026A34E0> <__main__.Test object at 0x00000000026A3518> <class '__main__.Test'>

基本继承

class MySubClass(object):
        print('this is subclass')
         
    class Contact:
        all_contacts = []
        def __init__(self, name , email):
            self.name = name 
            self.email = email 
            Contact.all_contacts.append(self) #列表自动将对象添加进来
    c1 = Contact('jack', '10')
    c2 = Contact('rose', '20')
    print(Contact.all_contacts)
    #[<__main__.Contact object at 0x000000000222EF60>, <__main__.Contact object at 0x000000000222E7F0>]
     
    class Supplier(Contact):
        def order(self, order):
            print('send %s order to %s'%(order, self.name))
    c3 = Contact('haha','123')
    s = Supplier('s_haha', '2222')  
    s.order('ok')  # send ok order to s_haha
    print(s.all_contacts)#子类可以使用父类的全部方法，属性

扩展内置类,扩展list类

class ContactList(list):#继承与list类,子类拥有父类的所有属性和方法
        def search(self, name):
            matching_contacts = []
            for contact in self:    # self表示创建的实例本身
                if name in contact.name:
                    matching_contacts.append(contact)
            return matching_contacts
    class Contact1:
        all_contacts = ContactList() #可以将其看做是 list 列表
        def __init__(self, name , email):
            self.name = name 
            self.email = email 
            self.all_contacts.append(self)
    c1= Contact1('john a', 'c1')
    c2 = Contact1('john b', 'c2')
    c3 = Contact1('tom 1', 't1')
    print('--')
    for c in Contact1.all_contacts.search('john'):
        print(c.name, end= ' ,')
    print()
    print([c.name for c in Contact1.all_contacts.search('john')]) #['john a', 'john b']
    print([c.name for c in Contact1.all_contacts.search('tom')])

重写和 Super

# 在contact 类中增加属性, 可以通过重写构造函数, 其他方法也可以重写
    class Friend(Contact1):
        def __init__(self, name, email, phone):
            self.name = name 
            self.email = email 
            self.phone = phone 
            
    #但是，这会导致维护复杂， 因为需要在2个地方进行代码更新，另一种方法是通过super()， 调用父类的方法
    #它返回的是一个父类的实例化对象， 允许直接调用父类的方法
    class Friend1(Contact1):
        def __init__(self, name, email, phone):
            super().__init__(name, email)
            self.phone = phone

多态 ： 调用不同的子类会产生不同的行为

class AudioFile:
        def __init__(self, filename):
            if not filename.endswith(self.ext):
                raise Exception(' Invalid file format')
            self.filename = filename 
    class MP3File(AudioFile):
        ext = 'mp3'
        def play(self):
            print('playing %s as mp3'%self.filename)
    class WavFile(AudioFile):
        ext = 'wav'
        def play(self):
            print('playing %s as wav'%self.filename)
    class OggFile():
        ext = 'agg'
        def play(self):
            print('playing %s as ogg'%self.filename)
    
    mp3 = MP3File('myfile.mp3')
    mp3.play()

[当心调入多重继承的坑][Link 1]

几个概念：

1. 深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。

2.广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。

多重继承：

![70][]

class A:
        def say(self):
            print('A hello:', self)
    class B(A):
        def eat(self):
            print('B eat:', self)
    class C(A):
        def eat(self):
            print('C eat:', self)
    class D(B, C):
        def say(self):
            super().say()
            print('D hello:', self)
    #     def eat(self):
    #         print('D eat..')
        def dinner(self):
            self.say()
            
            super().say()
            
            self.eat()
            
            super().eat()
            C.eat(self)
    d = D()
    d.say() 
    # A hello: <__main__.D object at 0x000000000227B908>
    # D hello: <__main__.D object at 0x000000000227B908>

方法解析顺序（ Method Resolution Order， MRO）， \_\_mro\_\_

print(D.__mro__) #输出顺序叫方法解析顺序（ Method Resolution Order， MRO）
    #(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

d.dinner()
    # A hello: <__main__.D object at 0x000000000269B908>
    # D hello: <__main__.D object at 0x000000000269B908> 输出的顺序和 d.say() 顺序是一样的
    
    # A hello: <__main__.D object at 0x000000000269B908> 输出 super().say()
    
    # B eat: <__main__.D object at 0x000000000269B908>  输出self.eat()
    # B eat: <__main__.D object at 0x000000000269B908>  输出super().eat()
    
    # C eat: <__main__.D object at 0x000000000269B908>  输出C.eat(self)

参考：[https://blog.csdn.net/u011019726/article/details/77712080][https_blog.csdn.net_u011019726_article_details_77712080]

[Link 1]: https://www.jianshu.com/p/71c14e73c9d9
[70]: /images/20220514/2caa881ab0064923b8626ab24e0bc9ac.png
[https_blog.csdn.net_u011019726_article_details_77712080]: https://blog.csdn.net/u011019726/article/details/77712080