1、处理问题：

你处理过的问题

2、Mysql 索引类型

Fulltext:针对全文检索，可以设置关键字或者分词，适用于like %%，对中文支持不好

Hash:将一列或几列hash出一个值，将查询条件也hash，查看hash值相等的，取出硬盘上的地址，一次查找比btree效率高，但是只适用于=，不适用于范围查找，并且因为无法避免全表扫描，所以表大的时候效率不高，在内存数据库数据量小的情况下很好用

Btree:二叉树，折半查找，默认

RTree:范围查找比较好，在mysql中使用很少

3、Mysql innodb和myisam区别

1、InnoDB不支持FULLTEXT类型的索引。

2、InnoDB 中不保存表的具体行数，也就是说，执行select count(*) from table时，InnoDB要扫描一遍整个表来计算有多少行，但是MyISAM只要简单的读出保存好的行数即可。注意的是，当count(*)语句包含where条件时，两种表的操作是一样的。

3、对于AUTO_INCREMENT类型的字段，InnoDB中必须包含只有该字段的索引，但是在MyISAM表中，可以和其他字段一起建立联合索引。

4、DELETE FROM table时，InnoDB不会重新建立表，而是一行一行的删除。

5、LOAD TABLE FROM MASTER操作对InnoDB是不起作用的，解决方法是首先把InnoDB表改成MyISAM表，导入数据后再改成InnoDB表，但是对于使用的额外的InnoDB特性(例如外键)的表不适用。

6、两种类型最主要的差别就是Innodb 支持事务处理与外键和行级锁

7、只读不写的数据，myisam强于innodb

8、Myisam数据和索引分开，innodb绑在一起没有压缩，所以innodb大

9、Innodb非主键查询也锁全表

4、交换机端口类型

Access 只属于一个vlan连接PC

Trunk 属于多个vlan服务器之间

Hybrid 混合

接收

端口接收到的报文类型

报文帧结构中携带VLAN标记

报文帧结构中不携带VLAN标记

Access端口

丢弃该报文

为该报文打上VLAN标记为本端口的PVID

Trunk端口

判断本端口是否允许携带该VLAN标记的报文通过。如果允许则报文携带原有VLAN标记进行转发，否则丢弃该报文

同上

Hybrid端口

同上

同上

interface g 1/0/1

port link-type trunk

port trunk allow-pass vlan 2 to 4094

发送

Access端口

剥掉报文所携带的VLAN标记，进行转发

Trunk端口

首先判断报文所携带的VLAN标记是否和端口的PVID相等。如果相等，则剥掉报文所携带的VLAN标记，进行转发；否则报文将携带原有的VLAN标记进行转发

Hybrid端口

首先判断报文所携带的VLAN标记在本端口需要做怎样的处理。如果是untagged方式转发，则处理方式同Access端口；

如果是tagged方式转发，则处理方式同Trunk端口

5、Vlan

隔离二层网络，同一个vlan是同一个二层网络，vlan之间通过三层网络ip连接

Vlanif vlan的逻辑端口，为vlan下所有用户的网关

6、华为交换机配置路由

ip route-static 10.1.200.0 255.255.255.0 10.10.2.2

7、华为交换机配置OSPF

同一个网络里不同的ospf自治域，每个area有自己的id，不同area之间通过边缘交换机连接，这里例如area1和area1两个自治域，area0是两个核心交换机连接的地方，在

配置vlan

interface g 1/0/1

port hybrid pvid vlan 10

设置vlanif接口地址

interface vlanif 10

ip address 192.168.0.1 24

配置area

router id 1.1.1.1

ospf

area 0

network 192.168.0.0  0.0.0.255反掩码

quit

area 1

network 192.168.1.0  0.0.0.255

Quit

对端核心交换机上配置ospf

配置vlan

interface g 1/0/1

port hybrid pvid vlan 10

设置vlanif接口地址

interface vlanif 10

ip address 192.168.0.2.24

配置area

router id 2.2.2.2

ospf

area 0

network 192.168.0.0  0.0.0.255反掩码，宣告路由

quit

area 2

network 192.168.2.1  0.0.0.255

Quit

其他的边缘交换机

Routerid 3.3.3.3

Ospf

area 2

network 192.168.0.0  0.0.0.255反掩码

quit

验证

display ospf peer邻居

display ospf routing路由

8、TCP滑动窗口

发送缓冲区中一部分数据(窗口大小)，B接收后发送确认，再滑动窗口发送，以此类推

乱序的问题通过Sequence Number序号来解决

9、TCP三次握手四次挥手

10、http请求过程

1、dns解析

2、TCP三次握手

3、发送get或者post请求，包括http请求头

4、服务器相应http响应头，发送html

5、浏览器解析

11、http包请求头

Accept  就是告诉服务器端，我接受那些MIME类型

Accept-Encoding  这个看起来是接受那些压缩方式的文件

Accept-Lanague   告诉服务器能够发送哪些语言

Connection       告诉服务器支持keep-alive特性

Cookie           每次请求时都会携带上Cookie以方便服务器端识别是否是同一个客户端

Host             用来标识请求服务器上的那个虚拟主机，比如Nginx里面可以定义很多个虚拟主机

那这里就是用来标识要访问那个虚拟主机。

User-Agent       用户代理，一般情况是浏览器，也有其他类型，如：wget curl搜索引擎的蜘蛛等

12、响应头

Connection            使用keep-alive特性

Content-Encoding      使用gzip方式对资源压缩

Content-type          MIME类型为html类型，字符集是UTF-8

Date                  响应的日期

Server                使用的WEB服务器

Transfer-Encoding:chunked   分块传输编码 是http中的一种数据传输机制，允许HTTP由网页服务器发送给客户端应用(通常是网页浏览器)的数据可以分成多个部分，分块传输编码只在HTTP协议1.1版本(HTTP/1.1)中提供

Vary  这个可以参考(http://blog.csdn.NET/tenfyguo/article/details/5939000)

X-Pingback  参考(http://blog.sina.com.cn/s/blog_bb80041c0101fmfz.html)

13、http包结构

请求

相应

14、Python变量

Pyton变量是内存中一个对象的引用，可以视为是C语言的指针

String tunple numbers是不可更改的，list dict可以更改

修改python字符串：

a = ‘12345’

b = a[:1]+’3’+a[2:]

或者

List转成数组

15、Python staticmethod和classmethon

Classmethod参数有cls，是绑定的类，类对象和实例都可以调用，cls代表类对象，可以使用类变量，但是不能访问实例变量

Staticmethod，类对象和实例对象都可以调用

16、调用父类的构造函数

在子类的构造函数中使用 FOO.__init__(self)或者 super(Foo2,self).__init__()

17、类变量和实例变量

Class A:

name = ‘1’

name_lsit = []

a = A()

b = A()

a.name = ‘2’#只改变他自己

a.name_list.append(1)#改变所有的

18、python双下划线与单下划线

__foo__：python内部方法

_foo_:类私有变量

__foo:解析器替换为__classname__foo，以区别其他类

19、Extend与append区别

Extend只能接受列表，append什么都可以额，二者都只能接受一个参数

20、Yield

用在循环语句中，返回一个生成器。这个生成器只能被迭代一次

比如 在for语句中yield i，就是返回一个由每次的i组成的列表

21、新式类和旧式类

新式类在2.2引入，2.*中要显式的继承object，3.*中默认继承object。新式类相同父类只执行一次构造函数，旧式类多次，新式类搜索父类广度优先，旧式类深度优先

22、Select poll 和epoll:

Select 和poll差不多，都是先把fd_set或者pollfd从用户态拷贝到内核，然后__epoll_wait注册到内核等待队列中等待唤醒，唤醒后执行回调函数设置mask，select在内核中遍历fd列表，碰见有唤醒的就拷贝回用户空间

这样主要有三个问题

1、 fd多次拷贝开销大

2、 在内核中遍历所有fd开销大

3、 Select有文件上限

epoll提供了三个函数：epoll_create，epoll_ctl，epoll_wait，epoll_create创建一个epoll句柄；epoll_ctl注册要监听的事件类型，注册要监听的事件类型；epoll_wait等待返回。

1、 epoll_ctl注册时拷贝fd到内核，省的在epoll_wait中来回拷贝

2、 epoll_ctl时为每个fd注册一个回调函数，如果就绪了，就把自己加入到一个就绪链表，这样内核只要遍历就绪链表就可以了，不需要遍历所有

3、 没有上限，上限和系统一样

参考文献

23、__new__()实例

class LxmlDocument(object_ref):

cache = weakref.WeakKeyDictionary()

__slots__ = ['__weakref__']

def __new__(cls, response, parser=etree.HTMLParser):

cache = cls.cache.setdefault(response, {})

if parser not in cache:

obj = object_ref.__new__(cls)

cache[parser] = _factory(response, parser)

return cache[parser]

24、单例模式

Import天然是单例模式

New单例

class Singleton(object):

_instance = None

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

if not cls._instance:

cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)

return cls._instance

class MyClass(Singleton):

a = 1

http://python.jobbole.com/87294/

装饰器

2

3

4

5

6

7

8

9

10

11

12

13

14

from functools import wraps

def singleton(cls):

instances = {}

@wraps(cls)

def getinstance(*args, **kw):

if cls not in instances:

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

return instances[cls]

return getinstance

@singleton

class MyClass(object):

a = 1

http://python.jobbole.com/87294/

25、Awk

awk ‘BEGIN {awk-commands} /pattern/ {awk-commands} END {awk-commands}’ file

使用文件awk ‘……’ -f awkfile

Awk -v variable=value awk变量

--dump-variables = file 打印全局变量到文件

--lint treat error as warn

--profile = file 讲程序输入到文件中

{print $0}打印所有行

示例：

统计行数：

awk ‘/a/ {++cnt} END {print “Count = “,cnt}’ file

awk 'BEGIN{FS=" "} /Phys/{print $3 }' marks.txt

內建变量：

ARGC 命令行参数个数

ARGV命令行参数数组

CONVFMT 数字的约定模式

ENVIORON 环境变量数组

FILENAME 当前文件名

FS 分隔符

NF 字段数目

NR 行数

FNR 处理多文件时相对当前文件的行号

OFMT 输出格式数字

OFS 输出字符分隔符

ORS 输出行分隔符

RLENGTH 匹配字符串长度

RS 输入字符分隔符

RSTART match第一次匹配的位置

数据结构：

数组：

array_name[index] = value

创建数组的方式非常简单，直接为变量赋值即可

删除使用delete

流程控制：

If(condition)command;else command

for(initialisation;condition;increment/decrement)action

while(condition)action

do action while(condition)

內建函数：

数学函数

atan2(y, x)

cos(expr)

exp(expr)

int(expr)

log(expr)

rand

sin(expr)

sqrt(expr)

srand([expr])

字符串函数

asort(arr [, d [, how] ])

asorti(arr [, d [, how] ])

gsub(regex, sub, string)

index(str, sub)

length(str)

match(str, regex)

split(str, arr, regex)

sprintf(format, expr-list)

strtonum(str)

sub(regex, sub, string)

substr(str, start, l)

tolower(str)

toupper(str)

时间函数

systime

mktime(datespec)

strftime([format [, timestamp[, utc-flag]]])

字节操作函数

and

compl

lshift

rshift

or

Xor

参考文献：

http://blog.jobbole.com/109089/

算法

1、 判断单链表是否交叉

判断是否交叉：两个链表分别遍历到底，看底部是否相等

判断是交叉点：长链表减去短链表之后的位置开始同时遍历两边，查看是否有相等的地方，，相等的地方就是交叉点

2、 二分查找

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

def binarySearch(l, t):

low, high = 0, len(l) - 1

while low < high:

print low, high

mid = (low + high) / 2

if l[mid] > t:

high = mid

elif l[mid] < t:

low = mid + 1

else:

return mid

return low if l[low] == t else False

if __name__ == '__main__':

l = [1, 4, 12, 45, 66, 99, 120, 444]

print binarySearch(l, 12)

print binarySearch(l, 1)

print binarySearch(l, 13)

print binarySearch(l, 444)

3、 如何判断链表是否有环

设置两个指针，一个slow，一个fast，slow每次前进一，fast每次前进二，如果slow碰上fast就是有环

环的长度：记录下slow和fast的碰撞点P，下次相撞前走过的路程l就是环长

连接点位置：分别从碰撞点和头指针开始走，相撞的地方就是连接点，因为你碰撞点p到连接点对的距离等于头指针到连接点的距离

4、 遍历二叉树

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

## 14 二叉树节点

class Node(object):

def __init__(self, data, left=None, right=None):

self.data = data

self.left = left

self.right = right

tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))

## 15 层次遍历

def lookup(root):

stack = [root]

while stack:

current = stack.pop(0)

print current.data

if current.left:

stack.append(current.left)

if current.right:

stack.append(current.right)

## 16 深度遍历

def deep(root):

if not root:

return

print root.data

deep(root.left)

deep(root.right)

前序遍历：左子树-根-右子树

中序遍历：根-左子树-右子树

后序遍历：右子树-根-左子树