月度归档： 2021 年 4 月

1.不同服务之间的访问需要使用公网IP+端口才能访问

2.服务器上一般都是域名访问，服务器会把ip+端口映射成固定的域名，所以如果想访问服务器上其他应用，就必须的放开应用限制

问题，在服务器上放开对某个端口的限制。

问题：

背景：jmeter压力机放在服务器上，控制机在本地，控制机会发送命令给服务器上的压力机，压力机会进行并发压测，压测完了后会返回压测结果给控制机。

1.保证压力机能访问到控制机，控制机也要能访问到压力机

现在压力机启动jmeter-server，启动的ip不是公网ip，如图：

但是没有关系：因为一个公网ip会映射多个内网ip，端口不会重复，所以访问时只需要用公网ip+应用本身占的ip，不用管应用启起来所占的ip。

服务器公网ip

可以用于域名解析ip，服务器远程登录ip，是*主要的服务器ip地址。

内网ip
不能用于域名解析。
不可以直接用于服务器远程登录，其主要作用是：跟当前帐号下的其他同集群的机器通信。
一些小型企业或者学校，通常都是申请一个固定的IP地址，然后通过IP共享(IP Sharing)，使用整个公司或学校的机器都能够访问互联网。而这些企业或学校的机器使用的IP地址就是内网IP，内网IP是在规划IPv4协议时，考虑到IP地址资源可能不足，就专门为内部网设计私有IP地址(或称之为保留地址)，一般常用内网IP地址都是这种形式的：10.X.X.X、
172.16.X.X-172.31.X.X、192.168.X.X等。需要注意的是，内网的计算机可向Internet上的其他计算机发送连接请求，但Internet上其他的计算机无法向内网的计算机发送连接请求。
公网IP就是除了保留IP地址以外的IP地址，可以与Internet上的其他计算机随意互相访问。我们通常所说的IP地址，其实就是指的公网 IP。互联网上的每台计算机都有一个独立的IP地址，该IP地址唯一确定互联网上的一台计算机。这里的IP地址就是指的公网IP地址。
其实，互联网上的计算机是通过“公网IP＋内网IP”来唯一确定的，就像很多大楼都是201房间一样，房间号可能一样，但是大楼肯定是唯一的。公网IP地址和内网IP地址也是同样，不同企业或学校的机器可能有相同的内网IP地址，但是他们的公网IP地址肯定不同。那么这些企业或学校的计算机是怎样IP地址共享的呢？这就需要使用NAT(Network Address Translation,网络地址转换)功能。当内部计算机要连接互联网时，首先需要通过NAT技术，将内部计算机数据包中有关IP地址的设置都设成NAT主机的公共IP地址，然后再传送到Internet，虽然内部计算机使用的是私有IP地址，但在连接Internet时，就可以通过NAT主机的NAT技术，将内网我IP地址修改为公网IP地址，如此一来，内网计算机就可以向Internet请求数据了。

对了弄服务器的小白来说，不知道内网和外网的区别，它们有什么区别。现在由我指点迷津吧

服务器公网ip

可以用于域名解析ip，服务器远程登录ip，是*主要的服务器ip地址。

内网ip
不能用于域名解析。
不可以直接用于服务器远程登录，其主要作用是：跟当前帐号下的其他同集群的机器通信。

一些小型企业或者学校，通常都是申请一个固定的IP地址，然后通过IP共享（IP Sharing），使用整个公司或学校的机器都能够访问互联网。而这些企业或学校的机器使用的IP地址就是内网IP，内网IP是在规划IPv4协议时，考虑到IP地址资源可能不足，就专门为内部网设计私有IP地址（或称之为保留地址），一般常用内网IP地址都是这种形式的：10.X.X.X、

172.16.X.X-172.31.X.X、192.168.X.X等。需要注意的是，内网的计算机可向Internet上的其他计算机发送连接请求，但Internet上其他的计算机无法向内网的计算机发送连接请求。
公网IP就是除了保留IP地址以外的IP地址，可以与Internet上的其他计算机随意互相访问。我们通常所说的IP地址，其实就是指的公网 IP。互联网上的每台计算机都有一个独立的IP地址，该IP地址唯一确定互联网上的一台计算机。这里的IP地址就是指的公网IP地址。
其实，互联网上的计算机是通过“公网IP＋内网IP”来唯一确定的，就像很多大楼都是201房间一样，房间号可能一样，但是大楼肯定是唯一的。公网
IP地址和内网IP地址也是同样，不同企业或学校的机器可能有相同的内网IP地址，但是他们的公网IP地址肯定不同。那么这些企业或学校的计算机是怎样
IP地址共享的呢？这就需要使用NAT（Network Address Translation,网络地址转换）功能。当内部计算机要连接互联网时，首先需要通过NAT技术，将内部计算机数据包中有关IP地址的设置都设成
NAT主机的公共IP地址，然后再传送到Internet，虽然内部计算机使用的是私有IP地址，但在连接Internet时，就可以通过NAT主机的
NAT技术，将内网我IP地址修改为公网IP地址，如此一来，内网计算机就可以向Internet请求数据了。

KNN算法解决分类问题

前言
这是鄙人*次写CSDN，也是*次用MarkDown，所以有哪里写得不恰当的地方，希望佬们可以在评论区指点。非常感谢！！！
这篇博客主要是想记录一下自己的python机器学习时用到的K近邻算法，也希望可以做成自己的学习笔记系列，如果可以给大家带来一点帮助也是我的荣幸之至。
一、K近邻算法是什么？
网上大佬的理解很多，这里就不多做解释，直接上算法的使用步骤

二、使用k近邻算法解决分类问题
1.载入数据
这里采用的数据是kaggle官网上的数据，这里给出数据的链接：`https://www.kaggle.com/c/facebook-v-predicting-check-ins，利用pandas库的read_csv函数下载csv格式文件，并观察数据相关特征。

import pandas as pd
Loc = pd.read_csv(‘data/FBlocation/train.csv’)
print(Loc.head())

2.数据预处理
数据预处理是很重要的一个步骤，也就是数据的特征工程。通过分析该数据的特点，这里给出我对该数据进行预处理的几个方向，*步是对时间数据进行处理，首先将时间列转换为DataTime的时间戳数据类型，并在此基础上按一个月某天，一周的周几和一天的某时增加三列时间相关特征向量，同时去除原时间特征向量。
代码如下：

# 处理时间数据，由于人们的选择主要与以月或者以周或者以天为周期有关，因此将该时间数据转换为一个月某天，一周的周几和一天的某时
# to_datetime需要表明以什么作为单位，默认以ns做单位
new_time = pd.to_datetime(Loc[‘time’], unit=’s’)
# 将datetime数据转换为转换为字典格式，DatetimeIndex 对象支持全部常规 Index 对象的基本用法，及一些列简化频率处理的高级时间序列专有方法。
new_time = pd.DatetimeIndex(new_time)
# 将day，weekday，hour作为特征向量放入数据中
Loc[‘day’] = new_time.day
Loc[‘weekday’] = new_time.weekday
Loc[‘hour’] = new_time.hour
# 去除原有的time特征向量
Loc.drop(‘time’, axis=1, inplace=True)
print(Loc.head(10))

在处理完时间数据之后，结合数据的实际场景，又将打卡次数少于三次的商家去除（即place_id）因为这样的商家也不建议进行推荐。
代码如下：

# 去除掉签到数量小于3的地点数据，因为签到数量少的地方表示该地点并不受欢迎，可建议作为推荐
New_Loc = Loc.groupby(by=’place_id’).count()
Loc_Index = New_Loc[New_Loc[‘row_id’] > 2].reset_index()
# 重置索引,将原索引放入DataFrame中
# tf = New_Loc[New_Loc.row_id > 3].reset_index()
# 将不在选出来的地点从原数据中去除掉
Loc = Loc[Loc[‘place_id’].isin(Loc_Index[‘place_id’])]
print(Loc.head(10))

到这里，数据预处理主要工作已经完成，为了方便后期的特征工程，将数据集中作用较小的几个特征向量去除，并把特征值向量和目标值向量进行分离
代码如下：

# 取出特征值向量和目标值向量
# 取出目标值
y = Loc[‘place_id’].reset_index()
# 去除无用的特征向量和目标值向量作为特征值向量
x = Loc.drop([‘place_id’, ‘row_id’, ‘accuracy’], axis=1).reset_index()
x = x.drop(‘index’, axis=1)
y = y.drop(‘index’, axis=1)
print(x)
print(y)

3.特征工程
数据预处理部分工作完成后，便将进入到特征工程。首先，为了方便进行之后的k近邻算法训练，将数据集划分为训练集和测试集。并对特征值向量进行标准化，至于标准化，会在之后结合归一化，正则化等再写一期。
代码如下：

from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
# 划分训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
# 进行标准化特征工程,由于k邻近算法使用到距离作为度量相似性,因此可以先对数据进行标准化
std = StandardScaler()
# 对训练集和测试集进行标准化
x_train = std.fit_transform(x_train)
x_test = std.transform(x_test)

4.K近邻算法的使用
这部分也是*简单的内容，基本上都是一样，不过k近邻算法是有一个参数的，这个参数决定你的K近邻会选取该点*近的n个点对该点进行判断，用一句有趣的话解释这个参数对结果的影响就是：n选取过大会导致随大流，n选取过小便会太过于自我
代码如下：

from sklearn.neighbors import KNeighborsClassifier
# 进行k近邻训练
knn = KNeighborsClassifier(n_neighbors=10)
# # 利用训练集进行训练
knn.fit(x_train,y_train)
# # 利用测试集数据进行预测
y_predict = knn.predict(x_test)
# # 查看测试集的精确率
print(‘准确率为:%f’ % knn.score(x_test,y_test))

当然，这里也可以通过网格搜索的方法找出*合适的k近邻参数
代码如下：

from sklearn.neighbors import KNeighborsClassifier
# 进行k近邻训练
knn = KNeighborsClassifier(n_neighbors=10)
# 利用网格搜索,并进行3折交叉验证
# 首先选取几个数据作为knn近邻的参数用来网格搜索
param = {“n_neighbors”: [3, 5, 7, 9, 10, 12, 15]}
# 进行网格搜索
gc = GridSearchCV(knn, param_grid=param, cv=3)
# 对x进行标准化,之后进行k近邻训练
gc.fit(x_train, y_train)
# 预测准确率
print(“在测试集上准确率：”, gc.score(x_test, y_test))

print(“在交叉验证当中*好的结果：”, gc.best_score_)

print(“选择*好的模型是：”, gc.best_estimator_)

三、总结
*后再介绍一下K近邻的优缺点：
优点：

简单有效
重新训练的代价低
适合类域交叉样本
适合大样本的自动分类问题
缺点：

惰性学习
类别评估不是规格化
输出可解释性不强
对不均衡的样本不擅长
计算量较大
文章写的比较匆忙，里面还有许多不完善的地方，理论部分基本上也没有，主要介绍了如何用python完成一个k近邻算法的分类问题，希望对自己之后复习有一定帮助。

面向对象之封装

目录
一 、引入
二、 隐藏属性
三 、开放接口
3.1 隐藏数据属性
3.2 隐藏方法属性
四 、property（属性）装饰器
一 、引入
​ 面向对象编程有三大特性：封装、继承、多态，其中*重要的一个特性就是封装。封装指的就是把数据与功能都整合到一起，听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。除此之外，针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口

二、 隐藏属性
Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的），但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成“_类名__属性名”的形式：

class Foo:
__N=0 # 变形为_Foo__N

def __init__(self): # 定义函数时，会检测函数语法，所以__开头的属性也会变形
self.__x=10 # 变形为self._Foo__x

def __f1(self): # 变形为_Foo__f1
print(‘__f1 run’)

def f2(self): # 定义函数时，会检测函数语法，所以__开头的属性也会变形
self.__f1() #变形为self._Foo__f1()

print(Foo.__N) # 报错AttributeError:类Foo没有属性__N

obj = Foo()
print(obj.__x) # 报错AttributeError:对象obj没有属性__x

这种变形需要注意的问题是：

在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如Foo._A__N，所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。
>>> Foo.__dict__
mappingproxy({…, ‘_Foo__N’: 0, …})

>>> obj.__dict__
{‘_Foo__x’: 10}

>>> Foo._Foo__N
0
>>> obj._Foo__x
10
>>> obj._Foo__N
0

类内部是可以直接访问双下滑线开头的属性的，比如self.__f1()，因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。
>>> obj.f2()
__f1 run
1
2
变形操作只在类定义阶段发生一次,在类定义之后的赋值操作，不会变形。
>>> Foo.__M=100
>>> Foo.__dict__
mappingproxy({…, ‘__M’: 100,…})
>>> Foo.__M
100

>>> obj.__y=20
>>> obj.__dict__
{‘__y’: 20, ‘_Foo__x’: 10}
>>> obj.__y
20

三 、开放接口
定义属性就是为了使用，所以隐藏并不是目的

3.1 隐藏数据属性
将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制.

class Teacher:
def __init__(self, name, age): # 将名字和年纪都隐藏起来
self.__name = name
self.__age = age

def tell_info(self): # 对外提供访问老师信息的接口
print(‘姓名:%s,年龄:%s’ % (self.__name, self.__age))

def set_info(self, name, age): # 对外提供设置老师信息的接口，并附加类型检查的逻辑
if not isinstance(name, str):
raise TypeError(‘姓名必须是字符串类型’)
if not isinstance(age, int):
raise TypeError(‘年龄必须是整型’)
self.__name = name
self.__age = age

>>> t=Teacher(‘lili’,18)
>>> t.set_info(‘LiLi’,’19’) # 年龄不为整型，抛出异常
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
File “<stdin>”, line 11, in set_info
TypeError: 年龄必须是整型
>>> t.set_info(‘LiLi’,19) # 名字为字符串类型，年龄为整形，可以正常设置
>>> t.tell_info() # 查看老师的信息
姓名:LiLi,年龄:19

3.2 隐藏方法属性
目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成，比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开放取款这个功能接口即可,其余功能我们都可以隐藏起来

class ATM:
def __card(self): # 插卡
print(‘插卡’)

def __auth(self): # 身份认证
print(‘用户认证’)

def __input(self): # 输入金额
print(‘输入取款金额’)

def __print_bill(self): # 打印小票
print(‘打印账单’)

def __take_money(self): # 取钱
print(‘取款’)

def withdraw(self): # 取款功能
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()

obj = ATM()
print(obj.withdraw())

总结隐藏属性与开放接口，本质就是为了明确地区分内外，类内部可以修改封装内的东西而不影响外部调用者的代码；而类外部只需拿到一个接口，只要接口名、参数不变，则无论设计者如何改变内部实现代码，使用者均无需改变代码。这就提供一个良好的合作基础，只要接口这个基础约定不变，则代码的修改不足为虑。

四 、property（属性）装饰器
BMI指数是用来衡量一个人的体重与身高对健康影响的一个指标，计算公式为
体质指数（BMI）=体重（kg）÷身高2（m）
EX：70kg÷（1.75×1.75）=22.86

身高或体重是不断变化的，因而每次想查看BMI值都需要通过计算才能得到，但很明显BMI听起来更像是一个特征而非功能，为此Python专门提供了一个装饰器property，可以将类中的函数“伪装成”对象的数据属性，对象在访问该特殊属性时会触发功能的执行，然后将返回值作为本次访问的结果，例如

>>> class People:
… def __init__(self,name,weight,height):
… self.name=name
… self.weight=weight
… self.height=height
… @property
… def bmi(self):
… return self.weight / (self.height**2)
…
>>> obj=People(‘lili’,75,1.85)
>>> obj.bmi #触发方法bmi的执行，将obj自动传给self，执行后返回值作为本次引用的结果
21.913805697589478

使用property有效地保证了属性访问的一致性。另外property还提供设置和删除属性的功能，如下

>>> class Foo:
… def __init__(self,val):
… self.__NAME=val #将属性隐藏起来
… @property # name = property(name)
… def name(self):
… return self.__NAME
… @name.setter
… def name(self,value):
… if not isinstance(value,str): #在设定值之前进行类型检查
… raise TypeError(‘%s must be str’ %value)
… self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME
… @name.deleter
… def name(self):
… raise PermissionError(‘Can not delete’)
…
>>> f=Foo(‘lili’)
>>> f.name
lili
>>> f.name=’LiLi’ #触发name.setter装饰器对应的函数name(f,’Lili’)
>>> f.name=123 #触发name.setter对应的的函数name(f,123),抛出异常TypeError
>>> del f.name #触发name.deleter对应的函数name(f),抛出异常PermissionError

class People:
def __init__(self, name):
self.__name = name

def get_name(self):
return self.__name

def set_name(self, val):
if not isinstance(val,str):
print(‘必须传入str类型’)
return
self.__name = val

def del_name(self):
print(‘不让删除’)
# del self.__name

name=property(get_name,set_name,del_name)

rosdep update 指令超时问题

在执行rosdep update后出现超时问题，报如下错误
reading in sources list data from /etc/ros/rosdep/sources.list.d ERROR: unable to process source [https://raw.githubusercontent.com/ros/rosdistro/master/rosdep/osx-homebrew.yaml]: <urlopen error timed out> (https://raw.githubusercontent.com/ros/rosdistro/master/rosdep/osx-homebrew.yaml) Hit https://raw.githubusercontent.com/ros/rosdistro/master/rosdep/base.yaml
首先执行

sudo gedit /usr/lib/python2.7/dist-packages/rosdep2/sources_list.py
1
然后找到download_rosdep_data函数，大概在300行左右加上这句话url=”https://ghproxy.com/”+url，改完之后是这样

def download_rosdep_data(url):
“””
:raises: :exc:`DownloadFailure` If data cannot be
retrieved (e.g. 404, bad YAML format, server down).
“””
try:
# http/https URLs need custom requests to specify the user-agent, since some repositories reject
# requests from the default user-agent.
url=”https://ghproxy.com/”+url
if url.startswith(“http://”) or url.startswith(“https://”):
url_request = request.Request(url, headers={‘User-Agent’: ‘rosdep/{version}’.format(version=__version__)})
else:
url_request = url
f = urlopen(url_request, timeout=DOWNLOAD_TIMEOUT)
text = f.read()
f.close()
data = yaml.safe_load(text)
if type(data) != dict:

然后执行

sudo gedit /usr/lib/python2.7/dist-packages/rosdistro/__init__.py

将DEFAULT_INDEX_URL进行更改
改为DEFAULT_INDEX_URL = ‘https://ghproxy.com/https://raw.githubusercontent.com/ros/rosdistro/master/index-v4.yaml’

Android多语言翻译之arrays.xml生成脚本

前言
Android studio有处理普通strings.xml的Translations Editor工具，这个大家应该都知道吧。

但是我们的开发中除了一般的string，可能还有string-array。

如果你的公司要做海外多语言十几个国家的生意，一般的string可以很方便的从Excel中复制到Editor中，但是如果是string-array呢？

咋搞？如果你有好的办法，可以在底下留言告诉我。

为了不想一个一个地编辑string-array的item（将翻译好的字符串拷贝进去），这未免效率太低了一点。

为了稍微提高一点点效率，我花了一点时间，写了两个简单的脚本，供大家参考使用。

示例这里以中文、英文进行简单的介绍，实际你面临可能是日语、韩语、阿拉伯语、泰语等等……

脚本1：提供生成单个国家的arrays.xml的功能
文件名：single_translated_text_copy.py

#!/usr/bin/python3

”’
要使用此脚本，只需在该脚本所在路径下执行以下动作，
1. 创建用于存放多个string-array的name的“key.txt”，
2. 创建用于存放多个string-array的item的“item.txt”
3. 执行该脚本，若执行成功，则获得“arrays.xml”
”’

head = “<?xml version=\”1.0\” encoding=\”utf-8\”?>”
resources_start = “<resources>”
string_array_start = “<string-array”
string_array_name_start = ” name=\””
string_array_name_end = “\”>”
string_array_item_start = “<item>”
string_array_item_end = “</item>”
string_array_end = “</string-array>”
resources_end = “</resources>”

key_file_name = “key.txt”
item_file_name = “item.txt”
target_file_name = “arrays.xml”

def create_head(s):
return create(s, head) + ‘\n’

def create_resources_tag_start(s):
return create(s, resources_start) + ‘\n’

def create_resources_tag_end(s):
return create(s, resources_end) + ‘\n’

def create(s1, s2):
s1 = s1 + s2
return s1

def key_dict(lines):
result_dict = {}
for i in lines:
if i.isspace():
continue

# cut ‘\n’
i = i[:-1]

if i in result_dict:
result_dict[i] += 1
else:
temp = {i : 1}
result_dict.update(temp)
return result_dict

def check(l1, l2):
keys_line_count = 0
for i in l1:
if i.isspace():
continue
else:
keys_line_count += 1

item_line_count = 0
for j in l2:
if j.isspace():
continue
else:
item_line_count += 1

if keys_line_count != item_line_count:
print(“Error. There have %d keys, %d items” % (keys_line_count, item_line_count))
return False
else :
print(“Check OK. Count: %d ” % keys_line_count)
return True

def make_body(keys, items, content):
key_dict_d = key_dict(keys)
print(“[Message] key dict: %s \n\n” % key_dict_d)

string_arrays = []

sum = 0
for k in key_dict_d:
obj = StringArray(k)
count = key_dict_d[k]
# print(“key name : %s , count: %d” % (k, count))
index = 0
while(index < count):
temp = items[sum + index]
temp = temp[:-1]

if len(temp) > 0:
# valid
obj.add(temp)
index += 1
else:
continue
sum += count
string_arrays.append(obj)

# print(“string arrray obj count: %d” % len(string_arrays))
for i in range(len(string_arrays)):
content += string_arrays[i].out()
return content

class StringArray:

def __init__(self, key_name):
self.key_name = key_name
self.items_ = []

def add(self, item):
self.items_.append(item)
# print(“add: ” + item)

def out(self):
result = string_array_start + string_array_name_start + self.key_name + string_array_name_end + ‘\n’
for s in self.items_:
t = string_array_item_start + s + string_array_item_end + ‘\n’
result += t
result += (string_array_end + ‘\n’)
return result

if __name__ == ‘__main__’:
key_file = open(key_file_name, ‘r’, encoding=’UTF-8′)
item_file = open(item_file_name, ‘r’, encoding=’UTF-8′)

keys = key_file.readlines()
items = item_file.readlines()

if check(keys, items):
arrays_xml_file = open(target_file_name, ‘w’, encoding=’UTF-8′)

result_content = “”
result_content = create_head(result_content)
result_content = create_resources_tag_start(result_content)
result_content = make_body(keys, items, result_content)
result_content = create_resources_tag_end(result_content)
print(result_content)
arrays_xml_file.write(result_content)

arrays_xml_file.close()
else:
print(“Bye”)

key_file.close()
item_file.close()

你只需要在key.txt中，写入如下：

test_key1_fruit
test_key1_fruit
test_key2_car
test_key2_car
test_key2_car
test_key3_phone
test_key3_phone
同时，在item.txt中，写入如下：

apple
banana
BMW
BENZ
AUDI
Apple
Huawei
然后用py命令执行该脚本即可，不再赘述。

脚本2：提供同时生成多个语言地区的arrays.xml的功能（该脚本会依赖前一个脚本）
文件名：mutable_translated_text_copy.py

#!/usr/bin/python3

”’
要使用此脚本，只需在该脚本所在路径下执行以下动作，
1. 创建用于存放多个string-array的name的“key.txt”，
2. 创建用于存放多个国家的string-array的item的“item.txt”，创建规则见示例文档
3. 执行该脚本，若执行成功，则获得多个以国家命名的文件夹下的“arrays.xml”
”’

from single_translated_text_copy import create_head, create_resources_tag_start, create_resources_tag_end
from single_translated_text_copy import make_body, check
import os

head = “<?xml version=\”1.0\” encoding=\”utf-8\”?>”
resources_start = “<resources>”
string_array_start = “<string-array”
string_array_name_start = ” name=\””
string_array_name_end = “\”>”
string_array_item_start = “<item>”
string_array_item_end = “</item>”
string_array_end = “</string-array>”
resources_end = “</resources>”

key_file_name = “key.txt”
item_file_name = “item.txt”
target_file_name = “arrays.xml”

split = “//coco//”

def split_items(item_file_lines, split):
country_list = []
obj = None
content = []
for line in item_file_lines:
if line.startswith(split):
if obj is None:
pass
else:
obj.add(content)
# print(“Text: %s ! for %s” % (content, obj.country))
country_list.append(obj)
content = []

country = line[len(split):-1]
print(country)
obj = CountryStringArray(country)
else:
content.append(line)
print(“read to tail..”)
if obj is not None:
obj.add(content)
country_list.append(obj)
content = []

for i in country_list:
print(“Text: %s ! for %s” % (i.text, i.country))

return country_list

class CountryStringArray:
def __init__(self, country):
self.country = country
self.text = []

def add(self, s):
self.text = s

if __name__ == ‘__main__’:
key_file = open(key_file_name, ‘r’, encoding=’UTF-8′)
item_file = open(item_file_name, ‘r’, encoding=’UTF-8′)
keys = key_file.readlines()
items = item_file.readlines()

all_item_list = split_items(items, split)

for obj in all_item_list:
# print(“Now: %s” % obj.text)
if check(keys, obj.text):
os.mkdir(obj.country)
arrays_xml_file = open(obj.country + os.sep + target_file_name, ‘w’, encoding=’UTF-8′)
result_content = “”
result_content = create_head(result_content)
result_content = create_resources_tag_start(result_content)
result_content = make_body(keys, obj.text, result_content)
result_content = create_resources_tag_end(result_content)
print(result_content)
arrays_xml_file.write(result_content)
arrays_xml_file.close()
else:
print(“The %s’s items is not same as keys.” % obj.country)

key_file.close()
item_file.close()

示例的key.txt文件同上。

而item.txt中，写入如下：

//coco//zh
苹果
香蕉
宝马
奔驰
奥迪
苹果
华为
//coco//en
apple
banana
BMW
BENZ
AUDI
Apple
Huawei
执行该脚本后会生成“zh”和“en”两个文件夹，里面各有一个arrays.xml

 

python 更换国内镜像源

一.前言
使用python版本 3.8.0、windows 10

国内比较出名的开源镜像站

豆瓣：http://pypi.douban.com/simple/
中科大：https://pypi.mirrors.ustc.edu.cn/simple/
清华：https://pypi.tuna.tsinghua.edu.cn/simple/
阿里云：https://mirrors.aliyun.com/pypi/simple/

二、步骤
永久更改
在命令提示符中运行

pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/

将pip 的下载源 永久切换到阿里云开源镜像站

或者在命令提示符中运行

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/
将pip 的下载源 永久切换到清华开源镜像站

上面的这种方式只支持python较高版本，比较低的版本可以用这种方式

windows下，直接在user目录中创建一个pip目录，

如：C:\Users\xx\pip，新建文件pip.ini，内容如下

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple/

可以看到我上面一步换源的方法也是放在这个目录中的

一次性使用
可以在使用pip的时候加参数-i http://pypi.douban.com/simple/

比如：

pip install pandas -i http://pypi.douban.com/simple/
1
就会从豆瓣开源镜像站去下载*新版本的pandas库

Python绘制气泡图

实现python绘制气泡图，用气泡的不同颜色，不同大小展示信息
代码部分

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
from matplotlib.pyplot import MultipleLocator

def DrawBubble(read_name):#气泡图
sns.set(style = “whitegrid”)#设置样式
fp = pd.read_excel(read_name)#数据来源
x = fp[‘序号’]#X轴数据
y = fp[‘数值’]#Y轴数据
z = fp[‘数值’]#用来调整各个点的大小s
import matplotlib
plt.rcParams[‘font.sans-serif’] = [‘SimHei’]
plt.rcParams[‘axes.unicode_minus’] = False

cm = plt.cm.get_cmap(‘jet’) #RdYlBu plasma jet
fig,ax = plt.subplots(figsize=(30,20))
#注意s离散化的方法，因为需要通过点的大小来直观感受其所表示的数值大小
#我所使用的是当前点的数值减去集合中的*小值后+0.1再*1000
#参数是X轴数据、Y轴数据、各个点的大小、各个点的颜色
bubble = ax.scatter(x, y , s = 3*np.sqrt(z)* 100, c = z, cmap = cm,vmin = 0,vmax = 25, linewidth = 0.5, alpha = 0.5)
ax.grid()
fig.colorbar(bubble)
#plt.ylim((-1, 126))
#ax.set_xlabel(‘people of cities’, fontsize = 15)#X轴标签
ax.set_ylabel(‘参数出现次数’, fontsize = 18)#Y轴标签
plt.xticks(())
plt.yticks(())
for i in range(len(fp[‘数值’])): # 为每个气泡做标注
plt.annotate(fp[‘数值’][i], xy=(fp[‘序号’][i], fp[‘数值’][i]), xytext=(fp[‘序号’][i]-0.10, fp[‘数值’][i] – 0.2), fontproperties=”Times New Roman”)
plt.annotate(fp[‘名称’][0], xy=(fp[‘序号’][0], fp[‘数值’][0]), xytext=(fp[‘序号’][0]- 0.52, fp[‘数值’][0]-1.35), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][1], xy=(fp[‘序号’][1], fp[‘数值’][1]), xytext=(fp[‘序号’][1]- 0.52, fp[‘数值’][1]+1.1), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][2], xy=(fp[‘序号’][2], fp[‘数值’][2]), xytext=(fp[‘序号’][2]- 0.45, fp[‘数值’][2]+1.1), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][3], xy=(fp[‘序号’][3], fp[‘数值’][3]), xytext=(fp[‘序号’][3]- 0.42, fp[‘数值’][3]+1.1), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][4], xy=(fp[‘序号’][4], fp[‘数值’][4]), xytext=(fp[‘序号’][4]- 0.20, fp[‘数值’][4]+1.1), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][5], xy=(fp[‘序号’][5], fp[‘数值’][5]), xytext=(fp[‘序号’][5]- 0.40, fp[‘数值’][5]+1.1), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][6], xy=(fp[‘序号’][6], fp[‘数值’][6]), xytext=(fp[‘序号’][6]- 0.35, fp[‘数值’][6]+1.05), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][7], xy=(fp[‘序号’][7], fp[‘数值’][7]), xytext=(fp[‘序号’][7]- 0.27, fp[‘数值’][7]+0.95), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][8], xy=(fp[‘序号’][8], fp[‘数值’][8]), xytext=(fp[‘序号’][8]- 0.45, fp[‘数值’][8]+0.9), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][9], xy=(fp[‘序号’][9], fp[‘数值’][9]), xytext=(fp[‘序号’][9]- 0.36, fp[‘数值’][9]+1.1), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][10], xy=(fp[‘序号’][10], fp[‘数值’][10]), xytext=(fp[‘序号’][10]- 0.50, fp[‘数值’][10]+0.95), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][11], xy=(fp[‘序号’][11], fp[‘数值’][11]), xytext=(fp[‘序号’][11]- 0.40, fp[‘数值’][11]+0.75), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][12], xy=(fp[‘序号’][12], fp[‘数值’][12]), xytext=(fp[‘序号’][12]- 0.80, fp[‘数值’][12]-0.9), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][13], xy=(fp[‘序号’][13], fp[‘数值’][13]), xytext=(fp[‘序号’][13]- 0.50, fp[‘数值’][13]+0.75), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][14], xy=(fp[‘序号’][14], fp[‘数值’][14]), xytext=(fp[‘序号’][14]- 0.26, fp[‘数值’][14]-0.9), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][15], xy=(fp[‘序号’][15], fp[‘数值’][15]), xytext=(fp[‘序号’][15]- 0.64, fp[‘数值’][15]+0.75), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][16], xy=(fp[‘序号’][16], fp[‘数值’][16]), xytext=(fp[‘序号’][16]- 0.50, fp[‘数值’][16]-0.9), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][17], xy=(fp[‘序号’][17], fp[‘数值’][17]), xytext=(fp[‘序号’][17]- 0.75, fp[‘数值’][17]+0.75), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][18], xy=(fp[‘序号’][18], fp[‘数值’][18]), xytext=(fp[‘序号’][18]- 0.50, fp[‘数值’][18]-0.9), fontsize=10.2, fontproperties=”simhei”)
plt.annotate(fp[‘名称’][19], xy=(fp[‘序号’][19], fp[‘数值’][19]), xytext=(fp[‘序号’][19]- 0.62, fp[‘数值’][19]+0.75), fontsize=10.2, fontproperties=”simhei”)

plt.show()
#fig.savefig(‘hah.png’, bbox_inches=’tight’, dpi=800, pad_inches=0.0)
fig.savefig(‘液滴.jpg’, dpi=800)
if __name__==’__main__’:
DrawBubble(“液滴.xlsx”)#气泡图

简单的登录用例自动化测试

@file_data(‘file.yml’)
def test_3(self, order, name, pw):
# self.driver = webdriver.Firefox()
# self.driver.get(“”)
self.driver.find_element_by_xpath(‘//*[@id=”app”]/div/div/div[2]/div[1]/div/input’).send_keys(name)
self.driver.find_element_by_xpath(‘//*[@id=”app”]/div/div/div[2]/div[2]/div/input’).send_keys(pw)
self.driver.find_element_by_xpath(‘//*[@id=”app”]/div/div/div[2]/button’).click()
sleep(3)
if order == 2:
self.assertEqual(‘用户名和密码不匹配，请重试’, self.driver.find_element_by_xpath(‘//*[@id=”tip”]’).text)
else:
self.assertEqual(‘张新艺’, self.driver.find_element_by_xpath(‘/html/body/div[1]/div/section/section/section/header/div/div[1]/p’).text)

self.driver.quit()

if name == ‘main’:
#read_excel()

#执行套件
# suit = unittest.TestSuite()
# testcase = unittest.defaultTestLoader.discover(os.getcwd(), “test.py”)
# suit.addTests(testcase)
# unittest.TextTestRunner().run(suit)

#生成测试报告
testcase = unittest.defaultTestLoader.discover(os.getcwd(), “test.py”)
filename = open(os.getcwd()+’/report.html’, ‘wb’)
runner = HTMLTestRunner(stream=filename, verbosity=2, title=’自动化测试报告’, description=’详情’)
runner.run(testcase)

#生成测试报告并加上时间戳
t = time.strftime(’%Y-%m-%d %H_%M_%S’)
testcase = unittest.defaultTestLoader.discover(os.getcwd(), “test.py”)
filename = os.getcwd() + t +‘result.html’
name = open(filename, ‘wb’)
runner = HTMLTestRunner(stream=name, verbosity=2, title=‘自动化测试报告’, description=‘详情’)
runner.run(testcase)
yaml文件内容
order: 1
name : zhangxinyi
pw: 123456

order: 2
name: zhangxinyi222222
pw: 22222222222