Python常用语法和命令

最新推荐文章于 2024-07-10 09:15:55 发布

夜空中最靓的猪

最新推荐文章于 2024-07-10 09:15:55 发布

阅读量623

点赞数 22

文章标签： python windows 网络运维开发

本文链接：https://blog.csdn.net/Eric_W_/article/details/137454483

版权

1、当前用户下安装setuptools

python setup.py install --user

2、时间转换 date and datetime

int(time.mktime(datetime.datetime.strptime(time_str, “%Y年%m月%d日 %H时%M分%S秒”).timetuple()))
datetime.datetime.strftime() datetime转换成指定格式的日期时间字符串
datetime.datetime.strptime() 字符串转换成指定格式的datetime
time.time() :float类型的当前时间戳
time.gmtime(time.time()) ：将时间戳转换成时间元祖格式
time.mktime(）：将时间元组转换成时间戳

%a 星期的简写。如 星期三为Web
%A 星期的全写。如 星期三为Wednesday
%b 月份的简写。如4月份为Apr
%B 月份的全写。如4月份为April
%c:  日期时间的字符串表示。（如： 04/07/10 10:43:39）
%d:  日在这个月中的天数（是这个月的第几天）
%f:  微秒（范围[0,999999]）
%H:  小时（24小时制，[0, 23]）
%I:  小时（12小时制，[0, 11]）
%j:  日在年中的天数 [001,366]（是当年的第几天）
%m:  月份（[01,12]）
%M:  分钟（[00,59]）
%p:  AM或者PM
%S:  秒（范围为[00,61]，为什么不是[00, 59]，参考python手册~_~）
%U:  周在当年的周数当年的第几周），星期天作为周的第一天
%w:  今天在这周的天数，范围为[0, 6]，6表示星期天
%W:  周在当年的周数（是当年的第几周），星期一作为周的第一天
%x:  日期字符串（如：04/07/10）
%X:  时间字符串（如：10:43:39）
%y:  2个数字表示的年份
%Y:  4个数字表示的年份
%z:  与utc时间的间隔 （如果是本地时间，返回空字符串）
%Z:  时区名称（如果是本地时间，返回空字符串）
%%:  %% => %

3、排序 sort and sorted

1）对于简单list：
list.sort():修改list本身
new_list = sorted(list):不修改list本身
2）对于复杂的元组排序：

           student_tuples = [
               ('john', 'A', 15),
               ('jane', 'B', 12),
               ('dave', 'B', 10),
           ]
           result = sorted(student_tuples, key=lambda student: student[2])
           print result

   # 输出 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

3）对于dict：
sorted（）默认对字典的key进行排序
如果对value进行排序：
my_dict = {“a”:“2”, “c”:“5”, “b”:“1”}
result1 = sorted(my_dict)
result2 = sorted(my_dict, key=lambda x:my_dict[x])
# result1输出:[‘a’, ‘b’, ‘c’]
# result2输出:[‘b’, ‘a’, ‘c’]
sorted()的reverse参数接受False 或者True 表示是否逆序

4、python 读写txt

读：with open(filename,‘r’) as read_txt:
read_txt.read()
写：read_txt.write(str)
https://www.cnblogs.com/youyou0/p/8921719.html

逐行写入txt

f1 = open('query_result.txt','w')
for j in s:
	f1.write(j + '\n')
f1.close()

5、python 读写json

读：
#按行读取：
with open(sys.argv[1], ‘r’) as read_json:
for line in read_json:
load_dict = json.loads(line)
写：
with open(file_path,“wb+”) as csvfile: # python2.x 使用’b’去掉空行，python3.x使用newline属性用于去掉空行

writer = csv.writer(csvfile)
writer.writerow(["timestamp","value"])
data_dict[file_name].sort()
for item in data_dict[file_name]:
    writer.writerow([int(item[0]),int(item[1])])
    csvfile.close()

6、python 读写csv

'w’覆盖写入，'a’追加写入
读：

import csv
csv_reader = csv.reader(open("fileName.csv"))
for row in csv_reader:
    print row

写：

with open(file_name,"wb+") as csvfile: 
    writer = csv.writer(csvfile)
    writer.writerow(["timestamp","value"])
    for item in val_list:
        writer.writerow([int(item[0]),float(item[1])])
    csvfile.close()

7、python 遍历文件夹中的文件

       import os
       import sys
       import csv
       file_path = sys.argv[1]
       for file in os.listdir(file_path):
           if file.endwith(".csv"):
               print file
               with open(os.path.join(file_path,file),'r') as f:  			     					   #os.path.join(file_path,file)  组合file_path和file路径
                   csv_reader = csv.reader(f)
                   for line in csv_reader:
                       print line
                       break 

#创建目录
os.mkdir(path[, mode]) #path表示需要创建的目录路径，mode表示目录权限（默认为0777）

#创建多级目录
os.makedirs()

8、python 冒泡法

       # 冒泡算法降序排列
       a = 0  # 这个可以删除的，因为Python赋值的是指针
       swap = 0
       count = 0
       lst = [1, 2, 9, 6, 3]
       lst_len = len(lst)
       for i in range(lst_len):
           flag = False
           for j in range(lst_len - i - 1):
               count += 1
               if lst[j] 小于 lst[j + 1]:
                   a = lst[j]  # 交换方法一
                   lst[j] = lst[j + 1]
                   lst[j + 1] = a
                   # lst[j],lst[j+1] = lst[j+1],lst[j]  # 交换方法二，原理与方法一一样
                   swap += 1
                   flag = True
           if not flag:
               break
       print("排序结果：{}".format(lst))
       print("交换次数：{}".format(swap))
       print("循环次数：{}".format(count))

9、python 遍历字典

#遍历key
>>> a
{'a': '1', 'b': '2', 'c': '3'}
>>> for key in a:
       print(key+':'+a[key])
 
a:1
b:2
c:3
>>> for key in a.keys():
       print(key+':'+a[key])
 
a:1
b:2
c:3

#遍历value
>>> for value in a.values():
       print(value)
 
1
2
3

#遍历字典项
>>> for kv in a.items():
       print(kv)
 
('a', '1')
('b', '2')
('c', '3')

#遍历键值
>>> for key,value in a.items():
       print(key+':'+value)
 
a:1
b:2
c:3
>>> for (key,value) in a.items():
       print(key+':'+value)
 
a:1
b:2
c:3

10、python 执行GET请求

#python2
import time
import urllib2
import os
import json
import ssl

# ip2system stored path
basic_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

# config path setting
rest_api = "http://0.0.0.0:8080"
config_path_src = "/api/settings/global"
config_path_dst = "/api/service"
token = ""

def get_transfer_type(service_name):
    request_url = rest_api + config_path_dst + service_name
    request = urllib2.Request(request_url)
    request.add_header('Content-Type', 'application/json')
    request.add_header('Authorization', token)
    if request_url.split(":")[0] == "https":
        response = urllib2.urlopen(request, timeout=timeout_sec, context=unverified_context)
    else:
        response = urllib2.urlopen(request)
    data = json.loads(response.read())
    if data["data"].has_key("children"):
        return data["data"]["children"]
    else:
        return []

#python3
import urllib.request
import urllib.parse

def get_kpi_list():
  kpi_dict = {}
  request_url = kpi_url_simp
  headers = {"Content-Type":"application/json","Authorization":token}
  request = urllib.request.Request(request_url,headers=headers)
  response = urllib.request.urlopen(request)
  resp = response.read().decode("utf-8")
  data = json.loads(resp)

11、python 执行POST请求

#python2 urllib2
def upload_volcano_ips(service_name,ips):
    try:
        request_url = rest_api + config_path_dst + service_name
        res_data = json.dumps({"volcano_config":{"success_code":[],"ips":ips}})
        request = urllib2.Request(request_url)
        request.add_header('Content-Type', 'application/json')
        request.add_header('Authorization', token)
        response = urllib2.urlopen(request,data=res_data)
        req = response.read()
    except Exception as e:
        print "Service: %s,catch error: %s" %(service_name,e)  

#python3 urllib
def creat_service(name,kpis):
  request_url = service_url
  data = {"name":name,"monitored_kpi":kpis,"type":"third_level"}
  body = json.dumps(data).encode("utf-8")
  headers = {"Content-Type":"application/json","Authorization":token}
  request = urllib.request.Request(request_url,body,method='POST',headers=headers)
  response = urllib.request.urlopen(request)
  resp = response.read().decode("utf-8")

12、python 执行DELETE请求

def delete_service(service_id):
    try:
        request_url = rest_api + config_path_dst + service_id
        request = urllib2.Request(request_url)
        request.add_header('Content-Type', 'application/json')
        request.add_header('Authorization', token)
        request.get_method = lambda: 'DELETE'
        response = urllib2.urlopen(request)
        req = response.read()
        print req
    except Exception as e:
        print "Service: %s,catch error: %s" %(service_id,e)

13、python 执行curl请求

例：curl -GET 'http://0.0.0.0:8086/query' --data-urlencode "db=test" --data-urlencode "q=show measurements"


代码：

import json
import urllib2
import urllib

cmd_line = 'http://0.0.0.0:8086/query'
cmd_line1 = 'http://0.0.0.0:8086/query --data-urlencode "db=test" --data-urlencode "q=show measurements"'

def get_influxdb_measurements():
    value = {"db":"test","q":"show measurements"}
    data = urllib.urlencode(value)
    request = urllib2.Request(cmd_line,data)
    #request.add_header('Content-Type', 'application/json')
    response = urllib2.urlopen(request)
    req = response.read().decode('utf-8')
    print req

14、python 正则匹配

Python中的正则表达式（Regular Expression，通常简写为regex或regexp）是一种强大的文本处理工具，它允许你使用特定的模式来匹配、查找或替换文本中的字符串。正则表达式由一系列的字符和特殊符号组成，这些字符和符号定义了搜索模式。

下面是一些Python正则表达式中常用的元字符和它们的含义：

.：匹配除了换行符以外的任意字符。
^：匹配字符串的开始。
$：匹配字符串的结束。
*：匹配前面的子表达式零次或多次。
+：匹配前面的子表达式一次或多次。
?：匹配前面的子表达式零次或一次。
{n}：n是一个非负整数。匹配确定的n次。
{n,}：n是一个非负整数。至少匹配n次。
{n,m}：m和n均为非负整数，其中n<=m。匹配至少n次，但不超过m次。
[...]：字符集。匹配方括号中的任意字符。
[^...]：否定字符集。匹配任何不在方括号中的字符。
\：转义字符。用于匹配那些具有特殊意义的字符。
|：或者。匹配|符号前后的任意一项。
(...)：捕获括号。将括号内的内容作为一个整体进行匹配，并可以通过索引获取。
(?...)：非捕获括号。不保存匹配的内容，只作为分组使用。
\d：匹配一个数字字符。等价于[0-9]。
\D：匹配一个非数字字符。等价于[^0-9]。
\s：匹配任何空白字符，包括空格、制表符、换页符等等。
\S：匹配任何非空白字符。
\w：匹配包括下划线的任何单词字符。等价于[a-zA-Z0-9_]。
\W：匹配任何非单词字符。
此外，Python的re模块提供了一系列函数和方法来执行正则表达式的匹配、查找和替换操作。例如：

re.match(pattern, string, flags=0)：从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.search(pattern, string, flags=0)：扫描整个字符串并返回第一个成功的匹配。
re.findall(pattern, string, flags=0)：在字符串中找到正则表达式所匹配的所有子串，并返回一个包含这些子串的列表。
re.sub(pattern, repl, string, count=0, flags=0)：在字符串中查找匹配正则表达式的部分，并用另一个字符串替换它。

IPV4
#简单的匹配给定的字符串是否是ip地址

import re
if re.match(r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$", "236.168.192.1"):
  print "IP vaild"
 else:
  print "IP invaild"
#精确的匹配给定的字符串是否是IP地址
import re
if re.match(r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$", "236.168.192.1"):
  print "IP vaild"
 else:
  print "IP invaild"
#简单从长文本中提取IP
import re
string_ip = "is this 236.168.192.1 ip 12321"
result = re.findall(r"\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b", string_ip)
if result:
  print result
else:
  print "re cannot find ip"

15、python 处理XML

#xml样例
<systems shelf="New Arrivals">
<system title="001">
   <service>00</service>
   <service>01</service>
   <service>02</service>
   <service>03</service>
</system>
<system title="002">
   <service>00</service>
   <service>01</service>
   <service>02</service>
   <service>03</service>
</system>
</systems>

from xml.dom.minidom import parse
import xml.dom.minidom import
collecttree = xml.dom.minidom.parse('test.xml')
systems = collecttree.getElementsByTagName('system')
for system in systems:
    if system.hasAttribute('title'):
        title = system.getAttribute('title')  #获取title字段
    services = system.get.ElementsByTagName('service')
    for service in services:
        service_num = service.childNodes[0].data  #获取样例中00、01数据

16、python 匹配中文+数字

import re

re.findall(’[\u4e00-\u9fa5]’, astr)

zhmodel = re.compile(u'[\u4e00-\u9fa5]')  #检查中文  可能需要decode('utf-8')转换
#zhmodel = re.compile(u'[^\u4e00-\u9fa5]')  #检查非中文
contents = u'（2014）深南法民二初字第280号'
match = zhmodel.search(contents)   
if match:
  print(contents)
else:
  print(u'没有包含中文')
pattern = re.compile(r"\d{6}")  #匹配6位数字

17、python 数组比较

print set(a).intersection(set(b)) # 交集
print set(a).union(set(b)) # 并集
print set(a).difference(set(b)) # 差集，在a中但不在b中的元素
print set(b).difference(set(a)) # 差集，在b中但不在a中的元素

18、python random随机数

random.random() #生成一个 0-1 之间的随机浮点数
random.uniform(a,b) #生成[a,b]之间的浮点数
random.randint(a,b) #生成[a,b]之间的整数
random.randrange(a,b,step) #在指定的集合[a,b)中，以 step 为基数随机取一个数
random.choice(sequence) #从特定序列中随机取一个元素，这里的序列可以是字符串，列表，元组等

19、python 字符串模糊匹配

import difflib
  
list1 = ['ape', 'apple', 'peach', 'puppy']
difflib.get_close_matches('appel', list1)

# difflib.get_close_matches(x,words,n,cutoff)
# x：被匹配的字符串。
# words：去匹配的字符串列表。
# n，前topn个最佳匹配返回，默认为3。
# cutoff：匹配度大小，为[0, 1]浮点数，默认数值0.6。

20、python 列表组成字典

>>> a
[1, 2, 3, 4, 5]
>>> a.sort(reverse=True)
>>> a
[5, 4, 3, 2, 1]
>>> a
[5, 4, 3, 2, 1]
>>> b=sorted(a)
>>> b
[1, 2, 3, 4, 5]
>>> a
[5, 4, 3, 2, 1]
>>> c=dict(zip(a,b))
>>> c
{1: 5, 2: 4, 3: 3, 4: 2, 5: 1}

21、python 随机列表

#方法一，使用random库的randint函数生成随机数，然后使用列表推导式将这些随机数生成一个列表
c = [random.randint(1, 10) for _ in range(10)]

#方法二，使用random库中的sample函数从指定的范围中随机选取指定数量的不重复元素，然后转换为列表返回
c = random.sample(range(1, 10+1), 10)

22、python 倒序回文

a = [1,2,3,4,5,6]
b = 'abcdef'

a[::-1]
[6,5,4,3,2,1]

b[::-1]
'fedcba'

23、python 数组删除元素

1、remove()方法：可以通过指定要删除的元素的值来删除元素，删除第一个匹配元素
  my_list = [1, 2, 3, 4, 3]
  my_list.remove(3)
  print(my_list)  # 输出 [1, 2, 4, 3]

2、pop()方法：可以通过指定要删除的元素的索引来删除元素
  my_list = [1, 2, 3, 4]
  my_list.pop(2)
  print(my_list)  # 输出 [1, 2, 4]

3、del语句：可以通过指定要删除的元素的索引或者切片来删除元素
  my_list = [1, 2, 3, 4]
  del my_list[2]
  print(my_list)  # 输出 [1, 2, 4]

4、列表解析（list comprehension）：可以通过条件判断筛选出要保留的元素，进而生成一个新的列表
  my_list = [1, 2, 3, 4]
  my_list = [x for x in my_list if x != 3]
  print(my_list)  # 输出 [1, 2, 4]

24、python 求最大公约数

def f(a, b):
    if b == 0:
        return a
    else:
        return f(b, a%b)
a, b = input(“Enter two natural numbers: ”)
print f(a, b)