关于独立的程序：

我们可以将编写的代码放到一个文本里，并将文件名命名为xxx.py的形式。如果想要运行程序，直接在终端或者命令终端输入 python xxx.py。

命令行参数

我们编写文件test.py，包含下面两行代码：
import sys print('Program arguments:', sys.argv)
下面是我们在shell环境下运行这段程序：
python test.py ('Program arguments:', ['test.py']) python test.py rtcfvgbh fgh ('Program arguments:', ['test.py', 'rtcfvgbh', 'fgh'])

模块和import语句

一个模块仅仅是Python代码的一个文件，是一个不带.py扩展的文件的文件名。引用其他模块的代码时使用import语句，被引用模块种的代码和变量对该程序可见。

导入模块

下面是一个小栗子，主程序输出报告，一个单独的具有单个函数额度模块返回天气的描述。
主程序：命名为weatherman.py
import report description=report.get_description() print("Today's weather:", description)
天气模块的代码：
def get_description(): """Return random weather, just like the pros""" from random import choice possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows'] return choice(possibilities)
我们在两个不同的地方使用了 import：

• 主程序 weatherman.py 导入模块 report；
• 在模块文件 report.py 中，函数get_description() 从 Python 标准模块 random 导入函数 choice。
  我们以两种不同的方式使用了 import：
• 主程序调用 import report，然后运行 report.get_description()；
• report.py 中 的 get_description() 函 数 调 用 from random import choice， 然 后 运 行 choice(possibilities)。
  当导入整个模块的时候，需要把report. 作为get_description()的前缀。在这个 import 语句之后，只要在名称前加 report.，report.py 的所有内容（代码 和变量）就会对主程序可见。通过模块名限定模块的冲突，能够避免命名的冲突。
  当所有代码都在一个函数下，并且没有其他名为choice的函数，所以我们直接从random模块导入函数choice()。
  一般被导入的代码使用多次，就应该考虑在函数外导入；如果被导入的代码使用有限，就在函数内导入。一般建议在开头导入。

使用别名导入模块

我们可以对导入的模块起一个方便记忆的别名：

import 模块名 as 别名

以后在用到模块名的地方都可以换成别名

导入模块的一部分

在python种可以导入模块的若干部分。每一部分都有自己的原始名字或者自己起的别名。首先，从 report 模块中用原始名字导入函数 get_description()：
from report import get_description description = get_description() print("Today's weather:",description)

使用它的别名do_it导入：
from report import get_description as do_it description = get_description() print("Today's weather:",description)

包

我们可以把多个模块组织称文件层次，称之为包。
许我们需要两种类型的天气预报：一种是次日的，一种是下周的。一种可行的方式是新 建目录 sources，在该目录中新建两个模块 daily.py 和 weekly.py。每一个模块都有一个函数 forecast。每天的版本返回一个字符串，每周的版本返回包含 7 个字符串的列表。
下面是主程序和两个模块（函数 enumerate() 拆分一个列表，并对列表中的每一项通过 for 循环增加数字下标）。
主程序：weather.py

from sources import daily,weekly
print(“daily”,daily.forecast())
print(“weekly:”)
for number,outlook in enumerate(weekly.forecast(),1):
print(number,outlook)

模块1:sources/daily.py

def forecast():
‘fake daily forecast’
return ‘like yesterday’

模块2：sources/weekly.py

def forecast():
“””Fake weekly forecast”””
return [‘snow’, ‘more snow’, ‘sleet’, ‘freezing rain’, ‘rain’, ‘fog’, ‘hail’]

除了以上两个模块外，还需要在包 sources目录下添加一个文件：__init__.py。这个文件可以是空的，但python需要它，以便把该目录作为一个包。

Python标准库

使用setdefault()和defaultdict()处理缺失的键

读取字典中不存在的键的值会抛出异常。使用字典函数get()返回一个默认值会避免异常发生。函数setdefault()类似get()，当键不存在时它会在字典中添加一项：

periodic_table = {'Hydrogen': 1, 'Helium': 2}

如果键不在字典中，新的默认值会被添加进去：

carbon = periodic_table.setdefault('Carbon', 12) 
 periodic_table {'Helium': 2, 'Carbon': 12, 'Hydrogen': 1}

如果试图把一个不同的默认值赋给已经存在的键，不回改变原来的值，仍将返回初始值：

helium = periodic_table.setdefault('Helium', 947) 
 periodic_table {'Helium': 2, 'Carbon': 12, 'Hydrogen': 1}

defaultdict()也有同样的用法，但是在字典创建的时候，对每个新的键都会指定默认值。它的参数时一个函数，下面的栗子，把函数int()作为参数传入，会按照int()调用，返回整数0：

from collections import defaultdict
periodic_tab = defaultdict(int)
periodic_tab['Hycds'] = 1 
periodic_tab['Lead']
periodic_tab
defaultdict(int, {'Heklc': 0, 'Hycds': 1, 'Lead': 0})

任何缺失的值都将被赋值为整数0：

函数defaultdict()的参数是一个函数，它返回赋给缺失键的值，下面的栗子中no_idea()在需要时被执行，返回一个值：

from collections import defaultdict 
def no_idea():
    return 'Hub'  
bestity = defaultdict(no_idea)
bestity['A'] = 'nearjkl' 
bestity['B'] = 'jvkefk' 
bestity['A'] 
'nearjkl'
bestity['B'] 
'jvkefk'
bestity['C'] 
'Hub'

同样可以使用函数int()，list()或者dict()返回默认的值：int()返回0，list()返回空列表（[ ]），dict()返回空字典（{ }）。如果你删掉该函数参数，新建的初始值会被设置为None。
也可以使用lambda来定义我们的默认值：

bestiary = defaultdict(lambda: 'Huh?')
bestity['C'] 
'HHub'

使用int是一种定义计数器的方式：

from collections  import  defaultdict 
food_counter = defaultdict(int)
for food in ['spam','spam','eggs','spam']:
    food_counter[food]+=1
for food,count in food_counter.items():
    print(food,count)
结果：
spam 3
eggs 1

上面的栗子中，如果 food_counter 已经是一个普通的字典而不是 defaultdict 默认字典， 那每次试图自增字典元素 food_counter[food] 值时，Python 会抛出一个异常，因为我们没 有对它进行初始化。在普通字典中，需要做额外的工作，如下所示：

dict_counter = {}
for food in ['spam','spam','eggs','spam']:
    ...:     if not  food in dict_counter:
    ...:         dict_counter[food] = 0
    ...:     dict_counter[food] += 1   
for food,count in dict_counter.items():
    ...:     print(food,count) 
结果：
spam 3
eggs 1

在上面的栗子中，我们先创建一个空的字典，然后判断键时候在字典中，如果不在，设置键值为0，如果在将键值加1（肯定事先都不在）。最后遍历字典。

使用Counter()计数

python中有一个标准计数器：Counter()

from collections import Counter 
breakfast = ['spam','spam','eggs','spam']
breakfas_counter = Counter(breakfast)
breakfas_counter
Counter({'eggs': 1, 'spam': 3})

函数most_common()以降序返回所有元素，如果给定一个数字，会返回该数字前的元素：

breakfas_counter.most_common()
[('spam', 3), ('eggs', 1)]
breakfas_counter.most_common(1)
[('spam', 3)]

也可以组合计数器，下面先创建一个列表lunch和一个计数器lunch_counter:

lunch = ['eggs','eggs','bacon']
lunch_counter = Counter(lunch) 
lunch_counter
Counter({'bacon': 1, 'eggs': 2})

第一种组合方式是使用 +:
>breakfas_counter + lunch_counter
Counter({'bacon': 1, 'eggs': 3, 'spam': 3})

第二种组合方式是使用 -：查看早餐有午餐没有
>breakfas_counter - lunch_counter
Counter({'spam': 3})

第三种组合方式是使用交集运算符 & 得到两者共有的项：
>breakfas_counter & lunch_counter
Counter({'eggs': 1})

两者的交集通过取两者中的较小计数。

第四种组合方式是使用并集运算符 | 得到所有元素：
>breakfas_counter |  lunch_counter 
Counter({'bacon': 1, 'eggs': 2, 'spam': 3})

两者的并集通过取两者中较大的计数。

使用有序字典OrderedDict()按键排序

一个字典中键的顺序是不可预知的，字典返回的数据顺序和添加的顺序可能不一致，有序字典OrderedDict()记忆字典键添加的顺序，然后从一个迭代器按照相同的顺序返回。试着用元组（键，值）创建一个有序字典：

from  collections  import OrderedDict
quotes = OrderedDict([('Moe','bhfsnzkml'),('Laary','Oww'),('Curly','ebanj')])
for  stooge in quotes:
    print(stooge)    
Moe
Laary
Curly

双端队列：栈+队列

deque是一个双端队列，同时具有栈和队列的特征。他可以从序列的任何一端添加和删除项。现在，我们从一个词的两端扫向中间，判断是否为回文。函数popleft()去掉最左边的项并返回该项，pop()去掉最右边的项并返回该项。从两边一直向中间扫描，只要两端 的字符匹配，一直弹出直到到达中间：

def palindrome(word):
    from collections import deque 
    dq = deque(word)
    while len(dq) > 1 :
        if dq.popleft() != dq.pop():
            return False 
    return True 
palindrome('a')
True
palindrome('anmmna')
True
palindrome('anmdcds')
False
palindrome('')
True
list = ['a','b','c']
palindrome(list)
False
list = ['a','b','a']
palindrome(list)
True

使用itertools迭代代码结构

itertools包含特殊用途的迭代器函数。在for…in循环中调用迭代函数，每次会返回一项，并记住当前调用的状态。
即使chain()的参数是单个迭代对象，它也会使用参数进行迭代：

import  itertools 
for item in itertools.chain([1,2],['a','b'],{1:'a',2:'b'}):
    print(item)
1
2
a
b
1
2

cycle()是一个在它的参数之间循环的无限迭代器：

import  itertools
for item in itertools.cycle([1,2]):
    print(item)
1
2
1
2

友情提示，上面小栗子会永无止境，要尽快结束

accumulate()计算累积的的值。默认的话，它的计算是累加和：

import  itertools 
for  item in itertools.accumulate([1,2,3,4]):
    print(item)     
1
3
6
10

可以把一个函数作为accumulate()的第二个参数，代替默认的加法函数。这个参数函数应该接受两个参数，返回单个结果。下面的栗子是计算乘积：

import  itertools 
def multiply(a,b):
    return a * b 
for item in itertools.accumulate([1,2,3,4],multiply):
    print(item)    
1
2
6
24

使用pprint()友好输出

之前的栗子中都用print()（或者在交互式解释器中用变量名）打印输出。有时输出结果的可读性差，我们有一个友好的输出函数：pprint()。

In [1]: from pprint import  pprint

In [2]: from collections import  OrderedDict 

In [3]: quotes = OrderedDict([    ('Moe','A djnk  ndk'),    ('Larry','Oww'),    ('Curry','jfnkl'),    ]) 

In [4]: print(quotes) 
OrderedDict([('Moe', 'A djnk  ndk'), ('Larry', 'Oww'), ('Curry', 'jfnkl')])

In [5]: pprint(quotes) 
OrderedDict([('Moe', 'A djnk  ndk'), ('Larry', 'Oww'), ('Curry', 'jfnkl')])

注：本文内容来自《Python语言及其应用》欢迎购买原书阅读