import random

print(random.random())    #float

print(random.randrange(1,4))  #int，在1,2,3中随机选取

print(random.randint(1,5))  #int，在1,2,3,4,5中随机选取

print(random.choice([1,‘23‘,[4,5]]))   #在1,‘23‘,[4,5]这三个项中随机选取

print(random.sample([1,‘23‘,[4,5]],2))  #在1,‘23‘,[4,5]这三个项中随机选取两个

print(random.uniform(1,3))#1.927109612082716 #[1,3)随机选取一个浮点数

l=[1,2,3,4]
print(random.shuffle(l))  #将原有列表顺序随机打乱 
print(l)

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

import json
#--------------序列化---------------------
data=http://www.mamicode.com/{‘a‘:1,‘b‘:2,‘c‘:3}
#--------------json,dumps------------
with open(‘text.log‘,‘w‘) as f:
    data_new=json.dumps(data)
    f.write(data_new)
#--------------json,dump------------
with open(‘text.log‘,‘a‘) as f:
    json.dump(data,f)  # 等于 f.write(json.dumps(data))


#-------------反序列化---------------------
#-----------------json.load-----------------
with open(‘text.log‘,‘r‘,encoding=‘utf8‘) as f:
    data=json.load(f)   #等于 json.loads(f.read())
#-----------------json.loads-----------------
with open(‘text.log‘,‘r‘,encoding=‘utf8‘) as f:
    data=f.read()
    data=json.loads(data)
print(data)

import pickle
#--------------序列化---------------------
data=http://www.mamicode.com/{‘a‘:1,‘b‘:2,‘c‘:3}
# #--------------pickle.dumps------------
with open(‘text.log‘,‘wb‘) as f:  #pickle序列化后的数据类型是bytes，所以写入文档中需要使用二进制模式
    data_new=pickle.dumps(data)
    f.write(data_new)
--------------pickle.dump------------
with open(‘text.log‘,‘wb‘) as f:
    pickle.dump(data,f)  # 等于 f.write(json.pickle(data))


-------------反序列化---------------------
#-----------------pickle.load-----------------
with open(‘text.log‘,‘rb‘) as f:   #读取的数据类型为bytes，所以用二进制的方法读取
    data=http://www.mamicode.com/pickle.load(f)   #等于 pickle.loads(f.read())
#-----------------pickle.loads-----------------
with open(‘text.log‘,‘rb‘) as f:  #读取的数据类型为bytes，所以用二进制的方法读取
    data=http://www.mamicode.com/f.read()
    data=pickle.loads(data)
print(data)

import shelve

f = shelve.open(‘test.txt‘)

#-----------根据序列的形式进行赋值---------
f[‘test1‘]={‘a‘:1,‘b‘:2}
f[‘test2‘]=[1,2,3]   #shelve保存数据后，会生成test.txt.bak; test.txt.dat; test.txt.dir 三个文件

#-----------类似字典的形式查询数据
print(f.get(‘test1‘))
print(f.get(‘test1‘)[‘a‘])

import  xml.etree.ElementTree as ET

tree=ET.parse(‘test.xml‘)
root=tree.getroot()

#---------------------查--------------------------
print(root.tag)    #tag 查看标签名
for item in root:
    print(item.tag,item.attrib)   #attrib 查看属性
    for i in item:
        print(i.tag, i.text)      #text 查看标签间的内容

for item in root:                    #左边结果和下面的输出结果一致，下面的代码更优
    for node in item.iter(‘year‘):  #for node in root.iter(‘year‘):
        print(node.tag, node.text)    #    print(node.tag,node.text)



#---------------------修改-------------------------
for node in root.iter(‘year‘):     #获取year标签
    new_year = int(node.text) + 1      #将原来的内容+1
    node.text = str(new_year)
    node.set("updated","yes")          #更新
    tree.write("test.xml")        #将更新后的树从内存中写入文件

#----------------------删除-------------------------------

for country in root.findall(‘country‘):
    rank = int(country.find(‘rank‘).text)
    if rank > 50:
        root.remove(country)

tree.write(‘output.xml‘)

import re

print(re.findall(‘new‘,‘this is new,so new‘))   #以列表的形式，返回所有匹配到的内容
print(re.search(‘new‘,‘this is new,so new‘))   #以对象的形式，返回第一个匹配到的内容，该对象可以通过group查看
print(re.match(‘new‘,‘this is new,so new‘))    #返回None . match 匹配开头的内容，类似于字符串的startwwith。
print(re.match(‘new‘,‘new,so new‘))             #以对象的形式,返回new
print(re.sub(‘old‘,‘new‘,‘this is old,so old‘))  #将第一个匹配内容 替换为第二个，以字符串的形式返回内容.
print(re.subn(‘old‘,‘new‘,‘this is old,so old‘))#将第一个匹配内容 替换为第二个，以元组的形式返回修改回的内容，及修改的个数
print(re.split(‘,‘,‘1,2,3,4,5‘))  #根据定义的匹配内容，分割字符串，以列表的形式返回

new_re=re.compile(‘old‘)  #如果要大量处理一个同样的规则，可以将该规则使用compile封装进去，然后再后续时候该对象时，不需要再定义匹配规则
print(new_re.findall(‘this is old,so old‘))
print(new_re.search(‘this is old ,so old‘))

a=re.finditer(‘new‘,‘this is new,so new‘) #生成一个迭代器
print(next(a).group())    #返回一个对象，使用group查看内容

import re
#-------------------1--------------------------------------------- 
ret=re.findall(‘www.(baidu|oldboy).com‘,‘www.oldboy.com‘)
print(ret)#[‘oldboy‘]     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
 
ret=re.findall(‘www.(?:baidu|oldboy).com‘,‘www.oldboy.com‘)
print(ret)#[‘www.oldboy.com‘]

#-----------------------2----------------------------------------------
可以 使用 (?P<name>)来定义组的名称。例如 
print(re.search(r‘(?P<dig>\d+)‘,‘aa234bb345cc‘).groupdict())

import logging

logger = logging.getLogger()    #logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger.
print(logger.name)   #查看logger的name.在这边，返回root
logger.setLevel(logging.INFO)   #设置该用户的输出级别

# 创建一个handler，用于写入日志文件
fh = logging.FileHandler(‘test.log‘)

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()

formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
logger.addHandler(ch)

logger.debug(‘logger debug message‘)
logger.info(‘logger info message‘)
logger.warning(‘logger warning message‘)
logger.error(‘logger error message‘)
logger.critical(‘logger critical message‘)
‘‘‘
    logging库提供了多个组件：Logger、Handler、Filter、Formatter。
    Logger对象提供应用程序可直接使用的接口，
    Handler发送日志到适当的目的地，
    Filter提供了过滤日志信息的方法，
    Formatter指定日志显示格式。
‘‘‘

import logging
logger = logging.getLogger()            #设置root
logger1 = logging.getLogger(‘mysql‘)   #设置用于mysql为logger1
logger1.setLevel(logging.INFO)   #logger的输出级别为 INFO

logger2=logging.getLogger(‘mysql‘)  #设置用于mysql为logger2
logger2.setLevel(logging.WARNING)   #logger的输出级别为 WARNING

fh = logging.FileHandler(‘test.log‘)
ch = logging.StreamHandler()

formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)

fh.setFormatter(formatter)
ch.setFormatter(formatter)


logger.addHandler(ch)  #由于父层有设置流显示，所以当父层传递日志给子层，会打印一次
logger1.addHandler(fh)
logger1.addHandler(ch)  #子层打印一次
logger2.addHandler(fh)
logger2.addHandler(ch)

logger1.debug(‘logger debug message‘)
logger1.info(‘logger info message‘)
logger1.warning(‘logger warning message‘)
logger1.error(‘logger error message‘)
logger1.critical(‘logger critical message‘)

logger2.debug(‘logger debug message‘)
logger2.info(‘logger info message‘)
logger2.warning(‘logger warning message‘)
logger2.error(‘logger error message‘)
logger2.critical(‘logger critical message‘)
‘‘‘
1.
    logger1级别为info,应该输出内容为info及以上的共四个级别的日志 
    logger2级别为warning,应该输出内容为warning及以上的共三个级别的日志 
    但实际输出为六行内容，且都是warning 及以上级别日志
2.由于logger是 树形层级结构，既会将消息分发给他的handler进行处理也会传递给所有的祖先Logger处理。  
    
‘‘‘

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler(‘test.log‘)

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()

formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)

fh.setFormatter(formatter)
ch.setFormatter(formatter)

# 定义一个filter
filter = logging.Filter(‘mylogger‘)
fh.addFilter(filter)
ch.addFilter(filter)  # 这两行的作用 等于logger.addFilter(filter)

#logger.addFilter(filter)
logger.addHandler(fh)
logger.addHandler(ch)


logger.setLevel(logging.DEBUG)

logger.debug(‘logger debug message‘)
logger.info(‘logger info message‘)
logger.warning(‘logger warning message‘)
logger.error(‘logger error message‘)
logger.critical(‘logger critical message‘)

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
  
[bitbucket.org]
User = hg
  
[topsecret.server.com]
Port = 50022
ForwardX11 = no

import configparser
  
config = configparser.ConfigParser()
config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
                      ‘Compression‘: ‘yes‘,
                     ‘CompressionLevel‘: ‘9‘}
  
config[‘bitbucket.org‘] = {}
config[‘bitbucket.org‘][‘User‘] = ‘hg‘
config[‘topsecret.server.com‘] = {}
topsecret = config[‘topsecret.server.com‘]
topsecret[‘Host Port‘] = ‘50022‘     # mutates the parser
topsecret[‘ForwardX11‘] = ‘no‘  # same here
config[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘
with open(‘example.ini‘, ‘w‘) as configfile:  #写入文件时调用config 的方法
   config.write(configfile)　　

import hashlib,re
obj=hashlib.md5(‘admin‘.encode(‘utf8‘))  #加盐
obj.update(‘hello‘.encode(‘utf8‘))
print(obj.hexdigest())


import hmac
h = hmac.new(‘alvin‘.encode(‘utf8‘))
h.update(‘hello‘.encode(‘utf8‘))
print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940