python学习 day18

面向对象初识

### 面向过程：

# 例1：
s1 = '字符zifu'
count = 0
for i in s1:
    count += 1
# 例2：
l1 = [1, 2, 3, 4]
count = 0
for j in l1:
    count += 1

### 函数

def func(s):
    count = 0
    for i in s:
        count += 1
    return count

### 函数

# auth：
 def login():
     pass
 def regisgter():
     pass

# account：
 def func1():
     pass
 def func2():
     pass

# shoppingcar：
def shopping(username,money):
    pass
def check_paidgoods(username,money):
    pass
def check_unpaidgoods(username,money):
    pass
def save(username,money):
    pass

### 面向对象：面向对象是一类相似功能函数的集合体。

 1，第一个优点： 更清晰化，更规范化。

 2，面向对象，必须要站在上帝的角度，去考虑问题。类，其实就是一个公共模板；对象，就从具体的模板实例化出来。

# auto
class LoginHandler:
    def login(self):
        pass
    def regisgter(self):
        pass

# account
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

# 面向对象的结构

'''
class 类名():
    
    变量
    
    函数（方法） 
'''

例：

class Human:
    """
    此类主要是构建人类
    """
    mind = '会思想' 　　 # 静态属性 属性 静态变量 静态字段
    language = '使用文字'
    # dic = {}
    # l1 = []

    def __init__(self,name,sex,age,hobby): 　　 # 方法 函数 动态属性
        # print(self,name,sex,age,hobby)
        # print(666)
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

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

    def tools(self):
        # self.color = 'blue'
        print('人类都会使用工具')

### 类名

1）类名操作类中的静态属性

第一种：# 查，“   类名.__dict__　”（Human.__dict__）查看类中所有内容时使用。

print(Human.__dict__)              # 查看类中所有内容
'''
 {'__module__': '__main__', '__doc__': '
    此类主要是构建人类
    ', 'mind': '有思想', 'language': '实用语言',
 '__init__': <function Human.__init__ at 0x0000024F6ABCD9D8>, 'work': <function Human.work at 0x0000024F6ABCDA60>,
 'tools': <function Human.tools at 0x0000024F6ABCDAE8>, '__dict__': <attribute '__dict__' of 'Human' objects>,
 '__weakref__': <attribute '__weakref__' of 'Human' objects>}
'''        

print(Human.__dict__['mind'])        # 查看 静态变量 mind 中的内容
# 有思想

Human.__dict__['mind'] = '无脑'        # 无法对类中内容进行更改，否则报错
print(Human.__dict__)                

第二种：万能的 “  .  ” 可以增删改查类中的静态属性。

Human.walk = '直立行走'   ### 增　　　　# 增加了 walk=‘直立行走’ 的属性
print(Human.walk)

del Human.mind  ### 删　　　　# 将 mind = ‘有思想’ 属性删除

Human.mind = '思维zhang'  ### 改  
print(Human.mind)        # mind = ‘有思想’   改为了    mind = ‘思维zhang’

print(Human.mind)  ### 查        # mind = ‘思维zhang’

2）类名操作类中的方法（除去特殊方法：静态方法，类方法之外，一般不会通过类名执行类中的方法）。

方法： “  类名.方法名(参数)  ”  <--->  Human.work(1231)

Human.work(1231)
# 1222
# 人类会工作

Human.tools(111)    
# 人类都会使用工具

### 对象

----   “  类名（）”  这是一个实例化过程，就会产生一个对象。

例：obj = Human() 　产生了一个实例化对象 obj 

obj = Human        # 实例化一个过程

实例化一个对象需要经历的3件事情（即 实例化一个对象的过程）：

1）产生一个空的对象空间。

print(obj)  # <__main__.Human object at 0x0000019BC6A0F828>

2）自动执行类中的 __init__ 方法并且将这个空的对象空间传给 self 。

print(obj)  

3）在 __init__ 中通过self给这个空间添加属性。

obj = Human('小胖','男',20,'女')        # 实例化对象

# 对象  操作  对象空间  的属性

1）" obj.__dict__  " 查询对象中所有的属性

print(obj.__dict__)        # {'n': '小胖', 's': '男', 'a': 20, 'h': '女'}

2）通过万能的  " . "  的方式操作对象中的单个属性。

obj.job = 'IT'      # 增

del obj.n      # 删

obj.s = '女'     # 改
print(obj.s)

print(obj.__dict__)    # 查

3）对象可以查询类中的属性。

print(obj.mind)　　# 查询 mind = “会思想”
print(obj.language)　　# 查询 language = “使用语言”
print(obj.a)　　　　# 查询　　a = 20
obj.a = 666
print(obj.a)　　# 改 a = 666

4）对象可以执行类中的方法。

       对象执行类中的所有方法(除去3个特殊方法)Python解释器都会将对象空间主动传给方法的第一个参数self。

print(obj)        
# <__main__.Human object at 0x00000284476FBCF8>

obj.work()
# <__main__.Human object at 0x00000284476FBCF8>
# 人类会工作

 self：类中方法的第一个形参 约定俗成 写  self  便于统一，self 接受的就是 对象空间。

class Human:
    """
    此类主要是构建人类
    """
    mind = '会思想'  # 静态属性 属性 静态变量 静态字段
    language = '使用文字'
    # dic = {}
    # l1 = []
    def __init__(self,name,sex,age,hobby):  # 方法 函数 动态属性
        # print(self,name,sex,age,hobby)
        # print(666)
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

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

    def tools(self):
        # self.color = 'blue'
        print('人类会使用工具')
        print('猩猩会使用工具')
        print('猴子会使用工具')

obj = Human('小胖', '男', 20, '女')
print(obj.__dict__)　　# {'n': '小胖', 's': '男', 'a': 20, 'h': '女'}

obj.tools()
# 人类会使用工具
# 猩猩会使用工具
# 猴子会使用工具
print(obj.__dict__)　　# {'n': '小胖', 's': '男', 'a': 20, 'h': '女'}

self = [1,2,3]
self.append(666)
obj = self
print(obj, self)　# [1, 2, 3, 666] [1, 2, 3, 666]

self.append(777)
obj.append(888)
print(obj, self)    # [1, 2, 3, 666, 777, 888] [1, 2, 3, 666, 777, 888]

# 多个对象

# 多个对象
# xiaopang = Human('小胖','男',20,'美女')
# xiangye = Human('相爷','男',18,'肥女')
# print(xiangye,xiaopang)
# print(xiaopang.__dict__)
# print(xiangye.__dict__)

 内容总结：

# 内容回顾：
    面向对象：将一些相似功能的函数集合到一起。
    类：具有相同属性和功能的一类事物。
    对象：类的具体体现。
        1.将一些相似功能的函数集合到一起
        2.站在上帝的角度考虑问题，类就是一个公共模板。
    类的结构：
    class Person:
        mind = "有思想"        # 静态属性 静态字段
        def __init__(self, name, age)
            self.n = name
            self.a = age
        def work(self):         # 动态属性 方法
            print('能工作')
    类名：
        1，Person.mind  # 万能的‘ . ’
        2,Person.__dict__ 查询类中所有内容
        3，Person.work(111)      # 不建议这样做
    对象：
        Person()    # 产生一个对象
        obj = Person('barry', 20)
        1)在内存中开辟一个空的对象空间
        2)自动执行 __init__ 方法，先把对象空间传给self，后面参数依次传入
        3)执行 __init__ 代码，将封装好属性的对象空间返回给了obj
        1,查询对象的属性：
            obj.__dict__
        2,查询对象单独的属性：
            obj.name
        3，查询类中的属性：
            obj.mind
        4，查询执行类中的方法：
            obj.work()
            Person.work(obj)