Das deutsche Python-Forum

Vorschlag zur besseren gegenseitigen Hilfe (OOP nutzen)

Grüße,

mir als programmierer, entwickler geht es oft so, dass ich gerne gewisse Sachen umsetzen würde, aber ich meist an den vielen kleinen problemen scheitere, in die das große Problem zerfällt.

So musste ich mir vor kurzem überlegen, wie ich es hinbekommen, aus einer Liste unbekannter Länge und unbekannten Inhalts von Zahlen, wie ich daraus bestimmte Zahlen herausfiltere. Herausgekommen ist das hier:

Code: Alles auswählen

	def filter_number_from_list(trend_list, number_to_filter):
	# EXAMPLE
	# 1) INPUT: trend_list = [5, 0, -3, -1, 4, 0, 6, 4], number_to_filter = 0
	# 2) OUTPUT: trend_list = [5, -3, -1, 4, 6, 4]
	
		# INIT
		number_to_filter_counter = 0
		
		# FILTER
		for i in trend_list:
			if i == number_to_filter:
				number_to_filter_counter += 1
				
		for i in range(number_to_filter_counter):
			trend_list.remove(number_to_filter)
		
		# RETURN
		return trend_list

Es kann ja nun durchaus sein, dass dieser befehl schon exestiert und ich mir vergeblich Mühe gemacht habe, aber eh ich erst poste und die antworten abwarte und auswerte, schreib ich mir eben lieber selber schnell eine lösung. vielleicht geht es anderen auch so und ich fände es dumm, wenn jeder das gleiche Problem lösen müsste.

Ich möchte daher einen Anstoß geben, dass jeder vielleicht versucht etwas offener und allgemeiner zu programmieren, so könnten wir gegenseitig überschneidende Probleme schneller lösen. Eine Art pool für Probleme einfacher Art aufbauen.
Wenn ich nicht erst lang nachdenken muss über irgend ein kleines Problem, weil das eben schon im "pool" gelöst ist, kann ich mich schon wieder um ein anderes kümmern und so dem pool wieder etwas hinzufügen.

Hier noch die Klasse in der die Funktion zu finden ist:

Code: Alles auswählen

class make_calculations:
	# new_random_numbers: INPUT A LIST OF INTEGERS. EX: [1, 1, -1, 1, -1]
	# connect_how_many: INPUT THE INTEGERS: 1 OR 2
	
	def __init__(self, new_random_numbers, connect_how_many):
		
		# INPUT
		self.new_random_numbers = new_random_numbers
		self.connect_how_many = connect_how_many
		# /INPUT
		
		# OUTPUT
		self.trend_list = []
		# /OUTPUT
	
	def connect_trends_of_same_direction_together(self, list_of_positive_and_negative_integers):
	# EXAMPLE
	# 1) INPUT: list_of_positive_and_negative_integers = [1, -1, 5, 4, 3, -1, -6, -5]
	# 2) OUTPUT: trend_list = [1, -1, 12, -12]
		
		# INIT
		trend_direction = ''
		up_trend_length = 0
		down_trend_length = 0
		trend_list = []
		
		# CONNECTING
		for i in range(len(list_of_positive_and_negative_integers)):
			if (trend_direction != 'DOWN'):
				if (list_of_positive_and_negative_integers[i] > 0):
					up_trend_length += list_of_positive_and_negative_integers[i]
					trend_direction = 'UP'
				elif (trend_direction == 'UP'):
					trend_list.append(up_trend_length)
					up_trend_length = 0
					trend_direction = 'DOWN'
				
				if (list_of_positive_and_negative_integers[i] < 0):
					down_trend_length += list_of_positive_and_negative_integers[i]
					trend_direction = 'DOWN'
				elif (trend_direction == 'DOWN'):
					trend_list.append(down_trend_length)
					down_trend_length = 0
					trend_direction = 'UP'
					
					
			elif (trend_direction != 'UP'):
				if (list_of_positive_and_negative_integers[i] < 0):
					down_trend_length += list_of_positive_and_negative_integers[i]
					trend_direction = 'DOWN'
				elif (trend_direction == 'DOWN'):
					trend_list.append(down_trend_length)
					down_trend_length = 0
					trend_direction = 'UP'
				
				if (list_of_positive_and_negative_integers[i] > 0):
					up_trend_length += list_of_positive_and_negative_integers[i]
					trend_direction = 'UP'
				elif (trend_direction == 'UP'):
					trend_list.append(up_trend_length)
					up_trend_length = 0
					trend_direction = 'DOWN'
				
		if trend_direction == 'UP':
			trend_list.append(up_trend_length)
		elif trend_direction == 'DOWN':
			trend_list.append(down_trend_length)
			
		# RETURN
		return trend_list
	
	
	def connect_trends(self, connect_how_many, trend_list):
	# connect_how_many ONLY FOR VALUES: 1 OR 2
	
	# EXAMPLE
	# 1) INPUT: connect_how_many = 2, trend_list = [5, -3, -1, 4, 6, 4]
	# 2) OUTPUT: new_trend_list = [2, 3, 10]
	
		# INIT
		old_trend_list_is = ''
		if len(trend_list) % 2 == 1:
			old_trend_list_is = 'UNEVEN'
			trend_list.pop()
		else:
			old_trend_list_is = 'EVEN'
		
		# CONNECT THE TRENDS
		new_trend_list = []
		new_current_trend = 0
		for i in range(len(trend_list)/connect_how_many):
			new_current_trend = 0
			for j in range(connect_how_many):
				new_current_trend += trend_list[connect_how_many*i + j]
			new_trend_list.append(new_current_trend)
		
		# RETURN
		return new_trend_list
	
	
	def filter_number_from_list(self, trend_list, number_to_filter):
	# EXAMPLE
	# 1) INPUT: trend_list = [5, 0, -3, -1, 4, 0, 6, 4], number_to_filter = 0
	# 2) OUTPUT: trend_list = [5, -3, -1, 4, 6, 4]
	
		# INIT
		number_to_filter_counter = 0
		
		# FILTER
		for i in trend_list:
			if i == number_to_filter:
				number_to_filter_counter += 1
				
		for i in range(number_to_filter_counter):
			trend_list.remove(number_to_filter)
		
		# RETURN
		return trend_list


	def do_action(self):
		# CONNECTS ALL -1s AND 1s (1, 1, 1 --> 3, -1, -1, -1 --> -3)
		self.trend_list = self.connect_trends_of_same_direction_together(self.new_random_numbers)
		
		# CONNECTS TWO DIFFERENT TRENDS ex(2, -3) --> -1
		self.trend_list = self.connect_trends(self.connect_how_many, self.trend_list)
		
		# IF ZERO APPEARS IT GETS FILTERED
		self.trend_list = self.filter_number_from_list(self.trend_list, 0)
		
		# if TWO POSITIVE TRENDS ARE IN A ROW 
		# then THEY ARE GETTING CONNECTED TO ONE
		self.trend_list = self.connect_trends_of_same_direction_together(self.trend_list)

cu, qweet

Hi!

Naja, ich würde fast sagen, dass genau dafür die Codesnippets da sind, oder?

Dein Problem würd ich übrigens so lösen, oder überseh ich da etwas:

Code: Alles auswählen

def my_filter(lst, number):
    return [x for x in lst if x != number]

EDIT: und so wenn man mehrere Zahlen übergeben können soll:

Code: Alles auswählen

def my_filter(lst, numbers):
    return [x for x in lst if x not in numbers]
lst = [1,2,3,1,2,3,1,2,3]
print my_filter(lst, [2,3])

Gruß, mawe

cool

ja wenn ich das vorher gewusst hätte...

naja, genau das mein ich halt. Vielleicht nen Sticky-thread wo man ne dokumentierte lösung für ein sehr allgemeines problem reinstellt.

Oder vielleicht auch, wie man viele kleinere Lösungen zusammenfassen kann um ein größeres Problem zu lösen. Das man halt irgendwie dieses Baukastenprinzip umsetzt.

und alle lösungen in dem sticky-thread funktionieren halt, sind getestet. Da muss man sich dann keine platte mehr drüber machen.

so in etwas vielleicht.

qweet hat geschrieben:naja, genau das mein ich halt. Vielleicht nen Sticky-thread wo man ne dokumentierte lösung für ein sehr allgemeines problem reinstellt.

Dafür haben wir ja das Wiki: [wiki]Tipps und Tricks[/wiki]

Woll ich auch grade schreiben, jens war wider mal schneller

PS: Ist das mit dem Wiki linken neu? Hab ich irgendwie verpasst

aber den kannte ich noch nicht. na danke auf jeden

mawe hat geschrieben:PS: Ist das mit dem Wiki linken neu? Hab ich irgendwie verpasst

Yes: http://www.python-forum.de/viewtopic.php?t=4800

Naja, früher hatten wir einen Link dazu, der scheint weg zu sein.

Übrigens, die anderen beiden Funktionen Deiner Klasse versteh ich irgendwie nicht. Kannst Du die ein bisschen erklären, vielleicht gibts da auch noch kürzere Wege.

EDIT: @jens: peinlich

Aber wer liest schon die Ankündigungen

eben wer liest schon ankündigungen. das ist was für weicheier und warmduscher

naja. ok.

also wegen der anderen zwei methoden:

Code: Alles auswählen

def connect_trends_of_same_direction_together

hat die aufgabe eine liste mit integer zusammenzufassen. alle positiven zahlen sollen addiert werden, bis die nächste negative zahl kommt. sobald das der fall ist, sollen alle negativen zahlen addiert werden, bis die nächste positive kommt...usw.

Code: Alles auswählen

def connect_trends(self, connect_how_many, trend_list):

hat die aufgabe 2 werte aus einer liste miteinander zu verbinden. dann die nächsten zwei usw. Ich hätte es eigentlich gerne so, dass ich auch 3 oder 4 werte miteinander verbinde. wusste aber nicht wie das geht. naja, damit ich wenigstens was habe, hab ich halt vorlieb genommen mit nur 2 werten.

auf alle fälle ist nicht bekannt was in der liste ist und wie lang die liste ist.

Code: Alles auswählen

def connect_trends(lst, n):
    return [sum(lst[i:i+n]) for i in range(0,len(lst),n)]

lst = [5, -3, -1, 4, 6, 4]
print connect_trends(lst, 2)   # -> [2, 3, 10]
print connect_trends(lst, 3)   # -> [1, 14]

ich weiß jetzt nicht ob es sowas schon in der art gibt, hab mir das wiki noch nicht sooo sehr angeschaut, aber ich hätt gern eine art problem-lösungs-wiki.

bsp:

--

problem: "filter specific numbers from a list of integers"

EXAMPLE
1) INPUT: list = [5, 0, -3, -1, 4, 0, 6, 4], number_to_filter = 0
2) OUTPUT: list = [5, -3, -1, 4, 6, 4]

solution version 1

Code: Alles auswählen

def my_filter(list, numbers):
    return [x for x in lst if x not in numbers]

solution version 0

Code: Alles auswählen

    def filter_number_from_list(trend_list, number_to_filter):
    # EXAMPLE
    # 1) INPUT: trend_list = [5, 0, -3, -1, 4, 0, 6, 4], number_to_filter = 0
    # 2) OUTPUT: trend_list = [5, -3, -1, 4, 6, 4]
   
        # INIT
        number_to_filter_counter = 0
       
        # FILTER
        for i in trend_list:
            if i == number_to_filter:
                number_to_filter_counter += 1
               
        for i in range(number_to_filter_counter):
            trend_list.remove(number_to_filter)
       
        # RETURN
        return trend_list

qweet hat geschrieben:ich weiß jetzt nicht ob es sowas schon in der art gibt, hab mir das wiki noch nicht sooo sehr angeschaut, aber ich hätt gern eine art problem-lösungs-wiki.

Das solltest du mal nachholen... Denn dafür ist genau [wiki]Tipps und Tricks[/wiki] da

Code: Alles auswählen

def connect(lst):
    new = []
    tmp = lst[0]
    for i in range(1, len(lst)):
        if lst[i-1] * lst[i] < 0:
            new.append(tmp)
            tmp = lst[i]
        else: tmp += lst[i]
    new.append(tmp)
    return new

lst = [1, -1, 5, 4, 3, -1, -6, -5]
print connect(lst)

mawe hat geschrieben:

Code: Alles auswählen

def connect_trends(lst, n):
    return [sum(lst[i:i+n]) for i in range(0,len(lst),n)]

lst = [5, -3, -1, 4, 6, 4]
print connect_trends(lst, 2)   # -> [2, 3, 10]
print connect_trends(lst, 3)   # -> [1, 14]

lst = [5, -3, -1, 4, 6, 4, -3]
connect_trends(list, 2)

Traceback (most recent call last):
File "<pyshell#17>", line 1, in -toplevel-
connect_trends(list, 2)
File "<pyshell#15>", line 2, in connect_trends
return [sum(list[i:i+n]) for i in range(0,len(list),n)]
TypeError: len() of unsized object

das ist nicht gut.

Aber ansonsten ist dein Code cool.

Code: Alles auswählen

lst = [5, -3, -1, 4, 6, 4, -3]
connect_trends(list, 2)

Die Liste heisst lst, nicht list

list ist ein Python-Keyword, kann zu kuriosen Fehlern führen, wenn man so etwas als Variablennamen verwendet

hmm. auch gut zu wissen.

ich gebe mich geschlagen.

list ist ein Python-Keyword, kann zu kuriosen Fehlern führen, wenn man so etwas als Variablennamen verwendet

List ist _kein_ Keyword, es ist der Name einer eingebauten Factory-Funktion. Wenn es ein Keyword wäre würde der Interpreter einen SyntaxError schmeißen bei der Benutzung wie da angegeben, er tut es aber nicht.

Keywords sind Dinge wie if, while, print, for, in, und seit neuestem auch None (probiere mal eine Zuweisung auf None zu machen in Python 2.4).

--- Heiko.

modelnine hat geschrieben:...und seit neuestem auch None (probiere mal eine Zuweisung auf None zu machen in Python 2.4).

Da muss ich dir ausnahmsweise mal wiedersprechen. None ist kein Keyword. Auch wenn es einen Syntax Error wirft, ist es nach wie vor ein Objekt vom type NoneType.

Stimmt.

Ich hab mich zumindest dunkel daran erinnert dass None ein Keyword werden sollte für 2.4 (dachte ich halt zumindest), ist es aber noch nicht geworden.

--- Heiko.

modelnine hat geschrieben:List ist _kein_ Keyword, es ist der Name einer eingebauten Factory-Funktion.

Ich will auch mal "Erbsenzählen": `list` ist keine Factory-Funktion, das war früher mal. Jetzt ist `list` ein `type`. Sonst könnte man nicht davon erben.