Python基础知识
《A Byte of Python》中文版《 简明 python 教程》，非常简洁，有助于具有一定编程基础的人，快速了解和掌握python。
对于很多编程语言来说，程序都必须要有一个入口，比如 C，C++，以及完全面向对象的编程语言 Java，C# 等。如果你接触过这些语言，对于程序入口这个概念应该很好理解，
C 和 C++ 都需要有一个 main 函数来作为程序的入口，也就是程序的运行会从 main 函数开始。同样，Java 和 C# 必须要有一个包含 Main 方法的主类来作为程序入口。
而 Python 则有不同，它属于脚本语言，不像编译型语言那样先将程序编译成二进制再运行，而是动态的逐行解释运行。也就是从脚本第一行开始运行，没有统一的入口。
if __name__ == '__main__' 就相当于是 Python 模拟的程序入口。Python 本身并没有规定这么写，这只是一种编码习惯。
由于模块之间相互引用，不同模块可能都有这样的定义，而入口程序只能有一个。到底哪个入口程序被选中，这取决于 __name__ 的值。
__name__ 是内置变量，用于表示当前模块的名字，同时还能反映一个包的结构。如果一个模块被直接运行，则其没有包结构，其 __name__ 值为 __main__。
所以，if __name__ == '__main__' 我们简单的理解就是： 如果模块是被直接运行的，则代码块被运行，如果模块是被导入的，则代码块不被运行。
1.Python是一种解释型语言.Python解释器是通过“一次执行一条语句”的方式运行程序的。Python科学计算程序员则更趋向于使用IPython（一种加强的交互式Python解释器）。
通过使用命令%run，IPython会在同一个进程中执行指定文件中的代码。（.py文件和IPython解释器在同一目录下，或者运行时加上文件路径）
|
1
2
|
%run hello_world.py #out: Hello world %run E:/hello_world.py #out: Hello world |
2.元组是一种一维的，定长的，不可变的Python对象序列。最简单的创建方式是一组以逗号隔开的值。通过调用tuple，任何序列或迭代器都可以被转换成元组。
|
1
2
3
4
|
tup = 4,5,6 print tup #(4,5,6) print tuple([4,0,2]) #(4,0,2) print tuple('string') #('s','t','r','i','n','g') |
3.元组拆包可以非常轻松的交换变量名。拆包功能还可以用于元组或列表组成的序列进行迭代。元组中比较有用的方法是count（对列表也是如此），它用于用于计算指定指定值的出现次数。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
a = 5 b = 2 b,a = a,b print a,b # 2 5 seq = [(1,2,3),(4,5,6)] for a,b,c in seq: print a,b,c # 1 2 3 # 4 5 6 a = (1,2,2,2,3,4,3,2) print a.count(2) #4 |
4.跟元组相比，列表（list）是变长的，而且其内容也是可以修改的。它通过方括号（[ ]）或list函数进行定义。通过append方法，可以将元素添加到列表的末尾。
|
1
2
3
4
5
6
7
8
|
a_list = [2,3,4,None] print a_list #[2, 3, 4, None] tup = ('foo','bar','baz') b_list = list(tup) print b_list #['foo', 'bar', 'baz'] b_list.append('dwarf') print b_list #['foo', 'bar', 'baz', 'dwarf'] |
5.合并列表，和元组一样，用加号（+）将两个列表加起来即可实现合并。对于一个已定义的列表，可以用extend方法一次性添加多个元素。
|
1
2
3
4
|
print [4,None,'foo'] + [7,8,(2,3)] #[4, None, 'foo', 7, 8, (2, 3)] x = [4,None,'foo'] x.extend([7,8,(2,3)]) print x #[4, None, 'foo', 7, 8, (2, 3)] |
注意：列表的合并是一种相当费资源的操作，因为必须创建一个新列表并将所有对象复制过去。而用extend将元素附加到现有列表（尤其是在构建一个大列表时）就会好很多。
#extend() 方法 合并速度快的多
|
1
2
3
4
5
6
|
everything = [] for chunk in list_of_lists: #合并速度快的多 everything.extend(chunk) for chunk in list_of_lists: everything = everything + chunk |
6.对于一个序列进行迭代时，常常需要跟踪当前项的索引，Python内置了一个enumerate函数，它可以返回序列的值和索引。
|
1
2
3
4
5
6
7
8
9
10
11
|
i = 0 for value in ['aa','bb','cc']: i += 1 print str(i) + ":" + value for i,value in enumerate(['aa','bb','cc']): # 0:aa print str(i) + ":" + value # 1:bb # 2:cc some_list = ['foo','bar','baz'] mapping = dict((v,i) for i,v in enumerate(some_list)) print mapping #{'baz': 2, 'foo': 0, 'bar': 1} |
7.zip用于将多个序列（列表，元组）中的元素“配对”，从而产生一个新的元组列表。zip最常见的用法是同时迭代多个序列，还可以结合enumerate一起使用。
|
1
2
3
4
5
6
7
|
seq1 = ['foo','bar','baz'] seq2 = ['one','two','three'] print zip(seq1,seq2) #[('foo', 'one'), ('bar', 'two'), ('baz', 'three')] for i,(a,b) in enumerate(zip(seq1,seq2)): #0:foo,one print('%d:%s,%s'%(i,a,b)) #1:bar,two #2:baz,three |
8.调用列表的sort方法可以实现就地的排序。sorted函数可以将任何序列返回为一个新的有序列表。reversed用于按逆序迭代序列中的元素。
|
1
2
3
4
5
6
|
a = [7,2,5,1,3] a.sort() print a #[1, 2, 3, 5, 7] print sorted([7,1,2,6,0,3,2]) #[0, 1, 2, 2, 3, 6, 7] print list(reversed(range(10))) #[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] |
9.导入工具库，dir(math)查看模块中的方法和属性。
|
1
2
3
|
from some_module import f #f直接用 import some_module as sm # sm.f import some_module # some_module.f |
10.Python用if elif else，True False首字母要大写。
11.格式化字符串和新的方法格式化字符串。
|
1
2
3
4
5
|
hw2015 = "%s %s %d"%('Hello','world',2015) print hw2015 #Hello world 2015 print "{} is a {}".format("THis","string") #THis is a string print "{0} can be {1}".format("strings","formatted") #strings can be formatted |
|
1
2
3
4
5
6
7
8
9
10
11
|
import numpy as np print range(5) #[0, 1, 2, 3, 4] print range(1,9,2) #[1, 3, 5, 7] print np.arange(5) #[0 1 2 3 4] print xrange(5) #xrange(5) print list(xrange(5)) #[0, 1, 2, 3, 4] for i in xrange(5): print i |
13.字典：字典(dict)可算是Python中最重要的内置数据结构，他更常见的名字是哈希映射（hash map）或关联数组。
它是一种大小可变的键值对集，其中的键(key)和值（value）都是Python对象。用{ }或dict函数创建字典。
|
1
2
3
4
5
6
7
8
|
d1 = {'a':'some value','b':[1,2,3,4]} print d1 #{'a': 'some value', 'b': [1, 2, 3, 4]} d1[7] = 'an integer' # 添加元素 print d1 #{'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'} print d1['b'] #[1, 2, 3, 4] 访问元素 del d1[7] #删除元素 print d1 #{'a': 'some value', 'b': [1, 2, 3, 4]} |
keys()和values()方法分别用于获取键和值的列表。虽然键值对没有特定的顺序，但这两个函数会以相同的顺序输出键和值：
|
1
2
3
|
d1 = {'a':'some value','b':[1,2,3,4]} print d1.keys() #['a', 'b'] print d1.values() #['some value', [1, 2, 3, 4]] |
利用update方法。一个字典可以被合并到另一个字典中：
|
1
2
3
|
d1 = {'a':'some value','b':[1,2,3,4]} d1.update({'c':12}) print d1 #{'a': 'some value', 'c': 12, 'b': [1, 2, 3, 4]} |
从序列类型创建字典：
|
1
2
3
4
5
6
|
key_list = ['a','b'] value_list = [1,2] mapping = {} for key,value in zip (key_list,value_list): mapping[key] = value print mapping #{'a': 1, 'b': 2} |
14.defaultdict：创建字典时，有时会出现字典的key不存在的异常，为此需使用if else判断一下：
|
1
2
3
4
5
6
7
8
9
|
words = ['apple','bat','bar','atom','book'] by_letter = {} for word in words: letter = word[0] if letter not in by_letter: by_letter[letter] = [word] else: by_letter[letter].append(word) print by_letter #{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']} |
内置的collections模块有一个叫做defaultdict的类，它可以使该过程更简单。传入一个类型或函数（用于生成字典各插槽所使用的默认值）即可创建一个defaultdict：
|
1
2
3
4
5
6
7
|
words = ['apple','bat','bar','atom','book'] from collections import defaultdict by_letter = defaultdict(list) for word in words: by_letter[word[0]].append(word) print by_letter #defaultdict(<type 'list'>, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}) |
|
1
2
3
4
5
6
7
|
strings = ['a','as','bat','car','dove','python'] list_comp = [x.upper() for x in strings if len(x)>2] print list_comp #['BAT', 'CAR', 'DOVE', 'PYTHON'] set_comp = {len(x) for x in strings} print set_comp #set([1, 2, 3, 4, 6]) map_comp = {val:index for index,val in enumerate(strings)} print map_comp #{'a': 0, 'bat': 2, 'python': 5, 'car': 3, 'as': 1, 'dove': 4} |
