Getting rid of bitwise operators in Python 3?

[mensanator at aol.com]

On Sep 21, 10:44?pm, Carl Banks <pavlovevide... at gmail.com> wrote:
> Anyone with me here?  (I know the deadline for P3 PEPs has passed; this
> is just talk.)

Are you a loony?

Python doesn't have enough bit operations.

I'm always using the gmpy module's bit functions:

    digits(...)
        digits(x[,base]): returns Python string
        representing x in the given base (2 to 36,
        default 10 if omitted or 0); leading '-'
        present if x<0, but no leading '+' if x>=0.
        x must be an mpz, or else gets coerced into one.

    getbit(...)
        getbit(x,n): returns 0 or 1, the bit-value
        of bit n of x; n must be an ordinary Python
        int, >=0; x is an mpz, or else gets coerced
        to one.

    hamdist(...)
        hamdist(x,y): returns the Hamming distance
        (number of bit-positions where the bits
        differ) between x and y.  x and y must be
        mpz, or else get coerced to mpz.

    lowbits(...)
        lowbits(x,n): returns the n lowest bits of
        x; n must be an ordinary Python int, >0;
        x must be an mpz, or else gets coerced to one.

    numdigits(...)
        numdigits(x[,base]): returns length of string
        representing x in the given base (2 to 36,
        default 10 if omitted or 0); the value returned
        may sometimes be 1 more than necessary; no
        provision for any 'sign' characte, nor leading
        '0' or '0x' decoration, is made in the returned
        length.  x must be an mpz, or else gets coerced
        into one.

    popcount(...)
        popcount(x): returns the number of 1-bits set
        in x; note that this is 'infinite' if x<0,
        and in that case, -1 is returned. x must be
        an mpz, or else gets coerced to one.

    scan0(...)
        scan0(x, n=0): returns the bit-index of the
        first 0-bit of x (that is at least n); n must
        be an ordinary Python int, >=0.  If no more
        0-bits are in x at or above bit-index n
        (which can only happen for x<0, notionally
        extended with infinite 1-bits), None is
        returned. x must be an mpz, or else gets
        coerced to one.

    scan1(...)
        scan1(x, n=0): returns the bit-index of the
        first 1-bit of x (that is at least n); n
        must be an ordinary Python int, >=0.  If no
        more 1-bits are in x at or above bit-index
        n (which can only happen for x>=0, notionally
        extended with infinite 0-bits), None is returned.
        x must be an mpz, or else gets coerced to one.

    setbit(...)
        setbit(x,n,v=1): returns a copy of the value
        of x, with bit n set to value v; n must be
        an ordinary Python int, >=0; v, 0 or !=0;
        x must be an mpz, or else gets coerced to one.

And I don't do hardware, I do math research where
things like Hamming distance, popcount and scan1
are used extensively along with Python's bit
operators like >>.

Hey, I never use classes, maybe we should get rid of
them also, eh?