操作系统
桌面
手机
服务器
嵌入式
ubuntu常用路径
/etc 系统配置文件
/bin 可执行二进制文件目录
/var 系统执行时经常变化的文件 如/var/log
ls pwd cd cp mv rm mkdir
touch clear > >> tree gedit more
| In cat grep find tar gzip
bzip2 zip unzip chomd sudo passwd exit
who reboot shutdown
FTP 文件传输协议 用于Internet上的控制文件的双向传输, 上传，下载
ssh 远程登录 >> ssh 用户名@IP
scp 远程文件下载或上传 >> 下载: scp 用户名@IP: 目标文件路径， 下载文件路径
scp [email protected]:/home/python/Desktop/zzt/aa.txt ./scp
#上传: scp 文件 用户名@IP: 目标文件路径
scp -r ./scp [email protected]:/home/python/Desktop/zzt
# 文件夹 -rvim 工作模式
编辑模式 <> 命令模式 <> 末行模式
udp 用户数据报协议
ip地址, A, B， C， D ,E 类 网络号加主机号
socket_udp = socket.socket(socket.AF_INET, socket.DETRAM)
.bind(('', 7788))
.sendto(data, (.., ..))
.recvfrom(1024)
tcp 传输控制协议
发送应答机制， 超时重传， 错误校验， 流量控制和阻塞管理
客户端
tcp_socket = socket(AF_INET, SOCK_STREAM)
.connect(('', 8080))
.send(data)
.recv(1024)
port重复使用
self.socket_tcp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
服务器端
tcp_socket.bind(('', 7788))
tcp_socket.listen(128)
client_socket, client_ip = tcp_socket.accept()
client_socket.close()
tcp_socket.close()
import sys
sys.argv
三次握手， 四次挥手
time.time()-time.time()
random.random()
多任务线程
使用
1种
threading
.Thread(target=function, args=(, ))
.setDaemon(True)
.enumerate()
.active_count()
.current_thread()
2种
类继承自threading.Thread
重写run()
同进程内的线程共享全局变量， 共同对一个全局变量操作， 可能会造成不正确
同步：同步就是协同步调，按预定的先后次序进行运行。
互斥锁
死锁， 银行家算法
多任务进程
进程定义
新建 就绪 堵塞/运行 死亡
multiprocessing
Process([group [, target [, name [, args [, kwargs]]]]])
.is_alive()
.terminate()
.join([timeout])：是否等待子进程执行结束，或等待多少秒
os.getpid()
进程线程对比
进程是系统进行资源分配和调度的一个独立单位.线程是进程的一个实体,是CPU调度和分派的基本单位它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高
进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
线线程不能够独立执行，必须依存在进程中
线程和进程在使用上各有优缺点
from multiprocessing import Queue
.put() .put_nowait(), .get() .get_nowait() .qsize() .empty() .full()
from multiprocessing import Pool
po = Pool(3)
for i in range(6):
po.apply_async(func_name, (i,))
po.close()
协程
迭代器Iterator
可以通过for.in.这类语句迭代读取一条数据供我们使用的对象称为可迭代对象（Iterable）
可迭代对象通过__iter__方法向我们提供一个迭代器
先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据.
具备了__iter__方法的对象，就是一个可迭代对象
iter()函数实际上就是调用了可迭代对象的__iter__方法。
next()
from collections import Iterator # 迭代器， 可迭代对象是Iterable
isinstance(iter([]), Iterator)
next()函数的时候，调用的就是迭代器对象的__next__方法
一个实现了__iter__方法(返回自身)和__next__方法的对象，就是迭代器。
def __next__(self):
if self.current < self.n:
num = self.num1
self.num1, self.num2 = self.num2, self.num1+self.num2
self.current += 1
return num
else:
raise StopIteration
def __iter__(self):
return self生成器
生成器是一类特殊的迭代器。
为了达到记录当前状态，并配合next()函数进行迭代使用
第一种方法很简单，只要把一个列表(列表推导式)生成式的 [ ] 改成 ( )
使用了yield的函数就是生成器
yield关键字
1/保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
2/将yield关键字后面表达式的值作为返回值返回
可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）
send()函数唤醒的一个好处是可以在唤醒的同时向断点处传入一个附加数据。
def fib(n):
current = 0
num1, num2 = 0, 1
while current < n:
num = num1
num1, num2 = num2, num1+num2
current += 1
yield num
return 'done' # 异常里面的value值会有
F = fib(5) F 为生成器对象， 和迭代器对象一样使用next(F)协程
在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定
协程的切换只是单纯的操作CPU的上下文
线程切换从系统层面远不止保存和恢复 CPU上下文，每个线程都有自己缓存Cache等等数据
1.yield
while True:
next(w1)
next(w2)
2.from greenlet import greenlet
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch() #切换到gr1中运行
3.gevent
def f(n):
for i in range(n):
print(gevent.getcurrent(), i)
#用来模拟一个耗时操作，注意不是time模块中的sleep
gevent.sleep(1)
g1 = gevent.spawn(f, 5)
g1.join()
gevent.joinall([
gevent.spawn(coroutine_work, "work1"),
gevent.spawn(coroutine_work, "work2")
])
正则表达式
re模块
"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$" //email地址 [email protected]