Python spaCy NLP Library

Fri, 31 Mar 2023 14:47:25 +0400

Python Libraries, tools and Links | Official Python Docs | Intro to Pygame | spaCy

Python spaCy NLP Library

Here is the truth about spaCy: it is an industrial-strength Natural Language Processing library for Python that treats linguistic annotation as a pipeline of fast, composable components. If you need to tokenise, tag, parse or recognise entities in real text, spaCy is the default workhorse.

What it is, in plain words

spaCy (Explosion AI) provides:

Intro to Pygame Notes

Thu, 30 Mar 2023 23:23:52 +0400

Python Libraries, tools and Links | Official Python Docs | Intro to Pygame

Intro to Pygame Notes

Here is the truth about Pygame: it is a friendly box of SDL bindings that lets Python draw pixels, play sounds and read joysticks – enough to make real games without a 3D engine. If you can write a loop and blit a surface, you can ship a game.

What it is, in plain words

Pygame is a community library wrapping SDL2 for Python. It gives you:

Python Keywords

Sun, 05 Sep 2021 05:50:54 +0400

Python Keywords

Here is the truth about Python keywords: there are only a few dozen of them, they are the grammar of the language, and you cannot use them as names. Everything else is a builtin or an ordinary identifier.

What it is, in plain words

A keyword (reserved word) is a token the Python parser treats specially. As of Python 3.12/3.13 the set includes:

iPython

Sat, 03 Dec 2016 00:34:08 +0400

iPython

Here is the truth about IPython: the best place to learn Python is not a file – it’s a prompt that remembers what you just did, shows you plots, and lets you edit the last thought. IPython is that prompt, and Jupyter is the notebook built around it.

SciPy

Sat, 03 Dec 2016 00:30:25 +0400

SciPy

Here is the truth about SciPy: it is the standard library Python never shipped for science and engineering. Where NumPy gives you arrays, SciPy gives you the algorithms that use them – integration, optimisation, signal processing, statistics, sparse linear algebra and more.

What it is, in plain words

SciPy (pronounced “sigh pie”) is an open-source Python library built on NumPy. It collects battle-tested implementations of classical numerical methods, many of them wrappers around the same Fortran and C libraries (QUADPACK, FFTpACK, ARPACK, ODEPACK, LAPACK) that scientists have trusted for decades. The top-level packages you’ll actually import:

NumPy

Sat, 03 Dec 2016 00:29:14 +0400

NumPy

Here is the truth that makes Python fast at maths: the maths isn’t actually done in Python. NumPy hands whole arrays to compiled C (and Fortran-descended) code in one go, and that single idea – think in arrays, not loops – is what makes the whole scientific Python world possible.

Python Language Notes

Sun, 27 Nov 2016 21:45:02 +0400

Python Libraries, tools and Links | Official Python Docs | Intro to Pygame | spaCy

Python Language Notes

Lexical Analysis
Keywords

name ::= lc_letter (lc_letter | "_")*
lc_letter ::= "a"..."z"

1. **Operators and Builtin Functions**
1. 1. **All Types**
 1. ```
 type(obj) --> type object
 ```
 1. ```
 isinstance(obj, typ) --> bool
 ```
 1. ```
 repr(obj) #evaluatable representation
 ```
 1. ```
 str(obj) #printable representation
 ```
 1. ```
 is, is not # are two objects the same
 ```
1. - **All Numeric Types**
 - - ` abs(-1) # 1`
 - ` chr(65) #'A' `
 - ` ord('A')#65 `
 - ` complex(1) #(1+0j) `
 - ` divmod(25,7) #(3,4) `
 - ` pow(2,8) #256 `
 - ` round(2.75,1) #2.8, rounds up `
1. **Objects**
1. ```
int, float, bool, dict, set, tuple, str, bytes
 None

Classification
- Primative, Numeric, Sequence, Container: Can contain other types, Collection
- Common use cases
- - Dictionaries for lookups
    - Tuples for data that is invariant at runtime
    - Lists for dynamic runtime data
Primative Types
- bool -> True, False
- - bool(float("NaN")) --> True
    - bool(0.0) --> False
    - bool(0) --> False
    - bool([]) --> False
- int
- - 2**31 - 1
    - binary: 0b10, bin(20) #'0b10100'
    - octal: 0o77, oct(20) #'0o24"
    - hex: 0xFF, hex(20) #'0x14'
    - int(3.5); int("3.5"); int("1111", 1) --> 15
    - abs(-1)
    - 1//3 #0, integer division
- float
- - 1.41
    - 3e-5
    - float(3), float("3.14")
    - float("nan"), float("inf"), float("-inf")
    - : {round(1.234, 2)
Complex
```
complex(2,3) #(2+3j)
```

1. **Sequence** (Builtin Functions)
1. `len(obj)`
1. - **character** (char): `ord(char)` --> int
 - **strings**
 - ```
 help(str)
 >>> m = """This is
 ... a multiline
 ... string"""
 'This is\na multiline\nstring'
 print(m)
 str(666)
 "Vi er så glad for å høre og lære om Python!" # 'Vi er så glad for å høre og lære om Python!'
 "Vi er s\u00e5 glad for \u00e5 h\xf8re og l\u00e6re om Python!" ' #Vi er så glad for å høre og lære om Python!'
 ```
 - ```
 '\\xe5'
 'å' 
 ```
 - ```
 '\\345' 'å'
 ```
 - ```
 str.title(), str.upper(), str.lower, str.lstrip(), .rstrip, .strip
 var = 'in'
 print(f"I am {var} trouble!")
 ```
 - **f**
 - raw strings `r'this is t raw'`
 - - implicit concatantion `"hello" "world"`
 - bytes `b'this is a byte string'`
 - ```
 b'this is a byte string'.split()
 [b'this', b'is', b'a', b'byte', b'string']
 "Vi er så glad for ".encode('utf-8')
 b'Vi er sa\\xcc\\x8a glad for '.decode('utf-8')
 ```
 - **bytearray**
 - **tuple**
 - ```
 (1,2)
 (False, 1, 'c')
 (2,) + (9,) => (2,9)
 ```
 - **Lists**
 - ```
 [1,2,3]
 [True, False, '7']
 ```
 - ```
 append(x), count(x), extend(L), index(x), insert(x), insert(i,x), pop(x), remove(x), reverse(), sort()
 ```
 - ```
 alist = [0, 1, 2, 3]
 del alist[2] #[0, 1, 3]
 ```
 - **slice**
 - ```
 mylist[:]
 ```
 - - **Sorting Lists**
 - ```
 sorted() #generate a copy
 sort
 sorted(x, reverse=True)
 reverse()
 ```
 - **Numerical Lists**
 - ` range() `
 - ```
 list(range(5))
 list(range(5,11))
 nums = []
 for exp in range(5):
 nums.append(2**exp)
 ```
 - **List Comprehensions**
 - ```
 [2**exp for exp in range(5)]
 ```
 - ` [i**3 for i in range(10) if True] `
 - ```
 f = open("test.txt", 'r')
 data = [line.strip for line in f]
 f.close()
 # now process data
 ```
 - **Generator Expressions**
 - *list comprensions*
 - ```
 f = open("test.txt", 'r')
 data = (line.strip for line in f)
 #now process data before closing the file!
 f.close()
 ```
 - **dictionary**
 - ` {key:value}`
 - ` 'key' in dict `
 - ```
 states = {
 	'ca': 'California',
 	'il': 'Illinois',
 	'fl': 'florida',
 	}
 states['ca']
 states.get('xx', 'default value') # equivalant to: states['xx'] if 'xx' in states else 'default value'
 states.setdefault('xx', 'default value') #in not there set and return the key.
 states['ny'] = 'New York'
 del states['il']
 states.values() #dict_values([...]), <class 'dict_values'>
 states.items()
 states.keys()
 ```
 - ```
 has_key(), keys(), values(), dict.items(), clear(), copy(), update(x), get(x,[y])
 ```
 - **Set**
 - ` {1,2,3}`
 - ```
 s = set()
 s.add(1)
 s.add('foo')
 t = set()
 s | t #union of t & s
 ```
 - *Set Comprehensions*
 - ```
 odd = \{i for i in range(10) if i % 2\}
 ```
 - **Frozenset**
 - **Complex**
1. **Modules and Packages**
1. - **Modules**
 - ```
 import module
 import module as mod
 from module import specific_function
 ```
 - **Packages**
 - *maps*
 - ```
 maps/
 __init__.py
 cities.py
 navigation.py
 gpsdata.py
 ```
 - **__init__.py**
 - ```
 import maps 
 ```
 - ```
 maps.navigation.turn_right() 
 ```
1. **Standard Library / Types**
1. - **math**
 - ```
 import math
 math.sqrt(16)
 PI = math.pi
 math.sin(PI)
 math.log(1000, 10)
 ```
 - **Fraction**
 - **Decimal**
 - **Date**
 - **Array**
 - **range**
 - ```
 range(5)
 ```
1. **Converstion Functions**
1. - `int, float, bool, str, tuple, list, dict, set`
 - `chr(int)` --> char
1. **Operators**
1. - ` + 1 * ** / // % `
 - ` ~ >> << & ^ | `
 - ` < > <= >= <> != == `
 - ` and, or, not `
 - ```
 <string | list> + <string | list>
 'five' + 'four'
 <int> * <string | list>
 <obj> in <seq>
 ```
 - **Function application**
 - ` function(args...)`
 - **Indexing**
 - ` seq[index | range] `
 - **Lookup (dictionaries)**
 - ` d[key] `
1. **Expressions**
1. ```
 Operator Precedence
| no. | operators | description |
| 1 | f(...) | function application |
| 2 | o[l] | index lookups |
| 3 | o.f(...) | method call |
| 4 | ** | exponentiation |
| 5 | -N | sign change |
| 6 | *,/,//,% | numeric |
| 7 | +,- | numeric |
| 8 | <, <=, ... | comparisons |
| 9 | in, not in | membership |
| 10 | not o | logical |
| 11 | and 0 | logical |
| 12 | or | logical |

Rules for Well-formedness

R1
```
 Every Value is well formed
```
R2 (E)

 if E is well formed then (E) is well formed

R3 <uop> E

 <uop> is a unary operation
 if E, then <uop> E is well formed

R4 E1 <bop> E2

 <bop> is a binary operation
 if E1, E2, then E1 <bop> E2

R5 E1[E2]
```
 if E1, E2, the E1[E2]
```
R6 F(A, …)

 if F is a function with A, A1, A2, ... expressions
 then F(), F(A), F(A, A1), F(A, A1, A2), ...

R7 if O.f(E)

 if O, f, E, E1, ...
 then O.f(), O.f(E), O.f(E, E1), ...

Printing

print("hello", 'how')
print("hello", end='')
from pprint import *
pprint(expressions)

1. **Functions**
1. *anonymous*
1. - **lambda**
 - ```
 lambda x: x
 ```
 - **def**
 - ```
 def f(x,y):
 return x + y
 ```
 - ```
 def h():
 "hello"
 #This function returns None
 h() #None
 ```
 - **keyword**
 - ```
 def f(x=0, y=0):
 print("x = ", x, "y = ", y)
 return (x, y)
 f(x=1, 2)
 f()
 f(1)
 ```
 - **Destructuring with Tuples**
 - *positional*
 - ```
 def ff(*a):
 print("first = ", a[0], "Second = ", a[1])
 return (len(a), a)
 ```
 - **Destructuring with Dictionaries**
 - ```
 def fff(**a):
 print(a["first"])
 return a
 ```
 - **destructuring with both**
 - ```
 def g(*a,**b):
 return (a,b)
 ```
1. **Methods**
1. ```
 x+1
 [is actually]
 x.__add__(1)

Magic Methods

__add__(self, y) # x + y
__sub__(self, y) # x - y
__mul__(self, y) # x * y
__mod__(self, y) # x % y
__neg__(self) # -x
__eq__(self, y) # x == y
__ge__(self, y) # x >= y
__gt__(self, y) # x > y
__lt__(self, y) # x < y
__le__(self, y) # x <= y
__ne__(self, y) # x != y
__contains__(self,y) # y in x
__getitem__(self, y) # x[y]
__setitem__(self, i, y) # x[i] = y
__hash__(self) # hash(x)
__int__(self) # int(x)
__iter__(self) # for y in x
__len__(self) # len(x)
__repr__(self) # repr(x)
__str__(self) # str(x)

Some Builtins
```
abs, min, max
type
len
dir
```

gives internal dictionary of names

Python on The VikiD Truth

Python spaCy NLP Library

Python spaCy NLP Library

What it is, in plain words

Intro to Pygame Notes

Intro to Pygame Notes

What it is, in plain words

Python Keywords

Python Keywords

What it is, in plain words

iPython

iPython

SciPy

SciPy

What it is, in plain words

NumPy

NumPy

Python Language Notes

Python Language Notes