In Python, a
**function** is a reusable block of code designed to perform a specific task.
Functions help make code modular, easier to manage, and avoid repetition. You
can define your own functions or use built-in functions provided by Python.
### Syntax
of a Python Function:
```python
def
function_name(parameters):
# code block
return result
```
- **`def`**:
This keyword is used to define a function.
-
**`function_name`**: A unique name to identify the function.
-
**`parameters`**: Optional; these are values you can pass to the function.
- **`return`**:
Optional; this keyword is used to return a result from the function.
### Example
of a Simple Function:
```python
# Example: A
simple function to greet
def greet():
print("Hello, welcome!")
# Calling
the function
greet()
```
**Output:**
```
Hello,
welcome!
```
###
Functions with Parameters:
Functions
can take **parameters** (also called **arguments**) to work with dynamic
inputs.
```python
# Example:
Function with parameters
def
greet_person(name):
print(f"Hello, {name}!")
greet_person("Alice")
greet_person("Bob")
```
**Output:**
```
Hello,
Alice!
Hello, Bob!
```
In this
example, the function `greet_person()` takes the parameter `name` and uses it
to customize the greeting.
### Return
Values from Functions:
A function
can return a value using the `return` statement. This value can be used
elsewhere in the program.
```python
# Example:
Function that returns a value
def
add_numbers(a, b):
return a + b
result =
add_numbers(3, 5)
print(result)
```
**Output:**
```
8
```
Here, the
function `add_numbers()` takes two arguments, adds them, and returns the
result.
### Default
Parameters:
You can
provide **default values** to parameters. If no argument is passed when the
function is called, the default value will be used.
```python
# Example:
Function with default parameter
def
greet_person(name="Guest"):
print(f"Hello, {name}!")
greet_person() # Uses default value "Guest"
greet_person("Alice") # Uses provided argument "Alice"
```
**Output:**
```
Hello,
Guest!
Hello,
Alice!
```
### Keyword
Arguments:
When calling
a function, you can specify arguments by their parameter name, making the order
of arguments irrelevant.
```python
# Example:
Keyword arguments
def
describe_person(name, age, city):
print(f"{name} is {age} years old and lives
in {city}.")
describe_person(age=25,
city="New York", name="Alice")
```
**Output:**
```
Alice is 25
years old and lives in New York.
```
###
Variable-Length Arguments:
You can use
special syntax to define functions that accept an arbitrary number of arguments:
-
**`*args`**: For a variable number of positional arguments.
-
**`**kwargs`**: For a variable number of keyword arguments.
#### Using
`*args` (Variable Positional Arguments):
```python
# Example:
Function with *args
def
add_all(*args):
return sum(args)
result =
add_all(1, 2, 3, 4, 5)
print(result)
```
**Output:**
```
15
```
#### Using
`**kwargs` (Variable Keyword Arguments):
```python
# Example:
Function with **kwargs
def
display_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
display_info(name="Alice",
age=25, city="New York")
```
**Output:**
```
name: Alice
age: 25
city: New
York
```
###
Functions with Multiple Return Values:
Python
functions can return multiple values as a tuple.
```python
# Example: Returning
multiple values
def
get_info():
name = "Alice"
age = 25
city = "New York"
return name, age, city
person_name,
person_age, person_city = get_info()
print(person_name,
person_age, person_city)
```
**Output:**
```
Alice 25 New
York
```
### Lambda
Functions:
A **lambda
function** is a small anonymous function that can take any number of arguments
but has only one expression. It is used for short and simple functions.
```python
# Example:
Lambda function
add = lambda
a, b: a + b
result =
add(3, 5)
print(result)
```
**Output:**
```
8
```
### Scope of
Variables:
- **Local
variables**: Defined inside a function and can only be used within that
function.
- **Global
variables**: Defined outside all functions and can be used throughout the program.
```python
x = 10 # Global variable
def
my_function():
x = 5
# Local variable
print("Inside function:", x)
my_function()
print("Outside
function:", x)
```
**Output:**
```
Inside
function: 5
Outside
function: 10
```
### Summary:
- A function
is a block of reusable code to perform a specific task.
- Use the
`def` keyword to define a function.
- Functions
can accept parameters and return values.
- Default
and keyword arguments provide flexibility in how functions are called.
- You can
use `*args` and `**kwargs` for variable-length arguments.
- Lambda
functions are used for concise, single-expression functions.
