三天速通复习python

阶段一 了解IDE

1. 使用pycharm：
   • 新建项目:会生成.idea目录;
   • 设置编辑器：下载Anaconda，设置脚本路径和名称，名称建议与项目名相同;
   • 设置断点：点击小虫按钮，通过步入前进;
   • 中文：右下角为UTF-8
2. 使用jupeyter：
   • 在Anaconda navigator中下载
   • 一种笔记软件，基于浏览器实现，由python编译器和markdown语法构成
3. 其他：
   • spyder： 类似于matlab的IDE

阶段二 基本语法

• 本段代码来源：Python基础知识总结(十分钟速成)

1. 注释

# 单行注释
"""
    多行注释
    写代码之前可以先写多行注释对接下来的操作进行整体描述
"""

2. 操作符

# 简单的算数
+ - * / %
// # 向下取整
** # 幂运算
5 / 2  # => 2 省去小数点
+= -= *= /= %= **= //=

# 布尔值 注意首字母大写
True  False

# 逻辑运算符
not &——and |——or
< <= > >= != ==

# 比较运算可以连起来写
1 < 2 < 3  # => True
2 < 3 < 2  # => False

# 字符串通过 " 或 ' 括起来 => 好处：可以用撇号
'I say:"you are a liar!"' # => I say:"you are a liar!"

# 字符串通过加号拼接
"Hello " + "world!"  # => "Hello world!"

# 字符串可以被视为字符的列表
"This is a string"[0]  # => 'T'

# 格式化 第一个方法:%s、%d、%x 与c类似
"%s can be %s" % ("strings", "interpolated")
# 推荐使用 format
"{0} can be {1}".format("strings", "formatted")
# 也可以用变量名代替数字 变量多的时候用
"{name} wants to eat {food}".format(name="Bob", food="lasagna")

# None 是对象
None  # => None

# 不要用相等 `==` 符号来和None进行比较
# 要用 `is`
"etc" is None  # => False
None is None  # => True

# 'is' 可以用来比较对象的相等性
# 这个操作符在比较原始数据时没多少用，但是比较对象时必不可少
# None, 0, 和空字符串都被算作 False 其他的均为 True
0 == False  # => True
"" == False  # => True

3. 变量和集合

# 很方便的输出
print ("I'm Python. Nice to meet you!")
# 输入 默认为string
input (n)

# 给变量赋值前不需要事先声明
# 一般建议使用小写字母、数字、下划线组合来做为变量名,且数字不能开头
some_var = 5    
some_var  # => 5
a=b=c=1 # 连续赋值

# 访问未赋值的变量会抛出异常
# 可以查看控制流程一节来了解如何异常处理
some_other_var  # 抛出 traceback() … NameError：…

# if 语句可以作为表达式来使用
"yahoo!" if 3 > 2 else 2  # => "yahoo!"

# 列表用来保存序列
li = []
# 可以直接初始化列表
other_li = [4, 5, 6] #下标范围在-3:2

# 在列表末尾添加元素
li.append(1)    # li 现在是 [1]
li.append(2)    # li 现在是 [1, 2]
li.append(4)    # li 现在是 [1, 2, 4]
li.append(3)    # li 现在是 [1, 2, 4, 3]
# 移除列表末尾元素
li.pop()        # => 3 li 现在是 [1, 2, 4]
# 重新加进去
li.append(3)    # li is now [1, 2, 4, 3] again.

# 像其他语言访问数组一样访问列表
li[0]  # => 1
# 访问最后一个元素 范围是-4到3
li[-1]  # => 3
# 越界会抛出异常
li[4]  # IndexError: list index out of range

# 切片语法需要用到列表的索引访问 类似于matlab
# 可以看做数学之中左闭右开区间 以下为说明，不是基本语法
li[0:3] = li[:3] = li[0:] #都表示从[1,2,4,3]
# 返回空
li[-1:2] # => []

# 删除特定元素
del li[2]  # li 现在是 [1, 2, 3]

# 合并列表
li + other_li  # => [1, 2, 3, 4, 5, 6] - 并不会不改变这两个列表
# 通过拼接来合并列表
li.extend(other_li)  # li 是 [1, 2, 3, 4, 5, 6]

# 用 in 来返回元素是否在列表中
1 in li  # => True

# 返回列表长度
len(li)  # => 6

# 列表生成式 python内置的非常强大的操作
[i for i in range(1,100) if i%10==0] # => [10, 20, 30, 40, 50, 60, 70, 80, 90]

# 元组类似于列表，但它是不可改变的
tup = (1, 2, 3)
tup[0]  # => 1
tup[0] = 3  # TypeError: 'tuple' object does not support item assignment

# 对于大多数的列表操作，也适用于元组
len(tup)  # => 3
tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
tup[:2]  # => (1, 2)
2 in tup  # => True

# 你可以将元组解包赋给多个变量
a, b, c = (1, 2, 3)     # a 是 1，b 是 2，c 是 3
# 如果不加括号，将会被自动视为元组
d, e, f = 4, 5, 6
# 现在我们可以看看交换两个数字是多么容易的事
e, d = d, e     # d 是 5，e 是 4


# 字典用来储存映射关系 哈希表unordered_map
empty_dict = {}
# 字典初始化
filled_dict = {"one": 1, "two": 2, "three": 3}

# 字典也用中括号访问元素
filled_dict["one"]  # => 1

# 把所有的键保存在列表中
filled_dict.keys()  # => ["three", "two", "one"]
# 键的顺序并不是唯一的，得到的不一定是这个顺序

# 把所有的值保存在列表中
filled_dict.values()  # => [3, 2, 1]
# 和键的顺序相同

# 读取所有值
filled_dict.items() # => {"one": 1, "two": 2, "three": 3}

# 判断一个键是否存在
"one" in filled_dict  # => True
1 in filled_dict  # => False

# 查询一个不存在的键会抛出 KeyError
filled_dict["four"]  # KeyError
filled_dict["four"] = 4 # 赋值语句，直接在键值对后添加4

# 用 get 方法来避免 KeyError
filled_dict.get("one")  # => 1
filled_dict.get("four")  # => None
# get 方法支持在不存在的时候返回一个默认值
filled_dict.get("one", 4)  # => 1
filled_dict.get("four", 4)  # => 4

# setdefault 是一个更安全的添加字典元素的方法
filled_dict.setdefault("five", "nvidia")  # filled_dict["five"] 的值为 "nvidia"
filled_dict.setdefault("five", 5)  # filled_dict["five"] 的值仍然是 "nvidia"


# 集合储存无顺序的元素 集合unorder_set 不允许重复值
empty_set = set()
# 初始化一个集合
some_set = set([1, 2, 2, 3, 4])  # some_set 现在是 set([1, 2, 3, 4])
# Python 2.7 之后，大括号可以用来表示集合
filled_set = {1, 2, 2, 3, 4}  # => {1 2 3 4}

# 向集合添加元素
filled_set.add(5)  # filled_set 现在是 {1, 2, 3, 4, 5}

# 用 & 来计算集合的交
other_set = {3, 4, 5, 6}
filled_set & other_set  # => {3, 4, 5}
# 用 | 来计算集合的并
filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
# 用 - 来计算集合的差
{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}

# 用 in 来判断元素是否存在于集合中
2 in filled_set  # => True
10 in filled_set  # => False

4. 选择、循环结构

# 新建一个变量
some_var = 5

# 这是个 if 语句，在 python 中缩进是很重要的。
# 下面的代码片段将会输出 "some var is smaller than 10"
if some_var > 10:
    print "some_var is totally bigger than 10."
elif some_var < 10:    # 这个 elif 语句是不必须的
    print "some_var is smaller than 10."
else:           # 这个 else 也不是必须的
    print "some_var is indeed 10."

# for循环里同样有break和continue
# 循环 1
for animal in ["dog", "cat", "mouse"]:
    # 你可以用 % 来格式化字符串
    print "%s is a mammal" % animal
# 循环 2
for i in range(4):
    print i
# 循环 3
x = 0
while x < 4:
    print x
    x += 1  #  x = x + 1 的简写

5. 函数

# 用 def 来新建函数
def add(x, y):
    print "x is %s and y is %s" % (x, y)
    return x + y    # 通过 return 来返回值

# 调用带参数的函数
add(5, 6)  # => 输出 "x is 5 and y is 6" 返回 11

# 通过关键字赋值来调用函数
add(y=6, x=5)   # 关键字实参的顺序是无所谓的

# 我们也可以定义接受多个变量的函数，这些变量是按照顺序排列的
def varargs(*args):
    return args

varargs(1, 2, 3)  # => (1,2,3)

# 我们也可以定义接受多个变量的函数，这些变量是按照关键字排列的
def keyword_args(**kwargs):
    return kwargs

# 实际效果：
keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}

# 你也可以同时将一个函数定义成两种形式
def all_the_args(*args, **kwargs):
    print args
    print kwargs
"""
all_the_args(1, 2, a=3, b=4) prints:
    (1, 2)
    {"a": 3, "b": 4}
"""

# 当调用函数的时候，我们也可以进行相反的操作，把元组和字典展开为参数
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)  # 等价于 foo(1, 2, 3, 4)
all_the_args(**kwargs)  # 等价于 foo(a=3, b=4)
all_the_args(*args, **kwargs)  # 等价于 foo(1, 2, 3, 4, a=3, b=4)

# 函数的嵌套调用
def create_adder(x):
    """先传外，再传内"""
    def adder(y): #特殊变量，如果没有传第二个参数则不会调用
        return x + y
    return adder

add_10 = create_adder(10)
add_10(3)  # => 13

# 常见函数
# 1. 匿名函数：不用def的函数，本质是一行代码的仿函数
#    lambda [arg1 [,arg2,.....argn]]:expression
(lambda x: x > 2) (3)  # => True
# 2. map函数：会根据提供的函数对指定序列做映射，类似于feval(matlab)
#    map(function, iterable, ...) 
map(add_10, [1, 2, 3])  # => [11, 12, 13]
# 3. filter函数：过滤掉不符合条件的元素，返回一个迭代器对象
#    filter(function, iterable)
filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
# 4. 数学函数
max() sum() min() abs()

# 可以用列表方法来对高阶函数进行更巧妙的引用
[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]

6. 类

# 我们新建的类是从 object 类中继承的
class Human(object):

     # 类属性
    species = "H. sapiens" # 公有属性，由所有类的对象共享
    __species0 =''         # 私有属性
    
    # 基本构造函数
    def __init__(self, name):
        # 将参数赋给对象成员属性
        self.name = name

    # 成员方法，参数要有 self
    def say(self, msg):
        return "%s: %s" % (self.name, msg)

    # 类方法由所有类的对象共享
    # 这类方法在调用时，会把类本身传给第一个参数，即成员函数
    @classmethod
    def get_species(cls):
        return cls.species

    # 静态方法是不需要类和对象的引用就可以调用的方法
    @staticmethod
    def grunt():
        return "*grunt*"


# 实例化一个类
i = Human(name="Ian")
print i.say("hi")     # 输出 "Ian: hi"

j = Human("Joel")
print j.say("hello")  # 输出 "Joel: hello"

# 访问类的方法
i.get_species()  # => "H. sapiens"

# 改变共享属性
Human.species = "H. neanderthalensis"
i.get_species()  # => "H. neanderthalensis"
j.get_species()  # => "H. neanderthalensis"

# 访问静态变量
Human.grunt()  # => "*grunt*"

7. 模块

# 可以导入其他模块
import math
print math.sqrt(16)  # => 4

# 可以从一个模块中导入特定的函数
from math import ceil, floor
print ceil(3.7)   # => 4.0
print floor(3.7)  # => 3.0

# 从模块中导入所有的函数
# 警告：不推荐使用，效率低下
from math import *

# 简写模块名
import math as m
math.sqrt(16) == m.sqrt(16)  # => True

# Python的模块其实只是普通的python文件
# 你也可以创建自己的模块，并且导入它们
# 模块的名字就和文件的名字相同

# 也可以通过下面的方法查看模块中有什么属性和方法
import math
dir(math) 

阶段三 以题带练

• 题目来源：Data-Science-Notes
• 题目只是为了保持手感，加上本人最近时间有限，故只做三天；第一天是阶段一之后复习巩固，第二天是学完数据分析三剑客后复习巩固，第三天是复写本人毕业设计中matlab代码后的感想

day 1

• 输入函数input()返回的是string类型，如果是整数，需在前文添加int,即：n=int(input())

day 2

• 连续输入a=input().split(',')，其中数据以逗号分隔开来；还可以与函数map()联用
• 类中self可以不预设属性值，直接用self.n来传递参数
• range()函数用法：

range(stop) # [0,stop)，是一个左闭右开的区间
range(start, stop[, step]) # step即步长

• join()函数用法：用来连接字符串

str.join(sequence)
# example
','.join([1,2,3]) # => 1,2,3 没有括号

• 二维数组正确的创建方法：li2=[[0 for j in range(n)]for i in range(m)]
• list中排序函数的用法：list.sort( key=None, reverse=False)
• 内建函数sorted()的用法：sorted(iterable, key=None, reverse=False)

day 3

• count()函数用法：

#list count函数用法，此法更常用
list.count(obj) 
#内置函数 count函数用法
str.count(sub, start= 0,end=len(string))

• list remove()用法：

list.remove(obj) # 该方法没有返回值但是会移除列表中的某个值的第一个匹配项

• 进制转换可以使用：

# 十进制转其他进制：
bin(obj) # 转换为2进制
oct(obj) # 转换为8进制
hex(obj) # 转换为10进制
# 其他进制转十进制：
int(obj,n) # n=2，就是2进制

• ord()函数：返回对应ASCII码的十进制整数 -> ord(c)
• \n是换行符
• 要多用[],只有函数才用()

阶段四 数据分析

• 本阶段是通过看视频学习，视频来源：Python数据分析三剑客

1. numpy

1. 介绍：数值计算拓展，全称为numeric python；通常以import numpy as np调用
2. 基本用法：

# 产生数组
arr=np.array([1,2]) # => 1,2
# 对加减乘除进行了重载 + - * / 类似于matlab 矩阵相加减
arr+1 # => 2,3
arr1 + arr2 # => 即matlab点加

# 生成数列的函数
arr=np.zeros(n) # => 生成n个0.0的数组
arr=np.ones(n [,dtype='type name']) # => 生成n个1.0(默认为float)的数组
arr.fill(n) # => arr中每个元素都变成n，会自动取整
arr.astype('type name') # => 对array进行类型转换
arr=np.arange(start,stop [,step]) # => 类似于range函数，生成整数数列
arr=np.linspace(start,stop，num) # => 生成从start到stop(包括)个数为num的等差数列
arr=np.random.rand(num) # => 生成(0,1)的num个随机数
arr=np.random.randn(num) # => 生成正态分布的num个随机数
arr=np.random.randint(start,stop,num) # => 生成(start,stop)的num个随机数

# 数组属性
arr.dtype # => 查看数组内元素的数据类型，如果用type会直接返回numpy.ndarray
arr.shape # => 返回一个元组，每个元素表示这一维的元素数目 (,5)
arr.size # => 查看数组所以元素
arr.ndim # => 查看维度，1

# 索引和切片
# 和基本语法完全一样！
arr[::2] # => 从0到-1，步长为2进行索取
arr2=arr[1:]-arr[:-1] # => 差分数组，其中-1不包括最后一个，所以个数相同
where(condition) # => 返回所有满足condition的元素的索引
# 多维数组
arr=np.array([[0,1,2,3],[10,11,12,13]])
arr.shape # => (2,4)2行4列数组
# 多维数组索引和切片 与matlab基本相同 arr[row(lower:upper:step),colume]
arr[1,3] # => 行和列都是从0开始算，(1,3)即13
arr[1,3]=-1 # => 赋值
arr[1] # => 第二行 [10,11,12,13]
arr[:,1] # => 第二列 [1,11]

# 引用与复制--花式索引
# array和list的不同：array的切片是引用机制，改变b的数值会改变a的数值；
arr3=arr[2:4].copy() # => 解决引用机制带来的问题

index=[1,2,-3]
arr3=arr[index] # => 获取arr中第1、2、-3个元素

mask=np.array([0,1,2,……],dtype='bool')
arr3=arr[mask] # => 获取arr中mask为True的元素

3. 进阶学习：

# 数组类型：整数、无符号整数、浮点数、复数、字符串、时间、对象
# 类型转换
arr=np.array([],dtype=float)
arr=np.asarray(arr.dtype=float) # => 前两者等价
arr2=arr.astype('float') # => 不调用引用机制

# 基本操作
## 单维数组
np.sort(arr) # => 排序，不解释
np.argsort(arr) # => 从小到大排序之后，返回排序后元素在原数组中的索引
np.sum(arr) or arr.sum() # => 求和，不解释
np.max(arr) or arr.max() # => 最大值，不解释
np.min(arr) or arr.min() # => 最小值，不解释
np.mean(arr) or arr.mean() # => 求均值，不解释
np.std(arr) or arr.std() # => 求标准差，不解释
np.cov(arr) or arr.cov() # => 求协方差
## 二维数组
arr.shape=row,colume # => 可以直接转成行列式 
arr2=arr.reshape(2,3) # => 不调用引用机制
arr.T # => 转置矩阵
arr2=arr.transpose() # => 不调用引用机制
np.concatenate((x,y)，axis=1 or 0) # => 连接数组，0是按行连接
np.stack() or np.vstack() # => 同上理由

4. 要学会查文档，numpy+python约等于matlab了

2. pandas

1. 基本介绍：解决数据分析任务创建的，全称为python data analysis,通常以import pandas as pd调用
2. 基本数据结构：

• 一维数组：Series，通常以pd.Series()调用，下标默认为数字

# 属性
s=pd.Series([num]，index=[]) # 初始化
s.index # 查看索引
s.values # 查看所有值
# 切片 完全一样
# 索引赋值
s.index.name='索引'
s.index=list("abcdef") # 把索引从123->abc，切片取的时候要注意，会包括右区间

• 二维数组：DataFrame，表格型数据结构，是一个以series的容器，重中之重

# example
data=pd.date_range('20180101',periods=6) #创造一组时间序列
# 创建dataframe结构：行是data，列是ABCD
df=pd.DataFrame(np.random.randn(6,4),index=date,colums=list('ABCD'))
or
df2=pd.DataFrame({'A':1,'B':……})
# 只需要保证每一列的类型相同即可

3. 文件读写

# 读取excel数据
df=pd.read_excel(r'filepath')
# 写入excel数据
df.to_excel(r'filepath')

4. 增删改查

# 查看头尾属性
df.head()
df.tail() # 默认为5 

# 查看数据
df.index()
df.values() # 此两者同上
df.colume() # 这个是看列头 index看行头

# 行操作
## 查看行数据
df.iloc[index] # 查看 row==index 的数据，左闭右开区间
df.loc[index] # 不同于上者，这个是左右闭区间
## 添加一行
dit=['name':'the Avenger','A':12,……] # 每一行df都是一个dict
s=pd.Series(dit) # 先创建序列
df=df.append(s) # 添加数据
## 删除一行
df=df.drop([index],axis=0) # 删除index的数据

# 列操作
## 查看列数据
df.columns 
df['name'][:5] # 取 columns==name 的前五个数据
df['name']['A'] # 取多列数据
## 增加一列
df['sex']=range(1,len(df)+1) # 直接增加一列,columns==sex
## 删除一列
df=df.drop(['sex'],axis=1)
df.index=range(len(df)) # 删除一列后最好更新一下序列索引

# 通过标签选择数据
df.loc[[index],[column]]

# 条件选择:& |
df['name']=='Linxson' # 取出数据为bool型
df[df['name']=='Linxson'][:5] # 取出符合条件的数据的前5个
df[(df.name=='Linxson')&(df.sex=male)][:5]

5. 缺失值及异常值处理方法

# 判断缺失值
df['column'].isnull() # 返回bool值
# 填充缺失值
df['name'].fillna(0,inpace=True) # 用0去覆盖空值
# 删除填充值
df.dropna(how='all',inplace=True,axis=0) # 删除所有；是否覆盖；行还是列

6. 数据格式转换

# 查看格式
df['name'].dtype
# 转换格式 str2int
df['name']=df['name'].astype('int')
# 转换数据可能会报错，部分数据是带有控制字符or错误值，需提前对数据进行修正

7. 排序

# 按照某一个index排序
df.sort_values(by='name',ascending=False) # 按name排序，且降序排列
# 按照多个值排序，前优先于后
df.sort_values(by=['name','sex'],ascending=False)

8. 基本统计分析

# 描述性统计：展示表格中count、mean等等数据
df.describe()
# 基本操作
df['name'].min()
df['name'].max()
df['name'].mean()
df['name'].median() # 中值
df['name'].var() # 方差
df['name'].std() # 标准差
df['name'].sum()
df['name','sex'].cov() # 相关系数、协方差：两个参数
df['name'].unique() # 查阅：不同姓名的人
df['name'].value_counts() # 计数： 不同姓名出现的次数
df['name'].replace('Linxson','NUX',impalce=True) # 用NUX替换Linxson

9. 数据透视 pivot_talbe

# 基础形式
pd.pivot_table(df,index=['name'])
pd.pivot_table(df,index=['name','sex']) # 分两类计数
# 参数调节：调节行、列最大值
pd.set_option（'max_columns',500)
pd.set_option（'max_rows',500)
# 操作
pd.pivot_table(df,index=['name'],values=['sex']) # 只统计sex
pd.pivot_table(df,index=['name'],values=['sex'],aggfunc=np.mean) # 以姓名为主，按性别人数之和的平均值进行统计，默认是和；aggfunc可以是dict，比如以性别按人数之和，其他按平均值之类的
pd.pivot_table(df,index=['name'],values=['sex'],aggfunc=np.mean,fill_value=0)# 移除非数值，并将其覆盖为0
pd.pivot_table(df,index=['name'],values=['sex'],aggfunc=np.mean,fill_value=0,margins=True) # 汇总行

10. 数据重塑和轴向旋转

• 层次化索引：类似于合并同类项，本质是一级目录、二级目录–看图好理解

# 建立
s=pd.Series(np.arange(1,4),index=[['a','a','b'],['c','d','d']])
"""
a c 1
  d 2
b d 3
"""
# 切片：可以切一级索引，也可以切二级索引

• Dataframe的层次化索引：s.unstack()将Series转换为Dataframe

# 建立
data=pd.Dataframe(np.arange(12).reshape(1,3),index=[['a','a','b','b'],[1,2,1,2]],columns=[['A','A','B'],['z','x']])
# 命名
data.columns.names=['column1','column2']
# 轴向旋转
data.swaplevel('column1','column2')
# 每一个索引都是一个元组，可以简化很多筛选环节

#取消层次化索引
df=df.reset_index()

• 数据旋转

data.T

11. 数据分组与分组运算: GroupBy

# 分组比透视表更加方便
group1=df.groupby(df['name'])
group2=df.groupby(df['name','sex']) # 根据两个变量进行分组

12. 离散化处理：区间化、分组化

# 常见形式
pd.cut(x,bins,right=True,labels=None,retbins=False,precision=3,include_lowest=False)
# x：需要离散化的数组、Series、DataFrame类
# bins：分组依据
# right：右闭间
# labels：分组后评级标准
# include_lowest： 左开间

13. 合并数据集

• append：先把数据集拆分为多个，然后再上下拼接
• merge：连接两个对象

pd.merge(left, right, how = 'inner', on = None, left_on = None, right_on = None,
    left_index = False, right_index = False, sort = True,
    suffixes = ('_x', '_y'), copy = True, indicator = False, validate=None) 
# 设计数据库之类的知识，和数据库join相似，暂不做深究

• concat：将多个数据集进行批量合并 pd.concat([df1,df2,df3])

3. matplotlib

1. 基本介绍：包含一系列类似于matlab中绘图函数的相关函数
   • 导入库调用：import matplotlib.pyplot as plt
   • jupyter中，使用魔术命令：% matplotlib inline
2. 基本用法

# 显示图像
plt.show()
# 绘图函数
plt.plot(x,y)
plt.plot([1,2,3,4]) # 只有一组参数会当做y，默认x为0~N-1
plt.ylabel('y',fontsize=14)
plt.xlabel('x')
plt.axis(xmin,xmax,ymin,ymax)
# 字符参数：和matlab一模一样 e.g.'-k'黑直线

# 传入numpy数组and绘制三条直线
t=np.arange(0.,5.,0.2)
plt.plot(t,t,'r--',t,t**2,'bs',t,t**3,'g^')

# 线条属性
plt.plot(x,y,linewidth=1.0,color='r')
line1=plt.plot(x,y,'r-')
line1.linewidth=1.0 # 错误示范
plt.setp(line1,'linewidth'=1.0) # 正确示范

# 子图
plt.figure(num)
plt.subplot(numrows,numcols,fignum)
# 画函数图
def f(t):
    return np.exp(-t)*np.cos(2*np.pi*t)
plot(x,f(x))

3. 实例操作

# 忽略警告
import warnings
warnings.filterwarning('ignore')

# 设置中文字体
plt.rcParms['font.sans-serif']=['SimHei']
plt.rcParms['axes.unicode_minus']=False

# 修改坐标
plt.xticks(rotation=90)

# 加标注
## text
for a,b in zip(x,y):
    plt.text(a,b+10,b,ha='center',va='bottom',fontsize=10)
## annotate
annottate(xy,xylabel)

# 画柱状图
plt.bar(x,y,'g')

# 画饼状图
plt.pie(x,explode,label,……)
# x:每一块比例
# labels:每一块说明文字
# explode:每一块离开中心的距离

# 画直方图
plt.hist(arr,bins,……)

# 画双轴图
ax1=……
mlab.normpdf(bins,df,'name'.mean(),df['name'].std()) # 概率密度函数
ax2=ax1.twinx()
ax2.plot()

# 画散点图
plt.scatter()
# 画箱线图
plt.boxplot()
# 画热力图
ax = sns.heatmap()

4. 数据分析报告

• 背景介绍：说明问题，阐述问题重要性
• 数据来源与说明：公开渠道、说明样本含义、制作图表
• 描述性分析：分维度可视化展示，描述图表
• 统计建模：解决问题
• 结论建议

阶段五 WNTR包

• 资料：WNTR 0.4.1 官方文档
• to be continue……