随机现象:不确定性与统计规律性 
概率论:从数量上研究随机现象的统计规律性的科学
数理统计:从应用角度研究处理随机性数据，建立有效的统计方法，进行统计推理

1.试验的可重复性 —— 在相同条件下可重复进行;
2.一次试验结果的随机性 —— 一次试验的可能结果不止一个，且试验之前无法确定具体是哪种结果出现; 
3.全部试验结果的可知性 —— 所有可能的结果是预先可知的，且每次试验有且仅有一个结果出现。

1、E (C ) = C
2、E (aX ) = a E (X )
3、E (X + Y ) = E (X ) + E (Y )
4、当X ,Y 相互独立时，E (X Y ) = E (X )E (Y )

求导找函数的最小(大)值不行吗?
考虑:1、多元函数
2、局部最大最小值

pyspark是spark的python API,允许python调用spark编程模型

rdd.subtract(rdd2)							返回RDD2里没有匹配键的rdd的兼职对
rdd2.subtractByKey(rdd)						返回rdd2里的每个（键、值）对，rdd中，没有匹配的键
rdd.cartesian(rdd2)							返回rdd和rdd2的笛卡尔积

rdd.sortBy(lambda x:x[1])					按给定函数排序RDD
rdd.sortByKey()								按键排序RDD的键值对

rdd.repartition(4)							新建一个含4个分区的RDD
rdd.coalesce(1)								将RDD中的分区数缩减为1个

rdd.saveAsTextFile("rdd.txt")
rdd.saveAsHadoopFile("hdfs://namenodehost/parent/child",'org.apache.hadoop.mapred.TextOutputFormat')

sc.stop()

./bin/spark-submit examples/src/main/python/pi.py

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("my app").config("spark.some.config.option","some-value").getOrCreate()

from pyspark.sql.types import *
推断Schema
sc = spark.sparkContext
lines = sc.textFile("people.txt")
parts = lines.map(lambda l:l.split(","))
people = parts.map(lambda p:Row(name=p[0],age=int(p[1])))
peopledf = spark.createDataFrame(people)
指定Schema
people = parts.map(lambda p:Row(name=p[0],age=int(p[1].strip())))
schemaString = "name age"
fields = [StructField(field_name,StringType(),True) for field_name in schemaString.split()]
schema = StructType(fields)
spark.createDataFrame(people,schema).show()

df.dtypes						返回df的列名与数据类型
df.show()						显示df内容
df.head()						返回前n行数据
df.first()						返回第一行数据
df.take(2)						返回前两行数据
df.schema						返回df的schema
df.describe().show()			汇总统计数据
df.columns						返回df列名
df.count()						返回df的行数
df.distinct().count()			返回df中不重复的行数
df.printSchema()				返回df的Schema
df.explain()					返回逻辑与实体方案

df = df.drop("address","phoneNumber")
df = df.drop(df.address).drop(df.phoneNumber)

peopledf.sort(peopledf.age.desc()).collect()
df.sort("age",ascending=False).collect()
df.orderBy(["age","city"],ascending=[0,1]).collect()

spark.stop()

1. 优点:向量化数据操作比for循环,速度大大加强，numpy array比list好的地方在于切片
2. array属性
    np.random.random((2,2)) # 0-1随机数
    np.random.randint(1,10,(3,3)) # 随机整数
    array.shape, array.dtype # numpy两个属性
    array.astype(np.float64) # 类型转换
3. array切片操作
    a[0,1] # 第一个维度为0,第二个维度1,第三个维度全选,类似于a[0,1,:]
    a[a>2] # boolean indexing, 利用broadcasting进行判断, 之后可以作为index进行数据的提取
    a[a>2]=0 # 也可以对满足条件的元素进行赋值
4. array数学运算
    broadcasting, 对不匹配的数据在高维上进行扩展,在取最小公倍数
    np.sum(array) # 统计运算
    np.dot # 矩阵乘法,点乘
    np.multiply  # 逐个元素乘法,对应相乘

基于Numpy构建，利用它的高级数据结构和操作工具，可使数据分析工作变得更加便捷高效。
import numpy as np
import pandas as pd

1. 基本概念
    pd.__version__ # 查看版本
    pd.Series # 可以使用不同类型,和list区别在于有index, 可以指定index

2. Series构建
    pd.Series([1,2,3], index=['a', 'b', 'c'])
    pd.Series({...}, name="xxx") # 通过对dictionary进行构建pandas, 给Series赋予名字

3. 切片
    aseries[[1,4,3]]; aseries[1:]; aseries[:-1]  # 数字下标切片,即使index不是数字也ok

4. 运算规则
    series的相加是根据index对应相加的

5. 取值
    数学运算也是broadcasting方式
    'xxx' in aseries # 判断xxx是否在aseries的index中
    aseries.get('xxx', 0) # 类似于字典
    aseries[aseries<20] # boolean index也可以
    aseries.median() # 除去缺失值之后进行统计运算
    aseries['xxx'] = 1000 # 对aseries['xxx']重新赋值
    np.square(aseries) # 对每个运算进行计算平方

1. 基本概念
    一组Series集合在一起

2. DataFrame的构建
    - pd.DataFrame({'a':[1,2,3], 'b':[1,4,3]}, columns = ['b', 'a'], index = ['one', 'two', 'three']) # 构建DF, 指定列名以及index名
    - pd.DataFrame([{'a':100,'b':200}, {'a':200, 'b':300}], index=['one', 'two']) # 按照一行一行构建DF
    - pd.DataFrame({'a':seriesa, 'b':seriesb} # 记住按照index对齐, 缺失值直接Nan填充

3. 元素的提取以及增加及逻辑操作及转置
    - aDF['xxx']/aDF.xxx # 取出来的是一个Series
    - aDF[['xxx']] # 取出来的是一个DF
    - aDF.loc(['a','b'],['c','d']) # 取对应的数据
    - aDF.loc[:, 'newcol'] = 2000 # 如果没有newcol那么就新加一列
    - aDF.loc[(aDF['a']>10) & (aDF['b']<100), :] # 也可以给条件进行筛选,& | ~进行逻辑运算
    - aDF.T # 进行转置
4. 数据读入以及基本信息以及删除
    - pd.read_csv(path, sep='\t', index_col=''/int, usecols=[...], header=0, parse_dates=[0]/['Date']) # 读文件，第一列作为日期型，日期型处理参照: http://hshsh.me/post/2016-04-12-python-pandas-notes-01/
    - aDF.to_csv('xxx.csv', sep='\t', index=True, header=True) # 写文件
    - aDF.describe(include=[np.float64...]) / aDF.info() # 对数据进行统计，查看缺失值
    - aDF.shape
    - aDF.isnull() # 判断是是否为空
    - aDF[aDF['xxx'].isnull(), :] = 10 # 对空值赋值
    - aDF.notnull() # 查看是否有值
    - aDF.drop(['one', 'two'], axis=0) # 对index为one和two的两行进行删除, axis=1删除列

5. 数据分组聚合
    - aDF.groupby('name', sort=False).sum() # 对DF进行聚合操作,同时对相应聚合的列进行排序,然后计算其他值的和
    - groupbyname=aDF.groupby('name'); groupbyname.groups; len(groupbyname) # 得到对应的各个组别包含的index, 并且可以获取对应的group长度
    - aDF.groupby('name').agg([np.sum, np.mean, np.std]) # 对不同类别的数据进行各类运算, 每个name对应三列分别是分组之后np.sum, np.mean, np.std计算
    - aDF.groupby('name').agg(['sum', 'median', 'mean']) # 和上面的作用相同
    - aDF.groupby('name').agg(['a':np.sum, 'b':median, 'c':np.mean]) # 对不同列进行不同操作
    - aDF.groupby(['name', 'year']).sum()/mean()/median()/describe() # 多组分类
    - aDF.groupby(['name', 'year']).size() # 多组分类, 每一组有多少个记录
    - 提取group类别名称以及类别对应的数据行
        for name,group in groupbyname:
            print(name) # 类别名称
            print(group) # 名称对应的数据行
        groupbyname.get_group('jason') # 可以得到对应组别的数据行,DF格式
6. transform/apply/filter 数据变换
    transfrom可以对分组进行变换, apply对整个DF进行分类,filter对分组进行判断
    - aDF['Date'].dt.dayofweek # 可以得到对应的日期中的第几天
    - aDF.groupby(aDF.index.year).mean() # 可以对相应的日期型的年进行分组聚合
    - aDF.groupby(aDF.index.year).transform(lambda x: (x-x.mean())/x.std()) # 对每一年的数据求均值以及标准差,并对每个数据进行操作,之所以没以每年为单位进行展示主要是跟function有关,因为之前的是mean之类的
    - aDF.groupby(aDF.index.year).apply(lambda x: (x-x.mean())/x.std()) # 可以起到相同的效果
    - aDF.loc[:,'new'] = aDF['xxx'].apply(afunc) # 可以对xxx这一列进行操作按照afunc进行操作,然后创建新的列
    - aSer = pd.Series([1,1,2,2,2,3,3,4,5,5]); sSer.groupby(sSer).filter(lambda x:x.sum()>4) # 对ser进行过滤,留下那些和大于4的类别

7. 表格的拼接与合并(concat/append/merge/join)
    - df1.append(df2, sort=False, ignore_index=True) # 追加在行上,同时忽略原先df1和df2的index,合并为新的index
    - df1.append([df2, df3])  # 也可以追加两个DF, 参考: https://zhuanlan.zhihu.com/p/38184619
    - pd.concat([df1.set_index('a'), df2.set_index('a')], sort=False, axis=1, join='inner') # 和上述利用merge在a字段上进行内连接的效果类似,因为concat是基于index进行连接的,merge可以不基于index,指定字段
    - pd.concat([df1, df2, df3], keys=['a', 'b', 'c'], axis=0, join='outer', sort=False) #列对齐的方式对行进行拼接,缺少值则补充为None,可以对拼接的每个df进行key的命名,axis=1的时候行对齐列拼接; join指定连接方式,outer表示外连接,inner表示内连接,sort是否对合并的数据进行排序
    - merge # 基于某个字段进行连接,之前的append和concat都是在行上或者列上进行连接的,merge类似于SQL里面的连接,可以指定某个字段或某几个字段,体现在on上,on接list就是多个字段为key
    - pd.merge(df1, df4, on='city', how='outer'/'inner'/'left'/'right') # 基于两个表中的city字段进行表格的连接,把其他的列进行combine到一起,不指定on的话就会找字段相同的那个进行拼接,注意concat是基于index进行拼接的
    - pd.merge(df1, df2, how='inner', left_index=True, right_on='id') # 对数据进行merge,左表以index作为连接关键字,右表用id作为关键字
8. 链家Case study流程
    - pd.to_datetime() # 日期类型转换
    - df.drop(droplist, inplace=True, axis=1) # 删除一些列
    - aDF.describe(include='all') # 字符串变量也会同时统计
    - aDF.sort_values(by = 'xxx').tail() # 找出更新最晚的20套,但是有可能同一天超过20套
    - 如果对数据进行处理发现转换未果可能是因为数据有缺失,做异常处理,缺失值作为Nan
    - aDF.nsmallest(columns='age', n=20) # 取出年龄最小的20个数据
    - groupby().agg() 之后一般会使用reset_index() 对数据进行归置然后再进行操作,ascending=False
    - adf.value_counts(normalize=True) # 默认是按照value进行排序的
    - aDF.apply(lambda x: 'xxx' in x) # 筛选出xxx在某列的值中与否,返回Ture, False，正则表达式的字符串匹配
    - 可以定义正则表达式对文本信息进行提取
        def get_info(s, pattern, n):
            result = re.search(pattern, s)
            if result:
                return result.group(n)
            else:
                return ''
    - .astype(int) # 转换pd类型
    - help(pd.Series.value_counts) # 打印帮助文档

1. pandas 绘图
    - pd.date_range('2018/12/28', periods=10) # 产生日期格式, 以2018/12/28为起始产生以天为单位的日期时间list
    - pandas绘图需要把横坐标作为index,之后再画图
    - 折线图绘制需要注意各列幅度，否则数值不明显
    - df.plot.bar() # barplot, stacked=True, 堆叠
    - df.plot.barh() # 绘制水平的barplot
    - df.plot.hist(bins = 20) # 绘制直方图,单维度
    - df.plot.box() # 对每列去看一些分布outlier
    - df.plot.area # 堆叠区域图
    - df.plot.scatter(x='a', y='b') # 散点图
    - df.plot.pie(subplots=True) # 绘制带图例的饼图
    
2. matplotlib 绘图
    - plt.rcParams['figure.figsize'] = (12,8) / plt.figure(figsize=(12,8)) # 设置画布大小
    - ax = plt.plot(x,y,color='green', linewidth='-', marker='./*/x', label=r'$y=cos{x}$'/r'$y=sin{x}$'/r'$y=\sqrt{x}$') # 绘图
    - ax.spines['right'].set_color('none') # 去掉右边的边框
    - ax.xaxis.set_ticks_position('bottem') # ??????????????
    - plt.xticks([2,4,6], [r'a',r'b',r'c']) # 设置坐标轴刻度
    - ax.spines['bottem'].set_position('data', 0)  # 设置坐标轴从0开始
    - plt.xlim(1,3) # 设置坐标位置
    - plt.title() # 标题
    - plt.xlabel(r'xxx', fontsize=18, labelpad=12.5) # 绘制label, r值的是不转义的,$$值的是markdown格式
    - plt.text(0.8, 0.9, r'$$', color='k', fontsize=15) # 进行注解
    - plt.scatter([8], [8], 50, color='m') # 在某个位置,点有多大,颜色是什么
    - plt.annotate(r'$xxx$', xy=(8,8), xytext=(8.2, 8.2), fontsize=16, color='m', arrowprops=dict(arrowstyle='->', connectionstyle='arc3, rad=0.1', color='m')) # 对某个点进行注解, 进行加箭头等等
    - plt.grid(True) # 网格线 
    - plt.plot(x, y) # xy应为np array,如果是pandas那么可以通过values进行取值转换
3. matplotlib 绘图case
    - 文件解压
        x = zipfile.ZipFile(xxx, 'r') # 解压文件夹
        x.extractall('xxxdir') # 解压到某个文件夹下
        x.close() # 记得关闭
    - matplotlib.rc('figure', figsize=(14,7)) # 设置一下图片尺寸
    - matplotlib.rc('font', size=14) # 设置字体
    - matplotlib.rc('axes.spines', top=False, right=False) # 设置边线
    - matplotlib.rc('axes', grid=False) # 设置网格
    - matplotlib.rc('axes', facecolor='white') # 设置颜色
    - fig,ax含义
        fig,ax = plt.subplots() # 创建绘图对象之后对ax进行操作，相当于先fig=plt.figure()再ax=fig.add_subplot(1,1,1)
        https://blog.csdn.net/htuhxf/article/details/82986440
    - ax.fill_between(x, low, upper, alpha=) # 对回归进行置信度绘制
    - ax2 = ax1.twinx() # 共享同一个x轴
    - ax2.spines['right'].set_visible(True) # 对右侧坐标轴进行设置,得到相应的图
    - 图的使用
        关联分析:散点图,曲线图,置信区间曲线图,双坐标曲线图
        分布分析:堆叠直方图, 密度图
        组间分析:柱状图(带errorbar),boxplot,这个需要多看看,
        
 4. seaborn 绘图
    - 引入seaborn的同时也要引入matplotlib因为,是底层
    - 颜色设置
        sns.set(color_codes=True) # 一些集成的颜色
        https://seaborn.pydata.org/tutorial/color_palettes.html
    - sns.displot(x, kde=True, bins=20, rug=True, fit=stats.gamma) # histgram加密度线,样本分布情况, 拟合某些分布fit
    - sns.kdeplot # 类似于上面的,kde是每个样本用正态分布画,如果样本多,高度就高,之后再做归一化
    - sns.jointplot(x,y,data) # 绘制带有histgram以及散点图的图，两个变量
    - sns.pairplot(df) # 直接绘制各个列之间的散点图以及对应的histgram，多个变量
    - scatter plot的密度版
        with sns.axes_style('ticks'):
            sns.jointplot(x,y,data, kind='hex'/'kde',color='m') #相当于对点很多的时候,六角箱图就能体现出点的多少,kde是等高线,密度联合分布
    - 多图绘制1
        g = sns.PairGrik(df) # 各个列混合,产出n*n个格子
        g.map_diag(sns.kdeplot) # 对角线绘制
        g.map_offdiag(sns.kdeplot, cmap='Blues_d', n_levels=20) # 绘制对角线是kde密度图其他为等高线的图
    - 多图绘制2
        g = FaceGrid(row=[..],aspect=1.5, data=)
        g.map(sns.boxplot, x, y, hue, hue_order=[], ...)
    - 多图绘制3
        g = sns.PairGrid(data, x_vars=[], y_vars=[], aspect=0.5, size=3.5)
        g.map(sns.violinplot, palette='bright') # x_vars数量*y_vars数量个子图，然后每个子图都绘制violinplot
    - 关联分析 sns.lmplot
        · sns.lmplot(x, y, data) # 散点图+线性回归,95%置信区间,适用于连续值
        · sns.lmplot(x, y, data, x_jitter=0.08) # 左右抖动, 点如果离得近,会把点左右抖动开,适用于离散值
        · sns.lmplot(x, y, data, x_estimator=np.mean, ci=95, scatter_kws={'s':80}, order=2, robust=True) # 对于离散值还可以这样操作,先求均值和95置信区间,之后再进行拟合, scatter_kws对点进行操作,order是说对数据点进行二次方的分布,而不是线性分布,robust打开的作用是踢除异常点,然后再进行绘制图
        · sns.lmplot(x, y, data, x_estimator=np.mean, ci=95, scatter_kws={'s':80}, order=1, robust=True, logistic=True) # 相当于是说对二值化的数据进行logistic回归拟合,sigmoid拟合
        · sns.lmplot(x, y, data, hue, col, row, col_wrap, aspect=0.5) # 散点图.线性回归,95%置信区间,适用于连续值,hue进行分组类似于pandas里面的groupby, hue变量一定是个离散变量, col也可以加一个变量,可以把图分成多列,row可以多行,如果row,col以及hue都指定,那么相当于在pandas里面groupby三个内容,col_wrap用于之指定每个col中的绘图数量
    - sns.residplot() # 残差图
    - sns.barplot(x,y,hue,ci=None)  # 是否打开置信区间
    - sns.stripplot(x, y, data, jitter =True) # 基于x为离散数据的,类似于散点图的boxplot
    - sns.swarmplot(x, y, data) #  蜂群图，类似于小提琴图的点版
    - sns.boxplot()
    - sns.violinplot(bw) # 属于kde以及boxplot的组合，既看了单变量分布，也看了各变量之间的差异
    - sns.violinplot(split=True， hue， inner='stick') # split将hue为两个类型的进行拼接绘制小提琴图，stick，每个样本绘制竖线
    - sns.countplot(x, data) # 绘制离散变量数量分布，类似于value_counts()，类似于barplot但是使用的统计量是数量
    - sns.pointplot(x, y, hue) # 查看离散变量x以及hue在离散变量y上的差别，使用均值，画点
    - sns.factorplot(x, y, hue, col, data, kind='swarm') # 是一种泛化的绘图函数
    - a.savefig('xx') # 进行图片存储 plt函数

为实现一些快捷操作，提升效率。notebook中提供magic开关，能极大的优化使用notebook的体验。
magic开关分为两大类：%line magic & %%cell magic

jupyter_contrib_nbextensions
直接安装官网conda命令安装即可
conda install jupyter notebook
conda install -c conda-forge jupyter_contrib_nbextensions 
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple autopep8 
pip安装加速镜像:https://www.cnblogs.com/microman/p/6107879.html
jupyter 使用参考资料:https://zhuanlan.zhihu.com/p/33105153
jupyter extension 参考资料:https://zhuanlan.zhihu.com/p/52890101

!head -n 5 xx.txt # 直接通过jupyter行使linux命令

python语言是一种面向对象、动态数据类型的解释型语言
1.运行方式
    解释运行:直接py脚本运行
    交互运行:jupyter输入一个输出一个

2.命名规则:
    常量大写，下划线隔开单词
    类用驼峰命名
     del xx 删除变量xx

3.操作优先级：
    函数调用，寻址，下标
    幂运算
    翻转运算符
    正负号
    * / %
    - + 
4.赋值
    多重赋值:a=b=10相当于a=10,b=10
    多元赋值 a,b,c = 1,2,3
    交换赋值 a,b = b,a # 指针

5.解包(需要拓展 参考:https://zhuanlan.zhihu.com/p/33896402?utm_source=wechat_session&utm_medium=social&s_r=0)
    l1 = [1,2,3,4,5,'6']; a,b,*c,d = l1
    l1=[1,2,3,4];b='sdaad';[*l1,*b]
    b,=[[3,4,5]] # 逗号解包 

6.python进制及基本类型
    bin() 二进制
    oct() 八进制
    hex() 十六进制

    float('inf') 正无穷

#行内注释
""" """多行注释
？内省，显示对象的通用信息
？？内省，显示出大部分函数的源代码
help()显示一个对象的帮助文档
%timeit 魔法命令，计算语句的平均执行时间
type（x）查看变量x的数据类型
in(x) 将变量x的数据类型转换为整型
isinstance(x,float)检测变量x是否为浮点型，返回一个布尔型数值

s=u" "定义Unicode字符串
s=r" "定义原始字符串，避免字符串中的字符串转义，在正则表达式中经常使用到
len(s)返回s字符串的字数
s.lower()字母全部转为小写
s.upper()字母全部转为大写
s.capitalize()将字符串s中的首个字符转换为大写，其余部分转换为小写
s.replace('k','l')使用字符"l"替换掉s中所有的字符"k",返回结果是cooldata
s.strip()去掉s最前面和最后面的空格
s.split("\t")使用制表符"\t"分割字符串
'%s is No.%d'%(s,1)格式化
'{} is No.{}'.format(s,1)格式化

list()空列表
l[-1]返回列表的最后一个元素
l[1:3]返回列表的第二个和第三个元素
len(l)返回列表长度
l[::-1]将列表进行逆序排列
l.reverse()将列表进行逆序排列
l.insert(1,"b")在指定的索引位置插入'b'
l.append()在列表末尾添加元素
l.extend()等价于"1+L"，将列表L中的元素依次添加到1的末尾
l.remove()删除列表中的某个元素
l.pop()等价于del l[]，删除列表中对应索引位置的元素
" ".join([''c,'o','o','k'])将列表中的各个字符串元素用空格连接起来并转换为字符串，返回结果为cook

if condition1:
		statement1
elif condition2:
		statement2
else:
		statement3
		
for item in sequence:
		statement
		
while condition:
		statement
		
range(5)产生一个从0到5且间隔为1的整数列表[0，1，2，3，4]
break从最内层for循环或while循环中跳出
continue继续执行下一次循环
pass占位符

for i,item in emumerate(l)在每一次循环时取出索引号和相应的值分别赋给和item
s={item**2 for item in l}集合推导式，对l中的每一个元素取平方得到的新集合
D={key:value for key,value in zip(l,k)}字典推导式，通过zip()函数将两个列表l和k中的元素组成键对并形成字典
enumerate(list/set, start=0) # 遍历元素，start指定从哪个数字作为开始下标
c = list(zip(a,b))
c = set(zip(a,b))
c = dict(zip(a,b))
list(zip(*c)) # 解压

L=[item**2 for item in l]列表推导式，对l中每一个元素取平方得到新的列表
S={item**2 for item in l}集合推导式，对l中的每一个元素取平方得到新的集合
D={key:value for key,value in zip(l,k)}字典推导式，通过zip()函数将两个列表l和k中的元素组成键值对并形成字典
[i for i in range(30) if 1%2==0] # 取0-29之间偶数
[function(i) for i in range(30) if 1%2==0] # function可以自己定义
[ x**2 if x%2 ==0 else x**3 for x in range(10)] # 两个条件

读取文件
f=open(filename,mode)返回一个文件对象f，读文件"mode=r",写文件"mode=w"
f.read(size)返回包含前size个字符的字符串
f.readline()每次读取一行，返回该行字符串
f.readlines()返回包含每个文件内容的列表，列表的元素为文件的每一行内容所构成的字符串
f.close()关闭文件并释放它所占用的系统资源
with open("aa.txt","r") as f:
		content = f.readlines()
在with主体块语句执行完后，自动关闭文件并释放占用的系统资源
import csv
f=open("aa.csv","r")
csvreader = csv.reader(f)
content_list=list(csvreader)
读取csv文件，并把数据存储为一个嵌套列表(列表的元素扔是一个对象)content_list

写入文件
f.write(s)
print(s,file=f)
两种等价的方式，将字符串s写入文件对象f中

def sum(a,b=1)
		return a+b
def sum(*args,**kwargs)不定长参数，*args接收包含多个位置参数的元组，**kwargs接收包含多个关键字参数的字典。
obj.methodname一个方法是一个"属于"对象并被命名为obj.methodname的函数

map(func,sequence)将函数依次作用在序列的每个元素上，把结果作为一个新的序列返回。
lambda a,b:a+b匿名函数，正常函数定义的语法糖
lambda [参数列表]:表达式
例如: sum = lambda x,y:x+y # 可以有多个参数,返回只能有一个式子
可以作为一个函数的参数赋给另外一个参数
当然普通函数也可以作为参数传入
a = [{'name':'ss','age':10},{'name':'yy','age':7},{'name':'zz','age':15}] # 将匿名函数作为参数传入第三方函数的参数
a.sort(key=lambda x:x['age']) # sort方法需要传入一个key，这个key可以作为排序依据，lambda可以提取每个元素，并对元素排列
a.sort(key=lambda x:x['age']， reverse=True) # 降序

包是一个文件夹
模块是不同的python文件
import package.module.func()
import package1.module1, package2.module1 # 多个模块调用
import package1.module1 as p1m1 # 对模块进行重命名使用
from package.module import func1 # 调用某个包某个模块的某个函数
import sys;sys.path # 搜索模块路径，包含当前文件夹
package.module.__file__ # 可以确定当前的模块所在的路径
__init__.py  #在包被加载的时候，会被执行。在一个包下面可以有也可以没有__init__.py
from package import * # 引用包下面所有的模块都加载，自动搜索是不会发生的，
    需要我们在__init__.py下进行定义才可以实现,定义的内容是__all__=["module1","module2"],
    将package下的module1和module2都加载进来
    如果想直接加载某个函数，在__init__.py里面加入from .module1 import func1, __all__=["func1"]
    这样修改完之后，可以直接from package import *，然后直接调用func1即可，不用带package.module
    restart kernel
如果想要直接引用包,如：import package,这样的话，需要一定要有__init__.py，否则会在打印package.__file__的时候报错。
注意import package和from package import *效果相同

字典的继承类
set dict list tuple 作为key
from collection import Counter # 导入
cnt = Counter()
for i in [1,1,2,2,2,3]:
    cnt[i] += 1
print cnt
如果用key的话会报错先做第一次初始化才行
cnt2 = Counter(alist)  #可以统计每个元素出现的次数（字符串，set,list,）
Counter(cat=4,dogs=8,abc=-1) # 初始化counter次数，或者用dictionary构建
Counter({'cat':4,'dogs':8,'abc':-1})
Counter返回一个字典，如果缺失的话会返回0
del cnt2['xx']
.values()
list(cnt),set(cnt),dict(cnt) # 前两个只返回key
cnt.most_common()[0] # 对出现次数排序
cnt.clear()
cnt1+cnt2 # 对于key相同的value做加法，如果为0则不保留
cnt1-cnt2 # 对于key相同的value做减法
& # 求key相同value的最小值
| # 求key相同value的最大值

import random #引入
random.random() # 0-1
random.uniform(1,10) # 包含1，10的浮点数
random.randint(1,10)  # 包含1，10的整数
random.randrange(0,20,3) # 0-20能被3整除的数
random.choice([1,2,3]) # 随机取元素
random.choice("qwdwq") # 随机取元素
random.shuffle([12,3,1,4,2,3]) # 混洗
random.sample([1,2,3,4,5], 3) # 从前面的list中选3个

import chardet
chardet.detect(s)
检测字符串的编码方式

try:
		statement
except:
		pass

try:
		statement
except Exception as e:
		print(e)

try:
		statement
except (Exception1,Exception2) as e:
		statement1
else:
		statement2
finally:
		statement3#无论对错都运行
抛出异常
raise Exception('Oops！')
assert statement,e#若继续运行代码、否则抛出e的错误提示信息

import re
raw_s=r'\d{17}[\d|x]|\d{15}'
pattern=re.compile(raw_s)
re.search(pattern,s)
用于匹配身份证号
首先使用原始字符串定义正则表达式；然后编译原始字符为正则表达式Pattern对象；最后对整个字符串s进行模式搜索，如果模式匹配，则返回MatchObject的实例，如果该字符串没有模式匹配，则返回弄none
re.search(r'\d{17}[\d|x]|\d{15}',s)将Pattern编译过程与搜索过程合二为一
re.match(pattern,s)从字符串s的起始位置匹配一个模式，如果匹配不成功返回None
re.findall(pattern,s)返回一个包含所有满足条件的字串列表
re.sub(pattern,repl,s)使用替换字符串repl替换匹配到的字符串
re.split(pattern,s)利用满足匹配模式的字符串将字符串s分隔开，并返回一个列表

1.正则表达式的match与search区别
    https://segmentfault.com/a/1190000006736033

2.贪婪匹配与非贪婪匹配的区别
    https://segmentfault.com/a/1190000002640851
    https://blog.csdn.net/lxcnn/article/details/4756030

3. 练习网站
    https://alf.nu/RegexGolf 一个正则表达式练习网站
    https://regexr.com/ 验证网站

4. 单字符匹配
    . # 匹配出点换行符之外的任意字符
    \. # 匹配单个.字符
    [abd] # 匹配a/b/d单个字符
    \d # 匹配数字, 相当于[1,2,3,4,5,6,7,8,9]
    \D # 所有非字符
    \s # 空白符,空格 tab等等
    \S # 所有非空格
    \w # a-z,A-Z,0-9,_
    \W # 除了 a-z,A-Z,0-9

5. 数量词用来多匹配
    m{2} # 表示匹配两个m
    m{2,4} # 表示匹配2/3/4个m,贪婪匹配
    m* # 0个或者更多个,贪婪匹配
    m+ # 1个或者更多个,贪婪匹配
    m? # 0个或者1个
    ^xx # 文本开头是xx进行匹配
    xxx$ # 对结尾进行匹配
    (re)su(lt) # group

6. python中的正则表达式步骤
    写一个文本pattern
    进行匹配
    对匹配的文本进行后续操作
    例子:
        import re
        pattern = re.compile(r'hello.*\!') # hello后面有若干个字符串直到有!
        match = pattern.match('hello, xxx! how are you?') # 对文本进行匹配
        if match: # 是否匹配
            print match.group() # 如果匹配上了返回相应的匹配到的部分

7. 使用实例
    import re
    re.compile(r"""
    \d+ # 数字部分
    \. # 小数点
    \d # 小数部分
    """, re.X)
    这种模式下可以写注解
    re.compile(r"\d+\.\d") # 与这个模式结果一样

8.一些命令
    match # 一次匹配结果,从头匹配,开头没有就匹配不上了
    search # 所有匹配到的
    findall # search返回第一个匹配的结果,findall会返回所有的结果
    m=re.match()
    m.string # 匹配的字符串
    m.group(1,2) # 匹配1和2处字符串

9. 替换和分割
     split也可以使用正则表达式进行分割
        p = re.compile(r'\d+')
        p.split('adwdwad1dawwd23dwadw') # 字符串复杂分割
    sub # 用来替换
        p = re.compile(r'(\w+) (\w+)')
        p.sub(r'\2 \1', s) # 匹配字符串并且在匹配到的字符串处进行前后颠倒 
    subn # 和sub类似,只不过除了返回替换的远足之外,还返回相应的替换次数,可以p.subn(afunc, s), afunc可以自己定义

from datetime import datetimes
format="%Y-%m-%d %H:%M:%S"指定日期格式
date_s=datetime.striptime(s,format)
date_s.year
date_s.month
date_s.now()

# encoding: UTF-8
import re
 
# 将正则表达式编译成Pattern对象
pattern = re.compile(r'hello.*\!')
 
# 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
match = pattern.match('hello, hanxiaoyang! How are you?')
 
if match:
    # 使用Match获得分组信息
    print match.group()

hello, hanxiaoyang!

regex_1 = re.compile(r"""\d +  # 数字部分
                         \.    # 小数点部分
                         \d *  # 小数的数字部分""", re.X)
regex_2 = re.compile(r"\d+\.\d*")

import re
m = re.match(r'(\w+) (\w+)(?P<sign>.*)', 'hello hanxiaoyang!')
 
print "m.string:", m.string
print "m.re:", m.re
print "m.pos:", m.pos
print "m.endpos:", m.endpos
print "m.lastindex:", m.lastindex
print "m.lastgroup:", m.lastgroup
 
print "m.group(1,2):", m.group(1, 2)
print "m.groups():", m.groups()
print "m.groupdict():", m.groupdict()
print "m.start(2):", m.start(2)
print "m.end(2):", m.end(2)
print "m.span(2):", m.span(2)
print r"m.expand(r'\2 \1\3'):", m.expand(r'\2 \1\3')

m.string: hello hanxiaoyang!
m.re: <_sre.SRE_Pattern object at 0x10b111be0>
m.pos: 0
m.endpos: 18
m.lastindex: 3
m.lastgroup: sign
m.group(1,2): ('hello', 'hanxiaoyang')
m.groups(): ('hello', 'hanxiaoyang', '!')
m.groupdict(): {'sign': '!'}
m.start(2): 6
m.end(2): 17
m.span(2): (6, 17)
m.expand(r'\2 \1\3'): hanxiaoyang hello!

import re
p = re.compile(r'(\w+) (\w+)(?P<sign>.*)', re.DOTALL)
 
print "p.pattern:", p.pattern
print "p.flags:", p.flags
print "p.groups:", p.groups
print "p.groupindex:", p.groupindex

p.pattern: (\w+) (\w+)(?P<sign>.*)
p.flags: 16
p.groups: 3
p.groupindex: {'sign': 3}

# encoding: UTF-8 
import re 
 
# 将正则表达式编译成Pattern对象 
pattern = re.compile(r'H.*g') 
 
# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None 
# 这个例子中使用match()无法成功匹配 
match = pattern.search('hello Hanxiaoyang!') 
 
if match: 
    # 使用Match获得分组信息 
    print match.group()

Hanxiaoyang

import re
 
p = re.compile(r'\d+')
print p.split('one1two2three3four4')

['one', 'two', 'three', 'four', '']

import re
 
p = re.compile(r'\d+')
print p.findall('one1two2three3four4')

['1', '2', '3', '4']

import re
 
p = re.compile(r'\d+')
for m in p.finditer('one1two2three3four4'):
    print m.group()

1
2
3
4

import re
 
p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello hanxiaoyang!'
 
print p.sub(r'\2 \1', s)
 
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
 
print p.sub(func, s)

say i, hanxiaoyang hello!
I Say, Hello Hanxiaoyang!

import re
 
p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello hanxiaoyang!'
 
print p.subn(r'\2 \1', s)
 
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
 
print p.subn(func, s)

('say i, hanxiaoyang hello!', 2)
('I Say, Hello Hanxiaoyang!', 2)

Building prefix dict from the default dictionary ...
Loading model from cache /var/folders/pn/xp31896922n9rqxgftrqk3l00000gn/T/jieba.cache
Loading model cost 0.496 seconds.

<generator object cut at 0x10bbd91e0>

Prefix dict has been built succesfully.

Full Mode: 我/ 在/ 学习/ 自然/ 自然语言/ 语言/ 处理
Default Mode: 我/ 在/ 学习/ 自然语言/ 处理
他, 毕业, 于, 上海交通大学, ，, 在, 百度, 深度, 学习, 研究院, 进行, 研究
小明, 硕士, 毕业, 于, 中国, 科学, 学院, 科学院, 中国科学院, 计算, 计算所, ，, 后, 在, 哈佛, 大学, 哈佛大学, 深造

print('/'.join(jieba.cut('如果放到旧字典中将出错。', HMM=False)))

如果/放到/旧/字典/中将/出错/。

jieba.suggest_freq(('中', '将'), True)

494

print('/'.join(jieba.cut('如果放到旧字典中将出错。', HMM=False)))

如果/放到/旧/字典/中/将/出错/。

import jieba.analyse as analyse
lines = open('NBA.txt').read()
print "  ".join(analyse.extract_tags(lines, topK=20, withWeight=False, allowPOS=()))

韦少  杜兰特  全明星  全明星赛  MVP  威少  正赛  科尔  投篮  勇士  球员  斯布鲁克  更衣柜  张卫平  三连庄  NBA  西部  指导  雷霆  明星队

lines = open(u'西游记.txt').read()
print "  ".join(analyse.extract_tags(lines, topK=20, withWeight=False, allowPOS=()))

行者  八戒  师父  三藏  唐僧  大圣  沙僧  妖精  菩萨  和尚  那怪  那里  长老  呆子  徒弟  怎么  不知  老孙  国王  一个

全明星赛  勇士  正赛  指导  对方  投篮  球员  没有  出现  时间  威少  认为  看来  结果  相隔  助攻  现场  三连庄  介绍  嘉宾
---------------------我是分割线----------------
勇士  正赛  全明星赛  指导  投篮  玩命  时间  对方  现场  结果  球员  嘉宾  时候  全队  主持人  特点  大伙  肥皂剧  全程  快船队

lines = open(u'西游记.txt').read()
print "  ".join(analyse.textrank(lines, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v')))

行者  师父  八戒  三藏  大圣  不知  菩萨  妖精  只见  长老  国王  却说  呆子  徒弟  小妖  出来  不得  不见  不能  师徒

我 r
爱 v
自然语言 l
处理 v

并行分词速度为 830619.50933 bytes/second
非并行分词速度为 259941.448353 bytes/second