python27期day19：面向对象

其他 2019-11-09 13:17:30 阅读次数: 0 
class GirlFriend(object):
    #定义女朋友类：
    eyes = 2
    #类属性(静态属性),是属于当前类的
    #当前类的所有对象,所共有的特征
    sex = "女"
    """
    说明
    """
    #初始化方法
    def __init__(self,name,age,height,weight):
        #实例属性
        self.name = "qwe"
        self.age = age
        self.height = height
        self.weight = weight
        #函数属性
    def xiyifu(self):
        #定义洗衣服功能：
        print(self.name,"洗衣服")
    def chuitu(self):
        #定义捶腿功能：
        print("捶腿")
    def tiwolianji(self):
        #定义替我联机功能：
        print("打怪升级")

#调用类属性,需要使用类名去调用(对象名也可以调用,但是不建议)
# print(GirlFriend.name)

#类名不能调用实例属性,也不要去调用实例方法
print(GirlFriend.eyes)

#可以在对象创建时,就让他拥有不同的属性值
girl_1 = GirlFriend("迪丽热巴",18,170,170)
#通过对象调用类属性,没问题
#但是不能修改
print(girl_1.eyes)

#如果通过对象去修改类属性,会创建一个新的实例属性,这个实例属性在对象中会覆盖掉类属性
girl_1.eyes = 3
GirlFriend.eyes = 3
print("girl1的",girl_1.eyes)

#实例属性的增加
girl_1.money = 100

#实例属性的删除
del girl_1.name

#实例属性的修改
girl_1.age = 19

#实例属性的查看
print(girl_1.age)

#修改某个对象的实例属性,对当前类的其他对象,没有任何影响
#如果,在类中做了修改,所有对象都会发生改变
girl_1.chuitu()
girl_1.tiwolianji()

# girl_1.name = "迪丽热巴"
#在类的外部,给对象添加属性
# girl_1.money = 100
# print(girl_1.money)

girl_2 = GirlFriend("baby",35,120,250)
print(girl_2.name)
print("girl2的",girl_2.eyes)




#定义天使：
#光圈,翅膀,有眼睛,有腿等等,漂亮,善良,会飞,有法力,能打坏人,能救人,治疗
#类是一个模板(里面放了一些属性和方法)
#对象(也叫当前类的一个实例),是通过类创建出来的,用来完成具体工作

#设计程序的思路:
#首先,根据需求,来设计类,这个过程被称为"抽象",从真实存在的事务当中,抽象出共同的属性和方法





#宝元Alex
# class A:
#     宝元 = {hp:100,atk:200,名字:meet,体重:250,身高:150,工资:100,坐骑:破电动车,年龄:50,性别:男,爱好:洗头}
#     def 宝元技能1():
#         print("电光毒龙钻")
#     def 宝元技能2():
#         print("摸头下蛋")
#
# Alex = {hp:30,atk:1,名字:Alexsb,体重:130,身高:149,工资:20,坐骑:特斯拉,年龄:83,性别:不详,爱好:毒鸡汤}
# def Alex技能1():
#     print("吐口水")






# #类名,大家约定俗成,首字母大写
# class Person:
#     def __init__(self):
#         #放属性
#         self.name = "小明"
#         self.age = 18
#     #方法和属性,只关心完成当前工作所需要的
#     def eat(self):
#         #具体的工作(算法)
#         print("人可以吃东西")
# #self:哪个对象调用了当前方法,self就代表谁
#     def run(self):
#         print(self.name)
#         print("人会跑")
#
# #创建对象(实例化)
# 小明 = Person()
# 小明.run()
# print(小明.name,小明.age)







#
# class Hero:
#     def __init__(self,name,HP,MP,ATK):
#         self.name = name
#         self.hp = HP
#         self.mp = MP
#         self.atk = ATK
#     def jineng1(self):
#         print("电光毒龙钻")
#         self.hp -= 20
#
#     def jineng2(self):
#         print("摸鸡头下蛋")
#
# alex = Hero("alex",100,200,250)
# bigB = Hero("元宝",200,50,300)
# alex.at = 123123123
# del alex.jineng1
# alex.jineng1()
# if alex.hp <= 0:
#     del alex
# alex.atk = 20
# print(alex.name)






# 创建一个英雄类：
# • 包含英雄的各项属性：例如血量魔法值等等（注意哪些应该是类属性，哪些应该作
# 为实例属性）
# • 英雄有自残的能力，自残后会掉血
# class Hero:
#     def __init__(self,hp):
#         self.hp = hp  #血量
#         self.mp = 200 #魔法值
#     def zican(self):
#         print("我钻我自己")
          #自身数量值减1
#         self.hp -= 1






# • 创建一个狗类：
# • 包含名字，颜色，品种，年龄，性别等属性
# • 有一个自我介绍的方法，打印自身的属性信息（我叫XXX。。。）
# • 狗有看家的能力，狗有叫的能力，在看家方法中调用叫的方法
# class Dog:
    #定义狗类：
    # def __init__(self,name,color,type,age,sex):
    #实例化姓名、颜色、品种、年龄、性别
    #     pass
    # def ziwojieshao(self):
    #     print("我叫",self.name,)
#     def kanjia(self):
        #类里面的方法相互调用：
#         self.jiao()
#     def jiao(self):
#         print("汪~汪~")
# douding = Dog()
# douding.kanjia()









num = 0
class Hero:
    num = 0
    def __init__(self):
        self.name = "abc"
        Hero.num += 1   #数量自加1
    def run(self):
        print("会跑")
for i in range(10):
    "循环调用10圈"
    alex = Hero()
bigB = Hero()
a = Hero()
print(Hero.num)









## 面向过程(函数式编程)

通过数学逻辑去解决问题(设计算法,得到想要的结果)

函数式编程:提高了代码的复用性,提高了维护性

## 面向对象

python中 万物皆对象

面向过程,的程序,执行效率高

面向对象,的开发效率高

类:一类具有相同特征的事物的总称

对象:通过类,创建的一个具体事务,用来完成工作

基础数据结构(列表,元组...)是数据的封装,函数是算法的封装

类:是抽象出来的,数据和算法都能封装,可维护性更高,能处理更复杂的问题,代码逻辑更清晰

创建类和对象的格式






```python
#类名,大家约定俗成,首字母大写
class Person:
    def __init__(self):
        #放属性
        self.name = "小明"
        self.age = 18
    #方法和属性,只关心完成当前工作所需要的
    def eat(self):
        #具体的工作(算法)
        print("人可以吃东西")
    def run(self):
        print("人会跑")

#创建对象(实例化)
小明 = Person()
小明.run()
print(小明.name,小明.age)
```





过程描述:

1,抽象

2,通过抽象出的内容来设计类

3,class 类名:

​        属性

​        def __init__(self):

​              self.XXX = XXX

​        方法

​        函数定义一样

4,创建对象:

对象名 = 类名()

5,调用对象的属性和方法使用万能的点.

创建对象时:

1,在内存中开辟一块空间

2,自动调用init方法

#方法和函数究竟有什么区别

class Person:
    def abc(self):
        pass

a = Person()
print(type(a.abc))
print(type(Person.abc))
#通过对象去调用时,是方法
#其他情况,比方说通过类名调用,或者放在类外的时候叫函数

#例一：
class Baooy:
    def __init__(self,name,girlFriend = None):
        self.name = name
        self.girlFriend = girlFriend
    def eat(self):
        if self.girlFriend:
            print(f"{self.name}带着他的女朋友{self.girlFriend}去吃饭")
        else:
            print("单身狗，吃狗粮")
    def movie(self):
        if self.girlFriend:                                                     #加self确认的
            print(f"{self.name}带着他的女朋友{self.girlFriend}去看电影")        #打印时一定加上self
        else:
            print("单身狗，回家看")
a = Baooy("zs","zs1")
a.eat()                     #对象调用函数属性：
a.movie()

#例二：
import random
class Hero:
    def __init__(self,name,hp,atk):
        self.name = name
        self.hp = hp
        self.atk = atk
    def skill(self,tool):
        print(self.name,"对",tool.name,"使出了波动拳")
        tool.hp -= self.atk * random.randint(1,5)/2
class Boss:
    def __init__(self,name,hp,atk):
        self.name = name
        self.hp = hp
        self.atk = atk
    def skill(self,tool):
        print(self.name,"对",tool.name,"使出了独孤九剑")
        tool.hp -= self.atk * random.randint(1,5)/2
bigB = Hero("宝元",200,15)
alex = Boss("alex",150,20)
bigB.skill(alex)
alex.skill(bigB)
while True:
    if bigB.hp <= 0 or alex.hp <= 0:
        print("游戏结束")
        del bigB
        break
    if alex.hp <= 0:
        print("游戏结束")
        del alex
        break




# class Person:
#     def __init__(self,name,age):
#         self.name = name
#         self.hp = 100
#     def play(self,tool):
#         print(self.name,"钻",tool.name)
#         tool.hp -= 20
#         print(tool.name,"还有",tool.hp,"点血")
#     def kanjia(self,tool):
#         tool.kanjia()
# class Dog:
#     def __init__(self,name,hp):
#         self.name = name
#         self.hp = hp
#     def kanjia(self):
#         print("汪~汪~~")
#
# alex = Person("Alex",83)
# bigB = Person("宝元",76)
# alex.play(bigB)
# xiaohei = Dog("小黑",20)
# bigB.kanjia(xiaohei)







#关联关系就是在一个类的方法当中,引入了另一个对象(另一个类的对象)
# 定义一个英雄类和一个反派类
# • 两个类都包含名字、血量，攻击力（ATK），和一个技能（skill）
# • 两派对象互殴
# • 血量为0死亡，删除对象（del 对象名）
import random
class Hero:
    def __init__(self,name,hp,atk):
        self.name = name
        self.hp = hp
        self.atk = atk
    def skill(self,tool):           #tool = alex
        print(self.name,"对",tool.name,"使出了波动拳") #name = 宝元，tool = alex
        tool.hp -= self.atk * random.randint(1,5)/2
class Boss:
    def __init__(self,name,hp,atk):     #name = alex
        self.name = name
        self.hp = hp
        self.atk = atk
    def skill(self,tool):
        print(self.name,"对",tool.name,"使出了独孤九剑")    #name = alex、tool = bigB、tool.name = bigB.name = 宝元
        tool.hp -= self.atk * random.randint(1,5)/2
bigB = Hero("宝元",200,15)
alex = Boss("alex",150,20)
while True:
    bigB.skill(alex)
    alex.skill(bigB)
    if bigB.hp <= 0:
        print("游戏结束")
        del bigB                #删除Hero的实例
        break
    if alex.hp <= 0:
        print("游戏结束")
        del alex                #删除Boss的实例
        break
结果：  宝元 对 alex 使出了波动拳
        alex 对 宝元 使出了独孤九剑
        宝元 对 alex 使出了波动拳
        alex 对 宝元 使出了独孤九剑
        宝元 对 alex 使出了波动拳
        alex 对 宝元 使出了独孤九剑
        宝元 对 alex 使出了波动拳
        alex 对 宝元 使出了独孤九剑
        宝元 对 alex 使出了波动拳
        alex 对 宝元 使出了独孤九剑
        游戏结束








# class Father(object):
#     #在py3中,如果一个类,没有显式的继承任何一个类,那么他默认继承object
#     # def __init__(self,name,age):
#     #     self.name = name
#     #     self.age = age
#     def livelikeyemen(self):
#         print("打妈妈")
# class Son:
#     def __init__(self,f):
#         self.f = f
#     def abc(self):
#         self.f.livelikeyemen()
#     #父类方法重写
#     def livelikeyemen(self):
#         print("打妹妹")
# daming = Father()
# xiaoming = Son(daming)
# xiaoming.abc()





# class Anm(object):
#       """定义动物类"""
#     def __init__(self,name,age):
#       """实例化姓名和年龄"""
#         self.name = name
#         self.age = age
#     def run(self):
#       """定义跑的方法"""
#         print("123")
# class Dog(Anm):
#       """定义狗类继承动物类"""
#     #如果子类也有自己的初始化方法,可能会出错
#     #解决方式,在子类的init方法里面,调用父类的init方法用super（）
#     def __init__(self,name,age):
#         self.xihuanshi = True
#         super().__init__(name,age)
#     def jump(self):
#         print("跳")
#     def run(self):
#         print("abc")
#         """调用动物类的跑方法"""
#         Anm.run(self)
#         """运行动物类的跑方法"""
#         super().run()
# class Cat(Dog):
#       """定义猫类继承狗类"""
#     def __init__(self):
#       """调用狗类里面的init方法用super()"""
#         super().__init__()
#     def jiao(self):
#         print("喵喵~~~")
# a = Dog("动物",20)
# a.run()







class 蛇:
    def __init__(self):
        self.ya = 2
    def panta(self):
        print("pan")
    def run(self):
        print("123")
class 蜘蛛:
    def __init__(self):
        eyes = 8
        jiao = 8
    def 吐丝(self):
        print("cici")
    def run(self):
        print("456")
class 人(蜘蛛,蛇):
    pass
    # def __init__(self, name,age):
    #     self.name = name
    #     self.age = age
    #     super().__init__()
xiaoming = 人()
xiaoming.run()





# 类之间的关系

## 依赖关系：就是将一个类的对象放到另一个类的方法当中就叫依赖

            此时,类之间的关系是最轻的,因为随时可以更换其他对象

## 组合关系：将一个类的对象,放到另一个类的属性中(作为一个组成部分)
class Boy:
    def __init__(self,name,tools = None):
        self.name = name
        self.girl = tools
    def play(self):
        if self.girl:
            print(self.name,"玩",self.girl.name)
        else:
            print("单身狗玩自己吧")
class Girl:
    def __init__(self,name):
        self.name = name
## 继承关系：在不改变现有类的情况下,扩展这个类,子类可以获得父类的所有属性和方法

继承的格式:

class 子类名(父类名):

子类可以定义自己的方法,也可以定义和父类同名的方法(方法重写),这时,子类方法会覆盖掉父类的同名方法

因此,如果子类和父类都拥有自己的初始化方法,需要在子类的初始化方法中调用父类的init方法

调用方式为

```
父类名.__init__(self)
```

如果只是想操作另一个类的对象,用依赖

如果两个类当中存在has a 的关系,用组合

如果是is a 的关系,用继承(尽量少用继承,多用组合)

新式类:继承了object的类,就叫新式类

经典类:没有继承object的类

py3中,所有的类都是新式类

py2中,如果没有显式继承,那么这个类就没有集成任何类,所以有经典类,也有新式类

# class Boy:
#     def __init__(self,name,tools = None):
#         self.name = name
#         self.girl = tools
#     def play(self):
#         if self.girl:
#             print(self.name,"玩",self.girl.name)
#         else:
#             print("单身狗玩自己吧")
#
# class Girl:
#     def __init__(self,name):
#         self.name = name

# class Hero:
#     def __init__(self,wuqi,hujia):
#         self.wuqi = wuqi
#         self.hujia = hujia
#     def skill(self,tool):
#         print(f"用{self.wuqi.name}打{tool.name}")

#组合关系:将一个类的对象,作为另一类的属性

#一对一关系

class Person:
    def __init__(self):
        self.girl = []
    def bamei(self,g1):
        self.girl.append(g1)
    def play(self):
        for i in self.girl:
            print(i.name,end=" ")
            i.play()
class Girl:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def play(self):
        print("陪玩")
girl1 = Girl("小丽",18)
girl2 = Girl("贾玲",30)
girl3 = Girl("韩红",50)
bigB = Person()
bigB.bamei(girl3)
bigB.bamei(girl1)
bigB.play()





# 定义一个用户类,用户名和密码是这个类的属性,实例化两个用户,分别有不同的用户名和密码
        # 登陆成功之后才创建用户对象
        # 设计一个方法 修改密码
#
# class User:
#     def __init__(self,name,pw):
#         self.name = name
#         self.pw = pw
#     def rPassW(self):
#         newPW = input("请输入新密码")
#         self.pw = newPW
#
# num = 0
# while True:
#     userName = input("请输入用户名")
#     userPW = input("请输入密码")
#     if userName == "alex" and userPW == "123123":
#         xiaoming = User("xiaoming","123abc")
#         xiaoli = User("xiaoli","123456")
#         break
#     else:
#         print("输入有误!,请重新输入!")
#         num += 1







# 定义一个列表的操作类：Listinfo
# 包括的方法:
# 1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
# 2 列表元素取值：get_key(num) [num:整数类型]
# 3 列表合并：update_list(list) [list:列表类型]
# 4 删除并且返回最后一个元素：del_key()
# list_info = Listinfo([44,222,111,333,454,'sss','333'])
# class ListInfo:
#     def __init__(self, lis):
#         self.lis = lis
#     def add_Key(self, keyname):
#         self.lis.append(keyname)
#     def get_key(self,num):
#         return self.lis[num]
#     def update_list(self, new_list):
#         self.lis + new_list
#     def del_key(self):
#         return self.lis.pop()








# class A:
#     Country = ['中国']                          # 静态变量/静态属性 存储在类的命名空间里的
#     def __init__(self,name,age,country):        # 绑定方法 存储在类的命名空间里的
#         self.name = name
#         self.age = age
#     def func1(self):
#         print(self)
# a = A('alex',83,'印度')
# b = A('wusir',74,'泰国')
# a.Country[0] = '日本'
# print(a.Country)
# print(b.Country)
# print(A.Country)

猜你喜欢

转载自www.cnblogs.com/zhang-da/p/11825001.html
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022