正文 

当前位置： 首页 > 知识 > java教程

python网络编程（基础总结入门经典）

parisgabriel parisgabriel     2022-12-23     139

关键词：

Linux下文件类型：
    bcd -lsp
         b（块、设备文件）
         c（字符设备文件）
         d（目录）
         -（普通文件）
         l（链接文件）
         s（套接字文件）
         p（管道文件）
    kill -sig pid：通过pid发送信号杀死指定进程
    kill -l：查看操作系统内所所有sig信号
    ps -aux ---> STAT表示进程状态
    信号：
        SIGHUP   断开链接
    SIGINT   Ctrl + c
    SIGQUIT  Ctrl +
    SIGTSTP  Ctrl + z
    SIGKILL  终止进程且不能被处理
    SIGSTOP  暂停进程且不能被处理
    SIGALRM  时钟信号
    SIGCHLD  子进程改变状态时父进程会收到此信号
 
 
OSI七层模型 -----> 网络通信的标准化流程
 
    应用层： 提供用户服务，具体的内容由特定的程序规定
    表示层： 提供数据的加密和压缩优化
    会话层： 确定建立应用链接，选择传输服务
    传输层： 提供数据传输服务，进行流量控制
    网络层： 路由选着，网络互联
    链路层： 提供链路交换，具体消息的发送
    物理层： 物理硬件，接口，网卡的规定
网络协议：
应用层：TFTP（文件传输）、HTTP（超文本传输协议）、DNS（域名解析）、SMTP（邮件传输）
传输层：TCP、UDP
网络层：IP
物理层：IEEE
IP地址
本地使用：127.0.0.1 或 “localhost”
网络地址：“0.0.0.0” 或 “172.168.40.53”
IPv4： 点分十进制   例如：192.168.1.3   取值0~255（32位）
IPv6： 128位
 
 
socket模块：
    ifconfig：查看本机IP （ens33：本地IP  lo：本地回还）
    ipconfig：windoes中
    socket.gethostname() ：                                       获取本机主机名
    socket.gethostbyname(‘tedu‘) ：                           利用主机名获取ip
    socket.gethostbyname(‘localhost‘)：                     获取本地ip
    socket.gethostbyaddr(‘127.0.0.1‘)                         访问主机IP地址
    socket.inet_aton(‘192.168.1.2‘)                             IP十六进制转换
    socket.inet_ntoa(b‘xc0xa8x012‘)                     IP十进制转换
    socket.getservbyname(‘ssh‘)                                 获取应用程序的端口
创建TCP服务端套接字：
sockfd.socket（sock_family = AF_INET,
               sock_tpye = SOCK_STREAM,
               proto = 0）
    sockfd.bind（addr）                                              绑定地址
    sockfd.listen(n)                                                      设置监听套接字
  connfd，addr = sockfd.accept（）                         等待接受客户端链接
  data = connfd.recv（buffersize）                           接收消息
  connfd.send（data）                                              发送消息
  sockfd.close（）                                                     关闭套接字
创建TCP客户端套接字：
sockfd.socket（sock_family = AF_INET,
               sock_tpye = SOCK_STREAM,
               proto = 0）
    sockfd.bind（addr）                                             绑定地址
  sockfd.connect（addr）                                         链接服务端
  data = connfd.recv（buffersize）                           接收消息
  connfd.send（data） 发送消息
  sockfd.close（） 关闭套接字
 
 
创建UDP客户端套接字：
  sockfd.socket（sock_family = AF_INET,
               sock_tpye = SOCK_DGRAM,
               proto = 0）
    sockfd.bind（addr）                                            绑定地址
  data = sockfd.recvfrom（buffersize）                   接收消息
  sockfd.sendto（data, addr）                                发送消息
  sockfd.close（）                                                   关闭套接字
创建UDP客户端套接字：
  sockfd.socket（sock_family = AF_INET,
               sock_tpye = SOCK_DGRAM,
               proto = 0）
  data = sockfd.recvfrom（buffersize）                   接收消息
  sockfd.sendto（data, addr）                                发送消息
  sockfd.close（）                                                  关闭套接字
 
创建本地套接字服务端：
  sockfd = socket（AF_UNIX, SOCK_STREAM） 
  sockfd.bind（file）                                                绑定套接字文件
  sockfd.listen(3)                                                      监听
  connfd,addr = sockfd.accept()                               等待链接
  connfd.recv(buffersize)                                          接收消息
  connfd.send(data)                                                 发送消息
  sockfd.close()                                                        关闭套接字
创建本地套接字客户端：
  sockfd = socket（AF_UNIX, SOCK_STREAM） 
  sockfd.connect(sock_file)                                     链接服务端
  connfd.recv(buffersize)                                         接收消息
  connfd.send(data)                                                 发送消息
  sockfd.close()                                                        关闭套接字
 
 
 
套接字属性：
  sockfd.type                                                              返回套接字类型
  sockfd.family                                                           返回地址类型
套接字方法：
  sockfd.fileno（）                                                     获取套接字的文件描述符
  sockfd.getsockname（）                                         获取套结字绑定的地址
  sockfd.getpeername（）                                        获取链接套接字客户端的地址
  sockfd.setsockopt（level，optname， value）      设置端口可立即重用
  sockfd.setblocking(False)                                       将套接字设置为非阻塞状态
  sockfd.settimeout（sec）                                       设置套接字的超时时间
 
select模块：                                                            IO多路复用，阻塞等待监控的IO事件发生
rs， ws， xs = select（rlist，                                   等待处理的IO
                                     wlist                                     想要主动处理的IO
                                     xlist[，                                 出错希望去处理的IO
                                     timeout]）                            超时检测
p = select.poll                                                          创建poll对象
p.register(s， POLLIN | PLLERR)                           注册关注的IO
events = p.poll（）                                                   监控关注的IO事件
 
multiprocessing模块：                                            创建进程对象
Process(target，                                                       要绑定的函数
               name，                                                        给进程起的名称
               args，                                                         元组给target函数位置传参
               kwargs)                                                       字典给target函数键值传参
p.start()                                                                     启动进程terget绑定函数
p.join([timeout])                                                         阻塞等待子进程退出
p.name                                                                       获取进程名（属性）
p.daemon                                                                  设置为True主进程结束杀死所有子进程（必须start（）前设置）
p.is_alive()                                                                 判断进程是处于alive状态（存活）
p.pid                                                                          获取创建进程的pid号（属性）
 
pool = pool（x）                                                       创建进程池对象（进程池大小）
pool.apply_async(fun,                                               要执行的函数(异步执行)
                             args,                                             以元组形式为fun传参
                             kwds)                                            以字典形式为fun传参
pool.apply(fun, args, kwds)                                       (同步执行)
r = pool.map(fun,range(6))                                         将要执行的事件放入进程池
pool.close()                                                                关闭进程池
pool.join()                                                                    回收进程池
 
fd1，fd2 = Pipe(duplex=True)                                    创建管道（Flase：fd1只读，fd2只写）
fd.recv（）                                                                  从管道读取信息空则阻塞
fd.send（data）                                                          向管道写入内容满则阻塞
 
q = Queue（maxsize=0）                                            创建队列对象（存放多少条消息）
q.put（data,                                                                   存入消息（支持Python数据类型）
           [block,                                                                默认阻塞 False：非阻塞
           timeout]）                                                          block为True是表示超时检测
data = q.get([block,timeout])                                         取出消息
q.full（）                                                                       判断队列是否为满
q.empty()                                                                      判断队列是否为空
q.qsize()                                                                       获取队列中消息的数量
q.close()                                                                        关闭队列
 
shm = Value（ctype，                                                  创建共享内存共享空间
                        obj）                                                       ctype字符串：（C语言数据类型），obj初始数据
shm.value                                                                       表示共享内存的值（可以赋值）
shm = Array（ctype，obj）                                          创建共享内存共享空间
 
sem = Semaphore（num）                                          创建信号量
sem.acquire（）                                                            将信号量减1  0时阻塞
sem.release（）                                                            将信号量加1
sem.get_value（）                                                         获取当前信号量的值（数量）
 
e = Event（）                                                                创建Event事件对象
e.wait（[timeout]）                                                         阻塞进程 直到事件对象被set
e.set.()                                                                            让事件对象变为被设置状态
e.clear（）                                                                     使事件对象清除设置状态
e.is_set（）                                                                    判断当前事件是否被set
 
Lock = Lock（）                                                            创建锁对象
lock.acquire（）                                                            上锁
lock.release()                                                                 解锁
 
threading 模块：                                                            创建线程对象
threshold.Thread（target，                                            线程函数
                               name,                                                线程名字
                                args,                                                元组给线程函数位置传参
                                kwargs）                                         字典给线程函数位置传参
t.start（）                                                                       启动线程
t.join（）                                                                         回收线程
t.name                                                                              线程名
t.daemon = True                                                            主线程退出分支线程也退出
t.setDaemon(True)                                                       主线程退出分支线程也退出
t.isDaemon                                                                    查看daemon值
t.setName（“name”）                                                   设置线程名称
t.is_alive（）                                                                 查看线程状态
threading.currentThread()                                              获取当前进程对象
 
e = threading.Event()                                                    创建Event事件对象
e.wait([timeout])                                                             事件阻塞
e.set（）                                                                       设置事件
e.clear（）                                                                    清除事件
 
lock = threading.Lock（）                                            创建锁对象
lock.acquire() 上锁
lock.release() 解锁
 
 
socketserver集成并发模块：
StreamRequestHandler                                                处理tcp请求
DatagramRequestHandler                                            处理udp请求
 
ForkingMixIn                                                                  创建多进程
ThreadingMixIn                                                             创建多线程
 
TCPServer                                                                   创建tcp  server
UDPServer                                                                  创建udp  server
 
ForkingTCPServer                                                        ForkingMixIn  +  TCPServer 
ForkingUDPServer                                                      ForkingMixIn  +  UDPServer 
ThreadingTCPServer                                                    ThreadingMixIn  +  TCPServer 
ThreadingUDPServer                                                    ThreadingMixIn  +  UDPServer 
 
 
 
signal模块：
signal.alarm（sec）                                                       设置时钟信号给自己SIGALRM信号
signal.pause（）                                                           阻塞进程，等待一个信号
signal.signal（sig，                                                      要处理的信号
                        handler）                                               处理方法（SIG_DFL：默认 SIG_IGN：忽略 func：自定义函数）
 
 
sys模块补充：
    sys.argv                              获取从命令行获取的参数内容列表
    sys.stdin      0                     标准输入IO文件描述符
    sys.stdout   1                      标准输出IO文件描述符
    sys.stderr   2                      错误IO文件描述符
    sys.exit（[status]）            退出一个进程（状态：退出提示字符串）
字符串方法补充：
    S.splitlines                          按行分隔
 
os模块补充：
os.path.exists（file）                                 判断一个文件是否存在
os.remove（file）                                      删除文件
os.unlink（file）                                         删除文件
pid = os.fork()                                             创建进程 失败-1 成功0
os.getpid（）                                             获取进程的PID号
os.getppid（）                                           获取父进程的PID
os.exit（status）                                      退出一个进程（状态：整数 默认0）
pid,status = os.wait()                                 塞等待处理子进程的退出
os.WEXITSTATUS(status)                       获取原来退出状态
pid,status = os.waitpid(pid,option)            阻塞等待处理子进程的退出
os.path.getsize(‘./1.txt‘)                            读取文件的大小
os.kill（pid，sig）                                    发送一个信号给某个进程
os.listdir(path)                                         获取指定目录文件列表
os.path.isfile()                                         判断一个 文件是否为普通文件
os.path.isdir()                                         判断一个文件是否为目录 
 
 
传输层服务：
    面向连接的传输服务（tcp协议）：
        传输特征：
          可靠的数据传输：
            可靠性：无失序、无差错、无重复、无丢失、无重复
        在数据传输前和传输后需要建立连接和断开链接
          面向传输服务建立连接的过程：‘三次握手’
            1.客户端向服务器发送链接请求
            2.服务器接受到请求进行确认，返回确认报文
            3.客户端收到服务器回复最终确认链接
          面向传输服务断开链接的过程：‘四次挥手’
            1.主动方发送报文，告知被动方要断开链接
    2.被动方回复报文，表示已经接受到请求，准备断开
    3.被动方再次发送报文，表示准备处理就绪，可以断开
    4.主动方发送确认报文，断开链接
        应用情况：
    适用于传输较大的内容或文件，网络良好，
    需要保证传输可靠性的情况
    e.g.  信息聊天，文件上传下载，邮件，网页获取
 
    面向无连接的传输服务（udp协议）：
        不保证传输的可靠性
没有建立连接和断开的过程
数据的收发比较自由
适用情况： 
    网络情况较差，对可靠性要求不高，收发消息的两端
    e.g.：网络视频，群聊，广播等
 
 
收发函数特性：
     recv特征：
       如果建立的另一端链接被断开， 则recv立即返回空字符串
       recv是从接受缓冲区取出内容，当缓冲区为空则阻塞
       recv如果一次接受不完缓冲区的内容，下次执行会自动接受
     send特征：
        如果发送的另一端不存在则会产生pipe...异常
send是从发送缓冲区发送内容当缓冲区为满则堵塞
 
 
http协议：
   超文本传输协议
   用途：
      网站中浏览区器网页的获取，基于网站事物数据传输
      编写基于http协议的数据传输
   特点：
      1.应用层协议，传输层使用tcp服务
      2.简单、灵活，可以使用多种编程语言操作
      3.无状态的协议，既不用记录用户的输入内容
      4.http1.1  ---> http2.0（还没发布）  技术的成熟和稳定性
   http请求（request）：
      1.请求格式：
         1）请求行：说明具体的请求类别和内容
          GET    /index.html    /HTTP/1.1
                请求类别   请求内容    协议版本
     2）请求类别：
        GET：获取网络资源
POST：提交一定的附加数据
HEAD：获取相应头
PUT：更新服务器资源
DELETE：删除服务器资源
CONNECT：未使用
TRACE：用于测试
OPTIONS：获取服务器性能信息
 2.请求头：对请求的具体描述
     Accept：text/html
        每一个键值对占一行，描述了一个特定信息
 3.空行
 4.请求体：具体的参数或提交的内容
          get参数或者post提交的内容
   http响应（response）：
      1.响应格式：
        1）响应行:反馈具体的响应情况
          HTTP/1.1     20       OK
  版本协议   响应码   附加信息
    3）响应码：
       1xx：提示信息，表示请求已经接收
       2xx：响应成功
       3xx：响应需要定向
       4xx：客户端错误
       5xx：服务器端错误
 3）常见响应码：
   200  成功
   404  请求内容不存在
   401  没有访问权限
   500  服务器未知错误
       503  服务器暂时无法执行
      2.响应头：对响应内容的具体描述
      3.空行
      4.响应体：
         将客户端请求内容进行返回
 
 
IO多路复用
定义：
通过一个监测，可以同时监控多个IO事件的行为，
当那个IO可以执行，让这个IO事件发生
同时监控多个IO事件，当哪个IO事件准备就绪就执行哪个IO事件
此时形成多个IO时间都可以操作的现象，不必逐个等待执行
IO准备就绪：
IO事件即将发生时的临界状态是不可逆转的
在程序中存在的IO事件中选择要监测的事件
创建监测，将监测的IO事件注册
等待监测的IO事件发生，判断是什么事件
处理相应的IO
 
poll方法实现IO多路复用：
   1.创建poll对象：
       p = select.poll
   2.注册关注的IO：
       p.register(s， POLLIN | PLLERR)
       不关注：
          p.unregister(s)
       事件类别：
          POLLIN  POLLOUT  POLLERR  POLLHUP   POLLPRI
          rlist    wlist    xlist     断开   紧急处理 
   3.监控IO：
       events = p.poll（）
       功能：监控关注的IO事件
       返回值：
           返回发生IO事件
   events是一个列表[(fileno, evnet), (), ()....]
   每个就绪IO对应一个元组（描述符，就绪事件）
       IO地图：s.fileno():s
   4.处理IO事件
 
位运算：
   按照二进制位进行位运算操作
   & 按为与   |按位或   ^按位异或
 
   << 左异    >>右移
 
   11  1011
   14  1110
 
   &   1010  有0得0
   |   1111  有1得1
   ^   0101  相同为0不同为1
  
   11 << 2  == 44   右侧补零（乘2乘2次）
   14 >> 2  == 3    挤掉右侧的数字（地板除2除2次）
使用：
    1.在低层硬件时操作寄存器
    2.做标志位的过滤
 
 
 
多任务编程：
    意义：
充分利用计算机资源，同时运行多个任务，
提高程序整体的运行效率
    定义：
通过程序利用计算机的多个核心达到同时执行多个任务的目的
因此达到提升程序运行效率的目的
    实施方案：
多进程编程
多线程编程
    并行：
        多个计算机核心在同时处理多个任务，
这时多个任务之间是并行关系
     并发：
        同时运行多个任务，内核在多个任务之间的不断切换，
达到多个任务都会执行的处理效果
此时多个任务之间的并发关系
 
程序：
    是一个可执行文件，是静态的，只占有磁盘
    不占用计算机运行资源
进程：
    程序在计算机中的一次执行过程
    是一个动态过程，占有一定的计算机资源
    有一定的生命周期
注：
    同一个程序不同的运行过程是不同的进程，
    因为分配的资源和生命周期都不同
 
进程的创建过程：
    1.用户启动一个程序，或是调用接口发起进程创建
    2.操作系统接收用户请求分配计算机资源创建进程
    3.操作系统将一定状态的进程提供给用户使用
    4.用户利用操作提供的进程完成任务
 
CPU时间片：
    如果有个进程占有CPU此时我们称为该进程占有CPU的时间片
    多个进程任务或轮流占有CPU时间片并形成并发效果
  
进程信息（process）
    PCB（进程控制块）：
         进程创建后 会自动在内存中产生一个空间存放进程信息
    进程信息：
        进程ID 进程占有内存的位置  创建时间、创建位置
查看系统进程信息：ps -aux
    PID（process ID）：
      在操作系统中每个进程都有唯一的PID值是由系统分配的
进程特征：
    进程是操作系统分配资源的最小单元
    每个进程拥有自己独立的运行空间（4个G的虚拟内存空间）
    进程之间相互独立各不影响
进程的状态：
    三态：
    就绪状态：
         进程具备执行条件，等待系统分配处理器资源进入运行态
    运行态：
         进程占有CPU处于运行状态
    等待态：
         进程暂时不具备运行条件，需要阻塞等待
 
    五态：
         在三态的基础上增加新建和终止态 
 新建：
   创建一个新的程序，获取系统资源的过程
 终止：
   进程执行结束，释放资源的过程
 
ps -aux ---> STAT表示进程状态：
    D  等待态  阻塞  不可中断等待态
    S  等待态  睡眠  可中断等待态
    T  等待态  暂停  暂停执行
    R  运行态（就绪态）
    Z  僵尸
      +  前台进程（在终端运行）
      <  有较高优先级的进程
      N  较低优先级的进程
      s  回话组
      l  有进程链接
进程的优先级：
    top 查看进程运行态优先级
    取值范围：-20~19   -20最高
    nice：
       以指定的优先级运行一个程序
       nice -9 ./hello.py  以9的优先级运行
       sudo nice --9 ./hello.py 以-9优先级运行
 
    首行添加 #! /usr/bin/python3  指定执行器
      执行：./hello.py
    修改程序权限添加可执行权限
         chmod 775 hello.py
 
孤儿进程 ： 
当父进程先于子进程退出，此时子进程就会成为孤儿进程。
    * 孤儿进程会被系统指定进程收养，即系统进程会成为孤儿
      进程新的父进程。系统进程会自动处理孤儿进程退出状态
 
僵尸进程 ： 
子进程先于父进程退出，父进程没有处理子进程的退出状态，此时子进程就会成为僵尸进程
* 僵尸进程会滞留部分PCB信息在内存中，大量的僵尸进
   程会消耗系统的内存资源，所以要尽量避免僵尸进程产生
 
如何避免僵尸进程产生？
* 父进程先退出
* 父进程处理子进程退出状态
* 创建二级子进程
 
进程池技术：
    产生原因：
    如果有大量的任务需要多进程完成，而调用周期比较短且需要频繁创建
此时可能产生大量进程频繁创建销毁的情况  消耗计算机资源较大
    使用方法：
    1.创建进程池，在池内放入适当数量的进程
2.将事件封装成函数。放入到进程池
3.事件不断运行，直到所有放入进程池事件运行完成
4.关闭进程池，回收进程
同步互斥机制
    目的：
       解决对共有资源产生的资源争夺
    临界资源：
         多个进程或线程都可以操作的资源
    临界区：
        操作临界资源的代码段
    同步：
    同步是一种合作关系，为完成某个任务，
多进程或者多个线程之间形成的一种协调
按照约定执行，相互告知，共同完成任务
    互斥：
    互斥是一种制约关系，当一个进程或者线程
进入临界区操作资源时采用上锁的方式，
阻止其他进程操作，直到解锁后才能让出资源
多线程：
    什么是线程（thread）？
      线程也是一种多任务编程方式，可以使用计算机的多核资源
      线程被称为轻量级的进程
    线程的特征：
      1.一个进程可以包含多个线程
      2.线程是计算机内核使用的最小单位
      3.线程也是一个运行过程，也要消耗计算机资源
      4.多个线程共享共用进程的资源
      5.线程也有自己的特征属性，TID、指令集、线程栈
      6.多个线程之间独立运行互不干扰 空间不独立（都消耗进程空间）
      7.线程的创建删除消耗的资源要小于进程 线程/进程（1/20）
线程通信：
               多个线程共用线程空间，所以进程的全局变量对进程内线程均可见
               线程的通信方法就是使用去全局变量通信
       注：
              线程间使用全局变量进程通信时，全局变量为共享资源
               往往需要同步互斥机制
 
 
 
进程和线程的区别和联系：
    1.两者都是多任务编程的方式  都能够使用计算机的多核
    2.进程的创建和删除要比线程消耗更多的计算机资源
    3.进程空间独立，数据安全性好，有专门的进程间的通信方法
    4.线程使用全局变量，更加简单，但需要同步互斥操作
    5.一个进程可以包含多个线程，线程共享进程空间资源
    6.进程线程都独立执行，有自己的特有属性
 
使用情况：
    1.一个进程中并发任务比较多，比较简单，适合使用多线程
    2.如果数据程序比较复杂，特别是可能多个任务通信比较多的时候
      要考虑使用线程同步互斥的复杂性
    3.多个任务存在明显差异，和功能分离的时候没有必要一定写入到一个进程中
    4.使用Python要考虑到GIL的问题
 
 
Pyhthon线程GIL问题：
    GIL （全局解释器锁）
    Python --->支持线程操作--->出现IO同步互斥--->加锁--->超级锁，给解释器加锁
    后果：
        同一时刻一个解释器只解释一个线程 
        此时其他线程需要等待。大大降低了Python线程的执行效率
        只能实现并发不能实现并行
 
Python GIL问题解决方案：
    1.修改c解释器
    2.尽量使用多进程进行并行操作
    3.Python线程尽量用在高延迟多阻塞的IO情形
    3.不使用CPython   使用C#、JAVA 做的得解释器
 
 
网络服务器基础：
    循环服务器：：
        单进程程序，循环接受客户请求，处理请求，处理完毕后再接受下一次请求
        特点：
            每次只能处理一个客户端请求，如果客户端长期占有服务器则无法处理其他客户端
            请求
        优点：
            实现简单，占用资源少
        缺点：
            无法同时处理多个客户端，体验差
        使用情况：
            任务短暂，可以快速完成，udp比tcp更适合循环
    并发服务器：
        能够同时处理多个客户端任务请求
        IO并发：
            IO多路复用 协程
            优点：
                可以实现IO并发操作，占用系统资源少
            缺点：
                不能够监控CPU密集的情况，并不能有长期阻塞
        多进程/线程并发：
            为每个客户端单独提供一个进程或线程，处理客户端请求
            优点：
                客户端可以长期占有服务器
            缺点：
                消耗计算机资源比较多

 

想轻松入门python编程，这10个经典案例你还不知道嘛？

一直以来，Python都是一门很简单的编程语言，其实无论你有没有基础，学起来都不难。但，必须有方法，而最好的方法其实就是学+练，即：基本常识+这10经典案例。而同时有着系统的Python基础知... 查看详情

哪有python编程入门经典教程

【033】Python（喵喵教程）百度网盘免费资源在线学习  链接:https://pan.baidu.com/s/1ZS20DsOp-_70wVD9NNxGow提取码:1ek8  【033】Python（喵喵教程）量化金融项目北京15期就业班 python课件python开发工具python基础班Python3爬虫课... 查看详情

python基础：python入门介绍

文章目录Python入门介绍一、什么是Python？二、Python历史三、学习Python优势四、Python受欢迎的9个原因五、Python的未来六、总结Python入门介绍14天学习训练营导师课程：杨鑫《Python自学编程基础》杨鑫《Python网络爬虫基础》... 查看详情

c#异步编程基础入门总结

1.前言*.NETFramework提供了执行异步操作的三种模式：异步编程模型（APM）模式（也称为IAsyncResult的模式），其中异步操作要求Begin和End方法（例如，BeginWrite和EndWrite异步写入操作）。这种模式不再被推荐用于新开发。有关更多信息... 查看详情

python3操作mongodb的crud以及聚合案例，代码可直接运行（python经典编程案例）(代码片段)

基础篇（能解决工作中80%的问题）:MongoDB的概述、应用场景、下载方式、连接方式和发展历史等MongoDB数据类型、重要概念以及shell常用指令MongoDB文档的各种增加、更新、删除操作总结MongoDB各种查询操作总结MongoDB对列的各... 查看详情

零基础学python有什么建议？怎么入门？

Python作为一门易学的编程语言，非常适合初学者入门和培养编程兴趣，但即便如此还是有很多从未接触过编程学习的小伙伴会感到困惑，所以我这里也给大家总结了一些学习经验和方法：初学者学习步骤第一步... 查看详情

学python买啥书

参考技术A1、基础书籍：《Python编程》豆瓣评分：9.1分推荐指数：★★★★★2、入门秘籍：《零基础入门学习Python》豆瓣评分：8.7分推荐指数：★★★★★3、经典好书：《利用Python进行数据分析》豆瓣评分：8.6分推荐指数：★... 查看详情

总结+经典例题重做(代码片段)

欢迎交流学习~~专栏：蓝桥杯Python组刷题日寄从4个月前开始写蓝桥杯系列，到目前为止一共是19篇，其中：入门篇5篇，简单篇8篇，进阶篇6篇。这篇文章主要是为了为先前内容进行总结，并对其中的部... 查看详情

50kstar，计算机网络基础知识总结开源了！(代码片段)

第一本是程序员必知的硬核基础知识，这是一本非常入门的经典PDF，看完能让你对计算机有一个基础的了解和入门，是培养你 内核 的基础，我们看下目录大纲基本上涵盖了计算机所有基础知识，从CPU到内存... 查看详情

javascript入门经典零基础学习

本书目录第一章： JavaScript语言基础第二章： JavaScript内置对象第三章： 窗口window对象第四章： 文档document对象第五章： 表单form对象第六章： History与Navigator对象第七章： JavaScript框架编程第八章： ... 查看详情

不硬啃，不生背《最常用python操作总结》零基础快速入门(代码片段)

...PPT模板、学习资料、面试题库。直接去文末领取目录1、python操作linux2、网络爬虫：requests3、发送邮件4、字符串正则匹配5、操作数据库：MySQLdb6、操作execl：pandas7、数据分析：numpy8、数据画图分析 查看详情

完美python入门基础知识点总结

 Python标识符在Python里，标识符有字母、数字、下划线组成。在Python中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。Python中的标识符是区分大小写的。以下划线开头的标识符是有特殊意义的。以单下划... 查看详情

关于python的经典入门书籍都有哪些

我接触的如下：《Python学习手册》，死贵的书，但是看完了似乎没什么卵用。我一直拿来跟学习Perl的时候做对比，学习Perl的时候一个星期就能够熟练写代码。这本书将近1000页，让我学了一个多月。看完了几本还处于Helloworld、... 查看详情

计算机入门书单

...要从三个方面入手：编程语言、数据结构与算法、计算机基础知识；以下基本是我总结的经典教材，书不在多，经典就好。搞定这几本，也就算了真正入门了。通过这些书可以系统地培养起知识体系，少走弯路。1）编程语言《CP... 查看详情

python基础|函数及面向过程编程详解

第五章函数⭐本专栏旨在对Python的基础语法进行详解，精炼地总结语法中的重点，详解难点，面向零基础及入门的学习者，通过专栏的学习可以熟练掌握python编程，同时为后续的数据分析，机器学习及深度学习的代码能力打下坚... 查看详情

matplotlib各种案例总结（python经典编程案例）(代码片段)

一.绘制基本图表颜色color和简写：红色r:red绿色g:green蓝色b:blue青色c:cyan洋红色m:magenta黄色y:yellow黑色k:black白色w:white1.1绘制柱状图importmatplotlib.pyplotaspltx=[1,2,3,4,5,6,7,8]y=[60,45,49,36,42,67,40,50]plt.bar(x,y) 查看详情

python3操作mongodb的crud以及聚合案例，代码可直接运行（python经典编程案例）(代码片段)

...种查询操作以及聚合操作总结05MongoDB对列的各种操作总结python3操作MongoDB的各种案例一.插入数据案例#- 查看详情

我入门python后总结的基础教程(代码片段)

先唠叨几句学习Python有几周了，也写了2个小项目来解决自己的实际需求。简单记录一下，供自己备忘，也供后来者参考。0.0)我为什么选择Python我之前使用Swift+Vapor开发了iPic(图床工具)的后端服务，遇到很多问... 查看详情