Difference between revisions of "EGR 103/Spring 2019/Skills Quiz"

From PrattWiki
Jump to navigation Jump to search
 
 
(2 intermediate revisions by the same user not shown)
Line 1: Line 1:
 +
Draft v. 0.1 - 1/31/2019
 +
 
== ints and floats ==
 
== ints and floats ==
 
* Operators (** * / % // + -) -- work as expected as long as you expect x**y to be x to the yth power!
 
* Operators (** * / % // + -) -- work as expected as long as you expect x**y to be x to the yth power!
Line 6: Line 8:
 
* int(blah) returns the integer value of blah if blah is a string with a valid integer in it
 
* int(blah) returns the integer value of blah if blah is a string with a valid integer in it
 
* float(blah) returns the float value of blah if blah is a string with a valid float in it
 
* float(blah) returns the float value of blah if blah is a string with a valid float in it
 +
 +
== arrays ==
 +
* rectangular sequences of numbers (ints or floats)
 +
* create using np.array(COLLECTION) where COLLECTION could be a list, list of lists, tuple, tuple of tuples, etc - must be rectangular
 +
* + between arrays will add corresponding elements; + between an array and a number will add that number to each element
 +
** -, *, /, **, //, and % work in similar fashion
 +
* np.TRIG() (where TRIG is cos, sin, etc) works on an array -- note that m.TRIG() will not
 +
* no easy way to append an array
 +
** x = np.array([*x, NEW])  works - haven't used in class or lab
 +
* slicing
 +
* Must use np.max() np.min() and np.mean() to get max, min, and average
 +
** collection.copy() to create duplicate list somewhere else in memory
  
 
== lists ==
 
== lists ==
Line 40: Line 54:
 
** phrase.lower(), phrase.upper(), phrase.capitalize() -- returns a string with words having appropriate cases
 
** phrase.lower(), phrase.upper(), phrase.capitalize() -- returns a string with words having appropriate cases
  
== slices ==
+
== slicing ==
* work on strings, lists, and tuples
+
* work on arrays, strings, lists, and tuples
 
* thing[a:b:c] will slice the elements in thing starting with the ath item and going to just before the bth item, skipping c items at a time.   
 
* thing[a:b:c] will slice the elements in thing starting with the ath item and going to just before the bth item, skipping c items at a time.   
 
* For a thing with N elements,
 
* For a thing with N elements,
Line 47: Line 61:
 
** Default for b is N if c is positive or "up to and including the 0th entry" if c is negative
 
** Default for b is N if c is positive or "up to and including the 0th entry" if c is negative
 
* If going backwards, you must include a negative c; thing[4:2] will return an empty version the same type as thing
 
* If going backwards, you must include a negative c; thing[4:2] will return an empty version the same type as thing
 +
* For lists of lists (or tuples of tuples) or arrays, can cascade indices (q[2][4]
 +
* FOR ARRAYS ONLY can use x[row(s), col(s)]
  
 
== logic ==
 
== logic ==
Line 70: Line 86:
 
* np.polyfit(x, y, ord) and np.polyval(coefs, new_x)
 
* np.polyfit(x, y, ord) and np.polyval(coefs, new_x)
 
* np.loadtxt('filename')
 
* np.loadtxt('filename')
 +
* np.min(), np.mean(), np.max()
  
  
Line 117: Line 134:
 
** for k in range(start, stop): iterates over integers from start to stop-1
 
** for k in range(start, stop): iterates over integers from start to stop-1
 
** for k in range(start, stop, step): iterates over integers from start by step to the value before hitting or going over stop
 
** for k in range(start, stop, step): iterates over integers from start by step to the value before hitting or going over stop
 +
* for idx,val in enumerate(ITERABLE): provides an index in idx and the value in that index in val
 
* nested versions of all of the above
 
* nested versions of all of the above
  
Line 139: Line 157:
  
 
== Not on test ==
 
== Not on test ==
 +
* Dictionaries
 
* LaTeX
 
* LaTeX
 
* binary
 
* binary
 +
* try...except
 +
* open, write, close

Latest revision as of 15:43, 1 February 2019

Draft v. 0.1 - 1/31/2019

ints and floats

  • Operators (** * / % // + -) -- work as expected as long as you expect x**y to be x to the yth power!
  • += and -= to add or subtract a value from a variable
  • Relational operators (< <= == >= > !=)
  • round(blah, [ndigits=0]) -- rounds to the 10**(-ndigits) place; round(123.456, -1) is 120.0 for instance.
  • int(blah) returns the integer value of blah if blah is a string with a valid integer in it
  • float(blah) returns the float value of blah if blah is a string with a valid float in it

arrays

  • rectangular sequences of numbers (ints or floats)
  • create using np.array(COLLECTION) where COLLECTION could be a list, list of lists, tuple, tuple of tuples, etc - must be rectangular
  • + between arrays will add corresponding elements; + between an array and a number will add that number to each element
    • -, *, /, **, //, and % work in similar fashion
  • np.TRIG() (where TRIG is cos, sin, etc) works on an array -- note that m.TRIG() will not
  • no easy way to append an array
    • x = np.array([*x, NEW]) works - haven't used in class or lab
  • slicing
  • Must use np.max() np.min() and np.mean() to get max, min, and average
    • collection.copy() to create duplicate list somewhere else in memory

lists

  • Sequence made up of any types of items, including other lists
  • + will concatenate lists ([1, 2] + [3] yields [1, 2, 3])
    • Have to be lists -- [1, 2] + 3 yields an error!
  • += will append an item to a list - that item must be a list!
  • * will repeat lists -- [1, 2] * 3 yields [1, 2, 1, 2, 1, 2]
  • Useful commands (assume the variable collection is a list):
    • max(collection), min(collection) -- returns the appropriate value if all items are the same type (i.e. all numbers or all strings or all lists)
    • slicing
    • collection.copy() to create duplicate list somewhere else in memory

tuples

  • Immutable - cannot change values
  • Sequence made up of any types of items, including other tuples
  • Single-element tuples created by putting , after item: x = (3,)
  • + will concatenate tuples ((1, 2) + (3,) yields (1, 2, 3))
    • Have to be tuples -- (1, 2) + 3 or (1, 2) + (3) both yield an errors!
  • += will append an item to a tuple and replace the old tuple with the new one - that item must be a tuple!
  • * will repeat tuples -- (1, 2) * 3 yields (1, 2, 1, 2, 1, 2)
  • Useful commands (assume the variable collection is a tuple):
    • max(collection), min(collection) -- returns the appropriate value if all items are the same type (i.e. all numbers or all strings or all lists)
    • slicing
    • collection.copy() to create duplicate list somewhere else in memory

strings

  • Immutable - cannot change characters
  • + will concatenate strings ('Go' + ' ' + 'Duke' yields 'Go Duke')
  • * will repeat strings ('Go' * 4 yields 'GoGoGoGo')
  • ord(letter) can work on a single-character to return the ASCII value of that single letter; chr(number) will give the string related to the ASCII value of number. Since this only works on one character, need to map it to get all of them.
  • Useful commands (assume the variable phrase is some string):
    • phrase = input("prompt: ") -- input always gets a string, use int() or float() to convert to something else if needed
    • phrase.lower(), phrase.upper(), phrase.capitalize() -- returns a string with words having appropriate cases

slicing

  • work on arrays, strings, lists, and tuples
  • thing[a:b:c] will slice the elements in thing starting with the ath item and going to just before the bth item, skipping c items at a time.
  • For a thing with N elements,
    • Default for a is 0 if c is positive or N if c is negative
    • Default for b is N if c is positive or "up to and including the 0th entry" if c is negative
  • If going backwards, you must include a negative c; thing[4:2] will return an empty version the same type as thing
  • For lists of lists (or tuples of tuples) or arrays, can cascade indices (q[2][4]
  • FOR ARRAYS ONLY can use x[row(s), col(s)]

logic

  • Logical operators (not, and, or)
  • "in" operator
    • check if integer is in a list or tuple
    • check if a letter or string is in a list of strings or in a string -- note different between "Ha" in "Happy" (which is True) and "Ha" in ["Happy"], which is false
    • Note: if you are checking if a list is in another list, the whole list has to be there! So, 1 in [1, 2, 3] is true, [1] in [1, 2, 3] is false, and [1] in [[1], 2, 3] is true.

math

  • requires import math or import math as m
  • Constants: m.pi and m.e
  • Trig -- only works on a single value (m.sin(), m.cos(), m.asin(), etc); degrees are in radians
  • Rounding -- m.ceil(), m.floor()
  • Others:
    • m.log(x, [b==m.e]) returns base b logarithm of x
    • m.exp(x) returns m.e**x

numpy

  • requires import numpy or import numpy as np
  • np.linspace()
  • np.random.randint(), np.random.uniform(), np.random.normal(), np.random.seed()
  • np.polyfit(x, y, ord) and np.polyval(coefs, new_x)
  • np.loadtxt('filename')
  • np.min(), np.mean(), np.max()


printing

  • Be able to use print using replacement fields and the format command
  • Given a replacement field of the form "{" [field_name] ["!" conversion] [":" format_spec] "}", be able to use:
    • field name: if blank, take next field on stack; if a number, take that entry in the stack
    • conversion - N/A
    • format spec - given the general format spec of [[fill]align][sign][#][0][width][,][.precision][type], be able to use:
      • sign: if this is +, put - and + in front of numbers; otherwise, ignore +
      • width: reserve at least this much space to print the number; if the number needs more space, it will take it. If it needs left, default alignment is to the right for a number and to the left for a string
      • precision: number of digits after the decimal point
      • type: s for strings, f for regular floating point, e for scientific notation
  • default is for print to append '\n' to go to next line; use print(thing, end="") to stop that from happening


plotting

  • requires import matplotlib.pyplot as plt
  • Start with
fig,ax = plt.subplots(num=1, clear=True)
  • fig.clf()
  • ax.plot(y)
  • ax.plot(x, y)
  • ax.plot(x, y, format)
  • ax.set_xlabel(), ax.set_ylabel(), ax.set_title(), ax.grid()
  • fig.savefig(NAME)
  • Need to know for the format:
    • colors: b g r c m y k w
    • line styles: - -- -. :
    • marker styles: . o s + D
    • Can only put one color in format

functions

  • definition and default cases
  • required inputs,
  • returns (returns a tuple - can either grab all or each individually)

program flow

  • if trees
    • May include multiple elif branches
    • May include else branch at the end
  • for loops
    • for k in LIST: iterates over each item in the list
    • for k in TUPLE: iterates over each item in the tuple
    • for k in STRING: iterates over each character in the string
    • for k in range(stop): iterates over integers from 0 to stop-1
    • for k in range(start, stop): iterates over integers from start to stop-1
    • for k in range(start, stop, step): iterates over integers from start by step to the value before hitting or going over stop
  • for idx,val in enumerate(ITERABLE): provides an index in idx and the value in that index in val
  • nested versions of all of the above

unix

Be able to define the following commands, show common use cases

  • pwd
  • ls
    • also ls -a
  • cd
  • mkdir
  • wget
    • Given a web address for a file, know how to get the file
  • tar
    • specifically tar -kxvf FILE.tar
  • cp
    • also cp -ir
  • emacs
  • latex
  • dvipdf
  • evince
  • & after a command

Not on test

  • Dictionaries
  • LaTeX
  • binary
  • try...except
  • open, write, close