pyefun 易函数¶
为python提供强大且易用的中文函数库，完整的封装了易语言核心支持库所有功能，以及易语言中简单易用的函数
qq群 : 1017240979
pyefun 易函数¶
核心支持库命令¶
pyefun.核心支持库.算数运算 module¶
提示
算数运算
1import unittest
2
3from .算数运算 import *
4from .类型转换 import *
5
6class Test算数运算(unittest.TestCase):
7
8 def test_1(self):
9 pass
10 self.assertEqual(四舍五入(123.144, 2), 123.14)
11 self.assertEqual(四舍五入(123.146, 2), 123.15)
12 self.assertEqual(取绝对值(-1), 1)
13
14 self.assertEqual(取绝对值(-100), 100)
15 self.assertEqual(取绝对值(-0.1), 0.1)
16 self.assertEqual(取绝对值(0.1), 0.1)
17
18 self.assertEqual(取整(100.111), 100)
19 self.assertEqual(到整数('8852791.5'), 8852791)
20 self.assertEqual(到整数('-8852791.5'), -8852791)
21 self.assertEqual(到整数('8852791.5123456789'), 8852791)
22 self.assertEqual(到整数('-8852791.5123456789'), -8852791)
23
24 self.assertEqual(求次方(2, 2), 4)
25 self.assertEqual(求次方(4, 2), 16)
26 self.assertEqual(求余弦(30), 0.15425144988758405)
27 self.assertEqual(求反正切(30), 1.5374753309166493)
28 self.assertEqual(求平方根(2), 1.4142135623730951)
29 self.assertEqual(求正切(30), -6.405331196646276)
30 self.assertEqual(求正弦(30), -0.9880316240928618)
31 self.assertEqual(取随机数(1, 1), 1)
32 self.assertEqual(取整数('8852791.5'), 8852791)
33 self.assertEqual(取整数('+8852791.5'), 8852791)
34 self.assertEqual(取整数('-8852791.5'), -8852791)
35 self.assertEqual(取整数(8852791.5), 8852791)
36
- pyefun.核心支持库.算数运算.取整(value)[源代码]¶
调用格式： 〈整数型〉 取整 （双精度小数型 欲取整的小数） - 系统核心支持库->算术运算
英文名称：int
返回一个小数的整数部分。本命令与“绝对取整”命令不相同之处为：
如果给定小数为负数，则本命令返回小于或等于该小数的第一个负整数，而“绝对取整”命令则会返回大于或等于该小数的第一个负整数。例如，本命令将 -7.8 转换成 -8，而“绝对取整”命令将 -7.8 转换成 -7。本命令为初级命令。
参数<1>的名称为“欲取整的小数”，类型为“双精度小数型（double）”。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.取绝对值(双精度小数型: float)[源代码]¶
调用格式： 〈双精度小数型〉 取绝对值 （双精度小数型 欲取其绝对值的数值） - 系统核心支持库->算术运算
英文名称：abs
如果所提供数值为字节型，则将直接返回该数值。本命令为初级命令。
参数<1>的名称为“欲取其绝对值的数值”，类型为“双精度小数型（double）”。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.取随机数(欲取随机数的最小值: int, 欲取随机数的最大值: int)[源代码]¶
调用格式： 〈整数型〉 取随机数 （［整数型 欲取随机数的最小值］，［整数型 欲取随机数的最大值］） - 系统核心支持库->算术运算
英文名称：rnd
返回一个指定范围内的随机数值。在使用本命令取一系列的随机数之前，应该先使用“置随机数种子”命令为随机数生成器初始化一个种子值。本命令为初级命令。
参数<1>的名称为“欲取随机数的最小值”，类型为“整数型（int）”，可以被省略。参数必须大于或等于零。本参数如果被省略，默认为 0 。
参数<2>的名称为“欲取随机数的最大值”，类型为“整数型（int）”，可以被省略。参数必须大于或等于零。本参数如果被省略，默认为无限。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.四舍五入(欲被四舍五入的数值: float, 被舍入的位置: int)[源代码]¶
调用格式： 〈双精度小数型〉 四舍五入 （双精度小数型 欲被四舍五入的数值，［整数型 被舍入的位置］） - 系统核心支持库->算术运算
英文名称：round
返回按照指定的方式进行四舍五入运算的结果数值。本命令为初级命令。
参数<1>的名称为“欲被四舍五入的数值”，类型为“双精度小数型（double）”。
参数<2>的名称为“被舍入的位置”，类型为“整数型（int）”，可以被省略。如果大于0，表示小数点右边应保留的位数；如果等于0，表示舍入到整数；如果小于0，表示小数点左边舍入到的位置。例如：四舍五入 (1056.65, 1) 返回 1056.7； 四舍五入 (1056.65, 0) 返回 1057； 四舍五入 (1056.65, -1) 返回 1060。如果省略本参数，则默认为0。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.求余弦(欲进行计算的角: float)[源代码]¶
调用格式： 〈双精度小数型〉 求余弦 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算
英文名称：cos
返回指定角的余弦值。本命令为初级命令。
参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.求反正切(欲求其反正切值的数值: float)[源代码]¶
调用格式： 〈双精度小数型〉 求反正切 （双精度小数型 欲求其反正切值的数值） - 系统核心支持库->算术运算
英文名称：atn
返回指定数的反正切值。本命令为初级命令。
参数<1>的名称为“欲求其反正切值的数值”，类型为“双精度小数型（double）”。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.求平方根(欲求次方数值: float)[源代码]¶
调用格式： 〈双精度小数型〉 求平方根 （双精度小数型 欲求其平方根的数值） - 系统核心支持库->算术运算
英文名称：sqr
返回指定参数的平方根。本命令为初级命令。
参数<1>的名称为“欲求其平方根的数值”，类型为“双精度小数型（double）”。参数值如果小于零将导致计算错误。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.求次方(欲求次方数值: float, 次方数: float)[源代码]¶
调用格式： 〈双精度小数型〉 求次方 （双精度小数型 欲求次方数值，双精度小数型 次方数） - 系统核心支持库->算术运算
英文名称：pow
返回指定数值的指定次方。本命令为初级命令。
参数<1>的名称为“欲求次方数值”，类型为“双精度小数型（double）”。参数值指定欲求其某次方的数值。
参数<2>的名称为“次方数”，类型为“双精度小数型（double）”。参数值指定对欲求次方数值的运算指数。
操作系统需求： Windows、Linux
- pyefun.核心支持库.算数运算.求正切(欲进行计算的角: float)[源代码]¶
调用格式： 〈双精度小数型〉 求正切 （双精度小数型 欲进行计算的角） - 系统核心支持库->算术运算
英文名称：tan
返回指定角的正切值。本命令为初级命令。
参数<1>的名称为“欲进行计算的角”，类型为“双精度小数型（double）”。所使用单位为弧度。为了将角度转换成弧度，请将角度乘以 pi / 180。为了将弧度转换成角度，请将弧度乘以 180 / pi。如果参数值大于等于 2 的 63 次方，或者小于等于 -2 的 63 次方，将导致计算溢出。
操作系统需求： Windows、Linux
pyefun.核心支持库.数组操作 module¶
提示
数组操作
1import unittest
2
3from .算数运算 import *
4from .数组操作 import *
5from .文本操作 import *
6
7
8class Test数组操作(unittest.TestCase):
9
10 def test_1(self):
11 pass
12 # arr = 数组(["a", "b", "c"])
13 # arr.加入成员("a")
14 arr = 数组()
15 for i in range(10):
16 arr.加入成员(取随机数(1, 100))
17
18 print(arr.取所有成员())
19 arr.排序(reverse=False)
20 print(arr.取所有成员())
21 arr.排序(reverse=True)
22 print(arr.取所有成员())
23
24 arr2 = 数组()
25 print("arr2???", arr2.取所有成员())
26
27 for i in range(10):
28 arr2.加入成员((取随机数(1, 100), 字符(65 + i)))
29
30 print(arr2.取所有成员())
31 arr2.排序(reverse=False)
32 print(arr2.取所有成员())
33 # arr2.排序(reverse=True,)
34 arr2.排序(reverse=True, key=lambda d: d[0])
35 print(arr2.取所有成员())
36
37 def test_2(self):
38 arr = 数组([1, 2, 3, 4, 5, 0, 0, 0])
39 arr.加入成员(6)
40 arr.插入成员(0, 2)
41 print(arr.取所有成员())
42
43 data = arr.统计成员次数(0)
44 print(data)
45
46 data = arr.查找成员(3)
47 print(data)
48 print(arr.取所有成员())
49 data = arr.弹出成员()
50 print(data)
51 print(arr.取所有成员())
52 arr.移除成员(2)
53 print(arr.取所有成员())
54
55 arr.翻转()
56 print(arr.取所有成员())
57
58 arr.清空()
59 print(arr.取所有成员())
60
61 def test_3(self):
62 # arr = 数组(["a", "b", "c"])
63 # arr.加入成员("a")
64 arr = 数组()
65 for i in range(10):
66 arr.加入成员(取随机数(1, 100))
67
68 print(arr.取所有成员())
69 arr.从大到小()
70 print(arr.取所有成员())
71 arr.从小到大()
72 print(arr.取所有成员())
73
74 arr2 = 数组()
75 print("arr2???", arr2.取所有成员())
76
77 for i in range(10):
78 arr2.加入成员((取随机数(1, 100), 取随机数(1, 100),str(取随机数(1, 100)), 字符(65 + i)))
79 print(arr2.取所有成员())
80 arr2.从大到小(0)
81 print(arr2.取所有成员())
82 # arr2.排序(reverse=True,)
83 arr2.从小到大(2)
84 print(arr2.取所有成员())
85 arr2.从小到大(3)
86 print(arr2.取所有成员())
87 arr2.从大到小(3)
88 print(arr2.取所有成员())
pyefun.核心支持库.编码转换 module¶
提示
编码转换
需要安装 chardet
pip install chardet
1import unittest
2
3from .编码转换 import *
4from .磁盘操作 import *
5
6
7class Test编码转换(unittest.TestCase):
8
9 def test_1(self):
10 pass
11 # E文本编码转换(编码_UTF8编码("你好aaaa"), "", "utf-8")
12 text = 编码_UTF8编码("大家好我是gbk编码你好aaaa")
13 print(type(text))
14 text2 = 文本编码转换(text, "", "gbk")
15 print(type(text2))
16 print(text2)
17 print(编码_检查(text2))
18
19 # 写到文件("gbk.txt",text2)
20 print("--------------")
21
22 text = 编码_GBK编码("大家好我是gbk编码你好aaaa")
23 print(type(text))
24 text2 = 文本编码转换(text, "", "utf-8")
25 print(type(text2))
26 print(text2)
27 print(编码_检查(text2))
28 # 写到文件("utf-8.txt",text2)
29
30 # 删除文件("gbk.txt")
31 # 删除文件("utf-8.txt")
32
33 def test_2(self):
34 data = 编码_URL编码("你好ABC")
35 print(data)
pyefun.核心支持库.磁盘操作 module¶
提示
磁盘操作
1"""
2
3.. Hint::
4 磁盘操作
5
6.. literalinclude:: ../../../pyefun/核心支持库/磁盘操作.py
7 :language: python
8 :caption: 代码示例
9 :linenos:
10
11
12"""
13import os
14import sys
15import stat
16import shutil
17from .公用函数 import *
18from .文本操作 import *
19
20
21# 取磁盘总空间
22# 取磁盘剩余空间
23# 取磁盘卷标
24# 置磁盘卷标
25# 改变驱动器
26# 改变目录 -
27# 取当前目录 -
28# 创建目录 -
29# 删除目录 -
30# 复制文件 -
31# 移动文件 -
32# 删除文件 -
33# 文件更名 -
34# 文件是否存在 -
35# 寻找文件
36# 取文件时间
37# 取文件尺寸
38# 取文件属性
39# 置文件属性
40# 取临时文件名
41# 读入文件 -
42# 写到文件 -
43
44
45def 取资源文件路径(relative_path=""):
46 """ PyInstaller 单文件解压后目录的路径 """
47 try:
48 base_path = sys._MEIPASS
49 except Exception:
50 base_path = os.path.abspath(".")
51 return os.path.join(base_path, relative_path)
52
53
54def 取运行目录():
55 """ PyInstaller 单文件的运行目录 """
56 if getattr(sys, 'frozen', False):
57 return os.path.dirname(os.path.realpath(sys.argv[0]))
58 else:
59 return sys.path[0]
60
61
62def 取当前目录():
63 return os.getcwd()
64
65
66# 调用格式： 〈逻辑型〉 复制文件 （文本型 被复制的文件名，文本型 复制到的文件名） - 系统核心支持库->磁盘操作
67# 英文名称：FileCopy
68# 成功返回真，失败返回假。本命令为初级命令。
69# 参数<1>的名称为“被复制的文件名”，类型为“文本型（text）”。
70# 参数<2>的名称为“复制到的文件名”，类型为“文本型（text）”。
71#
72# 操作系统需求： Windows、Linux
73@异常处理返回类型逻辑型
74def 复制文件(被复制的文件名, 复制到的文件名):
75 shutil.copyfile(被复制的文件名, 复制到的文件名)
76 return True
77
78
79@异常处理返回类型逻辑型
80def 复制目录(被复制的目录, 复制到的目录):
81 shutil.copytree(被复制的目录, 复制到的目录)
82 return True
83
84
85# 调用格式： 〈逻辑型〉 移动文件 （文本型 被移动的文件，文本型 移动到的位置） - 系统核心支持库->磁盘操作
86# 英文名称：FileMove
87# 将文件从一个位置移动到另外一个位置。成功返回真，失败返回假。本命令为初级命令。
88# 参数<1>的名称为“被移动的文件”，类型为“文本型（text）”。
89# 参数<2>的名称为“移动到的位置”，类型为“文本型（text）”。
90#
91# 操作系统需求： Windows、Linux
92@异常处理返回类型逻辑型
93def 移动文件(被移动的文件, 移动到的位置):
94 shutil.move(被移动的文件, 移动到的位置)
95 return True
96
97
98def 文件_目录文件列表(路径='.'):
99 '.为单前目录，..为上级目录，目录下的文件名,文件夹名,不带路径'
100 return os.listdir(路径)
101
102
103def 文件_遍历子目录(路径='.'):
104 '成功返回列表：(路径, [包含目录], [包含文件]),用法 for root, dirs, files in os.walk("..", topdown=False):'
105 return list(os.walk(路径))
106
107
108def 文件_递归获取所有文件(路径='.'):
109 """获取文件夹下所有文件绝对路径 排查文件夹"""
110 filess = []
111 listFiles = os.listdir(路径)
112 for i in range(0, len(路径)):
113 path = os.path.join(路径, listFiles[i])
114 if os.path.isdir(path):
115 filess.extend(文件_递归获取所有文件(path))
116 elif os.path.isfile(path):
117 filess.append(path)
118 return filess
119
120
121@异常处理返回类型逻辑型
122def 创建目录(路径, 自动创建目录=True):
123 if 文件是否存在(路径):
124 return True
125 if 自动创建目录:
126 try:
127 access = 0o777
128 original_umask = os.umask(000)
129 os.makedirs(路径, access)
130 finally:
131 os.umask(original_umask)
132 else:
133 os.mkdir(路径)
134 return True
135
136
137# 调用格式： 〈逻辑型〉 写到文件 （文本型 文件名，字节集 欲写入文件的数据，... ） - 系统核心支持库->磁盘操作
138# 英文名称：WriteFile
139# 本命令用作将一个或数个字节集顺序写到指定文件中，文件原有内容被覆盖。成功返回真，失败返回假。本命令为初级命令。命令参数表中最后一个参数可以被重复添加。
140# 参数<1>的名称为“文件名”，类型为“文本型（text）”。
141# 参数<2>的名称为“欲写入文件的数据”，类型为“字节集（bin）”。
142#
143# 操作系统需求： Windows、Linux
144
145@异常处理返回类型逻辑型
146def 写到文件(文件名, 欲写入文件的数据):
147 if (type(欲写入文件的数据) == str):
148 欲写入文件的数据 = bytes(欲写入文件的数据, encoding="utf-8")
149
150 with open(文件名, 'wb') as f:
151 f.write(欲写入文件的数据)
152 return True
153
154
155def 读入文件(文件名):
156 if 文件是否存在(文件名) == False:
157 return b""
158 '方式默认用r 字节集用rb 长度默认读取全部,更多模式参考https://www.runoob.com/python3/python3-func-open.html'
159 with open(文件名, 'rb') as f:
160 return f.read(-1)
161
162
163@异常处理返回类型逻辑型
164def 删除文件(路径):
165 '成功返回True,用于删除文件,如果文件是一个目录则返回一个错误'
166 os.remove(路径)
167 return True
168
169
170@异常处理返回类型逻辑型
171def 删除目录(路径, 递归删除=False):
172 if 文件是否存在(路径) == False:
173 return False
174 if 递归删除:
175 shutil.rmtree(路径)
176 else:
177 os.rmdir(路径)
178 return True
179
180
181@异常处理返回类型逻辑型
182def 文件更名(原文件名, 新文件名):
183 '成功返回True,可以是文件或文件夹'
184 # os.rename(原文件名, 新文件名)
185 shutil.move(原文件名, 新文件名)
186
187 return True
188
189
190def 文件_路径取扩展名(路径):
191 return os.path.splitext(路径)[1]
192
193
194def 文件_取文件名(路径, 是否需要拓展名=True):
195 if 是否需要拓展名:
196 return os.path.basename(路径)
197 else:
198 return os.path.splitext(os.path.basename(路径))[0]
199
200
201def 路径_取目录名(路径):
202 return os.path.basename(路径)
203
204
205def 文件_取目录(路径):
206 '去掉文件名，返回目录路径'
207 return os.path.dirname(路径)
208
209
210@异常处理返回类型逻辑型
211def 改变目录(路径):
212 '成功返回True'
213 os.chdir(路径)
214 return True
215
216
217@异常处理返回类型逻辑型
218def 改变当前进程目录(路径):
219 '成功返回True'
220 os.chroot(路径)
221 return True
222
223
224def 文件_检查权限(路径, 权限=os.F_OK):
225 '类型：0 是否存在 1 是否可读 2 是否可写 3 是否可执行，返回True或False'
226 # {0: os.F_OK, 1: os.R_OK, 2: os.W_OK, 3: os.X_OK}
227 return os.access(路径, 权限)
228
229
230def 文件_是否为绝对路径(路径):
231 '传入路径返回True或False'
232 return os.path.isabs(路径)
233
234
235def 文件_是否为目录(路径):
236 '传入路径返回True或False'
237 return os.path.isdir(路径)
238
239
240def 文件_是否为文件(路径):
241 '传入路径返回True或False'
242 return os.path.isfile(路径)
243
244
245def 文件是否存在(路径):
246 """传入路径返回True或False/可以判断文件夹或者文件"""
247 return os.path.exists(路径)
248
249
250def 文件_取文件大小(路径):
251 '返回文件长度'
252 return os.path.getsize(路径)
253
254
255def 文件_获取文件信息(路径):
256 '成功返回(上次访问时间,修改时间,文件大小)，返回的是10位时间戳'
257 结果 = os.stat(路径)
258 return (结果.st_atime, 结果.st_mtime, 结果.st_size)
259
260
261def 文件_修改文件时间(路径, 时间):
262 '成功返回True,传入的时间为10位时间戳元组类型(访问时间戳,修改时间戳)'
263 os.utime(路径, 时间)
264 return True
265
266
267# 调用格式： 〈日期时间型〉 取文件时间 （文本型 文件名） - 系统核心支持库->磁盘操作
268# 英文名称：FileDateTime
269# 返回指定文件被创建或最后修改后的日期和时间。如果该文件不存在，将返回100年1月1日。本命令为初级命令。
270# 参数<1>的名称为“文件名”，类型为“文本型（text）”。
271#
272# 操作系统需求： Windows、Linux
273def 取文件访问时间(路径):
274 '返回时间戳'
275 return os.path.getatime(路径)
276
277
278def 取文件创建时间(路径):
279 '返回时间戳'
280 return os.path.getctime(路径)
281
282
283def 取文件修改时间(路径):
284 '返回时间戳'
285 return os.path.getmtime(路径)
286
287
288def 文件_修改权限(路径, 权限=stat.S_IRWXU):
289 'http://www.runoob.com/python/os-chmod.html'
290 # stat.S_IREAD 只读
291 # stat.S_IWRITE 取消只读
292 # stat.S_IRWXU 读写执行
293 return os.chmod(路径, 权限)
294
295
296def 文件_枚举(欲寻找的目录=".", name=".jpg", 递归子目录=True):
297 list = []
298 for item in os.listdir(欲寻找的目录):
299 item_path = os.path.join(欲寻找的目录, item)
300 if os.path.isdir(item_path):
301 if (递归子目录):
302 newlist = 文件_枚举(item_path, name, 递归子目录)
303 for item_path in newlist:
304 list.append(item_path)
305 elif os.path.isfile(item_path):
306 if name in item:
307 list.append(item_path)
308 return list
309
310
311def 目录_枚举(欲寻找的目录=".", 递归子目录=True):
312 list = []
313 for item in os.listdir(欲寻找的目录):
314 item_path = os.path.join(欲寻找的目录, item)
315 if os.path.isdir(item_path):
316 list.append(item_path)
317 if (递归子目录):
318 newlist = 目录_枚举(item_path, 递归子目录)
319 for item_path in newlist:
320 list.append(item_path)
321 return list
322
323
324def 文件_删除(欲删除的文件名: str) -> bool:
325 return 删除文件(欲删除的文件名)
326
327
328def 文件_取扩展名(路径: str) -> str:
329 return 子文本替换(文件_路径取扩展名(路径), ".", "")
330
331
332def 文件_更名(原文件名, 新文件名) -> bool:
333 return 文件更名(原文件名, 新文件名)
334
335
336def 文件_取父目录(路径) -> str:
337 return os.path.dirname(路径)
338
339
340def 文件_写出(文件名: str, 欲写入文件的数据) -> bool:
341 dir = 文件_取父目录(文件名)
342 if 文件是否存在(dir) == False:
343 创建目录(dir)
344 return 写到文件(文件名, 欲写入文件的数据)
345
346
347@异常处理返回类型逻辑型
348def 文件_追加文本(文件名: str, 欲追加的文本: str) -> bool:
349 dir = 文件_取父目录(文件名)
350 if 文件是否存在(dir) == False:
351 创建目录(dir)
352 with open(文件名, "a") as f:
353 f.write(str(欲追加的文本) + "\n")
354 return True
355
356
357@异常处理返回类型逻辑型
358def 读入文本(文件名: str) -> str:
359 return 读入文件(文件名).decode('utf-8')
360
361
362def 文件_保存(文件名: str, 欲写入文件的数据: bytes) -> str:
363 dir = 文件_取父目录(文件名)
364 if 文件是否存在(dir) == False:
365 创建目录(dir)
366 return 文件_写出(文件名, 欲写入文件的数据)
367 else:
368 data = 读入文件(文件名)
369 wdata = 欲写入文件的数据
370 if (data != wdata):
371 return 文件_写出(文件名, 欲写入文件的数据)
372 return True
373
374
375def 文件从列表中选取存在的文件路径(路径列表):
376 """
377 匹配文件是否存在 存在则返回文件路径
378
379.. code-block:: python
380 :linenos:
381
382 labelsPath = 文件从列表中选取存在的文件路径([
383 "./model/labels.txt",
384 "/opt/labels.txt",
385 "/opt/model/labels.txt",
386 ])
387 """
388 for v in 路径列表:
389 if os.path.exists(v):
390 return v
391 return ''
392
393
394def 路径优化(path):
395 """
396 把\\ // 乱七八糟的路径转化为规整的
397 :param path:
398 :return:
399 """
400 if 寻找文本(path, "\\") > -1:
401 path = 子文本替换(path, "\\", "/")
402 if 寻找文本(path, r"\\") > -1:
403 path = 子文本替换(path, r"\\", "/")
404 if 寻找文本(path, r"//") > -1:
405 path = 子文本替换(path, r"//", "/")
406 return os.path.normpath(path)
407
408
409def 目录_取文件夹大小(path):
410 """传入路径是文件夹"""
411 size = 0.0
412 for root, dirs, files in os.walk(path):
413 size += sum([os.path.getsize(os.path.join(root, file)) for file in files])
414 size = round(size / 1024 / 1024, 2)
415 if size > 1000:
416 size = round(size / 1024, 2)
417 return str(size) + '-GB'
418 return str(size) + '-MB'
- pyefun.核心支持库.磁盘操作.文件_遍历子目录(路径='.')[源代码]¶
成功返回列表：(路径, [包含目录], [包含文件]),用法 for root, dirs, files in os.walk(“..”, topdown=False):
pyefun.核心支持库.公用函数 module¶
提示
公用模块 异常处理等等
1@异常处理返回类型逻辑型
2def 如果函数发生错误即可提示兵忽略:
3 print("没问题")
4 a = 0/0 # 这个一定报错
pyefun.核心支持库.文本操作 module¶
提示
文本操作
1import unittest
2
3from .文本操作 import *
4
5class TestString(unittest.TestCase):
6
7 def test_1(self):
8 data = 取文本长度("1234")
9 self.assertEqual(data, 4)
10 data = 取文本长度("你好")
11 self.assertEqual(data, 2)
12
13 def test_2(self):
14 data = 取文本左边("1234", 2)
15 self.assertEqual(data, "12")
16 data = 取文本左边("1234", 10)
17 self.assertEqual(data, "1234")
18
19 def test_3(self):
20 data = 取文本右边("1234", 2)
21 self.assertEqual(data, "34")
22 data = 取文本右边("1234", 10)
23 self.assertEqual(data, "1234")
24
25 data = 取文本中间("123abc123", 3,3)
26 self.assertEqual(data, "abc")
27 data = 取文本中间("123abc123", 3,10)
28 self.assertEqual(data, "abc123")
29
30
31 def test_4(self):
32 data = 字符(65)
33 self.assertEqual(data, "A")
34 data = 字符(97)
35 self.assertEqual(data, "a")
36 data = 字符(66)
37 self.assertEqual(data, "B")
38
39 def test_5(self):
40 data = 取代码("A")
41 self.assertEqual(data, 65)
42 data = 取代码("a")
43 self.assertEqual(data, 97)
44
45 def test_6(self):
46 data = 寻找文本("ABCDEFG", "A")
47 self.assertEqual(data, 0)
48 data = 寻找文本("ABCDEFG", "B")
49 self.assertEqual(data, 1)
50 data = 寻找文本("ABCDEFG", "G")
51 self.assertEqual(data, 6)
52 data = 寻找文本("ABCDEFGA", "A", 1)
53 self.assertEqual(data, 7)
54 data = 寻找文本("BBBAACCCAAA", "A", 3)
55 self.assertEqual(data, 3)
56 data = 寻找文本("BBBAACCCAAA", "A", 4)
57 self.assertEqual(data, 4)
58 data = 寻找文本("BBBAACCCAAA", "A", 5, 7)
59 self.assertEqual(data, -1)
60 data = 寻找文本("祖国你好", "你好")
61 self.assertEqual(data, 2)
62
63 def test_7(self):
64 data = 倒找文本("ABCDEFG", "A")
65 self.assertEqual(data, 0)
66 data = 倒找文本("ABCDEFGA", "A")
67 self.assertEqual(data, 7)
68 data = 倒找文本("ABCDEFGAa", "A", 2)
69 self.assertEqual(data, 7)
70
71 def test_8(self):
72 data = 到大写("abc")
73 self.assertEqual(data, "ABC")
74 data = 到小写("ABC")
75 self.assertEqual(data, "abc")
76
77 data = 到全角("abc123456789,./;'[]")
78 self.assertEqual(data, "ａｂｃ１２３４５６７８９，．／；＇［］")
79 data = 到半角("ａｂｃ１２３４５６７８９，．／；＇［］")
80 self.assertEqual(data, "abc123456789,./;'[]")
81
82 def test_9(self):
83 data = 删首空(" abc")
84 self.assertEqual(data, "abc")
85 data = 删尾空("abc ")
86 self.assertEqual(data, "abc")
87 data = 删首尾空(" abc ")
88 self.assertEqual(data, "abc")
89 data = 删全部空(" a b c ")
90 self.assertEqual(data, "abc")
91
92 data = 子文本替换("1234567890123", "123", "")
93 self.assertEqual(data, "4567890")
94
95 data = 子文本替换("1234567890123", "123", "", 1)
96 self.assertEqual(data, "4567890123")
97
98 data = 取空白文本(10)
99 self.assertEqual(data, " ")
100 data = 取重复文本(10, "a")
101 self.assertEqual(data, "aaaaaaaaaa")
102
103 data = 分割文本("1 2 3 4 5 6 7 8 9 0 ", " ")
104 self.assertEqual(data, ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0', ''])
105
106 data = 分割文本("1 2 3 4 5 6 7 8 9 0 ", " ",5)
107 self.assertEqual(data, ['1', '2', '3', '4', '5', '6 7 8 9 0 '])
pyefun.核心支持库.系统处理 module¶
提示
系统处理
1import unittest
2
3from pyefun import *
4
5
6class TestSystemProcessingBase(unittest.TestCase):
7
8 def test_1(self):
9 pass
10 data = 运行("ipconfig")
11 print(data)
12
13 def test_2(self):
14 pass
15 # data = 取鼠标位置()
16 # print(data.x)
17 # print(data.y)
pyefun.核心支持库.日期时间操作 module¶
提示
日期时间操作 符合中国人思维逻辑的日期时间操作实用函数
1import unittest
2
3from .日期时间操作 import *
4
5
6class Test日期时间操作(unittest.TestCase):
7
8 def test_1(self):
9 pass
10 t = 取现行时间()
11 print(t)
12 print(t.到文本("YYYY年MM月DD日 HH时mm分ss秒"))
13 print(t.到文本())
14 print("取年", t.取年())
15 print("取月", t.取月())
16 print("取日", t.取日())
17 print("取小时", t.取小时())
18 print("取分钟", t.取分钟())
19 print("取秒", t.取秒())
20 print("取微妙", t.取微妙())
21 print("取每周的第几天", t.取每周的第几天())
22 print("取每年的第几周", t.取每年的第几周())
23 print("取每年的第几天", t.取每年的第几天())
24 print("取每月的第几周", t.取每月的第几周())
25 print("取日期", t.取日期())
26 t.设置年月日(2020, 1, 1)
27 print(t.到文本())
28 t.设置时分秒(1, 1, 1)
29 print(t.到文本())
30 t = t.增减日期时间(
31 years=1,
32 months=1,
33 days=1,
34 hours=1,
35 minutes=1,
36 seconds=1,
37 )
38 print("增减日期时间", t.到文本())
39
40 t1 = 取现行时间()
41 t2 = t1.copy()
42 print("取现行时间", t1.到文本())
43 t2 = t2.增减日期时间(
44 years=1,
45 months=1,
46 days=1,
47 hours=1,
48 minutes=1,
49 seconds=1,
50 ).datetime()
51 print("t2", t2)
52 print("t1", t1)
53 print("取时间间隔", t1.取时间间隔(t2))
54
55 t2 = 取现行时间()
56 t2 = t2.增减日期时间(
57 years=-1,
58 months=1,
59 days=1,
60 hours=1,
61 minutes=1,
62 seconds=1,
63 )
64 print("取友好时间", t2.取友好时间())
65
66 t = 取现行时间().取时间戳()
67 print(t)
68
69
70
71 t = 日期时间("2021-05-17 12:01:42").取时间戳()
72 print(t)
73
74 t = 日期到时间戳("2021-05-17 12:01:42")
75 print(t)
76
77 def test_2(self):
78 list = 时间迭代("2021-01-17", "2021-05-27")
79 for i in list.range('months'):
80 print(i.to_datetime_string())
81
82 # for i in list.range('days'):
83 # print(i.to_datetime_string())
84
85 def test_3(self):
86 data = date("Y-m-d H:i:s", now().取时间戳())
87 print(data)
88 def test_4(self):
89 print(取现行时间2('%d %H:%M:%S',True))
90
91 def test_5(self):
92 t = 日期时间(取现行时间戳())
93 print(t)
94 print(t.取时间戳())
- pyefun.核心支持库.日期时间操作.取现行时间2(格式, 自定义=False)[源代码]¶
自定义 %Y-%m-%d %H:%M:%S (yyyy-MM-dd HH:mm:ss)这种格式不可以 格式1 = 2020-10-09 22:11:52 格式2 = 2020-10-09 格式3= 22:13:37 格式4= 2020年10月17日18时27分40秒
%a # 本地(local) 简化星期名称 %A # 本地完整星期名称 %b # 本地简化月份名称 %B # 本地完整月份名称 %c # 本地相应的日期和时间表示 %d # 一个月中的第几天（01-31） %H # 一天中的第几个小时（24小时制00-23） %I # 第几个小时（12小时制01-12） %j # 一年中的第几天（001-366） %m # 月份（01-12） %M # 分钟数（00-59） %p # 本地am或pm的相应符 %S # 秒（01-60） %U # 一年中的星期数。（00-53 星期天是一个星期的开始）第一个星期天之前的所有天数都放在第0周 %w # 一个星期中的第几天（0-6 0是星期天） %W # 和%U基本相同，不同的是%W以星期一为一个星期的开始 %x # 本地相应日期 %X # 本地相应时间 %y # 去掉世纪的年份（00-99） %Y # 完整的年份 %z # 时区的名字
pyefun.核心支持库.类型转换 module¶
提示
类型转换
1import unittest
2
3from pyefun import *
4
5
6class TestTypeConv(unittest.TestCase):
7
8 def test_1(self):
9 pass
10 data = 到文本(b"123")
11 print(type(data), data)
12
13 data = 到字节集("123")
14 print(type(data), data)
15
16 data = 到整数("123.123")
17 print(type(data), data)
18
19 data = 到数值("123.123")
20 print(type(data), data)
21
22 data = 到时间("2021-05-18")
23 print(type(data), data)
24
25 def test_2(self):
26 data = json到文本({"a": 1, "b": 2,"name":"你好"})
27 print(data)
28 data = json解析(data)
29 print(repr(data))
30 print(data['a'])
31 print(data['b'])
32 print(data['name'])
pyefun.核心支持库.时钟 module¶
提示
时钟
易语言的时钟组件
实现了 时钟周期事件
使用装饰器设置定时任务 函数内返回 false则停止时钟
1import unittest
2
3from .时钟 import *
4
5
6class Test时钟(unittest.TestCase):
7
8 def test_1(self):
9 pass
10
11 @时钟周期事件(时钟周期=1000)
12 def 定时任务():
13 print("定时任务")
14 # return True
15 return False
16
17 def test_2(self):
18 pass
19
20 def 定时任务():
21 print("定时任务")
22 # return True
23 return False
24 时钟(定时任务, 时钟周期=1000)
1 @时钟周期事件(时钟周期=1000)
2 def 定时任务():
3 print("定时任务")
4 # return True
5 return False
6
7 定时任务2运行状态 = True
8
9 def 定时任务2():
10 print(1111111111111,定时任务2运行状态)
11 return 定时任务2运行状态
12 # return False
13
14
15 时钟(定时任务2, 时钟周期=2000)
16
17 @时钟周期事件(时钟周期=5000)
18 def 定时任务3():
19 global 定时任务2运行状态
20 print("把时钟停止掉")
21 定时任务2运行状态 = False
22 return False
核心易函数支持库¶
pyefun.核心易函数支持库.实用函数 module¶
- pyefun.核心易函数支持库.实用函数.写环境变量(环境变量名称: str, 欲写入内容: str) bool[源代码]¶
调用格式： 〈逻辑型〉 写环境变量 （文本型 环境变量名称，文本型 欲写入内容） - 系统核心支持库->环境存取
英文名称：PutEnv
修改或建立指定的操作系统环境变量。成功返回真，失败返回假。本命令为初级命令。
参数<1>的名称为“环境变量名称”，类型为“文本型（text）”。
参数<2>的名称为“欲写入内容”，类型为“文本型（text）”。
操作系统需求： Windows、Linux
- pyefun.核心易函数支持库.实用函数.取主机名()[源代码]¶
调用格式： 〈文本型〉 取主机名 （） - 系统核心支持库->网络通信
英文名称：GetHostName
返回本机的主机名，用作在网络通讯中标志本机地址。本命令为初级命令。
操作系统需求： Windows
- 返回
- pyefun.核心易函数支持库.实用函数.取执行文件名()[源代码]¶
调用格式： 〈文本型〉 取执行文件名 （） - 系统核心支持库->环境存取
英文名称：GetRunFileName
取当前被执行的易程序文件的名称。本命令为初级命令。
操作系统需求： Windows
- 返回
commonlyUtil.py
- pyefun.核心易函数支持库.实用函数.标准输入()[源代码]¶
调用格式： 〈文本型〉 标准输入 （［逻辑型 是否回显］） - 系统核心支持库->控制台操作
英文名称：fgets
在标准输入设备上请求输入最多包含2048个字符的一行文本，返回用户所输入的内容。注意本命令只能在控制台程序中使用。本命令为初级命令。
参数<1>的名称为“是否回显”，类型为“逻辑型（bool）”，可以被省略。本参数决定输入时是否显示所输入字符，为假不显示，为真显示。如果被省略，默认值为真，即回显。可以通过将本参数设置为假以输入密码等特殊信息。
操作系统需求： Windows、Linux
- pyefun.核心易函数支持库.实用函数.标准输出(*args)[源代码]¶
调用格式： 〈无返回值〉 标准输出 （［整数型 输出方向］，通用型 欲输出内容，… ） - 系统核心支持库->控制台操作
英文名称：fputs
在标准输出设备或标准错误设备上输出指定的内容，注意本命令只能在控制台程序中使用。本命令为初级命令。命令参数表中最后一个参数可以被重复添加。
参数<1>的名称为“输出方向”，类型为“整数型（int）”，可以被省略。本参数提供内容所输出到的设备，可以为以下常量值之一： 1、#标准输出设备； 2、#标准错误设备。如果省略本参数，默认为“#标准输出设备”。
参数<2>的名称为“欲输出内容”，类型为“通用型（all）”。本参数只能为文本、数值、逻辑值或日期时间。如果内容为文本且包含多行，可在各行之间用回车符 (即“字符 (13)”)、换行符 (即“字符 (10)”) 或回车换行符的组合 (即：“字符 (13) + 字符 (10)”) 来分隔。
操作系统需求： Windows、Linux
- pyefun.核心易函数支持库.实用函数.结束(*args, **kwargs)[源代码]¶
调用格式： 〈无返回值〉 结束 （） - 系统核心支持库->流程控制
英文名称：end
本命令结束当前易程序的运行。本命令为初级命令。
操作系统需求： Windows、Linux、Unix
- pyefun.核心易函数支持库.实用函数.读环境变量(环境变量名称: str) str[源代码]¶
调用格式： 〈文本型〉 读环境变量 （文本型 环境变量名称） - 系统核心支持库->环境存取
英文名称：GetEnv
返回文本，它关连于一个操作系统环境变量。成功时返回所取得的值，失败则返回空文本。本命令为初级命令。
参数<1>的名称为“环境变量名称”，类型为“文本型（text）”。
操作系统需求： Windows、Linux
pyefun.核心易函数支持库.文本操作实用函数 module¶
提示
文本操作实用函数
- pyefun.核心易函数支持库.文本操作实用函数.文本_TAB转空格(欲处理文本: str, 转换的数量: int = 8) str[源代码]¶
把字符串中的 tab 符号（ ）转换为空格，如不指定参数，默认的空格数是 tabsize=8
- pyefun.核心易函数支持库.文本操作实用函数.文本_判断文本前缀(欲处理文本: str, 开头的文本: str, 开始的位置: int = 0, 结束的位置: int = 0) bool[源代码]¶
如果字符串为指定的开头返回True，否则返回False
pyefun.核心易函数支持库.正则表达式 module¶
提示
正则表达式
- class pyefun.核心易函数支持库.正则表达式.正则[源代码]¶
基类：
object提示
正则的匹配模式
re.A
re.ASCII
让 w, W, , B, d, D, s 和 S 只匹配ASCII，而不是Unicode。这只对Unicode样式有效，会被byte样式忽略。相当于前面语法中的内联标志 (?a) 。
注意，为了保持向后兼容， re.U 标记依然存在（还有他的同义 re.UNICODE 和嵌入形式 (?u) ) ， 但是这些在 Python 3 是冗余的，因为默认字符串已经是Unicode了（并且Unicode匹配不允许byte出现)。
re.DEBUG
显示编译时的debug信息，没有内联标记。
re.I
re.IGNORECASE
进行忽略大小写匹配；表达式如 [A-Z] 也会匹配小写字符。Unicode匹配（比如 Ü 匹配 ü）同样有用，除非设置了 re.ASCII 标记来禁用非ASCII匹配。当前语言区域不会改变这个标记，除非设置了 re.LOCALE 标记。这个相当于内联标记 (?i) 。
注意，当设置了 IGNORECASE 标记，搜索Unicode样式 [a-z] 或 [A-Z] 的结合时，它将会匹配52个ASCII字符和4个额外的非ASCII字符： ‘İ’ (U+0130, 拉丁大写的 I 带个点在上面), ‘ı’ (U+0131, 拉丁小写没有点的 I ), ‘ſ’ (U+017F, 拉丁小写长 s) and ‘K’ (U+212A, 开尔文符号).如果使用 ASCII 标记，就只匹配 ‘a’ 到 ‘z’ 和 ‘A’ 到 ‘Z’ 。
re.L
re.LOCALE
由当前语言区域决定 w, W, , B 和大小写敏感匹配。这个标记只能对byte样式有效。这个标记不推荐使用，因为语言区域机制很不可靠，它一次只能处理一个 “习惯”，而且只对8位字节有效。Unicode匹配在Python 3 里默认启用，并可以处理不同语言。 这个对应内联标记 (?L) 。
在 3.6 版更改: re.LOCALE 只能用于byte样式，而且不能和 re.ASCII 一起用。
在 3.7 版更改: 设置了 re.LOCALE 标记的编译正则对象不再在编译时依赖语言区域设置。语言区域设置只在匹配的时候影响其结果。
re.M
re.MULTILINE
设置以后，样式字符 ‘^’ 匹配字符串的开始，和每一行的开始（换行符后面紧跟的符号）；样式字符 ‘$’ 匹配字符串尾，和每一行的结尾（换行符前面那个符号）。默认情况下，’^’ 匹配字符串头，’$’ 匹配字符串尾。对应内联标记 (?m) 。
re.S
re.DOTALL
让 ‘.’ 特殊字符匹配任何字符，包括换行符；如果没有这个标记，’.’ 就匹配 除了 换行符的其他任意字符。对应内联标记 (?s) 。
re.X
re.VERBOSE
这个标记允许你编写更具可读性更友好的正则表达式。通过分段和添加注释。空白符号会被忽略，除非在一个字符集合当中或者由反斜杠转义，或者在 *?, (?: or (?P<…> 分组之内。当一个行内有 # 不在字符集和转义序列，那么它之后的所有字符都是注释。
例如正则表达式 d + # 这是注释
- 允许注释 = 64¶
- 只匹配ASCII = 256¶
- 只匹配Unicode = 32¶
- 多行模式 = 8¶
- 忽略大小写 = 2¶
- 点dot匹配全部字符 = 16¶
- 语言依赖 = 4¶
- class pyefun.核心易函数支持库.正则表达式.正则表达式(正则表达式文本: str = '', 模式=RegexFlag.None)[源代码]¶
基类：
objectpython的正则表达式 https://docs.python.org/zh-cn/3/library/re.html#re.compile
例子
print(正则表达式(r”d+”, 正则.多行模式 | 正则.忽略大小写).搜索(“123456789”)) print(正则表达式(r”d+”, 正则.多行模式 | 正则.忽略大小写).替换(“替换”, “123456798”))
- class pyefun.核心易函数支持库.正则表达式.正则表达式类(正则表达式文本: str = '', 被搜索的文本: str = '', 是否区分大小写=False, 是否匹配多行=True)[源代码]¶
基类：
object精易模块的正则表达式类命名方式
坦率讲 该类是为了精易模块的正则表达式代码能够直接迁移
python有更好用的方式实现
- 传统易语言代码的实现 取子匹配数量 取子匹配文本 在python里面很多余 为了兼容实现了
zz = 正则表达式类() zz.创建(r”d+”, str, 是否区分大小写=True, 是否匹配多行=True) for i in range(zz.取匹配数量()):
print(“取匹配文本”, zz.取匹配文本(i)) print(“取子匹配数量”, zz.取子匹配数量()) for k in range(zz.取子匹配数量()):
print(“取子匹配文本 i= %s k= %s” % (i, k), zz.取子匹配文本(i, k))
- python的实现
正则结果 = 正则表达式类(r”d+”, str, 是否区分大小写=True, 是否匹配多行=True).取结果()
建议使用 正则表达式 代码更加简单 本类 只是为了兼容精易模块的代码降低学习成本
print(正则表达式(r”d+”, 正则.多行模式 | 正则.忽略大小写).搜索(“123456789”)) print(正则表达式(r”d+”, 正则.多行模式 | 正则.忽略大小写).替换(“替换”, “123456798”))
pyefun.核心易函数支持库.正则表达式实用函数 module¶
提示
正则表达式
pyefun.核心易函数支持库.网络请求 module¶
提示
网络请求 eRequests 是实用的http请求模块 轻松配置cookie文件保存 全局请求头信息 代理ip ehttp = eRequests(cookies文件路径=”cookie文件路径”,全局头信息=”User-Agent: pyefun”) ehttp.设置全局HTTP代理(“127.0.0.1:11111”)
返回文本 = ehttp.get(“http://127.0.0.1:9000/1.php”) print(返回文本.文本)
返回文本 = ehttp.post(“http://127.0.0.1:9000/post.php”, 发送文本={“aa”: 1, “bb”: 2, “cc”: 3}) print(返回文本.文本)
# 文件上传 字节集 = 读入文件(“share.png”) 返回文本 = ehttp.post(“http://127.0.0.1:9000/post.php”, 发送文本={“aa”: 1, “bb”: 2, “cc”: 3},
上传文件={‘upload’: (‘code.png’, 字节集, ‘image/png’)})
- class pyefun.核心易函数支持库.网络请求.eRequests(cookies文件路径='', 访问失败重试次数=0, 全局头信息='')[源代码]¶
基类：
object- cookies文件路径 = ''¶
- req()¶
Returns a
Sessionfor context-management.1.0.0 版后已移除: This method has been deprecated since version 1.0.0 and is only kept for backwards compatibility. New code should use
Sessionto create a session. This may be removed at a future date.- 返回类型
Session
- 全局HTTP代理 = None¶
- 全局头信息 = ''¶
- 访问(url: str, 访问方法: str = 'GET', 发送文本: str = '', 附加头信息: str = '', 允许重定向=True, 超时=15, 不使用代理访问=False, 上传文件=None)[源代码]¶
- 调试信息 = False¶
- 默认头信息 = 'Accept : */*\nUser-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36\nContent-Type: application/x-www-form-urlencoded'¶
pyefun.核心易函数支持库.时间统计 module¶
提示
时间工具类 时间统计
pyefun.核心易函数支持库.线程操作 module¶
提示
线程操作有线程池
- class pyefun.核心易函数支持库.线程操作.线程[源代码]¶
基类：
object- 取运行中的线程对象(**kwargs)¶
- 取运行的线程数(**kwargs)¶
- 启动线程(**kwargs)¶
- 等待线程结束(**kwargs)¶
- 线程是否在运行(**kwargs)¶
- pyefun.核心易函数支持库.线程操作.线程_取当前线程()[源代码]¶
返回与Thread调用方的控制线程相对应的当前对象。如果未通过threading模块创建调用者的控制 线程，则返回功能有限的虚拟线程对象。
- pyefun.核心易函数支持库.线程操作.线程_取所有活动对象()[源代码]¶
返回Thread当前所有活动对象的列表。该列表包括守护线程，由创建的伪线程对象 current_thread()和主线程。它不包括终止的线程和尚未启动的线程。
- pyefun.核心易函数支持库.线程操作.线程_取线程标识符()[源代码]¶
返回当前线程的“线程标识符”。这是一个非零整数。它的值没有直接的意义。它旨在用作魔术Cookie，例如用于索引线程特定数据的字典。当一个线程退出并创建另一个线程时，线程标识符可以被回收。
- class pyefun.核心易函数支持库.线程操作.线程池(最大线程数量, 投递任务时阻塞=True, 线程名称前缀='', 线程初始化函数=None, 初始化函数参数=())[源代码]¶
基类：
concurrent.futures.thread.ThreadPoolExecutor当有大量并发任务需要处理时，再使用传统的多线程就会造成大量的资源创建销毁导致服务器效率的下降。这时候，线程池就派上用场了。线程池技术为线程创建、销毁的开销问题和系统资源不足问题提供了很好的解决方案。
用法
- def 线程初始化(data):
print(“初始化”, data, 取当前线程名称())
互斥锁 = 互斥锁() def 任务函数(i):
time.sleep(1) 互斥锁.进入() print(i) 互斥锁.退出() return “返回参数” + str(i)
- def 任务完成(future):
print(“当前线程”, 取当前线程名称()) print(“future”, future.result())
任务池 = 线程池(4, “pyefun”, 线程初始化, [0])
- for url in range(10):
future = 任务池.投递任务(任务函数, url) 任务池.设置任务结束回调函数(future, 任务完成)
任务池.等待()
pyefun.核心易函数支持库.进程池 module¶
提示
进程池使用方法
方便的使用python开启多进程
- class pyefun.核心易函数支持库.进程池.进程(子程序名, 元组参数=(), 字典参数={}, 进程名=None)[源代码]¶
基类：
object
pyefun.核心易函数支持库.json函数 module¶
json编码解码飞快的库
https://github.com/ijl/orjson 还有 https://github.com/ultrajson/ultrajson
pyefun.核心易函数支持库.环境变量 module¶
提示
环境变量
读入.env并且加载到系统环境变量中
- pyefun.核心易函数支持库.环境变量.环境变量_获取(环境变量名称: str) str[源代码]¶
返回文本，它关连于一个操作系统环境变量。成功时返回所取得的值，失败则返回空文本。本命令为初级命令。
pyefun.核心易函数支持库.配置项 module¶
提示
配置项 读取ini配置文件
pyefun.核心易函数支持库.网络实用函数 module¶
提示
网络操作
模块¶
pyefun.模块.javascript引擎 module¶
提示
JavaScript引擎
在python中运行JavaScript代码
python调用js的函数
需要安装 pip install PyExecJS
需要安装 node 环境
PyV8 = “PyV8”
Node = “Node”
JavaScriptCore = “JavaScriptCore”
SpiderMonkey = “SpiderMonkey”
JScript = “JScript”
PhantomJS = “PhantomJS”
SlimerJS = “SlimerJS”
Nashorn = “Nashorn”
- class pyefun.模块.javascript引擎.javscript(运行环境名称: str = 'Node')[源代码]¶
基类：
objectpython调用js的函数 需要安装 pip install PyExecJS 需要安装 node 环境
PyV8 = “PyV8” Node = “Node” JavaScriptCore = “JavaScriptCore” SpiderMonkey = “SpiderMonkey” JScript = “JScript” PhantomJS = “PhantomJS” SlimerJS = “SlimerJS” Nashorn = “Nashorn”
pyefun.模块.二维码 module¶
pyefun.模块.协程池 module¶
提示
asyncio 实现的协程池 asyncio为python原生支持
调用时需要引入
import asyncio
还有另外一个版本的实现 协程池Gevent 为 Gevent实现协程
- class pyefun.模块.协程池.协程池(协程数量=1, 投递任务时阻塞=True, 线程池数量=None, loop=None)[源代码]¶
基类：
object支持动态添加任务
支持停止事件循环
支持最大协程数：maxsize
支持进度条
实时获取剩余协程数
支持阻塞协程，需要线程进行支持，注意设置线程池：pool_maxsize
- async async_thread_pool_func(block_func, *args, thread_pool=True)[源代码]¶
信号代理 线程池代理
loop: asyncio.AbstractEventLoop
- 参数
block_func – 阻塞任务
args – 参数
thread_pool – 是否使用自定义线程池
- 返回
- property running¶
获取剩余协程数 :return:
- start_loop(loop, pool_maxsize=None)[源代码]¶
运行事件循环 开启新线程 :param loop: 协程 :param pool_maxsize: 线程池大小，默认为系统内核数 :return:
pyefun.模块.协程池Gevent module¶
提示
gevent实现的协程池
调用时需要引入猴子补丁 需要安装gevent
pip install gevent
代码中需要引入猴子补丁
import gevent from gevent import monkey monkey.patch_all()
还有另一个版本的协程池实现 协程池 为python原生支持的实现
pyefun.模块.窗口操作 module¶
pyefun.模块.进度显示 module¶
提示
进度显示 使您可以测量和打印迭代过程的进度。这可以通过可迭代的界面或使用手动API来完成。使用可迭代的接口是最常见的。
pyefun.模块.缓存工具 module¶
提示
缓存工具 用于快速缓存函数结果的
pyefun.模块.定时任务 module¶
定时任务
需要安装第三方模块
pip install 定时任务
- pyefun.模块.定时任务.时钟_一次性运行(后台模式=False, 子程序=None, 元组参数=None, 字典参数=None, 序号=None, datetime运行的日期=None, 同时允许的线程数=0)[源代码]¶
设置最大同时允许线程数可以解决 程序本身允许时间超过循环的时间, 运行时间可以是datetime 或 文本型时间 scheduler.add_job(my_job, ‘date’, run_date=’2009-11-06 16:30:05’, args=[‘测试任务’])
- pyefun.模块.定时任务.时钟_循环间隔模式(后台模式=False, 子程序=None, 元组参数=None, 字典参数=None, 序号=None, weeks周=0, days天=0, hours小时=0, minutes分钟=0, seconds秒钟=0, 开始时间='2020-01-01 00:00:01', 结束时间=None, 延时执行=None, 同时允许的线程数=0)[源代码]¶
设置最大同时允许线程数可以解决 程序本身允许时间超过循环的时间, 例子,scheduler .add_job(job_func, ‘interval’, minutes=2, start_date=’2019-04-15 17:00:00’ , end_date=’2019-12-31 24:00:00’)
pyefun.模块.winapi module¶
pyefun.模块.通用实用函数 module¶
提示
实用函数
- class pyefun.模块.通用实用函数.临时目录[源代码]¶
基类：
ubelt.util_path.TempDir用于创建和清理临时目录的上下文。
#Example: # with 临时目录() as self: # dpath = self.dpath # print(dpath) # assert 文件是否存在(dpath) # assert not 文件是否存在(dpath)
#Example: # self = 临时目录() # dpath = self.ensure() # assert exists(dpath) # self.cleanup() # assert not exists(dpath)
- class pyefun.模块.通用实用函数.分块(items, 分块数量=None, 创建块数=None, 创建数量=None, 边界模式='none')[源代码]¶
基类：
ubelt.util_list.chunks
- pyefun.模块.通用实用函数.取缓存目录(name)[源代码]¶
# The resource root directory is # ~/AppData/Roaming on Windows, # ~/.config on Linux and ~/Library/Application Support on Mac. # The cache root directory is ~/AppData/Local on Windows, # ~/.config on Linux and ~/Library/Caches on Mac.
- pyefun.模块.通用实用函数.字典_取最小值(indexable, key=None)[源代码]¶
# assert argmin({‘a’: 3, ‘b’: 2, ‘c’: 100}) == ‘b’ # assert argmin([‘a’, ‘c’, ‘b’, ‘z’, ‘f’]) == 0 # assert argmin([[0, 1], [2, 3, 4], [5]], key=len) == 2 # assert argmin({‘a’: 3, ‘b’: 2, 3: 100, 4: 4}) == ‘b’ # assert argmin(iter([‘a’, ‘c’, ‘A’, ‘z’, ‘f’])) == 2
- pyefun.模块.通用实用函数.数组_去重复(items, key=None)[源代码]¶
# import ubelt as ub # import six # items = [‘A’, ‘a’, ‘b’, ‘B’, ‘C’, ‘c’, ‘D’, ‘e’, ‘D’, ‘E’] # unique_items = list(ub.unique(items, key=six.text_type.lower)) # assert unique_items == [‘A’, ‘b’, ‘C’, ‘D’, ‘e’] # unique_items = list(ub.unique(items)) # assert unique_items == [‘A’, ‘a’, ‘b’, ‘B’, ‘C’, ‘c’, ‘D’, ‘e’, ‘E’]
- pyefun.模块.通用实用函数.数组_取唯一值的索引(items, key=None)[源代码]¶
# import ubelt as ub # import six # items = [‘A’, ‘a’, ‘b’, ‘B’, ‘C’, ‘c’, ‘D’, ‘e’, ‘D’, ‘E’] # unique_items = list(ub.unique(items, key=six.text_type.lower)) # assert unique_items == [‘A’, ‘b’, ‘C’, ‘D’, ‘e’] # unique_items = list(ub.unique(items)) # assert unique_items == [‘A’, ‘a’, ‘b’, ‘B’, ‘C’, ‘c’, ‘D’, ‘e’, ‘E’]
- pyefun.模块.通用实用函数.数组_取唯一值的逻辑值(items, key=None)[源代码]¶
# import ubelt as ub # import six # items = [‘A’, ‘a’, ‘b’, ‘B’, ‘C’, ‘c’, ‘D’, ‘e’, ‘D’, ‘E’] # unique_items = list(ub.unique(items, key=six.text_type.lower)) # assert unique_items == [‘A’, ‘b’, ‘C’, ‘D’, ‘e’] # unique_items = list(ub.unique(items)) # assert unique_items == [‘A’, ‘a’, ‘b’, ‘B’, ‘C’, ‘c’, ‘D’, ‘e’, ‘E’]
- pyefun.模块.通用实用函数.数组_取最小值(indexable, key=None)[源代码]¶
# assert argmin({‘a’: 3, ‘b’: 2, ‘c’: 100}) == ‘b’ # assert argmin([‘a’, ‘c’, ‘b’, ‘z’, ‘f’]) == 0 # assert argmin([[0, 1], [2, 3, 4], [5]], key=len) == 2 # assert argmin({‘a’: 3, ‘b’: 2, 3: 100, 4: 4}) == ‘b’ # assert argmin(iter([‘a’, ‘c’, ‘A’, ‘z’, ‘f’])) == 2
- pyefun.模块.通用实用函数.数组_是否全部相同(iterable, eq=<built-in function eq>)[源代码]¶
#allsame([1, 1, 1, 1]) # True #allsame([]) # True #allsame([0, 1]) # False #iterable = iter([0, 1, 1, 1]) #next(iterable) #allsame(iterable) # True #allsame(range(10)) # False #allsame(range(10), lambda a, b: True) # True
- pyefun.模块.通用实用函数.数组_构建逻辑值列表(indices, maxval=None)[源代码]¶
# import ubelt as ub #indices = [0, 1, 4] #mask = ub.boolmask(indices, maxval=6) #assert mask == [True, True, False, False, True, False] #mask = ub.boolmask(indices) #assert mask == [True, True, False, False, True]
- pyefun.模块.通用实用函数.文本_水平合并(args, sep='')[源代码]¶
# import ubelt as ub # B = ub.repr2([[1, 2], [3, 457]], nl=1, cbr=True, trailsep=False) # C = ub.repr2([[5, 6], [7, 8]], nl=1, cbr=True, trailsep=False) # args = [‘A = ‘, B, ‘ * ‘, C] # print(文本_水平合并(args)) # A = [[1, 2], * [[5, 6], # [3, 457]] [7, 8]]
- pyefun.模块.通用实用函数.查找可执行文件(名称, 匹配所有=False, 路径=None)[源代码]¶
# 查找可执行文件(‘ls’) # 查找可执行文件(‘ping’) # assert 查找可执行文件(‘which’) == 查找可执行文件(查找可执行文件(‘which’)) # 查找可执行文件(‘which’, 匹配所有=True) # 查找可执行文件(‘ping’, 匹配所有=True) # 查找可执行文件(‘cmake’, 匹配所有=True) # 查找可执行文件(‘nvcc’, 匹配所有=True) # 查找可执行文件(‘noexist’, 匹配所有=True)
- pyefun.模块.通用实用函数.查找文件或目录(名称, 路径=None, 精确=False)[源代码]¶
# list(查找文件或目录(‘ping’, exact=True)) # list(查找文件或目录(‘bin’)) # list(查找文件或目录(‘bin’)) # list(查找文件或目录(‘cc’)) # list(查找文件或目录(‘cmake*’))
pyefun.人工智能.通用文字识别 module¶
编码解码¶
更多模块¶
excel操作xls¶
提示
xlwt 和 wlrd 封装的excel操作
可能需要
pip install xlutils pip install xlwt pip install xlrd
- class pyefun.excel.excel_xlwr.ExcelSheet(sheet: Optional[xlrd.sheet.Sheet] = None, sheetw: Optional[xlwt.Worksheet.Worksheet] = None)[源代码]¶
基类：
object
- class pyefun.excel.excel_xlwr.Excel写工作簿(wb: xlwt.Workbook.Workbook = <xlwt.Workbook.Workbook object>)[源代码]¶
基类：
object
- class pyefun.excel.excel_xlwr.Excel字体[源代码]¶
基类：
xlwt.Formatting.Font- property 下划线¶
- property 删除线¶
- property 大小¶
- property 字体名称¶
- property 斜体¶
- property 粗体¶
- property 轮廓¶
- property 阴影¶
- property 颜色¶
- class pyefun.excel.excel_xlwr.Excel对齐方式[源代码]¶
基类：
xlwt.Formatting.Alignment- 垂直_两端对齐 = 3¶
- 垂直_分散 = 4¶
- 垂直_居中对齐 = 1¶
- 垂直_底端对齐 = 2¶
- 垂直_顶端对齐 = 0¶
- property 垂直方向¶
- 水平_两端对齐 = 5¶
- 水平_中心选择 = 6¶
- 水平_分散 = 7¶
- 水平_右对齐 = 3¶
- 水平_填满 = 4¶
- 水平_居中对齐 = 2¶
- 水平_左对齐 = 1¶
- 水平_常规 = 0¶
- property 水平方向¶
- property 自动换行¶
- class pyefun.excel.excel_xlwr.Excel样式[源代码]¶
基类：
xlwt.Style.XFStyle- property 字体¶
- property 对齐方式¶
- property 背景颜色¶
- property 边框¶
- pyefun.excel.excel_xlwr.创建Excel字体(字体名称='宋体', 轮廓=False, 阴影=False, 颜色=0, 大小=12, 下划线=False, 斜体=False, 粗体=False, 删除线=False)[源代码]¶
- pyefun.excel.excel_xlwr.创建Excel样式(字体=<pyefun.excel.excel_xlwr.Excel字体 object>, 对齐方式=<pyefun.excel.excel_xlwr.Excel对齐方式 object>, 边框=<xlwt.Formatting.Borders object>, 背景颜色=<xlwt.Formatting.Pattern object>, 保护=<xlwt.Formatting.Protection object>)[源代码]¶
- pyefun.excel.excel_xlwr.创建Excel背景颜色(颜色索引=None)[源代码]¶
0=黑色，1=白色，2=红色，3=绿色，4=蓝色，5=黄色，6=品红，7=青色，16=褐红色，17=深绿色，18=深蓝色，19=深黄色，几乎棕色），20=深品红，21=青色，22=浅灰色，23=深灰色
excel操作xls xlsx¶
提示
openpyxl 封装的excel操作
需要安装 openpyxl
pip install openpyxl
- class pyefun.excel.excel_openpyxl.Excel[源代码]¶
基类：
object- 置单元格字体风格(行: int, 列: int, 字体名称='微软雅黑', 字体大小=11, 加粗=False, 斜体=False, 删除线=False, 颜色='ffffff')[源代码]¶
白=ffffff 红=ff0000 黄=ffff00 绿=33ff00 蓝=0000ff 黑=000000 紫=9900ff
- 置单元格对齐方式(行: int, 列: int, 对齐方式=<openpyxl.styles.alignment.Alignment object> Parameters: horizontal='justify', vertical='justify', textRotation=0, wrapText=None, shrinkToFit=None, indent=0.0, relativeIndent=0.0, justifyLastLine=None, readingOrder=0.0)[源代码]¶
horizontal代表水平方向，可以左对齐left，还有居中center和右对齐right，分散对齐distributed，跨列居中centerContinuous，两端对齐justify，填充fill，常规general
vertical代表垂直方向，可以居中center，还可以靠上top，靠下bottom，两端对齐justify，分散对齐distributed
另外还有自动换行：wrap_text，这是个布尔类型的参数，这个参数还可以写作wrapText
- 置单元格背景颜色(行: int, 列: int, 颜色='ffffff')[源代码]¶
# 1开始 注意：fill_type为填充类型，如果不写的话，则没有效果。 默认纯色填充 颜色代号 白=ffffff 红=ff0000 黄=ffff00 绿=33ff00 蓝=0000ff 黑=000000 紫=9900ff
- 置单元格边框(行: int, 列: int, left=<openpyxl.styles.borders.Side object> Parameters: style='thin', color=<openpyxl.styles.colors.Color object> Parameters: rgb='00000000', indexed=None, auto=None, theme=None, tint=0.0, type='rgb', right=<openpyxl.styles.borders.Side object> Parameters: style='thin', color=<openpyxl.styles.colors.Color object> Parameters: rgb='00000000', indexed=None, auto=None, theme=None, tint=0.0, type='rgb', top=<openpyxl.styles.borders.Side object> Parameters: style='thin', color=<openpyxl.styles.colors.Color object> Parameters: rgb='00000000', indexed=None, auto=None, theme=None, tint=0.0, type='rgb', bottom=<openpyxl.styles.borders.Side object> Parameters: style='thin', color=<openpyxl.styles.colors.Color object> Parameters: rgb='00000000', indexed=None, auto=None, theme=None, tint=0.0, type='rgb')[源代码]¶
浏览器类自动化测试¶
Submodules¶
浏览器类自动化测试¶
提示
需要安装 selenium chrome浏览器或者Firefox浏览器
本地调试下需要安装 chrome浏览器 chromedriver驱动 或者 Firefox geckodriver驱动
window macos ubuntu 使用 浏览器初始化本地环境() 就可以自动检测驱动和自动下载配置
使用 docker 部署远程浏览器 无需安装驱动
部署时建议使用docker部署远程浏览器
pip install selenium
https://chromedriver.chromium.org/
https://chromedriver.storage.googleapis.com/index.html?path=90.0.4430.24/
docker run --name chrome -d -p 4444:4444 -p 5900:5900 -v /dev/shm:/dev/shm selenium/standalone-chrome-debug:3.141.59-20210422
docker run --name chrome -d -p 4444:4444 -p 5900:5900 selenium/standalone-chrome-debug:3.141.59-20210422
VNC Viewer https://www.realvnc.com/en/connect/download/viewer/
127.0.0.1:5900 即可连接至远程桌面
1import unittest
2import warnings
3
4from .seleniumUtil import *
5from pyefun import *
6
7
8class TestseleniumUtil(unittest.TestCase):
9
10 def test_1(self):
11 pass
12 浏览器初始化本地环境()
13
14 浏览器 = 浏览器类()
15 浏览器.打开chrome()
16
17 浏览器.浏览网页("https://www.baidu.com")
18 print(浏览器.取页面标题())
19 print(浏览器.取名称())
20 # print(浏览器.取页面链接())
21 # print(浏览器.取页面源码())
22 with 时间统计("就绪"):
23 print(浏览器.等待元素显示(5, "s_ipt"))
24
25 延时(1)
26
27 搜索输入框 = 浏览器.取元素从id("kw")
28 百度一下按钮 = 浏览器.取元素从id("su")
29
30 搜索输入框.输入("pyefun")
31 百度一下按钮.点击()
32
33 延时(1)
34
35 with 时间统计("结果就绪"):
36 print(浏览器.等待元素显示(5, "result"))
37
38 搜索结果 = 浏览器.取元素从class_name("result")
39 print("搜索结果多少条", len(搜索结果))
40 for 元素 in 搜索结果:
41 print(元素.取文本())
42 # print(元素.取源码())
43
44 延时(1)
45 浏览器.退出()
46
47 def test_2(self):
48 pass
49
50 warnings.simplefilter('ignore', ResourceWarning) # 屏蔽一堆错误
51
52 浏览器 = 浏览器类()
53 远程浏览器地址 = "http://127.0.0.1:4444/wd/hub"
54 while 浏览器.远程浏览器是否就绪(远程浏览器地址) == False:
55 延时(1)
56 print("浏览器未就绪")
57
58 浏览器.获取远程chrome(远程浏览器地址)
59
60 浏览器.浏览网页("https://www.baidu.com")
61 print(浏览器.取页面标题())
62 print(浏览器.取名称())
63 # print(浏览器.取页面链接())
64 # print(浏览器.取页面源码())
65 with 时间统计("就绪"):
66 print(浏览器.等待元素显示(5, "s_ipt"))
67
68 延时(1)
69
70 搜索输入框 = 浏览器.取元素从id("kw")
71 百度一下按钮 = 浏览器.取元素从id("su")
72
73 搜索输入框.输入("pyefun")
74 百度一下按钮.点击()
75
76 延时(1)
77
78 with 时间统计("结果就绪"):
79 print(浏览器.等待元素显示(5, "result"))
80
81 搜索结果 = 浏览器.取元素从class_name("result")
82 print("搜索结果多少条", len(搜索结果))
83 for 元素 in 搜索结果:
84 print(元素.取文本())
85 # print(元素.取源码())
86
87 延时(1)
88 浏览器.退出()
- class pyefun.seleniumUtil.seleniumUtil.浏览器类[源代码]¶
基类：
object- 打开chrome(驱动路径='chromedriver', 无痕模式=True, 无头模式=False, 隐藏自动化提示=True, 隐藏滚动条=False, 禁止加载图片=False, 禁用插件=False, 禁止Javascript=False, 禁用JAVA=False, 禁止密码保存提示=True, 禁用弹窗=False, 禁止策略化=False, 初始运行=False, 沙盒运行=True, user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36', 代理='', 编码='lang=zh_CN.UTF-8', 禁止使用GPU=False, 谷歌浏览器路径='')[源代码]¶
代理格式：127.0.0.1:8888 带账号密码验证的自行百度修改
- 等待元素加载(By元素类型=0, 元素名称='', 等待秒数=60)[源代码]¶
成功返回真,失败返回假 ,By元素类型参数0是css_selector 谷歌直接复制 1 是id属性 2是name属性, 3 是链接名称 4是xpath属性 5是class_name属性 6是tag_name属性 7,模糊 链接名称
- 获取本地chrome(驱动路径='chromedriver', ChromeOptions=<selenium.webdriver.chrome.options.Options object>)[源代码]¶
Module contents¶
pyefun.阿里云SDK.fc.fc module¶
pyefun.阿里云SDK.oss.oss module¶
pyefun.人工智能.ONNX分类模型推理 module¶
pyefun.图像处理.图像处理 module¶
pyefun.图像处理.图像处理PIL module¶
所有模块¶
易函数视窗编程系统¶
易函数视窗编程系统是一款为中国人入门编程的产品
易函数视窗编程系统由三个主要部分组成
pycharm插件
易函数视窗编程系统易函数视窗设计器
易函数ui组件库
易函数视窗编程系统快速入门文字版 易函数视窗编程系统快速入门视频教程
优势¶
中文编程的得天独厚
可视化视窗设计器
最强的
python开发工具Pycharm的加持pyefun易函数全中文函数库以及专门为wxPython封装的中文组件属性及组件事件以易语言核心支持库组件库为标准封装的界面库
易函数提供了国人熟悉的组件属性和组件事件命名
易函数支持跨平台的可视化窗口程序开发
window，mac OS，ubuntu实现一套代码多端运行易函数为
wxPython插上中文函数的翅膀import wx可替代为import pyefun.wxefun as wx即可提供中文函数支持对原有项目没有任何影响易函数提供一键编译功能将任意python代码转换为c编译为可执行程序
代码风格展示
import pyefun.wxefun as wx
class 窗口1(wx.窗口):
def __init__(self):
self.初始化界面()
def 初始化界面(self):
#########以下是创建的组件代码#########
wx.窗口.__init__(self, None, title='易函数视窗编程系统', size=(380, 250), name='frame', style=541072896)
self.容器 = wx.容器(self)
self.Centre()
self.窗口1 = self
self.按钮1 = wx.按钮(self.容器, size=(106, 42), pos=(28, 25), label='易函数您好', name='button')
self.按钮1.鼠标指针 = wx.鼠标指针.手型
self.按钮1.绑定事件(wx.事件.被单击, self.按钮1_被单击)
self.编辑框1 = wx.编辑框(self.容器, size=(182, 42), pos=(153, 25), value='', name='text', style=0)
self.编辑框1.背景颜色 = (255, 255, 255, 255)
self.按钮2 = wx.按钮(self.容器, size=(301, 39), pos=(31, 90), label='禁止状态的按钮', name='button')
self.按钮2.禁止 = True
self.按钮2.字体 = wx.Font(16, 74, 90, 400, False, 'Microsoft YaHei UI', 28)
self.按钮2.文本颜色 = (255, 0, 0, 255)
self.按钮2.绑定事件(wx.事件.被单击, self.按钮2_被单击)
#########以上是创建的组件代码##########
#########以下是组件绑定的事件代码#########
def 按钮1_被单击(self, event):
print("按钮1_被单击")
self.编辑框1.内容 = "祖国您好"
def 按钮2_被单击(self,event):
print("按钮2_被单击")
#########以上是组件绑定的事件代码#########
class 应用(wx.App):
def OnInit(self):
self.窗口1 = 窗口1()
self.窗口1.Show(True)
return True
if __name__ == '__main__':
app = 应用()
app.MainLoop()
安装pyefun¶
安装¶
正式版本(稳定) 定期更新
正式版本 https://pypi.org/project/pyefun/
pip install pyefun
测试版本 实时更新 如有bug请及时反馈
测试版本 https://test.pypi.org/project/pyefun/
pip install -i https://test.pypi.org/simple/ pyefun
使用¶
from pyefun import *
安装ide代码提示插件¶
pycharm 在插件中搜索 chinese 安装两个插件，界面中文汉化语言包和拼音提示
https://github.com/tuchg/ChinesePinyin-CodeCompletionHelper
关于¶
为python提供强大且易用的中文函数库，完整的封装了易语言核心支持库所有功能，以及易语言中简单易用的函数
github¶
https://github.com/duolabmeng6/pyefun
欢迎贡献代码¶
欢迎加入易函数，参与贡献：提意见、Issue与文档¶
易函数是开源的、免费的软件，这意味着任何人都可以为其开发和进步贡献力量。易函数的项目源代码目前同时托管在 github（主库）和 gitee（国内）平台上，两个平台的仓库保持即时的同步，代码贡献统一使用github主库。我们非常欢迎有更多的朋友加入到易函数的开发中来，你为易函数所做出的任何贡献都将会被记录到易函数的史册中。
贡献代码请提交到github主库 码云仓库仅作为镜像
github (主库) : https://github.com/duolabmeng6/pyefun
码云 : https://gitee.com/duolabmeng666/pyefun
qq群 : 1017240979
参与开源¶
参与贡献¶
易函数代码：参与易函数功能开发、单元测试、ISSUE提交、反馈建议等等，https://github.com/duolabmeng6/pyefun
开发文档：参与WIKI文档的撰写，便于更多的人了解、热爱并加入易函数的开发。
贡献流程¶
首先fork一份仓库代码到自己的版本库中；
在自己的版本库中新建开发分支并对代码做修改，随后提交修改到自己的版本库；
在自己的版本库中创建一个pull request，源分支选择自己的开发分支，目标分支选择主库的master分支：https://help.github.com/en/articles/creating-a-pull-request
提交pull request请求，随后等待由项目的开发作者对提交内容做审核，审核通过之后你将成为易函数的成员之一；
恭喜你，你的名字将永久地载入到易函数源代码的贡献列表中；
协作约定¶
函数名必须使用直观易用的中文命名。请参考易语言的支持库命名，精易模块、火山开发平台的中文函数命名方式
注释必须包括使用方法，代码示例，注意事项 ，如果逻辑复杂的程序部分需要阐述实现思路
必须编写测试用例。如此运行单个用例：
$ python -m unittest pyefun.regexpUtil_test请保持 Windows、Linux 的兼容性。如果是 Windows 的专有函数不要引入公共库
pyefun/__init__.py中，可参考pyefun/asyncPoolGevent、pyefun/javscript的方法封装，使用时单独引入即可贡献代码时 务必 检查代码是否运行正常。
请通过github贡献代码。或者通过提交 issues 的方式贡献代码亦可，贡献代码方式多种多样。
项目推荐¶
goefun (go易函数) 为golang提供强大且易用的中文函数库，易语言go函数库，完整的封装了易语言核心支持库所有功能，以及易语言中简单易用的函数 https://github.com/duolabmeng6/goefun
ide中文拼音插件 https://github.com/tuchg/ChinesePinyin-CodeCompletionHelper