运维工程师速成

一、处理问题：

你处理过的问题

二、Mysql 索引类型

Fulltext:针对全文检索，能够设置关键字或者分词，适用于like %%，对中文支持很差

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

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

RTree:范围查找比较好，在mysql中使用不多

http://www.cnblogs.com/yuan-shuai/p/3225417.html

三、Mysql innodb和myisam区别

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

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

三、对于AUTO_INCREMENT类型的字段，InnoDB中必须包含只有该字段的索引，可是在MyISAM表中，能够和其余字段一块儿创建联合索引。

四、DELETE FROM table时，InnoDB不会从新创建表，而是一行一行的删除。

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

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

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

八、Myisam数据和索引分开，innodb绑在一块儿没有压缩，因此innodb大

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

四、交换机端口类型

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端口

 

五、Vlan

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

Vlanif vlan的逻辑端口，为vlan下全部用户的网关

六、华为交换机配置路由

ip route-static 10.1.200.0 255.255.255.0 10.10.2.2

七、华为交换机配置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

https://wenku.baidu.com/view/c55b6a36ccbff121dc368315.html

验证

display ospf peer邻居

display ospf routing路由

https://wenku.baidu.com/view/c55b6a36ccbff121dc368315.html

八、TCP滑动窗口

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

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

九、TCP三次握手四次挥手

 

 

十、http请求过程

一、dns解析

二、TCP三次握手

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

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

五、浏览器解析

十一、http包请求头

 

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

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

Accept-Lanague   告诉服务器可以发送哪些语言

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

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

Host             用来标识请求服务器上的那个虚拟主机，好比Nginx里面能够定义不少个虚拟主机

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

User-Agent       用户代理，通常状况是浏览器，也有其余类型，如：wget curl 搜索引擎的蜘蛛等    

十二、响应头

 

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）

1三、http包结构

请求

 

相应

 

1四、Python变量

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

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

修改python字符串：

a = ‘12345’

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

或者

List转成数组

1五、Python staticmethod和classmethon

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

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

1六、调用父类的构造函数

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

1七、类变量和实例变量

Class A:

name = ‘1’

name_lsit = []

a = A()

b = A()

a.name = ‘2’#只改变他本身

a.name_list.append(1)#改变全部的

1八、python双下划线与单下划线

__foo__：python内部方法

_foo_:类私有变量

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

1九、Extend与append区别

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

20、Yield

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

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

2一、新式类和旧式类

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

2二、Select poll 和epoll:

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

这样主要有三个问题

一、 fd屡次拷贝开销大

二、 在内核中遍历全部fd开销大

三、 Select有文件上限

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

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

二、 epoll_ctl时为每一个fd注册一个回调函数，若是就绪了，就把本身加入到一个就绪链表，这样内核只要遍历就绪链表就能够了，不须要遍历全部

三、 没有上限，上限和系统同样

参考文献

http://www.cnblogs.com/Anker/p/3265058.html

2三、__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]

2四、单例模式

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/

2五、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/

 

 

算法

一、 判断单链表是否交叉

 

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

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

二、 二分查找

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)

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

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

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

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

四、 遍历二叉树

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)

 

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

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

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