可转债交易策略 — Python 量化投资实战教程(10)

以下内容仅供参考学习,不构成投资意见。

可转债,是一种具有中国特色的、受到国家管理和保护的债券,之所以说它很有特色,是因为它身上具备了两种闪闪发光的特性:

1.债性 — 安全保本

可转债本质上是一种公司的债券,也就是我们生活中所说的“欠条”,每张“欠条”的价值是100块钱。

如果你持有一张可转债,它就代表着上市公司欠你100块钱,而且未来必须偿还这笔钱并附带利息。截止到目前,所有上市的可转债,都完成了保本的使命。

也就是说,如果你在转债价格低于100元的时候买入,此时就是保本的。而且公司在赎回时,会付你一定的利息,所以当你在可转债价格低于100元的时候买入,就是保本保利的。

2.股性(可转换) — 存在套利空间

可转债是一张可转换为股票的公司债券。比如目前 晨光转债 转股价为 12.25 元,100/12.25=8.16,那么一张晨光转债会被取证转为8股晨光生物,其余的尾数会被转换为证券账户资金。

目前晨光生物正股16.10元,转换后,你相当于获得了8*16.10=128.8元的股票,加上刚刚尾数补充的账户资金,转股后你相当于获得了131.43元,131.43元被称为转股价值。

也就是说,如果你在前一天收盘前买入了1张晨光转债,并在当前转换为股票,第二天你会获得价值为131.43元的股票+证券账户资金。目前晨光转债的价格为 130.2 元,净利0.93%,但这个套利逻辑有个大前提:第二天开盘股价不会跌,如果跌了,你就拿不到这么多的价值,甚至有可能亏本。

下面本文要研究和利用的,不是可转债的股性,而是可转债的债性。

就如前面所说的,如果你买入100元以下的可转债,除非公司老板带着小姨子跑路,否则都是保本的。于是就有了下面这个自动交易的逻辑:

对于100元以下的可转债,触发某种上涨信号时,买入。上涨0.5%则卖出。如果下跌则一直持有。

上涨就赚了,下跌的话长期持有也不亏,利用可转债的债性及T+0交易的特性实行日内高频率交易就是这个策略的主要逻辑。

1.准备

开始之前,你要确保Python和pip已经成功安装在电脑上,如果没有,请访问这篇文章:超详细Python安装指南 进行安装。

(可选1) 如果你用Python的目的是数据分析,可以直接安装Anaconda:Python数据分析与挖掘好帮手—Anaconda,它内置了Python和pip.

(可选2) 此外,推荐大家用VSCode编辑器来编写小型Python项目:Python 编程的最好搭档—VSCode 详细指南

Windows环境下打开Cmd(开始—运行—CMD),苹果系统环境下请打开Terminal(command+空格输入Terminal),输入命令安装依赖:

在终端输入以下命令安装我们所需要的依赖模块:

pip install backtrader
pip install easytrader

看到 Successfully installed xxx 则说明安装成功。

某些券商在登录的时候可能需要识别验证码,这时候需要下载tesseract

1.下载并安装tesseract

前往 tesseract-ocr 官网下载二进制包,此外你也可以在Python实用宝典公众号后台回复: 量化投资10,直接获得本文源代码和tesseract的安装包。

双击下载下来的安装包,然后傻瓜式安装就可以,这里只需要注意一点:安装过程中有一个让你选择 Additional language data(download) 表示选择的话帮你下载语言包,这里最好不要选择勾选,因为勾选的话,安装过程非常慢,本教程只需要用到数字和英文识别而已。

2.配置环境变量

右击我的电脑/计算机,选择属性,然后选择高级属性设置,选择环境变量,在系统变量的path变量中添加你的 tesseract 目录就可以了

3.判断是否安装成功

在命令行中输入:

tesseract --version

出现下面的提示说明安装成功:

2.回测

按照这个策略的逻辑,回测的目的不在于探讨是否会亏损,而在于最高能赚多少。

为什么不需要探讨亏损?因为实际上即便我们买入80元的广汇转债,一直持有,3年后它以100元的价格赎回,我们的3年收益都达到了20%,平均年化率达6.67%。

当然,风险是有的,广汇老板如果带着小姨子跑路了,那你的转债可能一文不值,但是目前还没有出现过这种情况,因为如果出现了这种情况,将出现严重的信用危机,监管部门不可能允许这种情况发生。

回测的主要目的在于:怎样进行自动化交易,能最大化我们的收益。

关于编写策略的方法我们前面九篇系列文章都讲的很清楚了,这里就不再赘述,这里只重点研究买入的逻辑。

2.1 基于分钟K线的Sma金叉策略

这是最简单的策略,如果sma5和sma10实现金叉,则买入债券。涨0.5%则卖出,否则不动。

部分代码如下:

    def golden(self, a, b):
        if a[-1] - b[-1] < 0 and a[0] - b[0] > 0:
            return True
        else:
            return False

    def next(self):
        if self.order:
            return

        if not self.position:
            if self.golden(self.sma5, self.sma10):
                self.order = self.buy()
                self.params.buydays.append(self.datas[0].datetime.date(0))

        else:
            condition = (self.dataclose[0] - self.bar_executed_close) / self.bar_executed_close
            if condition > 0.005:
                self.order = self.sell()
                self.dead = False
                self.params.selldays.append(self.datas[0].datetime.date(0))
                self.params.hold_days.append((self.params.selldays[-1] - self.params.buydays[-1]).days)
                if self.params.buydays[-1] != self.params.selldays[-1]:
                    days = get_every_day(self.params.buydays[-1], self.params.selldays[-1])
                    for day in days:
                        self.params.hold_count[day] += 1

随机抽取了15只低价债券,回测了 2020-9-15 至 2020-11-8 之间的走势,一共交易了59次,每次买入50股。

可以看到每次交易的平均持有日期为4天,这是平均值,如果你看中位数会更大,有些交易可能连续持有了30天,有些可能当天买入当天卖出,两极分化比较大。

不过即便这样,按平均每次收益0.5%、平均每支债券价格为80元的情况来看, 59次交易*0.005*80*50股 = 1180元,如果可转债每次交易的平均手续费是1元,那么除去手续费 1180-2*59=1062元。看起来是一笔可观的羊毛,但是你必须忍受有部分资金被套牢在一些低价转债的情况。

2.2 基于分钟K线的EMA金叉的策略

接下来我们测试一下使用EMA均线的效果,这里选择的是ema(12)和ema(50):

    def golden(self, a, b):
        if a[-1] - b[-1] < 0 and a[0] - b[0] > 0:
            return True
        else:
            return False

    def next(self):
        if self.order:
            return

        if not self.position:
            if self.golden(self.exp1, self.exp2):
                self.order = self.buy()
                self.params.buydays.append(self.datas[0].datetime.date(0))

        else:
            condition = (self.dataclose[0] - self.bar_executed_close) / self.bar_executed_close
            if condition > 0.005:
                self.order = self.sell()
                self.dead = False
                self.params.selldays.append(self.datas[0].datetime.date(0))
                self.params.hold_days.append((self.params.selldays[-1] - self.params.buydays[-1]).days)
                if self.params.buydays[-1] != self.params.selldays[-1]:
                    days = get_every_day(self.params.buydays[-1], self.params.selldays[-1])
                    for day in days:
                        self.params.hold_count[day] += 1

效果如下:

交易次数相对于sma策略少了14次,所以收益肯定也会下降。平均持有日期达到了5.4天,相比于sma策略也有所提高。因此ema在我们的整个策略逻辑里表现地比sma策略稍差一些。

上面展示了两种策略在我们的低价转债投资逻辑里的应用和分析,由于篇幅关系这里就不再展示一些其他策略的回测结果,大家有兴趣可以自己试一下。

3.自动交易

使用easytrader模块,可以简单实现一个单进程的自动交易程序。

对于本策略而言单进程的自动交易程序也够了,因为这个策略要求的实时性并不是很高。

由于这部分代码无法脱敏,因此不能进行深入地讲解。逻辑并不难,每分钟对指定的股票进行监控,当其符合相关策略时进行买入或卖出,下面进行简单的讲解。

1.读取今日需检测的股票

在一天开始交易之前,需要获取今日所符合条件的低价可转债:

def start():
    account = Account()
    codes = read_today_codes()
    logger.info(f"总股票数 {len(codes)}")
    last_ping_time = datetime.datetime.now().timestamp()

2.巡检

在交易时间里,循环检测可转债是否符合买入策略

    while True:
        # 是否在交易时间
        if not check_time():
            continue
        for code in codes:
            now = int(datetime.datetime.now().timestamp())
            logger.info(f"{now} - {code}")
            try:
                # TODO: 异步执行算法
                buy_dict = algorithm(code)
                if not buy_dict:
                    continue
                logger.info(buy_dict)
                buy_time = list(buy_dict.keys())[0]
                buy_value = list(buy_dict.values())[0]

                if abs(int(buy_time.timestamp()) - now) < 300:
                    logic(account, code, buy_time, buy_value)

            except Exception as e:
                traceback.print_exc()
                logger.info(e)
                # send_mail(f"算法解析失败: {traceback.print_exc()}", "WRONG", code)

如果符合买入规则,在logic函数内,便会对可转债发布买单,同时挂一个0.5%利润的卖单。

3.卖单兜底

理想化情况下,在你挂了买单后立马成交,此时顺利挂出卖单。

不理想情况下,在你挂了买单后,几分钟后才成交,出现这种异步的情况后,卖单无法顺利挂出。

所以我们需要有一个兜底的措施:

        now = datetime.datetime.now()
        new_ping_time = now.timestamp()
        if new_ping_time - last_ping_time > 15:
            # 大于15秒,检测持仓,把未委托卖出的单子委托卖出
            account.every_day_sell()
        last_ping_time = new_ping_time
        logger.info(f"{datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S')} ping")

每次巡检任务都检查持仓,如果存在未挂出卖单的可转债,则按成本价+0.5%的利润挂出卖单。这样保证没有漏掉的可转债。

上述只是简单的几个步骤,实现上你会还有许多细节需要考虑,大家可以自己尝试实现一个这样的自动交易流程。

欢迎在公众号后台回复:加群,回答相应红字验证信息,进入互助群交流。

我们的文章到此就结束啦,如果你喜欢今天的Python 实战教程,请持续关注Python实用宝典。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!


​Python实用宝典 (pythondict.com)
不只是一个宝典
欢迎关注公众号:Python实用宝典

数据分析实战教程|Pandas处理数据太慢,来试试Polars吧!

很多人在学习数据分析的时候,肯定都会用到Pandas这个库,非常的实用!

从创建数据到读取各种格式的文件(text、csv、json),或者对数据进行切片和分割组合多个数据源,Pandas都能够很好的满足。

Pandas最初发布于2008年,使用Python、Cython和C编写的。是一个超级强大、快速易于使用的Python库,用于数据分析和处理。

当然Pandas也是有不足之处的,比如不具备多处理器,处理较大的数据集速度很慢。

今天,小F就给大家介绍一个新兴的Python库——Polars。

使用语法和Pandas差不多,处理数据的速度却比Pandas快了不少。

一个是大熊猫,一个是北极熊~

GitHub地址:https://github.com/ritchie46/polars

使用文档:https://ritchie46.github.io/polars-book/

Polars是通过Rust编写的一个库,Polars的内存模型是基于Apache Arrow。

Polars存在两种API,一种是Eager API,另一种则是Lazy API。

其中Eager API和Pandas的使用类似,语法差不太多,立即执行就能产生结果。

而Lazy API就像Spark,首先将查询转换为逻辑计划,然后对计划进行重组优化,以减少执行时间和内存使用。

安装Polars,使用百度pip源。

# 安装polars
pip install polars -i https://mirror.baidu.com/pypi/simple/

安装成功后,开始测试,比较Pandas和Polars处理数据的情况。

使用某网站注册用户的用户名数据进行分析,包含约2600万个用户名的CSV文件。

import pandas as pd

df = pd.read_csv(‘users.csv’)
print(df)

数据情况如下。

此外还使用了一个自己创建的CSV文件,用以数据整合测试。

import pandas as pd

df = pd.read_csv(‘fake_user.csv’)
print(df)

得到结果如下。

首先比较一下两个库的排序算法耗时。

import timeit
import pandas as pd

start = timeit.default_timer()

df = pd.read_csv(‘users.csv’)
df.sort_values(‘n’, ascending=False)
stop = timeit.default_timer()

print(‘Time: ‘, stop – start)

————————-
Time:  27.555776743218303

可以看到使用Pandas对数据进行排序,花费了大约28s。

import timeit
import polars as pl

start = timeit.default_timer()

df = pl.read_csv(‘users.csv’)
df.sort(by_column=‘n’, reverse=True)
stop = timeit.default_timer()

print(‘Time: ‘, stop – start)

———————–
Time:  9.924110282212496

Polars只花费了约10s,这意味着Polars比Pandas快了2.7倍。

下面,我们来试试数据整合的效果,纵向连接。

import timeit
import pandas as pd

start = timeit.default_timer()

df_users = pd.read_csv(‘users.csv’)
df_fake = pd.read_csv(‘fake_user.csv’)
df_users.append(df_fake, ignore_index=True)
stop = timeit.default_timer()

print(‘Time: ‘, stop – start)

————————
Time:  15.556222308427095

使用Pandas耗时15s。

import timeit
import polars as pl

start = timeit.default_timer()

df_users = pl.read_csv(‘users.csv’)
df_fake = pl.read_csv(‘fake_user.csv’)
df_users.vstack(df_fake)
stop = timeit.default_timer()

print(‘Time: ‘, stop – start)

———————–
Time:  3.475433263927698

Polars居然最使用了约3.5s,这里Polars比Pandas快了4.5倍。

通过上面的比较,Polars在处理速度上表现得相当不错。

可以是大家在未来处理数据时,另一种选择~

当然,Pandas目前历时12年,已经形成了很成熟的生态,支持很多其它的数据分析库。

Polars则是一个较新的库,不足的地方还有很多。

如果你的数据集对于Pandas来说太大,对于Spark来说太小,那么Polars便是你可以考虑的一个选择。

本文转载自公众号【法纳斯特】

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

一行代码实战,用Python玩转所有的 emoji

本文简介

还记得刚刚玩儿QQ、微信时,表情轰炸的场景吗?
  • 小时候,快乐是件很简单的事儿!
  • 长大后,简单是件很快乐的事儿!
随着时间的推移,有些表情被淘汰了,有的表情被保留了下来。慢慢地,它似乎可以代替我们说话人的表情和语气了,它好像成为了社交必备。你或许还看过,微信表情可以当作证据提交,这样的新闻。
“表情”很好玩,我们可以随时随地用它表达我们此时此刻的情感;

“表情”很烦人,有些表情确实让人挺尴尬。

就是玩儿,反正玩儿 也不犯罪,大家开心就好。今天黄同学就带大家讲述如何用Python玩转“表情”。

安装emoji库

emoji库,属于第三方库。在使用之前,我们需要提前安装和导入。

① emoji库的安装

pip install emoji -i https://pypi.tuna.tsinghua.edu.cn/simple/
当出现successfully表示安装成功。

②emoji库的导入

import emoji

玩儿起来

emoji中主要就两个函数,供大家玩耍,分别是:
  • emojize():根据 code 生成 emoji 表情;
  • demojize():将 emoji 表情解码为code;
注意哦:默认情况,你只能使用一部分表情。很多表情,需要加参数use_aliases=True后,才可以展示。
昨天没睡好,今天好困呀!
emoji.emojize(“昨天没睡好,今天:zzz:呀”)
结果如下:
笑逐颜开,好彩自然来!
emoji.emojize(“:smile:逐颜开,好彩自然来!”,use_aliases=True)
结果如下:
黄同学是白羊座!
emoji.emojize(“黄同学是:aries:”,use_aliases=True)
结果如下:
小明是AB型血型!
emoji.emojize(“小明是:ab:型血型!”,use_aliases=True)
结果如下:
晚上十一点了!
emoji.emojize(“晚上:clock11:了!”,use_aliases=True)
结果如下:
其实这个库有很多表情包了,部分截图如下:
这里直接给大家上官网吧,大家可以自行下去玩玩儿。https://pypi.org/project/emoji/
本文转自快学Python

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

利用 Python pyttsx3 将 PDF 文档转为语音音频

 

 

 

 

 

 

 

 

1. 转语音工具

微信读书里的电子书有配套的自动音频,而且声音优化的不错,比传统的机械朗读听起来舒服很多

记得之前看到过 Python有一个工具包,可以将文字转换为语音,支持英文和中文的同时,还能调节语速语调、导出 mp3 等音频文件

去 Github 查了下,这个依赖库叫:pyttsx3

简单来说,pyttsx3 可以文字转语音,且是离线工作的,这一点就很实用

安装比较容易,直接在命令行用 pip 安装:

pip install pyttsx3

我准备动手试试,将 PDF 书籍转成音频

用什么书呢?最近在群里看到有人发张磊的新作《价值》电子书,这本今年刚出的畅销书盗版猖獗,我之前在微信读书里看过,对作者长期主义的观点深信不疑

那就它了

2. PDF转文本

肯定需要先读取 PDF 中的文字,再利用 pyttsx3 转语音

Python 中操作 PDF 的工具库主要是 PyPDF2,但发现编码实在有点繁琐

我就换了另一个库 pdfplumber,它与 PyPDF2 语法类似,用起来还算流畅

pdfplumber 可以处理 PDF 包括文本、表格、格式在内的各种信息,小而强大

# 读取PDF文档
pdf = pdfplumber.open("价值.pdf")

# 获取页数
print("总页数:",len(pdf.pages))
print("-----------------------------------------")

# 读取第4页
first_page = pdf.pages[3]
print("本页:",first_page.page_number+1)
print("-----------------------------------------")

# 导出第4页文本
text = first_page.extract_text()
print(text)

输出文字内容如下:

上面的代码做了几件事情:「读取 PDF 文档、读取页数、读取第 4 页、输出第 4 页文本」

3. 文本转语音

接下来开始将第 4 页的文本转化为音频

import pyttsx3

# 初始化来获取语音引擎
engine = pyttsx3.init()

# 去掉文本中的换行符
text = text.replace('\n','')

# 朗读文本
engine.say(text)
engine.runAndWait()

上面代码使用 pyttsx3 将文本转化为音频,然后朗读出来

我是在 jupyter notebook 上做实验的,代码执行后,电脑会直接朗读

最后,将生成的音频保存为 mp3 格式

# 保存音频到本地,格式为mp3
engine.save_to_file(text, 'test.mp3')
engine.runAndWait()

当然,你还可以调整声音的类型、速度、大小

# 调整人声类型
voices = engine.getProperty('voices')  
engine.setProperty('voice', voices[0].id)

# 调整语速,范围一般在0~500之间
rate = engine.getProperty('rate')                         
engine.setProperty('rate'200)     

# 调整声量,范围在0~1之间
volume = engine.getProperty('volume')                         
engine.setProperty('volume',0.8

最后听下生成的语音是什么样的?

test.mp3 来自AirPython 01:58

整体比较流畅,虽然不如微信读书语音听着那般舒服,但做做小工具还是不错的

转自AirPython.

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

Loguru — 最强大的 Python 日志记录器

Loguru 一个能彻底解放你的日志记录器。

它即插即用,具备多种方式滚动日志、自动压缩日志文件、定时删除等功能。

除此之外,多线程安全、高亮日志、日志告警等功能也不在话下。

下面就给大家介绍一下这个强大工具的基本使用方法。

Loguru 安装方式很简单,打开终端输入:

pip install loguru

即可完成安装。

1.即开即用

如果你需要输出 debug 日志到终端,可以这么做:

from loguru import logger

logger.debug("That's it, beautiful and simple logging!")

其输出自带高亮:

如果你需要把日志输出到文件,只需要这样:

from loguru import logger
logger.add("file_{time}.log")
logger.debug("That's it, beautiful and simple logging!")

这样就会在当前运行的文件夹下生成 file_当前时间.log 的日志文件:

2.滚动日志与压缩

使用 Loguru 我们可轻易地实现滚动日志。

按时间滚动

比如按时间滚动,我们只需要在 logger.add 参数中添加一个 rotation 参数:

from loguru import logger
logger.add("file_2.log", rotation="12:00")     # 每天12:00会创建一个新的文件
logger.debug("That's it, beautiful and simple logging!")

这样,如果当前时间过了这个设定的时间,它就会生成一个新的日志文件。如果没有则使用原来的日志文件:

如图所示,过了设定的时间,则将原来的 file_2.log 重命名,并添加一个新的 file_2.log 文件。

按大小滚动

除了按时间滚动日志外,Loguru 还可以按日志大小滚动:

from loguru import logger
logger.add("file_1.log", rotation="1 MB")    # 滚动大日志文件
logger.debug("That's it, beautiful and simple logging!")

这样,一旦日志文件大小超过 1 MB 就会产生新的日志文件。

压缩日志

如果你不想删除原有日志文件,Loguru 还支持将日志直接压缩:

from loguru import logger
logger.add("file_Y.log", compression="zip")    # 压缩日志

3.其他特性

自定义颜色

Loguru 是支持自定义颜色的,如果你不喜欢它默认的颜色,可以这么改:

logger.add(sys.stdout, colorize=True, format="<green>{time}</green> <level>{message}</level>")

类似于HTML标签 <green></green> 标签中间的文字将会被标记为绿色。

多进程安全

Loguru 默认情况下是线程安全的,但它不是多进程安全的。不过如果你需要多进程/异步记录日志,它也能支持,只需要添加一个 enqueue 参数:

logger.add("somefile.log", enqueue=True)

支持Backtrace

对于日志而言,没有错误堆栈的日志是没有灵魂的。Loguru 允许显示整个堆栈信息来帮助你发现问题(包括变量)。

比如下面这个例子:

logger.add("out.log", backtrace=True, diagnose=True)  # Caution, may leak sensitive data in prod

def func(a, b):
    return a / b

def nested(c):
    try:
        func(5, c)
    except ZeroDivisionError:
        logger.exception("What?!")

nested(0)

日志将会是这样的:

非常清晰明了。

邮件告警

Loguru 可以和强大的邮件通知模块 notifiers 库结合使用,以在程序意外失败时接收电子邮件,或发送许多其他类型的通知。

import notifiers

params = {
    "username": "you@gmail.com",
    "password": "abc123",
    "to": "dest@gmail.com"
}

# 初始化时发送一封邮件
notifier = notifiers.get_notifier("gmail")
notifier.notify(message="The application is running!", **params)

# 发生Error日志时,发邮件进行警报
from notifiers.logging import NotificationHandler

handler = NotificationHandler("gmail", defaults=params)
logger.add(handler, level="ERROR")

这样配置之后,每次产生 Error 日志,程序都会自动向你的邮箱发送告警,真的极其方便。

除了这些特性外,Loguru 还支持与 Python 原生的 Logging 模块兼容使用,你可以将原始的标准日志记录器记录的所有信息转移到Loguru中。

你还可以基于 Loguru 定制新的日志 Level,定制自己喜欢的结构化数据,详情可见 Loguru 的官方文档:

https://github.com/Delgan/loguru

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

Python 教程 — 将微信头像秒变成表情包

在日常生活中,我们经常会存取一些朋友们的丑照,在这个项目中,我们以萌萌哒的熊猫头作为背景,然后试着在背景图上加入朋友们的照片。效果如下图所示:

二、实现步骤

  1. 导入朋友的照片(前景照片);

  2. 处理前景照片(缩放、旋转,填充);

  3. 导入熊猫头照片(背景照片);

  4. 将前景和背景拼接起来形成表情包;

  5. 在表情包下面添加文字。

三、Python 实现

1、导入需要的库

import cv2
import numpy as mp
import matplotlib.pyplot as plt
from PIL import Image, ImageDraw, ImageFont

这个项目主要是通过 opencv 完成,但如果要在表情包下面写中文的话,PIL(pillow)库是必不可少的。

2、绘图函数

这里写一个绘图函数,方便绘图操作。

def plt_show(img):
    imageRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    plt.imshow(imageRGB)
    plt.show()

3、导入前景照片

image = cv2.imread('SXC.jpg', 0)  # 导入灰度图即可
plt_show(image)

4、等比例缩放前景照片

因为我们发现前景照片的尺寸比背景尺寸还要大,这显然是不合适的,所以要先对其进行等比例(0.3)缩放。

image_resize = cv2.resize(image, None, fx=0.3, fy=0.3, interpolation = cv2.INTER_CUBIC)
plt_show(image_resize)

5、对前景照片进行二值化处理

在这里,我们将像素值大于 80 的区域设置为 255;小于 80 的区域设置成 0。

ret, image_binary = cv2.threshold(image_resize, 80, 255, cv2.THRESH_BINARY)
plt_show(image_binary)

6、提取出感兴趣区域

image_roi = image_binary[74: 185, 0: 150]
plt_show(image_roi)

7、旋转图片

因为我们的背景图片(熊猫头)是正的,而前景图片有些向右倾斜,所以要先对其进行旋转操作(大概逆时针旋转 15 度即可)。

rows, cols = image_roi.shape
M = cv2.getRotationMatrix2D(((cols-1)/2.0, (rows-1)/2.0), 15, 1)  # (旋转中心,逆时针旋转角度,各个方向同等扩大比例)
image_rotate = cv2.warpAffine(image_roi, M, (140, 130))  # (140, 130) 是指旋转后的画布大小
plt_show(image_rotate)

8、将一些不需要的黑色区域删除掉

在这里我们使用 cv2.fillPoly 函数对不需要的区域用白色进行填充。

h, w = image_rotate.shape

image_rotate_copy = image_rotate.copy()
pts1 = np.array([[0, 20],  [64, 0], [0, 0]], np.int32)
pts2 = np.array([[0, 18],  [0, h], [80, h]], np.int32)
pts3 = np.array([[0, 100],  [0, h], [w, h], [w, 100]], np.int32)
pts4 = np.array([[111, 0],  [w, 0], [w, 30]], np.int32)
pts5 = np.array([[124, 0],  [115, h], [w, h]], np.int32)
pts6 = np.array([[120, 40],  [95, 100], [120, 100]], np.int32)
foreground = cv2.fillPoly(image_rotate_copy, [pts1], (255, 255, 255))  # (图片,填充区域,填充颜色)
foreground = cv2.fillPoly(image_rotate_copy, [pts2], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts3], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts4], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts5], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts6], (255, 255, 255))

plt_show(foreground)

9、再次提取感兴趣区域并缩放

foreground_roi = foreground[0: 93, 0: 125]
plt_show(foreground_roi)

foreground_roi_resize = cv2.resize(foreground_roi, None, fx=2.5, fy=2.5, interpolation = cv2.INTER_CUBIC)
plt_show(foreground_roi_resize)

10、导入背景图片

background = cv2.imread('back.jpg', 0)
plt_show(background)

11、组合两张图片成表情包

h_f, w_f = foreground.shape
h_b, w_b = background.shape

left = (w_b - w_f)//2  # 前景图片在背景图片中的左边的横坐标
right = left + w_f  # 前景图片在背景图片中的右边的横坐标
top = 100  # 前景图片在背景图片中的上边的纵坐标
bottom = top + h_f  # 前景图片在背景图片中的下边的纵坐标

emoji = background
emoji[top: bottom, left: right] = foreground
plt_show(emoji)

12、在表情包下面添加文本

12.1 添加英文文本

如果只是要添加英文文本,用 opencv 就可以解决:

emoji_copy = emoji.copy()
# (图片,文本,位置,字体,文本大小,文本颜色,文本粗细)
cv2.putText(emoji_copy, "FXXK!!", (210, 500), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 0), 5)
plt_show(emoji_copy)

12.2 添加中文文本

如果要添加中文文本,我们需要借助 PIL 库来实现。

PilImg = Image.fromarray(emoji)  # cv2 转 PIL
draw = ImageDraw.Draw(PilImg)  # 创建画笔
ttfront = ImageFont.truetype('simhei.ttf', 34)  # 设置字体
draw.text((210, 450),"你瞅啥!!",fill=0, font=ttfront)  # (位置,文本,文本颜色,字体)
emoji_text = cv2.cvtColor(np.array(PilImg),cv2.COLOR_RGB2BGR)  # PIL 转回 cv2
plt_show(emoji_text)

13、保存表情包

cv2.imwrite('./emoji.png', np.array(emoji_text))

四、完整代码

import cv2
import numpy as mp
import matplotlib.pyplot as plt
from PIL import Image, ImageDraw, ImageFont

def plt_show(img):
    imageRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    plt.imshow(imageRGB)
    plt.show()

image = cv2.imread('SXC.jpg', 0)  # 导入前景图片

image_resize = cv2.resize(image, None, fx=0.3, fy=0.3, interpolation = cv2.INTER_CUBIC)  # 缩放

ret, image_binary = cv2.threshold(image_resize, 80, 255, cv2.THRESH_BINARY)  # 图片二值化

image_roi = image_binary[74: 185, 0: 150]  # 感兴趣区域

rows, cols = image_roi.shape
# 旋转
M = cv2.getRotationMatrix2D(((cols-1)/2.0, (rows-1)/2.0), 15, 1)
image_rotate = cv2.warpAffine(image_roi, M, (140, 130))
# 填充不需要的区域
h, w = image_rotate.shape
image_rotate_copy = image_rotate.copy()
pts1 = np.array([[0, 20],  [64, 0], [0, 0]], np.int32)
pts2 = np.array([[0, 18],  [0, h], [80, h]], np.int32)
pts3 = np.array([[0, 100],  [0, h], [w, h], [w, 100]], np.int32)
pts4 = np.array([[111, 0],  [w, 0], [w, 30]], np.int32)
pts5 = np.array([[124, 0],  [115, h], [w, h]], np.int32)
pts6 = np.array([[120, 40],  [95, 100], [120, 100]], np.int32)
foreground = cv2.fillPoly(image_rotate_copy, [pts1], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts2], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts3], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts4], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts5], (255, 255, 255))
foreground = cv2.fillPoly(image_rotate_copy, [pts6], (255, 255, 255))

foreground_roi = foreground[0: 93, 0: 125]
foreground_roi_resize = cv2.resize(foreground_roi, None, fx=2.5, fy=2.5, interpolation = cv2.INTER_CUBIC)

background = cv2.imread('back.jpg', 0)  # 导入背景图片
# 拼接两张图片
h_f, w_f = foreground_roi_resize.shape
h_b, w_b = background.shape
left = (w_b - w_f)//2
right = left + w_f
top = 80
bottom = top + h_f
emoji = background
emoji[top: bottom, left: right] = foreground_roi_resize

PilImg = Image.fromarray(emoji)  # cv2 转 PIL
draw = ImageDraw.Draw(PilImg)  # 创建画笔
ttfront = ImageFont.truetype('simhei.ttf', 34)  # 设置字体
draw.text((210, 450),"你瞅啥!!",fill=0, font=ttfront)  # (位置,文本,文本颜色,字体)
emoji_text = cv2.cvtColor(np.array(PilImg),cv2.COLOR_RGB2BGR)  # PIL 转回 cv2

cv2.imwrite('./emoji.png', np.array(emoji_text))  # 保存表情包

原文链接:https://urlify.cn/2aQfya

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

Python 优化提速的 8 个小技巧

 

   作者:张皓

   来源:https://zhuanlan.zhihu.com/p/143052860

Python 是一种脚本语言,相比 C/C++ 这样的编译语言,在效率和性能方面存在一些不足。但是,有很多时候,Python 的效率并没有想象中的那么夸张。本文对一些 Python 代码加速运行的技巧进行整理。

0. 代码优化原则

本文会介绍不少的 Python 代码加速运行的技巧。在深入代码优化细节之前,需要了解一些代码优化基本原则。

第一个基本原则是不要过早优化。很多人一开始写代码就奔着性能优化的目标,“让正确的程序更快要比让快速的程序正确容易得多”。因此,优化的前提是代码能正常工作。过早地进行优化可能会忽视对总体性能指标的把握,在得到全局结果前不要主次颠倒。

第二个基本原则是权衡优化的代价。优化是有代价的,想解决所有性能的问题是几乎不可能的。通常面临的选择是时间换空间或空间换时间。另外,开发代价也需要考虑。

第三个原则是不要优化那些无关紧要的部分。如果对代码的每一部分都去优化,这些修改会使代码难以阅读和理解。如果你的代码运行速度很慢,首先要找到代码运行慢的位置,通常是内部循环,专注于运行慢的地方进行优化。在其他地方,一点时间上的损失没有什么影响。

1. 避免全局变量

# 不推荐写法。代码耗时:26.8秒
import math

size = 10000
for x in range(size):
    for y in range(size):
        z = math.sqrt(x) + math.sqrt(y)

许多程序员刚开始会用 Python 语言写一些简单的脚本,当编写脚本时,通常习惯了直接将其写为全局变量,例如上面的代码。但是,由于全局变量和局部变量实现方式不同,定义在全局范围内的代码运行速度会比定义在函数中的慢不少。通过将脚本语句放入到函数中,通常可带来 15% – 30% 的速度提升。

# 推荐写法。代码耗时:20.6秒
import math

def main():  # 定义到函数中,以减少全部变量使用
    size = 10000
    for x in range(size):
        for y in range(size):
            z = math.sqrt(x) + math.sqrt(y)

main()

2. 避免.

2.1 避免模块和函数属性访问

# 不推荐写法。代码耗时:14.5秒
import math

def computeSqrt(size: int):
    result = []
    for i in range(size):
        result.append(math.sqrt(i))
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

每次使用.(属性访问操作符时)会触发特定的方法,如__getattribute__()__getattr__(),这些方法会进行字典操作,因此会带来额外的时间开销。通过from import语句,可以消除属性访问。

# 第一次优化写法。代码耗时:10.9秒
from math import sqrt

def computeSqrt(size: int):
    result = []
    for i in range(size):
        result.append(sqrt(i))  # 避免math.sqrt的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

在第 1 节中我们讲到,局部变量的查找会比全局变量更快,因此对于频繁访问的变量sqrt,通过将其改为局部变量可以加速运行。

# 第二次优化写法。代码耗时:9.9秒
import math

def computeSqrt(size: int):
    result = []
    sqrt = math.sqrt  # 赋值给局部变量
    for i in range(size):
        result.append(sqrt(i))  # 避免math.sqrt的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

除了math.sqrt外,computeSqrt函数中还有.的存在,那就是调用listappend方法。通过将该方法赋值给一个局部变量,可以彻底消除computeSqrt函数中for循环内部的.使用。

# 推荐写法。代码耗时:7.9秒
import math

def computeSqrt(size: int):
    result = []
    append = result.append
    sqrt = math.sqrt    # 赋值给局部变量
    for i in range(size):
        append(sqrt(i))  # 避免 result.append 和 math.sqrt 的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

2.2 避免类内属性访问

# 不推荐写法。代码耗时:10.4秒
import math
from typing import List

class DemoClass:
    def __init__(self, value: int):
        self._value = value
    
    def computeSqrt(self, size: int) -> List[float]:
        result = []
        append = result.append
        sqrt = math.sqrt
        for _ in range(size):
            append(sqrt(self._value))
        return result

def main():
    size = 10000
    for _ in range(size):
        demo_instance = DemoClass(size)
        result = demo_instance.computeSqrt(size)

main()

避免.的原则也适用于类内属性,访问self._value的速度会比访问一个局部变量更慢一些。通过将需要频繁访问的类内属性赋值给一个局部变量,可以提升代码运行速度。

# 推荐写法。代码耗时:8.0秒
import math
from typing import List

class DemoClass:
    def __init__(self, value: int):
        self._value = value
    
    def computeSqrt(self, size: int) -> List[float]:
        result = []
        append = result.append
        sqrt = math.sqrt
        value = self._value
        for _ in range(size):
            append(sqrt(value))  # 避免 self._value 的使用
        return result

def main():
    size = 10000
    for _ in range(size):
        demo_instance = DemoClass(size)
        demo_instance.computeSqrt(size)

main()

3. 避免不必要的抽象

# 不推荐写法,代码耗时:0.55秒
class DemoClass:
    def __init__(self, value: int):
        self.value = value

    @property
    def value(self) -> int:
        return self._value

    @value.setter
    def value(self, x: int):
        self._value = x

def main():
    size = 1000000
    for i in range(size):
        demo_instance = DemoClass(size)
        value = demo_instance.value
        demo_instance.value = i

main()

任何时候当你使用额外的处理层(比如装饰器、属性访问、描述器)去包装代码时,都会让代码变慢。大部分情况下,需要重新进行审视使用属性访问器的定义是否有必要,使用getter/setter函数对属性进行访问通常是 C/C++ 程序员遗留下来的代码风格。如果真的没有必要,就使用简单属性。

# 推荐写法,代码耗时:0.33秒
class DemoClass:
    def __init__(self, value: int):
        self.value = value  # 避免不必要的属性访问器

def main():
    size = 1000000
    for i in range(size):
        demo_instance = DemoClass(size)
        value = demo_instance.value
        demo_instance.value = i

main()

4. 避免数据复制

4.1 避免无意义的数据复制

# 不推荐写法,代码耗时:6.5秒
def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        value_list = [x for x in value]
        square_list = [x * x for x in value_list]

main()

上面的代码中value_list完全没有必要,这会创建不必要的数据结构或复制。

# 推荐写法,代码耗时:4.8秒
def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        square_list = [x * x for x in value]  # 避免无意义的复制

main()

另外一种情况是对 Python 的数据共享机制过于偏执,并没有很好地理解或信任 Python 的内存模型,滥用 copy.deepcopy()之类的函数。通常在这些代码中是可以去掉复制操作的。

4.2 交换值时不使用中间变量

# 不推荐写法,代码耗时:0.07秒
def main():
    size = 1000000
    for _ in range(size):
        a = 3
        b = 5
        temp = a
        a = b
        b = temp

main()

上面的代码在交换值时创建了一个临时变量temp,如果不借助中间变量,代码更为简洁、且运行速度更快。

# 推荐写法,代码耗时:0.06秒
def main():
    size = 1000000
    for _ in range(size):
        a = 3
        b = 5
        a, b = b, a  # 不借助中间变量

main()

4.3 字符串拼接用join而不是+

# 不推荐写法,代码耗时:2.6秒
import string
from typing import List

def concatString(string_list: List[str]) -> str:
    result = ''
    for str_i in string_list:
        result += str_i
    return result

def main():
    string_list = list(string.ascii_letters * 100)
    for _ in range(10000):
        result = concatString(string_list)

main()

当使用a + b拼接字符串时,由于 Python 中字符串是不可变对象,其会申请一块内存空间,将ab分别复制到该新申请的内存空间中。因此,如果要拼接 n 个字符串,会产生 n-1 个中间结果,每产生一个中间结果都需要申请和复制一次内存,严重影响运行效率。而使用join()拼接字符串时,会首先计算出需要申请的总的内存空间,然后一次性地申请所需内存,并将每个字符串元素复制到该内存中去。

# 推荐写法,代码耗时:0.3秒
import string
from typing import List

def concatString(string_list: List[str]) -> str:
    return ''.join(string_list)  # 使用 join 而不是 +

def main():
    string_list = list(string.ascii_letters * 100)
    for _ in range(10000):
        result = concatString(string_list)

main()

5. 利用if条件的短路特性

# 不推荐写法,代码耗时:0.05秒
from typing import List

def concatString(string_list: List[str]) -> str:
    abbreviations = {'cf.''e.g.''ex.''etc.''flg.''i.e.''Mr.''vs.'}
    abbr_count = 0
    result = ''
    for str_i in string_list:
        if str_i in abbreviations:
            result += str_i
    return result

def main():
    for _ in range(10000):
        string_list = ['Mr.''Hat''is''Chasing''the''black''cat''.']
        result = concatString(string_list)

main()

if 条件的短路特性是指对if a and b这样的语句, 当aFalse时将直接返回,不再计算b;对于if a or b这样的语句,当aTrue时将直接返回,不再计算b。因此, 为了节约运行时间,对于or语句,应该将值为True可能性比较高的变量写在or前,而and应该推后。

# 推荐写法,代码耗时:0.03秒
from typing import List

def concatString(string_list: List[str]) -> str:
    abbreviations = {'cf.''e.g.''ex.''etc.''flg.''i.e.''Mr.''vs.'}
    abbr_count = 0
    result = ''
    for str_i in string_list:
        if str_i[-1] == '.' and str_i in abbreviations:  # 利用 if 条件的短路特性
            result += str_i
    return result

def main():
    for _ in range(10000):
        string_list = ['Mr.''Hat''is''Chasing''the''black''cat''.']
        result = concatString(string_list)

main()

6. 循环优化

6.1 用for循环代替while循环

# 不推荐写法。代码耗时:6.7秒
def computeSum(size: int) -> int:
    sum_ = 0
    i = 0
    while i < size:
        sum_ += i
        i += 1
    return sum_

def main():
    size = 10000
    for _ in range(size):
        sum_ = computeSum(size)

main()

Python 的for循环比while循环快不少。

# 推荐写法。代码耗时:4.3秒
def computeSum(size: int) -> int:
    sum_ = 0
    for i in range(size):  # for 循环代替 while 循环
        sum_ += i
    return sum_

def main():
    size = 10000
    for _ in range(size):
        sum_ = computeSum(size)

main()

6.2 使用隐式for循环代替显式for循环

针对上面的例子,更进一步可以用隐式for循环来替代显式for循环

# 推荐写法。代码耗时:1.7秒
def computeSum(size: int) -> int:
    return sum(range(size))  # 隐式 for 循环代替显式 for 循环

def main():
    size = 10000
    for _ in range(size):
        sum = computeSum(size)

main()

6.3 减少内层for循环的计算

# 不推荐写法。代码耗时:12.8秒
import math

def main():
    size = 10000
    sqrt = math.sqrt
    for x in range(size):
        for y in range(size):
            z = sqrt(x) + sqrt(y)

main() 

上面的代码中sqrt(x)位于内侧for循环, 每次训练过程中都会重新计算一次,增加了时间开销。

# 推荐写法。代码耗时:7.0秒
import math

def main():
    size = 10000
    sqrt = math.sqrt
    for x in range(size):
        sqrt_x = sqrt(x)  # 减少内层 for 循环的计算
        for y in range(size):
            z = sqrt_x + sqrt(y)

main() 

7. 使用numba.jit

我们沿用上面介绍过的例子,在此基础上使用numba.jitnumba可以将 Python 函数 JIT 编译为机器码执行,大大提高代码运行速度。关于numba的更多信息见下面的主页:http://numba.pydata.org/numba.pydata.org

# 推荐写法。代码耗时:0.62秒
import numba

@numba.jit
def computeSum(size: float) -> int:
    sum = 0
    for i in range(size):
        sum += i
    return sum

def main():
    size = 10000
    for _ in range(size):
        sum = computeSum(size)

main()

8. 选择合适的数据结构

Python 内置的数据结构如str, tuple, list, set, dict底层都是 C 实现的,速度非常快,自己实现新的数据结构想在性能上达到内置的速度几乎是不可能的。

list类似于 C++ 中的std::vector,是一种动态数组。其会预分配一定内存空间,当预分配的内存空间用完,又继续向其中添加元素时,会申请一块更大的内存空间,然后将原有的所有元素都复制过去,之后销毁之前的内存空间,再插入新元素。

删除元素时操作类似,当已使用内存空间比预分配内存空间的一半还少时,会另外申请一块小内存,做一次元素复制,之后销毁原有大内存空间。

因此,如果有频繁的新增、删除操作,新增、删除的元素数量又很多时,list的效率不高。此时,应该考虑使用collections.dequecollections.deque是双端队列,同时具备栈和队列的特性,能够在两端进行 O(1) 复杂度的插入和删除操作。

list的查找操作也非常耗时。当需要在list频繁查找某些元素,或频繁有序访问这些元素时,可以使用bisect维护list对象有序并在其中进行二分查找,提升查找的效率。

另外一个常见需求是查找极小值或极大值,此时可以使用heapq模块将list转化为一个堆,使得获取最小值的时间复杂度是 O(1)

下面的网页给出了常用的 Python 数据结构的各项操作的时间复杂度:https://wiki.python.org/moin/TimeComplexity

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

超简单一键美化你的文章—使其更具可读性

在平时写文章的时候,我都会注意在中文和英文单词之间保留一个空格的习惯,这样能使文本具有良好的可读性。

但是我经常忽略某些半角字符(数字和符号)与中文之间的空格,导致可读性比较差,在阅读别人的文章或者修改别人的文章时候,也经常为烦恼他人没有这种优化可读性的细节。

现在,有一个很棒的工具,叫做 pangu , 它可以在中文、日文、韩文和半角字符(字母,数字和符号)之间自动插入空格。

有了它,你可以在每次写完文章后利用 pangu 一键美化文章。也可以用 pangu 美化别人的文章:

import pangu

new_text = pangu.spacing_text('你可以在每次写完文章后利用pangu一键美化文章。也可以用pangu 美化别人的文章:')
print(new_text)
# new_text = '你可以在每次写完文章后利用 pangu 一键美化文章。也可以用 pangu 美化别人的文章:'

如上所示,非常方便。当然你也可以自己用正则表达式去匹配并美化,但是用起来肯定没有 pangu 方便。

下面教大家 pangu 模块的使用方法:

1.准备

开始之前,你要确保Python和pip已经成功安装在电脑上,如果没有,请访问这篇文章:超详细Python安装指南 进行安装。

(可选1) 如果你用Python的目的是数据分析,可以直接安装Anaconda:Python数据分析与挖掘好帮手—Anaconda,它内置了Python和pip.

(可选2) 此外,推荐大家用VSCode编辑器来编写小型Python项目:Python 编程的最好搭档—VSCode 详细指南

Windows环境下打开Cmd(开始—运行—CMD),苹果系统环境下请打开Terminal(command+空格输入Terminal),输入命令安装依赖:

pip install -U pangu

2.使用

安装完成之后,你可以尝试写一些简单的句子并美化它们:

import pangu

new_text = pangu.spacing_text('Windows环境下打开Cmd(开始—运行—CMD),苹果系统环境下请打开Terminal(command+空格输入Terminal)')
print(new_text)
# new_text = 'Windows 环境下打开 Cmd (开始 — 运行 —CMD),苹果系统环境下请打开 Terminal (command + 空格输入 Terminal)'

一键执行

你也可以不写 python 文件,直接通过 -m 参数执行命令:

python -m pangu "為什麼小明有問題都不Google?因為他有Bing"
# 為什麼小明有問題都不 Google?因為他有 Bing

此外,pangu 也支持 pangu 命令直接格式化文本:

pangu "請使用uname -m指令來檢查你的Linux作業系統是32位元或是[敏感词已被屏蔽]位元"
# 請使用 uname -m 指令來檢查你的 Linux 作業系統是 32 位元或是 [敏感词已被屏蔽] 位元

文件支持

通过 -f 参数,pangu 支持把指定的文件内容进行美化,然后输出到另一个文件中:

echo "未來的某一天,Gmail配備的AI可能會得出一個結論:想要消滅垃圾郵件最好的辦法就是消滅人類" >> path/to/file.txt
pangu -f path/to/file.txt >> pangu_file.txt
cat pangu_file.txt
# 未來的某一天,Gmail 配備的 AI 可能會得出一個結論:想要消滅垃圾郵件最好的辦法就是消滅人類

管道支持 (UNIX)

在 UNIX 系统中,比如 Linux 和 MacOS,pangu还支持使用管道 ( | ) 命令美化文本:

echo "心裡想的是Microservice,手裡做的是Distributed Monolith" | pangu
# 心裡想的是 Microservice,手裡做的是 Distributed Monolith

echo "你從什麼時候開始產生了我沒使用Monkey Patch的錯覺?" | python -m pangu
# 你從什麼時候開始產生了我沒使用 Monkey Patch 的錯覺?

两句命令的效果一样,如果你无法直接使用 pangu 命令,可以尝试 python -m pangu,他们能达到一样的效果。

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

Python 中 10 个常用的内置函数

在 3.8 版本中,Python 解释器有近 69 个内置函数可供使用,有了它们能极大地提高编码效率

数量虽然不少,但在日常搬砖中只用到其中一部分,根据使用频率和用法,这里列出来几个本人认为不错的内置函数,结合一些例子介绍给大家

complex()

返回一个形如 a+bj 的复数,传入参数分为三种情况:

  • 参数为空时,返回0j
  • 参数为字符串时,将字符串表达式解释为复数形式并返回
  • 参数为两个整数(a,b)时,返回 a+bj
  • 参数只有一个整数 a 时,虚部 b 默认为0,函数返回 a+0j
>>> complex('1+2j')
(1+2j)
>>> complex()
0j
>>> complex(1,2)
(1+2j)
>>> complex(2)
(2+0j)

dir()

  • 不提供参数时,返回当前本地范围内的名称列表
  • 提供一个参数时,返回该对象包含的全部属性
>>> class Test:
 def first(self):
  return 1
 def second(self):
  return 2
>>> dir(Test)# 提供参数时
['__class__''__delattr__''__dict__''__dir__''__doc__''__eq__''__format__''__ge__''__getattribute__''__gt__''__hash__''__init__''__init_subclass__''__le__''__lt__''__module__''__ne__''__new__''__reduce__''__reduce_ex__''__repr__''__setattr__''__sizeof__''__str__''__subclasshook__''__weakref__''first''second']
>>> dir()# 未提供参数时
['Test''__annotations__''__builtins__''__doc__''__loader__''__name__''__package__''__spec__']

divmod(a,b)

  • a — 代表被除数,整数或浮点数;
  • b — 代表除数,整数或浮点数;

根据 除法运算 计算 a,b 之间的商和余数,函数返回一个元组(p,q) ,p 代表商 a//b ,q 代表余数 a%b

>>> divmod(21,4)
(5, 1)
>>> divmod(20.1,3)
(6.0, 2.1000000000000014)

enumerate(iterable,start=0)

  • iterable — 一个可迭代对象,列表、元组序列等
  • start — 计数索引值,默认初始为0

该函数返回枚举对象是个迭代器,利用 next() 方法依次返回元素值,每个元素以元组形式存在,包含一个计数元素(起始为 start )和 iterable 中对应的元素值;

>>> stu = ['xiao','zhang','li','qian']
>>> enumerate(stu)
<enumerate object at 0x0000025331773F48>
>>> list(enumerate(stu))# 默认start = 0
[(0, 'xiao'), (1, 'zhang'), (2, 'li'), (3, 'qian')]
>>> list(enumerate(stu,start = 1))# 默认start = 1
[(1, 'xiao'), (2, 'zhang'), (3, 'li'), (4, 'qian')]

eval(expression,globals,locals)

  • expression — 字符串表达式
  • globals — 变量作用,全局命名空间,如果提供必须为字典形式;可选参数
  • locals — 变量作用域,局部命名空间,如果提须可为任何可映射对象;可选参数

将字符串表达式解析,返回执行结果

>>> eval("2+2")
4
>>> eval("2==2")
True

filter(function,iterable)

  • function — 提供筛选函数名,返回 true 或 false

  • iterable — 列表、元组等可迭代对象

函数返回 iterable 中满足 function 为 True 的元素;假设有一个列表,我们只需要其中的一部分元素,这时就可以提前写一个函数再借助 filter 来进行过滤

>>> num_list = list(range(20))
>>> num_list
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> def mod_three(num):
 if(num%3==0):
  return True
 else:
  return False

>>> filter(mod_three,num_list)
<filter object at 0x00000253315A6608>
>>> list(filter(mod_three,num_list))
[0, 3, 6, 9, 12, 15, 18]

isinstance(object,classinfo)

  • object –表示一个类型的对象,若不是此类型, 函数恒返回 False;
  • calssinfo — 为一个类型元组或单个类型;

判断对象 object 的类型是否为 classinfo 或 classinfo 中其中一个类型,返回 True 或 False;

调试Python程序时,障碍之一就是初始变量没有定义类型,所以在代码编写或者调试时,isinstance() 函数常被用来判断变量类型,帮助我们了解程序整个逻辑防止出错

>>> isinstance(num,str)
False
>>> isinstance(num,int)
True

map(function,iterable,…)

  • function — 执行函数;
  • iterable — 可迭代对象;

将 iterable 中的每一个元素放入函数 function 中依次执行,得到与 iteable 元素数量相同的迭代器;

map() 中可迭代对象可以为多个,其中函数 function 中的参数为所有可迭代对象中并行元素,最终得到的迭代器的数量是以提供元素数量最少可迭代对象为基准,当数量最少的可迭代对象所有元素输入完毕后即执行停止

>>> def fun_a(a,b):
 return a+2*b

>>> num_list1 = [1,2,3,4]
>>> num_list2 = [2,3,4,5]
>>> list(map(fun_a,num_list1,num_list2))
[5, 8, 11, 14]

input()

函数用于人机交互,读取从输入端输入的一行内容,转化为字符串

>>> s = input('input:')
input:小张Pyhon
>>> s
'小张Pyhon'

zip(*iteables)

  • *iterables — 两个或两个以上可迭代对象

将所有 iterable 对象中元素按参数顺序以元素并行方式聚合在一起,得到一个迭代器,迭代器中每个元素是个n元素元组,n 表示函数中输入 iterable 参数数量

>>> num_list1 = [1,2,3,4]
>>> num_list2 = [2,3,1,2]
>>> list(zip(num_list1,num_list2))
[(1, 2), (2, 3), (3, 1), (4, 2)]

zip() 函数功能等价于

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

除了上面列举的 10 个之外,还有其它 59 个内置函数,想了解的小伙伴可点击下方原文阅读去了解

对于 Python 开发者来说,掌握这些内置函数非常有用,一方面能提高编码效率,另一方面也能提高代码简洁性;在某一方面功能虽然没有第三方库函数强大,但也不能被小觑

好了以上就是本篇文章的全部内容了,最后感谢大家阅读,我们下期见~

本文转自AirPython.

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

PySnooper – 永远不要使用print进行调试

PySnooper 是一个非常方便的调试器。如果您正在试图弄清楚为什么您的Python代码没有按照您的预期去做,您会希望使用具有断点和监视功能的成熟Debug工具,但是许多Debug工具配置起来非常麻烦。

现在,有了PySnooper,您并不需要配置那么复杂的Debug工具,就能够完成对整个代码的分析。它能告诉您哪些代码正在运行,以及局部变量的值是什么。

其实,PySnooper就是替代了一行一行print的重复性工作,给你的代码一个pysnooper装饰器,它能自动识别到语句和变量并将其值print出来:

import pysnooper

@pysnooper.snoop()
def number_to_bits(number):
    if number:
        bits = []
        while number:
            number, remainder = divmod(number, 2)
            bits.insert(0, remainder)
        return bits
    else:
        return [0]

number_to_bits(6)

效果如下:

Source path:... 1.py
Starting var:.. number = 6
23:03:35.990701 call         4 def number_to_bits(number):
23:03:35.991699 line         5     if number:
23:03:35.991699 line         6         bits = []
New var:....... bits = []
23:03:35.991699 line         7         while number:
23:03:35.991699 line         8             number, remainder = divmod(number, 2)
Modified var:.. number = 3
New var:....... remainder = 0
23:03:35.991699 line         9             bits.insert(0, remainder)
Modified var:.. bits = [0]
23:03:36.004664 line         7         while number:
23:03:36.005661 line         8             number, remainder = divmod(number, 2)
Modified var:.. number = 1
Modified var:.. remainder = 1
23:03:36.005661 line         9             bits.insert(0, remainder)
Modified var:.. bits = [1, 0]
23:03:36.007657 line         7         while number:
23:03:36.007657 line         8             number, remainder = divmod(number, 2)
Modified var:.. number = 0
23:03:36.008655 line         9             bits.insert(0, remainder)
Modified var:.. bits = [1, 1, 0]
23:03:36.008655 line         7         while number:
23:03:36.009651 line        10         return bits
23:03:36.009651 return      10         return bits
Return value:.. [1, 1, 0]
Elapsed time: 00:00:00.020945

可以看到,它将每一行变量的值都输出到屏幕上,方便你调试代码。

仅仅需要写一行代码—使用装饰器就可以实现这个方便的调试功能,比起一行行写print,这可方便多了。

0.安装

使用这个模块,你只需要使用Pip安装PySnooper:

pip install pysnooper

接下来讲讲这个模块其他好用的功能:

1.支持日志文件

如果你觉得print到屏幕上不方便,还可以将其输出到log文件中,你只需要将装饰器那一行改为:

@pysnooper.snoop('/my/log/file.log')

2.读取局外变量或其他表达式

如果你想读取在装饰器作用范围以外的变量或者表达式的值,还可以使用watch参数:

@pysnooper.snoop(watch=('foo.bar', 'self.x["whatever"]'))

3.如果你不想用装饰器,也可以用上下文的形式调试

没错,装饰器有限定的使用条件,使用起来比较局限,因此pysnooper还支持使用 with 的上下文形式:

import pysnooper
import random

def foo():
    lst = []
    for i in range(10):
        lst.append(random.randrange(1, 1000))

    with pysnooper.snoop():
        lower = min(lst)
        upper = max(lst)
        mid = (lower + upper) / 2
        print(lower, mid, upper)

foo()

效果如下,只有上下文里的代码才会被调试出来:

New var:....... i = 9
New var:....... lst = [681, 267, 74, 832, 284, 678, ...]
09:37:35.881721 line        10         lower = min(lst)
New var:....... lower = 74
09:37:35.882137 line        11         upper = max(lst)
New var:....... upper = 832
09:37:35.882304 line        12         mid = (lower + upper) / 2
74 453.0 832
New var:....... mid = 453.0
09:37:35.882486 line        13         print(lower, mid, upper)
Elapsed time: 00:00:00.000344

当我们只需要调试部分代码的时候,这个上下文形式的调试方法非常方便。

此外,PySnooper还有许多更强大的用法,大家可以看他们的高级使用文档:

https://github.com/cool-RR/PySnooper/blob/master/ADVANCED_USAGE.md

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

有趣好用的Python教程

退出移动版
微信支付
请使用 微信 扫码支付