Basic Python for Data Science

248979

1. Comment in Python

A comment is a piece of text that is added to the code for documentation or clarification purposes. Comments are ignored by the Python interpreter and are not executed as part of the program. They are used to make the code more readable and understandable for humans who are reading and maintaining the code.

Comments in Python start with the # symbol and continue until the end of the line. For example:

# This is a comment in Python
print("Hello, World!") # This is another comment

Hello, World!

In the above example, the first line is a comment, and it is ignored by the Python interpreter. The second line is a code that prints the message "Hello, World!", but the part of the line after the # symbol is a comment and is also ignored by the interpreter.

You can also create multiline comments in Python by using triple quotes ''' or """. For example:

'''
This is a multiline comment in Python.
It can span across multiple lines.
'''
print("Hello, World!")

Hello, World!

In the above example, the first three lines are a multiline comment, and they are ignored by the Python interpreter. The fourth line is a code that prints the message "Hello, World!" and is executed by the interpreter.

2. Variable in Python

A variable is a name that refers to a value or an object in memory. It is a way to store and access data in a program. When you create a variable in Python, you assign a name to a value, which can be a number, a string, a list, a dictionary, or any other data type.

To create a variable in Python, you simply choose a name for the variable and assign a value to it using the equal sign (=). For example, the following code creates a variable called "x" and assigns it the value of 5:

x = 5
x

You can then use the variable in your code to perform operations or manipulate the data. For example, you can add 2 to the value of x and assign the result to a new variable called "y" like this:

y = x + 2
y

The value of y will be 7, because it is the result of adding 2 to the value of x (which is 5).

Variables in Python are dynamic, meaning that you can change the value of a variable at any time by assigning a new value to it. For example, you can change the value of x from 5 to 10 like this:

x = 10
x

Now the value of x is 10, and any operation or manipulation that uses x will use the new value.

3. Data Types in Python

A data type is a classification that determines the type of data that a variable or expression can hold. Python supports several built-in data types, including:

Numeric Types: int, float, complex Numeric types represent numbers in Python. int represents integer numbers, float represents decimal numbers, and complex represents complex numbers.

Example:

a = 5  # int
b = 3.14  # float
c = 2 + 3j  # complex

print(type(a))  # Output: <class 'int'>
print(type(b))  # Output: <class 'float'>
print(type(c))  # Output: <class 'complex'>

<class 'int'>
<class 'float'>
<class 'complex'>

Boolean Type: bool The Boolean type represents a value that is either True or False.

Example:

a = True
b = False

print(type(a))  # Output: <class 'bool'>
print(type(b))  # Output: <class 'bool'>

<class 'bool'>
<class 'bool'>

Sequence Types: list, tuple, range Sequence types represent ordered collections of items. list and tuple are used to store a collection of items of any type but, lists are mutable and tuples are immutable, and range is used to generate a sequence of numbers.

Example:

a = [1, 2, 3]  # list
b = (4, 5, 6)  # tuple
c = range(0, 10, 2)  # range

print(type(a))  # Output: <class 'list'>
print(type(b))  # Output: <class 'tuple'>
print(type(c))  # Output: <class 'range'>

<class 'list'>
<class 'tuple'>
<class 'range'>

Set Types: set, frozenset Set types represent unordered collections of unique items. set is mutable, while frozenset is immutable.

Example:

a = {1, 2, 3}  # set
b = frozenset({4, 5, 6})  # frozenset

print(type(a))  # Output: <class 'set'>
print(type(b))  # Output: <class 'frozenset'>

<class 'set'>
<class 'frozenset'>

Mapping Type: dict The mapping type represents a collection of key-value pairs, where each key is unique.

Example:

a = {"name": "John", "age": 30, "city": "New York"}  # dict

print(type(a))  # Output: <class 'dict'>

<class 'dict'>

Binary Types: bytes, bytearray, memoryview Binary types represent sequences of bytes. bytes and bytearray are used to store a sequence of bytes, and memoryview is used to access the memory of a byte buffer.

Example:

a = b'hello'  # bytes
b = bytearray(b'world')  # bytearray
c = memoryview(b)  # memoryview

print(type(a))  # Output: <class 'bytes'>
print(type(b))  # Output: <class 'bytearray'>
print(type(c))  # Output: <class 'memoryview'>

<class 'bytes'>
<class 'bytearray'>
<class 'memoryview'>

Python is a dynamically typed language, which means that you don't have to explicitly declare the data type of a variable. The data type of a variable is inferred from the value that is assigned to it.

4. Operators in Python

Operators are special symbols or characters that allow you to perform operations on values or variables. Python supports a wide range of operators, including arithmetic operators, comparison operators, assignment operators, logical operators, and bitwise operators. Here's a brief overview of each type of operator:

Arithmetic operators: These operators are used to perform mathematical operations such as addition, subtraction, multiplication, division, modulus, and exponentiation. Examples of arithmetic operators in Python include +, -, *, /, %, and **.

x = 10
y = 5

print(x + y)    # Output: 15      # Addition
print(x - y)    # Output: 5       # Subtraction
print(x * y)    # Output: 50      # Multiplication
print(x / y)    # Output: 2.0     # Division
print(x % y)    # Output: 0       # Modulus
print(x ** y)   # Output: 100000  # Exponentiation

Comparison operators: These operators are used to compare values or variables and return a Boolean value (True or False) based on the comparison result. Examples of comparison operators in Python include ==, !=, >, <, >=, and <=.

x = 10
y = 5

print(x == y)   # Output: False  # Equals to
print(x != y)   # Output: True   # Not equals to
print(x > y)    # Output: True   # Greater than
print(x < y)    # Output: False  # Less than
print(x >= y)   # Output: True   # Greater than or equal to
print(x <= y)   # Output: False  # Less than or equal to

False
True
True
False
True
False

Assignment operators: These operators are used to assign values to variables. Examples of assignment operators in Python include =, +=, -=, *=, /=, and %=.

x = 10
x += 5      # Same as x = x + 5
print(x)    # Output: 15  

x -= 3      # Same as x = x - 3
print(x)    # Output: 12

x *= 2      # Same as x = x * 2
print(x)    # Output: 24

x /= 4      # Same as x = x / 4
print(x)    # Output: 6.0

x %= 2      # Same as x = x % 2
print(x)    # Output: 0.0

Logical operators: These operators are used to perform logical operations on Boolean values (True or False). Examples of logical operators in Python include and, or, and not.

x = 5
y = 2

print(x > 3 and y < 5) # And         # Output: True
print(x > 3 or y > 5)  # Or          # Output: True
print(not(x > 3 and y < 5)) # Not    # Output: False


x = True
y = False

print(x and y)  # Output: False
print(x or y)   # Output: True
print(not x)    # Output: False

True
True
False
False
True
False

Bitwise operators: These operators are used to perform bitwise operations on binary values. Examples of bitwise operators in Python include &, |, ^, ~, <<, and >>.

a = 5  # 0b0101 in binary
b = 3  # 0b0011 in binary

# Perform a bitwise AND operation on a and b
c = a & b

print(c)  # Output: 1 (0b0001 in binary)

# Perform a bitwise OR operation on a and b
c = a | b

print(c)  # Output: 7 (0b0111 in binary)

# Perform a bitwise XOR operation on a and b
c = a ^ b

print(c)  # Output: 6 (0b0110 in binary)

# Perform a bitwise NOT operation on a
c = ~a

print(c)  # Output: -6 (0b1010 in binary)

Understanding how to use operators is essential to programming in Python, as they allow you to manipulate values and variables in a variety of ways.

5. Loops in Python

A loop is a programming construct that allows you to execute a set of statements repeatedly. There are two main types of loops in Python: for loop and while loop.

for loop A for loop is used to iterate over a sequence (such as a list, tuple, string, or range object) and execute a block of code for each element in the sequence. The basic syntax of a for loop in Python is:

#for variable in sequence:
    # code to execute for each element in sequence

Here, variable is a variable that takes on the value of each element in the sequence, one at a time. The code inside the loop is executed for each element in the sequence.

For example, to print each element of a list, you could use a for loop like this:

my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)

while loop A while loop is used to repeatedly execute a block of code as long as a certain condition is true. The basic syntax of a while loop in Python is:

#while condition:
    # code to execute while condition is true

Here, condition is an expression that is evaluated at the beginning of each iteration of the loop. If the condition is true, the code inside the loop is executed. This process continues until the condition becomes false.

For example, to print the numbers from 1 to 5 using a while loop, you could do this:

i = 1
while i <= 5:
    print(i)
    i += 1

In this example, the loop continues to execute as long as i is less than or equal to 5.

6. Function in Python

A function is a block of code that performs a specific task and can be reused multiple times in a program. A function can be thought of as a self-contained mini-program that takes some input, processes it, and returns a result.

In Python, functions are defined using the "def" keyword, followed by the name of the function and a set of parentheses. Inside the parentheses, you can specify any arguments that the function should accept. The body of the function is defined using indentation, and typically includes one or more statements that perform the desired task.

Here is an example of a simple Python function that takes two arguments and returns their sum:

def add_numbers(x, y):
    result = x + y
    return result

This function can be called with two arguments, like this:

print(add_numbers(5, 7))  # Output: 12

In this example, the function "add_numbers" takes two arguments (x and y), adds them together, and returns the result. The function is then called with the values 5 and 7, and the result (12) is printed to the console using the "print" statement.

7. Module in Python

A module is a file containing Python definitions and statements. These files typically have a .py extension and can be used to group related functions, classes, and variables together, making it easier to organize and reuse code.

A module can be imported into another Python script, allowing the functions and variables defined in the module to be used in the script. Python provides many standard modules that can be used to perform common tasks, such as working with files, handling dates and times, and performing mathematical calculations.

To use a module in a Python script, you can use the import statement followed by the name of the module. For example, if you wanted to use the math module to perform some calculations, you would include the following line at the top of your script:

import math

Once you have imported a module, you can access its functions and variables using dot notation. For example, to use the sqrt function from the math module, you would write:

x = math.sqrt(16)

This would assign the value 4.0 to the variable x.