python借鉴

提示

做完之后输出的答案是什么类型需要注意,最好不要循环输出（因为小心最后一个数，不能有空格）

list1 = list(map(int,input().split()));

整数

次方还有根号（**2，**0.5）

四舍五入

print('四舍五入为 {0:.1f}。'.format(2.45))
结果：四舍五入为 2.5。

商和余数

分别取商和余数

divmod(10,3)
结果：(3, 1)

幂和余同时做

pow 三个参数都给出，表示先幂运算再取余：

pow(3, 2, 4)
结果：1

输出时用空格间隔，print(1, end=’ ')

list1 = [32,543,6543,654,645,0,0,0];
for i in list1:
    print(i,end=' ');

循环

从判断跳出循环（201403-2）

for i in range(3):
    result = 0;
    for j in range(2):
        print(j,end=' ');               #若只有这里，要输出3次 0 1
        if(j ==1):
            result=1;
            break;                      #这里的break,只是跳出这个判断而已
    if(result==1):                      #这里的break,已经是跳出了最上面的循环，也就是所有循环，所以输出1次 0 1
        break;

结果：

字符串

replace和eval,字符直接计算

def st190302():
    n=int(input())
    for i in range(n):
        a = input().replace('/','//').replace('x', '*')
        num=eval(a)
        if num==24:
            print('Yes')
        else:
            print('No')

if __name__ == '__main__':
    st190302()

输入str,可以用for拆分其中元素

n = input()
sum=0
for i in n:
    sum=sum+int(i)
print(sum)

十转二

将十进制转换为二进制：

> bin(10)
'0b1010'

十转八

十进制转换为八进制：

>>> oct(9)
'0o11'

十转十六

十进制转换为十六进制：

>>> hex(15)
'0xf'

八进制转十进制，

记得带上双引号
后面数字8代表，从什么进制开始转成十进制

int('04',8)

eval

检验由什么字符串结尾

Str='Runoob example....wow!!!'
suffix='run'
print (Str.endswith(suffix, 0, 19))
前一个数字是开始位，后面的事结束位
结果：False

检验是否只包含数字

isdigit()

如果字符串只包含数字则返回 True 否则返回 False…

检验是否只包含数字字符

isnumeric()

如果字符串中只包含数字字符，则返回 True，否则返回 False

所有小写

lower()

转换字符串中所有大写字符为小写.

首字母大写

title()

返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

整数和ASCII互转

整数转ASCII：

In [1]: chr(65)
Out[1]: 'A'

ASCII转整数：

In [1]: ord('A')
Out[1]: 65

列表

去除重复set

list1=[1,2,3,4,4];
a = set(list1);
print(a);

结果：

排序,sort，sorted(sorted可以赋值给其他变量，sort不行)

list1=[4,1,3,2];
list1.sort()
print(list1);

结果：

添加多元素

a=[3,7,4,2,6]
a.extend([0,10])# 一次就地添加0,10两个元素
结果：[3, 7, 5, 4, 2, 6, 1, 0, 10]

列表生成式

a=[i for i in range(50) if i&1]

两个列表找相同元素

print(set(a) & set(b))

查数字

#上面两个例子0是作为元素去查询，如果只有 304 这样的元素里面有0，也是查不到的
list1 = [321,354,764,5,87,3,0,25];
if(0 in list1):
    print("里面有0存在");
else:
    print("里面没有0存在");

list1 = ["321","354","764","5","87","3","0","25"];
if("0" in list1):
    print("里面有0存在");
else:
    print("里面没有0存在");

list1 = "423423";
if("0" in list1):
    print("里面有0存在");
else:
    print("里面没有0存在");

两个列表切片合并成一个列表

#方法一
list1 = [1,2,3,4,5];
list2 = [6,7,8,9,10];
list3 =[];
list3.append(list1[0:3]+list2[2:4]);
print(list3)

结果：[[1, 2, 3, 8, 9]]

#方法二：
list1 = [1,2,3,4,5];
list2 = [6,7,8,9,10];
list3 =[];
list3.append([list1[0:3],list2[2:4]]);
print(list3)
结果：[[[1, 2, 3], [8, 9]]]

多维列表降维

方法一：

oldlist = [[1, 2, 3], [4, 5]]
方法一，粗暴拼接法：
newlist = oldlist[0] + oldlist[1]

方法二：

 方法二，列表推导式：
newlist = [i for j in range(len(oldlist)) for i in oldlist[j]]

方法三：

 方法三，巧用sum：
newlist = sum(oldlist,[])

返回元素的位置

列表中最好用index,别用find(find只可以用在字符串上)
s = [32,453,603,7,0,423,45,0,422,654,4,43,0,53];
count = s.count(0);
s1 = str(s);
print(s1);
 print(type(s1));
n=0;
for i in range(count):

    print("0在列表中第",s.index(0,n));     # 这里的n表示从第n位开始查找
    n = s.index(0,n) +1;

结果：

扭转二维数组

方法一：

m,n = list(map(int,input().split()))        #定义m行，n列
numbersarray = []
for i in range(0, m):                       #在列表中再加m行列表，变成矩阵
    numbersarray.append(list(map(int, input().split())))
 print(numbersarray)
for x in range(n-1,-1,-1):                  #2、一共有多少行
    for y in range(0, m):                   #1、每行先输出m个元素
        print(numbersarray[y][x],end=' ')
    print()

结果：

方法二：

original = [
    [5, 1, 9, 11],
    [2, 4, 8, 10],
    [13, 3, 6, 7],
    [15, 14, 12, 16]
]

rotated = list(zip(*original[::-1]))
print(rotated)

结果：

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)]

列表反过来排列

list2 = [];
list_temp = [];

for i in range(n):
    list1 = list(map(int,input().split()));
    list2.append(list1);

for i in range(-1,-n-1,-1):             #反过来排序
    list_temp.append(list2[i][:]);
print(list2);
print(list_temp);

结果：

(2)更实用

li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
print(li[::-1])

结果：

深复制

from copy import deepcopy

list1 = [[6, 6, 6, 6], [6, 6, 6, 6], [6, 6, 6, 6]]

list3 = deepcopy(list1);
list3[0][0]=1;
print(list3);
print(list1)

这里千万记得不能,下面是浅复制

list1 = [[6, 6, 6, 6]]*3

列表实现栈

列表中使用：append,pop

列表实现队列（双向列表）

from collections import deque;

d1 = deque([1,2,3]);
d1.appendleft(2);
print(list(d1))

优先队列（堆序列）

import heapq
In [41]: a = [3,1,4,5,2,1]
In [42]: heapq.heapify(a) # 对a建堆，建堆后完成对a的就地排序
In [43]: a[0] # a[0]一定是最小元素
In [44]: a
Out[44]: [1, 1, 3, 5, 2, 4]
In [46]: heapq.nlargest(3,a) # a的前3个最大元素
Out[46]: [5, 4, 3]
In [47]: heapq.nsmallest(3,a) # a的前3个最小元素
Out[47]: [1, 1, 2]

使用场景 如果想要统计list中前几个最小(大)元素，那么使用heapq很方便，同时它还提供合并多
个有序小list为大list的功能。

基本原理 堆是一个二叉树，它的每个父节点的值都只会小于或大于所有孩子节点（的值），原
理与堆排序极为相似。

检验是否有“0”的元素

In [5]: all([1,0,3,6])
Out[5]: False

In [8]: any([0,0,1])
Out[8]: True

检验是否有不为“0”的元素

In [7]: any([0,0,0,[]])
Out[7]: False

In [8]: any([0,0,1])
Out[8]: True

创建复数

In [1]: complex(1,2)
Out[1]: (1+2j)

字典

取出key,value

from collections import OrderedDict
od = OrderedDict({'c':3,'a':1,'b':2})
for k,v in od.items():
	print(k,v)

合并两个字典

def merge_dict(dic1, dic2):
return {**dic1, **dic2} # python3.5后支持的一行代码实现合并字典
merge_dict({'a': 1, 'b': 2}, {'c': 3}) # {'a': 1, 'b': 2, 'c': 3}

由value查找key

1、

student = {'小萌': '1001', '小智': '1002', '小强': '1003', '小明': '1004'}
>>> new_dict = {v : k for k, v in dict.items()}

>>> new_dict ['1001']

结果显示：'小萌'

2、

student = {'小萌': '1001', '小智': '1002', '小强': '1003', '小明': '1004'}
>>> def get_key (dict, value):
	 return [k for k, v in dict.items() if v == value]

>>> get_key (student, '1002')

结果显示：'小智'

其它函数

序号	函数及描述
1	dict.clear()
删除字典内所有元素
2	dict.copy()
返回一个字典的浅复制
3	dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5	dict.has_key(key)
如果键在字典dict里返回true，否则返回false
6	dict.items()
以列表返回可遍历的(键, 值) 元组数组
7	dict.keys()
以列表返回一个字典所有的键
8	dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)
把字典dict2的键/值对更新到dict里
10	dict.values()
以列表返回字典中的所有值
11	pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem()
返回并删除字典中的最后一对键和值。

元组

根据第二位排列大小

若先比第二位，再比第一位的“双重条件”，先排好序，再.items()

s = [32,453,643,7,0,403,45,0,422,654,4,43,0,53];
s1 = set(s);		#set是去重，不会根据顺序去重的，所以在set后排序
dict1 = {};			#定义一个字典，并且赋值
for i in s1:
    dict1[i] = s.count(i);

print(dict1);
print("\n看一下dict1.items()是怎么样的",dict1.items(),"\n");		#.items()是元组的意思

maxnum = max(dict1.items(),key=lambda x:x[1]);	#这里表示用元组的形式比较，找出所有第二位最大的值
print(maxnum[0]);
d_order = sorted(dict1.items(),key=lambda x:x[0], reverse=True);
print(d_order);

算法

二维前缀和

二维前缀和必须是正方形矩阵即：n*n；若是后缀和反过来加0
4
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

n=int(input())
a=[]
count=0
for i in range(n):
    a.append(list(map(int,input().split())))
for i in range(n):
    a[i].insert(0,0)                        #先给每一行加0
a.insert(0,[0]*(n+1))                       #直接加入一行0
print(a)
S=[([0]*(n+1))for i in range(n+1)]          #初始化数组
print(S)
for i in range(1,n+1):
    for j in range(1,n+1):
        Sum=0
        Sum+=a[i][j]+S[i-1][j]+S[i][j-1]-S[i-1][j-1]
        S[i][j]=Sum


print(S)
for i in range(n+1):
    S[i].remove(0)
del S[0];
print(S)