2019년 8월 26일 학습 내용 및 메모

개요

객체 지향과 객체 지향 프로그래밍
개념 :

프로세스 중심의

장점 : 복잡한 문제의 과정, 그리고 더 단순화
단점 : 가난한 확장 성

객체 지향

장점 : 높은 확장 성

단점 : 쓰기 복잡

클래스와 객체

클래스의 정의

클래스 키워드 클래스 이름 :

패스

제작 객체

개체 클래스 이름 = ()

- 클래스 :

그리고 클래스의 속성 방법을 얻을

클래스 ._ _ dict_ _
클래스의 속성과 메소드를 호출

1. 의해 촬영 딕셔너리 (단지, 아니오)

2. 클래스 속성 / 함수의 이름

- 대상 :

개체 속성과 메소드를 가져옵니다

객체. _ _ DICT _ _
```
2.  对象来调取属性和方法
```
속성 / 메소드 객체

3 (속성의 순서를 찾기 위해, 결합 법) 객체를 생성

- 속성 속성을 찾기

- 객체를 찾기 시작 자체 ---------> 클래스 발견 ---------> 오류

- 개체 속성 푸

- 한 가지 방법 :

stu1 = 학생 ()
sru1.name = '닉 SB'

- 두 번째 방법 :을 통해 _ _init __

- 쓰기 매개 변수의 방법은, 클래스에 정의 된 방법

- 객체의 객체 인스턴스가 생성 될 때, 괄호 안의 값이 전달 될 수있다 패스 _ _ _ init_

- 방법을 바인딩 :

- 클래스 내에 정의

- 객체는 메소드 내부의 객체를 수정할 수 있습니다, 그것은 자동으로 객체를 통해 전달합니다, 호출

'''
对象：属性方法的结合体
类：一系列共同的属性和方法

现实生活中：先有对象再有类
程序中：先有类再有对象
'''

'''
学生1:
    学习：老男孩
    姓名：李铁蛋
    性别：女
    年龄：18
    方法：
        选课
        学习
学生2：
    学习：老男孩
    姓名：Nick
    性别: 男
    年龄：48
    方法：
        选课
        学习  
'''
# 定义类（类型建议用驼峰体命名）
# class关键字 类名：
# class Student:
#     #变量表示属性
#     school = 'oldboy'
#     def choose(self):
#         print("选课")
#     def study(self):
#         print("学习")
# 生成对象  类加括号，生成对象
#stu1=Student()
# 获取对象属性和方法，通过 . 获取
# print(stu1.school) #oldboy
# print(stu1.choose)#<bound method Student.choose of <__main__.Student object at 0x000000000295F0B8>>(内存地址）

#查看类中的属性和函数
#print(Student.__dict__)
# print(Student.__dict__['school'])#oldboy
# print(Student.__dict__['choose'])#<function Student.choose at 0x0000000002996620>
# Student.__dict__['choose'](123)#123代表方法传的参数
# Student.choose(123)##123代表方法传的参数
# print(Student.school)#oldboy

#获取对象的属性和方法
class Student:
    #变量表示属性
    school='oldboy'
    def choose(self):
        print("选课....")
    def study(self):
        print('学习')

#stu1=Student()
# print(stu1.__dict__)#{}
# print(stu1.school)#oldboy
#对象来调用方法，第一个参数不用传
#print(stu1.choose)#<bound method Student.choose of <__main__.Student object at 0x000000000297F080>>

#stu2=Student()
#print(stu2.school)#oldboy
#对象自己属性和方法

# stu1=Student()
# stu1.name='nick'
# stu1.school='新东方'
# print(stu1.name)#nick
# print(stu1.school)#新东方
# print(stu1.__dict__)#{'name': 'nick', 'school': '新东方'}

#属性查找顺序：先从对象自身找----->类中找----->没有就报错
# Student.school='xxx'
# stu1=Student()
# print(stu1.school)#xxx

#向对象中放属性
#第一种方式:
# stu1=Student()
# stu1.name='nick'

#第二种方式：通过__init__方法
class Student:
    #变量表示属性
    school='oldboy'
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("选课....")
    def study(self):
        print("学习")

#产生对象
#stu1=Student()没有参数报错
#stu1=Student('nick')
# print(stu1.name)#nick
#内部帮我们做了一些事 ：当我在实例化产生对象的时候，会自动调用__init__方法，完成对象的初始化
#print(stu1.name)#nick

# stu2=Student('jason')
# print(stu2.name)#jason

def change(obj,name):
    obj.name=name

stu1=Student('xxx')
print(stu1.name)#xxx
Student.__init__(stu1,'nick')
change(stu1,'nick')
print(stu1.name)#nick

stu2=Student('李铁蛋')
print(stu2.name)#李铁蛋

#绑定方法：
#定义在类内部的方法
#如果类来调用：就是一个普通函数，有几个参数就要传几个参数
#对象来调用：它叫对象的绑定方法，第一个参数不需要传，自动传递
class Student:
    #变量表示属性
    school='oldboy'
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("选课")
    def study(self):
        print("%s学会了python"%self.name)
stu1=Student('nick')
stu1.study()#nick学会了python
stu2=Student('李铁蛋')
stu2.study()#李铁蛋学会了python

4 모든 개체

#在Python中，字典，列表字符串...都是对象
# 类即类型（type)
#list=[1,2,3]
#类实例化产生对象
list1=list([1,2,3])
list2=list([5,6,7])
#对象调用对象的绑定方法，修改对象自己
list1.append(5)
print(list1)#[1, 2, 3, 5]

list.append(list1,9)
print(list1)#[1, 2, 3, 5, 9]

class Student:
    #变量表示属性
    school='oldboy'
    def school(self):
        print('选课')
    def study(self):
        print('学习')
a=Student()
print(type(a))#<class '__main__.Student'>

5 작은 실천

사람과 개 총격전

#人狗大战
#定义一个狗类
class Dog:
    type_dog='藏獒'
    def __init__(self,name,aggressivity,hp=100):
        self.name=name
        self.aggressivity=aggressivity
        self.hp=hp
    def bite(self,target):

        target.hp-=self.aggressivity
        print('''
        狗的品种：%s
        %s狗咬了一下%s人，
        人掉血：%s
        人的血剩余：%s'''%(self.type_dog,self.name,target.name,self.aggressivity,target.hp))

#人类
class Human:
    def __init__(self,name,aggressivity,hp=100):
        self.name=name
        self.aggressivity=aggressivity
        self.hp=hp
    def bite(self,target):
        target.hp-=self.aggressivity
        print('''
        %s人咬了一下%s狗，
        狗掉血:%s
        狗的剩余血量：%s'''%(self.name,self.aggressivity,target.hp,target.name))

#实例化产生狗对象
dog=Dog('旺旺财',10,200)
nick=Human('nick',50)

dog.bite(nick)
print(nick.hp)#90

nick.bite(dog)
print(dog.hp)#150

2019년 8월 26일 학습 내용 및 메모

추천