Learning he SQL statements - insert statement

Learning he SQL statements - insert statement

Lesson Details:
June 29, 2020

I: Introduction

Programming Language is an artificial language that is designed to communicate instructions

to a machine, particularly a computer. It is used to create programs that can be run on the

machine. The syntax of programming language is different in each language.

Python Programming Language is a high-level programming language which was created by Guido van

Rossum in 1991. It is open source and free software. It has also evolved into a general-purpose


Python has implementations available for many operating systems. It has built-in data types,

including booleans, numerics, sequences, sets, and dictionaries. Built-in data structures include

tuples, lists, sets, and dictionaries. It also supports many specialty data types. Python's dynamic

typing and the inclusion of immutable types makes it a versatile programming language that can

be used for a variety of applications. Its standard library has a module that allows the programmer

to work with XML documents. Other key python features are its clear syntax and its readability. Python is a powerful high level programming language. It is easy to learn and use because it is similar to English. It has rich set of built-in data structures and built-in support for common algorithms. In addition it has libraries to provide functionality not included in the core language. Python is also very easy to write extension modules for other applications . Python was originally developed by Guido van Rossum at CWI in the Netherlands as a successor to the ABC language that he had designed for the Amoeba distributed operating system. Python's design goals include good-programming-practice compatibility with C while offering high-level data types and dynamic typing. Python was intended to be a replacement for ABC and ABC's Pedler later served as the model for Python's reference implementation, CPython. In October 1991, Van Rossum released version 1.0 of the Python interpreter and the code was made available to other interested parties via an open source license which granted rights to modify and redistribute Python to anyone who asked and who agreed to give proper credit and support Van Rossum's continued involvement with the project. The original version was described as "very alpha" and had many bugs; Van Rossum received much assistance from volunteers who used the mailing lists and contributed bug fixes, ideas, and even whole new implementations for operating systems not covered by the existing ones. Some early adopters were interested in using Python as an easy way to learn programming, so they typed in programs from books and O'Reilly's published editions of "Programming Python" (by Mark Lutz) and "Learning Python" (by Mark Lutz and David Ascher), and the Python Cookbook (by Alex Martelli and David Ascher). The availability of these books encouraged programmers to contribute improved versions of their code to Van Rossum, who incorporated many of them into the official Python distributions. The feedback from programmers also prompted Van Rossum to add many new features to Python; it is said that most new features have been suggested by some programmer somewhere in the world through one of Python's online discussion groups. Because of its success in the programming community, many programmers began writing books about Python in order to help others learn the language; among them was Learning Python by Mark Lutz, which was published in 1996 and became popular among new Python programmers. In December 2002 Van Rossum stepped down as leader of the Python Software Foundation and turned over leadership of the foundation to Thomas Wouters; Van Rossum remains active in the Python community, but no longer holds an official role in leading development or directing the long-term direction of development efforts such as those aimed at adding closures to Python. In October 2002 there were two major changes: Python 2.2 introduced iterators and generators, which enabled the creation of simpler list comprehensions; generators were added so as to allow lazy evaluations. Simpler list comprehensions were possible before this change, but required coding certain algorithms rather than using higher level constructs (see list slicing). Also added was a complex number datatype (called Ctypes), which is used by NumPy for efficient computation on arrays of complex numbers; array slicing is implemented using this datatype; NumPy uses NumPy Array objects behind the scenes; NumPy was designed to take advantage of Ctypes, which allows NumPy to benefit from C optimizations such as vectorization (where multiple array elements are processed per call). In January 2003, Python 2.3 was released; it contained many speed improvements, such as an improved iteration over dictionaries, Unicode strings (which may contain any character from the Unicode character set), a bytecode optimizer, a simplified class attribute lookup mechanism, a fast new implementation for shutil, a better file system interface implemented on top of lib2to3's abstract base classes (which allowed directory walkers to be written in pure Python), standard object finalization mechanism based on weakrefs, better string handling capabilities, faster string sorting algorithm named Timsort, etc.; it also added some new modules such as ElementTree (an XML parsing module), ConfigParser(a configuration file parser), binary data support through binascii module which supports binary floating point numbers through the use of a format called "binary packed decimal", a database API that supports SQLite 3 database files/databases which was previously only available through PySQLite module thought not part of standard library), a powerful text processing module re based on regular expressions named regexp , an MPFR/MPF/MPC-based arbitrary precision float point arithmetic module named decimal ; there were also some new syntax additions such as lambda function which represents anonymous function expressions with lexical scope provided by enclosing parentheses ("Lambda expressions" section of Wikipedia). Starting from version 2.4, Python started including more advanced modules from different domains such as statistics, linear algebra, XML processing etc., all bundled under SciPy name; currently SciPy consists of NumPy (numerical computing), SciPy (scientific tools) and Matplotlib (mathematical plotting); there are also third party packages which extend this core stack like SymPy (symbolic mathematics) or Pandas (data analysis). Many users think that this package distribution approach is an improvement over earlier versions because it provides consistency across packages; however it makes it difficult for users outside scientific domains to find related packages. Version 2.5 added yet more modules including DB API 2 (an update of database API that supports several database management systems including SQLite 3), ElementTree 1.1 (a newer version of an XML parsing module), logging module (for writing log messages), threading (for using threads within multi-threaded programs) and Tkinter (for using an object oriented interface based on Tcl/Tk toolkit). Version 2.6 added subprocess module (for running processes) and subprocess32 module (for running 32 bit processes on 64 bit platforms). Version 2.7 added inspect module (for introspecting live objects) and collections module (for working with various collection types). Version 3.0 added execnet module (for creating network sockets), pathlib module (for manipulating filesystem paths), concurrent.futures module (for parallel programming without threads), typing module (for static type checking) and asyncio module (for asynchronous I/O). Version 3.5 added memoryview module (for working with memory buffers) and pathlib2 module (for manipulating filesystem paths). Most recently version 3.6 added asyncpgmv3 module to work with PostgreSQL databases using asynchronous programming model. There are also third party packages for parallel computing through Charm++ parallel framework or Intel Threading Building Blocks parallel framework via IPython parallel computing kernel which implements concurrency using threads or processes respectively . This trend has continued with recent versions of Python where additional special purpose packages have been added on top of core stack for example SQLAlchemy for working with relational databases using Object Relational Mapping paradigm . Further examples are PyCUDA for integrating CUDA GPU programming platform into Python programs or PyOpenCL for integrating OpenCL GPU programming platform into Python programs . Among other notable additions are multiprocessing package for executing sub processes simultaneously or concurrently via subprocess package , ctypes package for faster foreign function calls through FFI , decorator package for easier decoration of classes , contextlib package which helps with anti-patterns that involve passing context objects like file descriptors or locks around in functions or methods , enum package for ability to define enumerations programmatically , faulthandler package for handling crashes , functools package for functional tools , ipaddress package for dealing with IP addresses , numpy package for performing array oriented numerical calculations , pathlib package for dealing with filesystem paths , pytest package , pytest-cov module (for coverage testing)

Course content