13.mongodb之python爬虫

最新推荐文章于 2023-05-25 18:09:36 发布
最新推荐文章于 2023-05-25 18:09:36 发布
阅读量354 收藏
点赞数
分类专栏： Python基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanjianhai/article/details/103667692
版权

mongodb 文档行数据库总结

1. Centos7安装mongodb链接

  • 注意： 这里有个错： https 换成http

2. mongodb常用命令

  • 查看当前数据库 db
  • 查看所有数据库 show dbs / show databases
  • （创建）切换数据库 use db_name
  • 删除当前数据库 db.dropDatabase()
  • 查看所有集合 show collections
  • 删除某个集合 db.collection_name.drop()

3. mongodb数据类型

  • Object ID: 文档ID
    • ObjectID是一个12字节的十六进制数：
    • 前4个字节为当前时间戳
    • 接下来的3个字节为机器ID
    • 接下来的2个字节为MongoDB的服务进程id
    • 最后3个字节是简单的增量值
  • String： 字符串， 最常用， 必须是有效地UTF-8
  • Boolean：存储一个布尔值，true或false
  • Integer： 整数可以使32位或者64位， 这取决于服务器
  • Arrays：数组或列表， 多个值存储到一个键
  • Object： 用于嵌入式的文档， 即一个值为一个文档
  • Null：存储Null值
  • TimeStamp：时间戳， 表示从1970-1-1到现在的总秒数
  • Date： 存储当前日期或者时间的UNIX时间格式

4. 增删改查

  • 插入一条数据 db.test.insert({"name":"xiaofan","age":18})
  • 查询数据 db.test.find()
  • 插入一条数据 db.test.save({"_id":"0001", "name":"xiaofan", "age":98})
  • 更新一条数据
    • db.test.update({"name":"xiaofan"},{"name":"xiaoli"})
    • db.test.update({name:“xiaofan”},{$set:{name:“xiaoma”}})
    • db.test.update({name:“xiaoma”},{KaTeX parse error: Expected 'EOF', got '}' at position 25: …:"xiaoxiaofan"}}̲, {multi:true})…符配合使用才有效
  • 删除数据
    • db.test.remove({name:"xiaoxiaofan"}, {justOne:true}) 删除一条数据
    • db.test.remove({name:“xiaoxiaofan”}) 删除所有满足条件的数据

05. 高级查询

1. 数据查询

  • find({条件文档}) 查询 db.test.find({age:23})
  • findOne({条件文档}) 只返回一条 db.test.findOne({age:23})
  • pretty() 将结果格式化 db.test.find({age:22}).pretty()

2. 比较运算符

  • 等于： 默认等于判断， 没有运算符
  • 小于：$lt
  • 小于等于: $lte
  • 大于：KaTeX parse error: Expected '}', got 'EOF' at end of input: …est.find({age:{gt:22}})
  • 大于等于：$gte
  • 不等于：KaTeX parse error: Expected '}', got 'EOF' at end of input: …est.find({age:{ne:23}})

3. 范围运算符

  • KaTeX parse error: Expected '}', got 'EOF' at end of input: …est.find({age:{in:[22, 23]}})
  • KaTeX parse error: Expected '}', got 'EOF' at end of input: …est.find({age:{nin:[22, 23]}})

4. 逻辑运算符

  • and：在json中写多个条件即可 db.test.find({name:“xiao”,age:22})
  • or: 使用KaTeX parse error: Expected '}', got 'EOF' at end of input: … db.test.find({or:[{name:“xiao”},{age:23}]})

5. 正则表达式

  • 使用 // 或者 $regex编写正则表达式
    • 以…开头 db.test.find({name:/^xiaoxiao/})
    • 以…结尾 db.test.find({name:{ r e g e x : " 24 regex:"24 regex:"24"}})

6. skip和limit

  • skip() 类似于mysql中的offset
  • limit() 类似于mysql中的limit db.test.find().skip(2).limit(2)

7. 自定义查询$where

8. 投影

  • 在查询到的返回结果中，只选择必要的字段， 参数为字段值，值为1显示，不写不显示， _id 默认显示，不过不显示要明确写0
  • db.test.find({age:{$gt:22}},{name:1,age:1,_id:0})
{ "name" : "xiaoxiaofan", "age" : 98 }
{ "name" : "xiao24", "age" : 23 }
{ "name" : "xiao25", "age" : 23 }

9. 排序sort： 用于对结果进行排序 参数为1时为升序， -1时为降序

db.test.find().sort({age:-1})

10. 统计个数和去重

  • 统计：db.test.find({age:{$gte:23}}).count()
  • 去重：db.集合名称.distinct('去重字段',{条件}) db.test.distinct("name",{age:{$gt:22}})

06. mongodb的备份与恢复

  • 备份
    mongodump -d test1 -o ./test1000 （本地备份）

  • 恢复
    mongorestore -d test2000 --dir ./test1000/test1

07. mongodb聚合 aggregate

1. 聚合aggregate是基于数据处理的聚合管道，每个文档通过一个由多个阶段stage组成的管道，可以对每个阶段的管道进行分组、过滤等功能，然后经过一系列的处理， 输出相应的结果。

  • db.集合名称.aggregate({管道：{表达式}})

2. mongodb常用管道

  • $group: 将集合中的文档分组， 可用于统计结果
  • $match: 过滤数据，只输出符合条件的文档
  • $project: 修改输入文档的结构， 如重命名，增加，删除字段， 创建计算结果
  • $sort: 将输入文档排序后输出
  • $limit: 限制聚合管道输出的文档数目
  • $skip：跳过指定数量的文档，返回剩下的文档
  • $unwind: 将数组类型的字段拆分

3. 表达式：处理输入文档并输出

  • 语法：表达式： “$列名”
  • 常用表达式
    • $sum: 计算总和， $sum:1 表示以一倍奇数
    • $avg: 计算平均值
    • $min: 获取最小值
    • $max: 获取最大值
    • $push：在结果文档中插入值到一个数组中
    • $first：根据资源文档的排序获取第一个文档数据
    • $last：根据资源文档的排序获取最后一个文档数据

4. 案例

  • $group分组
db.test.aggregate(
    {$group:{_id: "$age"}}
)
  • 分组统计每一组内文档个数
db.test.aggregate(
    {$group:{_id: "$age", count:{$sum:1}}}
)
  • $group统计文档的个数，平均年龄，没有年龄的不参与计算
db.test.aggregate(
    {$group:{_id: null, count:{$sum:1}, mean_avg:{$avg:"$age"}}}
)

$group使用的注意点

  • '$group’对应的字典中有几个值， 结果中就有几个值
  • 分组依据需要放到’_id’后面，如果是null，则对全部数据进行计算
  • 取不同的字段的值需要使用 , ′ ,' ,′gender’, ‘$age’

$project使用

db.test.aggregate(
    {$group:{_id:"$age", count:{$sum:1}}},
    {$project:{age: "$_id", count:1, _id:0}}
)

db.test.aggregate(
    {$group:{_id:"$age", count:{$sum:1}}},
    {$project:{age: "$_id", count:"$count", _id:0}}
)

m a t c h 相 当 于 f i n d ， 但 是 在 管 道 中 只 能 使 用 match 相当于find，但是在管道中只能使用 match相当于find，但是在管道中只能使用match

db.test.aggregate(
    {$match:{age:{$gt:22}}}
)

去重

db.test.aggregate({
    $group:{_id:{country:"$country", province:"$province", userid:"$userid"}}
})

去重之后按省份分组统计

db.test.aggregate(
    {$group:{_id:{country:"$country", province:"$province", userid:"$userid"}}},
    {$group:{_id:{country:"$_id.country", province:"$_id.province"}, count:{$sum:1}}}
)

对结果进行格式化（美化）

db.test.aggregate(
    {$group:{_id:{country:"$country", province:"$province", userid:"$userid"}}},
    {$group:{_id:{country:"$_id.country", province:"$_id.province"}, count:{$sum:1}}},
    {$project:{country:"$_id.country", province:"$_id.province", count:1, _id:0}}
)

聚合命令： $unwind的使用

db.test.insert({username:"Alex", "tags":["C#","Java","C++"]})
db.test.aggregate({$match:{username:"Alex"}},{$unwind:"$tags"},{$group:{_id:null, count:{$sum:1}}})
  • $unwind: 属性 preserveNullAndEmptyArrays值为false 表示丢弃属性值为空的文档, 值为true标识保留属性为空的文档
db.test.aggregate({$match:{username:"Alex"}},{$unwind:{path:"$tags",preserveNullAndEmptyArrays:true}},{$group:{_id:null, count:{$sum:1}}})

08. 索引的创建

  • 检测运行时间：db.test1.find({name:“test9999”}).explain(“executionStats”)
  • 查看当前集合的所有索引：db.test1.getIndexes()
  • 在默认情况下索引字段的值是可以相同的
  • 创建索引： db.test1.ensureIndex({name:1})
  • 创建唯一索引（索引的值是唯一的），可以通过这种方式达到去重的目的 db.test1.ensureIndex({name:1},{unique:true})
  • 创建联合索引
  • 删除索引：db.test1.dropIndex({name:1})

09. pymongo操作

from pymongo import MongoClient

client = MongoClient(host="mini3", port=27017)
# test2为数据库名 test1为collection名
collection = client["test2"]["test1"]

ret = collection.find().limit(10)
for i in ret:
    print(i)

10. mongodb案例

  • 爬虫源码，并写入到mongodb当中
import requests
from lxml import etree
import json
import time
from pymongo import MongoClient


class MySpider:
    def __init__(self):
        self.client = MongoClient(host="mini3", port=27017)
        # test2为数据库名 test1为collection名
        self.collection = self.client["db_area"]["c_area"]
        self.base_url = "http://www.stats.gov.cn/tjsj/tjbz/tjyqhdmhcxhfdm/2018/{}"
        self.start_url = self.base_url.format("index.html")
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Linux; Android 5.1.1; Nexus 6 Build/LYZ28E) AppleWebKit/537.36 (KHTML, "
                          "like Gecko) Chrome/63.0.3239.84 Mobile Safari/537.36"}
        self.item = []

    def parse_url(self, url):  # 发送请求，获取响应
        response = requests.get(url, headers=self.headers)
        return response.content.decode("gbk", errors='ignore')

    def run(self):  # 实现主要逻辑
        province_ret_str = self.parse_url(self.start_url)
        province_html = etree.HTML(province_ret_str)
        province_hrefs = province_html.xpath("//tr[@class='provincetr']/td/a")
        # 抓取省份和下一页的链接
        item = []
        for a in province_hrefs:
            province_dict = {}
            province = a.xpath("./text()")[0]
            province_link = a.xpath("./@href")[0]
            province_dict["province_name"] = province
            # province_dict["province_link"] = province_link
            # 爬取市、区相关信息
            city_ret_str = self.parse_url(self.base_url.format(province_link))
            city_html = etree.HTML(city_ret_str)
            city_trs = city_html.xpath("//tr[@class='citytr']")
            city_item = []

            for city_tr in city_trs:
                city_dict = {}

                country_link = city_tr.xpath("./td[1]/a/@href")[0]
                city_code = city_tr.xpath("./td[1]/a/text()")[0]
                city_code = city_code[0:6]
                city_name = city_tr.xpath("./td[2]/a/text()")[0]
                city_dict["city_name"] = city_name
                city_dict["city_code"] = city_code
                # city_dict["link"] = country_link
                # 爬取区县相关信息
                country_ret_str = self.parse_url(self.base_url.format(country_link))
                country_html = etree.HTML(country_ret_str)
                country_trs = country_html.xpath("//tr[@class='countytr']")
                country_item = []

                for country_tr in country_trs:
                    country_dict = {}

                    country_code = country_tr.xpath("./td[1]//text()")[0]
                    country_code = country_code[0:6]
                    country_name = country_tr.xpath("./td[2]//text()")[0]
                    country_dict["country_name"] = country_name
                    country_dict["country_code"] = country_code
                    country_item.append(country_dict)

                city_dict["country"] = country_item

                city_item.append(city_dict)

            province_dict["city"] = city_item
            self.collection.insert(province_dict)
            # item.append(province_dict)
            time.sleep(2)
            print(item)


if __name__ == '__main__':
    mySpider = MySpider()
    mySpider.run()
  • 对mongodb当中的数据进行处理，并写入到excel当中
import xlsxwriter
from pymongo import MongoClient
import copy


def save_to_excel(data_list):
    """
    数据保存到 excel
    :param data_list: 数据列表
    :return:
    """

    workbook = xlsxwriter.Workbook("省份-城市-地区表.xlsx")
    worksheet = workbook.add_worksheet()

    cols = ['id', 'name', 'code']
    for col_index, col in enumerate(cols):
        worksheet.write(1, col_index, col)

    for row_index, data in enumerate(data_list, start=2):
        worksheet.write(row_index, 0, data['id'])
        worksheet.write(row_index, 1, data['name'])
        worksheet.write(row_index, 2, data['code'])

    workbook.close()


client = MongoClient(host="mini3", port=27017)
# test2为数据库名 test1为collection名
collection = client["db_area"]["c_area"]

# ret = collection.aggregate([{"$match": {"province_name": "山西省"}}, {"$limit": 1}, {"$unwind": "$city"},
#                             {"$group": {"_id": {"province": "$province_name", "city": "$city"}}},
#                             {"$project": {"province_name": "$_id.province", "city": "$_id.city", "_id": 0}},
#                             {"$unwind": "$city.country"}, {
#                                 "$project": {"province_name": 1, "city_name": "$city.city_name",
#                                              "city_code": "$city.city_code",
#                                              "country_name": "$city.country.country_name",
#                                              "country_code": "$city.country.country_code"}}])


ret = collection.aggregate([{"$unwind": "$city"},
                            {"$group": {"_id": {"province": "$province_name", "city": "$city"}}},
                            {"$project": {"province_name": "$_id.province", "city": "$_id.city", "_id": 0}},
                            {"$unwind": {"path": "$city.country", "preserveNullAndEmptyArrays": True}}, {
                                "$project": {"province_name": 1, "city_name": "$city.city_name",
                                             "city_code": "$city.city_code",
                                             "country_name": "$city.country.country_name",
                                             "country_code": "$city.country.country_code"}},
                            {"$sort": {"province_name": 1}}])

# for i in ret:
#     print(i)

# 把Python中的字典写入到文件
# with open("my_file_json.json", "w", encoding="utf-8") as f:
#     for i in ret:
#         print(i)
#         f.write(json.dumps(i, ensure_ascii=False, indent=4))

province = ""
city_code = ""
data_list = []
i = 0
for item in ret:
    if province != item["province_name"]:
        i = i + 1
        data_dict = copy.deepcopy({})
        # 省份不同， 写入省份
        data_dict["id"] = i
        data_dict["code"] = None
        data_dict["name"] = item["province_name"]
        data_list.append(data_dict)
        # 写入城市
        # 省份相同, 比较城市
        if city_code != item["city_code"]:
            i = i + 1
            # 城市不同，写入城市
            data_dict = copy.deepcopy({})
            data_dict["id"] = i
            data_dict["name"] = item["city_name"]
            data_dict["code"] = item["city_code"]
            data_list.append(data_dict)
            try:
                i = i + 1
                # 写入地区
                data_dict = copy.deepcopy({})
                data_dict["id"] = i
                data_dict["name"] = item["country_name"]
                data_dict["code"] = item["country_code"]
                data_list.append(data_dict)
            except Exception as e:
                print(e)

        else:
            try:
                i = i + 1
                # 城市相同，写入地区
                data_dict = copy.deepcopy({})
                data_dict["id"] = i
                data_dict["name"] = item["country_name"]
                data_dict["code"] = item["country_code"]
                data_list.append(data_dict)
            except Exception as e:
                print(e)
        city_code = item["city_code"]

    else:
        # 省份相同, 比较城市
        if city_code != item["city_code"]:
            i = i + 1
            data_dict = copy.deepcopy({})
            # 城市不同，写入城市
            data_dict["id"] = i
            data_dict["name"] = item["city_name"]
            data_dict["code"] = item["city_code"]
            data_list.append(data_dict)
            try:
                i = i + 1
                # 写入地区
                data_dict = copy.deepcopy({})
                data_dict["id"] = i
                data_dict["name"] = item["country_name"]
                data_dict["code"] = item["country_code"]
                data_list.append(data_dict)
            except Exception as e:
                print(e)
        else:
            try:
                i = i + 1
                # 城市相同，写入地区
                data_dict = copy.deepcopy({})
                data_dict["id"] = i
                data_dict["name"] = item["country_name"]
                data_dict["code"] = item["country_code"]
                data_list.append(data_dict)
            except Exception as e:
                print(e)

        city_code = item["city_code"]

    province = item["province_name"]
print(data_list)
save_to_excel(data_list)

11. 医院数据的整理

  • 爬取疾控中心数据并且保存到mongodb
import re

import requests
from lxml import etree
from pymongo import MongoClient

# 对应mongodb中数据库名
DB_HOSPITAL = "db_hospital"
# 对应mongodb中collection名
PROVINCE = "heibei"
DISEASE_NAME = "cdc"
TB_HOSPITAL = "t_hospital_{}_{}".format(PROVINCE, DISEASE_NAME)
# 待爬链接
URL = "http://www.hebeicdc.cn/jkjg/1107.jhtml"
# 当前省份
PROVINCE_NAME = "河北省"


class HospitalSpider:
    """疾控中心的爬虫，病保存到mongodb"""

    def __init__(self):
        self.client = MongoClient(host="192.168.1.27", port=27017)
        # db_hospital为数据库名 t_hospital为collection名

        self.collection = self.client[DB_HOSPITAL][TB_HOSPITAL]
        self.start_url = URL
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Linux; Android 5.1.1; Nexus 6 Build/LYZ28E) AppleWebKit/537.36 (KHTML, "
                          "like Gecko) Chrome/63.0.3239.84 Mobile Safari/537.36"}
        self.item = []

    def parse_url(self, url):  # 发送请求，获取响应
        response = requests.get(url, headers=self.headers)
        return response.content.decode()

    def run(self):  # 实现主要逻辑
        hospital_ret_str = self.parse_url(self.start_url)
        hospital_html = etree.HTML(hospital_ret_str)
        tr_elements = hospital_html.xpath("//div[@class='contxt']//tr")
        for tr in tr_elements:
            item_dict = {}
            tds = tr.xpath("./td")

            if len(tds) > 1:
                hospital_name = tr.xpath("./td[1]//text()")
                hospital_name = "".join(hospital_name)
                # 必须拿到全部文本
                other_info = tr.xpath("./td[2]//text()")
                other_info = "".join(other_info)
                ret = re.match(r"地址：(?P<name1>.*).*邮编：(?P<name2>.*)", other_info)
                hospital_address = ret.group(1)
                post_code = ret.group(2)

                item_dict['province_name'] = PROVINCE_NAME
                item_dict['city_name'] = self.city_name

                # 先从地址里面匹配区县
                hospital_address = hospital_address.strip()
                ret = re.match(r"(?P<name1>.*[区|县]).*", hospital_address)
                if ret is not None:
                    item_dict['county_name'] = ret.group(1)
                else:
                    # 从地址里面匹配地级市
                    ret = re.match(r"(?P<name1>.*[市]).*", hospital_address)
                    if ret is not None:
                        item_dict['county_name'] = ret.group(1)
                    else:
                        # 从医院名里面匹配区县
                        ret = re.match(r"(?P<name1>.*[区|县]).*", hospital_name)
                        if ret is not None:
                            item_dict['county_name'] = ret.group(1)
                        else:
                            # 从医院名里面匹配地级市
                            ret = re.match(r"(?P<name1>.*[市]).*", hospital_name)
                            if ret is not None:
                                item_dict['county_name'] = ret.group(1)
                            else:
                                item_dict['county_name'] = "无法识别"

                item_dict['hospital_name'] = hospital_name.strip()
                item_dict['hospital_address'] = hospital_address
                item_dict['post_code'] = post_code.strip()
                item_dict['alias_name'] = ""
                item_dict['organization_type'] = ""
                item_dict['note'] = ""

                print(item_dict)
                self.collection.insert(item_dict)


            else:
                self.city_name = tr.xpath("./td[1]//text()")[0].strip()


if __name__ == '__main__':
    hospitalSpider = HospitalSpider()
    hospitalSpider.run()
  • 导出mongodb疾控数据到excel
import xlsxwriter
from pymongo import MongoClient

# 对应mongodb中数据库名
DB_HOSPITAL = "db_hospital"
# 对应mongodb中collection名
PROVINCE = "heibei"
DISEASE_NAME = "cdc"
TB_HOSPITAL = "t_hospital_{}_{}".format(PROVINCE, DISEASE_NAME)
EXCEL_NAME = "河北省省、市、县（区）疾控机构 .xlsx"


def save_to_excel(title, data_list):
    """
    数据保存到 excel
    :param data_list: 数据列表
    :return:
    """

    workbook = xlsxwriter.Workbook(title)
    worksheet = workbook.add_worksheet()

    cols = ['province_name', 'city_name', 'county_name', 'hospital_name', 'hospital_address','alias_name', 'organization_type', 'note']
    for col_index, col in enumerate(cols):
        worksheet.write(1, col_index, col)

    for row_index, data in enumerate(data_list, start=2):
        worksheet.write(row_index, 0, data['province_name'])
        worksheet.write(row_index, 1, data['city_name'])
        worksheet.write(row_index, 2, data['county_name'])
        worksheet.write(row_index, 3, data['hospital_name'])
        worksheet.write(row_index, 4, data['hospital_address'])
        if data['alias_name'] is None:
            data['alias_name'] = ""
        worksheet.write(row_index, 5, data['alias_name'])
        if data['organization_type'] is None:
            data['organization_type'] = ""
        worksheet.write(row_index, 6, data['organization_type'])
        if data['note'] is None:
            data['note'] = ""
        worksheet.write(row_index, 7, data['note'])

    workbook.close()


if __name__ == '__main__':
    """导出mongodb中的疾控数据到excel"""
    client = MongoClient(host="192.168.1.27", port=27017)
    collection = client[DB_HOSPITAL][TB_HOSPITAL]
    ret = collection.aggregate(
        [{"$group": {
            "_id": {"province_name": "$province_name", "city_name": "$city_name", "county_name": "$county_name",
                    "hospital_name": "$hospital_name","hospital_address":"$hospital_address" ,"alias_name": "$alias_name",
                    "organization_type": "$organization_type", "note": "$note"}}},
            {"$project": {"province_name": "$_id.province_name", "city_name": "$_id.city_name",
                          "county_name": "$_id.county_name", "hospital_name": "$_id.hospital_name","hospital_address":"$_id.hospital_address",
                          "alias_name": "$_id.alias_name", "organization_type": "$_id.organization_type",
                          "note": "$_id.note",
                          "_id": 0}},
            {"$sort": {"province_name": 1, "city_name": 1, "country_name": 1}}
        ])

    data_list = []
    for item in ret:
        print(item)
        data_list.append(item)
    save_to_excel(EXCEL_NAME, data_list)
  • 所有excel入mongodb
import os

import xlrd
from pymongo import MongoClient

count = 0

# 对应mongodb中数据库名
DB_HOSPITAL = "db_hospital"
# 对应mongodb中collection名
PROVINCE = "heibei"
DISEASE_NAME = "total"
TB_HOSPITAL = "t_hospital_{}_{}".format(PROVINCE, DISEASE_NAME)


def save_data_2_mongo(filename, collection):
    global count
    # 链接：https://www.cnblogs.com/nancyzhu/p/8401552.html
    # 只能读不能写,打开一个excel
    book = xlrd.open_workbook(filename)
    # 根据顺序获取sheet
    sheet = book.sheet_by_index(0)
    # 根据sheet页名字获取sheet
    # sheet = book.sheet_by_name(sheet_name)
    print("列数： " , sheet.ncols)
    for row in range(sheet.nrows):
        if row < 2:
            continue
        count += 1
        item_dict = {}
        for index, col in enumerate(range(sheet.ncols)):
            if index == 0:
                item_dict['province_name'] = sheet.cell(row, col).value
            elif index == 1:
                item_dict['city_name'] = sheet.cell(row, col).value
            elif index == 2:
                item_dict['county_name'] = sheet.cell(row, col).value
            elif index == 3:
                item_dict['hospital_name'] = sheet.cell(row, col).value
            elif index == 4:
                item_dict['alias_name'] = sheet.cell(row, col).value
            elif index == 5:
                item_dict['organization_type'] = sheet.cell(row, col).value
            elif index == 6:
                item_dict['note'] = sheet.cell(row, col).value
        collection.insert(item_dict)


if __name__ == '__main__':
    """所有excel入mongodb"""
    # 读取excel 保存到mongodb
    client = MongoClient(host="192.168.1.27", port=27017)
    collection = client[DB_HOSPITAL][TB_HOSPITAL]
    directory = r"C:\Users\59404\Desktop\医院数据2019"

    filenames = os.listdir(directory)
    print(filenames)
    for filename in filenames:
        filename = directory + "/" + filename
        save_data_2_mongo(filename, collection)

    print(count)
越奋斗，越幸运
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MongoDB
享你所想
04-24 767
如果不取消勾选，会自动安装一个软件：用来管理此数据库的程序，当由于是从国外网站下载程序，速度会很慢，为避免安装过程中出现问题，我们就取消勾选。如果age对应的值是字符串类型的，也能筛选出来，而db.demo1.find({age:{$gt:19}})这种方法就筛选不出来。运行之后可以看到光标一直在闪，是因为想要插入的数据太多，程序一直在运行中，一段时间之后就会运行完成。映射：返回指定字段，如果为1 返回该字段，_id列默认显示。不⼿动创建表(当前没有这个表，插⼊⼀条数据，表⾃动创建)
python_爬虫 11 MongoDB数据库
qq_30346413的博客
06-05 329
目录 一、在windows 安装 mongodb 二、mongodb 概念介绍 三、mongodb 三元素 四、mongodb 操纵命令 五、python 操作 mongodb 一、在windows 安装 mongodb 1、从服务器下载 mongodb 安装包，这里是的是 zip 的安装包，下载链接：mongodb-windows-x86_64-4.4.6.zip 2、下载之后在文件夹下创建data 文件夹，再进入到解压文件夹下的 bin 文件夹，目录结构如下 3、...
爬虫 第七讲 MongoDB
热门推荐
yangyusir的博客
04-29 5万+
爬虫 第七讲 MongoDB MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。它支持的数据结构非常松散，因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引 SQL和NoSQL的主要区别 • 在SQL中层级关系:数据库->表->数据 • 在NoSQL中是:数据库->集合->数据 Mongo
Python------python爬虫数据导入MongoDB数据库
COCOLI_BK的博客
09-17 4164
开发前环境配置: Pycharm开发工具下载: Python下载: 链接：https://pan.baidu.com/s/19QWYN91vzJPhaxVEEgx64A 提取码：nbls 64位系统的安装这个!!! MongoDB下载: 链接：https://pan.baidu.com/s/1N1TrhoRDgqTmgQlrY6CUXg 提取码：5210 1. 在根目录中创建mongo.conf文件:复制以下内容 dbpath=E:\mongodb\data #数据库路径...
Python爬虫之使用MongoDB存储数据
naer_chongya的博客
05-25 1805
MongoDB是一种基于文档的（Document-Oriented）NoSQL数据库，它设计简单、易于使用，适用于大多数应用程序开发需求。与传统的关系型数据库不同，MongoDB不需要一个明确定义的模式来存储数据，这意味着可以轻松存储包含不同类型和结构的数据。在Python中使用MongoDB存储数据是非常简单的，Python中有很多优秀的MongoDB驱动库可以选择，本文将介绍如何使用pymongo驱动库来实现数据存储。
Python + MongoDB开发的百度云爬虫.zip
最新发布
04-18
Python + MongoDB开发的百度云爬虫.zipPython + MongoDB开发的百度云爬虫.zipPython + MongoDB开发的百度云爬虫.zipPython + MongoDB开发的百度云爬虫.zipPython + MongoDB开发的百度云爬虫.zipPython + MongoDB开发...
python爬虫用mongodb的理由
12-17
python爬虫用mongodb的原因： 1、文档结构的存储方式 简单讲就是可以直接存json,list 2、不要事先定义”表”,随时可以创建 3、“表”中的数据长度可以不一样 也就是第一条记录有10个值，第二条记录不要规定也要10个...
python爬虫数据保存到mongoDB的实例方法
09-08
在本篇文章里小编给大家整理的是一篇关于python爬虫数据保存到mongoDB的实例方法，有需要的朋友们可以参考下。
python爬虫，Scrapy抓手机App数据并存入MongoDB（今日头条）
01-17
python爬虫，Scrapy抓手机App数据并存入MongoDB（今日头条）python爬虫，Scrapy抓手机App数据并存入MongoDB（今日头条）python爬虫，Scrapy抓手机App数据并存入MongoDB（今日头条）python爬虫，Scrapy抓手机App数据...
Python爬虫数据写入MongoDB
ju7ran的博客
05-13 2133
除了插入数据，MongoDB还支持更新、查询和删除等操作，我们可以根据不同的业务需求选择相应的方法进行操作。总之，Python和MongoDB的结合可以帮助我们实现高效的数据爬取和存储，为数据分析和挖掘提供了良好的基础。上述代码中，我们定义了一个包含三个书籍信息的列表，使用insert_many()方法将这些书籍信息批量插入到MongoDB中，并打印出新插入数据的ID。在上述代码中，我们使用insert_one()方法将字典类型的数据插入到MongoDB中，并打印出新插入的数据的ID。
豆瓣电影信息Python爬虫存入MongoDB.一分钟1W条数据
01-23
Python关于豆瓣电影信息的爬虫,抓起1w条电影数据只要一分钟左右,
用python爬取网页并用mongodb保存.docx
12-14
mongodb的应用之用python爬取网页内容并用mongodb保存. 由于mongodb是文档型数据库，区别于传统的数据库，它是用来管理文档的。在传统的数据库中，信息被分割成离散的数据段，而在文档数据库中，文档是处理信息的基本单位。一个文档可以很长、很复杂、可以无结构，与字处理文档类似。一个文档相当于关系数据库中的一条记录。 文档存储一般用类似json的格式存储，存储的内容是文档型的。这样也就有机会对某些字段建立索引，实现关系数据库的某些功能。 MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。
python实现爬虫数据存到 MongoDB
12-16
在以上两篇文章中已经介绍到了 Python 爬虫和 MongoDB ， 那么下面我就将爬虫爬下来的数据存到 MongoDB 中去，首先来介绍一下我们将要爬取的网站, readfree 网站，这个网站非常的好，我们只需要每天签到就可以免费下载三本书，良心网站，下面我就将该网站上的每日推荐书籍爬下来。 利用上面几篇文章介绍的方法，我们很容易的就可以在网页的源代码中寻找到书籍的姓名和书籍作者的信息。 找到之后我们复制 XPath ，然后进行提取即可。源代码如下所示 # coding=utf-8 import re import requests from lxml import etree im
Python爬虫从0到1(第九天)——Python与MongoDB
weixin_43770993的博客
05-01 232
在前面的文章中我们已经学习到了如何从网站中获取到数据，接下来我们就要开始学习如何将我们从网站中获取到的数据进行保存，存储的媒介是分为很多种的，例如:文本文档、excel、json、数据库等；MongoDB文档的数据结构和json基本是一样的，所有存储在集合中的数据都是BSON格式。（1）键值对存储（key-value）：代表软件Redis，它的优点能够进行数据的快速查询，而缺点是需要存储数据之间的关系。注意，再查看时，并不会显示出刚刚创建的数据库，如果要显示出来，我们还需要在里面插入一条数据之后才会显示。
python-pymongo-常用查询方法含聚合.
叽里呱啦的一大摊，人生太艰难.
04-13 4291
普通查询 按照所需字段排序. db_set.find().sort("field_name ",pymongo.ASCENDING) --升序 db_set.find().sort("field_name ",pymongo.DESCENDING) --降序 查询数据库表的全部内容 # 第一种： db_set.find({}) #第二种： db_set.find() 精确查询 db_set.find({“field_name”:”value”}) db_set.find({“field_nam
pymongo操作MongoDB数据库
you are sherlocked by me!
06-29 2031
上次我们在将MongoDB数据库基础的时候讲解了使用MongoDB shell来操作MongoDB数据库这次我们来讲解PyMongo模块来操作数据库PyMongo简介:     是用Python编写的高性能，对接MongoDB数据库的驱动程序。(PyMongo is a Python distribution containing toolsfor working with MongoDB, an...
Python+MongoDB 爬虫实战
架构设计
03-04 278
工具准备及爬虫搭建 Scrapy(python写成的爬虫框架) 在前一篇 Scrapy爬虫入门里有写到Scrapy的安装和基本使用，他的特点是每个不同的page都自己定制一个不同的Spider，通过 scrapy crawl spidername -o file -t json 的方法运行爬虫程序并且以json形式保存到目标文件里（当然后面 -o -t 两项可以省略）。而且pytho...
Python爬虫之一——环境准备（Python 、MongoDB）
故乡的云
04-23 1108
最近打算尝试下Python爬虫的实现，环境搭建主要涉及到如下几部分：1、Python &amp; Pycharm，因为我本地已经安装了Python 3.6.* 和Pycharm 的社区版，所以忽略这步，另外，网上建议也可以直接安装Anaconda, 可以从清华的镜像下载 https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/ 2、MongoDB...
python爬虫--连接MongoDB 存数据
Qin_xian_shen的博客
10-17 1949
之前做爬虫 爬取贴吧松爱协会的内容是存在txt文件的 这个并不好 所以这一次存在Mongdb 这次是在windows 安在Mongodb里  官网下载  https://www.mongodb.com/download-center?jmp=nav#community 启动： mongod.exe --logpath "c:\data\log\mongodb.log"
python爬虫的mongodb
10-15
Python爬虫可以使用MongoDB作为数据存储的一种方式。MongoDB是一个NoSQL数据库，具有高性能、高可用性和可扩展性等特点，非常适合存储爬虫数据。 在Python中，可以使用pymongo库来连接MongoDB数据库，并进行数据的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值