线程切换

json库

tornado异步请求

tornado.web.asynchronous这个装饰器 ioloop

a 36  21  21 15  15 6 6 3 3 0

块 类 函数

with  上下文管理器__enter__() 和 __exit__() 方法  contextlib 模块  自定义上下文管理器

Python核心编程，python简明教程

WSGI 和 FastCGI 的关系

CGI全称是“公共网关接口”(CommonGateway Interface)，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，其程序须运行在网络服务器上。

FastCGI像是一个常驻(long-live)型的CGI，它可以一直执行着，只要激活后，不会每次都要花费时间去fork一次(这是CGI最为人诟病的fork-and-execute模式)。

WSGI的全称为： PythonWeb Server Gateway Interface v1.0 （Python Web 服务器网关接口），

它是 Python 应用程序和 WEB 服务器之间的一种接口。

Tornado

它是非阻塞式服务器，而且速度相当快。得利于其 非阻塞的方式和对epoll的运用

Http协议

规定了浏览器和万维网服务器之间互相通信的规则，通过因特网传送万维网文档的数据传送协议。是一个应用程序级的基于TCP / IP协议，分布式，协作，超媒体信息系统（互联网）。

HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。

HTTP协议的主要特点可概括如下：

1.支持客户/服务器模式。

2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。

3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。

4.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。

5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

Http请求头和常见响应状态码

HTTP 1.1中加入了“Host”请求头字段  支持长连接

2xx：成功--表示请求已被成功接收、理解、接受

4xx：客户端错误--请求有语法错误或请求无法实现

装饰器

    面向切面编程AOP

def deco(func):

    def _deco():

        print("before myfunc() called.")

        func()

        print("  after myfunc() called.")

        # 不需要返回func，实际上应返回原函数的返回值

    return _deco

@deco

def myfunc():

    print(" myfunc() called.")

    return 'ok'

myfunc()

python参数

*args and **kwargs

def funcC(a, b=0):  funcB(a=100, b=99)  def funcD(a, b, *c):

必须参数  缺省参数  可变参数tuple 关键字参数dict

用*args和**kwargs只是为了方便并没有强制使用它们.

当你不确定你的函数里将要传递多少参数时你可以用*args.例如,它可以传递任意数量的参数:

Python

1

2

3

4

5

6

7

8

>>> def print_everything(*args):

for count, thing in enumerate(args):

... print '{0}. {1}'.format(count, thing)

...

>>> print_everything('apple', 'banana', 'cabbage')

0. apple

1. banana

2. cabbage

相似的,**kwargs允许你使用没有事先定义的参数名:

Python

1

2

3

4

5

6

7

>>> def table_things(**kwargs):

... for name, value in kwargs.items():

... print '{0} = {1}'.format(name, value)

...

>>> table_things(apple = 'fruit', cabbage = 'vegetable')

cabbage = vegetable

apple = fruit

python 不需要重载

函数重载主要是为了解决两个问题。

可变参数类型。    python 可以接受任何类型的参数

可变参数个数。    缺省参数

新式类和旧式类

新式类是广度优先,旧式类是深度优先) 

继承object的是新式类

__new__和__init__的区别

__new__是一个静态方法,而__init__是一个实例方法.

new方法会返回所构造的对象，init则不会.

new函数必须以cls作为第一个参数，而init则以self作为其第一个参数.

单例模式

装饰器版本

def singleton(cls, *args, **kw):

    instances = {}

    def getinstance():

        if cls not in instances:

            instances[cls] = cls(*args, **kw)

        return instances[cls]

    return getinstance

@singleton

class MyClass:

class Singleton(object):

__instance=None

def__init__(self):

pass

def__new__(cls,*args,**kwd):

if Singleton.__instance is None:

Singleton.__instance=object.__new__(cls,*args,**kwd)

return Singleton.__instance

import方法

作为python的模块是天然的单例模式

Python

1

2

3

4

5

6

7

8

9

10

11

# mysingleton.py

class My_Singleton(object):

def foo(self):

pass

my_singleton = My_Singleton()

# to use

from mysingleton import my_singleton

my_singleton.foo()

@classmethod    @staticmethod  @property这三个装饰器的使用对象是在类中定义的函数  property把一个方法变成属性调用，通常用在属性的get方法和set方法，通过设置@property可以实现实例成员变量的直接访问，又保留了参数的检查。

未装饰的方法还是正常的行为方式，需要当前的类实例（self）作为第一个参数。

类方法的第一个参数永远是该类

静态方法（static method）中除了你调用时传入的参数以外，没有其他的参数。

@property是实现getter和setter方法的一种方式。直接调用它们是错误的。

# “只读”属性可以通过只定义getter方法，不定义setter方法实现。

class MyClass:

...

  @classmethod  # classmethod的修饰符  def class_method(cls, arg1, arg2, ...):

  ...

  @staticmethod  # staticmethod的修饰符  def static_method(arg1, arg2, ...):

  ...

对于classmethod的参数，需要隐式地传递类名，而staticmethod参数中则不需要传递类名，其实这就是二者最大的区别。

Python中的作用域

Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定的。

当 Python 遇到一个变量的话他会按照这样的顺序进行搜索：

本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

GIL线程全局锁

线程全局锁(Global Interpreter Lock),即Python为了保证线程安全而采取的独立线程运行的限制,说白了就是一个核只能在同一时间运行一个线程.

协程

简单点说协程是进程和线程的升级版,进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间,而协程就是用户自己控制切换的时机,不再需要陷入系统的内核态.

Python里最常见的yield就是协程的思想!

闭包

必须有一个内嵌函数

内嵌函数必须引用外部函数中的变量

外部函数的返回值必须是内嵌函数

匿名函数

>>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])

[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> f = lambda x: x * x

>>> f

at 0x10453d7d0>

>>> f(5)

25

def build(x, y):

    return lambda: x * x + y * y

偏函数

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools>>> int2 = functools.partial(int, base=2)>>> int2('1000000')64>>> int2('1010101')85

高阶函数  函数式编程

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x, y, f):

    return f(x) + f(y)

x ==> -5y ==> 6f ==> abs

f(x) + f(y) ==> abs(-5) + abs(6) ==> 11

map

>>> def f(x):...    return x * x

...>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce

>>> def add(x, y):...    return x + y

...>>> reduce(add, [1, 3, 5, 7, 9])25

filter

def is_odd(n):

    return n % 2 == 1filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])# 结果: [1, 5, 9, 15]

内置模块和第三方模块

os,sys,urllib,urllib2,re,json，copy，random， itertools，functools，shutil，pickle，sqlite3,string,gzip,csv,hashlib,md5,io ,time,platform,select,threading,subprocess,xmldom,cookie,parser

lxml  etree，collection

第三方库

BeautifulSoup，xlwt（用于将数据写到excel文件），scrapy，pyspider，PIL（用于处理图像方面的图形库）

Numpy：高阶大量的矩阵运算，pip，django，webpy，twisted，pyqt，mySQLdb，py2exe，用于生成文本的模板工具Jinja2，logging，spark，pymango，flask，selenium，matplotlib 画图，gevent  ，except，sched

Python所有的内置函数

Built-in Functions

abs()divmod()input()open()staticmethod()

all()enumerate()int()ord()str()

any()eval()isinstance()pow()sum()

basestring()execfile()issubclass()print()super()

bin()file()iter()property()tuple()

bool()filter()len()range()type()

bytearray()float()list()raw_input()unichr()

callable()format()locals()reduce()unicode()

chr()frozenset()long()reload()vars()

classmethod()getattr()map()repr()xrange()

cmp()globals()max()reversed()zip()

compile()hasattr()memoryview()round()__import__()

complex()hash()min()set()apply()

delattr()help()next()setattr()buffer()

dict()hex()object()slice()coerce()

dir()id()oct()sorted()intern()

re

# encoding: UTF-8

import re

# 将正则表达式编译成Pattern对象

pattern = re.compile(r'hello')

# 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None

match = pattern.match('hello world!')

if match:

    # 使用Match获得分组信息

    print match.group()

### 输出 ###

# hello

copy 和deepcopy

浅复制只复制对象本身，没有复制该对象所引用的对象。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

#coding=gbk

import copy

l1 = [1, 2, [3, 4]]

l2 = copy.copy(l1)

print l1

print l2

l2[2][0] = 50

print l1

print l2

#---- 结果 ----

[1, 2, [3, 4]]

[1, 2, [3, 4]]

[1, 2, [50, 4]]

[1, 2, [50, 4]]

同样的代码，使用深复制，结果就不一样：

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

import copy

l1 = [1, 2, [3, 4]]

l2 = copy.deepcopy(l1)

print l1

print l2

l2[2][0] = 50

print l1

print l2

#---- 结果 ----

[1, 2, [3, 4]]

[1, 2, [3, 4]]

[1, 2, [3, 4]]

[1, 2, [50, 4]]

import copy

a = [1, 2, 3, 4, ['a', 'b']]  #原始对象

b = a  #赋值，传对象的引用

c = copy.copy(a)  #对象拷贝，浅拷贝

d = copy.deepcopy(a)  #对象拷贝，深拷贝

a.append(5)  #修改对象a

a[4].append('c')  #修改对象a中的['a', 'b']数组对象

print 'a = ', a

print 'b = ', b

print 'c = ', c

print 'd = ', d

输出结果：

a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]

b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]

c =  [1, 2, 3, 4, ['a', 'b', 'c']]

d =  [1, 2, 3, 4, ['a', 'b']]

os和sys

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;sys模块负责程序与Python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

os 常用方法

os.remove(‘path/filename’) 删除文件

os.rename(oldname, newname) 重命名文件

os.walk() 生成目录树下的所有文件名

os.chdir('dirname') 改变目录

os.mkdir/makedirs('dirname')创建目录/多层目录

os.rmdir/removedirs('dirname') 删除目录/多层目录

os.listdir('dirname') 列出指定目录的文件

os.getcwd() 取得当前工作目录

os.chmod() 改变目录权限

os.path.basename(‘path/filename’) 去掉目录路径，返回文件名

os.path.dirname(‘path/filename’) 去掉文件名，返回目录路径

os.path.join(path1[,path2[,...]]) 将分离的各部分组合成一个路径名

os.path.split('path') 返回( dirname(), basename())元组

os.path.splitext() 返回 (filename, extension) 元组

os.path.getatimectimemtime 分别返回最近访问、创建、修改时间

os.path.getsize() 返回文件大小

os.path.exists() 是否存在

os.path.isabs() 是否为绝对路径

os.path.isdir() 是否为目录

os.path.isfile() 是否为文件

sys 常用方法

sys.argv 命令行参数List，第一个元素是程序本身路径

sys.modules.keys() 返回所有已经导入的模块列表

sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息

sys.exit(n) 退出程序，正常退出时exit(0)

sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0

sys.version 获取Python解释程序的版本信息

sys.maxint 最大的Int值

sys.maxunicode 最大的Unicode值

sys.modules 返回系统导入的模块字段，key是模块名，value是模块

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

sys.stdout 标准输出

sys.stdin 标准输入

sys.stderr 错误输出

sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息

sys.exec_prefix 返回平台独立的python文件安装的位置

sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'

sys.copyright 记录python版权相关的东西

sys.api_version 解释器的C的API版本

json

>>> import json

>>> data = {"spam" : "foo", "parrot" : 42}

>>> in_json = json.dumps(data) # Encode the data

>>> in_json'{"parrot": 42, "spam": "foo"}'>>> json.loads(in_json) # Decode into a Python object{"spam" : "foo", "parrot" : 42}

urllib 和urllib2

urllib2可以用urllib2.openurl中设置Request参数，来修改Header头。如果你访问一个网站，想更改User Agent（可以伪装你的浏览器），你就要用urllib2.

urllib支持设置编码的函数，urllib.urlencode,在模拟登陆的时候，经常要post编码之后的参数，所以要想不使用第三方库完成模拟登录，你就需要使用urllib。

urllib一般和urllib2一起搭配使用

这个面试官确实问过,当时答的urllib2可以Post而urllib不可以.

urllib提供urlencode方法用来GET查询字符串的产生，而urllib2没有。这是为何urllib常和urllib2一起使用的原因。

urllib2可以接受一个Request类的实例来设置URL请求的headers，urllib仅可以接受URL。这意味着，你不可以伪装你的User Agent字符串等。

itertools

>>> import itertools>>> natuals = itertools.count(1)>>> for n in natuals:...    print n

...123...

>>> import itertools>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种>>> for c in cs:...    print c

...'A''B''C''A''B''C'...

>>> ns = itertools.repeat('A', 10)>>> for n in ns:...    print n

...

打印10次'A'

functools.partial 通过包装手法，允许我们 "重新定义" 函数签名

# shutil 模块

shutil.copyfile( src, dst) 从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉

shutil.move( src, dst)  移动文件或重命名

shutil.copymode( src, dst) 只是会复制其权限其他的东西是不会被复制的

shutil.copystat( src, dst) 复制权限、最后访问时间、最后修改时间

shutil.copy( src, dst)  复制一个文件到一个文件或一个目录

shutil.copy2( src, dst)  在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西

shutil.copy2( src, dst)  如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作

shutil.copytree( olddir, newdir, True/Flase)

把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接

shutil.rmtree( src ) 递归删除一个目录以及目录内的所有内容

#pickle 模块

python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

　pickle.dump(obj, file, [,protocol])

pickle.load(file)

#使用pickle模块将数据对象保存到文件

import pickle

data1 = {'a': [1, 2.0, 3, 4+6j],

        'b': ('string', u'Unicode string'),

        'c': None}

selfref_list = [1, 2, 3]

selfref_list.append(selfref_list)

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.

pickle.dump(data1, output)

# Pickle the list using the highest protocol available.

pickle.dump(selfref_list, output, -1)

output.close()

 hashlib是涉及安全散列和消息摘要，提供多个不同的加密算法借口，如SHA1、SHA224、SHA256、SHA384、SHA512、MD5等

import hashlib

m = hashlib.md5()  #创建hash对象，md5:(message-Digest Algorithm 5)消息摘要算法,得出一个128位的密文print m            #m.update('BeginMan')#更新哈希对象以字符串参数print m.digest()    #返回摘要，作为二进制数据字符串值print m.hexdigest() #返回十六进制数字字符串    0b28251e684dfbd9102f8b6f0281c0c5print m.digest_size #16print m.block_size  #64

select poll epoll

2.6以后的内核就是epoll，tornado也是epoll

select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制.select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟 使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

poll没有最大文件描述符数量的限制。

poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。

epoll采用基于事件的就绪通知方式。

当一个服务器需要与多个客户端进行通信时，可以使用多进程或者多线程的服务器，也可以使用select模块，它可以实现异步通信

基本上select有3个缺点:

连接数受限

查找配对速度慢

数据由内核拷贝到用户态

#cookielib 模块

python内置有cookielib模块操作cookie，配合urllib模块就可以了很轻易的爬取数据。

列表推导式

>>> [x * x for x in range(1, 11) if x % 2 == 0]

[4, 16, 36, 64, 100]

>>> [m + n for m in 'ABC' for n in 'XYZ']

['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }>>> for k, v in d.iteritems():...    print k, '=', v... y = B

x = A

z = C

Python垃圾回收机制

Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题，通过“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率。

1 引用计数

PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少.引用计数为0时，该对象生命就结束了。

优点:

简单

实时性

缺点:

维护引用计数消耗资源

循环引用

2 标记-清除机制

基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。

3 分代技术

分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。

Python默认定义了三代对象集合，索引数越大，对象存活时间越长。

举例：

当某些内存块M经过了3次垃圾收集的清洗之后还存活时，我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行，这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。在这个过程中，集合B中的某些内存块由于存活时间长而会被转移到集合A中，当然，集合A中实际上也存在一些垃圾，这些垃圾的回收会因为这种分代的机制而被延迟。

迭代器和生成器

不适用迭代器

def fab(max):

    L = []

    n, a, b = 0, 0, 1

    while n < max:

        L.append(b)

        a, b = b, a + b

        n = n + 1

    return L

class Fab(object):

    def __init__(self, max):

        self.max = max

        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):

        return self

    def next(self):

        if self.n < self.max:

            r = self.b

            self.a, self.b = self.b, self.a + self.b

            self.n = self.n + 1

            return r

        raise StopIteration()

生成器（yield）既可以保持代码1的简洁性，又可以保持代码3的效果

def fab(max):

    n, a, b = 0, 0, 1

    while n < max:

        yield b

        a, b = b, a + b

        n = n + 1

Cookie和Session

CookieSession

储存位置客户端服务器端

目的跟踪会话，也可以保存用户偏好设置或者保存用户名密码等跟踪会话

安全性不安全安全

session技术是要使用到cookie的，之所以出现session技术，主要是为了安全。

XSRF和XSS

CSRF(Cross-site request forgery)跨站请求伪造

XSS(Cross Site Scripting)跨站脚本攻击

CSRF重点在请求,XSS重点在脚本

nginx

抗并发，nginx 处理请求是异步非阻塞的，支持更多的并发连接，而apache 则是阻塞型的，在高并发下nginx 能保持低资源低消耗高性能

restful

（1）每一个URI代表一种资源；

　　（2）客户端和服务器之间，传递这种资源的某种表现层；

　　（3）客户端通过四个HTTP动词，对服务器端资源进行操作，实现"表现层状态转化"。

Python自省

这个也是python彪悍的特性.

自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.比如type(),dir(),getattr(),hasattr(),isinstance().

字典推导式

L = [1,2,3,4,5,6,7,8,9]

要生成下面这样的字典：

{1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80, 9: 90}

以前需要这样：

dict([(v, v*10) for v in L])

现在可以直接这样：

{v: v*10 for v in L}

Python的函数参数传递

看两个例子:

Python

1

2

3

4

5

a = 1

def fun(a):

a = 2

fun(a)

print a # 1

Python

1

2

3

4

5

a = []

def fun(a):

a.append(1)

fun(a)

print a # [1]

所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。

这里记住的是类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象。(这就是这个问题的重点)

当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了.所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉.而第二个例子就不一样了,函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改.

进程和线程

线程切换

计算密集型  不适合用python

IO密集型  网络，磁盘，web应用，瓶颈不在CPU

操作系统提供异步IO的支持，称为事件驱动模型

Nginx就是支持异步IO的Web服务器，它在单核CPU上采用单进程模型就可以高效地支持多任务

对应到Python语言，单进程的异步编程模型称为协程，有了协程的支持，就可以基于事件驱动编写高效的多任务程序

序列化

Python语言特定的序列化模块是pickle，但如果要把序列化搞得更通用、更符合Web标准，就可以使用json模块。

json模块的dumps()和loads()函数是定义得非常好的接口的典范。

继承

class A(object):

    def go(self):

        print "go A go!"

    def stop(self):

        print "stop A stop!"

    def pause(self):

        raise Exception("Not Implemented")

class B(A):

    def go(self):

        super(B, self).go()

        print "go B go!"

python语言优势

解释型：不需要编译  动态：声明变量不需要说明变量的类型，专注于算法和数据结构的设计，不用处理底层细节，胶水语言

运行速度慢

递归算法

def print_directory_contents(sPath):

    import os

    for sChild in os.listdir(sPath):

        sChildPath = os.path.join(sPath,sChild)

        if os.path.isdir(sChildPath):

            print_directory_contents(sChildPath)

        else:

            print sChildPath

print_directory_contents('C:/Users/F1316196/PycharmProjects/untitled/')

旧列表和新列表传参数

def f(x,l=[]):

    for i in range(x):

        l.append(i*i)

    print l

f(2)

f(3,[3,2,1])

f(3)

[0, 1]

[3, 2, 1, 0, 1, 4]

[0, 1, 0, 1, 4]

各种语言都用过，才会对各种概念有更深刻的理解。

nodejs  express  实现restful web service  即表述性状态传递（英文：Representational State Transfer，简称REST 

以下为 REST 基本架构的四个方法：

GET - 用于获取数据。

PUT - 用于添加数据。

DELETE - 用于删除数据。

POST - 用于更新或添加数据。

经历：获取用户列表，添加删除用户 ；webui 11.5 html5 redfish协议，postman，在system，chassis，manager方面测试。

微信开发

微信公众号 ，url，token

index.wsgi  相当于views.py

get过来的进行验证

post过来的数据进行XML解析，获得用户所输入的内容

memcached

pylibmc  random  set get random.choice

$def with (toUser,fromUser,createTime,content)

$createTime

SSH 框架的理解

maven ,ant,web.xml,spirng-mvc-servlet.xml

AOP  IOC 控制反转，依赖注入

@controller  @requestMapping

xml版本，注解版本进行控制

SpringAOP 是面向方面编程，实现事务处理、日志服务等与业务无关的系统服务，实现插件式编程。

Spring的IoC来实现组件之间的依赖关系注入

Struts在项目中主要负责视图层、控制层，在视图层提供了大量的标签库，提高视图层的开发速度。在控制层使用中央控制器（Actionsupport）和配置文件(struts.xml)，实现拦截用户请求、封装请求参数及页面导航。

改数据库不需要更改代码，因为Hibernate会根据数据库方言来生成对应的SQL语句；2、是对JDBC的轻量级封装，简化持久层的代码，提高开发速度。

AngularJS 

ng-app 指令告诉 AngularJS，

ng-model 指令把输入域的值绑定到应用程序变量 name。

ng-bind 指令把应用程序变量 name 绑定到某个段落的 innerHTML。

把后台实现移动到了前端

Html5 新特点

Audio & Video: 可以嵌入您的网页上的音频或视频，而不诉诸第三方插件.

Drag and drop: 从一个位置到另一个位置的同一网页上拖放项目.

WebSocket : 下一代Web应用程序的双向通讯技术。

新的语义元素: 它们如 , 和 .

nodejs

goole V8

回调函数 express 事件驱动

事件驱动程序

Node.js 使用事件驱动模型，当web server接收到请求，就把它关闭然后进行处理，然后去服务下一个web请求。

当这个请求完成，它被放回处理队列，当到达队列开头，这个结果被返回给用户。

这个模型非常高效可扩展性非常强，因为webserver一直接受请求而不等待任何读写操作。（这也被称之为非阻塞式IO或者事件驱动IO）

在事件驱动模型中，会生成一个主循环来监听事件，当检测到事件时触发回调函数。

前端

jquery选择器，事件方法    jquery ajax  load，get，post

jqueryUI  日期选择器，小部件 widget

jquery ui 是jquery开发团队 开发，适用于网站式的页面。

jquery easyui 是第三方基于jquery开发，适用于应用程序式的页面。

两者的方法调用也略有不同：

jquery ui 是：

$("#divTabs").tabs("remove" , index);

jquery easyui 是：

$("#divTabs").tabs("close" , title);

bootstrap可视化组件

反射（自省）

python的反射，它的核心本质其实就是利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！

import commons

def run():

    inp = input("请输入您想访问页面的url： ").strip()

    func = getattr(commons, inp)

    func()

if __name__ == '__main__':

    run()

python的四个重要内置函数：getattr、hasattr、delattr和setattr较为全面的实现了基于字符串的反射机制。他们都是对内存内的模块进行操作，并不会对源文件进行修改。

多进程 多线程

gevent协程

from gevent import monkey; monkey.patch_socket()import geventdef f(n):

    for i in range(n):

        print gevent.getcurrent(), i

g1 = gevent.spawn(f, 5)

g2 = gevent.spawn(f, 5)

g3 = gevent.spawn(f, 5)

g1.join()

g2.join()

g3.join()

简述Python的作用域以及Python搜索变量的顺序

Python作用域简单说就是一个变量的命名空间。代码中变量被赋值的位置，就决定了哪些范围的对象可以访问这个变量，这个范围就是变量的作用域。在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域。Python的变量名解析机制也称为 LEGB 法则：本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

多线程代码

Lock、Rlock类

Condition类

可以认为，除了Lock带有的锁定池外，Condition还包含一个等待池，池中的线程处于等待阻塞状态，直到另一个线程调用notify()/notifyAll()通知；得到通知后线程进入锁定池等待锁定。

Event类

Event其实就是一个简化版的 Condition。Event没有锁，无法使线程进入同步阻塞状态。

timer类

Timer（定时器）是Thread的派生类，用于在指定时间后调用一个方法。

Semaphore

Thread类

isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。 

　　get/setName(name): 获取/设置线程名。 

　　start():  线程准备就绪，等待CPU调度

　　is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）

　　　　如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止

       　　如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

　　start(): 启动线程。 

　　join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。

django需要安装openssl，twisted库

git

我们使用 git clone 从现有 Git 仓库中拷贝项目（类似 svn checkout）。

每个开发人员从中心版本库/服务器上chect out代码后会在自己的机器上克隆一个自己的版本库。可以这样说，如果你被困在一个不能连接网络的地方时，就像在飞机上，地下室，电梯里等，你仍然能够提交文件，查看历史版本记录，创建项目分支，等。对一些人来说，这好像没多大用处，但当你突然遇到没有网络的环境时，这个将解决你的大麻烦。

GIT把内容按元数据方式存储，而SVN是按文件：

python框架比较

flask    ：

url映射

@app.route('/login', methods = ['GET', 'POST'])

tornado：

异步非阻塞IO

webpy：

容易理解，小巧灵活

写过的python脚本

fru信息获取，整理成json格式  json dumps loads

微信号  webpy  mysql  memcached

svn备份  sched定时任务

MEI  platform，subprocess，

diag  遍历解析xml

pyqt

socket传文件，对时

装饰器记录日志，logging模块

psuti 查看cpu memory状态

os.kill 杀死进程

数据结构

Python中常见的数据结构可以统称为容器（container）。而序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。

Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象

算法

冒泡排序法

array = [1,7,2,3,6,5,4]

def bubble(array):

    for i in range(len(array)):

        for j in range(i):

            if array[j] > array[i]:

                array[j], array[i] = array[i], array[j]

    print array

    return array

bubble(array)

bruins底层开发

memmap，

ioremap写字符设备驱动 ioctrl

linux shell

函数传参数$    python也有except模块

贴近linux命令 ，  expect ， 多线程 ， 代码块tee 重定向，curl，grep，awk

linux

vim ，文件系统打trap，samba，联系测试diag，编译成动态静态库.a,.so[vesta]

浏览器兼容

margin，padding，div

html

select，option，ul，li，form

分布式理解

map/reduce

git

 Hadoop是一个分布式系统基础框架，基于这个框架开发分布式应用程序，利用集群的高速运算和存储的威力。类似于，基于NVIDIA 的 CUDA并行架构开发并行程序，发挥GPU的并行计算能力。

     HDFS是Hadoop的文件系统。基于HDFS，你可以对文件进行操作，例如新建，删除，编辑，重命名等。

     Hbase: 基于Hadoop架构的数据库系统。不是关系型数据库，基于列的模式。

jsp和servlet

jsp经编译后就变成了Servlet.(JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)

JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

SQL

sql注入

mongodb和Redis

MongoDB更类似MySQL，支持字段索引、游标操作，其优势在于查询功能比较强大，擅长查询JSON数据，能存储海量数据，但是不支持事务。

Mysql在大数据量时效率显著下降，MongoDB更多时候作为关系数据库的一种替代。

内存管理机制

Redis数据全部存在内存，定期写入磁盘，当内存不够时，可以选择指定的LRU算法删除数据。

MongoDB数据存在内存，由Linux系统mmap实现，当内存不够时，只将热点数据放入内存，其他数据存在磁盘。

支持的数据结构

Redis支持的数据结构丰富，包括hash、set、list等。

MongoDB数据结构比较单一，但是支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富。

mongodb

SQL术语/概念MongoDB术语/概念解释/说明

databasedatabase数据库

tablecollection数据库表/集合

rowdocument数据记录行/文档

columnfield数据字段/域

indexindex索引

table joins表连接,MongoDB不支持

primary keyprimary key主键,MongoDB自动将_id字段设置为主键

iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

python优势和特点

多重继承

切片，迭代，列表生成式，生成器，函数式编程，匿名函数，装饰器，偏函数

__slots__

Python 是一门动态语言，可以在运行过程中，修改对象的属性和增删方法。任何类的实例对象包含一个字典__dict__, Python通过这个字典将任意属性绑定到对象上。有时候我们只想使用固定的对象，而不想任意绑定对象，这时候我们可以定义一个属性名称集合，只有在这个集合里的名称才可以绑定。__slots__就是完成这个功能的。