Develop Reference

How to get output in one line

I do reverse string and input is The quick brow fox
def reverse_word(word):
for i in word:
re = (i[::-1])
print('Reversed words ==> '+ re )
def main():
word = input('Enter a line : ').split()
reverse_word(word)
main()
but my result is
Reversed words ==> ehT
Reversed words ==> kciuq
Reversed words ==> worb
Reversed words ==> xof
I want result like:
Reversed words ==> ehT kciuq worb xof

you can use end in print method
def reverse_word(word):
print('Reversed words ==> ', end='')
for i in word:
re = (i[::-1])
print(re, end=' ' )
def main():
word = input('Enter a line : ').split()
reverse_word(word)
main()

Can try this one :
def reverse_word(word):
print("Reversed words ==>", end="")
for i in word:
re = (i[::-1])
print(" " + re, end="")
def main():
word = input('Enter a line : ').split()
reverse_word(word)
main()

In order to get a single line output , you can have a global string out = "" To which you will concatenate your resulting words.
out += " " + re
Inside the for loop
And this can be printed right after the end of the loop.
out = ""
def reverse_word(word):
for i in word:
re = (i[::-1])
out += " " + re
print("Reversed Words ==> " + out)
def main():
word = input('Enter a line : ').split()
reverse_word(word)
main()

def reverse_word(word):
res = ""
for i in word:
re = (i[::-1])
res += " "+re
return 'Reversed words ==>'+ res
word = input('Enter a line : ').split()
print(reverse_word(word))
Believe this would have desired effect.
Not really a question asked so no need to explain it further. Keep it simple!

When you say word it looks like this is really a collection of words, so words is probably a better name, and each of those should probably be word rather than i.
def reverse_words(words):
for word in words:
re = (word[::-1])
print('Reversed words ==> '+ re )
def main():
words = input('Enter a line : ').split()
reverse_words(words)
main()
Now, we can use a generator expression to generate the reversed word for each word.
(word[::-1] for word in words)
And let's join those with a space.
' '.join(word[::-1] for word in words)
And putting it into a function, using an f-string to print it:
def reverse_words(words):
print(f"Reversed words ==> {' '.join(word[::-1] for word in words)}")
Alternatively, we can use reversed.
def reverse_words(words):
print(f"Reversed words ==> {' '.join(''.join(reversed(word)) for word in words)}")

return last word in a file that starts with capital letter

I'm trying to make a simple script that seraches for a designated .txt file for the last word that starts with a capital letter and returns it. If there are no words that start with a capital letter, it returns an empty string.
This is what I have tried so far:
def find_last_capitalised(file_name):
with open(file_name) as wordfile:
text_str = wordfile.read()
word_list = text_str.split()
upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for word in word_list:
if word.rfind(upper):
return word
else:
return " "
but this isn't working.
I also tried this:
with open(file_name) as wordfile:
text_str = wordfile.read()
word_list = text_str.split()
for word in word_list:
if word_list[-1].isupper():
return word_list[-1]
else:
return " "
Any help?

Others provided you with various method for doing your task. I want to explain why your 1st method do not work as intended:
upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
if word.rfind(upper):
.rfind method of str is looking for position of last substring ABCDEFGHIJKLMNOPQRSTUVWXYZ inside word. I guess that your words do NOT contain such substring, in which case .rfind returns -1, which according to rules of Python evaluate to True (as it is not zero), so it would catch almost any word (it will give 0 or False only for words starting with ABCDEFGHIJKLMNOPQRSTUVWXYZ and containing only single ABCDEFGHIJKLMNOPQRSTUVWXYZ)

Fist of all, your algorithm would return the first capitlized word, not the last so there needs to be a little change in logic. Also the simplest way to check if word is capitalized is provided:
def find_last_capitalised(file_name):
with open(file_name) as wordfile:
text_str = wordfile.read()
word_list = text_str.split()
last_cap_word = " "
for word in word_list:
if word[0].isupper():
last_cap_word = word
return last_cap_word

Looks like you need reversed.
Ex:
def find_last_capitalised(file_name):
with open(file_name) as wordfile:
text_str = wordfile.read()
word_list = text_str.split()
for word in reversed(word_list): #reversed
if word[0].isupper():
return word
return " "

I did something like this.
import re
pattern = "[A-Z][a-zA-Z]+"
with open('input.txt', 'r') as file:
for el in reversed(file.readlines()):
res = re.findall(pattern, el)
if res:
print(res[-1])

def find_last_capitalised(word_list):
lastCapWord = " "
for word in word_list:
print(word)
if word[0].isupper():
lastCapWord = word
print('lastCapWord:', lastCapWord)
return lastCapWord
word_list = ['this', 'is', 'A', 'test']
find_last_capitalised(word_list)
Your algorithm is a little off. It doesn't go through each word in the list, instead it just returns based off the first word it sees. Assuming you make you make your word list into an array, the following code should work just fine.

You need are returning " " at first fail. That's why you don't get expected result.
def find_last_capitalised(file_name):
with open(file_name) as wordfile:
text_str = wordfile.read()
word_list = text_str.split()
for word in reversed(word_list):
if word[0].isupper():
return word
return ""
However if your file is much bigger, you might want to read file in a reverse order. Which will let you find what you looking for much easier.
import os
def find_last_capitalised(file_name):
with open(file_name) as wordfile:
wordfile.seek(0, os.SEEK_END)
position = wordfile.tell()
word = ''
while position >= 0:
qfile.seek(position)
next_char = qfile.read(1)
if next_char == " ":
if word[0].isupper():
return word
word = ''
else:
word += next_char
position -= 1
return ""
I suggest using similar approach to solve your problem.

You can try with reversed and is_upper keywords:
def find_last_capitalised(file_name):
with open(file_name) as wordfile:
text_str = wordfile.read()
word_list = text_str.split()
word_list = reversed(word_list)
for word in word_list:
if word[0].isupper():
return word
print(find_last_capitalised("demo.txt"))

def find_last_capitalised(file_name):
with open(file_name) as wordfile:
text_str = wordfile.read()
word_list = text_str.split(" ")
upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for word in reversed(word_list):
if upper.rfind(word[0]) >= 0:
return word
return " "
Please try with the above code ... If its not working let me know here.

Python, How do you check how many times an item appears in an array

I'm making a program that finds every word in a block of text and outputs each word and how many times the word was used.
My current code is here:
text = input("Please enter some text ")
terminator = len(text)
n = 0
word = ""
wordlist = []
while len(text) > 0:
if word != "":
wordlist.append(word)
text = text[n:]
word = ""
n = 0
for char in text:
if char != " ":
word = word + char
n = n + 1
else:
text = text[1:]
break
for item in wordlist:
print(item)
thanks :)

I'd do something like this:
import re
from collections import Counter
text = input("Please enter some text ")
text = re.sub(' +', ' ', text)
text = text.split(' ')
counter = Counter(text)
The line text = re.sub(' +', ' ', text) deals with cases where the user enters multiple consecutive spaces.

Codecademy Practice Makes Perfect 10/15 (Word Censoring)

I'm on Codecademy, the section called "Practice Makes Perfect", on problem 10/15, the word-censoring one. The problem goes like this:
Write a function called censor that takes two strings, text and word, as input. It should return the text with the word you chose replaced with asterisks.
My idea was to do this:
def censor(text, word):
length_of_word = len(word)
word_now_censored = '*' * length_of_word
wordlist = text.split()
for item in wordlist:
if item == word:
item = word_now_censored
return " ".join(wordlist)
But, so it seems, changing the value of item in the for loop doesn't change the value of the item in the list.
I thought another way could be to use a while loop, going from i = 0 to i < len(wordlist), and then modify wordlist[i] as needed, but I'd just like to understand why my for-loop method doesn't work.

Change it to this:
for index, item in enumerate(wordlist):
if item == word:
wordlist[index] = word_now_censored

You could simply use re.sub to replace all instances of word:
import re
def censor(text, word):
return re.sub(r'\b{}\b'.format(word), '*' * len(word), text)

Your observation is right
changing the value of item in the for loop doesn't change the value of the item in the list.
There are many ways to go about this. Here is one way. Create another variable new_words_list. Append the word from wordlist to new_words_list if it not word. Else append word_now_censored to new_words_list.
Which translates to:
def censor(text, word):
length_of_word = len(word)
word_now_censored = '*' * length_of_word
wordlist = text.split()
new_words_list = []
for item in wordlist:
if item == word:
new_words_list.append(word_now_censored)
else:
new_words_list.append(item)
return " ".join(new_words_list)

def censor(text,word):
text=list(text)
for n in range(0,len(text)):
i=0
while 1==1:
for i in range(0,len(word)):
if text[n+i]==word[i]:
i+=1
else:
break
if i==len(word):
for m in range(0,i):
text[n+m]='*'
else:
break
n+=i
return "".join(text)
print censor("this hack is wack hack", "hack")

Here is another version:
def censor(text, word):
lst = text.split()
while word in lst:
index = lst.index(word)
lst.remove(word)
lst.insert(index,'*' * len(word))
return " ".join(lst)

censor takes two strings, text and word, as input. It returns the text with the word you chose replaced with asterisks.
def censor(text,word):
result = ""
count = 0
no_of_stars = 0
split_list = text.split()
for i in split_list:
count += 1
if(i==word):
result += "*" * len(i)
else:
result +=i
if(count != len(split_list)):
result += " "
return result

Here's my version. Simply build a new word of asterisks the same length as the word, then replace it.
def censor(text, word):
if word in text:
blabber = ""
while True:
blabber += "*"
if len(blabber) == len(word):
break
return text.replace(word, blabber)

def censor(text,word):
res = text.split()
temp = ""
for i,j in enumerate(res):
if j == word:
res[i] = "*" * len(word)
return " ".join(res)

Just solved it and this was my solution:
def censor(text, word):
textList = text.split()
for index, var in enumerate(textList):
if var == word:
textList[index] = "*" * len(word)
return " ".join(textList)

def censor(text,word) :
c=''
for i in text.split() :
if i == word :
i = "*" * len(word)
c += ' ' + i
else :
c += ' ' + i
return c
print censor("this hack is wack hack", "hack")

def censor(text, word):
lista=[]
for i in text.split():
if i==word:
lista+=['*'*len(word)]
else:
lista+=[i]
return ' '.join(lista)

def censor(text, word):
new_text = text.split()
ctext = []
for item in new_text:
if item == word:
item = "*" *len(word)
ctext.append(item)
return " ".join(ctext)

def censor(text, word):
a = word
b = len(a)
for a in text:
text = text.replace(word, "*"*b)
return text

My idea was just:
def censor(text, word):
answer = text.replace(word, "*"*len(word))
return answer
This is might be simple one but I think simple is good. And I didn't have to use any loop, is it good?
If you like my answer, please let me know, I'll be really happy. Thank you

I've made it quite simple and I don't see why no one mentioned this.
def censor(text, word):
return text.replace(word,"*" * len(word))

I'll appreciate it if you will take a look at this one.
def censor(text, word):
if word in text:
return text.replace(word, '*' * len(word))

How to separate words that have uppercase and lowercase in Python?

I need to separate words that have at least one uppercase letter with the lowercase. I need to take input and separate uppercase words and lowercase words and print them both. Here is my code:
text = input("Input your text: ")
words0 = text.strip().split()
words1 = []
words2 = []
wordslen= len(words0)
for word in words0:
counter = 0
for x in word:
while counter != wordslen:
if x.isupper():
words1.append(word)
else:
words2.append(word)
counter += 1
wordsupper = list(set(words1))
wordslower = list(set(words2))
allwords = wordsupper + wordslower
for word in allwords:
print(word)

words = input("Input your text: ").strip().split()
lower, mixed = set(), set()
for word in words:
if word == word.lower():
lower.add(word)
else:
mixed.add(word)
print("Lowercase words: " + ", ".join(lower))
print("Mixed- and uppercase words: " + ", ".join(mixed))
which runs like:
Input your text: This is a Perl and Python party.
Lowercase words: a, and, is, party.
Mixed- and uppercase words: This, Python, Perl

To separate words that have only lowercase characters from the rest:
text = raw_input('Input text: ')
lower, rest = set(), set()
for word in text.split():
(lower if word == word.lower() else rest).add(word)
print(lower)
print(rest)

this is similar to previous posts, but uses map() instead of for word in words:
text = raw_input("Input your text: ")
words = text.strip().split()
upper = []
lower = []
def sort_word(word):
if word.lower() == word:
lower.append(word)
else:
upper.append(word)
map(sort_word, words)

Maybe something like this:
text = input("Input your text: ")
words = text.strip().split()
wordslower = []
wordsupper = []
for word in words:
# if the word is the same as word.lower() that means all the
# characters are lower case. Also, don't add duplicates to
# the list.
if word == word.lower():
if word not in wordslower:
wordslower.append(word)
else: # The word has at least one capital letter
if word not in wordsupper:
wordsupper.append(word)
print(wordslower)
print(wordsupper)

Try this:
def check(word):
for k in word:
if k != k.lower(): #If the letter is capitalized
return True
return False
text = input('Text: ')
text = text.strip().split()
wordsupper = []
wordslower = []
for k in text:
if check(k) == True:
wordsupper.append(k)
else:
wordslower.append(k)
print(wordslower)
print(wordsupper)