模块

模块中写全局变量

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

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

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

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

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

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

image.png

name

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

image.png

访问模块私有的属性

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

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

  1. #文件名:test.py
  2. import mtest
  3. print(mtest._pnumber)

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

  1. #文件名:test.py
  2. from mtest import _pnumber
  3. 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
  5. # 一个方法,只要调用这个方法就会生成一个
  6. # 新的类属性
  7. def add_number3(self):
  8. Student.class_number3 = 200
  9. obj = Student()
  10. print(Student.__dict__) #__dict__是一个字典,保存了当前的实例或者对象
  11. # 中的所有属性,包括函数和内置属性和自定义属性
  12. print(obj.__dict__)

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

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

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

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

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

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

image.png

实例属性

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

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

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

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

image.png