Python 操作 excel


使用 xlwt 库
写入 excel

import xlwt

wb = xlwt.Workbook()
sh = wb.add_sheet('A Test Sheet')

sh.write(0, 0, 1234.56)
sh.write(1, 0, 8888)
sh.write(2, 0, 'hello')
sh.write(2, 1, 'world')

wb.save('example.xls')

读取 excel

import xlrd

# 打开 xls 文件
book = xlrd.open_workbook("test.xls")
print "表单数量", book.nsheets
print "表单名称", book.sheet_names()
# 获取第1个表单
sh = book.sheet_by_index(0)
print u"表单 %s 共 %d 行 %d 列" % (sh.name, sh.nrows, sh.ncols)
print "第二行 第三列", sh.cell_value(1, 2)
# 遍历所有表单
for s in book.sheets():
    for r in range(s.nrows):
        # 输出指定行
        print s.row(r)
阅读全文

Python 循环引用报错


文件名 json.py
代码很简单

import json

data = {'a':"A",'b':"b",'c':3}
print data
print type(data)

代码被执行了两次

{'a': 'A', 'c': 3, 'b': 'b'}
<type 'dict'>
{'a': 'A', 'c': 3, 'b': 'b'}
<type 'dict'>

当 import json 的时候

Traceback (most recent call last):
  File "json.py", line 3, in <module>
    import json
  File "/data/code/Python/Test/json.py", line 9, in <module>
    data_string = json.dumps(data)
AttributeError: 'module' object has no attribute 'dumps'

这证明文件被循环引用了,自己写的 json.py 文件被解析成了系统的 json 包。
把文件重命名成 json1.py,执行成功。

{'a': 'A', 'c': 3, 'b': 'b'}
<type 'dict'>
阅读全文

Python 解析 json


序列化:将对象的状态信息转换为可以存储或可以通过网络传输的过程,传输的格式可以是 JSON、XML 等。
反序列化:从存储区域(JSON,XML)读取反序列化对象的状态,重新创建该对象。

Python2.6 开始加入了 JSON 模块,无需另外下载,Python 的 JSON 模块序列化与反序列化的过程分别是 encoding 和 decoding。

encoding:把一个 Python 对象编码转换成 Json 字符串
decoding:把 Json 格式字符串解码转换成 Python 对象

对于简单数据类型(string、unicode、int、float、list、tuple、dict),可以直接处理。
代码很简单

# -*- coding: utf-8 -*-

import json

data = {'a':"A",'b':"b",'c':3}
print data

data_string = json.dumps(data)
print data_string

decoded = json.loads(data_string)
print decoded

执行结果

{'a': 'A', 'c': 3, 'b': 'b'}
{"a": "A", "c": 3, "b": "b"}
{u'a': u'A', u'c': 3, u'b': u'b'}
阅读全文

Python 中的 package 实现


目录结构

demo.py
MyPackage
---classOne.py
---classTwo.py
---__init__.py

1.__init__.py 空白文件方式
demo.py 内容

from MyPackage.classOne import classOne
from MyPackage.classTwo import classTwo
if __name__ == "__main__":
    c1 = classOne()
    c1.printInfo()
    c2 = classTwo()
    c2.printInfo()

classOne.py 内容

class classOne:
    def __init__(self):
        self.name = "class one"
    def printInfo(self):
        print "i am class One!"

classTwo.py 内容

class classTwo:
    def __init__(self):
        self.name = "class two"
    def printInfo(self):
        print "i am class two!"

阅读全文

Python 类中 __new__ 和 __init__ 方法区别


init 方法为初始化方法, new 方法才是真正的构造函数。

1.__new__ 方法默认返回实例对象供 init 方法、实例方法使用。

class Foo(object):
    price = 50
    def how_much_of_book(self, n):
        return self.price * n
foo = Foo()

分析上面的代码,这个类实例化过程,Foo 类继承 object 类,继承了 object 的 new 方法。
当你没有重载这个方法,Foo 实例化是默认自动调用父类 new 方法,这个方法返回值为类的实例 (self),提供这个函数
how_much_of_book,默认的第一个参数 self。

class Foo(object):
    price = 50
    def __new__(cls, *agrs, **kwds):
        inst = object.__new__(cls, *agrs, **kwds)
        return inst
    def how_much_of_book(self, n):
        return self.price * n
foo = Foo()

Foo 类中重载了 new 方法,它的返回值为 Foo 类的实例对象。



阅读全文

Python 字符串 Intern 机制


s3 = "hello!"
s4 = "hello!"
s3 is s4
False
id(s3)
80325968L
id(s4)
80326048L

s3 和 s4 虽然值是一样的,但确确实实是两个不同的字符串对象,Python 会为它们俩各自分配一段内存空间,假设程序中存在大量值相同的字符串,系统就不得不为每个字符串重复地分配内存空间,显然对系统来说是一种无谓的资源浪费。为了解决这种问题,Python 引入了 intern 机制。

s3 = intern('hello!')
s4 = intern('hello!')
s3 is s4
True
id(s3)
80325968L
id(s4)
80325968L

intern 是 Python 中的一个内建函数,该函数的作用就是对字符串进行 intern 机制处理,处理后返回字符串对象。我们发现但凡是值相同的字符串经过 intern 机制处理之后,返回的都是同一个字符串对象,这种方式在处理大数据的时候无疑能节省更多的内存空间,系统无需为相同的字符串重复分配内存,对于值相同的字符串共用一个对象即可。
在主流面向对象的编程语言中intern 机制对于处理字符串已经成为一种标配,通过 intern 机制可以提高字符串的处理效率,当然,解释器内部很对 intern 机制的使用策略是有考究的,有些场景会自动使用 intern,有些地方需要通过手动方式才能启动。

s1 = "hello"
s2 = "hello"
s1 is s2
True
id(s1)
72320704L
id(s2)
72320704L
阅读全文

Python 判断文件、文件夹是否存在


判断文件是否存在

import os  
os.path.isfile('./file.txt')
# True
os.path.isfile('./fake.txt')
# False

判断文件夹是否存在

import os  
os.path.isdir('./dir')
# True
os.path.isdir('./foo')
# False

判断文件或文件夹是否存在

import os  
os.path.exists('./file.txt')
# True
os.path.exists('./fake.txt')
# False
os.path.exists('./dir')
# True
os.path.exists('./foo')
# False
阅读全文

一道关于 Python 字符类型面试题


a = u'China'
b = 'China'
c = u'中国'
d = '中国'
# 1
print '%s %s' % (a, b)
# 2
print '%s' % c
# 3
print '%s' % d
# 4
print '%s %s' % (c, d)

先说正确答案,只有最后一行会报错。

Python2,默认的字符类型是 str,这个 str 和 Python3 的 str 完全不同,Python2 的 str 类型是 8 位的 ascii 序列。
Python2 在处理 str 类型转换时遵循这样的规则:如果被处理的 str 型变量值小于 7 位,就可以和 unicode 类型混用。可以做 + 连接,格式化等操作,同 unicode 享受同样的待遇。Python2 在格式化字符时,会把 str 格式化为 str,如果字符串里混入了 unicode,就会把其他字符都转化为 unicode。
所以这道题里 1 处的 a,b 两个值混合后的字符就是一个 unicode 字符串,c 和 d 单独格式化后仍保留了自己的格式。但是 Python2 在格式化代码位置 4 时,发现 c 是 unicode 而 d 不是,就会尝试按照上面的混用规则,格式化 d 为 unicode 类型,但是 d 的值'中国'显然是一个大于 7 位的 str,因此 Python2 抛出 UnicodeDecodeError。
Python3 里,str 类型则变成了一个纯 unicode 字符,也就是说 Python3 里的 str 等价于 Python2 里的 unicode 类型。Python3 里为了清晰明了,使用 bytes 代表 8 位 ascii 序列。除此之外,Python3 严格禁止混用两种类型。
使用 Python2 处理字符串,尤其是中文字符串,最好前边加上 u。Python2 里不要混用 str 和 unicode,如果处理文本时,先将全部数据格式化成 unicode。

阅读全文