刘总的笔记小站

问题零，list可变对象的，将会数据联动

Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> orgList = [ ['one'], ['two'] ]
>>> modList = []
>>> modList.append(orgList[0])

#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
>>> modList[0][0] = 'mod'
>>> orgList # [['mod'], ['two']]
>>> modList # [['mod']]

#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
>>> modList[0] = ['chg']
>>> modList # [['chg']]
>>> orgList # [['mod'], ['two']]

问题一，python对list套list进行去重无效的问题

python针对list使用set倒换去重，set要求list的内部数据类型是可hash的元素。

s = range(0,2) + range(0,2) # [0, 1, 0, 1]
list(set(s))  list(set([0, 1, 0, 1]))  // OK unique

a = [range(0,2), range(0,2)] # [[0, 1], [0, 1]]
list(set(s)) # TypeError: unhashable type: 'list'

list, set, dict：不可哈希， int, float, str, tuple：可以哈希
print( list.__hash__ ) # None
print( set.__hash__ ) # None
print( dict.__hash__ ) # None
print( int.__hash__ ) # <slot wrapper '__hash__' of 'int' objects>
print( str.__hash__ ) # <slot wrapper '__hash__' of 'str' objects>
print( float.__hash__ ) # <slot wrapper '__hash__' of 'float' objects>
print( tuple.__hash__ ) # <slot wrapper '__hash__' of 'tuple' objects>

list不使用hash进行索引，因此对元素没有是否可以hash的要求，即list可以重复
set和map使用hash进行索引，故因此内部元素是唯一的(dic针对key)，不可以重复

为什么list是不可哈希的，而tuple是可哈希的
（1）因为list是可变的在它的生命期内，你可以在任意时间改变其内的元素值。
（2）所谓元素可不可哈希，意味着是否使用 hash 进行索引
（3）list不使用hash进行元素的索引，自然它对存储的元素有可哈希的要求;而set使用hash值进行索引。

问题二，python数据结构，list set dic内部对象存储模型，传值和传引用

Python 存储模型
1、Python彻底分离了对象和引用，可以认为内存中的对象都是不可修改的，每次修改引用，相当于在堆上重新创建一个对象，引用指向新对象。
2、对于数值和字符串，修改意味着引用指向一个新对象。
3、集合中的元素都是引用。考虑元组，元组中的引用不能增加删除，也不能修改引用的指向。但是元组本身也是个引用，可以指向另一个元组。
4、考虑列表，列表中的引用可以增加删除，也可以修改引用的指向。列表本身也是个引用，也可以指向另一个列表。
5、考虑字典，字典的key不能修改指向，value可以修改指向。字典本身也是个引用，也可以指向另一个字典。
6、考虑下面的情况，listB = listA, listB 与 listA 指向同一个列表，listB修改元素也会影响到listA，如果不想受到影响怎么办？
　　进行深拷贝，listB = deepcopy(listA), 这种情况下，listB只是对listA中的元素(引用)做了copy，对应的元素还是指向同一个对象。
　　当listB修改元素的指向时，listA不受影响。
　　在Python中，深拷贝也只是拷贝引用，不会对内容拷贝。因此，对于包含引用的引用（也就是集合），深拷贝才有意义。
7、为什么设计出元组？毕竟列表可以完全取代元素。
　　这体现了“最小特权原则”，也就是尽量限制别人不该有的权利。元组是一种弱化了的列表，不允许对其中的引用增加删除，修改引用。

问题三，装饰器使用，类的生命周期， 垃圾回收机制

1，装饰器实现原则 封闭： 已实现的功能代码块不应该被修改；开放： 对现有功能的扩展开放。
   理解装饰器的三要素：函数的作用域,高阶函数,闭包

def funs(f):
    def func():
        f()
    return func

@funs   # @funs ===> “foo = funs(foo)”
def foo():
    print('foo...')

foo() # call



python变量在Module(模块)、Class(类)、def(函数)中定义的时候，才会有作用域

class Test:
    var = 0
    def __init__(self):
        self.var = 0
    def set(self, n):
        self.var = n
    def get(self):
        print(self.var)


def funC(n):
    t = Test()
    t.set(n)
    t.get()
    return t
    
def funD(n):
    r = funC(n)
    r.get()
    
    t = Test()
    t.get()

funD(9)

2，类对象的生命周期遵从python变量的作用域，但同时也要兼顾引用计数器。


3，垃圾回收机制Garbage collection(GC) 
python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的策略。

问题四 ，可变对象，和不可变对象

1，str  s = 'abc'  s.replace('a', 'A') # 'Abc' ,  s is 'abc' 注意区分s是变量，字符串'abc'是不可变对象。
2，tuple，定义变量的元素不可修改，
3， list 可变对象

问题五，python编码问题，参考python常用语法及知识总结