import socket

def main():

    # af_inet ==> ipv4；sock_stream ==> 类型是tcp，stream 流
    # sock_dgram ==> 类型是udp，dgram 数据报、数据报套接字
    with socket.socket(socket.af_inet, socket.sock_dgram) as udp_sock:
        udp_sock.sendto("大兄弟，你好啊".encode("utf-8"), ("192.168.36.235", 8080))
    print("over")

if __name__ == '__main__':
    main()

import socket

def main():
    with socket.socket(socket.af_inet, socket.sock_dgram) as udp_socket:
        # 绑定固定端口
        udp_socket.bind(('', 5400))
        # 发送消息
        udp_socket.sendto("小明，你知道小张的生日吗？\n".encode("utf-8"),
                          ("192.168.36.235", 8080))
    print("over")

if __name__ == '__main__':
    main()

from socket import socket, af_inet, sock_dgram

def main():
    with socket(af_inet, sock_dgram) as udp_socket:
        # 绑定端口
        udp_socket.bind(('', 5400))
        while true:
            # 发送消息
            udp_socket.sendto("你可以给我离线留言了\n".encode("utf-8"),
                              ("192.168.36.235", 8080))
            # 接收消息（data,(ip,port)）
            data, info = udp_socket.recvfrom(1024)
            print(f"[来自{info[0]}:{info[1]}的消息]：\n{data.decode('utf-8')}")

if __name__ == '__main__':
    main()

from socket import socket, af_inet, sock_dgram

def main():
    with socket(af_inet, sock_dgram) as udp_socket:
        # 绑定端口
        udp_socket.bind(('', 5400))
        while true:
            msg = input("请输入发送的内容：")
            if msg == "dotnetcrazy":
                break
            else:
                udp_socket.sendto(
                    msg.encode("utf-8"), ("192.168.36.235", 8080))

            data, info = udp_socket.recvfrom(1024)
            print(f"[来自{info[0]}:{info[1]}的消息]：\n{data.decode('utf-8')}")

if __name__ == '__main__':
    main()

from socket import socket, af_inet, sock_dgram
from multiprocessing.dummy import pool as threadpool

def send_msg(udp_socket):
    while true:
        msg = input("输入需要发送的消息：\n")
        udp_socket.sendto(msg.encode("utf-8"), ("192.168.36.235", 8080))

def recv_msg(udp_socket):
    while true:
        data, info = udp_socket.recvfrom(1024)
        print(f"[来自{info[0]}:{info[1]}的消息]：\n{data.decode('utf-8')}")

def main():
    # 创建一个socket
    with socket(af_inet, sock_dgram) as udp_socket:
        # 绑定端口
        udp_socket.bind(('', 5400))

        # 创建一个线程池
        pool = threadpool()

        # 接收消息
        pool.apply_async(recv_msg, args=(udp_socket, ))

        # 发送消息
        pool.apply_async(send_msg, args=(udp_socket, ))

        pool.close()  # 不再添加任务
        pool.join()  # 等待线程池执行完毕
    print("over")

if __name__ == '__main__':
    main()

from socket import socket, af_inet, sock_dgram
from multiprocessing.dummy import pool as threadpool

def get_port(msg):
    """获取用户输入的端口号"""
    while true:
        port = input(msg)
        try:
            port = int(port)
        except exception as ex:
            print(ex)
        else:
            return port  # 没有错误就退出死循环

def recv_msg(udp_socket):
    """接收消息"""
    while true:
        data, info = udp_socket.recvfrom(1024)
        print(f"[来自{info[0]}:{info[1]}的消息]：\n{data.decode('utf-8')}")

def send_msg(udp_socket):
    """发送消息"""
    ip = input("请输入对方ip：")
    port = get_port("请输入对方端口号：")
    while true:
        msg = input("请输入发送的消息：\n")
        udp_socket.sendto(msg.encode("utf-8"), (ip, port))

def main():
    with socket(af_inet, sock_dgram) as udp_socket:
        # 绑定端口
        udp_socket.bind(('', get_port("请输网络助手的端口号：")))
        # 创建一个线程池
        pool = threadpool()
        # 接收消息
        pool.apply_async(recv_msg, args=(udp_socket, ))
        # 发送消息
        pool.apply_async(send_msg, args=(udp_socket, ))

        pool.close()
        pool.join()

if __name__ == '__main__':
    main()

_localhost    = '127.0.0.1' # 看这
_localhost_v6 = '::1'

   def socketpair(family=af_inet, type=sock_stream, proto=0):
        if family == af_inet:
            host = _localhost # 看这
        elif family == af_inet6:
            host = _localhost_v6
        ....

        lsock = socket(family, type, proto)
        try:
            lsock.bind((host, 0)) # 看这
            lsock.listen()
            ...

using system.net;
using system.text;
using system.net.sockets;

namespace netcore
{
    class program
    {
        static void main(string[] args)
        {
            // udp通信
            using (var udp_socket = new socket(addressfamily.internetwork, sockettype.dgram, protocoltype.udp))
            {
                var ip_addr = ipaddress.parse("192.168.36.235");

                // 绑定本地端口
                udp_socket.bind(new ipendpoint(ip_addr, 5400));
                // udp发送消息
                int i = udp_socket.sendto(encoding.utf8.getbytes("小明你好啊～"), new ipendpoint(ip_addr, 8080));
                console.writeline($"发送计数：{i}");
            }
            console.writeline("over");
        }
    }
}

from socket import socket

def main():
    # 默认就是创建tcp socket
    with socket() as tcp_socket:
        # 连接服务器（没有返回值）
        tcp_socket.connect(("192.168.36.235", 8080))
        # 发送消息（返回发送的字节数）
        tcp_socket.send("小张生日快乐～".encode("utf-8"))
        # 接收消息
        msg = tcp_socket.recv(1024)
        print(f"服务器：{msg.decode('utf-8')}")

if __name__ == '__main__':
    main()

from socket import socket

def get_buffer(tcp_socket):
    buffers = b''
    while true:
        b = tcp_socket.recv(1024)
        if b:
            buffers += b
        else:
            break
    # 返回bytes
    return buffers

def main():
    with socket() as tcp_socket:
        # 连接服务器
        tcp_socket.connect(("dotnetcrazy.cnblogs.com", 80))
        # 发送消息（模拟http）
        tcp_socket.send(
            b'get / http/1.1\r\nhost: dotnetcrazy.cnblogs.com\r\nconnection: close\r\n\r\n'
        )
        # 以"\r\n\r\n"分割一次
        header, data = get_buffer(tcp_socket).split(b"\r\n\r\n", 1)
        print(header.decode("utf-8"))
        with open("test.html", "wb") as f:
            f.write(data)
    print("over")

if __name__ == '__main__':
    main()

from socket import socket

def main():
    # 默认就是创建tcp socket
    with socket() as tcp_socket:
        # 连接服务器（没有返回值）
        tcp_socket.connect(("192.168.36.235", 8080))

        print("connected tcp server...")  # 连接提示

        # 发送消息（返回发送的字节数）
        tcp_socket.send("小张生日快乐～\n".encode("utf-8"))
        # 接收消息
        msg = tcp_socket.recv(1024)
        print(f"服务器：{msg.decode('utf-8')}")

if __name__ == '__main__':
    main()

from socket import socket

def main():
    with socket() as tcp_socket:
        # 绑定端口（便于客户端找到）
        tcp_socket.bind(('', 8080))
        # 变成被动接收消息（监听）
        tcp_socket.listen()  # 不指定连接最大数则会设置默认值

        print("tcp server is running...")  # 运行后提示

        # 等待客户端发信息
        client_socket, client_addr = tcp_socket.accept()

        with client_socket:
            # 客户端连接提示
            print(f"[来自{client_addr[0]}:{client_addr[1]}的消息]\n")

            # 接收客户端消息
            data = client_socket.recv(1024)
            print(data.decode("utf-8"))

            # 回复客户端
            client_socket.send("知道了".encode("utf-8"))

if __name__ == '__main__':
    main()

from time import sleep
from socket import socket
from multiprocessing.dummy import pool

def send_msg(tcp_socket):
    with tcp_socket:
        while true:
            try:
                tcp_socket.send("小明同志\n".encode("utf-8"))
                sleep(2)  # send是非阻塞的
                print("向服务器问候了一下")
            except exception as ex:
                print("服务端连接已断开:", ex)
                break

def recv_msg(tcp_socket):
    with tcp_socket:
        while true:
            # 这边可以不捕获异常：
            #    服务端关闭时，send_msg会关闭，然后这边也就关闭了
            try:
                data = tcp_socket.recv(1024)
                if data:
                    print("服务端回复：", data.decode("utf-8"))
            except exception as ex:
                print("tcp_socket已断开:", ex)
                break

def main():
    with socket() as tcp_socket:
        # 连接tcp server
        tcp_socket.connect(("192.168.36.235", 8080))
        print("connected tcp server...")  # 连接提示

        pool = pool()
        pool.apply_async(send_msg, args=(tcp_socket,))
        pool.apply_async(recv_msg, args=(tcp_socket,))
        pool.close()
        pool.join()

if __name__ == '__main__':
    main()

from socket import socket
from multiprocessing.dummy import pool

def wait_client(client_socket, ip_port):
    with client_socket:
        while true:
            data = client_socket.recv(1024)
            print(f"[来自{ip_port}的消息]:\n{data.decode('utf-8')}")
            client_socket.send(b"i know")  # bytes类型

def main():
    with socket() as tcp_socket:
        # 绑定端口
        tcp_socket.bind(('', 8080))
        # 服务器监听
        tcp_socket.listen()

        print("tcp server is running...")  # 运行后提示

        p = pool()
        while true:
            # 等待客户端连接
            client_socket, client_addr = tcp_socket.accept()
            ip_port = f"{client_addr[0]}:{client_addr[1]}"
            print(f"客户端{ip_port}已连接")
            # 响应多个客户端则需要多个线程来处理
            p.apply_async(wait_client, args=(client_socket, ip_port))

if __name__ == '__main__':
    main()

using system;
using system.text;
using system.net;
using system.net.sockets;
using system.threading.tasks;

namespace _2_tcp
{
    class program
    {
        static void main(string[] args)
        {
            using (var tcp_socket = new socket(addressfamily.internetwork, sockettype.stream, protocoltype.tcp))
            {
                var ip_addr = ipaddress.parse("192.168.36.235");
                // 服务器端绑定port
                tcp_socket.bind(new ipendpoint(ip_addr, 8080));
                // 服务器监听
                tcp_socket.listen(5);
                while (true)
                {
                    // 等待客户端连接
                    var client_socket = tcp_socket.accept();
                    // 远程端口
                    var client_point = client_socket.remoteendpoint;
                    task.run(() =>
                    {
                        while (true)
                        {
                            byte[] buffer = new byte[1024];
                            int count = client_socket.receive(buffer);
                            console.writeline($"来自{client_socket.remoteendpoint.tostring()}的消息:\n{encoding.utf8.getstring(buffer, 0, count)}");
                            client_socket.send(encoding.utf8.getbytes("知道了～"));
                        }
                    });
                }
            }
        }
    }
}

using system;
using system.text;
using system.net;
using system.net.sockets;

namespace client
{
    class program
    {
        static void main(string[] args)
        {
            using (var tcp_socket = new socket(addressfamily.internetwork, sockettype.stream, protocoltype.tcp))
            {
                // 连接服务器
                tcp_socket.connect(new ipendpoint(ipaddress.parse("192.168.36.235"), 8080));

                while (true)
                {
                    // 发送消息
                    tcp_socket.send(encoding.utf8.getbytes("服务器你好"));
                    // 接收服务器消息
                    byte[] buffer = new byte[1024];
                    int count = tcp_socket.receive(buffer);
                    console.writeline($"来自服务器的消息：{encoding.utf8.getstring(buffer, 0, count)}");
                }
            }
        }
    }
}

from socket import socket
from multiprocessing.dummy import pool

ip = "127.0.0.1"

def tcp_port(port):
    """ip：服务端ip，port：服务端port"""
    with socket() as tcp_socket:
        try:
            tcp_socket.connect((ip, port))
            print(f"[tcp port:{port} is open]")
        except exception:
            pass

def main():
    # 查看系统本地可用端口极限值 cat /proc/sys/net/ipv4/ip_local_port_range
    max_port = 60999
    global ip
    ip = input("请输入要扫描的ip地址：")
    print(f"正在对ip：{ip}进行端口扫描...")

    pool = pool()
    pool.map_async(tcp_port, range(max_port))
    pool.close()
    pool.join()

if __name__ == '__main__':
    main()