组合
定义：给一个类的对象封装一个属性，这个属性是另一个类的对象。
class Gamerole: def __init__(self,nickname,ad,hp): self.nickname = nickname self.ad = ad self.hp = hp def attack(self,role): role.hp = role.hp - self.ad print('%s攻击%s,%s掉了%s血,还剩%s血' %\ (self.nickname,role.nickname,role.nickname,self.ad,role.hp)) def equip_weaon(self,w): # 给人物封装了一个武器属性，这个属性值是Weapon类的一个对象 self.weapon = w # 组合 class Weapon: def __init__(self,name,ad): self.name = name self.ad = ad def fight(self,role1,role2): role2.hp = role2.hp - self.ad print('%s 用 %s 攻击了%s, %s掉了%s血,还剩%s血'\ %(role1.nickname,self.name,role2.nickname,role2.nickname,self.ad,role2.hp)) p1 = Gamerole('盖伦',20,500) p2 = Gamerole('剑豪',100,200) # p1.attack(p2) # print(p2.hp) # w1.fight(p1,p2) # 这样不好，动作的发起者应该是人而不是武器 # w1 = Weapon('大宝剑',30) # w2 = Weapon('武士刀',80) # print(w1) # p1.equip_weaon(w1) # print(p1.weapon) #其实 他就是w1 # p1.weapon.fight(p1,p2) # 让剑豪利用武士刀给盖伦一刀 # p2.equip_weaon(w2) # p2.weapon.fight(p2,p1)
Day15天作业及默写 # 1,完成下列功能: # 1.1创建一个人类Person,再类中创建3个静态变量(静态字段) # animal = '高级动物' # soul = '有灵魂' # language = '语言' # 1.2在类中定义三个方法,吃饭,睡觉,工作. # 1.3在此类中的__init__方法中,给对象封装5个属性:国家,姓名,性别,年龄, 身高. # 1.4实例化四个人类对象: # 第一个人类对象p1属性为:中国,alex,未知,42,175. # 第二个人类对象p2属性为:美国,武大,男,35,160. # 第三个人类对象p3属性为:你自己定义. # 第四个人类对象p4属性为:p1的国籍,p2的名字,p3的性别,p2的年龄,p3 的身高. # 1.5 通过p1对象执行吃饭方法,方法里面打印:alex在吃饭. # 1.6 通过p2对象执行吃饭方法,方法里面打印:武大在吃饭. # 1.7 通过p3对象执行吃饭方法,方法里面打印:(p3对象自己的名字)在吃饭. # 1.8 通过p1对象找到Person的静态变量 animal # 1.9 通过p2对象找到Person的静态变量 soul # 2.0 通过p3对象找到Person的静态变量 language # class Person: # animal = '高级动物' # soul = '有灵魂' # language = '语言' # def __init__(self,country,name,sex,age,height): # self.country = country # self.name = name # self.age = age # self.sex = sex # self.height = height # def eat(self): # print('%s吃饭' %self.name) # def sleep(self): # print('睡觉') # def work(self): # print('工作') # p1 = Person('中国','alex','未知',42,175) # p2 = Person('美国','武大','男',35,140) # p3 = Person('日本','西门','男',20,180) # p4 = Person(p1.country,p2.name,'男',20,180) # p1.eat() # p2.eat() # p3.eat() # 2,通过自己创建类,实例化对象 # 在终端输出如下信息 # 小明，10岁，男，上山去砍柴 # 小明，10岁，男，开车去东北 # 小明，10岁，男，最爱大保健 # 老李，90岁，男，上山去砍柴 # 老李，90岁，男，开车去东北 # 老李，90岁，男，最爱大保健 # 老张… # class Daylife: # def __init__(self,name,sex,age): # # self.name = name # self.age = age # self.sex = sex # # def chop_wood(self): # print('%s,%s,%s,上山去砍柴' %(self.name,self.age,self.sex)) # def drive(self): # print('%s,%s,%s,开车去东北' %(self.name,self.age,self.sex)) # def health_care(self): # print('%s,%s,%s,最爱大保健' % (self.name, self.age, self.sex)) # # p1 = Daylife('小明','男',10) # p1.chop_wood() # p1.drive() # p1.health_care() # 3,模拟英雄联盟写一个游戏人物的类（升级题）. # 要求: # (1)创建一个 Game_role的类. # (2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性. # (3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能: # 例: 实例化一个对象 盖伦,ad为10, hp为100 # 实例化另个一个对象 剑豪 ad为20, hp为80 # 盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血, 还剩多少血'的提示功能. # # # 4,默写内容: # 创建一个人类,定义三个静态变量,在构造方法中封装3个属性.然后实例化一个对象,对象调用自己的属性,对象调用类的静态方法,对象调用类中的方法. # 默写一下实例化一个对象，具体经历了哪些阶段。 #
# -*- coding: utf-8 -*- # @Time : 2018/8/28 8:33 # @Author : 骑士计划 # @Email : customer@luffycity.com # @File : 1.内容回顾.py # @Software: PyCharm # 类 具有相同属性和方法的一类事物 # 实例化 类名() # 开辟了一块内存空间 # 执行init # 封装属性 # 自动的把self返回给实例化对象的地方 # 对象/实例 # 一个实实在在存在的实体 # 组合 # 一个类的对象 作为另一个类对象的属性 # 让两个类之间产生关系 # 类和对象的命名空间 # class Course: # def __init__(self,name,price): # self.name = name # self.price = price # class Student: # def __init__(self,name,age,course): # self.name = name # self.age = age # self.course = course # # python = Course('python',19800) # xiaoming1 = Student('小明',22,python) # xiaoming2 = Student('小明',22,python) # xiaoming3 = Student('小明',22,python) # python.price = 29800 # print(xiaoming.course.name) # class Student: # def __init__(self,name,age,course_name,course_price): # self.name = name # self.age = age # self.course_name = course_name # self.course_price = course_price # # xiaoming1 = Student('小明',22,'python',19800) # xiaoming1 = Student('小明',22,'python',19800) # xiaoming1 = Student('小明',22,'python',19800) # xiaoming1 = Student('小明',22,'python',19800) # __dict__ : # 类中 ： 所有的静态属性 和 方法 # 对象 ： 所有的对象的属性 、 类对象指针 # class Foo: # count = 0 # def __init__(self): # self.count += 1 # f1 = Foo() # f2 = Foo() # print(Foo.count) # 0 # print(f1.count) # 1 # print(f2.count) # 静态属性 ： 类的属性，所有的对象共享这个变量 # 对象名 去修改 类的静态属性 # 在对象的空间中又创建了一个属性，而不能修改类中属性的值 # 操作静态属性 应该 用类名来操作 # 请你写一个类，能够统计一共实例化了多少个对象？ # class Foo: # count = 0 # def __init__(self): # Foo.count += 1 # # f1 = Foo() # print(f1.count) # f2 = Foo() # f3 = Foo() # f4 = Foo() # f5 = Foo() # print(f1.count) # print(f5.count) # print(Foo.count) # 当类中的属性发生改变的时候，对象中没有同名的属性、方法的时候，对象使用属性名会跟着类中的变量走 # class Foo: # count = [0] # # f1 = Foo() # f1.count[0] += 1 # print(f1.count[0]) # print(Foo.count[0]) # f1.count = [2] # print(f1.count) # print(Foo.count) # 只要对象的某个属性被直接赋值，那么一定是对象的命名空间发生变化 # 只要是静态变量，就用类名操作*****
面向对象的三大特性
继承
#
# 继承和抽象 两个概念
# 单继承
# 语法 ： 父类 子类
# 继承与重用
# 子类可以使用父类中的名字（变量和方法）
# 游戏 # 梅西 奥巴马 史努比 史派克 小猪配齐 猪八戒 # 实例 # 人 狗 猪 # 分类 # 动物 # 汇总 # 先抽象 后继承 # 猫类 ： # 属性 ： 名字，品种，食物 # 方法 ： 叫，抓老鼠，吃，喝 # 狗类 ： # 属性 ： 名字，品种，食物 # 方法 ： 叫，看家，吃，喝 # class Animal: # def __init__(self,name,kind,food,language): # self.name = name # self.kind = kind # self.food = food # self.language = language # def yell(self): # print('%s叫'%self.language) # def eat(self): # print('吃%s'%(self.food)) # def drink(self): # print('喝水') # # class Cat(Animal): # def catch_mouse(self): # print('抓老鼠') # # class Dog(Animal): # def look_after_house(self): # print('看家') # 继承 # 父类/超类/基类 ：Animal # 子类/派生类 ：Cat、Dog # 继承与重用 - 父类中所有的属性和方法都可以被子类使用了 # 阿猫 = Cat('阿猫','橘猫','牛杂','喵喵') # print(阿猫.name) # 阿猫.drink() # 阿猫.eat() # 阿猫.yell() # # 阿狗 = Dog('阿狗','土狗','阿猫','汪汪') # print(阿狗.name) # 阿狗.drink() # 阿狗.eat() # 阿狗.yell()
# 继承与派生
# 子类在父类的基础上又新创建了自己需要的方法和属性
# 父类有的子类没有 - 子类对象直接调用 就会直接执行父类的方法
# 父类有的子类也有 - 子类对象调用 直接执行子类中的方法
# 想在子类中使用父类的名字 ： 父类名、super()去调用
# 派生 # class Animal: # def __init__(self,name,kind,food,language): # print('in animal') # self.name = name # self.kind = kind # self.food = food # self.language = language # def yell(self): # print('%s叫'%self.language) # def eat(self): # print('吃%s'%(self.food)) # def drink(self): # print('喝水') # # class Cat(Animal): # Animal的派生类 # def __init__(self,name,kind,food,language,eye_color): # print('in Cat') # self.eye_color = eye_color # 派生属性 # Animal.__init__(self,name,kind,food,language) # # super().__init__(name,kind,food,language) # # def catch_mouse(self): # 派生方法 # print('抓老鼠') # # def eat(self): # 不仅执行了父类中的基础功能，还完成了特殊的功能 # Animal.eat(self) # # super().eat() # self.weight = 10 # # class Dog(Animal): # def look_after_house(self): # print('看家') # # def eat(self): # # Animal.eat(self) # super().eat() # self.drink() # # 阿猫 = Cat('阿猫','橘猫','牛杂','喵喵','绿色') # print(阿猫.eye_color) # print(阿猫.food) # 阿猫.catch_mouse() # 阿猫.eat() # print(阿猫.weight) # 当子类当中有要被调用的方法的时候，子类的对象会直接选择子类中的方法、变量,父类中的方法不会被自动执行 # 如果我们既想要执行子类的方法，也想要执行父类的方法，那么需要在子类的方法中调用父类的方法： # 父类名.方法名(self,...) # super().方法名(...) # 帮助我们在子类中调用父类中的同名方法
# 面试题 # class Foo: # def __init__(self): # self.func() # def func(self): # print('in Foo') # # class Son(Foo): # def func(self): # print('in Son') # # s1 = Son() # class Foo: # Country = 'China' # def func(self): # print(self.Country) # # class Son(Foo): # Country = 'English' # def func(self): # 走这个方法 # print(self.Country) # # s = Son() # s.func() # class Foo: # Country = 'China' # def func(self): # 走这个方法 # print(self.Country) # # class Son(Foo): # Country = 'English' # # s = Son() # s.func() # English # class Foo: # Country = 'China' # def func(self): # print(self.Country) # # class Son(Foo):pass # # s = Son() # s.func() # 'China'
一样
# 规范的编程模式
# 抽象类
# 工作中 公司有使用抽象类开发的规则 # 源码 别人使用抽象类 # 支付功能 from abc import ABCMeta,abstractmethod class Payment(metaclass=ABCMeta): # 模板的功能 @abstractmethod # abstractmethod是一个装饰器，装饰器怎么用？放在函数/类的上一行 def pay(self):pass @abstractmethod def shouqian(self):pass class Alipay(Payment): def pay(self,money): print('使用支付宝支付了%s元'%money) class Wechatpay(Payment): def pay(self,money): print('使用微信支付了%s元'%money) class ApplePay(Payment): def pay(self,money): print('使用applepay支付了%s元' % money) def pay(obj,money): obj.pay(money) p = Payment() # a = Alipay() # # a.pay(100) # pay(a,100) # # we = Wechatpay() # # we.pay(200) # pay(we,200) # # ap = ApplePay() # 规范 # 多人开发、复杂的需求、后期的扩展 # 手段 来帮助我们完成规范 # 抽象类 # 抽象类是一个规范，它基本不会实现什么具体的功能，抽象类是不能被实例化 # 要想写一个抽象类 # from abc import ABCMeta,abstractmethod # 在这个类创建的时候指定 metaclass = ABCMeta # 在你希望子类实现的方法上加上一个 @abstractmethod装饰器 # 使用抽象类 # 继承这个类 # 必须实现这个类中被@abstractmethod装饰器装饰的方法
# 多继承
# 不是所有的语言都支持多继承 java # c++ 支持多继承 # 天鹅 飞 游泳 走路 # 老虎 走路 游泳 # 鹦鹉 飞 说话 走路 # class Animal: # def __init__(self,name): # self.name = name # def talk(self): # print('%s说话了'%self.name) # # def swim(self): # print('%s在游泳'%self.name) # # def fly(self): # print('%s在飞'%self.name) # # def walk(self): # print('%s在走路'%self.name) class Animal: def __init__(self,name): self.name = name class FlyAnimal(Animal): def fly(self): print('%s在飞' % self.name) class WalkAnimal(Animal): def walk(self): print('%s在走路'%self.name) class SwimAnimal(Animal): def swim(self): print('%s在游泳'%self.name) class Tiger(SwimAnimal,WalkAnimal): pass class Swan(SwimAnimal,WalkAnimal,FlyAnimal): pass class Parrot(FlyAnimal,WalkAnimal): def talk(self): print('%s说话了'%self.name) swan = Swan('天鹅') swan.fly() swan.walk()
# 语法
# 接口（原生python没有，是一些程序员自己搞出来的）
# java c# 以下是java等接口的独自写代码实现接口 # 不允许多继承 # 接口 Interface 接口可以被多继承 # Interface FlyAnimal: # 规范继承我的类必须实现这个方法 # def fly():pass # Interface WalkAnimal: # def walk():pass # Interface SwimAnimal: # def swim():pass # class Tiger(WalkAnimal,SwimAnimal): 继承了一个规范 # def walk():代码 # def swim():代码 # 抽象类 # 接口
新式类和经典类
# 新式类中
# 所有的多继承关系寻找方法的顺序 - 遵循广度优先算法
# 继承object
# mro方法
# super : super不是单纯的找父类，而是遵循mro顺序的
# 经典类
# python2.x
# 不主动继承object
# 经典类在找父类中方法的过程中 遵循 —— 深度优先
# 不提供mro方法和super
# 新式类 # 在python3.x版本中 所有的类都是新式类 # 所有的新式类都有一个默认的父类 ： object # class Person1:pass # class Person2():pass # class Person3(object):pass # # p = Person2() # __init__ 初始化方法 # print(Person1.__bases__) # print(Person2.__bases__) # print(Person3.__bases__) # python 2.7 # 经典类 和 新式类 并存 # class Student:pass # 经典类 # class Student(object):pass # 继承了object的类就是新式类 # 在py3中所有的类都是新式类 # 在py2中既有新式类又有经典类 # 多继承的顺序 在新式类和经典类之间的区别 # class A: # def func(self): # print('A') # # class B(A): # pass # # def func(self): # # print('B') # # class C(A): # pass # # def func(self): # # print('C') # # class D(B,C): # pass # # def func(self): # # print('D') # print(D.mro()) # d = D() # d.func() # 新式类中 # 所有的多继承关系寻找方法的顺序 - 遵循广度优先算法 # 继承object # mro方法 # super : super不是单纯的找父类，而是遵循mro顺序的 # 经典类 # python2.x # 不主动继承object # 经典类在找父类中方法的过程中 遵循 —— 深度优先 # 不提供mro方法和super # class A: # def func(self): # print('A') # # class B(A): # def func(self): # super().func() # print('B') # # class C(A): # def func(self): # super().func() # print('C') # # class D(B,C): # def func(self): # super().func() # print('D') # # D().func() # B().func() class A(object): pass def func(self): print('A') class B(A): pass def func(self): A.func(self) print('B') class C(A): pass def func(self): print('C') class D(B,C): pass # def func(self): # print('D') D().func()
新式类：广度优先。
# 多态
# 什么是多态
什么是多态 : Animal类表现出了Dog，Cat两种形态 class Animal:pass class Dog(Animal):pass class Cat(Animal):pass 旺财 = Dog() 为什么要把多态单独列出来 def func(str name,int age): print(name,age) func(1,2) class Payment:pass class ApplePay(Payment): def pay(self):pass class Alipay(Payment): def pay(self):pass def pay(obj,money): obj.pay() app = ApplePay() print(type(app)) pay(app,123) alp = Alipay() pay(alp,345) java中运用多态来解决传参数的时候 数据类型的规范问题 str 是一个类 a = '123' a = str('123') # str是一个类，str()就是实例化 ，a是一个对象，是str类的对象，a的type就是str
# 多态在python中的应用
# 一个类表现出的多种状态 ： 通过继承来实现的 # 在java中的表现 : 在一个函数中需要给参数指定数据类型，如果这个地方可以接收两个以上类型的参数， # 那么这些类型应该有一个父类，这个父类是所有子类对象的类型 # def func(Cat mao):pass # def func(Dog gou):pass # def func(Animal gou|mao):pass # 在python中：函数的参数不需要指定数据类型，所以我们也不需要通过继承的形式来统一一组类的类型， # 换句话说 所有的对象其实都是object类型，所以在python当中其实处处是多态 # def func(a): # a既可以传猫也可以传狗类型，随便传任意类型
# 鸭子类型
def len(obj) len() # str list tuple dict set range(3) print() # 所有的对象都是鸭子类型 不是明确的通过继承实现的多态 而是通过一个模糊的概念来判断这个函数能不能接受这个类型的参数 背下来 写在本上 过两个月再返回来看 理解
# 封装
# 广义的封装
# 狭义的封装
# 私有的
# 原理
# 使用方式、场景
# 广义上的封装 # class 类名: # def 方法1(self):pass # 是为了只有这个类的对象才能使用定义在类中的方法 # 狭义上的封装 # 把一个名字藏在类中 # class Goods: # __discount = 0 # 私有的静态变量 # print(__discount) # print(Goods.__discount) # 在类的外部不能引用私有的静态变量 # 类中的静态变量和方法名在程序加载的过程中就已经执行完了，不需要等待调用 # 在这个类加载完成之前，Goods这个名字还没有出现在内存空间中 # 私有的静态属性可以在类的内部使用，用来隐藏某个变量的值 # class Goods: # __discount = 0 # 私有的静态变量 # # 变形 ： _类名__私有变量 # # print(Goods.__dict__) # print(Goods._Goods__discount) # 编程规范的角度上出发 我们不能在类的外部使用私有的变量 # class Srudent: # def __init__(self,name,age): # self.__name = name # self.age = age # def name(self): # return self.__name # zhuge = Srudent('诸葛',20) # print(zhuge.name()) # print(zhuge.age) # zhuge.age = 'aaaa' # print(zhuge.age) # class Goods: # __discount = 0.7 # 私有的静态变量 # def __init__(self,name,price): # self.name = name # self.__price = price # # def price(self): # return self.__price * Goods.__discount # # def change_price(self,new_price): # if type(new_price) is int: # self.__price = new_price # else: # print('本次价格修改不成功') # # apple = Goods('APPLE',5) # print(apple.price()) # apple.change_price('aaaa') # print(apple.price()) # # class User: # def __init__(self,username,password): # self.usr = username # self.__pwd = password # self.pwd = self.__getpwd() # # def __getpwd(self): # return hash(self.__pwd) # # obj = User('alex','alex3714') # print(obj.usr,obj.pwd) # 类中的私有成员： # 私有的静态属性 # 私有的对象属性 # 私有的方法 # 我为什么要定义一个私有变量呢： # 我不想让你看到这个值 # 我不想让你修改这个值 # 我想让你在修改这个值得时候有一些限制 # 有些方法或者属性不希望被子类继承 # 私有变量能不能在外部被定义？？？ # class A : # __country = 'China' # 在类的内部会发生变形 # print(__country) # '_A__country' # print(A.__dict__) # A.__Language = 'Chinese' # print(A.__dict__) # 私有变量能不能被继承？？？ # class A: # __country = 'China' # def __init__(self,name): # self.__name = name # '_A__name' # # class B(A): # # print(__country) # # NameError: name '_B__country' is not defined # def get_name(self): # return self.__name # '_B__name' # # b = B('alex') # print(b.__dict__) # 广义上的封装 把属性函数都放到类里 # 狭义上的封装 定义私有成员 # 类中的私有成员： # 私有的静态属性 # 私有的对象属性 # 私有的方法 # 我为什么要定义一个私有变量呢： # 我不想让你看到这个值 # 我不想让你修改这个值 # 我想让你在修改这个值得时候有一些限制 ： 保证了数据的安全 # 有些方法或者属性不希望被子类继承
面向对象练习题：
# 1. 简述编写类和执行类中的方法流程 class Bar: pass obj = Bar() class Foo: def __init__(self, name): # 构造方法: 完成对象内容的初始化 self.name = name self.age = 233 obj = Foo('Canaan') # 2. 简述面向对象的三大特性 # 封装(属性和方法)——将相关的功能(类的方法)和共同的参数(类的属性)封装到一个类中 # 继承(为了提高代码的重用性) # 多态 # 3. 改写函数方法 def func(a1): print(a1) class Function: def __init__(self, a1): self.a1 = a1 def func(self): print(self.a1) obj = Function(a1) obj.func() # 4. 方法和函数的区别？ # (定义)类中的是方法，(执行)必须先实例化对象，再通过对象去调用，(传参)python会默认传一个self(实例化对象本身)参数 # 函数 # 5. 什么是构造方法 class Foo: def __init__(self, name): self.name = name # 6. self只的是一个实例的对象本身 # 7. 以下代码的结果 class Foo: def func(self): print("foo.func") obj = Foo() result = obj.func() # foo.func print(result) # None(方法没有返回值，默认返回None) # 8. 定义一个类，其中有计算周长和面积的方法(圆的半径通过参数传递到构造方法) import math class Circle: # 接收参数初始化一个对象，构造方法封装的值不一定需要参数传递 def __init__(self, r): self.r = r # 计算周常 def girth(self): return 2 * math.pi * self.r # 计算面积 def area(self): return math.pi * self.r * self.r # 9. 面向对象为什么要有继承？ # 提高代码的复用性，如果两个类有重复的属性和方法，就放到基类里 # 10. python多继承时，查找成员的顺序是什么规则？ # 先找自己，没有从左往右找父类 # 11. 查看代码写结果 class Base1: def f1(self): print("Base1.f1") def f2(self): print("Base1.f2") def f3(self): print("Base1.f3") # Base1.f3 self.f1() # Base1.f1 class Base2: def f1(self): print("Base2.f1") class Foo(Base1, Base2): def f0(self): print("foo.f0") self.f3 obj = Foo() obj.f0() # foo.f0 class Base: def f1(self): print("base.f1") def f3(self): print("base.f3") class Foo(Base): def f1(self): print("foo.f1") def f2(self): print("foo.f2") obj = Base() obj.f2() # 报错(父类不能调用子类的方法)
# 15. 补充代码实现 class UserInfo: def __init__(self, user, pwd, email): self.user = user self.pwd = pwd self.email = email user_list = [] while True: user = input("请输入用户名： ") pwd = input("请输入密码： ") email = input("请输入邮箱： ") user_obj = UserInfo(user, pwd, email) user_list.append(user_obj) if len(user_list) > 2: break for item in user_list: s = "我叫{name}, 邮箱是{email}".format(name=item.user, email=item.email) print(s)
# 16. 补充代码实现：用户注册和用户登录 class User: def __init__(self, name, pwd): self.name = name self.pwd = pwd class Account: def __init__(self): self.user_list = [] # 用户列表，数据格式: [User对象, User对象, User对象] def login(self): # 用户登录，用户输入用户名和密码并去user_list中检查是否合法 i = 3 user = input("请输入用户名: ") pwd = input("请输入密码: ") flag = False for item in self.user_list: if user == item.name and pwd == item.pwd: flag = True break if flag == True: print("登录成功") else: print("登录失败") def register(self): # 用户注册，动态的创建User对象，并添加到user_list中 i = 0 while i < 3: i = i + 1 user = input("请输入用户名: ") pwd = input("请出入密码: ") user_obj = User(user, pwd) self.user_list.append(user_obj) def run(self): # 主程序，进行两次用户注册，再执行用户登录(3次重试机会) self.register() self.login() if __name__ == "__main__": obj = Account() obj.run()
面向对象作业：
# 1. 类变量（静态属性）和实例变量（对象属性）的区别？ # 2. super的作用？在子类中调用父类的方法 # 一般情况下 子类中有和父类相同的方法名 # 3. isinstance和type的区别并用代码举例说明？ # isinstance能判断对象与类之间的继承关系 # type只能判断这个对象是哪个类创建出来的 # 4. 补全代码 # ``` python # def func(arg): # """ # 判断arg是否可以被调用，如果可以则执行并打印其返回值，否则直接打印结果 # :param arg: 传入的参数 # """ # pass # def func(arg): # """ # 判断arg是否可以被调用，如果可以则执行并打印其返回值，否则直接打印结果 # :param arg: 传入的参数 # """ # 5. 补全代码 # ``` python # def func(*args): # """ # 计算args中函数、方法、Foo类的对象的个数，并返回给调用者。 # :param args: 传入的参数 # """ # # 6. 看代码写结果并画图表示对象和类的关系以及执行流程 # ``` python # class StarkConfig(object): # list_display = [] # # def get_list_display(self): # self.list_display.insert(0,33) # return self.list_display # # class RoleConfig(StarkConfig): # list_display = [11,22] # # s1 = StarkConfig() # s2 = StarkConfig() # # result1 = s1.get_list_display() # print(result1) # # result2 = s2.get_list_display() # print(result2) # ``` # 7. 看代码写结果并画图表示对象和类的关系以及执行流程 # ``` python class StarkConfig(object): list_display = [] def get_list_display(self): self.list_display.insert(0,33) return self.list_display class RoleConfig(StarkConfig): list_display = [11,22] s1 = StarkConfig() s2 = RoleConfig() result1 = s1.get_list_display() print(result1) result2 = s2.get_list_display() print(result2) # ``` # 8. 看代码写结果并画图表示对象和类的关系以及执行流程 # ```python # class StarkConfig(object): # list_display = [] # # def get_list_display(self): # self.list_display.insert(0,33) # return self.list_display # # class RoleConfig(StarkConfig): # list_display = [11,22] # # s1 = RoleConfig() # s2 = RoleConfig() # # result1 = s1.get_list_display() # print(result1) # # result2 = s2.get_list_display() # print(result2) # ``` # 9. 看代码写结果 # ```python # class Base(object): # pass # # class Foo(Base): # pass # # print(issubclass(Base, Foo)) 作业
6题
# 1,完成下列功能: # 1.1创建一个人类Person,再类中创建3个静态变量(静态字段) # animal = '高级动物' # soul = '有灵魂' # language = '语言' # 1.2在类中定义三个方法,吃饭,睡觉,工作. # 1.3在此类中的__init__方法中,给对象封装5个属性:国家,姓名,性别,年龄, 身高. # 1.4实例化四个人类对象: # 第一个人类对象p1属性为:中国,alex,未知,42,175. # 第二个人类对象p2属性为:美国,武大,男,35,160. # 第三个人类对象p3属性为:你自己定义. # 第四个人类对象p4属性为:p1的国籍,p2的名字,p3的性别,p2的年龄,p3 的身高. # 1.5 通过p1对象执行吃饭方法,方法里面打印:alex在吃饭. # 1.6 通过p2对象执行吃饭方法,方法里面打印:武大在吃饭. # 1.7 通过p3对象执行吃饭方法,方法里面打印:(p3对象自己的名字)在吃饭. # 1.8 通过p1对象找到Person的静态变量 animal # 1.9 通过p2对象找到Person的静态变量 soul # 2.0 通过p3对象找到Person的静态变量 language # class Person: # animal = '高级动物' # soul = '有灵魂' # language = '语言' # def __init__(self,country,name,sex,age,height): # self.country = country # self.name = name # self.age = age # self.sex = sex # self.height = height # def eat(self): # print('%s吃饭' %self.name) # def sleep(self): # print('睡觉') # def work(self): # print('工作') # p1 = Person('中国','alex','未知',42,175) # p2 = Person('美国','武大','男',35,140) # p3 = Person('日本','西门','男',20,180) # p4 = Person(p1.country,p2.name,'男',20,180) # p1.eat() # p2.eat() # p3.eat() # 2,通过自己创建类,实例化对象 # 在终端输出如下信息 # 小明，10岁，男，上山去砍柴 # 小明，10岁，男，开车去东北 # 小明，10岁，男，最爱大保健 # 老李，90岁，男，上山去砍柴 # 老李，90岁，男，开车去东北 # 老李，90岁，男，最爱大保健 # 老张… # class Daylife: # def __init__(self,name,sex,age): # # self.name = name # self.age = age # self.sex = sex # # def chop_wood(self): # print('%s,%s,%s,上山去砍柴' %(self.name,self.age,self.sex)) # def drive(self): # print('%s,%s,%s,开车去东北' %(self.name,self.age,self.sex)) # def health_care(self): # print('%s,%s,%s,最爱大保健' % (self.name, self.age, self.sex)) # # p1 = Daylife('小明','男',10) # p1.chop_wood() # p1.drive() # p1.health_care() # 3,模拟英雄联盟写一个游戏人物的类（升级题）. # 要求: # (1)创建一个 Game_role的类. # (2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性. # (3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能: # 例: 实例化一个对象 盖伦,ad为10, hp为100 # 实例化另个一个对象 剑豪 ad为20, hp为80 # 盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血, 还剩多少血'的提示功能. # # # 4,默写内容: # 创建一个人类,定义三个静态变量,在构造方法中封装3个属性.然后实例化一个对象,对象调用自己的属性,对象调用类的静态方法,对象调用类中的方法. # 默写一下实例化一个对象，具体经历了哪些阶段。 #
# 1,完成下列功能: # 1.1创建一个人类Person,再类中创建3个静态变量(静态字段) # animal = '高级动物' # soul = '有灵魂' # language = '语言' # class Person: # animal ='高级动物' # soul = '有灵魂' # language = '语言' # 1.2在类中定义三个方法,吃饭,睡觉,工作. # class Person: # animal ='高级动物' # soul = '有灵魂' # language = '语言' # # def chi(self): # pass # def sellp(self): # pass # def working(self): # pass # 1.3在此类中的__init__方法中,给对象封装5个属性:国家,姓名,性别,年龄, 身高. # class Person: # animal = '高级动物' # soul = '有灵魂' # language = '语言' # def __init__(self,gj,name,sex,age,height): # self.gj1 = gj # self.name1 = name # self.sex1 = sex # self.age1 = age # self.height1 = height # # def chi(self): # pass # # def sellp(self): # pass # # def working(self): # pass # 1.4实例化四个人类对象: # 第一个人类对象p1属性为:中国,alex,未知,42,175. # 第二个人类对象p2属性为:美国,武大,男,35,160. # 第三个人类对象p3属性为:你自己定义. # 第四个人类对象p4属性为:p1的国籍,p2的名字,p3的性别,p2的年龄,p3 的身高. # class Person: # animal = '高级动物' # soul = '有灵魂' # language = '语言' # def __init__(self,gj,name,sex,age,height): # self.gj1 = gj # self.name1 = name # self.sex1 = sex # self.age1 = age # self.height1 = height # # def chi(self): # pass # # def sellp(self): # pass # # def working(self): # pass # p1 = Person('中国','alex','未知',42,175) # print(p1.__dict__) # p2 = Person('美国','武大','男',35,160) # print(p2.__dict__) # p3 = Person('亚洲','帅哥','男',37,187) # print(p3.__dict__) # p4 = Person(p1.__dict__['gj1'],p2.__dict__['name1'],p3.__dict__['sex1'],p2.__dict__['age1'],p3.__dict__['height1']) # print(p4.__dict__) # 1.5 通过p1对象执行吃饭方法,方法里面打印:alex在吃饭. # 1.6 通过p2对象执行吃饭方法,方法里面打印:武大在吃饭. # 1.7 通过p3对象执行吃饭方法,方法里面打印:(p3对象自己的名字)在吃饭. # 1.8 通过p1对象找到Person的静态变量 animal # 1.9 通过p2对象找到Person的静态变量 soul # 2.0 通过p3对象找到Person的静态变量 language class Person: animal = '高级动物' soul = '有灵魂' language = '语言' def __init__(self,gj,name,sex,age,height): self.gj1 = gj self.name1 = name self.sex1 = sex self.age1 = age self.height1 = height def chi(self): return '%s在吃饭' %(self.name1) def sellp(self): pass def working(self): pass p1 = Person('中国','alex','未知',42,175) print(p1.chi()) p2 = Person('美国','武大','男',35,160) print(p2.chi()) p3 = Person('亚洲','帅哥','男',37,187) print(p3.chi()) print(p1.animal) print(p2.soul) print(p3.language) # class Person: # animal = '高级动物' # soul = '有灵魂' # language = '语言' # def __init__(self,country,name,sex,age,height): # self.country = country # self.name = name # self.age = age # self.sex = sex # self.height = height # def eat(self): # print('%s吃饭' %self.name) # def sleep(self): # print('睡觉') # def work(self): # print('工作') # p1 = Person('中国','alex','未知',42,175) # p2 = Person('美国','武大','男',35,140) # p3 = Person('日本','西门','男',20,180) # p4 = Person(p1.country,p2.name,'男',20,180) # p1.eat() # p2.eat() # p3.eat() # 2,通过自己创建类,实例化对象 # 在终端输出如下信息 # 小明，10岁，男，上山去砍柴 # 小明，10岁，男，开车去东北 # 小明，10岁，男，最爱大保健 # 老李，90岁，男，上山去砍柴 # 老李，90岁，男，开车去东北 # 老李，90岁，男，最爱大保健 # 老张… # class Daylife: # def __init__(self,name,sex,age): # # self.name = name # self.age = age # self.sex = sex # # def chop_wood(self): # print('%s,%s,%s,上山去砍柴' %(self.name,self.age,self.sex)) # def drive(self): # print('%s,%s,%s,开车去东北' %(self.name,self.age,self.sex)) # def health_care(self): # print('%s,%s,%s,最爱大保健' % (self.name, self.age, self.sex)) # # p1 = Daylife('小明','男',10) # p1.chop_wood() # p1.drive() # p1.health_care() # 3,模拟英雄联盟写一个游戏人物的类（升级题）. # 要求: # (1)创建一个 Game_role的类. # (2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性. # (3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能: # 例: 实例化一个对象 盖伦,ad为10, hp为100 # 实例化另个一个对象 剑豪 ad为20, hp为80 # 盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血, 还剩多少血'的提示功能. # class Game_role: # # def __init__(self,name,ad,hp): # self.name = name # self.ad = ad # self.hp = hp # def attack(self,vicitm): # vicitm.hp = vicitm.hp - self.ad # print( "%s攻击%s,%s掉了%s血,还剩%s血" % (self.name, vicitm.name, vicitm.name, self.ad, vicitm.hp)) # p1 = Game_role("盖伦",10,100) # p2 = Game_role('剑豪',20,80) # # p1.attack(p2) # print(p2.hp) # # 4,默写内容: # 创建一个人类,定义三个静态变量,在构造方法中封装3个属性.然后实例化一个对象,对象调用自己的属性,对象调用类的静态方法,对象调用类中的方法. # 默写一下实例化一个对象，具体经历了哪些阶段。 #
# # 1简述编写类和执行类中方法的流程。 # # # 2简述面向对象三大特性? # # # 3将以下函数改成类的方式并调用 : # # def func(a1): # # print(a1) # # # 4面向对象中的self指的是什么? # # # # 5以下代码体现 面向对象的什么特点? # # class Person: # # def __init__(self,name,age,gender): # # self.name = name # # self.age = age # # self.gender = gender # # obj = Person('王五',18,'男') # # # # 6以下代码体现 面向对象的什么特点? # # class Message: # # def email(self): # # """ # # 发送邮件 # # :return: # # """ # # pass # # def mag(self): # # """ # # 发送短信 # # :return: # # """ # # pass # # def wechat(self): # # """ # # 发送微信 # # :return: # # """ # # pass # # 7看代码写结果 # # class Foo: # # def func(self): # # print('foo.func') # # obj = Foo() # # result = obj.func() # # print(result) # # 8定义个类，其中有计算圆周长和面积的方法(圆的半径通过参数传递到初始化方法)。 # # # 9面向对象中为什么要有继承? # 10Python继承时，查找成员的顺序遵循什么规则? # 11看代码写结果 # class Base1: # def f1(self): # print('base1.f1') # # def f2(self): # print('base1.f2') # # def f3(self): # print('base1.f3') # self.f1() # # # class Base2: # def f1(self): # print('base2.f1') # # # class Foo(Base1, Base2): # def f0(self): # print('foo.f0') # self.f3() # # # obj = Foo() # obj.f0() # # 12看代码写结果: # class Base: # def f1(self): # print('base.f1') # # def f3(self): # self.f1() # print('base.f3') # # # class Foo(Base): # def f1(self): # print('foo.f1') # # def f2(self): # print('foo.f2') # self.f3() # # # obj = Foo() # obj.f2() # # # 13 .补充代码实现 # user_list = [] # while True: # user = input(“请输入用户名:”) # pwd = input(“请输入密码:”) # email = input(“请输入邮箱:”) # # """ # # 需求 # 1. while循环提示 户输 : 户名、密码、邮箱(正则满 邮箱格式) # 2. 为每个 户创建 个对象，并添加到 表中。 # 3. 当 表中的添加 3个对象后，跳出循环并以此循环打印所有 户的姓名和邮箱 # """ # 14补充代码:实现用户注册和登录。 # # # class User: # def __init__(self, name, pwd): # self.name = name # self.pwd = pwd # # # class Account: # def __init__(self): # # 用户列表，数据格式：[user对象，user对象，user对象] # self.user_list = [] # # def login(self): # """ # 用户登录，输入用户名和密码然后去self.user_list中校验用户合法性 # :return: # """ # pass # # def register(self): # """ # 用户注册，没注册一个用户就创建一个user对象，然后添加到self.user_list中，表示注册成功。 # :return: # """ # pass # # def run(self): # """ # 主程序 # :return: # """ # pass # # # if __name__ == '__main__': # obj = Account() # obj.run() # # # # # # # # # # # # # # # # # # # # # # # #
ps:部分内容来自于互联网整理，如有侵权请联系我们，我们会在看到通知后24小时内做出处理。
posted on
浙公网安备 33010602011771号