㈠ 求助关于python 的socket.timeout: timed out错误问题:
最好是先设置好超时时间
socket.setdefaulttimeout 或者urllib2.socket.setdefaulttimeout
来设置默认超时时间
也可以直接指定
urlopen(url, data=None, timeout=<object object>)
我在win下也写过python脚本,一旦except到了指定错误,脚本标会退出
这样不会出错
try:
pass
except:
do something
但不是你的本意了
linux操作是没有这个问题的
希望可以帮到你
㈡ Python 之 Socket编程(TCP/UDP)
socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。
有效的端口号： 0～ 65535
但是小于1024的端口号基本上都预留给了操作系统
POSIX兼容系统(如Linux、Mac OS X等)，在/etc/services文件中找到这些预留端口与的列表
面向连接的通信提供序列化、可靠的和不重复的数据交付，而没有记录边界。意味着每条消息都可以拆分多个片段，并且每个消息片段都能到达目的地，然后将它们按顺序组合在一起,最后将完整的信息传递给等待的应用程序。
实现方式(TCP)：
传输控制协议（TCP）， 创建TCP必须使用SOCK_STREAM作为套接字类型
因为这些套接字（AF_INET）的网络版本使用因特网协议(IP)来搜寻网络中的IP,
所以整个系统通常结合这两种协议(TCP/IP)来进行网络间数据通信。
数据报类型的套接字, 即在通信开始之前并不需要建议连接,当然也无法保证它的顺序性、可靠性或重复性
实现方式(UDP)
用户数据包协议（UDP), 创建UDP必须使用SOCK_DGRAM (datagram)作为套接字类型
它也使用因特网来寻找网络中主机，所以是UDP和IP的组合名字UDP/IP
注意点:
1）TCP发送数据时，已建立好TCP连接，所以不需要指定地址。UDP是面向无连接的，每次发送要指定是发给谁。
2）服务端与客户端不能直接发送列表，元组，字典。需要字符串化repr(data)。
TCP的优点： 可靠，稳定 TCP的可靠体现在TCP在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源。
TCP的缺点： 慢，效率低，占用系统资源高，易被攻击 TCP在传递数据之前，要先建连接，这会消耗时间，而且在数据传递时，确认机制、重传机制、拥塞控制机制等都会消耗大量的时间，而且要在每台设备上维护所有的传输连接，事实上，每个连接都会占用系统的CPU、内存等硬件资源。 而且，因为TCP有确认机制、三次握手机制，这些也导致TCP容易被人利用，实现DOS、DDOS、CC等攻击。
什么时候应该使用TCP : 当对网络通讯质量有要求的时候，比如：整个数据要准确无误的传递给对方，这往往用于一些要求可靠的应用，比如HTTP、HTTPS、FTP等传输文件的协议，POP、SMTP等邮件传输的协议。 在日常生活中，常见使用TCP协议的应用如下： 浏览器，用的HTTP FlashFXP，用的FTP Outlook，用的POP、SMTP Putty，用的Telnet、SSH QQ文件传输.
UDP的优点： 快，比TCP稍安全 UDP没有TCP的握手、确认、窗口、重传、拥塞控制等机制，UDP是一个无状态的传输协议，所以它在传递数据时非常快。没有TCP的这些机制，UDP较TCP被攻击者利用的漏洞就要少一些。但UDP也是无法避免攻击的，比如：UDP Flood攻击……
UDP的缺点： 不可靠，不稳定 因为UDP没有TCP那些可靠的机制，在数据传递时，如果网络质量不好，就会很容易丢包。
什么时候应该使用UDP： 当对网络通讯质量要求不高的时候，要求网络通讯速度能尽量的快，这时就可以使用UDP。 比如，日常生活中，常见使用UDP协议的应用如下： QQ语音 QQ视频 TFTP ……
㈢ linux python connect 对同一个端口可以建立多少个
如果是tcp client用同一个本地端口去连不同的两个服务器ip，连第二个时就会提示端口已被占用。但服务器的监听端口，可以accept多次，建立多个socket；我的问题是服务器一个端口为什么能建立多个连败樱接而客户端却不行呢？
TCP server 可以，TCP client 也可以。一个套接字只能建立一个连接，无论对于 server 还是 client。
注意报错消息是：
[Errno 106] (EISCONN) Transport endpoint is already connected
man 2 connect 说得很清楚了：
Generally, connection-based protocol sockets may successfully connect() only once; connectionless protocol sockets may use connect() multiple times to change their association.
就是说，TCP 套接字最多只能调用 connect 一次。那么，你的监听套接字调用 connect 了几次？
来点有意思的。
一个套接字不能连接两次，并不代表一个本地地址不能用两次，看！****加粗文字**加做并粗文字**
>>> import socket
>>> s = socket.socket()
# since Linux 3.9, 见 man 7 socket
>>> s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
>>> s2 = socket.socket()
>>> s2.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
>>> s.bind(('127.0.0.1', 12345))
>>> s2.bind(('127.0.0.1', 12345))
# 都可以使用同一本地地址来连接哦
>>> s.connect(('127.0.0.1', 80))
>>> s2.connect(('127.0.0.1', 4321))
>>> netstat -npt | grep 12345
(Not all processes could be identified, non-owned process info
will not be shown, you would have to be root to see it all.)
tcp 0 0 127.0.0.1:4321 127.0.0.1:12345 ESTABLISHED 18284/python3
tcp 0 0 127.0.0.1:12345 127.0.0.1:4321 ESTABLISHED 4568/python3
tcp 0 0 127.0.0.1:80 127.0.0.1:12345 ESTABLISHED -
tcp 0 0 127.0.0.1:12345 127.0.0.1:80 ESTABLISHED 4568/python3
你们这些有女友的都弱爆了啦 :-(
更新：大家来玩 TCP： 一个人也可以建立 TCP 连接呢 - 依云's Blog
2015年08月19日回答 · 2015年08月19日更新
依云21.1k 声望
答案对人有帮助，有参考价值1答案没帮助，是错误的答案，答非所问
内核是以一个（着名的）5元信息组来标识不同的socket的：源地址、源端口、目的地址、目的端口、协议号。任何一个不同，都不叫“同一个socket”。
2015年08月20日回答
sched_yield80 声望
答案对人有帮察胡丛助，有参考价值0答案没帮助，是错误的答案，答非所问
首先,TCP链接是可靠的端对端的链接，每个TCP链接由4个要素组成：2组IP地址（本地和远端），2组端口地址（本地和远端）。其中如果需要跟端口信息绑定时，都需要调用bind函数，如果server端针对2个同样的IP、端口组进行同样的绑定时，第2次同样是不成功的。
2015年08月16日回答
charliecui2.4k 声望
答案对人有帮助，有参考价值0答案没帮助，是错误的答案，答非所问
有个相关的问题： ftp的数据传输，服务器会用20端口主动连接客户端，如果两个客户端同时在一下载东西，那ftp 服务器能用20端口去连接两个ip ？（这时ftp的服务器其实是tcp里的客户端）
2015年08月16日回答
编辑
hyanleo163 声望
+1
能啊，看我的实验。
依云 · 2015年08月19日
不管是服务器还是客户端，建立TCP链接，同一个端口都只能使用一次。
这句话其实是**错的**！
对于TCP协议，要成功建立一个新的链接，需要保证新链接四个要素组合体的唯一性：客户端的IP、客户端的port、服务器端的IP、服务器端的port。也就是说，服务器端的同一个IP和port，可以和同一个客户端的多个不同端口成功建立多个TCP链接（与多个不同的客户端当然也可以），只要保证【Server IP + Server Port + Client IP + Client Port】这个组合唯一不重复即可。
> netstat -a -n -p tcp ｜grep 9999
tcp 0 0 127.0.0.1:51113 127.0.0.1:9999 ESTABLISHED 2701/nc
tcp 0 0 127.0.0.1:51119 127.0.0.1:9999 ESTABLISHED 2752/nc
上述结果127.0.0.1:9999中9999端口成功建立两个TCP链接，也就可以理解。
**客户端**发送TCP链接请求的端口，也就是后续建立TCP链接使用的端口，所以一旦TCP链接建立，端口就被占用，无法再建立第二个链接。
而**服务器端**有两类端口：侦听端口 和 后续建立TCP链接的端口。其中侦听端口只负责侦听客户端发送来的TCP链接请求，不用作建立TCP链接使用，一旦侦听到有客户端发送TCP链接请求，就分配一个端口（一般随机分配，且不会重复）用于建立TCP链接，而不是所说的服务器一个端口能建立多个连接。
上述描述也比较片面，客户端如何请求及建立链接，服务器端如何侦听及是否分配新随机端口等...应该都可以在应用层面进行控制，所以上述描述可以作为建立TCP链接的一种方式，仅供参考。
一些英文的参考：
How do multiple clients connect simultaneously to one port, say 80, on a server?
TCP : two different sockets sharing a port?
------------------------------------------------------------------------------------
提升linux下tcp服务器并发连接数限制 2012-12-02 20:30:23
1、修改用户进程可打开文件数限制
在Linux平台上，无论编写客户端程序还是服务端程序，在进行高并发TCP连接处理时，最高的并发数量都要受到系统对用户单一进程同时可打开文件数量的限制(这是因为系统为每个TCP连接都要创建一个socket句柄，每个socket句柄同时也是一个文件句柄)。可使用ulimit命令查看系统允许当前用户进程打开的文件数限制：
[speng@as4 ~]$ ulimit -n
1024
这表示当前用户的每个进程最多允许同时打开1024个文件，这1024个文件中还得除去每个进程必然打开的标准输入，标准输出，标准错误，服务器监听 socket，进程间通讯的unix域socket等文件，那么剩下的可用于客户端socket连接的文件数就只有大概1024-10=1014个左右。也就是说缺省情况下，基于Linux的通讯程序最多允许同时1014个TCP并发连接。
对于想支持更高数量的TCP并发连接的通讯处理程序，就必须修改Linux对当前用户的进程同时打开的文件数量的软限制(soft limit)和硬限制(hardlimit)。其中软限制是指Linux在当前系统能够承受的范围内进一步限制用户同时打开的文件数；硬限制则是根据系统硬件资源状况(主要是系统内存)计算出来的系统最多可同时打开的文件数量。通常软限制小于或等于硬限制。
修改上述限制的最简单的办法就是使用ulimit命令：
[speng@as4 ~]$ ulimit -n
上述命令中，在中指定要设置的单一进程允许打开的最大文件数。如果系统回显类似于“Operation notpermitted”之类的话，说明上述限制修改失败，实际上是因为在中指定的数值超过了Linux系统对该用户打开文件数的软限制或硬限制。因此，就需要修改Linux系统对用户的关于打开文件数的软限制和硬限制。
第一步，修改/etc/security/limits.conf文件，在文件中添加如下行：
speng soft nofile 10240
speng hard nofile 10240
其中speng指定了要修改哪个用户的打开文件数限制，可用'*'号表示修改所有用户的限制；soft或hard指定要修改软限制还是硬限制；10240则指定了想要修改的新的限制值，即最大打开文件数(请注意软限制值要小于或等于硬限制)。修改完后保存文件。
第二步，修改/etc/pam.d/login文件，在文件中添加如下行：
session required /lib/security/pam_limits.so
这是告诉Linux在用户完成系统登录后，应该调用pam_limits.so模块来设置系统对该用户可使用的各种资源数量的最大限制(包括用户可打开的最大文件数限制)，而pam_limits.so模块就会从/etc/security/limits.conf文件中读取配置来设置这些限制值。修改完后保存此文件。
第三步，查看Linux系统级的最大打开文件数限制，使用如下命令：
[speng@as4 ~]$ cat /proc/sys/fs/file-max
12158
这表明这台Linux系统最多允许同时打开(即包含所有用户打开文件数总和)12158个文件，是Linux系统级硬限制，所有用户级的打开文件数限制都不应超过这个数值。通常这个系统级硬限制是Linux系统在启动时根据系统硬件资源状况计算出来的最佳的最大同时打开文件数限制，如果没有特殊需要，不应该修改此限制，除非想为用户级打开文件数限制设置超过此限制的值。修改此硬限制的方法是修改/etc/rc.local脚本，在脚本中添加如下行：
echo 22158 > /proc/sys/fs/file-max
这是让Linux在启动完成后强行将系统级打开文件数硬限制设置为22158。修改完后保存此文件。
完成上述步骤后重启系统，一般情况下就可以将Linux系统对指定用户的单一进程允许同时打开的最大文件数限制设为指定的数值。如果重启后用 ulimit- n命令查看用户可打开文件数限制仍然低于上述步骤中设置的最大值，这可能是因为在用户登录脚本/etc/profile中使用ulimit-n命令已经将用户可同时打开的文件数做了限制。由于通过ulimit-n修改系统对用户可同时打开文件的最大数限制时，新修改的值只能小于或等于上次ulimit-n 设置的值，因此想用此命令增大这个限制值是不可能的。所以，如果有上述问题存在，就只能去打开/etc/profile脚本文件，在文件中查找是否使用了 ulimit-n限制了用户可同时打开的最大文件数量，如果找到，则删除这行命令，或者将其设置的值改为合适的值，然后保存文件，用户退出并重新登录系统即可。
通过上述步骤，就为支持高并发TCP连接处理的通讯处理程序解除关于打开文件数量方面的系统限制。
2、修改网络内核对TCP连接的有关限制
在Linux上编写支持高并发TCP连接的客户端通讯处理程序时，有时会发现尽管已经解除了系统对用户同时打开文件数的限制，但仍会出现并发TCP连接数增加到一定数量时，再也无法成功建立新的TCP连接的现象。出现这种现在的原因有多种。
第一种原因可能是因为Linux网络内核对本地端口号范围有限制。此时，进一步分析为什么无法建立TCP连接，会发现问题出在connect()调用返回失败，查看系统错误提示消息是“Can't assign requestedaddress”。同时，如果在此时用tcpmp工具监视网络，会发现根本没有TCP连接时客户端发SYN包的网络流量。这些情况说明问题在于本地Linux系统内核中有限制。其实，问题的根本原因在于Linux内核的TCP/IP协议实现模块对系统中所有的客户端TCP连接对应的本地端口号的范围进行了限制(例如，内核限制本地端口号的范围为1024~32768之间)。当系统中某一时刻同时存在太多的TCP客户端连接时，由于每个TCP客户端连接都要占用一个唯一的本地端口号(此端口号在系统的本地端口号范围限制中)，如果现有的TCP客户端连接已将所有的本地端口号占满，则此时就无法为新的TCP客户端连接分配一个本地端口号了，因此系统会在这种情况下在connect()调用中返回失败，并将错误提示消息设为“Can't assignrequested address”。有关这些控制逻辑可以查看Linux内核源代码，以linux2.6内核为例，可以查看tcp_ipv4.c文件中如下函数：
static int tcp_v4_hash_connect(struct sock *sk)
请注意上述函数中对变量sysctl_local_port_range的访问控制。变量sysctl_local_port_range的初始化则是在tcp.c文件中的如下函数中设置：
void __init tcp_init(void)
内核编译时默认设置的本地端口号范围可能太小，因此需要修改此本地端口范围限制。
第一步，修改/etc/sysctl.conf文件，在文件中添加如下行：
net.ipv4.ip_local_port_range = 1024 65000
这表明将系统对本地端口范围限制设置为1024~65000之间。请注意，本地端口范围的最小值必须大于或等于1024；而端口范围的最大值则应小于或等于65535。修改完后保存此文件。
第二步，执行sysctl命令：
[speng@as4 ~]$ sysctl -p
如果系统没有错误提示，就表明新的本地端口范围设置成功。如果按上述端口范围进行设置，则理论上单独一个进程最多可以同时建立60000多个TCP客户端连接。
第二种无法建立TCP连接的原因可能是因为Linux网络内核的IP_TABLE防火墙对最大跟踪的TCP连接数有限制。此时程序会表现为在 connect()调用中阻塞，如同死机，如果用tcpmp工具监视网络，也会发现根本没有TCP连接时客户端发SYN包的网络流量。由于 IP_TABLE防火墙在内核中会对每个TCP连接的状态进行跟踪，跟踪信息将会放在位于内核内存中的conntrackdatabase中，这个数据库的大小有限，当系统中存在过多的TCP连接时，数据库容量不足，IP_TABLE无法为新的TCP连接建立跟踪信息，于是表现为在connect()调用中阻塞。此时就必须修改内核对最大跟踪的TCP连接数的限制，方法同修改内核对本地端口号范围的限制是类似的：
第一步，修改/etc/sysctl.conf文件，在文件中添加如下行：
net.ipv4.ip_conntrack_max = 10240
这表明将系统对最大跟踪的TCP连接数限制设置为10240。请注意，此限制值要尽量小，以节省对内核内存的占用。
第二步，执行sysctl命令：
[speng@as4 ~]$ sysctl -p
如果系统没有错误提示，就表明系统对新的最大跟踪的TCP连接数限制修改成功。如果按上述参数进行设置，则理论上单独一个进程最多可以同时建立10000多个TCP客户端连接。
3、使用支持高并发网络I/O的编程技术
在Linux上编写高并发TCP连接应用程序时，必须使用合适的网络I/O技术和I/O事件分派机制。
可用的I/O技术有同步I/O，非阻塞式同步I/O(也称反应式I/O)，以及异步I/O。在高TCP并发的情形下，如果使用同步I/O，这会严重阻塞程序的运转，除非为每个TCP连接的I/O创建一个线程。但是，过多的线程又会因系统对线程的调度造成巨大开销。因此，在高TCP并发的情形下使用同步I /O 是不可取的，这时可以考虑使用非阻塞式同步I/O或异步I/O。非阻塞式同步I/O的技术包括使用select()，poll()，epoll等机制。异步I/O的技术就是使用AIO。
从I/O事件分派机制来看，使用select()是不合适的，因为它所支持的并发连接数有限(通常在1024个以内)。如果考虑性能，poll()也是不合适的，尽管它可以支持的较高的TCP并发数，但是由于其采用“轮询”机制，当并发数较高时，其运行效率相当低，并可能存在I/O事件分派不均，导致部分 TCP连接上的I/O出现“饥饿”现象。而如果使用epoll或AIO，则没有上述问题(早期 Linux内核的AIO技术实现是通过在内核中为每个I/O请求创建一个线程来实现的，这种实现机制在高并发TCP连接的情形下使用其实也有严重的性能问题。但在最新的Linux内核中，AIO的实现已经得到改进)。
综上所述，在开发支持高并发TCP连接的Linux应用程序时，应尽量使用epoll或AIO技术来实现并发的TCP连接上的I/O控制，这将为提升程序对高并发TCP连接的支持提供有效的I/O保证。
㈣ python获取系统下打开的端口
第一个问题没啥，用0作为端口那么就会选择本地没有使用的端口。
第二个要么用python序列化的方法，只要对端用反序列化解释就可以。要么用自定义的，借助于struct的pack/unpack，或者如果跟c通讯，用ctypes定义结构体也可以。看你需要了
㈤ 初学者怎么学习Python
初学者、零基础学Python的话，建议参加培训班，入门快、效率高、周期短、实战项目丰富，还可以提升就业竞争力。
以下是老男孩教育Python全栈课程内容：阶段一：Python开发基础
Python开发基础课程内容包括：计算机硬件、操作系统原理、安装linux操作系统、linux操作系统维护常用命令、Python语言介绍、环境安装、基本语法、基本数据类型、二进制运算、流程控制、字符编码、文件处理、数据类型、用户认证、三级菜单程序、购物车程序开发、函数、内置方法、递归、迭代器、装饰器、内置方法、员工信息表开发、模块的跨目录导入、常用标准库学习，b加密\re正则\logging日志模块等，软件开发规范学习，计算器程序、ATM程序开发等。
阶段二：Python高级级编编程&数据库开发
Python高级级编编程&数据库开发课程内容包括：面向对象介绍、特性、成员变量、方法、封装、继承、多态、类的生成原理、MetaClass、__new__的作用、抽象类、静态方法、类方法、属性方法、如何在程序中使用面向对象思想写程序、选课程序开发、TCP/IP协议介绍、Socket网络套接字模块学习、简单远程命令执行客户端开发、C\S架构FTP服务器开发、线程、进程、队列、IO多路模型、数据库类型、特性介绍，表字段类型、表结构构建语句、常用增删改查语句、索引、存储过程、视图、触发器、事务、分组、聚合、分页、连接池、基于数据库的学员管理系统开发等。
阶段三：前端开发
前端开发课程内容包括：HTML\CSS\JS学习、DOM操作、JSONP、原生Ajax异步加载、购物商城开发、Jquery、动画效果、事件、定时期、轮播图、跑马灯、HTML5\CSS3语法学习、bootstrap、抽屉新热榜开发、流行前端框架介绍、Vue架构剖析、mvvm开发思想、Vue数据绑定与计算属性、条件渲染类与样式绑定、表单控件绑定、事件绑定webpack使用、vue-router使用、vuex单向数据流与应用结构、vuex actions与mutations热重载、vue单页面项目实战开发等。
阶段四：WEB框架开发
WEB框架开发课程内容包括：Web框架原理剖析、Web请求生命周期、自行开发简单的Web框架、MTV\MVC框架介绍、Django框架使用、路由系统、模板引擎、FBV\CBV视图、Models ORM、FORM、表单验证、Django session & cookie、CSRF验证、XSS、中间件、分页、自定义tags、Django Admin、cache系统、信号、message、自定义用户认证、Memcached、redis缓存学习、RabbitMQ队列学习、Celery分布式任务队列学习、Flask框架、Tornado框架、Restful API、BBS+Blog实战项目开发等。
阶段五：爬虫开发
爬虫开发课程内容包括：Requests模块、BeautifulSoup，Selenium模块、PhantomJS模块学习、基于requests实现登陆：抽屉、github、知乎、博客园、爬取拉钩职位信息、开发Web版微信、高性能IO性能相关模块：asyncio、aiohttp、grequests、Twisted、自定义开发一个异步非阻塞模块、验证码图像识别、Scrapy框架以及源码剖析、框架组件介绍(engine、spider、downloader、scheler、pipeline)、分布式爬虫实战等。
阶段六：全栈项目实战
全栈项目实战课程内容包括：互联网企业专业开发流程讲解、git、github协作开发工具讲解、任务管理系统讲解、接口单元测试、敏捷开发与持续集成介绍、django + uwsgi + nginx生产环境部署学习、接口文档编写示例、互联网企业大型项目架构图深度讲解、CRM客户关系管理系统开发等。
阶段七：数据分析
数据分析课程内容包括：金融、股票知识入门股票基本概念、常见投资工具介绍、市基本交易规则、A股构成等，K线、平均线、KDJ、MACD等各项技术指标分析，股市操作模拟盘演示量化策略的开发流程，金融量化与Python，numpy、pandas、matplotlib模块常用功能学习在线量化投资平台：优矿、聚宽、米筐等介绍和使用、常见量化策略学习，如双均线策略、因子选股策略、因子选股策略、小市值策略、海龟交易法则、均值回归、策略、动量策略、反转策略、羊驼交易法则、PEG策略等、开发一个简单的量化策略平台，实现选股、择时、仓位管理、止盈止损、回测结果展示等功能。
阶段八：人工智能
人工智能课程内容包括：机器学习要素、常见流派、自然语言识别、分析原理词向量模型word2vec、剖析分类、聚类、决策树、随机森林、回归以及神经网络、测试集以及评价标准Python机器学习常用库scikit-learn、数据预处理、Tensorflow学习、基于Tensorflow的CNN与RNN模型、Caffe两种常用数据源制作、OpenCV库详解、人脸识别技术、车牌自动提取和遮蔽、无人机开发、Keras深度学习、贝叶斯模型、无人驾驶模拟器使用和开发、特斯拉远程控制API和自动化驾驶开发等。
阶段九：自动化运维&开发
自动化运维&开发课程内容包括：设计符合企业实际需求的CMDB资产管理系统，如安全API接口开发与使用，开发支持windows和linux平台的客户端，对其它系统开放灵活的api设计与开发IT资产的上线、下线、变更流程等业务流程。IT审计+主机管理系统开发，真实企业系统的用户行为、管理权限、批量文件操作、用户登录报表等。分布式主机监控系统开发，监控多个服务，多种设备，报警机制，基于http+restful架构开发，实现水平扩展，可轻松实现分布式监控等功能。
阶段十：高并发语言GO开发高并发语言GO开发课程内容包括：Golang的发展介绍、开发环境搭建、golang和其他语言对比、字符串详解、条件判断、循环、使用数组和map数据类型、go程序编译和Makefile、gofmt工具、godoc文档生成工具详解、斐波那契数列、数据和切片、make&new、字符串、go程序调试、slice&map、map排序、常用标准库使用、文件增删改查操作、函数和面向对象详解、并发、并行与goroute、channel详解goroute同步、channel、超时与定时器reover捕获异常、Go高并发模型、Lazy生成器、并发数控制、高并发web服务器的开发等。
㈥ python无法建立socket连接
服务端listen, bind。笑差 这留意这个host最好使用0.0.0.0。
客户端的host要明确指向这个服务器所在IP地址。
另外有些linux是有iptable的。 如果你开的端嫌仿口太低。比如少于1024. 或者是iptable限制外部访问，这就没芹升纤有办法了。
另外你的linux是否在虚拟机上。虚拟机如果是host 模式不成的。要桥接模式才成。
不过看情况，你都ssh连接上了。 应该还是iptable限制的问题。
㈦ Linux平台下python中有什么方法可以与一个进程通信
本文实例讲解了python实现两个程序之间通信的方法，具体方法如下：
该实例采用socket实现，与socket网络编程不一样的是socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)的第一个参数是socket.AF_UNIX
而不是 socket.AF_INET
例中两个python程序 s.py/c.py 要先运行s.py
基于fedora13/python2.6测试，成功实现！
s.py代码如下：
#!/usr/bin/env python
import socket
import os
if __name__ == '__main__':
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
conn = '/tmp/conn'
if not os.path.exists(conn):
os.mknod(conn)
if os.path.exists(conn):
os.unlink(conn)
sock.bind(conn)
sock.listen(5)
while True:
connection,address = sock.accept()
data = connection.recv(1024)
if data == "hello,server":
print "the client said:%s!\n" % data
connection.send("hello,client")
connection.close()
c.py代码如下：
#!/usr/bin/env python
import socket
import time
if __name__ == '__main__':
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
conn = '/tmp/conn'
sock.connect(conn)
time.sleep(1)
sock.send('hello,server')
print sock.recv(1024)
sock.close()
㈧ mac os x 下的python 为什么没有epoll
介绍
从2.6版本开始, python 提供了使用linux epoll 的功能. 这篇文章通过3个例子来大致介绍如何使用它. 欢迎提问和反馈.
阻塞式socket通讯
第一个例子是一个简单的python3.0版本的服务器代码, 监听8080端口的http请求, 打印结果到命令行, 回应http response给客户端.
行 9: 建立服务器的socket
行 10: 允许11行的bind()操作, 即使其他程序也在监听同样的端口. 不然的话, 这个程序只能在其他程序停止使用这个端口之后的1到2分钟后才能执行.
行 11: 绑定socket到这台机器上所有IPv4地址上的8080端口.
行 12: 告诉服务器开始响应从客户端过来的连接请求.
行 14: 程序洞毕会一直停在这里, 直弊颤碧到建立了一个连接. 这个时候, 服务器socket会建立一个新的socket, 用来和客户端通讯. 这个新的socket是accept()的返回值, address对象标示了客户端的IP地址和端口.
行 15-17: 接收数据, 直到一个完整的http请求被接收完毕. 这是一个简单的http服务器实现.
行 18: 为了方便验证, 打印客户端过来的请求到命令行.
行 19: 发送回应.
行 20-22: 关闭连接, 以及服务器的监听socket.
python官方 HOWTO 里面有具体如何使用socket编程的描述.
1 import socket
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13
14 connectiontoclient, address = serversocket.accept()
15 request = b''
16 while EOL1 not in request and EOL2 not in request:
17 request += connectiontoclient.recv(1024)
18 print(request.decode())
19 connectiontoclient.send(response)
20 connectiontoclient.close()
21
22 serversocket.close()
第租举2个例子, 我们在15行加上了一个循环, 用来循环处理客户端请求, 直到我们中断这个过程(在命令行下面输入键盘中断, 比如Ctrl-C). 这个例子更明显地表示出来了, 服务器socket并没有用来做数据处理, 而是接受服务器过来的连接, 然后建立一个新的socket, 用来和客户端通讯.
最后的23-24行确保服务器的监听socket最后总是close掉, 即使出现了异常.
1 import socket
2
3 EOL1 = b'\n\n'
4 EOL2 = b'\n\r\n'
5 response = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'
6 response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'
7 response += b'Hello, world!'
8
9 serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10 serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
11 serversocket.bind(('0.0.0.0', 8080))
12 serversocket.listen(1)
13
14 try:
15 while True:
16 connectiontoclient, address = serversocket.accept()
17 request = b''
18 while EOL1 not in request and EOL2 not in request:
19 request += connectiontoclient.recv(1024)
20 print('-'*40 + '\n' + request.decode()[:-2])
21 connectiontoclient.send(response)
22 connectiontoclient.close()
23 finally:
24 serversocket.close()
异步socket和linux epoll的优势
第2个例子里面的socket采用的是阻塞方式, 因为python解释器在出现事件之前都处在停止状态. 16行的accept()一直阻塞, 直到新的连接进来. 19行的recv()也是一直阻塞, 直到从客户端收到数据(或者直到没有数据可以接收). 21行的send()也一直阻塞, 直到所有需要发送给客户端的数据都交给了linux内核的发送队列.
当一个程序采用阻塞socket的时候, 它经常采用一个线程(甚至一个进程)一个socket通讯的模式. 主线程保留服务器监听socket, 接受进来的连接, 一次接受一个连接, 然后把生成的socket交给一个分离的线程去做交互. 因为一个线程只和一个客户端通讯, 在任何位置的阻塞都不会造成问题. 阻塞本身不会影响其他线程的工作.
多线程阻塞socket模式代码清晰, 但是有几个缺陷, 可能很难确保线程间资源共享工作正常, 可能在只有一个CPU的机器上效率低下.
C10K(单机1万连接问题!) 探讨了其他处理并行socket通讯的模式. 一种是采用异步socket. socket不会阻塞, 直到特定事件发生. 程序在异步socket上面进行一个特定操作, 并且立即得到一个结果, 不管执行成功或者失败. 然后让程序决定下一步怎么做. 因为异步socket是非阻塞的, 我们可以不采用多线程. 所有的事情都可以在一个线程里面完成. 虽然这种模式有它需要面对的问题, 它对于特定程序来说还是不错的选择. 也可以和多线程合起来使用: 单线程的异步socket可以当作服务器上面处理网络的一个模块, 而线程可以用来访问阻塞式的资源, 比如数据库.
Linux 2.6有一些方式来管理异步socket, python API能够用的有3种: select, poll和epoll. epoll和poll比select性能更好, 因为python程序不需要为了特定的事件去查询单独的socket, 而是依赖操作系统来告诉你什么socket产生了什么事件. epoll比poll性能更好, 因为它不需要每次python程序查询的时候, 操作系统都去检查所有的socket, 在事件产生的时候, linux跟踪他们, 然后在python程序调用的时候, 返回具体的列表. 所以epoll在大量(上千)并行连接下, 是一种更有效率, 伸缩性更强的机制. 图示.
采用epoll的异步socket编程示例
采用epoll的程序一般这样操作:
建立一个epoll对象
告诉epoll对象, 对于一些socket监控一些事件.
问epoll, 从上次查询以来什么socket产生了什么事件.
针对这些socket做特定操作.
告诉epoll, 修改监控socket和/或监控事件.
重复第3步到第5步, 直到结束.
销毁epoll对象.
采用异步socket的时候第3步重复了第2步的事情. 这里的程序更复杂, 因为一个线程需要和多个客户端交互.
行 1: select模块带有epoll功能
行 13: 因为socket默认是阻塞的, 我们需要设置成非阻塞(异步)模式.
行 15: 建立一个epoll对象.
行 16: 注册服务器socket, 监听读取事件. 服务器socket接收一个连接的时候, 产生一个读取事件.
行 19: connections表映射文件描述符(file descriptors, 整型)到对应的网络连接对象上面.
行 21: epoll对象查询一下是否有感兴趣的事件发生, 参数1说明我们最多等待1秒的时间. 如果有对应事件发生, 立刻会返回一个事件列表.
行 22: 返回的events是一个(fileno, event code)tuple列表. fileno是文件描述符, 是一个整型数.
行 23: 如果是服务器socket的事件, 那么需要针对新的连接建立一个socket.
行 25: 设置socket为非阻塞模式.
行 26: 注册socket的read(EPOLLIN)事件.
行 31: 如果读取事件发生, 从客户端读取新数据.
行 33: 一旦完整的http请求接收到, 取消注册读取事件, 注册写入事件(EPOLLOUT), 写入事件在能够发送数据回客户端的时候产生.
行 34: 打印完整的http请求, 展示即使通讯是交错的, 数据本身是作为一个完整的信息组合和处理的.
行 35: 如果写入事件发生在一个客户端socket上面, 我们就可以发送新数据到客户端了.
行s 36-38: 一次发送一部分返回数据, 直到所有数据都交给操作系统的发送队列.
行 39: 一旦所有的返回数据都发送完, 取消监听读取和写入事件.
行 40: 如果连接被明确关闭掉, 这一步是可选的. 这个例子采用这个方法是为了让客户端首先断开, 告诉客户端没有数据需要发送和接收了, 然后让客户端断开连接.
行 41: HUP(hang-up)事件表示客户端断开了连接(比如 closed), 所以服务器这端也会断开. 不需要注册HUP事件, 因为它们都会标示到注册在epoll的socket.
行 42: 取消注册.
行 43: 断开连接.
行s 18-45: 在这里的异常捕捉的作用是, 我们的例子总是采用键盘中断来停止程序执行.
行s 46-48: 虽然开启的socket不需要手动关闭, 程序退出的时候会自动关闭, 明确写出来这样的代码, 是更好的编码风格.