内容简介：包与模块（五）
1.1 模块
1.1.1 模块介绍
常见的场景：一个模块就是一个包含了一组功能的 python 文件,比如spam.py，模块名为spam，可以通过import spam使用。
在python中，模块的使用方式都是一样的，但其实细说的话，模块可以分为四个通用类别：
1 使用python编写的.py文件
2 已被编译为共享库或DLL的C或C++扩展
3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
4 使用C编写并链接到python解释器的内置模块
1.1.2 为何要使用模块
1、从文件级别组织程序，更方便管理
随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用
2、拿来主义，提升开发效率
同样的原理，我们也可以下载别人写好的模块然后导入到自己的项目中使用，这种拿来主义，可以极大地提升我们的开发效率
#ps：
如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。
以spam.py为例来介绍模块的使用：文件名spam.py,模块名spam
#spam.py
print('from the spam.py')
money=1000
def read1():
print('spam模块：',money)
def read2():
print('spam模块')
read1()
def change():
global money
money=0
模块使用.py
import spam money=1 print(spam.money) print(spam.read1) print(spam.read2) print(spam.change)
测试一
money=1 print(spam.money)
测试二（绝对导入）：
def read1():
print('from current')
# spam.read1()
spam.read2()
测试三：
money=1 spam.change() print(money) spam.read1()
1.2 使用模块之import
1.2.1 import的使用
模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下
#test.py
import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果. import spam import spam import spam
'''
执行结果：
from the spam.py
'''
ps：我们可以从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。
1.2.2 在第一次导入模块时会做三件事，重复导入会直接引用内存中已经加载好的结果
1.为源文件(spam模块)创建新的名称空间，在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。
2.在新创建的命名空间中执行模块中包含的代码，见初始导入import spam
提示:导入模块时到底执行了什么？
事实上函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放入模块全局名称空间表，用globals()可以查看
3.创建名字spam来引用该命名空间
这个名字和变量名没什么区别，都是‘第一类的’，且使用spam.名字的方式
可以访问spam.py文件中定义的名字，spam.名字与test.py中的名字来自
两个完全不同的地方。
1.2.3 被导入模块有独立的名称空间
每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突
测试一:money与spam.money不冲突
#test.py
import spam money=10 print(spam.money)
'''
执行结果：
from the spam.py
1000
'''
测试二：read1与spam.read1不冲突
#test.py
import spam
def read1():
print('========')
spam.read1()
'''
执行结果:
from the spam.py
spam->read1->money 1000
'''
测试三：执行spam.change()操作的全局变量money仍然是spam中的
#test.py
import spam money=1 spam.change() print(money)
'''
执行结果：
from the spam.py
1
'''
1.2.4 为模块名起别名
为已经导入的模块起别名的方式对编写可扩展的代码很有用
import spam as sm
print(sm.money)
engine=input('>>: ')
if engine == 'mysql':
import mysql as sql
elif engine == 'oracle':
import oracle as sql
sql.parse()
有两中 sql 模块 mysql 和oracle，根据用户的输入，选择不同的sql功能
假设有两个模块xmlreader.py和csvreader.py，它们都定义了函数read_data(filename):用来从文件中读取一些数据，但采用不同的输入格式。可以编写代码来选择性地挑选读取模块
if file_format == 'xml':
import xmlreader as reader
elif file_format == 'csv':
import csvreader as reader
data=reader.read_date(filename)
1.2.5 在一行导入多个模块
import sys,os,re
1.2.6 使用模块之from ... import...
1.2.6.1 from ... import... .的使用
from spam import money,read1,read2,change
money=1
print(money)
read1='read1'
print(read1)
money=1
read1()
def read1():
print('from current func')
read2()
money=1
change()
print(money)
1.2.7 from...import 与import的对比
唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：spam.
#from...import...的方式有好处也有坏处
好处：使用起来方便了
坏处：容易与当前执行文件中的名字冲突
read1=1
print(money,read1,read2,change)
print(_money)
print(read1,read2,change)
from spam import _money
print(_money)
import spam
spam.read1()
import sys
print(sys.path)
sys.path.append(r'D:\video\python20期\day5\01_模块\aaa')
import spam
print(spam.money)
import spam,time
time.sleep(10)
import spam
print(spam.money)
import sys,spam
print('spam' in sys.modules)
print('time' in sys.modules)
import time
print(time)
time.sleep(3)
1.2.8 from spam import *
#from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置
#大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。
1.3 py文件区分两种用途:模块与脚本
写好的一个python文件可以有两种用途：
一：脚本，一个文件就是整个程序，用来被执行
二：模块，文件中存放着一堆功能，用来被导入使用
#python为我们内置了全局变量__name__，
当文件被当做脚本执行时：__name__ 等于'__main__'
当文件被当做模块导入时：__name__等于模块名
#作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
if __name__ == '__main__':
1.4 模块搜索路径
模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径中包含的模块
模块的查找顺序
1、在第一次导入某个模块时（比如spam），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用
ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看
2、如果没有，解释器则会查找同名的内建模块
3、如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。
1.5 包
1.5.1 什么是包
包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来
需要强调的是：
1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块
1.5.2 为何要使用包
包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来
随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性
注意事项：
#1.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
#2、import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件
#3、包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间
1.5.3 包的使用之import
创建包package1,在package1创建package2
在包package1中创建文件init.py
# print('__init__.py')
x=1
# m1='m1'
# import m1 #错误
from package1 import m1
# package2='package2'
# import package2 #错误,单独导入包名称时不会导入包中所有包含的所有子模块 from package1 import package2
在包package1中创建文件m1.py
def f1():
print('from f1 func')
在包package2中创建文件m2.py
def f2():
print('f2')
需要注意的是 from 后 import 导入的模块，必须是明确的一个不能带点，否则会有语法错误，如： from a import b.c 是错误语法
1.6 绝对导入和相对导入
我们的最顶级包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：
绝对导入：以glance作为起始
相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）
1.6.1 相对导入
包的使用.py
# import package1
#
# # package1.f1()
# package1.f2()
import sys
sys.path.append(r'D:\video\python20期\day5\02_包\测试三（相对导入）\aaa')
import package1
package1.f2()
m1.py
def f1():
print('from f1 func')
包1_init_.py
from .m1 import f1 from .package2.m2 import f2
m2.py
from ..m1 import f1
def f2():
f1()
print('f2')
1.6.2 绝对导入
包的使用.py
import package1 package1.f1() package1.f2() # import sys # # # sys.path.append(r'D:\video\python20期\day5\02_包\测试二（绝对导入）\package1\package2') # # sys.path.append(r'D:\video\python20期\day5\02_包\测试二（绝对导入）\package1') #
m1.py
def f1():
print('from f1 func')
包1_init_.py
from package1.m1 import f1 from package1.package2.m2 import f2
m2.py
def f2():
print('f2')
包2_init_.py
from package1.package2 import m2
1.7 软件开发规范
图1-1
#===============>star.py
import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from core import src
if __name__ == '__main__':
src.run()
#===============>settings.py
import os BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__))) DB_PATH=os.path.join(BASE_DIR,'db','db.json') LOG_PATH=os.path.join(BASE_DIR,'log','access.log') LOGIN_TIMEOUT=5
"""
logging配置
"""
# 定义三种日志输出格式
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# log配置字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
},
'filters': {},
'handlers': {
#打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # 打印到屏幕
'formatter': 'simple'
},
#打印到文件的日志,收集info及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件
'formatter': 'standard',
'filename': LOG_PATH, # 日志文件
'maxBytes': 1024*1024*5, # 日志大小 5M
'backupCount': 5,
'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了
},
},
'loggers': {
#logging.getLogger(__name__)拿到的logger配置
'': {
'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递
},
},
}
#===============>src.py
from conf import settings
from lib import common
import time
logger=common.get_logger(__name__)
current_user={'user':None,'login_time':None,'timeout':int(settings.LOGIN_TIMEOUT)}
def auth(func):
def wrapper(*args,**kwargs):
if current_user['user']:
interval=time.time()-current_user['login_time']
if interval < current_user['timeout']:
return func(*args,**kwargs)
name = input('name>>: ')
password = input('password>>: ')
db=common.conn_db()
if db.get(name):
if password == db.get(name).get('password'):
logger.info('登录成功')
current_user['user']=name
current_user['login_time']=time.time()
return func(*args,**kwargs)
else:
logger.error('用户名不存在')
return wrapper
@auth
def buy():
print('buy...')
@auth
def run():
print('''
1 购物
2 查看余额
3 转账
''')
while True:
choice = input('>>: ').strip()
if not choice:continue
if choice == '1':
buy()
#===============>db.json
{"egon": {"password": "123", "money": 3000}, "alex": {"password": "alex3714", "money": 30000}, "wsb": {"password": "3714", "money": 20000}}
#===============>common.py
from conf import settings
import logging
import logging.config
import json
def get_logger(name):
logging.config.dictConfig(settings.LOGGING_DIC) # 导入上面定义的logging配置
logger = logging.getLogger(name) # 生成一个log实例
return logger
def conn_db():
db_path=settings.DB_PATH
dic=json.load(open(db_path,'r',encoding='utf-8'))
return dic
#===============>access.log
[2017-10-21 19:08:20,285][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功] [2017-10-21 19:08:32,206][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功] [2017-10-21 19:08:37,166][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在] [2017-10-21 19:08:39,535][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在] [2017-10-21 19:08:40,797][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在] [2017-10-21 19:08:47,093][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在] [2017-10-21 19:09:01,997][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功] [2017-10-21 19:09:05,781][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在] [2017-10-21 19:09:29,878][MainThread:8812][task_id:core.src][src.py:19][INFO][登录成功] [2017-10-21 19:09:54,117][MainThread:9884][task_id:core.src][src.py:19][INFO][登录成功]
#介绍
# import logging
# logging.basicConfig(
# # filename='access.log',
# format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
# datefmt='%Y-%m-%d %H:%M:%S %p',
# level=10
# )
#
# logging.debug('debug') # 10
# logging.info('info') # 20
# logging.warning('warn') #30
# logging.error('error') #40
# logging.critical('critial') #50
1.8 常用模块
1.8.1 日志模块的详细用法：
import logging
1.8.2 Logger：产生日志
logger1=logging.getLogger('访问日志')
# logger2=logging.getLogger('错吴日志')
1.8.3 Filter：几乎不用
1.8.4 Handler：接收Logger传过来的日志，进行日志格式化，可以打印到终端，也可以打印到文件
sh=logging.StreamHandler() #打印到终端
fh1=logging.FileHandler('s1.log',encoding='utf-8')
fh2=logging.FileHandler('s2.log',encoding='utf-8')
1.8.5 Formatter：日志格式
formatter1=logging.Formatter(
fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
)
formatter2=logging.Formatter(
fmt='%(asctime)s : %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
)
formatter3=logging.Formatter(
fmt='%(asctime)s : %(module)s : %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
)
1.8.6 、为handler绑定日志格式
sh.setFormatter(formatter1)
fh1.setFormatter(formatter2)
fh2.setFormatter(formatter3)
1.8.7 、为logger绑定handler
logger1.addHandler(sh)
logger1.addHandler(fh1)
logger1.addHandler(fh2)
1.8.8 设置日志级别:logger对象的日志级别应该＜＝handler的日志界别
# logger1.setLevel(50)
logger1.setLevel(10) #
sh.setLevel(10)
fh1.setLevel(10)
fh2.setLevel(10)
1.8.9 测试
logger1.debug('测试着玩')
logger1.info('运行还算正常')
logger1.warning('可能要有bug了')
logger1.error('不好了，真tm出bug了')
logger1.critical('完犊子，推倒重写')
1.9 日志的继承
import logging
1.9.1 Logger：产生日志
logger1=logging.getLogger('root')
logger2=logging.getLogger('root.child1')
logger3=logging.getLogger('root.child1.child2')
1.9.2 Filter：几乎不用
1.9.3 Handler：接收Logger传过来的日志，进行日志格式化，可以打印到终端，也可以打印到文件
sh=logging.StreamHandler() #打印到终端
1.9.4 Formatter：日志格式
formatter1=logging.Formatter(
fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
)
1.9.5 为handler绑定日志格式
sh.setFormatter(formatter1)
1.9.6 为logger绑定handler
logger1.addHandler(sh)
logger2.addHandler(sh)
logger3.addHandler(sh)
1.9.7 设置日志级别:logger对象的日志级别应该＜＝handler的日志界别
# logger1.setLevel(50)
logger1.setLevel(10) #
logger2.setLevel(10) #
logger3.setLevel(10) #
sh.setLevel(10)
1.9.8 测试
logger1.debug('爷爷')
logger2.debug('爸爸')
logger3.debug('孙子')
1.10 正则模块
import re
# print(re.findall('\w','egon 123 + _ - *'))
# print(re.findall('\W','egon 123 + _ - *'))
# print(re.findall('\s','ego\tn 12\n3 + _ - *'))
# print(re.findall('\S','ego\tn 12\n3 + _ - *'))
# print(re.findall('\d','ego\tn 12\n3 + _ - *'))
# print(re.findall('\D','ego\tn 12\n3 + _ - *'))
# print(re.findall('\n','ego\tn 12\n3 + _ - *'))
# print(re.findall('\t','ego\tn 12\n3 + _ - *'))
# print(re.findall('e','ego\tn 12\n3 +hello _ - *'))
# print(re.findall('^e','ego\tn 12\n3 +hello _ - *'))
# print(re.findall('o$','ego\tn 12\n3 +hello'))
#重复：.|?|*|+|{m,n}|.*|.*?
#.代表任意一个字符
# print(re.findall('a.b','a1b a b a-b aaaaaab'))
# a.b
# print(re.findall('a.b','a1b a b a\nb a-b aaaaaab',re.DOTALL))
# a.b
#?:代表?号左边的字符出现0次或者1
# print(re.findall('ab?','a ab abb abbbb a1b')) #['a','ab','ab','ab','a']
# # ab?
#*:代表*号左边的字符出现0次或者无穷次
# print(re.findall('ab*','a ab abb abbbb a1b')) #['a','ab','abb','abbbb','a']
# ab*
#+:代表+号左边的字符出现1次或者无穷次
# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']
# # ab+
# {m,n}:代表左边的字符出现m次到n次
# print(re.findall('ab{0,1}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
# print(re.findall('ab?','a ab abb abbbb a1b')) #['ab','abb','abbbb']
# print(re.findall('ab{0,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
# print(re.findall('ab*','a ab abb abbbb a1b')) #['ab','abb','abbbb']
# print(re.findall('ab{1,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']
# print(re.findall('ab{2,4}','a ab abb abbbb a1b')) #['abb', 'abbbb']
#.*:贪婪匹配
# print(re.findall('a.*b','xxxy123a123b456b'))
# a.*b
#.*?:非贪婪匹配
# print(re.findall('a.*?b','xxxy123a123b456b'))
#|:或者
# print(re.findall('compan(y|iess)','too many companiess have gone bankrupt, and the next one is my company'))
# print(re.findall('compan(?:y|iess)','too many companiess have gone bankrupt, and the next one is my company'))
# compan(y|iess)
# print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击我</a>'))
#rawstring：
# print(re.findall(r'a\\c','a\c a1c aBc')) #a\\c->a\c
#[]:取中括号内任意的一个
# print(re.findall('a[a-z]b','axb azb aAb a1b a-b a+b'))
# print(re.findall('a[A-Z]b','axb azb aAb a1b a-b a+b'))
# print(re.findall('a[a-zA-Z]b','axb azb aAb a1b a-b a+b'))
# print(re.findall('a[0-9]b','axb azb aAb a1b a-b a+b'))
# print(re.findall('a[-+*/]b','axb azb aAb a1b a-b a+b'))
# print(re.findall('a[^-+*/]b','axb azb aAb a1b a-b a+b'))
#re模块的其他方法
#re.search :只匹配成功一次就返回
# print(re.search('a[*]b','axb azb aAb a1b a-b a+b'))
# print(re.search('a[0-9]b','axb azb aAb a1b a-b a2b a+b').group())
# re.match:从开头取
# print(re.match('a[0-9]b','axb azb aAb a1b a-b a2b a+b'))
# print(re.match('a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())
# print(re.search('^a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())
# re.split
# print(re.split(':','root:x:0:0::/root:/bin/bash',maxsplit=1))
# 'root:x:0:0::/root:/bin/bash'.split(':')
# re.sub
# print(re.sub('root','admin','root:x:0:0::/root:/bin/bash',1))
#了解
# print(re.sub('^([a-z]+)([^a-z]+)(.*?)([^a-z]+)([a-z]+)$',r'\5\2\3\4\1','root:x:0:0::/root:/bin/bash'))
# re.compile
obj=re.compile('a\d{2}b')
print(obj.findall('a12b a123b a12345b abbb'))
print(obj.search('a12b a123b a12345b abbb').group())
1.11 时间模块
import time
#掌握
# print(time.time())
# print(time.localtime())
# print(time.localtime().tm_mday)
# print(time.gmtime())
# print(time.strftime('%Y-%m-%d %H:%M:%S'))
# print(time.strftime('%Y-%m-%d %X'))
#了解
# print(time.localtime(11111111))
# print(time.localtime(time.time()))
# print(time.gmtime(time.time()))
# print(time.mktime(time.localtime()))
# print(time.strftime('%Y-%m-%d',time.localtime()))
# print(time.strptime('2017-03-01','%Y-%m-%d'))
# print(time.asctime(time.localtime()))
# print(time.ctime(111111))
#datetime
import datetime # print(datetime.datetime.now()) # print(datetime.datetime.fromtimestamp(111111111)) # print(datetime.datetime.now()+datetime.timedelta(days=3)) # print(datetime.datetime.now()+datetime.timedelta(days=-3)) # print(datetime.datetime.now()+datetime.timedelta(hours=3)) # print(datetime.datetime.now()+datetime.timedelta(minutes=3)) # print(datetime.datetime.now()+datetime.timedelta(seconds=3)) # print(datetime.datetime.now().replace(year=1999,hour=12))
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持 码农网
猜你喜欢:
- Node.js模块系统 （创建模块与加载模块）
- 黑客基础，Metasploit模块简介，渗透攻击模块、攻击载荷模块
- 022.Python模块序列化模块（json，pickle）和math模块
- 024.Python模块OS模块
- 023.Python的随机模块和时间模块
- Laravel 模块化开发模块 – Caffienate
本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。
数学建模算法与应用
司守奎、孙玺菁 / 国防工业出版社 / 2011-8 / 49.00元
《数学建模算法与应用》主要内容简介：作者司守奎、孙玺菁根据多年数学建模竞赛辅导工作的经验编写《数学建模算法与应用》，涵盖了很多同类型书籍较少涉及的新算法和热点技术，主要内容包括时间序列、支持向量机、偏最小二乘面归分析、现代优化算法、数字图像处理、综合评价与决策方法、预测方法以及数学建模经典算法等内容。《数学建模算法与应用》系统全面，各章节相对独立。《数学建模算法与应用》所选案例具有代表性，注重从不......一起来看看 《数学建模算法与应用》 这本书的介绍吧!
MD5 加密
MD5 加密工具
XML、JSON 在线转换
在线XML、JSON转换工具