# Quick revision of python

**Print statement:**

The print() function is used to display output on the console.

Syntax: `print("Hello, World!")`

**Variables:**

Variables are used to store data in memory. In Python, you don't need to declare the type of variable before using it.

Syntax: `variable_name = value`

Example: `name = "John"`

**Data types:**

Python supports various data types, including integer, float, string, boolean, list, tuple, set, and dictionary.

Syntax: `variable_name = value`

Example: `age = 30`

**Conditional statements:**

Conditional statements are used to execute different blocks of code based on certain conditions.

Syntax:

```python
if condition:
    # code to execute if condition is true
elif condition:
    # code to execute if the first condition is false and this condition is true
else:
    # code to execute if both conditions are false
```

**Loops:**

Loops are used to execute a block of code repeatedly.

a. For loop:

```python

for variable in sequence:
    # code to execute for each value in the sequence
```

Example:

```python
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
```

b. While loop:

```python

while condition:
    # code to execute as long as the condition is true
```

Example:

```python
i = 0
while i < 5:
    print(i)
    i += 1
```

**Functions:**

Functions are used to group a set of related statements and reuse them throughout the program.

Syntax:

```python
def function_name(parameters):
    # code to execute
    return value
```

**Lists:**

Lists are used to store multiple items in a single variable. They are mutable, meaning their values can be changed.

Syntax: `my_list = [item1, item2, item3]`

Example: `fruits = ["apple", "banana", "cherry"]`

**Tuples:**

Tuples are used to store multiple items in a single variable. They are immutable, meaning their values cannot be changed.

Syntax: `my_tuple = (item1, item2, item3)`

Example: `fruits = ("apple", "banana", "cherry")`

**Dictionaries:**

Dictionaries are used to store key-value pairs. They are mutable, meaning their values can be changed.

Syntax: `my_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}`

Example: `person = {"name": "John", "age": 30, "city": "New York"}`

**Modules:**

Modules are used to organize code into reusable files. You can import modules in your program to use their functions and variables.

Syntax: `import module_name`

Example: `import math`

**File I/O:**

File I/O is used to read from and write to files on the computer.

a. Reading from a file:

```python

with open("filename.txt", "r") as f:
    contents = f.read()
```

Example:

```python
open("test.txt", "r") as f:
    contents = f.read()
    print(contents)
```

b. Writing to a file:

```python

with open("filename.txt", "w") as f:
    f.write("contents to write")
```

**Exception handling:**

Exception handling is used to catch and handle errors in a program.

Syntax:

```python
try:
    # code that might raise an exception
except ExceptionType:
    # code to handle the exception
```

Example:

```python
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
```

**Classes and objects:**

Classes and objects are used in object-oriented programming to define data structures and their behavior.

Syntax:

```python
class ClassName:
    def __init__(self, parameters):
        # code to initialize the object
    def method_name(self, parameters):
        # code to define a method
```

Example:

```python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def say_hello(self):
        print("Hello, my name is " + self.name)

john = Person("John", 30)
john.say_hello()
```

**Built-in functions:**

Python has many built-in functions that can be used to perform common tasks.

Syntax: `function_name(parameters)`

Example: `print("Hello, World!")`

**List comprehension:**

List comprehension is a concise way to create a list based on an existing list.

Syntax: `[expression for item in list if condition]`

Example: `squares = [x*x for x in range(1, 11)]`

**Lambda functions:**

Lambda functions are used to create small, anonymous functions. They are often used as arguments to higher-order functions.

Syntax: `lambda parameters: expression`

Example: `square = lambda x: x*x`

**Decorators:**

Decorators are used to modify the behavior of functions or classes.

Syntax:

```python
@decorator_function
def my_function(parameters):
    # code to define the function
```

Example:

```python
def my_decorator(function):
    def wrapper(*args, **kwargs):
        # code to modify the function
        return function(*args, **kwargs)
    return wrapper

@my_decorator
def my_function(parameters):
    # code to define the function
```

**Generators:**

Generators are used to create iterators. They are useful when you need to iterate over a large dataset that cannot fit into memory.

Syntax:

```python
def my_generator():
    # code to generate the data
    yield data
```

Example:

```python
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
```

**Regular expressions:**

Regular expressions are used to search for and manipulate text patterns.

Syntax: [`re.search`](http://re.search)`(pattern, string)`

Example: [`re.search`](http://re.search)`("[a-z]+", "Hello, World!")`

**Concurrency:**

Concurrency is used to run multiple tasks at the same time.

Syntax:

```python
pythonCopy codeimport threading

def my_function(parameters):
    # code to define the function

t1 = threading.Thread(target=my_function, args=(arguments,))
t1.start()
```

Example:

```python
import threading

def print_numbers():
    for i in range(1, 11):
        print(i)

def print_letters():
    for letter in "abcdefghij":
        print(letter)

t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_letters)
t1.start()
t2.start()
```