Python入门

Python

第1章 Python概述

1.1 初识Python

TIOBE排行榜：http://www.tiobe.com/tiobe-index//
Python的特性 ：简单易学、开源的、免费的、高可移植性全面支持面向对象的程序设计思想高可扩展性支持嵌入式编程、功能强大的开发库

1.2 开始Python编程

执行Python脚本文件

cmd执行命令：访问F盘，只需要输入F：进入文件夹，输入cd filedicname。查看目录结构，输入dir。返回上一层目录，输入 cd..。切换到程序目录之后输入python xxx.py即可。

第2章 Python语言基础

2.1 标量类型

命名

常量 ：常量命名全部大写。
变量：标识符名字是区分大小写的。变量名使用小写字母，驼峰命名法：numberOfStudents, radius。

变量赋值就是将对象(该变量的地址)指向赋值给它的常量或者变量的地址。

字符串
字符串和元组是不可变的。换行字符串可以使用三重引号。
2.7版本的Python不能print汉字。解决办法

a = u"我是中文"
print a

常用转义字符

\n——换行
\r——回车
\''——''
\——\

s = r"this\has\no"      #原生字符串，等价于"this\\has\\no"
print '%.2f %s are wortg $%d' %(4.555, 'test', 2)      #字符串格式化

字符串处理函数

数据类型转换

list(str)           #字符串转列表
tuple(str)          #字符串转元组
"".join(lists)      #列表转字符串
"".join(tuples)     #元组转字符串
int()       
long()
float()
eval()              #计算字符串中的有效Python表达式，并返回结果
str()
repr()              #将对象转换为可打印字符串
chr ()              #将一个整数转换为可对应ASCII的字符
ord()               #将一个字符转换为对应的ASCII
hex()               #将一个整数转换为一个十六进制字符串
oct()               #将一个整数转换为一个八进制字符串

2.2 运算符和表达式

运算符

python2中整数相除结果不保留小数位。可以添加以下解决：

from __future__ import division

运算符优先级

三元表达式

value = true-expr if condition else fasle-expr

2.3 常用语句

循环语句

for i in range(start, end):
    break                   #只能跳出一重循环
    continue                #提前进入下一个循环
fruits = [‘banana’, ‘apple’]
for fruit in fruits:
    print fruit

while结构中存在可选部分else，当循环体执行结束后，会执行else语句块。但是当break语句和else语句相结合，while会因为break语句而终止。

range和xrange

range(a, b)         #a - b-1
range(b)            #0 - b-1
range(a, b, k)      #范围a, a+k, …b-x,
range(a, b, -1)     #范围a, a-1, …b-(-1)
#对于非常长的范围，建议使用xrange，不会预先产生所有的值并将它们保存到列表中，而是返回用于逐个产生整数的迭代器
sum = 0
for i in xrange(10000):
    if i % 3 == 0 or i % 5 == 0:
        sum += i

异常处理

try:
    <try语句块>
# 不同的异常处理，可以使用多个except
except [<异常处理类>, <异常处理类>,….] as <异常处理对象>:
    <异常处理代码>
finally:
    <最后执行的代码>

例子：

try:
    i = 10
    print(30 / (i - 10))
except Exception as e:
    print(e);
finally:    
    print("执行完成")
def attempt_float(x):
    try:
        return float(x)
    except (TypeError, ValueError):
        return x

raise ValueError可以手动触发Error。主要包括：NameError，ZeroDiVisionError，IndexError, KeyError, IOError, ValueError, EOFError, TypeError, AtrributeError

pass：空操作。可以用于没有任何功能的代码块。

2.4 序列数据结构

列表

列表（List）是一组有序存储的数据。变长，可修改。遍历列表时，不能删除其中的元素，可以保留要删除的元素到新的列表中，然后再处理，否则会引起不可预测的后果。

menulist = ['红烧肉', '熘肝尖', '西红柿炒鸡蛋', '油焖大虾']
len(menulist)                               # 获取列表长度
print(menulist[0])
menulistr.append('北京烤鸭')                # 添加列表元素
menulist.insert(4, '北鸭')                    # 插入列表元素
popitem = menulist.pop(4)                   # 移除元素，并返回指定索引处的值
print '红烧肉' in menulist
menulist1.extend (menulist2)                # 合并列表
menulist3 = menulist1 + menulist2           #列表合并，保留重合
del menulist[0]
print(menulist.index('红烧肉'))             # 获取列表中某个元素的索引
# 遍历
list2 = [["CPU", "内存"], ["硬盘","声卡"]]
for i in range(len(list2)):
    for j in range(len(list2[i])):
        print(list2[i][j])
#使用sort()函数对列表进行升序排列，修改列表
a = [7, 2, 5, 1, 3]
a.sort()
b = ['saw', 'small', 'He', 'foxes', 'six']
b.sort(key=len)
# reverse()函数对列表进行反序排列
listobj.reverse()
# sorted 不修改列表
a = [7, 1, 2, 6, 0, 3, 2]
b = sorted(a)
sorted('horse race')
sorted(set('this is just some string'))
# 二分搜索和维护有序列表
import bisect
c = [1, 2, 2, 2, 3, 4, 7]
bisect.bisect(c, 2)             #二分搜索
bisect.bisect(c, 5)
bisect.insort(c, 6)             #二分插入
#切片
seq = [7, 2, 3, 7, 5, 6, 0, 1]
seq[1:5]                        # 索引[2, 3, 7, 5]
seq[3:4] = [6, 3]               # 赋值[7, 2, 3, 6, 3, 5, 6, 0, 1]
seq[:5]
seq[3:]
seq[-4:]                        # [5, 6, 0, 1]
seq[-6:-2]                      # [6, 3, 5, 6]
seq[::2]                        # 步长为2 [7, 3, 3, 6, 1]
seq[::-1]                       # 反序排列
#内置的序列函数
# enumerate逐个返回序列的(i,value)元组
for i, value in enumerate(collection): 
   # do something with value
# 例子：将序列值映射到其所在位置的字典
# 结果：mapping    {'bar': 1, 'baz': 2, 'foo': 0}
some_list = ['foo', 'bar', 'baz']
mapping = dict((v, i) for i, v in enumerate(some_list))
#序列配对：产生新的元组列表，最短的序列决定yuanzu长度
#例子1
#结果： [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]
seq1 = ['foo', 'bar', 'baz']
seq2 = ['one', 'two', 'three']
zip(seq1, seq2)
# 例子2
# 结果：[('foo', 'one', False), ('bar', 'two', True)]
seq3 = [False, True]
zip(seq1, seq2, seq3)
# 例子3
# 结果
#0: foo, one
#1: bar, two
#2: baz, three
for i, (a, b) in enumerate(zip(seq1, seq2)):
    print('%d: %s, %s' % (i, a, b))
# 解压
# 例子3
# 结果：first_names ('Nolan', 'Roger', 'Schilling')
# 结果：last_names ('Ryan', 'Clemens', 'Curt')
pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),
            ('Schilling', 'Curt')]
first_names, last_names = zip(*pitchers)
#逆序迭代
list(reversed(range(10)))
# 常用函数       
max(seq)
min(seq)
sum(seq)
seq.pop()
seq.count(value)

变量传递

is和==

1. is是比较两个引用是否指向了同一个对象（引用比较）比较的是内存地址。
2. ==是比较两个对象是否相等它会直接进行值比较。

a=[1, 2, 3]
b=a#两者指向同一对象
c = list(a)
print “Are they same?” , a is b  #True a的引用复制给b，他们在内存中其实是指向了用一个对象
print “Are they same？”, [4, 5, 6] is [4, 5, 6] # 结果为假
b == a # True 值相等
b = a[:] # b通过a切片获得a的部分，这里的切片操作重新分配了对象，
b is a #False 指向的不是同一个对象
b == a # True 值相等

元组

一经定义，元组的内容不能改变。元组元素可以是不同类型的数据，可以是字符串、数字，甚至是元组。

# 创建
tup = 1,2,3,4
nested_tup = (4, 5, 6), (7, 8)
tuple([4, 0, 2])
t = (1, 2, 3, 4) 
print(t[0])
print(len(t))
# 'sdr'
s =('s''d''r') 
# error!不可修改
s[1]=’w’ 
# 元组的遍历
t = ('王二', '张三', '李四', '王五');
for i in range(len(t)):
    print(t[i]);
list = ['王二', '张三', '李四', '王五'];
for index,value in enumerate(list):
    print("第%d个元素值是[%s]" %(index, value));
# 元组和List的转换
listobj = list(tupleobj)
tupleobj = tuple(listobj)
# 连接
(4, None, 'foo') + (6, 0) + ('bar',)
('foo', 'bar') * 4
# 拆包
tup = (4, 5, 6)
a, b, c = tup       
tup = 4, 5, (6, 7)
a, b, (c, d) = tup
# 交换值简写
tmp = a
a = b
b = tmp
b, a = a, b
seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]#元组迭代时候拆包
for a, b, c in seq:
    pass
# 方法
a = (1, 2, 2, 2, 3, 4, 2)
a.count(2)

字典

更常见的名字：哈希映射，是一种大小可变的键值对集。可以在定义字典时指定里面的元素，每个元素由键和值组成，键和值之间由冒号（:）分割，元素间由逗号（,）分割。
特点：

1. 字典查找和插入的速度极快，不会随着键的增加而增加
2. 需要占用大量内存
3. 无序对象的集合。

d={'name':'小明', 'sex':'男','age':'18', 'score':'80'}
print(len(d))
print(d['name'])                # 对字典元素的访问
d.pop('score')                  # 删除指定的字典元素
d['height'] = '170'             # 插入元素
'name' in d                     # 判断是否存在某个键
del d['height']                 # 删除值
ret = d.pop('age')
print ret                       # 18
print d.keys()                  # 返回一个包含所有键的列表，python3返回迭代器
print d.values()                # 返回一个包含所有值的列表，python3返回迭代器
d.update(d2)                    # 将2个字典合并,d2中的键值对覆盖进去d中
mapping = dict(zip(range(5), reversed(range(5))))       # 从序列创建字典
# 默认值
value = some_dict.get(key, default_value)               # 省略了if-else块
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)
    # if-else可以用以下代替，解决了初始不在字典的问题
    by_letter.setdefault(letter, []).append(word)
# 也可以生成字典值的默认值
from collections import defaultdict
by_letter = defaultdict(list)
for word in words:
    by_letter[word[0]].append(word)
# 字典键的有效性
# 字典值可以是任意对象，但是键必须是不可变对象。通过hash判断是否可作为键
hash((1, 2, (2, 3)))
hash((1, 2, [2, 3])) # fails because lists are mutable
# 字典嵌套
d={'name':{'first':'Johney','last':'Lee'},'age':40}
print(d['name'][ 'first'])
 # 遍历字典的键
d={'age': '18', 'name': '小明', 'score': '80', 'sex': '男'}
for key in d.keys():
    print('键'+key+ '的值：'+ d[key]);
 # 遍历字典的值
for value in d.values():
    print(value);
#清空指定的字典所有元素
d. clear()
# 判断是否存在元素
d={'age': '18', 'name': '小明', 'score': '80', 'sex': '男'}
if 'name1' in d: 
    print(d['name1'])
else:
    print('不包含键位name1的元素')
# 检查字典中是否存在某一键
has_key()
# 返回一个由(key, value)组成的列表
items()
counts = dict()
names = ['csev', 'cwen', 'csev', 'zqian', 'cwen']
for name in names :
    #get 根据键返回值，当间不存在的时候返回0并增加一个键
    counts[name] = counts.get(name, 0) + 1#计数，开始为0
print counts

集合

集合是由唯一元素组成的无序集。集合由一组无序排列的元素组成，可以分为可变集合（set）和不可变集合（frozenset）。可变集合创建后可以添加元素，修改元素和删除元素。而不可变集合创建后则不能改变。

# 创建的两种方法
set([2, 2, 2, 1, 3, 3])
{2, 2, 2, 1, 3, 3}
# 数学运算
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7, 8}
a | b               # union (or)
a & b               # intersection (and)
a - b               # difference
a ^ b               # symmetric difference (xor)
s = s1.union(s2)
s = s1.intersection (s2)
s = s1.difference(s2)
# 集合之间的关系
a_set = {1, 2, 3, 4, 5}
{1, 2, 3}.issubset(a_set)
a_set.issuperset({1, 2, 3})
# 集合运算
a.add(x)                # 将x添加到集合a
a.remove(x)             # 从a中删除元素x
a.isdisjoint(b)         # 没有公共元素，则为True
s = set('python')       #可变集合
print s                 # 无序
print len(s) 
s.add('0')              # 添加元素
s.update([4, 5, 6])     # 另外一个集合的元素添加到指定集合中
s.remove('p')           # 清除指定元素
if 2 in s:              #判断集合是否存在元素
    print '存在'
# 遍历集合
for e in s:
    print(e);
# 清除所有元素
s.clear()       
fs = frozenset('python')        # 不可变集合
print(type(fs))                 # <type 'frozenset'>
print(fs)                       # frozenset(['h', 'o', 'n', 'p', 't', 'y'])

推导式

• 列表基本形式

expr for val in collection if condition

相当于

result = []
for val in collection:
    if condition:
        result.append(expr)

例子

strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
[x.upper() for x in strings if len(x) > 2]

• 字典推导式：

dict_comp = {key-expr: value-expr for value in collection if condition}

例子

loc_mapping = {val : index for index, val in enumerate(strings)}
# 或者
loc_mapping = dict((val, idx) for idx, val in enumerate(strings))

• 集合推导式

set_comp = {expr for value in collection if condition}

例子

unique_lengths = {len(x) for x in strings}

• 嵌套列表推导式

all_data = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
            ['Susie', 'Casey', 'Jill', 'Ana', 'Eva', 'Jennifer', 'Stephanie']]
names_of_interest = []
for names in all_data:
    enough_es = [name for name in names if name.count('e') > 2]
    names_of_interest.extend(enough_es)
# for 可以用以下代替
result = [name for names in all_data for name in names
          if name.count('e') >= 2]
# 扁平化整数列表
some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
# 顺序和for写是一样的
flattened = [x for tup in some_tuples for x in tup]

第3章 函数

3.1 声明和调用函数

3.1.1 自定义函数

关键字参数：通常用于指定默认值或可选参数。其余为位置参数。关键字参数必须位于位置参数之后。

"""
===================================
Demo of xxx algorithm
===================================
功能说明
"""
print(__doc__)
def PrintString(str):
'''
说明
'''
    print(str)
def my_function(x, y, z=1.5):
    if z > 1:
        return z * (x + y)
    else:
        return z / (x + y)
my_function(5, 6, z=0.7)
my_function(3.14, 7, 3.5)

当编写func(a, b, c, d=some, e=value)时，位置参数和关键字参数分别被打包成元组和字典。函数实际接收的是一个元组args和一个字典kwargs，并进行一些错误检查。

a, b, c = args#内部转化
d = kwargs.get('d', d_default_value)
e = kwargs.get('e', e_default_value)

def say_hello_then_call_f(f, *args, **kwargs):
    print 'args is', args
    print 'kwargs is', kwargs
    print("Hello! Now I'm going to call %s" % f)
    return f(*args, **kwargs)
def g(x, y, z=1):
    return (x + y) / z
In [8]:  say_hello_then_call_f(g, 1, 2, z=5.)
args is (1, 2)
kwargs is {'z': 5.0}
Hello! Now I'm going to call <function g at 0x2dd5cf8>
Out[8]: 0.6

3.1.2 作用域

a = 100;        # 全局变量
def setNumber():
    a = 10;     # 局部变量
    print(a);   # 打印局部变量a
setNumber();
print(a);       # 打印全局变量a
# 全局变量声明使用global!!!
a = None
def bind_a_variable():
    global a
    a = []
bind_a_variable()
print a
def outer_function(x, y, z):#局部函数
    def inner_function(a, b, c):
        pass
    pass

设置断点，运行时可以查看变量的值。

柯里化：部分参数应用

通过“部分参数应用”从现有函数派生出新函数的技术。如：

def add_numbers(x, y):
    return x + y
add_five = lambda y: add_numbers(5, y)

内置的functools模块可以用partial函数将此过程简化：

from functools import partial
add_five = partial(add_numbers, 5)

例子：

# compute 60-day moving average of time series x
ma60 = lambda x: pandas.rolling_mean(x, 60)
# Take the 60-day moving average of of all time series in data
data.apply(ma60)

3.2 参数和返回值

3.2.1 在函数中传递参数

def outer_function(x, y, z):
    def inner_function(a, b, c):
        pass
    pass
def f():#返回多个值
    a = 5
    b = 6
    c = 7
    return a, b, c
a, b, c = f()
def f():#返回字典
    a = 5
    b = 6
    c = 7
    return {'a' : a, 'b' : b, 'c' : c}
#####################函数是对象#####################
states = ['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda',
          'south   carolina##', 'West virginia?']
def remove_punctuation(value):
    return re.sub('[!#?]', '', value)
clean_ops = [str.strip, remove_punctuation, str.title]
def clean_strings(strings, ops):
    result = []
    for value in strings:
        for function in ops:
            value = function(value)
        result.append(value)
    return result
clean_strings(states, clean_ops)
# 在一组数据上应用一个函数
map(remove_punctuation, states)

def func(num):
    print("形参num的地址", id(num))
a = 10
func(a);
print("实参a的地址", id(a));

运行结果如下：
形参num的地址 1557053600
实参a的地址 1557053600
地址竟然是一样的！！！

默认参数：
在Python中，可以为函数的参数设置默认值。可以在定义函数时，直接在参数后面使用“=”为其设置默认值。在调用函数时可以不指定拥有默认值的参数的值，此时在函数体中以默认值作为该参数。

def say(message, times = 1):
    print(message * times)
say('hello')
say('Python', 3)

有默认值的参数放在没有默认值的参数前面，可能会报错
关键参数：
可以任意顺序指定参数。

def func(a, b=5, c=10):
    print a, b, c
func(3, 7)
func(25, c=24)
func(c=50, a=100)

Python还支持可变长度的参数列表。可变长参数可以是元祖或字典。当参数以*开头时，表示可变长参数将被视为一个元祖，格式如下：
def func(*t):
在func ()函数中t被视为一个元祖，使用t[index]获取每一个可变长参数。
def func1(*t):
print("可变长参数数量如下：")
print(len(t))
print("依次为：")
for x in range(len(t)):
print(t[x]);
调用：func1(1,2,3,4);

以字典为可变长参数：
def sum(**t):
print(t);
sum(a=1,b=2,c=3);
运行结果如下：
{'a': 1, 'c': 3, 'b': 2}

3.3内置函数

3.3.1数学运算函数

3.3.2其他常用内置函数

help()函数
help()函数用于显示指定参数的帮助信息，语法如下：
help(para)
如果para是一个字符串，则会自动搜索以para命名的模块，方法等。如果para是一个对象，则会显示这个对象的类型的帮助信息。

type()函数用于显示指定对象的数据类型，语法如下：
type(obj)
obj是一个常量、变量或对象 

第4章 Python面向对象程序设计

4.2 定义和使用类

4.2.1 声明类

class Person:
    name = “zhou”
    def SayHello(self):
        print("Hello!")

在成员函数SayHello()中有一个参数self。这也是类的成员函数（方法）与普通函数的主要区别。类的成员函数必须有一个参数self，而且位于参数列表的开头。self就代表类的实例（对象）自身，可以使用self引用类的属性和成员函数。
xxx表示系统定义名字。
xxx表示类中的私有属性，私有属性不能通过类名和对象名访问。共有属性可以通过类名和对象名两种方式访问。
**构造函数**是类的一个特殊函数，它拥有一个固定的名称，即__init
析构函数有一个固定的名称，即del ()

class MyString:
    def __init__(self): #构造函数
        self.str = "MyString"
    def __del__(self):  #析构函数
        print("byebye~")
    def output(self):
        print(self.str);
s = MyString()
s.output()
del s  #删除对象

4.2.2 静态变量

Python不需要显式定义静态变量，任何公有变量都可以作为静态变量使用。

class Users (object):
        online_count = 0;
        def __init__(self):# 构造函数,创建对象时Users.online_count加1
                Users.online_count+=1;
        def __del__(self):# 析构函数,释放对象时Users.online_count减1
                Users.online_count-= 1;
a = Users();创建Users对象
a.online_count += 1
print(Users.online_count);

4.2.3 方法

对象方法
如果在方法名前面加上了两个下划线，表示为私有方法。私有方法只能在对象的公有方法中通过self调用。
静态方法
静态方法不需要参数。只能通过类名调用。
1. 静态方法无需传入self参数，因此在静态方法中无法访问属于对象的成员，只能访问属于类的成员。
2. 在静态方法中不可以直接访问类的静态变量，但可以通过类名引用静态变量。

因为不能直接访问类的静态变量，所以静态方法与定义它的类没有直接关系，而是起到了类似函数工具库的作用。

class 类名:
    @staticmethod
    def 静态方法名():
        方法体
    @classmethod
    def 类方法名(cls):
        方法体

类方法
1. 类方法可以使用类名调用类方法。
2. 类成员方法也无法访问实例变量，但可以访问类的静态变量。
3. 类方法需传入代表本类的cls参数

4.2.4 instance()函数判断对象类型

isinstance(对象名, 类名或类型名)

4.3 类的继承和多态

4.3.1 继承

从类A派生一个类B，代码如下：

class B(A) :
    propertyB;  # 类B的成员变量
    def functionB():    # 类B的成员函数

支持多重继承，需要以逗号分隔。

class UserLogin(Users):
    def __init__(self, uname, lastLoginTime):
        Users.__init__(self, uname) #调用父类Users的构造函数
        self.lastLoginTime = lastLoginTime
    def dispLoginTime (self):
        print(" 登录时间为：" + self.lastLoginTime);
#获取当前时间
now = time.strftime('%Y-%m-%d%H:%M:%S',time.localtime(time.time()))

4.3.2 抽象类和多态

Python通过类库abc实现抽象类，因此在定义抽象类之前需要从类库abc导入ABCMeta类和abstractmethod类。

from abc import ABCMeta, abstractmethod

ABCMeta是 Metaclass for defining Abstract Base Classes的缩写，也就是抽象基类的元类。所谓元类就是创建类的类。在定义抽象类时只需要在类定义中增加如下代码：

__metaclass__ = ABCMeta

即指定该类的元类是ABCMeta。例如：

class myabc(object):
    __metaclass__ = ABCMeta

在抽象类里面可以定义抽象方法。定义抽象方法时需要在前面加上下面的代码：

@abstractmethod

因为抽象方法不包含任何实现的代码，所以其函数体通常使用pass。例如，在抽象类myabc中定义一个抽象方法abcmethod()，

class myabc(object):
    __metaclass__ = ABCMeta
   @abstractmethod
   def abcmethod (self):pass

重载
子类中使用与父类完全相同的方法名，从而重载父类的方法。

4.4 复制对象

新对象名 = 原有对象名 

第5章 Python模块

5.1 Python标准库中的常用模块

模块是Python语言的一个重要概念，它可以将函数按功能划分到一起，以便日后使用或共享给他人。可以使用Python标准库中的模块，也可以下载和使用第三方模块。

5.1.1 sys模块

sys模块是Python标准库中最常用的模块之一。通过它可以获取命令行参数，从而实现从程序外部向程序传递参数的功能；也可以获取程序路径和当前系统平台等信息。

5.1.2 platform模块

CPython：默认的Python实现。脚本大多数情况下都运行在这个解释器中。 CPython是官方的python解释器，完全按照Python的规格和语言定义来实现，所以被当作其他版本实现的参考版本。CPython是用C语言写的，当执行代码的时候Python代码会被转化成字节码。因此CPython是个字节码解释器。
PyPy：由Python写成的解释器。很多地方都和CPython很像的实现。这个解释器的代码先转化成C，然后再编译。PyPy比CPython性能更好。因为CPython会把代码转化成字节码，PyPy会把代码转化成机器码。

5.1.3 与数学有关的模块

math

random

decimal
浮点数缺乏精确性，decimal模块提供了一个Decimal 数据类型用于浮点数计算。与内置的二进制浮点数实现float相比，Decimal 数据类型更适用于金融应用和其他需要精确十进制表达的情况。
使用下面的方法可以定义Decimal类型的数据：

from decimal import Decimal
Decimal(数字字符串)

fractions模块
fractions模块用于表现和处理分数。

import fractions
x = fractions.Fraction(分子, 分母)
Fraction对象将会自动进行约分。

5.1.4 time模块

from datetime import datetime, date, time
dt = datetime(2011, 10, 29, 20, 30, 21)
print dt.day#29
print dt.minute#30
print dt.date()#2011-10-29
print dt.time()#20:30:21
print dt.strftime('%m/%d/%Y %H:%M')#10/29/2011 20:30 格式化变成了字符串
print datetime.strptime('20091031', '%Y%m%d')#2009-10-31 00:00:00
print dt.replace(minute=0, second=0)#2011-10-29 20:00:00
dt2 = datetime(2011, 11, 15, 22, 30)
delta = dt2 - dt
print delta#17 days, 1:59:39
type(delta)#datetime.timedelta
print dt + delta#2011-11-15 22:30:00
time.time()#获取当前时间的时间戳
time.localtime()#将一个时间戳转换成一个当前时区的struct_time
time.ctime()#可以返回当前时间的字符串。

5.2 自定义和使用模块

5.2.1创建自定义模块

5.2.2导入模块

#mymodule.py
def PrintString(str):
    print(str);
#求和
def sum(num1, num2):
    print(num1 + num2);
import mymodule # 导入mymodule模块
mymodule.PrintString("Hello Python")#调用PrintString()函数
mymodule.sum(1,2)  #调用sum()函数

第6章 函数式编程

一种编程的基本风格。将计算过程看作是数学函数，使用表达式编程。
函数式编程的优点

1. 便于进行单元测试
2. 便于调试
3. 适合并行执行

6.1 函数式编程

6.1.1 匿名函数 lambda

lambda表达式的函数体只能有一条语句，也就是返回值表达式语句。其语法如下：

func = lambda input1, ...inputn : return_expr

例如

sum = lambda x,y,z : x+y+z #求和
sum(1,2,3)#调用

可以将lambda 表达式作为数组元素（也可以是列表或字典），从而实现跳转表的功能（函数的列表）。lambda 表达式数组的定义方法如下：

arrObject = [(lambda expr1), (lambda expr2), …]
Arr= [(lambda x: x**2), (lambda x: x**3), (lambda x: x**4)]
# 下面分别调用列表函数
print (Arr[0](2), Arr[1](2), Arr[2](2)) #2的平方、立方和四次方组成的元组

可以将lambda 表达式作为函数的返回值：

def math(o):
    if(o==1):
        return lambda x,y : x+y
    if(o==2):
        return lambda x,y : x-y
    if(o==3):
        return lambda x,y : x*y
    if(o==4):
        return lambda x,y : x/y
action = math(1)#返回加法Lambda表达式
print("10+2", action(10,2))
action = math(2)#返回减法Lambda表达式
print("10-2=",action(10,2))
action = math(3)#返回乘法Lambda表达式
print("10*2,=",action(10,2))
action = math(4)#返回除法Lambda表达式
print("10/2,=",action(10,2))
#############lambda函数是一个对象################
def apply_to_list(some_list, f):
    return [f(x) for x in some_list]
ints = [4, 0, 1, 5, 6]
apply_to_list(ints, lambda x: x * 2)
strings = ['foo', 'card', 'bar', 'aaaa', 'abab']
strings.sort(key=lambda x: len(set(list(x))))#根据单词中字母多少来排序
strings

6.2.2 map()

map()函数用于将指定序列中的所有元素作为参数调用指定函数，并将结果构成一个新的序列返回。map函数的语法如下：

结果序列 = map(映射函数, 序列1[, 序列2,…])

例子

arr = map(lambda x: x ** 2, [2, 4, 6, 8, 10])
for e in enumerate(arr):
    print(e)
arr = map(lambda x,y: x + y, [1, 3, 5, 7, 9] ,[2, 4, 6, 8, 10])
for e in enumerate(arr):
    print(e)

6.2.3 filter()

filter()函数可以对指定序列执行过滤操作，具体定义如下：

filter(函数function, 序列sequence)
#函数function接受一个参数，返回布尔值True或False。序列sequence可以是列表、元组或字符串

例子

def is_even(x):
    return x %2 == 0
arr = filter(is_even, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print arr #[2, 4, 6, 8, 10]

6.2.4 reduce()

reduce()函数用于将指定序列中的所有元素作为参数按一定的规则调用指定函数。reduce函数的语法如下：

计算结果= reduce(映射函数, 序列)

映射函数的必须有2个参数。reduce()函数首先以序列的第1和第2个元素为参数调用映射函数，然后将返回结果与序列的第3个元素为参数调用映射函数。以此类推，直至应用到序列的最后一个元素，将计算结果作为reduce()函数的返回结果。

from functools import reduce#python 3.0之后不被集成到内置函数中
def myadd(x,y): 
    return x+y
sum=reduce(myadd,(2,4,6,8,10))
print(sum)

6.2.5 zip()

zip()函数以一系列列表作为参数，将列表中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

a = [1,2,3]
b = [4,5,6,7,8,9]
zipped = zip(a,b)#[(1, 4), (2, 5), (3, 6)]
for element in zipped:
    print(element)
a = [1,2,3]
b = [4,5,6]
zipped = zip(a,b)
unzipped = zip(*zipped)#解压[(1, 2, 3), (4, 5, 6)]
for element in unzipped:
    print(element)

6.2.6 对比

函数式编程：

1. 代码更简单。
2. 数据，操作，返回值都放在一起。
3. 没有循环体，几乎没有临时变量，也就不用劳神去分析程序的流程行尾数据变化过程了。
4. 代码用来要做什么，而不是怎么去做。

list1 =[2, -6, 11, -7, 8, 15, -14, -1, 10, -13, 18]
sum = 0
for i in range(len(list)):
    if list [i]>0:
        sum += list1[i]
print(sum)
#######################################
from functools import reduce
list1 =[2, -6, 11, -7, 8, 15, -14, -1, 10, -13, 18]
sum = filter(lambda x: x>0, list1)
s = reduce(lambda x,y: x+y, sum)
print(s)

6.3 闭包和递归函数

闭包：闭包指函数的嵌套。可以在函数内部定义一个嵌套函数，将嵌套函数视为一个对象，所以可以将嵌套函数作为定义它的函数的返回结果。被返回的函数可以访问其创建者的局部命名空间中的变量。

def func_lib():
    def add(x, y):
        return x+y
    return add       # 返回函数对象
fadd = func_lib()
print(fadd(1, 2))
##
def make_closure(a):
    def closure():
        print 'I know the secret: %d' % a
    return closure
closure = make_closure(5)
closure()
## 记录曾经传入的一切参数
def make_watcher():
    have_seen = {}
    def has_been_seen(x):
        if x in have_seen:
            return True
        else:
            have_seen[x] = True
            return False
    return has_been_seen
watcher = make_watcher()
vals = [5, 6, 1, 5, 1, 6, 3, 5]
[watcher(x) for x in vals]
## 15位字符串浮点数格式化器
def format_and_pad(template, space):
    def formatter(x):
        return (template % x).rjust(space)
    return formatter
fmt = format_and_pad('%.4f', 15)
fmt(1.756)

递归函数：递归函数是指直接或间接调用函数本身的函数。

• 优势：它能使一个蕴含递归关系且结构复杂的程序简洁精炼，增加可读性
• 劣势：嵌套层次深，函数调用开销大

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
print(fact(5))

6.4 迭代器和生成器

6.4.1 迭代器

迭代器是访问集合内元素的一种方式。迭代器对象从序列（列表、元组、字典、集合）的第一个元素开始访问，直到所有的元素都被访问一遍后结束。迭代器不能回退，只能往前进行迭代。
1.iter（）函数
使用内建的工厂函数iter(iterable)可以获取序列的迭代器对象，方法如下：迭代器对象 = iter(序列对象)
使用next()函数可以获取迭代器的下一个元素，方法如下:next(迭代器对象)

list = [111, 222, 333]
it = iter(list)
print(next(it))
print(next(it))
print(next(it))

2、enumerate ()函数
使用enumerate ()函数可以将列表或元组生成一个有序号的序列。

list = [111, 222, 333]
for index , val in enumerate(list):
    print("第%d个元素是%s" %(index+1, val))

6.4.2 生成器

生成器是构造新的可迭代对象的一种简单方式。以延迟的方式返回一个值序列，每返回一个值之后暂停，直到下一个值被请求时再继续。创建只需要将函数中的return替换为yield即可。 生成器是一个特殊的函数，它具有如下特点：

1. 生成器函数都包含一个yield语句，当执行到yield语句时函数返回；
2. 生成器函数可以记住上一次返回时在函数体中的位置，对生成器函数的下一次调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。

#addlist()是一个生成器，它会遍历列表参数alist中的每一个元素，然后将其加1，并使用yield语句返回。生成器的返回值有一个__next__()方法，它可以恢复生成器执行，直到下一个yield表达处
# Python 3
def addlist(alist):
    for i in alist:
        yield i + 1
alist = [1, 2, 3, 4]
x = addlist(alist)#生成器
x= x.__next__();
print(x);
x= x.__next__();
print(x);
x= x.__next__();
print(x);
x= x.__next__();
print(x);

第7章 IO编程

7.1 输入和显示数据

7.1.1 输入数据

用户输入的数据 = input( 提示字符串)

 a = eval(raw_input("Enter a value:"))  #字符串转换为数字

7.1.2 输出数据

for i in range(0,10):
    print(i, end='')#不会换行

科学计数法：123.456表示成1.23456E2
不换行打印：print(item, end =’ ’) print(‘BBB’, end = ‘ ‘ )
格式化浮点数：print(format(57.3, “10.2f”))：10位长度2位小数
“10.2%”:写成百分数形式
“<10.2f”:左对齐

7.2 文件操作

与文件相关的模块：
os模块：对目录和文件进行操作
os.path模块：文件的属性获取
shutil模块：日常的文件和目录管理任务

7.2.1 打开文件

在读写文件之前，需要打开文件。调用open()函数可以打开指定文件，语法如下：
文件对象 = open(文件名,访问模式,buffering)
也可以使用file()函数打开文件，file()函数和open()函数的用法完全相同。
访问模式参数的可取值

7.2.2 关闭文件

f.close()

7.2.3 读取文件内容

1．read()

str = f.read([b])   #b读取的字节数

2．readlines()

list= f.readreadlines() # 读取文件中的所有行，返回行字符串列表

3．readline()

str= f.readline()   #逐行读取文件的内容

4．使用in关键字

for line in f:
    # 处理行数据line

7.2.4 写入文件

1．write()方法

f. write(str)

2．追加写入
以a或a+为参数调用open()方法打开文件。
3．writelines()方法

f.writelines(sequence_of_strings)   #写入字符串序列

7.2.5 文件指针

1．获取文件指针的位置
文件指针是指向一个文件的指针变量，用于标识当前读写文件的位置，通过文件指针就可对它所指的文件进行各种操作。打开一个文件时，文件指针的位置为0。

pos = f.tell()      #获取文件指针的位置

2．移动文件指针

f.seek((offset,where))

offset：移动的偏移量，单位为字节。等于正数时向文件尾方向移动，等于负数时向文件头方向移动文件指针。
where：指定从何处开始移动。等于0时从起始位置移动，等于1时从当前位置移动，等于2时从结束位置移动。

7.2.6截断文件

可以使用truncate()方法从文件头开始截取文件

f.truncate([size])

参数size指定要截取的文件大小，单位为字节，size字节后面的文件内容将被丢弃掉。

7.2.7 文件属性

使用os模块的stat()函数可以获取文件的创建时间、修改时间、访问时间、文件大小等文件属性。

文件属性元组 = os.stat(文件路径)

os.stat()返回的文件属性元组元素的含义

sta模块中定义的文件属性元组索引对应的常用常量

import os, stat
fileStats = os.stat('test.txt')                #获取文件/目录的状态
print(fileStats[stat.ST_SIZE])
print(fileStats[stat.ST_MTIME])
print(fileStats[stat.ST_ATIME])
print(fileStats[stat.ST_CTIME])

7.2.8 复制文件

shutil.copy("C:\\Python34\\LICENSE.txt", "D:\\LICENSE.txt")

7.2.9 移动文件

move(src, dst)

7.2.10 删除文件

os.remove(src)      # src指定要删除的文件

7.2.11 重命名文件

os.rename(原文件名, 新文件名)

7.3 目录编程

7.3.1 获取当前目录

os.getcwd()

7.3.2 获取目录内容

os.listdir(path)

7.3.3 创建目录

os.mkdir(path)

7.3.4 删除目录

os.rmdir(path)

第8章 图形界面编程

Python提供了一些用于图形界面编程的模块，包括Tkinter模块、wxWidgets模块、easygui模块和wxpython模块。
Tkinter模块：是Python的标准T看GUI工具包的接口。
wxPython：开源软件，GUI图形库，下载：wxpython.org/download.php

8.1 常用Tkinter组件的使用

import Tkinter #导入Tkinter模块
import Tkinter as tk #导入Tkinter为tk
from tkinter import * #导入Tkinter所有内容
form tkinter import func1 #导入模块的某一函数

8.1.1 弹出消息框

from tkinter.messagebox import *
showinfo(title=‘标题’,message=‘内容’)       # 提示消息框
showwarning(title=‘标题’,message=‘内容’)    # 警告消息框
showerror(title=‘标题’,message=‘内容’)      # 错误消息消息框
askquestion (title=‘标题’,message=‘内容’)   #是否疑问消息框，“是” 返回字符串'yes'， “否” ，'no'
askyesnocancel(title=‘标题’,message=‘内容’)     # “是否”疑问消息框:返回True， False
askokcancel(title=‘标题’,message=‘内容’)        # “确定”“取消”疑问消息框:返回True， False
askretrycancel(title=‘标题’,message=‘内容’)     #重试取消疑问消息框:返回True， False

8.1.2 创建Windows窗口

#1．导入Tkinter模块
from tkinter import *
#2．创建窗口对象
win = Tk();
#3．显示Windows窗口
win.mainloop();
#4．设置窗口标题
win.title(titlestr)
#5．设置窗口大小
win.geometry(“宽度x高度”)
#或者
win.minsize(minWidth, minHeight)

8.1.3 Label组件

# 1．创建和显示Label对象
LabelObject = Label(Tkinter WindowsObject,text =“display text”)
LabelObject.pack()
# 2.使用Label组件显示图片
# hourglass-沙漏图标
# info-信息图标
# questhead-信息图标
# question-疑问图标
# warning-警告图标
# gray12/25/50/75-灰度背景图标
#显示自定义图片
# bm = PhotoImage(file = 'C:\Python34\Lib\idlelib\Icons\idle_48.png')
# label = Label(win,image = bm)
# label.pack()#显示Label组件
l1 = Label(win,bitmap = 'error')# 显示错误图标
3．设置Label组件的颜色
label = Label(win, fg = 'red',bg = 'blue', text='字符串')

其他常用的Lable组件属性

8.1.4 Button组件

1．创建和显示Button对象
ButtonObject= Button (Tkinter WindowsObject,text =“  ”, command=func1)
ButtonObject.pack()
2．使用Button组件显示图片
bm = PhotoImage(file =”C:\pic.jpg”)
b = Button (win,text = '  ', command=func,image = bm)
3．设置Button组件的大小
b = Button (win,text = '点我啊', command=CallBack, width=100, height=50) 

常用的Button组件属性

8.1.5 Canvas画布组件

# 1.创建和显示Canvas对象
CanvasObject= Canvas (WindowObject,width, height, …)
CanvasObject.pack()

Canvas对象时的常用选项

# 2．绘制线条
line = canvas.create_line(x0, y0, x1, y1, ..., xn, yn, 选项)

创建矩形对象时的常用选项