# Code does not work: alphabetical ordering,

Hello, what could I do in order to make this code work?

What is the most effective way to find whether a specific part of a string text e.g. “a” exists is in any n number of string texts?

Maybe this?

``````the_input_word = input("Please give a word.")
the_looked_for_letter = input ("Please give a letter look for in the previously given word.")

x = 0
While x < int( len(the_input_word) +1):
if str(word [x:x+1:] == str(the_looked_for_letter):
print("The letter", " ", str(the_looked_for_character), " ", "was found in the word '", "", str(the_input_word), "", "'."
``````

In this exercise I should look for if a letter appears in both the user-input words.

``````While x < int( len(the_input_word) +1:
if str(word [x:x+1:] == str(the_looked_for_letter):
and if str(word2 [x:x+1:] == str(the_looked_for_letter):
print("The letter", " ", str(the_looked_for_character), " ", "was found in the both words '", "", str(
the_input_word), "" , "' and '", "", str(the_input_word2), "". "'.", sep="")
else:
print("The letter", " ", str(the_looked_for_character), " ", "was not found in the both words '", "", str(the_input_word), "" , "' and '", "", str(the_input_word2), "". "'.", sep="")
``````

the original code:

``````word1 = input("Please give a word1: ")
word2 = input("Please give a word2: ")

mylist = [str(word1), str(word2)]
mylist.sort()
if print(mylist) == ['str(word1)', 'str(word2)']:
print("'", "", str(word1), "", "' is in the alphabet before than '", word2, "", "'.", sep="")
elif print(mylist) == ['str(word2)', 'str(word1)']:
print("'", "", str(word2), "", "' is in the alphabet before than '", word1, "", "'.", sep="")
else:
print("Something went wrong.")

if word1 [0:1] or word1 [1:2] or word1 [2:3] or word1 [3:4] or word1 [4:5] == "z" and word2 [0:1] or word2 [1:2] or word2 [2:3] or word2 [3:4] or word2 [4:5] != "z":
print ("From the both words no 'z' can be found")
else:
print ("Something went wrong.")

tested_word = input("Please give a word to test: ")
palindrome = tested_word [int(tested_word): -1: -1]

if str(tested_word) == str(palindrome):
print("The word you gave is a palindrome.")
elif str(tested_word) !=  str(palindrome):
print("The word you gave is no palindrome.")
else:
print("Something went wrong.")

print("It is reversed '", "", str(tested_word [int(tested_word): -1: -1]), "", "' and corretly", " ", str(tested_ word), sep="")
``````

Hello, what could I do in order to make this code work?

What is the most effective way to find whether a specific part of a string text e.g. “a” exists is in any n number of string texts?

You’re aware that the `str` class has an `in` operator?

`````` >>> "a" in "abc"
True
>>> "a" in "cba"
True
>>> "a" in "xyz"
False
``````

It’s actually a substring search:

`````` >>> "ab" in "abc"
True
>>> "ab" in "cba"
False
``````

Maybe this?

``````the_input_word = input("Please give a word.")
the_looked_for_letter = input ("Please give a letter look for in the previously given word.")

x = 0
While x < int( len(the_input_word) +1):
``````

You want a lowercase `while`. But the quick way to iterate `x` of the
indices of `the_input_word` is:

`````` for x in range(len(the_input_word)):
``````

if str(word [x:x+1:] == str(the_looked_for_letter):

The expression `word[x:x+1:]` can be written `word[x]`.

``````  print("The letter", " ", str(the_looked_for_character), " ", "was found in the word '", "", str(the_input_word), "", "'."
``````

This loop runs that print on every match. Consider searching for `"a"`
in `"abracadabra"`.

In this exercise I should look for if a letter appears in both the
user-input words.

``````While x < int( len(the_input_word) +1:
if str(word [x:x+1:] == str(the_looked_for_letter):
and if str(word2 [x:x+1:] == str(the_looked_for_letter):
print("The letter", " ", str(the_looked_for_character), " ", "was found in the both words '", "", str(
the_input_word), "" , "' and '", "", str(the_input_word2), "". "'.", sep="")
``````

You’ve broken that line up, but this looks like you’re actually testing
if `the_looked_for_letter` occurs in the same place in `word1` and
`word2` because `x` will be the same value for each test.

I recommend you pull the “search for a letter” logic out into a
function, eg:

`````` def letter_occurs_in_word(letter, word):
``````

You can use the “early return” approach:

`````` def letter_occurs_in_word(letter, word):
for x in range(len(word)):
if word[x] == letter:
# found it, return imemdiately
return True
return False
``````

Then you can test using your `letter_occurs_in_word(the_looked_for_letter,word1)` and so forth as needed.

Cheers,
Cameron Simpson cs@cskk.id.au

Thank you for the reply. Sadly I was due to my limited and short-time knowledge of programming only able to understand 5-10% of your explanation in only two days. Realistically speaking, I will maybe understand your explanation fully in a month or two.

Umm… is this any better? I am aware that the code does not work, however, I receive no syntax error.

``````word1 = input("Please give a word1: ")
word2 = input("Please give a word2: ")

mylist = ['word1', 'word2']
if mylist.sort() == ['word1', 'word2']:
print("'", "", word1, "", "' is in the alphabet before than '", word2, "", "'.", sep="")
elif mylist.sort() == ['word2', 'word1']:
print("'", "", word2, "", "' is in the alphabet before than '", word1, "", "'.", sep="")
else:
print("Something went wrong.")

"z" in "str(word1)" and "z" in "str(word2)"
if False:
print("Neither word has 'z' in it.")
else:
print("Something went wrong.")

tested_word = input("Please give a word to test: ")
palindrome = tested_word [(len(tested_word))::-1]

if str(tested_word) == str(palindrome):
print("The word you gave is a palindrome.")
elif str(tested_word) !=  str(palindrome):
print("The word you gave is no palindrome.")
else:
print("Something went wrong.")

print("It is reversed '", "", str(tested_word [len(tested_word)::-1]), "", "' and corretly", " ", str(tested_word), sep="")
``````

Thank you for the reply. Sadly I was due to my limited and short-time
knowledge of programming only able to understand 5-10% of your
explanation in only two days. Realistically speaking, I will maybe
understand your explanation fully in a month or two.

No worries.

Umm… is this any better? I am aware that the code does not work, however, I receive no syntax error.

No syntax errors just means that the code is “well formed”, like using
correct grammar in an English sentence. It doesn’t mean the code does
what you hoped to achieve.

`````` word1 = input("Please give a word1: ")
word2 = input("Please give a word2: ")
``````

This prompts the user and reads two responses into the variables `word1`
and `word2` repsectively. All good.

`````` mylist = ['word1', 'word2']
``````

This makes a short list, containing the literal strings `'word1'` and
`'word2'`. Those are not the strings the user entered. I suspect you
actually wanted:

`````` mylist = [word1, word2]
``````

This version uses the variables `word1` and `word2`, not the unrelated
strings `'word1'` and `'word2'` which are just… strings. Suppose the
user entered the words `alpha` and `beta` at your prompts. Then the
vairable `word1` would refer to the string `'alpha'`, and the variable
`word2` would refer to the string `'beta'`.

Your definition of the `mylist` variable would make it refer to a list
witth these 2 strings:

`````` 'word1'
'word2'
``````

Using the variables (eg `word1`) instead of a literal string (eg `'word1'`)
makes a list with these 2 strings:

`````` 'alpha'
'beta'
``````

because those are bound to the `word1` and `wod2` variables.

`````` if mylist.sort() == ['word1', 'word2']:
``````

Again, you’ve got literal strings instead of the variables. You want:

`````` if mylist.sort() == [word1, word2]:
``````

However, there’s a further complication.

The expression `mylist.sort()` does not return a sorted version of
`mylist`. Instead it sorts `mylist` in place, and returns `None`, the
Python placeholder value meaning “no value”. What you really want is:

`````` if sorted(mylist) == [word1, word2]:
``````

The `sorted()` function makes a new list containing the values from
`mylist` in sorted order and returns that new list. Let me demonstrate
interactively:

`````` >>> L = [3, 2, 1]
>>> L
[3, 2, 1]
>>> sorted(L)
[1, 2, 3]
>>> L
[3, 2, 1]
>>> L.sort()
>>> L
[1, 2, 3]
``````

Here we make a list of numbers, not sorted numericly. We show `L` to
check that it has what we want. Then we show `sorted(L)`, which makes a
new sorted list and returns it.

Then we show `L` again, to see that it is unchanged (still not sorted).

The we call `L.sort()`. This sorts the list in place i.e. it modifies
`L` itself. And returns `None`. You can tell it returned `None` because
the value of `L` was not printed.

Then we show `L` again, and see that it is sorted.

This convention is common in Python: functions which modify something in
place like `L.sort()` return nothing, and functions which create a new
thing like `sorted(L)` return the new thing. This avoids some common
mistakes.

Note that they “avoid” these mistakes by returning `None`, which is not
useful. It doesn’t means that they don’t run! It just means that your
code won’t work correctly with the `L.sort()` form.

That is why you actually want this test:

`````` if sorted(L) == [word1, word2]:
``````

The same issues apply to your `elif` test.

Let’s look at your substring check:

`````` "z" in "str(word1)" and "z" in "str(word2)"
if False:
print("Neither word has 'z' in it.")
else:
print("Something went wrong.")
``````

Usually, evaluating an expression without using its result, such as
assigning it to something, is not useful. So this:

`````` "z" in "str(word1)" and "z" in "str(word2)"
``````

performs a test but does not store the result of the test anywhere.
Typically you’d put this test directly into the if-statement so that the
if-statement gets to use the result, eg:

`````` if "z" in "str(word1)" and "z" in "str(word2)":
........
``````

Alternatively you can store the result in a variable:

`````` z_in_both = "z" in "str(word1)" and "z" in "str(word2)"
``````

and then use the variable in the if-statement:

`````` if z_in_both:
........
``````

But there are problems with the test itself, and they’re a lot like the
problems you had with `mylist` earlier. This:

`````` "str(word1)"
``````

is a literal string, representing the text:

`````` str(word1)
``````

So you’re seeing if the string `"z"` occurs in the string `"str(word1)"`
(which it does not, so the test will always return `False`). I think
what you really intended is written like this:

`````` z_in_both = "z" in word1 and "z" in word2
``````

which looks for `"z"` in the string referred to by `word1`. In my
example input, that would be a string containing this text:

`````` alpha
``````

Likewise for `word2`.

In Python, text between quotes is a literal piece of text. A word not
in quotes is a variable name, and the value used is what it referes to.
Here’s an interactive example:

`````` >>> w = "text1"
>>> y = "w"
>>> y
'w'
>>> y = w
>>> y
'text1'
``````

Here we make a string `"text1"`. And refer to it with the variable `w`.

Using `y = "w"` assigns the literal string `"w"` to `y`.
Using `y = w` assigns the string referred to by the variable `w` to `y`.

Coming back to the if-statement after your `"z"` test:

`````` if False:
print("Neither word has 'z' in it.")
else:
print("Something went wrong.")
``````

This tests the value `False`, which is always false! So it will always
run the second `print()` call.

What you actually want to test it the result of your test. So this will
work:

`````` z_in_both = "z" in word1 and "z" in word2
if z_in_both:
print("Something went wrong.")
else:
print("Neither word has 'z' in it.")
``````

Notice that I switches the `print()`s to match the result of the test.

However, this `print()` is not saying the right thing:

`````` print("Neither word has 'z' in it.")
``````

This is because `z_in_both` will only be true if both words contain a
`"z"`. So a false result doesn;t mean that neither contains a `"z"`;
it is enough for just one to not contain `"z"` for the result to be
false (because you used `and` to combine the individual tests). So the
`print()` should say:

`````` print("At least one of the words does not contain 'z'.")
``````

or something equivalent to that.

Continuing:

`````` tested_word = input("Please give a word to test: ")
palindrome = tested_word [(len(tested_word))::-1]
``````

Ok, so you’re getting the reversed form of `tested_word` using a funky
slice which has a negative step (the `-1`).

`````` if str(tested_word) == str(palindrome):
print("The word you gave is a palindrome.")
``````

This is correct. But both `tested_word` and `palindrome` are already
strings. You you can just write:

`````` if tested_word == palindrome:
print("The word you gave is a palindrome.")
``````

which is much easier to read.

`````` elif str(tested_word) !=  str(palindrome):
print("The word you gave is no palindrome.")
``````

Technically, you do not need the `!=` test. If your code runs the
`elif...else...` section then you already know that
`tested_word!=palindrome` because the `==` test failed. So you could
simplify this down to:

`````` else:
print("The word you gave is no palindrome.")
``````

However, I want to commend you for the final `else:` anyway. We often
write an `if`/`elif`/`elif`/…/`else` chain to sort out various
circumstances, and I commonly see the `else:` part left out because the
programmer thinks that the conditions in the `if` and `elif` should
cover everything which can happen. But circumstances can change, and it
is prudent to always catch the “none of the above” situation and log
an error or raise an exception.

Here’s a real world example from my own code:

`````` if opt == '-d':
if not isdirpath(val):
raise GetoptError("not a directory: %r" % (val,))
options.spdpath = val
elif opt == '-n':
options.doit = False
else:
raise RuntimeError("unhandled pre-option")
``````

Here I’m handling some command line switches: `-d` and `-n`.

In theory the `else:` part of this code can never run because the code
which defines `opt` only recognises `-d` or `-n`, and so opt can only
ever be one of those two and in a perfect world the last `else:` can
never happen.

However, supposing I modify the earlier stuff which sets `opt` to
recognise some additional option, but forget to update this
if-statement above? Without the `else:` part it would quietly ignore
whatever extra option that was. With the `else:` it explodes loudly,
making it obvious that there’s a gap in my logic.

It is almost always good to have a catch-all at the end.

Finally, the last `print()` call:

`````` print("It is reversed '", "", str(tested_word [len(tested_word)::-1]), "", "' and corretly", " ", str(tested_word), sep="")
``````

First: you don’t need `str(tested_word)` etc. These things are already
strings.

Second: if you want to get these strings with quotes around them (to
make the output more understandable) Python has a handy function named
`repr()` which ideally returns a string which is a Pythin expression for
the value you hand it. So:

`````` print(word1)
``````

might print the text:

`````` alpha
``````

but this:

`````` print( repr(word1) )
``````

would print the text:

`````` 'alpha'
``````

which is the Python expression for that literal string value. The you
could go:

`````` print("It is reversed", repr(tested_word [len(tested_word)::-1]), "and correctly", repr(tested_word))
``````