Seite 1 von 1

String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 16:57
von Tron0070
Hallo Leute, ich komme auch nach langem probieren und suchen nach einer Lösung nicht weiter.
Ich habe in Funktion "seite1" die Variable "url = "www"" diese brauche ich in der Funktion "Seite2" und will diese dann ausgeben.
Kann mir bitte jemand dabei helfen, dass es funktioniert?

Gruß Tron

Code: Alles auswählen

class Anfang():
    def __init__(self, url):
        self.url = url

    def seite1(self, url):
        url = "www"

    def seite2(self, url):
        return url

k = Anfang
print (k.seite2)



#Aktuelle Ausgabe:
<function Anfang.seite2 at 0x7f2774537f80>

#Gewünschte Ausgabe:
www

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 17:25
von mp1337
Hallo,
du rufst die seite1 Methode ja gar nicht auf, also wird die variable url nicht gesetzt. Das ganze Konstrukt scheint irgendwie keinen Sinn zu machen. Seite2 erwartet einen Parameter url den du auch nicht übergibst.

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 18:00
von Tron0070
Hallo mp1337, vielen Dank für Deinen Beitrag. Leider hilft es mir nicht mein Problem zu lösen.

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 18:54
von __blackjack__
@Tron0070: Das Problem ist, das wir nicht so wirklich wissen was Dein Problem ist. Also ausser das Du anscheinend was mit Klassen machen willst bevor Du Funktionen wirklich verstanden hast. Das was Du das Funktionen nennst ist schon einen Schritt weiter, das sind Methoden. Also sollen es vermutlich sein, sind es aber beide nicht, weil die nix mit dem Objekt (`self`) machen, also eigentlich Funktionen sein könnten die nicht in einer Klasse stecken.

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 19:00
von noisefloor
Hallo,

der erste Fehler ist `k = Anfang`. Damit bindest du eine Referenz auf Anfang an k, aber du erzeugst keine Instanz. Dafür fehlen da Klammern.

Der 2. Fehler ist (wahrscheinlich, zumindest im Kontext des beschriebenen) ist `url=www` in der Methode `seite1`. Damit erzeugst du eine _lokale_ Variable im Scope von `seite1` und `url` ist außerhalb der Methode nicht verfügbar.

Beschreib' doch mal, was du _wirklich_ vor hast. Beim gezeigten brauchst du nicht wirklich eine Klasse.

Gruß, noisefloor

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 19:29
von mp1337
Tron0070 hat geschrieben: Donnerstag 7. Mai 2020, 18:00 Hallo mp1337, vielen Dank für Deinen Beitrag. Leider hilft es mir nicht mein Problem zu lösen.
Es wäre schön wenn du uns erklären würdest was du vor hast.
So würde deine Klasse funktionieren,

Code: Alles auswählen

class Anfang():
    def __init__(self, url=""):
        self.url = url

    def seite1(self):
        self.url = "www"

    def seite2(self):
        self.seite1()
        return self.url

k = Anfang()
print(k.seite2())

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 21:00
von Tron0070
Hallo Leute, vielen Dank für Eure Beiträge.
noisefloor hat geschrieben: Donnerstag 7. Mai 2020, 19:00 Beschreib' doch mal, was du _wirklich_ vor hast. Beim gezeigten brauchst du nicht wirklich eine Klasse.
Theoretisch brauche ich keine Klassen, Methoden und Funktionen. Aber ich bin gerade dabei Python zu lernen und bei meinem Projekt wollte ich es damit versuchen.

Bei meinem Projekt baue ich ein Crawler, der für die Filme auf meiner Festplatte die Film Infos liefert. In der ersten URL (Seite1) liegt die Karte zum Film mit der weiterführenden URL. Diese wird an den zweiten Crawler weitergegeben.

Ich habe für Seite1 und Seite2 in verschiedenen Dateien gearbeitet. Einzeln habe dies gut funktioniert. Doch jetzt als ich diese zusammen fügen wollte stieß ich auf Probleme und wollte Seite2 eine neue Methode zuweisen.

@mp1337: Ich werde morgen Mal versuchen mein vorhaben mit Deinem Code umsetzten kann. Vielen Dank.

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Donnerstag 7. Mai 2020, 23:16
von __blackjack__
@Tron0070: Funktionen *brauchst* Du, denn auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Wenn Du also keine Klassen, Methoden und Funktionen schreibst, bleiben nur noch Konstanten. Es kann (selten) sinnvoll sein ein Modul zu haben in dem ausschliesslich Konstanten definiert sind, aber das ist dann kein Programm, weil Konstanten ”tun” ja nichts, das sind einfach nur konstante Werte.

Klassen kann man nur lernen wenn man Klassen auch tatsächlich braucht, denn neben der Syntax ist es auch wichtig zu wissen wann Klassen Sinn machen, und eben auch wann nicht, und dann ist ist die richtige Verwendung von Klassen sie eben auch *nicht* zu verwenden wenn man sie nicht benötigt.

Die Namen lassen zumindest erahnen das hier etwas nicht stimmt, also entweder die Namen, oder eben dass das in einer Klasse steckt. Der Klassenname sollte das Ding oder Konzept beschreiben, das durch Attribute und den Operationen auf diesen Attributen, die in der Klasse zusammengefasst sind, modelliert wird. Was ist ein `Anfang`? Welche Attribute beschreiben den Zustand eines `Anfang`\s? Und welche Operationen gibt es auf einem Anfang die diesen Zustand verändern?

Warum heisst ein Exemplar von `Anfang` dann `k`? Was soll `k` bedeuten?

Methodennamen sind wie Funktionsnamen in der Regel eine Beschreibung der Tätigkeit welche die Methode durchführt. `seite1()` und `seite2()` wären Namen für einen Wert der eine Seite repräsentiert, aber das sind keine Tätigkeiten.

Re: String in einer Funktion1 an die nächste Funktion2 weitergeben

Verfasst: Freitag 8. Mai 2020, 07:49
von Tron0070
Hallo __blackjack__ , danke für Deinen Beitrag.

Ich will soweit wie es geht erst mal versuchen meinen eigenen Weg zu gehen, auch wenn es erst mal der Falsche ist. Wenn was im Code nicht funktioniert und ich lange Zeit dafür brauche das zu fixen, verkleiner ich den code etwas und probiere es weiter. Wenn es dann immer noch nicht läuft wird der code weiter verkleinert, sodass ich nur noch den kleinsten Teil vor mir habe. Das war der Code den ich gepostet hatte. Die Klassen- und Methodenbezeichnung war nur exemplarisch um einen besseren Überblick zu haben.

... Nach weiterm porbieren kommen ich nicht weiter.
Ich habe Teil 1 und 2 in separaten Dateien geschrieben, getestet.
Jetzt beim zusammenfügen sind Probleme auftauchen bei denen ich nicht weiß, wie ich diese bewältigen kann.

Hier habe ich mal meinen kompletten Code. Das Problem ist, dass ich in der Klasse "CrawledItem" die Variable "item_url" aus der Klasse "CrawledArticle" brauche.

Ich hoffe, das ist verständlich von mir beschrieben worden und dass mir jemand dabei helfen kann.

Gruß Tron

Code: Alles auswählen

#!/usr/bin/env python
import sys
import mysql.connector as mc

import requests
from bs4 import BeautifulSoup # sudo pacman -S python-p # sudo pip install beautifulsoup4
from urllib.parse import urljoin

url_start_item = "https://www.themoviedb.org"

url_start="https://www.themoviedb.org/search/movie?query="
url_end="&language=de-DE"


try:
	connection = mc.connect (host = "localhost",
							user = "mysql",
							passwd = "************",
							db = "Video_Database")


	cursor = connection.cursor()
	#cursor.execute("SELECT fi_title, fi_year FROM Video_Database.Movies WHERE `fi_fileID`='1' AND `fi_TMDb_Title` IS NULL")
	cursor.execute("SELECT fi_title, fi_year FROM Video_Database.Movies WHERE `fi_fileID`='1'")

	#cursor.execute("SELECT * FROM Video_Database.Movies")
	print('''Result of "SELECT fi_title, fi_year FROM Video_Database.Movies":''')
	result = cursor.fetchall() 
	
	
	for r in result:
		title=r[0].replace(" ", "%20")
		title2=r[0]
		year=r[1]
		url_full=url_start + title + "%20y:" + str(year) + url_end
		print(title2)
		#print(url_full)
		#continue
		r = requests.get(url_full)
		doc = BeautifulSoup(r.text, "html.parser")

		#####################################################
		#Teil1
		class CrawledArticle():
			def __init__(self, title, title2, id_num, full_url, item_url, content, release, release_year, image1, image2, counter):
				self.title = title
				self.id_num = id_num
				self.full_url = full_url
				self.item_url = item_url
				self.content = content
				self.release = release
				self.image1 = image1
				self.image2 = image2
				self.counter = counter
				self.release_year = release_year
				self.title2 = title2

			def fetch():
				counter = 0
				articles = []
				for card in doc.select(".card"):
					counter += 1

					image  = card.select_one(".image .poster .result img")
					if image is not None:
						image  = image.attrs["data-srcset"].split(",")
						image1 = image[0].replace("1x", "").replace(" ", "")
						image2 = image[1].replace("2x", "").replace(" ", "")
					else:
						image1 = "kein Bild"
						image2 = ""

					content = card.select_one(".overview").text.strip()
					if content == "":
						content = "kein Inhalt"
					title = card.select_one("h2").text
					#release = card.select_one(".release_date").text

					release = card.select_one(".release_date")
					if release is not None:
						release = release.text.strip()
					else:
						release = "k.A"

					release_year = release.split(" ")[2]

					item_url = card.select_one(".result").attrs["href"]
					item_url = url_start_item + item_url
					id_num = item_url.split("/")[4].split("?")[0]
					full_url = url_full

					crawled = CrawledArticle(title, title2, id_num, full_url, item_url, content, release, release_year, image1, image2, counter)
					articles.append(crawled)

				return articles
		################################################################################

		# Teil 2: Item
		class CrawledItem():
			url = "https://www.themoviedb.org/movie/97-tron?language=de-DE"
			r_item = requests.get(url)
			doc = BeautifulSoup(r_item.text, "html.parser")

			def __init__(self, image1, image2, genres_list, act_list):
				self.image1 = image1
				self.image2= image2
				self.genres_list = genres_list
				self.act_list = act_list

			def item_crawler():
				item_list = []
				for card in doc.select(".inner_content"):
					#Bild
					image = card.select_one("#main .content .poster .poster")
					if image is not None:
						image = image.attrs["srcset"].split(",")
						image1 = image[0].replace("1x", "").replace(" ", "")
						image2 = image[1].replace("2x", "").replace(" ", "")
					else:
						image1 = "kein Bild"
						image2 = "kein Bild"

					#Genres
					genres_list = []
					genres = card.select(".genres a")
					genres_num = len(genres)
					genres_count = 0
					for i in range(0, genres_num):
						genres_list.append(genres[i].text)

					#Darsteller
					#i=5
					act_list = []
					act_len = len(card.select(".card .character"))
					#print(act_len)
					for act_num in range(0, act_len):
						#act_num=7
						act_name = card.select(".card p a")[act_num].text
						act_list.append(act_name)




					crawled = CrawledItem(image1, image2, genres_list, act_list)
					item_list.append(crawled)
				return item_list
		################################################################################
		item = CrawledItem.item_crawler()

		for item2 in item:
			print(item2.image1)
			print(item2.image2)
			print(item2.genres_list)
			print(item2.act_list)
			print("Test")



		################################################################################

		articles = CrawledArticle.fetch()

		for article in articles:
			sql_update_query = """UPDATE `Video_Database`.`Movies` SET `fi_TMDb_ID`=%s,`fi_TMDb_Title`=%s WHERE `fi_title`=%s AND `fi_year`=%s"""
			input = (article.id_num,article.title, article.title2, article.release_year)

			cursor.execute(sql_update_query, input)
			#connection.commit()


			sql_update_query = """UPDATE `Video_Database`.`Movies` SET `fi_TMDb_content`=%s WHERE `fi_title`=%s AND `fi_year`=%s AND `fi_fileID`=1"""
			input = (article.content, article.title2, article.release_year)

			cursor.execute(sql_update_query, input)
			connection.commit()

			print("Record Updated successfully ")

			#break


#except mc.Error as e:
    #print("Error %d: %s" % (e.args[0], e.args[1]))
    #sys.exit(1)


except mysql.connector.Error as error:
    print("Failed to update record to database: {}".format(error))



finally:
    if (connection.is_connected()):
        connection.close()
        print("MySQL connection is closed")
#https://www.themoviedb.org/search/movie?query=Der%20Junge%20im%20gestreiften%20Pyjama&language=de-DE


Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Freitag 8. Mai 2020, 10:37
von noisefloor
Hallo,

mal unabhängig von Code an sich, also der Qualität des Codes: das ist strukturell völlig falsch. Es ist falsch, die Klasse _in_ der for-Schleife zu definieren. Das macht man 1x am Beginn des Codes oder - strukturell ggf. besser - in einer eigenen Datei, aus der man dann die Klassen importiert.

Eine Klasse, die nur eine Methode hat ist ein starkes Indiz dafür, dass man gar keine Klasse braucht, weil man das auch mit einer Funktion abbilden kann.
Dadurch, dass die URL auf Klassenebene definiert ist, gilt die URL für _alle_ Instanzen der Klasse. Macht aber keinen Sinn, weil man sich eher einen Instanz pro Film anlegen will.
Du erzeugst nach wie vor keine Instanz der Klasse, sondern rufst direkt eine Methode auf. Bzw. du erzeugst in der Klasse eine Instanz derselbigen - das ist schon ziemlich schräg. Richtiger (hier) wäre: Instanz anlegen, Methode zum befüllen der Attribute ausführen, mit den Attributen arbeiten. Aber, wie gesagt: geht auch mit einer Funktion.

Unter Strich bis du was Klassen angeht, ziemlich auf dem komplett falsch Pfad. Am besten den Code weg werfen, nochmal das Python-Tuturial zu Klassen lassen, sich Gedanken über eine _sinnvolle_ Struktur / Aufteilung machen, neu anfangen.

Gruß, noisefloor

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Freitag 8. Mai 2020, 10:40
von __blackjack__
@Tron0070: Wie kbr zu dem Vorgehen mit dem verkleinern des Codes um den Fehler einzugrenzen bereits schrieb ist das im Grunde die falsche Richtung. Denn das macht viel mehr Arbeit einem grossen Quelltext zu verfassen und *dann* die Fehler zu suchen, als immer kleine, in sich geschlossene Funktionen zu schreiben, und die zu testen, und so einen grossen Quelltext ohne Fehler zu schreiben. Das gelingt natürlich nicht immer, und manchmal muss man dann auch in einer grösseren Quelltextbasis Fehler finden. Aber auch dann ist es von Vorteil wenn der aus einzeln testbaren Funktionen besteht, weil man dann den Fehler leichter eingrenzen kann.

Das kann auch zu einer Motivationsfrage werden. Mal angenommen man macht bei beiden Vorgehensweisen die gleiche Anzahl von Fehlern. Wenn man das Programm Stück für Stück, Funktion für Funktion entwickelt und immer testet, dann trifft man während der Entwicklung auf einen Fehler nach dem anderen, hat aber zwischendurch immer wieder ein (hoffentlich) fehlerfreies Programm, von dem man weiss, das es soweit läuft, weil man ja immer testet. Man sieht einen Fortschritt. Wenn man aber erst ganz viel Code schreibt, und das Programm im Grunde fertig ist, weil für alles was das Programm machen soll der Code schon da ist, und dann erst testet und Fehler sucht, dann hat man eine ganze Weile das Gefühl man tritt auf der Stelle, weil man schon zu 99% am Ziel ist, aber die ganze Zeit für *alle* Fehler in dem letzten 1% drauf geht, man aber nicht das Gefühl hat, das man voran kommt, weil immer wenn man einen Fehler gefixt hat und das Programm laufen lässt, der nächste Fehler sichtbar wird. Das kann sehr demotivierend wirken. Und man ist auch eher geneigt unsaubere Hacks zu schreiben und Fehler nur oberflächlich zu reparieren, nur um endlich das ganze zum laufen zu bringen.

Es kann auch zu unnötiger Arbeit führen, nämlich dann, wenn man alles ”fertig” hat und dann auf einen Fehler stösst, der einem zeigt, dass man etwas grundsätzlich nicht so lösen kann, wie man sich das gedacht hat. Dann muss man manchmal grosse Teile des Quelltextes ändern oder gar komplett neu schreiben. Wenn man während der Entwicklung schon die Fehler in den kleinen Teillösungen sucht und behebt, stösst man auf so ein Problem bevor man Code schreiben kann, der sich auf etwas verlässt, was so nicht funktioniert.

Zum Code: Den aufzuräumen kommt auf jedem Fall einem neu schreiben des gesamten Quelltextes gleich. Da macht es fast keinen Sinn sich über die ”Klassen” zu unterhalten. Da weiss ich fast nicht wo ich anfangen soll. Das sind nicht wirklich Klassen. Klassendefinitionen gehören nicht in eine verschachtelte Ebene, das macht nur selten einen Sinn und wenn dann in einer einfachen Verzweigung aber ganz sicher nicht so tief und in einer Schleife.

Dann haben Deine Klassen gar keine Methoden sondern Funktionen die Du über das Klassenobjekt aufrufst. In seltenen Fällen kann das mal Sinn machen eine Funktion auf einer Klasse zu haben, die weder ein Exemplar dieser Klasse noch die Klasse selbst benötigt, aber trotzdem so eng mit der Klasse gekoppelt ist, dass man sie nicht als eigenständige Funktion schreibt, sondern als `staticmethod()`.

Datenattribute auf Klassen sind in aller Regel Konstanten. Man führt im Klassenkörper keinen Code aus der Webseiten abfragt oder ähnlich drastische Seiteneffekte und Anforderungen an die Umgebung hat.

Und diese falschen ”Klassen” sind Teil von einem riesigen ca. 190 Zeilen langen Codemonster, mit Unmengen an globalen Variablen, das kein Mensch wirklich verstehen kann. Du läufst mit der Entwicklung in die völlig falsche Richtung, triffst bereits auf Probleme die dadurch entstehen, willst aber aber weiter in diese Richtung laufen und fragst uns wie man denn richtig in die falsche Richtung läuft. Das macht keinen Sinn. Wie gesagt, ist das jetzt bereits nichts mehr was man mit kleinen Reparaturen geradebiegen kann.

Fang das am besten noch mal neu an, mit Funktionen. Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Funktionen (und Methoden) bekommen alles was sie ausser Konstanten benötigen als Argument(e) übergeben. Ergebnisse werden mit ``return`` an den Aufrufer zurückgegeben. Eine Funktion löst eine in sich geschlossene Aufgabe mit wenigen Zeilen Code, so dass man jede Funktion für sich leicht lesen und verstehen kann.

Erster sinnvoller Einsatz für Klassen könnte das sein was Du schon so ein bisschen versucht hast: Datenklassen. Also erst einmal nur verschiedene Werte die sinnvoll zusammengehören zu einem Objekt zusammengefasst. Ohne Methoden. Ob man dann Code hat der sinnvoll als Methode zu solchen Daten gehört kann man dann noch sehen.

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Freitag 8. Mai 2020, 14:16
von Tron0070
Hallo __blackjack__ und noisefloor, vielen Dank für Eure Kritik.

Ich werde Euren Rat folgen, noch mal neu anfangen und versuchen es besser zu strukturieren.
Da mein code einzeln für sich funktioniert, dachte ich, ich wäre annähernd auf dem richtigen weg. Natürlich ist das jetzt ein Rückschlag für mich. Aber damit kann ich leben.
Um eine Richtung zu haben, könnte Ihr mir sagen ob ich für meinen code überhaupt Klassen brauche bzw. verwenden sollte?
Ich bin jetzt ein bisschen desorientiert und weiß nicht wie/womit ich beginnen soll. Vielleicht kann mir jemand eine Strukturvorlage geben?

Code: Alles auswählen

Titel und Jahr stehen schon in der Datenbank
Ich gehe zu dem Datensatz in der Datenbank der NULL ist
cursor.execute("SELECT fi_title, fi_year FROM Video_Database.Movies WHERE `fi_file_id`='1' AND `fi_TMDb_id` IS NULL")
Aus diesem Datensatz ziehe ich Titel und Jahr
Titel und Jahr übergebe ich dann an eine Funktion als Argument?

In der Funktion baue ich die URL zusammen die aus Titel und Jahr besteht.
      Mit der URL ziehe ich die Infos aus der Seite.
      Und speicher diese in dem Datensatz ab oder lieber erst mal in eine Variable?
Ist dieser Pseudo-code erst mal der richtige Ansatz? Habt bitte Verständnis falls nicht.

Vielen Dank

Gruß Tron

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Freitag 8. Mai 2020, 15:17
von __blackjack__
@Tron0070: Wenn Du zu Titel und Jahr weitere Infos zu dem Film aus dem Netz ziehen willst, dann mit einer Funktion die genau das macht: Titel und Jahr als Argumente entgegen nehmen, und die Filminformationen als Rückgabewert liefern. Nicht in der Funktion auch gleich wieder in eine Datenbank speichern. Denn sonst kann man die Funktion ja gar nicht ohne eine Datenbank testen. Das holen der Daten zu einem Film aus dem Netz hat ja nichts mit der Datenbank zu tun. Der Funktion ist egal bzw. sollte egal sein wo Titel und Jahr her kommen und auch was mit dem Ergebnis, den weiteren Filmdaten danach passiert.

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Freitag 8. Mai 2020, 16:30
von Tron0070
Hallo __blackjack__ , vielen Dank.

Ich verstehe es so langsam. Ich kenne inzwischen einige Werkzeuge, aber die Struktur macht mir halt noch Probleme.
Hier habe ich mal einen erste Funktion. Ist diese soweit akzeptabel?

Code: Alles auswählen

import requests
from bs4 import BeautifulSoup

def get_info(title, year):
    url_fl = "https://www.themoviedb.org/search/movie?query=" + title + "%20y:" + year + "&language=de-DE"
    req = requests.get(url_fl)
    doc = BeautifulSoup(req.text, "html.parser")
    
    for card in doc.select(".card"):
        #Titel
        title = card.select_one("h2").text

        #ItemURL
        item_url = card.select_one(".result").attrs["href"]

        items = {"Titel": title, "Item_URL": item_url}
        return items


film_info = get_info("Tron", "2010")
   
print(film_info["Titel"])
print(film_info["Item_URL"])


Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Freitag 8. Mai 2020, 19:24
von __blackjack__
@Tron0070: Namen sollten keine kryptischen Abkürzungen enthalten oder sein. `req` ist beispielsweise auch falsch, denn das ist ein `Response`-Objekt. `Request` ist das was man an den Server sendet.

Das Jahr ist doch semantisch eine Zahl und kommt doch so auch aus der Datenbank, das sollte also nicht als Zeichenkette übergeben werden müssen.

Die Kodierung von URL-Parameters sollte man dem `requests`-Modul überlassen und da nicht selbst was mit Zeichenketten zusammenstückeln. Dann braucht man sich auch nicht selbst um so etwas wie Leerzeichen kümmern oder Zeichen wie "&" im Titel.

Die Kommentare ``# Titel`` vor ``title = …`` und ``# ItemURL`` vor ``item_url = …`` machen keinen Sinn.

Bei zwei Werten würde ich noch ein Tupel für den Rückgabewert in Betracht ziehen.

`items` ist als Name falsch, denn das ist ja nur *ein* Element und die ``for``-Schleife ist sinnfrei wenn man die gleich in der ersten Iteration mit einem ``return`` beendet.

Zudem kann es den Fall geben das kein Ergebnis gefunden wird, dann läuft das in ein implizites ``return None``, was aber explizit da stehen sollte wenn das gewollt wäre.

Code: Alles auswählen

#!/usr/bin/env python3
import requests
from bs4 import BeautifulSoup


def get_info(title, year):
    response = requests.get(
        "https://www.themoviedb.org/search/movie",
        params={"query": f"{title} y:{year}", "language": "de-DE"},
    )
    response.raise_for_status()
    doc = BeautifulSoup(response.text, "html.parser")
    card = doc.select_one(".card")
    if not card:
        return None

    return (
        card.select_one("h2").text,
        card.select_one(".result").get("href"),
    )
    


def main():
    print(get_info("Tron", "2010"))


if __name__ == "__main__":
    main()

Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Samstag 9. Mai 2020, 09:55
von Tron0070
Hallo __blackjack__ , vielen Dank.

Ich habe das als Modul eingebunden und es funktioniert. Doch leider kann ich diese Ausgabe nicht als Funktionsparameter übergeben. Mit 1 Parameter funktioniert es aber nicht mit 2 bzw. einer Liste oder Tupel.
Weißt du woran das liegt? Ich habe es mit quotation versucht, aber half nicht.

Code: Alles auswählen

#!/usr/bin/env python
from module import get_infos as hole
from module import verbinden as schreibe

ausgabe = hole.get_info("Tron", "2010")
schreibe.connection(ausgabe) 


print(ausgabe)
('TRON: Legacy', '/movie/20526?language=de-DE', '20526', '10. Dezember 2010', 'https://image.tmdb.org/t/p/w94_and_h141_bestv2/okpodI7zyPwWsAm2yF5yva6Ea5h.jpg', 'https://image.tmdb.org/t/p/w188_and_h282_bestv2/okpodI7zyPwWsAm2yF5yva6Ea5h.jpg', '21 Jahre nach dem mysteriösen Verschwinden seines Vaters folgt Sam Flynn dem Lockruf eines Pagersignals und wird in die digitale Computerwelt des "Grid" hineingezogen. Dort hat Clu, das einst von seinem Vater geschaffene Programm, die Macht übernommen, dort verstecken sich auch Kevin Flynn und sein Protegé, das Programm Quorra. Nachdem Vater und Sohn sich wiedergefunden haben, verfolgen sie nur ein Ziel, wollen das Grid verlassen. Doch genau das will auch Clu, um seine Diktatur auf die Welt der User auszudehnen.', '2010')


Re: String in einer Funktion1 an die nächste Funktion2 wertergeben

Verfasst: Samstag 9. Mai 2020, 11:22
von Tron0070
OK. habe es so lösen können.

Code: Alles auswählen

schreibe.connection(ausgabe,2,3,4,5,6,7,8)