ACM python 输入输出简记

这篇文章上次修改于 10 个月前，可能部分内容已经不适用，如有疑问可询问作者。

ACM python 输入输出简记

基本函数

输入：Python的输入是字符串，所以要自己转类型

strip去掉左右两端的空白符，返回str

slipt把字符串按字符（默认空白符）拆开，返回[str] ,

map把list里面的值映射到指定类型，返回[type]

EOF用抓异常

print后面加逗号就不会换行，否则反之。

其他常用处理函数

sort sorted 注意前者无返回值，直接对原列表处理，后者返回一个新的列表。

PYTHON
sort(iterable, cmp=None, key=None, reverse=False)
sorted(iterable, cmp=None, key=None, reverse=False)
Copy

list

对于list的操作简单记录一下

PYTHON

list = [] #定义
list.append(a) #在数组的末尾添加元素a
list.insert(i,a) #i为在哪一个位置插入a
list.extend([]) # 把某个列表插到list中，参数是一个列表
list.index(a) #在列表中搜索元素a，返回其位置
list.index(a,0,5) #在0,5搜索
list.remove(a) #删除第一个次出现的a
len(list) #列表长度
del list #把list在内存中清除
del list[1] #把list[1]删除
list[1:3] #只是拷贝 list[1],list[2] （3-1=2只有两个元素）
list1 = list[:] #列表拷贝
list2 = list #只是相等，list变，list2也变，只是指定另一个名字罢了
#列表之间的比较 默认从[0]开始
list = list1 + list2 # 合并列表
list * 3
# 列表判断元素
a in list 
a not in list
list.count(a) #a在list中出现的次数
list.reserve() #翻转
list.sort() 
list.sort(reserve = true) #从大到小
Copy

字典

删除

PYTHON
# del
# 使用del删除键值对,先要找到dict所对应的键,进行删除
# 注意,在字典中键值对是成对出现的,删除键值也就消失了,不能出现单独的键或者单独的值
dict1 = {'name': 'xiaoming', 'age': 18}
del dict1['age']
print(dict1)  # {'name': 'xiaoming'}

# clear() 清空字典
# 使用clear将字典所对应的内存空间中的数据进行了清空
dict1.clear()
print(dict1)  # {}

# 通过之前的学习经验我们猜测 pop是删除简直对用的
dict2 = {'name': 'xiaoming', 'age': 18, 'gender': '男'}
# 使用pop可以根据指定的key删除键值对
# 使用pop删除键值对后会将其键对应的值进行返回
# print(dict2.pop('name'))  # xiaoming
# print(dict2)  # {'age': 18, 'gender': '男'}

# 猜测:popitem也是删除键值对使用的
# 随机删除一个键值对,一般都是删除最后一个
# 删除后会将我们所删除的键值对以元组的形式进行返回
print(dict2.popitem())  # ('gender', '男')
print(dict2.popitem())  # ('age', 18)
print(dict2)  # {'name': 'xiaoming'}

# dict  无序的  因为其不能通过索引进行键值对的获取(了解)
# Python3.5以后,字典中键值对的顺序和我们插入键值对的顺序保持一致,但是该顺序没法被利用(了解)
Copy

查询

PYTHON
# 直接使用key进行查询
dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
# 查询学员的名称?
print(dict1['name'])

# get查询
# 如果我们查询的键不存在会真么样??? 报错
# KeyError: 'apple'  会出现keyerror  表示查询的键不存在  报错
# print(dict1['apple'])
# 使用get进行查询,只需要在get中传入对应的键即可
# 如果使用get查询的键不存在,则不会报错,会默认返回一个None
print(dict1.get('name'))  # 小明
print(dict1.get('apple'))  # None
# 如果查询的键不存在,get可以自定义默认返回值
# 格式 字典.get(要查询的键, 查询的键不存在时返回的数据)
print(dict1.get('apple', '小刚'))
print(dict1.get('apple', 9))

# keys 获取当前字典中所有的键
print(dict1.keys())  # dict_keys(['name', 'age', 'gender', 'id'])
# keys返回的内容不是列表,而是dict_keys,该数据类型不能直接使用索引查询数据,但是可以进行for遍历
print(type(dict1.keys()))  # <class 'dict_keys'>
keys_1 = dict1.keys()
#  不能使用索引查询
# TypeError: 'dict_keys' object is not subscriptable
# print(keys_1[1])
# 可以被迭代
for i in keys_1:
    print(i)

# values 获取当前字典中所有的值
print(dict1.values())  # dict_values(['小明', 18, '男', '001'])
# dict_values不能使用索引查询,但是可以迭代
print(type(dict1.values()))  # <class 'dict_values'>

# items 获取当前字典中所有的键值对,键值对以元组形式展示
print(dict1.items())  # dict_items([('name', '小明'), ('age', 18), ('gender', '男'), ('id', '001')])
# dict_items不能使用索引查询,但是可以迭代
print(type(dict1.items()))  # <class 'dict_items'>
Copy

排序

PYTHON
#  单独打印出排序后的key值
new_sys = sorted(sys)
print(new_sys)

new_sys = sorted(sys.keys())
print(new_sys)

# 根据key的升序排列，把key value都打印出来
new_sys1 = sorted(sys.items(), key=lambda d: d[0], reverse=False)
print(new_sys1)

new_sys1 = sorted(sys.items(), reverse=False)
print(new_sys1)

# ============================================== #

# 单独打印出排序后的value值
new_sys1 = sorted(sys.values())
print(new_sys1)

# 打印出根据value排序后的键值对的具体值
new_sys2 = sorted(sys.items(),  key=lambda d: d[1], reverse=False)
print(new_sys2)
Copy

格式化

对于输出的处理格式：

%f ——保留小数点后面六位有效数字
　　%.3f，保留3位小数位

%e ——保留小数点后面六位有效数字，指数形式输出
　　%.3e，保留3位小数位，使用科学计数法

%g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
　　%.3g，保留3位有效数字，使用小数或科学计数法

%s

%10s——右对齐，占位符10位

%-10s——左对齐，占位符10位

%.2s——截取2位字符串

%10.2s——10位占位符，截取两位字符串

PYTHON

print('%d %d %d'%(a, b, c))  # 在一个括号内进行多个格式化输出）
Copy

四舍五入

round(number[, ndigits])

参数：

number - 这是一个数字表达式。

ndigits - 表示从小数点到最后四舍五入的位数。默认值为0。

返回值

该方法返回x的小数点舍入为n位数后的值。

PYTHON
 >>> round(1.1125)  # 四舍五入，不指定位数，取整
 1
 >>> round(1.1135,3)  # 取3位小数，由于3为奇数，则向下“舍”
 1.113
Copy

format使用

PYTHON
 >>> print('{} {}'.format('hello','world'))  # 不带字段
 hello world
 >>> print('{0} {1}'.format('hello','world'))  # 带数字编号
 hello world
 >>> print('{0} {1} {0}'.format('hello','world'))  # 打乱顺序
 hello world hello
 >>> print('{1} {1} {0}'.format('hello','world'))
 world world hello
 >>> print('{a} {tom} {a}'.format(tom='hello',a='world'))  # 带关键字
 world hello world
 >>> print('{} is {:.2f}'.format(1.123,1.123))  # 取2位小数
 1.123 is 1.12
Copy

其他格式：(直接在字符串前面加f来快速格式化）

PYTHON
name = 'qianfeng'
age = 18
sex = 'man'
job = "IT"
salary = 9999.99

print(f'my name is {name.capitalize()}.')
print(f'I am {age:*^10} years old.')
print(f'I am a {sex}')
print(f'My salary is {salary:10.3f}')

# 结果
my name is Qianfeng.
I am ****18**** years old.
I am a man
My salary is   9999.990
Copy

常用处理小连招

对于多组数据读入丝滑小连招：

PYTHON
while True:
    try:
        data=list(map(int,input().strip().split()))
        n,array=data[0],data[1:]
        print(sum(array))
    except EOFError:
        break
Copy

二维处理

对于二维数组处理小连招：

首先是m行n列的二维数组。常见的如下：

PYTHON
L = [[] * n] * m

# 或者append方法

l = 0 #行从0开始
mat = [] # 定义一个二维数组mat
while l < m:
    r = 0 #列从0开始
    line = [] #line存储每一行数据
    while r < n:
        line.append(0) #装载行数据
        r = r + 1
    mat.append(line) #按行装载二维数组
    l = l + 1
Copy

但是前者更改其中一行的值会导致每行的值都被更改。（对中间值引用了n次。故不推荐）

反转，旋转操作：

PYTHON
reversed = reversed(original)
rotated = list(zip(*original[::-1])) 
rotated = list(map(list, zip(*a[::-1])))
Copy

对于BFS，使用队列结构。

PYTHON
# 1.使用queue
from queue import Queue
q = Queue() # 定义，为什么是这样涉及python的设计，不是很懂
q.put(node) # 放入
q.get() # 出队
Copy