Python and Scheme have different philosophies when it comes to strings. Scheme strings are mutable and consist of characters, which are a separate type. By contrast, Python’s strings are immutable, and its “characters” are really strings with a length of one.
Also, Python uses both ” ” and ‘ ‘ for string literals, while Scheme only uses ” “.
Aside from that, strings can be used in these languages in ways that are very similar (as opposed to e.g. C’s strings which tend to involve memory allocation and pointer arithmetic). So in this post, I will be focusing on common string operations, and what they look like in both Python and Scheme.
In Python, all these strings operations work out of the box. In Scheme, some are provided by R5RS, while others are found in SRFI-13 (a very useful library which has a large number of non-trivial string operations), and yet others are included by Chicken (but not necessarily part of other Scheme implementations). In the examples below, I’m assuming Chicken with SRFI-13 imported.
Joining multiple strings »
Python has the very obvious + operator to concatenate two strings, something which won’t work in Scheme; (+ “a” “b”) is an error. It also has the butt-ugly str.join method to join a list of strings. Scheme has string-append (R5RS) and string-join (SRFI-13).
>>> "hello" + " " + "world"
>>> " ".join(['my', 'name', 'is', 'poison'])
'my name is poison'
> (string-append "hello" " " "world")
> (string-join '("my" "name" "is" "poison") " ")
"my name is poison"
Getting the length »
These functions are very simple, but I’m mentioning them anyway because there might be surprises here for people coming from other languages. Python uses the len() function rather than a method (like e.g. Ruby and Io do). Scheme uses string-length rather than length (which only works on lists).
> (string-length "koyaanisqatsi")
Python uses the  syntax for indexing and slicing; it also accepts negative numbers (to count from the end of the string). Scheme has string-ref and substring, which work similarly, except they don’t take negative values. (Note that string-ref returns a *character* rather than a one-length string.)
>>> s = "hello"
> (define s "hello")
> (string-ref s 0)
> (string-ref s 2)
> (substring s 1 3)
Comparing strings »
In Python, strings are compared with the usual == family of operators. Case matters; “a” does not compare equal to “A”. Scheme, on the other hand, has a number of functions to do the comparison; string=? and friends for case-sensitive comparing like in Python, and the string-ci=? family for case-insensitive comparing.
>>> "abc" == "abc"
>>> "abc" == "ABC"
>>> "b" > "a"
> (string=? "abc" "ABC")
> (string-ci=? "abc" "ABC")
> (string>? "b" "a")
SRFI-13 also provides equivalents for Python’s useful startswith() and endswith() methods:
> (string-prefix? "He" "Herbert")
> (string-suffix? "tt" "Abbott")
Changing case »
Speaks for itself. Note that R5RS defines char-upcase and char-downcase, but not string-upcase or string-downcase (those are in SRFI-13).
>>> "kibbles and bits".upper()
'KIBBLES AND BITS'
>>> "KIBBLES AND BITS".lower()
'kibbles and bits'
>>> "kibbles and bits".capitalize()
'Kibbles and bits'
>>> "kibbles and bits".title()
'Kibbles And Bits'
> (string-upcase "kibbles and bits")
"KIBBLES AND BITS"
> (string-downcase "KIBBLES AND BITS")
"kibbles and bits"
> (string-titlecase "kibbles and bits")
"Kibbles And Bits"
Splitting a string into a list of smaller strings is a common thing to do in high-level languages. Luckily, for common cases, we don’t have to resort to regular expressions. Python uses the split() method, Scheme has string-tokenize (SRFI-13) and string-split (Chicken).
>>> "a few good men".split()
['a', 'few', 'good', 'men']
['a', 'racada', 'ra']
> (string-tokenize "a few good men") ;; SRFI-13
("a" "few" "good" "men")
> (string-split "a few good men") ;; Chicken built-in
("a" "few" "good" "men")
> (string-split "abracadabra" "b")
("a" "racada" "ra")
To trim characters from the left and/or right side of a string, Python uses the lstrip (from the left), rstrip (from the right) or strip (both sides) methods. Somewhat asymmetrically, in Scheme (or, more precisely, SRFI-13) these functions are called string-trim (from the left), string-trim-right (from the right) and string-trim-both (both sides).
Both Python and Scheme allow you to specify the character(s) that need to be stripped. By default, whitespace is removed, as this seems to be the most common use case.
>>> s = " i like cookies "
'i like cookies'
'i like cookies '
' i like cookies'
> (define s " i like cookies ")
> (string-trim s)
"i like cookies "
> (string-trim-right s)
" i like cookies"
> (string-trim-both s)
"i like cookies"
> (string-trim-both "xxxhi!xxx" #\x)
In Python, you can loop over a string (using for) or turn it into a list, but what you get is essentially a list of strings with length one. In Scheme, you get characters. Use string->list to get a list of characters, and string-map to map one string to another (much like the regular map, but it takes and returns a string).
>>> for c in "hello": print c,
h e l l o
['h', 'e', 'l', 'l', 'o']
> (string->list "hello")
(#\h #\e #\l #\l #\o)
> (lambda (c) (printf "~a! " c))
> (string->list "hello"))
h! e! l! l! o!
> (string-map char-upcase "hello")
Python has several ways to search strings for contents… like the find/rfind methods (and their index/rindex counterparts) to find the index of a matching substring, and the in operator if you just want to know if a string has a certain substring, but don’t need to know where exactly it starts.
You can do the same things in Scheme, assuming you use SRFI-13, as R5RS does not define any of this. string-index searches for a character (or a character set or a predicate), string-contains searches for a substring. When found, it returns the index, otherwise #f (which is useful because it allows one to write (if (string-contains s1 s2) …)).
>>> "lemon-flavored jellibeans".find("e")
>>> "lemon-flavored jellibeans".rfind("e")
>>> "lemon-flavored jellibeans".find("el")
>>> "lemon-flavored jellibeans".find("xyz")
>>> "el" in "lemon-flavored jellibeans"
> (string-index "lemon-flavored jellibeans" #\e)
> (string-index-right "lemon-flavored jellibeans" #\e)
> (string-contains "lemon-flavored jellibeans" "el")
> (string-contains "lemon-flavored jellibeans" "xyz")
Python’s replace() method is very easy: simply specify the substring that needs to be replaced, and its replacement. By contrast, SRFI-13′s string-replace is more sophisticated. It takes a string, a replacement string, and start/end indices that indicate what part of the string needs replaced. See the example below.
>>> "I like cookies".replace("cookie", "hot dog")
'I like hot dogs'
> (string-replace "i like cookies" "hot dog" 7 13)
"i like hot dogs"
I don’t know if there’s a version that is easier to use floating around somewhere (in a SRFI or otherwise), but it’s not so hard to write something that emulates the Python behavior:
(define (string-replace-v2 s before after)
(let ((idx (string-contains s before)))
(string-replace s after idx (+ idx (string-length before)))
Also, Chicken has string-translate*, which works for our purposes, but is used with a table of elements to be replaced:
> (string-translate* "i like cookies"
> '(("cookie" . "hot dog")))
"i like hot dogs"
This has become a long post, longer than I intended, and there are still many things I haven’t even touched upon yet… like Unicode, or the fact that some of the aforementioned functions have equivalents that change the string in-place, rather than returning a new string. Anyway, this wasn’t meant to be a complete reference; it’s more of a starting point, or a quick way to look up “I can do X in Python, how do I do it in Scheme?”