pandas基础篇一

python——pandas基础篇一
pandas的知识很多很细,更多感觉像字典工具一样,自己就打算借助这个平台梳理知识脉络,见证自己的成长!

一、文件的读取和写入
1、文件读取
pandas能读取的文件格式有很多种,主要介绍常用的几种格式(.csv/.txt/.xlsx…)
1
1.1语法
.csv%title插图%num

txt/xlsx

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210325142721709.png

1.2 分割参数sep
在读取txt文件时,经常遇到分隔符非空格的情况,read_table有一个分割参数sep,它使得用户可以自定义分割符号,进行txt数据的读取。%title插图%num

2、数据写入
pandas中没有定义to_table函数,但是to_csv可以保存为txt文件,并且允许自定义分隔符,常用制表符\t分割:%title插图%num

读取TXT文件,也可以使用上面的read_table,就可避免分隔符问题了。

Windows 10配置网络代理服务器

Windows 10配置网络代理服务器
本文是基于Windows 10系统环境,配置网络代理服务器,Cent OS 7.3希望通过网络参数配置,可以实现通过网络代理服务器连接互联网:

Windows 10
CentOS 7.3

一、配置Windows 10网络代理服务

1. 配置以太网参数
为了保证与CentOS 7.3服务器的连通性,首先配置IP地址,子网掩码、默认网关、DNS

%title插图%num

2. 配置WLAN参数
Windows 10主机是通过WLAN上网的,因此需要配置WLAN参数,选中允许其他网络用户通过此计算机的Internet连接来连接

%title插图%num

3. 配置Cent OS 7.3的网络参数

vi /etc/sysconfig/network-scripts/ifcfg-eth0
# 修改内容如下
TYPE=Ethernet
BOOTPROTO=static
DEFROUTE=yes
PEERDNS=yes
PEERROUTES=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_PEERDNS=yes
IPV6_PEERROUTES=yes
IPV6_FAILURE_FATAL=no
IPV6_ADDR_GEN_MODE=stable-privacy
NAME=eth0
UUID=b583ed4e-a467-43da-af32-117d4f67efe6
DEVICE=eth0
ONBOOT=yes
IPADDR=192.168.10.103
NETMASK=255.255.0.0
GATEWAY=192.168.0.198
DNS=192.168.100.1
DNS1=8.8.8.8
DNS2=114.114.114.114

4. 重启Cent OS 7.3网络
systemctl restart network

5. 测试连通性
ping 192.168.0.198
ping www.baidu.com

pandas基础篇(二)

pandas基础篇(二)
这部分主要整理介绍pandas的基本数据结构及其基础语法
pandas的基本数据结构有两种数据类型:(1)Series
(2) DataFrame

1. Series
1.1 Series的组成
Series的组成由四部分组成:

data :序列的值
index:索引 (索引有它自己的名字属性,默认为NULL)
dtype: 储存类型
name: 序列名字
1.2 定义
#定义Series
import pandas as pd
s = pd.Series(data = [100, ‘a’, {‘dic1’:5}],
index = pd.Index([‘id1’, 20, ‘third’], name=’my_idx’),
dtype = ‘object’,
name = ‘my_name’)
s

运行截图%title插图%num

Object:代表了一种混合类型。正如上面所示,data里既有字符串,又有整数,字典形式等。此外,pandas把纯字符串序列也默认认为是一种object类型的序列,但它也可以用string类型存储。

1.3 Series获取属性
series获取属性,其实和java类似,都是以”.”的方式获取属性和方法。

#获取属性代码如下:
s.values #获取data值,得写成values,不能直接写data
s.index
s.dtype
s.name

部分代码运行截图:%title插图%num

2. DataFrame
DataFrame在Series的基础上增加了列索引,一个数据框可以由二维的data与行列索引来构造:

2.1 两种定义方式
普通定义
data = [[1, ‘a’, 1.2], [2, ‘b’, 2.2], [3, ‘c’, 3.2]]
df = pd.DataFrame(data = data,
index = [‘row_%d’%i for i in range(3)],
columns=[‘col_0’, ‘col_1’, ‘col_2’])
df

运行截图%title插图%num

常用方式
采用从列索引名到数据的映射来构造数据框,同时再加上行索引:
df = pd.DataFrame(data = {‘col_0’: [1,2,3],
‘col_1’:list(‘abc’),
‘col_2’: [1.2, 2.2, 3.2]},
index = [‘row_%d’%i for i in range(3)])
df

2.2 获取属性
与Series类似,在数据框中同样可以取出相应的属性

df.values
df.index

2.3 .T转置
通过.T可以把DataFrame进行转置:

df.T%title插图%num

这一次,阿里云再度将“重构计算”扛在肩头!

引言:冲击业务永续与*致性能,推进自研软硬一体与全面云原生,阿里云这是要将“重构计算”进行到底了……

近日,阿里云第三代神龙云服务器风风火火的上新了。

这一幕距离六月基础设施算力升级,搭载第三代神龙云服务器架构的高主频七代发布仅仅过了一个多月。

阿里云弹性计算负责人旭卿说,如此之快还要归功于第三代神龙架构带来的利好尝试。

确实,通过三代神龙架构的强势助力,全新推出的第三代神龙云服务器在各项服务能力上都得到了全面升级。

无论是计算效率还是网络与存储方面的硬实力,均可谓“强势来袭”。

综合性能暴涨160%,第三代神龙云服务器不是一点子智慧
有数据显示,与上一代神龙云服务器同款相比,这次的三代产品综合性能暴涨高达160%,相比目前全球范围内*顶级的云服务器还要快上超过30%,地表强悍有木有?

与第七代ECS企业级高主频实例类似,第三代神龙云服务器在架构上更好地支持了一些四路服务器。

或许大家可能知晓,主流的云服务器过去通常采用的是二路服务器,即一个服务器中携带两颗CPU。

如今创新性选择了更加高密度部署的四路服务器制式,也就是同时携带四颗CPU。不但是单体计算性能得到显著提升,从整机的性能角度上也有很大飞跃。

很明显,四路服务器带来的好处,每颗均摊到整体基础设施的成本,相比之前确实下降不少,当然这也是其整体性能综合提升高达160%的关键所在。

具体来说,第三代神龙云服务器产品家族提供了*多208核、*大6TB内存。

其中云盘IOPS高达 100万、2400万的网络转发以及*高达100G的网络带宽,掐指一算均为全球*高性能水平。

如此表现出挑,根源何处?

旭卿认为第三代神龙架构中的自研神龙芯片很关键。

以云盘IOPS为例,经过阿里云整体性能测试,即便是达到峰值100万的状态,其表现出的延迟也基本呈直线状态,充分说明其性能平稳异于非常。

%title插图%num

 

这主要得益于在架构层面被提供了硬件的QoS能力,其统计的精确程度是传统云盘或者软件层面无法比拟的。

当然,怎样能够在快速互联网迭代方式下,能够解决芯片伴随用户周期迭代,并同时确保稳定性能等,这些统统都提出了很大挑战。

总体来说,在三代神龙架构的推动下,神龙芯片在数据面的加速以及硬件QoS能力上为云服务器以及第六代ECS增强型实例提供了强有力的保障。

如果说进一步提及第三代神龙云服务器的场景优势,“全能选手”或可称为关键词之一。

对此科技星象获悉,在一些通用类的业务中,该产品带来的优势提升表现明显。例如在以持久内存著称的AEP实例中,经常运行的SAP Hana数据库场景、缓存Redis场景以及AI领域经常提及的参数服务器场景中,性能表现都很突出。
%title插图%num

此外,值得强调的一点子智慧,第三代神龙云服务器产品家族还支持CPU、GPU、NPU、FPGA等多种计算形态,具备3分钟交付50万核vCPU的*速扩容能力,被称为云原生的*佳载体。

用旭卿的话说,这就是一款真正的云原生硬件。

谈及这个概念自然免不了说说“买神龙服务器”的梗。

神龙服务器上新之初,的确有很多人纷纷跑来咨询买入并打算在线下使用。

其实回复很简单,神龙服务器很难在线下使用。原因在于其与云计算的结合度很高,并不是一台“拿回家就可以使用”的服务器。

而是需要与阿里云庞大有力的基础设施相融合,通过软硬件协同才能有效发挥*致性能。

如果独立拿出一个硬件使用,对于企业软件的开发成本可谓是增加了更多不必要的负担。
%title插图%num

当然,神龙服务器的“云原生属性”不单单表现在与云计算使用的紧密结合,更重要的是与容器的“天生一对”。

过去人们总认为容器的*佳CP是物理服务器,但其实忽视了几个属于物理服务器的天生缺陷,例如无弹性、不稳定、共性连困难以及迭代速度缓慢等。

而基于神龙架构的云服务器,既具备传统物理机的*佳性能又兼具虚拟机的灵活性。

由于在虚拟化技术中采用了硬件隔离的方式,使服务器的安全性也很高,并且将存储、网络的IO运算封装在芯片中,果断实现了端到端安全。

再加上阿里云本身的迭代周期完全可以达到*快达每周一更新,远远超过了传统意义上半年一迭代的速率。

更重要的是,神龙架构对云原生浪潮下容器等产品适配程度*高。

通过I/O offload芯片加速,高效调度和自动化弹性伸缩的容器化产品可帮助降低50%的计算成本,性能甚至比物理机更优越。

举个例子来说,在典型的双十一场景中,压测过程中我们就会发现,神龙服务器和同规格的物理机相比,在云原生的应用场景下性能会有20%到30%的性能提升。

通常情况下,传统物理机性能在压测中能够达到40%-50%的CPU利用率就已堪称*限,可见与神龙服务器的差异性之大。

第六代增强型实例入驻ECS产品家族,多几个九那都是小事儿
另外在发布中,基于第三代神龙云服务器以及架构,阿里云还构建了新一代ECS产品家族。

其中包括六月初刚刚邀测的第七代高主频实例,以及内存增强硬实例,新一代GPU实例与NPU实例,还涉及超级计算集群实例,非易失性内存APE实例等在内。

在不断扩展服务用户的能力同时,基于第三代神龙云服务器架构的第六代增强型实例也被顺势妥妥纳入其中。

值得提及的一点,该实例由三部分组成,在计算方面阿里云率先自研了Dragonfly Hypervisor,不再使用传统例如KVM、XEN这种虚拟化架构。

除了具备非常轻量级的特性,Dragonfly Hypervisor不仅资源占用少,还在虚拟化效率提升上收效明显。

据悉可以在计算抖动层面做到百万分之一的级别。

此外全系搭配ESSD系列云盘,存储转发能力*多提升四倍。

进一步了解,过去三年间,阿里云方面一直致力于打造新一代SSD云盘。

而通过ESSD可以具备单盘100万IOPS能力,单路延迟*低可以做到100微秒,每一次快照备份可以做到5秒钟之内。

这样一种*致性能,其实大大提升了第六代增强型实例的存储能力。

有数据显示,ESSD还支持10Gbps突发内网带宽,单卷延时大幅下降;性能等级按需配置,在线无损变配,同时使用门槛大幅下降50%。

在网络能力方面,自研的神龙架构也带来了超强网络IO能力,*强可以提供单实例2400万PPS的转发能力。

这就意味着,每个数据包*低延迟可以做到21us。

更重要的是,Mysql和Redis性能提升超过15%,Nginx性能提升达100%。

配合Alibaba Cloud Linux 2 LTS,启动速度*多提升60%,运行时性能提升30%以上且稳定性*多提升50%。

可以说第六代增强型实例算是集大成者,果断继承了第三代神龙云服务器的几乎所有优点。

过去的一个多月的时间,已有超过80%的用户开始使用第六代增强型实例,如今已全球开售。

另外针对内存密集型的应用,例如SAP HANA内存数据库应用,本次发布也推出了业界首款裸金属且经过SAP HANA认证的实例。

实例本身具备208vCPU和*高6个TB内存,无论是支撑OLTP还是OLAP,与传统物理机以及上一代产品相比,都会有35%以上的性价比提升。

“除此之外,安全可信云实例其实也是基于我们对于硬件、固件和操作系统全栈的安全能力基础上推出的可信实例。”

以弹性计算服务为例,阿里云透露,目前单实例的可用性可以做到99.975%;而跨可用区多实例可用性也可做到99.995%。
%title插图%num

总之通过技术和产品创新,提供更高的可靠性、可用性的能力才是关键。

对此阿里云弹性计算负责人旭卿表示,传统服务器主要依赖堆砌硬件提升性能;而阿里云自研的神龙架构更多基于硬件云原生理念,创新性打破了虚拟化技术与CPU、内存、网卡等硬件的天然鸿沟,可发挥出比传统物理机更强的性能。

我们理解,尽管摩尔定律客观左右发展,但通过软硬一体化的思路确实可以将软硬结合的性能潜力激发出来,达成“超摩尔”的效果。

毕竟阿里云就是此工作成功的实践者之一。

关于未来,旭卿坦承,对于神龙架构的存储性能提升、安全合规增强以及SOC方面的规划都会成为继续努力的技术升级方向。

十年进化,重构计算:业务永续+性能*致,一直都是标准旋律
一直以来,云计算被誉为新的计算模式,其弹性计算服务作为*基础核心的产品被业界熟知。

基于此,2010年5月10日,阿里云对外发布的*个商业化的产品就是弹性计算产品,也就是ECS1.0。

从2010年通过发布ECS1.0来服务中小企业站长,到2015年发布ECS2.0来服务诸如12306这种*具挑战的业务场景,再到2017-2018年,上马神龙架构去承担双11这种世界级的难题。

“经过十年进化,我们确实重构了整个计算的服务模式,也具备了服务全业务场景的能力。”

有数据统计,过去十年时间,阿里云的存储性能提升了2000倍,网络性能提升了500倍,整体算力以平均每12个月翻一番的速度增长。

但归于根本,都是为了满足用户*重要的诉求之一,那就是业务永续,即业务永远不要停机、不要宕机。

“一直以来,阿里云都始终坚持自主研发,我们挑剔和控制掌握每一行代码,就是做到为用户提供更加稳定与可靠的服务,保障永不停机的计算服务,是我们的使命。”

这是2019年杭州云栖大会上,阿里巴巴合伙人、阿里云智能基础产品事业部总经理、研究员蒋江伟,花名小邪的压轴之词。

当然在业务永续的基础之上,*致性能的要求更是重中之重。

在过去几年间,阿里云借着软硬一体化的趋势,自研了神龙计算平台、盘古存储平台和洛神网络平台,通过软硬一体化的结合能力来大幅度提升计算效率。

早在2016年阿里云就秘密启动了一项代号为“X-Dragon”的项目,并于2017年推出首款自研神龙云服务器,就独自研发解决方案并重构了云计算的基础设施。

而*新发布的第三代自研神龙架构,更是贯穿了整个IaaS计算平台,并在 IOPS、PPS 等方面提升5倍性能,甚至可以做到在云上获得物理机100%的计算能力。

如今从*早的单一通用计算,到推出异构计算与高性能计算产品,再到目前一系列新品出炉,阿里云弹性计算已覆盖互联网、金融、零售等行业在内的近300种场景,全球22个地域,63个大型的数据中心支撑各种流量高峰。例如12306的春运抢票、微博热点暴涨流量以及钉钉2小时扩容10万台云服务器等。

目前架构已大规模应用于淘宝、天猫、菜鸟等业务,高效解决高峰值的性能瓶颈问题。

据悉以“帮助中小企业更快更好上云,在疫情期间节约IT成本渡过难关”为主题的“以旧换新,10亿元补贴”计划与“培养更多云计算高级人才助力技术产业发展”的高校计划为达成进一步的神龙生态发展,已纷纷启动。

而伴随云计算向纵深方向发展,软硬一体和云原生将成为云计算技术架构的主流。

肉眼可见,阿里云正通过不断推进软硬一体化与全方位云原生化来加快重构基础设施计算层面,这是铁定的主旋律,不过对此,你看好吗?

python基础篇(三)

python基础篇(三)
这篇主要整理pandas常用的基本函数,主要分为五部分:

汇总函数
特征统计函数
唯一值函数
替换函数
排序函数
1、汇总函数
常用的主要是4个:

tail(): 返回表或序列的后n行
head(): 返回表或序列的前n行
info(): 返回表的信息概况
describe(): 返回表中数值列对应的主要统计量
n默认为5
df.describe()

#运行截图
Height Weight
count 183.000000 189.000000
mean 163.218033 55.015873
std 8.608879 12.824294
min 145.400000 34.000000
25% 157.150000 46.000000
50% 161.900000 51.000000
75% 167.500000 65.000000
max 193.900000 89.000000

2、特征统计函数
在Series和DataFrame上定义了许多统计函数,*常见的是:

sum
mean (均值)
median (中位数)
var (方差)
std (标准差)
max
min
用法示例
df_demo = df[[‘Height’, ‘Weight’]]
df_demo.mean()
1
2
聚合函数
quantile (返回分位数)
count (返回非缺失值个数)
idxmax (*大值对应的索引)
聚合函数,有一个公共参数axis,axis=0代表逐列聚合,axis=1表示逐行聚合

df_demo.mean(axis=1).head()
1
3、唯一值函数
唯一值函数常用的四个函数:

unique() : 得到唯一值组成的列表->统计出指定列唯一存在的值有哪些
nunique() :唯一值的个数->统计出指定列唯一存在的值总共有多少个
value_counts() : 得到唯一值和其对应出现的频数
drop_duplicates() : 去重
duplicated()
drop_duplicates()基本用法
关键参数keep
first : 保留*次出现的重复行,删除后面的重复行
last : 删除重复项,除了*后一次出现
False:把所有重复组合所在的行剔除。
需要指定列
代码:

#原本的数据样例
df_demo = df[[‘Gender’,’Transfer’,’Name’]]
df_demo

Gender Transfer Name
0 Female N Gaopeng Yang
1 Male N Changqiang You
2 Male N Mei Sun
3 Female N Xiaojuan Sun
4 Male N Gaojuan You
… … … …
195 Female N Xiaojuan Sun
196 Female N Li Zhao
197 Female N Chengqiang Chu
198 Male N Chengmei Shen
199 Male N Chunpeng Lv
200 rows × 3 columns

#现给Gender,Transfer两列去重
df_demo.drop_duplicates([‘Gender’,’Transfer’])

Gender Transfer Name
0 Female N Gaopeng Yang
1 Male N Changqiang You
12 Female NaN Peng You
21 Male NaN Xiaopeng Shen
36 Male Y Xiaojuan Qin
43 Female Y Gaoli Feng

由此可见,使用了first参数,保留*次出现的重复行,删除后面的重复行
在未指定参数的情况下,keep默认first;

指定last
案例如下:

df_demo.drop_duplicates([‘Gender’, ‘Transfer’], keep=’last’)
1
Gender Transfer Name
147 Male NaN Juan You
150 Male Y Chengpeng You
169 Female Y Chengquan Qin
194 Female NaN Yanmei Qian
197 Female N Chengqiang Chu
199 Male N Chunpeng Lv

last:删除所有的重复行,只保留出现的*后一个
drop_duplicates() & duplicated()的区别
duplicated和drop_duplicates的功能类似,但前者返回了是否为唯一值的布尔列表,其keep参数与后者一致。其返回的序列,把重复元素设为True,否则为False。 drop_duplicates等价于把duplicated为True的对应行剔除。
4、替换函数
替换函数有三类:

映射函数:replace()…
逻辑函数:(1)where (2)mask
数值替换
replace的用法
#原本的数据
df_demo = df[[‘Gender’,’Transfer’,’Name’]]
df_demo

Gender Transfer Name
0 Female N Gaopeng Yang
1 Male N Changqiang You
2 Male N Mei Sun
3 Female N Xiaojuan Sun
4 Male N Gaojuan You
… … … …
195 Female N Xiaojuan Sun
196 Female N Li Zhao
197 Female N Chengqiang Chu
198 Male N Chengmei Shen
199 Male N Chunpeng Lv
200 rows × 3 columns
1
#替换Gender,女替换为0,男替换为1
df[‘Gender’].replace({‘Female’:0, ‘Male’:1}).head()

Name: Gender, dtype: int64

逻辑替换
逻辑替换包括了where和mask,这两个函数是完全对称的:where函数在传入条件为False的对应行进行替换,而mask在传入条件为True的对应行进行替换,当不指定替换值时,替换为缺失值(NAN)

s = pd.Series([-1, 1.2345, 100, -50])
s.where(s<0)

0 -1.0
1 NaN
2 NaN
3 -50.0
dtype: float64

s.where(s<0, 100)

0 -1.0
1 100.0
2 100.0
3 -50.0
dtype: float64

s.mask(s<0)

0 NaN
1 1.2345
2 100.0000
3 NaN
dtype: float64

centos 下 nginx 使用了 HTTPs,网页访问不了

周一之前 https 可以正常访问,周一之后就不行。问了阿里云那边,阿里云那里可以正常访问。服务器端口都开放了,没有防火墙。域名由于法人更换,有段时间是不行的。现在 80 端口可以访问,就是 443 端口出问题了。切换端口也可以。这是什么问题啊?

tomwen 1
tomwen 2019-12-31 09:55:11 +08:00
域名能发出来看看吗?
首先端口是不是开了?不能访问是浏览器阻止了还是直接就打不开?是不是证书过期或者自制证书?
guanganqishi 2
guanganqishi 2019-12-31 10:21:35 +08:00 ❤️ 1
@tomwen kubao.360reborn.com:8443 弄了个 8443 端口可以访问 https://kubao.360reborn.com 443 端口不能访问
证书是昨天弄了新的,还是不行。浏览器显示的是连接已重置
sujin190 3
sujin190 2019-12-31 10:52:30 +08:00
香港阿里云的话,一直都有这个问题啊,tsl 连接会被阻断,过几分钟又正常了
guanganqishi 4
guanganqishi 2019-12-31 11:01:44 +08:00
@sujin190 不是香港的,服务器在杭州
ChicC 5
ChicC 2019-12-31 11:04:45 +08:00
配置问题咯
guanganqishi 6
guanganqishi 2019-12-31 11:08:26 +08:00
@ChicC
server {
listen 443 ssl http2;
listen [::]:443 ssl;
server_name *.360reborn.com;
charset utf-8;
access_log logs/kubao.https.access.log main;
error_log logs/kubao.https.error.log error;

index index.php index.html index.htm;

ssl on;
ssl_certificate /usr/local/nginx/ssh/360reborn.pem;
ssl_certificate_key /usr/local/nginx/ssh/360reborn.key;

ssl_session_cache shared:SSL:10m;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP;
ssl_prefer_server_ciphers on;

location / {
root /var/www/kubao/web;
index index.php index.html index.htm;
if (!-e $request_filename) {
rewrite ^(.*)$ /index.php?s=$1 last;
break;
}
}

error_page 404 /404.html;

error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}

location ~ \.php$ {
root /var/www/kubao/web;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}

}

是这样的配置
sujin190 7
sujin190 2019-12-31 11:17:49 +08:00
看了下,tls 就建立不成功,客户端发送 client hello 之后连接被服务器重置了,但是不发送域名是可以成功建立连接的,所以要么是域名备案问题,要么是防火墙有特殊配置,实在不行也可以升级下 nginx 和 openssl 试试
sujin190 8
sujin190 2019-12-31 11:19:08 +08:00
证书和加密套件配置都没有问题,如果域名备案没有问题,防火墙也是正常的,那么 nginx 有 bug 也是可能的
guanganqishi 9
guanganqishi 2019-12-31 11:43:46 +08:00
@sujin190 嗯嗯 好的 谢谢 我再看看吧
sujin190 10
sujin190 2019-12-31 11:53:08 +08:00
看非 443 可以正常用而且是服务器 rst,所以大概率是域名合规问题,实在找不出啥问题可以给阿里云提工单问问

noqwerty 2019-12-31 12:02:30 +08:00 via Android
我这边可以直接打开你的链接啊,浏览器清一下缓存看看?
venhow 12
venhow 2019-12-31 14:33:46 +08:00
没有加载到证书啊
ChicC 13
ChicC 2019-12-31 14:42:46 +08:00
ssl_certificate /usr/local/nginx/ssh/360reborn.pem;
@guanganqishi

是配置 pem 文件吗?不是 crt 吗
justfly 14
justfly 2019-12-31 14:49:37 +08:00
https://47.98.153.226/ 没问题,也能达到正确的证书,所以倾向于证书没啥问题,但是使用域名就有问题,怀疑防火墙或者 SNI 相关逻辑,看看 nginx 的错误日志。
privil 15
privil 2019-12-31 15:10:37 +08:00
本机配置一下 host 域名指向 127.0.0.1 然后 curl 试一下行不行。
privil 16
privil 2019-12-31 15:11:25 +08:00
服务器本机。
jeblur 17
jeblur 2019-12-31 15:16:41 +08:00
正常打开
whnzy 18
whnzy 2020-01-03 16:38:24 +08:00
法人变更,是需要更新备案信息的,因为 2020 年,TLSv1.0 和 TLSv1.1 就不支持了,TLSv1.2 是支持 SNI 的,很容易被监测出来的。
我 ICP 查询,你们是备案的,但是有可能是因为没有更新备案信息。
每个浏览器对 TLSv1.0 和 TLSv1.1 的禁用时间不同,就会导致不同的浏览器会有不同的表现。
希望能帮到你。

python爬虫–协程

python爬虫–协程
基本知识
event_loop:事件循环,相当于一个无限循环,我们可以把一些函数注册到这个事件循环上,当满足某些条件的时候,函数就会被循环执行。
coroutine:携程对象,我们可以将携程对象注册到事件循环中,它会被时间循环调用。我们可以使用async关键字来定义一个方法,这个方法在调用时不会被立即执行,而是返回一个协程对象。
task:任务,它是对协程对象的进一步封装, 包含了任务的各个状态。
future:代表将来执行或还没有执行的任务,实际上和task 没有本质区别。
async定义-个协程.
await用来挂起阻塞方法的执行。
协程的基本使用
import asyncio

async def request(url):
print(‘正在请求的url是:’,url)
print(‘请求成功:’,url)
#async修饰的函数,调用之后返回的一个协程对象
c = request(‘www.baidu.com’)

# #创建一个事件循环对象
# loop = asyncio.get_event_loop()
#
# #将携程对象注册到loop中,然后启动loop
# loop.run_until_complete(c)

# #task的使用
# loop = asyncio.get_event_loop()
# #基于loop创建一个task对象
# task = loop.create_task(c)
# print(task)
# loop.run_until_complete(task)
# print(task)

#future的使用
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(c)
print(task)
loop.run_until_complete(task)
print(task)

多任务协程实现
import asyncio
import time

async def request(url):
print(‘正在请求的url是:’,url)
#在异步协程中如果出现同步模块相关的代码,那么就无法实现异步
#time.sleep(2)
await asyncio.sleep(2)
print(‘请求成功:’,url)
#async修饰的函数,调用之后返回的一个协程对象
start = time.time()
urls = {
‘www.123.com’,
‘www.234.com’,
‘www.345.com’
}
#存放多个任务对象
stask = []
for url in urls:
c = request(url)
task = asyncio.ensure_future(c)
stask.append(task)
loop = asyncio.get_event_loop()

loop.run_until_complete(asyncio.wait(stask))

print(time.time()-start)

多任务协程异步实现
在进行多任务协程实现前,还需要建立一个简单的本地http服务

from flask import Flask
import time

app = Flask(__name__)

@app.route(‘/azb’)
def index_azb():
time.sleep(2)
return ‘Hello azb’

@app.route(‘/xx’)
def index_xx():
time.sleep(2)
return ‘Hello xx’

@app.route(‘/hh’)
def index_hh():
time.sleep(2)
return ‘Hello hh’

if __name__ == ‘__main__’:
app.run(threaded=True)

%title插图%num
实现

import requests,asyncio,time

start = time.time()
urls = [
‘http://127.0.0.1:5000/azb’,’http://127.0.0.1:5000/xx’,’http://127.0.0.1:5000/hh’
]

async def get_page(url):
print(‘正在下载’,url)
#request是基于同步,必须使用基于异步的网络请求模块
response = requests.get(url=url)
print(‘下载成功!’,url)

tasks = []

for url in urls:
c = get_page(url)
task = asyncio.ensure_future(c)
tasks.append(task)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

print(‘总耗时’,time.time()-start)
%title插图%num

aiohttp模块引入
import requests,asyncio,time,aiohttp

start = time.time()
urls = [
‘http://127.0.0.1:5000/azb’,’http://127.0.0.1:5000/xx’,’http://127.0.0.1:5000/hh’
]

async def get_page(url):
async with aiohttp.ClientSession() as session:
async with await session.get(url) as response:
#text()返回字符串形式的响应数据
#read()返回的二进制形式的响应数据
#json()返回的就是json对象
#获取响应数据操作之前一定要使用await进行手动挂起

page_text = await response.text()
print(page_text)

tasks = []

for url in urls:
c = get_page(url)
task = asyncio.ensure_future(c)
tasks.append(task)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

print(‘总耗时’,time.time()-start)%title插图%num

 

协程还是没有理解

Android Fragment 真正的完全解析(上)

自从Fragment出现,曾经有段时间,感觉大家谈什么都能跟Fragment谈上关系,做什么都要问下Fragment能实现不~~~哈哈,是不是有点过~~~

本篇博客力求为大家说明Fragment如何产生,什么是Fragment,Fragment生命周期,如何静态和动态的使用Fragment,Fragment回退栈,Fragment事务;以及Fragment的一些特殊用途,例如:没有布局的Fragment有何用处?Fragment如何与Activity交互?Fragment如何创建对话框?Fragment如何与ActionBar集成等等。

1、Fragment的产生与介绍

Android运行在各种各样的设备中,有小屏幕的手机,超大屏的平板甚至电视。针对屏幕尺寸的差距,很多情况下,都是先针对手机开发一套App,然后拷贝一份,修改布局以适应平板神马超级大屏的。难道无法做到一个App可以同时适应手机和平板么,当然了,必须有啊。Fragment的出现就是为了解决这样的问题。你可以把Fragment当成Activity的一个界面的一个组成部分,甚至Activity的界面可以完全有不同的Fragment组成,更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件,这样就不必在Activity写一堆控件的事件处理的代码了。更为重要的是,你可以动态的添加、替换和移除某个Fragment。

2、Fragment的生命周期

Fragment必须是依存与Activity而存在的,因此Activity的生命周期会直接影响到Fragment的生命周期。官网这张图很好的说明了两者生命周期的关系:

%title插图%num

可以看到Fragment比Activity多了几个额外的生命周期回调方法:
onAttach(Activity)
当Fragment与Activity发生关联时调用。
onCreateView(LayoutInflater, ViewGroup,Bundle)
创建该Fragment的视图
onActivityCreated(Bundle)
当Activity的onCreate方法返回时调用
onDestoryView()
与onCreateView想对应,当该Fragment的视图被移除时调用
onDetach()
与onAttach相对应,当Fragment与Activity关联被取消时调用
注意:除了onCreateView,其他的所有方法如果你重写了,必须调用父类对于该方法的实现,

3、静态的使用Fragment

嘿嘿,终于到使用的时刻了~~

这是使用Fragment*简单的一种方式,把Fragment当成普通的控件,直接写在Activity的布局文件中。步骤:

1、继承Fragment,重写onCreateView决定Fragemnt的布局

2、在Activity中声明此Fragment,就当和普通的View一样

下面展示一个例子(我使用2个Fragment作为Activity的布局,一个Fragment用于标题布局,一个Fragment用于内容布局):

TitleFragment的布局文件:

  1. <?xml version=”1.0″ encoding=”utf-8″?>
  2. <RelativeLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  3. android:layout_width=“match_parent”
  4. android:layout_height=“45dp”
  5. android:background=“@drawable/title_bar” >
  6. <ImageButton
  7. android:id=“@+id/id_title_left_btn”
  8. android:layout_width=“wrap_content”
  9. android:layout_height=“wrap_content”
  10. android:layout_centerVertical=“true”
  11. android:layout_marginLeft=“3dp”
  12. android:background=“@drawable/showleft_selector” />
  13. <TextView
  14. android:layout_width=“fill_parent”
  15. android:layout_height=“fill_parent”
  16. android:gravity=“center”
  17. android:text=“我不是微信”
  18. android:textColor=“#fff”
  19. android:textSize=“20sp”
  20. android:textStyle=“bold” />
  21. </RelativeLayout>

TitleFragment

  1. package com.zhy.zhy_fragments;
  2. import android.app.Fragment;
  3. import android.os.Bundle;
  4. import android.view.LayoutInflater;
  5. import android.view.View;
  6. import android.view.View.OnClickListener;
  7. import android.view.ViewGroup;
  8. import android.widget.ImageButton;
  9. import android.widget.Toast;
  10. public class TitleFragment extends Fragment
  11. {
  12. private ImageButton mLeftMenu;
  13. @Override
  14. public View onCreateView(LayoutInflater inflater, ViewGroup container,
  15. Bundle savedInstanceState)
  16. {
  17. View view = inflater.inflate(R.layout.fragment_title, container, false);
  18. mLeftMenu = (ImageButton) view.findViewById(R.id.id_title_left_btn);
  19. mLeftMenu.setOnClickListener(new OnClickListener()
  20. {
  21. @Override
  22. public void onClick(View v)
  23. {
  24. Toast.makeText(getActivity(),
  25. “i am an ImageButton in TitleFragment ! “,
  26. Toast.LENGTH_SHORT).show();
  27. }
  28. });
  29. return view;
  30. }
  31. }

同理还有ContentFragment的其布局文件:

  1. <?xml version=”1.0″ encoding=”utf-8″?>
  2. <LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  3. android:layout_width=“match_parent”
  4. android:layout_height=“match_parent”
  5. android:orientation=“vertical” >
  6. <TextView
  7. android:layout_width=“fill_parent”
  8. android:layout_height=“fill_parent”
  9. android:gravity=“center”
  10. android:text=“使用Fragment做主面板”
  11. android:textSize=“20sp”
  12. android:textStyle=“bold” />
  13. </LinearLayout>

 

  1. package com.zhy.zhy_fragments;
  2. import android.app.Fragment;
  3. import android.os.Bundle;
  4. import android.view.LayoutInflater;
  5. import android.view.View;
  6. import android.view.ViewGroup;
  7. public class ContentFragment extends Fragment
  8. {
  9. @Override
  10. public View onCreateView(LayoutInflater inflater, ViewGroup container,
  11. Bundle savedInstanceState)
  12. {
  13. return inflater.inflate(R.layout.fragment_content, container, false);
  14. }
  15. }

MainActivity

  1. package com.zhy.zhy_fragments;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. import android.view.Window;
  5. public class MainActivity extends Activity
  6. {
  7. @Override
  8. protected void onCreate(Bundle savedInstanceState)
  9. {
  10. super.onCreate(savedInstanceState);
  11. requestWindowFeature(Window.FEATURE_NO_TITLE);
  12. setContentView(R.layout.activity_main);
  13. }
  14. }

Activity的布局文件:

  1. <RelativeLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  2. xmlns:tools=“http://schemas.android.com/tools”
  3. android:layout_width=“match_parent”
  4. android:layout_height=“match_parent” >
  5. <fragment
  6. android:id=“@+id/id_fragment_title”
  7. android:name=“com.zhy.zhy_fragments.TitleFragment”
  8. android:layout_width=“fill_parent”
  9. android:layout_height=“45dp” />
  10. <fragment
  11. android:layout_below=“@id/id_fragment_title”
  12. android:id=“@+id/id_fragment_content”
  13. android:name=“com.zhy.zhy_fragments.ContentFragment”
  14. android:layout_width=“fill_parent”
  15. android:layout_height=“fill_parent” />
  16. </RelativeLayout>

是不是把Fragment当成普通的View一样声明在Activity的布局文件中,然后所有控件的事件处理等代码都由各自的Fragment去处理,瞬间觉得Activity好干净有木有~~代码的可读性、复用性以及可维护性是不是瞬间提升了~~~下面看下效果图:

%title插图%num

4、动态的使用Fragment

上面已经演示了,*简单的使用Fragment的方式~下面介绍如何动态的添加、更新、以及删除Fragment

为了动态使用Fragment,我们修改一下Actvity的布局文件,中间使用一个FrameLayout,下面添加四个按钮~~~嘿嘿~~不是微信的按钮- -!

  1. <RelativeLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  2. xmlns:tools=“http://schemas.android.com/tools”
  3. android:layout_width=“match_parent”
  4. android:layout_height=“match_parent” >
  5. <fragment
  6. android:id=“@+id/id_fragment_title”
  7. android:name=“com.zhy.zhy_fragments.TitleFragment”
  8. android:layout_width=“fill_parent”
  9. android:layout_height=“45dp” />
  10. <include
  11. android:id=“@+id/id_ly_bottombar”
  12. android:layout_width=“fill_parent”
  13. android:layout_height=“55dp”
  14. android:layout_alignParentBottom=“true”
  15. layout=“@layout/bottombar” />
  16. <FrameLayout
  17. android:id=“@+id/id_content”
  18. android:layout_width=“fill_parent”
  19. android:layout_height=“fill_parent”
  20. android:layout_above=“@id/id_ly_bottombar”
  21. android:layout_below=“@id/id_fragment_title” />
  22. </RelativeLayout>

底部四个按钮的布局就不贴了,到时看效果图就明白了~~

下面主Activity

  1. package com.zhy.zhy_fragments;
  2. import android.app.Activity;
  3. import android.app.FragmentManager;
  4. import android.app.FragmentTransaction;
  5. import android.os.Bundle;
  6. import android.view.View;
  7. import android.view.View.OnClickListener;
  8. import android.view.Window;
  9. import android.widget.LinearLayout;
  10. public class MainActivity extends Activity implements OnClickListener
  11. {
  12. private LinearLayout mTabWeixin;
  13. private LinearLayout mTabFriend;
  14. private ContentFragment mWeixin;
  15. private FriendFragment mFriend;
  16. @Override
  17. protected void onCreate(Bundle savedInstanceState)
  18. {
  19. super.onCreate(savedInstanceState);
  20. requestWindowFeature(Window.FEATURE_NO_TITLE);
  21. setContentView(R.layout.activity_main);
  22. // 初始化控件和声明事件
  23. mTabWeixin = (LinearLayout) findViewById(R.id.tab_bottom_weixin);
  24. mTabFriend = (LinearLayout) findViewById(R.id.tab_bottom_friend);
  25. mTabWeixin.setOnClickListener(this);
  26. mTabFriend.setOnClickListener(this);
  27. // 设置默认的Fragment
  28. setDefaultFragment();
  29. }
  30. private void setDefaultFragment()
  31. {
  32. FragmentManager fm = getFragmentManager();
  33. FragmentTransaction transaction = fm.beginTransaction();
  34. mWeixin = new ContentFragment();
  35. transaction.replace(R.id.id_content, mWeixin);
  36. transaction.commit();
  37. }
  38. @Override
  39. public void onClick(View v)
  40. {
  41. FragmentManager fm = getFragmentManager();
  42. // 开启Fragment事务
  43. FragmentTransaction transaction = fm.beginTransaction();
  44. switch (v.getId())
  45. {
  46. case R.id.tab_bottom_weixin:
  47. if (mWeixin == null)
  48. {
  49. mWeixin = new ContentFragment();
  50. }
  51. // 使用当前Fragment的布局替代id_content的控件
  52. transaction.replace(R.id.id_content, mWeixin);
  53. break;
  54. case R.id.tab_bottom_friend:
  55. if (mFriend == null)
  56. {
  57. mFriend = new FriendFragment();
  58. }
  59. transaction.replace(R.id.id_content, mFriend);
  60. break;
  61. }
  62. // transaction.addToBackStack();
  63. // 事务提交
  64. transaction.commit();
  65. }
  66. }

可以看到我们使用FragmentManager对Fragment进行了动态的加载,这里使用的是replace方法~~下一节我会详细介绍FragmentManager的常用API。

注:如果使用Android3.0以下的版本,需要引入v4的包,然后Activity继承FragmentActivity,然后通过getSupportFragmentManager获得FragmentManager。不过还是建议版Menifest文件的uses-sdk的minSdkVersion和targetSdkVersion都改为11以上,这样就不必引入v4包了。

代码中间还有两个Fragment的子类,ContentFragment上面已经见过,FriendFragment其实类似:

  1. package com.zhy.zhy_fragments;
  2. import android.app.Fragment;
  3. import android.os.Bundle;
  4. import android.view.LayoutInflater;
  5. import android.view.View;
  6. import android.view.ViewGroup;
  7. public class FriendFragment extends Fragment
  8. {
  9. @Override
  10. public View onCreateView(LayoutInflater inflater, ViewGroup container,
  11. Bundle savedInstanceState)
  12. {
  13. return inflater.inflate(R.layout.fragment_friend, container, false);
  14. }
  15. }

效果图:

%title插图%num

可以看到很好的实现了效果,有兴趣可以看看。

5、Fragment家族常用的API

Fragment常用的三个类:

android.app.Fragment 主要用于定义Fragment

android.app.FragmentManager 主要用于在Activity中操作Fragment

android.app.FragmentTransaction 保证一些列Fragment操作的原子性,熟悉事务这个词,一定能明白~

a、获取FragmentManage的方式:

getFragmentManager() // v4中,getSupportFragmentManager

b、主要的操作都是FragmentTransaction的方法

FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务

transaction.add() 

往Activity中添加一个Fragment

transaction.remove()

从Activity中移除一个Fragment,如果被移除的Fragment没有添加到回退栈(回退栈后面会详细说),这个Fragment实例将会被销毁。

transaction.replace()

使用另一个Fragment替换当前的,实际上就是remove()然后add()的合体~

transaction.hide()

隐藏当前的Fragment,仅仅是设为不可见,并不会销毁

transaction.show()

显示之前隐藏的Fragment

detach()

会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。

attach()

重建view视图,附加到UI上并显示。

transatcion.commit()//提交一个事务

注意:常用Fragment的哥们,可能会经常遇到这样Activity状态不一致:State loss这样的错误。主要是因为:commit方法一定要在Activity.onSaveInstance()之前调用。

上述,基本是操作Fragment的所有的方式了,在一个事务开启到提交可以进行多个的添加、移除、替换等操作。

值得注意的是:如果你喜欢使用Fragment,一定要清楚这些方法,哪个会销毁视图,哪个会销毁实例,哪个仅仅只是隐藏,这样才能更好的使用它们。

a、比如:我在FragmentA中的EditText填了一些数据,当切换到FragmentB时,如果希望会到A还能看到数据,则适合你的就是hide和show;也就是说,希望保留用户操作的面板,你可以使用hide和show,当然了不要使劲在那new实例,进行下非null判断。

b、再比如:我不希望保留用户操作,你可以使用remove(),然后add();或者使用replace()这个和remove,add是相同的效果。

c、remove和detach有一点细微的区别,在不考虑回退栈的情况下,remove会销毁整个Fragment实例,而detach则只是销毁其视图结构,实例并不会被销毁。那么二者怎么取舍使用呢?如果你的当前Activity一直存在,那么在不希望保留用户操作的时候,你可以优先使用detach。

上述已经介绍完成了Fragment常用的一些方法,相信看完,大家一定清楚了Fragment的产生理由,以及如何使用Fragment,再根据API的讲解,也能明白,曾经为何觉得Fragment会出现一些列乱七八槽的问题,终究是因为没有弄清楚其生命周期。

由于篇幅原因,剩下的内容留到下一篇了。在下一篇,会介绍:

1、如何管理Fragment回退栈

2、Fragment如何与Activity交互

3、Fragment与Activity交互的*佳实践

4、没有视图的Fragment的用处

5、使用Fragment创建对话框

6、如何与ActionBar,MenuItem集成等~~

 

会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。

Ivanti Neurons™神经元:远程边缘设备实现自主、自动、自助管理

打造可愈合的自主边缘(Autonomous Edge),让远程工作人员提前结合上下文,实现远程边缘设备的自助管理。

近日,致力于通过统一IT为企业用户提供更加高效安全数字化工作场所的Ivanti发布了基于深度学习技术的超级自动化平台——Ivanti Neurons™ 神经元。

该平台赋予企业自主愈合和保护边缘设备的能力,并重新诠释了为*终用户提供IT自助服务的理念。

通过一系列智能应用,*终用户可自主进行检测和修复边缘设备,企业IT团队的服务效率将获得大幅提升,管理成本显著减少。

目前,已采用Ivanti Neurons™ 神经元的企业可将意外停运时间减少63%,部署安全升级的时间缩短88%,并在用户上报之前解决多达80%的端点设备问题。

%title插图%num

Ivanti Neurons™神经元的全新上线,标志着Ivanti进一步实现其预见性和前瞻性,即打造超级自动化平台,帮助企业用户有效地应对日益繁复的设备、数据和远程工作人员的管理问题,以及层出不穷的安全威胁,助力企业IT管理从基础的自动化转型,走向成熟的超级自动化,为远程工作人员提供可愈合的自主体验,帮助其提前结合自身状况,实现远程边缘设备的自助管理。

Ivanti执行副总裁兼首席产品总监Nayaki Nayyar表示:“随着远程工作模式成为下一个常态,Ivanti Neurons™ 神经元不仅为企业提供了自主修复和保护端点设备的能力,还为员工提供了 ‘随时随地工作’的无缝体验。借助可自主检修和保护边缘端点设备的智能应用,IT部门将实现‘及早发现,及时解决问题’的工作目标。”

金斯顿大学技术服务负责人Daniel Bolton表示:“Ivanti Neurons™神经元提供主动式监测,让我们随时掌握各设备电池的使用情况及寿命,节省了大量资产采购和维修成本。而且,Ivanti Neurons™神经元能在短时间内为技术部门提供动态信息,帮助我们做出更合理的决策,确保在校员工和学生高效地完成工作及学习。”

Ivanti Neurons™超级自动化平台,可为企业及组织提供多项功能,包括:

· Ivanti Neurons™ for Edge Intelligence边缘设备智能化: 这项基于自然语言处理技术(NLP)的功能,将帮助IT团队快速查询所有边缘设备,在短时间内获取内部整体信息;它还拥有基于传感器的架构,可以帮助企业迅速了解边缘设备的运营环境,实时清点资产,并做好安全配置。

· Ivanti Neurons™ for Healing自我治疗:该功能可提供一系列智能应用,可主动检测、诊断和自动修复端点设备的配置问题、合规问题及安全问题,实现常规任务自动化,为打造真正的IT自愈合环境铺平道路,大大提升效率并缩减成本,改善用户体验。

· Ivanti Neurons™ for Discovery发现:该功能可在短时间内提供准确而实用的资产信息,通过主动扫描、被动扫描和第三方连接器,提供实时的可视化功能。这些规范化的软硬件资产清点数据、软件使用信息以及实用的洞察,有助于高效地配置管理数据库和资产管理数据库。

· Ivanti Neurons™ Workspace工作空间:该功能基于实时数据,提供了从设备、用户,到应用程序和服务的360度全方位视图,可帮助一线IT人员解决原本需要向专家上报的问题,消除问题上报带来的复杂性,同时缩短等待时间并降低上报成本,有助于加快解决*终用户的问题,大幅提高工作效率。