Python on Dapeng Zhang

fabric 2.5.0添加类似env配置文件，减少执行命令重复操作

Wed, 30 Jul 2025 11:44:26 +0800

fabric 2.5.0可以通过添加类似env配置文件，从而达到减少执行命令的重复操作，比如减少每次执行任务的用户名和密码的输入

如果将用户名和密码写入fabric.py这种项目文件中，并提交到git仓库的话也是非常不安全的

但是根据用户来创建一个可自己访问和执行的文件就比较方便，尤其是在linux系统下，多个用户多一个操作系统都有权限的话，每个用户下面只要有个~/.fabric.yaml文件

便可以执行fabric的任务操作，从而避免了将重要密码暴漏给所有人，或者将自己的密码共享给所有人

创建配置文件


touch ~/.fabric.yaml

在配置文件中添加类似如下的配置信息


user: dpzhang
pwd: 123456

然后在fabric.py中添加任务


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-04 16:52:35
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-20 18:50:44

import getpass
from fabric import Connection, task

@task
def test(c):
 print(c.user)
 print(c.pwd)

命令行下执行


fab test

得到输出的结果如下


dpzhang
123456

如果将test方法修改如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-04 16:52:35
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-20 18:50:44

import getpass
from fabric import Connection, task

@task
def test(c):
 print(c.user)
 print(c.pwd)
 print(c.hosts.host)

同时修改~/.fabric.yaml，内容修改后如下


user: dpzhang
pwd: 123456
hosts:
 host: 127.0.0.1

再次运行


fab test

得到的输出结果如下


dpzhang
123456
127.0.0.1

Python小技巧 - 下载抓取小视频

Wed, 30 Jul 2025 11:44:11 +0800

采集/下载小视频

操作流程

分析页面
抓取页面
抓取小视频
保存小视频

比如抓取pearvideo网站的视频

选取要抓取的页面https://www.pearvideo.com/popular，分析此页面的视频，通过点击页面的链接知道视频的页面https://www.pearvideo.com/video_1707347

然后抓取小视频，下载保存小视频

通过以上分析不难得出

每一页的获取是通过https://www.pearvideo.com/popular_loading.jsp?reqType=1&categoryId=&start=20&sort=15&mrd=0.24415926264194443
视频的获取是通过https://www.pearvideo.com/video_1707347页面的ajax请求https://www.pearvideo.com/videoStatus.jsp来获取视频的参数
分析视频的参数获得视频的地址，这里注意一个地址的更换，假地址：https://video.pearvideo.com/mp4/adshort/20201117/1605695463779-15486835_adpkg-ad_hd.mp4真地址：https://video.pearvideo.com/mp4/adshort/20201117/cont-1707347-15486835_adpkg-ad_hd.mp4

最后示例代码如下


import requests
import re
import os

def fetch_video_content(video_id):
 page_video_url = 'https://www.pearvideo.com/videoStatus.jsp'
 params = {
 'contId': video_id,
 'mrd': '0.9725183045235088'
 }

 headers = {
 'Referer': f'https://www.pearvideo.com/video_{video_id}',
 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) \
 AppleWebKit/537.36 (KHTML, like Gecko) \
 Chrome/86.0.4240.193 Safari/537.36'
 }
 response = requests.get(page_video_url, params=params, headers=headers)

 data = response.json()

 video_url = re.sub(data['systemTime'],
 f'cont-{video_id}',
 data['videoInfo']['videos']['srcUrl'])

 video_content = requests.get(video_url)
 save_path = os.getcwd() + '/videos/video_' + str(video_id) + '.mp4'

 with open(save_path, mode='wb') as f:
 f.write(video_content.content)

def fetch_video():
 for page in range(10, 110, 10):
 page_web_page_url = f'https://www.pearvideo.com/popular_loading.jsp'
 params = {
 'reqType': 1,
 'start': page,
 'sort': 15,
 'mrd': '0.24415926264194443'
 }

 response = requests.get(page_web_page_url, params=params)

 titles = re.findall(
 '<h2 class="popularem-title">(.*?)</h2>', response.text)
 video_ids = re.findall(
 '<a href="video_(\d+)" class="popularembd actplay">',
 response.text)

 for video_id in video_ids:
 fetch_video_content(video_id)

知识点汇总

正则的使用 re.findall re.sub
requests的使用，尤其是 headers params
requests的json处理，response.json()
request的二进制数据处理，response.content

Python技巧 - Python多线程爬虫

Wed, 30 Jul 2025 11:44:04 +0800

Python多线程爬虫 - 案例记录

用的库如下

requests
theading
queue
fake_useragent
lxml

实现原理：通过多线程方式读取Queue中的数据

代码实现思路如下


# -*- coding:utf-8 -*-
from threading import Thread
from queue import Queue
from lxml import etree
from fake_useragent import Useragent

class CrawlInfo(Thread):
 def __init__(self, url_queue, html_queue):
 self.url_queue = url_queue
 self.html_queue = html_queue

 # 重写run方法
 def run(self):
 '''
 1. 模拟浏览器
 2. 请求
 3. 数据筛选
 4. 数据保存
 '''
 headers = {'User-Agetn': Useragent().random}

 while self.url_queue.empty() != False:
 url = self.url_queue.get()
 response = requests.get(url, headers=headers)
 if response.status_code == 200:
 print(response.text)
 self.html_queue.put(response.text)

class ParseInfo(Thread):
 def __init__(self, html_queue):
 self.html_queue = html_queue

 def run(self):
 while self.html_queue.empty() != False:
 e = etree.HTML(self.html_queue.get())
 span_contents = e.xpath('//div[@class="content"]/span[1]')
 with open('duanzi.txt', 'a', encoding='utt-8') as f:
 for span in span_contents:
 info = span.xpath('string(.)')
 f.write(info + '\n')

if __name__ == "__main__":
 url_queue = Queue()
 html_queue = Queue()
 base_url = 'https://www.qiushibaike.com/8hr/page/{}/'
 for i in range(1, 14):
 url_queue.put(base_url.format(i))

 crawl_list = []
 for i in range(1, 3):
 crawl = CrawlInfo(url_queue, html_queue)
 crawl_list.append(crawl)
 crawl.start()

 for crawl in crawl_list:
 crawl.join()

 parse_list = []
 for i in range(3):
 parse = ParseInfo(html_queue)
 parse_list.append(parse)
 parse.start()

 for parse in parse_list:
 parse.join()

代码未运行测试

Python技巧 - 制作抖音引流脚本

Wed, 30 Jul 2025 11:43:59 +0800

技巧记录

1、安装ApowerMirror软件（一个投屏软件）

2、安装adb驱动即Android Debug Bridge（安卓测试桥） tools，一个命令行窗口

3、了解命令

截屏命令


adb shell screencap -p /sdcard/screen.png

保存图片命令


adb pull /sdcard/screen.png

点击命令


adb shell input tap x y

翻页命令


adb shell input swipe x1 y1 x2 y2

4、脚本


import os
os.system('') # 执行截屏命令
os.system('') # 执行保存图片命令
# 根据关注按钮坐标执行点击操作
os.system('') # 执行点击关注命令
# 循转执行翻页命令
os.system('') # 执行翻页命令

Python 技巧 - 抓取页面并保存为PDF

Wed, 30 Jul 2025 11:43:55 +0800

技巧要点记录

1、requests和parsel库的安装

2、获取网页内容

发送一个请求


url = ''

headers = {
 'Host': '',
 'Referer': '',
 'User-Agent': ''
}

cookie = {
 'Cookie': ''
}

response = requests.get(url, headers=headers, cookie=cookie)

print(response.text)

获取到内容

3、pdfkit、wkhtmltopdf库的安装


pip install pdfkit

wkhtmltopdf 请去官网下载 https://wkhtmltopdf.org/downloads.html

4、转换为PDF

pdfkit、wkhtmltopdf库的安装


import pdfkit

config = pdfkit.configuration(wkhtmltopdf='xxx/xxx/wkhtmltopdf.exe')

pdfkit.from_file('xx.html', 'xxx.pdf', configuration=config)

Python 3.9.0 小知识 - PEP 616：移除前缀和后缀的字符串方法

Wed, 30 Jul 2025 11:43:46 +0800

Python 3.9.0 新增内置方法：移除前缀和后缀的字符串方法

详情可以点击这里查看

这里简单做下记录

从详情中我们可以看到其具体实现


def removeprefix(self: str, prefix: str, /) -> str:
 if self.startswith(prefix):
 return self[len(prefix):]
 else:
 return self[:]

def removesuffix(self: str, suffix: str, /) -> str:
 # suffix='' should not call self[:-0].
 if suffix and self.endswith(suffix):
 return self[:-len(suffix)]
 else:
 return self[:]

同时列举了几个例子

第一个列子


if test_func_name.startswith("test_"):
 print(test_func_name[5:])
else:
 print(test_func_name)

这里例子如果在Python 3.9.0的话，可以改善为下面的方式


print(test_func_name.removeprefix("test_"))

第二个例子


if funcname.startswith("context."):
 self.funcname = funcname.replace("context.", "")
 self.contextfunc = True
else:
 self.funcname = funcname
 self.contextfunc = False

如果使用Python 3.9.0的话，可以改善为下面的方式


if funcname.startswith("context."):
 self.funcname = funcname.removeprefix("context.")
 self.contextfunc = True
else:
 self.funcname = funcname
 self.contextfunc = False

进一步可以改善为


self.contextfunc = funcname.startswith("context.")
self.funcname = funcname.removeprefix("context.")

第三个例子


def strip_quotes(text):
 if text.startswith('"'):
 text = text[1:]
 if text.endswith('"'):
 text = text[:-1]
 return text

如果使用Python 3.9.0的话，可以改善为下面的方式


def strip_quotes(text):
 return text.removeprefix('"').removesuffix('"')

第四个列子


if name.endswith(('Mixin', 'Tests')):
 return name[:-5]
elif name.endswith('Test'):
 return name[:-4]
else:
 return name

如果使用Python 3.9.0的话，可以改善为下面的方式


return (name.removesuffix('Mixin')
 .removesuffix('Tests')
 .removesuffix('Test'))

Python全栈开发与人工智能 - 学习指南

Wed, 30 Jul 2025 11:43:43 +0800

阶段一：Python开发基础

Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件操作、函数、装饰器、迭代器、内置方法、常用模块等。

阶段二：Python高级编程和数据库开发

Python高级编程和数据库开发知识学习内容包括：面向对象开发、Socket网络编程、线程、进程、队列、IO多路模型、Mysql数据库开发等。

阶段三：前端开发

前端开发知识学习内容包括：Html、CSS、JavaScript开发、Jquery&bootstrap开发、前端框架VUE开发等。

阶段四：WEB框架开发

WEB框架开发学习内容包括：Django框架基础、Django框架进阶、BBS+Blog实战项目开发、缓存和队列中间件、Flask框架学习、Tornado框架学习、Restful API等。

阶段五：爬虫开发

爬虫开发学习内容包括：爬虫开发实战。

阶段六：全栈项目实战

全栈项目实战学习内容包括：企业应用工具学习、CRM客户关系管理系统开发、路飞学城在线教育平台开发等。

阶段七：数据分析

数据分析学习内容包括：金融量化分析。

阶段八：人工智能

人工智能学习内容包括：机器学习、图形识别、无人机开发、无人驾驶等。

阶段九：自动化运维&开发

自动化运维&开发学习内容包括：CMDB资产管理系统开发、IT审计+主机管理系统开发、分布式主机监控系统开发等。

阶段十：高并发语言GO开发

高并发语言GO开发学习内容包括：GO语言基础、数据类型与文件IO操作、函数和面向对象、并发编程等。

上面内容参考了这里，点击这里跳转

感觉学习久了，不做点东西容易迷失方向，没事看看自己哪里还不会的。

Python 3.9.0 小知识 - PEP 585：标准多项集中的类型标注泛型

Wed, 30 Jul 2025 11:43:35 +0800

PEP 585：标准多项集中的类型标注泛型

字面上有点难理解，我也是懵圈中

看了下官网的解释：https://www.python.org/dev/peps/pep-0585/

大概了解下来我用实例演示下

从Python 3.7到Python 3.8之前我们可以这样创建函数了

比如我要获取一个List的长度


$ python
Python 3.8.6 (default, Oct 8 2020, 14:06:32)
[Clang 12.0.0 (clang-1200.0.32.2)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import typing
>>> def get_value_length(l: typing.List[str]) -> int:
... return len(l)
...
>>> get_value_length([1,2,4])
3

但是如果我要像下面这样创建是不行的


$ python
Python 3.8.6 (default, Oct 8 2020, 14:06:32)
[Clang 12.0.0 (clang-1200.0.32.2)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def get_value_length(l: List[str]) -> int:
... return len(l)
...
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
NameError: name 'List' is not defined

或者


>>> def get_value_length(l: list[str]) -> int:
... return len(l)
...
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: 'type' object is not subscriptable

但是现在在Python 3.9中这个事情就变的简单了


$ /usr/local/Cellar/[email protected]/3.9.0/bin/python3
Python 3.9.0 (default, Oct 6 2020, 04:17:54)
[Clang 12.0.0 (clang-1200.0.32.2)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def get_value_length(l: list[str]) -> int:
... return len(l)
...
>>> get_value_length([1,2,3])
3
>>> get_value_length(['1','2','3'])
3

这里我只演示了list

其实还有很多类似这样的，如下

tuple # typing.Tuple
list # typing.List
dict # typing.Dict
set # typing.Set
frozenset # typing.FrozenSet
type # typing.Type
collections.deque
collections.defaultdict
collections.OrderedDict
collections.Counter
collections.ChainMap
collections.abc.Awaitable
collections.abc.Coroutine
collections.abc.AsyncIterable
collections.abc.AsyncIterator
collections.abc.AsyncGenerator
collections.abc.Iterable
collections.abc.Iterator
collections.abc.Generator
collections.abc.Reversible
collections.abc.Container
collections.abc.Collection
collections.abc.Callable
collections.abc.Set # typing.AbstractSet
collections.abc.MutableSet
collections.abc.Mapping
collections.abc.MutableMapping
collections.abc.Sequence
collections.abc.MutableSequence
collections.abc.ByteString
collections.abc.MappingView
collections.abc.KeysView
collections.abc.ItemsView
collections.abc.ValuesView
contextlib.AbstractContextManager # typing.ContextManager
contextlib.AbstractAsyncContextManager # typing.AsyncContextManager
re.Pattern # typing.Pattern, typing.re.Pattern
re.Match # typing.Match, typing.re.Match

不过对于我来说也许我也就用到下面几个

tuple # typing.Tuple
list # typing.List
dict # typing.Dict
set # typing.Set
frozenset # typing.FrozenSet
type # typing.Type

完全个人理解，仅供参考

Python小技巧 - Lambda函数

Wed, 30 Jul 2025 11:43:32 +0800

Lambda函数

lambda创建函数


add = lambda x, y: x + y


print(add(2, 3))

普通方式创建函数


def add(x, y):
 return x + y


print(add(2, 3))

lambda匿名函数


add_res = (lambda x, y: x + y)(2, 3)
print(add_res)

Python 3.9.0 小知识 - PEP584：增加字典合并操作符

Wed, 30 Jul 2025 11:43:01 +0800

PEP584：增加字典合并操作符

内置字典类增加合并（ | ）与更新（ |= ）操作符

就是增加了合并操作符和更新操作符，简单应用下


>>> d = {'spam': 1, 'eggs': 2, 'cheese': 3}
>>> e = {'cheese': 'cheddar', 'aardvark': 'Ethel'}
>>> d | e
{'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}
>>> e | d
{'aardvark': 'Ethel', 'spam': 1, 'eggs': 2, 'cheese': 3}


>>> d |= e
>>> d
{'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}

文章参考：链接1

Python 3.9.0 正式发布

Wed, 30 Jul 2025 11:28:45 +0800

Python3.9.0 版本发布

发布时间：2020 年 10 月 5 日

主要的新特性如下

为 dict 增加合并运算符；
标准多项集中的类型标注泛型。
放宽对装饰器的语法限制。
移除前缀和后缀的字符串方法。
灵活的函数和变量标注；
添加了 os.pidfd_open() 以允许不带竞争和信号的进程管理。
IANA 时区数据库现在已包含于标准库的 zoneinfo 模块；
图的拓扑排序实现现在已由新的 graphlib 模块提供。

更多详情请参考

链接1、链接2

Python小知识 - dis字节码反汇编器

Wed, 30 Jul 2025 11:28:42 +0800

dis字节码反汇编器

这里主要是通过dis类的dis方法


dis.dis(x=None, *, file=None, depth=None)

官方解释如下：

反汇编 x 对象。 x 可以表示模块、类、方法、函数、生成器、异步生成器、协程、代码对象、源代码字符串或原始字节码的字节序列。对于模块，它会反汇编所有功能。对于一个类，它反汇编所有方法（包括类和静态方法）。对于代码对象或原始字节码序列，它每字节码指令打印一行。它还递归地反汇编嵌套代码对象（推导式代码，生成器表达式和嵌套函数，以及用于构建嵌套类的代码）。在被反汇编之前，首先使用 compile() 内置函数将字符串编译为代码对象。如果未提供任何对象，则此函数会反汇编最后一次回溯。

下面看个实例方法


import dis

def greet(name):
 return 'Hello,' + name + '!'

dis.dis(greet)

运行后得到的结果如下


 15 0 LOAD_CONST 1 ('Hello,')
 2 LOAD_FAST 0 (name)
 4 BINARY_ADD
 6 LOAD_CONST 2 ('!')
 8 BINARY_ADD
 10 RETURN_VALUE

Python小知识 - classmethod、staticmethod和正常方法的区别

Wed, 30 Jul 2025 11:28:38 +0800

classmethod、staticmethod和正常方法的区别是什么

简单的创建一个类


class TestClass(object):
 def method(self):
 return 'instance method called', self

 @classmethod
 def classmethod(self):
 return 'class method called', self

 @staticmethod
 def staticmethod(self):
 return 'static method called', self

接下来实例化类，实现如下


test = TestClass()
print(test.method())
print(test.classmethod())
print(test.staticmethod())

运行后输出的结果如下


('instance method called', <__main__.TestClass object at 0x10fe64e50>)
('class method called', <class '__main__.TestClass'>)
Traceback (most recent call last):
 File "/Users/durban/python/practise/main.py", line 31, in <module>
 print(test.staticmethod())
TypeError: staticmethod() missing 1 required positional argument: 'self'

staticmethod这个方法因为加了@staticmethod修饰符导致第一个参数self并不是类自身，而是作为一个参数需要传入

看下面的调用方式


test = TestClass()
print(test.method())
print(test.classmethod())
print(test.staticmethod(1))

运行后输出的结果如下


('instance method called', <__main__.TestClass object at 0x105e72e50>)
('class method called', <class '__main__.TestClass'>)
('static method called', 1)

再看个调用方式


print(TestClass.classmethod())
print(TestClass.staticmethod(1))
print(TestClass.method())

运行后得到的结果类似如下


('class method called', <class '__main__.TestClass'>)
('static method called', 1)
Traceback (most recent call last):
 File "/Users/durban/python/practise/main.py", line 30, in <module>
 print(TestClass.method())
TypeError: method() missing 1 required positional argument: 'self'

将上面的调用方式调整如下


print(TestClass.classmethod())
print(TestClass.staticmethod(1))
print(TestClass.method(1))

运行后得到的结果类似如下


('class method called', <class '__main__.TestClass'>)
('static method called', 1)
('instance method called', 1)

奇怪的是method可以被正常的调用了

python http web server 探索（十二）

Wed, 30 Jul 2025 11:28:33 +0800

作为一个简单的http web server

response应该提供一个公共的方法，方便调用的函数能够根据具体的情况做具体的内容类型调用

我这里目前简单的做了一个文本的操作

代码如下


# _*_coding:utf-8_*_

class HttpResponse(object):
 def __init__(self, writer):
 self.writer = writer

 def text(self, text):
 self.writer.write(str.encode(text))

在使用的时候，我们只返回一个response给调用函数，然后在调用函数中调用text方法就可以了


import asyncio, logging
from http_request import HttpRequest
from http_response import HttpResponse

url_map = []

def route(url, **kwargs):
 def wrapper(func):
 url_map.append((url, func, kwargs))
 return func

 return wrapper

@route('/hello')
async def hello(request, response):
 response.text("hello")

@route('/world')
async def world(request, response):
 response.text("world")

async def response_before(writer,
 content_type="text/html; charset=utf-8",
 status="200",
 headers=None):
 writer.write(str.encode(f"HTTP/1.0 {status} NA\r\n"))
 writer.write(b"Content-Type: ")
 writer.write(str.encode(content_type))

 if not headers:
 writer.write(b"\r\n\r\n")
 return

 writer.write(b"\r\n")
 if isinstance(headers, bytes) or isinstance(headers, str):
 await writer.write(str.encode(headers))
 else:
 for k, v in headers.items():
 writer.write(str.encode(k))
 writer.write(b": ")
 writer.write(str.encode(v))
 writer.write(b"\r\n")
 writer.write(b"\r\n")

async def response_404(reader, writer):
 await response_before(writer, status='404')

async def handle(reader, writer):
 method = ''
 path = ''
 found = False

 try:
 data = await reader.readline()
 except Exception as e:
 print(e)

 request = HttpRequest(reader, data)

 if request:
 pattern = None
 response_action = None
 extra = {}

 for url in url_map:
 pattern = url[0]
 response_action = url[1]

 if len(url) > 2:
 extra = url[2]

 if request.path == str.encode(pattern):
 found = True
 break

 response = HttpResponse(writer)
 if found:
 await response_before(writer, status='200')
 await response_action(request, response)
 else:
 await response_404(reader, writer)
 else:
 await response_404(reader, writer)

 await writer.drain()
 writer.close()
 await writer.wait_closed()

def serve(loop, host, port):
 loop.create_task(asyncio.start_server(handle, host, port))
 loop.run_forever()

def run(host, port=8090):
 loop = asyncio.get_event_loop()
 serve(loop, host, port)
 print('run ....')
 loop.close()

def runner(host, port):
 print('running')
 asyncio.run(run('0.0.0.0'))

runner('127.0.0.1', 8090)

然后启动下项目

运行后分别访问http://127.0.0.1/hello和http://127.0.0.1/world

均能看到输出hello和word

python http web server 探索（十一）

Wed, 30 Jul 2025 11:27:33 +0800

模板如何选择

这里参考了网上的一篇文章，其中写到的三个模板库记录如下

第一个模板库：Mako

Mako 是以 MIT 许可证发布的 Python 模板工具，专为快速展现而设计的（与 Jinja2 不同）。Reddit 已经使用 Mako 来展现他们的网页，它同时也是 Pyramid 和 Pylons 等 web 框架的默认模板语言。它相当简单且易于使用。你可以使用几行代码来设计模板；支持 Python 2.x 和 3.x，它是一个功能强大且功能丰富的工具，具有良好的文档，这一点我认为是必须的。其功能包括过滤器、继承、可调用块和内置缓存系统，这些系统可以被大型或复杂的 web 项目导入。

第二个模板库：Jinja2

Jinja2 是另一个快速且功能全面的选项，可用于 Python 2.x 和 3.x，遵循 BSD 许可证。Jinja2 从功能角度与 Mako 有很多重叠，因此对于新手来说，你在两者之间的选择可能会归结为你喜欢的格式化风格。Jinja2 还将模板编译为字节码，并具有 HTML 转义、沙盒、模板继承和模板沙盒部分的功能。其用户包括 Mozilla、 SourceForge、 NPR、 Instagram 等，并且还具有强大的文档。与 Mako 在模板内部使用 Python 逻辑不同的是，Jinja2 使用自己的语法。

第三个模板库：Genshi

Genshi 是我会提到的第三个选择。它是一个 XML 工具，具有强大的模板组件，所以如果你使用的数据已经是 XML 格式，或者你需要使用网页以外的格式，Genshi 可能成为你的一个很好的解决方案。HTML 基本上是一种 XML（好吧，不是精确的，但这超出了本文的范围，有点卖弄学问了），因此格式化它们非常相似。由于我通常使用的很多数据都是 XML 或其他类型的数据，因此我非常喜欢使用我可以用于多种事物的工具。

python http web server 探索（十）

Wed, 30 Jul 2025 11:27:20 +0800

web server中的HttpRequest实现

这个花了点时间想做的完善一些

但是就目前的情况来说，先简单的实现基础的功能就好

代码实现如下


class HttpRequest(object):
 def __init__(self, reader, data):
 self.reader = reader

 method, path, proto = data.split()

 self.method = method
 self.path = path
 self.query = self.parse_query_string(proto)

 def parse_query_string(self, data):
 return {}

然后调用的方式如下


import asyncio, logging
from http_request import HttpRequest

url_map = []

def route(url, **kwargs):
 def wrapper(func):
 url_map.append((url, func, kwargs))
 return func

 return wrapper

@route('/hello')
async def hello(request, writer):

 print(request.method)
 print(request.path)

 await start_response(writer, status='200')

 writer.write(b"hello\r\n")

 return 'hello'

@route('/world')
async def world(request, writer):
 print(f"request.method = {request.method}")
 print(f"request.path = {request.path}")

 await start_response(writer, status='200')

 writer.write(b"world\r\n")

 return 'world'

async def start_response(writer,
 content_type="text/html; charset=utf-8",
 status="200",
 headers=None):
 writer.write(str.encode(f"HTTP/1.0 {status} NA\r\n"))
 writer.write(b"Content-Type: ")
 writer.write(str.encode(content_type))

 if not headers:
 writer.write(b"\r\n\r\n")
 return

 writer.write(b"\r\n")
 if isinstance(headers, bytes) or isinstance(headers, str):
 await writer.write(str.encode(headers))
 else:
 for k, v in headers.items():
 writer.write(str.encode(k))
 writer.write(b": ")
 writer.write(str.encode(v))
 writer.write(b"\r\n")
 writer.write(b"\r\n")

async def handler(reader, writer):

 # await start_response(writer, status='404')
 await start_response(writer, status='200')

 writer.write(b"hello\r\n")

async def handler_404(reader, writer):
 await start_response(writer, status='404')

async def handle(reader, writer):
 print(f'handle...')

 print(url_map)

 method = ''
 path = ''
 found = False

 try:
 data = await reader.readline()
 except Exception as e:
 print(e)

 request = HttpRequest(reader, data)

 if request:
 pattern = None
 handler_action = None
 extra = {}

 for url in url_map:
 pattern = url[0]
 handler_action = url[1]

 if len(url) > 2:
 extra = url[2]

 if request.path == str.encode(pattern):
 found = True
 break

 if found:
 await handler_action(request, writer)
 else:
 print('here 1')
 await handler_404(reader, writer)
 else:
 print('here 2')
 await handler_404(reader, writer)

 await writer.drain()
 writer.close()
 await writer.wait_closed()

def serve(loop, host, port):
 loop.create_task(asyncio.start_server(handle, host, port))
 loop.run_forever()

def run(host, port=8090):
 loop = asyncio.get_event_loop()
 serve(loop, host, port)
 print('run ....')
 loop.close()

asyncio.run(run('0.0.0.0'))

其实主要的实现逻辑在这个函数里面


async def handle(reader, writer):

让我明白的是，request其实在整个请求中，我觉得是一个解析器，就是将所有的请求信息，解析出来然后提供给调用函数去调用，那么其实把所有需要的信息都塞给http类就好了，这样的话可以给调用函数提供更多的可用信息。

python http web server 探索（九）

Wed, 30 Jul 2025 11:27:17 +0800

如何封装

关于web server的封装，这点首先我自己是没有想好的

不过能够清楚的知道

Requet部分、Response部分、Header部分应该是可以被先封装下的

Request部分主要用来处理请求过来的信息，至少包括路由、请求参数、请求方法等

Response部分主要是用来处理回应信息，至少要包括回应的文本信息，后面可以对接第三方的库

Header部分也是可以被封装的，至少基本的Header部分中的ContentType等类似的值可以封装下

具体的后面介绍

python http web server 探索（八）

Wed, 30 Jul 2025 11:27:14 +0800

前面的文章已经分析了，路由如何创建。并且知道如何根据请求的数据获取路由参数

今天记录下，如何匹配路由，并根据路由来执行指定的函数方法

看下面代码


import asyncio, logging

url_map = []

def route(url, **kwargs):
 def wrapper(func):
 url_map.append((url, func, kwargs))
 return func

 return wrapper

@route('/hello')
async def hello(reader, writer):
 await start_response(writer, status='200')

 writer.write(b"hello\r\n")

 return 'hello'

@route('/world')
async def world(reader, writer):
 await start_response(writer, status='200')

 writer.write(b"world\r\n")

 return 'world'

async def start_response(writer,
 content_type="text/html; charset=utf-8",
 status="200",
 headers=None):
 writer.write(str.encode(f"HTTP/1.0 {status} NA\r\n"))
 writer.write(b"Content-Type: ")
 writer.write(str.encode(content_type))

 if not headers:
 writer.write(b"\r\n\r\n")
 return

 writer.write(b"\r\n")
 if isinstance(headers, bytes) or isinstance(headers, str):
 await writer.write(str.encode(headers))
 else:
 for k, v in headers.items():
 writer.write(str.encode(k))
 writer.write(b": ")
 writer.write(str.encode(v))
 writer.write(b"\r\n")
 writer.write(b"\r\n")

async def handler(reader, writer):

 # await start_response(writer, status='404')
 await start_response(writer, status='200')

 writer.write(b"hello\r\n")

async def handler_404(reader, writer):
 await start_response(writer, status='404')

async def handle(reader, writer):
 print(f'handle...')

 print(url_map)

 method = ''
 path = ''
 found = False

 try:
 data = await reader.readline()
 method, path, proto = data.split()
 print(data)
 print(method)
 print(path)
 print(proto)

 except Exception as e:
 print(e)

 print('method = ', method)
 print('path = ', path)

 pattern = None
 handler_action = None
 extra = {}

 for url in url_map:
 pattern = url[0]
 handler_action = url[1]

 if len(url) > 2:
 extra = url[2]

 print('pattern = ', str.encode(pattern))
 print('path = ', path)
 if path == str.encode(pattern):
 found = True
 break

 if found:
 await handler_action(reader, writer)
 else:
 await handler_404(reader, writer)

 await writer.drain()
 writer.close()
 await writer.wait_closed()

def serve(loop, host, port):
 loop.create_task(asyncio.start_server(handle, host, port))
 loop.run_forever()

def run(host, port=8090):
 loop = asyncio.get_event_loop()
 serve(loop, host, port)
 print('run ....')
 loop.close()

asyncio.run(run('0.0.0.0'))

运行上面代码，然后分别访问http://127.0.0.1:8090/hello和http://127.0.0.1:8090/world

可以在浏览器中看到，分别输出hello和world

主要的逻辑其实这部分


for url in url_map:
 pattern = url[0]
 handler_action = url[1]

 if len(url) > 2:
 extra = url[2]

 print('pattern = ', str.encode(pattern))
 print('path = ', path)
 if path == str.encode(pattern):
 found = True
 break

if found:
 await handler_action(reader, writer)
else:
 await handler_404(reader, writer)

从目前来看目前小型web server已经成型，后面要进行封装下

python http web server 探索（七）

Wed, 30 Jul 2025 11:27:11 +0800

前面的文章已经理顺了如何获取请求的数据

包括路由路径，request method，和一些参数

接下里要结合下前面的文章中介绍的，装饰器

通过使用装饰器我们来填充下路由创建的空白功能

先看下代码


def route(url, **kwargs):
 def wrapper(func):
 url_map.append((url, func, kwargs))
 return func

 return wrapper

这个是比较基础的，但是能够实现最基础的功能

然后添加两个函数


@route('/hello')
def hello():
 return 'hello'

@route('/world')
def world():
 return 'world'

最后看下整体的代码


import asyncio, logging

url_map = []

def route(url, **kwargs):
 def wrapper(func):
 url_map.append((url, func, kwargs))
 return func

 return wrapper

@route('/hello')
def hello():
 return 'hello'

@route('/world')
def world():
 return 'world'

async def start_response(writer,
 content_type="text/html; charset=utf-8",
 status="200",
 headers=None):
 writer.write(str.encode(f"HTTP/1.0 {status} NA\r\n"))
 writer.write(b"Content-Type: ")
 writer.write(str.encode(content_type))

 if not headers:
 writer.write(b"\r\n\r\n")
 return

 writer.write(b"\r\n")
 if isinstance(headers, bytes) or isinstance(headers, str):
 await writer.write(str.encode(headers))
 else:
 for k, v in headers.items():
 writer.write(str.encode(k))
 writer.write(b": ")
 writer.write(str.encode(v))
 writer.write(b"\r\n")
 writer.write(b"\r\n")

async def handler(reader, writer):

 # await start_response(writer, status='404')
 await start_response(writer, status='200')

 writer.write(b"hello\r\n")

async def handle(reader, writer):
 print(f'handle...')

 print(url_map)

 try:
 data = await reader.readline()
 method, path, proto = data.split()
 print(data)
 print(method)
 print(path)
 print(proto)

 except Exception as e:
 print(e)

 await handler(reader, writer)
 await writer.drain()

 writer.close()
 await writer.wait_closed()

def serve(loop, host, port):
 loop.create_task(asyncio.start_server(handle, host, port))
 loop.run_forever()

def run(host, port=8090):
 loop = asyncio.get_event_loop()
 serve(loop, host, port)
 print('run ....')
 loop.close()

运行下代码


asyncio.run(run('0.0.0.0'))

访问http://127.0.0.1:8090看看输出的结果


[('/hello', <function hello at 0x10f80ea70>, {}), ('/world', <function world at 0x10fd53b90>, {})]

可以看到类似上面的输出，说明这个就装饰器就解决了一个痛点，就是需要自己去维护一个路由列表，这里一个函数就对应的一个路由，非常方便维护，此刻能够理解Flask为什么也适用此方式了，而且也理解了Flask的实现原理的一部分

python http web server 探索（六）

Wed, 30 Jul 2025 11:27:08 +0800

前面很多做了一部分铺垫

今天想着如何解析出路由信息，method信息等

下面看个实现的代码


async def handle(reader, writer):
 print(f'handle...')

 try:
 data = await reader.readline()

 print(data)
 except Exception as e:
 print(e)

 await handler(reader, writer)
 await writer.drain()

 writer.close()
 await writer.wait_closed()

运行之后，输出下data结果如下


b'GET / HTTP/1.1\r\n'

从上面的字符串可以看到是一个字符串，用空格分割的，这样的话我们就能拿到method方法，route路径

修改后的代码如下


async def handle(reader, writer):
 print(f'handle...')

 try:
 data = await reader.readline()
 method, path, proto = data.split()
 print(data)
 print(method)
 print(path)
 print(proto)
 except Exception as e:
 print(e)

 await handler(reader, writer)
 await writer.drain()

 writer.close()
 await writer.wait_closed()

运行后会看到类似如下的输出内容


b'GET / HTTP/1.1\r\n'
b'GET'
b'/'
b'HTTP/1.1'

python http web server 探索（五）

Wed, 30 Jul 2025 11:27:04 +0800

前面的文章我做了一个简单的小例子

从小例子中可以看出，已经能够在server运行起来之后，访问的时候，可以简单的返回内容到浏览器了

接下来要做的就是如何接收请求，然后根据请求来处理不同的逻辑

首先看下如何解析一个GET请求的参数

代码如下


def parse_query_args(s):
 res = {}
 if s:
 pairs = s.split('&')
 for p in pairs:
 vals = [x for x in p.split("=", 1)]
 res[vals[0]] = vals[1]

 return res

代码很简单

比如，如果接收一个参数类似“foo=1&bar=2”

简单写个测试的代码

print(parse_query_args("foo=1&bar=2"))

运行后得到如下输出

{'foo': '1', 'bar': '2'}

这个就是我们想要的结果了，当然这个是一个简单的测试，还有很多应用场景需要测试

python http web server 探索（四）

Wed, 30 Jul 2025 11:27:01 +0800

针对于昨天的简单web server的构造

今天需要实现一个简单的文本输出

既然能够运行起来一个web server，那么距离实现一个简单的文本输出也不远了

代码如下


import asyncio, logging

async def start_response(writer,
 content_type="text/html; charset=utf-8",
 status="200",
 headers=None):
 writer.write(str.encode(f"HTTP/1.0 {status} NA\r\n"))
 writer.write(b"Content-Type: ")
 writer.write(str.encode(content_type))

 if not headers:
 writer.write(b"\r\n\r\n")
 return

 writer.write(b"\r\n")
 if isinstance(headers, bytes) or isinstance(headers, str):
 await writer.write(str.encode(headers))
 else:
 for k, v in headers.items():
 writer.write(str.encode(k))
 writer.write(b": ")
 writer.write(str.encode(v))
 writer.write(b"\r\n")
 writer.write(b"\r\n")

async def handler(reader, writer):
 # await start_response(writer, status='404')
 await start_response(writer, status='200')

 writer.write(b"hello\r\n")

async def handle(reader, writer):
 print(f'handle...')

 await handler(reader, writer)
 await writer.drain()
 await asyncio.sleep(0.001)
 writer.close()

def serve(loop, host, port):
 loop.create_task(asyncio.start_server(handle, host, port))
 loop.run_forever()

def run(host, port=8090):
 loop = asyncio.get_event_loop()
 serve(loop, host, port)
 print('run ....')
 loop.close()

asyncio.run(run('0.0.0.0'))

运行后访问http://127.0.0.1:8090

我们用curl测试下，得到的结果如下

$ curl -v http://127.0.0.1:8090
* Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to 127.0.0.1 (127.0.0.1) port 8090 (#0)
> GET / HTTP/1.1
> Host: 127.0.0.1:8090
> User-Agent: curl/7.64.1
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 NA
< Content-Type: text/html; charset=utf-8
<
hello
* Closing connection 0

一个小的server终于运行起来了，后面会加以完善

python http web server 探索（三）

Wed, 30 Jul 2025 11:26:58 +0800

最近思考如何更进一步了web server

前面有一篇文章解释如何使用http.server创建一个web server，这样的话就会不支持asyncio，或者需要自己再封装一个

经过资料的查询，发现一个start_server的方法


coroutine asyncio.start_server(client_connected_cb, host=None, port=None, *, loop=None, limit=None, family=socket.AF_UNSPEC, flags=socket.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, start_serving=True)

本意是指启动一个socket服务器

下面看下如何简单的使用


import asyncio

async def handle(reader, writer):
 print(f'handle...')
 await asyncio.sleep(1)
 writer.close()

def serve(loop, host, port):
 loop.create_task(asyncio.start_server(handle, host, port))
 loop.run_forever()

def run(host, port=8090):
 loop = asyncio.get_event_loop()
 serve(loop, host, port)
 print('run ....')
 loop.close()

asyncio.run(run('0.0.0.0'))

运行后访问http://127.0.0.1:8090/

在终端会得到如下输出


$ python main.py

handle...
handle...
handle...
handle...
handle...
handle...

可以说能够得到正常的运行了

Python小知识 - 装饰器

Wed, 30 Jul 2025 11:26:55 +0800

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

比如我们有个函数，如下


def do_get():
 """
 docstring
 """
 print('do get')

有个需求，需要给这个函数增加一个日志，记录这个函数的执行日志，于是在代码中添加日志代码如下


def do_get():
 print('do get')
 logging.info('go get logging')

但是如果我们要给类似的函数都加上函数的执行日志，会造成大面积的修改，如果一两个函数还是可以的

但是如果有很多的函数需要添加，就需要大量的工作，这个是不可取的

所以需要一个专门来处理日志的函数


import logging

def do_logging(func):
 logging.warning(f"{func.__name__} is running")
 func()

def do_get():
 print("do get")

do_logging(do_get)

但是这样的话，需要每次将一个函数作为参数传递给do_logging函数，也不是非常理想

于是我想到了装饰器


import logging

def do_logging(func):
 def wrapper(*args, **kwargs):
 logging.warning(f"{func.__name__} is running")
 return func(*args, **kwargs)

 return wrapper

def do_get():
 print('do get')

do_get = do_logging(do_get)

do_get()

这里do_logging就是一个装饰器

'@符号'是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作，使用方式如下


import logging

def do_logging(func):
 def wrapper(*args, **kwargs):
 logging.warning(f"{func.__name__} is running")
 return func(*args, **kwargs)

 return wrapper

@do_logging
def do_get():
 print('do get')

do_get()

使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了


import logging
from functools import wraps

def do_logging(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 logging.warning(f"{func.__name__} is running")
 func(*args, **kwargs)

 return wrapper

@do_logging
def do_get():
 print('do get')

do_get()

python http web server 探索（二）

Wed, 30 Jul 2025 11:25:07 +0800

web server的实现最基础逻辑的几点思考

request：接收请求

response：返回结果

path：如何解决路由的问题

还有BaseHTTPRequestHandler这个最基础的类，我们应该如何解决，为什么很少见到有人使用这个简答的Handler

如果自己做的话，如何做一个Handler

python http web server 探索（一）

Wed, 30 Jul 2025 11:04:07 +0800

最近想着这么多的python web框架

但是也只是处于会用的阶段，如果不懂其中的原理（非理论），即不知道如何实现，似乎有点愧于接触web开发

看个小例子


from http.server import HTTPServer, BaseHTTPRequestHandler

def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
 server_address = ('', 8009)
 httpd = server_class(server_address, handler_class)
 httpd.serve_forever()

run()

运行下，然后访问http://127.0.0.1:8009/，得到如下结果


$ python main.py
127.0.0.1 - - [22/Sep/2020 23:48:53] code 501, message Unsupported method ('GET')
127.0.0.1 - - [22/Sep/2020 23:48:53] "GET / HTTP/1.1" 501 -
127.0.0.1 - - [22/Sep/2020 23:48:54] code 501, message Unsupported method ('GET')
127.0.0.1 - - [22/Sep/2020 23:48:54] "GET /favicon.ico HTTP/1.1" 501 -

似乎有点眉头了，明天继续。

Python asyncio协程 - 简单等待（二）

Wed, 30 Jul 2025 11:04:04 +0800

asyncio协程 - 简单等待（二）

语法如下


asyncio.as_completed(aws, *, loop=None, timeout=None)

官方文档解释

并发地运行 aws 集合中的可等待对象。返回一个协程的迭代器。所返回的每个协程可被等待以从剩余的可等待对象集合中获得最早的下一个结果。

如果在所有 Future 对象完成前发生超时则将引发 asyncio.TimeoutError。

比如下面的示例


for coro in as_completed(aws):
 earliest_result = await coro
 # ...

我们看一个完整的示例


import asyncio
import time

async def delay_timer(delay):
 await asyncio.sleep(delay)
 print(f"delay for {delay} seconds")
 return delay

async def main():
 print(f"start at {time.strftime('%X')}")
 tasks = [delay_timer(i) for i in range(10)]
 for p in asyncio.as_completed(tasks):
 res = await p

 print(f"end at {time.strftime('%X')}")

asyncio.run(main())

运行结果如下


$ python main.py
start at 22:23:48
delay for 0 seconds
delay for 1 seconds
delay for 2 seconds
delay for 3 seconds
delay for 4 seconds
delay for 5 seconds
delay for 6 seconds
delay for 7 seconds
delay for 8 seconds
delay for 9 seconds
end at 22:23:57

Python asyncio协程 - 简单等待（一）

Wed, 30 Jul 2025 11:04:01 +0800

asyncio协程 - 简单等待

语法如下

coroutine asyncio.wait(aws, *, loop=None, timeout=None, return_when=ALL_COMPLETED)¶

官方文档简介如下

并发运行 aws 指定的可等待对象并阻塞线程直到满足 return_when 指定的条件。

返回两个 Task/Future 集合: (done, pending)。

用法如下

done, pending = await asyncio.wait(aws)

如指定 timeout (float 或 int 类型) 则它将被用于控制返回之前等待的最长秒数。

请注意此函数不会引发 asyncio.TimeoutError。当超时发生时，未完成的 Future 或 Task 将在指定秒数后被返回。

return_when 指定此函数应在何时返回。它必须为以下常数之一:

常数	描述
`FIRST_COMPLETED`	函数将在任意可等待对象结束或取消时返回。
`FIRST_EXCEPTION`	函数将在任意可等待对象因引发异常而结束时返回。当没有引发任何异常时它就相当于 `ALL_COMPLETED`。
`ALL_COMPLETED`	函数将在所有可等待对象结束或取消时返回。

与 wait_for() 不同，wait() 在超时发生时不会取消可等待对象。

注意

wait() 会自动将协程作为任务加入日程，以后将以 (done, pending) 集合形式返回显式创建的任务对象。因此以下代码并不会有预期的行为:

import asyncio

async def num():
 return 42

async def main():

 coro = num()
 done, pending = await asyncio.wait({coro})

 if coro in done:
 # 这里将不会运行
 print(coro)

asyncio.run(main())

上面的代码将不会运行

如果将上面的代码修改为下面的代码

import asyncio

async def num():
 return 42

async def main():

 coro = asyncio.create_task(num())
 done, pending = await asyncio.wait({coro})

 if coro in done:
 # 这里将不会运行
 print(coro)

asyncio.run(main())

上面的代码运行结果类似如下

$ python main.py
<Task finished coro=<num() done, defined at main.py:14> result=42>

Python asyncio协程 - 超时

Wed, 30 Jul 2025 11:03:58 +0800

先回忆下之前关于asyncio的学习（基本忘的差不多了）

1、gather（集合，感觉类似于collect的意思），实际上是用来并发运行任务的

2、writable object（可等待对象）

3、Task（任务）

4、sleep（休眠）

好了，上面的几个特性，我觉得是在asyncio中用的比较多的

下面看下超时和屏蔽取消的特性

先看下屏蔽取消

屏蔽取消

这个屏蔽取消主要是针对gather里面的特性，因为在使用gather的时候，会遇到一个情况就是取消并发任务中的某个任务，这个时候就需要用到取消的动作，

既然有取消，就会有屏蔽取消的情况，这个功能果然与矛盾相关

看下如何屏蔽取消，首先是语法

awaitable asyncio.shield(aw, * , loop=None)

然后在使用的时候，像下面这样调用

await asyncio.shield(some_func())

下面看个简单的实例

import asyncio

async def div(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(2)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 task1 = asyncio.shield(div(1, 2))
 task2 = asyncio.create_task(div(2, 3))
 task3 = asyncio.create_task(div(3, 4))
 res = asyncio.gather(task1, task2, task3, return_exceptions=True)

 task1.cancel()
 task2.cancel()
 print(await res)

asyncio.run(main())

运行后得到的结果如下

$ python main.py
1 / 2 = 0.5
3 / 4 = 0.75
[CancelledError(), CancelledError(), 0.75]

超时（Timeouts）

coroutine asyncio.wait_for(aw, timeout, *, loop=None)

超时使用的情况也是比较多的

先看下官方的解释

等待 aw 可等待对象完成，指定 timeout 秒数后超时。

如果 aw 是一个协程，它将自动作为任务加入日程。

timeout 可以为 None，也可以为 float 或 int 型数值表示的等待秒数。如果 timeout 为 None，则等待直到完成。

如果发生超时，任务将取消并引发 asyncio.TimeoutError.

要避免任务取消，可以加上 shield()。

函数将等待直到目标对象确实被取消，所以总等待时间可能超过 timeout 指定的秒数。

如果等待被取消，则 aw 指定的对象也会被取消。

Deprecated since version 3.8, will be removed in version 3.10: loop 形参。

下面看个简单的例子

import asyncio

async def sleep(sleep_time):
 await asyncio.sleep(sleep_time)
 print(f'after {sleep_time} , sleep over')

async def main():

 try:
 await asyncio.wait_for(sleep(3600), 1.0)
 except asyncio.TimeoutError as timeout:
 print('timeout!')

asyncio.run(main())

运行后得到的结果如下

$ python main.py
timeout!

使用方法也比较简单

我能想到的可能的场景

比如，数据库SQL查询的时候

Python 3.9.0rc2现在可以开测了

Wed, 30 Jul 2025 11:03:52 +0800

原文地址点击这里

Python 3.9.0rc2已经可以开始测试了，距离Python 3.9.0发布也不远了，原文提到预计2020-10-05发布

同时，原文中提到强烈推荐第三方的Python项目准备为3.9的兼容性作准备，并且在遇到问题的时候及时向https://bugs.python.org/提交bug

嗯我也去试下，我去试试我项目的兼容性

Python asyncio协程 - gather(5)

Wed, 30 Jul 2025 11:03:49 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第六点的特性

如果 aws 序列中的任一 Task 或 Future 对象被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用不会被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

前面的几篇文章分别记录了gather的五个特性，基本上都在说gather中的方法执行的时候被取消会发生什么异常，这个是最后的一个特性

下面先记录下一个简单的例子来说明问题

import asyncio

async def div(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(1)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 task1 = asyncio.create_task(div(0, 2))
 task2 = asyncio.create_task(div(1, 2))
 task3 = asyncio.create_task(div(3, 4))

 t = asyncio.gather(task1, task2, task3, return_exceptions=True)

 task1.cancel()

 print(await t)

asyncio.run(main())

运行结果如下

$ python main.py
1 / 2 = 0.5
3 / 4 = 0.75
[CancelledError(), 0.5, 0.75]

Python asyncio协程 - gather(4)

Wed, 30 Jul 2025 11:03:39 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第五点的特性

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会被取消。

前面的几篇文章分别记录了gather的四个特性，为了下面的记录能够比较好的理解，请先回顾

下面先记录下一个简单的例子来说明问题


import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(5)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 t = asyncio.gather(fac(0, 2), fac(1, 2), fac(3, 4))
 await asyncio.sleep(1)
 t.cancel()
 await t

asyncio.run(main())

运行后得到的结果如下

$ python main.py
1 / 2 = 0.5
3 / 4 = 0.75
Traceback (most recent call last):
 File "main.py", line 29, in <module>
 asyncio.run(main())
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/runners.py", line 43, in run
 return loop.run_until_complete(main)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/base_events.py", line 579, in run_until_complete
 return future.result()
 File "main.py", line 26, in main
 await t
 File "main.py", line 15, in fac
 raise ZeroDivisionError
ZeroDivisionError

似乎看不出什么效果

我们将gather的代码修改如下，将sleeo的时间增加到5秒

import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 await asyncio.sleep(5)
 print(f"{x} / {y} = {x/y}")
 return x / y

async def main():
 t = asyncio.gather(fac(0, 2), fac(1, 2), fac(3, 4))
 await asyncio.sleep(1)
 t.cancel()
 await t

asyncio.run(main())

运行后得到的结果如下

$ python main.py
Traceback (most recent call last):
 File "main.py", line 30, in <module>
 asyncio.run(main())
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/runners.py", line 43, in run
 return loop.run_until_complete(main)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/base_events.py", line 579, in run_until_complete
 return future.result()
 File "main.py", line 27, in main
 await t
 File "main.py", line 16, in fac
 raise ZeroDivisionError
ZeroDivisionError

从这里可以很清楚的了解这一特性

只要有一个是异常的后面的尚未执行的也会被取消

Python asyncio协程 - gather(3)

Wed, 30 Jul 2025 11:03:35 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第三点的特性

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象不会被取消并将继续运行。

先简单的看个例子

import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 print(f"{x}/{y}={x/y}")
 return x / y

async def main():
 res = await asyncio.gather(fac(1, 2), fac(2, 3), fac(0, 2))

 print(res)

asyncio.run(main())

运行后结果如下

$ python main.py
1/2=0.5
2/3=0.6666666666666666
Traceback (most recent call last):
 File "main.py", line 28, in <module>
 asyncio.run(main())
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/runners.py", line 43, in run
 return loop.run_until_complete(main)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/asyncio/base_events.py", line 579, in run_until_complete
 return future.result()
 File "main.py", line 23, in main
 res = await asyncio.gather(fac(1, 2), fac(2, 3), fac(0, 2))
 File "main.py", line 16, in fac
 raise ZeroDivisionError
ZeroDivisionError

如果我们将return_exceptions换个参数加上再试下

代码如下

import asyncio

async def fac(x, y):
 if x == 0:
 raise ZeroDivisionError
 else:
 print(f"{x}/{y}={x/y}")
 return x / y

async def main():
 res = await asyncio.gather(fac(1, 2),
 fac(2, 3),
 fac(0, 2),
 return_exceptions=True)

 print(res)

asyncio.run(main())

运行后结果如下

$ python main.py
1/2=0.5
2/3=0.6666666666666666
[0.5, 0.6666666666666666, ZeroDivisionError()]

上面的代码例子就是要说的第四点特性

如果 return_exceptions 为 True，异常会和成功的结果一样处理，并聚合至结果列表。

Python asyncio协程 - gather(2)

Wed, 30 Jul 2025 11:03:32 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第二点的特性

如果所有可等待对象都成功完成，结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。

我们看一个例子理解下

import asyncio

async def fac(name, num):
 total = 1
 for i in range(2, num + 1):
 await asyncio.sleep(1)
 total *= i

 return total

async def main():
 gather_res = await asyncio.gather(fac('xiao wang', 2), fac('xiao li', 3),
 fac('xiao zhang', 4))

 print(gather_res)

asyncio.run(main())

ok，运行后得出的结果如下

$ python main.py
[2, 6, 24]

从输出的结果中可以看出，这个是一个列表，而且是一个有序的列表，正好跟我们传值的顺序一致

下面换个调用顺序测试下

代码如下

import asyncio

async def fac(name, num):
 total = 1
 for i in range(2, num + 1):
 await asyncio.sleep(1)
 total *= i

 return total

async def main():
 gather_res = await asyncio.gather(fac('xiao wang', 4), fac('xiao li', 3),
 fac('xiao zhang', 2))

 print(gather_res)

asyncio.run(main())

运行后的结果如下

$ python main.py
[24, 6, 2]

Python asyncio协程 - gather(1)

Wed, 30 Jul 2025 11:03:28 +0800

在Python 3的协程中，官方针对gather的使用有几个特性的说明，先说第一点的特性

并发执行aws参数指定的可等待（awaitable）对象序列。

如果 aws 中的某个可等待对象为协程，它将自动作为一个任务加入日程。

可以理解为如果 aws 序列中的某个 awaitable 对象是一个协程,则自动将这个协程封装为 Task对象进行处理

看下面的代码

import asyncio

async def fac(name, number):
 num = 1

 for i in range(2, number + 1):
 print(f"Task {name}: Compute fac({i})")
 await asyncio.sleep(1)
 num *= i

 print(f"Task {name}: fac({number}) = {num}")

async def main():
 await asyncio.gather(fac("xiao wang", 2), fac("xiao li", 3),
 fac("xiao zhang", 4))

asyncio.run(main())

运行下看下结果

$ python main.py
Task xiao wang: Compute fac(2)
Task xiao li: Compute fac(2)
Task xiao zhang: Compute fac(2)
Task xiao wang: fac(2) = 2
Task xiao li: Compute fac(3)
Task xiao zhang: Compute fac(3)
Task xiao li: fac(3) = 6
Task xiao zhang: Compute fac(4)
Task xiao zhang: fac(4) = 24

再来对比下下面的代码

import asyncio

async def fac(name, number):
 num = 1

 for i in range(2, number + 1):
 print(f"Task {name}: Compute fac({i})")
 await asyncio.sleep(1)
 num *= i

 print(f"Task {name}: fac({number}) = {num}")

async def main():
 task1 = asyncio.create_task(fac("xiao wang", 2))
 task2 = asyncio.create_task(fac("xiao li", 3))
 task3 = asyncio.create_task(fac("xiao zhang", 4))

 await asyncio.gather(task1, task2, task3)

asyncio.run(main())

运行看下效果

$ python main.py
Task xiao wang: Compute fac(2)
Task xiao li: Compute fac(2)
Task xiao zhang: Compute fac(2)
Task xiao wang: fac(2) = 2
Task xiao li: Compute fac(3)
Task xiao zhang: Compute fac(3)
Task xiao li: fac(3) = 6
Task xiao zhang: Compute fac(4)
Task xiao zhang: fac(4) = 24

这样应该可以理解为自动封装为一个task对象来处理了。

Python小技巧 - List不带索引可以做哪些有趣的事情

Wed, 30 Jul 2025 11:03:22 +0800

List不带索引可以做很多有趣的事情，比如下面的代码

清空List列表

list_1 = [1, 2, 3, 4]
a = list_1
del list_1[:]
print(list_1)
print(a)

运行后输出结果如下

$ python main.py
[]
[]

替换所有元素

list_1 = [1, 2, 3, 4]
a = list_1
list_1[:] = ['a', 'b', 'c']
print(list_1)
print(a)
print(a is list_1)

运行后输出结果如下

$ python main.py
['a', 'b', 'c']
['a', 'b', 'c']
True

List复制

list_1 = [1, 2, 3, 4]
a = list_1[:]
print(list_1)
print(a)
print(a is list_1)

运行后输出结果如下

$ python main.py
[1, 2, 3, 4]
[1, 2, 3, 4]
False

Python小技巧 - f-strings格式化字符串

Wed, 30 Jul 2025 11:03:18 +0800

Python 3.8 中 f-strings 添加了一个"="，让f-strings使用起来更加方便

比如下面的代码


from datetime import date

user = 'durban'
member_since = date(1988, 1, 2)
print(f'{user=} {member_since=}')

运行后输出结果如下


user='durban' member_since=datetime.date(1988, 1, 2)

再比如下面的代码实例


from datetime import date

user = 'durban'
member_since = date(1988, 1, 2)

delta = date.today() - member_since

print(f'{user=!s} {delta.days=:,d}')

运行后输出结果如下


user=durban delta.days=11,937

再比如下面的代码实例


from math import cos, radians

theta = 45
print(f'{theta=} {cos(radians(theta))=:.3f}')

运行后结果如下

theta=45 cos(radians(theta))=0.707

Python小技巧 - Python 类型注释

Wed, 30 Jul 2025 11:03:08 +0800

Python 类型注释

Python 3.5+ 开始支持类型注释，以后也可以写一些静态类型的代码了

具体如何使用，看下面的代码


def add(x: int, y: int) -> int:
 return x + y

def sub(x: int, y: int) -> int:
 return x - y

def multi(x: int, y: int) -> int:
 return x * y

def div(x: int, y: int) -> int:
 return x / y

def splice(x: str, y: str) -> str:
 return x + ' ' + y

调用上面的函数试试


print(add(1, 2))
print(sub(4, 3))
print(multi(2, 3))
print(div(10, 5))
print(splice('hello', 'world'))
print(add('1', '2'))

运行后得到的结果如下


$ python main.py
3
1
6
2.0
hello world
12

从上面的结果可以看出，虽然在代码编写的时候是可以加类型注释的，但是在运行的时候并没有提示异常的错误信息

关于这个问题我找到了答案可以点击这里进行详细了解

另外推荐一个mypy

Python小技巧 - Python内置 HTTP server

Wed, 30 Jul 2025 10:41:26 +0800

Python有个非常好用的功能，Python内置 HTTP server，对于预览网站非常有用，尤其是静态网站开发的时候

Python 3 以上版本使用方法如下


$ python3 -m http.server

类型如下的输出代表运行正常


Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Python 2 版本使用方法如下


$ python -m SimpleHTTPServer 8000

类型如下的输出代表运行正常


Serving HTTP on 0.0.0.0 port 8000 ...

访问以上地址，打开的就是当前目录下的文件

Python小技巧 - first-class 功能

Wed, 30 Jul 2025 10:41:22 +0800

由于Python具有 fisrt-class 的功能，因此它们可用于模拟switch / case语句

先看下一个if逻辑判断函数

代码如下


def if_func(operator, x, y):
 if operator == 'add':
 return x + y
 elif operator == 'sub':
 return x - y
 elif operator == 'mul':
 return x * y
 elif operator == 'div':
 return x / y
 else:
 return None

上面代码我们能很清晰的看清楚这个函数的具体功能

然后我们参考上面的代码逻辑新写一个


def dict_func(operator, x, y):
 return {
 'add': lambda: x + y,
 'sub': lambda: x - y,
 'mul': lambda: x * y,
 'div': lambda: x / y
 }.get(operator, lambda: None)()

下面我们测试下两个函数的结果


print(if_func('add', 1, 2))
print(dict_func('add', 1, 2))
print(if_func('mul', 3, 4))
print(dict_func('mul', 3, 4))

执行结果如下

Python小技巧 - timeit计算代码片段的耗时

Wed, 30 Jul 2025 10:41:19 +0800

timeit提供了一种简单的方法来计算一小段 Python 代码的耗时

比如下面的代码段


import timeit

print(timeit.timeit('"_".join(str(n) for n in range(1000))', number=10000))

执行结果如下


5.119179364

或者


3.155041132

但是每次执行的时间都不太一样

再比如下面的代码片段


import timeit

print(timeit.timeit('"_".join([str(n) for n in range(100)])', number=10000))

执行结果如下


0.370741945

或者


0.395660464

再比如下面的代码片段


import timeit

print(timeit.timeit('"_".join(map(str, range(100)))', number=10000))

执行结果如下


0.370741945

或者


0.395660464

Python小技巧 - pip源管理

Wed, 30 Jul 2025 10:41:04 +0800

列出pip配置信息，命令如下


pip config list

正常情况下，pip的配置文件是放在下面这个文件中的(我的是mac)


~/.config/pip/pip.conf

但是一般去配置它，也不会自动生成，我的就是，当然也不需要你自己去创建，多麻烦

我们只要自己添加一个配置项就好了

在国内，安装pip源码的时候，最麻烦的就是要千里迢迢的去国外拉资源，这样很不方便，必将有铜墙铁壁，有时候不方便

pip国内的一些镜像推荐几个如下

阿里云 http://mirrors.aliyun.com/pypi/simple/

中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/

豆瓣(douban) http://pypi.douban.com/simple/

清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/

中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/

若担心安全问题请使用HTTPS加密源

我们以豆瓣的pip源为例子


pip config set global.index-url http://pypi.douban.com/simple/
pip config set global.trusted-host pypi.douban.com # 信任pypi.douban.com这个域名下面源，主要是解决不支持https的如果你配置了https源的话，不需要这个配置项也是可以的

下次再次执行pip源安装的时候就会从http://pypi.douban.com/simple/下面拉取源代码了，如下


pip install --upgrade pip
Looking in indexes: http://pypi.douban.com/simple/
Collecting pip
 Downloading http://pypi.doubanio.com/packages/54/0c/d01aa759fdc501a58f431eb594a17495f15b88da142ce14b5845662c13f3/pip-20.0.2-py2.py3-none-any.whl (1.4MB)
 |████████████████████████████████| 1.4MB 2.3MB/s
Installing collected packages: pip
 Found existing installation: pip 19.3.1
 Uninstalling pip-19.3.1:
 Successfully uninstalled pip-19.3.1
Successfully installed pip-20.0.2

Python小知识 - “is” 与 “==” 的区别

Wed, 30 Jul 2025 10:41:00 +0800

Python中 “is” 与 “==” 有什么区别

示例如下


a = ['a', 'b', 'c']
b = a

print(a is b)
print(a == b)

运行结果如下


True
True

“is”与“==”结果是一致的

在看下面的示例


a = ['a', 'b', 'c']
c = list(a)
print(a is c)
print(a == c)

运行结果如下


False
True

“is”与“==”结果是不一致的

“is” 如果两个变量指向同一个对象，则表达式的计算结果为True

“==” 如果变量引用的对象相等，则求值为True

Python小知识 - Python中的函数的几个特点

Wed, 30 Jul 2025 10:40:57 +0800

Python中的函数可以作为一个参数传递给另外一个函数，同时可以作为另外一个函数的返回值，同时可以复制给一个变量并且存储里面的数据结构

比如下面的代码示例


def my_func(x, y):
 return x + y

funcs = [my_func]
print(funcs[0])
print(funcs[0](1, 2))

运行后得到的结果如下


$ python main.py
<function my_func at 0x10d46bc20>
3

Python小技巧 - 函数参数解压

Wed, 30 Jul 2025 10:40:54 +0800

函数参数解压

一个非常方便传递参数的功能

看下实例代码


def my_func(a, b, c):
 print(a)
 print(b)
 print(c)
 print(a, b, c)

tuple_value = (1, 2, 3)
dict_value = {'a': 1, 'b': 2, 'c': 3}

my_func(*tuple_value)
my_func(*dict_value)
my_func(**dict_value)

运行后结果如下

当我们使用字典参数的时候，需要注意的是，字典中必须包含对应的参数key，而且键值个数必须跟参数相对应，键值的前后顺序可以不同

看下面错误的例子


def my_func(a, b, c):
 print(a)
 print(b)
 print(c)
 print(a, b, c)

dict_wrong_1_value = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict_wrong_2_value = {'a': 1, 'b': 2, 'd': 4}

my_func(**dict_wrong_1_value)
my_func(**dict_wrong_2_value)

运行后会得到如下的错误


Traceback (most recent call last):
 File "main.py", line 24, in <module>
 my_func(**dict_wrong_1_value)
TypeError: my_func() got an unexpected keyword argument 'd'

flask使用sqlalchemy实现一个group by并且order by的查询

Wed, 30 Jul 2025 10:40:51 +0800

比如我要将我的Tags表的title，按照使用次数最多的并进行降序排列，而且获取前20条Tag
如果是sql查询的话，如果下


select count(*) as total, title 
from tags 
where title <> '' 
group by title 
order by total DESC 
limit 0, 20;

用sqlalchemy的使用方式如下


from sqlalchemy import func

Tag.query.with_entities(
 Tag.title, func.count(Tag.title).label('total')
).filter(Tag.title != '')\
 .group_by(Tag.title)\
 .order_by('total DESC')\
 .limit(20)\
 .all()

但是上面的使用方式在执行的时候会报如下错误


SAWarning: Can't resolve label reference 'total DESC'; converting to text() (this warning may be suppressed after 10 occurrences)
 util.ellipses_string(element.element))

解决方案的代码如下


from sqlalchemy import func, desc

order_by_total = func.count(Tag.title).label('total')

Tag.query.with_entities(
 Tag.title, func.count(Tag.title).label('total')
).filter(Tag.title != '')\
 .group_by(Tag.title)\
 .order_by(desc(order_by_total))\
 .limit(20)\
 .all()

使用方式还是挺奇怪的

Python小知识 - asyncio之sleep和gather

Wed, 30 Jul 2025 10:40:48 +0800

asyncio 之 Sleep 阻塞休眠

coroutine asyncio.sleep(delay, result=None, *, loop=None)

阻塞指定的描述

如果指定了 result，则当协程完成时将其返回给调用者。

sleep() 总是会挂起当前任务，以允许其他任务运行。

Deprecated since version 3.8, will be removed in version 3.10: loop 形参。

以下协程示例运行 5 秒，每秒显示一次当前日期:


import asyncio
import datetime

async def display_date():
 loop = asyncio.get_running_loop()
 end_time = loop.time() + 5.0
 while True:
 print(datetime.datetime.now())
 if (loop.time() + 1.0) >= end_time:
 break

 await asyncio.sleep(1)

asyncio.run(display_date())

运行结果类似如下


$ python main.py
2020-08-13 22:26:19.414429
2020-08-13 22:26:20.417651
2020-08-13 22:26:21.418705
2020-08-13 22:26:22.420557
2020-08-13 22:26:23.421803

asyncio 之 Gather 并发运行任务

awaitable asyncio.gather(*aws, loop=None, return_exceptions=False)¶

并发运行 aws 序列中的可等待对象。

如果 aws 中的某个可等待对象为协程，它将自动作为一个任务加入日程。

如果所有可等待对象都成功完成，结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象不会被取消并将继续运行。

如果 return_exceptions 为 True，异常会和成功的结果一样处理，并聚合至结果列表。

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会被取消。

如果 aws 序列中的任一 Task 或 Future 对象被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用不会被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

Deprecated since version 3.8, will be removed in version 3.10: loop 形参。

简单应用实例


import asyncio

async def factorial(name, number):
 f = 1
 for i in range(2, number + 1):
 print(f"Task {name}: Compure factorial({i})")
 await asyncio.sleep(1)
 f *= i
 print(f"Task {name}: factorial({number}) = {f}")

async def main():
 await asyncio.gather(factorial("X", 2), factorial("Y", 3),
 factorial("Z", 4))

asyncio.run(main())

运行结果类似如下


$ python main.py
Task X: Compure factorial(2)
Task Y: Compure factorial(2)
Task Z: Compure factorial(2)
Task X: factorial(2) = 2
Task Y: Compure factorial(3)
Task Z: Compure factorial(3)
Task Y: factorial(3) = 6
Task Z: Compure factorial(4)
Task Z: factorial(4) = 24

Python 3 小知识 - asyncio writable

Wed, 30 Jul 2025 10:40:45 +0800

在asyncio 中什么是 writable

在asyncio 中 writable 一般指的是 writable object

如果一个对象在await语句中使用，那么TA就是 writable object ，叫做可等待对象

在许多 asyncio API中，许多都被设计为 writable object

writable object 分为三种主要类型：Coroutines、Tasks和Futures

Coroutines

Coroutines 属于 writable object，因此可以在其他Coroutines中被等待:

比如如下代码


import asyncio

async def num():
 return 50

async def main():
 print(num())

 print(await num())

asyncio.run(main())

执行后的结果如下


$ python main.py
main.py:29: RuntimeWarning: coroutine 'num' was never awaited
 num()
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
50

Tasks

Tasks 被用来设置日程以便并发执行Coroutines

当一个Coroutines通过 asyncio.create_task() 等函数被打包为一个任务，该Coroutines将自动排入日程准备立即运行:

下面看如下实例代码


import asyncio

async def num():
 return 50

async def main():

 task = asyncio.create_task(num())

 print(await task)

asyncio.run(main())

执行后的结果如下


$ python main.py
50

Futures

Future 是一种特殊的低层级可等待对象，表示一个异步操作的最终结果。

当一个 Future 对象被等待，这意味着协程将保持等待直到该 Future 对象在其他地方操作完毕。

在 asyncio 中需要 Future 对象以便允许通过 async/await 使用基于回调的代码。

通常情况下没有必要在应用层级的代码中创建 Future 对象。

Future 对象有时会由库和某些 asyncio API 暴露给用户，用作可等待对象:

Python小技巧 - 如何让字典参数值输出更加易读

Wed, 30 Jul 2025 10:40:39 +0800

标准的字典字符串的输出是比较难易读的，这个说的是什么意思

下面看个代码例子


mapping_1 = {'a': 23, 'b': 42, 'c': 0xc0ffee}
print(mapping_1)

执行后代码输出结果如下


{'a': 23, 'b': 42, 'c': 12648430}

但是我们换个输出方式，会让字段输出比较人性化

“ json”模块可以做的更好：

看下面这个代码例子


import json

mapping_1 = {'a': 23, 'b': 42, 'c': 0xc0ffee}

print(json.dumps(mapping_1, indent=4, sort_keys=True))

运行后输出结果如下


$ python main.py
{
 "a": 23,
 "b": 42,
 "c": 12648430
}

是不是这个方式的输出更加友好一些

Python小技巧 - Fabric并发执行远程主机操作

Wed, 30 Jul 2025 10:40:36 +0800

fabric中如何实现并发执行远程主机任务

比如我有多台远程主机，想要通过并行的方式在没太主机上执行同样的命令

如果按照fabric提供的ThreadingGroup的话，可能会遇到一个问题就是，每个主机在执行命令的时候，遇到问题，比如链接失败的话可能会导致所有的链接都失败，再比如我要判断每台机器的部署项目的目录是否存在，这个时候的话，每个远程主机执行的时候需要执行不同的逻辑，我采用另外一个方式，就是multiprocessing的方式

首先看下multiprocessing的并发如何实现

第一种是Process

实现方式如下


from multiprocessing import Pool, Process
import time

def host_run(host):
 print('执行 %s' % host)
 time.sleep(10)
 print('结束 %s' % host)

hosts = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

# Process方式创建进程
print('创建Process')
for h in hosts:
 p = Process(target=host_run, args=(h + ' - process', ))
 p.start()
print('Process执行结束')

运行结果如下


创建Process
执行 1 - process
执行 2 - process
执行 3 - process
执行 4 - process
执行 5 - process
执行 6 - process
执行 7 - process
执行 8 - process
Process执行结束
执行 9 - process
执行 10 - process
结束 1 - process
结束 2 - process
结束 3 - process
结束 4 - process
结束 5 - process
结束 6 - process
结束 7 - process
结束 8 - process
结束 9 - process
结束 10 - process

第二种是Pool

实现方式如下


from multiprocessing import Pool, Process
import time

def host_run(host):
 print('执行 %s' % host)
 time.sleep(10)
 print('结束 %s' % host)

hosts = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

# Pool方式创建大量子进程
print('创建Pool')
pool = Pool(len(hosts))
for h in hosts:
 pool.apply_async(host_run, args=(h + 'pool', ))
print('等待Pool执行')
pool.close()
pool.join()

运行结果如下


创建Pool
等待Pool执行
执行 1 - pool
执行 2 - pool
执行 3 - pool
执行 4 - pool
执行 5 - pool
执行 6 - pool
执行 7 - pool
执行 8 - pool
执行 9 - pool
执行 10 - pool
结束 2 - pool
结束 3 - pool
结束 1 - pool
结束 4 - pool
结束 5 - pool
结束 6 - pool
结束 7 - pool
结束 8 - pool
结束 9 - pool
结束 10 - pool

到这里，两种方式我们都实现了并发的方式执行代码逻辑

下面回到主体，整合到fabric中，要如何实现

实现代码如下


import socket, paramiko.ssh_exception
from fabric import SerialGroup, exceptions, runners, Connection
from fabric import task
from fabric.exceptions import GroupException
from multiprocessing import Process

hosts = ['localhost', 'localhost', 'localhost', 'localhost']

def host_run(host):
 c = Connection(host)
 res = c.run('ls -ahl')
 print(res)

@task
def asyncrun(c):
 for h in hosts:
 p = Process(target=host_run, args=(h, ))
 p.start()

运行结果如下


$ fab asyncrun
Process Process-1:
Traceback (most recent call last):
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 self.run()
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 res = c.run('ls -ahl')
 File "<decorator-gen-3>", line 2, in run
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
Process Process-3:
Process Process-4:
Process Process-2:
Traceback (most recent call last):
Traceback (most recent call last):
Traceback (most recent call last):
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 267, in _bootstrap
 self.run()
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self.run()
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 res = c.run('ls -ahl')
 File "<decorator-gen-3>", line 2, in run
 self.run()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 File "/usr/local/Cellar/python@2/2.7.16/Frameworks/Python.framework/Versions/2.7/lib/python2.7/multiprocessing/process.py", line 114, in run
 self._target(*self._args, **self._kwargs)
 File "/Users/durban/python/practise/fabfile.py", line 34, in host_run
 res = c.run('ls -ahl')
 res = c.run('ls -ahl')
 File "<decorator-gen-3>", line 2, in run
 File "<decorator-gen-3>", line 2, in run
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 29, in opens
 raise NoValidConnectionsError(errors)
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
 self.open()
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/fabric/connection.py", line 634, in open
 self.client.connect(**kwargs)
 File "/Users/durban/python/.env_2.7.16/lib/python2.7/site-packages/paramiko/client.py", line 368, in connect
 raise NoValidConnectionsError(errors)
 raise NoValidConnectionsError(errors)
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1
 raise NoValidConnectionsError(errors)
NoValidConnectionsError: [Errno None] Unable to connect to port 22 on 127.0.0.1 or ::1

我这里是报了错误，但是从错误信息可以看出，每个host都并发的执行了，不然错误应该不会交叉输出的

后面会记录一个完整版的fabric，能过链接正式生产环境的脚本实践实例。

Python小知识 - import this

Wed, 30 Jul 2025 10:40:33 +0800

最近发现一个很神奇的import使用方法


import this

导入this之后会自动输出如下内容


The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

具体的原因可以查看这里

Python小技巧 - 字典中如何使用get()方法

Wed, 30 Jul 2025 10:40:29 +0800

字典类型在很多编程语言中都是常用的类型

js中


let dict_obj = {
 a: 1,
};

如何获取其中的键值


console.log(dict_obj["a"] || "");
console.log(dict_obj["b"] || "no value");

执行后得到结果如下


1
no value

那么在python中如何实现类似功能

先创建一个字典


name_for_age = {30: "xiaowang", 28: "xiaoli", 32: "xiaozhang"}

def get_age(age):
 return "%d is %s" % (age, name_for_age.get(age, 'no person'))

print(get_age(30))
print(get_age(32))
print(get_age(18))

执行后结果如下


30 is xiaowang
32 is xiaozhang
18 is no person

这里用到了get()方法，一个非常方便的取值器

Python小知识 - asyncio使用记录（1）

Wed, 30 Jul 2025 10:40:26 +0800

asyncio是什么，如何使用

官方介绍如下，熟读

asyncio is a library to write concurrent code using the async/await syntax.

asyncio is used as a foundation for multiple Python asynchronous frameworks that provide high-performance network and web-servers, database connection libraries, distributed task queues, etc.

asyncio is often a perfect fit for IO-bound and high-level structured network code.

asyncio provides a set of high-level APIs to:

run Python coroutines concurrently and have full control over their execution;

perform network IO and IPC;

control subprocesses;

distribute tasks via queues;

synchronize concurrent code;

Additionally, there are low-level APIs for library and framework developers to:

create and manage event loops, which provide asynchronous APIs for networking, running subprocesses, handling OS signals, etc;

implement efficient protocols using transports;

bridge callback-based libraries and code with async/await syntax.

简单的看下如何使用，建议使用 Python 3.7+


import asyncio

async def main():
 print("Print ..... 1")
 await asyncio.sleep(10)
 print("Print ..... 2")

asyncio.run(main())

运行下之后，可以发现，“Print ….. 1”输出之后要过10秒才会输出“Print ….. 2”

这个不是并发的吗，为什么，用起来却不是并发的

其实上面的代码只是展示了如何用asyncio的async/await语法

看下如何实现并发的操作

实现之前先看下我么要做的功能


import time
import asyncio

async def start_run(delay, name):
 await asyncio.sleep(delay)
 print('%s start run' % name)

async def main():
 print(f"started at {time.strftime('%X')}")

 await start_run(2, 'dog')
 await start_run(3, 'cat')

 print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

运行后输出结果如下


started at 20:15:09
dog start run
cat start run
finished at 20:15:14

这里我们知道要如何运行了，下面我们来实现下如何并发


import time
import asyncio

async def start_run(delay, name):
 await asyncio.sleep(delay)
 print('%s start run' % name)

async def main():
 dog_run = asyncio.create_task(start_run(2, 'dog'))
 cat_run = asyncio.create_task(start_run(3, 'cat'))

 print(f"started at {time.strftime('%X')}")

 await dog_run
 await cat_run

 print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

运行后输出结果如下


started at 20:19:18
dog start run
cat start run
finished at 20:19:23

提示：暂时别像下面这样操作


import time
import asyncio

async def start_run(delay, name):
 await asyncio.sleep(delay)
 print('%s start run' % name)

async def main():
 print(f"started at {time.strftime('%X')}")

 await asyncio.create_task(start_run(2, 'dog'))
 await asyncio.create_task(start_run(3, 'cat'))

 print(f"finished at {time.strftime('%X')}")

asyncio.run(main())

我实验了下，不会有效果，待查

Python小知识 - 什么是Namedtuples，如何使用Namedtuples

Wed, 30 Jul 2025 10:40:24 +0800

什么是Namedtuples，如何使用Namedtuples

Namedtuples是一个轻量的并且很容易创建的对象类型

Namedtuples的实例可以像对象实例一样使用

Namedtuples跟struct很像

Namedtuples是不可变的

Namedtuples类型被添加在Python 2.6 和 Python 3.0

下面看个例子


from math import sqrt

p1 = (1, 2)
p2 = (2, 3)

line_length = sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)

print(line_length)

如果使用Namedtuples，上面代码的可读性将会稍微有些改善

下面看代码


from math import sqrt
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

p1 = Point(1, 2)
p2 = Point(2, 3)

line_length = sqrt((p1.x - p2.x)**2 + (p1.y - p2.y)**2)

print(line_length)

Namedtuples也兼容了第一个例子中的使用方式，代码如下


from math import sqrt
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

p1 = Point(1, 2)
p2 = Point(2, 3)

line_length = sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)

print(line_length)

Point = namedtuple('Point', ['x', 'y'])

这段代码也可以用下面的方式来声明

Point = namedtuple('Point', ('x y'))

用个例子来说明下


from math import sqrt
from collections import namedtuple

Point = namedtuple('Point', ('x y'))

p1 = Point(1, 2)
p2 = Point(2, 3)

line_length = sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)

print(line_length)

再来看下，Namedtuples是如何不可变的

示例如下


from collections import namedtuple

Point = namedtuple('Point', ('x y'))

p = Point(1, 2)

p.x = 3

运行结果报错如下


Traceback (most recent call last):
 File "main.py", line 95, in <module>
 p.x = 3
AttributeError: can't set attribute

参考文章：地址

Python小技巧 - 如何整合两个字典

Wed, 30 Jul 2025 10:40:20 +0800

在Python 3.5+中如何合并两个字典

举个例子


a_dict = {'x': 1, 'y': 2, 'z': 3}
b_dict = {'m': 1, 'p': 2, 'q': 3}
c_dict = {**a_dict, **b_dict}
print(c_dict)

输出的结果如下


{'x': 1, 'y': 2, 'z': 3, 'm': 1, 'p': 2, 'q': 3}

在Python2版本中可以使用如下的方式

举个例子


a_dict = {'x': 1, 'y': 2, 'z': 3}
b_dict = {'m': 1, 'p': 2, 'q': 3}
c_dict = dict(**a_dict, **b_dict)
print(c_dict)

输出的结果如下


{'x': 1, 'y': 2, 'z': 3, 'm': 1, 'p': 2, 'q': 3}

在这些示例中，Python合并字典键按照表达式中列出的顺序，覆盖从左到右重复。

在Python3.5+中

举个例子


a_dict = {'x': 1, 'y': 2, 'z': 3}
b_dict = {'z': 1, 'p': 2, 'q': 3}
c_dict = dict(**a_dict, **b_dict)
print(c_dict)

输出的结果如下


{'x': 1, 'y': 2, 'z': 1, 'p': 2, 'q': 3}

什么是迭代器，什么是生成器（generator）

Wed, 30 Jul 2025 10:40:18 +0800

迭代器

迭代器是Python中最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历位置的对象。

迭代器对象从集合的第一个元素开始访问，知道所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter()和next()

字符串、列表或元祖对象都可用于创建迭代器

举个例子


list = ['a', 'b', 'c']
list_iter = iter(list) # 创建迭代器
print(next(list_iter))
print(next(list_iter))
print(next(list_iter))

迭代器可以使用常规的for语句进行遍历

举个例子


list = ['a', 'b', 'c']
list_iter = iter(list) # 创建迭代器
for i in list_iter:
 print(i)

如何创建迭代器

举个例子


import sys

class IncrementNumber(object):
 def __iter__(self):
 self.num = 1
 return self

 def __next__(self):
 num = self.num
 self.num += 1
 return num

num = IncrementNumber()
num_iter = iter(num)
for n in num:
 if n > 100:
 sys.exit()
 else:
 print(n)

把一个类作为一个迭代器使用，需要在类中实现两个方法__iter__()和__next__()

__iter__()方法返回一个特殊的迭代器对象，这个迭代器对象实现了__next__方法并通过StopIteration异常标识迭代的完成

__next__()方法会返回下一个迭代器对象

StopInteration异常用于标识迭代的完成，防止出现无限循环的情况，

在__next__()方法中我们可以设置在完成指定循环次数后触发StopIntertion异常来结束迭代

举个例子


import sys

class IncrementNumber(object):
 def __iter__(self):
 self.num = 1
 return self

 def __next__(self):
 if self.num > 50:
 raise StopIteration

 num = self.num
 self.num += 1
 return num

num = IncrementNumber()
num_iter = iter(num)
for n in num:
 if n > 100:
 sys.exit()
 else:
 print(n)

生成器

生成器是一个返回迭代器的函数

在调用生成器运行的过程中，每次遇到yield的时候函数会暂停继续执行并保存当前所有的运行信息，返回yield的值，

并在下一次执行next()的时候从当前位置继续运行

调用一个生成器函数，返回的是一个迭代器对象


import sys

# 生成器函数
def getNum():
 yield 1
 yield 2
 yield 3

# num 是一个迭代器，由生成器返回生成
num = getNum()

while True:
 try:
 print(next(num))
 except StopIteration:
 sys.exit()

Fabric 并发方式执行项目部署命令

Wed, 30 Jul 2025 10:40:13 +0800

最近做运维工作，遇到项目部署的问题，不过通过python库fabric也是可以解决问题的

而且还是很方便，大概的方式如下

强调下，这里使用的是fabric 2这个版本

原理也是简单就是，fabric提供了ThreadingGroup这个类，网上很少有人用吧，google很久才找到

先看下以前的并行的方式，是如何执行项目部署命令的

代码如下


import getpass
from fabric import Connection, task
from invoke import Responder

hosts = [
 # service online machine
 '127.0.0.1', # web1
 '127.0.0.2', # web2
 '127.0.0.3', # web3
]

user = input('Input username:')
auth_pass = getpass.getpass('Input password:')
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy_series(c):
 for host in hosts:
 conn = Connection('%s@%s' % (user, host),
 connect_kwargs={'password': auth_pass})
 command = 'ls -al /'
 res = conn.run(command, pty=True, watchers=[sudo_pass])
 print(res)

示例代码简单的执行了ls -al /命令

上面的方式就是一台跟着一台机器的进行命令的执行，总的时间是没台机器执行完的时间总和，着实有点慢，影响代码上线的效率

下面看下并行的方式，并发的方式是如何运行的

代码如下


import getpass
from fabric import Connection, task
from invoke import Responder
from fabric import SerialGroup, ThreadingGroup
from fabric.exceptions import GroupException

hosts = [
 # service online machine
 '127.0.0.1', # web1
 '127.0.0.2', # web2
 '127.0.0.3', # web3
]

user = input('Input username:')
auth_pass = getpass.getpass('Input password:')
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy_parallel(c):
 g = ThreadingGroup(*hosts,
 user=user,
 connect_kwargs={'password': auth_pass})
 try:
 command = 'ls -al /'
 res = g.run(command, pty=True, watchers=[sudo_pass])
 print(res)
 except GroupException as e:
 for c, r in e.result.items():
 print(c)
 print(r)

同样的也只是执行命令而已

但是执行的顺序是并发的方式，总的执行时间是执行时间最长的那台机器的时间，很大程度提高了上线代码的执行效率。

Python小技巧 - 如何根据字典中的值来排序字典

Wed, 30 Jul 2025 10:39:40 +0800

很多情况下，我们需要的数据是按照一定顺序的，通常情况下顺序都是按照键或者是键值来排序

按照字典的值来排序的话，记录集中方式供参考

举个例子

原始字典值为


dict1 = {'x1': 4, 'x2': 5, 'x3': 6, 'x4': 7, 'x5': 3}

第一种按照值来排序的方式


dict2 = sorted(dict1.items(), key=lambda x: x[1])
print(dict2)

输出结果如下


[('x5', 3), ('x1', 4), ('x2', 5), ('x3', 6), ('x4', 7)]

第二种按照值来排序的方式


dict3 = sorted(dict1.items(), key=operator.itemgetter(1))
print(dict3)

输出结果如下


[('x5', 3), ('x1', 4), ('x2', 5), ('x3', 6), ('x4', 7)]

Python小技巧 - 使用不同的方式同时测试多个标记

Wed, 30 Jul 2025 09:57:45 +0800

如何使用不同的方式同时测试多个标记

比如我有个需求如下

代码逻辑是这样的


x, y, z = 1, 0, 1
if x == 1 or y == 1 or z == 1:
 print('passed')

可以修改为如下方式，实现同时测试多个标记，不需要分开写，比较方便


if 1 in (x, y, z):
 print('passed')

再比如我有这个需求，只判断true 或者 false


if a or b or c:
 print('passed')

可以修改为下面的方式，实现同时测试多个标记


if any((a, b, c)):
 print('passed')

每天积累一点，技术成熟一点

Python的List Comprehension(列表推导式)

Wed, 30 Jul 2025 09:57:26 +0800

如何更高效的创建列表

Python提供了一个高效的列表推导式（List Comprehension）

语法如下


values = [expression
 for value in collection
 if condition]

等价于


vals = []
for value in collection:
	if condition:
		vals.append(expression)

举个简单的例子


even_squares = [x * x for x in range(10) if not x % 2]
print(even_squares)

输出结果如下


[0, 4, 16, 36, 64]

列表推导式（List Comprehension）还有更多好用的方法，后面继续补充

Python小知识 - Python的PSF是什么

Wed, 30 Jul 2025 09:57:23 +0800

Python小知识 - Python的PSF是什么

PSF是Python Software Foundation的缩写

Python Software Foundation（Python软件基金会）是Python背后的组织。

The Python Software Foundation is the organization behind Python. Become a member of the PSF and help advance the software and our mission

Python软件基金会是一个致力于Python编程语言的非营利组织，成立于2001年3月6日。

基金会的任务在于促进Python使用社群的发展，并负责Python社群中的各项工作，包括开发Python核心版本、管理智慧财产权、开发者研讨会（包含PhyCon），以及募款。

如何使用fabric 2.x使用并行方式和串行方式远程自动化运维部署

Wed, 30 Jul 2025 09:57:20 +0800

之前一篇文章介绍如何使用fabric进行远程自动化部署

fabric2.x使用指南

脚本如下


import getpass
from fabric import Connection, task
from invoke import Responder

hosts = ['10.0.0.1', '10.0.0.2', '10.0.0.3', '10.0.0.4']

user = raw_input('Input username: ')
project = raw_input('Input project dirname: ')
auth_pass = getpass.getpass('Input auth pass: ')

# 需要sudo权限的时候需要
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy(c):
 for h in hosts:
 conn = Connection('%s@%s' % (user, h), connect_kwargs={'password': auth_pass})
 command = 'ls -al'
 # sudo 权限可用下面的命令
 # conn.run(command, pty=True, watchers=[sudo_pass])
 # 非sudo权限可用下面的命令 - 这里使用非sudo权限
 conn.run(command)

串行方式如下


import getpass
from fabric import Connection, task, SerialGroup
from invoke import Responder

hosts = ['10.0.0.1', '10.0.0.2', '10.0.0.3', '10.0.0.4']

user = raw_input('Input username: ')
project = raw_input('Input project dirname: ')
auth_pass = getpass.getpass('Input auth pass: ')

# 需要sudo权限的时候需要
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy(c):
 g = SerialGroup(*hosts, user=user, connect_kwargs={'password': auth_pass})
 command = 'ls -al'
 # sudo 权限可用下面的命令
 # conn.run(command, pty=True, watchers=[sudo_pass])
 # 非sudo权限可用下面的命令 - 这里使用非sudo权限
 conn.run(command)

并行方式如下


import getpass
from fabric import Connection, task, SerialGroup
from invoke import Responder

hosts = ['10.0.0.1', '10.0.0.2', '10.0.0.3', '10.0.0.4']

user = raw_input('Input username: ')
project = raw_input('Input project dirname: ')
auth_pass = getpass.getpass('Input auth pass: ')

# 需要sudo权限的时候需要
sudo_pass = Responder(
 pattern=r'\[sudo\] password',
 response=auth_pass + '\n',
)

@task
def deploy(c):
 g = ThreadingGroup(*hosts, user=user, connect_kwargs={'password': auth_pass})
 command = 'ls -al'
 # sudo 权限可用下面的命令
 # conn.run(command, pty=True, watchers=[sudo_pass])
 # 非sudo权限可用下面的命令 - 这里使用非sudo权限
 conn.run(command)

节省掉了for循环的操作但是增加了排查问题的难度

这里举例如何处理异常


import socket, paramiko.ssh_exception
from fabric import SerialGroup, exceptions, runners
from fabric import task
from fabric.exceptions import GroupException

@task
def run(c):
 g = SerialGroup('localhost')
 try:
 res = g.run('hostname')
 # print(res)
 except GroupException as e:
 for c, r in e.result.items():
 print("{}".format(c.host))
 print(c)
 print(r)
 if isinstance(r, runners.Result):
 print(" SUCCESS, " + r.stdout.strip())
 elif isinstance(r, socket.gaierror):
 print("NetWork Error")
 elif isinstance(r, paramiko.ssh_exception.AuthenticationException):
 print("Auth failed")
 else:
 print('Other Error')

基础知识汇总

Fabric 提供了一个 fabric.group.Group 基类，并由其派生出两个子类，区别是：

SerialGroup(*hosts, **kwargs)：按串行方式执行操作
ThreadingGroup(*hosts, **kwargs)：按并发方式执行操作

参考资料：

https://cloud.tencent.com/developer/article/1590930

Python 3.8 安装细节记录

Wed, 30 Jul 2025 09:57:15 +0800

为了防止安装virtualenv时`sudo /usr/local/bin/pip install virtualenv`遇到如下错误


ModuleNotFoundError: No module named '_ctypes'

在CentOS 7下执行下面命令


sudo yum install libffi-devel -y

然后源码安装


cd Python-3.8.0
sudo make && sudo make install

为了防止安装mysql时遇到如下错误


OSError: mysql_config not found

在Centos 7下执行下面命令


sudo yum install mysql-devel -y

然后源码安装


cd Python-3.8.0
sudo make && sudo make install

wrap_socket() got an unexpected keyword argument '_context'

Wed, 30 Jul 2025 09:57:12 +0800

最近的项目gunicorn+flask+nginx

但是最近在使用过程中，通过urllib发起请求的时候，遇到了一个错误，错误如下


wrap_socket() got an unexpected keyword argument '_context'

不知道，不懂这是什么错误信息，于是google了一下

居然是eventlet的问题

可以追溯到这里

https://github.com/eventlet/eventlet/issues/526

看到最后，会发现“python 3.8+pyopenssl”，居然有人用这个方式说解决了。我懵了，我的是python 3.7你让我升级吗？开玩笑，我不想折腾了，我就要用3.7。然后在网上爬一会，会发现有人建议使用gevent

截止2019-12-27，解决方案是

将eventlet替换为gevent，加完之后，在使用的时候会提示这个错误哦


/var/www/baby/.env3_baby/lib/python3.7/site-packages/gunicorn/workers/ggevent.py:53: MonkeyPatchWarning: Monkey-patching ssl after ssl has already been imported may lead to errors, including RecursionError on Python 3.6. It may also silently lead to incorrect behaviour on Python 3.7. Please monkey-patch earlier. See https://github.com/gevent/gevent/issues/1016. Modules that had direct imports (NOT patched): ['pymongo.ssl_support (/var/www/baby/.env3_baby/lib/python3.7/site-packages/pymongo/ssl_support.py)', 'eventlet.green.ssl (/var/www/baby/.env3_baby/lib/python3.7/site-packages/eventlet/green/ssl.py)']. Subclasses (NOT patched): ["<class 'eventlet.green.ssl.GreenSSLContext'>"].
 monkey.patch_all()

但是后来我又测试了几次又没有问题了，看来不是必现的问题

不过看他提示的意思是代码入口处加上monkey.patch_all()，下次遇到可以试试。

如何在Flask扩展开发的过程中加入异常日志

Wed, 30 Jul 2025 09:57:08 +0800

之前开发了一个扩展叫做flask_dxcaptcha

最近在使用他的过程中发现了一个问题，发现异常的时候直接导致使用的他的程序奔溃了，异常让人崩溃，但是不能给使用者带来崩溃，于是做了修复，加了下日志处理逻辑。

但是如果自己再定义一个好像显得有些麻烦，毕竟定义一套虽说可以更加责任化（就是出了问题知道是自己扩展的问题），但是既然是Flask扩展，应该跟使用Flask框架结合下会更好，于是决定先暂时这样处理吧，添加的代码如下


from flask import current_app

try:
 ......
except Exception as e:
 current_app.logger.exception(str(e))
 ......

测试如下


from flask import current_app

try:
	raise Exception('测试异常')
 ......
except Exception as e:
 current_app.logger.exception(str(e))
 ......

于是得到的异常结果如下


[2019-12-27 10:51:12,653] ERROR in captchaclient: 测试异常
Traceback (most recent call last):
 File "/Users/durban/python/baby/.env3_baby/lib/python3.7/site-packages/flask_dxcaptcha/captchaclient.py", line 57, in checkToken
 raise Exception('测试异常')
Exception: 测试异常

Python 3 - sqlite3的时区如何设置

Wed, 30 Jul 2025 09:57:01 +0800

在使用Python的sqlite3库的时候，我第一次遇到时区不知道怎么设置的情况

比如下面这个表


CREATE TABLE post (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 author_id INTEGER NOT NULL,
 the_date VARCHAR(32) NOT NULL,
 created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
 updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
 title TEXT NOT NULL,
 body TEXT NOT NULL,
 FOREIGN KEY (author_id) REFERENCES user (id)
);

插入记录的时候created和updated被默认赋值一个时间戳

比如我当前的时间是2019-12-26 17:36:44，时区是8

那么插入后的结果值是2019-12-26 09:36:44，了解程序的都知道这个是UTC时区为0的时间

那么知识点就来了，在使用sqlite3时，当插入表的数据中，created和updated字段是TIMESTAMP类型并且默认值为CURRENT_TIMESTAMP时，其值是一个UTC时区为0的时间。

另外一个知识点，如何将此时间转换为我们当前时区需要的值


import datetime
import time

the_date = '2019-12-26 09:36:44'

t = time.strptime(the_date, "%Y-%m-%d %H:%M:%S")
timestamp = int(time.mktime(t))
dt = datetime.datetime.fromtimestamp(timestamp).replace(tzinfo=datetime.timezone.utc)
dt8 = dt.astimezone(datetime.timezone(datetime.timedelta(hours=8)))
date = dt8.strftime("%Y-%m-%d %H:%M:%S")
print(date)

Output:


>>> print(date)
2019-12-26 17:36:44

封装下，得到如下函数


import datetime
import time

the_date = '2019-12-26 09:36:44'

def date_to_timezone_date(date, timezone):
 t = time.strptime(the_date, "%Y-%m-%d %H:%M:%S")
 timestamp = int(time.mktime(t))
 dt = datetime.datetime.fromtimestamp(timestamp).replace(tzinfo=datetime.timezone.utc)
 dt8 = dt.astimezone(datetime.timezone(datetime.timedelta(hours=timezone)))
 date = dt8.strftime("%Y-%m-%d %H:%M:%S")

 return date

后期在将数据查出来之后就可以直接进行转换了，想转任何一个时区都可以。

最终的解决方案是，sqlite3的时区可以不用设置，也是可以拿到准确时间的

如何发布一个Flask扩展包

Wed, 30 Jul 2025 09:56:59 +0800

如何开发和发布一个Flask扩展，如何开发一个Flask扩展，官方介绍在这里

如何开发Flask扩展 - 实战篇（以我最近开发的flask_dxcaptcha为例）

OS - MAX OS

创建一个目录flask_dxcaptcha


mkdir flask_dxcaptcha
cd flask_dxcaptcha

创建python虚拟环境并激活


virtualenv .env -p /usr/local/bin/python3
source .env/bin/activate

创建包并开发具体的逻辑(flask_dxcaptcha目录下)


mkdir flask_dxcaptcha
cd flask_dxcaptcha
touch __init__.py

编写__init__.py文件开始开发扩展逻辑，记录下flask_dxcaptcha的__init__.py


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-25 17:02:16
# @Last Modified by: durban
# @Last Modified time: 2019-12-25 18:43:25

from flask import current_app, _app_ctx_stack

from flask_dxcaptcha.captchaclient import CaptchaClient

class DXCaptcha(object):

 def __init__(self, app=None):
 self.app = app
 if app is not None:
 self.init_app(app)

 def init_app(self, app):
 app.config.setdefault('DX_APP_ID', '')
 app.config.setdefault('DX_APP_SECRECT', '')

 def init_captcha_client(self):
 if current_app.config['DX_APP_ID'] == '' or \
 current_app.config['DX_APP_SECRECT'] == '':
 raise Exception('DX_APP_ID and DX_APP_SECRECT can not empty.')

 return CaptchaClient(
 current_app.config['DX_APP_ID'],
 current_app.config['DX_APP_SECRECT'],
 )

 @property
 def client(self):
 ctx = _app_ctx_stack.top
 if ctx is not None:
 if not hasattr(ctx, 'dx_captcha'):
 ctx.dx_captcha = self.init_captcha_client()
 return ctx.dx_captcha

flask_dxcaptcha包下的目录结构如下


.
├── __init__.py
├── captchaclient.py
├── captcharesponse.py
├── ctuclient.py
├── cturequest.py
├── cturesponse.py
├── cturesponsestatus.py
├── cturesult.py
├── hitrule.py
├── risklevel.py
├── risktype.py
├── suggestion.py
└── suggestpolicy.py

然后先项目目录下面添加如下几个文件 setup.py # 具体打包和安装配置 MANIFEST.in # 打包文件配置 README.md # 项目介绍包括如何安装、如何使用 LICENSE # 项目许可类型

这里比较重要的是setup.py和MANIFEST.in，着重记录下这两个文件，其余两个文件可以去参考这个扩展flask_dxcaptcha

setup.py的配置如下


# -*- coding: utf-8 -*-
# @Author: durban
# @Date: 2019-12-25 18:00:43
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-25 19:03:55

from setuptools import find_packages, setup

setup(
 name='Flask-DXCaptcha',
 version='1.0.0',
 url='https://github.com/durban89/flask_dxcaptcha',
 license='MIT',
 author='durban zhang',
 author_email='[email protected]',
 description='Flask-DXCaptcha是依赖顶象科技提供的无感验证功能开发的Flask 扩展',
 long_description=__doc__,
 packages=find_packages(),
 zip_safe=False,
 include_package_data=True,
 platforms='any',
 install_requires=[
 'Flask>=1.1.1'
 ],
 python_requires=">=3.7.4",
 classifiers=[
 'Environment :: Web Environment',
 'Intended Audience :: Developers',
 'License :: OSI Approved :: BSD License',
 'Operating System :: OS Independent',
 'Programming Language :: Python :: 3',
 'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
 'Topic :: Software Development :: Libraries :: Python Modules'
 ]
)

具体关于setup参数的介绍，请点这里

MANIFEST.in的配置如下


include MANIFEST.in
include README
include LICENSE
recursive-exclude *.pyc

具体关于参数的介绍，请点这里

如何发布Flask扩展

如何发布Flask扩展，具体的可以参考官方介绍，点这里

这里以flask_dxcaptcha为例介绍下，前提是项目开发后，自己测试没有问题再发布

在flask_dxcaptcha项目目录下面运行如下命令（注意是我们的虚拟环境）

如果没有安装setuptools和wheel执行下面命令


pip install setuptools wheel

打包扩展


python3 setup.py sdist bdist_wheel

在dist目录下生成如下文件


$ tree dist
dist
├── Flask-DXCaptcha-1.0.0.tar.gz
└── Flask_DXCaptcha-1.0.0-py3-none-any.whl

上传包到Test PyPI


pip install twine -i https://mirrors.aliyun.com/pypi/simple/

-i 参数指定了包的镜像源

上传所有打包文件到Test PyPI


twine upload --repository-url https://test.pypi.org/legacy/ dist/*

示例如下


$ twine upload --repository-url https://test.pypi.org/legacy/ ./dist/*
Uploading distributions to https://test.pypi.org/legacy/
Enter your username: [your_username]
Enter your password:
Uploading Flask_DXCaptcha-1.0.0-py3-none-any.whl
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 13.0k/13.0k [00:04<00:00, 3.01kB/s]
Uploading Flask-DXCaptcha-1.0.0.tar.gz
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 9.53k/9.53k [00:01<00:00, 7.57kB/s]

View at:
https://test.pypi.org/project/Flask-DXCaptcha/1.0.0/

测试安装上传的包


pip install -i https://test.pypi.org/simple/ --no-deps Flask-DXCaptcha==1.0.0

如果安装成功，就可以正常使用了


$ python
Python 3.7.4 (default, Jul 9 2019, 18:14:44)
[Clang 9.0.0 (clang-900.0.39.2)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import flask_dxcaptcha
>>>

如果以上都是正常包的话，那么将包发布到正式的PyPI中


twine upload dist/*

示例如下


$ twine upload dist/*
Uploading distributions to https://upload.pypi.org/legacy/
Enter your username: durban_zhang
Enter your password:
Uploading Flask_DXCaptcha-1.0.0-py3-none-any.whl
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 13.0k/13.0k [00:09<00:00, 1.41kB/s]
Uploading Flask-DXCaptcha-1.0.0.tar.gz
100%|███████████████████████████████████████████████████████████████████████████████████████████████| 9.53k/9.53k [00:01<00:00, 6.87kB/s]

View at:
https://pypi.org/project/Flask-DXCaptcha/1.0.0/

打开地址 https://pypi.org/project/Flask-DXCaptcha/1.0.0/ 就能看到发布的Flask扩展了

Python2 urllib2 与 Python3 urllib.request API对照

Wed, 30 Jul 2025 09:56:56 +0800

Python2 urllib2 与 Python3 urllib.request API对照

python2	python3
urllib2.urlopen()	urllib.request.urlopen()
urllib2.install_opener()	urllib.request.install_opener()
urllib2.build_opener()	urllib.request.build_opener()
urllib2.URLError	urllib.error.URLError
urllib2.HTTPError	urllib.error.HTTPError
urllib2.Request	urllib.request.Request
urllib2.OpenerDirector	urllib.request.OpenerDirector
urllib2.BaseHandler	urllib.request.BaseHandler
urllib2.HTTPDefaultErrorHandler	urllib.request.HTTPDefaultErrorHandler
urllib2.HTTPRedirectHandler	urllib.request.HTTPRedirectHandler
urllib2.HTTPCookieProcessor	urllib.request.HTTPCookieProcessor
urllib2.ProxyHandler	urllib.request.ProxyHandler
urllib2.HTTPPasswordMgr	urllib.request.HTTPPasswordMgr
urllib2.HTTPPasswordMgrWithDefaultRealm	urllib.request.HTTPPasswordMgrWithDefaultRealm
urllib2.AbstractBasicAuthHandler	urllib.request.AbstractBasicAuthHandler
urllib2.HTTPBasicAuthHandler	urllib.request.HTTPBasicAuthHandler
urllib2.ProxyBasicAuthHandler	urllib.request.ProxyBasicAuthHandler
urllib2.AbstractDigestAuthHandler	urllib.request.AbstractDigestAuthHandler
urllib2.HTTPDigestAuthHandler	urllib.request.HTTPDigestAuthHandler
urllib2.ProxyDigestAuthHandler	urllib.request.ProxyDigestAuthHandler
urllib2.HTTPHandler	urllib.request.HTTPHandler
urllib2.HTTPSHandler	urllib.request.HTTPSHandler
urllib2.FileHandler	urllib.request.FileHandler
urllib2.FTPHandler	urllib.request.FTPHandler
urllib2.CacheFTPHandler	urllib.request.CacheFTPHandler
urllib2.UnknownHandler	urllib.request.UnknownHandler

Celery任务自动重试

Wed, 30 Jul 2025 09:56:53 +0800

使用flask框架开发中，开始只是简单的使用celery做异步任务的，但是最近发现在用户注册环节中发现，如果邮件发送系统出现问题，比如我使用的是腾讯QQ邮箱，由于发送的邮件速度过快直接提示我“Connection frequency limited”，结果就是邮件系统不能发送了，但是如果你了解这个QQ发送频率的话，可以设置一个重新发送的设置，等待状态恢复正常，在此发送也是一个比较好的策略，不过要确定好这个重试的次数，那么如何才能实现重新发送呢？

celery提供了很完美的接口给我们用，可以到这里查看详细文档

这里记录下自己实际使用celery的情况

celery.task原始的代码如下


@celery.task()
def send_register_email(self, domain, username, email, code):
 subject = 'Please verify your email address'
 html = '''
......
'''
 link = '%s/auth/register/activate?code=%s' % (domain, code)

 with mail.connect() as conn:

 msg = Message(
 sender='Walkerfree <%s>' % celery.conf['MAIL_FROM'],
 subject=subject,
 html=html % (username, link, link),
 recipients=[email]
 )

 conn.send(msg)

celery.task改完之后的代码如下


@celery.task(bind=True,
 default_retry_delay=1 * 60,
 retry_kwargs={'max_retries': 3},
 name='tasks.send_register_email')
def send_register_email(self, domain, username, email, code):
 subject = 'Please verify your email address'
 html = '''
......
'''
 link = '%s/auth/register/activate?code=%s' % (domain, code)

 with mail.connect() as conn:

 msg = Message(
 sender='Walkerfree <%s>' % celery.conf['MAIL_FROM'],
 subject=subject,
 html=html % (username, link, link),
 recipients=[email]
 )

 try:
 conn.send(msg)
 except SMTPDataError as e:
 raise self.retry(exc=e)

我这里只是简单的加了如下celery任务的接口参数


bind=True,
default_retry_delay=1 * 60,
retry_kwargs={'max_retries': 3},

并且在执行celery任务的时候捕获到异常并调用如下代码


raise self.retry(exc=e)

然后就可以使用了，比如我这里调用celery任务的时候，会遇到这样的提示


[2019-12-25 10:14:58,749: INFO/ForkPoolWorker-1] Task tasks.send_register_email[9acaaf96-6574-4c54-b46c-e3a35bf3935a] retry: Retry in 60s: SMTPDataError(550, b'Connection frequency limited')

意思是在遇到"SMTPDataError(550, b’Connection frequency limited’)“的时候，celery将在60秒内重试任务

还是很简单的

Flask 1.0进阶 - 扩展

Wed, 30 Jul 2025 09:56:50 +0800

扩展是为flask应用程序添加功能的额外包。例如，扩展可能会添加对发送电子邮件或连接到数据库的支持。一些扩展添加了全新的框架来帮助构建某些类型的应用程序，比如REST API。

查找扩展

Flask扩展通常命名为“Flask-Foo”或“Foo-Flask”。您可以在PyPI中搜索带有 Framework :: Flask 标记的包。

使用扩展

关于每个扩展的安装、配置和使用说明，请查询他们的文档。通常，扩展从 app.config 获取他们自己的配置参数并在初始化的时候传参到应用程序实例中。举个例子，比如扩展“Flask-Foo”的使用方式可能如下：


from flask_foo import Foo

foo = Foo()

app = Flask(__name__)
app.config.update(
 FOO_BAR='baz',
 FOO_SPAM='eggs',
)

foo.init_app(app)

创建扩展

尽管PyPI包含了许多Flask扩展，但是仍没有找到适合你的扩展。如果是这样的话，你可以创建一个你自己的扩展。请参考Flask Extension Development来开发你自己的Flask扩展。

命令行界面

安装Flask后，会默认安装flask脚本的，这个脚本一个Click命令行接口会被安装到虚拟环境中。

通过终端，这个脚本可以访问内建的命令、扩展的命令和程序定义的命令。使用--help选项可以获取到更多关于命令的信息和关于命令的选项

应用程序发现

flask命令是被Flask安装的，不是你的应用安装的。为了使用这个命令，必须告诉你的应用程序在哪里。FLASK_APP环境变量则是用来告诉在哪里能找到应用程序

使用方式如下：

Unix Bash (Linux, Mac, etc.):


$ export FLASK_APP=hello
$ flask run

Windows CMD:


> set FLASK_APP=hello
> flask run

Windows PowerShell:


> $env:FLASK_APP = "hello"
> flask run

FLASK_APP支持多种形式的选项来具体化你的应用程序，大多数都是用比较简单的方式。

下面是一些比较典型的例子

(不做任何设置)


wsgi.py文件将被导入，并自动的检查是否有app(```app```)，它提供了最简单的方式去创建了一个带有额外参数的工厂函数

FLASK_APP=hello 名字将被导入，并自动检查是否有app(app)或者工厂函数(create_app)

FLASK_APP有三个部分：一个设置了当前工作目录的可选路径，一个Python文件或者有点的导入路径和一个可选的实例或者工厂函数变量名。如果是一个工厂函数的话可以通过小括号传入需要的参数，下面看下具体的例子

FLASK_APP=src/hello


设置当前目录的src目录并导入hello

FLASK_APP=hello.web


导入```hello.web```路径

FLASK_APP=hello:app2


使用在hello中的```app2``` Flask实例

FLASK_APP="hello:create_app('dev')"


```create_app```工厂函数在```hello```中被调用并传递参数```'dev'```字符串

如果FLASK_APP没有设置，执行命令时将尝试导入“app”或者“wsgi”（作为一个“.py”文件，或者包）并尝试去检查一个应用实例或者工厂

如果导入的信息被设置了，即FLASK_APP被设置了的话。执行命令时，程序查找一个应用实例名字叫做app或者application，它是一个应用的实例。如果没有找到实例，程序会查找一个工厂行数，名称是create_app或者make_app，它会返回一个实例

当应用工厂函数被调用，如果工厂函数带有一个名字叫做script_info的参数，则ScriptInfo实例会作为一个关键字参数传递进去。如果工厂函数只带有一个参数并且没有圆括号跟在工厂函数名字后面，则ScriptInfo实例将作为一个位置参数传递进去。如果圆括号跟在工厂函数后面的话，他们的内容将被解析喂Python字符串并作为参数传入到函数中。这意味着字符串始终在引号中。

启动开发服务器

run命令将启动一个开发服务器，在许多情况下替代了 Flask.run() 方法


$ flask run
 * Serving Flask app "baby" (lazy loading)
 * Environment: development
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 267-735-523

注意

不要使用run命令再生产环境中，只使用开发服务器在开发环境中。开发服务器虽然提供了便利，但是不是安全的、不是稳定的、不是高效率的。

进阶结束更新说明

先说下此系列的进阶，主要是以官方文档为主线，边阅读边实践，并记录分享，其中有部分官方的实例是有问题的，但是没有找到反馈入口，也出于没有人访问的情况，所以结束继续分享。如果有疑问可以转到官方文档这里去查看

flask在pytest中如何使用session

Wed, 30 Jul 2025 09:56:47 +0800

先看代码


class AuthActions(object):

 def __init__(self, client):
 self._client = client

 def login(self, username='test', password='test', code='1111'):
 with self._client.session_transaction() as session:
 session['captcha_key'] = '1111'

 return self._client.post(
 '/auth/login',
 data={'username': username, 'password': password,
 'verification-code': code}
 )

 def logout(self):
 return self._client.get('/auth/logout')

这里为什么会提到session，因为我们正常使用的过程中，在登录或者注册的逻辑中会遇到session记录验证码，然后用户用户进行登录或者注册提交表单时的验证，但是这个逻辑在pytest中会遇到一些问题，因为要伪造一个类似于session的情况来测试类似登录或者注册的逻辑中使用session的情况。

这个问题在flask的官网也有介绍如何在测试环境中使用session，可以参考

https://flask.palletsprojects.com/en/1.1.x/testing/#accessing-and-modifying-sessions

https://flask.palletsprojects.com/en/1.1.x/api/#flask.testing.FlaskClient.session_transaction

都有对应的说明但是具体没有实例的话时没有办法具体了解其使用场景的

不过今天在进行测试单元改写的时候发现原来可以这样使用特此记录下方便日查找

上段代码是自我在conftest.py中的代码

使用的时候可以像下面这样调用


@pytest.fixture
def auth(client):
 return AuthActions(client)

然后在测试函数中可以直接这样写


def test_login(client, auth):
 # ... 省略 
 response = auth.login()

 # ... 省略

当然还要自己定义一个叫做client的fixture

fabric2.x使用指南

Wed, 30 Jul 2025 09:56:44 +0800

之前在看flask1.0的文档，里面学到了一个自动部署的工具fabric，但是里面介绍的是1.0系列的使用指南，但是我安装的时候版本已经更新了，已经是fabric2.x了，so，没办法，直接使用fabric2.x的版本吧，但是文档是fabric1.0的版本确实挺难受，毕竟很多功能要靠自己去摸索，然后再一点一点的实现，刚开始也是一头雾水，没有思路，今天回过头一看其实很简单的，主要是远程连接这块，不在区分本地和远程连接了，fabric1.x版本的时候会有个local的方法，使用起来一目了然，就知道具体这个是本地的还是远程。然后有小伙伴说了，就使用这个版本不行吗，我说不行，具体可以去fabric官网看下升级的必要性说明，其他不多说了，下面看下我说如何使用fabric2.x实现具体细节的

代码如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-12-04 16:52:35
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-12-04 18:41:59

import getpass
from fabric import Connection, task

@task
def pack(c):
 # 这里的c参数我理解为是Connection连接的本地 然后根据setup.py进行项目打包
 c.run('python setup.py release sdist --format=gztar')

@task
def deploy(c):
 # 输入服务器的登录用户名
 user = raw_input('Input login user name: ')
 # 输入服务器的登录地址
 host = raw_input('Input login host: ')
 # 输入服务器的项目目录地址
 root = raw_input('Input project root path：')
 # 输入服务器的登录密码
 user_pass = getpass.getpass('Input login user pass：')
 # 获取包的全名称
 result = c.run('python setup.py --fullname', hide=True)
 dist = result.stdout.strip()
 filename = '%s.tar.gz' % dist

 # 获取包的名称 - 这个名称可以根据自己的需求来自定义，这里主要是为了下面supervisor启动时使用
 result = c.run('python setup.py --name', hide=True)
 name = result.stdout.strip()

 # 远端服务器连接创建
 remote = Connection('%s@%s' % (user, host),
 connect_kwargs={"password": user_pass})
 # 上传文件到远端服务器
 remote.put('./dist/%s' %
 filename, remote='%s' % root)

 # 在远端服务器上执行下面命令 - 这个会默认输出你在远端服务器展示的信息
 result = remote.run('cd %s &&\
 source .env/bin/activate &&\
 ls -al && type python &&\
 pip install %s &&\
 supervisorctl restart walkerfree' % (root, filename))

使用方式如下


fab pack deploy

这个命令其实也可以分布执行


fab pack
fab deploy

我上面的代码也可以将两个函数合并到一起在执行，分开的话主要是看起来思路比较清晰

Python正则表达式

Wed, 30 Jul 2025 09:56:41 +0800

知识点一：正则表达式使用方式


>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group()
'def'
>>> m.group(0)
'def'

(?<=abc)def ，并不是从a开始搜索，而是从d往回看的


>>> m = re.search('(?<=-)\w+', 'email-address')
>>> m.group(0)
'address'
>>>

这个例子搜索一个跟随在连字符(-)后的单词

具体的正则使用方式可以参考官网：https://docs.python.org/zh-cn/3/library/re.html

知识点二：正则表达式对象

将正则表达式的样式编译为一个正则表达式对象，可以让程序更加高效


prog = re.compile(pattern)
results = prog.match(string)

等价于


result = re.match(pattern, string)

知识点三：search() vs. match()

re.search()检查字符串的任意位置，re.match()检查字符串开头


>>> re.match("c", "abcded") # no match
>>> re.search("c", "abcdef") # match
<re.Match object; span=(2, 3), match='c'>
>>>

在search()中，可以使用^作为开始来限制匹配到字符串的首位


>>> re.match("c", "abcdef") # no match
>>> re.search("^c", "abcdef") # no match
>>> re.search("^a", "abcdef") # match
<re.Match object; span=(0, 1), match='a'>
>>>

Python字符串格式化记录

Wed, 30 Jul 2025 09:56:39 +0800

之前学习Python只是在一些书籍或者是文章中学习，而且是一遍实践一遍学，这样的话，会很容易忽略一些细节的，导致你发现不了Python的强大

最近在看Python的官方文档，看到“字符串格式化”，发现这个格式化使用可以非常灵活

我这里使用的是Python 4.7.4

下面记录下格式化具体可以如何使用，方便日后查找，格式化用起来还是很方便的

第一种格式化使用方式 - 按位置访问参数


>>> '{0},{1},{2}'.format(1,2,3)
'1,2,3'
>>> '{},{},{}'.format(1,2,3)
'1,2,3'
>>> '{2},{1},{0}'.format(1,2,3)
'3,2,1'
>>> '{2},{1},{0}'.format(*('123')) # 解包参数序列
'3,2,1'
>>> '{0},{1},{0}'.format('123','45') # 参数的索引可以重复
'123,45,123'

第二种格式化使用方式 - 按名称访问参数


>>> '坐标：{lat},{lon}'.format(lat='37.24N',lon='-155.8W')
'坐标：37.24N,-155.8W'
>>> coord = {'lat':'37.24N','lon':'-155.8W'}
>>> '坐标：{lat},{lon}'.format(**coord)
'坐标：37.24N,-155.8W'
>>>

第三种格式化使用方式 - 按参数访问参数


>>> c = 5-3j
>>> '复数{0}是有实数{0.real}和虚数{0.imag}组成'.format(c)
'复数(5-3j)是有实数5.0和虚数-3.0组成'
>>> class Point():
... def __init__(self, x, y):
... self.x, self.y = x, y
... def __str__(self):
... return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 5))
'Point(4, 5)'

第四种格式化使用方式 - 按参数的项访问参数


>>> point = (3, 5)
>>> 'X: {0[0]}, Y: {0[1]}'.format(point)
'X: 3, Y: 5'

第五种格式化使用方式 - 替代%s和%r


>>> 'repr() show qoutes:{!r}, str() do not:{!s}'.format("test1","test2")
"repr() show qoutes:'test1', str() do not:test2"

这里的区别就是引号的区别，test1加了引号，test2没有加引号

第六种格式化使用方式 - 对齐文本以及指定宽度


>>> '{:<60}'.format('left aligned，length - 60')
'left aligned，length - 60 '
>>> '{:>60}'.format('right aligned，length - 60')
' right aligned，length - 60'
>>> '{:^60}'.format('center aligned，length - 60')
' center aligned，length - 60 '
>>> '{:*^60}'.format('center aligned，length - 60')
'*****************center aligned，length - 60*****************'

第七种格式化使用方式 - 替代 %+f, %-f 和 % f 以及指定正负号


>>> '{:+f};{:-f}'.format(3.14, -3.14)
'+3.140000;-3.140000'
>>> '{: f};{: f}'.format(3.14, -3.14)
' 3.140000;-3.140000'
>>> '{: f};{: f}'.format(+3.14, -3.14)
' 3.140000;-3.140000'
>>> '{:-f};{:-f}'.format(3.14, -3.14)
'3.140000;-3.140000'
>>> '{:f};{:f}'.format(3.14, -3.14)
'3.140000;-3.140000'

第八种格式化使用方式 - 替代 %x 和 %o 以及转换基于不同进位制的值


>>> 'int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}'.format(42)
'int: 42; hex: 2a; oct: 52; bin: 101010'
>>> 'int: {0:#d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}'.format(42)
'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'
>>>

binary 二进制 octal 八进制 hexadecimal 十六进制 decimal 十进制

第九种格式化使用方式 - 使用逗号作为千位分隔符


>>> '{:,}'.format(123456789)
'123,456,789'

第十种格式化使用方式 - 使用特定类型的专属格式化


>>> import datetime
>>> d = datetime.datetime(2010, 11, 28, 11, 54, 20)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-11-28 11:54:20'

第十一种格式化使用方式 - 嵌套参数以及更复杂的示例


>>> for align, text in zip('<^>',['left','center','right']):
... '{0:{fill}{align}16}'.format(text, fill=align, align=align)
...
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>> octets = [192, 168, 0, 1] # 16进制
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> width = 5
>>> for num in range(5, 12):
... for base in 'dXob':
... print('{0:{width}{base}}'.format(num, width=width, base=base), end=' ')
... print()
...
 5 5 5 101
 6 6 6 110
 7 7 7 111
 8 8 10 1000
 9 9 11 1001
 10 A 12 1010
 11 B 13 1011

其实我比较喜欢最后一种格式，其实也是应用中应该被经常用到的使用方式

Flask中如何获取Server的相关信息

Wed, 30 Jul 2025 09:55:29 +0800

在使用Flask做web开发的时候，偶尔会需要调用Request中的Server信息，比如端口号，域名之类的

在Flask中这个Server的相关信息获取是非常简单的

通过request.environ可以获取到几乎全部的Server信息

比如我这里访问http://127.0.0.1:5000/post/item 然后将request.environ的信息输出到日志，可以获取到类似如下的信息


{'wsgi.errors': <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>, 'wsgi.version': (1, 0), 'wsgi.multithread': True, 'wsgi.multiprocess': False, 'wsgi.run_once': False, 'wsgi.url_scheme': 'http', 'REQUEST_METHOD': 'GET', 'SCRIPT_NAME': '', 'RAW_PATH_INFO': '/post/item', 'PATH_INFO': '/post/item', 'CONTENT_TYPE': 'text/plain', 'SERVER_PROTOCOL': 'HTTP/1.0', 'SERVER_NAME': '127.0.0.1', 'SERVER_PORT': '5000', 'REMOTE_ADDR': '127.0.0.1', 'REMOTE_PORT': '58405', 'GATEWAY_INTERFACE': 'CGI/1.1', 'headers_raw': (('Host', '127.0.0.1:5000'), ('Connection', 'keep-alive'), ('Cache-Control', 'max-age=0'), ('Upgrade-Insecure-Requests', '1'), ('User-Agent', 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.87 Safari/537.36'), ('Sec-Fetch-User', '?1'), ('Accept', 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3'), ('Sec-Fetch-Site', 'none'), ('Sec-Fetch-Mode', 'navigate'), ('Accept-Encoding', 'gzip, deflate, br'), ('Accept-Language', 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6,lb;q=0.5,co;q=0.4'), ('Cookie', 'access_token=4b68629fe81a7982728adbea50357c1d382017b8; is_hide_download=true; isShowRedpacket=1; platform=web; QN_HIDDEN_INVEST_TIPS=; QN_HIDDEN_PRODUCT_BUY_PAGE_TIPS=; QN_saveplan_product_id=193; web_device_key=BWDFI2CF7ATW30TXPH07PK2BQTU0YE; zg_did=%7B%22did%22%3A%20%2216680adccf7a2c-0f4a3f6c3160ce-2d604637-3d10d-16680adccf8845%22%7D; _ga=GA1.1.430310970.1544409236; __wzd96bb85a21755618844b8=1556007296|d5311aa69976; UM_distinctid=16b4e888bbd24a-0fffcd4765422c-37677e05-fa000-16b4e888bbeb3; zg_99e520e4c4f745888ab0223f331b0032=%7B%22sid%22%3A%201567655012.547%2C%22updated%22%3A%201567655012.547%2C%22info%22%3A%201567395368068%7D; responseTimeline=1939; io=gwqkVXtguegCXzK5AAAD; __wzdd49646447596a96dfec7=1570773843|a90819629f09; __wzdeea8348a655ff8b452a8=1571706979|dee6f4a108b0; CNZZDATA5587427=cnzz_eid%3D52917038-1544409237-http%253A%252F%252F127.0.0.1%253A3041%252F%26ntime%3D1573781899; Hm_lvt_1ac5a848f7ad883bf5520aa84eda1200=1573781902; Hm_lpvt_1ac5a848f7ad883bf5520aa84eda1200=1573784001; __wzd3bcf756fc5845d894763=1574414880|4bfd4bec505e')), 'HTTP_HOST': '127.0.0.1:5000', 'HTTP_CONNECTION': 'keep-alive', 'HTTP_CACHE_CONTROL': 'max-age=0', 'HTTP_UPGRADE_INSECURE_REQUESTS': '1', 'HTTP_USER_AGENT': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.87 Safari/537.36', 'HTTP_SEC_FETCH_USER': '?1', 'HTTP_ACCEPT': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3', 'HTTP_SEC_FETCH_SITE': 'none', 'HTTP_SEC_FETCH_MODE': 'navigate', 'HTTP_ACCEPT_ENCODING': 'gzip, deflate, br', 'HTTP_ACCEPT_LANGUAGE': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6,lb;q=0.5,co;q=0.4', 'HTTP_COOKIE': 'access_token=4b68629fe81a7982728adbea50357c1d382017b8; is_hide_download=true; isShowRedpacket=1; platform=web; QN_HIDDEN_INVEST_TIPS=; QN_HIDDEN_PRODUCT_BUY_PAGE_TIPS=; QN_saveplan_product_id=193; web_device_key=BWDFI2CF7ATW30TXPH07PK2BQTU0YE; zg_did=%7B%22did%22%3A%20%2216680adccf7a2c-0f4a3f6c3160ce-2d604637-3d10d-16680adccf8845%22%7D; _ga=GA1.1.430310970.1544409236; __wzd96bb85a21755618844b8=1556007296|d5311aa69976; UM_distinctid=16b4e888bbd24a-0fffcd4765422c-37677e05-fa000-16b4e888bbeb3; zg_99e520e4c4f745888ab0223f331b0032=%7B%22sid%22%3A%201567655012.547%2C%22updated%22%3A%201567655012.547%2C%22info%22%3A%201567395368068%7D; responseTimeline=1939; io=gwqkVXtguegCXzK5AAAD; __wzdd49646447596a96dfec7=1570773843|a90819629f09; __wzdeea8348a655ff8b452a8=1571706979|dee6f4a108b0; CNZZDATA5587427=cnzz_eid%3D52917038-1544409237-http%253A%252F%252F127.0.0.1%253A3041%252F%26ntime%3D1573781899; Hm_lvt_1ac5a848f7ad883bf5520aa84eda1200=1573781902; Hm_lpvt_1ac5a848f7ad883bf5520aa84eda1200=1573784001; __wzd3bcf756fc5845d894763=1574414880|4bfd4bec505e', 'wsgi.input': <eventlet.wsgi.Input object at 0x109933550>, 'eventlet.input': <eventlet.wsgi.Input object at 0x109933550>, 'eventlet.posthooks': [], 'flask.app': <Flask 'baby'>, 'werkzeug.request': <Request 'http://127.0.0.1:5000/post/item' [GET]>}

这里我们看下常见的Server有哪些

HTTP_HOST

HTTP_USER_AGENT

HTTP_ACCEPT

HTTP_COOKIE

SERVER_NAME

SERVER_PORT

REMOTE_ADDR

REMOTE_PORT

REQUEST_METHOD

SCRIPT_NAME

RAW_PATH_INFO

PATH_INFO

CONTENT_TYPE

SERVER_PROTOCOL

当我们想要获取其中的值的话，可以使用下面的方法比如获取SERVER_NAME的值


request.environ.get('SERVER_NAME')

Flask 1.0 - Celery管理后台任务-工厂模式

Tue, 29 Jul 2025 10:56:33 +0800

管理后台任务，在许多项目中都是必不可少的，Flask的文档中推荐的Celery，但是官方文档简单介绍了非工厂模式的使用方式，简单的介绍了使用方法，但是对于使用工厂模式创建应用的我来说，完全达不到我使用的目的，根本不完美

文章参考

https://citizen-stig.github.io/2016/02/17/using-celery-with-flask-factories.html

经过搜索找到了这篇文章，给了我启发。so，记录下我自己项目的使用方式吧

baby/__init__.py保持create_app不变

添加文件

baby/celery.py文件，代码如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-11-13 17:19:11
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-11-13 17:19:25
from celery import Celery

def create_celery(app=None):
 celery = Celery(
 app.import_name,
 backend=app.config['CELERY_RESULT_BACKEND'],
 broker=app.config['CELERY_BROKER_URL']
 )
 celery.conf.update(app.config)

 class ContextTask(celery.Task):

 def __call__(self, *args, **kwargs):
 with app.app_context():
 return self.run(*args, **kwargs)

 celery.Task = ContextTask

 return celery

然后创建baby/task.py文件，代码如下


# -*- coding: utf-8 -*-
# @Author: durban.zhang
# @Date: 2019-11-13 16:30:07
# @Last Modified by: durban.zhang
# @Last Modified time: 2019-11-13 17:19:48
from baby import create_app
from baby.celery import create_celery
celery = create_celery(create_app())

@celery.task(name="tasks.add_together")
def add_together(a, b):
 return a + b

这些添加完之后，运行celery


celery -A baby.task worker -E --loglevel=info

输入类似如下


celery@durbanzhangdeMacBook-Pro v4.3.0 (rhubarb)

Darwin-16.7.0-x86_64-i386-64bit 2019-11-13 17:20:02

[config]
.> app: baby:0x1030c1310
.> transport: redis://localhost:6379//
.> results: redis://localhost:6379/
.> concurrency: 4 (prefork)
.> task events: ON

.> celery exchange=celery(direct) key=celery

[tasks]
 . tasks.add_together

[2019-11-13 17:20:03,547: INFO/MainProcess] Connected to redis://localhost:6379//
[2019-11-13 17:20:03,561: INFO/MainProcess] mingle: searching for neighbors
[2019-11-13 17:20:04,617: INFO/MainProcess] mingle: all alone
[2019-11-13 17:20:04,649: INFO/MainProcess] celery@durbanzhangdeMacBook-Pro ready.

Celery相关的参数配置如下（使用的是Redis）


app.config['CELERY_BROKER_URL'] = 'redis://localhost:6379'
app.config['CELERY_RESULT_BACKEND'] = 'redis://localhost:6379'

下面看下在view中如何调用这个任务吧


from baby.celery import create_celery

@bp.route('/together')
def together():
 celery = create_celery(current_app)
 result = celery.send_task(name='tasks.add_together', args=(2, 3))
 print(result.wait())
 return 'success'

我这里使用的是Blueprint，所以只说使用Blueprint的情况

运行项目，访问http://localhost:5000/stream/together

看下celery的输出


[2019-11-13 17:51:47,160: INFO/MainProcess] Received task: tasks.add_together[b37ca0cc-1fa3-4182-9ca8-3404aafc6ad3]
[2019-11-13 17:51:47,201: INFO/ForkPoolWorker-2] Task tasks.add_together[b37ca0cc-1fa3-4182-9ca8-3404aafc6ad3] succeeded in 0.0225263449999602s: 5
[2019-11-13 17:52:19,636: INFO/MainProcess] Received task: tasks.add_together[223f1ead-cbf4-46c3-b5fc-18f362d9a3b5]
[2019-11-13 17:52:19,672: INFO/ForkPoolWorker-1] Task tasks.add_together[223f1ead-cbf4-46c3-b5fc-18f362d9a3b5] succeeded in 0.01702427300006093s: 5
[2019-11-13 17:52:20,395: INFO/MainProcess] Received task: tasks.add_together[87b47fde-daae-4a9a-940a-3d038577af0d]
[2019-11-13 17:52:20,398: INFO/ForkPoolWorker-2] Task tasks.add_together[87b47fde-daae-4a9a-940a-3d038577af0d] succeeded in 0.0009092729999338189s: 5

一切运行正常。当然我这边也有一个输出


127.0.0.1 - - [13/Nov/2019 17:52:19] "GET /stream/together HTTP/1.1" 200 160 0.212275
5

注意这里输出的值“5”

好了，记录到此结束。

Flask 1.0 - Flask MongoEngine 'QuerySet' object has no attribute 'get_or_404'

Tue, 29 Jul 2025 10:56:29 +0800

学习Flask 1.0中使用“flask-mongoengine==0.9.5”，遇到类似“ AttributeError: ‘QuerySet’ object has no attribute ‘first_or_404’”这个错误

网上查了文档，说要在创建model类的时候添加一段代码，如下


meta = {'abstract': True, 'queryset_class': BaseQuerySet}

从代码的逻辑上来说，应该不会有问题的，而且Flask 1.0的官方文档应该也不会傻到用错误的实例来误导大家吧

文档地址：https://flask.palletsprojects.com/en/1.1.x/patterns/mongoengine/中有个创建Movie Model的代码


import mongoengine as me

class Movie(me.Document):
 title = me.StringField(required=True)
 year = me.IntField()
 rated = me.StringField()
 director = me.StringField()
 actors = me.ListField()

于是去看了“flask-mongoengine==0.9.5”的源代码，不看不知道，一看醒然大悟呀

在源码文件中“site-packages/flask_mongoengine/__init__.py”这个文件中有Document这个类如下


class Document(mongoengine.Document):
 """Abstract document with extra helpers in the queryset class"""

 meta = {'abstract': True,
 'queryset_class': BaseQuerySet}

 def paginate_field(self, field_name, page, per_page, total=None):
 """Paginate items within a list field."""
 # TODO this doesn't sound useful at all - remove in next release?
 count = getattr(self, field_name + "_count", '')
 total = total or count or len(getattr(self, field_name))
 return ListFieldPagination(self.__class__.objects, self.pk, field_name,
 page, per_page, total=total)

于是明白了，官方文档果然有点傻，忽悠我们上当嘞，我将Movie的Model类代码修改下，如下


from flask_mongoengine import Document
import mongoengine as me
from . import Imdb

class Movie(Document):
 title = me.StringField()
 year = me.IntField()
 rated = me.StringField()
 director = me.StringField()
 actors = me.ListField()
 imdb = me.EmbeddedDocumentField(Imdb)

再次运行试试，果然代码没有再报错误了。

再次进行写入操作后，写入逻辑如下


bttf = Movie(title='Back To The Feature', year=1985)
bttf.actors = [
 'Michael J. Fox',
 'Christopher Lloyd'
]
bttf.imdb = Imdb(imdb_id='tt0088763', rating=8.5)
bttf.save()

bttf = Movie.objects(title='Back To The Feature').first_or_404()

终于可以查到了


> use baby
switched to db baby
> db.collection
baby.collection
> coll = db.baby
baby.baby
> coll.find()
> coll.find({'title':'Back To The Feature'})
> coll.find({'title':'Back To The Feature'})
> col = db.movie
baby.movie
> col.find({'title':'Back To The Feature'})
{ "_id" : ObjectId("5dcb58d3bff86222392e8ca6"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5a06e08d79942ea2184b"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5c0299c8eebebb5f6ce0"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5c105a4bbdabd53bc2f6"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5c20fc294890b9693548"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5f41a6fb86c4f3bc4d4d"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
{ "_id" : ObjectId("5dcb5f42a6fb86c4f3bc4d4e"), "title" : "Back To The Feature", "year" : 1985, "actors" : [ "Michael J. Fox", "Christopher Lloyd" ], "imdb" : { "imdb_id" : "tt0088763", "rating" : 8.5 } }
>

最后还发现这个文档这里的一个坑，mongodb的配置如果按照下面的写法


app.config['MONGODB_SETTINGS'] = {
 'db': 'baby'
}

会报错提示如下错误

MongoEngineConnectionError: You have not defined a default connection

改为如下可正常运行


app.config['MONGODB_SETTINGS'] = {
 'db': 'baby',
 'alias': 'default'
}

刚刚又遇到一个问题

在使用get_or_404()这个方法的时候，居然报404错误，但是如果去掉get_or_404()，直接使用如下代码


movies = Movie.objects(title='Back To The Feature')

然后将数据渲染到前端居然可以获取到数据，是不是说，不需要使用get_or_404()还是说我使用的方法错误了，应该还需要做些什么操作。


return render_template('langcode/me.j2', movies=movies)

渲染的html代码如下


{% extends "base.j2" %}

{% block content %}
 {% for movie in movies %}
 <p>{{ movie.id }}</p>
 <p>{{ movie.title }}</p>
 <p>{{ movie.year }}</p>
 <p>{{ movie.imdb.rating }}</p>
 {% endfor %}
{% endblock %}

Flask 1.0 - AttributeError: 'DispatcherMiddleware' object has no attribute 'config'

Tue, 29 Jul 2025 10:56:26 +0800

Flask 1.0使用过程中遇到“AttributeError: ‘DispatcherMiddleware’ object has no attribute ‘config’”，官方的文档暂时还没更新，这里经过资料搜集，暂时有了一个可使用的解决方案。

最近在偷偷的自学Flask，一边看文档，一边实践，发现了一些小问题。

官方文档在“绑定应用”的章节实例代码如下


from werkzeug.middleware.dispatcher import DispatcherMiddleware
from frontend_app import application as frontend
from backend_app import application as backend

application = DispatcherMiddleware(frontend, {
 '/backend': backend
})

但是在经过测试后运行报错了


Server initialized for eventlet.
Traceback (most recent call last):
 File "wsgi.py", line 12, in <module>
 socketio.run(application, debug=True)
 File "/Users/durban/python/baby/.env3_baby/lib/python3.7/site-packages/flask_socketio/__init__.py", line 498, in run
 server_name = app.config['SERVER_NAME']
AttributeError: 'DispatcherMiddleware' object has no attribute 'config'

可以看出错误的问题属性没有了

https://stackoverflow.com/questions/36219842/flask-app-wrapped-with-dispatchermiddleware-no-longer-has-test-client

于是在这里找到了答案

最后的实例使用方法如下


from baby_backend import application as backend
from werkzeug.middleware.dispatcher import DispatcherMiddleware

app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {
 '/backend': backend
})

这里的baby_backend是个package

实战记录 - Flask中使用SQLAlchemy创建Model，实现“一对多”、“多对多”的方式

Tue, 29 Jul 2025 10:56:22 +0800

Flask中使用SQLAlchemy创建Model，实现“一对多”、“多对多”的方式

Flask==0.12.2 Flask-SQLAlchemy==2.3.2

实现“一对多”的情况

一个帖子对应一个分类，一个分类对应多个贴子

使用backref的方式如下

分类模型


class Category(db.Model):
 '''分类'''
 __tablename__ = 'category'

 id = db.Column(db.Integer, primary_key=True)
 title = db.Column(db.String(100), unique=True)

 def __repr__(self):
 return '<Category %r>' % self.title

帖子模型


class Article(db.Model):
 ''' 帖子'''
 __tablename__ = 'article'

 id = db.Column(db.Integer, primary_key=True, doc='自增id')
 title = db.Column(db.String(100), unique=True, doc='标题')
 content = db.Column(db.Text, doc='描述内容')
 user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
 category_id = db.Column(db.Integer, db.ForeignKey('category.id'))

 # 这里是关键点 通过使用backref的方式
 category = db.relationship('Category', backref='article')

 def __repr__(self):
 return '<Article %r>' % self.title

使用back_populates的方式如下

分类模型


class Category(db.Model):
 '''分类'''
 __tablename__ = 'category'

 id = db.Column(db.Integer, primary_key=True)
 title = db.Column(db.String(100), unique=True)
 # 这里是关键点 通过使用backref的方式
 article = db.relationship('Article', back_populates='back_populates')

 def __repr__(self):
 return '<Category %r>' % self.title

帖子模型


class Article(db.Model):
 ''' 帖子'''
 __tablename__ = 'article'

 id = db.Column(db.Integer, primary_key=True, doc='自增id')
 title = db.Column(db.String(100), unique=True, doc='标题')
 content = db.Column(db.Text, doc='描述内容')
 user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
 category_id = db.Column(db.Integer, db.ForeignKey('category.id'))

 # 这里是关键点 通过使用backref的方式
 category = db.relationship('Category', back_populates='article')

 def __repr__(self):
 return '<Article %r>' % self.title

实现“多对多”的情况

一个帖子对应多个标签，一个标签对应多个贴子

需要建立一个中间表

帖子标签关联表配置


ARTICLE_TAGS = db.Table('article_tags',
 db.Column('tag_id', db.Integer,
 db.ForeignKey('tags.id')),
 db.Column('article_id', db.Integer,
 db.ForeignKey('article.id'))
 )

帖子模型


class Article(db.Model):
 '''帖子'''
 __tablename__ = 'article'

 id = db.Column(db.Integer, primary_key=True, doc='自增id')
 title = db.Column(db.String(100), unique=True, doc='标题')
 content = db.Column(db.Text, doc='描述内容')
 user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
 category_id = db.Column(db.Integer, db.ForeignKey('category.id'))

 # 多对多的关联配置
 tags = db.relationship(
 'Tag',
 secondary=ARTICLE_TAGS,
 backref=db.backref('article', lazy='dynamic'))

 def __repr__(self):
 return '<Article %r>' % self.title

标签模型


class Tag(db.Model):
 '''标签'''
 __tablename__ = 'tags'

 def __init__(self, title):
 self.title = title

 id = db.Column(db.Integer, primary_key=True)
 title = db.Column(db.String(100))

疑问article_tags这个需要建表吗

答：当然需要，不然怎么存储多对多的关联呢

Flask 1.0 进阶 - 具有Blueprint的模块化应用程序

Tue, 29 Jul 2025 10:56:19 +0800

具有Blueprint的模块化应用程序

Flask使用蓝图概念来制作应用程序组件，并在应用程序或应用程序中支持常见模式。蓝图可以极大地简化大型应用程序的工作方式，并为Flask扩展提供注册应用程序操作的核心方法。 Blueprint 对象与 Flask 应用程序对象的工作方式类似，但它实际上并不是一个应用程序。相反，它是如何构建或扩展应用程序的蓝图。

为何选择蓝图？

Flask中的蓝图适用于以下情况：

将应用程序纳入一组蓝图中。这是大型应用的理想选择;项目可以实例化一个应用程序对象，初始化几个扩展，并注册一组蓝图。
在URL前缀和/或子域中的应用程序上注册蓝图。URL前缀/子域中的参数成为蓝图中所有视图函数的公共视图参数（具有默认值）。
在具有不同URL规则的应用程序上多次注册蓝图。
通过蓝图提供模板过滤器，静态文件，模板和其他实用程序。蓝图不必实现应用程序或查看功能。
在初始化Flask扩展时，在应用程序中为任何这些情况注册蓝图。

Flask中的蓝图不是一个可插拔的应用程序，因为它实际上不是一个应用程序 - 它是一组可以在应用程序上注册的操作，甚至多次。为什么没有多个应用程序对象？您可以这样做（请参阅应用程序调度），但您的应用程序将具有单独的配置，并将在WSGI层进行管理。

相反，蓝图在Flask级别提供分离，共享应用程序配置，并且可以根据需要在注册时更改应用程序对象。缺点是，一旦创建应用程序，您无法取消注册蓝图，而不必销毁整个应用程序对象。

蓝图的概念

蓝图的基本概念是它们记录在应用程序上注册时要执行的操作。在分派请求和从一个端点到另一个端点生成URL时，Flask将视图函数与蓝图相关联。

我的第一份蓝图

这是一个非常基本的蓝图。在这种情况下，我们希望实现一个简单渲染静态模板的蓝图：


from flask import Blueprint, render_template, abort
from jinja2 import TemplateNotFound

simple_page = Blueprint('simple_page', __name__,
 template_folder='templates')

@simple_page.route('/', defaults={'page': 'index'})
@simple_page.route('/<page>')
def show(page):
 try:
 return render_template('pages/%s.html' % page)
 except TemplateNotFound:
 abort(404)

在@simple_page.route装饰器的帮助下绑定函数时，蓝图将记录在应用程序稍后注册时在应用程序上注册函数show的意图。此外，它将为函数的端点添加蓝图的名称，该蓝图的名称是给予 Blueprint 构造函数的（在本例中也是simple_page）。蓝图的名称不会修改URL，只会修改endpoint。

注册蓝图

那么你如何注册这个蓝图？像这样：


from flask import Flask
from yourapplication.simple_page import simple_page

app = Flask(__name__)
app.register_blueprint(simple_page)

如果您检查在应用程序上注册的规则，您会发现：


[<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
 <Rule '/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>,
 <Rule '/' (HEAD, OPTIONS, GET) -> simple_page.show>]

第一个显然来自应用程序本身的静态文件。另外两个用于simple_page蓝图的 show 函数。如您所见，它们还以蓝图的名称为前缀，并以点（.）分隔。

然而，蓝图也可以安装在不同的位置：


app.register_blueprint(simple_page, url_prefix='/pages')

然后，生成的规则对应如下：


[<Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
 <Rule '/pages/<page>' (HEAD, OPTIONS, GET) -> simple_page.show>,
 <Rule '/pages/' (HEAD, OPTIONS, GET) -> simple_page.show>]

最重要的是，您可以多次注册蓝图，但并非每个蓝图都可以正确响应。实际上，如果蓝图可以多次安装，它取决于蓝图的实现方式。

蓝图资源

蓝图也可以提供资源。有时您可能只想为其提供的资源引入蓝图。

蓝图资源文件夹

与常规应用程序一样，蓝图被认为包含在文件夹中。虽然多个蓝图可以来自同一个文件夹，但并非必须如此，通常不建议这样做。

该文件夹是从 Blueprint 的第二个参数推断出来的，通常是*name*。此参数指定哪个逻辑Python模块或包对应于蓝图。如果它指向一个实际的Python包，那么包（它是文件系统上的文件夹）就是资源文件夹。如果它是一个模块，则包含模块的包将是资源文件夹。您可以访问 Blueprint.root_path 属性以查看资源文件夹是什么：


>>> simple_page.root_path
'/Users/username/TestProject/yourapplication'

要从此文件夹快速打开源，您可以使用 open_resource() 函数：


with simple_page.open_resource('static/style.css') as f:
 code = f.read()

静态文件

蓝图可以通过使用static_folder参数提供文件系统上文件夹的路径来公开具有静态文件的文件夹。它是绝对路径或相对于蓝图的位置：


admin = Blueprint('admin', __name__, static_folder='static')

默认情况下，路径的最右边部分是它在Web上公开的位置。可以使用static_url_path参数更改此设置。因为此处的文件夹名为static，所以它将在蓝图+/static的url_prefix中提供。如果蓝图具有前缀/admin，则静态URL将为/admin/static。

endpoint名为blueprint_name.static。您可以使用 url_for() 生成URL，就像使用应用程序的静态文件夹一样：


url_for('admin.static', filename='style.css')

但是，如果蓝图没有url_prefix，则无法访问蓝图的静态文件夹。这是因为在这种情况下URL将是/static，并且应用程序的/static路由优先。与模板文件夹不同，如果应用程序静态文件夹中不存在该文件，则不会搜索蓝图静态文件夹。

模板

如果您希望蓝图公开模板，可以通过向Blueprint构造函数提供template_folder参数来实现：


admin = Blueprint('admin', __name__, template_folder='templates')

对于静态文件，路径可以是蓝图资源文件夹的绝对路径或相对路径。

模板文件夹添加到模板的搜索路径中，但优先级低于实际应用程序的模板文件夹。这样，您可以轻松覆盖蓝图在实际应用程序中提供的模板。这也意味着如果您不希望意外覆盖蓝图模板，请确保没有其他蓝图或实际应用程序模板具有相同的相对路径。当多个蓝图提供相同的相对模板路径时，注册的第一个蓝图优先于其他蓝图。

因此，如果您在yourapplication/admin中的文件夹中有蓝图，并且您希望呈现模板'admin/index.html'并且您提供了templates作为template_folder，则必须创建如下文件：yourapplication/admin/templates/admin/index.html的。额外admin文件夹的原因是为了避免在实际应用程序模板文件夹中使用名为index.html的模板覆盖我们的模板。

为了进一步重申这一点：如果你有一个名为admin的蓝图，并且你想渲染一个名为index.html的模板，这个模板是特定于这个蓝图的，那么最好的想法就是像这样布置你的模板：


yourpackage/
 blueprints/
 admin/
 templates/
 admin/
 index.html
 __init__.py

然后，当您想要渲染模板时，使用admin/index.html作为名称来查找模板。如果您在加载正确的模板时遇到问题，请启用EXPLAIN_TEMPLATE_LOADING配置变量，该变量将指示Flask打印出在每次render_template调用时定位模板的步骤。

构建网址

如果你想从一个页面链接到另一个页面，你可以使用 url_for() 函数，就像你通常只需要在URL端点前面加上蓝图的名称和点（.）：


url_for('admin.index')

此外，如果您处于蓝图或渲染模板的视图功能中并且想要链接到同一蓝图的另一个端点，则可以通过在端点前面添加一个点来使用相对重定向：


url_for('.index')

这将链接到admin.index，例如，以防当前请求被分派到任何其他管理蓝图端点。

错误处理程序

蓝图支持errorhandler装饰器，就像 Flask 应用程序对象一样，因此很容易制作特定于蓝图的自定义错误页面。

以下是“404找不到页面”异常的示例：


@simple_page.errorhandler(404)
def page_not_found(e):
 return render_template('pages/404.html')

大多数错误处理程序将按预期工作;但是，有关404和405例外处理程序的警告。这些错误处理程序仅从相应的raise语句或另一个蓝图视图函数中的abort调用中调用;例如，无效的URL访问不会调用它们。这是因为蓝图不“拥有”某个URL空间，因此如果给定无效的URL，应用程序实例无法知道它应该运行哪个蓝图错误处理程序。如果您希望基于URL前缀对这些错误执行不同的处理策略，可以使用请求代理对象在应用程序级别定义它们：


@app.errorhandler(404)
@app.errorhandler(405)
def _handle_api_error(ex):
 if request.path.startswith('/api/'):
 return jsonify_error(ex)
 else:
 return ex

有关错误处理的更多信息请参阅自定义错误页

Flask 1.0 进阶 - 请求上下文

Tue, 29 Jul 2025 10:56:14 +0800

请求上下文在请求期间跟踪请求级数据。而不是将请求对象传递给在请求期间运行的每个函数，而是访问 request 和会话代理。

这类似于应用程序上下文，它独立于请求跟踪应用程序级数据。当推送请求上下文时，推送相应的应用程序上下文。

上下文的目的

当 Flask 应用程序处理请求时，它会根据从WSGI服务器收到的环境创建一个 Request 对象。由于worker（线程，进程或协程取决于服务器）一次只处理一个请求，因此在该请求期间可以将请求数据视为该工作者的全局请求。Flask为此使用术语context local。

Flask在处理请求时自动推送请求上下文。查看函数，错误处理程序以及在请求期间运行的其他函数将有权访问 request 代理，该代理指向当前请求的请求对象。

上下文的生命周期

当Flask应用程序开始处理请求时，它会push请求上下文，这也会push 应用程序上下文。当请求结束时，它会pop请求上下文，然后pop应用程序上下文。

上下文对于每个线程（或其他worker类型）是唯一的。request 无法传递给另一个线程，另一个线程将具有不同的上下文堆栈，并且不会知道父线程指向的请求。

上下文本地在Werkzeug中实现。有关其内部工作原理的更多信息，请参阅上下文本地。

手动推送上下文

如果您尝试在请求上下文之外访问请求或使用它的任何内容，您将收到以下错误消息：


RuntimeError: Working outside of request context.

This typically means that you attempted to use functionality that
needed an active HTTP request. Consult the documentation on testing
for information about how to avoid this problem.

通常只有在测试需要active请求的代码时才会发生这种情况。一种选择是使用test client 来模拟完整请求。或者，您可以在with块中使用test_request_context() ，并且块中运行的所有内容都可以访问请求，并填充测试数据。


def generate_report(year):
 format = request.args.get('format')
 ...

with app.test_request_context(
 '/make_report/2017', data={'format': 'short'}):
 generate_report()

如果您在代码中的其他位置看到与测试无关的错误，则很可能表示您应该将该代码移动到视图函数中。

有关如何使用交互式Python shell中的请求上下文的信息，请参阅使用命令行管理程序。

上下文如何运作

调用Flask.wsgi_app()方法来处理每个请求。它在请求期间管理上下文。在内部，请求和应用程序上下文用作堆栈，_request_ctx_stack 和_app_ctx_stack 。当上下文被压入堆栈时，依赖于它们的代理是可用的，并指向来自堆栈顶部上下文的信息

当请求开始时，创建并pushed RequestContext，如果该应用程序的上下文不是顶层上下文，则首先创建并pushes AppContext。在推送这些上下文时，current_app，g，request和session代理可用于处理请求的原始线程。

因为上下文是堆栈，所以可以推送其他上下文以在请求期间更改代理。虽然这不是一种常见的模式，但它可以在高级应用程序中使用，例如，进行内部重定向或将不同的应用程序链接在一起。

在调度请求并生成并发送响应之后，将poped请求上下文，然后popped应用程序上下文。在popped它们之前，执行teardown_request() 和teardown_appcontext() 函数。即使在发送期间发生未处理的异常，它们也会执行。

回调和错误

Flask在多个阶段调度请求，这可能会影响请求，响应以及如何处理错误。在所有这些阶段中，上下文都是活跃的。

Blueprint 可以为这些特定于blueprint的事件添加处理程序。如果blueprint拥有与请求匹配的路由，则将运行blueprint处理程序。

在每个请求之前，调用before_request() 函数。如果其中一个函数返回一个值，则跳过其他函数。返回值被视为响应，并且不调用视图函数。
如果before_request()函数未返回响应，则调用匹配路由的视图函数并返回响应。
视图的返回值将转换为实际响应对象并传递给after_request()函数。每个函数都返回一个修改的或新的响应对象。
返回响应后，弹出上下文，调用teardown_request()和teardown_appcontext()函数。即使在上面的任何点引发了未处理的异常，也会调用这些函数。

如果在拆卸函数之前引发异常，Flask会尝试将其与errorhandler()函数匹配以处理异常并返回响应。如果未找到错误处理程序，或者处理程序本身引发异常，Flask将返回通用的500内部服务器错误响应。仍然会调用拆卸函数，并传递异常对象。

如果启用了调试模式，则未处理的异常不会转换为500响应，而是传播到WSGI服务器。这允许开发服务器向交互式调试器提供回溯。

Teardown回调

teardown回调与请求分派无关，而是在popped时由上下文调用。即使在调度期间存在未处理的异常，也会调用函数，以及手动推送的上下文。这意味着无法保证请求调度的任何其他部分首先运行。请务必以不依赖于其他回调的方式编写这些函数，并且不会失败。

在测试期间，在请求结束后推迟popped上下文可能很有用，这样可以在测试函数中访问它们的数据。使用test_client()作为with块来保留上下文，直到with块退出。


from flask import Flask, request

app = Flask(__name__)

@app.route('/')
def hello():
 print('during view')
 return 'Hello, World!'

@app.teardown_request
def show_teardown(exception):
 print('after with block')

with app.test_request_context():
 print('during with block')

# teardown functions are called after the context with block exits

with app.test_client():
 client.get('/')
 # the contexts are not popped even though the request ended
 print(request.path)

# the contexts are popped and teardown functions are called after
# the client with block exists

Signals

如果signals_available为true，则发送以下信号：

request_started 在调用before_request() 函数之前发送。
在调用after_request()函数之后发送request_finished。
在开始处理异常时，但在查找或调用errorhandler() 之前发送got_request_exception 。
在调用teardown_request() 函数之后发送request_tearing_down 。

上下文保留错误

在请求结束时，将popped请求上下文，并销毁与其关联的所有数据。如果在开发过程中发生错误，则延迟销毁数据以进行调试非常有用。

当开发服务器以开发模式运行时（FLASK_ENV环境变量设置为'development'），错误和数据将被保留并显示在交互式调试器中。

可以使用 PRESERVE_CONTEXT_ON_EXCEPTION 配置控制此行为。如上所述，它在开发环境中默认为True。

不要在生产中启用 PRESERVE_CONTEXT_ON_EXCEPTION ，因为它会导致应用程序在异常时泄漏内存。

关于代理的注意事项

Flask提供的一些对象是其他对象的代理。对于每个工作线程，代理以相同的方式访问，但指向此页面中描述的绑定到幕后每个worker的唯一对象。

大多数情况下你不必关心它，但有一些例外情况，知道这个对象是一个真正的代理是很好的：

代理对象不能伪造其类型作为实际对象类型。如果要执行实例检查，则必须对要代理的对象执行此操作。
如果特定对象引用很重要，例如发送信号或将数据传递给后台线程。

如果需要访问代理的基础对象，请使用_get_current_object()方法：


app = current_app._get_current_object()
my_signal.send(app)

python升级后，如何给virtualenv里的python进行升级

Tue, 29 Jul 2025 10:56:11 +0800

如题：virtualenv的python版本是3.6.4，现在装了3.7.4，如何将virtualenv里的版本也更新到3.7.4呢？如果是3.6，那么这种跨大版本的又该如何升级到3.7呢？

这个问题我是这样解决的，其实如果python2的话我觉得是没有必要进行升级，因为使用包可能面临着必须要重新安装的情况，如果溶蚀python3的话就好解决了，从理论上上讲，同一个版本的迭代应该不会有太大的区别，除非改动太大了，这个情况的话，建议重新建立一个virtualenv比较妥当一些。

前提我本地是有一个.env3的虚拟环境的，而且现在里面的python版本指向的是一个3.6的版本


 '/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/Python' -> '/Users/durban/python/.env3/.Python'

现在我进行了覆盖式的操作


virtualenv -p /usr/local/Cellar/python/3.7.4/bin/python3 .env3

然后报错了，错误如下


unning virtualenv with interpreter /usr/local/Cellar/python/3.7.4/bin/python3
Already using interpreter /usr/local/opt/python/bin/python3.7
Using base prefix '/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7'
New python executable in /Users/durban/python/.env3/bin/python3.7
Not overwriting existing python script /Users/durban/python/.env3/bin/python (you must use /Users/durban/python/.env3/bin/python3.7)
Traceback (most recent call last):
 File "/usr/local/lib/python3.7/site-packages/virtualenv.py", line 420, in copyfile
 os.symlink(os.path.realpath(src), dest)
FileExistsError: [Errno 17] File exists: '/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/Python' -> '/Users/durban/python/.env3/.Python'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
 File "/usr/local/lib/python3.7/site-packages/virtualenv.py", line 2632, in <module>
 main()
 File "/usr/local/lib/python3.7/site-packages/virtualenv.py", line 870, in main
 symlink=options.symlink,
 File "/usr/local/lib/python3.7/site-packages/virtualenv.py", line 1156, in create_environment
 install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages=site_packages, clear=clear, symlink=symlink)
 File "/usr/local/lib/python3.7/site-packages/virtualenv.py", line 1629, in install_python
 copyfile(os.path.join(prefix, "Python"), virtual_lib, symlink)
 File "/usr/local/lib/python3.7/site-packages/virtualenv.py", line 423, in copyfile
 copy_file_or_folder(src, dest, symlink)
 File "/usr/local/lib/python3.7/site-packages/virtualenv.py", line 403, in copy_file_or_folder
 shutil.copy2(src, dest)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/shutil.py", line 266, in copy2
 copyfile(src, dst, follow_symlinks=follow_symlinks)
 File "/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7/lib/python3.7/shutil.py", line 121, in copyfile
 with open(dst, 'wb') as fdst:
FileNotFoundError: [Errno 2] No such file or directory: '/Users/durban/python/.env3/.Python'

从错误可以看出来问题在哪里，原因是因为.env3里面已经存在了一个/Users/durban/python/.env3/.Python

看下指向了哪里


$ ll .env3/.Python
lrwxr-xr-x 1 durban staff 78B 5 7 2018 .env3/.Python -> /usr/local/Cellar/python/3.6.5/Frameworks/Python.framework/Versions/3.6/Python

那试着删除下吧


$ rm .env3/.Python

删除后在执行下看看


$ virtualenv -p /usr/local/Cellar/python/3.7.4/bin/python3 .env3
Running virtualenv with interpreter /usr/local/Cellar/python/3.7.4/bin/python3
Already using interpreter /usr/local/opt/python/bin/python3.7
Using base prefix '/usr/local/Cellar/python/3.7.4/Frameworks/Python.framework/Versions/3.7'
New python executable in /Users/durban/python/.env3/bin/python3.7
Not overwriting existing python script /Users/durban/python/.env3/bin/python (you must use /Users/durban/python/.env3/bin/python3.7)
Installing setuptools, pip, wheel...
done.
Overwriting /Users/durban/python/.env3/bin/activate with new content
Overwriting /Users/durban/python/.env3/bin/activate.fish with new content
Overwriting /Users/durban/python/.env3/bin/activate.csh with new content
Overwriting /Users/durban/python/.env3/bin/activate_this.py with new content

居然初始化成功了，从结果上来看应该是没有删除我们已经安装的包的。

Flask 1.0 进阶 - 应用程序上下文

Tue, 29 Jul 2025 10:56:08 +0800

应用程序上下文在请求，CLI命令或其他活动期间跟踪应用程序级数据。而不是将应用程序传递给每个函数，而是访问current_app 和g 代理。

这类似于请求上下文，它在请求期间跟踪请求级数据。当推送请求上下文时，推送相应的应用程序上下文。

上下文的目的

Flask 应用程序对象具有诸如config 之类的属性，这些属性对于在视图和CLI命令中进行访问很有用。但是，在项目中的模块中导入app实例很容易出现循环导入问题。使用应用工厂模式或编写可重复使用的蓝图或扩展时，根本不会导入app实例。

Flask使用 应用程序上下文 解决了这个问题。您可以使用current_app 代理，而不是直接引用应用程序，该代理指向处理当前活动的应用程序。

Flask在处理请求时自动推送应用程序上下文。视图函数，错误处理程序以及在请求期间运行的其他函数将具有对 current_app 的访问权限。

使用@app.cli.command()运行在 Flask.cli 中注册的CLI命令时，Flask还会自动推送应用程序上下文。

上下文的生命周期

必要时创建并销毁应用程序上下文。当Flask应用程序开始处理请求时，它会pushes应用程序上下文和请求上下文。当请求结束时，它会pops请求上下文，然后pops应用程序上下文。通常，应用程序上下文与请求具有相同的生命周期。

有关上下文如何工作以及请求的完整生命周期的更多信息，请参阅请求上下文。

手动Push一个上下文

如果您尝试在应用程序上下文之外访问current_app 或使用它的任何内容，您将收到以下错误消息：


RuntimeError: Working outside of application context.

This typically means that you attempted to use functionality that
needed to interface with the current application object in some way.
To solve this, set up an application context with app.app_context().

如果在配置应用程序时发现错误，例如初始化扩展时，您可以手动push上下文，因为您可以直接访问app。在with块中使用 app_context() ，块中运行的所有内容都可以访问 current_app 。


def create_app():
 app = Flask(__name__)

 with app.app_context():
 init_db()

 return app

如果您在代码中的其他位置看到与配置应用程序无关的错误，则很可能表示您应将该代码移动到视图函数或CLI命令中。

存储数据

应用程序上下文是在请求或CLI命令期间存储公共数据的好地方。Flask为此提供了g object 。它是一个简单的命名空间对象，其生命周期与应用程序上下文相同。

注意：
g名称代表“全局”，但这指的是在上下文中是全局的数据。上下文结束后g上的数据丢失，并且它不是在请求之间存储数据的合适位置。使用 会话(session) 或数据库跨请求存储数据。

g的常见用途是在请求期间管理资源。

如果资源X不存在，则get_X()创建资源X，将其缓存为g.X.
如果资源存在，teardown_X()将关闭或以其他方式释放资源。它被注册为 teardown_appcontext() 处理程序。

例如，您可以使用此模式管理数据库连接：


from flask import g

def get_db():
 if 'db' not in g:
 g.db = connect_to_database()

 return g.db

@app.teardown_appcontext
def teardown_db():
 db = g.pop('db', None)

 if db is not None:
 db.close()

在请求期间，每次调用get_db()都将返回相同的连接，并在请求结束时自动关闭。

您可以使用 LocalProxy 从get_db()创建一个新的本地上下文：


from werkzeug.local import LocalProxy
db = LocalProxy(get_db)

访问db将在内部调用get_db，方法与 current_app 的工作方式相同。

如果您正在编写扩展名，则应为用户代码保留 g 。您可以将内部数据存储在上下文中，但请确保使用足够唯一的名称。使用_app_ctx_stack.top 访问当前上下文。有关更多信息，请参阅Flask Extension Development。

事件和信号

当弹出应用程序上下文时，应用程序将调用teardown_appcontext() 注册的函数。

Flask 1.0 进阶 - 可插拔视图（Pluggable Views）

Tue, 29 Jul 2025 10:56:05 +0800

Flask 0.7引入了可插拔视图，其灵感来自Django的通用视图，它们基于类而不是函数。主要目的是您可以替换部分实现，这种方式具有可自定义的可插拔视图。

基本原则

假设您有一个函数从数据库加载对象列表并呈现到模板中：


@app.route('/users/')
def show_users(page):
 users = User.query.all()
 return render_template('users.html', users=users)

这是简单而灵活的，但如果您想以通用方式提供此视图，以便适应其他模型和模板，您可能需要更多灵活性。这是可插入的基于类的视图的地方。作为将此转换为基于类的视图的第一步，您将执行此操作：


from flask.views import View

class ShowUsers(View):

 def dispatch_request(self):
 users = User.query.all()
 return render_template('users.html', objects=users)

app.add_url_rule('/users/', view_func=ShowUsers.as_view('show_users'))

正如您所看到的，您要做的是创建 flask.views.View 的子类并实现 dispatch_request() 。然后我们必须使用 as_view() 类方法将该类转换为实际的视图函数。传递给该函数的字符串是视图随后具有的端点的名称。但这本身并没有用，所以让我们稍微重构一下代码：


from flask.views import View

class ListView(View):

 def get_template_name(self):
 raise NotImplementedError()

 def render_template(self, context):
 return render_template(self.get_template_name(), **context)

 def dispatch_request(self):
 context = {'objects': self.get_objects()}
 return self.render_template(context)

class UserView(ListView):

 def get_template_name(self):
 return 'users.html'

 def get_objects(self):
 return User.query.all()

这当然对这样一个小例子没那么有用，但它足以解释基本原理。当你有一个基于类的视图时，问题出现在self指向的位置。这种方式的工作方式是每当调度请求时，都会创建一个新的类实例，并使用URL规则中的参数调用 dispatch_request() 方法。使用传递给 as_view() 函数的参数来实例化类本身。例如，你可以写一个这样的类：


class RenderTemplateView(View):
 def __init__(self, template_name):
 self.template_name = template_name
 def dispatch_request(self):
 return render_template(self.template_name)

然后你可以像这样注册：


app.add_url_rule('/about', view_func=RenderTemplateView.as_view(
 'about_page', template_name='about.html'))

方法提示

通过使用route()或更好的add_url_rule()，可插拔视图像常规函数一样附加到应用程序。但是，这也意味着您必须在附加此视图时提供视图支持的HTTP方法的名称。为了将该信息移动到类，您可以提供具有以下信息的方法属性：


class MyView(View):
 methods = ['GET', 'POST']

 def dispatch_request(self):
 if request.method == 'POST':
 ...
 ...

app.add_url_rule('/myview', view_func=MyView.as_view('myview'))

基于方法的调度

对于RESTful API，为每个HTTP方法执行不同的功能特别有用。使用 flask.views.MethodView ，您可以轻松地做到这一点。每个HTTP方法都映射到一个具有相同名称的函数（只是小写）：


from flask.views import MethodView

class UserAPI(MethodView):

 def get(self):
 users = User.query.all()
 ...

 def post(self):
 user = User.from_form_data(request.form)
 ...

app.add_url_rule('/users/', view_func=UserAPI.as_view('users'))

这样你就不必提供methods属性。它会根据类中定义的方法自动设置的。

装饰视图

由于视图类本身不是添加到路由系统的视图函数，因此装饰类本身没有多大意义。相反，你要么必须手工装饰as_view()的返回值：


def user_required(f):
 """Checks whether user is logged in or raises error 401."""
 def decorator(*args, **kwargs):
 if not g.user:
 abort(401)
 return f(*args, **kwargs)
 return decorator

view = user_required(UserAPI.as_view('users'))
app.add_url_rule('/users/', view_func=view)

从Flask 0.8开始，还有另一种方法可以指定要在类声明中应用的装饰器列表：


class UserAPI(MethodView):
 decorators = [user_required]

由于来自调用者视角的隐式self，您不能在视图的各个方法上使用常规视图装饰器，但请记住这一点。

API的方法视图

Web API通常与HTTP谓词密切配合，因此基于 MethodView 实现这样的API非常有意义。也就是说，您会注意到API将需要不同的URL规则，这些规则在大多数情况下都会转到相同的方法视图。例如，考虑您在Web上公开用户对象：

URL	Method	Description
/users/	GET	Gives a list of all users
/users/	POST	Creates a new user
/users/	GET	Shows a single user
/users/	PUT	Updates a single user
/users/	DELETE	Deletes a single user

那么你将如何使用 MethodView 做到这一点？诀窍是利用您可以为同一视图提供多个规则的事实。

我们暂时假设视图看起来像这样：


class UserAPI(MethodView):

 def get(self, user_id):
 if user_id is None:
 # return a list of users
 pass
 else:
 # expose a single user
 pass

 def post(self):
 # create a new user
 pass

 def delete(self, user_id):
 # delete a single user
 pass

 def put(self, user_id):
 # update a single user
 pass

那么我们如何将其与路由系统联系起来呢？通过添加两个规则并明确提到每个规则的方法：


user_view = UserAPI.as_view('user_api')
app.add_url_rule('/users/', defaults={'user_id': None},
 view_func=user_view, methods=['GET',])
app.add_url_rule('/users/', view_func=user_view, methods=['POST',])
app.add_url_rule('/users/<int:user_id>', view_func=user_view,
 methods=['GET', 'PUT', 'DELETE'])

如果你有很多类似的API，你可以重构那个注册码：


def register_api(view, endpoint, url, pk='id', pk_type='int'):
 view_func = view.as_view(endpoint)
 app.add_url_rule(url, defaults={pk: None},
 view_func=view_func, methods=['GET',])
 app.add_url_rule(url, view_func=view_func, methods=['POST',])
 app.add_url_rule('%s<%s:%s>' % (url, pk_type, pk), view_func=view_func,
 methods=['GET', 'PUT', 'DELETE'])

register_api(UserAPI, 'user_api', '/users/', pk='user_id')

Flask 1.0 进阶 - 信号(Signals)

Tue, 29 Jul 2025 10:56:01 +0800

从Flask 0.6开始，Flask中集成了对信号的支持。这种支持由优秀的 blinker 库提供，如果不可用，将优雅地退回。

什么是信号？信号通过在核心框架或其他Flask扩展中的其他位置发生操作时发送通知来帮助您解耦应用程序。简而言之，信号允许某些发送者通知订阅者发生了什么事。

Flask附带了几个信号，其他扩展可能提供更多信号。另请注意，信号旨在通知订阅者，不应鼓励订阅者修改数据。您会注意到有些信号看起来像一些内置装饰器那样做（例如： request_started 与 before_request() 非常相似）。但是，它们的工作方式存在差异。例如，核心 before_request() 处理程序以特定顺序执行，并且能够通过返回响应来提前中止请求。相反，所有信号处理程序都以未定义的顺序执行，不会修改任何数据。

信号优于处理程序的一大优势是，您可以一瞬间安全地订阅它们。例如，这些临时订阅有助于单元测试。假设您想知道哪些模板作为请求的一部分呈现：信号允许您完全执行此操作。

订阅信号

要订阅信号，您可以使用信号的 connect() 方法。第一个参数是在发出信号时应该调用的函数，可选的第二个参数指定发送者。要取消订阅信号，可以使用 disconnect() 方法。

对于所有核心Flask信号，发送方是发出信号的应用程序。订阅信号时，除非您真的想要收听来自所有应用程序的信号，否则请务必提供发件人。如果您正在开发扩展，则尤其如此。

例如，这里有一个帮助器上下文管理器，可以在单元测试中使用它来确定呈现了哪些模板以及将哪些变量传递给模板：


from flask import template_rendered
from contextlib import contextmanager

@contextmanager
def captured_templates(app):
 recorded = []
 def record(sender, template, context, **extra):
 recorded.append((template, context))
 template_rendered.connect(record, app)
 try:
 yield recorded
 finally:
 template_rendered.disconnect(record, app)

现在可以轻松地与测试客户端配对：


with captured_templates(app) as templates:
 rv = app.test_client().get('/')
 assert rv.status_code == 200
 assert len(templates) == 1
 template, context = templates[0]
 assert template.name == 'index.html'
 assert len(context['items']) == 10

确保订阅额外的**extra参数，以便在Flask为信号引入新参数时，您的调用不会失败。

现在，应用程序 app 在with块体中发出的代码中的所有模板呈现都将记录在templates变量中。每当呈现模板时，模板对象以及上下文都会附加到其上。

此外，还有一个方便的辅助方法（ connected_to() ），它允许您使用上下文管理器临时为函数订阅函数。因为无法以这种方式指定上下文管理器的返回值，所以必须将列表作为参数传递：


from flask import template_rendered

def captured_templates(app, recorded, **extra):
 def record(sender, template, context):
 recorded.append((template, context))
 return template_rendered.connected_to(record, app)

上面的例子如下所示：


templates = []
with captured_templates(app, templates, **extra):
 ...
 template, context = templates[0]

创建信号

如果要在自己的应用程序中使用信号，可以直接使用blinker库。最常见的用例是自定义 Namespace 中的命名信号。这是大多数时候建议的：


from blinker import Namespace
my_signals = Namespace()

现在您可以创建这样的新信号：


model_saved = my_signals.signal('model-saved')

此处信号的名称使其独一无二，并简化了调试。您可以使用name属性访问信号的名称。

####To扩展开发者:

如果您正在编写Flask扩展，并且希望对缺少的blinker安装进行优雅降级，则可以使用flask.signals.Namespace类来执行此操作。

发送信号

如果要发出信号，可以通过调用 send() 方法来实现。它接受发送方作为第一个参数，并可选择接收一些转发给信号订阅者的关键字参数：


class Model(object):
 ...

 def save(self):
 model_saved.send(self)

尽量选择一个好的发送者。如果您有一个发出信号的类，请将self作为发送者传递。如果从随机函数发出信号，则可以将current_app._get_current_object()作为发送方传递。

将代理作为发送者传递
永远不要将 current_app 作为发送者传递给信号。请改用current_app._get_current_object()。原因是 current_app 是代理而不是真正的应用程序对象。

信号和Flask的请求上下文

信号在接收信号时完全支持请求上下文。在 request_started 和 request_finished 之间始终可以使用上下文局部变量，因此您可以根据需要依赖于 flask.g 和其他变量。请注意发送信号和 request_tearing_down 信号中描述的限制。

基于装饰器的信号订阅

使用Blinker 1.1，您还可以使用新的 connect_via() 装饰器轻松订阅信号：


from flask import template_rendered

@template_rendered.connect_via(app)
def when_template_rendered(sender, template, context, **extra):
 print 'Template %s is rendered with %s' % (template.name, context)

核心信号

查看信号以获取所有内置信号的列表。

Flask 1.0 进阶 - 配置处理

Tue, 29 Jul 2025 10:55:58 +0800

应用程序需要某种配置。您可能希望更改不同的设置，具体取决于应用程序环境，例如切换调试模式，设置密钥以及其他此类特定于环境的内容。

Flask的设计方式通常要求在应用程序启动时配置可用。您可以对代码中的配置进行硬编码，对于许多小型应用程序而言，实际上并不是那么糟糕，但有更好的方法。

无论您如何加载配置，都有一个可用的配置对象，它保存已加载的配置值： Flask 对象的 config 属性。这是Flask本身放置某些配置值的地方，也是扩展可以放置其配置值的地方。但这也是您可以拥有自己的配置的地方。

基础配置

config 实际上是字典的子类，可以像任何字典一样进行修改：


app = Flask(__name__)
app.config['TESTING'] = True

某些配置值也会转发到 Flask 对象，以便您可以从那里读取和写入它们：


app.testing = True

要一次更新多个密钥，可以使用 dict.update() 方法：


app.config.update(
 TESTING=True,
 SECRET_KEY=b'_5#y2L"F4Q8z\n\xec]/'
)

环境和调试功能

ENV 和 DEBUG 配置值是特殊的，因为如果在应用程序开始设置后更改，它们可能会表现不一致。为了可靠地设置环境和调试模式，Flask使用环境变量。

该环境用于指示Flask，扩展和其他程序，如Sentry，Flask正在运行的上下文。它由 FLASK_ENV 环境变量控制，默认为production。

将FLASK_ENV设置为development将启用调试模式。flask run将在调试模式下默认使用交互式调试器和重新加载器。要与环境分开控制，请使用 FLASK_DEBUG 标志。

要将Flask切换到开发环境并启用调试模式，请设置 FLASK_ENV：


export FLASK_ENV=development
flask run

建议使用上述环境变量。虽然可以在配置或代码中设置 ENV 和 DEBUG ，但强烈建议不要这样做。使用flask命令无法及早读取它们，并且某些系统或扩展可能已根据先前的值配置了自身。

内置配置值

Flask在内部使用以下配置值，这里只是简单介绍下比较常用的几个，具体的详细的配置值可以去官网查看

ENV

应用程序运行的环境。 Flask和扩展可以启用基于环境的行为，例如启用调试模式。env 属性映射到此配置键。这是由FLASK_ENV环境变量设置的，如果在代码中设置，可能不会按预期运行。

在生产环境中部署时不要启用开发模式。

默认值：'production'

DEBUG

是否启用调试模式。当使用flask run启动开发服务器时，将显示一个交互式调试器，用于未处理的异常，并在代码更改时重新加载服务器。debug 属性映射到此配置键。当ENV 为'development'并被FLASK_DEBUG环境变量覆盖时，将启用此功能。如果在代码中设置，它可能不会按预期运行。

在生产中部署时，请勿启用调试模式。

默认值：如果ENV为'development'时值为True，否则为False

TESTING

启用测试模式。异常传播而不是由应用程序的错误处理程序处理。扩展也可能会改变其行为，以方便测试。您应该在自己的测试中启用它。

默认值：False

PROPAGATE_EXCEPTIONS

异常被重新引发而不是由应用程序的错误处理程序处理。

如果没有设置，在启用了TESTING或DEBUG，则隐含为true。

默认值: None

PRESERVE_CONTEXT_ON_EXCEPTION

发生异常时不要弹出请求上下文。

如果未设置，在DEBUG为true时，则为true。这允许调试器在错误上内省请求数据，通常不需要直接设置。

默认值: None

SECRET_KEY

用于安全签名会话cookie的密钥，可用于扩展或您的应用程序的任何其他安全相关需求。它应该是一个长的随机字节串，尽管也接受unicode。例如，将其输出复制到您的配置：


python -c 'import os; print(os.urandom(16))'
b'_5#y2L"F4Q8z\n\xec]/'

提交问题或提交代码时不要泄露密钥。

默认值: None

从文件配置

如果您可以将其存储在单独的文件中，理想情况下位于实际应用程序包之外，则配置会变得更有用。这使得可以通过各种包处理工具（使用Setuptools进行部署）来打包和分发应用程序，最后修改配置文件。

所以一个常见的模式是：


app = Flask(__name__)
app.config.from_object('yourapplication.default_settings')
app.config.from_envvar('YOURAPPLICATION_SETTINGS')

首先从 yourapplication.default_settings 模块加载配置，然后使用YOURAPPLICATION_SETTINGS环境变量指向的文件内容覆盖值。在启动服务器之前，可以使用shell中的export命令在Linux或OS X上设置此环境变量：


$ export YOURAPPLICATION_SETTINGS=/path/to/settings.cfg
$ python run-app.py
 * Running on http://127.0.0.1:5000/
 * Restarting with reloader...

在Windows系统上使用内置的 set 代替：


>set YOURAPPLICATION_SETTINGS=\path\to\settings.cfg

配置文件本身就是实际的Python文件。以后只有大写的值实际存储在配置对象中。因此，请确保为配置键使用大写字母。

以下是配置文件的示例：


# Example configuration
DEBUG = False
SECRET_KEY = b'_5#y2L"F4Q8z\n\xec]/'

确保尽早加载配置，以便扩展能够在启动时访问配置。配置对象上还有其他方法可以从单个文件加载。有关完整参考，请阅读 Config 对象的文档。

从环境变量配置

除了使用环境变量指向配置文件之外，您可能会发现直接从环境控制配置值很有用（或必要）。

在启动服务器之前，可以使用shell中的export命令在Linux或OS X上设置环境变量：


$ export SECRET_KEY='5f352379324c22463451387a0aec5d2f'
$ export MAIL_ENABLED=false
$ python run-app.py
 * Running on http://127.0.0.1:5000/

在Windows系统上使用内置的set代替：


>set SECRET_KEY='5f352379324c22463451387a0aec5d2f'

虽然这种方法很容易使用，但重要的是要记住环境变量是字符串 - 它们不会自动反序列化为Python类型。

以下是使用环境变量的配置文件的示例：


import os

_mail_enabled = os.environ.get("MAIL_ENABLED", default="true")
MAIL_ENABLED = _mail_enabled.lower() in {"1", "t", "true"}

SECRET_KEY = os.environ.get("SECRET_KEY")

if not SECRET_KEY:
 raise ValueError("No SECRET_KEY set for Flask application")

请注意，除了空字符串之外的任何值都将被解释为Python中的布尔值True，如果环境显式设置了值为False的值，则需要注意。

确保尽早加载配置，以便扩展能够在启动时访问配置。配置对象上还有其他方法可以从单个文件加载。有关完整参考，请阅读 Config 类文档。

配置最佳实践

前面提到的方法的缺点是它使测试更加困难。一般来说，这个问题没有单一的100％解决方案，但是您可以记住以下几点来改善这种体验：

在函数中创建应用程序并在其上注册blueprint。这样，您可以创建应用程序的多个实例，并附加不同的配置，这使得单元测试变得更加容易。您可以根据需要使用它来传递配置。
不要在导入时编写需要配置的代码。如果您将自己限制为仅对请求进行配置访问，则可以根据需要稍后重新配置对象。

开发/生产

大多数应用程序需要多个配置。生产服务器和开发期间使用的配置至少应该是单独的配置。处理此问题的最简单方法是使用始终加载的默认配置和版本控制的一部分，以及根据上述示例中提到的必要覆盖值的单独配置：


app = Flask(__name__)
app.config.from_object('yourapplication.default_settings')
app.config.from_envvar('YOURAPPLICATION_SETTINGS')

然后你只需要添加一个单独的config.py文件并导出YOURAPPLICATION_SETTINGS=/path/to/config.py就完成了。然而，也有其他方法。例如，您可以使用导入或子类化。

Django世界中非常流行的是通过将yourapplication.default_settings import *添加到文件顶部然后手动覆盖更改，在配置文件中显式导入。您还可以检查环境变量，如YOURAPPLICATION_MODE，并将其设置为生产，开发等，并根据该变量导入不同的硬编码文件。

一个有趣的模式也是使用类和继承进行配置：


class Config(object):
 DEBUG = False
 TESTING = False
 DATABASE_URI = 'sqlite:///:memory:'

class ProductionConfig(Config):
 DATABASE_URI = 'mysql://user@localhost/foo'

class DevelopmentConfig(Config):
 DEBUG = True

class TestingConfig(Config):
 TESTING = True

要启用此类配置，您只需调用from_object()：


app.config.from_object('configmodule.ProductionConfig')

请注意，from_object()不会实例化类对象。如果需要实例化类，例如访问属性，则必须在调用from_object()之前执行此操作：


from configmodule import ProductionConfig
app.config.from_object(ProductionConfig())

# Alternatively, import via string:
from werkzeug.utils import import_string
cfg = import_string('configmodule.ProductionConfig')()
app.config.from_object(cfg)

实例化配置对象允许您在配置类中使用@property：


class Config(object):
 """Base config, uses staging database server."""
 DEBUG = False
 TESTING = False
 DB_SERVER = '192.168.1.56'

 @property
 def DATABASE_URI(self): # Note: all caps
 return 'mysql://user@{}/foo'.format(self.DB_SERVER)

class ProductionConfig(Config):
 """Uses production database server."""
 DB_SERVER = '192.168.19.32'

class DevelopmentConfig(Config):
 DB_SERVER = 'localhost'
 DEBUG = True

class TestingConfig(Config):
 DB_SERVER = 'localhost'
 DEBUG = True
 DATABASE_URI = 'sqlite:///:memory:'

有许多不同的方法，由您决定如何管理配置文件。不过这里列出了很好的建议：

在版本控制中保留默认配置。使用此默认配置填充配置，或者在覆盖值之前将其导入您自己的配置文件中。
使用环境变量在配置之间切换。这可以从Python解释器外部完成，并使开发和部署变得更加容易，因为您可以快速轻松地在不同的配置之间切换而无需触摸代码。如果您经常在不同的项目上工作，您甚至可以创建自己的源代码脚本来激活virtualenv并为您导出开发配置。
在生产中使用类似fabric的工具将代码和配置分别推送到生产服务器。有关如何执行此操作的一些详细信息，请转到使用Fabric进行部署模式。

实例文件夹

Flask 0.8引入了实例文件夹。Flask很长一段时间可以直接引用相对于应用程序文件夹的路径（通过 Flask.root_path ）。这也是有很多开发人员加载了存储在应用程序旁边的配置。不幸的是，这只适用于应用程序不是包的情况，在这种情况下根路径引用包的内容。

随着Flask 0.8引入了一个新属性： Flask.instance_path 。它指的是一个名为“实例文件夹”的新概念。实例文件夹旨在不受版本控制，并且是特定于部署的。它是丢弃在运行时或配置文件中更改的东西的理想场所。

您可以在创建Flask应用程序时显式提供实例文件夹的路径，也可以让Flask自动检测实例文件夹。对于显式配置，请使用 instance_path 参数：


app = Flask(__name__, instance_path='/path/to/instance/folder')

请记住，提供时此路径必须是绝对的。

如果未提供 instance_path 参数，则使用以下默认位置：

未安装模块：


/myapp.py
/instance

未安装包：


/myapp
 /__init__.py
/instance

已安装的模块或包装：


$PREFIX/lib/python2.X/site-packages/myapp
$PREFIX/var/myapp-instance

$PREFIX是Python安装的前缀。这可以是/usr或virtualenv的路径。您可以打印sys.prefix的值以查看前缀的设置。

由于配置对象提供了从相对文件名加载配置文件，因此我们可以通过文件名将加载更改为相对于实例路径（如果需要）。配置文件中相对路径的行为可以在“相对于应用程序根目录”（默认）到“相对于实例文件夹”之间通过 instance_relative_config 切换到应用程序构造函数：


app = Flask(__name__, instance_relative_config=True)

下面是一个完整的示例，说明如何配置Flask以从模块预加载配置，然后从实例文件夹中的文件覆盖配置（如果存在）：


app = Flask(__name__, instance_relative_config=True)
app.config.from_object('yourapplication.default_settings')
app.config.from_pyfile('application.cfg', silent=True)

可以通过 Flask.instance_path 找到实例文件夹的路径。Flask还提供了使用 Flask.open_instance_resource() 从实例文件夹中打开文件的快捷方式。

两者的示例用法：


filename = os.path.join(app.instance_path, 'application.cfg')
with open(filename) as f:
 config = f.read()

# or via open_instance_resource:
with app.open_instance_resource('application.cfg') as f:
 config = f.read()

Flask 1.0 进阶 - 日志

Tue, 29 Jul 2025 10:55:51 +0800

Flask使用标准的Python日志记录。所有与Flask相关的消息都记录在’flask’记录器命名空间下。Flask.logger返回名为“flask.app”的记录器，可用于记录应用程序的消息。


from flask import current_app

@app.route('/login', methods=['GET', 'POST'])
def login():
 if request.method == 'POST':
 username = request.form['username']
 password = request.form['password']

 db = get_db()
 error = None

 user = db.execute(
 'SELECT * FROM user WHERE username = ?', (username,)
 ).fetchone()

 if user is None:
 error = 'Incorrect username.'
 current_app.logger.info('%s logged fail', username)
 elif not check_password_hash(user['password'], password):
 app.logger.info('%s logged fail', username)
 error = 'Incorrect password.'

 if error is None:
 session.clear()
 session['user_id'] = user['id']
 current_app.logger.info('%s logged successfully', username)
 return redirect(url_for('blog.index'))

 flash(error)

 return render_template('auth/login.html')

基础配置

如果要为项目配置日志记录，则应在程序启动时尽快执行。如果在配置日志记录之前访问 app.logger ，它将添加默认处理程序。如果可能，在创建应用程序对象之前配置日志记录

此示例使用 dictConfig() 创建类似于Flask默认的日志记录配置，但所有日志除外：


from logging.config import dictConfig

dictConfig({
 'version': 1,
 'formatters': {
 'default': {
 'format': '[%(asctime)s] %(levelname)s \
in %(module)s: %(message)s ',
 }
 },
 'handlers': {
 'wsgi': {
 'class': 'logging.StreamHandler',
 'stream': 'ext://flask.logging.wsgi_errors_stream',
 'formatter': 'default'
 }
 },
 'root': {
 'level': 'INFO',
 'handlers': ['wsgi']
 }
})

app = Flask(__name__)

默认配置

如果您没有自己配置日志记录，Flask会自动将一个 StreamHandler 添加到 app.logger 。在请求期间，它将在environ ['wsgi.errors']（通常是 sys.stderr ）中写入由WSGI服务器指定的流。在请求之外，它将记录到 sys.stderr 。

移除默认的Handler

如果您在访问 app.logger 后配置了日志记录，并且需要删除默认处理程序，则可以导入和删除它：


from flask.logging import default_handler

app.logger.removeHandler(default_handler)

向管理员发送电子邮件错误

在远程服务器上运行应用程序进行生产时，您可能不会经常查看日志消息。WSGI服务器可能会将日志消息发送到文件，如果用户告诉您出错，只要检查该文件就可以了。

要主动发现和修复错误，您可以配置 logging.handlers.SMTPHandler 以在记录错误和更高错误时发送电子邮件。


import logging
from logging.handlers import SMTPHandler

mail_handler = SMTPHandler(
 (
 'server',
 'server_port'
 ),
 fromaddr='[email protected]',
 toaddrs=['[email protected]'],
 subject='Application Error',
 (
 'username',
 'password'
 )
)

mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter('[%(asctime)s] %(levelname)s \
in %(module)s: %(message)s '))

if not app.debug:
 app.logger.addHandler(mail_handler)

这要求您在同一服务器上设置SMTP服务器。有关配置处理程序的更多信息，请参阅Python文档。

注入请求信息

查看有关请求的更多信息（例如IP地址）可能有助于调试某些错误。您可以将 logging.Formatter 子类化为注入可以在消息中使用的自己的字段。您可以更改Flask的默认处理程序，上面定义的邮件处理程序或任何其他处理程序的格式化程序。


from flask.logging import default_handler

from flask import (
 has_request_context,
 request
)

def logging_common_formatter():
 class RequestFormatter(logging.Formatter):

 def format(self, record):
 if has_request_context():
 record.url = request.url
 record.remote_addr = request.remote_addr
 else:
 record.url = None
 record.remote_addr = None

 return super().format(record)

 formatter = RequestFormatter(
 '[%(asctime)s] %(remote_addr)s requested %(url)s\n'
 '%(levelname)s in %(module)s: %(message)s'
 )

 return formatter

formatter = logging_common_formatter()
mail_handler.setFormatter(formatter)
default_handler.setFormatter(formatter)

其他库

其他库可能会广泛使用日志记录，您也希望从这些日志中查看相关消息。最简单的方法是将处理程序添加到root记录器而不是仅添加应用程序记录器。


from flask.logging import default_handler

root = logging.getLogger()
root.addHandler(default_handler)
root.addHandler(mail_handler)

根据您的项目，配置您关注的每个记录器可能更有用，而不是仅配置root记录器。


for logger in (
 app.logger,
 logging.getLogger('sqlalchemy'),
 logging.getLogger('other_package'),
):
 logger.addHandler(default_handler)
 logger.addHandler(mail_handler)

Werkzeug

Werkzeug将基本请求/响应信息记录到'werkzeug'记录器。如果root记录器没有配置处理程序，Werkzeug会将 StreamHandler 添加到其记录器中。

Flask扩展

根据具体情况，扩展程序可以选择记录到app.logger或其自己的命名记录程序。有关详细信息，请参阅每个扩展的文档。

Flask 1.0 进阶 - 应用程序错误

Tue, 29 Jul 2025 10:55:48 +0800

应用程序失败，服务器失败迟早你会看到生产中的例外情况。即使您的代码100％正确，您仍会不时看到异常。为什么？因为所涉及的一切都会失败。以下是一些完美的代码可能导致服务器错误的情况：

客户端提前终止了请求，应用程序仍然从传入的数据中读取
数据库服务器挂了，无法处理查询
文件系统已满
一个硬盘崩溃了
一个后端服务器挂了
正在使用的库中出现了编程错误
服务器与另一个系统的网络连接失败

这只是您可能面临的一小部分问题。那么我们如何处理这类问题呢？默认情况下，如果您的应用程序在生产模式下运行，Flask将为您显示一个非常简单的页面，并将异常记录到 logger 中。

但是你可以做的更多，我们将介绍一些更好的设置来处理错误。

错误记录工具

如果有足够多的用户遇到错误并且通常从不查看日志文件，那么发送错误邮件（即使仅针对关键邮件）也会变得无法控制。这就是我们建议使用Sentry处理应用程序错误的原因。它可以在GitHub上作为开源项目使用，也可以作为托管版本使用，您可以免费试用。Sentry聚合重复错误，捕获完整堆栈跟踪和本地变量以进行调试，并根据新错误或频率阈值向您发送邮件。

要使用Sentry，您需要安装具有额外Flask依赖性的raven客户端：


pip install raven[flask]

然后将其添加到Flask应用中：


from raven.contrib.flask import Sentry
sentry = Sentry(app, dsn='YOUR_DSN_HERE')

或者，如果您正在使用工厂，您也可以稍后启动它：


from raven.contrib.flask import Sentry
sentry = Sentry(dsn='YOUR_DSN_HERE')

def create_app():
 app = Flask(__name__)
 sentry.init_app(app)
 ...
 return app

需要使用从Sentry安装获得的DSN值替换YOUR_DSN_HERE值。

之后故障会自动报告给Sentry，您可以从那里收到错误通知。

错误处理程序

您可能希望在发生错误时向用户显示自定义错误页面。这可以通过注册错误处理程序来完成。

错误处理程序是返回响应的普通视图函数，但它不是为路由注册，而是注册在尝试处理请求时引发的异常或HTTP状态代码。

注册

通过使用errorhandler() 装饰函数来注册处理程序。或者使用 register_error_handler() 稍后注册该函数。请记住在返回响应时设置错误代码。


@app.errorhandler(werkzeug.exceptions.BadRequest)
def handle_bad_request(e):
 return 'bad request!', 400

# or, without the decorator
app.register_error_handler(400, handle_bad_request)

werkzeug.exceptions.HTTPException 子类如 BadRequest 及其HTTP代码在注册处理程序时是可互换的。（BadRequest.code == 400）

代码无法注册非标准HTTP代码，因为Werkzeug不知道它们。相反，使用适当的代码定义 HTTPException 的子类并注册并引发该异常类。


class InsufficientStorage(werkzeug.exceptions.HTTPException):
 code = 507
 description = 'Not enough storage space.'

app.register_error_handler(InsuffcientStorage, handle_507)

raise InsufficientStorage()

可以为任何异常类注册处理程序，而不仅仅是HTTPException子类或HTTP状态代码。可以为特定类或父类的所有子类注册处理程序。

处理

当Flask在处理请求时捕获到异常时，首先按代码查找。如果没有为代码注册处理程序，则按类层次结构查找;选择最具体的处理程序。如果未注册任何处理程序，则HTTPException 子类显示有关其代码的通用消息，而其他异常则转换为通用500内部服务器错误。

例如，如果引发了 ConnectionRefusedError 的实例，并且为 ConnectionError 和 ConnectionRefusedError 注册了处理程序，则使用异常实例调用更具体的 ConnectionRefusedError 处理程序以生成响应。

在blueprint上注册的处理程序优先于在应用程序上全局注册的处理程序，假设blueprint正在处理引发异常的请求。但是，blueprint无法处理404路由错误，因为404可以在确定blueprint之前发生在路由级别。

版本0.11：处理程序的优先级取决于它们注册的异常类的特殊性，而不是它们注册的顺序

日志记录

有关如何记录异常的信息，请参阅记录，例如通过电子邮件将其发送给管理员。

调试应用程序错误

对于生产应用程序，使用应用程序错误中所述的日志记录和通知配置应用程序。本节提供了调试部署配置和深入挖掘全功能Python调试器的指针。

当有疑问时，手动运行

在为生产配置应用程序时遇到问题？如果您具有对主机的shell访问权限，请验证您是否可以从部署环境中的shell手动运行应用程序。请确保在与配置的部署相同的用户帐户下运行，以解决权限问题。您可以在生产主机上使用带有 debug = True 的Flask内置开发服务器，这有助于捕获配置问题，但 请务必在受控环境中暂时执行此操作 。不要使用 debug = True 在生产中运行。

使用调试器

为了深入挖掘，可能需要跟踪代码执行，Flask提供了一个开箱即用的调试器（参见调试模式）。如果您想使用其他Python调试器，请注意调试器会相互干扰。您必须设置一些选项才能使用您喜欢的调试器：

debug - 是否启用调试模式和捕获异常
use_debugger - 是否使用内部Flask调试器
use_reloader - 是否在异常时重新加载和分叉进程

debug必须为True（即必须捕获异常）才能使其他两个选项具有任何值。

如果您使用Aptana/Eclipse进行调试，则需要将use_debugger和use_reloader都设置为False。

一个可能有用的配置模式是在config.yaml中设置以下内容（当然，根据您的应用程序更改块）：


FLASK:
 DEBUG: True
 DEBUG_WITH_APTANA: True

然后在你的应用程序的入口点（main.py），你可以有类似的东西：


if __name__ == "__main__":
 # To allow aptana to receive errors, set use_debugger=False
 app = create_app(config="config.yaml")

 if app.debug: use_debugger = True
 try:
 # Disable Flask's debugger if external debugger is requested
 use_debugger = not(app.config.get('DEBUG_WITH_APTANA'))
 except:
 pass

 app.run(use_debugger=use_debugger, debug=app.debug,
 use_reloader=use_debugger, host='0.0.0.0')

Flask 1.0 进阶 - 测试Flask应用程序

Tue, 29 Jul 2025 10:55:45 +0800

“未经测试的东西被打破了”

这句话的起源是未知的，虽然它并不完全正确，但它也离真相不远。未经测试的应用程序使得现有代码难以改进，未经测试的应用程序的开发人员往往变得非常偏执。如果应用程序具有自动化测试，您可以安全地进行更改，并立即知道是否有任何中断。

Flask提供了一种方法来测试您的应用程序，方法是暴露Werkzeug测试Client并为您处理上下文本地。然后，您可以将其与您喜欢的测试解决方案一起使用。

在本分享中，我们将使用pytest包作为测试的基础框架。您可以使用pip安装它，如下所示：


pip install pytest

应用程序

首先，我们需要一个应用程序来测试;我们将使用教程中的应用程序。如果您还没有该应用程序，请从示例中获取源代码。

测试骨架搭建

我们首先在应用程序根目录下添加一个tests目录(如果有的话可以不用创建)。然后创建一个Python文件来存储我们的测试（test_baby.py）。当我们格式化文件名如test_*.py时，它将被pytest自动发现。

接下来，我们创建一个名为 client() 的pytest fixture，它配置应用程序以进行测试并初始化一个新的数据库，代码如下：


#! _*_ coding: utf-8 _*_
#
#

import os
import tempfile
import pytest
from baby import create_app
from baby.db import init_db, get_db

with open(os.path.join(os.path.dirname(__file__), 'data.sql'), 'rb') as f:
 _data_sql = f.read().decode('utf8')

@pytest.fixture
def client():
 db_fd, db_path = tempfile.mkstemp()

 app = create_app({
 'DATABASE': db_path,
 'TESTING': True
 })

 client = app.test_client()

 with app.app_context():
 init_db()
 get_db().executescript(_data_sql)

 yield client

 os.close(db_fd)
 os.unlink(app.config['DATABASE'])

每个单独的测试将调用此client fixture。它为我们提供了一个简单的应用程序接口，我们可以在其中触发对应用程序的测试请求。client还将为我们跟踪cookie。

在设置过程中，TESTING配置标志被激活。这样做是在请求处理期间禁用错误捕获，以便在对应用程序执行测试请求时获得更好的错误报告。

因为SQLite3是基于文件系统的，所以我们可以轻松地使用tempfile模块来创建临时数据库并对其进行初始化。mkstemp()函数为我们做了两件事：它返回一个低级文件句柄和一个随机文件名，后者我们用作数据库名。我们必须保持db_fd，以便我们可以使用 os.close() 函数来关闭文件。

要在测试后删除数据库，fixture会关闭文件并将其从文件系统中删除。

如果我们现在运行测试组件，我们应该看到以下输出：


$ pytest tests/test_baby.py
======================================== test session starts ======================================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 0 items

==================================== no tests ran in 0.05 seconds =================================

即使它没有运行任何实际测试，我们已经知道我们的flaskr应用程序在语法上是有效的，否则导入将因异常而结束。

测试数据库

现在是时候开始测试应用程序的功能了。如果我们访问应用程序的根目录（/），让我们检查应用程序是否显示“Baby”。为此，我们向test_baby.py添加了一个新的测试函数，如下所示：


def test_empty_db(client):
 rv = client.get('/')
 assert b'Baby' in rv.data

请注意，我们的测试函数以单词test开头;这允许pytest自动将函数识别为要运行的测试。

通过使用client.get，我们可以使用给定路径向应用程序发送HTTP GET请求。返回值将是response_class对象。我们现在可以使用data属性来检查应用程序的返回值（作为字符串）。在这种情况下，我们确保“No entries here so far”是输出的一部分。

再次运行它，您应该看到一个通过测试：


$ pytest -v tests/test_baby.py
======================= test session starts ========================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 1 item

tests/test_baby.py::test_empty_db PASSED [100%]

===================== 1 passed in 0.10 seconds =====================

测试登录和注销

我们的应用程序的大部分功能仅适用于管理用户，因此我们需要一种方法来将我们的测试客户端记录到应用程序中。为此，我们使用所需的表单数据（用户名和密码）向登录和注销页面发出一些请求。并且由于登录和注销页面重定向，我们告诉客户端follow_redirects

将以下类添加到test_baby.py文件中：


class AuthActions(object):
 def __init__(self, client):
 self._client = client

 def login(self, username='test', password='test'):
 return self._client.post(
 '/auth/login',
 data={'username': username, 'password': password}
 )

 def logout(self):
 return self._client.get('/auth/logout')

现在，我们可以轻松地测试登录和注销是否正常工作，以及它是否因无效凭据而失败。添加这个新的测试功能：


def test_login(client, auth):
 auth.login('test', 'test')
 with client:
 client.get('/')
 assert session['user_id'] == 1

 rv = auth.login('testx', 'test')
 print(rv.data)
 assert b'Incorrect username' in rv.data

 rv = auth.login('test', 'testx')
 print(rv.data)
 assert b'Incorrect password' in rv.data

def test_logout(client, auth):
 auth.login('test', 'test')
 with client:
 rv = auth.logout()
 assert 'user_id' not in session

再次运行测试得到如下结果


$ pytest -v tests/test_baby.py
=========================== test session starts ============================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 3 items

tests/test_baby.py::test_empty_db PASSED [ 33%]
tests/test_baby.py::test_login PASSED [ 66%]
tests/test_baby.py::test_logout PASSED [100%]

========================= 3 passed in 0.71 seconds =========================

测试添加帖子

我们还应该测试添加帖子是否有效。添加一个新的测试函数，如下所示：


def test_add_post(client, auth):
 auth.login()
 with client:
 rv = client.post('/create', data=dict(
 title='<Hello>',
 body='<strong>Html</strong> is here'
 ), follow_redirects=True)

 assert b'&lt;strong&gt;Html&lt;/strong&gt; is here' in rv.data

 assert b'&lt;Hello&gt;' in rv.data

在这里，我们检查文本中是否允许HTML，而不是标题中的HTML，这是预期的行为。

运行它现在应该给我们四个通过测试：


$ pytest -v tests/test_baby.py
=================== test session starts ====================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg
collected 4 items

tests/test_baby.py::test_empty_db PASSED [ 25%]
tests/test_baby.py::test_login PASSED [ 50%]
tests/test_baby.py::test_logout PASSED [ 75%]
tests/test_baby.py::test_add_post PASSED [100%]

================= 4 passed in 0.71 seconds =================

其他测试技巧

除了使用如上所示的测试client之外，还有test_request_context()方法，该方法可以与with语句结合使用以临时激活请求上下文。通过这种方式，您可以访问request，g和session对象，例如视图函数。以下是演示此方法的完整示例：


import flask

app = flask.Flask(__name__)

with app.test_request_context('/?name=Peter'):
 assert flask.request.path == '/'
 assert flask.request.args['name'] == 'Peter'

可以以相同的方式使用上下文绑定的所有其他对象。

如果要使用不同的配置测试应用程序并且似乎没有好的方法，请考虑切换到应用程序工厂（请参阅应用程序工厂）。

但请注意，如果使用测试请求上下文，则不会自动调用before_request()和after_request()函数。但是，当测试请求上下文离开with块时，确实执行了teardown_request()函数。如果你确实想要调用before_request()函数，你需要自己调用preprocess_request()：


app = flask.Flask(__name__)

with app.test_request_context('/?name=Peter'):
 app.preprocess_request()
 ...

根据应用程序的设计方式，这可能是打开数据库连接或类似连接所必需的。

如果要调用after_request()函数，则需要调用preprocess_request()，但是要求您将响应对象传递给它：


app = flask.Flask(__name__)

with app.test_request_context('/?name=Peter'):
 resp = Response('...')
 resp = app.process_response(resp)
 ...

这通常不太有用，因为此时您可以直接开始使用测试客户端。

伪造资源和上下文

一种非常常见的模式是在应用程序上下文或flask.g对象上存储用户授权信息和数据库连接。一般的模式是在第一次使用时将对象放在那里，然后在拆卸时将其移除。想象一下这个代码来获取当前用户：


def get_user():
 user = getattr(g, 'user', None)
 if user is None:
 user = fetch_current_user_from_database()
 g.user = user
 return user

对于测试，从外部覆盖此用户而不必更改某些代码将是很好的。这可以通过挂钩flask.appcontext_pushed信号来完成：


from contextlib import contextmanager
from flask import appcontext_pushed, g

@contextmanager
def user_set(app, user):
 def handler(sender, **kwargs):
 g.user = user
 with appcontext_pushed.connected_to(handler, app):
 yield

然后想下面这样使用它


from flask import json, jsonify

@app.route('/users/me')
def users_me():
 return jsonify(username=g.user.username)

with user_set(app, my_user):
 with app.test_client() as c:
 resp = c.get('/users/me')
 data = json.loads(resp.data)
 self.assert_equal(data['username'], my_user.username)

保持上下文环境

有时触发常规请求保持上下文环境会有所帮助，但仍会将上下文保持一段时间，以便进行额外的内省。使用Flask 0.4，可以使用带有with块的test_client()：


app = flask.Flask(__name__)

with app.test_client() as c:
 rv = c.get('/?tequila=42')
 assert request.args['tequila'] == '42'

如果您只使用不带with块的test_client()，则断言将失败并显示错误，因为请求不再可用（因为您尝试在实际请求之外使用它）。

访问和修改会话

有时，从测试客户端访问或修改会话非常有用。通常有两种方法。如果您只是想确保某个会话将某些键设置为某些值，您可以保持上下文并访问flask.session：


with app.test_client() as c:
 rv = c.get('/')
 assert flask.session['foo'] == 42

但是，这无法在发出请求之前修改会话或访问会话。从Flask 0.8开始，我们提供了一个所谓的“会话事务”，它模拟在测试客户端上下文中打开会话的相应调用并对其进行修改。在事务结束时存储会话。这与所使用的会话后端无关：


with app.test_client() as c:
 with c.session_transaction() as sess:
 sess['a_key'] = 'a value'

 # once this is reached the session was stored

请注意，在这种情况下，您必须使用sess对象而不是flask.session代理。然而，对象本身将提供相同的接口。

测试JSON API

Flask非常支持JSON，是构建JSON API的流行选择。使用JSON数据发出请求并检查响应中的JSON数据非常方便：


from flask import request, jsonify

@app.route('/api/auth')
def auth():
 json_data = request.get_json()
 email = json_data['email']
 password = json_data['password']
 return jsonify(token=generate_token(email, password))

with app.test_client() as c:
 rv = c.post('/api/auth', json={
 'username': 'flask', 'password': 'secret'
 })
 json_data = rv.get_json()
 assert verify_token(email, json_data['token'])

在测试客户端方法中传递json参数将请求数据设置为JSON序列化对象，并将内容类型设置为application/json。您可以使用get_json从请求或响应中获取JSON数据。

测试CLI命令

Click附带了用于测试CLI命令的实用程序。CliRunner独立运行命令并捕获Result对象中的输出。

Flask提供了test_cli_runner()来创建FlaskCliRunner，它自动将Flask应用程序传递给CLI。使用其invoke()方法以与从命令行调用命令相同的方式调用命令。


import click

@app.cli.command('hello')
@click.option('--name', default='World')
def hello_command(name)
 click.echo(f'Hello, {name}!')

def test_hello():
 runner = app.test_cli_runner()

 # invoke the command directly
 result = runner.invoke(hello_command, ['--name', 'Flask'])
 assert 'Hello, Flask' in result.output

 # or by name
 result = runner.invoke(args=['hello'])
 assert 'World' in result.output

在上面的示例中，按名称调用命令很有用，因为它验证命令是否已正确注册到应用程序。

如果要测试命令如何解析参数而不运行命令，请使用其make_context()方法。这对于测试复杂的验证规则和自定义类型很有用。


def upper(ctx, param, value):
 if value is not None:
 return value.upper()

@app.cli.command('hello')
@click.option('--name', default='World', callback=upper)
def hello_command(name)
 click.echo(f'Hello, {name}!')

def test_hello_params():
 context = hello_command.make_context('hello', ['--name', 'flask'])
 assert context.params['name'] == 'FLASK'

Flask 1.0 进阶 - 模板

Tue, 29 Jul 2025 10:55:42 +0800

Flask利用Jinja2作为模板引擎。你显然可以自由使用不同的模板引擎，但你仍然需要安装Jinja2来运行Flask本身。此要求是启用丰富扩展所必需的。扩展可以依赖于Jinja2存在。

本节仅简要介绍Jinja2如何集成到Flask中。如果您需要有关模板引擎语法本身的信息，请访问官方Jinja2模板文档以获取更多信息。

Jinja 设置

除非定制，否则Jinja2由Flask配置如下：

使用render_template()时，对于以.html，.htm，.xml和.xhtml结尾的所有模板启用自动过滤。
使用render_template_string()时，为所有字符串启用自动过滤。
模板可以使用{％autoescape％}标记选择使用火不适用自动过滤。
除了默认存在的值之外，Flask还将一些全局函数和帮助程序插入到Jinja2上下文中。

标准上下文

默认情况下，Jinja2模板中提供以下全局变量：

config


当前配置对象(**flask.config**)

request


当前请求对象（**flask.request**）。如果在没有活动请求上下文的情况下呈现模板，则此变量不可用。

session


当前session对象（**flask.session**）。如果在没有活动请求上下文的情况下呈现模板，则此变量不可用。


全局变量的请求绑定对象（**flask.g**）。如果在没有活动请求上下文的情况下呈现模板，则此变量不可用。

url_for()


**flask.url_for()**函数

get_flash_messages()


**flask.get_flash_messages()**函数

Jinja上下文行为

这些变量被添加到变量的上下文中，它们不是全局变量。不同之处在于，默认情况下这些不会显示在导入模板的上下文中。这部分是由性能考虑因素造成的，部分原因是为了使事情明确。

这对你意味着什么？如果您有要导入的宏，则需要访问请求对象，您有两种可能：

您将request显式的传递给macro作为参数，或您感兴趣的请求对象的属性。

你可以用"with context"导入macro。

使用上下文导入如下所示：

{% from '_helpers.html' import my_macro with context %}

标准过滤器

除了Jinja2本身提供的过滤器之外，Jinja2还提供了这些过滤器：

tojson

此函数将给定对象转换为JSON表示。例如，如果您尝试动态生成JavaScript，这将非常有用。

请注意，内部脚本标记必须不进行转义，因此如果您打算在script标记内使用它，请确保在Flask 0.10之前禁用转义|safe;


<script type=text/javascript>
	doSomethingWith({{ user.username|tojson|safe }});
</script>

控制自动过滤

自动过滤是为您自动转义特殊字符的概念。HTML（或XML，因此XHTML）意义上的特殊字符是＆，>，<，'以及"。因为这些字符本身在文档中具有特定含义，所以如果要将它们用于文本，则必须用所谓的“entities”替换它们。不这样做不仅会导致用户因无法在文本中使用这些字符而感到沮丧，而且还会导致安全问题。（请参阅跨站点脚本（XSS））。

但有时您需要在模板中禁用自动转换。如果您想要将HTML显式地插入到页面中，例如，如果它们来自生成安全HTML的系统（如HTML转换器的markdown），则可能出现这种情况。

有三种方法可以实现这一目标：

在Python代码中，将HTML字符串包装在Markup对象中，然后再将其传递给模板。这通常是推荐的方式。
在模板内部，使用|safe过滤器将字符串显式标记为安全HTML（{{myvariable | safe}}）
暂时禁用autoescape系统。

要在模板中禁用autoescape系统，您可以使用{％autoescape％}块：


{% autoescape false %}
 <p>autoescaping is disabled here
 <p>{{ will_not_be_escaped }}
{% endautoescape %}

无论何时执行此操作，请对此块中使用的变量非常谨慎。

注册过滤器

如果您想在Jinja2中注册自己的过滤器，您有两种方法可以做到这一点。您可以手动将它们放入应用程序的jinja_env中，也可以使用template_filter())装饰器。

以下两个示例的工作方式相同，都反转了一个对象：


@app.template_filter('reverse')
def reverse_filter(s):
 return s[::-1]

def reverse_filter(s):
 return s[::-1]
app.jinja_env.filters['reverse'] = reverse_filter

在装饰器的情况下，如果要将函数名称用作过滤器的名称，则参数是可选的。注册后，您可以像使用Jinja2的内置过滤器一样在模板中使用过滤器，例如，如果您在上下文中有一个名为mylist的Python列表：


{% for x in mylist | reverse %}
{% endfor %}

上下文处理器

要将新变量自动注入模板的上下文，Flask中存在上下文处理器。上下文处理器在呈现模板之前运行，并且能够将新值注入模板上下文。上下文处理器是一个返回字典的函数。然后，对于应用程序中的所有模板，此字典的键和值将与模板上下文合并：


@app.context_processor
def inject_user():
 return dict(user=g.user)

上面的上下文处理器在模板中创建了一个名为user的变量，其值为g.user。这个例子不是很有趣，因为无论如何g都可以在模板中使用，但它可以让我知道这是如何工作的。

变量不限于数值;上下文处理器也可以使函数可用于模板（因为Python允许传递函数）：


@app.context_processor
def utility_processor():
 def format_price(amount, currency=u'€'):
 return u'{0:.2f}{1}'.format(amount, currency)
 return dict(format_price=format_price)

上面的上下文处理器使format_price函数可用于所有模板：


{{ format_price(0.33) }}

您还可以将format_price构建为模板过滤器（请参阅注册过滤器），但这演示了如何在上下文处理器中传递函数。

Flask 1.0 新手教程 - 持续开发

Tue, 29 Jul 2025 10:55:39 +0800

你已经通过此教程学了一部分关于Flask和Python的概念。返回去再重新看下新手教程一步一步对比下你的代码，将您的项目与示例项目进行比较，由于本教程的逐步特性，该项目可能看起来有点不同

Flask比你到目前为止看到的要多得多。即便如此，您现在已经准备好开始开发自己的Web应用程序了。查看快速入门，了解Flask可以做些什么，然后深入了解文档以继续学习。Flask在幕后使用Jinja，Click，Werkzeug和ItsDangerous，它们都有自己的文档。您还会对Extensions感兴趣，它可以使用数据库或验证表单数据等任务变得更容易，更强大。

如果您想继续开发Baby项目，可以参考以下内容：

一个展示帖子详情的视图，点击帖子的标题跳转到这个页面
喜欢/不喜欢帖子
评论
标签。点击一个标签显示所有关于这个标签的帖子
一个搜索框，能够通过名称过滤帖子
分页。一个页面只显示5个帖子
上传图片以配合帖子。
使用Markdown格式化帖子。
新帖子的RSS提要。

玩得开心，制作更加出色的应用程序！

完结。

Flask 1.0 新手教程 - 部署到生产环境

Tue, 29 Jul 2025 10:55:35 +0800

这部分假设你有一台可以部署你应用的服务器，它概述了如何创建分发文件并进行安装，但不会详细介绍要使用的服务器或软件。您可以在开发计算机上设置新环境以尝试以下说明，但可能不应将其用于托管真实的公共应用程序。有关托管应用程序的许多不同方法的列表，请参阅部署选项。

构建和安装

如果要在其他位置部署应用程序，可以构建分发文件。Python发行版的当前标准是wheel格式，扩展名为.whl。确保首先安装了wheel库。


pip install wheel

使用Python运行setup.py为您提供了一个命令行工具来发出与构建相关的命令。bdist_wheel命令将构建一个wheel分配文件。


python setup.py bdist_wheel

运行完之后，将会在目录dist下发现一个文件baby-1.0.0-py3-none-any.whl。文件名是项目的名称，版本以及有关该文件的一些标记可以安装。

将此文件复制到另一台计算机，设置一个新的virtualenv，然后使用pip安装该文件。


pip install baby-1.0.0-py3-none-any.whl

Pip将安装您的项目及其依赖项。

由于这是一台不同的机器，因此需要再次运行init-db以在instance文件夹中创建数据库。


export FLASK_APP=baby
flask init-db

当Flask检测到它已安装（不是可编辑模式）时，它会为instance文件夹使用不同的目录。你可以在venv/var/baby-instance找到它。

配置私钥（Secret Key）

在本教程的第一篇分享中，为SECRET_KEY提供了默认值。生产环境中应该改为一些随机字节。否则，攻击者可以使用公共“dev”密钥来修改会话cookie或使用密钥的任何其他内容。

您可以使用以下命令输出随机密钥：


python -c 'import os; print(os.urandom(16))'
b'\x05\x81\xb5\xa2xln&\\\xb8\xda\xecY\x94\xef\xb5'

在instance文件夹中创建config.py文件，如果存在，工厂将从中读取该文件。将生成的值复制到其中。

venv/var/baby-instance/config.py


SECRET_KEY=b'\x05\x81\xb5\xa2xln&\\\xb8\xda\xecY\x94\xef\xb5'

你也可以在这里设置任何其他必要的配置，虽然SECRET_KEY是Baby唯一需要的配置。

运行生产环境服务器

在生产环境中而不是在开发环境中运行时，不应使用内置开发服务器（flask run）。开发服务器由Werkzeug提供以方便使用，但其设计不是特别高效，稳定或安全。

而是使用生产WSGI服务器。例如，要使用Waitress，请先在虚拟环境中安装它：


pip install waitress

您需要告诉Waitress您的应用程序，但它不像Flask运行那样使用FLASK_APP。您需要告诉它导入并调用应用程序工厂以获取应用程序对象。


waitress-serve --call 'baby:create_app'
Serving on http://0.0.0.0:8080

有关托管应用程序的许多不同方法的列表，请参阅部署选项。Waitress只是一个例子，因为它同时支持Windows和Linux。您可以为项目选择更多WSGI服务器和部署选项。

下一期继续 - 继续开发！

Flask 1.0 新手教程 - 测试覆盖率

Tue, 29 Jul 2025 10:55:32 +0800

为我们开发的程序写单元测试是为了检查我们写的代码能够按照我们希望的逻方式去运行。Flask提供了一个测试客户端来模拟请求到应用程序然后返回响应的数据。

您应该尽可能多地测试代码。函数中的代码仅在调用函数时运行，分支中的代码（如if块）仅在满足条件时运行。您希望确保使用涵盖每个分支的数据测试每个函数。

您越接近100％覆盖率，您就越容易做出改变,而这个改变不会意外地改变其他行为。但是，100％的覆盖率并不能保证您的应用程序没有错误。特别是，它不能监测到用户如何在浏览器中与应用程序交互。尽管如此，测试覆盖率是开发过程中使用的重要工具。

注意

这是在本教程后期介绍的，但在您将来的项目中，您应该在开发时进行测试。

您将使用pytest和coverage来测试和测量代码，安装命令如下：


pip install pytest coverage

Setup和Fixtures

测试代码放在了tests目录中，这个目录跟baby包同层级，不在包里面。tests/conftest.py文件包含了设置函数。tests/conftest.py文件包含每个测试将使用的称为fixture的设置函数。测试是在以test_开头的Python模块中，并且这些模块中的每个测试函数也以test_开头。

每个测试都将创建一个新的临时数据库文件，并填充将在测试中使用的一些数据。编写一个SQL文件来插入该数据。

tests/data.sql


INSERT INTO user (username, password)
VALUES
 ('test', 'pbkdf2:sha256:50000$TCI4GzcX$0de171a4f4dac32e3364c7ddc7c14f3e2fa61f2d17574483f7ffbb431b4acb2f'),
 ('other', 'pbkdf2:sha256:50000$kJPKsz6N$d2d4784f1b030a9761f5ccaeeaca413f27f2ecb76d6168407af962ddce849f79');

INSERT INTO post (title, body, author_id, created)
VALUES
 ('test title', 'test' || x'0a' || 'body', 1, '2019-01-01 00:00:00');

应用程序fixture将调用工厂并传递test_config以配置应用程序和数据库以进行测试，而不是使用本地开发配置。

tests/conftest.py


#! _*_ coding: utf-8 _*_
import os
import tempfile

import pytest
from baby import create_app
from baby.db import get_db, init_db

with open(os.path.join(os.path.dirname(__file__), 'data.sql'), 'rb') as f:
 _data_sql = f.read().decode('utf8')

@pytest.fixture
def app():
 db_fd, db_path = tempfile.mkstemp()

 app = create_app({
 'TESTING': True,
 'DATABASE': db_path
 })

 with app.app_context():
 init_db()
 get_db().executescript(_data_sql)

 yield app

 os.close(db_fd)
 os.unlink(db_path)

@pytest.fixture
def client(app):
 return app.test_client()

@pytest.fixture
def runner(app):
 return app.test_cli_runner()

tempfile.mkstemp()创建并打开一个临时文件，返回文件对象及其路径。重写DATABASE路径，因此它指向此临时路径而不是实例文件夹。设置路径后，将创建数据库表并插入测试数据。测试结束后，临时文件将被关闭并删除。

TESTING告诉Flask应用程序处于测试模式。Flask更改了一些内部行为，因此更容易测试，而其他扩展也可以使用该标志来更轻松地测试它们。

clientfixture使用appfixture创建的应用程序对象调用app.test_client()。测试将使用客户端向应用程序发出请求而不运行服务器。

runnerfixture与client类似。app.test_cli_runner()创建一个可以调用在应用程序中注册的Click命令的runner。

Pytest通过将其函数名称与测试函数中的参数名称进行匹配来使用fixture。例如，您接下来要编写的test_hello函数将使用client参数。Pytest与clientfixture函数匹配，调用它，并将返回的值传递给测试函数。

工厂

关于工厂本身的测试并不多。大多数代码都将针对每个测试执行，因此如果某些内容失败，其他测试将会受到影响。

唯一可以改变的行为是传递测试配置。如果未传递config，则应该有一些默认配置，否则应该重写配置。

tests/test_factory.py


#! _*_ coding: utf-8 _*_

from baby import create_app

def test_config():
 assert not create_app().testing
 assert create_app({'TESTING': True}).testing

def test_baby(client):
 response = client.get('/baby')
 assert response.data == b'Baby'

在本教程开头编写工厂时，您添加了baby路由作为示例。它返回“Baby”，因此测试检查响应数据是否匹配。

数据库

在应用程序上下文中，get_db应在每次调用时返回相同的连接。在上下文之后，应该关闭连接。

tests/test_db.py


#! _*_ coding: utf-8 _*_
import sqlite3

import pytest

from baby.db import get_db

def test_get_close_db(app):
 with app.app_context():
 db = get_db()
 assert db is get_db()

 with pytest.raises(sqlite3.ProgrammingError) as e:
 db.execute('SELECT 1')

 assert 'closed' in str(e)

init-db命令应调用init_db函数并输出消息。


def test_init_db_command(runner, monkeypatch):
 class Recorder(object):
 called = False

 def fake_init_db():
 Recorder.called = True

 monkeypatch.setattr('baby.db.init_db', fake_init_db)
 result = runner.invoke(args=['init-db'])
 assert 'Initialized' in result.output
 assert Recorder.called

此测试使用Pytest的monkeypatchfixture将init_db函数替换为记录它已被调用的函数。您在上面编写的runner命令用于按名称调用init-db命令。

认证

对于大多数视图，用户需要登录。在测试中执行此操作的最简单方法是使用客户端向login视图发出POST请求。您可以编写一个包含方法的类，而不是每次都写出来，并使用fixture将每个测试的客户端传递给它。

tests/conftest.py


class AuthActions(object):
 def __init__(self, client):
 self._client = client

 def login(self, username='test', password='test'):
 return self._client.post(
 '/auth/login',
 data={'username': username, 'password': password}
 )

 def logout(self):
 return self._client.get('/auth/logout')

@pytest.fixture
def auth(client):
 return AuthActions(client)

使用authfixture，您可以在测试中调用auth.login()以作为测试用户登录，该测试用户作为测试数据的一部分插入到app fixture中。

register视图应在GET上成功渲染。在具有有效表单数据的POST上，它应该重定向到登录URL，并且用户的数据应该在数据库中。无效数据应显示错误消息。

tests/test_auth.py


#! _*_ coding: utf-8 _*_

import pytest

from flask import g, session
from baby.db import get_db

def test_register(client, app):
 assert client.get('/auth/register').status_code == 200
 response = client.post(
 '/auth/register', data={'username':'a','password':'a'}
 )
 assert 'http://localhost/auth/login' == response.headers['Location']

 with app.app_context():
 assert get_db().execute(
 "SELECT * FROM user WHERE username = 'a'"
 ).fetchone() is not None

@pytest.mark.parametrize(('username', 'password', 'message'), (
 ('', '', b'Username is required'),
 ('a', '', b'Password is required'),
 ('test', 'test', b'already registered'),
))
def test_register_validate_input(client, username, password, message):
 response = client.post(
 '/auth/register',
 data={'username':username, 'password': password}
 )
 assert message in response.data

client.get()发出GET请求并返回Flask返回的Response对象。类似地，client.post()发出POST请求，将data字典转换为表单数据。

要测试页面是否渲染成功，可以发出一个简单的请求并检查200 OK状态码。如果渲染失败，Flask将返回500内部服务器错误代码。

当注册视图重定向到登录视图时，header将是一个带有登录URL的Location标头。

data包含响应的主体作为字节。如果您希望在页面上呈现某个值，请检查它是否在数据中。必须将字节与字节进行比较。如果要比较Unicode文本，请改用get_data(as_text = True)。

pytest.mark.parametrize告诉Pytest使用不同的参数运行相同的测试函数。您可以在此处使用它来测试不同的无效输入和错误消息，而无需编写相同的代码三次。

login视图的测试与register的测试非常相似。session应该在登录后设置user_id，而不是测试数据库中的数据。

tests/test_auth.py


def test_login(client, auth):
 assert client.get('/auth/login').status_code == 200
 response = auth.login()
 assert 'http://localhost/' == response.headers['Location']

 with client:
 client.get('/')
 assert session['user_id'] == 1
 assert g.user['username'] == 'test'

@pytest.mark.parametrize(('username', 'password', 'message'),(
 ('a', 'test', b'Incorrect username.'),
 ('test', 'a', b'Incorrect password.'),
))
def test_login_validate_input(auth, username, password, message):
 response = auth.login(username, password)
 assert message in response.data

在with块中使用client允许在返回响应后访问上下文变量，例如session。通常，访问请求之外的session会引发错误。

测试logout与login相反。注销后，session不应包含user_id。

tests/test_auth.py


def test_logout(client, auth):
 auth.login()
 with client:
 auth.logout()
 assert 'user_id' not in session

博客

所有博客视图都使用之前编写的auth fixture。调用auth.login()以及来自客户端的后续请求将作为测试用户登录。

index视图应显示有关随测试数据添加的帖子的信息。以作者身份登录时，应该有一个链接来编辑帖子。

还可以在测试index视图时测试更多身份验证行为。未登录时，每个页面都会显示登录或注册的链接。登录后，会有一个注销链接。

tests/test_blog.py


#! _*_ coding: utf-8 _*_

import pytest
from baby.db import get_db

def test_index(client, auth):
 response = client.get('/')
 assert b'Log In' in response.data
 assert b'Register' in response.data

 auth.login()
 response = client.get('/')

 assert b'Log Out' in response.data
 assert b'test title' in response.data
 assert b'by test on 2019-01-01' in response.data
 assert b'test\nbody' in response.data
 assert b'href="/1/update"' in response.data

create,update,delete视图必须在用户登录后才能访问，update和delete视图必须在登录的用户是帖子的作者时才能被访问，否则返回403 Forbidden状态。如果post请求是给传递的id不存在，则update和delete视图应该返回404 Not Found状态。

tests/test_blog.py


@pytest.mark.parametrize('path', (
 '/create',
 '/1/update',
 '/1/delete'
))
def test_login_required(client, path):
 response = client.post(path)
 assert 'http://localhost/auth/login' == response.headers['Location']

def test_author_required(app, client, auth):
 with app.app_context():
 db = get_db()
 db.execute(
 'UPDATE post SET author_id = 2 WHERE id = 1'
 )
 db.commit()

 auth.login()

 assert client.post('/1/update').status_code == 403
 assert client.post('/1/delete').status_code == 403

 assert b'href="/1/update"' not in client.get('/').data

@pytest.mark.parametrize('path', (
 ('/2/update'),
 ('/2/delete')
))
def test_exists_required(client, auth, path):
 auth.login()
 assert client.post(path).status_code == 404

create和update视图在GET请求时应该渲染并返回200 OK状态。当有效的数据通过POST请求提交时，create视图应该输入新的数据到数据库，update视图应该修改存在的数据。两个视图在遇到无效的数据提交时应该显示错误信息。

tests/test_blog.py


def test_create(client, auth, app):
 auth.login()
 assert client.get('/create').status_code == 200

 client.post('/create', data={'title':'created','body':''})

 with app.app_context():
 db = get_db()
 count = db.execute('SELECT COUNT(id) FROM post').fetchone()[0]
 assert count == 2

def test_update(app, client, auth):
 auth.login()
 assert client.get('/1/update').status_code == 200
 client.post('/1/update', data={'title':'updated', 'body': ''})

 with app.app_context():
 db = get_db()
 post = db.execute('SELECT * FROM post WHERE id = 1').fetchone()
 assert post['title'] == 'updated'

@pytest.mark.parametrize('path', (
 '/create',
 '/1/update'
))
def test_create_update_validate(client, auth, path):
 auth.login()
 response = client.post(path, data={'title': '', 'body': ''})
 assert b'Title is required' in response.data

delete视图应该重新到index URL，并且数据库不应该存在该帖子。

tests/test_blog.py


def test_delete(app, client, auth):
 auth.login()
 response = client.post('/1/delete')
 assert response.headers['Location'] == 'http://localhost/'

 with app.app_context():
 db = get_db()
 post = db.execute('SELECT * FROM post WHERE id = 1').fetchone()
 assert post is None

运行测试

可以将一些额外的配置添加到项目的setup.cfg文件中，这些配置不是必需的，但可以使运行测试的覆盖范围更加冗长。

setup.cfg


[tool:pytest]
testpaths = tests

[coverage:run]
branch = True
source = 
 baby

要运行测试，请使用pytest命令。它将查找并运行我们编写的所有测试函数。


$ pytest
============================== test session starts ==============================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0
rootdir: /Users/durban/python/baby, inifile: setup.cfg, testpaths: tests
collected 24 items

tests/test_auth.py ........ [ 33%]
tests/test_blog.py ............ [ 83%]
tests/test_db.py .. [ 91%]
tests/test_factory.py .. [100%]

=========================== 24 passed in 1.83 seconds ===========================
(.env3)

如果任何测试失败，pytest将显示引发的错误。您可以运行pytest -v来获取每个测试函数的列表而不是点。


$ pytest -v
===================================== test session starts ======================================
platform darwin -- Python 3.6.5, pytest-4.4.0, py-1.8.0, pluggy-0.9.0 -- /Users/durban/python/baby/.env3/bin/python3
cachedir: .pytest_cache
rootdir: /Users/durban/python/baby, inifile: setup.cfg, testpaths: tests
collected 24 items

tests/test_auth.py::test_register PASSED [ 4%]
tests/test_auth.py::test_register_validate_input[--Username is required] PASSED [ 8%]
tests/test_auth.py::test_register_validate_input[a--Password is required] PASSED [ 12%]
tests/test_auth.py::test_register_validate_input[test-test-already registered] PASSED [ 16%]
tests/test_auth.py::test_login PASSED [ 20%]
tests/test_auth.py::test_login_validate_input[a-test-Incorrect username.] PASSED [ 25%]
tests/test_auth.py::test_login_validate_input[test-a-Incorrect password.] PASSED [ 29%]
tests/test_auth.py::test_logout PASSED [ 33%]
tests/test_blog.py::test_index PASSED [ 37%]
tests/test_blog.py::test_login_required[/create] PASSED [ 41%]
tests/test_blog.py::test_login_required[/1/update] PASSED [ 45%]
tests/test_blog.py::test_login_required[/1/delete] PASSED [ 50%]
tests/test_blog.py::test_author_required PASSED [ 54%]
tests/test_blog.py::test_exists_required[/2/update] PASSED [ 58%]
tests/test_blog.py::test_exists_required[/2/delete] PASSED [ 62%]
tests/test_blog.py::test_create PASSED [ 66%]
tests/test_blog.py::test_update PASSED [ 70%]
tests/test_blog.py::test_create_update_validate[/create] PASSED [ 75%]
tests/test_blog.py::test_create_update_validate[/1/update] PASSED [ 79%]
tests/test_blog.py::test_delete PASSED [ 83%]
tests/test_db.py::test_get_close_db PASSED [ 87%]
tests/test_db.py::test_init_db_command PASSED [ 91%]
tests/test_factory.py::test_config PASSED [ 95%]
tests/test_factory.py::test_baby PASSED [100%]

================================== 24 passed in 1.94 seconds ===================================
(.env3)

要测量测试的代码覆盖率，请使用coverage命令运行pytest而不是直接运行它。


coverage run -m pytest

您可以在终端中查看简单的覆盖率报告：


coverage report


$ coverage report
Name Stmts Miss Branch BrPart Cover
----------------------------------------------------
baby/__init__.py 25 1 4 1 93%
baby/auth.py 54 0 22 0 100%
baby/blog.py 54 0 16 0 100%
baby/db.py 24 0 4 0 100%
----------------------------------------------------
TOTAL 157 1 46 1 99%
(.env3)

HTML报告允许您查看每个文件中包含的行：


coverage html

这会在htmlcov目录中生成文件。在浏览器中打开htmlcov/index.html以查看报告。

下一期继续 - 部署到生产

Flask 1.0 新手教程 - 使项目可安装

Tue, 29 Jul 2025 10:09:53 +0800

使项目可安装意味着您可以构建分发文件并将其安装在另一个环境中，就像在项目环境中安装Flask一样。这使得部署项目与安装任何其他库相同，因此您使用所有标准Python工具来管理所有内容。

安装还带来了其他一些好处，这些好处可能在教程中或作为新的Python用户不明显，包括：

目前，Python和Flask只了解如何使用baby包，因为你是从项目目录运行的。安装意味着无论您从何处运行，都可以导入它。
您可以像管理其他软件包一样管理项目的依赖项，因此请安装yourproject.whl安装它们。
测试工具可以将您的测试环境与开发环境隔离开来。

注意

这是在本教程后期介绍的，但是在您将来的项目中，您应该始终从这开始。

项目描述

setup.py文件描述了您的项目以及属于它的文件。

setup.py


#! _*_ coding: utf-8 _*_

from setuptools import find_packages, setup

setup(
 name='baby',
 version='1.0.0',
 author='张大鹏',
 author_email='[email protected]',
 packages=find_packages(),
 include_package_data=True,
 zip_safe=False,
 install_requires=[
 'flask'
 ]
)

packages告诉Python要包含哪些包目录（以及它们包含的Python文件）。find_packages()自动查找这些目录，因此您不必键入它们。要包含其他文件，例如static和templates目录，请设置include_package_data。Python需要另一个名为MANIFEST.in的文件来告诉其他数据是什么。

MANIFEST.in


include baby/schema.sql
graft baby/static
graft baby/templates
global-exclude *.pyc

这告诉Python复制static和template目录以及schema.sql文件中的所有内容，但要排除所有字节码文件。

有关所用文件和选项的其他说明，请参阅官方包装指南。

安装项目

使用pip在虚拟环境中安装项目。


pip install -e .

这告诉pip在当前目录中找到setup.py并将其安装在可编辑或开发模式下。可编辑模式意味着当您对本地代码进行更改时，如果更改有关项目的元数据（例如其依赖项），则只需重新安装。

您可以观察到项目现在已安装了pip list。


$ pip list
Package Version Location
----------------- ------- -------------------------
astroid 2.2.5
atomicwrites 1.3.0
attrs 19.1.0
autopep8 1.4.3
baby 1.0.0 /Users/durban/python/baby
Click 7.0
coverage 4.5.3
Flask 1.0.2
gunicorn 19.9.0
isort 4.3.16
itsdangerous 1.1.0
Jinja2 2.10
lazy-object-proxy 1.3.1
MarkupSafe 1.1.1
mccabe 0.6.1
more-itertools 7.0.0
pip 19.1.1
pluggy 0.9.0
py 1.8.0
pycodestyle 2.5.0
pylint 2.3.1
pytest 4.4.0
setuptools 39.0.1
six 1.12.0
typed-ast 1.3.1
waitress 1.2.1
Werkzeug 0.15.1
wheel 0.33.1
wrapt 1.11.1

到目前为止，您运行项目的方式没有任何变化。FLASK_APP仍然设置为baby并且flask run仍然运行应用程序。

下一期继续 - 测试覆盖率

Flask 1.0 新手教程 - 博客Blueprint

Tue, 29 Jul 2025 10:09:50 +0800

写博客的Blueprint跟写身份认证的Blueprint所使用的技术是一样的。博客应该列出所有的帖子，允许登录的用户去创建帖子，允许发帖用户去编辑或者删除帖子。

当我们实现每个视图的时候，请保持服务器一直处于运行状态。在保存更改时，请尝试访问浏览器中的URL并进行测试。

Blueprint

在应用程序工厂中定义blueprint并注册它

baby/blog.py


#! _*_ coding: utf-8 _*_

from flask import (
 Blueprint, flash, g, redirect, request, render_template, url_for
)

from werkzeug.exceptions import abort
from baby.auth import login_required
from baby.db import get_db

bp = Blueprint('blog', __name__)

使用app.register_blueprint()在工厂中导入并注册blueprint。放下面的代码在工厂的底部，在返回变量app之前。

baby/init.py


def create_app(test_config=None):
 # 忽略已经有的部分代码

 from . import blog
 app.register_blueprint(blog.bp)
 app.add_url_rule('/', endpoint='index')

 return app

不像身份认证blueprint，博客blueprint没有使用url_prefix，因此index视图将被放在/路由上，create视图位于/create，依此类推。博客是Baby的主要特色，因此博客索引将成为主要索引。

但是，下面定义的index视图的endpoint将是blog.index。一些身份验证视图引用了普通indexendpoint。app.add_url_rule()将endpoint名称为'index'与/url相关联，以便url_for('index')或url_for('blog.index')都可以工作，生成相同/URL的方式。

在另一个应用程序中，您可以为博客blueprint提供url_prefix，并在应用程序工厂中定义单独的index视图，类似于hello视图。然后index和blog.indexendpoint和URL会有所不同。

Index视图

index视图将显示所有的帖子，最近的一个。这里使用了JOIN，可以关联user表来获得用户的信息在结果中展示。

baby/blog.py


@bp.route('/')
def index():
 db = get_db()
 posts = db.execute(
 'SELECT p.id, title, body, created, author_id, username'
 ' FROM post p JOIN user u ON p.author_id = u.id'
 ' ORDER BY created DESC'
 ).fetchall()
 return render_template('blog/index.html', posts=posts)

baby/templates/blog/index.html


{% extends 'base.html' %}

{% block header %}
 <h1>{% block title %}Posts{% endblock %}</h1>
 {% if g.user %}
 <a class="action" href="{{url_for('blog.create')}}">New</a>
 {% endif %}
{% endblock %}

{% block content %}
 {% for post in posts %}
 <article class="post">
 <header>
 <div>
 <h1>{{ post['title'] }}</h1>
 <div class="about">by {{ post['username'] }} on {{ post['created'].strftime('%Y-%m-%d') }}
 </div>
 {% if g.user['id'] == post['author_id'] %}
 <a class="action" href="{{ url_for('blog.update', id=post['id']) }}">Edit</a>
 {% endif %}
 </header>
 <p class="body">{{ post['body'] }}</p>
 </article>
 {% if not loop.last %}
 <hr />
 {% endif %}
 {% endfor %}
{% endblock %}

当用户登录后，header部分会添加一个create视图的链接，当用户是帖子的作者，将会看到一个指向update视图的’Edit’链接。loop.last是Jinja for loops中的一个可用的特殊变量。它用于在每个帖子之后显示除最后一个之外的一行，以便在视觉上将它们分开。

Create视图

create视图与身份认证register视图的工作方式相同。显示表单，或验证发布的数据，并将帖子添加到数据库或显示错误。之前编写的login_required装饰器用于博客视图。一个用户必须在登录后才能访问这些视图，否则用户将被重定向到登录页面。

baby/blog.py


@bp.route('/create', methods=['GET', 'POST'])
@login_required
def create():
 if request.method == 'POST':
 title = request.form['title']
 body = request.form['body']
 error = None

 if not title:
 error = 'Title is required'

 if error is not None:
 flash(error)
 else:
 db = get_db()
 db.execute(
 'INSERT INTO post (title, body, author_id)'
 ' VALUES (?,?,?)',
 (title, body, g.user['id'])
 )
 db.commit()
 return redirect(url_for('blog.index'))

 return render_template('blog/create.html')

baby/templates/blog/create.html


{% extends 'base.html' %}

{% block header %}
 <h1>{% block title %}New Posts{% endblock %}</h1>
{% endblock %}

{% block content %}
 <form method="POST">
 <label for="title">Title</label>
 <input id='title' name='title' value="{{ request.form['title'] }}" required/>
 <label for="body">body</label>
 <textarea id='body' name='body' value="{{ request.form['body'] }}"></textarea>
 <input type="submit" value="Save" />
 </form>
{% endblock %}

Update视图

update和delete视图需要通过id获取post，并且检查post的作者与登录用户是否匹配。为了避免代码重复，可以写一个函数来获取post，并且每个视图都能调用。

baby/blog.py


def get_post(id, check_author=True):
 post = get_db().execute(
 'SELECT p.id, title, body, created, author_id, username'
 ' FROM post p JOIN user u ON p.author_id = u.id'
 ' WHERE p.id = ?',
 (id,)
 ).fetchone()

 if post is None:
 abort(404, "Post id {0} doesn't exist".format(id))

 if check_author and post['author_id'] != g.user['id']:
 abort(403)

 return post

abort()将引发一个返回HTTP状态代码的特殊异常。它需要一个可选的消息来显示错误，否则使用默认消息。 404意味着“Not Found”，403意味着“Forbidden”（401意味着“Unauthorized”，但是我们应该重定向到登录页面而不是返回该状态。）

定义的check_author参数，以便该函数可用于获取帖子而无需检查作者。如果您编写一个视图来显示页面上的单个帖子，用户无关紧要，因为他们没有修改帖子，这将非常有用。

baby/blog.py


@bp.route('/<int:id>/update', methods=['GET', 'POST'])
@login_required
def update(id):
 post = get_post(id)

 if request.method == 'POST':
 title = request.form['title']
 body = request.form['body']
 error = None

 if not title:
 error = 'Title is required'

 if error is not None:
 flash(error)
 else:
 db = get_db()
 db.execute(
 'UPDATE post SET title = ?, body = ?'
 ' WHERE id = ?',
 (title, body, id)
 )
 db.commit()
 return redirect(url_for('blog.index'))

 return render_template('blog/update.html', post=post)

这个视图跟前面的视图不太一样，update函数需要传递一个参数id，这对应于路径中的<int:id>。真实的URL看起来像这个/1/update/，Flask将会捕捉到1，并保证它是个int，并且传递它作为id参数。如果不是一个具体的int:而是一个<id>，获取到的参数将会是一个String。为了生成一个URL地址到update页面，url_for需要传递一个id参数，比如url_for('blog.update', id=post['id'])。这个也可以在上面的index.html中看到。

create和update视图看起来很像，最大的不同是update视图使用一个post对象并且UPDATE代替了INSERT。通过一些巧妙的重构，你可以使用一个视图和模板替换掉create和update视图，但是由于是新手教程，保持两个视图分离看起来会比较清晰。

baby/templates/blog/update.html


{% extends 'base.html' %}

{% block header %}
 <h1>{% block title %}Edit "{{ post['title'] }}"{% endblock %}</h1>
{% endblock %}

{% block content %}
 <form method="POST">
 <label for="title">Title</label>
 <input id="title" name="title" value="{{ request.form['title'] or post['title']}}" required />
 <label for="body">Body</label>
 <textarea name="body" id="body">{{ request.form['body'] or post['body'] }}</textarea>
 <input type="submit" value="Save" />
 </form>
 <hr />
 <form method="POST" action="{{url_for('blog.delete', id=post['id'])}}">
 <input class="danger" type="submit" value="Delete" onclick="return confirm('Are you sure?');" />
 </form>
{% endblock %}

{{ request.form['title'] or post['title'] }}用来选择表单中显示的数据，当表单没有被提交时，原始的post的数据将会显示，但是如果无效的表单数据被提交，我们希望显示这个错误的数据，并让用户去修改此错误，因此使用request.form['title']。request是另一个变量，可以自动在模板中使用。

Delete视图

delete视图没有自己的模板，delete按钮是update.htmls的一部分并发布到/<id>/delete网址。因此没有模板，它只是处理POST方法并且重定向到index视图。

baby/blog.py


@bp.route('/<int:id>/delete', methods=['POST'])
@login_required
def delete(id):
 get_post(id)
 db = get_db()
 db.execute(
 'DELETE FROM post where id = ?', (id,)
 )
 db.commit()
 return redirect(url_for('blog.index'))

到这里我们就已经完成了如何开发一个应用程序的新手教程，可喜可贺，花一些时间在浏览器上试试所有的功能。然而到这里在项目完成之前还是有很多要做的。

下一期继续 - 使项目可安装

Flask 1.0 新手教程 - 静态文件

Tue, 29 Jul 2025 10:09:47 +0800

身份验证视图和模板可以正常工作，但它们现在看起来很简单。可以添加一些CSS来为您构建的HTML布局添加样式。样式不会改变，因此它是静态文件而不是模板。

Flask会自动添加一个static视图，该视图采用相对于baby/static目录的路径并为其提供服务。base.html模板已经有一个指向app.css文件的链接


<link rel="stylesheet" href="{{url_for('static', filename='app.css')}}" />

除了CSS之外，其他类型的静态文件可能是具有JavaScript功能的文件或logo图像。它们都放在baby/static目录下，并用url_for('static'，filename ='...')引用。

这个教程的目标不在于教你如何写CSS，因此你只需要将下面的代码复制到baby/static/app.css文件中即可。

baby/static/app.css


html { font-family: sans-serif; background: #eee; padding: 1rem; }
body { max-width: 960px; margin: 0 auto; background: white; }
h1 { font-family: serif; color: #377ba8; margin: 1rem 0; }
a { color: #377ba8; }
hr { border: none; border-top: 1px solid lightgray; }
nav { background: lightgray; display: flex; align-items: center; padding: 0 0.5rem; }
nav h1 { flex: auto; margin: 0; }
nav h1 a { text-decoration: none; padding: 0.25rem 0.5rem; }
nav ul { display: flex; list-style: none; margin: 0; padding: 0; }
nav ul li a, nav ul li span, header .action { display: block; padding: 0.5rem; }
.content { padding: 0 1rem 1rem; }
.content > header { border-bottom: 1px solid lightgray; display: flex; align-items: flex-end; }
.content > header h1 { flex: auto; margin: 1rem 0 0.25rem 0; }
.flash { margin: 1em 0; padding: 1em; background: #cae6f6; border: 1px solid #377ba8; }
.post > header { display: flex; align-items: flex-end; font-size: 0.85em; }
.post > header > div:first-of-type { flex: auto; }
.post > header h1 { font-size: 1.5em; margin-bottom: 0; }
.post .about { color: slategray; font-style: italic; }
.post .body { white-space: pre-line; }
.content:last-child { margin-bottom: 0; }
.content form { margin: 1em 0; display: flex; flex-direction: column; }
.content label { font-weight: bold; margin-bottom: 0.5em; }
.content input, .content textarea { margin-bottom: 1em; }
.content textarea { min-height: 12em; resize: vertical; }
input.danger { color: #cc2f2e; }
input[type=submit] { align-self: start; min-width: 10em; }

您可以在示例代码中找到一个不太紧凑的style.css版本。

转到http://127.0.0.1:5000/auth/login，该页面应如下面的屏幕截图所示。

您可以从Mozilla的文档中了解有关CSS的更多信息。如果更改静态文件，请刷新浏览器页面。如果更改未显示，请尝试清除浏览器的缓存。

下一期继续 - 博客Blueprint

Flask 1.0 新手教程 - 模板

Tue, 29 Jul 2025 10:09:44 +0800

经过上篇文章，我们已经为应用程序编写了身份验证视图，当时当我们运行服务并且试着去访问其中任何一个URL的时候，将会看到TemplateNotFound的错误。那是因为视图调用了render_template()函数，但是我们还没有创建对应的模板。模板文件将被存储在baby包中的templates文件夹中。

模板是包含静态数据和动态数据占位符的文件。一个模板使用特定数据呈现以生成最终文档。Flask使用Jinja模板库来渲染模板。

在应用程序中，将使用templates去渲染将在用户浏览器上显示的HTML，在Flask中，Jinja被配置为自动转移将在HTML模板中渲染的任何数据。这意味着用户的输入将被安全的渲染，他们输入的任何字符都可能破坏HTML。例如<和>将转义为安全值，这些值在浏览器中看起来相同，但不会造成不必要的影响。

Jinja的外观和行为都很像Python。使用特殊的分隔符将Jinja语法与模板中的静态数据区分开来，{{和}}的表达式符号表示他们之间的任何内容都是将输出到最终文档。{%和%}符号表示类似if和for的控制流语句。不像Python，块由开始和结束标记表示，而不是缩进，因为块内的静态文本可以更改缩进。

基础布局

在应用程序中每个页面都有一个类似的基础布局包裹着不同的body。而不是在每个模板中编写整个HTML结构，每个模板将会继承基础布局然后重写具体的部分。

baby/templates/base.html


<!DOCTYPE html>
<title>{% block title %}{% endblock %} - Baby</title>
<link rel="stylesheet" href="{{url_for('static', filename='app.css')}}" />
<nav>
 <h1>Baby</h1>
 <ul>
 {% if g.user %}
 <li><span>{{g.user['username']}}</span></li>
 <li><a href="{{url_for('auth.logout')}}">Log Out</a></li>
 {% else %}
 <li><a href="{{url_for('auth.register')}}">Register</a></li>
 <li><a href="{{url_for('auth.login')}}">Log In</a></li>
 {% endif %}
 </ul>
</nav>
<section class="content">
 <header>
 {% block header %}{% endblock %}
 </header>
 {% for message in get_flashed_messages() %}
 <div class="flash">{{message}}</div>
 {% endfor %}
 {% block content %}{% endblock %}
</section>

g在模板中将会自动可用，基于g.user设置用户(从load_logged_in_user)，要么显示用户名和注销链接，要么显示注册和登录链接。url_for()也将会自动可用，并且被用于生成URL，而不是手动将他们写出来。

在页面title的后面，并且在content的前面，模板循环调用get_flashed_messages()返回的每个信息。您在视图中使用flash()来显示错误消息，下面的代码将显示它们。

这里的有三个被定义的块，在其他模板中将被重写。

{% block title %}将改变在浏览器标签显示的标题和窗口的标题
{% block header %}类似于title，但是会改变在页面上显示的标题
{% block content %}是每个页面的内容所在，例如登录表单或博客文章

基础模板直接在模板的目录下面。为了保持其他模板的组织，蓝图的模板将被放置在与蓝图同名的目录中

注册

baby/templates/auth/register.html


{% extends 'base.html' %}

{% block header %}
<h1>{% block title %}Register{% endblock %}</h1>
{% endblock %}

{% block content %}
<form method="POST">
 <label for="username">Username</label>
 <input name="username" id="username" required />
 <label for="password">Password</label>
 <input type="password" name="password"" id="password" required/>
 <input type="submit" value="Register" />
</form>
{% endblock %}

{% extends 'base.html' %}告诉Jinja这个模板应该替换掉基础模板中的block。所有渲染的内容都必须出现在{% block %}标记中，这些标记覆盖基础模板中的块。

这里使用的一个有用模式是将{% block title %}放在{% block header %}中。这将设置title块，然后将其值输出到header块中，这样窗口和页面就可以共享相同的标题，而不需要编写两次标题。

input标签有一个required属性，这是在告诉浏览器知道所有的输入框都填入数据才能被提交。如果用户使用的是老版本的浏览器并且不支持这个属性，或者使用了除了浏览器之外其他的工具做了请求操作，你仍然应该在视图中去验证数据。始终在服务器上完全验证数据是很重要的，即使客户机也执行一些验证。


{% extends "base.html" %}

{% block header %}
<h1>{% block title %}Login In{% endblock %}</h1>
{% endblock %}

{% block content %}
<form method="POST">
 <label for="username">Username</label>
 <input id="username" name="username" required />
 <label for="password">Password</label>
 <input type="password" id="password" name="password" required />
 <input type="submit" value="Login In" />
</form>
{% endblock %}

注册一个用户

现在身份认证模块已经写完，你可以注册一个用户。确保服务器仍在运行(如果没有运行，执行flask run)，然后访问http://127.0.0.1:5000/auth/register。试着在没有填写任何内容的情况下点击“注册”按钮，然后应该可以看到浏览器的错误提示信息。试着从register.html模板中将required属性移除，然后点击再次点击“注册”按钮。与浏览器显示错误不同，页面将重新加载，视图中的flash()将显示错误信息。

填充一个username和password，然后你将被重定向到一个登录页面，试着输入一个错误的username或者是正确的username和错误的password。如果你登录进去后，你将会得到一个错误因为还没有一个index视图去跳转。

下一期继续 - 静态文件

Flask 1.0 新手教程 - Blueprint和视图

Tue, 29 Jul 2025 10:09:41 +0800

视图函数是我们编写用于响应对应的应用程序的请求的代码。Flask使用模式将传入的请求URL与应该处理它的视图相匹配。该视图返回Flask转换后的响应数据。Flask也可以转向另一个方向，并根据其名称和参数生成视图的URL。

创建Blueprint

Blueprint是一种组织一组相关视图和其他代码的方法。他们不是直接在应用程序中注册视图和其他代码，而是使用蓝图进行注册。然后，当它在工厂功能中可用时，蓝图就会在应用程序中注册。

baby将会有两个Blueprint，一个用于身份验证功能，另一个用于博客帖子功能。每个蓝图的代码都将在一个单独的模块中。由于博客需要了解身份验证，因此首先要编写身份验证的部分。

baby/auth.py


#! _*_ coding: utf-8 _*_
import functools

from flask import (
 Blueprint, flash, g, redirect, render_template, request, session, url_for
)

from werkzeug.security import check_password_hash, generate_password_hash
from baby.db import get_db

bp = Blueprint('auth', __name__, url_prefix='/auth')

上面的代码创建了一个名为’auth’的Blueprint，像应用程序对象一样，blueprint需要知道它是在哪里定义的，因此传递一个__name__作为第二个参数。url_prefix的值将被追加到所有与blueprint有关的URLs的前面。

在工厂函数中，使用app.register_blueprint()导入并注册blueprint。放置新的代码在工厂函数末尾，在返回app之前。

baby/init.py


def create_app():
 app = ///
 # 忽略已存在的代码

 from . import auth
 app.register_blueprint(auth.bp)

 return app

身份认证功能的blueprint会有几个试图，注册新用户的视图、登录的视图、登出的视图。

第一个视图：注册

当用户访问/auth/register的URL时，register视图将返回一个HTML表单以供用户填写。当用户提交表单时，视图函数将会验证用户的输入，如果验证失败将会显示一个带有错误信息的表单，如果验证成功则创建一个新用户，并进入到登录页面。

现在我们先写一部分视图代码，在下一篇分享中，将介绍如何用模板去生成一个HTML表单。

baby/auth.py


@bp.route('/register', methods=['GET', 'POST'])
def register():
 if request.method == 'POST':
 username = request.form['username']
 password = request.form['password']
 db = get_db()
 error = None

 if not username:
 error = 'Username is required.'
 elif not password:
 error = 'Password is required.'
 elif db.execute(
 'SELECT id FROM user WHERE username = ?', (username,)
 ).fetchone() is not None:
 error = 'user {} is already registered.'.format(username)

 if error is None:
 db.execute(
 'INSERT INTO user (username, password) VALUES (?, ?)', 
 (username, generate_password_hash(password))
 )
 db.commit()
 return redirect(url_for('auth.login'))

 flash(error)

 return render_template('auth/register.html')

下面解说下这个register视图函数正在做的

@bp.route()将URL/register与register视图函数相关联。当Flask收到对/auth/register的请求时，它将调用register视图并使用返回值作为响应。
如果用户提交了表单，request.method将是'POST'，在这种情况下，请开始验证输入
request.form是一种特殊类型的dict映射，提交了表单键和值。用户将输入他们的username和password。
验证username和password不为空。
通过查询数据库并通过返回的结果验证username是否已经被注册过了。db.execute采用SQL查询?任何用户输入的占位符，以及用于替换占位符的值元组。数据库库将负责转义值，因此您不容易受到SQL注入攻击。

fetchone()从查询中返回一行。如果查询没有返回结果，它会返回None。稍后，使用fetchall()，它返回所有结果的列表。
如果验证成功了则插入新用户的数据到数据库。为了安考虑，密码永远都不要用明文还自己存储，而是使用generate_password_hash()安全地将明文密码机型哈希处理，然后存储哈希值。由于此查询修改数据，因此需要在之后调用db.commit()以保存更改。
存储用户之后，被重定向到登录页面。url_for()根据其名称生成一个登录视图URL。这比直接编写URL更好，因为它允许您稍后更改URL而不更改链接到它的所有代码。redirect()生成对生成的URL的重定向响应。
如果验证失败，错误信息将被显示给用户。flash()存储的信息，在模板渲染的时候能被检索出来。
当用户最初导航到auth/register，或者存在验证错误时，应显示带有注册表单的HTML页面。render_template()将呈现包含HTML的模板，您将在本教程的下一步中编写该模板。

第二个视图：登录

该视图遵循与上面的register视图相同的模式。

baby/auth.py


@bp.route('/login', methods=['GET','POST'])
def login():
 if request.method == 'POST':
 username = request.form['username']
 password = request.form['password']

 db = get_db()
 error = None

 user = db.execute(
 'SELECT * FROM user WHERE username = ?', (username,)
 ).fetchone()

 if user is None:
 error = 'Incorrect username.'
 elif not check_password_hash(user['password'], password):
 error = 'Incorrect password.'

 if error is None:
 session.clear()
 session['user_id'] = user['id']
 return redirect(url_for('blog.index'))

 flash(error)

 return render_template('auth/login.html')

这个视图与register视图有一些不同之处：

首先查询用户并将其存储在变量中以供以后使用。
check_password_hash()以存储的哈希相同的方式哈希处理提交的密码并安全地比较它们。如果匹配，则密码有效。
session是一个跨请求存储数据的字典。验证成功后，用户的id将存储在新会话中。数据存储在发送到浏览器的cookie中，然后浏览器将其与后续请求一起发回。Flask安全地对数据进行签名，以便不会被篡改。

现在用户的id存储在会话中，它将在后续请求中可用。在每个请求开始时，如果用户已登录，则应加载其信息并使其可供其他视图使用。

baby/auth.py


@bp.before_app_request
def load_logged_in_user():
 user_id = session.get('user_id')

 if user_id is None:
 g.user = None
 else:
 g.user = get_db().execute(
 'SELECT * FROM user WHERE id = ?', (user_id,)
 ).fetchone()

bp.before_app_request()注册一个在视图函数之前运行的函数，无论请求什么URL。load_logged_in_user检查用户id是否存储在session中并从数据库中获取该用户的数据，并将其存储在g.user上，该持续时间为请求的长度。如果没有用户ID，或者id不存在，则g.user将为None。

第三个视图：登出/退出

要注销，需要从会话中删除用户ID。然后load_logged_in_user将不会在后续请求中加载用户。

baby/auth.py


@bp.route('/logout', methods=['GET'])
def logout():
 session.clear()
 return redirect(url_for('blog.index'))

在其他视图中需要身份验证

创建，编辑和删除博客帖子将需要用户登录。装饰器可用于检查它应用于的每个视图。

baby/auth.py


def login_required(view):
 @functools.wraps(view)
 def wrapped_view(**kwargs):
 if g.user is None:
 return redirect(url_for('auth.login'))

 return view(**kwargs)

 return wrapped_view

这个装饰器返回一个新的视图函数，它包装了它应用的原始视图。新函数检查用户是否已加载，未加载的话将重定向到登录页面。如果加载了用户，则调用原始视图并继续正常运行。在编写博客视图时，您将使用此装饰器。

Endpoint和URL

url_for()函数根据名称和参数生成视图的URL。与视图关联的名称也称为endpoint，默认情况下，它与视图函数的名称相同。

例如，在本教程前面添加到app工厂的hello()视图名为'hello'，可以链接到url_for('hello')。如果这个视图函数带了一个参数，这部分将在后面的教程中看到，他将被连接到url_for('hello', who='World')。

使用blueprint时，blueprint的名称将附加到函数的名称前面，因此上面写入的登录函数的endpoint是'auth.login'，因为我们将其添加到'auth' blueprint中。

下一期继续 - 模板

Flask 1.0 新手教程 - 定义和访问数据库

Tue, 29 Jul 2025 10:09:38 +0800

本教程的应用程序将使用SQLite数据库来存储用户和帖子，Python在sqlite3模块中内置了对SQLite的支持

SQLite是很方便的，因为他不需要设置单独的数据库服务器并且内置与Python中。然而如果并发请求同时试着写入数据，随着每次写入顺序发生，它们会变慢。

小应用程序不会注意到这一点。一旦变大，您可能希望切换到其他数据库。

本教程不会详细介绍SQL。如果您不熟悉它，SQLite文档会描述该语言。

连接数据库

使用SQLite数据库（以及大多数其他Python数据库）时要做的第一件事就是创建一个连接。使用连接执行任何查询和操作，该连接在工作完成后关闭。

在Web应用程序中，此连接通常与请求相关联。它在处理请求时在某个时刻创建，并在发送响应之前关闭。

baby/db.py


#! _*_ coding: utf-8 _*_
import sqlite3

import click
from flask import current_app, g
from flask.cli import with_appcontext

def get_db():
 if 'db' not in g:
 g.db = sqlite3.connect(
 current_app.config['DATABASE'],
 detect_types=sqlite3.PARSE_DECLTYPES
 )
 g.db.row_factory = sqlite3.Row

 return g.db

def close_db(e=None):
 db = g.pop('db', None)

 if db is not None:
 db.close()

g是一个特殊对象，对每个请求都是唯一的。它用于存储请求期间可能由多个函数访问的数据。

如果在同一请求中第二次调用get_db，则会存储并重用连接，而不是创建新连接。

current_app是另一个指向处理请求的Flask应用程序的特殊对象。由于您使用的是应用程序工厂，因此在编写其余代码时没有应用程序对象。创建应用程序并处理请求时将调用get_db，因此可以使用current_app

sqlite3.connect()建立与DATABASE配置键指向的文件的连接。此文件尚不存在，并且在您稍后初始化数据库之前不会存在。

sqlite3.Row告诉连接返回行为类似于dicts的行。这允许按名称访问列。

close_db通过检查是否已设置g.db来检查是否创建了连接。如果连接存在，则关闭。再往下，您将告诉您的应用程序有关应用程序工厂中的close_db函数，以便在每次请求后调用它。

建表

在SQLite中，数据存储在表和列中。这些需要在存储和检索数据之前创建。Baby项目将用户存储在用户表中，并在post表中存储帖子。使用创建空表所需的SQL命令创建一个文件：

baby/schema.sql


DROP TABLE IF EXISTS user;
DROP TABLE IF EXISTS post;

CREATE TABLE user (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 username TEXT UNIQUE NOT NULL,
 password TEXT NOT NULL
);

CREATE TABLE post (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 author_id INTEGER NOT NULL,
 created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
 title TEXT NOT NULL,
 body TEXT NOT NULL,
 FOREIGN KEY (author_id) REFERENCES user (id)
)

将运行这些SQL命令的Python函数添加到db.py文件中：

baby/db.py


def init_db():
 db = get_db()

 with current_app.open_resource('schema.sql') as f:
 db.executescript(f.read().decode('utf8'))

@click.command('init-db')
@with_appcontext
def init_db_command():
 """Clear the existing data and create new tables"""
 init_db()
 click.echo('Initialized the database.')

open_resource()打开一个相对于baby包的文件，这很有用，因为在以后部署应用程序时你不一定知道该位置在哪里。get_db返回数据库连接，用于执行从文件读取的命令。

click.command()定义了一个名为init-db的命令行命令，该命令调用init_db函数并向用户显示成功消息。您可以阅读命令行界面以了解有关编写命令的更多信息。

注册应用程序

close_db和init_db_command函数需要在应用程序中被注册，否则他们将不会被应用程序调用。但是，由于您使用的是工厂函数，因此在编写函数时该实例不可用。相反，编写一个接受应用程序并进行注册的函数。

baby/db.py


def init_app(app):
 app.teardown_appcontext(close_db)
 app.cli.add_command(init_db_command)

app.teardown_appcontext()告诉Flask在返回响应后清理时调用该函数。

app.cli.add_command()添加了一个可以使用flask命令调用的新命令。

从工厂导入并调用此功能。在返回应用程序之前，将新代码放在工厂函数的末尾。

baby/init.py


def create_app(test_config=None):
 # create and configure the app
 app = Flask(__name__, instance_relative_config=True)
 app.config.from_mapping(
 SECRET_KEY='dev',
 DATABASE=os.path.join(app.instance_path, 'baby.sqlite')
 )

 if test_config is None:
 app.config.from_pyfile('config.py', silent=True)
 else:
 app.config.from_mapping(test_config)

 try:
 os.makedirs(app.instance_path)
 except OSError:
 pass

 @app.route('/baby')
 def index():
 return 'Baby'

 # 新加
 from . import db
 db.init_app(app)

 return app

初始化数据库文件

现在已经在应用程序中注册了init-db，可以使用flask命令调用它，类似于上一节的run命令。

注意：

如果您仍在从上一页运行服务器，则可以停止服务器，也可以在新终端中运行此命令。如果您使用新终端，请记住更改到项目目录并激活env，如激活环境中所述。您还需要设置FLASK_APP和FLASK_ENV，如上一节所示。

运行init-db命令


flask init-db
Initialized the database

现在，项目中的实例文件夹中将有一个baby.sqlite文件。

下一期继续 - Blueprint和视图

Flask 1.0 新手教程 - 应用程序设置

Tue, 29 Jul 2025 10:09:35 +0800

Flask应用程序是一个Flask类的实例。关于应用的任何事情，例如配置和URLs都将通过这个类来注册。

最直截了当的方式创建一个Flask应用是直接在代码顶部通过创建一个全局的Flask实例，就像上一篇教程的“Hello，World！”示例一样。虽然这在某些情况下很简单且有用，但随着项目的增长，它可能会导致一些棘手的问题。

在函数内创建Flask实例，而不是全局创建Flask实例。此功能称为应用程序工厂。应用程序需要的任何配置，注册和其他设置都将在函数内部进行，然后将返回应用程序。

应用程序工厂

是时候开始编码了！创建baby目录并添加__init__.py文件。__init__.py提供双重任务：它将包含应用工厂，并且它将告诉Python，baby目录将被作为一个包来对待。


make baby

baby/init.py


#! _*_ coding: utf-8 _*_

import os

from flask import Flask

def create_app(test_config=None):
 # 创建和配置应用程序
 app = Flask(__name__, instance_relative_config=True)
 app.config.from_mapping(
 SECRET_KEY='dev',
 DATABASE=os.path.join(app.instance_path, 'baby.sqlite')
 )

 if test_config is None:
 # 加载实例配置（如果存在），不测试时
 app.config.from_pyfile('config.py', silent=True)
 else:
 # 如果传入则加载测试配置
 app.config.from_mapping(test_config)

 # 确保实例文件夹存在
 try:
 os.makedirs(app.instance_path)
 except OSError:
 pass

 # 一个简单的页面
 @app.route('/hello')
 def index():
 return 'Hello, World!'

 return app

application = create_app()

if __name__ == "__main__":
 application.run()

create_app是应用程序工厂函数。您将在本教程的后面添加它，但它已经做了很多

app = Flask(__name__, instance_relative_config=True)创建Flask实例
- __name__是当前Python模块的的名称。应用程序需要知道它所在的位置以设置一些路径，并__name__是告诉它的一种方便的方法
- instance_relative_config=True告诉应用程序配置文件是相对于instance文件夹的。这个instance文件夹位于baby包外面并且可以保存本地数据，且数据不能被提交到版本库，例如配置密码和数据库文件。
app.config.from_mapping()设置一些应用程序将会使用的默认配置：
- SECRET_KEY 被Flask和扩展使用用来保证数据的安全。它被设置为’dev’以在开发期间提供方便的值，但在部署时应该用随机值覆盖它。
- DATABASE 是保存SQLite数据库文件的路径。它位于app.instance_path下，这是Flask为实例文件夹选择的路径。您将在下一篇教程中了解有关数据库的更多信息。
app.config.from_pyfile()使用从instance文件夹中的config.py文件获取的值覆盖默认配置（如果存在）。例如当部署的时候，将被用于设置一个真实的SECRET_KEY。
- test_config也可以传递给工厂，而不是实例配置。这样您将在本教程后面编写的测试可以独立于您配置的任何开发值进行配置
[os.makedirs()]确保app.instance_path存在。Flask不会自动创建一个instance文件夹，但是它需要被创建，因为你的项目将在这创建SQLite数据库文件。
@app.route()创建了一个简单的路由，以便在进入本教程的其余部分之前可以看到应用程序正常工作。它在URL /hello和返回响应的函数之间创建了一个连接，在这种情况下响应函数会返回一个字符串’Hello，World！'

运行应用程序

现在可以通过Flask命令运行应用程序。通过终端，告诉Flask在哪里找到你的应用程序，然后通过开发者模式运行

开发者模式，只要页面引发异常，就显示一个交互式调试器，在改变代码的时候重启服务器。您可以让它保持运行，只需按照教程重新加载浏览器页面即可。

对于Linux和Mac：


export FLASK_APP=baby
export FLASK_ENV=development
flask run

对于Windows cmd，使用set而不是export：


set FLASK_APP=baby
set FLASK_ENV=development
flask run

对于Windows PowerShell，请使用$env：而不是export：


$env:FLASK_APP = "baby"
$env:FLASK_ENV = "development"
flask run

你会看到与此类似的输出：


$ flask run
 * Serving Flask app "baby" (lazy loading)
 * Environment: development
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 390-520-193

在浏览器中访问http://127.0.0.1:5000/hello，您应该看到“Hello，World！”消息。恭喜，您现在正在运行Flask Web应用程序！

下一期继续 - 定义和访问数据库

Flask 1.0 新手教程 - 项目布局

Tue, 29 Jul 2025 10:09:32 +0800


mkdir baby
cd baby

然后参考安装说明来设置Python虚拟环境并且为项目安装Flask

本教程假设您从现在开始使用baby目录，每个代码块顶部的文件名都与该目录相关。

Flask应用程序可以像单个文件一样简单。

hello.py


from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
 return 'Hello, World!'

然而随着项目越来复杂，所有代码放在一个文件将会变得越来越臃肿。Python项目使用包将代码组织成多个模块，可以在需要的地方导入，本教程也会这样做。

本教程项目目录将会包括如下内容：

baby/，一个包含应用程序代码和文件的Python包
tests/，一个包含测试模块的目录
.env3，一个Flask和其他依赖库被安装的Python虚拟环境
安装文件告诉Python如何安装项目。
版本控制配置，例如git。您应养成给所有项目使用某种类型的版本控制的习惯，无论大小如何。
您将来可能添加的任何其他项目文件

最后，您的项目布局将如下所示：


/Users/durban/python/baby
├── tests
│ ├── test_factory.py
│ ├── test_db.py
│ ├── test_blog.py
│ ├── test_auth.py
│ ├── data.sql
│ └── conftest.py
├── setup.py
├── setup.cfg
├── gunicorn.example.conf
├── gunicorn.conf
├── baby
│ ├── templates
│ │ ├── blog
│ │ │ ├── update.html
│ │ │ ├── index.html
│ │ │ └── create.html
│ │ ├── base.html
│ │ └── auth
│ │ ├── register.html
│ │ └── login.html
│ ├── static
│ │ └── app.css
│ ├── schema.sql
│ ├── db.py
│ ├── blog.py
│ ├── auth.py
│ └── __init__.py
├── README.md
└── MANIFEST.in

如果你使用了版本控制，应忽略在运行项目时生成的以下文件。根据您使用的编辑器，可能还有其他文件。通常，忽略您未编写的文件。例如，使用git：

.gitignore


.env3/

*.pyc
__pycache__/

instance/

.pytest_cache/
.coverage
htmlcov/

dist/
build/
*.egg-info/

下一期继续 - 应用程序设置

Flask 1.0 新手教程 - 概览

Tue, 29 Jul 2025 10:09:28 +0800

教程内容有：

本教程将指导您创建一个名为Baby的基本博客应用程序。用户可以注册，登录，创建帖子，编辑或删除自己的帖子。您将能够在其他计算机上打包并安装该应用程序。

假设您已熟悉Python。Python文档中的官方教程是首先学习或复习的好方法。

虽然这个新手教程旨在提供一个良好的起点，但本教程并未涵盖Flask的所有功能。查看快速入门，了解Flask可以做的事情，然后深入了解文档以了解更多信息。本教程仅使用Flask和Python提供的内容。在其他项目中，您可能决定使用Extensions或其他库来简化某些任务。

Flask是很灵活的，它不需要您使用任何特殊的项目或者代码布局。然后，首次使用时，使用更结构化的方法会很有帮助。这意味着该新手教程需要预先考虑一些样板，但这样做是为了避免新开发人员遇到的许多常见陷阱，并创建一个易于扩展的项目。一旦你对Flask更加舒适，你可以走出这个结构并充分利用Flask的灵活性。

如果您希望在学习本教程时将项目与最终产品进行比较，那么本教程项目可作为Flask存储库中的示例提供。

下一期继续 - 项目布局

Flask 1.0 快速入手【四】

Tue, 29 Jul 2025 10:09:23 +0800

Sessions

除了请求对象之外，还有一个叫做session的第二个对象，它允许您将特定于某个用户的信息从一个请求存储到下一个请求。这是在cookie的基础上实现的，并以加密方式对cookie进行签名。这意味着用户可以查看cookie的内容但不能修改它，除非他们知道用于签名的密钥。

要使用session的话，您必须设置一个密钥。以下是session的工作方式：


from flask import Flask, session, redirect, url_for, escape, request

app = Flask(__name__)

app.secret_key = b'\xbc\xf6\x8aTP\xba\xe7\xf8*\xcc\xa7\xbe\xb2S\xd5\x83'

@app.route('/')
def index():
 if 'username' in session:
 return 'Logged in as %s' % escape(session['username'])

 return 'You are not logged in'

@app.route('/login', methods=['POST', 'GET'])
def login():
 if request.method == 'POST':
 session['username'] = request.form['username']
 return redirect(url_for('index'))

 return '''
		<form method="post">
			<p><input type='text' name='username' /></p>
			<p><input type='submit' value='Login' /></p>
		</form>
	'''

@app.route('/logout')
def logout():
 session.pop('username', None)
 return redirect(url_for('index'))

如果你没有使用模板引擎（如本例所示），这里提到的escape()会为你做转义处理。

如何生成一个好一点的密钥

密钥应尽可能随机。您的操作系统可以基于加密随机生成器生成相当随机的数据。使用以下命令快速生成一个值给Flask.secret_key (或者 SECRET_KEY):


$ python -c 'import os; print(os.urandom(16))'
b'\xbc\xf6\x8aTP\xba\xe7\xf8*\xcc\xa7\xbe\xb2S\xd5\x83'

关于基于cookie的会话的说明：Flask将获取您放入session对象的值，并将它们序列化为cookie。如果您发现某些值不会在请求中保留，则确实启用了Cookie，并且您没有收到明确的错误消息，请检查页面响应中的Cookie大小与Web浏览器支持的大小相比较。

除了默认的基于客户端的session，如果你想在服务器端处理session，有几个Flask扩展支持这个。

即时消息

好的应用和用户体验是关于反馈的，如果用户没有得到足够的反馈，他们可能最终会厌恶应用程序，Flask提供了一种使用即时系统向用户提供反馈的简单方法。即时系统基本上可以在请求结束时记录消息，并在下一个（也是下一个）请求中访问它。这通常与布局模板结合使用以显示消息。

要使用flash()方法添加一个即时消息，要获取即时消息，可以使用get_flashed_messages()的方法，这些消息也可以在模板中使用。查看即时消息以获取完整示例。

日志

有时您可能处理的数据应该是正确的，但事实并非如此。例如，您可能有一些客户端代码向服务器发送HTTP请求，但显然格式不正确。这可能是由用户篡改数据或客户端代码失败引起的。在大多数情况下，在这种情况下回复400 Bad Request是可以的，但有时不会这样做，而且代码必须继续工作。

您可能仍想记录发生了可疑的事情。这是loggers派上用场的地方。从Flask 0.3开始，预先配置了一个logger供您使用。

以下是一些日志调用示例：


app.logger.debug('A value for debuging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('A error occurred')

附加自带的logger是标准的Logger，因此请访问官方logging文档以获取更多信息。

详细了解应用程序错误

挂钩WSGI中间件

如果要将WSGI中间件添加到应用程序，可以包装内部WSGI应用程序。例如，如果你想使用Werkzeug包中的一个中间件来处理lighttpd中的bug，你可以这样做


from werkzeug.contrib.fixers import LighttpdCGIRootFix
app.wsgi_app = LighttpdCGIRootFix(app.wsgi_app)

使用Flask Extensions

扩展程序是帮助您完成常见任务的程序包。例如，Flask-SQLAlchemy提供SQLAlchemy支持，使其易于与Flask一起使用。

有关Flask扩展的更多信息，请查看扩展。

部署到Web服务器

准备部署新的Flask应用了吗？转到“部署选项”。

Flask 1.0 快速入手【三】

Tue, 29 Jul 2025 10:09:19 +0800

Cookies

你可以通过cookies这个属性来访问到cookies，可以使用响应对象的set_cookie方法来设置cookies。请求对象的cookies属性是一个字典类型，它包含了所有从客户端传递过来的cookies数据。如果你想使用cookies，不要直接使用cookies，而是使用Flask中的Sessions，它为您在cookies的上一层添加了一些安全的处理。

读取cookies


from flask import request

@app.route('/')
def index()：
 username = request.cookies.get('username')
 # 为了避免键值不存在的情况，使用cookies.get(key)替换cookies[key]

存储cookies


from flask import make_response

@app.route('/')
def index():
 resp = make_response(render_template('....'))
 resp.set_cookie('username', 'the other username')
 return resp

请注意，cookies是在响应对象中设置的。由于我们通常只是从视图函数返回字符串，Flask会为你将它们转换为响应对象。如果您明确要这样做，可以使用make_response()函数然后修改它。

有时您可能希望在响应对象尚不存在的位置设置cookie，这可以通过使用延迟请求回调模式来实现。

为此，请参阅关于响应。

重定向和错误

将用户重定向到另一个端点，使用redirect()函数。用一个错误代码提前中止请求，使用abort()函数。


from flask import abort, redirect, url_for

@app.route('/')
def index():
 return redirect(url_for('login'))

@app.route('/login')
def login():
 abort(401)
 this_is_never_executed()

这是一个毫无意义的例子，因为它将一个用户从index页面重定向到了一个不能访问的401页面，但是这个例子演示了如何使用的。

默认情况下，每一个错误码都会显示一个黑白的错误页面，如果你想自定义这个错误页面，可以使用errorhandler()装饰器


from flask import render_template

@app.errorhandler(404)
def page_not_found(error):
 return render_template('page_not_found.html', error=error), 404

请注意render_template()调用后的404。这将告诉Flask页面的状态码是404，404意味着页面不存在。默认情况下，页面状态码为200，意思是：一切正常。

有关详细信息，请参阅错误处理程序

关于响应

视图函数返回的值被自动转换为一个响应对象。如果返回值是一个字符串，它将被转换为一个带有该字符串的响应对象作为响应体，状态码200和一个text/htmlMIME类型。Flask转换返回值为一个响应对象的逻辑如下：

如果返回一个正确类型的响应对象，这个响应对象将会从视图函数直接返回。
如果返回一个字符串，一个影响对象将携带改字符串和默认的参数被创建。
如果返回元组，则元组中的项可以提供额外信息。这样的元组必须采用(response, status, headers)或(response, headers)的形式，其中至少有一个项目必须在元组中。status值将覆盖状态代码，headers可以是其他标头值的列表或字典。
如果这些都不起作用，Flask将假定返回值是有效的WSGI应用程序并将其转换为响应对象。

如果要在视图中获取生成的响应对象，可以使用make_response()函数。

假如你有一个像下面这样的视图


@app.errorhandler(404)
def not_found(error):
 return render_template('error.html', 404)

您只需要使用make_response()包装返回表达式并获取响应对象以对其进行修改，然后将其返回：


@app.errorhandler(404)
def not_found(error):
 resp = make_response(render_template('error.html'), 404)
 resp.headers['X-Something'] = 'A value'
 return resp

Flask 1.0 快速入手【二】

Tue, 29 Jul 2025 10:09:16 +0800

静态文件

动态web应用也需要静态文件。通常包括CSS和Javascript文件。理想情况下，你的服务器配置为为你自己服务的，但是在开发环境Flask也能做到这些，只要创建一个static文件夹在包里面或者在你模块的旁边创建一个static文件夹，在应用中通过/static调用的方式就会起作用

为了给static文件生成一个URLs，可以使用一个特殊的static节点，如下


url_for('static', filename='style.css')

模板渲染

从Python中生成HTML并不好玩，而且实际上非常麻烦，你必须自己进行HTML转义以保证应用程序的安全。因此Flask自动为你配置了Jinja2模板引擎。

为了渲染一个模板你可以使用 render_template() 方法。你必须传递一个模板的名字和你想要传递给模板的变量到模板引擎作为关键字参数。下面这个是一个简单例子，演示了如何渲染一个模板


from flask import render_template

@app.route('/hello')
@app.route('/hello/<name>')
def hello(name=None):
 return render_template('hello.html', name=name)

Flask将在templates文件夹中寻找对应的模板，如果你的应用是一个模块，这个文件夹将在模块的同一级，如果你的应用是一个包的话，则这个文件夹应该在包的里面，如下例子例子1：一个模块


/application.py
/templates
 /hello.html

例子2：一个包


/application
 /__init__py
 /templates
 /hello.html

对于模板，您可以使用Jinja2模板的全部功能。有关更多信息，请访问官方Jinja2模板文档。

下面是一个模板的例子


<!doctype html>
<title>
	Hello from Flask
</title>
{% if name %}
	<h1>Hello {{ name }}!</h1>
{% else %}
	<h1>Hello, World!</h1>
{% endif %}

在模板内部你可以访问request,session和g[1]对象，并且还可以使用get_flasjed_message()函数

模板的继承是非常有用的。如果你想要知道如何工作的，可以访问模板继承模式文档。基本上，模板继承可以在每个页面上保留某些元素（例如头部，导航和底部）

模板启动了自动转移功能，因为如果name中含有HTML，则会自动转义。如果你信任一个变量并且你知道它是一个安全的HTML（例如，它来自将wiki标记转换为HTML的模块）你可以使用Markup类标记他是安全的，或者通过使用|safe过滤下在模板中，有关更多示例，请访问Jinja 2文档

下面是一个简单的介绍，关于如何使用Markup类


>>> from flask import Markup
>>> Markup('<string>Hello %s!</strong>') % '<blink>hacker</blink>'
Markup('<string>Hello &lt;blink&gt;hacker&lt;/blink&gt;!</strong>')
>>> Markup.escape('<blink>hacker</blink>')
Markup('&lt;blink&gt;hacker&lt;/blink&gt;')
>>> Markup('<em>Marked up</em> &raquo; Html').striptags()
'Marked up » Html'

更改日志在0.5版本修改：不再为所有的模板启动自动转义。以.html,.htm,.xml,.xhtml扩展的模板将自动触发转义过滤。从字符串加载的模板将禁用自动转义。

[1] 不知道g对象是什么？它是一个你能存储你需要的信息的东西,有关详细信息，请查看该对象的文档（g）和使用带有Flask的SQLite 3。

访问请求数据

对于web应用程序，对客户端发送到服务器的数据做出相应是非常重要的，在Flask中这些信息通过全局request对象提供。如果你有一些Python开发经验，你也许想要知道改对象如何是全局的以及如何Flask如何设置他仍然是线程安全的。答案是上下文本地化

上下文本地化

如果你想知道它是如何工作的，并且想知道它是如何实现的，请阅读这部分否则跳过继续

Flask中的某些对象是全局对象，但是不是通常的对象。这些对象实际上是一个协议，而且能够本地化到一个特定的上下文。非常绕，但是实际上很容易理解。

想象下，这个上下文是一个处理中的线程。一个请求过来后服务器端决定产生一个新的线程（或其他东西，底层对象能够处理除线程之外的并发系统）。当Flask启动它的内部请求去处理它时，他会判断出当前线程是活动上下文并将当前应用程序和WSGI环境绑定到改上下文（线程）。它以智能的方式实现了这个逻辑，以便一个应用程序可以在不中断情况下调用另一个应用程序。

这对于你意味着什么呢？基本上你能完全忽略这个情况，除非你做了一些事情比如单元测试，你将注意到因为没有请求对象导致依赖于对象请求的代码将突然中断。这个解决方案就是你自己创建了一个请求对象然后绑定它到上下文，最简单的单元测试解决方案是使用test_request_context()上下文管理器。结合with语句时，它将会绑定一个测试请求使你能够跟它进行交互。下面是一个例子：


from flask import request

with app.test_request_context('/hello', method='POST'):
 assert request.path == '/hello'
 assert request.method == 'POST'

其他可能的情况是传入整个WSGI环境的到request_context()方法


from flask import request

with app.request_context(env):
 assert request.method == 'POST'

请求对象

请求对象被记录在API部分，这里暂时不做全覆盖的介绍，具体详情可以看Request或者看我后面的介绍，这里暂时只介绍下普通情况下用的比较频繁的操作，首先我们必须从flask模块导入它


from flask import request

通过使用method属性可以获取当前请求的方式。为了访问到表单数据（数据通过POST或者PUT方式请求）你可以使用form属性。这里是一个完整的例子，关于这两个属性的


@app.route('/login', methods=['POST', 'GET'])
def login():
 error = None
 if request.method == 'POST':
 if valid_login(request.form['username'], request.form['password']):
 return log_the_user_in(request.form['username'])
 else:
 error = 'Invalid username/password'

 return render_template('login.html', error=error)

如果form的属性中没有对应的key会发生什么呢？这种情况下将会抛出一个KeyError异常。你可以像标准KeyError一样捕获它，但如果不这样做，则会显示HTTP 400错误请求错误页面。所以很多情况下你没必要处理这个问题。

要访问URL(?key=value)中提交的参数，可以使用args属性


key = request.args.get('key')

建议使用get或捕获KeyError来访问URL参数，因为用户可能会更改URL并向他们显示400个错误请求页面，在这种情况下体验并不友好。

有关请求对象的方法和属性的完整列表，请转到Request文档。

文件上传

你能很容易的使用Flask处理上传的文件。只要确保在提交的表单中不要忘记设置enctype="multipart/form-data"属性，否则浏览器将不会传递你的提交的文件

上传到文件存储在内存或者文件系统的一个临时的位置。你能通过request对象的files这个属性访问这些文件。每个上传的文件存储在一个字典中。它的行为就想标准的Python文件对象一样，但是也有一个**save()**方法，这个防范允许你将文件存储到服务器的文件系统中。下面是一个简单的演示例子


from flask import request

@app.route('/upload', methods=['GET','POST'])
def upload_file():
 if request.method == 'POST':
 f = request.files['file']
 f.save('/var/www/uploads/upload.txt')

如果您想知道文件在上传到您的应用程序之前在客户端上的命名方式，你可以通过访问filename属性。但请记住，这个价值可以伪造，所以永远不要相信这个价值。如果你想要使用客户端的文件名去存储到服务器上，通过Werkzeug为您提供的**secure_filename()**函数传递它。


from flask import request
from werkzeug.utils import secure_filename

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
 if request.method == 'POST':
 f = request.files['file']
 f.save('/var/www/upload/' + secure_filename(f.filename))

有关更好的示例，请查看上传文件章节。

Flask 1.0 快速入手【一】

Tue, 29 Jul 2025 10:09:13 +0800

是不是已经很想快点尝试下Flask了，本次分享将尽量全面的介绍Flask，继续下面的内容之前请确保您已经安装了Flask，如果你还没有安装的话，请回到前面的部分“Flask 1.0安装”再了解下如何安装。

一个小的应用

一个小应用的代码看起来像是下面这个样子


from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
	return "hello world"

下面解释下这段代码做了什么

首先我们导入了Flask类，这个类的实例将是我们WSGI应用的实例
下面创建这个类的实例。第一个参数是应用的模块或者包的名称。如果你使用一个单独的模块（比如这里的例子），你应该使用__name__，因为这个取决于应用是否作为一个应用程序启动还是作为一个模块导入，它的名称将是不同的（__main__与实际导入的名称相对应）。这个是必须要传入的参数，会让Flask知道去哪里查找模板、静态文件等等，有关于更多的信息可以查看Flask的官方文档
我们使用route()装饰器去告诉Flask什么样的URL路由将会触发我们的函数
hello_world这个函数的名称也是有用的，后面在生成URLs的时候会有特殊的功能，而且函数的返回值将展示在用户的浏览器上。

只需要保存上面的代码到文件hello.py或者是其他的名称带有后缀.py的文件即可，同时确保文件的名称不能叫做flask.py，因为这样会是的自己的文件脚本跟Flask自己冲突。

为了运行应用程序，你既可以使用flask命令也可以使用python的-m启动Flask.不过在你运行程序前你应该在终端导入一个环境变量FALSK_APP，如下：


$ export FLASK_APP=hello.py
$ flask run
 * Serving Flask app "hello.py"
 * Environment: production
 WARNING: Do not use the development server in a production environment.
 Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

如果您使用的是Windows，则环境变量语法取决于命令行解释程序。在命令提示符上:


C:\path\to\app>set FLASK_APP=hello.py

在PowerShell上：


PS C:\path\to\app> $env:FLASK_APP = "hello.py"

另外你也可以使用python -m flask


$ export FLASK_APP=hello.py
$ python -m flask run
 * Serving Flask app "hello.py"
 * Environment: production
 WARNING: Do not use the development server in a production environment.
 Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

外部可见服务器

这将运行一个非常简单的内置服务器，对于开发和测试是足够用了，但是不是你想在生产环境使用的东西。后面会有相关部署环节的介绍。

如果你启动了上面的程序的话，你将会注意到，运行起来的服务只能你自己的电脑才能访问，网络上其他的电脑是没有办法访问的。在debug模式中这是默认的行为，只允许你自己在你自己的电脑上随意的执行Python代码

如果你禁止了debug模式或者新人在在同一网络上的用户，你可以公开你的服务，只需要简单的在命令行中加入--host=0.0.0.0


flask run --host=0.0.0.0

这个操作将会告诉你的电脑，去监听所有公开的网络ip

如果服务没有启动该做什么

一旦python -m flask启动失败或者flask不存在，这总情况可能有多种原因，首先你需要仔细看一下报错的错误信息

旧的flask版本

Flask版本小于0.11的话会有不同的方式启动应用，简而言之，flask命令不存在，而且也没有python -m flask。这种情况下有两种选择，一是将Flask升级到新版本，二是看下这个开发服务器文档遭到启动服务器的替代方法

导入名称无效

FLASK_APP环境变量是在flask run的时候导入的模块的名称，在这种情况下，模块的名称是错误的话你将得到一个启动时导入错误提示（或者，如果导航到应用程序时启用了调试），它将告诉你试图导入的内容以及失败的原因。

最常见的错误是拼写错误或者是因为你实际上并没有创建一个应用程序对象

调试模式

(想要记录错误和堆栈跟踪？请看应用程序错误) flask脚本能够很适合启动一个本地的开发服务器，但是每次更改代码后都需要重新启动服务器。这不是很好，Flask能做的更好，如果启动了调试支持，服务器将在代码改动后自动重新加载，如果出现问题，他还会提供一个有用的调试器。

为了启用所有开发功能（包括调试模式），你需要在启动服务器前导入FLASK_ENV环境变量并且设置它的值为development


$ export FLASK_ENV=development
$ flask run

（在Windows环境中需要用set代替export）

这样做有以下几点：

它激活了调试器
它激活了自动重新加载器
它启用了Flask应用程序上的调试模式。

你也能通过导入变量FLASK_DEBUG=1来单独控制调试模式

在开发服务器中有更多关于参数的介绍

注意

尽管交互调试器不能在工作在分叉环境中（几乎不可能在生产环境中使用），他仍然允许执行任务的代码，这就使得服务器非常的不安全，所以绝对不要在生产服务上使用

下面是一个调试器的截图

有关使用调试器的更多信息，请参阅Werkzeug文档。还有另一个调试器吗？请参阅使用调试器。

路由

现代的web应用使用更加有意义的URLs去帮助用户，如果页面使用有意义的并且用户可以记住的URL，用户可能会更喜欢这个页面并返回来直接访问该页面。

使用route()装饰器来绑定一个函数到一个URL地址上：


@app.route('/')
def index():
	return 'Index Page'

@app.route('/hello')
def hello():
	return 'Hello World'

你可以做得更多！可以将URL的一部分动态化并将多个规则附加到函数。

变量规则

使用<variable_name>标记部分添加变量部分到URL。你的函数将接收到<variable_name>作为关键字参数。你也可以一个转换器，来定义具体的参数类型像这样<converter:variable_name>(可选)


@app.route('/user/<username>')
def show_user_profile(username):
	return 'User %s' % username

@app.route('/post/<int:post_id>')
def show_post(post_id):
	return 'Post %d' % post_id

@app.route('/path/<path:subpath>')
def show_subpath(subpath):
	return 'Showpath %s' % subpath

转换器类型：

类型	描述
string	接收任意字符串除了斜杠（默认情况下接收string类型）
int	接收正整数
float	接收正浮点值
path	类似string但是也接受斜杠
uuid	接收UUID字符串

唯一URL地址/重定向行为

下面的两个规则在使用尾部斜杠的时候有所不同


@app.route('/projects/')
def projects():
	return 'The project page.'

@app.route('/about')
def about():
	return 'The about page.'

projects的规范路由最后部分有斜杠，类似于一个文件系统的文件夹。如果你访问这个URL地址不带有最后的斜杠，Flask则重定向到一个尾部带有斜杠的规范路由

about的规范路由最后部分没有斜杠，类似于一个文件的文件路径名。如果你访问这个URL地址最后带有斜杠的话，会产生一个404“Not Found”错误。这有助于保持URL对这些资源的唯一性，并且保持搜索引擎避免两次索引同一页面

URL构建

为了构建一个URL地址到一个具体的函数，使用url_for()函数。它接收一个函数的名字作为第一个参数和任意数量的关键字参数，每一个对应到URL规则变量的对应部分。未知的变量部分作为查询参数附加到URL

为什么要使用URL转换函数url_for()来构建URL，而不是用硬编码的方式写在模板里面

转换要比硬编码十分具有描述性
你可以一次性修改网址而不比记住它手动去修改硬编码的URL网址
URL构建处理特殊字符和Unicode数据的转义
产生的网址路径都是绝对的，避免了不必要的相对路径的麻烦
如果您的应用程序位于URL根目录之外，例如，在/myapplication而不是/，url_for()能够妥善处理这些问题

例如下面我们使用test_request_context()方法来测试url_for().test_request_context()告诉Flask。即使我们使用Python shell，它也会像处理请求一样。请参阅上下文本地。


from flask import Flask, url_for
app = Flask(__name__)

@app.route('/')
def index():
 return 'Index'

@app.route('/login')
def login():
 return 'Login page'

@app.route('/user/<username>')
def profile(username):
 return '{}\'s profile'.format(username)

with app.test_request_context():
 print(url_for('index'))
 print(url_for('login'))
 print(url_for('login', next='/'))
 print(url_for('profile', username='Durban'))

/
/login
/login?next=%2F
/user/Durban

HTTP方法

Web应用程序在访问URL时使用不同的HTTP方法，在使用Flask开发时，你自己应该熟悉HTTP方法，默认情况下，一个路由只回应一个GET请求，你可以使用route()装饰器的第二个参数来处理不同的HTTP方法


from flask import Flask

@app.route('/login', methods=['GET', 'POST'])
def login():
	if request.method == 'POST':
		return 'do the login'
	else:
		return 'show the login form'

如果存在GET，Flask会自动添加对HEAD方法的支持，并根据HTTP RFC处理HEAD请求。同样，OPTIONS会自动为您实施

Flask 1.0 - 安装

Tue, 29 Jul 2025 10:09:10 +0800

Python版本要求

Flask从1.0开始支持Python 3，Flask支持Python 3.4和最新版本，以及Python 2.7和PyPy，同时官方建议使用Python 3的最新版本，由此可以看出Flask 从1.0开始拥抱Python 3

包依赖

Werkzeug 实现WSGI，它是应用程序和服务器之间的标准Python接口
Jinja 一种模板语言，用于呈现应用程序所服务的页面
MarkupSafe 附带Jinja. 它在渲染模板时逃避不受信任的输入以避免注入攻击。
ItsDangerous 安全地签署数据以确保其完整性。这用于保护Flask的会话cookie。
Click 是一个用于编写命令行应用程序的框架。它提供flask命令并允许添加自定义管理命令。

这些包会在安装Flask后自动安装

其他可选包

Blinker 为Signals提供支持.
SimpleJSON 是一个快速的JSON实现，与Python的json模块兼容。如果安装了JSON操作，则首选它。
python-dotenv 在运行flask命令时启用对 dotenv的环境变量的支持。
Watchdog 为开发服务器提供更快，更高效的重新加载器。

以上的可选包不会自动安装，不过，如果你安装了的话，Flask将自动监测并使用他们

虚拟环境

建议在开发和生产中使用虚拟环境来管理你项目的依赖库。

虚拟环境能解决什么问题呢？如果你拥有Python的项目越多，你需要使用不同版本的Python库的可能性就越大，甚至是Python本身。一个较新版本的Python库可能会打破另一个项目的兼容性

虚拟环境是独立的Python库组合，每个项目一个。一个项目安装的软件包不会影响其他项目或操作系统的软件包。

Python 3已经绑定了venv模块用来创建虚拟环境。如果你使用的是Python 3，可以继续下面的操作。

如果你使用的是Python 2，首先先看下“安装virtualenv”

创建虚拟环境

创建一个项目目录然后添加一个.venv_baby文件夹，当然这个文件夹你也可以根据自己的需要来定义：


mkdir baby
cd baby
python3 - venv .venv_baby

Windows环境下的操作


py -3 -m venv .venv_baby

如果您使用的是旧版本的Python，您需要安装virtualenv，请使用一下命令：


virtualenv .venv_baby

Windows环境下的操作


\Python27\Scripts\virtualenv.exe .venv_baby

激活环境

在你的项目中工作前，激活相应的环境


. .venv_baby/bin/activate

在Windows环境下


.venv_baby\Scripts\activate

你的shell提示中将显示激活环境的名称

安装Flask

在激活的环境中使用下面的命令安装Flask


pip install Flask

如果您希望在发布之前使用最新的Flask代码，请安装或更新主分支中的代码：


pip install -U https://github.com/pallets/flask/archive/master.tar.gz

安装virtualenv

如果你使用的是Python 2，venv模块是不可用的，因此需要安装virtualenv 在Linux系统中，virtualenv由包管理器提供


# Debian, Ubuntu
sudo apt-get install python-virtualenv

# CentOS, Fedora
sudo yum install python-virtualenv

# Arch
sudo pacman -S python-virtualenv

如果你的系统是Mac OS或者Windows，先下载get-pip.py，然后执行下面的代码


sudo python2 Downloads/get-pip.py
sudo python2 -m pip install virtualenv

在Windows系统上，已administrator的身份执行


\Python27\python.exe Downloads\get-pip.py
\Python27\python.exe -m pip install virtualenv

现在返回到上面的“创建虚拟环境”.

Flask 1.0 生产环境部署记录

Tue, 29 Jul 2025 10:09:06 +0800

Flask 1.0 开始支持Python3啦，一直在使用Flask构建自己的博客，今天重温看了下Flask1.0，感觉还是有很多优点的，随后根据官网的教程搞了一个简易的小博客，整体使用下来，还算是比较轻便的。唯独在部署上不是那么的轻松，但是经过查询也算是找到了解决办法，跟之前的Flask版本不同的是，我这次想试下Gunicorn+Nginx+Supervisor。

安装的部分就不用我多说，我是把Gunicorn安装在了项目目录下，实际上作为一个项目的话Gunicorn是没必要放在项目中的，毕竟一个是服务层一个是逻辑层。

为了Gunicorn的启动配置项简单明了，最好是建立一个配置文件，这样下次也能清楚里面启动的时候配置了哪些参数，网上找了一个配置，仅供参考

gunicorn.conf


# 并行工作进程数
workers = 4
# 指定每个工作者的线程数
threads = 2
# 监听内网端口5000
bind = '127.0.0.1:8000'
# 设置守护进程,将进程交给supervisor管理
daemon = 'false'
# 设置最大并发量
worker_connections = 2000
# 设置进程文件目录
pidfile = '/var/tmp/gunicorn.pid'
# 设置访问日志和错误信息日志路径
accesslog = '/var/tmp/gunicorn_access.log'
errorlog = '/var/tmp/gunicorn_error.log'
# 设置日志记录水平
loglevel = 'warning'

这里的配置注意daemon为false

然后添加supervisor的配置，这里要做的只是简单的添加supervisor配置，至于supervisor的安装还是很简单的，mac下建议使用brew安装

贴出一份我这边测试时使用的配置

baby.ini


[program:baby]
directory = /Users/durban/python/baby ; 程序的启动目录
command = gunicorn -c /Users/durban/python/baby/gunicorn.conf baby ; 启动命令，可以看出与手动在命令行启动的命令是一样的
autostart = true ; 在 supervisord 启动的时候也自动启动
startsecs = 5 ; 启动 5 秒后没有异常退出，就当作已经正常启动了
autorestart = true ; 程序异常退出后自动重启
startretries = 3 ; 启动失败自动重试次数，默认是 3
user = durban ; 用哪个用户启动
redirect_stderr = true ; 把 stderr 重定向到 stdout，默认 false
stdout_logfile_maxbytes = 20MB ; stdout 日志文件大小，默认 50MB
stdout_logfile_backups = 20 ; stdout 日志文件备份数
; stdout 日志文件，需要注意当指定目录不存在时无法正常启动，所以需要手动创建目录（supervisord 会自动创建日志文件）
stdout_logfile = /var/tmp/baby_stdout.log

; 可以通过 environment 来添加需要的环境变量，一种常见的用法是修改 PYTHONPATH
; environment=PYTHONPATH=$PYTHONPATH:/path/to/somewhere

然后重启下supervisor就可以了

这里注意下supervisor的问题，如果你supervisor的配置文件是在/etc/等supervisor默认搜索的目录下的话直接使用supervisorctl reload是没有任何问题的，如果配置文件不在默认的搜索目录下的话，就会报类似refused connection的错误提示，建议操作supervisor的时候，指定下配置文件，如下


supervisorctl -c /usr/local/etc/supervisord.ini reload

然后配置nginx，简单的配置示例如下


server {
	charset utf-8;

	client_max_body_size 128M;

	listen 80;

	server_name flask1.walkerfree.local; # 这是HOST机器的外部域名，用地址也行

	access_log /var/log/flask1.walkerfree.local.access.log;
	error_log /var/log/flask1.walkerfree.local.error.log;

	location / {
		proxy_pass http://127.0.0.1:8000; # 这里是指向 gunicorn host 的服务地址
		proxy_set_header Host $host;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}

	location ~ /\.(git|svn|ht) {
		deny all;
	}
}

Flask 日志邮件发送客户端授权密码验证错误

Mon, 28 Jul 2025 17:52:42 +0800

最近在使用flask的日志邮件发送功能，就是程序出现问题的时候，可以通过邮件发送到指定的邮箱，当时使用的是QQ邮箱的

基本上会有如下的错误

smtplib.SMTPAuthenticationError: (535, b’Error: authentication failed')

smtplib.SMTPServerDisconnected: Connection unexpectedly closed

Connection unexpectedly closed: timed out

开始的配置如下


ADMINS = ['xxx@xxx']
MAIL_SUBJECT_PREFIX = '[Walkerfree]'
MAIL_SENDER = 'xxx@xxx'
MAIL_SERVER = 'smtp.qq.com'
MAIL_PORT = 465
MAIL_USE_SSL = True
MAIL_USE_TLS = False
MAIL_USERNAME = 'xxx@xxx'
MAIL_PASSWORD = '123456'

在测试的时候会遇到超时，但是是这里的问题


mail_handler = SMTPHandler(
 application.config['MAIL_SERVER']
 application.config['MAIL_SENDER'],
 application.config['ADMINS'],
 'application error',
 (
 application.config['MAIL_USERNAME'],
 application.config['MAIL_PASSWORD'],
 )
 )

第一个参数没有传递端口号，可以看源码


self.mailhost, self.mailport = mailhost

有mailhost和mailport，没有端口号怎么能行呢

修改后如下


mail_handler = SMTPHandler(
 (
 application.config['MAIL_SERVER'],
 application.config['MAIL_PORT']
 ),
 application.config['MAIL_SENDER'],
 application.config['ADMINS'],
 'application error',
 (
 application.config['MAIL_USERNAME'],
 application.config['MAIL_PASSWORD'],
 )
 )

报错如下


SMTPServerDisconnected: Connection unexpectedly closed: timed out

最后修改了配置，如下


ADMINS = ['xxx@xxx']
MAIL_SUBJECT_PREFIX = '[Walkerfree]'
MAIL_SENDER = 'xxx@xxx'
MAIL_SERVER = 'smtp.qq.com'
MAIL_PORT = 25
MAIL_USE_SSL = True
MAIL_USE_TLS = False
MAIL_USERNAME = 'xxx@xxx'
MAIL_PASSWORD = '123456'

最后发送成功。客户端授权码的这个需要自己去搞，QQ帮助中心有指引的。

快捷链接:http://service.mail.qq.com/cgi-bin/help?subtype=1&&id=28&&no=1001256%27)

Python数据挖掘入门 - 亲和性分析示例(Affinity analysis)

Mon, 28 Jul 2025 17:52:28 +0800

# 亲和性分析示例

亲和性分析是根据样本个体之间的相似度，确定它们关系的亲疏。

比如：向网站用户提供多样化的服务或定向投放广告

亲和性还有多种测量方法，比如，统计两件商品一起出售的概率，或者统计用户购买了商品1后再购买商品2的比率。

下面具体分析下如何计算个体之间的相似度。

场景：

一个人去超市买东西，买了面包后又买了牛奶。

作为数据挖掘入门性质的例子，我们希望得到下面这样的规则：

“如果一个人买了商品X,那么他可能购买Y”

下面我们导入具体的数据集

import numpy as np
dataset_filename = "dataset.txt"
datas = np.loadtxt(dataset_filename)
n_samples, n_features = data.shape
print(n_samples) # 行数
print(n_features) # 列数

输出

 100
 5

dataset.txt的文件请从后面提供的git地址上下载

print(datas[:5])

输出

 [[0. 0. 1. 1. 1.]
 [1. 1. 0. 1. 0.]
 [1. 0. 1. 1. 0.]
 [0. 0. 1. 1. 1.]
 [0. 1. 0. 0. 1.]]

每行代表用户每次购买的5个商品

假设每列分别代表面包、牛奶、奶酪、苹果和香蕉

比如第一行是[0. 0. 1. 1. 1.]

代表用户买了奶酪、苹果和香蕉，没有买面包、牛奶

1-> 表示买了该商品

0-> 表示没有买该商品

products_name = ["面包", "牛奶", "奶酪", "苹果", "香蕉"]

## 实现简单的排序规则

如果要找出"如果一个人买了商品X,那么他可能购买Y"这样的规则。

简单的办法就是找出数据集中所有同时购买两件商品的情况，找到规则后，我们还需要判断规则的优劣，最后选择最优的。

规则的优劣有多种衡量方法，常用的方法有“支持度”和“置信度”

支持度指数据集里面规则有效的次数，统计起来很简单。

有时候，还需要对支持度进行规范化，即再除以规则有效的总数量。

我们这里只简单统计规则有效的次数。

支持度衡量的是给定规则有效的比例，而置信度衡量的则是规则有效准确率，即符合给定条件(即规则的“如果”语句所表示的前提条件)的所有规则里，跟当前规则结论一致的比例有多大。

计算方法为首先统计当前规则的出现次数，再用它来除以条件(“如果”语句)相同的规则数量

如下面的代码所示，通过判断交易数据中data[3]的值，就能知道一个顾客是否买了苹果。这里，data表示一条交易信息，也就是数据集里的一行数据。

purchase_apple_sum = 0 # 购买苹果的人数
for data in datas:
 if data[3] == 1: # 购买了苹果
 purchase_apple_sum += 1 # 计算购买了苹果的人数

print("{0}人买了苹果".format(purchase_apple_sum))

输出

 36人买了苹果

有多少人买了苹果有买了香蕉呢

valid_rule = 0 # 符合规则的有效次数
invalid_rule = 0 # 不符合规则的有效次数
purchase_apple_not_banana_num = 0
for data in datas:
 if data[3] == 1: # 购买了苹果
 if data[4] == 1: # 购买了香蕉
 valid_rule += 1 # 计算购买苹果和香蕉的人数
 else:
 invalid_rule += 1 # 计算购买苹果没有购买香蕉的人数
print("{0}人同时购买了苹果和香蕉".format(purchase_apple_and_banana_num))
print("{0}人只购买了苹果没有购买香蕉".format(purchase_apple_not_banana_num))

输出

 21人同时购买了苹果和香蕉
 0人只购买了苹果没有购买香蕉

现在有了所有需要的数据，我们就可以计算支持度和置信度

# 支持度就是 符合规则有效的次数
support_degree = valid_rule
# 置信度
confidence_degree = valid_rule / purchase_apple_sum
print("支持度是{0}, 置信度是{1:0.3f}".format(support_degree, confidence_degree))
# 置信度可以用百分比来表示
print("置信度的百分比是{0:0.1f}%".format(confidence_degree * 100))

输出

 支持度是21, 置信度是0.583
 置信度的百分比是58.3%

为了计算所有规则的置信度和支持度，首先创建一个字典，用来存放计算结果。

需要统计的量有

1、有效规则

2、无效规则

3、条件相同的规则数量

'''
对于上面的符合要求的，即同时购买了苹果和香蕉的标识符合我们的规则，反之不符合我们的规则，按照此逻辑我们找出所有有效规则
'''
from collections import defaultdict
valid_rules = defaultdict(int) # 有效规则
invalid_rules = defaultdict(int) # 无效规则
num_occurances = defaultdict(int) # 规则数量
for data in datas:
 for fruit in range(n_features):
 # 首先检查个体是否符合规则【购买的规则，没有购买的就直接跳过】
 if data[fruit] == 0: # 不符合规则，继续下一个循环 
 continue
 num_occurances[fruit] += 1 # 符合规则加1

 for also_fruit in range(n_features):
 if fruit == also_fruit: # 跳过不符合要求的，即我们想要的是买了x水果又买了y水果，而不是买了x水果又买了x水果
 continue
 if data[also_fruit] == 1:
 valid_rules[(fruit, also_fruit)] += 1

 else:
 invalid_rules[(fruit, also_fruit)] += 1

support_degrees = valid_rules
confidence_degrees = defaultdict(float)
for fruit, also_fruit in valid_rules.keys():
 confidence_degrees[(fruit, also_fruit)] = valid_rules[(fruit, also_fruit)] / num_occurances[fruit]

for fruit, also_fruit in confidence_degrees:
 fruit_name = products_name[fruit]
 also_fruit_name = products_name[also_fruit]
 print("规则: 如果一个人买了商品【{0}】，那么他可能买商品【{1}】".format(fruit_name, also_fruit_name))
 print(" - 置信度是: {0:.3f}".format(confidence_degrees[(fruit, also_fruit)]))
 print(" - 支持度是: {0}".format(support_degrees[(fruit, also_fruit)]))

输出

 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【苹果】
 - 置信度是: 0.610
 - 支持度是: 25
 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【香蕉】
 - 置信度是: 0.659
 - 支持度是: 27
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【奶酪】
 - 置信度是: 0.694
 - 支持度是: 25
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【香蕉】
 - 置信度是: 0.583
 - 支持度是: 21
 规则: 如果一个人买了商品【香蕉】，那么他可能买商品【奶酪】
 - 置信度是: 0.458
 - 支持度是: 27
 规则: 如果一个人买了商品【香蕉】，那么他可能买商品【苹果】
 - 置信度是: 0.356
 - 支持度是: 21
 规则: 如果一个人买了商品【面包】，那么他可能买商品【牛奶】
 - 置信度是: 0.519
 - 支持度是: 14
 规则: 如果一个人买了商品【面包】，那么他可能买商品【苹果】
 - 置信度是: 0.185
 - 支持度是: 5
 规则: 如果一个人买了商品【牛奶】，那么他可能买商品【面包】
 - 置信度是: 0.304
 - 支持度是: 14
 规则: 如果一个人买了商品【牛奶】，那么他可能买商品【苹果】
 - 置信度是: 0.196
 - 支持度是: 9
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【面包】
 - 置信度是: 0.139
 - 支持度是: 5
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【牛奶】
 - 置信度是: 0.250
 - 支持度是: 9
 规则: 如果一个人买了商品【面包】，那么他可能买商品【奶酪】
 - 置信度是: 0.148
 - 支持度是: 4
 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【面包】
 - 置信度是: 0.098
 - 支持度是: 4
 规则: 如果一个人买了商品【牛奶】，那么他可能买商品【香蕉】
 - 置信度是: 0.413
 - 支持度是: 19
 规则: 如果一个人买了商品【香蕉】，那么他可能买商品【牛奶】
 - 置信度是: 0.322
 - 支持度是: 19
 规则: 如果一个人买了商品【面包】，那么他可能买商品【香蕉】
 - 置信度是: 0.630
 - 支持度是: 17
 规则: 如果一个人买了商品【香蕉】，那么他可能买商品【面包】
 - 置信度是: 0.288
 - 支持度是: 17
 规则: 如果一个人买了商品【牛奶】，那么他可能买商品【奶酪】
 - 置信度是: 0.152
 - 支持度是: 7
 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【牛奶】
 - 置信度是: 0.171
 - 支持度是: 7

def print_rule(fruit, also_fruit, support_degrees, confidence_degrees, products_name):
 fruit_name = products_name[fruit]
 also_fruit_name = products_name[also_fruit]
 print("规则: 如果一个人买了商品【{0}】，那么他可能买商品【{1}】".format(fruit_name, also_fruit_name))
 print(" - 置信度是: {0:.3f}".format(confidence_degrees[(fruit, also_fruit)]))
 print(" - 支持度是: {0}".format(support_degrees[(fruit, also_fruit)]))

print_rule(1, 3, support_degrees, confidence_degrees, products_name)

输出

 规则: 如果一个人买了商品【牛奶】，那么他可能买商品【苹果】
 - 置信度是: 0.196
 - 支持度是: 9

## 排序找出最佳规则

我们上面已经拿到了所有有效规则及对应的置信度和支持度，为了找出最佳规则，我们还需要根据支持度和置信度对规则进行排序。

为了找出支持度最高的规则，首先对支持度字典进行排序。

# 排序支持度
from pprint import pprint
pprint(list(support_degrees.items()))

输出

 [((2, 3), 25),
 ((2, 4), 27),
 ((3, 2), 25),
 ((3, 4), 21),
 ((4, 2), 27),
 ((4, 3), 21),
 ((0, 1), 14),
 ((0, 3), 5),
 ((1, 0), 14),
 ((1, 3), 9),
 ((3, 0), 5),
 ((3, 1), 9),
 ((0, 2), 4),
 ((2, 0), 4),
 ((1, 4), 19),
 ((4, 1), 19),
 ((0, 4), 17),
 ((4, 0), 17),
 ((1, 2), 7),
 ((2, 1), 7)]

# 使用itemgetter() 类作为键，这样就可以对嵌套列表进行排序
from operator import itemgetter
# itemgetter(1)表示以字典各元素的值(这里为 支持度)作为排序依据，reverse=True表示降序排列。
sorted_support_degrees = sorted(support_degrees.items(), key=itemgetter(1), reverse=True)
print(sorted_support_degrees)

输出

 [((2, 4), 27), ((4, 2), 27), ((2, 3), 25), ((3, 2), 25), ((3, 4), 21), ((4, 3), 21), ((1, 4), 19), ((4, 1), 19), ((0, 4), 17), ((4, 0), 17), ((0, 1), 14), ((1, 0), 14), ((1, 3), 9), ((3, 1), 9), ((1, 2), 7), ((2, 1), 7), ((0, 3), 5), ((3, 0), 5), ((0, 2), 4), ((2, 0), 4)]

# 排序完成之后就可以输出支持度最高的前5条
for i in range(5):
 print("规则: #{0}".format(i))
 fruit, also_fruit = sorted_support_degrees[i][0]
 print_rule(fruit, also_fruit, support_degrees, confidence_degrees, products_name)

输出

 规则: #0
 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【香蕉】
 - 置信度是: 0.659
 - 支持度是: 27
 规则: #1
 规则: 如果一个人买了商品【香蕉】，那么他可能买商品【奶酪】
 - 置信度是: 0.458
 - 支持度是: 27
 规则: #2
 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【苹果】
 - 置信度是: 0.610
 - 支持度是: 25
 规则: #3
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【奶酪】
 - 置信度是: 0.694
 - 支持度是: 25
 规则: #4
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【香蕉】
 - 置信度是: 0.583
 - 支持度是: 21

'''
同理我们还可以输出置信度最高的规则，首先对置信度进行排序
'''
sorted_confidence_degrees = sorted(confidence_degrees.items(), key=itemgetter(1), reverse=True)
print(sorted_confidence_degrees)

输出

 [((3, 2), 0.6944444444444444), ((2, 4), 0.6585365853658537), ((0, 4), 0.6296296296296297), ((2, 3), 0.6097560975609756), ((3, 4), 0.5833333333333334), ((0, 1), 0.5185185185185185), ((4, 2), 0.4576271186440678), ((1, 4), 0.41304347826086957), ((4, 3), 0.3559322033898305), ((4, 1), 0.3220338983050847), ((1, 0), 0.30434782608695654), ((4, 0), 0.288135593220339), ((3, 1), 0.25), ((1, 3), 0.1956521739130435), ((0, 3), 0.18518518518518517), ((2, 1), 0.17073170731707318), ((1, 2), 0.15217391304347827), ((0, 2), 0.14814814814814814), ((3, 0), 0.1388888888888889), ((2, 0), 0.0975609756097561)]

# 排序完成之后就可以输出置信度最高的前5条
for i in range(5):
 print("规则: #{0}".format(i))
 fruit, also_fruit = sorted_confidence_degrees[i][0]
 print_rule(fruit, also_fruit, support_degrees, confidence_degrees, products_name)

输出

 规则: #0
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【奶酪】
 - 置信度是: 0.694
 - 支持度是: 25
 规则: #1
 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【香蕉】
 - 置信度是: 0.659
 - 支持度是: 27
 规则: #2
 规则: 如果一个人买了商品【面包】，那么他可能买商品【香蕉】
 - 置信度是: 0.630
 - 支持度是: 17
 规则: #3
 规则: 如果一个人买了商品【奶酪】，那么他可能买商品【苹果】
 - 置信度是: 0.610
 - 支持度是: 25
 规则: #4
 规则: 如果一个人买了商品【苹果】，那么他可能买商品【香蕉】
 - 置信度是: 0.583
 - 支持度是: 21

从排序结果来看，“顾客买苹果，也会买奶酪”和“顾客买奶酪，也会买香蕉”，这两条规则的支持度和置信度都很高。

超市经理可以根据这些规则来调整商品摆放位置。

例如，如果本周苹果促销，就在旁边摆上奶酪。

但是香蕉和奶酪同时搞促销就没有多大意义了，因为我们发现购买奶酪的顾客中，接近66%的人即使不搞促销也会买香蕉——即使搞促销，也不会给销量带来多大提升

实例代码：https://github.com/durban89/python_data_mining_Affinity-analysis

Python数据挖掘入门-环境配置(Python Data Mining Primer - Environment Configuration)

Mon, 28 Jul 2025 17:52:24 +0800

1】创建虚拟环境

virtualenv -p /usr/local/Cellar/python/3.6.5/bin/python3 .env3

此处的python路径根据自己本地的环境来配置，如果本地安装的默认的就是python3的版本，可以直接创建虚拟环境，或者不创建虚拟环境也是可以的，只要保持本地的python版本是3以上的就好了。我这里的python版本是“Python 3.6.5”

提示：如果你没有安装virtualenv、python等基础的软件，请自行google安装，或者加群交流

安装完之后执行

source .env3/bin/activate

激活python3的运行环境

2】安装ipython

pip install ipython[all]

这里注意别安装错误了

pip install ipython

跟

pip install ipython[all]

是不一样的

3】运行notebook

jupyter notebook

运行后会自动打开一个页面，界面类似如下

4】安装scikit-learn库

scikit-learn库是Pythonk开发的机器学习库，这个库包含大量的机器机器算法、数据集、工具和框架

pip install scikit-learn

好了，以上我们就搭建了数据挖掘需要的基本环境

Python 入门基础知识 - 多媒体编程 - PIL处理图片之为图片添加Logo

Mon, 28 Jul 2025 17:48:31 +0800

为图片添加Logo

使用PIL为图片添加Logo，主要使用Image的paste函数。paste函数可以向图片中粘贴其他的图片。代码实例如下，使用PIL模块为图片批量添加Logo

# _*_ coding: utf-8 -*-
# version 2.7.13
# osx

import os
from PIL import Image
import Tkinter
import tkFileDialog
import tkMessageBox

class Window:
 def __init__(self):
 self.root = root = Tkinter.Tk()
 self.Image = Tkinter.StringVar()
 self.status = Tkinter.StringVar()
 self.mstatus = Tkinter.IntVar()
 self.fstatus = Tkinter.IntVar()
 self.pstatus = Tkinter.IntVar()
 self.Image.set('bmp')
 self.mstatus.set(0)
 self.fstatus.set(0)
 self.pstatus.set(0)
 label = Tkinter.Label(root, text='Logo')
 label.place(x=5, y=5)
 self.entryLogo = Tkinter.Entry(root)
 self.entryLogo.place(x=55, y=5)

 self.buttonBrowserLogo = Tkinter.Button(
 root, text='浏览', command=self.BrowserLogo)
 self.buttonBrowserLogo.place(x=200, y=5)

 self.checkM = Tkinter.Checkbutton(root, text='批量转换',
 command=self.OnCheckM,
 variable=self.mstatus,
 onvalue=1,
 offvalue=0)
 self.checkM.place(x=5, y=30)
 label = Tkinter.Label(root, text='选择文件')
 label.place(x=5, y=55)
 self.entryFile = Tkinter.Entry(root)
 self.entryFile.place(x=55, y=55)
 self.buttonBrowserFile = Tkinter.Button(root, text='浏览',
 command=self.BrowserFile)
 self.buttonBrowserFile.place(x=200, y=55)
 label = Tkinter.Label(root, text='选择目录')
 label.place(x=5, y=80)
 self.entryDir = Tkinter.Entry(root, state=Tkinter.DISABLED)
 self.entryDir.place(x=55, y=80)
 self.buttonBrowserDir = Tkinter.Button(root, text='浏览',
 command=self.BrowserDir,
 state=Tkinter.DISABLED)
 self.buttonBrowserDir.place(x=200, y=80)
 self.checkF = Tkinter.Checkbutton(root, text='改变文件格式',
 command=self.OnCheckF,
 variable=self.fstatus,
 onvalue=1,
 offvalue=0)
 self.checkF.place(x=5, y=110)
 frame = Tkinter.Frame(root)
 frame.place(x=10, y=130)
 labelTo = Tkinter.Label(frame, text='格式')
 labelTo.pack(anchor='w')
 self.rBmp = Tkinter.Radiobutton(frame, variable=self.Image,
 value='bmp',
 text='BMP',
 state=Tkinter.DISABLED)
 self.rBmp.pack(anchor='w')
 self.rJpg = Tkinter.Radiobutton(frame, variable=self.Image,
 value='jpg',
 text='JPG',
 state=Tkinter.DISABLED)
 self.rJpg.pack(anchor='w')
 self.rGif = Tkinter.Radiobutton(frame, variable=self.Image,
 value='gif',
 text='GIF',
 state=Tkinter.DISABLED)
 self.rGif.pack(anchor='w')
 self.rPng = Tkinter.Radiobutton(frame, variable=self.Image,
 value='png',
 text='PNG',
 state=Tkinter.DISABLED)
 self.rPng.pack(anchor='w')

 pframe = Tkinter.Frame(root)
 pframe.place(x=70, y=130)

 labelPos = Tkinter.Label(pframe, text='位置')
 labelPos.pack(anchor='w')

 self.rLT = Tkinter.Radiobutton(
 pframe, variable=self.pstatus, value=0, text='左上角')
 self.rLT.pack(anchor='w')

 self.rRT = Tkinter.Radiobutton(
 pframe, variable=self.pstatus, value=1, text='右上角')
 self.rRT.pack(anchor='w')

 self.rLB = Tkinter.Radiobutton(
 pframe, variable=self.pstatus, value=2, text='左下角')
 self.rLB.pack(anchor='w')

 self.rRB = Tkinter.Radiobutton(
 pframe, variable=self.pstatus, value=3, text='左上角')
 self.rRB.pack(anchor='w')

 self.buttonAdd = Tkinter.Button(root, text='添加', command=self.Add)
 self.buttonAdd.place(x=180, y=175)

 self.labelStatus = Tkinter.Label(root, textvariable=self.status)
 self.labelStatus.place(x=150, y=205)

 def MainLoop(self): # 进入消息循环
 self.root.minsize(250, 250)
 self.root.maxsize(250, 250)
 self.root.mainloop()

 def BrowserLogo(self):
 file = tkFileDialog.askopenfilename(title='Python Music Player', filetypes=[(
 'JPG', '*.jpg'), ('BMP', '*.bmp'), ('PNG', '*.png'), ('GIF', '*.gif')])
 if file:
 self.entryLogo.delete(0, Tkinter.END)
 self.entryLogo.insert(Tkinter.END, file)

 def BrowserDir(self):
 directory = tkFileDialog.askdirectory(title='Python')
 if directory:
 self.entryDir.delete(0, Tkinter.END)
 self.entryDir.insert(Tkinter.END, directory)

 def BrowserFile(self):
 file = tkFileDialog.askopenfilename(title='Python Music Player', filetypes=[(
 'JPG', '*.jpg'), ('BMP', '*.bmp'), ('PNG', '*.png'), ('GIF', '*.gif')])
 if file:
 self.entryFile.delete(0, Tkinter.END)
 self.entryFile.insert(Tkinter.END, file)

 def OnCheckM(self): # 设置组件状态
 if not self.mstatus.get():
 self.entryDir.config(state=Tkinter.DISABLED)
 self.entryFile.config(state=Tkinter.NORMAL)
 self.buttonBrowserDir.config(state=Tkinter.DISABLED)
 self.buttonBrowserFile.config(state=Tkinter.NORMAL)
 else:
 self.entryDir.config(state=Tkinter.NORMAL)
 self.entryFile.config(state=Tkinter.DISABLED)
 self.buttonBrowserDir.config(state=Tkinter.NORMAL)
 self.buttonBrowserFile.config(state=Tkinter.DISABLED)

 def OnCheckF(self): # 设置组件状态
 if not self.fstatus.get():
 self.rBmp.config(state=Tkinter.DISABLED)
 self.rJpg.config(state=Tkinter.DISABLED)
 self.rGif.config(state=Tkinter.DISABLED)
 self.rPng.config(state=Tkinter.DISABLED)
 else:
 self.rBmp.config(state=Tkinter.NORMAL)
 self.rJpg.config(state=Tkinter.NORMAL)
 self.rGif.config(state=Tkinter.NORMAL)
 self.rPng.config(state=Tkinter.NORMAL)

 def Add(self):
 n = 0
 if self.mstatus.get():
 path = self.entryDir.get()
 if path == '':
 tkMessageBox.showerror('Python Tkinter', '请输入路径')
 return

 filenames = os.listdir()
 if self.fstatus.get():
 f = self.Image.get()
 for filename in filenames:
 if filename[-3:] in ('bmp', 'jpg', 'gif', 'png'):
 self.addlogo(path + '/' + filename, f)
 n = n + 1
 else:
 for filename in filenames:
 if filename[-3:] in ('bmp', 'jpg', 'gif', 'png'):
 self.addlogo(path + '/' + filename)
 n = n + 1
 else:
 file = self.entryFile.get()
 if file == '':
 tkMessageBox.showerror('Python Tkinter', '请选择文件')
 return

 if self.fstatus.get():
 f = self.Image.get()
 self.addlogo(file, f)
 n = n + 1
 else:
 self.addlogo(file)
 n = n + 1

 self.status.set('成功添加%d图片' % n)

 def addlogo(self, file, format=None):
 logo = self.entryLogo.get()
 if logo == '':
 tkMessageBox.showerror('Python Tkinter', '请选择logo')

 im = Image.open(file)
 lo = Image.open(logo)
 imwidth, imheight = im.size
 lowidth, loheight = lo.size

 pos = self.pstatus.get()
 if pos == 0:
 left = 0
 top = 0
 right = lowidth
 bottom = loheight
 elif pos == 1:
 left = imwidth - lowidth
 top = 0
 right = imwidth
 bottom = loheight
 elif pos == 2:
 left = 0
 top = imheight - loheight
 right = lowidth
 bottom = imheight
 else:
 left = imwidth - lowidth
 top = imheight - loheight
 right = imwidth
 bottom = imheight

 im.paste(lo, (left, top, right, bottom))
 if format:
 im.save(file[:len(file)-4] + '_logo.' + format)
 else:
 im.save(file[:len(file)-4] + '_logo' + file[-4:])

window = Window()
window.MainLoop()

运行后效果如下

Python 入门基础知识 - 多媒体编程 - PIL处理图片之生成缩略图

Mon, 28 Jul 2025 17:39:07 +0800

生成缩略图

使用PIL生成缩略图主要是使用Image的size函数。使用size函数可以重新指定图片的大小，代码实例如下，使用PIL模块批量生成图片缩略图

# _*_ coding: utf-8 -*-
# version 2.7.13

import os
from PIL import Image
import Tkinter
import tkFileDialog
import tkMessageBox

class Window:
 def __init__(self):
 self.root = root = Tkinter.Tk()
 self.Image = Tkinter.StringVar()
 self.status = Tkinter.StringVar()
 self.mstatus = Tkinter.IntVar()
 self.fstatus = Tkinter.IntVar()
 self.Image.set('bmp')
 self.mstatus.set(0)
 self.fstatus.set(0)
 label = Tkinter.Label(root, text='输入百分比')
 label.place(x=5, y=5)
 self.entryNew = Tkinter.Entry(root)
 self.entryNew.place(x=65, y=5)
 self.checkM = Tkinter.Checkbutton(root, text='批量转换',
 command=self.OnCheckM,
 variable=self.mstatus,
 onvalue=1,
 offvalue=0)
 self.checkM.place(x=5, y=30)
 label = Tkinter.Label(root, text='选择文件')
 label.place(x=5, y=55)
 self.entryFile = Tkinter.Entry(root)
 self.entryFile.place(x=55, y=55)
 self.buttonBrowserFile = Tkinter.Button(root, text='浏览',
 command=self.BrowserFile)
 self.buttonBrowserFile.place(x=200, y=55)
 label = Tkinter.Label(root, text='选择目录')
 label.place(x=5, y=80)
 self.entryDir = Tkinter.Entry(root, state=Tkinter.DISABLED)
 self.entryDir.place(x=55, y=80)
 self.buttonBrowserDir = Tkinter.Button(root, text='浏览',
 command=self.BrowserDir,
 state=Tkinter.DISABLED)
 self.buttonBrowserDir.place(x=200, y=80)
 self.checkF = Tkinter.Checkbutton(root, text='改变文件格式',
 command=self.OnCheckF,
 variable=self.fstatus,
 onvalue=1,
 offvalue=0)
 self.checkF.place(x=5, y=110)
 frame = Tkinter.Frame(root)
 frame.place(x=10, y=130)
 labelTo = Tkinter.Label(frame, text='To')
 labelTo.pack(anchor='w')
 self.rBmp = Tkinter.Radiobutton(frame, variable=self.Image,
 value='bmp',
 text='BMP',
 state=Tkinter.DISABLED)
 self.rBmp.pack(anchor='w')
 self.rJpg = Tkinter.Radiobutton(frame, variable=self.Image,
 value='jpg',
 text='JPG',
 state=Tkinter.DISABLED)
 self.rJpg.pack(anchor='w')
 self.rGif = Tkinter.Radiobutton(frame, variable=self.Image,
 value='gif',
 text='GIF',
 state=Tkinter.DISABLED)
 self.rGif.pack(anchor='w')
 self.rPng = Tkinter.Radiobutton(frame, variable=self.Image,
 value='png',
 text='PNG',
 state=Tkinter.DISABLED)
 self.rPng.pack(anchor='w')
 self.buttonConv = Tkinter.Button(root, text='转换', command=self.Conv)
 self.buttonConv.place(x=100, y=175)
 self.labelStatus = Tkinter.Label(root, textvariable=self.status)
 self.labelStatus.place(x=80, y=205)

 def MainLoop(self): # 进入消息循环
 self.root.minsize(250, 250)
 self.root.maxsize(250, 250)
 self.root.mainloop()

 def BrowserDir(self):
 directory = tkFileDialog.askdirectory(title='Python')
 if directory:
 self.entryDir.delete(0, Tkinter.END)
 self.entryDir.insert(Tkinter.END, directory)

 def BrowserFile(self):
 file = tkFileDialog.askopenfilename(title='Python Music Player', filetypes=[('JPG','*.jpg'),('BMP', '*.bmp'),('PNG', '*.png'),('GIF', '*.gif')])
 if file:
 self.entryFile.delete(0, Tkinter.END)
 self.entryFile.insert(Tkinter.END, file)

 def OnCheckM(self): # 设置组件状态
 if not self.mstatus.get():
 self.entryDir.config(state=Tkinter.DISABLED)
 self.entryFile.config(state=Tkinter.NORMAL)
 self.buttonBrowserDir.config(state=Tkinter.DISABLED)
 self.buttonBrowserFile.config(state=Tkinter.NORMAL)
 else:
 self.entryDir.config(state=Tkinter.NORMAL)
 self.entryFile.config(state=Tkinter.DISABLED)
 self.buttonBrowserDir.config(state=Tkinter.NORMAL)
 self.buttonBrowserFile.config(state=Tkinter.DISABLED)

 def OnCheckF(self): # 设置组件状态
 if not self.fstatus.get():
 self.rBmp.config(state=Tkinter.DISABLED)
 self.rJpg.config(state=Tkinter.DISABLED)
 self.rGif.config(state=Tkinter.DISABLED)
 self.rPng.config(state=Tkinter.DISABLED)
 else:
 self.rBmp.config(state=Tkinter.NORMAL)
 self.rJpg.config(state=Tkinter.NORMAL)
 self.rGif.config(state=Tkinter.NORMAL)
 self.rPng.config(state=Tkinter.NORMAL)

 def Conv(self):
 n = 0
 if self.mstatus.get():
 path = self.entryDir.get()
 if path == '':
 tkMessageBox.showerror('Python Tkinter', '请输入路径')
 return

 filenames = os.listdir()
 if self.fstatus.get():
 f = self.Image.get()
 for filename in filenames:
 if filename[-3:] in ('bmp','jpg','gif','png'):
 self.make(path + '/' + filename, f)
 n = n + 1
 else:
 for filename in filenames:
 if filename[-3:] in ('bmp', 'jpg', 'gif', 'png'):
 self.make(path + '/' + filename)
 n = n + 1
 else:
 file = self.entryFile.get()
 if file == '':
 tkMessageBox.showerror('Python Tkinter', '请选择文件')
 return

 if self.fstatus.get():
 f = self.Image.get()
 self.make(file, f)
 n = n + 1
 else:
 self.make(file)
 n = n + 1

 self.status.set('成功转换%d图片' % n)

 def make(self, file, format=None):
 im = Image.open(file)
 mode = im.mode
 if mode not in ('L', 'RGB'):
 im = im.convert('RGB')

 width, height = im.size
 s = self.entryNew.get()
 if s == '':
 tkMessageBox.showerror('Python Tkinter', '请输入百分比')
 return
 else:
 n = int(s)

 nwidth = width * n / 100
 nheight = height * n / 100
 thumb = im.resize((nwidth, nheight), Image.ANTIALIAS)
 if format:
 thumb.save(file[:len(file)-4] + '_thumb.' + format)
 else:
 thumb.save(file[:len(file)-4] + '_thumb' + file[-4:])

window = Window()
window.MainLoop()

执行后的结果如下

Python 入门基础知识 - 多媒体编程 - PIL处理图片之转换图片格式

Mon, 28 Jul 2025 17:39:02 +0800

转换图片格式

使用PIL转换图片格式，主要是使用PIL的Image模块。首先使用Image.open函数打开文件，然后将文件保存成所需要的格式即可。Image可以根据文件的扩展名自动选择文件保存的格式，因此不需要设置文件格式。如下所示的代码演示，使用Image模块进行批量图片文件格式转换。


# _*_ coding: utf-8 -*-
# version 2.7.13

import os
from PIL import Image
import Tkinter
import tkFileDialog
import tkMessageBox

class Window:

 def __init__(self):
 self.root = root = Tkinter.Tk()
 label = Tkinter.Label(root, text='选择目录')
 label.place(x=5, y=5)
 self.entry = Tkinter.Entry(root)
 self.entry.place(x=55, y=5)
 self.buttonBrowser = Tkinter.Button(
 root, text='浏览', command=self.Browser)
 self.buttonBrowser.place(x=200, y=5)
 frameF = Tkinter.Frame(root)
 frameF.place(x=5, y=30)
 frameT = Tkinter.Frame(root)
 frameT.place(x=100, y=30)
 self.fImage = Tkinter.StringVar()
 self.tImage = Tkinter.StringVar()
 self.status = Tkinter.StringVar()
 self.fImage.set('.bmp')
 self.tImage.set('.bmp')
 labelFrom = Tkinter.Label(frameF, text='From')
 labelFrom.pack(anchor='w')
 labelTo = Tkinter.Label(frameT, text='To')
 labelTo.pack(anchor='w')
 frBmp = Tkinter.Radiobutton(
 frameF, variable=self.fImage, value='.bmp', text='BMP')
 frBmp.pack(anchor='w')

 frJpg = Tkinter.Radiobutton(
 frameF, variable=self.fImage, value='.jpg', text='JPG')
 frJpg.pack(anchor='w')

 frGif = Tkinter.Radiobutton(
 frameF, variable=self.fImage, value='.gif', text='GIF')
 frGif.pack(anchor='w')

 frPng = Tkinter.Radiobutton(
 frameF, variable=self.fImage, value='.png', text='PNG')
 frPng.pack(anchor='w')

 trBmp = Tkinter.Radiobutton(
 frameT, variable=self.tImage, value='.bmp', text='BMP')
 trBmp.pack(anchor='w')

 trJpg = Tkinter.Radiobutton(
 frameT, variable=self.tImage, value='.jpg', text='JPG')
 trJpg.pack(anchor='w')

 trGif = Tkinter.Radiobutton(
 frameT, variable=self.tImage, value='.gif', text='GIF')
 trGif.pack(anchor='w')

 trPng = Tkinter.Radiobutton(
 frameT, variable=self.tImage, value='.png', text='PNG')
 trPng.pack(anchor='w')

 self.buttonConv = Tkinter.Button(root, text='转换', command=self.Conv)
 self.buttonConv.place(x=100, y=150)
 self.labelStatus = Tkinter.Label(root, textvariable=self.status)
 self.labelStatus.place(x=50, y=175)

 def MainLoop(self):
 self.root.minsize(250, 200)
 self.root.maxsize(250, 200)
 self.root.mainloop()

 def Browser(self):
 directory = tkFileDialog.askdirectory(title='Python')
 if directory:
 self.entry.delete(0, Tkinter.END)
 self.entry.insert(Tkinter.END, directory)

 def Conv(self):
 n = 0
 t = self.tImage.get()
 f = self.fImage.get()
 path = self.entry.get()
 if path == '':
 tkMessageBox.showerror('Python Tkinter', '请输入路径')
 return

 filenames = os.listdir(path)
 os.mkdir(path + '/' + t[-3:])
 for filename in filenames:
 if filename[-4:] == f:
 Image.open(path + '/' + filename)\
 .save(path + '/' + t[-3:] + '/' + filename[:-4] + t)
 n = n + 1

 self.status.set('成功转换%d张图片' % n)

window = Window()
window.MainLoop()

运行效果如下

Python 入门基础知识 - 使用PIL处理图片

Mon, 28 Jul 2025 17:06:49 +0800

使用PIL处理图片

PIL(Python Imaging Library)为Python提供了强大的图形处理能力，并支持多种图形文件格式。通过使用PIL模块，可以使用Python对图片进行处理。

PIL的安装

PIL是跨平台的，在Mac下可以使用PIL的强大功能。由于PIL不是Python自带的模块，因此需要用户自己安装。

执行下面的命令

pip install pillow

出现类型如下内容

Installing collected packages: pillow
Successfully installed pillow-5.0.0

代表已经安装成功

PIL简介

在PIL中提供了以下主要模块对图片进行处理

Image: PIL的主要模块

ImageChops: 图片计算模块

ImageColor: 颜色模块

ImageDraw: 绘图模块

ImageEnchace: 图片效果模块

ImageFile: 图片文件存取模块

ImageFileIO: 图片流模块

ImageFilter: 图片过滤模块

ImageFont: 字形模块，用于绘图

ImageGrab: 图片抓取模块

ImageOps: 图片处理模块

ImagePath: 路径队列模块

ImagePalette: 图片调色板模块

ImageSequence: 队列包装模块

ImageStat: 图片属性模块

ImageTk: 提供对Tkinter模块

ImageWin: 提供对Windows的支持

PSDraw: 提供对PostScript的支持

对于简单的图片处理一般仅需要使用Image模块，此处仅对Image模块中的主要函数进行简要的介绍，其他模块中的函数可以参考PIL的帮助文档。

1、打开图片

Image模块中主要的函数时open函数，其用于打开图片。函数原型如下

open(file, mode)

参数含义如下

fiile: 要打开的图片文件

model: 可选参数，打开文件的方式

2、复制图片

open函数执行成功后返回一个Image对象，使用Imagem模块的copy方法可以复制图片，使用crop方法可以复制图片中的某一个区域，函数原型如下

crop(box)

参数含义如下

box: 一个由4个元素组成的元组，分别表示图片的左、上、右、下的位置。

3、粘贴图片

使用Image对象的paste方法可以向图片中粘贴图片、图像，paste方法有以下几种形式。

paste(image, box)

paste(color, box)

paste(image, box)

paste(image, box, mask)

paste(color, box, mask)

参数含义如下

image: 被粘贴到图片中的图片对象

box: 所要粘贴的区域，同crop中的参数box

color: 填充的颜色

mask: 指定填充颜色透明度

4、调整图片大小

使用Image对象的resize方法可以重新调整图片的大小。函数原型如下

resize(size, filter)

参数含义如下

size: 图片调整后的大小，为由宽和高组成的元组

filter: 可选参数，可以是NEAREST、BILINEAR、BICUBIC或者ANTIALIAS

5、旋转图片

使用Imaged对象的rotate方法可以选装图片。函数原型如下

rotate(angle, filter, expand)

参数含义如下

angle: 旋转的角度

filter: 可选参数，同resize中的filter参数

expand: 可选参数，如果为真，则增大图片，以容纳旋转后的图片，否则保持图片尺寸。

6、显示图片

使用Image对象的show方法可以显示图片。使用Image对象的save方法可以保存图像，函数原型如下

save(outfile, format, options)

参数含义如下

outfile: 所保存的文件名

format: 可选参数，保存的文件格式。如果不给出，将根据保存的文件名的扩展名进行存储。

options: 其他的操作参数

另外，Image对象还有size属性，其有宽和高组成的元组。Image对象的format属性为图片的格式。Image对象的mode属性为图片的模式。

Python 入门基础知识 - 多媒体编程 - PyGame

Mon, 28 Jul 2025 17:06:30 +0800

PyGame

PyGame是用来编写游戏的Python模块。PyGame是基于SDL的，SDL(Simple DirectMedia Layer)是一个跨平台的多媒体开发包，SDL专门为游戏h额多媒体设计。使用PyGame可以创建使用SDL库创建的游戏和多媒体程序。

如何安装PyGame

具体的安装细节，读者可以到这里查找https://www.pygame.org/wiki/GettingStarted#Pygame Installation

我这里使用的是mac，我就介绍下在mac下的安装过程

执行如下命令

pip install pygame

如果出现如下类似内容

Installing collected packages: pygame
Successfully installed pygame-1.9.3

说明就是安装成功了

PyGame简单的使用介绍

下面演示实例，简单的创建一个游戏窗口

# _*_ coding: utf-8 -*-
# version 2.7.13

import pygame
import sys
from pygame.locals import *

pygame.init()
DISPLAYSURF = pygame.display.set_mode((400, 300))
pygame.display.set_caption('Hello World!')
while True: # main game loop
 for event in pygame.event.get():
 if event.type == QUIT:
 pygame.quit()
 sys.exit()
 pygame.display.update()

运行结果如下

Python 入门基础知识 - 多媒体编程 - 使用PyOpenGL绘制3D图形(五)

Mon, 28 Jul 2025 17:06:27 +0800

纹理映射

在PyOpenGL中处理纹理贴图需要使用PIL模块，在下篇文章中讲解PIL模块详细的使用方法。实例代码如下，绘制了一个立方体，并对每一个面进行贴图，在代码中使用glutIdleFunc函数，设置了空闲时的场景绘制函数，创建了立方体旋转dd额动画。


# _*_ coding: utf-8 -*-
# version 2.7.13

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys
from PIL import Image

class OpenGLWindow:
 # 初始化

 def __init__(self, width=640, height=480, title='PyOpenGL'):
 # 传递命令行参数
 glutInit(sys.argv)
 # 设置显示模式
 glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
 # 设置窗口大小
 glutInitWindowSize(width, height)
 # 创建窗口
 self.window = glutCreateWindow(title)
 # 设置场景绘制函数
 glutDisplayFunc(self.Draw)
 # 设置空闲时场景绘制函数
 glutIdleFunc(self.Draw)
 # 调用OpenGL初始化函数
 self.InitGL(width, height)
 self.x = 0.2
 self.y = 0.2
 self.z = 0.2
 # 绘制场景

 def Draw(self):
 # 清除屏幕和深度缓存
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 # 重置观察矩阵
 glLoadIdentity()
 # 移动位置
 glTranslatef(0.0, 0.0, -5.0)
 # 绕x轴旋转
 glRotate(self.x, 1.0, 0.0, 0.0)
 # 绕y轴旋转
 glRotate(self.y, 0.0, 1.0, 0.0)
 # 绕z轴旋转
 glRotate(self.z, 0.0, 0.0, 1.0)
 # 绘制立方体
 glBegin(GL_QUADS)
 # 对前面进行贴图
 glTexCoord2f(0.0, 0.0)
 glVertex3f(-1.0, -1.0, 1.0)
 glTexCoord2f(1.0, 0.0)
 glVertex3f(1.0, -1.0, 1.0)
 glTexCoord2f(1.0, 1.0)
 glVertex3f(1.0, 1.0, 1.0)
 glTexCoord2f(0.0, 0.0)
 glVertex3f(-1.0, 1.0, 1.0)
 # 对后面进行贴图
 glTexCoord2f(1.0, 0.0)
 glVertex3f(-1.0, -1.0, -1.0)
 glTexCoord2f(1.0, 1.0)
 glVertex3f(-1.0, 1.0, -1.0)
 glTexCoord2f(0.0, 1.0)
 glVertex3f(1.0, 1.0, -1.0)
 glTexCoord2f(0.0, 0.0)
 glVertex3f(1.0, -1.0, -1.0)
 # 对顶面进行贴图
 glTexCoord2f(0.0, 1.0)
 glVertex3f(-1.0, 1.0, -1.0)
 glTexCoord2f(0.0, 0.0)
 glVertex3f(-1.0, 1.0, 1.0)
 glTexCoord2f(1.0, 0.0)
 glVertex3f(1.0, 1.0, 1.0)
 glTexCoord2f(1.0, 1.0)
 glVertex3f(1.0, 1.0, -1.0)
 # 对底面进行贴图
 glTexCoord2f(1.0, 1.0)
 glVertex3f(-1.0, -1.0, -1.0)
 glTexCoord2f(0.0, 1.0)
 glVertex3f(1.0, -1.0, -1.0)
 glTexCoord2f(0.0, 0.0)
 glVertex3f(1.0, -1.0, 1.0)
 glTexCoord2f(1.0, 0.0)
 glVertex3f(-1.0, -1.0, 1.0)
 # 对右侧面进行贴图
 glTexCoord2f(1.0, 0.0)
 glVertex3f(1.0, -1.0, -1.0)
 glTexCoord2f(1.0, 1.0)
 glVertex3f(1.0, 1.0, -1.0)
 glTexCoord2f(0.0, 1.0)
 glVertex3f(1.0, 1.0, 1.0)
 glTexCoord2f(0.0, 0.0)
 glVertex3f(1.0, -1.0, 1.0)
 # 对左侧面进行贴图
 glTexCoord2f(0.0, 0.0)
 glVertex3f(-1.0, -1.0, -1.0)
 glTexCoord2f(1.0, 0.0)
 glVertex3f(-1.0, -1.0, 1.0)
 glTexCoord2f(1.0, 1.0)
 glVertex3f(-1.0, 1.0, 1.0)
 glTexCoord2f(0.0, 1.0)
 glVertex3f(-1.0, 1.0, -1.0)
 # 结束绘制
 glEnd()
 # 交换缓存
 glutSwapBuffers()
 # 旋转角度增加
 self.x = self.x + 0.2
 self.y = self.y + 0.2
 self.z = self.z + 0.2

 # OpenGL初始化函数
 def InitGL(self, width, height):
 # 载入纹理
 self.LoadTextures()
 # 允许纹理映射
 glEnable(GL_TEXTURE_2D)

 # 设置为黑色背景
 glClearColor(0.0, 0.0, 0.0, 0.0)
 # 设置深度缓存
 glClearDepth(1.0)
 # 设置深度测试类型
 glDepthFunc(GL_LESS)
 # 允许深度测试
 glEnable(GL_DEPTH_TEST)
 # 启动平滑阴影
 glShadeModel(GL_SMOOTH)
 # 设置观察矩阵
 glMatrixMode(GL_PROJECTION)
 # 重置观察矩阵
 glLoadIdentity()
 # 设置屏幕宽高比
 gluPerspective(45.0, float(width) / float(height), 0.1, 100.0)
 # 设置观察矩阵
 glMatrixMode(GL_MODELVIEW)

 def LoadTextures(self): # 载入纹理图片
 # 打开图片
 image = Image.open('jonatan-pie-226805.jpg')
 # 图像宽度
 width = image.size[0]
 # 图像高度
 height = image.size[0]
 # 转换图像
 image = image.tobytes('raw', 'RGBX', 0, -1)
 # 创建纹理
 glBindTexture(GL_TEXTURE_2D, glGenTextures(1))
 glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
 glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height,
 0, GL_RGBA, GL_UNSIGNED_BYTE, image)
 glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP)
 glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP)

 glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
 glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)

 glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
 glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)

 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)

 def MainLoop(self):
 # 进入消息循环
 glutMainLoop()

# 创建窗口
window = OpenGLWindow()
# 进入消息循环
window.MainLoop()

运行结果如下

Python 入门基础知识 - 多媒体编程 - 使用PyOpenGL绘制3D图形(四)

Mon, 28 Jul 2025 17:06:24 +0800

绘制3D图形

在PyOpenGL中绘制3D图形时和绘制2D图形类似，通过设置Z坐标，可以设置图形所在的空间位置。代码实例演示如下，绘制了一个立方体

# _*_ coding: utf-8 -*-
# version 2.7.13

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys

class OpenGLWindow:
 # 初始化

 def __init__(self, width=640, height=480, title='PyOpenGL'):
 # 传递命令行参数
 glutInit(sys.argv)
 # 设置显示模式
 glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
 # 设置窗口大小
 glutInitWindowSize(width, height)
 # 创建窗口
 self.window = glutCreateWindow(title)
 # 设置场景绘制函数
 glutDisplayFunc(self.Draw)
 # 调用OpenGL初始化函数
 self.InitGL(width, height)

 # 绘制场景
 def Draw(self):
 # 清除屏幕和深度缓存
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 # 重置观察矩阵
 glLoadIdentity()
 # 移动位置
 glTranslatef(1.5, 0.0, -7.0)
 # 绕x、y、z轴旋转45度
 glRotate(45, 1.0, 1.0, 1.0)
 # 绘制立方体
 glBegin(GL_QUADS)
 # 设置颜色为红色
 glColor3f(1.0, 0.0, 0.0)
 # 绘制立体的顶面
 glVertex3f(1.0, 1.0, -1.0)
 glVertex3f(-1.0, 1.0, -1.0)
 glVertex3f(-1.0, 1.0, 1.0)
 glVertex3f(1.0, 1.0, 1.0)
 # 设置颜色为绿色
 glColor3f(0.0, 1.0, 0.0)
 glVertex3f(1.0, -1.0, 1.0)
 glVertex3f(-1.0, -1.0, 1.0)
 glVertex3f(-1.0, -1.0, -1.0)
 glVertex3f(1.0, -1.0, -1.0)
 # 设置颜色为蓝色
 glColor3f(0.0, 0.0, 1.0)
 glVertex3f(1.0, 1.0, 1.0)
 glVertex3f(-1.0, 1.0, 1.0)
 glVertex3f(-1.0, -1.0, 1.0)
 glVertex3f(1.0, -1.0, 1.0)

 # 设置颜色为红色
 glColor3f(1.0, 0.0, 0.0)
 # 绘制立体的顶面
 glVertex3f(1.0, -1.0, -1.0)
 glVertex3f(-1.0, -1.0, -1.0)
 glVertex3f(-1.0, 1.0, -1.0)
 glVertex3f(1.0, 1.0, -1.0)
 # 设置颜色为绿色
 glColor3f(0.0, 1.0, 0.0)
 glVertex3f(-1.0, 1.0, 1.0)
 glVertex3f(-1.0, 1.0, -1.0)
 glVertex3f(-1.0, -1.0, -1.0)
 glVertex3f(-1.0, -1.0, 1.0)
 # 设置颜色为蓝色
 glColor3f(0.0, 0.0, 1.0)
 glVertex3f(1.0, 1.0, -1.0)
 glVertex3f(1.0, 1.0, 1.0)
 glVertex3f(1.0, -1.0, 1.0)
 glVertex3f(1.0, -1.0, -1.0)

 # 结束绘制
 glEnd()
 # 交换缓存
 glutSwapBuffers()

 # OpenGL初始化函数
 def InitGL(self, width, height):
 # 设置为黑色背景
 glClearColor(0.0, 0.0, 0.0, 0.0)
 # 设置深度缓存
 glClearDepth(1.0)
 # 设置深度测试类型
 glDepthFunc(GL_LESS)
 # 允许深度测试
 glEnable(GL_DEPTH_TEST)
 # 启动平滑阴影
 glShadeModel(GL_SMOOTH)
 # 设置观察矩阵
 glMatrixMode(GL_PROJECTION)
 # 重置观察矩阵
 glLoadIdentity()
 # 设置屏幕宽高比
 gluPerspective(45.0, float(width) / float(height), 0.1, 100.0)
 # 设置观察矩阵
 glMatrixMode(GL_MODELVIEW)

 def MainLoop(self):
 # 进入消息循环
 glutMainLoop()

# 创建窗口
window = OpenGLWindow()
# 进入消息循环
window.MainLoop()

Python 入门基础知识 - 多媒体编程 - 使用PyOpenGL绘制3D图形(三)

Mon, 28 Jul 2025 17:06:20 +0800

绘制2D图形

在PyOpenGL中绘制图形时应以glBegin函数开始，当绘制完成后应调用glEnd函数。glBegin函数原型如下所示。

glBegin(mode)

参数含义如下

mode: 绘制的图形

其中可以选择的图形有以下几种。

GL_POINTS: 绘制点

GL_LINES: 绘制直线

GL_LINES_STRIP: 绘制连续直线，不封闭

GL_LINE_LOOP: 绘制连续直线，封闭

GL_TRIANGLES: 绘制三角形

GL_TRIANGLES_STRIP: 绘制三角形串

GL_TRIANGLES_FAN: 绘制三角扇形

GL_QUADS: 绘制四边形

GL_QUADS_STRIP: 绘制四边形串

GL_POLYGON: 绘制多边形

由于在PyOpenGL中没有提供直接绘制圆形的函数，因此可以使用多边形来模拟绘制圆形，如下代码演示绘制了几种简单的2D图形

# _*_ coding: utf-8 -*-
# version 2.7.13

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys
import math

class OpenGLWindow:
 # 初始化

 def __init__(self, width=640, height=480, title='PyOpenGL'):
 # 传递命令行参数
 glutInit(sys.argv)
 # 设置显示模式
 glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
 # 设置窗口大小
 glutInitWindowSize(width, height)
 # 创建窗口
 self.window = glutCreateWindow(title)
 # 设置场景绘制函数
 glutDisplayFunc(self.Draw)
 # 调用OpenGL初始化函数
 self.InitGL(width, height)

 # 绘制场景
 def Draw(self):
 # 清除屏幕和深度缓存
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 # 重置观察矩阵
 glLoadIdentity()
 # 移动位置
 glTranslatef(-2.0, 2.0, -6.0)
 # 绘制直线
 glBegin(GL_LINES)
 # 直线第一点坐标
 glVertex3f(0.0, 0.0, 0.0)
 # 直线第二点坐标
 glVertex3f(2.0, 0.0, 0.0)
 # 结束绘制
 glEnd()
 # 移动位置
 glTranslatef(3.0, 0.0, 0.0)
 # 通过绘制多边形来模拟圆形
 glBegin(GL_POLYGON)
 i = 0
 while(i <= 3.14 * 2):
 x = 0.5 * math.cos(i)
 y = 0.5 * math.sin(i)
 glVertex3f(x, y, 0.0)
 i = i + 0.01

 glEnd()
 # 移动位置
 glTranslatef(-2.0, -3.0, 0.0)
 # 绘制三角形
 glBegin(GL_POLYGON)
 glVertex3f(0.0, 1.0, 0.0)
 glVertex3f(1.0, -1.0, 0.0)
 glVertex3f(-1.0, -1.0, 0.0)
 glEnd()

 # 移动位置
 glTranslatef(2.5, 0.0, 0.0)
 # 绘制四边形
 glBegin(GL_QUADS)
 glVertex3f(-1.0, 1.0, 0.0)
 glVertex3f(1.0, 1.0, 0.0)
 glVertex3f(1.0, -1.0, 0.0)
 glVertex3f(-1.0, -1.0, 0.0)
 glEnd()
 # 交换缓存
 glutSwapBuffers()

 # 绘制文字函数
 def DrawText(self, string):
 # 循环处理字符串
 for c in string:
 # 输出文字
 glutBitmapCharacter(GLUT_BITMAP_8_BY_13, ord(c))

 # OpenGL初始化函数
 def InitGL(self, width, height):
 # 设置为黑色背景
 glClearColor(0.0, 0.0, 0.0, 0.0)
 # 设置深度缓存
 glClearDepth(1.0)
 # 设置深度测试类型
 glDepthFunc(GL_LESS)
 # 允许深度测试
 glEnable(GL_DEPTH_TEST)
 # 启动平滑阴影
 glShadeModel(GL_SMOOTH)
 # 设置观察矩阵
 glMatrixMode(GL_PROJECTION)
 # 重置观察矩阵
 glLoadIdentity()
 # 设置屏幕宽高比
 gluPerspective(45.0, float(width) / float(height), 0.1, 100.0)
 # 设置观察矩阵
 glMatrixMode(GL_MODELVIEW)

 def MainLoop(self):
 # 进入消息循环
 glutMainLoop()

# 创建窗口
window = OpenGLWindow()
# 进入消息循环
window.MainLoop()

Python 入门基础知识 - 多媒体编程 - 使用PyOpenGL绘制3D图形(二)

Mon, 28 Jul 2025 17:06:17 +0800

绘制文案

使用PyOpenGL绘制文字相对比较复杂，需要使用glutBitmapCharacter函数，其原型如下

glutBitmapCharacter(font, character)

参数含义如下

font: 所使用的字体

chracter: 输出字符的ASCII值

可以选用的字体有如下几种

GLUT_BITMAP_8_BY_13

GLUT_BITMAP_9_BY_15

GLUT_BITMAP_TIMES_ROMAN_10

GLUT_BITMAP_TIMES_ROMAN_24

GLUT_BITMAP_HELVETICA_10

GLUT_BITMAP_HELVETICA_12

GLUT_BITMAP_HELVETICA_18

由于glutBitmapCharacter每次只能输出一个字符，因此需要在脚本中编写函数处理字符串。实例代码如下所示

# _*_ coding: utf-8 -*-
# version 2.7.13

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys

class OpenGLWindow:
 # 初始化

 def __init__(self, width=640, height=480, title='PyOpenGL'):
 # 传递命令行参数
 glutInit(sys.argv)
 # 设置显示模式
 glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
 # 设置窗口大小
 glutInitWindowSize(width, height)
 # 创建窗口
 self.window = glutCreateWindow(title)
 # 设置场景绘制函数
 glutDisplayFunc(self.Draw)
 # 调用OpenGL初始化函数
 self.InitGL(width, height)

 # 绘制场景
 def Draw(self):
 # 清除屏幕和深度缓存
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 # 重置观察矩阵
 glLoadIdentity()
 # 移动位置
 glTranslatef(0.0, 0.0, -1.0)
 # 设置颜色为绿色
 glColor3f(0.0, 1.0, 0.0)
 # 定位文字
 glRasterPos2f(0.0, 0.0)
 # 绘制文字
 self.DrawText('PyOpenGL')
 # 交换缓存
 glutSwapBuffers()

 # 绘制文字函数
 def DrawText(self, string):
 # 循环处理字符串
 for c in string:
 # 输出文字
 glutBitmapCharacter(GLUT_BITMAP_8_BY_13, ord(c))

 # OpenGL初始化函数
 def InitGL(self, width, height):
 # 设置为黑色背景
 glClearColor(0.0, 0.0, 0.0, 0.0)
 # 设置深度缓存
 glClearDepth(1.0)
 # 设置深度测试类型
 glDepthFunc(GL_LESS)
 # 允许深度测试
 glEnable(GL_DEPTH_TEST)
 # 启动平滑阴影
 glShadeModel(GL_SMOOTH)
 # 设置观察矩阵
 glMatrixMode(GL_PROJECTION)
 # 重置观察矩阵
 glLoadIdentity()
 # 设置屏幕宽高比
 gluPerspective(45.0, float(width) / float(height), 0.1, 100.0)
 # 设置观察矩阵
 glMatrixMode(GL_MODELVIEW)

 def MainLoop(self):
 # 进入消息循环
 glutMainLoop()

# 创建窗口
window = OpenGLWindow()
# 进入消息循环
window.MainLoop()

Python 入门基础知识 - 多媒体编程 - 使用PyOpenGL绘制3D图形(一)

Mon, 28 Jul 2025 17:06:12 +0800

Python多媒体编程

使用Python可以进行创建3D图形、播放音乐等多媒体编程。使用PyOpenGL可以创建3D图形。另外使用PyGame可以编写游戏。

使用PyOpenGL绘制3D图形

PyOpenGL模块是对OpenGL的封装，OpenGL提供了不同的函数调用以绘制从简单的图形到复杂的3D图形。使用OpenGL模块可以使用OpenGL中的函数绘制3D图形。

1、安装PyOpenGL

pip install PyOpenGL

具体的针对不同系统的可以到这里http://pyopengl.sourceforge.net/查看安装细节

2、使用OpenGL创建窗口

使用PyOpenGL和使用OpenGL创建程序的过程基本类似，在程序中首先对OpenGL进行初始化，设置相关的参数。在使用OpenGL的程序中首先调用glutInit函数，向其传递命令行参数。然后调用glutInitDisplayMode函数设置显示模式，调用glutCreateWindow函数创建窗口，调用glutDisplayFunc设置场景绘制函数。最后调用自定义的初始函数完成OpenGL的初始化，进入消息循环。代码实例演示如下

# _*_ coding: utf-8 -*-
# version 2.7.13

from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sys

class OpenGLWidow:

 def __init__(self, width=640, height=480, title='PyOpenGL'):
 glutInit(sys.argv)
 glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
 glutInitWindowSize(width, height)
 self.window = glutCreateWindow(title)
 glutDisplayFunc(self.Draw)
 self.InitGL(width, height)

 def Draw(self):
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 glLoadIdentity()
 glutSwapBuffers()

 def InitGL(self, width, height):
 glClearColor(0.0, 0.0, 0.0, 0.0)
 glClearDepth(1.0)
 glDepthFunc(GL_LESS)
 glEnable(GL_DEPTH_TEST)
 glShadeModel(GL_SMOOTH)
 glMatrixMode(GL_PROJECTION)
 glLoadIdentity()
 gluPerspective(45.0, float(width) / float(height), 0.1, 100.0)
 glMatrixMode(GL_MODELVIEW)

 def MainLoop(self):
 glutMainLoop()

window = OpenGLWidow()
window.MainLoop()

下篇文章，介绍下如何进行绘制文字

Python 入门基础知识 - 科学计算 - 使用Matplotlib绘制函数图形

Mon, 28 Jul 2025 17:06:09 +0800

使用Matplotlib绘制函数图形

Matplotlib是绘制2D图形的Python的一种模块，它依赖于NumPy和Tkinter。Matplotlib中大部分函数都和MATLAB中的函数名相同，熟悉MATLAB的学者可以很快地掌握Matplotlib。Matplotlib可以绘制多种形式的图形包括普通的线图、直方图、饼图、散点图以及误差线图等。

1、安装Matplotlib

执行如下命令【unix linux系统】

pip install matplotlib

2、使用Matplotlib绘制图形

使用Matplotlib绘制图形主要使用其plot函数，plot函数和MATLAB中的plot函数用法相同。Matplotlib还包含了一些用于设置x、y轴标签文本以及图形标题的函数，如下所示

xlabel 设置x轴标签

ylabel 设置y轴标签

title 设置绘图标题

text 在指定坐标处输出文字

figtext 在绘制的图形上添加文字

另外，Matplotlib还支持一部分Text排版命令，可以较好的显示数学公式。如下代码所示，在Python交互式命令行中使用Matplotlib绘制图形。

绘制正弦曲线

>>> import matplotlib.pyplot as plt
>>> from pylab import *
>>> t = arange(0.0, 2.0, 0.05)
>>> s = sin(2*pi*t)
>>> plot(t, s)
[<matplotlib.lines.Line2D object at 0x10b0abd10>]
>>> plt.show()

绘制余弦图形

>>> import matplotlib.pyplot as plt
>>> from pylab import *
>>> figure(2)
<matplotlib.figure.Figure object at 0x10de7f350>
>>> t = arange(0.0, 2.0, 0.05)
>>> s = cos(2*pi*t)
>>> plot(t, s)
[<matplotlib.lines.Line2D object at 0x111050d10>]
>>> plt.show()

同时绘制正弦曲线和余弦曲线

>>> import matplotlib.pyplot as plt
>>> from pylab import *
>>> t = arange(0.0, 2.0, 0.05)
>>> s = cos(2*pi*t)
>>> plot(t, s, linestyle='-', marker='o')
[<matplotlib.lines.Line2D object at 0x108fc4a50>]
>>> s = sin(2*pi*t)
>>> plot(t, s, linestyle='-', marker='+')
[<matplotlib.lines.Line2D object at 0x108fc4890>]
>>> xlabel('X')
<matplotlib.text.Text object at 0x109eba150>
>>> ylabel('Y')
<matplotlib.text.Text object at 0x109eae110>
>>> title('sin(x) and sin(y)')
<matplotlib.text.Text object at 0x108fa9bd0>
>>> plt.show()

绘制函数y = 10 / (1 + x ** 2)

>>> import matplotlib.pyplot as plt
>>> from pylab import *
>>> x = arange(-5, 5, 0.1)
>>> y = 10 / (1 + x ** 2)
>>> plot(x, y)
[<matplotlib.lines.Line2D object at 0x11191f590>]
>>> xlabel('X')
<matplotlib.text.Text object at 0x112648490>
>>> ylabel('Y')
<matplotlib.text.Text object at 0x112693090>
>>> plt.show()

实例演示环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 科学计算 - 矩阵运算和解线性方程

Mon, 28 Jul 2025 17:06:06 +0800

矩阵运算和解线性方程

使用SciPy可以完成矩阵分解、线性方程组求解和多项式求根等数学运算。SciPy中提供的函数名与MATLAB中的函数名大部分相同，用法也差不多。熟悉SciPy的学者可以很快熟悉SciPy。

矩阵运算

除了基本的矩阵乘除运算以外，还可以使用SciPy做矩阵分解运算、求逆运算等。SciPy中的linalg模块提供了和线性代数相关的函数，可以用于对矩阵进行运算。常用的linalg模块中常用的函数如下

inv 求解矩阵的逆

det 求解方阵的行列式

norm 求解向量的模

lstsq 求最小二乘法解

eig 求解特征值和特征向量

orth 求解矩阵的标准正交集

lu 矩阵的LU分解

qr 矩阵的QR分解

cholesky 矩阵的Cholesky分解

如下实例演示，在Python的交互式命令行中使用SciPy中的linalg模块对矩阵进行运算。

>>> import scipy # 导入SciPy模块
>>> from scipy import linalg 导入linalg模块
>>> a = scipy.mat('[1 2 3; 2 2 1; 3 4 3]') 生成矩阵
>>> a
matrix([[1, 2, 3],
 [2, 2, 1],
 [3, 4, 3]])
>>> b = linalg.inv(a) # 求a的逆矩阵
>>> b
array([[ 1. , 3. , -2. ],
 [-1.5, -3. , 2.5],
 [ 1. , 1. , -1. ]])
>>> a * b # 求a * b ，有误差，应为对角矩阵
matrix([[ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00],
 [ -2.22044605e-16, 1.00000000e+00, 4.44089210e-16],
 [ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
>>> linalg.det(a) # 求a的行列式值，有误差，应为2
1.9999999999999996
>>> a = scipy.mat('[1 2 3]')
>>> linalg.norm(a) # 求a的模
3.7416573867739413
>>> a = scipy.mat('[1 -1; -1 1; 2 -2; -3 1]') # 建立系数矩阵
>>> a # 检验系数矩阵
matrix([[ 1, -1],
 [-1, 1],
 [ 2, -2],
 [-3, 1]])
>>> b = scipy.mat('[1;2;3;4]') # 建立常数项向量
>>> b
matrix([[1],
 [2],
 [3],
 [4]])
>>> x,y,z,w = linalg.lstsq(a, b) # 求最小二乘法解
>>> x # x为解
array([[-2.41666667],
 [-3.25 ]])
>>> y
array([ 9.83333333])
>>> z
2
>>> w
array([ 4.56605495, 1.07291295])
>>> a = scipy.mat('[-1 1 0; -4 3 0; 1 0 2]')
>>> a
matrix([[-1, 1, 0],
 [-4, 3, 0],
 [ 1, 0, 2]])
>>> x,y = linalg.eig(a) # 求a的特征值
>>> x
array([ 2.+0.j, 1.+0.j, 1.+0.j]) # a的特征值
>>> y # a的特征向量
array([[ 0. , 0.40824829, 0.40824829],
 [ 0. , 0.81649658, 0.81649658],
 [ 1. , -0.40824829, -0.40824829]])
>>> a = scipy.mat('[]1 2 3; 0 1 2; 2 4 1')
>>> a
matrix([[1, 2, 3],
 [0, 1, 2],
 [2, 4, 1]])
>>> x,y,z = linalg.lu(a) # 求a的LU分解
>>> x
array([[ 0., 0., 1.],
 [ 0., 1., 0.],
 [ 1., 0., 0.]])
>>> y # L矩阵
array([[ 1. , 0. , 0. ],
 [ 0. , 1. , 0. ],
 [ 0.5, 0. , 1. ]])
>>> z # U矩阵
array([[ 2. , 4. , 1. ],
 [ 0. , 1. , 2. ],
 [ 0. , 0. , 2.5]])
>>> a = scipy.mat('[16 4 8; 4 5 -4; 8 -4 22]')
>>> a
matrix([[16, 4, 8],
 [ 4, 5, -4],
 [ 8, -4, 22]])
>>> linalg.cholesky(a) # 求a的Cholesky分解
array([[ 4., 1., 2.],
 [ 0., 2., -3.],
 [ 0., 0., 3.]])

SciPy中的linalg提供了基本的解线性方程组的函数，只要给出方程的系数矩阵和常数项向量，就可以获得方程组的解。对于非线性方程组可以采用数值解法。linalg模块中的solve函数可以用于解线性方程组，有如下所示的方程组

2X1 + X2 - 5X3 + X4 = 8

X1 - 3X2 - 6X4 = 9

2X2 - X3 + 2X4 = -5

X1 + 4X2 - 7X3 + 6X4 = 0

代码实现演示如下，在Python命令行中，使用linalg模块中的solve函数解上述线性方程组

>>> import scipy
>>> from scipy import linalg
>>> a = scipy.mat('[2 1 -5 1; 1 3 0 -6; 0 2 -1 2;1 4 -7 6]') # 建立系数矩阵
>>> a
matrix([[ 2, 1, -5, 1],
 [ 1, 3, 0, -6],
 [ 0, 2, -1, 2],
 [ 1, 4, -7, 6]])
>>> b = scipy.mat('[8;9;-5;0]') # 建立常数项向量
>>> b
matrix([[ 8],
 [ 9],
 [-5],
 [ 0]])
>>> linalg.solve(a, b)
array([[-3.26086957],
 [-1.56521739],
 [-3.7826087 ],
 [-2.82608696]])

运行实例环境

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 科学计算 - NumPy和SciPy

Mon, 28 Jul 2025 17:06:02 +0800

科学计算

科学计算是计算机应用的主要内容之一。开源软件Scilab和商业软件MATLAB都是以科学计算为主的应用软件。使用Python同样可以进行矩阵运算、数值分析等。

NumPy和SciPy简介

NumPy和SciPy是Python中用以实现科学计算的模块包。NumPy主要提供了数组对象、基本的数组函数和傅里叶变换的相关函数。SciPy依赖于NumPy，SciPy提供了更多的计算工具，例如绘制图形等。

1、安装NumPy和SciPy

执行下面的命令安装NumPy

pip install numpy

执行下面命令安装SciPy

pip install scipy

2、NumPy的使用简介

NumPy提供了Python没有提供的数组对象。使用NumPy的数组对象可以创建类似于C语言中的数组。使用NumPy时首先应导入NumPy模块。如下实例，在Python交互式命令行中使用NumPy创建数组，并对数组进行简单的运算。

>>> import numpy # 导入NumPy模块
>>> a = numpy.array((1,2,3,4,5)) # 生成一个数组对象
>>> print(a) # 打印数组a
[1 2 3 4 5]
>>> b = numpy.array(([1,2,3],[4,5,6],[7,8,9])) # 生成数组对象b
>>> print(b)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
>>> c = b + b # 数组对象的加法运算
>>> print(c)
[[ 2 4 6]
 [ 8 10 12]
 [14 16 18]]
>>> d = c * 2 # 数组对象的乘法运算
>>> print(d)
[[ 4 8 12]
 [16 20 24]
 [28 32 36]]
>>> e = d / c # 数组对象的除法运算
>>> print(e)
[[2 2 2]
 [2 2 2]
 [2 2 2]]
>>> print(b * e) # 数组相乘
[[ 2 4 6]
 [ 8 10 12]
 [14 16 18]]
>>> numpy.sin(b) # 求正弦
array([[ 0.84147098, 0.90929743, 0.14112001],
 [-0.7568025 , -0.95892427, -0.2794155 ],
 [ 0.6569866 , 0.98935825, 0.41211849]])
>>> numpy.tan(b) # 求正切
array([[ 1.55740772, -2.18503986, -0.14254654],
 [ 1.15782128, -3.38051501, -0.29100619],
 [ 0.87144798, -6.79971146, -0.45231566]])
>>> numpy.resize(b, [2,2]) # 重新调整b的大小，生成新的数组
array([[1, 2],
 [3, 4]])
>>> numpy.resize(b, [3,4]) # 重新调整b的大小
array([[1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 1, 2, 3]])
>>> numpy.sum(b) # 求b中所有元素的和
45
>>> zero = numpy.zeros((4,4)) # 生成一个4*4的全为0的数组
>>> print(zero)
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
>>> one = numpy.ones((4,4)) # 生成一个4*4的全为1的数组
>>> print(one)
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

3、SciPy的使用简介

SciPy模块依赖于NumPy，但是SciPy提供了更多的数学工具。使用SciPy不仅可以进行矩阵运算，还可以求解线性方程、进行微积分运算、优化等。SciPy的功能非常接近MATLAB，如下实例，在Python交互式命令行中使用SciPy。

>>> import scipy # 导入scipy模块
>>> a = scipy.mat('[1 2 3; 4 5 6; 7 8 9]') # 生成一个矩阵
>>> print(a)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
>>> a
matrix([[1, 2, 3],
 [4, 5, 6],
 [7, 8, 9]])
>>> a * 2 # 矩阵乘以2
matrix([[ 2, 4, 6],
 [ 8, 10, 12],
 [14, 16, 18]])
>>> 0.5 * a # 0.5乘以矩阵a
matrix([[ 0.5, 1. , 1.5],
 [ 2. , 2.5, 3. ],
 [ 3.5, 4. , 4.5]])
>>> b = scipy.mat('[1;2;3]') # 生成矩阵
>>> print(b) # 输出矩阵
[[1]
 [2]
 [3]]
>>> b
matrix([[1],
 [2],
 [3]])
>>> a * b # 矩阵相乘
matrix([[14],
 [32],
 [50]])
>>> scipy.sin(a) # 求正弦
matrix([[ 0.84147098, 0.90929743, 0.14112001],
 [-0.7568025 , -0.95892427, -0.2794155 ],
 [ 0.6569866 , 0.98935825, 0.41211849]])
>>> scipy.tan(a) # 求正切
matrix([[ 1.55740772, -2.18503986, -0.14254654],
 [ 1.15782128, -3.38051501, -0.29100619],
 [ 0.87144798, -6.79971146, -0.45231566]])
>>> scipy.resize(a, (4,4)) # 重新调整举证大小 4*4
array([[1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 1, 2, 3],
 [4, 5, 6, 7]])
>>> v = scipy.vander((1,6)) # 生成Vandermonde矩阵
>>> print(v)
[[1 1]
 [6 1]]
>>> v
array([[1, 1],
 [6, 1]])
>>> scipy.diff(v) # 差分运算
array([[ 0],
 [-5]])
>>>
>>> from scipy import integrate # 导入integrate模块
>>> integrate.quad(lambda x: 2*x, 0, 6) # 求积分 
(36.0, 3.9968028886505635e-13)
>>> integrate.quad(lambda x: 1/(1 + x ** 2), 0, 1) # 求积分
(0.7853981633974484, 8.719671245021581e-15)

Python 入门基础知识 - 数据结构与算法 - 排序

Mon, 28 Jul 2025 17:05:57 +0800

排序

排序相对于查找来说要复杂的多，排序的方法也较多，有冒泡排序、希尔排序、二叉树排序和快速排序等，其中二叉树排序是比较有意思的一种排序方法，而且也便于操作。二叉树排序的过程主要是二叉树的建立和遍历的过程。例如有一组数据"3,5,7,20,44,2,15,30"，则二叉树的建立过程如下

1、首先将第一个数据3放如根节点

2、将数据5与节点中的数据3比较，由于5大于3，则将5放入3的右子树中

3、将数据7与根节点中的数据3比较，由于7大于3，则将7放入3的右子树中，由于2已经有右子树5，将7与5比较，因为7大于5，则将7放入5的有子树中。

4、将数据20与根节点3进行比较，由于20大于3，则将7放入3的右子树中，重复比较，最终将20放入7的右子树中

5，将数据44与树中的节点值进行比较，最终将其放入20的右子树中

6、将数据2与根节点3比较，由于2小于3，则将2放入3的左子树中

7、同样的对数据15和30进行处理，最终形成如下图的树

当树创建好后，对树进行中序遍历后的结果就是对数据从小到大的排序。如果要从大到小进行排序，则可以先从右子树开始进行中序遍历。

实例代码演示如下，采用二叉树排序的方式对数据进行排序

# _*_ coding: utf-8 -*-
# version 2.7.13

class BTree: # 二叉树节点

 def __init__(self, value): # 初始化函数
 self.left = None # 左子树
 self.data = value # 节点值
 self.right = None # 右子树

 def insertLeft(self, value): # 向左子树插入节点
 self.left = BTree(value)
 return self.left

 def insertRight(self, value): # 向右子树插入节点
 self.right = BTree(value)
 return self.right

 def show(self): # 输出节点数据
 print(self.data)

def inorder(node):
 if node.data:
 if node.left:
 inorder(node.left)
 node.show()

 if node.right:
 inorder(node.right)

def rinorder(node):
 if node.data:
 if node.right:
 rinorder(node.right)
 node.show()

 if node.left:
 rinorder(node.left)

def insert(node, value):
 if value > node.data:
 if node.right:
 insert(node.right, value)
 else:
 node.insertRight(value)

 else:
 if node.left:
 insert(node.left, value)
 else:
 node.insertLeft(value)

if __name__ == '__main__':
 l = [3, 5, 7, 20, 44, 2, 15, 30]
 Root = BTree(l[0])
 node = Root

 for i in range(1, len(l)):
 insert(Root, l[i])

 print('********************************')
 print(' 从小到大 ')
 print('********************************')
 inorder(Root)

 print('********************************')
 print(' 从大到小 ')
 print('********************************')
 rinorder(Root)

运行结果如下

********************************
 从小到大
********************************
2
3
5
7
15
20
30
44
********************************
 从大到小
********************************
44
30
20
15
7
5
3
2

Python 入门基础知识 - 数据结构与算法 - 查找

Mon, 28 Jul 2025 17:05:52 +0800

查找与排序

查找和排序是最基本的算法。在很多脚本中都会用到查找和排序，在前边的文章中，多次使用Python的函数查找字符串中的子字符串。尽管Python提供了用户查找和排序的函数能够满足绝大多数需求，但还是有必要了解最基本的查找和排序算法。

查找

基本的查找方法有顺序查找、二分查找和分块查找。其中，顺序查找是最简单的查找方法，就是按数据排列的顺序依次查找，直到找到所查找的数据为止。二分查找是首先对要进行查找的数据进行排序，有按大小顺序排好的9个数字，如下图

如果要查找数字5，首先与中间值10进行比较，5小于10，于是对序列的前半部分1~9进行查找。此时，中间值为5，恰好为要找的数字，查找结束。

分块查找是顺序查找和二分查找之间的一种查找方法。使用分块查找时首先对查找表建立一个索引表，再进行分块查找。建立索引表时，首先对查找表进行分块，要求"分块有序"，即块内关键字不一定有序，但分块之间有大小顺序。索引表是抽取各块中的最大关键字及起始位置构成的，如下图

分块查找分两步进行，首先查找索引表，因为索引表是有序的，查找索引表时可以使用二分查找。查找完索引表以后，就确定了要查找的数据所在的分块，然后在改分块中进行顺序查找。

实例演示代码如下

# _*_ coding: utf-8 -*-
# version 2.7.13

def binary_search(l, key): # 二分查找
 low = 0
 high = len(l) - 1
 i = 0
 while (low <= high):
 i = i + 1
 mid = (high + low) / 2
 if (l[mid] < key):
 low = mid + 1
 elif (l[mid] > key):
 high = mid - 1
 else:
 print('use %d time(s)' % i)
 return mid
 return -1

if __name__ == '__main__':
 l = [1, 5, 6, 9, 10, 51, 62, 65, 70] # 构造列表
 print(binary_search(l, 5)) # 在列表中查找
 print(binary_search(l, 10))
 print(binary_search(l, 65))
 print(binary_search(l, 70))

运行结果如下

use 2 time(s)
1
use 1 time(s)
4
use 3 time(s)
7
use 4 time(s)
8

Python 入门基础知识 - 数据结构与算法 - 图

Mon, 28 Jul 2025 17:05:48 +0800

图

图也是非线性的数据结构，是由顶点和边组成的。如果图中的顶点是有序的，那么图是有方向的，称之为有向图，

否则，图是无方向的，称之为无向图。在图中，由顶点组成的序列称为路径。

图和树相比，少了树明显的层次结构。在Python中可以采用字典的方式来创建图，图中的每个元素是字典中的键，该元素所指向的图中其他元素则组成键的值。同树一样，对于图来说也可以对其进行遍历。除了遍历外，可以在图中搜索所有的从一个顶点到另一个定点的路径。图中的顶点可以看做是城市，路径可以看做是城市到城市之间的公路。因此，通过搜索所有的路径，可以找到一个顶点到另一个顶点的最短路径，即城市到城市间的最短路线。

如下代码所示，使用字典的方法构建了有向图，并搜索图中的路径。

# _*_ coding: utf-8 -*-
# version 2.7.13

def searchGraph(graph, start, end): # 搜索树
 results = [] # 路径列表
 generatePath(graph, [start], end, results) # 生成路径
 results.sort(lambda x, y: cmp(len(x), len(y))) # 按路径长短排序
 return results

def generatePath(graph, path, end, results): # 生成路径
 state = path[-1]
 if state == end:
 results.append(path)
 else:
 for arc in graph[state]:
 if arc not in path:
 generatePath(graph, path + [arc], end, results)

if __name__ == '__main__':
 Graph = {
 'A': ['B', 'C', 'D'],
 'B': ['E'],
 'C': ['D', 'F'],
 'D': ['B', 'E', 'G'],
 'E': [],
 'F': ['D', 'G'],
 'G': ['E']
 }

 r = searchGraph(Graph, 'A', 'D') # 搜索A到D的路径
 print('*******************************')
 print(' A TO D ')
 print('*******************************')

 for i in r:
 print(i)

 r = searchGraph(Graph, 'A', 'E') # 搜索A到E的路径
 print('*******************************')
 print(' A TO E ')
 print('*******************************')

 for i in r:
 print(i)

 r = searchGraph(Graph, 'C', 'E') # 搜索C到E的路径
 print('*******************************')
 print(' C TO E ')
 print('*******************************')

 for i in r:
 print(i)

运行的结果如下

*******************************
 A TO D
*******************************
['A', 'D']
['A', 'C', 'D']
['A', 'C', 'F', 'D']
*******************************
 A TO E
*******************************
['A', 'B', 'E']
['A', 'D', 'E']
['A', 'C', 'D', 'E']
['A', 'D', 'B', 'E']
['A', 'D', 'G', 'E']
['A', 'C', 'D', 'B', 'E']
['A', 'C', 'D', 'G', 'E']
['A', 'C', 'F', 'D', 'E']
['A', 'C', 'F', 'G', 'E']
['A', 'C', 'F', 'D', 'B', 'E']
['A', 'C', 'F', 'D', 'G', 'E']
*******************************
 C TO E
*******************************
['C', 'D', 'E']
['C', 'D', 'B', 'E']
['C', 'D', 'G', 'E']
['C', 'F', 'D', 'E']
['C', 'F', 'G', 'E']
['C', 'F', 'D', 'B', 'E']
['C', 'F', 'D', 'G', 'E']

Python 入门基础知识 - 数据结构与算法 - 二叉树遍历

Mon, 28 Jul 2025 17:05:42 +0800

二叉树遍历

按照先左后右，树的遍历方法有3种：

先序遍历、中序遍历、后序遍历。其中，先序遍历的次序是：如果二叉树不为空，则访问根节点，然后访问左子树，最后访问右子树；否则，程序退出。中序遍历的次序是：如果二叉树不为空，则先访问左子树，然后范文根节点，最后访问右子树；否则，程序退出。后序遍历的次序依次是：如果二叉树不为空，则先访问左子树，然后访问右子树，最后访问根节点。

代码实例演示如下

# _*_ coding: utf-8 -*-
# version 2.7.13

class BTree: # 二叉树节点

 def __init__(self, value): # 初始化函数
 self.left = None # 左儿子
 self.data = value # 节点值
 self.right = None # 右儿子

 def insertLeft(self, value): # 向左子树中插入节点
 self.left = BTree(value)
 return self.left

 def insertRight(self, value): # 向右子树中插入节点
 self.right = BTree(value)
 return self.right

 def show(self): # 输出节点数据
 print(self.data)

def preorder(node): # 先序遍历
 if node.data:
 node.show()
 if node.left:
 preorder(node.left)

 if node.right:
 preorder(node.right)

def inorder(node): # 中序遍历
 if node.data:
 if node.left:
 inorder(node.left)
 node.show()

 if node.right:
 inorder(node.right)

def postorder(node):
 if node.data:
 if node.left:
 postorder(node.left)
 if node.right:
 postorder(node.right)

 node.show()

if __name__ == "__main__":
 Root = BTree('Root')
 A = Root.insertLeft('A')
 C = A.insertLeft('C')
 D = A.insertRight('D')
 F = D.insertLeft('F')
 G = D.insertRight('G')
 B = Root.insertRight('B')
 E = B.insertRight('E')

 print('*********************************')
 print('Binary Tree Pre Order')
 print('*********************************')
 preorder(Root)

 print('*********************************')
 print('Binary Tree In Order')
 print('*********************************')
 inorder(Root)

 print('*********************************')
 print('Binary Tree Post Order')
 print('*********************************')
 postorder(Root)

运行后结果如下

*********************************
Binary Tree Pre Order
*********************************
Root
A
C
D
F
G
B
E
*********************************
Binary Tree In Order
*********************************
C
A
F
D
G
Root
B
E
*********************************
Binary Tree Post Order
*********************************
C
F
G
D
A
E
B
Root

Python 入门基础知识 - 数据结构与算法 - 二叉树

Mon, 28 Jul 2025 17:05:39 +0800

二叉树

二叉树是一类比较特殊的数，在二叉树中每个节点最多只有两个儿子，分为左和右

相对于树而言，二叉树的构建和使用都要简单的多，而且任何一棵树，都可以通过变换转换成一颗二叉树。

在Python中，二叉树的构建和树一样，可以使用列表或者类的方式。由于二叉树中的节点具有确定的儿子数，

因此，使用类的方式要更为简便。代理实例演示如下

# _*_ coding: utf-8 -*-
# version 2.7.13

class BTree: # 二叉树节点

 def __init__(self, value): # 初始化函数
 self.left = None # 左儿子
 self.data = value # 节点值
 self.right = None # 右儿子

 def insertLeft(self, value): # 向左子树中插入节点
 self.left = BTree(value)
 return self.left

 def insertRight(self, value): # 向右子树中插入节点
 self.right = BTree(value)
 return self.right

 def show(self): # 输出节点数据
 print(self.data)

if __name__ == "__main__":
 Root = BTree('Root')
 A = Root.insertLeft('A')
 C = A.insertLeft('C')
 D = A.insertRight('D')
 F = D.insertLeft('F')
 G = D.insertRight('G')
 B = Root.insertRight('B')
 E = B.insertRight('E')
 Root.show()
 Root.left.show()
 Root.right.show()
 A = Root.left
 A.left.show()
 Root.left.right.show()

运行后输出结果如下

Root
A
B
C
D

当创建好一颗二叉树后，可以按照一定的顺序对树中所有的元素进行遍历。按照先左后右，树的遍历方法有3种：

先序遍历、中序遍历、后序遍历。其中，先序遍历的次序是：如果二叉树不为空，则访问根节点，然后访问左子树，

最后访问右子树；否则，程序退出。中序遍历的次序是：如果二叉树不为空，则先访问左子树，然后范文根节点，

最后访问右子树；否则，程序退出。后序遍历的次序依次是：如果二叉树不为空，则先访问左子树，然后访问右子树，

最后访问根节点。

遍历的方式我们下篇文章继续概述。

Python 入门基础知识 - 数据结构与算法 - 树

Mon, 28 Jul 2025 17:05:36 +0800

树和图

树和前几篇文章说的数据结构不同，树不是线性的。在处理较多数据的时候，使用线性结构较慢，而使用树结构则

可以提高处理速度。不过树的构建相对于线性的表、堆栈和队列等较为复杂。

树

树是一种非线性的数据结构

之所以称为树，是因为其形状像一颗倒置的大树。每颗树都有一个跟节点，如上图所示，Root为根节点。A、B、C

为Root的儿子，Root为A、B、C的父亲，A、B、C为兄弟。同样A为D、E的父亲，D、E为A的儿子，D、E为兄弟。D、E

为Root的孙子，Root为D、E的祖父。在树中，如果一个元素没有儿子，则称为树的叶子。

在Python中树的实现可以使用列表或者类的方式实现。使用列表的方式较为简单，但树的构建较为复杂。使用类的

方式构建树时，需要首先确定树中的节点所能拥有的最大儿子树。因为每个节点所拥有的儿子树并不一定相同，因此使用

类的方法将占用更大的存储空间，如下代码实例，以列表的方式构建了上图所示的树

# _*_ coding: utf-8 -*-
# version 2.7.13

G = ['G', []] # 构造叶子G，树中每个元素都由该元素的值和该元素的儿子列表组成
H = ['H', []] # 构造叶子节点H
I = ['I', []] # 构造叶子节点I
K = ['K', []] # 构造叶子节点K
E = ['E', [G, H, I, K]] # 构造E节点
D = ['D', []] # 构造叶子节点D
F = ['F', []] # 构造叶子节点F
A = ['A', [D, E]] # 构造A节点
B = ['B', []] # 构造叶子节点D
C = ['C', [F]] # 构造C节点
Root = ['Root', [A, B, C]] # 构造树根
print(Root)

输出结果如下

['Root', [['A', [['D', []], ['E', [['G', []], ['H', []], ['I', []], ['K', []]]]]], ['B', []], ['C', [['F', []]]]]]

Python 入门基础知识 - 数据结构与算法 - 队列

Mon, 28 Jul 2025 17:05:32 +0800

队列

队列和栈类似

但不同的是，队列的出队操作是队首元素进行的删除操作，因而对于队列而言，先入队的元素将先出队。因此队

的特性可以称为先进先出（FIFO）。

和堆栈类似，在Python中同样可以使用列表来构建一个队列，并完成对队列的操作。如下实例

# _*_ coding: utf-8 -*-
# version 2.7.13
class TestQueue:

 def __init__(self, size=20): # 创建队列
 self.queue = [] # 队列
 self.size = size # 队列大小
 self.end = -1 # 队列尾

 def setSize(self, size): # 设置队列大小
 self.size = size

 def In(self, element): # 入队
 if self.end < self.size - 1:
 self.queue.append(element)
 self.end = self.end + 1
 else:
 raise 'TestQueue Full' # 如果队列满，则引发异常

 def Out(self): # 出队
 if self.end != -1:
 element = self.queue[0]
 self.queue = self.queue[1:]
 self.end = self.end - 1
 return element
 else:
 raise 'TestQueue Empty'

 def End(self):
 return self.end

 def Empty(self): # 清空队列
 self.queue = []
 self.end = -1

if __name__ == '__main__':
 queue = TestQueue()
 for i in range(10):
 queue.In(i)

 print(queue.End())

 for i in range(10):
 print(queue.Out())

 for i in range(20):
 queue.In(i)

 print(queue.Empty())

 for i in range(20):
 print(queue.Out())

运行结果如下

9
0
1
2
3
4
5
6
7
8
9
None
Traceback (most recent call last):
 File "base_phrase.py", line 64, in <module>
 print(queue.Out())
 File "base_phrase.py", line 38, in Out
 raise 'TestQueue Empty'
TypeError: exceptions must be old-style classes or derived from BaseException, not str

Python 入门基础知识 - 数据结构与算法 - 栈

Mon, 28 Jul 2025 17:05:16 +0800

栈

栈可以看做插入和删除在同一个位置上进行的表，一般是栈顶。栈的基本操作是进栈和出栈，栈可以看作是一个容器。

如下图，

先入栈的在容器底部，后入栈的在容器顶部。在出栈的时候，后入栈的先出，而先入栈的后出，因此栈有一个特性叫做

后进先出

在Python中，仍然可以使用列表来存储堆栈数据。通过创建堆栈类，来实现对堆栈进行操作的方法。如，进栈PUSH

方法、出栈POP方法，编写检查栈是都为满栈，或者是否为空栈的方法等。

如下示例代码

# _*_ coding: utf-8 -*-
# version 2.7.13
class TestStack:

 def __init__(self, size=20):
 self.stack = []
 self.size = size
 self.top = -1

 def setSize(self, size):
 self.size = size

 def push(self, element):
 if self.is_full():
 raise 'TestStack OverFlow'
 else:
 self.stack.append(element)
 self.top = self.top + 1

 def pop(self):
 if self.is_empty():
 raise 'TestStack Empty'
 else:
 element = self.stack[-1]
 self.top = self.top - 1
 del self.stack[-1]
 return element

 def Top(self):
 return self.top

 def empty(self):
 self.stack = []
 self.top = -1

 def is_empty(self):
 if self.top == -1:
 return True
 else:
 return False

 def is_full(self):
 if self.top == self.size - 1:
 return True
 else:
 return False

if __name__ == '__main__':
 stack = TestStack()
 for i in range(10):
 stack.push(i)

 print('%d' % stack.Top())

 for i in range(10):
 print(stack.pop())

 stack.empty()
 for i in range(21):
 stack.push(i)

Python 入门基础知识 - 数据结构与算法 - 表

Mon, 28 Jul 2025 17:05:13 +0800

数据结构与算法

数据结构用来描述一种或多种数据元素之间的特定关系。算法是程序设计中对数据操作的描述。数据结果和算法组成

了程序。对于简单的任务，只要使用编程语言提供的基本数据类型就足够了。而对于较复杂的任务，就需要使用基本

的数据类型构造更加复杂的数据结构。

表、栈和队列

表、栈和队列都是基本的线性数据结构。由于Python设计良好的数据结构，其列表可以当做表来使用。而且列表的

某些特性跟链表相似，在Python中表的实现非常简单。对于栈和队列，则可以自己在脚本中构建。

表

表示最基本的数据结构，在Python中可以使用列表来创建表。而在C语言中，一般使用数组来创建表。由于使用数组

创建表，对表中元素进行插入和删除操作的开销较大。当插入一个元素时，要先将该元素后的所有元素，从最后一个

元素开始，依次向后移动一个位置。完成元素移动后，再将元素插入数组中。同样，要删除表中的元素时，首先删除

元素，然后将位于该元素之后的元素从前向后，依次向前移动一个位置。

如果一个表含有元素较多，而要进行插入或删除的位置又比较靠近表的前端，则移动元素的操作将耗费大量的时间。

为了减少插入和删除元素的线性开销，可以使用链表代替表。在C语言中，链表中不仅保存数据，还保存了指向下一个

元素的指针，如下图

当进行插入操作时，要先将位于插入元素前的元素指针赋值给插入元素。完成赋值后再将插入元素的地址赋值给位于

其前的元素，如下图

当进行删除元素时，只需要删除元素的指针赋值给其前边的元素即可。如下图

使用链表，可以降低插入、删除元素的线性开销。由于链表中不仅存储了数据，而且还保存了指向下一个元素的指针，

因而使用链表将占用更大的存储空间。而在Python中，列表本身就提供了插入和删除操作。因此，在Python中列表

也可以充当链表使用，而不用自己构建。

还有一种链表，称之为双向链表，如下图

双向链表中不仅保存了指向下一个元素地址的指针，而且还保存了指向其上一个元素地址的指针。相对于单向链表，

双向链表需要更大的存储空间，但使用双向列表可以完成倒序扫描连边表。

Python 入门基础知识 - Python处理XML实例-简单的RSS阅读器

Mon, 28 Jul 2025 17:05:09 +0800

Python处理XML实例-简单的RSS阅读器

RSS(Really Simple Syndication)是一种描述和同步网站内容的格式。RSS是基于XML的。使用Python可以做一个

简单的RSS阅读器。RSS有其自己的标准，可以通过阅读其标准编写一个脚本来处理网站的RSS。但鉴于XML的良好

可读性和良好的结构，只要找到一个简单的RSS文件，完全可以写出一个简答的RSS阅读器。以Python官网提供的

RSS为例，访问地址如下：https://www.python.org/jobs/feed/rss/

可以看到每一条主要的消息处于"item"元素之间。在"item"元素中依次包含"title"、“link”、“description”、

“guid"元素。其中"title"元素包含了消息的标题，“description"元素包含了消息的简要描述，“link"元素包含

了消息的具体访问地址。Python官网的RSS文件非常直观，通过查看RSS文件内容即可了解其结构。

下面通过如下代码实例演示如何获取标题和"link"访问地址

# _*_ coding: utf-8 -*-
import Tkinter
import urllib
import xml.parsers.expat

class ParserXML:

 def __init__(self, edit):
 self.parser = xml.parsers.expat.ParserCreate() # 生成XMLParser
 self.parser.StartElementHandler = self.start # 起始标记处理方法
 self.parser.EndElementHandler = self.end # 结束标记处理方法
 self.parser.CharacterDataHandler = self.data # 字符数据处理方法

 self.title = False
 self.link = False
 self.edit = edit

 def start(self, name, attrs):
 if name == 'title':
 self.title = True
 elif name == 'link':
 self.link = True
 else:
 pass

 def end(self, name):
 if name == 'title':
 self.title = False
 elif name == 'link':
 self.link = False
 else:
 pass

 def data(self, data):
 if self.title:
 self.edit.insert(Tkinter.END, '******************************\n')
 self.edit.insert(Tkinter.END, 'Title: ')
 self.edit.insert(Tkinter.END, data + '\n')
 elif self.link:
 self.edit.insert(Tkinter.END, 'Link: ')
 self.edit.insert(Tkinter.END, data + '\n')
 else:
 pass

 def feed(self, data):
 self.parser.Parse(data, 0)

class Window:

 def __init__(self, root):
 self.root = root
 self.get = Tkinter.Button(root, text='获取RSS', command=self.get)
 self.get.place(x=280, y=15)
 self.frame = Tkinter.Frame(root, bd=2)
 self.scrollbar = Tkinter.Scrollbar(self.frame)
 self.edit = Tkinter.Text(self.frame,
 yscrollcommand=self.scrollbar.set,
 width=96,
 height=32)
 self.scrollbar.config(command=self.edit.yview)
 self.edit.pack(side=Tkinter.LEFT)
 self.scrollbar.pack(side=Tkinter.RIGHT, fill=Tkinter.Y)
 self.frame.place(y=50)

 def get(self):
 url = 'https://www.python.org/jobs/feed/rss/'
 page = urllib.urlopen(url)
 data = page.read()
 parser = ParserXML(self.edit)
 parser.feed(data)

root = Tkinter.Tk()
window = Window(root)
root.minsize(600, 480)
root.maxsize(600, 480)
root.mainloop()

运行后，生成的结果如下

Python 入门基础知识 - 使用Python处理XML（三）

Fri, 25 Jul 2025 15:55:46 +0800

使用xml.dom处理XML的简介

DOM(Document Object Model)，即文档对象模型，使用树式结构创建XML文档。Python的xml.dom模块提供了DOM

接口，可以将XML文档转为树结构。Python提供了基本的DOM分析系统minidom模块和复杂的DOM分析系统pulldom

模块。minidom模块适用于较小的XML文档，因为它将整个文档读到内存中。而pulldom模块则适用于较大的XML文档，

因为它不将整个XML文档读入内存。

Python的xml.dom中的接口较多，其常用的有Element对象中的如下几种方法

getElementByTagName(): 用于获取标记的分支

getElementBtTagNameNS(): 用于获取标记的分支(使用了命名空间的情况)

getAttribute(): 用于获取属性值

getAttributeNode(): 用于获取属性节点

getAttributeNS(): 用于获取属性值(使用了命令空间的情况)

getAttributeNodeNS(): 用于获取属性节点(使用了命令空间的情况)

removeAttribute(): 用于移除属性

removeAttributeNode(): 用于移除属性节点

removeAttributeNS(): 用于移除属性节点(使用了命令空间的情况)

setAttribute(): 用于设置属性

setAttributeNS(): 用于设置属性(使用了命令空间的情况)

setAttributeNode(): 用于设置属性节点

setAttributeNodeNS(): 用于设置属性节点(使用了命令空间的情况)

使用minidom时应首先使用parse，或parseString方法获取XML数据。当获取XML数据后就可以使用xml.dom中的

方法对XML文档进行处理。

Python 入门基础知识 - 使用Python处理XML（二）

Fri, 25 Jul 2025 15:55:42 +0800

使用xml.sax处理XML的简介

与xml.parsers.expat模块不同，xml.sax模块将分析器和处理器分离了。使用

xml.sax模块时，可以使用make_parser函数创建分析器，它返回一个XMLParser

对象。然后使用XMLReader对象的setContentHandler设置XMLReader对象的

ContentHandler。在脚本中通过继承ContentHandler类，重载相应的处理方法，

即可对XML文档进行处理。如果需要对DTD进行处理，可以使用XMLReader对象的

setDTDHandler方法。使用setDTDHandler方法设置XMLReader对象的DTDHandler

句柄。

xml.sax的分析器在分析XML文档时，在XML文档开始时将调用ContentHandler的startDocument方法，在XML文档结束时将调用ContentHandler的endHandler方法。其函数原型分别如下

startElement(name, attrs)

endElement(name)

参数含义如下

name: 元素名

attrs: 元素属性

如果在XML文档中使用了命名空间，将调用startElementNS方法和endElementNS方法。原型分别如下

startElementNS(name, qname, attrs)

endElementNS(name, qname)

参数含义如下

name: 由URI和本地名组成的元组

qname: 元素名

attrs: 元素属性

当xml.sax的分析器遇到字符数据时，将调用ContentHandler的characters方法。原型如下

characters(content)

参数含义如下

content: 字符数据内容

当xml.sax的分析器遇到XML处理指令时，将调用ContentHandler的processingInstruction方法。原型如下

processingInstruction(target, data)

参数含义如下

target: 指令名称

data: 指令数据

当xml.sax的分析器处理DTD时，将调用DTDHandler中的方法。在DTDHandler中主要提供了用于处理声明的notationDecl方法和用于处理分析实体声明unparsedEntityDecl方法。原型如下

notationDecl(name, publicId, systemId)

upparsedEntityDecl(name, publicId, systemId, ndata)

Python 入门基础知识 - 使用Python处理XML（一）

Fri, 25 Jul 2025 15:55:40 +0800

使用Python处理XML

在Python中提供了许多标准模块用于处理XML文档。例如使用Expat分析器的xml.parsers.expat模块，

使用SAX分析器的xml.sax模块，使用DOM的xml.dom模块。其中xml.parsers.expat和xml.sax模块与

HTMLParser类似，都是基于事件的方式对XML文档进行分析。

本篇文章简单了解下使用xml.parsers.expat处理XML

在Python中使用xml.parsers.expat处理XML时，应首先使用其ParserCreate创建一个XMLParser实例

对象。其原型如下

ParserCreate(encoding, namespace_separator)

参数含义如下

encoding: XML文档的编码，可选参数

namespace_separator: XML文档的命令空间，可选参数

当创建XMLParser对象后需要使用Parse或者ParseFile方法向其传递要处理的XML数据或XML文档。其原型如下

Parse(data, isfinal)

参数含义如下

data: 要进行处理的XML数据

isfinal: 当最后一次调用该方法时，isfinal应为True，可选参数

ParseFile(file)

参数含义如下

file: 打开的文件对象

在使用XMLParser处理XML的过程中，当遇到相应的事件时，XMLParser会调用相应的事件处理方法。在使用

XMLParser时可以通过继承创建新类，重载需要处理的方法，也可以直接使用XMLParser，自己编写函数，将

其赋值给XMLParser的处理方法。当XMLParser遇到XML文档声明时，会调用XmlDeclHandler方法，其原型如下

XmlDeclHandler(version, encoding, standalone)

其参数如下

version: XML规范的版本

encoding: XML文档的编码

standalone: XML文档的standalone属性值

当XMLParser遇到文档类型定义开始时，将调用StartDoctypeDeclHandler方法，当结束时将调用EndDoctypeDeclHandler

方法。其原型如下

StartDoctypeDeclHandler(doctypeName, systemId, publicId, has_internal_subset)

参数含义如下

doctypeName: DID名称

systemId: 系统标识

publicId: 公共标识

has_internal_subset: 如果XML文档包含DTD，则has_internal_subset为真

EndDoctypeDeclHandler()

当XMLParser遇到DTD中元素声明时，将调用ElementDeclHandler方法。其原型如下

ElementDeclHandler(name, model)

参数含义如下

name: 元素名

model: 元素内容模型

当XMLParer遇到DTD中元素属性声明时，将调用AttlistDeclHandler方法，其原型如下

AttlistDeclHandler(elname, attname, type, default, required)

参数含义如下

elname: 元素名

attname: 属性名

type: 元素数据类型

default: 属性默认值

required: 如果属性为必须的，则required为真。

当XMLParser遇到元素开始标记时，将调用StartElementHandler方法，当遇到结束标记是，将调用EndElementHandler

方法，原型如下

StartElementHandler(name, attributes)

参数含义如下

name: 元素名

attributes: 元素属性

EndElementHandler(name)

参数含义如下

name: 元素名

当XMLParser遇到XML处理指令时，将调用ProcessingInstructionHandler方法，其原型如下

ProcessingInstructionHandler(target, data)

参数含义如下

target: 指令名称

name: 指令数据

当XMLParser遇到字符数据时，将调用CharacterDataHandler方法，原型如下

CharacterDataHandler(data)

参数含义如下

data: 字符数据

当XMLParser遇到XML文档中的注释时，将调用CommentHandler方法，原型如下

CommentHandler(data)

参数含义如下

data: 注释内容

当XMLParser遇到CDATA开始时，将调用StartCdataSectionHandler方法，当遇到CDATA结束时

将调用EndCdataSectionHandler方法。

Python 入门基础知识 - 处理HTML

Fri, 25 Jul 2025 15:55:36 +0800

处理HTML

在Python中可以使用HTMLParser模块处理HTML，获取页面中感兴趣的内容

HTMLParser模块提供了对HTML标记处理的方法。如果有些内容不能使用HTMLParser

处理，还可以自己编写正则表达式进行匹配

1、HTMLParser模块简介

在使用HTMLParser模块处理HTML时，首先应继承HTMLParser模块中的HTMLParser

类，然后重载相关的处理方法。使用HTMLParser对象的feed方法可以向HTMLParser传递数据。

其原型如下

feed(data)

参数含义

data: 传递的数据

当向HTMLParser对象传递数据后，就开始对数据进行处理。使用HTMLParser对象的close

方法，可以强制处理feed方法存在缓冲区的数据。使用HTMLParser对象的reset方法

可以重新设置对象实例，进行新一轮的数据处理。使用HTMLParser对象的getpos方法

可以获得当前处理的行号和偏移位置。

在使用HTMLParser处理HTML的过程中，遇到某些标记或者数据就会调用相应的方法。一般

情况下，在脚本中需要重载这些方法，已完成对HTML的处理。当HTMLParser每次遇到一个

起始标记时，会调用handle_starttag方法。原型如下

handle_starttag(tag, attrs)

参数含义

tag: HTMLParser遇到的标记

attrs: 标记的属性

当HTMLParser遇到类似于的标记时，将调用handle_startendtag方法。原型如下

handle_startendtag(tag, attrs)

参数含义

tag: HTMLParser遇到的标记

attrs: 标记的属性

当HTMLParser遇到结束标记时，会调用handle_endtag。其原型如下

handle_endtag(tag)

参数含义

tag: HTMLParser遇到的结束标记。

使用HTMLParser的handle_data方法可以处理标记间的数据。原型如下

handle_data(data)

参数含义

data: 标记间的数据

当HTMLParser遇到HTML中的注释时，将调用handle_comment方法。原型如下

handle_comment(data)

参数含义如下

data: 注释内容

除了HTMLParser模块中的HTMLParser类以外，在htmllib模块中也提供了一个简单的HTMLParser

类。其提供了处理超链接和图片的方法。htmllib模块中HTMLParser类处理超链接

的方法如下

anchor_bgn(href, name, type)

anchor_end()

参数如下

href: href属性

name: name属性

type: type属性

htmllib模块中HTMLParser类处理图片的方法原型如下

handle_image(source, alt, ismap, align, width, height)

参数含义

source: source属性

alt: alt属性

ismap: ismap属性

align: align属性

width: width属性

height: height属性

2、获取页面图片地址

在Python的HTMLParser模块中提供了处理标记的方法，由于在网页中图片都是以’‘标记

嵌入到网页中的，因此要获取页面中图片的地址只要处理’‘标记即可。如下代码实例

重载了HTMLParser类的handle_starttag方法，对’‘标记进行处理分别获得GIF和JPG

图片的地址。

# _*_ coding: utf-8 -*-
import Tkinter
import urllib
import HTMLParser

class ImageHTMLParser(HTMLParser.HTMLParser):

 def __init__(self):
 HTMLParser.HTMLParser.__init__(self)
 self.gifs = []
 self.jpgs = []

 def handle_starttag(self, tags, attrs):
 if tags == 'img':
 for attr in attrs:
 for t in attr:
 if 'gif' in t:
 self.gifs.append(t)
 elif 'jpg' in t:
 self.jpgs.append(t)
 else:
 pass

 def get_gifs(self):
 return self.gifs

 def get_jpgs(self):
 return self.jpgs

class Window:

 def __init__(self, root):
 self.root = root
 self.label = Tkinter.Label(root, text='输入URL:')
 self.label.place(x=5, y=15)
 self.entryUrl = Tkinter.Entry(root, width=30)
 self.entryUrl.place(x=65, y=15)
 self.get = Tkinter.Button(root, text='获取图片', command=self.get)
 self.get.place(x=280, y=15)

 self.edit = Tkinter.Text(root, width=470, height=600)
 self.edit.place(y=50)

 def get(self):
 try:
 url = self.entryUrl.get()
 page = urllib.urlopen(url)
 data = page.read()
 parser = ImageHTMLParser()
 parser.feed(data)
 self.edit.insert(Tkinter.END, '============GIF=========\n')
 gifs = parser.get_gifs()
 for gif in gifs:
 self.edit.insert(Tkinter.END, gif + '\n')

 self.edit.insert(Tkinter.END, '========================\n')
 self.edit.insert(Tkinter.END, '============JPG=========\n')
 jpgs = parser.get_jpgs()
 for jpg in jpgs:
 self.edit.insert(Tkinter.END, jpg + '\n')

 self.edit.insert(Tkinter.END, '========================\n')
 page.close()
 except IndexError, value:
 print(value)

root = Tkinter.Tk()
window = Window(root)
root.minsize(600, 480)
root.mainloop()

运行脚本后，在文本框中输入网址，单击’获取图片’按钮，将对网址进行处理，获取网页

中的图片地址。由于很多网站使用的HTML不是标准的语法格式，因此，使用HTMLParser

处理时，并不一定能够获得所有的图片。

Python 入门基础知识 - XMPPY的使用

Fri, 25 Jul 2025 15:55:33 +0800

1、XMPPPY模块简介

XMPPPY模块使用Python对XMPP协议进行了封装，使用XMPPPY可以使用Python连接到支持的XMPP协议的服务器。XMPPPY主要有以下几个模块

auth: 实现XMPP协议用户认证的模块

browser: 用户提供DISCO服务器框架

client: 用于提供扩展

debug: 用户调试

dispatcher: XMPPPY的主要模块

features: 包含一些不能分割的内容

filetransfer: 用于实现JEP-0047

protocol: 实现XMPP通信协议模块

roster: 用户实现用户列表

simplexml: 用户处理XML

transports: 底层传输协议

XMPPPY模块比较庞大，详细的内容可以参考XMPPPY的帮助文档。

2、使用xmpppy连接Gtalk

代码示例如下，为了方便起见，脚本中创建连接后就进入循环，当有用户发送消息，就输出消息内容和用户名，然后向用户发送消息。

# _*_ coding: utf-8 -*-
import xmpp # 导入模块

def get_message(client, message): # 消息处理函数
 text = message.getBody()
 people = message.getFrom()
 print('GET: %s FROM: %s' % (text, people))
 client.send(xmpp.protocol.Message(people, 'GET: ' + text, type='chat'))

user = raw_input('User:')
password = raw_input('Passwd:')
jid = xmpp.protocol.JID(user + '@gmail.com')
client = xmpp.Client(jid.getDomain()) # 创建客户端
# 连接服务器 - 服务器不再支持，可以更换为可用的
client.connect(server=('hangouts.google.com', 5222))
client.auth(jid.getNode(), password) # 用户认证
Roster = client.getRoster() # 获取用户列表
names = Roster.getItems()

for name in names:
 status = Roster.getStatus(name)
 print(name)
 print(status)

client.RegisterHandler('message', get_message)
client.sendInitPresence()

while 1:
 try:
 client.Process(1)
 except KeyboardInterrupt: # 处理Control+c
 break

注意！

2016年6月26日，Google Talk正式关闭，并被Google Hangouts取代。

Python 入门基础知识 - poplib和smtplib邮件模块（二）

Fri, 25 Jul 2025 15:55:29 +0800

发送邮件

发送邮件一般使用的是SMTP协议，使用Python的smtplib模块可以登录SMTP协议发送邮件。使用SMTP协议发送邮件，

首先要登录SMTP服务器

1、smtplib模块简介

使用smtplib模块的SMTP类可以创建一个SMTP对象实例。其原型如下

SMPT(host, port, local_hostname)

其参数含义如下

host: 连接的服务器名，可选参数

port: 服务器端口，可选参数

local_hostname: 本地主机名，可选参数

如果在创建SMTP对象时没有指定host和port，可以使用SMTP对象的connect方法连接到服务器。其原型如下

connect(host, port)

其参数含义如下

host: 连接的服务器名，可选参数

port: 服务器端口，可选参数

使用SMTP对象的set_debuglevel方法可以设置调试级别。其原型如下

set_debuglevel(level)

其参数含义如下

level: 调试级别

使用SMTP对象的docmd方法可以向SMTP服务器发送命令，其原型如下

docmd(cmd, argstring)

其参数含义如下

cmd: 向SMTP服务器发送的命令

argstring: 命令参数，可选参数

使用SMTP对象的sendmail方法可以发送邮件。其原型如下

sendmail(from_addr, to_addr, msg, mail_options, rcpt_options)

参数含义如下

from_addr: 发送者邮件地址

to_addr: 接收者邮件地址

msg: 邮件内容

mail_options: 邮件ESMTP操作，可选参数

rcpt_options: RCPT操作，可选参数

使用SMTP对象的quit方法可以断开同服务器的连接

2、使用smtplib发送邮件

和Python收取邮件一样，使用Python发送邮件，也可以找到所使用的SMTP服务器的地址和端口。对于网易163的邮箱，其SMTP

服务器的地址为smtp.163.com,端口默认值为25。对于网易126的邮箱，其SMTP服务器的地址为smtp.126.com，

端口默认值为25。

代码示例演示如下

# _*_ coding: utf-8 -*-
import smtplib
import Tkinter

class Window:
 """docstring for Window"""

 def __init__(self, root):
 label1 = Tkinter.Label(root, text='SMTP')
 label2 = Tkinter.Label(root, text='Port')
 label3 = Tkinter.Label(root, text='用户名')
 label4 = Tkinter.Label(root, text='密码')
 label5 = Tkinter.Label(root, text='收件人')
 label6 = Tkinter.Label(root, text='主题')
 label7 = Tkinter.Label(root, text='发件人')

 label1.place(x=5, y=5)
 label2.place(x=5, y=30)
 label3.place(x=5, y=55)
 label4.place(x=5, y=80)
 label5.place(x=5, y=105)
 label6.place(x=5, y=130)
 label7.place(x=5, y=155)

 self.entryPOP = Tkinter.Entry(root)
 self.entryPort = Tkinter.Entry(root)
 self.entryUser = Tkinter.Entry(root)
 self.entryPass = Tkinter.Entry(root)
 self.entryTo = Tkinter.Entry(root)
 self.entrySub = Tkinter.Entry(root)
 self.entryFrom = Tkinter.Entry(root)

 self.entryPort.insert(Tkinter.END, '25')

 self.entryPOP.place(x=50, y=5)
 self.entryPort.place(x=50, y=30)
 self.entryUser.place(x=50, y=55)
 self.entryPass.place(x=50, y=80)
 self.entryTo.place(x=50, y=105)
 self.entrySub.place(x=50, y=130)
 self.entryFrom.place(x=50, y=155)

 self.get = Tkinter.Button(root, text='发送邮件', command=self.get)
 self.get.place(x=60, y=180)
 self.text = Tkinter.Text(root)
 self.text.place(y=200)

 def get(self):
 try:
 host = self.entryPOP.get()
 port = self.entryPort.get()
 user = self.entryUser.get()
 pw = self.entryPass.get()
 from_addr = self.entryFrom.get()
 to_addr = self.entryTo.get()
 subject = self.entrySub.get()
 text = self.text.get(1.0, Tkinter.END) # 获取邮件内容
 msg = ("From: %s\nTo: %s\nSubject: %s\n\n" %
 (from_addr, to_addr, subject))
 msg = msg + text

 smtp = smtplib.SMTP(host, port)
 smtp.set_debuglevel(1)
 smtp.login(user, pw)
 smtp.sendmail(from_addr, to_addr, msg)
 smtp.quit()
 except IndexError, value:
 print(value)
 self.text.insert(Tkinter.END, '发送错误\n')

root = Tkinter.Tk()
window = Window(root)
root.minsize(600, 480)
root.mainloop()

Python 入门基础知识 - poplib和smtplib邮件模块(一)

Fri, 25 Jul 2025 15:55:26 +0800

使用poplib和smtplib模块收到邮件

Python中的poplib模块和smtplib模块提供了对POP3协议和SMTP协议的支持。使用POP3协议可以登录E-mail

收取邮件，使用SMTP协议可以发送邮件。

本篇博文先介绍下如何收取邮件

收取邮件

一般的邮箱服务器都提供了POP3收取邮件的方式，Outlook等E-mail客户端就是使用POP3协议收取邮箱中的邮件。

使用Python的poplib模块可以实现一个简单的收取邮件的客户端。

1、poplib模块简介

使用poplib模块中的POP3类可以创建一个POP3对象实例。其原型如下

POP3(host, port)

参数含义如下

host: POP3邮件服务器

port: 服务器端口，可选参数，默认为110

当创建一个POP3对象实例后可以使用其user方法向POP3服务器发送用户名。其原型如下

user(username)

参数含义如下

username: 登录服务器的用户名

使用POP3对象的pass_方法可以向POP3服务器发送密码。其原型如下

pass_(password)

参数含义如下

password: 登录服务器密码

当登录服务器后可以使用POP3对象的getwelcome方法获取服务器的欢迎信息。使用POP3对象的set_debuglevel方法

可以设置调试级别。其原型如下

set_debuglevel(level)

参数含义如下

level: 调试级别

使用POP3对象的stat可以获取邮箱的状态，如邮件数、邮箱大小等。使用POP3对象的list方法可以获得邮件的内容列表。

其原型如下

list(which)

参数含义如下

which: 可选参数，如果指定，则仅列出指定的邮件内容。

使用POP3对象的retr方法可以获取指定的邮件。其原型如下

retr(which)

参数含义如下

which: 指定要获取的邮件

使用POP3对象的dele方法可以删除指定额邮件。其原型如下

dele(which)

参数含义如下

which: 指定要删除的邮件

使用POP3对象的top方法可以删除指定的邮件。其原型如下

top(which, howmuch)

参数含义如下

which: 指定获取的邮件

howmuch: 指定获取的行数

使用POP3对象的rset方法可以清除收件箱中的删除标记。使用POP3对象的noop方法可以保持同服务器的连接。

使用POP3对象的quit方法可以断开同服务器的连接。

2、使用Python收取E-mail

使用Python检查E-mail首先应该知道自己所使用的E-mail的POP3服务器地址和端口。对于网易163邮箱，其POP3

服务器的地址为pop.163.com，端口为默认值110。对于网易126的邮箱，其POP3服务器地址为pop.126.com，端口

为默认值110。使用其他的E-mail可以查看网站帮助，获取POP3服务器的地址和端口。

代码示例演示如下

# _*_ coding: utf-8 -*-
import poplib
import re
import Tkinter

class Window:

 def __init__(self, root):
 label1 = Tkinter.Label(root, text='POP3:')
 label2 = Tkinter.Label(root, text='Port:')
 label3 = Tkinter.Label(root, text='用户名:')
 label4 = Tkinter.Label(root, text='密码:')
 label1.place(x=5, y=5)
 label2.place(x=5, y=30)
 label3.place(x=5, y=55)
 label4.place(x=5, y=80)

 self.entryPOP = Tkinter.Entry(root)
 self.entryPort = Tkinter.Entry(root)
 self.entryUser = Tkinter.Entry(root)
 self.entryPass = Tkinter.Entry(root, show='*')
 self.entryPort.insert(Tkinter.END, '110')
 self.entryPOP.place(x=50, y=5)
 self.entryPort.place(x=50, y=30)
 self.entryUser.place(x=50, y=55)
 self.entryPass.place(x=50, y=80)
 self.get = Tkinter.Button(root, text="收取邮件", command=self.get)
 self.get.place(x=60, y=120)
 self.text = Tkinter.Text(root)
 self.text.place(y=150)

 def get(self): # 按钮事件
 try:
 host = self.entryPOP.get() # 获取服务器地址
 port = self.entryPort.get() # 获取主机端口
 user = self.entryUser.get() # 获取用户名
 passwd = self.entryPass.get() # 获取密码

 // pop = poplib.POP3(host, port) # 创建POP3实例
 pop = poplib.POP3_SSL(host) # 创建POP3实例
 pop.user(user) # 登录服务器
 pop.pass_(passwd)

 stat = pop.stat() # 获取状态
 self.text.insert( # 输出状态
 Tkinter.END, 'Status: %d message(s), %d bytes\n' % stat)

 rx_headers = re.compile(r"(From|To|Subject)") # 编译正则表达式
 for n in range(stat[0]):
 response, lines, bytes = pop.top(n + 1, 10)
 self.text.insert(Tkinter.END, "-" * 30 + '\n')
 self.text.insert(Tkinter.END, '\n'.join(
 filter(rx_headers.match, lines))) # 输出匹配到的内容
 self.text.insert(Tkinter.END, "-" * 30 + '\n')
 except IndexError, value:
 print(value)
 self.text.insert(Tkinter.END, '接受错误\n')

root = Tkinter.Tk()
window = Window(root)
root.minsize(600, 480)
root.mainloop()

Python 入门基础知识 - 访问FTP

Fri, 25 Jul 2025 15:55:22 +0800

访问FTP

Python中的ftplib模块提供了用于访问FTP的函数。使用ftplib模块可以在Python脚本中访问FTP，完后

上传、下载文件等

1、ftplib模块简介

使用ftplib模块中的FTP类，可以创建一个FTP连接对象。其原型如下

FTP(host, user, passwd, acct)

参数含义如下

host: 要连接的FTP服务器，可选参数

user: 登录FTP服务器所使用的用户名，可选参数

passwd: 登录FTP服务器所使用的密码，可选参数

acct: 可选参数，默认为空

当创建一个FTP连接对象后，可以使用set_debuglevel方法设置调试级别。其原型如下

set_debuglevel(level)

参数含义如下

level: 调试级别，默认的调试级别为0

如果在创建FTP连接对象时未使用HOST参数，则可以使用FTP对象的connect方法，其原型如下

connect(host, port)

其参数含义如下

host: 要连接的FTP服务器

port: FTP服务器的端口，可选参数

如果在创建FTP对象时未使用用户名和密码，则可以使用FTP对象的login对象使用用户名和密码

登录到FTP服务器。其原型如下

login(user, passwd, acct)

其参数含义如下

host: 要连接的FTP服务器，可选参数

user: 登录FTP服务器所使用的用户名，可选参数

passwd: 登录FTP服务器所使用的密码，可选参数

使用FTP对象的getwelcome方法可以获得FTP服务器的欢迎信息。使用FTP对象的abort方法可以中断文件传输。

使用FTP对象的sendcmd和voidcmd方法可以向FTP服务器发送命令。不同的是voidcmd没有返回值。其原型如下

sendcmd(command)

voidcmd(command)

其参数含义如下

command: 向服务器发送的命令字符串

使用FTP对象的retrbinary和retrlines方法可以从FTP服务器下载文件。不同的是retrbinary方法使用二进制

形式传输文件，而retrlines方法使用ASCII形式传输文件。其函数原型如下

retrbinary(command, callback, maxblocksize, rest)

retrlines(command, callback)

retrbinary参数含义如下

command: 传输命令，由"RETR+文件名"组成（之间有空格）

callback: 传输回调函数

maxblocksize: 设置每次传输的最大字节数，可选参数

rest: 设置文件续传位置，可选参数

retrlines参数含义如下

command: 传输命令

callback: 传输回调函数

使用FTP对象的storbinary和storlines方法可以向FTP服务器上传文件。不同的是

storbinary方法使用二进制形式传输文件，而storlines方法使用ASCII形式传输文件。

其函数原型分别如下

storbinary(command, file, blocksize)

storlines(command, file)

storbinary参数含义如下

command: 传输命令，由"STOR+文件名"组成（之间有空格）

file: 本地文件句柄

blocksize: 设置每次读取文件最大字节数，可选参数

storlines参数含义如下

command: 传输命令

file: 本地文件句柄

使用FTP对象的set_pasv方法可以设置传输模式。其函数原型如下

set_pasv(boolean)

参数含义如下

boolean: 如果为True，则为被动模式，如果未False，则为主动模式

使用FTP对象的dir方法可以获取当前目录中的内容列表。使用FTP对象的rename方法可以修改FTP

服务器中的文件名。其原型如下：

rename(fromname, toname)

其参数含义如下

fromname: 原来文件名

toname: 重命名后的文件名

使用FTP对象的delete方法可以从FTP服务器上删除文件。其原型如下

delete(filename)

其参数含义如下

filename: 要删除的文件名

使用FTP对象的cwd方法可以改变当前目录。其原型如下：

cwd(pathname)

参数含义如下

pathname: 要进入目录的路径

使用FTP对象的mkd方法可以获得当前目录。使用FTP对象的rmd方法可以删除FTP服务器上的目录。其函数原型如下

rmd(dirname)

参数含义如下

dirname: 要删除的目录

使用FTP对象的size方法可以获得文件的大小。其函数原型如下

size(filename)

其参数含义如下

filename: 文件名

使用FTP对象的quit和close方法可以关闭同FTP服务器的连接。

2、使用Python访问FTP

Python的ftplib模块提供了完整的用于FTP协议的函数、方法，使用ftplib模块可以制作一个简单的

类似于Windows自带的FTP客户端。

代码示例演示如下

# _*_ coding: utf-8 -*-
import string
from ftplib import FTP

bufsize = 1024

def get(filename):
 command = 'RETR ' + filename
 ftp.retrbinary(command, open(filename, 'wb').write, bufsize)
 print('下载成功')

def put(filename):
 command = 'STOR ' + filename
 filehandler = open(filename, 'rb')
 ftp.storbinary(command, filehandler, bufsize)
 filehandler.close()
 print('上传成功')

def pwd():
 print(ftp.cwd())

def size(filename):
 print(ftp.size(filename))

def help():
 print('''
 ==================================
 Simple Python FTP 
 ==================================
 cd 进入文件夹
 delete 删除文件
 dir 获取当前文件列表
 get 下载文件
 help 帮助
 mkdir 创建文件夹
 put 上传文件
 pwd 获取当前目录
 rename 重命名文件
 rmdir 删除文件夹
 size 获取文件大小

 ''')

server = raw_input('请输入FTP服务器地址:')
ftp = FTP(server)
username = raw_input('请输入用户名:')
passwd = raw_input('请输入密码:')
ftp.login(username, passwd)
print(ftp.getwelcome())
actions = {
 'dir': ftp.dir,
 'pwd': pwd,
 'cd': ftp.cwd,
 'get': get,
 'put': put,
 'help': help,
 'rmdir': ftp.rmd,
 'mkdir': ftp.mkd,
 'delete': ftp.delete,
 'size': size,
 'rename': ftp.rename
}

while True:
 print('pyftp>')
 cmds = raw_input()
 cmd = string.split(cmds)

 try:
 if len(cmd) == 1:
 if string.lower(cmd[0]) == 'quit':
 break
 else:
 actions[string.lower(cmd[0])]()
 elif len(cmd) == 2:
 actions[string.lower(cmd[0])](cmd[1])
 elif len(cmd) == 3:
 actions[string.lower(cmd[0])](cmd[1], cmd[2])
 else:
 print('输入错误')
 except:
 print('命令出错')
ftp.quit()

实例环境声明

# version 2.7.13

Python 入门基础知识 - 使用urllib、httplib

Fri, 25 Jul 2025 15:55:18 +0800

使用urllib、httplib

Python提供的socket的模块主要用户底层网络协议，对于常用的HTTP协议和FTP协议可以使用Python中的

httplib和ftplib进行访问

1、使用Python访问网站

网站都是基于HTTP协议的，使用Python中的urllib和httplib都可以访问网站。其中urllib主要用于处理

URL，使用urllib操作URL可以使用和打开本地文件一样的操作。而httplib则实现了对HTTP协议的封装。

1、urllib模块简介

使用Python中的urllib模块可以对URL进行处理。使用urllib模块中的urlopen函数可以打开一个URL。

原型如下

urlopen(url, data, proxies)

参数含义如下

url: 要进行操作的URL地址

data: 向URL传递的数据，可选参数

proxies: 使用的代理地址，可选参数

urlopen将返回一个类似于file的对象，可以像操作文件一样使用read、readline、close等方法对URL

进行操作。

使用urllib模块中的urlretrieve可以将URL保存为本地文件。

原型如下

urlretrieve(url, filename, reporthook, data)

参数含义如下

url: 要保存的URL地址

filename: 指定保存的文件名，可选参数

reporthook: 回调函数，可选参数

data: 发送的数据，一般用于POST，可选参数

使用urllib模块中的urlencode可以对URL进行编码

原型如下

urlencode(query, doseq)

参数含义如下

query: 由要进行编码的变量和变量值组成的字典

doseq: 可选参数，若为True，则将为元组的值分别编码成"变量=值"的形式

使用urllib模块中的quote和quote_plus可以替换字符串中的特殊字符，使其符合URL所要求使用的字符

原型如下

quote(string, safe)

quote_plus(string, safe)

参数含义如下

string: 要进行替换的字符串

safe: 可选参数，指定不需要替换的的字符，默认为"/"

使用urllib模块中的unquote和unquote_plus可以将quote和quote_plus替换后的字符还原

原型如下

unquote(string)

unquote_plus(string)

参数含义如下

string: 要进行还原的字符串

2、httplib简介

在Python的httplib模块中提供了HTTPConnection对象和HTTPResponse对象。

当创建一个HTTPConnection对象后，可以使用request方法向服务器发送请求

原型如下

request(method, url, body, headers)

参数含义如下

method: 发送的操作，一般为"GET"或"POST"

url: 进行操作的URL

body: 发送的数据

headers: 发送的HTTP头

当想服务器发送请求后，可以使用HTTPConnection对象的getresponse方法返回一个HTTPResponse对象。使用

HTTPConnection对象的close方法可以关闭同服务器的连接。除了使用request方法外，还可以依次使用如下所示方法

向服务器发送请求。

putrequest(request, selector, skip_host, skip_accept_encoding)

putheader(header, argument, …)

endheaders()

send(data)

putrequest的参数含义如下

request: 所发送的操作

seletor: 进行操作的URL

skip_host: 可选参数，若为真，禁止自动发送"HOST:"

skip_accept_encoding: 可选参数，若为真，禁止自动发送"Accept-Encoding:headers"

putheader的参数含义如下

header: 发送的HTTP头

argument: 发送的参数

send的参数函数如下

data: 发送的数据

urllib模块中的HTTPResponse对象主要用于处理服务器对所发送请求的响应，使用HTTPResponse对象的read方法

可以获得服务器响应主体。使用HTTPResponse对象的getheader可以获得服务器响应的HTTP头

原型如下

getheader(name, default)

参数含义如下

name: 指定HTTP头名

default: 可选参数，如果指定的name不存在，则获取default指定的HTTP头。

HTTPResponse对象还具有version、status和reason等属性，用于查看HTTP协议的版本、状态等。

3、使用Python访问网站

使用Python的urllib模块可以创建一个简单的访问网站的脚本，获取指定的页面。如果使用GUI库中显示HTML的

组件，还可以制作一个简单的Python Web浏览器，使用httplib模块也可以访问网站，但此过程比urllib模块要复杂。

httplib模块可以用于需要用户名和密码认证的网站，而urllib模块只能简单的访问、下载页面内容。

实例演示如下

# _*_ coding: utf-8 -*-
# version 2.7.13

import Tkinter
import urllib

class Window:

 def __init__(self, root):
 self.root = root
 self.entryUrl = Tkinter.Entry(root, width=40) # 创建组件
 self.entryUrl.place(x=5, y=15)
 self.get = Tkinter.Button(root, text='下载页面', command=self.get)
 self.get.place(x=340, y=15)
 self.edit = Tkinter.Text(root)
 self.edit.place(y=50)

 def get(self):
 url = self.entryUrl.get() # 获取URL
 page = urllib.urlopen(url) # 打开URL
 data = page.read() # 读取URL内容
 self.edit.insert(Tkinter.END, data) # 将内容输出到文本框
 page.close()

root = Tkinter.Tk()
window = Window(root)
root.minsize(600, 480)
root.mainloop()

Python 入门基础知识 - 在局域网中传输文件

Fri, 25 Jul 2025 15:55:14 +0800

在局域网中传输文件

使用Python中的socket模块可以编写一个简单的传文件的脚本。传输文件也就是将文件内容依次发送出去。服务端代码实例如下

# -*- coding: utf-8 -*-
import Tkinter
import threading
import socket
import os

class ListenThread(threading.Thread): # 监听线程

 def __init__(self, edit, server):
 threading.Thread.__init__(self)
 self.edit = edit # 保存窗口中的多行文本框
 self.server = server

 def run(self): # 进入监听状态
 while 1: # 使用while循环等待连接
 try: # 捕获异常
 client, addr = self.server.accept() # 等待连接
 self.edit.insert(Tkinter.END, '连接来自:%s:%d\n' %
 addr) # 向文本框输出状态
 data = client.recv(1024) # 接收数据
 print('recieve filename = ' + data)
 self.edit.insert(Tkinter.END, '收到的文件:%s\n' % data) # 向文本框中输出数据
 file = os.open(data, os.O_WRONLY | os.O_CREAT |
 os.O_EXCL) # 创建文件
 while 1:
 rdata = client.recv(1024) # 接收数据
 print('recieve data = ' + rdata)
 if not rdata:
 break

 os.write(file, rdata) # 将数据写入文件
 os.close(file) # 关闭文件
 client.close() # 关闭同客户端的连接
 self.edit.insert(Tkinter.END, '关闭客户端\n') # 向文本框中输出状态
 except IndexError, value:
 self.edit.insert(Tkinter.END, value)
 self.edit.insert(Tkinter.END, '关闭连接\n')
 break # 结束循环

class Control(threading.Thread): # 控制线程

 def __init__(self, edit):
 threading.Thread.__init__(self)
 self.edit = edit # 保留窗口中的多行文本框
 self.event = threading.Event() # 创建Event对象
 self.event.clear() # 清楚event标志

 def run(self):
 server = socket.socket(
 socket.AF_INET, socket.SOCK_STREAM) # 创建socket连接
 server.bind(('', 1051)) # 绑定本地端口1051
 server.listen(1) # 开始监听
 self.edit.insert(Tkinter.END, '正在等待连接\n') # 向文本框中输出状态
 self.lt = ListenThread(self.edit, server) # 创建监听线程对象
 self.lt.setDaemon(True)
 self.lt.start() # 执行监听线程
 self.event.wait() # 进入等待状态
 server.close() # 关闭连接

 def stop(self): # 结束控制线程
 self.event.set() # 设置event标志

class Window: # 主窗口

 def __init__(self, root):
 self.root = root
 self.butlisten = Tkinter.Button(
 root, text='开始监听', command=self.listen) # 创建组件
 self.butlisten.place(x=20, y=15)
 self.butclose = Tkinter.Button(root, text='停止监听', command=self.close)
 self.butclose.place(x=120, y=15)
 self.edit = Tkinter.Text(root)
 self.edit.place(y=50)

 def listen(self): # 处理按钮事件
 self.ctrl = Control(self.edit) # 创建控制线程对象
 self.ctrl.setDaemon(True)
 self.ctrl.start() # 执行控制线程

 def close(self):
 self.ctrl.stop() # 结束控制线程

root = Tkinter.Tk()
window = Window(root)
root.mainloop()

下面是客户端的代码，用户发送文件(脚本中没有处理字符编码，因此发送的文件路径和文件名不能包含中文)。客户端代码示例如下

# -*- coding: utf-8 -*-
import Tkinter
import tkFileDialog
import socket
import os
import time

class Window:

 def __init__(self, root): # 创建组件
 label1 = Tkinter.Label(root, text='IP')
 label2 = Tkinter.Label(root, text='Port')
 label3 = Tkinter.Label(root, text='文件')
 label1.place(x=5, y=5)
 label2.place(x=5, y=30)
 label3.place(x=5, y=55)

 self.entryIP = Tkinter.Entry(root)
 self.entryIP.insert(Tkinter.END, '127.0.0.1')
 self.entryPort = Tkinter.Entry(root)
 self.entryPort.insert(Tkinter.END, '1051')
 self.entryData = Tkinter.Entry(root)
 self.entryData.insert(Tkinter.END, 'Hello')

 self.Recv = Tkinter.Text(root)
 self.entryIP.place(x=40, y=5)
 self.entryPort.place(x=40, y=30)
 self.entryData.place(x=40, y=55)

 self.Recv.place(y=105)
 self.send = Tkinter.Button(root, text='发送数据', command=self.send)
 self.openfile = Tkinter.Button(root, text='浏览', command=self.open_file)
 self.send.place(x=40, y=80)
 self.openfile.place(x=170, y=55)

 def send(self): # 按钮事件
 try: # 异常处理
 ip = self.entryIP.get() # 获取IP
 port = self.entryPort.get() # 获取端口
 filename = self.entryData.get() # 获取发送数据
 tt = filename.split('/')
 name = tt[len(tt) - 1]
 client = socket.socket(
 socket.AF_INET, socket.SOCK_STREAM) # 创建socket对象

 client.connect((ip, int(port))) # 连接服务器
 print('filename: ' + name)
 client.send(name) # 发送数据

 time.sleep(3)

 file = os.open(filename, os.O_RDONLY |
 os.O_EXCL) # 打开文件
 while 1: # 发送文件
 data = os.read(file, 1024)
 if not data:
 break
 print('filename data : ' + data)
 client.send(data)
 os.close(file)
 client.close() # 关闭连接
 except IndexError, value:
 print(value)
 self.Recv.insert(Tkinter.END, '发送错误\n')

 def open_file(self):
 r = tkFileDialog.askopenfilename(
 title='Python Tkinter',
 filetypes=[('All Files', '*'), ('Python', '*.py *.pyw')])
 if r:
 self.entryData.delete(0, Tkinter.END)
 self.entryData.insert(Tkinter.END, r)

root = Tkinter.Tk()
window = Window(root)
root.mainloop()

Python 入门基础知识 - socket建立客户端和服务端

Fri, 25 Jul 2025 15:55:10 +0800

socket建立客户端和服务端

1，建立服务端

使用socket模块建立一个简单的服务端。首先应创建一个socket对象，使用socket对象的bind方法绑定IP地址和端口。

然后使用socket对象的listen方法监听socket连接。最后进入循环等待客户端的连接。代码如下

# -*- coding: utf-8 -*-
import Tkinter
import threading
import socket

class ListenThread(threading.Thread): # 监听线程

 def __init__(self, edit, server):
 threading.Thread.__init__(self)
 self.edit = edit # 保存窗口中的多行文本框
 self.server = server

 def run(self): # 进入监听状态
 while 1: # 使用while循环等待连接
 try: # 捕获异常
 client, addr = self.server.accept() # 等待连接
 self.edit.insert(Tkinter.END, '连接来自:%s:%d\n' %
 addr) # 向文本框输出状态
 data = client.recv(1024) # 接收数据
 self.edit.insert(Tkinter.END, '收到的数据:%s\n' % data) # 向文本框中输出数据
 client.send('I GOT: %s' % data) # 发送数据
 client.close() # 关闭同客户端的连接
 self.edit.insert(Tkinter.END, '关闭客户端\n') # 向文本框中输出状态
 except IndexError, value:
 self.edit.insert(Tkinter.END, value)
 self.edit.insert(Tkinter.END, '关闭连接\n')
 break # 结束循环

class Control(threading.Thread): # 控制线程

 def __init__(self, edit):
 threading.Thread.__init__(self)
 self.edit = edit # 保留窗口中的多行文本框
 self.event = threading.Event() # 创建Event对象
 self.event.clear() # 清楚event标志

 def run(self):
 server = socket.socket(
 socket.AF_INET, socket.SOCK_STREAM) # 创建socket连接
 server.bind(('', 1051)) # 绑定本地端口1051
 server.listen(1) # 开始监听
 self.edit.insert(Tkinter.END, '正在等待连接\n') # 向文本框中输出状态
 self.lt = ListenThread(self.edit, server) # 创建监听线程对象
 self.lt.setDaemon(True)
 self.lt.start() # 执行监听线程
 self.event.wait() # 进入等待状态
 server.close() # 关闭连接

 def stop(self): # 结束控制线程
 self.event.set() # 设置event标志

class Window: # 主窗口

 def __init__(self, root):
 self.root = root
 self.butlisten = Tkinter.Button(
 root, text='开始监听', command=self.listen) # 创建组件
 self.butlisten.place(x=20, y=15)
 self.butclose = Tkinter.Button(root, text='停止监听', command=self.close)
 self.butclose.place(x=120, y=15)
 self.edit = Tkinter.Text(root)
 self.edit.place(y=50)

 def listen(self): # 处理按钮事件
 self.ctrl = Control(self.edit) # 创建控制线程对象
 self.ctrl.setDaemon(True)
 self.ctrl.start() # 执行控制线程

 def close(self):
 self.ctrl.stop() # 结束控制线程

root = Tkinter.Tk()
window = Window(root)
root.mainloop()

在上面的代码中，由于使用while循环监听连接，为了避免图形界面下假死的状态，将while循环放在一个线程里执行，

但Python中没有提供结束线程的函数或者方法，为了随时终止监听，在脚本中创建了一个控制线程。通过控制线程执行

监听线程，然后控制线程进如等待状态。当event被设置后，在控制线程中将关闭socket连接，监听也就停止了。由于

监听线程已经进入监听状态，在控制线程中关闭socket连接将导致异常，所有在监听线程中使用try捕获异常，结束循环。

2，建立客户端

客户端的创建相对简单，只要连接指定的IP和端口地址，然后想服务器发送数据即可，代码如下

# -*- coding: utf-8 -*-
import Tkinter
import socket

class Window:

 def __init__(self, root): # 创建组件
 label1 = Tkinter.Label(root, text='IP')
 label2 = Tkinter.Label(root, text='Port')
 label3 = Tkinter.Label(root, text='Data')
 label1.place(x=5, y=5)
 label2.place(x=5, y=30)
 label3.place(x=5, y=55)

 self.entryIP = Tkinter.Entry(root)
 self.entryIP.insert(Tkinter.END, '127.0.0.1')
 self.entryPort = Tkinter.Entry(root)
 self.entryPort.insert(Tkinter.END, '1051')
 self.entryData = Tkinter.Entry(root)
 self.entryData.insert(Tkinter.END, 'Hello')

 self.Recv = Tkinter.Text(root)
 self.entryIP.place(x=40, y=5)
 self.entryPort.place(x=40, y=30)
 self.entryData.place(x=40, y=55)

 self.Recv.place(y=105)
 self.send = Tkinter.Button(root, text='发送数据', command=self.send)
 self.send.place(x=40, y=80)

 def send(self): # 按钮事件
 try: # 异常处理
 ip = self.entryIP.get() # 获取IP
 port = self.entryPort.get() # 获取端口
 data = self.entryData.get() # 获取发送数据
 client = socket.socket(
 socket.AF_INET, socket.SOCK_STREAM) # 创建socket对象

 client.connect((ip, int(port))) # 连接服务器
 client.send(data) # 发送数据
 rdata = client.recv(1024) # 接收数据
 self.Recv.insert(Tkinter.END, "Server: " + rdata + '\n') # 输出接收的数据
 client.close() # 关闭连接
 except IndexError, value:
 print(value)
 self.Recv.insert(Tkinter.END, '发送错误\n')

root = Tkinter.Tk()
window = Window(root)
root.mainloop()

服务端点击"开始监听"后，启动客户端，点击"发送数据"，这样客户端就能跟服务端进行通信了。

对于新手来说这里又用到Tkinter，这个GUI的模块，请关注后面的GUI模块的相关分享

Python 入门基础知识 - 使用socket模块建立网络通信

Fri, 25 Jul 2025 15:55:07 +0800

使用socket模块建立网络通信

使用Python中的socket模块提供的socket对象的方法，可以在计算机与计算机之间建立连接。一般来说，使用socket创建的通信

应有服务端和客户端，服务端首先建立一个socket，并等待客户端的连接。

客户端建立与服务端的socket连接，当连接成功后，客户端和服务端就可以使用socket进行通信。

socket模块简介

使用socket模块时，应首先使用socket()函数，创建一个socket对象。然后就可以使用socket对象的方法创建连接。

socket()函数原型如下

socket(family, type, proto)

参数含义如下：

family: 地址系列，可选参数。默认为AF_INET，也可以是AF_INET6或AF_UNIX。

type: socket类型，可选参数。默认为SOCK_STREAM

proto: 协议类型，可选参数。

创建好socket对象后，可以使用socket对象的bind方法绑定IP地址和端口。

bind方法的原型如下所示。

bind(address)

其参数函数如下

address: 由IP地址和端口组成的元组，例如"(‘127.0.0.1’, 1051)"。如果IP地址为空，则表示本机。

使用socket对象的listen方法可以监听所有socket对象创建的连接。

其函数原型如下

listen(backlog)

其参数含义如下

backlog: 指定连接队列数，最小值为1，最大值由所使用的操作系统决定，一般情况下为5。

使用socket对象的connect和connect_ex都可以连接到服务端，不同的是将返回一个错误，代替引发一个异常。

connect(address)

connect_ex(address)

其参数含义如下

address: 由IP地址和端口组成的元组。

使用socket对象的accept方法可以接收来自客户端的数据。accept方法将返回一个新的socket对象和客户端的地址。

使用socket对象的recv和recvfrom方法都可以从socket对象获取数据，不同的是recvfrom方法将返回所接收的字符串和地址，

而recv方法仅返回字符串，其原型分别如下

recv(bufsize, flags)

recvfrom(bufsize, flags)

其参数含义如下

bufsize: 指定接收缓冲区的大小

flags: 接收标志，可选参数。

使用socket对象的send和sendall方法都可以向已经连接的socket发送数据，不同的是sendall将一直发送完全的数据，

其原型分别如下

send(string, flags)

sendall(string, flags)

其参数含义如下

string: 所发送的数据

flags: 发送标志，可选参数

使用socket对象的sendto方法可以向一个未连接的socket发送数据，

其参数原型如下

sendto(string, flags, address)

其参数含义如下

string: 所发送的数据

flags: 发送标志，可选参数

address: 由IP地址和端口组成的元组

使用socket对象的makefile方法可以将socket关联到文件对象上，

其原型如下

makefile(mode, bufsize)

参数含义如下

mode: 文件模式，可选参数

bufsize: 缓冲区大小，可选参数

当完后通信后，应使用socket对象的close方法关闭网络连接。

下一篇文章我们演示下如何建立服务器

Python 入门基础知识 - Python网络编程

Fri, 25 Jul 2025 15:55:04 +0800

Python网络编程

Python的标准模块中提供了对网络编程的支持。在Python中，可以使用socket模块进行底层的网络编程，

也可以使用urllib、httplib、ftplib、poplib和smtplib等模块针对特定的网络协议进行编程。除了

Python的标准模块以外，还可以使用Twisted进行网络编程。Twisted支持多种底层协议，使用Twisted

可以更加方便的编写网络应用程序。

使用socket模块

Python中的socket模块进行了底层的网络接口，使用Python的socket模块可以实现网络上不同计算机之间

的socket通信。Python中的socket实现了BSD（Berkeley Software Distribution）套接字标准。

网络编程概述

网络服务都是建立在socket基础之上。socket是网络连接端点，是网络的基础。每个socket都被绑定到指定

的IP和端口上。

每台处于网络中的计算机都有一个IP地址来标识自己的位置。IP地址是一个32位长的二进制数，为方便起见，

IP地址通常由小于255的4组整数组成，每组数之间用".“隔开。例如"123.45.67.89”，如果将其写成二进制

的形式，则是"01111011001011010100001101011001"。有些IP地址比较特殊，例如127.0.0.1，它总是指向

本机，而以"192.168.*.*“开头的则只能用于局域网中。

IP地址还可以和域名绑定，例如，IP地址82.94.237.218绑定到了www.python.org域名上。使用82.94.237.218

同样可以访问Python的官方网站，但显然IP地址不如域名更容易记忆。

除了IP地址，使用socket时还需指定计算机端口。计算机端口的范围值是0~65535，其中小于1024的都是系统所保留的端口，

或者一些网络服务所使用的端口。例如，FTP服务使用21端口，Web服务使用80端口，系统也使用一些较大的端口，

例如，Windows系统中著名的3389端口

IP和端口表明了计算机在网络中的位置，类似于邮政编码和详细地址。计算机之间为了进行通信还需要遵循特定的计算机

网络协议。常见的网络协议有一下几种。

TCP/IP协议，即传输控制协议/互联网协议，其用于在安装了不同硬件和不同操作系统的计算机之间时间可靠的网络通信。

其中，TCP协议用于保证数据包传输的可靠性，IP协议用于保证数据包能被传送到目标计算机。

NetBIOS协议，是由IBM公司开发的，主要用于小型局域网。NetBIOS协议为程序提供了请求低级服务的统一的命令接口，几乎所有的局域网都是在NetBIOS协议的基础上工作的。

FTP协议，及文件传输协议。FTP是Internet中使用最多的文件传输协议。通过FTP协议可以使用客户端从FTP服务器上

下载各种文件。

Telnet协议，即远程登录协议，使用Telnet协议可以登录到远程计算机上。目前仍有很多额BBS可以使用Telnet登录。

HTTP协议，即超文本传输协议，其用于传送WWW方式的数据。

PPP协议，即点对点协议，其主要用来创建电话线路以及ISDN拨号接入ISP的连接，具有多种身份验证方法、数据压缩和

加密以及通知IP地址等功能。

PPPoE协议，即以太网上的点对点协议，其广泛用户ADSL接入方式，也就是常说的宽带。通过PPPoE技术和宽带调制解调器，

用户可以创建虚拟拨号，连接到Internet上。

Python 入门基础知识 - 嵌入式数据库SQLite

Fri, 25 Jul 2025 15:55:01 +0800

嵌入式数据库SQLite

SQLite是一款轻型的嵌入式数据库，相对于其他的庞大数据库软件，SQLite显得十分小巧。

使用SQLite不需要要像MySQL的守护进程。SQLite可以满足一般的数据库应用，Python也提供了对SQLite的支持。

1、SQLite的安装

我使用的是Mac电脑，里面有个比较方便的工具brew，可以自己安装brew，然后执行

brew install sqlite3

安装SQLite完成

2、创建数据库

sqlite3 python

命令行参数"python"表示创建一个名为"python"的数据库。运行后将出现如下提示

SQLite version 3.21.0 2017-10-24 18:55:49

Enter “.help” for usage hints.

sqlite> CREATE TABLE people (name VARCHAR(30), age INT, sex CHAR(1)); # 创建名为’people’的表

sqlite> INSERT INTO people VALUES (‘Durban-1’, 20, ‘M’); # 插入内容

sqlite> INSERT INTO people VALUES (‘Durban-2’, 20, ‘F’); # 插入内容

sqlite> SELECT * FROM people; # 查看表’people’的数据内容

Durban-1|20|M

Durban-2|20|F

sqlite>

3、Python中使用SQLite

完成对数据库的操作后可以使用.exit命令退出命令行，此时就可以在Python中使用所创建的’python’数据库了。在Python中

使用SQLite数据库和使用MySQL数据库的过程类似。首先需要导入sqlite3模块，由于SQLite不需要服务器，因此直接使用connect

方法直接打开数据库即可。connect方法返回一个数据库连接对象，使用其cursor方法可以获得一个游标，然后就可以对记录进行操作。

在完成操作后，应使用close方法关闭游标和数据库连接。

实例演示如下

# _*_ coding: utf-8 -*-
import sqlite3
con = sqlite3.connect('python')
cur = con.cursor()
cur.execute(
 'insert into people (name, age, sex) values (\'Durban-3\', 23, \'F\')')
r = cur.execute('delete from people where age = 20')
con.commit()
cur.execute('select * from people')
s = cur.fetchall()
print(s)
cur.close()
con.close()

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 使用MySQL数据库

Fri, 25 Jul 2025 15:54:57 +0800

使用MySQL数据库

MySQL是一个小巧的多用户、多线程SQL数据库服务器。MySQL是一个客户机/服务器结构的实现，它由一个服务器守护进程和客户程序组成。

MySQL提供了对SQL语句的支持。在Python中可以使用MySQLdb模块链接到MySQL，对于MySQL数据库进行操作。

1、安装MySQL

这个环节，可以自行去官网下载进行安装，不会的可以群里交流

安装好MySQL后可以使用其附带的命令行工具创建数据库。创建好数据库后，就可以使用MySQL模块，在Python中连接到数据，对记录进行操作。

2、安装MySQLdb

在Python中使用MySQL的数据库需要安装MySQLdb模块。

由于我的是在mac下，我一般都是用命令行安装，可以参考如下命令

pip install MySQL-python

3、在Python中使用MySQL数据库

使用MySQLdb连接到MySQL数据库，首先使用MySQLdb模块的connect方法链接到MySQL守护进程。connect方法将返回一个数据库链接。使用数据库

链接的cursor方法可以获得当前数据库的游标。然后就可以使用游标的Execute方法执行SQL语句，完成对数据库的操作。

同样，当完成操作应调用close方法关闭游标和数据连接。

示例如下

import MySQLdb # 导入MySQLdb模块
db = MySQLdb.connect(
 host='localhost', # 连接到数据库，服务器为本机
 user='root', # 用户名为root
 passwd='123456', # 密码为123456
 db='test') # 数据库名为test
cur = db.cursor() # 获得数据库游标
cur.execute(
 'insert into people \
 (name, age, sex) \
 values \
 (\'Durban - 1\', 21, \'Female\')') # 执行SQL语句，添加记录
cur.execute(
 'insert into people \
 (name, age, sex) \
 values \
 (\'Durban - 2\', 20, \'Male\')') # 执行SQL语句，添加记录
r = cur.execute('delete from people where age = 20') # 执行SQL语句，删除记录
db.commit() # 提交事务
r = cur.execute('select * from people') # 执行SQL语句，获得记录
r = cur.fetchall() # 获取数据
print(r) # 输出数据
cur.close()
db.close()

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 代码框架生成器

Fri, 25 Jul 2025 15:54:54 +0800

代码框架生成器

编写代码要养成良好的习惯，为了使脚本更具可读性，往往需要添加注释，而且还应该在脚本头添加基本的说明，如作者、文件名、日期、

用途、版本说明。以及所需要使用的模块等信息。这样不仅便于保存脚本，而且也便于交流。

但是，如果每次编写代码写一个脚本就依次添加这样的信息，不免有些麻烦，下面代码简单生成了一个代码框架生成器

# _*_ coding: utf-8 -*-
import os
import sys
import string
import datetime
py = '''# ------------------------------------------------------
# To:
# ------------------------------------------------------
# By:
# ------------------------------------------------------
'''

c = ''' * ------------------------------------------------------
 * To:
 * ------------------------------------------------------
 * By:
 * ------------------------------------------------------
'''

if os.path.isfile(sys.argv[1]):
 print('%s already exist!' % sys.argv[1])
 sys.exit()

file = open(sys.argv[1], 'w') # 创建文件
today = datetime.date.today() # 获取当前日期，并格式化为xxxx-xx-xx形式
date = today.strftime('%Y') + '-' + today.strftime('%m') + \
 '-' + today.strftime('%d')
filetypes = string.split(sys.argv[1], '.') # 判断将创建的文件是什么类型以便对其分别处理
length = len(filetypes)
filetype = filetypes[length - 1]
if filetype == 'py':
 print('use python mode')
 file.writelines('# -*- coding: utf-8 -*-')
 file.write('\n')
 file.writelines('# File: ' + sys.argv[1])
 file.write('\n')
 file.write(py)
 file.write('# Date: ' + date)
 file.write('\n')
 file.write('# ------------------------------------------------------')
 file.write('\n')
elif filetype == 'c' or filetype == 'cpp':
 print('use c mode')
 file.writelines('/*')
 file.write('\n')
 file.writelines(
 ' * ------------------------------------------------------')
 file.write('\n')
 file.writelines(' * File: ' + sys.argv[1])
 file.write('\n')
 file.write(c)
 file.write(' * Date: ' + date)
 file.write('\n')
 file.write(' * ------------------------------------------------------')
 file.write('\n')
 file.write(' */ \n')
else:
 print('just create %s ' % sys.argv[1])

file.close()

这样就可以随时运行，方便在目录中生成Python脚本或c/c++脚本

测试如下

python generate.py python.py
python generate.py c.c

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 批量重命名

Fri, 25 Jul 2025 15:54:51 +0800

批量重命名

在日常工作中经常会遇到这样的情况，需要将某个文件夹下的文件按照一定的规律重新命名。如果手完成的话，

需要耗费大量的时间，而且容易出错。在学习Python以后，完全可以写一个脚本完成这样的工作。

示例如下

import os
prefix = 'Python' # prefix 为重命名后的文件起始字符
length = 2 # length为除去prefix以后，文件名要达到的长度
base = 1 # 文件名的其实函数
format = 'mdb' # 文件名的后缀

'''函数padLeft将文件名补全到指定长度
str 为要补全的字符
num 为要达到的长度
padstr 为达到长度所需要添加的字符
'''

def padLeft(str, num, padstr):
 stringLen = len(str)
 n = num - stringLen
 if n > 0:
 str = padstr * n + str

 return str

# 为了避免用户误操作，这里先提示用户
print('the files in "%s" will be renamed' % os.getcwd())
input = raw_input('press y to continue\n')
if input != 'y':
 exit()

filenames = os.listdir(os.curdir) # 获取当前目录中的内容
# 从基数减1，为了使i = i + 1在第一次执行时等于基数
i = base - 1
for filename in filenames:
 i = i + 1
 # 判断当前路径是否为文件，并且不是"rename.py"
 if filename != 'base_practise.py' and os.path.isfile(filename):
 name = str(i)
 name = padLeft(name, length, '0')
 t = filename.split('.')
 m = len(t)
 if format == '': # 如果未指定文件类型，则更改当前目录中所有文件
 os.rename(filename, prefix + name + '.' + t[m - 1])
 else: # 否则只修改指定类型的文件
 if t[m - 1] == format:
 os.rename(filename, prefix + name + '.' + str(t[m - 1]))
 else:
 i = i - 1 # 保证i连续
 else:
 i = i - 1

可以自己运行下，创建个xxx.mdb的文件

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 文件和目录

Fri, 25 Jul 2025 15:54:48 +0800

文件和目录

文件目录常用函数

在进行文件和目录操作的时候，一般会用到以下几种函数

1，获取当前路径

在Python中可以使用os.getcwd()函数获得当前目录的路径。其原型如下所示。

os.getcwd()

该函数不需要传入参数，他返回当前目录。需要说明的是，当前目录并不是指脚本所在的目录，而是所运行脚本的目录。

示例如下

import os
print('current directory %s' % os.getcwd())

运行后结果输出如下

current directory /Users/durban/python/practise

2，获得目录中的内容

在Python中可以使用os.listdir()函数获得指定目录中的内容，其原型如下

os.listdir(path)

其参数含义如下

path: 要获得内容目录的路径

示例如下

import os
print(os.listdir(os.getcwd()))

运行后输出如下

['base_phrase.py', 'base_practise.py', 'module', 'pdb_test.py', 'test.py', 'usemodule.py', 'usemodule.pyo']

3，创建目录

在Python中可以使用os.mkdir()函数创建目录，其原型如下所示

os.mkdir(path)

其参数函数如下

path 要创建目录的路径

示例如下

import os
os.mkdir('/Users/durban/python/practise/temp')

4，删除目录

在Python中删除目录可以使用os.rmdir函数删除目录。其原型如下

os.rmdir(path)

其参数含义如下

path 要删除的目录的路径

示例如下

import os
os.rmdir('/Users/durban/python/practise/temp')

需要注意的是，使用os.rmdir()删除目录的时候，目录必须为空，否则会报错

5，判断目录是否存在

在Python中可以使用os.path.isdir()函数判断某一路径是否是目录。

其原型如下

os.path.isdir(path)

其参数含义如下

path: 要进行判断的路径

示例如下

import os
print(os.path.isdir('/Users/durban/python/practise/module')) # 一个存在的目录

运行结果如下

True

6，判断是否是文件

在Python中os.path.isfile()函数可以判断一个目录是否是文件，其函数原型如下

os.path.isfile(path)

其参数含义如下

path: 要进行判断的路径

示例如下

import os
print(os.path.isfile('/Users/durban/python/practise/module')) # 一个目录

结果输出如下

False

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 使用微线程

Fri, 25 Jul 2025 15:54:44 +0800

使用微线程

使用Stackless Python的内置模块stackless可以完成多线程编程，使用起来更加方便。

实力代码如下

# _*_ coding: utf-8 -*-
import stackless
import Queue

def Producer(i):
 global queue
 queue.put(i)
 print('Producer %s add %s' % (i, i))

def Consumer(i):
 global queue
 i = queue.get()
 print('Consumer %s add %s' % (i, i))

queue = Queue.Queue()

for i in range(10):
 stackless.tasklet(Producer)(i)

for i in range(10):
 stackless.tasklet(Consumer)(i)

stackless.run()

运行脚本后输出结果如下所示

Producer 0 add 0
Producer 1 add 1
Producer 2 add 2
Producer 3 add 3
Producer 4 add 4
Producer 5 add 5
Producer 6 add 6
Producer 7 add 7
Producer 8 add 8
Producer 9 add 9
Consumer 0 add 0
Consumer 1 add 1
Consumer 2 add 2
Consumer 3 add 3
Consumer 4 add 4
Consumer 5 add 5
Consumer 6 add 6
Consumer 7 add 7
Consumer 8 add 8
Consumer 9 add 9

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 微线程 - Stackless Python

Fri, 25 Jul 2025 15:54:39 +0800

微线程 - Stackless Python

Stackless Python是Python的一个增强版本。Stackless Python修改了Python的代码，提供了对微线程的支持。

微线程是轻量级的线程，与前边所讲的线程相比，微线程在多个线程间切换所需的时间更多，占用资源也更少。

Stackless Python概述

Stackless Python不是必需的，它只是Python的一个修改版本，对多线程编程更友好的支持。如果在对线程应用有较高的的要求时

可以考虑使用Stackless Python来完成。

1.Stackless Python 安装

在安装Stackless Python之前应该先安装Python，根据所安装的Python版本到Stackless Python的官网

http://stackless.com下载相应的版本。

安装完后可以在Python的交换式环境中输入如下代码

import stackless

如果没有错误产生，则表示Stackless Python已经安装好了。若出现错误，则可能是Stackless Python与当前的Python版本不兼容，

可以考虑使用其他版本的Python

2. stackless模块中的tasklet对象

Stackless Python提供了stackless内置模块。stackless模块中的tasklet对象完成了与创建线程类似的功能。

使用tasklet对象可以像创建线程运行函数那样来运行函数。

示例代码如下

# _*_ coding: utf-8 _*_
import stackless
def show():
 print('Stackless Python')
st = stackless.tasklet(show)() # 调用tasklet添加函数，第2个括号为函数参数
st.run() # 调用run方法，执行函数
st = stackless.tasklet(show)() # 重新生成st
print(st.alive) # 查看其状态
st.kill() # 调用kill方法结束线程
print(st.alive) # 查看其状态
print(stackless.tasklet(show)()) # 直接调用tasklet
print(stackless.tasklet(show)())
stackless.run() # 调用run方法

运行后输出结果如下

Stackless Python
True
False
<_stackless.tasklet object at 0x1007e76e0>
<_stackless.tasklet object at 0x1007e7b40>
Stackless Python
Stackless Python

3.stackless模块中的schedule对象

stackless模块中的schedule对象可以控制任务的执行顺序。当有多个任务时，可以使用schedule对象使其依次执行。

示例代码如下

# _*_ coding: utf-8 _*_
import stackless
def show():
 stackless.schedule()
 print(1)
 stackless.schedule()
 print(2)
stackless.tasklet(show)() # 调用tasklet,生成任务列表
stackless.tasklet(show)()
stackless.run() # 执行任务

运行后输出结果如下

4.stackless模块中的channel对象

使用stackless模块中的channel对象可以在不同的人之间进行通信，这和线程间的通信类似。使用channel对象的

send方法可以发送数据。使用channel对象的receive方法可以接收数据。

# _*_ coding: utf-8 _*_
import stackless
def send():
 chn.send('Stackless Python')
 print('I send: Stackless Python')
def rec():
 print('I receive: %s ' % chn.receive())
chn = stackless.channel()
stackless.tasklet(send)()
stackless.tasklet(rec)()
stackless.run()

运行结果如下

I receive: Stackless Python
I send: Stackless Python

实例环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 线程间通信

Fri, 25 Jul 2025 15:10:19 +0800

线程间通信

Python提供了Event对象用于线程间的相互通信。实际上线程同步在一定程度上已经实现线程间的通信。线程同步是每次仅有一个线程

对共享数据进行操作，其他线程则等待。而Event对象是由线程设置的信号标志，如果信号标志为真，则其他线程等待直到信号解除。

Event对象的方法

Event对象实现了简单的线程通信机制，它提供了设置信号、清除信号、等待等用于实现线程间的通信。

1.设置信号

使用Event对象的set()方法可以设置Event对象内部的信号标志为真。Event对象提供了isSet()方法来判断其内部信号标志的状态。

当使用Event对象的set()方法后，isSet()方法返回真。

2.清除信号

使用Event对象的clear()方法可以清除Event对象内部的信号标志，即将其设置为假。当使用Event对象的clear()方法后，isSet()方法

返回假。

3.等待

Event对象wait的wait方法只有在其内部信号为真时才会很快的执行完成并返回。当Event对象的内部信号标志为假时，则wait方法一直

等到为真时才返回。另外还可以向wait方法传递参数，以设定最长等待时间。

使用Event对象实现线程间通信

配合使用Event对象的几种方法可以实现进程间的简单通信。

实例演示如下

# _*_ coding: utf-8 _*_
import threading

class TestThread(threading.Thread):
 def __init__(self, name):
 threading.Thread.__init__(self, name=name)

 def run(self):
 global event # 使用全局Event对象
 if event.isSet(): # 判断Event对象内部信号标志
 event.clear() # 若已设置标志则清除
 event.wait() # 调用wait方法
 print(self.getName())
 else:
 print(self.getName())
 event.set() # 设置Event对象内部信号标志

event = threading.Event() # 生成Event对象
event.set() # 设置Event对象内部信号标志

t1 = []
for i in range(10):
 t = TestThread('线程：' + str(i))
 t1.append(t)

for i in t1:
 i.start()

运行脚本后结果输出如下，每次运行后结果会不一样

线程：1
线程：2
线程：0
线程：4
线程：5
线程：3
线程：8
线程：7
线程：6
线程：9

实例环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 使用队列保持线程同步

Fri, 25 Jul 2025 15:10:16 +0800

使用队列保持线程同步

Python中的Queue对象也提供了对线程同步的支持。使用Queue对象可以实现多生产者和多消费者形成的先进先出的队列。

每个生产者将数据依次存入队列，而每个消费者则依次从队列中取出数据。

实例演示如下

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

import threading
import Queue

class Producer(threading.Thread):
 def __init__(self, name):
 threading.Thread.__init__(self, name=name)

 def run(self):
 global queue
 queue.put(self.getName())
 print('%s, put %s to queue' % (self.getName(), self.getName()))

class Consumer(threading.Thread):
 def __init__(self, name):
 threading.Thread.__init__(self, name=name)

 def run(self):
 global queue
 print('%s, get %s from queue' % (self.getName(), self.getName()))

queue = Queue.Queue()
plist = []
clist = []

for i in range(10):
 p = Producer('Producer ' + str(i))
 plist.append(p)

for i in range(10):
 c = Consumer('Consumer ' + str(i))
 clist.append(c)

for i in plist:
 i.start()
 i.join()

for i in clist:
 i.start()
 i.join()

运行结果如下

Producer 0, put Producer 0 to queue
Producer 1, put Producer 1 to queue
Producer 2, put Producer 2 to queue
Producer 3, put Producer 3 to queue
Producer 4, put Producer 4 to queue
Producer 5, put Producer 5 to queue
Producer 6, put Producer 6 to queue
Producer 7, put Producer 7 to queue
Producer 8, put Producer 8 to queue
Producer 9, put Producer 9 to queue
Consumer 0, get Consumer 0 from queue
Consumer 1, get Consumer 1 from queue
Consumer 2, get Consumer 2 from queue
Consumer 3, get Consumer 3 from queue
Consumer 4, get Consumer 4 from queue
Consumer 5, get Consumer 5 from queue
Consumer 6, get Consumer 6 from queue
Consumer 7, get Consumer 7 from queue
Consumer 8, get Consumer 8 from queue
Consumer 9, get Consumer 9 from queue

Python 入门基础知识 -使用条件变量保持线程同步

Fri, 25 Jul 2025 15:10:12 +0800

使用条件变量保持线程同步

Python的Condition对象提供了对复杂线程同步的支持。使用Condition对象可以在某些事件触发后才处理数据。

Condition对象除了具有acquire方法和release方法以外，还有wait方法、notify方法、notifyAll方法等用于

条件处理。

实例代码演示如下

# _*_ coding: utf-8 _*_
import threading

class Producer(threading.Thread):
 def __init__(self, name):
 threading.Thread.__init__(self, name=name)

 def run(self):
 global x
 con.acquire()
 if x == 100000:
 con.wait()
 pass
 else:
 for i in range(100000):
 x = x + 1
 con.notify()
 print(x)
 con.release()

class Consumer(threading.Thread):
 def __init__(self, name):
 threading.Thread.__init__(self, name=name)

 def run(self):
 global x
 con.acquire()
 if x == 0:
 con.wait()
 pass
 else:
 for i in range(100000):
 x = x - 1
 con.notify()
 print(x)
 con.release()

con = threading.Condition()
x = 0
p = Producer('Producer')
c = Consumer('Consumer')
p.start()
p.join()
c.start()
c.join()

运行后输出结果如下

100000
0

Python 入门基础知识 - 线程同步

Fri, 25 Jul 2025 15:10:09 +0800

线程同步

如果多个线程共同对某个数据修改，则可能会出现不可预料的结果。为了保证数据被正确修改，需要对多个线程进行同步。

简单的线程同步

使用Thead对象的Lock和RLock可以实现简单的线程同步。Lock对象和RLock对象都具有acquire方法和release方法。对于如果

需要每次只有一个线程操作的数据，可以将操作过程放在acquire方法和release方法之间。

实例演示如下

# _*_ coding: utf-8 -*-
# version 2.7.13
#
import threading # 导入threading模块
import time # 导入time模块

class TestThread(threading.Thread): # 通过继承创建类

 def __init__(self, thread_name): # 初始化方法
 threading.Thread.__init__(self, name=thread_name) # 调用父类的初始化方法

 def run(self): # 重载run方法
 global x # 使用global表明x为全局变量
 lock.acquire() # 调用lock的acquire方法
 for i in range(3):
 x = x + 1

 time.sleep(5) # 让线程休眠5秒
 print(x)
 lock.release() # 调用lock的release方法

lock = threading.RLock() # 生成RLock对象
t1 = [] # 定义列表
for i in range(10):
 t = TestThread('线程 %s' % str(i)) # 类实例化
 t1.append(t) # 将类对象添加到列表中

x = 0
for i in t1:
 i.start()

执行后输出结果如下

将上面脚本中的"lock.acquire()"、“lock.release()“和"threading.RLock()“删除后运行脚本。得到如下结果

修改后的脚本输出都是30也就是x的终值。由于x是全局变量，在每个线程对x进行操作后就"休眠"了。在线程休眠的时候，Python

解释器已经执行了其他的线程，而使x值增加。当所有线程"休眠"结束后，i的值已被所有线程修改变成了30，因此输出30。

而在使用Lock对象的脚本中，对全局变量x的操作放在acquire方法和release方法之间。Python解释器每次仅允许一个线程对x

进行操作。只有当该线程操作完成后，并且结束休眠以后才开始下一个线程，所以使用Lock对象的脚本输出是依次递增的。

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - Thread对象中的方法

Fri, 25 Jul 2025 15:10:06 +0800

Thread对象中的方法

在上一篇文章中，仅使用了Thread对象中的start方法，重载了Thread对象的run方法。当线程被运行时，将运行run方法。

Thread对象具有以下的几种方法。

1、join方法

如果一个线程或者在函数的执行过程中调用另一个线程，并且待其完成操作后才能执行，那么在调用线程时可以使用被调用线程的join方法。

方法的原型如下

join([timeout])

其参数函数如下。

timeout: 可选参数，线程运行的最长时间。

实例演示如下

import threading # 导入threading模块
import time # 导入time模块
class TestThread(threading.Thread): # 通过继承Thread创建类
 def __init__(self, id): # 初始化方法
 threading.Thread.__init__(self) # 调用父类的初始化方法
 self.id = id
 def run(self): # 重载run方法
 time.sleep(10) # 使用time模块中的sleep方法让线程休眠10秒
 print('线程ID: %s' % self.id)
def testFunc(): # 定义线程
 t1.start() # 运行线程
 for i in range(5):
 print(i)
t1 = TestThread(2) # 生成TestThread对象
testFunc() # 调用函数，运行线程

运行结果如下

0
1
2
3
4
线程ID: 2

从上面的结果看出，testFunc直接运行了，并没有等待线程完成

def secondTestFunc():
 t2.start()
 t2.join()
 for i in range(5):
 print(i)
t2 = TestThread(3)
secondTestFunc()

运行结果如下

线程ID: 3
0
1
2
3
4

从上面的结果看出，secondTestFunc等待线程完成后，在执行

2、isAlive方法

当线程创建后，可以使用Thread对象的isAlive方法查看线程是否运行。

实例演示如下

import threading
import time
class TestThread2(threading.Thread):
 def __init__(self, id):
 threading.Thread.__init__(self)
 self.id = id
 def run(self):
 time.sleep(5)
 print('当前线程ID: %s' % self.id)
t3 = TestThread2(4)
def thirdTestFunc():
 t3.start() # 运行线程
 print(t3.isAlive()) # 打印线程状态
thirdTestFunc() # 调用函数

运行结果如下

True # 线程状态
当前线程ID: 4 # 线程输出

3、线程名

当线程创建后可以设置线程名来区分不同的线程，以便对线程进行控制。线程名可以在类的初始化函数中定义，也可以使用Thread

对象setName方法设置线程名。使用Thread对象的getName方法可以获得线程名。

实例演示如下

import threading
class TestThread3(threading.Thread):
 def __init__(self, threadName):
 threading.Thread.__init__(self, name=threadName)
 def run(self):
 print(self.getName())
t1 = TestThread3('t1')
print(t1.getName())

运行后输出结果如下

t1

t1.setName('T1')
print(t1.getName())

运行后输出结果如下

T1

t2 = TestThread3('t2')
t2.start()
print(t2.getName())
t2.setName('T2')
print(t2.getName())

运行后输出如下

t2
t2
T2

4、setDaemon方法

在脚本运行过程中有一个线程，如果主线程又创建一个子线程，那么当主线程退出时，会检验子线程是否完成。如果子线程未完成，则

主线程会等待子线程完成后再退出。当需要主线程退出时，不管子线程是否完成都随主线程退出，则可以使用Thead对象的setDaemon

方法来设置。

代码示例如下

# _*_ coding: utf-8 -*-
# version 2.7.13
import threading
import time

class TestThread(threading.Thread):

 def __init__(self, thread_name):
 threading.Thread.__init__(self, name=thread_name)

 def run(self):
 time.sleep(10)
 print(self.getName())

def func1():
 t1.start()
 print('func1 done')

def func2():
 t2.start()
 print('func2 done')

t1 = TestThread('线程T1')
t2 = TestThread('线程T2')
t2.setDaemon(True)
func1()
func2()

运行后输出结果如下

func1 done
func2 done
线程T1

由于调用了线程t2的setDaemon方法，当主线程结束时，线程t2也跟着结束。因此t2还没有来得及打印自己的线程名，就结束了。

将脚本中的t2.setDaemon(True)删除后运行得到结果如下

func1 done
func2 done
线程T2
线程T1

修改后的脚本要等待所有子线程完成后才会退出，因此线程t1和t2都被执行完成。如果在交互式模式下运行改脚本，则不会有区别，

因为在交互模式下的主线程在退出Python时才终止。

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 多线程编程

Fri, 25 Jul 2025 15:10:02 +0800

多线程编程

进程是操作系统中应用程序的执行实例，而线程是进程内部的一个执行单元。当系统创建一个进程后，也就创建了一个主线程。每个进程至少有一个线程，

也可以有多个线程。在程序中使用多线程可以实现并行处理，充分利用CPU。Python提供了对多线程的支持。在Python中可以方便的使用多线程进行编程。

线程基础

Python提供了thread、threading模块对多线程编程的支持。threading模块是对thread模块的封装。多数情况下使用threading模块来进行多线程编程。

创建编程

在Python中可以通过使用thread模块中的函数，或者通过继承threading类来创建线程。编程创建后还可以对其进行操作。

1，使用thread模块创建线程

thread模块提供了start_new_thread函数，用以创建线程。start_new_thread函数成功创建线程后将返回线程标识。其函数原型如下所示。

其函数含义如下。

function: 在线程中执行的函数名

args: 元组形式的函数列表

kwargs: 可选参数，以字典的形式指定参数

实例演示如下

import thread # 导入thread函数
import time

def run(n): # 定义run函数
 for i in range(n):
 print(i)

print(thread.start_new_thread(run, (4,))) # 使用start_new_thread函数创建线程
print(thread.start_new_thread(run, (2,))) # 使用start_new_thread函数创建线程
print(thread.start_new_thread(run, (), {'n': 4})) # 使用字典向函数传递参数

time.sleep(10) # 防止主线程先于子线程结束而报错

运行代码后输出如下

123145544208384 # 返回线程的标识
0 # 此处为run函数的输出
1
2
3
0
1
123145548414976 # 返回线程的标识
0 # 此处为run函数的输出
1
123145544208384 # 返回线程的标识

可以看到以上输入每次执行后都会有不同的顺序输出

2，使用threading模块创建线程

通过继承threading模块中的Thread创建新类，重载run方法后，可以通过start方法创建线程。线程创建后将运行run方法。

代码演示如下

import threading

class TestThread(threading.Thread):

 def __init__(self, num):
 threading.Thread.__init__(self)
 self.num = num

 def run(self):
 print('I am ' + str(self.num))

t1 = TestThread(1)
t2 = TestThread(2)
t3 = TestThread(3)
t1.start()
t2.start()
t3.start()

运行代码后输出如下

I am 1
I am 2
I am 3

除了通过继承threading.Thread创建类以外，还可以通过使用threading.Thread直接在线程中创建函数。

实例演示如下

import threading # 导入threading模块

def run(x, y): # 定义run函数
 for i in range(x, y):
 print(i)

t1 = threading.Thread(target=run, args=(15, 20)) # 直接使用Thread附加函数，args为函数参数
t1.start() # 运行线程
# 运行结果如下
# 15
# 16
# 17
# 18

t2 = threading.Thread(target=run, args=(7, 11)) # 直接使用Thread附加函数，args为函数参数
t2.start() # 运行线程
# 运行结果如下
# 7
# 8
# 9
# 10

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - pdb调试命令

Fri, 25 Jul 2025 15:09:59 +0800

pdb调试命令

前几篇文章已经使用了部分pdb的调试命令与被调试的脚本进行交互。pdb中的调试命令可以完成单步执行、打印变量值、设置断点等功能。

pdb的部分调试命令如下

完整命令 | 简写命令 | 描述

args | a | 打印当前函数的参数

break | b | 设置断点

clear | cl | 清楚断点

condition | 无 | 设置条件断点

continue | c或者cont | 继续运行，直到遇到断点或者脚本结束

disable | 无 | 禁用断点

help | h | 查看pdb帮助

ignore | 无 | 忽略断点

jump | j | 跳转到指定行数运行

list | l | 列出脚本清单

next | n | 执行下条语句，遇到函数不进行其内部

p | p | 打印变量值，也可以用print

quit | q | 退出pdb

return | r 一直运行到函数返回

tbreak | 无 | 设置临时断点，断点只中断一次

step | s | 执行下一条语句，遇到函数进入其内部

where | w | 查看所在的位置

! | 无 | 在pdb中执行语句

以下实例通过命令行启动pdb对脚本机型调试。如下所示

$ python -m pdb pdb_test.py
> /Users/durban/python/practise/pdb_test.py(4)<module>()
-> import math
(Pdb) list # 先停在这里，前边有"(Pdb)"提示符，输入list命令
 1 # _*_ coding: utf-8 -*- # list命令默认只列出前11行
 2 # version 2.7.13
 3 #
 4 -> import math
 5
 6
 7 def isprime(i):
 8 for t in range(2, int(math.sqrt(i)) + 1):
 9 if i % t == 0:
 10 return 0
 11 return 1
(Pdb) n
> /Users/durban/python/practise/pdb_test.py(7)<module>()
-> def isprime(i):
(Pdb) l 14, 17 # 使用list命令列出14到17行的脚本内容
 14 print('打印100-110之间的素数有：')
 15
 16
 17 for i in range(100, 110):
(Pdb) b 14 # 使用b在第14行设置断点
Breakpoint 1 at /Users/durban/python/practise/pdb_test.py:14 # 返回断点编号1
(Pdb) b isprime # 在函数isprime上设置断点
Breakpoint 2 at /Users/durban/python/practise/pdb_test.py:7 # 返回断点编号2
(Pdb) c # 使用c命令运行脚本
> /Users/durban/python/practise/pdb_test.py(14)<module>() # 停在断点1处，即第14行
-> print('打印100-110之间的素数有：')
(Pdb) c # 使用c命令继续运行脚本
打印100-110之间的素数有： # 第14行脚本输出
> /Users/durban/python/practise/pdb_test.py(8)isprime() # 停在断点2处，即isprime函数处
-> for t in range(2, int(math.sqrt(i)) + 1):
(Pdb) b 17 # 在17行设置断点
Breakpoint 3 at /Users/durban/python/practise/pdb_test.py:17 # 返回断点编号3
(Pdb) disable 2 # 禁用断点2，即isprime函数处的断点
(Pdb) c # 继续运行脚本
> /Users/durban/python/practise/pdb_test.py(17)<module>() # 停在断点3处，即第15行
-> for i in range(100, 110):
(Pdb) print i # 使用print打印变量i的值
100
(Pdb) print(i)
100
(Pdb) c # 继续运行断点
101
> /Users/durban/python/practise/pdb_test.py(17)<module>() # 停在断点3处，即第17行
-> for i in range(100, 110):
(Pdb) p i # 使用p打印变量i的值
101
(Pdb) enable 2 # 恢复断点2，即isprime函数处的断点
(Pdb) c # 继续运行脚本
> /Users/durban/python/practise/pdb_test.py(8)isprime() # 停在断点2处，即isprime函数处的断点
-> for t in range(2, int(math.sqrt(i)) + 1):
(Pdb) n # 单步执行下一语句
> /Users/durban/python/practise/pdb_test.py(9)isprime()
-> if i % t == 0: # 停在下一语句处
(Pdb) p t # 使用p打印变量t的值
2
(Pdb) cl # 清楚所有断点，输入y确认
Clear all breaks? y
(Pdb) c # 继续运行脚本
103
105
107
109
The program finished and will be restarted # 脚本运行结束，回到开始处
> /Users/durban/python/practise/pdb_test.py(4)<module>()
-> import math
(Pdb) q # 使用q命令退出pdb

pdb_test.py文件代码如下：

# _*_ coding: utf-8 -*-
# version 2.7.13
#
import math

def isprime(i):
 for t in range(2, int(math.sqrt(i)) + 1):
 if i % t == 0:
 return 0
 return 1

print('打印100-110之间的素数有：')

for i in range(100, 110):
 if isprime(i):
 print(i)

实例环境如下

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - pdb设置硬断点

Fri, 25 Jul 2025 15:09:56 +0800

设置硬断点

在Python中可以使用pdb模块的set_trace函数在脚本中设置硬断点。set_trace函数一般在".py"脚本中使用。

其函数原型如下所示：

set_trace()

实例演示如下：

import pdb # 导入pdb模块
pdb.set_trace() # 使用set_trace函数设置硬断点
for i in range(1, 10):
 i = i * 5
 print(i)

运行脚本后如下所示

> /Users/durban/python/practise/test.py(12)<module>()
-> for i in range(1, 10):
(Pdb) list
 7 	# 其函数原型如下所示：
 8 	# set_trace()
 9 	import pdb # 导入pdb模块
 10
 11 	pdb.set_trace() # 使用set_trace函数设置硬断点
 12 ->	for i in range(1, 10):
 13 	 i = i * 5
 14 	 print(i)
 15
 16 	# 运行脚本后如下所示
[EOF]
(Pdb) n
> /Users/durban/python/practise/test.py(13)<module>()
-> i = i * 5
(Pdb) list
 8 	# set_trace()
 9 	import pdb # 导入pdb模块
 10
 11 	pdb.set_trace() # 使用set_trace函数设置硬断点
 12 	for i in range(1, 10):
 13 ->	 i = i * 5
 14 	 print(i)
 15
 16 	# 运行脚本后如下所示
[EOF]
(Pdb) continue
5
10
15
20
25
30
35
40
45

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - pdb运行函数

Fri, 25 Jul 2025 15:09:53 +0800

pdb运行函数

在Python中可以使用pdb模块的runcall函数来调试函数。其函数原型如下所示。

runcall(function[, argument, …])

其参数含义如下

function: 函数名

argument: 函数的参数

实例演示如下

import pdb

def sum(*args):
 r = 0
 for arg in args:
 r = r + arg
 return r

pdb.runcall(sum, 1, 2, 3, 4)

运行顺序可以参考如下

>>> import pdb # 导入pdb模块
>>>
>>>
>>> def sum(*args): #定义函数sum求所有参数之和
... r = 0
... for arg in args:
... r = r + arg
... return r
...
>>> pdb.runcall(sum, 1, 2, 3, 4) # 使用runcall调试函数sum
> <stdin>(2)sum()
(Pdb) print(r)
*** NameError: name 'r' is not defined
(Pdb) n # 进入调试状态，使用n命令，进行单步执行
> <stdin>(3)sum()
(Pdb) n # 使用n命令，进行单步执行
> <stdin>(4)sum()
(Pdb) print r 使用print打印变量r的值
0
(Pdb) print(r)
0
(Pdb) n
> <stdin>(3)sum()
(Pdb) n
> <stdin>(4)sum()
(Pdb) n
> <stdin>(3)sum()
(Pdb) print(r)
3
(Pdb) continue # 使用continue继续执行
10 # 函数返回结果

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - pdb运行表达式

Fri, 25 Jul 2025 15:09:49 +0800

pdb运行表达式

在Python中可以使用pdb模块的runeval函数来调试表达式。其参数原型如下所示。

runeval(expression[, globals[, locals]])

其参数如下。

statement: 要调试的表达式，以字符串的形式

globals: 可选参数，设置statement运行的全局环境变量

locals: 可选参数，设置statement运行的局部环境变量

以下实例如下

import pdb # 导入pdb模块
l = [1,2,3] # 定义一个列表
pdb.runeval('n = l[1]') # 使用runeval调试表达式l[1]

运行后结果如下

> <string>(1)<module>()
(Pdb) n # 进入调试状态，使用n命令，单步执行
--Return--
> <string>(1)<module>()->2
(Pdb) n # 使用n命令，单步执行

pdb.runeval('3+5*6/2') # 使用runeval调试表达式3+5*6/2

运行后结果如下

> <string>(1)<module>()
(Pdb) n # 进入调试状态，使用n命令，单步执行
--Return--
> <string>(1)<module>()->18
(Pdb) n # 使用n命令，单步执行

实例声明如下

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 使用pdb调试Python脚本

Fri, 25 Jul 2025 15:09:45 +0800

使用pdb调试Python脚本

在Python中脚本的语法错误可以被Python解释器发现，但是脚本逻辑上的错误，或者其他的一些变量使用错误却不容易被发现。

如果脚本运行后没有获得预想的结果，则需要对脚本进行调试。pdb模块是Python自带的调试模块。使用该模块可以为脚本设置

断点、单步执行、查看变量值等。pdb模块可以以命令行参数的形式启动，也可以通过import将其导入使用。

通过import导入pdb模块后，就可以使用pdb模块的函数对脚本进行调试。常用的pdb模块的函数可以分为以下几类。

运行语句

在Python中可以使用pdb模块的run函数来调试语句块。其参数原型如下所示。

run(statement[, globals[, locals]])

其参数如下。

statement: 要调试的语句块，以字符串的形式

globals: 可选参数，设置statement运行的全局环境变量

locals: 可选参数，设置statement运行的局部环境变量

以下实例使用run函数调试语句块。

import pdb
pdb.run('''
for i in range(0, 3):
 i = i ** 2
 print(i)
''')

运行后得到如下

> <string>(2)<module>()
(Pdb) n # "(Pdb)"为调试命令提示符，表示可以输入调试命令
> <string>(3)<module>()
(Pdb) n # 执行下一行
> <string>(4)<module>()
(Pdb) n
0
> <string>(2)<module>()
(Pdb) n
> <string>(3)<module>()
(Pdb) n
> <string>(4)<module>()
(Pdb) n
1
> <string>(2)<module>()
(Pdb) print(i) # print打印变量i值
1
(Pdb) continue # 继续运行程序
4

实力环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 自定义异常类

Fri, 25 Jul 2025 15:09:41 +0800

自定义异常类

在Python中可以通过继承Exception类来创建自己的异常类。异常类和其他的类并没有区别，一般仅有在

异常类中定义几个属性信息。

实例如下

class CustomError(Exception):
 def __init__(self, data): # 重载__init__方法
 self.data = data

 def __str__(self): # 重载__str__方法
 return self.data

raise CustomError, 'Error'

异常输出如下

 raise CustomError, 'Error'
__main__.CustomError: Error

try:
 raise CustomError, 'Raise CustomError'
except CustomError, data:
 print(data)
else:
 print('No Error')

输出如下

Raise CustomError

实例环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - assert - 简化的raise语句

Fri, 25 Jul 2025 15:09:38 +0800

assert - 简化的raise语句

在Python中使用assert语句同样可以引发异常。但与raise语句不同，assert语句是在条件测试为假时，

才引发异常。assert语句的一般形式如下：

assert <条件测试>, <异常附件数据> # 其中异常附加数据是可选的

实例如下

l = []

assert len(l) # 如果列表为空，则使用assert引发异常

异常抛出如下

 assert len(l)
AssertionError

assert len(l), 'Error'

异常输出如下

 assert len(l), 'Error'
AssertionError: Error

try:
 assert len(l), 'Error'
except:
 print('Error')
else:
 print('No Error')

输出如下

Error

l.append(1) # 向列表中添加成员
assert len(l) # 此时列表不为空，assert将不会引发异常

从上面的实例可以看出，assert相当于raise语句和if语句联合使用。

例如如下assert语句

assert len(l)

可以改写如下

if __debug__:
 if len(1):
 raise AssertionError, <附加数据>

需要注意的是，assert语句一般用于开发时对程序条件的验证。只有当内置__debug__为True时，assert语句才有效。

当Python脚本为-O选项编译成字节码文件时，assert语句将被移除。

实例环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 引发异常

Fri, 25 Jul 2025 15:09:35 +0800

引发异常

除了内置的异常意外，在Python中还可以通过使用raise语句引发异常。在类中也可以使用raise引发异常，

并向异常传递数据。使用raise可以定义新的错误类型，以适应脚本的需要。例如对用户输入数据的长度有要求，

则可以使用raise引发异常，以确保数据输入符合要求。

使用raise引发异常

使用raise引发异常十分简单，有以下几种形式

raise 异常

raise 异常名, 附加数据

raise 类名

以下实例使用try语句捕获由raise引发的异常。

raise BaseException

会得到如下异常输出

 raise BaseException
BaseException

try:
 raise BaseException, 'Raise an BaseException'
except BaseException, data:
 print(data)
else:
 print('No Error')

会得到如下输出

Raise an BaseException

def fun(n):
 if n == 0:
 raise BaseException, 'n in Zero'
 else:
 print(n)
try:
 fun(0)
except BaseException, data:
 print(data)

会得到如下输出

n in Zero

class A:
 def show(self):
 print('A')
try:
 raise A
except A:
 print('Error')
else:
 print('No Error')

会得到如下输出

Error

实例环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 多重异常处理

Fri, 25 Jul 2025 15:09:32 +0800

多重异常处理

在Python中可以在try语句中嵌套另外一个try语句。由于Python将try放在堆栈中，一旦引发异常，Python将匹配

最近的except语句。如果except能够处理异常，则外围的try语句将不再不会捕获异常。如果except忽略该异常，

则异常将被外围try语句捕获。

代码实例如下：

l = [1, 2] # 定义一个列表

try: # 嵌套try语句
 try:
 l[5]
 except: # 捕获所有异常
 print('Error1') # 打印Error1
except: # 捕获所有异常
 print('Error2') # 打印Error2
else:
 print('No Error')

输出结果如下

Error1
No Error

try:
 try:
 l[1] / 0
 except IndexError:
 print('Error1')
except:
 print('Error2')
else:
 print('No Error')

输出结果如下

Error2

try:
 try:
 l[1] / 's'
 except IndexError:
 print('Error1')
except ZeroDivisionError:
 print('Error2')
else:
 print('No Error')

运行代码后会遇到如下错误

TypeError: unsupported operand type(s) for /: 'int' and 'str'

实例环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 处理异常

Fri, 25 Jul 2025 15:09:27 +0800

处理异常

在except中可以捕获指定的异常。除此之外，except语句还可以捕获异常的附加数据。

Python中常用的内置异常如下

AttributeError 调用不存在的方法引发的异常

EOFError 遇到文件末尾引发的异常

ImportError 导入模块出错引发的异常

IndexError 列表越界引发的异常

IOError I/O操作引发的异常，如打开文件出错等

KeyError 使用字典中不存在的关键字引发的异常

NameError 使用不存在的变量名引发的异常

TabError 语句块缩进不正确引发的异常

ValueError 搜索列表中不存在的值引发的异常

ZeroDivisionError 除数为零引发的异常

except语句主要有以下几种用法。

except:
except <异常名>:
except (异常名1,异常名2):
except <异常名>, <数据>:
except (异常名1,异常名2), <数据>:

以下实例使用except捕获异常

l = [1, 2, 3]

try:
 l[5]
except IndexError, Error:
 print Error
else:
 print('No Error')

以下代码运行后会输出如下

list index out of range

try:
 l[5] / 0
except:
 print('Error')
else:
 print('No Error')

运行上段代码会输出如下内容

Error

try:
 l[2] / 0
except (IndexError, ZeroDivisionError), value:
 print(value)

运行上段代码会得到如下输出

integer division or modulo by zero

实例环境声明

# _*_ coding: utf-8 _*_
# Python 2.7.13

Python 入门基础知识 - 异常与调试

Fri, 25 Jul 2025 15:09:24 +0800

异常与调试

异常通常是脚本在运行过程中引发的错误。如果在脚本中未包含有关异常处理的代码，那么脚本将终止运行。

在Python中可以为脚本添加异常处理，以应对可能出现的错误，从而使脚本更’健壮’。

捕获异常

在脚本运行的过程中常见的异常有除零、下标越界等。在Python中可以捕获这些异常，并编写相关异常的处理语句。

使用try语句

在Python中可以使用try语句来处理异常。和Python中其他语句一样，try语句也要使用缩进结构。try语句也有

一个可选的else语句块。一般的try语句形式如下所示。

try:
 <语句> # 要进行捕捉的语句
except <异常名1>: # 要进行处理的语句
 <语句> # 对异常进行处理的语句
except <异常名2>: # 要进行处理的异常
 <语句> # 对异常进行处理的语句
else:
 <语句> # 如果异常未捕获，则执行该语句

执行过程如下

 |--- 引发异常1 ---> 异常1处理语句 ---
 | |
 | |
开始 ---> 其他语句 ---> try语句块|--- 未引发异常 ---> else语句块 ---> 其他语句 --->结束
 | |
 | |
 |--- 引发异常2 ---> 异常2处理语句 ---

try语句还有还有一种不包含except和else语句的特殊形式。其形式如下所示

try:
 <语句>
finally:
 <语句>

不管try语句块中是否发生异常，都将执行finally语句块。

实例演示如下：

l = [1, 2, 3]
print(l[5])

会遇到如下错误

IndexError: list index out of range

try:
 print(l[5])
except:
 print('Error')
else:
 print('No Error')

运行上面的代码会输出如下内容

Error

try:
 print(l[2])
except:
 print('Error')
else:
 print('No Error')

运行上面的代码会输出如下内容

3
No Error

try:
 l[2] / 0
except IndexError:
 print('Error')
else:
 print('No Error')

上面这段代码运行后会遇到如下错误

ZeroDivisionError: integer division or modulo by zero

try:
 l[2] / 0
except IndexError:
 print('IndexError')
except ZeroDivisionError:
 print('ZeroDivisionError')
else:
 print('No Error')

运行后会输出如下结果

ZeroDivisionError

try:
 print(l[2])
finally:
 print('A')

会输出如下

3
A

try:
 print(l[5])
finally:
 print('A')

会抛出异常并输出’A'

IndexError: list index out of range
A

实例环境声明

# _*_ coding: utf-8 _*_
#
# Python 2.7.13

Python 入门基础知识 - 模块中的类

Fri, 25 Jul 2025 15:09:20 +0800

模块中的类

类与函数一样，也可以写到模块中。在其他脚本中可以通过导入模块名使用定义的类。

模块中类的使用方式与模块中的函数类似。实际上可以将模块中的类当做函数一样使用。将上一篇文章中定义的LiseExample类整理后保存到ListExample中。

如下所示 :

# _*_ coding: utf-8 -*-
# Filename : ListExample.py

class ListExample:
 __list = []

 def __init__(self, *args):
 self.__list = []
 for arg in args:
 self.__list.append(arg)

 def __add__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] + n

 def __sub__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] - n

 def __mul__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] * n

 def __div__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] / n

 def __mod__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] % n

 def __pow__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] ** n

 def __len__(self):
 return len(self.__list)

 def show(self):
 print(self.__list)

然后在编写一个UseListExample.py的脚本，使用ListExample.py中的ListExample类。实例代码如下

# _*_ coding: utf-8 -*-
# 
# Filename: UseListExample.py

import ListExample

l = ListExample.ListExample(1, 2, 3, 4, 5)
l.show()

l + 10
l.show()

l * 2
l.show()

print(len(l))

l ** 3
l.show()

结果输出如下

# [1, 2, 3, 4, 5]
# [11, 12, 13, 14, 15]
# [22, 24, 26, 28, 30]
# 5
# [10648, 13824, 17576, 21952, 27000]

Python 入门基础知识 - 重载

Fri, 25 Jul 2025 15:09:16 +0800

重载

重载允许通过继承而创建的类重新定义父类的方法。不仅可以重载方法，而且还可以重载运算符，例如"+"、"*“等，

以适用自创建的类。

方法重载

通过继承而创建的类，其父类的方法不一定能满足类的需求。新类实际上只是修改部分功能，为了避免命名函数的麻烦，可以使用方法重载来解决。

或者，新类需要重新初始化，此时就可以重载__init__方法来实现。

方法的重载实际上就是在类中使用def关键字重载父类的方法。如果重载父类中的方法，但又需要在类中先使用父类的该方法，可以使用父类加”.“加方法名的形式调用。

例如重载”__init__“方法时，而父类也需要使用__init__方法，则可以在__init__前加上父类名来调用该方法。

如下实例演示

class human:
 __age = 0
 __sex = ''
 __height = ''
 __weight = ''
 name = ''

 def __init__(self, age, sex, height, weight):
 self.__age = age
 self.__sex = sex
 self.__height = height
 self.__weight = weight

 def setname(self, name):
 self.name = name

 def show(self):
 print(self.name)
 print(self.__age)
 print(self.__sex)
 print(self.__height)
 print(self.__weight)

class student(human):
 __classes = ''
 __grade = ''
 __num = 0

 def __init__(self, classes, grade, num, age, sex, height, weight):
 self.__classes = classes
 self.__grade = grade
 self.__num = num
 human.__init__(self, age, sex, height, weight)

 def show(self):
 human.show(self)
 print(self.__classes)
 print(self.__grade)
 print(self.__num)

a = student('小学', '大班', '20171128', 12, '男', 140, 40)
a.setname('John')
a.show()

输出结果如下

# John
# 12
# 男
# 140
# 40
# 小学
# 大班
# 20171128

运算符重载

在Python中运算符重载不需要像在C++中那样使用operator关键字。由于在Python中，运算符都有其相对应的函数。在类中，运算符对应类的专有方法。因此运算符的重载

实际上是对运算符对应的专有方法的重载。

部分运算符和类的专有方法对应表如下：

运算符|专有方法

| __add__

| __sub__

* | __mul__

/ | __div__

% | __mod__

** | __pow__

实例演示如下

class ListExample:
 __list = []

 def __init__(self, *args):
 self.__list = []
 for arg in args:
 self.__list.append(arg)

 def __add__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] + n

 def __sub__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] - n

 def __mul__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] * n

 def __div__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] / n

 def __mod__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] % n

 def __pow__(self, n):
 for i in range(0, len(self.__list)):
 self.__list[i] = self.__list[i] ** n

 def __len__(self):
 return len(self.__list)

 def show(self):
 print(self.__list)

l = ListExample(1, 2, 3, 4, 5)
l.show()
# [1, 2, 3, 4, 5]
l + 5
l.show()
# [6, 7, 8, 9, 10]
l - 3
l.show()
# [3, 4, 5, 6, 7]
l * 3
l.show()
# [9, 12, 15, 18, 21]
l / 3
l.show()
# [3, 4, 5, 6, 7]
l % 3
l.show()
# [0, 1, 2, 0, 1]
l ** 3
l.show()
# [0, 1, 8, 0, 1]
print(len(l))
# 5
b = ListExample(2, 3, 4, 5, 6, 7, 8)
b.show()
# [2, 3, 4, 5, 6, 7, 8]
b - 5
b.show()
# [-3, -2, -1, 0, 1, 2, 3]

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 类的继承

Fri, 25 Jul 2025 15:09:08 +0800

类的继承

一个新类可以通过继承来获得已有类的方法以及属性等。通过继承而来的类也可以自己定义新的方法或者属性。

通过创建继承类

在类的定义中已经提到如何通过继承来获得一个新类。新类可以继承公类的公有属性和公有方法，但是不能继承

父类的私有属性和私有方法。

实例如下：

class book:
 __author = ''
 __name = ''
 __page = 0
 price = 0
 __press = 0

 def __check(self, item):
 if item == '':
 return 0
 else:
 return 1

 def show(self):
 if self.__check(self.__author):
 print(self.__author)
 else:
 print('No Value')

 if self.__check(self.__name):
 print(self.__name)
 else:
 print('No Value')

 def setname(self, name):
 self.__name = name

 def __init__(self, author, name):
 self.__author = author
 self.__name = name

class student(book):
 __class = ''
 __grade = ''
 __sname = ''

 def showinfo(self):
 self.show()

b = student('John', 'A Great Book')
b.showinfo()
# John
# A Great Book

如果在定义类的时候，试图使用父类的私有属性或者私有方法将会导致错误，如下：

class student(book):

 def showall(self):
 if self.__check(self.__name):
 print(self.__name)
 else:
 print('No Value')

c = student('John', 'A Great Book')
# c.showall()
# 会遇到如下错误：
# AttributeError: student instance has no attribute '_student__check'

多重继承

多重继承是指创建的类同时拥有几个类的属性和方法。多重继承与单重继承不同的是在类名后边的圆括号中包含多个父类名，

父类名以逗号隔开。通过多重继承创建一个新类的一般形式如下所示：

class <新类名>(父类1，父类2，….，父类n):

<语句1>

<语句2>

…

<语句n>

使用多重继承需要注意圆括号中父类名字的顺序。如果父类中有相同的方法名，而在类中使用时未指定父类名，Python解释器

将从左到右搜索。示例如下：

class A:
 name = 'A'
 __num = 1
 def show(self):
 print(self.name)
 print(self.__num)
 def setnum(self, num):
 self.__num = num
class B:
 nameb = 'B'
 __numb = 2
 def show(self):
 print(self.nameb)
 print(self.__numb)
 def setname(self, name):
 self.nameb = name
class C(A, B):
 def showall(self):
 print(self.name)
 print(self.nameb)
c = C()
c.showall()
# A
# B

c.show()
# A
# 1

c.setnum(3)
c.show()
# A
# 3

c.setname('D')
c.showall()
# A
# D

如果需要在类C中使用类B的show方法，可以按如下实例操作：

class C(A, B):

 def showall(self):
 print(self.name)
 print(self.nameb)

 show = B.show

c = C()
c.show()
# B
# 2

实例环境如下

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 类的属性和方法

Fri, 25 Jul 2025 14:10:59 +0800

类的属性和方法

每一个类都有自己的属性和方法。属性和方法是面向对象程序设计所独有的概念。属性是类所封装的数据，而方法则是类对数据进行的操作。

类的属性

在上一篇文章中简单的定义和使用了类的属性。类的属性实际上是类内部的变量。上一篇文章的例子使用了类的属性，确切的说，称作类的

公有属性。在上篇文章中在类的外部设置了其属性的值，在某些情况下可能不希望在类的外部多其属性进行操作，此时就可以使用类的私有

属性。

数据保护是面向对象程序设计所特有的，在面向过程的程序设计中并没有数据保护的概念。在Python中与C++不同，在类的内部声明一个私有

成员不需要使用private关键字。在Python中，是通过类中属性的命名形式来表示类属性是公有还是私有的。类中的私有属性是不能在类的外部

进行操作的，这种方式起到了对属性的保护作用。

在Python中，如果类中的属性是以两条下划线开始的话，则该属性为类的私有属性，不能在类的外部被使用或者访问。

下面为一个私有属性的命名方式

__private_attre # 以双下划线开始

如果在类内部的方法中使用类的私有属性，则应该以如下的方式调用：

self.__private_attre # 应该在私有属性名钱加上"self."

实例如下：

class book:
 __author = ''
 __name = ''
 __page = 0
 price = 0
 __press = ''

a = book()
# a.__author # 调用属性 __author
# 会跑出如下异常信息
# AttributeError: book instance has no attribute '__author'

print(a.price)
# 0

a.price = 20
print(a.price)
# 20

# print(a.__name)
# 报错内容如下：
# AttributeError: book instance has no attribute '__name'

# print(a.__page)
# 报错内容如下：
# AttributeError: book instance has no attribute '__page'

可以看到，在类的定义的时候，凡是两条下划线开始的属性不能在类的外部访问，当然也不能修改。如果要修改类的私有属性值或者获取其值，

可以通过使用提供的方法来完成。

类的方法

类的方法实际上就是类内部使用def关键字定义的函数。定义类的方法与定义一个函数基本相同，在类的方法中同样也要使用缩进。

1、定义类的方法

在类的内部使用def关键字可以为类定义一个方法。与函数定义不同的是，类的方法必须包含函数"self"，且"self"必须为第一个参数。

实例如下：

class book:
 __author = ''
 __name = ''
 __page = 0
 price = 0
 __press = ''

 def show(self):
 print(self.__author)
 print(self.__name)

 def setname(self, name):
 self.__name = name

a = book()
a.show()
a.setname('John')
a.show() # 这里会输出"John"

与类的属性相同，类的方法也可以是类私有的，类的私有方法不能在类的外部调用。和类的私有属性命名相同，类的私有方法名也要

以两条下划线开始。类的私有方法只能在类的内部调用，而不能在类的外部调用。另外，在类的内部调用其私有方法，要使用"self.私有方法名"的形式。实例代码如下

class book:
 __author = ''
 __name = ''
 __page = 0
 price = 0
 __press = ''

 def __check(self, item):
 if item == '':
 return 0
 else:
 return 1

 def show(self):
 if self.__check(self.__author):
 print(self.__author)
 else:
 print('No value')

 if self.__check(self.__name):
 print(self.__name)
 else:
 print('No value')

 def setname(self, name):
 self.__name = name

a = book()
a.show()
a.setname('John')
a.show()
# a.__check() # 调用类的私有方法，结果出错
# 报错内容如下；
# AttributeError: book instance has no attribute '__check'

2、类的专有方法

在Python中有一类似以两条下划线开始并且以两条下划线结束的类的方法，称之为类的专有方法。专有方法是针对类的特殊操作。

例如，在类实例化时将调用__init__方法。部分类的专有方法如下：

__init__ 构造函数，生成对象时调用

__del__ 析构函数，释放对象时调用

__add__ 加运算

__mul__ 乘运算

__cmp__ 比较运算

__repr__ 打印、转换

__setitem__ 按照索引赋值

__getitem__ 按照索引获取值

__len__ 获得长度

__call__ 函数调用

实例演示如下：

class book:
 __author = ''
 __name = ''
 __page = 0
 price = 0
 __press = ''

 def __check(self, item):
 if item == '':
 return 0
 else:
 return 1

 def show(self):
 if self.__check(self.__author):
 print(self.__author)
 else:
 print('No value')

 if self.__check(self.__name):
 print(self.__name)
 else:
 print('No value')

 def setname(self, name):
 self.__name = name

 def __init__(self, author, name):
 self.__author = author
 self.__name = name

a = book('John', 'I like this book')
a.show()
# John
# I like this book
a.setname('About John')
a.show()
# John
# About John

实例环境声明：

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 类的基础

Fri, 25 Jul 2025 14:10:56 +0800

类的基础

由于Python面向对象程序设计的良好支持，在Python中定义和使用类并不复杂。类的定义和使用与函数的定义和使用有很多相似的地方。

类的定义

在Python中类的定义与函数的定义类似，不同的是，类的定义使用关键字"class"。与函数定义相同。在定义类的时候也要使用缩进以

表示缩进的语句属于该类。一般的类的定义形式如下所示：

class <类名>:

<语句1>

<语句2>

…

<语句3>

与函数定义一样，在使用类之前必须先定义类。类的定义一般放在脚本的头部。在Python中也可以在if语句的分之中或者函数定义中定义类。

以下实例定义一个human类，并定义了相关属性。

class human:
 age = 0
 sex = ''
 height = ''
 weight = ''
 name = ''

类还可以通过继承的形式获得。通过类继承来定义类的基本形式如下所示。

class <类名>(父类名):

<语句1>

<语句2>

…

<语句3>

其中园括号中的父类名就是要继承的类。关于继承将在后面的文章介绍，此处给出一个简单的实例，实例如下：

class student(human):
 school = ''
 number = ''
 garde = ''

上述通过human继承而来的student类具有human类的属性，并且又为student类定义了其他的属性。

类定义后就产生了一个名字空间，与函数类似。在类内部使用的属性，相当于函数的变量名，还可以在类的外部继续使用。

类的内部与函数的内部一样，相当于一个局部作用域。不同类的内部也可以使用相同的属性名。

类的使用

类在定义后必须先实例化才能使用。类的实例化与函数调用类似，只要使用类名加圆括号的形式就可以实例化一个类。类

实例话以后会生成一个对象。一个类可以实例化多个对象，对象与对象之间并不相互影响。类实例化以后可以使用其属性和

方法等。以下实例首先定义一个book类，然后将其实例化。

class book:
 author = ''
 name = ''
 pages = 0
 price = 0
 press = ''

a = book()
print(a)
# <__main__.book instance at 0x10769fef0>

print(a.author)
print(a.pages)
print(a.price)
a.author = 'John'
a.pages = 300
a.price = 25
print(a.author)
print(a.pages)
print(a.price)
# # 空字符串
# 0
# 0
# John
# 300
# 25

b = book()
print(b)
# <__main__.book instance at 0x105c7de18>

print(b.author)
print(b.price)
b.author = 'Json'
b.price = 10
print(b.author)
print(b.price)
print(a.price) # a对象的price属性并没有改变
print(a.author) # a对象的author属性也没有改变
print(b.pages) # 访问b对象的pages属性
print(a.pages) # 访问a对象的pages属性
# # 空字符串
# 0
# Json
# 10
# 25
# John
# 0
# 300

上述例子只定义了类的属性，并在类实例化以后重新设置其属性，从上例可以看出类的实例化相当于调用一个函数，这个函数就是类。

函数返回一个类的实例对象，返回后的对象就具有了类所定义的属性。上述例子生成了两个book实例对象，可以看到，设置其中一个

对象的属性，并不影响另一个对象的属性。

在Python中需要注意的是，虽然类首先需要实例化，然后才能使用其属性。而实际上当创建一个类以后就可以通过类名访问其属性。

如果直接使用类名修改器属性，那么将影响已经实例化的对象。

class A:
 name = 'A'
 num = 2

print(A.name)
print(A.num)
# A
# 2

a = A()
print(a.name)
# A

b = A() # 生成b对象
print(b.name) # 查看b的name属性
# A

A.name = 'B' # 使用类名修改name属性

print(a.name) # a对象的name属性被修改
print(b.name) # b对象的name属性被修改

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 面向对象的Python

Fri, 25 Jul 2025 14:10:53 +0800

面向对象的Python

Python是一种面向对象的编程语言，但是Python和C++一样，还支持面向过程的程序设计。在Python中完全可以使用函数、模块等方式来完成工作。

但是在使用Python完成一个很庞大的项目时，则应该考虑使用面向对象的方法，以便更好的对项目进行管理。

概述

面向对象程序设计简称为OOP，是与面向过程的程序设计不同的另一类变成架构。之前的文章大都是面向过程的，而非面向对象的。

Python中的面向对象的思想

面向对象程序设计是从20世纪90年代开始流行起来的一种变成方法，强调对象的"抽象"、“封装”、“继承”、“多态”。面向对象程序设计方法的基本思想是将

任何事物当做对象，是其所属对象类的一个实例。对于复杂的对象则将其划分成简单对象，由这些简单的对象以某种方式组合而形成复杂的对象。每一个对象都有

其相对应的对象类。属于同一个对象类的对象具有相同的属性以及操作方法等。

对象以对象类的形式将其内部的数据或者方法封装。对象与对象之间只有相互传递数据，而不能访问其他对象的内部。对象的内部相对于其他对象来说是不可见的。

不同的对象类之间可以通过继承的形式来拥有其他对象的属性和方式等，而形成父子关系。面向对象程序设计方法的基本过程如下。

（1）确定对象及其属性和方法等。

（2）分析对象之间的联系确定其通信机制。

（3）将具有共同特征的对象抽象为对象类。

（4）设计、实现类，并确定类相互间的继承关系。

（5）创建对象实例，实现对象间的相互关系。

例如，可以将人作为一个对象类。每一个具体的人，如张三，则是一个对象实例。每个人都具有名字、性别、年龄、身高等，则可以将这些抽象为对象类的属性。

Python完全采用了面向对象程序设计的思想。在Python中可以使用类建立一个对象模型，以及对象所拥有的属性和方法等。该模型能够较好的反应事物的本质，

以及其相互之间的关系，其本质是更接近于人类认知事物所采用的计算模型。

Python脚本是真正面向对象的脚本语言，虽然其与C++的类机制有所区别，但Python保证对类的最重要功能的支持，例如类的继承、基类的重载等。

在Python中，对象概念比较广泛，对象不一定非得是类的实例。Python的内置数据类型如字符串、列表、字典等，他们都不是类，但却多少具有类相似的语法。

例如，使用".“操作符来使用内置类型的某些方法。

类和对象

类是面向对象程序设计的基础。类具有抽象性、封装性、继承性和多态性。

类的抽象性是指类是对具有共同方法和属性的一类对象的描述。

类的封装性是指类将属性和方法封装，对于外部其实不可见的，只有通过类提供的接口才能与属于类的实例对象进行信息交换。

类的继承性是指类可以由已有的类派生。派生出来的类拥有父类的方法和属性等。

类的多态性是指类可以根据不同的参数类型调用不同的方法。同一个方法可以处理不同类型的参数。实际上Python的内部已经很好的实现了多态。在Python中

使用类不需要考虑太多不同类型数据之间的处理。

每个类都具有自己的属性和方法。类的属性实际上就是类内部的变量。而类的方法，则是在类内部定义的函数。

对象是具体的函数，是实例化的类。每个对象的属性值可能不一样，但所有由同一类实例化得来的对象都拥有共同的属性和方法。在程序中由类实例化生成对象，

然后使用对象的方法进行操作，完成任务。一个类可以实例化成多个对象。类与对象的关系如下

对象1<----|
对象2<----| 实例化
 |<=========类
对象3<----|
对象4<----|

Python 入门基础知识 - 使用正则表达式处理文件

Fri, 25 Jul 2025 14:10:50 +0800

使用正则表达式处理文件

正则表达式是处理文本文件的强有力的工具。

下面演示一个获取Python文件中所有函数跟变量的实例

在Python脚本中，函数定义是以"def"开头，因此处理函数的过程相当简单。为了代码简洁，此处假设脚本编写规范"def"后跟一个空格，

然后是函数名，接着就是函数。没有考虑使用多个空格的情况。

而Python脚本中的变量不好处理，因为变量一般不需要事先声明，而是直接赋值，因此脚本中首先处理了变量直接赋值的情况。

通过匹配单词后接"=“的情况查找变量名。同样，为了代码简洁，仅考虑比较规范整洁的代码写法，变量名与”=“之间有一空格。

另外，还有一类变量是在for循环语句中直接使用的，因此脚本中又特别处理了for循环的情况。为了使代码简洁，脚本并没有

处理变量名重复的情况。整个脚本的代码如下所示。

# _*_ coding: utf-8 -*-
# File: test.py
import re
import sys

def deal_with_func(s):
 r = re.compile(r'''
 (?<=def\s) # 前边必须含有def且def后跟一个空格
 \w+ # 匹配函数名
 \(.*?\) # 匹配参数
 (?=:) # 后边必须跟一个:
 ''', re.X) # 设置编译选项，忽略模式中的注释
 return r.findall(s)

def deal_with_var(s):
 vars = [] # 定义一个列表，因为这里分两种情况处理
 r = re.compile(r'''
 \b # 匹配单词开始
 \w+ # 匹配变量名
 (?=\s=) # 处理未给变量赋值的情况
 ''', re.X)
 vars.extend(r.findall(s))

 r = re.compile(r'''
 (?<=for\s) # 处理变量位于for语句中的情况
 \w+ # 匹配变量名
 \s # 匹配空格
 (?=in) # 匹配in
 ''', re.X) # 设置编译选项，忽略模式中的注释

 vars.extend(r.findall(s))

 return vars

# 判断命令行是否有输入，没有则要求输入
if len(sys.argv) == 1:
 sour = raw_input('请输出要处理的文件路径:')
else:
 sour = sys.argv[1]

file = open(sour)
s = file.readlines()
file.close()
print('**********************************')
print('%s 中的函数有：' % sour)
print('**********************************')
i = 0
for line in s:
 i = i + 1
 function = deal_with_func(line)
 if len(function) == 1:
 print('Line: %i \t %s' % (i, function[0]))

i = 0
for line in s:
 i = i + 1
 var = deal_with_var(line)
 if var and len(var) == 1:
 print('Line: %i \t %s' % (i, var[0]))

比如运行此脚本后输入：test.py

得到的结果如下：

请输出要处理的文件路径:test.py
**********************************
base_practise.py 中的函数有：
**********************************
Line: 20 	 deal_with_func(s)
Line: 30 	 deal_with_var(s)
Line: 21 	 r
Line: 31 	 vars
Line: 32 	 r
Line: 39 	 r
Line: 53 	 sour
Line: 55 	 sour
Line: 57 	 file
Line: 58 	 s
Line: 63 	 i
Line: 64 	 line
Line: 65 	 i
Line: 66 	 function
Line: 70 	 i
Line: 71 	 line
Line: 72 	 i
Line: 73 	 var

Python 入门基础知识 - 正则表达式 - Match对象

Fri, 25 Jul 2025 14:10:46 +0800

Match对象

Match对象实例是有正则表达式对象的match()，以及search()方法在匹配成功后返回的。Match对象有以下常用的方法和属性，

用于对匹配成功的正则表达式进行处理。

使用Match对象处理组

group(),groups()和groupdict()方法都是处理在正则表达式中使用"()“分组的情况。不同的是，group的返回值为字符串，

当传递多个参数时其返回值为元组。groups()的返回值为元组。groupdict()的返回值为字典。

原型分别如下

group([group1, …])

groups([default])

groupdict([default])

对于group()而言，其参数为分组的编号。如果向group()传递多个参数，则其返回各个参数所对应的字符串组成的元组。对于groups()和

groupdict()一般不需要向其传递参数。

示例演示如下：

import re
s = '''Life can be dreams,
Life can be great thoughts;
Life can mean a person,
Sitting in a count.'''
r = re.compile('\\b(?P<first>\w+)a(\w+)\\b') # 编译正则表达式，匹配所有包含字母'a'的单词
m = r.search(s) # c从头开始搜索，search()返回搜索到的第一个单词
print(m)
# <_sre.SRE_Match object at 0x100af58b0>

print(m.groupdict())
# {'first': 'c'}

print(m.groups())
# ('c', 'n')

m = r.search(s, 9) # 从第十个字符开始搜索
print(m.group())
# dreams

print(m.group(1))
# dre

print(m.group(2))
# ms

print(m.group(1, 2))
# ('dre', 'ms')

print(m.groupdict())
# {'first': 'dre'}

print(m.groups())
# ('dre', 'ms')

使用Match对象处理索引

start()、end()以及span()方法返回所匹配的子字符串的索引。

原型如下

start([groupid=0])

end([groupid=0])

span([groupid=0])

参数含义

groupid: 为可选参数，即分组编号。

如果不传递参数，则返回整个字符串的索引。

start()方法返回子字符串或者组的起始位置索引。

end()方法返回子字符串或者组的结束位置索引。

而span()方法则以元组的形式返回以上两者。

使用方法如下

import re
s = '''Life can be dreams,
Life can be great thoughts;
Life can mean a person,
Sitting in a court.'''
r = re.compile('\\b(?P<first>\w+)a(\w+)\\b') # 编译正则表达式匹配含有字母"a"的单词
m = r.search(s, 9) # 从第十个字符开始搜索
print(m.start()) # 输出匹配到的子字符串的起始位置
# 12

print(m.start(1)) # 输出第一组的起始位置
# 12

print(m.start(2)) # 输出第二组的起始位置
# 16

print(m.end(1)) # 输出第一组的子字符串结束位置
# 15

print(m.end()) # 输出子字符串的结束位置
# 18

print(m.span()) # 输出子字符串的开始和结束的位置
# (12, 18)

print(m.span(2)) # 输出第二组子字符串的开始和结束的位置
# (16, 18)

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python 入门基础知识 - 正则表达式 - 使用组

Fri, 25 Jul 2025 14:10:43 +0800

使用组

组允许将正则表达式分解成几个不同的组成部分。在完成匹配和搜索后，可以使用元组编号访问不同部分匹配的内容。

组概述

在正则表达式中以一对圆括号"()“来表示位于其中的内容属于一个组。

例如”(re)+“将匹配"rere”,“rerere"等多个"re"重复的情况。组在匹配由不同部分组成的一个整体时非常有用。

如电话号码由区号和号码组成，在正则表达式中可以使用两组来进行匹配：一组匹配区号，另外一组匹配后边的号码。

实例演示如下

import re
s = 'Phone No. 010-9876543'
r = re.compile(r'(\d+)-(\d+)')
m = r.search(s)
print(m)
# <_sre.SRE_Match object at 0x1059838b0>

print(m.group(1))
# 010

print(m.group(2))
# 9876543

print(m.groups())
# ('010', '9876543')

在正则表达式中可以通过使用”(?P<组名>)“为组设置一个名字，通过使用如下所示模式，将第一个组的名字设置为"Area”，将第二组的名字设置为"No"。

import re
s = 'Phone No. 010-9876543'
r = re.compile(r'(?P<Area>\d+)-(?P<No>\d+)')
m = r.search(s)
print(m.groups())
# ('010', '9876543')

print(m.group(1))
# 010

print(m.group(2))
# 9876543

print(m.groupdict())
# {'Area': '010', 'No': '9876543'}

print(m.group('Area'))
# 010

print(m.group('No'))
# 9876543

组的扩展语法

除了在组中使用"?P<组名>“来命名组名以外，还可以使用以下集中以”?“开头的扩展语法

(?iLmsux) 设置匹配标志，可以是i、L、m、s、u、x以及它们的组合。其含义与编译标志相同。

(?:…) 表示此非一个组

(?P=name) 表示在此之前的名为name的组

(?#…) 表示注释

(?=…) 用于正则表达式之后，表示如果”=“后的内容在字符串中出现则匹配，但不返回”=“后的内容

(?!…) 用于正则表达式之后，表示如果”!“后的内容在字符串中不出现则匹配，但不返回”!“后的内容

(?<=…) 用于正则表达式之前，与(?=…)含义相同

(?<!…) 用于正则表达式之前，与(?!…)含义相同

实例演示如下

import re
s = '''Life can be good;
Life can be bad;
Life is mostly cheerful;
But sometimes sad.
'''
r = re.compile(r'be(?=\sgood)') # 编译正则表达式，只匹配其后单词为'good'的'be'
m = r.search(s)
print(m)
# <_sre.SRE_Match object at 0x10625e850>

print(m.span()) # 输出匹配到的单词在字符串的位置
# (9, 11)

print(r.findall(s))
# ['be']

r = re.compile('be')
print(r.findall(s))
# ['be', 'be']

r = re.compile(r'be(?!\sgood)') # 重新编译，匹配之后的单词不为'good'的'be'
m = r.search(s)
print(m)
# <_sre.SRE_Match object at 0x1007c6238>

print(m.span())
# (27, 29)

r = re.compile(r'(?:can\s)be(\sgood)') # 使用组来匹配'be good'
m = r.search(s)
print(m)
# <_sre.SRE_Match object at 0x1055b1648>

print(m.groups())
# (' good',)

print(m.group(1))
# good # good前面是有空格的哦

r = re.compile(r'(?P<first>\w)(?P=first)') # 使用组名重复，此处匹配具有两个重复字母的单词
print(r.findall(s))
# ['o', 'e']

r = re.compile(r'(?<=can\s)b\w*\b') # 匹配以字母'b'开头位于'can'之后的单词
print(r.findall(s))
# ['be', 'be']

r = re.compile(r'(?<!can\s)b\w*\b') # 匹配以字母'b'开头不位于'can'之后的单词
print(r.findall(s))
# ['bad']

r = re.compile(r'(?<!can\s)(?i)b\w*\b') # 重新编译，忽略大小写
print(r.findall(s))
# ['bad', 'But']

实例环境声明

# _*_ coding: utf-8 -*-
# version 2.7.13

Python on Dapeng Zhang

fabric 2.5.0添加类似env配置文件，减少执行命令重复操作

Python小技巧 - 下载抓取小视频

采集/下载小视频

知识点汇总

Python技巧 - Python多线程爬虫

Python技巧 - 制作抖音引流脚本

Python 技巧 - 抓取页面并保存为PDF

Python 3.9.0 小知识 - PEP 616：移除前缀和后缀的字符串方法

Python全栈开发与人工智能 - 学习指南

Python 3.9.0 小知识 - PEP 585：标准多项集中的类型标注泛型

Python小技巧 - Lambda函数

Python 3.9.0 小知识 - PEP584：增加字典合并操作符

Python 3.9.0 正式发布

Python小知识 - dis字节码反汇编器

Python小知识 - classmethod、staticmethod和正常方法的区别

python http web server 探索（十二）

python http web server 探索（十一）

python http web server 探索（十）

python http web server 探索（九）

python http web server 探索（八）

python http web server 探索（七）

python http web server 探索（六）

python http web server 探索（五）

python http web server 探索（四）

python http web server 探索（三）

Python小知识 - 装饰器

python http web server 探索（二）

python http web server 探索（一）

Python asyncio协程 - 简单等待（二）

Python asyncio协程 - 简单等待（一）

Python asyncio协程 - 超时

屏蔽取消

超时（Timeouts）

Python 3.9.0rc2现在可以开测了

Python asyncio协程 - gather(5)

如果 aws 序列中的任一 Task 或 Future 对象 被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用 不会 被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

Python asyncio协程 - gather(4)

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会 被取消。

Python asyncio协程 - gather(3)

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象 不会被取消 并将继续运行。

如果 return_exceptions 为 True，异常会和成功的结果一样处理，并聚合至结果列表。

Python asyncio协程 - gather(2)

如果所有可等待对象都成功完成，结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。

Python asyncio协程 - gather(1)

如果 aws 中的某个可等待对象为协程，它将自动作为一个任务加入日程。

Python小技巧 - List不带索引可以做哪些有趣的事情

Python小技巧 - f-strings格式化字符串

Python小技巧 - Python 类型注释

Python小技巧 - Python内置 HTTP server

Python小技巧 - first-class 功能

Python小技巧 - timeit计算代码片段的耗时

Python小技巧 - pip源管理

Python小知识 - “is” 与 “==” 的区别

Python小知识 - Python中的函数的几个特点

Python小技巧 - 函数参数解压

flask使用sqlalchemy实现一个group by并且order by的查询

Python小知识 - asyncio之sleep和gather

Python 3 小知识 - asyncio writable

Coroutines

Tasks

Futures

Python小技巧 - 如何让字典参数值输出更加易读

Python小技巧 - Fabric并发执行远程主机操作

Python小知识 - import this

Python小技巧 - 字典中如何使用get()方法

Python小知识 - asyncio使用记录（1）

Python小知识 - 什么是Namedtuples，如何使用Namedtuples

Python小技巧 - 如何整合两个字典

什么是迭代器，什么是生成器（generator）

迭代器

如何创建迭代器

生成器

Fabric 并发方式执行项目部署命令

Python小技巧 - 如何根据字典中的值来排序字典

第一种按照值来排序的方式

第二种按照值来排序的方式

Python小技巧 - 使用不同的方式同时测试多个标记

Python的List Comprehension(列表推导式)

Python小知识 - Python的PSF是什么

如果 aws 序列中的任一 Task 或 Future 对象被取消，它将被当作引发了 CancelledError 一样处理 – 在此情况下 gather() 调用不会被取消。这是为了防止一个已提交的 Task/Future 被取消导致其他 Tasks/Future 也被取消。

如果 gather() 被取消，所有被提交 (尚未完成) 的可等待对象也会被取消。

如果 return_exceptions 为 False (默认)，所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象不会被取消并将继续运行。

为了防止安装virtualenv时`sudo /usr/local/bin/pip install virtualenv`遇到如下错误