def func(m):
    for k,v in m.items():
        m[k+2] = v + 2 #这样做是会报错的，RuntimeError: dictionary changed size during iteration

m = {1:2,3:4}
l = m
l[9]=10
# func(l) #
m[7]=8

# 1、在python中遍历字典的时候是不能对字典涉及的键进行操作(键的添加和删除)
# 2、深浅拷贝
print(l) # 注释掉函数后的结果是 {1: 2, 3: 4, 9: 10, 7: 8}
print(m) #                      {1: 2, 3: 4, 9: 10, 7: 8}

from copy import deepcopy
m = {1:2,3:4}
l = m # 浅拷贝
l2 = deepcopy(m) # 深拷贝
l[9]=10
m[7]=8

print(l) # 注释掉函数后的结果是 {1: 2, 3: 4, 9: 10, 7: 8}
print(m) #                      {1: 2, 3: 4, 9: 10, 7: 8}
print(l2) #{1: 2, 3: 4}

'''
1、python新版本推荐使用format
2、python2.6才加入的支持format语法支持
3、python3.6引入了新特性f-string
'''
name = 'Fred'
res = f"he said his name is {name}"
print(res) #he said his name is Fred

def foo(arg,li=[]): 
    li.append(arg)
    return li

list1 = foo(21)
list2 = foo(21,[1,])
list3 = foo(28)

print(list1) #[21,28]
print(list2) #[1,21]
print(list3) #[21.28]

li = [11,22,33,44]
print(li[10:]) #[]

# 1
fib = lambda n:n if n<2 else fib(n-1) + fib(n-2)
print(fib(6))
# 2
def fib(n):
    a,b = 0,1
    for _ in range(n):
        a,b = b, a+b
    return b

# set集合
l1 = ['b','c','d','b','a','c','c']
print(set(l1))

# 用字典
l2 = {}.fromkeys(l1).keys()
print(l2)

#列表推导式
l3 = []
[l3.append(i) for i in l1 if i not in l3]
print(l3)
for i in l1:
    if i not in l3:
        l3.append(i)
print(l3)

def loop_merge_sort(l1,l2):
    tmp = []
    while len(l1)>0 and len(l2)>0:
        if l1[0]<l2[0]:
            tmp.append(l1[0])
            del l1[0]
        else:
            tmp.append(l2[0])
            del l2[0]
    tmp.extend(l1)
    tmp.extend(l2)
    return tmp

print(loop_merge_sort([1,3,5],[1,2,7]))

class SingleTon(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            cls._instance = object.__new__(cls,*args,**kwargs)
        return cls._instance

class TestSingle(SingleTon):
    a = 1

t1 = TestSingle()
t2 = TestSingle()
print(id(t1),'--',id(t2))

l1 = ['a','b','c','d','a','v','s','d','c','a','c','c']
# 法1
from collections import Counter
result = Counter(l1).most_common(1)
print(result)

# 法2
def all_list(l1):
    """获取所有元素的出现次数，使用list中的count方法"""
    result = {}
    for i in set(l1):
        result[i] = l1.count(i)
    return result

result = all_list(l1)
for k,v in result.items():
    if result[k] == max(result.values()):
        print(k,v)

'''
上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法
作用：
1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，
  你无须再去关系这个问题，这将大有用处
'''
class Open:
    def __init__(self,filepath,mode="r",encode="utf-8"):
        self.f = open(filepath,mode=mode,encoding=encode)

    def write(self):
        pass

    def __getattr__(self, item):
        return getattr(self.f,item)

    def __del__(self):
        print("--->del")
        self.f.close()

    def __enter__(self):
        print("出现with语句，对象会调用我")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("with结束之后，会执行我啦")

with Open('1.txt') as f:
    f.write()
'''
出现with语句，对象会调用我
with结束之后，会执行我啦
--->del
'''