面向对象初识

一 : 面向对象初识

1.1 回顾面向过程编程VS函数式编程

面向过程编程,测量元素的个数

s = "dsdsgffd"
count = 0
for i in s:
    count += 1
print(count)


l1 = [1,2,3,4,5]
count = 0
for i in l1:
    count += 1
print(l1)


函数编程

def func(s):
    count = 0
    for i in s:
        count += 1
    return count
# func('dsdsgffd')
func('[1,2,3,4,5]')

**函数编程较之于面向过程编程最明显的两个特点 : **

1.减少代码的重用性

2.增强代码的可读性

1.2 函数式编程VS面向对象编程

函数式编程

# 函数式编程

# auth 认证相关
def login():
    pass

def regisgter():
    pass

# account 账户相关
def func1():
    pass

def func2():
    pass


# 购物车相关
def shopping(username,money):
    pass
def check_paidgoods(username,money):
    pass
def check_unpaidgoods(username,money):
    pass
def save(username,money):
    pass

函数式编程

面向对象式编程

class LoginHandler:
    def login(self):
        pass

    def regisgter(self):
        pass

class Account:
    def func1(self):
        pass

    def func2(self):
        pass

class ShoppingCar:
    def shopping(username,money):
        pass
    def check_paidgoods(username,money):
        pass
    def check_unpaidgoods(username,money):
        pass
    def save(username,money):
        pass

面向对象编程第一个优点 : 是一类相似功能函数的集合,使你的代码更清晰化,更合理化

第二个优点 : 面向对象,要有上帝视角,类其实是一个公共模板(厂房),对象就是从具体的模板实例化出来(慢慢体会)

1.3类的结构

class Human:
    """
    此类主要构建人类
    """
    mind = '有思想'   #  第一部分  静态属性 属性  静态变量  静态字段
    dic = {}
    l1 = []
    def sork(self):   #  第二部分  方法  函数  动态属性
        print('人都会工作')  #  print(self)

class 是关键字与 def 的用法 相同 定义一个类

Human 是此类的类名,类名推荐使用的是驼峰体,首字母大写.(私有类可以加下划线)

类的结构从大方向来说分为两部分:

静态变量

动态方法

二 : 从类名的角度研究类

2.1 类名操作静态属性

2.11 查看类中的所有内容

类名.__dict__ 方式

class Human:
    """
    此类主要构建人类
    """
    mind = '有思想'   #  第一部分  静态属性 属性  静态变量  静态字段
    dic = {}
    l1 = []
    def sork(self):   #  第二部分  方法  函数  动态属性
        print('人都会工作')  #  print(self)
# print(Human.__dict__)   #  查找到所有内容
# print(Human.__dict__['mind'])  #  有思想   直接查找到
# Human.__dict__['mind'] = '无脑'
# print(Human.__dict__)  # 报错   通过这种方式只能查询  不能修改
#  这种方式一般用来用户查询

2.12 第二种 : 万能的点

class Human:
    """
    此类主要构建人类
    """
    mind = '有思想'   #  第一部分  静态属性 属性  静态变量  静态字段
    dic = {}
    l1 = []
    def sork(self):   #  第二部分  方法  函数  动态属性
        print('人都会工作')
#  查
# print(Human.mind)  #  有思想
#  改
# Human.mind = "无脑"
# print(Human.mind)   #  无脑
# 删
del Human.mind
Human.work = '直立行走'
print(Human.work)  #   直立行走


通过万能的点   可以增删改查类中的单个属性

对以上内容的总结 : 如果想查找类中的所有内容,用第一种方法 dict 的方法,如果只是操作单个属性则用万能的点的方式.

2.2 类名操作动态属性

class Human:
    """
    此类主要是构建人类
    """
    mind = '有思想'  # 第一部分：静态属性 属性 静态变量 静态字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函数 动态属性
        # print(self)
        print('人类会工作')
    def tools(self):
        print('人类会使用工具')
Human.work(1)        # 人类会工作
Human.tools(11)      # 人类会使用工具  

三 : 从对象角度研究类

3.1什么是对象

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

class Human:
    mind = "有思想"
    def __init__(self):
        print(666)
        print(self)

    def work(self):
        print('人类会工作')

    def tools(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': '运动'}

3.2 对象操作对象空间所有属性

3.21对象查询对象中所有属性

对象.__dict__

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': '运动'}

3.22对象操作对象中的单个属性,万能的点

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,'运动')

#  增
# obj.job = 'IT'
# print(obj.__dict__)  #  {'n': 'barry', 's': '男', 'a': 18, 'h': '运动', 'job': 'IT'}

#  删
# del obj.n
# print(obj.__dict__)   #    {'s': '男', 'a': 18, 'h': '运动'}

3.3 对象查看类中的属性

class Human:
    mind = '有思想'
    language = '实用语言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby
obj = Human('zhou','男',18,'画画')
print(obj.mind)
print(obj.language)
obj.a = 666
print(obj.a)

3.4对象操作类中的方法 (自己的理解是调用函数)

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(self)
        print('人们会使用工具')
obj = Human('barry','女',18,'写作')
obj.work()
obj.tools()

类中的方法都是通过对象执行的,并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self

self 是什么?

self 其实是类中方法(函数)的第一个位置参数,只不过解释器会自动的将调用这个函数对象给self,所以咱们把类中的方法的第一个参数约定俗成设置成self, 代表这个就是对象。

一个类可以实例化多个参数

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(self)
        print('人们会使用工具')

obj1= Human('小胖','男',20,'美女')  
obj2= Human('相爷','男',18,'肥女')
print(obj1,obj2)  #<__main__.Human object at 0x10483d080> <__main__.Human object at 0x10483d208>
print(obj1.__dict__) # {'n': '小胖', 's': '男', 'a': 20, 'h': '美女'}
print(obj2.__dict__) # {'n': '相爷', 's': '男', 'a': 18, 'h': '肥女'}