a = list(map(int, input().split()))#将读入创建为一个整数list
len(a)#返回a的长度
a[i]#访问a中第i个元素
a[-i]#访问a中倒数第i个元素
a[1:5]#列表切片，返回[a_1,a_2,a_3,a_4]
#列表切片还可以写成
a[:] # 常用于拷贝
a[::-1] # 翻转
a[::2]
a[:5]
a[1:]
a[1:10:2]
#三维分别代码起点，终点（左闭右开），步长。可以参照下文中的range函数介绍一起理解。
a.sort()#升序排序
a.sort(reversed = True)#降序排序

a = [1, 2, 3]
b = [4, 5]
print(a + b)
# [1, 2, 3, 4, 5]

a = (1, 2, 3)

s = '1323'
s = list(s)

s = 'hello  my name is caidd!!!'
print(s.split())  # ['hello', 'my', 'name', 'is', 'caidd!!!']
print(s.split('my'))  # ['hello  ', ' name is caidd!!!']

d = {'str': 1, 'int': 2, 'float': 3}
print(d['str'], d['int'], d['float'])
# 1, 2, 3
d['str'] += 1
print(d['str'])
# 2
d['list'] = 4
d.pop('str')  # 删除键值
for i in d:  # 等价于d.keys()
    print(i)
'''
int
float
list
'''
for i in d.values():
    print(i)
'''
2
3
4
'''
for k, v in d.items():
    print(k, v)
'''
int 2
float 3
list 4
'''
if 'int' in d:  # 查询
    print('yes')
# d['str'] += 1 会报错，抛异常

s = set()  # 创建一个空集合
s.add(1)  # 加入元素 O(1)
s.remove(1)  # 删除1 O(1)
if 1 in s:  # 查找1是否在集合内 O(1)

a = {1, 2, 3}
b = {3, 4, 5}
print(a & b)  # 交集 {3}
print(a | b)  # 并集 {1, 2, 3, 4, 5}
print(a - b)  # 差集 {1, 2}
print(a ^ b)  # 对称差集 {1, 2, 4, 5}

for i in s:

a = 120
a = str(a) # 字符串 120
a = a[::-1] # 字符串 021
a = int(a) # 整型 21

for i in range(10):
    print(i)

if __name__ == "__main__":
    for i in range(10):
        print(i)

print(123)
if __name__ == "__main__":
    for i in range(10):
        print(i)

for i in range(n):
    # do something
i = 0
while i < n:
    # do something

for i in range(n):
    i += 1

for i in range(n): #遍历[0,n)
for i in range(1, n): #遍历[1,n)
for i in range(0, n, 2):#遍历[0,n)，步长为2
for i in range(n - 1, -1, -1):#倒遍历[0,n - 1)

if x % 3 == 0:
    # do something
elif x % 3 == 1:
    # do something
else:
    # do something

# a是一个list x是一个int
if x not in a: 
    # do something
#可以发现不用再用for逐个判断a是否有x，直接可以用in关键字就可以判断了，
#但复杂度仍然是O(n)并没变小
#不止是list，一些可迭代的高级数据类型也支持这种使用方法

def func(x):
    # do something
    return

def func1():
    print(1)
    def func2():
        print(2)
   	func2()
func1()

def func(x):
    return x + 1, x + 2
x, y = func(10)
print(x, y)

t = 10
def func(x):
    global t 
    t += 1
    return x + 1, x + 2
x, y = func(10)
print(x, y)

def work():
    t = 10
    def func(x):
        nonlocal t
        t += 1
        return x + 1, x + 2
    x, y = func(10)
    print(x, y)
work()

import math #导入math库
from math import *#导入math库下所有变量和函数
from math import sin, cos#导入math库下的sin，cos函数

import math #导入math库
print(math.sin(10))

from math import sin, cos#导入math库下的sin，cos函数
print(sin(10))

def abcdefgasdas(x):
    print(x)
    
abcdefgasdas(10)
func = abcdefgasdas
func(10)

# 上面是常用的读入一棵树，并给点赋权值的一种输入格式
# 读入方法如下
n = int(input()) # int()函数将input()获取的一行字符串转换为整数
for i in range(n - 1):
    x, y = map(int, input().split())# 因为一行有多个整数，首先对input()获取的字符串
    #用split()函数切割，该方法将返回一个以' '和'\n'为分隔符切片后的字符串列表
    #用map()函数就可以将这个列表中字符串数据全转换为整数，并赋给左值
    # do something
w = list(map(int, input().split()))
#w因为类型是列表，因此还要多一个list()，这是一个构造方法，将map对象转为list数据类型

s = input()

import sys
input = sys.stdin.readline

print(10) # 输出10并换行
print(1,2,3) # 输出1 2 3并在末尾换行
print(1, end = ' ') # 输出1并再末尾输出一个' '

file = open(r'input.txt', 'r')  # 字符串前的r表示后续紧跟的字符串不进行转义，即原始字符串
a = file.readline()  # 后面调用这个方法即可如input函数一样使用

file = open(r'input.txt', 'w+')
file.write('hello\n')  # write方法不如print会自动换行，若要换行需要手动加换行符

# 下列函数可以传入数字或者可迭代数据类型，常传入list
# 以list为例说明功能
max()  # 返回list的最大值，也可传入多个单体值返回最大，如max(1, 2, 3, 4)
min()  # 返回list的最小值，同max用法
sum()  # 返回list的和
any()  # 如果list中有True，返回True
all()  # 如果list中全部为True，返回True

# 内置的，求幂取模用的是快速幂算法，O(log(n))，n为指数
pow()  # 该函数有一个内置的，math库里也有一个，需要注意的是内置的更好，支持求幂取模，求逆元（带膜，指数取-1即可）
abs()  # 绝对值

factorial()  # 阶乘值
ceil()       # 向上取整
floor()      # 向下取整
comb()       # 求组合值
perm()       # 求排列值
gcd()        # 最大公约数
lcm()        # 最小公倍数
exp()        # e ** x 即 e 的 x 次方
log()        # 以e为底的对数值
log2()       # 以2为底的对数值
log10()      # 以10为底的对数值
sqrt()       # 求平方根
pi           # 圆周率的常量值，精度很高
e            # 自然常数
             # 三角函数一堆，不说了，自己查

#自定义排序方法
import functools
a = [1,2,4,3,5]
def compare_personal(x,y):
    if x > y: return -1 #如果x>y，让x在y前面，返回-1
    return 1#否则让x在后面，返回1
a.sort(key = functools.cmp_to_key(compare_personal))
print(a)# 输出为[5, 4, 4, 3, 1]
#当然如果只是想得到降序序列，有很简单的方法:
a.sort(reversed = True)

#a = [[6,5],[3,4],[5,6]]
a.sort(key = lambda A: (A[1],-A[0]))#按第1维升序，第二维降序排列

b = sorted(a， key = lambda A: (A[1],-A[0]))

a = [1, -2, 3, -4, 5, -6, 7]
print(list(map(abs, a)))
# [1, 2, 3, 4, 5, 6, 7]

q = deque()         # 创建空队列
q = deque([1,2,3])  # 创建元素为1,2,3的队列
q.append(1)         # 尾插
q.appendleft(1)     # 头插
q.extend([1,2])     # 尾插可迭代对象
q.extendleft([1,2]) # 头插可迭代对象
q.pop()             # 将队列尾部的数据弹出，并作为返回值。
q.popleft()         # 将队列头部的数据弹出，并作为返回值。

from collections import defaultdict

a = defaultdict(int)  # 默认返回int类型的默认值，若写list，则键值不存在时返回空列表
print(a['caidd'])     # 0，此时创建了一个键值对
if a['rmx']:          # 此时创建了一个键值对
    print('yes')
print(a)              # defaultdict(<class 'int'>, {'caidd': 0, 'rmx': 0})

from collections import Counter

a = [1, 1, 1, 2, 3, 3, 5]
cnt = Counter(a)
print(cnt)     # Counter({1: 3, 3: 2, 2: 1, 5: 1})
print(cnt[1])  # 3
cnt[2] += 1
print(cnt[2])  # 2
print(cnt[6])  # 0

from heapq import heapify, heappop, heappush

q = [4, 2, 1, 4, 5]
heapify(q)  # 一次堆排序
heappush(q, 3)  # 放入1，并进行一次堆排序
print(heappop(q))  # 弹出堆头 3

a = [1,2,3,4,5]
b = [5,4,3,2,1]
for x, y in zip(a, b):
    print(x, y)

a = [1,2,3,4,5]
for i, x in enumerate(a):
    print(i, x)

from itertools import permutations, combinations
a = [1, 2, 3]
for p in permutations(a):
    print(p)
for p in combinations(a, 2):
    print(p)

from itertools import accumulate

a = [2, 3, 1, 6, 5, 4]
b = list(accumulate(a))
print(b)  # [2, 5, 6, 12, 17, 21]
c = list(accumulate(a, initial=0))  # 实际情况这种更常用，用作前缀和
print(c)  # [0, 2, 5, 6, 12, 17, 21]
d = list(accumulate(a, func=lambda x, y: max(x, y), initial=0))
print(d)  # [0, 2, 3, 3, 6, 6, 6]

from itertools import pairwise

a = [2, 3, 1, 6, 5, 4]
for k, v in pairwise(a):
    print(k, v)
'''
2 3
3 1
1 6
6 5
5 4
'''

import operator
from functools import reduce

a = [1, 2, 3, 4, 5]
print(reduce(operator.add, a))  # 15，同 sum
print(reduce(lambda x, y: max(x, y), a))  # 5，同 max
a = [[1, 2, 3, 4], [5, 6]]
print(reduce(operator.add, a))  # [1, 2, 3, 4, 5, 6] # operator调用的是加操作符，此处sum不可用

a, b = b, a

a = [x for x in range(6)]
#生成一个[1,2,3,4,5]的列表
adj = [[] for _ in range(n)]
#生成一个二维，空列表
#等同于 vector<vector<int>> adj(n);

# 求列表全体偶数和
sum(x for x in a if x % 2 == 0)
#判断列表是否严格单调递增
all(a[i - 1] < a[i] for i in range(1, n))

a = [[0] * 2 for i in range(4)]

a = [[0] * 2] * 4

a = [[0] * 2] * 4
a[0][0] = 1
print(a)
'''
[[1, 0], [1, 0], [1, 0], [1, 0]]
'''

x = 10
y = 20
a = x if x == y else y
print(a)
# 输出为20，返回的是在判断x==y为假后，返回了y并赋值给a

mp = {}
mp = dict()
mp = {a : b for a, b in lst}#将列表元素构造为键值对放入字典