在 Python 函数中使用递归输出元组列表

Question

I'm very new to python and would kindly appreciate any help.Basically im inputting a string and returning the string "encoded" if you like. I'm having problems however with my function, i don't know where i'm going wrong.

def encode_it(x):
    output = []
    counter = 1
    while x[0] != x[-1]:
        if x[0] == x[1]:
            counter += 1
            return encode_it(x[1:])
        else:
            output += (x[0],counter)
            counter = 1
            return encode_it(x[1:])

    return output

the result i want is this:

>>>encode_it("qqqqppttyl")
[("q",4),("p",2),("t",2),("y",1),("l",1)]

I would really appreciate any help, I'm just learning python and trying my hand at recursion, if there was even an easier way of doing this without recursion i'd be really grateful :)

Thanks guys!! in response to L3viathan's code , i modified it so it would output the result but it doesnt add the last character to the list:

def encode_it(x):
last_char = None
num = 0
result = []
for char in x:
    t = ( )
    if last_char == char:
        num += 1
    else:
        if last_char:
            t += last_char,num
            result += t
        last_char = char
        num = 1
return result 

if i was to call encode_it("qqqeerrw"), the result i would get is:

['q', 3, 'e', 2, 'r', 2] #it's leaving out the w here?

also, the reason i have an empty tuple 't' and an empty list 'result' is because, i want each character to be in its own tuple with its count...like so:

[("q",3),("e",2),("r",2),("w",1)]

Answer 1

This task is easily done by itertools.groupby :

def encode_it(txt):
    return ((c, len(tuple(grp))) for c, grp in itertools.groupby(txt))

Then:

>>> list(encode_it("qqqqppttyl"))
[('q', 4), ('p', 2), ('t', 2), ('y', 1)]

Answer 2

One of the issues of your code is that output is reinitialized as an empty list on every recursive call. In the final case, when you're through the complete string, the newly created empty list is returned (and then also handed back through all of the recursive calls).

---

This is a solution without recursion, as a generator:

def encode_it(x):
    last_char = None
    num = 0
    for char in x:
        if last_char == char:
            num += 1
        else:
            if last_char:
                yield (last_char, num)
            last_char = char
            num = 1

Usage:

>>> list(encode_it("qqqqppttyl"))
[('q', 4), ('p', 2), ('t', 2), ('y', 1)]

---

The way this works is by iterating over the string, and testing whether the current character is the same as the one saved in last_char . If so, we just increment a counter. If it isn't, we yield the tuple of the last character along with its count, and set new values for last_char and num .

A generator doesn't return a list, but instead a generator object, so to turn it into a list, you can call list() on it.

Answer 3

A simple recursive (as it was asked) solution to the problem:

def encode_it(x):
    if not x:  # base case: empty string
        return []
    i, c = 1, x[0] 
    while i < len(x) and c == x[i]:
        i += 1
    return [(c, i)] + encode_it(x[i:])

Answer 4

You can easily without recursion using the count method and a single line for loop.

def encode_it(x):
   return [(char,x.count(char)) for char in x]

list.count(x) return the number of times x appears in the list.

Answer 5

A messy one-liner:

def encode_it(x):
    return [(c,x.count(c,i,next((i for i, v in enumerate(x) if v != c), -1))) for i, c in enumerate(x) if x.index(c) == i]

Answer 6

Below solution will also work if same character are not in sequence also, without using recursion function.

For Example given string is something

>>>groupBy("qqqqqq1212")
[('q', 6), ('1', 2), ('2', 2)]

or

>>>groupBy("qqqqqq1212tytl")
[('y', 1), ('q', 6), ('1', 2), ('l', 1), ('t', 2), ('2', 2)]

Program without recursion function

str = "qqqqqq1212tytl"

def groupBy(str):
   result = []
   count = {}
   for c in str:
      if c in count:
          count[c] += 1
      else:
          count[c] = 1

   for key in count:
      if count[key] >= 1:
          result +=  [(key, count[key])]            

   return result           


print(groupBy(str))

Please let me know, how can it be better coded by use of recursive function?