python知识点总结(十)


python知识点总结十

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

函数装饰器

python 复制代码
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))

类装饰器

python 复制代码
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))

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

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

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

队列的实现:

python 复制代码
from collections import deque

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

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

# 出队
while queue:
    front = queue.popleft()
    print("出队:", front)

栈的实现:

python 复制代码
# 创建一个空栈
stack = []

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

# 出栈
while stack:
    top = stack.pop()
    print("出栈:", top)

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

python 复制代码
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')

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

python 复制代码
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)

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

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

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

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_())

相关推荐
禁默3 分钟前
深入浅出:AWT的基本组件及其应用
java·开发语言·界面编程
Cachel wood10 分钟前
python round四舍五入和decimal库精确四舍五入
java·linux·前端·数据库·vue.js·python·前端框架
Jasmine_llq10 分钟前
《 火星人 》
算法·青少年编程·c#
Code哈哈笑12 分钟前
【Java 学习】深度剖析Java多态:从向上转型到向下转型,解锁动态绑定的奥秘,让代码更优雅灵活
java·开发语言·学习
終不似少年遊*15 分钟前
pyecharts
python·信息可视化·数据分析·学习笔记·pyecharts·使用技巧
程序猿进阶16 分钟前
深入解析 Spring WebFlux:原理与应用
java·开发语言·后端·spring·面试·架构·springboot
Python之栈17 分钟前
【无标题】
数据库·python·mysql
qq_4336184418 分钟前
shell 编程(二)
开发语言·bash·shell
闻缺陷则喜何志丹21 分钟前
【C++动态规划 图论】3243. 新增道路查询后的最短距离 I|1567
c++·算法·动态规划·力扣·图论·最短路·路径