python学习之【面向对象编程】

第六章 对象（object）

什么是对象？

- 对象是内存中专门用来存储数据的一块区域
- 对象中可以存放各种数据（比如：数字，布尔值，代码）
- 对象由三部分组成：
    1.对象的标识（id）
    2.对象的类型（type）
    3.对象的值（value）

面向对象（oop）

- python是一门面向对象的编程语言
- 所谓的面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的
- 面向过程的编程语言
    - 面向过程指的是将我们的程序的逻辑分解为一个一个的步骤，
        通过对每个步骤的抽象，来完成程序
    - 列子：
        - 孩子上学
            1.妈妈起床
            2.妈妈洗漱
            3.妈妈做饭
            4.爸爸起床
            5.爸爸叫孩子起床
            6.孩子洗漱
            7.孩子吃饭
            8.孩子出门
            9.爸爸送上学
    - 面向过程的编程思想将一个功能分解为一个一个的小步骤，
        我们通过完成一个一个的小步骤来完成一个程序。
    - 这种编程方式，符号我们人类的思维，编写起来相对比较简单
    - 但是这中方式编写代码的往往只适用于一个功能
        如果要在实现别的功能，即使功能相差极小，也往往要重新编写代码，
        所以他的可复用性较低，并且难于维护
- 面向对象的编程语言
    - 面向对象的编写语言，关注的是对象，而不关注过程
    - 对于面向对象的语言来说，一切都是对象
    - 例子：
        1.谁叫孩子起床
        
    - 面向对象的编程思想，将所有的功能统一保存到对应的对象中
        比如，妈妈功能保存到妈妈对象中，孩子的功能保存到孩子对象中
        要使用某个功能，直接找到对应的对象即可
    - 这种方式编写的代码，比较容易阅读，并且比较易于维护，容易复用。
    - 但这种方式编写，不太符合常规思维，编写起来超微麻烦一点 
    
- 简单归纳一下，面向对象的思想
    1.找对象
    2.搞对象

类（class）

- 我们目前所学习的对象都是python内置的对象
- 但是内置对象并不能满足所有的需求，所以我们在开发中经常需要自定义一些对象
- 类，简单理解他就相当于一个图纸，在程序中我们需要根据类来创建对象
- 类就是对象的图纸！
- 我们称对象是类的实例（instance）
- 如果多个对象是通过一个类创建的，我们称这些对象是一类对象
- 像 int() float() bool() str() list() dict()...这些都是类
- a = int(10) # 创建一个int类的实例，等价于 a = 10
- 我们自定义的类都需要使用大写字母开头，使用大驼峰命名法（帕斯卡命名法）来对类命名

- 类也是一个对象!
- 类是一个创建对象的对象！

类的简介

a = int(10) # 创建一个int类的实例
b = str('assdf') # 创建一个str类的实例

print(a,type(a))# 10 
print(b,type(b))# assdf 

# 定义一个简单的类
# 使用class关键字来定义类，语法和函数很像！
# class 类名([父类]):
#     代码块
#
class MyClass():
    pass
print(MyClass)

# 使用MyClass创建一个对象
# 使用类来创建对象，就像调用一个函数一样
mc = MyClass() # mc就是通过MyClass创建的对象，mc是MyClass的实例
mc2 = MyClass()
mc3 = MyClass()
mc4 = MyClass()
# mc mc2 mc3 mc4都是MyClass的实例，他们都是一类对象
# isinstance()用来检查一个对象是否是一个类的实例
result = isinstance(mc,MyClass)
print(result) #True
result = isinstance(mc,str)
print(result) #False
print(mc,type(mc)) #<__main__.MyClass object at 0x0000025DD7258148> 

print(id(MyClass),type(MyClass)) #2735482185384 
# 现在我们通过MyClass这个类创建的对象都是一个空对象
# 也就是对象中实际上什么都没有，就相当于一个空的盒子
# 可以向对象中添加变量，对象中的变量称为属性
# 语法：   对象.属性名 = 属性值
mc.name = '孙悟空'
print(mc.name) #孙悟空
# print(mc_2.name)
#     print(mc_2.name)
# NameError: name 'mc_2' is not defined

创建对象的流程

class MyClass:
    pass
mc = MyClass()
p1 = Person()的运行流程
    -1: 类被调用及执行且执行一次：执行类的代码块中的代码（只在类定义的时候执行一次）
    ① 创建一个变量mc
    ② 在内存中创建一个新的对象
    ③ __init__(self)方法执行
    ④ 将对象的id赋值给变量p1

对象的初始化

class Preson:
    # name = 'swk'
    print('Person代码块中的代码')
    # 在类中定义一些特殊方法（魔术方法）
    # 特殊方法都是以__双下线开头和结尾__的方法
    # 特殊方法不需要我们自己调用，不要尝试去调用特殊方法
    # 特殊方法将会在特殊的时刻自动调用
    # 学习特殊方法：
    #     1.特殊方法什么时候调用
    #     2.特殊方法有什么用
    # 创建对象的流程：
    # p1 = Person()的运行流程
    # -1: 类被调用及执行且执行一次：执行类的代码块中的代码（只在类定义的时候执行一次）
    # ① 创建一个变量mc
    # ② 在内存中创建一个新的对象
    # ③ __init__(self)方法执行
    # ④ 将对象的id赋值给变量p1

    # init会在对象创建以后立即执行
    # 每创建一次init就执行一次
    # init 可以向新创建的对象中初始化属性
    # 调用类创建对象时，类后边的所有参数都会依次传递到init()中
    def __init__(self,name):
        print(self) #<__main__.Preson object at 0x000001F59CE0C108>
        print('init方法执行！！')
        # 通过self向新建的对象中初始化属性
        self.name = name

    def say_hello(self):
        print('大家好，我是%s'%self.name)

# 目前来讲，对于Preson类来说name是必须的，并且每一个对象中的name属性基本上都是不同的
# 而且我们现在是将name属性在定义为对象后，手动添加到对象中，这种方式很容易出现错误
# 我们希望，在创建对象时，必须设置name属性，如果不设置对象将无法创建
#   并且属性的创建应该是自动完成的，而不是在创建对象以后手动完成的

p1 = Preson('name')
# 手动向对象中添加name属性
# p1.name = 'sunwukong'

p2 = Preson('wukong')
# p2.name = 'zhubajie'
#
# p3 = Preson()
#     print('大家好，我是%s'%self.name)
# AttributeError: 'Preson' object has no attribute 'name'
# p3.say_hello()
# p1.say_hello('悟空')
p1.say_hello()

类的定义

- 类和对象都是对现实生活的事物或程序中的内容的抽象
- 实际上所有的事物由两部分构成：
    1.数据（属性）
    2.行为（方法）

- 在类的代码块中，我们可以定义变量和函数，
    变量会成为该类实例的公共属性，所有的该类实例都可以通过：对象.属性名 的形式访问
    函数会成为该类实例的公共方法，所有该类实例都可以通过：对象.方法名() 的形式调用方法
    
- 注意：
    方法调用时，默认会传递一个参数，第一个参数由解析器自动传递，
    所以定义方法时，至少要定义一个形参！

- 实例为什么能访问到类中的属性和方法？
    类中定义的属性和方法都是

定义类

# 尝试定义一个表示人的类
class Person:
    # pass
    # 在类的代码块中，我们可以定义变量和函数
    # 在类中我们所定义的变量，将会成为所有的实例的公共属性
    # 所有实例都可以访问这些变量
    name = 'swk' # 公共属性， 所有实例都可以访问

#     在类中也可以定义函数，类中定义的函数，我们称为方法
#     这些方法可以通过该类的所有实例来访问
    def say_hello(self):
        # 方法每次调用时，解析器都会自动传递第一个实参
        # 第一个参数，就是调用方法的对象本身
        #   如果是p1调用，则第一个参数就是p1对象
        #   如果是p2调用，则第一个参数就是p2对象
        # 一般我们都会将这个参数命名为self

        # say_hello()这个方法，可以显示如下各式的数据：
        #   你好！我是XXX
        #   在方法中不能直接访问法类中的属性
        print('nihao! %s'%self.name)

# 创建Person的实例
p1 = Person()
p2 = Person()
p1.name = '123'
print(p1.name)

# 调用方法，对象.方法名()
# 方法调用和函数调用的区别
# 如果是函数调用，则调用时传递几个参数，就会有几个参数
# 但是如果是方法调用，默认传递一个参数，所以方法中至少要定义一个形参
#     def say_hello():
#         print('nihao!')
# p1.say_hello()
# TypeError: say_hello() takes 0 positional arguments but 1 was given
p1.say_hello()

类的基本结构

class 类名([父类]) :
    
    公共属性...
    
    # 对象的初始化方法
    def __init__(self,...) :
        ...
    
    # 其他方法
    def method_1(self,...) :
        ...
    def method_2(self,...) :
        ...
        
    ...
    
- 练习：
    尝试自定义一个表示狗的类(Dog)        
        属性：
            name
            age
            gender
            height
            ...
        方法：
            jiao()
            yao()
            run()
            ...

练习

class Dog:
    '''
    表示狗的类
    '''

    def __init__(self,name,age,gender,height):
        self.name = name
        self.age = age
        self.gender = gender
        self.height = height

    def jiao(self):
        '''
        狗叫的方法
        :return:
        '''
        print('汪汪汪！')
    def yao(self):
        '''
        狗咬的方法
        :return:
        '''
        print('狗咬你！')
    def run(self):
        '''
        狗跑的方法
        :return:
        '''
        print('快乐的奔跑！%s'%self.name)


# 目前我们可以直接通过 对象.属性 的方式来修改属性的值，这种方式导致对象中的属性可以随意修改
#   非常不安全，值可以任意修改，不论对错
# 现在我们需要一种方式来增强数据的安全性
#     1.属性不能随意修改（我让你改你才能改，不让你改你就不能改）
#     2.属性不能修改为任意的值（年龄不能是负数）
d = Dog('旺财',3,'男','1m')
d.run()
d.yao()

封装

# 封装是面向对象的三大特性之一
# 封装指的是隐藏对象中一些不希望被外部所访问的到的属性和方法
# 如何隐藏一个对象中的属性？
#   - 弱安全：将对象的属性名，修改为一个外部不知道的名字
#   -
# 如何获取（修改）对象中的属性？
#   - 需要提供一个getter和setter方法使外部可以访问到属性
#   - getter 获取对象中的指定属性（get_属性名）
#   - setter 用来设置对象的指定属性（set_属性名）
# 使用封装，确实增加了类的定义的复杂程度，但是他也确保了数据的安全性
#   1.隐藏了属性名，使调用者无法随意的修改对象中的属性
#   2.增加了getter和setter方法，很好的控制了属性是否是只读的
#       如果希望属性是只读的，则可以直接去掉setter方法
#       如果希望属性不能被外部访问到，则可以直接去掉getter方法
#   3.使用setter方法设置属性，可以增加数据的验证，确保数据的值是正确的
#   4.使用getter方法获取属性，使用setter方法设置属性，
#     可以在读取属性和修改属性的同时做一些其他的处理

# 封装：
#   1.隐藏属性名
#   2.通过getter()方法去读取属性，通过setter方法去设置属性


class Dog:
    '''
    表示狗的类
    '''

    def __init__(self,name,age,gender,height):
        self.hidden_name = name
        self.hidden_age = age

    def say_hello(self):
        print('hello,大家好，我叫%s'%self.hidden_name)
    def get_name(self):
        '''
        get_name()用来获取对象的name属性
        :return:
        '''
        return self.hidden_name
    def set_name(self, name):
        self.hidden_name = name

    def get_age(self):
        return self.hidden_age

    def set_age(self,age):
        self.hidden_age = age
d = Dog("啦啦",17,"woman",150)
# d.hidden_name = '昊哥'
# 调用setter来修改name属性
d.set_name('元宝')
d.age = 18
d.gender = "man"
d.height = 180
d.say_hello()
print(d.hidden_name)

class Rectangle:
    '''
        表示矩形的类
    '''
    def __init__(self,width,height):
        self.hidden_width = width
        self.hidden_height = height

    def get_width(self):
        return self.hidden_width
    def set_width(self,width):
        self.hidden_width = width

    def get_height(self):
        return self.hidden_height
    def set_height(self,height):
        self.hidden_height = height

    def get_area(self):
        return self.hidden_width * self.hidden_height

# r = Rectangle(2,4)
# r.set_height(5)
# r.set_width(3)
# print(r.get_area())

# 可以为对象的属性使用双下划线开头，__xxx
# 双下滑线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
# 其实隐藏属性只不过是python自动为属性改了一个名字
#   实际上是将名字修改为了， _类名__属性名   比如：__name  -> _Person__name
class Person:
    def __init__(self,name):
        self.hidden_name = name
    def get_name(self):
        return self.hidden_name
    def set_name(self,name):
        self.hidden_name = name

p = Person('孙悟空')
p.hidden_name = '沙和尚'
print(p.get_name())

# 使用双下滑开头的属性，实际上依然可以在外部访问，所以这种方式我们一般不用
# 一般我们会将一些私有属性（不希望被外部访问的属性）以_开头
class Person2:
    def __init__(self,name):
        self.__name = name
    def get_name(self):
        return self.__name
    def set_name(self,name):
        self.__name = name

p = Person2('孙悟空')
# print(p.__name) # __开头的属性是隐藏属性，无法通过对象访问
# print(p.__name)
# AttributeError: 'Person' object has no attribute '__name'
p.__name = 'zhubaojie' # 修改未生效
# print(p.__Person__name)
p._Person2__name = 'zhuwukong' # 修改生效
print(p.get_name())

# 开发中常用写法
# 一般我们会将一些私有属性（不希望被外部访问的属性）以_开头
class Person3:
    def __init__(self,name):
        self._name = name
    def get_name(self):
        return self._name
    def set_name(self,name):
        self._name = name

class Person:
    def __init__(self,name):
        self._name = name

    # 使用property装饰器，用来将一个get方法，转换为对象的属性
    # 添加为property装饰器以后，我们就可以像调用属性一样使用get方法
    # 使用property装饰的方法，必须和属性名是一样的

    @property
    def name(self):
        print('get方法执行了')
        return self._name
    # setter方法的装饰器：@属性名.setter
    @name.setter
    def name(self,name):
        self._name = name

p = Person('猪八戒')
print(p.name)

继承

# 继承
# 定义一个类Animal(动物)
#   这个类中需要两个方法：run() sleep()

class Animal:
    def run(self):
        print('动物会跑')
    def sleep(self):
        print('动物睡觉')
    # def brak(self):
    #     print('动物会叫')
# 定义一个类Dog(狗)
#   这个类中需要三个方法：run() sleep() bark()
# class Dog:
#     def run(self):
#         print('dog会跑')
#     def sleep(self):
#         print('dog睡觉')
#     def brak(self):
#         print('dog会叫')
# 有一个类，能都实现我们需要的大部分功能，但是不能实现全部功能
# 如何能让这些类实现全部的功能呢？
#   ① 直接修改这个类，在这个类中添加我们需要的功能
#         - 修改起来会比较麻烦，并且违反了OCP原则
#   ② 直接创建一个新的类
#         - 创建一个新的类比较麻烦，并且需要大量的进行复制粘贴，会出现大量的重复性代码
#   ③ 直接从Animal类中继承他的属性和方法
#         - 继承是面向对象的三大特性之一
#         - 通过继承我们可以使一个类获取到其他类中的属性和方法
#         - 在定义类时，可以在类名后边的括号中指定当前类的父类（超类，基类，super）
#             子类（衍生类）可以直接继承父类中的所有的属性和方法
# 通过继承可以直接让子类获取到父类的方法和属性，避免编写重复性代码，也符合OCP原则
#   所以我们经常通过继承来对也给类进行扩展

class Dog(Animal):
    def brak(self):
        print('dog会叫')

class Hashiqi(Dog):
    def brak(self):
        print('哈士奇')

d = Dog()
d.run() # 动物会跑
d.sleep() # 动物睡觉
d.brak() # dog会叫
h = Hashiqi()
h.brak() # 哈士奇

# isinstance()  # 检查一个对象是否是一个类的实例
#   如果这个类是这个对象的父类，也会返回True
#   所有的对象都是object的实例
r = isinstance(d , Dog) # True
r = isinstance(d , Animal) # True

print(r) # True

# 创建类时，如果省略了父类，则默认父类为object
#   object是所有类的父类，所有类都继承自object
class Person(object):
    pass

# issubclass() #检查一个类是否是另一个类的子类
print(issubclass(Animal,Dog)) #False
print(issubclass(Animal,object)) #True
print(issubclass(Person,object)) #True

print(isinstance(print,object)) # True

class Animal:
    def __init__(self,name):
        self._name = name
    def run(self):
        print('动物会跑')
    def sleep(self):
        print('动物睡觉')

    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name

# 父类中的所有方法都会被子类继承，包括特殊方法
# 也可以重写特殊方法
class Dog(Animal):
    def __init__(self,name,age):
        # 希望可以直接使用父类的__init__来初始化父类中定义的属性
        # super()可以动态获取当前类的父类
        #   并且通过super()返回对象调用父类方法时，不需要传递self
        # Animal.__init__(self,name)
        super().__init__(name)
        self._age = age
    def brak(self):
        print('dog会叫')
    def run(self):
        print('dog会跑')

d = Dog('猪八戒',12)
d.name = '猪八戒'
print(d.name)

重写

class Animal:
    def run(self):
        print('动物会跑')
    def sleep(self):
        print('动物睡觉')

class Dog(Animal):
    def brak(self):
        print('dog会叫')
    def run(self):
        print('dog会跑')

# 如果在子类中如果有和父类同名的方法，则通过子类实例去调用方法时，
#   会调用子类的方法而不是父类的方法，这个特点我们称为方法的重写（覆盖，override）

# 创建Dog类的实例
d = Dog()

d.run() # dog会跑

# 当我们调用一个对象的方法时，会优先去当前对象中寻找是否具有该方法
# 如果有则调用，如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
# 如果没有则去父类的父类中寻找，以此类推，直到找到object，如果依然没有找到，则报错

多重继承

class Animal:
    def run(self):
        print('动物会跑')
    def sleep(self):
        print('动物睡觉')

class Dog(Animal):
    def brak(self):
        print('dog会叫')
    def run(self):
        print('dog会跑')

class A(object):
    def test(self):
        print('Aaa')

class B(object):
    def test2(self):
        print('Baa')

# 在python中是支持多重继承的，也就是我们可以为一个类同时指定多个父类
#   可以在类名的()后边添加多个类，来实现多重继承
#   多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
# 在开发中没有特殊情况，应该尽量避免使用多重继承，因为多重继承会让我们的代码国语复杂
# 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后到第二个中寻找，然后是第三个。。。
#   前边父类的方法会覆盖后边父类的方法
class C(A,B):
    pass

# 类名.__bases__这个属性可以用来获取当前类的所有父类
print(A.__bases__) #(,)
print(C.__bases__) #(, )

c = C()

c.test()
c.test2()

多态

# 多态是面向对象的三大特征之一
# 多态从字面上理解是多种形态
# 狗（狼狗，奶狗，哈士奇，柴犬。。。）
# 一个对象可以有多种不同的形态去呈现

# 定义两个类

class A:
    def __init__(self,name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class B:
    def __init__(self,name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class C:
    pass

a = A('wukong')
b = B('zhubajie')
c = C()
# 定义一个函数
# 对于say_hello()这个函数来说，只要对象中含有name属性，他就可以作为参数传递
#   这个函数并不会考虑对象的类型，只要有name属性即可

def say_hello(obj):
    print('你好%s'%obj.name)

# say_hello(a) # 你好wukong
# say_hello(c) # 你好zhubajie
#     print('你好%s'%obj.name)
# AttributeError: 'C' object has no attribute 'name'

# 在say_hello_2中我们做了类型检查，也就是只有obj是A 类型的对象时，才可以正常使用
#   其他类型的对象都无法使用该对象
def say_hello_2(obj):
    # 做类型检查
    if isinstance(obj,A):

        print('你好%s'%obj.name)

say_hello_2(b) # 执行结果为空，没有打印任何信息

# 鸭子类型
# 如果一个东西，走路像鸭子，叫声像鸭子，那么他就是鸭子

# len()
# 之所以一个对象能通过len()来获取长度，是因为对象中具有一个特殊方法__len__
# 换言之，只要对象中具有__len__特殊方法，就可以通过len()来获取他的长度
l = [1,2,3]
s = 'hello'

print(len(l))
print(len(s))
# print(len(b))
# print(len(c))

# 面向对象的三大特征：
#   封装：
#     - 保证了对象中的数据安全性
#   继承:
#     - 保证了对象的可扩展性
#   多态：
#     - 保证了程序的灵活性

类中的属性和方法

# 定义一个类
class A(object):

    # 类属性
    # 实例属性
    # 类方法
    # 实例方法
    # 静态方法

    # 类属性，直接在类中定义的属性叫类属性
    #   类属性可以通过类或类的实例访问到
    #   但是类属性只能通过类对象来修改，无法通过实例对象修改
    conut = 0

    def __init__(self):
        # 实例属性，通过实例对象添加的属性是实例属性
        #   实例属性只能通过实例对象来访问和修改，类对象无法访问修改
        self.name = 'sunwukong'

        # 实例方法
        #   在类中定义，以self为第一个参数的方法就是实例方法
        #   实例方法在调用时，python会将调用对象作为self传入
        #   实例方法可以通过实例和类去调用
        #       当通过实例调用时，会自动将当前调用的对象作为self传入
        #       当通过类调用时，不会自动传递self，此时我们必须手动传递self

    def test(self):
        print('这是test方法',self)

    # 类方法
    # 在类内部使用 @classmethod来修饰的方法属于类方法
    # 类方法的第一个参数时cls,也会被自动传递，cls就是当前类的对象
    #   类方法和实例方法的区别：
    #     实例方法的第一个参数时self,而类方法的第一个参数时cls
    #     类方法可以通过类去调用，也可以通过实例调用，没有区别
    @classmethod
    def test_2(cls):
        print('test_2执行了，这是一个类方法',cls)
        print(cls.conut)

    # 静态方法：
    # 在类中使用@staticmethod来修饰的方法属于静态方法
    # 静态方法不需要指定任何的默认参数，静态方法可以通过类和实例去调用
    # 静态方法，基本上是一个和当前类无关的方法，他只是一个保存到当前类中的函数
    # 静态方法一般都是一些工具方法，和当前类无关
    @staticmethod
    def test_3():
        print("这是test_3静态类执行了")

a = A()
# 实例属性，通过实例对象添加的属性属于实例属性
a.conut = 10
A.conut = 100

print('a',a.conut) # a 10
print('A',A.conut) # A 100

print('a',a.name) # a sunwukong
# print('A',A.name)
# print('A',A.name)
# AttributeError: type object 'A' has no attribute 'name'

a.test() # 等价于 A.test(a)   这是test方法 <__main__.A object at 0x000002E58321B548>
A.test_2() # 等价于 a.test_2()   test_2执行了，这是一个类方法 
A.test_3() # 这是test_3静态类执行了
a.test_3() # 这是test_3静态类执行了

垃圾回收

# 垃圾回收
# 就像我们生活中会产生垃圾一样，程序在运行过程中产生的垃圾
# 程序运行过程中产生的垃圾，会影响到程序的运行的运行性能，所以这些垃圾必须被及时清理
# 没用的东西就是垃圾
# 在程序中没有被引用的对象就是垃圾
#   所以我们必须进行及时的垃圾回收，所谓的垃圾回收就是将垃圾对象从内存中删除
# 在python中有自动的垃圾回收机制，他会自动将这些没有被引用的对象删除
#   所以我们不用手动处理垃圾回收
class A:
    def __init__(self):
        self.name = 'A类'

    # del是一个特殊方法，他会在对象被垃圾回收前调用
    def __del__(self):
        print('A()对象被删除了',self)
a = A()
b = a # 又引用了一个变量b，来引用a对应的对象
print(a.name)

a = None # 将a变量设置为了None，此时没有任何变量对A()对象进行引用，A()就变成了垃圾
# b = None

# del a # del 删除的是变量a,类对象A()还在被b变量引用，所以需要把b变量一起删除，A()对象才会被释放
# del b

input('回车键退出。。。')

# A类
# 回车键退出。。。
# A()对象被删除了 <__main__.A object at 0x000001BF48E45E08>

特殊方法

# 特殊方法 ： 也称为魔术方法
#   特殊方法都是用__开头和结尾的
# 特殊方法一般不需要我们手动执行，需要在一些特殊情况下自动执行

# 定义一个Person类
class Person(object):
    '''
        人类
    '''
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # __str__()这个特殊方法会在尝试将对象转换为字符串的时候调用
    #   它的作用可以用来指定对象转换为字符串的结果（print函数）
    def __str__(self):
        return 'Person [name=%s,age=%d]'%(self.name,self.age)

    # ___repr__()这个特殊方法会在当前对象使用repr()函数的时候调用
    #   它的作用是指定对象在'交互模式'中直接输出的效果
    def __repr__(self):
        return 'hello'

    def __lt__(self, other):
        print('比较年龄大小')
        return self.age < other.age

    # object.__bool__(self)
    def __bool__(self):
        print('年龄大于17岁返回True')
        return self.age > 17

# 创建两个Person实例
p1 = Person('孙悟空',12)
p2 = Person('猪八戒',123)

# 打印p1
# 当我们打印一个对象时，实际上打印的对象中的特殊方法  __str__() 的返回值
print(p1) # <__main__.Person object at 0x0000021756F45D08>
# 重写__str__()方法后
print(p1) # Person [name=孙悟空,age=12]
print(p2) # Person [name=猪八戒,age=123]

print(p1 > p2)
#     print(p1 > p2)
# TypeError: '>' not supported between instances of 'Person' and 'Person'
# 需要添加定义指定的特殊方法
#  object.__lt__(self, other) 小于 <
# object.__le__(self, other) 小于等于 <=
# object.__eq__(self, other) 等于  ==
# object.__ne__(self, other)不等 !=
# object.__gt__(self, other) 大于 >
# object.__ge__(self, other) 大于等于 >=
print(p2 > p1)
# 比较年龄大小
# True

print(bool(p1))
# 年龄大于17岁返回True
# False

if p1:
    print(p1.name,'年龄大于17岁返回True')
else:
    print(p1.name,'年龄小于17岁返回Flase')

模块

# 模块（module）
# 模块化，模块化指将一个完整的程序分解为一个一个小的模块
#   通过将模块组合，来搭建出一个完整的程序
# 不采用模块化，统一将所有的代码编写到一个文件中
# 采用模块化，将程序分别编写到多个文件中
#   模块化的优点：
#       ① 方便开发
#       ② 方便维护
#       ③ 模块可以复用！！

# 在python中，一个py文件就是一个模块，要想创建模块，实际上就是创建一个Python文件
# 注意：模块名要符合标识符的规范

# 如何引入外部模块
# 在一个模块中引入外部模块
# ① import 模块名 （模块名，就是Python文件的名字，注意不要py后缀）
# ② import 模块名 as 模块别名
#   - 可以引入同一个模块多次，但是模块的实例只会创建一个
#   - import 可以在程序的任意位置调用，但是一般情况下，import语句都会统一写在程序的开头
#   - 在每一个模块内部都有一个__name__属性，通过这个属性可以获取到模块的名字
#   - __name__属性值为__main__的模块是主模块，一个程序中只会有一个主模块
#       主模块就是我们直接通过python执行的模块
# import test_module
# import test_module
# import test_module
# import test_module
import test_module as test
# 运行输出test_module
# print(test) # 

print(test.__name__) # test_module
print(__name__) # __main__  主模块的__name__输出的是__main__

# import m

# 访问模块m中的变量：模块名.变量名
# print(m.a,m.b)
# m.test()
# m.test2()

# print(p.name)
#     print(p.name)
# NameError: name 'p' is not defined

def test2():
    print('这是主模块中的test2')

# 也可以只引入模块中的部分内容
# 语法：
#   from 模块名 import 变量,变量...
# from m import Person

# m = Person()
# print(m) # 
# test2() # 这是主模块中的test2

# from m import test
# test() # test

# from m import Person,test
# m = Person()
# print(m)
# test()
# 
# test

# from m import * # 引入到模块中所有内容，一般不会使用
# 当主模块中也有相同的test2()方法时，引入模块的test2()方法会覆盖掉主模块中的test2()方法
# test2() # test2

# 也可以为引入的变量使用别名，解决重名被覆盖的问题
# 语法：
#   from 模块名 import 变量 as 别名
# from m import test2 as new_test2
# test2() # 这是主模块中的test2
# new_test2() # test2

# import m
# print(m._c) # 35

from m import *
# print(a,b) # 12 13
# print(_c)
#     print(_c)
# NameError: name '_c' is not defined

# import xxx
# import xxx as yyy
# from xxx import yyy,zzz,fff
# from xxx import *
# from xxx import yyy as zzz

包

# 包 Package
# 包也是一个模块
# 当我们模块中代码过多时，或者一个模块需要被分解为多个模块时，这时候就需要使用到包
# 普通的模块就是一个py文件，而包是一个文件夹
#   包中必须要有一个一个__init__.py这个文件，这个文件中可以包含有包中的主要内容

# import hello

# print(hello) # 
# print(hello.a)
# print(hello.b)
# hello.test()

from hello import a,b
print(a)
# 
print(b)
# 
print(a.e) # 12

print(b.d) # 13

# __pycache__是模块的缓存文件
# py代码在执行前，需要被解析器先转换为机器码，然后在执行
#   所以我们在使用模块（包）时，也需要将模块的代码先转换为机器码然后再交由计算机执行
#   而是为了提高程序运行的性能，Python会在编译过一次以后，将代码保存到一个缓存文件中
#   这样在下次加载这个模块（包）时，就可以不再重新编译而是直接加载缓存中编译好的代码即可

Python的标准库

# 开箱即用
# 为了实现开箱即用的思想，Python中为我们提供了一个模块的标准库
# 在这个标准库中，有很多很强大的模块，我们可以直接使用，
#   并且标准库会随Python的按装一同按装
# sys模块，他里边提供了一些变量和函数，使我们可以获取到Python解析器的信息
#   或者通过函数来操作Python解析器
# 引入sys模块
import sys

# pprint 模块它给我们提供了一个
import pprint

# sys.argv
# 获取执行代码时，命令行中所包含的参数
# 该属性是一个列表，列表中保存了当前命令的所有参数
# print(sys.argv)
# ['D:/python-workspace/python-base/huan/lesson_06/nineteen_Python的标准库.py']

# sys.modules
# 获取当前程序中引入的所有模块
# modules是一个字典，字典的key是模块的名字，字典的value是模块的对象
# print(sys.modules)
# {'sys': , 'builtins': , '_frozen_importlib': , '_imp': , '_thread': , '_warnings': , '_weakref': , 'zipimport': , '_frozen_importlib_external': , '_io': , 'marshal': , 'nt': , 'winreg': , 'encodings': , 'codecs': , '_codecs': , 'encodings.aliases': , 'encodings.utf_8': , '_signal': , '__main__': , 'encodings.latin_1': , 'io': , 'abc': , '_abc': , 'site': , 'os': , 'stat': , '_stat': , '_collections_abc': , 'ntpath': , 'genericpath': , 'os.path': , '_sitebuiltins': , '_bootlocale': , '_locale': , 'encodings.gbk': , '_codecs_cn': , '_multibytecodec': , '_distutils_hack': , 'sitecustomize': }

# pprint.pprint(sys.modules)

# {'__main__': ,
#  '_abc': ,
#  '_bootlocale': ,
#  '_codecs': ,
#  '_codecs_cn': ,
#  '_collections': ,
#  '_collections_abc': ,
#  '_distutils_hack': ,
#  '_frozen_importlib': ,
#  '_frozen_importlib_external': ,
#  '_functools': ,
#  '_heapq': ,
#  '_imp': ,
#  '_io': ,
#  '_locale': ,
#  '_multibytecodec': ,
#  '_operator': ,
#  '_signal': ,
#  '_sitebuiltins': ,
#  '_sre': ,
#  '_stat': ,
#  '_thread': ,
#  '_warnings': ,
#  '_weakref': ,
#  'abc': ,
#  'builtins': ,
#  'codecs': ,
#  'collections': ,
#  'copyreg': ,
#  'encodings': ,
#  'encodings.aliases': ,
#  'encodings.gbk': ,
#  'encodings.latin_1': ,
#  'encodings.utf_8': ,
#  'enum': ,
#  'functools': ,
#  'genericpath': ,
#  'heapq': ,
#  'io': ,
#  'itertools': ,
#  'keyword': ,
#  'marshal': ,
#  'nt': ,
#  'ntpath': ,
#  'operator': ,
#  'os': ,
#  'os.path': ,
#  'pprint': ,
#  're': ,
#  'reprlib': ,
#  'site': ,
#  'sitecustomize': ,
#  'sre_compile': ,
#  'sre_constants': ,
#  'sre_parse': ,
#  'stat': ,
#  'sys': ,
#  'types': ,
#  'winreg': ,
#  'zipimport': }

# sys.path
# 他是一个列表，列表中保存的是模块的搜索路径
# pprint.pprint(sys.path)
# ['D:\\python-workspace\\python-base\\huan\\lesson_06',
#  'D:\\python-workspace\\python-base',
#  'F:\\Program Files\\PyCharm 2020.1\\plugins\\python\\helpers\\pycharm_display',
#  'F:\\python\\py\\python37.zip',
#  'F:\\python\\py\\DLLs',
#  'F:\\python\\py\\lib',
#  'F:\\python\\py',
#  'D:\\python-workspace\\python-base\\huan',
#  'D:\\python-workspace\\python-base\\huan\\lib\\site-packages',
#  'F:\\Program Files\\PyCharm '
#  '2020.1\\plugins\\python\\helpers\\pycharm_matplotlib_backend']

# sys.platform
# 表示当前Python运行的平台
# print(sys.platform)
# win32

# sys.exit()
# 函数用来退出程序
# sys.exit('程序异常退出程序')

# os 模块让我们可以操作系统进行访问
import os

# print(os)
# 

# os.environ 通过这个属性可以获取到系统的环境变量
# print(os.environ)
# pprint.pprint(os.environ['path'])

# os.system()
# 可以用来执行操作系统的名字
os.system('dir') # 显示目录
os.system('notepad') # 打开记事本