1.推荐：常见算法的python实现（github上25000多star）

github上发现一个25000多star的仓库，把各种常见算法用python实现了，而且还有动图演示，非常值得推荐。

仓库地址：https://github.com/TheAlgorithms/Python

仓库说明

这个仓库用python语言实现了绝大部分算法，主要是用于教学目的，因此效率稍微低于工业界。

内容说明

包含了常见的算法的python实现，如二叉树、排序、查找等等。这些是算法工程师必须掌握的技能。

文件目录

自己手写的DNN神经网络——手写数字识别：

 % DNN手写数字

 

%数据准备

clc

clear all

data=[];    %大小为 794*1000,共1000个样本，每个样本为一个784的列向量 ;

                 % [1:784,1000]为图片,[785:794,1000]为标签(one hot)

col=0;

f1=fullfile('E:\教学工作\在线课程建设\《通信网软件仿真》在线课程\data\' )

for n_x=0:9

      for n_y=1:100

             col=col+1;

             j_x=num2str(n_x);

             j_y=num2str(n_y);

             p=strcat( f1, j_x,'\' , j_x , '_', j_y , '.bmp' );

             pic=imread(p);

             pic=double(pic)/255;

             

             data(1:784,col)=reshape(pic,784,1);

             switch(n_x)     

                    case 0

                            data(785:794,col) = [0,0,0,0,0,0,0,0,0,1]';     

                    case 1

                            data(785:794,col) = [1,0,0,0,0,0,0,0,0,0]'; 

                    case 2

                            data(785:794,col) = [0,1,0,0,0,0,0,0,0,0]';     

                    case 3

                            data(785:794,col) = [0,0,1,0,0,0,0,0,0,0]';     

                    case 4

                            data(785:794,col) = [0,0,0,1,0,0,0,0,0,0]'; 

                    case 5

                            data(785:794,col) = [0,0,0,0,1,0,0,0,0,0]';   

                    case 6

                            data(785:794,col) = [0,0,0,0,0,1,0,0,0,0]';     

                    case 7

                            data(785:794,col) = [0,0,0,0,0,0,1,0,0,0]'; 

                    case 8

                            data(785:794,col) = [0,0,0,0,0,0,0,1,0,0]';     

                    case 9

                            data(785:794,col) = [0,0,0,0,0,0,0,0,1,0]';                                  

             end

             

      end

end

%% 

%参数初始化

%对数据进行洗牌，即打乱数据顺序，增加数据的随机性。

rowrank = randperm(size(data, 2)) ;   % 把数据的列号进行洗牌处理。

data_shuffle= data(:, rowrank);        %按照打乱的列号，重新封装数据

X_train=data(1:784,:)';

y_train=data(785:794,:);

% 激活函数 及其导函数

sigmoid = @(x) 1./(1 + exp(-x));

diff_sigmoid=@(x) x .* (1 - x);

% initializing the variables

epoch=2000 ;           % number of training iterations

lr=0.001;                   % learning rate

X_size=size(X_train);

L1_neuro=100;

L2_neuro=120;

L3_neuro=10;

%  initializing weight and bias

w_L1=randn(X_size(2),L1_neuro)/10;

b_L1=randn(1,L1_neuro)/10;

w_L2=randn(L1_neuro,L2_neuro)/10;

b_L2=randn(1,L2_neuro)/10;

w_L3=randn(L2_neuro,L3_neuro)/10;

b_L3=randn(1,L3_neuro)/10;

 

%  training the model

for i=1:epoch

     if rem(i,100)==0

         i

     end

    % Forward Propogation

    z_L1=X_train*w_L1+b_L1;

    a_L1=sigmoid(z_L1);

    z_L2=a_L1*w_L2+b_L2;

    a_L2=sigmoid(z_L2);

    z_L3=a_L2*w_L3+b_L3;

    a_L3=z_L3';

    out=softmax(a_L3);  

    

    %准确率(Precision)

     %此时out与y_train都是10行1000列，即1000个样本，每个样本为一个10*1的列向量

     if rem(i,50)==0 

         [out_v,out_loc]=max(out); %获得每个样本（列方向）最大值位置索引，得到1个1*1000行向量

         [y_v,y_loc]=max(y_train);   %获得每个标签（列方向）最大值位置索引，得到1个1*1000行向量

         %利用==运算得到0-1分布的逻辑矩阵（1*1000），并统计这个矩阵中和，即1的个数，也就是正确预测的数量

         Precision=sum(out_loc==y_loc);  

         Precision=vpa(Precision/length(out));  %预测对的数量除以总样本数，得到准确率

         loss= sum(sum((out-y_train).^2))/1000 %为了简单采用MSE loss，实际程序采用的是交叉熵

           fprintf('epoch=%d  ，Accuracy Rate=%f  ,  loss=%f  \n ',i,Precision,loss)

         %pause()                %手动详细查看各个阶段的准确率和损失函数值

     end

    % 计算梯度的反向传播

    deta_a_L3 = (out-y_train);

    deta_z_L3=deta_a_L3';     %   deta_z_L3=deta_a_L3.*diff_sigmoid(a_L3);

    deta_w_L3=(a_L2')*deta_z_L3;

    deta_b_L3=sum(deta_z_L3,1);

  

    deta_z_L2=deta_z_L3*w_L3'.*diff_sigmoid(a_L2);

    deta_w_L2=a_L1'*deta_z_L2;

    deta_b_L2=sum(deta_z_L2,1);

    

    deta_z_L1=deta_z_L2*w_L2'.*diff_sigmoid(a_L1);

    deta_w_L1= X_train'*deta_z_L1;

    deta_b_L1=sum(deta_z_L1,1);

    %通过梯度更新各层的参数w,b

    w_L3=w_L3-deta_w_L3*lr;

    b_L3=b_L3-deta_b_L3*lr;

    w_L2=w_L2-deta_w_L2*lr;

    b_L2=b_L2-deta_b_L2*lr;

    w_L1=w_L1-deta_w_L1*lr;

    b_L1=b_L1-deta_b_L1*lr;

end

%% 

% test 测试数据集中第k个样本

k=610;

X_test=data(1:784,k)';

Y_test=data(785:794,k)';

% 样本数据前向传播 

z_L1=X_test*w_L1+b_L1;

a_L1=sigmoid(z_L1);

z_L2=a_L1*w_L2+b_L2;

a_L2=sigmoid(z_L2);

z_L3=a_L2*w_L3+b_L3;

a_L3=z_L3';

out=softmax(a_L3);  

out'

Y_test

pic2=reshape(X_test,28,28);

imshow(pic2)

冒泡排序的代码

from __future__ import print_function

def bubble_sort(collection):
    """Pure implementation of bubble sort algorithm in Python
    :param collection: some mutable ordered collection with heterogeneous
    comparable items inside
    :return: the same collection ordered by ascending
    Examples:
    >>> bubble_sort([0, 5, 3, 2, 2])
    [0, 2, 2, 3, 5]
    >>> bubble_sort([])
    []
    >>> bubble_sort([-2, -5, -45])
    [-45, -5, -2]

    >>> bubble_sort([-23,0,6,-4,34])
    [-23,-4,0,6,34]
"""
    length = len(collection)
    for i in range(length-1):
        swapped = False
        for j in range(length-1-i):
            if collection[j] > collection[j+1]:
                swapped = True
                collection[j], collection[j+1] = collection[j+1], collection[j]
            if not swapped: break # Stop iteration if the collection is sorted.
        return collection

if __name__ == '__main__':
    try:
        raw_input # Python 2
    except NameError:
        raw_input = input # Python 3
    user_input = raw_input('Enter numbers separated by a comma:').strip()
    unsorted = [int(item) for item in user_input.split(',')]
    print(*bubble_sort(unsorted), sep=',')