summaryrefslogtreecommitdiffhomepage
path: root/python.html.markdown
blob: 8a9ea48f8d3cf1a7c3955f682758d1b0ea502840 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
---
language: Python
author: Louie Dinh
author_url: http://ldinh.ca
---

Python was created by Guido Van Rossum in the early 90's. It is now one of the most popular languages in existence. I fell in love with Python for it's syntactic clarity. It's basically executable pseudocode.

```Python
# Single line comments start with a hash.
""" Multiline comments can we written
    using three "'s
"""

----------------------------------------------------
-- 1. Primitive Datatypes and Operators
----------------------------------------------------

# You have numbers
3 #=> 3

# Math is what you would expect
1 + 1 #=> 2
8 - 1 #=> 9
10 * 2 #=> 20
35 / 5 #=> 7

# Division is a bit tricky. It is integer division and floors the results automatically.
11 / 4 #=> 2

# Enforce precedence with parentheses
(1 + 3) * 2 #=> 8

# Boolean values are primitives
True
False

# negate with not
not True #=> False
not False #=> True


# Equality is ==
1 == 1 #=> True
2 == 1 #=> False

# Strings are created with " or '
"This is a string."
'This is also a string.'

# Strings can be added too!
"Hello " + "world!" #=> "Hello world!"

# A string can be treated like a list of characters
"This is a string"[0] #=> 'T'

# None is an object
None #=> None


----------------------------------------------------
-- 2. Variables and Collections
----------------------------------------------------

# Printing is pretty easy
print "I'm Python. Nice to meet you!"


# No need to declare variables before assigning to them.
some_var = 5    # Convention is to use lower_case_with_underscores for variables
some_var #=> 5

# Accessing a previously unassigned variable is an exception
some_other_var  # Will raise a NameError


# Lists store sequences
li = []
# You can start with a prefilled list
other_li = [4, 5, 6]

# Add stuff to the end of a list with append
li.append(1)    #li is now [1]
li.append(2)    #li is now [1, 2]
li.append(4)    #li is now [1, 2, 4]
li.append(3)    #li is now [1, 2, 4, 3]

# Access a list like you would any array
li[0] #=> 1
# Looking out of bounds is an IndexError
li[4] # Raises an IndexError

# Remove elements from a list with del
del li[2] # li is now [1, 2, 3]

# You can add lists
li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li and other_li is left alone

# Concatenate lists with extend
li.extend(other_li) # Now li is [1 ,2 ,3 ,4 ,5 ,6] 

# Check for existence in a list with in
1 in li #=> True

# Examine the length with len
len(li) #=> 6

# Tuples are like lists but are immutable
tup = (1, 2, 3)
tup[0] #=> 1
tup[0] = 3  # Raises a TypeError


# Dictionaries store mappings
empty_dict = {}
# Here is a prefilled dictionary
filled_dict = {"one": 1, "two": 2, "three": 3}

# Look up values with []
filled_dict["one"] #=> 1

# Get all keys as a list
filled_dict.keys() #=> ["three", "two", "one"] Note - Dictionary key ordering is not guaranteed. Your results might not match this exactly.

# Get all values as a list
filled_dict.values() #=> [3, 2, 1] Note - Same as above regarding key ordering.

# Check for existence of keys in a dictionary with in
"one" in filled_dict #=> True
1 in filled_dict #=> False


# Sets store ... well sets
empty_set = set()
# Initialize a set with a bunch of values
filled_set = set([1,2,2,3,4]) # filled_set is now set([1, 2, 3, 4])

# Add more items to a set
filled_set.add(5) # filled_set is now set([1, 2, 3, 4, 5])

# Do set intersection with &
other_set = set([3, 4, 5 ,6])
filled_set & other_set #=> set([3, 4, 5])

# Do set union with |
filled_set | other_set #=> set([1, 2, 3, 4, 5, 6])

# Check for existence in a set with in
2 in filled_set #=> True
10 in filled_set #=> False


----------------------------------------------------
-- 3. Control Flow
----------------------------------------------------

# Let's just make a variable
some_var = 5

# Here is an if statement. INDENTATION IS SIGNIFICANT IN PYTHON!
# prints "some var is smaller than 10"
if some_var > 10:
    print "some_var is totally bigger than 10."
elif some_var < 10:    # This elif clause is optional.
    print "some_var is smaller than 10."
else:           # This is optional too.
    print "some_var is indeed 10."


"""
For loops iterate over lists
prints:
    dog is a mammal
    cat is a mammal
    mouse is a mammal
"""
for animal in ["dog", "cat", "mouse"]:
    print "%s is a mammal" % animal     # You can use % to interpolate formatted strings

"""
While loops go until a condition is no longer met.
prints:
    0
    1
    2 
    3
"""
x = 0
while x < 4:
    print x
    x += 1  # Short hand for x = x + 1

# Handle exceptions with a try/except block
try:
    raise IndexError("This is an index error")  # Use raise to raise an error
except IndexError as e:
    pass    # Pass is just a no-op. Usually you would do recovery here.


----------------------------------------------------
-- 4. Functions
----------------------------------------------------

# Use def to create new functions
def add(x, y):
    print "x is %s and y is %s" % (x, y)
    return x + y    # Return values with a return statement

# Calling functions with parameters
add(5, 6) #=> 11 and prints out "x is 5 and y is 6"
# Another way to call functions is with keyword arguments
add(y=6, x=5)   # Equivalent to above. Keyword arguments can arrive in any order.

# You can define functions that take a variable number of positional arguments
def varargs(*args):
    return args

varargs(1, 2, 3) #=> (1,2,3)


# You can define functions that take a variable number of keyword arguments
def keyword_args(**kwargs):
    return kwargs

# Let's call it to see what happens
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}


# Python has first class functions
def create_adder(x):
    def adder(y):
        return x + y
    return adder

# Let's create a new function that always adds 10 to the argument
add_10 = create_adder(10):
add_10(3) #=> 13

# There are also anonymous functions
(lambda x: x > 2)(3) #=> True

# There are built-in higher order functions
map(add_10, [1,2,3]) #=> [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]

# We can use list comprehensions for nice maps and filters
[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]

----------------------------------------------------
-- 5. Classes
----------------------------------------------------

# We can define classes with the class statement
class Human():    # By convention CamelCase is used for classes. 
    pass

# We subclass from object to get a "new-style class". All your code should do this.
class Human(object):

     # A class attribute. It is shared by all instances of this class
    species = "H. sapiens"

    # Basic initializer
    def __init__(self, name):
        self.name = name        # We are assigning the argument to the instance's name attribute

    # A method. All methods take self as the first argument, including the initializer
    def say(self, msg):
       return "%s: %s" % (self.name, msg)

    # A class method is shared among all instances
    @classmethod
    def get_species(cls):
        return cls.species

    # Static methods are called without a parameter reference to the class or instance
    @staticmethod
    def grunt():
        return "*grunt*"


# Instantiate a class
h = Human(name="Harry")
print h.say("hi")     # prints out "Harry: hi"
i = Human("Ian")
print i.say("hello")  #prints out "Ian: hello"

# Call our class method
h.get_species() #=> "H. sapiens"

# Change the shared attribute
h.species = "H. neanderthalensis"
h.get_species() #=> "H. neanderthalensis"
i.get_species() #=> "H. neanderthalensis"

# Call the static method
Human.grunt() #=> "*grunt*"