Scribd
Upload
0 views

python function

This document is a comprehensive guide on Python functions, covering their definition, syntax, and various features such as parameters, return statements, default arguments, keyword arguments, variable-length arguments, lambda functions, variable scope, and recursion. It includes examples and key takeaways to help understand the concepts. The guide emphasizes the importance of functions in organizing code and improving readability.

Uploaded by

Amadi Samuel
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
0 views

python function

This document is a comprehensive guide on Python functions, covering their definition, syntax, and various features such as parameters, return statements, default arguments, keyword arguments, variable-length arguments, lambda functions, variable scope, and recursion. It includes examples and key takeaways to help understand the concepts. The guide emphasizes the importance of functions in organizing code and improving readability.

Uploaded by

Amadi Samuel
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 4

# **Python Functions: A Complete Guide**

A **function** in Python is a reusable block of code that performs a specific task.


Functions help in organizing code, reducing repetition, and improving readability.

---

## **1. Defining a Function**


Use the `def` keyword followed by the function name and parentheses `()`.

### **Syntax:**
```python
def function_name(parameters):
"""Docstring (optional)"""
# Function body (code)
return value # Optional
```

### **Example:**
```python
def greet(name):
"""This function greets the user."""
print(f"Hello, {name}!")
```

---

## **2. Calling a Function**


To execute a function, call it by its name followed by parentheses.

```python
greet("Alice") # Output: Hello, Alice!
```

---

## **3. Parameters vs. Arguments**


- **Parameter** → Variable in the function definition.
- **Argument** → Value passed to the function when calling it.

```python
def add(a, b): # a and b are parameters
return a + b

result = add(3, 5) # 3 and 5 are arguments


print(result) # Output: 8
```

---

## **4. Return Statement**


- A function can return a value using `return`.
- If no `return` is given, it returns `None`.

```python
def square(x):
return x * x

print(square(4)) # Output: 16
```

---

## **5. Default Arguments**


You can set default values for parameters.

```python
def power(base, exponent=2): # Default exponent=2
return base ** exponent

print(power(3)) # Output: 9 (3^2)


print(power(3, 3)) # Output: 27 (3^3)
```

---

## **6. Keyword Arguments**


Pass arguments by parameter name (order doesn’t matter).

```python
def describe_pet(name, animal="dog"):
print(f"I have a {animal} named {name}.")

describe_pet(animal="cat", name="Whiskers")
# Output: I have a cat named Whiskers.
```

---

## **7. Variable-Length Arguments**


- `*args` → Accepts any number of positional arguments (as a **tuple**).
- `**kwargs` → Accepts any number of keyword arguments (as a **dictionary**).

### **Example with `*args`:**


```python
def sum_all(*numbers):
total = 0
for num in numbers:
total += num
return total

print(sum_all(1, 2, 3)) # Output: 6


```

### **Example with `**kwargs`:**


```python
def display_info(**details):
for key, value in details.items():
print(f"{key}: {value}")

display_info(name="Alice", age=25, city="New York")


# Output:
# name: Alice
# age: 25
# city: New York
```

---
## **8. Lambda (Anonymous) Functions**
- Small, one-line functions defined with `lambda`.
- No `return` statement needed.

### **Syntax:**
```python
lambda arguments: expression
```

### **Example:**
```python
double = lambda x: x * 2
print(double(5)) # Output: 10
```

---

## **9. Scope of Variables**


- **Local variable** → Defined inside a function (accessible only inside).
- **Global variable** → Defined outside a function (accessible everywhere).

```python
x = 10 # Global variable

def my_func():
y = 5 # Local variable
print(x + y) # Can access global x

my_func() # Output: 15
print(y) # Error: y is not defined globally
```

---

## **10. Recursion (Function Calling Itself)**


A function can call itself (useful for problems like factorial, Fibonacci).

### **Example (Factorial):**


```python
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)

print(factorial(5)) # Output: 120 (5! = 5*4*3*2*1)


```

---

## **Summary Table**
| Feature | Example |
|---------|---------|
| Define a function | `def greet():` |
| Return a value | `return x + y` |
| Default argument | `def func(a=1):` |
| Keyword argument | `func(name="Alice")` |
| Variable arguments | `*args`, `**kwargs` |
| Lambda function | `lambda x: x * 2` |
| Recursion | `factorial(n-1)` |

---

### **Key Takeaways**


✅ Functions are defined using `def`.
✅ Use `return` to send back a value.
✅ `*args` for multiple positional arguments.
✅ `**kwargs` for multiple keyword arguments.
✅ `lambda` for small anonymous functions.
✅ Recursion allows a function to call itself.

Would you like more examples or explanations on any part? 😊

You might also like