Python面向对象Day1

一、面向对象初始

面向过程变成属于流水式

面向对象是一种思想

 

结构上理解面向对象：两部分

class A:                      # 类
    name = '小明'             # 静态属性，静态变量，静态字段，或者属性、变量、字段

    def func(self):           # 函数、动态属性、方法
        pass

 

函数和面向对象的区别：

①.函数封装一个功能，而面向对象封装多个功能

②.面向对象比较抽象，它是一种思想，要站在上帝的角度去理解它

③.程序可扩展，对象都是一个个独立的。既有耦合性又有差异性

 

二、类、对象

类：具有相同属性或者功能的一类事物，类包含属性和方法。例如：人类、猫类、狗类；

对象：对象是类的具体体现（独一无二），例如：具体到事物，每个事物是独立的。

 

三、类名的使用

类：类似于一个公共框架，一个公共模型

定义类：

class 类名：

　　属性

　　方法

 

① 查看类中的所有属性及方法__dict__

主要用途：类名.__dict__ 查看类的所有方法和属性

返回的是字典，__dict__只有一个功能，就是查看所有的属性和方法，也能查看单独的属性及方法，但是不能增删改

使用：类名.__dict__

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法  
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

print(Person.__dict__)            # 查看类的所有属性和方法，以字典的形式返回

# 结果
{'__module__': '__main__', 'name': '小明', 'age': 18, 'eat': <function Person.eat at 0x0000021D7A978AE8>, 'sleep': <function Person.sleep at 0x0000021D7A978950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

 

单独查看属性（不建议使用）

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')


print(Person.__dict__['name'])            # 单独查看属性

# 结果
小明

 

② 查看类中单独的属性或者方法，用万能的点

使用：类名.属性（方法）

除了查看属性，还能对属性增删改

 

查：

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

print(Person.age)                 # 单独查看类的属性
print(Person.__dict__)            # 查看类的所有属性和方法，以字典的形式返回

# 结果
18
{'__module__': '__main__', 'name': '小明', 'age': 18, 'eat': <function Person.eat at 0x000001B497B98AE8>, 'sleep': <function Person.sleep at 0x000001B497B98950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

 

增：

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

Person.hoppy = 'football'         # 在类中增加一个属性
print(Person.__dict__)            # 查看类的所有属性和方法，以字典的形式返回

# 结果
{'__module__': '__main__', 'name': '小明', 'age': 18, 'eat': <function Person.eat at 0x000002019FFD8AE8>, 'sleep': <function Person.sleep at 0x000002019FFD8950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, 'hoppy': 'football'}

 

改：

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

Person.name = '小白'              # 修改属性
print(Person.name)
print(Person.__dict__)

# 结果
小白
{'__module__': '__main__', 'name': '小白', 'age': 18, 'eat': <function Person.eat at 0x00000196D23A8AE8>, 'sleep': <function Person.sleep at 0x00000196D23A8950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

 

删：

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

del Person.age                    # 删除属性
print(Person.__dict__)

# 结果
{'__module__': '__main__', 'name': '小明', 'eat': <function Person.eat at 0x000002312E698AE8>, 'sleep': <function Person.sleep at 0x000002312E698950>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

 

③ 类内的方法的操作

一般不通过类名操作！！使用类的实例化对象来操作

使用：类名.方法(参数)

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

Person.eat(1)                     # 调用类的方法，需要实参

# 结果
在吃饭

 

类名.__dict__[方法名](参数)　　　　不建议使用

class Person:
    name = '小明'                 # 属性
    age = 18

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

Person.__dict__['eat'](1)         # 用__dict__的key调用方法，不建议使用

# 结果
在吃饭

 

类中的特殊方法，用于实例化对象

def __init__(self):　　　　

　　pass

    def __init__(self):           # 类中的特殊方法，用于实例化对象
        pass

 

类的实例化对象

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self):           # 类中的特殊方法，用于实例化对象
        pass

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person()                    # 实例化对象

类名()　　　　 这个过程就是实例化过程，它会实例化一个对象（它会给内存实例化一个对象空间）

obj = 类名()　　把内存实例化的空间赋值给obj

 

实例化过程内部进行了三个阶段：

① 在内存中开辟一个类对象空间，产生一个类对象指针

② 它会根据指针找到类的__init__的方法，自动执行类中的__init__方法，并且将对象空间自动传给self参数，其他参数手动传入

③ 执行__init__的方法，给类对象空间封装相应的属性

 

 def __init__(self): 　　　　功能：给对象封装属性的

 

四、对象

对象里不能定义方法，对象只能封装静态属性

 ①对象操作对象空间

　　对象.__dict__    　　　　以字典的形式返回封装的属性，查看对象的所有属性

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self,hobby,job):           # 给实例化对象定义属性，必须提供参数才能实例化
        self.hobby = hobby
        self.job = job

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person('football','IT')                 # 实例化对象
print(obj.__dict__)                           # 查看对象的所有属性

# 结果
{'hobby': 'football', 'job': 'IT'}

 

对象操作对象的属性方式：增删改查

增（属性不存在与对象空间）：

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self,hobby,job):           # 给实例化对象定义属性，必须提供参数才能实例化
        self.hobby = hobby
        self.job = job

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person('football','IT')                 # 实例化对象
obj.age = 20                                  # 对象创建一个属性
print(obj.__dict__)                           # 查看对象的所有属性

# 结果
{'hobby': 'football', 'job': 'IT', 'age': 20}

 

改（属性存在与对象空间）：

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self,hobby,job):           # 给实例化对象定义属性，必须提供参数才能实例化
        self.hobby = hobby
        self.job = job

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person('football','IT')                 # 实例化对象
obj.age = 20                                  # 对象创建一个属性
print(obj.__dict__)                           # 查看对象的所有属性
obj.age = 15                                  # 修改对象的属性
print(obj.__dict__)                           # 查看对象的所有属性

# 结果
{'hobby': 'football', 'job': 'IT', 'age': 20}
{'hobby': 'football', 'job': 'IT', 'age': 15}

 

删：

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self,hobby,job):           # 给实例化对象定义属性，必须提供参数才能实例化
        self.hobby = hobby
        self.job = job

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person('football','IT')                 # 实例化对象
print(obj.__dict__)                            # 查看对象的所有属性
del obj.hobby                                 # 删除对象的属性
print(obj.__dict__)                            # 查看对象的所有属性

# 结果
{'hobby': 'football', 'job': 'IT'}
{'job': 'IT'}

 

查：

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self,hobby,job):           # 给实例化对象定义属性，必须提供参数才能实例化
        self.hobby = hobby
        self.job = job

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person('football','IT')                 # 实例化对象
print(obj.job)                                # 查看某一属性的值

# 结果
IT

 

②对象操作类空间的属性

只能通过对象查询类空间的属性，不能修改，因为一旦修改就是给对象增加属性

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self,hobby,job):           # 给实例化对象定义属性，必须提供参数才能实例化
        self.hobby = hobby
        self.job = job

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person('football','IT')                 # 实例化对象
print(Person.__dict__)
print(obj.__dict__)
obj.name = '小白'
print(Person.__dict__)
print(obj.__dict__)

# 结果
{'__module__': '__main__', 'name': '小明', 'age': 18, '__init__': <function Person.__init__ at 0x000001DB42518AE8>, 'eat': <function Person.eat at 0x000001DB42518950>, 'sleep': <function Person.sleep at 0x000001DB42518A60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
{'hobby': 'football', 'job': 'IT'}
{'__module__': '__main__', 'name': '小明', 'age': 18, '__init__': <function Person.__init__ at 0x000001DB42518AE8>, 'eat': <function Person.eat at 0x000001DB42518950>, 'sleep': <function Person.sleep at 0x000001DB42518A60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
{'hobby': 'football', 'job': 'IT', 'name': '小白'}

 

 

③ 对象操作类空间的方法：

对象.类空间的方法()

类名.类空间方法(对象)

class Person:
    name = '小明'                 # 属性
    age = 18

    def __init__(self,hobby,job):           # 给实例化对象定义属性，必须提供参数才能实例化
        self.hobby = hobby
        self.job = job

    def eat(self):                # 方法
        print('在吃饭')

    def sleep(self):
        print('在睡觉')

obj = Person('football','IT')                 # 实例化对象
obj.sleep()                                   # 调用类空间的方法

# 结果
在睡觉

 

五、类名称空间、对象名称空间

实例化对象调用类中的属性与方法（内存级别）

类对象指针：对象与类的指向关系

① 对象能调用类中的属性与方法

obj.属性名 先从自己的空间去找，没有此属性它会通过类对象指针从类中去找，类中找不到，会从父类去找属性

② 类不能调用对象的属性

类不存在指向对象的值，找不到值；类只是公共的模板，对象的不同在__init__体现

对象能操作模板，模板不能操控类

③ 对象与对象之间不能互相调用

两个独立的空间是互相不能访问的，同一类实例化的对象之间是不能互相访问，不同类实例化的对象有可能访问

 给对象封装属性：__init__或者任意位置增加；但是属性一般都封装在__init__