• 1. 可变数据类型和不可变数据类型
• 2. 列表倒序
• 3. 深拷贝和浅拷贝
• 4. is 和 ==
• 5. 双端队列
• 6. 变量作用域
• 7. 常见内置函数
• 8. 多线程 & 多进程 & 锁
• 9. range() 和 xrange()

1. 可变数据类型和不可变数据类型

python中不可变数据类型的定义为：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，就称不可变数据类型，包括：int（整型）、string（字符串）、tuple（元组）

python中对可变数据类型的定义为：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，就称可变数据类型。包括：set（集合）、list（列表）、dict（字典）

字典值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
python 字典实现原理

2. 列表倒序

lists = lists[::-1]

关于列表

Python中的列表是由对其它对象的引用组成的连续数组。指向这个数组的指针及其长度被保存在一个列表头结构中。这意味着，每次添加或删除一个元素时，由引用组成的数组需要该标大小（重新分配）。幸运的是，Python在创建这些数组时采用了指数分配，所以并不是每次操作都需要改变数组的大小。

index() O(1)
append O(1)
pop() O(1)
pop(i) O(n)
insert(i, item) O(n)
del operator O(n)
iteration O(n)
contains(in) O(n)
get slice[x:y] O(k)
del slice O(n)
set slice O(n+k)
reverse O(n)
concatenate O(k)
sort O(nlogn)

3. 深拷贝和浅拷贝

python中的深拷贝和浅拷贝和java里面的概念是一样的，所谓浅拷贝就是对引用的拷贝，所谓深拷贝就是对对象的资源的拷贝。

对源对象的不可变元素进行修改，会开辟新的内存，就有新的引用，而浅拷贝是指向的修改前的引用，所以浅拷贝不变。

• 直接赋值：其实就是对象的引用（别名）。
  
• 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
  
• 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
  

4. is 和 ==

is比较的是id是不是一样，==比较的是值是不是一样。
Python中，万物皆对象！万物皆对象！万物皆对象！(很重要，重复3遍)每个对象包含3个属性，id，type，value

• id就是对象地址，可以通过内置函数id()查看对象引用的地址。
• type就是对象类型，可以通过内置函数type()查看对象的类型。
• value就是对象的值。

5. 双端队列

append() 和 pop() 操作的时间复杂度为O(1)

底层：双向链表

from collection import deque
queue = deque(['xx', 'xx'])

# 方法
append()
appendleft()
pop()  # 删除右边的元素
popleft() # 删除左边的元素


index(ele, begin, end) # 查找从(begin,end) 区间内，ele第一次出现的index
insert(i, a) #在位置i插入a
remove(ele) # 删除第一次出现的ele
count(ele) # 统计ele出现次数

extend(iterable) # 添加一组元素
extendleft(iterable)
reverse()

6. 变量作用域

global & nonlocal

• python 变量作用域：

  • 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量 。

• 两个关键词都用于允许在一个局部作用域中使用外层的变量。

  • global 表示将变量声明为全局变量
  • nonlocal 表示将变量声明为外层变量（外层函数的局部变量，而且不能是全局变量）

x = 0
def outer():
    x = 1
    def inner():
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 0


x = 0
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 2
# global: 0


x = 0
def outer():
    x = 1
    def inner():
        global x
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 2

https://stackoverflow.com/questions/1261875/python-nonlocal-statement

7. 常见内置函数

• ord() & chr()

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数

ord('a')
# 97
ord('b')
# 98

chr(97)
# 'a'

• map() & reduce()

• map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
• reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，效果：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

def f(x):
    return x*x

r = map(f, [1, 2, 3, 4, 5])
list(r)
# output: [1, 4, 9, 16, 25]

from functools import reduce
def (x, y):
    return x+y

reduce(add, [1, 3, 5, 7, 9])
# output: 25


reduce(lambda x,y: x^y, nums)

8. 多线程 & 多进程 & 锁

# 多进程
from multiprocessing import Pool

# maxtasksperchild : 防止内存泄漏。每个worker使用一次后就会销毁，然后创建一个新的worker
pool = Pool(maxtasksperchild=1)
# default processes=os.cpu_count()
pool.apply_async(func=train_worker,
                      args=(domain, request.dataset_path, request.model_version, mgr, params,
                            train_params, self.kb_host, self.ner_host, self.callback_urls),
                      callback=self.training_callback)

# 锁
UPDATE_MUTEX = threading.Lock()

9. range() 和 xrange()

• range()和xrange()都是在循环中使用，输出结果一样。
• range()返回的是一个list对象，而xrange返回的是一个生成器对象(xrange object)。
• xrange()则不会直接生成一个list，而是每次调用返回其中的一个值，内存空间使用极少。因而性能非常好。
• 在python3 中没有xrange，只有range。range和python2 中的xrange()一样。