Summary of Basic Knowledge for Python Beginners

0. Prerequisites
1. Common Data Types

NOTICE
1.1 Numerical Operations
NOTICE
1.2 Strings
1.3 Indexing and Slicing
1.4 Lists
1.5 Tuples
1.6 Dictionaries
1.7 Sets

2. Control Flow

2.1 if
2.2 while
2.3 for with range/zip/enumerate
3. Functions
4. Input and Output (Standard Input and Output)
5. File Operations
6. Packages
7. Classes
8. Exception Handling
Understanding that variables in Python are all pointers/references

0. Prerequisites

Statements in Python can be executed directly without needing to be written inside a main function like in C/C++.
Use# to indicate that everything from here to the end of the line is a comment, similar to the use of// in C/C++.
All data in Python is stored in objects, even numbers like 123 are also objects.
Variable assignment does not require prior declaration or type specification, for example, a = 123.
From a C/C++ perspective, variables are all of typeobject*, so they can point to any object.
Arrays are of typeobject*[], so they can store any objects mixed together.
Usetype(x) to get the type of an object,dir(x) to get the methods of an object, andid(x) to get the ID of an object, which is actually the address of the object, similar to(size_t)&x.

1. Common Data Types

Type	Name	Example
int	Integer	-100
complex	Complex Number	1 + 2j
bool	Boolean	Only True and False
float	Floating Point	3.1416
str	String	‘hello’, “abc”
list	List	[1, 0.3, ‘hello’]
tuple	Tuple	(‘hello’, 10)
set	Set	{1, 2, 3}
dict	Dictionary	{‘dogs’: 5, ‘pigs’: 3}
NoneType	Only None

NOTICE

int has no size limit and can perform operations on arbitrarily large integers.
float is a 64-bit floating point, equivalent to the double type in C/C++.
bool type only has True and False with the first letter capitalized.
NoneType is a special type that has only one value/object instance, None, which is typically used to represent a null value, similar to nullptr in C++.

1.1 Numerical Operations

// is floor division (rounding down, even for negative numbers).
round(-3.9) rounds to the nearest integer (rounding half away from zero).
= is based on value comparison, whileis is based on id (address) comparison.
To check for inequality, generally writea is not b, notnot a is b.
Comparison operations can be chained, and any number of comparisons can be chained:1<2<3 is equivalent to1<2 and 2<3.

NOTICE

To check for None, useis andis not, not== and!=, because None is a unique object and equality should be checked based on id, not value.

1.2 Strings

Strings can be enclosed in single or double quotes.
Single quotes within single quotes (or double quotes within double quotes) need to be escaped with\, but single quotes within double quotes (or vice versa) do not require escaping.
Triple single/double quotes can span multiple lines.
String operations: (strings are immutable, any operation returns a new string object)

" ".join(["1", "2", "3"]), results in'1 2 3', which joins the three elements of the string sequence with a space.

Concatenation:'ab' + 'cd' -> 'abcd'
Repetition:'ab' * 3 -> 'ababab'
Splitting:a.split(b), splits a using string b as the delimiter
Joining:a.join(b), joins the elements of string sequence b using string a:
Replacing:a.replace(b,c) replaces all occurrences of b in string a with c, for example, "1,2,3".replace(",","@"), results in"1@2@3".
Case conversion:upper() and lower().

String conversion:

str(a): converts a to a string
hex(a), oct(a), bin(a): converts integer a to hexadecimal, octal, and binary string respectively
int(str,b): converts string str to an integer of base b
float(str): converts string str to a float

Raw strings: prefix with r to indicate that\ should not be treated as an escape character, which is very convenient for handling Windows paths and regular expressions.
Template strings: prefix with f, which is very convenient when needing to use variable values, just enclose the variable in{}, and inside{} you can have not only variable names but also other expressions.

Example 1:

a = 1
b = 2
f"a's value is {a}, b's value is {b}"
# Result is 'a's value is 1, b's value is 2'

- Example 2:

a = 1.2345678
f"a ≈ {a:.3f}" # Keep 3 decimal places (PS: the left string is just a normal approximately equal sign ≈)
# Result is 'a=1.235'

- Example 3: If you want to use a plain `{` or `}` character, you need to write the escape identifier twice, similar to `%%` in printf

a = "b"
f" {{ a }} vs {a}"
# Result is '{a} vs b'

1.3 Indexing and Slicing

Indexing

For an ordered sequence, you can access the corresponding value by indexing. Strings are an example of an ordered sequence, and Python uses[] for indexing ordered sequences. Indexing starts at 0, where index 0 corresponds to the first element of the sequence, and an error will occur if the index exceeds the maximum value. Python also has negative index values, which count from the end.

Slicing

You can extract the desired subsequence from a sequence using the syntax:var[lower:upper:step], where the left is inclusive and the right is exclusive; step indicates the stride of the values. These three parameters can be partially omitted, for example:

a[:]: from start to end, creates a copy
a[1:]: from 1 to the end
a[:3], a[:-2]: from 0 to 3, from 0 to the second last
a[::-1]: reverse order

1.4 Lists

In Python, a list is an ordered sequence. Lists are generated using a pair of[] with elements separated by,, and the elements do not need to be of the same type, and the length of the list is also not fixed. You can also create an empty list usinglist() or[]. The operations on lists are similar to those on strings, as follows:

len(): outputs the length of the list
+: concatenation
*: repetition
Array indexing and slicing can be used for both reading and assigning values, and using slicing for assignment automatically expands the length of the list.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
a[5:7] = ["a", "b", "c", "d"] # Replace two elements with four elements
# Result is [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 8, 9]

You can also usedel to delete

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
del a[0:3]
print(a)
# Result is [4, 5, 6, 7, 8, 9]

List operations

l.append(a) adds a to the end of the list, treating any type of data as a whole
l.extend(a) if a is a sequence, it is equivalent to appending each element of the sequence
l.insert(idx,a) inserts a at index idx of the list
l.remove(a) removes the first occurrence of a, raises an error if it does not exist

Testing membership:in
Counting and indexing:l.count(a) returns the number of occurrences of a in list l;l.index(a) returns the index of the first occurrence of a in list l, raises an error if it does not exist (an AttributeError)
Adding, inserting, and removing:
Sorting and reversing:a.sort() sorts a in place, changing the values in a;sorted(a) returns a new sorted list without changing the original values;a.reverse() and reversed(a) indicate reversal, the difference is similar to the above.

1.5 Tuples

Similar to lists, tuples are also an ordered sequence, can be indexed and sliced, but they are immutable.

Empty tuple:() or tuple()
Note: A single-element tuple should be written as(1,) to avoid ambiguity with a regular parentheses expression.
Generally, tuples can be used to return multiple values from functions, and can also be used for multiple variable assignments. The counting function of tuplescount() and finding the first occurrence of an elementindex().

t = (1, 3, 4, 6, 7, 56, 83, 3)
print(t.count(3), t.index(56))
# Result is 2 5

w, x, y, z = 1, 2, 3, 4 # 1,2,3,4 is a tuple, parentheses can be omitted here
x = 1, 2, 3, 4
print(x, type(x))
print(type((1, 2, 3, 4)))
# Result is:
# (1, 2, 3, 4) &lt;class 'tuple'&gt;
# &lt;class 'tuple'&gt;

1.6 Dictionaries

A dictionary is a data structure composed of key-value pairs, and values can be accessed through keys. Dictionaries are unordered, so they do not have indexing or slicing.

Basic Operations

Creating a dictionary: can be created using{} or dict() to create an empty dictionary, and can also be initialized using the structurekey:value. Thedict() function requires a list of tuples as parameters, for example, a = dict([ ("1","a1") , ("2","b2") ]) constructs a dictionary with key-value pairs("1"->"a1", "2"->"b2") (i.e., the string “1” (key) corresponds to the string “a1” (value), and the other is similar).
Note:

The keys of a dictionary must be of an immutable type, such as integers, strings, tuples, etc., while values can be any Python object.
Generally, floating-point numbers are not used as keys due to precision issues.

a = {"blue": 1, "red": 2}
b = {"white": 3, "black": 4}
c = {"color1": a, "color2": b}
print(c) # Nested dictionaries

a = {1.1: "a", 2.2: "b", 3.3: "c"}
print(a[3.3])
print(a[2.2 + 1.1])
# The first one outputs c but the second one raises an error because 2.2+1.1 is not exactly 3.3 (it is approximately 3.3 but not exactly equal)

Dictionary Methods

Accessing values:d.get(key), compared to usingd[key], it will not raise an error if the key does not exist in the dictionary, but will returnNone.
Deleting elements:d.pop(key), deletes and returns the key-value pair for key, returnsNone if it does not exist. You can also usedel d[key] to delete.
Updating a dictionary:d.update(d'), updates elements from dictionary d’ into d.
Querying a dictionary:a in d, checks if key a is in dictionary d. Note: “not in” is generally written asa not in d rather thannot a in d
keys method:d.keys(), returns a sequence of all keys.
values method:d.values(), returns a sequence of all values.
items method:d.items(), returns a sequence of all key-value pairs as tuples.

1.7 Sets

A setset is an unordered sequence, so if there are two identical elements, only one will be retained; and to ensure that there are no duplicate elements, the elements added to a set must be deterministic objects. Because it is unordered, there are also no indexing or slicing. Sets can be created using{} or set(), but to create an empty set, you can only useset(), because{} represents an empty dictionary.

Set Operations

Union:a.union(b) or a | b
Intersection:a.intersection(b) or a & b
Difference:a.difference(b) or a - b; elements in a that are not in b
Symmetric Difference:a.symmetric_difference(b) or a ^ b; elements in a or b, but not in both a and b
Subset relationship:

Check if a is a superset of b:a.issuperset(b) or a <= b
Check if a is a proper subset of b:a < b

Set Methods

Add a single element:s.add(a), adds a to set s
Add multiple elements:s.update(seq), adds all elements from seq to set s
Remove a single element:s.remove(b), removes b from set s, raises an error if it does not exist

2. Control Flow

2.1 if

The basic structure isif <condition>:
Unlike C language, it does not require{}, but uses indentation to distinguish levels.
elif meanselse if.
False, None, 0, empty strings, empty lists, empty dictionaries, and empty sets are all consideredFalse.
Since indentation is mandatory, and the content after indentation cannot be empty, we usually write apass, which does nothing. When writing code, if you want to temporarily skip a branch, you can usepass as a placeholder.

if True:
    pass

2.2 while

The basic format iswhile <condition>:, you can usebreak to exit, andcontinue to proceed to the next iteration.

2.3 for with range/zip/enumerate

The basic format isfor <variable> in <iterable>, where iterable can be lists, strings,range, opened files, etc.
range:

range(3) -> 0, 1, 2
range(1, 5) -> 1, 2, 3, 4
range(1, 10, 2) -> 1, 3, 5, 7, 9, starts from 1 to 10, with a step of 2
range(n) automatically generates an arithmetic sequence from 0 to n – 1 (excluding n) with a step of 1

range is used to create a series of arithmetic sequencesrange(begin,end,step), where some parameters can be omitted.
You can also usebreak andcontinue.
A programming convention in Python is to use_ to indicate unused values, for example, if we want to loop 3 times but do not need the loop variable, we can write it like this. Optionally, you can addelse, which will execute when the loop exits normally rather than viabreak.

a = [1, 2, 3]
for i in a:
    if i == 1:
        print("1 is in a")
        break
else:
    print("1 is not in a")

for _ in range(3):
    print(233)

zip:

zip is used to iterate multiple iterables simultaneously (like lists, tuples), the number of iterations is based on the shortest one.
Assuming we have two listsnames = ['Alice', 'Bob', 'Candy'] and num = [1,2,3], usingzip(names,num) will yield an iterator consisting of three tuples, where the first position in the tuple corresponds to the element in thenames list, and the second element corresponds to the element in thenum list.

names = ['Alice', 'Bob', 'Charlie']
scores = [80, 90, 75]
for name, score in zip(names, scores):
    print(name, score)

enumerate:

Used to iterate both index and value simultaneously.
enumerate() returns an iterator containing each character and its corresponding index.

a = "abcdefg"
for i, j in enumerate(a):
    print(i, j)

List comprehensions:

More concise and understandable than for loops, and more efficient.

a = []
for i in range(10):
    a.append(i * i)
# Equivalent to

a = [i * i for i in range(10)] # Quickly generate the required list

- You can also add conditional statements in list comprehensions.

a = []
for i in range(10):
    if i % 2 == 0:
        a.append(i * i)
# Equivalent to

a = [i * i for i in range(10) if i

This document mainly explains the basic knowledge of Python, covering functions, input and output, file operations, packages, classes, exception handling, and variable references among other topics. Below is the content converted to Markdown format:

3. Functions

Format:def function_name(parameter_list):
Parameter List: directly write variable names, no need to specify types.
Default Parameters: use= to give default values to parameters, similar to default parameters in C++.
Return Value: usereturn to return, the return value can be of any type.
Three Parameter Passing Modes

Positional Arguments: pass parameter values in the order of their position in the function definition.
Keyword Arguments: pass parameter values by their names, not relying on their position.
Passing Parameters by Position or Keyword: when calling the function, you can pass parameter values either by their position in the function definition or by using keywords.
Assuming acomplex function is defined with parametersreal and imag, the callcomplex(real,imag) and complex(3,4) have the same effect.
In custom functions, you can use/ and * to declare the parameter passing method. Parameters before the forward slash/ are positional; parameters between the forward slash/ and the asterisk* can be passed either by position or keyword; parameters after the asterisk* must be passed by keyword. For example, def fcn_name(a, b, /, c, d, *, e, f), wherea and b are positional parameters, c and d can be passed either by position or keyword, and e and f are keyword parameters.

Setting Default Parameter Values: you can set default values for parameters when defining the function, and omit parameters with default values when calling.

def quad(x, a=1, b=0, c=0):
    return a * x**2 + b * x + c
print(quad(2.0))
print(quad(2.0, c=3))
# Result is 4.0 7.0

Receiving Variable-Length Parameters

*args indicates that excess positional parameters are passed as a tuple toargs.

def add(x, *args):
    total = x 
    for arg in args:
        total += arg
    return total
print(add(1, 2, 3, 4))
print(add(1, 2))
print(add(1))
# Result is 10 3 1

- `**kwargs` indicates that excess keyword parameters are passed as a dictionary to `kwargs` .

def add(x, **kwargs):
    total = x
    for arg, value in kwargs.items():
        print("adding ", arg)
        total += value
    return total
print(add(10, y=11, z=12, w=13))
# Result is:
# adding y 
# adding z 
# adding w 
# 46

Returning Multiple Values: a function can return multiple values, which will automatically become a tuple. Using tuple and array assignment, the values in the tuple can be assigned to corresponding variables, but the number of variables on both sides must match, otherwise an error will occur.

def f():
    return 1, 2, 3
a, b, c = f()
print(a, b, c) 
# Result is 1 2 3

a, b = 1, 2 
a, b = (1, 2) 
a, b = [1, 2] 
a,b,c = 1,2 
# Will raise an error

a = 1,2,3 
x,y,z = a

4. Input and Output (Standard Input and Output)

Useinput function to get input.

a = input("Please enter:")

print formatted output can use the previously mentioned template strings, and formatted input can consider using regular expressions.

5. File Operations

Writing Text Files: the first parameter is the file path, the second parameter is the open mode ('w' mode overwrites, 'a' mode appends), and theencoding parameter specifies the file encoding (commonly 'utf8', on Chinese Windows systems sometimes use'gb2312').

with open("123.txt", "w", encoding="utf8") as f:
    f.write("This is a line\n")
    f.write("This is another line\n")
with open("123.txt", "a", encoding="utf8") as f:
    f.write("Adding another line\n")

Reading Text Files: use'r' mode, and useencoding to specify the file encoding.

with open("123.txt", "r", encoding="utf8") as f:
    for i in f: 
        print(i)

with open("123.txt", "r", encoding="utf8") as f:
    a = f.read() 
    print(a)

f.read() returns the entire file as a single string; f.readlines() returns a list of strings for each line.

6. Packages

Importing Entire Packages:

import math
math.sin(math.pi / 4)

You can rename the imported package:

import math as mt
mt.sin(mt.pi/4)

Importing Specific Functions:

from math import sin
sin(1)

Importing Multiple Functions:

from math import sin
from math import cos

from math import sin, cos
cos(1)

Renaming Imported Functions:

from math import sin as math_sin
math_sin(1)

Importing Everything from a Package (Not Recommended):

from math import *

7. Classes

Basic Format:

class A:
    def __init__(self):
        self.a = 1
    def f(self, x):
        self.b = 1
        return self.a + x

Functions or variables that start and end with__ are special functions or variables, and the__init__ function is executed when an object is created, similar to a constructor.
Functions that do not start with_ or__ are generally consideredpublic; functions starting with one underscore areprotected, and those starting with two underscores areprivate (to be confirmed).
Non-static class member functions receive the class object as the first parameter, usually namedself.
Inheritance: In any function, you can add new attributes to an object usingself.xxx = xxx.

class A:
    def __init__(self, x):
        self.x = x
    def print_x(self):
        print(self.x)
class B(A):
    def __init__(self, y):
        super().__init__(233) 
        self.y = y 
    def print_y(self):
        print(self.y)
b = B(3)
b.print_y()

super() returns the inherited parent class, and super().__init__() calls the__init__ function of the parent class.self refers to the object constructed by the class, which is automatically passed in and does not need to be written out when called.type(x) can get the type of an object, and isinstance(obj,cls) can check if an object inherits from a certain class.

8. Exception Handling

try:
    pass
except...:
    pass
else: 
    pass
finally: 
    pass

try is followed by code that may throw an error.
except is followed by the type of error to catch, if not specified it is equivalent toexcept Exception, which can catch most error types, and the code to execute when an error occurs is written inside.
else is the code that executes when there is no error (optional).
finally is the code that will execute regardless of whether an error occurs (optional).
Useraise to throw a specified type of error, and you can also specify error feedback information.

raise ValueError ("Error message")

Useassert to throw anAssertionError type error when the assertion is false.

assert 1 + 1 == 3, "Does one plus one not equal three?"

Understanding that Variables in Python are All Pointers/References

a = [1, 2, 3]
b = a 
def f(b):
    b[1] = 100 
f(b)
print(b,a)
b[0] = 4 
print(a, b)

b = a[:]

b = list(a)
a = [1, 2, 3]
b = a[:]
b[0] = 4
print(a, b)

If the list contains lists, the above is a “shallow” copy and will not copy the inner lists. To deeply copy any object, usedeepcopy.

from copy import deepcopy
b = deepcopy(a)

0. Prerequisites

1. Common Data Types

NOTICE

1.1 Numerical Operations

NOTICE

1.2 Strings

1.3 Indexing and Slicing

Indexing

Slicing

1.4 Lists

1.5 Tuples

1.6 Dictionaries

Basic Operations

Dictionary Methods

1.7 Sets

Set Operations

Set Methods

2. Control Flow

2.1 if

2.2 while

2.3 for with range/zip/enumerate

3. Functions

4. Input and Output (Standard Input and Output)

5. File Operations

6. Packages

7. Classes

8. Exception Handling

Understanding that Variables in Python are All Pointers/References

Related posts

Leave a Comment Cancel reply