#numbers in python

[ankitmadan]

Python Numbers-InsideAIML

Python Numbers blog provide brief about python int, python float, python decimal, python string concatenation, etc. Click To Read More

[shilkaren]

Top 7 Trends of Education Technology for 2021

1.Online Education

In any event, when things like ticket booking, staring at the TV shows, requesting food is becoming on the web, instruction is as yet behind as far as online training conveyance. Because of the simple accessibility of web, the quantity of web clients is expanding quickly. The expanding number of Smartphone clients is giving a decent chance to convey training on the web.

Online instruction which incorporates online courses and online assessments are gradually and without a doubt becoming well known because of the premium displayed by the functioning experts to learn new things and extend their insight about innovation. More number of associations like InsideAIML's is arising to target online training for understudies.

2. Computerized and Comprehensive Online Assessments

Assessment of understudies is one of the vital spaces of scholastic educational program. Accomplishment of instruction generally relies upon kind of assessment done. Generally, the assessment of the understudies has to a great extent been centered around hypothesis assessments. The understudies are dissected dependent on their hypothetical information. The understudies for the most part compose hypothesis or engaging answers in the tests and it is being assessed by one of the analysts. Their passing or disappointment relies upon their comprehension of hypothesis.

Limits of current appraisals of assessment framework

Assessment is human ward

It is one-sided and not normalized for all understudies

It is inclined to mistake

It doesn't think about useful parts of the information

In the coming a very long time there would be more spotlight on pragmatic and active part of studies. The assessment of understudy would likewise be founded on their useful information which they have procured of specific point. Extent of hypothesis tests would be decreased while the measure of exploratory, on the field or non-hypothetical training would increment.

3. Acquiring BlockChain system to Education Technology

Blockchain innovation assists with duplicating and move information yet doesn't permit adjustment. This innovation is amazingly valuable as it can forestall hacking of the framework. This has made Blockchain an arising innovation. It will overwhelm advancement across numerous organizations in the coming decade.

Numerous articles are being expounded on Block-chain innovation. They are valuable when there is a need of cooperation or appropriation of data set/data. Square chain is valuable in numerous spaces of instruction including assessment the board, understudy accreditations confirmation, declaration check and so forth

4. Customized Learning

Customary homeroom based learning includes a standard hypothesis based prospectus educated by instructors actually. The schedule, study halls and instructors are same for every one of the understudies' disregarding the distinctions to their greatest advantage and getting a handle on limit. As the customary study hall based learning isn't redone relating to the requirements of each individual understudy, it is turning into an old and old.

Allow us to consider instances of on the web or on request web-based features like Netflix, Amazon Prime and so on These stages give us customized and on request TV experience. They are eliminating area, gadget and timing limitations. Network shows, games are being spilled in the customized way with the assistance of these stages.

5. Computer based intelligence based Personalized Analysis of Individual

Man-made consciousness (AI) is most recent popular expression on the planet today. Innovation area as well as all areas including money, assembling and medical care will be reformed because of execution of AI. Instruction area is additionally prone to get more thoughts and executions utilizing AI in the impending years.

6. Upheaval in Exam Management with Education Technology

Tests are as yet directed in customary way which incorporates test focuses, manual test invigilation, manual answer sheet assessment and so forth The customary assessment framework isn't just monotonous however it is additionally dangerous because of a ton of manual work and human intercession.

However, presentation of AI in the assessment the board framework can acquire a ton of extraordinary changes in current test the executives. Man-made intelligence based delegating or auto distant administering can empower establishments to lead test with no need of framework or strategic.

7. Augmented Reality (VR) in Education Technology

Augmented reality is a PC produced innovation which can establish a virtual climate which is vivid and intelligent. It can make a world which is like this present reality yet totally different. No big surprise, augmented reality has acquired gigantic fame in the gaming business.

Idea of VR is becoming practical. Numerous different areas have begun utilizing VR for some basic things. Training is additionally a field which can profit the advantages of this innovation. Consider beneath examination of data maintenance. With regards to study hall based talks, information maintenance is the least. Information maintenance improves radically when it is given as sounds, recordings, visuals, and so forth.

Stay udated with latest artificial intelligence, machine learning and data science updates. Read our recent blog on Python Numbers

[shilkaren]

Python Numbers-InsideAIML

Python Numbers blog provide brief about python int, python float, python decimal, python string concatenation, etc. Click To Read More

Python Numbers | Insideaiml article

[wizardtutorial]

Working With Numbers In Python - Python Basics

Working With Numbers In Python – Python Basics

Numbers are important part of any programming language and Python is no different. We use numbers for everything like calculating the distance to a location or counting how many visitors visited your website. We use numbers everyday in computer programming so let’s go over some important points when working with numbers in Python.

Using Integers When working with numbers in Python

What is a…

View On WordPress

[rkpai]

Python - Deep dive into Number types

This post is the sixth of many that attempts to document everything I have been learning about Python.

Number types in Python

1. Integers 2. Floating Point 3. Complex Numbers 4. Fixed precision decimal numbers 5. Fractions

Integers in 2.6 come in 2 flavors, int which is 32 bits and long which has as much precision as the system memory allows for. Python automatically switches to using long when int cannot hold values. It prints long values with a l or L at the end of the number.

Integers in 3.0 allow for as much precision as the system memory allows. There is no long type in 3.0.

Floating points precision is the same as the precision allowed for by the float data type of the C compiler that was used to build Python.

You can express integer literals as octal, hexadecimal and binary number expressions. All these are just expressions that evaluate to an integer.

>>> # binary, octal, hexadecimal >>> '0b11', '0o21', '0xA2' ('0b11', '0o21', '0xA2') >>>

The built in methods oct, hex and bin convert the integer to the respective forms.

You specify a oct with a 0o, hex with 0x and bin with 0b.

>>> >>> bin(128), oct(128), hex(128) ('0b10000000', '0o200', '0x80') >>>

Operator precedence the easy way

You do not have to memorize the operator precedence rules in Python if you are careful enough to group operations in parenthesis.

Mixed type expressions

When evaluating expressions that have different types (only numeric), the resulting type of the entire expression is the most complex type, that is, types are converted up to the most complex type being used in the expression. This means that integers are converted up to floats and floats to complex numbers.

>>> # adding a int with a float, resulting type is a float >>> 1 + 3.0 4.0 >>>

In 2.6, mixed type comparisons are allowed. By mixed type comparisons, I mean comparisons between types that are not numbers.

>>> # In 2.6, mixed type comparisons >>> 3 < 'test' True >>>

In 3.0, mixed type comparisons, types in which you use numbers with other types like strings will result in an error.

>>> # In 3.0, mixed type comparisons are not allowed >>> 3 < 'test' Traceback (most recent call last): File "", line 1, in 3 < 'test' TypeError: unorderable types: int() < str()

Variable creation in Python

1. Variables are never declared ahead of time. 2. Variables are replaced by their values when used in expressions. 3. Variables are created when they are first assigned values. 4. Variables have to be initialized before they can be used.

You can display numbers using both repr and str display formats. repr is used to display numbers as codes and str is usually used to display numbers in user friendly formats.

>>> # repr and str >>> repr("Throw it in the bag"), str("Throw it in the bag") ("'Throw it in the bag'", 'Throw it in the bag') >>>

Chain comparison operations

Python allows you to chain comparison operations.  

>>> >>> #Chaining comparison operators >>> # 2 < 3 AND 3 < 4 >>> 2 < 3 < 4 True >>> # 1 == 2 AND 2 < 3 >>> 1 == 2 < 3 False >>>

Division in Python

There are 2 operators that perform division and they come in 3 flavors.

In 3.0:

The / operator performs true division, no matter what type of operands, the result is always a float.

The // operator performs a floor division and maintains the type conversion convention. int and int will result in int. int and float will result in float

>>> >>> 3 / 2, 3.0 / 2.0 (1.5, 1.5) >>> 3 // 2, 3.0 // 2.0 (1, 1.0) >>>

In 2.6:

The / operator preforms classic division, it drops the decimal part in case of integers.

The // operator works the same way as in 3.0

>>> >>> 3 / 2, 3.0 / 2.0 (1, 1.5) >>> 3 // 2, 3.0 // 2.0 (1, 1.0) >>>

// (3.0 & 2.6) and / (2.6) have a special case because of floor division.

Floor division is the same as truncation in case of positive numbers, but when negative numbers are involved, floor is different from truncation.

Complex Numbers

These are built-in types in Python. They consist of a real part and a imaginary part. You can use the Cmath module to process them. It is the complex number equivalent to the standard Math module.

Oct, Hex, Bin notation

You can code integer literals using oct, hex and bin notation, they are just one way of generating integers.

In 2.6, you can code an octal by adding a zero to the beginning of an integer and it will be interpreted as base 8.

In 3.0, you have to use 0o that is zero followed by the letter o.

The built-in functions oct(), hex() and bin() generate numbers in their respective bases.

The int() built in takes a string and a optional base.

>>> >>> bin(128), oct(128), hex(128) ('0b10000000', '0o200', '0x80') >>> int('0o200', 8) 128 >>> int('0x80', 16) 128 >>>

You can also use formatting expressions

{0:o} is for octal

{0:x} is for hexadecimal

{0:b} is for binary

>>> # octal >>> '{0:o}'.format(200) '310' >>> # hex >>> '{0:x}'.format(200) 'c8' >>> # bin >>> '{0:b}'.format(200) '11001000' >>>

The eval built in function, takes any string and runs it as Python code. You can pass integer literals to it as strings (in any base) and it will run it as python code and echo the result in IDLE.

>>> eval('0b011') 3 >>>

Bit Operators

Python has support for bitwise operations, << (left shift), >> (right shift), ^ (XoR), & (and), | (or)

Further, you can use the bit_length method (new in 3.1) to see how many bits are needed to represent a integer. You can achieve this in 2.6 by getting the length of the binary representation of the integer and subtracting 2 to get the bits needed to represent the number.

>>> a = 3 >>> a.bit_length() 2 >>> len(bin(3)) - 2 2 >>>

There are many built in tools and modules that allow you to process numbers.

Built-ins like abs (absolute), pow (exponent) and round.

The Math module has many of the same functions as the math library in C

trunc - just drops the decimal part.

floor - drops the decimal part and floors the value (same as trunc for positive numbers, but diff for negative numbers)

There are 3 ways to compute a square root in Python

Import the math library and use math.sqrt

Raise the number to the power .5 using **

Use the pow built in function and specify .5 as the power.

>>> abs(-10), pow(3, 2) (10, 9) >>> >>> import math >>> math.trunc(3.0) 3 >>> math.floor(-3.5) -4 >>> round(3.456, 2) 3.46 >>> >>> # all compute the square root >>> math.sqrt(81) 9.0 >>> pow(81, .5) 9.0 >>> 81 ** .5 9.0 >>>

The default namespace in Python is builtins in 3.0 and __builtin__ in 2.6

Decimals

The decimal type in Python represents fixed precision decimal. They are decimal numbers with a fixed set of decimal places.

You cannot create a decimal using a literal. The decimal module must be imported and you call the Decimal method by passing in a string that has the number.

With the decimal type, you can set the number of decimal places to be used. It tends to be a lot more accurate than using floats, but you incur a small performance penalty.

When you run operations on decimals with different precision of decimal places, Python will scale up all the other decimal values to the value with the largest number of decimal places.

You can set the number of decimals to be used by calling the getcontext() method of the decimal module and setting its prec property.

>>> >>> decimal.getcontext().prec = 2 >>> decimal.Decimal('1.4444') + decimal.Decimal('4.11111') Decimal('5.6')

Using the with statement to set the precision will cause all the code inside the with block to use the precision and the code outside the block will use the global default precision value.

>>> >>> # this will set a scope in which the >>> # precision will be applied to >>> with decimal.localcontext() as xt: xt.prec = 2 var1 + var2 Decimal('8.0') >>>

Fraction

Like the Decimal type, Fraction was introduced to get past the inaccuracies of floating point operations.

Like the Decimal type, you have to import the fraction module to use the Fraction type.

You can create the Fraction type by passing in 2 numbers (numerator and denominator). You can also pass in a float to the fraction type's from_float() method to create it.

Floats have a as_integer_ratio method that convert a float to a fraction.

While you can convert float to fractions, you might lose a lot of precision.

You might have to limit the denominator to be able to retain precision. You limit the denominator using the limit_denominator() method of the fraction.

>>> >>> import fractions >>> v1 = fractions.Fraction(1,3) >>> v2 = fractions.Fraction(2,3) >>> v1 + v2 Fraction(1, 1) >>> >>> v3 = fractions.Fraction.from_float(3.44) >>> v3.limit_denominator(10) Fraction(31, 9)

You can pass a fraction to Float() to convert it into a float

Mixed type conversions

Expressions that have int & fraction will result in a fraction

Expressions that have float & fraction will result in a float

Sets

Sets are a un-ordered collection of unique, immutable objects. The set type is iterable

They support all the regular set based operations.

You can create a set by passing in any iterable type to the Set() method.

Apart from the built-in operators that allow you to perform operations on sets. The set type has methods that allow you to perform those same operations.

While the built in operators operate only on set types, the built in methods will accept any iterable type.

In 2.6 you do not have a literal syntax to create a set, you had to rely on the Set() method. In 3.0 you can use the {} syntax to create a set.

Sets can only contain immutable objects and so you cannot embed lists and dictionaries in them. Sets also cannot contain other sets. To store one set inside another, you have to create a frozen set and embed that in other sets.

Set comprehension syntax is the same as list comprehension, except for Sets you enclose it in {}

>>> >>> set1 = set('this is a set') >>> set1 {'a', ' ', 'e', 'i', 'h', 's', 't'} >>> set2 = {'n','e','w','s'} >>> set1 & {'1', '2', '3'} set() >>> set1 | {'1', '2'} {'a', ' ', 's', '1', 'e', 't', 'i', 'h', '2'} >>> set1.union >>> set1.union({'1', '2'}) {'a', ' ', 's', '1', 'e', 't', 'i', 'h', '2'}

Booleans

Python has a data type named bool which has 2 values, True and False. These are actually representations of the values 1 and 0. bool is a subclass of int and True / False are basically values that are being printed instead of 1 and 0, this has been done by overriding the repr and str methods of the bool class.

>>> >>> truth = True >>> truth + 1 # Woah! 2 >>>

[rkpai]

Python - Numbers & Strings

This post is the fourth of many that attempts to document everything I have been learning about Python.

Python is dynamically typed, there are no type declarations. It keeps track of types for you and is a strongly typed language. Types are created when expressions are evaluated. Only operations valid on a type can be performed on it.

Python provides built-in object types that you can start using in your programs right away. Objects like lists, dictionaries, tuples and strings are part of the core language.

In most cases, these built-in objects are all that you need to model your application domain. Moreover, these objects are implemented using C which means you get a good deal of performance by using them.

In cases where you have to define your own, Python allows you to define your own types which can in turn leverage the functionality provided by Python's core built-in objects.

Python types are either immutable (cannot be changed in place) or mutable (can be changed in place).

Strings, numbers, tuples, sets are immutable.

Lists & Dictionaries are mutable.

Numbers

Numbers in python  are integers, floating point numbers, fixed precision decimals, complex and rational numbers.

In 3.0 integers can hold values no matter how large, in 2.6 a separate long integer type holds values that are beyond the range of integers.

Strings

Strings in Python are positional ordered collection of single characters. They are part of the family of sequences. You can operations like index and slice on them.

Indexing a string:

>>> >>> # string in Python >>> day_job = 'human genome project' >>> >>> # indexing a string to retrieve the >>> # character at the index (offset) >>> >>> day_job[0] 'h' >>> >>> # Negative offsets can be used >>> # start from the end of the string >>> >>> day_job[-1] 't' >>>

Slicing a string:

You can extract parts of a string by slicing it. The syntax is val[i:j] where i is the starting offset and the string is sliced all the way up to but not including offset j

>>> >>> day_job = "human genome project" >>> >>> # slicing a string >>> day_job[6:12] 'genome' >>>

You can slice using negative offsets. If you skip the indexes all together, they default - 0 for the lower bound and the length of the string for the upper bound.

>>> day_job = "human genome project" >>> >>> # slicing a string >>> # using negative offsets >>> day_job[0:-3] 'human genome proj' >>> >>> # slicing a string >>> # using offset defaults >>> day_job[:-7] 'human genome ' >>> day_job[5:] ' genome project' >>>

The indexing and slice operations are built in Python operations and are applicable to any type that is a sequence.

You can apply operations on strings. + is used to concatenate strings, whereas a * will repeat the string a certain number of times.

>>> >>> # concatenation >>> "day" + " job" 'day job' >>> >>> # repetition >>> "day job" * 3 'day jobday jobday job' >>>

Operations that are type specific are available as callable methods on that type.

>>> >>> day_job = "human genome project" >>> >>> # returns the index of the string >>> # location of the string. >>> day_job.find('genome') 6 >>> >>> # replaces the old value with the new one >>> day_job.replace('project', 'assignment') 'human genome assignment' >>>

To get a list of all string methods, you can use the dir method by passing in the type as parameter. You can then invoke the help method by passing the type and its attribute to learn more about its usage.

>>> >>> day_job = "human genome project" >>> dir(day_job) ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] >>> >>> help(day_job.upper) Help on built-in function upper: upper(...) S.upper() -> str Return a copy of S converted to uppercase. >>>

You can create strings using string literals, string format expressions, string format functions (new in version 3.x), strings with special characters, multiline strings that are printed as-is created using 3 quotes (either single or double).

The string type in 3.x is used to handle both regular ASCII and Unicode characters.