一、基础内容
1、什么叫模块——由代码组成的单独的文件就是模块
2、模块导入方式
import 模块名，调用时要用到 ‘模块名.函数名’form 模块名 import 函数名（或者改为*，调用模块里面所有的函数，易出错），当多个模块一起导入，并且函数名称相同时会出现命名冲突，此时后面模块的函数会把之前模块的同名函数覆盖。import 模块名 as 自己喜欢的标志
3、举例：将下列程序另存为一个文件就可以在编程的时候调用Const（）函数
class Const:
def __setattr__(self,name,value):
if name in self.__dict__:
raise TypeError('常数不能修改！')
if not name.isupper():
raise TypeError('常量名必须是大写！')
self.__dict__[name] = value #将value的值传入const.NAME
import sys
sys.modules [__name__] = Const() #将模块与对象挂钩。导入的模块就变成了对象
4、测试环节，在实际的操作中，每一个模块都需要自我测试，会在后面附带一段测试代码，如何使实际运行时不会运行测试代码？if __name__ == '__main__'
以下通俗解释摘自 https://blog.csdn.net/yjk13703623757/article/details/77918633
通俗的理解__name__ == '__main__'：
假如你叫小明.py，在朋友眼中，你是小明(__name__ == '小明')；
在你自己眼中，你是你自己(__name__ == '__main__')。
if __name__ == '__main__'的意思是：
当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；
当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。
def c2f(cel):
fah = cel*1.8 + 32
return fah
def f2c(fah):
cel = (fah-32)/1.8
return cel
def test():
print('0摄氏度等于%d的华氏度' % (f2c(0)))
print('0华氏度等于%d的摄氏度' % (c2f(0)))
if __name__ == '__main__': #自己运行时，运行测试
#当作为一个模块时，不运行
test()
5、
利用sys.path来寻找路径，sys.path.append(具体路径)来增加路径
利用包，将模块分别打包利于管理。就是单独用文件夹保存，并且包里面必须新建一个名为__init__.py的文件，作为区分包与普通文件夹，在导入模块的时候需要在模块前面加上包的名字
6、利用document文件去学习模块，但实际文档太大，一般转而使用打印简介去了解学习
import 模块
print(模块名.__doc__)
dir(模块)，会列出所有的变量和函数
模块.__all__，显示外界可以调用的所有信息，form 模块 import *只有__all__属性的函数变量才会导入
模块.__file__显示源代码的位置
如何提高编程的能力
1、编写代码
2、阅读高手的代码
help(模块)，打印出介于文档和dir显示的
>>> import timeit
>>> dir(timeit)
['Timer', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_globals', 'default_number', 'default_repeat', 'default_timer', 'dummy_src_name', 'gc', 'itertools', 'main', 'reindent', 'repeat', 'sys', 'template', 'time', 'timeit']
>>> timeit.__all__
['Timer', 'timeit', 'repeat', 'default_timer']
>>> timeit.__file__
'C:\\Users\\1\\AppData\\Local\\Programs\\Python\\Python37\\lib\\timeit.py'
>>> print(timeit.__doc__ )
Tool for measuring execution time of small code snippets.
This module avoids a number of common traps for measuring execution
times. See also Tim Peters' introduction to the Algorithms chapter in
the Python Cookbook, published by O'Reilly.
Library usage: see the Timer class.
Command line usage:
python timeit.py [-n N] [-r N] [-s S] [-p] [-h] [--] [statement]
Options:
-n/--number N: how many times to execute 'statement' (default: see below)
-r/--repeat N: how many times to repeat the timer (default 5)
-s/--setup S: statement to be executed once initially (default 'pass').
Execution time of this setup statement is NOT timed.
-p/--process: use time.process_time() (default is time.perf_counter())
-v/--verbose: print raw timing results; repeat for more digits precision
-u/--unit: set the output time unit (nsec, usec, msec, or sec)
-h/--help: print this usage message and exit
--: separate options from statement, use when statement starts with -
statement: statement to be timed (default 'pass')
A multi-line statement may be given by specifying each line as a
separate argument; indented lines are possible by enclosing an
argument in quotes and using leading spaces. Multiple -s options are
treated similarly.
If -n is not given, a suitable number of loops is calculated by trying
successive powers of 10 until the total time is at least 0.2 seconds.
Note: there is a certain baseline overhead associated with executing a
pass statement. It differs between versions. The code here doesn't try
to hide it, but you should be aware of it. The baseline overhead can be
measured by invoking the program without arguments.
Classes:
Timer
Functions:
timeit(string, string) -> float
repeat(string, string) -> list
default_timer() -> float
>>> help(timeit)
Help on module timeit:
NAME
timeit - Tool for measuring execution time of small code snippets.
DESCRIPTION
This module avoids a number of common traps for measuring execution
times. See also Tim Peters' introduction to the Algorithms chapter in
the Python Cookbook, published by O'Reilly.
Library usage: see the Timer class.
Command line usage:
python timeit.py [-n N] [-r N] [-s S] [-p] [-h] [--] [statement]
Options:
-n/--number N: how many times to execute 'statement' (default: see below)
-r/--repeat N: how many times to repeat the timer (default 5)
-s/--setup S: statement to be executed once initially (default 'pass').
Execution time of this setup statement is NOT timed.
-p/--process: use time.process_time() (default is time.perf_counter())
-v/--verbose: print raw timing results; repeat for more digits precision
-u/--unit: set the output time unit (nsec, usec, msec, or sec)
-h/--help: print this usage message and exit
--: separate options from statement, use when statement starts with -
statement: statement to be timed (default 'pass')
A multi-line statement may be given by specifying each line as a
separate argument; indented lines are possible by enclosing an
argument in quotes and using leading spaces. Multiple -s options are
treated similarly.
If -n is not given, a suitable number of loops is calculated by trying
successive powers of 10 until the total time is at least 0.2 seconds.
Note: there is a certain baseline overhead associated with executing a
pass statement. It differs between versions. The code here doesn't try
to hide it, but you should be aware of it. The baseline overhead can be
measured by invoking the program without arguments.
Classes:
Timer
Functions:
timeit(string, string) -> float
repeat(string, string) -> list
default_timer() -> float
CLASSES
builtins.object
Timer
class Timer(builtins.object)
| Timer(stmt='pass', setup='pass', timer=<built-in function perf_counter>, globals=None)
|
| Class for timing execution speed of small code snippets.
|
| The constructor takes a statement to be timed, an additional
| statement used for setup, and a timer function. Both statements
| default to 'pass'; the timer function is platform-dependent (see
| module doc string). If 'globals' is specified, the code will be
| executed within that namespace (as opposed to inside timeit's
| namespace).
|
| To measure the execution time of the first statement, use the
| timeit() method. The repeat() method is a convenience to call
| timeit() multiple times and return a list of results.
|
| The statements may contain newlines, as long as they don't contain
| multi-line string literals.
|
| Methods defined here:
|
| __init__(self, stmt='pass', setup='pass', timer=<built-in function perf_counter>, globals=None)
| Constructor. See class doc string.
|
| autorange(self, callback=None)
| Return the number of loops and time taken so that total time >= 0.2.
|
| Calls the timeit method with increasing numbers from the sequence
| 1, 2, 5, 10, 20, 50, ... until the time taken is at least 0.2
| second. Returns (number, time_taken).
|
| If *callback* is given and is not None, it will be called after
| each trial with two arguments: ``callback(number, time_taken)``.
|
| print_exc(self, file=None)
| Helper to print a traceback from the timed code.
|
| Typical use:
|
| t = Timer(...) # outside the try/except
| try:
| t.timeit(...) # or t.repeat(...)
| except:
| t.print_exc()
|
| The advantage over the standard traceback is that source lines
| in the compiled template will be displayed.
|
| The optional file argument directs where the traceback is
| sent; it defaults to sys.stderr.
|
| repeat(self, repeat=5, number=1000000)
| Call timeit() a few times.
|
| This is a convenience function that calls the timeit()
| repeatedly, returning a list of results. The first argument
| specifies how many times to call timeit(), defaulting to 5;
| the second argument specifies the timer argument, defaulting
| to one million.
|
| Note: it's tempting to calculate mean and standard deviation
| from the result vector and report these. However, this is not
| very useful. In a typical case, the lowest value gives a
| lower bound for how fast your machine can run the given code
| snippet; higher values in the result vector are typically not
| caused by variability in Python's speed, but by other
| processes interfering with your timing accuracy. So the min()
| of the result is probably the only number you should be
| interested in. After that, you should look at the entire
| vector and apply common sense rather than statistics.
|
| timeit(self, number=1000000)
| Time 'number' executions of the main statement.
|
| To be precise, this executes the setup statement once, and
| then returns the time it takes to execute the main statement
| a number of times, as a float measured in seconds. The
| argument is the number of times through the loop, defaulting
| to one million. The main statement, the setup statement and
| the timer function to be used are passed to the constructor.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
FUNCTIONS
default_timer = perf_counter(...)
perf_counter() -> float
Performance counter for benchmarking.
repeat(stmt='pass', setup='pass', timer=<built-in function perf_counter>, repeat=5, number=1000000, globals=None)
Convenience function to create Timer object and call repeat method.
timeit(stmt='pass', setup='pass', timer=<built-in function perf_counter>, number=1000000, globals=None)
Convenience function to create Timer object and call timeit method.
DATA
__all__ = ['Timer', 'timeit', 'repeat', 'default_timer']
FILE
c:\users\1\appdata\local\programs\python\python37\lib\timeit.py
