Python学习笔记

文章还没有更新完，主要是对Python知识点做一些梳理。

一、数据类型

基本数据类型：int、float、bool(int的子类)、complex
组合数据类型：str、tuple、list、dict、set
不可变数据类型：int、float、complex、bytes、str、tuple

二、字符串函数

常用函数

len(s) 求字符串长度
s.count(sub) 求子串sub出现的次数，重叠部分不会重复计算，例如"AAA"中子串"AA"只出现一次
s.upper()、s.lower() 返回一个新的字符串（不改变原来的字符串），是原来字符串的大/小写
s.find(sub) 从头查找子串sub并返回子串下标，查找失败则返回-1
s.find(sub, index) 从下标index处查找子串sub并返回子串下标，查找失败则返回-1
s.index(sub) 功能同find，不同之处是查找失败会引发异常
s.rfind(sub) 从尾查找子串sub并返回子串下标，查找失败则返回-1
s.rindex(sub) 功能同rfind，不同之处是查找失败会引发异常
s.replace(old, new) 返回一个新的字符串（不改变原来的字符串），将原来字符串中所有的子串old替换成new
s.isdigit()、s.isupper()、s.islower() 判断字符串是否是数、是否全是大/小写
s.startswith(sub)、s.endswith(sub) 判断字符串是否以某个子串开头/结尾
s.strip() 返回一个新的字符串（不改变原来的字符串），去除字符串头尾的空白字符(空格、’\r’、’\t’、’\n’)
s.lstrip() 返回一个新的字符串（不改变原来的字符串），去除字符串头部的空白字符(空格、’\r’、’\t’、’\n’)
s.rstrip() 返回一个新的字符串（不改变原来的字符串），去除字符串尾部的空白字符(空格、’\r’、’\t’、’\n’)
s.strip(x)、s.lstrip(x)、s.rstrip(x) 同上，但去除的是x中出现的字符

字符串格式化

1.format
{序号：对齐 宽度.精度 类型} 宽度可以是0
^：中对齐
>：右对齐
<：左对齐

x = "Hello {0} {1:>10},you get ${2:0.4f}".format("Mr.", "Jack", 3.2)
print(x) #>>Hello Mr.      Jack,you get $3.2000

2.%

print("Today is %s.%d" % ("May", 21)) #Today is May.21

3.f"{变量名}"

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(f"Hello, {full_name.title()}!") #Hello, Ada Lovelace!

转义字符

Python中提供了\不转义字符串的用法，r表示字符串中的\就是\，示例如下：

print(r"ab\ncd") #>>ab\ncd

三、元组

元组是Python中一种不可变的数据类型。元组是由逗号标识的，圆括号的作用只是让其看起来更整洁、更清晰。定义一个只有一个元素的元组时，需以逗号结尾：

tup = ("123",)

元组的运算

以下运算建立了新的元组，并没有改变元组的值。
1.元组的连接

tup = (10, 20)
tup += (30, 40)
print(tup) #>>(10, 20, 30, 40)

2.元组的乘法

tup = (10, 20)
tup = tup * 3
print(tup) #>>(10, 20, 10, 20, 10 ,20)

3.比较大小
两个元组逐个比较大小，直到分出胜负。若有两个对应元素不可比大小，则抛出runtime error。

元组生成式

结构大体为tuple(求值表达式 取值范围)，示例如下：

print(tuple(x*x for x in range(1, 11)))	#>>(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

四、列表

列表里放的是指针。

列表的+=、+和append的区别

对列表来说，a += b 和 a = a + b是不同的。
a += b是直接将列表b中的元素添加到列表a的末尾；
a = a + b将列表b元素添加到列表a末尾，会得到一个新的列表，不会影响到原先的列表。
append的作用是添加单个元素至列表的末尾，与+=不同。

b = a = [1, 2]
a += [3]
print(a, b) #>>[1, 2, 3] [1, 2, 3]
a = a + [4, 5]
print(a) #>>[1, 2, 3, 4, 5]
print(b) #>>[1, 2, 3]
a.append([4, 5])
print(a) #>>[1, 2, 3, 4, 5, [4, 5]]

列表的乘法

类似于元组的乘法，这里不赘述。

列表的排序

Python自带的排序函数sort和sorted的时间复杂度O(nlog(n))。list.sort(key = myKey)，sort函数按照每个元素调用函数myKey的返回值从小到大进行排序，示例如下：

def myKey(x):
	return x % 10
mylist = [25, 7, 16, 33, 4, 1, 2]
mylist.sort(key = myKey)
print(mylist) #>>[1, 2, 33, 4, 25, 16, 7]

常用函数

append(x) 添加x到列表尾部
extend(x) 添加列表x中的元素到列表尾部
insert(index, x) 将元素x插入到列表下标index处
remove(x) 从列表中删除元素x
reverse() 颠倒整个列表
index(x) 查找元素x，返回第一次出现的下标，找不到则抛出异常
copy() 浅拷贝

列表映射map

map(function，sequence)，可用于将一个序列（列表、元组、集合等）映射到另一个序列。返回值为一个延迟求值的对象， 可以转化为list、tuple、set等。示例如下：

def f(x):
    print(x, end="")
    return x*x
a = map(f, [1, 2, 3])	#没有输出，因为实际上没有执行函数f
print("list(a):", end="")	
print(list(a))	#>>list(a):123[1, 4, 9]
print(tuple(a))	#>>()
a = list(map(lambda x : 2*x, [2, 3, 4]))
print(a)	#>>[4, 6, 8]

列表过滤filter

filter(function，sequence)，抽取序列中令function(x)为True的元素。返回值为一个延迟求值的对象， 可以转化为list、tuple、set等。示例如下：

def f(x):
    return x % 2 == 0
lst = tuple(filter(f, [1, 2, 3, 4, 5]))
print(lst)	#>>(2, 4)

列表生成式

结构大体为[求值表达式 取值范围]，用法可以有很多，这里只举两个例子：

print([[m + n for m in 'ABC'] for n in 'XYZ'])	#>>[['AX', 'BX', 'CX'], ['AY', 'BY', 'CY'], ['AZ', 'BZ', 'CZ']]
L = ['Hello', 'World', 18]
print([s.lower() for s in L if isinstance(s, str)])	#>>['hello', 'world']

列表的深拷贝

由于列表中存储的是指针，所以list[ : ]进行的是浅拷贝，对于列表中的可变数据类型，改变其值仍会影响原来的列表。Python提供了copy.deepcopy来实现列表的深拷贝，示例如下：

import copy
a = [1, [2]]
b = copy.deepcopy(a)
b.append(4)
print(b) #>>[1, [2], 4]
a[1].append(3)
print(a)	#>>[1, [2, 3]]
print(b)	#>>[1, [2], 4]

元组和列表互转

用list和tuple实现互转，示例如下：

a = [1, 2, 3]
b = tuple(a)
c = list(b)
t = (1, 2, 3)
(a, b, c) = t	#a=1, b=2, c=3
s = [1, 2, 3]
[a, b, c] = s	#a=1, b=2, c=3

元组、列表和字符串互转

print(list("hello"))	#>>['h', 'e', 'l', 'l', 'o']
print("".join(['H', 'i', '!']))	#>>Hi!
print(tuple("hello"))	#>>('h', 'e', 'l', 'l', 'o')
print("".join(('H', 'i', '!')))	#>>Hi!

五、字典

Python3.5及以前字典的键值对是无序的，Python3.6及以后字典的键值对是有序的（加入字典的顺序）。字典的键必须是不可变的数据类型且内容不相同，若内容相同，则字典会自动去除重复的部分，只留下一个。从运行结果来看，留下的是最后一个示例如下：

a = (1, 2, 3)
b = (1, 2, 3)
d = {(1, 2, 3) : 50, a : 60, b : 70, (1, 2, 3) : 80}
print(d[a])	#>>80
print(d[b])	#>>80
print(d[(1, 2, 3)])	#>>80

字典的构造

通过dict函数构造，示例如下：

items = [('name', 'Gumby'), ('age', 21)]
print(dict(items))	#>>{'name': 'Gumby', 'age': 21}
print(dict(name='Gumby', 'age'=21))	#>>{'name': 'Gumby', 'age': 21}

常用函数

clear() 清空字典
keys() 取字典的键的序列（非list、tuple和set）
items() 取字典的键值对的序列
values() 取字典的值的序列
pop(x) 删除键为x的键值对，若x不在字典中，则抛出异常
copy() 浅拷贝
基于items的两种遍历方式，示例如下：

d = {(1, 2, 3), 80}
for k, v in d.items():
    print(k)	#>>(1, 2, 3)
    print(v)	#>>80
for i in d.items():#元组
    print(i[0])	#>>(1, 2, 3)
    print(i[1])	##>>80

补充：python的内置函数dir() 不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

六、集合

集合中的元素必须是不可变的数据类型。集合中的元素没有顺序，不支持通过下标访问。

集合的构造

空集合输出set()。字典转化为集合时，只取字典的键。

print(set([]))	#>>set()
print(set({1 : 2, 'ok' : 3, (3, 4) : 4}))	#>>{1, 'ok', (3, 4)}

常用函数

add(x) 添加元素x，若存在，则不添加
clear() 清空集合
copy() 浅拷贝
remove(x) 删除元素x，若x不存在，则抛出异常
update(x) 将序列x中的元素加入到集合中

集合的运算

x in a、a | b、a & b、a - b、a ^ b。
a <= b a是b的子集；a < b a是b的真子集。

七、文件

常用函数

open(filepath, pattern，encoding=“encoded”) 返回一个表示文件的对象。第一个参数是路径名，表示目录结构时用斜杠(/)，使用反斜杠进行转义(\)。第二个参数是模式参数：读取模式(‘r’)、写入模式(‘w’)、附加模式(‘a’)和读写模式(‘r+’)，缺省为只读模式。若以写入模式打开文件，文件不存在，则会创建一个新的文件，前提是文件的上一级目录存在；若文件存在，则会清空该文件内容后再返回。第三个参数指定文件的编码，encoded为编码的名字，缺省为系统编码。
f.write(string) 向文件写入内容，string只能是字符串。
f.read() 返回一个字符串，包括文件的全部内容。
f.readlines() 返回一个列表，列表的元素为字符串，内容为文件的一行，包括换行符。
f.readline() 返回一个字符串，内容为文件的一行，包括换行符。空行也有一个字符’\n’。
f.close() 关闭文件。

文件读取

关键词with在不再需要访问文件后将其关闭，不需要程序员调用close，但文件对象的作用域仅限于with中。可对文件对象使用for循环来依次访问每一行，示例如下：

with open("1.txt") as f:
	for line in f:
		print(line, end="")

亦可以调用readlines来进行读取，使代码的可读性更强，示例如下：

with open("1.txt") as f:
	lines = f.readlines()
	for line in lines:
	print(line, end="")

也可以调用readline来进行读取，示例如下：

with open("1.txt") as f:
	while True:
		line = f.readline()
		if line == ""
			break
		print(line, end="")

当前路径

程序可以通过调用os.getcwd()来获得当前文件夹的路径，即.py所在的文件夹（但以命令行方式运行程序时，打印的是cmd的当前文件夹），还可以调用os.chdir(dir)来改变当前文件夹，示例如下：

import os
print(os.getcwd())	#>>当前文件夹的绝对路径
os.chdir("c:/tmp")
print(os.getcwd())	#>>c:/tmp

os库和shutil库中的文件夹操作函数

os.getcwd() 求程序的当前文件夹
os.chdir(dir) 将当前文件夹设置为dir
os.listdir(dir) 返回一个列表，列表里是文件夹dir中的所有文件和文件夹的名字（不是路径）
os.mkdir(dir) 创建文件夹dir
os.path.getsize(file) 获得文件file的大小，单位是字节
os.path.isfile(file) 判断file是不是文件夹
os.remove(file) 删除文件file
os.rmdir(dir) 删除文件夹dir，dir必须是空文件夹
os.rename(x, y) 将文件或文件夹x改名为y。该函数还可以起到移动文件或文件夹的作用。例如，os.rename(“c:/tmp/a”, “c:/tmp2/b”)可以将文件或文件夹"c:/tmp/a"移动到 文件夹"c:/tmp2/"下，前提是tmp2必须存在
shutil.copyfile(x, y) 拷贝文件x到文件y，若y已存在，会发生覆盖

##命令行参数
可以在命令行中输入python 文件名 参数来运行程序。Python提供了sys.argv来获得程序的命令行参数，示例如下：

import sys
for x in sys.argv:
	print(x)

使用json存储数据

Python提供了json（JavaScript Object Notation）包让程序员能够将简单的Python数据结构转储到文件中。JSON数据格式其他编程语言亦可以使用。json.dump()函数将数据存储到文件中，它接收两个参数：第一个参数是要存储的数据，第二个参数是要存储到的文件对象。json.load()函数将数据从文件加载到内存中，接收一个文件对象的参数。示例如下：

import json
numbers = [2, 3, 5]
filename = 'numbers.json'
with open(filename, 'w') as f:
	json.dump(numbers, f)
with open(filename, 'w') as f:
	numbers = json.load(f)
print(numbers)	#>>[2, 3, 5]

八、异常

若except中不对异常做任何处理，可以使用pass语句来明确的告诉Python，pass还充当了占位符的作用，以后要处理可以进行修改。else代码块中应该放入依赖try代码块执行成功的代码。

try:
	#代码块
except ZeroDivisionError: #捕获的异常
	#代码块/pass语句
else：
	#代码块

九、测试

断言方法

Python提供了模块unittest来实现对代码的测试，该模块提供了以下几种常用的断言方法：
assertEqual(a, b)
assertNotEqual(a, b)
assertTrue(x)
assertFalse(x)
assertIn(item, list)
assertNotIn(item, list)

测试类

要测试的类如下：

class AnonymousSurvey:
	"""收集匿名调查问卷的答案"""

	def _init_(self, question):
		"""存储一个问题，并为存储答案做准备"""
		self.question = question
		self.responses = []
	
	def store_response(self, new_response):
		"""存储单份调查答卷"""
		self.responses.append(new_response)
	#略去其他方法

编写对应的测试类需要继承unittest.TestCase类。程序员可以编写setUp方法，该方法会在每个测试方法被调用前调用，因此可以在该方法中实现测试前的初始化。每个测试方法必须以test_开头，否则不会被自动运行。
第24、25行的if代码块检查特殊变量_name_，这个变量在程序执行时设置，若该文件作为主程序执行，则该变量被设置为’main’，在这里，调用unittest.main()来运行测试用例。每完成一个单元测试，Python都打印一个字符：通过–句点；错误–E；断言失败–F。示例如下：

import unittest
from survey import AnonymousSurvey

class TestAnonymousSurvey(unittest.TestCase):
	"""测试AnonymousSurvey类"""
	
	def setUp(self):
		"""创建一个调查对象和一组答案，供使用的测试方法使用"""
		self.my_survey = AnonymousSurvey(question)
		self.responses = ['English', 'Spanish', 'Mandarin']
		
	def test_store_single_response(self):
		"""测试单个答案会被妥善地存储"""
		self.my_survey.store_response(self.responses[0])
		self.assertIn(self.responses[0], self.my_survey.responses)
	
	def test_store_three_responses(self):
		"""测试三个答案会被妥善地存储"""
		for response in self.responses:
			self.my_survey.store_response(response)
		for response in self.responses:
			self.assertIn(response, self.my_survey.responses)
			
if _name_ == '_main_':
	unittest.main()

十、正则表达式

regex包re

match

re.match(pattern, string, flags=0) 从字符串string的起始位置匹配一个模式pattern，若成功，则返回一个匹配对象，否则返回None。flags为标志位，用于控制模式串的匹配方式，如：是否区分大小写，多行匹配等等，例如(re.M | re.I)表示忽略大小写且多行匹配。

search

re.search(pattern, string, flags=0) 功能同re.match，不同之处是对匹配的位置没有要求，从左到右返回第一个匹配成功的匹配对象。

findall

re.findall(pattern, string, flags=0) 在正则表达式中没有分组时，查找字符串中所有和模式匹配的子串(不重叠)放入列表；在正则表达式中有且仅有一个分组时，每个元素是一个匹配子串中分组对应的内容；在正则表达式中有超过一个分组时，每个元素是一个元组，每个元组对应于一个匹配的子串，元组里的元素，依次是1号分组、2号分组、3号分组…匹配的内容(若分组没匹配到任何东西(受到’|‘的影响)，则显示空串’’)。没有匹配的子串则返回空表[]。

finditer

re.finditer(pattern, string, flags=0) 查找字符串中所有和模式匹配的子串(不重叠)，每个子串对应于一个匹配对象，返回匹配对象的序列(可调用迭代器)。

sub

re.sub(pattern, substring, string) 把母串string中匹配的子串替换为substring。

split

分隔串用|隔开，两个相邻的分隔串之间会隔出一个空串’’，示例如下：

import re
a = 'Beautiful, is; better*than\nugly'
print(re.split(';| |,|\*|\n', a))
#>>['Beautiful', '', 'is', '', better, 'than', 'ugly']

匹配对象

属性

string：匹配时使用的母串
lastindex：最后一个被匹配的分组的编号(不一定是最大的分组编号，有可能存在嵌套的情况)。如果没有被匹配的分组，则为None

函数

r.group([n1, n2, …]) 返回一个由元组，元组的元素依次是第n1、n2、…分组匹配到的子串。 没有匹配的子串则返回None。
r.group() 等价于r.group(0)，返回整个匹配到的子串。
r.group(i) 返回第i个分组匹配到的子串。
r.groups([default]) 返回一个元组，每个元素为每个分组所匹配到的子串，若分组没匹配到任何东西(受到’|'的影响)，则以default替代，缺省为None。
r.groupdict([default]) 返回以有名字的组的名字为键、以该组匹配的子串为值的字典，default用法同上。
r.start([group]) 返回指定的组匹配的子串在string中的起始位置，group缺省为0。
r.end([group]) 返回指定的组匹配的子串在string中的结束位置(闭区间)，group缺省为0。
r.span() 返回匹配到的子的起止位置(start, end)，end是闭区间。

边界符号

\A 表示字符串的左边界
\Z 表示字符串的右边界
^ 同\A，但还可以用于多行匹配模式
$ 同\Z，但还可以用于多行匹配模式
\b 表示此处是单词的左边界或右边界
\B 表示此处不允许是单词的左边界或右边界，即不可是单词字符
注：python中’\b’是一个字符表示删除(BACKSPACE)，因此正则表达式在使用边界符号’\b’时，要写成’\b’。

分组

括号中的表达式是一个分组。多个分组按左括号从左到右从1开始编号。
在分组的右边可以通过分组的编号引用该分组所匹配的子串，示例如下：

import re
m = r"(((ab*)c)d)e \ 3"	#\数字 是转义字符
r = re.match(m, "abbbcdeabbbkfg")	#后面的三个b少一个都不能成功匹配
print(r.group(3))	#>>abbb
print(r.group())	#>>abbbcdeabbb 

分组后跟量词，并不要求每次出现的内容都相同。例如(ab*)*，并不要求每次b的个数都相同。

'|'的用法

‘|‘表示或，起作用的范围是直到整个正则表达式的开头或结尾或另一个’|’，若用于分组中，则起作用的范围仅限于分组内。’|'具有从左到右短路匹配的特点。

匹配方式

量词的贪婪模式

量词+，*，？，{m，n}，默认匹配尽可能长的子串。

量词的懒惰模式

量词+，*，？，{m，n}后面加？，则匹配尽可能短的子串。

十一、Python的生态

datatime库

datatime能处理的时间是公元1年至9999年。
1.处理日期

import datetime #导入datetime模块
dtBirth = datetime.date(2000,9,27) #创建日期对象，日期为2000年9月27日
print(dtBirth.weekday()) #>>2 输出dtBirth代表的日期是星期几。0表示星期一
dtNow = datetime.date.today() #取今天日期,假设是 2020年8月15日
print(dtBirth < dtNow) #>>True 日期可以比大小
life = dtNow - dtBirth #取两个日期的时间差
print(life.days, life.total_seconds()) #>>7262 627436800.0
#两个日期相差7262天，即627436800.0秒
delta = datetime.timedelta(days = -10) #构造时间差对象，时间差为-10天
newDate = dtNow + delta #newDate代表的日期是dtNow的日期往前数10天
print(newDate.year, newDate.month, newDate.day, newDate.weekday()) 
#>>2020 8 5 2 2020年8月5日星期三
print(newDate.strftime(r'%m/%d/%Y')) #>>08/05/2020
newDate = datetime.datetime.strptime("2020.08.05", "%Y.%m.%d")
print(newDate.strftime("%Y%m%d")) #>>20200805

2.处理时刻

import datetime 
tm = datetime.datetime.now() #取当前时刻，精确到微秒
print(tm.year,tm.month,tm.day,tm.hour,tm.minute,tm.second,
tm.microsecond)
#>>2020 8 15 20 32 53 899669 假设当前时刻是2020年8月15日20时32分53秒899669微秒
tm = datetime.datetime(2017, 8, 10, 15, 56, 10,0)
#构造一个时刻，2017年8月10日15时56分10秒0微秒
print(tm.strftime("%Y%m%d %H:%M:%S")) #>>20170810 15:56:10
print(tm.strftime("%Y%m%d %I:%M:%S %p")) #>>20170810 03:56:10 PM
tm2 = datetime.datetime.strptime("2013.08.10 22:31:24", 
"%Y.%m.%d %H:%M:%S") #由字符串生成一个时间对象
delta = tm - tm2 #求两个时间的时间差
print(delta.days,delta.seconds,delta.total_seconds())
#>>1460 62686 126206686.0 #时间差是1460天零62686秒，总共126206686.0秒
delta = tm2 - tm
print(delta.days,delta.seconds,delta.total_seconds())
#>>-1461 23714 -126206686.0
delta = datetime.timedelta( days = 10, hours= 10,minutes=30,seconds=20)
#构造一个时间差，10天10小时30分20秒
tm2 = tm + delta
print(tm2.strftime("%Y%m%d %H:%M:%S")) #>>20170821 02:26:30

random库

random.random() 随机生成一个[0,1]之间的数
random.uniform(x,y) 随机生成一个[x,y]之间的数（含两端，下同）。x,y可以是小数
random.randint(x,y) 随机生成一个[x,y]之间的整数。x,y都是整数
random.randrange(x,y,z) 在range(x,y,z)中随机取一个数，z为步长且y不算在内
random.choice(x) 从序列x中随机取一个元素。x可以是为列表、元组、字符串
random.shuffle(x) 将列表x的元素顺序随机打乱
random.sample(x,n) 从序列x中随机取一个长度为n的子序列。x可以是元组、列表或集合
random.seed(x) 设置随机种子为x。x可以是数、元组或字符串

jieba库

解决分词问题。

import jieba #导入分词库
s = "我们热爱中华人民共和国"
lst = jieba.lcut(s) #分词的结果是一个列表
#默认用精确模式分词，分出的结果正好拼成原文
print(lst) #>>['我们', '热爱', '中华人民共和国']
print(jieba.lcut(s,cut_all = True)) #全模式分词，输出所有可能的词
#>>['我们', '热爱', '中华', '中华人民', '中华人民共和国', '华人', '人民', '人民共和国', '共和', '共和国']
print(jieba.lcut_for_search(s)) #搜索引擎模式分词
#>>['我们', '热爱', '中华', '华人', '人民', '共和', '共和国', '中华人民共和国']
s = "拼多多是个网站"
print(jieba.lcut(s)) #>>['拼', '多多', '是', '个', '网站']
jieba.add_word("拼多多") #往jieba的词典添加新词
print(jieba.lcut(s)) #>>['拼多多', '是', '个', '网站']
s = "高克丝马微中"
print(jieba.lcut(s)) #>>['高克丝', '马微', '中']
jieba.load_userdict("c:/tmp/tmpdict.txt")	#高克 丝马 微中
print(jieba.lcut(s)) #>>['高克', '丝马', '微中']
print(jieba.lcut("显微中，容不得一丝马虎。")) #优先选择常见的词
#>>['显微', '中', '容不得', '一丝', '马虎', '。']

openpyxl库

用于处理excel文档(office 2010之后.xlsx文件)。

import openpyxl as pxl
book = pxl.load_workbook("c:/tmp/test.xlsx") #book就是整个excel文件
sheet = book.worksheets[0] #取第0张工作表，和以下代码等价：
#sheet = book.active #取活跃的工作表（缺省就是第0张工作表)
#sheet = book["price"] #取名为" price "的工作表
print(sheet.title) #输出工作表名字(显示于工作表下方标签)
print(sheet.min_row, sheet.max_row) #输出最小有效行号、最大有效行号
print(sheet.min_column, sheet.max_column) #输出最小有效列号、最大有效列号
for row in sheet.rows: #按行遍历整个工作表，从第1行到sheet.max_row行（含）
for cell in row: #遍历一行的每个单元格。cell是一个单元格
print(cell.value) #cell.value是单元格的值，空单元格值是None
for cell in sheet['G']: #遍历名为'G'的那一列
print(cell.value)
for cell in sheet[3]: #遍历第3行
print(cell.value, type(cell.value),cell.coordinate,
cell.col_idx,cell.number_format) 

#单元格属性
#type(cell.value) : int, float ,str, datetime.datetime
#cell.coordinate : 'A2', 'E3'
#cell.col_idx : 单元格列号
#cell.number_format : 数的显示格式，"General", "0.00%", "0.00E+00"等

for sheet in book.worksheets: #worksheets是工作表构成的列表
print(sheet.title)	#遍历所有工作表，并打印其名字

sheet['E2'].value = 12.5 #单元格值为小数
sheet["E2"].number_format = "0.00%" #单元格显示格式是百分比形式
sheet['F1'].value = 3500 #单元格值类型为int
sheet['F2'].value = "35.00" #单元格值类型为str
sheet['F3'].value = datetime.datetime.today().date()
sheet.column_dimensions['F'].width = len(str(sheet['F3'].value))
sheet.row_dimensions[2].height = 48 #设置第2行高度为48 points
sheet2 = book.create_sheet("Sample2") #添加名为Sample2的工作表
sheet2["A1"] = 50 
sheet2 = book.create_sheet("Sample0",0) #添加名为Sample0的工作表
sheet3 = book.copy_worksheet(sheet) #添加一张新工作表，其为sheet的拷贝
book.remove_sheet(book["Sample2"]) #删除名为Sample2的工作表
book.save('c:/tmp/sample.xlsx') #保存文件

十二、作用域

Python中的作用域只有四种，即LEGB规则：
L， local – 在lambda函数内或者def函数内部的变量
E， Enclosing-function – 闭包的作用域 外部嵌套函数的命名空间
G，Global – 全局作用域 所在模块(文件)的命名空间
B， Build-in – 内建(内置)作用域 Python内置模块的命名空间
只有当变量在Module(模块)、Class(类)、def(函数)中定义的时候，才会有作用域的概念。
在if-elif-else、for-else、while、try-except/try-finally等关键字的语句块中并不会产生作用域。
有以下四条法则，用于判断一个变量是全局的还是局部的：
1.若变量在全局作用域中使用(即所有函数之外)，它就总是全局变量。
2.若在一个函数中，有针对该变量的global语句，它就是全局变量。
3.否则，若该变量用于函数中的赋值语句，它就是局部变量。
4.但是，若该变量没有用在赋值语句中，它就是全局变量。
且在一个函数中，一个变量要么总是全局变量，要么总是局部变量。示例如下：

def spam():
	global eggs #不能同时进行赋值
	eggs = 1 #global
def bacon():
	eggs = 2 #local
def ham():
	print(eggs)	#global
eggs = 42 #global

详细内容链接：Python作用域问题详解

十三、代码风格

变量名只能包含字母、数字和下划线且不能以数字开头。，一般以小写字母开头。
类名采用驼峰命名法–单词首字母大写而不使用下划线。
实例名、模块名和函数名均采用小写格式，并在单词之间加上下划线。
先导入标准库模块，再添加一个空行，然后导入自己编写的模块。
一个空行分隔：类中的方法，代码内容
两个空行分隔：类