老师我想不出来错哪里了

import turtle
import math

#定义多点坐标
x1,y1 = 23,56
x2,y2 = 78,10
#绘制折线图
turtle.penup()
turtle.goto(x1,y1)
turtle.pendown()
turtle.goto(x2,y2)
#计算起始点和终点的距离
distance = math.sqrt((x1-x1)**2,(y1-y2)**2)

turtle.write(distance)

老师你好，元旦快乐。

问题：像使用＋号扩展是会把之前的回收掉吗？

代码1:

def test01(n):
    #c=n
    print("test01:",n)
    if n==0:
        print("over")
    else:
        test01(n-1)
        print("test01****",n)
test01(4)

代码2：

def test01(n):
    #c=n
    print("test01:",n)
    if n==0:
        print("over")
    else:
        test01(n-1)
    print("test01****",n)
test01(4)

运行结果1：

运行结果2：

老师请问一下，为什么上述两个程序的运行结果不一样呢？

class Car:
    def __init__(self, montor, chassis, seat, shell):
        self.montor = montor
        self.chassis = chassis
        self.seat = seat
        self.shell = shell
    def run(self):
        self.montor.work()
        self.chassis.work()
        self.seat.work()
class Montor:
    def work(self):
        print('这是发动机')
class Chassis:
    def work(self):
        print('这是底盘')
class Seat:
    def work(self):
        print('这是座椅')
class Shell:
    def work(self):
        print('这是车辆外壳')

m = Montor()
c = Chassis()
s = Seat()
h = Shell()
car = Car(m, c, s, h)
car.run()

老师，这里的代码我看的有点懵，能讲一下这个运行方式吗

老师，为什么这里无法打印这个return值呢？

class Employee:
    id = 1000
    def __init__(self, name, salary):
        self.__name = name
        self.__salary = salary
        Employee.id += 1

    @property
    def salary(self):
        return self.__salary

    @salary.setter
    def salary(self, salary):
        if 1000 < salary < 50000:
            self.__salary = salary
        else:
            print('不在范围内')
    def __add__(self, other):
        return self.salary+other.salary
a = eval(input('输入第一个人的名字：'))
a1 = eval(input('输入第一个人的薪水：'))
emp1 = Employee(a, a1)
emp1.salary = a1
b = eval(input('输入第二个人的名字：'))
b2 = eval(input('输入第二个人的薪水：'))
emp2 = Employee(b, b2)
emp2.salary = b2
x = emp2 + emp1
print('薪水和为：', x)

老师，这里的

def __add__(self, other):
        return self.salary+other.salary

other是什么？

'''
定义一个 Employee 雇员类，要求如下：
(1) 属性有：id、name、salary
(2) 运算符重载+：实现两个对象相加时，默认返回他们的薪水和
(3) 构造方法要求：输入 name、salary，不输入 id。id 采用自增的方式，从 1000 开始自增，第一个新增对象是 1001，第二个新增对象是 1002
(4) 根据 salary 属性，使用@property 设置属性的 get 和 set 方法。set 方法要求输入：1000-50000 范围的数
'''
class Employee:
    id=1000
    def __init__(self,name,salary):
        self.__name=name
        self.__salary=salary
        Employee.id+=1
    def __add__(self, other):
        if isinstance(other,Employee):
            return self.__salary+other.__salary
    @property
    def salary(self):
        if 1000<self.__salary<50000:
            return self.__salary
        else:
            return '录入错误，薪水在1000到50000这个范围'
    @salary.setter
    def salary(self,salary):
        if 1000<salary<50000:
            self.__salary=salary
        else:
            return '薪水录入错误！只能在1000-50000之间'
emp1=Employee('高淇',30000)
print(emp1.id)
print(emp1.salary)
emp2=Employee('高希希',20000)
print(emp2.id)
print(emp2.salary)
emp2.salary=60000
print(emp1+emp2)

1.为什么emp2.salary=60000 并没有执行？

2.在运行emp2后再输出emp1.id，emp1.id就会等于emp2.id  请问老师这种情况正常吗？

import copy


def testCopy():
    a = [10,20,30,40]
    b = copy.copy(a)                    #浅拷贝
    print("a id",id(a))
    print("b id",id(b))                 #比较原始对象和拷贝对象的ID
    b.append(50)                        #对copy对象进行操作
    print("a",a)
    print("b",b)
    a.append(60)                       #对原始对象进行操作
    print("a", a)
    print("b", b)

def testDeepCopy():
    a = [10,20,30,40]
    b = copy.deepcopy(a)                       #深拷贝
    print("a id",id(a))
    print("b id",id(b))
    b.append(50)
    print("a",a)
    print("b",b)
    a.append(60)
    print("a", a)
    print("b", b)


testCopy()
print('****下面是深拷贝****')
testDeepCopy()

为啥单层列表，无论是浅拷贝 还是深拷贝，对原始对象或者拷贝对象操作 都不影响另外一个对象的值

老师，麻烦问一下，实例对象是类名吗，例如，class Student,实例对象是Student吗

老师，那之前学的__init__()是不是都可以用__call__()代替

我是不是可以这么理解：

1. 类是一个模具，模具里存在类属性、类方法、静态方法、实例属性、实力方法，这些内容是公用的

2. 可以通过类名去调用类属性、类方法、静态方法、实例属性、实力方法

3. 但是在类方法、静态方法中无法调用实例属性和实力方法

老师怎么将字符串转换为列表，为什么我直接m.lite转不了

''''
使用工厂模式、单例模式实现如下需求：
(1) 电脑工厂类 ComputerFactory 用于生产电脑 Computer。工厂类使用单例模式，也就是说只能有一个工厂对象。
(2) 工厂类中可以生产各种品牌的电脑：联想、华硕、神舟
(3) 各种品牌的电脑使用继承实现：
(4) 父类是 Computer 类，定义了 calculate 方法
(5) 各品牌电脑类需要重写父类的 calculate
'''
class Computer:
    __obj=None
    __init__flag=True
    def create_computer(self,brand):
        if brand=='联想':
            return Lenovo(Computer)
        if brand=='华硕':
            return Asus(Computer)
        if brand=='神舟':
            return Hasee(Computer)
        else:
            return '未知品牌，无法创建'
    def calculate(self):
        print('生产电脑')
    def __new__(cls, *args, **kwargs):
        if cls.__obj==None:
            cls.__obj=object.__init__(cls)
            return cls.__obj
    def __init__(self,brand):
        if self.__init__flag:
            print('init...')
            self.__init__flag=False

class Lenovo(Computer):
    def calculate(self):
        print('生产联想电脑')
class Asus(Computer):
    def calculate(self):
        print('生产华硕电脑')
class Hasee(Computer):
    def calculate(self):
        print('生产神舟电脑')
factory=Computer()
factory2=Computer()
x=factory.create_computer('联想')

老师，我这个代码一直报错，看了问答区感觉我代码好像没错啊

老师，isinstance是什么意思？？