diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py
index 4f43f5d..7512263 100644
--- a/Lib/test/test_code.py
+++ b/Lib/test/test_code.py
@@ -6,7 +6,7 @@
 ...     return g
 ...
 
->>> dump(f.func_code)
+>>> dump(f.__code__)
 name: f
 argcount: 1
 kwonlyargcount: 0
@@ -18,7 +18,7 @@
 flags: 3
 consts: ('None', '<code object g>')
 
->>> dump(f(4).func_code)
+>>> dump(f(4).__code__)
 name: g
 argcount: 1
 kwonlyargcount: 0
@@ -37,7 +37,7 @@
 ...     return c
 ...
 
->>> dump(h.func_code)
+>>> dump(h.__code__)
 name: h
 argcount: 2
 kwonlyargcount: 0
@@ -54,7 +54,7 @@
 ...     print(obj.attr2)
 ...     print(obj.attr3)
 
->>> dump(attrs.func_code)
+>>> dump(attrs.__code__)
 name: attrs
 argcount: 1
 kwonlyargcount: 0
@@ -72,7 +72,7 @@
 ...     53
 ...     0x53
 
->>> dump(optimize_away.func_code)
+>>> dump(optimize_away.__code__)
 name: optimize_away
 argcount: 0
 kwonlyargcount: 0
@@ -88,7 +88,7 @@
 ...     return a,b,k1
 ...
 
->>> dump(keywordonly_args.func_code)
+>>> dump(keywordonly_args.__code__)
 name: keywordonly_args
 argcount: 2
 kwonlyargcount: 1
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 1acb4a1..022f7c0 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -235,7 +235,7 @@
             g = +9223372036854775807  # 1 << 63 - 1
             h = -9223372036854775807  # 1 << 63 - 1
 
-            for variable in self.test_32_63_bit_values.func_code.co_consts:
+            for variable in self.test_32_63_bit_values.__code__.co_consts:
                 if variable is not None:
                     self.assertTrue(isinstance(variable, int))
 
@@ -315,7 +315,7 @@
             f2 = lambda x=2: x
             return f1, f2
         f1, f2 = f()
-        self.assertNotEqual(id(f1.func_code), id(f2.func_code))
+        self.assertNotEqual(id(f1.__code__), id(f2.__code__))
 
     def test_unicode_encoding(self):
         code = u"# -*- coding: utf-8 -*-\npass\n"
diff --git a/Lib/test/test_compiler.py b/Lib/test/test_compiler.py
index bbd7511..8535f42 100644
--- a/Lib/test/test_compiler.py
+++ b/Lib/test/test_compiler.py
@@ -160,7 +160,7 @@
             c = compiler.compile(sourcecode, '<string>', 'exec')
             dct = {}
             exec(c, dct)
-            self.assertEquals(dct['f'].func_annotations, expected)
+            self.assertEquals(dct['f'].__annotations__, expected)
 
     def testWith(self):
         # SF bug 1638243
diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
index cb075c3..fd6109c 100644
--- a/Lib/test/test_copy.py
+++ b/Lib/test/test_copy.py
@@ -83,7 +83,7 @@
         def f():
             pass
         tests = [None, 42, 2**100, 3.14, True, False, 1j,
-                 "hello", u"hello\u1234", f.func_code,
+                 "hello", u"hello\u1234", f.__code__,
                  NewStyle, xrange(10), Classic, max]
         for x in tests:
             self.assert_(copy.copy(x) is x, repr(x))
@@ -256,7 +256,7 @@
         def f():
             pass
         tests = [None, 42, 2**100, 3.14, True, False, 1j,
-                 "hello", u"hello\u1234", f.func_code,
+                 "hello", u"hello\u1234", f.__code__,
                  NewStyle, xrange(10), Classic, max]
         for x in tests:
             self.assert_(copy.deepcopy(x) is x, repr(x))
diff --git a/Lib/test/test_decorators.py b/Lib/test/test_decorators.py
index 56aa5e1..2558247 100644
--- a/Lib/test/test_decorators.py
+++ b/Lib/test/test_decorators.py
@@ -27,7 +27,7 @@
 def dbcheck(exprstr, globals=None, locals=None):
     "Decorator to implement debugging assertions"
     def decorate(func):
-        expr = compile(exprstr, "dbcheck-%s" % func.func_name, "eval")
+        expr = compile(exprstr, "dbcheck-%s" % func.__name__, "eval")
         def check(*args, **kwds):
             if not eval(expr, globals, locals):
                 raise DbcheckError(exprstr, func, args, kwds)
@@ -40,12 +40,12 @@
 def countcalls(counts):
     "Decorator to count calls to a function"
     def decorate(func):
-        func_name = func.func_name
+        func_name = func.__name__
         counts[func_name] = 0
         def call(*args, **kwds):
             counts[func_name] += 1
             return func(*args, **kwds)
-        call.func_name = func_name
+        call.__name__ = func_name
         return call
     return decorate
 
@@ -63,7 +63,7 @@
         except TypeError:
             # Unhashable argument
             return func(*args)
-    call.func_name = func.func_name
+    call.__name__ = func.__name__
     return call
 
 # -----------------------------------------------
@@ -131,7 +131,7 @@
         @countcalls(counts)
         def double(x):
             return x * 2
-        self.assertEqual(double.func_name, 'double')
+        self.assertEqual(double.__name__, 'double')
 
         self.assertEqual(counts, dict(double=0))
 
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index ab70778..bb8638b 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -19,8 +19,8 @@
 
  %-4d        10 LOAD_CONST               1 (1)
              13 RETURN_VALUE
-"""%(_f.func_code.co_firstlineno + 1,
-     _f.func_code.co_firstlineno + 2)
+"""%(_f.__code__.co_firstlineno + 1,
+     _f.__code__.co_firstlineno + 2)
 
 
 def bug708901():
@@ -43,9 +43,9 @@
         >>   25 POP_BLOCK
         >>   26 LOAD_CONST               0 (None)
              29 RETURN_VALUE
-"""%(bug708901.func_code.co_firstlineno + 1,
-     bug708901.func_code.co_firstlineno + 2,
-     bug708901.func_code.co_firstlineno + 3)
+"""%(bug708901.__code__.co_firstlineno + 1,
+     bug708901.__code__.co_firstlineno + 2,
+     bug708901.__code__.co_firstlineno + 3)
 
 
 def bug1333982(x=[]):
@@ -78,9 +78,9 @@
 
  %-4d        48 LOAD_CONST               0 (None)
              51 RETURN_VALUE
-"""%(bug1333982.func_code.co_firstlineno + 1,
-     bug1333982.func_code.co_firstlineno + 2,
-     bug1333982.func_code.co_firstlineno + 3)
+"""%(bug1333982.__code__.co_firstlineno + 1,
+     bug1333982.__code__.co_firstlineno + 2,
+     bug1333982.__code__.co_firstlineno + 3)
 
 _BIG_LINENO_FORMAT = """\
 %3d           0 LOAD_GLOBAL              0 (spam)
diff --git a/Lib/test/test_extcall.py b/Lib/test/test_extcall.py
index 3e0426f..453f464 100644
--- a/Lib/test/test_extcall.py
+++ b/Lib/test/test_extcall.py
@@ -274,6 +274,6 @@
         for kwargs in ['', 'a', 'd', 'ad', 'abde']:
             kwdict = {}
             for k in kwargs: kwdict[k] = k + k
-            print(func.func_name, args, sortdict(kwdict), '->', end=' ')
+            print(func.__name__, args, sortdict(kwdict), '->', end=' ')
             try: func(*args, **kwdict)
             except TypeError as err: print(err)
diff --git a/Lib/test/test_funcattrs.py b/Lib/test/test_funcattrs.py
index 2f4b67a..528ca18 100644
--- a/Lib/test/test_funcattrs.py
+++ b/Lib/test/test_funcattrs.py
@@ -47,7 +47,7 @@
 
 d = {'hello': 'world'}
 b.__dict__ = d
-if b.func_dict is not d:
+if b.__dict__ is not d:
     raise TestFailed, 'func.__dict__ assignment to dictionary failed'
 if b.hello != 'world':
     raise TestFailed, 'attribute after func.__dict__ assignment failed'
@@ -179,12 +179,12 @@
 else: raise TestFailed
 
 try:
-    del another.func_dict
+    del another.__dict__
 except TypeError: pass
 else: raise TestFailed
 
 try:
-    another.func_dict = None
+    another.__dict__ = None
 except TypeError: pass
 else: raise TestFailed
 
@@ -195,7 +195,7 @@
 
 # This isn't specifically related to function attributes, but it does test a
 # core dump regression in funcobject.c
-del another.func_defaults
+del another.__defaults__
 
 def foo():
     pass
@@ -212,7 +212,7 @@
 d={}
 d[foo] = 1
 
-foo.func_code = temp.func_code
+foo.__code__ = temp.__code__
 
 d[foo]
 
@@ -236,45 +236,31 @@
 def test_func_closure():
     a = 12
     def f(): print(a)
-    c = f.func_closure
+    c = f.__closure__
     verify(isinstance(c, tuple))
     verify(len(c) == 1)
     verify(c[0].__class__.__name__ == "cell") # don't have a type object handy
-    cantset(f, "func_closure", c)
+    cantset(f, "__closure__", c)
 
 def test_func_doc():
     def f(): pass
     verify(f.__doc__ is None)
-    verify(f.func_doc is None)
     f.__doc__ = "hello"
     verify(f.__doc__ == "hello")
-    verify(f.func_doc == "hello")
     del f.__doc__
     verify(f.__doc__ is None)
-    verify(f.func_doc is None)
-    f.func_doc = "world"
-    verify(f.__doc__ == "world")
-    verify(f.func_doc == "world")
-    del f.func_doc
-    verify(f.func_doc is None)
-    verify(f.__doc__ is None)
 
 def test_func_globals():
     def f(): pass
-    verify(f.func_globals is globals())
-    cantset(f, "func_globals", globals())
+    verify(f.__globals__ is globals())
+    cantset(f, "__globals__", globals())
 
 def test_func_name():
     def f(): pass
     verify(f.__name__ == "f")
-    verify(f.func_name == "f")
     f.__name__ = "g"
     verify(f.__name__ == "g")
-    verify(f.func_name == "g")
-    f.func_name = "h"
-    verify(f.__name__ == "h")
-    verify(f.func_name == "h")
-    cantset(f, "func_globals", 1)
+    cantset(f, "__globals__", 1)
     cantset(f, "__name__", 1)
     # test that you can access func.__name__ in restricted mode
     s = """def f(): pass\nf.__name__"""
@@ -288,25 +274,25 @@
     def f1(): print(a)
     def g1(): print(b)
     def f2(): print(a, b)
-    verify(type(f.func_code) is types.CodeType)
-    f.func_code = g.func_code
-    cantset(f, "func_code", None)
+    verify(type(f.__code__) is types.CodeType)
+    f.__code__ = g.__code__
+    cantset(f, "__code__", None)
     # can't change the number of free vars
-    cantset(f,  "func_code", f1.func_code, exception=ValueError)
-    cantset(f1, "func_code",  f.func_code, exception=ValueError)
-    cantset(f1, "func_code", f2.func_code, exception=ValueError)
-    f1.func_code = g1.func_code
+    cantset(f,  "__code__", f1.__code__, exception=ValueError)
+    cantset(f1, "__code__",  f.__code__, exception=ValueError)
+    cantset(f1, "__code__", f2.__code__, exception=ValueError)
+    f1.__code__ = g1.__code__
 
 def test_func_defaults():
     def f(a, b): return (a, b)
-    verify(f.func_defaults is None)
-    f.func_defaults = (1, 2)
-    verify(f.func_defaults == (1, 2))
+    verify(f.__defaults__ is None)
+    f.__defaults__ = (1, 2)
+    verify(f.__defaults__ == (1, 2))
     verify(f(10) == (10, 2))
     def g(a=1, b=2): return (a, b)
-    verify(g.func_defaults == (1, 2))
-    del g.func_defaults
-    verify(g.func_defaults is None)
+    verify(g.__defaults__ == (1, 2))
+    del g.__defaults__
+    verify(g.__defaults__ is None)
     try:
         g()
     except TypeError:
@@ -317,18 +303,13 @@
 def test_func_dict():
     def f(): pass
     a = f.__dict__
-    b = f.func_dict
     verify(a == {})
-    verify(a is b)
     f.hello = 'world'
     verify(a == {'hello': 'world'})
-    verify(f.func_dict is a is f.__dict__)
-    f.func_dict = {}
-    verify(not hasattr(f, "hello"))
+    verify(a is f.__dict__)
     f.__dict__ = {'world': 'hello'}
     verify(f.world == "hello")
-    verify(f.__dict__ is f.func_dict == {'world': 'hello'})
-    cantset(f, "func_dict", None)
+    verify(f.__dict__ == {'world': 'hello'})
     cantset(f, "__dict__", None)
 
 def test_im_class():
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index 4a480aa..cb37021 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -162,18 +162,18 @@
         def f3(two, arguments): pass
         def f4(two, (compound, (argument, list))): pass
         def f5((compound, first), two): pass
-        self.assertEquals(f2.func_code.co_varnames, ('one_argument',))
-        self.assertEquals(f3.func_code.co_varnames, ('two', 'arguments'))
+        self.assertEquals(f2.__code__.co_varnames, ('one_argument',))
+        self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments'))
         if sys.platform.startswith('java'):
-            self.assertEquals(f4.func_code.co_varnames,
+            self.assertEquals(f4.__code__.co_varnames,
                    ('two', '(compound, (argument, list))', 'compound', 'argument',
                                 'list',))
-            self.assertEquals(f5.func_code.co_varnames,
+            self.assertEquals(f5.__code__.co_varnames,
                    ('(compound, first)', 'two', 'compound', 'first'))
         else:
-            self.assertEquals(f4.func_code.co_varnames,
+            self.assertEquals(f4.__code__.co_varnames,
                   ('two', '.1', 'compound', 'argument',  'list'))
-            self.assertEquals(f5.func_code.co_varnames,
+            self.assertEquals(f5.__code__.co_varnames,
                   ('.0', 'two', 'compound', 'first'))
         def a1(one_arg,): pass
         def a2(two, args,): pass
@@ -209,9 +209,9 @@
         # ceval unpacks the formal arguments into the first argcount names;
         # thus, the names nested inside tuples must appear after these names.
         if sys.platform.startswith('java'):
-            self.assertEquals(v3.func_code.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c'))
+            self.assertEquals(v3.__code__.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c'))
         else:
-            self.assertEquals(v3.func_code.co_varnames, ('a', '.1', 'rest', 'b', 'c'))
+            self.assertEquals(v3.__code__.co_varnames, ('a', '.1', 'rest', 'b', 'c'))
         self.assertEquals(v3(1, (2, 3), 4), (1, 2, 3, (4,)))
         def d01(a=1): pass
         d01()
@@ -302,23 +302,23 @@
 
         # argument annotation tests
         def f(x) -> list: pass
-        self.assertEquals(f.func_annotations, {'return': list})
+        self.assertEquals(f.__annotations__, {'return': list})
         def f(x:int): pass
-        self.assertEquals(f.func_annotations, {'x': int})
+        self.assertEquals(f.__annotations__, {'x': int})
         def f(*x:str): pass
-        self.assertEquals(f.func_annotations, {'x': str})
+        self.assertEquals(f.__annotations__, {'x': str})
         def f(**x:float): pass
-        self.assertEquals(f.func_annotations, {'x': float})
+        self.assertEquals(f.__annotations__, {'x': float})
         def f(x, y:1+2): pass
-        self.assertEquals(f.func_annotations, {'y': 3})
+        self.assertEquals(f.__annotations__, {'y': 3})
         def f(a, (b:1, c:2, d)): pass
-        self.assertEquals(f.func_annotations, {'b': 1, 'c': 2})
+        self.assertEquals(f.__annotations__, {'b': 1, 'c': 2})
         def f(a, (b:1, c:2, d), e:3=4, f=5, *g:6): pass
-        self.assertEquals(f.func_annotations,
+        self.assertEquals(f.__annotations__,
                           {'b': 1, 'c': 2, 'e': 3, 'g': 6})
         def f(a, (b:1, c:2, d), e:3=4, f=5, *g:6, h:7, i=8, j:9=10,
               **k:11) -> 12: pass
-        self.assertEquals(f.func_annotations,
+        self.assertEquals(f.__annotations__,
                           {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9,
                            'k': 11, 'return': 12})
 
diff --git a/Lib/test/test_hotshot.py b/Lib/test/test_hotshot.py
index 2751b3f..5480257 100644
--- a/Lib/test/test_hotshot.py
+++ b/Lib/test/test_hotshot.py
@@ -85,8 +85,8 @@
             x = 1
         def g():
             f()
-        f_lineno = f.func_code.co_firstlineno
-        g_lineno = g.func_code.co_firstlineno
+        f_lineno = f.__code__.co_firstlineno
+        g_lineno = g.__code__.co_firstlineno
         events = [(ENTER, ("test_hotshot", g_lineno, "g")),
                   (LINE,  ("test_hotshot", g_lineno+1, "g")),
                   (ENTER, ("test_hotshot", f_lineno, "f")),
diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py
index 296e259..5e03218 100644
--- a/Lib/test/test_inspect.py
+++ b/Lib/test/test_inspect.py
@@ -53,7 +53,7 @@
         self.istest(inspect.isbuiltin, 'sys.exit')
         self.istest(inspect.isbuiltin, '[].append')
         self.istest(inspect.isclass, 'mod.StupidGit')
-        self.istest(inspect.iscode, 'mod.spam.func_code')
+        self.istest(inspect.iscode, 'mod.spam.__code__')
         self.istest(inspect.isframe, 'tb.tb_frame')
         self.istest(inspect.isfunction, 'mod.spam')
         self.istest(inspect.ismethod, 'mod.StupidGit.abuse')
@@ -210,7 +210,7 @@
         m.__file__ = "<string>" # hopefully not a real filename...
         m.__loader__ = "dummy"  # pretend the filename is understood by a loader
         exec("def x(): pass", m.__dict__)
-        self.assertEqual(inspect.getsourcefile(m.x.func_code), '<string>')
+        self.assertEqual(inspect.getsourcefile(m.x.__code__), '<string>')
         del sys.modules[name]
         inspect.getmodule(compile('a=10','','single'))
 
diff --git a/Lib/test/test_keywordonlyarg.py b/Lib/test/test_keywordonlyarg.py
index 0ace785..2e1f8bd 100644
--- a/Lib/test/test_keywordonlyarg.py
+++ b/Lib/test/test_keywordonlyarg.py
@@ -135,12 +135,12 @@
         def foo(p1,p2=0, *, k1, k2=0):
             return p1 + p2 + k1 + k2
 
-        self.assertEquals(2, foo.func_code.co_kwonlyargcount)
-        self.assertEquals({"k2":0}, foo.func_kwdefaults)
-        foo.func_kwdefaults = {"k1":0}
+        self.assertEquals(2, foo.__code__.co_kwonlyargcount)
+        self.assertEquals({"k2":0}, foo.__kwdefaults__)
+        foo.__kwdefaults__ = {"k1":0}
         try:
             foo(1,k1=10)
-            self.fail("func_kwdefaults is not properly changed")
+            self.fail("__kwdefaults__ is not properly changed")
         except TypeError:
             pass
 
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index 6c98022..9c58c12 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -144,7 +144,7 @@
 
 class CodeTestCase(unittest.TestCase):
     def test_code(self):
-        co = ExceptionTestCase.test_exceptions.func_code
+        co = ExceptionTestCase.test_exceptions.__code__
         new = marshal.loads(marshal.dumps(co))
         self.assertEqual(co, new)
 
diff --git a/Lib/test/test_new.py b/Lib/test/test_new.py
index e2d26fa..797a8c3 100644
--- a/Lib/test/test_new.py
+++ b/Lib/test/test_new.py
@@ -79,18 +79,18 @@
                 return x + y
             return g
         g = f(4)
-        new.function(f.func_code, {}, "blah")
-        g2 = new.function(g.func_code, {}, "blah", (2,), g.func_closure)
+        new.function(f.__code__, {}, "blah")
+        g2 = new.function(g.__code__, {}, "blah", (2,), g.__closure__)
         self.assertEqual(g2(), 6)
-        g3 = new.function(g.func_code, {}, "blah", None, g.func_closure)
+        g3 = new.function(g.__code__, {}, "blah", None, g.__closure__)
         self.assertEqual(g3(5), 9)
         def test_closure(func, closure, exc):
-            self.assertRaises(exc, new.function, func.func_code, {}, "", None, closure)
+            self.assertRaises(exc, new.function, func.__code__, {}, "", None, closure)
 
         test_closure(g, None, TypeError) # invalid closure
         test_closure(g, (1,), TypeError) # non-cell in closure
         test_closure(g, (1, 1), ValueError) # closure is wrong size
-        test_closure(f, g.func_closure, ValueError) # no closure needed
+        test_closure(f, g.__closure__, ValueError) # no closure needed
 
     # Note: Jython will never have new.code()
     if hasattr(new, 'code'):
@@ -98,7 +98,7 @@
             # bogus test of new.code()
             def f(a): pass
 
-            c = f.func_code
+            c = f.__code__
             argcount = c.co_argcount
             kwonlyargcount = c.co_kwonlyargcount
             nlocals = c.co_nlocals
diff --git a/Lib/test/test_profilehooks.py b/Lib/test/test_profilehooks.py
index 53f882a..0f5616d 100644
--- a/Lib/test/test_profilehooks.py
+++ b/Lib/test/test_profilehooks.py
@@ -324,7 +324,7 @@
     if hasattr(function, "f_code"):
         code = function.f_code
     else:
-        code = function.func_code
+        code = function.__code__
     return code.co_firstlineno, code.co_name
 
 
diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py
index 478083e..1edda75 100644
--- a/Lib/test/test_pyclbr.py
+++ b/Lib/test/test_pyclbr.py
@@ -140,7 +140,7 @@
             if isinstance(item, ClassType):
                 return item.__module__ == module.__name__
             if isinstance(item, FunctionType):
-                return item.func_globals is module.__dict__
+                return item.__globals__ is module.__dict__
             return False
         for name in dir(module):
             item = getattr(module, name)
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index 31e57e5..b9dc711 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -518,10 +518,10 @@
             return lambda: x + 1
 
         g = f(3)
-        self.assertRaises(TypeError, eval, g.func_code)
+        self.assertRaises(TypeError, eval, g.__code__)
 
         try:
-            exec(g.func_code, {})
+            exec(g.__code__, {})
         except TypeError:
             pass
         else:
diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py
index 21cba89..0678761 100644
--- a/Lib/test/test_struct.py
+++ b/Lib/test/test_struct.py
@@ -54,7 +54,7 @@
             # Grrr, we need this function to warn every time.  Without removing
             # the warningregistry, running test_tarfile then test_struct would fail
             # on 64-bit platforms.
-            globals = func.func_globals
+            globals = func.__globals__
             if '__warningregistry__' in globals:
                 del globals['__warningregistry__']
             warnings.filterwarnings("error", r"""^struct.*""", DeprecationWarning)
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index 8b5f73c..6fbb3cc 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -341,7 +341,7 @@
             finally:
                 if locale and orig_locale:
                     locale.setlocale(category, orig_locale)
-        inner.func_name = func.func_name
+        inner.__name__ = func.__name__
         inner.__doc__ = func.__doc__
         return inner
     return decorator
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 897c6b0..36cca2c 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -230,7 +230,7 @@
         self.assertRaises(TypeError, sys._getframe, 42, 42)
         self.assertRaises(ValueError, sys._getframe, 2000000000)
         self.assert_(
-            SysModuleTest.test_getframe.im_func.func_code \
+            SysModuleTest.test_getframe.im_func.__code__ \
             is sys._getframe().f_code
         )
 
diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py
index 7b5ac7d..b1778dd 100644
--- a/Lib/test/test_trace.py
+++ b/Lib/test/test_trace.py
@@ -226,14 +226,14 @@
         sys.settrace(tracer.trace)
         func()
         sys.settrace(None)
-        self.compare_events(func.func_code.co_firstlineno,
+        self.compare_events(func.__code__.co_firstlineno,
                             tracer.events, func.events)
 
     def run_test2(self, func):
         tracer = Tracer()
         func(tracer.trace)
         sys.settrace(None)
-        self.compare_events(func.func_code.co_firstlineno,
+        self.compare_events(func.__code__.co_firstlineno,
                             tracer.events, func.events)
 
     def test_01_basic(self):
@@ -313,7 +313,7 @@
 
         def g(frame, why, extra):
             if (why == 'line' and
-                frame.f_lineno == f.func_code.co_firstlineno + 2):
+                frame.f_lineno == f.__code__.co_firstlineno + 2):
                 raise RuntimeError, "i am crashing"
             return g
 
@@ -344,7 +344,7 @@
         self.done = False
 
     def trace(self, frame, event, arg):
-        if not self.done and frame.f_code == self.function.func_code:
+        if not self.done and frame.f_code == self.function.__code__:
             firstLine = frame.f_code.co_firstlineno
             if frame.f_lineno == firstLine + self.jumpFrom:
                 # Cope with non-integer self.jumpTo (because of
diff --git a/Lib/test/test_univnewlines.py b/Lib/test/test_univnewlines.py
index e91bde7..922c184 100644
--- a/Lib/test/test_univnewlines.py
+++ b/Lib/test/test_univnewlines.py
@@ -83,7 +83,7 @@
         namespace = {}
         execfile(test_support.TESTFN, namespace)
         func = namespace['line3']
-        self.assertEqual(func.func_code.co_firstlineno, 3)
+        self.assertEqual(func.__code__.co_firstlineno, 3)
         self.assertEqual(namespace['line4'], FATX)
 
 
diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py
index eb962d2..16c612e 100644
--- a/Lib/test/test_urllib.py
+++ b/Lib/test/test_urllib.py
@@ -295,7 +295,7 @@
 
     def test_default_safe(self):
         # Test '/' is default value for 'safe' parameter
-        self.assertEqual(urllib.quote.func_defaults[0], '/')
+        self.assertEqual(urllib.quote.__defaults__[0], '/')
 
     def test_safe(self):
         # Test setting 'safe' parameter does what it should do