Python
Jan 3
安装 && 介绍:http://blog.puppeter.com/read.php?7
github: https://github.com/puppeter/clip/tree/master/clip.0.02

新增功能:

clip ssh && clip scp && clip lt 支持ssh打通关系信任执行系统命令与同步文件;
clip ssh && clip scp && clip lt 支持多线程并发执行系统命令与同步文件;
clip ssh && clip scan 支持json格式返回执行命令结果;
clip scp && clip lt 支持rsync同步文件;
clip scp && clip lt 支持反向下载服务器文件;
修复程序bug && 优化功能;
clip version 增加版本功能。


Clip SDK使用
Clip SDK 功能用于获取Server上的IP关系,并在Client上重新组织编排IP关系。(注:目前clip也支持将IP存放到本地文件中管理)。目前Clip 提供8个子命令,以下Clip子命令的参数解释与演示(更多案例参考:Clip SDK 案例):
clip scan (用于对String对应的IP进行端口存活状态扫描)

--query_string(-q)# 根据String扫描IP的端口
--ip (-i) # 扫描指定IP的端口
--query_string (-q) *-test-*-*,*-docker-*-* # 多String扫描用逗号分隔
--append (-a) # 在原有String基础上,追加IP,追加多个(192.168.0.1,192.168.0.2)IP用逗号分隔
--remove_ip (-r) # 删除String原有IP列表的IP
--limit(-l)# 扫描String中指定范围的IP范围
--port (-P) # 指定自定义扫描端口(注:默认为80端口)
--log_disable(-o)# 默认日志会上报服务器,并通过history命令查看历史,通过此命令可以关闭日志上报,建议频繁使用clip关闭clip
--json (-j) # 一次性输出json格式({ip:status} 其中0位成功,1为失败)

clip scan 使用演示:
扫描*-puppet-*-* 对应开放的端口
点击在新窗口中浏览此图片

clip cstring(正解与反解String对应IP关系)

--query_string(-q)# 解析String对应的IP列表
--ip (-i) # 解析IP对应的String
--query_string (-q) *-test-*-*,*-docker-*-* # 解析多个String对应IP列表,多String用逗号分隔
--limit(-l)# 解析String中指定范围的IP范围
--append (-a) #在原有String基础上,追加IP,追加多个(192.168.0.1,192.168.0.2)IP用逗号分隔
--remove_ip (-r) # 删除String原有IP列表的IP
--join (-j) # 指定输出的格式,支持(“|” “,” “\n”,space) 4种格式输出
--log_disable(-o)# 默认日志会上报服务器,并通过history命令查看历史,通过此命令可以关闭日志上报,建议频繁使用clip关闭clip
--count (-c) # 统计输出IP个数
--dryrun (-d) # 输出调用接口用例

clip cstring演示:
解析*-qq-*-* 对应的IP关系。
点击在新窗口中浏览此图片
解析192.168.0.7 对应的String。
点击在新窗口中浏览此图片

clip ssh (远程命令执行工具)

--password (-p) # 密码 (如果打通了机器信任关系,密码字段请使用null)
--append (-a) # 在原有String基础上,追加IP,追加多个(192.168.0.1,192.168.0.2)IP用逗号分隔
--remove_ip (-r) # 删除String原有IP列表的IP
--limit(-l)# 解析String中指定范围的IP范围
--port (-P) #指定自定义端口(注:默认为22端口)
--dryrun (-d) # 输出调用接口用例
--log_disable(-o)# 默认日志会上报服务器,并通过history命令查看历史,通过此命令可以关闭日志上报,建议频繁使用clip关闭clip
--worker (-w) 以worker形式并发启动(限200并发)
--json (-j) 一次性输出json格式

clip ssh演示:
查看string(sh-docker-base_v1-*) 对应机器上负载.
点击在新窗口中浏览此图片
查看string(sh-docker-base_v1-*)的第一台服务器对应负载
点击在新窗口中浏览此图片

clip scp (远程命令执行工具)

--password (-p) # 密码(如果打通了机器信任关系,密码字段请使用null)
--append (-a) #  在原有String基础上,追加IP,追加多个(192.168.0.1,192.168.0.2)IP用逗号分隔
--remove_ip (-r) # 删除cstring原有IP列表的IP
--limit(-l)# 解析String中指定范围的IP范围
--port (-P) # 指定自定义端口(注:默认为22端口)
--dryrun (-d) # 输出调用接口用例
--log_disable(-o)# 默认日志会上报服务器,并通过history命令查看历史,通过此命令可以关闭日志上报,建议频繁使用clip关闭clip
--worker  以worker形式并发启动(限200并发)
--json (-j) 一次性输出json格式
--rsync (-R) 通过rsync方式做增量文件传输
--download (-D) 反向从远程服务器下载文件



clip scp演示:
将ip文件推送到string(sh-docker-base_v1-*)对应机器的/tmp目录上。
点击在新窗口中浏览此图片

tree(String关系遍历工具)

--query_string(-p) # 密码
--json (-j) # 指定输出的格式
--dryrun (-d) # 输出调用接口用例
--log_disable(-o)# 默认日志会上报服务器,并通过history命令查看历史,通过此命令可以关闭日志上报,建议频繁使用clip关闭clip

clip tree 演示:
遍历*-*-*-* 下的节点
点击在新窗口中浏览此图片

import(IP关系导入工具)

--insert (-i) # 将文件内的clip对应关系导入数据库
--bulid (-b) # 创建clip导入数据库,关系模板文件
--list_struct (-l) # 显示clip数据库结构

clip import 演示:
clip import -b 创建导入string与关系模板
点击在新窗口中浏览此图片

lt(Local tools 本地获取IP关系管理工具)

--password (-p) # 密码
--append (-a) # 追加IP,多个IP用逗号分隔
--remove (-r) # # 删除原有IP列表的IP
--port (-P) # 指定自定义端口(注:默认为22端口)
--worker (-w)  #以worker形式并发启动(限200并发)
--json (-j)  #一次性输出json格式


clip import 演示:
clip lt 根据本地文件IP文件,进行远程ssh command,其中root@“本地IP关系文件名”
点击在新窗口中浏览此图片


Clip 使用案例
最近有同学发现在使用clip过程中不能远程执行awk命令。说一下这里的原因,因为clip最终是将命令通过ssh方式进行远程调用,这里涉及到特殊字符的转义。在使用clip ssh 时 命令部分建议用单引号('')引起,awk 命令通过双引号,另外注意awk中的($)符号是特殊字符需要转义,最终使用方式(clip ssh -p null root@*-qq-*-*  'ps -ef|grep ssh | awk "{print \$2}" ' )这样就可以方便的使用ssh执行远程awk命令了见截图。

未转义前
点击在新窗口中浏览此图片
转义后
点击在新窗口中浏览此图片

Oct 15
1、插入排序

描述

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序,时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分:第一部分包含了这个数组的所有元素,但将最后一个元素除外(让数组多一个空间才有插入的位置),而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后,再将这个最后元素插入到已排好序的第一部分中。

代码实现

Python

def insert_sort(lists):

    # 插入排序

    count = len(lists)

    for i in range(1, count):

        key = lists[i]

        j = i - 1

        while j >= 0:

            if lists[j] > key:

                lists[j + 1] = lists[j]

                lists[j] = key

            j -= 1

    return lists


2、希尔排序

描述

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

代码实现

Python

def shell_sort(lists):

    # 希尔排序

    count = len(lists)

    step = 2

    group = count / step

    while group > 0:

        for i in range(0, group):

            j = i + group

            while j < count:

                k = j - group

                key = lists[j]

                while k >= 0:

                    if lists[k] > key:

                        lists[k + group] = lists[k]

                        lists[k] = key

                    k -= group

                j += group

        group /= step

    return lists


3、冒泡排序

描述

它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

代码实现

Python

def bubble_sort(lists):

    # 冒泡排序

    count = len(lists)

    for i in range(0, count):

        for j in range(i + 1, count):

            if lists[i] > lists[j]:

                lists[i], lists[j] = lists[j], lists[i]

    return lists

4、快速排序

描述

通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

代码实现

Python

def quick_sort(lists, left, right):

    # 快速排序

    if left >= right:

        return lists

    key = lists[left]

    low = left

    high = right

    while left < right:

        while left < right and lists[right] >= key:

            right -= 1

        lists[left] = lists[right]

        while left < right and lists[left] <= key:

            left += 1

        lists[right] = lists[left]

    lists[right] = key

    quick_sort(lists, low, left - 1)

    quick_sort(lists, left + 1, high)

    return lists

5、直接选择排序

描述

基本思想:第1趟,在待排序记录r1 ~ r[n]中选出最小的记录,将它与r1交换;第2趟,在待排序记录r2 ~ r[n]中选出最小的记录,将它与r2交换;以此类推,第i趟在待排序记录r[i] ~ r[n]中选出最小的记录,将它与r[i]交换,使有序序列不断增长直到全部排序完毕。

代码实现

Python

def select_sort(lists):

    # 选择排序

    count = len(lists)

    for i in range(0, count):

        min = i

        for j in range(i + 1, count):

            if lists[min] > lists[j]:

                min = j

        lists[min], lists[i] = lists[i], lists[min]

    return lists

6、堆排序

描述

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即A[PARENT[i]] >= A[i]。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。

代码实现

Python

def adjust_heap(lists, i, size):

    lchild = 2 * i + 1

    rchild = 2 * i + 2

    max = i

    if i < size / 2:

        if lchild < size and lists[lchild] > lists[max]:

            max = lchild

        if rchild < size and lists[rchild] > lists[max]:

            max = rchild

        if max != i:

            lists[max], lists[i] = lists[i], lists[max]

            adjust_heap(lists, max, size)



def build_heap(lists, size):

    for i in range(0, (size/2))[::-1]:

        adjust_heap(lists, i, size)



def heap_sort(lists):

    size = len(lists)

    build_heap(lists, size)

    for i in range(0, size)[::-1]:

        lists[0], lists[i] = lists[i], lists[0]

        adjust_heap(lists, 0, i)

7、归并排序

描述

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1;否则将第二个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现,先把待排序区间[s,t]以中点二分,接着把左边子区间排序,再把右边子区间排序,最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

代码实现

Python


def merge(left, right):

    i, j = 0, 0

    result = []

    while i < len(left) and j < len(right):

        if left[i] <= right[j]:

            result.append(left[i])

            i += 1

        else:

            result.append(right[j])

            j += 1

    result += left[i:]

    result += right[j:]

    return result



def merge_sort(lists):

    # 归并排序

    if len(lists) <= 1:

        return lists

    num = len(lists) / 2

    left = merge_sort(lists[:num])

    right = merge_sort(lists[num:])

    return merge(left, right)

8、基数排序

描述

基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序,其时间复杂度为O (nlog(r)m),其中r为所采取的基数,而m为堆数,在某些时候,基数排序法的效率高于其它的稳定性排序法。

代码实现

Python


import math

def radix_sort(lists, radix=10):

    k = int(math.ceil(math.log(max(lists), radix)))

    bucket = [[] for i in range(radix)]

    for i in range(1, k+1):

        for j in lists:

            bucket[j/(radix**(i-1)) % (radix**i)].append(j)

        del lists[:]

        for z in bucket:

            lists += z

            del z[:]

    return lists

分页: 1/1 第一页 1 最后页 [ 显示模式: 摘要 | 列表 ]