学习笔记-10.13

Python学习

---

初识Python

Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言(大佬果然任性)。

• 主要优点：简便，通俗易懂（看了一些代码感觉就像Chinglish），跨平台，有丰富的库
• 主要缺点：运行速度较慢（但多数情况无影响）

Python语法

基本数据类型

整数，浮点数，字符串，和布尔值与以前接触过的语言没有多少区别。

• 或与非：Python使用“or”、“and”、“not”来表示“||”、“&&”、“！”。
• 空值：空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

容器Containers

• 列表Lists：
  类似于C语言中的数组但比它强大，例如如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

>>> classmates = ['Michael', 'Bob', 'Tracy']>>> classmates['Michael', 'Bob', 'Tracy']>>> classmates[-1]'Tracy'

以此类推，可以获取倒数第2个、倒数第3个：

>>> classmates[-2]'Bob'>>> classmates[-3]'Michael'

而且还有一些函数（append, insert, pop等）来对list进行操作。list里面的元素的数据类型也可以不同并且list元素也可以是另一个list。

• 元组Tuples:
  tuple和list非常类似，但是tuple一旦初始化就不能修改。因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> t = (1, 2)>>> t(1, 2)

如果要定义一个空的tuple，可以写成()：

>>> t = ()>>> t()

Python规定，定义一个只有1个元素的tuple必须加一个逗号,，来消除歧义：

>>> t = (1,)>>> t(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

• 字典Dictionaries：
  字典用来储存（键, 值）对，与Java中的Map差不多。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

• 集合Sets:
  集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。创建集合：大括号或 set() 函数可以用来创建集合。大括号不可以创建元素含有字典与列表的集合。

函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def my_abs(x):    if x >= 0:        return x    else:        return -x

如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。

类

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
在Python中，定义类是通过class关键字：

class Student(object):    pass

class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：

>>> bart = Student()>>> bart<__main__.Student object at 0x10a67a590>>>> Student<class '__main__.Student'>

可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：

>>> bart.name = 'Bart Simpson'>>> bart.name'Bart Simpson'

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的init方法，在创建实例的时候，就把name，score等属性绑上去：

class Student(object):    def __init__(self, name, score):        self.name = name        self.score = score

注意：特殊方法“init”前后有两个下划线！！！
注意到init方法的第一个参数永远是self，表示创建的实例本身，因此，在init方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了init方法，在创建实例的时候，就不能传入空的参数了，必须传入与init方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

>>> bart = Student('Bart Simpson', 59)>>> bart.name'Bart Simpson'>>> bart.score59

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。
数据封装:
面向对象编程的一个重要特点就是数据封装。在上面的Student类中，每个实例就拥有各自的name和score这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：

>>> def print_score(std):...     print('%s: %s' % (std.name, std.score))...>>> print_score(bart)Bart Simpson: 59

但是，既然Student实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

class Student(object):    def __init__(self, name, score):        self.name = name        self.score = score    def print_score(self):        print('%s: %s' % (self.name, self.score))

要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入：

>>> bart.print_score()Bart Simpson: 59

这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score，而如何打印，都是在Student类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。
封装的另一个好处是可以给Student类增加新的方法，比如get_grade：

class Student(object):    ...    def get_grade(self):        if self.score >= 90:            return 'A'        elif self.score >= 60:            return 'B'        else:            return 'C

同样的，get_grade方法可以直接在实例变量上调用，不需要知道内部实现细节：

>>> bart.get_grade()'C'

KNN算法实现(Python)

#-*- coding: utf-8 -*-from numpy import *import operatordef classify(inputPoint,dataSet,labels,k):    dataSetSize = dataSet.shape[0]     #已知分类的数据集（训练集）的行数    #先tile函数将输入点拓展成与训练集相同维数的矩阵，再计算欧氏距离    diffMat = tile(inputPoint,(dataSetSize,1))-dataSet  #样本与训练集的差值矩阵    sqDiffMat = diffMat ** 2                    #差值矩阵平方    sqDistances = sqDiffMat.sum(axis=1)         #计算每一行上元素的和    distances = sqDistances ** 0.5              #开方得到欧拉距离矩阵    sortedDistIndicies = distances.argsort()    #按distances中元素进行升序排序后得到的对应下标的列表    #选择距离最小的k个点    classCount = {}    for i in range(k):        voteIlabel = labels[ sortedDistIndicies[i] ]        classCount[voteIlabel] = classCount.get(voteIlabel,0)+1    #按classCount字典的第2个元素（即类别出现的次数）从大到小排序    sortedClassCount = sorted(classCount.items(), key = operator.itemgetter(1), reverse = True)    return sortedClassCount[0][0]if __name__ == "__main__" :    dataset = array([[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [3, 3, 3, 3, 3], [-3, -3, -3, -3, -3], [1, 2, 3, 4, 4], [4, 4, 3, 2, 1], [3, 3, 3, 2, 4], [0, 0, 1, 1, -2]])    labels = ['A', 'B', 'C', 'D', 'A', 'B', 'C', 'D']     X = array([1, 2, 3, 2, 4])      Y = array([8, 7, 2, 3, 5])    Z = array([-4, -4, -4, -4, -4])    k = 3    labelX =  classify(X,dataset,labels,k)    labelY =  classify(Y,dataset,labels,k)    labelZ =  classify(Z,dataset,labels,k)    print ("Your input is:", X, "and classified to class: ", labelX)    print ("Your input is:", Y, "and classified to class: ", labelY)    print ("Your input is:", Z, "and classified to class: ", labelZ)

运行结果：