Python Syntax and Basic Concepts

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.