为什么我的不一样，随便怎样调整都没用。想知道哪个环节出问题了

class MySingleton:
  __obj = None
  __init_flag = True

  def __new__(cls, *args, **kwargs):
    if cls.__obj == None:
      cls.__obj = object.__new__(cls)

    return cls.__obj

  def __init__(self,name):
    if MySingleton.__init_flag:
      print("init....")
      self.name = name
      MySingleton.__init_flag = False

a = MySingleton("aa")
print(a)
b = MySingleton("bb")
print(b)

老师，因为__init__第二次初始化对象失败，才会新建一个对象吗？

<table align="center" width="800" height="800">
    <tr align="center" bgcolor="pink">
        <td  rowspan="2">洒店</td>
        <td>海外酒店</td>
        <td>团购</td>
    </tr>
    <tr align="center" bgcolor="pink">
        <td>特价酒店</td>
        <td>民宿/客栈</td>
    </tr>
    <tr align="center" bgcolor="blue">
        <td  rowspan="2">机票</td>
        <td>火车票检票</td>
        <td>汽车票/船票</td>
    </tr>
    <tr align="center" bgcolor="blue">
        <td>特价机票</td>
        <td>专车租车</td>
    </tr>
    <tr align="center" bgcolor="gree">
        <td  rowspan="2">旅游</td>
        <td>目的地攻略</td>
        <td>邮轮旅游</td>
    </tr>
    <tr align="center" bgcolor="gree">
        <td>周边游</td>
        <td>定制旅行</td>
    </tr>
    <tr  align="center" bgcolor="yelleow">
        <td>景点玩乐</td>
        <td>美食林</td>
        <td>购物外汇</td>
    </tr>
    <tr align="center" bgcolor="yelleow">
        <td>礼品卡</td>
        <td>WIFI 电话</td>
        <td>保险签证</td>
    </tr>
</table>

class Person:

  def __del__(self):

    print("销毁对象：{0}".format(self))

p1 = Person()

p2 = Person()

del p2

print("程序结束")

老师，要整个程序运行完了，才会调用__del__方法，进行销毁吗？就是说，在__del__方法后面还有一些方法，我会先把后面的方法执行完了，再调用析构方法吗？

老师，我这个code改成301之后为什么检查里显示的是200呢

老师你好，我的06文档已经给我删除了，为什么运行07的时候还是提示06的错误。

#conding="utf-8"
from multiprocessing.context import Process
from multiprocessing.queues import Queue

from time import sleep


class MyProcess(Process):
    def __init__(self,name,mq):
        Process.__init__(self)
        self.name=name
        self.mq=mq



    def run(self):
        print(f"Process:{self.name},start")
        print(f"get Data:{self.mq.get()}")
        sleep(3)
        print(f"Process:{self.name},end")

if __name__ == '__main__':
    mq = Queue()
    mq.put("1")
    mq.put("2")
    mq.put("3")
    #进程列表
    t_list = []
    #创建进程
    # t1=MyProcess("t1")
    # t2=MyProcess("t2")
    # t3=MyProcess("t3")
    # t1.start()
    # t2.start()
    # t3.start()
    #使用for循环
    for i in range(3):
        t = MyProcess(f"t{i}",mq)
        t_list.append(t)
        t.start()

老师麻烦你帮我看一下

def add(a,b,c):

  '''完成三个数的加法，并返回他们的和'''

  sum = a+b+c

  print("{0}、{1}、{2}三个数的和是：{3}".format(a,b,c,sum))

  return sum

add(10,20,30)

add(30,40,50)

老师，上面代码的return返回值，我们并没有使用到吗？它返回给谁啊？

C:\WINDOWS\system32>ruby -v

ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [x64-mingw-ucrt]

C:\WINDOWS\system32>gem sources --add https://gems.ruby-china.com/ --remove https://rubygems.org/

Error fetching https://gems.ruby-china.com/:

        server did not return a valid file (https://gems.ruby-china.com/specs.4.8.gz)

C:\WINDOWS\system32>

老师 这个报错怎么解决啊

turtle
math

x1,y1 =,x2,y2 =,-x3,y3 =-,-x4,y4 =-,turtle.penup()
turtle.goto(x1,y1)
turtle.pendown()
turtle.goto(x2,y2)
turtle.goto(x3,y3)
turtle.goto(x4,y4)
distance =math.sqrt(x1-x4)**+(y1-y4)**turtle.write(distance)
turtle.done()

time

b=(time.time())
(b)
totalMinutes=b//(totalMinutes)
totaDays=totalMinutes//(*)
totalYears=totaDays//(totalYears)

老师 选择某个维度作为条件如何理解？是先选择分裂特征，在选择分裂特征之后，在确定分裂条件吗？还是同时进行呢？

import time
class Decorater():
    __cache = {}
    def __init__(self,func):
        self.func = func
    def __call__(self, *args, **kwargs):
        if self.func.__name__ in Decorater.__cache:
            return Decorater.__cache[self.func.__name__]
        else:
            result = self.func(*args,**kwargs)
            Decorater.__cache[self.func.__name__] = result
            return result

def costtime(func):
    def infunc(*args,**kwargs):
        start = time.time()
        result = func(*args,**kwargs)
        end = time.time()
        print(f"{end-start}")
        return end-start
    return infunc
@costtime
@Decorater
def long_time():
    print("start")
    time.sleep(4)
    print("end")
    return 999
if __name__ == "__main__":
    r1 = long_time()
    r2 = long_time()
    print(r1)
    print(r2)

请问老师，这里我输出的结果没有返回值999是什么原因啊

老师可以解释一下什么是解释型语言，什么是编译型语言吗。本质区别是什么？

请问老师，对于一元线性回归的最大似然估计可不可以理解为：

模型的组测输出公式为y^= wx + b, 和真实值的误差是e，所以真实值y和预测值y^之间的关系可以定为：

y = y^ +e = wx +b +e。 所以当误差e最小时所对应的w和b就是我们需要的模型最佳参数。

因为e是符合正态分布，那么y也是符合正态分布的。所以y可以写成关于w和b的符合正态分布的概率密度公式。其中均值是wx + b，方差是一个常熟。那么对于一个样本，当这个概率密度最大的时候也就是wx + b越接近y的时候，我们模型的预测是最准确的，得到真实值的概率是最大的。此时所对应的w参数wb就是我们需要的模型参数。

因为我们所有样本都满足独立分布，所以总概率就可以写成所有样本的上述概率密度的累乘，我们只要最大化这个累乘后的概率密度，就可以找到对于所有数据样本来说最接近真实y概率的对应参数wb从而得到一个拟合不错的线性模型。

之后两边同取对数之后，因为以e为底的对数函数是单调递增的，所以最大化似然函数等同于最大化这个对数函数。因为化简后有一个常数项和一个有负号的关于wb的一项，那么问题就变成了最小化去掉负号的带有wb的这一项函数，从而就推导出来了我们的mse损失函数。