面向对象初识

 1.面向过程 vs 函数式编程

面向过程:
s1 = 'asdfqweqmvas'
count = 0
for i in s1:
    count += 1
print(count)

lst = [i for i in range(100)]
count = 0
for i in lst:
    count += 1
print(count)

函数式编程
def func(num):
    count = 0
    for i in num:
        count += 1
    return count
print(func('asdfqweqmvas'))
print(func(i for i in range(100)))

 函数体编程相较与面向过程编程:

1.减少代码的重用性
2.增强代码的可读性

2.函数式编程 vs 面向对象编程

类:就是具有相同属性和功能的一类事物
对象:就是类的具体体现

面向对象编程的优点第一个:是一类功能函数的集合,使你的代码更清晰化,合理化
第二个优点:面向对象,要拥有上帝视角看问题,类其实就是一个公共模板,对象就是从具体的模板实例化出来的
　　　　　　对象去操作使用这个公共模板

3.类的结构:

class human():
    '''
    此类主要是构建人类
    '''
    mind = '有思想'    #第一部分 静态属性 (属性,静态变量,静态字段)
    body = '有四肢'
    def think(self):    #第二部分 动态属性  (方法,函数)
        print(666)

class 是类的关键字,定义一个类
human是这个类的类名
类的结构从大方向来说分为两部分:静态变量,动态方法

4.类名操作静态属性

查看类中所有的方法  __dict__

class human:
    mind = '思想'
    body = {'眼睛':'看','嘴':'吃','耳朵':'听'}
    def work(self):
        print('人会工作')
# print(human.__dict__)  #查看类中的所有,以字典的形式输出
print(human.__dict__['mind'])   #思想

通过__dict__方法,只能进行查询,不能进行增删改
一般不用于单独的属性查询

5.万能的点

class Computer:
    screen = '显示画面'
    processor = '处理数据'
    def memory(self):
        print('电脑')
print(Computer.screen)   #利用类名查询静态变量
Computer.screen = '动态画面'  #利用类名改变静态变量的值
print(Computer.screen)
del Computer.screen         #利用类名删除静态变量的值
print(Computer.__dict__)
Computer.mouse = '鼠标'         #利用类增加静态变量
print(Computer.__dict__)

类名对静态变量的操作总结:
查看类的全部时,用__dict__.
对单个属性进行操作时,用万能的点

6.类名操作动态方法:

前提:除了两个特殊方法:静态方法,类方法之外,不会用类名去操作一个类中的方法

class Computer:
    screen = '显示画面'
    processor = '处理数据'
    def memory(self):
        print('牛逼')
Computer.memory(111)    #将参数传给self
Computer.__dict__['memory'](111)#也可以用,但是不用

 
7. 什么是对象?

    对象是从类中出来的,只要是类名加上(),这就是实例化的过程,这样会实例化一个对象

class human:
    mind = '思想'
    def name(self):
        print("第一个")
        print(self)
    def __init__(self):
        print('第二个')
    def leg(self):
        print('第三个')
obj = human()       #只要是实例化出对象,就会执行__init__方法
print(obj)
#obj的地址跟self的地址一样

实例化一个对象总共发生了三件事:
1.内存中开辟了一个对象空间
2.自动执行类中的__init__方法,并对这个对象空间的内存地址传递给__init__的第一个位置参数self
3.在__init__方法中通过self给对象空间添加属性

class Human:
    mind = '有思想'
    language = '使用语言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('barry','男',18,'运动')  #类名+()为对象
print(obj.__dict__)     查看对象的空间属性
#{'n': 'barry', 's': '男', 'a': 18, 'h': '运动'}

8.对象操作对象的空间属性

对象操作对象的空间属性: __dict__
对象名+__dict__ #查询对象中的所有属性 对象.__dict__

对象操作对象中的单个属性.万能的点
class human:
    mind = '有思想'
    def __init__(self,name,age,sex):
        self.n = name
        self.a = age    #通过self 将属性封装给对象obj  方便利用对象进行调用
        self.s = sex
obj = human('牛逼',18,'男')
obj.job = 'IT'      #増
del obj.n           #删
obj.s = '女'         #改　　　　　　
print(obj.s)        #查
print(obj.__dict__)

 8 从对象中操作类的操作:

class human:
    mind = '有思想'
    def __init__(self,name,age,sex):
        self.n = name
        self.a = age
        self.s = sex
obj = human('牛逼',18,'男')
print(obj.mind)# 对象查询类中的静态属性

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
    def work(self):
        print(self)
        print('人类会工作')
    def tools(self):
        print('人类会使用工具')
obj = Human('barry','男',18,'运动')
obj.work()
obj.tools()

 对象查看类中的静态方法 ,只能查看

类中的方法一般都是通过对象执行的,

并且对象执行这些方法后都会将空间地址,
传给方法中的第一个参数self
self 就是类中方法(函数)的第一个参数,代表的就是这个对象
一个类可以实例化多个对象