slices to the rescue :)

def left(s, amount):
    return s[:amount]

def right(s, amount):
    return s[-amount:]

def mid(s, offset, amount):
    return s[offset:offset+amount]

You can return a mutable object, such as a one-element list:

a = [None]

def foo():
    return a

foo()[0] = "hello"

print(a)  # prints "hello"

However, this is not necessarily idiomatic Python: Python functions usually pass objects around instead of memory buffers, so there might be a better way to solve your actual problem. It also can't directly emulate your foo and foo2 functions. There are ways to do that as well, but they tend to be even uglier than the previous code snippet.

You're looking for slicing:

>>> s = "Hello World!"
>>> print s[2:] # From the second (third) letter, print the whole string
llo World!
>>> print s[2:5] # Print from the second (third) letter to the fifth string
llo
>>> print s[-2:] # Print from right to left
d!
>>> print s[::2] # Print every second letter
HloWrd

So for your example:

>>> s = 'col555'
>>> print s[3:]
555

You can use int.bitlength to get the number of bits required to represent the number, then and the result of the shift with (1 << bitlength) - 1 to restrict the result to that many bits:

def lls_const_bits(n):
    return (n << 1) & ((1 << n.bit_length()) - 1)

print(lls_const_bits(100))

Output:

72

If you want to restrict the output to a fixed number of bits b, you would need to mask with (1 << b) - 1:

def lls_const_bits(n, b):
    return (n << 1) & ((1 << b) - 1)

print(lls_const_bits(100, 7))

Output:

72

rsplit and join could be used to simulate the effects of an rreplace

>>> 'XXX'.join('mississippi'.rsplit('iss', 1))
'missXXXippi'

You'd mask the resulting value, with & bitwise AND:

mask = 2 ** 16 - 1
k = (i << j) & mask

Here 16 is your desired bit width; you could use i.bit_length() to limit it to the minimum required size of i, but that'd mean that any left shift would drop bits.

The mask forms a series of 1 bits the same width as the original value; the & operation sets any bits to 0 outside of these:

>>> 0b1010 & 0b111
2
>>> format(0b1010 & 0b111, '04b')
'0010'

Some side notes:

• You are left shifting, not right shifting.

• You appear to have forgotten to a d in your debug print:

  print "%d left shift %d gives" % (i,j)
  

  There was a lone % there that combined with the g for gives to make %g (floating point formatting).

• You can use:

  def showbits(x):
      return format(x, '016b')
  

  to format an integer to a 0-padded 16-character wide binary representation without the 0b prefix.

this code will work. I assume you already have a function got getting links. I have just used a dummy one _get_links. You will have to delete the content of links file and need to put 0 in index file after every successful run.

import time

def _get_links():
    return ["a", "b", "c"]

def _get_links_from_file():
    with open("links") as file:
        return file.read().split(",")


def _do_something(link):
    print(link)
    time.sleep(30)

def _save_links_to_file(links):
    with open("links", "w") as file:
        file.write(",".join(links))
    print("links saved")

def _save_index_to_file(index):
    with open("index", "w") as file:
        file.write(str(index))
    print("index saved")

def _get_index_from_file():
    with open("index",) as file:
        return int(file.read().strip())


def process_links():
    links=_get_links_from_file()
    if len(links) == 0:
        links = _get_links()
        _save_links_to_file(links)
    else:
        links = _get_links_from_file()[_get_index_from_file():]


    for index, link in enumerate(links):
        _do_something(link)
        _save_index_to_file(index+1)

if __name__ == '__main__':
    process_links()

This is a bug in limit computation; if you haven't encountered such bugs before, it just means you haven't given SymPy sufficiently complicated limits. Non-analytic, piecewise defined functions like abs and sign give a lot of trouble to SymPy's algorithm which is based on series expansions. It sometimes manages the correct answer, sometimes gives a wrong answer, and sometimes no answer at all.

When sign(something) does not work, it is reasonable to try something/Abs(something), which is mathematically equivalent but might work better (or worse) in SymPy.

f = sp.cos(sp.pi/x) / sp.Abs(sp.cos(sp.pi/x))
sp.limit(f, x, 2, '-')

does not raise any exceptions and promptly returns an answer: 1. Unfortunately, the answer is wrong...

If the problem is made simpler by replacing pi/x with a symbol y (which now approaches pi/2 from the right), then SymPy gets the correct answer:

y = sp.symbols('y')
f = sp.cos(y) / sp.Abs(sp.cos(y))
sp.limit(f, y, sp.pi/2, '+')  

returns -1.

Starting with bisect, one use (as shown here) is to find an index into one list that can be used to dereference a related list:

from bisect import bisect

def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
    i = bisect(breakpoints, score)
    return grades[i]

grades = [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]
print(grades)

Output:

['F', 'A', 'C', 'C', 'B', 'A', 'A']

bisect_left operates the same way as bisect but in the case of a "tie" it will return the index to the "left" of the match (e.g., a score of 70 in the above example would map to "D" using bisect_left)

First two letters for each value in a column:

>>> df['StateInitial'] = df['state'].str[:2]
>>> df
   pop       state  year StateInitial
0  1.5    Auckland  2000           Au
1  1.7       Otago  2001           Ot
2  3.6  Wellington  2002           We
3  2.4     Dunedin  2001           Du
4  2.9    Hamilton  2002           Ha

For last two that would be df['state'].str[-2:]. Don't know what exactly you want for middle, but you can apply arbitrary function to a column with apply method:

>>> df['state'].apply(lambda x: x[len(x)/2-1:len(x)/2+1])
0    kl
1    ta
2    in
3    ne
4    il