day22 02 面向对象的交互

day22 02 面向对象的交互

一、三种编程方式

1.面向过程编程：核心是过程，流水线式思维

优点：极大降低了写程序的复杂程度，只需要顺着要执行的步骤，堆叠代码即可

缺点：一套流水线或者流程就用来解决一个问题，代码牵一发而动全身

2.面向函数编程：核心是函数

3.面向对象编程：核心是对象，上帝式思维，比较复杂而多的过程用面向对象编程就比较适合

优点：解决了程序的扩展性，对某一个对象单独修改，会立刻反应到整个系统中，修改比较容易

缺点:可控性差，无法像面向过程那样可以很精准的预测问题的处理流程与结果

二、类和对象实例

字典dict----一个类
dict={'k':'v'}----一个对象
list----类
list=[1,2]----对象
print(dict)----类
print(d)----对象

自定义类：类似自定义函数，自定义类也有一个类名，而在类里面是类的各种属性。通过类名可以去操做和查看里面的属性，方式如下：

class 类名:#可有括号也可无
    属性='a'
print(类名.属性)

运行结果：

a

类的调用和传参和一般的函数调用和传参是不同的，下面的方式就是不正确的：

class someone(name,blood,aggr,sex):#这里报错，不接收传的参数，括号不是拿来传参的
    pass
person=someone('王昭君',100,3,'girl')#不能在这里传参数

三、类的调用以及传参的特殊方法

以以下代码为例：

class person:

    country='china'

    def __init__(self,*args):
        self.name=args[0]
        self.blood=args[1]
        self.aggr=args[2]
        self.sex=args[3]

    def walk(self,n):
        print('%s走过来了，走了%s步'%(self.name,n))

someone=person('王昭君',100,3,'girl')
print(someone.name)
print(someone.blood)
print(someone.aggr)
print(someone.sex)
print(someone.__dict__)
print(person.country)
print(person.walk(someone,6))
print(person.__dict__)
print(person.__dict__['country'])
print(someone.__dict__['name'])
someone.__dict__['name']='蔡文姬' 
print(someone.name)
someone.name='蔡文姬'
print(someone.name)
person.__dict__['country']='美国'
print(person.country) #报错，不能修改类下面的静态属性

以下是对应上面的代码添加注释部分，详细的分析整个代码的执行过程，以及一些过程的意义所在：

class person:  #1. 定义一个类叫person

    country='China' #创建了一个只要是这个类就一定具有的属性，即共有的属性,也叫静态属性，可以在类下调用

    def __init__(self,*args):
        #2. _init_初始化方法，里面是自己要写的代码，这里的self可以相当于游戏里面定义人物角色的那个字典someone，
        # 里面有人物各种属性，此时的self是空的，拿来放下面的属性以及对应的值；*args拿来接收调用类传入的参数即属性对应的值，也相当于字典里面key对应的值
        #self是一个可以存储很多属性的大字典，是一个对象，是必须传的参数
        self.name=args[0]
        #4. 将属性以及对应的值放入类中，往字典里面添加属性的方式发生了变化
        #左边的self.name是类的属性，相当于someone['name']即someone字典里面的key
        #右边的args[0]是传入的对应参数，即属性对应的值，也相当于字典里面的name这个key对应的值
        self.blood=args[1]
        self.aggr=args[2]
        self.sex=args[3]
        #5.这里不用写return返回值，self会以类似字典关系自动将属性以及对应的参数返回给调用的地方

    def walk(self,n): #9. 类里面定义的一个walk方法，第一个参数一定是类里面的对象self，并且一定要放在第一个，后面还可以传其他
        print('%s走过来了，走了%s步'%(self.name,n))

someone=person('王昭君',100,3,'girl')#对象=类名（）#调用类执行类得到对象----实例化，即类名可以实例化对象
#3.调用person这个类，并传入参数，参数是属性对应的值
#6.接收调用返回来的值，是一个存有类的属性以及参数的大字典赋值给someone，此时的someone是一个具体的对象，也可以说someone=self
print(someone.name)
#7.打印对象.属性才能查看属性值，直接打印someone取到的是一个对象的内存地址，someone.name=self.name
print(someone.blood)
print(someone.aggr)
print(someone.sex)
print(person.walk(someone.name,6))
#8. 调用类里面的walk方法 ，并传入参数,调用的方法：类名.方法名（对象名，其他参数），对象名参数一定要传，并且一定要放在第一个
print(person.country) #调用类person里面的静态属性，类名可以查看类中的属性，不需要实例化就可以查看
print(person.__dict__) #查看类里面的所有方法双下方法
print(someone.__dict__) #查看对象里面所有具体的属性
print(person.__dict__['country']) #以字典的形式查看类里面的属性
print(someone.__dict__['name']) #以字典的形式查看对象里面的属性值
someone.__dict__['name']='蔡文姬' #以字典的方式修改对象的属性值
print(someone.name)
someone.name='蔡文姬' #以对象点属性的方式修改属性值
print(someone.name)
# person.__dict__['country']='美国'
# print(person.country) #报错，不能修改类下面的静态属性

四、小结

对象=类名（）

过程：

1.类名（）首先会创造出一个对象，创建了一个self变量
2.调用_init_方法，类名括号里面的参数会被在这里接收
3.执行_init_方法
4.返回self

对象能做的事：

1.查看属性
2.调用方法
3._dict_对于对象的增删改查操作都可以通过字典的语法进行

类名能做的事：

1.实例化
2.调用方法：只不过要自己传递self参数
3.调用类中的属性，也就是调用静态属性
4._dict_对于类中的名字只能看 不能操作