Basic Python

Data Types , Variables and Operators

Data Types and Variables

Numeric Data Types :
- int : Represents integer values, e.g., 42, -5, 0.
- float : Represents floating-point numbers with decimal values, e.g., 3.14, -0.5.
String Data Type :
- str : Represents sequences of characters, e.g., "hello", 'world', "123".
Boolean Data Type :
- bool : Represents either True or False, e.g., True, False.
List Data Type :
- list : Represents ordered collections of items, which can be of different data types, e.g., [1, 2, 3], ['a', 'b', 'c'], [1.2, 'hello', True].
Tuple Data Type :
- tuple : Represents immutable (unchangeable) ordered collections of items, e.g., (1, 2, 3), ('a', 'b', 'c').
Dictionary Data Type :
- dict : Represents key-value pairs, where keys are unique and immutable, e.g., {'name': 'John', 'age': 30}, {'color': 'blue', 'size': 'small'}.

Variables in Python:

A variable is a named location in the computer's memory that can store a value of a particular data type.
Variables are created by assigning a value to a name using the assignment operator (=).
- Example: x = 10 creates a variable named x and assigns it the value of 10.

Operations in Python:

Arithmetic Operations :
- Addition (+)
- Subtraction (-)
- Multiplication (*)
- Division (/)
- Modulus (%)
- Exponentiation (**).
Assignment Operations :
- Assign (=)
- Add and assign (+=)
- Subtract and assign (-=)
- Multiply and assign (*=)
- Divide and assign (/=)
- Modulus and assign (%=)
- Exponentiation and assign (**=).
Comparison Operations :
- Equal to (==)
- Not equal to (!=)
- Greater than (>)
- Less than (<)
- Greater than or equal to (>=)
- Less than or equal to (<=)
Logical Operations :
- AND (and)
- OR (or)
- NOT (not)
Other Operations :
- Type conversion (int(), float(), str(), bool())
- Membership test (in)
- Identity test (is)

Here's an example of using data types, variables, and operations in Python:

# Numeric Data Types and Variables
x = 42           # int
y = 3.14         # float
result = x + y   # Addition

# String Data Type and Variables
name = "Abhijit"    # str
age = 30         # int
greeting = "Hello, " + name   # String concatenation

# Boolean Data Type and Variables
is_active = True   # bool
is_adult = age >= 18   # Comparison

# List Data Type and Variables
numbers = [1, 2, 3, 4, 5]   # list
fruits = ['apple', 'banana', 'cherry']
numbers[2] = 7   # List item modification

# Tuple Data Type and Variables
coordinates = (10, 20)   # tuple
x, y = coordinates      # Tuple unpacking

# Dictionary Data Type and Variables
person = {'name': 'Alice', 'age': 25}   # dict
print(person['name'])   # Accessing dictionary value

# Arithmetic Operations
a = 5
b = 3
sum = a + b        # Addition
difference = a - b   # Subtraction
product = a * b      # Multiplication
quotient = a / b

#use in
'apple' in fruit #True
'Abhijit' in fruit #False

#use is
data = None
data is None #True

#use Not
Not(True) #False
Not(None) #True
Not('') #True

Classes and Objects

Define the Class : Define a class using the class keyword, followed by the class name, and a pair of parentheses. Inside the class, you can define attributes (data members) and methods (functions).
Create Objects : Create objects (also known as instances) of the class by calling the class name followed by parentheses, just like calling a function. This creates a new object with its own memory space.
Initialize Objects : If the class has a constructor method (__init__), it will be automatically called when an object is created. You can define the constructor method inside the class to initialize the attributes of the object.
Access Attributes and Call Methods : You can access the attributes (data members) and call the methods (functions) of the object using the dot (.) operator followed by the attribute or method name.
Modify Attributes : You can modify the attributes of an object by directly assigning a new value to them using the dot (.) operator.

Here's an example of how to define and use a simple class in Python:

# Define a class
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print("Woof!")

# Create objects
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# Access attributes
print(dog1.name)  # Output: Buddy
print(dog2.age)    # Output: 5

# Call methods
dog1.bark()       # Output: Woof!
dog2.bark()       # Output: Woof!

# Modify attributes
dog1.age = 4
print(dog1.age)    # Output: 4

Functions in python

A function is a block of code that performs a specific task and can be reused throughout your program.
Functions can take input arguments and return output values.
To define a function in Python, use the def keyword followed by the function name, parameter list (if any), and a colon (:). The function body should be indented after the colon. Here's an example of defining and calling a simple function in Python:

# Define a function that takes two numbers as arguments and returns their sum
def add_numbers(x, y):
    result = x + y
    return result

# Call the function and print the result
print(add_numbers(3, 5))   # Output: 8

In this example, we defined a function named add_numbers that takes two arguments (x and y) and returns their sum.
We then called the function and passed in the values 3 and 5 as arguments, which resulted in a return value of 8.
We then printed the result using the print function.

Functions can also have default parameter values, allowing you to call the function without passing in all arguments :

# Define a function that takes two numbers as arguments and returns their sum
# with a default value of 0 for y
def add_numbers(x, y=0):
    result = x + y
    return result

# Call the function with one argument and the default value for y
print(add_numbers(3))   # Output: 3

# Call the function with two arguments
print(add_numbers(3, 5))   # Output: 8

In this example, we defined a function named add_numbers that takes two arguments (x and y) with a default value of 0 for y.
We then called the function with only one argument, which resulted in a return value of 3 (since y defaulted to 0).
We then called the function with two arguments, which resulted in a return value of 8 (since y was set to 5).

Functions can also return multiple values using tuples :

# Define a function that takes two numbers as arguments and returns their sum and product
def add_and_multiply_numbers(x, y):
    sum = x + y
    product = x * y
    return sum, product

# Call the function and unpack the return values into two variables
result_sum, result_product = add_and_multiply_numbers(3, 5)
print(result_sum)      # Output: 8
print(result_product)  # Output: 15

In this example, we defined a function named add_and_multiply_numbers that takes two arguments (x and y) and returns
their sum and product as a tuple.
We then called the function and unpacked the resulting tuple into two separate variables (result_sum and result_product).
We then printed the two variables using the print function.

Control structures in Python

Conditional statements

Conditional statements are used to perform different actions based on different conditions.
The basic syntax of an if/else statement in Python is:

if condition:
    # code to be executed if the condition is True
else:
    # code to be executed if the condition is False

Here's an example:

# Define a function that takes an integer as input and returns a message based on its value
def check_number(n):
    if n > 0:
        return "Positive"
    elif n == 0:
        return "Zero"
    else:
        return "Negative"

# Call the function and print the result
print(check_number(5))   # Output: Positive
print(check_number(0))   # Output: Zero
print(check_number(-5))  # Output: Negative

In this example, we defined a function named check_number that takes an integer as input and returns a message based on whether it is positive, zero, or negative.
We then called the function with three different values and printed the result using the print function.

Loops

Loops are used to repeat a block of code multiple times.
Python provides two types of loops: for loops and while loops.

for loops :

for loops are used to iterate over a sequence of elements (such as a list, tuple, or string) or a range of numbers.

The basic syntax of a for loop in Python is:

# Define a list of names and print each name
names = ["Alice", "Bob", "Charlie", "Dave"]
for name in names:
    print(name)

# Output:
# Alice
# Bob
# Charlie
# Dave

while loops:

while loops are used to repeat a block of code as long as a certain condition is True.

The basic syntax of a while loop in Python is:

# Define a variable and print its value until it is greater than 10
n = 1
while n <= 10:
    print(n)
    n += 1

# Output:
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 10

Loop control statements:

Python provides two special statements that allow you to control the flow of a loop: break and continue.
break is used to exit a loop prematurely, while continue is used to skip to the next iteration of a loop.

Here's an example:

# Define a list of numbers and print each one until a negative number is encountered
numbers = [1, 2, 3, -4, 5, 6, 7, -8, 9]
for number in numbers:
    if number < 0:
        break   # exit the loop if a negative number is encountered
    print(number)

# Output:
#1
#2
#3

Data Types , Variables and Operators​

Data Types and Variables​

Variables in Python:​

Operations in Python:​

Classes and Objects​

Functions in python​

Control structures in Python​

Conditional statements​

Loops​