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