0Pricing
Linux Networking & TCP/IP for Developers · 课时

Socket API 入门

探索套接字编程的核心概念，包括套接字类型、地址和常见 API 调用

Socket API 入门 是 CoddyKit 上的免费 Linux Networking & TCP/IP for Developers 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Linux Networking & TCP/IP for Developers 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Linux Networking & TCP/IP for Developers 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

What are Network Sockets?

Welcome to socket programming! A socket is a crucial concept in network communication. Think of it as one endpoint of a two-way communication link between two programs running on the network.

It's like a phone jack on a wall. You plug a phone into it to connect to the phone network. Similarly, programs use sockets to connect and talk over a computer network.

Python's Socket Module

Python makes socket programming accessible through its built-in socket module. This module provides all the necessary functions and classes to create and manage sockets.

You'll typically import it at the beginning of your script. Let's see how to get started:

import socket

# Now you can use socket functions!

Socket Address Families

Before creating a socket, we need to specify its address family. This determines the type of addresses the socket can work with.

  • socket.AF_INET: Used for IPv4 addresses (e.g., 192.168.1.1). This is the most common.
  • socket.AF_INET6: Used for IPv6 addresses.
  • socket.AF_UNIX: Used for communication between processes on the same machine.

We'll primarily use AF_INET for standard internet communication.

Socket Types: Stream vs. Datagram

Next, we choose the socket type, which defines the communication style.

  • socket.SOCK_STREAM: This type uses TCP (Transmission Control Protocol). It's reliable, ordered, and connection-oriented, like a phone call. Data arrives exactly as sent.
  • socket.SOCK_DGRAM: This type uses UDP (User Datagram Protocol). It's connectionless and less reliable, like sending postcards. Data might arrive out of order or not at all.

Most common applications, especially web browsing, use SOCK_STREAM.

Creating Your First Socket

Now let's put it together and create a basic socket object. We'll specify the address family (IPv4) and the socket type (TCP stream).

This line creates an inactive socket that's ready to be configured for either client or server roles.

import socket

# Create a TCP/IP socket
my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

print(f"Socket created: {my_socket}")
# Don't forget to close sockets when done!
my_socket.close()

Binding a Socket (Server Side)

For a server, the socket needs an address to listen on. This is called binding. You assign an IP address and a port number to your socket.

Clients will use this address and port to connect to your server. A port is a number that identifies a specific application or service on a host.

import socket

HOST = '127.0.0.1'  # Localhost
PORT = 65432        # Port to listen on (> 1023 for non-privileged)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    print(f"Socket bound to {HOST}:{PORT}")
    # The socket is now bound, but not yet listening or accepting.

Listening for Connections

After binding, a server socket must listen for incoming client connections. The listen() method puts the socket into server mode.

The argument to listen() is the backlog, which is the maximum number of unaccepted connections that the system will allow before refusing new connections.

import socket

HOST = '127.0.0.1'
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen(1) # Allow 1 pending connection
    print(f"Server listening on {HOST}:{PORT}")
    # Now the server is ready to accept a connection.

Accepting a Connection

When a client tries to connect, the server uses the accept() method. This method blocks (waits) until a client connects.

It then returns a new socket object (conn) representing the connection to the client, and the client's address (addr). All communication with the client happens via this new socket.

import socket

HOST = '127.0.0.1'
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen(1)
    print("Waiting for a client connection...")
    # This part would typically be in a loop in a real server
    conn, addr = s.accept()
    with conn:
        print(f"Connected by {addr}")
        # Now 'conn' can be used to send/receive data to/from the client.

Connecting to a Server (Client Side)

A client socket doesn't bind; instead, it uses the connect() method to establish a connection with a server that is listening on a specific IP address and port.

Once connected, the client can immediately start sending and receiving data. Data is always exchanged as bytes.

import socket

HOST = '127.0.0.1'
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    try:
        s.connect((HOST, PORT))
        print(f"Connected to server at {HOST}:{PORT}")
        s.sendall(b'Hello from client!')
        data = s.recv(1024) # Receive up to 1024 bytes
        print(f"Received: {data.decode()}")
    except ConnectionRefusedError:
        print("Error: Server not running or not listening.")

Sending and Receiving Data

Once a connection is established, data can be exchanged using sendall() and recv().

  • socket.sendall(data): Sends all of the byte-like data to the connected socket. It keeps sending until all data is sent or an error occurs.
  • socket.recv(bufsize): Receives data from the socket. bufsize is the maximum number of bytes to be received at once. It returns an empty bytes object (b'') when the connection is closed.

Socket API Quick Check

Which of the following statements about Python's socket module and socket types is TRUE?

Recap: Intro to Sockets

Great job! In this lesson, you've taken your first steps into socket programming with Python. You learned:

  • What a network socket is and its role in communication.
  • About Python's socket module.
  • The difference between address families (AF_INET, AF_INET6) and socket types (SOCK_STREAM for TCP, SOCK_DGRAM for UDP).
  • The basic API calls: socket() for creation, bind() and listen() for servers, and connect() for clients.
  • How accept() handles incoming connections and how sendall()/recv() work.

Next, we'll dive deeper into building full TCP client-server applications!

常见问题解答

「Socket API 入门」课时是免费的吗？

是的 — 「Socket API 入门」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Linux Networking & TCP/IP for Developers 课程的其余内容，请升级到 CoddyKit PRO。 Linux Networking & TCP/IP for Developers 课程共包含 4 节课。

「Socket API 入门」这节课中我会学到什么？

探索套接字编程的核心概念，包括套接字类型、地址和常见 API 调用 你通过在浏览器中直接运行的动手代码来练习 Linux Networking & TCP/IP for Developers，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Linux Networking & TCP/IP for Developers 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Linux Networking & TCP/IP for Developers 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。

「Socket API 入门」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Linux Networking & TCP/IP for Developers 课中编写并运行代码吗？

能。每节 Linux Networking & TCP/IP for Developers 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. Socket API 入门
  2. TCP 客户端与服务器套接字
  3. UDP 客户端与服务器套接字
  4. 非阻塞套接字与 select()
← 返回 Linux Networking & TCP/IP for Developers