day19总结

其他 2019-10-09 15:41:13 阅读次数: 0

目录

类

面向过程编程:
    核心是“过程”二字，过程指的是做事情的步骤，即先做什么再做什么
    基于该编程思想编写程序，就好比一条工厂流水线，一种机械式的思维方式。
    优点:
        逻辑清晰，复杂的问题流程化，进而简单化。

    缺点:
        可扩展性差。

面向对象编程:
    核心是“对象”二字，对象指的是特征与技能的结合体。
    基于该编程思想编写程序，就好比在创造世界，一种上帝式的思维方式。

    优点:
        可扩展性高。

    缺点:
        编写程序的复杂程度要远高于面向过程编程思想。

优先使用面向过程还是面向对象？
    面向过程结合面向对象一起使用。
    # 选课系统项目。

如何造对象？首先需要学习类。

什么是类?
    类型、类别、分类。

    先定义类，后调用类产生对象。

    - 在现实世界中:
        对象是一个个具体存在的事物，类是由人类文明的发展抽象总结出来的。

    - 在程序中:
        必须遵循，先有类，再有对象。

    如何定义类：
        1.先从现实世界中，基于一个个的对象，抽取出类。
        2.再定义类。

    类: 对象是特征与技能的结合体，类是一系列对象相同的特征与技能的结合体。
类:
    对象是特征与技能的结合体，类是一系列对象相同的特征与技能的结合体。

如何定义类:
    首定义类，后调用类创造对象。

定义类的语法:
    def 函数名():

    class 类名:
        对象相同的特征
        对象相同的技能

    class: 用来定义类的，class后跟的是类名。
    类名: 类的名字，用来调用创造对象的。

    注意: 类名必须要遵循驼峰命名法，python在定义变量与函数时不推荐使用，但在定义类时推荐使用。

    在定义类发生的事情:
        1.类在定义时，会产生一个空的名称空间。
        2.会把类内部所有名字，扔进类的名称空间中。
        注意: 类在定义阶段就已经产生好了名称空间，执行python文件时会执行类内部的代码。


学生类:
    相同特征 --> 类内部的变量
        school

    相同技能 --> 类内部的函数
        learn
        choose_course
# # 学生类
# class OldboyStudent:
#     # 特征
#     school = 'oldboy'
#     print('tank is handsome...')
#
#     # 技能
#     def learn(self):
#         print('learn python...')
#
#     def choose_course(self):  # self = None
#         print('choose_course ....')


# OldboyStudent ---> 会指向类的名称空间
# print(OldboyStudent.__dict__)  # 查看类的名称空间内所有名字
# print(OldboyStudent.__dict__.get('school'))  # oldboy

# 查
# print(OldboyStudent.__dict__.get('school'))

# 改
# OldboyStudent.__dict__['school'] = 'oldgirl'
# print(OldboyStudent.__dict__.get('school'))

# 增
# OldboyStudent.__dict__['address'] = 'SH'
# print(OldboyStudent.__dict__['address'])

# 删
# del OldboyStudent.__dict__['school']
# print(OldboyStudent.__dict__['school'])


'''
类.特征或技能的方式对类内部的名字进行修改。
"."会指向类内部的名称空间，从而获取名字。
'''
# 查
# print(OldboyStudent.school)  # oldboy

# 改
# OldboyStudent.school = 'oldgirl'
# print(OldboyStudent.school)

# 增
# print(OldboyStudent.address)  # 报错，特征也称之为属性
# OldboyStudent.address = '上海'
# print(OldboyStudent.address)

# 删
# del OldboyStudent.address
# print(OldboyStudent.address)

# OldboyStudent.choose_course(123)

# 以上是类的操作。

对象

如何产生对象：
语法:
类名 + () 调用类产生对象。

名称空间的产生:
1.类的名称空间在类定义阶段就已经产生了。
2.对象的名称空间，在调用类时产生。

 # 学生类
# class OldboyStudent:
#     # 特征
#     school = 'oldboy'
#     print('tank is handsome...')
#
#     # 技能
#     def learn(self):
#         print('learn python...')
#
#     def choose_course(self):  # self = None
#         print('choose_course ....')
# stu1 = OldboyStudent()  # OldboyStudent()---> 学生对象
# stu2 = OldboyStudent()  # OldboyStudent()---> 学生对象
# stu3 = OldboyStudent()  # OldboyStudent()---> 学生对象
# # print(stu1, stu2, stu3)
# print('stu1', stu1.school)
# stu1.learn()
# stu1.choose_course()
# print('stu2', stu2.school)
# stu2.learn()
# stu2.choose_course()
# print('stu3', stu3.school)
# stu3.learn()
# stu3.choose_course()




# 问题： 对象与对象之间的特征与技能一样。
'''
# 解决: 在类内部定义__init__函数。

# 中文翻译: 为对象初始化某些属性。
__init__: 会在调用类时，自动触发该函数。
'''


# 学生类
class OldboyStudent:
    # 若__init__中有self以外的参数，调用类时必须在括号内传入参数。
    def __init__(self, x, y, z):  # self --> 就是对象本身  x = 高峰峰  y=93   z=female
        # print(self, x, y, z)
        # print('此处时__init__。。。。')
        # 给对象添加特征的方式二：
        self.name = x
        self.age = y
        self.sex = z

    # 特征
    school = 'oldboy'
    # print('tank is handsome...')

    # 技能
    def learn(self):
        print('learn python...')

    def choose_course(self):  # self = None
        print('choose_course ....')


stu1 = OldboyStudent('高峰峰', 93, 'female')  # OldboyStudent()---> 学生对象
stu2 = OldboyStudent('小丁丁', 84, 'female')  # OldboyStudent()---> 学生对象
stu3 = OldboyStudent('大丁丁', 18, 'male')  # OldboyStudent()---> 学生对象

# print(stu1)
# print(stu2)
# print(stu3)

# 给对象添加属性的方式一:
# print(stu1.name)
# stu1.name = '高峰峰'
# stu1.age = 93
# stu1.sex = 'female'
# print(stu1.name, stu1.age, stu1.sex)

调用类发生的事情:
1.首先会产生一个空的对象，就是产生“对象的名称空间”。
2.会自动触发__init__。
3.会把对象本身以及括号内的参数一并传给__init__函数。
总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例.

# 查看类的名称空间
# print(OldboyStudent.__dict__)

# 查看对象的名称空间
# print(stu1.__dict__)
print(stu1.name, stu1.school)

对象与类的查找顺序

class OldboyStudent:
    SCHOOL = 'oldboy'
    NAME = 'DDDDDDDD'

    def __init__(self, name, age, sex, school):
        self.name = name
        self.age = age
        self.sex = sex
        self.SCHOOL = school


stu1 = OldboyStudent('小正正', 17, 'male', 'oldgirl')
print(stu1.SCHOOL)


'''
对象与类的查找顺序:
    1.对象.属性，若对象本身有，则优先查找对象自己的。
    2.若对象本身没有，则去类里面找，若类没有，则报错。
'''

# print(stu1.NAME)
# print(stu1.AGE)
# print(OldboyStudent.AGE)

对象绑定方法的特殊之处

类内部的函数主要是给对象用的:
1.由类来调用类内部的函数，该函数只是一个普通的函数，
普通函数需要接收几个参数就得传入几个参数。

2.由对象来调用称之为对象的绑定方法,
不同的对象调用该绑定方法,则会将不同的对象传入该绑定方法中.

​ 对象的绑定方法,是由对象来调用的,
​ 特殊之处就是把对象当作第一个参数传入该方法中.

class OldboyStudent:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    # 特征
    school = 'oldboy'
    # 技能
    def learn(self):  # 普通函数
        # print('stu:', self)
        print('learn python...')

    def choose_course(self, course):  # self =
        print(f'[{self.name}]choose_course {course} ....')

# print(OldboyStudent.learn)  # function
# OldboyStudent.learn(123)


stu1 = OldboyStudent('高凤凤1', 73, 'female')
stu2 = OldboyStudent('高凤凤2', 84, 'male')

# 对象之间与类的方法功能是一样的
# OldboyStudent.learn(123)
# stu1.learn()
# print(OldboyStudent.learn)
# print(stu1.learn)
# print(stu2.learn)

stu1.choose_course('python')  # choose_course(self, 'python')
stu2.choose_course('linux')  # choose_course(self, 'python')

python中一切皆对象

int,float,str,list,tuple,dict,set,bool在python中一切皆对象.

# 定义一个列表
list1 = [1, 2, 3]  # list([1, 2, 3])
print(list1)  # [1, 2, 3]
print(id(list1))  # 2738050243464
print(type(list1))  # <class 'list'>


# print(list)
# list1.append(1)


class Foo:
    def append(self, x):
        print(x)
        pass


# print(Foo)
# obj = Foo()
# obj.append(1)

f = float()
s1 = str()
l = list()
t = tuple()
d = dict()
s2 = set()
b = bool()

print(type(f))
print(type(s1))
print(type(l))
print(type(t))
print(type(d))
print(type(s2))
print(type(b))
# print(filter)
# print(map)

人狗大作战

'''
需求:
    人对象
    狗对象
    人狗互咬,直到一方生命值为0,则程序结束.

定义两个类:
    人类
    狗类
'''


# 在现实世界中
'''
对象人1:
    特征:
        name = '高冯冯'
        aggr = 100
        life = 500
    
    技能:
         咬狗
         def bite()
对象人2:
    特征:
        name = '小丁丁'
        aggr = 200
        life = 1000
    
    技能:
         咬狗
         def bite()
         
    相同特征:
        
    相同技能:
        bite
         
         
对象狗1:
    特征:
        name = 'nick'
        dog_type = '哈士奇'
        aggr = 200
        life = 300
    
    技能:
        咬人
        bite
        
对象狗2:
    特征:
        name = 'jason'
        dog_type = '泰日天'
        aggr = 500
        life = 100
    
    技能:
        咬人
        bite    
        
        
    相同特征:
    相同技能:
        bite
'''

class People:
    def __init__(self, name, aggr, life):
        # 对象特有的特征
        self.name = name
        self.aggr = aggr
        self.life = life

    # 人咬狗方法
    def bite(self, dog):
        if dog.life <= 0:
            return True

        if self.life:
            # 狗掉血
            dog.life -= self.aggr
            print(
                f'''
                人: [{self.name}]开始咬狗:[{dog.name}]
                狗掉血: [{self.aggr}] 
                狗还剩血量: [{dog.life}]
                ''')


class Dog:
    def __init__(self, name, dog_type, aggr, life):
        self.name = name
        self.dog_type = dog_type
        self.aggr = aggr
        self.life = life

    # 狗咬人方法
    def bite(self, people):
        if people.life <= 0:
            return True

        if self.life:
            # 人掉血
            people.life -= self.aggr

            print(
                f'''
                狗: [{self.name}]开始咬人:[{people.name}]
                人掉血: [{self.aggr}] 
                人还剩血量: [{people.life}]
                ''')


p1 = People('egon', 200, 1000)
d1 = Dog('nick', '哈士奇', 500, 400)

while True:

    flag1 = p1.bite(d1)

    # print(flag1)
    if flag1:
        break

    flag2 = d1.bite(p1)
    if flag2:
        break

1:
面向过程编程:
核心是“过程”二字，过程指的是做事情的步骤，即先做什么再做什么
基于该编程思想编写程序，就好比一条工厂流水线，一种机械式的思 维方式。
优点:逻辑清晰，复杂的问题流程化，进而简单化。
缺点:可扩展性差。
面向对象编程:
核心是“对象”二字，对象指的是特征与技能的结合体。
基于该编程思想编写程序，就好比在创造世界，一种上帝式的思维方式。
优点:可扩展性高。
缺点:编写程序的复杂程度要远高于面向过程编程思想。

2:
在定义类发生的事情:
1.类在定义时，会产生一个空的名称空间。
2.会把类内部所有名字，扔进类的名称空间中。
注意: 类在定义阶段就已经产生好了名称空间，执行python文件时会执行类内部的代码。

3:
调用类发生的事情(******):
1.首先会产生一个空的对象，就是产生“对象的名称空间”。
2.会自动触发__init__。
3.会把对象本身以及括号内的参数一并传给__init__函数。
总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例.

4:
init: 会在调用类时，自动触发该函数。

5:
1.类调用类内部的函数,只是调用普通函数.
2.对象的绑定方法特殊之处(*******):

由对象来调用的,会把对象当作第一个参数传入该方法中
同的对象来调用,就会把不同的对象传给不同的绑定方法.

猜你喜欢

转载自www.cnblogs.com/zhm-cyt/p/11642127.html
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022