python知识点总结(十)

---

1、装饰器的理解、并实现一个计时器记录执行性能，并且将执行结果写入日志文件中

函数装饰器

def decator(file):
    def outer(func):
        def inner(*args, **kwargs):
            start = time.time()
            time.sleep(3)
            res = func(*args, **kwargs)
            with open(file,encoding='utf-8',mode='w') as f:
                f.write(str(res))
            end = time.time()
            print('执行时间:', end - start)

            return res

        return inner
    return outer


@decator(file='1.txt')
def func(a, b):
    return a + b


a = 2
b = 3
print(func(a, b))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

类装饰器

class A:
    def __init__(self,file):
        self.file=file

    def __call__(self, func, *args, **kwargs):

        def wrapper(*args,**kwargs):
            start = time.time()
            time.sleep(3)
            res = func(*args, **kwargs)
            with open(self.file, encoding='utf-8', mode='w') as f:
                f.write(str(res))
            end = time.time()
            print('执行时间:', end - start)

            return res
        return wrapper

@A(file='a.txt')
def f(a,b):
    return a+b

a=3
b=6
print(f(a, b))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2、队列和栈的区别，并且用python实现

队列（Queue）和栈（Stack）是两种常见的数据结构，它们之间的主要区别在于数据的存取方式：
队列（Queue）：
先进先出（FIFO）：队列是按照先进先出的原则存取数据的，即先进入队列的数据会先被取出。
操作：在队列中，数据的插入是在队尾进行（enqueue），数据的删除是在队头进行（dequeue）。
应用：队列常用于实现广度优先搜索（BFS）等算法，如消息队列、任务调度等。

栈（Stack）：
后进先出（LIFO）：栈是按照后进先出的原则存取数据的，即最后压入栈的数据会最先被弹出。
操作：在栈中，数据的插入和删除都是在栈顶进行，压入数据称为入栈（push），弹出数据称为出栈（pop）。
应用：栈常用于实现递归函数、表达式求值、回溯算法等。

队列的实现：

from collections import deque

# 创建一个空队列
queue = deque()

# 入队
queue.append(1)
queue.append(2)
queue.append(3)

# 出队
while queue:
    front = queue.popleft()
    print("出队：", front)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

栈的实现：

# 创建一个空栈
stack = []

# 入栈
stack.append(1)
stack.append(2)
stack.append(3)

# 出栈
while stack:
    top = stack.pop()
    print("出栈：", top)
1
2
3
4
5
6
7
8
9
10
11
12

3、设计实现遍历目录与子目录

import os 
def get_files(dir,suffix): 
    res = [] 
    for root,dirs,files in os.walk(dir): 
        for filename in files: 
            name,suf = os.path.splitext(filename) 
            if suf == suffix: 
                res.append(os.path.join(root,filename)) 
    print(res) 

get_files("./",'.pyc')
1
2
3
4
5
6
7
8
9
10
11

4、CPU处理进程最慢的情况通常发生在以下几种情况下：

1、cpu负载过高：
当系统中的CPU负载达到极限或者过载时，CPU处理进程的速度就会变慢。这是因为系统资源不足，导致CPU长时间无法及时处理进程造成的。
2、竞争资源：
当多个进程竞争同一资源，如内存、硬盘或者网络宽带等，会导致CPU处理进程变慢。因为CPU需要需要等待资源的释放。
3、I/O操作：
当进程需要进行大量的输入输出操作时，CPU处理进程的速度会变慢，这是因为I/O操作相比于CPU处理速度较慢。
5、系统调度：系统调度算法不当或者优先级设置不合理可能会导致 CPU 处理进程的速度变慢，造成进程长时间等待。

5、CPU处理线程最慢的情况通常发生在以下几种情况下：

1. CPU密集型任务：当系统中存在大量的 CPU 密集型任务，会导致 CPU 处理线程变慢。因为 CPU 需要不断执行这些耗时的任务，占用大量计算资源。

2. 资源竞争：当多个线程竞争同一资源，如共享内存、文件、数据库连接等，会导致 CPU 处理线程变慢。因为线程需要等待资源的释放或者合适时机才能继续执行。

3. I/O操作：和处理进程类似，线程进行大量的 I/O 操作也会导致 CPU 处理线程变慢，因为线程需要等待 I/O 操作完成才能继续执行。

4. 死锁：当线程之间出现死锁情况时，CPU 处理线程会陷入等待状态，无法继续执行。这也会导致 CPU 处理线程变慢，直到死锁解除。

5. 线程调度：系统调度算法或线程优先级设置不当可能会导致 CPU 处理线程变慢，造成线程长时间等待。

6. 线程处于阻塞状态。

6、如何做到线程同步？

1. 互斥锁（Mutex）：互斥锁是一种最基本的线程同步机制，用于保护共享资源不被多个线程同时访问。在访问共享资源之前，线程需要先锁定互斥锁，访问完成后再释放锁。这样可以确保在同一时刻只有一个线程可以访问共享资源。

2. 信号量（Semaphores）：信号量是一种用于线程同步的计数器，可以阻塞或唤醒线程。通过信号量实现同步操作，控制多个线程对共享资源的访问。可以实现信号量来控制资源的访问数量，从而保证线程同步。

3. 读写锁（Read-Write Locks）：读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。通过读写锁，可以提高共享资源的并发访问性能。

4. 屏障（Barriers）：屏障用于多个线程需要在某个点同步，等待所有线程都到达后才能继续执行。屏障可以保证多个线程在执行过程中按一定顺序同步，实现前后依赖关系。

5. 原子操作（Atomic Operations）：原子操作是一种不可分割的操作，可以保证操作的完整性和线程安全性。在需要对共享资源进行简单操作时，可以使用原子操作来保证线程同步。

7、手写代码：对于字符串bdackmkdbb,输出第二个只出现一次的字符, 输出c

def test(s):
    dic={}
    res=[]
    for i in s:
        if i not in dic:
            dic[i]=1
        else:
            dic[i]+=1

    for key,value in dic.items():
        if value==1:
            res.append(key)
    return res[1]

s="bdackmkdbb"
res=test(s)
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

8、按按照题目要求写出对应的装饰器。

要求:有一个通过网络获取数据的函数(可能会因为网络原因出现异常)，写一个装饰器让这个函数在出现指定异常时可以重试指定的次数，并在每次重试之前随机延迟一段时间，最长延迟时间可以通过参数进行控制。

点评:LeetCode上的企业面试题目，我们不止一次强调过，装饰器几乎是Python面试必问内
容，这个题目比之前的题目稍微复杂一些，它需要的是一个参数化的装饰器。

from functools import wraps
from random import random


def retry(retry_time=3, max_wait_sec=5, error=(Exception,)):
    def decorate(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            for _ in range(retry_time):
                try:
                    return fn(*args, **kwargs)
                except error:
                    time.sleep(random() * max_wait_sec)
            return None

        return wrapper

    return decorate


@retry(retry_time=4, max_wait_sec=4)
def request_():
    return '6666'


print(request_())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

---