标签 python 下的文章

冒泡排序(Python实现)

冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。

原理

比较相邻的元素,如果第一个比第二个大,就交换。对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

时间复杂度

冒泡算法每次都需要对元素进行比较,是一种稳定的排序算法,时间复杂度为:O(n²)

Python实现

# -*- coding:utf-8 -*-
# 冒泡排序

'''
重点:每一轮比较都把最大的数放到最后,第二层循环的循环次数是递减的,
所以j终止的条件是 j = end - i - 1
'''

# while 写法
def bubble_sort(list):
    # if len(list) < 1:
    #     return list

    i = 0
    end = len(list) - 1
    while i < end:
        j = 0
        while j < end - i:
            if list[j] > list[j + 1]:
                list[j], list[j + 1] = list[j + 1], list[j]
            j = j + 1

        i = i + 1

    return list

# for 写法
def bubble_sort_for(list):
    # if len(list) < 1:
    #     return list

    end = len(list)

    # 外循环次数等于需排序个数减 1,比如3个数字,只需要循环两轮,i初始为0
    for i in range(end - 1):
        for j in range(end - i - 1): # 单趟排序比较的次数要减去已排序好的个数(即 i)
            if list[j] > list[j + 1]:
                list[j], list[j + 1] = list[j + 1], list[j]
    return list

归并排序(Python实现)

原理

归并排序是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)。
这是一种递归算法,每次将一个列表一分为二,如果列表为空或只有一个元素,那么从定义上来说它就是有序的。如果列表不止一个元素,就将列表一分为二,并对两部分都递归调用归并排序。
该算法1945年由约翰·冯·诺伊曼首次提出。

时间复杂度

归并排序是一种稳定的排序算法,时间复杂度为:O(nlogn)

# -*- coding:utf-8 -*-
# 归并排序

def mergeSort(alist):
    if len(alist) > 1:
        mid = len(alist) // 2 # 向下取整
        lefthalf = alist[:mid]
        righthalf = alist[mid:]

        lefthalf = mergeSort(lefthalf)
        righthalf = mergeSort(righthalf)

        i = 0
        j = 0
        k = 0
        while i < len(lefthalf) and j < len(righthalf):
            if lefthalf[i] < righthalf[j]:
                alist[k] = lefthalf[i]
                i = i + 1
            else:
                alist[k] = righthalf[j]
                j = j + 1
            k = k + 1

        while i < len(lefthalf):
            alist[k] = lefthalf[i]
            i = i + 1
            k = k + 1

        while j < len(righthalf):
            alist[k] = righthalf[j]
            j = j + 1
            k = k + 1
    return alist

b = [54, 26, 93, 17, 77, 31, 44, 55, 20]
mergeSort(b)

插入排序(Python实现)

原理

在列表较低的一端维护一个有序的子列表,并逐个将后面每个新元素“插入”这个子列表。

  1. 将待排序列表的第一个元素当做已排序序列,第二个元素到最后一个元素当成未排序序列。
  2. 取未排序序列中的第一个数据,插入到已排序序列中顺序正确的位置。将未排序的第一个数据与相邻的前一个数据(已排序序列的最后一个数)据进行比较,如果顺序错误则交换位置,交换位置后继续与相邻的前一个数据进行比较,直到不需要交换则插入完成。每次插入数据后,已排序序列都是排好序的。
  3. 重复上一步,继续插入下一个数据。每进行一次插入,已排序序列的长度加1,未排序序列的长度减1,直到列表中的所有数据都插入到已排序序列了,则列表排序完成。

时间复杂度

插入排序的时间复杂度也是O(n²)。

Python 实现

# -*- coding: UTF-8 -*-
# 插入排序

def insertionSort(alist):
    for index in range(1, len(alist)):
        currentvalue = alist[index]
        position = index

        while position > 0 and alist[position-1] > currentvalue:
            alist[position] = alist[position-1]
            position = position-1

        alist[position] = currentvalue
    return alist

使用Python库Pillow等比例修改图片尺寸并压缩

PIL:Python Imaging Library,是一个非常强大的图像处理标准库,但只支持到Python2.7。于是Pillow诞生了,它Fork至PIL,可兼容至最新的Python3.X,还加入了不少新特性。使用pip install Pillow即可安装。

本文使用的基础环境:Python 2.7.18
pip自动安装的是Pillow 6.2.2

现在有一堆尺寸较大的图片,从5千多px到2千多px不等,体积也是,小到3M,大到12M,而且还分布在不同的文件夹里。用ps处理比较慢,要一个一个打开,然后等比例调整尺寸,费时费力。决定用Python来处理,找到了Pillow这个优秀的图像处理库,很快就找到了解决方案。

先看代码:

# -*- coding:utf-8 -*-
from PIL import Image
import os

linesep = os.linesep
sep = os.sep
rootpath = "D:\\image"
maxsize = (1024, 1024)

def resizeImage(start_dir):
    start_dir = start_dir.strip()
    extend_name = ['.jpg','.png','.gif','.PNG','.jpeg','.JPG','.JPEG'] # 查找的文件类型
    os.chdir(start_dir)
 
    for each_file in os.listdir(os.curdir):
        curfile = os.getcwd() + sep + each_file
        img_prop = os.path.splitext(each_file)
        if img_prop[1] in extend_name:
            try:
                im = Image.open(curfile)
            except:
                im.close()
                with open(rootpath + "/process.err.log", "a") as f:
                    f.write(curfile + " open error" + linesep)
            else:
                try:
                    im.thumbnail(maxsize, Image.ANTIALIAS)
                    im.save(img_prop[0] + "_new" + img_prop[1], quality=95, optimize=True)
                except:
                    im.close()
                    with open(rootpath + "/process.err.log", "a") as f:
                        f.write(curfile + " save error" + linesep)
 
        if os.path.isdir(curfile):
            resizeImage(curfile)
            os.chdir(os.pardir)

    print("processing " + start_dir)

if __name__ == '__main__':
    sdir = rootpath
    resizeImage(sdir)

resizeImage函数从指定的文件夹开始,迭代查找指定类型的图片,对其进行Image.thumbnail处理,然后通过Image.save进行压缩保存。中间用到了try..except,是因为有些图片格式可能有问题,导致打开或者保存出错,为避免丢失原图片而做的处理。
可以看到,逻辑其实很简单,但对于有大量图片需要进行处理的情况,这样的小脚本确实能帮上不少忙。

PS:2020年最后一天,挥别过去,迎接全新的一年,全新的自己。

CentOS7.5 安装supervisor 4.2.1

环境:CentOS 7.5,Python2.7.16
建议使用pip安装

安装

pip install supervisor

安装之后,执行echo_supervisord_conf,如果能看到配置文件内容,说明安装成功。

生成配置文件

新建/etc/supervisor目录,然后执行命令:

echo_supervisord_conf > /etc/supervisor/supervisord.conf

配置文件名称建议使用supervisord.conf,如果你取了别的名称,后面执行supervisorctl命令时,就需要指定配置文件,否则会报错。

- 阅读剩余部分 -