Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision 		Previous revision
python [2019/02/22 18:14]
paul [Virtual Environments] 		python [2019/07/09 17:29] (current)
paul [Formatting]
Line 1: Line 1:
 ====== Python ===== ====== Python =====
  
-==== Web App ====+You can make a python file run by adding this to the script: 
 + 
 +<code bash> 
 +#!/usr/bin/python 
 +</code> 
 + 
 +This tells the command line that it is a python script. 
 + 
 +There is a distinction between function, and instances. Like for instance, a file 
 +called: 
 + 
 +<code python> 
 +test_file = open("test.txt", "wb") 
 +</code> 
 + 
 +This file has instances you can acces: 
 + 
 +<code python> 
 +test_file.mode  
 +</code> 
 + 
 +Then there are also functions you can access, and to access them you use parenthesis. 
 + 
 +===== Python Version ===== 
 +Ok so theres a very big distinction between python 2 and 3. I already ran into 
 +issues looking at tutorials and just using the print statement, which apparently 
 +got changed from a statement to a function in version 3. 
 + 
 +In my version of Ubuntu 16.04, the default python is 2, and to use 3 i have to do 
 +python3 
 + 
 +===== Python Types ===== 
 + 
 +Numbers, strings, lists, tuples, dictionary. 
 + 
 +==== Strings ==== 
 + 
 +Multiple ways of printing strings. 
 +  * single quotes 
 +  * double quotes 
 +  * triple quotes 
 + 
 +==== Numbers ==== 
 +Integers by default. 
 + 
 +In python you do not predeclare variables. It is dynamically typed. You don't have to 
 +worry about types. 
 + 
 +In python you don't worry about references or pointers. But you do worry about 
 +mutable vs immutable data. 
 + 
 +Integers are an immutable type. Strings are also immutable. Lists are mutable.   
 + 
 +To make a list you do: 
 +  
 +<code python> 
 +x = [0 , 1] 
 +</code> 
 + 
 +Python puts values in memory and then it creates labels to it. Thats a concept of 
 +variables. Ok cool, so a big ditinction is that data is stored in memory, vs 
 +allocated for by datatypes. 
 + 
 +==== Booleans ==== 
 + 
 +0 evaluates to ''%%False%%''. 1 or any other number evaluates to ''%%True%%''. 
 + 
 +==== Lists ==== 
 + 
 +Lists are one of the fundamental datatypes. You can create lists by doing the 
 +following: 
 + 
 +<code python> 
 +this_is_a_list = ['Cup', 'Watch', 'Scissors', 'Iphone'] 
 +</code> 
 + 
 +You can index the list: 
 + 
 +<code python> 
 +print(this_is_a_list[0])  
 + 
 +# This prints everything including 0 up to but not including 3. 
 +print(this_is_a_list[0:3]) 
 +</code> 
 + 
 +You can have lists inside of lists. 
 + 
 +There is a crazy amount of stuff with can do with lists, and python is really 
 +flexible and easy to use. Sort, add, combine lists, what have you. Super quick and 
 +easy. 
 + 
 +==== Tuple ==== 
 + 
 +Unlike a list, you can't change a tuple after you create it. 
 + 
 +Declared with parenthesis. 
 + 
 +<code python> 
 +this_is_a_tuple(3,1,4,1,5,9) 
 +</code> 
 + 
 +==== Dictionaries ==== 
 + 
 +Values that have a unique key for each value that you are storing. Very similar to 
 +lists, but you can't join like you can with a plus sign. 
 + 
 +===== Operators ===== 
 + 
 +7 different operators.  
 + 
 +<code python> 
 ++ - * / % ** // 
 +</code> 
 + 
 +==== Logical Operators ==== 
 + 
 +<code python> 
 +if else elif 
 +</code> 
 + 
 +<code python> 
 +== != > >= < <== 
 +</code> 
 + 
 +You can combine conditionals with ''%%or%%'' and ''%%not%%''. 
 + 
 +===== Loops ===== 
 + 
 +==== for loops ==== 
 + 
 +for x in range(0,10) 
 +for x in this_is_list 
 + 
 +==== while loops ==== 
 + 
 +<code python> 
 +while(x != 0): 
 +  do stuff! 
 +</code> 
 +     
 +===== Functions ===== 
 + 
 +Functions allow us to reuse and make more readable code. In python you don't have to 
 +specify return type. Woah! 
 + 
 +<code python> 
 +def addNumber(fNum, lNum): 
 +    sumNum  = fNum + lNum 
 +    return seNum 
 +</code> 
 + 
 +===== Strings ===== 
 + 
 +Python has really strong string support. You can index characters 
 +within strings using square brackets 
 + 
 +<code python> 
 +string_thing(0:2) 
 +</code> 
 + 
 +Theres a bunch of stuff you can with the % operator, the string formatting operator 
 + 
 +each string kinda becomes an object that has lots of functions associated with it 
 + 
 +  * ''%%isalpha()%%'' 
 +  * ''%%isalnum()%%'' 
 +  * ''%%strip()%%'' 
 +  * ''%%split()%%'' 
 + 
 +==== Formatting ==== 
 + 
 +If you want to print a neat line of data use the [[https://docs.python.org/2/library/string.html#format-string-syntax|Format String Syntax]]. 
 + 
 +For example:  
 +<code python> 
 +print("[ FAIL ] {: <20} Channel: {: <20} Statistics: {:>6.4f} hz".format(description, chan, stats)) 
 +</code> 
 + 
 +This sets a fix width for each field and aligns the test either left ''%%<%%'' or right ''%%>%%'' 
 + 
 +===== Mutability ===== 
 + 
 +In python pretty much everything is an object, and these objects are either 
 +mutable or immutable. Mutable means the object and its contants can change and 
 +immutable means that it cannot. Lots of basic data types are immutable, such as 
 +int, float, and string. The crazy thing is that python creates an object to 
 +represent that value that a variable such as an int is set to and then uses the 
 +variable as a tag that points to that object. 
 + 
 +Immutable ojects: 
 +  * bool 
 +  * int 
 +  * float  
 +  * tuple 
 +  * str 
 + 
 +Mutable objects: 
 +  * list 
 +  * set 
 +  * dict 
 + 
 + 
 +===== File IO ===== 
 + 
 +Yay, we access files! 
 + 
 +It is super easy. Just use the ''%%open%%'', ''%%close%%'', ''%%read%%'', 
 +''%%write%%'' file functions! Create a variable that is a file, then open it, 
 +read it, write it, delete it using an os function, whatever you want man! 
 + 
 +===== OOP ===== 
 + 
 +Objects have attributes and abilities. We define these objects inside classes that 
 +contain attributes and abilities. 
 + 
 +Define a class using class ''%%Name:%%'' 
 + 
 +Private attributes are preceeded by two underscores. 
 + 
 +There is the ''%%self%%'' instance that refers to the object instance. Just like 
 +the ''%%this%%''.  
 + 
 +There are also constructors which you call with ''%%__init__%%''  
 + 
 +There is method overloading, which you do by setting a parameter to ''%%None%%''. This makes 
 +it optional. Then you can check inside the method if that parameter is None.  
 + 
 +There is polymorphism, which allows you to make functions that take in a parent 
 +class, and then you can pass in child objects of that parent class.  
 + 
 +See the ''%%classes.py%%'' in the learn directory for examples!! 
 + 
 +===== Web App =====
  
 Did this [[https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-iii-web-forms|python - flask tutorial]] Did this [[https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-iii-web-forms|python - flask tutorial]]
  
 I used SQLAlchemy python plugin to interface with an SQLite db and also used a migration app to automatically handle db changes. I used SQLAlchemy python plugin to interface with an SQLite db and also used a migration app to automatically handle db changes.
-==== Debugging ====+ 
 +===== Debugging =====
 {{::screenshot_2019-01-10_10-25-29.png?400|}} {{::screenshot_2019-01-10_10-25-29.png?400|}}
  
 To debug, you can use PuDB, which is a nice graphical terminal program. To debug, you can use PuDB, which is a nice graphical terminal program.
  
-==== Virtual Environments ====+===== Virtual Environments =====
  
 A virtual environment creates a python environment stored in a folder of your choosing. This allows you to install all kinds of crap not to your system, but to that virtual environment in that folder. A virtual environment creates a python environment stored in a folder of your choosing. This allows you to install all kinds of crap not to your system, but to that virtual environment in that folder.
Line 20: Line 253:
 python3 -m venv /path/to/virtualenv/folder python3 -m venv /path/to/virtualenv/folder
 </code> </code>
 +
 +===== Plane Notes =====
 +
 +Did a bunch of review, and now gonna skim through the book!
 +
 +Fundamental data types:
 +ints, floats, strings,
 +
 +Learning how to build strings with single quotes, double quotes and tripple
 +single/double quotes.
 +
 +Learning how to build lists and index it and slice them with ranges [0:4]. Only
 +works in legal ranges. A slice will always return a list. an access will return
 +an element.
 +
 +Learning about ranges.
 +
 +Learned about pop, and how you can index a pop, by doing
 +list_whatever.pop(index) and how theres no push in python because there is an
 +append, and python wants to be all pure and shit and not have duplicate
 +functions.
 +
 +You can assign lists uisng text parallel assignment
 +<code python>
 +firstname, lastname = ["Bilbo", "Baggins"]
 +</code>
 +
 +God python is so wierd with shit, like, there's all these nice little features
 +everywhere. Haha.
 +
 +Dictionaries have keys and they are defined by curly braces {}. They are
 +unordered. You can make a dictionary using a sequence of keys.
 +
 +Learning about the format functions on strings. God damn dude you can do
 +anything to strings. You use it by calling it on a string and using {0}, {1} ...
 +positionals to insert formatted string values.
 +
 +For instance to insert a decimal number from a calc:
 +
 +<code python>
 +strNum = "Hi this a the square root of 2: {0:.{1}f}".format(math.sqrt(2),5)
 +</code>
 +
 +Omg reg exes. Ok so you can create a pattern by using
 +pattern = re.compile('whater|whatever|'), then you use a function in the pattern
 +to split a string. COOOL.
 +<code python>
 +pattern = re.compile(",|:|;")
 +pattern.split("Hi,I'm:a;string")
 +# this will print out ["Hi",'I'm','a','string']
 +</code>
 +
 +You can do so much funky shit with strings. Every string object has a list of
 +useful functions.
 +
 +OK tuples time and I'm fuggin DONE. Tuples are like lists, but they're assigned
 +with parenthesis and they're immutable so you can't append or pop. Apparently
 +they're faster.
 +
 +They can only be changed by replacement. So you could do something like:
 +<code python>
 +t = (1,2,3)
 +l = list(t)
 +l.append("apples")
 +t = tuple(l)
 +</code>
 +
 +You can index tuples by using square braces.
 +
 +Tuples of 1 are not created as tuples, but as objects of their respective
 +datatype.
 +
 +Empty types are still tuples.
 +
 +<code python>
 +().__class__ == tuple
 +</code>
 +
 +Tuples can be embedded!
 +
 +===== Methods =====
 +
 +To make a function you simply write:
 +
 +<code python>
 +def my_function(a, b)
 +    return a + b
 +</code>
 +
 +PS: this is how you document a method.
 +<code python>
 +##
 +# @brief This function does this
 +# 
 +# @return It returns nothing
 +#
 +</code>
 +
 +You can create a method that is in the class scope by adding a self parameter.
 +
 +Methods that don't return anything return ''%%None%%''.
 +
 +You can have method with default arguments:
 +
 +<code python>
 +def method_a(a,b,c=3):
 +    return a + b + c
 +</code>
 +
 +Functions without self arg are global, even if they are defined in a class.
 +
 +Empty functions need a pass function but lines after the pass filler still get
 +called.
 +
 +A string placed at the top of a function definition is a documentation string
 +that can be accessed with the ''%%__doc__%%'' attribute.
 +
 +===== Classes =====
 +
 +It's very easy to make classes in python. 
 +
 +<code python>
 +class Rabbit:
 +    def name(self):
 +        return "Muccho"
 +    def _status(self):
 +        return "dead"
 +    def __password(self):
 +        return 'password'
 +</code>
 +
 +===== Control Statements =====
 +
 +The ''%%continue%%'' statement is fun. It sends the execution to the start of
 +the while loop without running any code following the continue.
 +
 +
  • python.1550859287.txt.gz
  • Last modified: 2019/02/22 18:14
  • by paul