diff --git a/src/sage/combinat/abstract_tree.py b/src/sage/combinat/abstract_tree.py
index 71ddb9903bb..bea0504a86f 100644
--- a/src/sage/combinat/abstract_tree.py
+++ b/src/sage/combinat/abstract_tree.py
@@ -187,7 +187,7 @@ def pre_order_traversal_iter(self):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.n_nodes()
             7
             sage: l = [1 for i in t.pre_order_traversal_iter()]
             sage: len(l)
@@ -259,7 +259,7 @@ def iterative_pre_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.n_nodes()
             7
             sage: l = []
             sage: t.iterative_pre_order_traversal(lambda node: l.append(1))
@@ -376,7 +376,7 @@ def pre_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.n_nodes()
             7
             sage: l = []
             sage: t.pre_order_traversal(lambda node: l.append(1))
@@ -471,7 +471,7 @@ def post_order_traversal_iter(self):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.n_nodes()
             7
             sage: l = [1 for i in t.post_order_traversal_iter()]
             sage: len(l)
@@ -543,7 +543,7 @@ def post_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.n_nodes()
             7
             sage: l = []
             sage: t.post_order_traversal(lambda node: l.append(1))
@@ -617,7 +617,7 @@ def iterative_post_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.n_nodes()
             7
             sage: l = []
             sage: t.iterative_post_order_traversal(lambda node: l.append(1))
@@ -710,7 +710,7 @@ def contour_traversal(self, first_action=None, middle_action=None, final_action=
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.n_nodes()
             7
             sage: l = []
             sage: t.contour_traversal(first_action = lambda node: l.append(0))
@@ -852,7 +852,7 @@ def paths_at_depth(self, depth, path=[]):
 
         .. SEEALSO::
 
-            :meth:`paths`, :meth:`paths_to_the_right`, :meth:`node_number_at_depth`
+            :meth:`paths`, :meth:`paths_to_the_right`, :meth:`number_of_nodes_at_depth`
 
         EXAMPLES::
 
@@ -886,7 +886,7 @@ def paths_at_depth(self, depth, path=[]):
             for i in range(len(self)):
                 yield from self[i].paths_at_depth(depth - 1, path + [i])
 
-    def node_number_at_depth(self, depth):
+    def number_of_nodes_at_depth(self, depth):
         r"""
         Return the number of nodes at a given depth.
 
@@ -900,7 +900,7 @@ def node_number_at_depth(self, depth):
 
         .. SEEALSO::
 
-            :meth:`node_number`, :meth:`node_number_to_the_right`, :meth:`paths_at_depth`
+            :meth:`n_nodes`, :meth:`number_of_nodes_to_the_right`, :meth:`paths_at_depth`
 
         EXAMPLES::
 
@@ -915,7 +915,7 @@ def node_number_at_depth(self, depth):
               o    o
                    |
                    o
-            sage: [T.node_number_at_depth(i) for i in range(6)]
+            sage: [T.number_of_nodes_at_depth(i) for i in range(6)]
             [1, 3, 4, 2, 1, 0]
 
         TESTS:
@@ -927,7 +927,7 @@ def node_number_at_depth(self, depth):
             .
             sage: T.is_empty()
             True
-            sage: [T.node_number_at_depth(i) for i in range(3)]
+            sage: [T.number_of_nodes_at_depth(i) for i in range(3)]
             [0, 0, 0]
 
         Check that we do not hit a recursion limit::
@@ -935,7 +935,7 @@ def node_number_at_depth(self, depth):
             sage: T = OrderedTree([])
             sage: for _ in range(9999):
             ....:     T = OrderedTree([T])
-            sage: T.node_number_at_depth(2000)
+            sage: T.number_of_nodes_at_depth(2000)
             1
         """
         if self.is_empty():
@@ -965,6 +965,8 @@ def lf_action(node):
         self.contour_traversal(fr_action, m_action, fn_action, lf_action)
         return Integer(m)
 
+    node_number_at_depth = number_of_nodes_at_depth
+
     def paths_to_the_right(self, path):
         r"""
         Return a generator of paths for all nodes at the same
@@ -979,7 +981,7 @@ def paths_to_the_right(self, path):
 
         .. SEEALSO::
 
-            :meth:`paths`, :meth:`paths_at_depth`, :meth:`node_number_to_the_right`
+            :meth:`paths`, :meth:`paths_at_depth`, :meth:`number_of_nodes_to_the_right`
 
         EXAMPLES::
 
@@ -1023,7 +1025,7 @@ def paths_to_the_right(self, path):
         for p in self[path[0]].paths_to_the_right(path[1:]):
             yield tuple([path[0]] + list(p))
 
-    def node_number_to_the_right(self, path):
+    def number_of_nodes_to_the_right(self, path):
         r"""
         Return the number of nodes at the same depth and to the right of
         the node identified by ``path``.
@@ -1033,7 +1035,7 @@ def node_number_to_the_right(self, path):
 
         .. SEEALSO::
 
-            :meth:`node_number`, :meth:`node_number_at_depth`, :meth:`paths_to_the_right`
+            :meth:`n_nodes`, :meth:`number_of_nodes_at_depth`, :meth:`paths_to_the_right`
 
         EXAMPLES::
 
@@ -1048,28 +1050,30 @@ def node_number_to_the_right(self, path):
               o    o
                    |
                    o
-            sage: T.node_number_to_the_right(())
+            sage: T.number_of_nodes_to_the_right(())
             0
-            sage: T.node_number_to_the_right((0,))
+            sage: T.number_of_nodes_to_the_right((0,))
             2
-            sage: T.node_number_to_the_right((0,1))
+            sage: T.number_of_nodes_to_the_right((0,1))
             2
-            sage: T.node_number_to_the_right((0,1,0))
+            sage: T.number_of_nodes_to_the_right((0,1,0))
             1
 
             sage: T = OrderedTree([])
-            sage: T.node_number_to_the_right(())
+            sage: T.number_of_nodes_to_the_right(())
             0
         """
         depth = len(path)
         if depth == 0:
             return Integer(0)
-        result = sum(son.node_number_at_depth(depth - 1)
+        result = sum(son.number_of_nodes_at_depth(depth - 1)
                      for son in self[path[0] + 1:])
         if path[0] < len(self) and path[0] >= 0:
-            result += self[path[0]].node_number_to_the_right(path[1:])
+            result += self[path[0]].number_of_nodes_to_the_right(path[1:])
         return result
 
+    node_number_to_the_right = number_of_nodes_to_the_right
+
     def subtrees(self):
         """
         Return a generator for all nonempty subtrees of ``self``.
@@ -1099,12 +1103,12 @@ def subtrees(self):
         TESTS::
 
             sage: t = OrderedTree([[], [[], [[], []], [[], []]], [[], []]])
-            sage: t.node_number() == len(list(t.subtrees()))
+            sage: t.n_nodes() == len(list(t.subtrees()))
             True
             sage: list(BinaryTree().subtrees())
             []
             sage: bt = BinaryTree([[],[[],[]]])
-            sage: bt.node_number() == len(list(bt.subtrees()))
+            sage: bt.n_nodes() == len(list(bt.subtrees()))
             True
         """
         return self.pre_order_traversal_iter()
@@ -1142,12 +1146,12 @@ def paths(self):
         TESTS::
 
             sage: t = OrderedTree([[], [[], [[], []], [[], []]], [[], []]])
-            sage: t.node_number() == len(list(t.paths()))
+            sage: t.n_nodes() == len(list(t.paths()))
             True
             sage: list(BinaryTree().paths())
             []
             sage: bt = BinaryTree([[],[[],[]]])
-            sage: bt.node_number() == len(list(bt.paths()))
+            sage: bt.n_nodes() == len(list(bt.paths()))
             True
         """
         if not self.is_empty():
@@ -1156,36 +1160,36 @@ def paths(self):
                 for p in t.paths():
                     yield (i,) + p
 
-    def node_number(self):
+    def n_nodes(self):
         """
         Return the number of nodes of ``self``.
 
         .. SEEALSO::
 
-            :meth:`node_number_at_depth`, :meth:`node_number_to_the_right`
+            :meth:`number_of_nodes_at_depth`, :meth:`number_of_nodes_to_the_right`
 
         EXAMPLES::
 
-            sage: OrderedTree().node_number()
+            sage: OrderedTree().n_nodes()
             1
-            sage: OrderedTree([]).node_number()
+            sage: OrderedTree([]).n_nodes()
             1
-            sage: OrderedTree([[],[]]).node_number()
+            sage: OrderedTree([[],[]]).n_nodes()
             3
-            sage: OrderedTree([[],[[]]]).node_number()
+            sage: OrderedTree([[],[[]]]).n_nodes()
             4
-            sage: OrderedTree([[], [[], [[], []], [[], []]], [[], []]]).node_number()
+            sage: OrderedTree([[], [[], [[], []], [[], []]], [[], []]]).n_nodes()
             13
 
         EXAMPLES::
 
-            sage: BinaryTree(None).node_number()
+            sage: BinaryTree(None).n_nodes()
             0
-            sage: BinaryTree([]).node_number()
+            sage: BinaryTree([]).n_nodes()
             1
-            sage: BinaryTree([[], None]).node_number()
+            sage: BinaryTree([[], None]).n_nodes()
             2
-            sage: BinaryTree([[None, [[], []]], None]).node_number()
+            sage: BinaryTree([[None, [[], []]], None]).n_nodes()
             5
 
         TESTS:
@@ -1195,7 +1199,7 @@ def node_number(self):
             sage: T = OrderedTree([])
             sage: for _ in range(9999):
             ....:     T = OrderedTree([T])
-            sage: T.node_number()
+            sage: T.n_nodes()
             10000
         """
         count = 0
@@ -1207,6 +1211,8 @@ def incr(node):
         self.iterative_pre_order_traversal(incr)
         return Integer(count)
 
+    node_number = n_nodes
+
     def depth(self):
         """
         Return the depth of ``self``.
@@ -1523,7 +1529,7 @@ def canonical_labelling(self, shift=1):
         deca = 1
         for subtree in self:
             liste += [subtree.canonical_labelling(shift + deca)]
-            deca += subtree.node_number()
+            deca += subtree.n_nodes()
         return LTR._element_constructor_(liste, label=shift)
 
     def to_hexacode(self):
@@ -1566,7 +1572,7 @@ def to_hexacode(self):
         """
         if len(self) > 15:
             raise ValueError("the width of the tree is too large")
-        if self.node_number() == 1:
+        if self.n_nodes() == 1:
             return "0"
         return ("%x" % len(self)) + "".join(u.to_hexacode() for u in self)
 
@@ -1594,7 +1600,7 @@ def tree_factorial(self):
             sage: BinaryTree().tree_factorial()
             1
         """
-        nb = self.node_number()
+        nb = self.n_nodes()
         if nb <= 1:
             return Integer(1)
         return nb * prod(s.tree_factorial() for s in self)
@@ -2359,7 +2365,7 @@ def leaf_labels(self):
             sage: LBT(None).leaf_labels()
             []
         """
-        return [t.label() for t in self.subtrees() if t.node_number() == 1]
+        return [t.label() for t in self.subtrees() if t.n_nodes() == 1]
 
     def __eq__(self, other):
         """
diff --git a/src/sage/combinat/bijectionist.py b/src/sage/combinat/bijectionist.py
index 1404d9cc86b..617f167813e 100644
--- a/src/sage/combinat/bijectionist.py
+++ b/src/sage/combinat/bijectionist.py
@@ -156,7 +156,7 @@
     ....:         else:
     ....:             return m+1
     sage: bij = Bijectionist(A, B, tau)
-    sage: bij.set_statistics((lambda a: a.size(), lambda b: b.node_number()-1))
+    sage: bij.set_statistics((lambda a: a.size(), lambda b: b.n_nodes()-1))
     sage: from sage.combinat.cyclic_sieving_phenomenon import orbit_decomposition
     sage: bij.set_constant_blocks(orbit_decomposition(A, theta))
     sage: list(bij.solutions_iterator())
@@ -173,7 +173,7 @@
     ....:                                          B2.to_dyck_word()).to_binary_tree()
     sage: bij = Bijectionist(A, B)
     sage: bij.set_intertwining_relations((2, concat_path, concat_tree))
-    sage: bij.set_statistics((lambda d: d.semilength(), lambda t: t.node_number()))
+    sage: bij.set_statistics((lambda d: d.semilength(), lambda t: t.n_nodes()))
     sage: for D in sorted(bij.minimal_subdistributions_iterator(), key=lambda x: (len(x[0][0]), x)):
     ....:     ascii_art(D)
     ( [ /\ ], [ o ] )
diff --git a/src/sage/combinat/binary_tree.py b/src/sage/combinat/binary_tree.py
index 6274bf72474..3f7c26b263e 100644
--- a/src/sage/combinat/binary_tree.py
+++ b/src/sage/combinat/binary_tree.py
@@ -766,7 +766,7 @@ def rec(tr, idx):
                     emb[idx] = []
                     return
                 else:  # tr is a node.
-                    nbl = 2 * tr[0].node_number() + 1
+                    nbl = 2 * tr[0].n_nodes() + 1
                     res.add_edges([[idx, idx + 1], [idx, idx + 1 + nbl]])
                     emb[idx] = [idx + 1 + nbl, idx + 1]
                     rec(tr[0], idx + 1)
@@ -785,7 +785,7 @@ def rec(tr, idx):
             # In this case, the general DiGraph construction would
             # falsely yield an empty graph (since it adds nodes only
             # implicitly by adding edges).
-            if self.node_number() == 1:
+            if self.n_nodes() == 1:
                 res = DiGraph({0: []})
                 res.set_embedding({0: []})
                 return res
@@ -799,14 +799,14 @@ def rec(tr, idx):
                 if not tr:  # tr is a leaf.
                     return
                 else:  # tr is a node.
-                    nbl = tr[0].node_number()
+                    nbl = tr[0].n_nodes()
                     if nbl > 0:
                         res.add_edge([idx, idx + 1])
                         emb[idx] = [idx + 1]
                         rec(tr[0], idx + 1)
                     else:
                         emb[idx] = []
-                    if tr[1].node_number() > 0:
+                    if tr[1].n_nodes() > 0:
                         res.add_edge([idx, idx + nbl + 1])
                         emb[idx] = [idx + nbl + 1] + emb[idx]
                         rec(tr[1], idx + nbl + 1)
@@ -840,7 +840,7 @@ def canonical_labelling(self, shift=1):
         """
         LTR = self.parent().labelled_trees()
         if self:
-            sz0 = self[0].node_number()
+            sz0 = self[0].n_nodes()
             return LTR([self[0].canonical_labelling(shift),
                         self[1].canonical_labelling(shift + 1 + sz0)],
                        label=shift + sz0)
@@ -1400,7 +1400,7 @@ def _postfix_word(self, left_first=True, start=1):
         if not self:
             return []
         left = self[0]._postfix_word(left_first, start)
-        label = start + self[0].node_number()
+        label = start + self[0].n_nodes()
         right = self[1]._postfix_word(left_first, start=label + 1)
         if left_first:
             left.extend(right)
@@ -1618,7 +1618,7 @@ def to_tilting(self):
 
             sage: w = DyckWord([1,1,1,1,0,1,1,0,0,0,1,1,0,1,0,1,1,0,1,1,0,0,0,0,0,0])   # needs sage.combinat
             sage: t2 = w.to_binary_tree()                                               # needs sage.combinat
-            sage: len(t2.to_tilting()) == t2.node_number()                              # needs sage.combinat
+            sage: len(t2.to_tilting()) == t2.n_nodes()                              # needs sage.combinat
             True
         """
         if not self:
@@ -1749,7 +1749,7 @@ def to_132_avoiding_permutation(self):
         from sage.combinat.permutation import Permutation
         return Permutation(self._postfix_word(left_first=False))
 
-    def left_children_node_number(self, direction='left'):
+    def number_of_left_nodes(self, direction='left'):
         r"""
         Return the number of nodes which are left children in ``self``.
 
@@ -1774,34 +1774,34 @@ def left_children_node_number(self, direction='left'):
               o       o
              / \     /
             o   o   o
-            sage: bt.left_children_node_number('left')
+            sage: bt.number_of_left_nodes('left')
             3
-            sage: bt.left_children_node_number('right')
+            sage: bt.number_of_left_nodes('right')
             4
 
-            sage: all(5 == 1 + bt.left_children_node_number()
-            ....:            + bt.left_children_node_number('right')
+            sage: all(5 == 1 + bt.number_of_left_nodes()
+            ....:            + bt.number_of_left_nodes('right')
             ....:     for bt in BinaryTrees(5))
             True
 
         TESTS::
 
-            sage: BinaryTree([[],None]).left_children_node_number()
+            sage: BinaryTree([[],None]).number_of_left_nodes()
             1
-            sage: BinaryTree([None,[]]).left_children_node_number()
+            sage: BinaryTree([None,[]]).number_of_left_nodes()
             0
-            sage: BinaryTree([]).left_children_node_number()
+            sage: BinaryTree([]).number_of_left_nodes()
             0
-            sage: BinaryTree().left_children_node_number()
+            sage: BinaryTree().number_of_left_nodes()
             0
 
-            sage: BinaryTree([[],None]).left_children_node_number('right')
+            sage: BinaryTree([[],None]).number_of_left_nodes('right')
             0
-            sage: BinaryTree([None,[]]).left_children_node_number('right')
+            sage: BinaryTree([None,[]]).number_of_left_nodes('right')
             1
-            sage: BinaryTree([]).left_children_node_number('right')
+            sage: BinaryTree([]).number_of_left_nodes('right')
             0
-            sage: BinaryTree().left_children_node_number('right')
+            sage: BinaryTree().number_of_left_nodes('right')
             0
         """
         if self.is_empty():
@@ -1810,13 +1810,15 @@ def left_children_node_number(self, direction='left'):
         if self[0]:
             if direction == 'left':
                 res += 1
-            res += self[0].left_children_node_number(direction)
+            res += self[0].number_of_left_nodes(direction)
         if self[1]:
             if direction == 'right':
                 res += 1
-            res += self[1].left_children_node_number(direction)
+            res += self[1].number_of_left_nodes(direction)
         return res
 
+    left_children_node_number = number_of_left_nodes
+
     @combinatorial_map(order=2, name="Left-right symmetry")
     def left_right_symmetry(self):
         r"""
@@ -2500,8 +2502,8 @@ def single_edge_cut_shapes(self):
         """
         resu = []
         left, right = list(self)
-        L = left.node_number()
-        R = right.node_number()
+        L = left.n_nodes()
+        R = right.n_nodes()
         if L:
             resu += [(m + R + 1, i, n)
                      for m, i, n in left.single_edge_cut_shapes()]
@@ -2711,7 +2713,7 @@ def twisting_number(self):
             [1, 1]
         """
         tn = [0, 0]
-        if self.node_number() <= 1:
+        if self.n_nodes() <= 1:
             return tn
 
         L = self.comb('left')
@@ -2894,16 +2896,16 @@ def product_of_subtrees(b):
                     return basering.one()
                 b0 = b[0]
                 b1 = b[1]
-                return q_binomial(b.node_number() - 1, b0.node_number(), q=q) * \
+                return q_binomial(b.n_nodes() - 1, b0.n_nodes(), q=q) * \
                     product_of_subtrees(b0) * product_of_subtrees(b1) * \
-                    q ** (b1.node_number())
+                    q ** (b1.n_nodes())
         else:
             def product_of_subtrees(b):
                 if b.is_empty():
                     return basering.one()
                 b0 = b[0]
                 b1 = b[1]
-                return q_binomial(b.node_number() - 1, b0.node_number(), q=q) * \
+                return q_binomial(b.n_nodes() - 1, b0.n_nodes(), q=q) * \
                     product_of_subtrees(b0) * product_of_subtrees(b1)
 
         return product_of_subtrees(self)
@@ -3599,7 +3601,7 @@ def builder(i, p):
             def builder(i, p):
                 return list(p) + [i]
 
-        shift = self[0].node_number() + 1
+        shift = self[0].n_nodes() + 1
         for l, r in product(self[0].sylvester_class(left_to_right=left_to_right),
                             self[1].sylvester_class(left_to_right=left_to_right)):
             for p in shuffle(W(l), W([shift + ri for ri in r])):
@@ -3820,7 +3822,7 @@ def is_perfect(self):
             [  / \     / \  ]
             [ o   o   o   o ]
         """
-        return 2 ** self.depth() - 1 == self.node_number()
+        return 2 ** self.depth() - 1 == self.n_nodes()
 
     def is_complete(self):
         r"""
@@ -4209,7 +4211,7 @@ def __contains__(self, x):
             sage: S([[],[]]) in S
             True
         """
-        return isinstance(x, BinaryTree) and x.node_number() == self._size
+        return isinstance(x, BinaryTree) and x.n_nodes() == self._size
 
     def _an_element_(self):
         """
@@ -4302,7 +4304,7 @@ def _element_constructor_(self, *args, **keywords):
             [., .]
         """
         res = BinaryTree(*args, **keywords)
-        if res.node_number() != self._size:
+        if res.n_nodes() != self._size:
             raise ValueError("wrong number of nodes")
         return res
 
@@ -4450,7 +4452,7 @@ def __contains__(self, x):
             False
         """
         return (isinstance(x, BinaryTree)
-                and x.node_number() == self._size
+                and x.n_nodes() == self._size
                 and x.is_full())
 
     def _an_element_(self):
@@ -4572,7 +4574,7 @@ def _element_constructor_(self, *args, **keywords):
             ValueError: not full
         """
         res = BinaryTree(*args, **keywords)
-        if res.node_number() != self._size:
+        if res.n_nodes() != self._size:
             raise ValueError("wrong number of nodes")
         if not res.is_full():
             raise ValueError("not full")
diff --git a/src/sage/combinat/free_dendriform_algebra.py b/src/sage/combinat/free_dendriform_algebra.py
index 92255248cc8..148111ceca8 100644
--- a/src/sage/combinat/free_dendriform_algebra.py
+++ b/src/sage/combinat/free_dendriform_algebra.py
@@ -313,7 +313,7 @@ def degree_on_basis(self, t):
             sage: A.degree_on_basis(u.over(u))
             2
         """
-        return t.node_number()
+        return t.n_nodes()
 
     def _an_element_(self):
         """
@@ -627,7 +627,7 @@ def coproduct_on_basis(self, x):
         """
         B = self.basis()
         Trees = B.keys()
-        if not x.node_number():
+        if not x.n_nodes():
             return self.one().tensor(self.one())
         L, R = list(x)
         try:
diff --git a/src/sage/combinat/free_prelie_algebra.py b/src/sage/combinat/free_prelie_algebra.py
index f892a69a69d..da7dd92e6fb 100644
--- a/src/sage/combinat/free_prelie_algebra.py
+++ b/src/sage/combinat/free_prelie_algebra.py
@@ -373,7 +373,7 @@ def degree_on_basis(self, t):
             sage: A.degree_on_basis(RT([RT([])]))
             2
         """
-        return t.node_number()
+        return t.n_nodes()
 
     def _an_element_(self):
         """
@@ -609,7 +609,7 @@ def corolla(self, x, y, n, N):
         resu = self.zero()
         for k in range(min_deg, N + 1):   # total degree of (x ; y, y, y, y)
             for mx, coef_x in xx:
-                dx = mx.node_number()
+                dx = mx.n_nodes()
                 step = self.zero()
                 for pi in IntegerVectors(k - dx, n, min_part=vy, max_part=max_y):
                     for ly in product(*[y_homog[part] for part in pi]):
diff --git a/src/sage/combinat/grossman_larson_algebras.py b/src/sage/combinat/grossman_larson_algebras.py
index 0e8b9ee0ede..08f59690320 100644
--- a/src/sage/combinat/grossman_larson_algebras.py
+++ b/src/sage/combinat/grossman_larson_algebras.py
@@ -359,7 +359,7 @@ def degree_on_basis(self, t):
             sage: A.degree_on_basis(RT([RT([])]))
             1
         """
-        return t.node_number() - 1
+        return t.n_nodes() - 1
 
     def _an_element_(self):
         """
@@ -508,7 +508,7 @@ def counit_on_basis(self, x):
             sage: A.counit_on_basis(RT([],'#'))
             1
         """
-        if x.node_number() == 1:
+        if x.n_nodes() == 1:
             return self.base_ring().one()
         return self.base_ring().zero()
 
diff --git a/src/sage/combinat/growth.py b/src/sage/combinat/growth.py
index 53196640151..e5a209dac95 100644
--- a/src/sage/combinat/growth.py
+++ b/src/sage/combinat/growth.py
@@ -3003,7 +3003,7 @@ def rank(self, v):
             sage: Sylvester.rank(Sylvester.vertices(3)[0])
             3
         """
-        return v.node_number()
+        return v.n_nodes()
 
     def is_Q_edge(self, v, w):
         r"""
@@ -3147,7 +3147,7 @@ def Q_symbol(self, Q_chain):
         """
         def add_label(L, S, T, m):
             if L.is_empty():
-                assert T.node_number() == 1
+                assert T.n_nodes() == 1
                 return LabelledBinaryTree([], m)
             l = L.label()
             if T[0] == S[0]:
diff --git a/src/sage/combinat/ordered_tree.py b/src/sage/combinat/ordered_tree.py
index 8e7be3e36ba..fd310205324 100644
--- a/src/sage/combinat/ordered_tree.py
+++ b/src/sage/combinat/ordered_tree.py
@@ -411,7 +411,7 @@ def _to_parallelogram_polyomino_Boussicault_Socci(self):
             [[0, 0, 1], [1, 0, 0]]
         """
         from sage.combinat.parallelogram_polyomino import ParallelogramPolyomino
-        if self.node_number() == 1:
+        if self.n_nodes() == 1:
             return ParallelogramPolyomino([[1], [1]])
         upper_nodes = []
         lower_nodes = []
@@ -450,14 +450,14 @@ def H(path):
             lower_path.append(0)
             lower_path += [1] * (W(lower_nodes[i]) - W(lower_nodes[i - 1]))
         lower_path.append(0)
-        lower_path += [1] * (self.node_number() - len(lower_path))
+        lower_path += [1] * (self.n_nodes() - len(lower_path))
 
         upper_path = []
         for i in range(1, len(upper_nodes)):
             upper_path.append(1)
             upper_path += [0] * (H(upper_nodes[i]) - H(upper_nodes[i - 1]))
         upper_path.append(1)
-        upper_path += [0] * (self.node_number() - len(upper_path))
+        upper_path += [0] * (self.n_nodes() - len(upper_path))
 
         return ParallelogramPolyomino([lower_path, upper_path])
 
@@ -1047,7 +1047,7 @@ def __contains__(self, x):
             sage: T([[],[]]) in T
             True
         """
-        return isinstance(x, self.element_class) and x.node_number() == self._size
+        return isinstance(x, self.element_class) and x.n_nodes() == self._size
 
     def _an_element_(self):
         """
@@ -1177,7 +1177,7 @@ def _element_constructor_(self, *args, **keywords):
             []
         """
         res = self.element_class(self._parent_for, *args, **keywords)
-        if res.node_number() != self._size:
+        if res.n_nodes() != self._size:
             raise ValueError("wrong number of nodes")
         return res
 
diff --git a/src/sage/combinat/rooted_tree.py b/src/sage/combinat/rooted_tree.py
index b7a9e9a9090..0180aa28990 100644
--- a/src/sage/combinat/rooted_tree.py
+++ b/src/sage/combinat/rooted_tree.py
@@ -657,7 +657,7 @@ def __contains__(self, x):
             sage: S([[],[]]) in S
             True
         """
-        return isinstance(x, self.element_class) and x.node_number() == self._n
+        return isinstance(x, self.element_class) and x.n_nodes() == self._n
 
     def _an_element_(self):
         """
@@ -720,7 +720,7 @@ def check_element(self, el, check=True):
             ...
             ValueError: wrong number of nodes
         """
-        if el.node_number() != self._n:
+        if el.n_nodes() != self._n:
             raise ValueError("wrong number of nodes")
 
     def cardinality(self):
@@ -779,7 +779,7 @@ def _element_constructor_(self, *args, **keywords):
             []
         """
         res = self.element_class(self._parent_for, *args, **keywords)
-        if res.node_number() != self._n:
+        if res.n_nodes() != self._n:
             raise ValueError("wrong number of nodes")
         return res
 
diff --git a/src/sage/databases/findstat.py b/src/sage/databases/findstat.py
index 417bf49ebc5..0f99e5c3f69 100644
--- a/src/sage/databases/findstat.py
+++ b/src/sage/databases/findstat.py
@@ -4522,7 +4522,7 @@ def name(self, style='singular'):
     _SupportedFindStatCollection(lambda x: BinaryTree(str(x)),
                                  str,
                                  BinaryTrees,
-                                 lambda x: x.node_number(),
+                                 lambda x: x.n_nodes(),
                                  lambda x: isinstance(x, BinaryTree)),
     "Cores":
     _SupportedFindStatCollection(lambda x: Core(*literal_eval(x)),
@@ -4575,7 +4575,7 @@ def name(self, style='singular'):
     _SupportedFindStatCollection(lambda x: OrderedTree(literal_eval(x)),
                                  str,
                                  OrderedTrees,
-                                 lambda x: x.node_number(),
+                                 lambda x: x.n_nodes(),
                                  lambda x: isinstance(x, OrderedTree)),
     "ParkingFunctions":
     _SupportedFindStatCollection(lambda x: ParkingFunction(literal_eval(x)),
diff --git a/src/sage/graphs/generators/random.py b/src/sage/graphs/generators/random.py
index 897724e9794..ae7c7ea6b48 100644
--- a/src/sage/graphs/generators/random.py
+++ b/src/sage/graphs/generators/random.py
@@ -2237,8 +2237,8 @@ def blossoming_contour(t, shift=0, seed=None):
     t1, t2 = t
     leaf_xb = ('xb',)
     leaf_x = ('x',)
-    n1 = t1.node_number()
-    n = t.node_number()
+    n1 = t1.n_nodes()
+    n = t.n_nodes()
 
     # adding buds on edges in t1
     if not t1: