class ComputerFactory:
    _obj = None
    _init_flag = True

    def create_computer(self,brand):
        if brand == '联想':
           return Lenovo()
        elif brand == '华硕':
           return Asus()
        elif brand == '神舟':
            return Hasee()
        else:
            return '未知品牌，无法创建'

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

    def __init__(self):
        if ComputerFactory._init_flag:
            print("init ComputerFactory....")
            ComputerFactory._init_flag = False


class Computer(ComputerFactory):
    def __init__(self,unit,amount):
        self.unit = unit
        self.amount = amount

    def calculate(self):
        print('总销售额是：{0}'.format(self.unit*self.amount))


class Lenovo(Computer):
    def __init__(self,unit,amount,year):
        self.year = year
        Computer.__init__(self,unit,amount)

    def calculate(self):
        print('第{0}年的总销售额是{1}'.format(self.year,self.unit*self.amount))

class Asus(Computer):
    def __init__(self, unit, amount, year):
        self.year = year
        Computer.__init__(self, unit, amount)

    def calculate(self):
        print('第{0}年的总销售额是{1}'.format(self.year, self.unit * self.amount))

class Hasee(Computer):
    def __init__(self, unit, amount, year):
        self.year = year
        Computer.__init__(self, unit, amount)

    def calculate(self):
        print('第{0}年的总销售额是{1}'.format(self.year, self.unit * self.amount))


factory = ComputerFactory()
c1 = factory.create_computer('联想')
c2 = factory.create_computer('华硕')
c3 = factory.create_computer('神舟')
print(c1)
print(c2)
print(c3)
l=Lenovo()
l.calculate('联想',3000,4789,2020)

老师好，最后想分别计算各个品牌的数据并打印输出，这里的代码不会写。

字典推导式，依照视频中的例子，统计一段字符串(x)中每个字符出现了好多次，用字典记下来    

{c:x.count() for c in x}

我就想问的是，在字符串中出现同样的字符就直接跳过了  这是为啥呢  不知道我表达清楚没得

就比如x=aabbcc 

统计出来是，a :2 b:2 c :2  为啥不是a : 2 a :2 b :2........  这个样子

s.upper() == "Q"

这里为啥子必须要用大写的Q呢  我之前检查了好多次 都不得行  原来就是这里用了小写

那么python到底是用来干什么的，有什么具体用处

老师我想不出来错哪里了

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__()代替