"""
    .1 默认解释器编码:py2-> ascii ; py3->utf-8
    .2 字符串和字节(*****)
        py2:
            unicode
            str = bytes
        py3:
            str,字符串 
            bytes,字节
    .3 经典类和新式类
        py2:
            - 经典
            - 新式(直接或间接继承object)
        py3:
            - 新式
    .4 yield from 
    
    ...
"""

20、python2和python3区别？列举5个

1、Python3 使用 print 必须要以小括号包裹打印内容，比如 print('hi')

Python2 既可以使用带小括号的方式，也可以使用一个空格来分隔打印内容，比如 print 'hi'

2、python2 range(1,10)返回列表，python3中返回迭代器，节约内存4   

4、python2中unicode表示字符串序列，str表示字节序列

      python3中str表示字符串序列，byte表示字节序列

5、python2中为正常显示中文，引入coding声明，python3中不需要

6、python2中是raw_input()函数，python3中是input()函数

GIL全局解释器锁

在同一个进程里的每一个线程同一时间只能有一个线程访问cpu,只要在多线程/进程之间用到全局 变量就要加上锁

@classmethod(cls):类方法,类名去调用,它会将类空间传给cls

@staticmethod():静态方法,不用传入类空间,对象空间的方法,相当于普通函数.

浅拷贝:第一层创建的是新的内存地址,而从第二层开始,指向的都是同一个内存地址,所以,对于第二层及更深的层数来说,保持一致性

深拷贝:完全独立(复制其数据对象完完全全放独立的一个内存,完全拷贝,数据不共享)

search():从左到右找,找到第一个就返回,找不到返回None

match():从开头找,找不到报错,相当于在前面加个"^"

迭代器就是用于迭代操作的的对象，遵从迭代协议（内部实现了__iter__()和__next__()方法，可以像列表（可迭代对象，只有__iter__()方法）一样迭代获取其中的值，与列表不同的是，构建迭代器的时候，不像列表一样一次性把数据加到内存，而是以一种延迟计算的方式返回元素，即调用next方法时候返回此值。
迭代器取值:__next__,或者for循环
生成器本质上也是一个迭代器，自己实现了可迭代协议，与生成器不同的是生成器的实现方式不同，可以通过生成器表达式和生成器函数两种方式实现，代码更简洁。生成器和迭代器都是惰性可迭代对象，只能遍历一次，数据取完抛出Stopiteration异常
生成式取值:一个yield对应一个next

协程:能在一条线程的基础上,在多个任务之间互相切换
协程的实现:
import gevent
 
def test1():
    print(1,2)
    gevent.sleep(0)#执行到这里的时候切换去函数test2
    print(3,4)
 
 
 
def test2():
    print(5,6)
    gevent.sleep(0)
    print(7,8)
 
gevent.joinall(
    [gevent.spawn(test1),gevent.spawn(test2)]
)#在函数test1等待的时候，协程去执行了函数test2

装饰器:装饰器的本质是闭包函数,功能,在不改变原函数的基础上,为原函数增加一些额外的功能
# 使用装饰器实现单例模式
def singleton(cls, *args, **kwargs):
    instance = {}
    def _instance():
        if cls not in instance:
            instance[cls] = cls(*args, *kwargs)
        return instance[cls]
    return _instance

@singleton
class Test_singleton:
    def __init__(self):
        self.num = 0

    def add(self):
        self.num = 99

ts1 = Test_singleton()
ts2 = Test_singleton()
print(ts1)
print(ts2) 

一行代码实现:
quick_sort = lambda array: array if len(array) <= 1 else quick_sort([item for item in array[1:] if item <= array[0]]) + [array[0]] + quick_sort([item for item in array[1:] if item > array[0]])
   

#常见快排
def quick_sort(array, left, right):
    if left >= right:
        return
    low = left
    high = right
    key = array[low]
    while left < right:
        while left < right and array[right] > key:
            right -= 1
        array[left] = array[right]
        while left < right and array[left] <= key:
            left += 1
        array[right] = array[left]
    array[right] = key
    quick_sort(array, low, left - 1)
    quick_sort(array, left + 1, high)

#算法中的快排
def quick_sort(array, l, r):
    if l < r:
        q = partition(array, l, r)
        quick_sort(array, l, q - 1)
        quick_sort(array, q + 1, r)
 
def partition(array, l, r):
    x = array[r]
    i = l - 1
    for j in range(l, r):
        if array[j] <= x:
            i += 1
            array[i], array[j] = array[j], array[i]
    array[i + 1], array[r] = array[r], array[i+1]
    return i + 1

select原理概述           
调用select时，会发生以下事情：

从用户空间拷贝fd_set到内核空间；
注册回调函数__pollwait；
遍历所有fd，对全部指定设备做一次poll（这里的poll是一个文件操作，它有两个参数，一个是文件fd本身，一个是当设备尚未就绪时调用的回调函数__pollwait，这个函数把设备自己特有的等待队列传给内核，让内核把当前的进程挂载到其中）；
当设备就绪时，设备就会唤醒在自己特有等待队列中的【所有】节点，于是当前进程就获取到了完成的信号。poll文件操作返回的是一组标准的掩码，其中的各个位指示当前的不同的就绪状态（全0为没有任何事件触发），根据mask可对fd_set赋值；
如果所有设备返回的掩码都没有显示任何的事件触发，就去掉回调函数的函数指针，进入有限时的睡眠状态，再恢复和不断做poll，再作有限时的睡眠，直到其中一个设备有事件触发为止。
只要有事件触发，系统调用返回，将fd_set从内核空间拷贝到用户空间，回到用户态，用户就可以对相关的fd作进一步的读或者写操作了。
epoll原理概述                    
调用epoll_create时，做了以下事情：

内核帮我们在epoll文件系统里建了个file结点；
在内核cache里建了个红黑树用于存储以后epoll_ctl传来的socket；
建立一个list链表，用于存储准备就绪的事件。
调用epoll_ctl时，做了以下事情：

把socket放到epoll文件系统里file对象对应的红黑树上；
给内核中断处理程序注册一个回调函数，告诉内核，如果这个句柄的中断到了，就把它放到准备就绪list链表里。
调用epoll_wait时，做了以下事情：

观察list链表里有没有数据。有数据就返回，没有数据就sleep，等到timeout时间到后即使链表没数据也返回。而且，通常情况下即使我们要监控百万计的句柄，大多一次也只返回很少量的准备就绪句柄而已，所以，epoll_wait仅需要从内核态copy少量的句柄到用户态而已。
对比                 
select缺点:

最大并发数限制：使用32个整数的32位，即32*32=1024来标识fd，虽然可修改，但是有以下第二点的瓶颈；
效率低：每次都会线性扫描整个fd_set，集合越大速度越慢；
内核/用户空间内存拷贝问题。
epoll的提升：

本身没有最大并发连接的限制，仅受系统中进程能打开的最大文件数目限制；
效率提升：只有活跃的socket才会主动的去调用callback函数；
省去不必要的内存拷贝：epoll通过内核与用户空间mmap同一块内存实现。
当然，以上的优缺点仅仅是特定场景下的情况：高并发，且任一时间只有少数socket是活跃的。

如果在并发量低，socket都比较活跃的情况下，select就不见得比epoll慢了（就像我们常常说快排比插入排序快，但是在特定情况下这并不成立）。

垃圾回收
Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记－清除”解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。

引用计数
原理：当一个对象的引用被创建或者复制时，对象的引用计数加1；当一个对象的引用被销毁时，对象的引用计数减1，当对象的引用计数减少为0时，就意味着对象已经再没有被使用了，可以将其内存释放掉。

优点：引用计数有一个很大的优点，即实时性，任何内存，一旦没有指向它的引用，就会被立即回收，而其他的垃圾收集技术必须在某种特殊条件下才能进行无效内存的回收。

缺点：但是它也有弱点，引用计数机制所带来的维护引用计数的额外操作与Python运行中所进行的内存分配和释放，引用赋值的次数是成正比的，这显然比其它那些垃圾收集技术所带来的额外操作只是与待回收的内存数量有关的效率要低。同时，引用技术还存在另外一个很大的问题－循环引用，因为对象之间相互引用，每个对象的引用都不会为0，所以这些对象所占用的内存始终都不会被释放掉。如下：

a = []
b = []
a.append(b)
b.append(a)
print a
[[[…]]]
print b
[[[…]]]
标记－清除
标记－清除只关注那些可能会产生循环引用的对象，显然，像是PyIntObject、PyStringObject这些不可变对象是不可能产生循环引用的，因为它们内部不可能持有其它对象的引用。Python中的循环引用总是发生在container对象之间，也就是能够在内部持有其它对象的对象，比如list、dict、class等等。这也使得该方法带来的开销只依赖于container对象的的数量？？？

原理：1. 寻找跟对象（root object）的集合作为垃圾检测动作的起点，跟对象也就是一些全局引用和函数栈中的引用，这些引用所指向的对象是不可被删除的；2. 从root object集合出发，沿着root object集合中的每一个引用，如果能够到达某个对象，则说明这个对象是可达的，那么就不会被删除，这个过程就是垃圾检测阶段；3. 当检测阶段结束以后，所有的对象就分成可达和不可达两部分，所有的可达对象都进行保留，其它的不可达对象所占用的内存将会被回收，这就是垃圾回收阶段。（底层采用的是链表将这些集合的对象连接在一起）

缺点：标记和清除的过程效率不高。

分代回收
原理：将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，Python默认定义了三代对象集合，垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾，就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。

server端:
import socket
sk = socket.socket()         # 创建客户套接字
sk.bind(('127.0.0.1',8898))  #把地址绑定到套接字
sk.listen()          #监听链接
conn,addr = sk.accept() #接受客户端链接
ret = conn.recv(1024)  #接收客户端信息
print(ret)       #打印客户端信息
conn.send(b'hi')        #向客户端发送信息
conn.close()       #关闭客户端套接字
sk.close()        #关闭服务器套接字(可选)
client端:
import socket
sk = socket.socket()           # 创建客户套接字
sk.connect(('127.0.0.1',8898))    # 尝试连接服务器
sk.send(b'hello!')
ret = sk.recv(1024)         # 对话(发送/接收)
print(ret)
sk.close()            # 关闭客户套接字

#下面代码会输出什么
def f(x,l=[]):
    for i in range(x):
        l.append(i*i)
    print(l)
f(2)  #[0, 1]
f(3,[3,2,1]) #[3, 2, 1, 0, 1, 4]
f(3)  #[0, 1, 0, 1, 4]


#下面代码会输出什么
class Parent(object):
    x=1
class Child1(Parent):
    pass
class Child2(Parent):
    pass
print(Parent.x,Child1.x,Child2.x)   #1 1 1
print(Parent.x,Child1.x,Child2.x)  #1 2 1
Parent.x=3
print(Parent.x,Child1.x,Child2.x)  #3 2 3[6, 6, 6, 6]



#下面代码会输出什么
def multipliers():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()]) #[6, 6, 6, 6]

def quchong(list1):
   list2=[];
   for i in list1:
       if i not in list2:
           list2.append(i);
   print(list2);
list1 = [9, 4, 2, 5, 8,4,5,3];
quchong(list1)

import threading
import time


class Foo(object):
    _instance = None
    _lock = threading.RLock()

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


def task():
    obj = Foo()
    print(obj)


for i in range(10):
    t = threading.Thread(target=task)
    t.start()

time.sleep(100)
obj = Foo()

数字、字符串、Bytes、列表、元组、字典、集合、布尔等

==比较数值

is比较内存地址

1：*args的功能:------接收多个位置参数，转换成元组tuple形式
2：**kwargs的功能------接收多个关键字参数，转换成字典dict形式
3：位置参数一定要在关键字参数之前，也就是(*args，**kwargs)

什么是lamda函数？
lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数。 （注意：lambda 函数不能包含命令，它们所包含的表达式不能超过一个）
lamda函数有什么好处？
1、lambda函数比较轻便，即用即仍，很适合需要完成一项功能，但是此功能只在此一处使用，连名字都很随意的情况下；
2、匿名函数，一般用来给filter，map这样的函数式编程服务;
3、作为回调函数，传递给某些应用，比如消息处理

标准包:内置模块?
"""
    os
    time & datetime
    random
    hashlib
    sys
    re 
    logging
    json
    pickle
    
"""

# 11. 第三方模块
"""
    requsts
    bs4 
    pymysql
    pymongo
    gevent

range: range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列。注意这里是生成一个序列。

xrange的用法与range相同，即xrange([start,] stop[, step])根据start与stop指定的范围以及step设定的步长,他所不同的是xrange并不是生成序列，而是作为一个生成器。即他的数据生成一个取出一个。

所以相对来说，xrange比range性能优化很多，因为他不需要一下子开辟一块很大的内存，特别是数据量比较大的时候。

注意：1、xrange和range这两个基本是使用在循环的时候。

           2、 当需要输出一个列表的时候，就必须要使用range了。

进程:资源分配的最小单位
线程:CPU调度的最小单位
进程:IO密集型/计算密集型 提高并发,资源浪费.
    线程:IO密集型提高并发,多个线程
    协程:IO密集型提供并发,1个线程
    
    计算密集型:进程
    IO密集型:线程 < 协程
区别:

1、 一个程序中至少有一个进程，一个进程中至少有一个线程；
2、 线程的划分尺度小于进程（占有资源），使得多线程程序的并发性高；
3、 进程运行过程中拥有独立的内存空间，而线程之间共享内存，从而极大的提高了程序的运行效率
4、 线程不能独立运行，必须存在于进程中
优缺点： 
线程开销小，但是不利于资源的管理和保护，而进程反之。

元组：()用元括弧括起来的一组元素集合。其特点是内容不可变，即一旦定义其长度和内容都是固定的；类似于C询言的数组。如： t = (0, True, ‘a’) 上面就定义了一个包含3个子元素的元组列表，访问元组成员的格式是使用成员下标，如： print t(1)   True （理解为C的数组）

列表：[]由中括弧括起来的包含一组元素的集合；其特点是长度和内容都可以改变。定义如下： L = [0, False, ‘l’] 列表可以进行如下操作： 添加元素：L.append(1) 删除元素：del L[0] 插入元素：L.insert(2, 3) 修改元素：L[1] = True （理解为java链表数组）

字典：{}Python中的字典和其它询言的字典是一个意思，是对hashmap的实现；其询法定义为： d = {‘k1’: ‘k’, ‘k2’: ‘k2’} 字典可以有如下操作： 增加键值对：d[‘k3’] = 3 删除键值对：del d[‘k’]  修改键值对：d[‘k2’] = True 获取键值： d[‘k1’] 

l1 = ["alex","wusir"]
l1.remove("alex")
dic = {'name':'老男孩','age':56,'hobby':'women'}
del dic['name']

都是通过元素找索引:
 find()方法：查找子字符串，若找到返回从0开始的下标值，若找不到返回-1
index方法是在字符串里查找子串第一次出现的位置,如果查找不到子串，会抛出异常，

1.Web框架
Django： 开源Web开发框架，它鼓励快速开发,并遵循MVC设计，开发周期短。
ActiveGrid： 企业级的Web2.0解决方案。
Karrigell： 简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库PyDBLite。
Tornado： 一个轻量级的Web框架，内置非阻塞式服务器，而且速度相当快
webpy： 一个小巧灵活的Web框架，虽然简单但是功能强大。
CherryPy： 基于Python的Web应用程序开发框架。
Pylons： 基于Python的一个极其高效和可靠的Web开发框架。
Zope： 开源的Web应用服务器。
TurboGears： 基于Python的MVC风格的Web应用程序框架。
Twisted： 流行的网络编程库，大型Web框架。
Quixote： Web开发框架。
2.科学计算
Matplotlib： 用Python实现的类matlab的第三方库，用以绘制一些高质量的数学二维图形。
SciPy： 基于Python的matlab实现，旨在实现matlab的所有功能。
NumPy： 基于Python的科学计算第三方库，提供了矩阵，线性代数，傅立叶变换等等的解决方案。
3.GUI
PyGtk： 基于Python的GUI程序开发GTK+库。
PyQt： 用于Python的QT开发库。
WxPython： Python下的GUI编程框架，与MFC的架构相似。
4.其它
BeautifulSoup： 基于Python的HTML/XML解析器，简单易用。
PIL： 基于Python的图像处理库，功能强大，对图形文件的格式支持广泛。
PyGame： 基于Python的多媒体开发和游戏软件开发模块。
Py2exe： 将python脚本转换为windows上可以独立运行的可执行程序。

MVC是一种架构设计模式，是一种设计理念。是为了达到分层设计的目的，从而使代码解耦，便于维护和代码的复用。MVC是3个单词的缩写，全称：Model-View-Controller（模型-视图-控制器）。

1、Model

模型层，可以简单理解就是数据层，用于提供数据。在项目中，（简单理解）一般把数据访问和操作，比如将对象关系映射这样的代码作为Model层，也就是对数据库的操作这一些列的代码作为Model层。比如代码中我们会写DAO和DTO类型的代码，那这个DAO和DTO我们可以理解为是属于Model层的代码。

2、View

视图层，就是UI界面，用于跟用户进行交互。一般所有的JSP、Html等页面就是View层。

3、Controller

控制层，Controller层的功能就是将Model和View层进行关联。比如View主要是显示数据的，但是数据又需要Model去访问，这样的话，View会先告诉Controller，然后Controller再告诉Model，Model请求完数据之后，再告诉View。这样View就可以显示数据了。

数据库中的数据都是存储在表中的，而视图只是一个或多个表依照某个条件组合而成的结果集，一般来说你可以用update，insert，delete等sql语句修改表中的数据，而对视图只能进行select操作。但是也存在可更新的视图，对于这类视图的update，insert和delete等操作最终会作用于与其相关的表中数据。因此，表是数据库中数据存储的基础，而视图只是为了满足某种查询要求而建立的一个对象。

表是物理存在的，你可以理解成计算机中的文件！
视图是虚拟的内存表，你可以理解成Windows的快捷方式！
区别：1、视图是已经编译好的sql语句。而表不是  
      2、视图没有实际的物理记录。而表有。
      3、表是内容，视图是窗口
      4、表只用物理空间而视图不占用物理空间，视图只是逻辑概念的存在，表可以及时对它进行修改，但视图只能有创建的语句来修改
      5、表是内模式，视图是外模式
      6、视图是查看数据表的一种方法，可以查询数据表中某些字段构成的数据，只是一些SQL语句的集合。从安全的角度说，视图可以不给用户接触数据表，从而不知道表结构。
      7、表属于全局模式中的表，是实表；视图属于局部模式的表，是虚表。 
      8、视图的建立和删除只影响视图本身，不影响对应的基本表。

data={'time':'2016-08-05T13;13:05',
      'some_ID':'ID1234',
      'graps1':{'fld1':1,'fld2':2},
      'xxx2':{'fld3':0,'fld5':0.4},
      'fld6':11,
      'fld7':7,
      'fld':8
}
# 类递归思想  # 栈的思想
fields = 'fld2|fld3|fld7|fld9'
fields_lst = fields.split('|')  #['fld2', 'fld3', 'fld7', 'fld9']
result = {}
data_lst = [1]
while data != 1:
      for key in data:
            if key in fields_lst:
                 result[key] = data[key]
            if type(data[key]) == dict:
                  data_lst.append(data[key])
      data = data_lst.pop()  
print(result)

#思路一：
def select(data,fields):
    result = {}
    field_lst = fields.split('|')
    for key in data:
        if key in field_lst:
            result[key] = data[key]
        elif type(data[key]) == dict:
            res = select(data[key],fields)
            result.update(res)
    return result
data={"time":"2016-08-05T13:13:05",
    "some_id":"ID1234",
    "grp1":{ "fld1":1,"fld2":2},
    "xxx2":{ "fld3":0,"fld5":0.4},
    "fld6":11,
    "fld7":7,
    "fld46":8}
fields = 'fld2|fld3|fld7|fld19'
print(select(data,fields))

#思路二：
def select(data,fields,result = {}):
    field_lst = fields.split('|')
    for key in data:
        if key in field_lst:
            result[key] = data[key]
        elif type(data[key]) == dict:
            select(data[key], fields)
    return result
data={"time":"2016-08-05T13:13:05",
    "some_id":"ID1234",
    "grp1":{ "fld1":1,"fld2":2},
    "xxx2":{ "fld3":0,"fld5":0.4},
    "fld6":11,
    "fld7":7,
    "fld46":8}
fields = 'fld2|fld3|fld7|fld19'
select(data,fields)
print(select(data,fields))

li=[1,2]
while li[-1]<4000000:
    li.append(li[-1]+li[-2])
del li[-1]
print(li[-1])
print(len(li))

def func(x):
    if x <= 3:
    return x
    else:
    first = 2
    second = 3
    for i in range(3,x-1):
        value = first + second
        first = second
        second = value
    return first+second
 
print func(32)

dicta={'a':1,'b':2,'c':3,'d':4,'f':'hello'}
dictb={'b':3,'d':5,'e':7,'m':9,'k':'world'}
dic={}
for key1 in dicta:
    for key2 in dictb:
        if key1==key2:
            dic[key1]=dicta[key1]+dictb[key2]
for a in dicta:
    if a not in dic:
        dic[a]=dicta[a]
for b in dictb:
    if b not in dic:
        dic[b]=dictb[b]
print(dic)