发表于 | 分类于
字数统计:

Coding Now

初衷

一是平时看的一些自己认为不错的文章总是很难整理，所以打算开一个项目管理这些，也可以分享给大家；二是记录自己平时所学的一些笔记，一些经历，以供将来翻阅；三是想系统地进阶学习一番，记录这个项目也是想激励自己；四是分享一些平时看的电子书啊、视频等等

GitHub及Git使用

1546841656292

原文链接：https://paulmillr.com/posts/simple-description-of-popular-software-licenses/

Linux系统下开发环境搭建

Linux命令及Shell脚本学习笔记

爬虫篇（Python）

爬虫这一块我也没多少可以说的，距离我上次写爬虫程序都有一年多了。谈谈感想吧，别听什么培训机构诳你什么爬虫工程师有前途啥的，当然学好学精爬虫也能拿到高薪，但这一行也有不少人了，精通的自然不用说。而且现在有很多像八爪鱼、火车头这些可以定制的爬虫软件，还有一些自学习的爬虫框架。所以我觉得爬虫这一块只要稍微学下，了解下即可

我建议如果是python的话，了解urllib（http请求），requests（http请求），lxml（文本解析），Scrapy（爬虫框架），多线程爬虫就可以了

原来也在csdn上写过一些scrapy的文章，当然学习一门语言官方文档才是最重要的（scrapy也有中文的）

数据分析篇

机器学习及深度学习篇

机器学习网站及教程

GitHub上相关项目推荐

数据分析竞赛

大数据篇

大数据开发环境安装配置

以下出自我在csdn上的一些文章，https://blog.csdn.net/lzw2016/

Hadoop系列

  • Apache Hadoop: 是Apache开源组织的一个分布式计算开源框架，提供了一个分布式文件系统子项目(HDFS)和支持MapReduce分布式计算的软件架构

  • Apache Hive: 是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，通过类SQL语句快速实现简单的MapReduce统计，不必开发专门的MapReduce应用，十分适合数据仓库的统计分析

  • Apache Pig: 是一个基于Hadoop的大规模数据分析工具，它提供的SQL-LIKE语言叫Pig Latin，该语言的编译器会把类SQL的数据分析请求转换为一系列经过优化处理的MapReduce运算 【不准备学，计划Hive代替Pig】

  • Apache HBase: 是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群

  • Apache Sqoop: 是一个用来将Hadoop和关系型数据库中的数据相互转移的工具，可以将一个关系型数据库（MySQL ,Oracle ,Postgres等）中的数据导进到Hadoop的HDFS中，也可以将HDFS的数据导进到关系型数据库中

  • Apache Mahout:是基于Hadoop的机器学习和数据挖掘的一个分布式框架。【不打算学，计划利用SparkMLLib代替】

  • Apache Zookeeper: 是一个为分布式应用所设计的分布的、开源的协调服务，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，简化分布式应用协调及其管理的难度，提供高性能的分布式服务

  • Apache Flume: 是一个分布的、可靠的、高可用的海量日志聚合的系统，可用于日志数据收集，日志数据处理，日志数据传输

  • 等等，当然不可能全学的

Spark系列

实战项目

推荐系统

算法篇

eBook和视频资源

只推荐我看过的，且个人觉得不错的

Python

视频资源 点这里—>eBook/Python

  • Python3数据分析与挖掘（某课网）
  • python分布式爬虫打造搜索引擎【完整版 某课网】
  • Python升级3.6 强力Django+Xadmin打造在线教育平台

电子书推荐，下面给了几个可以下载电子书的网站，都能找得到的

  • 入门
    • 《Python基本教程》，貌似出第三版了
    • 《Python核心编程》
    • 《Python CookBook》
  • 爬虫
    • 《Python网络数据采集》
    • 也有人推荐崔庆才的书，我只看过他的博客觉得挺不错的，书想比也可以吧
    • 我更推荐看博客，爬虫这一块更新太快了，书跟不上步伐
  • 数据分析
    • 《用Python进行数据分析》足以
  • 机器学习和深度学习
    • 《机器学习实战》
    • 我看的更多的是官方文档和博客，反正不推荐看国人写的书（好多都是骗钱的，我原来看过一本封面画了个鹦鹉的，叫什么一步一步什么走向机器学习之类的，就是把sklearn文档翻译了一遍加了几个案例，烂）

      Java系列

Hadoop系列

Spark系列

视频资源 点这里—>eBook/Spark系列

  • Spark 2.0从入门到精通245讲 【墙推】

  • 01-基于Spark2.x新闻网大数据实时分析可视化系统项目

  • 02-Spark离线和实时电影推荐系统直播回放(视频+文档+代码）
  • 03-Spark项目实战：爱奇艺用户行为实时分析系统
  • 04-Spark企业级实战项目：道路交通实时流量监控预测系统
  • 05-Spark企业级实战项目：知名手机厂商用户行为实时分析系统
  • 06-Spark大型项目实战：电商用户行为分析大数据平台

以上来源于大数据学习资源群的分享

算法系列

数据库

计算机网络

基础书籍

常用网站收纳

工具

搜索

翻译

文档编辑

制图、图床

插件

发表于 | 分类于
字数统计:

第二章：可行性研究

数据流图和数据字典 P40 P47

数据流图完成功能的需求，数据字典完成数据定义

画数据流图要注意哪些事项？
答：1.设计数据流图时只需考虑系统必须完成的基本逻辑功能，不需要考虑怎样具体的实现
这些功能。
2.从顶层数据流开始。
3.并不是所有数据存储和数据流都能直接从问题描述中提取出来；
4.当进一步分解将涉及如何具体地实现一个功能时，就不应该在分解了；
5.数据流图中个成分的命名要仔细推敲，看是否恰当；

1546826407679

1546827141760

数据字典：名字、别名、描述、定义、位置

定义中，=（是）、[ A|B ]（A或B）、1{A}5（A重复1到5次）、A+B（A和B）、(A)（A可选）

1546826346837

第三章：需求分析阶段

结构化分析方法：面向数据流自顶向下逐步求精进行需求分析的方法

快速建立软件原型

E-R模型

状态图（状态转换图） P66

注意：初态是实心圆，终态是同心圆(内部实心圆)，中间状态是圆形框

1546826778046

P69 IPO图

1546826913687

• 左边框中列出有关的输入
• 中间框中列出主要的处理
• 右边框中列出产生的输出
• 处理的顺序暗示了执行的顺序
• 箭头指出数据通信的情况

第五章：总体设计（系统设计阶段、结构设计阶段）

层次图和 HIPO 图(H图，带标签的层次图) P103

通常用层次图作为描述软件结构的文档

1546827667395

如图是HIPO图，去掉数字是层次图

数据流图转成软件结构图

软件结构图可在层次图基础上，在方框间加入箭头代表模块的调用关系

箭头尾部是空心圆表示传递的是数据，实心圆表示传递的是控制信息

模块独立性：耦合、内聚 P97

低【数据耦合】、中【控制耦合、特征耦合、公共环境耦合】、高【内容耦合】

尽量用数据耦合，少使用控制、特征耦合，限制公共环境耦合的范围，不用内容耦合

低内聚【偶然内聚、逻辑内聚、时间内聚】、中内聚【过程内聚、通信内聚】、高内聚【顺序内聚、功能内聚】

耦合越低、内聚越高，独立性越好

第六章：详细设计

判定表和判定树 P127 、129

1546829101200

这是判定树（判定表的变种）

1546829150554

程序流程图和盒图 P125

程序流程图要区分 while-do和 do-until两种，还有case语句图

1546828721769

下面是盒图：

盒图

依据伪码（PDL）画出流图，并计算复杂度 P138（以及控制结构测试中求出流图的独立路径） P166

流图有的地方也叫控制流图、程序图

McCabe方法

复杂度是E-N+2（边数-点数+2）

1546829371774

1546829617473

上面这个是判定a OR b

第七章：软件实现与测试

编码和测试统称为实现

软件测试在软件生命周期中横跨两个阶段：开发中的开发者进行的单元测试（编码和单元测试属于软件生命周期的同一阶段），专门测试人员负责的综合测试

测试是发现错误，最终目的是调试（诊断并改正错误，发生在测试之后）

调试方法：蛮干法、回溯法、原因排除法

可靠性模型

软件可靠性是程序在给定的 时间间隔内 ，按照规格说明书的规定成功地运行的概率

软件可用性是程序在给定的 时间点 ，按照规格说明书的规定，成功地运行的概率

应同时使用可靠性和可用性衡量

测试方法：黑、白盒测试

  • 黑盒测试又称功能测试，在程序接口进行的测试。按照规格说明书的规定功能是否有效，能否适当接收数据产生正确信息
    • 主要技术：等价划分、边界值分析、错误推测
  • 白盒测试又称结构测试，检测程序内部逻辑结构是否正确
    • 主要技术：逻辑覆盖、控制结构测试

逻辑覆盖分为：语句覆盖、判定覆盖、条件覆盖、（判定条件覆盖、条件组合覆盖）、路径覆盖 【覆盖强度依次增强】

  • 语句覆盖是保证每个语句至少执行一次
    • 如下图所示，语句K，J都执行一次，只能选择数据组1、2
  • 路径覆盖是走过所有路径，测试用例可以覆盖程序中所有可能的执行路径

判定覆盖和条件覆盖的区别：

  • 判定覆盖：不仅每个语句必须至少执行一次，而且每个判定的每种可能的结果都应该至少执行一次，也就是每个判定的每个分支都至少执行一次
  • 条件覆盖：类似判定覆盖，但是保证每个判定中的每个条件语句都可取到各种结果

1546701860223针

对这里的条件覆盖为什么不能选8，因为第2、4组只能使得x<1取到一种结果

  • 判定-条件覆盖

1546849983561

  • 条件组合覆盖

1546849900736

Pareto原理：80%的错误很可能由20%的模块造成

测试应该从小规模开始，逐步进行大规模测试，不可能穷举测试

测试四步骤：

  • 单元测试：针对各个单独模块，采用白盒测试
  • 集成测试：各个模块集成一起形成完整软件包，同时测试。常用黑盒测试，也可使用部分白盒
    • 集成模块时，又分渐增式和非渐增式测试
    • 自顶向下集成
    • 自底向上集成
    • 回归测试( 回归测试 是指重新执行已经做过的测试的某个子集，以保证上述这些变化没有带来非预期的副作用)
  • 确认测试：仅使用黑盒测试，验证需求分析阶段确认的标准
  • 系统测试

软件测试包括哪些步骤？同时说明这些步骤的测试目的是什么？

答：（1）单元测试，目的是代码达到模块说明书的要求

（2）集成测试，目的是将经过单元测试的模块逐步组装成具有良好一致性的完整的程序

（3）确认测试，目的是确认程序系统是否满足软件需求规格说明书的要求

（4）系统测试，目的是检查能否与系统的其余部分协调运行，并且完成SRS对他的要求。

控制结构测试 P166 【这也是一种白盒测试方法】

分为 基本路径测试、条件测试、循环测试（包含简单、嵌套、串接循环三种）

  • 基本路径测试流程：
    1. 一般是根据伪码画出流图
    2. 求出流图复杂度
    3. 确定线性独立路径的基本集合 【独立路径数同复杂度值】
      • 独立路径至少包含一条在定义该路径之前不曾用过的边
    4. 设计每条路径的测试用例

第八章：软件维护（生命周期最后一个阶段）

  • 改正错误
  • 满足新的需求

1546745763355

完善性维护占主要，其次是改正性、适应性维护

决定可维护性的因素：

  • 软件的可理解性、可测试性、可修改性
  • 文档描述符合要求、用户文档简洁明确、系统文档完整标准

第九章：面向对象分析

优点：

  • 与人的思维方法一致
  • 稳定性好
  • 可重用性好
  • 较易开发大型软件
  • 可维护性好

对象的特点：以数据为中心，实现了数据的封装，对象是主动的，并行性，模块独立性好

  1. 对象模型：类图 P218
  2. 动态模型：每个类用一张状态图（状态转换图）描述，状态图见3.6节，P66；事件跟踪图（时序图）
  3. 功能模型：使用 UML 中的用例图 P225

功能模型直接地反映了用户对目标系统的需求

描述系统静态结构的对象模型、描述系统控制结构的动态模型、以及描述系统计算
结构的功能模型。其中，对象模型是最基本、最核心、最重要的

用例图怎么画

1546760577001

扩展关系：向一个用例中加入一些新的动作后构成了另一个用例，这两个用例之间的关系就是扩展关系，后者通过继承前者的一些行为得来，通常把后者称为扩展用例

使用关系：当一个用例使用另一个用例时，这两个用例之间就构成了使用关系

类图怎么画

类图是静态模型，是构建状态图、协作图等基础

类图包括类的定义和类之间的关系

属性名和类型名必须有，其他操作部分根据需要可有可无

类的名字
属性
操作

属性用+-#分布表示public、private、protected

1546761260457

状态图怎么画

1546761428933

顺序图（时序图）怎么画

两个坐标轴，横坐标表示不同对象，纵坐标表示时间

1546763155022

事件跟踪图是简化的顺序图，下面这个是顺序图

考题

  • 由代码画出程序盒图，并求出环形复杂度
  • 给出一段文字，分析，然后画用例模型
  • 使用UML，画出类图
  • 画数据流图，给出说明
  • 白盒测试，黑盒测试，给出最小测试用例组
  • 数据流图—建立功能模型
  • 实体联系图（E-R）—建立数据模型
  • 状态图—建立行为模型
  • 测试阶段有关的文档——————需求规格说明书
  • 维护阶段的文档——————软件问题报告、概要设计说明书

（需求分析节点产生）需求规格说明书作用：

  1. 软件验收依据
  2. 软件设计依据
  3. 用户与开发人员对软件要做什么的共同理解

需求规格说明书主要组成部分：数据流图和数据字典【二者也共同构成了系统的逻辑模型】

  • 软件的生存周期一般分成哪几个阶段？
    答：三个时期：软件定义，软件开发，运行并维护。八个阶段：问题定义，可行性研究，需求分析，概要（总体）设计，详细设计，编码和单元测试，综合测试，运行维护
  • 分别叙述“瀑布模型”和“快速原型模型”的优缺点
    1. 瀑布模型：优点：可强迫开发人员采用规范的方法；严格的规定了每个阶段必须提交的文档；要求每个阶段交出的所有产品都必须经过质量保证小组的仔细验证。
      缺点：瀑布模型是文档驱动的。缺乏灵活性
    2. 快速原型模型：优点：软件产品的开发基本上是按线性顺序进行的。
      缺点：所选用的开发技术和工具不一定符合主流的发展； 快速建立起来的系统结构加上连续的修改可能会导致产品质量低下；

喷泉模型，”喷泉“体现了迭代和无缝特点。

瀑布模型关键不足在无法适应需求的动态变更（不适应用户的需求变更），因为是依赖文档的

快速动态模型可以有效地适应用户需求的动态变化

螺旋模型在瀑布模型和增量模型基础上增加了风险分析活动

软件详细设计主要采用方法：结构化程序设计

一般把数据流图中的数据划分为事务流和交换流

需求分析过程中无需确定软件系统运行的平台

非功能性需求，是指软件产品为满足用户业务需求而必须具有且除功能需求以外的特性。软件产品的非功能性需求包括系统的性能、可靠性、可维护性、可扩充性和对技术和对业务的适应性等

需求分析阶段分为四个方面：对问题的识别、分析与综合、编写需求文档、需求分析评审

程序的三种基本控制结构：顺序、条件、循环

软件工程三要素：方法、工具、过程

软件组成：程序、文档、数据

详细设计阶段所使用到的设计工具：程序流程图、PAD图、N-S图、HIPO图、判定树、判定表

软件生命周期中花费最多的阶段是：测试与维护阶段

度量可靠性的指标：成功运行的概率、平均故障时间

软件的风险分析包括 风险识别、风险预测、风险管理

通过软件测试未发现错误，并不一定代表软件是正确的

在可行性研究中最难决断和最关键的问题是技术可行性

类与对象的静态关系主要有 关联、聚集、泛化、依赖

  • 关联：
  • 聚集
  • 泛化
  • 依赖

数据字典主要由数据流描述、加工描述、文件描述组成，它对数据流图上每一个成分：数据项、文件(数据结构)、数据流、数据存储、加工和外部项等给以定义和说明

结构化设计的主要思想：

  • 自顶向下、逐步求精的程序设计方法
  • 使用三种基本结构、单入单出口

面向对象设计准则包括：模块化、信息隐藏、抽象和逐步求精、低耦合、高内聚

软件可行性研究实质上是进行一次 简化、压缩的需求分析、设计过程

软件结构图的形态特征能反映程序重用率的是 扇入

要显示描绘软件开发项目各作业的依赖关系，应选择( B )。

A. Gantt图 B.工程网络

C. COCOMO模型 D.数据流图

COCOMO模型 是成本估算方法

黑白盒测试都属于动态测试

系统流程图使用了描述系统物理模型的

有几个单词简写要了解DFD图（数据流图）、DD（数据字典）、PAD图、sc图（结构图）

SA（结构化分析方法）、SD（结构化设计方法）、SP（结构化程序设计方法）

发表于 | 分类于
字数统计:

Hadoop概述

Hadoop是分布式系统基础架构，其核心包括HDFS（分布式文件系统）、MapReduce（分布式计算系统）、YARN（分布式资源调度和管理系统）

Google三驾马车

  • GFS发展成HDFS
  • Google BigTable发展成HBase
  • Google MapReduce发展成MapReduce

Google大数据三篇著名论文中文版

Hadoop生态系统

蓝色部分，是Hadoop生态系统组件，黄色部分是Spark生态组件。二者并非互斥，像MR和Spark是共生关系，Spark提供了基于内存的实时计算，Hadoop提供了Spark没有的分布式文件系统，但Spark不一定就依赖HDFS，可以借助AWS的S3

HSQL未来可能会被Spark SQL替代，现在很多企业都是HIVE SQL和Spark SQL两种工具共存，当Spark SQL逐步成熟的时候，就有可能替换HSQL；

MapReduce绝对会被Spark替换，趋势是这样，Spark发展很快

Hadoop中的算法库Mahout正被Spark中的算法库MLib所替代，我觉得可以在Spark学习中侧重选择Spark Mlib学习

但是Hadoop也非常重要，我感觉绝对不会被Spark取代。为什么呢？就是因为它的HDFS分布式文件系统

阅读全文 »

发表于 | 分类于
字数统计:

参考[Hadoop] setup & cleanup 方法

Mapper类的setup（）函数在Mapper类的run（）函数中被调用。

向hadoop提交job后，hadoop会在MapTask的runNewMapper（）或者runOldMapper（）函数中使用反馈机制 实例化具体的Mapper子类，然后调用这个对象的run（）函数，其中setup()函数就在这个函数的开始被调用，因为hadoop会向 setup（）函数中传递Configuration等一些变量，所以我们可以通过重载setup（）函数来获得系统变量实现自己的功能。

setup()
此方法被MapReduce框架仅且执行一次，在执行Map任务前，进行相关变量或者资源的集中初始化工作。若是将资源初始化工作放在方法map()中，导致Mapper任务在解析每一行输入时都会进行资源初始化工作，导致重复，程序运行效率不高！
cleanup()
此方法被MapReduce框架仅且执行一次，在执行完毕Map任务后，进行相关变量或资源的释放工作。若是将释放资源工作放入方法map()中，也会导致Mapper任务在解析、处理每一行文本后释放资源，而且在下一行文本解析前还要重复初始化，导致反复重复，程序运行效率不高！

所以，建议资源初始化及释放工作，分别放入方法setup()和cleanup()中进行。

参考 【转】MapReduce编程模式原理及其算法设计（里面包括了Setup的说明）

发表于 | 分类于
字数统计:

一些有趣的Python特性—-阅读《wtfPython》记录

181214

  1. 看这道题
1
2
3
4
5
>>> row = ['']*3
>>> board = [row]*3
>>> board[0][0] = 'x'
>>> board
???会输出什么
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
>>> row = ['']*3
>>> id(row)
2511596760840
>>> board = [row]*3
>>> board
[['', '', ''], ['', '', ''], ['', '', '']]
# 像最初创建时，row、board中每个元素指向地址都是一样的
>>> id(board[0])
2511596760840
>>> id(board[1])
2511596760840
>>> id(board[2])
2511596760840
>>> id(row[0])
2511562308272
>>> id(row[1])
2511562308272
>>> id(row[2])
2511562308272
# 一旦给其中某个元素赋了值，该元素指向地址就发生了改变
>>> row[0]='x'
>>> row
['x', '', '']
>>> id(row[0])
2511566106048
# 但board中每个元素仍旧指向row对象
>>> board
[['x', '', ''], ['x', '', ''], ['x', '', '']]
# 这个同上面row[0]修改一样
>>> board[0]=['y','z','x']
>>> board
[['y', 'z', 'x'], ['x', '', ''], ['x', '', '']]

这个关键是board是通过一个对象row来创建的，而row对象也是通过一个对象来创建的，所以board[0]，board[1]，board[2]，row都指向了同一列表对象

要是想只改变board[0][0]，那就不要通过一个row对象来创建就好了

1
2
3
4
5
6
7
8
9
10
>>> board = [['']*3 for _ in range(3)]
>>> id(board[0])
2511596761672
>>> id(board[1])
2511596761416
>>> id(board[2])
2511596761032
>>> board[0][0] = 'x'
>>> board
[['x', '', ''], ['', '', ''], ['', '', '']]
  1. is not… 和 is (not …)…不同

我想这个不难理解，对非空对象都能判断，主要是None对象的理解。记住下面这个就OK了

1
2
3
4
>>> 1 is (not None)
False
>>> 1 is not None
True
  1. 字符串末尾的反斜杠
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> 'asdf\'
  File "<stdin>", line 1
    'asdf\'
          ^
SyntaxError: EOL while scanning string literal
>>> 'asdf\\'
'asdf\\'
>>> r'asdf\'
  File "<stdin>", line 1
    r'asdf\'
           ^
SyntaxError: EOL while scanning string literal
>>> r'asdf\\'
'asdf\\\\'
>>> r'as\df\\'
'as\\df\\\\'
>>> r'as\'df\\'
"as\\'df\\\\"
  1. == 优先级高于 not

看下这个会输出什么

1
2
3
4
>>> True == False
???
>>> True == not False
???
1
2
3
4
5
6
7
>>> True == not False
  File "<stdin>", line 1
    True == not False
              ^
SyntaxError: invalid syntax
>>> not True == False
True

== 优先级高于not ，所以 True == not False 等同于· (True == not) False ，自然语法错误

== 和 not in 优先级同级

  1. 字符串的隐式连接

看下文会输出什么

1
2
3
4
>>> 'hello'''
???
>>> 'hello' ''
???
1
2
3
4
5
6
7
8
9
10
11
>>> 'hello'''
'hello'
>>> 'hello' ''
'hello'
# 隐式连接，没有空格
>>> 'hello' 'python'
'hellopython'
# 但是三个引号在前，反而会报错
>>> print('''hello')
# 解释器先遇到三引号会认为是多行字符串，就会默认去寻找三个终止的引号，找不到报错
# 像命令行下python解释器不到三引号结尾根本不会打印

补充

  • 列表推导式中，for循环部分居然可以用 _ 来占位

181215

  • 布尔类型是int类型的子类

看下下面会输出什么

1
2
3
4
5
6
>>> dict = {}
>>> dict[True] = "python"
>>> dict[1] = "scala"
>>> dict[1.0] = "spark"
>>> dict[True]
???

结果是spark。布尔类型是int类型的子类，所以True的整数值就是1，False是0。其次，字典中是通过判断key的哈希值是否相等来判断键是否相同的，所以1、1.0、True都是1

See this：Why is bool a subclass of int?

1
2
3
4
5
6
7
8
9
10
>>> some_bool = True
>>> some_bool*"wtf"
'wtf'
>>> some_bool = False
>>> some_bool*"wtf"
# isinstance(object,classinfo)判断object对象是否是已知的classinfo类型
>>> isinstance(True,int)
True
>>> isinstance(False,int)
True

关于isinstance()和type()用法见补充

  • 类变量和类实例变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>> class A:
    	x = 1

>> class B(A):
   		pass

>> class C(A):
    	pass
>>> A.x,B.x,C.x
(1, 1, 1)
>>> C.x =2
>>> A.x,B.x,C.x
(1, 1, 2)
>>> A.x = 3
>>> A.x,B.x,C.x
(3, 3, 2)
>>> a = A()
>>> a.x
3
>>> a.x = 4
>>> a.x,A.x
(4, 3)

首先类B、C都是A的子类，a是A的实例对象，其次要知道一点，类变量和实例变量在内部是通过类对象的 __dict__ 属性来处理. 如果在当前类的字典中找不到的话就去它的父类中寻找

所以，C类给x赋值2后，C中已经有了该实例变量，但B中仍旧是用的父类A的变量。实例a也是如此

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 SomeClass:
...     some_var = 15
...     some_list = [5]
...     another_list = [5]
...     def __init__(self, x):
...         self.some_var = x + 1
...         self.some_list = self.some_list + [x]
...         self.another_list += [x]
...
>>> some = SomeClass(10)
>>> some.some_var
11
>>> some.some_list
[5, 10]
>>> some.another_list
[5, 10]
# 注意这两个
>>> some.some_list is SomeClass.some_list
False
>>> some.another_list is SomeClass.another_list
True
>>> another = SomeClass(15)
>>> another.some_list
[5, 15]
>>> another.another_list
[5, 10, 15]

+= 回原地修改可变对象，并不改变对象，所以some的some_list不是原属性对象，another_list仍是原对象

  • tuple到底可不可变

看下下面这个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> some_tuple = ([1],[2],[3])
>>> some_tuple[0] += [2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> some_tuple
([1, 2], [2], [3])

>>> some_tuple[0] = [2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> some_tuple
([1, 2], [2], [3])

不可变序列 不可变序列的对象一旦创建就不能再改变. (如果对象包含对其他对象的引用，则这些其他对象可能是可变的并且可能会被修改; 但是，由不可变对象直接引用的对象集合不能更改.)

没错，不可变的tuple确实报了错（tuple不支持修改），但是使用+=时，确实改变了tuple

像上面说的+=回原地修改可变对象，而tuple中+=是两个过程，先+再=，所以+操作时已经修改了原对象，但是再次赋值就触犯了元组不能修改规则，抛出异常

首先需要重温+=这个运算符,如a+=b:

  • 对于可变对象(mutable object)如list, +=操作的结果会直接在a对应的变量进行修改，而a对应的地址不变.
  • 对于不可变对象(imutable object)如tuple, +=则是等价于a = a+b 会产生新的变量，然后绑定到a上而已.

参考这个：Python中tuple+=赋值的四个问题

1
2
3
4
5
6
>>> a = some_tuple[0]
>>> a += [3]
>>> a
[1, 2, 3]
>>> some_tuple
([1, 2, 3], [2], [3])

所以元组到底可不可变？从上面可以看到tuple不支持=这种assign操作，但是对其中可变元素的原地修改是可以的

+=, -=, =, /=, //=, %=, *=, <<=, >>=, &=, ^=, |=这些操作符都是原地修改可变对象，不会改变对象

所以，tuple元组的不可变是指元素对象的引用不可变，不能对其再次赋值，但是在其中可变元素对象的引用不被修改前提下，仍旧可以对可变元素对象修改

部分参考如下：

补充

  • isinstance和type方法的异同

二者都可用来判断一个对象的类型，type是直接返回类型。但是isinstance方法会考虑继承的关系，会认为子类是一种父类类型，就像上面提到的True是int类型

1
2
3
4
5
6
7
>>> isinstance(True,int)
True
# 差异
>>> type(True) == int
False
>>> type(True) == bool
True

isinstance(object,classinfo) ，classinfo 可以是直接或间接类名、基本类型或者由它们组成的元组

推荐使用isinstance

  • +=, -=, =, /=, //=, %=, *=, <<=, >>=, &=, ^=, |=这些操作符都是原地修改可变对象，不会改变对象

发表于 | 分类于
字数统计:

Spark–最全面详解从理论、实践到案例【附案例及数据】(出处: about云开发)

Hadoop组件可以通过以下方式与Spark一起使用：

  • HDFS：Spark可以在HDFS之上运行，以利用分布式存储。
  • MapReduce：Spark可以与MapReduce一起用于同一个Hadoop集群，也可以单独作为处理框架使用。
  • YARN：可以使Spark应用程序在YARN（Hadoop NextGen）上运行。
  • 批处理和实时处理：MapReduce和Spark一起使用，其中MapReduce用于批处理，Spark用于实时处理。

[学习线路] spark零基础学习线路指导[spark2已更新]

img

更多资料推荐
Spark1.0.0 学习路线指导
http://www.aboutyun.com/forum.php?mod=viewthread&tid=8421

Spark学习总结—入门
http://www.aboutyun.com/forum.php?mod=viewthread&tid=20710

spark个人学习总结
http://www.aboutyun.com/forum.php?mod=viewthread&tid=14584

spark入门教程及经验总结
http://www.aboutyun.com/forum.php?mod=viewthread&tid=11128

发表于 | 分类于
字数统计:

前期准备

spark可以在Linux上搭建，也能不安装hadoop直接在Windows上搭建单机版本。首先是从官网上下载和你hadoop版本匹配的spark版本（版本不要太新，选择稳定版本，如我的是hadoop2.6版本对应spark-2.0.2-bin-hadoop2.6.tgz）

可以放心的是，spark安装远比hadoop安装简单的多

本地安装

把下载的压缩包解压到本地某个位置上，修改环境变量，添加%SPARK_HOME%:解压的位置；修改Path，增加一栏%SPARK_HOME%/bin

好了，本地安装就这么简单。打开CMD命令行工具，输入spark-shell，如图显示就是安装成功了

  • Error：安装后运行是有可能会遇到一个错误：Failed to find Spark jars directory
    • 解决方法：安装路径名上不能有空格（比如Program Files就不行）
      阅读全文 »

发表于 | 分类于
字数统计:

初识MapReduce

先看一张图

MapReduce程序词频统计源码分析

  • 前言
    • hdfs中有自己的数据类型，java中的Int对应IntWritable，String对应Text
    • 为了实现文件序列化，编程中必须把Int、String转变为上面的两个
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
public class WordCount {

  public static class TokenizerMapper 
       extends Mapper<Object, Text, Text, IntWritable>{//定义MAP的输入输出的Key-Value类型，第一对key-value的key不一定是字符串，所以申明为Object类型
    
    private final static IntWritable one = new IntWritable(1);//key-value中经常用到1，申明为常量
    private Text word = new Text();//相当于java中的String
      
//    map方法每次只处理一行【应该是的，我在另一个程序中打印输出是每次一行，还待深究】
    public void map(Object key, Text value, Context context
                    ) throws IOException, InterruptedException {//这里三个变量，前两个对应上面的，context封装了输出的key-value
      StringTokenizer itr = new StringTokenizer(value.toString());//字符串分词器
//      String[] strs = value.toString().split(" "); //等于上面这行，就是分词
      while (itr.hasMoreTokens()) {// 取出子串，并赋1，写入context。不用管context存在什么地方
        word.set(itr.nextToken());
        context.write(word, one);
        //有个概念要知道，这里他给每个词都赋值value=1，实际上value=2也是可以的（
        // 比如hello hello，可以一次计算value=2），看你怎么处理了(value=1省去了一步相同词再汇总过程)
      }
    }
  }
  
  public static class IntSumReducer 
       extends Reducer<Text,IntWritable,Text,IntWritable> {//如上，不过输入、出都是字符串-Int型
    private IntWritable result = new IntWritable();//对每个key，求value的和为result，比如<hello,3>

    public void reduce(Text key, Iterable<IntWritable> values, 
                       Context context
                       ) throws IOException, InterruptedException {
      int sum = 0;
      for (IntWritable val : values) {
        sum += val.get();// get是将IntWritable转为Int类型，set相反，见下面
      }
      result.set(sum);// sum是Int类型，hadoop无法将之序列化，所以转为IntWritable类型
      context.write(key, result);
    }
  }

  public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
    if (otherArgs.length < 2) {
      System.err.println("Usage: wordcount <in> [<in>...] <out>");
      System.exit(2);
    }
    // 作业调度
    Job job = new Job(conf, "word count");
    job.setJarByClass(WordCount.class);// 指定作业调度的类
    job.setMapperClass(TokenizerMapper.class);//指定Mapper类
    job.setCombinerClass(IntSumReducer.class);//指定Combiner类
    job.setReducerClass(IntSumReducer.class);//指定Reducer类
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);
    for (int i = 0; i < otherArgs.length - 1; ++i) {    //传入的文件参数可为多个【最后一个是输出文件】
      FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
    }
    FileOutputFormat.setOutputPath(job,
      new Path(otherArgs[otherArgs.length - 1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);//等待执行，0是正常退出，1是错误退出
  }
}

Windows下实现MapReduce编程初步

宿主机上开发环境配置

基于MapReduce统计学生平均成绩

如图，在hdfs的/expr/studentgrades/grades/ 下创建，几个文件，随便写几行数据，类似如下(学号 成绩)：

1
2
3
1001 90
1002 100
...

代码及注释如下：

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package gradesAverage;

import java.io.IOException;
import java.util.StringTokenizer;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import mapReduceTest.wordCount.WordCount;
import mapReduceTest.wordCount.WordCount.IntSumReducer;
import mapReduceTest.wordCount.WordCount.TokenizerMapper;

public class GradesAverage {

    public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> {
        private Text student = new Text();
        private IntWritable grade = new IntWritable();

        /* (non-Javadoc)
         * @see org.apache.hadoop.mapreduce.Mapper#map(KEYIN, VALUEIN, org.apache.hadoop.mapreduce.Mapper.Context)
         */
        /* (non-Javadoc)
         * @see org.apache.hadoop.mapreduce.Mapper#map(KEYIN, VALUEIN, org.apache.hadoop.mapreduce.Mapper.Context)
         */
        public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
//          StringTokenizer iTokenizer = new StringTokenizer(value.toString(),"\n");
            System.out.println("key is："+key+"value is: "+value.toString());
//          while (iTokenizer.hasMoreTokens()) {
//              
//          }
            String[] list_strs = value.toString().split(" ");
            // 因为每行只有一个学号和对应成绩，不需要考虑切分多个词
            student.set(list_strs[0]);
            grade.set(Integer.parseInt(list_strs[1]));
            context.write(student, grade);
            
//          String line = value.toString(); //将输入的纯文本文件的数据转化成String
//          System.out.println(line);//为了便于程序的调试，输出读入的内容   
//                           //将输入的数据先按行进行分割
//          StringTokenizer tokenizerArticle = new StringTokenizer(line,"\n"); 
//                  //分别对每一行进行处理
//          while(tokenizerArticle.hasMoreTokens()){
//                              //每行按空格划分
//          StringTokenizer tokenizerLine = new StringTokenizer(tokenizerArticle.nextToken()); 
//          String strName = tokenizerLine.nextToken(); //学生姓名部分  
//          String strScore = tokenizerLine.nextToken();//成绩部分
//          Text name = new Text(strName);//学生姓名  
//          int scoreInt = Integer.parseInt(strScore);//学生成绩score of student
//          context.write(name, new IntWritable(scoreInt));//输出姓名和成绩
//          }
        }
    }

    public static class gradesAverageReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        private IntWritable gradesSum = new IntWritable();

        public void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int sum = 0;
            int grades = 0;
            for (IntWritable val : values) {
                sum += 1;
                grades += val.get();
            }
            System.out.println("student is:"+key.toString()+",grades is:"+grades+",sum is:"+sum);
            gradesSum.set((int)grades/sum);
            context.write(key, gradesSum);
        }
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        // 1.设置HDFS配置信息
        String namenode_ip = "192.168.17.10";
        String hdfs = "hdfs://" + namenode_ip + ":9000";
        Configuration conf = new Configuration(); // Hadoop配置类
        conf.set("fs.defaultFS", hdfs);
        conf.set("mapreduce.app-submission.cross-platform", "true"); // 集群交叉提交
        /*
         * conf.set("hadoop.job.user", "hadoop"); conf.set("mapreduce.framework.name",
         * "yarn"); conf.set("mapreduce.jobtracker.address", namenode_ip + ":9001");
         * conf.set("yarn.resourcemanager.hostname", namenode_ip);
         * conf.set("yarn.resourcemanager.resource-tracker.address", namenode_ip +
         * ":8031"); conf.set("yarn.resourcemtanager.address", namenode_ip + ":8032");
         * conf.set("yarn.resourcemanager.admin.address", namenode_ip + ":8033");
         * conf.set("yarn.resourcemanager.scheduler.address", namenode_ip + ":8034");
         * conf.set("mapreduce.jobhistory.address", namenode_ip + ":10020");
         */

        // 2.设置MapReduce作业配置信息
        String jobName = "GradesAverage"; // 定义作业名称
        Job job = Job.getInstance(conf, jobName);
        job.setJarByClass(GradesAverage.class); // 指定作业类
        job.setJar("export\\GradesAverage.jar"); // 指定本地jar包
        job.setMapperClass(TokenizerMapper.class);
        job.setCombinerClass(gradesAverageReducer.class); // 指定Combiner类
        job.setReducerClass(gradesAverageReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // 3.设置作业输入和输出路径
        String dataDir = "/expr/studentgrades/grades"; // 实验数据目录
        String outputDir = "/expr/studentgrades/output"; // 实验输出目录
        Path inPath = new Path(hdfs + dataDir);
        Path outPath = new Path(hdfs + outputDir);
        FileInputFormat.addInputPath(job, inPath);
        FileOutputFormat.setOutputPath(job, outPath);
        // 如果输出目录已存在则删除
        FileSystem fs = FileSystem.get(conf);
        if (fs.exists(outPath)) {
            fs.delete(outPath, true);
        }

        // 4.运行作业
        System.out.println("Job: " + jobName + " is running...");
        if (job.waitForCompletion(true)) {
            System.out.println("统计 success!");
            System.exit(0);
        } else {
            System.out.println("统计 failed!");
            System.exit(1);
        }
    }
}

运行结果如下：

1
2


查看平均成绩结果文件，目录结构如图