网络编程笔记

1------------------------------------

'localhost' '127.0.0.1'　只在本地测试使用　
 '0.0.0.0'　 '' 　'本机IP'　如果想咋网络上进行测试
查看IP网络信息
linux   ifconfig
win     ipconfig       

获取计算机名称
In [2]: socket.gethostname()
Out[2]: 'tedu'

获取主机IP
In [5]: socket.gethostbyname('localhost')
Out[5]: '127.0.0.1'

特殊IP
127.0.0.1 本地测试IP　　(本地计算机测试用)
0.0.0.0 本地网卡通用IP　　　(局域网内)
192.168.1.0  表示当前网段　　(192.168.1.0 ~ 1)
192.168.1.1  表示网关　　　　　(路由器)
192.168.1.255  广播地址

获取服务主机信息
In [7]: socket.gethostbyaddr("www.baidu.com")
Out[7]: ('127.0.0.1', [],   ['119.75.213.61'])
          主机        别名   IP地址

将ip十进制转化为二进制
In [12]: socket.inet_aton("192.168.1.2")
Out[12]: b'\xc0\xa8\x01\x02'

将ip二进制转化为十进制
In [11]: socket.inet_ntoa(b"\xc0\xa8\x01\x02")
Out[11]: '192.168.1.2'

TCP
服务端
socket.socket(socket_family = AF_INET,
              socket_type = SOCK_STREAM,
              proto = 0)  创建套接字

sockfd.bind()  绑定IP端口
sockfd.listen(n)  将套接字设置为监听套接字，并设置监听队列
connfd,addr = sockfd.accept() 等待客户端的连接
data = connfd.recv(buffersize)  接收消息
n = connfd.send(data)   发送消息
closs()  关闭套接字

客户端
socket() 创建套接字
connect()  发起连接
send recv  发收消息
close()  关闭套接字

2-------------------------------------------------------

基于udp的通信
服务端
sockfd = socket(AF_INET,SOCK_DGRAM) 创建套接字　--->> 数据报套接字
sockfd.bind()  绑定服务端地址
data,addr = recvfrom(buffersize)  接受udp消息 (addr发送者的地址)
sendto(data,addr)  发送消息  (addr 目标地址)
sockfd.close()  关闭套接字

客户端
１．创建套接字
２．消息收发
３．关闭套接字

sys.argv　获取命令行的参数，形成一个列表
sendall()　同send()发送成功返回None,失败返回异常
s.type : 获取套接字类型
s.family:获取地址族类型
s.fileno():获取套接字的文件描述符
s.getsockname():获取套接字绑定地址
s.getpeername():获取连接套接字另一端的地址
s.setsockopt(level,optname,value):设置套接字选项　丰富修改原有套接字功能
参数：lever : 获取选项的类型
    　optname:每个选项类型中的子选项
     value:为选项设置值
s.setsockopt(SOL_SOCKET,SO_BROADCAST,1)

format():合成字符串

3----------------------------------------------------

s.setblocking()　设置套接字的阻塞状态　False为非阻塞
s.settimeout(sec)　　设置套接字超时时间

r,w,x = select(rlist,wlist,xlist[,timeout])
功能：监控IO事件，阻塞等待IO事件发生
参数：rlist     列表　　　存放被动等待处理的IO事件
     wlist　　　　　列表　　　存放需要主动处理的IO
     xlist　　　　　列表　　　存入如果发生异常需要处理的IO
     timeout　　　超时时间

位运算

按照二进制位来进行位运算操作

& 按位与
| 按位或
^ 按位异或
<< 左移
>> 右移

11   1011
14   1110
11 & 14 --> 10
11 | 14 --> 15
11 ^ 14 --> 5
11 << 2 --> 44
14 >> 2 --> 3

4------------------------

p = poll()  创建poll对象

poll IO事件分类
POLLIN  POLLOUT  POLLERR  POLLHUP  POLLPRI  POLLVAL
 rlist    wlist   xlist   断开连接　　　紧急处理　　　无效

p.register(s,POLLIN　| POLLERR) 　　　关注ＩＯ事件
p.unregister(s)  取消对IO的关注

events = p.poll()  监控关注的IO，阻塞等待IO发生
返回值：events是一个列表，列表中每个元素为一个元组，代表准备就绪的IO
events --> [(fileno,　　　　　　　　　　　event),(),()]
             就绪IO的fileno  哪个事件就绪
fdmap = {s.fileno():s}　#建立通过fileno查找IO对象的字典

epoll  使用方法：　与poll基本相同

本地套接字
linux 下文件类型
b（块设备文件） c（字符设备文件） d（目录）
-（普通文件） l（链接文件） s（套接字文件） p（管道文件）

本地套接字创建流程：
sockfd = socket（AF_UNIX,SOCK_STREAM）创建套接字对象
sockfd.bind(path) 绑定本地套接字文件 path : 一个文件
监听
接收发送消息

os.path.exists(path)
功能：判断一个文件夹下是否有某个文件
参数： 文件位置
返回值： 存在返回True  否则返回False

os.unlink()   os.remove()
功能：删除一个文件
参数：要删除的文件

In [2]: os.path.exists("./re")
Out[2]: True

In [3]: os.unlink("./re")

进程信息查看命令：　ps -aux

查看进程树：　pstree
查看父进程PID: ps -ajx

pid = os.fork() 创建一个新的进程

5--------------------------------------------

os.getpid():获取当前进程的PID号
os.getppid() 获取父进程的PID号
os._exit(status) 退出进程
sys.exit([status]) 退出时打印括号中内容

pid,status = os.wait()
功能：在父进程中阻塞等待处理子进程的退出
返回值：pid　退出的子进程的PID号
    　　　status  子进程的退出状态

pid,status = os.waitpid(pid,option)
功能：同wait
参数：pid  -1  表示任意子进程退出
        　　　>0  整数　　指定PID号的子进程退出
     option  0  表示阻塞等待
        　　 　WNOHANG　表示非阻塞
waitpid(-1,0)  ====  wait()

process() 创建进程对象
参数：name : 给创建的进程对象起一个名字
            默认process-1
      target : 绑定的函数
      args : 元组　给target函数按照位置传参
      kwargs : 字典　给target函数按照键值出传参

p.start() 启动进程
p.join([timeout])阻塞等待回收响应的进程 参数：超时时间

6----------------------------------------------------

p.is_alive() 判断进程生命周期状态　返回True False
p.name 进程名称　默认为Process-1 如果起名字则为自定义名称
p.pid  创建的进程的PID
p.daemon  默认值为False父进程退出不会影响子进程运行
          如果设置为True 则父进程退出子进程也会退出

pool = Pool(processes)
功能：创建进程池对象
参数：表示进程池中有多少进程

pool.apply_async(func,args,kwds) 将事件放入进程池队列
r = pool.apply_async(func = worker,args = (msg,))
返回事件对象  通过get()获取返回值
print(r.get())

pool.closs() 关闭进程池
pool.join() 阻塞等待回收进程池

pool.map(func,iter)
功能：将要完成的事件放入进程池
参数：func要完成的事件函数
    　iter可迭代对象给func传参
返回值：事件函数的返回值列表

os.path.getsize(path) 获取一个文件的大小

fd1,fd2 = Pipe(duplex = True)
功能：创建一个管道
参数：默认为双向管道
     如果设置为False　则为单向管道
返回值：如果双向管道，fd1 fd2都可以进行读写操作
    　　　如果是单向管道，则fd1 只可读，fd2只可写

fd.recv()  从管道读取内容 如果管道无内容则阻塞
fd.send()  向管道写入内容

创建队列
q = Queue(maxsize = 0)
功能：创建队列
参数：maxsize 默认表示根据系统分配空间存储消息
    如果传入一个正整数则表示最多存放多少条消息
返回：队列对象

q.put(data,[block,timeout])
功能：存放消息
参数：data 存入的消息(python数据类型)
    　block 默认为True表示当队列满的时候阻塞
    　设置为False则表示非阻塞
    timeout 当block为True表示超时时间

data = q.get([block,timeout])
功能：取出消息
参数：block 默认为True 当队列空时阻塞
    　　　　　　　设置为False表示非阻塞
    　timeout 当block为True时表示超时时间
返回值：返回获取到的消息

q.full() 判断队列是否为满
q.empty() 判断队列是否为空
q.qsize() 判断当前队列有多少消息
q.close() 关闭队列

obj = Value(ctype,obj)
功能：开辟共享内存空间
参数：ctype 字符串　　要转变的c的数据类型
                　　对比类型对照表
    obj 共享内存的初始化数据
返回：共享内存对象

obj.value 表示共享内存中的值，对其修改或者使用即可

obj = Array(ctype,obj)
功能：开辟共享内存
参数：ctype 要转化的c的类型
    　obj 要存入共享内存的数据
        　列表　　将列表存入共享内存，数据类型一致
    　正整数　　表示开辟几个数据空间

7----------------------------------------

kill -l 查看信号
kill -signum PID  给PID的进程发送一个信号

SIGHUP  　　　终端断开
SIGINT　　　　　ctrl + c
SIGQUTT    ctrl + \
SIGTSTP    ctrl + z
SIGKILL    终止进程且不能被处理
SIGSTOP　　　　暂停进程且不能被处理
SIGALRM　　　　时钟信号
SIGCHLD　　　　子进程状态改变发给父进程

os.kill(pid,sig) 发送信号给某个进程
signal.alarm(sec) 一定时间后给自身发送一个SIGALRM信号
signal.pause()  阻塞等待一个信号的发生

signal.signal(signum,handler) 处理信号
参数：signum 要处理的信号
    　handler 信号的处理方法
        SIG_DFL 表示使用默认的方法处理
        SIG_IGN 表示忽略这个信号
        func  自定义函数处理信号
            def func(sig,frame):
                pass
            sig 表示要处理的信号
            frame 信号的结构对象

sem = Semaphore(num)  生成信号量对象 num是初始值
sem.acquire() 信号量数量减1　信号量为0时会阻塞
sem.release() 信号量数量加1
sem.get_value() 获取当前信号量的值

Event 事件
multiprocessing --> Event

e = Event()创建事件对象
e.wait([timeout])事件阻塞
e.set()事件设置　当e被set()后e.wait()不再阻塞
e.clear()事件清除　当e被clear()后e.wait()又会阻塞
e.is_set()事件判断 判断当前事件对象是否被设置

锁
创建对象
lock = Lock()
lock.acquire() 上锁
lock.release() 解锁

线程
threading.Thread()
功能：创建线程对象
参数：name 线程名称
    　target 线程函数
    　args 元组　给线程函数传参
    　kwargs 字典　给线程函数传参

t.start() 启动线程
t.join([timeout]) 回收线程
t.is_alive() 查看线程状态
t.name 线程名称
t.setName() 设置线程名称
threading.currentThread() 获取当前线程对象
t.isDaemon()　判断daemon属性
t.daemon　默认下，主线结束不影响分线,如设置为True则主线程退出分线也退出
设置方法
t.daemon = True
t.setDaemon(True)

8和9--------------------------------------------------------------

线程的Event事件
e = threading.Event()
e.wait([timeout]) 如果e为设置状态则不阻塞，未设置则阻塞
e.set()  将e变为设置状态
e.clear() 将e设置去除

线程锁
lock = threading.Lock() 创建锁
lock.acquire()  上锁
lock.release()  解锁

os.listdir(PATH) 获取文件夹下的所有列表
os.path.isfile()  判断一个文件的类型是否为普通文件
os.path.isdir()　　判断一个文件的类型是否为目录