Loops And Such Options

[bam]

I have this so far:

CODE

for item in dupes[]:
  mydupeitem=item
  for item in filter[]:
     if mydupeitem[2:] = item:
        pass
     else
        write......etc.

now is there anything wrong with this? it wipes out my entire bash history, so it never gets to the write statement. filter[] is just a list of filters(strings) and dupes[] is just a list of strings as well, basically i an 'cleaning' my bash history at logoff, I have a remove duplicates script running and it sorts but I would like to remove any "cd blahblah" and rm's mv's etc. any ideas, I am new to python, so any help would be great.

[zmiq2]

Instead of

CODE

for item in dupes[]:
 mydupeitem=item

I would use something like

CODE

for mydupeitem in dupes[]:
 

I centainly think that using the same variable name, item, in both nested loops doesn't seem a good idea and could cause an undesired side effect.

HTH

[bam]

I agree, I thought "item" was one of the collections constants, such as in vb with "for each vbtextbox in form" i know the wrong syntax but you get the idea.

[kopsis]

I have this so far:

CODE

for item in dupes[]:
  mydupeitem=item
  for item in filter[]:
     if mydupeitem[2:] = item:
        pass
     else
        write......etc.

A few observations:

* Your "if mydupeitem..." line is using an assignment (=) instead of a compare (==).
* You're reusing your loop variable (item) in the inner loop. I'm not sure Python cares (I'm in the habit of not trying such things), but in other languages like C that would cause much breakage. Note: "item" is just a variable that gets set on each loop iteration. You can use any variable name there that you wish.
* I don't understand the empty [] brackets on the "for item ..." lines. They should cause syntax errors.

A more elegant solution (assuming you're using a recent version of Python would be something like:

CODE

def f(x):
   for item in filter:
       if x[2:] = item:
           return false
   return true

filtered_list = filter(f, dupes)

That will run f(x) on every element in dupes and set filtered_list equal to the list of those for which f(x) returned true (i.e. they did not match any items in the filter list).

[bam]

morning,
yea there was some issues, got it all solved, though not quite as nice as yours. I am new to c-style programming, mostly I diddle with visual basic(for my company work). I saw that python had a nice gui to play with pyQt so this "seemed" closest to vb, so I thought the learning curve would be a little more flat, but guess not. I will however need to start writing "functions" and "subs" in order to keep stuff organized and not spagetti code, not only that but reuseability will be nicer.


actually here is what I did:

CODE

filterlist = ["df","cd","mv","cp"]

(removed duplicates before filter)

for ditem in noDupes:
  for fitem in filterlist:
     if ditem[2:] ==fitem:
        filterfound == bool(True)
        break
     if filterfound == False:
        fileToOutput.write(ditem)
     filterfound == bool(False)

I use this script to clean up my .bash_history file of duplicates and unwanted commands. It executes on exiting console(.bash_logout)

[kopsis]

yea there was some issues, got it all solved, though not quite as nice as yours. I am new to c-style programming, mostly I diddle with visual basic(for my company work). I saw that python had a nice gui to play with pyQt so this "seemed" closest to vb, so I thought the learning curve would be a little more flat, but guess not. I will however need to start writing "functions" and "subs" in order to keep stuff organized and not spagetti code, not only that but reuseability will be nicer.

Congrats on getting your program working Going from VB to any modern language is going to have bit of a learning curve, but if you stick with it you'll make yourself a much better programmer. However, I have to disagree with your statement that you're new to C style programming. What you call C style is technically referred to a "imperative" programming. Both VB and C (at least in conventional usage) are actuall very similar in abstract programming language terms.

What causes a lot of confusion for new Python programmers is that it offers a number of features borrowed from the world of "functional programming". Things like lists, first-class functions, list comprehensions and built-ins like map() and filter() let you break out of the imperative style when writing Python code.

Why would you want to do that? Well, research shows that for many types of problems functional programming techniques result in much smaller programs with far fewer bugs. It makes it possible to work with programs as mathematical expressions rather than cookbook recipes. Ask yourself "where are most of the bugs in my programs?" The answer is usually "loops and state". Note how my example contained neither The function I defined wasn't there for traditional structured programming purity, it was there so I could pass it as a variable to the filter() built-in The whole idea of passing functions as variables may sound a bit strange, but that's one of the keys to FP.

Now, just as one can write FORTRAN style code in C++, it's possible to write VB style code in Python. But if you really want to improve yourself as a programmer, focus on learning to use the FP features in Python. In the long run, you'll be glad you did If you want to learn more Functional Programming For The Rest Of Us is a good place to start.

[bam]

FP is just, phenominal, actually I like it(about half way through the article now. This dramatiacally simplifies coding.

[bam]

well here is the end result, I think I am getting ahold of it

#!/usr/bin/env python

import os
import fileinput

fileToSearch="/home/zaurus/.bash_history"

#filterlist for non-saves, just add as needed
filterlist=[ "cd","mv","cp","df","exit"]
filteredlist=[]
mylist=[]
noDupes=[]

[mylist.append(line) for line in fileinput.input( fileToSearch )]
fileinput.close()

[noDupes.append(j) for j in mylist if not noDupes.count(j)]
noDupes.sort

filteredlist=noDupes
os.remove(fileToSearch)
fileToOutput = open( fileToSearch, 'w' )

[filteredlist.remove(y) for x in filterlist for y in noDupes if x == y[0:len(x)] ]
[fileToOutput.write(item) for item in filteredlist]
fileToOutput.close()

basically run this under .bash_logout to clean up my bash_history file of duplicates and unwanted commands, eventually I will have it check against "valid" bash commands/executables as well.