python之面向对象介绍（四）——继承与多态

最新推荐文章于 2024-04-19 14:11:27 发布
最新推荐文章于 2024-04-19 14:11:27 发布
阅读量961 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Claire_chen_jia/article/details/106041378
版权

python之面向对象介绍（四）


对象的三大特性分别是：

  1. 封装（确保对象中的数据安全）
  2. 继承（保证了对象的可扩展性）
  3. 多态（保证了程序的灵活）
    我们在面向对象介绍（三）中介绍了封装，现在就让我们来细说对象的继承和多态

1 继承

1.1 继承的简介

1.1.1 继承的引入

情形1：

# 情形1
# 创建一个医生的类
class Doctor():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def work(self):
        print('治疗病人.....')
#创建一个军人的类
class Soldie():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def work(self):
        print('保卫国家....')
#创建一个教师的类
class Teacher():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def work(self):
        print('教书育人....')

# 评价：三个类都存在一个共同点是初始化相同。作为人，都有姓名和名字
# 这样是否可以考虑创建一个人的类，然后让上面三个类继承人的类的方法或者属性
class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age

情形2：

# 情形2
# 已有一个动物类（跑、睡），需要一个狗类（跑、睡、叫）
# 方法1：直接修改动物类，在这个类中添加我们需要的功能 | 隐患：修改起来比较麻烦，违反了ocp原则
# 方法2：直接创建一个新的类，这个类就是狗类 | 隐患:创建一个新类比较麻烦，需要大量的复制粘贴。维护修改起来比较麻烦

# 方法1
class Animal:
    def run(self):
        print('动物跑.....')
    def sleep(self):
        print('动物睡觉....')
    # def speak(self):
    #
    #     print('旺旺.....')

# 方法2
class Dog:
    def run(self):
        print('动物跑.....')
    def sleep(self):
        print('动物睡觉....')
    def speak(self):
        print('旺旺.....')
# 通过以上情形，我们同样可以通过创建一个动物的类，承接所有动物的方法和属性，并让特定动物继承其功能

综上，我们大体就知道继承讲的是什么了？

  • 定义：面向对象的三大特性之一，通过继承我们可以使一个类获取到其他类中的属性和方法
  • 特点：(1)提高了代码的复用性；(2)让类与类之间产生了关系。有了这个关系，才有多态的特性
# 情形1 解决
class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
# 创建一个医生的类
class Doctor(Person):  # 继承Person的类
    def __init__(self,name,age):
        super().__init__(name,age) #  通过super()可以直接获取当前类的父类
    def work(self):
        print('治疗病人.....')

# 情形2 解决
class Animal:
    def run(self):
        print('动物跑.....')
    def sleep(self):
        print('动物睡觉....')
class Dog(Animal):  #继承Animal的类 
    def speak(self):
        print('旺旺.....')

1.1.2 继承的语法

  1. 语法就是 class 子类(父类)：
# 1. 语法就是 class 子类(父类)：
class Parent_Class:
    print('我是父类')
class Son_Class(Parent_Class):  # 语法就是 (父类)
    print('我是子类，继承了父类')
son_class = Son_Class()
print(son_class)  # 结果： 我是父类  我是子类，继承了父类  <__main__.Son_Class object at 0x000001CA8E405908>
# Son_Class()的实例化对象son_class继承了其自身和父类的语法
  1. 检验是否是其父类的语法：issubclass(子类,父类)
# 2.检验是否是其父类的语法：issubclass(子类,父类)
print(issubclass(Son_Class,Parent_Class))  # 结果为True
  1. object是所有对象的父类
# 3.object是所有对象的父类
print(issubclass(int,object))   # 结果为True
print(issubclass(Son_Class,object))   # 结果为True
print(issubclass(Parent_Class,object))   # 结果为True

1.1.3 继承的顺序

当我们调⽤⼀个对象的方法时：

  • 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
  • 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
  • 如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了
# 继承顺序
'''
当我们调⽤⼀个对象的方法时：
- 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
- 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
- 如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了
'''
class A(object):
    def test(self):
        print('A....')
class B(A):
    def test(self):
        print('B....')
class C(B):
    def test(self):
        print('C....')
c = C()
c.test()  # C....   （会优先去当前对象中寻找是否具有该方法，如果有则直接调用）

class A(object):
    def test(self):
        print('A....')
class B(A):
    def test(self):
        print('B....')
class C(B):
    pass
c = C()
c.test()  # B....   （如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法）

class A(object):
    def test(self):
        print('A....')
class B(A):
    pass
class C(B):
    pass
c = C()
c.test()  # A....   （如果没有，则去父类中的父类寻找，以此类推）
c.speak() #报错： AttributeError: 'C' object has no attribute 'speak'  # 子类和父类都没有 直到找到object，如果依然没有找到就报错了

1.2 继承的使用

1.2.1 方法重写

如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖， overrides)。原理在于继承的顺序。

# 方法重写
# - 如果子类中有和父类同名的方法。则通过子类的实例去调用方法时，会调用子类的方法而不是父类的方法。这个特点我们也称之为方法的重写(覆盖)
class Animal:
    def run(self):
        print('动物跑.....')
    def sleep(self):
        print('动物睡觉....')

class Dog(Animal):
    def run(self):
        print('狗跑.....')
    def speak(self):
        print('旺旺.....')
d = Dog()
d.run()  # 结果为 狗跑.....  方法重写（overrides）

1.2.2 多重继承

继承可以分为单继承和多继承。

  • 单继承是：一个类继承一个父类（class 子类(父类)：）
# 单继承： 一个类继承一个父类（class 子类(父类)：）
class grandFather():
    print('我是爷爷')
class Parent(grandFather):
    print('我是父类')
class SubClass(Parent):
    print('我是子类')

sub = SubClass()  # 结果：我是爷爷  我是父类  我是子类
  • 多继承是：一个类可以继承多个父类（class 子类（父类1，父类2））
# 多重继承 ：一个类可以继承多个父类（class 子类（父类1，父类2））
class Parent():
    print('我是第一个爹')
class Parent2():
    print('我是第二个爹')
class SubClass(Parent, Parent2):
    print('我是子类')

sub = SubClass()  # 结果：'我是第一个爹  我是第二个爹  我是子类

查找子类的所有的父类用方法__base__()
注意查询的主体是子类，而不是子类的实例化对象

# 查找子类的所有的父类用方法__base__()
# 注意查询的主体是子类，而不是子类的实例化对象
print(SubClass.__bases__)  # (<class '__main__.Parent'>, <class '__main__.Parent2'>)
print(sub2.__bases__)  # 报错：AttributeError: 'SubClass' object has no attribute '__bases__'

评价：

  • 在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
  • 如果多个父类中有同名的方法，则会先在第⼀个父类中寻找（父类没有，去object寻找，然后才开始第二个父类，以此同理类推），然后找第二个，找第三个…前面会覆盖后面的

1.2.3 super()函数

（1）定义

  • super() 函数是用于调用多重父类(超类)的一个方法。
  • super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表(先在第⼀个父类中寻找,然后找第二个，找第三个…前面会覆盖后面的)。
（2）语法：
super().xxx # xxx 是指父类的方法，或者属性
（3）特点：
super()可以获取当前类的父类并且通过super()返回对象调⽤父类方法时，不需要传递self

# 创建一个父类
class Animal:
    def __init__(self,name):  # 初始化
        self._name = name
    def run(self):
        print('动物跑.....')
    def sleep(self):
        print('动物睡觉....')
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name
# 父类中所有的方法都会被子类继承，包括特殊方法

class Dog(Animal):
    def __init__(self,name,age):  # age 是狗类自己私有的属性
        # 希望可以直接调用父类的__init__
        # 我希望有一种动态的方式来获取类的父类
        # Animal.__init__(self,name)  # 非动态调用，如果有多个类，需要不断修改前面的类名
        # 通过super()可以直接获取当前类的父类
        super().__init__(name)  # 语法 super().xxx  并且通过super()返回对象调⽤父类方法时，不需要传递self
        self._age = age
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self,age):
        self._age = age
    def run(self):
        print('狗跑.....')
    def speak(self):
        print('旺旺.....')


d = Dog('二哈',8)
d.name = '德牧'
print(d.name)  # 德牧 封装修改的方法
print(d.age)  # 8

（4）综合练习
参考：类的继承中super的使用

# 创建父类学校成员SchoolMember
class SchoolMember:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def tell(self):
        # 打印个人信息
        print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")

# 创建子类老师 Teacher
class Teacher1(SchoolMember):
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age) # 利用父类进行初始化
        self.salary = salary
    # 方法重写
    def tell(self):
        # 语法：print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")
        # 继承父类的方法，并加以完善自己要的东西
        SchoolMember.tell(self)
        print('Salary: {}'.format(self.salary))

member1 = SchoolMember("John", 44)
teacher1 = Teacher1("John", 44, "$60000")
member1.tell()  # Name:"John" Age:"44"
teacher1.tell()  # 打印 Name:"John" Age:"44" Salary: $60000

评价：上述类的继承中，使用了SchoolMember.init(self, name, age)和SchoolMember.tell(self)两个方法实现实例初始化与tell函数，但更好的编程实践是使用super方法实现继承。
改进：

# 创建子类老师 Teacher2
class Teacher2(SchoolMember):
    def __init__(self, name, age, salary):
        super().__init__(name,age) # 利用父类进行初始化
        self.salary = salary
    def tell(self):
        super().tell()  # 等同于 SchoolMember.tell(self)
        print('Salary: {}'.format(self.salary))

teacher2 = Teacher2("Mary", 34, "$70000")
teacher2.tell()  # 打印 Name:"Mary" Age:"34" Salary: $70000

'''
# 在子类当中可以通过使用super关键字来直接调用父类的中相应的方法，简化代码。
# 在下面例子中，教师子类调用了父类的__init__()方法、tell()方法。
# super().__init__(name,age)等同于SchoolMember.__init__(self, name, age)
# super().tell()等同于SchoolMember.tell(self)。
# 当你使用Python super()关键字调用父类方法时时，注意去掉括号里self这个参数。
'''

2 多态

2.1 多态简介

多态是⾯向对象的三大特性之⼀。从字面理解就是多种形态，即一个对象⼀个对象可以以不同形态去呈现。

class A:
    def __init__(self,name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name
class B:
    def __init__(self,name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name
class C:
    pass

a = A('葫芦娃')
b = B('钢铁侠')
c = C()
def speak(obj):
    print('你好 %s'%obj.name)
# 对应speak()这个函数来说，只要对象中函数有name属性，它就可以作为参数传递
# 这个函数并不考虑对象的类型。只要有name属性就可以
# 对象以多种形态呈现，保证程序的灵活性

def speak2(obj):
    # 检查
    if isinstance(obj,A):
        print('你好 %s' % obj.name)
# 在speak2()中我们做了一个类型检查，也就是只有符合obj是A类型的对象时，才可以使用
# 其他类型的对象使用不了该函数。这个函数就违反了多态

2.2 动态的使用

（1）分类
静态多态性：如任何类型都可以用运算符+进行运算

print('你好！'+ '很开心认识你')

动态多态性

class People:
    def talk(self):
        print('People is talking')
class Cat:
    def talk(self):
        print('Cat is miaomiao')
class Dog:
    def talk(self):
        print('Dog is wangwang')
cat1 = Cat()
dog1 = Dog()
peo1 = People()
# peo、dog、pig都是动物,只要是动物肯定有talk方法
# 于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo1.talk()
dog1.talk()
peo1.talk()
# 定义一个统一的接口来访问
def func(obj):
    obj.talk()
func(cat1)

2.3 多态特点

  • 增加了程序的灵活性：以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(obj)

  • 增加了程序de 可扩展性通过继承父类创建了一个新的类，使用者无需更改自己的代码，还是用func(父类)去调用

3 属性和方法

3.1 属性

  • 类属性
    （1）类属性：直接在类中定义的属性是类属性
    （2）类属性可以通过类或类的实例访问到。但是类属性只能通过类对象来修改，无法通过实例对象修改
'''
    # 类属性 直接在类中定义的属性
    # 类属性可以通过类和类的实例访问到
    # 类属性只能通过类对象来修改,无法通过实例对象修改
'''
class A:
    name = 'claire'  # 创建类的属性

a = A() # 类的实例化对象a
print(A.name) # claire 类属性可以通过类和类的实例访问到
print(a.name) # claire  类属性可以通过类和类的实例访问到
a.name = 'chen'
print(a.name) # chen 类属性只能通过类对象来修改,无法通过实例对象修改
print(A.name) # claire  类属性只能通过类对象来修改,无法通过实例对象修改
  • 实例属性
    （1）实例属性：通过实例对象添加的属性属于实例属性
    （2）实例属性只能通过实例对象来访问和修改，类对象无法访问修改
'''
        # 实例属性 通过实例对象添加的属性
        # 实例属性只能通过实例对象访问和修改，类对象无法访问和修改
'''
class B:
    def __init__(self):
        self.name = 'claire' # 实例属性 通过实例对象添加的属性

b = B()
print(b.name)
# print(B.name) # 报错：type object 'B' has no attribute 'name'
B.name = 'chen'
print(B.name) # claire
b.name = 'chen'
print(b.name) # chen  实例属性只能通过实例对象访问和修改，类对象无法访问和修改

3.2 方法

  • 实例方法
    （1）在类中定义，以self为第⼀个参数的方法都是实例方法
    （2）实例方法在调⽤时,Python会将调用对象以self传入
    （3）实例方法可以通过类实例和类去调用：
    当通过实例调用时，会⾃动将当前调用对象作为self传⼊
    （4）当通过类调用时，不会自动传递self，我们必须手动传递self
'''
    # 在类中定义，以self第一个参数的方法都是实例方法
    # 实例方法在调用的时候 Python会将调用对象以self传入
    # 当通过类去调用时，不会自动传递self，此时需要手动传递self
'''
class C:
    def fn(self): # 在类中定义，以self第一个参数的方法都是实例方法
        print('我是实例方法')

c = C()
c.fn()  # 我是实例方法 # 实例方法在调用的时候 Python会将调用对象以self传入
# C.fn() # 报错：fn() missing 1 required positional argument: 'self'
# C.fn(self)  # 报错： name 'self' is not defined
C.fn(c) # 我是实例方法  self就是对象 # 当通过类去调用时，不会自动传递self，此时需要手动传递self
  • 类方法
    （1）类方法 在类的内容以@classmethod 来修饰的方法属性类方法
    （2）类方法第⼀个参数是cls 也会自动被传递。cls就是当前的类对象
    （3）类方法和实例方法的区别，实例方法的第⼀个参数是self，类方法的第⼀个参数是cls
    （4）类方法可以通过类去调用，也可以通过实例调用
''
    # 类方法和实例方法的区别 实例方法第一个是参数self 而类方法第一个参数是cls
    # 而且类方法需要用@classmethod
    # 类方法可以通过类去调用，也可以通过实例调用
'''
class D:
    count = 0
    @classmethod  # 类方法需要用@classmethod
    def fn(cls):
        print('我是类方法',cls.count)

D.fn() # 我是类方法 0
d = D()
d.fn() # 我是类方法 0
  • 静态方法
    （1）在类中用@staticmethod来修饰的方法属于静态方法
    （2）静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用
    （3）静态方法，基本上是⼀个和当前类无关的方法，它只是⼀个保存到当前类中的函数
    （4）静态方法⼀般都是些工具方法，和当前类无关
'''
    #  @staticmethod  修饰的方法是静态方法
    # 静态方法不需要指定任何默认参数。静态方法可以通过类或者实例调用
    # 静态方法 基本上是一个和当前类无关的方法。它只是一个保存到当前类的函数
    # 静态方法一般都是一些工具方法。和当前类无关
'''
class E:
    @staticmethod   #  @staticmethod  修饰的方法是静态方法
    def fn():
        print('我是静态方法')

E.fn()  # 我是静态方法
e = E()
e.fn() # 我是静态方法
Claire_chen_jia
关注
Java程序中创建doctor类医生_Java程序设计案例教程 模块四 编程题1
weixin_32584595的博客
02-26 2995
该楼层疑似违规已被系统折叠隐藏此楼查看此楼Java程序设计案例教程 模块四 编程题1医生有姓名(name)、编号(idnumber)、地址(address)等基本信息，医生又分为专业医生和非专业医生，他们所具有的信息和上面所列的基本信息一样，但是专业医生除了具有上述基本信息外还有特定信息——专业(speciality)。根据它们之间的关系，创建一个Doctor类，其中包含医生的基本信息，再利用既...
python之路-面向对象（封装、继承、多态）
qq_43535322的博客
08-15 1070
文章目录面向对象-三大特征面向对象-封装封装的定义面向对象-继承继承的概念、语法和特点继承的语法专业术语继承的传递性多级继承方法的重写父类的私有属性和私有方法面向对象-多态面向对象-类属性和类方法面向对象-静态方法 面向对象-三大特征 封装 ------根据职责将属性和⽅法封装到⼀个抽象的类中； 封装 ------根据职责将属性和⽅法封装到⼀个抽象的类中； 多态 ------不同的对象调⽤相同的⽅法，产⽣不同的执⾏结果，增加代码的灵活度； 面向对象-封装 封装的定义 就是把类的属性和方法封装到类的内部
【java】【面对对象高级7】阶段实战 医院挂号系统
春天的波菜
08-02 690
通过高级的学习，通过医院挂号系统来巩固学习知识点。
患某种疾病的患者
11
05-08 140
写一条 SQL 语句，查询患有 I 类糖尿病的患者 ID （patient_id）、患者姓名（patient_name）以及其患有的所有疾病代码（conditions）。I 类糖尿病的代码总是包含前缀。'conditions' （疾病）包含 0 个或以上的疾病代码，以空格分隔。Bob 和 George 都患有代码以 DIAB1 开头的疾病。patient_id （患者 ID）是该表的主键。这个表包含医院中患者的信息。查询结果格式如下示例所示。
数据分析_Python学习04（面向对象）
qq_23904809的博客
12-28 267
面向对象的类和对象 类；一类事物，知识一个概念 Dog 对象：具体到某一个东西 zf家的狗 对象可以有属性和方法 一个简单的例子： # 类的定义 class Teacher(object): country = 'China' def teach(self): print('老师可以教书') # 创建对象 teacher = Teacher() pri...
l0.编写Doctor类{name, age, job,gender, sal} 目应的getter()和setter()方法，5个参数的构造器，重写父类(Object)的equals()方法:ubl
雾潋的博客
04-16 157
目应的getter()和setter()方法，5个参数的构造器，重写父类(Object)的equals()方法:ublic boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同。l0.编写Doctor类{name, age, job,gender, sal}
Python面向对象之继承和多态用法分析
09-19
### Python面向对象之继承和多态用法分析 #### Python 类的继承 在面向对象编程(Object Oriented Programming, OOP)中，继承是一种强大的机制，它允许创建一个新的类（子类），该类会继承现有类（基类或父类）的...
JAYのpython学习笔记——继承和多态
m0_37199634的博客
02-16 589
父类和子类 继承可以定义一个通用类（父类）,随后将它扩展成更多特定的类（子类） 在面向对象的术语中，如果类C1扩展自另一个类C2，那么就将C1成为派生类或子类，将C2称为超类基类或父类。 子类除了可以继承父类中的数据域和方法，还可以有其他的数据域和方法 #mermaid-svg-OAvgZRNyfWtFWrPr .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;
python面向对象的程序设计——类（1）
12-21
面向对象的程序设计是Python编程的核心概念之一，它基于类（Class）来构建对象，以模拟现实世界中的实体。在Python中，类是创建对象的蓝图，它定义了一组特性和行为，即属性（Attributes）和方法（Methods）。让我们...
Python面向对象特性——多态（基本概念、代码示例）
weixin_48728769的博客
09-12 951
1）封装： 根据职责将属性和方法封装到一个抽象的类中 定义类的准则 2）继承： 继承实现代码的重复利用，相同的代码不需要重复的编写 设计类的技巧 子类针对自己的特有需求，编写特定的代码 3）多态：不同的子类对象调用相同的父类方法，产生不同的执行结果 多态可以增加代码对的灵活度 以继承和重写父类方法为前提 是调用方法的技巧，不会影响到类的内部设计
创建一个Doctor类，姓名，有suggest方法和operation方法：输出“注意复诊”，“正在检查”,创建一个中医类，继承Doctor，创建一个西医类，继承Doctor.....
gfh
03-09 1094
package exam3; /** 编写一个Java应用程序，创建对应的类，并完成以下程序功能： （1） 创建一个Doctor类，姓名，有suggest方法和operation方法：输出“注意复诊”，“正在检查” （2） 创建一个中医类，继承Doctor，重写suggest和operation方法输出“注意休息”，“望闻问切” （3） 创建一个西医类，继承Doctor，重写重写sug...
Python——快速理解面向对象及三大特性
weixin_66551331的博客
04-18 398
其中def__init__(self)是初始化属性的时候要写的，里面的self是对象本身，类内添加属性的方式是self.属性名=属性值的方式，类外进行属性的添加的话就是对象名.属性名=属性值的方式。多态指的是：多种状态。多态的条件首先得有继承 （定义父类、定义子类，子类继承父类)，然后就是函数重写 （子类重写父类的函数），最后是父类引用指向子类对象 （子类对象传给父类对象调用者）。好比在饭店吃饭，要解决的问题是吃饭，但我没有自己去买菜做饭，而是把这一系列繁琐的操作过程交给饭店的厨师，就吃厨师做好的饭就行。
2021-06-01
麋鹿不迷糊的博客
06-01 363
类的继承与派生 设计以下类和函数 1.人员基类Person。其成员包括： 数据成员：姓名、性别、年龄 成员函数：SetPerson，设置人员数据函数； DisplayPerson，显示人员数据函数。 2.派生类1，Teacher， 派生自Person。新增成员包括： 数据成员：职称、教研室、所授课程 成员函数：SetTeacher，设置数据 DisplayTeacher，显示数据 3.派生类2，Student，派生自Person。新增成员包括： 数据成员：专业、班级、类别 成员函数：SetStudent，.
【附源码】Python计算机毕业设计私人医生预约系统
杰记计算机程序源码
11-19 377
项目运行环境配置：Pychram社区版+ python3.7.7 + Mysql5.7 + HBuilderX+list pip+Navicat11+Django+nodejs。项目技术：django + python+ Vue 等等组成，B/S模式 +pychram管理等等。环境需要1.运行环境：最好是python3.7.7，我们在这个版本上开发的。其他版本理论上也可以。2.pycharm环境：pycharm都可以。推荐pycharm社区版;
python计算机毕设【附源码】医生咨询系统（django+mysql+论文）
最新发布
Python毕设源码程序高学长
04-19 589
本毕业设计将采用HTML+CSS+JavaScript+Vue作为前端技术，Java+SSM作为后端技术，MySQL5.7作为数据库，Eclipse或IDEA作为开发工具，Tomcat7.0和JDK1.8作为运行环境，Maven3.3.9作为项目管理工具，力求打造一个功能完善、操作简便、安全可靠的在线医生咨询系统。在数据库管理工具的选择上，使用了Navicat 11，这是一个用户友好且功能强大的数据库管理软件，它支持多种数据库系统，包括MySQL，并提供了图形化界面，使得数据库的管理和维护工作更加便捷。
编写一个teacher类，含有“职工号”、“姓名”、“性别”、“年龄”、“职称”几个成员变量，还含有一个打印详细资料的成员函数
MarkTang3的博客
04-08 4844
class Teacher { private String name; private String num; private String Homedwelling; private String Gender; private int age; public Teacher(String name,String num,String prof){ this.name=name; this.num=num; this.Homedwelling=Homedwelling; } .
Python版医院挂号系统，基于Django+MySQL+Redis，支持支付宝扫码付款
Python代码大全
06-27 1629
Python版医院挂号系统，基于Django+MySQL+Redis，支持支付宝扫码付款。运行程序前请先申请支付宝API及支付宝公钥和私钥，可登录支付宝开放平台申请。 患者：登录、注册、挂号（选择科室、选择医生、选择时间、填写病情、支付宝支付）、展示挂号单。 医生：登录、展示并处理挂号单。 管理员：增删查改数据。 程序运行截图 核心代码： views.py setting.py 完整程序代码下载地址：Python版医院挂号系统源代码 更多Python源代码请关注：......
设计一个Employee类，包含：雇员的编号、姓名、性别、出生日期等。其中“出生日期”声明为一个日期类的对象。用成员函数实现对人员信息的录入和显示。
weixin_68255694的博客
04-11 2620
#include <iostream> using namespace std; class CDate {//创建一个名为CDate的类，用于设置日期 public: void setDate(int year, int month, int day) { Year = year; Month = month; Day = day; } void showDate(); //以下三个成员函数用于Employee中调...
Python 定义类和属性
相信相信的力量
07-25 3503
类定义动物是自然界一个庞大的群体，下面演示使用OOP建模动物类。使用Python语言创建动物类的基本语法如下，使用class关键字定义一个动物类：classAnimal(): ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值