新普金娱乐网址


出品番茄工作法

前者工程师的学识系统

python之路:始解

  • 三月 09, 2019
  • 天文
  • 没有评论

模块导入的主意:

JSON AND PICKEL

JSON(JavaScript Object
Notation)是一种轻量级的数据沟通格式。json全数语言都通用,能够与区别语言进行数据交互,json暗中同意只是支持最不难易行的转移类型。与XML相同,但比XML更为不难方便。

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


import json
a={
    1:"2",
    2:"3",
    4:"5"
}



with open("json.txt","w") as f:
    f.write(json.dumps(a))       #########序列化


with open("json.txt","r") as f:
    data=json.loads(f.read())##########反序列化

print(data["1"])

res: 2

 

pickel

用法跟json类似,可是足以用于python特有的类型 和
python的数据类型间进行更换。

# -*- coding:utf-8 -*-
import pickle
a={
1:"2",
2:"3",
4:"5"
}



with open("pickle.txt","wb") as f:
f.write(pickle.dumps(a))


with open("pickle.txt","rb") as f:
data=pickle.loads(f.read())

print(data[1])

包的导入方法:

迭代器

可以直接功能于for循环的数据类型:

壹 、集合数据类型: 如 列表list、元组tuple 、 字典dict、 集合set、
字符串str、 字节类型byte等

二 、generator 包罗生成器和带yield的generator function

可迭代 即为可轮回

可以行使isinstance()判断是或不是为迭代器对象

 

能够被for循环的对象叫做可迭代对象 iterable可迭代

能够被netxt()函数调用并持续重返下二个值的靶子变成可迭代器:iterator。

 

大凡可职能于for循环的靶子都以iterable类型

举凡可效果于next()函数的对象都以iterator类型,他们代表一个惰性总括的队列

集合数据类型如list dict str 等是iterable
但不是iterator,但是能够透过iter()函数获得二个iterator对象

Python中的for循环本质上正是通过不停调用next()函数实现的

 

5、json和pickle模块

置于模块

1、定义:

模块:用来从逻辑上组织python代码(变量、函数、类、逻辑,从而实现八个效应),本质上便是一个.py结尾的python文件(如文件名为test.py,
则对应的模块名为:test)

python包:本质正是3个文件夹(必须包括五个_init_.py的文件)

 

2.导入方法:

  1、 import module_name

  2、import module_name,module2_name

  3、from module_alex import * 从module_alex
中引用全部的始末,即一对一于将module_alex中的内容复制出来了一份

  4、frommodule_alex import 相关函数
能够运用此方法引入想用的函数或许是法力,那样引入的法力平素调用就足以,无需使用最初的作品件名点出来

  5、from module_alex import logger as logger_alex
将logger从module_alex中引入,并将其别的命名为logger_alex

 

 

③ 、导入模块的本来面目(路径搜索和查找路径)

  导入模块的精神就是把python文件说Bellamy遍

  导入包的面目便是实行李包裹下边包车型客车_init_.py的文件

  因而能够利用from .import test来进展函数的引用

 

假如要给一个py文件导入模块,那么肯定要在sys.path中显示出来,即供给在系统暗中同意的os.path中添加上

os.append()将当前目录追加进来

若想要提升此文件的优先级,可以应用os.insert()来将急需添加的嵌入后边。

 

④ 、导入模块的优化,假设1个模块日常性的使用,则足以应用from module
import test 将其一向引入,那样可防止止每一回都开始展览检索。

 

 

⑤ 、 模块的分类:

  a.标准库

    时间模块:time 和 datetime

        获取时间戳 time.time()

        用来表示时间的艺术:1时间戳

                  2格式化的时间字符串

                  3元组(struct_time)

        时间的归类:UTC
Green尼治天文时间,世界标准时间,中中原人民共和国选拔的是UTC+8

        DST 夏令时

        time.timezone()呈现当前所在时区

        time.altzone()展现夏令时与当前时区的差值

        time.daylight()是还是不是利用了夏令时

        time.sleep()时间结束多长期,暗中认可时间单位为秒

        time.gmtime()当前时间的格林尼治时间 为UTC时区时间

        time.localtime()当前时光

        以上二种是把时间戳转换为元组的措施

 

        由元组传转换为时间戳:mktime()

 

        由元组转换为字符串:strtime(”格式“,元组的日子)

 

        由字符串转化为元组:striptime(”格式化的字符串“,格式)

 

        time.ctime()由时间戳转换为字符串格式 时间戳

 

        time.asctime()由元组转化为字符串格式 参数是元组 tuple

 

        datetime.datetime.now()+datetime..timedelta(3)
当前岁月的后四天

 

        datetime.datetime.now()+datetime..timedelta(-3)
当前时光的前二十八日

  random模块

      random.random()私下认可随机0到1里面包车型客车数值,值类型为浮点数

      random.uniform(1,10) 从一个范围内取值,值类型为浮点数

      random.randint(1,3)随机1-3里面包车型大巴整数,可以取到3的值

      random.randrange(0,3) 随机1-3之间的整数,不能取到3的值

      random.choice(“”)能够流传字符串、列表、元组等,从中取3个值;随机字符成效

      random.sample(“
hello”,2)以前面的hello中取多个值;随机字符功效,钦点取值几

 

  OS模块

      os.getcwd()获取当前的干活目录

      os.chdir(r“c:\”)切换目录

      os.curdir()重临当前目录 类似 Linux下的cd .

      os.pardir()获取当前目录的父目录字符串 类似Linux下的cd ..

      os.makedirs()递归创立目录

      os.removedirs()若目录为空,则删除并递归到上一层,假若也为空,则删除,以此类推

      os.mkdir(“dirname”) 创造目录 类似Linux下的mkdir test

      os.rmdir() 删除目录,类似linux下的rm -rf

      os.listdir()列出当前目录的文件列表

      os.stat(“test”)获取test的文件音信

      os.sep输出当前平台运用的门路分隔符

      os.linesep输出当前平台选取的行终止符 windows下为“\r\n”
Linux下为”\n”

      os.environ列出当前系统的环境变量

      os.pathsep输出用于私分文件路径的字符串

      os.name 获取当前选用平台

      os.system(“dir”)运行shell命令

      os.path.abspath()获取某一文书的相对路径

      os.path.split(r”c:\d\e\f”)将路径分割成目录和文件名二元组并赶回

      os.path.dirname(路径)取此path的门径的值

      os.path.basename(路径) 取此path的文书名的值

      (split、dirname、basename都能够不考虑背后的门径是不是存在,其一味是处理字符串)

      os.path.exists(r“c:\a”)重临此路径是还是不是留存,存在为True,不存在为False

      os.path.isabbs(路径)判断此路径是还是不是为相对路径 是为真 否为假

      os.path.join()组合多少个途径并重返值,第③个相对路径此前的参数将被忽略

      os.path.getatime()
重回路径所指向的文书或目录最终的存取时间

      os.path.getmtime()重回路径所指向的文书或目录最终的修改时间

 

  sys模块

      sys.argv()命令行参数list,第二个成分是程序本人路径

      sys.exit()退出程序,平时退出时exit(0)

      sys.version()获取python解释程序的版本音信

      sys.maxint()最大的int值

      sys.path()再次回到模块的搜寻路径,开首化时利用Pythonpath环境变量的值

      sys.platform()再次来到操作系统平台名称

  shutil模块(copy文件)

      shutil.copyfile(sourceFile,destFile)从源文件拷贝到指标文件

      shutil.copymode(sourceFile,destFile)仅拷贝权限,内容、组、用户均不变

      shutil.copystat(sourceFile,destFile)拷贝状态的音信,不涉及文件内容

      shutil.copy(sourceFile,destFile)拷贝文件和权杖

      shutil.cpoy2(sourceFile,destFile)拷贝文件和景象新闻

      shutil.copytree(sourceFile,destFile)递归的正片文件,即为拷贝文件夹

      shutil.rmtree(sourceFile,destFile)递归的去删除文件,即为删除文件夹

      shutil.make_archive(压缩包的称谓,压缩类型,要缩减的门道,用户(默许当前用户),组(私下认可当前组),记录日志)

      如shutil.make_archive(“test”,”zip”,root_dir=”c:\test\”

 

  zipfile模块

    #压缩

      z=zipfile.ZipFile(“test.zip”,”w”)将要压缩的公文物保护留到test.zip中

      z.write()

      z.close()

 

    #解压

      z=zipfile.ZipFile(“test.zip‘,”r“)解压test.zip中的文件

      z.extractall()#可安装解压路径,将精减包内的公文全体解压

      z.close()

  tarfile模块

     #压缩

      tar=tarfile.open(“test.zip”,”w”)

      tar.add()

      tar.close()

 

    #解压

      tar=tarfile.open(“test.zip”,”r”)

      tar.extractall()

      tar.close()

  json模块

      json用于字符串和python数据类型间开始展览置换,可以实现不等语言之间的数码传输

      只补助简单的数据类型

  pickle模块

      用于python特有的品类和Python的数据类型间实行更换

 

  shelve模块

      shelve模块是3个大约的将内部存款和储蓄器数据通过文件持久化的模块,能够持久化任何pickle可支撑的Python数据格式

      例:

      import shelve

      d=shelve.open(“test.txt”)#开辟二个文件

      name=[“rain”,“ass”。“dss”]

      num=[1,2,3,4,5]

      d[“name”]=name

      d[“num”]=num

      d.close()

 

  xml处理模块

#创建xml文件
import xml.etree.cElementTree as et
new_xml=et.Element("namelist")

name=et.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = et.SubElement(name,"age",attrib={"checked":"no"})
sex = et.SubElement(name,"age")
sex.text = '20'
name2 = et.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = et.SubElement(name2,"age")
age.text = '19'

et = et.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True

#修改xml文件
import xml.etree.ElementTree as et

tree = et.parse("xmltest.xml")
root = tree.getroot()

#修改
for node in root.iter('year'):
        new_year = int(node.text) + 1
        node.text = str(new_year)
        node.set("updated","yes")

tree.write("xmltest.xml")

 

 

#删除node
for country in root.findall('country'):
      rank = int(country.find('rank').text)
      if rank > 50:
            root.remove(country)

tree.write('output.xml')

 

  hashlib模块

      用于实践加密的连带操作,3.x中替代了md5模块和sha模块,首假如提供SHA壹 、SHA22肆 、SHA25六 、SHA25陆 、SHA38④ 、SHA5壹 、MD5算法

      用法:

       

import hashlib

s=hashlib.md5()
s.update(b"hello")
print(s.hexdigest())#加密后以十六进制显示
print(s.digest())#加密后以二进制显示

 

 

  hmac模块:能够成立key和内容,处理以往再拓展加密

      hmac
散列新闻鉴定分别码,是一种基于信息鉴定区别码的识别机制,使用HMAC时,音信报纸发表的相互,通过认证音讯中进入的辨认密钥K来识别新闻的真真假假;一般用于互联网通信中国国投息加密,前提是双边都知道K的值

      用法:

      import hmac

      s=hmac.new(b”youloveit”,”你好,我是mir赵”.encode(encoding=”utf-8″))

       print(s.hexdigest())

 

  logging模块

      用于存款和储蓄各种格式的日记,有多少个报告警方级别:debug(),info(),warning(),error(),critical()

 

      显示器输出

       

屏幕输出
import logging

logging.debug("this is a debug")
logging.info("this is a info")
logging.warning("this is a warning")#默认从此处开始在屏幕上显示
logging.error("this is a error")

      写入文件

写入文件:(不会在屏幕输出)
import logging

logging.basicConfig(filename="filename.txt",level=logging.DEBUG)
logging.debug("this is a debug")
logging.info("this is a info")
logging.warning("this is a warning")
logging.error("this is a error")

OR


import logging

logging.basicConfig(filename="filename.txt",level=logging.DEBUG,format=("%(asctime)s %(message)s"),datefmt="%Y-%m-%d %H:%M:%S")
logging.debug("this is a debug")
logging.info("this is a info")
logging.warning("this is a warning")
logging.error("this is a error")
#此处的basicconfig表示的是保存到文件名为filename.txt的文件中,保存等级是从debug开始,格式是“时间 信息” 日期格式为年-月-日 时-分-秒

 

     

    将日志既要荧屏输出还要存入文件:

#logger提供一个能用程序可以直接时候用的接口
#handle将日志记录发送到合适的目的输出(一个handle就是一个输出地)
#filter提供了细度设备来输出哪条日志记录
#formatter决定日志记录的最终输出格式

#每个程序在输出信息之前都要获得一个logger,即需要为其取一个名称:
import logging
#定义一个logger
Log=logging.getLogger("chat.ui")
Log.setLevel(logging.WARNING)#设置默认级别为warning
#设置格式时间-告警logger名称-告警级别-日志信息
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

#设置两个handle 一个指向屏幕,一个指向文件
screen=logging.StreamHandler()
#屏幕默认级别为错误
screen.setLevel(logging.CRITICAL)
screen.setFormatter(formatter)
#文件默认级别为debug
fileimput=logging.FileHandler("fileinput.txt",mode="a",encoding="utf-8")
fileimput.setLevel(logging.DEBUG)
fileimput.setFormatter(formatter)

Log.addHandler(screen)
Log.addHandler(fileimput)

Log.debug('this is a debug message')
Log.info('this is a info message')
Log.warn('this is a warn message')
Log.error('this is a error message')
Log.critical('this is a critical message')

      依据时间自动截断文件备份      

import logging

from logging import handlers
#设置logger,定义告警级别,设置格式
Log=logging.getLogger("chat.core")
Log.setLevel(logging.DEBUG)
formatter =logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
#屏幕输出
screen =logging.StreamHandler()
screen.setLevel(logging.INFO)
screen.setFormatter(formatter)
#文件输出
#文件名为filetime 时间是按照秒计算,备份数量最多两份,编码类型为utf-8
fileinput =handlers.TimedRotatingFileHandler       \                                    
("filetime",when="S",backupCount=2,encoding="utf-8")

fileinput.setLevel(logging.INFO)
fileinput.setFormatter(formatter)
#将文件输出和屏幕输出添加到Log中,完成接口挂靠
Log.addHandler(screen)
Log.addHandler(fileinput)
#内容
Log.debug('this is a debug message')
Log.info('this is a info message')
Log.warn('this is a warn message')
Log.error('this is a error message')
Log.critical('this is a critical message')

 

3、from module_name import *
#其一本质正是先找到module_name模块的门道,然后把module_name中的全体内容解释三回,可以间接调用模块里面包车型大巴内容,比如函数呀,变量等

 

4、sys模块

 

为了可以更好的难忘各类时间之间的额转换,小编去盗个图如下:

生成器

在Python中,一边循环一边盘算的体制,成为生成器 generator

 

① 、唯有在调用时才会转变对应的数量

贰 、只记录当前岗位

③ 、唯有一个_next_()方法 在Python2.7里面为next()

 

能够使用如下代码实行生成器的测试。

import time
a=time.time()
s=[i*2 for i in range(0,10000)]
b=time.time()
print(b-a)
#0.0010023117065429688

import time
a=time.time()
s=(i*2 for i in range(0,100000000))
b=time.time()
print(b-a)
#0.0

后人实际上没有生成真是的多寡,因而进程较快。

 

由生成器可得生成器函数模型:

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


def fib(max):
    n,a,b=0,0,1
    while n<max:
        yield b
        a,b=b,a+b
        n+=1
    return "done"

print(fib(10))

 

yield 能够兑现单线程的气象下并发运算的职能。

yield的功能是保留当前结果并暂停

 

next只是调用yield 不会给yield传值

send是调用yield,同事给yield传值

 

劳动者消费者模型:

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

import  time
def consumer(name):
    print("%s准备开始吃包子啦"%name)
    while True:
        baozi=yield
        print("包子%s来了,被%s吃掉了"%(baozi,name))


def producer(name):
    c1=consumer("gao")
    c2=consumer("yang")
    c1.__next__() #相当于让consumer成为生成器,启用next之后,就让consumer走到了yield这一步,随后停止
    c2.__next__()
    print("%s开始制作包子"%name)
    for i in range(3):
        time.sleep(1)
        print("做一个包子")
        c1.send(i)
        c2.send(i)

producer("li")

 

pickle,用于python特有的类型 和 python的数据类型间展开转移

装饰器

器:表示的是函数 装饰器本质上是函数

装饰器是为着装饰别的函数。正是为任何职能添加附加效能。

装饰器的标准化是:1.不可能修改棉被服装饰的函数的源代码

        2.不能够改改棉被服装饰的函数的调用方式

 

兑现装饰器须要知道:

  壹 、函数即“变量”
:函数与变量一样都以存在内部存款和储蓄器中的,若索引不被剔除,则一向在内部存款和储蓄器中驻留到程序截止。

  ② 、高阶函数

    1)把三个函数名当狠抓参传给别的2个函数,在不修改棉被服装饰函数源代码的境况下为其充裕效果。

    2)再次回到值中涵盖函数名(不改动函数的调用情势)

  ③ 、嵌套函数

 

说到底:高阶函数+嵌套函数=装饰器

 

最简单易行的装饰器如下所示:

一部分网站页面在炮制形成之后,或许供给通过证实才可以开始展览下一步的拜访,具体落到实处:

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

def login(func):
    def user_pass():
        user=input("请输入用户名:")
        password=input("请输入密码:")
        if user=="miss" and password=="miss":
            res=func()
            return res#结束处需要记得返回当前func运行的结果,否则会将存在return的函数的结果丢失
        else:
            print("输入错误,请重试")
    return user_pass

@login#装饰器语法
def index():
    print("welcome to index")
    return"from home"

@login
def bbs():
    print("welcome to bbs")

def email():
    print("welcome to email")


bbs()

平凡的装饰器使用就如出示所示,将login函数冠在要装修的函数之上,即可成功给函数扩张新功能,同时,被点缀函数既倍感不到装饰器的存在,也不会因为被点缀而变更了调用模式。

下面那种是无需往装饰器中传参数的,而除此以外一种则恐怕要求往装饰器中传参,比如完成区别页面不一致认证方法的作用。

那么大家就足以拓展如下所示操作:

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

def login(auth_type):#先行传入认证类型
    def outer_wapper(func):
        def user_pass():
            user=input("请输入用户名:")
            password=input("请输入密码:")
            if auth_type=="local":
                if user=="miss" and password=="miss":
                    res=func()
                    return res#结束处需要记得返回当前func运行的结果,否则会将存在return的函数的结果丢失
                else:
                    print("输入错误,请重试")
            elif auth_type=="ldap":
                print("暂无此种认证")
        return user_pass
    return outer_wapper

@login(auth_type="ldap")#加入auth_type以后,整体的传入参数往下压一级
def index():
    print("welcome to index")
    return"from home"

@login(auth_type="local")
def bbs():
    print("welcome to bbs")

def email():
    print("welcome to email")

index()
bbs()

那种方法接Nabi较普遍。

再有一种办法,是在做作业的时候使用的,就是棉被服装饰函数需求从装饰器中赢得自个儿要求的值,比如照旧登录的意况,要是用户登录成功,
那么继续函数会变动3个以当下用户名为文件名的文件,来记录相关消息。而用户登录是在装饰器中形成的,若装饰器不能回去相关相关数据,后续函数则不能够做到对应的做事,那么就能够动用如下情势展开提取数据:

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


def denglu(func):
    def renzheng(msg):
        user=input("用户名:")
        passwd=input("密码:")
        if user=="admin" and passwd=="123":
            print("认证成功!")
            msg.append(user) #认证成功后,将用户名和密码追加到列表中,通过在return中完成对msg的返回。
            msg.append(passwd)
            return func(msg)
    return renzheng

@denglu
def Main(msg): #函数在收到msg之后,首先对msg进行分离,按照添加的顺序,一一拆分出来。
    user=msg[0]
    passwd=msg[1]
    print("登录成功的用户是%s,密码是%s,创建文件名为%s的文件"%(user,passwd,user))


if __name__ == '__main__':
    msg=[] #此处首先创建一个空列表,方便后续对登录用户名和密码的收集
    Main(msg)

从地点的事例可以见到,大家用了三个列表,根据既定规则追加拆分,即可获取想要获得的数额。此类措施不囿于于接纳列表,也得以利用字典的花样,如:

msg={}
msg.update("user":user)
msg.update("passwd":passwd)

 

5、from module_name improt m1 as name
#以此精神同上,为了幸免与调用本模块的函数争执所以取了分小名。

 

pickle模块提供了八个作用:dumps、dump、loads、load

1、import module_name
#以此真相正是先找到module_name模块的路径,然后把module_name全部解释三次,调用的时候经过module_name.func_name
进行调用

>>> random.random() #产生0-1之间的随机数
0.1089807568787472
>>> random.randint(1,10) #产生1-10之间的随机整数
2
>>> random.randrange(10) #可以先理解为range(10)然后在随机,这样的话还可以加入步长这个参数
6
>>> random.choice([1,2,3,4,5,]) #在已经有的集合中随机产生
2
>>> random.sample([1,2,3,4,5],3) #在已有的集合中随机出k个值
[2, 3, 5]
>>> random.uniform(1,10)#产生1-10之间的随机浮点数
6.588532716071202
>>> s = [1,2,3,4,5]
>>> random.shuffle(s) #对列表数据进行重新洗牌
>>> s
[2, 1, 3, 5, 4]
>>>

再有正是个格式化字符串的格式如下:

>>> sys.version #返回python解释器版本
'3.6.3 |Anaconda, Inc.| (default, Oct 15 2017, 03:27:45) [MSC v.1900 64 bit (AMD64)]'
>>> sys.path #返回模块的搜索路径
['', 'C:\\Anaconda3\\python36.zip', 'C:\\Anaconda3\\DLLs', 'C:\\Anaconda3\\lib', 'C:\\Anaconda3', 'C:\\Anaconda3\\lib\\site-packages', 'C:\\Anaconda3\\lib\\site-packages\\Babel-2.5.0-py3.6.egg', 'C:\\Anaconda3\\lib\\site-packages\\win32', 'C:\\Anaconda3\\lib\\site-packages\\win32\\lib', 'C:\\Anaconda3\\lib\\site-packages\\Pythonwin']
>>> sys.platform #返回操作平台名称
'win32'
>>> sys.stdout.write("please") #标准化输出
please6 
>>>sys.argv #命令行参数是list,第一个元素是程序本身
>>>sys.exit(n) #退出程序,正常退出时exit(0)
>>> sys.stdin.read(1) #标准化输入
ddd
'd'
>>> sys.getsizeof([1,2,3,4]) #返回对象字节长度
96

3、os模块

在聊模块前大家先聊聊怎么采纳模块,也便是模块的导入。

用以连串化的多少个模块

UTC(Coordinated Universal
Time,世界和谐时)亦即格林威治天文时间,世界标准时间。在中NokiaUTC+8。DST(Daylight
Saving 提姆e)即夏令时。

json,用于字符串 和 python数据类型间开始展览转换

我们输入help(time)就能够收获如下的不二法门:

 

壹 、自定义模块

   
不管是模块的导入照旧包的导入,都是在同级目录下展开导入,所以在导入会提到到目录的切换,在常用模块中os模块中会介绍目录的切换。

元组(struct_time)方式:struct_time元组共有8个要素,再次来到struct_time的函数主要有gmtime(),localtime(),strptime()。

光阴戳(timestamp)的方式:经常来说,时间戳表示的是从一九七〇年11月11十六日00:00:00开首按秒计算的偏移量。大家运维“type(time.time())”,重返的是float类型。重返时间戳形式的函数首要有time(),clock()等。

在python中常用来表示时间的有两种情势:① 、时间戳(也正是从一九六九年上马到有个别时间的秒数),贰 、格式化的日子字符串,③ 、元组(总共有八个字段)

图片 1

一、模块

③ 、内置标准模块(又称之为标准库)

4、from module_name import m1,m2,m3
#其一同上,只是解释模块的具体内容,调用方式一样

贰 、常用模块的牵线

1、time&datetime模块

 

接下去聊聊datetime模块,其实datetime无非就是能够日期和岁月分离,那里也就介绍多少个常用的方法,具体别的方法请用help(datetime)、help(datetime.date)、help(datetime.time)去询问具体的用法:

那多少个模块能够参考http://www.cnblogs.com/wupeiqi/articles/4963027.html

2、random模块

模块是一段代码的成团,模块分为三种:

那么些模块首要用来扭转随机数,一般能够选择于验证码选取。常用的点子如下:

② 、开源模块(python强大的由来)

>>> import os
>>> os.getcwd() #获取当前工作目录,即当前python脚本的工作目录路径
'C:\\Users\\HZ'
>>> os.chdir("C:\\Users") #修改脚本目录,相当于linux中的cd命令
>>> os.getcwd()
'C:\\Users'
>>> os.curdir #返回当前目录
'.'
>>> os.pardir #返回上一级目录
'..'
>>> os.makedirs("a/b/c") #创建一个目录,相当于linux 中mkdir -p
>>> os.removedirs("a/b/c")# 如目录为空,删除目录并递归到附录进行同样的操作
>>> os.mkdir("a") #创建目录,只能是单级
>>> os.rmdir("a") #删除指定目录,若目录不为空,则不能删除
>>> os.listdir(os.getcwd()) #获取目录下的所有文件,以列表的形式显示
>>> os.stat(os.getcwd()) #获取目录的状态
>>> os.sep #输出操作系统特定的路径分隔符
'\\'
>>> os.linesep #输出当前平台的行终止符
'\r\n'
>>> os.pathsep #输出用于分割文件路径的字符串
';'
>>> os.name #输出字符串指示当前使用的平台win->'nt',linux->'posix'
'nt'
>>> os.system("bash command")#运行shell命令,直接显示
>>> os.environ #获取系统的环境变量
>>> os.path.abspath("C:\\") #返回绝对路径
'C:\\'
>>> os.path.split(os.getcwd()) #将目录切分为一个二元元组,分别为目录和文件名
('C:\\Users', 'HZ')
>>> os.path.dirname(os.getcwd()) #获取目录的目录值,就是去掉最后一项文件
'C:\\Users'
>>> os.path.basename(os.getcwd()) #返回文件
'HZ'
>>> os.path.exists(os.getcwd()) #判断目录是否存在
True
>>> os.path.isfile(os.getcwd()) #判断是否是文件
False
>>> os.path.isdir(os.getcwd()) #判断是否是目录
True
>>> os.path.getatime(os.getcwd()) #返回目录中文件的最后存取时间
1510048928.72143
>>> os.path.getmtime(os.getcwd()) #返回目录或文件最后的修改时间
1510048928.72143
%a    本地(locale)简化星期名称    
%A    本地完整星期名称    
%b    本地简化月份名称    
%B    本地完整月份名称    
%c    本地相应的日期和时间表示    
%d    一个月中的第几天(01 - 31)    
%H    一天中的第几个小时(24小时制,00 - 23)    
%I    第几个小时(12小时制,01 - 12)    
%j    一年中的第几天(001 - 366)    
%m    月份(01 - 12)    
%M    分钟数(00 - 59)    
%p    本地am或者pm的相应符    一    
%S    秒(01 - 61)    二    
%U    一年中的星期数。(00 - 53星期天是一个星期的开始。)第一个星期天之前的所有天数都放在第0周。    三    
%w    一个星期中的第几天(0 - 6,0是星期天)    三    
%W    和%U基本相同,不同的是%W以星期一为一个星期的开始。    
%x    本地相应日期    
%X    本地相应时间    
%y    去掉世纪的年份(00 - 99)    
%Y    完整的年份    
%Z    时区的名字(如果不存在为空字符)    
%%    ‘%’字符
>>> datetime.datetime.now() #获取当前的日期和时间
datetime.datetime(2017, 11, 7, 16, 39, 52, 297738)
>>> datetime.date.fromtimestamp(time.time()) #把时间戳转换成日期
datetime.date(2017, 11, 7)
>>> datetime.datetime.now()+datetime.timedelta(3) #在当前时间上加3天
datetime.datetime(2017, 11, 10, 16, 41, 56, 679677)
>>> datetime.datetime.now()+datetime.timedelta(-3) #在当前时间上加-3天
datetime.datetime(2017, 11, 4, 16, 42, 1, 385043)
>>> datetime.datetime.now()+datetime.timedelta(hours = -3) #在当前时间上减3小时
datetime.datetime(2017, 11, 7, 13, 42, 9, 967968)
>>> datetime.datetime.now()+datetime.timedelta(minutes = 40) #在当前时间上加3小时
datetime.datetime(2017, 11, 7, 17, 22, 24, 57756)
>>> datetime.datetime.now().replace(hour = 2,minute = 3) #把当前时间的小时和分钟替换为自己想要的
datetime.datetime(2017, 11, 7, 2, 3, 12, 327112)

Json模块提供了五个效用:dumps、dump、loads、load

此外更多的模块请看:http://www.cnblogs.com/wupeiqi/articles/4963027.html

模块在逻辑上看来正是有集体的python代码,本质就是.py结尾的python文件。

import package_name
#如此那般的作用就是实施了包下的__init__.py代码,大家能够在__init__.py代码中置放我们要导入的模块,例如
from . import module_name,在那之中的点(.)代表当前目录。

time() -- return current time in seconds since the Epoch as a float
clock() -- return CPU time since process start as a float
sleep() -- delay for a number of seconds given as a float
gmtime() -- convert seconds since Epoch to UTC tuple
localtime() -- convert seconds since Epoch to local time tuple
asctime() -- convert time tuple to string
ctime() -- convert time in seconds to string
mktime() -- convert local time tuple to seconds since Epoch
strftime() -- convert time tuple to string according to format specification
strptime() -- parse string to time tuple according to format specification
tzset() -- change the local timezone

>>> time.time()  #获取当前的时间,格式为时间戳格式
1510038819.3997512
>>> time.clock()  #返回处理器的时间
3.6467229817941e-07
>>> time.sleep(3) #延迟3秒
>>> time.localtime() #获取当地此时的时间,时间格式为元组,字段分别代表(年、月、日、时、分、秒、星期数、一年中的第几天、是否是夏令时)
time.struct_time(tm_year=2017, tm_mon=11, tm_mday=7, tm_hour=15, tm_min=15, tm_sec=32, tm_wday=1, tm_yday=311, tm_isdst=0)
>>> time.gmtime(time.time()) #返回utc的时间,时间格式为元组,由于我们是东八区,所以这个时间刚好与我们相差八个小时
time.struct_time(tm_year=2017, tm_mon=11, tm_mday=7, tm_hour=7, tm_min=20, tm_sec=59, tm_wday=1, tm_yday=311, tm_isdst=0)
>>> time.asctime(time.localtime())  #返回一种固定的时间格式
'Tue Nov  7 15:16:30 2017'
>>> time.ctime() #同上
'Tue Nov  7 15:16:40 2017'

#时间转换之将格式化字符串时间和时间戳转换为元组格式的时间
>>> time.strptime("2017/11/07","%Y/%m/%d") #格式化->>元组
time.struct_time(tm_year=2017, tm_mon=11, tm_mday=7, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=311, tm_isdst=-1)
>>> time.gmtime(time.time()) #时间戳 ->>元组
time.struct_time(tm_year=2017, tm_mon=11, tm_mday=7, tm_hour=7, tm_min=31, tm_sec=48, tm_wday=1, tm_yday=311, tm_isdst=0)

#时间转换之将元组格式的时间转换为格式化字符串时间和时间戳

>>> struct_time = time.gmtime(time.time())
>>> time.strftime("%Y-%m-%d %H:%M:%S",struct_time) #元组->>格式化字符串时间
'2017-11-07 07:36:14'
>>> time.mktime(struct_time)#元组->>时间戳
1510011374.0

首要功能即是提供系统开始展览调用接口,一些常用的办法如下:

2、import module_name , module_name2
#实质同上,只是叁遍性导入多个模块

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图