包与模块,模块与包

一、模块的使用

模块定义:一多级功用的集合体

分为三大类:1.自定义模块

      2.嵌入模块(比如 time,os,sys)

      3.其三方模块

模块的表现情势

  1.使用python编写的py文件

  2.已被编译为共享库或DLL的C或C++扩张

  3.把一与日俱增模块协会到2头的文书夹(ps:文件夹下有二个__init__.py文件,该文件夹称为包)

  4.利用C编写并链接到python解释器的放置模块

干什么要用模块:

  1.可以拿来放置、第2方的模块,然后径直动用,这种拿来就用的法门,会极大的提拔开发作用

  2.将顺序中共用的有的作用集团到一个文本中,然后程序各部分零件能够引用该文件中的功用。

    优点是 减弱代码冗余,增强程序的团队结构性与可维护性

怎么用模块:

  1个py文件就是七个模块,假如文件名为modules.py,模块名则为modules

  ps:模块的行使必须搞驾驭何人是实践文书,何人是被导入的模块

包与模块(五),模块

1.1 模块

1.1 模块

澳门葡京备用网址,一,模块的拔取之import

澳门葡京备用网址 1澳门葡京备用网址 2

#:coding:utf-8
#modules.py
print('from the modules.py')

money=1000

def read1():
    print('modules模块.read1',money)

def read2():
    print('modules模块.read2')
    read1()

def change():
    global money
    money=0

modules.py

澳门葡京备用网址 3澳门葡京备用网址 4

import modules 

money=111111111111
print(modules.money)
print(modules.read1)
print(modules.read2)
print(modules.change)
modules.money=2222
print(money)###结果为money=111111111111

modules.read1()#modules模块.read1 2222   #这个更改成功modules.money=2222

def read1():#此处定义read1
    print('run.py中的read1')

modules.read1()#执行结果仍为modules模块.read1 2222

money=20000000
modules.change()#此处执行了modules中change函数
print(money)###此处为上述money=20000000
print(modules.money)##结果为0


import modules as spam ##可以as 起个别名
print(spam.money)  #依旧执行成功  结果为0

run.py

 

履行文书:run.py      被导入模块是:modules.py

首次导入模块会发生三件事: 

  一,创制三个模块modules.py的称谓空间
  二,执行模块对应的文书modules.py,将暴发的名字丢到模块的名号空间中
  3、在日前举办文书的名称空间中得到多少个名字modules,该名字就是指向模块modules.py的名目空间的
  import modules# modules=modules.py名称空间的内存地址

ps

  在如今进行文书中援引模块中的名字语法为:modules.名字,必须抬高modules.作为前缀
  modules.名字约等于指名道姓地跟某三个名号空间要名字,根本不会与当下施行文书的名字争持

 

1.1 模块

1.1.1 模块介绍

广泛的景观:三个模块就是2个含有了一组成效的python文件,比如spam.py,模块名为spam,可以经过import
spam使用。

在python中,模块的使用方式都以千篇一律的,但实在细说的话,模块可以分为两个通用项目: 

1 使用python编写的.py文件

2 已被编译为共享库或DLL的C或C++扩大

3
把一层层模块协会到一起的文本夹(注:文件夹下有三个__init__.py文件,该公文夹称之为包)

4 使用C编写并链接到python解释器的放权模块

 

1.1.1 模块介绍

普遍的情景:二个模块就是1个饱含了一组功效的python文件,比如spam.py,模块名为spam,可以透过import
spam使用。

在python中,模块的应用方法都以如出一辙的,但实在细说的话,模块可以分为多少个通用项目: 

1 使用python编写的.py文件

2 已被编译为共享库或DLL的C或C++伸张

3
把一密密麻麻模块社团到手拉手的文书夹(注:文件夹下有壹个__init__.py文件,该公文夹称之为包)

4 使用C编写并链接到python解释器的放置模块

 

2、模块的使用之  from   import

澳门葡京备用网址 5澳门葡京备用网址 6

#modules.py
# print('from the modules.py')

__all__=['money','read1']

money=1000

def read1():
    print('spam模块.read1',money)

def read2():
    print('spam模块.read2')
    read1()

def change():
    global money
    money=0

spam.py

澳门葡京备用网址 7澳门葡京备用网址 8

from spam import money,read1,read2,change
#
def read1():
    print('run.py.read1')

read1()      #  run.py.read1
read2()      #  spam模块.read2  ------------>   spam模块.read1 1000


from spam import money as my
print(my)   #1000

# ===========================================
from spam import * # * 会检索被导入模块中的__all__指定的名字,如果没有该变量那默认导入所有
print(money)  #1000
print(read1)  # <function read1 at 0x0000000001EB1C80>
# print(read2) #会报错
# print(change) #会报错

run.py

 

施行文书:run.py      被导入模块: spam.py

第四回导入模块会生出三件事
  1、创制一个模块spam.py的名号空间
  二,执行模块对应的文本spam.py,将时有暴发的名字丢到模块的称谓空间中
  三,在此时此刻履行文书的称号空间中拿到1个名字money,该名字就是指向模块spam.py的称呼空间的十一分money
  from spam import money,read1,read2,change

两种导入方式的比较
相同点:函数的作用域关系在概念阶段就规定死了,与调用地点非亲非故

from import
亮点:可以不要加前缀而直接引用名字,更简短
症结:简单与当前施行文书中的名字争辩

import
优点:指名道姓跟某一个称号空间要名字,肯定不会与当下名称空间中的名字争执
缺陷:必须抬高前缀

 

1.1.1 模块介绍

广大的气象:一个模块就是2个包含了一组功效的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个个的文书,那样做程序的协会更清楚,方便管理。那时大家不光可以把这么些文件作为脚本去履行,还可以把他们当作模块来导入到其余的模块中,达成了功效的再度使用

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.1.2 为啥要采纳模块

1、从文件级别协会程序,更方便管理

趁着程序的进步,作用越来越多,为了方便管理,大家不乏先例将次第分成一个个的文书,那样做程序的构造更清楚,方便管理。这时大家不光可以把这个文件作为脚本去实践,还是可以够把他们当作模块来导入到其余的模块中,达成了功效的再次利用

二,拿来主义,升高开发功用

一如既往的规律,我们也可以下载旁人写好的模块然后导入到自身的体系中应用,那种拿来主义,可以极大地提高我们的付出作用

#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()

 

三,循环导入的题材

澳门葡京备用网址 9澳门葡京备用网址 10

# print('正在导入m1')
#
# x='m1.py'
#
# from m2 import y
#

print('正在导入m1')

def f1():
    from m2 import y,f2
    print(y)
    f2()

x='m1.py'

m1.py

澳门葡京备用网址 11澳门葡京备用网址 12

# print('正在导入m2')
#
# y='m2'
#
# from m1.py import x


print('正在导入m2')

def f2():
    from m1 import x
    print(x)

y='m2.py'

m2.py

###   run.py
# 1、创建m1.py的名称空间
# 2、执行m1.py的代码,将产生的名字丢到m1.py的名称空间中
# 3、在当前执行文件的名称空间中拿到一个名字m1
import m1

m1.f1()

 

1.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 使用模块之import

肆,模块的检索路径

模块搜索路径优先级:

  内存  ——–> 内置的模块 ——–> sys.path(环境变量)

澳门葡京备用网址 13澳门葡京备用网址 14

#模块的查找顺序
1、在第一次导入某个模块时(比如spam),会先检查该模块是否已经被加载到内存中(当前执行文件的名称空间对应的内存),如果有则直接引用
    ps:python解释器在启动时会自动加载一些模块到内存中,可以使用sys.modules查看
2、如果没有,解释器则会查找同名的内建模块
3、如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。


#sys.path的初始化的值来自于:
The directory containing the input script (or the current directory when no file is specified).
PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
The installation-dependent default.

#需要特别注意的是:我们自定义的模块名不应该与系统内置模块重名。虽然每次都说,但是仍然会有人不停的犯错。 

#在初始化后,python程序可以修改sys.path,路径放到前面的优先于标准库被加载。
1 >>> import sys
2 >>> sys.path.append('/a/b/c/d')
3 >>> sys.path.insert(0,'/x/y/z') #排在前的目录,优先被搜索
注意:搜索时按照sys.path中从左到右的顺序查找,位于前的优先被查找,sys.path中还可能包含.zip归档文件和.egg文件,python会把.zip归档文件当成一个目录去处理,

#首先制作归档文件:zip module.zip foo.py bar.py 
import sys
sys.path.append('module.zip')
import foo,bar

#也可以使用zip中目录结构的具体位置
sys.path.append('module.zip/lib/python')


#windows下的路径不加r开头,会语法错误
sys.path.insert(0,r'C:\Users\Administrator\PycharmProjects\a')


#至于.egg文件是由setuptools创建的包,这是按照第三方python库和扩展时使用的一种常见格式,.egg文件实际上只是添加了额外元数据(如版本号,依赖项等)的.zip文件。

#需要强调的一点是:只能从.zip文件中导入.py,.pyc等文件。使用C编写的共享库和扩展块无法直接从.zip文件中加载(此时setuptools等打包系统有时能提供一种规避方法),且从.zip中加载文件不会创建.pyc或者.pyo文件,因此一定要事先创建他们,来避免加载模块是性能下降。

详见的牵线

 

1.2 使用模块之import

1.2.1 import的使用

模块可以分包可实施的话语和函数的概念,这一个话语的目的是起首化模块,它们只在模块名首次相遇导入import语句时才实施(import语句是可以在程序中的任意地点选取的,且针对同一个模块很import数次,为了防止万一你又一次导入,python的优化手段是:第2遍导入后就将模块名加载到内存了,后续的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.1 import的使用

模块可以包含可实施的口舌和函数的概念,这一个讲话的目的是发轫化模块,它们只在模块名第2遍相遇导入import语句时才实施(import语句是可以在程序中的任意位置运用的,且针对同1个模块很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是二个字典,内部含有模块名与模块对象的映照,该字典决定了导入模块时是还是不是需求重新导入。

 

五,区分python文件的二种用途

一个python文件有二种用途:(模块与剧本)
  1、可以推行运营:__name__ == ‘__main__’
  二,可以被看成模块导入:__name__ == ‘模块名’

if __name__ == '__main__':

 

1.2.1 import的使用

模块可以包罗可实施的说话和函数的定义,这几个讲话的目标是初步化模块,它们只在模块名第2遍相见导入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来引用该命名空间

    那些名字和变量名没什么不同,都是‘第2、类的’,且使用spam.名字的艺术

    可以访问spam.py文件中定义的名字,spam.名字与test.py中的名字来自

    七个完全不相同的地方。

1.2.2 在率先次导入模块时会做三件事,重复导入会直接引用内存中已经加载好的结果

1.为源文件(spam模块)成立新的名目空间,在spam中定义的函数和章程假设使用到了global时访问的就是其一称谓空间。

2.在新创设的命名空间中推行模块中隐含的代码,见起先导入import spam

 指示:导入模块时到底执行了哪些?

实际上函数定义也是“被实践”的说话,模块级别函数定义的履行将函数名放入模块全局名称空间表,用globals()可以查阅

3.开立名字spam来引用该命名空间

    这么些名字和变量名没什么分歧,都以‘第壹类的’,且使用spam.名字的法子

    能够访问spam.py文件中定义的名字,spam.名字与test.py中的名字源于

    八个精光两样的地点。

二、包的运用

1.2.2 在率先次导入模块时会做三件事,重复导入会平昔引用内存中已经加载好的结果

1.为源文件(spam模块)创设新的称呼空间,在spam中定义的函数和方式假设使用到了global时访问的就是那几个称呼空间。

2.在新创造的命名空间中实施模块中包罗的代码,见开头导入import spam

 提醒:导入模块时到底执行了怎么?

实在函数定义也是“被实践”的语句,模块级别函数定义的实践将函数名放入模块全局名称空间表,用globals()可以查看

3.创办名字spam来引用该命名空间

    这些名字和变量名没什么分歧,都以‘第2类的’,且使用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.3 被导入模块有独立的名目空间

各种模块都以2个单独的名称空间,定义在那些模块中的函数,把这些模块的名号空间作为全局名称空间,那样我们在编写本人的模块时,就不用操心大家定义在和谐模块中全局变量会在被导入时,与使用者的全局变量冲突

测试一: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、什么是包

官网解释

Packages are a way of structuring Python’s module namespace by using
“dotted module names”

包是一种透过利用‘.模块名’来公司python模块名称空间的艺术

切切实实的:包就是七个包括有__init__.py文件的文件夹,所以其实大家创立包的目标就是为着用文件夹将文件/模块社团起来

亟需强调的是:   

  1. 在python3中,尽管包下没有__init__.py文件,import
    包如故不会报错,而在python2中,包下一定要有该文件,否则import 包报错
      

2.
创建包的目标不是为着运维,而是被导入使用,记住,包只是模块的一种样式而已,包的本来面目就是一种模块

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.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)

 

 

二,为啥要用包

包的真相就是三个文书夹,  那么文件夹唯一的效益就是将文件协会起来
随着功效越写愈多  ,我们不能将据此功用都置于一个文书中,
于是我们采用模块去社团效率, 而随着模块更多,
大家就须要用文件夹将模块文件社团起来,以此来进步程序的结构性和可维护性。

ps:注意事项

#1.关于包相关的导入语句也分为import和from ... import ...两种,但是无论哪种,无论在什么位置,在导入时都必须遵循一个原则:凡是在导入时带点的,点的左边都必须是一个包,否则非法。可以带有一连串的点,如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后,在使用时就没有这种限制了,点的左边可以是包,模块,函数,类(它们都可以用点的方式调用自己的属性)。

#2、import导入文件时,产生名称空间中的名字来源于文件,import 包,产生的名称空间的名字同样来源于文件,即包下的__init__.py,导入包本质就是在导入该文件

#3、包A和包B下有同名模块也不会冲突,如A.a与B.a来自俩个命名空间

 

|---示例
|     ||---dir1 #文件夹
|     |     |-----dir2 #文件夹
|     |            |---p1 #包文件夹
|     |               |||-------p2 #包文件夹
|     |               |||       ||----- __init__.py
|     |               |||       |------m3.py
|     |               |||
|     |               |||--- __init__.py
|     |               ||----m1.py     
|     |               |-----m2.py   
|     |
|     |------run.py  #执行文件

澳门葡京备用网址 15澳门葡京备用网址 16

#   run.py

from dir1.dir2 import p1
p1.f1()
p1.f2()
p1.f3()

#======================================
#dir1文件夹 (dir2文件夹)
#
#dir2文件夹(p1包文件夹)
#======================================
                          #p1下的文件内容
#__init.py

from .m1 import f1
from .m2 import f2
from .p2.m3 import f3
#------------------------------------------
#m1.py

def f1():
    print('m1.f1')
#-------------------------------------------
#m2.py

def f2():
    print('m2.f2')
#-------------------------------------------
#p1包文件夹(p2包文件夹)
#=======================================
                         #p2下的文件内容
#__init__.py

#空
#--------------------------------------------
#m3.py

def f3():
    print('m3.f3')

文本内容

#import p1
#1 创建p1的名称空间
#2 执行p1下的__init__.py文件的代码,将执行过程中产生的名字都丢到名称空间中
#3 在当前执行文件中拿到一个名字p1,p1指向__init__.py的名称空间

#包内模块的:绝对导入与相对导入
#    绝对导入:每次导入都是以最顶级包为起始开始查找的
#    相对导入:相对于当前所在的文件,.代表当前所在的文件,..代表上一级,...
#        强调:
#            相对导入只能在被导入的模块中使用
#           在执行文件里不能用.或者..的导入方式

#注意:
# 但凡在导入时带点的,点的左边必须是一个包

 

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.5 在一行导入七个模块

import sys,os,re

 

三、软件开发的目录规范

  澳门葡京备用网址 17

一,bin 文件夹  :一般放程序运行文件(start.py)

2、conf 文件夹:一些安顿新闻(例如路径等)

三,core 文件夹:程序的主干文件 与用户挂钩的

四,db 文件夹   :数据文件所在地

5、lib 文件夹   :公共模块文件(例如认证文件)

六,log 文件夹  :日志文件所在地 

7、Readme 文件   :程序的扶助文档

 

1.2.5 在一行导入多个模块

import sys,os,re

 

1.2.6 使用模块之from … import…

1.2.6 使用模块之from … import…

四、logging模块(日志)

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.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)

 

 

一、日志的级别

CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置

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.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)

 

 

二、暗中同意级别为warning ,默许打印到巅峰

import logging

logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')

'''
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''

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.2.8 from spam import *

#from spam import *
把spam中享有的不是以下划线(_)初步的名字都导入到当前岗位

#大多数情况下大家的python程序不应当使用那种导入格局,因为*您不晓得您导入什么名字,很有可能会覆盖掉你前边曾经定义的名字。而且可读性极其的差,在交互式环境中导入时不曾难点。

 

三、为logging 模块指定全局配置,针对全部logger有效,控制打印到文件

可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为,可用参数有

澳门葡京备用网址 18澳门葡京备用网址 19

filename:用指定的文件名创建FiledHandler,这样日志会被存储在指定的文件中。

filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。

format:指定handler使用的日志显示格式。

datefmt:指定日期时间格式。 

level:设置rootlogger 的日志级别 

stream:用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件,默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。


#格式
%(name)s:Logger的名字,并非用户名,详细查看

%(levelno)s:数字形式的日志级别

%(levelname)s:文本形式的日志级别

%(pathname)s:调用日志输出函数的模块的完整路径名,可能没有

%(filename)s:调用日志输出函数的模块的文件名

%(module)s:调用日志输出函数的模块名

%(funcName)s:调用日志输出函数的函数名

%(lineno)d:调用日志输出函数的语句所在的代码行

%(created)f:当前时间,用UNIX标准的表示时间的浮 点数表示

%(relativeCreated)d:输出日志信息时的,自Logger创建以 来的毫秒数

%(asctime)s:字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒

%(thread)d:线程ID。可能没有

%(threadName)s:线程名。可能没有

%(process)d:进程ID。可能没有

%(message)s:用户输出的消息  

logging.basicConfig()

澳门葡京备用网址 20澳门葡京备用网址 21

#========使用
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')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')





#========结果
access.log内容:
2017-07-28 20:32:17 PM - root - DEBUG -test:  调试debug
2017-07-28 20:32:17 PM - root - INFO -test:  消息info
2017-07-28 20:32:17 PM - root - WARNING -test:  警告warn
2017-07-28 20:32:17 PM - root - ERROR -test:  错误error
2017-07-28 20:32:17 PM - root - CRITICAL -test:  严重critical

part2: 可以为logging模块指定模块级的配置,即所有logger的配置

固定套路

 

1.2.8 from spam import *

#from spam import *
把spam中装有的不是以下划线(_)起初的名字都导入到当前岗位

#一大半情景下我们的python程序不应有利用这种导入格局,因为*您不通晓您导入什么名字,很有只怕会覆盖掉你前面早已定义的名字。而且可读性极其的差,在交互式环境中导入时未尝难点。

 

1.3 py文件分别三种用途:模块与剧本

写好的3个python文件可以有三种用途:

    一:脚本,五个文书就是成套程序,用来被实施

    二:模块,文件中存放着一堆效果,用来被导入使用

 

#python为大家放手了全局变量__name__,

    当文件被用作脚本执行时:__name__ 等于’__main__’

    当文件被当做模块导入时:__name__等于模块名

 

#功能:用来控制.py文件在不一致的运用场景下执行不一的逻辑

    if __name__ == ‘__main__’:

 

1.3 py文件分别三种用途:模块与剧本

写好的二个python文件可以有二种用途:

    一:脚本,三个文件就是一切程序,用来被实施

    二:模块,文件中存放着一堆效果,用来被导入使用

 

#python为大家松开了全局变量__name__,

    当文件被用作脚本执行时:__name__ 等于’__main__’

    当文件被当做模块导入时:__name__相当于模块名

 

#功能:用来控制.py文件在不一样的行使场景下实施不一的逻辑

    if __name__ == ‘__main__’:

 

四、logging模块的Formatter ,Handler,Logger,Filte 对象

#logger:产生日志的对象

#Filter:过滤日志的对象

#Handler:接收日志然后控制打印到不同的地方,FileHandler用来打印到文件中,StreamHandler用来打印到终端

#Formatter对象:可以定制不同的日志格式对象,然后绑定给不同的Handler对象使用,以此来控制不同的Handler的日志格式

澳门葡京备用网址 22澳门葡京备用网址 23

'''
critical=50
error =40
warning =30
info = 20
debug =10
'''


import logging

#1、logger对象:负责产生日志,然后交给Filter过滤,然后交给不同的Handler输出
logger=logging.getLogger(__file__)#日志名

#2、Filter对象:不常用,略

#3、Handler对象:接收logger传来的日志,然后控制输出
h1=logging.FileHandler('t1.log') #打印到文件
h2=logging.FileHandler('t2.log') #打印到文件
h3=logging.StreamHandler() #打印到终端

#4、Formatter对象:日志格式
formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

formmater2=logging.Formatter('%(asctime)s :  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

formmater3=logging.Formatter('%(name)s %(message)s',)


#5、为Handler对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)

#6、将Handler添加给logger并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)

#7、测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')

logging模块的定势套路

详细步骤:

1、配图

澳门葡京备用网址 24

壹,logger对象承担发生日志

logger1=logging.getLogger('xx日志')

二,filter过滤(基本用不到)

三,handler对象急需与logger对象绑定,用来收取logger对象传过来的日志,支配打印到不相同的地点(文件、终端)

fh1=logging.FileHandler(filename='a1.log',encoding='utf-8')
fh2=logging.FileHandler(filename='a2.log',encoding='utf-8')

sh=logging.StreamHandler()# 往终端打印的

肆,formmater对象急需与handler对象绑定,用以控制handler对象的日志格式

澳门葡京备用网址 25澳门葡京备用网址 26

formmater1=logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)

#两种不同的日志格式

formmater2=logging.Formatter(
    fmt='%(asctime)s - %(levelname)s :  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)

formmater格式

ps1:设置日志级别(统一安装):logger与handler两层关卡都放行,日志最终才放行

logger1.setLevel(10)  #logger对象设置

fh1.setLevel(10)  #文件1的handler设置级别
fh2.setLevel(20)  #文件2的handler设置级别
sh.setLevel(30)   #打印到终端的handler设置级别

ps2:建立logger对象与handler对象的绑定关系

logger1.addHandler(fh1)
logger1.addHandler(fh2)
logger1.addHandler(sh)

ps3:建立handler对象与formmater对象的绑定关系

fh1.setFormatter(formmater1)
fh2.setFormatter(formmater1)
sh.setFormatter(formmater2)

末段:使用logger1对象爆发日志,打印到不相同的地方

logger1.debug('蘑菇买彩票中奖30元')
logger1.warning('蘑菇花了1000元买彩票')

 

1.3 py文件分别二种用途:模块与剧本

写好的3个python文件可以有三种用途:

    一:脚本,1个文本就是一切程序,用来被执行

    二:模块,文件中存放着一堆效果,用来被导入使用

 

#python为大家松开了全局变量__name__,

    当文件被用作脚本执行时:__name__ 等于’__main__’

    当文件被当做模块导入时:__name__等于模块名

 

#功能:用来控制.py文件在不一样的运用场景下举行差别的逻辑

    if __name__ == ‘__main__’:

 

1.4 模块搜索路径

模块的物色顺序是:内存中已经加载的模块->内置模块->sys.path路径中包括的模块

模块的寻找顺序

壹,在首先次导入有些模块时(比如spam),会先检查该模块是或不是业已被加载到内存中(当前执行文书的称谓空间对应的内存),即使有则直接引用

   
ps:python解释器在运转时会活动加载一些模块到内存中,可以应用sys.modules查看

2、如若没有,解释器则会寻找同名的内建模块

三,要是还尚无找到就从sys.path给出的目录列表中逐条寻找spam.py文件。

 

1.4 模块搜索路径

模块的追寻顺序是:内存中已经加载的模块->内置模块->sys.path路径中隐含的模块

模块的探寻顺序

一,在第一回导入有个别模块时(比如spam),会先检查该模块是不是已经被加载到内存中(当前推行文书的名号空间对应的内存),假设有则间接引用

   
ps:python解释器在运转时会自动加载一些模块到内存中,可以采纳sys.modules查看

二,若是没有,解释器则会寻找同名的内建模块

三,假使还未曾找到就从sys.path给出的目录列表中各类寻找spam.py文件。

 

五、Logger与Handler的级别

 logger与handler两层关卡都放行,日志最后才放行

专注:logger是率先层关卡  ,然后才到handler

澳门葡京备用网址 27澳门葡京备用网址 28

import logging


form=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

ch=logging.StreamHandler()

ch.setFormatter(form)
# ch.setLevel(10)
ch.setLevel(20)

l1=logging.getLogger('root')
# l1.setLevel(20)
l1.setLevel(10)
l1.addHandler(ch)

l1.debug('l1 debug')

示例

 

1.4 模块搜索路径

模块的检索顺序是:内存中已经加载的模块->内置模块->sys.path路径中隐含的模块

模块的搜寻顺序

1、在首先次导入有些模块时(比如spam),会先反省该模块是或不是早已被加载到内存中(当前施行文书的名号空间对应的内存),假设有则一向引用

   
ps:python解释器在运营时会活动加载一些模块到内存中,可以利用sys.modules查看

二,如果没有,解释器则会寻找同名的内建模块

叁,若是还向来不找到就从sys.path给出的目录列表中相继寻找spam.py文件。

 

1.5 包

1.5 包

六、具体模块的采纳格局

即使老是使用模块都得依据上述的步子,那就太烦琐了。

由此logging模块有一个从字典中加载配置的主意

1.5 包

1.5.1 什么是包

包就是1个暗含有__init__.py文件的文书夹,所以实际大家创制包的目标就是为着用文件夹将文件/模块社团起来

必要强调的是:

  1. 在python3中,就算包下没有__init__.py文件,import
包还是不会报错,而在python2中,包下一定要有该文件,否则import 包报错

 

  2.
成立包的目标不是为着运行,而是被导入使用,记住,包只是模块的一种形式而已,包的本来面目就是一种模块

1.5.1 什么是包

包就是三个分包有__init__.py文件的文本夹,所以实际上我们创设包的目标就是为了用文件夹将文件/模块社团起来

须求强调的是:

  1. 在python3中,就算包下没有__init__.py文件,import
包依然不会报错,而在python2中,包下一定要有该文件,否则import 包报错

 

  2.
创制包的目标不是为着运转,而是被导入使用,记住,包只是模块的一种样式而已,包的本质就是一种模块

1.使用模板

澳门葡京备用网址 29澳门葡京备用网址 30

"""
logging配置
"""

import os
import logging.config

# 定义三种日志输出格式 开始

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'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = 'all2.log'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# 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': logfile_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)传递
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()

logging配置文件

logging配置模板

澳门葡京备用网址 31澳门葡京备用网址 32

"""
MyLogging Test
"""

import time
import logging
import my_logging  # 导入自定义的logging配置

logger = logging.getLogger(__name__)  # 生成logger实例


def demo():
    logger.debug("start range... time:{}".format(time.time()))
    logger.info("中文测试开始。。。")
    for i in range(10):
        logger.debug("i:{}".format(i))
        time.sleep(0.2)
    else:
        logger.debug("over range... time:{}".format(time.time()))
    logger.info("中文测试结束。。。")

if __name__ == "__main__":
    my_logging.load_my_logging_cfg()  # 在你程序文件的入口加载自定义logging配置
    demo()

使用

澳门葡京备用网址 33澳门葡京备用网址 34

#1、有了上述方式我们的好处是:所有与logging模块有关的配置都写到字典中就可以了,更加清晰,方便管理


#2、我们需要解决的问题是:
    1、从字典加载配置:logging.config.dictConfig(settings.LOGGING_DIC)

    2、拿到logger对象来产生日志
    logger对象都是配置到字典的loggers 键对应的子字典中的
    按照我们对logging模块的理解,要想获取某个东西都是通过名字,也就是key来获取的
    于是我们要获取不同的logger对象就是
    logger=logging.getLogger('loggers子字典的key名')


    但问题是:如果我们想要不同logger名的logger对象都共用一段配置,那么肯定不能在loggers子字典中定义n个key   
 'loggers': {    
        'l1': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上(更高level的logger)传递
        },
        'l2: {
            'handlers': ['default', 'console' ], 
            'level': 'DEBUG',
            'propagate': False,  # 向上(更高level的logger)传递
        },
        'l3': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上(更高level的logger)传递
        },

}


#我们的解决方式是,定义一个空的key
    'loggers': {
        '': {
            'handlers': ['default', 'console'], 
            'level': 'DEBUG',
            'propagate': True, 
        },

}

这样我们再取logger对象时
logging.getLogger(__name__),不同的文件__name__不同,这保证了打印日志时标识信息不同,但是拿着该名字去loggers里找key名时却发现找不到,于是默认使用key=''的配置

log配置字典相关题材

1.5.1 什么是包

包就是贰个暗含有__init__.py文件的文本夹,所以其实大家创制包的目标就是为了用文件夹将文件/模块社团起来

亟待强调的是:

  1. 在python3中,尽管包下没有__init__.py文件,import
包还是不会报错,而在python2中,包下一定要有该公文,否则import 包报错

 

  2.
创立包的目的不是为了运维,而是被导入使用,记住,包只是模块的一种样式而已,包的精神就是一种模块

1.5.2 为什么要拔取包

包的面目就是2个文书夹,那么文件夹唯一的效用就是将文件协会起来

乘胜功用越写愈多,大家无能为力将就此作用都放到1个文本中,于是大家使用模块去社团听从,而随着模块越多,大家就需求用文件夹将模块文件社团起来,以此来提升程序的结构性和可维护性

注意事项:

#1.有关包相关的导入语句也分为import和from … import
…三种,可是无论哪个种类,无论在怎么着岗位,在导入时都必须比照多个规范:凡是在导入时带点的,点的左手都必须是2个包,否则不合规。可以涵盖接二连三串的点,如item.subitem.subsubitem,但都必须比照这些条件。但对此导入后,在采用时就不曾那种范围了,点的左侧可以是包,模块,函数,类(它们都可以用点的法门调用本身的习性)。

#二,import导入文本时,发生名称空间中的名字来自文件,import
包,爆发的称呼空间的名字如出一辙来自文件,即包下的__init__.py,导入包本质就是在导入该公文

#三,包A和包B下有同超级模特块也不会争持,如A.a与B.a来自俩个命名空间

1.5.2 为啥要选择包

包的真相就是三个文本夹,那么文件夹唯一的功能就是将文件社团起来

随着功能越写更加多,大家无能为力将为此成效都放到二个文本中,于是大家使用模块去协会效能,而随着模块愈多,大家就需求用文件夹将模块文件社团起来,以此来增进程序的结构性和可维护性

注意事项:

#1.关于包相关的导入语句也分为import和from … import
…二种,可是不论哪一种,无论在怎么地点,在导入时都不可以不根据三个规则:凡是在导入时带点的,点的左边都不可以不是壹个包,否则不合规。可以分包一而再串的点,如item.subitem.subsubitem,但都必须按照那几个规格。但对此导入后,在行使时就没有那种限制了,点的左边可以是包,模块,函数,类(它们都足以用点的措施调用本身的性格)。

#二,import导入文本时,暴发名称空间中的名字来自文件,import
包,发生的称号空间的名字同样来自文件,即包下的__init__.py,导入包本质就是在导入该公文

#叁,包A和包B下有同有名的模特块也不会争辨,如A.a与B.a来自俩个命名空间

2.示例

|----示例
|    |---bin
|    |    |----start.py  #启动文件
|    |
|    |---conf
|    |    |----settings.py   #配置文件(logging配置)
|    |
|    |---core
|    |    |----  src.py   #业务核心逻辑
|    |
|    |---lib
|    |    |---- common.py    #公共库
|    |
|    |---  log    #日志

澳门葡京备用网址 35澳门葡京备用网址 36

import os

BASE_DIR=os.path.dirname(os.path.dirname(__file__))


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文件的全路径
fh1_logfile_path = r'%s\%s\%s' %(BASE_DIR,'log','b1.log')
fh2_logfile_path = r'%s\%s\%s' %(BASE_DIR,'log','b2.log')

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志,使用的格式为 simple_format
        'ch': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件b1.log的日志,使用的格式为 standard_format
        'fh1': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': fh1_logfile_path,  # 日志文件
            'encoding': 'utf-8',  # 日志文件的编码,再也不用担心中文log乱码了
        },
        #打印到文件b2.log的日志,使用的格式为 standard_format
        'fh2': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': fh2_logfile_path,  # 日志文件
            'encoding': 'utf-8',  # 日志文件的编码,再也不用担心中文log乱码了
        },
    },
    'loggers': {
        '': {
            'handlers': ['ch', 'fh1','fh2'],  # 这里把上面定义的两个handler都加上,即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

settings配置

澳门葡京备用网址 37澳门葡京备用网址 38

from conf import settings
import logging.config

def get_logger(name):
    logging.config.dictConfig(settings.LOGGING_DIC)
    logger1=logging.getLogger(name)
    return logger1

common.py

澳门葡京备用网址 39澳门葡京备用网址 40

from lib import common

logger1=common.get_logger("交易日志")

def shopping():
    print('购物')

def pay():
    print('支付')
    logger1.info('蘑菇 支付了1元')

def transfer():
    print('转账')
    logger1.info('蘑菇给小火柴支付了200元')


def withdraw():
    print('提现')
    logger1.info('蘑菇提现200元')

func_dic={
    '1': shopping,
    '2': pay,
    '3': transfer,
    '4': withdraw
}

def run():
    while True:
        print("""
        0 退出
        1 购物
        2 支付
        3 转账
        4 提现
        """)
        choice=input('请输入您的操作: ').strip()
        if choice == '0':break
        if choice not in func_dic:
            print("输入的指令不存在,请重新输入")
            continue
        func_dic[choice]()

src.py

澳门葡京备用网址 41澳门葡京备用网址 42

import sys
import os

BASE_DIR=os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)

from core import src

if __name__ == '__main__':
    src.run()

start.py

 

1.5.2 为什么要使用包

包的实质就是三个文件夹,那么文件夹唯一的职能就是将文件协会起来

乘机作用越写越来越多,大家鞭长莫及将据此功效都停放贰个文件中,于是我们运用模块去协会效果,而随着模块越多,大家就须求用文件夹将模块文件协会起来,以此来做实程序的结构性和可维护性

注意事项:

#1.关于包相关的导入语句也分为import和from … import
…二种,然而无论是哪一类,无论在怎么着职位,在导入时都必须按照二个准绳:凡是在导入时带点的,点的左边都必须是多个包,否则违规。可以包括连续串的点,如item.subitem.subsubitem,但都不或然不依据这些规则。但对于导入后,在行使时就一直不那种范围了,点的左边可以是包,模块,函数,类(它们都可以用点的格局调用自个儿的性能)。

#二,import导入文本时,暴发名称空间中的名字源于文件,import
包,爆发的名号空间的名字如出一辙来自文件,即包下的__init__.py,导入包本质就是在导入该文件

#三,包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.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是破绽百出语法

五、re 模块(正则匹配)

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 绝对导入和周旋导入

小编们的最一级包glance是写给外人用的,然后在glance包内部也会有互相之间互相导入的须要,那时候就有相对导入和相持导入二种办法:

纯属导入:以glance作为开场

相对导入:用.只怕..的章程最好先导(只可以在一个包中使用,不可能用于差距目录内)

 一、什么是正则

正则就是
用一些切实特殊意义的符号组合到一起(称为正则表明式)来讲述字符或字符串的主意。或许说正则就是用来描述一类东西的条条框框。python中,它内嵌在python中,并透过re模块已毕。

正则表明式被编译成一各类的字节码,然后由C编写的格外引擎执行。

生存中各处是正则:

  比如大家讲述:4条腿

    就会想到四条腿的动物恐怕桌子,椅子

  再描述:四条腿,活的

    就只有四条腿的动物那类

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.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')

 

二、常用匹配格局(元字符)

澳门葡京备用网址 43

#==========================re模块  正则表达式=============================
import re
#1、 \w匹配数字字母下划线
print(re.findall('\w','hello 123 - _ *()'))
#['h', 'e', 'l', 'l', 'o', '1', '2', '3', '_']
print(re.findall('mogu','hello mogu, mogu say hello'))#前面mogu代表完全匹配
#['mogu', 'mogu']

#2、 \W 上方的取反
print(re.findall('\W','hello 123 - _ *()'))
#[' ', ' ', '-', ' ', ' ', '*', '(', ')']

#3、 \s 匹配任意空白字符
print(re.findall('\s','666 \t jiayou'))
#[' ', '\t', ' ']
#    \S 上方取反

#4、 \d 匹配任意数字   \D 取反匹配任意数字
print(re.findall('\d','666 \t jia\nyou'))
#['6', '6', '6']

#5、 \n 只匹配换行符, \t 只匹配制表符
print(re.findall('\n','666 \t jia\nyou'))
print(re.findall('\t','666 \t jia\nyou'))
#['\n']
#['\t']

#6、 ^ 匹配字符串的开头   $ 匹配字符串的结尾
print(re.findall('^mogu','hello mogu, mogu say hello'))
print(re.findall('mogu$','hello mogu, mogu say hello mogu'))
# ^结果为空 只匹配开头
# $ ['mogu']  只匹配匹配末尾

#7、 . :点 代表匹配除了换行符以外的任意单个字符
print(re.findall('a.c','a-c a*c a2c a\nc aacacacacac a c a\tc',re.DOTALL))
# ['a-c', 'a*c', 'a2c', 'aac', 'a c', 'a\tc']
# re.DOTALL  可以让换行符也匹配出来

#8、 [] : 代表匹配指定范围的任意字符
print(re.findall('\d[-+*/]\d','1+2 3!3 qweasd 2+3 1/2 2-3 axcz hello'))
#['1+2', '2+3', '1/2', '2-3']
print(re.findall('a[0-9]c','a1c aAc a2c acc axc a23c a*c a9c'))
#['a1c', 'a2c', 'a9c']
print(re.findall('a[0-9][0-9]c','a1c aAc a2c acc axc a23c a*c a9c'))
#['a23c']
print(re.findall('a[a-z]c','a1c aAc a2c acc axc a23c a*c a9c'))
#['acc', 'axc']
print(re.findall('a[A-Z]c','a1c aAc a2c acc axc a23c a*c a9c'))
#['aAc']

#9、重复匹配
#9.1  ? : 代表左边那一个字符出现0次或者1次 可以用{0,1}
print(re.findall('ab?','b ab abb bbabbabbabba'))
#['ab', 'ab', 'ab', 'ab', 'ab', 'a']

#9.2  * :代表左边那一个字符出现0次或者无穷次,如果没有可以凑合,但如果>1个,有多少就必须拿多少
#   可以用{0,}
print(re.findall('ab*','b ab abb bbabbababba'))
#['ab', 'abb', 'abb', 'ab', 'abb', 'a']

#9.3  + :代表左边那一个字符出现1次或者无穷次,至少要有一个,但如果有>1个,有多少就必须拿多少
#   可以用{1,}
print(re.findall('ab+','b ab abb bbabbabbabba'))
#['ab', 'abb', 'abb', 'abb', 'abb']

#9.4 {n,m}:代表左边那一个字符出现n次到m次,至少要有n个,但如果有>n个,就拿<=m个
print(re.findall('ab{2,5}','b ab abb bbabbabbabba abbbbbbbb'))
#['abb', 'abb', 'abb', 'abb', 'abbbbb']

#9.5  .* : 匹配0个或无穷个任意字符,默认是贪婪匹配
print(re.findall('a.*c','a123c hello ab123  c321 mogu c'))
# ['a123c hello ab123  c321 mogu c'] 找离a最远的c

#9.6  .*? : 匹配0个或无穷个任意字符,非贪婪匹配
print(re.findall('a.*?c','a123c hello ab123  c321 mogu c'))
#['a123c', 'ab123  c']  找离a最近的c

#示例: 正则使用非贪婪匹配 ()括号的意思是  只取分组内的内容
print(re.findall('href="(.*?)"',''
    '<div class="div1"><a href="https://www.baidu.com">点我啊</a>'
    '</div><div class="div1"><a href="https://www.python.org">点我啊</a></div>'))

澳门葡京备用网址 44澳门葡京备用网址 45

#[]
print(re.findall('a[1*-]b','a1b a*b a-b')) #[]内的都为普通字符了,且如果-没有被转意的话,应该放到[]的开头或结尾
print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反,所以结果为['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反,所以结果为['a=b']
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]内的^代表的意思是取反,所以结果为['a=b']
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]内的^代表的意思是取反,所以结果为['a=b']

#\# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时,会发生转义,然后交给re去执行,所以抛出异常
print(re.findall(r'a\\c','a\c')) #r代表告诉解释器使用rawstring,即原生字符串,把我们正则内的所有符号都当普通字符处理,不要转义
print(re.findall('a\\\\c','a\c')) #同上面的意思一样,和上面的结果一样都是['a\\c']

#():分组
print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123')) #['ab'],匹配到末尾的ab123中的ab
print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容,而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))#['http://www.baidu.com']
print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))#['href="http://www.baidu.com"']

#|
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

补充

澳门葡京备用网址 46澳门葡京备用网址 47

import re
#1 findall
print(re.findall('e','mogu like read') )   #['e', 'e'],findall返回所有满足匹配条件的结果,放在列表里
#2 search
print(re.search('e','mogu like read').group())# e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。

#3 match
print(re.match('e','mogu like read'))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match

#4 split
print(re.split('[ ]','mogu like read'))     #['mogu', 'like', 'read'],先按'空格'分割得到'mogu' 'like' 'read'

#5
print('===>',re.sub('m','M','mogu like read movie')) #===> Mogu like read Movie,不指定n,默认替换所有
print('===>',re.sub('m','M','mogu like read movie',1)) #===> Mogu like read movie
print('===>',re.sub('m','M','mogu like read movie',2)) #===> Mogu like read Movie
print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1','mogu like read movie')) #===> read like mogu

print('===>',re.subn('m','M','mogu like read movie')) #===> ('Mogu like read Movie', 2),结果带有总共替换的个数

#6
obj=re.compile('\d{2}')  #封装一种正则匹配模式

print(obj.search('abc123eeee').group()) #12
print(obj.findall('abc123eeee')) #['12'],重用了obj

#=======================================
print(re.findall(r'-?\d+\.?\d*',"1-12*(60+(-40.35/5)-(-4*3))")) #找出所有数字['1', '-12', '60', '-40.35', '5', '-4', '3']


#使用|,先匹配的先生效,|左边是匹配小数,而findall最终结果是查看分组,所有即使匹配成功小数也不会存入结果
#而不是小数时,就去匹配(-?\d+),匹配到的自然就是,非小数的数,在此处即整数
print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) #找出所有整数['1', '-2', '60', '', '5', '-4', '3']

re模块的办法

澳门葡京备用网址 48澳门葡京备用网址 49

#为何同样的表达式search与findall却有不同结果:
print(re.search('\(([\+\-\*\/]*\d+\.?\d*)+\)',"1-12*(60+(-40.35/5)-(-4*3))").group()) #(-40.35/5)
print(re.findall('\(([\+\-\*\/]*\d+\.?\d*)+\)',"1-12*(60+(-40.35/5)-(-4*3))")) #['/5', '*3']

#看这个例子:(\d)+相当于(\d)(\d)(\d)(\d)...,是一系列分组
print(re.search('(\d)+','123').group()) #group的作用是将所有组拼接到一起显示出来
print(re.findall('(\d)+','123')) #findall结果是组内的结果,且是最后一个组的结果

findall与search

总计:尽量简洁,详细的如下

尽心尽力拔取泛匹配方式.*

尽可能使用非贪婪方式:.*?

拔取括号得到匹配目标:用group(n)去取得结果

有换行符就用re.S:修改格局

 

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.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

 

六、time与datetime模块

持续记录    常用模块 与 面向对象

未完待续。。。

 

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 软件开发规范

 澳门葡京备用网址 50

 

图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.7 软件开发规范

 澳门葡京备用网址 51

 

图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.7 软件开发规范

 澳门葡京备用网址 52

 

图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.8 常用模块

1.8.1 日志模块的详细用法:

import logging

1.8.1 日志模块的事无巨细用法:

import logging

1.8.1 日志模块的详尽用法:

import logging

1.8.2 Logger:产生日志

logger1=logging.getLogger(‘访问日志’)

# logger2=logging.getLogger(‘错吴日志’)

1.8.2 Logger:暴发日志

logger1=logging.getLogger(‘访问日志’)

# logger2=logging.getLogger(‘错吴日志’)

1.8.2 Logger:暴发日志

logger1=logging.getLogger(‘访问日志’)

# logger2=logging.getLogger(‘错吴日志’)

1.8.3 Filter:大致不用

1.8.3 Filter:大约不用

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.4 Handler:接收Logger传过来的日志,举行日志格式化,可以打印到终极,也得以打印到文件

sh=logging.StreamHandler() #打印到巅峰

fh1=logging.FileHandler(‘s1.log’,encoding=’utf-8′)

fh2=logging.FileHandler(‘s2.log’,encoding=’utf-8′)

 

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.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.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.6 、为handler绑定日志格式

sh.setFormatter(formatter1)

fh1.setFormatter(formatter2)

fh2.setFormatter(formatter3)

 

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.7 、为logger绑定handler

logger1.addHandler(sh)

logger1.addHandler(fh1)

logger1.addHandler(fh2)

 

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.8 设置日志级别:logger对象的日志级别相应<=handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

sh.setLevel(10)

fh1.setLevel(10)

fh2.setLevel(10)

 

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.8.9 测试

logger1.debug(‘测试着玩’)

logger1.info(‘运营还算不奇怪’)

logger1.warning(‘恐怕要有bug了’)

logger1.error(‘不好了,真tm出bug了’)

logger1.critical(‘完犊子,推倒重写’)

 

1.8.9 测试

logger1.debug(‘测试着玩’)

logger1.info(‘运维还算平常’)

logger1.warning(‘或然要有bug了’)

logger1.error(‘不好了,真tm出bug了’)

logger1.critical(‘完犊子,推倒重写’)

 

1.9 日志的接续

import logging

1.9 日志的持续

import logging

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.1 Logger:暴发日志

logger1=logging.getLogger(‘root’)

logger2=logging.getLogger(‘root.child1’)

logger3=logging.getLogger(‘root.child1.child2’)

 

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.2 Filter:大概不用

 

1.9.2 Filter:大致不用

 

1.9.3 Handler:接收Logger传过来的日志,举办日志格式化,可以打印到巅峰,也可以打印到文件

sh=logging.StreamHandler() #打印到极点

 

1.9.3 Handler:接收Logger传过来的日记,举办日志格式化,可以打印到巅峰,也能够打印到文件

sh=logging.StreamHandler() #打印到极限

 

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.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.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.5 为handler绑定日志格式

sh.setFormatter(formatter1)

 

1.9.5 为handler绑定日志格式

sh.setFormatter(formatter1)

 

1.9.6 为logger绑定handler

logger1.addHandler(sh)

logger2.addHandler(sh)

logger3.addHandler(sh)

 

1.9.6 为logger绑定handler

logger1.addHandler(sh)

logger2.addHandler(sh)

logger3.addHandler(sh)

 

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.7 设置日志级别:logger对象的日志级别相应<=handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

logger2.setLevel(10) #

logger3.setLevel(10) #

sh.setLevel(10)

 

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.9.8 测试

logger1.debug(‘爷爷’)

logger2.debug(‘爸爸’)

logger3.debug(‘孙子’)

 

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*

 

#+:代表+号左边的字符出现3次照旧无穷次

# 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.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*

 

#+:代表+号左侧的字符现身三次或然无穷次

# 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.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

 

#[]:取中括号内任意的3个

# 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))

 

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))

 

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))

 

1.1 模块 1.1.1 模块介绍
常见的场景:一个模块就是二个蕴涵了一组功用的python文件,比如spam.py,模块名为spam,可以通…

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website