Python pequeños ejercicios orientados a objetos

Uno, la primera parte

Ejercicio 1: los objetos pueden agregar instancias directamente

#第一个类对象的测试
class Student:

    def __init__(self,name,age):
         self.name = name
         self.age = age

    def get_score(self):
        print("{0}分数是：{1}".format(self.name,self.age))

s1 = Student("Clichong",18)
s1.get_score()

s1.salary = 100000		#直接添加实例salary与score
s1.score = 41
print(s1.salary)

s2 = Student("Xioaqi",41)
print(s2.age)

Ejercicio 2: objetos de ejemplo

#以下两行代码运行得出的结果是相同的
a.say_score()
Student.say_score(a)

print(dir(s2))
print(type(s2))
print(s2.__dict__)
print(isinstance(s2,Student))

Ejercicio 3: Atributos de clase

#第一个类对象的测试
class Student:
    company = "sxt"     #类属性
    pname = "aic"

    def __init__(self,name,age):
         self.name = name
         self.age = age

    def get_score(self):
        print("{0}分数是：{1}".format(self.name,self.age))

print(Student.company)
print(Student.pname)

Ejercicio 4: métodos de clase

#第一个类对象的测试
class Student:
    company = "sxt"     		#类属性
    pname = "aic"

    @classmethod				#类方法
    def PrintCompany(cls):
        print(Student.company)

    def __init__(self,name,age):
         self.name = name		#实例属性
         self.age = age

    def get_score(self):		#实例方法
        print("{0}分数是：{1}".format(self.name,self.age))

Student.PrintCompany()

Ejercicio 5: métodos estáticos

#第一个类对象的测试
class Student:
    company = "sxt"     #类属性
    pname = "aic"

    @staticmethod
    def reback(n):      #静态方法，但是无法实现递归
        if n == 0:
            return 1
        else:
            return n

    @classmethod		#类方法
    def PrintCompany(cls):
        print(Student.company)

    def __init__(self,name,age):	#构造函数
         self.name = name			#实例属性
         self.age = age

    def get_score(self):			#实例方法
        print("{0}分数是：{1}".format(self.name,self.age))

Student.PrintCompany()
print(Student.reback(5))

Ejercicio 6: objetos invocables

El objeto que define el método __call__ se llama "objeto invocable", es decir, el objeto se puede llamar como una función

#测试可调用方法_call__()

class SalaryAccount:
    '''工资计算类'''

    def __call__(self, Salary):
        print("算工资啦....")
        yearSalary  = Salary*12
        daySalary = Salary//22.5
        hourSarlay = Salary//8
        monthSalary = Salary

        return dict(yearSalary = yearSalary,monthSalary = monthSalary,daySalary = daySalary,hourSarlay = hourSarlay)

    def __init__(self,name,salary):
        self.name = name
        self.salary = salary

    def Print(self):
        print("hello world")

print(help(SalaryAccount))     #打印出此文档的介绍

s1 = SalaryAccount("aa",2131)
s1.Print()

s2 = SalaryAccount("21",131)
s2.Print()
print(s2(10000))

s3 = SalaryAccount("Clichong",3000)
print(s3.salary)
print(s2.salary)
print(s1.name)

class SalaryAccount:
    def __call__(self):				#可调用对象设置
        return 100

    def __init__(self,salary):		#构造函数
        self.salary = salary

    def Print(self):				#实例方法
        print(self.salary)

s1 = SalaryAccount(1)
s1.Print()

s2 = SalaryAccount(2)
s2.Print()
print(s2())	#调用可调用对象，打印100

Ejercicio 7: Cambiar la función dinámicamente

#测试可调用方法_call__()

class SalaryAccount:
    def __call__(self):
        return 100

    def __init__(self,salary):
        self.salary = salary

    def Print(self):
        print(self.salary)

def Print01(self):
#要注意，此处要带一个参数，否则会报错，因为SalaryAccount累中的Print函数也是带一个参数的
    print("好好学习，天天向上")

s1 = SalaryAccount(1)
s1.Print()

s2 = SalaryAccount(2)
s2.Print()
print(s2())

SalaryAccount.Print = Print01
s2.Print()      #要注意，此处不可以加参数，因为本来已经存在一个隐含的参数self

suplemento:

class Myfunction:
    pass

class MyAddfunction:

    mynum = None

    def __call__(self, num):    #使得对象可以像函数一样被调用
        self.mynum = num
        return self.mynum


    def __init__(self,num):     #构造函数，需要初始化的时候需要使用这个函数
        self.mynum = num

    def __add__(self, other):   #重载+运算符
        if isinstance(other,MyAddfunction):
            print("myadd_function...")
            return self.mynum*other.mynum
        else:
            print("不是同类，不能相加")

    def __mul__(self, other):   #重载*运算符
        if isinstance(other,MyAddfunction):
            print("mymul_function...")
            return self.mynum+other.mynum
        else:
            print("不是同类，不能相乘")


def mywork(s):          #在类之外定义两个方法
    print("mywork")

def mygame(s):
    print("myganme")

MyAddfunction.work = mywork     #动态的增加类方法
MyAddfunction.game = mygame

p = MyAddfunction(20)
p.work()        #可以正常进行工作
p.game()

Ejercicio 8: atributos privados

1. Prueba 1

class Clichong:

    def __init__(self,name,salary):
        self.name = name
        self.salary = salary

    def Print(self):
        print(self.name)
        print(self.salary)

a = Clichong("Tom",10000)
a.Print()
print(dir(a))

2. Prueba 2

class Clichong:

    def __init__(self,name,salary):
        self.__name = name      #定义私有属性
        self.__salary = salary  #定义私有属性

    def Print(self):
        pass
  #      print(self.name)
   #     print(self.salary)

a = Clichong("Tom",10000)
#a.Print()
print(dir(a))

3. Prueba tres

class Clichong:

    def __init__(self,name,salary):
        self.__name = name      #定义私有属性
        self.__salary = salary  #定义私有属性

    def Print(self):
        print(self.name)
        print(self.salary)

a = Clichong("Tom",10000)
a.Print()
print(dir(a))

4. Prueba 4

class Clichong:

    def __init__(self,name,salary):
        self.__name = name      #定义私有属性
        self.__salary = salary  #定义私有属性

    def Print(self):
        print(self._Clichong__name)     #由于已经转变为私有属性，改为指定格式才可以打印
        print(self._Clichong__salary)

a = Clichong("Tom",10000)
a.Print()
print(dir(a))

Ejercicio 9: métodos privados, variables de clase privadas, atributos privados

class Clichong:

    __myvar = "今年是2020年"    #定义私有类变量

    def __init__(self,name,salary):
        self.__name = name      #定义私有属性
        self.__salary = salary  #定义私有属性

    def Print(self):
        print(self._Clichong__name)     #由于已经转变为私有属性，改为指定格式才可以打印
        print(self._Clichong__salary)

    def __myprivate(self):      #定义私有方法
        print("hello Clichong")

    def PrintMyvar(self):
        print("__myvar:",Clichong.__myvar)  #内部调用私有类变量，不需要写成_Clichong__myvar的形式，只需要Clichong.__myvar便可

a = Clichong("Tom",10000)

#私有属性的测试
a._Clichong__salary = 200000    #可以直接修改室友属性
print("a._Clichong__salary:",a._Clichong__salary)   #还可以打印出来

#私有类变量的测试
print("a._Clichong__myvar:",a._Clichong__myvar)
a.PrintMyvar()
a._Clichong__myvar = "今年是2021年"         #外部直接调用私有的类变量，需要写成_Clichong__myvar的形式，与私有属性一样，与私有方法也一样
print("a._Clichong__myvar:",a._Clichong__myvar)
a.PrintMyvar()

#打印私有属性测试
a.Print()
print(dir(a))

#使用私有方法测试
# a.__myprivate()           #会失败
a._Clichong__myprivate()    #成功打印

para resumir:

• Cuando se llaman atributos privados externamente, las operaciones de las variables de clase privada y los métodos privados son las mismas. Ambos se agregan en la forma de _Clichong__myvar = "", y luego se puede llamar directamente a p._Clichong__myvar.
• Para llamar a variables de clase privadas internamente, solo necesita Clichong .__ myvar = ""

Ejercicio 10: uso de decoradores de propiedades

#property装饰器的使用
# @property 修饰的属性，如果没有加 setter 方法，则为只读属性。此处修改报错
#@property 主要用于帮助我们处理属性的读操作、写操作。

class Employee:

    def __init__(self,name,salary):
       self.name = name
       self.__salary = salary

    @property
    def salary(self):
       print("salary:",self.__salary)
       return self.__salary


    @salary.setter
    def salary(self,salary):
       if(0 < salary < 100000):
           self.__salary = salary
       else:
           print("录入错误")


a = Employee("Clichong",1000)
print(a.salary)

a.salary = -1433
print(a.salary)

Ejercicio 11: reescribe la función __str __ () en la clase de objeto

class Person:
    "Class name is Person"

    def __init__(self,name):
        self.name = name

    def __str__(self):
        return "Today is 2020/11/15"

a = Person("Clichong")
print(a)

Tarea 1: Prueba pequeña del método de clase

Diseñe una clase de rectángulo llamada MyRectangle para representar rectángulos. Esta clase contiene:
(1) Las coordenadas del vértice de la esquina superior izquierda: x, y
(2) Ancho y alto: ancho, alto
(3) Método de construcción: pasar en x, y, ancho, alto. Si no se pasa (x, y), el valor predeterminado es 0, si
no se pasa el ancho y el alto, el valor predeterminado es 100.
(4) Defina un método getArea () para calcular el área
(5) Defina un getPerimeter () para calcular el método del perímetro
(6) Definir un método draw () para dibujar este rectángulo usando un dibujo de tortuga

import turtle

pen = turtle.Pen()
pen.width(5)
pen.color("blue")
pen.showturtle()

class MyRectangle:

    def __init__(self,x = 0,y = 0,width = 100,height = 100):
        self.x = x
        self.y = y
        self.width = width
        self.height = height

    def getData(self):
        print("x:",self.x)
        print("y:",self.y)
        print("width:",self.width)
        print("height:",self.height)

    def getArea(self):
        area = self.height*self.width
        print("are:",area)

    def getPerimeter(self):
        perimeter = 2*(self.width+self.height)
        print("perimeter:",perimeter)

    def draw(self):
        pen.penup()
        pen.goto(self.x,self.y)
        pen.pendown()
        pen.goto(self.x+self.width,self.y)
        pen.goto(self.x+self.width,self.y-self.height)
        pen.goto(self.x,self.y-self.height)
        pen.goto(self.x,self.y)
        pen.penup()

#a = MyRectangle(width = 100,height = 200,x = 20,y = 10)
a = MyRectangle(width = 100,height = 200)	#直接命名参数
a.getData()
a.getArea()
a.getPerimeter()
a.draw()

while True:
    pass

Resultados de la prueba:

Segundo, la segunda parte

Ejercicio 1: La realización de la herencia múltiple y el polimorfismo, el uso de superfunción

#测试多态的实现
class Animal:
    def shout(self):
        print("动物叫")

class Dog(Animal):
    def shout(self):
        print("动物叫，狗也叫")

class Cat(Animal):
    def shout(self):
        print("动物叫，猫也叫")

class Man(Animal):
    def shout(self):
        super().shout()         #调用父类的shout方法
        print("动物叫，人也叫")

class Kid(Dog,Cat,Man):     #python语言中额可以一次性继承多个父类
    def shout(self):
        print("动物叫，小孩叫")

class Child:
    def shout(self):
        print("小屁孩叫，全都叫")

def DefWhoScout(myobject):      #多态的实现
    if isinstance(myobject,Animal):
        myobject.shout()
    else:
        print("原来是个小孩叫")

print(Man.mro())    #由于super函数，会打印父类的方法；还会打印自己的方法
print(Dog.mro())
print(Kid.mro())    #验证python中的多重继承

DefWhoScout(Man())		#注意，此处的类对象Man是有括号的Man()
DefWhoScout(Dog())		#注意，此处的类对象Dog是有括号的Dog()
DefWhoScout(Kid())
DefWhoScout(Child())    #因为其没有继承Animal类，故其会执行else语句，而不是自己的shout函数

Ejercicio 2: una breve discusión sobre operadores sobrecargados

#重载运算符的实现

#原本的+运算符的用法
num1 = 10
num2 = 20
result = num1 + num2
print("[+]no change result:",result)

class Myfunction:
    pass

class MyAddfunction:

    def __init__(self,num):
        self.num = num

    def __add__(self, other):       #重载+运算符
        if isinstance(other,MyAddfunction):
            return self.num*other.num   #[+]的运算规则是相乘
        else:
            print("不是同类，不能相加")

    def __mul__(self, other):       #重载*运算符
        if isinstance(other, MyAddfunction):
            return self.num + other.num  # [*]的运算规则是相加
        else:
            print("不是同类，不能相加")

t0 = Myfunction()
t1 = MyAddfunction(10)
t2 = MyAddfunction(20)
print("t1:",t1.num,"   t2:",t2.num)

#测试重载后的+运算符
t = t1+t2
print("{0}+{1}={2}".format("t1","t2",t))

#测试重载后的*运算符
t = t1*t2
print("{0}*{1}={2}".format("t1","t2",t))

Suplemento: La idea es convertir la clase en un objeto y luego usar el operador sobrecargado para llamar, pero el resultado falla.

#重载运算符的实现
class Myfunction:
    pass

class MyAddfunction:

    mynum = None

    def __call__(self, num):    #使得对象可以像函数一样被调用
        self.mynum = num
        return self.mynum


    def __init__(self,num):     #构造函数，需要初始化的时候需要使用这个函数
        self.mynum = num

    def __add__(self, other):   #重载+运算符
        if isinstance(other,MyAddfunction):
            print("myadd_function...")
            return self.mynum*other.mynum
        else:
            print("不是同类，不能相加")

    def __mul__(self, other):   #重载*运算符
        if isinstance(other,MyAddfunction):
            print("mymul_function...")
            return self.mynum+other.mynum
        else:
            print("不是同类，不能相乘")


'''''''''
t1 = MyAddfunction()
t2 = MyAddfunction()
t = t1(10)+t2(20)       #由于运算符是返回之后再相加，所以没有使用重载的功能
print(t)
'''''''''

t1 = MyAddfunction(10)
t2 = MyAddfunction(20)
t = t1 + t2             #使用了重载的功能
print(t)

Resumen: indica que la función __call__ no se puede utilizar con operadores sobrecargados.

Ejercicio 3: Discusión sobre copia superficial y copia profunda

• La operación de asignación de variables
  solo forma dos variables, que en realidad apuntan al mismo objeto.
• Copia superficial Las copias de
  Python son generalmente copias superficiales. Al copiar, el contenido de los subobjetos contenidos en el objeto no se copia. Por lo tanto, el objeto de origen
  y el objeto copiado se refieren al mismo objeto secundario.
• Copia profunda
  Utilice la función de copia profunda del módulo de copia para copiar de forma recursiva los subobjetos contenidos en el objeto.
  Todos los objetos secundarios del objeto de origen y el objeto copiado también son diferentes.

Resumen: La
operación de copia no copia ningún contenido, solo la asignación geológica apunta al mismo contenido. La copia superficial es la copia del objeto, pero el contenido de los objetos secundarios del objeto no se copia, sino que apunta al mismo contenido. La copia profunda no solo copia el objeto, sino que también copia los subobjetos del objeto.

import copy

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("CPU对象",self)

class Screen:
    def show(self):
        print("屏幕对象",self)

c = CPU()
s = Screen()
m = MobilePhone(c,s)

m.cpu.calculate()
m.screen.show()

#赋值操作
p1 = m
print("p1:",p1," m:",m) #对象地址没有改变
p1.cpu.calculate()      #对象的子对象地址也没有改变，说明还是同一个地址
p1.screen.show()

#浅拷贝操作
p2 = copy.copy(m)       
print("p2:",p2," m:",m) #对象地址发生变化，说明拷贝了一个对象
p2.cpu.calculate()      #对象的子对象没有改变，说明还是指向统一而个地址
p2.screen.show()

#深拷贝操作
p3 = copy.deepcopy(m)
print("p3:",p3," m:",m) #对象地址改变
p3.cpu.calculate()      #子对象的地址也改变，说明是完全拷贝了一个新的
p3.screen.show()

Ejercicio 4: ejemplo simple de patrón de fábrica

El modelo de fábrica se da cuenta de la separación del creador y el llamador. El uso de una clase de fábrica especial seleccionará la clase de implementación y creará objetos para una
gestión y control unificados.

# 工程设计模式
class CarFactroy:
    def createCar(self,brand):
        if brand == "Benz":
            return Benz()
        elif brand == "BWM":
            return BMW()
        elif brand == "BYD":
            return BYD()
        else:
            return "Error! Unknowd Brand!"

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass


factory = CarFactroy()
c1 = factory.createCar("Benz")
c2 = factory.createCar("BYD")

print(c1)
print(c2)

Ejercicio 5: ejemplo simple de patrón singleton

La función principal del Singleton Pattern es garantizar que una clase tenga solo una instancia y proporcionar un punto de acceso global a esa instancia.
El modo singleton solo genera un objeto de instancia, lo que reduce la sobrecarga de los recursos del sistema. Cuando la generación de un objeto requiere más recursos, como la lectura de archivos de configuración y la generación de otros objetos dependientes, se puede generar un "objeto singleton" y luego residir permanentemente en la memoria, lo que reduce en gran medida la sobrecarga.
Hay muchas formas de implementar el modo singleton. Recomendamos el método de reescribir __new __ () aquí. Método new (): se usa para crear objetos, pero generalmente no necesitamos redefinir este método.

#单例模式的其中一种实现方法

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("Clichong")
print(a)
b = MySingleton("Kacura")
print(b)

class MySingle:

    object_flag = None

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

    def __init__(self,number):	#不对构造函数作出限定，则其会不断地进行构造然后覆盖，不符合意思
        self.number = number

p3 = MySingle(10)
p4 = MySingle(20)
print(p3.number)
print(p4.number)

PD:

· _Xxx: Proteger miembros, no se pueden importar con "from module import *". Solo los objetos de clase y los objetos de subclase pueden acceder a estos miembros. ·
· Xxx : miembros especiales definidos por el sistema
· __xxx: miembros privados de la clase, solo el objeto de clase en sí puede acceder y el objeto de subclase tampoco puede acceder a él. (Sin embargo, fuera de la clase se puede acceder a través de la forma especial de "nombre de objeto. _Nombre de clase__xxx". Python no tiene miembros privados en el sentido estricto)

Tarea 2: Uso de la combinación

Defina la clase de motor Motor, la clase de chasis Chassis, la clase de asiento Seat y la clase de carcasa del vehículo Shell, y utilice la
relación de combinación para definir la clase de automóvil. Otros requisitos son los siguientes:
definir el método run () del automóvil, que necesita llamar al método work () de la clase Motor, al método work () de la
clase de asiento y al método work () de la clase de chasis Chasis.

class Motor:
    def work(self):
        print("In Motor Work...")

class Chassis:
    def work(self):
        print("In Chassis Work...")

class Seat:
    def work(self):
        print("In Seat Work...")

class Shell:
    def work(self):
        print("In Shell Work...")

class Car:
    def __init__(self,motor,chassis,seat,shell):
        self.motor = motor
        self.chassis = chassis
        self.seat = seat
        self.shell = shell

    def run(self):
        self.motor.work()
        self.shell.work()
        self.seat.work()
        self.chassis.work()

Mo = Motor()
Sh = Shell()
Se = Seat()
Ch = Chassis()

mycar = Car(Mo,Sh,Se,Ch)
mycar.run()

Tarea 3: use el modo de fábrica y el modo singleton para lograr los siguientes requisitos

(1) La clase ComputerFactory ComputerFactory se utiliza para producir computadoras. La clase de fábrica usa el patrón singleton, lo que
significa que solo puede haber un objeto de fábrica.
(2) Se pueden producir varias marcas de computadoras en la clase de fábrica: Lenovo, ASUS, Shenzhou
(3) El uso de la implementación de herencia de varias marcas de computadoras:
(4) La clase principal es la clase Computadora, que define el método de cálculo
(5) Computadoras de varias marcas La clase debe anular el método de cálculo de la clase principal

class ComputerFactory:

    __single_flag = None

    def __new__(cls, *args, **kwargs):      #设置成单例模式
        if cls.__single_flag == None:
            cls.__single_flag = object.__new__(cls)
        return cls.__single_flag

    def ProtectComputer(self,brand):        #工程模式，没有写构造函数
        if brand == "联想":
            return Lenovo()
        elif brand == "华硕":
            return HuaShuo()
        elif brand == "神舟":
            return ShenZhou()
        else:
            print("Error! Unknowed Brand!!!")

class Computer:     #父类
    Flag = 111200
    def calculate(self):
        pass

#定义三个子类继承父类
class ShenZhou(Computer):
    def calculate(self):
        print("Produce Shenzhou computer...:",self.Flag)

class Lenovo(Computer):
    def calculate(self):
        print("Produce Lenovo computer...:",self.Flag)

class HuaShuo(Computer):
    def calculate(self):
        print("Produce Huashuo computer...:",self.Flag)

#定义两个对象来测试单例模式
myfacture = ComputerFactory()
myotherfacture = ComputerFactory()
print(myfacture)
print(myotherfacture)

#生产不同的电脑测试工厂模式
c1 = myfacture.ProtectComputer("联想")        #更换了对象也是无所谓的，因为是同一个对象
c2 = myotherfacture.ProtectComputer("华硕")
c3 = myfacture.ProtectComputer("神舟")

#调用各自改写父类的方法
c1.calculate()
c2.calculate()
c3.calculate()

Ejercicio 4: uso mixto de métodos get y set y sobrecargas para la configuración de propiedades

Para definir una clase de empleado, los requisitos son los siguientes:
(1) Los atributos son: id, nombre, salario
(2) Sobrecarga del operador +: cuando se suman dos objetos, su salario y
(3) Requisitos del método de construcción: nombre de entrada , Salario, no ingrese id. id adopta el método de autoincremento, a partir de 1000
, el primer objeto nuevo es 1001 y el segundo objeto nuevo es 1002.
(4) De acuerdo con la propiedad de salario, use @property para establecer los métodos get y set de la propiedad. El método establecido requiere la entrada
: un número en el rango de 1000-50000.

class Employee:

    employee_id = 1000

    def __init__(self,name,salary):     #构造函数
        self.name = name
        self.__salary = salary
        self.id = self.employee_id
        Employee.employee_id += 1       #实现id自增

    def __add__(self, other):           #重载+运算符，对象相加返回的是工资相加
        if isinstance(other,Employee):
            return self.__salary+other.__salary
        else:
            print("Error! 不是同一种类型")

    @property                   #将函数salary修饰为一个对象，返回的工资金额，也就是赋值与工资保存
    def salary(self):
        return self.__salary

    @salary.setter              #限制工资的录入范围
    def salary(self,salary):
        if(1000 < salary < 50000):
            self.__salary = salary
        else:
            print("Error! Salery Info Error!!!")

#定义了3个对象
emp1 = Employee("Clichong",35000)
emp2 = Employee("Kacura",15000)
emp3 = Employee("Lawrence",25000)

#id自增测试
print("id = {0} name = {1} salary = {2}".format(emp1.id,emp1.name,emp1.salary))
print("id = {0} name = {1} salary = {2}".format(emp2.id,emp2.name,emp2.salary))
print("id = {0} name = {1} salary = {2}".format(emp3.id,emp3.name,emp3.salary))

#重载了+运算符测试
emp = emp1+emp2
print("emp1+emp2=",emp)
emp = emp2+emp3
print("emp2+emp3=",emp)

#property 设置属性的 get 和 set 方法测试
print(dir(emp1))
print("emp1.salary:",emp1.salary,"emp1._Employee__salary:",emp1._Employee__salary)
emp1.salary = 10500         #property修饰器使得salary函数变成了一个对象去使用
print("emp1.salary:",emp1.salary,"emp1._Employee__salary:",emp1._Employee__salary)
emp1.salary = -1000         #会报错，因为超出了范围
print("emp1.salary:",emp1.salary,"emp1._Employee__salary:",emp1._Employee__salary)
emp1.salary = 45000         #emp1的salary又重新被修改为45000
print("emp1.salary:",emp1.salary,"emp1._Employee__salary:",emp1._Employee__salary)