## python 基础题

### 1.进制间的转换

``````number = 20

# 方式一
# 二进制
print(bin(number))
# 八进制
print(oct(number))
# 十六进制
print(hex(number))
# 十进制
print(int(number))

# 方式二，只能转换为最后的int类型
# 将数字转按照八进制转换为int类型
print(int(str(number), base=8))
# 将数字转按照十六进制转换为int类型
print(int(str(number), base=16))
# 将0b二进制字符串按照二进制转换为int类型数字
print(int(str(bin(number)), base=2))

``````
``````0b10100
0o24
0x14
20
16
32
20
``````

``````b_number = 0b10100
print(b_number)
o_number = 0o24
print(o_number)
h_number = 0x14
print(h_number)
``````
``````20
20
20
``````

### 2.最大递归数

``````def recursion(n):
print(n)
n += 1
recursion(n)

recursion(1)

``````

``````python2.7: 1000, 在第1000次调用此函数时会出现异常
python3.6: 998, 在998次调用此函数时会出现异常
``````

``````import sys
sys.setrecursionlimit(1200)
``````

### 3.and、not、or运算符优先级

not x if x is false,then True,else False 1
x and y if x is false,then x,else y 2
x or y if x is false,then y,else x 3
``````v1 = 1 or 3  # 1
v2 = 1 and 3 # 3
v3 = 0 and 2 and 1 # 0
v4 = 0 and 2 or 1 # 1
v5 = 0 and 2 or 1 or 4 # 1
v6 = 0 or False and 1 # False
``````
``````1
3
0
1
1
False
``````

### 4.三元运算符，三目运算符

``````a = 10
# print(a > 2 ? a : 0)

print(a if a > 2 else 0)
``````

### 5.python2与python3区别

#### 1.python2 True、False可以作为一个变量，可以对其进行赋值及取值，python3则不可以, True、False作为关键字无法修改

``````True = 1
print(True)

False = 0
print(False)
``````

python2

``````1
0
``````

python3

``````    True = 1
^
SyntaxError: can't assign to keyword
``````

#### 2.python2默认使用ASCII编码，对中文需要手动添加文档头注释， python3则不需要

``````print('你好')
``````

python2

``````  File "/home/ts/flask_study/interview/05python2和python3的区别.py", line 12
SyntaxError: Non-ASCII character '\xe4' in file /home/ts/flask_study/interview/05python2和python3的区别.py on line 12, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details
``````

``````# -*- coding:utf-8 -*-
``````

python3:则没有影响

``````你好
``````

#### 3.python2的range返回一个list，资源消耗较大，python3返回一个可迭代对象，资源消耗较小，可使用for循环进行结果的迭代输出，python3的range取代了xrange。

``````data = range(10)
print(data)
print(type(data))

from typing import Iterable, Iterator, Generator
print(isinstance(data, Iterable))
print(isinstance(data, Iterator))
print(isinstance(data, Generator))
``````

python2

``````[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
<type 'list'>
``````

python3

``````range(0, 10)
<class 'range'>
True
False
False
``````

#### 4.python3引入nonlocal关键字，方便内部函数读取和修改外部函数的值，当内部函数读取和修改外部函数的值时，则外部函数和内部函数形成了闭包

``````def outter():
number = 10
def inner():
nonlocal number
number += 1
print(number)
return inner

outter()()
``````

python2

``````UnboundLocalError: local variable 'number' referenced before assignment
``````

python3

``````11
``````

``````import os

file_path = os.path.join(os.path.dirname(__file__), "01进制转换.py")
print(file_path)
with open(str(file_path), mode="r") as f:
print(f)
print(type(f))
# print(isinstance(f, Iterable))
for line in f:
print(line)
print(lines)
print(type(lines))
``````

### 6.布尔值为False的值

``````print(bool(0))
print(bool(None))
print(bool([]))
print(bool({}))
print(bool(""))
print(bool(0j))
``````

### 7.字符串、列表、元组、字典每个常用的5个方法？

#### 字符串

``````str_data = 'adminasdasd asdasd'
# 计算字符串中的元素出现次数
print(str_data.count('a'))
# 全部转为大写
print(str_data.upper())
# 以什么开头，可以指定开始的位置
print(str_data.startswith('a'))
# 截取字符串，使用较多
print(str_data.split('a'))
# 只在字符串首部将首字母大写
print(str_data.capitalize())
# 在字符串中的每个单词首字母大写
print(str_data.title())
# 字符串居中 前后补空格
print(str_data.center(22))
# 字符串前面补0
print(str_data.zfill(22))
``````
``````5
True
['', 'dmin', 'sd', 'sd ', 'sd', 'sd']
``````

#### 列表

``````list_data = [1,2,3,4, [5,6]]
# 添加元素
list_data.append(11)
print(list_data)
# 浅拷贝列表数据， 当修改其中的可变对象时，原有对象会发生改变
copy_list_data = list_data.copy()
print(copy_list_data)
copy_list_data[4].append(4)
print(list_data)
print(copy_list_data)
# 删除对应值的元素
list_data.remove(3)
print(list_data)
# 统计某个元素出现的次数
print(list_data.count(1))
# 两个列表合并
list_data.extend(copy_list_data)
print(list_data)
# 列表排序，元素需要是同类型， 默认是升序
# list_data.sort()
print(list_data)
# 在指定下标插入元素
list_data.insert(0, -1)
print(list_data)
# 删除对应下标的元素
list_data.pop(4)
print(list_data)
``````
``````[1, 2, 3, 4, [5, 6], 11]
[1, 2, 3, 4, [5, 6], 11]
[1, 2, 3, 4, [5, 6, 4], 11]
[1, 2, 3, 4, [5, 6, 4], 11]
[1, 2, 4, [5, 6, 4], 11]
1
[1, 2, 4, [5, 6, 4], 11, 1, 2, 3, 4, [5, 6, 4], 11]
[1, 2, 4, [5, 6, 4], 11, 1, 2, 3, 4, [5, 6, 4], 11]
[-1, 1, 2, 4, [5, 6, 4], 11, 1, 2, 3, 4, [5, 6, 4], 11]
[-1, 1, 2, 4, 11, 1, 2, 3, 4, [5, 6, 4], 11]
``````

#### 元组

``````tuple_data = (1,2,3,4,5,1,5)
# 统计元素出现的次数
print(tuple_data.count(1))
# 获取某个下标的元素
print(tuple_data.index(1))
``````
``````2
0
``````

#### 字典

``````dict_data = {"name":"tom", "age":10, "gender":"man"}
dict_data2 = {"city":"nanjing"}
# 获取字典的所有keys
print(dict_data.keys())
# 获取字典的所有values
print(dict_data.values())
# 获取字典的所有键值对，元组形式展示
print(dict_data.items())
# 合并两个字典
dict_data.update(dict_data2)
print(dict_data)
# 获取字典中的元素，可以设置默认值
print(dict_data.get('name', None))
# 删除字典中的元素
dict_data.pop('age')
print(dict_data)
# 生成新字典，取出字典的key， 设置默认的value值，默认value为None
print(dict_data.fromkeys(dict_data.copy(), "no data"))
# 删除字典中的元素，默认删除最后一个元素
dict_data.popitem()
print(dict_data)
# 获取字典中元素的值，当对应key不存在时会主动设置对应的key及返回设置的值， 当key存在时，此函数与get使用一致
print(dict_data.setdefault('age', 10))
print(dict_data)
# 清空字典
dict_data.clear()
print(dict_data)
``````
``````dict_keys(['name', 'age', 'gender'])
dict_values(['tom', 10, 'man'])
dict_items([('name', 'tom'), ('age', 10), ('gender', 'man')])
{'name': 'tom', 'age': 10, 'gender': 'man', 'city': 'nanjing'}
tom
{'name': 'tom', 'gender': 'man', 'city': 'nanjing'}
{'name': 'no data', 'gender': 'no data', 'city': 'no data'}
{'name': 'tom', 'gender': 'man'}
10
{'name': 'tom', 'gender': 'man', 'age': 10}
{}
``````

### 8.lambda使用方法及使用场景

``````def sum(m,n):
return m+n

print(sum(1,2))
sum2 = lambda m,n:m+n
print(sum2(1,2))
``````

lambda主要是针对于函数进行简化代码操作，但只能进行简单代码的简化，复杂代码不建议使用lambda，

#### 使用场景

##### 1.map、reduce、filter等进行序列处理时使用
``````l = list(range(1, 10))
data = map(lambda n:n*n, l)
print(list(data))

from functools import reduce
data = reduce(lambda m,n:m*n, l)
print(data)
``````
``````[1, 4, 9, 16, 25, 36, 49, 64, 81]
362880
``````
##### 2.lambda与list相结合, 注意lambda只会记录最后一次的状态，不会记录中间过程的状态
``````l2 = [lambda:i for i in range(10)]
print(l2[0]())
print(l2[3]())
``````
``````9
9
``````

### 9.pass的作用

pass主要就是在代码实现过程中，暂时没有想好怎么实现的时候，一般在函数、方法中使用较多，避免因为函数或方法中没有内容导致报错

### 10.*arg和**kwarg作用

#### 在函数或方法中, *args会将元素转换为元组, **kwargs会将x=y类似的元素转换为字典

``````def run(*args, **kwargs):
print(args)
print(kwargs)

run(1,2,a=1,b=2)
``````
``````(1, 2)
{'a': 1, 'b': 2}
``````

#### 2. *作为解包

``````l1 = [1,2,3]
l2 = [4,5,6]

l = list(zip(l1, l2))
print(l)
print(*l)
print(list(zip(*l)))
``````
``````[(1, 4), (2, 5), (3, 6)]
(1, 4) (2, 5) (3, 6)
[(1, 2, 3), (4, 5, 6)]
``````

#### 11. is和==的区别

is 不仅比较值也比较内存地址， == 只比较值

``````a = 1
b = 1
print(id(a))
print(id(b))
print(a == b)
print(a is b)

c = {"name":"mike", "age":13}
d = {"name":"mike", "age":13}
print(id(c))
print(id(d))
print(c == d)
print(c is d)
``````
``````10914496
10914496
True
True
140187512042624
140187511976800
True
False
``````

### 12.深拷贝与浅拷贝

#### 浅拷贝:复制的是对象的引用

``````import copy

data = [1, 2, 3, [4, 5, 6], {"name": "tom", "gender": "man"}]

copy_data = copy.copy(data)

copy_data.append(7)
print(data)
print(copy_data)
copy_data[3].append(8)
print(data)
print(copy_data)
copy_data[4]["city"] = "nanjing"
print(data)
print(copy_data)
``````
``````[1, 2, 3, [4, 5, 6], {'name': 'tom', 'gender': 'man'}]
[1, 2, 3, [4, 5, 6], {'name': 'tom', 'gender': 'man'}, 7]
[1, 2, 3, [4, 5, 6, 8], {'name': 'tom', 'gender': 'man'}]
[1, 2, 3, [4, 5, 6, 8], {'name': 'tom', 'gender': 'man'}, 7]
[1, 2, 3, [4, 5, 6, 8], {'name': 'tom', 'gender': 'man', 'city': 'nanjing'}]
[1, 2, 3, [4, 5, 6, 8], {'name': 'tom', 'gender': 'man', 'city': 'nanjing'},
``````

#### 深拷贝：生成一个新对象，将原始数据的值重新拷贝一份

``````import copy

data = [1, 2, 3, [4, 5, 6], {"name": "tom", "gender": "man"}]

copy_data = copy.deepcopy(data)

copy_data.append(7)
print(data)
print(copy_data)
copy_data[3].append(8)
print(data)
print(copy_data)
copy_data[4]["city"] = "nanjing"
print(data)
print(copy_data)

``````

#### 使用场景

``````1.在某些情况下，我们需要复制某个列表或者字典的数据时，就需要使用深拷贝，防止对原始数据造成影响
``````

### 13.可变类型和不可变类型

#### 可变类型：当数据的值发生改变时，内存地址不会发生改变

``````list_data = [1, 2, 4]
print(id(list_data))
list_data.append(5)
print(id(list_data))

dict_data = {"name": "tome", "gender": "man"}
print(id(dict_data))
dict_data.setdefault("city", "nanjing")
print(id(dict_data))

set_data = {1, 2, 4}
print(id(set_data))
print(id(set_data))
``````
``````2275116072896
2275116072896
2275115992448
2275115992448
2275116213728
2275116213728
``````

#### 不可变类型：当数据的值发生改变时，内存地址会发生改变

``````str_data = 1
print(id(str_data))
str_data = 2
print(id(str_data))

str_data = "a"
print(id(str_data))
str_data = "b"
print(id(str_data))

str_data = 1.0
print(id(str_data))
str_data = 2.0
print(id(str_data))

tuple_data = (1, 2, 3)
print(id(tuple_data))
tuple_data = (1, 2, 4)
print(id(tuple_data))
``````
``````2109049864432
2109049864464
2109051267184
2109051030000
2109050903248
2109050903024
2109051248000
2109051248256
``````

### 15.求以下代码的结果

``````t = []
v = dict.fromkeys(["k1", "k2"], t)
print(v)
v["k1"].append(666)
print(v)
v["k1"] = 777
print(v)
``````

``````{'k1': [], 'k2': []}
{'k1': [666], 'k2': [666]}
{'k1': 777, 'k2': [666]}
``````
``````def num():
return [lambda x: i * x for i in range(4)]

print(num())
print([m(2) for m in num()])
``````

``````[<function num.<locals>.<listcomp>.<lambda> at 0x0000026926836170>, <function num.<locals>.<listcomp>.<lambda> at 0x0000026926836200>, <function num.<locals>.<listcomp>.<lambda> at 0x0000026926836290>, <function num.<locals>.<listcomp>.<lambda> at 0x0000026926836320>]
[6, 6, 6, 6]
``````

### 16.常见的内置函数及作用

#### map:将函数批量作用一个序列中

``````from typing import Iterator

list_data = [1, 2, 3]
data = map(lambda n: n * 2, list_data)
print(data)
print(type(data))
print(isinstance(data, Iterator))
for item in data:
print(item)

``````

``````<map object at 0x0000026C4B6EBD90>
<class 'map'>
True
2
4
6
``````

#### reduce：依次对序列进行函数处理并进行累计处理

``````from functools import reduce

list_data = [1, 2, 3]
data = reduce(lambda m, n: m * n, list_data)
print(data)
``````

``````6
``````

#### filter：依据函数对序列进行过滤，返回符合条件的filter对象

``````from typing import Iterable

list_data = [1, 2, 3]
data = filter(lambda n: n > 2, list_data)
print(data)
print(type(data))
print(isinstance(data, Iterable))
for item in data:
print(item)

``````

``````<filter object at 0x000002045EA3BD90>
<class 'filter'>
True
3
``````

#### sorted:自定义排序

sorted(Iterable, key, reverse=False)
key为需要进行排关键字
reverse默认为False、升序；反之则降序

``````dict_data = {"a": 1, "c": 3, "b": 2}
print(tuple(dict_data.items()))
# 按照字典的key排序
data = sorted(dict_data.items(), key=lambda x: x[0])
print(dict(data))
# 按照字典的value排序
data = sorted(dict_data.items(), key=lambda x: x[1], reverse=True)
print(dict(data))
``````
``````(('a', 1), ('c', 3), ('b', 2))
{'a': 1, 'b': 2, 'c': 3}
{'c': 3, 'b': 2, 'a': 1}
``````

### 18.python如何安装第三方模块

#### pip 查找模块

``````pip install pip-search
``````

``````pip_search module
``````

#### pip 安装模块

##### 基本安装方法
``````pip install module
``````
##### 一般国内默认的源较慢，可以指定安装的源, 例如清华源、豆瓣源等，可以上网查询
``````pip install module -r https://pypi.tuna.tsinghua.edu.cn/simple
``````

1.在window的文件管理器输入%APPDATA%进入默认的用户目录，一般为C:\Users\xxx\AppData\Roaming， xxx为用户名
2.在此文件夹下新建一个名为pip的文件夹
3.在新建的pip文件夹下创建一个名为pip.ini的文件，此处使用的是清华源，也有一些其他的国内源，自行修改即可

``````[global]
timeout = 6000
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
trusted-host = pypi.tuna.tsinghua.edu.cn
``````

Linux与Windows类似，不同是路径、文件不一致，打开文件后直接将上述文件写入即可

``````mkdir ~/.pip
cd ~/.pip
touch pip.conf
vim pip.conf
``````

#### 有时候我们需要指定某个某个模块的版本

``````pip install module==1.0.1
``````

#### 导出项目中使用的模块,方便移植

``````pip freeze > requirements.txt
``````

#### 既然有导出，肯定有导入

``````pip install -r requirements.txt
``````

### 19.使用过的第三方模块，常用的模块？

• os:操作文件、文件夹路径、系统分隔符等:详细介绍：os相关操作
• shutils：批量新建文件、文件夹、压缩文件等，详细介绍:shutils相关操作
• request:请求操作，例如get、post等
如下是requests的简单使用
``````import requests

url = "https://movie.douban.com/"
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) \
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
}
result = pathlib.Path(__file__).parent.joinpath("douban.html")
with open(result, mode="w", encoding="utf8") as f:
print(response.text)
f.write(response.text)
print(response)
``````
• virtualenv:创建虚拟环境
• winreg:Windows注册表相关
• psutil:系统cpu、内存、线程相关
• fire:添加命令行相关参数（main create ...)
• pyinstaller:将py文件打包成exe文件
• configparser：操作ini文件。详细介绍：ini文件操作
• PyYAML：操作yaml文件。详细介绍：yaml文件操作
• 操作excel文件:excel文件操作
• 操作xml、html的模块，lxml：详细介绍: lxml相关操作
• 持续更新中

### 22.求结果

``````print([i % 2 for i in range(10)])
# 生成的是一个列表：[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
print((i % 2 for i in range(10)))
# 生成的是一个生成器，需要手动next或者for循环遍历
print(1 or 2)  # 1
print(1 and 2)  # 2
print(1 < (2 == 2))  # False
print(1 < 2 == 2) # True
``````

or： 第一个元素为True则输出第一个元素， 反之
and: 第一个元素为Flase输出第一个元素，反之

### 23.def func(a,b=[]) 这种写法有什么坑？

``````def func(a, b=[]):
b.append(a)
print(b)

for i in range(10):
func(i)
``````
``````[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
``````

``````默认参数必须要指向不可变对象
``````

``````def func(a, b=None):
if b is None:
b = []
b.append(a)
print(b)

for i in range(10):
func(i)

``````
``````[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
``````

### 24.如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] \ [‘1’,’2’,’3’]变成[1,2,3] ??

``````data = "1,2,3"
print(data.split(','))

data = ["1", "2", "3"]
print([int(n) for n in data])
print(list(map(lambda n: int(n), data)))
``````

### 25.比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？

``````a = [1, 2, 3]
b = [(1), (2), (3)]
c = [(1,), (2,), (3,)]

print(type(a))
print(type(a[0]))
print(type(b))
print(type(b[0]))
print(type(c))
print(type(c[0]))
``````
``````<class 'list'>
<class 'int'>
<class 'list'>
<class 'int'>
<class 'list'>
<class 'tuple'>
``````

### 26.如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?

``````print(list(map(lambda n: n * n, range(1, 11))))
``````

### 27.一行代码实现删除列表中重复的值 ?

``````list_data = [1, 3, 4, 5, 6, 7, 2, 5, 1, 3, 8]

# 第一种方法，使用set, 默认会自动排序，顺序可能会发生改变
print(list(set(list_data)))
# 第二种方法，遍历列表元素去重

def remove_repeat(data):
result_list = []
for item in data:
if list_data.count(item) == 1 or (
list_data.count(item) > 1 and result_list.count(item) == 0
):
result_list.append(item)
return result_list

# 此方法使用yield 返回生成器的方式，节省消耗
def remove_repeat2(data):
for item in data[-1:]:
if list_data.count(item) == 1:
yield item
else:
data.remove(item)

print(remove_repeat(list_data))
print(list(remove_repeat2(list_data)))

# 第三种方法，使用Counter
from collections import Counter

print(list(Counter(list_data)))

``````

### 28.如何在函数中设置一个全局变量 ?

#### 全局变量

``````count = 0

def run():
global count
count += 1

run()
print(count)
# 1
``````

#### 函数中的全局变量

nonlocal是python3出现的，方便内部函数调用外部函数变量， 如果不使用nonlocal，只能获取外部函数的变量值

``````def outter():
number = 1

def inner():
nonlocal number
number += 1
print(number)
return inner

outter()()
# 2
``````

### 29.logging模块的作用？以及应用场景？

logging是python自带的日志模块，可以很方便的进行日志的输出及输出到文件等

INFO 无异常时输出的日志，主要是确认程序是否正常按照预期进行的
DEBUG 一般在开发阶段使用，用于问题的诊断与定位
WARNING 当出现一些异常信息（例如磁盘空间不足）时，但是不会影响程序的正常执行
ERROR 当出现问题时导致程序无法正常运行时
CRITICAL 当出现严重问题时导致程序无法继续运行时
``````import logging

logging.info("info")
logging.warning("warning")
logging.debug("debug")
logging.error("error")
logging.critical("critical")
``````

### 31.常用字符串格式化哪几种？

``````print("%d %s" % (1, "test"))

timeout = 1
print(f"{timeout}")
print("{}".format("test"))
``````

### 33.用Python实现一个二分查找的函数。

#### 二分查找

• 需要找的元素大于中间元素，则到n/2右边的序列中继续进行二分查找
• 需要找的元素小于中间元素，则到n/2左边的序列中继续进行二分查找
• 需要找的元素刚好就是中间元素，查找结束
``````target = 9
list_data = [1, 2, 4, 2, 9, 43, 2]
list_len = len(list_data)
index = 0
middle = int(list_len / 2) - 1
while True:
if target == list_data[middle]:
index = middle
break
elif target > list_data[middle]:
middle = middle + int((list_len - middle) / 2) - 1
else:
middle = int(middle / 2) - 1

print(index)

``````

### 35.os和sys模块的作用？

os和sys都属于系统层级的模块
os:通常用于文件、文件夹的相关操作（新建、删除、重命名等），也可用于路径的获取与切换；执行命令等
sys:通常用于命令行参数的获取、系统平台的获取、系统执行路径等

### 36.如何生成一个随机数？

``````import random

rand = random.Random()
# 随机生成0-1内的浮点类型数据
print(rand.random())
# 生成0-1符合 贝塔分布
print(rand.betavariate(0.1, 0.5))
tu = (1, 2, 3, 4, 78, 12, 98)
# 从一个非空序列中选择一个元素
print(rand.choice(tu))
# 从列表中随机选取多个值，返回的是一个列表
print(rand.choices(tu, k=2))
# 返回一个区间内的数字
print(rand.randint(1, 100))
# 返回一个区间的数字，不过可以指定step步长
print(rand.randrange(1, 100, 2))
``````

### 37.如何使用python删除一个文件？

#### 使用os中的删除文件或者文件夹，不过无法删除里面包含文件夹或者文件的文件夹，需要递归进行操作

``````import os
import time

os.mkdir("test")
time.sleep(4)
os.rmdir("test")

with open("1.txt", mode="w", encoding="utf8") as f:
f.write("test" * 10)
time.sleep(4)
os.remove("1.txt")

os.makedirs("test2/test3")
time.sleep(4)
os.removedirs("test2/test3")
``````

#### 使用shutil可以递归操作文件夹

``````import shutil

# 相当于mv
shutil.move()
# 拷贝整个文件夹，里面可以包含子文件或者子文件夹
shutil.copytree()
# 与上述类似，可以删除整个文件夹，哪怕存在子文件夹
shutil.rmtree()
``````

### 42.是否使用过functools中的函数？其作用是什么？

#### reduce:对序列进行叠加操作

``````from functools import reduce

li = [1, 2, 3, 4]
print(reduce(lambda m, n: m + n, li))
``````

#### wraps:装饰器中的改变函数注释及函数名称的

``````from functools import wraps

def decorator(func):
@wraps(func)
def inner(*args, **kwargs):
func(*args, **kwargs)

return inner
``````

#### partial：偏函数，用于生成新函数，可以指定某些固定的参数

``````from functools import partial

def fun(x, y, z):
return x + y + z

fun2 = partial(fun, 1)
print(fun2(2, 4))
``````

### 44.如何判断是函数还是方法？

python有自带的可以区分是函数还是方法的函数。

``````from abc import abstractmethod
import inspect

def fun():
pass

print(inspect.isfunction(fun))
print(inspect.ismethod(fun))
print(type(fun))

class Test:
def __init__(self) -> None:
pass

def fun():
pass

def fun2(self):
pass

@staticmethod
def fun3():
pass

@classmethod
def fun4(cls):
pass

@abstractmethod
def fun5():
pass

fun2 = Test().fun2
print(inspect.isfunction(fun2))
print(inspect.ismethod(fun2))
print(type(fun2))

fun = Test().fun
print(inspect.isfunction(fun))
print(inspect.ismethod(fun))
print(type(fun))

fun3 = Test().fun3
print(inspect.isfunction(fun3))
print(inspect.ismethod(fun3))
print(type(fun3))

fun4 = Test().fun4
print(inspect.isfunction(fun4))
print(inspect.ismethod(fun4))
print(type(fun4))

fun5 = Test().fun5
print(inspect.isfunction(fun5))
print(inspect.ismethod(fun5))
print(type(fun5))

``````
``````True
False
<class 'function'>
False
True
<class 'method'>
False
True
<class 'method'>
True
False
<class 'function'>
False
True
<class 'method'>
False
True
<class 'method'>
``````

### 45.静态方法和类方法区别？

``````class Test:
def __init__(self) -> None:
self.name = "mike"

@staticmethod
def static_method(a, b):
print(a + b)
print("static_method")

@classmethod
def class_method(cls, a, b):
print(a + b)
print("class_method")

t = Test()
t.static_method(1, 2)
Test.static_method(2, 3)
t.class_method(1, 2)
Test.class_method(2, 3)

``````

type与metaclass

### 52.什么是面向对象的mro

MRO的全称是Method Resolution Order(方法解析顺序)，它指的是一棵类继承树，当调用最底层类对象的所对应的实例方法时， python解释器在类继承树上的搜索方法的顺序。对于一棵类继承树可以通过最底层方法mro()或是__mro__的属性获得他的MRO。

``````class D:
def run(self):
print("d run")

class C(D):
def run(self):
print("C run")

class B(D):
def run3(self):
print("B run")

class A(B, C):
def run2(self):
print("A run")

A().run()
print(A.mro())
``````

### 53.isinstance作用以及应用场景？

``````print(isinstance("1", str))
print(isinstance("1", int))

print(isinstance(1, int))
print(isinstance(1, str))

print(isinstance([1, 2], list))
print(isinstance([1, 2], tuple))
``````

### 54，给定一个整数数组，返回两个数字的索引，使它们相加到一个特定的目标。您可以假设每个输入都会只有一个解决方案，您可能不会两次使用相同的元素。

``````Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1]
``````
``````nums = [2, 7, 11, 15, 34, 1, 23, 11]
target = 25

def fun(data, target):
for index, item in enumerate(nums):
if item > target:
continue
if data.count(target - item) > 0:
return [index, data.index(target - item)]
return False

print(fun(nums, target))

``````

### 57.使用代码实现查看列举目录下的所有文件。

``````# 使用代码实现查看列举目录下的所有文件。
import os
import pathlib

dir_path = "D:\python_study"
# 文件夹名称 文件夹下的文件夹，以列表形式呈现 文件夹下的文件，以列表形式呈现
for dirpath, dir_list, file_list in os.walk(dir_path):
print(f"dirpath:{dirpath}")
print(f"dirnames:{dir_list}")
print(f"filenames:{file_list}")

# 只能显示当前层级的文件夹，以列表形式呈现
print(os.listdir(dir_path))

# 只能显示当前层级的文件夹，以生成式+路径对象形式呈现
print(list(pathlib.Path(dir_path).iterdir()))
print(list(pathlib.Path(dir_path).glob("*")))

# 显示所有的文件及文件夹 路径对象，以生成器+路径对象形式呈现
print(list(pathlib.Path(dir_path).rglob("*")))
``````