Python

目录
1. Python 基本语法与数据类型....................................................................................................4
1.1. 基本数据运算操作.........................................................................................................4
1.2. 基本数据类型.................................................................................................................4
1.2.1. 整数、浮点型.....................................................................................................4
1.2.4. 列表(list).........................................................................................................4
1.2.5. 元组(tuple)——不可变的列表（有着和列表类似的操作）.......................5
1.2.6. range 类型..........................................................................................................6
1.2.7. 集合(set)...........................................................................................................6
1.2.8. 字典(dictionary)——类似 DataFrame..........................................................7
1.3. 条件语句（注意缩进！）.............................................................................................7
1.3.1. for 循环（使用的循环定义域变量很广）......................................................7
1.3.2. while 循环..........................................................................................................8
1.3.3. countinue 与 break 与 else..............................................................................8
1.3.4. 列表推导式.........................................................................................................8
1.3.5. if.........................................................................................................................8
1.3.6. 逻辑表达式.........................................................................................................8
1.4. 函数................................................................................................................................ 9
1.4.1. def.......................................................................................................................9
1.4.2. 函数的参数.........................................................................................................9
1.4.3. 函数的参数传递.................................................................................................9
1.4.4. 匿名函数（简洁地定义一个简单的函数）...................................................10
1.5. 类..................................................................................................................................10
1.5.1. 定义...................................................................................................................10
1.5.2. 类的属性...........................................................................................................11
1.5.3. 类的继承...........................................................................................................12
1.5.4. 类的多态...........................................................................................................13
1.6. 命名空间与作用域.......................................................................................................13
2. Python 的文本处理语言..........................................................................................................14
2.1. 文件路径.......................................................................................................................14
2.1.1. 工作目录...........................................................................................................14
2.1.2. 绝对路径与相对路径.......................................................................................14
2.1.3. 路径有效性.......................................................................................................15
2.2. 文件读写.......................................................................................................................15
2.2.1. 用 open()返回对象进行读写..........................................................................15
2.2.2. 用 with open() as 进行读写........................................................................15
2.2.3. 文件的写作模式...............................................................................................16
2.3. import json——存储(dump)与读取(load).............................................................16
2.4. import pickle——二进制格式（可以保存函数与类的实例）.............................16
2.5. import shelve——像字典一样保存.........................................................................17
2.6. 组织文件（import shutil, os）.............................................................................17
2.6.1. 复制与移动.......................................................................................................17
 2.7. 文件操作.......................................................................................................................17
2.7.1. 删除操作...........................................................................................................17
2.7.2. 遍历目录树.......................................................................................................18
3. Numpy........................................................................................................................................18
3.1. numpy.array.................................................................................................................18
3.1.1. array 的创建....................................................................................................18
3.1.2. 基本函数...........................................................................................................19
3.1.3. 切片...................................................................................................................19
3.1.4. 多维数组...........................................................................................................20
3.1.5. 布尔索引——返回拷贝...................................................................................20
3.1.6. 神奇索引--返回拷贝.......................................................................................21
3.1.7. array 的转置、换轴、合并与拆分................................................................21
3.2. np 函数..........................................................................................................................22
3.2.1. 通用函数...........................................................................................................22
3.2.2. 数学统计方法...................................................................................................22
3.3. 矩阵运算.......................................................................................................................23
3.4. 广播..............................................................................................................................23
4. Pandas......................................................................................................................................23
4.1. Series——带标签的一维数组,可以使用 np 函数，有字典的类似性质................23
4.1.1. Series 的创建(注意大写！)..........................................................................23
4.1.2. Series 的信息..................................................................................................23
4.1.3. 标签索引...........................................................................................................24
4.1.4. 逻辑判断与加法...............................................................................................24
4.1.5. 使用 np 函数.....................................................................................................24
4.1.6. name...................................................................................................................24
4.2. DataFrame.....................................................................................................................24
4.2.1. Dataframe 的创建............................................................................................24
4.2.2. 常用处理...........................................................................................................25
4.2.3. 标签...................................................................................................................25
4.2.4. name...................................................................................................................25
4.2.5. 索引...................................................................................................................26
4.2.6. 删除条目...........................................................................................................26
4.2.7. 使用索引筛选...................................................................................................26
4.2.8. loc 与 iloc.......................................................................................................27
4.2.9. Series 与 DataFrame 的运算...........................................................................28
4.2.10. 映射函数（用 np 函数就行）.......................................................................28
4.2.11. Series 的排序................................................................................................28
4.2.12. 重复索引.........................................................................................................29
4.2.13. 统计.................................................................................................................29
5. 用 pandas 处理数据.................................................................................................................30
5.1. 数据储存与读取...........................................................................................................30
5.2. 保存数据.......................................................................................................................31
5.2.1. csv 格式............................................................................................................31
5.2.2. 二进制格式.......................................................................................................31
 5.2.3. HDF5 格式..........................................................................................................31
5.2.4. Excel 格式........................................................................................................31
5.3. 处理缺失值...................................................................................................................32
5.3.1. 缺失的判断.......................................................................................................32
5.3.2. 缺失的处理.......................................................................................................32
5.4. 处理重复值...................................................................................................................32
5.4.1. 重复值的判断...................................................................................................32
5.4.2. 重复值的删除...................................................................................................32
5.5. 函数映射 （df.map）.................................................................................................32
5.6. 替代值..........................................................................................................................33
5.6.1. df.replace...........................................................................................................33
5.6.2. 重命名轴索引 df.rename...............................................................................33
5.7. 离散化 pd.cut(A,B)...................................................................................................33
5.8. 处理异常值...................................................................................................................34
5.9. 置换与随机抽样...........................................................................................................34
5.10. 分层索引（多层索引，分为 leves 与 codes）.......................................................34
5.11. 用列索引.....................................................................................................................35
5.12. 组合、合并.................................................................................................................35
5.12.1. pd.merge(df1.df2) 其中第一列为 key，第二列为不同的 data1、data2
........................................................................................................................................35
5.12.2. 根据索引合并.................................................................................................36
5.12.3. 沿着轴向连接.................................................................................................36
5.13.1. df.groupby.....................................................................................................37
5.13.2. groupby 的迭代..............................................................................................38
5.13.4. 用函数进行分组（根据函数返回的值分组）.............................................39
6. 绘图..........................................................................................................................................39
6.1. import matplotlib.pyplot as plt (类似 matlab)..............................................39
6.2. import seaborn as sns (0.12.2 版本)..................................................................40
6.2.1. 绘图函数...........................................................................................................40
6.2.2. 绘制 subplot....................................................................................................41
6.2.3. 图片设置...........................................................................................................41
6.3. Pandas 绘图..................................................................................................................41
7. 统计模型..................................................................................................................................41
7.1. 线性回归模型...............................................................................................................41
7.2. K-means 聚类................................................................................................................42
7.3. PCA 降维........................................................................................................................42
7.4. 层次聚类.......................................................................................................................42
7.5. k 折交叉验证........................................................................................................................43
1. Python 基本语法与数据类型

1.1. 基本数据运算操作
1.1.1. 变量声明： 只能使用数字、字母与下划线不能用空格

1.1.2. 基本运算符号：

/ 除法 += 加法直接赋值
// 取整的除法（直 -= 减法直接赋值
接去除小数）
% 取余数 /= 除法直接赋值
** 次方 %= 取余直接赋值
@ 矩阵乘法 **= 幂次直接赋值

1.2. 基本数据类型
1.2.1. 整数、浮点型

* 相互转换： float() int() str()注意 int 是向下取整 、

*type(num)
1.2.2. 布尔型： False True
1.2.3. 字符串: 用”” 或者''

1.1.1.1.字符串调整大小写

.title() *将字符串中每个单词的首字母大写，并将其余字符变为小写
.upper() *将字符串中的所有字符变为大写字母。
.lower() *将字符串中的所有字符变为小写字母。

1.1.1.2.字符串的的索引与切片

first_name + “ ” + last_name
* 字符串的连接使用 +
* 字符串可以使用索引 name[0] 如同 python 其他索引一样可以用-1 返回
最后一个元素
*可以使用索引切片 name[0:2] 效果如同 until
full_name[::2]
*数字为 slice step ，取 1 时返回整个字符串，取 2 时隔一个取一个
1.1.1.3.转义字符

\\ 输出反斜杠\ \n 表示换行
\' 输出单引号' \t 表示 Tap
\” 输出双引号”

1.2.4. 列表(list)

1.2.4.1.生成 list

mylist=['a',3,'string',4.5]
 *可以包含不同类型的元素，用[]生成
*可以使用 python 索引，从零开始,-1 最后一个元素
len(list)
*返回列表长度（不能用 size）
python 索引机制
* 使用[] 从 0 开始正着数，从-1 开始取倒数
* [: 2] 从头开始取 2 个元素返回新的 list，0 的话返回一个空的 list
* a[:] 与 a[::]返回一整个 a
* [::2] 从头开始隔一个取一个，要大于 0
* list[[1,3,5]] python 的多重索引

1.2.4.2.修改列表元素

 修改 直接使用索引
 添加
mylist.append(val)
mylist.extend([4,5]) #可以在末尾插入一个 list
mylist.insert(1,val)
*注意前面的数字是插入后的索引，0 为第一个，1 为第二个
 删除
del mylist[0] #直接利用索引
mylist.pop(0) #会返回删除的元素
mylist.remove('str') #会删除指定的元素

1.2.4.3.列表排序

list.sort() #对列表进行永久性的排序（字符从 a 到 b，数字从小到大）

list.sort(reverse = True) #reverse:倒转

list.reserve() #永久倒转列表

sorted(list) #临时排序

list1 + list2 #合并两个列表

mylist *2 #重复两次 mylist 等同于 mylist+mylist

1.2.4.4.列表赋值

*如果直接 b = mylist 会使得指针赋值到同一个！

mylist.copy()

mylist[:]

mylist[::]
1.2.5. 元组(tuple)——不可变的列表（有着和列表类似的操作）

1.2.5.1.元组生成

mytuple = (100,'wo')

*可以使用不同的数据类型，可以使用 python 索引
*但是元组里的数据不可以改变，意味着无法在元组中添加、修改或删除元
素，但是可以通过重新赋值一个新的元组实现元组内容的修改
例如 :
test= (1,[2,3],5)

test[1].append(4) #返回(1,[2,3,4],5)

* 假如直接用逗号相连：
1,2,3

默认返回元组(1,2,3)
1.2.5.2.元组拆包

* 将一个元组里的元素都拿出来赋给另外的值，如果要取出某几个可以使
用元组的索引 a,b = t[:,2]之类的
a = 1,2,3

a1,a2,a3 = a #a1,a2,a3 是 int

b1,b2 = a2,a1 #后面是一个元组前面是拆包，如果

1.2.6. range 类型
range(start,stop,step)

*range 是不可变类型，通常为 int，类似 until 不包括 stop，step 可以为

负数
*range 的三个参数要为整数
list（myrange） 可以转换为 list
1.2.7. 集合(set)

1.2.7.1.集合的创建
myset = {'a','b'}

a = set('abcdfr') #返回单个字母的集合

*重复元素只剩下一个

*集合无序，不能使用索引，只能用 in 判断（可以用 for 循环取出）

1.2.7.2.集合的运算

a-b a 中有 b 中没有 a|b a并b

a ^ b 不同时在 a 和 b 的元素 a&b a交b
 注意 a+b 没有意义！！

1.2.7.3.集合的函数（增加与删减）
a.add('e')

a.remove('e') #要是没有'e'会报错
1.2.7.4.frozenset

*frozenset 之中的元素不能增删
frozenset('abbaskc')

1.2.8. 字典(dictionary)——类似 DataFrame

1.2.8.1.生成字典（key-values）与调用
d1= {'color': 'green', 'points': 5}

dict(one=1,two=2,three=3)

dict(zip(a，b))

*zip 将两个列表 a，b 配对，a 作为 keyb 作为 values

d1['color']

d1['point']

1.2.8.2.字典内操作（索引与增删）

*增加： d1['new']=new_value
*删除：
del d1['new'] #整个删除了键值对

b = d1.pop('color') #只返回 value

1.2.8.3.返回参数（视图对象）
akeys = a.keys()

avals = a.values()

*返回的是视图对象,展示其动态特性，会实时改变
a_items = a.items

* 返回字典的所有键值对，是一个 dict_items 类型
dict_items([('two', 2), ('three', 3)]),也是视图，中间元素是元组
1.2.8.4.字典间的操作
a.update(b)

*将两个字典合并，实际上是在对 a 操作
1.3. 条件语句（注意缩进！）
1.3.1. for 循环（使用的循环定义域变量很广）
 for i in range(10):

print(m_sum)

*注意缩进、in、冒号
*循环字典中的值（这其实就是元组拆包）
for key, value in user_0.items(): #items 返回键值对的元组
print("\nKey: " + key)

print("Value: " + value)

1.3.2. while 循环
while current_number <= 5:

print(current_number)

while a in mydict:

mydict.remove(a)

1.3.3. countinue 与 break 与 else

*通常与 if 连用，应该是跳出当前循环：其后可以加 else 进行不跳出

循环的步骤
*可以通过 input()函数进行问卷的判断与退出
if m == 'quit':

break

if current_number % 2 == 0:

continue

1.3.4. 列表推导式

*在列表的[]（set 和 dict 也可以）里面利用 for 循环语句，更复杂一

些可以用 for 加 if 等多个条件语句
squares = [x**2 for x in range(10)
[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
squares = {x**2 for x in range(10)}
dict([(x, 0) for x in ['1','2','3']])

1.3.5. if
if age < 4:
print("cost is $0.")
elif age < 18:
print(" cost is $5.")
else:
 print(" cost is $10.")

1.3.6. 逻辑表达式

in 在某里面 and 且
not in 不在某里面 or 或
== 等于 != 不等于
> 大于 < 小于
>= 大于等于 <= 小于等于
not() 里面放条件语句，取反 all 需要全部为 True
的 bool（非）
any 只需要一个为 True

1.4. 函数
1.4.1. def

*注意缩进与冒号、用 return 返回值（不带 return 相当于返回 None）

*返回的值可以使用逗号隔开返回多个(元组)
def f(canshu):
print('注意缩进')
print('注意冒号，用 return 返回值')
return canshu*2

1.4.2. 函数的参数

*函数调用的时候传递的是对象的引用而不是对象的值
*位置实参与关键字实参（前者需要注意创建函数时参数的位置，后者使用
了关键字所以不必在意位置），实际上关键字实参传递了键值对
* 参数默认值：注意顺序，只能放在后面
def describe_pet(pet_name, animal_type='dog'):

*参数默认值只会定义一次,在 def 函数的时候被创建，相当于函数的私有

值
def f(a,l=[]):
#其中的 l

1.4.3. 函数的参数传递

*不可变类型：如整数、字符串、元组
由于 a 不可变，如果在 fun(a)内部修改 a 的值，则是生成新的对象。
*可变类型：如列表，字典
由于 a 可变，修改后 fun 外部的 a 也会改变。
*传递任意数量的实参：（放后面）
 使用 *tuple_name 传递任意数量的参数并将多出来了放到此元组里面
def make_pizza(*toppings):
#形参名*toppings 中的星号让 Python 创建一个名为 toppings 的空元组，并将收到的所
有值都封装到这个元组中。

*传递任意数量的关键词实参 （两个星号）（放后面）
def build_profile(first, last, **user_info):
#形参**user_info 中的两个星号让 Python 创建一个名为 user_info 的空字典，并将收到
的所有名称—值对都封装到这个字典中

*函数可以作为对象进行 for 循环等判断

for fun in funs:

fun()

1.4.4. 匿名函数（简洁地定义一个简单的函数）
fun = lambda x: x**2

#一个简单的平方函数 fun（）

*另一用途：结合 filter 过滤：

even_lst = list(filter(lambda x: x % 2 == 0, lst))

1.5. 类
1.5.1. 定义
class Car():

def __init__(self, make, model, year):

"""初始化描述汽车的属性"""
self.make = make

self.model = model

self.year = year

self.odometer_reading = 0

def get_descriptive_name(self):

""""返回整洁的描述性信息"""
long_name = str(self.year) + ' ' + self.make + ' ' + self.model

return long_name.title()

def read_odometer(self):

"""打印一条指出汽车里程的消息"""
print("This car has " + str(self.odometer_reading) + " miles on it.")

def update_odometer(self, mileage): #更改里程表

 """将里程表读数设置为指定的值"""
self.odometer_reading = mileage

def increment_odometer(self, miles):

"""将里程表读数增加指定的量"""
self.odometer_reading += miles

*类中的成员函数称为方法，都有 self 这一参数 （注意构造类的时候都写

上，后面调用可以不用写）
*__init__()类似 C++中的构造函数，是一个特殊的方法。在这里声明并赋值
self 的参数
*类中的属性（类的数据成员）是公有的，可以在任何地方调用
*类中可以在__init__()函数中写上 self.newval = 0 新建属性

1.5.2. 类的属性

1.5.2.1.类属性

*如果某一属性不是用 self.var 定义的，则会定义为类的共享属性

class Dog():

"""一次模拟小狗的简单尝试"""
color='yellow'

#此处定义为类属性，区别于实例属性，所有实例共享类属性。

#类似 c++中的静态变量
def __init__(self, name, age):

*当共享属性为不可变类型：
*实例（例如有实例 x,y）直接调用共享属性会显示类属性，但是通过实例
可以定义一个实例自己的同名属性，del 之后仍然显示类属性；不过 del 两次
后此实例的这一属性就没有了（其他类与实例还会有）
x=Dog('Bob',16)
 y=Dog('Tom',18)

x.color #yellow

y.color #yellow

x.color='red' #此处定义了一个实例属性，注意 x.color 不再是类属性

print(y.color) #yellow

print(x.color) #red

Dog.color #yellow

del x.color

print(x.color) #yellow

*当共享属性设置为列表之类的可变属性，实例的此属性改变会使得整个属
性改变
1.5.2.2.私有属性

*在属性的名字前面加__(两个下划线)可以使得属性变为私有变量，不能使
用原变量名访问
class Dog():

__count = 0

def __init__(self, name, age):

self.__count = 0

Dog.__count+=1

*为了调用私有变量，可以创建一个公共方法 print 这个私有变量

def counts():

print(Dog.__count)

def sitcounts(self):

print(self.name+" sits "+str(self.__count)+" times")

1.5.3. 类的继承

1.5.3.1.构造函数的继承
class ElectricCar(Car):

def __init__(self, make, model, year):

"""初始化父类的属性"""
super().__init__(make, model, year)

#用 super 调用父类的构造函数

*类在继承后不会自动调用父类的构造函数，除非子类中没有构造函数（即
 定义了子类自己的构造函数就不会主动调用父类的构造函数）
*super().__init__( 传 入 的 参 数 ) 就可以 调用父 类的操作，不 需要重新写一 遍
self.xxx 相当于简化使用了，便于多态

1.5.3.2.方法的继承

*Python 的成员函数均为虚函数，这意味着重写子类的成员函数会直接本
来给子类的覆盖父类的函数（不会改变父类本身）
*isinstance 可以判断一个实例 a 是否是 B 类中的；issubclass 可以判断
一个类 A 是否继承与另一个类 B
ininstance(a,B) #若 a 是 B 的子类的实例返回 True

issubclass(A,B)

1.5.4. 类的多态

def sounds(all):

try:

all.sounds()

except AttributeError:

print('不会叫')

1.6. 命名空间与作用域
1. namespace ( 命 名 空 间 ) 是 一 个 从 名 字 到 对 象 的 映 射 ， 大 部 分 命 名 空 间 都 由
Python 字典实现。

3. 不同命名空间中的名称之间没有关系，两个不同的模块都可以定义一个 maximize
函数而不会产生混淆

4. 程序在访问变量时，会在当前的命名空间内查找。

5. 一个 scope (作用域) 是 Python 可直接访问的命名空间的文本区域

6. 命名空间保证了名称不冲突，而作用域给出了访问这些名称的区域

7. global 语句可被用来表明特定变量生存于全局作用域并且应当在其中被重新绑
定；nonlocal 语句表明特定变量生存于外层作用域中并且应当在其中被重新绑定。

注意后面定义的全局变量 spam 将函数

内部的变量带到了函数外面
2. Python 的文本处理语言

2.1. 文件路径

导包：import os
2.1.1. 工作目录

注意转义字符，用字符串时要用\\ (LInux 用/)

os.getcwd() #get current working directory 返回当前工作目录的字符串

os.chir('C:\\Windows\\System32') #指定工作目录 change directory

*两个函数：

os.path.join('a','b','c') 将字符串用\\连接起来

os.path.splitext() 将文件路径名与文件名和扩展名（如.txt）分成两个字符串元组

2.1.2. 绝对路径与相对路径
 * 绝对路径：'C:\\Users\\huggs\\Desktop\\file.txt'
* 相对路径：
'.\\file.txt''
'..\\Desktop\\file.txt''
* os.listdir('.') 查看当前目录下所有文件
* os.makedirs('\\tmp\\a\\b') 建立/tmp/a/b 目录，如果已经有了报错
2.1.3. 路径有效性

* os.path.exists('C:\\Windows') #路径是否存在
* os.path.isdir('C:\\Windows\\System32') #是否为文件夹
* os.path.isfile('C:\\Windows\\System32') #是否为文件
2.2. 文件读写
2.2.1. 用 open()返回对象进行读写

1.用 open()返回一个 File 对象

file_object=open('pi_digits.txt')

2. 用 read()读取文件内容(所有内容，返回字符串)
contents = file_object.read()

3.用.close()关闭文件
file_object.close()

file_object.closed #返回一个 Bool 看是否关闭

2.2.2. 用 with open() as 进行读写

with open('pi_digits.txt') as file_object:

#调用 open()函数，返回一个 File 对象

#关键字 with 在不再需要访问文件后将其关闭

contents = file_object.read()
 #调用 File 对象的 read()方法

print(contents)

* 逐行读取：
filename = 'pi_digits.txt'

with open(filename) as file_object:

for line in file_object:

print(line) #默认输出一个回车

* line.rstrip() #rstrip 消除这些多余的空白行

* line.strip() #strip 消除空格
2.2.3. 文件的写作模式

* open 的参数设置:
open(filename, 'w') #写入模式，直接覆盖原文件

open(filename, 'r') #读取模式，未指定参数的默认模式,不能修改

open(filename, 'a') #追加模式，追加到末尾

open(filename, 'r+') # 读写模式

open(filename, 'b') # 二进制模式

* 用.write('string') 写入内容：
file_object.write("I love programming.\n") #要手动换行

* 用 w 和 a 模式若是没有文件会新建
2.3. import json——存储(dump)与读取(load)
import json

numbers = [2, 3, 5, 7, 11, 13]

filename = 'numbers.json'

with open(filename, 'w') as f_obj:

json.dump(numbers, f_obj) #json.dump 存储对象

with open(filename) as f_obj:

numbers1 = json.load(f_obj) #json.load 加载对象

print(numbers1)
2.4. import pickle——二进制格式（可以保存函数与类的实例）
import pickle

filename = 'pet'

with open(filename, 'wb') as f_obj:

pickle.dump(mypet,f_obj)

with open(filename, 'rb') as f_obj:

newpet=pickle.load(f_obj)

2.5. import shelve——像字典一样保存

import shelve

shelfFile = shelve.open('mydata')

cats = ['Zophie', 'Pooka', 'Simon']

shelfFile['cats'] = cats

shelfFile.close()

* shelve 有 key-value:

* import random
random.shuffle(mylist) #随机打乱一个列表
2.6. 组织文件（import shutil, os）
2.6.1. 复制与移动

shutil.copy('pi_digits.txt', '.\\test\\test1.txt')
shutil.copytree('test', 'test1')
shutil.move('test\\test1.txt', 'test1\\test2.txt')
2.7. 文件操作
 2.7.1. 删除操作

2.7.2. 遍历目录树

os.walk(dir)

3. Numpy

import numpy as np
3.1. numpy.array
3.1.1. array 的创建

* 使用列表创建
np.array([1,2,3],dtype=np.float64)

* 使用 ones，zeros，empty,full_like 生成相同元素
np.zeros(10)

np.zeros((3, 6))

np.empty((2, 3, 2)) #直接分配内存里的数据，这些数据随机

 np.arange(15) #类似于 np.array(range(0,15))注意里面类型是 int（但是 arange 可以
生成非整数）

np.arange(start,stop,step)

arr2=np.full_like(arr1,0.3) #生成与 arr1 一样的数据维度，填充为 0.3

arr2=np.ones_like(arr1)

np.identity(5) #生成单位阵

np.random.randn(1,3) #生成[0][0:3]的标准正态随机数

np 生成随机数：

np.random.rand(n) 均匀分布随机数

np.random.randn(n) 标准正态随机数

np.random.randint(low,high,size) 指定范围内随机整数左闭右开

np.random.random(n) 均匀分布随机数

np.random.uniform(low,high,size)

np.random.(mu,std,size)

np.random.binomial(n,p,size)

np.random.chisquare(df,size) #df 为自由度

np.random.seed(134) #设置随机种子

3.1.2. 基本函数

* arr1.shape // arr1.ndim #返回是 shape 的数目

* arr.dtype
* arr.astype(np.int32) // arr.astype(float)
* type(arr) #返回的是 np.bdarray
*数组运算（一般的数字运算直接对元素作用，相乘也是直接数乘而不是向
量相乘）
*如果在数组运算的时候 arr1 与 arr2 维数不对应则会使用广播将维数进行
匹配（）
3.1.3. 切片

*切片返回的是数组的视图而不是拷贝，切片的索引机制类似 until 不包括

最后一个索引
b = arr[5:8]
 b=arr[5:8].copy() #进行拷贝
*切片是要返回与原来格式一样的 ，例如一位 arr1 中 b=arr1[0]为一个
float 不是切片，b 改变不会影响 arr1；但是多维数组 arr2d 中 c=arr2d[0]为
一个 arry 是 arr2d 的切片
*List 的切片返回的是拷贝
lst=list(range(10))

b=lst[5:8] #list 返回拷贝，不会改变原始的 list

b[0]=1

3.1.4. 多维数组

*索引方式：(两种索引等同，都是先返回第一个大的，然后第一行，再行
里的元素)
arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

arr3d[0][1][1]

arr3d[0,1,1]

arr2d=np.array([[1,2,3],[4,5,6]])

3.1.5. 布尔索引——返回拷贝

names == 'Bob' #返回一个全是 bool 的 array

data[names == 'Bob'] #返回对应 True 的元素，由于 name 是 7 个，data 是 7*4，故返

回的是对应行

* 逻辑运算符
 ~bool_index #真假反转

mask=(names == 'Bob')|(names == 'Will') #or 或

mask=(names == 'Bob')&(names == 'Will') #and 且

tt=data[names != 'Joe']

tt[1]=8

* 返回的是拷贝，data 不会变
3.1.6. 神奇索引--返回拷贝

arr = np.arange(32).reshape((8, 4))

3.1.7. array 的转置、换轴、合并与拆分

*转置
arr = np.arange(15).reshape((3, 5))

#python 是按照一行一行 reshape 的但 R 会一列一列

arr.T

*换轴——返回视图（最简单的是行换列，即转置）
#对于三维，原来的(0,1,2)轴变为了（1,0,2）即第一个轴与第二个轴互换了，第三个轴
不变：（[0,1]的位置变为了[1,0]的位置）

arr = np.arange(16).reshape((2, 2, 4))

arr.transpose((1, 0, 2))

*合并
vstack：上下垂直合并
np.vstack((arr1, arr2))

hstack：左右水平合并
np.hstack((arr1, arr2))

*拆分
arr = np.random.randn(5, 2)

first, second, third = np.split(arr, [1, 3])

#1,3 表示拆分数组的行的索引（默认）位置，即切两刀分为三份，第一份从 0 开始,第

二份从 1 开始，第三份从 3 开始

fist,second = np.split(arr,[1],axis=1)

*注意拆分的起始索引是要输入 list
*注意 axis = 1 是从列，axis=0 是从行
3.2. np 函数
3.2.1. 通用函数

np.sqrt(arr)

np.exp(arr)

np.log(arr)

np.sin(arr)

np.maximum(arr1, arr2) #对比 x，y（同维度）返回最大值

xiaoshu,zhengshu = np.modf(arr) #将向量拆分为整数部分与小数部分

3.2.2. 数学统计方法

arr=np.random.randn(5, 3)

np.mean(arr) ; arr.mean()

np.mean(arr,axis=0) #对行作用求均值，最后返回一个行向量是每一列的均值

np.mean(arr,axis=1) #对列作用求均值，最后返回一个列向量是每一行的均值
 arr.mean(0) #对每一列求均值(即对行的五个数作用了)

arr.mean(1) #对每一行求均值（即对列的三个数作用了）

arr.sum()

arr.std()

arr.max()

arr.sort() #按最后一个维度(列)排序 即每一行的数都从小到大排序

arr.sort(0) #按列排序 每一列的数都从小（维数低）到大（维数高）排序

3.3. 矩阵运算
x.dot(y) ; x@y

numpy.linalg.inv(X)

np.random.shuffle(X) #打乱的是第一维即行

3.4. 广播
*较小的数组在较大的数组上面广播使得元素匹配（即 array 总是按照元素
处理）

4. Pandas

import pandas as pd #注意小写！

4.1. Series——带标签的一维数组,可以使用 np 函数，有字典的类似性质

4.1.1. Series 的创建(注意大写！)

* 用列表
pd.Series([4,'7',[3,5]]) #默认标签 0 1 2

pd.Series([4,'7',[3,5]],index=['a','b','c'])

* 用字典
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

obj3 = pd.Series(sdata)

obj3

* 用列表和字典
states = ['California', 'Ohio', 'Oregon', 'Texas']

obj4 = pd.Series(sdata, index=states)

 #重新给定索引顺序，注意其中 California 是 sdata 没有的，而 Utah 被去掉了

*按照 index 生成 Series，新生成的索引为 NaN，没有包含在索引的键值对

去除
4.1.2. Series 的信息

* Series.index :获取索引未指定的时候默认生成一个 RangeIndex，可以

直接修改 Seires 的索引：
obj.index = ['Bob','S','J','R']

* Series.value :获取储存的内容，是 np.array 类型

4.1.3. 标签索引

* 直接用标签
obj['a'] = 6

* 布尔索引
obj[obj>2]

* 神奇索引
obj[['c','a','d']]

4.1.4. 逻辑判断与加法

pd.isnull(obj4) #判断是否为空值，返回一个 bool 的新的 Series

pd.notnull(obj4)#判断是否不为空值

obj3 + obj4 #相同 index 的 value 相加，若一方没有（不同时有）index 为 NAN

4.1.5. 使用 np 函数

*可以使用 np 的函数：
np.exp(obj) #对 value 指数，如果有不是数字会报错

4.1.6. name

* Series 对象本身和索引都有 name 属性（类似表头）

obj4.name = 'population'

obj4.index.name = 'state'

4.2. DataFrame
二维数据结构，每一列是一个 Series（相同 index）
4.2.1. Dataframe 的创建

* 使用字典
 data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],

'year': [2000, 2001, 2002, 2001, 2002, 2003],

'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}

df= pd.DataFrame(data)

* 使用列表指定 index 与 columns

pd.DataFrame(np.arange(9).reshape(3,3),

index=['a','b','c'],

columns=['1','2','3'])

4.2.2. 常用处理

df.head()

pd.DataFrame(df, columns=['year', 'state', 'pop']) #调整列的顺序

df.T #将行列转置

*注意当 df 已经创建，之后用 pd.DataFrame()重新指定 index 和 columns

时会调整顺序
* 指定 index 可以将已经创建的 df 转置
4.2.3. 标签

* 获得 DataFrame 的标签（返回类似列表的 Index 数据类）:

df.index

df.columns

*用标签索引列（实际上 Series 可变，所以是视图）

df['state'] #按名字索引展示一整列，即所在的 Series。不存在会建立一个新的列

df.state #必须要存在才能索引

*用.loc 索引行，返回 Series 视图

df.loc['a']

*用标签索引元素
df['state'][0]='cc' #列标签在前行标签在后，本质是 Series

* 删除一整列
del df['eastern']

*使用标签时的视图与拷贝
 .columns_name 返回视图（但要是选择两列可能是 copy(又是可能根据内存
决定视图还是拷贝))，同理 df['col_name']也是视图
test=df2.state #这是视图 返回的 state 这一列

test['one']='test' #注意会改变 frame2 中的值。

test=frame2.state.copy() #这是拷贝

test['one']='test2'

4.2.4. name

df.index.name='year'

df.columns.name = 'state'

df.values #返回没有行列标签的 np.array

4.2.5. 索引

4.2.5.1.索引对象

myindex = obj_series.index

* 索引的为 pd.Index()，是不可变数据类型，只能对其整体 obj.index 修

改而不能对 myindex[1]修改
4.2.5.2.重建索引(reindex)

* reindex 返回拥有新索引的新对象
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e']) #obj 为 Seires

* 若新的索引数量多于原来的索引赋值为 NAN
* reindex 的 method 参数
obj3.reindex(range(6), method='ffill')

#ffill=向前填充（即后一个填充前一个的值（本来只有 0 2 4 有赋值））

obj3.reindex(range(6),method='bfill')

#bfill=向后填充（前一个填充后一个的值）

*改变列索引：
states = ['Texas', 'Utah', 'California']

df.reindex(columns=states)

4.2.6. 删除条目

* df.drop(‘row_name’),默认删除行，有 axis,inplace 两个参数

new_obj = obj.drop('c')
 #不会改变 obj 本身,返回一个新的对象

df.drop('two', axis=1)

df.drop(['two', 'four'], axis='columns')

#作用到列上面，可以删除 df 的列

obj.drop('c', inplace=True)

#inplace=True 使得直接修改 obj

4.2.7. 使用索引筛选

* 切片的两种方式（都是返回视图，一个 until 一个 to）

（df 可以对行索引而不能对列索引），返回的是行
* 对 Series：

test=obj[2:4] #位置索引切片返回视图

obj['b':'c'] #index 索引返回视图，注意包含尾部

* 对 df：（注意都是返回行）

b = df[:2] #默认提取前两行

df['Ohio':'New York'] #只能对 index 行索引，列索引会报错

data[data['three'] > 5]

data[data < 5] = 0

* 神奇索引返回新对象（df 可以对列索引而不能对行索引）
返回的是列
test=obj[['b', 'a', 'd']] #返回新对象

*如果想返回一个一列的 DataFrame 可以用两个括号的神奇索引

df[['one']]

* Series 的整数索引
4.2.8. loc 与 iloc

*这两个函数均是返回视图！
* .loc 用索引调用
data.loc['Colorado', ['two', 'three']] #只有一行时返回 Series

* .iloc 用顺序调用
data.iloc[2, [3, 0, 1]] #只有一行时返回 Series
 * .iloc 列索引范围必须有而.loc 可以没有，行索引可以用切片
data.iloc[:, :3][data.three > 5]

data.loc[:'Utah', 'two']

* .loc 可以使用布尔索引、函数等方法进行高级选取而.iloc 不行
* .loc 与.iloc 对于整数索引（按标签与按位置）
ser = pd.Series(np.arange(3.))

ser.loc[:1] #按照整数标签，包含 1 的索引所在行

ser.iloc[:1] #按照位置索引，不包含 1 的索引所在行,只返回 0 所在行

4.2.9. Series 与 DataFrame 的运算

* 两个 Series 相加:按照标 index 相加，如果有某个标签不是两者共有则为 NaN

* 两个 DataFrame 相加：按照 index 和 columns 相加，有一个没有就为 NaN
* 一些填充函数与运算函数
* 可以用 np.nan 创建 NaN 值（不能进行判断要用.isnull）
df1.add(df2, fill_value=0) #缺失值会被填充为 0，然后参与运算

df1.rdiv(1) #返回倒数

df1.div(2)#每个元素除以 2

df1.reindex(columns=df2.columns, fill_value=0)

#重建索引时，也可以指定填充值

* DataFrame 与 Series 之间的运算

frame - series #如果 Series 的 index 为 df 的 columns 会对每一行减去这个向量，但是是按照
index 减

frame.sub(series3, axis='index')#更改轴向，按照列去减 其中 Series 的 index 是 df 的 index

frame - series3 #还是认为是一行，index 完全不一样，会将 series 的 index 加到 df.columns 中

且全为 NaN

4.2.10. 映射函数（用 np 函数就行）

np.abs(frame) #取绝对值
* .apply(fun) 逐列
f = lambda x: x.max() - x.min()#匿名函数

frame.apply(f)#apply 方法将函数 f 应用到每一列上（默认）返回一个 Seires

frame.apply(f,axis='columns') #每行会调用一次
 * .applymap(fun) 逐元素
format = lambda x: '%.2f' % x #格式化的输出，按照小数点后两位输出

frame.applymap(format) #逐元素应用 format

frame['e'].map(format) #Series 使用 map 进行逐元素应用

4.2.11. Series 的排序

* index 排序；
参数：axis=’columns’ ascending=False (默认升序改为降序)
obj.sort_index() #返回新的排序好的对象，对 DataFrame 的话作用到.index

* value 排序
frame.sort_values(by='b') #by 后面加的列名，默认从小到大

frame.sort_values(by=['a', 'b']) #先按照 a 排序再按照 b 排序

* .rank() 返回 value 的顺序，一样的话会取两个中位数

参数：
method =’first’ #不取中位数，先到先得

method =’min’ #不取中位数，都取较小的那个（较前的）

method =’max’ #不取中位数，都取较大的那个（较后的）

ascending=False #排序改为从大到小

frame.rank(axis='columns') #在 columns 上对每一列排序

frame.rank(axis='index') #在 index 上对每一行进行排序

4.2.12. 重复索引
 * Series 可以设置相同标签：
obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])

* 返回是否有重复标签：
obj.index.is_unique

* 定位标签时会返回所有等于（例如 a，返回两个）标签的值
4.2.13. 统计

df.sum() #按照行向量相加，求每一列的总和。会自动去掉 NaN

df.sum(axis=1) #按照列相加

df.sum(axis='columns', skipna=False) #不去掉 NaN

df.idxmax() #返回每行最大值的列索引

df.cumsum() #对列作用（每列一个一个加下来），求累加

df.describe()

obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])

uniques = obj.unique() #对 Series 的 value 去重留下出现过的唯一 np.array

obj.value_counts() #计算每个元素的次数

df[‘column_name’]value_counts() #可以统计比如说某各班级出现了多少次

5. 用 pandas 处理数据

5.1. 数据储存与读取
* 读取 csv 文件
df = pd.read_csv('examples\ex1.csv')

pd.read_csv('examples\ex2.csv', header=None) #不让第一行作为列名，列名是从零开始的数

字

pd.read_csv('examples\ex2.csv', names=['a', 'b', 'c', 'd', 'message']) #重新命名列名

pd.read_csv('examples/ex2.csv', names=names, index_col='message')将 message 列作为 index

* 多重 index
parsed = pd.read_csv('examples/csv_mindex.csv',index_col=['key1', 'key2'])

#此时用元组做分层索引，index 为(‘one’,’a’)

* 读取 txt
5.2. 保存数据
5.2.1. csv 格式

df.to_csv('examples/out.csv')

* 可以将 df 以 csv 的格式写入

* sep=’|’，设置分隔符
* na_rep='NULL' 默认 NaN 是不存储直接空着
* index=False, header=False 是否存储 index 与 header
* columns=['a', 'b', 'c'] 选择存储的列
* sys.stdout 显示在屏幕的标准输出
dates = pd.date_range('1/1/2000', periods=7)

* 生成类似 Excel 中的时间数据

5.2.2. 二进制格式

frame.to_pickle('examples/frame_pickle')

pd.read_pickle('examples/frame_pickle')

5.2.3. HDF5 格式
 store = pd.HDFStore('mydata.h5')

5.2.4. Excel 格式

xlsx = pd.ExcelFile('example)

pd.read_excel(xlsx, 'Sheet1')

df = pd.read_excel('file.xlsx')

#存储：

df.to_excel('data.xlsx', sheet_name=’Sheet2’,index=False)

5.3. 处理缺失值
5.3.1. 缺失的判断

pd.insull（df） #不能 nan ===nan

5.3.2. 缺失的处理

* 读取数据时：
pd.read_csv('examples/survey_visited.csv', keep_default_na=False)

#是否将没有的数据设置为 NaN

pd.read_csv('examples/survey_visited.csv', na_values=[619, 622])

#将 619 与 622 视为缺失值

* 读取数据后：
df.info() #统计每一个变量的类型

missing_values_count = df.isnull().sum() #统计每一列缺失的变量的数目

df.fillna(0) #填充缺失值

df.fillna(method='ffill') #向前填充缺失值（和前面那个值保持一致）

df.fillna(method='bfill') #向后填充，和后面的值保持一致

df.interpolate() # 插值，插两个间的均值

5.4. 处理重复值
5.4.1. 重复值的判断

df.duplicated() # 判断是不是行重复（行的每一个元素都要一样）

5.4.2. 重复值的删除

data.drop_duplicates() #删除完全相同的行只保留一个

data.drop_duplicates(['k1']) #列 k1 里的值只保留一个（先到先得）
 data.drop_duplicates(['k1', 'k2'], keep='last') #重复的行保留后面一个

5.5. 函数映射 （df.map）

lowercased = data['food'].str.lower()

data['animal'] = lowercased.map(meat_to_animal)

#map 接受一个函数或者字典，用字典的映射生成一列

data['food'].map(lambda x: meat_to_animal[x.lower()])

5.6. 替代值
5.6.1. df.replace

data.replace(-999, np.nan) #替换值

data.replace([-999, -1000], np.nan) #替换多个值

data.replace([-999, -1000], [np.nan, 0]) #用列表替换

data.replace({-999: np.nan, -1000: 0},inplace=True) #用字典替换

* inplace 表示对原 df 进行替换

5.6.2. 重命名轴索引 df.rename

data.rename(index=str.title, columns=str.upper)

#不修改原来的 dataframe，返回新的 dataframe

* str 指的是原来的数据
* 可以使用 inplace 来进行替换原数据
data.rename(index={'OHIO': 'INDIANA'},

columns={'three': 'peekaboo'})

5.7. 离散化 pd.cut(A,B)

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

bins = [18, 25, 35, 60, 100]

cats = pd.cut(ages, bins) #判断 ages 在 bins 的哪个区间，默认左开右闭

out：[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35, 60], (35, 60], (25,
35]]
 cats.codes #用序号代替区间进行返回
out：array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)

* right = False 左闭右开

group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']

pd.cut(ages, bins, labels=group_names) #为区间命名

* 若是 pd.cat(data,4) 输入的是数字，则按照 data 中的数据量 n 等分来

划分区间
* 用 pd.value_counts(cats)统计每个区间数值的数目的数目
* pd.qcut 按照分位数分段，后面的 list 是分位数
pd.value_counts(pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.]))

5.8. 处理异常值
data[(np.abs(data) > 3).any(1)]

#any 返回 axis=1 的满足条件的行(只要有一个是 true 就返回 true)

#这里是判断每行只要有一个绝对值大于三就返回 true

5.9. 置换与随机抽样
* np.random.permutation(n)对 0 到 n-1 的整数随机排序
sampler = np.random.permutation(5) #对 0 到 4 随机排序

df.take(sampler) #按照索引提取行

* df.sample(n) 无放回抽取 n 行
df.sample(n=10, replace=True)

5.10. 分层索引（多层索引，分为 leves 与 codes）

* 转换为 Series 的时候 pd.index 为第一个索引 pd.columns 为第二个索引

5.10.1. 重排序与层级排序

对于 df：（两层 index，两层 columns）

 frame.swaplevel('key1', 'key2') #把两级索引换序

frame.sort_index(level=1) #按照 level1（第二个，0 为第一个）进行排序

frame.swaplevel(0, 1).sort_index(level=0)

* 按照层级汇总：
frame.sum(level='key2') #计算 key2 的 level 下各列的总和，返回 DF，是行与行相加

frame.sum(level='color', axis=1) # 在 color 下 计 算 相 同 color 的 总 和 ， 行 索 引 还 是 原 来

的，axis=1 表示作用在列，是列与列相加

5.11. 用列索引

* .set_index() 按照顺序设置多层 index

* .reset_index() 之后 index 变为默认 0 到 n-1
5.12. 组合、合并
5.12.1. pd.merge(df1.df2) 其中第一列为 key，第二列为不同的 data1、data2

* 根据一个 index 的 level 合并 df

pd.merge(df1, df2) #其中 df1，df2 共有的列名和形式是 key

#merge 根据一个或者多个键进行合并 （根据 key 列的 a，b 合并，不考虑前面行的索引）

* 用 on 参数选定按照哪一列合并
pd.merge(df1, df2, on='key') #on：我按照哪一个列去合并

* 当 on 的参数不同时，可以用 left_on 与 right_on （会将指定的列按照

左右留在 colunms 中，留下两个 df 指定列的交集）
 pd.merge(df3, df4, left_on='lkey', right_on='rkey')

#merge 后的 dataframe 是原来 dataframe 键值的交集

* merge 的 how 参数：

# how =’outer’保留两个 df 的所有 key 对应的行

pd.merge(df1, df2, how='outer')

#how='outer'使得合并后的键值为原键值的并集，若有 key 中多个为（例如为 a）的元素则

多次配比，单有的元素（假如说 c 只在 df1）则 data2 为 NaN

# how =’inner’只保留两个 df 都有的 key 值对应的行 默认

pd.merge(df1, df2, how='inner')

#使得键值对变为交集，加入 df1 中 key 为 b 的有 3 个数据，df2 中 key 为 b 的有 2 个则返回

6 个（两两组合）

# how =’left’保留左边 df1 的行，假如左边两个 b 右边三个 b 则按照左边返回 6 个 b

# how =’right’保留右边 df2 的行 与上面类似但是相反

* suffixes 重命名在合并时冲突的列名加上的后缀并分开
5.12.2. 根据索引合并

left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],

'value': range(6)})

right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])

pd.merge(left1, right1, left_on='key', right_index=True)

#把索引当作键，第二个表的 index 为 key 匹配分组赋值

 df1.join(df2, how='outer') #join 按索引合并，直接简单链接

#等同于：

df1.merge(df2, how='outer', left_index=True, right_index=True)

5.12.3. 沿着轴向连接

* np.concatenate([arr, arr], axis=1) #横向左右连接，等价于

np.hstack([arr,arr])
* pd.concat() 可以连接两个 Series 或者 DataFrame

* s1,s2,s3 都是 Series：

pd.concat([s1, s2, s3])

pd.concat([s1, s2, s3], axis=1,sort=False) #不按照列名进行排序

pd.concat([s1, s4], axis=1, join='inner', sort=False)

result = pd.concat([s1, s1, s3], keys=['one', 'two', 'three'])

result.unstack()

5.13. groupby 返回 groupby 对象，可以写进 for 循环

5.13.1. df.groupby

* 指定列分组：
 * 指定多列分组：

* 一些函数：
group.mean()

group.size() #每个分组的大小（含有的函数个数）返回一个 Series

group.count() #每组中每一列的非缺失值个数，返回 DataFrame

5.13.2. groupby 的迭代

* 对一个 lable 分组

* 对两个 lable 分组（返回元组）

 5.13.3. 用 Series 和字典进行分组 注意 axis=1 时按照列分组

* 用 Series 和字典这两种数据类型的对应关系可以将相同的结果（比如说
两个列对应 red）分为一组

5.13.4. 用函数进行分组（根据函数返回的值分组）

people.groupby(len).sum()

#对 index(前面的名字字符个数)进行 len 函数，然后根据 len 的返回值进行分组

6. 绘图

6.1. import matplotlib.pyplot as plt (类似 matlab)

* 绘图
#意义不明折线图：

plt.plot(ds_1['x'], ds_1['y'])

# 散点图：

plt.plot(ds_1['x'], ds_1['y'], 'o')

* 绘子图：
 fig = plt.figure()

axes1 = fig.add_subplot(2, 2, 1)

axes2 = fig.add_subplot(2, 2, 2)

axes3 = fig.add_subplot(2, 2, 3)

axes4 = fig.add_subplot(2, 2, 4)

axes1.plot(ds_1['x'], ds_1['y'], 'o')

axes2.plot(ds_2['x'], ds_2['y'], 'o')

axes1.set_title("dataset_1") #小标题 axes1.set_xlabe(‘...’)

fig.suptitle("Anscombe Data") #大标题

* 直方图，散点图与箱线图

6.2. import seaborn as sns (0.12.2 版本)

6.2.1. 绘图函数

* sns.displot(data , x , y , kind ,kde)

默认只有直方图,kind=‘kde’为去掉直方图的 pdf 曲线；kde=True 返回两个图

* sns.countplot(data, x, y,hue)
sns.countplot(x=df["class"])

* sns.barplot(data, x, y, hue)
hue = ‘cloumns_name’可以构造第二分组计数,一般直接输入一个 df 的列就可以计数

绘制条形图，默认计算均值

* sns.regplot(data, x, y)
默认绘制线性回归直线和置信区间
 * sns.scatterplot(data, x, y, hue , size ,style)
hue 为分组不同颜色，size 会按照列名大小设置点的大小，style 会根据列名的值不同给予不
同形状

* sns.boxplot(data, x , y ,hue , order=[‘yes’,’no’])

* sns.violinplot(data, x , y, hue, order,split=True)
split=True 会按照 hue 进行左右对半分

* sns.jointplot(data, x, y , hue, kind)

绘制两变量散点图与频率直方图（或者 pdf）

kind = ‘kde’ #绘制 cdf 与等高线

kind = ‘reg’#中间绘制回归直线

kind = ‘hex’ #中间绘制蜂巢图

* sns.kdeplot(data, x, y) 绘制 pdf，x 横向；y 纵向

如果只输入 data 会按照 index 分类

* sns.pairplot(data, hue)
绘制每一列的变量相关图（默认对角直方图其他上下角散点图）

修改绘制图的类型：

pair_grid = sns.PairGrid(tips_numeric)

pair_grid = pair_grid.map_upper(sns.regplot)

pair_grid = pair_grid.map_lower(sns.kdeplot)

pair_grid = pair_grid.map_diag(sns.distplot, rug=True)

plt.show()

* a = sns.PairGrid(data, hue)
a.map(sna.scatterplot)
* sns.lmplot(data, x, y, hue)
# 与 regplot 相比可以绘制多个子图(比如说 x 是离散变量)并用 hue 分组

6.2.2. 绘制 subplot

fig, axs = plt.subplots(nrows=2, ncols=2)

sns.histplot(data=df, x='x', ax=axs[0, 0])

sns.scatterplot(data=df, x='x', y='y', ax=axs[0, 1])

 sns.boxplot(data=df, x='x', y='y', ax=axs[1, 0])

sns.lineplot(data=df, x='x', y='y', ax=axs[1, 1])

6.2.3. 图片设置

facet = facet.add_legend() #加上图例

p.set(title="Histogram of Total Bill", xlabel="Total Bill", ylabel="Count")

* 主题与样式
sns.set_style('whitegrid')

6.3. Pandas 绘图
* 直方图
fig, ax = plt.subplots()

ax = tips[['total_bill', 'tip']].plot.hist(alpha=0.5, bins=20, ax=ax)

plt.show()

ax = tips[['total_bill', 'tip']].plot.kde(ax=ax)

ax = tips.plot.scatter(x='total_bill', y='tip', ax=ax)

ax = tips.plot.hexbin(x='total_bill', y='tip', gridsize=10, ax=ax)

ax = tips.plot.box(ax=ax)

7. 统计模型

7.1. 线性回归模型
import statsmodels.formula.api as smf
model = smf.ols('tip ~ total_bill', data=tips)

results = model.fit()

results.summary()

* 中间是回归的变量，如果有交叉效应可以用 x1*x2
7.2. K-means 聚类
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3,random_state=42).fit(data.values)

kmeans_3 = pd.DataFrame(kmeans.labels_,columns=['cluster'])

# kmeans.labels_ 是预测结果

7.3. PCA 降维
from sklearn.decomposition import PCA

pca0 = PCA(n_components = 2).fit(data)

pca_trans = pca0.transform(data)

pca_trans_df = pd.DataFrame(pca_trans,columns=['pca1','pca2'])

kmeans_3 = pd.concat([kmeans_3,pca_trans_df],axis=1)

fig = sns.lmplot(x='pca1',

y='pca2',

data=kmeans_3,

hue='cluster',fit_reg=False)

7.4. 层次聚类
from scipy.cluster import hierarchy

wine_complete = hierarchy.complete(wine)

# complete 计算距离的方式

fig = plt.figure()

dn = hierarchy.dendrogram(wine_complete)
plt.show()

7.5. k 折交叉验证