python3 - 应用提升

一些常用的应用模块和功能

Posted by LOLITA0164 on March 1, 2019

CGI 编程

CGI(Common Gateway Interface),通用网关接口,它是一段程序,运行在服务器上(如 HTTP服务器),提供客户端的接口作用。

网页浏览

为了更好的了解 CGI 的工作流程,我们以网页点击一个链接为例:

CGI架构图

  1. 使用浏览器访问 URL 并链接到 HTTP web 服务器。
  2. Web 服务器接收到请求信息后回解析 URL,并查找访问的文件在服务器上是否存在,如果存在返回文件的内容,否则返回错误信息。
  3. 浏览器从服务器上接收信息,并显示接收的文件或错误信息。

CGI 程序可以是Python脚本、PERL脚本、SHELL脚本,C或者C++程序等。

一个 CGI 程序

#!/usr/bin/env python
print("Content-Type: text/html\n")

print("Hello World!!!")

上述脚本是一个简单的Python脚本,第一行输出的内容Content-Type: text/html\n发送到浏览器并告知浏览器显示的内容类型为’text/html’。

访问CGI

传递参数

Python中有一个叫做cgi的内置库,我们可是使用它来接收参数,无奈是GET还是POST都是一样的。

#!/usr/bin/env python
import	cgi
print("Content-Type: text/html\n")

# 创建 FieldStorage 的实例
store = cgi.FieldStorage()
# 获取参数
name = store.getvalue('name')
age = store.getvalue('age')

print("姓名:{0}, 年龄:{1}".format(name,age))

访问接口:

访问接口

上述例子中都是以文本形式,你也可以修改”Content-Type”类型以 json 形式返回。

#!/usr/bin/env python
import	cgi
print("Content-Type: text/json\n")

# 创建 FieldStorage 的实例
store = cgi.FieldStorage()
# 获取参数
name = store.getvalue('name')
age = store.getvalue('age')

import json
dict = {
	"name":name
	"age":age
}
json = json.dumps(dict)
print(json)

json形式

使用Cookie

cookie就是在客户访问脚本的同时,通过客户的浏览器,在客户硬盘上写入记录数据,当下次客户访问脚本时取回数据信息,从而达到身份判别的功能,cookie常用在身份校验中。

cookie语法

 Set-cookie:name=name;expires=date;path=path;domain=domain;secure
  • name=name: 需要设置cookie的值,有多个name值使用”;”分隔,例如:name1=name1;name2=name2。
  • expires=date: cookie的有效期限,格式:expires=”Wdy,DD-Mon-YYYY HH:MM:SS”
  • path=path: 设置cookie支持的路径,如果path是一个路径,则cookie对这个目录下的所有文件及子目录生效。
  • domain=domain: 对cookie生效的域名
  • secure:如果给出此标志,表示cookie只能通过SSL协议的https服务器来传递。
  • cookie的接收是通过设置环境变量 HTTP_COOKIE 来实现的,CGI程序可以通过检索该变量获取cookie信息。

设置cookie

#!/usr/bin/env python
import	cgi
print ('Content-Type: text/html')
print ('Set-Cookie: name="xiaoming";expires=Wed, 28 Aug 2018 18:30:00 GMT\n')

print("Cookie set OK!")

设置cookie

检索cookie

 #!/usr/bin/env python
import os
import http.cookies
print ('Content-Type: text/html\n')

if 'HTTP_COOKIE' in os.environ:
	cookie_string = os.environ.get('HTTP_COOKIE')
	c = http.cookies.SimpleCookie()
	c.load(cookie_string)

	try:
		data = c['name'].value
		print ("cookie data:{}".format(data))
	except :
		print ("cookie 没有设置或者已经过期")
else:
	print ("HTTP_COOKIE 无")

MySQL

mysql-connector

mysql-connector 是 MySQL 官方提供的驱动器。我们可以使用 pip 命令来安装 mysql-connector:

python -m pip install mysql-connector

数据库连接

import mysql.connector
 
mydb = mysql.connector.connect(
  host="localhost",       # 数据库主机地址
  user="yourusername",    # 数据库用户名
  passwd="yourpassword"   # 数据库密码
)

cursor()

可以使用cursor()方法创建一个游标对象cursor,我们可以使用他来进行一些数据库操作。

mycursor = mydb.cursor()

execute() 方法

游标对象有一个execute()方法,用来执行SQL语句。例如我们来查看已存在的数据库信息:

mycursor.execute("SHOW DATABASES")

commit() 方法

对于数据内容有更新的,都必须使用commit()语句来确认本次提交。

sql = "INSERT INTO sites (name, url) VALUES (%s, %s)"
val = ("RUNOOB", "https://www.runoob.com")
mycursor.execute(sql, val)
# 确认本次提交
mydb.commit()

rowcount

操作所影响的记录条数。

print(mycursor.rowcount, "记录插入成功。")

fetchall()、fetchone()

在查询数据时,我们可以使用上述两个方法来获取所有或者一条数据记录。

# 执行查询语句
mycursor.execute("SELECT name, url FROM sites")
# 查询所有
myresult1 = mycursor.fetchall()
# 查询单条记录
myresult2 = mycursor.fetchone()

PyMySQL

PyMySQL 是在 Python3.x 版本中用于连接 MySQL 服务器的库。

你可以使用 pip 安装 PyMySQL:

$ pip3 install PyMySQL

也可以使用 git 或手动安装

$ git clone https://github.com/PyMySQL/PyMySQL
$ cd PyMySQL/
$ python3 setup.py install

PyMySQL下的数据库操作与之前非常的相似。

操作数据库的相关实例:

#!/usr/bin/python3
 
import pymysql
 
# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
 
# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()
 
# 使用 execute()  方法执行 SQL 查询 
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()
 
print ("Database version : %s " % data)
 
# 关闭数据库连接
db.close()

数据查询

Python查询,mysql使用 ‘fetchone()’ 获取单条数据,使用 ‘fetchall()’ 获取多条数据。

  • fetchone() : 获取单条记录,查询的结果集是一个对象
  • fetchall() : 获取所有记录,查询的结果集是数组
  • rowcount : 返回执行 execute() 后所影响的行数,只读属性
# SQL 查询语句
sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > %s" % (1000)
try:
   # 执行SQL语句
   cursor.execute(sql)
   # 获取所有记录列表
   results = cursor.fetchall()
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
       # 打印结果
      print ("fname=%s,lname=%s,age=%s,sex=%s,income=%s" % \
             (fname, lname, age, sex, income ))
except:
   print ("Error: unable to fetch data")
 
# 关闭数据库连接
db.close()

事务

为何需要数据回滚?因为为了确保数据的一致性,及在执行某些操作时候,因为一些原因导致发生了异常,为了保证数据的完整性、一致性,我们需要将数据状态恢复到操作前的状态,即我们所有操作要么都被执行,要么都不被执行,而我们每次做的操作都被称为事务。

事务应该具有4种特性:原子性、一致性、隔离性、持久性。这4种属性通常称为ACID特性。

  • 原子性(atomicity):一个事务是一个不可分割的工作单位,事务中包括的诸多操作要么都做,要么都不做。
  • 一致性(consistency):事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性和原子性都是密切相关的。
  • 隔离性(isolation):一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能相互干扰。
  • 持久性(durability):持久性也称为永久性(permanence),指一个事务一旦提交,它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

python对事务提供了两个方法:commitrollback。这两个方法用来确认和回滚事务。在Python数据库编程中,当游标建立之时,就自动开始了一个隐形的数据库事务。

commit() 和 rollback()

在操作数据时,经常会发生一些异常,我们在执行这些更新数据时,可以将其放在 try/except 语句中,另外与其对应的,有一个 ‘rollback()’ 回滚的方法,撤销之前一切操作,回到最初的状态。

# SQL 插入语句
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   # 执行sql语句
   cursor.execute(sql)
   # 提交到数据库执行
   db.commit()
except:
   # 如果发生错误则回滚
   db.rollback()
 
# 关闭数据库连接
db.close()

MySQL 教程

有关更多的 MySQL 操作,可以查看菜鸟教程中的 MySQL 教程


多线程

线程的一些概念

每个独立的的线程有一个程序运行入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。每个线程都有他自己的一组CPU寄存器,称为线程的上下文,该上下文反映了线程上次运行该线程的CPU寄存器的状态。指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器,线程总是在进程的到上下文中运行的,这些地址都用于标志拥有线程的进程地址空间中的内存。

线程可以被抢占中断,在其他线程正在运行时,线程可以暂时搁置(也称为睡眠)。线程可以被分为内核线程和用户线程。内核线程是由操作系统内核创建和撤销,用户线程不需要内核支持而是在用户程序中实现的线程。

线程模块

Python3提供了两个标准库 _threadthreading对线程的支持,其中_thread模块已经被废弃,它提供了低级别的、原始的线程以及一个简单的锁,它相比于 threading模块的功能还是比较有限的。threading取代了_thread模块,前者除了包含后者的所有方法以外,还提供了其他的方法:

  • currentThread(): 返回当前的线程变量
  • enumerate(): 返回一个包含正在运行的线程list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程
  • activeCount(): 返回正在运行的线程数量
  • run() : 用以表示线程活动的方法
  • start() : 启动线程活动
  • join([time]) : 等待至线程中止。这阻塞调用线程直至线程的join()方法被调用中止(正常退出、抛出异常、超时)
  • isAlive() : 返回线程是否活动
  • getName() : 返回线程名
  • setName() : 设置线程名

实例:

开启一个线程执行任务。

import threading
import time

# 为线程定义一个任务
def print_time(delay):
    count = 0
    while count<5:
        time.sleep(delay)
        count += 1
        # 输出当前线程的名称以及时间
        print('{},{}'.format( threading.current_thread().name, time.ctime(time.time()) ))

# 创建线程,target为线程执行的任务,args为任务需要的参数
thread_1 = threading.Thread( target=print_time, name="Thread-1", args=(3,) )

thread_1.start()
thread_1.join()

输出结果:

Thread-1,Wed Mar  6 16:06:36 2019
Thread-1,Wed Mar  6 16:06:39 2019
Thread-1,Wed Mar  6 16:06:42 2019
Thread-1,Wed Mar  6 16:06:45 2019
Thread-1,Wed Mar  6 16:06:48 2019

接下来我们开始两个线程来执行任务,演示一下join()的作用,首先是同时开启任务。

# 创建线程,target为线程执行的任务,args为任务需要的参数
thread_1 = threading.Thread( target=print_time, name="Thread-1", args=(3,) )
thread_2 = threading.Thread( target=print_time, name="Thread-2", args=(2,) )

thread_1.start()
thread_2.start()
thread_1.join()
thread_2.join()

print("任务结束。")

输出结果:

Thread-2,Wed Mar  6 17:23:30 2019
Thread-1,Wed Mar  6 17:23:31 2019
Thread-2,Wed Mar  6 17:23:32 2019
Thread-1,Wed Mar  6 17:23:34 2019
Thread-2,Wed Mar  6 17:23:34 2019
Thread-2,Wed Mar  6 17:23:36 2019
Thread-1,Wed Mar  6 17:23:37 2019
Thread-2,Wed Mar  6 17:23:38 2019
Thread-1,Wed Mar  6 17:23:40 2019
Thread-1,Wed Mar  6 17:23:43 2019
任务结束。

我们发现join()阻塞了当前主线程,直至thread_1和thread_2的任务完成。如果你不使用join()方法,print("任务结束。")将会被优先执行。

我们交换一些位置,就像下面这样:

thread_1.start()
thread_1.join()

thread_2.start()
# thread_2.join()

print("任务结束。")

输出结果为:

Thread-1,Wed Mar  6 17:27:04 2019
Thread-1,Wed Mar  6 17:27:07 2019
Thread-1,Wed Mar  6 17:27:10 2019
Thread-1,Wed Mar  6 17:27:13 2019
Thread-1,Wed Mar  6 17:27:16 2019
任务结束。
Thread-2,Wed Mar  6 17:27:18 2019
Thread-2,Wed Mar  6 17:27:20 2019
Thread-2,Wed Mar  6 17:27:22 2019
Thread-2,Wed Mar  6 17:27:24 2019
Thread-2,Wed Mar  6 17:27:26 2019

线程安全

在多线程编程时,如果多个线程共同对某个数据修改,则可能出现不可预料的结果,就像下面这样。

import threading
import time

# 定义一个全局共用的数据
count = 10

# 为线程1定义 +1 任务
def addOne():
    global count
    for i in range(5):
        count += 1
        print('{},{}'.format(threading.current_thread().name, count))
        time.sleep(1)

# 为线程2定义 -1 任务
def reduceOne():
    global count
    for i in range(5):
        count -= 1
        print('{},{}'.format(threading.current_thread().name, count))
        time.sleep(2)

thread_1 = threading.Thread(target=addOne, name="thread-1")
thread_2 = threading.Thread(target=reduceOne, name="thread-2")

thread_1.start()
thread_2.start()

输出的结果:

thread-1,11
thread-2,10
thread-1,11
thread-2,10
thread-1,11
thread-1,12
thread-2,11
thread-1,12
thread-2,11
thread-2,10

为了保证数据的正确性,需要对多个线程进行同步。

Python中,使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步,这两个对象都有 acquire 方法和 release 方法,分别对应锁的两种状态–锁定和未锁定,对于那些需要每次只允许一个线程操作的数据,可以将其操作放到 acquire 和 release 方法之间。

import threading
import time

# 定义一个全局共用的数据
count = 10

# 创建锁
threadLock = threading.Lock()

# 为线程1定义 +1 任务
def addOne():
    global count
    # 锁定
    threadLock.acquire()
    for i in range(5):
        count += 1
        print('{},{}'.format(threading.current_thread().name, count))
        time.sleep(1)
    # 释放锁
    threadLock.release()

# 为线程2定义 -1 任务
def reduceOne():
    global count
    # 锁定
    threadLock.acquire()
    for i in range(5):
        count -= 1
        print('{},{}'.format(threading.current_thread().name, count))
        time.sleep(2)
    # 释放锁
    threadLock.release()

thread_1 = threading.Thread(target=addOne, name="thread-1")
thread_2 = threading.Thread(target=reduceOne, name="thread-2")

thread_1.start()
thread_2.start()

输出结果为:

thread-1,11
thread-1,12
thread-1,13
thread-1,14
thread-1,15
thread-2,14
thread-2,13
thread-2,12
thread-2,11
thread-2,10

结果正确。在线程1进行加1操作时,线程锁锁定,线程2只能等待,等到线程1的锁被释放后,线程2继续进行减1操作。

Queue 队列

Python 的 Queue 模块中提供了同步的、线程安全的队列类,包括 FIFO(先进先出)的队列,LIFO(后入先出LifoQueue)队列以及优先级队列(PriorityQueue)。队列用来在生产者和消费者线程之间的信息传递。

这些队列都实现了锁原语,能够在多线程中直接使用,可以使用队列来实现线程的同步。

Queue 模块中常用的方法:

  • qsize(): 队列的大小
  • empty(): 队列的是否空值
  • full(): 队列是否满了
  • get([block[,timeout]]): 获取队列,timeout为等待时间
  • get_nowait(): 相当于 Queue.get(False)
  • put(item[,timeout]): 写入队列,timeout为等待时间
  • put_nowait(item): 相当于 Queue.put(item,False)
  • task_done(): 在完成一项工作之后,Queue.task_done()函数像任务已完成的队列发送一个信号
  • join(): 实际上意味着等到队列为空,再执行别的操作

1、FIFO 队列

FIFO 即 First In First Out。Queue 提供了一个基本的 FIFO 容器,使用方法很简单,maxsize 是个整数,指明了队列中能存放的数据个数的上限,一旦达到上限,插入操作就被阻塞,直到队列中的数据被消费掉。如果maxsize小于或等于0,队列大小没有限制。

import queue
# 创建 FIFO 队列,限制元素数量为 10
q = queue.Queue(maxsize=10)
# 填充队列
for i in range(5):
    q.put(i)
# 输出所有的元素
while not q.empty():
    print(q.get())

输出结果为:

0
1
2
3
4

2、LIFO 队列

LIFO 即 Last In First Out,后进先出,和栈类似。

import queue
# 创建 LIFO 队列,数量无限制
q = queue.LifoQueue()
# 填充队列
for i in range(5):
    q.put(i)
# 输出所有的元素
while not q.empty():
    print(q.get())

输出结果为:

4
3
2
1
0

可以看出,LIFO 和 FIFO 效果相反。

3、优先级队列

顾名思义,优先级列队会根据元素的优先级来决定谁被优先处理。

import queue
# 创建优先级队列
q = queue.PriorityQueue()
# 创建不同优先级的"任务",注意这些任务插入队列的顺序
for i in [3,10,1,12,5]:
    q.put((i, 'levle {} job'.format(i)))

while not q.empty():
    # 从队列中获取"任务"
    priority, info = q.get()
    print(info)

输出结果为:

levle 1 job
levle 3 job
levle 5 job
levle 10 job
levle 12 job

我们发现,这些“任务”并非按照先进先出或后进先出的顺序被执行,而是按照优先级来执行,我们看到优先级小的被先执行了,实际上,由于Queue代码的核心是利用 heapq 模块,heapq.heappop()会返回最小值项,因此需要把 priority 的值变为负,才能让队列将每一项按从最高到最低优先级的顺序级来排序。

事实上,我们也可以定义一个任务类,实现相关的比较方法,就可以使用优先级队列,实现按照优先级来执行相关任务。

import queue
# 定义一个任务类
class Job(object):
    def __init__(self, priority, info):
        self.priority = priority
        self.info = info

    # 实现 Job 类的比较,这里拿优先级的值来比较
    __eq__ = lambda self, other : self.priority == other.priority
    __lt__ = lambda self, other : self.priority < other.priority
    __gt__ = lambda self, other : self.priority > other.priority

q = queue.PriorityQueue()
# 设置不同优先级的任务,注意插入队列的顺序
for i in [3,1,4,6,5,2]:
    q.put((Job(i, 'level {} job'.format(i))))

while not q.empty():
    job = q.get()
    print(job.info)

输出结果为:

level 1 job
level 2 job
level 3 job
level 4 job
level 5 job
level 6 job

4、线程同步

在介绍完队列的概念后,我们回到最初,之前提到过 Queue 的三种队列都实现了锁原语,能够在多线程中直接使用,无需再使用锁来实现线程同步。

接下来,我们使用多线程来执行不同优先级的任务,来看看在队列中的任务是否会被多个线程同时处理。

import queue
import threading
import time

# 定义一个任务类
class Job(object):
    def __init__(self, priority, info):
        self.priority = priority
        self.info = info

    # 实现 Job 类的比较,这里拿优先级的值来比较
    __eq__ = lambda self, other : self.priority == other.priority
    __lt__ = lambda self, other : self.priority < other.priority
    __gt__ = lambda self, other : self.priority > other.priority

q = queue.PriorityQueue()
# 设置不同优先级的任务,注意插入队列的顺序
for i in [3,1,4,6,5,2]:
    q.put((Job(i*-1, 'level {} job'.format(i))))

# 定义一个用于多线程的任务
def process_job(q):
    while True:
        time.sleep(1)
        next_job = q.get()
        print('线程:{},任务:{}'.format(threading.current_thread().name, next_job.info))
        q.task_done()

threads = [
    threading.Thread(target=process_job, name="thread-1", args=(q,)),
    threading.Thread(target=process_job, name="thread-2", args=(q,)),
    threading.Thread(target=process_job, name="thread-3", args=(q,)),
]

for thread in threads:
    thread.setDaemon(True)
    thread.start()

q.join()

执行结果为:

线程:thread-1,任务:level 6 job
线程:thread-2,任务:level 5 job
线程:thread-3,任务:level 4 job
线程:thread-2,任务:level 3 job
线程:thread-1,任务:level 2 job
线程:thread-3,任务:level 1 job

在该例子中,我们创建了三个线程一同去优先级队列中执行任务,从结果中,我们发现,优先级高的依旧被优先处理,三个线程也都只能同步的,一个接着一个的执行队列中的任务。

由此可见,Queue 中的数据被多线程使用时,无需担心线程安全的问题。


时间

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间戳

  • time()

时间戳是以秒为单位的浮点小数。每个时间戳都是以自从1970年1月1日经过了多长时间来表示。时间戳单位最适合做日期运算,但是1970年之前的日期就无法以此表示了,太遥远的日期也不行,UNIX和Windows只支持到2038年。

import time
# 获取时间戳,1970年到当前时间
ticks = time.time()
print('当前时间戳:{}'.format(ticks))

# 输出
当前时间戳:1551935182.847225

时间元组

python函数用一个元组装起来的9组数字处理时间,该结构字段如下:

序号 属性 取值
0 tm_year 四位数字的年份
1 tm_mon 1-12
2 tm_mday 1-31
3 tm_hour 0-23
4 tm_min 0-59
5 tm_sec 0-61(60或61是润秒)
6 tm_wday 0-6(0表示周一)
7 tm_yday 1-366,一年中的第几天
8 tm_isdst 是否为夏令时
  • localtime([seconds])

我们可以使用 localtime([seconds])获取当前时间元组

# 获取当前时间元组
# 参数为空时,默认是当前时间戳
localtime = time.localtime()
print('当前时间:{}'.format(localtime))

# 输出
当前时间:time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=13, tm_min=20, tm_sec=20, tm_wday=3, tm_yday=66, tm_isdst=0)

# 往前推一年的时间
timestamp = time.time() - 365*24*60*60
localtime2 = time.localtime(timestamp)
print('一年前时间:{}'.format(localtime2))

# 输出
一年前时间:time.struct_time(tm_year=2018, tm_mon=3, tm_mday=7, tm_hour=13, tm_min=20, tm_sec=20, tm_wday=2, tm_yday=66, tm_isdst=0)

# 可以将时间元组分别取出年月日
print('当前日期:{}-{:0>2d}-{:0>2d}'.format(localtime.tm_year, localtime.tm_mon, localtime.tm_mday))

# 输出
当前日期:2019-03-07
  • mktime(p_tuple)

我们利用时间戳得到时间元组,也可以将时间元组转换为时间戳,调用方法mktime()即可。

localtime = time.localtime()
# 将当前时间元组转换为当前时间戳
timestamp = time.mktime(localtime)
print('当前时间戳:{}'.format(timestamp))
print('当前时间戳:{}'.format(time.time()))

# 输出
当前时间戳:1551936978.0
当前时间戳:1551936978.986351

可以看到,mktime()只会保留到秒级。

格式化时间

在开发过程中,通常我们都需要时间的各种格式的字符串。这里介绍几种格式化方法。

  • asctime([p_tuple])

将时间元组转换为可读的时间模式,参数默认为当前时间元组。

# 获取格式化的时间
formatTime = time.asctime()
print(formatTime)

# 输出
Thu Mar  7 13:26:54 2019
  • ctime([seconds])

时间戳也可以直接使用ctime([seconds])格式化,参数默认为当前时间戳。

# 获取格式化的时间,参数为时间戳,默认使用当前时间戳
formatTime = time.ctime()
print(formatTime)

# 输出
Thu Mar  7 13:31:03 2019
  • strftime(format[, p_tuple])

当然,我们可以看到,上述的两个方法的格式化中包括了英文下的月份、星期,在通常情况下,我们并不需要这样的时间格式,而strftime()方法可以满足我们自由定制的时间格式。

先来一个简单例子:

# 格式化日期
time1 = time.strftime("%Y-%m-%d %H:%M:%S")
print(time1)

# 输出
2019-03-07 14:00:05

python中时间日期格式化符号:

符号 简述
%y 两位数的年份表示(00-99)
%Y 四位数的年份表示(000-9999)
%m 月份(01-12)
%d 月内中的一天(0-31)
%H 24小时制小时数(0-23)
%I 12小时制小时数(01-12)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)星期天为星期的开始
%w 星期(0-6),星期天为星期的开始
%W 一年中的星期数(00-53)星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
  • strptime(string, format)

除了将时间戳,时间元组格式化为字符串,我们还可以将字符串转换为时间元组或时间戳。

# 将时间字符串转换为时间元组
timeString = "2019-03-07 14:00:05"
timeTuple = time.strptime(timeString, "%Y-%m-%d %H:%M:%S")
print('时间元组:{}'.format(timeTuple))

# 输出
时间元组:time.struct_time(tm_year=2019, tm_mon=3, tm_mday=7, tm_hour=14, tm_min=0, tm_sec=5, tm_wday=3, tm_yday=66, tm_isdst=-1)

# 继续将时间元组转换为时间戳
timestamp = time.mktime(timeTuple)
print('当前时间戳:{}'.format(timestamp))

# 输出
当前时间戳:1551938405.0

几种时间格式的关系图。

关系图

  • sleep(secs)

推迟调用线程的运行,参数为秒单位。

print ("Start : {}".format(time.ctime()))
time.sleep( 5 )
print ("End : {}".format(time.ctime()))

# 输出
Start : Thu Mar  7 15:12:46 2019
End : Thu Mar  7 15:12:51 2019

网络编程


内置函数

说明

以上内容均来自菜鸟教程,更多内容可继续查阅相关资料。

感谢菜鸟教程的无私奉献!