小结
- 面向对象和面向编程
概念：
面向过程
优点：复杂问题流程化，进而简单化
缺点：可拓展性差
面向对象
优点：可拓展性高
缺点：编写复杂
- 类与对象
定义类
class关键字 类名：
pass
产生对象
对象=类名（）
-类：
-
获取类的属性和方法
类 ._ _ dict_ _
-
类的调用属性和方法
1.通过dict来取（复杂，不用）
2.类名 . 属性/函数
-对象：
-
对象获取属性和方法
对象 . _ _ dict _ _
2. 对象来调取属性和方法 对象 . 属性/方法
3 产生对象（绑定方法，属性的查找顺序）
-属性查找属性
-先从对象自身找--------->类中找--------->报错
-对象赋属性
-方式一：
stu1=student()
sru1.name='nick 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