Here’s more fundamental Python programming knowledge to deepen your understanding:
### 15. **Tuples**
Tuples are similar to lists but are **immutable** (you can't modify their values after creation). They
are defined using parentheses `()`.
```python
coordinates = (10, 20)
print(coordinates[0]) # Output: 10
# coordinates[0] = 30 # This will cause an error because tuples are immutable
```
### 16. **Sets**
A **set** is an unordered collection of unique elements. Sets are defined using curly braces `{}` or the
`set()` function.
```python
fruits = {"apple", "banana", "cherry"}
fruits.add("orange") # Add an element
fruits.remove("banana") # Remove an element
```
- **Set Operations** (useful in many scenarios):
```python
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2) # Union: {1, 2, 3, 4, 5}
print(set1 & set2) # Intersection: {3}
print(set1 - set2) # Difference: {1, 2}
```
### 17. **List Comprehensions**
A powerful way to create lists in a concise manner.
```python
squares = [x**2 for x in range(10)]
print(squares) # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
```
You can also add conditions:
```python
evens = [x for x in range(10) if x % 2 == 0]
print(evens) # Output: [0, 2, 4, 6, 8]
```
### 18. **Dictionary Comprehensions**
Similarly, you can generate dictionaries using comprehension.
```python
squares = {x: x**2 for x in range(5)}
print(squares) # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
```
### 19. **Lambda Functions**
**Lambda** functions are anonymous, small, single-expression functions. They are often used in
situations where a simple function is required temporarily.
```python
add = lambda x, y: x + y
print(add(2, 3)) # Output: 5
```
- **Using Lambdas with functions like `map()` and `filter()`**:
```python
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, numbers)) # Squares all numbers
print(squares) # Output: [1, 4, 9, 16, 25]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) # Filters even numbers
print(even_numbers) # Output: [2, 4]
```
### 20. **Classes and Objects (Object-Oriented Programming)**
Python supports object-oriented programming. A **class** is like a blueprint for creating objects.
```python
class Dog:
def __init__(self, name, age):
self.name = name # instance variable
self.age = age
def bark(self):
print(f"{self.name} says Woof!")
my_dog = Dog("Rex", 5)
my_dog.bark() # Output: Rex says Woof!
```
- **Instance vs Class Variables**:
```python
class Animal:
species = "Dog" # Class variable
def __init__(self, name):
self.name = name # Instance variable
a1 = Animal("Rex")
print(a1.species) # Output: Dog
```
### 21. **Inheritance**
Python supports inheritance, where one class can inherit attributes and methods from another class.
```python
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a sound.")
class Dog(Animal): # Inherit from Animal
def speak(self):
print(f"{self.name} barks.")
my_dog = Dog("Rex")
my_dog.speak() # Output: Rex barks.
```
### 22. **Iterators**
An **iterator** is an object that contains a countable number of values and can be iterated upon.
```python
my_list = [1, 2, 3]
my_iter = iter(my_list)
print(next(my_iter)) # Output: 1
print(next(my_iter)) # Output: 2
```
### 23. **Generators**
Generators are functions that yield values one at a time, making them memory efficient for large data
sets.
```python
def my_generator():
for i in range(3):
yield i # yields values one at a time
for value in my_generator():
print(value) # Output: 0, 1, 2
```
### 24. **Decorators**
Decorators allow you to modify the behavior of a function or method.
```python
def decorator_function(original_function):
def wrapper_function():
print("Wrapper executed before the function")
return original_function()
return wrapper_function
@decorator_function
def display():
print("Display function ran")
display()
# Output:
# Wrapper executed before the function
# Display function ran
```
### 25. **Context Managers (with statement)**
The `with` statement simplifies resource management, like working with files.
```python
with open('example.txt', 'r') as file:
data = file.read()
```
This automatically closes the file when you're done reading.
### 26. **Error Handling with Multiple Exceptions**
You can handle multiple exceptions using multiple `except` blocks or a tuple.
```python
try:
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero.")
except ValueError:
print("Invalid value.")
```
### 27. **Regular Expressions (Regex)**
Python supports regular expressions, which allow pattern matching in strings. The `re` module is used
for this.
```python
import re
pattern = r"\b[a-z]+\b"
text = "Python is fun"
matches = re.findall(pattern, text)
print(matches) # Output: ['ython', 'is', 'fun']
```
### 28. **List vs Tuple vs Set vs Dictionary**
- **List**: Ordered, mutable collection. Allows duplicates.
- **Tuple**: Ordered, immutable collection. Allows duplicates.
- **Set**: Unordered, mutable collection. No duplicates allowed.
- **Dictionary**: Unordered, mutable collection of key-value pairs. Keys must be unique.
### 29. **Command-Line Arguments**
Python can accept arguments from the command line using the `sys` module.
```python
import sys
print("Arguments:", sys.argv)
```
### 30. **Python Virtual Environments**
Virtual environments allow you to create isolated Python environments for different projects, ensuring
that dependencies don't conflict.
- Create a virtual environment:
```bash
python -m venv myenv
```
- Activate the virtual environment:
- On Windows:
```bash
myenv\Scripts\activate
```
- On Mac/Linux:
```bash
source myenv/bin/activate
```
These concepts will help you cover a wider range of Python programming, including object-oriented
design, error handling, and working with various data types.
