Python基本概念及零碎知识点

1.python面向对象

类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的实例：这类
似于你有一个int类型的变量，这存储整数的变量是int类的实例（对象）
把握一点：在python中一切皆对象
Python 不包含像 int 这样的简单类型 —— 只有对象类型。如果 Python 中需要整数值，将整数赋值给相应变量（如 i = 100 ）即可。在后台，Python 将创建一个整数对象，并将对新对象的引用赋值给变量。问题的关键是：Python 是一种动态类型化语言，所以无需声明变量类型。事实上在单个程序中，变量的类型是可以改变（多次）的。
也就是说在python中即使是整数也被看做对象(属于int类)，可以通过help(int)来了解更多关于此类的详情
self：决定了类的方法和普通函数的一个特别的区别--他们必须有一个额外的第一参数名称，即self（default don't change it）
也就是说如果你有一个不需要参数的方法，你依然要给这个方法定义一个self参数
self的原理就是：假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1,arg2)
__init__方法：__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希
望的初始化 。注意，这个名称的开始和结尾都是双下划线。
__init__方法一般不用专门调用，在创建一个类的新的实例时，将参数包括在圆括号内跟在类名后面，从而传递给__init__方法，自动调用。
__init__方法类似于C++、C#和Java中的 constructor
__del__则类似于descontructor

2.python去除表中重复的元素

法1：

>>>l1 = ['b','c','a','b','c','a','a']
>>> l2 = list(set(l1))
>>> print l2

['a', 'c', 'b']       注：set表示Build an unordered collection of unique elements.

法2：

l1 = ['b','c','d','b','c','a','a']
l2 = {}.fromkeys(l1).keys()
print l2

['a', 'c', 'b']

缺点：改变了原有顺序

改进：不改变顺序

用list类的sort方法

l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index)
print l2

也可以这样写

l1 = ['b','c','d','b','c','a','a']
l2 = sorted(set(l1),key=l1.index)
print l2

 

 

也可以用遍历

l1 = ['b','c','d','b','c','a','a']
l2 = []
for i in l1:
    if not i in l2:
        l2.append(i)
print l2

上面的代码也可以这样写

l1 = ['b','c','d','b','c','a','a']
l2 = []
[l2.append(i) for i in l1 if not i in l2]
print l2

3.python有两个内置的函数：locals和globals，他们提供基于dictionary的访问局部和全局变量的方式。

局部名字空间可以通过locals函数来访问，全局(模块级别)名字空间可以通过内置的golobals函数来访问。

def foo(arg):

　　x=1

　　print locals()

>>>foo(7)

{'arg': 7, 'x': 1}

>>>foo('bar')

{'arg': 'bar', 'x': 1}

函数foo()在他的局部名字空间中有两个变量：arg(它的值是被传入函数的)和x(它是在函数里定义的)；locals返回一个名字/值对的dictionary

回想一下 from module import 和 import module 之间的不同。使用 import module，模块自身被导入，但是它保持着自已的名字空间，这就是为什么您需要使用模块名来访问它的函数或属性：module.function 的原因。但是使用 from module import，实际上是从另一个模块中将指定的函数和属性导入到您自己的名字空间，这就是为什么您可以直接访问它们却不需要引用它们所来源的模块。使用 globals 函数，您会真切地看到这一切的发生。

globals：关于items的用法：

items()是directory中的一个method，globals()函数返回一个directory，故可以直接调用items()方法，items()返回的是一个包含键/值对元组的列表

4.所有的python模块都是对象，并且有几个有用的属性，可以使用这些属性方便的测试所编写的模块：如下是一个使用if __name__的技巧：

if __name__ == "__main__":

模块是对象，并且所有的模块都有一个内置属性__name__:一个模块的__name__的值取决于你如何应用模块，如果import 模块，那么 __name__ 的值通常为模块的文件名，不带路径或者文件扩展名。但是您也可以像一个标准的程序一样直接运行模块，在这种情况下 __name__ 的值将是一个特别的缺省值，__main__。

如此，在你设计的模块内部加入这个if语句，当你直接运行模块，__name__的值就是__main__，所以测试套件执行，而当你导入模块，即在其他程序中使用import导入该模块，__name__的值就是其他别的东西了，所以测试套件就会被忽略，不执行。这样就可以使得将新的模块集成到一个大程序之前开发和调试容易很多。

5.[python]三种方法删除列表中重复的元素及效率分析！

方法一： 使用列表对象的sort()方法对列表进行排序，从最后一个元素开始循环迭代列表，判断相邻的两元素是否是否相等!

1 2 3 4 5 6 7 8 9 10

def methodOne(list):     list.sort()       lenList = len(list)       lastItem = list[lenList-1]       for i in range(lenList-2,-1,-1):        　　if list[i] == lastItem:             　　　　list.remove(list[i])         　　else:             　　　　lastItem = list[i]     return list

方法二： 定义一个临时列表,循环迭代出的元素如果不在临时表中，则加入，最后返回临时列表！

1 2 3 4 5 6

def methodTwo(list):     tempList = []       for i in list:       　　  if not i in tempList:               tempList.append(i)       return tempList

方法三：

1 2	lists=[20,12,34,12,24,34,55,27] print list(set(lists))

1、方法一相对方法二来说，有更多的额外操作如：排序、赋值。因为在Python中，变量是不可变的，每迭代出一个元素比较不相等后的操作是都是新建立一个局部变量并赋值而丢弃原变量，这需要消耗更多的内存!同时因为排序操作，破坏了相对位置。 2、方法二建立一个临时列表进行操作，而列表是可变的，每次追加元素都只是在原列表上增加一个索引及值,因而相对方法一来说效率会更高! 3、第三个方法无疑是这三种方法中效率最好的（无论是代码的简洁还是运行效率）：set()是内置的数据类型“集合类型”，它是无序的且值是唯一项的！所以set() 执行的结果就是转为集合且直接去除了重复的元素，再list()则将集合又转回列表类型。 但是，set()是会破坏了排列顺序，如果要保留排序，list(set(lists)) 可改为 sorted(set(lists),key=lists.index)

6.列表，元组，集合，字典

列表(list),可以理解为"打了激素的数组"，跟数组一样可以根据下标(索引)来访问元素，但要比数组更加强大，还有自己特有的功能

元组，就是不可变的列表，一旦创建了元组，其内容就不可以再改变

集合，有自己独特的"气质"：它里面的值唯一且无序，正所谓"孤傲而随性"

字典，由键和值两兄弟组成的无序集合，可谓"无敌二人组"

7.Python - extend v append on a list

In Python, you can extend a list and you can append to it as well. 
What's the difference?   If you append a list to another list, you add the new list as a single extra list to the original, thus makingthe original list just one longer with an item that is itself a list.   But if you extend a list with another list, you add each element of the new list onto the original.   Here's an example to show you what I mean:
>>> first = [10,20,30]

>>> second = [40,50,60]

>>> first.append([70,80,90])

>>> second.extend([100,110,120])

>>> first [10, 20, 30, [70, 80, 90]]

>>> second [40, 50, 60, 100, 110, 120]

>>>