Python3一些常用函数

输入输出

input()

input([prompt])

参数说明：
prompt: 提示信息
函数接受一个标准输入数据，返回为 string 类型。无论输入的是数字还是字符串，统一按照字符串类型输出。

print()

打印输出

 print (value,...,sep='',end='\n',file=sys.stdout,flush=False)

运算符

**

**作为运算符表示乘方

//

整数除法，结果去掉小数位，5//2=2

if else三元操作符号

语法“[on true] if [expression] else [on false]”。

范围比较运算符

可以直接通过比较运算符来表示范围
x = 8
print(0 <= x <= 10) #输出TRUE

字符串判断

isdigit(),

str.isdigit() 检测字符串是否只由数字组成，只对 0 和 正数有效。

isupper()

如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是大写，则返回 True，否则返回 False。

islower()

如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写，则返回 True，否则返回 False。

isalpha()

检测字符串是否字母。

字符串转换

strip()

strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列

split()

split()方法有两个参数，即sep和maxsplit，这两个参数可以根据需要进行设置。sep参数：指定分隔符，如果不设置则默认使用空格作为分隔符。maxsplit参数：指定最大分割次数，如果不设置则默认为-1，表示分割所有出现的分隔符。返回一个列表，其中包含分割后的字符串。如果分隔符未找到，则返回包含整个字符串的列表。另外，如果分割符连续出现，则会在列表中生成空字符串。

join()

用于将序列中的元素以指定的字符连接生成一个新的字符串。‘’.join(seq)为直接变成字符串

upper()

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

lower()

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

ljust()

str.ljust(width[, fillchar])返回宽度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位（默认使用 ASCII 空格符）。 如果 width 小于等于原字符串长度，则返回原字符串.

replace()

str.replace(old, new [, count])
str 是要执行替换的字符串或字符串变量，各个参数的含义如下：old ： str 中要被替换的旧字符串。new ： 用于替换 str 中的新字符串。count ： 可选参数，指定 count 后，只有 str 中前 count 个旧字符串old被替换
replace(str,‘’)相当于删除

format()

（1）不设置位置，按默认顺序（从左到右）输出。

（2）指定位置

'学习{1}中的{0}函数'.format('format','python')

（3）设置参数

print('{name}, {age}'.format(name='John', age=30))

输出结果为：
John, 30

（4）数字格式化

 {:.2f}'.format(314.541) 

int()

int(x, base=10) x – 字符串或数字,base – 进制数，默认十进制，返回整型数据。。

bin()

bin(n),将整数转化为二进制字符串表示,
bin(10) =‘0b1010’

ord()

“ord（c）”
其中c为参数可以代入长度为1的字符(串）。如果长度大于1，则会报错：TypeError。
此函数的返回值为10进制整数。
ord(‘A’)) 返回65
ord(‘a’)返回整数97

chr()

chr(n)
给定一个整数 n，返回一个字符串，字符串的唯一字符是 Unicode 码点为 n 的字符。

字符串或列表查找

in,not in

判断是否在列表或字符串里

find()

方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
方法语法：

str.find(str, beg=0, end=len(string))

参数
str – 指定检索的字符串
beg – 开始索引，默认为0。
end – 结束索引，默认为字符串的长度。
返回值
如果包含子字符串返回开始的索引值，否则返回-1。

count()

用于统计字符串里某个字符或子字符串出现的次数。
可选参数为在字符串搜索的开始与结束位置。
str.count(sub, start= 0,end=len(string))
不同序列类型的 count() 语法：

s.count(x) # 通用语法，
str.count(sub[, start[, end]]) # 字符串，
list.count(x) # 列表，
tuple.count(x) # 元组
range.count(x) # 等差数列
bytes.count(sub[, start[, end]]) # 字节串
bytearray.count(sub[, start[, end]]) # 字节数组

字符串或列表切片

a[::-1]

字符串或列表反转,

a[:-1]

去掉最后一个元素的列表或字符串,

a[:8]

前8个元素构成列表或字符串

a[8:]

去掉前8个元素后构成列表字符串

a[-1]

倒数第一个元素

容器集合相关

range()

用来创建一个整数列表,range(end) 或 range(start,end[,step]) 参数说明：start:计数从start开始，默认是从0开始计数到end结束，但是不包括end。step:步长，默认为1.

len()

计算字符或列表长度;

min()

min返回可迭代对象的最小元素或者多个实参中的最小值。如果min函数只传入一个位置参数，那么这个实参必须是可迭代对象，min函数返回可迭代对象的最小值，如果传入多个位置参数，min函数返回他们中的最小值。

 min([4, 6, 1, 3]) 
 min((4, 28, 4, 88)) 
 min("abcd"),
 min(set([4, 6, 8, 10]))

list()

set转list非常的简单，直接将set的值放入list()的括号中即可，
相反，list转set也同样如此。

append()

用于给列表list添加元素

pop()

语法规则为：列表名.pop(index)，从列表list中删除指定索引上的元素，如果不指定 index，默认删除最后一个元素。

add()

用于给set添加元素，如果添加的元素在set中已存在，则不执行任何操作。

get()

dict.get(key, default=None)

get函数中包含了两个参数，其中key参数表示的是我们要在一个字典中要查找的键，第二个参数是设置默认的返回值的，返回默认值的时候，就表示在这个字典中没有存在值。这个函数的最后返回会是一个字典中的键的值，如果值不在字典中，那么默认返回的就是none

remove()

如果我们需要从集合中删除某个元素，我们可以简单地使用.remove方法进行操作，如下所示：s1 = {3,4,5,6} s1.remove(6)

discard()

不希望删除的时候会触发错误，那么我们可以简单的使用discard函数，该函数和remove函数功能一样，同时在删除不存在的元素时不会触发错误。

sort()

用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法：list.sort( key=None, reverse=False)
例如

sort(key=str.upper)#将所有字母不论大小写排序，相同时保证之前输入的顺序不变
res.sort(key=lambda x: (x.time, x.pay)) 先比较time，后比较pay，按小到大排列

sorted()

list = sorted(iterable, key=None, reverse=False)
其中，iterable 表示指定的序列，key 参数可以自定义排序规则；
reverse 参数指定以升序（False，默认）
还是降序（True）进行排序。
sorted() 函数会返回一个排序的列表。

map()

map(function, iterable, …)
参数function
函数iterable – 一个或多个序列 返回值 返回一个迭代器。

n, k, x = map(int, input().split())

for()

循环遍历列表或字符串语法,
(1) for item in list：
(2) for index in range(len(list)):
(3) for index,value in enumerate(list):
(4) for item in iter(list):

循环遍历Map语法，
(1) for k, v in my_dict.items():
(2) for k in my_dict.keys():
(3) for v in my_dict.values():

list合并

方法一：使用”+”运算符
可以使用”+”运算符将两个List合并成一个List。例如：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
new_list = list1 + list2
print(new_list) # 输出[1, 2, 3, 4, 5, 6]

上述代码演示了如何使用”+”运算符将两个List合并成一个List。

方法二：使用extend()方法
可以使用extend()方法将一个List中的元素添加到另一个List中。例如：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1) # 输出[1, 2, 3, 4, 5, 6]

上述代码演示了如何使用extend()方法将一个List中的元素添加到另一个List中。

方法三：使用运算符
可以使用运算符将一个List重复多次，并将它们合并成一个List。例如：

list1 = [1, 2, 3]
new_list = list1 * 3
print(new_list) # 输出[1, 2, 3, 1, 2, 3, 1, 2, 3]

上述代码演示了如何使用*运算符将一个List重复多次，并将它们合并成一个List。

方法四：使用列表推导式
可以使用列表推导式将多个List合并成一个List。例如：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
new_list = [x for x in [list1, list2]]
print(new_list) # 输出[[1, 2, 3], [4, 5, 6]]

上述代码演示了如何使用列表推导式将多个List合并成一个List。

[for in ]

ak=[0,1,2,3,4,5,6,7]
new_t = [x for x in ak]
print(new_t)
[0, 1, 2, 3, 4, 5, 6, 7]#这里是输出的new_t，
# 这个程序的功能是将ak中的值，赋值给new_t

[for in if]

下面看一下 for …in …if 语句

ak=[0,1,2,3,4,5,6,7]
new_t2 = [x for x in ak if x%2==0]
print(new_t2)
[0, 2, 4, 6]
#这里只看new_t2的赋值部分。new_t2 = [x for x in ak if x%2==0]
#if x%2的意思是 当x是偶数时，才能将ak中的值赋值给new_t2

二维矩阵

dp = [[0] * (n + 1) for _ in range(m + 1)]
 [[0,0] for _ in range(m + 1)]
distances = [list(map(int, input().strip().split())) for _ in range(bs_num)]

一些非内置函数

defaultdict

defaultdict([default_factory[, …]])
default_factory 接收一个工厂函数作为参数, 例如int str list set等.
defaultdict在dict的基础上添加了一个missing(key)方法, 在调用一个不存的key的时候, defaultdict会调用__missing__, 返回一个根据default_factory参数的默认值, 所以不会返回Keyerror.

from collections import defaultdict
    num_pos = defaultdict(list)

bisect(),insort()

import bisect
bisect 返回要插入元素在列表中的下标。假定列表是有序的。i
bisect_left 与 bisect 类似，只不过其默认将元素插到左边，所以返回的是插入到左边的下标。
bisect_left(a, x, lo=0, hi=None) ​,其目的在于查找该数值将会插入的位置并返回，而不会插入。如果x存在在a中则返回x左边的位置.
bisect_right与 bisect_left 相反。

import bisect
a = [1, 3, 4, 4, 6, 8, 9]
print(bisect.bisect(a, 4)) # 输出 4
print(bisect.bisect_left(a, 4)) # 输出 2

insort 会在列表中插入元素到正确位置，假定列表有序。如果列表无序，那么会返回空。默认插入到右边。
insort_left 和insort 类似。
insort_right 和insort_left 相反。

注意：bisect模块不会检查列表是否已排好序，进行检查的话会耗费大量计算。
因此，对未排序的列表使用bisect不会产生错误，但结果不一定正确。

cmp_to_key()

functools中的cmp_to_key可以将一个cmp函数变成一个key函数，从而支持自定义排序
例子
(1)

from functools import cmp_to_key
def cmp_new(x,y):
    if (x+y)>(y+x):
        return 1
    elif (x+y)<(y+x):
        return -1 # left
    else :
        return 0
s=input().split()
s.sort(key=cmp_to_key(cmp_new),reverse=True)

(2)

from functools import cmp_to_key 
L=[9,2,23,1,2]
sorted(L,key=cmp_to_key(lambda x,y:y-x))

输出：
[23, 9, 2, 2, 1]

sorted(L,key=cmp_to_key(lambda x,y:x-y))

输出：
[1, 2, 2, 9, 23]

(3)

sorted(L,key=cmp_to_key(lambda x:x[1]))