my python study two | Python Fiddle

a = [1,2,'cc','d', 3]
b = a #pointor copy, change a value will reflect to another
c = a[:] #content copy, c have seperate memory place

print a, b, c
a[0] = 111
print a, b, c
for var in a:
    print var
    
#test if a value is in the list
print 111 in a, 111 in c

# chan two list together
print a+b

#reture None, just add this value this the list
a.append(321) 
print a

# remove indecate value from the list
print a.pop(1) 
print a
print sorted(a)
del a[0] 
print a
print b

# remove the defination of a[0], but the value still there
m = 10
n = m
del m 
print n

#customer sort function
a = ['c', 'dddd', 'ffa', 'ddd']
def last(s):
    return s[-1]
print a
print sorted(a, key=last, reverse=False)

#put a list together as a string
b = ' % '.join(a)
print b

#split a string to list
print b.split('%')

print range(10)

# this one is imutable, both content and length
a = (2,3,4,5)
print a

######################################################################################
print "#################################list 1########################################"
# Copyright 2010 Google Inc.
# Licensed under the Apache License, Version 2.0
# http://www.apache.org/licenses/LICENSE-2.0

# Google's Python Class
# http://code.google.com/edu/languages/google-python-class/

# Basic list exercises
# Fill in the code for the functions below. main() is already set up
# to call the functions with a few different inputs,
# printing 'OK' when each function is correct.
# The starter code for each function includes a 'return'
# which is just a placeholder for your code.
# It's ok if you do not complete all the functions, and there
# are some additional functions to try in list2.py.

# A. match_ends
# Given a list of strings, return the count of the number of
# strings where the string length is 2 or more and the first
# and last chars of the string are the same.
# Note: python does not have a ++ operator, but += works.
def match_ends(words):
	# +++your code here+++
	countor = 0
	for word in words:
		if 2 <= len(word) and word[0] == word[-1]:
			countor += 1
	return countor

# B. front_x
# Given a list of strings, return a list with the strings
# in sorted order, except group all the strings that begin with 'x' first.
# e.g. ['mix', 'xyz', 'apple', 'xanadu', 'aardvark'] yields
# ['xanadu', 'xyz', 'aardvark', 'apple', 'mix']
# Hint: this can be done by making 2 lists and sorting each of them
# before combining them.
def keyPair(word):
    if 'x' == word[0]:
        a = 1
    else:
        a = 2
    return (a, word)
def front_x(words):
	# +++your code here+++
	return sorted(words, key=keyPair)

# C. sort_last
# Given a list of non-empty tuples, return a list sorted in increasing
# order by the last element in each tuple.
# e.g. [(1, 7), (1, 3), (3, 4, 5), (2, 2)] yields
# [(2, 2), (1, 3), (3, 4, 5), (1, 7)]
# Hint: use a custom key= function to extract the last element form each tuple.
def lastInTuple(tupleVal):
    return tupleVal[-1]
def sort_last(tuples):
	# +++your code here+++
	return sorted(tuples, key = lastInTuple)

# Simple provided test() function used in main() to print
# what each function returns vs. what it's supposed to return.
def test(got, expected):
	if got == expected:
		prefix = ' OK '
	else:
		prefix = 'X '
	print '%s got: %s expected: %s' % (prefix, repr(got), repr(expected))

# Calls the above functions with interesting inputs.
def main():
	print 'match_ends'
	test(match_ends(['aba', 'xyz', 'aa', 'x', 'bbb']), 3)
	test(match_ends(['', 'x', 'xy', 'xyx', 'xx']), 2)
	test(match_ends(['aaa', 'be', 'abc', 'hello']), 1)

print
	print 'front_x'
	test(front_x(['bbb', 'ccc', 'axx', 'xzz', 'xaa']), ['xaa', 'xzz', 'axx', 'bbb', 'ccc'])
	test(front_x(['ccc', 'bbb', 'aaa', 'xcc', 'xaa']), ['xaa', 'xcc', 'aaa', 'bbb', 'ccc'])
	test(front_x(['mix', 'xyz', 'apple', 'xanadu', 'aardvark']), ['xanadu', 'xyz', 'aardvark', 'apple', 'mix'])

print
	print 'sort_last'
	test(sort_last([(1, 3), (3, 2), (2, 1)]), [(2, 1), (3, 2), (1, 3)])
	test(sort_last([(2, 3), (1, 2), (3, 1)]), [(3, 1), (1, 2), (2, 3)])
	test(sort_last([(1, 7), (1, 3), (3, 4, 5), (2, 2)]), [(2, 2), (1, 3), (3, 4, 5), (1, 7)])

if __name__ == '__main__':
	main()
    
    
##################################################################################################
print "################################list 2####################################################"
# Copyright 2010 Google Inc.
# Licensed under the Apache License, Version 2.0
# http://www.apache.org/licenses/LICENSE-2.0

# Google's Python Class
# http://code.google.com/edu/languages/google-python-class/

# Additional basic list exercises

# D. Given a list of numbers, return a list where
# all adjacent == elements have been reduced to a single element,
# so [1, 2, 2, 3] returns [1, 2, 3]. You may create a new list or
# modify the passed in list.
def remove_adjacent(nums):
	# +++your code here+++
	if not nums:
		return nums
	preNum = nums[0] + 1
	numList = []
	for num in nums:
		if preNum != num:
			numList.append(num)
			preNum = num
	return numList

# E. Given two lists sorted in increasing order, create and return a merged
# list of all the elements in sorted order. You may modify the passed in lists.
# Ideally, the solution should work in "linear" time, making a single
# pass of both lists.
def linear_merge(list1, list2):
	# +++your code here+++
    retList = []
    i, j = 0, 0
    while True:
		if i < len(list1) and j < len(list2):
			if list1[i] > list2[j]:
				retList.append(list2[j])
				j +=1
			else:
				retList.append(list1[i])
				i +=1
		else:
			break
    retList = retList + list1[i:]
    retList = retList + list2[j:]
    return retList

# Note: the solution above is kind of cute, but unforunately list.pop(0)
# is not constant time with the standard python list implementation, so
# the above is not strictly linear time.
# An alternate approach uses pop(-1) to remove the endmost elements
# from each list, building a solution list which is backwards.
# Then use reversed() to put the result back in the correct order. That
# solution works in linear time, but is more ugly.

# Calls the above functions with interesting inputs.
def main():
	print 'remove_adjacent'
	test(remove_adjacent([1, 2, 2, 3]), [1, 2, 3])
	test(remove_adjacent([2, 2, 3, 3, 3]), [2, 3])
	test(remove_adjacent([]), [])

print
	print 'linear_merge'
	test(linear_merge(['aa', 'xx', 'zz'], ['bb', 'cc']), ['aa', 'bb', 'cc', 'xx', 'zz'])
	test(linear_merge(['aa', 'xx'], ['bb', 'cc', 'zz']), ['aa', 'bb', 'cc', 'xx', 'zz'])
	test(linear_merge(['aa', 'aa'], ['aa', 'bb', 'bb']), ['aa', 'aa', 'aa', 'bb', 'bb'])

if __name__ == '__main__':
	main()

Python Fiddle

Python Cloud IDE