模块导入方法

1、import 语句

  1. import module1[,module2[,...moduleN]]

当我们使用import语句的时候,Python解释器是怎么找到对应对文件对呢?
答案是解释器有自己的搜索路径,存在sys.path里
2、form ...import 语句

  1. from modname import name1[,name2,[,...nameN]]

3、from...import *

  1. from...import *

注意:

使用impor会执行下面的动作

1、执行对应文件

2、引入变量名

引用多个模块时,可以用逗号隔开

例子:

  1. def add(x,y):
  2. return x+y
  3.  
  4. def sub(x,y):
  5. return x-y

cal.py

引入该模块有下面的写法

  1. import cal
  2. from cal import add
  3. from cal import sub
  4. from cal import * #引入所有,不推荐

例子:

  1. import cal
  2.  
  3. def run():
  4. print(cal.add(3,7))

main.py

  1. from my_lenson import main
  2.  
  3. main.run()

bin.py

结果:

执行bin.py文件报错,找不到模块名cal。main.py中的模块引用应改成 from  my_lenson import cal
另一种方式是把路径添加到sys.path列表中。

引入的路径只认执行文件的路径。执行bin文件程序会把..\lenson添加到sys.path列表中。能通过头部模块引用找到my_lenson下的main文件,但是main文件中代码import cal只能在路径..\lenson中找所以找不到。

#补充
import sys
sys.path.append() 只是做临时修改,永久修改在系统的环境变量里操作。

例子:

如果目录结构为web\web1\web2\cal.py,要调用cal中的cal函数,写法

  1. from web.web1.web2 import cal
  2. print(cal.add(2,5))
  3.  
  4. from web.web1.web2.cal import add
  5. print(add(2,6))
  6.  
  7. from web.web1 import web2 #引用都会执行web,web1,web2的__init__文件,唯一不支持的调用方式
  8. print(web2.cal.add(2,5)) #报错

补充:

print(__name__)在执行文件的执行结果是__main__;在调用文件的执行结果是显示文件名。

  1. if __name__=="__main__":#调试的时候可以使用:执行的时候会执行,引用的时候不会执行

功能1:用于被调用函数的测试

功能2:不让其他人随意执行自己的程序

如果我们是直接执行某个.py文件的时候,该文件中"__name__=='__main__'"是true,但是我们如果从另一个.py文件通过import导入该文件对时候,这时__name__的值是这个py文件名字而不是__main__。结果是false所以不会运行下面的代码。

调试代码的时候,在"if __name__=='__main__'"中加入一些我们的调试代码,我们可以让外部模块调用的时候不执行我们的调试代码,但是如果我们想排查问题的时候,直接执行该模块文件,调试代码能够正常执行

补充:

执行bin,调用my_lenson下的main

有这三种写法:

  1. import sys,os
  2. #方式一
  3. sys.path.append(r"D:\PycharmProjects\test1\lenson") #写死的。不推荐
  4.  
  5. #方式二
  6. BASE_DIR=os.path.dirname(os.path.dirname(__file__))#pycharm可以,在终端下执行不行.__file__只能得到文件名
  7. sys.path.append(BASE_DIR)
  8.  
  9. #方式三
  10. BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  11. sys.path.append(BASE_DIR)
  12.  
  13. from my_lenson import main
  14. main.run()

time时间模块

1、time模块时间的格式转化

  1. import time
  2. #时间戳
  3. print(time.time()) #1970年1月1日。到现在经过的秒数
  4. print(time.localtime()) #结构化时间对象,当地时间
  5. #默认相当于localtime(time.time())
  6. t=time.localtime()
  7. print(t.tm_year)
  8. print(t.tm_wday) #一周的第几天
  9.  
  10. print(time.gmtime()) #标准时间UTC,世界统一时间。
  11.  
  12. #=====时间格式的转化=====
  13. #结构化时间转化成时间戳
  14. print(time.mktime(time.localtime()))
  15.  
  16. #将结构化时间转化成字符串时间
  17. print(time.strftime("%Y-%m-%d %X",time.localtime())) #%X表示时分秒
  18.  
  19. #将字符串时间转化成结构化时间
  20. print(time.strptime("2016:12:24:15:50:36","%Y:%m:%d:%X"))
  21.  
  22. #=========将时间格式转化成一种一种固定好的格式===========
  23. #将结构化时间转化成一种固定好的时间格式
  24. #默认是转化的当前时间
  25. print(time.asctime()) #显示格式为:Wed Feb 12 18:24:02 2020
  26. #将时间戳转化成一种固定好的时间格式
  27. print(time.ctime()) #显示格式为:Wed Feb 12 18:24:02 2020

2、其他方法

sleep():

clock() #不常用,在win系统中指时间差

*time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead

3、datetime模块

  1. import datetime
  2. print(datetime.datetime.now())#2020-02-12 18:32:05.267959

random模块

  1. import random
  2. ret=random.random() #(0,1)--float
  3. print(ret)
  4.  
  5. print(random.randint(1,3)) #[1,2,3]
  6. print(random.randrange(1,3))#[1,3),不含3
  7. print(random.choice([1,'',[4,5]]))#从列表里随机取值
  8. print(random.sample([11,22,33,44],2))#随机选2个,结果是列表
  9. print(random.uniform(1,4)) #1到4的浮点数
  10.  
  11. ret=[1,2,3,4,5]
  12. random.shuffle(ret)
  13. print(ret) #把顺序打乱的一个列表 [1, 3, 5, 2, 4]

例子:生成一个随机验证码

  1. def v_code():
  2. ret=''
  3. for i in range(5):
  4. num=random.randint(0,9)
  5. alf=chr(random.randint(65,122))
  6. s=str(random.choice([num,alf]))
  7. ret+=s
  8. return ret
  9. print(v_code())

os模块

  1. import os
  2. print(os.getcwd()) #获取当前工作目录,即当前python脚本工作的目录路径
  3. os.chdir("lenson")# 改变当前脚本工作目录,相当于shellcd
  4. print(os.curdir) #返回当前目录:("."),不常用
  5. print(os.pardir) #获取当前目录的父目录字符串名:("..") ,不常用
  6. os.makedirs("dirname1/dirname2") #可生成多层递归目录
  7. os.removedirs(r"D:\PycharmProjects\test1\lenson\dirname1\dirname2") #若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依次类推
  8. os.mkdir("dirname") #生成单级目录;相当于shell中mkdir dirname
  9. os.rmdir(r"D:\PycharmProjects\test1\lenson\dirname1\dirname2") #删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
  10. print(os.listdir(r"D:\PycharmProjects\test1\lenson")) #列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
  11. os.remove() #删除一个文件
  12. os.rename("oldname","newname") #重命名文件/目录
  13. print(os.stat(r"D:\PycharmProjects\test1\lenson\bin.py"))#获取文件/目录信息,大小,修改时间等
  14. os.sep #输出操作系统特定的路径分割符,win下为"\\",linux下为"/"
  15. print(os.linesep) #输出当前平台的行终止符,win 下为"\r\n",linux下为"\n"
  16. print(os.pathsep) #输出用于分割文件路径的字符串 win下为;,linux下为:
  17. print(os.name) #输出字符串指示当前使用平台。win->"nt";linux->"posix" ,不常用
  18. os.system("bash command") #运行shell命令,直接显示,不常用
  19. print(os.environ)# 获取系统环境变量,不常用
  20. os.path.abspath(path) #返回path规范化的绝对路径
  21. os.path.split(path) #将path分割成目录和文件名二元组返回
  22. os.path.dirname(path) #返回path的目录。其实就是os.path.split(path)的第一个元素
  23. os.path.basename(path) #返回path最后的文件名。如果path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
  24. os.path.exist(path) #如果path存在,返回true;不存在返回false
  25. os.path.isabs(path) #如果path是绝对路径,返回true
  26. os.path.isfile(path) #如果path是一个存在的文件,返回true,否则返回false
  27. os.path.isdir(path) #如果path是一个存在的目录,则返回true,否则返回false
  28. os.path.join(path1[,path2[,...]]) #将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
  29. os.path.getatime(path) #返回path所指向的文件或者目录的最后存取时间
  30. os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间

sys模块

  1. sys.argv 命令行参数list,第一个元素是程序本身路径
  2. #sys.argv[1],sys.argv[2]。显示传的参数。比如上传下载的时候可以使用。
  3. sys.exit(n) 退出程序,正常退出时exit(0)
  4. sys.version 获取python解释程序的版本信息
  5. sys.maxint() 最大Int
  6. sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
  7. sys.platform 返回操作系统平台名称

例子:进度条显示

  1. import time
  2. for i in range(100):
  3. sys.stdout.write("#") #向屏幕显示对应的内容。print是以此为基础的。
  4. time.sleep(0.2)
  5. sys.stdout.flush() #程序通过sys的接口把要输出的内容放在了缓存里,最后才显示到终端,所以加个刷新。

json&pickle模块

之前讲用eval内置方法可以将一个字符串转成python对象,不过,eval方法是有局限性的,对于普通的数据类型,json.loads和eval都能用,但遇到特殊类型的时候,eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式,并返回表达式的值。

如:

  1. import json
  2. x="[null,true,false,1]"
  3. print(eval(x)) #报错
  4. print(json.loads(x))

方法:

json.dumps()   转化成字符串,封装成json格式的字符串
json.loads()

什么是序列化?

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening等等,都是一个意思。

序列化之后,就可以把序列化后的内容写入磁盘,或者通过网络传输到别的机器上。

反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即unpickling。

json

如果我们要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如XML,但更好的方法是序列化为JSON,因为JSON表示出来就是一个字符串,可以被所有语言读取,也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式,并且比XML更快,而且可以直接在Web页面中读取,非常方便。

JSON表示的对象就是标准的JavaScript语言的对象,JSON和Python内置的数据类型对应如下

  1. import json
  2. '''
  3. dic={'name':'jobs'} #-->{"name":"jobs"}-->'{"name":"jobs"}'
  4. i=8 #-->'8'
  5. s='hello' #-->"hello"-->'"hello"'
  6. l=[11,22] #-->"[11,22]"
  7. '''
  8. #------序列化-----
  9. dic={'name':'jobs'}
  10. f=open("序列化对象","w")
  11. dic_str=json.dumps(dic) #转化成json格式的字符串,如上的形式,单引号会变成双引号
  12. f.write(dic_str) #----等价于json.dump(dic,f)
  13. f.close()
  14.  
  15. #------反序列化-----
  16. import json
  17. f=open("序列化对象")
  18. data=json.loads(f.read()) #---等价于data=json.load(f)
  1. 注意:无论数据是怎样创建的,只要满足json格式,就可以json.loads出来,不一定非要dumps的数据才能loads
  1. import json
  2. # dct="{'a':'111'}" #报错,json不认单引号
  3. # dct=str({"a":"111"}) #报错,因为生成的数据还是单引号
  4.  
  5. dct='{"a":"111"}'
  6. print(json.loads(dct))

pickle

#pickle与json在使用上是完全一致的。pickle在序列化处理成字节bytes。json是处理成字符串str
#pickle支持的数据类型更多。类,函数。但是用处需求少很少用。

如:

  1. import pickle
  2.  
  3. #------序列化-----
  4. dic={'name':'jobs'}
  5. f=open("序列化对象","wb") #注意是w是写入str,wb是写入bytes
  6. dic_p=pickle.dumps(dic) #dic_p是'bytes'
  7. f.write(dic_str) #----等价于pickle.dump(dic,f)
  8. f.close()
  9.  
  10. #------反序列化-----
  11. import pickle
  12. f=open("序列化对象","rb")
  13. data=pickle.loads(f.read()) #---等价于data=pickle.load(f)

shelve模块  

shelve模块比pickle模块简单,只有一个open函数,返回类似字典的对象,可读可写;key必须为字符串,而值可以是python所支持的数据类型

  1. import shelve
  2. f=shelve.open(r'shelve') #目的:将一个字典放入文本
  3. f['stu1_info']={'name':'steven','age':''}
  4. f['stu2_info']={'name':'job','age':''}
  5. f.close()
  6.  
  7. print(f.get('stu1_info')['age']) #反序列化

xml模块

xml是实现不同语言或程序之间进行数据交换的协议,跟json差不多,但json使用起来更简单,不过,古时候,在json还没诞生的黑暗年代,大家只能选择用xml呀,至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下,就是通过<>节点来区别数据结构的:

  1. import xml.etree.ElementTree as ET
  2.  
  3. tree=ET.parse(r"C:\Users\Administrator\Desktop\test.xml")
  4. root=tree.getroot()
  5. print(root.tag)
  6. #----遍历-----
  7. for child in root:
  8. print(child.tag,child.attrib)
  9. for i in child:
  10. print(i.tag,i.text)
  11. #----只遍历某个节点----
  12. for node in root.iter('year'):
  13. print(node.tag,node.attrib)
  14. #----修改----
  15. for node in root.iter('year'):
  16. new_year=int(node.text)+1
  17. node.text=str(new_year)
  18. node.set("updated","yes")
  19. tree.write("abc.xml")
  20. #-----删除----
  21. for country in root.findall("country"):
  22. rank=int(country.find("rank").text)
  23. if rank > 50:
  24. root.remove(country)
  25. tree.write("output.xml")
  26. #-----创建-----
  27. import xml.etree.ElementTree as ET
  28. new_xml=ET.Element("data")
  29. country=ET.SubElement(new_xml,"country",attrib={"name":"American"})
  30. rank=ET.SubElement(country,"rank")
  31. rank.text=''
  32. year=ET.SubElement(country,"year",attrib={"checked":"no"})
  33. year.text=''
  34. country=ET.SubElement(new_xml,"country",attrib={"name":"china"})
  35. rank=ET.SubElement(country,"rank")
  36. rank.text=''
  37. year=ET.SubElement(country,"year",attrib={"checked":"yes"})
  38. year.text=''
  39. et=ET.ElementTree(new_xml) #生成文档对象
  40. et.write("test.xml",encoding="utf-8",xml_declaration=True)
  41. ET.dump(new_xml)

re模块

本质而言,正则表达式(或 RE)是一种小型的、高度专业化的编程语言,(在Python中)它内嵌在Python中,并通过 re 模块实现。正则表达式模式被编译成一系列的字节码,然后由用 C 编写的匹配引擎执行。

字符匹配(普通字符,元字符):

1 普通字符:大多数字符和字母都会和自身匹配
              >>> re.findall('jobs','yuanaleSxjobszhoumo')
                      ['jobs']

2 元字符:. ^ $ * + ? { } [ ] | ( ) \

  1. import re
  2. #.:通配符,什么都能匹配,除了换行符
  3. re.findall("a..x","adsfaeexkksdjfis")
  4. #^:表示以什么开头
  5. re.findall("^a..x","adsxfajdkfjkadfjka") #匹配以a开头。。。
  6. #$:表示以什么结尾
  7. re.findall("a..x$","adfakfjakfjasix")#匹配结尾是x
  8. #*+{}? 可以匹配重复
  9. #*:表示0到无穷次
  10. #+:1到无穷次
  11. re.findall("^d*","ddddfajdfkajdfk")
  12. re.findall("seex*","asdkfafdaseexxx")
  13. re.findall("seex+","asdkfafdaseexxx")
  14. re.findall("seex*","asdkfafdseele")#0次能匹配上 ['see']
  15. re.findall("seex+","asdkfafdseele")#不能匹配上
  16. #?:表示0或1次
  17.  
  18. #{};表示自己定义次数
  19. '''
  20. {0,} == *
  21. {1,} == +
  22. {0,1}== ?
  23. {6} 表示匹配重复6次
  24. {1,6} 表示重复1到6次
  25. '''

注意:

  1. 前面的*,+,?等都是贪婪匹配,也就是尽可能匹配,后面加?使其变成惰性匹配
  1. ret=re.findall("abc*?","abcccc")
  2. print(ret)#["ab"]

3 字符集[]

  1. #[]:字符集 - ^ \这三个字符有特殊意义,^在里面表示非。
  2. re.findall("a[bc]","abccc") #['ab']
  3. re.findall("q[a-z]","akjdkfqba")#["qb"] 中括号里只有-有特殊意义。 表示a-z任一字符
  4. re.findall("q[a*z]","adkfjakqadkq*kk")#["qa",q*] 这里的*没有特殊意思。
  5. re.findall("q[a-z]*","qdfjakdjka")#["qdfjakdjka"]
  6. re.findall("q[a-z]*","qdfjakdjka877")#["qdfjakdjka"]
  7. re.findall("q[0-9]*","q38423fkafdkfjq")#["q38423","q"]
  8. re.findall("q[^a-z]","q38djffjk")#["q38"]

4 元字符之转义符\

反斜杠后边跟元字符去除特殊功能,比如\.
反斜杠后边跟普通字符实现特殊功能,比如\d

\d 匹配任何十进制数;相当于类[0-9]
\D 匹配任何非数字字符;相当于类[^0-9]
\s 匹配任何空白字符;相当于类[\t\n\r\f\v]
\S 匹配任何非空白字符;相当于类[^\t\n\r\f\v]
\w 匹配任何字母数字字符;相当于类[a-zA-Z0-9_]
\W 匹配任何非字母数字字符;相当于类[^a-zA-Z0-9_]
\b 匹配一个特殊字符边界,比如空格,&,#等

  1. print(re.findall("I\b","hello I am LIST")) #匹配不上,因为\b在ASCII表中是有意义的
  2. print(re.findall(r"I\b","hello I am LIST"))#加r表示字符串不做转义 ['I']
  3. print(re.findall("I\\b","hello I am LIST"))#['I']
  4. print(re.findall("c\\\\l","abc\lerwt")) #['c\\l']

5元字符()分组

  1. import re
  2. re.findall(r"(ab)+","abccc") #['ab'],未命名的分组
  3. re.search("(?P<name>\w+)","abcccc") #获得一个匹配的对象,命名的分组
  4. re.search("(?P<name>\w+)","abcccc").group()#'abcccc'
  5. #?P是固定的,这个方式可以将匹配的结果赋给一个变量。用于在匹配的结果较多时获取想要的特定值,如下
  6. re.search("(?P<name>[a-z]+)(?P<age>\d+)","steven33jobs22smile45").group("name")#'steven'
  7. re.search("(?P<name>[a-z]+)(?P<age>\d+)","steven33jobs22smile45").group("age")#'33'

注意
#有分组时,匹配的结果会优先返回分组里匹配的内容

  1. re.findall("www\.(baidu|hao123)\.com","www.baidu.com")#['baidu']

#想要匹配的内容,用?:取消权限即可

  1. re.findall("www\.(?:baidu|hao123)\.com","www.baidu.com")#['www.baidu.com']

6元字符|或

  1. ret=re.search('(ab)|\d','rabhdg8sd')
  2. print(ret.group())#ab

7、re模块常用方法

  1. import re
  2.  
  3. #1.findall
  4. re.findall('a','alvin yuan') #返回所有满足匹配条件的结果,放在列表里
  5. #2.search
  6. re.search('a','alvin yuan').group() #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
  7. #通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。
  8. #3.match
  9. re.match("a","abc").group() #同search类似,但是是在字符串开头处进行匹配
  10. #4.split
  11. re.split(" ","hello abc def")
  12. re.split("[ |]","hello abc|def")#['hello', 'abc', 'def']
  13. re.split("[ab]","abc") #['', '', 'c'] 先按a分得到""和"bc",再对""和"bc"按b分割
  14. re.split("[ab]","asdabcd") #['', 'sd', '', 'cd']
  15. #5.sub 替换
  16. re.sub("\d+","A","dafj12dkf345kj88")#'dafjAdkfAkjA' 将匹配的结果用第二个参数替换
  17. re.sub("\d+","A","dafj12dkf345kj88",2)#'dafjAdkfAkj88' 第四个参数为最多匹配替换的次数
  18. re.subn("\d+","A","dafj12dkf345kj88")#('dafjAdkfAkjA', 3) 获取替换后的结果和次数
  19. #6.compile
  20. com=re.compile("\d+")
  21. com.findall("qwe232iieu2123iii666")#['232', '2123', '666']
  22. #7.finditer 把结果放在迭代器里面
  23. ret=re.finditer("\d","dadf873kiiue887")
  24. print(ret)#<callable_iterator object at 0x0399D0B0>
  25. print(next(ret).group())#
  26. print(next(ret).group())#

logging模块

一、简单应用

  1. import logging
  2. logging.debug("debug message")
  3. logging.info("info message")
  4. logging.warning("warning message")
  5. logging.error("error message")
  6. logging.critical("critical message")

结果为:

结论:

  1. 默认情况下Pythonlogging模块将日志打印到了标准输出中,且只显示了大于等于WARNING级别的日志,这说明默认的日志级别设置为WARNING(日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET),
    默认的日志格式为:日志级别:Logger名称:用户输出消息。

二、灵活配置

  1. import logging
  2.  
  3. logging.basicConfig(
  4. level=logging.DEBUG,#配置日志的级别
  5. filename="logger.log", #输出到制定文件中
  6. filemode="w",#写文件的方式
  7. format="%(asctime)s %(filename)s[%(lineno)d] %(message)s"
  8. )
  9.  
  10. #logger对象
  11. logger=logging.getLogger()
  12.  
  13. fh=logging.FileHandler("test_log") #配置输出到文件句柄
  14. ch=logging.StreamHandler() #配置输出到控制台
  15.  
  16. fm=logging.Formatter("%(asctime)s %(message)s")
  17.  
  18. fh.setFormatter(fm)
  19. ch.setFormatter(fm)
  20.  
  21. logger.addHandler(fh)
  22. logger.addHandler(ch)
  23. logger.setLevel("DEBUG")
  24.  
  25. logger.debug("debug")
  26. logger.info("hello")
  27. logger.warning("warning")
  28. logger.error("error")
  29. logger.critical("critical")
  1. 注意1:如果用logger1=logging.getLogger("mylogger")创建。相当于创建了一个root下的子用户mylogger。并且是唯一的。
    再创建一个同名的用户指向的是同一个对象。logger1=logging.getLogger("mylogger.sontree")创建子用户的子用户
    注意2logger=logging.getLogger();logger1=logging.getLogger("mylogger")
    子对象和父对象都存在并且都在输出时。子对象会多输出一次。每向上多一个层级多输出一次。

configparser模块

配置解析

  1. import configparser
  2.  
  3. config=configparser.ConfigParser() #config={}
  4.  
  5. config["DEFAULT"]={'ServerAliveInterval':"",
  6. "Compression":"yes",
  7. "CompressionLevel":""
  8. }
  9.  
  10. config["bitbucket.org"]={}
  11. config["bitbucket.org"]["User"]="hg"
  12.  
  13. config["topsecret.server.com"]={}
  14. topsecret=config["topsecret.server.com"]
  15. topsecret["Host Port"]=""
  16. topsecret["ForwardX11"]="no"
  17.  
  18. config["DEFAULT"]["ForwardX11"]="yes"
  19.  
  20. with open("example.ini","w") as configfile:
  21. config.write(configfile)

结果:

  1. [DEFAULT]
  2. serveraliveinterval = 45
  3. compression = yes
  4. compressionlevel = 9
  5. forwardx11 = yes
  6.  
  7. [bitbucket.org]
  8. user = hg
  9.  
  10. [topsecret.server.com]
  11. host port = 50022
  12. forwardx11 = no

example.ini

增删改查

  1. #----查询----
  2. import configparser
  3.  
  4. config=configparser.ConfigParser()
  5. config.read("example.ini")
  6.  
  7. print(config.sections())#['bitbucket.org', 'topsecret.server.com']
  8. print('bitbucket.org' in config)#True
  9. print(config["bitbucket.org"]["User"])#hg
  10. for key in config["topsecret.server.com"]:#遍历下面的键,结果会包含了默认[DEFAULT]下面的键。
  11. print(key)
  12. print(config.options("bitbucket.org"))#['user', 'serveraliveinterval', 'compression', 'compressionlevel', 'forwardx11'].显示所有的键同上,但是以列表的形式
  13. print(config.items("bitbucket.org"))#[('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('forwardx11', 'yes'), ('user', 'hg')]
  14. #把键和值组成元祖的形式显示
  15. print(config.get("bitbucket.org","compression"))#yes
  16.  
  17. #----删改增----
  18. config.add_section("yuan") #增加一个块
  19. config.set("yuan","k1","")#增加块下面的一个键值对
  20.  
  21. config.remove_section("yuan") #删除一个块
  22. config.remove_option("yuan","k1")#删除块下面的键值对
  23.  
  24. config.write(open("example.ini","w"))

hashlib 模块

  1. 用于加密相关的操作,3.x里代替了md5模块和sha模块,主要提供SHA1,SHA224,SHA256,SHA384,SHA512,MD5算法
  1. import hashlib
  2.  
  3. obj=hashlib.md5()#可以用其他加密算法等 obj=hashlib.sha256()
  4. obj.update("hello".encode("utf8"))
  5. print(obj.hexdigest()) #5d41402abc4b2a76b9719d911017c592 把不定长的字符串转换成定长的秘文
  6.  
  7. obj.update("admin".encode("utf8"))#只执行admin的加密,结果为:21232f297a57a5a743894a0e4a801fc3
  8. print(obj.hexdigest()) #执行上面"hello"加密和"admin"加密,相当于对"helloadmin加密",结果为:dbba06b11d94596b7169d83fed72e61b
  1. 以上加密算法虽然依然非常厉害,但也有存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密
  1. import hashlib
  2. hash=hashlib.sha256("23192idfaljfie82".encode("utf8"))
  3. hash.update("alvin".encode("utf8"))
  4. print(hash.hexdigest())#ea1936a49f75518528fe0f2a60a412b8ff89360bcfe882ff4290bac45fbd26fa
  1. python还有一个hmac模块,它内部对我们创建key和内容再进行处理然后再加密:
  1. import hmac
  2. h=hmac.new("alvin".encode("utf8"))
  3. h.update("hello".encode("utf8"))
  4. print(h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

python学习笔记-模块和包的更多相关文章

  1. Python 2.7 学习笔记 模块和包

    我们来考虑下如下几种场景: 1.编写一个python程序,如果程序比较简单,则可以把代码放到一个python文件中.但如果程序功能比较多,可能需要多个python文件来组织源代码.而这些文件之间的代码 ...

  2. 【Python学习笔记】有关包的基本知识

    python的包(package)是一个有层次的文件目录结构.它定义了一个由模块和子包组成的Python应用程序执行环境. AAA/ __init__.py bbb.py CCC/ __init__. ...

  3. Python学习笔记——模块

    使用模块 python中包的组织方式是模块,一个使用其它模块的例子如下: # Filename: using_sys.py import sys print 'The command line arg ...

  4. 4月8日 python学习总结 模块与包

    一.包 #官网解释 Packages are a way of structuring Python's module namespace by using "dotted module n ...

  5. node 学习笔记 模块和包的管理与使用

    1.前言 对于各种编程语言,代码组织是很重要的.而模块是node中的代码组织机制,node中的很多功能都以模块划分,而模块中又封装了许多方法,而且不会改变全局作用域,极大的方便了各开发者的需求. 2. ...

  6. 吴裕雄--python学习笔记:爬虫包的更换

    python 3.x报错:No module named 'cookielib'或No module named 'urllib2' 1. ModuleNotFoundError: No module ...

  7. Python学习笔记之模块与包

    一.模块 1.模块的概念 模块这一概念很大程度上是为了解决代码的可重用性而出现的,其实这一概念并没有多复杂,简单来说不过是一个后缀为 .py 的 Python 文件而已 例如,我在某个工作中经常需要打 ...

  8. python学习笔记13(模块、包)

    在Python中有一个概念叫做模块(module),比如在Python中要调用sqrt函数,必须用import关键字引入math这个模块,下面就来了解一下Python中的模块. 模块文件以.py后缀结 ...

  9. Python学习笔记(十四):模块高级

    以Mark Lutz著的<Python学习手册>为教程,每天花1个小时左右时间学习,争取两周完成. --- 写在前面的话 2013-7-23 21:30 学习笔记 1,包导入是把计算机上的 ...

随机推荐

  1. 使用Indy解决Could not load SSL Library错误

    测试平台:DelphiXE7 + Indy 10.6.0.5169 + Win7 64bit 步骤: 1. SSL下载版本:openssl-1.0.1j-i386-win32 可去http://yun ...

  2. ACM-寻宝

    题目描述:寻宝 有这么一块神奇的矩形土地,为什么神奇呢?因为上面藏有很多的宝藏.该土地由N*M个小正方形土地格子组成,每个小正方形土地格子上,如果标有“E”,则表示该格可以通过:如果标有“X”,则表示 ...

  3. P1049 数列的片段和

    P1049 数列的片段和 转跳点:

  4. SQL语句--分组统计

    一.教师号 星期号 是否有课1 2 有1 3 有2 1 有3 2 有`1 2 有写一条sql语句让你变为这样的表教师号 星期一 星期二 星期三1 2 12 13 1各星期下的数字表示:对应的教师在星期 ...

  5. Codeforces Round #616 (Div. 2) 题解

    A. Even But Not Even 题意: 定义一个数所有位置的和为偶数它本身不为偶数的数为ebne,现在给你一个数字字符串,你可以删除任意位置上的数字使其变为ebne输出任意改变后的结果,如果 ...

  6. 【机器学习实战学习笔记(2-2)】决策树python3.6实现及简单应用

    文章目录 1.ID3及C4.5算法基础 1.1 计算香农熵 1.2 按照给定特征划分数据集 1.3 选择最优特征 1.4 多数表决实现 2.基于ID3.C4.5生成算法创建决策树 3.使用决策树进行分 ...

  7. 好记性不如烂笔头--shell参数及shell判断if系列

    $0 当前脚本的文件名$n 传递给脚本或函数的参数.n 是一个数字,表示第几个参数.例如,第一个参数是$1,第二个参数是$2$# 传递给脚本或函数的参数个数$* 传递给脚本或函数的所有参数$@ 传递给 ...

  8. sql server C#操作。原文在收藏页面

    C#操作SQL Server数据库   1.概述 2.连接字符串的写法 3.SqlConnection对象 4.SqlCommand对象 5.SqlDataReader对象 6.DataSet对象 7 ...

  9. ACM-DFS Template

    自己写的DFSTemplate: // DFS_Template.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" //DFS的思想是:一直向 ...

  10. css渐变实现

    body{ width: 100%; height: 100%; overflow: hidden; } *{ margin: 0px; padding: 0px; font-size: 0px; } ...