Python面试题常用函数总结

1. Python 中 join() 的用法

'a'.join(s) : 返回在 s 的每一个元素之间插入字符串 a 的新字符串。
参数说明
a：分隔符，可以为空
s：要连接的元素序列、字符串、元组、字典
上面的语法即：以 a 作为分隔符，将 s 所有的元素合并成一个新的字符串
返回值：返回一个以分隔符 a 连接各个元素后生成的字符串 

补充：os.path.join()函数
语法： os.path.join(path1[,path2[,…]])
返回值：将多个路径组合后返回
注：第一个绝对路径之前的参数将被忽略 

#对序列进行操作 使用‘ ’作为分隔符
s= ['hello' , 'how' , 'are' , 'you' ]
print(' '.join(s))
#对字符串进行操作
# 输出 hello how are you

# 对元祖进行操作
s = ('hello' ,'good' , 'boy', 'liu')
print(':'.join(s))
# 输出 hello:good:boy:liu

# 对字典进行操作
s = {'hello':1 , 'good':2, 'boy':3}
print(':'.join(s))
# 输出 hello:good:boy

# 合并目录
import  os
print(os.path.join('/hello/','good/boy/','xu'))
# 输出 /hello/good/boy/liu


>>> s='abcdefg'
>>> '%'.join(s)
'a%b%c%d%e%f%g'
>>> '%'.join(s.split(c))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'c' is not defined
>>> '%'.join(s.split('c'))
'ab%defg'
>>> s[:-1]
'abcdef'
>>> s[:len(s)]
'abcdefg'
>>> s[::]
'abcdefg'
>>> s[1:len(s):2]
'bdf'

2. list(s)函数

list(s) 函数将序列 s 转换为一个列表
描述：list() 方法用于将元组或字符串转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
语法：list( seq )
参数 seq 是要转换为列表的元组或字符串。
返回值：返回列表。

【拓展】：list1[0] 返回列表list1中的元素值；list1[:1] 返回列表。
>>> list1 = ['1', '2']
>>> list1[0]
'1'
>>> list1[:1]
['1']

>>> s='hello'
>>> print(list(s))
['h', 'e', 'l', 'l', 'o']

>>> s=('hello','world','123')
>>> print(list(s))
['hello', 'world', '123']

3. Python 中是没有 ++ 和 -- 操作的，自增自减操作可通过 +=/-=

4. split()函数

string.split(str, num)

str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。规定要执行的拆分数。默认值为 -1，即“所有出现次数”。

描述：split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串。它是按指定的分隔符，把一个字符串分隔成指定数目的子字符串，然后把它们放入一个列表中，其中每个单词都是一个列表项。

#例1：
>>> a="I love China"
>>> a.split()   # 分隔符为空，分割次数默认
['I', 'love', 'China']

#例2：
>>> b="I love China, and you, you"
>>> b.split(", ")    # 使用逗号和空格作为分隔符
['I love China', 'and you', 'you']
 
#例3：
>>> c="I#love#China#andyou#you"
>>> c.split("#")   #使用#作为分隔符
['I', 'love', 'China', 'andyou', 'you']

#例4：
>>> d="I#love#China#andyou#you"
>>> d.split("#",1)   # 将 max值为 1，将返回包含 2 个元素的列表
['I', 'love#China#andyou#you']
 
#例5：
>>> e="with great power comes great responsibility. I love China and you you"
>>> e.split(" ",15) #空格为分隔符
['with', 'great', 'power', 'comes', 'great', 'responsibility.', 'I', 'love', 'China', 'and', 'you', 'you'] 

5. 巧用 [::-1] python字符串切片方法 

[::-1] 是一个逆序操作，核心是切片。设有列表/字符a，则切片的语法为 b = a[start_index: end_index: step]

s1 = s[: : -1] 其实就是s1 = s[-1: : -1]

>>> s='the sky is blue'
>>> print(list(s)[::-1])
['e', 'u', 'l', 'b', ' ', 's', 'i', ' ', 'y', 'k', 's', ' ', 'e', 'h', 't']
>>> print(s.split()[::-1])
['blue', 'is', 'sky', 'the']
>>> print(s[::-1])
eulb si yks eht
>>> a=['h','e','ll','o']
>>> print(a[::-1])
['o', 'll', 'e', 'h']

6. Counter()函数 

Counter() 是 collections 库中的一个函数，可以用来统计一个 python 列表、字符串、元组等可迭代对象中每个元素出现的次数，即统计词频 并返回一个字典。

from collections import Counter
 
nums = [1, 1, 1, 6, 6, 6, 7, 8]
count = Counter(nums)  # 统计词频
for k, v in count.items():
    print(k, v)
print(count)
"""
输出：
1 3
6 3
7 1
8 1
Counter({1: 3, 6: 3, 7: 1, 8: 1})
"""

使用 Counter 统计完词频后可以使用 most_common 方法来查找出现频率最高的 k 个数字及其出现次数。

from collections import Counter
 
nums = [1, 1, 1, 6, 6, 6, 7, 8]
 
count = Counter(nums)
 
ansdict = count.most_common(2)  # 返回出现次数最多的两个数及其出现的次数
print(ansdict) # 注意输出格式
ans = []
for i in range(len(ansdict)):
    ans.append(ansdict[i][0])  # 提取出出现次数最多的两个数
print(ans)
 
"""
输出：
[(1, 3), (6, 3)]
[1, 6]
"""

7. 字典(Dictionary)的 get() 方法 

 get() 函数返回指定键的值。

dict.get(key[, value]) 

• key -- 字典中要查找的键。
• value -- 可选，如果指定键的值不存在时，返回该默认值。
• 返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。

tinydict = {'Name': 'Runoob', 'Age': 27}

print ("Age : %s" %  tinydict.get('Age'))

# 没有设置 Sex，也没有设置默认的值，输出 None
print ("Sex : %s" %  tinydict.get('Sex'))  

# 没有设置 Salary，输出默认的值  0.0
print ('Salary: %s' % tinydict.get('Salary', 0.0))

# 输出
Age : 27
Sex : None
Salary: 0.0

8. stack 栈 方法：stack.pop()出栈，stack.append()入栈，stack[-1] 表示栈中的最后一个元素

9. zip() 和 zip(*) 函数常用于矩阵转置（行变成列）

（1）传入一个参数时：

zip(iteration): 它的参数为多个可迭代对象，作用是聚合每个可迭代对象中的元素。
从iteration中依次取一个元组，组成一个元组。

（2）传入两个参数时 zip(a,b)：

zip()函数分别从a和b依次各取出一个元素组成元组，再将依次组成的元组组合成一个新的迭代器–新的zip类型数据。

其中，

- 要求a与b的维数相同，当两者具有相同的行数与列数时，正常组合对应位置元素即可；
- 当a与b的行数或列数不同时，取两者结构中最小的行数和列数，依照最小的行数和列数将对应位置的元素进行组合；这时相当于调用itertools.zip_longest(*iterables)函数。

>>> grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
>>> list(zip(*grid))
[(3, 2, 9, 0), (0, 4, 2, 3), (8, 5, 6, 1), (4, 7, 3, 0)]
>>> list(zip(grid))
[([3, 0, 8, 4],), ([2, 4, 5, 7],), ([9, 2, 6, 3],), ([0, 3, 1, 0],)]

10. tuple() 函数 

tuple()函数用于将列表、区间（range）等转换为元组。

注意：元组和列表非常类似，但列表与元组最大的区别在于：元组是不可改变的，列表是可改变的。元组支持的操作，列表基本上都支持；列表支持对元素的修改，而元组则不支持。从这个角度来看，可以认为列表是增强版的元组。

虽然大部分时候都可使用列表来代替元组，但如果程序不需要修改列表所包含的元素，那么使用元组代替列表会更安全。

用法：tuple(list/range...)，返回元组。

a = [1,2] #list
b = {"1":2,"3":3} #dict
c = {1,2,3,3}  #set
d = range(2,10,2) #range
print(tuple(a))
print(tuple(b))
print(tuple(c))
print(tuple(d))

#输出
(1, 2)
('1', '3')
(1, 2, 3)
(2, 4, 6, 8)

11. collections.deque() python自带的库函数 

collections是python自带的库，collections.deque()是双端队列，可以实现左右两端添加或取出元素的功能，时间复杂度均为O(1)，同时具有栈和队列的性质。

append()：从右端添加元素，与list相同。

appendleft()：从左端添加元素

extend()：从右端逐个添加可迭代对象，与list相同，Python中的可迭代对象有：列表、元组、字典、字符串。

extendleft()：从左端逐个添加可迭代对象，Python中的可迭代对象有：列表、元组、字典、字符串。

pop()：移除列表中的一个元素（默认最右端的一个元素），并且返回该元素的值（与list同），如果没有元素，将会报出IndexError。

popleft()：移除列表中的一个元素（默认最左端的一个元素），并且返回该元素的值，如果没有元素，将会报出IndexError。

count()：统计队列中的元素个数（与list同）。

insert(index,obj)：在指定位置插入元素（与list同）。

rotate(n)： 从右侧反转n步，如果n为负数，则从左侧反转。如：d.rotate(1) 等于 d.appendleft(d.pop())

maxlen：只读的属性，deque限定的最大长度，如果无，就返回None。当限制长度的deque增加超过限制数的项时，另一边的项会自动删除。

remove()：移除第一次出现的元素，如果没有找到，报出ValueError。

clear()：将deque中的元素全部删除，最后长度为0。

q = collections.deque()
q.append('a') # 在队列右边添加元素‘a’，deque(['a'])
q.appendleft('b') # 在队列左边添加元素‘b’，deque(['b', 'a'])
q.extend('c') # 在队列右边添加序列，deque(['b', 'a', 'c])
q.extendleft('d') # 在队列左边添加序列，deque(['d', 'b', 'a', 'c'])
# 关于append和extend的区别
# append添加一整个对象，不管该对象是什么类型，都作为一个整体全部添加进来，如整型数据或者一整个列表
# extend添加一个序列，只能是相同类型的元素，如该题中的字符/字符串或者是由字符和字符串组成的列表['st','e']，其他类型的数据如整数就会报错
q.append(['e','f'] # deque(['d', 'b', 'a', 'c', ['e', 'f']])
q.append(4) # deque(['d', 'b', 'a', 'c', ['e', 'f'], 4])
q.extend([g', 'h'] # deque(['d', 'b', 'a', 'c', ['e', 'f'], 4, 'g', 'h'])
q.append(5) # 报错 TypeError: 'int' object is not iterable
# 取出元素
q.pop() # 右端取出
q.popleft() # 左端取出

12. enumerate() 函数 

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标。

也就是说，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。一般用在 for 循环当中。

语法：enumerate(sequence[,startindex=0])

参数：

• sequence -- 一个序列、迭代器或其他支持迭代对象。
• start -- 下标起始位置。

season=['spring','summer','fall','winter']
print(enumerate(season))
# 输出 <enumerate object at 0x000002CE4C2EC870>
print(list(enumerate(season)))
# 输出 [(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]
for i in enumerate(season):
    print(i)
# 输出 (0, 'spring')
#      (1, 'summer')
#      (2, 'fall')
#      (3, 'winter')
for i,element in enumerate(season):
    print(i,season[i])
    print(i)
#输出 0 spring
#     0
#     1 summer
#     1
#     2 fall
#     2
#     3 winter
#     3

abc='abcdefg'
print(enumerate(abc))
print(list(enumerate(abc)))
for i in enumerate(abc):
    print(i)
for i,element in enumerate(abc):
    print(i,abc[i])

# 输出： 

<enumerate object at 0x000001B75A712828>
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e'), (5, 'f'), (6, 'g')]
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')
(6, 'g')
0 a
1 b
2 c
3 d
4 e
5 f
6 g

13. defaultdict(int) 函数 

    defaultdict 是 dict 的一个子类。通常 Python 中字典(dict)这种数据类型是通过键值对来存取的，当索引一个不存在的键时，就会引发 keyerror 异常。那么，defaultdict 就可以解决这个问题，它可以实现为不存的键值返回一个默认值。

    defaultdict是 collections 包下的一个模块，defaultdict 在初始化时可以提供一个 default_factory 的参数，default_factory 接收一个工厂函数作为参数， 可以是 int、str、list 等内置函数，也可以是自定义函数。

• defaultdict(int)：初始化为 0
• defaultdict(float)：初始化为 0.0
• defaultdict(str)：初始化为 ''

# ① 统计字符串中字母出现的个数

from collections import defaultdict
s = 'mississippi'
d = defaultdict(int)
for k in s:
    d[k] += 1
print(d)
# 输出
# defaultdict(<class 'int'>, {'m': 1, 'i': 4, 's': 4, 'p': 2})

#如果不用 defaultdict 的话，写法如下：
s = 'mississippi'
d = {}
for k in s:
    if k not in d:
        d[k] = 1
    else:
        d[k] = d[k] + 1
print(d)
# 输出
# {'m': 1, 'i': 4, 's': 4, 'p': 2}

s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d = defaultdict(list)
for k, v in s:
    d[k].append(v)
print(d)
# 输出
# defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})

# ② 使用 lambda 函数。
q = defaultdict(lambda: [0, 0, 0])
print(q['a'])
# 输出
# [0, 0, 0]

14. bisect.insort、bisect.bisect函数  

bisect是python内置模块，用于有序序列的插入和查找。

bisect.insort（seq,item）把变量 item 插入到序列 seq 中，并能保持 seq 的升序顺序。

bisect.bisect(a,c)：返回数组a中最后一个<=c的索引值+1

若c存在于数组a，bisect.bisect_left(a,c)返回数组a中第一个出现c的索引值

若c不存在于数组a，bisect.bisect_left与bisect.bisect等效

若c存在于数组a，bisect.bisect_right(a,c)返回数组a中最后一个等于c的索引值+1

若c不存在于数组a，bisect.bisect_right与bisect.bisect等效

import bisect
import random
 
SIZE = 7
random.seed(1729)
my_list = []
for i in range(SIZE):
    new_item = random.randrange(SIZE * 2)
    bisect.insort(my_list, new_item)
    print('%2d ->' % new_item, my_list)
# 输出结果为：
'''
10 -> [10]
 0 -> [0, 10]
 6 -> [0, 6, 10]
 8 -> [0, 6, 8, 10]
 7 -> [0, 6, 7, 8, 10]
 2 -> [0, 2, 6, 7, 8, 10]
10 -> [0, 2, 6, 7, 8, 10, 10]
'''