time.time()     # 时间戳:1487130156.419527

time.strftime("%Y-%m-%d %X")     #格式化的时间字符串:'2017-02-15 11:40:53'

time.localtime()    #本地时区的struct_time

time.gmtime()     #UTC时区的struct_time

time.localtime(1473525444.037215) #时间戳到struct_time对象

time.mktime(time.localtime()）    #struct_time对象到时间戳

time.strptime('2007-12-1 2-3-4','%Y-%m-%d %H-%M-%S')   #字符串到struct_time对象

time.strftime("%Y-%m-%d %X", time.localtime())    #struct_time 到字符串

datetime.date 代表年月日，datetime.time代表时分秒，datetime.datetime代表年月日时分秒
时间加减
a = datetime.datetime.now()

datetime.datetime.now()-a > datetime.timedelta(days=30)

datetime.datetime.fromtimestamp(time.time()) #1)时间戳到datetime.datetime对象

datetime.timedelta：datetime.datetime.now() + datetime.timedelta(hours=3) #2)时间加减对象,当前时间+3小时

datetime.datetime.now().replace(minute=3,hour=2). #3)时间替换

sys.path.append

sys.stdout sys.stderr sys.stdin 三流

sys.modules[__name__] 获得本模块

random.random() #(0,1)----float 大于0且小于1之间的小数

random.randint(1,3) #[1,3] 大于等于1且小于等于3之间的整数

random.randrange(1,3) #[1,3) 大于等于1且小于3之间的整数

random.choice([1,'',[4,5]])#1或者23或者[4,5]

random.sample([1,'',[4,5]],2)#列表元素任意2个组合

random.uniform(1,3) #大于1小于3的小数，如1.927109612082716

item=[1,3,5,7,9]

random.shuffle(item) #打乱item的顺序,相当于"洗牌"

os模块是与操作系统交互的一个接口

os.urandom(32) 　　#获得32字节的随机数，字节类型

os.getcwd()  　　#获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname") 　　# 改变当前脚本工作目录；相当于shell下cd

os.makedirs('dirname1/dirname2')  　　#可生成多层递归目录

os.removedirs('dirname1') 　　# 若目录为空，则删除，并递归到下一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname') 　　# 生成单级目录；相当于shell中mkdir dirname

os.rmdir('dirname') 　　# 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

os.listdir('dirname') 　　# 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.remove(‘filepath’) 　　　　# 删除一个文件

os.rename("oldname","newname") 　　# 重命名文件/目录

os.stat('path/filename')　　# 获取文件/目录信息

os.name     #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.system("bash command") 　　# 运行shell命令，直接显示

os.path.abspath(path) 　　# 返回path规范化的绝对路径

os.path.split(path) 　　# 将path分割成目录和文件名二元组返回

os.path.dirname(path) 　　# 返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path) 　　# 返回path最后的文件名。若path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

os.path.exists(path) 　　# 如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path) 　　# 如果path是绝对路径，返回True

os.path.isfile(path) 　　# 如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path) 　　# 如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]]) 　　# 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path) 　　# 返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)　　# 返回path所指向的文件或者目录的最后修改时间

os.path.getsize(path) 　　#返回path的大小

注意：os.path.getsize() 和 f.seek(0,2) f.tell() 和os.stat(path).st_size 的结果相同

import os

path = r'C:\Users\Administrator\Desktop\file'

for dirpath,dirnames,filenames in os.walk(path):

    for filename in filenames:

    print(os.path.join(dirpath,filename))

op = optparse.OptionParser()

op.add_option('-s','--server',dest='server')

op.add_option('-p','--port',dest='port')

options, args = op.parse_args() #传入完成，做解析

shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w')) #将文件内容拷贝到另一个文件中：

shutil.copyfile('f1.log', 'f2.log') #拷贝文件,目标文件无需存在

shutil.copymode('f1.log', 'f2.log') #拷贝权限。内容、组、用户均,不变目标文件必须存在

shutil.copystat('f1.log', 'f2.log') #拷贝状态的信息，包括：mode bits, atime, mtime, flag,s目标文件必须存在

shutil.copy('f1.log', 'f2.log')    #拷贝文件和权限

shutil.copy2('f1.log', 'f2.log')    #拷贝文件和状态信息

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) #递归的去拷贝文件夹：目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除

shutil.rmtree('folder1')，#删除非空文件夹

shutil.move('folder1', 'folder3')   # 递归的去移动文件，它类似mv命令，其实就是重命名

ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')     #创建压缩包并返回文件路径，例如：zip、tar：

    #将 /data下的文件打包放置 /tmp/目录

#pyhton中含有对解压操作的两个模块：zipfile,tarfile#

json.dumps(xx) #转化为json字符串、参数可以是字典、列表、元组、基本数据类型

json.loads(xx) #传入json字符串，还原为原来的数据，和eval不同的是，eval侧重于语句，eval('1+1')可以执行，json则可以跨语言，

-----------------------------------------------------------------------------------------
 json.dumps(books, default=lambda o: o.__dict__) . # 将对象转化为对象内部的字典，有递归效果

--------------------------------------------------------------------------------------------

#扩展json序列化引擎类，序列化datetime对象
class CJsonEncoder(json.JSONEncoder):

    def default(self, obj):

        #if isinstance(obj, datetime):

            #return obj.strftime('%Y-%m-%d %H:%M:%S')

        if isinstance(obj, datetime.date):

            return obj.strftime('%Y-%m-%d %H:%M:%S')

        else:

            return json.JSONEncoder.default(self, obj)

import json

import datetime

a = datetime.datetime.now()

print(a)

b = json.dumps(a,cls=CJsonEncoder)

print(b)

from django.core import serializers

ret = models.BookType.objects.all()

data = serializers.serialize("json", ret)    

import shelve

f=shelve.open(r'sheve.txt')

f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}

f['stu2_info']={'name':'gangdan','age':53}

f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])

f.close()

m=hashlib.md5()

m.update('helloalvin'.encode('utf8')) #只能传入字节

m.hexdigest() #92a7e713c30abbb0319fa07da2a5c4af

hash = hashlib.sha256('898oaFs09f'.encode('utf8')) #添加自己的key，然后初始化

hash.update('alvin'.encode('utf8'))

hash.hexdigest()#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

base64.b64encode(''.encode('utf8'))

#'MTIzNDU2'

 base64.b64decode('MTIzNDU2'.encode('utf8'))

#'123456'

secret_key = b'qazwsx123'

msg = os.urandom(32)

h=hmac.new(secret_key,msg) #使用随机生成的msg对secret_key加密

digest=h.digest() #产生加密结果

hmac.compare_digest(digest,respone) #比较字节是否相等

config = configparser.ConfigParser()　　#1.必须操作，创建对象

config.read('a.cfg')    #像文件一样首先打开

res=config.sections() #查看所有的标题：['section1', 'section2']

options=config.options('section1')    #查看标题section1下所key=value的key组成的列表：

val=config.get('section1','user')     #取出指定section的指定键的值

#注意，get还有其他‘子类’函数，适用于取出特定类型，就是简化取出之后的类型转换步骤

config.remove_section('section2')     #删除整个节section2

config.remove_option('section1','k1')    #删除节下面的指定键值对

config.add_section('egon')    #添加一个标题：

config.set('egon','name','egon')   #在标题egon下添加name=egon,age=18

config.write(open('a.cfg','a+'))   #写入文件

 config.has_section('section1')   #判断有指定节

config.has_option('section1','')    #判断节下面是否有

默认级别为warning，默认打印到终端,低于级别的日志不输出

CRITICAL = 50 #FATAL = CRITICAL

ERROR = 40

WARNING = 30 #WARN = WARNING

INFO = 20

DEBUG = 10

NOTSET = 0 #不设置

logging.basicConfig()函数中通过具体参数来更改logging模块默认行为。

#这是全局配置，针对所有logger有效

#并且这个配置比较低级，

#常用两者之一，有stream参数就不能设置filename，反过来也是

logging.basicConfig(level=logging.DEBUG,stream=std.__stdout__)

logging.basicConfig(level=10,filename='log.log')

logger：产生日志的对象

Filter：过滤日志的对象，一般不用

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

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

#1.logger对象：负责产生日志，然后交给Filter过滤，然后交给不同的Handler输出

logger=logging.getLogger(__file__)

#2、Filter对象：不常用，略

#3、Handler对象：接收logger传来的日志，然后控制输出

h1=logging.FileHandler('t1.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',)

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

h1.setFormatter(formmater1)

h3.setFormatter(formmater3)

logger.addHandler(h1)

logger.addHandler(h3)

logger.setLevel(10)

logger.debug('debug')

logger.info('info')

logger.warning('warning')

logger.error('error')

logger.critical('critical')

import logging
import os
from conf import setting

class Log(object):
    __instance = None

    def __init__(self):
        self.error_log_path = setting.ERROR_LOG_PATH
        self.run_log_path = setting.RUN_LOG_PATH
        self.error_log = None
        self.run_log = None
        self.__init_error_log()
        self.__init_error_log()

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls, *args, **kwargs)
        return cls.__instance

    def __check_path_exists(self, file_path):
        if not os.path.exists(file_path):
            raise Exception('%s not exists' % file_path)

    def __init_error_log(self):
        self.__check_path_exists(self.error_log_path)
        logger = logging.Logger('error_log', logging.ERROR)
        h = logging.FileHandler(self.error_log_path, 'a', encoding='utf8')
        fmt = logging.Formatter(fmt="%(asctime)s - %(levelname)s :  %(message)s")
        h.setFormatter(fmt)
        logger.addHandler(h)
        self.error_log = logger

    def __init_run_log(self):
        self.__check_path_exists(self.run_log_path)
        logger = logging.Logger('run_log', logging.INFO)
        h = logging.FileHandler(self.run_log_path, 'a', encoding='utf8')
        fmt = logging.Formatter(fmt="%(asctime)s - %(levelname)s :  %(message)s")
        h.setFormatter(fmt)
        logger.addHandler(h)
        self.run_log = logger

    def log(self, msg, status=True):
        if status:
            self.run_log.info(msg)
        else:
            self.error_log.error(msg)

logger = Log()

logger1=logging.getLogger('abc')

logger2=logging.getLogger('abc.freedom')

logger3=logging.getLogger('abc.freedom.child2')

'file': {

'level': 'INFO',

'class': 'logging.handlers.TimedRotatingFileHandler', # 用时间切割

'when': "D", #D 表示天

'interval': 1, #1 表示每1天，每天切割一次日志文件

"backupCount": 3,

'formatter': 'default',

'filename': os.path.join(BASE_DIR, 'logs', 'dbops.log')

},

re.sub(r'(a)',lambda x:x.group(0).upper(),'caca')

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

re.split('[ab]','abcd') #['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割

re.split('[ab]','acaccccbzzzafreedom')

['', 'c', 'cccc', 'zzz', 'freedom']

re.sub('a','A','alex make love',1) Alex make love

obj=re.compile('\d{2}')

obj.search('abc123eeee').group()) #

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

print(re.search('(\d)+','').group()) #group的作用是将所有组拼接到一起显示出来

print(re.findall('(\d)+','')) #findall结果是组内的结果,且是最后一个组的结果

re.match(r'ddd','ddd32')

 <_sre.SRE_Match object; span=(0, 3), match='ddd'>

注意：这个是javascript

var m = "abcabc".match(/(?:a)(b)(c)/)

结果 ["abc", "b", "c"]

var m = "abcabc".match(/(a)(b)(c)/)

结果 ["abc", "a", "b", "c"]

In [30]: re.match(r'www\.','www.')

Out[30]: <_sre.SRE_Match object; span=(0, 4), match='www.'>

#预扫描就是先走一遍，找到?=中的正则，然后返回匹配的结果。剩下的正则，还是从‘预扫描’正则的前一个正则处理完的位置开始。

re.match(r'(?=123|456)(?=123abc)(?=123abcfree)123abcfree','123abcfree')

Out[]: <_sre.SRE_Match object; span=(, ), match='123abcfree'>  

#预匹配经常用于这样的场景，例如：密码需要包含大小写字母，数字和下划线

re.match(r'(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*_).*','fdfds2121_FSD')
Out[111]: <_sre.SRE_Match object; span=(0, 13), match='fdfds2121_FSD'>

from functools import wraps

def hello(fn):

    @wraps(fn)

    def wrapper():

        print "hello, %s" % fn.__name__

        fn()

        print "goodby, %s" % fn.__name__

    return wrapper

res=subprocess.Popen('dir',shell=True,stdout=subprocess.PIPE)  #shell=True意味着用shell命令形式执行第一参数'dir',stdout参数指定将结果放到管道里面。

res.stdout.read() #从管道中读出数据，数据为二进制

res=subprocess.getoutput('ver') #直接获取cmd命令的返回值

res=subprocess.Popen('ls',shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE) # 注意，虽说是这么写，但是其实是不同的管道。

a=struct.pack('b',-1)

struct.unpack('b',a) #返回的是元祖

data = xlrd.open_workbook('demo.xls') #打开excel

data.sheet_names() #查看文件中包含sheet的名称

#得到第一个工作表，或者通过索引顺序 或 工作表名称

table = data.sheets()[0]

table = data.sheet_by_index(0)

table = data.sheet_by_name(u'Sheet1')

#获取行数和列数

nrows = table.nrows

ncols = table.ncols

#获取整行和整列的值（数组）

table.row_values(i)

table.col_values(i)

#循环行,得到索引的列表

for rownum in range(table.nrows):

print table.row_values(rownum)

#单元格

cell_A1 = table.cell(0,0).value

cell_C4 = table.cell(2,3).value

#分别使用行列索引

cell_A1 = table.row(0)[0].value

cell_A2 = table.col(1)[0].value

服务端套接字函数

s.bind()    绑定(主机,端口号)到套接字

s.listen()  开始TCP监听

s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数

s.connect()     主动初始化TCP服务器连接

s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数

s.recv()            接收TCP数据

s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)

s.sendall()         发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)

s.recvfrom()        接收UDP数据

s.sendto()          发送UDP数据

s.getpeername()     连接到当前套接字的远端的地址

s.getsockname()     当前套接字的地址

s.getsockopt()      返回指定套接字的参数

s.setsockopt()      设置指定套接字的参数

s.close()           关闭套接字

面向锁的套接字方法

s.setblocking()     设置套接字的阻塞与非阻塞模式

s.settimeout()      设置阻塞套接字操作的超时时间

s.gettimeout()      得到阻塞套接字操作的超时时间

class Myserver(socketserver.BaseRequestHandler):

    def handle(self):

        print(self.request) #conn

        print(self.client_address)#addr

while True:

    data = self.request.recv(1024)

    self.request.sendall(data.upper())

s = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer) #注意这里第二参数为自定义子类

s.serve_forever() #链接循环    

from urllib.request import urlopen

    return urlopen(url).readlines() 

functools.partial(iter,li)　　#偏函数，即绑定参数，第一个参数为要操作的函数，第二参数为操作函数的第一个参数。

# select 模拟一个socket server，注意socket必须在非阻塞情况下才能实现IO多路复用。

# 接下来通过例子了解select 是如何通过单进程实现同时处理多个非阻塞的socket连接的。

#server端

import select

import socket

import queue

server = socket.socket()

server.bind(('localhost',9000))

server.listen(1000)

server.setblocking(False)  # 设置成非阻塞模式，accept和recv都非阻塞

# 这里如果直接 server.accept() ，如果没有连接会报错，所以有数据才调他们

# BlockIOError：[WinError 10035] 无法立即完成一个非阻塞性套接字操作。

msg_dic = {}

inputs = [server,]  # 交给内核、select检测的列表。

# 必须有一个值，让select检测，否则报错提供无效参数。

# 没有其他连接之前，自己就是个socket，自己就是个连接，检测自己。活动了说明有链接

outputs = []  # 你往里面放什么，下一次就出来了

while True:

    readable, writeable, exceptional = select.select(inputs, outputs, inputs)  # 定义检测

    #新来连接                                        检测列表         异常（断开）

    # 异常的也是inputs是： 检测那些连接的存在异常

    print(readable,writeable,exceptional)

    for r in readable:

        if r is server:  # 有数据，代表来了一个新连接

            conn, addr = server.accept()

            print("来了个新连接",addr)

            inputs.append(conn)  # 把连接加到检测列表里，如果这个连接活动了，就说明数据来了

            # inputs = [server.conn] # 【conn】只返回活动的连接，但怎么确定是谁活动了

            # 如果server活动，则来了新连接，conn活动则来数据

            msg_dic[conn] = queue.Queue()  # 初始化一个队列，后面存要返回给这个客户端的数据

        else:

            try :

                data = r.recv(1024)  # 注意这里是r，而不是conn，多个连接的情况

                print("收到数据",data)

                # r.send(data) # 不能直接发，如果客户端不收，数据就没了

                msg_dic[r].put(data)  # 往里面放数据

                outputs.append(r)  # 放入返回的连接队列里

            except ConnectionResetError as e:

                print("客户端断开了",r)

                if r in outputs:

                    outputs.remove(r) #清理已断开的连接

                inputs.remove(r) #清理已断开的连接

                del msg_dic[r] ##清理已断开的连接

    for w in writeable:  # 要返回给客户端的连接列表

        data_to_client = msg_dic[w].get()  # 在字典里取数据

        w.send(data_to_client)  # 返回给客户端

        outputs.remove(w)  # 删除这个数据，确保下次循环的时候不返回这个已经处理完的连接了。

    for e in exceptional:  # 如果连接断开，删除连接相关数据

        if e in outputs:

            outputs.remove(e)

        inputs.remove(e)

        del msg_dic[e]

#*************************client

import socket

client = socket.socket()

client.connect(('localhost', 9000))

while True:

    cmd = input('>>> ').strip()

    if len(cmd) == 0 : continue

    client.send(cmd.encode('utf-8'))

    data = client.recv(1024)

    print(data.decode())

client.close()

sel = selectors.DefaultSeletors() # 首先创建根据操作系统取一个最好的IO复用方式（前提是存在）

sel.reister(sock,selectors.EVENT_READ,myaccept) #也就要对sock和myaccept函数做一个绑定，只要sock有活动，直接调用myaccpet方法

sel.unregister(conn）解除conn绑定的函数

events = sel.select() # 获得激活状态的事件

from socket import *

import selectors

sel=selectors.DefaultSelector()

def accept(server_fileobj,mask):

    conn,addr=server_fileobj.accept()

    sel.register(conn,selectors.EVENT_READ,read)

def read(conn,mask):

    try:

        data=conn.recv(1024)

        if not data:

            print('closing',conn)

            sel.unregister(conn)

            conn.close()

            return

        conn.send(data.upper()+b'_SB')

    except Exception:

        print('closing', conn)

        sel.unregister(conn)

        conn.close()

server_fileobj=socket(AF_INET,SOCK_STREAM)

server_fileobj.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

server_fileobj.bind(('127.0.0.1',8088))

server_fileobj.listen(5)

server_fileobj.setblocking(False) #设置socket的接口为非阻塞

sel.register(server_fileobj,selectors.EVENT_READ,accept) #相当于网select的读列表里append了一个文件句柄server_fileobj,并且绑定了一个回调函数accept

while True:

    events = sel.select() # 获得激活状态的事件

for key, mask in events:

    callback = key.data # 传入函数

    callback(key.fileobj, mask) #mask暂时没有意义

>>> platform.system() #返回系统名称

'Windows'

#linux

>>> platform.system()

'Linux'

# 第三方模块，pip install requests

# 可以模仿浏览器请求web服务器

# get方式请求

requests.get(url='https://www.bilibili.com/video/av21534444/')

# 1.1 get方式带参数

requset.get(url='https://www.bilibili.com/video/av21534444/?p=4&a=1')

# 1.2 get方式带参数（借由params参数，）

#注意的是params参数无论是get请求，还是post请求，都是放在url的‘？’后面

requset.get(url='https://www.bilibili.com/video/av21534444/'，params={'p':4,'a':1})

#获得数据
data =requset.get(url='https://www.bilibili.com/video/av21534444/'，params={'p':4,'a':1})
data.text # 整个html文本
data.json() # 将获得的数据进行json.load()后返回

# post方式 # 注意的是，会有csrf验证阻止，需要使用以下装饰器装饰指定视图 from django.views.decorators.csrf import csrf_exempt # 还有使用data参数是存放post数据，params是get数据 requset.post(url='https://www.bilibili.com/video/av21534444/'，data={'p':4,'a':1})

# 还要注意的是data参数是一个字典，但是该字典的value值不能也是个字典（ajax请求也一样），如果是，则会被转化为列表（只剩下键）。
# 要通过序列化的参数json，并且django的视图，要从request.body中取。（额外知识：request.body只能用于post请求，因为get请求requset.body会没有值而报错）
requset.post(url='https://www.bilibili.com/video/av21534444/'，json={'p':4,'a':{1:1,2:2}})

# 返回值

response = request.get(url='xxx')
response.content #字节
response.text #字符串

response.encoding = response.apparent_encoding #指定编码为其网页指定的

# cookies
response.cookies.get_dict()
requset.get(url='xx',cookie={'xx':'xx'})

重要参数说明

# 帮助html，结构化为对象

pip3 install beautifulsoup4

 from bs4 import BeautifulSoup

html_doc = """

<html><head><title>The Dormouse's story</title></head>

<body>

asdf

    <div class="title">

        <b>The Dormouse's story总共</b>

        <h1>f</h1>

    </div>

<div class="story">Once upon a time there were three little sisters; and their names were

    <a  class="sister0" id="link1">Els<span>f</span>ie</a>,

    <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and

    <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;

and they lived at the bottom of a well.</div>

ad<br/>sf

<p class="story">...</p>

</body>

</html>

"""

soup = BeautifulSoup(html_doc, features="lxml")

# 找到第一个a标签

tag1 = soup.find(name='a')

# 找到所有的a标签

tag2 = soup.find_all(name='a')

# 找到id＝link2的标签

tag3 = soup.select('#link2')

常用方法属性整理

from bs4 import BeautifulSoup

bs = BeautifulSoup(s,'html.parser')

bs.text

# XSS的危害：相当于让浏览器执行一堆可执行的脚本

from bs4 import BeautifulSoup

bs = BeautifulSoup(s,'html.parser')

for tag in bs.find_all(): #内部递归遍历文档树

    if tag.name in ['script','link']:

        tag.decompose() #从文档树中删除

article_detail=str(bs) #获得过滤后的html字符串

from concurrent.futures import ThreadPoolExecutor

pool = ThreadPoolExecutor(10)
for item in task['data']:
    hostname = item['hostname']
    pool.submit(self.run, hostname)
pool.shutdown(wait=True)

def run(self, hostname):
server_info = plugins.get_server_info(hostname)
server_json = Json.dumps(server_info.data)
self.post_asset(server_json, self.callback)

import redis

#事务+一次发送多个命令：

conn = redis.Redis(host='47.94.172.250',port=6379,password='Luffy!4321')

pipe = conn.pipeline(transaction=True)

pipe.multi()

pipe.set('k2','')

pipe.hset('k3','n1',666)

pipe.lpush('k4','laonanhai')

pipe.execute()

#通过yield创建一个生成器完成一点一点获取（通过字典操作的源码来的灵感）
# hscan_iter（切记：一般到公司以后，如果不知道数据到底有多少条，千万不要用hgetall，而用这个）
　　例如,取出一个key的所有val进行打印（1000w条，hash类型）
　　 方案一：一次取完（不可行）
　　如果1000w条一次取完，内存爆炸
　　方案二：一次取一个val(可行，浪费）
　　每次取1个值都要来回收发，非常低效
　　方案三：折中做法（迭代器做法，就是这个）
　　一次发个100条，读完再发

def list_iter(key, count=100):

    index = 0

    while True:

        data_list = conn.lrange('k1', index, index + count - 1)

        if not data_list:

            return

        index += count

        for item in data_list:

            yield item

     

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import redis

pool = redis.ConnectionPool(host='10.211.55.4', port=6379)

r = redis.Redis(connection_pool=pool)

r.set('foo', 'Bar')

print r.get('foo')