公司下个月有编程比赛，多年前大学的时候我曾使用C语言参加ACM比赛，后来尝试使用java，但现在我能相对熟练的语言只有python了，所以这篇文章主要是针对使用python3参加竞赛时的一些注意点。因为到时可以携带纸质资料，所以这里总结的要点也是我可以携带的资料之一。
一、python格式化输出
（一）%方式：print('%s %f'%('dd',num)) #注意后面有括号， %f ——保留小数点后面六位有效数字 ， %.3f，保留3位小数位
（二）format方式：1.通过位置 'a1 = {} a2= {} a3= {}'.format('first','second','third') #{}不带参数
'a1 = {1} a2= {0} a3= {2}'.format('first','second','third') #{}带位置参数的，输出：'a1 = second a2= first a3= third'
2.通过参数：'your name is {name} , age is {age}'.format(name='jack',age=87)
（三）round(number[, ndigits])
指定保留小数位数，四舍五入
参数：
number - 这是一个数字表达式。
ndigits - 表示从小数点到最后四舍五入的位数。默认值为0。
返回值
该方法返回x的小数点舍入为n位数后的值。
round(2.565, 2)
（四）日期格式化：
import time
print(time.strftime('%y-%m-%d|%H:%M:%S', time.localtime(time.time())))
2.56
（四）输出不换行
print('contents', end='!@#$%^&*')
end就表示print将如何结束，默认为end="\n"（换行）
例：print("祝各位身体健康", end=' ')
print("！")
二、python输入
（一）接收单个输入：a = input('please input a:')
（二）接收多个输入：按空格划分，用split隔开为list
1.str1 = input('please input nums')
numlist = str1 .split(' ')
for n in numlist:
print(n)
2. a, b, c= map(int, input('please input n,q').split()) #将输入按空格分开后，直接转化为int类型，无需一一转化
print(a,b,c)
（三）注意如果题目中输入没有提示，那么input中也不应该包含提示信息。否则可能无法通过。
三、字符串处理
（一）"".join()方法用于将序列中的元素以""中指定的字符连接生成一个新的字符串。 str1 = '!'.join(numlist) 结果：56!89!76，类似split的反操作，用某个字符把序列隔开。
（二）strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。 用法：str.strip([chars]); 中间可以是正则表达式； lstrip()：把左边的空格去掉； rstrip()：把右边的空格去掉
（三）实现字符串的contains功能：
方法1：使用 in 方法实现contains的功能：
site = 'http://www.jb51.net/'
if "jb51" in site:
print('site contains jb51')
输出结果：site contains jb51
方法2：使用find函数实现contains的功能
s = "This be a string"
if s.find("is") == -1: #找到时返回第一次出现的位置 ； str.find(str, beg=0, end=len(string))，可以指定查找范围
print "No 'is' here!"
else:
print "Found 'is' in the string."
（四）字符串替换：用字符串本身的replace方法:
a = 'hello word'
b = a.replace('word','python')
print b
四、循环
(一)for:使用range控制范围
for i in range(1,10):
for j in range(1,10):
print(i,j)
for i in range(100, 0, -2): #表示从100反向到0，每次递减2
for i in range(0, 100, 2): #表示从0到100，每次递增2
(二)while：使用计数变量（可以用于计数变量为非整型的情形）
x = -100
while x < 100.001:
y = a*x**3 + b*x**2 + c * x + d
if -0.001< y < 0.001:
print("%.2f" % x, end=" ")
x = x + 0.001
五、列表
定义： names = list() 或names = []
追加：names.append(element) 删除最后一个元素：names.pop()
插入：列表指定位置插入：list.insert(index, obj)。只要定义了列表，就算列表是空的也可以插入，但是在不初始化时，直接赋值是不行的。
x = []
x.insert(0, 1) #可以插入
x.insert(5,2) #可以插入，虽然序号越界了，但是默认插到最后
x[3] = 2 #报越界错误
翻转：list.reverse() #没有返回值，直接对list进行修改，所以print(list.reverse())只能得到None
删除：del li[2]，删除指定下表元素；li.remove(4)，删除指定值元素；li = li[:-1]，使用切片来删除。前几种不需要返回，直接对列表修改，但切片不会修改原列表，需要用一个变量来保存。
使用列表创建二维数组的正确方法：num_list = [ [0] * 5 for i in range(2)] 创建了一个初始值为0, 2*5的数组。如果不初始化为0，那么每一行是空的，不能直接用num_list[i][j]的方式进行赋值，只能用append追加。
初始化数组（直接在创建时初始化）：x = [i for i in range(10)]，新初始化了一个长度为10，元素为0-9的一维数组。列表元素去重：把num_list中的重复元素去掉，把列表中的列表作为一个整体去比较即可。如果是一维数组列表，直接转化为set即可。
num_list = [[1,2], [3,4], [1,2]]
num_list2 = []
for i in range(len(num_list)): #相当于获取行数，或者说是下一级元素个数
if num_list[i] not in num_list2:
num_list2.append(num_list[i])
print(num_list2)index方法：list.index(obj)。该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
六、类型转换
转整型:int() ,转字符串str(), 转浮点float(), #一般接收input输入的结果是字符串，需要转换为指定类型
字符串转列表：list(str)，但是str(list)无法把list转为字符串，而是会把list中的元素类型转为字符串。
列表转字符串：使用.join方法，''.join(列表名)，实质是一种拼接,前提是a中元素必须是字符串类型，不然无法拼接。如：
a = ['2', 'd', 's', '2']
b = ''.join(a)七、数学运算
（一）绝对值：abs(), #无需math包
（二）三角函数：math.sin() π：math.pi
（三）除法：与python2不同，python两个整数相除可能得到浮点数
（四）min, max, sum可以求序列的最小，最大值，总和。sum内必须是列表。min、max可以是多个数字。
max用于字典：b = {1:2, 2:3, 4:3, 5:-1} max(b)会输出最大key；b[max(b)]输出最大key对应的value；max(b, key=b.get)输出最大value对应的key，b[max(b, key=b.get)]输出最大value。或者直接用max(b.values()), max(b.keys())
（五）平方根：sqrt( x )
import math
math.sqrt( x )a = 434
b = 822
print(b/a) #返回实际结果，浮点
print(b//a) #取整除 - 向下取接近除数的整数
（六）进制换算
bin()、oct()、hex()的返回值均为字符串，且分别带有0b、0o、0x前缀。行表示原进制，列表示要转换结果进制。其他进制转10进制只需int(x, 原进制)，其他进制转其他进制，中间使用十进制过度一下。例：8进制到2进制，先用int(x, 8)把x转为10进制，再用bin(x)转为2进制。注意：x为字符串
八、函数
返回多个值时，可以用多个变量去接收或者当用一个变量去接收时，结果就是元组。
def func():
return 1,2
a,b= func() #a = 1, b = 2
c = func() # c = (1,2)
九、遍历
（一）字典：
插入（新增元素）：a = {} a[k] = v 即可。
遍历key：for key in a 和 for key in a.keys() 两者等价，因此list(a)和list(a.keys())都可以把key保存到列表中
遍历value：for value in a.values()
同时遍历key和value：for key,value in a.items():
例子：
dict1 = {1:'duoduo', 2:'girl'}
for k, v in dict1.items():
print(k, v)
for k in dict1:
print(dict1[k])
判断key是否存在：if name in d.keys()，返回True或者False
十、其他
（一）main函数：if __name__=="__main__":
（二）赋值：a,b = 1, 2(a=1, b=2) 交换：a,b = b, a
（三）zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
（四）逻辑判断 ：
# 比较运算符
a == b # a等于b（注意不能只用一个=，只用一个=是赋值运算符）
a < b # a小于b
a > b # a大于b
a >= b # a大于等于b
b <= b # b小于等于a
a != b # a不等于b
# 同一性运算符
a is b # a和b是同一个对象
a is not b # a和b不是同一个对象
# 成员运算符
a in b # a是容器b里的成员
a not in b # a不是容器b里的成员
# 布尔运算符（顺序运算符）
condition_a and condition_b
condition_a or condiction_b
not False（五）统计个数
1、某元素出现个数：字符串：str1.count(element) 列表：list1.count(element)
2.统计字符串、列表、字典长度： len(对象)
（六）高精度：由于python支持任意长度的数字计算，所以高精度题目用python可以直接做，直接进行大数相加、相乘等如a，b为大数，直接用 a + b即可 。例如本题：https://ac.nowcoder.com/acm/problem/15756。
（七）ord() 函数返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。 ord('a')，必须是字符
chr(x ) :将一个整数转换为一个字符。也就是将 ASCII转化为对应的字符。
（八）全局变量。如果函数中要使用全局变量，该变量必须定义在函数外部，并且在该函数内使用前先用global字段声明。
s = 0 #全局变量
def move(n, a, b, c):
global s #必须声明在该函数使用s之前的位置
if n == 1:
#print(a, '-->', c)
s = s + 1 #使用全局s
else:
move(n - 1, a, c, b)
#print(a, '-->', c)
s = s + 1#使用全局s
move(n - 1, b, a, c)
十一、类的使用
（一）类主要可以替代C语言中的结构体，一个对象中保存多个变量
（二）主要用法实例：
1.定义和使用
class Employee:
'所有员工的基类'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print("Total Employee %d" % Employee.empCount)
2.类的继承
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类
def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法'
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值
十二、python二维数组（多维数组）操作：用列表list可以实现，但是使用numpy包更加直接
（一）初始化和赋值操作
import numpy
import numpy as np
num_list = np.zeros((100, 100), dtype=np.int) #创建一个大小为100*100的矩阵，初始化为0，类型为int
for i in range(100):
for j in range(100):
num_list[i][j] = i + j
print(num_list)
初始化为1：x = np.ones((2,2), dtype = int) #shape可用中括号（二）numpy常用操作
import numpy as np
x = np.ones((20,20), dtype = int)
print(x.shape) #以元组形式输出数组维数，如果是二维的就是行数和列数
print(x.size) #输出数组总元素数目
y = x.reshape(10,40) #重新调整维数，前提是可以调整到指定维数
print(y.shape)
print(y.size)
z = np.empty([3,2], dtype = str) #创建一个3*2空数组
z[2][1] = '*'
print (z)
算法类：
1、递归
（一）斐波那契数列
def fib(n):
if n==0:
return 0
elif n==1:
return 1
elif n>=2:
return fib(n-1) + fib(n-2)
for i in range(10):
print(fib(i), end = ' ')
（二）汉诺塔问题
#coding:utf-8
def move(n, a, b, c): # n为圆盘数，a代表初始位圆柱，b代表过渡位圆柱，c代表目标位圆柱
if n == 1:
print(a, '-->', c)
else:
move(n - 1, a, c, b) # 将初始位的n-1个圆盘移动到过渡位，此时初始位为a，上一级函数的过渡位b即为本级的目标位，上级的目标位c为本级的过渡位
print(a, '-->', c)
move(n - 1, b, a, c) # 将过渡位的n-1个圆盘移动到目标位，此时初始位为b，上一级函数的目标位c即为本级的目标位，上级的初始位a为本级的过渡位
move(10, 'A', 'B', 'C')2、排序
（一）简单单元素排序
list1 = [2,3,1,5,6,7,3,10]
list1.sort() #按数字从小到大或者ASII码顺序排序
print(list1)
list1.sort(reverse = True) #反序
print(list1)
（二）待排序为一个对象时
# 简单的dict
lst = [('d', 2), ('a', 4), ('b', 3), ('c', 2)]
#其实就是指定排序要按照的属性
# 按照value排序，k表示lst中的每个对象, k[1]表示按照该属性排序
lst.sort(key=lambda k: k[1])
print(lst)
# 按照key排序
lst.sort(key=lambda k: k[0])
print(lst)
# 先按value排序再按key排序
lst.sort(key=lambda k: (k[1], k[0]))
print(lst)
#先按属性1降序排序，如果属性1相等，则按属性2升序排序：
stu_list = [[1,34, 32], [4,45,5], [2,89,5], [3,45, 32], [4, 28, 43], [4, 56, 43],[1, 34,67]] #定义对象列表，列表中可以是列表或者元组等，但是每个对象中元素数量必须相等。
stu_list.sort(key=lambda k: (k[0], -k[1]), reverse=True) #reverse=True表示顺序是降序，但由于属性2需要升序排序，所以使用-k[1]表示升序。
print(stu_list)（三）python实现经典排序
插入排序：
view sourceprint?
01 def insertion_sort(sort_list):
02 iter_len = len(sort_list)
03 if iter_len < 2:
04 return sort_list
05 for i in range(1, iter_len):
06 key = sort_list[i]
07 j = i - 1
08 while j>=0 and sort_list[j]>key:
09 sort_list[j+1] = sort_list[j]
10 j -= 1
11 sort_list[j+1] = key
12 return sort_list
冒泡排序：
view sourceprint?
1 def bubble_sort(sort_list):
2 iter_len = len(sort_list)
3 if iter_len < 2:
4 return sort_list
5 for i in range(iter_len-1):
6 for j in range(iter_len-i-1):
7 if sort_list[j] > sort_list[j+1]:
8 sort_list[j], sort_list[j+1] = sort_list[j+1], sort_list[j]
9 return sort_list
选择排序：
view sourceprint?
01 def selection_sort(sort_list):
02 iter_len = len(sort_list)
03 if iter_len < 2:
04 return sort_list
05 for i in range(iter_len-1):
06 smallest = sort_list[i]
07 location = i
08 for j in range(i, iter_len):
09 if sort_list[j] < smallest:
10 smallest = sort_list[j]
11 location = j
12 if i != location:
13 sort_list[i], sort_list[location] = sort_list[location], sort_list[i]
14 return sort_list
二分查找：
def search(list, key):
left = 0 # 左边界
right = len(list) - 1 # 右边界
while left <= right:
mid = (left + right) // 2 # 取得中间索引
if key > list[mid]:
left = mid + 1
elif key < list[mid]:
right = mid - 1
else:
return mid
else:
return -1
list = [2, 5, 13, 21, 26, 33, 37]
print(search(list, 5))