From f370b6ae87445cae5d92b4575e6091101be4ca99 Mon Sep 17 00:00:00 2001 From: anapauladsmendes Date: Sat, 6 Oct 2018 16:16:01 -0300 Subject: [PATCH] Organization of README.md and renomeation of programs name --- README.md | 21 +++++++++++ class.py | 23 +++++++++++ dicts.py | 23 +++++++++++ exceptions.py | 90 ++++++++++++++++++++++++++++++++++++++++++++ factorial.py | 9 +++++ file.py | 9 +++++ func.py | 8 ++++ game.py | 66 ++++++++++++++++++++++++++++++++ generators.py | 47 +++++++++++++++++++++++ import.py | 32 ++++++++++++++++ input.py | 12 ++++++ listcomprehension.py | 24 ++++++++++++ lists.py | 31 +++++++++++++++ loops.py | 26 +++++++++++++ methods_input.py | 37 ++++++++++++++++++ nested_loops | 25 ++++++++++++ permutation.py | 29 ++++++++++++++ print.py | 34 +++++++++++++++++ tuples.py | 30 +++++++++++++++ while.py | 38 +++++++++++++++++++ 20 files changed, 614 insertions(+) create mode 100644 class.py create mode 100644 dicts.py create mode 100644 exceptions.py create mode 100644 factorial.py create mode 100644 file.py create mode 100644 func.py create mode 100644 game.py create mode 100644 generators.py create mode 100644 import.py create mode 100644 input.py create mode 100644 listcomprehension.py create mode 100644 lists.py create mode 100644 loops.py create mode 100644 methods_input.py create mode 100644 nested_loops create mode 100644 permutation.py create mode 100644 print.py create mode 100644 tuples.py create mode 100644 while.py diff --git a/README.md b/README.md index 9d4ed7d..cd601b9 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,23 @@ # Learn-Python To make the users familiar with the syntax of Python. + +Samples: + + - [class](/Learn-Python/class.py) + - [dicts](/Learn-Python/dicts.py) + - [exceptions](/Learn-Python/exceptions.py) + - [factorial](/Learn-Python/factorial.py) + - [file](/Learn-Python/file.py) + - [func](/Learn-Python/func.py) + - [game](/Learn-Python/game.py) + - [generators](/Learn-Python/generators.py) + - [import](/Learn-Python/import.py) + - [input](/Learn-Python/input.py) + - [list](/Learn-Python/list.py) + - [comprehension lists](/Learn-Python/comprehension_lists.py) + - [loops](/Learn-Python/loops.py) + - [methods input](/Learn-Python/methods_input.py) + - [permutation](/Learn-Python/permutation.py) + - [print](/Learn-Python/print.py) + - [tuples](/Learn-Python/tuples.py) + - [while](/Learn-Python/while.py) diff --git a/class.py b/class.py new file mode 100644 index 0000000..0870430 --- /dev/null +++ b/class.py @@ -0,0 +1,23 @@ +# SAMPLE CODE TO ILLUSTRATE CLASSES IN PYTHON + + + +class TheThing(object): + def __init__(self): + self.number = 0 + def some_function(self): + print "I got called." + def add_me_up(self, more): + self.number += more + return self.number +# two different things +a = TheThing() +b = TheThing() +a.some_function() +b.some_function() +print a.add_me_up(20) +print a.add_me_up(20) +print b.add_me_up(30) +print b.add_me_up(30) +print a.number +print b.number diff --git a/dicts.py b/dicts.py new file mode 100644 index 0000000..9d9dcac --- /dev/null +++ b/dicts.py @@ -0,0 +1,23 @@ +# SAMPLE CODE TO UNDERSTAND THE CONCEPT OF DICTIONARIES IN PYTHON + +cities = {'CA': 'San Francisco', 'MI': 'Detroit','FL': 'Jacksonville'} +cities['NY'] = 'New York' +cities['OR'] = 'Portland' +def find_city(themap, state): + if state in themap: + return themap[state] + else: + return "Not found." +# ok pay attention! + +cities['_find'] = find_city + +while True: + print "State? (ENTER to quit)", + state = raw_input("> ") + if not state: break + +# this line is the most important ever! study! + + city_found = cities['_find'](cities, state) + print city_found diff --git a/exceptions.py b/exceptions.py new file mode 100644 index 0000000..d04fe2d --- /dev/null +++ b/exceptions.py @@ -0,0 +1,90 @@ +# python sampleexceptions.py + +# Minimal types of exceptions are used in this sample. +# For a list of built in python exceptions see https://docs.python.org/2/library/exceptions.html + + +# Expected Output: +# +# Basic exception raised. +# Basic exception with message: ERROR. +# Caught non basic exception: No module named badimport. +# Caught non basic exception: unsupported operand type(s) for +: 'int' and 'str'. +# Demonstrated how to handle multiple types of exceptions the same way. +# Demonstrated how to handle multiple types of exceptions the same way with a message: No module named badimport. +# Demonstrated how to handle exceptions differently. +# This should appear. +# Demonstrated how finally is run after exceptions. +# Demonstrated how else is run when no exceptions occur. +# Demonstrated how to use a basic custom exception: Custom Exception. + + +try: + raise Exception +except: + print "Basic exception raised." + + +try: + raise Exception("ERROR") +except Exception as e: + print "Basic exception with message: %s." % str(e) + + +try: + import badimport +except ImportError as e: + print "Caught non basic exception: %s." % str(e) + + +try: + test = 1 + '1' +except TypeError as e: + print "Caught non basic exception: %s." % str(e) + + +try: + import badimport +except ImportError, TypeError: + print "Demonstrated how to handle multiple types of exceptions the same way." + + +try: + import badimport +except (ImportError, TypeError) as e: + print "Demonstrated how to handle multiple types of exceptions the same way with a message: %s." % str(e) + + +try: + import badimport +except ImportError: + print "Demonstrated how to handle exceptions differently." +except TypeError: + print "This should not appear." + + +try: + import badimport +except ImportError: + print "This should appear." +finally: + print "Demonstrated how finally is run after exceptions." + + +try: + test = 1 + 1 +except: + print "This should not appear." +else: + print "Demonstrated how else is run when no exceptions occur." + + +class CustomBasicError(Exception): + """ Custom Exception Type - Can be customised further """ + pass + + +try: + raise CustomBasicError("Custom Exception") +except CustomBasicError as e: + print "Demonstrated how to use a basic custom exception: %s." % str(e) diff --git a/factorial.py b/factorial.py new file mode 100644 index 0000000..c884dd0 --- /dev/null +++ b/factorial.py @@ -0,0 +1,9 @@ +def fatorial(n): + if(n == 0 or n == 1): + return 1 + else: + return fatorial(n-1)*n + +n = int(input("Please, enter the numb: ")) +fatorial(n) +print(fatorial(n)) diff --git a/file.py b/file.py new file mode 100644 index 0000000..326d59a --- /dev/null +++ b/file.py @@ -0,0 +1,9 @@ +from sys import argv +script , filename =argv +txt=open(filename) +print "here is your file %r" %filename +print txt.read() +print "i'll also ask you to type it again" +fi=raw_input("> ") +tx=open(fi) +print tx.read() diff --git a/func.py b/func.py new file mode 100644 index 0000000..998966e --- /dev/null +++ b/func.py @@ -0,0 +1,8 @@ +def multiply(a,b): + c=a*b + print "product is %r" %c +def add(a,b): + e=a+b + print "addition is %r" %e +multiply(3,4) +add(3,4) diff --git a/game.py b/game.py new file mode 100644 index 0000000..be0539b --- /dev/null +++ b/game.py @@ -0,0 +1,66 @@ +# SAMPLE CODE TO ILLUTRATE THE CONCEPT OF BRANCHES AND FUNCTIONS IN PYTHON +# Users are advised to go through this piece of code and dry run it to get an understanding of function calls. + +from sys import exit +def gold_room(): + print "This room is full of gold.How much do you take?" + next = raw_input("> ") + if "0" in next or "1" in next: + how_much = int(next) + else: + dead("Man, learn to type a number.") + if how_much < 50: + print "Nice, you're not greedy, you win!" + exit(0) + else: + dead("You greedy bastard!") +def bear_room(): + print "There is a bear here." + print "The bear has a bunch of honey." + print "The fat bear is in front of another door." + print "How are you going to move the bear?" + bear_moved = False + while True: + next = raw_input("> ") + if next == "take honey": + dead("The bear looks at you then slaps your face off.") + elif next == "taunt bear" and not bear_moved: + print "The bear has moved from the door. You can go through it now." + bear_moved = True + elif next == "taunt bear" and bear_moved: + dead("The bear gets pissed off and chews your leg off.") + elif next == "open door" and bear_moved: + gold_room() + else: + print "I got no idea what that means." + +def cthulu_room(): + print "Here you see the great evil Cthulu." + print "He, it, whatever stares at you and you go insane." + print "Do you flee for your life or eat your head?" + next = raw_input("> ") + if "flee" in next: + start() + elif "head" in next: + dead("Well that was tasty!") + else: + cthulu_room() + +def dead(why): + print why, "Good job!" + exit(0) + +def start(): + print "You are in a dark room." + print "There is a door to your right and left." + print "Which one do you take?" + next = raw_input("> ") + if next == "left": + bear_room() + elif next == "right": + cthulu_room() + else: + dead("You stumble around the room until you starve.") + +start() + diff --git a/generators.py b/generators.py new file mode 100644 index 0000000..b47f665 --- /dev/null +++ b/generators.py @@ -0,0 +1,47 @@ +# Generators hold values that are fetched lazily. +# Meaning that the entire collection isn't stored +# in memory all at once, but rather retrieved when +# needed. + +# This is best used when dealing with a large +# collection of items. Such as rows returned from +# a database call or looping over a large csv. + +# Generators are intelligent enough to handle these +# large collections without running out of memory. +# They dispose of variables in memory that are no +# longer used and do not worry about variables +# that are not yet needed. + +# Here's the syntax for a generator. It's just a +# function! Take note of the yield keyword. yield +# basically means 'return', but lets Python know +# we'll be coming back for more. +def color_generator(): + yield 'blue' + yield 'orange' + yield 'yellow' + yield 'purple' + +# One way to use generators is by calling `next()` +# on it's instance +g = color_generator() # create the instance +next(g) # 'blue' +next(g) # 'orange' +next(g) # 'yellow' +next(g) # 'purple' + +# However, once a generator is exhausted, it will +# not start back at the beginning. +next(g) # Raises StopIteration error. + +# They're also iterables. No StopIteration errors +# are thrown with this method. +for color in color_generator(): + print(color) + +# 'blue' +# 'orange' +# 'yellow' +# 'purple' + diff --git a/import.py b/import.py new file mode 100644 index 0000000..3d209c2 --- /dev/null +++ b/import.py @@ -0,0 +1,32 @@ +# import command line argument reader 'argv' from the 'sys' python module +from sys import argv + +# takes the two arguments after the 'python' command, +# and assigns to the variables 'script' and 'user_name' +script, user_name = argv + +# assigns the string with an arrow and space to the variable 'prompt' +prompt = '> ' + +# user_name, the second argument, and 'sampleimport.py' replace %s in the order listed +print "Hi %s, I'm the %s script." % (user_name, script) +print "I'd like to ask you a few questions." + +# replaces %s with the variable user_name and prints +print "Do you like me %s?" % user_name + +# prints '> ' and allows user to input a value, assigns user input to the 'likes' variable +likes = raw_input(prompt) + +# repeats the process above two more times +print "Where do you live %s?" % user_name +lives = raw_input(prompt) +print "What kind of computer do you have?" +computer = raw_input(prompt) + +# takes the last three user inputs in order and inserts into the last print statement, replacing %r +print """ +Alright, so you said %r about liking me. +You live in %r. Not sure where that is. +And you have a %r computer. Nice. +""" % (likes, lives, computer) diff --git a/input.py b/input.py new file mode 100644 index 0000000..1d7d815 --- /dev/null +++ b/input.py @@ -0,0 +1,12 @@ +# import command line argument reader 'argv' from the 'sys' python module +from sys import argv + +# takes the four arguments after the 'python' command, +# and assigns to the variables 's', 'f', 'ss', and 't' +s,f,ss,t=argv + +# prints the four arguments on separate lines with text +print "the script is" , s +print "var1 1 is" , f +print "var 2 is" , ss +print "var 3 is" , t diff --git a/listcomprehension.py b/listcomprehension.py new file mode 100644 index 0000000..0ac7991 --- /dev/null +++ b/listcomprehension.py @@ -0,0 +1,24 @@ +# Hi! Welcome to this mini tutorial on using list comprehensions in Python! +# Check out samplelists.py if you need help with lists. + +# Starting off with list comprehensions! +# Syntax used to make an ordinary list: +my_list = ["apple", "banana", "pear", "peach"] + +# To concisely make a new list of elements, use a list comprehension: +list_comp = [num for num in range(10)] # Notice how square brackets are +# used to create a list. +print list_comp + +# List comprehension syntax can be understood as so: +# [num for num in range(5)] +# Make a new num for each num in given range + +# The first expression (before the "for" keyword) can be altered to satisfy a +# given condition over an iterable. +doubled_list_comp = [num * 2 for num in list_comp] +print doubled_list_comp + +# Furthermore, "if" statements can be used in list comprehensions as well. +even_num_list_comp = [num for num in list_comp if num % 2 == 0] +print even_num_list_comp diff --git a/lists.py b/lists.py new file mode 100644 index 0000000..7364347 --- /dev/null +++ b/lists.py @@ -0,0 +1,31 @@ +# We now will build some lists using some loops and print them out: +the_count = [1, 2, 3, 4, 5] +fruits = ['apples', 'oranges', 'pears', 'apricots'] +change = [1, 'pennies', 2, 'dimes', 3, 'quarters'] + +# this first kind of for-loop goes through a list +for number in the_count: + print "This is count %d" % number + +# same as above +for fruit in fruits: + print "A fruit of type: %s" % fruit + +# also we can go through mixed lists too +# notice we have to use %r since we don't know what's in it +for i in change: + print "I got %r" % i + +# we can also build lists, first start with an empty one +elements = [] + +# then use the range function to do 0 to 5 counts +for i in range(0, 6): + print "Adding %d to the list." % i + +# append is a function that lists understand + elements.append(i) + +# now we can print them out too +for i in elements: + print "Element was: %d" % i diff --git a/loops.py b/loops.py new file mode 100644 index 0000000..aee9a27 --- /dev/null +++ b/loops.py @@ -0,0 +1,26 @@ +# assigns numbers 1 through 3 to an array +arr=[1,2,3] + +# assigns three names to an array +arrstr=["ashu" , "himu" , "piyu"] + +# loops through each number from the number array, and prints the number +for num in arr: + print "numbers are %d" %num + +# loops through each name from the name array, and prints the name +for name in arrstr: + print "names are %s" %name + +# initializes an empty array +arrinput=[] + +# asks the user for a input four times and pushes inputs into an array +for i in range(0,4): + print "enter element number %d" %i + number = raw_input("> ") + arrinput.append(number) + +# loops through the input array and prints each input +for inp in arrinput: + print "elements are %r" %inp diff --git a/methods_input.py b/methods_input.py new file mode 100644 index 0000000..b0330f6 --- /dev/null +++ b/methods_input.py @@ -0,0 +1,37 @@ +# Example input: +# 5 +# 1 2 3 4 5 +# Example Output: n = 5, data = [1, 2, 3, 4, 5] +n, data = input(), [int(i) for i in input().strip().split()] + +# How to take input from multiple lines +# Will take input until sees a blank line (sentinel) +# Example input: +# 1 2 3 +# 4 5 +# Example Output: user_input = '1 2 3 4 5' +sentinel = '' +user_input = '\n'.join(iter(input, sentinel)).replace('\n', ' ') + +# Example input: +# 1 2 3 4 +# Example Output: var1 = 1, var2 = 2, var3 = 3, var4 = 4, such that var1, var2, var3, var4 are of type string +var1, var2, var3, var4 = input().split() + +# Example input: +# 1 2 3 4 +# Example Output: var1 = 1, var2 = 2, var3 = 3, var4 = 4, such that var1, var2, var3, var4 are of type int +var1, var2, var3, var4 = map(int, input().split()) + +# Example input: +# 1 2 3 +# 1 2 3 +# ... +# 1 2 3 +while True: + try: + + var1, var2, var3 = map(int, input().split()) + + except EOFError: + break \ No newline at end of file diff --git a/nested_loops b/nested_loops new file mode 100644 index 0000000..42e28a3 --- /dev/null +++ b/nested_loops @@ -0,0 +1,25 @@ +#Program to understand working of loops and nested loops in python by a simple pattern formation. +#suppose if user enters 4 then the following should be printed +#output - +# * + +# * * + +# * * * + +# * * * * +# ignore all the '#' above in the output + +a=int(input("enter ")) #we take an input from the users of how many lines the pattern should run. +for i in range(a): #executing a loop, here i's value will start from 0 till a-1. + t=((a-1)-i) #carefuly observing the pattern we get to understand that we need loop for spaces and one for * so first we define t that will contain values from a-1 to 0 + for b in range(t): #creating a Nested loop for spaces + print(" ",end=' ') + k=i+1 #by observing the pattern above we can see that we need a variable that can print the number of * , and by logic the line number = number of * in that line + for c in range(k): # making a loop to print * + print("*"," ",end=' ') + print("\n") + +# Hence loops work in a defined order to produce a specific result. +# hence in all , all the logical patterns are solved by nested loop concept and to be a master in that getting the right logic and sufficient number of nested loops is important. +# If possible try running this python code and try putting different input and see the output diff --git a/permutation.py b/permutation.py new file mode 100644 index 0000000..dda502a --- /dev/null +++ b/permutation.py @@ -0,0 +1,29 @@ +# PowerSet.py +# Description: given an array of numbers, generates +# a power set + +def findPowerSet(originalSet, index, currentSet, powerSet): + if (index >= len(originalSet)): + # add list to power set(convert list to tuple) + powerSet.append(currentSet) + return + + # set where element was not added + notAddedSet = currentSet[:] + + # append both sets + currentSet.append(originalSet[index]) + + # recursive call to other elements in originalSet + findPowerSet(originalSet, index + 1, currentSet, powerSet) + findPowerSet(originalSet, index + 1, notAddedSet, powerSet) + + +if __name__ == "__main__": + print("in main file") + testSet = [1, 2, 3] + powerSet = [] + + findPowerSet(testSet, 0, [], powerSet) + + print("Final Set = " + str(powerSet)) diff --git a/print.py b/print.py new file mode 100644 index 0000000..00ec5a0 --- /dev/null +++ b/print.py @@ -0,0 +1,34 @@ +# prints an empty space since comments are ignored +print #"Hello World!" + +# prints the following strings and separate lines +print "Hello Again" +print "I like typing this." +print "This is fun." +print 'Yay! Printing.' +print "I'd much rather you 'not'." +print 'I "said" do not touch this.' + +# prints the boolean value of this mathematical comparison +print 3 + 2 < 5 - 7 + +# assigning numerical values to variables +cars = 100 +space_in_a_car = 4.0 +drivers = 30 +passengers = 90 + +# performing mathematical operations on the variables above, +# and assigning the answers to new variables +cars_not_driven = cars - drivers +cars_driven = drivers +carpool_capacity = cars_driven * space_in_a_car +average_passengers_per_car = passengers / cars_driven + +# the new variables are printed on separate lines +print "We need to put about", average_passengers_per_car, "in each car." +print "We have", passengers, "to carpool today." +print "There will be", cars_not_driven, "empty cars today." +print "We can transport", carpool_capacity, "people today." +print "There are only", drivers, "drivers available." +print "There are", cars, "cars available." diff --git a/tuples.py b/tuples.py new file mode 100644 index 0000000..2ff50b5 --- /dev/null +++ b/tuples.py @@ -0,0 +1,30 @@ +# SAMPLE CODE TO ILLUSTRATE TUPLES IN PYTHON + +days = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday") +print "tuple: ", days + +# a tuple is a collection +for day in days: + print day + +print day[0] + +# we can get each element in a tuple +monday, tuesday, wednesday, thursday, friday, saturday, sunday = days +print monday, tuesday, wednesday, thursday, friday, saturday, sunday + +# A tuple also can have differents types. Arrays, dicts even other tuples +tupleMix = (1,"happy", 3.1416, True, [1,2], {"lang": "English"}, (1,2)) +print tupleMix + +# we can concat tuples +a = (1,2,3) +b = (4,5,6) +c = a + b +print c + +# or multiply a tuple +a = ("hi",) * 4 +print a + +# :) learn more about tuples right here https://docs.python.org/3.1/tutorial/datastructures.html \ No newline at end of file diff --git a/while.py b/while.py new file mode 100644 index 0000000..4aafc35 --- /dev/null +++ b/while.py @@ -0,0 +1,38 @@ +# A while-loop will keep executing the code block under it as long as a boolean expression is True. +# If we write a line and end it with a colon then that tells Python to start a new block of code. +# Then we indent and that is the new code. +# This is all about structuring your programs so that Python knows what you mean. +# If you do not get that idea then go back and do some more work with if-statements, functions, and the for-loop until you get it. + +# SAMPLE CODE + +# initialize the while iterator to 0 +i = 0 + +# initialze empty numbers array +numbers = [] + +# keep running this while loop as long as 'i' is less than 6 +while i < 6: + + # prints the value of i at the beginning of the loop + print "At the top i is %d" % i + + # adds the number i to the number array + numbers.append(i) + + # increase the number i by 1 + i = i + 1 + + # prints the current numbers array + print "Numbers now: ", numbers + + # prints the value of i at the end of the loop + print "At the bottom i is %d" % i + +# prints the numbers of the numbers array, +# every value of i during the loop before it exited (0 through 5) +# since the while loop exited when i reached 6 +print "The numbers: " +for num in numbers: + print num