本文目录一览：

如何使用python访问ECMWF公共数据集
python怎么连接mysql数据库
如何在Python中访问HBase的数据
Python网络编程6-使用Pysnmp实现简单网管
python 运维常用脚本

如何使用python访问ECMWF公共数据集

1. 安装ECMWF KEY

如果您没有帐户，请通过 https://apps.ecmwf.int/registration/ 进行自我注册，然后转到以下步骤。登录 https://apps.ecmwf.int/auth/login/ 通过 https://api.ecmwf.int/v1/key/ 获取密钥请注意，该密钥在1年内到期。您将在到期日期前1个月收到注册电子邮件地址的电子邮件，并附上续订说明。要查看当前密钥登录的到期日期，请访问复制此页面中的信息，并将其粘贴到文件 $HOME/.ecmwfapirc（Unix/Linux）或 %USERPROFILE%\.ecmwfapirc（Windows）

如何创建前导点文件？

创建 file.txt，然后重命名为 .file，最后一个点将被删除，你就得到 .file。我们需要创建 .ecmwfapirc 文件，并将下面内容拷贝进去：

{
  "url": "",
  "key": "XXXXXXXXXXXXXXXXXX",
  "email": "example@123.com"
}

将 .ecmwfapirc 放在 %USERPROFILE% 下，例如路径为 C:\Users\Cronous。

2. 安装客户端库

该版本的库提供对 Python 2.7.x 和 Python 3 的支持。在 Unix/Linux 上运行：

sudo pip install ecmwfapi

在 Windows 上：

pip install ecmwfapi

如果您无法运行 sudo 或 pip 命令，只需下载 ecmwf-api-client-python.tgz。提取其内容并将模块复制到环境变量 PYTHONPATH 指向的目录中。

3. 检查数据可用性

要查看 ECMWF Public Datasets 的可用性，请访问 Web 界面：使用此界面，您可以发现我们存档中提供的所有 ECMWF 公用数据集。我们强烈建议您浏览我们的公共数据集以熟悉其可用性。您可以选择一个公共数据集，并开始浏览其内容。请考虑有关内容的一些注意事项：

不同的 ECMWF 公共数据集包括不同的“参数”，“时间”和“步骤”
在每个 ECMWF 公共数据集中，并非所有“参数”都可以从所有“步骤”
在每个 ECMWF 公共数据集中，并非所有“时间”都提供所有“步骤” 上面的 Web 界面将帮助您检查和了解可用性。对于任何类型的选择，系统将以动态方式更新属性以反映当前的可用性。（即如果您更改步骤，一些参数将被添加或删除）。

小费

选择完成后，我们鼓励用户使用页面底部的“查看MARS请求”功能。使用这个MARS请求，你可以建立自己的Python脚本。这里说一下查看MARS请求可以自动生成python脚本样例文件，我们可以对照着学习一下，如下面的我选择的数据源：自动生成的python脚本如下：

#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
    "class": "ti",
    "dataset": "tigge",
    "date": "2017-10-01/to/2017-10-20",
    "expver": "prod",
    "grid": "0.5/0.5",
    "levtype": "sfc",
    "origin": "ecmf",
    "param": "134/167/228228",
    "step": "0/6/12/18/24/30/36/42/48/54/60/66/72/78/84/90/96/102/108/114/120/126/132/138/144/150/156/162/168/174/180/186/192/198/204/210/216/222/228/234/240/246/252/258/264/270/276/282/288/294/300/306/312/318/324/330/336/342/348/354/360",
    "time": "00:00:00/12:00:00",
    "type": "cf",
    "target": "output",
})

我们可以对照着学习一下。这里给出一个 TIGGE 数据源的示例：

TIGGE压力水平控制预测

#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
    'origin': "kwbc",
    'levelist': "200/250/300/500/700/850/925/1000",
    'levtype': "pl",
    'expver': "prod",
    'dataset': "tigge",
    'step': "0/6/12/18/24/30",
    'grid': "0.5/0.5",
    'param': "131/132",
    'time': "00/06/12/18",
    'date': "2014-10-01",
    'type': "cf",
    'class': "ti",
    'target': "tigge_2014-10-01_00061218.grib"
})

TIGGE表面扰动预测

#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
    'origin': "ecmf",
    'levtype': "sfc",
    'number': "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",
    'expver': "prod",
    'dataset': "tigge",
    'step': "0/6/12/18",
    'grid': "0.5/0.5",
    'param': "167",
    'time': "00/12",
    'date': "2014-11-01",
    'type': "pf",
    'class': "ti",
    'target': "tigge_2014-11-01_0012.grib"
})

来自日本东京日本的 rjtd：

#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
    'origin': "rjtd",
    'levtype': "sfc",
    'number': "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",
    'expver': "prod",
    'dataset': "tigge",
    'step': "0/6/12/18",
    'grid': "0.5/0.5",
    'param': "167",
    'time': "00/12",
    'date': "2014-11-01",
    'type': "pf",
    'class': "ti",
    'target': "tigge_2014-11-01_0012.grib"
})

来自 rksl，韩国：

#!/usr/bin/env python
from ecmwfapi import ECMWFDataServer
server = ECMWFDataServer()
server.retrieve({
    'origin': "rksl",
    'levtype': "sfc",
    'number': "1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23",
    'expver': "prod",
    'dataset': "tigge",
    'step': "0/6/12/18",
    'grid': "0.5/0.5",
    'param': "167",
    'time': "00/12",
    'date': "2014-11-01",
    'type': "pf",
    'class': "ti",
    'target': "tigge_2014-11-01_0012.grib"
})

监控您的请求（python中我如何知道是否成功，如何取消请求）

根据一些因素和限制，请求可能需要一些时间（从几分钟到几个小时）才能完成。（例如，您提交的请求数，Nr当前正在运行的总活动请求数量，所涉及资源的可用性，最重要的是您的请求效率）如何追溯旧请求？您的工作列表可用于跟踪旅游请求。您还可以使用 Web-API 活动和 MARS 活动页面。请参阅为什么 MARS 活动很重要。哪个是取消请求的最佳方式？如果您想取消请求，请访问您的工作，并单击取消选项。一旦你已经取消了它，请求的状态将成为中止。取消不是推荐的方法，因为它可能会影响其他提交的请求的性能。参见下一个常见问题。我可以在本地环境中杀死我的请求（例如通过 CTRL + C）如果您只是在本地环境中杀死一个 Web API 请求（例如通过 CTRL + C），那么在 web-API 服务级别上的相应作业不会被取消，但仍在运行。您的请求将在您的工作列表中继续有效。这个是查看请求的列表的网站，执行完的请求数据以及请求状态都可以看到，请求完成的数据也可以在这里下载。请参阅以前的常见问题，以查看如何正确取消您的请求。我的请求已经排队（或活动）了很长时间。我要杀了吗？根据许多因素和限制，请求可能需要一些时间才能完成。访问您的工作列表以查看请求的状态您可能需要访问我们的疑难解答页面了解更多信息。

进一步

我可以要求“netcdf”格式的数据吗？是的，你只需要添加你的请求 "format": "netcdf" 我可以要求有限区域吗？是如果您已经在请求中设置了 "grid" 关键字，可以添加 "area": "coordinates" 关键字。您可以设置预定义的区域，例如欧洲，或者使用北/西/南/东的坐标设置区域。您还可以访问 MARS 区域关键字以获取更多信息：后处理关键字。见下面的例子。

"area": "europe",
// #area: N/W/S/E
// #europe"area": "75/-20/10/60",
// #africa"area": "40/-20/-40/60",

由 Cristian Simarro 创建，最后修改于五月 11，2015

python怎么连接mysql数据库

在 Python 语言环境下我们这样连接数据库。

from mysql import connector
cnx = connector.connect(host="172.16.192.100", port=3306, user="appuser", password="xxxxxx")

但是连接数据库的背后发生了什么呢？当我们通过驱动程序（mysql-connector-python, pymysql）连接 MySQL 服务端的时候，就是把连接参数传递给驱动程序，驱动程序再根据参数会发起到 MySQL 服务端的 TCP 连接。当 TCP 连接建立之后驱动程序与服务端之间会按特定的格式和次序交换数据包，数据包的格式和发送次序由 MySQL 协议规定。 MySQL 协议：整个连接的过程中 MySQL 服务端与驱动程序之间，按如下的次序发送了这些包。

MySQL 服务端向客户端发送一个握手包，包里记录了 MySQL-Server 的版本，默认的授权插件，密码盐值（auth-data）。
MySQL 客户端发出 ssl 连接请求包（如果有必要的话）。
MySQL 客户端发出握手包的响应包，这个包时记录了用户名，密码加密后的串，客户端属性，等等其它信息。
MySQL 服务端发出响应包，这个包里记录了登录是否成功，如果没有成功也会给出错误信息。

如何在Python中访问HBase的数据

Python连接HBase时需要先加载Thrift和HBase的相关包，之后创建与HBase的连接并进行后续操作，具体代码如下：

# -*- coding: utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
from thrift.transport.TSocket import TSocket
from thrift.transport.TTransport import TBufferedTransport
from thrift.protocol import TBinaryProtocol
from hbase import Hbase
from hbase.ttypes import *
class HBaseOperator():
    def __init__(self):
        self.host = "ip_address"
        self.port = 9090
        self.transport = TBufferedTransport(TSocket(self.host, self.port))
        self.transport.open()
        self.protocol = TBinaryProtocol.TBinaryProtocol(self.transport)
        self.client = Hbase.Client(self.protocol)
    def __del__(self):
        self.transport.close()
    def getAllTablesInfo(self):
        # get table info
        listTables = self.client.getTableNames()
        print("="*40)
        print("Show all tables information....")
        for tableName in listTables:
            print("TableName:" + tableName)
            print(" ")
            listColumns = self.client.getColumnDescriptors(tableName)
            print(listColumns)
            print(" ")
            listTableRegions = self.client.getTableRegions(tableName)
            print(listTableRegions)
            print("+"*40)

Python网络编程6-使用Pysnmp实现简单网管

简单网络管理协议 SNMP（Simple Network Management Protocol）用于网络设备的管理。SNMP 作为广泛应用于 TCP/IP 网络的网络管理标准协议，提供了统一的接口，从而实现了不同种类和厂商的网络设备之间的统一管理。 SNMP 协议分为三个版本：SNMPv1、SNMPv2c 和 SNMPv3。 SNMP 系统由网络管理系统 NMS（Network Management System）、SNMP Agent、被管对象 Management object 和管理信息库 MIB（Management Information Base）四部分组成。 SNMP 查询是指 NMS 主动向 SNMP Agent 发送查询请求。SNMP Agent 接收到查询请求后，通过 MIB 表完成相应指令，并将结果反馈给 NMS。SNMP 查询操作有三种：Get、GetNext 和 GetBulk。SNMPv1 版本不支持 GetBulk 操作。不同版本的 SNMP 查询操作的工作原理基本一致，唯一的区别是 SNMPv3 版本增加了身份验证和加密处理。 SNMP 设置是指 NMS 主动向 SNMP Agent 发送对设备进行 Set 操作的请求。SNMP Agent 接收到 Set 请求后，通过 MIB 表完成相应指令，并将结果反馈给 NMS。不同版本的 SNMP Set 操作的工作原理基本一致，唯一的区别是 SNMPv3 版本增加了身份验证和加密处理。 SNMP Traps 是指 SNMP Agent 主动将设备产生的告警或事件上报给 NMS，以便网络管理员及时了解设备当前运行的状态。 SNMP Agent 上报 SNMP Traps 有两种方式：Trap 和 Inform。SNMPv1 版本不支持 Inform。Trap 和 Inform 的区别在于，SNMP Agent 通过 Inform 向 NMS 发送告警或事件后，NMS 需要回复 InformResponse 进行确认。在 Ensp 中搭建网络环境，在 R2 上启用 SNMP 作为 SNMP agent，Linux 主机作为 NMS；为方便观察 SNMP 报文格式，在 R2 使用 SNMP 的版本为 v2c。通过下面的 Python 脚本获取 R2 的系统信息与当前的主机名：

# 示例代码

运行结果如下：在 R2 接口上抓包结果如下，Linux 主机向 R2 的 161 端口发送 SNMP get-request 报文，可以看到 SNMP 使用的版本为 v2c，设置的团体名为 public，随机生成了一个 request-id，变量绑定列表（Variable bindings），即要查询的 OID，但 Value 为空；值得注意的是这些信息都是明文传输的，为了安全在实际环境中应使用 SNMPv3。通过下面的 Python 脚本获取 R2 的接口信息。运行结果如下：在 R2 接口抓包结果如下，getBuikRequest 相比 get-request 设置了一个 max-repetitions 字段，表明最多执行 get 操作的次数。Variable bindings 中请求的 OID 条目只有一条。下面 Python 脚本用于设置 R2 的主机名为 SNMPv2R2。运行结果如下：在路由器上可以看到主机名有 R2 变为了 SNMPv2R2。 get-response 数据包内容与 set-request 中无异。下面 Python 脚本用于接收，R2 发送的 Trap，并做简单解析。先运行该脚本，之后再 R2 上手动将一个接口 shutdown，结果如下：接口上抓包结果如下，此时团体名用的是 public，data 部分表明是 trap。由于 Ensp 中的通用路由器认证算法只支持 des56，而 pysnmp 不支持该算法，因此使用 AR 路由器配置 SNMPv3。使用下面 Python 脚本发送 snmpv3 get 报文获取设备系统信息。抓包结果如下，首先发送 get-resques 进行 SNMPv3 认证请求，随机生成一个 msgID，认证模式为 USM，msgflgs 中 Reportable 置 1 要求对方发送 report，其他为置 0，表示不进行加密与鉴权；另外安全参数，认证参数、加密参数都为空，此时不携带 get 请求数据。路由器给 NMS 回复 report，msgID 与 resquest 一致，Msgflgs 中各位都置 0，同时回复使用的安全引擎，认证与加密参数为空，不进行认证与加密，因此能看到 data 中的数据。 AR1 收到请求后进行回复，数据包中 msgflags 标志位中除 reportable 外其他位都置 1，表示不需要回复，同时进行加密与鉴权。同样也可以看到认证用户为 testuser，认证参数与加密参数都有填充，data 部分也是同样加密。参考：

python 运维常用脚本

Python 批量遍历目录文件,并修改访问时间

import os
path = "D:/UASM64/include/"
dirs = os.listdir(path)
temp = []
for file in dirs:
    temp.append(os.path.join(path, file))
for x in temp:
    os.utime(x, (1577808000, 1577808000))

Python 实现的自动化服务器管理

import sys
import os
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
def ssh_cmd(user, passwd, port, userfile, cmd):
    pass
def ssh_put(user, passwd, source, target):
    pass
while True:
    try:
        shell = str(input("[Shell] # "))
        if shell == "":
            continue
        elif shell == "exit":
            exit()
        elif shell == "put":
            ssh_put("root", "123123", "./a.py", "/root/a.py")
        elif shell == "cron":
            temp = input("输入一个计划任务: ")
            temp1 = "(crontab -l; echo " + temp + ") |crontab"
            ssh_cmd("root", "123123", "22", "./user_ip.conf", temp1)
        elif shell == "uncron":
            temp = input("输入要删除的计划任务: ")
            temp1 = "crontab -l | grep -v " + temp + "|crontab"
            ssh_cmd("root", "123123", "22", "./user_ip.conf", temp1)
        else:
            ssh_cmd("lyshark", "123123", "22", "./user_ip.conf", shell)
    except Exception as e:
        print(e)

遍历目录和文件

import os
def list_all_files(rootdir):
    _files = []
    list = os.listdir(rootdir)  # 列出文件夹下所有的目录与文件
    for i in range(0, len(list)):
        path = os.path.join(rootdir, list[i])
        if os.path.isdir(path):
            _files.extend(list_all_files(path))
        if os.path.isfile(path):
            _files.append(path)
    return _files
a = list_all_files("C:/Users/LyShark/Desktop/a")
print(a)

python检测指定端口状态

import socket
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.settimeout(1)
for ip in range(0, 254):
    try:
        sk.connect(("192.168.1." + str(ip), 443))
        print("192.168.1.%d server open \n" % ip)
    except Exception:
        print("192.168.1.%d server not open" % ip)
sk.close()

python实现批量执行CMD命令

import sys
import os
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
print("------------------------------\n")
print("使用说明,在当前目录创建ip.txt写入ip地址")
print("------------------------------\n")
user = input("输入用户名:")
passwd = input("输入密码:")
port = input("输入端口:")
cmd = input("输入执行的命令:")
file = open("./ip.txt", "r")
line = file.readlines()
for i in range(len(line)):
    print("对IP: %s 执行" % line[i].strip('\n'))

python3-实现钉钉报警

import requests
import sys
import json
dingding_url = ''
data = {"msgtype": "markdown", "markdown": {"title": "监控", "text": "apche异常"}}
headers = {'Content-Type': 'application/json;charset=UTF-8'}
send_data = json.dumps(data).encode('utf-8')
requests.post(url=dingding_url, data=send_data, headers=headers)

判断指定端口是否开放

import socket
port_number = [135, 443, 80]
for index in port_number:
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    result = sock.connect_ex(('127.0.0.1', index))
    if result == 0:
        print("Port %d is open" % index)
    else:
        print("Port %d is not open" % index)
    sock.close()

判断指定端口并且实现钉钉轮询报警

import requests
import sys
import json
import socket
import time
def dingding(title, text):
    dingding_url = ''
    data = {"msgtype": "markdown", "markdown": {"title": title, "text": text}}
    headers = {'Content-Type': 'application/json;charset=UTF-8'}
    send_data = json.dumps(data).encode('utf-8')
    requests.post(url=dingding_url, data=send_data, headers=headers)
def net_scan():
    port_number = [80, 135, 443]
    for index in port_number:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        result = sock.connect_ex(('127.0.0.1', index))
        if result == 0:
            print("Port %d is open" % index)
        else:
            return index
        sock.close()
while True:
    dingding("Warning", net_scan())
    time.sleep(60)

python-实现SSH批量CMD执行命令

import sys
import os
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
def ssh_cmd(user, passwd, port, userfile, cmd):
    file = open(userfile, "r")
    line = file.readlines()
    for i in range(len(line)):
        print("对IP: %s 执行" % line[i].strip('\n'))
        ssh.connect(hostname=line[i].strip('\n'), port=port, username=user, password=passwd)
        stdin, stdout, stderr = ssh.exec_command(cmd)
        result = stdout.read()
        print(result)
ssh_cmd("lyshark", "123", "22", "./ip.txt", "free -h |grep 'Mem:' |awk '{print $3}'")

用python写一个列举当前目录以及所有子目录下的文件，并打印出绝对路径

import sys
import os
for root, dirs, files in os.walk("C://"):
    for name in files:
        print(os.path.join(root, name))

按照这样的日期格式（xxxx-xx-xx）每日生成一个文件，例如今天生成的文件为2013-09-23.log，并且把磁盘的使用情况写到到这个文件中。

import os
import sys
import time
new_time = time.strftime("%Y-%m-%d")
disk_status = os.popen("df -h").readlines()
str1 = ''.join(disk_status)
f = open(new_time + '.log', 'w')
f.write("%s" % str1)
f.flush()
f.close()

统计出每个IP的访问量有多少？（从日志文件中查找）

import sys
list = []
f = open("/var/log/httpd/access_log", "r")
str1 = f.readlines()
f.close()
for i in str1:
    ip = i.split()[0]
    list.append(ip)
list_num = set(list)
for j in list_num:
    num = list.count(j)
    print("%s ----- %s" % (num, j))

写个程序，接受用户输入数字，并进行校验，非数字给出错误提示，然后重新等待用户输入。

import sys
while True:
    try:
        num = int(input("输入数字：").strip())
        for x in range(2, num + 1):
            for y in range(2, x):
                if x % y == 0:
                    break
            else:
                print(x)
    except ValueError:
        print("您输入的不是数字")
    except KeyboardInterrupt:
        sys.exit("\n")

ps 可以查看进程的内存占用大小，写一个脚本计算一下所有进程所占用内存大小的和。

import sys
import os
list = []
sum = 0
str1 = os.popen("ps aux", "r").readlines()
for i in str1:
    str2 = i.split()
    new_rss = str2[5]
    list.append(new_rss)
for i in list[1:-1]:
    num = int(i)
    sum = sum + num
print("%s --- %s" % (list[0], sum))

关于Python 命令行参数argv

import sys
if len(sys.argv) < 2:
    print("没有输入任何参数")
    sys.exit()
if sys.argv[1].startswith("-"):
    option = sys.argv[1][1:]

利用random生成6位数字加字母随机验证码

import sys
import random
rand = []
for x in range(6):
    y = random.randrange(0, 5)
    if y == 2 or y == 4:
        num = random.randrange(0, 9)
        rand.append(str(num))
    else:
        temp = random.randrange(65, 91)
        c = chr(temp)
        rand.append(c)
result = "".join(rand)
print(result)

自动化-使用pexpect非交互登陆系统

import pexpect
import sys
ssh = pexpect.spawn('ssh lyshark@59.110.167.239')
fout = open('sshlog.txt', 'w')
ssh.logfile = fout
ssh.expect("lyshark@59.110.167.239's password:")
ssh.sendline("密码")
ssh.expect('#')
ssh.sendline('ls /home')
ssh.expect('#')

Python-取系统时间

import sys
import time
time_str = time.strftime("日期：%Y-%m-%d", time.localtime())
print(time_str)
time_str = time.strftime("时间：%H:%M", time.localtime())
print(time_str)