• 官方tutor教程
• Interactive Vim tutorial (openvim.com)
• Learn VIM while playing a game - VIM Adventures

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

========= basic ==========
left : h
right : l
up : k
down : j
undo the previous motion: u
undo the previous motion of the line : U
undo undo : ctrl+R
word : w
end : e
insert : i
append : a
paste : p
replace a char ：r
replace a word : R
copy a word: yw  (paste is p!!)
copy some words : v+y
show the numbers of line : set number
to the line end : $
command prompt : ctrl + d  / tab
($ is means the end of the line)
(w is means word)
(e is means end) 
======== delete ========== d+motion
delete a char: x
delete to word : dw
delete to end : de
left delete : dj
right delete : dl
delete to line : d$
delete line : dd
======= number to execute =====
move to second word : 2w
move to second word end : 2e
to the end of the line : 0
delete 2 words : d2w
delete 2 lines : 2dd
======= the command of place =====
delete a line and paste it below the current line : dd + p
replace a word : r + word
change a word to the end of the word : cw/ce
change to the end of the row : c$
change to second word : c2w
======= location and file status =====
go to the first line : gg
go to the last line : G
show file status : ctrl+g
====== search command ==========
search word in order :  /+word (n:next one ;N:the previous one)
search word in reverse : ?+word
find matched brackets(查找匹配的括号) : %
replace word in this line : :/s/oldword/newword
replace word all : :/s/oldword/newword/g
replace word all and confirm everyone :  :/s/oldword/newword/gc
replace word between line1 and line3 : :1,3/oldword/newword/g
====== others =========
use external instruction in vim : :!+commad(eg: :!ls)
save file in another file : :w+filename(eg: :w test)
merge other file in this file : :r + filename(insert to now location)           
insert mode
insert line under the line : o
insert line upon the line : O

前几天在跑一个程序的时候遇到了一个很诡异的事情，在dolphinSchedule上面上线了几天的一个程序突然挂掉了，查看问题原因总是报连接超时。无从下手，然后查看代码发现是同事写的代码有一个分区的bug，改掉了但是运行到程序的一个关联操作的地方还是连接超时，然后直接就死掉了。感觉很诡异，因为程序运行了几天没问题，说明代码可能是没问题的，然后计算的数据是一年的数据，猜想可能是数据量的变化出现的问题。

2 问题详情

2.1 报错信息

• 具体信息

1
2
3
4
5
6
7
8
9
10
11
12

Traceback (most recent call last):
  File "LineLossRate.py", line 237, in <module>
    dfjoin.show(5)
  File "/opt/cloudera/parcels/SPARK2-2.4.0.cloudera2-1.cdh5.13.3.p0.1041012/lib/spark2/python/lib/pyspark.zip/pyspark/sql/dataframe.py", line 378, in show
  File "/opt/cloudera/parcels/SPARK2-2.4.0.cloudera2-1.cdh5.13.3.p0.1041012/lib/spark2/python/lib/py4j-0.10.7-src.zip/py4j/java_gateway.py", line 1257, in __call__
  File "/opt/cloudera/parcels/SPARK2-2.4.0.cloudera2-1.cdh5.13.3.p0.1041012/lib/spark2/python/lib/pyspark.zip/pyspark/sql/utils.py", line 63, in deco
  File "/opt/cloudera/parcels/SPARK2-2.4.0.cloudera2-1.cdh5.13.3.p0.1041012/lib/spark2/python/lib/py4j-0.10.7-src.zip/py4j/protocol.py", line 328, in get_return_value
py4j.protocol.Py4JJavaError: An error occurred while calling o409.showString.
: org.apache.spark.SparkException: Could not execute broadcast in 1800 secs. You can increase the timeout for broadcasts via spark.sql.broadcastTimeout or disable broadcast join by setting spark.sql.autoBroadcastJoinThreshold to -1
at org.apache.spark.sql.execution.exchange.BroadcastExchangeExec.doExecuteBroadcast(BroadcastExchangeExec.scala:150)
at org.apache.spark.sql.execution.InputAdapter.doExecuteBroadcast(WholeStageCodegenExec.scala:387)
at org.apache.spark.sql.execution.SparkPlan$$anonfun$executeBroadcast$1.apply(SparkPlan.scala:144)

在其他节点上显示有一些重复连接超时的警告：

1
2
3
4
5
6
7
8
9
10
11

21/07/02 19:13:42 WARN scheduler.TaskSetManager: Lost task 9.0 in stage 70.0 (TID 5771, cdh06.nari.com, executor 12): java.net.ConnectException: Connection timed out (Connection timed out)
at java.net.PlainSocketImpl.socketConnect(Native Method)
at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:350)
at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:206)
at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:188)
at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)
at java.net.Socket.connect(Socket.java:589)
at java.net.Socket.connect(Socket.java:538)
at java.net.Socket.<init>(Socket.java:434)
at java.net.Socket.<init>(Socket.java:244)
at org.apache.spark.api.python.PythonWorkerFact

2.2 报错代码

1
2
3
4
5
6
7
8

dfjoin=df365.join(resDf3,on=["xx"]).\
    withColumn("xx",F.lit(dateMyes)). \
    withColumn("xx", F.expr("cast(`xx` as string)")).join(tg_id,on=["xx"]).\
    withColumnRenamed("xx","xx").\
    select("xx","xx","xx""xx""xx""xx""xx").persist()

dfjoin.show(5)
dfjoin.coalesce(128).write.mode("append").partitionBy("XXX").format("parquet").saveAsTable("tableName")

3 问题刨析

从报错的信息中基本可以定位问题出现在数据join的位置，但是其中的两个dataframe，resDf3和df365数据量都在十几万也并不是很大。但是从这句话中可以看出也是join的问题，建议我们关闭BroadcastJoin。然后大致可以清楚了，BroadcastJoin是关联一个大表和一个小表的方法，但是这里关联的两个表数据量基本相同，如果使用BroadcastJoin的话就可能导致广播时间过长而连接超时，初步猜想问题的原因就在于此。

1

You can increase the timeout for broadcasts via spark.sql.broadcastTimeout or disable broadcast join by setting spark.sql.autoBroadcastJoinThreshold to -1

于是添加了spark.sql.autoBroadcastJoinThreshold参数为-1，程序正常运行，问题解决。

4 扩展延伸：spark的三种join方式

文章参考链接：SparkSQL – 有必要坐下来聊聊Join – 有态度的HBase/Spark/BigData (hbasefly.com)

这里是对该文章内的信息转载并做一个简要的摘录：

当前SparkSQL支持三种Join算法－shuffle hash join、broadcast hash join以及sort merge join。其中前两者归根到底都属于hash join，只不过在hash join之前需要先shuffle还是先broadcast。

4.1 Hash Join

先来看看这样一条SQL语句：select * from order,item where item.id = order.i_id，很简单一个Join节点，参与join的两张表是item和order，join key分别是item.id以及order.i_id。现在假设这个Join采用的是hash join算法，整个过程会经历三步：

1. 确定Build Table以及Probe Table：这个概念比较重要，Build Table使用join key构建Hash Table，而Probe Table使用join key进行探测，探测成功就可以join在一起。通常情况下，小表会作为Build Table，大表作为Probe Table。此事例中item为Build Table，order为Probe Table。

2. 构建Hash Table：依次读取Build Table（item）的数据，对于每一行数据根据join key（item.id）进行hash，hash到对应的Bucket，生成hash table中的一条记录。数据缓存在内存中，如果内存放不下需要dump到外存。

3. 探测：再依次扫描Probe Table（order）的数据，使用相同的hash函数映射Hash Table中的记录，映射成功之后再检查join条件（item.id = order.i_id），如果匹配成功就可以将两者join在一起

这里可能存在的疑问：

1. hash join性能如何？hash join基本都只扫描两表一次，可以认为o(a+b)

2. 为什么Build Table选择小表？因为构建的Hash Table最好能全部加载在内存，效率最高；这也决定了hash join算法只适合至少一个小表的join场景，对于两个大表的join场景并不适用；

4.1.1 Broadcast Hash Join

Broadcast Hash Join一般分为两步：

1. broadcast阶段：将小表广播分发到大表所在的所有主机。广播算法可以有很多，最简单的是先发给driver，driver再统一分发给所有executor；要不就是基于bittorrete的p2p思路；

2. hash join阶段：在每个executor上执行单机版hash join，小表映射，大表试探

SparkSQL规定broadcast hash join执行的基本条件为被广播小表必须小于参数spark.sql.autoBroadcastJoinThreshold，默认为10M

4.1.2 Shuffle Hash Join

在大数据条件下如果一张表很小，执行join操作最优的选择无疑是broadcast hash join，效率最高。但是一旦小表数据量增大，广播所需内存、带宽等资源必然就会太大，broadcast hash join就不再是最优方案。此时可以按照join key进行分区，根据key相同必然分区相同的原理，就可以将大表join分而治之，划分为很多小表的join，充分利用集群资源并行化。如下图所示，shuffle hash join也可以分为两步：

1. shuffle阶段：分别将两个表按照join key进行分区，将相同join key的记录重分布到同一节点，两张表的数据会被重分布到集群中所有节点。这个过程称为shuffle

2. hash join阶段：每个分区节点上的数据单独执行单机hash join算法。

4.2 Sort-Merge Join

sort merge join 一般分为三个步骤：

1. shuffle阶段：将两张大表根据join key进行重新分区，两张表数据会分布到整个集群，以便分布式并行处理

2. sort阶段：对单个分区节点的两表数据，分别进行排序

3. merge阶段：对排好序的两张分区表数据执行join操作。join操作很简单，分别遍历两个有序序列，碰到相同join key就merge输出，否则取更小一边

5. 再次回到问题

从上面介绍的三种join的原理可以基本确定各自所对应的应用场景，这次遇到的问题就是由于spark默认使用了broadcast join方法，然后两个join的表的数据量基本相似，所以遇到了broadcast join乱广播导致程序超时的现象。所以手动禁止该方法解决了问题。

1.1 核心组件

• Driver

将用户程序转化成任务（job）

在Executor之间执行任务调度

跟踪Executor的执行情况

通过UI站视查询运行情况

• Executor：

执行任务并返回给Driver

通过自身的Block Manager为用户程序中需要缓存的RDD提供内存式存储。RDD是直接存储在Executor中的进程内的，因此任务在运行时可以充分利用缓存数据加速运算。

• Master

资源调度和分配，集群的监控

• Worker

由Master分配任务并进行计算

• ApplicantsMaster

对Driver与Master的直接通信进行解耦合，Driver通过ApplicantsMaster与Master进行通信，监控任务的执行等任务

1.2 核心概念

• Executor和Core

Executor为提供计算的节点个数，Core为核数

• 并行度

整个集群并行执行任务的数量

1.3 其他相关

• 序列化（serialization）在计算机科学的资料处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。

2 RDD

RDD数据处理方式：类似IO流，包含装饰器设计模式。

通过每一个操作方法的输入与输出来确定数据的格式。

2.1 RDD的创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//TODO 通过内存中创建
val ints: Seq[Int] = Seq(1, 2, 3, 4)
//val value: RDD[Int] = sc.parallelize(ints)
//makeRdd方法就是parallelize方法的包装
val value: RDD[Int] = sc.makeRDD(ints)

//TODO 通过文件创建rdd
//1. 通过文件路径创建
val value: RDD[String] = sc.textFile("datas/1.txt")
//2. 通过文件夹创建
//val value: RDD[String] = sc.textFile("datas.txt")
//3. 通过文件路径通配符创建
//val value: RDD[String] = sc.textFile("datas/1*.txt")
//4. 通过hdfs文件系统路径创建
//val value: RDD[String] = sc.textFile("hdfs://linux1:8080/tmp/file.txt")     

2.1 RDD方法=>RDD算子

• 转换方法

功能的转换和封装，将旧的RDD包装成新的RDD(flatMap,map)

• 行动方法（操作方法）

触发任务的调度和作业的执行(collect)

惰性执行方法

2.1.1 RDD转换算子

2.1.1.1 Map

• Map方法

1
2
3
4
5
6
7
8
9
10

scala> val rdd = sc.makeRDD(List(1,2,3))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at makeRDD at <console>:24
scala> rdd.map{(v)=>(v*2)}.collect()
scala> rdd.map((num:Int)=>{num*2}).collect()
scala> rdd.map((num:Int)=>(num*2)).collect()
scala> rdd.map((num:Int)=>num*2).collect()
# 最简单的方法
scala> rdd.map{_*2}.collect()
scala> rdd.map(_*2).collect()
res: Array[Int] = Array(2, 4, 6)

• Map的并行计算顺序
• • 单个分区内的数据是一个一个执行的，只有前面一个数据的所有逻辑都执行完才能进行下一个数据的执行逻辑，分区内数据的执行是有序的
  • 而多个分区的数据计算是无序的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 单个分区
val value: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),**1**)
  val mapRDD: RDD[Int] = value.map(
    num => {
      println(">>>>>>>" + num)
      num
    }
  )
  val mapRDD1: RDD[Int] = mapRDD.map(
    num => {
      println("@@@@@@@@" + num)
      num
    }
  )
  mapRDD1.collect()
  # 输出结果
  >>>>>>>1
  @@@@@@@@1
  >>>>>>>2
  @@@@@@@@2
  >>>>>>>3
  @@@@@@@@3
  >>>>>>>4
  @@@@@@@@4
  # 多个分区
  val value: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
  。。。。。。。
  >>>>>>>3
  @@@@@@@@3
  >>>>>>>4
  @@@@@@@@4
  >>>>>>>1
  @@@@@@@@1
  >>>>>>>2
  @@@@@@@@2

2.1.1.2 MapPratitions

MapPratitions是对分区的数据进行操作

1
2
3
4
5
6
7
8
9
10

# 求分区的最大值
val value: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
# mapPartitions传入的是迭代器，传出的也是迭代器
   val value1: RDD[Int] = value.mapPartitions (
     iter => List(iter.max).iterator
   )
   value1.collect().foreach(println)
   # 输出
   2
   4

2.1.1.3 Map和Mappartitions的对比

map是对所有的数据串行进行操作，输入与输出个数相同

而mappartitions是分块对分区内的数据进行操作，输入与输出数据个书可以不同。

map速度慢，占用内存较少

mappartitions速度快，会长时间占用内存。

2.1.1.4 glom()方法

将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变

2.1.1.5 groupby()

groupby方法会将数据打乱并重新组合，也称之为shuffle

分区数不变

2.1.1.6 coalsce(numPartitions=num；shuffle=boolen)

当大批量数据经过处理之后，需要缩小分区数可以使用coalsce()方法修改分区数。分区数修改后，分区内的数据不会被coalsce方法打散重新组合（并且同一个分区的数据也不会被分开）。

随意使用coalsce方法可能会产生数据倾斜，如果希望使数据均衡，可以使用shuffle（使shuffle=True）。

如果需要扩大分区的话使用repartition，它是coalsce的上层实现（coalsce(numPartitions=bignum；shuffle=True)）

2.1.1.7 groupByKey和reduceByKey的区别

• groupByKey只分组，如果需要聚合需使用map
• reduceByKey包含分组和聚合两个功能
• 如果只需要分组则只能使用groupByKey

groupByKey导致数据打乱重组，数据处理的时候存在shuffle操作，数据量大的话可能会导致数据倾斜然后内存溢出。

所以在spark中shuffle操作必须落盘处理（保存在硬盘中），不能在内存中进行等待。所以shuffle操作的性能十分低。

reduceByKey可以预先在分区内将相同key的数据进行聚合，然后进行落盘再shuffle。提升了很大的性能

而groupByKey只能先打乱所有的数据再落盘聚合。

2.1.1.8 foreach

foreach是在每个exector上执行的，而collect()算子是将所有的分区数据集合在一起在执行的

1
2
3
4
5
6
7

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
// 收集后打印
rdd.map(num=>num).collect().foreach(println)
> 1 2 3 4
// 分布式打印
rdd.foreach(println)
> 3 4 1 2 

2.1.1.9 宽依赖和窄依赖

宽依赖：父rdd对一个子rdd（一对一/独生子女)

窄依赖：父rdd对多个子rdd（一对多/多生子女）

2.1.2 闭包检查

闭包的理解：使用到了外部（超出其作用域）的变量的函数称为闭包。

从计算的角度算子以外的代码都是在driver端运行，算子里的代码都是在excutor里面运行，在scala编程中经常会遇到算子内会用到算子外的数据，这样就形成了闭包的效果。如果内部需要用到外部的数据，则需要检查内部的对象能否序列化，这样的过程称为闭包检测。（如果算子内部的对象可以进行序列化，则可以对外部引用数据进行序列化传给excutor端进行计算）

3 SparkSql

3.1 DataSet和DataFrame

强类型：DataSet（每一行的类型都可能不相同，当相同时就是DateFrame）

弱类型：DataFrame（每一行的类型都相同，由第一行标识出）

https://www.jianshu.com/p/120b61aa4cee

2. 装饰器

装饰器本质上是一个 Python 函数或类，它可以让其他函数或类在不需要做任何代码修改的前提下增加额外功能，装饰器的返回值也是一个函数/类对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
先来看一个简单例子，如果你要对多个函数进行统计运行时间，不使用装饰器会是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from time import time, sleep

def fun_one():
    start = time()
    sleep(1)
    end = time()
    cost_time = end - start
    print("func one run time {}".format(cost_time))
    
def fun_two():
    start = time()
    sleep(1)
    end = time()
    cost_time = end - start
    print("func two run time {}".format(cost_time))

在每个函数里都需要获取开始时间start、结束时间end、计算耗费时间cost_time、加上一个输出语句。
使用装饰器的方法是这样的

简单装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def run_time(func):
    def wrapper():
        start = time()
        func()                  # **函数在这里运行**
        end = time()
        cost_time = end - start
        print("func three run time {}".format(cost_time))
    return wrapper

@run_time
def fun_one():
    sleep(1)
    
@run_time
def fun_two():
    sleep(1)

3.anconda升级python版本

• 先查看本地镜像源，清华镜像源从2019年已经停用了，建议使用中科大的镜像源
• 然后直接命令指定升级python版本即可，如果不升级镜像源的话可能报404或者下载速度慢

3.1 修改镜像源

先查看已经安装过的镜像源，cmd窗口执行命令：

1

conda config --show

查看配置项channels，如果显示带有tsinghua，则说明已安装过清华镜像。

1
2
3
4
5
6

channels:
- https://mirrors.tuna.tsinghua.edu.cn/tensorflow/linux/cpu/
- https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/
- https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
- https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
- https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/

下一步，使用conda config --remove channels url地址删除清华镜像，如下命令删除第一个。然后，依次删除所有镜像源

1

conda config --remove channels https://mirrors.tuna.tsinghua.edu.cn/tensorflow/linux/cpu/

添加目前可用的中科大镜像源：

1

conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/free/

并设置搜索时显示通道地址：

1

conda config --set show_channel_urls yes

确认是否安装镜像源成功，执行conda config --show，找到channels值为如下：

1
2
3

channels:
  - https://mirrors.ustc.edu.cn/anaconda/pkgs/free/
  - defaults

3.2 升级python版本

打开Anaconda Prompt，
输入

1

conda create -n python36 python=3.6 anaconda

4.文件io

4.1 文件打开方式，r/w/a/+的说明

• r只读，r+读写(覆盖写)，不创建
• w新建只写，w+新建读写，二者都会将文件内容清零
• w+与r+区别：

• r+：可读可写，若文件不存在，报错；w+: 可读可写，若文件不存在，创建

• a：附加写方式打开，不可读；
• a+: 附加读写方式打开

#5. 代码规范性测试

pylint代码规范测试

6. fileinput 懒惰行迭代

只读取实际需要的文件部分

7. 编码规范

1. 多次使用的常量使用全大写命名，并考虑设置为全局变量
2. 创建单独的配置文件模块，保存一些配置的参数

   简单配置或者使用configparser模块

3. 在需要的时候使用日志记录（logging模块）

8.魔法方法理解

魔法方法是python内置方法，不需要主动调用，存在的目的是为了给python的解释器进行调用，几乎每个魔法方法都有一个对应的内置函数，或者运算符，当我们对这个对象使用这些函数或者运算符时就会调用类中的对应魔法方法，可以理解为重写内置函数

实际上, 当我们调用x = SomeClass()的时候调用,__init__并不是第一个执行的, __new__才是。所以准确来说,是__new__和__init__共同构成了”构造函数”.

new() 是一种负责创建类实例的静态方法，它无需使用 staticmethod 装饰器修饰，且该方法会优先 init() 初始化方法被调用

9.正则表达式

##9.1 match()和search()比较

1
2
3
4
5
6
7

m = re.match('foo', 'seafood') 
m.group()
>>> None    # 匹配失败

m = re.search('foo', 'seafood') 
m.group()
>>> 'foo' # 搜索成功， 但是之前匹配失败

match是从字符串的起始部分开始匹配模式，把字符串当作一个整体来匹配，而search表示字符串中任意位置出现符合匹配模式的字符串，都将其提取出来。
##9.2 中括号（[cr][23][dp][o2]）和或运算符（r2d2|c3po）的区别

• [cr][23][dp][o2]

  上述表示匹配由四个字符组成的类似‘ABCD’字符串，每一个字符匹配一个中括号内的两个字符中的一个

• r2d2|c3po

  上述表示匹配“r2d2”或“c3po”

##9.3 使用group()或groups()访问匹配组

pattern中每一个括号为一个匹配模式，返回的结果保存在group()中，而groups()可以查看所有的子组匹配结果（如果pattern中无括号分组模式则groups为空）。

m = re.match(‘(\w\w\w)-(\d\d\d)’, ‘abc-123’)
m.group() # 完整匹配
‘abc-123’
m.group(1) # 子组 1
‘abc’
m.group(2) # 子组 2
‘123’
m.groups() # 全部子组
(‘abc’, ‘123’)

9.4 findall和search方法的区别

findall()查询字符串中某个正则表达式模式全部的非重复出现情况，和search类似，但是findall总是返回一个列表，当匹配失败时列表为空；当匹配成功时返回所有成功的匹配部分。

9.5 sub()和subn()，表示替换

sub和subn基本一样，但是subn还返回了替换的次数。

10 python多线程与多进程

参考python进程池：multiprocessing.pool - jihite - 博客园 (cnblogs.com)

10.1 总结

i/o密集型任务用多线程，多任务计算使用多进程

10.2 使用进程池

10.2.1 样例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#coding: utf-8
import multiprocessing
import time

def func(msg):
    print "msg:", msg
    time.sleep(3)
    print "end"

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 3)
    for i in xrange(4):
        msg = "hello %d" %(i)
        pool.apply_async(func, (msg, ))   #维持**同时**执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去（多通道）
   #pool.apply(func, (msg, )) # 而使用apply方法的时候是通道阻塞的，一次只有一个进程在运行，当一个进程执行完毕后再添加新的进程（单通道）
    print "Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~"
    pool.close()
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    print "Sub-process(es) done."

10.2.2 结果：

apply_async方法，多通道

1
2
3
4
5
6
7
8
9
10

mMsg: hark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~ello 0
 
msg: hello 1
msg: hello 2
end
msg: hello 3
end
end
end
Sub-process(es) done.

apply方法，单通道

1
2
3
4
5
6
7
8
9
10

msg: hello 0
end
msg: hello 1
end
msg: hello 2
end
msg: hello 3
end
Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~
Sub-process(es) done.　

11 python 集合set中 add与update的区别

集合set是一个无序不重复元素的集

1
2
3
4

set(['hello','hello','hi'])
# {'hello', 'hi'}
set('hello hello hi')
# {' ', 'e', 'h', 'i', 'l', 'o'}

set.add() 与set.update()的区别

1
2
3
4
5
6
7
8
9
10

myset1 = set()
myset1.add('hello')
#{'hello'}
myset1.update('world')
#{'d', 'hello', 'l', 'o', 'r', 'w'}

myset2 = set()
myset2.add('123')
myset2.update('123')
#{'1', '123', '2', '3'}

12. python离线环境迁移

12.1 依赖文件requirement.txt生成

1
2
3
4

# 在当前目录生成该目录下项目所需的所有依赖文件：注意生成包之后需要手动核对一下版本最好，会有部分版本生成错误的问题
pipreqs ./ --encoding=utf8
# 与pip freeze的区别
# freeze 是生成当前python环境的所有包

12.2 然后根据requirement.txt批量下载包文件

1
2
3
4

pip wheel --wheel-dir=.pip wheel --wheel-dir=./packages -r requirements.txt
# 最后一起迁移到离线环境中并进行安装
#在新服务器的site-packages目录下执行：
pip install --no-index --find-links=/xxx/xxx/packages -r /xxx/xxx/packages/requirements.txt

12.3 出现问题

使用pipreqs生成的requirement.txt无法完整安装所有的包

使用python -m pip freeze > req.txt生成依赖文件然后替换用该文件安装

13. collection方法详解

13.1 命名元组 namedtuple

使用namedtuple可以对元组中的每一个值进行命名

1
2
3
4
5
6
7

# 使用命名元组解析csv
from collections import *
import csv

EmployeeRecord = namedtuple('EmployeeRecord','name, age, title, department, paygrade')
for emp in map(EmployeeRecord._make,csv.reader(open("employee.csv","rb"))):
    print (emp.name,emp.title)

13.2 defaultdict

功能和dict差不多，区别是会对未存在的key值赋予一个默认值而不报异常

并且 defaultdict()的default_factory参数可以传入list，int，tuple等类型

1
2
3
4
5
6
7

>>> from collections import *
>>> >>> s = [('yellow',1),('blue',2),('yellow',3),('blue',4),('red',5)]
>>> d = defaultdict(list)
>>> for k,v in s: 
... d[k].append(v)
>>> d.items()
[('blue', [2, 4]), ('red', [5]), ('yellow', [1, 3])]

13.3 Counter

counter可以支持方便、快速的计数

1
2
3
4
5

>>> from collections import *

>>> cnt = Counter('aabbcc')
>>> cnt
Out[14]: Counter({'a': 2, 'b': 2, 'c': 2})

13.4 deque

deque是栈和队列的一种广义实现，deque是”double-end queue”的简称；deque支持线程安全、有效内存地以近似O(1)的性能在deque的两端插入和删除元素，尽管list也支持相似的操作，但是它主要在固定长度操作上的优化，从而在pop(0)和insert(0,v)（会改变数据的位置和大小）上有O(n)的时间复杂度。

1
2
3
4
5
6
7
8

>>> from collections import deque
>>> dq = deque(range(10), maxlen=10) 
>>> dq
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
# rotate 将循环队列向右移三次
>>> dq.rotate(3) 
>>> dq
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)

————其他—————————

• mysql/oracle

内连接是保证两个表中所有的行都要满足连接条件，而外连接则不然。在外连接中，某些不满条件的列也会显示出来，也就是说，只限制其中一个表的行，而不限制另一个表的行。分左连接、右连接、全连接三种。

• Django/Flask
• git

14 多线程，多进程，协程

程序是由多个进程组成的，然后每个进程可能有多个线程（线程更加底层）

而python由于GIL（全局解释器锁）的存在，使得多线程无法充分使用多核的优势

如果使用爬虫这种i/o密集型程序，多线程操作还是很明显的。

15 pandas操作

16 scrapy相关

17 restful api

遵循 REST 架构规范的应用编程接口

api：

客户端和服务器端信息的传递者

传输格式：

JSON（Javascript 对象表示法）、HTML、XLT、Python、PHP 或纯文本

一般常见的下划线为以下几种：

• 前置单下划线：_var
• 后置单下划线：var_
• 前置双下划线：__var
• 前后双下划线：__var__
• 单下划线：_

###1. 前置单下划线变量和单下划线方法的区别：

前置单下划线表示在方法内部使用，单下划线变量可以从外部引用，而单下划线方法在使用通配符导入包时（from package import *）不可以，除非使用import package，然后使用”package._model”进行使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Test:
    def __init__(self):
        self.foo = 11
        self._bar = 23
>>> t = Test()
>>> t.foo
11
>>> t._bar
23

# my_module.py：
def external_func():
    return 23
def _internal_func():
    return 42
>>> from my_module import *
>>> external_func()
23
>>> _internal_func()
NameError: "name '_internal_func' is not defined"

>>> import my_module
>>> my_module.external_func()
23
>>> my_module._internal_func()
42

2. 后置单下划线

当需要使用的最合适的变量名与关键字所重复，可以使用后置单下划线来绕过命名冲突

1
2
3
4
5

>>> def make_object(name, class):
SyntaxError: "invalid syntax"

>>> def make_object(name, class_):
... pass

3. 前置双下划线

前置双下划线会被解释器进行命名改写。这个例子先声明_MangledGlobal__mangled为全局变量，然后在名为MangledGlobal的类环境中访问变量。由于名称改写，类中的test()方法仅用__mangled就能引用_MangledGlobal__mangled全局变量。__mangled以双下划线开头，因此Python解释器自动将名称扩展为_MangledGlobal__mangled。这表明名称改写不专门与类属性绑定，而是能够应用于类环境中所有以双下划线开头的名称

1
2
3
4
5
6
7
8

_MangledGlobal__mangled = 23

class MangledGlobal:
    def test(self):
        return __mangled

>>> MangledGlobal().test()
23

###4. 单独单下划线

单下划线有时用作名称，来表示变量是临时的或无关紧要的

1
2
3

例如下面的循环中并不需要访问运行的索引，那么可以使用_来表示它只是一个临时值：
>>> for _ in range(32):
...     print('Hello, World.')

5.总结

• 前置单下划线_var：命名约定，用来表示该名称仅在内部使用。一般对Python解释器没有特殊含义（通配符导入除外），只能作为对程序员的提示。
• 后置单下划线var_：命名约定，用于避免与Python关键字发生命名冲突。
• 前置双下划线__var：在类环境中使用时会触发名称改写，对Python解释器有特殊含义。
• 前后双下划线__var__：表示由Python语言定义的特殊方法。在自定义的属性中要避免使用这种命名方式。
• 单下划线_：有时用作临时或无意义变量的名称（“不关心”）。此外还能表示Python REPL会话中上一个表达式的结果。

通过信息熵的大小判断某项数据在整体数据评测中所占的比重大小。

一般来说，若某个指标的信息熵Ej越小，表明指标值得变异程度越大，提供的信息量越多，在综合评价中所能起到的作用也越大，其权重也就越大。相反，某个指标的信息熵越大，表明指标值得变异程度越小，提供的信息量也越少，在综合评价中所起到的作用也越小，其权重也就越小

#2.计算步骤

2.1 数据标准化

假设给定了k个指标（类别）$X_1$,$X_2$，……，$X_i$={$x_1$,$x_2$,……},

假设对各指标数据标准化后的值为 : $Y_1$,$Y_2$….$Y_k$

则$X_{ij}$表示第$i$个指标下的第$j$个值

那么标准化的$Y_{ij}$ =$\frac{X_{ij}-min(X_{ij})}{max(X_i) - min(X_i)}$

2.2 计算各指标的信息熵

信息熵 $E_j = -\frac{1}{lnn}∑^n_{i=1}p_{ij}lnp_{ij}$

其中 $p_{ij} = \frac{Y_{ij}}{\stackrel{n}{\stackrel{∑{Y_{ij}}}{i=1}}}$

如果： $p_{ij}=0$

则：$\stackrel{lim}{p_{ij-0}} p_{ij}lnp_{ij}=0$

2.3 确定各指标权重

根据信息熵$E_j$的计算公式计算信息熵分别为$E_1,E_2,……E_k$

然后计算权重:

$W_i = \frac{1-E_i}{k-∑E_i}(i = 1,2,3….k)$

这里的分母$k-∑E_i$通过上面计算出所有的信息熵E之后为一个固定的常数。

2.4 根据权重打分

根据计算后：$X_1$,$X_2$，……，$X_i$={$x_1$,$x_2$,……}每一项指标分别对应的权重为$W_1,W_2,….W_i$

得到每个个体的得分计算为

$R_1 = X_{11}W_1+X_{21}W_2+….+X_{i1}W_i$

部分摘录

1. 线性回归

1.1 特征缩放（归一化）

1.1.1 Standardization

Standardization又称为 Z-score normalization，量化后的特征将服从标准正态分布：

z = （X_i-μ）/δ

其中， μ ， δ 分别为对应特征 x_i 的均值和标准差。量化后的特征将分布在 [−1,1] 区间

1.1.2 Min-Max Scaling

Min-Max Scaling 又称为 normalization，特征量化的公式为：

z = x_i−min(x_i) / max(x_i)−min(x_i)

量化后的特征将分布在[0,1]区间。

大多数机器学习算法中，会选择 Standardization 来进行特征缩放，但是，Min-Max Scaling 也并非会被弃置一地。在数字图像处理中，像素强度通常就会被量化到[0,1] 区间，在一般的神经网络算法中，也会要求特征被量化到 [0,1] 区间。

1.2 学习率的调节

1.2.1 梯度下降

• 批量梯度下降
• 随机梯度下降

1.2.2 正规方程

我们通过梯度下降法来求得J(θ) 的最小值，但是对于学习率α 的调节有时候使得我们非常恼火。为此，我们可通过正规方程来最小化 J(θ) ：

θ=(X^T^X)^−1^X^T^y

其中， X 为输入向量矩阵，第0 个特征表示偏置（x0=1）， y 为目标向量，仅从该表达式形式上看，我们也脱离了学习率α 的束缚。

1.3 欠拟合与过拟合

1.3.1 局部加权线性回归（LWR）

为了解决欠拟合和过拟合问题，引入了局部加权线性回归。

LWR 补充自机器学习实战一书，后续章节中我们知道，更一般地，我们使用正规化来解决过拟合问题。

2. 逻辑回归

• 逻辑回归就是解决分类问题，求决策边界

2.1 0/1 分类问题

简单的根据y值大小（类别）进行分类

2.2 逻辑回归

上一节我们知道，使用线性回归来处理 0/1 分类问题总是困难重重的，因此，人们定义了逻辑回归来完成 0/1 分类问题，逻辑一词也代表了是（1）和非（0）。

2.2.1 Sigmoid预测函数

在逻辑回归中，定义预测函数为：
h_θ(x)=g(z)

其中， z=θ^T^x 是分类边界（分类边界曲线/线），且g(z)=1 / 1+e^−z^

g(z) 称之为 Sigmoid Function，亦称 Logic Function

2.3 决策边界

决策边界，顾名思义，就是用来划清界限的边界，边界的形态可以不定，可以是点，可以是线，也可以是平面。Andrew Ng 在公开课中强调：“决策边界是预测函数 hθ(x) 的属性，而不是训练集属性”，这是因为能作出“划清”类间界限的只有h_θ(x) ，而训练集只是用来训练和调节参数的。

2.4 利用正规化解决过拟合问题

在之前的文章中，我们认识了过拟合问题,通常，我们有如下策略来解决过拟合问题：

减少特征数，显然这只是权宜之计，因为特征意味着信息，放弃特征也就等同于丢弃信息，要知道，特征的获取往往也是艰苦卓绝的。

不放弃特征，而是拉伸曲线使之更加平滑以解决过拟合问题，为了拉伸曲线，也就要弱化一些高阶项（曲线曲折的罪魁祸首）。由于高阶项中的特征 x 无法更改，因此特征是无法弱化的，我们能弱化的只有高阶项中的系数 θ_i 。我们把这种弱化称之为是对参数 θ 的惩罚（penalize）。Regularization（正规化）正是完成这样一种惩罚的“侩子手”

2.5 多分类问题

通常采用 One-vs-All，亦称 One-vs-the Rest 方法来实现多分类，其将多分类问题转化为了多次二分类问题。假定完成K个分类，One-vs-All 的执行过程如下：

• 轮流选中某一类型i，将其视为正样本，即 “1” 分类，剩下样本都看做是负样本，即 “0” 分类。
• 训练逻辑回归模型得到参数 θ^(1)^,θ^(2)^,…,θ^(K)^ ，即总共获得了K−1个决策边界。

给定输入x，为确定其分类，需要分别计算 h_θ^(k)^(x),k=1,…,K , h_θ^(k)^(x)越趋近于 1，x 越接近是第k类。

总结：ABC三类，将A当作一类，BC当作一类，得到决策边界h₁；然后将B当一类，AC当一类，得到决策边界h2，以此类推。然后将目标x_θ代入h₁,h₂,h₃中求解。哪个值越接近1，即为x₀的类别。

这里为什么条件是接近1：因为逻辑回归的归一化函数比如说上面的sigmod函数归一化的值区间为[0,1],如果h₃(x0)值为0.8表示x₀有0.8的概率为h3类别，并不是h₃(x₀)的值越大表示它的类别一定为h₃

3. 神经网络

3.1 再论 0/1 分类问题

在逻辑回归中，通过对特征进行多项式展开，可以让逻辑回归支持非线性的分类问题。
但是当数据的特征维度比较高的时候，多项式展开扩展后的特征个数是特别高的，对计算机的性能提出了很大的挑战。

比如说在计算机视觉（CV）领域，图像的特征往往都是高维的

因此，就需要考虑用新的机器学习模型来处理高维特征的非线性分类问题，神经网络是典型的不需要增加特征数目就能完成非线性分类问题的模型。

3.2 神经网络概述

3.2.1 卷积层

作用：提取图像特征

关于卷积核的选取

3.2.2 池化层

特征降维

3.2.3 全连接层

全连接的核心操作就是矩阵向量乘积：y=Wx

本质就是由一个特征空间线性变换到另一个特征空间。目标空间的任一维——也就是隐层的一个 cell——都认为会受到源空间的每一维的影响。不考虑严谨，可以说，目标向量是源向量的加权和。

在 CNN 中，全连接常出现在最后几层，用于对前面设计的特征做加权和。比如 mnist，前面的卷积和池化相当于做特征工程，后面的全连接相当于做特征加权。（卷积相当于全连接的有意弱化，按照局部视野的启发，把局部之外的弱影响直接抹为零影响；还做了一点强制，不同的局部所使用的参数居然一致。弱化使参数变少，节省计算量，又专攻局部不贪多求全；强制进一步减少参数。少即是多）

在 RNN 中，全连接用来把 embedding 空间拉到隐层空间，把隐层空间转回 label 空间等

4. 算法分析与优化

4.1 调优方法

在线性回归中，我们使用了如下的代价函数来评估预测误差：
J(θ)=1 / 2m（costFunction + 正则化表达式）

想要降低预测误差，即提高预测精度，我们往往会采用这些手段：

4.2 数据集划分

训练集：70%
测试集：30%

在对数据集进行训练集和测试集的划分前，最好先对数据集进行乱序，防止类似样本聚到一起

4.2.1 交叉验证集

在多项式回归中,我们总是尝试不同的多项式次数（degree）,形成了不同的预测模型:

y1= θ₀X

y2 = θ₀X + θ₁X^2^

y3 = θ₀X + θ₁X^2^ + θ₂X^3^

假设y₃的测试误差最小，我们选取y₃中的θ作为模型的参数。
这时参数已经有了，如何评估模型的泛化能力呢？

这时就要使用交叉验证集对模型的泛化能力进行验证。通常情况下：

• 训练集：60%，确定参数 θ
• 交叉验证集：20%，进行模型选择。
• 测试集：20%，评价模型预测能力。

1
2
3

graph LR
使用训练集得到参数θ-->使用交叉验证集对模型泛化能力进行验证可能会修改超参数θ的值
使用交叉验证集对模型泛化能力进行验证可能会修改超参数θ的值--> 使用测试集评价模型预测能力

4.3偏差与方差

在机器学习中，偏差（bias）反映了模型无法描述数据规律，而方差（variance）反映了模型对训练集过度敏感，而丢失了数据规律，高偏差和高方差都会造成新数据到来时，模型给出错误的预测。

通过诊断（Diagnose）模型是出现了高偏差问题还是高方差问题，我们能对症下药，采取不同的解决策略

4.4 问题分析方法

对于机器学习问题，吴恩达给出了一些 tips：

• 在一开始，尽量不要将问题复杂化（不要提前优化），先快速实现一个简单算法，然后通过交叉验证集评估模型。这就好比在软件工程中，不会做提前优化，而是先迭代功能。
• 通过绘制学习曲线（learning curve），确定面临的问题是高偏差还是高方差，来决定是添加更多训练样本，还是添加更多特征。
• 甚至可以手动检查交叉验证集中误差较大的样本，确定错误的来源和解决策略。

4.4.1 举个例子

假定交叉验证集有 500 个样本，即 mcv=500mcv=500 ，我们的模型错分了其中 100 个样本，那么我们会通过下述手段进行错误分析：

• 需要知道哪些邮件被错分了，是假冒伪劣的推销邮件？医药邮件？还是钓鱼邮件？
• 需要知道提供什么线索（特征）能帮助模型区分出这些邮件？

例如，在这 100 个错分样本中，我们发现有 53 个样本是钓鱼邮件，因此，我们就需要考虑为模型注入识别的钓鱼邮件的能力。继续观察，我们发现，在这 53 封钓鱼邮件中，故意使用错误拼写的邮件有 5 封，来源可疑（发送人可疑）的邮件有 16 封，使用了大量煽动性标点符号的邮件有 32 封。因此，对于识别钓鱼邮件来说，我们更适合将煽动性标点符号添加为特征，而不用再考虑去识别错误拼写。

5. SVM

常用来处理多维度不规则分类问题

5.1 大间距分类器

SVM 是典型的大间距分类器：寻找一个直线（面）将数据分类，而这个线（面）到所有点的距离之和最大。

5.2 核函数

在逻辑回归中，我们会通过多项式扩展来处理非线性分类问题：
h₀(x)=θ₀+θ₁x₁+θ₂x₂+θ₃x₁x₂+θ₄x₁^2^+θ₅x₂^2^+⋯

假设我们令：

f₁=x₁,

f₂=x₂,

f₃=x₁x₂,

f₄=x₁^2^,

f₅=x₂^2^

则预测函数为：

h_θ(x)=θ₀+θ₁f₁+θ₂f₂+θ₃f₃+⋯

但多项式回归所带来的高阶项不一定作用明显，针对这一问题，SVM 不会引入高阶项来作为新的特征，而是会选择一些标记点（landmark），并将样本x与标记点l^(i)^的相似程度作为新的训练特征f_i（将f_i作为数据集的一个属性进行训练） ：

距离度量的方式就称之为核函数（Kernel），最常见的核函数是高斯核函数（Gaussian Kernel）

5.3 svm的使用说明

5.3.1 参数和核函数

使用这些库时，我们通常需要声明 SVM 需要的两个关键部分：

• 参数 C

  由于 C 可以看做与正规化参数 λ 作用相反，则对于 C 的调节：

  低偏差，高方差，即遇到了过拟合时：减小 C 值。
  高偏差，低方差，即遇到了欠拟合时：增大 C 值。

• 核函数（Kernel）

  而对于核函数的选择有这么一些 tips：

  当特征维度n较高，而样本规模m较小时，不宜使用核函数，否则容易引起过拟合。

  当特征维度n较低，而样本规模m足够大时，考虑使用高斯核函数。不过在使用高斯核函数前，需要进行特征缩放（feature scaling）。另外，当核函数的参数δ较大时，特征f_i 较为平缓，即各个样本的特征差异变小，此时会造成欠拟合（高偏差，低方差）：

5.3.2 分类模型的选择

目前，我们学到的分类模型有：

（1）逻辑回归
（2）神经网络；
（3）SVM。

怎么选择在这三者中做出选择呢？我们考虑特征维度n及样本规模m ：

• 如果n相对于m非常大，例如例如 n=10000,m∈(10,10000) :此时选用用逻辑回归或者无核的 SVM。
• 如果n较小，m适中，如 n∈(1,1000) ，而 m∈(10,10000) ：此时选用核函数为高斯核函数的 SVM。
• 如果n较小，m 较大，如 n∈(1,1000) ，而 m>50000 ：此时，需要创建更多的特征（比如通过多项式扩展），再使用逻辑回归或者无核的 SVM。

神经网络对于上述情形都有不错的适应性，但是计算性能上较慢。

6. k-means

• 聚类算法，其中的k为簇的种类数
• 簇中心的选取：遍历随机初始化选取
• 确定聚类数：肘部法则

6.1 二分k-means

• 常规的 K-Means 算法的误差通常只能收敛到局部最小，在此，引入一种称为二分 K-Means（bisecting kmeans）的算法，相较于常规的 K-Means，二分 K-Means 不急于一来就随机K个聚类中心，而是首先把所有点归为一个簇，然后将该簇一分为二。计算各个所得簇的失真函数（即误差），选择误差最大的簇再进行划分（即最大程度地减少误差），重复该过程直至达到期望的簇数目
• 虽然二分 K-Means 能带来全局最优解，但是我们也可以看到，该算法是一个贪心算法，因此计算量不小。

7. 特征降维

• 特征降维的一般手段就是将高维特征投影到低维空间

7.1 PCA（主成分分析）

PCA，Principle Component Analysis，即主成分分析法，是特征降维的最常用手段。顾名思义，PCA 能从冗余特征中提取主要成分，在不太损失模型质量的情况下，提升了模型训练速度

8. 异常检测

8.1 高斯分布模型

异常检测的核心就在于找到一个概率模型，帮助我们知道一个样本落入正常样本中的概率，从而帮助我们区分正常和异常样本。高斯分布（Gaussian Distribution）模型就是异常检测算法最常使用的概率分布模型。

9. 推荐系统

9.1 协同过滤

• 基于用户的协同过滤推荐(User-based Collaborative Filtering Recommendation)

  基于用户的协同过滤推荐算法先使用统计技术寻找与目标用户有相同喜好的邻居，然后根据目标用户的邻居的喜好产生向目标用户的推荐。基本原理就是利用用户访问行为的相似性来互相推荐用户可能感兴趣的资源

• 基于项目的协同过滤推荐(Item-based Collaborative Filtering Recommendation)

  根据所有用户对物品或者信息的评价，发现物品和物品之间的相似度，然后根据用户的历史偏好信息将类似的物品推荐给该用户

• 基于模型的协同过滤推荐(Model-based Collaborative Filtering Recommendation)

基模型的协同过滤推荐就是基于样本的用户喜好信息，训练一个推荐模型，然后根据实时的用户喜好的信息进行预测推荐

hbase的内部使用KeyValue的形式存储，其key是rowKey：family：column：logTime，value是其存储的内容。

其在region内大多以升序的形式排列，唯一的时logTime是以降序的形式进行排列。

所以，rowKey里越靠近左边的信息越容易被检索到。其设计时，要考虑把重要的信息放左边，不重要的信息放到右边。这样可以提高查询数据的速度。最重要的提高索引速度的就是设计合适的rowKey。

在做RowKey设计时，请先考虑业务是读比写多，还是读比写少，HBase本身是为写优化的，即便是这样，也可能会出现热点问题，而如果我们读比较多的话，除了考虑以上RowKey设计原则外，还可以考虑HBase的Coprocessor甚至elasticSearch结合的方法，无论哪种方式，都建议做实际业务场景下数据的压力测试以得到最优结果。

1.1 Hbase的存储结构

1.1.1 逻辑存储结构

在本图中，列簇（Column Family）对应的值就是 info 和 area ，列（ Column 或者称为 Qualifier ）对应的就是 name 、 age 、 country 和 city ，Row key 对应的就是 Row 1 和 Row 2，Cell 对应的就是具体的值。

• Row key ：表的主键，按照字典序排序。
• 列簇：在 HBase 中，列簇将表进行横向切割。
• 列：属于某一个列簇，在 HBase 中可以进行动态的添加。
• Cell : 是指具体的 Value 。
• Version ：在这张图里面没有显示出来，这个是指版本号，用时间戳（TimeStamp ）来表示。

在 HBase 中的 KEY 组成是这样的：

KEY 的组成是以 Row key 、CF(Column Family) 、Column 和 TimeStamp 组成的。

TimeStamp 在 HBase 中充当的作用就是版本号，因为在 HBase 中有着数据多版本的特性，所以同一个 KEY 可以有多个版本的 Value 值（可以通过配置来设置多少个版本）。查询的话是默认取回最新版本的那条数据，但是也可以进行查询多个版本号的数据

1.1.2 Region Server 和 Region 的关系

• 一个 Region Server 就是一个机器节点(服务器)
• 一个 Region Server 包含着多个 Region
• 一个 Region 包含着多个列簇 (CF)
• 一个 Region Server 中可以有多张 Table，一张 Table 可以有多个 Region

1.1.3 Hbase读取数据的过程

Client 请求读取数据时，先转发到 ZK 集群，在 ZK 集群中寻找到相对应的 Region Server，再找到对应的 Region，先是查 MemStore，如果在 MemStore 中获取到数据，那么就会直接返回，否则就是再由 Region 找到对应的 Store File，从而查到具体的数据。

在整个架构中，HMaster 和 HRegion Server 可以是同一个节点上，可以有多个 HMaster 存在，但是只有一个 HMaster 在活跃。

在 Client 端会进行 rowkey-> HRegion 映射关系的缓存，降低下次寻址的压力。

1.2 HBase的存储机制

HBase是一个面向列的数据库，在表中它由行排序。表模式定义只能列族，也就是键值对。一个表有多个列族以及每一个列族可以有任意数量的列。后续列的值连续存储在磁盘上。表中的每个单元格值都具有时间戳。总之，在一个HBase：

• 表是行的集合。
• 行是列族的集合。
• 列族是列的集合。
• 列是键值对的集合。

这里的列式存储或者说面向列，其实说的是列族存储，HBase是根据列族来存储数据的。列族下面可以有非常多的列，列族在创建表的时候就必须指定。

2.HBase中建立分区（表）

2.1 为什么要建立分区表/分区表存在的意义是什么:

• 将大数据表的增加由无序变为有序

2.2 原理

在HBase中，每个表默认时都由一个Region存储原数据，但是若当数据慢慢增加时，就会将一个Region分裂成其他若干个不同的region。但是这种无序的分裂，会让后期的表扫描，表过滤操作很不方便（特别耗时）。正是着眼于未来表的改变，才有了为表创建分区的操作。
提前创建分区表为有序

1.1 python打包访问oracle数据库无instantclient相关问题

1.1.1 问题1：cx_Oracle.DatabaseError: DPI-1047: 64-bit Oracle Client library cannot be loaded解决方法”

解决方法：本机安装instantclient，安装步骤如下(参考：http://www.360doc.com/content/12/1103/21/8827884_245559524.shtml)

• 第一步，先安装Oracle客户端，结合你的情况自己找合适的版本，我下载的是 oracle-instantclient11.2-basic-11.2.0.3.0-1.x86_64.rpm
  下载地址为（http://www.oracle.com/technetwork/topics/linuxx86-64soft-092277.html）

1

rpm -ivh oracle-instantclient11.2-basic-11.2.0.3.0-1.x86_64.rpm

• 第二步，找出你的ORACLE_HOME，我安装之后在这里：/usr/lib/oracle/11.2/client64/lib/

• 第三步，下载oracle-instantclient11.2-sdk-11.2.0.1.0-1.x86_64.zip 下载地址。解压，把里面那个叫sdk的文件夹复制到 /usr/lib/oracle/11.2/client64/lib/

• 第四步，做一个软链：

1
2

$ cd /usr/lib/oracle/11.2/client64/lib/
$ ln -s libclntsh.so.11.1 libclntsh.so

• 第五步，安装cx_Oracle:

1
2
3

$ export ORACLE_HOME=/usr/lib/oracle/11.2/client64/lib
$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME
$ easy_install cx_Oracle

• 试一下：

1
2

$ python
$ import cx_Oracle

done.

• 不过还没配环境变量，一退再进去就不行了，在.bashrc里加入刚才安装之前的那两句：

1
2
3
4
5

$cd vim ~/.bashrc
export ORACLE_HOME=/usr/lib/oracle/11.2/client64/lib
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME

source ~/.bashrc

1.1.2 问题2：上述问题解决后出现“cx_Oracle.DatabaseError: Error while trying to retrieve text for error ORA-01804”问题

解决方法（参考“https://blog.csdn.net/zklth/article/details/7184032）”：

1
2

注释掉
os.environ["LD_LIBRARY_PATH"] = '$LD_LIBRARY_PATH:$ORACLE_HOME:$ORACLE_HOME'

出现新问题 “cx_Oracle连接数据库错误ORA-21561: 生成 OID 失败”

解决方法:参考“https://www.rookiefly.cn/detail/161”

1
2
3
4

修改本机hostname名称，然后终于成功
cat /etc/hosts  
127.0.0.1   localhost redhat6
::1         localhost redhat6

1.1.3 问题3：数据库可以访问后出现 “from numpy.testing import nosetester ImportError: cannot import name ‘nosetester’”问题

问题原因：当前安装在python3.5.2的numpy版本和pandas版本冲突，修改版本
可用版本:

1
2

numpy (1.11.1)
pandas (0.18.1)

1.1.4 问题4：打包报错“ File “sklearn/metrics/pairwise_fast.pyx”, line 1, in init sklearn.metrics.pairwise_fast ImportError: No module named ‘sklearn.utils._cython_blas’”

问题原因：打包的时候无法自动加入sklearn包，手动添加即可

解决方法：在main.spec中的hiddenimports属性中手动添加

1
2

hiddenimports=['cython',  'sklearn', 'sklearn.utils._cython_blas','sklearn.neighbors.typedefs',
           'sklearn.neighbors.quad_tree','sklearn.tree','sklearn.tree._utils'],

1.1.5 问题5：打包后运行然后又报问题2，“cx_Oracle.DatabaseError: Error while trying to retrieve text for error ORA-01804”

问题原因：缺少相关的oracle包

解决方法: 在main.spec中添加：

1
2
3
4

a.binaries = a.binaries + [('libclntsh.so', '/usr/lib/oracle/11.2/client64/lib/libclntsh.so.11.1','BINARY')]
a.binaries = a.binaries + [('libnnz11.so', '/usr/lib/oracle/11.2/client64/lib/libnnz11.so','BINARY')]
a.binaries = a.binaries + [('libocci.so', '/usr/lib/oracle/11.2/client64/lib/libocci.so.11.1','BINARY')]
a.binaries = a.binaries + [('libociicus.so', '/usr/lib/oracle/11.2/client64/lib/libociicus.so','BINARY')]

1.1.6 问题6：添加上述包之后出现“Oracle returned an error. ORA-12737: Instant Client Light: unsupported server character set SIMPLIFIED CHINESE_CHINA.UTF8 ”

问题原因： 见（https://thwack.solarwinds.com/t5/SAM-Discussions/Oracle-returned-an-error-ORA-12737-Instant-Client-Light/td-p/356034）
或https://www.cnblogs.com/chenjianhong/p/4144399.html

在Instant Client Light中，语言只能是美国语言，地区可以是任何受支持的地区，字符集可以是以下任意一项：

＆＃9632; 单字节

US7ASCII
WE8DEC
WE8MSWIN1252
WE8ISO8859P1
＆＃9632; 统一码

UTF8
AL16UTF16
AL32UTF8
指定除列出为客户端或服务器字符集的字符集或国家字符集以外的字符集或国家字符集，或者在客户端上以NLS_LANG设置语言时，将引发以下错误之一：

• ＆＃9632; ORA-12734
• ＆＃9632; ORA-12735
• ＆＃9632; ORA-12736
• ＆＃9632; ORA-12737

使用Instant Client Light，获得的错误消息仅是英文的。因此，NLS_LANG设置的有效值的类型为：American_territory.characterset ，其中，region可以是任何有效且受支持的领域，并且characterset可以

可以是前面列出的任何字符集。Instant Client Light可以与在OCI_UTF16模式下创建的OCI环境句柄一起使用。

解决方法：
修改文字编码：

1

将os.environ['NLS_LANG'] = 'SIMPLIFIED CHINESE_CHINA.UTF8'  修改为os.environ['NLS_LANG'] = 'AMERICAN_AMERICA.AL32UTF8'

2.最终打包成功样例

步骤0：下载oracle客户端驱动文件

1
2
3
4
5

instantclient-sdk-linux.x64-11.2.0.4.0_2
instantclient-basic-linux.x64-11.2.0.4.0
# basic中要包含libclntsh.so，libnnz11.so，libocci.so，libociicus.so这四个文件
# 如果没有从instantclient-basiclite-linux.x64-11.2.0.4.0包中找
# 官方下载链接“https://www.oracle.com/database/technologies/instant-client/downloads.html”

步骤1:添加依赖链接在main.spec中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

main.spec： pyinstaller打包的说明文件，里面编写一些打包的时候手动添加的文件

# -*- mode: python ; coding: utf-8 -*-

block_cipher = None

a = Analysis(['main.py'],
             pathex=['/home/redhat/Desktop/monthPredict'],
             datas=[],
             hiddenimports=['cython',  'sklearn', 'sklearn.utils._cython_blas','sklearn.neighbors.typedefs',
             'sklearn.neighbors.quad_tree','sklearn.tree','sklearn.tree._utils'],
             hookspath=[],
             runtime_hooks=[],
             excludes=[],
             win_no_prefer_redirects=False,
             win_private_assemblies=False,
             cipher=block_cipher,
             noarchive=False)

a.binaries = a.binaries + [('libclntsh.so', '/usr/lib/oracle/11.2/client64/lib/libclntsh.so.11.1','BINARY')]
a.binaries = a.binaries + [('libnnz11.so', '/usr/lib/oracle/11.2/client64/lib/libnnz11.so','BINARY')]
a.binaries = a.binaries + [('libocci.so', '/usr/lib/oracle/11.2/client64/lib/libocci.so.11.1','BINARY')]
a.binaries = a.binaries + [('libociicus.so', '/usr/lib/oracle/11.2/client64/lib/libociicus.so','BINARY')]

pyz = PYZ(a.pure, a.zipped_data,
             cipher=block_cipher)
exe = EXE(pyz,
          a.scripts,
          a.binaries,
          a.zipfiles,
          a.datas,
          [],
          name='main',
          debug=False,
          bootloader_ignore_signals=False,
          strip=False,
          upx=True,
          upx_exclude=[],
          runtime_tmpdir=None,
          console=True )

步骤2：打包

1

使用 pyinstaller  main.spec 命令打包

随机森林和GBDT部分对比

一：随机森林(bagging思想)

• 通过构建决策树然后进行分类，最后选择种类比较多的类别
• 随机：随机选取固定的样本和固定的特征
• 集成学习：投票选举（民主集中制）

二：GBDT(boosting思想)

• GBDT是回归树不是分类树
• 核心在于累加所有树的结果最为最终结果
• 利用损失函数的负梯度去模拟残差，使用残差构建决策树
• 为什么使用梯度决策树而不是回归算法

1
2

> 回归算法寻找参数和目标值之间存在的某种曲线关系，但是当某些特征与目标值之间无线性关系可使用梯度决策树。
> 梯度决策树是讲特征拟化成数值分类回归最佳结果。

2.1 参数说明

class sklearn.ensemble.GradientBoostingRegressor(loss='ls', learning_rate=0.1, n_estimators=100, subsample=1.0, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort='auto')

• n_estimators：指GBR使用的学习算法的数量。通常，如果你的设备性能更好，可以把n_estimators设置的更大，效果也会更好。

• max_depth：应该在优化其他参数之前先调整max_depth参数。因为每个学习算法都是一颗决策树，max_depth决定了树生成的节点数。选择合适的节点数量可以更好的拟合数据，而更多的节点数可能造成拟合过度。

• loss:loss参数决定损失函数，也直接影响误差。默认值为ls，表示最小二乘法（least squares）。还有最小绝对值差值，Huber损失和分位数损失（quantiles）等等。

• learning_rate:学习率

2.1.1 参数调整

Grid Search来选择性能表现最好的超参数

https://zhuanlan.zhihu.com/p/55524425

在Gradient Boosting Regressor 模型中，有一些独立的参数最好是手动调整。

超参数主要使用了：

• n_estimators=2000,
• learning_rate=0.01,
• max_depth=15,
• max_features=’sqrt’,
• min_samples_leaf=10,
• min_samples_split=10,
• loss=’ls’,
• random_state =42)

2.2 负荷预测程序说明记录

1. 误差偏大的处理方法

误差偏大的原因：缺失值处理不当(0或空值设置为均值)

因为数据波动较大，设置为历史均值是否存在较大的参考价值。其次数据量教少直接删除也不太可取。尝试设置为近一年的均值进行测试。

融会贯通

2.1 章节摘录

2.1.1 07 | 为什么说MapReduce既是编程模型又是计算框架？

模型是人们对一类事物的概括与抽象，可以帮助我们更好地理解事物的本质，更方便地解决问题。比如，数学公式是我们对物理与数学规律的抽象，地图和沙盘是我们对地理空间的抽象，软件架构图是软件工程师对软件系统的抽象。

通过抽象，我们更容易把握事物的内在规律，而不是被纷繁复杂的事物表象所迷惑，更进一步深刻地认识这个世界。通过抽象，伽利略发现力是改变物体运动的原因，而不是使物体运动的原因，为全人类打开了现代科学的大门。

这些年，我自己认识了很多优秀的人，他们各有所长、各有特点，但是无一例外都有个共同的特征，就是对事物的洞察力。他们能够穿透事物的层层迷雾，直指问题的核心和要害，不会犹豫和迷茫，轻松出手就搞定了其他人看起来无比艰难的事情。有时候光是看他们做事就能感受到一种美感，让人意醉神迷。

这种洞察力就是来源于他们对事物的抽象能力，虽然我不知道这种能力缘何而来，但是见识了这种能力以后，我也非常渴望拥有对事物的抽象能力。所以在遇到问题的时候，我就会停下来思考：这个问题为什么会出现，它揭示出来背后的规律是什么，我应该如何做。甚至有时候会把这些优秀的人带入进思考：如果是戴老师、如果是潘大侠，他会如何看待、如何解决这个问题。通过这种不断地训练，虽然和那些最优秀的人相比还是有巨大的差距，但是仍然能够感受到自己的进步，这些小小的进步也会让自己产生大大的快乐，一种不荒废光阴、没有虚度此生的感觉。

我希望你也能够不断训练自己，遇到问题的时候，停下来思考一下：这些现象背后的规律是什么。有时候并不需要多么艰深的思考，仅仅就是停一下，就会让你察觉到以前不曾注意到的一些情况，进而发现事物的深层规律。这就是洞察力。

2.1.2 06 | 新技术层出不穷，HDFS依然是存储的王者

• 1.如何设计分布式文件系统

  DataNode 负责文件数据的存储和读写操作，HDFS 将文件数据分割成若干数据块（Block），每个 DataNode 存储一部分数据块，这样文件就分布存储在整个 HDFS 服务器集群中.
  NameNode 负责整个分布式文件系统的元数据（MetaData）管理，也就是文件路径名、数据块的 ID 以及存储位置等信息，相当于操作系统中文件分配表（FAT）的角色。

NameNode 负责整个分布式文件系统的元数据（MetaData）管理，也就是文件路径名、数据块的 ID 以及存储位置等信息，相当于操作系统中文件分配表（FAT）的角色

• 2.HDFS的高可用设计

1. 数据存储故障容错

   磁盘介质在存储过程中受环境或者老化影响，其存储的数据可能会出现错乱。HDFS 的应对措施是，对于存储在 DataNode 上的数据块，计算并存储校验和（CheckSum）。在读取数据的时候，重新计算读取出来的数据的校验和，如果校验不正确就抛出异常，应用程序捕获异常后就到其他 DataNode 上读取备份数据。

2. 磁盘故障容错

   如果 DataNode 监测到本机的某块磁盘损坏，就将该块磁盘上存储的所有 BlockID 报告给 NameNode，NameNode 检查这些数据块还在哪些 DataNode 上有备份，通知相应的 DataNode 服务器将对应的数据块复制到其他服务器上，以保证数据块的备份数满足要求。

3. DataNode 故障容错

   DataNode 会通过心跳和 NameNode 保持通信，如果 DataNode 超时未发送心跳，NameNode 就会认为这个 DataNode 已经宕机失效，立即查找这个 DataNode 上存储的数据块有哪些，以及这些数据块还存储在哪些服务器上，随后通知这些服务器再复制一份数据块到其他服务器上，保证 HDFS 存储的数据块备份数符合用户设置的数目，即使再出现服务器宕机，也不会丢失数据。

4. NameNode 故障容错

   NameNode 是整个 HDFS 的核心，记录着 HDFS 文件分配表信息，所有的文件路径和数据块存储信息都保存在 NameNode，如果 NameNode 故障，整个 HDFS 系统集群都无法使用；如果 NameNode 上记录的数据丢失，整个集群所有 DataNode 存储的数据也就没用了。

2.1.3 13 | 同样的本质，为何Spark可以更高效？

1. spark的计算阶段

   MapReduce 一个应用一次只运行一个 map 和一个 reduce 不同，Spark 可以根据应用的复杂程度，分割成更多的计算阶段（stage），这些计算阶段组成一个有向无环图 DAG，Spark 任务调度器可以根据 DAG 的依赖关系执行计算阶段。

2.1.4 18 | 如何自己开发一个大数据SQL引擎？

如果只是作为学习者，被动接受总是困难的。但如果从开发者的视角看，很多东西就豁然开朗了，明白了原理，有时甚至不需要学习，顺着原理就可以推导出各种实现细节。

各种知识从表象上看，总是杂乱无章的，如果只是学习这些繁杂的知识点，固然自己的知识面是有限的，并且遇到问题的应变能力也很难提高。所以有些高手看起来似乎无所不知，不论谈论起什么技术，都能头头是道，其实并不是他们学习、掌握了所有技术，而是他们是在谈到这个问题的时候，才开始进行推导，并迅速得出结论。

我在 Intel 的时候，面试过一个交大的实习生，她大概只学过一点 MapReduce 的基本知识，我问她如何用 MapReduce 实现数据库的 join 操作，可以明显看出她没学习过这部分知识。她说：我想一下，然后盯着桌子看了两三秒的时间，就开始回答，基本跟 Hive 的实现机制一样。从她的回答就能看出这个女生就是一个高手，高手不一定要很资深、经验丰富，把握住了技术的核心本质，掌握了快速分析推导的能力，能够迅速将自己的知识技能推进到陌生的领域，就是高手。

2.1.4 23 | 大数据基准测试可以带来什么好处？

大数据测试工具：HiBeach
HiBench 内置了若干主要的大数据计算程序作为基准测试的负载（workload）。

2.1.5 24 | 从大数据性能测试工具Dew看如何快速开发大数据系统

1. Akka 原理与应用

Akka 使用一种叫 Actor 的编程模型，Actor 编程模型是和面向对象编程模型平行的一种编程模型。面向对象认为一切都是对象，对象之间通过消息传递，也就是方法调用实现复杂的功能。

而 Actor 编程模型认为一切都是 Actor，Actor 之间也是通过消息传递实现复杂的功能，但是这里的消息是真正意义上的消息。不同于面向对象编程时，方法调用是同步阻塞的，也就是被调用者在处理完成之前，调用者必须阻塞等待；给 Actor 发送消息不需要等待 Actor 处理，消息发送完就不用管了，也就是说，消息是异步的。

2. 主要原理

Akka 实现异步消息的主要原理是，Actor 之间的消息传输是通过一个收件箱 Mailbox 完成的，发送者 Actor 的消息发到接收者 Actor 的收件箱，接收者 Actor 一个接一个地串行从收件箱取消息调用自己的 receive 方法进行处理。如下图
https://static001.geekbang.org/resource/image/26/13/269b28c63c69444dd9dcb0c3124e0713.png

发送者通过调用一个 Actor 的引用 ActorRef 来发送消息，ActorRef 将消息放到 Actor 的 Mailbox 里就返回了，发送者不需要阻塞等待消息被处理，这是和传统的面向对象编程最大的不同，对象一定要等到被调用者返回结果才继续向下执行。

通过这种异步消息方式，Akka 也顺便实现了并发编程：消息同时异步发送给多个 Actor，这些 Actor 看起来就是在同时执行，即并发执行。

2.1.6 25 | 模块答疑：我能从大厂的大数据开发实践中学到什么？

1. 学习方法

学习一样新技术的时候，不会到处乱找资料，而是直接读原始论文。通过原始论文掌握核心设计原理以后，如果需要进一步学习，就去官网看官方文档；如果还需要再进一步参与开发，就去读源代码。

我刚开始读论文时感觉很费劲，但是后面习惯以后，发现读论文真的是最快的学习方法，因为最核心的东西就在其中，一旦看懂，就真的懂了，而且可以触类旁通，整个软件从使用到开发，很多细节通过脑补就可以猜个八九不离十。而且越是优秀的产品，越是厉害的作者，论文反而越是容易读懂，可能是因为这些作者是真的高手，自己理得越清楚，写出来的论文越是脉络清晰、结构合理、逻辑严谨。

2. 典型的互联网大数据平台的架构。

如图
https://static001.geekbang.org/resource/image/5f/1f/5f0515ad5740575ff79ac8c68990071f.png

2.1.7 35 | 如何利用大数据成为“增长黑客”？

1. AARRR 用户增长模型

关于用户增长有一个著名的 AARRR 模型，它描述了用户增长的 5 个关键环节，分别是：获取用户（Acquisition）、提高活跃度（Activation）、提高留存率（Retention）、获取收入（Revenue）和自传播（Refer）。
获取用户：通过各种推广手段，使产品触达用户并吸引用户，让用户访问我们的产品。

提高活跃度：用户访问我们的产品后，如果发现没意思、体验差，就很难再次打开，产品的价值也就无法实现。因此需要结合产品内容、运营活动各种手段吸引用户，提升产品的活跃度。

提高留存率：留住一个老用户的成本远低于获取一个新用户，而真正为产品带来营收利润的通常是老用户，因此需要提高留存率。提高留存率的常用手段有：针对老用户推出各种优惠和活动；建立会员等级体系，注册时间越长等级越高；对于一段时间没有访问的疑似流失用户进行消息短信推送以实现用户挽回等。

获取收入：做企业不是做慈善，开发、运营互联网产品的最终目的还是为了赚钱，即获取收入。互联网产品收入主要有用户付费和广告收入，有些互联网产品看起来是用户付费，但其实主要营收是广告收入，比如淘宝。
自传播：让用户利用利用自己的社交网络进行产品推广就是自传播，几乎所有的互联网产品都有“分享到”这样一个功能按钮，促进用户社交传播。有些产品还会利用“帮我砍价”“帮我抢票”等产品功能推动用户进行分享，实现产品的裂变式传播、病毒式营销。

2. 拼多多如何利用 AARRR 模型实现用户快速增长。

拼多多是近几年互联网产品中将自传播发挥到极致的一个产品。拼多多用户群体主要为三四线以下城市人群，社交成本比较低，愿意为了砍几块钱发动自己的各种社交资源，因此拼多多就利用“帮好友砍价”这一功能实现产品的快速裂变传播。事实上，拼多多非常准确地抓住了这一群体的社交痛点：交往不多的朋友，与其尬聊维持友谊，不如帮我砍价来的更实惠更亲密。

自传播也是拼多多主要获取用户的手段。比如帮好友砍价时，拼多多会提示“下载 App 可以帮好友砍更多价”，于是用户量呈指数级增长。
拼多多为了让新来的用户快速上手、增加活跃度，用户第一次使用拼多多的时候，并不需要注册登录，直接就可以挑选商品和购买，在后面订单环节再让用户注册，这时用户已经产生购买冲动，进行注册也更容易被接受。
拼多多通过各种消息推送促使用户打开 App（或者微信小程序），并在开屏页面的优惠信息给用户制造惊喜，达到留存用户的目的。

拼多多的主要交易模式为拼团，拼团属于冲动型购买，拼多多为了减少用户的思考时间、维持购买冲动，将购买路径设计得尽可能短，使用户可以尽快完成付费，企业获取收入。