Python: Conditional and Looping Statements

• Python offers conditional statements (if, elif, else) to execute code blocks based on conditions.
• Looping constructs (for, while) facilitate repeated execution of code blocks.

Conditional Statements

• if statement evaluates a condition; if true, the indented code block is executed.
• elif (else if) allows checking multiple conditions sequentially.
• else block executes if none of the preceding if or elif conditions are true.
• Conditions are boolean expressions that evaluate to either True or False.
• Comparison operators (e.g., ==, !=, >, <) are used to form conditions.
• Logical operators (and, or, not) combine or negate conditions.

Looping Statements

• for loop iterates over a sequence (e.g., list, string, range) or other iterable.
• while loop repeatedly executes a block as long as a condition remains true.
• break statement exits the loop prematurely.
• continue statement skips the current iteration and proceeds to the next.
• range() function generates a sequence of numbers for for loop iteration.
• Nested loops are possible, where one loop is placed inside another.

Strings in Python

• Strings are immutable sequences of characters.
• Strings are defined using single quotes ('...'), double quotes ("..."), or triple quotes ('''...''' or """...""") for multiline strings.
• Individual characters can be accessed using indexing (e.g., string[0]).
• Slicing extracts a portion of a string (e.g., string[1:5]).
• String concatenation joins strings using the + operator.
• String methods provide various functionalities, like upper(), lower(), strip(), replace(), find(), and split().
• String formatting uses placeholders to insert values into strings (e.g., f"The value is {value}").
• Escape sequences represent special characters (e.g., \n for newline, \t for tab).

Lists in Python

• Lists are mutable, ordered sequences of items.
• Lists are defined using square brackets [...].
• List items can be of different data types.
• Items can be accessed by index.
• Lists can be sliced.
• Lists are mutable; items can be added, removed, or modified.
• Methods like append(), insert(), remove(), pop(), sort(), and reverse() modify lists.
• len() returns the number of items in a list.
• List comprehension provides a concise way to create new lists based on existing iterables.

Tuples in Python

• Tuples are immutable, ordered sequences of items.
• Tuples are defined using parentheses (...).
• Tuple items can be of different data types.
• Items are accessed by index.
• Tuples can be sliced.
• Tuples are immutable; items cannot be changed after creation.
• Tuples generally consume less memory than lists.
• Methods like count() and index() are available for tuples.
• Tuples are often used to represent fixed collections of items.
• Tuple packing and unpacking allow assigning multiple values at once.

Dictionaries in Python

• Dictionaries are mutable, unordered collections of key-value pairs.
• Dictionaries are defined using curly braces {...}.
• Keys must be unique and immutable (e.g., strings, numbers, tuples).
• Values can be of any data type.
• Items are accessed by key (e.g., dictionary["key"]).
• Methods like keys(), values(), items(), get(), update(), and pop() are used to manipulate dictionaries.
• len() returns the number of key-value pairs in a dictionary.
• Dictionary comprehension offers a concise way to create dictionaries.
• Dictionaries are useful for representing mappings and associations between data.