actioncontext,doing的答句三年级

actioncontext，doing的答句三年级？

1. He is playing soccer.

2. Because the question is in present continuous tense, indicating an action that is currently happening. "Playing soccer" is a possible activity that someone could be doing at the moment.

3. Other possible answers could include "He is reading a book" or "He is watching TV".

The answer depends on the context and what the person in question is actually doing.

最近在学习pyspark？

Spark提供了一个Python_Shell，即pyspark，从而可以以交互的方式使用Python编写Spark程序。

有关Spark的基本架构介绍参考http://blog.csdn.net/cymy001/article/details/78483614；

有关Pyspark的环境配置参考http://blog.csdn.net/cymy001/article/details/78430892。

pyspark里最核心的模块是SparkContext（简称sc）,最重要的数据载体是RDD。RDD就像一个NumPy array或者一个Pandas Series，可以视作一个有序的item集合。只不过这些item并不存在driver端的内存里，而是被分割成很多个partitions，每个partition的数据存在集群的executor的内存中。

引入Python中pyspark工作模块

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

#任何Spark程序都是SparkContext开始的，SparkContext的初始化需要一个SparkConf对象，SparkConf包含了Spark集群配置的各种参数(比如主节点的URL)。初始化后，就可以使用SparkContext对象所包含的各种方法来创建和操作RDD和共享变量。Spark shell会自动初始化一个SparkContext(在Scala和Python下可以，但不支持Java)。

#getOrCreate表明可以视情况新建session或利用已有的session

SparkSession是Spark 2.0引入的新概念。SparkSession为用户提供了统一的切入点，来让用户学习spark的各项功能。在spark的早期版本中，SparkContext是spark的主要切入点，由于RDD是主要的API，我们通过sparkcontext来创建和操作RDD。对于每个其他的API，我们需要使用不同的context。例如，对于Streming，我们需要使用StreamingContext；对于sql，使用sqlContext；对于hive，使用hiveContext。但是随着DataSet和DataFrame的API逐渐成为标准的API，就需要为他们建立接入点。所以在spark2.0中，引入SparkSession作为DataSet和DataFrame API的切入点。SparkSession实质上是SQLContext和HiveContext的组合(未来可能还会加上StreamingContext)，所以在SQLContext和HiveContext上可用的API在SparkSession上同样是可以使用的。SparkSession内部封装了SparkContext，所以计算实际上是由SparkContext完成的。

初始化RDD的方法

（1）本地内存中已经有一份序列数据(比如python的list)，可以通过sc.parallelize去初始化一个RDD。当执行这个操作以后，list中的元素将被自动分块(partitioned)，并且把每一块送到集群上的不同机器上。

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

#（a）利用list创建一个RDD;使用sc.parallelize可以把Python list，NumPy array或者Pandas Series,Pandas DataFrame转成Spark RDD。

rdd = sc.parallelize([1,2,3,4,5])

rdd

#Output:ParallelCollectionRDD[0] at parallelize at PythonRDD.scala:480

#（b）getNumPartitions()方法查看list被分成了几部分

rdd.getNumPartitions()

#Output:4

#（c）glom().collect()查看分区状况

rdd.glom().collect()

#Output:[[1], [2], [3], [4, 5]]

在这个例子中，是一个4-core的CPU笔记本;Spark创建了4个executor，然后把数据分成4个块。colloect()方法很危险，数据量上BT文件读入会爆掉内存……

（2）创建RDD的另一个方法是直接把文本读到RDD。文本的每一行都会被当做一个item，不过需要注意的一点是，Spark一般默认给定的路径是指向HDFS的，如果要从本地读取文件的话，给一个file://开头（windows下是以file:\\开头）的全局路径。

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

#（a）记录当前pyspark工作环境位置

import os

cwd=os.getcwd()

cwd

#Output:'C:\\Users\\Yu\\0JulyLearn\\5weekhadoopspark'

#（b）要读入的文件的全路径

rdd=sc.textFile("file:\\\\\\" + cwd + "\\names\yob1880.txt")

rdd

#Output:file:\\\C:\Users\Yu\0JulyLearn\5weekhadoopspark\names\yob1880.txt MapPartitionsRDD[3] at textFile at NativeMethodAccessorImpl.java:0

#（c）first()方法取读入的rdd数据第一个item

rdd.first()

#Output:'Mary,F,7065'

甚至可以sc.wholeTextFiles读入整个文件夹的所有文件。但是要特别注意，这种读法，RDD中的每个item实际上是一个形如(文件名，文件所有内容)的元组。读入整个文件夹的所有文件。

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

#记录当前pyspark工作环境位置

import os

cwd=os.getcwd()

cwd

#Output:'C:\\Users\\Yu\\0JulyLearn\\5weekhadoopspark'

rdd = sc.wholeTextFiles("file:\\\\\\" + cwd + "\\names\yob1880.txt")

rdd

#Output:org.apache.spark.api.java.JavaPairRDD@12bcc15

rdd.first()

Output:

('file:/C:/Users/Yu/0JulyLearn/5weekhadoopspark/names/yob1880.txt',

其余初始化RDD的方法，包括：HDFS上的文件，Hive中的数据库与表，Spark SQL得到的结果。这里暂时不做介绍。

RDD Transformation

（1）RDDs可以进行一系列的变换得到新的RDD，有点类似列表推导式的操作，先给出一些RDD上最常用到的transformation：

map() 对RDD的每一个item都执行同一个操作

flatMap() 对RDD中的item执行同一个操作以后得到一个list，然后以平铺的方式把这些list里所有的结果组成新的list

filter() 筛选出来满足条件的item

distinct() 对RDD中的item去重

sample() 从RDD中的item中采样一部分出来，有放回或者无放回

sortBy() 对RDD中的item进行排序

如果想看操作后的结果，可以用一个叫做collect()的action把所有的item转成一个Python list。数据量大时，collect()很危险……

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

numbersRDD = sc.parallelize(range(1,10+1))

print(numbersRDD.collect())

#map()对RDD的每一个item都执行同一个操作

squaresRDD = numbersRDD.map(lambda x: x**2) # Square every number

print(squaresRDD.collect())

#filter()筛选出来满足条件的item

filteredRDD = numbersRDD.filter(lambda x: x % 2 == 0) # Only the evens

print(filteredRDD.collect())

#Output:

#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#[2, 4, 6, 8, 10]

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

#flatMap() 对RDD中的item执行同一个操作以后得到一个list，然后以平铺的方式把这些list里所有的结果组成新的list

sentencesRDD=sc.parallelize(['Hello world','My name is Patrick'])

wordsRDD=sentencesRDD.flatMap(lambda sentence: sentence.split(" "))

print(wordsRDD.collect())

print(wordsRDD.count())

#Output:

#['Hello', 'world', 'My', 'name', 'is', 'Patrick']

对比一下：

这里如果使用map的结果是[[‘Hello’, ‘world’], [‘My’, ‘name’, ‘is’, ‘Patrick’]]，

使用flatmap的结果是全部展开[‘Hello’, ‘world’, ‘My’, ‘name’, ‘is’, ‘Patrick’]。

flatmap即对应Python里的如下操作：

l = ['Hello world', 'My name is Patrick']

ll = []

for sentence in l:

ll = ll + sentence.split(" ") #+号作用,two list拼接

（2）最开始列出的各个Transformation，可以一个接一个地串联使用，比如:

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

def doubleIfOdd(x):

if x % 2 == 1:

return 2 * x

else:

return x

numbersRDD = sc.parallelize(range(1,10+1))

resultRDD = (numbersRDD

.map(doubleIfOdd) #map,filter,distinct()

.filter(lambda x: x > 6)

.distinct()) #distinct()对RDD中的item去重

resultRDD.collect()

#Output:[8, 10, 18, 14]

（3）当遇到更复杂的结构，比如被称作“pair RDDs”的以元组形式组织的k-v对（key, value），Spark中针对这种item结构的数据，定义了一些transform和action:

reduceByKey(): 对所有有着相同key的items执行reduce操作

groupByKey(): 返回类似(key, listOfValues)元组的RDD，后面的value List 是同一个key下面的

sortByKey(): 按照key排序

countByKey(): 按照key去对item个数进行统计

collectAsMap(): 和collect有些类似，但是返回的是k-v的字典

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

rdd=sc.parallelize(["Hello hello", "Hello New York", "York says hello"])

resultRDD=(rdd

.flatMap(lambda sentence:sentence.split(" "))

.map(lambda word:word.lower())

.map(lambda word:(word, 1)) #将word映射成(word,1)

.reduceByKey(lambda x, y: x + y)) #reduceByKey对所有有着相同key的items执行reduce操作

resultRDD.collect()

#Output:[('hello', 4), ('york', 2), ('says', 1), ('new', 1)]

result = resultRDD.collectAsMap() #collectAsMap类似collect,以k-v字典的形式返回

result

#Output:{'hello': 4, 'new': 1, 'says': 1, 'york': 2}

resultRDD.sortByKey(ascending=True).take(2) #sortByKey按键排序

#Output:[('hello', 4), ('new', 1)]

#取出现频次最高的2个词

print(resultRDD

.sortBy(lambda x: x[1], ascending=False)

.take(2))

#Output:[('hello', 4), ('york', 2)]

RDD间的操作

（1）如果有2个RDD，可以通过下面这些操作，对它们进行集合运算得到1个新的RDD

rdd1.union(rdd2): 所有rdd1和rdd2中的item组合（并集）

rdd1.intersection(rdd2): rdd1 和 rdd2的交集

rdd1.substract(rdd2): 所有在rdd1中但不在rdd2中的item（差集）

rdd1.cartesian(rdd2): rdd1 和 rdd2中所有的元素笛卡尔乘积（正交和）

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

#初始化两个RDD

numbersRDD = sc.parallelize([1,2,3])

moreNumbersRDD = sc.parallelize([2,3,4])

numbersRDD.union(moreNumbersRDD).collect() #union()取并集

#Output:[1, 2, 3, 2, 3, 4]

numbersRDD.intersection(moreNumbersRDD).collect() #intersection()取交集

#Output:[2, 3]

numbersRDD.subtract(moreNumbersRDD).collect() #substract()取差集

#Output:[1]

numbersRDD.cartesian(moreNumbersRDD).collect() #cartesian()取笛卡尔积

#Output:[(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4)]

（2）在给定2个RDD后，可以通过一个类似SQL的方式去join它们

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

# Home of different people

homesRDD = sc.parallelize([

('Brussels', 'John'),

('Brussels', 'Jack'),

('Leuven', 'Jane'),

('Antwerp', 'Jill'),

])

# Quality of life index for various cities

lifeQualityRDD = sc.parallelize([

('Brussels', 10),

('Antwerp', 7),

('RestOfFlanders', 5),

])

homesRDD.join(lifeQualityRDD).collect() #join

#Output:

#[('Antwerp', ('Jill', 7)),

# ('Brussels', ('John', 10)),

# ('Brussels', ('Jack', 10))]

homesRDD.leftOuterJoin(lifeQualityRDD).collect() #leftOuterJoin

#Output:

#[('Antwerp', ('Jill', 7)),

# ('Leuven', ('Jane', None)),

# ('Brussels', ('John', 10)),

# ('Brussels', ('Jack', 10))]

homesRDD.rightOuterJoin(lifeQualityRDD).collect() #rightOuterJoin

#Output:

#[('Antwerp', ('Jill', 7)),

# ('RestOfFlanders', (None, 5)),

# ('Brussels', ('John', 10)),

# ('Brussels', ('Jack', 10))]

homesRDD.cogroup(lifeQualityRDD).collect() #cogroup

#Output:

#[('Antwerp',

# (<pyspark.resultiterable.ResultIterable at 0x73d2d68>,

# <pyspark.resultiterable.ResultIterable at 0x73d2940>)),

# ('RestOfFlanders',

# (<pyspark.resultiterable.ResultIterable at 0x73d2828>,

# <pyspark.resultiterable.ResultIterable at 0x73d2b70>)),

# ('Leuven',

# (<pyspark.resultiterable.ResultIterable at 0x73d26a0>,

# <pyspark.resultiterable.ResultIterable at 0x7410a58>)),

# ('Brussels',

# (<pyspark.resultiterable.ResultIterable at 0x73d2b38>,

# <pyspark.resultiterable.ResultIterable at 0x74106a0>))]

# Oops! Those <ResultIterable>s are Spark's way of returning a list

# that we can walk over, without materializing the list.

# Let's materialize the lists to make the above more readable:

(homesRDD

.cogroup(lifeQualityRDD)

.map(lambda x:(x[0], (list(x[1][0]), list(x[1][1]))))

.collect())

#Output:

#[('Antwerp', (['Jill'], [7])),

# ('RestOfFlanders', ([], [5])),

# ('Leuven', (['Jane'], [])),

# ('Brussels', (['John', 'Jack'], [10]))]

惰性计算，actions方法

特别注意：Spark的一个核心概念是惰性计算。当你把一个RDD转换成另一个的时候，这个转换不会立即生效执行！！！Spark会把它先记在心里，等到真的有actions需要取转换结果时，才会重新组织transformations(因为可能有一连串的变换)。这样可以避免不必要的中间结果存储和通信。

常见的action如下，当它们出现的时候，表明需要执行上面定义过的transform了:

collect(): 计算所有的items并返回所有的结果到driver端，接着 collect()会以Python list的形式返回结果

first(): 和上面是类似的，不过只返回第1个item

take(n): 类似，但是返回n个item

count(): 计算RDD中item的个数

top(n): 返回头n个items，按照自然结果排序

reduce(): 对RDD中的items做聚合

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

rdd = sc.parallelize(range(1,10+1))

rdd.reduce(lambda x, y: x + y) #reduce(): 对RDD中的items做聚合

#Output:55

reduce的原理：先在每个分区(partition)里完成reduce操作，然后再全局地进行reduce。

有时候需要重复用到某个transform序列得到的RDD结果。但是一遍遍重复计算显然是要开销的，所以我们可以通过一个叫做cache()的操作把它暂时地存储在内存中。缓存RDD结果对于重复迭代的操作非常有用，比如很多机器学习的算法，训练过程需要重复迭代。

import pyspark

from pyspark import SparkContext as sc

from pyspark import SparkConf

conf=SparkConf().setAppName("miniProject").setMaster("local[*]")

sc=SparkContext.getOrCreate(conf)

import numpy as np

numbersRDD = sc.parallelize(np.linspace(1.0, 10.0, 10))

squaresRDD = numbersRDD.map(lambda x: x**2)

squaresRDD.cache() # Preserve the actual items of this RDD in memory

avg = squaresRDD.reduce(lambda x, y: x + y) / squaresRDD.count()

print(avg)

#Output:38.5

vuex流程面试题？

1. vuex中如何异步修改数据？

首先, 概括下 vuex基本使用流程为: 在action中分发异步请求, 在异步回调中使用commit提交mutation,在mutation中修改State, 使用getters对state的值进行计算封装.

2.如何在模块中访问全局内容？

如果你希望使用全局 state 和 getter，rootState 和 rootGetter 会作为第三和第四参数传入 getter，也会通过 context 对象的属性传入 action。

若需要在全局命名空间内分发 action 或提交 mutation，将 { root: true } 作为第三参数传给 dispatch 或 commit 即可。

3.vuex中划分模块的好处？

（1）. state更为容易管理，尤其在团队人数多的时候，自己负责自己的state，既保证store了完整的状态树，又避免了相互之间的state冲突

（2）. 不管是命名，或是操作 state 都会变得更加扁平和直观

4、vuex 的 store 特性是什么

(1) vuex 就是一个仓库，仓库里放了很多对象。其中 state 就是数据源存放地，对应于一般 vue 对象里面的 data

(2) state 里面存放的数据是响应式的，vue 组件从 store 读取数据，若是 store 中的数据发生改变，依赖这相数据的组件也会发生更新

(3) 它通过 mapState 把全局的 state 和 getters 映射到当前组件的 computed 计算属性

5、 vuex 的 getter 特性是什么

(1) getter 可以对 state 进行计算操作，它就是 store 的计算属性

(2) 虽然在组件内也可以做计算属性，但是 getters 可以在多个组件之间复用

(3) 如果一个状态只在一个组件内使用，是可以不用 getters

(当然还有还都哦好多，我目前就只涉及到这些)

6. 谈谈你对vuex的理解

（1）先说一下vuex是什么

（2）vuex可以干什么

（3）怎样使用vuex

（可以按照这几个步骤来，具体的就看我上面所写的）

7. Vue.js中ajax请求代码应该写在组件的methods中还是vuex的actions中？

(1）.如果请求来的数据是不是要被其他组件公⽤，仅仅在请求的组件内使⽤，就不需要放⼊vuex 的state⾥。

(2). 如果被其他地⽅复⽤，这个很⼤⼏率上是需要的，如果需要，请将请求放⼊action⾥，⽅便复⽤。

电子邮件导出的excel表格文件名乱码是什么原因？

因为经常要用到导出功能，之前因为文件名乱码，所以都用英文或是拼音缩写来代替，今天特意要接觉下这个问题。顺便记录下。望对小白有用。

/**

* 导出结算详情列表

* @return

public void depositLogExport()

{

String title = "押金流水报表";

String excelName = "押金流水报表.xls";

OutputStream os = null;

try

{

int shopId=new Long(getShopLoginer().getShop().getId()).intValue();

if(date==null){

date=new DateBean();

}

int count=service.getCount(shopId, date);

Page<DepositLog> pageResult =new Page<DepositLog>();

if(count>0){

pageResult = service.list(1, count, shopId, date);

}

List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();

double shopDeposit=getShopLoginer().getShop().getDeposit();

for (DepositLog s : pageResult.getData())

{

Map<String, Object> map = new HashMap<String, Object>();

map.put("id", s.getId());

map.put("depositSn", s.getDepositSn());

map.put("createTime", StringUtils.timestamptoString(s.getCreateTime()));

map.put("type", type[s.getType()]);

map.put("amount", s.getAmount());

map.put("depositRest", s.getDepositRest());

map.put("depositGap", shopDeposit-s.getDepositRest());

map.put("userName", s.getUserName());

map.put("remarks", s.getRemarks());

list.add(map);

}

// 表格表头

String[] header = {"流水号","流水时间","类型","流水金额","押金余额","押金缺口","操作人","备注"};

// 对应Map中的key

String[] key = { "depositSn", "createTime","type",

"amount", "depositRest", "depositGap", "userName", "remarks"};

HSSFWorkbook workbook = null;

HttpServletResponse response = ServletActionContext

.getResponse();

workbook = ExportUtil.workPaperExport(list, header, key,

title, true, null, null, null);

os = response.getOutputStream();

response.setHeader("Content-disposition",

"attachment; filename=" + toUtf8String(excelName));

response.setContentType("application/msexcel;charset=UTF-8");

workbook.write(os);

os.flush();

} catch (Exception e) {

if (logger.isDebugEnabled())

logger.error(e.getMessage(), e);

e.printStackTrace();

} finally {

try {

if (os != null)

os.close();

} catch (IOException e) {

if (logger.isInfoEnabled())

logger.error(e.getMessage(), e);

e.printStackTrace();

}

//return null;

}

//文件名乱码处理

public static String toUtf8String(String s){

StringBuffer sb = new StringBuffer();

for (int i=0;i<s.length();i++){

char c = s.charAt(i);

if (c >= 0 && c <= 255){sb.append(c);}

else{

byte[] b;

try { b = Character.toString(c).getBytes("utf-8");}

catch (Exception ex) {

System.out.println(ex);

b = new byte[0];

}

for (int j = 0; j < b.length; j++) {

int k = b[j];

if (k < 0) k += 256;

sb.append("%" + Integer.toHexString(k).toUpperCase());

}

return sb.toString();

}

java中怎么把文件上传到服务器的指定路径？

String realpath = ServletActionContext.getServletContext().getRealPath("/upload") ;//获取服务器路径 String[] targetFileName = uploadFileName; for (int i = 0; i < upload.length; i++) { File target = new File(realpath, targetFileName[i]); FileUtils.copyFile(upload[i], target)

; //这是一个文件复制类copyFile()里面就是IO操作，如果你不用这个类也可以自己写一个IO复制文件的类 } 其中private File[] upload;// 实际上传文件 private String[] uploadContentType; // 文件的内容类型 private String[] uploadFileName; // 上传文件名这三个参数必须这样命名，因为文件上传控件默认是封装了这3个参数的，且在action里面他们应有get，set方法！