特点
1、网购的东西价格相对都较低；
2、足不出户，在网络就可以买东西，并可以直接送到家。
缺点：
1、网购可能有风险，比如假的、坏的等等；
2、在运输当中可能会有破损的风险，虽然可以退换货，但时间上也比较浪费。
网上采购以计算机和网络技术为载体，通过网络这种成熟、便利的工具寻找产品及供应商资源，利用网络信息交流的便捷与高效进行产品的性能价格对比，并将网上信息处理和网下实际采购操作过程相结合的一种新的采购模式。
采购流程：采购申请计划（有使用部门提出）——采购计划（由采购计划员或采购员编制）——采购计会审（由采购部门评审）——采购渠道确定（由部门采购小组确定）——签订合同——采购——到货验收（由专职或兼职人员按计划、合同、标准等验收）——区分验收状态（合格、不合格、待验）——合格入库——开入库单——验收人或库管员确认——结算（领导在结算签字，付发票和入库单到财务办手续）
1：简述一个采购流程（看你是否能适应本公司的采购流程）
2：做为一名新采购，你觉得你应该怎样着手开展自己的工作（看你的适应能力与开展工作的能力)
3：做为一名采购，如何避免你负责的物料库存过高,如何确保物料及时到位（日常工作能力）
4：你觉得你的优点和缺点是什么？各举三点。（从你的优缺点看你是否适合做采购）
5：拿出一件你负责的物料，让你做成本分析，并报价（成本分析能力，基础市场掌握情况）
答：招标采购岗位面试题如下：
1、你为什么要选择做采购？谈谈你对采购的认识与看法。
2、“做一个合格的采购员”，你怎么理解“合格”这两个字？
3、你认为采购员与公司内部各部门的关系是什么?
4、做为一个采购员,你认为怎么样才处理好你与你上司之间的关系？
5、据我所知，***公司是一家不错的企业，你为什么辞去那份做采购的工作.
6、你做采购这么久了，以前工作中有没有遇到些什么困惑？是怎么解决的？
7、你认为影响采购工作有哪些？
8、你认为采购员与供应商的关系是什么?
9、在采购过程中，如果供应商给你回扣你怎么办？
10、 有一批物料，你已经下订单通知供应商生产，但接到业务通知说客户取消订单，向供应商所订的物料公司其它产品上用不到。请问如果你是采购，你会怎么处理？请给出2-3个解决方案 。
11、你为什么要选择做采购？谈谈你对采购的认识与看法。
12、“做一个合格的采购员”，你怎么理解”合格”这两个字？
13、你认为采购员与公司内部各部门的关系是什么?
14、做为一个采购员,你认为怎么样才处理好你与你上司之间的关系.
15、据我所知，***公司是一家不错的企业，你为什么辞去那份？
16、你做采购这么久了，以前工作中有没有遇到些什么困惑？是怎么解决的？
17、你认为影响采购工作有哪些？
18、你认为采购员与供应商的关系是什么?
作为全球最大的连锁快餐品牌之一，麦当劳致力于为顾客带来丰富多样的餐点选择，而其中最让人垂涎欲滴的当属麦当劳的甜品系列。无论是喜爱甜食的人还是儿童，每个人都能在麦当劳的甜品菜单上找到自己心仪的美味。
麦当劳的甜品系列可谓琳琅满目，包括各种经典甜品和季节限定口味。无论您是想要享受一份传统的香浓巧克力奶昔还是尝试一款新颖的水果派，麦当劳都能满足您的味蕾。
以下是麦当劳常见的甜品系列：
除了以上常见的甜品，麦当劳还会不定期推出限定口味的甜品，让顾客们尝试新的味道和口感。
麦当劳的甜品以使用新鲜优质的原料为标志，确保每一道甜品都能给客人带来满意的享受。
以下是麦当劳甜品常用的制作原料：
麦当劳对于原料的选择非常严格，并注重将新鲜、健康和美味带给顾客。
在如此多样的麦当劳甜品选择面前，您可能会觉得难以决定究竟选哪一款。以下是一些建议，帮助您选择合适的麦当劳甜品：
总之，选择麦当劳甜品时，根据个人口味、季节和搭配等因素进行综合考虑，能够帮助您找到最适合自己的甜品。
麦当劳的甜品系列丰富多样，无论您是喜欢巧克力、水果还是奶昔，都能够在麦当劳找到心仪的甜品。麦当劳注重使用新鲜优质的原料，为甜品带来口感和风味上的丰富。在选择麦当劳甜品时，考虑口味偏好、季节和搭配等因素，能够帮助您找到自己喜爱的甜品。
麦当劳是全球最知名的快餐连锁品牌之一，其在京都的发展历程也是备受瞩目的。自从麦当劳首次进军京都以来，它已经成为了当地人们钟爱的就餐选择。本文将为您介绍麦当劳在京都的发展历史，以及其取得的成功。
麦当劳首次进入京都市场是在20世纪80年代初。当时，它开设了第一家分店，为京都的居民和游客带来了全新的快餐体验。麦当劳以其优质的服务、美味的食物和便利的就餐环境，很快就赢得了消费者的喜爱。
首家麦当劳分店的开设引起了轰动。尽管日本已经有了一些快餐连锁店，但麦当劳在京都的开业带来了一种全新的氛围。它引领了快餐行业的潮流，为京都市场注入了新的活力。
麦当劳进军京都市场后，不仅在经营业绩上取得了巨大成功，还深深融入了当地文化。麦当劳积极学习京都的传统文化，将其与品牌相结合，推出了一系列独特的京都特色美食。
京都的传统美食是世界闻名的，麦当劳充分利用了这一优势，为顾客提供了原汁原味的京都味道。无论是抹茶冰淇淋、京都风味汉堡还是京都传统点心套餐，都成为了当地人和游客的首选。
作为一家国际性企业，麦当劳注重社会责任，积极参与当地社区的建设和慈善活动。在京都，麦当劳一直扮演着积极的角色，为社会发展做出了重要贡献。
麦当劳在京都的员工培训和晋升机制也备受赞赏。它致力于提供优质的员工培训计划，为年轻人提供发展机会。许多年轻人从麦当劳开始职业生涯，并在之后取得了更大的成功。
展望未来，麦当劳在京都市场将继续发展壮大。随着人们对快餐食品的需求增加，麦当劳将不断创新，满足消费者日益多样化的口味。同时，麦当劳也将继续关注当地社区的需求，积极参与环保和慈善事业。
麦当劳一直在不断努力，追求卓越。它希望为京都市场带来更多的就业机会、特色美食和美好记忆。相信在麦当劳的努力下，京都的居民和游客将继续享受到优质、便捷、美味的快餐体验。
本文将介绍天坛麦当劳，探讨其在中国快餐市场的地位和影响。天坛麦当劳是一家世界知名的快餐连锁品牌，在中国市场拥有广泛的消费者基础和强大的品牌认知度。
天坛麦当劳于1990年进入中国市场，成为中国第一家外资快餐企业。凭借其独特的产品、优质的服务和全球化的形象，在中国市场迅速获得成功。
天坛麦当劳不仅在中国市场引入了经典的汉堡、薯条和奶昔等产品，还根据中国人的口味和文化推出了一些特色菜品。比如，他们推出了辣鸡腿汉堡、麦辣鸡翅和麦香鱼等，以迎合中国消费者的口味喜好。
随着中国市场的扩大和消费水平的提高，天坛麦当劳在中国开设了越来越多的分店。如今，在全国范围内已经有数千家天坛麦当劳分店，遍布城市和乡村。
天坛麦当劳的进入不仅在中国快餐市场引发了竞争，也为中国消费者提供了更多多样化的餐饮选择。它的成功推动了中国快餐行业的发展和创新。
天坛麦当劳以其高效的服务、统一的品质标准和可靠的食品安全控制而深受消费者青睐。它的经营理念和管理经验对中国本土快餐企业的发展产生了积极的影响，并推动了整个行业向更高标准发展。
天坛麦当劳的成功还激发了中国快餐业的竞争态势。为了争夺市场份额，其他国际快餐品牌纷纷进入中国市场。这种竞争促使各家企业不断创新，提高产品质量和服务水平，从而让中国消费者受益。
随着中国经济的持续增长和消费者需求的变化，天坛麦当劳在中国市场仍然具备巨大的发展潜力。
天坛麦当劳正在致力于提供更多健康、营养的餐饮选择，以满足中国消费者对健康生活方式的追求。他们推出了一系列低糖、低盐、低脂肪的产品，并积极推广食品安全、环保和社会责任等方面的倡议。
另外，天坛麦当劳正在加大在中国市场的投资力度，改善就餐环境和服务质量。他们正在引入更加现代化的装修设计，提供更加舒适和便捷的用餐体验。
总的来说，天坛麦当劳作为中国快餐市场的领军品牌，将继续在中国市场发挥重要作用。他们将通过不断创新和满足中国消费者的需求，实现更大的成功和更长远的发展。
作为全球知名的快餐品牌，麦当劳不仅在正餐方面有着出色的表现，其甜点也是非常值得一试的。下面就为大家推荐几款麦当劳的甜点，让你在享受美食的同时，也能感受到麦当劳的独特魅力。
麦当劳的冰淇淋有多种口味可选，口感细腻，甜度适中，是夏季消暑的好选择。推荐尝试其经典口味香草冰淇淋和巧克力冰淇淋。
麦当劳的奶昔系列也是非常丰富的，有各种水果口味可选。推荐尝试其经典口味草莓奶昔和芒果奶昔。
麦当劳的甜筒口感酥脆，甜度适中，是小朋友们非常喜欢的一款甜点。推荐尝试其经典口味巧克力甜筒。
麦当劳的布丁口感Q弹，甜度适中，非常适合作为餐后甜点。推荐尝试其经典口味芒果布丁。
麦当劳的饼干系列也是非常丰富的，有各种口味可选。其中，巧克力饼干和芝士饼干是其中的明星产品，口感酥脆，非常好吃。
麦当劳的果冻系列也是非常受欢迎的甜点之一。其中，草莓果冻和葡萄果冻是其中的明星产品，口感Q弹，甜度适中。
总的来说，麦当劳的甜点不仅口感丰富多样，而且品质也非常有保障。无论是作为餐前甜点还是餐后甜点，都是非常不错的选择。希望这些推荐能够满足你的味蕾需求，让你在品尝美食的同时，也能感受到麦当劳的独特魅力。
麦当劳（McDonald's）是全球最大的快餐连锁企业之一，其股票一直备受投资者关注。在决定投资麦当劳股票之前，了解相关的基本信息和投资策略非常重要。
作为全球最大的快餐连锁企业之一，麦当劳在全球拥有数千家分店。麦当劳以其标志性的金拱门和丰富多样的快餐菜单而闻名。公司的业务在全球范围内稳步增长，其独特的经营模式和品牌价值使其成为吸引投资者的对象。
虽然麦当劳股票具有一定的投资优势，但在投资麦当劳股票时，投资者也需要注意以下几点：
投资麦当劳股票是一个有吸引力的选择，麦当劳作为全球快餐巨头，在全球市场上享有较高的竞争优势。投资者应该密切关注麦当劳的发展动态和公司治理方面的信息，并根据个人的投资目标和风险承受能力制定合理的投资策略。
感谢您阅读本文，希望能够为您的投资决策提供一些有用的信息和参考。
之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。
训练数据：
Day Outlook Temperature Humidity Wind PlayTennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Strong Yes
D8 Sunny Mild High Weak No
D9 Sunny Cool Normal Weak Yes
D10 Rain Mild Normal Weak Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No
检测数据：
sunny，hot，high，weak
结果：
Yes=》 0.007039
No=》 0.027418
于是使用Java代码调用Mahout的工具类实现分类。
基本思想：
1. 构造分类数据。
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
接下来贴下我的代码实现=》
1. 构造分类数据：
在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。
数据文件格式，如D1文件内容： Sunny Hot High Weak
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》
package myTesting.bayes;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.util.ToolRunner;
import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;
import org.apache.mahout.text.SequenceFilesFromDirectory;
import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;
public class PlayTennis1 {
private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";
/*
* 测试代码
*/
public static void main(String[] args) {
//将训练数据转换成 vector数据
makeTrainVector();
//产生训练模型
makeModel(false);
//测试检测数据
BayesCheckData.printResult();
}
public static void makeCheckVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"testinput";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeTrainVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"input";
String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeModel(boolean completelyNB){
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";
String model = WORK_DIR+Path.SEPARATOR+"model";
String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";
Path in = new Path(input);
Path out = new Path(model);
Path label = new Path(labelindex);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
if(fs.exists(label)){
//boolean参数是，是否递归删除的意思
fs.delete(label, true);
}
TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();
String[] params =null;
if(completelyNB){
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};
}else{
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};
}
ToolRunner.run(tnbj, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("生成训练模型失败！");
System.exit(3);
}
}
}
package myTesting.bayes;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.common.Pair;
import org.apache.mahout.common.iterator.sequencefile.PathType;
import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;
import org.apache.mahout.math.RandomAccessSparseVector;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.Vector.Element;
import org.apache.mahout.vectorizer.TFIDF;
import com.google.common.collect.ConcurrentHashMultiset;
import com.google.common.collect.Multiset;
public class BayesCheckData {
private static StandardNaiveBayesClassifier classifier;
private static Map<String, Integer> dictionary;
private static Map<Integer, Long> documentFrequency;
private static Map<Integer, String> labelIndex;
public void init(Configuration conf){
try {
String modelPath = "/zhoujianfeng/playtennis/model";
String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";
String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";
String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";
dictionary = readDictionnary(conf, new Path(dictionaryPath));
documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));
labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));
NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);
classifier = new StandardNaiveBayesClassifier(model);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("检测数据构造成vectors初始化时报错。。。。");
System.exit(4);
}
}
/**
* 加载字典文件，Key: TermValue； Value：TermID
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {
Map<String, Integer> dictionnary = new HashMap<String, Integer>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
String name = path.getName();
return name.startsWith("dictionary.file");
}
};
for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {
dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());
}
return dictionnary;
}
/**
* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {
Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
return path.getName().startsWith("part-r");
}
};
for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {
documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());
}
return documentFrequency;
}
public static String getCheckResult(){
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String classify = "NaN";
BayesCheckData cdv = new BayesCheckData();
cdv.init(conf);
System.out.println("init done...............");
Vector vector = new RandomAccessSparseVector(10000);
TFIDF tfidf = new TFIDF();
//sunny，hot，high，weak
Multiset<String> words = ConcurrentHashMultiset.create();
words.add("sunny",1);
words.add("hot",1);
words.add("high",1);
words.add("weak",1);
int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数
for (Multiset.Entry<String> entry : words.entrySet()) {
String word = entry.getElement();
int count = entry.getCount();
Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，
if (StringUtils.isEmpty(wordId.toString())){
continue;
}
if (documentFrequency.get(wordId) == null){
continue;
}
Long freq = documentFrequency.get(wordId);
double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);
vector.setQuick(wordId, tfIdfValue);
}
// 利用贝叶斯算法开始分类,并提取得分最好的分类label
Vector resultVector = classifier.classifyFull(vector);
double bestScore = -Double.MAX_VALUE;
int bestCategoryId = -1;
for(Element element: resultVector.all()) {
int categoryId = element.index();
double score = element.get();
System.out.println("categoryId:"+categoryId+" score:"+score);
if (score > bestScore) {
bestScore = score;
bestCategoryId = categoryId;
}
}
classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";
return classify;
}
public static void printResult(){
System.out.println("检测所属类别是："+getCheckResult());
}
}
显示全部
收起
