Python is a high-level, interpreted programming language known for its simplicity, readability, and versatility. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Python is widely used for web development, scientific computing, data analysis, artificial intelligence, automation, and more.
Here's a simple example of Python code:
python# This is a Python script to calculate the area of a circle
# Define a function to calculate the area of a circle
def calculate_area(radius):
return 3.14 * radius ** 2 # Using the formula π * r^2 to calculate area
# Prompt the user to enter the radius of the circle
radius = float(input("Enter the radius of the circle: "))
# Call the calculate_area function with the user-input radius and store the result
area = calculate_area(radius)
# Display the calculated area
print("The area of the circle with radius", radius, "is:", area)Explanation of the example:
1. We define a function `calculate_area(radius)` that takes the radius of a circle as input and calculates its area using the formula π * r^2.
2. We prompt the user to enter the radius of the circle using `input()` function. The `float()` function is used to convert the user input (which is a string) to a floating-point number.
3. We call the `calculate_area()` function with the user-input radius and store the result in the variable `area`.
4. Finally, we print the calculated area using the `print()` function.
When you run this Python script and input a radius value, it will calculate and display the area of the circle with that radius.
This example demonstrates the simplicity and readability of Python code, as well as its ability to perform mathematical calculations. Python's interactive nature makes it great for tasks like data analysis, scripting, and quick prototyping.
Certainly! Let's delve deeper into Python and its features with another example:
python# This Python script simulates a simple banking system
class Account:
def __init__(self, account_number, balance):
self.account_number = account_number
self.balance = balance
def deposit(self, amount):
self.balance += amount
print("Deposited:", amount)
def withdraw(self, amount):
if amount <= self.balance:
self.balance -= amount
print("Withdrawn:", amount)
else:
print("Insufficient balance")
def display_balance(self):
print("Account Number:", self.account_number)
print("Balance:", self.balance)
# Creating a new account
my_account = Account("123456789", 1000)
# Performing transactions
my_account.display_balance()
my_account.deposit(500)
my_account.withdraw(200)
my_account.display_balance()Explanation:
1. We define a class `Account` to represent a bank account. It has attributes `account_number` and `balance`, and methods `deposit`, `withdraw`, and `display_balance` to perform various operations on the account.
2. The `__init__` method is a constructor used to initialize the account with an account number and initial balance.
3. The `deposit` method allows depositing money into the account. It increases the balance by the deposited amount.
4. The `withdraw` method allows withdrawing money from the account. It checks if the withdrawal amount is less than or equal to the current balance before deducting the amount. If the balance is sufficient, it deducts the amount; otherwise, it displays an "Insufficient balance" message.
5. The `display_balance` method prints the account number and current balance.
6. We create a new account `my_account` with an account number "123456789" and an initial balance of 1000.
7. We perform transactions on the account:
- Display the initial balance.
- Deposit 500 into the account.
- Withdraw 200 from the account.
8. Finally, we display the updated balance after the transactions.
This example illustrates several key aspects of Python:
- Object-oriented programming: Python supports classes and objects, allowing for the creation of reusable and organized code.
- Encapsulation: Data and methods related to an account are encapsulated within the `Account` class.
- Method invocation: We call methods on the `my_account` object to perform operations like depositing, withdrawing, and displaying balance.
- Readability: Python's syntax emphasizes readability, making the code intuitive and easy to understand.
