Python -- 面向对象:初识

Posted 2022-03-20 agoni-7

面向对象:初识

回顾: 面向过程式编程 vs 函数式编程

通过对比可知:函数式编程较面向过程式编程最明显的两个特点:

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

# 面向过程式编程,测量对象元素个数
s = 'aasdasdaskfl'
count = 0 
for i in s:
    count += 1

l1 = [1,2,3,4]
count = 0
for i in l1:
    count += 1
    
# 函数式编程
def func(s):
    count = 0
    for i in s:
        count += 1
    return count
print(func('aasdasdaskfl'))
func([1,2,3,4])

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

# 函数式编程

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

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

# 面向对象编程
class LoginHandler:
    def login(self):
        pass
    def regisgter(self):
        pass

class Account:
    def func1(self):
        pass
    def func2(self):
        pass

面向对象的优点:

1. 是一类相似功能函数的集合,使代码更清晰化,更合理化
2. 站在上帝的角度去考虑问题,类是一个公共模板,对象是从这个公共模板产出的
   • 类是具有相似功能和特性的事物
   • 对象是类的具体表现

7.1.1 类的结构

class Student:
    '''
    此处是构建学生
    '''
    diary = '日常'
    exam = '考试'
    def work(self):
        print('学习')
    def task(self):
        print('任务')
# class 是关键字与def用法相同,定义一个类
# Student 是类的类名,类名要具有描述性,首字母要大写,类名尽量不要用下划线
# 类的结构分为两部分
静态变量  --  动态方法

7.1.2 从类名的角度研究类

• 类名操作静态属性

1. 查看类中的偶有内容: 类名.__dict__

   class Student:
       '构建学生'
       diary = '学习'
       exam = '考试'
       def work(self):
           print('学习')
       def task(self):
           print('任务')
   print(Student.__dict__)
   print(Student.__dict__['diary'])
   Student.__dict__['task'] = '0'  # 会报错
   print(Student.__dict__)
   
   # 通过这样的方法只能查询,不能增删改
   # 类名.__dict__ 只用于查询全部内容,一般不用于单独属性查询

2. 万能的 .

   class Student:
       '构建学生'
       diary = '学习'
       exam = '考试'
       def work(self):
           print('学习')
       def task(self):
           print('任务')
   print(Student.diary)    # 查
   Student.exam = '不考试'  # 改
   del Student.diary        # 删
   Student.cloth = '校服'    # 增
   
   # 通过万能的 . 可以增删改查类中的单个属性

• 类名操作动态方法

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

  class Student:
      '构建学生'
      diary = '学习'
      exam = '考试'
      def work(self):
          print('学习')
      def task(self):
          print('任务')
  
  Student.work(111)  
  Student.task(222)
  # 这里通过类名操作动态方法必须传 一个实参给self

7.1.3 从对象的角度研究类

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

实例化对象会发生三件事:

1. 在内存中创建一个对象空间
2. 自动执行__init__方法,并将对象空间传给self参数
3. 执行__init__方法里面的代码,给对象空间封装其属性

• 对象查询对象中所有的属性. 对象.__dict__

• 对象操作对象中的单个属性. 万能的 .

class Student:
    diary = '学习'
    exam = '考试'

    def __init__(self,n,s):
        print('小学生')
        self.name = n
        self.sex = s

obj = Student('Agoni','男') # 只要实例化对象,就会自动执行__init__方法
print(obj)   <__main__.Student object at 0x0000015655819668>  obj和self 的地址相同
print(obj.__dict__) # 对象查看全部属性

# 对象可以操作对象空间的属性  万能的点
print(obj.name)    # 查 Agion
obj.sex = '女'     # 改 
print(obj.__dict__) 'name': 'Agion', 'sex': '女'
obj.age = '18'     # 增
print(obj.__dict__) 'name': 'Agion', 'sex': '女', 'age': '18'
del obj.sex        # 删
print(obj.__dict__) 'name': 'Agion', 'age': '18'

• 对象查看类中的属性

• 对象操作类中的方法

class Student:
    diary = '学习'
    exam = '考试'

    def __init__(self):
        print('小学生')
        self.name = 'Agion'
        self.sex = '男'

    def work(self):
        print('工作')
    def task(self):
        print('任务')
        
# 对象查看类中的属性
print(obj.diary)
print(obj.exam)

# 对象操作类中的方法
obj.work()
obj.tools()

类中的方法一般都是通过对象执行的(除去类方法,静态方法外),并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self .

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

一个类可以实例化多个对象

obj1 = Student('梅西','男')
obj2 = Student('C罗','男')
print(obj1,obj2)
print(obj1.__dict__)
print(obj2.__dict__)