Skip to content

Instantly share code, notes, and snippets.

@tvieiragoncalves

tvieiragoncalves/Untitled.ipynb

Created July 30, 2019 15:53
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save tvieiragoncalves/93c55fc5a7a5ab3465f8e0288ad97a18 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save tvieiragoncalves/93c55fc5a7a5ab3465f8e0288ad97a18 to your computer and use it in GitHub Desktop.
Download ZIP
Created on Cognitive Class Labs
Display the source blob
Display the rendered blob
Raw
Untitled.ipynb
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"--2019-07-30 15:45:28-- https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/labs/example1.txt\n",
"Resolving s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)... 67.228.254.193\n",
"Connecting to s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)|67.228.254.193|:443... connected.\n",
"HTTP request sent, awaiting response... 200 OK\n",
"Length: 45 [text/plain]\n",
"Saving to: ‘/resources/data/Example1.txt’\n",
"\n",
"/resources/data/Exa 100%[===================>] 45 --.-KB/s in 0s \n",
"\n",
"2019-07-30 15:45:28 (19.9 MB/s) - ‘/resources/data/Example1.txt’ saved [45/45]\n",
"\n"
]
}
],
"source": [
"!wget -O /resources/data/Example1.txt https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/labs/example1.txt"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"example1 = \"/resources/data/Example1.txt\"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"file1 = open(example1, \"r\")"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'/resources/data/Example1.txt'"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"file1.name"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'r'"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"file1.mode"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on built-in function open in module io:\n",
"\n",
"open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)\n",
" Open file and return a stream. Raise IOError upon failure.\n",
" \n",
" file is either a text or byte string giving the name (and the path\n",
" if the file isn't in the current working directory) of the file to\n",
" be opened or an integer file descriptor of the file to be\n",
" wrapped. (If a file descriptor is given, it is closed when the\n",
" returned I/O object is closed, unless closefd is set to False.)\n",
" \n",
" mode is an optional string that specifies the mode in which the file\n",
" is opened. It defaults to 'r' which means open for reading in text\n",
" mode. Other common values are 'w' for writing (truncating the file if\n",
" it already exists), 'x' for creating and writing to a new file, and\n",
" 'a' for appending (which on some Unix systems, means that all writes\n",
" append to the end of the file regardless of the current seek position).\n",
" In text mode, if encoding is not specified the encoding used is platform\n",
" dependent: locale.getpreferredencoding(False) is called to get the\n",
" current locale encoding. (For reading and writing raw bytes use binary\n",
" mode and leave encoding unspecified.) The available modes are:\n",
" \n",
" ========= ===============================================================\n",
" Character Meaning\n",
" --------- ---------------------------------------------------------------\n",
" 'r' open for reading (default)\n",
" 'w' open for writing, truncating the file first\n",
" 'x' create a new file and open it for writing\n",
" 'a' open for writing, appending to the end of the file if it exists\n",
" 'b' binary mode\n",
" 't' text mode (default)\n",
" '+' open a disk file for updating (reading and writing)\n",
" 'U' universal newline mode (deprecated)\n",
" ========= ===============================================================\n",
" \n",
" The default mode is 'rt' (open for reading text). For binary random\n",
" access, the mode 'w+b' opens and truncates the file to 0 bytes, while\n",
" 'r+b' opens the file without truncation. The 'x' mode implies 'w' and\n",
" raises an `FileExistsError` if the file already exists.\n",
" \n",
" Python distinguishes between files opened in binary and text modes,\n",
" even when the underlying operating system doesn't. Files opened in\n",
" binary mode (appending 'b' to the mode argument) return contents as\n",
" bytes objects without any decoding. In text mode (the default, or when\n",
" 't' is appended to the mode argument), the contents of the file are\n",
" returned as strings, the bytes having been first decoded using a\n",
" platform-dependent encoding or using the specified encoding if given.\n",
" \n",
" 'U' mode is deprecated and will raise an exception in future versions\n",
" of Python. It has no effect in Python 3. Use newline to control\n",
" universal newlines mode.\n",
" \n",
" buffering is an optional integer used to set the buffering policy.\n",
" Pass 0 to switch buffering off (only allowed in binary mode), 1 to select\n",
" line buffering (only usable in text mode), and an integer > 1 to indicate\n",
" the size of a fixed-size chunk buffer. When no buffering argument is\n",
" given, the default buffering policy works as follows:\n",
" \n",
" * Binary files are buffered in fixed-size chunks; the size of the buffer\n",
" is chosen using a heuristic trying to determine the underlying device's\n",
" \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n",
" On many systems, the buffer will typically be 4096 or 8192 bytes long.\n",
" \n",
" * \"Interactive\" text files (files for which isatty() returns True)\n",
" use line buffering. Other text files use the policy described above\n",
" for binary files.\n",
" \n",
" encoding is the name of the encoding used to decode or encode the\n",
" file. This should only be used in text mode. The default encoding is\n",
" platform dependent, but any encoding supported by Python can be\n",
" passed. See the codecs module for the list of supported encodings.\n",
" \n",
" errors is an optional string that specifies how encoding errors are to\n",
" be handled---this argument should not be used in binary mode. Pass\n",
" 'strict' to raise a ValueError exception if there is an encoding error\n",
" (the default of None has the same effect), or pass 'ignore' to ignore\n",
" errors. (Note that ignoring encoding errors can lead to data loss.)\n",
" See the documentation for codecs.register or run 'help(codecs.Codec)'\n",
" for a list of the permitted encoding error strings.\n",
" \n",
" newline controls how universal newlines works (it only applies to text\n",
" mode). It can be None, '', '\\n', '\\r', and '\\r\\n'. It works as\n",
" follows:\n",
" \n",
" * On input, if newline is None, universal newlines mode is\n",
" enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n",
" these are translated into '\\n' before being returned to the\n",
" caller. If it is '', universal newline mode is enabled, but line\n",
" endings are returned to the caller untranslated. If it has any of\n",
" the other legal values, input lines are only terminated by the given\n",
" string, and the line ending is returned to the caller untranslated.\n",
" \n",
" * On output, if newline is None, any '\\n' characters written are\n",
" translated to the system default line separator, os.linesep. If\n",
" newline is '' or '\\n', no translation takes place. If newline is any\n",
" of the other legal values, any '\\n' characters written are translated\n",
" to the given string.\n",
" \n",
" If closefd is False, the underlying file descriptor will be kept open\n",
" when the file is closed. This does not work when a file name is given\n",
" and must be True in that case.\n",
" \n",
" A custom opener can be used by passing a callable as *opener*. The\n",
" underlying file descriptor for the file object is then obtained by\n",
" calling *opener* with (*file*, *flags*). *opener* must return an open\n",
" file descriptor (passing os.open as *opener* results in functionality\n",
" similar to passing None).\n",
" \n",
" open() returns a file object whose type depends on the mode, and\n",
" through which the standard file operations such as reading and writing\n",
" are performed. When open() is used to open a file in a text mode ('w',\n",
" 'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\n",
" a file in a binary mode, the returned class varies: in read binary\n",
" mode, it returns a BufferedReader; in write binary and append binary\n",
" modes, it returns a BufferedWriter, and in read/write mode, it returns\n",
" a BufferedRandom.\n",
" \n",
" It is also possible to use a string or bytearray as a file for both\n",
" reading and writing. For strings StringIO can be used like a file\n",
" opened in a text mode, and for bytes a BytesIO can be used like a file\n",
" opened in a binary mode.\n",
"\n"
]
}
],
"source": [
"help(open)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'This is line 1 \\nThis is line 2\\nThis is line 3'"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\n",
"FileContent = file1.read()\n",
"FileContent"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"T\n",
"h\n",
"i\n",
"s\n",
" \n",
"i\n",
"s\n",
" \n",
"l\n",
"i\n",
"n\n",
"e\n",
" \n",
"1\n",
" \n",
"\n",
"\n",
"T\n",
"h\n",
"i\n",
"s\n",
" \n",
"i\n",
"s\n",
" \n",
"l\n",
"i\n",
"n\n",
"e\n",
" \n",
"2\n",
"\n",
"\n",
"T\n",
"h\n",
"i\n",
"s\n",
" \n",
"i\n",
"s\n",
" \n",
"l\n",
"i\n",
"n\n",
"e\n",
" \n",
"3\n"
]
}
],
"source": [
"for i in FileContent:\n",
" print(i)\n",
" \n",
" "
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(FileContent)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This\n"
]
}
],
"source": [
"with open(example1, \"r\") as file1:\n",
" print(file1.read(4))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"with open(example1, \"r\") as file1:\n",
" print(\"first line: \" + file1.readline())"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python",
"language": "python",
"name": "conda-env-python-py"
},
"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.6.7"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment