公司下个月有编程比赛,多年前大学的时候我曾使用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))