Ebook Free Text Processing in Python, by David Mertz
Again, reviewing habit will certainly consistently give helpful benefits for you. You might not should spend often times to read guide Text Processing In Python, By David Mertz Simply adjusted apart several times in our extra or free times while having dish or in your office to read. This Text Processing In Python, By David Mertz will certainly reveal you brand-new point that you can do now. It will help you to boost the top quality of your life. Occasion it is just an enjoyable publication Text Processing In Python, By David Mertz, you can be happier as well as a lot more enjoyable to enjoy reading.
Text Processing in Python, by David Mertz
Ebook Free Text Processing in Python, by David Mertz
Make use of the sophisticated modern technology that human develops this day to locate the book Text Processing In Python, By David Mertz quickly. However first, we will certainly ask you, just how much do you love to check out a book Text Processing In Python, By David Mertz Does it always until coating? Wherefore does that book review? Well, if you actually enjoy reading, aim to read the Text Processing In Python, By David Mertz as one of your reading compilation. If you only checked out the book based on need at the time and also unfinished, you have to try to such as reading Text Processing In Python, By David Mertz initially.
If you obtain the printed book Text Processing In Python, By David Mertz in on the internet book shop, you might additionally find the very same problem. So, you must relocate establishment to shop Text Processing In Python, By David Mertz and look for the offered there. However, it will not take place below. Guide Text Processing In Python, By David Mertz that we will provide right here is the soft file idea. This is what make you can quickly find and also get this Text Processing In Python, By David Mertz by reading this site. We provide you Text Processing In Python, By David Mertz the best product, always and consistently.
Never ever question with our deal, because we will consistently offer just what you need. As such as this upgraded book Text Processing In Python, By David Mertz, you could not find in the other area. Yet here, it's extremely easy. Simply click and also download, you can own the Text Processing In Python, By David Mertz When simpleness will alleviate your life, why should take the complicated one? You can purchase the soft data of the book Text Processing In Python, By David Mertz right here as well as be member people. Besides this book Text Processing In Python, By David Mertz, you can likewise locate hundreds listings of guides from numerous resources, compilations, authors, and writers in around the world.
By clicking the web link that our company offer, you could take the book Text Processing In Python, By David Mertz flawlessly. Hook up to web, download, and conserve to your device. Just what else to ask? Checking out can be so easy when you have the soft documents of this Text Processing In Python, By David Mertz in your gizmo. You can also replicate the documents Text Processing In Python, By David Mertz to your workplace computer system or at home or perhaps in your laptop computer. Simply discuss this excellent news to others. Recommend them to see this resource and obtain their looked for publications Text Processing In Python, By David Mertz.
Text Processing with Python, written by Python authority David Mertz, teaches programmers how to accomplish numerous text processing tasks using the Python language. Filled with concrete examples, this book provides effective solutions to specific text processing problems and practical strategies for dealing with all types of text processing challenges. It provides the answers to questions such as: What is the best way to convert from binary to ASCII?; How do I work with full text indexing?; How do I find a URL or an email address in text?; What are the different levels of pattern matching?; How do I process a report with a concrete state machine?; How do I parse, create and manipulate HTML documents?; How do I handle a lossless and lossy compression?; And what is the most efficient way to find codepoints in Unicode?
- Sales Rank: #916918 in Books
- Published on: 2003-06-12
- Original language: English
- Number of items: 1
- Dimensions: 9.10" h x 1.20" w x 6.90" l, 1.94 pounds
- Binding: Paperback
- 544 pages
From the Back Cover
Text Processing in Python is an example-driven, hands-on tutorial that carefully teaches programmers how to accomplish numerous text processing tasks using the Python language. Filled with concrete examples, this book provides efficient and effective solutions to specific text processing problems and practical strategies for dealing with all types of text processing challenges.
Text Processing in Python begins with an introduction to text processing and contains a quick Python tutorial to get you up to speed. It then delves into essential text processing subject areas, including string operations, regular expressions, parsers and state machines, and Internet tools and techniques. Appendixes cover such important topics as data compression and Unicode. A comprehensive index and plentiful cross-referencing offer easy access to available information. In addition, exercises throughout the book provide readers with further opportunity to hone their skills either on their own or in the classroom. A companion Web site (http://gnosis.cx/TPiP) contains source code and examples from the book.
Here is some of what you will find in thie book:
- When do I use formal parsers to process structured and semi-structured data? Page 257
- How do I work with full text indexing? Page 199
- What patterns in text can be expressed using regular expressions? Page 204
- How do I find a URL or an email address in text? Page 228
- How do I process a report with a concrete state machine? Page 274
- How do I parse, create, and manipulate internet formats? Page 345
- How do I handle lossless and lossy compression? Page 454
- How do I find codepoints in Unicode? Page 465
0321112547B05022003
About the Author
David Mertz came to writing about programming via the unlikely route of first being a humanities professor. Along the way, he was a senior software developer, and now runs his own development company, Gnosis Software ("We know stuff!"). David writes regular columns and articles for IBM developerWorks, Intel Developer Network, O'Reilly ONLamp, and other publications.
0321112547AB05022003
Excerpt. © Reprinted by permission. All rights reserved.
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one—and preferably only one—obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea—let's do more of those!
—Tim Peters, The Zen of Python
At the broadest level text processing is simply taking textual information and doing something with it. This doing might be restructuring or reformatting it, extracting smaller bits of information from it, algorithmically modifying the content of the information, or performing calculations that depend on the textual information. The lines between "text" and the even more general term "data" are extremely fuzzy; at an approximation, "text" is just data that lives in forms that people can themselves read—at least in principle, and maybe with a bit of effort. Most typically computer "text" is composed of sequences of bits which have a "natural" representation as letters, numerals and symbols; and most often such text is delimited (if delimited at all) by symbols and formatting that can be easily pronounced as "next datum."
The lines are fuzzy, but the data that seems least like text—and that, therefore this particular book is least concerned with—is the data that makes up "multimedia" (pictures, sounds, video, animation, etc.) and data that makes up UI "events" (draw a window, move the mouse, open an application, etc.). Like I said, the lines are fuzzy, and some representations of the most non-textual data are themselves pretty textual. But in general, the subject of this book is all the stuff on the near side of that fuzzy line.
Text processing is arguably what most programmers spend most of their time doing. The information that lives in business software systems mostly comes down to collections of words about the application domain—maybe with a few special symbols mixed in. Internet communications protocols consist mostly of a few special words used as headers, a little bit of constrained formatting, and message bodies consisting of additional wordish texts. Configuration files, log files, CSV and fixed-length data files, error files, documentation, and source code itself, are all just sequences of words with bits of constraint and formatting applied.
Programmers and developers spend so much time with text processing, that it is easy to forget that that is what we are doing. The most common text processing application is probably your favorite text editor. Beyond simple entry of new characters, text editors perform such text processing tasks as search/replace and copy/paste, which—given guided interaction with the user—accomplishes sophisticated manipulation of textual sources. Many text editors go farther than these simple capabilities, and include their own complete programming systems (usually called "macro processing"); in those cases where editors include "Turing-complete" macro languages, text editors suffice, in principle, to accomplish anything that the examples in this book can.
After text editors, a variety of text processing tools are widely used by developers. Tools like "File Find" under Windows, or "grep" on Unix (and other platforms) perform the basic chore of locating text patterns. "Little languages" like sed and awk perform basic text manipulation (or even non-basic). A large number of utilities—especially in Unix-like environments—perform small custom text processing tasks: wc, sort, tr, md5sum, uniq, split, strings and many others.
At the top of the text processing food chain are general purpose programming languages, such as Python. I wrote this book on Python in large part because Python is such a clear, expressive, and general purpose language. But for all Python's virtues, text editors and "little" utilities will always have an important place for developers "getting the job done." As simple as Python is, it is still more complicated than you need to achieve many basic tasks. But once you get past the very simple, Python is a perfect language for making the difficult things possible (and it is also good at making the easy things simple).
0.2 The Philosophy of Text ProcessingHang around any Python discussion groups for a little while, and you will certainly be dazzled by the contributions of the Python developer, Tim Peters (and by a number of other Pythonistas). His "Zen of Python" captures much of the reason that I choose Python as the language in which to solve most programming tasks that are presented to me. But to understand what is most special about text processing as a programming task, it is worth turning to Perl creator Larry Wall's cardinal virtues of programming: Laziness, impatience, hubris.
What sets text processing most clearly apart from other tasks computer programmers accomplish is the frequency with which we perform text processing on an ad hoc or "one-shot" basis. One rarely bothers to create a one-shot GUI interface for a program. You even less frequently performs a one-shot normalization of a relational database. But every programmer with a little experience has had numerous occasions where she has received a trickle of textual information (or maybe a deluge of it) from another department, from a client, from a developer working on a different project, or from data dumped out of a DBMS; the problem in such cases is always to "process" the text so that it is usable for our own project, program, database, or work unit. Text processing to the rescue. This is where the virtue of impatience first appears—we just want the stuff processed, right now!
But text-processing tasks that were obviously one-shot tasks that we knew we would never need again have a habit of coming back like restless ghosts. It turns out that that client needs to update the one-time data they sent last month. Or the boss decides that she would really like a feature of that text summarized in a slightly different way. The virtue of laziness is our friend here—with our foresight not to actually delete those one-shot scripts, we have them available for easy reuse and/or modification when the need arises.
Enough is not enough, however. That script you reluctantly used a second time turns out to be quite similar to a more general task you will need to perform frequently, perhaps even automatically. You imagine that with only a slight amount of extra work you can generalize and expand the script, maybe add a little error checking and some runtime options while you are at it; and do it all in time and under budget (or even as a side project, off the budget). Obviously, this is the voice of that greatest of programmers' virtues: hubris.
The goal of this book is to make its readers a little lazier, a smidgeon more impatient, and a whole bunch more hubristic. Python just happens to be the language best suited to the study of virtue.
0.3 What You'll Need to Use This BookThis book is ideally suited for programmers who are a little bit familiar with Python, and whose daily tasks involve a fair amount of text processing chores. Programmers who have some background in other programming languages—especially with other "scripting" languages—should be able to pick up enough Python to get going by reading Appendix A.
While Python is a rather simple language at heart, this book is not intended as a tutorial on Python for non-programmers. Instead, this book is about two other things: getting the job done, pragmatically and efficiently; and understanding why what works works and what doesn't work doesn't work, theoretically and conceptually. As such, we hope this book can be useful both to working programmers and to students of programming at a level just past the introductory.
Many sections of this book are accompanied by problems and exercises, and these in turn often pose questions for users. In most cases, the answers to the listed questions are somewhat open-ended—there are no simple right answers. I believe that working through the provided questions will help both self-directed and instructor-guided learners; the questions can typically be answered at several levels, and often have an underlying subtlety. Instructors who wish to use this text are encouraged to contact the author for assistance in structuring a curriculum involving it. All readers are encouraged to consult the book's web site to see possible answers provided by both the author and other readers; additional related questions will be added to the web site over time, along with other resources.
The Python language itself is conservative. Almost every Python script written ten years ago for Python 1.0 will run fine in Python 2.3+. However, as versions improve, a certain number of new features have been added. The most significant changes have matched the version number changes—Python 2.0 introduced list comprehension's, augmented assignments, Unicode support, and a standard XML package. Many scripts written in the most natural and efficient manner using Python 2.0+ will not run without changes in earlier versions of Python.
The general target of this book will be users of Python 2.1+, but some 2.2+ specific features will be utilized in examples. Maybe half the examples in this book will run fine on Python 1.5.1+ (and slightly fewer with older versions), but examples will not necessarily indicate their requirement for Python 2.0+ (where it exists). On the other hand, new features introduced with Python 2.1 and above will only be utilized where they make a task significantly easier, or where the feature itself is being illustrated. In any case, examples requiring versions past Python 2.0 will usually indicate this explicitly.
In the case of modules and packages—whether in the standard library or third-party—we will explicitly indicate what Python version is required; and where relevant, which version added the module or package to the standard library. In some cases, it will be possible to use later standard library modules with earlier Python versions. In important cases, this possibility will be noted.
0.4 Conventions Used in This BookAll constants, functions, and classes in discussions and cross-references will be explicitly prepended with their namespace (module). Methods will additionally, be prepended with their class. In some cases, code examples will use the local namespace, but a preference for explicit namespace identification will be present in sample code also. For example, a reference might read:
See Also: email.Generator.DecodedGenerator.flatten() 346; raw input() 442; tempfile.mktemp() 70;
The first is a class method in the email.Generator module; the second, a built-in function; the last, a function in the tempfile module
In the special case of built-in methods on types, the expression for an empty type object will be used in the style of a namespace modifier. For example:
Methods of built-in types include .sort(), "".islower(), {}.keys(), and (lambda:1).func code.
The file object type will be indicated by the name FILE in capitals; A reference to a file object method will appear as, e.g.:
See Also: FILE.flush() 16;
Brief inline illustrations of Python concepts and usage will be taken from the Python interactive shell. This approach allows readers to see the immediate evaluation of constructs, much as they might explore Python themselves. Moreover, examples presented in this manner will be self-sufficient (not requiring external data), and may be entered—with variations—by readers trying to get a grasp on a concept. For example:
>>> 13/7 # integer division
1
>>> 13/7. # float division
1.8571428571428572
In documentation of module functions, where named arguments are available, they are listed with their default value. Optional arguments are listed in square brackets. These conventions are also used in the Python Library Reference. For example:
foobar.spam(s, val=23 ,taste="spicy")
The function foobar.spam() uses the argument s to . . .
If a named argument does not have a specifiable default value, the argument is listed followed by an equal sign and ellipsis. For example:
foobar.baz(string=. . . , maxlen=. . . )
The foobar.baz() function . . .
With the introduction of Unicode support to Python, an equivalence between a character and a byte no longer holds in all cases. Where an operation takes a numeric argument affecting a string-like object, the documentation will specify whether characters or bytes are being counted. For example:
Operation A reads num bytes from the buffer. Operation B reads num charactersfrom the buffer.
The first line indicates a number of actual 8-bit bytes affected. The second line indicates an indefinite number of bytes are affected, but that they compose a number of (maybe multi-byte) characters.
0.5 A Word on Source Code ExamplesFirst things first. All the source code in this book is hereby released to the public domain. You can use it however you like, without restriction. You can include it in free software, or in commercial/proprietary projects. Change it to your heart's content, and in any manner you want. If you feel like giving credit to the author (or sending him large checks) for code you find useful, that is fine—but no obligation to do so exists.
All the source code in this book, and various other public domain examples, can be found at the book's web site. If such an electronic form is more convenient for you, we hope this helps you. In fact, if you are able, you might benefit from visiting this location, where you might find updated versions of examples or other useful utilities not mentioned in the book.
First things out of the way, let us turn to second things. Little of the source code in this book is intended as a final say on how to perform a given task. Many of the examples are easy enough to copy directly into your own program, or to use as stand-alone utilities. But the real goal in presenting the examples is educational. We really hope you will think about what the examples do, and why they do it the way they do. In fact, we hope readers will think of better, faster, and more general ways of performing the same tasks. If the examples work their best, they should be better as inspirations than as instructions.0.6 External Resources GENERAL RESOURCESA good clearing house for resources and links related to this book is the book's web site. Over time, I will add errata and additional examples, questions, answers, utilities, etc. to the site, so check it from time to time:
http://gnosis.cx/TPiP/
The first place you should probably turn for any question on Python programming(after this book), is:
http://www.python.org/
The Python newsgroup comp.lang.python is an amazingly useful resource, with discussion that is generally both friendly and erudite. You may also post to and follow the newsgroup via a mirrored mailing list:
http://mail.python.org/mailman/listinfo/python-list
This book generally aims at an intermediate reader. Other Python books are better introductory texts (especially for those fairly new to programming generally). Some good introductory texts are:
- Core Python Programming, Wesley J. Chun, Prentice Hall/PTR, 2001. ISBN: 0-130-26036-3
- Learning Python, Mark Lutz and David Ascher, O'Reilly, 1999. ISBN: 1-56592-464-9
- The Quick Python Book, Daryl D. Harms and Kenneth McDonald, Manning Publications, 2000. ISBN: 1-884777-74-0.
As introductions, I would generally recommend these books in the order listed, but learning styles vary between readers.
Two texts that overlap this book somewhat, but focus more narrowly on referencing the standard library are:
- Python Essential Reference, Second Edition, David M. Beazley, New Riders 2001. ISBN: 0-7357-1091-0.
- Python Standard Library, Fredrik Lundh, O'Reilly 2001. ISBN: 0-596-00096-0.
For coverage of XML, at a far more detailed level than this book has room for, is the excellent text:
- Python & XML, Christopher A. Jones and Fred L. Drake, Jr., O'Reilly 2002. ISBN: 0-596-00128-2.
Currently, the best Python-specific directory for software is the Vaults of Parnassus:
http://www.vex.net/parnassus/
SourceForge is a general open source software resource. Many projects—Python and otherwise—are hosted at that site, and the site provides search capabilities, keywords, category browsing, and the like:
http://sourceforge.net/
Freshmeat is another widely used directory of software projects (mostly open source). Like the Vaults of Parnassus, Freshmeat does not directly host project files, but simply acts as an information clearing house for finding relevant projects:
http://freshmeat.net/
A number of Python projects are discussed in this book. Most of those are listed in one or more of the software directories mentioned above. A general search engine like Google, http://google.com, is also useful in locating project homepages. Below are a number of project URLs that are current at the time of this writing. If any of these fall out of date by the time you read this book, try searching in a search engine or software directory for an updated URL.
The author's Gnosis Utilities contains a number of Python packages mentioned in this book, including gnosis.indexer , gnosis.xml.indexer , gnosis.xml.pickle , and others. You can download the most current version from:
http://gnosis.cx/download/Gnosis Utils-current.tar.gz
eGenix.com provides a number of useful Python extensions, some of which are documented in this book. These include mx.TextTools , mx.DateTime , severeral new datatypes, and others facilities:
http://egenix.com/files/python/eGenix-mx-Extensions.html
SimpleParse is hosted by SourceForge, at:
http://simpleparse.sourceforge.net/
The PLY parsers has a home page at:
http://systems.cs.uchicago.edu/ply/ply.html
0321112547P01302003
Most helpful customer reviews
2 of 2 people found the following review helpful.
A very good intro book
By Sean Fritz
This book is interesting, the field it covers is not one with many texts, so it's hard to do comparative analysis.
On it's strengths, this book is probably best suited for programmers that aren't afraid to learn advanced material. It covers in great detail everything you ever wanted to know about python string processing (and honestly probably a bit more). It has a very readable style, and overall is exceptionally informative. Examples are clear, pointed, and useful.
On it's weaknesses, some material (ie parsers) might be extremely dense and hard to understand if you don't have a CS or Linguistics degree. On the other hand, if you do understand it (and the explanation is pretty good), you will end up a much better programmer for it.
Overall, I'd recommend this book for professionals with theory background that need to do advanced python work. I'd also recommend it to people without theory background, but only if they're not afraid of getting their feet wet. People who are afraid of learning should probably avoid this book.
4 stars mostly because I'm not really sure how to evaluate this book.
8 of 8 people found the following review helpful.
Valuable information poorly presented
By Dale Wilson
There is a lot of good stuff in this book, but the presentation is lousy.
The first chapter dives into functional programming using obscure and terse high order functions including nested lambda expressions. He never does provide a "mere mortal" explanation for how these functions work. I was able to figure it out, but then I've been programming for 35 years in 20+ languages.
As a learning experience it was valuable debugging exercise for me, but as something for a programmer who was just getting to know Python, I can't think of a greater turn off.
Python as a rule is easy to read and easy to write. This book manages to make it unnecessarily hard.
Start with another Python book (or two, or three) then come back to this one when you have a lot of time and patience to spend. As I said there *is* some worthwhile information in there.
41 of 44 people found the following review helpful.
A beautiful book
By John S. Ryan
Yes, I mean it: this is a beautiful book. If your aesthetic sensibilities have been informed, directly or indirectly, by Kernighan and Ritchie's influential book on C, you'll know what I mean.
I've been programming computers in various capacities since I was in my early teens (the mid-1970s) and I've been through a number of languages. Not long ago I discovered Python, and I suspect I won't need to learn any other languages for quite a long time. Guido van Rossum is a wizard.
If you're interested in learning Python, don't start here. If you've got some programming background already, Guido's tutorial (which comes bundled with the Python download) will be enough to get you rolling. I personally recommend all of O'Reilly's books on the subject (_Learning Python_ for the absolute beginner, Mark Lutz's idiosyncratic but highly useful _Programming Python_ for the next level up, the magisterial _Python Cookbook_ for pretty much anybody, and the _Nutshell_ book to be placed permanently next to your keyboard). There are others as well, and after you've gotten started, you'll be a better judge than I am of what will be most useful to you. (But I'd skip the vastly overpriced and not-very-deep _Python Programming Patterns_ unless you can buy it used.)
This one's for later; although it does offer some beginning instruction in Python, it isn't really an introductory book. However, if you do any text processing with Python -- which you almost undoubtedly do if you use Python at all -- then you _do_ want this book even if you don't know it yet.
Most of what you'll want to know is in chapter two, which sets out the basics of string processing in Python. The other, fancier stuff in the later chapters may be handy sometimes, but author David Mertz himself will tell you not to overcomplicate things; if you can do what you need to do using string operations, do so.
Read the rest of it too, though. There's good stuff here on e.g. regular expressions and parsing that you'll find interesting and possibly useful. Just don't rush out and start trying to apply it when it isn't necessary.
Mertz is an excellent teacher. He tends to approach things from a foundation of "functional programming" -- of which I'm not particularly a fan, but he has a healthy sense of its limitations and his comments on the subject are refreshing. (If you're interested in functional programming, get a book on Haskell, which is actually a very cool language. But me, I like imperative languages just fine and I don't have any problem with "side effects" as long as they're deliberate or at least controlled.) At any rate, Mertz won't lock you in to a functional approach, but he will teach you some function-oriented stuff that will be useful to you no matter what your preferred programming style.
And his exposition is well organized and wonderfully lucid. If you're the sort of person who likes books that have a chapter zero, you'll enjoy his style.
Unless you have a strong programming background, then, you probably won't want to start your Python bookshelf with this one. But I recommend making it one of your first five.
Text Processing in Python, by David Mertz PDF
Text Processing in Python, by David Mertz EPub
Text Processing in Python, by David Mertz Doc
Text Processing in Python, by David Mertz iBooks
Text Processing in Python, by David Mertz rtf
Text Processing in Python, by David Mertz Mobipocket
Text Processing in Python, by David Mertz Kindle
