# encoding:utf-8
import requests
import base64
import json
# 获取token
# client_id 为官网获取的AK， client_secret 为官网获取的SK
def get_token(client_id, client_secret):
url="https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials"
params=
response=requests.get(url, params=params)
resultJson=response.json()
return resultJson['access_token']
# 根据图片名读取图片，并转换成base64
def read_photo(name):
with open(name, 'rb') as f:
base64_data=base64.b64encode(f.read())
base64_code=base64_data.decode()
return base64_code
# 调用百度的接口，实现融合图片
def face_fusion(token, template, target):
url='https://aip.baidubce.com/rest/2.0/face/v1/merge'
request_url=url + '?access_token=' + token
params={
"image_template": {
"image": template,
"image_type": "BASE64",
"quality_control": "NONE"
},
"image_target": {
"image": target,
"image_type": "BASE64",
"quality_control": "NONE"
},
"merge_degree": "NORMAL"
}
params=json.dumps(params)
headers={'content-type': 'application/json'}
result=requests.post(request_url, data=params, headers=headers).json()
if result['error_code']==0:
res=result["result"]["merge_image"]
down_photo(res)
else:
print(str(result['error_code'])+result['error_msg'])
# 下载融合后图片
def down_photo(data):
imagedata=base64.b64decode(data)
file=open('https://blog.51cto.com/u_14824425/result.jpg', "wb")
file.write(imagedata)
# 主程序
if __name__=='__main__':
template=read_photo('img/jjy.jpg')
target=read_photo('img/mzc.jpeg')
token=get_token('你的ID', '你的key')
face_fusion(token, template, target)
先导入一些关系较少的实体：朝代，牌名，飞花令，诗词形式，类别，地点，事件，飞花令句子，诗人合称。
这些实体之前的关系比较清晰。
朝代：唐宋元明清
牌名分为：词牌名与曲牌名
飞花令：单个字
飞花令句子：与飞花令关联
诗词形式：五言，七言，五言绝句，七言绝句，五言律诗，七言律诗
类别：是诗词的一种分类，也是极为简单。
地点实体：包含属性有古代地名，现今地名，经纬度
事件实体：包含属性有时间，地点，事件名
诗人合称：唐宋八大家，李杜。。。。
诗人，诗词
诗人实体与朝代，诗人，事件，地点
诗词与朝代，类别，诗词形式，牌名，诗人
补充关系
诗人和朝代两个节点是一起建立的，读取诗人的详情信息会包含对应的朝代信息，因此建立诗人节点同时也会建立朝代节点，如果已经建立则不创建新的朝代节点，只建立对应的关联关系。
诗人----朝代--->朝代
朝代----包含--->诗人
诗人的好友关系导入，将之前的好友关系梳理后，只建立有诗人节点的好友关系
诗人1---好友---->诗人2
诗人2---好友---->诗人1
诗人和诗人合称，关系如下：
诗人----合称---->诗人合称
诗人合称---包含--->诗人
诗人--轨迹-->地点
诗人--事迹--->事件
诗人----写作---->诗名
诗名----作者----->诗人
诗名----所属朝代--->朝代
朝代----包含诗词------>诗名
诗名----分类---->类别
类别---包含---->诗名
诗名-----形式----->诗词形式
诗词形式----包含---->诗名
诗名----词牌名|曲排名---->牌名
牌名----词牌名|曲排名---->诗名
诗句---关键字---->字
字-----诗句------>诗句
开始准备搭建flask框架，将可视化部分实现
构建性感分析的数据集
学习情感分析
package com.lh.std_everything.ui.home.hometype.studyshare.share;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import com.bumptech.glide.request.RequestOptions;
import com.lh.std_everything.R;
import com.lh.std_everything.ui.home.hometype.news.adapter.NewsAdapter;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
public class BooksAdapter extends RecyclerView.Adapter<BooksAdapter.MyViewHolder>{
JSONArray jsnotallow=new JSONArray();
private View itemview;
public String arr[]=;
public void setJsonArray(JSONArray jsonArray) {
this.jsonArray=jsonArray;
}
@NonNull
@Override
public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
LayoutInflater layoutInflater=LayoutInflater.from(parent.getContext());
itemview=layoutInflater.inflate(R.layout.cell_book,parent,false);
return new BooksAdapter.MyViewHolder(itemview);
}
@Override
public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
JSONObject bean=null;
try {
bean=jsonArray.getJSONObject(position);
holder.textViewName.setText(bean.getString("bookname"));
holder.textViewAuthor.setText(bean.getString("bookauthor"));
holder.textViewPublish.setText(bean.getString("bookpublish"));
String []urls=bean.getString("head").split("\\$");
RequestOptions options=new RequestOptions()
.error(R.drawable.error)
.placeholder(R.drawable.loading);
if(urls.length!=0) {
for(int i=0;i<urls.length;i++)
{
if(!urls[i].equals("null"))
{
Log.i("url",urls[i]);
Glide.with(itemview)
.load(urls[i])
.apply(options)
.into(holder.bookphoto);
break;
}
}
}
} catch (JSONException e) {
e.printStackTrace();
}
holder.itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Bundle bundle=new Bundle();
Intent intent=new Intent(itemview.getContext(), ShowBookActivity.class);
try {
bundle.putString("bookname", jsonArray.getJSONObject(position).getString("bookname"));
bundle.putString("bookauthor", jsonArray.getJSONObject(position).getString("bookauthor"));
bundle.putString("bookpublish", jsonArray.getJSONObject(position).getString("bookpublish"));
bundle.putString("username", jsonArray.getJSONObject(position).getString("username"));
bundle.putString("head", jsonArray.getJSONObject(position).getString("head"));
Log.i("bundle中的username:", ""+jsonArray.getJSONObject(position).getString("username"));
for(int i=1;i<=11;i++)
{
if(jsonArray.getJSONObject(position).has(arr[i]))
{
bundle.putString(arr[i], jsonArray.getJSONObject(position).getString(arr[i]));
}
}
} catch (JSONException e) {
e.printStackTrace();
}
intent.putExtras(bundle);
itemview.getContext().startActivity(intent);
}
});
}
@Override
public int getItemCount() {
return jsonArray.length();
}
static class MyViewHolder extends RecyclerView.ViewHolder{
ImageView bookphoto;
TextView textViewName,textViewAuthor,textViewPublish;
public MyViewHolder(@NonNull View itemView) {
super(itemView);
bookphoto=itemView.findViewById(R.id.bookimg);
textViewName=itemView.findViewById(R.id.booktitle);
textViewAuthor=itemView.findViewById(R.id.bookauthor);
textViewPublish=itemView.findViewById(R.id.bookpublish);
}
}
}
Index(['同学0', '同学1', '同学2', '同学3', '同学4', '同学5', '同学6', '同学7', '同学8', '同学9'], dtype='object')
Index(['语文', '数学', '英语', '政治', '体育'], dtype='object')
[[96 68 72 66 44]
[70 56 76 51 65]
[86 41 94 77 92]
[94 99 80 91 67]
[90 88 46 65 73]
[79 52 70 50 77]
[46 71 47 97 78]
[53 57 84 59 88]
[44 79 78 78 92]
[62 65 86 90 78]]
同学0 同学1 同学2 同学3 同学4 同学5 同学6 同学7 同学8 同学9
语文 96 70 86 94 90 79 46 53 44 62
数学 68 56 41 99 88 52 71 57 79 65
英语 72 76 94 80 46 70 47 84 78 86
政治 66 51 77 91 65 50 97 59 78 90
体育 44 65 92 67 73 77 78 88 92 78
index 语文 数学 英语 政治 体育
0 同学0 96 68 72 66 44
1 同学1 70 56 76 51 65
2 同学2 86 41 94 77 92
3 同学3 94 99 80 91 67
4 同学4 90 88 46 65 73
5 同学5 79 52 70 50 77
6 同学6 46 71 47 97 78
7 同学7 53 57 84 59 88
8 同学8 44 79 78 78 92
9 同学9 62 65 86 90 78
语文 数学 英语 政治 体育
0 96 68 72 66 44
1 70 56 76 51 65
2 86 41 94 77 92
3 94 99 80 91 67
4 90 88 46 65 73
5 79 52 70 50 77
6 46 71 47 97 78
7 53 57 84 59 88
8 44 79 78 78 92
9 62 65 86 90 78
语文 数学 英语 政治 体育
同学_0 96 68 72 66 44
同学_1 70 56 76 51 65
同学_2 86 41 94 77 92
同学_3 94 99 80 91 67
同学_4 90 88 46 65 73
同学_5 79 52 70 50 77
同学_6 46 71 47 97 78
同学_7 53 57 84 59 88
同学_8 44 79 78 78 92
同学_9 62 65 86 90 78
month year sale
0 1 2012 55
1 4 2014 40
2 7 2013 84
3 10 2014 31
month sale
year
2012 1 55
2014 4 40
2013 7 84
2014 10 31
sale
year month
2012 1 55
2014 4 40
2013 7 84
2014 10 31
# encoding:utf-8
from aip import AipFace
import base64
""" 你的APPID，API_KEY和SECRET_KEY """
APP_ID=''
API_KEY=''
SECRET_KEY=''
# 封装成函数，返回获取的client对象
def get_client(APP_ID, API_KEY, SECRET_KEY):
"""
返回client对象
:param APP_ID:
:param API_KEY:
:param SECRET_KEY:
:return:
"""
return AipFace(APP_ID, API_KEY, SECRET_KEY)
client=get_client(APP_ID, API_KEY, SECRET_KEY)
result=client.match([
{
'image': str(base64.b64encode(open('img/me.jpg', 'rb').read()), 'utf-8'),
'image_type': 'BASE64',
},
{
'image': str(base64.b64encode(open('img/xlf.jpg', 'rb').read()), 'utf-8'),
'image_type': 'BASE64',
}
])
if result['error_msg']=='SUCCESS':
score=result['result']['score']
if score>80:
print("照片相似度为："+str(score)+"基本确定是本人")
else:
print("照片相似度为：" + str(score) + "基本确定不是本人")
print(score)
else:
print('错误信息：', result['error_msg'])
package com.lh.std_everything.ui.home.hometype.studyshare.share;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.Spinner;
import android.widget.Toast;
import com.giftedcat.easylib.selector.MultiImageSelector;
import com.lh.std_everything.HttpUtil.HttpUtil;
import com.lh.std_everything.MainActivity;
import com.lh.std_everything.R;
import com.lh.std_everything.ui.home.hometype.dongtai.DongTaiActivity;
import com.lh.std_everything.ui.home.hometype.dongtai.NineGridAdapter;
import com.lh.std_everything.ui.home.hometype.dongtai.OnAddPicturesListener;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.Unbinder;
public class bookuploadActivity extends AppCompatActivity implements View.OnClickListener{
public EditText ed_title,ed_author,ed_publish;
public Spinner spinner;
public List<String> list=new ArrayList<>();
public ArrayAdapter<String> sadapter;
String selectString;
public ImageView submit;
public String title;
public String author;
public String publish;
private static final int REQUEST_IMAGE=2;
private int maxNum=9;
Unbinder unbinder;
ProgressBar progressBar;
public RecyclerView rvImages;
private Handler handle;
NineGridAdapter adapter;
private int uploadnum=0;
private int size;
private String urlimg;
private List<String> select;
List<String> mSelect;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_bookupload);
init();
list.add("图书照片");
list.add("第一章");
list.add("第二章");
list.add("第三章");
list.add("第四章");
list.add("第五章");
list.add("第六章");
list.add("第七章");
list.add("第八章");
list.add("第九章");
list.add("第十章");
list.add("其他");
sadapter=new ArrayAdapter<>(this,android.R.layout.simple_spinner_item,list);
sadapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spinner.setAdapter(sadapter);
spinner.setOnItemSelectedListener(new Spinner.OnItemSelectedListener(){
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
selectString=sadapter.getItem(position);
view.setVisibility(View.VISIBLE);
//Toast.makeText(bookuploadActivity.this,selectString,Toast.LENGTH_LONG).show();
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
selectString="NONE";
parent.setVisibility(View.VISIBLE);
}
});
submit.setOnClickListener(this);
}
public void init()
{
ed_title=findViewById(R.id.ed_booktitle);
ed_author=findViewById(R.id.ed_bookauthor);
ed_publish=findViewById(R.id.ed_bookpublish);
spinner=findViewById(R.id.spinner1);
rvImages=findViewById(R.id.rv_imgs);
unbinder=ButterKnife.bind(this);
submit=findViewById(R.id.submit);
progressBar=findViewById(R.id.progressBar);
mSelect=new ArrayList<>();
rvImages.setLayoutManager(new GridLayoutManager(this, 3));
adapter=new NineGridAdapter(bookuploadActivity.this, mSelect, rvImages);
adapter.setMaxSize(maxNum);
rvImages.setAdapter(adapter);
adapter.setOnAddPicturesListener(new OnAddPicturesListener() {
@Override
public void onAdd() {
pickImage();
}
});
}
@Override
public void onClick(View v) {
switch (v.getId())
{
case R.id.submit:
title=ed_title.getText().toString();
author=ed_author.getText().toString();
publish=ed_publish.getText().toString();
if(title.equals("") || author.equals("") || publish.equals("")|| selectString.equals(""))
{
Toast.makeText(bookuploadActivity.this,"请填写完整图书信息！",Toast.LENGTH_LONG).show();
return;
}
String username=MainActivity.getUsername();
handle=new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
switch (msg.what) {
case 100:
if (uploadnum < size) {
writeBookImg(select.get(uploadnum));
} else {
Toast.makeText(bookuploadActivity.this, "上传成功", Toast.LENGTH_SHORT).show();
progressBar.setVisibility(View.GONE);
}
break;
case 404:
Toast.makeText(bookuploadActivity.this, "上传失败,您可以点击上传按钮重新上传", Toast.LENGTH_SHORT).show();
progressBar.setVisibility(View.GONE);
break;
default:
break;
}
return true;
}
});
new Thread(new Runnable() {
@Override
public void run() {
String req="";
Log.i("输入的文本：", ""+title+" "+author+" "+" "+publish+" "+selectString);
String url2="http://116.62.178.231:8080/BaiXiaoSheng/findbook?username="+ MainActivity.getUsername()+"&title="+title+"&author="+author+"&publish="+publish;
String ms=String.valueOf(HttpUtil.sendPost(url2,req));
if(ms.equals("no"))
{
String url="http://116.62.178.231:8080/BaiXiaoSheng/addbook?username="+ MainActivity.getUsername()+"&title="+title+"&author="+author+"&publish="+publish;
Log.i("url:", ""+url);
String msg=String.valueOf(HttpUtil.sendPost(url,req));
Log.d("文字上传：",msg);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
bookuploadActivity.this.runOnUiThread(new Runnable() {
@Override
public void run() {
progressBar.setVisibility(View.VISIBLE);
if (Build.VERSION.SDK_INT >=Build.VERSION_CODES.O) {
progressBar.setTooltipText("正在上传...");
}
}
});
urlimg="http://116.62.178.231:8080/BaiXiaoSheng/downloadbook?title="+title+"&select="+selectString+"&bookauthor="+author+"&username="+MainActivity.getUsername();
handle.sendEmptyMessage(100);
}
}).start();
}
}
private void writeBookImg(final String img) {
new Thread(new Runnable() {
@Override
public void run() {
Log.i("图片地址：", img);
Map<String, File> fileMap=new HashMap<String, File>();
fileMap.put("file", new File(img));
String msg=null;
try {
msg=HttpUtil.sendPostImg(urlimg, fileMap);
} catch (IOException e) {
e.printStackTrace();
}
uploadnum++;
Log.i("当前已上传照片数：", ""+uploadnum);
final String finalMsg=msg;
bookuploadActivity.this.runOnUiThread(new Runnable() {
@Override
public void run() {
Log.e("服务器返回信息：", ""+finalMsg);
if (finalMsg.equals("yes")) {
Log.d("tag", finalMsg);
if (Build.VERSION.SDK_INT >=Build.VERSION_CODES.O) {
progressBar.setTooltipText("图片进度:" + uploadnum + "/" + size);
}
handle.sendEmptyMessage(100);
} else {
uploadnum=0;
handle.sendEmptyMessage(404);
}
}
});
}
}).start();
}
private void pickImage() {
MultiImageSelector selector=MultiImageSelector.create(this);
selector.showCamera(true);
selector.count(maxNum);
selector.multi();
selector.origin(mSelect);
selector.start(this, REQUEST_IMAGE);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode==REQUEST_IMAGE) {
if (resultCode==RESULT_OK) {
select=data.getStringArrayListExtra(MultiImageSelector.EXTRA_RESULT);
size=select.size()-1;
Log.i("照片总数：", ""+size);
mSelect.clear();
mSelect.addAll(select);
adapter.notifyDataSetChanged();
}
}
}
@Override
protected void onDestroy() {
super.onDestroy();
unbinder.unbind();
}
}
举报文章
请选择举报类型
内容侵权
涉嫌营销
内容抄袭
违法信息
其他
补充说明
0/200
上传截图
格式支持JPEG/PNG/JPG，图片不超过1.9M
function flushPage(num,curr){
layui.use(['laypage', 'layer'], function(){
laypage=layui.laypage
,layer=layui.layer;
laypage.render({
elem: 'demo2' //渲染的对象
,count: num //注意这里的count是数据条数
,limit: 16 //每页显示8条数据
,curr : curr //当前高亮页
,theme: '#1E9FFF'
,jump: function (obj, first) { //obj为当前页的属性和方法，第一次加载first为true
//do SomeThing
if (!first) { //非首次加载
console.log(obj.curr);
getSongByPage(obj.curr); //执行跳页方法，刷新显示内容，然后再在跳页方法中调用该方法，来改变总页数
//注意这里的总页数是，layui自己给我们算出来的，我们需要提供后台返回的总记录数，以及一页显示记录条数
}
}
});
});
}
package com.example.newbsh.UI.user;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.core.content.FileProvider;
import androidx.lifecycle.ViewModelProviders;
import android.Manifest;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import com.example.newbsh.HttpUtil.HttpUtil;
import com.example.newbsh.HttpUtil.NotificationUtils;
import com.example.newbsh.Login.LoginActivity;
import com.example.newbsh.MainActivity;
import com.example.newbsh.R;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import static android.app.Activity.RESULT_OK;
public class MeFragment extends Fragment {
private MeViewModel mViewModel;
private View view;
private TextView textViewname,textViewguanzhu,textViewfan;
private ImageView photoimageView;
private Button buttonmessage;
private Uri imageUri;
public static final int TAKE_PHOTO=1;
public static final int CHOOSE_PHOTO=2;
public static MeFragment newInstance() {
return new MeFragment();
}
public String getUsername(){
return MainActivity.getUserName();
}
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
view=inflater.inflate(R.layout.me_fragment, container, false);
return view;
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
mViewModel=ViewModelProviders.of(this).get(MeViewModel.class);
// TODO: Use the ViewModel
textViewname=view.findViewById(R.id.username);
textViewfan=view.findViewById(R.id.fannumber);
textViewguanzhu=view.findViewById(R.id.guanzhunumber);
photoimageView=view.findViewById(R.id.userphoto);
buttonmessage=view.findViewById(R.id.button);
Log.i("我的页面", getUsername());
textViewname.setText(getUsername());
photoimageView.setOnClickListener(l);
buttonmessage.setOnClickListener(l);
}
View.OnClickListener l=new View.OnClickListener() {
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.button:
Intent intent=new Intent(view.getContext(), LoginActivity.class);
PendingIntent pendingIntent=PendingIntent.getActivity(view.getContext(), 0, intent, 0);
NotificationUtils notificationUtils=new NotificationUtils(view.getContext());
notificationUtils
.setContentIntent(pendingIntent)
.sendNotification(3,"这个是标题3", "这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长这个是内容很长",R.drawable.qq);
break;
case R.id.userphoto:
showTypeDialog();
}
}
};
private void showTypeDialog() {
AlertDialog.Builder builder=new AlertDialog.Builder(getActivity());
final AlertDialog dialog=builder.create();
final View view=View.inflate(getActivity(), R.layout.dialog_select_photo, null);
TextView tv_select_gallery=(TextView) view.findViewById(R.id.tv_select_gallery);
TextView tv_select_camera=(TextView) view.findViewById(R.id.tv_select_camera);
tv_select_gallery.setOnClickListener(new View.OnClickListener() {// 在相册中选取
@Override
public void onClick(View v) {
if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE) !=PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
} else {
openAlbum();
}
dialog.dismiss();
}
});
tv_select_camera.setOnClickListener(new View.OnClickListener() {// 调用照相机
@Override
public void onClick(View v) {
File outputImage=new File(view.getContext().getExternalCacheDir(),"output_image.jpg");
try {
if(outputImage.exists()){
outputImage.delete();
}
outputImage.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
if(Build.VERSION.SDK_INT>=24){
imageUri=FileProvider.getUriForFile(view.getContext(),
"com.example.cameraalbumtest.fileprovider1",outputImage);
}else{
imageUri=Uri.fromFile(outputImage);
}
//启动相机程序
Intent intent=new Intent("android.media.action.IMAGE_CAPTURE");
intent.putExtra(MediaStore.EXTRA_OUTPUT,imageUri);
startActivityForResult(intent,TAKE_PHOTO);
dialog.dismiss();
}
});
dialog.setView(view);
dialog.show();
}
private void openAlbum() {
Intent intent=new Intent("android.intent.action.GET_CONTENT");
intent.setType("image
public static File uriToFile(Uri uri,Context context) {
String path=null;
if ("file".equals(uri.getScheme())) {
path=uri.getEncodedPath();
if (path !=null) {
path=Uri.decode(path);
ContentResolver cr=context.getContentResolver();
StringBuffer buff=new StringBuffer();
buff.append("(").append(MediaStore.Images.ImageColumns.DATA).append("=").append("'" + path + "'").append(")");
Cursor cur=cr.query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, new String[] { MediaStore.Images.ImageColumns._ID, MediaStore.Images.ImageColumns.DATA }, buff.toString(), null, null);
int index=0;
int dataIdx=0;
for (cur.moveToFirst(); !cur.isAfterLast(); cur.moveToNext()) {
index=cur.getColumnIndex(MediaStore.Images.ImageColumns._ID);
index=cur.getInt(index);
dataIdx=cur.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
path=cur.getString(dataIdx);
}
cur.close();
if (index==0) {
} else {
Uri u=Uri.parse("content://media/external/images/media/" + index);
System.out.println("temp uri is :" + u);
}
}
if (path !=null) {
return new File(path);
}
} else if ("content".equals(uri.getScheme())) {
// 4.2.2以后
String[] proj={ MediaStore.Images.Media.DATA };
Cursor cursor=context.getContentResolver().query(uri, proj, null, null, null);
if (cursor.moveToFirst()) {
int columnIndex=cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
path=cursor.getString(columnIndex);
}
cursor.close();
return new File(path);
} else {
//Log.i(TAG, "Uri Scheme:" + uri.getScheme());
}
return null;
}
public static String getRealFilePath(Context context, Uri uri) {
if (null==uri) return null;
final String scheme=uri.getScheme();
String realPath=null;
if (scheme==null)
realPath=uri.getPath();
else if (ContentResolver.SCHEME_FILE.equals(scheme)) {
realPath=uri.getPath();
} else if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
Cursor cursor=context.getContentResolver().query(uri,
new String[]{MediaStore.Images.ImageColumns.DATA},
null, null, null);
if (null !=cursor) {
if (cursor.moveToFirst()) {
int index=cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
if (index > -1) {
realPath=cursor.getString(index);
}
}
cursor.close();
}
}
if (TextUtils.isEmpty(realPath)) {
if (uri !=null) {
String uriString=uri.toString();
int index=uriString.lastIndexOf("/");
String imageName=uriString.substring(index);
File storageDir;
storageDir=Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES);
File file=new File(storageDir, imageName);
if (file.exists()) {
realPath=file.getAbsolutePath();
} else {
storageDir=context.getExternalFilesDir(Environment.DIRECTORY_PICTURES);
File file1=new File(storageDir, imageName);
realPath=file1.getAbsolutePath();
}
}
}
return realPath;
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
switch (requestCode){
case TAKE_PHOTO:
if(resultCode==RESULT_OK){
try {
Bitmap bitmap=BitmapFactory.decodeStream(view.getContext().getContentResolver().openInputStream(imageUri));
// String ans=imageUri.toString();
// bean.image=ans;
// muserOperator.updateImage(bean);
Log.i("imguri", bitmap.toString());
//photoimageView.setImageURI(imageUri);
photoimageView.setImageBitmap(bitmap);
String uri=getRealFilePath(view.getContext(),imageUri);
File file=new File(uri);
Map<String,File> map=new HashMap<>();
map.put("photo",file);
String ans=HttpUtil.sendPostImg("http://localhost:8080/BaiXiaoSheng/downloadimg?username=123",map);
if (ans.equals("yes")){
Toast.makeText(view.getContext(),"上传成功",Toast.LENGTH_LONG).show();
}else{
Toast.makeText(view.getContext(),"上传失败",Toast.LENGTH_LONG).show();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
break;
case CHOOSE_PHOTO:
if(resultCode==RESULT_OK){
if(Build.VERSION.SDK_INT>=19){
handleImageOnKitKat(data);
}else{
handleImageBeforeKitKat(data);
}
}
break;
default:
break;
}
}
@TargetApi(19)
private void handleImageOnKitKat(Intent data)
{
String imagePath=null;
Uri uri=data.getData();
Log.i("真实uri", uri.toString());
if(DocumentsContract.isDocumentUri(view.getContext(),uri))
{
//如果是document类型的uri则通过document id处理
String docId=DocumentsContract.getDocumentId(uri);
if("com.android.providers.media.documents".equals(uri.getAuthority()))
{
String id=docId.split(":")[1];//解析为数字格式的id
String selection=MediaStore.Images.Media._ID +"="+id;
imagePath=getImagePath(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,selection);
}
else if("com.android.providers.downloads.documents".equals(uri.getAuthority()))
{
Uri contentUri=ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"),Long.valueOf(docId));
imagePath=getImagePath(contentUri,null);
}
else if("content".equalsIgnoreCase(uri.getScheme()))
{
//如果是content类型的uri则使用普通方式处理
imagePath=getImagePath(uri,null);
}
else if("file".equalsIgnoreCase(uri.getScheme()))
{
//如果是file类型的uri直接获取图片路径就好
imagePath=uri.getPath();
}
displayImage(imagePath);//根据图片的路径显示图片
}
}
private void handleImageBeforeKitKat(Intent data)
{
Uri uri=data.getData();
Log.i("真实uri", uri.toString());
String imagePath=getImagePath(uri,null);
displayImage(imagePath);
}
private String getImagePath(Uri uri,String selection)
{
String path=null;
//通过uri和selection来获取真实的图片路径
Cursor cursor=view.getContext().getContentResolver().query(uri,null,selection,null,null);
if(cursor!=null)
{
if(cursor.moveToFirst())
{
path=cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
}
cursor.close();
}
return path;
}
private void displayImage(String imagePath)
{
if(imagePath!=null)
{
//Bitmap bitmap=BitmapFactory.decodeFile(imagePath);
//imageView.setImageBitmap(bitmap);
Uri ans=getImageContentUri(view.getContext(),imagePath);
Log.i("imgUri", ans.toString());
//保存图片到网址
photoimageView.setImageURI(ans);
}
else
{
Toast.makeText(view.getContext(),"获取图片失败", Toast.LENGTH_SHORT).show();
}
}
public static Uri getImageContentUri(Context context, String path) {
Cursor cursor=context.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
new String[] { MediaStore.Images.Media._ID }, MediaStore.Images.Media.DATA + "=? ",
new String[] { path }, null);
if (cursor !=null && cursor.moveToFirst()) {
int id=cursor.getInt(cursor.getColumnIndex(MediaStore.MediaColumns._ID));
Uri baseUri=Uri.parse("content://media/external/images/media");
return Uri.withAppendedPath(baseUri, "" + id);
} else {
// 如果图片不在手机的共享图片数据库，就先把它插入。
if (new File(path).exists()) {
ContentValues values=new ContentValues();
values.put(MediaStore.Images.Media.DATA, path);
return context.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
} else {
return null;
}
}
}
}
当登录成功后，会进入图标桌面，选择合适的功能，就会跳转到对应的界面
包含工程信息与监测对象信息
首页：（目前真实数据还没连接，所写的是静态数据）
监测对象信息
分三部分：模糊查找、添加监测对象与项目、监测对象的配置，修改，删除
模糊查找：根据项目名查找
添加监测对象与项目：通过新增Tab页来进行添加，添加成功后会在页面上展示出
监测对象的配置，修改，删除：配置为一部分重要内容，修改同样弹出Tab页进行修改，删除就加一个确定删除
目前还未连接数据库，都是写的静态数据，明天将2个增加页面实现，数据库存储实现，修改和删除实现。模糊查询尽力实现。
输入一个字符串，打印出该字符串中字符的所有排列。
你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
全排列问题可采用递归的思路，固定某个位置，求出其他位置的全排列
我们可以通过交换来获得所有可能的情况。比如第一个位置上的字符，假如 A 和 A 交换，就相当于第一个位置上固定了 A；假如 A 和 B 交换，B来到第一个位置，就相当于第一个位置上固定了 B；假如 A 和 C 交换，C来到第一个位置，就相当于第一个位置上固定了 C。递归的过程中都是同理。
此外，因为可能有字符重复，我们得到的全排列自然也会有重复，那么我们可以用 set （集合）来去重，并且还可以达到按照字母顺序排序的目的。
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
如果有一个数超过数组长度一半，意味着他可以把其他数字全部抵消，海能保证有剩余，因此，我们设定第一个数为最终的ans结果，在设置一个cnt次数表示目前该数出现的次数，若果下一个不是该数，并且次数为0，则更换ans，若果不是该数且次数不为0，则只减少次数，ans值不变。对数组进行一遍遍历，即可求出结果。
package com.example.newbsh.UI.friends;
import androidx.lifecycle.ViewModelProviders;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ListView;
import android.widget.TextView;
import com.example.newbsh.HttpUtil.HttpUtil;
import com.example.newbsh.MainActivity;
import com.example.newbsh.R;
import com.example.newbsh.UI.friends.list.SideBar;
import com.example.newbsh.UI.friends.list.SortAdapter;
import com.example.newbsh.UI.friends.list.User;
import org.json.JSONArray;
import org.json.JSONException;
import java.util.ArrayList;
import java.util.Collections;
public class FriendFragment extends Fragment {
private FriendViewModel mViewModel;
private View view;
private ListView listView;
private SideBar sideBar;
private ArrayList<User> list;
private Handler handler;
private String getUsername(){
return MainActivity.getUserName();
}
public static FriendFragment newInstance() {
return new FriendFragment();
}
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
view=inflater.inflate(R.layout.friend_fragment, container, false);
return view;
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
mViewModel=ViewModelProviders.of(this).get(FriendViewModel.class);
// TODO: Use the ViewModel
initView();
getThreadData();
handler=new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) { //线程回调更新数据
if (msg.what==200)
{
list=new ArrayList<>();
JSONArray jsonArray=(JSONArray)msg.obj;
for(int i=0;i<jsonArray.length();i++)
{
try {
String friendname=(String) jsonArray.getJSONObject(i).get("friendname");
String friendurl=(String) jsonArray.getJSONObject(i).get("friendurl");
User bean=new User(friendname,friendurl);
list.add(bean);
} catch (JSONException e) {
e.printStackTrace();
}
}
Collections.sort(list); // 对list进行排序，需要让User实现Comparable接口重写compareTo方法
SortAdapter adapter=new SortAdapter(view.getContext(), list);
listView.setAdapter(adapter);
}
return true;
}
});
}
private void initView() {
listView=(ListView) view.findViewById(R.id.listView);
sideBar=(SideBar) view.findViewById(R.id.side_bar);
sideBar.setOnStrSelectCallBack(new SideBar.ISideBarSelectCallBack() {
@Override
public void onSelectStr(int index, String selectStr) {
for (int i=0; i < list.size(); i++) {
if (selectStr.equalsIgnoreCase(list.get(i).getFirstLetter())) {
listView.setSelection(i); // 选择到首字母出现的位置
return;
}
}
}
});
}
private void getThreadData() { //线程封装网络请求
new Thread(new Runnable() {
@Override
public void run() {
String reqdata="";
String address="http://39.97.181.86/BaiXiaoSheng/myfriend?username="+getUsername();
try {
final JSONArray json=new JSONArray(String.valueOf(HttpUtil.sendPost(address, reqdata)));
Log.d("tag", json.toString());
Message msg=new Message();
msg.what=200;
msg.obj=json;
handler.sendMessage(msg);
} catch (JSONException e) {
e.printStackTrace();
}
}
}).start();
}
}
属性
包含：作诗时间，诗名，内容，翻译，背景。
关系
实体1 | 关系 | 实体2 |
诗名 | 形式 | 诗词形式 |
诗名 | 作者 | 诗人 |
诗名 | 分类 | 类别 |
诗名 | 词牌名 | 词牌名 |
诗名 | 曲牌名 | 曲牌名 |
诗名 | 朝代 | 朝代 |
属性
包含：出生时间，头像链接，去世时间，诗词数量，字，号，名字，简介。
关系
实体1 | 关系 | 实体2 |
诗人 | 好友 | 诗人 |
诗人 | 合称 | 诗人合称 |
诗人 | 轨迹 | 地点 |
诗人 | 写作 | 诗名 |
诗人 | 朝代 | 朝代 |
属性
包含：朝代名称（唐宋元明清）
关系
实体1 | 关系 | 实体2 |
朝代 | 包含 | 诗人 |
朝代 | 包含 | 诗名 |
属性
包含：类别名称（写景，抒怀，。。。）
关系
实体1 | 关系 | 实体2 |
类别 | 包含 | 诗名 |
属性
包含：诗词形式名称（五言律诗，五言绝句，五言，七言律诗，七言绝句，七言）
关系
实体1 | 关系 | 实体2 |
诗词形式 | 包含 | 诗名 |
属性
包含：词牌名名称
关系
实体1 | 关系 | 实体2 |
词牌名 | 包含 | 诗名 |
属性
包含：曲牌名名称
关系
实体1 | 关系 | 实体2 |
曲牌名 | 包含 | 诗名 |
属性
诗人合称名称
关系
实体1 | 关系 | 实体2 |
诗人合称 | 包含 | 诗人 |
属性
包含：古代地点名称，经纬度，现今名称
属性
包含：时间，事件名称，地点
属性
数据内容，关键字内容
关系
实体1 | 关系 | 实体2 |
诗句 | 关键字 | 字 |
字 | 诗句 | 诗句 |
构建的原则：
先构建单个实体，不易发生多种关系的单个实体。
例如：类别，诗词形式，词牌名，曲牌名，朝代，诗人合称，轨迹，事件
多关系实体：诗人，诗名
create_tag.py
展示
create_formal.py
展示
展示
展示
展示
展示
展示
展示
展示
展示
展示
实体关系构建完成，基本的古诗词关系理清，之后可以进行相关的网页展示。
整个关系结构图，如下所示：
1.背景
（1）典型用户：
用户性质 | 典型用户介绍 |
姓名 | 张三 |
年龄 | 18岁 |
职业 | 学生 |
代表用户在市场上的比例和重要性 | 代表寻求校园信息未果人群 |
使用本软件的典型场景 | 临近考试前，平常下课写作业时间，参加活动 |
使用本软件的环境 | 无限制 |
生活情况 | 积极乐观，对校园事情充满好奇 |
知识层次和能力 | 正常熟练使用手机 |
用户的动机，困难和目的 | 想要了解更多校园的事情 |
用户的偏好 | 喜欢交友，聊天，不挂科 |
（2）用户的需求/迫切需要解决的问题
获取不到实时的校园活动信息，以及校园的各种活动比赛，谈恋爱，失物招领等等有关校园内的或启动。
（3）假设
设计这几个方面的功能，发布者可以通过写博客的形式来进行发布，进而使更多的学生了解该活动，并积极的参与进来。学生用户通过查看博文的形式来进行了解校园的相关信息
2.场景
张三最近想参加一些校园活动来增长他的总测分数，于是他打开app，找到相关的比赛活动栏，带你进去浏览后，找到一个心仪的活动，点开该博文后，向博主进行报名。
3.其他资料
第一阶段，我主要承担的是校园新闻板块的编写，实现爬取校园新闻，然后展示到app上，同时统计浏览量与点赞和评论数。同时点击博文后可以参与评论等相关功能。
举报文章
请选择举报类型
内容侵权
涉嫌营销
内容抄袭
违法信息
其他
补充说明
0/200
上传截图
格式支持JPEG/PNG/JPG，图片不超过1.9M
举报文章
请选择举报类型
内容侵权
涉嫌营销
内容抄袭
违法信息
其他
补充说明
0/200
上传截图
格式支持JPEG/PNG/JPG，图片不超过1.9M
今天完成的：
实现从服务器上获取数据，并展示到Android端，对每个博文的展示采用的“卡片模型”，添加点击波纹特效，同时对点击后的新闻详情页做了部分，顶部的含历史记录框做了一部分。
明天要做：
将新闻详情页展示出来，同时尽量加上用户评论信息。将搜索功能进一步完善。
遇到的问题：
一开始获取服务器端的数据采用的是“volley”，结果数据获取不到，发现他只适合轻量级的传输，于是果断的采用http访问请求，顺利的获取到了数据。
之后对于新闻页中，有部分新闻并没有照片，一开始采用的是默认的照片，之后查阅后发现可以用错误处理图片，以及缓冲加载图片。因此加上之后，看起来美观许多。
同时加入下了刷新。
给我的感受是：除了运行时间外，内存的开销也很重要。这个观念其实早在大一刚接触算法不久后，就有了这个概念，做算法题的时候不仅讲究时间复杂度，还要考虑他的空间开销程度。同样，读了本节后让我知道他也同样适应于开发的软件。
规模控制，对项目经理而言，规模控制既是技术工作的一部分，也是管理工作的一部分。他必须研究用户和他们的应用，以设置将开发系统的规模。接着，把这些系统划分成若干部分，并设定每个部分的规模目标。由于规模－速度权衡方案的结果在很大的范围内变化，规模目标的设置是一件颇具技巧的事情，需要对每个可用方案有深刻的了解。聪明的项目经理还会给自己预留一些空间，在工作推行时分配。然而仅对核心功能进行规模控制是远远不够的，还需结合其他方面一起加入预算。在为每个单元设立核心规模的同时，要顺便设置访问的目标，否则我们的管理控制系统会失去度量，最后每个人的核心大小没有问题，然而规模上却发生了问题。
空间技能，用功能交换尺寸：任何一系列特殊选项被合并在一起进行分组时，程序需要的空间较少。这很像小汽车。如果把照明灯、点烟器和时钟作为整个配件来标明价格，则成本会比单独提供这些选择所需要的成本低。所以，设计人员必须决定用户可选项目的粗细程度。空间－时间的折衷：对于给定的功能，空间越多，速度越快。项目经理可以做两件事来帮助他的团队取得良好的空间－时间折衷。一是确保他们在
编程技能上得到培训，另外一种方法是认识到编程需要技术积累，需要开发很多公共单元构件。
数据的表现形式是编程的根本。好比之前学过的算法问题，一开始我所能用的解决排序的问题就是冒泡二重循环，复杂度为O（n2）；然而通过快排（sort），我可以将时间复杂度降到nl(lgn)级别，大大的节省时间。
今天完成的：
新闻页点击后，跳转页面到新闻详情页，查看文章，同时从数据库中读取相应的对应文章的图片，加载出来；评论，点赞，关注，收藏功能未实现。
遇到的问题：
一开始在想用自定义的可滑动的textview来装正文，确实可以实现，但是不太美观，同时之后会有评论而且肯定不止一条，于是采用ScorllView的布局，解决该难题。
之后就是图片加载，采用动态加载，读取数据库里的照片链接，然后根据链接的个数生成对应的照片（在设计照片位置和大小费了许多功夫）
明天任务：
设计评论，点赞，关注，收藏功能。
# coding:utf-8
#代码内容
#抽取诗人的个人经历：时间，地点，人物，事件，围绕这四个方面来抽取
import re
from pyhanlp import *
import pandas as pd
#人名“nr“
#地名“ns”
#机构名“nt”
import os
#获取文件夹下的所有文件名
def get_filename(path,filetype): # 输入路径、文件类型例如'.xlsx'
name=[]
for root,dirs,files in os.walk(path):
for i in files:
if os.path.splitext(i)[1]==filetype:
name.append(i)
return name # 输出由有后缀的文件名组成的列表
#添加自定义语料库：作者名，朝代年号
def add_user_dict():
CustomDictionary=JClass("com.hankcs.hanlp.dictionary.CustomDictionary")
#添加作者名字
author_data=pd.read_excel('https://blog.51cto.com/u_14824425/data2/author_new.xlsx')
name=author_data.author
for it in name:
CustomDictionary.add(it,"nr")
#添加时间词
time=[]
file='data3/'
lists=get_filename(file, '.xlsx')
for it in lists:
newfile=file + it
dd=pd.read_excel(newfile).year_hao
time.extend(dd)
#print(time)
for t in time:
#print(t)
CustomDictionary.add(t,"t")
#处理作者关键信息：时间，人物，地点，事件
def key_print(lists,text,new_author):
time=[]
where=[]
author=[]
move=[]
for it in lists:
simple=it.split('/')
if simple[1]=='t':
time.append(simple[0])
elif simple[1]=='nr':
author.append(simple[0])
elif simple[1]=='ns':
where.append(simple[0])
elif simple[1]=='v':
move.append(simple[0])
if len(time)!=0 and ( len(move)!=0 or len(where)!=0 ):
newtime=""
for it in time:
if bool(re.search(r'\d',it)) and it.find('年')!=-1:
newtime=it
f1=False
if newtime!="":
f1=True
#print("时间：" + newtime)
#保存时间
data_list.append(newtime)
else:
if len(data_list)!=0:
f1=True
#print("时间："+str(data_list[len(data_list)-1]))
data_list.append(data_list[len(data_list)-1])
if f1:
#时间必须有，才能采集后面的
if len(author)!=0:
author=list(set(author))
author_list.append(",".join(author))
#print("人物:"+" ".join(author))
else:
author_list.append(new_author)
#print("人物:"+new_author)
if len(where)!=0:
where_list.append(",".join(where))
#print("地点：" + " ".join(where))
else:
where_list.append("无")
#print("地点：无")
#处理事件
things=[]
if len(move)!=0:
thing_list=re.split('[，。；]+',text)
for v in move:
for it in thing_list:
if it.find(v)!=-1:
things.append(it)
#去重
set_things=list(set(things))
things_list.append(",".join(set_things))
#print("事件：")
#print(set_things)
else:
things_list.append("无")
#print("事件：无")
#事件：动作+人物+地点
#用crf模型提取词性
def demo_CRF_lexical_analyzer(text,new_author):
global bg_time
CRFnewSegment=HanLP.newSegment("crf")
term_list=CRFnewSegment.enableCustomDictionaryForcing(True).seg(text)
ans=[]
#'p'介词
#'ns'地名
#'t'时间词
#'nz'其他专名
#'j'简称略语
#'m'数词
#'n'名词
#至少得有时间词与人物
f1=False
f2=False
lists=['n','nr','v','nz','ns','t']
tmp=[]
for it in term_list:
if str(it.nature) in lists:
tmp.append(str(it.word)+"/"+str(it.nature))
if str(it.nature)=='t':
if bool(re.search(r'\d',it.word)):
#这一步保存bg_time是为后面没有具体时间的事件，提供时间
bg_time=str(it.word)
f1=True
elif str(it.nature)=='ns':
f2=True
if f1:
#print(tmp)
key_print(tmp,text,new_author)
else:
if f2:
tmp.append(bg_time+"/t")
#print(tmp)
key_print(tmp,text,new_author)
import xlwt
#进行诗人个人生平分析
def author_identity(text,author):
lists=text.split("。")
for it in lists:
#print(it)
demo_CRF_lexical_analyzer(it,author)
#print("============分析结果================")
#print(len(data_list))
#for i in range(len(data_list)):
#print(data_list[i], author_list[i], where_list[i], things_list[i])
#print("===========保存数据================")
if len(data_list)!=0:
xl=xlwt.Workbook()
# 调用对象的add_sheet方法
sheet1=xl.add_sheet('sheet1', cell_overwrite_ok=True)
sheet1.write(0, 0, "data")
sheet1.write(0, 1, "author")
sheet1.write(0, 2, "wheres")
sheet1.write(0, 3, "things")
for i in range(0, len(data_list)):
sheet1.write(i + 1, 0, data_list[i])
sheet1.write(i + 1, 1, author_list[i])
sheet1.write(i + 1, 2, where_list[i])
sheet1.write(i + 1, 3, things_list[i])
xl.save("https://blog.51cto.com/u_14824425/author2/"+author+".xlsx")
#清洗作者，只要包含个人生平的作者信息
def read_author():
author_list=pd.read_excel('https://blog.51cto.com/u_14824425/data2/author_new.xlsx').fillna('无')
author_name=author_list.author
author_experience=author_list.experience
for i in range(len(author_experience)):
if author_experience[i]!='无':
new_author_name.append(author_name[i])
new_author_experience.append(author_experience[i])
#测试
def read_one():
text='初显将才韩世忠出身于普通农民家庭。自幼喜欢练武，学习刻苦认真。少年时期就有过人的力气。性情憨直善良，喜欢行侠仗义。不慕功名。韩世忠长到十六、七岁时，生得身材魁梧高大，浑身是劲儿，勇力过人，家乡有人对他说，有如此好的功夫，应该去当兵为国效力。于是，年仅十七岁他就参军当了一名士卒。韩世忠所在的部队驻在西北地区，经常与西夏军队发生冲突。韩世忠入伍不久就参加了战斗，因作战勇敢就由士卒升为小队长，只管十几个人。官职虽小，但韩世忠仍能积极负责，他领导的那些士兵都比他年纪大，可是韩世忠作战勇敢，处事公道正派，说话正直在理，所以大家都听他的。有一次宋军攻打西夏的一座城池，久攻不下，韩世忠打红了眼，一个人爬墙冲进去，杀死守城的敌军头领，把他的脑袋扔出城外，宋军受到鼓舞，一涌而上，攻下城池。不久，西夏王的监军驸马亲率夏军向宋军反击，宋军有畏怯之状。韩世忠问清驸马的身份和作用，然后率几名敢死士卒，冲入敌阵，这突如其来的冲击让敌人惊慌失措，韩世忠冲入敌阵直奔元帅帐，还没等西夏兵明白过来，手起刀落，将西夏监军驸马的头砍了下来。西夏兵大乱，争相奔逃。宋军将领都称赞韩世忠的勇敢，说他年纪虽小，却是个不可多得的将才。因此，经略使上报朝廷，请求破格提拔韩世忠。可是，当时主持边事的童贯却怀疑汇报的真实性，只同意给韩世忠升一级。抗击金兵1121年（宣和三年），宋政权派出的部队与金兵战于燕山南。几路兵马均被金兵打败。韩世忠率五十余骑巡逻于滹沱河上，不巧与金兵大队人马遭遇。金兵是一支两千人的骑兵主力。韩世忠遇事冷静而果断，他告诉士卒：“慌乱就等于死，不要乱动，一切听我安排。”他让一个叫苏格的小队长率部分人抢占高坡，列阵其上，观而不动。又派出十余个骑士，把在河准备抢渡的散乱宋军组织起来，得众数百，让他们列阵击鼓呐喊。然后，他率几名敢死骑士，径直冲入金兵队阵之中，专砍打旗的金兵，连杀几个之后，其余举旗的纷纷将旗放倒，河边的宋军士卒击鼓高喊：“金兵败啦！金兵败啦！”倾刻间金兵大乱，苏格率占据高地的骑兵自上而下杀来，金兵丢下上百具尸体，乱纷纷向北逃去，韩世忠又追了一程才收住坐骑。1126年（靖康元年）十月，正在滹沱河一带担任防守任务的韩世忠被金兵数万追逼退入赵州城内。敌兵围城数重。城中兵少粮乏，军心不稳，有人主张弃城而遁。韩世忠传令下去，有敢言弃城者斩。当天夜里，天降大雪，韩世忠选精壮士卒三百人，悄悄出城，偷偷摸进金兵围城主帅营帐，杀死主帅，后偷袭金兵驻地，挑起金兵内部误相攻杀。一夜大战，金兵死伤过半，当得知主将被杀，看到遍地都是自家兄弟的尸体，流出的血把雪都染成了红色的，金兵无心再战，溃散退去。韩世忠在河北一带坚持抗金斗争数年，官阶不高，所率兵马并不多，但是战无不胜，攻无不克，因此，其威名震慑金兵。解救高宗靖康之变，开封城陷，宋徽宗和宋钦宗父子两人作了金兵的俘虏。徽宗的第九个儿子康王赵构在南京（商丘）当了皇帝，是为宋高宗。这是南宋小朝廷的第一任皇帝。赵构不想有所作为，只图苟且偷安。在商丘就任之后，一路被金兵追击，从商丘跑到杨州，又从杨州跑到杭州，最后跑到海上去躲避金兵。在岳飞等将的抵抗下，金兵退出江南，赵构又从海上返回杭州。为了平息舆论，他罢免了投降派宰相汪伯彦、黄潜善等人，任朱胜非为宰相，王渊掌枢密院事，吕颐浩为江东安抚制背使。将官苗傅、刘正彦对朝廷不满发动兵变，杀死了王渊和宦官康履，逼高宗让位给三岁的儿子。吕颐浩约韩世忠、张浚等大将平息叛乱，解救高宗。韩世忠身边兵不多，就在盐城一带收集散卒，组织起几十人的部队，从海上来到常熟。约见张浚等人进兵到秀州，然后诈称休兵，不再前进。实际暗中作攻城的准备。苗傅、刘正彦知韩世忠来攻，就俘虏韩世忠的妻子梁红玉作为人质。宰相朱胜非已假意屈从苗、刘，对他们说，与其逼韩世忠战，不若遣梁红玉去抚慰韩世忠，只要韩世忠能降，大事可成矣！苗、刘果然让使者跟随梁红玉去见韩世忠。梁氏回到丈夫身边，使者到来后，韩世忠烧了诏书，砍了使者，下令进攻杭州。韩世忠在杭州北关击败叛军防守部队，苗、刘惊惧，率二千主力逃跑。韩世忠救出高宗赵构，高宗告诉他，宫中的中军统制吴湛和苗、刘是一伙的，此贼不除，宫中不安。恰在此时，吴湛率兵前宋迎接韩世忠，伸手与韩世忠相握，韩世忠力大，顺势捏断了吴湛的手指，喝令拿下，与其他叛将一并斩于市曹。苗、刘之乱遂平，南宋小朝廷稳定下来。韩世忠功劳最大，从此成了高宗的亲信，被任命为武胜军节度使、御营左军都统制。此次平乱，确立了韩世忠在南宋将领中的名声和地位。围困兀术1129年（建炎三年），金兵再次南下，突破长江天险，攻破了建康（今南京）等重要城镇，躲在杭州的宋高宗赵构又要逃跑。韩世忠面见高宗，慷慨陈词：“国家已丢失河北、河东、山东诸地，再把江淮丢掉，还有何处可去?”赵构根本听不进去，他所想的只有保住性命。赵构任命韩世忠为浙西制置使，防守镇江，而赵构则跟随投降势力逃到了海上。镇江其时已处敌后，韩世忠领命仅率所部八千人急赶镇江．金兵在江南抢掠一阵之后陆续退去。韩世忠驻守于松江、江湾、海口一带，听到金兵撤退的消息，韩世忠立即分兵把守要地，准备乘机斩杀金兵。埋伏的宋兵差一点儿活捉金兵元帅兀术。兀术乃好战之将，他给韩世忠下了战书，约期会战。韩世忠与敌约定日期，在江中会战。金兵因不习水战，韩世忠就利用敌人这一弱点，封锁长江，几次交战大败金兵，还活捉了兀术的女婿龙虎大王。兀术不敢再战，率十万兵马退入黄天荡，企图从这里过江北逃。黄天荡是江中的一条断港，早已废置不用，只有进去的路，没有出去的路。韩世忠见金兵误入岐途，就抓住这一难得的机会，待金兵进去之后，立即率兵封锁住出口。兀术率金兵被困于黄天荡内，进退无门，眼见十万士卒就要被饿死荡中，兀术派使者与韩世忠讲和，愿意把抢掠的财物全部送还，向韩世忠献宝马，以此为条件，换条退路，韩世忠一概不答应。兀术只好重金悬赏求计。兀术重金从一个汉奸那里买来了良策。黄天荡内有一条老鹳河，直通建康秦淮河，因年久不用而淤塞，派人挖通即可从水路逃出。兀术派人，一夜之间挖通此河，企图从水道入建康。途经牛头山，刚收复建康的岳飞在此处驻有军队，见敌人从这里出来，立即调集大军猛击，兀术只好退回黄天荡。韩世忠准备置敌于死地，他派人打制铁索和铁钩，一遇敌船定要消灭。眼看敌人无计可施，只有等死，此时又一个汉奸向金兵献策，教他们乘宋军扬帆行船之时，集中火箭射船帆，烧毁宋军战船，这样便可逃出黄天荡。兀术大喜，依计而行，果然有效，宋军船只被烧毁许多，金兵乘机冲出黄天荡，向北逃过长江，撤回黄河以北地区。韩世忠仅用八千军队，困敌十万兵马于黄天荡，战四十八天，歼敌万余。此战意义非凡，激起了江淮人民的抗金情绪，使人民看到了金兵并不可怕。韩世忠因黄天荡战役以巧制敌，其威武雄姿和将帅风范传遍江淮地区。大仪镇大捷1134年（绍兴四年），韩世忠任建康、镇江、淮东宣抚使驻扎镇江。岳飞收复襄阳（今湖北襄樊）等六郡后，伪齐主刘豫派人向金乞援，金太宗完颜晟命元帅左监军完颜宗弼率军5万，与伪齐军联合，自淮阳(今江苏邳县西南)等地，兵分两路，南下攻宋。企图先以骑兵下滁州（今属安徽），步兵克承州（今江苏高邮），尔后渡江会攻临安（今浙江杭州）。九月二十六日，金军攻楚州（今江苏淮安）。宋淮东宣抚使韩世忠军自承州退守镇江（今属江苏）。宋廷急遣工部侍郎魏良臣等赴金军乞和，并命韩世忠自镇江北上扬州，以阻金军渡江。十月初四，韩世忠率兵进驻扬州后，即命部将解元守承州，邀击金军步兵；自率骑兵至大仪镇（今江苏扬州西北）抵御金骑兵。十二日，魏良臣路一行过扬州，韩世忠故意出示避敌守江的指令，佯作回师镇江姿态。待魏良臣走后，韩世忠立即率精骑驰往大仪镇，在一片沼泽地域将兵马分为5阵，设伏20余处，准备迎击金军。翌日，金将万夫长聂儿孛堇从魏良臣口中得知韩世忠退守镇江，遂命部将挞孛也等数百骑直趋扬州附近江口，进至大仪镇东。韩世忠亲率轻骑挑战诱敌，将金军诱入伏击区，宋伏兵四起，金军猝不及防，弓刀无所施。韩世忠命精骑包抄合击，并命背嵬军各持长斧，上劈人胸，下砍马足，金军陷于泥淖之中，伤亡惨重，金将挞孛也等200余人被俘，其余大部被歼。捷报传到杭州，群臣入贺，高宗命令令对韩世忠及各部将论功行赏。大仪镇之捷，是南宋十三处战功之一，当时论者有认为这是南宋中兴武功第一。斥责秦桧在南宋政权内部始终存在着抗战与投降之间的斗争。以岳飞、韩世忠等战将为代表的主战派，拒绝妥协投降，反对与金议和；而以秦桧等文臣为首的士族势力，企图偏安一隅，因此，反对抗战，主张妥协议和，最终走向了屈膝投降的道路。韩世忠不管率兵多少，从不畏惧金兵，不管在什么地方，闻警则动，见敌则战。他坚决主张打过长江、打过黄河去，收复所有失地。1140年，在金兵大肆南侵的形势下，韩世忠竟然率领为数不多的军队包围了被金兵占领的淮阳，然后大败金兵主力于泇口镇。在这个时期，抗战派略占上风。韩世忠因功被封为太保，封英国公，兼河南、河北诸路讨使。正当韩世忠招兵买马，扩大队伍准备大干之时，形势急转直下，投降派势力获得了宋高宗的支持，因为岳飞率领的抗金大军已在中原一带大得其势。宋高宗所担心的是一旦打败金兵，迎回他的父皇（徽宗）和哥哥（钦宗）。所以，在他的支持下，秦桧收了韩世忠、岳飞、张俊三位抗金大将的兵权。秦桧一日之内连发十二道金牌，强令处在抗金最前线的岳飞罢兵回临安。因韩世忠对宋高宗有救驾之恩，因此，升枢密使，明为升官，实为剥夺其兵权。岳飞父子被捕下狱，秦桧独霸朝政，无人敢言，但韩世忠不管这一套，他面见秦桧，当面指斥道：“岳飞父子何罪？为何将其关押？”秦桧答曰：“飞子云与张宪书，虽不明，其事体莫须有”。韩世忠斥道：“‘莫须有’三字能服天下吗？”好友劝他，得罪秦桧日后难逃报复，而韩世忠却说：“今吾为已而附合奸贼，死后岂不遭太祖铁杖？”韩世忠见岳飞父子被处死，大好的抗金形势白白丧失，自己又无能为力，便毅然辞去枢密使的官职，终日借酒消愁。晚年喜释、老，自号清凉居士。最终还是忧愤而死，卒于1151年（绍兴二十一年）。'
author='韩世忠'
author_identity(text, author)
#开始处理
if __name__=='__main__':
add_user_dict()
#提取最终的包含个人经历的作者
new_author_name=[]
new_author_experience=[]
read_author()
#输出一共多少个
print("一共："+str(len(new_author_name)))
for i in range(len(new_author_name)):
#存储上一个时间
bg_time=""
print("第"+str(i)+"个")
author=new_author_name[i]
text=new_author_experience[i]
# 时间序列
data_list=[]
author_list=[]
where_list=[]
things_list=[]
author_identity(text,author)
package com.example.newbsh.UI.home.hometype.news.adapter;
import android.annotation.SuppressLint;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.navigation.Navigation;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import com.bumptech.glide.request.RequestOptions;
import com.example.newbsh.HttpUtil.HttpUtil;
import com.example.newbsh.R;
import com.example.newbsh.UI.home.hometype.news.shownews.ShowNewsActivity;
import com.example.newbsh.UI.home.hometype.news.shownews.comment.BlogComment;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.ref.WeakReference;
public class NewsAdapter extends RecyclerView.Adapter<NewsAdapter.MyViewHolder> {
JSONArray jsonArray=new JSONArray();
private View itemview;
private String numcomment,numsupport;
public void setJsonArray(JSONArray jsonArray) {
this.jsonArray=jsonArray;
}
@NonNull
@Override
public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
LayoutInflater layoutInflater=LayoutInflater.from(parent.getContext());
itemview=layoutInflater.inflate(R.layout.cell_news,parent,false);
return new MyViewHolder(itemview);
}
private void showComment(String title) {
new Thread(new Runnable() {
@Override
public void run() {
String reqdata="http://39.97.181.86/BaiXiaoSheng/newscomment?title="+title;
numcomment=String.valueOf(HttpUtil.sendPost(reqdata,""));
Log.d("data", "评论:"+ numcomment);
}
}).start();
Log.d("data", "评论:"+ numcomment);
}
private void showSupport(String title) {
new Thread(new Runnable() {
@Override
public void run() {
String reqdata="http://39.97.181.86/BaiXiaoSheng/newssupport?title="+title;
numsupport=String.valueOf(HttpUtil.sendPost(reqdata,""));
Log.d("data", "点赞:"+ numsupport);
}
}).start();
Log.d("data", "点赞:"+ numsupport);
}
@Override
public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
JSONObject bean=null;
try {
bean=jsonArray.getJSONObject(position);
holder.textViewTitle.setText(bean.getString("title"));
holder.textViewJianJie.setText(bean.getString("doc"));
holder.textViewClicknumber.setText(bean.getString("click"));
holder.textViewDatetime.setText(bean.getString("date"));
String []urls=bean.getString("url").split(" ");
showSupport(bean.getString("title"));
showComment(bean.getString("title"));
holder.textViewnewscomment.setText(numcomment);
holder.textViewnewssupport.setText(numsupport);
numcomment="0";numsupport="0";
RequestOptions options=new RequestOptions()
.error(R.drawable.error)
.placeholder(R.drawable.loading);
if(urls.length!=0) {
for(int i=0;i<urls.length;i++)
{
if(!urls[i].equals(" "))
{
Log.i("url",urls[i]);
Glide.with(itemview)
.load(urls[i])
.apply(options)
.into(holder.photo);
break;
}
}
}
} catch (JSONException e) {
e.printStackTrace();
}
holder.itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Bundle bundle=new Bundle();
try {
bundle.putString("title", jsonArray.getJSONObject(position).getString("title"));
bundle.putString("doc",jsonArray.getJSONObject(position).getString("doc"));
bundle.putString("click",jsonArray.getJSONObject(position).getString("click"));
bundle.putString("date",jsonArray.getJSONObject(position).getString("date"));
bundle.putString("url",jsonArray.getJSONObject(position).getString("url"));
bundle.putString("authorname",jsonArray.getJSONObject(position).getString("authorname"));
bundle.putString("authorurl",jsonArray.getJSONObject(position).getString("authorurl"));
} catch (JSONException e) {
e.printStackTrace();
}
Navigation.findNavController(v).navigate(R.id.action_home_to_showNewsActivity,bundle);
}
});
}
@Override
public int getItemCount() {
return jsonArray.length();
}
static class MyViewHolder extends RecyclerView.ViewHolder{
TextView textViewTitle,textViewJianJie,textViewDatetime,textViewClicknumber,textViewnewssupport,textViewnewscomment;
ImageView photo;
public MyViewHolder(@NonNull View itemView) {
super(itemView);
textViewTitle=itemView.findViewById(R.id.NewsTitle);
textViewJianJie=itemView.findViewById(R.id.jianjie);
textViewClicknumber=itemView.findViewById(R.id.clicknumber);
textViewDatetime=itemView.findViewById(R.id.datetime);
textViewnewscomment=itemView.findViewById(R.id.newscomment);
textViewnewssupport=itemView.findViewById(R.id.newsupport);
photo=itemView.findViewById(R.id.userphoto);
}
}
}
{
"five": [
[
{
"name": "连云区"
},
{
"name": "连云区",
"value": 200
}
],
[
{
"name": "连云区"
},
{
"name": "高淳区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "建邺区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "鼓楼区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "浦口区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "六合区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "泰兴",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "泗阳县",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "阜宁",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "东台",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "江都区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "宝应县",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "邗江区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "仪征市",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "徐州云龙区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "开发区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "丰县",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "沛县*",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "铜山区",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "睢宁县",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "新沂市",
"value": 55
}
],
[
{
"name": "连云区"
},
{
"name": "贾汪区",
"value": 55
}
]
],
"four": [
[
{
"name": "金湖县"
},
{
"name": "金湖县",
"value": 200
}
],
[
{
"name": "金湖县"
},
{
"name": "连云区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "浦口区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "泰兴",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "盐都区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "宝应县",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "镇江市",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "常熟",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "开发区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "丰县",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "沛县*",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "铜山区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "睢宁县",
"value": 55
}
]
],
"name": [
"草履蚧",
"麻皮蝽",
"扁刺蛾",
"人纹污灯蛾",
"霜天蛾",
"杨扇舟蛾"
],
"one": [
[
{
"name": "徐州"
},
{
"name": "徐州",
"value": 200
}
],
[
{
"name": "徐州"
},
{
"name": "云龙区",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "鼓楼区",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "泉山区",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "开发区",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "丰县",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "沛县",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "铜山区",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "睢宁县",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "邳州市",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "新沂市",
"value": 55
}
],
[
{
"name": "徐州"
},
{
"name": "贾汪区(全市）",
"value": 55
}
]
],
"six": [
[
{
"name": "金湖县"
},
{
"name": "金湖县",
"value": 200
}
],
[
{
"name": "金湖县"
},
{
"name": "泰兴",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "靖江",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "江都区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "徐州云龙区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "鼓楼区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "泉山区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "开发区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "丰县",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "沛县",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "铜山区",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "睢宁县",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "邳州市",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "新沂市",
"value": 55
}
],
[
{
"name": "金湖县"
},
{
"name": "贾汪区(全市)",
"value": 55
}
]
],
"three": [
[
{
"name": "东海"
},
{
"name": "东海",
"value": 200
}
],
[
{
"name": "东海"
},
{
"name": "泰兴",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "宿迁泗阳",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "宿城区",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "江都区",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "云龙区",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "鼓楼区",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "开发区",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "丰县",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "沛县",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "铜山区",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "睢宁县",
"value": 55
}
],
[
{
"name": "东海"
},
{
"name": "新沂市",
"value": 55
}
]
],
"two": [
[
{
"name": "宜兴"
},
{
"name": "宜兴",
"value": 200
}
],
[
{
"name": "宜兴"
},
{
"name": "常州市",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "淮阴区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "金湖县",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "浦口区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "六合区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "玄武区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "栖霞区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "靖江",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "宿迁沭阳",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "宿城区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "宿豫区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "阜宁",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "大丰",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "东台",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "江都区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "宝应县",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "扬州市开发区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "镇江市",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "常熟",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "吴中区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "昆山",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "吴江",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "苏州高新区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "太仓",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "丰泾村",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "徐州",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "云龙区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "鼓楼区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "泉山区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "开发区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "丰县",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "沛县",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "铜山区",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "睢宁县",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "邳州市",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "新沂市",
"value": 55
}
],
[
{
"name": "宜兴"
},
{
"name": "贾汪区(全市)",
"value": 55
}
]
]
}
第二周开篇博客
1.介绍自己
我是一个很平凡的普通人，但是有着不平凡的一颗心。我的性格属于那种可能初看觉得很高冷，但是慢慢熟悉之后发现原来事实是一个逗比（玩的不错的朋友的评价）
我可能是属于那种慢慢熟的一种人。我个人喜欢一些体育项目，我在初中的时候打过乒乓球，为了能在台上多打一会，努力并且付出实践了一年半
实现了只要站在台上就不会再下来，可以一直对打。之后就转战“篮球”，但当时是真的菜，不过好在有会玩的带我们玩，经过一年多的配合，在初中毕业前成功干掉校内最强的一支队伍（篮球是一个团队的游戏，每个人都承担着不同的角色），那也是拼劲全力的一战。
除了玩之外，我在大学还迷恋上一个项目“ACM”这是一个很耗时很耗脑子的一个比赛，在大一刚刚接触编程就喜欢上了，并且一直持续到现在，努力一年也是有结果的，在校赛上获得了“一等奖”，之后我的目标是在今年的“蓝桥杯”上获得省一，接着再去打国赛。
2.现状，经验和计划
针对自己目前的现状，我通过一个表来评价自己
以我目前的现状处在3等级，我预计在本次课程结束后要到达4等级中期。
那么，我将如何为之努力，以下是给自己的几条努力方向：
①以练代学，在实践中发现自己的问题，通过各种方法去解决他
②阅读一些相关的技能书籍，视频
③借鉴优秀的代码，进行学后总结
④提高自己的代码量，每天抽出1~2小时进行代码训练
⑤向上届的学长询问相关的问题，看他们是如何来解决，与同学相互沟通
对于自己刚刚踏入软件工程半年，总结自己着摸爬滚打半年来的生存经验
其一：一定要对自己所做的事情充满信心，相信自己一定可以做到
其二：对自己要学习的东西进行归纳整理，对于一些问题的解决方案进行整理，写个博客归纳一下
其三：必须有足够的代码量与花费一定的时间去敲代码
其四：每天都要有目标，今天要做什么，今天任务实现度，遇到何种困难，如何解决。
并且通过这回寒假实战：连续进行6天的开发博客，明天都汇报自己完成的东西，遇到的问题，解决的方案，经过这连续的开发日志
每天都特别的又干劲，有动力。
计划：
安排自己开学后的编码时间：
周一晚上：7~9点
周二下午：上4节专业课，晚上估计也得加个班（将下午的东西完善）
周三下午：2~4点
周四下午：4~5：25
周五晚上：7~9点
周六日自行安排
每天的有效代码量要达到100行
这次课程的目标就是要实现团队开发完成一个具备软件注册权的软件产品
对产品的需求：过程要做到“现代实践课程”，产品要做到10+次的完善。
3.Quality questions
在互联网时代如何提问题。 还有这些要点：
① 在每个问题后面，必须说明哪一章节的什么内容引起了你的提问，提供一些上下文，如果能提供页码，就更加好。
② 列出一些事例或资料，支持你的提问 。
③ 说说你提问题的原因，你说因为自己的假设和书中的不同而提问，还是不懂书中的术语，还是对推理过程有疑问，还是书中的描述和你的经验（直接经验或间接经验）矛盾？
一个模板可以是这样：
我看了这一段文字 （引用文字），我有这个问题 （提出问题）。 我查了资料，有这些说法（引用说法），根据我的实践，我得到这些经验（描述自己的经验）。
但是我还是不太懂，我的困惑是（说明困惑）。
【或者】我反对作者的观点（提出作者的观点，自己的观点，以及理由）。
大学生应该能写出自己的思考， 而不光是摘抄书本内容。
因此，这就是我以后要向自己提出高质量问题的模板。
新的学期，一起奥利给！！
#----------诗人相关问题-------------------------------------------------
# 诗人的作品
self.poem_name_qwds=['诗','作品','诗集','诗词']
# 诗人的朋友
self.poemer_friend_qwds=['好友','朋友','知己']
# 诗人的出生年月
self.poemer_born_qwds=['出生','生于']
# 诗人的去世年月
self.poemer_die_qwds=['死', '去世']
# 诗人的简介
self.author_qwds=['简介','介绍']
# 诗人所属朝代
self.author_desty_qwds=['朝代','朝','年代','代']
# 诗人的合称
self.author_common_name_qwds=['合称','称号']
# 诗人旅行地点
self.author_travel_where_qwds=['旅行','游历','游玩','到','地点']
# 诗人的字
self.author_zi_qwds=['字']
# 诗人的号
self.author_hao_qwds=['号']
# 诗人的诗集总数
self.author_poem_sum_qwds=['总数','合计','总共','诗词总数']
# ----------诗词相关问题-------------------------------------------------
# 诗词的内容
self.poem_qwds=['内容']
# 诗词作诗时间
self.poem_date_qwds=['时间','作诗时间']
# 诗词的创作背景
self.poem_back_qwds=['创作背景','背景']
# 诗词的翻译
self.poem_trans_qwds=['翻译']
# 诗词的作者
self.poem_author_qwds=['作者','诗人']
# 诗词的朝代
self.poem_desty_qwds=['朝代','朝','年代','代']
# 诗词的类别
self.poem_tag_qwds=['类','类别','类型','风格']
# 诗词的形式
self.poem_formal_qwds=['形式','题材']
# 诗词的词牌名
self.poem_cipaiming_qwds=['词牌名']
# 诗词的曲牌名
self.poem_qupaiming_qwds=['曲牌名']
# ----------类别相关问题-------------------------------------------------
# 所有诗词类别？
self.tag_qwds=['诗词类别']
# 类别包含哪些诗？
self.tag_poem_qwds=['诗','有']
# ----------形式相关问题-------------------------------------------------
# 所有诗词形式？
self.formal_qwds=['诗词形式']
# 形式包含哪些诗？
self.formal_poem_qwds=['诗','有']
# ----------词牌名问题-----------------------------------------------
# 所有的词牌名？
self.cipaiming_qwds=['词牌名']
# 词牌名包含哪些诗？
self.cipaiming_poem_qwds=['诗','有']
# ----------曲牌名问题-----------------------------------------------
# 类所有曲牌名？
self.qupaiming_qwds=['曲牌名']
# 曲牌名包含哪些诗？
self.qupaiming_poem_qwds=['诗', '有']
# ----------朝代问题-----------------------------------------------
# 所有的朝代？
self.desty_qwds=['朝代']
# 朝代包含哪些诗？
self.desty_poem_qwds=['诗', '有']
# 朝代包含的诗人？
self.desty_author_qwds=['诗人','人']
# ----------诗人合称问题-----------------------------------------------
# 所有合称
self.common_name_qwds=['诗人合称']
# 诗人合称包含哪些人？
self.common_name_author_qwds=['人','诗人']
# ----------飞花令问题--------------------------------------------------
# 飞花令的诗句
self.word_qwds=['飞花令']
# 飞花令的诗句
self.word_poem_qwds=['飞花令']
解决的问题
- ? 使用 解析 生成 语法树, 将其后的逻辑计划生成, 优化, 物理计划都自己完成, 而不依赖
- 执行计划和优化交给优化器
- 内建了一套简单的 解析器, 可以不使用 , 此外, 还引入和 这样的 , 完全可以不依赖任何 的组件
- ? 只能查询文件, 可以直接降查询作用于 , 这一点是一个大进步
新的问题
对于初期版本的 ?, 依然有挺多问题, 例如只能支持 的使用, 不能很好的兼容命令式, 入口不够统一等
? 在 2.0 时代, 增加了一个新的 ?, 叫做 ?, ? 统一和结合了 ? 的访问和命令式 的使用, 这是一个划时代的进步
在 ? 中可以轻易的做到使用 ? 查询并且筛选数据, 然后使用命令式 进行探索式分析
| 重要性
? 不只是一个 ? 引擎, 也包含了一套对 结构化数据的命令式 ?, 事实上, 所有 ? 中常见的工具, 都是依赖和依照于 ? 的 设计的 |
总结: 是什么
? 是一个为了支持 ? 而设计的工具, 但同时也支持命令式的
定义 | 特点 | 举例 | |
结构化数据 | 有固定的 | 有预定义的 | 关系型数据库的表 |
半结构化数据 | 没有固定的 , 但是有结构 | 没有固定的 , 有结构信息, 数据一般是自描述的 | 指一些有结构的文件格式, 例如 |
非结构化数据 | 没有固定 , 也没有结构 | 没有固定 , 也没有结构 | 指文档图片之类的格式 |
结构化数据
一般指数据有固定的 ?, 例如在用户表中, ? 字段是 ? 型, 那么每一条数据的 ? 字段值都可以当作 来使用
半结构化数据
一般指的是数据没有固定的 , 但是数据本身是有结构的
没有固定
指的是半结构化数据是没有固定的 ? 的, 可以理解为没有显式指定 ?比如说一个用户信息的 文件, 第一条数据的 有可能是 , 第二条数据虽说应该也是 , 但是如果硬要指定为 , 也是有可能的
因为没有指定 , 没有显式的强制的约束
处理什么数据的问题?
- ? 的 主要用于处理 非结构化数据 和 半结构化数据
- 主要用于处理 结构化数据
? 相较于 的优势在哪?
- 提供了更好的外部数据源读写支持
- 因为大部分外部数据源是有结构化的, 需要在 之外有一个新的解决方案, 来整合这些结构化数据源
- 提供了直接访问列的能力
- 因为 主要用做于处理结构化数据, 所以其提供的 具有一些普通数据库的能力
总结: 适用于什么场景?
适用于处理结构化数据的场景
SparkSQL 中有一个新的入口点, 叫做 SparkSessionSparkSQL 中有一个新的类型叫做 DatasetSparkSQL 有能力直接通过字段名访问数据集, 说明 SparkSQL 的 API 中是携带 Schema 信息的
DataFrame & Dataset
? 对外提供的 有两类：
一类是直接执行 , 另外一类就是命令式.
? 提供的命令式 ? 就是 ? 和 ?, 暂时也可以认为 ? 就是 ?, 只是在不同的 ? 中返回的是 的不同表现形式
例如：
通过上面的代码, 可以清晰的看到, ? 的命令式操作相比于 ? 来说, 可以直接通过 信息来访问其中某个字段, 非常的方便
以往使用 ? 肯定是要有一个表的, 在 ? 中, 并不存在表的概念, 但是有一个近似的概念, 叫做 ?, 所以一般情况下要先通过 ? 或者 ? 注册一张临时表, 然后使用 操作这张临时表
总结
? 提供了 ? 和 命令式 两种不同的访问结构化数据的形式, 并且它们之间可以无缝的衔接
命令式 ? 由一个叫做 ? 的组件提供, 其还有一个变形, 叫做
? 是一个强类型, 并且类型安全的数据容器, 并且提供了结构化查询 ? 和类似 ? 一样的命令式
可以获取 ? 对应的 表示：
- 使用? 将? 转为 的形式
- ? 的执行计划底层的
? 中有 ? 信息, 可以像操作表一样操作 .
? 由两部分构成, 一是 ? 的集合, 每个 ? 对象表示一个行, 二是描述 ? 结构的 .
? 支持 ? 中常见的操作, 例如: ?, ?, ?, ?, ?, 等
通过集合创建 的时候, 集合中不仅可以包含样例类, 也可以只有普通数据类型, 后通过指定列名来创建
Step 1: 首先可以打印 ? 的 , 查看其中所包含的列, 以及列的类型
Step 2: 对于大部分计算来说, 可能不会使用所有的列, 所以可以选择其中某些重要的列
Step 3: 可以针对某些列进行分组, 后对每组数据通过函数做聚合
总结
- 是一个类似于关系型数据库表的函数式组件
- 一般处理结构化数据和半结构化数据
- 具有数据对象的 Schema 信息
- 可以使用命令式的 操作 , 同时也可以使用 操作
- 可以由一个已经存在的集合直接创建, 也可以读取外部的数据源来创建
第一点: 表达的含义是一个支持函数式操作的 , 而 表达是是一个类似 的东西, 可以处理任何对象
第二点: ? 中所存放的是 ? 对象, 而 ? 中可以存放任何类型的对象 第三点: 的操作方式和 ? 是一样的, 但是对于强类型操作而言, 它们处理的类型不同 第四点: 只能做到运行时类型检查, 能做到编译和运行时都有类型检查
? 对象表示的是一个
? 的操作类似于 ? 中的 数据类型
- ? 就是 , 他们的方式是一样的, 也都支持 和 两种操作方式
- ? 只能通过表达式的形式, 或者列的形式来访问数据, 只有 支持针对于整个对象的操作
- ? 中的数据表示为 , 是一个行的概念
由如下几个组件组成
组件 | 解释 |
结构信息, 因为 ? 是有结构的, 所以在读取数据的时候, 就需要有 信息, 有可能是从外部数据源获取的, 也有可能是指定的 | |
连接外部数据源的参数, 例如 ? 的 ?, 或者读取 ? 文件是否引入 等 | |
外部数据源的格式, 例如 ?, ?, 等 |
? 有两种访问方式, 一种是使用 ? 方法加载, 使用 ? 指定加载格式, 还有一种是使用封装方法, 类似 ?, ?, 等
中由如下几个部分组成
组件 | 解释 |
写入目标, 文件格式等, 通过 方法设定 | |
写入模式, 例如一张表已经存在, 如果通过 ? 向这张表中写入数据, 是覆盖表呢, 还是向表中追加呢? 通过 方法设定 | |
外部参数, 例如 ? 的 ?, 通过 ?, 设定 | |
类似 ? 的分区, 保存表的时候使用, 这个地方的分区不是 ? 的分区, 而是文件的分区, 或者表的分区, 通过 设定 | |
类似 ? 的分桶, 保存表的时候使用, 通过 设定 | |
用于排序的列, 通过 设定 |
指定了写入模式, 例如覆盖原数据集, 或者向原数据集合中尾部添加等
对象表示 | 字符串表示 | 解释 |
将 ? 保存到 时, 如果目标已经存在, 则报错 | ||
将 ? 保存到 ? 时, 如果目标已经存在, 则添加到文件或者 中 | ||
将 ? 保存到 ? 时, 如果目标已经存在, 则使用 中的数据完全覆盖目标 | ||
将 ? 保存到 ? 时, 如果目标已经存在, 则不会保存 ? 数据, 并且也不修改目标数据集, 类似于 |
? 也有两种使用方式, 一种是使用 ? 配合 ?, 还有一种是使用封装方法, 例如 ?, ?, 等
读写 文件：
写入 的时候可以指定分区
? 在写入文件的时候是支持分区的, 可以像 一样设置某个列为分区列
? 可以从一个保存了 ? 格式字符串的 ? 中读取 ? 信息, 转为
在 中创建表
第一步, 需要先将文件上传到集群中, 使用如下命令上传到 中
第二步, 使用 ? 或者 ? 执行如下
第三步：将hdfs上的文件，加载到该表
通过 ? 查询 的表
通过 ? 创建 表
使用 处理数据并保存进 Hive 表
打包后：通过spark-submit来运行
然后去hive中查看：
? 中并没有直接提供按照 ? 进行筛选读取数据的 ? 和参数, 但是可以通过 ? 来曲线救国, ? 指定目标表的名称, 但是因为 ? 中可以编写 , 所以使用子查询即可做到
属性 | 含义 |
指定按照哪一列进行分区, 只能设置类型为数字的列, 一般指定为 | |
?, | 确定步长的参数, ? 之间的数据均分给每一个分区, 小于 ? 的数据分给第一个分区, 大于 的数据分给最后一个分区 |
分区数量 |
false);
fabTop=view.findViewById(R.id.fab_top);
tabLayout=view.findViewById(R.id.tablayout);
viewPager2=view.findViewById(R.id.viewpager);
//构建展开按钮属性
FabAttributes writeblog=new FabAttributes.Builder()
.setBackgroundTint(Color.parseColor("#2096F3"))
.setSrc(getResources().getDrawable(R.drawable.ic_edit))
.setFabSize(FloatingActionButton.SIZE_AUTO)
.setPressedTranslationZ(10)
.setTag(1)
.build();
FabAttributes qiandao=new FabAttributes.Builder()
.setBackgroundTint(Color.parseColor("#FF9800"))
.setSrc(getResources().getDrawable(R.drawable.qiandao))
.setFabSize(FloatingActionButton.SIZE_AUTO)
.setPressedTranslationZ(10)
.setTag(2)
.build();
FabAttributes dongtai=new FabAttributes.Builder()
.setBackgroundTint(Color.parseColor("#03A9F4"))
.setSrc(getResources().getDrawable(R.drawable.dongtai))
.setFabSize(FloatingActionButton.SIZE_AUTO)
.setPressedTranslationZ(10)
.setTag(3)
.build();
//添加菜单
fabTop.addFab(writeblog, qiandao, dongtai);
fabTop.setAnimationManager(new FabAlphaAnimate(fabTop));
//设置菜单点击事件
fabTop.setFabClickListener(this);
package com.example.newbsh.UI.home.hometype.news.shownews;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import android.annotation.SuppressLint;
import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.method.ScrollingMovementMethod;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.bumptech.glide.Glide;
import com.bumptech.glide.request.RequestOptions;
import com.example.newbsh.HttpUtil.HttpUtil;
import com.example.newbsh.MainActivity;
import com.example.newbsh.R;
import com.example.newbsh.UI.home.hometype.news.shownews.comment.BlogComment;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.lang.ref.WeakReference;
import java.util.Objects;
public class ShowNewsActivity extends AppCompatActivity implements View.OnClickListener {
TextView textViewtitle,textViewdoc,textViewdate,textViewbkauthorname;
LinearLayout piclinearLayout,commentLayout;
TextView msg;
Button send;
private ImageView support,collect,bkphoto;
private Button attention;
private String title,authorname;
private String username=MainActivity.getUserName();
private ShowBlogHandler blogHandler;
String url;
@RequiresApi(api=Build.VERSION_CODES.M)
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_show_news);
blogHandler=new ShowBlogHandler(this);
init();//初始化文章的内容
isAttention();//判断是否关注
isCollect();//判断是否收藏
isSupport();//判断是否点赞
showComment();//展示评论
}
private void init() {
textViewtitle=findViewById(R.id.NewsTitle);
textViewdoc=findViewById(R.id.Newsdoc);
textViewdate=findViewById(R.id.Newsdate);
piclinearLayout=findViewById(R.id.picturelinearlayout);
commentLayout=findViewById(R.id.comment_layout);
textViewdoc.setMovementMethod(new ScrollingMovementMethod());
support=findViewById(R.id.support);
collect=findViewById(R.id.collect);
attention=findViewById(R.id.attention);
msg=findViewById(R.id.msg);
send=findViewById(R.id.send);
bkphoto=findViewById(R.id.userphoto);
textViewbkauthorname=findViewById(R.id.bkname);
initdoc();
support.setOnClickListener(this);
collect.setOnClickListener(this);
attention.setOnClickListener(this);
send.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String comment=msg.getText().toString();
if(comment.isEmpty()){
Toast.makeText(ShowNewsActivity.this, "发送内容不能为空", Toast.LENGTH_SHORT).show();
return;
}
writeComment(comment); //开启线程
}
});
}
public void onClick(View v) {
switch (v.getId()) {
case R.id.attention:
attentionAction();
break;
case R.id.collect:
collectAction();
break;
case R.id.support:
supportAction();
break;
default:
break;
}
}
private void isSupport() { //是否点赞
new Thread(new Runnable() {
@Override
public void run() {
Log.d("data", "点赞");
String requrl="http://39.97.181.86/BaiXiaoSheng/findsupport?username=" + username + "&title=" + title + "";
boolean isthumb=Boolean.parseBoolean(String.valueOf(HttpUtil.sendPost(requrl, "")));
Message msg=new Message();
msg.what=300;
msg.obj=isthumb;
blogHandler.sendMessage(msg);
Log.d("点赞", String.valueOf(isthumb));
}
}).start();
}
private void isCollect() { //是否收藏
new Thread(new Runnable() {
@Override
public void run() {
Log.d("data", "收藏");
String requrl="http://39.97.181.86/BaiXiaoSheng/findcollect?username=" + username + "&title=" + title + "";
boolean isStore=Boolean.parseBoolean(String.valueOf(HttpUtil.sendPost(requrl, "")));
Message msg=new Message();
msg.what=400;
msg.obj=isStore;
blogHandler.sendMessage(msg);
Log.d("收藏", String.valueOf(isStore));
}
}).start();
}
private void isAttention() { //是否关注
new Thread(new Runnable() {
@Override
public void run() {
Log.d("data", "关注");
String requrl="http://39.97.181.86/BaiXiaoSheng/findattention?username=" + username + "&authorname=" + authorname + "";
boolean isAttention=Boolean.parseBoolean(String.valueOf(HttpUtil.sendPost(requrl, "")));
Message msg=new Message();
msg.what=500;
msg.obj=isAttention;
blogHandler.sendMessage(msg);
Log.d("关注", String.valueOf(isAttention));
}
}).start();
}
private void attentionAction() {
new Thread(new Runnable() {
@Override
public void run() {
String text=attention.getText().toString();
String requrl="http://39.97.181.86/BaiXiaoSheng/attentionaction?username=" + username + "&authorname=" + authorname +
"&type=" + text.equals("关注") + "";
boolean flag=Boolean.parseBoolean(String.valueOf(HttpUtil.sendPost(requrl, "")));
Message msg=new Message();
msg.what=700;
msg.obj=flag;
blogHandler.sendMessage(msg);
}
}).start();
}
private void collectAction() {
new Thread(new Runnable() {
@Override
public void run() {
String requrl="http://39.97.181.86/BaiXiaoSheng/collectaction?username=" + username + "&title=" + title + "&" +
"type=" + judegIsDraw(collect) + "";
boolean flag=Boolean.parseBoolean(String.valueOf(HttpUtil.sendPost(requrl, "")));
Message msg=new Message();
msg.what=800;
msg.obj=flag;
blogHandler.sendMessage(msg);
}
}).start();
}
private void supportAction() {
new Thread(new Runnable() {
@Override
public void run() {
String requrl="http://39.97.181.86/BaiXiaoSheng/supportaction?username=" + username + "&title=" + title + "&" +
"type=" + judegIsDraw(support) + "";
boolean flag=Boolean.parseBoolean(String.valueOf(HttpUtil.sendPost(requrl, "")));
Message msg=new Message();
msg.what=900;
msg.obj=flag;
blogHandler.sendMessage(msg);
}
}).start();
}
private boolean judegIsDraw(View view) { //判断当前资源文件
boolean flag=false;
switch (view.getId()) {
case R.id.collect:
flag=Objects.equals(((ImageView) view).getDrawable().getCurrent().getConstantState(),
getResources().getDrawable(R.drawable.ic_turned_in_not).getConstantState());
Log.d("collect",String.valueOf(flag));
break;
case R.id.support:
flag=Objects.equals(((ImageView) view).getDrawable().getCurrent().getConstantState(),
getResources().getDrawable(R.drawable.ic_thumb_not_up).getConstantState());
Log.d("support",String.valueOf(flag));
break;
default:
break;
}
return flag;
}
private void writeComment(String comment)
{
new Thread(new Runnable() {
@Override
public void run() {
String reqdata="http://39.97.181.86/BaiXiaoSheng/sendnewscomment?username="+username+"&comment="+comment+"&title="+title;
String json=String.valueOf(HttpUtil.sendPost(reqdata,""));
Message msg=new Message();
msg.what=1000;
msg.obj=json;
blogHandler.sendMessage(msg);
Log.d("writecomment",json);
}
}).start();
}
private void showComment() {
new Thread(new Runnable() {
@Override
public void run() {
Log.d("data", "评论");
String requrl="http://39.97.181.86/BaiXiaoSheng/findallcomments?title="+title;
String json=String.valueOf(HttpUtil.sendPost(requrl, ""));
Message msg=new Message();
msg.what=600;
msg.obj=json;
blogHandler.sendMessage(msg);
Log.d("评论", json);
}
}).start();
}
private void initdoc() {
Bundle bundle=getIntent().getExtras();
url=bundle.getString("url");
String []urls=url.split(" ");
if (bundle !=null) {
title=bundle.getString("title");
textViewtitle.setText(bundle.getString("title"));
textViewdoc.setText(bundle.getString("doc"));
textViewdate.setText("文章发布时间为："+bundle.getString("date"));
textViewbkauthorname.setText(bundle.getString("authorname"));
authorname=bundle.getString("authorname");
Glide.with(this)
.load(bundle.getString("authorurl"))
.circleCrop()
.into(bkphoto);
} else {
Log.i("bundle", "为空。。。。。。");
}
RequestOptions options=new RequestOptions()
.error(R.drawable.error)
.placeholder(R.drawable.loading);
for(int i=0;i<urls.length;i++)
{
ImageView imageView=new ImageView(this);
Glide.with(this)
.load(urls[i])
.apply(options)
.into(imageView);
LinearLayout.LayoutParams layout=new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
layout.setMargins(0, 10, 0, 0);
imageView.setLayoutParams(layout);
piclinearLayout.addView(imageView);
}
}
static class ShowBlogHandler extends Handler { //防止内存泄漏
private final ShowNewsActivity mcontext;
ShowBlogHandler(ShowNewsActivity activity) {
WeakReference<ShowNewsActivity> weakReference=new WeakReference<>(activity);
mcontext=weakReference.get();
}
@SuppressLint("SetTextI18n")
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 300:
if (Boolean.parseBoolean(msg.obj.toString()))
mcontext.support.setImageResource(R.drawable.ic_thumb_up);
break;
case 400:
if (Boolean.parseBoolean(msg.obj.toString()))
mcontext.collect.setImageResource(R.drawable.ic_turned_in);
break;
case 500:
if (Boolean.parseBoolean(msg.obj.toString()))
mcontext.attention.setText("已关注");
break;
case 600:
try {
JSONArray comments=new JSONArray(msg.obj.toString());
Log.i("length:", ""+comments.length());
for (int i=0; i < comments.length(); i++) {
JSONObject object=comments.getJSONObject(i);
BlogComment blogComment=new BlogComment(mcontext);
if (!object.isNull("imgurl")) {
Glide.with(mcontext)
.load(object.getString("imgurl"))
.circleCrop()
.into(blogComment.getImageView());
}
blogComment.getName().setText(object.getString("username"));
blogComment.getComment().setText(object.getString("comment"));
blogComment.getDate().setText(object.getString("date"));
Log.i("次数:", ""+object.getString("comment"));
mcontext.commentLayout.addView(blogComment,0);
}
} catch (JSONException e) {
e.printStackTrace();
}
break;
case 700:
if (Boolean.parseBoolean(msg.obj.toString())) {
String text=mcontext.attention.getText().toString();
if (text.equals("关注")) {
mcontext.attention.setText("已关注");
Toast toast=Toast.makeText(mcontext, "关注成功", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
} else {
mcontext.attention.setText("关注");
Toast toast=Toast.makeText(mcontext, "已取消关注", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
} else {
Toast toast=Toast.makeText(mcontext, "未知原因，操作失败", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
break;
case 800:
if (Boolean.parseBoolean(msg.obj.toString())) {
if (mcontext.judegIsDraw(mcontext.collect)) {
mcontext.collect.setImageResource(R.drawable.ic_turned_in);
Toast toast=Toast.makeText(mcontext, "收藏成功", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
} else {
mcontext.collect.setImageResource(R.drawable.ic_turned_in_not);
Toast toast=Toast.makeText(mcontext, "已取消收藏", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
} else {
Toast toast=Toast.makeText(mcontext, "未知原因，操作失败", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
break;
case 900:
if (Boolean.parseBoolean(msg.obj.toString())) {
if (mcontext.judegIsDraw(mcontext.support)) {
mcontext.support.setImageResource(R.drawable.ic_thumb_up);
Toast toast=Toast.makeText(mcontext, "点赞成功", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
} else {
mcontext.support.setImageResource(R.drawable.ic_thumb_not_up);
Toast toast=Toast.makeText(mcontext, "已取消点赞", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
} else {
Toast toast=Toast.makeText(mcontext, "未知原因，操作失败", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
}
break;
case 1000:
try {
JSONObject object=new JSONObject(msg.obj.toString());
BlogComment blogComment=new BlogComment(mcontext);
blogComment.getDate().setText(object.getString("date"));
blogComment.getComment().setText(object.getString("comment"));
blogComment.getName().setText(object.getString("username"));
if(!object.isNull("imgurl")){
if(object.getString("imgurl").length()>0)
Glide.with(mcontext)
.load(object.getString("imgurl"))
.circleCrop()
.into(blogComment.getImageView());
}
mcontext.commentLayout.addView(blogComment,0);
mcontext.msg.setText("");
mcontext.msg.clearFocus();
InputMethodManager imm=(InputMethodManager) mcontext.getSystemService(Context.INPUT_METHOD_SERVICE); //键盘收缩
if (imm !=null) {
imm.hideSoftInputFromWindow(mcontext.msg.getWindowToken(),0);
}
Toast toast=Toast.makeText(mcontext, "评论成功", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
} catch (JSONException e) {
e.printStackTrace();
}
break;
default:
break;
}
}
}
}
举报文章
请选择举报类型
内容侵权
涉嫌营销
内容抄袭
违法信息
其他
补充说明
0/200
上传截图
格式支持JPEG/PNG/JPG，图片不超过1.9M
所学时间 | 720分钟 |
代码量 | 800行左右 |
博客量 | 6 |
学习的知识点 | 爬虫的基本操作，爬取静态网页，链接数据库，存储数据 |
基本的python的语法，变量还有ajax的交互与jqury的学习 | |
linux云服务器的配置，jre，jdk，tomcat和mysql的配置，成功部署网页项目 |
#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+10;
typedef long long ll;
ll n,m;
typedef pair<int, int> PII;
int h[maxn],e[maxn],w[maxn],ne[maxn],idx;
int dist[maxn];
bool st[maxn];
void add(int x,int y,int c)
{
//权值记录
w[idx]=c;
//终点边记录
e[idx]=y;
//存储编号为idx的边的前一条边的编号
ne[idx]=h[x];
//代表以x为起点的边的编号，这个值会发生变化
h[x]=idx++;
}
ll spfa()
{
ll i,j;
memset(dist,0x3f,sizeof(dist));
dist[1]=0;
queue<int> q;
//将起点加入
q.push(1);
//标记已在集合
st[1]=true;
while(q.size())
{
int t=q.front();
q.pop();
//弹出后，不在集合
st[t]=false;
for(i=h[t];i!=-1;i=ne[i])
{
//获得终点
j=e[i];
//判断距离
if(dist[j]>dist[t]+w[i])
{
//更新距离
dist[j]=dist[t]+w[i];
//判断终点是否在集合
if(!st[j])
{
//加到集合，继续更新他到其他点的最短距离
q.push(j);
st[j]=true;
}
}
}
}
//如果说原点到终点n的距离还是无穷，则代表到达不了
if(dist[n]==0x3f3f3f3f)
return -1;
else
return dist[n];
}
int main()
{
ll i,j;
cin>>n>>m;
//初始化h数组为-1，目的是为ne数组赋值
memset(h,-1,sizeof(h));
while(m--)
{
int x,y,z;
cin>>x>>y>>z;
//加边
add(x,y,z);
}
ll ans=spfa();
if(ans==-1)
cout<<"impossible";
else
cout<<ans;
return 0;
}
# -*-coding:utf-8-*-
import pickle
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam
from torch.utils.data import DataLoader
from tqdm import tqdm
from 情感分析.诗词情感分析 import dataset
from 情感分析.诗词情感分析.vocab import Vocab
train_batch_size=128
test_batch_size=128
voc_model=pickle.load(open("https://blog.51cto.com/u_14824425/models/vocab.pkl", "rb"))
sequence_max_len=100
def collate_fn(batch):
"""
对batch数据进行处理
:param batch: [一个getitem的结果，getitem的结果,getitem的结果]
:return: 元组
"""
reviews, labels=zip(*batch)
reviews=torch.LongTensor([voc_model.transform(i, max_len=sequence_max_len) for i in reviews])
labels=torch.LongTensor(labels)
return reviews, labels
def get_dataloader(train=True):
imdb_dataset=dataset.ImdbDataset(train)
batch_size=train_batch_size if train else test_batch_size
return DataLoader(imdb_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn)
class ImdbModel(nn.Module):
def __init__(self):
super(ImdbModel, self).__init__()
self.embedding=nn.Embedding(num_embeddings=len(voc_model), embedding_dim=200, padding_idx=voc_model.PAD).to()
self.lstm=nn.LSTM(input_size=200, hidden_size=64, num_layers=6, batch_first=True, bidirectional=True,
dropout=0.1)
self.fc1=nn.Linear(64 * 2, 64)
self.fc2=nn.Linear(64, 7)
def forward(self, input):
"""
:param input:[batch_size,max_len]
:return:
"""
input_embeded=self.embedding(input) # input embeded :[batch_size,max_len,200]
output, (h_n, c_n)=self.lstm(input_embeded) # h_n :[4,batch_size,hidden_size]
# out :[batch_size,hidden_size*2]
out=torch.cat([h_n[-1, :, :], h_n[-2, :, :]], dim=-1) # 拼接正向最后一个输出和反向最后一个输出
# 进行全连接
out_fc1=self.fc1(out)
# 进行relu
out_fc1_relu=F.relu(out_fc1)
# 全连接
out_fc2=self.fc2(out_fc1_relu) # out :[batch_size,2]
return F.log_softmax(out_fc2, dim=-1)
def device():
if torch.cuda.is_available():
return torch.device('cuda')
else:
return torch.device('cpu')
def train(imdb_model, epoch):
"""
:param imdb_model:
:param epoch:
:return:
"""
train_dataloader=get_dataloader(train=True)
optimizer=Adam(imdb_model.parameters())
for i in range(epoch):
bar=tqdm(train_dataloader, total=len(train_dataloader))
for idx, (data, target) in enumerate(bar):
optimizer.zero_grad()
data=data.to(device())
target=target.to(device())
output=imdb_model(data)
loss=F.nll_loss(output, target)
loss.backward()
optimizer.step()
bar.set_description("epcoh:{} idx:{} loss:{:.6f}".format(i, idx, loss.item()))
torch.save(imdb_model, 'lstm_model.pkl')
def test(imdb_model):
"""
验证模型
:param imdb_model:
:return:
"""
test_loss=0
correct=0
imdb_model.eval（)
test_dataloader=get_dataloader(train=False)
with torch.no_grad():
for data, target in tqdm(test_dataloader):
data=data.to(device())
target=target.to(device())
output=imdb_model(data)
test_loss +=F.nll_loss(output, target, reduction='sum').item()
pred=output.data.max(1, keepdim=True)[1] # 获取最大值的位置,[batch_size,1]
correct +=pred.eq(target.data.view_as(pred)).sum()
test_loss /=len(test_dataloader.dataset)
print(' Test set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%) '.format(
test_loss, correct, len(test_dataloader.dataset),
100. * correct / len(test_dataloader.dataset)))
def xlftest():
import numpy as np
model=torch.load('lstm_model.pkl')
model.to(device())
from 情感分析.诗词情感分析.dataset import tokenlize
#乐，悲，忧，思，喜，怒，惧
lines=['独在异乡为异客,每逢佳节倍思亲。遥知兄弟登高处，遍插茱萸少一人。 ',
'昔日龌龊不足夸，今朝放荡思无涯。春风得意马蹄疾，一日看尽长安花。',
'锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦？',
'少小离家老大回，乡音无改鬓毛衰。儿童相见不相识，笑问客从何处来。',
'故人具鸡黍，邀我至田家。绿树村边合，青山郭外斜。开轩面场圃，把酒话桑麻。待到重阳日，还来就菊花。',
'怒发冲冠，凭栏处'
]
for line in lines:
print(line)
review=tokenlize(line)
# review=tokenlize(line)
vocab_model=pickle.load(open("https://blog.51cto.com/u_14824425/models/vocab.pkl", "rb"))
result=vocab_model.transform(review,sequence_max_len)
# print(result)
data=torch.LongTensor(result).to(device())
data=torch.reshape(data,(1,sequence_max_len)).to(device())
# print(data.shape)
output=model(data)
#print(output.data)
pred=output.data.max(1, keepdim=True)[1] # 获取最大值的位置,[batch_size,1]
#print(pred.item())
#['悲', '惧', '乐', '怒', '思', '喜', '忧']
if pred.item()==0:
print("悲")
elif pred.item()==1:
print("惧")
elif pred.item()==2:
print("乐")
elif pred.item()==3:
print("怒")
elif pred.item()==4:
print("思")
elif pred.item()==5:
print("喜")
elif pred.item()==6:
print("忧")
if __name__=='__main__':
# imdb_model=ImdbModel().to(device())
# train(imdb_model,30)
# test(imdb_model)
package com.example.newbsh.UI.Find;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.navigation.Navigation;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import com.bumptech.glide.request.RequestOptions;
import com.example.newbsh.HttpUtil.HttpUtil;
import com.example.newbsh.R;
import com.example.newbsh.UI.home.hometype.news.shownews.ShowNewsActivity;
import com.example.newbsh.UI.home.hometype.news.shownews.comment.BlogComment;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONArray;
import java.lang.ref.WeakReference;
import static com.android.volley.VolleyLog.TAG;
public class FindAdapter extends BaseAdapter {
private JSONArray jsonArray;
private Context context;
private LayoutInflater layoutInflater;
public FindAdapter(JSONArray jsonArray, Context context) {
this.jsonArray=jsonArray;
this.context=context;
this.layoutInflater=LayoutInflater.from(context);
}
@Override
public int getCount() {
return jsonArray.length();
}
@Override
public Object getItem(int position) {
return position;
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder=null;
holder=new ViewHolder();
convertView=layoutInflater.inflate(R.layout.cell_news2,parent,false);
holder.textViewTitle=convertView.findViewById(R.id.Title);
holder.textViewJianJie=convertView.findViewById(R.id.jianjie);
holder.textViewClicknumber=convertView.findViewById(R.id.click);
holder.textViewDatetime=convertView.findViewById(R.id.date);
holder.textViewnewscomment=convertView.findViewById(R.id.comment);
holder.textViewnewssupport=convertView.findViewById(R.id.support);
holder.photo=convertView.findViewById(R.id.userphoto);
JSONObject bean=null;
try {
bean=jsonArray.getJSONObject(position);
holder.textViewTitle.setText(bean.getString("title"));
holder.textViewJianJie.setText(bean.getString("doc"));
holder.textViewClicknumber.setText(bean.getString("click"));
holder.textViewDatetime.setText(bean.getString("date"));
String []urls=bean.getString("url").split(" ");
holder.textViewnewscomment.setText(bean.getString("comment"));
holder.textViewnewssupport.setText(bean.getString("support"));
RequestOptions options=new RequestOptions()
.error(R.drawable.error)
.placeholder(R.drawable.loading);
if(urls.length!=0) {
for(int i=0;i<urls.length;i++)
{
if(!urls[i].equals(" "))
{
Log.i("url",urls[i]);
Glide.with(convertView)
.load(urls[i])
.apply(options)
.into(holder.photo);
break;
}
}
}
} catch (JSONException e) {
e.printStackTrace();
}
convertView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Bundle bundle=new Bundle();
try {
bundle.putString("title", jsonArray.getJSONObject(position).getString("title"));
bundle.putString("doc",jsonArray.getJSONObject(position).getString("doc"));
bundle.putString("click",jsonArray.getJSONObject(position).getString("click"));
bundle.putString("date",jsonArray.getJSONObject(position).getString("date"));
bundle.putString("url",jsonArray.getJSONObject(position).getString("url"));
bundle.putString("authorname",jsonArray.getJSONObject(position).getString("authorname"));
bundle.putString("authorurl",jsonArray.getJSONObject(position).getString("authorurl"));
} catch (JSONException e) {
e.printStackTrace();
}
Intent intent=new Intent(context,ShowNewsActivity.class);
intent.putExtras(bundle);
context.startActivity(intent);
}
});
return convertView;
}
private static class ViewHolder
{
public TextView textViewTitle,textViewJianJie,textViewDatetime,textViewClicknumber,textViewnewssupport,textViewnewscomment;
public ImageView photo;
}
}
（一）linux云服务器的配置
自己弄了一个月的华为云服务器，选的是linux系统
今天将jdk与tomcat部署到该系统，并将自己的一个小Demo成功部署上去，但是出现一个问题，目前还不能访问后台，前台是没有问题的
明天将继续解决这个问题，同时将mysql下载到服务器里。
教程后期会补上，等我将这些bug补完。
（一）云服务器配置
首先我们先去购买一个云服务器ECS（我这里选用的是阿里云）选的系统是：ubunto的64位系统
接下来我们用一个远程的操作软件putty来进行远程连接我们的服务器：通过公网ip来进行访问，在购买服务器时要选择root的密码
这样我们就登录上去了，接下来就开始配置jre，jdk和tomcat
1.首先更新软件目录
在根目录键入如下代码：
2.然后开始安装jre
键入：sudo apt-get install default-jre
之后回车会提示你（Y/n），此时选择Y，就会开始安装你的jre
3.开始安装jdk
键入：sudo apt-get install default-jdk
同样也会提示你（Y/n），选择Y，就会开始安装jdk，可能需要等待一小会儿
安装完后我们可以检测一下是否安装成功：
键入：java -version
正产情况下就会显示出你安装的jdk的版本
4.开始安装我们的tomcat
这回我们是从网站上获取资源下载：
我们一般会将自己的软件放在/usr/local目录下，所以
先输入命令：cd /usr/local 更改目录
通过该命令来下载tomcat：wget 链接
这里的链接指的是 Linux 系统下的 ?tomcat 的下载地址??
点击右键，获取下载地址
开始下载。。。。完成后键入：ls查看当前目录下的文件，已经出来他的压缩包了
接下来就是对他进行解压：
tar -zxvf apache-tomcat-9.0.31.tar.gz
瞬间就会解压完成，此时在查看当前的目录：ls
就会出现tomcat的文件夹，代表解压成功
接下来就是开启tomcat
cd apache-tomcat-9.0.31
cd bin
https://blog.51cto.com/u_14824425/startup.sh
就开始启动tomcat
出现Tomcat started就代表已经启动
接下来通过我们的：公网ip:8080来进行访问，看是否成功
啊欧！！！没有成功是不是
这是因为我的安全组设置没有进行设置对外访问的端口号
找到阿里云的安全组配置规则，点击快速创建规则，将80端口配置上
选择网络和安全组，里的安全组配置，在选择右上角的配置规则，然后选择右上角的快速创建规则，然后点下如下图所示：
这样设置好后，回到我们的putty，这是我们需要修改一下我们的Tomcat的端口号
返回上一级目录：cd ..
进入conf目录：cd conf
然后编辑server.xml:vi server.xml
然后找到下图
键入：i
将他改为：
然后：
按键盘上的Esc
再输入命令 ":wq"(不带双引号)
就返回了
cd ..
cd bin
先关闭tomcat：https://blog.51cto.com/u_14824425/shutdown.sh
然后再开始：https://blog.51cto.com/u_14824425/startup.sh
记下来你将会被感动：输入你的公网IP回车
就会出下下图所示：就会看到我们可爱的小猫咪
接下来我将简单的将自己的一个web项目，导入到该服务器里
通过eclipse将我们的web程序，导出成war文件
选择存储路径为桌面，然后下载一个：WINSCP的软件
通过他我们将该war文件放入到/usr/local/apache-tomcat-9.0.31/webapps目录下
然后再将tomcat关掉，重新启动一下，他就会自动编译我们的war文件
之后我们通过：公网IP/项目名，就可以访问我们的web项目啦
项目网址：??我的博客??
啦啦啦，撒花撒花
举报文章
请选择举报类型
内容侵权
涉嫌营销
内容抄袭
违法信息
其他
补充说明
0/200
上传截图
格式支持JPEG/PNG/JPG，图片不超过1.9M
# -*-coding:utf-8-*-
import pickle
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam
from torch.utils.data import DataLoader
from tqdm import tqdm
from 情感分析.weibo_many_emotion import dataset
from 情感分析.中文情感分类.vocab import Vocab
train_batch_size=512
test_batch_size=128
voc_model=pickle.load(open("https://blog.51cto.com/u_14824425/models/vocab.pkl", "rb"))
sequence_max_len=100
def collate_fn(batch):
"""
对batch数据进行处理
:param batch: [一个getitem的结果，getitem的结果,getitem的结果]
:return: 元组
"""
reviews, labels=zip(*batch)
reviews=torch.LongTensor([voc_model.transform(i, max_len=sequence_max_len) for i in reviews])
labels=torch.LongTensor(labels)
return reviews, labels
def get_dataloader(train=True):
imdb_dataset=dataset.ImdbDataset(train)
batch_size=train_batch_size if train else test_batch_size
return DataLoader(imdb_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn)
class ImdbModel(nn.Module):
def __init__(self):
super(ImdbModel, self).__init__()
self.embedding=nn.Embedding(num_embeddings=len(voc_model), embedding_dim=200, padding_idx=voc_model.PAD).to()
self.lstm=nn.LSTM(input_size=200, hidden_size=64, num_layers=2, batch_first=True, bidirectional=True,
dropout=0.1)
self.fc1=nn.Linear(64 * 2, 64)
self.fc2=nn.Linear(64, 4)
def forward(self, input):
"""
:param input:[batch_size,max_len]
:return:
"""
input_embeded=self.embedding(input) # input embeded :[batch_size,max_len,200]
output, (h_n, c_n)=self.lstm(input_embeded) # h_n :[4,batch_size,hidden_size]
# out :[batch_size,hidden_size*2]
out=torch.cat([h_n[-1, :, :], h_n[-2, :, :]], dim=-1) # 拼接正向最后一个输出和反向最后一个输出
# 进行全连接
out_fc1=self.fc1(out)
# 进行relu
out_fc1_relu=F.relu(out_fc1)
# 全连接
out_fc2=self.fc2(out_fc1_relu) # out :[batch_size,2]
return F.log_softmax(out_fc2, dim=-1)
def device():
if torch.cuda.is_available():
return torch.device('cuda')
else:
return torch.device('cpu')
def train(imdb_model, epoch):
"""
:param imdb_model:
:param epoch:
:return:
"""
train_dataloader=get_dataloader(train=True)
optimizer=Adam(imdb_model.parameters())
for i in range(epoch):
bar=tqdm(train_dataloader, total=len(train_dataloader))
for idx, (data, target) in enumerate(bar):
optimizer.zero_grad()
data=data.to(device())
target=target.to(device())
output=imdb_model(data)
loss=F.nll_loss(output, target)
loss.backward()
optimizer.step()
bar.set_description("epcoh:{} idx:{} loss:{:.6f}".format(i, idx, loss.item()))
torch.save(imdb_model, 'lstm_model.pkl')
def test(imdb_model):
"""
验证模型
:param imdb_model:
:return:
"""
test_loss=0
correct=0
imdb_model.eval（)
test_dataloader=get_dataloader(train=False)
with torch.no_grad():
for data, target in tqdm(test_dataloader):
data=data.to(device())
target=target.to(device())
output=imdb_model(data)
test_loss +=F.nll_loss(output, target, reduction='sum').item()
pred=output.data.max(1, keepdim=True)[1] # 获取最大值的位置,[batch_size,1]
correct +=pred.eq(target.data.view_as(pred)).sum()
test_loss /=len(test_dataloader.dataset)
print(' Test set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%) '.format(
test_loss, correct, len(test_dataloader.dataset),
100. * correct / len(test_dataloader.dataset)))
def xlftest():
import numpy as np
model=torch.load('lstm_model.pkl')
model.to(device())
from 情感分析.weibo_many_emotion.dataset import tokenlize
lines=['哈哈哈开心','真是无语，你们怎么搞的','小姐姐，祝你生日快乐','你他妈的有病']
for line in lines:
print(line)
review=tokenlize(line)
# review=tokenlize(line)
vocab_model=pickle.load(open("https://blog.51cto.com/u_14824425/models/vocab.pkl", "rb"))
result=vocab_model.transform(review,sequence_max_len)
# print(result)
data=torch.LongTensor(result).to(device())
data=torch.reshape(data,(1,sequence_max_len)).to(device())
# print(data.shape)
output=model(data)
print(output.data)
pred=output.data.max(1, keepdim=True)[1] # 获取最大值的位置,[batch_size,1]
print(pred.item())
if pred.item()==0:
print("喜悦")
elif pred.item()==1:
print("愤怒")
elif pred.item()==2:
print("厌恶")
elif pred.item()==3:
print("低落")
if __name__=='__main__':
# imdb_model=ImdbModel().to(device())
# train(imdb_model,20)
# test(imdb_model)
package com.example.newbsh;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.NotificationCompat;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.graphics.BitmapFactory;
import android.os.Build;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MessageActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_message);
Button button=findViewById(R.id.send_message);
button.setOnClickListener(l);
}
View.OnClickListener l=new View.OnClickListener() {
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.button:
sendNotification();
break;
}
}
};
private void sendNotification() {
NotificationManager notificationManager=(NotificationManager) getSystemService(NOTIFICATION_SERVICE);
NotificationCompat.Builder builder=null;
if (Build.VERSION.SDK_INT >=Build.VERSION_CODES.O) {
NotificationChannel notificationChannel=new NotificationChannel("测试渠道", getString(R.string.app_name),
NotificationManager.IMPORTANCE_DEFAULT);
notificationManager.createNotificationChannel(notificationChannel);
builder=new NotificationCompat.Builder(this, "测试渠道");
} else {
builder=new NotificationCompat.Builder(this);
}
//Ticker是状态栏显示的提示
builder.setTicker("显示setTicker");
//第一行内容 通常作为通知栏标题
builder.setContentTitle("显示setContentTitle");
//第二行内容 通常是通知正文
builder.setContentText("这里显示setContentText");
//第三行内容 通常是内容摘要什么的 在低版本机器上不一定显示
builder.setSubText("这里显示setSubText！");
//ContentInfo 在通知的右侧 时间的下面 用来展示一些其他信息
builder.setContentInfo("这里显示ContentInfo");
//number设计用来显示同种通知的数量和ContentInfo的位置一样，如果设置了ContentInfo则number会被隐藏
builder.setNumber(2);
//true：点击通知栏，通知消失
builder.setAutoCancel(true);
//通知时间
builder.setWhen(System.currentTimeMillis());
//系统状态栏显示的小图标
builder.setSmallIcon(R.mipmap.ic_launcher);
//下拉显示的大图标
builder.setLargeIcon(BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher));
builder.setPriority(NotificationCompat.PRIORITY_HIGH);
builder.setDefaults(NotificationCompat.DEFAULT_ALL);
builder.setChannelId(this.getPackageName());//必须添加（Android 8.0） 【唯一标识
Notification notification=builder.build();
notificationManager.notify(1, notification);
}
}
#include<bits/stdc++.h>
using namespace std;
const int N=550,M=10010;
struct Edge
{
int a, b, c;
}edges[M];
int n,m,k;
int dist[N];
int last[N];
int bellmm_ford()
{
memset(dist,0x3f,sizeof(dist));
dist[1]=0;
for(int i=0;i<k;i++)
{
//加入last数组，是为了防止进行串联
//保存上一次的dist数组距离
memcpy(last,dist,sizeof(last));
for(int j=0;j<m;j++)
{
auto e=edges[j];
dist[e.b]=min(dist[e.b],last[e.a]+e.c);
}
}
//因为他是存在负边的，会有某个点到最终点权值为负，则会更新最终点的距离，使它小于0x3f3f3f3f,故由此判断
if(dist[n]<0x3f3f3f3f/2)
return dist[n];
else
return -1;
}
int main()
{
int i,j;
cin>>n>>m>>k;
for(i=0;i<m;i++)
{
int a,b,c;
cin>>a>>b>>c;
edges[i]={a,b,c};
}
int ans=bellmm_ford();
if(ans!=-1)
cout<<ans;
else
cout<<"impossible";
return 0;
}
def get_poemtime_about_poem():
poem_name=request.form.get("poem_name")
db=MySqLHelper()
desty=['tang', 'song', 'yuan', 'ming', 'qing']
author=''
bg_time=''
for it in desty:
sql="select * from " + it + " where title='" + poem_name + "';"
ret=db.selectone(sql=sql)
if ret!=None:
author=ret[2]
bg_time=str(ret[9]).replace('年','')
break
# print(author)
# print(bg_time)
date_list=[]
back_list=[]
poem_list=[]
content_list=[]
left=int(bg_time)-3
right=int(bg_time)+3
for it in desty:
sql="select * from " + it + " where author='" + author + "';"
ret,count=db.selectall(sql=sql)
if ret!=None:
for row in ret:
if str(row[9])!='无' and str(row[9]).find('．')==-1 and str(row[9]).find('—')==-1 and str(row[6])!='无':
time=int(str(row[9]).replace('年',''))
if time>=left and time<=right and bool(re.search(r'\d', row[6])):
date_list.append(time)
back_list.append(row[6])
poem_list.append(row[0])
content_list.append(row[3])
jsonData=[]
for dd in range(left,right+1):
for i in range(len(date_list)):
time=date_list[i]
poem=poem_list[i]
back=back_list[i]
content=content_list[i].replace(' ','').split('。')
ans_content=[]
for it in content:
if it!='':
ans_content.append(it+"。")
if time==dd:
dic={}
dic['time']=str(time)+"年"
dic['title']=poem
dic['back']=back
dic['content']=ans_content
jsonData.append(dic)
#print(json.dumps(jsonData).encode('utf-8').decode("unicode-escape"))
return
在人月神话里有句话，令我颇有感悟：“向进度落后的项目中增加人手，只会使进度更加落后。”
用人月这一观念来衡量项目进度带有欺骗性。因为他使得项目看上去好像人力和时间是可交换的。如果时间不够，那么增加人手就可以加快进度。
这个衡量的方式严重的忽略了新增加的人手的培训时间以及队员之间的互相沟通等因素。比如我生活中遇到的一个例子：在编写c++代码的时候遇到了错误，于是你找来了一帮人来帮你解决问题，他们出了多种解决方法，而你听取了他们的意见，可能奏效也可能不奏效，最终虽然增加了些许人手，但你并也为此付出了许多的时间去和每个人说出你的的编程思路，这样反而大大折扣！你可以找一个人对他仔细的说明思路，然后由他一个人去给你讲解，这样就一种思路便理解的很快，而且时间也不会造成太大的浪费。
一直在寻找的完美队伍：外科手术队伍
在团队协作开发中，我相信每个人都会想与大牛组队，但是必竟大牛是稀少的，这样的大牛们组成的小队那就是精英小队，我相信他们在解决一些小型项目上的开发速度与质量绝对是一般的小队开发效率的10倍不止；然而当面对大型项目开发时，这样的小而美的小队就有些力不从心了，因此这时外科手术团队的方式就值得借鉴。书中的对应是一名首席程序员相当于外科医生，一个经验相对较少的人员充当副手，一个管理员负责行政事务的决策，一个编辑用于生成文档，两个文秘使得文件与项目协作一致，一个程序职员用于维护技术记录，一个工具维护人员，一个测试人员，以及一个语言专家。这样的开发团队人员平等但是各司其职，保证了团队的有序运行。对于大型的项目，就需要在人员安排上使用分解的思路，由架构师负责整体设计，系统实现则由各个小团队协作完成。这样项目就可以分解成若干块，每块都有专门的负责人，可以很快的对应上，在沟通与交流方面更加快捷，便利。
import pandas as pd
def emotion():
data=pd.read_excel('emotion.xlsx')
similar=data.get('similar')
sad_list=str(similar[0]).split(',')
fear_list=str(similar[1]).split(',')
happy_list=str(similar[2]).split(',')
anger_list=str(similar[3]).split(',')
think_list=str(similar[4]).split(',')
like_list=str(similar[5]).split(',')
worry_list=str(similar[6]).split(',')
return sad_list,fear_list,happy_list,anger_list,think_list,like_list,worry_list
def test_sentence(sentence):
sad_list, fear_list, happy_list, anger_list, think_list, like_list, worry_list=emotion()
sad=fear=happy=anger=think=like=worry=0
for k in sentence:
if k in sad_list:
sad+=1
elif k in fear_list:
fear+=1
elif k in happy_list:
happy+=1
elif k in anger_list:
anger+=1
elif k in think_list:
think+=1
elif k in like_list:
like+=1
elif k in worry_list:
worry+=1
ans=max(sad,fear,happy,anger,think,like,worry)
scord_list=[]
scord_list.append(sad)
scord_list.append(fear)
scord_list.append(happy)
scord_list.append(anger)
scord_list.append(think)
scord_list.append(like)
scord_list.append(worry)
emotion_list=['悲','惧','乐','怒','思','喜','忧']
i=0
for i in range(len(scord_list)):
if scord_list[i]==ans:
print(emotion_list[i])
break
return emotion_list[i]
def read():
data=pd.read_excel('tang.xlsx')
content_list=data.get('content')
for i in range(len(content_list)):
content=content_list[i].replace(' ','')
ans_content=[]
content_l=str(content).split('。')
for k in content_l:
kk=str(k).split('，')
for it in kk:
if it!='':
ans_content.append(it)
ans_emotion={}
for sentence in ans_content:
print(sentence)
emot=test_sentence(sentence)
if emot not in ans_emotion.keys():
ans_emotion[emot]=1
else:
ans_emotion[emot]+=1
print(sorted(ans_emotion.items(), key=lambda item: item[1], reverse=True))
ans_emotion=dict(sorted(ans_emotion.items(), key=lambda item: item[1], reverse=True))
for key,value in ans_emotion.items():
print('整篇文章情感：'+key)
break
break
if __name__=='__main__':
read()
package com.example.newbsh.UI.friends.list;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.TextView;
import com.example.newbsh.R;
public class SideBar extends androidx.appcompat.widget.AppCompatTextView {
private String[] letters=new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "I",
"J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
"W", "X", "Y", "Z", "#"};
private Paint textPaint;
private Paint bigTextPaint;
private Paint scaleTextPaint;
private Canvas canvas;
private int itemH;
private int w;
private int h;
float singleTextH;
private float scaleWidth;
private float eventY=0;
private int scaleSize=1;
private int scaleItemCount=6;
private ISideBarSelectCallBack callBack;
public SideBar(Context context) {
this(context, null);
}
public SideBar(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public SideBar(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(attrs);
}
private void init(AttributeSet attrs) {
if (attrs !=null) {
TypedArray ta=getContext().obtainStyledAttributes(attrs, R.styleable.SideBar);
scaleSize=ta.getInteger(R.styleable.SideBar_scaleSize, 1);
scaleItemCount=ta.getInteger(R.styleable.SideBar_scaleItemCount, 6);
scaleWidth=ta.getDimensionPixelSize(R.styleable.SideBar_scaleWidth, dp(100));
ta.recycle();
}
textPaint=new Paint(Paint.ANTI_ALIAS_FLAG);
textPaint.setColor(getCurrentTextColor());
textPaint.setTextSize(getTextSize());
textPaint.setTextAlign(Paint.Align.CENTER);
bigTextPaint=new Paint(Paint.ANTI_ALIAS_FLAG);
bigTextPaint.setColor(getCurrentTextColor());
bigTextPaint.setTextSize(getTextSize() * (scaleSize + 3));
bigTextPaint.setTextAlign(Paint.Align.CENTER);
scaleTextPaint=new Paint(Paint.ANTI_ALIAS_FLAG);
scaleTextPaint.setColor(getCurrentTextColor());
scaleTextPaint.setTextSize(getTextSize() * (scaleSize + 1));
scaleTextPaint.setTextAlign(Paint.Align.CENTER);
}
public void setDataResource(String[] data) {
letters=data;
invalidate();
}
public void setOnStrSelectCallBack(ISideBarSelectCallBack callBack) {
this.callBack=callBack;
}
public void setScaleSize(int scale) {
scaleSize=scale;
invalidate();
}
public void setScaleItemCount(int scaleItemCount) {
this.scaleItemCount=scaleItemCount;
invalidate();
}
private int dp(int px) {
final float scale=getContext().getResources().getDisplayMetrics().density;
return (int) (px * scale + 0.5f);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
case MotionEvent.ACTION_MOVE:
if (event.getX() > (w - getPaddingRight() - singleTextH - 10)) {
eventY=event.getY();
invalidate();
return true;
} else {
eventY=0;
invalidate();
break;
}
case MotionEvent.ACTION_CANCEL:
eventY=0;
invalidate();
return true;
case MotionEvent.ACTION_UP:
if (event.getX() > (w - getPaddingRight() - singleTextH - 10)) {
eventY=0;
invalidate();
return true;
} else
break;
}
return super.onTouchEvent(event);
}
@Override
protected void onDraw(Canvas canvas) {
this.canvas=canvas;
DrawView(eventY);
}
private void DrawView(float y) {
int currentSelectIndex=-1;
if (y !=0) {
for (int i=0; i < letters.length; i++) {
float currentItemY=itemH * i;
float nextItemY=itemH * (i + 1);
if (y >=currentItemY && y < nextItemY) {
currentSelectIndex=i;
if (callBack !=null) {
callBack.onSelectStr(currentSelectIndex, letters[i]);
}
//画大的字母
Paint.FontMetrics fontMetrics=bigTextPaint.getFontMetrics();
float bigTextSize=fontMetrics.descent - fontMetrics.ascent;
canvas.drawText(letters[i], w - getPaddingRight() - scaleWidth - bigTextSize, singleTextH + itemH * i, bigTextPaint);
}
}
}
drawLetters(y, currentSelectIndex);
}
private void drawLetters(float y, int index) {
//第一次进来没有缩放情况，默认画原图
if (index==-1) {
w=getMeasuredWidth();
h=getMeasuredHeight();
itemH=h / letters.length;
Paint.FontMetrics fontMetrics=textPaint.getFontMetrics();
singleTextH=fontMetrics.descent - fontMetrics.ascent;
for (int i=0; i < letters.length; i++) {
canvas.drawText(letters[i], w - getPaddingRight(), singleTextH + itemH * i, textPaint);
}
//触摸的时候画缩放图
} else {
//遍历所有字母
for (int i=0; i < letters.length; i++) {
//要画的字母的起始Y坐标
float currentItemToDrawY=singleTextH + itemH * i;
float centerItemToDrawY;
if (index < i)
centerItemToDrawY=singleTextH + itemH * (index + scaleItemCount);
else
centerItemToDrawY=singleTextH + itemH * (index - scaleItemCount);
float delta=1 - Math.abs((y - currentItemToDrawY) / (centerItemToDrawY - currentItemToDrawY));
float maxRightX=w - getPaddingRight();
//如果大于0，表明在y坐标上方
scaleTextPaint.setTextSize(getTextSize() + getTextSize() * delta);
float drawX=maxRightX - scaleWidth * delta;
//超出边界直接花在边界上
if (drawX > maxRightX)
canvas.drawText(letters[i], maxRightX, singleTextH + itemH * i, textPaint);
else
canvas.drawText(letters[i], drawX, singleTextH + itemH * i, scaleTextPaint);
}
}
}
public interface ISideBarSelectCallBack {
void onSelectStr(int index, String selectStr);
}
}
举报文章
请选择举报类型
内容侵权
涉嫌营销
内容抄袭
违法信息
其他
补充说明
0/200
上传截图
格式支持JPEG/PNG/JPG，图片不超过1.9M
找到从一个点到其他点的最短距离
①初始化距离dist数组，将起点dist距离设为0，其他点的距离设为无穷（就是很大的值）
②for循环遍历n次，每层循环里找出不在S集合中，且距离最近的点，然后用该点去更新其他点的距离，算法复杂度是O（n2），适合稠密图
题目：??https://www.acwing.com/problem/content/851/??
代码：
如果是稀疏图，点的个数比较多，1e5个点，用O（n2）就会爆掉，因此我们引入堆优化版的Dijstra
将找寻不在S中，且距离最近的点的方法进行优化，采用堆（优先队列的方法），时间复杂度为mlog(n)，就可以解决
对于稀疏图，我们可以用邻接表结构来进行存储
先上数据，如下。
第一行两个整数n m。n表示顶点个数（顶点编号为1~n），m表示边的条数。接下来m行表示，每行有3个数x y z，表示顶点x到顶点y的边的权值为z。下图就是一种使用链表来实现邻接表的方法。
上面这种实现方法为图中的每一个顶点（左边部分）都建立了一个单链表（右边部分）。这样我们就可以通过遍历每个顶点的链表，从而得到该顶点所有的边了。使用链表来实现邻接表对于痛恨指针的的朋友来说，这简直就是噩梦。
这里我将为大家介绍另一种使用数组来实现的邻接表，这是一种在实际应用中非常容易实现的方法。这种方法为每个顶点i（i从1~n）也都保存了一个类似“链表”的东西，里面保存的是从顶点i出发的所有的边，具体如下。
首先我们按照读入的顺序为每一条边进行编号（1~m）。比如第一条边“1 4 9”的编号就是1，“1 3 7”这条边的编号是5。
这里用u、v和w三个数组用来记录每条边的具体信息，即u[i]、v[i]和w[i]表示第i条边是从第u[i]号顶点到v[i]号顶点（u[i]àv[i]），且权值为w[i]。
再用一个first数组来存储每个顶点其中一条边的编号。以便待会我们来枚举每个顶点所有的边（你可能会问：存储其中一条边的编号就可以了？不可能吧，每个顶点都需要存储其所有边的编号才行吧！甭着急，继续往下看）。比如1号顶点有一条边是 “1 4 9”（该条边的编号是1），那么就将first[1]的值设为1。如果某个顶点i没有以该顶点为起始点的边，则将first[i]的值设为-1。现在我们来看看具体如何操作，初始状态如下。
咦？上图中怎么多了一个next数组，有什么作用呢？不着急，待会再解释，现在先读入第一条边“1 4 9”。
读入第1条边（1 4 9），将这条边的信息存储到u[1]、v[1]和w[1]中。同时为这条边赋予一个编号，因为这条边是最先读入的，存储在u、v和w数组下标为1的单元格中，因此编号就是1。这条边的起始点是1号顶点，因此将first[1]的值设为1。
另外这条“编号为1的边”是以1号顶点（即u[1]）为起始点的第一条边，所以要将next[1]的值设为-1。也就是说，如果当前这条“编号为i的边”，是我们发现的以u[i]为起始点的第一条边，就将next[i]的值设为-1（貌似的这个next数组很神秘啊⊙_⊙）。
读入第2条边（4 3 8），将这条边的信息存储到u[2]、v[2]和w[2]中，这条边的编号为2。这条边的起始顶点是4号顶点，因此将first[4]的值设为2。另外这条“编号为2的边”是我们发现以4号顶点为起始点的第一条边，所以将next[2]的值设为-1。
读入第3条边（1 2 5），将这条边的信息存储到u[3]、v[3]和w[3]中，这条边的编号为3，起始顶点是1号顶点。我们发现1号顶点已经有一条“编号为1 的边”了，如果此时将first[1]的值设为3，那“编号为1的边”岂不是就丢失了？我有办法，此时只需将next[3]的值设为1即可。现在你知道next数组是用来做什么的吧。next[i]存储的是“编号为i的边”的“前一条边”的编号。（注：next数组的大小由边的数目决定，first数组的大小由顶点的个数来决定）
读入第4条边（2 4 6），将这条边的信息存储到u[4]、v[4]和w[4]中，这条边的编号为4，起始顶点是2号顶点，因此将first[2]的值设为4。另外这条“编号为4的边”是我们发现以2号顶点为起始点的第一条边，所以将next[4]的值设为-1。
读入第5条边（1 3 7），将这条边的信息存储到u[5]、v[5]和w[5]中，这条边的编号为5，起始顶点又是1号顶点。此时需要将first[1]的值设为5，并将next[5]的值改为3（编号为5的边的前一条边的编号为3）。
此时，如果我们想遍历1号顶点的每一条边就很简单了。1号顶点的其中一条边的编号存储在first[1]中。其余的边则可以通过next数组寻找到。请看下图。
细心的同学会发现，此时遍历边某个顶点边的时候的遍历顺序正好与读入时候的顺序相反。因为在为每个顶点插入边的时候都直接插入“链表”的首部而不是尾部。不过这并不会产生任何问题，这正是这种方法的其妙之处。
题目：??https://www.acwing.com/problem/content/description/852/??
代码
这几天部署了一个云服务器，就想着将自己的项目部署到linux服务器上，结果访问前台页面还好，一旦访问到servlet他就报404
原因是：
本地的jdk版本和linux服务器上的版本不一致导致的linux上的服务器访问不到该路径
我的jdk版本号是12，而linux服务器上的jdk版本号是：11.0.6版本的
因此我要将自己的本地的web项目换成jdk为11.0.6版本的，我从网上下载并安装了jdk版本为11.0.6
接下来就是改变web项目的jdk版本
右击项目：选择Properies，然后选择对应编译环境对应的jdk版本，保存
然后去导入我们本地下载好的jdk版本，并选中，然后应用保存
这样我们再导出成.war的形式，然后部署到linux服务器上就完美的解决了。
终于解决困扰我的问题了，舒服。。。
现在我们有一个经典的数据集?数据集，地址：，这是一份包含了5万条流行电影的评论数据，其中训练集25000条，测试集25000条。数据格式如下：
下图左边为名称，其中名称包含两部分，分别是序号和情感评分，（1-4为neg，5-10为pos），右边为评论内容。
文本是一类序列数据，一篇文章可以看作是字符或单词的序列，本节将介绍文本数据的常见预处理步骤，预处理通常包括四个步骤：
- 读入文本
- 分词
- 建立字典，将每个词映射到一个唯一的索引（index）
- 将文本从词的序列转换为索引的序列，方便输入模型
文本的tokenization
?就是通常所说的分词，分出的每一个词语我们把它称为。
常见的分词工具很多，比如：
- 清华大学的分词工具THULAC：
构造词典
这里我们可以考虑把文本中的每个词语和其对应的数字，使用字典保存，同时实现方法把句子通过字典映射为包含数字的列表。
实现文本序列化之前，考虑以下几点:
- 如何使用字典把词语和数字进行对应
- 不同的词语出现的次数不尽相同，是否需要对高频或者低频词语进行过滤，以及总的词语数量是否需要进行限制
- 得到词典之后，如何把句子转化为数字序列，如何把数字序列转化为句子
- 不同句子长度不相同，每个batch的句子如何构造成相同的长度（可以对短句子进行填充，填充特殊字符）
- 对于新出现的词语在词典中没有出现怎么办（可以使用特殊字符代理）
思路分析：
- 对所有句子进行分词
- 词语存入字典，根据次数对词语进行过滤，并统计次数
- 实现文本转数字序列的方法
- 实现数字序列转文本方法
会生成对应的词典pkl文件
测试输出：
word embedding是深度学习中表示文本常用的一种方法。和one-hot编码不同，word embedding使用了浮点型的稠密矩阵来表示token。根据词典的大小，我们的向量通常使用不同的维度，例如100,256,300等。其中向量中的每一个值是一个参数，其初始值是随机生成的，之后会在训练的过程中进行学习而获得。
如果我们文本中有20000个词语，如果使用one-hot编码，那么我们会有20000*20000的矩阵，其中大多数的位置都为0，但是如果我们使用word embedding来表示的话，只需要20000* 维度，比如20000*300
我们会把所有的文本转化为向量，把句子用向量来表示
但是在这中间，我们会先把token使用数字来表示，再把数字使用向量来表示。
即：
word embedding API
参数介绍：
- ：词典的大小
- ：embedding的维度
使用方法：
embedding = nn.Embedding(vocab_size,300) #实例化
input_embeded = embedding(input) #进行embedding的操作
会生成对应的模型保存文件
导入可对其进行单独测试
准确率60%
超参数
模型
训练
测试
单条测试
测试效果
提升了一些
实现中文情感分析
from selenium import webdriver
import time
import random
def run():
browser=webdriver.Chrome()
browser.get("网址")
# 1
js="document.getElementById("q1").click()"
browser.execute_script(js)
browser.switch_to.frame("__calendarIframe")
js2="document.getElementById("selectTodayButton").click()"
browser.execute_script(js2)
browser.switch_to.parent_frame()
# 2
js="document.getElementById("q2").click()"
browser.execute_script(js)
browser.switch_to.frame("__calendarIframe")
js2="document.getElementById("selectTodayButton").click()"
browser.execute_script(js2)
browser.switch_to.parent_frame()
# 3
js="document.getElementById("q3_1").click()"
browser.execute_script(js)
# 4
browser.find_element_by_id("q4").send_keys("学号")
# 5
browser.find_element_by_id("q5").send_keys("姓名")
# 6
js="document.getElementById("q6_1").click()"
browser.execute_script(js)
# 7
js="document.getElementById("q7_3").click()"
browser.execute_script(js)
# 8
js="document.getElementById("q8_1").click()"
browser.execute_script(js)
browser.find_element_by_class_name("underline").send_keys("第一次1月9日阴性")
# 9
js="document.getElementById("q9_2").click()"
browser.execute_script(js)
# 10
js="document.getElementById("q10_2").click()"
browser.execute_script(js)
# 11
js="document.getElementById("q12_2").click()"
browser.execute_script(js)
# 12
browser.find_element_by_id("q14").send_keys("36."+str(random.randint(0,5))+"/36."+str(random.randint(0,5)))
#13
js="document.getElementById("q15_2").click()"
browser.execute_script(js)
#14
js="document.getElementById("q17_2").click()"
browser.execute_script(js)
#15
browser.find_element_by_id("q19").click()
time.sleep(1)
browser.switch_to.frame("PDF_i_chezchenz")
browser.find_element_by_id("txtInput").send_keys("地址")
js3="document.getElementById("btnSearch").click()"
browser.execute_script(js3)
time.sleep(1)
browser.find_element_by_css_selector("a.ensure_btn").click()
time.sleep(1)
browser.switch_to.default_content()
# 16
js="document.getElementById("q20_2").click()"
browser.execute_script(js)
# 17
browser.find_element_by_id("q22").send_keys("无")
# 18
browser.find_element_by_id('select2-q23-container').click()
# js="document.getElementById('select2-q23-container').click()"
# browser.execute_script(js)
browser.find_element_by_xpath("http://li[@class='select2-results__option'][1]").click()
# js="document.getElementById("select2-q23-result-ei9q-1").click()"
# browser.execute_script(js)
# submit
js="document.getElementById("submit_button").click()"
browser.execute_script(js)
if __name__=="__main__":
while True:
run()
time.sleep(4)
break
1/1 + 1/2 + 1/4 + 1/8 + 1/16 + ....
每项是前一项的一半，如果一共有20项,求这个和是多少，结果用分数表示出来。
类似：3/2当然，这只是加了前2项而已。分子分母要求互质。
可以知道这是一个等比数列，求前20项的和，在进行化简，gcd即可
整个20世纪(1901年1月1日至2000年12月31日之间)，一共有多少个星期一？
(不要告诉我你不知道今天是星期几)
计算总共的天数，然后计算除7和模7的结果，已知2000年12月31是星期日，模7后的结果为6，故不包含星期一，只需/7即可
如下的10行数据，每行有10个整数，请你求出它们的乘积的末尾有多少个零？
10是由2*5得来的，因此将每个数进行分解，看有多少个2和5，数量少的决定10的个数也就是末尾0的个数
到x星球旅行的游客都被发给一个整数，作为游客编号。
x星的国王有个怪癖，他只喜欢数字3,5和7。
国王规定，游客的编号如果只含有因子：3,5,7,就可以获得一份奖品。
前10个幸运数字是：3 5 7 9 15 21 25 27 35 45，因而第11个幸运数字是：49
小明领到了一个幸运数字 59084709587505。
去领奖的时候，人家要求他准确说出这是第几个幸运数字，否则领不到奖品。
请你帮小明计算一下，59084709587505是第几个幸运数字。
直接暴力是不可能的，可以看出规律，用当前的数*3，*5，*7出来的数只要比59084709587505小，就保留大则舍弃。用set来进行保存，初始可以为1.
一、继承条件下的构造方法的调用
输出：
GrandParent Created.
Parent Created.String:Hello.Parent.
Child Created
在构造子类的方法之前会先构造父类的方法，如果是多级继承，会先执行最顶级父类的构造方法，然后依次执行各级个子类的构造方法。若想在子类中调用父类的有参构造方法，需要在子类的构造方法的第一行加上super方法，注意：只能是第一行
为什么子类的构造方法在运行之前，必须调用父类的构造方法？能不能反过来？为什么不能反过来？
二、不允许继承的类
不可变的“类”有何作用：
①可方便和安全的用于多线程的环境中
②访问他们不用加锁，可高性能的执行
输出：
123
456
true
三、反汇编
输出：
A@15db9742
我们用javap -c 来反编译该文件的.class文件,得到：
点进object里，发现tostring方法
public void main（object x）调用了String类的valueOf方法，
故而出现了这样的输出
三、神奇的“+”号和方法覆盖
在输出字符串+对象时，会隐式的调用tostring（）的方法
方法的覆盖：要求子类和父类的方法一样，并且实现在子类中调用父类的被覆盖的方法
输出：
Parent print
Children print
利用super（）的方法调用父类的对象，然后再调用父类的覆盖方法
覆盖的语法规则：
四、如何判断对象是否可以转换
输出：
字符串是否是Object类的实例：true
字符串是否是String类的实例：true
字符串是否是Math类的实例：false
字符串是否是Comparable接口的实例：true
类型转换事例：
将子类dag赋值给基类m，可以实现，而将基类赋值给d需要进行强制类型转换，两个子类之间不能进行转换，m已经是Dog类，不能再被强制转换为Cat类
五、变态的类
输出：
Parent.printValue(),myValue=100
Child.printValue(),myValue=200
Child.printValue(),myValue=200
101
Child.printValue(),myValue=200
Child.printValue(),myValue=201
前两个输出没问题，将子类赋值给基类对象，基类对象指向子类对象，调用的是子类的方法，故而输出第三条，
六、多态
输出：
我不吃肉谁敢吃肉！
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我什么都吃，尤其喜欢香蕉。
我要减肥，所以每天只吃一点大米。
我要减肥，所以每天只吃一点大米。
我要减肥，所以每天只吃一点大米。
我要减肥，所以每天只吃一点大米。
我要减肥，所以每天只吃一点大米。
通过定义一个抽象类anmial，来控制所以动物吃的功能，通过vector这个可变长数组，来控制动物的增减，最终实现当再加入其他不同的动物时，用较少的修改来完成动物的添加。
除了可以用抽象类来实现，还可以使用接口的形式来实现
抽象类与抽象方法
抽象类的三种方法：
抽象类不能用来创建对象，一般用他来引用子类的对象
接口：
接口的使用：
接口的扩充：
接口与抽象类的区别：
RDD, 全称为 Resilient Distributed Datasets, 是一个容错的, 并行的数据结构, 可以让用户显式地将数据存储到磁盘和内存中, 并能控制数据的分区.
同时, RDD 还提供了一组丰富的操作来操作这些数据. 在这些操作中, 诸如 map, flatMap, filter 等转换操作实现了 Monad 模式, 很好地契合了 Scala 的集合操作. 除此之外, RDD 还提供了诸如 join, groupBy, reduceByKey 等更为方便的操作, 以支持常见的数据运算.
- RDD 是一个编程模型
- RDD 允许用户显式的指定数据存放在内存或者磁盘
- RDD 是分布式的, 用户可以控制 RDD 的分区
- RDD 是一个编程模型
- RDD 提供了丰富的操作
- RDD 提供了 map, flatMap, filter 等操作符, 用以实现 Monad 模式
- RDD 提供了 reduceByKey, groupByKey 等操作符, 用以操作 Key-Value 型数据
- RDD 提供了 max, min, mean 等操作符, 用以操作数字型的数据
- RDD 是混合型的编程模型, 可以支持迭代计算, 关系查询, MapReduce, 流计算
- RDD 是只读的
- RDD 之间有依赖关系, 根据执行操作的操作符的不同, 依赖关系可以分为宽依赖和窄依赖
简略的说, RDD 有三种创建方式
- RDD 可以通过本地集合直接创建
- RDD 也可以通过读取外部数据集来创建
- RDD 也可以通过其它的 RDD 衍生而来
通过本地集合直接创建 RDD
通过读取外部文件创建 RDD
通过其它的 RDD 衍生新的 RDD
作用
把 RDD 中的数据 一对一 的转为另一种形式，Map是一对一
作用
FlatMap 算子和 Map 算子类似, 但是 FlatMap 是一对多，flatMap 其实是两个操作, 是 , 也就是先转换, 后把转换而来的 List 展开
作用
首先按照 Key 分组, 接下来把整组的 Value 计算出一个聚合值, 这个操作非常类似于 MapReduce 中的 Reduce
参数
func → 执行数据处理的函数, 传入两个参数, 一个是当前值, 一个是局部汇总, 这个函数需要有一个输出, 输出就是这个 Key 的汇总结果，并进行更新
注意点
- ReduceByKey 只能作用于 Key-Value 型数据, Key-Value 型数据在当前语境中特指 Tuple2
- ReduceByKey 是一个需要 Shuffled 的操作
- 和其它的 Shuffled 相比, ReduceByKey是高效的, 因为类似 MapReduce 的, 在 Map 端有一个 Cominer, 这样 I/O 的数据便会减少
总结
- map 和 flatMap 算子都是转换, 只是 flatMap 在转换过后会再执行展开, 所以 map 是一对一, flatMap 是一对多
- reduceByKey 类似 MapReduce 中的 Reduce
import requests
from bs4 import BeautifulSoup
from lxml import etree
headers={'user-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36'}#创建头部信息
pom_list=[]
k=1
for i in range(1,1000):
url='https://www.xungushici.com/shicis/cd-yuan-p-'+str(i)
r=requests.get(url,headers=headers)
content=r.content.decode('utf-8')
soup=BeautifulSoup(content, 'html.parser')
hed=soup.find('div',class_='col col-sm-12 col-lg-9')
list=hed.find_all('div',class_="card mt-3")
# print(len(list))
for it in list:
content={}
#1.1获取单页所有诗集
href=https://blog.51cto.com/u_14824425/it.find('h4',class_='card-title').a['href']
real_href='https://www.xungushici.com'+href
title=it.find('h4',class_='card-title').a.text
print(title)
#2.1爬取诗词
r2=requests.get(real_href, headers=headers)
content2=r2.content.decode('utf-8')
soup2=BeautifulSoup(content2, 'html.parser')
zhu=""
if soup2.find('div',class_='card mt-3')==[]:
zhu="无"
content['title']=title
content['zhu']=zhu
pom_list.append(content)
print("第" + str(k) + "个")
k=k + 1
continue
card_div=soup2.find('div',class_='card mt-3')
if card_div==None or card_div.find('div',class_='card-body')==[]:
zhu="无"
content['title']=title
content['zhu']=zhu
pom_list.append(content)
print("第" + str(k) + "个")
k=k + 1
continue
card_body=card_div.find('div',class_='card-body')
p_list=card_body.find_all('p')
flag=1
for it in p_list:
if str(it).find('strong')!=-1 and it.find('strong').text=='注释':
flag=0
continue
if flag==0:
zhu=zhu+str(it)
if len(zhu)==0:
zhu="无"
content['title']=title
content['zhu']=zhu
pom_list.append(content)
print("第"+str(k)+"个")
k=k+1
import xlwt
xl=xlwt.Workbook()
# 调用对象的add_sheet方法
sheet1=xl.add_sheet('sheet1', cell_overwrite_ok=True)
sheet1.write(0,0,"title")
sheet1.write(0,12,'zhu')
for i in range(0,len(pom_list)):
sheet1.write(i+1,0,pom_list[i]['title'])
sheet1.write(i+1, 12, pom_list[i]['zhu'])
xl.save("yuan.xlsx")
# print(pom_list)
