In Vim there are two modes.

• i : Change to INSERT mode
• ESC : Change to COMMAND MODE (non-insert mode)
• . : repeat last action

Save and Close

The following commands are executed from COMMAND MODE.

• :w : save the document, this will not close vim
• :q : quit
• :wq : save and quit

Moving Cursors

To move the cursor you can use the arrow keys, or alternatively the ‘h’,'j’,'k’,'l’ keys. There are other options to move the cursor faster to other locations.

• h : left
• j : down
• k : up
• l : right
• 0 (number zero) : move to beginning of line
• $ (dollar sign) : move to end of line
• w,b,e : to move along words, for example: for(int i= 0; i < 10; i++) { will move from beginning of for to end of for, then to after parenthesis then to end of int ...
• W,B,E : to move along non-blanks, for example: for(int i= 0; i < 10; i++) { will move from beginning of for to end of int, then to after ; ...
• f + (character) : moves to the first occurrence of the character on the line, must enter the character right after f

Basic Editing

Editing, includes coping and pasting done in COMMAND MODE.

• d + (followed by a a cursor motion) : delete next item
• dd : delete line
• y + (followed by a cursor motion) : copy next item
• yy : copy line
• p : paste after
• P (capital p) : paste before

Searching

(done in command mode)

• / + (followed by regex string) + (return) : highlights all the findings
• ? + (followed by regex string) + (return) : highlights but moves backward
• n : moves the cursor to the next occurrence of the search entered using last two commands
• (move cursor under a word) + (ESC) + * : searches for that string

Macros

http://www.thegeekstuff.com/2009/01/vi-and-vim-macro-tutorial-how-to-record-and-play/

• q + (followed by a character) : start recording, the program is in RECORDING MODE
• q : stops recording if in recording mode
• @ + (character defined for recording) : plays the macro
• number + @ + (macro character defined) : replays macro for ‘Number’ of time

Resources

http://www.viemu.com/a_vi_vim_graphical_cheat_sheet_tutorial.html

Print stuff on the screen

Printing content on the screen can be done using the print statement. Here are some examples:

cars = 100
print "There are", cars, "cars available."
#output:
#There are 100 cars available.

t_name = "Gary Joorian"
t_age  = 25
print "My name is %s and I'm %d year old." % (t_name, t_age)
#output:
#My name is Gary Joorian and I'm 25 year old.

print "My name is %r and I'm %r year old." % (t_name, t_age)
#output:
#My name is Gary Joorian and I'm 25 year old.

word = "This is the first line" + "\n" + "This is the second line"
print word
#output:
#This is the first line
#This is the second line

print """
with three double-quotes
we can write on a new line
and no need for a new line char
"""
#output:
#with three double-quotes
#we can write on a new line
#and no need for a new line char

fat_cat = """
To Do list:
\t* eat
\t* sleep
"""
print fat_cat

#output:
#To Do list:
#	* eat
#	* sleep

String Manipulation

This will cover a very small subset of string manipulation. In python, a string is treated as a list of characters, so unlike Java or C#, it’s not an object type.

word = "name " + "and lastname"
print word
#output:
#name and lastname

word = "Honorific" + "        abilitudinitatibus".strip()
print word
#output:
#Honorificabilitudinitatibus

print word[6]
print word[17:21]
print word[:9]
print word[17:]
#output:
#f
#init
#Honorific
#initatibus

The last 4 lines of code illustrate that a string is essentially a list of characters. See the list section for more details.

User Input

use raw_input() to get a user input from the keyboard. The user input is not the same as the program arguments which a person uses when executing the program.
The user input is a string, which has to be converted to an integer if if required.

x = int(raw_input("Please enter an integer: "))
if x == 0:
     print 'zero'
elif x == 1:
     print 'One'
else:
     print 'None'

the raw_input allows the user to type in a string.

Program Arguments

Program arguments are variables sent to the program when executing them form a console. For example, if we execute a program named myprogram.py like so:

python myprogram.py 10 500 word

then 10, 500 and word are the first, second and third arguments sent to the program from the console.

from sys import argv # we are loading the argv module

script, first, second, third = argv #unpacking the values

print "The script is called:", script
print "Your first variable is:", first
print "Your second variable is:", second
print "Your third variable is:", third

assume this is the content of a file named arguments.py:

python arguments.py first 2nd 3rd
#output
The script is called: ex13.py
Your first variable is: first
Your second variable is: 2nd
Your third variable is: 3rd

for more advanced argument parsing technique look up examples for “optparse”. It creates helper / usage screen and validates user entered arguments automatically with user friendly messages indicating if any error occurred.

Read and Write to files

to open a files use open(filepath) which returns a file object for that file. for example:

from sys import argv

t_script, t_filename = argv
print "file to open is %s" % filename

t_file = open(t_filename) #open the file discriptor
t_fileCont = t_file.read() #will read all the content
print "the file content:"
print t_fileCont

To write to a file,

from sys import argv

t_script, t_filename = argv
print "file to write to is %s" % filename

# use 'w' to open file for write
t_file = open(t_filename, 'w') #open the file discriptor
t_text = raw_input("Input text > ")
t_file.write(t_text) #will read all the content
t_file.close() #must close file after write or read

use “\n” to insert newlines.

Some of the functionality of the file object:

t_filename = "somefile.txt"

# use 'w' to open file for write
t_file = open(t_filename, 'r') #open the file discriptor
t_file.readline();   #reads a whole line in the file
t_file.seek(0);   #moves the file cursor to the begging of the file
t_file.read();   #read all the content of the flie
t_file.close();  #must close file after write or read

Functions or Methods

In Python Methods are defined with the keyword ‘def’.

#Function that takes a list as input and prints
#the size of that list and the items
def PrintSizeAndItems(in_list):
	print "The size of a list is " + str(len(in_list))
	for t_name in in_list:
		print t_name

You can call the function like so,

_listOfNames = ["Adam", "Nazik" ,"Erik", "Alex"]
_listOfFoods = ["Potato", "Tomato" ,"Pizza"]
PrintSizeAndItems(_listOfNames)
PrintSizeAndItems(_listOfFoods)
PrintSizeAndItems("")

#output
The size of a list is 4
Adam
Nazik
Erik
Alex
The size of a list is 3
Potato
Tomato
Pizza
The size of a list is 0

You can specify a default value for arguments. like so:

def AskName(greet = 'Good Evening'):
	print greet
	_input = (raw_input("What is your name? "))
	print 'Hello ', _input.strip()
AskName()
AskName("Yo!")

But if you have functions with more than one argument,
it’s hard to keep track of which argument is what.
in Objective-C (Apple) you type in the parameter name
and then assign value to it so you wont get confused.
You can do the same in Python, like so:

def AskName(greet = 'Good Evening', hello = 'Hello'):
	print greet.strip()
	_input = (raw_input("What is your name? "))
	print hello.strip() , " " , _input.strip()
AskName(greet = "Hello Sir!" , hello = "Aloha")
AskName(greet = " Hola!" , hello = "saludo")

You can pass in an arbitrary list of arguments to a function
(using a C like pointer definition) like so:

def PathCombine(*in_paths):
	t_fullPath = "/"
	for t_path in in_paths:
		t_fullPath += t_path + '/'
	return t_fullPath
print PathCombine("Home", "user")
print PathCombine("var", "lib", "mysql")

#output
/Home/user/
/var/lib/mysql/

But if you pass in an argument list with keyword defined then
that list is treated like a dictionary. (we will get to this)

If Statement

The If statement is the same in python as in any language but instead of else if it’s elif. A general syntax of the if statement is:

if (condition):
    ....
elif (condition):
    ....
else:
    ....

where the three dots are regular statement. If you don’t what to use elif and instead another if statement of multiple condition cases, place a new line after the if executive statement and then the new if statement. For example:

temperature = 50;
if(temperature < 60)
    print "Temperature is below 60"

if(temperature > 90)
    print "it's really hot"

Loop

# Measure some strings:
a_word_list = ['cat', 'window', 'weird']
for x in a_word_list:
    print x, len(x)
#the output
cat 3
window 6
weird 5

You can place an else after a for loop, which will insure the execution of that code after the for loop has iterated through all the possible values:

_input = int(raw_input("Please enter an integer: "))
print _input
for a in range(0,100):
	if _input == a:
		print _input, ' is within 100'
		break
else:
	print 'input is NOT within 100 '

here is a sample run:

$ python lesson_2.py
Please enter an integer: 62
62
62  is within 100
$ python lesson_2.py
Please enter an integer: 301
301
input is NOT within 100

List

Lets create a list of names and print each one:

_listOfNames = ["Adam", "Nazik" ,"Erik", "Alex"]
print _listOfNames[0]
print _listOfNames[1]
print _listOfNames[2]
print _listOfNames[3]
#output
Adam
Nazik
Erik
Alex

much like strings, you can output a range of items using this pattern:

print _listOfNames[1:2]

and you can make a deep copy of the list like so:

copyOfNameList = _listOfNames[:]

** I dont know why it says shallow copy on the python website, I need to research more **

to be more elegant, we can traverse through this list using a for loop. So lets print the total number of names in the list and print each element.

_listOfNames = ["Adam", "Nazik" ,"Erik", "Alex"]
#len(list) takes a list as an argument and return the number of items in it,
#str(integer) takes an integer as an argument and returns the string
print "The size of a list is " + str(len(_listOfNames))
#print each name in the list
for t_name in _listOfNames:
	print t_name
#output is
The size of a list is 4
Adam
Nazik
Erik
Alex

Here are some of the basic methods you can call on a list to modify the values (directly from python website):

 a = [66.25, 333, 333, 1, 1234.5]
 print a.count(333), a.count(66.25), a.count('x')
2 1 0
 a.insert(2, -1)
 a.append(333)
 a
[66.25, 333, -1, 333, 1, 1234.5, 333]
 a.index(333)
1
 a.remove(333)
 a
[66.25, -1, 333, 1, 1234.5, 333]
 del a[0] #using index to remove the value
 a
[-1, 333, 1, 1234.5, 333]
 a.reverse()
 a
[333, 1234.5, 1, 333, -1]
 a.sort()
 a
[-1, 1, 333, 333, 1234.5]

more list functions:

#stack implementation
 stack = []
 stack.append(34)
 stack.append(12)
 stack
[34, 12]
 stack.pop()
12
 stack.pop()
34
#queue implementation
 queue = []
 queue.append("1")
 queue.append("2")
 queue.append("3")
 queue.append("4")
 queue.popleft()
1
 queue.popleft()
2

It is also possible to create a list of lists. For example a 3×3 matrix. Here is a sample:

mat = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
...       ]

to sort a list, call the sorted function:
sorted(a list of objects), which returns a the sorted version of a list

Tuples

Lets add the associated age to the names we listed. To do this, we will use tuples. Tuples are same as a set, but instead of brackets use parenthesis.

_listOfNames = (("Adam",46), ("Nazik",42) ,("Erik",15), ("Alex",18))
PrintSizeAndItems(_listOfNames)

but the output prints out in tuples:

The size of a list is 4
('Adam', 46)
('Nazik', 42)
('Erik', 15)
('Alex', 18)

lets create another function that pretty prints the names with the ages.

#print name and age
def PrintNameAndAge(in_list):
	print "The size of a list is " + str(len(in_list))
	for t_item in in_list:
		print t_item[0] + " is " + str(t_item[1]) + " years old."
_listOfNames = (("Adam",46), ("Nazik",42) ,("Erik",15), ("Alex",18))
PrintNameAndAge(_listOfNames)

IMPORTANT: to create a tuple container 0 item, create the item like so:

_listOfFruits = ()

IMPORTANT: to create a tuple container 1 item, create the item like so:

_listOfFruits = 'Banana', # ending comma

IMPORTANT: to create a tuple using the shorthand statement, create the item like so:

_listOfFruits = 'Banana', 'apple', 11

Dictionary

Dictionary is a list (array) but instead of index value of integer, it’s a string. Here the index is referred to as Key. The Key can be any data type except list and mutable object.

to create an empty dictionary:

 _fruitCost= {}

and to add values, you must specify a key followed by a ‘:’ and the value:

 _fruitCost= {'banana':7 , 'apple':0.8}
 _fruitCost['banana']
7

“The keys() method of a dictionary object returns a list of all the keys used in the dictionary, in arbitrary order (if you want it sorted, just apply the sorted() function to it). To check whether a single key is in the dictionary, use the in keyword.” (python.org)

you can use the sorted function like so:

 basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
 for f in sorted(set(basket)):
        print f

To loop through a dictionary you can use iteritems() to get the key and the value, like so:

 knights = {'gallahad': 'the pure', 'robin': 'the brave'}
 for k, v in knights.iteritems():
...     print k, v
...
gallahad the pure
robin the brave

Creating Modules

Modules to python is what libraries are to C/++/Java/etc…
here we have a few sample functions, that want to place them in a seperate file for
a cleaner reusable code.

#Function that takes a list as input and prints
#the size of that list along with the items
def PrintSizeAndItems(in_list):
	print "The size of a list is " + str(len(in_list));
	for t_name in in_list:
		print t_name

#Function that prompts the user for a yes or no response
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = raw_input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries <= 0 :
            raise IOError('refusenik user')
        print complaint

_listOfNames = (("Adam",46), ("Nazik",42) ,("Erik",15), ("Alex",18))
ask_ok("Ok to print?");
PrintNameAndAge(_listOfNames)

lets split the our code and place our functions in a separate file.

So create a another file named lesson_1_functions.py and place all the function definitions in there. (the file is in the same directory of where the lesson_1.py file is). So we would have:

#lesson_1_functions.py
#=====================

#Function that takes a list as input and prints
#the size of that list along with the items
def PrintSizeAndItems(in_list):
	print "The size of a list is " + str(len(in_list));
	for t_name in in_list:
		print t_name

#Function that prompts the user for a yes or no response
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = raw_input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries <= 0 :
            raise IOError('refusenik user')
        print complaint

and, so to use these functions in a different file, you’d need to import the file, like so:

#lesson_1.py
#===========

import lesson_1_functions

_listOfNames = (("Adom",46), ("Nazik",42) ,("Erik",15), ("Alex",18))
lesson_1_functions.ask_ok("Ok to print?");
lesson_1_functions.PrintSizeAndItems(_listOfNames)

Classes

Here is sample class structure:

class Person:
     def __init__(self, Name, Lastname, Sex, Age = None):
          self.Name = Name
          self.Lastname = Lastname
          self.Age = Age
          self.Sex = Sex

Another example of a class, which is a calculator class

class Calc:
    x,y = 0
    """A Calculator class"""
    def add(self):
        return self.x + self.y

The function, which is not a constructor, has ‘self’ for it’s first argument
which is a convention when defining methods for classes in python.

and to use the class:

t_basicCalc = Calc() #creates a new instance of the class
t_basicCalc.x = 4
t_basicCalc.y = 32
t_result = t_basicCalc.add();
print t_result; 		#prints 128
print t_basicCalc.__doc__ 	#returns "A Calculator class"

A note about class attributes – Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to.

def __init__, gets called when the object is instantiated. The self reference must be declared for every method but not needed to be passed when calling the method from an instance. An argument can have a default value if not specified by a user, in the Person class ‘Age’ is set to None (which is a the same as a null).

To create a Person object, all you do is set the class name to followed by a parenthesis to a variable.

t_someGirl = Person("Anna", "Stone" , 17, "female");

*****
if you defined the Person class in a module named “lesson_1_functions.py”, then you can instantiate Person like so:

t_someGirl = lesson_1_functions.Person("Anna", "Stone" , 17, "female");

*****

and to access the variable all you can do is use the dot notation, like so:

print t_someGirl.Name + " , " + t_someGirl.Lastname

which will print out: Anna , Stone

you can hold a collection of Person(s) like so:

People = []
People.append(Person("Giffan", "Pasoi", 42, "male"))
People.append(Person("Shean", "Perihas", 31, "male"))

for t_person in People:
	print t_person.Name + " , " + t_person.Lastname

the variables in a class are called attributes. Attributes can be deleted, like so:

t_person = Person("Tim","Stone",18,"male")
del t_person.Name

If you have long names for methods in classes, you can set it to a
variable and call it later.

t_person = Person("Tim","Stone",18,"male")
t_girl = Person("Brooke","Burke",30,"female")

t_girlFriend = t_person.IsRelationshipAnOption
#it takes a Person object as an argument
t_girlFriend(t_girl)

Inheritance

Example of inheritance:

class Base(object):
    def __init__(self, param):
        print "Base:", param
    def method(self, param):
        print "Base.method:", param

class Derived(Base):
    def __init__(self, param):
        super(Derived, self).__init__(param)
        print "Derived:", param
    def method(self, param):
        Base.method(self, param)
        print "Derived.method:", param

>>> d = Derived("me")
Base: me
Derived: me
>>> d.method("you")
Base.method: you
Derived.method: you

Python in Linux

In a Linux system, by default python is installed in /usr/local/bin/python directory.
To make a python script executable, set the permission mode to executable.

chmod +x python_script.py

to run it, call the script like so:

./python_script.py

Creating a GUI application

TKinter is the de facto GUI library for Python. You need to install the module in order to use it.
here is the code to install:

sudo apt-get install python-tk

here is a sample code:

from Tkinter import *

class App:

    def __init__(self, master):

        frame = Frame(master)
        frame.pack()

        self.button = Button(frame, text="QUIT", fg="red", command=frame.quit)
        self.button.pack(side=LEFT)

        self.hi_there = Button(frame, text="Hello", command=self.say_hi)
        self.hi_there.pack(side=LEFT)

    def say_hi(self):
        print "hi there, everyone!"

root = Tk()
app = App(root)

#run the main loop
root.mainloop()

Making Python scripts executable

the only way to execute python scripts is by typing python followed the name of the file. And, the other way is to include this line in the beginning of the python file:

#! /usr/bin/env python

and then change the file privileges to executable:

$ chmod +x python_file_script.py

*for windows, double clicking the python.py file will execute the file as if it’s an executable.

The standard library

os: directory/file operation

>>> import os
>>> os.getcwd()      # Return the current working directory
'C:\\Python26'
>>> os.chdir('/server/accesslogs')   # Change current working directory
>>> os.system('mkdir today')   # Run the command mkdir in the system shell
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>

shutil: file operation

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')

glob: directory

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

sys: input output

>>> import sys
>>> print sys.argv
['demo.py', 'one', 'two', 'three']
>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one

re: regex

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

#for simple ones use string operation
>>> 'tea for too'.replace('too', 'two')
'tea for two'

math: math operations

>>> import math
>>> math.cos(math.pi / 4.0)
0.70710678118654757
>>> math.log(1024, 2)
10.0

>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(xrange(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

urllib2: Internet Access

>>> import urllib2
>>> for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...         print line

Nov. 25, 09:43:32 PM EST

urllib2: Internet Access

>>> import urllib2
>>> for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...         print line

<BR>Nov. 25, 09:43:32 PM EST

datetime: time

>>> # dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'

>>> # dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

Performance

>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

Test Procedures

We have a sample function named average. The test procedure will be included in the comment area (where the __doc__ variable will read the text).

def average(values):
    """Computes the arithmetic mean of a list of numbers.

    >>> print average([20, 30, 70])
    40.0
    >>> print average([33, 41, 97])
    57.0
    >>> print average([31, 41, 97])
    57.0
    """
    return sum(values, 0.0) / len(values)

To run the tests, you must import doctest and call the testmod function.

import doctest
print doctest.testmod()   # automatically validate the embedded tests
**********************************************************************
File "lesson_3.py", line 8, in __main__.average
Failed example:
    print average([31, 41, 97])
Expected:
    57.0
Got:
    56.3333333333
**********************************************************************
1 items had failures:
   1 of   3 in __main__.average
***Test Failed*** 1 failures.
TestResults(failed=1, attempted=3)

Init

To start tracking a directory:

$ git init

Add

To start version-controlling specific files or a sub-set of files you need to add them to the staging area using the add command:

$ git add .
$ git commit -m 'first project commit'

The ‘.’ will add all files in the directory to the staging area. Instead of the ‘.’ which indicates all files in the directory you can write the full path to a file or a glob like pattern like *.c.

But you don’t want to do that some of the time, especially when you have a binary or executable file in the folder. The binary files are called Untracked files. Each file in your working directory can be in one of two states: tracked or untracked. Tracked files are files that were in the last snapshot, meaning files that were first places in the staging area. They can be unmodified, modified, or staged. Untracked files are files that will not be version-ed by git.

If you have a class of files which you don’t want Git to automatically add or not show as being tracked when calling status Then you can add those files as rules of Exception Example of such files are log files, object files, and etc.
You can add these class of files to a list of ignored files by typing the pattern in the .gitignore file:

$ cat .gitignore
(type the following lines inside the file)
*.[oa]     #for files ending with .o which are object files
*~         #for files that programs like Emacs create as a temporary cache

The .gitignore rules are:

• Blank lines or lines starting with # are ignored.
• Standard glob patterns work.
• You can end patterns with a forward slash (/) to specify a directory.
• You can negate a pattern by starting it with an exclamation point (!).

Commit

To commit changes to the repository, you need to commit the changes made in the staging area:

$ git commit

If you edit the files after adding them (staging the files), then the modified version will not be in the staging area, but the original file that was added last time ,will be in the staging area. Basically the modified version will be in the working directory, and the last time added version will be in the staging area. So a call to commit will not save the current changes. But only after adding the modified file again it will get in the staging area and ready to be committed to the repository.

Status

To see the status of the directory:

$ git status (or followed by –s for short version)

Let’s run a sample example:

$ vim README
$ git status
# On branch master
# Untracked files:
#   (use "git add ..." to include in what will be committed)
#
#	README
nothing added to commit but untracked files present (use "git add" to track)

$ git add README

$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD ..." to unstage)
#
#	new file:   README
#

Diff

If a file is changed in the working directory but not staged, you can view the changes using diff:

$ git diff

and you’ll see the changes indicated with + sign, like so:

diff --git a/readme.txt b/readme.txt
index 436fb61..ef8358f 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,2 +1,9 @@
what is this project?
+It is a python project
+

to see changes made in the staging area but not committed use the cached option:

$ git diff --cached

Clone

To get a copy of a project and it’s repository you need to do a clone. This is how you checkout a project in git:

$ git clone [url] ? the url can be ssh/http/https/ftp/git….

By default the Apache web server is installed on CentOS but even if it is not, you can install it using the following command:

$ sudo yum install httpd

to start the service, type the following entry:

$ service httpd start

if you want to be able to access your pages externally, you need to open port 80 on the firewall. Open up the iptables file:

$ vim /etc/sysconfig/iptables

and add the following line to the end of the file right before COMMIT:

A INPUT -m state --state NEW -m tcp -p tcp --dport 80 -j ACCEPT

save and exit, and then restart the firewall:

$ service iptables restart

The HTTP file location is in /var/www/
The index.html page should be in

/var/www/html

References

Apache guide by Dedoimedo

Setup

By default, Git is installed on your CentOS, but even if it is not for some reason you can install it manually.
Note: all of the following commands require root privilege:

$ su root

execute the following command to install git:

$ yum install git

don’t worry if you don’t know whether or not Git is installed on your system, the above command will detect whether it is installed or not and will ignore the installation request.

Configuration

To setup Git on CentOS, first you need to setup a SSH server on CentOS. Click here to read “Setting up SSH on CentOS“.

First, we will create a new user named Git on the Server system:

 $ adduser git  

To set or even change the password:

 $ passwd git  

A Git user will be created and the home directory of git will be created in

 /home/git  

The owner and the group owner of that folder must change so it belongs to the new user ‘git’ – we can change that via:

 $ chown git:git /home/git  

if you followed the steps from my last post on how to create SSH server on CentOS you must also add the ‘git’ user to the SSH allowed list of SSH-ers configured in this file:

 /etc/ssh/sshd_config 

Now lets create the project repository. We will login as git (exit root):

$ exit root
$ su git

and create the repo in the home directory:

$ cd ~
$ mkdir ProjectNameRepo.git
$ cd ProjectNameRepo.git
$ git init –bare

This folder will be the git repository on your server for this particular project. This is the folder where you will get copies from (called clone-ing) and committing new updates (called push-ing) from different users.

Using the System

From a different computer where you will use to code, create the project folder and create a readme file inside the folder, then initialize it using git:

$ mkdir ProjectName
$ cd ProjectName
$ touch readme.txt
$ git init

for more information on git commands see references at the bottom.
stage the newly added files using git add:

 $ git add . 

Now we must commit, but before that you must configure the user via git config. Your name and e-mail will be used in as part of the committing metadata.

$ git config --global user.name 'Your Name'
$ git config --global user.email you@somedomain.com
$ git commit -m 'My first commit! Matt Damooooon'

The changes have been snapshot-ed and will get transferred to the repo when pushed. Now, we need to define the repo server which is the CentOS PC we configured on the first part of this walkthrough.

$ git remote add origin ssh://git@server-address:port/~/ProjectNameRepo.git

And now we can push the code and push it later on when changes are made to the code:

 $git push origin master 

To get a clone of the project on a different PC user the following command:

$ git clone ssh://git@server-name:port/~/ProjectName.git

and if you want to work on it from the local server, you can get a copy by specifing a different path when calling clone

$ git clone /home/got/ProjectName.git

In both cases, a copy of the repo will get copied to your current location under the directory name ProjectName without the .git extension.

References

A git reference based tutorial: http://gitref.org/creating/

Setup

By default, SSH is installed on your CentOS, but even if it is not for some reason you can install it manually.
Note: all of the following commands require root privilege:

$su root

The most widely used SSH implementation is openssh which can be installed using this command:

$ yum install openssh

don’t worry if you don’t know whether or not SSH is installed on your system, the above command will detect if ssh is installed and it will ignore the request.

Configuration

To change the SSH settings, open up the following file (/etc/ssh/sshd_config) using a text editor. The easiest way to do this is using vim/vi since root privilege are required for this operation.

$ vim /etc/ssh/sshd_config

The file contains setting variables along with values First, we need to disable root access. What this means is that when using ssh to login to the computer you or anyone else shouldn’t be able to do root@mycomputer. So edit the following entry:

PermitRootLogin no

If you have specific users who are going to use ssh to login, add AllowUsers followed by the usernames, for example:

AllowUsers alice bob

For security reasons, change the default port from 22 to something else that is not being used by another process (for example do not use port 80, or 3433). To change the default port edit the following entry:

Port 4322

We are done with the ssh config file, so save and close it.

Al the last entry we changed the default port from 22 to 4322. Doing this would also require you to modify the Operating system firewall to allow access to port 4322. The firewall setting file is located at (/etc/sysconfig/iptables), so open it up using a text editor.

$ vim /etc/sysconfig/iptables

by default, port 22 is open on the firewall and the entry in the file that configures this is:

-A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT

so change the the number 22 to 4322 or any number you picked yourself.

-A INPUT -m state --state NEW -m tcp -p tcp --dport 4322 -j ACCEPT

Now save and close the file.

Since we modified the ssh server and the firewall settings, we need to restart the two services (or daemons).

$ service iptables restart
$ service sshd restart

if you have a router installed, read the rest of the steps.

Router Firewall

Your firewall is configured to ignore incoming packets. So we need to open up the new port 4322 and set it to route all the traffic to our PC using port forwarding.
First lets get the ip of the computer.

$ ifconfig

usually the first paragraph that starts with eth0, is the NIC your looking for. The IP should start with 192.168.xxx.xxx, in my case it is 192.168.1.3

Second go to your router page and find port forwarding page. Set the start and end ports to 4322 and the destination IP to the IP we found from last step, in my case this is 192.168.1.3. The specific steps are dependent on your router manufacturer.

Other Resources

CentOS Wiki page for SSH: http://wiki.centos.org/HowTos/Network/SecuringSSH

Python is a programming language like C or C++ with several key differences. First of all, it’s not as fast as C or C++ since it’s a scripting language. This means the code wont compile to a native machine language (10010101), instead a run-time environment will handle the execution. Secondly, Python is a dynamic language, meaning each line of code that the computer reads will get executed at that instant. But, python code will run on any machine (windows, mac, linux) and it’s very easy to learn and code in python.

Installing Python

If you haven’t already installed Python, you can find tutorials on-line on how to install python for your platform (Mac OS, Windows, Ubuntu, Red hat). Since I’m using Ubuntu, I’ll explain the installation process which is one line of bash code. Open up the terminal and type the following command:

$ sudo apt-get install python

Important Facts

• Python has no curly braces ({}). Instead of Braces python uses indentation to relate which part of code belongs to another. I use tab for indentation but the official website says use “Use 4-space indentation, and no tabs”. However if you use a proper programming text editor it will indent automatically.
• This is Pythons official tutorials page – this is where most of the material I present here is extracted from.
• There are two ways to write code in Python. One is straight from the interpreter and the other is within a file. We’ll write everything in a file and execute the code from files. The file which includes the python code has the “.py” extension.

Sample Run

Open up a terminal and create a directory where we can save all our exercise files there. Create a “lesson_1.py” file and write the following code in the file:

#assign 1 to number1
number1 = 1;
#assign 2 to number2
number2 = 2;
#add the two variables and place the result into number3
number3 = number1 + number2;
#print the value to the output
print number3;

on the terminal, cd into the newly created directory. Type python followed by the location of the lession_1.py file:

$ python lesson.py

and you’ll see a number 3 displaying on the output screen. The lines that start with a # are comments, so you can write notes and comments and it won’t affect your program. There is no need to type semicolon after each line however, if your going to write more than two phrases in one sentence you must include a semicolon (;) after each line. Using semicolon the above code will look something like this:

#all in one line
number1 = 1; number2 = 2; number3 = number1 + number2; print number3;

I mentioned above that you can execute your code straight from the interpreter. To do this, type python in the terminal:

garejoor@ubuntu:~$ python
Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24)
[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

now type in the same code we you wrote in the file above and press enter. You’ll see it will output the same result. To exit the interpreter type exit() and enter.