Python

Data types and variables

• Integers: Integers are whole numbers, both positive and negative, without any decimal point. For example, 5, -3, 100 are integers.
• Floats: Floats are numbers that have a decimal point. They can also represent fractional parts, like 3.14, -0.99, and 2.5.
• Strings: Strings are used to represent text. They can be written inside single (' ') or double (" ") quotes. For example, "Hello" or 'Python' are strings.
• Booleans: Booleans represent truth values and can either be True or False. They are often used in conditions and comparisons.

Variables and naming conventions

• Variables are like containers that store values. A variable can hold different types of data, such as an integer, float, string, or boolean. You create a variable by assigning a value to a name using the assignment operator `=`.

                    
age = 25  # Here, age is a variable that stores the value 25
                    
                

• Naming conventions: In Python, variables should follow these rules:
  • Variable names must start with a letter (a-z, A-Z) or an underscore (_).
  • After the first letter, you can use letters, numbers (0-9), and underscores.
  • Variable names are case-sensitive, so `age`, `Age`, and `AGE` are considered different variables.
  • Avoid using Python's reserved keywords (like `if`, `else`, `class`, etc.) as variable names.

Operators and Operator Precedence

• Arithmetic Operators: These operators are used to perform basic mathematical operations like addition, subtraction, multiplication, and division.
  • +: Addition
  • -: Subtraction
  • *: Multiplication
  • /: Division
  • %: Modulus (remainder)
  • **: Exponentiation
  • //: Floor Division (divides and rounds down to the nearest integer)
• Relational Operators: These operators are used to compare two values. They return either True or False.
  • ==: Equal to
  • !=: Not equal to
  • >: Greater than
  • <: Less than
  • >=: Greater than or equal to
  • <=: Less than or equal to
• Logical Operators: These operators are used to combine conditional statements.
  • and: Returns True if both conditions are true.
  • or: Returns True if at least one of the conditions is true.
  • not: Returns True if the condition is false.

Operator Precedence Rules

• Operator precedence defines the order in which operators are evaluated in an expression. Higher precedence operators are evaluated before lower precedence ones.
• The general order of precedence (from highest to lowest) is:
  • Parentheses ( ): Anything inside parentheses is evaluated first.
  • Exponentiation **: The exponentiation operator has higher precedence.
  • Multiplication, Division, Modulus, and Floor Division * / % //: These operators are evaluated next.
  • Addition and Subtraction + -: These have lower precedence than multiplication or division.
  • Relational Operators == != > < >= <=: These come after the arithmetic operations.
  • Logical Operators and or not: These have the lowest precedence.
• Example: In the expression 3 + 4 * 2, multiplication will be performed first, followed by addition. So the result is 11 (not 14).

Data Type Conversions

• Converting between types: In Python, you can convert one data type to another using built-in functions. This is useful when you need to perform operations on data of different types.
• Examples of Data Type Conversions:
• int to float: To convert an integer to a floating-point number, you can use the float() function.

                  
  num_int = 5
  num_float = float(num_int)
  print(num_float)  # Output: 5.0
                  
              

• float to int: To convert a floating-point number to an integer, you can use the int() function. This conversion will remove the decimal part.

                  
  num_float = 5.7
  num_int = int(num_float)
  print(num_int)  # Output: 5
                  
              

• str to int: To convert a string representing a number to an integer, use the int() function.

                  
  num_str = "10"
  num_int = int(num_str)
  print(num_int)  # Output: 10
                  
              

• str to float: To convert a string representing a floating-point number to a float, use the float() function.

                  
  num_str = "10.5"
  num_float = float(num_str)
  print(num_float)  # Output: 10.5
                  
              

• int to str: To convert an integer to a string, use the str() function.

                  
  num_int = 100
  num_str = str(num_int)
  print(num_str)  # Output: "100"
              
          

• Important Notes:
  • If you try to convert a string to an integer or float and the string doesn't represent a valid number, Python will raise a ValueError.
  • For example,

                        
    num_str = "abc"
    num_int = int(num_str)  # This will raise a ValueError.
                        
                    

Python Data Structures

Command Line Arguments

• Passing arguments when running a Python script from the command line: Command line arguments allow you to pass data to your Python script when executing it from the terminal or command prompt. This is useful for making scripts more dynamic and flexible.
• How to Pass Command Line Arguments:
  • In Python, the sys.argv list from the sys module is used to access command line arguments.
  • The first element of sys.argv is always the name of the script, and the subsequent elements are the arguments passed to the script.
• Example:

              
  import sys
  
  # Print the script name
  print("Script Name:", sys.argv[0])
  
  # Print command line arguments passed to the script
  for arg in sys.argv[1:]:
      print("Argument:", arg)
              
          

• Running the script from the command line:
  • Save the above script as example.py.
  • From the terminal, run the script by passing arguments:

                        
    python example.py arg1 arg2 arg3
                        
                    

  • The output will be:

                  
  Script Name: example.py
  Argument: arg1
  Argument: arg2
  Argument: arg3
                  
              

• Important Note: If no arguments are passed, sys.argv will only contain the script name. So always make sure to handle cases where no arguments are provided to avoid errors.

Data Input and Output

• Using input() to gather user input:
  • The input() function allows you to gather data from the user via the console.
  • It reads the input as a string by default, and you can then convert it into another data type (like integer or float) if necessary.
• Example of using input():

              
  # Gathering user's name
  name = input("Enter your name: ")
  print("Hello, " + name + "!")
              
          

  The above code will ask the user to enter their name, and then it will greet them with their name in the output.

• Using print() to display output:
  • The print() function is used to display information to the user or output results to the console.
  • It can display strings, numbers, or any other data type, and can even handle multiple items in one call.
• Example of using print():

              
  # Displaying a message
  print("Welcome to Python!")
  # Displaying multiple items
  age = 25
  print("Age:", age)
              
          

  The above code will print out the string "Welcome to Python!" and the age message "Age: 25".

Comments

• Single-line comments (#):
  • Single-line comments in Python are initiated by the # symbol. Everything after the # on that line is considered a comment and is ignored by Python during execution.
• Example of single-line comment:

              
  # This is a single-line comment
              
          

  The above code won't affect the program and is used to add notes or explanations in the code.

• Multi-line comments (triple quotes):
  • For comments that span multiple lines, Python allows you to use triple quotes ''' or """.
  • These can be useful for adding longer explanations or temporarily disabling blocks of code.
• Example of multi-line comment:

              
  '''
  This is a multi-line comment.
  It spans several lines.
  It can be used for longer explanations or to disable code.
  '''         
          

  The code inside the triple quotes will be ignored, making it easy to write multi-line comments.

Import Modules

• Using the import statement to include external modules:
  • The import statement allows you to include external Python modules or libraries into your program, which lets you access their functionality.
  • Once you import a module, you can use its functions, classes, and variables in your code.
• Example of using import:

              
  # Importing the math module
  import math
  
  # Using a function from the math module
  result = math.sqrt(16)
  print(result)  # Output: 4.0
              
          

  The above code imports the math module and uses its sqrt() function to calculate the square root of 16.

• Standard libraries and custom modules:
  • Python comes with many standard libraries (like math, random, datetime) that you can use without installing anything extra.
  • You can also create your own modules by saving Python code in a separate file (with a .py extension) and importing it into other scripts.
• Example of importing a custom module:

              
  # Assuming you have a file named mymodule.py with a function greet()
  
  # Importing the custom module
  import mymodule
  
  # Using a function from the custom module
  mymodule.greet("John")
              
          

  This example shows how you can import a custom module (like mymodule.py) and use its functions in your script.

Control Statements

• Conditional statements (if, elif, else):
  • Conditional statements allow you to execute different blocks of code based on certain conditions. The most common conditional statements in Python are if, elif (else if), and else.
  • The if statement checks a condition, and if it evaluates to True, the associated block of code is executed. If the condition is False, the elif or else block can be executed (if provided).
• Example of conditional statements:

              
  age = 20
  if age >= 18:
      print("You are an adult.")
  elif age >= 13:
      print("You are a teenager.")
  else:
      print("You are a child.")
              
          

  The code checks the value of age and prints the appropriate message based on whether the condition is True or False.

• Loops (for, while):
  • Loops allow you to repeat a block of code multiple times. The for loop is used to iterate over a sequence (like a list, tuple, or range), while the while loop continues as long as a specified condition remains True.
• Example of a for loop:

              
  for i in range(5):
      print(i)  # Output: 0, 1, 2, 3, 4
              
          

  This loop prints the numbers 0 through 4 using the range() function.

• Example of a while loop:

              
  count = 0
  while count < 5:
      print(count)
      count += 1  # Output: 0, 1, 2, 3, 4
              
          

  This loop prints numbers from 0 to 4, incrementing count after each iteration.

• break, continue, pass statements:
  • break is used to exit a loop prematurely, continue skips the rest of the current iteration and moves to the next iteration, and pass is a placeholder that does nothing but allows the program to continue.
• Example of break:

              
  for i in range(10):
      if i == 5:
          break  # Loop will stop when i equals 5
      print(i)  # Output: 0, 1, 2, 3, 4
              
          

• Example of continue:

              
  for i in range(5):
      if i == 3:
          continue  # Skips printing 3
      print(i)  # Output: 0, 1, 2, 4
              
          

• Example of pass:

              
  for i in range(3):
      if i == 2:
          pass  # Does nothing for i == 2
      print(i)  # Output: 0, 1, 2
              
          

Python Built-in Functions

• Common functions like print(), len(), type(), etc.
  • Python provides a variety of built-in functions that you can use to perform common tasks without needing to write custom code for them.
  • These functions simplify programming by performing common operations like displaying output, measuring the length of a sequence, checking the type of a variable, and more.
• Example of print() function:

              
  print("Hello, World!")  # Output: Hello, World!
              
          

  The print() function is used to display the specified message or data to the console.

• Example of len() function:

              
  word = "Python"
  print(len(word))  # Output: 6
              
          

  The len() function returns the number of items (characters, elements, etc.) in an object like a string, list, or tuple.

• Example of type() function:

                          
  number = 10
  print(type(number))  # Output: <class 'int'>
                          
                      

  The type() function is used to check the type of an object. In this case, it returns that the type of number is int (integer).

• Example of count() function:

                          
  my_list = [1, 2, 2, 3, 4, 2, 5]
  count_2 = my_list.count(2)
  print(count_2)  # Output: 3
                          
                      

  The count() function is used to count the number of occurrences of a specific element in a list. In this case, it returns 3 because the number 2 appears three times in my_list.

• Example of enumerate() function:

                          
  fruits = ['apple', 'banana', 'cherry']
  for index, fruit in enumerate(fruits):
      print(index, fruit)
  
  # Output:
  # 0 apple
  # 1 banana
  # 2 cherry
                          
                      

  The enumerate() function adds an index to each item in an iterable, returning both the index and the value. In this case, it assigns an index to each fruit in the fruits list.

Python Modules

• Creating and using modules in Python

  In Python, a module is a file that contains Python code. It can define functions, classes, and variables that you can reuse in other programs.

  To create a module, simply write your Python code in a separate file (with a .py extension). For example:

              
  # mymodule.py
  def greet(name):
      return f"Hello, {name}!"
              
          

  Now, you can use this module in another Python file by importing it:

              
  # main.py
  import mymodule
  print(mymodule.greet("Alice"))  # Output: Hello, Alice!
              
          

• Importing built-in modules

  Python comes with many built-in modules that provide additional functionality. You can import these modules and use their features in your program.

  For example, you can use the math module to perform mathematical operations:

              
  import math
  print(math.sqrt(16))  # Output: 4.0
              
          

  Here, we imported the math module and used its sqrt() function to calculate the square root of 16.

File Handling

• Reading from and writing to files

  In Python, file handling is an essential skill, as it allows you to interact with files on your system. When you're working with files, you can open them, read from them, write to them, and even modify them.

  First, let's start with the basics of opening a file. You use the open() function to open a file. The open() function takes two main arguments: the filename and the mode (what you want to do with the file).

  For example, to open a file for reading, use the r mode:

              
  # Open the file in read mode
  file = open("example.txt", "r")
  # Read the entire file
  content = file.read()
  print(content)
  file.close()  # Always remember to close the file!
              
          

  This will open the file example.txt, read its content, and print it to the screen. If the file does not exist, Python will throw an error.

  If you want to read a file line by line, you can use the readline() method. Here's how:

              
  # Open the file
  file = open("example.txt", "r")
  # Read one line at a time
  line1 = file.readline()
  line2 = file.readline()
  print(line1)
  print(line2)
  file.close()
              
          

  This will print the first two lines of the file. Each time you call readline(), it reads the next line.

  Now, let's talk about writing to files. To write to a file, you use the write() method. But before you can write to a file, you need to open it in write mode using the w mode:

              
  # Open the file in write mode (this will overwrite the existing content)
  file = open("output.txt", "w")
  file.write("Hello, world!")
  file.close()    
              
          

  This code will create a new file named output.txt (if it doesn't already exist) and write the string "Hello, world!" into it. If the file exists, its content will be replaced with the new content.

  If you want to append data to the end of a file without changing the existing content, you can use the a (append) mode:

              
  # Open the file in append mode
  file = open("output.txt", "a")
  file.write("\nAppended content!")
  file.close()
              
          

  This will add the text "Appended content!" to the end of the file without removing the original content.

• Working with file modes (r, w, a)

  When opening a file, you must specify what kind of interaction you want with it. This is where file modes come in. Python provides several modes for opening a file:

  • r - Read Mode: Opens the file for reading. If the file doesn't exist, an error is raised.
  • w - Write Mode: Opens the file for writing. If the file exists, its content is erased. If it doesn't exist, a new file is created.
  • a - Append Mode: Opens the file for adding content at the end. If the file doesn't exist, it creates a new one.
  • rb - Read Binary Mode: Opens the file in binary mode for reading. Useful for reading non-text files (like images).
  • wb - Write Binary Mode: Opens the file in binary mode for writing.
  • r+ - Read/Write Mode: Opens the file for both reading and writing.
  • w+ - Write/Read Mode: Opens the file for both writing and reading. The file will be overwritten if it exists.

  For example, if you want to work with binary files, like images, you would open the file in binary mode:

              
  # Open the image file in binary read mode
  file = open("image.png", "rb")
  data = file.read()
  file.close()
              
          

  Similarly, you can write to a binary file using the wb mode.

  To read and write to a file, you can use r+ or w+ modes. This allows you to modify a file:

              
  # Open the file for both reading and writing
  file = open("example.txt", "r+")
  file.write("Updated content!")
  file.seek(0)  # Move the cursor back to the start
  content = file.read()
  print(content)
  file.close()
              
          

  Here, after writing new content, we used seek(0) to move the cursor back to the beginning of the file and then read the updated content.