模块

模块中写全局变量

  1. # 文件名：mtest.py
  2. #在 Python 下 py 后缀名的文件就是模块
  4. g_number1 = 100
  5. g_number2 = 100

使用 import 可以直接导入模块，导入模块的同时会执行其中的代码，但是同一个模块的代码不论直接 import 多少次，都只执行一次, 

  1. # 文件名：test.py
  3. # 类似于 C++ 中的 include 没有使用命名空间
  4. import m
  5. print(m.g_number1)
  7. # 类似 C++ 中 inlcude + using std::xxx 指令
  8. # 最推荐使用的方式，但是使用较为繁琐
  9. from m import g_number1
  10. print(g_number1)
  12. # 类似于 include + using namesapce xxx 直接
  13. # 使用指定模块内的所有对象不需要加模块名
  14. from m import *
  15. print(g_number1)

image.png
拓展：
import ..　　　　 　　　　#导入整个模块
from .. import ..　　　　　 #导入模块中的类、函数或者变量
from .. import 　　　　　#导入模块中的所有*公开成员
from .. import .. as ..　　 #这个是给导入的成员取个别名

测试模块是被导入的还是不被导入的

  1. # 文件名：mtest.py
  3. def main():
  4.     # 如果当前模块不是被导入的，那么这就是主模块
  5.     print("这里是主函数，需要在当前为主模块的时候被执行")
  6. def nomain():
  7.     #如果当前模块是被导入的，那么这就不是主模块
  8.     print("该模块是被导入的")
  10. # 模仿主函数的行为，如果当前模块为主模块，那么 __name__
  11. # 这个全局变量中就会保存 __main__ 字符串
  12. if __name__ == "__main__":
  13.     main()
  14. else:
  15.     nomain()
  1. # 文件名：test.py
  3. import mtest

image.png

name

  1. # 文件名：mtest.py
  3. # 写在全局范围内的代码无论如何都会被执行
  4. # 如果是被导入的模块，那么 __name__ 就是
  5. # 模块名，去除后缀的文件名称
  6. print(__name__)
  1. #文件名：test.py
  3. import mtest

image.png

访问模块私有的属性

  1. #文件名：mtest.py
  3. # 模块的私有属性(不会被直接访问到的)
  4. # 以单下划线开头的全局变量不能被其它
  5. # 模块以 from xxx import * 的方式访问
  7. _pnumber = 10

可以通过import mtest方式导入访问(注意用模块名点出来)

  1. #文件名：test.py
  3. import mtest
  4. print(mtest._pnumber)

可以通过from mtest import _pnumber方式导入访问

  1. #文件名：test.py
  3. from mtest import _pnumber
  4. print(_pnumber)

类

构造与析构

class 类名(基类名称):
在 Python3 中所有的类都默认继承自 object

  1. class Student(object):
  2.     # 所有的构造函数都叫做 __init__
  3.     def __init__(self):
  4.         pass
  5.     # 所有的析构函数都叫做 __del__
  6.     def __del__(self):
  7.         pass
  8.     # 如果不编写这两个函数，会默认生成

类属性

1.类和对象的区别：主要是类属性和实例属性的区别

  1. class Student(object):
  2.     # 在类的作用域中直接编写的属性就是类属性
  3.     # 类属性类似于 C++ 中的静态数据成员
  4.     class_number = 0
  6.     # 一个方法，只要调用这个方法就会生成一个
  7.     # 新的类属性
  8.     def add_number3(self):
  9.         Student.class_number3 = 200
  11. obj = Student()
  13. print(Student.__dict__)             #__dict__是一个字典，保存了当前的实例或者对象
  14.                                     # 中的所有属性，包括函数和内置属性和自定义属性
  15. print(obj.__dict__)

image.png
2.访问类属性
可以使用类名和实例访问到类属性，推荐使用类名

  1. class Student(object):
  2.     # 在类的作用域中直接编写的属性就是类属性
  3.     # 类属性类似于 C++ 中的静态数据成员
  4.     class_number = 0
  6.     # 一个方法，只要调用这个方法就会生成一个
  7.     # 新的类属性
  8.     def add_number3(self):
  9.         Student.class_number3 = 200
  11. obj = Student()
  13. print(obj.class_number, Student.class_number)
  15. print(Student.__dict__)
  16. print(obj.__dict__)

image.png
3.修改类属性
使用类名可以直接修改类属性，如果尝试使用实例修改类属性，本质上是给实例添加了一个自己的属性

  1. class Student(object):
  2.     # 在类的作用域中直接编写的属性就是类属性
  3.     # 类属性类似于 C++ 中的静态数据成员
  4.     class_number = 0
  6.     # 一个方法，只要调用这个方法就会生成一个
  7.     # 新的类属性
  8.     def add_number3(self):
  9.         Student.class_number3 = 200
  11. obj = Student()
  13. Student.class_number=99
  14. obj.class_number=98
  16. print(obj.class_number, Student.class_number)
  18. print(Student.__dict__)
  19. print(obj.__dict__)

image.png
4.添加类属性
可以在成员方法或类外使用类名动态的添加属性

  1. class Student(object):
  2.     # 在类的作用域中直接编写的属性就是类属性
  3.     # 类属性类似于 C++ 中的静态数据成员
  4.     class_number = 0
  6.     # 一个方法，只要调用这个方法就会生成一个
  7.     # 新的类属性
  8.     def add_number3(self):
  9.         Student.class_number3 = 200
  11. obj = Student()
  13. Student.class_number2 = 100
  14. print(Student.__dict__)
  15. print(obj.__dict__)
  17. obj.add_number3()
  18. print(Student.__dict__)
  19. print(obj.__dict__)

image.png

实例属性

1.实例属性就是使用 self 或者 实例名 定义出来的属性，每一个实例都会拥有自己的实例属性，同样可以使用类名或者 self 动态添加属性

  1. class Student(object):
  2.     # 构造函数中添加的实例属性是每一个实例都有的
  3.     def __init__(self):
  4.         self.number = 10
  6.     # 调用这个函数会动态添加属性
  7.     def add_number2(self):
  8.         self.number2 = 20
  10. # 创建两个实例分别测试
  11. object1 = Student()
  12. object2 = Student()
  13. print(object1.__dict__, "\n", object2.__dict__)
  15. # 动态的使用 self 添加属性
  16. object1.add_number2()
  17. print(object1.__dict__, "\n", object2.__dict__)
  19. # 动态的使用 实例名称 添加属性
  20. object2.number3 = 30
  21. print(object1.__dict__, "\n", object2.__dict__)

image.png
此时类属性并没有增加
image.png
2.删除一个属性

  1. class Student(object):
  2.     # 构造函数中添加的实例属性是每一个实例都有的
  3.     def __init__(self):
  4.         self.number = 10
  6.     # 调用这个函数会动态添加属性
  7.     def add_number2(self):
  8.         self.number2 = 20
  10. # 创建两个实例分别测试
  11. object1 = Student()
  12. object2 = Student()
  14. # 动态的使用 self 添加属性
  15. object1.add_number2()
  17. # 动态的使用 实例名称 添加属性
  18. object2.number3 = 30
  20. #del object1.number2
  21. #print(object1.__dict__, "\n", object2.__dict__)
  24. print(object1.__dict__, "\n", object2.__dict__)
  25. del object2.number3
  26. print(object1.__dict__, "\n", object2.__dict__)

image.png