XPUB
/
S13-Words-for-the-Future-notebooks
15
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

changed pdf-toolkit/pdftk-stamp-background.ipynb stuff

Browse Source
master
eunalee 4 years ago
parent dd112259f5 06a43caf44
commit 9bdb911a27
24 changed files with 1207 additions and 1603 deletions
Show Stats Download Patch File Download Diff File

0
just_a_trying_file.txt
Unescape Escape View File

10
pdf-html2print/LIQUID.md
View File

File diff suppressed because one or more lines are too long

88
pdf-html2print/language.md
Unescape Escape View File

@ -1,88 +0,0 @@
Language
Florian Cramer
Software and language are intrinsically related, since software may process language, and is constructed in language.
Yet language means different things in the context of computing: formal languages in which algorithms are expressed and software is implemented, and in so-called “natural” spoken languages.
There are at least two layers of formal language in software: programming language in which the software is written, and the language implemented within the software as its symbolic controls.
In the case of compilers, shells, and macro languages, for example, these layers can overlap.
“Natural” language is what can be processed as data by software; since this processing is formal, however, it is restricted to syntactical operations.
While differentiation of computer programming languages as “artificial languages” from languages like English as “natural languages” is conceptually important and undisputed, it remains problematic in its pure terminology: There is nothing “natural” about spoken language; it is a cultural construct and thus just as “artificial” as any formal machine control language.
To call programming languages “machine languages” doesn’t solve the problem either, as it obscures that “machine languages” are human creations.
High-level machine-independent programming languages such as Fortran, C, Java, and Basic are not even direct mappings of machine logic.
If programming languages are human languages for machine control, they could be called cybernetic languages.
But these languages can also be used outside machines—in programming handbooks, for example, in programmer’s dinner table jokes, or as abstract formal languages for expressing logical constructs, such as in Hugh Kenner’s use of the Pascal programming language to explain aspects of the structure of Samuel Beckett’s writing.1 In this sense, computer control languages could be more broadly defined as syntactical languages as opposed to semantic languages.
But this terminology is not without its problems either.
Common languages like English are both formal and semantic; although their scope extends beyond the formal, anything that can be expressed in a computer control language can also be expressed in common language.
It follows that computer control languages are a formal (and as such rather primitive) subset of common human languages.
To complicate things even further, computer science has its own understanding of “operational semantics” in programming languages, for example in the construction of a programming language interpreter or compiler.
Just as this interpreter doesn’t perform “interpretations” in a hermeneutic sense of semantic text explication, the computer science notion of “semantics” defies linguistic and common sense understanding of the word, since compiler construction is purely syntactical, and programming languages denote nothing but syntactical manipulations of symbols.
What might more suitably be called the semantics of computer control languages resides in the symbols with which those operations are denoted in most programming languages: English words like “if,” “then,” “else,” “for,” “while,” “goto,” and “print,” in conjunction with arithmetical and punctuation symbols; in alphabetic software controls, words like “list,” “move,” “copy,” and “paste”; in graphical software controls, such as symbols like the trash can.
Ferdinand de Saussure states that the signs of common human language are arbitrary2 because it’s purely a cultural-social convention that assigns phonemes to concepts.
Likewise, it’s purely a cultural convention to assign symbols to machine operations.
But just as the cultural choice of phonemes in spoken language is restrained by what the human voice can pronounce, the assignment of symbols to machine operations is limited to what can be efficiently processed by the machine and of good use to humans.3 This compromise between operability and usability is obvious in, for example, Unix commands.
Originally used on teletype terminals, the operation “copy” was abbreviated to the command “cp,” “move” to “mv,” “list” to “ls,” etc., in order to cut down machine memory use, teletype paper consumption, and human typing effort at the same time.
Any computer control language is thus a cultural compromise between the constraints of machine design—which is far from objective, but based on human choices, culture, and thinking style itself 4—and the equally subjective user preferences, involving fuzzy factors like readability, elegance, and usage efficiency.
The symbols of computer control languages inevitably do have semantic connotations simply because there exist no symbols with which humans would not associate some meaning.
But symbols can’t denote any semantic statements, that is, they do not express meaning in their own terms; humans metaphorically read meaning into them through associations they make.
Languages without semantic denotation are not historically new phenomena; mathematical formulas are their oldest example.
In comparison to common human languages, the multitude of programming languages is of lesser significance.
The criterion of Turing completeness of a programming language, that is, that any computation can be expressed in it, means that every programming language is, formally speaking, just a riff on every other programming language.
Nothing can be expressed in a Turingcomplete language such as C that couldn’t also be expressed in another Turingcomplete language such as Lisp (or Fortran, Smalltalk, Java ...) and vice versa.
This ultimately proves the importance of human and cultural factors in programming languages: while they are interchangeable in regard to their control of machine functions, their different structures—semantic descriptors, grammar and style in which algorithms can be expressed—lend themselves not only to different problem sets, but also to different styles of thinking.
Just as programming languages are a subset of common languages, Turingincomplete computer control languages are a constrained subset of Turingcomplete languages.
This prominently includes markup languages (such as HTML), file formats, network protocols, and most user controls (see the entry “Interface”) of computer programs.
In most cases, languages of this type are restrained from denoting algorithmic operations for computer security reasons—to prevent virus infection and remote takeover.
This shows how the very design of a formal language is a design for machine control.
Access to hardware functions is limited not only through the software application, but through the syntax the software application may use for storing and transmitting the information it processes.
To name one computer control language a “programming language,” another a “protocol,” and yet another a “file format” is merely a convention, a nomenclature indicating different degrees of syntactic restraint built into the very design of a computer control language.
In its most powerful Turing-complete superset, computer control language is language that executes.
As with magical and speculative concepts of language, the word automatically performs the operation.
Yet this is not to be confused with what linguistics calls a “performative” or “illocutionary” speech act, for example, the words of a judge who pronounces a verdict, a leader giving a command, or a legislator passing a law.
The execution of computer control languages is purely formal; it is the manipulation of a machine, not a social performance based on human conventions such as accepting a verdict.
Computer languages become performative only through the social impact of the processes they trigger, especially when their outputs aren’t critically checked.
Joseph Weizenbaum’s software psychotherapist Eliza, a simple program that syntactically transforms input phrases, is a classical example,5 as is the 1987 New York Stock Exchange crash that involved a chain reaction of “sell” recommendations by day trading software.6 Writing in a computer programming language is phrasing instructions for an utter idiot.
The project of Artificial Intelligence is to prove that intelligence is just a matter of a sufficiently massive layering of foolproof recipes—in linguistic terms, that semantics is nothing else but (more elaborate) syntax.
As long as A.I.
fails to deliver this proof, the difference between common languages and computer control languages continues to exist, and language processing through computers remains restrained to formal string manipulations, a fact that after initial enthusiasm has made many experimental poets since the 1950s abandon their experiments with computer-generated texts.7 The history of computing is rich with confusions of formal with common human languages, and false hopes and promises that formal languages would become more like common human languages.
Among the unrealized hopes are artificial intelligence, graphical user interface design with its promise of an “intuitive” or, to use Jef Raskin’s term, “humane interface,”8 and major currents of digital art.
Digital installation art typically misperceives its programmed behaviorist black boxes as “interactive,” and some digital artists are caught in the misconception that they can overcome what they see as the Western male binarism of computer languages by reshaping them after romanticized images of indigenous human languages.
The digital computer is a symbolic machine that computes syntactical language and processes alphanumerical symbols; it treats all data—including images and sounds—as textual, that is, as chunks of coded symbols.
Nelson Goodman’s criteria of writing as “disjunct” and “discrete,” or consisting of separate single entities that differ from other separate single entities, also applies to digital files.9 The very meaning of “digitization” is to structure analog data as numbers and store them as numerical texts composed of discrete parts.
All computer software controls are linguistic regardless of their perceivable shape, alphanumerical writing, graphics, sound signals, or whatever else.
The Unix command “rm file” is operationally identical to dragging the file into the trashcan on a desktop.
Both are just different encodings for the same operation, just as alphabetic language and morse beeps are different encodings for the same characters.
As a symbolic handle, this encoding may enable or restrain certain uses of the language.
In this respect, the differences between ideographic-pictorial and abstract-symbolic common languages also apply to computer control languages.
Pictorial symbols simplify control languages through predefined objects and operations, but make it more difficult to link them through a grammar and thus express custom operations.
Just as a pictogram of a house is easier to understand than the letters h-o-u-s-e, the same is true for the trashcan icon in comparison to the “rm” command.
But it is difficult to precisely express the operation “If I am home tomorrow at six, I will clean up every second room in the house” through a series of pictograms.
Abstract, grammatical alphanumeric languages are more suitable for complex computational instructions.10 The utopia of a universal pictorial computer control language (with icons, windows, and pointer operations) is a reenactment of the rise and eventual fall of universal pictorial language utopias in the Renaissance, from Tommaso Campanella’s “Città del sole” to Comenius’ “Orbis pictus”—although the modern project of expressing only machine operations in pictograms was less ambitious.
The converse to utopian language designs occurs when computer control languages get appropriated and used informally in everyday culture.
Jonathan Swift tells how scientists on the flying island of Lagado “would, for example, praise the beauty of a woman, or any other animal ... by rhombs, circles, parallelograms, ellipses, and other “geometrical terms.” 11 Likewise, there is programming language poetry which, unlike most algorithmic poetry, writes its program source as the poetical work, or crossbreeds cybernetic with common human languages.
These “code poems” or “codeworks” often play with the interference between human agency and programmed processes in computer networks.
In computer programming and computer science, “code” is often understood either as a synonym of computer programming language or as a text written in such a language.
This modern usage of the term “code” differs from the traditional mathematical and cryptographic notion of code as a set of formal transformation rules that transcribe one group of symbols to another group of symbols, for example, written letters into morse beeps.
The translation that occurs when a text in a programming language gets compiled into machine instructions is not an encoding in this sense because the process is not oneto-one reversible.
This is why proprietary software companies can keep their source “code” secret.
It is likely that the computer cultural understanding of “code” is historically derived from the name of the first high-level computer programming language, “Short Code” from 1950.12 The only programming language that is a code in the original sense is assembly language, the human- readable mnemonic one-to-one representation of processor instructions.
Conversely, those instructions can be coded back, or “disassembled,” into assembly language.
Software as a whole is not only “code” but a symbolic form involving cultural practices of its employment and appropriation.
But since writing in a computer control language is what materially makes up software, critical thinking about computers is not possible without an informed understanding of the structural formalism of its control languages.
Artists and activists since the French Oulipo poets and the MIT hackers in the 1960s have shown how their limitations can be embraced as creative challenges.
Likewise, it is incumbent upon critics to reflect the sometimes more and sometimes less amusing constraints and game rules computer control languages write into culture.
Notes
1. Hugh Kenner, “Beckett Thinking,” in Hugh Kenner, The Mechanic Muse, 83–107.
2. Ferdinand de Saussure, Course in General Linguistics, ”Chapter I: Nature of the Linguistic Sign.”
3. See the section, “Saussurean Signs and Material Matters,” in N. Katherine Hayles, My Mother Was a Computer, 42–45.
4. For example, Steve Wozniak’s design of the Apple I mainboard was consijdered “a beautiful work of art” in its time according to Steven Levy, Insanely Great: The Life and Times of Macintosh, 81.
5. Joseph Weizenbaum, “ELIZA—A Computer Program for the Study of Natural Language Communication between Man and Machine.”
6. Marsha Pascual, “Black Monday, Causes and Effects.”
7. Among them concrete poetry writers, French Oulipo poets, the German poet Hans Magnus Enzensberger, and the Austrian poets Ferdinand Schmatz and Franz Josef Czernin.
8. Jef Raskin, The Humane Interface: New Directions for Designing Interactive Systems.
9. According to Nelson Goodman’s definition of writing in The Languages of Art, 143.
10. Alan Kay, an inventor of the graphical user interface, conceded in 1990 that “it would not be surprising if the visual system were less able in this area than the mechanism that solve noun phrases for natural language. Although it is not fair to say that ‘iconic languages can’t work’ just because no one has been able to design a good one, it is likely that the above explanation is close to truth.” This status quo hasn’t changed since. Alan Kay, “User Interface: A Personal View,” in, Brenda Laurel ed. The Art of Human-Computer Interface Design, Reading: Addison Wesley, 1989, 203.
11. Swift, Jonathan, Gulliver’s Travels, Project Gutenberg Ebook, available at http:// www.gutenberg.org / dirs / extext197 / gltrv10.txt / .
12. See Wolfgang Hagen, “The Style of Source Codes.”

186
pdf-html2print/markdown-html-print.ipynb
View File

File diff suppressed because one or more lines are too long

195
pdf-html2print/md-html-pdf.ipynb
Unescape Escape View File

@ -0,0 +1,195 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Markdown - HTML - print"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pypandoc\n",
"from weasyprint import HTML, CSS\n",
"from weasyprint.fonts import FontConfiguration"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Markdown → HTML"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pandoc: \"If you need to convert files from one markup format into another, **pandoc is your swiss-army knife**.\"\n",
"\n",
"https://pandoc.org/\n",
"\n",
"The Python library for Pandoc:\n",
"\n",
"https://github.com/bebraw/pypandoc \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Convert a Markdown file to HTML ...\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# ... directly from a file\n",
"html = pypandoc.convert_file('language.md', 'html')\n",
"print(html)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# ... or from a pad\n",
"\n",
"from urllib.request import urlopen\n",
"\n",
"url = 'https://pad.xpub.nl/p/language/export/txt'\n",
"response = urlopen(url)\n",
"md = response.read().decode('UTF-8')\n",
"\n",
"with open('language.md', 'w') as f:\n",
" f.write(md)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"html = pypandoc.convert_file('language.md', 'html')\n",
"print(html)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## HTML → PDF"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"for this we can use Weasyprint again"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"html = HTML(string=html)\n",
"print(html)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"css = CSS(string='''\n",
"@page{\n",
" size: A4;\n",
" margin: 15mm;\n",
" \n",
" counter-increment: page;\n",
" \n",
" @top-left{\n",
" content: \"hello?\";\n",
" }\n",
" @top-center{\n",
" content: counter(page);\n",
" font-size: 7pt;\n",
" font-family: monospace;\n",
" color: blue;\n",
" }\n",
" @bottom-center{\n",
" content: \"this is the bottom center!\";\n",
" }\n",
" }\n",
" \n",
" body{\n",
" color: magenta;\n",
" }\n",
"''')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It's actually interesting and useful to have a close look at paged media properties in CSS: \n",
"\n",
"https://developer.mozilla.org/en-US/docs/Web/CSS/%40page/size"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"html.write_pdf('language.pdf', stylesheets=[css])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

163
pdf-html2print/nltk-pos-tagging-and-weasyprint.ipynb
Unescape Escape View File

@ -0,0 +1,163 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# NLTK pos-tagged HTML → PDF"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import nltk\n",
"from weasyprint import HTML, CSS"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# open the input file\n",
"txt = open('../txt/language.txt').read()\n",
"words = nltk.word_tokenize(txt)\n",
"tagged_words = nltk.pos_tag(words)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# collect all the pieces of HTML\n",
"content = ''\n",
"content += '<h1>Language and Software Studies, by Florian Cramer</h1>'\n",
"\n",
"for word, tag in tagged_words:\n",
" content += f'<span class=\"{ tag }\">{ word }</span> '"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# write the HTML file\n",
"with open(\"language.html\", \"w\") as f:\n",
" f.write(f\"\"\"<!DOCTYPE html>\n",
"<html>\n",
"<head>\n",
" <meta charset=\"utf-8\">\n",
" <link rel=\"stylesheet\" type=\"text/css\" href=\"language.css\">\n",
" <title></title>\n",
"</head>\n",
"<body>\n",
"{ content }\n",
"</body>\n",
"\"\"\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# write a CSS file\n",
"with open(\"language.css\", \"w\") as f:\n",
" f.write(\"\"\"\n",
"\n",
"@page{\n",
" size:A4;\n",
" background-color:lightgrey;\n",
" margin:10mm;\n",
"}\n",
".JJ{\n",
" color:red;\n",
"}\n",
".VB,\n",
".VBG{\n",
" color:magenta;\n",
"}\n",
".NN,\n",
".NNP{\n",
" color:green;\n",
"}\n",
".EX{\n",
" color: blue;\n",
"}\n",
" \"\"\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# If you use @font-face in your stylesheet, you would need Weasyprint's FontConfiguration()\n",
"from weasyprint.fonts import FontConfiguration\n",
"\n",
"font_config = FontConfiguration()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# collect all the files and write the PDF\n",
"html = HTML(\"language.html\")\n",
"css = CSS(\"language.css\")\n",
"html.write_pdf('language.pdf', stylesheets=[css], font_config=font_config)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Preview your PDF in the notebook!\n",
"from IPython.display import IFrame, display\n",
"IFrame(\"language.pdf\", width=900, height=600)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

57
pdf-html2print/txt/liquid.css
Unescape Escape View File

@ -0,0 +1,57 @@
@page{
size: A4;
margin: 15mm;
background-color: lightgrey;
font-family: monospace;
font-size: 8pt;
color: #7da0d4;
border:1.5x dotted red;
@top-left{
content: "liquid";
}
@top-center{
content: "bodies";
}
@top-right{
content: "natural";
}
@top-middle{
content: ""
}
@left-top{
content: "material";
}
@right-top{
content: "existence";
}
@bottom-left{
content: "flux";
}
@bottom-center{
content: "living";
}
@bottom-right{
content: "energy";
}
}
body {
background: #f7c694;
margin: 20px;
line-height: 2;
font-family: monospace;
}
pre {
white-space: pre-wrap;
}
span.NN {
font-style: italic;
color: white;
border: 2px dashed black;
}
span.JJ {
color: #9abae3;
}

14
pdf-html2print/txt/liquid.html
View File

File diff suppressed because one or more lines are too long

10
pdf-html2print/txt/words-for-the-future/LIQUID.html
View File

File diff suppressed because one or more lines are too long

273
pdf-html2print/weasyprint-Copy1.ipynb
Unescape Escape View File

@ -0,0 +1,273 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Weasyprint"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"from weasyprint import HTML, CSS\n",
"from weasyprint.fonts import FontConfiguration"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"https://weasyprint.readthedocs.io/en/latest/tutorial.html"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# If you use @font-face in your stylesheet, you would need Weasyprint's FontConfiguration()\n",
"font_config = FontConfiguration()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## HTML"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# small example HTML object\n",
"html = HTML(string='<h1>hello</h1>')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"or in this case let's use python + nltk to make a custom HTML page with parts of speech used as CSS classes..."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"ename": "ModuleNotFoundError",
"evalue": "No module named 'nltk'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-9-52b984781443>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mnltk\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'txt/LIQUID1.txt'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mtxt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mwords\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnltk\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mword_tokenize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtxt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'nltk'"
]
}
],
"source": [
"import nltk\n",
"\n",
"with open('txt/LIQUID1.txt') as f:\n",
" txt = f.read()\n",
"words = nltk.word_tokenize(txt)\n",
"tagged_words = nltk.pos_tag(words)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"content = ''\n",
"content += '<h1>LIQUID | Rachel Armstrong</h1>'\n",
"\n",
"for word, tag in tagged_words:\n",
" content+= f'<span class=\"{tag}\">{ word }</span> '\n",
" \n",
"with open(\"txt/liquid.html\", \"w\") as f:\n",
" f.write(f\"\"\"<!DOCTYPE html>\n",
"<html>\n",
"<head>\n",
" <meta charset=\"utf-8\">\n",
" <link rel=\"stylesheet\" type=\"text/css\" href=\"txt/liquid.css\">\n",
" \n",
"\n",
" \n",
" \n",
" <title>Liquid</title>\n",
"</head>\n",
"<body>\n",
"{content}\n",
"</body>\n",
"\"\"\")\n",
"\n",
"html = HTML(\"txt/liquid.html\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Saved to [language.html](txt/language.html). Fun fact: jupyter filters HTML pages that are displayed in the notebook. To see the HTML unfiltered, use an iframe (as below), or right-click and select Open in New Tab in the file list.\n",
"\n",
"Maybe useful evt. https://stackoverflow.com/questions/23358444/how-can-i-use-word-tokenize-in-nltk-and-keep-the-spaces"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NB: The above HTML refers to the stylesheet [language.css](txt/language.css) (notice that the path is relative to the HTML page, so no need to say txt in the link)."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
" <iframe\n",
" width=\"1024\"\n",
" height=\"600\"\n",
" src=\"txt/liquid.html\"\n",
" frameborder=\"0\"\n",
" allowfullscreen\n",
" ></iframe>\n",
" "
],
"text/plain": [
"<IPython.lib.display.IFrame at 0xaf85cc30>"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from IPython.display import IFrame\n",
"IFrame(\"txt/liquid.html\", width=1024, height=600)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generating the PDF!\n",
"\n",
"Now let's let weasyprint do it's stuff! Write_pdf actually calculates the layout, behaving like a web browser to render the HTML visibly and following the CSS guidelines for page media (notice the special rules in the CSS that weasy print recognizes and uses that the browser does not). Notice that the CSS file gets mentioned again explicitly (and here we need to refer to its path relative to this folder)."
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [],
"source": [
"## If we had not linked the CSS in the HTML, you could specify it in this way\n",
"# css = CSS(\"txt/language.css\", font_config=font_config)\n",
"# html.write_pdf('txt/language.pdf', stylesheets=[css], font_config=font_config)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"css = CSS(\"txt/liquid.css\")"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"html.write_pdf('liquid1.pdf', stylesheets=[css], font_config=font_config)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
" <iframe\n",
" width=\"1024\"\n",
" height=\"600\"\n",
" src=\"txt/liquid.pdf\"\n",
" frameborder=\"0\"\n",
" allowfullscreen\n",
" ></iframe>\n",
" "
],
"text/plain": [
"<IPython.lib.display.IFrame at 0xaf8c79b0>"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from IPython.display import IFrame\n",
"IFrame(\"txt/liquid.pdf\", width=1024, height=600)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

128
pdf-html2print/weasyprint.ipynb
View File

File diff suppressed because one or more lines are too long

341
pdf-html2print/weasyprint1.ipynb
View File

File diff suppressed because one or more lines are too long

BIN
pdf-toolkit/pdf/quilt-stamped.pdf
View File

Binary file not shown.

100
pdf-toolkit/pdftk-stamp-background.ipynb
Unescape Escape View File

@ -1,100 +0,0 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# PDFTK Stamp / Background"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Background: \n",
"\n",
"`pdftk in.pdf background back.pdf output out.pdf`"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"!pdftk pdf/hope.pdf background pdf/HOPE_blue.pdf output pdf/quilt-background.pdf "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Stamp:\n",
"\n",
"`pdftk in.pdf stamp stamp.pdf output out.pdf`"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"!pdftk pdf/map.pdf stamp pdf/A32.pdf output pdf/stamped.pdf\n",
"\n",
"# with many pages, stamp will be applied for each page"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid syntax (<ipython-input-21-eca4999cbd7b>, line 1)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"<ipython-input-21-eca4999cbd7b>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m $ pdftk A3.pdf cat 1-endeast output A32.pdf\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
]
}
],
"source": []
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

88
txt/.ipynb_checkpoints/language-checkpoint.txt
Unescape Escape View File

@ -1,88 +0,0 @@
Language
Florian Cramer
Software and language are intrinsically related, since software may process language, and is constructed in language.
Yet language means different things in the context of computing: formal languages in which algorithms are expressed and software is implemented, and in so-called “natural” spoken languages.
There are at least two layers of formal language in software: programming language in which the software is written, and the language implemented within the software as its symbolic controls.
In the case of compilers, shells, and macro languages, for example, these layers can overlap.
“Natural” language is what can be processed as data by software; since this processing is formal, however, it is restricted to syntactical operations.
While differentiation of computer programming languages as “artificial languages” from languages like English as “natural languages” is conceptually important and undisputed, it remains problematic in its pure terminology: There is nothing “natural” about spoken language; it is a cultural construct and thus just as “artificial” as any formal machine control language.
To call programming languages “machine languages” doesn’t solve the problem either, as it obscures that “machine languages” are human creations.
High-level machine-independent programming languages such as Fortran, C, Java, and Basic are not even direct mappings of machine logic.
If programming languages are human languages for machine control, they could be called cybernetic languages.
But these languages can also be used outside machines—in programming handbooks, for example, in programmer’s dinner table jokes, or as abstract formal languages for expressing logical constructs, such as in Hugh Kenner’s use of the Pascal programming language to explain aspects of the structure of Samuel Beckett’s writing.1 In this sense, computer control languages could be more broadly defined as syntactical languages as opposed to semantic languages.
But this terminology is not without its problems either.
Common languages like English are both formal and semantic; although their scope extends beyond the formal, anything that can be expressed in a computer control language can also be expressed in common language.
It follows that computer control languages are a formal (and as such rather primitive) subset of common human languages.
To complicate things even further, computer science has its own understanding of “operational semantics” in programming languages, for example in the construction of a programming language interpreter or compiler.
Just as this interpreter doesn’t perform “interpretations” in a hermeneutic sense of semantic text explication, the computer science notion of “semantics” defies linguistic and common sense understanding of the word, since compiler construction is purely syntactical, and programming languages denote nothing but syntactical manipulations of symbols.
What might more suitably be called the semantics of computer control languages resides in the symbols with which those operations are denoted in most programming languages: English words like “if,” “then,” “else,” “for,” “while,” “goto,” and “print,” in conjunction with arithmetical and punctuation symbols; in alphabetic software controls, words like “list,” “move,” “copy,” and “paste”; in graphical software controls, such as symbols like the trash can.
Ferdinand de Saussure states that the signs of common human language are arbitrary2 because it’s purely a cultural-social convention that assigns phonemes to concepts.
Likewise, it’s purely a cultural convention to assign symbols to machine operations.
But just as the cultural choice of phonemes in spoken language is restrained by what the human voice can pronounce, the assignment of symbols to machine operations is limited to what can be efficiently processed by the machine and of good use to humans.3 This compromise between operability and usability is obvious in, for example, Unix commands.
Originally used on teletype terminals, the operation “copy” was abbreviated to the command “cp,” “move” to “mv,” “list” to “ls,” etc., in order to cut down machine memory use, teletype paper consumption, and human typing effort at the same time.
Any computer control language is thus a cultural compromise between the constraints of machine design—which is far from objective, but based on human choices, culture, and thinking style itself 4—and the equally subjective user preferences, involving fuzzy factors like readability, elegance, and usage efficiency.
The symbols of computer control languages inevitably do have semantic connotations simply because there exist no symbols with which humans would not associate some meaning.
But symbols can’t denote any semantic statements, that is, they do not express meaning in their own terms; humans metaphorically read meaning into them through associations they make.
Languages without semantic denotation are not historically new phenomena; mathematical formulas are their oldest example.
In comparison to common human languages, the multitude of programming languages is of lesser significance.
The criterion of Turing completeness of a programming language, that is, that any computation can be expressed in it, means that every programming language is, formally speaking, just a riff on every other programming language.
Nothing can be expressed in a Turingcomplete language such as C that couldn’t also be expressed in another Turingcomplete language such as Lisp (or Fortran, Smalltalk, Java ...) and vice versa.
This ultimately proves the importance of human and cultural factors in programming languages: while they are interchangeable in regard to their control of machine functions, their different structures—semantic descriptors, grammar and style in which algorithms can be expressed—lend themselves not only to different problem sets, but also to different styles of thinking.
Just as programming languages are a subset of common languages, Turingincomplete computer control languages are a constrained subset of Turingcomplete languages.
This prominently includes markup languages (such as HTML), file formats, network protocols, and most user controls (see the entry “Interface”) of computer programs.
In most cases, languages of this type are restrained from denoting algorithmic operations for computer security reasons—to prevent virus infection and remote takeover.
This shows how the very design of a formal language is a design for machine control.
Access to hardware functions is limited not only through the software application, but through the syntax the software application may use for storing and transmitting the information it processes.
To name one computer control language a “programming language,” another a “protocol,” and yet another a “file format” is merely a convention, a nomenclature indicating different degrees of syntactic restraint built into the very design of a computer control language.
In its most powerful Turing-complete superset, computer control language is language that executes.
As with magical and speculative concepts of language, the word automatically performs the operation.
Yet this is not to be confused with what linguistics calls a “performative” or “illocutionary” speech act, for example, the words of a judge who pronounces a verdict, a leader giving a command, or a legislator passing a law.
The execution of computer control languages is purely formal; it is the manipulation of a machine, not a social performance based on human conventions such as accepting a verdict.
Computer languages become performative only through the social impact of the processes they trigger, especially when their outputs aren’t critically checked.
Joseph Weizenbaum’s software psychotherapist Eliza, a simple program that syntactically transforms input phrases, is a classical example,5 as is the 1987 New York Stock Exchange crash that involved a chain reaction of “sell” recommendations by day trading software.6 Writing in a computer programming language is phrasing instructions for an utter idiot.
The project of Artificial Intelligence is to prove that intelligence is just a matter of a sufficiently massive layering of foolproof recipes—in linguistic terms, that semantics is nothing else but (more elaborate) syntax.
As long as A.I.
fails to deliver this proof, the difference between common languages and computer control languages continues to exist, and language processing through computers remains restrained to formal string manipulations, a fact that after initial enthusiasm has made many experimental poets since the 1950s abandon their experiments with computer-generated texts.7 The history of computing is rich with confusions of formal with common human languages, and false hopes and promises that formal languages would become more like common human languages.
Among the unrealized hopes are artificial intelligence, graphical user interface design with its promise of an “intuitive” or, to use Jef Raskin’s term, “humane interface,”8 and major currents of digital art.
Digital installation art typically misperceives its programmed behaviorist black boxes as “interactive,” and some digital artists are caught in the misconception that they can overcome what they see as the Western male binarism of computer languages by reshaping them after romanticized images of indigenous human languages.
The digital computer is a symbolic machine that computes syntactical language and processes alphanumerical symbols; it treats all data—including images and sounds—as textual, that is, as chunks of coded symbols.
Nelson Goodman’s criteria of writing as “disjunct” and “discrete,” or consisting of separate single entities that differ from other separate single entities, also applies to digital files.9 The very meaning of “digitization” is to structure analog data as numbers and store them as numerical texts composed of discrete parts.
All computer software controls are linguistic regardless of their perceivable shape, alphanumerical writing, graphics, sound signals, or whatever else.
The Unix command “rm file” is operationally identical to dragging the file into the trashcan on a desktop.
Both are just different encodings for the same operation, just as alphabetic language and morse beeps are different encodings for the same characters.
As a symbolic handle, this encoding may enable or restrain certain uses of the language.
In this respect, the differences between ideographic-pictorial and abstract-symbolic common languages also apply to computer control languages.
Pictorial symbols simplify control languages through predefined objects and operations, but make it more difficult to link them through a grammar and thus express custom operations.
Just as a pictogram of a house is easier to understand than the letters h-o-u-s-e, the same is true for the trashcan icon in comparison to the “rm” command.
But it is difficult to precisely express the operation “If I am home tomorrow at six, I will clean up every second room in the house” through a series of pictograms.
Abstract, grammatical alphanumeric languages are more suitable for complex computational instructions.10 The utopia of a universal pictorial computer control language (with icons, windows, and pointer operations) is a reenactment of the rise and eventual fall of universal pictorial language utopias in the Renaissance, from Tommaso Campanella’s “Città del sole” to Comenius’ “Orbis pictus”—although the modern project of expressing only machine operations in pictograms was less ambitious.
The converse to utopian language designs occurs when computer control languages get appropriated and used informally in everyday culture.
Jonathan Swift tells how scientists on the flying island of Lagado “would, for example, praise the beauty of a woman, or any other animal ... by rhombs, circles, parallelograms, ellipses, and other “geometrical terms.” 11 Likewise, there is programming language poetry which, unlike most algorithmic poetry, writes its program source as the poetical work, or crossbreeds cybernetic with common human languages.
These “code poems” or “codeworks” often play with the interference between human agency and programmed processes in computer networks.
In computer programming and computer science, “code” is often understood either as a synonym of computer programming language or as a text written in such a language.
This modern usage of the term “code” differs from the traditional mathematical and cryptographic notion of code as a set of formal transformation rules that transcribe one group of symbols to another group of symbols, for example, written letters into morse beeps.
The translation that occurs when a text in a programming language gets compiled into machine instructions is not an encoding in this sense because the process is not oneto-one reversible.
This is why proprietary software companies can keep their source “code” secret.
It is likely that the computer cultural understanding of “code” is historically derived from the name of the first high-level computer programming language, “Short Code” from 1950.12 The only programming language that is a code in the original sense is assembly language, the human- readable mnemonic one-to-one representation of processor instructions.
Conversely, those instructions can be coded back, or “disassembled,” into assembly language.
Software as a whole is not only “code” but a symbolic form involving cultural practices of its employment and appropriation.
But since writing in a computer control language is what materially makes up software, critical thinking about computers is not possible without an informed understanding of the structural formalism of its control languages.
Artists and activists since the French Oulipo poets and the MIT hackers in the 1960s have shown how their limitations can be embraced as creative challenges.
Likewise, it is incumbent upon critics to reflect the sometimes more and sometimes less amusing constraints and game rules computer control languages write into culture.
Notes
1. Hugh Kenner, “Beckett Thinking,” in Hugh Kenner, The Mechanic Muse, 83–107.
2. Ferdinand de Saussure, Course in General Linguistics, ”Chapter I: Nature of the Linguistic Sign.”
3. See the section, “Saussurean Signs and Material Matters,” in N. Katherine Hayles, My Mother Was a Computer, 42–45.
4. For example, Steve Wozniak’s design of the Apple I mainboard was consijdered “a beautiful work of art” in its time according to Steven Levy, Insanely Great: The Life and Times of Macintosh, 81.
5. Joseph Weizenbaum, “ELIZA—A Computer Program for the Study of Natural Language Communication between Man and Machine.”
6. Marsha Pascual, “Black Monday, Causes and Effects.”
7. Among them concrete poetry writers, French Oulipo poets, the German poet Hans Magnus Enzensberger, and the Austrian poets Ferdinand Schmatz and Franz Josef Czernin.
8. Jef Raskin, The Humane Interface: New Directions for Designing Interactive Systems.
9. According to Nelson Goodman’s definition of writing in The Languages of Art, 143.
10. Alan Kay, an inventor of the graphical user interface, conceded in 1990 that “it would not be surprising if the visual system were less able in this area than the mechanism that solve noun phrases for natural language. Although it is not fair to say that ‘iconic languages can’t work’ just because no one has been able to design a good one, it is likely that the above explanation is close to truth.” This status quo hasn’t changed since. Alan Kay, “User Interface: A Personal View,” in, Brenda Laurel ed. The Art of Human-Computer Interface Design, Reading: Addison Wesley, 1989, 203.
11. Swift, Jonathan, Gulliver’s Travels, Project Gutenberg Ebook, available at http:// www.gutenberg.org / dirs / extext197 / gltrv10.txt / .
12. See Wolfgang Hagen, “The Style of Source Codes.”

BIN
txt/language.pdf
View File

Binary file not shown.

0
txt/language.txt
Unescape Escape View File

57
txt/liquid.css
Unescape Escape View File

@ -0,0 +1,57 @@
@page{
size: A4;
margin: 15mm;
background-color: lightgrey;
font-family: monospace;
font-size: 8pt;
color: #7da0d4;
border:1.5x dotted red;
@top-left{
content: "liquid";
}
@top-center{
content: "bodies";
}
@top-right{
content: "natural";
}
@top-middle{
content: ""
}
@left-top{
content: "material";
}
@right-top{
content: "existence";
}
@bottom-left{
content: "flux";
}
@bottom-center{
content: "living";
}
@bottom-right{
content: "energy";
}
}
body {
background: #f7c694;
margin: 20px;
line-height: 2;
font-family: monospace;
}
pre {
white-space: pre-wrap;
}
span.NN {
font-style: italic;
color: white;
border: 2px dashed black;
}
span.JJ {
color: #9abae3;
}

14
txt/liquid.html
View File

File diff suppressed because one or more lines are too long

380
working-with-images/PIL-basics.ipynb
View File

File diff suppressed because one or more lines are too long

BIN
working-with-images/pillow_imagedraw.gif
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 107 KiB

18
working-with-language/NLTKing.ipynb
Unescape Escape View File

@ -11,9 +11,21 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": 1,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [
{
"ename": "ModuleNotFoundError",
"evalue": "No module named 'nltk'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-1-1d2184025e54>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mnltk\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'nltk'"
]
}
],
"source": [ "source": [
"import nltk" "import nltk"
] ]

433
working-with-language/WordNet-synsets.ipynb
Unescape Escape View File

@ -1,433 +0,0 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Wordnet"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"import nltk\n",
"from nltk.corpus import wordnet"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# You only need to run this once\n",
"# nltk.download('wordnet')"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Access to hardware functions is limited not only through the software application, but through the syntax the software application may use for storing and transmitting the information it processes.\n",
"\n"
]
}
],
"source": [
"lines = open('../txt/language.txt').readlines()\n",
"sentence = random.choice(lines)\n",
"print(sentence)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"----------\n",
"word: Access\n",
"synset: Synset('entree.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('entree.n.02')>\n",
"synset: Synset('access.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('access.n.02')>\n",
"synset: Synset('access.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('access.n.03')>\n",
"synset: Synset('access.n.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('access.n.04')>\n",
"synset: Synset('access.n.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('access.n.05')>\n",
"synset: Synset('access.n.06')\n",
"lemmas: <bound method Synset.lemma_names of Synset('access.n.06')>\n",
"synset: Synset('access.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('access.v.01')>\n",
"synset: Synset('access.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('access.v.02')>\n",
"----------\n",
"word: to\n",
"----------\n",
"word: hardware\n",
"synset: Synset('hardware.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('hardware.n.01')>\n",
"synset: Synset('hardware.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('hardware.n.02')>\n",
"synset: Synset('hardware.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('hardware.n.03')>\n",
"----------\n",
"word: functions\n",
"synset: Synset('function.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('function.n.01')>\n",
"synset: Synset('function.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('function.n.02')>\n",
"synset: Synset('function.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('function.n.03')>\n",
"synset: Synset('function.n.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('function.n.04')>\n",
"synset: Synset('function.n.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('function.n.05')>\n",
"synset: Synset('affair.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('affair.n.03')>\n",
"synset: Synset('routine.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('routine.n.03')>\n",
"synset: Synset('function.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('function.v.01')>\n",
"synset: Synset('serve.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('serve.v.01')>\n",
"synset: Synset('officiate.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('officiate.v.02')>\n",
"----------\n",
"word: is\n",
"synset: Synset('be.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.01')>\n",
"synset: Synset('be.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.02')>\n",
"synset: Synset('be.v.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.03')>\n",
"synset: Synset('exist.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('exist.v.01')>\n",
"synset: Synset('be.v.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.05')>\n",
"synset: Synset('equal.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('equal.v.01')>\n",
"synset: Synset('constitute.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('constitute.v.01')>\n",
"synset: Synset('be.v.08')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.08')>\n",
"synset: Synset('embody.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('embody.v.02')>\n",
"synset: Synset('be.v.10')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.10')>\n",
"synset: Synset('be.v.11')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.11')>\n",
"synset: Synset('be.v.12')\n",
"lemmas: <bound method Synset.lemma_names of Synset('be.v.12')>\n",
"synset: Synset('cost.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('cost.v.01')>\n",
"----------\n",
"word: limited\n",
"synset: Synset('express.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('express.n.02')>\n",
"synset: Synset('restrict.v.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('restrict.v.03')>\n",
"synset: Synset('limit.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('limit.v.02')>\n",
"synset: Synset('specify.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('specify.v.02')>\n",
"synset: Synset('limited.a.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('limited.a.01')>\n",
"synset: Synset('circumscribed.s.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('circumscribed.s.01')>\n",
"synset: Synset('limited.s.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('limited.s.03')>\n",
"synset: Synset('limited.s.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('limited.s.04')>\n",
"synset: Synset('limited.s.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('limited.s.05')>\n",
"synset: Synset('limited.s.06')\n",
"lemmas: <bound method Synset.lemma_names of Synset('limited.s.06')>\n",
"synset: Synset('limited.s.07')\n",
"lemmas: <bound method Synset.lemma_names of Synset('limited.s.07')>\n",
"----------\n",
"word: not\n",
"synset: Synset('not.r.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('not.r.01')>\n",
"----------\n",
"word: only\n",
"synset: Synset('lone.s.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('lone.s.03')>\n",
"synset: Synset('alone.s.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('alone.s.03')>\n",
"synset: Synset('merely.r.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('merely.r.01')>\n",
"synset: Synset('entirely.r.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('entirely.r.02')>\n",
"synset: Synset('only.r.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('only.r.03')>\n",
"synset: Synset('only.r.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('only.r.04')>\n",
"synset: Synset('only.r.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('only.r.05')>\n",
"synset: Synset('only.r.06')\n",
"lemmas: <bound method Synset.lemma_names of Synset('only.r.06')>\n",
"synset: Synset('only.r.07')\n",
"lemmas: <bound method Synset.lemma_names of Synset('only.r.07')>\n",
"----------\n",
"word: through\n",
"synset: Synset('done.s.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('done.s.01')>\n",
"synset: Synset('through.s.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.s.02')>\n",
"synset: Synset('through.r.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.01')>\n",
"synset: Synset('through.r.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.02')>\n",
"synset: Synset('through.r.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.03')>\n",
"synset: Synset('through.r.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.04')>\n",
"synset: Synset('through.r.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.05')>\n",
"----------\n",
"word: the\n",
"----------\n",
"word: software\n",
"synset: Synset('software.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('software.n.01')>\n",
"----------\n",
"word: application,\n",
"----------\n",
"word: but\n",
"synset: Synset('merely.r.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('merely.r.01')>\n",
"----------\n",
"word: through\n",
"synset: Synset('done.s.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('done.s.01')>\n",
"synset: Synset('through.s.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.s.02')>\n",
"synset: Synset('through.r.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.01')>\n",
"synset: Synset('through.r.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.02')>\n",
"synset: Synset('through.r.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.03')>\n",
"synset: Synset('through.r.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.04')>\n",
"synset: Synset('through.r.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('through.r.05')>\n",
"----------\n",
"word: the\n",
"----------\n",
"word: syntax\n",
"synset: Synset('syntax.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('syntax.n.01')>\n",
"synset: Synset('syntax.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('syntax.n.02')>\n",
"synset: Synset('syntax.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('syntax.n.03')>\n",
"----------\n",
"word: the\n",
"----------\n",
"word: software\n",
"synset: Synset('software.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('software.n.01')>\n",
"----------\n",
"word: application\n",
"synset: Synset('application.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('application.n.01')>\n",
"synset: Synset('application.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('application.n.02')>\n",
"synset: Synset('application.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('application.n.03')>\n",
"synset: Synset('application.n.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('application.n.04')>\n",
"synset: Synset('lotion.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('lotion.n.02')>\n",
"synset: Synset('application.n.06')\n",
"lemmas: <bound method Synset.lemma_names of Synset('application.n.06')>\n",
"synset: Synset('application.n.07')\n",
"lemmas: <bound method Synset.lemma_names of Synset('application.n.07')>\n",
"----------\n",
"word: may\n",
"synset: Synset('may.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('may.n.01')>\n",
"synset: Synset('whitethorn.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('whitethorn.n.01')>\n",
"----------\n",
"word: use\n",
"synset: Synset('use.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.n.01')>\n",
"synset: Synset('function.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('function.n.02')>\n",
"synset: Synset('use.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.n.03')>\n",
"synset: Synset('consumption.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('consumption.n.03')>\n",
"synset: Synset('habit.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('habit.n.02')>\n",
"synset: Synset('manipulation.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('manipulation.n.01')>\n",
"synset: Synset('use.n.07')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.n.07')>\n",
"synset: Synset('use.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.v.01')>\n",
"synset: Synset('use.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.v.02')>\n",
"synset: Synset('use.v.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.v.03')>\n",
"synset: Synset('use.v.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.v.04')>\n",
"synset: Synset('practice.v.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('practice.v.04')>\n",
"synset: Synset('use.v.06')\n",
"lemmas: <bound method Synset.lemma_names of Synset('use.v.06')>\n",
"----------\n",
"word: for\n",
"----------\n",
"word: storing\n",
"synset: Synset('store.v.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('store.v.01')>\n",
"synset: Synset('store.v.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('store.v.02')>\n",
"----------\n",
"word: and\n",
"----------\n",
"word: transmitting\n",
"synset: Synset('transmission.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('transmission.n.01')>\n",
"synset: Synset('convey.v.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('convey.v.03')>\n",
"synset: Synset('impart.v.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('impart.v.03')>\n",
"synset: Synset('air.v.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('air.v.03')>\n",
"synset: Synset('transmit.v.04')\n",
"lemmas: <bound method Synset.lemma_names of Synset('transmit.v.04')>\n",
"----------\n",
"word: the\n",
"----------\n",
"word: information\n",
"synset: Synset('information.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('information.n.01')>\n",
"synset: Synset('information.n.02')\n",
"lemmas: <bound method Synset.lemma_names of Synset('information.n.02')>\n",
"synset: Synset('information.n.03')\n",
"lemmas: <bound method Synset.lemma_names of Synset('information.n.03')>\n",
"synset: Synset('data.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('data.n.01')>\n",
"synset: Synset('information.n.05')\n",
"lemmas: <bound method Synset.lemma_names of Synset('information.n.05')>\n",
"----------\n",
"word: it\n",
"synset: Synset('information_technology.n.01')\n",
"lemmas: <bound method Synset.lemma_names of Synset('information_technology.n.01')>\n",
"----------\n",
"word: processes.\n"
]
}
],
"source": [
"words = sentence.split()\n",
"for word in words:\n",
" print('----------')\n",
" print('word:', word)\n",
" for synset in wordnet.synsets(word):\n",
" print('synset:', synset)\n",
" print('lemmas:', synset.lemma_names)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<bound method Lemma.name of Lemma('car.n.01.car')>\n",
"<bound method Lemma.name of Lemma('car.n.02.car')>\n",
"<bound method Lemma.name of Lemma('car.n.03.car')>\n",
"<bound method Lemma.name of Lemma('car.n.04.car')>\n",
"<bound method Lemma.name of Lemma('cable_car.n.01.car')>\n"
]
}
],
"source": [
"for lemma in wordnet.lemmas('car'):\n",
" print(lemma.name)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<bound method Synset.examples of Synset('car.n.01')>\n",
"<bound method Synset.examples of Synset('car.n.02')>\n",
"<bound method Synset.examples of Synset('car.n.03')>\n",
"<bound method Synset.examples of Synset('car.n.04')>\n",
"<bound method Synset.examples of Synset('cable_car.n.01')>\n"
]
}
],
"source": [
"for synset in wordnet.synsets('car'):\n",
" print(synset.examples)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

255
working-with-language/tfidf.ipynb
View File

File diff suppressed because one or more lines are too long
Write Preview
Loading…
Cancel
Save