オブジェクト指向の章VII

オブジェクト指向の章VII

7.1.1基本概念

1. カテゴリー：一つのことは、同じプロパティとメソッドを持ちます
2. オブジェクトインスタンス：特定の属性値を特定の個々の動作を有している、クラスのインスタンスであります
3. 例：具体的な目的は、プロセスのクラスから得られます

基本的な書式を7.1.2

# 定义类 
class 类名: #类名 第一个是大写字母
    def 方法名(self,name):  #必须由self
        print(name)
        return 123
    def 方法名(self,name):
        print(name)
        return 123
    def 方法名(self,name):
        print(name)
        return 123
    
# 调用类中的方法
# 1.创建该类的对象
obj = 类名()
# 2.通过对象调用方法
result = obj.方法名('alex')
print(result)

7.1.3アプリケーションのシナリオ

1. シナリオ：私たちは関数に分類して割り当てる必要が、機能の多くを満たします
2. 三つの言葉：クラス、オブジェクト、メソッド、
3. 彼は加えました：
   • クラスとオブジェクトの関係は何ですか？
     • オブジェクトは、クラスのインスタンスであります
   • 何自己のですか？（ときに自己方法のObj。objが通過します）
     • オブジェクトメソッドは、Pythonの内部のオブジェクトは、このパラメータを通過するときに自己引数の形である、呼び出さ
   • 、クラス変数は、内部コードを呼び出すことで、すぐに実行上から下への内部クラスのコードの実行が必要になります
   • 巻次のクラスの間でネストを行うことができます
   • オブジェクトは変数の他のタイプに入れ子にすることができるように、クラス/メソッド/
   • ときにオブジェクト指向？
     • より多くの機能（ビジネス機能）、オブジェクト指向分類するために使用することができます
     • データパッケージをしたい（あなたがデータを格納するための辞書を作成するときに、オブジェクト指向）
     • ゲーム例：いくつかのロールを作成し、役割に基づいて文字を作成する必要があります

7.2オブジェクト指向三つの特徴

7.2.1パッケージング

オブジェクト（OBJ）の役割：後で使用するために記憶された値の数

class File:
    def read(self):
        with open(self.name,mode='r',encoding='ut-8')as f:
            data =f.read()
        return data

    def write(self,content):
        with open(self.name,mode='a',encoding='ut-8')as f:
            f.write(content)

obj1=File() #创建了一个对象obj1，(实例化对象)
obj1.name ="data.txt" #在对象中写了一个name = ‘data.txt’
obj1.read()#通过对象类中的方法，read 方法中的self就是obj1

obj2 = File()
obj2.name ='info.txt'
obj2.write('alex')

プロの文言を使用するオブジェクトにカプセル化されたデータ、およびより便利に：パッケージの役割

class Person:
    def __init__(self,n,a,g): #初始化方法-给对象内部数据初始化
        self.name = n   #谁调用show,self就是谁（p1/p2）
        self.age = a
        self.gender = g
    def show(self):
        tmp ='我是%s,年龄%s，性别%s' %(self.name,self.age,self.gender)
        print(tmp)


#实例化对象
p1 =Person('zz',19,'男')  #当Person() 时 __init__就会执行
p1.show()

p2 =Person('zy',22,'男')
p2.show()

#我是zz,年龄19，性别男
我是zy,年龄22，性别男

概要：あなたがコードを書く場合は、より混沌とした機能。

• 関数/メソッドは、同じクラスに分類することができると
• 共通の繰り返し使用の関数の値は、オブジェクト内に配置することができる場合

あなたが理解7.2.1.1パッケージ？

（図2に示すように、一つはクラス包装方法、データパッケージの一部であり、他のような後の呼び出しを容易にすることです）

• クラスのパッケージの機能
• オブジェクトにカプセル化されたデータ

# 示例：循环让用户输入：用户名/密码/邮箱。 输入完成后再进行数据打印。
# 以前的写法：
USER_LIST = []
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    temp = {'username':user,'password':pwd,'email':email}
    USER_LIST.append(temp)
for item in USER_LIST:
    temp = "我的名字：%s,密码：%s,邮箱%s" %(item['username'],item['password'],item['email'],)
    print(temp)
    
# 面向对象写法一：
class Person:
    def __init__(self,user,pwd,email):
        self.username = user
        self.password = pwd
        self.email = email
    
USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    p = Person(user,pwd,email)
    USER_LIST.append(p)
for item in USER_LIST:
    temp = "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)
    print(temp)

# 面向对象写法二：
class Person:
    def __init__(self,user,pwd,email):
        self.username = user
        self.password = pwd
        self.email = email   
    def info(self):
        return "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)
    
USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    p = Person(user,pwd,email)
    USER_LIST.append(p)
for item in USER_LIST:
    msg = item.info()
    print(msg)

7.22継承

• 彼は親を見つけられませんでした、最初に彼自身を見つけているすべての名前（コール・メソッドとプロパティ）を検索
• そして、彼らは親funcを持っている、とクラス名を指定するには、スーパー（）/直接転送を親クラスを呼び出したい場合（FUNCオブジェクトobjの範囲の継承の次のクラス、多重継承ベース（フー、バー）を見つけます。）左から右へ

class F3(object):
    def f1(self):
        ret = super().f1()  #这里执行F2里的f1方法
        print(ret)
        return 123
    
class F2(object):
    def f1(self):
        print('123')
        
class F1(F3, F2):
    pass

obj = F1()
obj.f1()
#123
#None

#父类
class Base:
    def f1(self):
        pass
#子类
class Foo(Base): #这里就是Foo继承Base,Base是Foo的父类
    def f2(self):
        pass
#创建了一个子类的对象
obj = Foo()
#执行对象.方法时，优先在自己的类找，如果没有就到父类中查找
obj.f1()
obj.f2()
#只有子类能继承父类，父类不能继承子类

#父类
class Base:
    def f1(self):
        pass
#子类
class Foo(Base): #这里就是Foo继承Base,Base是Foo的父类
    def f2(self):
        pass
class Bar(base):
    def f3(self):
        pass
obj1 = Foo()
obj2 = Bar()
obj1.f1()

関係の承継の順序を探します：

#示例1：
class Base:
    def f1(self):
        print('base.f1')
class Foo(Base):
    def f2(self):
        print('foo.f2')
obj = Foo()
obj.f1() #base.f1
obj.f2() #foo.f2

#示例2：
class Base:
    def f1(self):
        print('base.f1')
class Foo(Base):
    def f2(self):
        self.f1()
        print('foo.f2')
    def f1(self):
        print('foo.f1')
obj = Foo()  #注意self指的是obj,f1现在自己类中找，如果没有趣父类找
obj.f2()
#foo.f1
#foo.f2

#示例3:
class Base:
    def f1(self):
        self.f2()
        print('base.f1')
     def f2(self):
        print('base.f2')    
class Foo(Base):
    def f2(self):
        print('foo.f2')
obj = Foo()  
obj.f1()  
#foo.f2
#base.f1

#示例5 #多继承  （里面的self一直是obj，obj是ThreadingTCPServer创建的，所以找的时候从ThreadingTCPServer类找）
class BaseServer:
    def serve_forever(self, poll_interval=0.5):
        self._handle_request_noblock()
    def _handle_request_noblock(self):
        self.process_request(request, client_address)
        
    def process_request(self, request, client_address):
        pass
    
class TCPServer(BaseServer):
    pass

class ThreadingMixIn:
    def process_request(self, request, client_address):
        pass
    
class ThreadingTCPServer(ThreadingMixIn, TCPServer): 
    pass

obj = ThreadingTCPServer()
obj.serve_forever()

注意事項：

Q：複数のクラスがパブリックメソッドで存在する場合、継承を使用することができます場合は、上書きされないように、基本クラスに配置することができます？。

• 自己は、最終的には誰ですか？
• 自己は、それが親クラスから見て、開始から見つけることはありませんが、（オブジェクトが最初に作成はobj）が作成されたクラスであります
• 複数の継承関係：多重継承、派生クラスは、複数の基底クラスを持っている場合は、オブジェクトのメソッドを実行し、優先事項ではない場合は、左からの基本クラスを見つけるために右に、自分のクラスで見つけることが自分に注意を払うことです？

また、アヒルモデルと呼ばれる7.23よりも状態（様々な形で/複数のタイプ）

• クラス展示、複数の状態 - >複数のクラスが同様の状態を示し、

  1.基本的な内容：複数の様々な形状/タイプ、のpython自体は、多型であります

  def func(arg): #可以多种类型，很多事物
      arg.send()# 但必须由一定的规则，send方法。 

  2.インタビューの質問：

  機能のために、タイプパラメータのPythonは、限定するものではない方法がarg.sendならば、受信パラメータが関数に、様々な種類のものとすることができる、それは（タイプを持たなければならない着信タイプの限界でありますアヒルのモデルである方法）を、送信してください。

  上記の機能に似ている限り、我々は（のみsendメソッドは、私たちが望む形である）アヒルのcroakしできるよう

7.3メンバー

7.3.1クラスメンバ

あなたはクラスのカテゴリを定義すると、それはメモリ内のスペースを開きますが、この方法/機能があります実行されません、それが呼び出されたときに、そのだけ行われています

1.クラス変数：都市（staticフィールド/プロパティ）の名前でオブジェクトobjで

• 定義：次のレベル、クラスに書き込むように同じレベルの方法と

• アクセス：

  类.类变量名称   obj1.name
  对象.类变量名称

• インタビューの質問

  class Base:
    x =1 
  #实例化对象
  obj = Base()
  obj.x #先去对象中找，如果没有在去类中找
  obj.y = 123 #在对象中添加了一个y =123变量。
  obj.x = 123 #在对象中添加了一个y =123变量。
  print(obj.y) #123
  print(obj.x) #123  #只能在自己对象中添加，不会修改类变量中的x
  print(Base.x) #1

• 要約：

  • 自分の変数を見つけるために探したときの優先順位は、それが親クラスには見えませんでした

    

    ここChild.xは、彼が結果は1で、親を探しに行きたくなかったです。クラスの多くのオブジェクトがあるかもしれないので、私は、オブジェクトを見つけるために、内部に行かなければなりませんでした

  • 変数を変更する場合、変数は、自分のメンバーを変更することができます。obj.x = 123、しかし、オブジェクトobj xにクラス変数に影響を修飾しないBase.x

1. 結合アプローチ/一般的な方法

• 定義：少なくとも1つの自己パラメータ
• 実行：まずオブジェクトのメソッドにより、オブジェクトを作成します（）。

class Foo:
    def __init__(self):
        self.name = 123
    def func(self,a,b):
        print(self.name,a,b)
obj = Foo() #标准的，创建了对象，也用到了
obj.func(1,2) 

3.静的メソッド

• @staticmethodデコレータ

• 無制限のパラメータ

  実行：

  • クラスメソッド（）を直接呼び出します
    
  • オブジェクトメソッド（）（推奨されません）

静的メソッドを使用する場合は？

• __init__のないパッケージ内のいくつかの値

class Foo:
    def __init__(self):
        self.name = 123
    def func(self,a,b):
        print(self.name,a,b)
    @staticmethod
    def f1():
        print(1234)
obj = Foo() #标准的，创建了对象，也用到了
obj.func(1,2) 
Foo.f1()  #直接类.方法 调用静态方法，不用创建对象，节省内存

クラスの4方法

定義：（静的メソッドと比べてちょうど1より多くのデフォルトパラメータのCLS）

• @classmethodデコレータ
• CLS少なくとも一つのパラメータは、現在のクラスに渡されます

実行：

• クラス。メソッド（）
• オブジェクトメソッド（）（推奨されません）

class Foo:
    def __init__(self):
        self.name = 123
    def func(self,a,b):
        print(self.name,a,b)
    @staticmethod
    def f1():
        print(1234)
    @classmethod
    def f2(cls,a,b):
        print('cls输出的是当前的类',cls)
        print('a,b')
obj = Foo() #标准的，创建了对象，也用到了
obj.func(1,2) 
Foo.f1()  #直接类.方法 调用静态方法，不用创建对象，节省内存
Foo.f2(1,2)

インタビューの質問：

- 问： @classmethod和@staticmethod的区别？
- 答：一个是类方法，一个静态方法
  定义：
    类方法：用@classmethod做装饰器且至少有一个cls参数
    静态方法：用staticmethod做装饰器且参数无限制
  调用：
    类.方法直接调用，对象.方法也可以调用 

5.プロパティ

定義：

• @propertyデコレータ

• 少なくとも1つの自己パラメータ

  実行：括弧なしのオブジェクトメソッド

class Foo:
    @property
    def func(self):
        print(123)
        return 666
obj = Foo()
result = obj.func  #这里调用func方法不用加括号
print(result)

#属性应用
# 属性的应用
class Page:
    def __init__(self, total_count, current_page, per_page_count=10):
        self.total_count = total_count
        self.per_page_count = per_page_count
        self.current_page = current_page
    @property
    def start_index(self):
        return (self.current_page - 1) * self.per_page_count
    @property
    def end_index(self):
        return self.current_page * self.per_page_count

USER_LIST = []
for i in range(321):
    USER_LIST.append('alex-%s' % (i,))

# 请实现分页展示：
current_page = int(input('请输入要查看的页码：'))
p = Page(321, current_page)
data_list = USER_LIST[p.start_index:p.end_index]
for item in data_list:
    print(item)

7.3.2インスタンス（オブジェクト）メンバー

インスタンス変数のオブジェクト（フィールドプロパティ）

• オブジェクトがobjを作成した後、インスタンス変数名を変数名=「アレックス」を作成

ネストされたオブジェクト：

• 機能：パラメータが任意の型であってもよいです
• 辞書：オブジェクトとクラスは、キーと値の辞書になることができます
• インスタンス変数（site.registry（3、UserConfigに））別のクラスのオブジェクトとしてのクラスオブジェクト

class School(object):
    def __init__(self,title,addr):
        self.title = title
        self.address = addr
class ClassRoom():
    def __init__(self,name,school_object):
        self.name =name
        self.school = school_object  #这里接受School的对象
          
s1 = School('北京','沙河')
s2 = School('上海','浦东')
s3 = School('深圳','南山')

c1 = ClassRoom('全栈21',s1)
cl.name
c1.school.title
c1.school.address  #这里就都可以调用了

class StackConfig(object):
    list_display = '李邵奇'
    
    def changelist_view(self):
        print(self.list_display)
        
class UserConfig(StackConfig):
    list_display = '利奇航'

class AdminSite(object):
    def __init__(self):
        self._register = {}

    def registry(self,key,arg=StackConfig):
        self._register[key] = arg

    def run(self):
        for key,value in self._register.items():
            obj = value()
            obj.changelist_view()
site = AdminSite()
site.registry(1)
site.registry(2,StackConfig)
site.registry(3,UserConfig)
site.run()

修飾子の7.3.3メンバー

1、国民は、すべての領域にアクセスすることができます

2、プライベート、唯一のあなたは修飾子にアクセスすることができます：2つの下線が__＃追加されたクラスのインスタンス変数とクラス変数でのみ修飾子内でアクセスすることができます

#示例1  #在外部不能访问，在类内部可以
class Foo:
    def __init__(self,name):
        self.__name = name
    def func(self)
        print(self.__name)
obj = Foo('alex')
#print(obj.__name) #报错，无法访问
obj.func()  #可以访问

#示例2
class Foo:
    __x = 1
    @staticmethod
    def func():
        print(Foo.__x) #报错
Foo.func()
#示例3
class Foo:
    def __fun(self):
        print('msg')
     def show(self):
        self.__fun()
obj = Foo()
#obj,__func() #报错
obj.show()  #keyi 

3、強制アクセスプライベートミドルプラス_クラス名（単一下線）

class Foo():
    def __init__(self,name):
        self.__x = name
obj = Foo('alex')
print(obj._Foo__x)  #强制访问私有实例变量

彼は加えました：

class Foo():
    pass
class Foo(object):
    pass
#在python3中 这两种写法一样，因为所有类都会继承object类，由他开辟内存，全部都是新式类

#如果在python2中定义，称为经典类
class Foo:
    pass
#如果在python2中这样定义，称为新式类
class Foo(object):
    pass

7.3.4特別会員

7.3.4.1 __init__

• 初期化メソッド
• 用途：オブジェクトobjへの割り当てのために

class Foo():
    def __init__(self,name):
        self.name = name 
obj = Foo('alex') #在执行Foo() 后，就会执行init方法初始化值

7.3.4.2 __new__

• コンストラクタ
  
• 対象オブジェクトに空のオブジェクトを作成するために用い

class Foo(object):
    def __init__(self):
        print('初始化对象')
        self.x = 123
    def __new__(cls, *args, **kwargs):
        print('创建对象')
        return object.__new__(cls)

obj = Foo()     # 先执行__new__方法，再执行__init__方法

7.3.4.3 __call__

• オブジェクトの実行メソッド呼び出しの後ろのブラケット。論理的に、オブジェクトは後で追加することができません（）

class Foo(object):
    def __call__(self, *args, **kwargs):
        print('执行call方法')

obj = Foo()
obj()        # 对象后面加括号，执行__call__方法 
# 相当于Foo()()

• 部位の例（設立の原則）

from wsgiref.simple_server import make_server

def func(environ,start_response):
    start_response("200 OK", [('Content-Type', 'text/plain; charset=utf-8')])
    return ['你好'.encode("utf-8")  ]

class Foo(object):
    def __call__(self, environ,start_response):
        start_response("200 OK", [('Content-Type', 'text/html; charset=utf-8')])
        return ['你<h1 style="color:red;">不好</h1>'.encode("utf-8")]

# 作用：写一个网站，用户只要来方法，就自动找到第三个参数并执行。
server = make_server('127.0.0.1', 8000, Foo())
server.serve_forever()

7.3.4.4 __getitem__ __setitem delitem

class Foo(object):
    def __setitem__(self, key, value):
        pass
    def __getitem__(self, item):
        return 'uuu'
    def __delitem__(self, key):
        pass

obj1 = Foo()
obj1['k1'] = 123        # 内部会自动调用 __setitem__方法
val = obj1['xxx']       # 内部会自动调用 __getitem__方法，用val接受返回值
del obj1['ttt']         # 内部会自动调用 __delitem__ 方法

7.3.4.5 __str__

• オブジェクトを印刷すると、自動的にこのメソッドを呼び出し、返された場合にのみ、その値は、ページに表示されます

class Foo(object):
    def __str__(self):
        return 'asdfasudfasdfsad'

obj = Foo()
print(obj) # obj是一个对象，只在打印的时候调用__str__方法，并返回值

• 例：

class User(object):
    def __init__(self,name,email):
        self.name = name
        self.email = email
    def __str__(self):
        return "%s %s" %(self.name,self.email,)
    
user_list = [User('二狗','[email protected]'),User('二蛋','[email protected]'),User('狗蛋','[email protected]')]
for item in user_list:
    print(item)

7.3.4.6 __dict__

• すべての変数がオブジェクトを見つけると辞書に変換するには

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

obj = Foo('alex',19)
val = obj.__dict__     # 去对象中找到所有变量并将其转换为字典
print(val)

7.3.4.7 __enter__ __exit__

• コンテキスト管理

# 面试题
class Foo(object):
    def do_something(self):
        print('内部执行')      # 第三步

class Context:
    def __enter__(self):
        print('进入')           # 第一步
        return Foo()
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('推出')      # 第四步

with Context() as ctx:   #这里的ctx 就是接受return的返回值
    print('内部执行')      # 第二步
    ctx.do_something()

7.3.4.8 __add__

• 2つのオブジェクトを追加するこの方法を使用する場合

class Foo(object):
    def __add__(self, other):    # self：obj1，other：obj2
        return 123      
    
obj1 = Foo()
obj2 = Foo()
val  = obj1 + obj2    # 内部会自动调用 __add__方法，并用val接受返回值
print(val)      # 123

7.3.4.9 __iter__

• オブジェクトが反復可能になったときに、この方法は、必要とされます

class Foo:
    def __iter__(self):
        return iter([1,2,3,4]) 

obj = Foo()

7.4データ構造

7.4.1キュー

• FIFOのFIFO

class Queue(object):
    '''
    先进先出
    '''
    def __init__(self):
        self.data_list = []
    def push(self,val):
        self.data_list.insert(0,val)
    def pop(self):
        return self.data_list.pop(0)

7.4.2スタック

• LIFO LIFO

class Stack(object):
    '''
    后进先出
    '''
    def __init__(self):
        self.data_list = []
    def push(self,val):
        '''
        向栈中压入一个数据（入栈）
        :param val:
        :return:
        '''
        self.data_list.append(val)
    def pop(self):
        '''
        从栈中拿走一个数据（出栈）
        :return:
        '''
        return  self.data_list.pop()

7.5制約

• Fooの抽象クラス、インターフェイスクラス：としても知られています
• 定義：サブクラスは、サブクラスは方法論を実装するための抽象クラスの仕様に従わなければならないように、仕様を与えることです
• 例

#NotmplementedError
#约束子类中必须写send方法，如果不写，则调用的时候回主动抛出异常

class BaseMessage(object):
    def send(self,a1):
        raise NotmplementedError #(看到这里就潜规则的发现子类中需要有send方法)
        
class Msg(BaseMessage):
    def senf(self):
        pass
class Email(BassMessage):
    def send(self):
        pass
class DingDing(BaseMessage):# 写新的方法时，内部必须由send方法
    def send(self):   
        pass
obj = Email()
obj.send()

7.6反射

• （ここでは、オブジェクトがクラス、モジュール、PYファイルとすることができる）彼のメンバーの操作でオブジェクトに文字列の形式を根絶
• パイソン、すべてが対象です（モジュール、パッケージ、クラス、オブジェクト）

7.6.1 GETATTR（対象文字列）

• のメンバーに応じて文字列の形式でオブジェクトを取得するには

class Foo(object):
    def __init__(self,name):
        self.name = name
    def login(self):
        print('登录')
obj = Foo('alex')
#获取变量
v1 =getattr(obj,'name')
print(v1)
#获取方法
method_name = getattr(obj,'login')  #这里就相当于obj.login
print(method_name()) #执行
#alex
#登录
#None

• サプリメント

class Foo(object):
    def get(self):
        pass

obj = Foo()
# if hasattr(obj,'post'): 
#     getattr(obj,'post')

v1 = getattr(obj,'get',None) # 推荐
print(v1)

7.6.2はhasattr（対象文字列）

• かどうかを決定する部材のストリング

from wsgiref.simple_server import make_server
class View(object):
    def login(self):
        return '登陆'
    def logout(self):
        return '登出'
    def index(self):
        return '首页'

def func(environ,start_response):
    start_response("200 OK", [('Content-Type', 'text/plain; charset=utf-8')])
    obj = View()
    # 获取用户输入的URL
    method_name = environ.get('PATH_INFO').strip('/')
    if not hasatt(obj.method_name): #不是成员就返回下面
        return ["sdf".encode("utf-8"),]
    response = getattr(obj,method_name)() #有就执行
    return [response.encode("utf-8")  ]

# 作用：写一个网站，用户只要来方法，就自动找到第三个参数并执行。
server = make_server('192.168.12.87', 8000, func)
server.serve_forever()

7.6.3 SETATTR（ターゲット、文字列値）

• メンバを修正/設定するオブジェクトの文字列

class Foo(object):
    pass
obj = Foo()
obj.k1 = 999
setattr(obj,'k1',123) 
print(obj.k1) #123

7.6.4 delattr（対象文字列）

• オブジェクトの文字列に従ってメンバーを削除

class Foo:
    pass

obj = Foo()
obj.k1 = 999
delattr(obj,'k1')
print(obj.k1)

7.6.5 Pythonのすべてが対象です

1. オブジェクトの定義
   • 狭い：クラスが出てオブジェクトをインスタンス化されます
   • 一般：
     • モジュール（PYファイル）とその内部のメンバー
     • パッケージ（フォルダ）とその内部のメンバー
     • クラスとその内部のメンバー
     • 狭いオブジェクト
2. Pythonのすべてが対象なので、将来は反射のメカニズムを介して達成することができ、文字列の形でその内部のメンバーを操作したいです

7.7シングルトンパターン（デザインパターン）

1.シングルトンパターン（設計パターン23）

#多例模式  每实例化一次就会创建一个新的对象
class Foo():
    pass
obj1 = Foo()
obj2 = Foo()

#单例模式 无论实例化多少次，都会用上一次创建的那个对象
obj1 = Foo()
obj2 = Foo()

• シングルトン標準シングルトンパターン

class Singleton(object):  #单例模式
    instance = None
    def __new__(cls, *args, **kwargs):
        # if Singleton.instance:
        #     return Singleton.instance
        # Singleton.instance = object.__new__(cls)
        # return Singleton.instance

        if not cls.instance:
            cls.instance = object.__new__(cls)
        return cls.instance

obj1 = Singleton()
obj2 = Singleton()

#不是最终的，要加锁  多线程

• 応用例：ファイル接続プール、データベース接続プール

class FileHelper(object):
    instance = None
    def __init__(self, path):
        self.file_object = open(path,mode='r',encoding='utf-8')

    def __new__(cls, *args, **kwargs):
        if not cls.instance:
            cls.instance = object.__new__(cls)
        return cls.instance

obj1 = FileHelper('x')
obj2 = FileHelper('x')

• インポートモジュール
  
• 複数の輸入がリロード

import jd #第一次会加载全部一遍
import jd #已经有就不会再加载了
print(456)

#如果想重新加载
import importlib
importlib.reload(jd) #会重新加载

• モジュールは、シングルトンを導入することにより達成することができます

#jd.py
class Foo(object):
    pass
obj = Foo()

#app.py
import jd #加载jd.py,加载后会实例化一个Foo对象给obj
print(jd.obj) 
#在有其他也许导入jd时，用的还是之前创建的那个对象

7.8プロジェクトの結果ディレクトリ

7.8.1プロジェクトの分類

1. スクリプト：ファイルPY内のすべてのコードを書きます

   

2. 単一の実行可能ファイル：唯一の実行可能ファイル

   # 可执行文件中包含：
   if __name__ == '__main__':
       pass

3. マルチ実行可能ファイル：複数の実行可能ファイルがあります。

7.8.2プロジェクトディレクトリ

1. パッケージとその内容は、ファイルの例
   • 実行可能ファイル：ビン
     • プロジェクトパスへのすべての実行可能ファイルは、＃がのsys.pathに追加された場所に注意を払う必要があります
   • ビジネス関連：SRC
     • 登録関連ログイン：account.pyを
     • 受注関連：order.py
     • メインプログラム：run.py
   • 公共図書館：LIB
     • ページング機能
   • データベース：DB
     • プロフィール：USER.TXT
   • 設定：設定
     • 設定：setting.py
   • ストレージをログ：ログ
     • すべてのログファイル

1. 注：各実行可能ファイルはのsys.pathにプロジェクトのルートディレクトリに追加する必要があります

   import os
   import sys
   
   BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
   sys.path.append(BASE_DIR)