Python - 标签 - 菠菜眾長https://lruihao.cn/tags/python/Python - 标签 - 菠菜眾長Hugo -- gohugo.iozh-CN1024@lruihao.cn (Lruihao)1024@lruihao.cn (Lruihao)Thu, 26 Mar 2020 11:08:38 +0000使用 Python 刷 csdn 访问量https://lruihao.cn/posts/csdnvisiter/Thu, 26 Mar 2020 11:08:38 +0000Lruihaohttps://lruihao.cn/posts/csdnvisiter/

使用 python 模拟浏览器行为刷 csdn 访问量，脚本仅做学习，请勿滥用~

直接丢代码，把代码挂到服务器上可以策马奔腾~，也可以生成二进制文件放到 Windows 桌面上随时使用~
打包 exe 参考

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#!/usr/bin/python
# -*- coding: utf-8 -*-
__author__ = 'lruihao.cn'
import urllib.request
import re
import time
from bs4 import BeautifulSoup

opener = urllib.request.build_opener()
opener.addheaders = [('User-agent',
                      'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.122 UBrowser/4.0.3214.0 Safari/537.36')]

def get_article_url(page,name):
    endurl = "/"+name+"/article/details/........"
    print(name)
    p = re.compile(endurl)
    url = "http://blog.csdn.net/"+name+"/article/list/"+str(page)
    # 使用 build_opener() 是为了让 python 程序模仿浏览器进行访问
    html = opener.open(url).read().decode('utf-8')
    allfinds = p.findall(html)
    return allfinds
    #print('allfinds',allfinds)

def start_do(allfinds):
    urlBase = "http://blog.csdn.net"  # 需要将网址合并的部分
    # 页面中的网址有重复的，需要使用 set 进行去重复
    mypages = list(set(allfinds))
    for i in range(len(mypages)):
        mypages[i] = urlBase + mypages[i]
    print('要刷的网页有：')
    for index, page in enumerate(mypages):
        print(str(index), page)
    # 设置每个网页要刷的次数
    brushNum = 1

    # 所有的页面都刷
    print('下面开始刷了哦：')
    for index, page in enumerate(mypages):
        for j in range(brushNum):
            try:
                pageContent = opener.open(page).read().decode('utf-8')
                # 使用 BeautifulSoup 解析每篇博客的标题
                soup = BeautifulSoup(pageContent)
                blogTitle = str(soup.title.string)
                blogTitle = blogTitle[0:blogTitle.find('-')]
                print(str(j), blogTitle)
            except urllib.error.HTTPError:
                print('urllib.error.HTTPError')
                time.sleep(3)  # 出现错误，停几秒先
            except urllib.error.URLError:
                print('urllib.error.URLError')
                time.sleep(3)  # 出现错误，停几秒先
                time.sleep(0.5)  # 正常停顿，以免服务器拒绝访问

def main(name):
    for page in range(1,5):
        print("************第"+str(page)+"页*************")
        endurl = get_article_url(page,name)
        start_do(endurl)

if __name__ == '__main__':
  name = input("输入你的 csdn 用户名：")
  if name=="":
    name = "qq_39520417" #cheung99857
  while 1:
    main(name)
        print("开始休息 ...")
        time.sleep(40)

主函数也可以这样写实现同时刷多人的访问量，人多可以适当减少休眠时间，当然有兴趣的可以尝试一下多线程~

1
2
3
4
5
6
7
8
9

if __name__ == '__main__':
    # 多用户
    names = ["qq_39520417","cheung99857"]
    while 1:
        for name in names:
            main(name)
            print("开始休息 ...")
            # 控制休眠时间相当于控制刷新的速度
            time.sleep(30)
]]>新冠疫情未返校未返工第 N 天之“自动打卡”https://lruihao.cn/posts/daka/Wed, 25 Mar 2020 08:22:42 +0000Lruihaohttps://lruihao.cn/posts/daka/
信息

这件事还得从一只蝙蝠说起 …
算了，昨天下午 3 点半，我还在王者峡谷 Timing, 突然潇 X 巴哥打了个电话给我说关于自动打卡的想法 …
哎，反正就是由于疫情需要每天健康打卡汇报给学校，然后每天提交一样的太麻烦了，就想写个程序自动打卡 …
我和潇 X 巴哥确定思路后兵分两路：

  1. 他用 java 写个后台自动刷多人的，再弄个网页给用户填写账号密码保存在数据库；
  2. 我想的就很直接，只刷一个人的，python 模拟浏览器登录后打卡，再设置定时任务（多人则设定多个）；

Windows 运行效果

打卡成功

重复打卡

定时任务日志

核心代码

适用湖南工程学院的打卡系统。
请勿滥用代码提交不实健康信息，隐瞒疫情将受到相关法律处理！

完整代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

def lajaDaka():
  # 登录
  r1 = requests.post(login_url, data=login,headers=headers,verify=False)
  if r1.status_code == 200:
    print(time.strftime("%Y:%m:%d:%H:%M", time.localtime()))
    print(login["username"] + " 登录成功！")
    # 拿到登录后的 cookie 并添加到 header 中
    header1 = r1.headers
    headers["Cookie"] = header1["Set-Cookie"]
  else:
    return

  # 打卡
  r2 = requests.post(daka_url, data=daka,headers=headers,verify=False)
  response2=r2.json()
  if r2.status_code != 200:
    print("打卡失败！")
    return
  if response2["result"] == True:
    print("打卡成功！")
  else:
    print(response2["errorInfoList"][0]["message"])

if __name__=="__main__":
  lajaDaka()

自动运行

Windows

适用 python 代码控制休眠时间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

if __name__=="__main__":
  while True:
    now_hour = time.strftime("%H", time.localtime())
    now_min = time.strftime("%M", time.localtime())
    # 设置每天 8 点发送
    if now_hour < "08":
      rest = 8 - int(now_hour)
      sleeptime = (rest-1)*3600 + (60-int(now_min))*60
      print("启动时北京时间为："+time.strftime("%H:%M", time.localtime()),"\t 脚本将在",rest-1,"小时",int((sleeptime-(rest-1)*3600)/60),"分钟后打卡")
      time.sleep(sleeptime)
    elif now_hour > "08":
      rest = 8 - int(now_hour) + 24
      sleeptime = (rest-1)*3600 + (60-int(now_min))*60
      print("启动时北京时间为："+time.strftime("%H:%M", time.localtime()),"\t 脚本将在",rest-1,"小时",int((sleeptime-(rest-1)*3600)/60),"分钟后打卡")
      time.sleep(sleeptime)
    elif now_hour == "08":
      print("软件明天开始将在每天 8 点发送数据！")
      lajaDaka()
      time.sleep(24*60*60-int(now_min)*60)

linux（云服务器）

搭建 python 环境下载依赖后，使用 shell 脚本定时执行。

1

python /home/python/yiban_daka/daka.py

CRON 表达式的基本语法

潇 x 巴哥的 java web 版本

符合程序员的应该有的简洁和方便，干净又卫生！ http://39.105.174.214/index.html

java web 版

]]>Web 开发规则，代码规范https://lruihao.cn/posts/dev-rules/Thu, 15 Aug 2019 18:30:31 +0000Lruihaohttps://lruihao.cn/posts/dev-rules/精神
  • 绝不写死代码，硬编码
  • 不留不要用的、垃圾代码

Git

  • Master 的 BUG 必须最少且趋近于零，为最稳定的版本
  • 每次 Commit 信息应该准确填写。不可模棱两可，eg: 修复 BUG、增加功能
  • 禁止 Commit IDE 的 project data，e.g: .vscode
  • 禁止上传垃圾代码

更多规则详见文档 Commit 规范

分支（Branch）

  • 命名规则：应以此分支主要目的命名（修复什么 BUG，新增特定功能）
  • 合并后的分支应该删除

commit

  • 遵循一个功能一个 commit 的原则

Restful

  • 资源名词站在 API 的角度思考

    • 复数名词：可以复数笔数据，回传结果为 Array

      举例：GET/users 取得多笔使用者资料

      • 刪除，放在复数名词內，让 Router 保持一致性
      • 增加，放在复数名詞內，让 Router 保持一致性

    • 单数名词：仅取得单笔数据，必须指定 PK，两两一组，回传结果为 Object 举例：GET/user/{accont} 取得单笔使用者资料，必须指定 PK

  • URL 中一律不带 id 参数

1
2

正确范例： calendar_manager/calendar/29
错误范例： calendar_manager/calendar/29?id=29

更多规则详见文档 RESTful

命名

  • 命名应根据内容做有意义的命名，让后续维护人员可以顾名思义！
  • 即使不会发生错误，代码英文大小写也需明确区分。

语意

类型 命名规则 说明
属性 (Attribute, Property) 名词 user_name、userName
方法 (Method, Function) 动词 + 名词 getUserName、get_user_name 常見的动词有：get、set、update、delete、remove

字母与分隔

语言 变量 (Variable, Parameter, Argument) 常量 (Constant) 面向对象 - 类名 (Class Name) 面向对象 - 成员 (mebmer)
HTML 全部小写，不同单词以「-」分隔
e.g: user-id
CSS、SCSS 全部小写，不同单词以「-」分隔，CSS 变量以「–」开头，SCSS 变量以「$」开头
e.g: .user-id、–header-height、$header-height
JavaScript 驼峰式命名法
首字小写，不同单字「首字以大写」分隔
e.g: userId		 全部大写，不同单字以「_」分隔 MAX_COUNT 驼峰式命名法
首字大写，不同单字「首字以大写」分隔
一个文件放一个 Class, 文件名即为 Class Name
e.g: User		 驼峰式命名法
公有 (public) : 首字小写，不同单词「首字以大写」分隔
e.g: name, getName
私有 (private): _公有命名规则
e.g: _name,_getName
Vue
Java
PHP 全部小写，不同单词以「_」分隔
e.g: user_id
Python
SQL 由使用者定义的：表名、字段名
全部小写，不同单词以「_」分隔		 SQL 语法、函数全部大写
e.g: SELECT、INSERT INTO

通用

  • 代码编写
  • 每个函数应该使用块注释，注释应包含函数功能说明、参数说明。规则见：JSDoc、JavaDoc
  • 不必要的代码不要写，也应禁止放到注释里面！
  • if-else 的 {} 严禁省略
  • 代码规范、代码排版等可通过 eslint 等工具做统一处理

正确写法

1
2
3
4
5
6

public function test () {
  // do something
  if (a === b) {
    // do something
  }
}

错误写法

1
2
3
4
5
6
7
8

public function test ()
{
  // do something
  if (a === b)
  {
    // do something
  }
}
  • 代码排版
    • 任何代码应该以 2 个 space 为一个缩进做好排版、不可使用 tab
  • 函数 (Function, Methd)
    • 函数声明时需在函数上方加上函数注释，注释应包含函数说明、参数内容（参数类型、参数英文名称、参数说明）、返回值内容（返回值类型、返回值说明）
  • 类 (Class)
    • 一个类（Class）的声明只能存在一个文件
    • 类（Class）的声明文件，文件名必须为类名
  • 其他
    • 连接本地任何其他资源（图片、文件、网站）皆使用相对路径，禁止使用绝对路径，非本地资源除外

HTML

代码编写

  • 禁止在 HTML 使用 <style>、<script>，一律使用外部档案引用方式引用 CSS、JavaScript 文件
  • HTML 标签需成双成对，有头有尾
  • 块级标签：<tag></tag>
  • 单标签：<tag />
  • 禁止使用已被 HTML 舍弃的旧标签、属性，如：
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

<!-- html tag -->
<center>
<font>
<basefont>
<s>
<strike>
<u>
<listing>
<plaintext>
<xmp>
<!-- html attribute -->
align
bgcolor
color

CSS

CSS 的定义应该独立一个 CSS 文件，禁止使用 <style> 或 style 属性直接在 HTML 中定义样式。

JavaScript

禁止使用 HTML 字串，一律使用 Dom 产生 HTML, e.g: document.createDocumentFragment()

注释

JavaScript 注释应该遵循 JSDoc 的标准撰写

全局变量 (Global)

1

/* global ZT */

常量 (Constant)

1
2
3
4

/**
 * 常量說明
 * @type {常量类型}
 */

Example

1
2
3
4
5

/**
 * 请求地址
 * @type {String}
 */
const REQUEST_URL = 'http://localhost:8080';

函數、方法 (Function, Method)

1
2
3
4
5
6
7

/**
 * 函数用途说明
 * @param {参数类型} 参数名称参数说明
 * @param {参数类型} [选择性参数名称] 参数说明
 * @param {参数类型} [选择性参数名称=参数预设值] 参数说明
 * @returns {返回值类型} 返回值说明
 */

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/**
 * 取得使用者
 * @param {Int} userId 使用者 ID
 * @param {Object} [options] 其他选项
 * @param {String} [options.query='a'] 查询关键词 默认为 'a'
 * @returns {Object} 使用者资料
 */
function getUser(userId, options) {
  // do something
  return user;
}

Vue

  • 待补充

Java

Java 注释应该遵循 JavaDoc 的标准撰写

  • 待补充

PHP

前端参数取得

参数取得需通过 filter_input 函数取得，不得使用 _GET 、_POST

输出到前台

参数命名必须为：全部小写，不同单字以「_」分隔

注解

PHP 注解应该遵循 PHPDoc 的标准撰写

成员变量 (Member)

成员变量只的是 Class 内的成员变数，我们都会要求替成员变量增加注解说明。通常 Function 的变量除非太特别否则都不需要特别注解说明。

1
2
3
4

/**
 * 成员变量說明
 * @type {类型}
 */

Example

1
2
3
4
5

/**
 * 使用者 ID
 * @type {String}
 */
$userId = 'Hello';

函数、方法 (Function, Method)

1
2
3
4
5
6
7

/**
 * 函数用途说明
 * @param 参数型态 参数名称 参数说明
 * @option 参数选项类型 参数选项名称 参数选项说明
 * @uses 全局变量 全域变数说明
 * @returns 返回值类型 返回值说明
 */

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/**
 * 取得使用者
 * @param int userId 使用者 ID
 * @param object options 其他选项
 * @option string options['query'] 查询关键字
 * @uses $_POST['role_id'] 从前端以 POST 取得角色 ID
 * @returns object 使用者资料
 */
function getUser ($userId, $options) {
  // do something
  return $user;
};

Python

  • 待补充

Database

  • 禁止使用 Table Join。
  • 禁止使用 Oracle Trigger。
  • 禁止将查询数据库的 SQL 放在循环中查询

SQL 撰写

  • 属于 SQL 语法使用大写（SELECT，WHERE，INSERT etc..）
  • 属于使用者自己定义的使用小写（表名 table name，字段名 column name etc..）
  • 表名、字段名前后需加上 `

Example

1

INSERT INTO `user` VALUES('a', 'b');

统一用词

系统中常用词，例如弹出框按钮、搜索框等，仅为举例，不限与此。

用词 统一
最后、最终 最后
关闭、Cancel、取消 取消
存储、保存、修改、OK、确定 确定
搜寻、查询、查找、搜索 搜索
]]>python 实训总结Ⅱhttps://lruihao.cn/posts/pysx2/Fri, 21 Jun 2019 18:46:41 +0000Lruihaohttps://lruihao.cn/posts/pysx2/

后面几天讲的有点杂，简单记录一下知识点。

6.19

这些知识点在课上都只是简单的提到了一下。
比如一些库的使用与安装都不会再课上详细讲解，需要课后再去研究。

切片操作

列表切片操作

字符串

python 原始字符串

1

print(r"D:\three\two")

长字符串

用三个单引号或者双引号包裹，前后呼应，成双成对。

用、换行字符表示字符未结束

格式化输出 format

"=={}=="，{}表示占位符，其前后字符保持原样输出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#TempConvert.py
TempStr = input("请输入带有符号的温度值：")
if TempStr[-1] in ['F','f']:
    C = (eval(TempStr[0:-1]) - 32)/1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C','c']:
    F = 1.8*eval(TempStr[0:-1]) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输入格式错误")

多变量赋值与交换（斐波那契数列）

python 3.x 版本 end="" 可使输出不换行

1

print(x, end="")
1
2
3
4
5

#斐波那契数列
a, b = 1,1
while a < 500: ## 输出不大于 500 的序列
    print(a,end=",")
    a,b = b,a + b #交换变量

笑傲江湖统计字符 (dict, 文件流）

统计《笑傲江湖》小说中出现的所有中文字符及标点符号的数量，每个字符及数目间用冒号:隔开，例如"笑：1024"，将所有字符及数量的对应采用逗号分隔，以 CSV 文件格式保存到“笑傲江湖--字符统计。txt”文件中。注意，统计字符不包括空格和回车。

csv 文件格式： ‘,’逗号连接元素

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

fi = open("data/笑傲江湖-网络版。txt","r",encoding="utf-8")
fo = open("data/笑傲江湖-字符统计。txt","w",encoding="utf-8")

txt = fi.read() #打开文件
#txt
d = {}

for c in txt:
    d[c] = d.get(c,0)+1

del d[' '] #删除字典中的空格和回车的键值对
del d['\n']

ls = []

for key in d:
    ls.append("{}:{}".format(key,d[key]))

fo.write(",".join(ls))
fi.close()
fo.close()

numpy 模块

…

pandas 模块

…

6.20

matplotlib 绘图

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import matplotlib.pyplot as plt
import numpy as np
x = np.arange(-5,5,0.01)
y = 2**x+1
plt.plot(x,y)
plt.title("y=2^x+1",fontsize=24)
plt.xlabel("X",fontsize=14)
plt.ylabel("Y",fontsize=14)
plt.tick_params(axis="both",labelsize=14)
plt.show()

爬虫

举了一个金融界，炒股，获取数据的爬虫 （今天没仔细听课，这数据爬过什么意思，咱不懂，咱也不敢问！）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#! /usr/bin/env python
#-*- encoding: utf-8 -*-
#author pythontab.com
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import pandas_datareader.data as web
import datetime
#import tushare as ts

df_stockload = web.DataReader("000001.SS", "yahoo", datetime.datetime(2017,1,1), datetime.date.today())
#print(type(datetime.datetime.now().strftime('%Y-%m-%d')))
#df_stockload = ts.get_hist_data('sh',start='2017-01-01',end=datetime.datetime.now().strftime('%Y-%m-%d'))
print (df_stockload.columns)#查看列名
print (df_stockload.index)#查看索引
print (df_stockload.describe())#查看各列数据描述性统计

#绘制移动平均线
df_stockload.Close.plot(c='b')
df_stockload.Close.rolling(window=30).mean().plot(c='r') #pd.rolling_mean(df_stockload.Close,window=30).plot(c='r')
df_stockload.Close.rolling(window=60).mean().plot(c='g') #pd.rolling_mean(df_stockload.Close,window=60).plot(c='g')
plt.legend(['Close','30ave','60ave'],loc='best')
plt.show()
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Index(['High', 'Low', 'Open', 'Close', 'Volume', 'Adj Close'], dtype='object')
DatetimeIndex(['2017-01-03', '2017-01-04', '2017-01-05', '2017-01-06',
               '2017-01-09', '2017-01-10', '2017-01-11', '2017-01-12',
               '2017-01-13', '2017-01-16',
               ...
               '2019-06-05', '2019-06-06', '2019-06-10', '2019-06-11',
               '2019-06-12', '2019-06-13', '2019-06-14', '2019-06-19',
               '2019-06-20', '2019-06-21'],
              dtype='datetime64[ns]', name='Date', length=596, freq=None)
              High          Low         Open        Close        Volume  \
count   596.000000   596.000000   596.000000   596.000000  5.960000e+02
mean   3076.147753  3039.201569  3056.960338  3060.169056  5.098201e+06
std     269.276147   273.757358   271.612122   272.072346  1.199107e+08
min    2488.479004  2440.906982  2446.019043  2464.363037  8.820000e+04
25%    2845.308228  2800.168762  2825.239502  2827.754822  1.375250e+05
50%    3153.184937  3118.613525  3134.300537  3139.085449  1.666500e+05
75%    3280.115234  3244.825256  3265.322021  3268.600342  2.091250e+05
max    3587.031982  3534.195068  3563.639893  3559.465088  2.927580e+09

         Adj Close
count   596.000000
mean   3060.169056
std     272.072346
min    2464.363037
25%    2827.754822
50%    3139.085449
75%    3268.600342
max    3559.465088

6.21

类

比第一天稍微仔细一点讲了一下类，有点需要注意：

  • self相当于this表示当前对象
  • python 类的所有函数的第一个参数都要写self参数，self 也可以是其他的比如lrh等字符替代，但是必须保持一致。
  • __表示私有的
  • class 的定义可以不加 (),() 内可写继承的父类

GUI 设计 wxPython

1

pip install wxPython
1

import wx
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import wx #导入 wxPython 库

class Panel(wx.Panel):

    def __init__(self,parent):

        wx.Panel.__init__(self,parent=parent, id=-1)

        pass

class Frame(wx.Frame):

    def __init__(self):

        wx.Frame.__init__(self, parent = None, title = u'量化软件', size=(1000,600), style=wx.DEFAULT_FRAME_STYLE^wx.MAXIMIZE_BOX)

        self.DispPanel= Panel(self)

        pass

class App(wx.App):

    def OnInit(self):

        self.frame = Frame()

        self.frame.Show()

        self.SetTopWindow(self.frame)

        return True

if __name__ == '__main__':

    app = App()

    app.MainLoop()
1
2
3
4
5
6
7
8

import wx

app = wx.App()
window = wx.Frame(None, title="wxPython 你好！", size=(400, 300))
panel = wx.Panel(window)
label = wx.StaticText(panel, label="Hello World", pos=(100, 100))
window.Show(True)
app.MainLoop()

talib 库的安装

下载 whl 文件

1
2

pip install TA_Lib-0.4.17-cp37-cp37m-win_amd64.whl
pip install TA-Lib

选择排序递归版

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def SelectSort(L):
    L=L[:]
    if len(L)<=1:
        return L
    min = 0
    for i in range(1,len(L)):
        if L[i]<L[min]:
            min = i
    L[min],L[0] = L[0],L[min]
    return [L[0]]+SelectSort(L[1:])

L = [5,2,3,6,1,9,8,10,0]
print(SelectSort(L))
1

[0, 1, 2, 3, 5, 6, 8, 9, 10]

机房上机系统（自我实践）

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 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
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

import time

class student():
    def __init__(self,stu_no="",stu_name="",stu_xi="",stu_time=""):
        self.stu_no = stu_no
        self.stu_name = stu_name
        self.stu_xi = stu_xi
        self.stu_time = stu_time

    def print(self):
        print("学号："+self.stu_no+"\t 姓名："+self.stu_name+"\t 系别："+self.stu_xi+"\t 机时 (h)："+self.stu_time)

    def get_stu_name(self):
        return self.stu_name

    def get_stu_time(self):
        return int(self.stu_time)

    def set_stu_time(self,add_time):
        self.stu_time = add_time

def menu():
    print("\t 机房上机系统 V0.1")
    print("********************************")
    print("\t—>1. 录入学生信息")
    print("\t—>2. 上机")
    print("\t—>3. 下机")
    print("\t—>4. 缴费")
    print("\t—>5. 退出")
    print("********************************")
    select = eval(input("请输入序号："))
    while select not in [1,2,3,4,5]:
        print("输入错误，请重新输入！")
        select = eval(input("请输入序号："))
    return select

def get_time(): #获取当前时间
    return time.strftime("%H:%M:%S", time.localtime())

def main():
    ## 全局变量
    text = [] ## 上机记录列表
    start_time = ""
    end_time = ""
    sum = 0 ## 本系统按小时计费，不足一小时按一小时算
    people = student()
    online_flag = False
    down_flag = False
    input_flag = False

    while True:
        select = menu() ## 启用菜单

        if select == 1:
            if input_flag:
                print("已录入，无需重复操作，缴费请输入 4:")
                continue
            else:
                input_flag = True
                stu_no = input("请输入学号：")
                stu_name = input("请输入姓名：")
                stu_xi = input("请输入系别：")
                stu_time = input("请输入机时：")
                people = student(stu_no,stu_name,stu_xi,stu_time)
                people.print()
                continue

        elif select == 2:
            if not input_flag:
                print("未录入学生信息，请录入！")
                continue
            if not online_flag:
                online_flag = True
                start_time = get_time()
                start_num = int(start_time[0:2])
                #print(start_num)

                text.append("上机时间："+start_time)
                print("已上机！上机时间为："+start_time)
                continue
            else:
                print("已上机！上机时间为："+start_time)
                continue

        elif select == 3:
            if not online_flag:
                print("还未上机，请上机！")
                continue
            else:
                end_time = get_time()
                end_num = int(end_time[0:2])
                sum = end_num - start_num
                sum = sum if(sum>=0) else sum+24
                sum = sum+1 if(sum==0) else sum
                print("已下机！下机时间为："+end_time+"\n 上机时长 (h)："+str(sum)+"\t 剩余机时 (h)："+str(people.get_stu_time()-sum))
                text.append("下机时间："+end_time+"\n 上机时长 (h)："+str(sum)+"\t"+people.get_stu_name()+"剩余机时 (h)："+str(people.get_stu_time()-sum))
                people.set_stu_time(str(people.get_stu_time()-sum))
                down_flag = True
                continue

        elif select == 4:
            if not input_flag:
                print("未录入学生信息，请录入！")
                continue
            else:
                people.print()
                add_time = eval(input("请输入机时："))
                people.set_stu_time(str(add_time+people.get_stu_time()))
                people.print()

        else:
            if down_flag:
                print("3s 后退出系统，感谢使用！")
                time.sleep(3) ## 延迟 3s，显示提示文字
                break ## 退出系统 写入文件
            else:
                print("请下机！")
                continue

    #写入 computer.txt 文件
    fo = open("D:\\computer.txt","w",encoding="utf-8")
    fo.write("\n".join(text))
    fo.close()

if __name__=="__main__":
    main()

量化交易代码分析与调试

由于 python 的版本问题和一些库的导入问题所以还未调试成功，先挂上代码。以后改篇再论。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 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
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272

#! /usr/bin/env python
#-*- encoding: utf-8 -*-
#author pythontab.com
import wx
import wx.adv
import numpy as np
import pandas as pd
import pandas_datareader.data as web
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.figure import Figure
import matplotlib.dates as mdates
import mpl_finance as mpf
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
import matplotlib.gridspec as gridspec#分割子图
import datetime
import talib
import csv,os
import codecs

from RedefPanelMod import MPL_Panel_Base,Loop_Panel_Base
from StockDataMod import GetStockDatPro
from IndicatStrateMod import Excave_Indic_Base, QuantPickTimeSys,FactorPickStockAng

plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号

class UserDialog(wx.Dialog):## user-defined

    def __init__(self,parent,text):
        wx.Dialog.__init__(self,parent,-1,u"选股提示",size=(400,500),style=wx.CAPTION|wx.CLOSE_BOX|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)

        sizer = wx.BoxSizer(wx.VERTICAL)

        pstock_Text = wx.StaticText(self, -1, u'选股策略筛选结果')
        pstock_Text.SetFont(wx.Font(18,wx.DEFAULT,wx.NORMAL,wx.BOLD))
        pstock_sure = wx.TextCtrl(self, -1, "角度值：\n",size=(350,300),style = wx.TE_MULTILINE|wx.TE_READONLY)#多行|只读
        pstock_sure.SetFont(wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.BOLD))

        okbtn = wx.Button(self,wx.ID_OK,u"确认")
        okbtn.SetDefault()

        sizer.Add(pstock_Text,flag=wx.ALIGN_CENTER)
        sizer.Add(pstock_sure,flag=wx.ALIGN_CENTER)
        sizer.Add(okbtn,flag=wx.ALIGN_CENTER)
        self.SetSizer(sizer)
        for i in text:pstock_sure.AppendText(i)


class Frame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, parent = None, title = u'量化软件', size=(1500,800),
                      style=wx.DEFAULT_FRAME_STYLE^wx.MAXIMIZE_BOX)
        #创建显示区面板
        self.DispPanel = MPL_Panel_Base(self)
        self.BackPanel = Loop_Panel_Base(self)
        self.am = self.DispPanel.am
        self.vol = self.DispPanel.vol
        self.devol = self.DispPanel.devol
        self.macd = self.DispPanel.macd

        #创建参数区面板
        self.ParaPanel = wx.Panel(self,-1)

        paraInput_Box = wx.StaticBox(self.ParaPanel, -1, u'参数输入')
        paraInput_Sizer = wx.StaticBoxSizer(paraInput_Box, wx.VERTICAL)
        self.StNameCodedict = {u"开山股份":"300257.SZ",u"浙大网新":"600797.SS",u"水晶光电":"002273.SZ", u"高鸿股份":"000851.SZ"}

        #初始化股票代码变量
        self.stockName_Val = u"开山股份"
        self.stockCode_Val = self.StNameCodedict[self.stockName_Val]

        self.stockName_CMBO = wx.ComboBox(self.ParaPanel, -1,self.stockName_Val, choices = list(self.StNameCodedict.keys()), style = wx.CB_READONLY|wx.CB_DROPDOWN) #股票名称
        stockCode_Text = wx.StaticText(self.ParaPanel, -1, u'股票名称')

       #策略选取
        strate_Text = wx.StaticText(self.ParaPanel, -1, u'策略名称')
        strate_Combo_Val = [u"双趋势融合", u"阿尔法", u"布林带"]
        self.pickstrate_Val = u"双趋势融合"
        self.pickstrate_CMBO = wx.ComboBox(self.ParaPanel, -1, self.pickstrate_Val, choices = strate_Combo_Val, style = wx.CB_READONLY|wx.CB_DROPDOWN) #策略名称

        #日历控件选择数据周期
        self.dpcEndTime = wx.adv.DatePickerCtrl(self.ParaPanel, -1,style = wx.adv.DP_DROPDOWN|wx.adv.DP_SHOWCENTURY|wx.adv.DP_ALLOWNONE)#结束时间
        self.dpcStartTime = wx.adv.DatePickerCtrl(self.ParaPanel, -1,style = wx.adv.DP_DROPDOWN|wx.adv.DP_SHOWCENTURY|wx.adv.DP_ALLOWNONE)#起始时间
        DateTimeNow = wx.DateTime.Now()#wx.DateTime 格式"03/03/18 00:00:00"
       #DateTimeNow = datetime.datetime.fromtimestamp(wx.DateTime.Now().GetTicks())
       #DateTimeNow = datetime.datetime.fromtimestamp(DateTimeNow)
        self.dpcEndTime.SetValue(DateTimeNow)
        DateTimeNow.SetYear(DateTimeNow.year-1)
        self.dpcStartTime.SetValue(DateTimeNow)
        stockData_Text = wx.StaticText(self.ParaPanel, -1, u'日期 (Start-End)')

        #初始化时间变量
        dateVal = self.dpcStartTime.GetValue()
        self.stockSdate_Val = datetime.datetime(dateVal.year,dateVal.month+1,dateVal.day)
        dateVal = self.dpcEndTime.GetValue()
        self.stockEdate_Val = datetime.datetime(dateVal.year,dateVal.month+1,dateVal.day)

        paraInput_Sizer.Add(stockCode_Text,proportion=0,flag=wx.EXPAND|wx.ALL,border=2)
        paraInput_Sizer.Add(self.stockName_CMBO, 0, wx.EXPAND|wx.ALL|wx.CENTER, 2)
        paraInput_Sizer.Add(stockData_Text,proportion=0,flag=wx.EXPAND|wx.ALL,border=2)
        paraInput_Sizer.Add(self.dpcStartTime, 0, wx.EXPAND|wx.ALL|wx.CENTER, 2)
        paraInput_Sizer.Add(self.dpcEndTime, 0, wx.EXPAND|wx.ALL|wx.CENTER, 2)
        paraInput_Sizer.Add(strate_Text, 0, wx.EXPAND|wx.ALL|wx.CENTER, 2)
        paraInput_Sizer.Add(self.pickstrate_CMBO, 0, wx.EXPAND|wx.ALL|wx.CENTER, 2)

        RadioList = ["不显示","跳空缺口", "金叉/死叉", "N 日突破"]
        self.StratInputBox = wx.RadioBox(self.ParaPanel, -1, label=u'指标提示', choices=RadioList,majorDimension = 4, style = wx.RA_SPECIFY_ROWS)
        self.StratInputBox.Bind(wx.EVT_RADIOBOX,self.OnRadioBox_Indicator)
        #初始化指标变量
        self.IndicatInput_Val = self.StratInputBox.GetStringSelection()

        self.TextAInput = wx.TextCtrl(self.ParaPanel, -1, "交易信息提示：", style = wx.TE_MULTILINE|wx.TE_READONLY)#多行|只读

        vboxnetA = wx.BoxSizer(wx.VERTICAL)#纵向 box
        vboxnetA.Add(paraInput_Sizer,proportion=0,flag=wx.EXPAND|wx.BOTTOM,border=2) #proportion 参数控制容器尺寸比例
        vboxnetA.Add(self.StratInputBox,proportion=0,flag=wx.EXPAND|wx.BOTTOM,border=2)
        vboxnetA.Add(self.TextAInput,proportion=1,flag=wx.EXPAND|wx.ALL,border=2)
        self.ParaPanel.SetSizer(vboxnetA)

        #创建 Right 面板
        self.CtrlPanel = wx.Panel(self,-1)
        #创建 FlexGridSizer 布局网格
        self.FlexGridSizer=wx.FlexGridSizer(rows=3, cols=1, vgap=3, hgap=3)

        #行情按钮
        self.Firmoffer = wx.Button(self.CtrlPanel,-1,"行情")
        self.Firmoffer.Bind(wx.EVT_BUTTON,self.FirmEvent)#绑定行情按钮事件
        #选股按钮
        self.Stockpick = wx.Button(self.CtrlPanel,-1,"选股")
        self.Stockpick.Bind(wx.EVT_BUTTON,self.PstockpEvent)#绑定选股按钮事件
        #回测按钮
        self.Backtrace = wx.Button(self.CtrlPanel,-1,"回测")
        self.Backtrace.Bind(wx.EVT_BUTTON,self.BackEvent)#绑定回测按钮事件

        #加入 Sizer 中
        self.FlexGridSizer.Add(self.Firmoffer,proportion = 1, border = 5,flag = wx.ALL | wx.EXPAND)
        self.FlexGridSizer.Add(self.Stockpick,proportion = 1, border = 5,flag = wx.ALL | wx.EXPAND)
        self.FlexGridSizer.Add(self.Backtrace,proportion = 1, border = 5,flag = wx.ALL | wx.EXPAND)
        self.FlexGridSizer.SetFlexibleDirection(wx.BOTH)

        self.CtrlPanel.SetSizer(self.FlexGridSizer)

        self.HBoxPanel = wx.BoxSizer(wx.HORIZONTAL)
        self.HBoxPanel.Add(self.ParaPanel,proportion = 1.5, border = 2,flag = wx.EXPAND|wx.ALL)
        self.HBoxPanel.Add(self.DispPanel,proportion = 8, border = 2,flag = wx.EXPAND|wx.ALL )
        self.HBoxPanel.Add(self.CtrlPanel,proportion = 1, border = 2,flag = wx.EXPAND|wx.ALL )
        self.SetSizer(self.HBoxPanel)

    def ProcessStock(self):
        #df_stockload = web.DataReader("600797.SS", "yahoo", datetime.datetime(2017,1,1), datetime.date.today())
        df_stockload = GetStockDatPro(self.stockCode_Val,self.stockSdate_Val, self.stockEdate_Val)

        """ 绘制移动平均线图 """
        #self.am.plot(self.numic[0:self.butNum],self.close[0:self.butNum],'#0f0ff0',linewidth=1.0)

        dispCont_List = []

        examp_trade= Excave_Indic_Base()
        if self.IndicatInput_Val == u"金叉/死叉":
            dispCont_pd,dispCont_List = examp_trade.plot_Aver_Cross(df_stockload)
            self.DispPanel.draw_avercross(df_stockload,dispCont_pd)
        elif self.IndicatInput_Val == u"跳空缺口":
            dispCont_pd,dispCont_List = examp_trade.plot_Jump_Thrd(df_stockload)
            self.DispPanel.draw_jumpgap(df_stockload,dispCont_pd)
        elif self.IndicatInput_Val == u"N 日突破":
            dispCont_pd,dispCont_List = examp_trade.plot_Ndays_Break(df_stockload)
            self.DispPanel.draw_ndaysbreak(df_stockload,dispCont_pd)
        else:
            dispCont_List = dispCont_List

        self.TextAInput.SetValue(u"指标提示信息如下："+'\n')
        for i in dispCont_List:self.TextAInput.AppendText(i)

        numic = np.arange(0,len(df_stockload.index))
        butNum = len(df_stockload.index)
        self.DispPanel.xylabel_tick_lim(self.stockName_Val,df_stockload.index)
        self.DispPanel.draw_subgraph(df_stockload,numic)

    def ProcessLoop(self):

        df_stockload = GetStockDatPro(self.stockCode_Val,self.stockSdate_Val, self.stockEdate_Val)
        dispCont_List = []
        if self.pickstrate_Val == u"双趋势融合":
            #多趋势融合策略执行 """
            examp_trade= QuantPickTimeSys(df_stockload)
            dispCont_List = examp_trade.run_factor_plot(self.BackPanel.trade,self.BackPanel.total,self.BackPanel.profit)
        else:
            #执行其他策略
            pass

        self.TextAInput.SetValue(u"策略提示信息如下："+'\n')
        for i in dispCont_List:self.TextAInput.AppendText(i)
        self.BackPanel.xylabel_tick_lim(self.stockName_Val)

    def reFlashLoop(self):
        self.BackPanel.clear_subgraph()#必须清理图形才能显示下一幅图
        self.ProcessLoop()
        self.BackPanel.update_subgraph()#必须刷新才能显示下一幅图

    def reFlashFrame(self):
        self.DispPanel.clear_subgraph()#必须清理图形才能显示下一幅图
        self.ProcessStock()
        self.DispPanel.update_subgraph()#必须刷新才能显示下一幅图

    def FirmEvent(self,event):
        #显示行情面板
        self.HBoxPanel.Hide(self.BackPanel)
        self.HBoxPanel.Replace(self.BackPanel,self.DispPanel)
        self.HBoxPanel.Show(self.DispPanel)
        #self.HBoxPanel.Remove(self.BackPanel)
        self.SetSizer(self.HBoxPanel)
        self.HBoxPanel.Layout()

        #获取列表股票代码和起始时间
        self.stockName_Val = self.stockName_CMBO.GetString(self.stockName_CMBO.GetSelection())
        self.stockCode_Val = self.StNameCodedict[self.stockName_Val]

        dateVal = self.dpcStartTime.GetValue()
        self.stockSdate_Val = datetime.datetime(dateVal.year,dateVal.month+1,dateVal.day)
        dateVal = self.dpcEndTime.GetValue()
        self.stockEdate_Val = datetime.datetime(dateVal.year,dateVal.month+1,dateVal.day)

        self.reFlashFrame()

    def BackEvent(self,event):
        #显示回测面板
        self.HBoxPanel.Hide(self.DispPanel)
        self.HBoxPanel.Replace(self.DispPanel,self.BackPanel)
        self.HBoxPanel.Show(self.BackPanel)
        #self.HBoxPanel.Remove(self.DispPanel)
        self.SetSizer(self.HBoxPanel)
        self.HBoxPanel.Layout()

        #获取策略名称
        self.pickstrate_Val = self.pickstrate_CMBO.GetString(self.pickstrate_CMBO.GetSelection())
        self.reFlashLoop()

    def PstockpEvent(self,event):
        dispCont_List = []
        """ 选股策略执行 """
        examp_trade= FactorPickStockAng()
        for index, stockName in enumerate(self.StNameCodedict.keys()) :
            print("stockName",stockName,self.StNameCodedict[stockName])
            df_stockload = GetStockDatPro(self.StNameCodedict[stockName],self.stockSdate_Val, self.stockEdate_Val)
            df_stockload.fillna(method='bfill',inplace=True)#后一个数据填充 NAN1
            dispCont_List.append(stockName+'\n'+examp_trade.fit_pick(df_stockload.Close)+'\n')
        print(dispCont_List)
        """ 选股策略执行 """
        """ 自定义提示框 """
        myPickStock = UserDialog(self,dispCont_List)
        if myPickStock.ShowModal() == wx.ID_OK:
            pass
        else:
            pass
        """ 自定义提示框 """

    def OnRadioBox_Indicator(self,event):
        self.IndicatInput_Val = self.StratInputBox.GetStringSelection()


class App(wx.App):
    def OnInit(self):
        self.frame = Frame()
        self.frame.ProcessStock()
        self.frame.Show()
        self.SetTopWindow(self.frame)
        return True

if __name__ == '__main__':
    app = App()
    app.MainLoop()
]]>python 实训总结Ⅰhttps://lruihao.cn/posts/pysx1/Tue, 18 Jun 2019 18:41:00 +0000Lruihaohttps://lruihao.cn/posts/pysx1/

以前和前一段时间自己也学习了一下 python，也写了几个小爬虫； 这次正好又课程安排了为期两周的综合实训，主要是“用 python 做量化交易” 进行了两天，讲的都是一些基本的东西，以前也接触过，所以很容易理解。还讲了一些软件，pycharm，anaconda,sublime 等大都也都用过。anaconda 倒是第一次接触。

6.17

1

print("Hello World!")

讲了一下变量和 python 的特色什么的。
还讲了模块定义def和类定义

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class zxm():
	def __init__(self):
		self.x=0
		self.y=0

	def move_up(self):
		self.y +=1

my_zxm=zxm()
print(my_zxm)
1

<__main__.zxm object at 0x000001D99CFEF668>

6.18

输入输出

print 输出
input 输入
eval 执行一个字符串表达式，并返回表达式的值

1
2
3
4

x=eval(input("请输入 x 的值："))
y=eval(input("请输入 y 的值："))
z=(x**2+y**2)**0.5
print(z)
1
2
3
4
5
6

# 导入复数数学模块
import cmath

num = int(input("请输入一个数字："))
num_sqrt = cmath.sqrt(num)
print('{0} 的平方根为 {1:0.3f}+{2:0.3f}j'.format(num ,num_sqrt.real,num_sqrt.imag))

数据类型

今天还讲了一下数据类型

  • 字符串： "" ''
  • 元组 tuple(2,3)
  • 列表 list[2,3]
  • 字典 dict{Key:Value}
  • 集合{}
1
2

x=[1,10]
type(x)#判断元素类型
1

list

循环判断

1
2

for x in range(1,10,2): # (start,stop,step)
    pass # pass 不做任何事情，一般用做占位语句
1
2
3
4
5
6
7

for letter in 'Python':
   if letter == 'h':
      pass
      print('这是 pass 块')
   print('当前字母 :'+ letter)

print("Good bye!")
1
2
3
4
5
6
7
8

当前字母 :P
当前字母 :y
当前字母 :t
这是 pass 块
当前字母 :h
当前字母 :o
当前字母 :n
Good bye!

str() 、 import 导库

1
2

x=10
print("整数转字符串"+str(x))
1

import this
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

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!

Google 翻译意思是： 美丽胜过丑陋。显式优于隐式。简单比复杂更好。复杂比复杂更好。Flat 优于嵌套。稀疏优于密集。可读性很重要。特殊情况不足以打破规则。虽然实用性胜过纯洁。错误不应该默默地传递。除非明确沉默。面对模棱两可，拒绝猜测的诱惑。应该有一个最好只有一个明显的方法来做到这一点。虽然这种方式起初可能并不明显，除非你是荷兰人。现在比永远好。虽然现在永远不会比正确好。如果实施很难解释，这是一个坏主意。如果实现很容易解释，那可能是个好主意。命名空间是一个很棒的主意，让我们做更多的事情吧！

turtle 绘图库（内置模块）

]]>python 实战：模拟 post 请求定时获取后台数据并打包发送至微信https://lruihao.cn/posts/mx2wx/Sat, 11 May 2019 17:02:31 +0000Lruihaohttps://lruihao.cn/posts/mx2wx/

用 python 模拟 post 请求获取“麻小科技”示例酒店后台的数据，再打包发送至指定的微信群或者好友。
要求每天早上 8 点定时把每个酒店的数据发送至每个酒店的微信工作群。

背景

麻小科技：
麻小科技全名深圳市麻小科技有限公司，成立于 2017 年 1 月。是我高一的时候参加Peer 夏令营带我们一个玩的“老师”和他的朋友的创业公司，说老师有点奇怪，我们都是直接叫名字的，比如大家都叫我瑞豪，我也就叫他文捷哥，简称捷哥吧。他们公司主要的开发模式是，小程序前端+php 后端，然后做的是酒店小程序，为每个酒店定制小程序。这些小程序可以贴在客房中给访客提供一些服务，大大节省了成本也提高了效率。
然后每个酒店小程序都有独立的后台，后台会记录一些点击需求的数据。现在他们有一个需求需要把每个酒店小程序后台的数据在每天早上 9 点发送至对应酒店的微信群。

实现代码

缓存登录信息，短时间类无需重复登录，仅第一次需要扫码登录（相当于微信网页版），后面的登录只需在手机上确认登录信息。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#!/usr/bin/python
import requests
import json
import time
from wxpy import *

## 基本信息填写：
## 酒店 id，酒店名称及群名列表数据，格式：["xxx","xxx","xxx"]
## 使用时请将以下三个列表一一对应
hotel=["xxxx","xxxx"] ## 酒店后台数据接口二级域名，已匿名
hotel_name=["增城宾馆","百丽酒店"]
grouplist = ["麻小","富强民主文明和谐自由平等公正法治"]

## post 请求发送的数据
postData = {
    ## 'username':'test',
    ## 'password':'123456',
}

def get_data():
	result = [] #结果列表
	i = 0 #计数器
	for each in hotel:
		url="http://"+each+".maxiaokeji.com/xxx/xxxxxxx/xxx" ## 为保护隐私及权益，这里不提供接口
		r = requests.post(url,data=postData)
		## print(r.text)

		## 把结果转化为 json 字符串
		response=json.dumps(r.json(),indent=4,ensure_ascii=False) #sort_keys=True

		## 把 json 转换为 dict 字典作为中间结果，再取出昨日数据
		midresult=json.loads(response)
		result.append("早上好！"+hotel_name[i]+"小程序昨日数据如下：\n 访问数："+str(midresult["data"]["yesterday_data"]["type1"])+"\n 房间数："+str(midresult["data"]["yesterday_data"]["type2"])+"\n 需求量："+str(midresult["data"]["yesterday_data"]["type3"])+"\n 商品点击量："+str(midresult["data"]["yesterday_data"]["type4"]))
		i+=1
	## print(result)
	return result

def wechat_send(bot,result):
	## my_friend = bot.friends().search('lrh')[0]
	## my_friend.send(result)
	i = 0 ## 计数器
	for group in grouplist:
		my_group = bot.groups().search(group)[0] #依次搜索每一个群名称，每次一个
		my_group.send(result[i])
		print(result[i])
		print("已发送至群："+group)
		i+=1

def main(bot):
	## 设置最大休眠时间，防止程序长时间占用系统资源
	while True:
		now_hour = time.strftime("%H", time.localtime())
		now_min = time.strftime("%M", time.localtime())
		## 设置每天 8 点发送
		if now_hour < "08":
			rest = 8 - int(now_hour)
			sleeptime = (rest-1)*3600 + (60-int(now_min))*60
			print("启动时北京时间为："+time.strftime("%H:%M", time.localtime()),"\t 软件将在",rest-1,"小时",int((sleeptime-(rest-1)*3600)/60),"分钟后发送数据")
			time.sleep(sleeptime)
		elif now_hour > "08":
			rest = 8 - int(now_hour) + 24
			sleeptime = (rest-1)*3600 + (60-int(now_min))*60
			print("启动时北京时间为："+time.strftime("%H:%M", time.localtime()),"\t 软件将在",rest-1,"小时",int((sleeptime-(rest-1)*3600)/60),"分钟后发送数据")
			time.sleep(sleeptime)
		elif now_hour == "08":
			print("软件明天开始将在每天 8 点发送数据！")
			result=get_data() ## 获取数据
			wechat_send(bot,result) ## 发送数据
			time.sleep(86400-int(now_min)*60)

if __name__=="__main__":
	bot = Bot(cache_path=True) ## 初始化机器人，扫码登陆
	main(bot);

测试结果

程序打包

使用 pyinstaller 工具打包成可执行文件即可。（可执行文件不可跨平台运行，分平台打包）

目前该程序已经上线测试中 … 暂未反馈问题

收获

第一次参与实际公司的项目开发，虽然只是一个小的需求设计，但是我在这个过程中也学到了很多，比如通过实际一两周的编程对 Python 的熟悉度远远好过以前在实验室看的一个月视频。
还有就是在此次开发中，也感受到了实际项目开发的团队合作重要性，刚开始拿到这个需求，由于我对 python 和后台，以及数据接口这些基本的操作都不懂，就拿数据获取来说，我一开始一位要自己模拟登陆后台（已知密码），一顿操作、百度等等失败告终，后来涛哥给了一个数据接口，加上涛哥耐心指点，我才终于拿到了数据。
还有在多人合作的项目中，为保持代码的可读性，要尽量的多些注释，还有函数方法的命名尽量具备可读性。比如我代码中的wechat_send()，一开始的命名是wxfs()，经捷哥指正我才改过来的。

]]>python 设置程序每天 8 点定时执行任务https://lruihao.cn/posts/pysettime/Thu, 09 May 2019 23:26:54 +0000Lruihaohttps://lruihao.cn/posts/pysettime/

第一次运行根据程序执行时间，判断程序休眠的时间，尽最大可能休眠，节省系统资源。
第二次运行后直接休眠一天，到每天早上 8 点执行任务。
（该程序需要一直挂着，保持网络不断）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import time
while True:
    now_hour = time.strftime("%H", time.localtime())
    now_min = time.strftime("%M", time.localtime())
    if now_hour < "08":
        rest = 8 - int(now_hour)
        sleeptime = (rest-1)*3600 + (60-int(now_min))*60
        print("启动时北京时间为："+time.strftime("%H:%M", time.localtime()),"\t 软件将在",rest-1,"小时",int((sleeptime-(rest-1)*3600)/60),"分钟后发送数据")
        time.sleep(sleeptime)
    elif now_hour > "08":
        rest = 8 - int(now_hour) + 24
        sleeptime = (rest-1)*3600 + (60-int(now_min))*60
        print("启动时北京时间为："+time.strftime("%H:%M", time.localtime()),"\t 软件将在",rest-1,"小时",int((sleeptime-(rest-1)*3600)/60),"分钟后发送数据")
        time.sleep(sleeptime)
    elif now_hour == "08":
        print("启动时北京时间为：" + time.strftime("%H:%M", time.localtime()), "\t 软件将在每天 8 点发送数据！")
        # 以下为定时任务
        print("数据")
        time.sleep(86400-int(now_min)*60)
]]>安装 pyinstaller 出错的解决办法及 csdn 工具实例打包https://lruihao.cn/posts/pyinstallererror/Thu, 09 May 2019 19:05:01 +0000Lruihaohttps://lruihao.cn/posts/pyinstallererror/

用过命令pip install pyinstaller安装失败，此包依赖于 pywin32，安装前需要先pip install pywin32, 我安装了还是出错，稍微百度了一下也没有看到解决办法。 这里通过手动下载安装解决的，记录一下。

下载

去官网下载 pyinstaller 安装包：https://pypi.org/project/PyInstaller/#files

解压

我这里解压到E:\应用、Python37\Lib\site-packages\PyInstaller-3.4

安装

cmd 也进入到上面的路径下，然后执行Python setup.py install，等待安装完毕

pyinstaller 简介

pyinstaller 将 Python 脚本打包成可执行程序，使在没有 Python 环境的机器上运行。

最新版是 pyinstaller 3.4，可运行在 Windows，Mac 和 Linux 操作系统下。 但它不是跨编译的，也就是说在 Windows 下用 PyInstaller 生成的 exe 只能运行在 Windows 下，在 Linux 下生成的只能运行在 Linux 下。

打包

打包的 app 里并不包含任何源码，但将脚本的 .pyc 文件打包了。

基本语法： pyinstaller options myscript.py

常用的可选参数如下：
--onefile 将结果打包成一个可执行文件
--onedir 将所有结果打包到一个文件夹中，该文件夹包括一个可执行文件和可执行文件执行时需要的依赖文件（默认）
--paths=DIR 设置导入路径
--distpath=DIR 设置将打包的结果文件放置的路径
--specpath=DIR 设置将 spec 文件放置的路径
--windowed 使用 windows 子系统执行，不会打开命令行（只对 windows 有效）
--nowindowed 使用控制台子系统执行（默认）（只对 windows 有效）
--icon=<FILE.ICO> 将 file.ico 添加为可执行文件的资源（只对 windows 有效）

如pyinstaller --paths="D:\" test.py

CSDN 访问量脚本实例

比如，拿以前写的一个刷 csdn 访问量工具 csdn.py（放在桌面上），代码详见

在 cmd 进入桌面路径，输入如下命令

1

pyinstaller --onefile --nowindowed csdn.py

]]>Python 如何操作 Json？https://lruihao.cn/posts/jsoninfo/Tue, 07 May 2019 18:42:47 +0000Lruihaohttps://lruihao.cn/posts/jsoninfo/

Json（JavaScript Object Notation）它是一种轻量级的数据交换格式，具有数据格式简单，读写方便易懂等很多优点。许多主流的编程语言都在用它来进行前后端的数据传输，大大的简化了服务器和客户端的开发工作量。相对于 XML 来说，更加的轻量级，更方便解析，因此许多开发者都遵循 Json 格式来进行数据的传输和交换。今天我们详细介绍一下 Python 在 Json 的编解码方面的知识。

json 的数据格式

在 json 中，遵循“键值对”的这样一种方式，比如：“{“name”:“tom”}”, 就是一个 json 格式的数据，json 的格式归纳下来，一般有以下几点：

  • 对象通过键值对表现；
  • 键通过双引号包裹，后面跟冒号“:”，然后跟该键的值；
  • 值可以是字符串、数字、数组等数据类型；
  • 对象与对象之间用逗号隔开；
  • “{}”用来表达对象；
  • “[]”用来表达数组；

我们看一个略为复杂一点的例子：

上例则是一个典型的 json 格式的数据，强大的 Python 提供了一个“json”模块，可以方便的将各种零散的数据通过模块的内置函数编码形成一个 json 格式的数据，也可以将一个 json 格式的数据解码形成自己需要的数据，非常好用，下面我们就来介绍一下。

json.dumps()

json 模块里的 dumps 函数是对数据进行编码，形成 json 格式的数据，我们看一下下面的例子：

通过输出的结果很容易看出，通过 dumps 方法使字典转换成为了 json 格式，虽然它们非常相似。其中，在 dumps 里的参数“sort_keys=True”，使得输出 json 后对 key 和 value 进行 0~9、a~ z 的顺序排序，如果不填，则按照无序排列。有时候，通过排序可以方便地比较 json 中的数据，因此，适当的排序是很有必要的。

此外，“Indent”参数表示缩进的意思，它可以使得输出的 Json 看起来更加整齐好看，可读性更强，例如：

下面列举一下 dumps（）的可填参数：

  • skipkey：默认为 False，当 dict 对象里的数据不是 Python 的基本数据类型；（str,unicode,int,long,float,bool,None）时，当 skipkey 为 False，就会报错，如果 skipkey 为 True，则可以跳过这类 key；
  • indent：如果填 0 或者不填，则按照一行进行打印，否则按照 indent 的数值显示前面的空格（正整数形式）；
  • separators：分隔符，默认为“(’,’,’:’)”，它表示 key 之间用“,”隔开，key 和 value 之间用“:”隔开；
  • encoding：编码格式，默认值是 UTF-8；
  • sort_keys：对 key、value 进行排序，默认值是 False，即不排序；
  • ensure_ascii：默认为 True，如果 dict 对象里含有 none-ASCII 的字符，则显示、uXX 的格式，如果为 False，则能正常显示出来；

json.loads()

和 dumps 相反，loads 函数则是将 json 格式的数据解码，转换为 Python 字典，我们看一下下面的例子：

有时候，输出结果遇到中文的时候，会出现编码格式不一样的情况，显示出为 Unicode 的编码格式，使得不易读懂，解决办法是添加参数“encoding”参数，即上面的改写成这样：d1 = json.loads(data1,encoding=‘utf-8’) 即可。

json.dump() 和 json.load()

相对于上面所讲的 dumps 和 loads 来说，dump 和 load 函数的功能类似，只不过前者是用来处理字符串类型的，而后者是用于处理文件类型的，如下所示：

上例列举出了 json 的四个方法：dumps（）和 dump（）、loads（）和 load（）的简单使用方法，可见，Python 对于 json 的处理相当方便，不像 c++那样（谁用谁知道）。

]]>python 发送 post 请求进行简单的接口测试https://lruihao.cn/posts/posttest/Tue, 07 May 2019 18:17:05 +0000Lruihaohttps://lruihao.cn/posts/posttest/

通过 requests 可以向某个地址发送请求，可以用来做一些接口的测试；主要有两个方法：

  • requests.get()
  • requests.post()
    最近帮朋友的项目做一个小需求，需要把后台数据定期打包发送到微信群，麻小科技涛哥给了我一个接口，post 访问。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#!/usr/bin/python
import requests

"""
通过 requests 可以向某个地址发送请求 requests.post(url,json date)
post 方法还有其他参数，如 header 等
"""

# post 发送的数据
postData = {
    # 'username':'test',
    # 'password':'123456',
    # 'salary':2000,
}

# 接口这里不便公开
r = requests.post('http://demo.maxiaokeji.com/xx/xxxxx/xxxx',data=postData)
# print(r.text)
response=r.json()
print(response)

运行后会在屏幕打印出返回的 json 数据

]]>用 MyQR 制作专属动态二维码 (py 和 exe 版本）https://lruihao.cn/posts/qrcode/Sat, 27 Apr 2019 14:16:54 +0000Lruihaohttps://lruihao.cn/posts/qrcode/

Python 二维码生成器是 github 上@sylnsfar 开源的一个 python 生成二维码工具。有 python, 网页及 exe 版本，详见 sylnsfar/qrcode，本文主要介绍记录一下 python 版本使用。exe 可以去 项目开源地址 下载，公众号文章后台回复关键词“qrcode”获取链接。

可生成普通二维码、带图片的艺术二维码（黑白与彩色）、动态二维码（黑白与彩色）。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

from MyQR import myqr
import os
version, level, qr_name = myqr.run(
    words='https://lruihao.cn',
    version=1,
    level='H',
    picture='2.jpg',
    colorized=True,
    contrast=1.0,
    brightness=1.0,
    save_name=None,
    save_dir=os.getcwd()
)

# help(myqr)
# https://github.com/sylnsfar/qrcode/
'''
Positional parameter
   words: str # 链接或者文字

Optional parameters
   version: int, from 1 to 40  # 控制边长
   level: str, just one of ('L','M','Q','H') # 控制纠错水平，从左到右依次升高。
   picutre: str, a filename of a image # 图片，需在同路径，默认 None
   colorized: bool  # 是否彩色 默认 False
   constrast: float # 对比度 默认 1.0
   brightness: float # 亮度 默认 1.0
   save_name: str, the output filename like 'example.png' #控制文件名，默认 None,'qrcode.png'
   save_dir: str, the output directory # 储存路径
'''

安装

1
2

# 通过 pip
pip(3) install myqr(or MyQR)

使用方法

命令行方式

（提示：如果你尚未安装 MyQR ，以下内容请使用python(3) myqr.py 而非myqr 。）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 概括
myqr 	Words
		[-v {1,2,3,...,40}]
		[-l {L,M,Q,H}]
        [-n output-filename]
		[-d output-directory]
		[-p picture_file]
		[-c]
		[-con contrast]
		[-bri brightness]
  • 普通二维码 介绍了 Words, -v, -l, -n, -d
  • 艺术二维码 介绍了 -p, -c, -con, -bri
  • 动态 GIF 二维码 介绍了动态的生成方法和注意点

普通二维码

1
2

#1 Words
myqr https://github.com
  • 在命令后输入链接或者句子作为参数，然后在程序的当前目录中产生相应的二维码图片文件，默认命名为 “qrcode.png”。
1
2

#2 -v, -l
myqr https://github.com -v 10 -l Q

  • 默认边长是取决于你输入的信息的长度和使用的纠错等级；

    而默认纠错等级是最高级的 H。

  • 自定义：如果想要控制边长和纠错水平就使用 -v 和 -l 参数。

    -v 控制边长，范围是** 1 至 40**，数字越大边长越大；

    -l 控制纠错水平，范围是** L、M、Q、H**，从左到右依次升高。

1
2

#3 -n, -d
myqr https://github.com -n github_qr.jpg -d .../paths/

  • 默认输出文件名是“ qrcode.png “，而默认存储位置是当前目录。

  • 自定义：可以自己定义输出名称和位置。注意同名文件会覆盖旧的。

    -n 控制文件名，格式可以是 .jpg， .png ，.bmp ，.gif ；

    -d 控制位置。

艺术二维码

1
2

#1 -p
myqr https://github.com -p github.jpg
  • 参数-p 用来将 QR 二维码图像与一张同目录下的图片相结合，产生一张黑白图片。
1
2

#2 -c
myqr https://github.com -p github.jpg -c
  • 加上参数 -c 可以使产生的图片由黑白变为彩色的。
1
2

#3 -con, -bri
myqr https://github.com -p github.jpg [-c] -con 1.5 -bri 1.6

  • 参数-con 用以调节图片的对比度，1.0 表示原始图片，更小的值表示更低对比度，更大反之。默认为 1.0。

  • 参数 -bri 用来调节图片的亮度，其余用法和取值与 -con 相同。

动态 GIF 二维码

动态二维码与上述的带图片的二维码的生成方法没什么区别，你只要采用 .gif 格式的图片即可生成黑白或者彩色的动态二维码。但注意如果使用了 -n 参数自定义输出的文件名，切记其格式也必须是 .gif 格式。

作为导入文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 安装模块后
from MyQR import myqr
version, level, qr_name = myqr.run(
	words,
    version=1,
    level='H',
    picture=None,
    colorized=False,
    contrast=1.0,
    brightness=1.0,
    save_name=None,
    save_dir=os.getcwd()
	)

以下各个参数已经在上文命令行方式有所介绍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# help(myqr)
Positional parameter
   words: str

Optional parameters
   version: int, from 1 to 40
   level: str, just one of ('L','M','Q','H')
   picutre: str, a filename of a image
   colorized: bool
   constrast: float
   brightness: float
   save_name: str, the output filename like 'example.png'
   save_dir: str, the output directory

使用提示

  • 请采用正方形或近似正方形的图片

  • 建议在图片尺寸大的时候使用 -v 的值也应该适当变大。

可用字符

  • 数字 0 到 9

  • 大小写的英文字母

  • 常用英文标点符号和空格

    1

    · , . : ; + - * / \ ~ ! @ # $ % ^ & ` ' = < > [ ] ( ) ? _ { } | and  (space)

依赖库

运行环境

  • Linux, Python 3
  • Windows, Python 3
  • Mac, Python 3
]]>python 爬取网站图片（图片链接相似）https://lruihao.cn/posts/mmtimgpy/Mon, 22 Apr 2019 12:46:34 +0000Lruihaohttps://lruihao.cn/posts/mmtimgpy/

以下程序对 该网址 内的手写体图片进行爬取！这个手写体是我在手机上通过《手迹造字》app 书写的，大概 6886 个字符，历时两年多，目前仍在修改中。字体效果查看

思路设计

通过观察目标网页中字符图片的链接，很容易发现每个字符图片的直链是由两部分组成。

  • 固定链接
  • 图片文件编号

其中固定连接为https://image.xiezixiansheng.com/users/2010/700/unzip/579767/, 图片文件为xxxxx.png@50q，如果去掉@50q，获取到的图片就是透明背景的不然就是白色背景。然后发现编号大多是 5 位数的形式，但是还有一些是 4 位的，甚至还有 2-3 位的数字。仔细看看 127 前的编号都是一些国际符号诸如英文和数字等。比对一下发现正是 ASCII 码对应的命名方式。可想而知中文自然也是通过编码来命名的。一个标准的字库文件至少包含 6763 个汉字，也就是我书写的这个GB2312-80, 范围： 0xA1A1 - 0xFEFE，其中汉字范围： 0xB0A1 - 0xF7FE。两个 16 进制位对应一个字节，一个汉字至少由两个字节组成，这样理解，范围自然是 4 个 16 进制位。所以转换成 10 进制，范围大致在 65278 以下。要了解更加具体一点的范围还需要去查一下汉字编码的分区等。这里暂时不必了解，因为本来就打算暴力下载。

说了这么多，既然图片链接这么简单，所以我是想暴力遍历，搜索图片，判断链接状态码，然后下载图片。

源码设计

大致分为三个范围吧

  • 英文字符
  • 中文符号
  • 汉字范围

我主要分这几个区间查找

  • 33 ~ 126
  • 8212 ~ 8243
  • 12289 ~ 12305
  • 19968 ~ 40864
  • 65281 ~ 65509

磨刀不误砍柴工，分析观察了这么久，终于可以运行程序了，F5 后就静静等待吧，可以去看看 java，或者打一把王者 hhhhh!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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
45
46
47
48
49
50
51
52
53
54
55
56

import os
import requests

path="C:\\Users\\李瑞豪、\Desktop\\MMT_images\\" #下载路径： 绝对或者相对路径比如。/image/
os.makedirs(path+"0\\", exist_ok=True) ## 创建文件夹
os.makedirs(path+"1\\", exist_ok=True)

## 下载图片
def urllib_download(url,num):  ## （下载链接，图片编号）
    from urllib.request import urlretrieve
    urlretrieve(url,path+num+".png")

## 判断状态码
def get_status(url):
    r = requests.get(url, allow_redirects = False)
    return r.status_code

def main():
	BASE_URL = "https://image.xiezixiansheng.com/users/2010/700/unzip/579767/"
	n=33
	total=0
	print("正在爬取第 1 张图片！")

	while n < 65510:
		#分段爬取，不然会超时！！！## 33 ~ 126 ## 8212 ~ 8243 ## 12289 ~ 12305 ## 19968 ~ 40864 ## 65281 ~ 65509
		if n == 127:
			n = 8212
			continue
		elif n == 8244:
			n = 12289
			continue
		elif n ==12306:
			n = 19968
			continue
		elif n == 40865:
			n = 65281
			continue

	## for n in range(37341,40865):
		num = str(n)
		IMAGE_URL = BASE_URL+num+".png" ## xxx.png 是透明背景，xxx.png@50q 是白色背景，分别存放在 0，1 文件夹 p 是中小 w 是小图
		if(get_status(IMAGE_URL)==200): ## 同时下载透明和白色背景的图片
			total+=1
			urllib_download(IMAGE_URL,"0\\"+num)
			IMAGE_URL += "@50q"
			urllib_download(IMAGE_URL,"1\\"+num)
			print("Downloaded "+num+".png")
			print("正在爬取第",total+1,"张图片！")
		n+=1

	print("\n 爬取完毕！共爬取",total,"张图片！")
	print("图片存放路径："+path)
	print("作者博客：lruihao.cn")

if __name__=="__main__":
    main();

爬取过程及结果

文件夹左下角数目变化

爬取过程

危险
说实话看着控制台不停地输出提示信息有没有很爽，对于强迫症来说真的是很治愈了！但是爬取第 6042 张图片的时候，我打开了一下目标网页发现无法加载图片了，就想这应该也算是一次 Dos 攻击了吧！打开控制台果然停了，相当于访问了近两万次！唉，还是太暴力了！！还差 800 多张，只好又重新接着写上次的位置爬！不慎造成目标网站服务器压力，实在对不起！

错误提示

一个半小时左右后终于下载完了，一共是 6886 张；程序是同时下载了透明和白色背景的图片的！分别在 0,1 子文件夹！

爬取完毕

其他思路

模拟浏览器载入 html 文件，获取源码，查找到所有<img>标签内链接，必要时配合正则表达式，然后下载图片。

]]>python 玩微信：初探 wxpyhttps://lruihao.cn/posts/wxpy1/Sat, 20 Apr 2019 15:44:57 +0000Lruihaohttps://lruihao.cn/posts/wxpy1/

文中涉及的图片涉及个人隐私，仅做举例，请勿传播

  • 查看微信好友男女比例
  • 查看好友地区分布
  • 群性别统计

前期准备

查看微信好友男女比例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from wxpy import *
from pyecharts import Pie

bot = Bot(cache_path = True)   #定义一个微信机器人
friends = bot.friends(update=False)   #获取更新好友列表
male = female = other = 0

for i in friends[1:]:     #[1:] 自己是第一个，排除掉
    sex = i.sex
    if sex == 1:
        male += 1
    elif sex == 2:
        female += 1
    else:
        other += 1
total = len(friends[1:])   #计算总数

#下面为分析
attr = ["男性","女性","其他"]
v1 = [float(male),float(female),float(other)]
pie = Pie("饼图-圆环图示例", title_pos='center')
pie.add("", attr, v1, radius=[40, 75], label_text_color=None, is_label_show=True,
        legend_orient='vertical', legend_pos='left')
pie.render("sex.html")

查看好友地区分布

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

from wxpy import *
from pyecharts import Map

#因为获取的列表城市都没有带市字，而 pyecharts 需要带个市字
b = '市'
def s(x):
    return x+b

#只提取湖南的
bot = Bot(cache_path = True)
friends = bot.friends(update=False).search(province = '湖南')
citys = []
for f in friends :
    city = f.city
    citys.append(city)
r = map(s,citys)
cityss = list(r)

#为城市计数
a = {}
for i in cityss:
    a[i] = cityss.count(i)
a.pop('市')

#把字典进行有序拆分为 2 个列表
attrs = []
values = []
for value, attr in a.items():
    values.append(attr)
    attrs.append(value)
#开始绘图
map = Map("湖南地图示例", width=1200, height=600)
map.add("", attrs, values, maptype='湖南', is_visualmap=True, visual_text_color='#000')
map.render("city.html")

以上参考简书 陈思煜

统计所有群男女数目

统计结果会自动发送到所有群聊 男女人数和不一定等于总数（有些人不显示性别）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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
45
46
47
48
49
50
51
52
53
54
55
56
57

#encoding=utf-8
from wxpy import *
import numpy

def removeAll(the_list, val):
    return [value for value in the_list if value != val]

def stats_text(target_group, group_name):
    print(group_name + "群共有：" + str(len(target_group)) + "人，其中：")
    all_stats_text = []
    all_dict = {}

    ## 乱序先整理一份省份 + 地点的列表
    for user in target_group.members:
        trimed_data = user.province.replace(' ', '') + user.city.replace(' ', '')
        if trimed_data != '':
            all_stats_text.append(trimed_data)
    ## 计数
    for data in all_stats_text:
        if all_stats_text.count(data) != 0:
            all_dict[data] = all_stats_text.count(data)
            all_stats_text = removeAll(all_stats_text, data)
    final_dict = {}
    for i in sorted(all_dict.keys()):
        final_dict[i] = all_dict[i]
    return final_dict

def stats_sex(target_group):
    male = 0
    female = 0
    other = 0

    for user in target_group.members:
        if user.sex == 1:
            male = male + 1
        if user.sex == 2:
            female = female + 1
        else:
            other = other + 1

    print("男的有：" + str(male) + "人")
    print("女的有：" + str(female) + "人")
    msg = "男的有：" + str(male) + "人、n" + "女的有：" + str(female) + "人、n"
    return msg

bot = Bot()

target_group = bot.groups(update=True, contact_only=False)

for curr_group in target_group:
    ## 小于 10 人的群过滤掉
    if len(curr_group) < 10:
        continue
    curr_group.update_group(members_details=True)
    print(curr_group.name + "一共有：" + str(len(curr_group)) + "人、n")
    msg = stats_sex(curr_group)
    curr_group.send(curr_group.name + "群，一共有：" + str(len(curr_group)) + "人、n" + msg)
]]>基本 python 实现的爬取微信好友头像，并拼接成大图https://lruihao.cn/posts/wximgpy/Sat, 20 Apr 2019 13:32:58 +0000Lruihaohttps://lruihao.cn/posts/wximgpy/

Python 通过 wxpy 登录微信网页版，爬取好友所有头像并拼接成一张大图。然后删除所有子图。（注释相关代码可以不删除）
文中涉及的图片涉及个人隐私，仅做举例，请勿传播
文中编码由 Sunbelife 提供，来自他的同名微信公众号，本博仅用于学习，侵删

依赖

  • wxpy（Pythone 登录微信）
  • pillow（拼接头像）
  • os（文件夹操作）
  • math（数学计算）

wxpy:
  wxpy 在 itchat 的基础上，通过大量接口优化提升了模块的易用性，并进行丰富的功能扩展。
PIL：
  Python Imaging Library，已经是 Python 平台事实上的图像处理标准库了。PIL 功能非常强大，但 API 却非常简单易用。由于 PIL 仅支持到 Python 2.7，加上年久失修，于是一群志愿者在 PIL 的基础上创建了兼容的版本，名字叫 Pillow，支持最新 Python 3.x，又加入了许多新特性，因此，我们可以直接安装使用 Pillow。

安装

1
2

pip install -U wxpy -i "https://pypi.doubanio.com/simple/"
pip install pillow

运行

如果在 Python IDE 运行出错，可能是因为微信好友的 id 是特殊字符，在 IDE 打印出错，注释掉代码 36 行即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

from wxpy import *
import math
import PIL.Image as Image
import os
import sys
import shutil
#
### 获取文件所在的绝对路径
def get_dir(sys_arg):
	sys_arg = sys_arg.split("/")

	dir_str = ""
	count = 0
	for cur_dir in sys_arg:
		if count == 0:
			count = count + 1
		if count == len(sys_arg):
			break
		dir_str = dir_str + cur_dir + "/"
		count = count + 1
	return dir_str

curr_dir = get_dir(sys.argv[0])

bot = Bot()

## 机器人账号自身
myself = bot.self
my_friends = bot.friends(update=True)

if not os.path.exists(curr_dir + "group-images/"):
	os.mkdir(curr_dir + "group-images/")

count = 0
for friend in my_friends:
	print(friend.nick_name)
	friend.get_avatar(curr_dir + "group-images/" + str(count) + ".jpg")
	count = count + 1

## 获取下载的头像文件
ls = os.listdir(curr_dir + 'group-images')

## 去除非 .jpg 文件
for filter_ls in ls:
	if ".jpg" in filter_ls:
		continue
	else:
		ls.remove(filter_ls)

## 排序
ls.sort(key=lambda x:int(x[:-4]))

## 头像墙尺寸
image_size = 2560

each_size = math.floor(image_size/math.floor(math.sqrt(len(ls))))
x_lines = math.ceil(math.sqrt(len(ls)))
y_lines = math.ceil(math.sqrt(len(ls)))
image = Image.new('RGB', (each_size * x_lines, each_size * y_lines))

x = 0
y = 0

for file_names in ls:
	try:
		img = Image.open(curr_dir + "group-images/" + file_names)
		print("正在处理" + file_names.split('.jpg')[0] + "/" + str(len(ls)))
	except IOError:
		continue
	else:
		img = img.resize((each_size, each_size))
		image.paste(img, (x * each_size, y * each_size))
		x += 1
		if x == x_lines:
			x = 0
			y += 1

img = image.save(curr_dir + "all.jpg")

try:
	shutil.rmtree(curr_dir + "group-images/")
	print("收尾，清理临时文件")
except FileNotFoundError:
	print("没什么好删的")

print("！！！\n 生成完毕了，放在了目录" + curr_dir + "，去看看吧。")
print("工具作者：@Sunbelife（新浪微博）")
print("公众号：Sunbelife")
print("感谢使用")
print("v1.2")
print("2019.4.18")

群友全家福

修改 11 行群名称

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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
45
46

import itchat
import math
import PIL.Image as Image
import os
import shutil

## 变量
itchat.auto_login(hotReload=True,enableCmdQR=False)
roomslist = itchat.get_chatrooms(update=True)[0:]
itchat.dump_login_status() ## 显示所有的群聊信息，默认是返回保存到通讯录中的群聊
myroom=itchat.search_chatrooms(name=u'绥宁一中高 396 班') #群聊名称
gsq=itchat.update_chatroom(myroom[0]['UserName'], detailedMember=True)

num = 0

if not os.path.exists("./group-images/"):
    os.mkdir("./group-images/")

for i in gsq['MemberList']:
    print(i["UserName"])
    img = itchat.get_head_img(userName=i["UserName"],chatroomUserName=myroom[0]['UserName'])
    fileImage = open("./group-images/" + str(num) + ".jpg",'wb')
    fileImage.write(img)
    fileImage.close()
    num += 1

ls = os.listdir('./group-images')
each_size = int(math.sqrt(float(640*640)/len(ls)))
lines = int(640/each_size)
image = Image.new('RGBA', (640, 640))
x = 0
y = 0
for i in range(0,len(ls)+1):
    try:
        img = Image.open("./group-images/" + str(i) + ".jpg")
    except IOError:
        print("Error")
    else:
        img = img.resize((each_size, each_size), Image.ANTIALIAS)
        image.paste(img, (x * each_size, y * each_size))
        x += 1
        if x == lines:
            x = 0
            y += 1
image.save("all.png")
shutil.rmtree("./group-images")

绥宁一中高 396 班

加个列表，加个循环实现自动爬取所有群聊头像并发送

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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
45
46
47
48
49

import itchat
import math
import PIL.Image as Image
import os
import shutil

## 变量
itchat.auto_login(hotReload=True,enableCmdQR=False)
roomslist = itchat.get_chatrooms(update=True)[0:]
itchat.dump_login_status() ## 显示所有的群聊信息，默认是返回保存到通讯录中的群聊

for room in roomslist:
    print(room['UserName'])
    gsq=itchat.update_chatroom(room['UserName'], detailedMember=True)
    num = 0

    if not os.path.exists("./group-images/"):
        os.mkdir("./group-images/")

    for i in gsq['MemberList']:
        print(i["UserName"])
        img = itchat.get_head_img(userName=i["UserName"],chatroomUserName=room['UserName'])
        fileImage = open("./group-images/" + str(num) + ".jpg",'wb')
        fileImage.write(img)
        fileImage.close()
        num += 1

    ls = os.listdir('./group-images')
    each_size = int(math.sqrt(float(640*640)/len(ls)))
    lines = int(640/each_size)
    image = Image.new('RGB', (640, 640))
    x = 0
    y = 0
    for i in range(0,len(ls)+1):
        try:
            img = Image.open("./group-images/" + str(i) + ".jpg")
        except IOError:
            print("Error")
        else:
            img = img.resize((each_size, each_size), Image.ANTIALIAS)
            image.paste(img, (x * each_size, y * each_size))
            x += 1
            if x == lines:
                x = 0
                y += 1
    image.save("all.jpg")
    itchat.send("写了个好玩的… 测试一下", room['UserName'])
    itchat.send_image("all.jpg", room['UserName'])
    shutil.rmtree("./group-images")
]]>