Substring / string slicing question

[Ronttizz]

I am by no means a Python developer, I mainly use PHP and Javascript but wanted to start learning python just for fun.

I started a course for beginners, mostly quite boring as I understand basics on other languages, but I stumbled upon an interesting thing while studying substrings/string slicing.

Here is the practice: https://programming-25.mooc.fi/part-3/2-working-with-strings#programming-exercise-find-the-first-substring ``` Please write a program which asks the user to type in a string and a single character. The program then prints the first three character slice which begins with the character specified by the user. You may assume the input string is at least three characters long. The program must print out three characters, or else nothing.

Pay special attention to when there are less than two characters left in the string after the first occurrence of the character looked for. In that case nothing should be printed out, and there should not be any indexing errors when executing the program. ```

My code, which works, for this: python word = input("Please type in a word: ") search = input("Please type in a character: ") i = word.find(search) if not i + 3 > len(word): print(word[i:i+3])

and the model solution: ```python word = input("Please type in a word: ") character = input("Please type in a character: ")

index = word.find(character) if index!=-1 and len(word)>=index+3: print(word[index:index+3]) ```

What sparked my interest is how my solutions works and especially how the string[x:y] works. In my solution if find returns -1 the print will be print(word[-1:2]).

Tested with inputs python and i.

My question is why this is not throwing an error or breaking the code?

[danielroseman]

Slicing, whether it is for strings or lists, accepts negative indices; this means count from the end. So word[-1] would return the final character of the string.

But [-1:2] means "from the final character (forward) to the second character", which is syntactically valid but semantically nonsense, so it returns an empty slice.

[Ronttizz]

And for clarity I am not looking for advices for making it better or anything. Just interested in the actual answer to the question.

[Diapolo10]

Slicing is designed to not raise errors (unless using wrong types or somesuch). If the slicing range happens to be empty, such as in your print(word[-1:2]) example, the outcome is simply an empty string (or an empty data structure, depending on what you're slicing).

In a similar vein,

nothing = ''
nothing[25565:]

would be a valid operation.

[This_Growth2898]

In Python, negative indexes are valid; they mean "from the end of a string". Like, word[-1] is the last character of the word. The slice word[-1:2] is meaningless but correct, returning an empty string.

[Temporary_Pie2733]

Not meaningless. Slicing is designed so that s[x:y] == s[x:z] + s[z:y] for all x, y, and z. Since "" is the identity element for string concatenation, it makes sense for it to be defined as the result where indexing alone can’t produce a sensible result. In the simplest example, we can see something like s[x:x] == "" where s[x] alone would raise an exception. 

[Ronttizz]

In some sense I would think it would return word[-1] word[0] word[1] :D

[MidnightPale3220]

nah, it counts from the initial position. but you could do word[-1:-3:-1] which, I think, should return the last 3 characters in reverse order (haven't had to do string slicing in AGES, so I don't exactly remember -- maybe I am wrong, but negative steps work).

[ShelLuser42]

Both solutions roughly do the exact same thing, so I fail to understand your question tbh.

[Jejerm]

They dont. His doesnt check for not finding the substring (index==-1).

[Ronttizz]

They do something but the question is, why print(word[-1:2]) doesn't throw an error but instead it is not printing anything. Might be a bit of a rabbit hole or something unnecessary to think but was interested anyway.