Python面试题常用函数总结_python机试常用

‘%’.join(s.split©)
Traceback (most recent call last):
File “”, line 1, in
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©)
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() # 左端取出

![](https://img-blog.csdnimg.cn/img_convert/17a20586c8a0fc0a9ba8cab6d4352aff.png)


![](https://img-blog.csdnimg.cn/img_convert/507a48809daa5a916da5db0768c95fbc.png)


![](https://img-blog.csdnimg.cn/img_convert/246dc41494f2bd00c03bdd45db1e40bd.png)


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