Automation

Using sed and awk

1. Text Processing: Both sed and awk are designed to process and manipulate text, line by line. They can be used to search, filter, modify, and extract data from text files.

2. Pattern Matching: Both tools allow for pattern matching using regular expressions, making them useful for searching for specific text patterns in files or data streams.

3. Command-line Utilities: Both sed and awk are primarily used from the command line or in shell scripts. They are widely available on Unix-like systems, including Linux and macOS.

4. Non-interactive Editing: Unlike interactive editors like vi or nano, both sed and awk can perform automated, non-interactive edits on text files.

Differences Between sed and awk

Despite their similarities, sed and awk are quite different in their design and typical use cases.

Use Cases and Examples

sed for Simple Text Substitution

The main strength of sed lies in its ability to perform simple, line-based transformations, such as search-and-replace operations.

Example: Replacing Text Using sed

Let’s say you have a file example.txt containing the following lines:

I love Linux.
Linux is great.

If you want to replace “Linux” with “Unix”, you can use sed like this:

sed 's/Linux/Unix/g' example.txt

Output:

I love Unix.
Unix is great.

Here, s/old/new/g performs a global substitution, replacing “Linux” with “Unix” throughout the file.

awk for Field-based Data Processing**

While sed is limited to line-based operations, awk is designed for more complex tasks, especially those involving structured data with fields, such as CSV or log files.

Example: Extracting and Summing Fields Using awk

Suppose you have a file data.txt with the following tab-separated values:

Alice   90
Bob     85
Carol   88

To print the second column (the scores) and calculate the total score using awk:

awk '{ total += $2 } END { print "Total:", total }' data.txt

Output:

Total: 263

Here, $2 refers to the second field, and awk processes each line, accumulating the scores in the total variable. The END block runs after all lines have been processed and prints the result.

3. Advanced Pattern Matching with sed

Although sed is simpler, it can still handle more advanced regular expressions for pattern matching.

Example: Deleting Lines Matching a Pattern

Suppose you want to delete all lines in log.txt that contain the word “ERROR”:

sed '/ERROR/d' log.txt

This deletes all lines containing “ERROR” in the file.

4. Advanced Data Transformation with awk

awk is extremely powerful when it comes to transforming structured data. It can even perform conditional logic and arithmetic.

Example: Conditional Processing and Reporting

Consider a file employees.txt:

Alice   90
Bob     85
Carol   88
David   92

If you want to print the names of employees who scored above 85:

awk '$2 > 85 { print $1 }' employees.txt

Output:

Alice
Carol
David

Here, the condition $2 > 85 checks if the score (second field) is greater than 85, and if true, it prints the first field ($1, the name).

When to Use sed or awk

Use sed When:

• You need to make simple text substitutions or deletions (e.g., replacing words, removing lines).
• Your task only involves line-by-line processing.
• You prefer a simpler, easier-to-read syntax for basic text operations.

Use awk When:

• You need to process structured data (e.g., CSV, log files, tabular data).
• Your task involves more complex logic like filtering, field extraction, or summarizing data.
• You need to handle multiple fields within a line or perform arithmetic operations on data.

Combining sed and awk

Sometimes, the strengths of both sed and awk can be combined in a single pipeline for even more powerful text processing.

Example: Using sed and awk Together

Suppose you have a file log.txt:

2024-01-01 ERROR Something bad happened.
2024-01-02 INFO All systems operational.
2024-01-03 ERROR Another error occurred.

You want to extract only the dates from lines containing “ERROR”:

sed -n '/ERROR/p' log.txt | awk '{ print $1 }'

• sed -n '/ERROR/p' filters only the lines containing “ERROR”.
• The output is then piped into awk '{ print $1 }', which extracts the first field (the date).

Output:

2024-01-01
2024-01-03

Introduction to POSIX and BASH Scripting

POSIX (Portable Operating System Interface) enables portability not just for scripting, but for applications and system utilities across different Unix-like operating systems, including Linux. By adhering to POSIX standards, developers can write software that is more portable and interoperable across multiple platforms, ensuring that the same scripts, commands, and programs will work consistently on different systems that support POSIX, such as Linux, macOS, and some versions of BSD.

What is BASH Scripting?

BASH scripting is the process of writing a series of commands for the BASH shell to execute. These scripts can automate repetitive tasks, manipulate files, and manage system operations. Because BASH is POSIX-compliant, scripts written in BASH can often be run on any system that supports POSIX standards, making them highly portable.

For example, most software distributions use POSIX compliant operations to minimize the cross platform efforts through the “./configure && make && make install” pattern that runs a script (./configure) which checks for compliance with needed functions, runs the make operation to complile the software, and then make install in order to install the software. Examples of cross-operating system POSIX commands include things like ls, cp, mv, grep, awk and sed. In addition, redirection (>, >>) and piping (|) are cross platform. However POSIX compliance between operating systems includes elements like File System Operations ( open(), read(), write(), chmod() ), Process Management like creation ( fork(), exec() ), and process control ( kill(), wait(), exit() ), Threading, I/O operations like read(), write(), and printf(), Signals and Signal Handling such as Ctrl+C killing a process, networking socket() and connect() operations, as well as User and Group management as well as Time and Date functions are usable across POSIX compatible systems.

Basic Syntax in BASH

Before diving into the specifics of operands and scripting capabilities, it’s important to understand the basic structure of a BASH script.

• Shebang (#!): The first line of a BASH script typically starts with a shebang, which indicates the script should be run in the BASH shell.

bash #!/bin/bash

• Comments (#): Any line starting with # is treated as a comment and is ignored by the shell.

bash # This is a comment

• Commands: Each line in the script usually represents a command that the shell will execute.

bash echo "Hello, World!"

Common Operands in BASH

Operands are essential components in BASH scripting, used in conjunction with commands and operators to perform various tasks, such as file manipulation, arithmetic operations, and condition checking.

Arithmetic Operands

BASH supports basic arithmetic operations using the following operands:

• Addition (+):

bash sum=$((3 + 5)) echo $sum # Outputs: 8

• Subtraction (-):

bash difference=$((10 - 4)) echo $difference # Outputs: 6

• Multiplication (*):

bash product=$((4 * 5)) echo $product # Outputs: 20

• Division (/):

bash quotient=$((20 / 4)) echo $quotient # Outputs: 5

• Modulus (%):

bash remainder=$((10 % 3)) echo $remainder # Outputs: 1

Comparison Operands

Comparison operands are used to compare values and are often used in conditional statements.

• Equal (-eq):

bash if [ 5 -eq 5 ]; then echo "Equal" fi

• Not Equal (-ne):

bash if [ 5 -ne 4 ]; then echo "Not equal" fi

• Greater Than (-gt):

bash if [ 10 -gt 5 ]; then echo "Greater" fi

• Less Than (-lt):

bash if [ 3 -lt 8 ]; then echo "Less" fi

• Greater Than or Equal (-ge):

bash if [ 7 -ge 7 ]; then echo "Greater or Equal" fi

• Less Than or Equal (-le):

bash if [ 2 -le 4 ]; then echo "Less or Equal" fi

File Test Operands

BASH provides a variety of operands to test file attributes:

• File Exists (-e):

bash if [ -e /path/to/file ]; then echo "File exists" fi

• File is a Directory (-d):

bash if [ -d /path/to/directory ]; then echo "Directory exists" fi

• File is Readable (-r):

bash if [ -r /path/to/file ]; then echo "File is readable" fi

• File is Writable (-w):

bash if [ -w /path/to/file ]; then echo "File is writable" fi

• File is Executable (-x):

bash if [ -x /path/to/file ]; then echo "File is executable" fi

4. String Operands

Operands can also be used to manipulate and compare strings.

• String Equality (=):

bash if [ "hello" = "hello" ]; then echo "Strings are equal" fi

• String Inequality (!=):

bash if [ "hello" != "world" ]; then echo "Strings are not equal" fi

• String Length (-z for zero length, -n for non-zero length):

bash str="" if [ -z "$str" ]; then echo "String is empty" fi

bash str="hello" if [ -n "$str" ]; then echo "String is not empty" fi

Writing a Simple BASH Script

Let’s put these concepts into practice by writing a simple BASH script that checks if a user-provided file exists and whether it is readable.

• Create a New Script File:

bash nano file_check.sh

• Add the Script Content:

```bash #!/bin/bash # Script to check if a file exists and is readable

echo “Enter the path to the file:” read file_path

if [ -e “$file_path” ]; then echo “File exists.” if [ -r “$file_path” ]; then echo “File is readable.” else echo “File is not readable.” fi else echo “File does not exist.” fi ```

• Explanation:

  The script prompts the user to enter the path to a file.

  It checks if the file exists using -e.

  If the file exists, it further checks if the file is readable using -r.

• Make the Script Executable:

bash chmod +x file_check.sh

• Run the Script:

bash ./file_check.sh

• Sample Output:

  bash Enter the path to the file: /etc/passwd File exists. File is readable.

Advanced BASH Scripting Concepts

Once you’re comfortable with basic operands and scripting, you can explore more advanced concepts such as loops, functions, and command-line arguments to create more sophisticated scripts.

• Loops:

```bash #!/bin/bash # Loop through a list of files

for file in /etc/*.conf; do if [ -r “$file” ]; then echo “Processing $file” fi done ```

• Functions:

```bash #!/bin/bash # Define a function

greet() { echo “Hello, $1!” }

greet “World” ```

• Command-Line Arguments:

```bash #!/bin/bash # Script that takes a filename as an argument

if [ -e “$1” ]; then echo “File $1 exists.” else echo “File $1 does not exist.” fi ```

What is Python Scripting?

Python is a versatile, high-level programming language that is widely used for various types of software development, including web development, data analysis, machine learning, and automation. Unlike BASH, which excels in automating command-line tasks, Python is ideal for more complex scripting and application development due to its powerful libraries, readability, and broad applicability.

We’re going to explore the fundamentals of Python scripting, focusing on basic syntax, commonly used operators, and how to leverage these tools to write effective Python scripts.

Python scripting involves writing Python code that can be executed to perform specific tasks. Python scripts are often used for automating repetitive tasks, manipulating data, and integrating systems. Python’s simplicity and readability make it a great choice for both beginners and experienced developers.

Basic Syntax in Python

Before diving into the specifics of operators and scripting capabilities, it’s important to understand the basic structure of a Python script.

• Comments (#): Any line starting with # is treated as a comment and is ignored by the Python interpreter.

python # This is a comment

• Print Statement: The print() function is used to output text or variables to the console.

python print("Hello, World!")

• Variables: Variables in Python are dynamically typed, meaning you don’t need to declare their type explicitly.

python message = "Hello, World!"

Common Operators in Python

Operators are essential components in Python, used to perform various operations such as arithmetic, comparison, and logical operations.

Arithmetic Operators

Python supports basic arithmetic operations:

• Addition (+):

python sum = 3 + 5 print(sum) # Outputs: 8

• Subtraction (-):

python difference = 10 - 4 print(difference) # Outputs: 6

• Multiplication (*):

python product = 4 * 5 print(product) # Outputs: 20

• Division (/):

python quotient = 20 / 4 print(quotient) # Outputs: 5.0

• Modulus (%):

python remainder = 10 % 3 print(remainder) # Outputs: 1

• Exponentiation (**):

python power = 2 ** 3 print(power) # Outputs: 8

Comparison Operators

Comparison operators are used to compare values and return True or False.

• Equal (==):

python if 5 == 5: print("Equal")

• Not Equal (!=):

python if 5 != 4: print("Not equal")

• Greater Than (>):

python if 10 > 5: print("Greater")

• Less Than (<):

python if 3 < 8: print("Less")

• Greater Than or Equal (>=):

python if 7 >= 7: print("Greater or Equal")

• Less Than or Equal (<=):

python if 2 <= 4: print("Less or Equal")

Logical Operators

Logical operators are used to combine multiple conditions.

• And (and):

python if 5 > 2 and 5 < 10: print("Both conditions are True")

• Or (or):

python if 5 > 2 or 5 > 10: print("At least one condition is True")

• Not (not):

python if not (5 > 10): print("Condition is False")

String Operators

Python provides several operators for working with strings.

• Concatenation (+):

python greeting = "Hello, " + "World!" print(greeting) # Outputs: Hello, World!

• Repetition (*):

python echo = "Hello! " * 3 print(echo) # Outputs: Hello! Hello! Hello!

• Membership (in):

python message = "Hello, World!" if "World" in message: print("Found 'World' in message")

Writing a Simple Python Script

Let’s put these concepts into practice by writing a simple Python script that checks if a user-provided number is positive, negative, or zero.

• Create a New Script File:

bash nano check_number.py

• Add the Script Content:

```python # check_number.py # Script to check if a number is positive, negative, or zero

number = float(input(“Enter a number: “))

if number > 0: print(“The number is positive.”) elif number < 0: print(“The number is negative.”) else: print(“The number is zero.”)

   - Explanation:

     The script prompts the user to enter a number.

     It converts the input to a floating-point number.

     It then checks whether the number is positive, negative, or zero using conditional statements.

- Run the Script:

   ```bash
   python3 check_number.py
   ```

   - Sample Output:
     ```bash
     Enter a number: 10
     The number is positive.
     ```

### Advanced Python Scripting Concepts

Once you’re comfortable with basic operators and scripting, you can explore more advanced concepts such as loops, functions, and modules to create more sophisticated scripts.

- Loops:

  ```python
  # Script to print numbers from 1 to 5

  for i in range(1, 6):
      print(i)
  ```

- Functions:

  ```python
  # Script with a function to greet a user

  def greet(name):
      print(f"Hello, {name}!")

  greet("Alice")
  ```

- Modules:

  ```python
  # Using the math module to calculate the square root of a number

  import math

  number = 16
  sqrt = math.sqrt(number)
  print(f"The square root of {number} is {sqrt}")
  ```

- Handling Command-Line Arguments:

  ```python
  # Script to print the first command-line argument

  import sys

  if len(sys.argv) > 1:
      print(f"First argument: {sys.argv[1]}")
  else:
      print("No arguments provided.")
  ```

### Networking and Sockets with Python

Networking is the backbone of modern computing, enabling devices to communicate and share resources across the globe. Understanding how networking works, from IP addressing to sockets, is crucial for anyone involved in software development, system administration, or IT. In this tutorial, we will cover the basics of networking, including IP addressing, subnetting, DNS, and network protocols. 

### IP Addressing

IP (Internet Protocol) addresses are unique identifiers assigned to devices on a network. They are essential for routing data to the correct destination.

#### Types of IP Addresses

1. IPv4:
    - Format: Consists of four decimal numbers (ranging from 0 to 255) separated by periods (e.g., 192.168.2.1).
    - Address Space: Provides approximately 4.3 billion unique addresses because it uses a 32-bit address space.
    - Example: A typical home router might have an address like 192.168.0.1.

2. IPv6:
    - Format: Uses eight groups of four hexadecimal digits separated by colons (e.g., 2606:2800:21f:cb07:6820:80da:af6b:8b2c).
    - Address Space: Provides an enormous number of unique addresses (approximately 3.4 x $10^{38}$ because it uses a 128-bit address space.
    - Example: An IPv6 address might look like 2606:2800:21f:cb07:6820:80da:af6b:8b2c.

### Subnetting

Subnetting involves dividing a larger network into smaller, more manageable sub-networks or subnets. This enhances network efficiency and security by reducing broadcast domains and isolating network segments.

- Example: Consider the IP address 192.168.2.1 with a subnet mask of 255.255.255.0. The subnet mask indicates that the first three octets (192.168.2) represent the network address, while the last octet (1) is the host address.

### DNS (Domain Name System)

DNS translates human-readable domain names into IP addresses that computers use to communicate. This system is fundamental to accessing websites and online services.

- Example: When you type "www.example.com" into your browser, DNS resolves this domain name to an IP address like 93.184.215.14, allowing your browser to connect to the correct server.

## Network Protocols

### Transport Layer Protocols:
1. **TCP (Transmission Control Protocol)**:
   - **Role**: TCP is a core protocol of the transport layer that provides reliable, connection-oriented communication between devices. It ensures that data is delivered error-free, in order, and without duplication. TCP establishes a connection before data transmission and requires acknowledgment from the recipient.
   - **Common Ports**: TCP operates on ports ranging from 0 to 65535. Some well-known ports include port 80 for HTTP (web traffic), port 443 for HTTPS (secure web traffic), port 22 for SSH, and port 21 for FTP.
   - **Use Case**: Web browsing, secure communication, and file transfers often rely on TCP due to its reliability.

2. **UDP (User Datagram Protocol)**:
   - **Role**: Unlike TCP, UDP is a connectionless protocol that focuses on speed rather than reliability. It sends data without waiting for acknowledgments, making it faster but less reliable (packets can be lost or out of order). This is often used in time-sensitive applications like video streaming or gaming where speed is more critical than perfect accuracy.
   - **Common Ports**: Similar to TCP, UDP also uses port numbers from 0 to 65535. Common examples include port 53 for DNS, ports 67 and 68 for DHCP, and port 69 for TFTP (Trivial File Transfer Protocol).
   - **Use Case**: Streaming services, VoIP (voice over IP), and online gaming often use UDP.

### Sockets:
- **Role**: Sockets are an abstraction layer that allows network communication through both TCP and UDP. A socket is an endpoint for sending and receiving data across a network, regardless of whether it uses TCP or UDP. This makes sockets essential for network programming.
- **Common Ports**: Since sockets work with both TCP and UDP, they depend on the specific protocol’s port numbers. They serve as the point where an application and the transport layer protocol (TCP/UDP) meet.

### Application Layer Protocols:
1. **HTTP (Hypertext Transfer Protocol)**:
   - **Role**: HTTP is an application layer protocol used for communication between web clients (like browsers) and web servers. It enables the transfer of hypertext, images, videos, and other content over the web. It is foundational to how we browse the internet.
   - **Common Ports**: HTTP generally uses port 80, while HTTPS (the secure version of HTTP) uses port 443. Both rely on TCP to ensure reliable data transmission.
   - **Use Case**: Loading web pages and interacting with web services.

2. **FTP (File Transfer Protocol)**:
   - **Role**: FTP is an application layer protocol designed for transferring files between a client and server over a network. It supports file uploads and downloads in a straightforward way.
   - **Common Ports**: FTP uses port 21 for controlling the connection and port 20 for transferring data. It operates over TCP to ensure reliability.
   - **Use Case**: Uploading or downloading files to and from servers.

### 1. **What is a Socket?**
A socket is an abstraction that allows programs to communicate over a network. It serves as an endpoint for sending and receiving data, and is associated with an IP address and port number. Sockets support both **connection-oriented** protocols (like TCP) and **connectionless** protocols (like UDP).

There are two main types of sockets:
- **Stream Sockets** (used for TCP)
- **Datagram Sockets** (used for UDP)

### 2. **How Sockets Work in Data Transmission:**
Let's break it down by protocol type:

#### **A. Stream Sockets (TCP)**
When using a **stream socket** for data transmission, the underlying protocol is TCP, which provides reliable, connection-oriented communication. The process includes the following steps:

1. **Creating a Socket**:
   - The client and server each create a socket using the system call `socket()`. This sets up an endpoint for network communication.
   - The server typically binds the socket to a specific port and IP address using `bind()`.

2. **Connection Establishment**:
   - The client initiates a connection using `connect()`, attempting to connect to the server’s IP address and port.
   - The server, meanwhile, listens for incoming connections using `listen()` and accepts them using `accept()`.
   - A **three-way handshake** takes place to establish a connection:
     1. The client sends a **SYN** packet (synchronize) to the server.
     2. The server responds with a **SYN-ACK** (synchronize-acknowledge).
     3. The client sends an **ACK** (acknowledge), confirming the connection.

3. **Data Transmission**:
   - Once a connection is established, both client and server can use `send()` and `recv()` system calls to exchange data in a continuous stream. TCP ensures that the data is:
     - **Ordered**: Data packets are received in the same order they were sent.
     - **Reliable**: If packets are lost or corrupted, TCP requests retransmission.
     - **Error-checked**: Each packet has a checksum to ensure integrity.
     - **Flow-controlled**: TCP manages congestion to ensure the network isn’t overwhelmed.

4. **Connection Termination**:
   - After the data transmission is complete, the connection is closed using a **four-way handshake**: 
     1. One side sends a **FIN** packet to indicate it's done sending data.
     2. The other side responds with an **ACK**.
     3. The second side then sends its own **FIN**.
     4. The first side acknowledges with an **ACK**, completing the termination.

#### **B. Datagram Sockets (UDP)**
When using **datagram sockets**, the underlying protocol is UDP, which provides connectionless, faster but less reliable communication. Here's how it works:

1. **Creating a Socket**:
   - Both the client and server create sockets using the `socket()` system call.
   - UDP does not require the server to **bind** or **listen** for connections in the same way as TCP, but the server must bind to a specific port to receive data.

2. **No Connection Establishment**:
   - Unlike TCP, UDP does not establish a connection. The client can immediately start sending data using `sendto()`, and the server receives data using `recvfrom()`.

3. **Data Transmission**:
   - With UDP, each packet (called a **datagram**) is sent individually without guarantees of order or delivery. It’s up to the application to manage things like packet loss, reordering, or data integrity if needed. 
   - **No Acknowledgment**: Since UDP doesn’t wait for acknowledgment, it’s faster but less reliable. Packets might get lost or arrive out of order, but for real-time applications like video or voice streaming, speed is more important than reliability.

4. **No Connection Termination**:
   - Because there’s no connection, there’s no formal process for closing communication. Either side can stop sending or receiving at any time.

### 3. **Socket Components for Data Transmission:**
- **IP Address**: The address of the machine on the network. Sockets require an IP address to know where to send or receive data.
- **Port Number**: A unique identifier that distinguishes different services on the same machine. For example, port 80 is typically used for HTTP traffic, while port 22 is used for SSH.
- **Protocol (TCP/UDP)**: The transport protocol chosen determines how data is transmitted, either using a connection-oriented method (TCP) or a connectionless method (UDP).

### 4. **Socket API Functions for Data Transmission:**
- **`socket()`**: Creates a new socket, specifying the type of communication (stream for TCP, datagram for UDP).
- **`bind()`**: Associates the socket with a specific IP address and port number (usually used on the server side).
- **`listen()`**: In TCP, this tells the server to start listening for incoming connection requests.
- **`accept()`**: In TCP, this accepts an incoming connection from a client.
- **`connect()`**: In TCP, the client uses this to establish a connection with the server.
- **`send()`, `recv()`**: Used to send and receive data in TCP after the connection is established.
- **`sendto()`, `recvfrom()`**: Used to send and receive datagrams in UDP without a connection.
- **`close()`**: Terminates the socket connection.

### 5. **How Data is Sent and Received via Sockets**:
- **Sending Data**: The client or server uses `send()` (for TCP) or `sendto()` (for UDP) to transmit data. The data is broken into packets or datagrams and transmitted over the network.
- **Receiving Data**: The recipient uses `recv()` (for TCP) or `recvfrom()` (for UDP) to receive the incoming data. The system buffers incoming data in the socket until the application reads it.

### 6. **Error Handling and Flow Control**:
- **TCP**: Handles errors, ensures data is sent in sequence, and manages congestion through mechanisms like **windowing** and **retransmission**.
- **UDP**: Does not handle error correction or sequencing. It’s up to the application to manage any potential issues.

### Network Devices

Network devices play specific roles in managing and directing traffic within and between networks.

- Router: Directs data packets between different networks. Routers connect local networks to the internet.
   - Example: A home router connects a local area network (LAN) to the wider internet.

- Switch: Connects devices within the same network, enabling communication between them.
   - Example: An Ethernet switch used in a corporate LAN.

- Firewall: Controls incoming and outgoing network traffic based on predetermined security rules.
   - Example: A firewall can block unauthorized access while allowing legitimate traffic through.

### Understanding Sockets

Sockets are a low-level mechanism that enables network communication between devices. They act as endpoints for sending and receiving data over a network.

#### Types of Sockets

- Stream Sockets (TCP):
    - Connection-Oriented: A connection must be established before data can be transmitted.
    - Reliable: Ensures data is delivered in the correct order and without errors.
    - Example: Used for applications like web browsing and email.

- Datagram Sockets (UDP):
    - Connectionless: Data is sent without establishing a connection.
    - Unreliable: There is no guarantee of data delivery or order.
    - Example: Used for applications like online gaming and video streaming.

### Creating a Socket in Python

Python provides a powerful library called `socket` that allows you to create and manage network connections using sockets. Here's a basic example of how to create a TCP socket in Python:

#### Step-by-Step: Creating a TCP Socket

- Import the socket library

   ```python
   import socket
   ```

- Create a socket object

   ```python
   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   ```

   - `socket.AF_INET`: Specifies the address family for IPv4.
   - `socket.SOCK_STREAM`: Specifies that the socket is a TCP socket.

- Connect to a server

   ```python
   s.connect(('www.example.com', 80))
   ```

   - This connects the socket to a server at `www.example.com` on port `80` (HTTP).

- Send a request

   ```python
   request = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"
   s.send(request.encode())
   ```

   - This sends an HTTP GET request to the server.

- Receive a response

   ```python
   response = s.recv(4096)
   print(response.decode())
   ```

   - This receives up to 4096 bytes of data from the server and prints it.

- Close the socket

   ```python
   s.close()
   ```

   - Always close the socket when you're done with it to free up resources.

#### Example

```python
import socket

## Create a socket object
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

## Connect to the server
s.connect(('www.example.com', 80))

## Send an HTTP GET request
request = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"
s.send(request.encode())

## Receive the response
response = s.recv(4096)
print(response.decode())

## Close the socket
s.close()

Explanation of the Example

• Creating the Socket: The socket() function creates a new socket object using the IPv4 address family and the TCP protocol.
• Connecting to a Server: The connect() method connects the socket to a remote server. Here, it connects to www.example.com on port 80.
• Sending Data: The send() method sends data through the socket. In this case, it sends a simple HTTP GET request.
• Receiving Data: The recv() method reads the response from the server. The argument 4096 specifies the maximum amount of data to be received at once.
• Closing the Socket: The close() method closes the socket, freeing up any resources it was using.