二分查找以及单例模式

二分查找

一：

def fun(opt,lis,start = 0,end=len(lis)):
　　m_lis = (end-1-start)/2+start
　　if opt >lis[m_lis]:
　　　　return fun(opt,lis,start = m_lis)
　　elif opt <lis[m_lis]:
　　　　return fun(opt,lis,start =0,end=m_lis+1)
　　elif opt==lis[m_lis]:
　　　　return m_lis
　　else:
　　　　return "sorry none"

 二：

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

def func(l,aim):
    mid = (len(l)-1)//2
    if l:
        if aim > l[mid]:
            func(l[mid+1:],aim)
        elif aim < l[mid]:
            func(l[:mid],aim)
        elif aim == l[mid]:
            print("bingo",mid)
    else:
        print('找不到')
func(l,66)
func(l,6)

三：

l1 = [1, 2, 4, 5, 7, 9]
def two_search(l,aim,start=0,end=None):
    end = len(l)-1 if end is None else end
    mid_index = (end - start) // 2 + start
    if end >= start:
        if aim > l[mid_index]:
            return two_search(l,aim,start=mid_index+1,end=end)

        elif aim < l[mid_index]:
            return two_search(l,aim,start=start,end=mid_index-1)

        elif aim == l[mid_index]:
            return mid_index
        else:
            return '没有此值'
    else:
        return '没有此值'
print(two_search(l1,9))

递归版本的二分查找:

单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。

比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。

在 Python 中，我们可以用多种方法来实现单例模式

单例模式 :对一个类是能实例化一个对象
class A:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if A.__instance is None: # 第一次进入,满足这个条件
            obj = object.__new__(cls)  # 利用object 创建一个对象空间 给了obj
            A.__instance = obj  # 我将类的私有静态字段 __instance 重新赋值了 对象空间obj
        return A.__instance
a1 = A()
b1 = A()
c1 = A()
print(a1,b1,c1)
得到结果  对象地址都是一样的