Author: 孤筝(lvbowen040427@163.com)

Machine - Hardware Related Functions

Pin Class

machine.Pin(id, mode=None, pull=None, value)

Pin object constructor

• id: GPIO number (0-29 for Pico)
• mode: Pin mode, options: None, Pin.IN(0), Pin.OUT(1), Pin.OPEN_DRAIN(2)
• pull: Internal pull-up/down resistor (only valid in input mode), options: None, Pin.PULL_UP(1), Pin.DOWN(2)
• value: Port value in output or open-drain mode (0 for low, 1 for high)

Pin.init(mode=None, pull=None)

Reinitialize GPIO port

Pin.value([x])

• Returns GPIO port value when no parameter is given
• Writes value to GPIO port when parameter 0/1 is provided

Pin.toggle()

Toggles port state in output or open-drain mode

Example: LED blinking

from machine import Pin
import time
led = Pin(25, Pin.OUT)
while True:
    led.toggle()
    time.sleep(1)  # Toggle LED every second

Pin.irq(handler=None, trigger=(Pin.IRQ_FALLING|PIN.IRQ_RISING))

External interrupt function

• handler: Callback function when interrupt triggers
• trigger: Interrupt trigger condition (edge/level triggered)

Other Functions

For output/open-drain mode:

• Pin.low(), Pin.off(): Set port to low voltage
• Pin.high(), Pin.on(): Set port to high voltage

Example: LED Control

from machine import Pin
import utime
# Button on GPIO15, input mode with pull-up
button_num = 15
button = Pin(button_num, Pin.IN, Pin.PULL_UP)
# Onboard LED on GP25, external LED on GP16
led1_num = 25
led2_num = 16
led1 = Pin(led1_num, Pin.OUT)
led2 = Pin(led2_num, Pin.OUT)

while True:
    led2.off()  # Turn off external LED
    if button.value() == 0:  # Check if button pressed (0 when pressed)
        utime.sleep(0.01)
        if button.value() == 0:  # Software debounce
            led1.toggle()  # Toggle onboard LED
            led2.on()  # Turn on external LED (GP16 high)
            print("The button is pressed.")
            while button.value() == 0:
                # Wait while button remains pressed (external LED stays on)
                utime.sleep(0.01)

PWM Class

machine.PWM(pin)

Reinitialize specified GPIO as PWM output

• pin: Pin class object

PWM.deinit()

Deinitialize PWM, stop PWM output

PWM.freq([value])

Set PWM frequency (in Hz), automatically calculates divider and TOP register values

PWM.duty_u16([value])

Set duty cycle

• value: Duty cycle ratio [0,65536], calculates corresponding value for CC register

PWM.duty_ns([value])

Set high-level duration per cycle in nanoseconds

Example: Breathing LED

from machine import Pin, PWM
import time

led = PWM(Pin(25))  # Initialize onboard LED as PWM
led.freq(1000)  # Set frequency
led_duty = 0  # Initial value
led_direction = 1  # Step size

while True:
    led_duty += led_direction  # Increase/decrease duty cycle
    if led_duty >= 100:  # Max
        led_duty = 100
        led_direction = -1
    elif led_duty <= 0:  # Min
        led_duty = 0
        led_direction = 1
        
    led.duty_u16(int(led_duty * 655.36))  # Convert ratio to value
    
    if led_duty % 5 == 0:
        print(led_duty)  # For monitoring
        
    time.sleep(0.01)
    # 2-second cycle

ADC Class

machine.ADC(id)

Initialize as ADC object

• id: Can be GPIO or ADC channel (GPIO must support ADC when using Pin object)
• Channels 0-3: Pico GPIO 26-29
• Channel 4: Internal temperature sensor

ADC.read_u16()

Read ADC channel value [0,65525]

Published on 2024-02-15 at 孤筝の温暖小家, last modified on 2024-02-15

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Author: 孤筝(lvbowen040427@163.com)

elem is the abbreviation of the word “element”, representing an indeterminate type in programming definitions, i.e., an abstract data type.

List

Definition

A container formed by a sequence of elements arranged in order.

• Elements can be of any type.
• Elements are arranged in a determined order, exhibiting sequentiality.

Creating a List

Method 1: Create an empty list instance and then add elements

• list()
• .append() method

>>> wife = list()  # Instantiation  
>>> wife.append("Nishimiya Shoko")  
>>> wife.append("Sakurajima Mai")  
>>> wife.append("Elysia")  
>>> wife  
['Nishimiya Shoko', 'Sakurajima Mai', 'Elysia']  

Method 2: Directly define and populate the list

>>> phones = ["Apple", "Huawei", "Xiaomi"]  
>>> phones  
['Apple', 'Huawei', 'Xiaomi']  

Accessing Elements

1. Using Indexing
   Access the (i+1)th element with [i].

2. index() Method
   name.index(x)
   Searches for the first element with value x in list name and returns its index.

3. count() Method
   name.count(x)
   Counts how many elements in list name have the value x and returns the count.

4. len() Method
   len(name)
   Returns the total number of elements in list name.

Adding Elements

1. append() Method
   name.append(x)
   Adds element x to the end of name.

2. insert() Method
   name.insert(i, x)
   Inserts object x at index i in name, shifting subsequent elements backward.

3. extend() Method
   name.extend(name2)
   Appends list name2 to the end of list name.

Modifying Elements

1. Direct Assignment via Index
   Assign a new value to an element using its index.

Deleting Elements

1. pop() Method
   name.pop()
   Removes the last element by default.
   name.pop(i)
   Removes the element at index i, shifting subsequent elements forward.

2. remove() Method
   name.remove(x)
   Removes the first element with value x, shifting subsequent elements forward.

3. clear() Method
   name.clear()
   Deletes all elements (empties the list).

4. del Statement
   del name[a:b]
   Deletes elements with indices in [a, b) (includes a, excludes b).
   del name[:] clears the list.
   del name[i] deletes the element at index i.

Reversing a List

1. reverse() Method
   name.reverse()
   Reverses the list in place (last element becomes first, etc.).

2. Slicing Method

   >>> nums = [1, 2, 3, 4, 5]  
   >>> new_nums = nums[::-1]  
   >>> new_nums  
   [5, 4, 3, 2, 1]  
   

   The original list nums remains unchanged; a new reversed list new_nums is created.

Sorting a List

1. sort() Method
   name.sort()
name.sort(cmp=None, key=None, reverse=False)
   • Modifies the original list in place (no return value).
   • cmp is an optional parameter (deprecated in Python 3).
   • key specifies a function to extract a comparison key from each element.
     • Omitted if elements are single-parameter (e.g., numbers or single characters).

   def takeSecond(elem):  
       return elem[1]  
   random = [(2, 2), (3, 4), (4, 1), (1, 3)]  
   random.sort(key=takeSecond)  # Sorts by the second element of each tuple.  
   print(random)  
   # Output: [(4, 1), (2, 2), (1, 3), (3, 4)]  
   

   • reverse: False for ascending (default), True for descending.

Tuple

Definition

A tuple is an immutable sequence of elements, similar to a list but unchangeable.

Creating a Tuple

1. Use parentheses () to enclose elements (lists use []).
2. Sometimes tuples can be created without () (not recommended).
3. Tuple Comprehension:

   atuple = (i+1 for i in range(31, 42))  
   

4. For single-element tuples, add a trailing comma , to avoid confusion with non-tuple objects.
5. Empty Tuple:

   a = tuple()  
   b = ()  
   

Tuples Are Immutable

Tuples do not support addition, deletion, or modification of elements.

Converting Between Tuples and Lists

• Tuple → List:

  atuple = (1, 'love', 3.334, 'Y')  
  alist = list(atuple)  # Converts to list  
  

• List → Tuple:

  alist = ['I', 2, 3.1415, 'polaris']  
  atuple = tuple(alist)  # Converts to tuple  
  

Dictionary (dict)

Definition

• A collection of key-value pairs.
• Keys must be hashable (e.g., strings, numbers).
  • Hash: A process that maps data of arbitrary size to fixed-size values.
• Values can be any object.

Creating a Dictionary

1. Empty Dictionary + Assignment:

   profile = dict(name='孤筝', age=19, hobby='明月栞那')  
   

   (Note: Keys as identifiers do not need quotes.)

2. Direct {} Syntax:

   profile = {'name': '孤筝', 'age': 19, 'hobby': '明月栞那'}  
   

   (Keys as strings require quotes.)

3. From Sequence of Pairs:

   alist = [('name', '孤筝'), ('age', 19), ('hobby', '明月栞那')]  
   profile = dict(alist)  
   

4. Dictionary Comprehension:

   adict = {i: i**2 for i in range(2, 6)}  
   # Output: {2: 4, 3: 9, 4: 16, 5: 25}  
   

Accessing Elements

1. dict[key]:
   Raises KeyError if the key is missing.

2. dict.get(key[, default]):
   Returns default (or None) if the key is missing.
   If the key is absent, it can optionally add the key with the default value.

Adding/Modifying Elements

• Add/Modify: dict[key] = value

Deleting Elements

1. dict.pop(key): Removes the key-value pair.
2. del dict[key]: Deletes the pair.

Other Key Methods

Checking Key Existence

1. in/not in
2. dict.has_key() (Python 2 only; removed in Python 3).

Setting Default Values

1. Conditional Check:

   if "gender" not in profile:  
       profile["gender"] = "male"  
   

2. setdefault():
   dict.setdefault(key, default=None)
   Sets default if the key is missing.

Set

Definition

An unordered collection of unique elements (like a mathematical set).
Question: If sets are unordered, how are elements ordered when printed/stored?

Creating a Set

1. Curly Braces {}: Duplicates are automatically removed.
2. set() Constructor:

   aset = {1314, '520'}  
   bset = set()  # Empty set  
   cset = set(['I', 'love', 'ishimiya'])  
   

Adding Elements

1. add():
   aset.add(elem)

   • No effect if elem already exists (no error).
   • elem must be immutable (e.g., numbers, strings).

2. update():
   aset.update(iterable)
   Adds elements from any iterable (e.g., list, tuple, dict keys).

Deleting Elements

1. remove(): Raises KeyError if the element is missing.
2. discard(): No error if the element is missing.
3. pop(): Randomly removes and returns an element.
4. clear(): Empties the set.

Set Operations

Union

aset.union(bset) or aset | bset

Difference

aset.difference(bset) or aset - bset

Intersection

1. intersection(): aset.intersection(bset) or aset & bset
2. intersection_update(): Updates aset in place.

Symmetric Difference (Non-Overlapping Elements)

1. symmetric_difference(): Returns new set.
2. symmetric_difference_update(): Updates aset in place.

Other Operations

1. Membership Check: elem in aset
2. Disjoint Check: aset.isdisjoint(bset) (True if no common elements).
3. Subset Check: bset.issubset(aset) (True if bset is a subset).

Iterator

Iterable Objects

Objects usable in for loops (e.g., lists, tuples).

Iterable Protocol

1. Implements __iter__(): Returns an iterator instance.
   • isinstance(obj, Iterable) returns True.
2. Fallback to __getitem__(): If __iter__() is missing, Python checks for __getitem__() to simulate iteration.
   • isinstance(obj, Iterable) returns False for this case.

Iterator Objects

• Created via iter(iterable).
• Elements are accessed using next(), raising StopIteration when exhausted.

alist = ['人', '生', '若', '只', '如', '初', '见']  
gen = iter(alist)  
for _ in alist:  
    print(next(gen))  # Outputs elements sequentially  

Iterable vs. Iterator

• Iterable: The container (e.g., list).
• Iterator: The object returned by iter(), enabling element-by-element traversal.

Generator

A function that produces values lazily (like an iterator), usable in for loops.

Creating Generators

List Comprehension → Generator

alist = [i for i in range(5)]  # List  
gen = (i for i in range(5))    # Generator  
print(next(gen))  # Output: 0  

yield Keyword

• Pauses function execution and returns a value.
• Resumes from the paused state on subsequent calls.

def generator():  
    top = 5  
    i = 0  
    while i < top:  
        print(f'Current value: {i}')  
        i += 1  
        yield i  
    raise StopIteration  

gen = generator()  
for _ in range(5):  
    print(next(gen))  

Key Difference: yield vs. return

• yield pauses execution; return terminates it.
• yield can resume; return cannot.

Published on 2023-08-27 at 孤筝の温暖小家, last modified on 2023-08-27

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Author: 孤筝(lvbowen040427@163.com)

Comments

• Single-line comment
  # content
• Multi-line comment

'''  
This green section is a comment  
This part is also  
'''  
This is no longer a comment  
# Single-line comment  
print("'''This is not a comment''' Will this be printed?")  
a='''Hello'''1  
Terminal: SyntaxError: invalid syntax  
'''  
Writing like this will cause an error. It seems inserting comments in the middle of code affects execution.  
Multi-line strings can be defined using '''string'''. The comment is interpreted as an assignment operation, so the above error points to the trailing 1.  
'''  

Encoding Format

• In Python 2.x, the default source file encoding is ASCII. If the content contains Chinese characters, the file cannot be read and output correctly without specifying the encoding format. You can add the following code at the beginning of the source file to specify UTF-8 encoding:

# -*- coding: UTF-8 -*-  

In Python 3.x, the default source file encoding is UTF-8. Therefore, when using Python 3.x, specifying the encoding format is usually unnecessary.

Identifiers

• Identifiers are a universal concept in programming, used to name ==variables, functions, interfaces, classes==, etc.
• Python identifiers are case-sensitive and consist of letters, numbers, and underscores. The first character must be a letter or underscore and cannot start with a number. In Python 3.x, Chinese characters can be used as identifiers.
• Identifiers starting with underscores have special meanings:
  • A single underscore prefix (e.g., _name) indicates a class attribute that cannot be accessed directly and requires an interface provided by the class.
  • A double underscore prefix (e.g., __age) indicates a private class member.
  • Identifiers with double underscores at both ends (e.g., __init__(), the class constructor) represent built-in Python identifiers.

Published on 2023-06-27 at 孤筝の温暖小家, last modified on 2023-06-27

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Author: 孤筝(lvbowen040427@163.com)

Function Parameter Passing

In Python, passing parameters to a function is essentially an assignment operation.

def func(arr):
    arr = 1
    print(arr)

a = 2
func(a)
print(a)

1. First, there are two variables arr and a, and two objects 1 and 2.
2. a is bound to 2, and func(a) assigns the object 2 bound to a to arr.
3. At this point, object 1 has not been created yet, and object 2 is labeled with both a and arr.
4. The operation arr = 1 removes the arr label from 2, creates object 1, and assigns it to arr.
5. Output:

1
2

Input and Output

The print() Function

>>> print("string")
string
>>> print("str1", "str2", "str3")
str1 str2 str3  # Spaces replace commas
print(a + b ** c)  # Computes the value first, then prints
print(sum(a, b / c))  # Executes the sum() function first

Prototype:

• sep parameter: Separator between multiple outputs (return values). Default is a space, but can be manually set.
• end parameter: How to end the print. Default is \n (newline), can be set to ' ' to avoid line breaks.

The input() Function

Gets user input and saves it as a string.
If the input is a number, it can be converted to an integer using int().

>>> age = input("Please input your age: ")
Please input your age: 18
>>> print(age)
'18'  # type(age) == <class 'str'>
>>> age = int(age)
>>> print(age)
18

• input() can take a string argument, which is printed as a prompt.
• When using int(), extra spaces can be removed with the strip() method. This also applies when saving string objects.
• input() can be used to consume a newline and pause program execution.
  [[Data Types and Operators#String Formatting]]

Utility Functions

id()

Example:
[[Data Types and Operators#Assignment Methods]]
id(variable_name) returns the memory address of the object bound to the variable.
If the object bound to the variable changes, the query result changes, but the original object’s memory address remains unchanged.

type()

• With one argument, returns the type of the object.
• With three arguments, returns a new object type:
  • type(name, bases, dict)
  • name — The name of the class.
  • bases — A tuple of base classes.
  • dict — A dictionary, the namespace variables defined within the class.

# One argument example  
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0: 'zero'})
<type 'dict'>
>>> x = 1
>>> type(x) == int  # Check if types are equal  
True

# Three arguments  
>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))  # Creates a new type X  
>>> X
<class '__main__.X'>

next()

[[Basic Data Structures#Iterator Objects]]

String Functions

Built-in String Methods

1. Remove leading/trailing spaces or characters: lstrip(), rstrip(), strip()

str = "    人生苦短，我用Python。    "
print(str.lstrip())  # Remove left spaces and print  
print(str.rstrip())  # Remove right spaces and print  
print(str.strip())   # Remove both left and right spaces and print  

str_1 = '333与君相别离，不知何日是归期，我如朝露转瞬晞。333'
print(str_1.strip('3'))  # Remove all '3' characters from both ends and print  

Note: These functions essentially return a new substring rather than modifying the original object.
lstrip() returns a new string with leading spaces or specified characters removed.

str = "    人生苦短，我用Python。    "
str.lstrip()  # Only calls the function without assignment or output  
print(str)
'''
Output remains:
    人生苦短，我用Python。    
With spaces on both ends, indicating the object is unchanged.
'''

2. Check if a string starts/ends with a substring: startswith(), endswith()
   Returns True if yes, False otherwise.

str = "山有木兮木有枝，心悦君兮君不知。"
print(str.startswith("山"))  # Returns True and prints  
print(str.endswith('不知'))  # Missing '。', returns False and prints  

3. Format strings:

   $$f"string content {other_string_variable} string content"$$

   
   Returns the formatted string.
   To be filled

4. Split strings: split()
   Splits a string into substrings using a delimiter (excluded from substrings) and returns a list.

str = '根，紧握在地下，叶，相触在云里，每一阵风过，我们都互相致意。'
strP = str.split('，')  # Note Chinese punctuation  
print(str)  # Outputs the original string  
print(strP)  # Outputs the split string list  
print(strP[1])  # Outputs "紧握在地下"  

Numeric Functions

1. Absolute value: abs()
2. Integer conversion: int()
3. Rounding (returns integer): round()
4. Check size or truthiness (Boolean functions): bool()
   [[Data Types and Operators#Boolean Values and Null]]

Type Conversion Functions

1. $$int(x [, base])$$
   x is the original object, base is optional (default 10 for decimal).
2. $$float(x)$$
3. $$complex(real[, imag])$$
   real is the real part, imag is the optional imaginary part.
4. $$str(x)$$
5. $$repr(x)$$
   Converts x to an expression string (readable by the Python interpreter).
6. $$chr(x)$$
   Converts an integer to a character.
7. $$ord(x)$$
   Converts a character to its integer value.
8. $$hex(x)$$
   Converts an integer to a hexadecimal string.
9. $$oct(x)$$
   Converts an integer to an octal string.
10. $$eval(str)$$
    Evaluates a string as a Python expression and returns an object.
11. $$tuple(s)$$
    Converts sequence s to a tuple.
12. $$list(s)$$
13. $$set(s)$$
    Converts sequence s to a mutable set.
14. $$frozenset(s)$$
    Converts sequence s to an immutable set.
15. $$dict(d)$$
    Converts a sequence d of (key, value) tuples to a dictionary.

High and Low Data Types

1. “Higher” and “lower” data types refer to precision in implicit type conversion.
2. Precision reflects the amount of information a data type can represent.
3. Higher types can represent more information (e.g., floats > integers).
4. Order: Boolean (bool) < Integer (int) < Float (float) < Complex (complex).

Can Data Types Be Converted Freely?

While Python provides functions like int(), float(), str(), etc., not all conversions are possible. It depends on whether the data contains enough information for the target type.

Examples:

• Integers can be converted to strings (e.g., 123 → "123").
• Numeric strings (e.g., "123") can be converted to integers or floats.

Exceptions:

• Non-numeric strings (e.g., "Hello") cannot be converted to numbers.
• Lists or tuples can be converted to sets (if elements are immutable) but not to integers.

Conditional and Loop Statements

if, elif, else Statements

if condition1:
    # Execute if condition1 is True  
elif condition2:
    # Execute if condition1 is False and condition2 is True  
else:
    # Execute if both conditions are False  

Example:

name = input('Who are you?')
age = input('How old are you?')
if name == '朱冰倩' and age >= 19:
    print('Daring, long time no see.')
elif name == '朱冰倩' and age == 18:
    print('Thank you for being in my life.')
else:
    print('こんにちわ。')

• Falsy values: None, empty lists, empty sets, empty dicts, empty tuples, empty strings, 0, False.
• Truthy values: Non-empty sequences, non-zero numbers, True.

for, break, continue Statements

Basic Loop

for x in sequence:  # list, dict, string, tuple, etc.  
    # Code block  

• for iterates over the sequence, assigning each element to x.

Indexed Loop

• Use enumerate() to get both index and value.
• enumerate(sequence, [start=0]):
  • sequence: Iterable object.
  • start: Optional starting index (default 0).

galgames = ['咖啡馆', '千恋万花', '天使骚骚']
for index, galgame in enumerate(galgames, 1):
    print(f'Today, play the {index}th game: {galgame}.')

Output:
Today, play the 1th game: 咖啡馆.
Today, play the 2th game: 千恋万花.
Today, play the 3th game: 天使骚骚.

break

Exits the current loop. Different levels of break exit different loops.

continue

Skips the rest of the loop and proceeds to the next iteration.

for-else

• An else block after for executes if the loop completes normally (without break).
• continue is considered normal.

while

while condition:
    # Code block  

Executes the code block while condition is True.
Avoid infinite loops by ensuring the condition can be broken or break is triggered.

while-else

Similar to for-else, the else block executes if the loop exits normally (without break).

Published on 2023-06-27 at 孤筝の温暖小家, last modified on 2023-06-27

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Author: 孤筝(lvbowen040427@163.com)

Constants and Variables

• Variables do not require type declaration
• Python uses = for variable assignment and == to compare two values, returning True if equal and False otherwise.
• Variables must be assigned before use (unlike C). A variable is created only after assignment.
  • Undefined variable exception:

>>> age  
Traceback (most recent call last):  
    File "<stdin>", line 1, in <module>  
NameError: name 'age' is not defined  

Constants — Immutable Variables
Python has no mechanism to ensure variables won’t change objects. No error is raised if altered, unlike C’s const. Extreme caution is advised.

Assignment Methods

The assignment operator = is right-associative.

• Single assignment:
  • age = 18
• Batch assignment:
  • a = b = c = 1
    • Unthinkable in C/C++ :(
• Compute then assign:
  • age = 17 + 1
• Separate assignment:
  • a, b, c = 1, 2, 3
    • a == 1, b == 2, c == 3

When we write a = "Jack", the Python interpreter does two things:

1. Creates a string object 'Jack' in memory (constant).
2. Creates a variable a in memory and points it to 'Jack'.

When you assign variable a to another variable b, this operation points b to the data a points to, as shown below:

>>> a = "Jack"  
>>> a  
'Jack'  
>>> b = a  
>>> b  
'Jack'  
>>> id(a)  
4332916664  
>>> id(b)  
4332916664  

The id() function checks a variable’s memory address.
[[Basic Functions#id()]]

• If another value is assigned to a, id(a) changes while id(b) remains the same:

>>> a = "Ross"  
>>> a  
'Ross'  
>>> id(a)  
Another number (different from 4332916664)  

Variables and Objects

In Python, everything is an object: numbers, lists, functions—everything. Variables are references (or labels/names) to objects, and all operations on objects are performed through these references.

For example:

>>> a = 1  

• Here, the number 1 is the object, and a is the variable (name).
• The assignment = binds a name to an object (labels the object 1 with a).
• An object can have multiple labels (variables), but a variable can only bind to one object.
• Variables themselves have no type; the type is stored in the object and determined by the object’s type.
  • Thus, Python doesn’t require variable type declarations upfront, as it automatically infers the object’s data type—a major difference from C/C++.

Strings

1. Python does not distinguish between single characters and strings.
2. Strings can be created with single '' or double "" quotes (but not mixed!).
3. Triple single or double quotes create multi-line strings:

>>> name_1 = 'Jack'  
>>> name_2 = "Rose"  
>>> sentence_1 = '''Rose,  
Jack,  
You jump,  
I jump!'''  
>>> sentence_2 = """Life is short,  
you need Python."""  
# Works perfectly!  

• To include quotes, use the escape character \.
  [[Basic Functions#String Functions]]

String Formatting

% Method

print('My wife is %c, she is %d.' % (name, age))

• % is followed by a tuple or dict to pass formatted values.
• Placeholder types:
  ![[Pasted image 20230628233506.png]]

>>> name = 'Bronya'  
>>> age = 18  
>>> print('My wife`s name is %s, she is %d years old.' % (name, age))  # % corresponds to the order in %()  
My wife`s name is Bronya, she is 18 years old.  

• Advanced
  • %[data name][alignment flag][width].[precision][type]
  • Data name is used for dict assignment; omit for arrays.
  • Alignment flags:
    • +: Show sign.
    • -: Left-align.
    • space: Add a space before positive numbers to align with negatives.
    • 0: Add a zero before positive numbers to align with negatives.
  • Width: Total length of the formatted string, padded with 0 or space if shorter.
  • Precision: Decimal places.
  • Type: Placeholder type.

format

• Use {} as placeholders in the string, then append .format() with the variables to fill.

>>> name = 'Kiana'  
>>> age = 18  
>>> print('My wife is {}, she is {}.'.format(name, age))  # Fill in order  
>>> print('My wife is {1}, she is {0}.'.format(age, name))  
'''  
Indices can be used inside {}.  
Numbers inside {} correspond to .format() tuple/dict indices.  
'''  
>>> print('My wife is {name}, she is {age}.'.format(name=name, age=age))  # Or use variable names (mapped by object attributes)  
>>> print('My wife is {name}, she is {age}.'.format(name='Kiana', age=18))  # Keyword mapping  

>>> list1 = ['Kiana', 18]  
>>> print("My wife is {0[0]}, she is {0[1]}.".format(list1))  # Dict index mapping  

• Advanced
  • {:[fill char][alignment][sign flag][#][width][,][.precision][type]}
  • Fill char: Defaults to space if omitted.
  • Alignment:
    • ^: Center.
    • <: Left-align.
    • >: Right-align.
  • Sign flags:
    • +: Show sign.
    • space: Add a space before positive numbers to align with negatives.
  • #: Show 0b, 0o, or 0x prefixes for binary, octal, or hexadecimal.
  • Width: Total string width.
  • ,: Enable thousand separators.
  • Precision: Decimal places.
  • Type: Placeholder type.

f-string

Formatted String Literals (f-strings), supported only in Python 3.6+.
Prefix the string with f to enable f-strings, allowing direct variable use inside {}.

>>> print(f'My wife is {name}, she is {age}.')  

• f-strings also support format control parameters:
  {variable:[fill char][alignment][sign flag][#][width][,][.precision][type]}

⭐ Slicing

• Sliceable objects: strings, tuples, lists.
  name[a:b:c]

1. The interval is [a, b), including a but excluding b. Omitting a starts from 0; omitting b goes to the end.
2. c is the step size (defaults to 1 if omitted).
   ==When c is negative, slicing goes backward.==

>>> name = "polaris"  
>>> print(name[1:3])  
'ol'  
>>> print(name[::-3])  
'sap'  
'''  
'ris' takes 's', 'ola' takes 'a', 'p' takes 'p'  
'''  
>>> print(name[::-1])  
'siralop'  
# String reversal  

3. Slicing doesn’t modify the original object. Use slicing to create copies:

>>> x = [2, 3, 6, 2, 5]  
>>> y = x[:]  
>>> y.sort()  
>>> print(x)  
[2, 3, 6, 2, 5]  
>>> print(y)  
[2, 2, 3, 5, 6]  

Integers, Floats, Complex Numbers

1. Integers (Int)

   1. 0x for hexadecimal.
   2. 0o for octal.

2. Floats (Float)

   1. Decimal form.
   2. Scientific notation, where 10 is replaced by e.
      • e.g., 1.23e-6.

3. Complex Numbers (Complex)

   1. Real part + imaginary part: a + bj.
   2. complex(a, b).
   3. Both a and b are floats.

4. [[Basic Functions#type()]]

5. Floor Division (integer part of division):
   a // b

6. Modulo:
   a % b

7. Absolute value:

>>> a = 10  
>>> b = 3  
>>> a // b  
3  
>>> a % b  
1  

Boolean Values and None

• True: Truthy (non-zero values, defaults to 1).
• False: Falsy (= 0, defaults to 0).
• None: Null value, not 0 (integer), and not a Boolean type but NoneType.

1. Notes:
   • Capitalize the first letter.
   • Any computation or expression returning True or False is a Boolean operation, e.g., comparison.
2. The following evaluate to False:
   • 0, 0.0, -0.0
   • None
   • Empty strings, lists, tuples, dictionaries.
3. The following evaluate to True:
   • -1, 1, or any non-zero value.
   • All non-empty strings, including "False".
   • All non-empty dictionaries, lists, sets, tuples.
4. Boolean values can be used in arithmetic: True == 1, False == 0.

Boolean Operations

1. AND (and):
   • Only returns True if all operands are True.
2. OR (or):
   • Returns True if at least one operand is True.
3. NOT (not):
   • Unary operator: Converts True to False and vice versa.
   • ==Right-associative==.

>>> True and True  
True  
>>> True and False  
False  
>>> False and True  
False  
>>> True and 0 + 3  
3  

>>> True or False  
True  
>>> 0 or True  
True  
>>> 0 or 0  
0  
>>> False or 31  
31  

>>> not 3  
False  

Operators

Python supports the following operators:

• Arithmetic
• Comparison (Relational)
• Assignment
• Logical
• Bitwise
• Membership
• Identity
• Operator Precedence

Arithmetic Operators

• **: Exponentiation, x ** y returns x raised to y.
  ==Right-associative==.

>>> 2 ** 2 ** 3  
256  
>>> (2 ** 2) ** 3  
64  
>>> 2 ** (2 ** 3)  
256  

• //: Floor division (returns the integer part of the quotient).
• When mixing integers and floats, integers are converted to floats.

Comparison Operators

• ==: Checks if two objects are equal.
  ==Python allows chaining comparison operators.==
  a > b == c is equivalent to a > b and b == c.

Assignment Operators

• **=: Exponentiation assignment, c **= a is c = c ** a.
• //=: Floor division assignment, c //= a is c = c // a.
• <<=: Left shift assignment, a <<= 2 is a = a << 2.
• >>=: Right shift assignment.
• &=: Bitwise AND assignment, a &= b is a = a & b.
• |=: Bitwise OR assignment.
• ^=: Bitwise XOR assignment.

Bitwise Operators

• &: Bitwise AND (right-associative).
• |: Bitwise OR.
• ^: Bitwise XOR.
• ~: Bitwise NOT (right-associative).
• <<: Left shift.
• >>: Right shift.

Logical Operators

• and: Boolean AND.
  • x and y: Returns False if x is False; otherwise, returns y’s evaluated value.
• or: Boolean OR.
  • x or y: Returns x if non-zero; otherwise, returns y’s evaluated value.
• not: Boolean NOT.
  • not x: Returns False if x is True, and vice versa.
  • ==Right-associative==.

Membership Operators

• in: x in Y (x is an object/variable, Y is a string/dict/tuple). Returns True if x is found in Y.
• not in: x not in Y. Returns True if x is not found.

Identity Operators

• is: Checks if two identifiers reference the same object (i.e., identical in essence).
  • x is y: Returns True if id(x) == id(y).
• is not: Returns True if id(x) != id(y).

⭐ Operator Precedence

1. (): Parentheses.
2. []: Indexing.
3. x.attribute: Attribute access.
4. **: Exponentiation.
5. ~: Bitwise NOT.
6. +@, -@: Unary plus/minus (sign).
   • +@, -@ are right-associative unary operators.
7. *, /, %, //: Multiplication, division, modulo, floor division.
8. +, -: Binary addition/subtraction.
9. <<, >>: Bitwise shifts.
10. &: Bitwise AND.
11. ^: Bitwise XOR.
12. |: Bitwise OR.
13. <, <=, >, >=, ==, !=: Comparison.
14. =, +=, -=, etc.: Assignment.
15. is, is not: Identity.
16. in, not in: Membership.
17. not: Logical NOT.
18. and: Logical AND.
19. or: Logical OR.
20. ,: Comma operator.

Published on 2023-06-27 at 孤筝の温暖小家, last modified on 2023-06-27

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!