suyas9445 发表于 2023-12-6 11:04:13

問答題：
0. 不同物件可以定義相同名字的方法
1. 減少需要定義的物件數量
2. 可以
3. 一支鳥走起來像鴨子，叫起來像鴨子，牠就是一隻鴨子
4. 低耦合
5. 不是

動手：
class Employee:
    def __init__(self,
               name,
               job,
               grade,
               year,
               uid
               ) -> None:
      self.name = name
      self.job = job
      self.grade = grade
      self.year = year
      self.uid = uid

    def get_uid(self):
      return self.uid
   
    def get_name(self):
      return self.name
   
    def get_job(self):
      return self.job
   
    def get_grade(self):
      return self.grade
   
    def get_year(self):
      return self.year
   
    def salary(self):
      if self.job == "E":
            return 3000 + 500 * self.grade + 50 * self.year
      if self.job == "T":
            return 4000 + 800 * self.grade + 100 * self.year
      if self.job == "M":
            return 5000 + 1000 * (self.grade + self.year)
      
class Interface:
    job_grade = {
      "E":10,
      "T":6,
      "M":3
    }

    job_up = {
      "E":"T",
      "T":"M"
    }

    job_down = {
      "T":"E",
      "M":"T"
    }

    def __init__(self) -> None:
      self.employees = {}
      self.uid = 10000

    def regist(self):
      name = str(input("姓名："))
      job = str(input("職位(E：普通員工；T：組長；M：經理)："))
      year = int(input("工齡："))
      grade = int(input("級別："))
      while grade > Interface.job_grade:
            grade = int(input(f"該職位最高級別為{Interface.job_grade}，請重新輸入級別："))
      self.employees = Employee(name, job, grade, year, self.uid)
      print(f"登入成功！ 姓名：{self.employees.name}，工號：{self.employees.uid}，薪資：{self.employees.salary()}")
      self.uid += 1

    def query_employee(self):
      uid = int(input("請輸入工號："))
      if not uid in self.employees:
            print("該工號不存在！")
            return
      
      print(f"姓名：{self.employees.name}")
      print(f"職位：{self.employees.job}")
      print(f"級別：{self.employees.grade}")
      print(f"工齡：{self.employees.year}")
      print(f"薪資：{self.employees.salary()}")

    def query_job(self):
      job_name = {
            "E":"普通員工",
            "T":"組長",
            "M":"經理"
      }
      job = str(input("職位(E：普通員工；T：組長；M：經理)："))
      result = [ info for uid, info in self.employees.items() if info.job == job ]
      print(f"目前{job_name}共有{len(result)}人：")
      for each in result:
            print(f"{each.uid} - {each.name}")

    def query_interface(self):
      function_dict = {
            1:self.query_employee,
            2:self.query_job
      }
      query = int(input("1.員工查詢；2.職位查詢："))

      function_dict()

    def upgrade(self):
      uid = int(input("請輸入工號："))
      if not uid in self.employees:
            print("該工號不存在！")
            return
      employee = self.employees
      presalary = employee.salary()
      print(f"{employee.name}，工號：{employee.uid}，當前職位：{employee.job}{employee.grade}，當前薪資：{employee.salary()}")
      up = int(input("請輸入需要增加的級數："))
      if employee.grade + up > Interface.job_grade:
            employee.job = Interface.job_up
            employee.grade = 1
      else:
            employee.grade += up
      
      print("升級成功！")
      print(f"{employee.name}，工號：{employee.uid}，升級後職位：{employee.job}{employee.grade}，升級後薪資：{employee.salary()}({'+' if employee.salary() - presalary > 0 else ''}{employee.salary() - presalary})")
      
    def downgrade(self):
      uid = int(input("請輸入工號："))
      if not uid in self.employees:
            print("該工號不存在！")
            return
      employee = self.employees
      presalary = employee.salary()
      print(f"{employee.name}，工號：{employee.uid}，當前職位：{employee.job}{employee.grade}，當前薪資：{employee.salary()}")
      down = int(input("請輸入需要減少的級數："))
      if employee.grade - down < 1:
            employee.job = Interface.job_down
            employee.grade = Interface.job_grade
      else:
            employee.grade -= down
      
      print("降級成功！")
      print(f"{employee.name}，工號：{employee.uid}，降級後職位：{employee.job}{employee.grade}，降級後薪資：{employee.salary()}({'+' if employee.salary() - presalary > 0 else ''}{employee.salary() - presalary})")

    def start(self):
      function_dict = {
            1:self.regist,
            2:self.query_interface,
            3:self.upgrade,
            4:self.downgrade,
      }
      while True:
            query = int(input("1.登錄；2.查詢；3.升級；4.降級；5.退出："))
            if query == 5:
                break

            function_dict()

interface = Interface()
interface.start()

火樂神 发表于 2023-12-5 22:05:41

0.python中的+和*遇到不同的类型会执行不同的运算
1.通过改变不同的场景，用同一种方法、函数、对象来实现不同的效果，可以显著减少代码的复杂程度
2.可以
3.“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
4.降低了耦合？
5.不是

0.
class Staff:
    def __init__(self,name,grade,year,uid):
      self.name = name
      self.grade = grade
      self.year = year
      self.uid = uid
    def get_uid(self):
      return self.uid
    def get_name(self):
      return self.name
    def get_job(self):
      return self.job
    def get_grade(self):
      return self.grade
    def get_year(self):
      return self.year
class Employee(Staff):
    member = []
    def __init__(self,name,grade,year,uid):
      self.job = "Employee"
      grade = "E" + str(grade)
      super().__init__(name,grade,year,uid)
      Employee.member +=
    def salary(self):
      return 3000 + 500 * int(self.grade) + 50 * self.year
class Teamleader(Staff):
    member = []
    def __init__(self,name,grade,year,uid):
      self.job = "Teamleader"
      grade = "T" + str(grade)
      super().__init__(name,grade,year,uid)
      Teamleader.member +=
    def salary(self):
      return 4000 + 800 * int(self.grade) + 100 * self.year
class Manager(Staff):
    member = []
    def __init__(self,name,grade,year,uid):
      self.job = "Manager"
      grade = "M" + str(grade)
      super().__init__(name,grade,year,uid)
      Manager.member +=
    def salary(self):
      return 5000 + 1000 * (int(self.grade) + self.year)

class Manage:
    def __init__(self):
      self.staff = dict()
      self.uid = 10000
    def program(self):
      ins = 0
      while ins != '5':
            ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
            if ins == '1':
                self.enter()
            elif ins == '2':
                self.search()
            elif ins == '3':
                self.upgrade()
            elif ins == '4':
                self.downgrade()
            elif ins != "5":
                print("请输入正确的指令")

    def confirm_uid(self):
      uid = int(input("请输入工号："))
      if not self.staff.get(uid):
            print("该工号不存在！")
            return 0
      else:
            return uid
    def confirm_job(self):
      job = input("职位（E.普通员工；T.组长；M.经理）：")
      while job not in('E','T','M'):
            print("请输入正确的指令")
            job = input("职位（E.普通员工；T.组长；M.经理）：")
      return job
   
    def enter(self):
      name = input("姓名：")
      job = self.confirm_job()
      year = int(input("工龄："))
      if job == "E":
            grade = int(input("级别："))
            while grade > 10:
                grade = int(input("该职位最高级别为10，请重新录入级别："))
            self.staff = Employee(name,grade,year,self.uid)
      elif job == "T":
            grade = int(input("级别："))
            while grade > 6:
                grade = int(input("该职位最高级别为6，请重新录入级别："))
            self.staff = Teamleader(name,grade,year,self.uid)
      else:
            grade = int(input("级别："))
            while grade > 3:
                grade = int(input("该职位最高级别为3，请重新录入级别："))
            self.staff = Manager(name,grade,year,self.uid)
      print(f"录入成功！姓名：{name}，工号：{self.uid},薪资：{self.staff.salary()}")
      self.uid += 1

    def search(self):
      ins = input("1.员工查询；2.职位查询：")
      if ins == '1':
            uid = self.confirm_uid()
            if uid:
                print(f"姓名：{self.staff.name}\n职位：{self.staff.job}\n级别：{self.staff.grade}\n工龄：{self.staff.year}\n薪资：{self.staff.salary()}")
      elif ins == '2':
            job = self.confirm_job()
            if job == "E":
                job = "普通员工"
                member = Employee.member
            elif job == "T":
                job = "组长"
                member = Teamleader.member
            else:
                job = "经理"
                member = Manager.member
            if len(member) != 0:
                print(f"目前{job}共有{len(member)}人")
                for each in member:
                  print(f"{each} - {self.staff.name}")
            else:
                print(f"目前公司没有{job}！")

    def upgrade(self):
      uid = self.confirm_uid()
      if uid:
            grade = self.staff.grade
            salary = self.staff.salary()
            print(f"{self.staff.name}，工号：{uid}，当前职位：{grade}，当前薪资：{self.staff.salary()}")
            num = int(input("请输入需要增加的级数："))
            if grade == "E":
                if int(grade) + num <= 10:
                  self.staff.grade = "E" + str(int(grade)+num)
                else:
                  grade = 1
                  self.staff = Teamleader(self.staff.name,grade,self.staff.year,uid)
                  Employee.member.remove(uid)
            elif grade == 'T':
                if int(grade) + num <= 6:
                  self.staff.grade = "T" + str(int(grade)+num)
                else:
                  grade = 1
                  self.staff = Manager(self.staff.name,grade,self.staff.year,uid)
                  Teamleader.member.remove(uid)
            else:
                if int(grade) + num <= 3:
                  self.staff.grade = "M" + str(int(grade)+num)
                else:
                  print("请输入正确的级数！")
                  return
            print("升级成功！")
            print(f"{self.staff.name}，工号：{uid}，升级后职位：{self.staff.grade}，升级后薪资：{self.staff.salary()}（+{self.staff.salary()-salary}）")

    def downgrade(self):
      uid = self.confirm_uid()
      if uid:
            grade = self.staff.grade
            salary = self.staff.salary()
            print(f"{self.staff.name}，工号：{uid}，当前职位：{grade}，当前薪资：{self.staff.salary()}")
            num = int(input("请输入需要增加的级数："))
            if grade == "E":
                if int(grade) - num > 0:
                  self.staff.grade = "E" + str(int(grade)-num)
                else:
                  print("请输入正确的级数！")
                  return
            elif grade == 'T':
                if int(grade) - num > 0:
                  self.staff.grade = "T" + str(int(grade)-num)
                else:
                  grade = 6
                  self.staff = Employee(self.staff.name,grade,self.staff.year,uid)
                  Teamleader.member.remove(uid)
            else:
                if int(grade) - num > 0:
                  self.staff.grade = "E" + str(int(grade)-num)
                else:
                  grade = 6
                  self.staff = Teamleader(self.staff.name,grade,self.staff.year,uid)
                  Manager.member.remove(uid)
            print("降级成功！")
            print(f"{self.staff.name}，工号：{uid}，降级后职位：{self.staff.grade}，降级后薪资：{self.staff.salary()}(-{salary-self.staff.salary()})")

def main():
    manage =Manage()
    manage.program()

472597966 发表于 2023-12-4 15:28:32

1

zhongyonglll 发表于 2023-12-3 17:00:08

1

panwei0774 发表于 2023-11-30 10:46:51

看看

忆故我在 发表于 2023-11-30 05:41:29

1

13814094978 发表于 2023-11-29 11:14:00

1

leizhenzi23 发表于 2023-11-29 05:13:43

1

arkia123 发表于 2023-11-28 19:16:56

z

python3366 发表于 2023-11-27 17:52:10

1

蒜爆泥鳅 发表于 2023-11-25 19:23:10

001

树上那只羊 发表于 2023-11-23 17:21:00

{:5_95:}

旦夕 发表于 2023-11-22 19:44:19

{:10_277:}

Pype 发表于 2023-11-21 21:23:22

0

PossibleWL 发表于 2023-11-20 20:16:58

happy

ike20180307 发表于 2023-11-20 15:25:54

# 企业员工管理程序
# 普通员工Employee 组长Teamleader 经理Manager 分别定义为类

# 基本信息类
class Info:
    def __init__(self, name, grade, year, uid):
      self.name = name
      self.grade = grade
      self.year = year
      self.uid = uid

    def get_uid(self):
      return self.uid
    def get_name(self):
      return self.name
    def get_job(self):
      return self.job
    def get_grade(self):
      return self.grade
    def get_year(self):
      return self.year
   

# 普通员工类
class Employee(Info):
    def __init__(self, name, grade, year, uid):
      self.job = 'E'
      super().__init__(name, grade, year, uid)
   
    def salary(self):
      return 3000 + 500*self.grade + 50*self.year
   

# 组长类
class Teamleader(Info):
    def __init__(self, name, grade, year, uid):
      self.job = 'T'
      super().__init__(name, grade, year, uid)

    def salary(self):
      return 4000 + 800*self.grade + 100*self.year


# 经理类
class Manager(Info):
    def __init__(self, name, grade, year, uid):
      self.job = 'M'
      super().__init__(name, grade, year, uid)

    def salary(self):
      return 5000 + 1000*self.grade + 1000*self.year
   

# 程序功能类
class Manage:
    def __init__(self):
      self.uid = 10000
      self.e = {}
      self.t = {}
      self.m = {}
      self.members =
      # 职位字典
      self.jobs = {'E1':1, 'E2':2, 'E3':3, 'E4':4, 'E5':5, 'E6':6, 'E7':7, 'E8':8, 'E9':9, 'E10':10,
                     'T1':11, 'T2':12, 'T3':13, 'T4':14, 'T5':15, 'T6':16,
                     'M1':17, 'M2':18, 'M3':19}

    def welcome(self):
      ins = 0
      while ins != '5':
            ins = input("\n1.录入； 2.查询； 3.升级； 4.降级； 5.退出：")
            if ins == '1':
                self.luru()
            elif ins == '2':
                self.chaxun()
            elif ins == '3':
                self.shengji()
            elif ins == '4':
                self.jiangji()
            elif ins == '5':
                print("再见~~~")

    # 录入
    def luru(self):
      name = input("姓名：")
      job = input("职位（E.普通员工； T.组长； M.经理）：")
      year = int(input("工龄："))
      if job == "E":
            grade = int(input("级别："))
            while grade < 1 or grade > 10:
                grade = int(input("普通员工1~10级，请重新输入："))
            self.e = Employee(name, grade, year, self.uid)
            print(f"录入成功！姓名：{name}，工号：{self.uid}，薪资：{self.e.salary()}")

      elif job == "T":
            grade = int(input("级别："))
            while grade < 1 or grade > 6:
                grade = int(input("组长1~6级，请重新输入："))
            self.t = Teamleader(name, grade, year, self.uid)
            print(f"录入成功！姓名：{name}，工号：{self.uid}，薪资：{self.t.salary()}")

      elif job == "M":
            grade = int(input("级别："))
            while grade < 1 or grade > 3:
                grade = int(input("组长1~3级，请重新输入："))
            self.m = Manager(name, grade, year, self.uid)
            print(f"录入成功！姓名：{name}，工号：{self.uid}，薪资：{self.m.salary()}")

      self.uid += 1

    # 查询
    def chaxun(self):
      ins = int(input("1.员工查询； 2.职位查询："))
      while ins != 1 and ins != 2:
            ins = int(input("输入错误，请重新输入。1.员工查询； 2.职位查询："))
      if ins == 1:
            uid = int(input("请输入工号："))
            for each in self.members:
                if each.get(uid):
                  print(f"姓名：{each.name}")
                  print(f"职位：{each.job}")
                  print(f"级别：{each.grade}")
                  print(f"工龄：{each.year}")
                  print(f"薪资：{each.salary()}")
                  break
            else:
                print("该工号不存在！")

      if ins == 2:
            job = input("职位（E.普通员工； T.组长； M.经理）：")
            if job == "E":
                print(f"目前普通员工共有 {len(self.e)} 人：")
                for each in self.e.keys():
                  print(f"{each} -> {self.e.name}")
            elif job == "T":
                print(f"目前组长共有 {len(self.t)} 人：")
                for each in self.t.keys():
                  print(f"{each} -> {self.t.name}")
            elif job == "M":
                print(f"目前经理共有 {len(self.m)} 人：")
                for each in self.m.keys():
                  print(f"{each} -> {self.m.name}")
   
    # 升级
    def shengji(self):
      uid = int(input("请输入工号："))
      for each in self.members:
            if each.get(uid):
                old_job = each.job
                old_salary = each.salary()
                old_grade = each.grade
                old_year = each.year
                old_name = each.name
                print(f"{old_name}，工号：{uid}，当前职位：{old_job}，当前薪资：{old_salary}")
                # 删除旧数据
                each.pop(uid)
                break
      else:
            print("该工号不存在！")
            return 0
      _grade = int(input("请输入现需要增加的级数："))
      # 旧职级字母
      old_job_grade = old_job + str(old_grade)
      while self.jobs + _grade > 19:
            _grade = int(input("升级后超过最高级，请重新输入现需要增加的级数："))
      # 职级数字
      _job_grade = self.jobs + _grade
      for each in self.jobs.items():
            if each == _job_grade:
                # 新职级
                new_job_grade = each
                break
      new_job = new_job_grade
      new_grade = int(new_job_grade)
      # 增加新数据
      if new_job == 'E':
            self.e = Employee(old_name, new_grade, old_year, uid)
            new_salary = self.e.salary()
      if new_job == 'T':
            self.t = Teamleader(old_name, new_grade, old_year, uid)
            new_salary = self.t.salary()
      if new_job == 'M':
            self.m = Manager(old_name, new_grade, old_year, uid)
            new_salary = self.m.salary()
      print("升级成功！")
      print(f"{old_name}，工号：{uid}，升级后职位：{new_job_grade}，升级后薪资：{new_salary}（{new_salary-old_salary:+}）")


    # 降级
    def jiangji(self):
      uid = int(input("请输入工号："))
      for each in self.members:
            if each.get(uid):
                old_job = each.job
                old_salary = each.salary()
                old_grade = each.grade
                old_year = each.year
                old_name = each.name
                print(f"{old_name}，工号：{uid}，当前职位：{old_job}，当前薪资：{old_salary}")
                # 删除旧数据
                each.pop(uid)
                break
      else:
            print("该工号不存在！")
            return 0
      _grade = int(input("请输入现需要减少的级数："))
      # 旧职级字母
      old_job_grade = old_job + str(old_grade)
      while self.jobs - _grade < 1:
            _grade = int(input("降级后超过最低级，请重新输入现需要减少的级数："))
      # 职级数字
      _job_grade = self.jobs - _grade
      for each in self.jobs.items():
            if each == _job_grade:
                # 新职级
                new_job_grade = each
                break
      new_job = new_job_grade
      new_grade = int(new_job_grade)
      # 增加新数据
      if new_job == 'E':
            self.e = Employee(old_name, new_grade, old_year, uid)
            new_salary = self.e.salary()
      if new_job == 'T':
            self.t = Teamleader(old_name, new_grade, old_year, uid)
            new_salary = self.t.salary()
      if new_job == 'M':
            self.m = Manager(old_name, new_grade, old_year, uid)
            new_salary = self.m.salary()
      print("降级成功！")
      print(f"{old_name}，工号：{uid}，降级后职位：{new_job_grade}，降级后薪资：{new_salary}（{new_salary-old_salary:+}）")



def main():
    m = Manage()
    m.welcome()

main()

无序的风 发表于 2023-11-19 23:08:38

发现思考的方向完全错了，得来抄一遍

FBI12138 发表于 2023-11-19 16:46:34

0.
python不会纠结对象的类别，而是在调用方法和函数的时候注重形似，只要函数和方法的操作能够进行就行

1.
优化了代码的可读性

2.
可以

3.
不知道

4.
增强了内聚，也降低了耦合

5.
不是

have a try
0.
'''企业员工管理程序'''
class stuff0:
    uid=10000

class up_down_MiXin:
    def up(self,z=0):
      if self.position=='普通工人':
            if self.grade+z>10:
                self.grade=1
                self.position='组长'
            else:
                self.grade+=z
      elif self.position=='组长':
            if self.grade+z>6:
                self.grade=1
                self.position='经理'
            else:
                self.grade+=z
      elif self.position=='经理':
            if self.grade+z>3:
                self.grade=3
            else:
                self.grade+=z
    def down(self,z=0):
      if self.position=='经理':
            if self.grade-z<0:
                self.position='组长'
                self.grade=6
            else:
                self.grade-+z
      elif self.position=='组长':
            if self.grade-z<0:
                self.position='普通工人'
                self.grade=10
            else:
                self.grade-=z
      elif self.position=='普通工人':
            if self.grade-z<0:
                self.grade=1
            else:
                self.grade-=z

class get_MiXin:
    def get_uid(self):
      return self.uid
    def get_name(self):
      return self.name
    def get_position(self):
      return self.position
    def get_grade(self):
      return self.grade
    def get_wage(self):
      return self.wage
    def salary(g):
      if g.position == '普通工人':
            pay=3000+500*g.grade+50*g.wage
            return pay

      elif g.position == '组长':
            pay=4000+800*g.grade+100*g.wage
            return pay

      elif g.position == '经理':
            pay=5000+1000*(g.grade+g.wage)
            return pay      

class stuff(stuff0,up_down_MiXin,get_MiXin):
    name='请初始化姓名'
    position='请初始化这位'
    wage=-1
    grade=-1
    uid=-1
    def __init__(self,name,position,wage,grade):
      self.name=name
      self.position=position
      self.wage=wage
      self.grade=grade
      self.uid=stuff0.uid
      stuff0.uid+=1


   
def main():
    stuffs=[]
    while True:
      mod=input('1.录入2.查询3.升级4.降级5.退出')
      if mod=='5':
            break
      elif mod=='1':
            name=input('姓名:')
            position=input('职位:(普通工人/组长/经理)')
            wage=int(input('工龄:'))
            grade=int(input('级别:'))
            stuff1=stuff(name,position,wage,grade)
            stuffs.append(stuff1)
            print(f'录入成功！姓名:{stuff1.name} 工号:{stuff1.uid} 薪资:{stuff1.salary()}')
      elif mod=='2':
            uid=input('请输入工号:')
            uid=int(uid)
            uid_condition=False
            for i in stuffs:
                if i.uid==uid:
                  j=i
                  uid_condition=True
            if uid_condition:
                print(f'姓名:{j.name}')
                print(f'职位:{j.position}')
                print(f'级别:{j.grade}')
                print(f'工龄:{j.wage}')
                print(f'薪资:{j.salary()}')
            else:
                print('该工号不存在')
      elif mod=='3':
            uid=input('请输入工号:')
            uid=int(uid)
            k=int(input('请输入升级的级数:'))
            uid_condition=False
            for i in range(len(stuffs)):
                if stuffs.uid==uid:
                  j=i
                  uid_condition=True
            if uid_condition:
                stuffs.up(k)
            else:
                print('该工号不存在')
      elif mod=='4':
            uid=input('请输入工号:')
            uid=int(uid)
            k=int(input('请输入降级的级数:'))
            uid_condition=False
            for i in range(len(stuffs)):
                if stuffs.uid==uid:
                  j=i
                  uid_condition=True
            if uid_condition:
                stuffs.down(k)
            else:
                print('该工号不存在')
            
            


   
   


coolrookie 发表于 2023-11-17 15:44:33

沙发

漂泊的小羽毛 发表于 2023-11-17 15:17:54

daan
页: 18 19 20 21 22 23 24 25 26 27 [28] 29 30 31 32 33 34 35 36 37
查看完整版本: 第063讲：类和对象（VI）| 课后测试题及答案