diff --git a/pymysql/__init__.py b/pymysql/__init__.py
index 29e6b87c..1e126dcd 100644
--- a/pymysql/__init__.py
+++ b/pymysql/__init__.py
@@ -23,7 +23,6 @@
 """
 import sys
 
-from ._compat import PY2
 from .constants import FIELD_TYPE
 from .converters import escape_dict, escape_sequence, escape_string
 from .err import (
@@ -79,10 +78,7 @@ def __hash__(self):
 
 def Binary(x):
     """Return x as a binary type."""
-    if PY2:
-        return bytearray(x)
-    else:
-        return bytes(x)
+    return bytes(x)
 
 
 def Connect(*args, **kwargs):
diff --git a/pymysql/_auth.py b/pymysql/_auth.py
index 57f9abb1..77caeafd 100644
--- a/pymysql/_auth.py
+++ b/pymysql/_auth.py
@@ -1,7 +1,6 @@
 """
 Implements auth methods
 """
-from ._compat import PY2
 from .err import OperationalError
 from .util import byte2int, int2byte
 
@@ -46,8 +45,6 @@ def scramble_native_password(password, message):
 
 def _my_crypt(message1, message2):
     result = bytearray(message1)
-    if PY2:
-        message2 = bytearray(message2)
 
     for i in range(len(result)):
         result[i] ^= message2[i]
@@ -61,7 +58,7 @@ def _my_crypt(message1, message2):
 SCRAMBLE_LENGTH_323 = 8
 
 
-class RandStruct_323(object):
+class RandStruct_323:
 
     def __init__(self, seed1, seed2):
         self.max_value = 0x3FFFFFFF
@@ -188,7 +185,7 @@ def _xor_password(password, salt):
     # See https://github.com/mysql/mysql-server/blob/7d10c82196c8e45554f27c00681474a9fb86d137/sql/auth/sha2_password.cc#L939-L945
     salt = salt[:SCRAMBLE_LENGTH]
     password_bytes = bytearray(password)
-    salt = bytearray(salt)  # for PY2 compat.
+    #salt = bytearray(salt)  # for PY2 compat.
     salt_len = len(salt)
     for i in range(len(password_bytes)):
         password_bytes[i] ^= salt[i % salt_len]
@@ -259,8 +256,6 @@ def scramble_caching_sha2(password, nonce):
     p3 = hashlib.sha256(p2 + nonce).digest()
 
     res = bytearray(p1)
-    if PY2:
-        p3 = bytearray(p3)
     for i in range(len(p3)):
         res[i] ^= p3[i]
 
diff --git a/pymysql/_compat.py b/pymysql/_compat.py
deleted file mode 100644
index 252789ec..00000000
--- a/pymysql/_compat.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import sys
-
-PY2 = sys.version_info[0] == 2
-PYPY = hasattr(sys, 'pypy_translation_info')
-JYTHON = sys.platform.startswith('java')
-IRONPYTHON = sys.platform == 'cli'
-CPYTHON = not PYPY and not JYTHON and not IRONPYTHON
-
-if PY2:
-    import __builtin__
-    range_type = xrange
-    text_type = unicode
-    long_type = long
-    str_type = basestring
-    unichr = __builtin__.unichr
-else:
-    range_type = range
-    text_type = str
-    long_type = int
-    str_type = str
-    unichr = chr
diff --git a/pymysql/charset.py b/pymysql/charset.py
index d3ced67c..3ef3ea46 100644
--- a/pymysql/charset.py
+++ b/pymysql/charset.py
@@ -6,7 +6,7 @@
         }
 
 
-class Charset(object):
+class Charset:
     def __init__(self, id, name, collation, is_default):
         self.id, self.name, self.collation = id, name, collation
         self.is_default = is_default == 'Yes'
diff --git a/pymysql/connections.py b/pymysql/connections.py
index 9e87e0b0..abc59345 100644
--- a/pymysql/connections.py
+++ b/pymysql/connections.py
@@ -2,11 +2,7 @@
 # http://dev.mysql.com/doc/internals/en/client-server-protocol.html
 # Error codes:
 # https://dev.mysql.com/doc/refman/5.5/en/error-handling.html
-from __future__ import print_function
-from ._compat import PY2, range_type, text_type, str_type, JYTHON, IRONPYTHON
-
 import errno
-import io
 import os
 import socket
 import struct
@@ -47,32 +43,11 @@
 
 _py_version = sys.version_info[:2]
 
-if PY2:
-    pass
-elif _py_version < (3, 6):
-    # See http://bugs.python.org/issue24870
-    _surrogateescape_table = [chr(i) if i < 0x80 else chr(i + 0xdc00) for i in range(256)]
-
-    def _fast_surrogateescape(s):
-        return s.decode('latin1').translate(_surrogateescape_table)
-else:
-    def _fast_surrogateescape(s):
-        return s.decode('ascii', 'surrogateescape')
-
-# socket.makefile() in Python 2 is not usable because very inefficient and
-# bad behavior about timeout.
-# XXX: ._socketio doesn't work under IronPython.
-if PY2 and not IRONPYTHON:
-    # read method of file-like returned by sock.makefile() is very slow.
-    # So we copy io-based one from Python 3.
-    from ._socketio import SocketIO
-
-    def _makefile(sock, mode):
-        return io.BufferedReader(SocketIO(sock, mode))
-else:
-    # socket.makefile in Python 3 is nice.
-    def _makefile(sock, mode):
-        return sock.makefile(mode)
+def _fast_surrogateescape(s):
+    return s.decode('ascii', 'surrogateescape')
+
+def _makefile(sock, mode):
+    return sock.makefile(mode)
 
 
 TEXT_TYPES = {
@@ -113,7 +88,7 @@ def lenenc_int(i):
         raise ValueError("Encoding %x is larger than %x - no representation in LengthEncodedInteger" % (i, (1 << 64)))
 
 
-class Connection(object):
+class Connection:
     """
     Representation of a socket with a mysql server.
 
@@ -258,7 +233,7 @@ def _config(key, arg):
             raise ValueError("port should be of type int")
         self.user = user or DEFAULT_USER
         self.password = password or b""
-        if isinstance(self.password, text_type):
+        if isinstance(self.password, str):
             self.password = self.password.encode('latin1')
         self.db = database
         self.unix_socket = unix_socket
@@ -459,7 +434,7 @@ def escape(self, obj, mapping=None):
 
         Non-standard, for internal use; do not use this in your applications.
         """
-        if isinstance(obj, str_type):
+        if isinstance(obj, str):
             return "'" + self.escape_string(obj) + "'"
         if isinstance(obj, (bytes, bytearray)):
             ret = self._quote_bytes(obj)
@@ -503,11 +478,8 @@ def cursor(self, cursor=None):
     def query(self, sql, unbuffered=False):
         # if DEBUG:
         #     print("DEBUG: sending query:", sql)
-        if isinstance(sql, text_type) and not (JYTHON or IRONPYTHON):
-            if PY2:
-                sql = sql.encode(self.encoding)
-            else:
-                sql = sql.encode(self.encoding, 'surrogateescape')
+        if isinstance(sql, str):
+            sql = sql.encode(self.encoding, 'surrogateescape')
         self._execute_command(COMMAND.COM_QUERY, sql)
         self._affected_rows = self._read_query_result(unbuffered=unbuffered)
         return self._affected_rows
@@ -758,7 +730,7 @@ def _execute_command(self, command, sql):
                 self.next_result()
             self._result = None
 
-        if isinstance(sql, text_type):
+        if isinstance(sql, str):
             sql = sql.encode(self.encoding)
 
         packet_size = min(MAX_PACKET_LEN, len(sql) + 1)  # +1 is for command
@@ -791,7 +763,7 @@ def _request_authentication(self):
             raise ValueError("Did not specify a username")
 
         charset_id = charset_by_name(self.charset).id
-        if isinstance(self.user, text_type):
+        if isinstance(self.user, str):
             self.user = self.user.encode(self.encoding)
 
         data_init = struct.pack('<iIB23s', self.client_flag, MAX_PACKET_LEN, charset_id, b'')
@@ -840,7 +812,7 @@ def _request_authentication(self):
             data += authresp + b'\0'
 
         if self.db and self.server_capabilities & CLIENT.CONNECT_WITH_DB:
-            if isinstance(self.db, text_type):
+            if isinstance(self.db, str):
                 self.db = self.db.encode(self.encoding)
             data += self.db + b'\0'
 
@@ -1049,7 +1021,7 @@ def get_server_info(self):
     NotSupportedError = err.NotSupportedError
 
 
-class MySQLResult(object):
+class MySQLResult:
 
     def __init__(self, connection):
         """
@@ -1219,7 +1191,7 @@ def _get_descriptions(self):
         conn_encoding = self.connection.encoding
         description = []
 
-        for i in range_type(self.field_count):
+        for i in range(self.field_count):
             field = self.connection._read_packet(FieldDescriptorPacket)
             self.fields.append(field)
             description.append(field.description())
@@ -1254,7 +1226,7 @@ def _get_descriptions(self):
         self.description = tuple(description)
 
 
-class LoadLocalFile(object):
+class LoadLocalFile:
     def __init__(self, filename, connection):
         self.filename = filename
         self.connection = connection
diff --git a/pymysql/converters.py b/pymysql/converters.py
index 1b582904..0e40eab7 100644
--- a/pymysql/converters.py
+++ b/pymysql/converters.py
@@ -1,5 +1,3 @@
-from ._compat import PY2, text_type, long_type, JYTHON, IRONPYTHON, unichr
-
 import datetime
 from decimal import Decimal
 import re
@@ -17,7 +15,7 @@ def escape_item(val, charset, mapping=None):
     # Fallback to default when no encoder found
     if not encoder:
         try:
-            encoder = mapping[text_type]
+            encoder = mapping[str]
         except KeyError:
             raise TypeError("no default type converter defined")
 
@@ -47,9 +45,6 @@ def escape_set(val, charset, mapping=None):
 def escape_bool(value, mapping=None):
     return str(int(value))
 
-def escape_object(value, mapping=None):
-    return str(value)
-
 def escape_int(value, mapping=None):
     return str(value)
 
@@ -61,7 +56,7 @@ def escape_float(value, mapping=None):
         s += 'e0'
     return s
 
-_escape_table = [unichr(x) for x in range(128)]
+_escape_table = [chr(x) for x in range(128)]
 _escape_table[0] = u'\\0'
 _escape_table[ord('\\')] = u'\\\\'
 _escape_table[ord('\n')] = u'\\n'
@@ -70,57 +65,21 @@ def escape_float(value, mapping=None):
 _escape_table[ord('"')] = u'\\"'
 _escape_table[ord("'")] = u"\\'"
 
-def _escape_unicode(value, mapping=None):
+def escape_string(value, mapping=None):
     """escapes *value* without adding quote.
 
     Value should be unicode
     """
     return value.translate(_escape_table)
 
-if PY2:
-    def escape_string(value, mapping=None):
-        """escape_string escapes *value* but not surround it with quotes.
-
-        Value should be bytes or unicode.
-        """
-        if isinstance(value, unicode):
-            return _escape_unicode(value)
-        assert isinstance(value, (bytes, bytearray))
-        value = value.replace('\\', '\\\\')
-        value = value.replace('\0', '\\0')
-        value = value.replace('\n', '\\n')
-        value = value.replace('\r', '\\r')
-        value = value.replace('\032', '\\Z')
-        value = value.replace("'", "\\'")
-        value = value.replace('"', '\\"')
-        return value
-
-    def escape_bytes_prefixed(value, mapping=None):
-        assert isinstance(value, (bytes, bytearray))
-        return b"_binary'%s'" % escape_string(value)
-
-    def escape_bytes(value, mapping=None):
-        assert isinstance(value, (bytes, bytearray))
-        return b"'%s'" % escape_string(value)
-
-else:
-    escape_string = _escape_unicode
-
-    # On Python ~3.5, str.decode('ascii', 'surrogateescape') is slow.
-    # (fixed in Python 3.6, http://bugs.python.org/issue24870)
-    # Workaround is str.decode('latin1') then translate 0x80-0xff into 0udc80-0udcff.
-    # We can escape special chars and surrogateescape at once.
-    _escape_bytes_table = _escape_table + [chr(i) for i in range(0xdc80, 0xdd00)]
 
-    def escape_bytes_prefixed(value, mapping=None):
-        return "_binary'%s'" % value.decode('latin1').translate(_escape_bytes_table)
+def escape_bytes_prefixed(value, mapping=None):
+    return "_binary'%s'" % value.decode('ascii', 'surrogateescape')
 
-    def escape_bytes(value, mapping=None):
-        return "'%s'" % value.decode('latin1').translate(_escape_bytes_table)
 
+def escape_bytes(value, mapping=None):
+    return "'%s'" % value.decode('ascii', 'surrogateescape')
 
-def escape_unicode(value, mapping=None):
-    return u"'%s'" % _escape_unicode(value)
 
 def escape_str(value, mapping=None):
     return "'%s'" % escape_string(str(value), mapping)
@@ -190,7 +149,7 @@ def convert_datetime(obj):
       True
 
     """
-    if not PY2 and isinstance(obj, (bytes, bytearray)):
+    if isinstance(obj, (bytes, bytearray)):
         obj = obj.decode('ascii')
 
     m = DATETIME_RE.match(obj)
@@ -224,7 +183,7 @@ def convert_timedelta(obj):
     can accept values as (+|-)DD HH:MM:SS. The latter format will not
     be parsed correctly by this function.
     """
-    if not PY2 and isinstance(obj, (bytes, bytearray)):
+    if isinstance(obj, (bytes, bytearray)):
         obj = obj.decode('ascii')
 
     m = TIMEDELTA_RE.match(obj)
@@ -272,7 +231,7 @@ def convert_time(obj):
     to be treated as time-of-day and not a time offset, then you can
     use set this function as the converter for FIELD_TYPE.TIME.
     """
-    if not PY2 and isinstance(obj, (bytes, bytearray)):
+    if isinstance(obj, (bytes, bytearray)):
         obj = obj.decode('ascii')
 
     m = TIME_RE.match(obj)
@@ -303,7 +262,7 @@ def convert_date(obj):
       True
 
     """
-    if not PY2 and isinstance(obj, (bytes, bytearray)):
+    if isinstance(obj, (bytes, bytearray)):
         obj = obj.decode('ascii')
     try:
         return datetime.date(*[ int(x) for x in obj.split('-', 2) ])
@@ -327,10 +286,9 @@ def through(x):
 encoders = {
     bool: escape_bool,
     int: escape_int,
-    long_type: escape_int,
     float: escape_float,
     str: escape_str,
-    text_type: escape_unicode,
+    bytes: escape_bytes,
     tuple: escape_sequence,
     list: escape_sequence,
     set: escape_sequence,
@@ -345,8 +303,6 @@ def through(x):
     Decimal: Decimal2Literal,
 }
 
-if not PY2 or JYTHON or IRONPYTHON:
-    encoders[bytes] = escape_bytes
 
 decoders = {
     FIELD_TYPE.BIT: convert_bit,
diff --git a/pymysql/cursors.py b/pymysql/cursors.py
index 033b5e7f..6f72ba35 100644
--- a/pymysql/cursors.py
+++ b/pymysql/cursors.py
@@ -1,9 +1,5 @@
-# -*- coding: utf-8 -*-
-from __future__ import print_function, absolute_import
-from functools import partial
 import re
 
-from ._compat import range_type, text_type, PY2
 from . import err
 
 
@@ -17,7 +13,7 @@
     re.IGNORECASE | re.DOTALL)
 
 
-class Cursor(object):
+class Cursor:
     """
     This is the object you use to interact with the database.
 
@@ -100,29 +96,20 @@ def nextset(self):
         return self._nextset(False)
 
     def _ensure_bytes(self, x, encoding=None):
-        if isinstance(x, text_type):
+        if isinstance(x, str):
             x = x.encode(encoding)
         elif isinstance(x, (tuple, list)):
             x = type(x)(self._ensure_bytes(v, encoding=encoding) for v in x)
         return x
 
     def _escape_args(self, args, conn):
-        ensure_bytes = partial(self._ensure_bytes, encoding=conn.encoding)
-
         if isinstance(args, (tuple, list)):
-            if PY2:
-                args = tuple(map(ensure_bytes, args))
             return tuple(conn.literal(arg) for arg in args)
         elif isinstance(args, dict):
-            if PY2:
-                args = {ensure_bytes(key): ensure_bytes(val) for
-                        (key, val) in args.items()}
             return {key: conn.literal(val) for (key, val) in args.items()}
         else:
             # If it's not a dictionary let's try escaping it anyways.
             # Worst case it will throw a Value error
-            if PY2:
-                args = ensure_bytes(args)
             return conn.escape(args)
 
     def mogrify(self, query, args=None):
@@ -133,8 +120,6 @@ def mogrify(self, query, args=None):
         This method follows the extension to the DB API 2.0 followed by Psycopg.
         """
         conn = self._get_db()
-        if PY2:  # Use bytes on Python 2 always
-            query = self._ensure_bytes(query, encoding=conn.encoding)
 
         if args is not None:
             query = query % self._escape_args(args, conn)
@@ -195,29 +180,21 @@ def executemany(self, query, args):
     def _do_execute_many(self, prefix, values, postfix, args, max_stmt_length, encoding):
         conn = self._get_db()
         escape = self._escape_args
-        if isinstance(prefix, text_type):
+        if isinstance(prefix, str):
             prefix = prefix.encode(encoding)
-        if PY2 and isinstance(values, text_type):
-            values = values.encode(encoding)
-        if isinstance(postfix, text_type):
+        if isinstance(postfix, str):
             postfix = postfix.encode(encoding)
         sql = bytearray(prefix)
         args = iter(args)
         v = values % escape(next(args), conn)
-        if isinstance(v, text_type):
-            if PY2:
-                v = v.encode(encoding)
-            else:
-                v = v.encode(encoding, 'surrogateescape')
+        if isinstance(v, str):
+            v = v.encode(encoding, 'surrogateescape')
         sql += v
         rows = 0
         for arg in args:
             v = values % escape(arg, conn)
-            if isinstance(v, text_type):
-                if PY2:
-                    v = v.encode(encoding)
-                else:
-                    v = v.encode(encoding, 'surrogateescape')
+            if isinstance(v, str):
+                v = v.encode(encoding, 'surrogateescape')
             if len(sql) + len(v) + len(postfix) + 1 > max_stmt_length:
                 rows += self.execute(sql + postfix)
                 sql = bytearray(prefix)
@@ -265,7 +242,7 @@ def callproc(self, procname, args=()):
 
         q = "CALL %s(%s)" % (procname,
                              ','.join(['@_%s_%d' % (procname, i)
-                                       for i in range_type(len(args))]))
+                                       for i in range(len(args))]))
         self._query(q)
         self._executed = q
         return args
@@ -356,7 +333,7 @@ def __iter__(self):
     NotSupportedError = err.NotSupportedError
 
 
-class DictCursorMixin(object):
+class DictCursorMixin:
     # You can override this to use OrderedDict or other dict-like types.
     dict_type = dict
 
@@ -469,7 +446,7 @@ def fetchmany(self, size=None):
             size = self.arraysize
 
         rows = []
-        for i in range_type(size):
+        for i in range(size):
             row = self.read_next()
             if row is None:
                 break
@@ -485,7 +462,7 @@ def scroll(self, value, mode='relative'):
                 raise err.NotSupportedError(
                         "Backwards scrolling not supported by this cursor")
 
-            for _ in range_type(value):
+            for _ in range(value):
                 self.read_next()
             self.rownumber += value
         elif mode == 'absolute':
@@ -494,7 +471,7 @@ def scroll(self, value, mode='relative'):
                     "Backwards scrolling not supported by this cursor")
 
             end = value - self.rownumber
-            for _ in range_type(end):
+            for _ in range(end):
                 self.read_next()
             self.rownumber = value
         else:
diff --git a/pymysql/optionfile.py b/pymysql/optionfile.py
index 91e2dfe3..79810ef3 100644
--- a/pymysql/optionfile.py
+++ b/pymysql/optionfile.py
@@ -1,9 +1,4 @@
-from ._compat import PY2
-
-if PY2:
-    import ConfigParser as configparser
-else:
-    import configparser
+import configparser
 
 
 class Parser(configparser.RawConfigParser):
diff --git a/pymysql/protocol.py b/pymysql/protocol.py
index e302edab..541475ad 100644
--- a/pymysql/protocol.py
+++ b/pymysql/protocol.py
@@ -1,9 +1,7 @@
 # Python implementation of low level MySQL client-server protocol
 # http://dev.mysql.com/doc/internals/en/client-server-protocol.html
 
-from __future__ import print_function
 from .charset import MBLENGTH
-from ._compat import PY2, range_type
 from .constants import FIELD_TYPE, SERVER_STATUS
 from . import err
 from .util import byte2int
@@ -37,7 +35,7 @@ def printable(data):
         print("-" * 66)
     except ValueError:
         pass
-    dump_data = [data[i:i+16] for i in range_type(0, min(len(data), 256), 16)]
+    dump_data = [data[i:i+16] for i in range(0, min(len(data), 256), 16)]
     for d in dump_data:
         print(' '.join("{:02X}".format(byte2int(x)) for x in d) +
               '   ' * (16 - len(d)) + ' ' * 2 +
@@ -46,7 +44,7 @@ def printable(data):
     print()
 
 
-class MysqlPacket(object):
+class MysqlPacket:
     """Representation of a MySQL response packet.
 
     Provides an interface for reading/parsing the packet results.
@@ -108,16 +106,10 @@ def get_bytes(self, position, length=1):
         """
         return self._data[position:(position+length)]
 
-    if PY2:
-        def read_uint8(self):
-            result = ord(self._data[self._position])
-            self._position += 1
-            return result
-    else:
-        def read_uint8(self):
-            result = self._data[self._position]
-            self._position += 1
-            return result
+    def read_uint8(self):
+        result = self._data[self._position]
+        self._position += 1
+        return result
 
     def read_uint16(self):
         result = struct.unpack_from('<H', self._data, self._position)[0]
@@ -276,7 +268,7 @@ def __str__(self):
                    self.type_code, self.flags))
 
 
-class OKPacketWrapper(object):
+class OKPacketWrapper:
     """
     OK Packet Wrapper. It uses an existing packet object, and wraps
     around it, exposing useful variables while still providing access
@@ -301,7 +293,7 @@ def __getattr__(self, key):
         return getattr(self.packet, key)
 
 
-class EOFPacketWrapper(object):
+class EOFPacketWrapper:
     """
     EOF Packet Wrapper. It uses an existing packet object, and wraps
     around it, exposing useful variables while still providing access
@@ -323,7 +315,7 @@ def __getattr__(self, key):
         return getattr(self.packet, key)
 
 
-class LoadLocalPacketWrapper(object):
+class LoadLocalPacketWrapper:
     """
     Load Local Packet Wrapper. It uses an existing packet object, and wraps
     around it, exposing useful variables while still providing access
diff --git a/pymysql/tests/base.py b/pymysql/tests/base.py
index 22bed9d8..16d14c03 100644
--- a/pymysql/tests/base.py
+++ b/pymysql/tests/base.py
@@ -6,27 +6,6 @@
 import unittest
 
 import pymysql
-from .._compat import CPYTHON
-
-
-if CPYTHON:
-    import atexit
-    gc.set_debug(gc.DEBUG_UNCOLLECTABLE)
-
-    @atexit.register
-    def report_uncollectable():
-        import gc
-        if not gc.garbage:
-            print("No garbages!")
-            return
-        print('uncollectable objects')
-        for obj in gc.garbage:
-            print(obj)
-            if hasattr(obj, '__dict__'):
-                print(obj.__dict__)
-            for ref in gc.get_referrers(obj):
-                print("referrer:", ref)
-            print('---')
 
 
 class PyMySQLTestCase(unittest.TestCase):
@@ -111,12 +90,3 @@ def drop_table(self, connection, tablename):
             warnings.simplefilter("ignore")
             cursor.execute("drop table if exists `%s`" % (tablename,))
         cursor.close()
-
-    def safe_gc_collect(self):
-        """Ensure cycles are collected via gc.
-
-        Runs additional times on non-CPython platforms.
-        """
-        gc.collect()
-        if not CPYTHON:
-            gc.collect()
diff --git a/pymysql/tests/test_SSCursor.py b/pymysql/tests/test_SSCursor.py
index 3bbfcfa4..2b0de78a 100644
--- a/pymysql/tests/test_SSCursor.py
+++ b/pymysql/tests/test_SSCursor.py
@@ -11,6 +11,7 @@
     import pymysql.cursors
     from pymysql.constants import CLIENT
 
+
 class TestSSCursor(base.PyMySQLTestCase):
     def test_SSCursor(self):
         affected_rows = 18446744073709551615
diff --git a/pymysql/tests/test_basic.py b/pymysql/tests/test_basic.py
index aa23e065..840c4860 100644
--- a/pymysql/tests/test_basic.py
+++ b/pymysql/tests/test_basic.py
@@ -1,4 +1,3 @@
-# coding: utf-8
 import datetime
 import json
 import time
diff --git a/pymysql/tests/test_connection.py b/pymysql/tests/test_connection.py
index 51b9f3a5..54537af7 100644
--- a/pymysql/tests/test_connection.py
+++ b/pymysql/tests/test_connection.py
@@ -4,7 +4,6 @@
 import pytest
 import pymysql
 from pymysql.tests import base
-from pymysql._compat import text_type
 from pymysql.constants import CLIENT
 
 import pytest
@@ -139,7 +138,7 @@ def realtestSocketAuth(self):
                       self.databases[0]['db'], self.socket_plugin_name) as u:
             c = pymysql.connect(user=TestAuthentication.osuser, **self.db)
 
-    class Dialog(object):
+    class Dialog:
         fail=False
 
         def __init__(self, con):
@@ -152,7 +151,7 @@ def prompt(self, echo, prompt):
                return b'bad guess at a password'
             return self.m.get(prompt)
 
-    class DialogHandler(object):
+    class DialogHandler:
 
         def __init__(self, con):
             self.con=con
@@ -174,7 +173,7 @@ def authenticate(self, pkt):
                     break
             return pkt
 
-    class DefectiveHandler(object):
+    class DefectiveHandler:
         def __init__(self, con):
             self.con=con
 
@@ -480,7 +479,7 @@ def test_defer_connect(self):
 
 
 # A custom type and function to escape it
-class Foo(object):
+class Foo:
     value = "bar"
 
 
@@ -523,7 +522,7 @@ def test_escape_fallback_encoder(self):
         class Custom(str):
             pass
 
-        mapping = {text_type: pymysql.escape_string}
+        mapping = {str: pymysql.escape_string}
         self.assertEqual(con.escape(Custom('foobar'), mapping), "'foobar'")
 
     def test_escape_no_default(self):
diff --git a/pymysql/tests/test_converters.py b/pymysql/tests/test_converters.py
index b7b5a984..c2c9b6bf 100644
--- a/pymysql/tests/test_converters.py
+++ b/pymysql/tests/test_converters.py
@@ -1,7 +1,5 @@
 import datetime
 from unittest import TestCase
-
-from pymysql._compat import PY2
 from pymysql import converters
 
 
@@ -16,13 +14,6 @@ def test_escape_string(self):
             u"foo\\nbar"
         )
 
-    if PY2:
-        def test_escape_string_bytes(self):
-            self.assertEqual(
-                converters.escape_string(b"foo\nbar"),
-                b"foo\\nbar"
-            )
-
     def test_convert_datetime(self):
         expected = datetime.datetime(2007, 2, 24, 23, 6, 20)
         dt = converters.convert_datetime('2007-02-24 23:06:20')
diff --git a/pymysql/tests/test_issues.py b/pymysql/tests/test_issues.py
index 604aeaff..2e11ddb5 100644
--- a/pymysql/tests/test_issues.py
+++ b/pymysql/tests/test_issues.py
@@ -7,16 +7,8 @@
 
 import pymysql
 from pymysql import cursors
-from pymysql._compat import text_type
 from pymysql.tests import base
 
-try:
-    import imp
-    reload = imp.reload
-except AttributeError:
-    pass
-
-
 __all__ = ["TestOldIssues", "TestNewIssues", "TestGitHubIssues"]
 
 class TestOldIssues(base.PyMySQLTestCase):
@@ -90,13 +82,6 @@ def test_issue_8(self):
         finally:
             c.execute("drop table test")
 
-    def test_issue_9(self):
-        """ sets DeprecationWarning in Python 2.6 """
-        try:
-            reload(pymysql)
-        except DeprecationWarning:
-            self.fail()
-
     def test_issue_13(self):
         """ can't handle large result fields """
         conn = self.connect()
diff --git a/pymysql/tests/test_optionfile.py b/pymysql/tests/test_optionfile.py
index 3ee519e2..81bd1fe4 100644
--- a/pymysql/tests/test_optionfile.py
+++ b/pymysql/tests/test_optionfile.py
@@ -1,11 +1,6 @@
-from pymysql.optionfile import Parser
+from io import StringIO
 from unittest import TestCase
-from pymysql._compat import PY2
-
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from io import StringIO
+from pymysql.optionfile import Parser
 
 
 __all__ = ['TestParser']
@@ -24,10 +19,7 @@ class TestParser(TestCase):
 
     def test_string(self):
         parser = Parser()
-        if PY2:
-            parser.readfp(StringIO(_cfg_file))
-        else:
-            parser.read_file(StringIO(_cfg_file))
+        parser.read_file(StringIO(_cfg_file))
         self.assertEqual(parser.get("default", "string"), "foo")
         self.assertEqual(parser.get("default", "quoted"), "bar")
         self.assertEqual(parser.get("default", "single_quoted"), "foobar")
diff --git a/pymysql/tests/thirdparty/test_MySQLdb/test_MySQLdb_nonstandard.py b/pymysql/tests/thirdparty/test_MySQLdb/test_MySQLdb_nonstandard.py
index 5c739a42..747ea4b0 100644
--- a/pymysql/tests/thirdparty/test_MySQLdb/test_MySQLdb_nonstandard.py
+++ b/pymysql/tests/thirdparty/test_MySQLdb/test_MySQLdb_nonstandard.py
@@ -5,10 +5,6 @@
 _mysql = pymysql
 from pymysql.constants import FIELD_TYPE
 from pymysql.tests import base
-from pymysql._compat import PY2, long_type
-
-if not PY2:
-    basestring = str
 
 
 class TestDBAPISet(unittest.TestCase):
@@ -34,13 +30,13 @@ def test_NULL(self):
 
     def test_version(self):
         """Version information sanity."""
-        self.assertTrue(isinstance(_mysql.__version__, basestring))
+        self.assertTrue(isinstance(_mysql.__version__, str))
 
         self.assertTrue(isinstance(_mysql.version_info, tuple))
         self.assertEqual(len(_mysql.version_info), 5)
 
     def test_client_info(self):
-        self.assertTrue(isinstance(_mysql.get_client_info(), basestring))
+        self.assertTrue(isinstance(_mysql.get_client_info(), str))
 
     def test_thread_safe(self):
         self.assertTrue(isinstance(_mysql.thread_safe(), int))
@@ -59,7 +55,7 @@ def tearDown(self):
 
     def test_thread_id(self):
         tid = self.conn.thread_id()
-        self.assertTrue(isinstance(tid, (int, long_type)),
+        self.assertTrue(isinstance(tid, int),
                         "thread_id didn't return an integral value.")
 
         self.assertRaises(TypeError, self.conn.thread_id, ('evil',),
@@ -76,23 +72,19 @@ def test_affected_rows(self):
                           #self.conn.dump_debug_info)
 
     def test_charset_name(self):
-        self.assertTrue(isinstance(self.conn.character_set_name(), basestring),
+        self.assertTrue(isinstance(self.conn.character_set_name(), str),
                         "Should return a string.")
 
     def test_host_info(self):
-        assert isinstance(self.conn.get_host_info(), basestring), "should return a string"
+        assert isinstance(self.conn.get_host_info(), str), "should return a string"
 
     def test_proto_info(self):
         self.assertTrue(isinstance(self.conn.get_proto_info(), int),
                         "Should return an int.")
 
     def test_server_info(self):
-        if sys.version_info[0] == 2:
-            self.assertTrue(isinstance(self.conn.get_server_info(), basestring),
-                            "Should return an str.")
-        else:
-            self.assertTrue(isinstance(self.conn.get_server_info(), basestring),
-                            "Should return an str.")
+        self.assertTrue(isinstance(self.conn.get_server_info(), str),
+                        "Should return an str.")
 
 if __name__ == "__main__":
     unittest.main()