打印时间那里用+号为什么会报错呢

time
time1 = time.time()
c = i ():
    c += time2 = time.time()
(,+(time2 - time1))
time3 = time.time()
li = []
i ():
    li.append()
d = .join(li)
time4 = time.time()
(,(time4 - time3))

time
time1 = time.time()
c = i ():
    c += time2 = time.time()
(,+(time2 - time1))
time3 = time.time()
li = []
i ():
    li.append()
d = .join(li)
time4 = time.time()
(,+(time4 - time3))

import time
time1 = time.time()
c = ''
for i in range(100000):
    c += 'trw'
time2 = time.time()
print("+的发生时间",str(time2 - time1))
time3 = time.time()
li = []
for i in range(1000000):
    li.append('trw')
d = ''.join(li)
time4 = time.time()
print("join的发生时间",str(time4 - time3))

输出：  print("+的发生时间",+str(time2 - time1))
                        ^^^^^^^^^^^^^^^^^^^
TypeError: bad operand type for unary +: 'str
问题：为什么第一段代码里面打印时间行前面是字符串后面也是字符串却不能用+号呢

print（"输入:"+name)

这个print后加的name只能是字符串类型吗

这怎么解决啊？

老师，我有几个问题没搞懂：

1、视频中.next的作用是啥

2、

“新节点的下一个节点”指的是“新节点的指针域”吗？，它指向“前驱节点的下一个节点”指的是“前驱节点的指针域”吗？但这里不应该指向“后驱节点的下一个节点”吗？

3、这个for _ in range()其实就是for i in range()对吧？

没ip地址啊老师

老师 线性模型的损失函数使用的是MSE，那么对模型的参数进行调整的话是只调整一次吗？

time
time1=time.time()
a=i ():
    a += time2=time.time()
(+(time2-time1))

time3=time.time()
li=[]
i ():
    li.append()
b=.join(li)
time4=time.time()
(+(time4-time3))

输出："C:\Users\NING MEI\luobo01\pythonProject\venv\Scripts\python.exe" "C:\Users\NING MEI\luobo01\pythonProject\mypy03.py" 

这是什情况，老师

x ():
    y ():
        (x,=)
    ()

想老师解释这个？还有在最后的print如果缩进没空格会有不一样的结果？

import os
from multiprocessing import Pool
from time import sleep

def func1(name):
    print(f"进程id:{os.getpid()}-{name}")
    sleep(2)
    return name

def func2(args):
    print(args)

if __name__ == '__main__':
   # 方式一
    # 创建进程池对象
    pool = Pool(5)
    # callback=func2 -> 执行完func1后将返回值传给func2
    pool.apply_async(func=func1, args=("sxt1",), callback=func2)
    pool.apply_async(func=func1, args=("sxt2",), callback=func2)
    pool.apply_async(func=func1, args=("sxt3",), callback=func2)
    pool.apply_async(func=func1, args=("sxt4",))
    pool.apply_async(func=func1, args=("sxt5",))
    pool.apply_async(func=func1, args=("sxt6",))
    pool.apply_async(func=func1, args=("sxt7",))
    pool.apply_async(func=func1, args=("sxt8",))

    # 使用完进程池关上
    pool.close()
   # 等待所有子进程执行完，不然的话，主进程可能直接关掉了进程池，而子进程还没执行完
    pool.join()

老师，想问下为什么如果先让子进程执行完（即先运行pool.join()），再让主线程关闭进程池（再运行pool.close()），会报错，正常逻辑不就是这样吗

#encoding=utf-8
import time

def cost_time(func):
    def infunc(*args,**kwargs):
        start = time.time()
        result = func(*args,**kwargs)
        end = time.time()
        print(f"耗时:{end-start}")
        return result
    return infunc

class CaheDecorator():
    __cache={} #类属性，用作所有实例的共享缓存
    def __init__ (self ,func):
        self.func = func
    def __call__ (self, *args, **kwargs):
        #如果缓存中有对应的方法名，则直接返回对应的返回值
        if self.func.__name__ in CaheDecorator.__cache:
            return CaheDecorator.__cache[self.func.__name__]
        # 如果缓存中没有对应的方法名，则进行计算，并将结果缓存
        else:
            result = self.func(*args,**kwargs)
            CaheDecorator.__cache[self.func.__name__] = result
            print(self.__cache)
            return result


@cost_time  #func1_long_time = cost_time(func1_long_time)
@CaheDecorator  #func1_long_time=CaheDecorator(func1_long_time)
def func1_long_time():
    """模拟耗时较长，每次执行返回结果都一样的情况"""
    print("start func1")
    time.sleep(3)
    print("end func1")
    return 999

if __name__ == '__main__':
    r1 = func1_long_time()
    r2 = func1_long_time()
    print(r1)
    print(r2)

这段代码的运行顺序是怎么样的？

time

(func):
    (*args**kwargs):
        start = time.time()
        result = func(*args**kwargs)
        end = time.time()
        (end-start)
        result
    infunc

CaheDecorator():
    __cache={} (func):
        .func = func
    (*args**kwargs):
        .func.CaheDecorator.__cache:
            CaheDecorator.__cache[.func.]
        :
            result = .func(*args**kwargs)
            CaheDecorator.__cache[.func.] = result
            (.__cache)
            result


():
    ()
    time.sleep()
    ()
    __name__ == :
    r1 = func1_long_time()
    r2 = func1_long_time()
    (r1)
    (r2)

这段代码他的运行顺序是怎么样的？