I'd stick with a Python 2 book instead.
Yes, a lot of changes applicable to Python 3 have been back-ported, and with each new 3.x release the transition from 2.x to 3.x is made easier. But a Python 3.x book will not tell you how to adapt your code to work in Python 2.7. Your Python 3.x code will have surprising effects when run by a Python 2.x interpreter.
Take the print() function, for example. In Python 2, print is a statement, so you normally would write print somevalue and that'd print the contents of the variable somevalue to stdout. In Python 3.x, you'd write print(somevalue) instead, as print() is a function there.
However, writing print(somevalue) also works in Python 2.x, but Python interprets that as the expression (somevalue) to be printed to stdout, instead of the expression somevalue being passed as an argument to the print() function. And that is subtly different.
The distinction becomes more apparent when more than one value is involved; print(onevalue, anothervalue) means, in Python 2.x, to print the tuple (onevalue, anothervalue), while in Python 3.x this means something different, namely to pass two arguments to the print() function, and each one has to be printed with the default separator (a space), which is a very different operation:
# Python 2.7
>>> print(1, 2)
(1, 2)
# Python 3.3
>>> print(1, 2)
1 2
So, although the code looks the same, the effect is quite different.
If you want to write code that works consistently across both major python versions, you'd actually need to do the following:
# Python 2.7
>>> from __future__ import print_function
>>> print(1, 2)
1 2
The __future__ import statement there was added to Python 2.6 and newer to facilitate the transition, to make it easier to write code that'll work the same in both Python 2.x and 3.x. In any module that imports print_function, the print statement is replaced by a print() function. Now, print(onevalue, twovalue) behaves the same way it would in Python 3.x.
The print vs. print() change is but one of many changes between the major versions though. Others require a deeper understanding of the language still, and place much heavier demands on someone just starting out with Python.
To give you an idea, here is a super-compacted and incomplete overview: I/O has been overhauled, the default string types have been switched, dict methods return views instead of lists, other built-in methods return iterators instead of lists, ordering comparisons have been simplified, the behaviour of the division operator has changed, octal literals have been tightened, you can specify that keyword arguments to a function can only be called using keyword arguments (and not as positionals), a new nonlocal statement to handle nested scoping beyond global vs. local, the import system has been overhauled and made more introspectable and hookable, many standard library modules have been moved around and reworked, etc., etc., etc.
If your job requires you to learn Python 2.7, then focus on that. The transition to 3.x will come later, with more experience of what Python is about.
