Python Syntax and Basic Concepts

Study Notes

Python Syntax และ Basic Concepts

Indentation:
- Python uses whitespace (spaces or tabs) for block delimitation, not braces or keywords.
Variables:
- No need for explicit declaration.
- Dynamic typing: Variable types are determined at runtime.
Data Types:
- Common types: integers, floats, strings, lists, tuples, dictionaries, sets.
- Example: x = 10, name = "Alice", numbers = [1, 2, 3].
Operators:
- Arithmetic: +, -, *, /, // (floor division), % (modulus), ** (exponentiation).
- Comparison: ==, !=, >, <, >=, <=.
- Logical: and, or, not.
Control Structures:
- Conditional statements: if, elif, else.
- Loops: for (iterates over sequences), while (executes as long as condition is true).
Comments:
- Single line: # This is a comment
- Multi-line:
```
"""
This is a 
multi-line comment
"""
```

Function และ Module

Functions:
- Defined using the def keyword:
```
def my_function(param1, param2):
    return param1 + param2
```
- Can have default parameters:
```
def greet(name="World"):
    print("Hello, " + name)
```
- Return values using return. If no return is specified, it returns None.
Lambda Functions:
- Anonymous functions defined using lambda:
```
add = lambda x, y: x + y
```
Modules:
- A module is a file containing Python code (functions, classes).
- Importing a module:
```
import math  # imports the math module
from math import sqrt  # imports specific function
```
- Standard library includes modules like os, sys, time, random, etc.
Packages:
- A way to structure modules; contains multiple modules.
- Created by organizing modules into directories with an __init__.py file.
Built-in Functions:
- Common functions: print(), len(), type(), range(), input().
Docstrings:
- Used for function documentation, enclosed within triple quotes inside the function.
- Example:
```
def add(x, y):
    """Returns the sum of x and y."""
    return x + y
```

Python Syntax

Whitespace is significant, indentation is used to define code blocks
No need to declare variable type.
Variable types are determined during program execution (dynamic typing).

Data Types

Integers: Whole numbers like 10, -5
Floats: Decimal numbers like 3.14, -2.5
Strings: Text enclosed in quotes like "Hello world", "Python", "123"
Lists: Ordered collections of items enclosed in square brackets [1, 2, 3], ["apple", "banana", "cherry"]
Tuples: Immutable ordered collections enclosed in parentheses (1, 2, 3), ("apple", "banana", "cherry")
Dictionaries: Key-value pairs enclosed in curly braces {"name": "John", "age": 30}, {"apple": 1, "banana": 2, "cherry": 3}
Sets: Unordered collections of unique elements enclosed in curly braces {1, 2, 3}, {"apple", "banana", "cherry"}

Operators

Arithmetic Operators:
- Addition +
- Subtraction -
- Multiplication *
- Division /
- Floor division //
- Modulus % (remainder after division)
- Exponentiation **
Comparison Operators:
- Equal to ==
- Not equal to !=
- Greater than >
- Less than <
- Greater than or equal to >=
- Less than or equal to <=

Indentation and Basic Concepts

Python uses indentation to define blocks of code. Consistent use of spaces or tabs is crucial.
Comments can be single-line using # or multi-line using '''...''' or """...""".
Variables do not require type declaration. Variable names are case-sensitive and can include letters, numbers, and underscores.
Python supports various data types:
- Numeric: int, float, complex
- Sequence: str, list, tuple
- Mapping: dict
- Set: set, frozenset
- Boolean: bool
Python includes various operators:
- Arithmetic: +, -, *, /, //, %, **
- Comparison: ==, !=, ``, =
- Logical: and, or, not
Control structures manage program flow:
- Conditional Statements: if, elif, else
- Loops:
  - for loop iterates over sequences.
  - while loop repeats execution based on a condition.
Exception handling uses try, except, and finally blocks.

Function and Module

Functions are defined using def, followed by the function name and parameters.
- Example:
```
def my_function(param1, param2):
    return param1 + param2
```
Function parameters can be:
- Positional: Passed in order.
- Keyword: Passed with keyword (param1=value).
- Default: Defined in the function signature with default values.
Functions can return values using the return keyword.
Lambda Functions are anonymous functions using the lambda keyword:
- Format: lambda arguments: expression
Modules are .py files containing functions, classes, and other code.
- They are imported using import:
  - Example: import math or from module import function
Packages are namespaces containing modules.
- They have an __init__.py file.
Standard Libraries offer extensive modules for various functionalities:
- Examples: os, sys, math, datetime.

Description

Test your knowledge on Python's syntax and basic concepts, including indentation, variable types, and control structures. This quiz covers essential elements like functions, operators, and comments to enhance your understanding of Python programming.