Basic

exegesis

1
2
3
4
5
6
7
8
9
# 单行注释

'''
多行注释
'''

"""
多行注释
"""

Output

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# print 语法
# print(value, ... , sep = ' ', end = '\n', file = None)
# sep 表示分割符 end 表示换行 file 文件

# print 字符串 写法
S = "SCUT" # 定义字符串 S
print(S)
print('SCUT')
print("SCUT") # 建议和 cpp 保持一致
print('''SCUT''')
print("""SCUT""")
print('S' + 'C' + 'U' + 'T')
print(S, S, S) #中间会有空格

# file output
fp = open("data.txt", 'w') # w 写操作
print("SCUT", file = fp) # 输出到 data.txt
fp.close() # close file

# 自定义 sep end
print("SCUT", "SCUT", sep = '####', end = "@@@@\n")

import keyword
print(keyword.kwlist) # 输出 python 的关键字集合

Input

1
2
3
var = input("input Tips: ") # 以字符串读入 # input Tips 是 读入提示用户

print(var)

variable & constant

1
2
S = "SCUT" # 大写一般定义为常量
s = "SCUT" # 小写一般定义为边量

type

digit

1
2
3
4
5
6
7
8
9
10
11
12
# 数默认十进制
a = 1918 # 十进制
b = 0b011101111110 # 二进制
c = 0o3576 # 八进制
d = 0x77E # 16进制
print(a, b, c, d, sep = '\n')

# 复数
e = 19 + 18j
print(e) # 整个打印
print(e.real) # 实数部分
print(e.imag) # 虚数部分

string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# string

# \ 的转义用法
# \n 换行
# \t 制表
# \\ 一个反斜杠
# \" 双引号
# \' 单引号
print("\"SCUT\"")
print("\'SCUT\'")

Sc = """
S
C
U
T
"""
print(Sc)

# 0 1 2 3 4 5 6 7 正序下标
# SCUT1918
# -8 -7 -6 -5 -4 -3 -2 -1 逆序
SchoolTime = "SCUT1918"

S, C, U, T = "SCUT" # 字符串分解赋值
print(S, C, U, T)

# length
# len()
print(len(SchoolTime))

# 切片 得到str区间[l, r] stringname[N:M] 得到区间[N, M - 1] !!!
print(SchoolTime[2 : 6]) # 区间 [2, 5]
print(SchoolTime[-6 : -2]) # 区间 [-6, -3]
print(SchoolTime[:4]) # [0, 3] 前者默认 头部
print(SchoolTime[4:]) # [4, 7] 后者默认 尾部

# 字符串常规操作
# x + y 拼接
# x * n 复制 n 次 x 
# x in s 如果 x 是 s 的子串 结果为 True 否则为 False
School = "SCUT"
Time = "1918"
print(School + Time)
print(School * 10)
print("AB" in School)
print("SC" in School)

bool

1
2
3
4
5
6
7
# bool
flag = True
print(flag)
print(bool(10)) # 非 0 True
print(bool(0)) 
print(bool("SCUT")) # 非 空 True
print(bool(""))

code format

1
2
3
4
5
# 在文件最前面加上下面一句话 （包括 #）

# coding = utf-8
 
# coding = gbk

type transform

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
# get type
# type()
print(type("SCUT"))

# int to char 
# chr()
print(chr(83) + chr(67) + chr(85) + chr(84))

# chr to int
# ord()
print(ord('S'), ord('C'), ord('U'), ord('T'))

# to strting 
# str()
print(str(1918))

# to float
# float()
print(float(1918))

# to hex
# hex()
print(hex(1918))

# to oct
# oct()
print(oct(1918))

# to bin
# bin()
print(bin(1918))

# to list
# list(sequence)
print(list("SCUT"))

# to tuple
# tuple(sequence)
print(tuple("SCUT"))

# to set
# set(sequence)
print(set("SCUT"))

# eval
# 去除字符串引号 等价于执行内部语句
print(eval("1 + 9 * 1 + 8"))
S = "1 + 9 * 1 + 8"
X = eval(S)
print(X, type(X)) # 类型变化

compute

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# 加
print(1900 + 18)

# 减
print(1920 - 2)

# 乘
print(959 * 2)

# 除
print(3836 / 2) # float 类型

# 整除
print(3836 // 2)

# 取余
print(1918 % 3)

# 幂运算 
print(3**2) # = 9

# -=    x -= y  x = x - y
# +=    x += y  x = x + y
# *=    x *= y  x = x * y
# /=    x /= y  x = x / y
# %=    x %= y  x = x % y
# //=   x //= y  x = x // y
# **=   x **= y  x = x ** y

# swap
a = "SCUT"
b = "1918"
print(a, b)
a, b = b, a
print(a, b)

# 比较运算
# >
# <
# >=
# <=
# ==
# !=

# 逻辑运算
# and   = C++ &&
# or    = C++ ||
# not   = C++ !

# 位运算 (bit op)
# &     且 
# |     或
# ^     异或
# ~     取反

if else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
S = input()
if S == "SCUT":
    print("1918")

if not S:
    print("S is empty")
else:
    print(S)

print(S if S else "empty")
# result if condition else not condition

if S:
    if len(S) > 4:
        print("length > 4")
    elif len(S) > 1: # C++ else if ==> python elif
        print("1")
    else:
        print(S)
else:
    print("empty")

# python3 模式匹配 
match S:
    case "SCUT":
        print("School")
    case "1918":
        print("Time")
# 和 C++ switch 不同 不需要break 不会执行不匹配的语句

for while

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
for i in "SCUT":
    print(i)

for i in range(1, 10): # range(n, m) 生成[n, m)的序列 注意不包含 m
    print(i)

for i in range(10): # 默认从 0 开始
    print(i)

# for ... else ... 结构
sum = 0
for i in range(10): # 完全执行所有 i 才会执行 else 内的语句， 遇到 break 认为未执行完 
    sum += i
    if i == 9:
        # break # 不会执行 else
        continue # 会执行 else
else:
    print(sum)


S = ""
while S != "SCUT" :
    S = input("input: SCUT ")
    print(S)

# while ... else ... 结构 未遇到 break 退出循环才会执行 else 内的语句
i = 0
while i < 100 :
    i += 1
    if i == 99 :
        #continue
        break
else :
    print(i)

pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# pass 语句 占位符 空语句

# 不会报错
while "SCUT" :
    pass

"""
报错
while "SCUT" :


"""

# 类似的 if else for 也可占位

other

1
A = B = C # maybe wrong

data

sequence

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# subsequence
# S[start : end : offset] 从区间[start, end) 每次走 offset 步得到的 子序列

S = "SCUT1918"
Sub = S[1 : 7 : 2]
print(Sub)
Sub = S[-3 : -8 : -2] # offset < 0 倒着走 
print(Sub)
print(S[ : : ]) 


# operation
Sp = "SCUT"
Su = "1918"
print(Sp + Su)
print((Sp + Su) * 10) # output * 10

# x in s
if "SC" in Sp :
    print("find")

# x not in s
if "Sc" not in Sp :
    print("Not find")

# len(s) # return length of s
print(len(S))

# max(s) # return max_element of s
print(max(S))

# min(s) # return min_element of s
print(min(S))

# s.index(x)  # return the first occur index of x
print(S.index('U'))

# s.count(x)  # return the number of count
print(S.count('1'))

list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
# create list
# [element1, ... , elementn]
# list()
# type of elements can be different 
Sp = ['S', 'C', 'U', 'T']
Su = list("1918")
print(Sp) # S C U T
print(Su) # 1 9 1 8
I = list(range(1, 10, 2)) # 1 - 9  offset = 2
print(I)
print(I * 3) # list * 3
print(len(I))
print(max(I))
print(min(I))

del I # 删除 I
# print(I) # error


# for_each
for x in Sp :
    print(x)

for x in range(len(Sp)) :
    print(Sp[x])

for i, x in enumerate(Sp) :
    print(i, x) # i 为 序号 不是 索引

for i, x in enumerate(Sp, start = 10) :
    print(i, x) # 序号 i 从 start 开始增加

for i, x in enumerate(Sp, 10) : # 同上
    print(i, x)


# 特有的操作
# append(x)     末尾增加一个 x
# insert(index, x)  index 插入 x     
# clear()       清空
# pop(index)    删除 index 位置的元素
# remove(x)     移除第一个出现的 x
# reverse()     反转
# copy()        拷贝所有元素 生成一个新的列表

lt = []
lt.append(1)
lt.append(3)
lt.append(2)
print(lt)
lt.insert(0, 4)
print(lt)
# lt.remove(0) # not in 会 error
lt.remove(4)
print(lt)
lt.pop(0)
print(lt)

nlt = lt.copy()
lt.clear()
# id(x) 获取地址
print(lt, id(lt)) # id 与 下面的不同
print(nlt, id(nlt)) # 


# sort 不会产生新的列表对象
# list.sort(key = None, reverse = False) 排序方法, 默认升序
print(nlt, id(nlt))
nlt.sort()
print(nlt)
print(nlt, id(nlt))

nlt.sort(reverse = True)
print(nlt)

# sorted 外部函数 返回排序的列表 原表不会变化
# sorted(iterable, key = None, reverse = False) # 排序对象， 排序方法， 是否倒序（默认False）
NLT = sorted(nlt)
print(nlt)
print(NLT)

import random
# 列表生成
# lstname = [expression for item in range]
# lstname = [expression for item in range if condition]

lst = [x * x for x in range(10)]
print(lst) # 99 以内的平方数
lst = [random.randint(1, 100) for x in range(10)] 
print(lst)

lst = [random.randint(1, 100) for x in range(10) if x % 2 == 0] # 当 condition 满足时才生成数
print(lst)  

# 二维列表
"""
lst = [
    [],
    [],
    [],
    []
]
"""

LST = [
    ['S', '1'],
    ['C', '9'],
    ['U', '1'],
    ['T', '8']
]

print(LST)
# for_each
for row in LST :
    for x in row :
        print(x)

for i in range(4) :
    for j in range(2):
        print(LST[i][j])


# 二维列表生成
# lst = [[... 同 一维] for item in range if condition]
LST = [[i * j for j in range(10)] for i in range(10)]
print(LST)

tuple

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 不可变序列 tuple
# dataname = (element1, ..., elementn)
# dataname = tuple()

tp = ('S', 'C', 'U', 'T')
print(tp)

S = ['S', 'C', 'U', 'T']
tp = tuple(S)
print(tp)

# 序列共有操作
print(tp.count('S'))
print(tp.index('C'))
print(min(tp))
print(max(tp))
print(len(tp))
print('S' in tp)
print('S' not in tp)
#del tp # delete tp

# support [ : : ] 
print(tp[0 : len(tp) : 2])


# for_each
for i in range(len(tp)) :
    print(tp[i])

for x in tp :
    print(x)

for i, x in enumerate(tp, start = 10) :
    print(i, x)

del tp

# tuple 生成
tp = tuple((i * i for i in range(10))) # 内部第一个() 表示生成 第二个()用 tuple() 转换为tuple
print(tp)

dict

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
# dataname = {key1 : value1, ..., keyn : valuen}
# dataname = dict(key1 = value1, ..., keyn = valuen)
# dataname = dict(zip(lst1, lst2)) 
# key 要求是不可变类型 list 不行 tuple 可， int, float, string 可

dc = {1 : 'S', 9 : 'C', 1 : 'U', 8 : 'T'} # 同 key 后面的把前面覆盖
print(dc)

Sc = ['S', 'C', 'U', 'T']
Ti = [1, 9, 1, 8]
dc = dict(zip(Ti, Sc)) # 覆盖同上
print(dc)

dc = dict(s = 'S', c = 'C', u = 'U', t = 'T')
print(dc)

# 序列公共操作 
print(max(dc)) # 对 Key 操作
print(min(dc)) 
print(len(dc))
# del dc # 删除

# dict 访问
# dataname[key] 如果 key 不存在 KeyError 
# dataname.get(key, value)    如果 key 不存在 返回 value 
print(dc.get('s'))
print(dc.get('g')) # None
print(dc.get('g', "Not find")) # None


print(dc['s'])
# print(dc['g']) # wrong


# for_each
for x in dc :   # for_each key
    print(x) 

for x in dc.items() : # for_each (key, value)   x is tuple
    print(x) 

for key, value in dc.items() : # split tuple in key and value
    print(key, "->", value)

for i, key in enumerate(dc, 10) :
    print(i, key)

for i, key_value in enumerate(dc.items(), 10) :
    print(i, key_value)


# operation
# 添加
dc['q'] = 'Q'

print(dc.keys()) # 获取所有 key
print(dc.values()) # 获取所有 value

# 删除 key
print(dc)
print(dc.pop('s', "默认值"))
print(dc.pop('s', "默认值"))
print(dc)

dc.popitem() # 随机删除 (key, value)
print(dc)

# in 
print('s' in dc)
print('u' in dc)

# clear
# dc.clear()

# 字典生成式
# dataname = [key : value for ... if condition]
dc = {key : key * key for key in range(10)}
dc = {key : key * key for key in range(10) if key % 2 == 0}
print(dc)

set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# create 
# st = {element1, ..., elementn}
# 存储类型同 dict 
st = {1, 2, 3 ,4}
print(st)

# 直接用 {} 内容空 创建的是字典
# set() 创建空set
st = {}
print(type(st)) # st is dict
st = set()
print(type(st))
st = {"SCUT"}
print(st)
st = set("SCUT") # 不同 把 字符串 当序列分割
print(st)

# 序列公共操作
print(min(st), max(st), len(st), 'S' in st, 'S' not in st)

del st


# 集合操作
Sc = set("SCUT")
Ti = set("1918")

print(Sc & Ti) # 交集
print(Sc | Ti) # 并集
print(Sc - Ti) # 差集  A & (U - B)   U = A | B
print(Sc ^ Ti) # 补集  (A | B) - (A & B)

# add
Sc.add("Q")
print(Sc)

# remove
Sc.remove('U')
print(Sc)

# clear
# Sc.clear()

# in
print('S' in Sc)

# for_each
for x in Sc :
    print(x)

for i, x in enumerate(Sc, 10) :
    print(i, x)

string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# string 不可变类型
S = "SCUT1918"
# S[0] = 'T' # Error
print(S)

# 支持 sequence 公共操作
# min, max, len


# lower, upper
print(S.lower())
print(S.upper())

# count 
print(S.count('S'))

# find
print(S.find('S'))  # return index
print(S.find('V'))  # not find return -1

# index
print(S.index('S'))  # return index
# print(S.index('V'))  # Error

# startwiths(x)  是否以 x 开头 
print(S.startswith("SCUT"))

# endswith(x) 是否以 x 结尾
print(S.endswith("1918"))

Sc = "SCUT"
Ti = 1918
Va = 10.0
# 格式化字符串
# 一 占位符
# %s string
# %d digit
# %f float
print("School %s Time %d Value %f" % ("SCUT", 1918, 0.0))
print("School %s Time %d Value %f" % (Sc, Ti, Va))

# 二 f-string
print(f"{Sc} {Ti} {Va}")

# 三 dataname.format
print("{0} {1} {2}".format(Sc, Ti, Va))

function

basic

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# def 定义

def fib(n) -> int :
    if n == 1 or n == 0 :
        return 1
    return fib(n - 1) + fib(n - 2)

for i in range(30) :
    print(fib(i))

# 默认参数
def fib(n = 0) :
    if n == 1 or n == 0 :
        return 1
    return fib(n - 1) + fib(n - 2)

for i in range(30) :
    print(fib(i))


# 个数可变的参数 在参数前加 * 表示可变参数
def get_type(*data) :
    print(type(data)) # 可变参数 形成 tuple
    for x in data :
        print(type(x))

get_type(1918, "SCUT", 100.0)

# 列表当参数
get_type([1918, "SCUT", 100.0])
# 列表内容当参数 在列表前加 *
get_type(*[1918, "SCUT", 100.0])


# 个数可变的关键字参数
def get(**para) :
    print(type(para)) # 可变参数 形成 tuple
    for x in para.items() :
        print(x)

get(School = "SCUT", Time = 1918, Value = 100.0)


# return -> type

# lambda 参数列表 : 表达式
fc = lambda a, b : a + b
print(fc(19, 18))

# 字符串 整数 元组 不可变类型 值传递

# 列表 字典 集合 可变类型 引用传递

some useful function

1
2
3
4
5
6
7
8
9
# pow
print(pow(10, 100))

# sum
print(sum([1, 9, 1, 8]))

# round 四舍五入
print(round(9.4))
print(round(9.5))