JavaScript Programmer

                                    A guide to commands in Python from what
                                        you know in JavaScript
                                  
                                      Python Study Guide for a JavaScript
                                          Programmer
                                    
                                    ​
​
                                  
                                      Related Articles:
                                    
                                      Applications of Tutorial & Cheat
                                          Sheet Respectivley (At Bottom Of
                                          Tutorial):
                                    
                                      Basics
                                    
                                            PEP8
                                                : Python Enhancement Proposals,
                                                style-guide for Python.
                                          
                                            print
                                                is the equivalent of console.log.
                                          
                                        ‘print() == console.log()’
                                      
                                      #
                                          is used to make comments in your
                                          code.
                                    
                                            1
                                          
                                          def foo(): """ The
                                              foo function does many amazing
                                              things that you should not
                                              question. Just accept that it
                                              exists and use it with caution.
                                              """
                                              secretThing()
                                        
                                            Copied!
                                          
                                        Python has a built in help function
                                            that let’s you see a description of
                                            the source code without having to
                                            navigate to it… “-SickNasty … Autor
                                            Unknown”
                                      
                                      Numbers
                                    
                                            Python has three types of
                                                numbers:
                                          
1.
                                            Integer
                                          
2.
                                            Positive and Negative Counting
                                                Numbers.
                                          
                                    No Decimal Point
                                  
                                        Created by a literal non-decimal
                                            point number … or
                                            … with the int()
                                            constructor.
                                      
                                            1
                                          
                                          print(3) # => 3 print(int(19))
                                              # => 19 print(int()) # =>
                                              0
                                        
                                            Copied!
                                          
                                    3. Complex Numbers
                                  
                                        Consist of a real part and
                                            imaginary part.
                                      
                                    Boolean is a subtype of integer in
                                        Python.🤷‍♂️
                                  
                                        If you came from a background in
                                            JavaScript and learned to accept the
                                            premise(s) of the following
                                            meme…
                                      
                                    ​
​
                                  
                                        Than I am sure you will find the
                                            means to suspend your
                                            disbelief.
                                      
                                            1
                                          
                                          print(2.24) # => 2.24
                                              print(2.) # => 2.0
                                              print(float()) # => 0.0
                                              print(27e-5) # => 0.00027
                                        
                                            Copied!
                                          
                                      KEEP IN MIND:
                                    
                                        The i
                                            is switched to a j
                                            in programming.
                                      
                                    This is because the letter i is common
                                        place as the de facto index for any and
                                        all enumerable entities so it just makes
                                        sense not to compete for name-space
                                        when there’s another 25 letters that
                                        don’t get used for every loop under the
                                        sun. My most medium apologies to
                                        Leonhard Euler.
                                  
                                            1
                                          
                                          print(7j) # => 7j
                                              print(5.1+7.7j)) # => 5.1+7.7j
                                              print(complex(3, 5)) # => 3+5j
                                              print(complex(17)) # => 17+0j
                                              print(complex()) # => 0j
                                        
                                            Copied!
                                          
                                            Type Casting
                                                : The process of converting one
                                                number to another.
                                          
                                            1
                                          
                                          # Using Floatprint(17) # =>
                                              17print(float(17)) # =>
                                              17.0
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # Using Intprint(17.0) # =>
                                              17.0print(int(17.0)) # =>
                                              17
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # Using Strprint(str(17.0) +
                                              ' and ' + str(17)) #
                                              => 17.0 and 17
                                        
                                            Copied!
                                          
                                    The arithmetic operators are the same
                                        between JS and Python, with two
                                        additions:
                                  
                                            “**” : Double asterisk for
                                                exponent.
                                          
                                            “//” : Integer Division.
                                          
                                            There are no spaces between
                                                math operations in
                                                Python.
                                          
                                            Integer Division gives the
                                                other part of the number from
                                                Module; it is a way to do round
                                                down numbers replacing Math.floor()
                                                in JS.
                                          
                                            There are no ++
                                                and --
                                                in Python, the only shorthand
                                                operators are:
                                          
                                    ​
​
                                  
                                      Strings
                                    
                                            Python uses both single and
                                                double quotes.
                                          
                                            You can escape strings like so 'Jodi asked,
                                                "What\'s up,
                                                Sam?"'
                                          
                                            Multiline strings use triple
                                                quotes.
                                          
                                            1
                                          
                                          print('''My
                                              instructions are very long so to
                                              make themmore readable in the code
                                              I am putting them onmore than one
                                              line. I can even include
                                              "quotes"of any kind
                                              because they won't get
                                              confused withthe end of the
                                              string!''')
                                        
                                            Copied!
                                          
                                    Use the len()
                                        function to get the length of a
                                        string.
                                  
                                            1
                                          
                                          print(len(“Spaghetti”)) # =>
                                              9
                                        
                                            Copied!
                                          
                                      Python uses zero-based indexing
                                    
                                    Python allows negative indexing (thank
                                        god!)
                                  
                                            1
                                          
                                          print(“Spaghetti”[-1]) # => i
                                            
                                            Copied!
                                          
                                            1
                                          
                                          print(“Spaghetti”[-4]) # =>
                                              e
                                        
                                            Copied!
                                          
                                            Python let’s you use
                                                ranges
                                          
                                    You can think of this as roughly
                                        equivalent to the slice method called on
                                        a JavaScript object or string… (mind you that in JS … strings are
                                        wrapped in an object (under the hood)…
                                        upon which the string methods are
                                        actually called. As a immutable
                                        privative type by textbook definition, a string literal could not hope to
                                        invoke most of it’s methods without
                                        violating the state it was bound to on
                                        initialization if it were not for this
                                        bit of syntactic sugar.)
                                  
                                            1
                                          
                                          print(“Spaghetti”[1:4]) # =>
                                              pag print(“Spaghetti”[4:-1]) #
                                              => hett print(“Spaghetti”[4:4])
                                              # => (empty string)
                                        
                                            Copied!
                                          
                                            The end range is exclusive just
                                                like slice
                                                in JS.
                                          
                                            1
                                          
                                          # Shortcut to get from the
                                              beginning of a string to a certain
                                              index.print("Spaghetti"[:4])
                                              # =>
                                              Spagprint("Spaghetti"[:-1])
                                              # => Spaghett
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # Shortcut to get from a certain
                                              index to the end of a
                                              string.print("Spaghetti"[1:])
                                              # =>
                                              paghettiprint("Spaghetti"[-4:])
                                              # => etti
                                        
                                            Copied!
                                          
                                            The index
                                                string function is the equiv. of indexOf()
                                                in JS
                                          
                                            1
                                          
                                          print("Spaghetti".index("h"))
                                              # =>
                                              4print("Spaghetti".index("t"))
                                              # => 6
                                        
                                            Copied!
                                          
                                            The count
                                                function finds out how many
                                                times a substring appears in a
                                                string… pretty nifty for a hard
                                                coded feature of the
                                                language.
                                          
                                            1
                                          
                                          print("Spaghetti".count("h"))
                                              # =>
                                              1print("Spaghetti".count("t"))
                                              # =>
                                              2print("Spaghetti".count("s"))
                                              # =>
                                              0print('''We choose
                                              to go to the moon in this decade
                                              and do the other things,not
                                              because they are easy, but because
                                              they are hard, because that goal
                                              willserve to organize and measure
                                              the best of our energies and
                                              skills, because thatchallenge is
                                              one that we are willing to accept,
                                              one we are unwilling topostpone,
                                              and one which we intend to win,
                                              and the others,
                                              too.'''.count('the
                                              ')) # => 4
                                        
                                            Copied!
                                          
                                            You can use +
                                                to concatenate strings, just
                                                like in JS.
                                          
                                            You can also use “*” to repeat
                                                strings or multiply
                                                strings.
                                          
                                            Use the format()
                                                function to use placeholders in
                                                a string to input values later
                                                on.
                                          
                                            1
                                          
                                          first_name =
                                              "Billy"last_name =
                                              "Bob"print('Your
                                              name is {0}
                                              {1}'.format(first_name,
                                              last_name)) # => Your name is
                                              Billy Bob
                                        
                                            Copied!
                                          
                                            Shorthand way to use format
                                                function is:
                                              print(f'Your name is
                                                {first_name}
                                                {last_name}')
                                          
                                    Some useful string methods.
                                  
                                            Note that in JS join
                                                is used on an Array, in Python
                                                it is used on String.
                                          
                                    ​
​
                                  
                                            There are also many handy
                                                testing methods.
                                          
                                    ​
​
                                  
                                      Variables and Expressions
                                    
                                            Duck-Typing
                                                : Programming Style which avoids
                                                checking an object’s type to
                                                figure out what it can do.
                                          
                                            Duck Typing is the fundamental
                                                approach of Python.
                                          
                                            Assignment of a value
                                                automatically declares a
                                                variable.
                                          
                                            1
                                          
                                          a = 7b =
                                              'Marbles'print(a) #
                                              => 7print(b) # =>
                                              Marbles
                                        
                                            Copied!
                                          
                                            You can chain variable
                                                  assignments to give multiple
                                                  var names the same value.
                                          
                                    Use with caution as this is highly
                                        unreadable
                                  
                                            1
                                          
                                          count = max = min = 0print(count)
                                              # => 0print(max) # =>
                                              0print(min) # => 0
                                        
                                            Copied!
                                          
                                    The value and type of a variable can be
                                        re-assigned at any time.
                                  
                                            1
                                          
                                          a = 17print(a) # => 17a =
                                              'seventeen'print(a) #
                                              => seventeen
                                        
                                            Copied!
                                          
                                            NaN
                                                does not exist in Python, but
                                                you can 'create' it
                                                like so:
                                              print(float("nan"))
                                          
                                            Python replaces null
                                                with none.
                                          
                                            none
                                                  is an object
                                                and can be directly assigned to
                                                a variable.
                                          
                                        Using none is a convenient way to
                                            check to see why an action may not
                                            be operating correctly in your
                                            program.
                                      
                                      Boolean Data Type
                                    
                                            One of the biggest benefits of
                                                Python is that it reads more
                                                like English than JS does.
                                          
                                    ​
​
                                  
                                            1
                                          
                                          # Logical ANDprint(True and True)
                                              # => Trueprint(True and False)
                                              # => Falseprint(False and
                                              False) # => False
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # Logical ORprint(True or True) #
                                              => Trueprint(True or False) #
                                              => Trueprint(False or False) #
                                              => False
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # Logical NOTprint(not True) #
                                              => Falseprint(not False and
                                              True) # => Trueprint(not True
                                              or False) # => False
                                        
                                            Copied!
                                          
                                            By default, Python considers an
                                                object to be true UNLESS it is
                                                one of the following:
                                          
                                            Constant None
                                                or False
                                          
                                            Zero of any numeric type.
                                          
                                            Empty Sequence or
                                                Collection.
                                          
                                            True
                                                and False
                                                must be capitalized
                                          
                                      Comparison Operators
                                    
                                            Python uses all the same
                                                equality operators as JS.
                                          
                                            In Python, equality operators
                                                are processed from left to
                                                right.
                                          
                                            Logical operators are processed
                                                in this order:
                                          
1.
                                            NOT
                                          
2.
                                            AND
                                          
3.
                                            OR
                                          
                                        Just like in JS, you can use parentheses
                                            to change the inherent order of
                                            operations.
                                      
                                        Short Circuit
                                            : Stopping a program when a true
                                            or false
                                            has been reached.
                                      
                                    ​
​
                                  
                                      Identity vs Equality
                                    
                                            1
                                          
                                          print (2 == '2') #
                                              => Falseprint (2 is
                                              '2') # => False
                                        
                                            Copied!
                                          
                                            1
                                          
                                          print ("2" ==
                                              '2') # => Trueprint
                                              ("2" is '2') #
                                              => True
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # There is a distinction between
                                              the number types.print (2 == 2.0)
                                              # => Trueprint (2 is 2.0) #
                                              => False
                                        
                                            Copied!
                                          
                                            In the Python community it is
                                                better to use is
                                                and is not
                                                over ==
                                                or !=
                                          
                                      If Statements
                                    
                                            1
                                          
                                          if name == 'Monica':
                                              print('Hi,
                                              Monica.')
                                        
                                            Copied!
                                          
                                            1
                                          
                                          if name == 'Monica':
                                              print('Hi,
                                              Monica.')else:
                                              print('Hello,
                                              stranger.')
                                        
                                            Copied!
                                          
                                            1
                                          
                                          if name == 'Monica':
                                              print('Hi, Monica.')elif
                                              age < 12: print('You are
                                              not Monica, kiddo.')elif age
                                              > 2000: print('Unlike you,
                                              Monica is not an undead, immortal
                                              vampire.')elif age > 100:
                                              print('You are not Monica,
                                              grannie.')
                                        
                                            Copied!
                                          
                                        Remember the order of elif
                                            statements matter.
                                      
                                      While Statements
                                    
                                            1
                                          
                                          spam = 0while spam < 5:
                                              print('Hello, world.')
                                              spam = spam + 1
                                        
                                            Copied!
                                          
                                            Break
                                                statement also exists in
                                                Python.
                                          
                                            1
                                          
                                          spam = 0while True:
                                              print('Hello, world.')
                                              spam = spam + 1 if spam >= 5:
                                              break
                                        
                                            Copied!
                                          
                                            As are continue
                                                statements
                                          
                                            1
                                          
                                          spam = 0while True:
                                              print('Hello, world.')
                                              spam = spam + 1 if spam < 5:
                                              continue break
                                        
                                            Copied!
                                          
                                      Try/Except Statements
                                    
                                            Python equivalent to try/catch
                                          
                                            1
                                          
                                          a = 321try: print(len(a))except:
                                              print('Silently handle error
                                              here')
                                        
                                            Copied!
                                          
                                            1
                                          
                                              # Optionally include a correction
                                              to the issue a = str(a)
                                              print(len(a)
                                        
                                            Copied!
                                          
                                            1
                                          
                                          a = '321'try:
                                              print(len(a))except:
                                              print('Silently handle error
                                              here')
                                        
                                            Copied!
                                          
                                            1
                                          
                                              # Optionally include a correction
                                              to the issue a = str(a)
                                              print(len(a))
                                        
                                            Copied!
                                          
                                            You can name an error to give
                                                the output more
                                                specificity.
                                          
                                            1
                                          
                                          a = 100b = 0try: c = a / bexcept
                                              ZeroDivisionError: c =
                                              Noneprint(c)
                                        
                                            Copied!
                                          
                                            You can also use the pass
                                                commmand to by pass a certain
                                                error.
                                          
                                            1
                                          
                                          a = 100b = 0try: print(a /
                                              b)except ZeroDivisionError:
                                              pass
                                        
                                            Copied!
                                          
                                            The pass
                                                method won't allow you to
                                                bypass every single error so you
                                                can chain an exception series
                                                like so:
                                          
                                            1
                                          
                                          a = 100# b = "5"try:
                                              print(a / b)except
                                              ZeroDivisionError: passexcept
                                              (TypeError, NameError):
                                              print("ERROR!")
                                        
                                            Copied!
                                          
                                            You can use an else
                                                statement to end a chain of except
                                                statements.
                                          
                                            1
                                          
                                          # tuple of file namesfiles =
                                              ('one.txt',
                                              'two.txt',
                                              'three.txt')
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # simple loopfor filename in
                                              files: try: # open the file in
                                              read mode f = open(filename,
                                              'r') except OSError: #
                                              handle the case where file does
                                              not exist or permission is denied
                                              print('cannot open
                                              file', filename) else: # do
                                              stuff with the file object (f)
                                              print(filename, 'opened
                                              successfully')
                                              print('found',
                                              len(f.readlines()),
                                              'lines') f.close()
                                        
                                            Copied!
                                          
                                            finally
                                                is used at the end to clean up
                                                all actions under any
                                                circumstance.
                                          
                                            1
                                          
                                          def divide(x, y): try: result = x
                                              / y except ZeroDivisionError:
                                              print("Cannot divide by
                                              zero") else:
                                              print("Result is",
                                              result) finally:
                                              print("Finally...")
                                        
                                            Copied!
                                          
                                            Using duck typing to check to
                                                see if some value is able to use
                                                a certain method.
                                          
                                            1
                                          
                                          # Try a number - nothing will
                                              print outa = 321if hasattr(a,
                                              '__len__'):
                                              print(len(a))
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # Try a string - the length will
                                              print out (4 in this case)b =
                                              "5555"if hasattr(b,
                                              '__len__'):
                                              print(len(b))
                                        
                                            Copied!
                                          
                                      Pass
                                    
                                            Pass Keyword is required to
                                                write the JS equivalent of
                                                :
                                          
                                            1
                                          
                                          if (true) {}
                                        
                                            Copied!
                                          
                                            1
                                          
                                          while (true) {}
                                        
                                            Copied!
                                          
                                            1
                                          
                                          if True: pass
                                        
                                            Copied!
                                          
                                            1
                                          
                                          while True: pass
                                        
                                            Copied!
                                          
                                      Functions
                                    
                                            Function definition
                                                includes:
                                          
                                            The def
                                                keyword
                                          
                                            The name of the
                                                function
                                          
                                            A list of parameters enclosed
                                                in parentheses.
                                          
                                            A colon at the end of the
                                                line.
                                          
                                            One tab indentation for the
                                                code to run.
                                          
                                            You can use default parameters
                                                just like in JS
                                          
                                            1
                                          
                                          def greeting(name,
                                              saying="Hello"):
                                              print(saying, name)
                                        
                                            Copied!
                                          
                                            1
                                          
                                          greeting("Monica")#
                                              Hello Monica
                                        
                                            Copied!
                                          
                                            1
                                          
                                          greeting("Barry",
                                              "Hey")# Hey Barry
                                        
                                            Copied!
                                          
                                    Keep in mind, default parameters must
                                        always come after regular
                                        parameters.
                                  
                                            1
                                          
                                          # THIS IS BAD CODE AND WILL NOT
                                              RUNdef increment(delta=1, value):
                                              return delta + value
                                        
                                            Copied!
                                          
                                            You can specify arguments by
                                                name without destructuring in
                                                Python.
                                          
                                            1
                                          
                                          def greeting(name,
                                              saying="Hello"):
                                              print(saying, name)
                                        
                                            Copied!
                                          
                                            1
                                          
                                          # name has no default value, so
                                              just provide the value# saying has
                                              a default value, so use a keyword
                                              argumentgreeting("Monica",
                                              saying="Hi")
                                        
                                            Copied!
                                          
                                            The lambda
                                                keyword is used to create
                                                anonymous functions and are
                                                supposed to be one-liners.
                                          
                                    toUpper = lambda s: s.upper()
                                  
                                      Notes
                                    
                                    Formatted Strings
                                  
                                        Remember that in Python join() is
                                            called on a string with an
                                            array/list passed in as the
                                            argument. Python has a very powerful
                                            formatting engine. format() is also
                                            applied directly to strings.
                                      
                                            1
                                          
                                          shopping_list =
                                              [‘bread’,’milk’,’eggs’]print(‘,’.join(shopping_list))
                                        
                                            Copied!
                                          
                                      Comma Thousands Separator
                                    
                                            1
                                          
                                          print(‘{:,}’.format(1234567890))‘1,234,567,890’
                                        
                                            Copied!
                                          
                                      Date and Time
                                    
                                            1
                                          
                                          d = datetime.datetime(2020, 7, 4,
                                              12, 15, 58)print(‘{:%Y-%m-%d
                                              %H:%M:%S}’.format(d))‘2020–07–04
                                              12:15:58’
                                        
                                            Copied!
                                          
                                      Percentage
                                    
                                            1
                                          
                                          points = 190total =
                                              220print(‘Correct answers:
                                              {:.2%}’.format(points/total))Correct
                                              answers: 86.36%
                                        
                                            Copied!
                                          
                                      Data Tables
                                    
                                            1
                                          
                                          width=8print(‘ decimal hex
                                              binary’)print(‘-’*27)for num in
                                              range(1,16):for base in
                                              ‘dXb’:print(‘{0:{width}{base}}’.format(num,
                                              base=base, width=width), end=’
                                              ‘)print()Getting Input from the
                                              Command LinePython runs
                                              synchronously, all programs and
                                              processes will stop when listening
                                              for a user input.The input
                                              function shows a prompt to a user
                                              and waits for them to type
                                              ‘ENTER’.Scripts vs
                                              ProgramsProgramming Script : A set
                                              of code that runs in a linear
                                              fashion.The largest difference
                                              between scripts and programs is
                                              the level of complexity and
                                              purpose. Programs typically have
                                              many UI’s.
                                        
                                            Copied!
                                          
                                    Python can be used to display html,
                                        css, and JS.
                                      It is common to use Python as an API
                                        (Application Programming Interface)
                                  
                                    Structured Data
                                  
                                    Sequence : The most basic data
                                        structure in Python where the index
                                        determines the order.
                                  
                                        List Tuple Range Collections :
                                            Unordered data structures, hashable
                                            values.
                                      
                                    Dictionaries
                                      Sets
                                  
                                    Iterable : Generic name for a sequence
                                        or collection; any object that can be
                                        iterated through.
                                  
                                    Can be mutable or immutable.
                                      Built In Data Types
                                  
                                      Lists are the python equivalent of
                                          arrays.
                                    
                                            1
                                          
                                          empty_list = []departments =
                                              [‘HR’,’Development’,’Sales’,’Finance’,’IT’,’Customer
                                              Support’]
                                        
                                            Copied!
                                          
                                      You can instantiate
                                    
                                            1
                                          
                                          specials = list()
                                        
                                            Copied!
                                          
                                    Test if a value is in a list.
                                  
                                            1
                                          
                                          print(1 in [1, 2, 3]) #>
                                              Trueprint(4 in [1, 2, 3]) #>
                                              False# Tuples : Very similar to
                                              lists, but they are
                                              immutable
                                        
                                            Copied!
                                          
                                    Instantiated with parentheses
                                  
                                            1
                                          
                                          time_blocks = (‘AM’,’PM’)
                                        
                                            Copied!
                                          
                                    Sometimes instantiated without
                                  
                                            1
                                          
                                          colors =
                                              ‘red’,’blue’,’green’numbers = 1,
                                              2, 3
                                        
                                            Copied!
                                          
                                    Tuple() built in can be used to convert
                                        other data into a tuple
                                  
                                            1
                                          
                                          tuple(‘abc’) # returns (‘a’, ‘b’,
                                              ‘c’)tuple([1,2,3]) # returns (1,
                                              2, 3)# Think of tuples as constant
                                              variables.
                                        
                                            Copied!
                                          
                                    Ranges : A list of numbers which can’t
                                        be changed; often used with for
                                        loops.
                                  
                                    Declared using one to three
                                        parameters.
                                  
                                        Start : opt. default 0, first # in
                                            sequence. Stop : required next
                                            number past the last number in the
                                            sequence. Step : opt. default 1,
                                            difference between each number in
                                            the sequence.
                                      
                                            1
                                          
                                          range(5) # [0, 1, 2, 3,
                                              4]range(1,5) # [1, 2, 3,
                                              4]range(0, 25, 5) # [0, 5, 10, 15,
                                              20]range(0) # [ ]for let (i = 0; i
                                              < 5; i++)for let (i = 1; i <
                                              5; i++)for let (i = 0; i < 25;
                                              i+=5)for let(i = 0; i = 0; i++)#
                                              Keep in mind that stop is not
                                              included in the range.
                                        
                                            Copied!
                                          
                                    Dictionaries : Mappable collection
                                        where a hashable value is used as a key
                                        to ref. an object stored in the
                                        dictionary.
                                  
                                    Mutable.
                                  
                                            1
                                          
                                          a = {‘one’:1, ‘two’:2,
                                              ‘three’:3}b = dict(one=1, two=2,
                                              three=3)c = dict([(‘two’, 2),
                                              (‘one’, 1), (‘three’, 3)])# a, b,
                                              and c are all equal
                                        
                                            Copied!
                                          
                                    Declared with curly braces of the
                                          built in dict()
                                  
                                        Benefit of dictionaries in Python
                                            is that it doesn’t matter how it is
                                            defined, if the keys and values are
                                            the same the dictionaries are
                                            considered equal.
                                      
                                    Use the in operator to see if a key
                                        exists in a dictionary.
                                  
                                    Sets : Unordered collection of distinct
                                        objects; objects that need to be
                                        hashable.
                                  
                                        Always be unique, duplicate items
                                            are auto dropped from the set.
                                      
                                    Common Uses:
                                  
                                        Removing Duplicates Membership
                                            Testing Mathematical Operators:
                                            Intersection, Union, Difference,
                                            Symmetric Difference.
                                      
                                    Standard Set is mutable, Python has a
                                        immutable version called
                                        frozenset.
                                      Sets created by putting comma seperated
                                        values inside braces:
                                  
                                            1
                                          
                                          school_bag =
                                              {‘book’,’paper’,’pencil’,’pencil’,’book’,’book’,’book’,’eraser’}print(school_bag)
                                        
                                            Copied!
                                          
                                    Also can use set constructor to
                                        automatically put it into a set.
                                  
                                            1
                                          
                                          letters =
                                              set(‘abracadabra’)print(letters)#Built-In
                                              Functions#Functions using
                                              iterables
                                        
                                            Copied!
                                          
                                    filter(function, iterable) : creates
                                        new iterable of the same type which
                                        includes each item for which the
                                        function returns true.
                                  
                                    map(function, iterable) : creates new
                                        iterable of the same type which includes
                                        the result of calling the function on
                                        every item of the iterable.
                                  
                                    sorted(iterable, key=None,
                                        reverse=False) : creates a new sorted
                                        list from the items in the
                                        iterable.
                                  
                                    Output is always a list
                                  
                                    key: opt function which coverts and
                                        item to a value to be compared.
                                  
                                    reverse: optional boolean.
                                  
                                    enumerate(iterable, start=0) : starts
                                        with a sequence and converts it to a
                                        series of tuples
                                  
                                            1
                                          
                                          quarters = [‘First’, ‘Second’,
                                              ‘Third’,
                                              ‘Fourth’]print(enumerate(quarters))print(enumerate(quarters,
                                              start=1))
                                        
                                            Copied!
                                          
                                    (0, ‘First’), (1, ‘Second’), (2,
                                        ‘Third’), (3, ‘Fourth’)
                                  
                                    (1, ‘First’), (2, ‘Second’), (3,
                                        ‘Third’), (4, ‘Fourth’)
                                  
                                        zip(*iterables) : creates a zip
                                            object filled with tuples that
                                            combine 1 to 1 the items in each
                                            provided iterable. Functions that
                                            analyze iterable
                                      
                                    len(iterable) : returns the count of
                                        the number of items.
                                  
                                    max(*args, key=None) : returns the
                                        largest of two or more
                                        arguments.
                                  
                                    max(iterable, key=None) : returns the
                                        largest item in the iterable.
                                  
                                    key optional function which converts an
                                        item to a value to be compared.
                                      min works the same way as max
                                  
                                    sum(iterable) : used with a list of
                                        numbers to generate the total.
                                  
                                    There is a faster way to concatenate an
                                        array of strings into one string, so do
                                        not use sum for that.
                                  
                                    any(iterable) : returns True if any
                                        items in the iterable are true.
                                  
                                    all(iterable) : returns True is all
                                        items in the iterable are true.
                                  
                                      Working with dictionaries
                                    
                                    dir(dictionary) : returns the list of
                                        keys in the dictionary.
                                      Working with sets
                                  
                                    Union : The pipe | operator or
                                        union(*sets) function can be used to
                                        produce a new set which is a combination
                                        of all elements in the provided
                                        set.
                                  
                                            1
                                          
                                          a = {1, 2, 3}b = {2, 4, 6}print(a
                                              | b) # => {1, 2, 3, 4, 6}
                                        
                                            Copied!
                                          
                                    Intersection : The & operator ca be
                                        used to produce a new set of only the
                                        elements that appear in all
                                        sets.
                                  
                                            1
                                          
                                          a = {1, 2, 3}b = {2, 4, 6}print(a
                                              & b) # => {2}Difference :
                                              The — operator can be used to
                                              produce a new set of only the
                                              elements that appear in the first
                                              set and NOT the others.
                                        
                                            Copied!
                                          
                                    Symmetric Difference : The ^ operator
                                        can be used to produce a new set of only
                                        the elements that appear in exactly one
                                        set and not in both.
                                  
                                            1
                                          
                                          a = {1, 2, 3}b = {2, 4, 6}print(a
                                              — b) # => {1, 3}print(b — a) #
                                              => {4, 6}print(a ^ b) # =>
                                              {1, 3, 4, 6}
                                        
                                            Copied!
                                          
                                      For Statements
                                        In python, there is only one for
                                          loop.
                                    
                                    Always Includes:
                                  
                                        1. The for keyword 2. A variable
                                            name 3. The ‘in’ keyword 4. An
                                            iterable of some kid 5. A colon 6.
                                            On the next line, an indented block
                                            of code called the for clause.
                                      
                                    You can use break and continue
                                        statements inside for loops as
                                        well.
                                  
                                    You can use the range function as the
                                        iterable for the for loop.
                                  
                                            1
                                          
                                          print(‘My name is’)for i in
                                              range(5):print(‘Carlita Cinco (‘ +
                                              str(i) + ‘)’)
                                        
                                            Copied!
                                          
                                            1
                                          
                                          total = 0for num in
                                              range(101):total +=
                                              numprint(total)Looping over a list
                                              in Pythonfor c in [‘a’, ‘b’,
                                              ‘c’]:print(c)
                                        
                                            Copied!
                                          
                                            1
                                          
                                          lst = [0, 1, 2, 3]for i in
                                              lst:print(i)
                                        
                                            Copied!
                                          
                                    Common technique is to use the len()
                                          on a pre-defined list with a for loop
                                          to iterate over the indices of the
                                          list.
                                  
                                            1
                                          
                                          supplies = [‘pens’, ‘staplers’,
                                              ‘flame-throwers’, ‘binders’]for i
                                              in
                                              range(len(supplies)):print(‘Index
                                              ‘ + str(i) + ‘ in supplies is: ‘ +
                                              supplies[i])
                                        
                                            Copied!
                                          
                                    You can loop and destructure at the
                                        same time.
                                  
                                            1
                                          
                                          l = 1, 2], [3, 4], [5, 6for a, b
                                              in l:print(a, ‘, ‘, b)
                                        
                                            Copied!
                                          
                                        Prints 1, 2
                                      
                                        Prints 3, 4
                                      
                                        Prints 5, 6
                                      
                                    You can use values() and keys() to loop
                                        over dictionaries.
                                  
                                            1
                                          
                                          spam = {‘color’: ‘red’, ‘age’:
                                              42}for v in
                                              spam.values():print(v)
                                        
                                            Copied!
                                          
                                    Prints red
                                  
                                    Prints 42
                                  
                                            1
                                          
                                          for k in
                                              spam.keys():print(k)
                                        
                                            Copied!
                                          
                                    Prints color
                                  
                                    Prints age
                                  
                                    For loops can also iterate over both
                                        keys and values.
                                  
                                    Getting tuples
                                  
                                            1
                                          
                                          for i in
                                              spam.items():print(i)
                                        
                                            Copied!
                                          
                                    Prints (‘color’, ‘red’)
                                  
                                    Prints (‘age’, 42)
                                  
                                    Destructuring to values
                                  
                                            1
                                          
                                          for k, v in
                                              spam.items():print(‘Key: ‘ + k + ‘
                                              Value: ‘ + str(v))
                                        
                                            Copied!
                                          
                                    Prints Key: age Value: 42
                                  
                                    Prints Key: color Value: red
                                  
                                    Looping over string
                                  
                                            1
                                          
                                          for c in “abcdefg”:print(c)
                                        
                                            Copied!
                                          
                                    When you order arguments within a
                                        function or function call, the args need
                                        to occur in a particular order:
                                  
                                    formal positional args.
                                  
                                    *args
                                  
                                    keyword args with default values
                                  
                                    **kwargs
                                  
                                            1
                                          
                                          def example(arg_1, arg_2, *args,
                                              **kwargs):pass
                                        
                                            Copied!
                                          
                                            1
                                          
                                          def example2(arg_1, arg_2, *args,
                                              kw_1=”shark”, kw_2=”blowfish”,
                                              **kwargs):pass
                                        
                                            Copied!
                                          
                                      Importing in Python
                                    
                                    Modules are similar to packages in
                                        Node.js
                                        Come in different types:
                                  
                                    Built-In,
                                  
                                    Third-Party,
                                  
                                    Custom.
                                  
                                    All loaded using import
                                        statements.
                                  
                                      Terms
                                    
                                        module : Python code in a separate
                                            file. package : Path to a directory
                                            that contains modules.
                                          init.py
                                            : Default file for a package.
                                            submodule : Another file in a
                                            module’s folder. function : Function
                                            in a module.
                                      
                                    A module can be any file but it is
                                        usually created by placing a special
                                        file init.py into a folder. pic
                                  
                                    Try to avoid importing with wildcards
                                        in Python.
                                  
                                    Use multiple lines for clarity when
                                        importing.
                                  
                                            1
                                          
                                          from urllib.request import
                                              (HTTPDefaultErrorHandler as
                                              ErrorHandler,HTTPRedirectHandler
                                              as
                                              RedirectHandler,Request,pathname2url,url2pathname,urlopen,)
                                        
                                            Copied!
                                          
                                      Watching Out for Python 2
                                    
                                    Python 3 removed <> and only uses
                                        !=
                                  
                                    format() was introduced with P3
                                  
                                    All strings in P3 are unicode and
                                        encoded.
                                      md5 was removed.
                                  
                                    ConfigParser was renamed to
                                        configparser
                                      sets were killed in favor of set()
                                        class.
                                  
                                    print was a statement in P2, but is a
                                        function in P3.
                                  
                                      Topics revisited (in python
                                          syntax)
                                    
                                      Cheat Sheet:
                                    
                                    If you found this guide helpful feel
                                        free to checkout my github/gists where I
                                        host similar content:
                                  
                                    ​bgoonz’s gists · GitHub​
                                  
                                    Or Checkout my personal Resource
                                        Site:
                                  
                                      Python Cheat Sheet:
                                    
                                      If you found this guide helpful feel
                                          free to checkout my GitHub/gists where
                                          I host similar content:
                                    
                                      Or Checkout my personal Resource
                                          Site:
                                    
                                      Discover More:
Python For JS Developers
Awesome Web Development Youtube Video Archive
Last modified 14d ago
Copy link
Python Study Guide for a JavaScript Programmer

Related Articles:

Applications of Tutorial & Cheat Sheet Respectivley (At Bottom Of Tutorial):

Basics

`#` is used to make comments in your code.

Numbers

KEEP IN MIND:

Strings

Python uses `zero-based indexing`

Variables and Expressions

Boolean Data Type

Comparison Operators

Identity vs Equality

If Statements

While Statements

Try/Except Statements

Pass

Functions

Notes

Comma Thousands Separator

Date and Time

Percentage

Data Tables

Lists are the python equivalent of arrays.

You can instantiate

Working with dictionaries

For Statements In python, there is only one for loop.

Importing in Python

Terms

Watching Out for Python 2

Topics revisited (in python syntax)

Cheat Sheet:

Python Cheat Sheet:

If you found this guide helpful feel free to checkout my GitHub/gists where I host similar content:

Or Checkout my personal Resource Site:

Discover More:

Python Study Guide for a JavaScript Programmer

Related Articles:

Applications of Tutorial & Cheat Sheet Respectivley (At Bottom Of Tutorial):

Basics

# is used to make comments in your code.

Numbers

KEEP IN MIND:

Strings

Python uses zero-based indexing

Variables and Expressions

Boolean Data Type

Comparison Operators

Identity vs Equality

If Statements

While Statements

Try/Except Statements

Pass

Functions

Notes

Comma Thousands Separator

Date and Time

Percentage

Data Tables

Lists are the python equivalent of arrays.

You can instantiate

Working with dictionaries

For Statements In python, there is only one for loop.

Importing in Python

Terms

Watching Out for Python 2

Topics revisited (in python syntax)

Cheat Sheet:

Python Cheat Sheet:

If you found this guide helpful feel free to checkout my GitHub/gists where I host similar content:

Or Checkout my personal Resource Site:

Discover More:

`#` is used to make comments in your code.

Python uses `zero-based indexing`
