python基础代码

 from heapq import *;
 from collections import *;
 import random as rd;
 import operator as op;
 import re;

 data = [2,2,6,7,9,12,34,0,76,-12,45,79,102];
 s = set();

 for num in data:
     s.add(data.pop(0));
     if s.__len__() == 4:
         break;

 heap = [];
 for n in s:
     heappush(heap,n);

 print(heap);

 for num in data:
     if num > heap[0]:
         heapreplace(heap,num);

 print(nlargest(4,heap))

 def file2matrix(path,dimension):
     with open(path,'r+') as fr:
         lines = fr.readlines();
         num_lines = len(lines);
         return_mat = np.zeros((num_lines,dimension));
         classLabel = [];

     index = 0;
     for line in lines:
         contents = line.strip().split(' ');
         li = contents[:dimension];
         li = list(map(float,li));
         return_mat[index,:] = li;

         if(contents[-1] == 'small'):
             classLabel.append(0);
         elif(contents[-1] == 'middle'):
             classLabel.append(1)
         elif (contents[-1] == 'large'):
             classLabel.append(2)
         index += 1;

     return return_mat, classLabel;

 #mat,label = file2matrix('G:\\test.txt',3);

 import collections;
 print(dir(collections))

 class MyObject:
     def __init__(self,score):
         self.score = score;

     def __repr__(self):
         return "MyObject(%s)" % self.score;

 objs = [MyObject(i) for i in range(5)];
 rd.shuffle(objs);
 print(objs);

 g = op.attrgetter("score");
 scores = [g(i) for i in objs];
 print("scores: ",scores);
 print(sorted(objs,key = g));

 l = [(i,i*-2) for i in range(4)]
 print ("tuples: ", l)
 g = op.itemgetter(1)
 vals = [g(i) for i in l]
 print ("values:", vals)
 print ("sorted:", sorted(l, key=g))

 class MyObj(object):
     def __init__(self, val):
         super(MyObj, self).__init__()
         self.val = val
         return

     def __str__(self):
         return "MyObj(%s)" % self.val

     def __lt__(self, other):
         return self.val < other.val

     def __add__(self, other):
         return MyObj(self.val + other.val)

 a = MyObj(1)
 b = MyObj(2)

 print(op.lt(a, b))

 print(op.add(a, b))

 items = [('A', 1),('B', 2),('C', 3)]
 regular_dict = dict(items);
 order_dict = OrderedDict(items);
 print(regular_dict);
 print(order_dict);

 # -*- coding: utf-8 -*-
 import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib.lines import Line2D

 x = np.linspace(0, 10, 1000)
 y = np.sin(x)
 z = np.cos(x**2)

 fig = plt.figure(figsize=(8,4),dpi=120)
 plt.plot(x,y,label="$sin(x)$",color="red",linewidth=2)
 plt.plot(x,z,"b--",label="$cos(x^2)$")
 plt.xlabel("Time(s)")
 plt.ylabel("Volt")
 plt.title("PyPlot First Example")
 plt.ylim(-1.2,1.2)
 plt.legend()
 #plt.show()

 f = plt.gcf();
 all_lines = plt.getp(f.axes[0],'lines');
 print(all_lines[0])

 fig = plt.figure()
 line1 = Line2D([0,1],[0,1], transform=fig.transFigure, figure=fig, color="r")
 line2 = Line2D([0,1],[1,0], transform=fig.transFigure, figure=fig, color="g")
 fig.lines.extend([line1, line2])
 fig.show()

 def autonorm(dataSet):
     minVals = dataSet.min(0);
     maxVals = dataSet.max(0);
     ranges = maxVals - minVals;
     rows = dataSet.shape[0];
     ranges = np.tile(ranges,(rows,1));
     dataSet = dataSet - np.tile(minVals,(rows,1));
     normData = dataSet / ranges;
     return normData;

 def classify(inX,path,k):
     #1.文件到矩阵的映射
     labels,dataSet = file2matrix(path);
     #2.矩阵归一化处理
     dataSet = autonorm(dataSet);
     #3.计算欧式距离
     distance = dataSet - inX;
     distance = np.square(distance);
     distance = distance.sum(axis=1);
     distance = np.sqrt(distance);
     print(distance);
     #4.对距离排序
     sortdisIndices = distance.argsort();
     #5.取前k个，加载到dict中，然后对dict排序，取首个值
     classCount = {};
     for index in range(k):
         label = labels[sortdisIndices[index]];
         print(label)
         classCount[label] = classCount.get(label,0) + 1;

     sortedDict = sorted(classCount.items(),key=op.itemgetter(1),reverse=True);
     return sortedDict[0][0];

 def file2matrix(filepath):
     with open(filepath,'r+') as fr:
         lines = fr.readlines();
         num_lines = len(lines);
         classLabelVector = [];
         dimension = len(lines[0].strip().split(" "))-1;
         dataSet = np.zeros((num_lines,dimension));

     index = 0;
     for line in lines:
         contents = line.strip().split(" ");
         li = contents[:dimension];
         li = list(map(float,li));
         dataSet[index,:] = li;

         if contents[-1] == 'largeDoses':
             classLabelVector.append(3);
         elif contents[-1] == 'smallDoses':
             classLabelVector.append(2);
         elif contents[-1] == 'didntLike':
             classLabelVector.append(1);
         index += 1;

     return classLabelVector,dataSet;

 def main():

     inX = np.array([1.2,1.0,0.8]);
     label = classify(inX,"E:\\Python\\datingTestSet.txt",3);
     print("class:",label);

 if __name__ == '__main__':
     main();