day19 요약

범주

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

    缺点:
        可扩展性差。

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

    优点:
        可扩展性高。

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

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

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

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

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

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

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

    如何定义类：
        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)

# 以上是类的操作。

사물

객체를 생성하는 방법 :
구문 :
클래스 이름 + ()이 호출은 객체 클래스를 생성합니다.

생산 네임 스페이스 :
클래스 정의 위상 공간에서 클래스의 이름이 작성하십시오.
호출 클래스의 결과 오브젝트 공간의 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')

파이썬 객체의 모든 것

INT는, 플로트, STR,리스트, 터플, 딕셔너리는, 설정, 파이썬 모두에서 부울 객체입니다.

# 定义一个列表
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. 모든 클래스는 내부 이름, 네임 스페이스는 클래스에 던져 질 것입니다.
참고 : 클래스 정의 단계가 좋은 이름 공간을 생산하고있다 파이썬 파일을 실행할 때, 클래스 내부의 코드를 실행합니다.

3
일 (******)를 호출 클래스가 발생합니다 :
1. 먼저 null 객체가하는 것입니다 생산합니다 "이름 공간 개체를."
2. 자동으로 __init__ 트리거합니다.
3. 객체 자체 것이며, 괄호 내의 파라미터 함께 __init__ 함수를 전달.
요약 : 클래스라는 프로 시저 호출 클래스의 객체 인스턴스를 생성하는 클래스를 호출은 결과 객체, 클래스가 인스턴스화라고합니다.

4 :
초기화 : 자동 기능을 트리거하는 클래스를 호출합니다.

5
. 1. 클래스의 내부 클래스 함수 호출하지만, 보통의 함수 호출을
특수에 대한 제 1 항에있어서, 객체 (*******)를 바인딩 :

객체 호출 메서드로 전달되는 첫 번째 인수로 객체 것
, 그것이 다른 결합 방법으로 서로 다른 객체를 호출하는 객체를 둘 것이다.