一、初始Python

Python语言概述

自从20世纪90年代初Python语言诞生至今，Python已被逐渐广泛应用于系统管理任务的处理和Web编程。
Python的创始人为荷兰人吉多·范罗苏姆 Guido van Rossum 。

Python是从ABC发展起来，主要受到了Modula-3（另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了Unix shell和C的习惯。

Python 已经成为最受欢迎的程序设计语言之一。自从2004年以后，python的使用率呈线性增长。Python 2于2000年10月16日发布，稳定版本是Python 2.7。Python 3于2008年12月3日发布，不完全兼容Python 2。 2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。

由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。

（摘自百度百科）

二、Python语言基础

基本数据类型

1.数值型

1）整数类型简称为整型（int），它是python中常用的一种数据类型。整数有正整数、零和负整数，其含义与数学中的含义相同。python用int数据类型表示整型

2）python语言用浮点型（float）表示数学中的实数（也称为浮点数），它是既有整数部分又有小数部分的数。浮点数用float表示

3）复数是由实数部分和虚数部分构成的数。python将复数型（complex）数值表示为x+yj，其中x是实数部分（实部），y是虚数部分（虚部），j为虚数单位

范例：

x = 10     #整型
y = 3.14    #浮点型
z = 1+2j    #复数型
print(type(x),type(y),type(z))  #用type()函数测试三个变量的数据类型

Out:<class 'int'> <class 'float'> <class 'complex'>

2.逻辑型

1）布尔型（bool）也称逻辑型，是用来表示逻辑值的数据类型。逻辑值在程序中用于条件真假逻辑判断，它只有“真”和“假”两个取值。其中“真”用True表示，“假”用False表示。

2）python中的逻辑型也可是为整型的子类，True和False对应的整型值分别为1和0。因此，python的逻辑型数据支持普通整型的所有计算，例如“False+1”是合法的计算。

3）python中的0或空集（空列表、空元组、空字典等）对应的逻辑值都是False

3.字符串

1）python采用字符串来表示和存储文本（如中英文字符）。字符串是最常用的数据类型，python中的字符串是用成对的引号（’）、（"）、（’’’）界定的一串字符，其中单引号和双引号用于界定单行文本，三引号通常用于界定多行文本。

2）转义字符：转义字符是一些有特殊含义且难以用一般方式表达的字符，如回车符、换行符等。python用反斜杠开头，后面紧跟一个字符来表示某个特定的转义字符

3）多行字符串：使用三引号、或者续行符（\）

4）两种格式化方法：%和format

范例：

>>> x = 3.457; y = 10
>>> 'x=%.2f y=%d'%(x,y)
'x=3.46 y=10'
>>> 'x = {:.2f} y = {}'.format(x,y)
'x = 3.46 y = 10'
>>> 

变量

1.用标识符命名的存储单元称为变量，变量用来存储数据，通过标识符可以获取变量的值，也可以对变量进行赋值

2.格式：变量名 = 表达式值

范例：

>>> a = 10
>>> b = 20
>>> c = 30
>>> a = 10 ; b = 20 ; c = 30
>>> a , b , c = 10 , 20 , 30

运算符与表达式

1.算术运算符：-（求负）、+、-、*、/、

2.关系运算符：==、!=、>、>=、<、<=

3.逻辑运算符：not、and、or

4.赋值运算符：=、+=、-=、*=、/=、//=(地板除法)、%=、**=

5.位运算符：~(取反)、&(与)、|(或)、^(异或)、>>(右移位运算)、<<(左移位运算)

6.成员运算符(测试某个对象是否为某个容器对象中的数据成员的运算符)：in(包含于)、not in(不包含)

7.身份运算符：is(等同)、is not(不等同)

8.数据类型转换：
int(x[,base]):将字符串或其他数值类型的数据转换为整型，其中base为进制
float(x):将字符串或其他数值类型的数据转换为浮点数
str(x):将数值转换为字符串
eval(x):将str转换为表达式并返回表达式的表达结果
ord(ch):返回字符ch对应的ASCII码或unicode码

输入与输出

1.输入函数input()：在程序运行过程从键盘获取数据

1）无论用户输入的是什么数据，函数input()一律将收到的数据视为字符串

2）语法：input() #：字符串，用于提示用户输入的文本内容

2.输出函数print()：显示输出其参数指定的内容

1）语法：print(<expr>[,<expr>,...][,sep=<string>][,end=<string>])

2）expr：输出内容的表达式，可省略

3）sep：多个输出数据之间的分隔符，可省略，默认值是单个空格

4）end：末尾输出内容，可省略，默认值是换行符’\n’

5）print()函数会依次显示输出各个<expr>表达式的结果。print()函数支持一个或多个表达式运算结果的输出，表达式之间要用","分隔。通常情况下print()函数在输出内容后会自动换行。通过设置end参数可以设定print()函数输出后不换行

范例：

a,b,c = 10,20,30
print(a,b,c)
print(a,b,c,sep='**')#设置分隔符
print(a);print(b);print(c)#换行输出
print(a,end = '');print(b,end = '');print(c,end = '')#同行输出

[out]:
10 20 30
10**20**30
10
20
30
102030

内置函数

1.数学运算函数

2.字符串处理函数

常用模块

1.模块导入

1）编程时如果要用到Python内置模块，那么就要使用import语句将该模块导入。

2）常规导入：常规导入就是将整个模块直接导入，被导入模块的所有变量、对象和函数在编程时都可以使用：import 模块名 或 from 模块名 import *

3）使用别名：import 模块名 as 别名

4）部分导入：如果不导入整个模块而只导入模块的某些变量、函数或子模块，有多个时使用逗号(,)隔开，语法：from 模块名 import 变量名/函数名/子模块 as 别名

2.math数学模块

1）math模块提供了4个数学常量和44个函数。要使用math模块，首先需要使用import语句导入模块

2）math模块中的常用常量和函数

3.random模块

4.time模块

1）time模块：time模块只要包含各种提供日期、时间功能的类和函数。该模块既提供了把日期、时间格式化为字符串的功能，又提供了将字符串转换为日期、时间的功能

2）时间戳：时间戳表示从1970年1月1日00:00:00开始到现在按秒计算的总秒数。这种事件表示方式广泛地应用在Unix系统和类Unix系统中

3）时间元组：Python在time模块内提供了一个time.struct_time类，该类代表一个时间对象，主要包含了9个属性：tm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst（夏令时）

4）格式化时间：格式化时间是由字母和数字表示的时间字符串，比如"Sat May 4 15:11:24 2019"，格式化的结构增强了时间字符串的可读性。时间字符串支持的格式符号如下

5）常用方法：

t = time.localtime() #获取当前日期和时间
time.strftime('%Y-%m-%d %H%M:%S',t)  #strftime将时间变量t转换为字符串（格式化时间）
time.strftime('2019-05-01','%Y-%m-%d') #strptime将字符串转换为时间

5.datetime模块

1）datetime模块：datetime模块重新封装了time模块，它以类的方式提供了多种日期和时间的表达方式，提供的类主要有datetime.date,datetime.time,datetime.datetime,datetime.timedelta,datetime.tzinfo

2）datetime.datetime类的常用函数与属性

三、Python容器数据类型

列表

1）列表(list)是Pyhton中的序列类型。由一系列元素(数据项)组成，所有的元素都被包含在一对方括号"[]"中。列表中的元素可以是任何类型的数据，并且不需要所有元素具有相同的类型。

2）列表的特性：列表中的元素类型可以相同，可以不同；每个列表元素都有索引和值两个属性，索引用于表示元素在列表中的位置，值是指元素本身的值

3）索引分为正索引和负索引两种情况，从左到右依次加1，左边第一个元素的索引为0；从右到左依次减1，右边第一个元素的索引为-1

1.创建列表和存取列表元素

[in]:lst = [1,2,"3"] #创建方式1
[in]:lst
[out]:[1, 2, '3']  #创建方式2
[in]:[1,2,"3"]
[out]:[1, 2, '3']
[in]:list("abcde") #字符串中的每个字符成为列表中的一个元素
[out]:['a', 'b', 'c', 'd', 'e']

2.列表基本操作

1）访问列表元素：列表对象[index]

2）列表合并：可以运用运算符"+"将两个列表合并在一起

3）重复：可以运用运算符"*"创建具有重复元素的列表

4）迭代：迭代操作可用于遍历列表中的元素

for x in lst:
	print(x)

5）成员判断：使用"in"操作符判断对象是否属于列表

3.列表常用函数

4.切片

1）列表的切片操作可以获得列表的多个元素。切片操作的基本格式：

列表对象[start:end:step]

范例：

[in]:lst = [1,2,3,4,5]
[in]:lst[1:4] #截取列表lst中从索引1到索引3的元素
[out]:[2, 3, 4]
[in]:lst[1:] #截取列表lst中从索引1到末尾的元素
[out]:[2, 3, 4, 5]
[in]:lst[:4] #截取列表lst中从开始到索引3的元素
[out]:[1, 2, 3, 4]
[in]:lst[1:4:2] #截取列表lst中从索引1到索引3，步长为2的元素
[out]:[2, 4]

5.列表生成方式

1）使用range()函数可以产生一个数值递增且可迭代操作的对象：range(start,end,step)

2）以迭代对象创建列表：

it = range(100)
lst = list(it)

3）列表生成式：Python的列表还可以用其特有的列表生成式语法生成

lst  = list(range(5))
lst2 = [x**2 for x in lst]

元组

元组(tuple)是用一对圆括号"()"定义的序列。元组中的元素值自身组创建后就不能修改。元组中的元素数据类型可以相同，也可以不同

1.创建元组和存取元组元素

1）使用圆括号"()"定义创建一个元组对象，也可以使用函数tuple()创建一个元组对象

2）用列表创建元组： tp = tuple([1,2,3,4])

2.元组和列表的差异

1）元组一旦创建，其中的元素就不可修改。元组也不能增加或删除元素。因为元组结构简单，所以元组占用的内存比列表占用的内存少，如果待处理的数据多用于查询，无需查询无需修改，那么可以考虑用元组存储。另外，由于元组是不可修改的，在函数调用或返回函数值时可考虑传递元组，以避免参数被误修改

2）虽然不可以直接修改元组中的元素，但如果需要改变元组中的元素，那么可以先将元组转换为列表，然后对列表进行修改，再将修改好的列表转换新的元组。列表和元组相互转换的函数时tuple(lst)和list(tp)

3.序列（列表或元组）操作函数

字典

字典(dict)可视为键值对构成的数据容器。搜索字典中的元素时，首先查找键，然后根据找到的键获取对应的值，这是一种高效、快速的查找方法。字典中的键必须是唯一的

1.创建字典和存取键值对

1）创建字典：可以使用标记"{}“创建一个字典对象，也可以使用函数dict()创建一个字典对象。字典中的每个元素都包含键和值两部分内容，创建字典时，键和值用”:“隔开，字典的元素之间用逗号”,"分开。

2）语法：{键1:值1,键2:值2,键3:值3...}或dict{键1=值1,键2=值2,键3=值3...}

3）字典的访问：字典中元素的访问是通过键获取相应的值。访问字典元素的格式：字典对象[key] #key：字典中元素的键

2.字典的常用方法

集合

集合(set)是由0或多个元素构成的无序组合，集合中的元素不允许重复。集合是可变的，即可以添加或删除集合中的元素。集合不支持索引操作

1.创建集合

1）可以使用标记"{}“创建一个集合对象，也可以使用函数set()创建一个集合对象。集合中的元素用逗号”,"分隔。与字典中的每个元素都包含键值对不同，集合中的每个元素只有值，没有键。

2）语法：{元素1,元素2,元素3....}或set(可迭代对象)

3）创建空集合只能用set()而不能用"{}"，因为"{}"创建的是空字典而不是空集合

2.遍历集合

1）通过迭代来遍历集合中的所有元素时，输出的顺序可能和创建时的顺序不一样

3.集合操作函数

可变类型和不可变类型

程序中的数据必须以特定类型存放在内存的某个区域中。根据变量对应的内存区域是否可以修改，Python将数据类型分为不可变数据类型和可变类型。如果变量的值发生改变后对应的内存地址也发生改变，那么这种数据类型称为不可变数据类型。如果变量的值发生改变后对应的内存地址保持不变，那么这种数据类型称为可变数据类型。例如lst2 = lst，此时lst2和lst是共享内存地址的

浅复制和深复制

1）为了解决可变变量赋值时两个对象指向同一内存区域从而产生修改时相互影响的问题，Python提供了浅复制和深复制两种方法

2）浅复制虽然复制完两者的内存地址不相同，但还是同时发生改变的。深复制则不会。

3）浅复制：a = b.copy() 深复制：a = b.deepcopy()

四、程序控制结构

顺序结构

程序的顺序结构是指按语句出现的先后顺序执行的程序结构。程序设计语言并不提供专门的控制流语句来表达顺序控制结构，而用程序语句的自然排列(即从上到下、从左到右)顺序来表达

选择结构

1.二分支选择结构

语法：

if 条件表达式1:
    语句块1
else:
    语句块2

2.单分支选择结构

语法：

if 条件表达式1:
    语句块1

3.多分支选择结构

语法：

if 条件表达式1:
    语句块1
elif 条件表达式2:
    语句块2
elif 条件表达式3:
    语句块3
    ......
else:
    语句块n

4.嵌套的选择结构

语法：

if 条件表达式1:
    语句块1
	if 条件表达式2:
    		语句块2
	else:
    		语句块3
else:
	if 条件表达式4:
    		语句块4
	else:
    		语句块5
    语句块6

循环结构

1.while循环

语法：

while 条件表达式:
	语句块1
[else:
	语句块2]

2.for循环

语法：

for 元素 in 组合数据或迭代对象:
	语句块1
[else:
	语句块2]

3.break语句与continue语句

1）break语句的功能是结束循环，继续执行循环结构后续的语句

2）continue语句的功能是结束本次循环，跳过循环体中还没有执行的剩余语句，接着执行循环条件的判断以确定是否开启下一轮循环

4.else语句

当while循环和for循环正常终止时，即由于循环条件不成立而结束循环时，程序将执行循环的else子句。若由于执行break而结束，或在循环体出现异常而结束，则不执行else子句

异常处理结构

1.异常处理（又称错误处理）通常是防止未知错误产生而采取的处理措施，它提供了处理程序运行时出现的任何意外或异常情况（即超出程序正常执行流程的某些特殊条件）的方法。Python程序在执行过程中出现错误时会引发异常。例如：执行除法操作遇到除数为0时，Python系统就会崩溃。异常处理结构可以对程序中的各种未知错误进行处理，防止程序崩溃。

2.语法：

try:
	语句块1
except Exception:
	语句块2
[else:
	语句块3
finally:
	语句块4]

3.其中else子句和finally子句是可选的。若语句块1中没有错误，则执行语句块3后执行语句块4；若语句块1中有错误，则执行语句块2后执行语句块4

五、函数

函数定义

1）Python程序开发者可以根据实际问题的需要在程序中定义合适的函数，通常称这类函为自定义函数

2）定义语法：

def 函数名([形式参数列表]):
	函数体
	[retrun 值]

函数调用与参数

1.函数调用的一般形式

函数名([实际参数列表])

2.不可变对象和可变对象参数

不可变参数作为函数实参时，会在函数体内改变形参的值，但不会导致实参值发生改变。与之相反，可变对象作为函数实参时，会在函数体内改变形参的值，导致实参的值发生改变

3.默认值参数

在Python定义函数时，可以为形式参数默认值。给形参设置默认值的一般形式：def 函数名(...,形参名 = 默认值)

4.关键字参数

例如函数：

def keyPara(a,b,c)
	print("a={},b={},c={}".format(a,b,c))

调用时：keyPara(c = 3 , a = 1 , b = 2)
输出：a = 1, b = 2, c =2

5.不定长参数

def 函数名(*形参名)
	函数体

6.实参序列解包

实参序列解包是指当前函数具有多个形式参数时，可以使用列表、元组、集合、字典及其其他可迭代对象作为实参，并在实参名称前面加上一个星号(*).如果实参是字典，那么需加两个星号

变量的作用域

变量的作用域是指变量起作用的范围，它由定义变量的位置决定。不同作用域内的变量之间互不影响。根据变量定义的位置，变量分为局部变量和全局变量。局部变量是指在函数内部定义的变量，它只在定义该变量的函数内部起作用，作用范围从定义该变量的位置开始到函数结束。全局变量是指在函数外部定义的变量，其作用范围从定义该变量的位置开始到程序结束。

lambda表达式

lambda表达式常用来定义匿名函数。有时我们需要使用一个函数，但只用这个函数一次。例如：

a.sort(key = lambda x : x*x)

lambda表达式的语法为： lambda 形参列表:表达式

函数递归调用

1）一个函数可以直接或间接地调用该函数本身，这种调用称为递归调用。

2）直接递归调用就是一个函数直接调用该函数自身：

def f():
	...
	f()
	...

3）间接递归调用是一个函数调用另一个函数，该函数又要调用原函数：

def f():
	...
	g()
	...
def g():
	...
	f()
	...

六、文件

文件的基本概念

1）文件是指存储在外部存储器中的一组信息集合。操作系统以文件为单位对外部存储器中的数据进行管理，操作系统用文件名对文件进行标识。

2）按照文件的组织形式，文件分为文本文件和二进制文件两种。文本文件将处理的数据视为一个字符串，把字符串中的每个字符的编码保存到文件中。二进制文件把二进制值存储到文件中。

3）将数据保存到外部存储器中后，程序要使用数据时，需要从外存内的文件中读取。程序从外存中读取数据的方式有非缓冲方式和缓冲方式两种。

4）使用非缓冲方式时，直接把数据从外存读到数据程序的数据区。使用非缓冲方式读取数据的速度往往较慢，使用缓冲区可以提高读取数据的速度。缓冲区是内存中的一段存储区域，存取文件时，系统会自动地为每个文件开辟一个缓冲区。如果要从外存读取数据，那么一次将一批数据读入缓冲区，程序运行需要数据时，直接从缓冲区中读取。

文件基本操作

1.用内置函数open打开文件：f = open(文件名,文件使用模式,编码方式,缓冲区大小) #返回一个文件对象

1）文件名是指要打开的文件的名称，是一个路径

2）文件使用模式是一个字符串，它指定文件的使用模式，默认值为"r"

3）编码方式用来指定文件中字符的编码，默认编码与操作系统有关

4）缓冲区大小是一个整数，它指定缓冲区的大小；0表示没有缓冲区，负数表示使用系统默认的缓冲区大小，默认值为-1.

范例：

f = open(r"d:\test.txt","r",encoding="utf-8") 

2.文件对象的属性和常用方法

3.关闭文件

1）完成对某个文件的操作后，一定要关闭这个文件对象，才能将所做的修改保存到文件中，如f.close()

2）在操作文件和关闭文件之前发生错误而导致程序崩溃时，无法正常关闭文件。使用关键字with可以避免这个问题。关键字with可以自动管理资源，不论什么原因跳出with块，总能保证正确关闭文件。

范例：

with open(文件名,文件使用模式) as fp:

4.读/写文本文件

1）读文件

# 读取其中的前6个字符
with open("./log.txt","rt",encoding='utf-8') as f1:
	a = f1.read(6)
	print(a,end = ' ')

# 按行遍历文件的所有行
with open("./log.txt","rt",encoding='utf-8') as f2:
        b = f2.readlines()
        for line in b:
            print(line,end = ' ')

# open返回的是一个可迭代对象，程序可以改为
with open("./log.txt","rt",encoding='utf-8') as f3:
        for line in f3:
            print(line,end = ' ')

2）写文件

# 随机生成一个长度为100的整数列表，其元素范围为1~100，将该列表以每10个一行（元素之间用空格分隔）写入一个文本文件

from random import randint
a = []
for i in range(100):
    a.append(randint(1,100))
with open("d:\\test.txt","w") as f:
    str = " "
    for  i , v in enumerate(a):
        str = str + "{}".format(v)+" "
        if(i+1)%10 == 0:
            b = f.write(str+"\n")
            str = " "

5.读/写二进制文件

1）序列化与反序列化：把内存中的数据对象写入二进制文件的过程称为序列化。读取二进制文件中的数据并重建原来的数据对象的过程称为反序列化

2）写二进制文件时使用pickle模块的dump()函数，它的一般使用形式：dump(写入对象,文件对象,[,协议])

3）协议是序列化使用的协议；若该项省略，则默认为0；若为负值或HIGHEST_PROTOCOL，则使用最高的协议版本

范例：

import pickle
a = 1234
with open("binary.dat","wb") as f:
	pick(a,f)

4）读二进制文件时使用pickle模块的load()函数，它的一般使用形式：load(文件对象)

范例：

with open("binary.dat","rb") as f:
	a = pickle.load(f)
	print(a)

6.文件定位

1）文件指针时一个用来标示文件当前读/写位置的变量。每当读/写文件时，都从文件的位置开始读/写。读/写完成后。根据读/写的数据量向后移动文件指针

2）文件对象的函数tell()返回文件指针的当前位置，它的一般使用形式：tell()

3）文件对象的函数seek()把文件指针移动到新位置，其一般使用形式：seek(偏移[,起点])

7.读/写docx文件和xlsx文件

1）建立新Word文档：建立新文档需要调用Document对象的save方法，一个Document对象代表一个Word文档，该方法的参数是保存的文件名

范例：

#建立新Word文档
from docx import Document
doc = Document()#创建对象
doc.save("test.docx")#参数名为文件名

2）添加段落和段落文字：添加段落需要调用Document对象的add_paragraph方法，该方法的参数是段落文字，返回值是一个Paragraph对象。调用Paragraph对象的add_run方法为该段落添加文字，该方法的参数是添加的文字。add_run方法的返回值是一个run对象，设置该对象的bold属性可以加粗相应的文字，设置对象的italic属性可以把相应的文字设置为斜体

范例：

from docx import Document
doc = Document()
p = doc.add_paragraph('无格式的部分') #添加一个段落，参数是段落文字
p.add_run('加粗部分').bold = True   #为段落添加文字，并设置粗体
p.add_run('无格式')                #为段落添加无格式字体
p.add_run('斜体部分').italic = True #为段落添加文字，并设置斜体
doc.save(r".\test.docx")        #保存文字

3）读取文档的所有段落：Document对象的paragraphs属性是一个包含文档所有Paragraph对象的列表对象，一个Paragraph对象代表文档的一个段落。对paragraphs属性进行循环遍历可以操作文档的所有段落。Paragraph对象的text属性代表该段落的文字

范例：

from docx import Document
doc = Document("./test.docx") #创建对象，参数为文件名（打开）
for p in doc.paragraphs:        #遍历，paragraphs代表每一个段落
    print(p.text)               #text属性代表段落的文本

4）创建Excel电子表格：建立新表格需要调用Workbook对象的save方法，一个Workbook对象代表一个Excel工作薄，该方法的参数是保存的文件名

范例：

from openpyxl import Workbook
wb = Workbook()#创建Wokbook对象
wb.save("test.xlsx")#保存，参数为文件名

5）创建工作表：创建工作表需要调用Workbook对象的create_sheet方法。该方法的参数是工作表的名称

范例：

from openpyxl import Workbook
wb = Workbook() 
wb.create_sheet("first") #创建工作表，名为first
wb.create_sheet("second") #创建工作表，名为second
wb.save("test.xlsx")

6）修改单元格的数据

范例：

from openpyxl import Workbook
from openpyxl import load_workbook
wb = load_workbook(r".\test.xlsx")#创建对象，返回一个Wolbook对象
ws = wb["first"]        #指定ws为wb中的名为first的表
ws['A1'] = "数学"         #设置ws的A1格值
ws['b1'] = "语文"         #设置ws的B1格值
ws.cell(2,1,90)           #设置第2行第1列的值为90
ws.cell(2,2,91)           #设置第2行第2列的值为91
ws.append([80,81])        #新增一行的值依次为80，81
ws['c2'] = "=sum(A2:B2)"  #为C2格插入公式
ws['c3'] = "=sum(A3:B3)"  #为C3格插入公式
wb.save(r".\test.xlsx")

文件与文件夹操作

1.os模块：os模块是Python标准库，它提供了文件与文件夹的相关操作，常用操作如下：

2.os.path模块：os.path属于python标准库，它提供了关于路径判断、连接及切分的方法，常用操作如下：

七、NumPy科学计算库

Numpy是一个开源的python科学计算库，是python生态圈中最重要的底层支持库，它支持快速的数组和矩阵运算

1.数组对象特性

1）一般来说，引入Numpy的标准格式为import numpy as np

范例：

import numpy as np #引入Numpy
print(np.__version__)      #显示Numpy的版本号
arr = np.arange(5)  #生成一个数组，含5个元素
print(arr)
print(type(arr))  #显示数组的数据类型

2）Numpy数组的数据类型是numpy.ndarray，这类数组对象具有很多特性。数组对象比较常用的特性如下：

范例：

import numpy as np
b = np.arange(6).reshape(2,3)#生成一个6个元素的数组，并且使之成为2*3的二维数组
print(b)        #输出b
print(b.ndim)   #输出b的数组维度
print(b.size)   #输出b数组中元素的个数
print(b.shape)  #输出b的数组形状
print(b.dtype)  #输出b数组元素的数据类型
print(b.T)      #进行b的转置

2.生成数组

1）使用array()生成数组，参数为元组或列表：

b = np.array((1,2,3,4))

2）Numpy的数组对象可调用tolist()函数转换为Python的列表对象：lst = b.tolist()

3）使用arange()函数生成数组：arange()是Numpy中的函数，它类似于Python中的range()，调用格式为arange(start,stop,step)，功能是生成指定范围内的等差数组。range()函数的步长参数step必须为整数。arange()函数的步长参数step可以为小数，默认为1

b = np.arange(1,5)

4）已有的数组还可使用repeat()函数或np.tile()函数进行重复(不一样)，以构造更大的数组

b.repeat(4) #将元素重复4次
np.tile(b,3) #将数组重复3次

5）使用ones()、zeros()等函数生成数组：

np.ones(5) #生成含有5个元素的一维全1数组
np.zeros((2,3))  #生成2*3的二维全0数组
np.full(5,1.2)   #生成5个元素都为1.2的一维数组
np.eye(3) #生成单位矩阵数组
np.diag([1,3,5])  #生成对角线矩阵数组

6）使用linspace(start,stop,num)函数生成等差数组：调用时需要指定等差数组的初值、终值和数据个数，但不需要指定差值

[in]:np.linspace(1,2,5)	#在区间[1,2]内等间距生成5个数据，含终值2
[out]:array([1.  , 1.25, 1.5 , 1.75, 2.  ])
[in]:np.linspace(1,2,5,endpoint = False) #在区间[1,2]内等间距生成5个数据，不含终值2
[out]:array([1. , 1.2, 1.4, 1.6, 1.8])

7）使用随机函数生成数组：

[in]:np.random.rand(3,4)  # 3*4数组，rand()生成在区间(0,1)内均匀分布的小数
[out]:array([[0.37593685, 0.86299426, 0.33854305, 0.65272705],
       [0.20506248, 0.48859259, 0.21358632, 0.36303535],
       [0.54406831, 0.5361081 , 0.15807879, 0.75233734]])

[in]:np.random.randn(3,4)  # 生成一个符合标准正态分布的3*4数组
[out]:array([[ 2.15445301e+00, -3.60500592e-01, -1.62115216e+00,
        -8.45961544e-01],
       [-2.45483615e-01, -1.13200690e+00, -1.83843862e+00,
         1.62799121e+00],
       [ 2.24272721e+00,  1.23815343e+00,  9.48475865e-01,
         1.81689766e-03]])

存取数组元素

1.基本索引和切片操作

1）Numpy支持一维和多维数组。存取一维数组的方法类似于访问Python列表，可单个索引或切片访问。Numpy的切片语法和列表的切片语法相同，但要注意Numpy的数组切片和Python的列表切片在内存管理机制上是不同的。

[in]:b = np.arange(5,10)
[in]:b
[out]:array([5, 6, 7, 8, 9])
[in]:b[1]	#单个索引下标访问元素
[out]:6
[in]: b[[0,1,3]]	#访问第0，1，3个元素，多个下标要放在[ ]内
[out]:array([5, 6, 8])
[in]: c = b[0:3]	#切片访问，访问第0，1，2（不含第3）个元素
[in]: c
[out]:array([5, 6, 7])
[in]: c[0] = 100	#Numpy数组切片和原数组共享内存
[in]: c
[out]:array([100,   6,   7])
[in]: b
[out]:array([100,   6,   7,   8,   9])

2.二维数组的索引操作

b = np.arange(12).reshape(3*4) #生成一个3*4的二维数组
b[1] #只给出行坐标，省略列坐标，访问第1行的所有元素
b[:,1] #行坐标为:代表所有的行，访问第1列的所有元素

3.布尔索引

1）布尔索引用一个布尔数组来索引数组元素，选取True值对应位置的数据

范例：

[in]:b = np.random.randint(40,100,size = 10) #生成10个区间[40，100)内的随机整数
[in]:c = b < 60
[in]: c
[out]:array([ True, False,  True, False,  True, False,  True,  True, False,
        True])
[in]:b[c]
[out]:array([41, 58, 56, 55, 57, 58])

数组运算和排序

1.数组和单个数据的运算

数组和单个数据的运算规则很简单，即对单个数据和数组的每个元素进行运算。Python的列表一般需要编写循环代码才能对整个列表元素进行计算，而数组不需要循环语句就可实现同样的操作

2.数组和数组的运算

1）数组形状相同时的运算：当两个数组的形状相同时，各位置上的元素对位计算

范例：

[in]:a1 = np.arange(5)
[in]:a1
[out]:array([0, 1, 2, 3, 4])
[in]:a2 = np.arange(5,10)
[in]:a2
[out]:array([5, 6, 7, 8, 9])
[in]:a1 + a2
[out]:array([ 5,  7,  9, 11, 13])
[in]:a1 * a2
[out]:array([ 0,  6, 14, 24, 36])

2）数组形状不同时的广播运算：当两个数组的形状不同时，Numpy将按照广播规则进行运算

广播规则具体如下：
①参加运算的数组都向维数最大的数组看齐，维数较小的数组在前面加1补齐
②结果数组的形状(shape)取各运算数组的各个轴上的最大值
③若运算数组的某个轴的长度为1，则该轴可扩充为结果数组的对应轴的长度。若轴的长度不为1，则不为扩充
④检查扩充后所有运算数组对应的轴的长度，若长度都相同则符合规则可以计算，否则相反规则无法计算

范例：

[in]:b1 = np.arange(3).reshape(3,1)
[in]:b2 = np.arange(10,12).reshape(1,2)
[in]:b1
[out]:array([[0],
       [1],
       [2]])
[in]:b2
[out]:array([[10, 11]])
[in]:b1 + b2
[out]array([[10, 11],
       	[11, 12],
       	[12, 13]])

3.数组排序

1）Numpy数组自带sort()排序方法，它可以把数据从小到大排列，但会改变数组自身： a.sort()

2）如果排序时不想改变数组自身，那么可以使用np.sort()函数

3）还有一个常用的排序函数 np.argsort()，它可以返回一个代表原数据顺序的有序下标数组，最小的值对应的下标最小

4）将数组逆序排序的小技巧：

b = [np.argsort(-b)]

5）在对二维数组排序时务必注意指定排序的轴。二维数组有行和列两个轴，分别用参数axis = 0和axis = 1指定，默认按最后一个轴(axis = 1)排列，在水平方向上排序，指定参数axis = 0，在数值方向上排序：

np.sort(b,axis = 0)

Numpy的函数

1.常用函数

2.随机函数

3.集合函数

数组组合和文件存取

1.改变数组的维度

import numpy as np
b = np.arange(12)

c = b.reshape(3,4) #调整为3*4的二维数组并赋给c,b保持不变
c.transpose() #矩阵转置

ar = np.array([3,4,5])
ar = ar[:,np.newaxis] #增加一个维度，从一维变为二维

二维数组展平为一维数组

d1 = ar.ravel() #返回一维数组视图
d2 = ar.flatten() #返回以为新数组(将分配新内存)

2.数组组合

3.数组分割

4.读写文件

1）读写文本文件使用savetxt()和loadtxt()函数

#将数组b以整数格式保存为文件data2.txt，delimiter参数指定以逗号分隔，fmt指定格式
np.savetxt('data.txt',delimiter = ',',fmt = "%i")

2）savetxt()存盘时默认采用科学记数法。想要保存其他格式，可在savetxt()函数中用fmt参数指定保存格式

3）fmt的常用格式字符