python乱七八糟

最新推荐文章于 2020-12-04 09:49:06 发布
落雪snowflake
最新推荐文章于 2020-12-04 09:49:06 发布
阅读量275
点赞数 1
分类专栏：求职笔试+面试
本文链接：https://blog.csdn.net/weixin_38858860/article/details/93530666
版权
求职笔试+面试专栏收录该内容
27 篇文章 0 订阅
订阅专栏
# .用Python匹配HTML g tag的时候，<.> 和 <.*?> 有什么区别
# 当重复匹配一个正则表达式时候， 例如<.*>, 当程序执行匹配的时候，会返回最大的匹配值
#
# 例如：

import re
s = ‘<html><head><title>Title</title>’
print(re.match(‘<.*>’, s).group())

# 会返回一个匹配<html><head><title>Title</title>而不是<html>
#
# 而

import re
s = ‘<html><head><title>Title</title>’
print(re.match(‘<.*?>’, s).group())

# 则会返回<html>
#
# <.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配
"""
编写一个程序，能在当前目录以及当前目录的所有子目录下查找文件名包含指定字符串的文件，并打印出绝对路径。
"""
import  os
from multiprocessing import  Process
import time

def pro_func(name,age,**kwargs):
    for i in range(5):
        print("子进程正在进行中，name=%s,age=%d,pid=%d"%(name,age,os,getpid()))
        print(kwargs)
        time.sleep(0.2)

if __name__=="__main__":
    #创建process对象
    p=Process(target=pro_func,args=('小明',18),kwargs={'m':20})
    #启动进程
    p.start()
    time.sleep(1)
    #1秒钟之后，立刻结束子进程
    p.terminate()
    p.join()
    """
    注意：进程间不共享全局变量

进程之间的通信-Queue

在初始化Queue()对象时（例如q=Queue(),若在括号中没有指定最大可接受的消息数量，获数量为负值时，那么就代表可接受的消息数量没有上限一直到内存尽头）

Queue.qsize():返回当前队列包含的消息数量

Queue.empty():如果队列为空，返回True，反之False

Queue.full():如果队列满了，返回True,反之False

Queue.get([block[,timeout]]):获取队列中的一条消息，然后将其从队列中移除，

block默认值为True。

如果block使用默认值，且没有设置timeout（单位秒),消息队列如果为空，此时程序将被阻塞（停在读中状态），直到消息队列读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出“Queue.Empty"异常：

Queue.get_nowait()相当于Queue.get(False)

Queue.put(item,[block[,timeout]]):将item消息写入队列，block默认值为True; 如果block使用默认值，且没有设置timeout（单位秒），消息队列如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息队列腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出”Queue.Full"异常 如果block值为False，消息队列如果没有空间可写入，则会立刻抛出"Queue.Full"异常; Queue.put_nowait(item):相当Queue.put(item,False)

进程间通信Demo:
    """
from multiprocessing import Process.Queue
import  os,time,random
#写数据进程执行的代码
def write(q):
    for value in ['A','B','C']:
        print("Put %s to queue....",%value)
        q.put(value)
        time.sleep(random.random)
#读数据进程执行的代码
def read(q):
    while True:
        if not q.empty():
            value =q.get(True)
            print("Get %s from queque.",%value)
            time.sleep(random.random)
if __name__=="__main__":
 #父进程创建Queue,并传给各个子进程
 q= Queue()
 pw=Process(target=write,args=(q,))
 pr=Process(target=read,args=(q,))
 #启动子进程pw，写入：
 pw.start()
 #等待pw结束
 pw.join()
 #启动子进程pr,读取：
 pr.start()
 pr.join()

 #pr进程里是死循环，无法等待其结束，只能强行终止：
 print('')
 print('所有数据都写入并且读完')
进程池Pool
#coding:utf-8
from multiprocessing import Pool
import os,time,random

def worker(msg):
    t_start = time.time()
    print("%s 开始执行，进程号为%d"%(msg,os.getpid()))
    # random.random()随机生成0-1之间的浮点数
    time.sleep(random.random()*2)
    t_stop = time.time()
    print(msg,"执行完毕，耗时%0.2f”%（t_stop-t_start))

po = Pool(3)#定义一个进程池，最大进程数3
for i in range(0,10):
    po.apply_async(worker,(i,))
print("---start----")
po.close()
po.join()
print("----end----")
# 进程池中使用Queue
#
# 如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue(),而不是multiprocessing.Queue(),否则会得到如下的错误信息：
#
# RuntimeError： Queue objects should only be shared between processs through inheritance
#
from multiprocessing import Manager,Pool
import os,time,random
def reader(q):
    print("reader 启动(%s）,父进程为(%s)"%(os.getpid(),os.getpgid()))
    for i in range(q.qsize()):
        print("reader 从Queue获取到消息:%s"%q.get(True))

def writer(q):
    print("writer 启动(%s),父进程(%s)"%(os.getpgid(),os.getpgid()))
    for i in i "itcast":
        q.put(i)


if __name__=="__main__":
    print("(%s)start"os.getpgid())
    q=Manager().Queue()
    po=Pool()
    po.apply_async(writer,(q,))
    time.sleep(1)
    po.apply_async(reader,(q,))
    po.close()
    po.join()
    print("(%s)End"%os.getpgid())

"""
07.谈谈你对多进程，多线程，以及协程的理解，项目是否用？
这个问题被问的概念相当之大， 进程：一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所有进程间数据不共享，开销大。

线程: cpu调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在，一个进程至少有一个线程，叫主线程，而多个线程共享内存（数据共享，共享全局变量),从而极大地提高了程序的运行效率。

协程: 是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操中栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快
108.Python异常使用场景有那些？
异步的使用场景:

1、 不涉及共享资源，获对共享资源只读，即非互斥操作

2、 没有时序上的严格关系

3、 不需要原子操作，或可以通过其他方式控制原子性

4、 常用于IO操作等耗时操作，因为比较影响客户体验和使用性能

5、 不影响主线程逻辑
09.多线程共同操作同一个数据互斥锁同步？
"""
import threading
import  time
class MyThread(threading.Thread):
    def run(self) :
        global num
        time.sleep(1)

        if mutex.acquire(1):
            num +=1
            msg =self.name+'set num to ' +str(num)
            print(msg)
            mutex.release()

num=0
mutex=threading.Lock()
def test():
    for i in range(5):
        t=MyThread()
        t.start()
if __name__ =="__main__":
  test()

"""
110.什么是多线程竞争？
线程是非独立的，同一个进程里线程是数据共享的，当各个线程访问数据资源时会出现竞争状态即：数据几乎同步会被多个线程占用，造成数据混乱，即所谓的线程不安全

那么怎么解决多线程竞争问题？---锁

锁的好处： 确保了某段关键代码（共享数据资源）只能由一个线程从头到尾完整地执行能解决多线程资源竞争下的原子操作问题。

锁的坏处： 阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了

锁的致命问题: 死锁

111.请介绍一下Python的线程同步？
一、 setDaemon(False) 当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行的最小单位，当设置多线程时，主线程会创建多个子线程，在Python中，默认情况下就是setDaemon(False),主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束。

例子
import threading 
import time

def thread():
    time.sleep(2)
    print('---子线程结束---')

def main():
    t1 = threading.Thread(target=thread)
    t1.start()
    print('---主线程--结束')

if __name__ =='__main__':
    main()
#执行结果
---主线程--结束
---子线程结束---
二、 setDaemon（True) 当我们使用setDaemon(True)时，这是子线程为守护线程，主线程一旦执行结束，则全部子线程被强制终止

例子

import threading
import time
def thread():
    time.sleep(2)
    print(’---子线程结束---')
def main():
    t1 = threading.Thread(target=thread)
    t1.setDaemon(True)#设置子线程守护主线程
    t1.start()
    print('---主线程结束---')

if __name__ =='__main__':
    main()
#执行结果
---主线程结束--- #只有主线程结束，子线程来不及执行就被强制结束
三、 join（线程同步) join 所完成的工作就是线程同步，即主线程任务结束以后，进入堵塞状态，一直等待所有的子线程结束以后，主线程再终止。

当设置守护线程时，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序，所以说，如果有10个子线程，全部的等待时间就是每个timeout的累加和，简单的来说，就是给每个子线程一个timeou的时间，让他去执行，时间一到，不管任务有没有完成，直接杀死。

没有设置守护线程时，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，子线程依然可以继续执行，直到子线程全部结束，程序退出。

例子
"""
import threading
import time

def thread():
    time.sleep(2)
    print('---子线程结束---')

def main():
    t1=threading.Thread(target=thread)
    t1.setDaemon(True)
    t1.start()
    t1.join(timeout=1)#1.线程同步，主线程堵塞1s 然后主线程结束，子线程继续执行
    #2 如果不设置timeout参数就等于子线程结束主线程再结属
    #3 如果设置了setDaemon=True和timeout=1线程等待1s后会强制杀死子线程，然后主线程结束
    print('---主线程结束---')


if __name__ == '__main___':
    main()
"""
12.解释以下什么是锁，有哪几种锁？
锁(Lock)是python提供的对线程控制的对象。有互斥锁，可重入锁，死锁。

113.什么是死锁？
若干子线程在系统资源竞争时，都在等待对方对某部分资源解除占用状态，结果是谁也不愿先解锁，互相干等着，程序无法执行下去，这就是死锁。

GIL锁 全局解释器锁

作用： 限制多线程同时执行，保证同一时间只有一个线程执行，所以cython里的多线程其实是伪多线程！

所以python里常常使用协程技术来代替多线程，协程是一种更轻量级的线程。

进程和线程的切换时由系统决定，而协程由我们程序员自己决定，而模块gevent下切换是遇到了耗时操作时才会切换

三者的关系：进程里有线程，线程里有协程。
114.多线程交互访问数据，如果访问到了就不访问了？
怎么避免重读？

创建一个已访问数据列表，用于存储已经访问过的数据，并加上互斥锁，在多线程访问数据的时候先查看数据是否在已访问的列表中，若已存在就直接跳过。

115.什么是线程安全，什么是互斥锁？
每个对象都对应于一个可称为’互斥锁‘的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

同一进程中的多线程之间是共享系统资源的，多个线程同时对一个对象进行操作，一个线程操作尚未结束，另一线程已经对其进行操作，导致最终结果出现错误，此时需要对被操作对象添加互斥锁，保证每个线程对该对象的操作都得到正确的结果。

116.说说下面几个概念：同步，异步，阻塞，非阻塞？
同步： 多个任务之间有先后顺序执行，一个执行完下个才能执行。

异步： 多个任务之间没有先后顺序，可以同时执行，有时候一个任务可能要在必要的时候获取另一个同时执行的任务的结果，这个就叫回调！

阻塞： 如果卡住了调用者，调用者不能继续往下执行，就是说调用者阻塞了。

非阻塞： 如果不会卡住，可以继续执行，就是说非阻塞的。

同步异步相对于多任务而言，阻塞非阻塞相对于代码执行而言。

117.什么是僵尸进程和孤儿进程？怎么避免僵尸进程？
孤儿进程： 父进程退出，子进程还在运行的这些子进程都是孤儿进程，孤儿进程将被init 进程（进程号为1）所收养，并由init 进程对他们完成状态收集工作。

僵尸进程： 进程使用fork 创建子进程，如果子进程退出，而父进程并没有调用wait 获waitpid 获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中的这些进程是僵尸进程。

避免僵尸进程的方法：

1.fork 两次用孙子进程去完成子进程的任务

2.用wait()函数使父进程阻塞

3.使用信号量，在signal handler 中调用waitpid,这样父进程不用阻塞
118.python中进程与线程的使用场景？
多进程适合在CPU密集操作（cpu操作指令比较多，如位多的的浮点运算）。

多线程适合在IO密性型操作（读写数据操作比多的的，比如爬虫）

119.线程是并发还是并行，进程是并发还是并行？
线程是并发，进程是并行;

进程之间互相独立，是系统分配资源的最小单位，同一个线程中的所有线程共享资源。

120.并行(parallel)和并发（concurrency)?
并行： 同一时刻多个任务同时在运行

不会在同一时刻同时运行，存在交替执行的情况。

实现并行的库有： multiprocessing

实现并发的库有: threading

程序需要执行较多的读写、请求和回复任务的需要大量的IO操作，IO密集型操作使用并发更好。

CPU运算量大的程序，使用并行会更好

121.IO密集型和CPU密集型区别？
IO密集型： 系统运行，大部分的状况是CPU在等 I/O（硬盘/内存）的读/写

CPU密集型： 大部分时间用来做计算，逻辑判断等CPU动作的程序称之CPU密集型。

122.python asyncio的原理？
asyncio这个库就是使用python的yield这个可以打断保存当前函数的上下文的机制， 封装好了selector 摆脱掉了复杂的回调关系

网络编程
123.怎么实现强行关闭客户端和服务器之间的连接?
--------------------- 
在socket通信过程中不算循环检测一个全局变量（开关标记变量），一旦标记变量变为关闭，则调用socket的close方法，循环结束，从而达到关闭连接的目的。
--------------------- 
124.简述TCP和UDP的区别以及优缺点?
--------------------- 
UDP是面向无连接的通讯协议，UDP数据包括目的端口号和源端口号信息。
优点：UDP速度快、操作简单、要求系统资源较少，由于通讯不需要连接，可以实现广播发送
缺点：UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数
据是否会正确接收，也不重复发送，不可靠。
                                                   
 
TCP是面向连接的通讯协议，通过三次握手建立连接，通讯完成时四次挥手
优点：TCP在数据传递时，有确认、窗口、重传、阻塞等控制机制，能保证数据正确性，较为可靠。
缺点：TCP相对于UDP速度慢一点，要求系统资源较多。
--------------------- 
125.简述浏览器通过WSGI请求动态资源的过程?
浏览器发送的请求被Nginx监听到，Nginx根据请求的URL的PATH或者后缀把请求静态资源的分发到静态资源的目录，
别的请求根据配置好的转发到相应端口。 实现了WSGI的程序会监听某个端口，监听到Nginx转发过来的请求接收后(
一般用socket的recv来接收HTTP的报文)以后把请求的报文封装成environ的字典对象，然后再提供一个start_response的方法。把这两个
对象当成参数传入某个方法比如wsgi_app(environ, start_response)或者实现了__call__(self, environ, start_response)方法的
某个实例。这个实例再调用start_response返回给实现了WSGI的中间件，再由中间件返回给Nginx。
126.描述用浏览器访问www.baidu.com的过程
--------------------- 
作者：TalkActor
链接：https://www.nowcoder.com/discuss/167480?type=0&order=0&pos=15&page=0
来源：牛客网

此处，浏览器——即“客户端”。

1、浏览器向DNS服务器发出解析域名的请求；
2、DNS服务器将域名解析为对应的IP地址，并返回给客户端；
3、浏览器与服务器建立TCP连接(默认端口为80)；
4、浏览器发出HTTP请求报文；
5、服务器回复HTTP响应报文；
6、浏览器解析响应报文，并显示在Web页上；
7、收发报文结束，释放TCP连接。

注意点：
1、HTTP请求报文在传输层被封装为TCP报文段；
2、TCP报文段在网络层被封装为IP数据包



HTTP请求报文在传输层被封装为TCP报文段——把HTTP会话请求分成报文段，添加源和目的端口；
TCP报文段在网络层被封装为IP数据包——然后使用IP层的IP地址查找目的主机；
客户端通过这个IP地址找到客户端到服务器的路径。

1.服务器使用80端口监听客户端的请求，客户端由系统随机选择一个端口如5000，与服务器进行交换数据。
 服务器把相应的请求返回给客户端的5000端口。。
2.客户端的网络层不用关心应用层或者传输层的东西，其主要工作是：通过查找路由表，来确定通过哪个路径到达目的主机。
3.客户端的链路层，包通过链路层发送到路由器，通过邻居协议查找给定IP地址的MAC地址，
然后发送ARP请求查找目的地址，如果得到回应后就可以使用ARP的请求应答交换的IP数据包现在就可以传输了，
然后发送IP数据包到达服务器的地址。



注意：
HTTP/1.0是短连接
HTTP/1.1是长连接，不会立马释放的，应该会等Connection:keepAlive时间过了才会释放掉TCP连接。

涉及到的协议
1、应用层：HTTP(WWW访问协议)，DNS(域名解析服务)
2、 传输层：TCP(为HTTP提供可靠的数据传输)，UDP(DNS使用UDP传输)
3、网络层：IP(IP数据数据包传输和路由选择)，ICMP(提供网络传输过程中的差错检测)，ARP(将目的主机的IP地址映射成MAC地址)

--------------------- 
127.Post和Get请求的区别?
--------------------- 
最直观的区别就是GET把参数包含在URL中，POST通过request body传递参数。
GET在浏览器回退时是无害的，而POST会再次提交请求。

 

GET产生的URL地址可以被Bookmark，而POST不可以。

 

GET请求会被浏览器主动cache，而POST不会，除非手动设置。

 

GET请求只能进行url编码，而POST支持多种编码方式。

 

GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。

 

GET请求在URL中传送的参数是有长度限制的，而POST么有。

 

对参数的数据类型，GET只接受ASCII字符，而POST没有限制。

 

GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。

 

GET参数通过URL传递，POST放在Request body中。
简单的说：

GET产生一个TCP数据包；POST产生两个TCP数据包。

 

长的说：

对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；

而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

--------------------- 
128.cookie 和session 的区别？
--------------------- 
cookie与session的区别有：cookie以文本格式存储在浏览器上，存储量有限；
而会话存储在服务端，可以无限量存储多个变量并且比cookie更安全
（1）Cookie以文本文件格式存储在浏览器中，而session存储在服务端它存储了限制数据量。它只允许4kb它没有在cookie中保存多个变量。

（2）cookie的存储限制了数据量，只允许4KB，而session是无限量的

（3）我们可以轻松访问cookie值但是我们无法轻松访问会话值，因此它更安全

（4）设置cookie时间可以使cookie过期。但是使用session-destory（），我们将会销毁会话。
cookie 和session 的区别：
1、cookie数据存放在客户的浏览器上，session数据放在服务器上。
2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗,考虑到安全应当使用session。
3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能,考虑到减轻服务器性能方面，应当使用COOKIE。

4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

 

cookie 和session 的联系：session是通过cookie来工作的session和cookie之间是通过$_COOKIE['PHPSESSID']来联系的
，通过$_COOKIE['PHPSESSID']可以知道session的id，从而获取到其他的信息
--------------------- 
129.列出你知道的HTTP协议的状态码，说出表示什么意思？
--------------------- 
一些常见的状态码为：
200 - 服务器成功返回网页
404 - 请求的网页不存在 
503 - 服务器超时 
下面提供 HTTP 状态码的完整列表。点击链接可了解详情。您也可以访问 HTTP 状态码上的 W3C 页获取更多信息。 
 1xx(临时响应) 表示临时响应并需要请求者继续执行操作的状态码。 
 100(继续)请求者应当继续提出请求。服务器返回此代码表示已收到请求的第一部分，正在等待其余部分。 
 101(切换协议)请求者已要求服务器切换协议，服务器已确认并准备切换。 
 2xx (成功) 表示成功处理了请求的状态码。 
 200(成功)服务器已成功处理了请求。通常，这表示服务器提供了请求的网页。如果是对您的 robots.txt 文件显示此状态码，
 则表示 Googlebot 已成功检索到该文件。 
 201(已创建)请求成功并且服务器创建了新的资源。 
 202(已接受)服务器已接受请求，但尚未处理。 
 203(非授权信息)服务器已成功处理了请求，但返回的信息可能来自另一来源。 
 204(无内容)服务器成功处理了请求，但没有返回任何内容。 
 205(重置内容)服务器成功处理了请求，但没有返回任何内容。与 204 响应不同，此响应要求请求者重置文档视图(例如，
 清除表单内容以输入新内容)。
 206(部分内容)服务器成功处理了部分 GET 请求。
 3xx (重定向) 要完成请求，需要进一步操作。通常，这些状态码用来重定向。Google建议您在每次请求中使用重定向不要超过 5 次。
 您可以使用网站管理员工具查看一下 Googlebot 在抓取重定向网页时是否遇到问题。诊断下的网络抓取页列出了由于
 
 重定向错误导致 Googlebot 无法抓取的网址。 300(多种选择)针对请求，服务器可执行多种操作。服务器可根据请求者 (user agent)
  选择一项操作，或提供操作列表供请求者选择。
 301(永久移动)请求的网页已永久移动到新位置。服务器返回此响应(对 GET 或 HEAD 请求的响应)时，会自动将请求者转到新位置。
 您应使用此代码告诉 Googlebot 某个网页或网站已永久移动到新位置。 
 302(临时移动)服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来响应以后的请求。
 此代码与响应 GET 和 HEAD 请求的 301 代码类似，会自动将请求者转到不同的位置，但您不应使用此代码来告诉 Googlebot 
 某个网页或网站已经移动，因为 Googlebot 会继续抓取原有位置并编制索引。 
 303(查看其他位置)请求者应当对不同的位置使用单独的 GET 请求来检索响应时，服务器返回此代码
 。对于除 HEAD 之外的所有请求，服务器会自动转到其他位置。 
 304(未修改)自从上次请求后，请求的网页未修改过。服务器返回此响应时，不会返回网页内容。
  如果网页自请求者上次请求后再也没有更改过，您应将服务器配置为返回此响应(称为 If-Modified-Since HTTP 标头)。
  服务器可以告诉 Googlebot 自从上次抓取后网页没有变更，进而节省带宽和开销。 
 305(使用代理)请求者只能使用代理访问请求的网页。如果服务器返回此响应，还表示请求者应使用代理。 
 307(临时重定向)服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来响应以后的请求。此代码与响应 GET 和 HEAD 请求的 301 代码类似，会自动将请求者转到不同的位置，但您不应使用此代码来告诉 Googlebot 某个页面或网站已经移动，因为 Googlebot 会继续抓取原有位置并编制索引。 
 4xx(请求错误) 这些状态码表示请求可能出错，妨碍了服务器的处理。 
 400(错误请求)服务器不理解请求的语法。 
 401(未授权)请求要求身份验证。对于登录后请求的网页，服务器可能返回此响应。 
 403(禁止)服务器拒绝请求。如果您在 Googlebot 尝试抓取您网站上的有效网页时看到此状态码(您可以在 Google 网站管理员工具诊断下的网络抓取页面上看到此信息)，可能是您的服务器或主机拒绝了 Googlebot 访问。 
 404(未找到)服务器找不到请求的网页。例如，对于服务器上不存在的网页经常会返回此代码。 如果您的网站上没有 robots.txt 文件，而您在 Google 网站管理员工具"诊断"标签的 robots.txt 页上看到此状态码，则这是正确的状态码。但是，如果您有 robots.txt 文件而又看到此状态码，则说明您的 robots.txt 文件可能命名错误或位于错误的位置(该文件应当位于顶级域，名为 robots.txt)。 如果对于 Googlebot 抓取的网址看到此状态码(在"诊断"标签的 HTTP 错误页面上)，则表示 Googlebot 跟随的可能是另一个页面的无效链接(是旧链接或输入有误的链接)。 
 405(方法禁用)禁用请求中指定的方法。 406(不接受)无法使用请求的内容特性响应请求的网页。
 407(需要代理授权)此状态码与 401(未授权)类似，但指定请求者应当授权使用代理。如果服务器返回此响应，还表示请求者应当使用代理。
 408(请求超时)服务器等候请求时发生超时。
 409(冲突)服务器在完成请求时发生冲突。服务器必须在响应中包含有关冲突的信息。服务器在响应与前一个请求相冲突的 PUT 请求时可能会返回此代码，以及两个请求的差异列表。 
 410(已删除)如果请求的资源已永久删除，服务器就会返回此响应。该代码与 404(未找到)代码类似，但在资源以前存在而现在不存在的情况下，有时会用来替代 404 代码。如果资源已永久移动，您应使用 301 指定资源的新位置。
 411(需要有效长度)服务器不接受不含有效内容长度标头字段的请求。 
 412(未满足前提条件)服务器未满足请求者在请求中设置的其中一个前提条件。 413(请求实体过大)服务器无法处理请求，因为请求实体过大，超出服务器的处理能力。 
 414(请求的 URI 过长)请求的 URI(通常为网址)过长，服务器无法处理。 415(不支持的媒体类型)请求的格式不受请求页面的支持。 
 416(请求范围不符合要求)如果页面无法提供请求的范围，则服务器会返回此状态码。
 417(未满足期望值)服务器未满足"期望"请求标头字段的要求。 
 5xx(服务器错误) 这些状态码表示服务器在处理请求时发生内部错误。这些错误可能是服务器本身的错误，而不是请求出错。
 500(服务器内部错误)服务器遇到错误，无法完成请求。 
 501(尚未实施)服务器不具备完成请求的功能。例如，服务器无法识别请求方法时可能会返回此代码。 
 502(错误网关)服务器作为网关或代理，从上游服务器收到无效响应。 
 503(服务不可用)服务器目前无法使用(由于超载或停机维护)。通常，这只是暂时状态。 
 504(网关超时)服务器作为网关或代理，但是没有及时从上游服务器收到请求。
--------------------- 
130.请简单说一下三次握手和四次挥手？
--------------------- 
置位概念：根据TCP的包头字段，存在三个重要的标识ACK SYN FIN

ACK:表示验证字段

SYN:位数置1，表示建立TCP连接

FIN:位数置1，表示断开TCP连接

1.TCP三次握手
TCP三次握手原理图如下图所示：

TCP三次握手与四次挥手

建立过程：

（1）数据包发起：由主机A发送建立TCP连接的请求报文，其中报文中包含seq序列号(seq=100)，是由发送端随机生成的，并且还将报文中SYN(SYN=1)字段置为1,表示需要建立TCP连接。

（2）数据包接收与确认数据连接：主机B接收到主机A的请求后会回复A发送的TCP连接请求报文，其中包含seq序列号，是由回复端随机生成的，并且将回复报文的SYN字段置为1，而且会产生ACK字段，ACK字段数值(ACK=seq+1=100+1)是建立在A发送过来的seq序列号基础上加1进行回复的，以便A收到信息是知道自己的TCP建立请求已得到了验证。

（3）回送确认数据包：主机A收到主机B发送的TCP建立验证请求后，会使自己的序列号在接收到ACK的数值上加1表示。这时主机A的seq的值是主机B的ack的值(seq=ACK=seq+1=101)，并且再次回复ACK验证请求(ACK=seq+1=301)，在B端发送过来的seq基础上加1(seq=ACK)，进行回复。

（4）取得最后确认：若一切都顺利，在服务器收到带有SYN=1且ack=301序号的数据包后，就能建立这次连接了。

2.TCP四次挥手
TCP四次挥手原理图如下图所示：

TCP三次握手与四次挥手

断开过程说明：

（1）主机A发送断开TCP连接请求的报文，其中报文中包含seq序列号，是有发送端随机生成的，并且还将报文中FIN字段的值设为1，表示需要断开TCP连接。

（2）主机B会回复A发送的TCP断开请求报文，其中包含seq序列号，是由恢复段随机生成的，而且会产生ACK字段，ACK字段的数值，是在A发送过来的seq序列号基础上加1进行回复的，以便A收到信息时，知晓自己的TCP断开请求已得到了验证。

（3）在主机B回复完A的TCP断开请求后，不会马上就进行TCP连接的断开，主机B先会确认确保断开前，所有传输到A的数据是否已经传输完毕，一旦确认传输完毕就会将回复报文的FIN字段置为1，并产生随机seq序列号。

（4）主机A收到主机B的TCP断开请求后，会回复主机B 的断开请求，包含随机生成的seq字段和ack字段，ack字段会在主机B的TCP断开请求的seq的基础上加1，从而完成主机B请求的验证回复。
--------------------- 
131.说一下什么是tcp的2MSL？
--------------------- 
MSL是Maximum Segment Lifetime英文的缩写，中文可以译为“报文最大生存时间”，他是任何报文在网络上存在的最长时间，超过这个时间报文将被丢弃。因为tcp报文（segment）是ip数据报（datagram）的数据部分，具体称谓请参见《数据在网络各层中的称呼》一文，而ip头中有一个TTL域，TTL是time to live的缩写，中文可以译为“生存时间”，这个生存时间是由源主机设置初始值但不是存的具体时间，而是存储了一个ip数据报可以经过的最大路由数，每经过一个处理他的路由器此值就减1，当此值为0则数据报将被丢弃，同时发送ICMP报文通知源主机。RFC 793中规定MSL为2分钟，实际应用中常用的是30秒，1分钟和2分钟等。

    2MSL即两倍的MSL，TCP的TIME_WAIT状态也称为2MSL等待状态，当TCP的一端发起主动关闭，在发出最后一个ACK包后，即第3次握手完成后发送了第四次握手的ACK包后就进入了TIME_WAIT状态，必须在此状态上停留两倍的MSL时间，等待2MSL时间主要目的是怕最后一个ACK包对方没收到，那么对方在超时后将重发第三次握手的FIN包，主动关闭端接到重发的FIN包后可以再发一个ACK应答包。在TIME_WAIT状态时两端的端口不能使用，要等到2MSL时间结束才可继续使用。当连接处于2MSL等待阶段时任何迟到的报文段都将被丢弃。不过在实际应用中可以通过设置SO_REUSEADDR选项达到不必等待2MSL时间结束再使用此端口。


    TTL与MSL是有关系的但不是简单的相等的关系，MSL要大于等于TTL。
--------------------- 
作者：xiaofei0859 
来源：CSDN 
原文：https://blog.csdn.net/xiaofei0859/article/details/6044694 
5. 为什么客户端在TIME-WAIT状态必须等待2MSL的时间？
2014年05月17日 10:38:50 谢小天1990 阅读数 1841
1）为了保证客户端发送的最后一个ACK报文段能够达到服务器。 这个ACK报文段可能丢失，因而使处在LAST-ACK状态的服务器收不到确认。服务器会超时重传FIN+ACK报文段，客户端就能在2MSL时间内收到这个重传的FIN+ACK报文段，接着客户端重传一次确认，重启计时器。最好，客户端和服务器都正常进入到CLOSED状态。如果客户端在TIME-WAIT状态不等待一段时间，而是再发送完ACK报文后立即释放连接，那么就无法收到服务器重传的FIN+ACK报文段，因而也不会再发送一次确认报文。这样，服务器就无法按照正常步骤进入CLOSED状态。
2）防止已失效的连接请求报文段出现在本连接中。客户端在发送完最后一个ACK确认报文段后，再经过时间2MSL，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。这样就可以使下一个新的连接中不会出现这种旧的连接请求报文段。
--------------------- 
132.为什么客户端在TIME-WAIT状态必须等待2MSL的时间？
---------------------
1）为了保证客户端发送的最后一个ACK报文段能够达到服务器。 这个ACK报文段可能丢失，因而使处在LAST-ACK状态的服务器收不到确认。服务器会超时重传FIN+ACK报文段，客户端就能在2MSL时间内收到这个重传的FIN+ACK报文段，接着客户端重传一次确认，重启计时器。最好，客户端和服务器都正常进入到CLOSED状态。如果客户端在TIME-WAIT状态不等待一段时间，而是再发送完ACK报文后立即释放连接，那么就无法收到服务器重传的FIN+ACK报文段，因而也不会再发送一次确认报文。这样，服务器就无法按照正常步骤进入CLOSED状态。
2）防止已失效的连接请求报文段出现在本连接中。客户端在发送完最后一个ACK确认报文段后，再经过时间2MSL，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。这样就可以使下一个新的连接中不会出现这种旧的连接请求报文段。
--------------------- 
作者：谢小天1990 
来源：CSDN 
原文：https://blog.csdn.net/xieyutian1990/article/details/26053411 
版权声明：本文为博主原创文章，转载请附上博文链接！
---------------------  
133.说说HTTP和HTTPS区别？
--------------------- 
TTP 协议传输的数据都是未加密的，也就是明文的，因此使用 HTTP 协议传输隐私信息非常不安
全，为了保证这些隐私数据能加密传输，于是网景公司设计了 SSL（Secure Sockets Layer）协议用于
对 HTTP 协议传输的数据进行加密，从而就诞生了 HTTPS。简单来说，HTTPS 协议是由 SSL+HTTP 协
议构建的可进行加密传输、身份认证的网络协议，要比 http 协议安全。
HTTPS 和 HTTP 的区别主要如下：
1、https 协议需要到 ca 申请证书，一般免费证书较少，因而需要一定费用。
2、http 是超文本传输协议，信息是明文传输，https 则是具有安全性的 ssl 加密传输协议。
3、http 和 https 使用的是完全不同的连接方式，用的端口也不一样，前者是 80，后者是 443。
4、http 的连接很简单，是无状态的；HTTPS 协议是由 SSL+HTTP 协议构建的可进行加密传输、身份认证的网络协议，比 http 协议安全。
--------------------- 
作者：读不懂的标题 
来源：CSDN 
原文：https://blog.csdn.net/weixin_43867210/article/details/88046175 
版权声明：本文为博主原创文章，转载请附上博文链接！
--------------------- 
134.谈一下HTTP协议以及协议头部中表示数据类型的字段？
--------------------- 
HTTP 协议是 Hyper Text Transfer Protocol（超文本传输协议）的缩写，是用于从万维网（WWW:World Wide Web）服务器传输超文本到本地浏览器的传送协议。

 HTTP 是一个基于 TCP/IP 通信协议来传递数据（HTML 文件， 图片文件， 查询结果等）。

 HTTP 是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。它于 1990 年提出，经过几年的使用与发展，得到不断地完善和扩展。目前在 WWW 中使用的是 HTTP/1.0 的第六版，HTTP/1.1 的规范化工作正在进行之中，而且 HTTP-NG(NextGeneration of HTTP)的建议已经提出。

 HTTP 协议工作于客户端-服务端架构为上。浏览器作为 HTTP 客户端通过 URL 向 HTTP 服务端即 WEB 服务器发送所有请求。Web 服务器根据接收到的请求后，向客户端发送响应信息。

 表示数据类型字段： Content-Type
--------------------- 
135.HTTP请求方法都有什么？
--------------------- 
根据 HTTP 标准，HTTP 请求可以使用多种请求方法。
HTTP1.0 定义了三种请求方法： GET， POST 和 HEAD 方法。
HTTP1.1 新增了五种请求方法：OPTIONS， PUT， DELETE， TRACE 和 CONNECT 方法。
1、GET 请求指定的页面信息，并返回实体主体。
2、HEAD 类似于 get 请求，只不过返回的响应中没有具体的内容，用于获取报头

 3、POST 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST 请求可能会导致新的资源的建立和/或已有资源的修改。
 4、PUT 从客户端向服务器传送的数据取代指定的文档的内容。
 5、DELETE请求服务器删除指定的页面。
 6、CONNECT HTTP/1.1 协议中预留给能够将连接改为管道方式的代理服务器。
 7、OPTIONS 允许客户端查看服务器的性能。
 8、TRACE 回显服务器收到的请求，主要用于测试或诊断。
--------------------- 

136.使用Socket套接字需要传入哪些参数 ？
--------------------- 
Address Family 和 Type，分别表示套接字应用场景和类型。
family 的值可以是 AF_UNIX(Unix 域，用于同一台机器上的进程间通讯)，也可以是 AF_INET（对于 IPV4 协议的TCP 和 UDP），
至于 type 参数，SOCK_STREAM（流套接字）或者SOCK_DGRAM（数据报文套接字）,SOCK_RAW（raw 套接字）。
--------------------- 

137.HTTP常见请求头？
--------------------- 
Host (主机和端口号)
Connection (链接类型)
Upgrade-Insecure-Requests (升级为 HTTPS 请求)
User-Agent (浏览器名称)
Accept (传输文件类型)
Referer (页面跳转处)
Accept-Encoding（文件编解码格式）
Cookie （Cookie）
x-requested-with :XMLHttpRequest (是 Ajax 异步请求)
--------------------- 
138.七层模型？
--------------------- 
IP： 网络层
TCP/UDP： 传输层
HTTP、RTSP、FTP： 应用层协议

形式： scheme://host[:port#]/path/…/[?query-string][#anchor]

scheme：协议(例如：http， https， ftp)

host：服务器的 IP 地址或者域名7.17 url 的形式？

port：服务器的端口（如果是走协议默认端口，80 or 443）

path：访问资源的路径

query-string：参数，发送给 http 服务器的数据

anchor：锚（跳转到网页的指定锚点位置）
--------------------- 
139.url的形式？
格式：（协议）：//（主机名）/（端口号）/（文件名）/（文件路径）

URL的访问方式有：1.ftp —— 文件传送协议 FTP2.http —— 超文本传送协议HTTP3.News —— USENET新闻
--------------------- 
形式 scheme://host[:port#]/path/.../[?query-string][#anchor]
scheme:协议（例如：http,https,ftp）

host:服务器的IP地址或者域名

port:服务器的端口（如果是走协议默认端口，80 or 443）

path:访问资源的路径

query-string:参数，发送给http服务器的数据

anchor:锚（跳转到网页指定锚点位置）



http://localhost:4000/file/part01/1.2.html

http://item.jd.com/11936238.html#product-detail



加不加锚点 响应内容都是一样的





HTTP请求的形式

请求方法   空格    URL    空格    协议版本    回车符     换行符      ---请求行

头部字段名 ： 值     回车符   换行符       ---请求头部

                          ......

头部字段名  ： 值     回车符   换行符 

    

回车符    换行符

                                                                   请求数据





HTTP常见请求头

1.HOST(主机和端口号)

2.Connection(链接类型)

3.Upgarde-Insecure-Requests(升级为HTTPS请求)

4.User-Agent（浏览器名称）    用户代理       浏览器的身份标识

5.Accept(传输文件类型)

6.Referer(页面跳转处)

7.Accept-Encoding(文件编解码格式)

8.Cookie (cookie)

9.x-requested-with: XML HttpRequest(是AJax异步请求)
--------------------- 
作者：shirley05lhz 
来源：CSDN 
原文：https://blog.csdn.net/shirley05lhz/article/details/78386604 
版权声明：本文为博主原创文章，转载请附上博文链接！
--------------------- 


"""
落雪snowflake
关注
1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
python乱七八糟

# .用Python匹配HTML g tag的时候，<.> 和 <.*?> 有什么区别# 当重复匹配一个正则表达式时候，例如<.*>, 当程序执行匹配的时候，会返回最大的匹配值## 例如：import res = ‘<html><head><title>Title</title>’print(re...
复制链接

扫一扫