Dieser Artikel ist mein eigenes Memo. Wir würden uns jedoch freuen, wenn Sie uns Ihre Meinungen / Ratschläge zur Verbesserung geben könnten.
Im vorherigen Artikel habe ich verstanden, wie die Bibliothek zum Verarbeiten von Daten im XML-Format verwendet wird. In diesem Artikel erstellen wir eine Wrapper-Klasse für die Verarbeitung von Pubmed-Papierdaten.
Mit der Wrapper-Klasse können Sie grundlegende Informationen wie Pubmed-ID, Doi, Erscheinungsjahr und Titel für jede Artikeldaten extrahieren. Außerdem
Es scheint, dass es in den veröffentlichten Papierdaten häufig nicht enthalten ist, wer der antwortende Autor des Papiers ist, aber wer der antwortende Autor des Papiers ist, ist eine wichtige Information. Gehen Sie daher so sorgfältig wie möglich damit um. ich gehe
Wir werden auch Informationen über Co-First, Co-Last und "Gleichheit" finden können.
Wer der antwortende Autor ist, wird in den Pubmde-Daten nicht ausdrücklich angegeben. Mit anderen Worten, Sie müssen sich die Daten genau ansehen, um festzustellen, wer der antwortende Autor ist. Ich beschloss, wie folgt zu urteilen.
Es gibt zwei Arten von Autoren, eine, die eine Person repräsentiert, und die andere, die eine Forschungsgruppe repräsentiert, aber ich möchte herausfinden können, ob eine bestimmte Person der antwortende Autor des Papiers ist. Ich werde an nichts anderes denken als an "menschlichen Autor".
Beurteilungsfluss: (Wenn nicht jeder Punkt bestätigt werden kann, beurteilen Sie anhand des folgenden Punktes)
Mit anderen Worten, 4 ist ein Fall, in dem es mehrere Autoren gibt, niemand E-Mail-Adressinformationen hat und mehrere Autoren (möglicherweise alle) Zugehörigkeitsinformationen haben. Wenn Sie von der veröffentlichten Seite zur verlinkten Artikelseite springen, ist im Grunde klar, wer der antwortende Autor ist, aber ich werde dies hier nicht verfolgen.
Wenn ich Beschreibung von Pubmeds XML lese, heißt es, dass EqualContrib Y sein sollte, um den gleichen Beitrag anzuzeigen. Mit anderen Worten <Author EqualContrib="Y"> Ein Beispiel wird gegeben.
Als ich es nachgeschlagen habe, schien es ein Beispiel zu geben, bei dem nur ein Autor Equal Contrib = "Y" hat. Zusätzlich zu diesen Problemen gibt es jedoch einige Beispiele, in denen in den Zugehörigkeitsinformationen der gleiche Beitrag erwähnt wird.
<Author>
<AffiliationInfo>
<Affiliation>###Es ist hier auf deine eigene Weise geschrieben###</Affiliation>
</AffiliationInfo>
</Author>
Beispiel:Einschließlich Gleich:
Equal authorship.
Joint last author with equal contributions.
Equal contribution.
Equal contribution as senior author.
A.P. and A.J. are the equal senior authors.
Contribute equal to this work.
Co-first authors with equal contribution.
Equal contributor.
These authors are joint senior authors with equal contribution.
Joint last author with equal contributions.
* Equal contributors.
Beispiel:Gleichermaßen einschließen
These authors contributed equally to this article.
Both authors contributed equally.
These authors contributed equally to this work.
Contributed equally.
These authors contributed equally and are co-first authors.
In einigen Fällen schrieb der Autor, der nichts mit gleichem Beitrag zu tun hat, über Gleichheit. Beispiel 32281472 In einigen Fällen ist "Gleich" im Zugehörigkeitsnamen enthalten. Foundation for Research on Equal Opportunity Social and Health Inequalities Network Pakistan Center for Health Policy and Inequalities Research
Die Beschreibung ist zu umfangreich, um den Inhalt lesen und verarbeiten zu können. Also für jeden Autor
Ich habe beschlossen, es als Liste der Ints zu behalten (ich habe 63.686 Artikel mit beiden Beschreibungen überprüft und keine gefunden, also habe ich beschlossen, es nicht zu haben. Wenn ja, wird es 1 in der Verarbeitung sein). Wir werden diese Unterteilung später zusammen mit den tatsächlich existierenden Mustern diskutieren.
Die folgenden drei Tags für Pubmed-Daten
1.PubmedArticle、 2.Author、 3.Affiliation
Erstellen Sie für das, was ist, eine Klasse, um damit umzugehen. Die Klassennamen sind ** PubmedArticle **, ** PubmedAuthor ** und ** PubmedAffiliation **, und die entsprechenden ElementTree-Objekte werden jeweils gespeichert.
Diese Klassen sind Wrapper-Klassen, die das Element-Objekt intakt halten. Kapseln Sie es für eine einfache Inspektion. Das PubmedArticle-Objekt hat einen Verweis auf das PubmedAuthor-Objekt, und das PubmedAuthor-Objekt hat einen Verweis auf das PubmedAffiliation-Objekt. Der Methodenaufruf sollte diesem Ablauf folgen und nicht rückwärts gehen. Hier beginnt die Beschreibung mit der Downstream-Klasse.
Ich habe die obigen drei Klassen erstellt und verschiedene Methoden wie folgt definiert, aber wie viele Methoden sollte ich überhaupt erstellen?
Wenn der Benutzer mit dem veröffentlichten Datenformat usw. vertraut ist, ist die Wrapper-Klasse zunächst nicht erforderlich. Selbst wenn Sie das veröffentlichte Datenformat oder das Datenmuster überhaupt nicht kennen, können Sie diese Klassen vollständig verwenden. Ich frage mich ein wenig, ob es möglich ist. Dies liegt daran, dass es viele Stellen gibt, an denen die Daten für jeden veröffentlichten Datensatz unterschiedlich geschrieben werden und nicht einheitlich verarbeitet werden können (z. B. das Jahr der Veröffentlichung, und der antwortende Autor ist häufig unklar. , Gleichstellungsinformationen werden auf verschiedene Arten gegeben).
In diesem Fall streben wir meiner Meinung nach eine Klasse an, die für Benutzer geeignet ist, die wissen, wie veröffentlichte Daten aussehen.
Es ist zu beachten, dass ein Autor möglicherweise mehrere Pubmed-Mitgliedschaften hat. Die folgenden Nummern entsprechen den Nummern, die den Methoden im Code zugewiesen sind.
import xml.etree.ElementTree as ET
import re
class PubmedAffiliation():
E_MAIL_PATTERN = re.compile(r'[0-9a-z_./?-]+@([0-9a-z-]+\.)+[0-9a-z-]+')
#1 Initialisierungsmethode
def __init__(self, xmlElement):
self.xml = xmlElement
#2 Enthält Ihre Zugehörigkeit eine E-Mail-Adresse?: bool
#Referenz:Wenn Ihre Zugehörigkeit eine E-Mail-Adresse enthält, können Sie diese als antwortenden Autor betrachten. Beachten Sie jedoch, dass in älterer Literatur Ihre E-Mail-Adresse möglicherweise nicht aufgeführt ist.
def hasAnyMailAddress(self,):
affiliation = self.xml.text
result = self.E_MAIL_PATTERN.search(affiliation)
if result is not None:
return True
return False
#3 Geben Sie die Zugehörigkeitsinformationen als Text zurück: str
def affiliation(self,):
if self.xml is not None:
return self.xml.text
return "-"
#4 Liste mit angegebener Zugehörigkeit(words)Enthält es alle Wörter in: bool
def isAffiliatedTo(self,words):#True, wenn alle enthalten sind
for word in words:
if not word in self.affiliation():
return False
return True
Die folgenden Nummern entsprechen den Nummern, die den Methoden im Code zugewiesen sind.
Die Variable singleCommonAffi, die bei der Initialisierung None festlegt, wird bei der Initialisierung des PubmedArticle-Objekts nach Bedarf festgelegt (abhängig von den pubmed-Daten kann in solchen Fällen nur ein Autor über Zugehörigkeitsinformationen verfügen. Beschlossen, diese Zugehörigkeitsinformationen als eine gemeinsame Zugehörigkeit für alle Autoren zu betrachten.
class PubmedAuthor():
#1 Initialisierungsmethode
def __init__(self, xmlElement):
self.xml = xmlElement
self.singleCommonAffi = None
#2 Ist Ihre E-Mail-Adresse in Ihrer Zugehörigkeit aufgeführt?: bool
def withAnyMailAddress(self,):#Ist es ein antwortender Autor?
for x in self.xml.findall('AffiliationInfo/Affiliation'):#Zugehörigkeit
pubmedAffiliation = PubmedAffiliation(x)
if pubmedAffiliation.hasAnyMailAddress():
return True
return False
#3 gibt den Nachnamen zurück: str
def lastName(self,):
x = self.xml.find('LastName')
if x is not None:
return x.text
return "-"
#4 gibt den Vornamen zurück: str
def foreName(self,):
x = self.xml.find('ForeName')
if x is not None:
return x.text
return "-"
#5 Initialen zurückgeben: str
def initials(self,):
x = self.xml.find('Initials')
if x is not None:
return x.text
return "-"
#6 Zugehörigkeit zu diesem Autor(PubmedAffiliation-Objekt)Liste mit allen: list
def affiliations(self,):
x = []
for y in self.xml.findall('AffiliationInfo/Affiliation'):#Zugehörigkeit
x.append(PubmedAffiliation(y))
return x
#7 Enthalten die Zugehörigkeitsinformationen alle in der Liste angegebenen Wörter?: bool
def isAffiliatedTo(self,words):
for x in self.xml.findall('AffiliationInfo/Affiliation'):#Zugehörigkeit
pubmedAffiliation = PubmedAffiliation(x)
if pubmedAffiliation.isAffiliatedTo(words):
return True
#Suchen Sie ohne singleCommonAffi nicht weiter
if self.singleCommonAffi is None
return False
#Informieren Sie sich über singleCommonAffi. True, wenn alle angegebenen Wörter vorhanden sind
for word in words:
if not word in self.singleCommonAffi:
return False
return True
Bei der Initialisierung empfängt es ein xmlElement-Objekt und untersucht die folgenden Elemente:
Es hat eine große Anzahl von Methoden. Die Nummer entspricht der Nummer, die der Methode im Code zugewiesen ist.
class PubmedArticle():
#0 Initialisierungsmethode
def __init__(self, xmlElement):
self.xml = xmlElement
self.humanAuthors = []
self.corespondingAuthors = []
self.collectiveNames = [] #In einigen Fällen wird der Gruppenname als Autor angegeben. nicht-human author
self.singleCommonAffi = None #
self.equalityStatements = [] #Beschreibung der Gleichheit
self.authorStates = []
#authorStates ist für jeden humanAuthor
# 0:Keine Beschreibung
# 1: EqualContrib =Es gibt eine Beschreibung von Y.
# 2:Es gibt eine Beschreibung in Bezug auf Qualität in der Zugehörigkeit.
#Es sei 0, 1 und 2 für jeden Autor.
#In Anbetracht des Autors als Ganzes gibt es mehrere Muster
#Muster 1:Alle 1....Jeder co-zuerst bei co-last
#Muster 2:2 oder 3 von vorne ist 1....co-1st
#Muster 3:Zwei von hinten sind 1.....co-last
#Muster 4:Der erste ist 2...Qualität hat etwas zu bieten. Ich weiß nicht, ob ich es lesen muss. Diese Beschreibung wird in QualityStatements beibehalten.
#Muster 5:Andere
#Sammle menschliche Autoren.
for x in self.xml.findall('MedlineCitation/Article/AuthorList/Author'):
pubmedAuthor = PubmedAuthor(x)
if x.find('CollectiveName') is not None:#<Author>Es gibt Fälle, in denen der Gruppenname geschrieben wird. Nehmen Sie es nicht in den Autor auf, sondern verwalten Sie es separat.
self.collectiveNames.append(pubmedAuthor)
else :
self.humanAuthors.append(pubmedAuthor)
#Sammeln Sie entsprechende Autoren.(Wenn es nur einen Autor mit Zugehörigkeitsinformationen gibt, überprüfen Sie diese Zugehörigkeit.)。
if len(self.humanAuthors) == 1:#Wenn es nur einen Autor gibt. Diese Person ist ein antwortender Autor.
self.corespondingAuthors.append(self.humanAuthors[0])
else:
for author in self.humanAuthors:
if author.withAnyMailAddress():#Korrespondierender Autor, wenn die E-Mail-Adresse im Anhang angegeben ist
self.corespondingAuthors.append(author)
if len(self.corespondingAuthors) == 0:
pubmedAffiliations = []
humanAuthorsWithAffiliation =[]
for author in self.humanAuthors:
x = author.xml.find('AffiliationInfo/Affiliation')
if x is not None:#Es gibt Zugehörigkeitsinformationen
humanAuthorsWithAffiliation.append(author)
pubmedAffiliations.append(PubmedAffiliation(x))
if (len(humanAuthorsWithAffiliation) == 1):
self.corespondingAuthors.append(humanAuthorsWithAffiliation[0])
self.singleCommonAffi = pubmedAffiliations[0]
#Geben Sie allen Autoren diese Informationen
for author in self.humanAuthors:
author.singleCommonAffi = self.singleCommonAffi
#In der Literatur co-zuerst oder co-Informationen zum letzten(Informationen zur Gleichstellung)Bestimmen Sie, ob enthalten ist
for author in self.humanAuthors:
state = 0
if 'EqualContrib' in author.xml.attrib:
if author.xml.attrib['EqualContrib'] == 'Y':
state = 1
else :
for x in author.xml.findall('AffiliationInfo/Affiliation'):
if ' equal ' in x.text or 'Equal ' in x.text or ' equally ' in x.text or 'Equally ' in x.text:
state = 2
self.equalityStatements.append(x.text)
break
self.authorStates.append(state)
#1 Gibt Informationen zur Mitautorschaft zurück.
def coauthorshipInfo(self,):
if all(map(lambda x: x == 1,self.authorStates)):#Alle 1
return "All authors are equal contributors."
if any(map(lambda x: x == 2,self.authorStates)):#Mindestens eins ist 2
return "Specific descriptions on co-authorship."
if self.authorStates[0] == 1 and self.authorStates[-1] == 1:#1 am Anfang und 1 am Ende
return "co-first and co-last authorships are described."
if self.authorStates[0] == 1:#Erstens ist 1
count = 0
for x in self.authorStates:
if x == 1:
count += 1
else:
break
return "co-first authorship is described. " + str(count) + " co-first authors"
if self.authorStates[-1] == 1:#Der letzte ist 1
count = 0
for x in reversed(self.authorStates):
if x == 1:
count += 1
else:
break
return "co-last authorship is described." + str(count) + " co-last authors"
return None
#2 Bewertung oder nicht:Bool-Wert
def isReview(self,):
for x in self.xml.findall('MedlineCitation/Article/PublicationTypeList/PublicationType'):
if (x.text == 'Review'):
return True
return False
#3 Ob es sich um einen korrigierten Artikel handelt:Bool-Wert
def isErratum(self,):
for x in self.xml.findall('MedlineCitation/Article/PublicationTypeList/PublicationType'):
if (x.text == 'Published Erratum'):
return True
return False
#4 Veröffentlichungstyp
def PublicationType(self,):
for x in self.xml.findall('MedlineCitation/Article/PublicationTypeList/PublicationType'):
if x.text is not None:
return x.text
return "-"
#5 Dokumentenkennung(doi): str
def doi(self,):
for x in self.xml.findall('MedlineCitation/Article/ELocationID'):
if(x.get('EIdType') == 'doi'):
return x.text
return "-"
#6 pubmed id(pmid): str
def pmid(self,):
element = self.xml.find('MedlineCitation/PMID')
if element is not None:
return element.text
else:
return "-"
#7 Titel: str
def title(self,):
element = self.xml.find('MedlineCitation/Article/ArticleTitle')
if element is not None:
return element.text
else:
return "-"
#8 Journalname: str
def journal(self,):
element = self.xml.find('MedlineCitation/Article/Journal/Title')
if element is not None:
return element.text
else:
return "-"
#9 Erscheinungsjahr: str
#Referenz: <MedlineDate>Zu"2019 Mar - Apr"Es gibt einen Fall, in dem es geschrieben steht.
#Referenz: <MedlineDate>Zu"2012-2013"Es gibt einen Fall, in dem es geschrieben steht.
def year(self,flag="all"):
element = self.xml.find('MedlineCitation/Article/Journal/JournalIssue/PubDate/Year')
if element is not None:
return element.text
else:
element = self.xml.find('MedlineCitation/Article/Journal/JournalIssue/PubDate/MedlineDate')
if element is not None:
if flag == "all":#Gibt standardmäßig die gesamte Zeichenfolge zurück
return element.text
else:#Andernfalls geben Sie das erste 4-stellige Jahr zurück
m = re.search('(\d{4})',element.text)
if m is not None:
return m.group(0)
else:
return "0"
return "0"
#10 Erscheinungsmonat: str
def month(self,):
element = self.xml.find('MedlineCitation/Article/Journal/JournalIssue/PubDate/Month')
if element is not None:
return element.text
else:
element = self.xml.find('MedlineCitation/Article/Journal/JournalIssue/PubDate/MedlineDate')
if element is not None:
return element.text.split(' ')[1]
return "-"
#11 Beschreibungssprache
def language(self,):
element = self.xml.find('MedlineCitation/Article/Language')
if element is not None:
return element.text
else:
return "-"
#################################################################################
##########Name des Autors(Taple)Kontaktiere uns unter.
#################################################################################
#Finden Sie heraus, welche Nummer der Autor ist(0 wenn nicht der Autor):int。
#12 Abfrage ist ein Tapple von Vorname und Nachname
def positionInAuthors(self,query):#Wenn es der 1. Autor ist, ist der Rückgabewert 1(Nicht 0).. Abfrage ist ein Taple(ForeName, LastName)
for x in range( len(self.humanAuthors) ):
if self.humanAuthors[x].foreName() == query[0] and self.humanAuthors[x].lastName() == query[1]:
return x + 1
if self.humanAuthors[x].initials() == query[0] and self.humanAuthors[x].lastName() == query[1]:
return x + 1
return 0
#13 Autoren werden in die angegebene Autorenliste aufgenommen oder zurückgegeben: bool
#Die Liste der angegebenen Autoren ist beispielsweise eine Liste der antwortenden Autoren.
def isAuthorIn(self,query,authors):#Name_Gibt zurück, ob der Nachname in den angegebenen Autoren enthalten ist. Abfrage ist ein Taple
for author in authors:
if ( author.foreName() == query[0] and author.lastName() == query[1]):
return True
if ( author.initials() == query[0] and author.lastName() == query[1]):
return True
return False
#14 Überprüfen Sie, ob der im Taple angegebene Autor der Autor ist: bool
def isAuthor(self,query):
for author in self.humanAuthors:
if author.foreName == query[0] and author.lastName == query[1]:
return True
if author.initials == query[0] and author.lastName == query[1]:
return True
return False
#15 Finden Sie heraus, ob der antwortende Autor bekannt ist: bool
def isCorrespondingAuthorDefined(self,):
if len(self.corespondingAuthors) == 0:
return False
else:
return True
#16 Finden Sie heraus, ob der im Tupel angegebene Autor ein antwortender Autor ist: bool
def isCorrespondingAuthor(self,query):
for author in self.corespondingAuthors:
if ( author.foreName() == query[0] and author.lastName() == query[1]):
return True
if ( author.initials() == query[0] and author.lastName() == query[1]):
return True
return False
Lesen wir die Daten. pubmed_result.xml ist eine Datendatei im XML-Format, die von der pubmed-Seite heruntergeladen wurde. Die Datendatei enthält mehrere Pubmed-Datensätze, die wir vollständig lesen und den Elementbaum in der Stammvariablen speichern.
test_data = open("/Users/yoho/Downloads/pubmed_result.xml", "r")
contents = test_data.read()
root = ET.fromstring(contents)
So greifen Sie auf grundlegende Informationen zu:
for pubmedArticleElement in root.findall('PubmedArticle'):
p = PubmedArticle(pubmedArticleElement)#Machen Sie einen Datensatz zu einem PubmedArticle-Objekt
print(
p.pmid(),# pubmed id
p.doi(),# doi (Dokumentkennung)
p.year(flag=1),#Erscheinungsjahr. Nur Jahresinformationen. Flagge für alle= "all"
p.month(),#Erscheinungsmonat
p.title(),#Papiertitel
p.language(),#Sprache
p.PublicationType(),#Veröffentlichungstyp
sep = "\t",end="\n")
So greifen Sie auf andere als grundlegende Informationen zu:
for pubmedArticleElement in root.findall('PubmedArticle'):
p = PubmedArticle(pubmedArticleElement)#Machen Sie einen Datensatz zu einem PubmedArticle-Objekt
#Anzahl der menschlichen Autoren
print (str(p.numberOfAuthors()))
#Zugriff auf den Namen des Autors
for x in p.humanAuthors:
print(
x.foreName(), # First Name
x.lastName(), # Last Name
sep="\t",end="\t")
print("")
#Finden Sie heraus, ob der antwortende Autor identifiziert wurde
if len(p.corespondingAuthors) != 0:
print("Der entsprechende Autor kann den veröffentlichten Informationen entnommen werden",end="\t")
else :
print("Die veröffentlichten Informationen geben keinen Aufschluss darüber, wer der antwortende Autor ist",end="\t")
#Zugang zum korrespondierenden Autor
if len(p.corespondingAuthors) == 0:
print("Wer der antwortende Autor ist, ist aus veröffentlichten Informationen nicht bekannt",end="\t")
else:
print("Anzahl der antwortenden Autoren:"+str(len(p.corespondingAuthors)),end="\t")
for x in p.corespondingAuthors:
print(
x.foreName(), # First Name
x.lastName(), # Last Name
sep=" ",end="\t")
#Finden Sie heraus, ob Sie ein antwortender Autor sind, indem Sie im Taple Vor- und Nachnamen angeben
author = ("Taro","Tohoku")
if p.isAuthorIn(author,p.corespondingAuthors):
print(author[0] + " " + author[1] + "Ist der antwortende Autor dieses Papiers.",end="\t")
else :
print(author[0] + " " + author[1] + "Ist nicht der antwortende Autor dieses Artikels.",end="\t")
#Finden Sie heraus, ob Sie der Autor sind, indem Sie im Taple Vor- und Nachnamen angeben
if p.isAuthor(author):
print(author[0] + " " + author[1] + "Ist der Autor dieses Papiers.",end="\t")
else:
print(author[0] + " " + author[1] + "Ist nicht der Autor dieses Artikels.",end="\t")
#Finden Sie heraus, welcher Autor Sie sind, indem Sie im Taple Vor- und Nachnamen angeben
position = p.positionInAuthors(author)
if position != 0:
print(str(position) + "Zweiter Autor",end="\t")
else:
print(author[0] + " " + author[1] + "Ist nicht der Autor",end="\t")
Hier habe ich alle veröffentlichten Daten analysiert, die AIDS im Titel enthalten. Gleichheit finden Sie in der Liste der Ints "authorStates". Die Anzahl der Datensätze beträgt 63.686 (Dateigröße 500 MB).
for pubmedArticleElement in root.findall('PubmedArticle'):
p = PubmedArticle(pubmedArticleElement)
if any(p.authorStates):
print(p.pmid(),end="\t")
print("".join(map(str,p.authorStates)),end="\n")
if p.authorStates[0] == 2:#Wenn es 2 ist, co-Es gibt einige Beschreibungen zur Urheberschaft.
pass #Ausgelassener Druck(" ".join(p.equalityStatements),end="\t")
#Ausgabe
# pumed id co-Beschreibung Stand der Urheberschaft(1 Autor 1 Ziffer)
# 32209633 000000011
# 30914431 110000000000
# 30912750 100
# 30828360 11000000000000
# 30421884 1100
# 30467102 10000
# 30356992 1100000000
# 29563205 1100000011
# 29728344 111111111
# 29588307 110000000000
# 29254269 110000000000
# 27733330 10
# 26990633 200000000
# 26949197 111000000000000
# 26595543 200000000000
# 26825036 20000000000000
# 26691548 20000
# 26397046 01110000
# 26535055 110
# 26544576 2000000000000
# 26173930 110000000011
# 26166108 20000000000
# 26125144 20000
# 25949269 1111111
# 24906111 20000000
# 24401642 200
# 22350831 110000000000000
# 22192455 11000
# 22098625 1110
# 21129197 11
# 20540714 11
Es scheint, dass es verschiedene Fälle gibt, wie Fälle, in denen jeder 1 erhält, Fälle, in denen nur der Anfang 2 ist, Fälle, in denen es 1 für die ersten beiden und die letzten beiden gibt. Ich würde gerne 1 annehmen, weil es gemäß den Regeln geschrieben ist, aber es gibt Fälle, in denen nur der Anfang 1 ist (wer und gleich?), Der Anfang 0 ist und die zweite und dritte Person 1 sind (unzureichende Daten? ) Und so weiter.
Es gibt verschiedene Arten von Beschreibungen für den Fall, dass 2 zugewiesen ist, und Sie können nicht verstehen, was dies bedeutet, es sei denn, Sie lesen die Beschreibung einzeln. Daher habe ich mich entschlossen, "zu bestimmen, um welche Art von Papier es sich handelt, indem ich mich bei Bedarf auf diese Liste von Ints beziehe" und auf die Informationen in 2 im Text zu verweisen.
Es gibt Zeiten, in denen Sie herausfinden möchten, wer schreibt und wie viel von einer Forschungseinrichtung insgesamt. Dies ist ein Fall, in dem eine Forschungseinrichtung in pubmed angegeben ist, eine Suche durchgeführt wird und die erhaltene XML analysiert wird. Erstellen Sie zunächst ein Wörterbuch mit "Tupple of First Name and Last Name" als Schlüssel und "List mit Pubmed Article-Objekten" als Wert.
#Wörterbuch erstellen
authorAndArticle = {}#Wörterbuch
for pubmedArticleElement in root.findall('PubmedArticle'):
p = PubmedArticle(pubmedArticleElement)
for author in p.humanAuthors:
if author.isAffiliatedTo(['Graduate School','Sciences']):
authorFullName = (author.foreName(),author.lastName()) #Verwenden Sie Taple als Schlüssel
if authorFullName in authorAndArticle:#Wenn das Wörterbuch bereits einen Schlüssel hat
authorAndArticle[authorFullName].append(p)
else:#Wenn der Schlüssel noch nicht im Wörterbuch ist
authorAndArticle[authorFullName] = [p]
Gibt Daten für jede Person aus.
for authorFN in authorAndArticle:
pubmedArticles = authorAndArticle[authorFN]
print(authorFN[0] + " " + authorFN[1])
for pma in pubmedArticles:
print(' ',end= '')
#Journalinformationen
print(pma.pmid(), pma.year(), pma.journal(), sep="\t",end='\t')
# co-Urteilsbedingung der Urheberschaft
print(pma.coauthorshipInfo(),end='\t')
# co-Informationen zum Autorschaftsstatus. Am Anfang, damit es in Excel als Zeichenfolge behandelt wird'Hinzufügen
print("'" + "".join(map(str,pma.authorStates)),end="\t")
#Welche Anzahl von Autoren
print(str(pma.positionInAuthors(authorFN)),end='\t')
#Anzahl der Autoren
print(str(len(pma.humanAuthors)),end='\t')
#Finden Sie heraus, ob es der erste Autor ist
if pma.positionInAuthors(authorFN) == 1:
print("First Author",end='\t')
else:
print("____",end='\t')
#Finden Sie heraus, ob es sich um einen antwortenden Autor handelt
if len(pma.corespondingAuthors) == 0:
print("Korrespondierender Autor unbekannt",end="\t")
elif pma.isAuthorIn(authorFN,pma.corespondingAuthors):
if len(pma.corespondingAuthors) == 1:
print("Coresponding author",end="\t")
else:
print("Coresponding author of total " + str(len(pma.corespondingAuthors)) + " coresponding authors",end='\t')
else:
print("",end="\t")
#Finden Sie heraus, ob es der letzte Autor ist.
if pma.positionInAuthors(authorFN) == len(pma.humanAuthors):
print("Last author",end='\t')
else:
print("",end='\t')
print("")
Jetzt ist es möglich, die Daten darüber, wer welche Art von Papier geschrieben hat, von den Daten jedes Papiers in die Daten jeder Person umzuwandeln. Wenn in älteren Artikeln der Vorname des Autors nicht in den Daten enthalten ist oder sich der Name aufgrund einer Heirat usw. ändert, wird er als eine andere Person behandelt. Wenn sie denselben Nachnamen und denselben Namen haben, können sie auch nicht unterschieden werden. In neuen Veröffentlichungen kann ORCID zur Unterscheidung von Personen verwendet werden. Wenn ORCID jedoch nicht rückwirkend den Autoren zugewiesen wird, scheint es sehr schwierig zu sein, die Identität des Autors einheitlich herauszufinden.
Ich habe versucht, verschiedene Dinge zu machen, aber es war schwierig, weil es verschiedene Möglichkeiten gab, veröffentlichte Daten zu schreiben, und sie konnten nicht einheitlich verarbeitet werden. In Bezug auf die Gleichstellung haben wir nur eine Liste erstellt, ob für jeden Autor eine Beschreibung vorhanden ist oder nicht. Der Rest muss also auf der Benutzerseite behandelt werden.
Recommended Posts