python基础总结(基于2.7版本也适用于3.4)

import urllib2  #调用urllib2  
url=‘http://www.baidu.com/s?wd=cloga‘ #把等号右边的网址赋值给url
html=urllib2.urlopen(url).read()   #html随意取名 等号后面的动作是打开源代码页面，并阅读
print html #打印

#coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-3
字符串演示部分
@author: samy
‘‘‘
# 单引号，双引号，三引号；
print(‘hello world‘)
print("hello world")
print(‘‘‘hello world‘‘‘)
age = 3
name = "samy"
# format()字符串
print("{0} was {1} year old ".format(name,age))
# 联合
print(name +" was "+str(age)+" year old ")
#换行符
print("What‘s your name?\n Samy")
# 字面常量
# 可以直接以字面意义使用它们
print(3.45e-3)#0.00345
#变量
# 命名规则：
# 第一个字符必须是字母或者下划线，其余字符可以是字母，数字，或者下划线；区分大小写；

# coding=utf-8
‘‘‘
    优先级记忆口诀表：
函数寻址下标一；
幂运算小二小嘻嘻；
全体单元第三位； # 比如翻转运算~，正负号等。单位运算符，就是一个操作对象的运算符
乘除求余四千里；
乘除完了五加减；
六娃玩耍左右移；
七是按位或跟与； # 同时包括异或
八仙生气要比敌； # 比较运算符
倒数第一逻辑或非与；
lambda表达式在刚开始的时候很少遇到，遇到的时候很容易将其放到最低优先级，所以这里为了记忆方便，将常见的逻辑或非与放到最后即可
 * @dec:运算符与表达式演示
 * @author: samy(hongfeiliuxing@gmail.com)
 * @datetime: 2015-05-23  14:31
‘‘‘
print "=============+:两个数字相加================"
a = 7 + 8
print a
print "=============-:取一个数字的相反或者实现两个数字相减================"
a = -7
print a
b = -(-8)
print b
c = 19 - 1
print c
print "=============*:两个数相乘或者字符串重复================"
a = 4*7
print a
b = "samy\t"*7
print b
print "=============*:两个数字相除================"
a = 7/2
print a
b = 7.0/2
print b
c = 7/2.0
print c
print "=============**:求幂运算================"
# 相当于2的3次幂，就是2*2*2
a = 2**3
print a
print "=============<:小于符号，返回一个bool值================"
a = 3 < 7
print a
b = 3 < 3
print b
print "=============<:大于符号，返回一个bool值================"
a = 3 > 7
print a
b = 3 > 3
print b
print "=============!=:不等于符号，返回一个bool值================"
a = 2 != 3
print a
b = 2 != 2
print b
print "=============//:除法运算，然后返回其商的整数部分，舍掉余数================"
a = 10 // 3
print a
print "=============%:除法运算，然后返回其商的余数部分，舍掉商跟//相反================"
a = 10 % 3
print a
# 没有余数的时候返回什么0
b = 10 % 1
print b
a = 10 // 3  # a为商的整数部分
b = 10 % 3  # b为商的余数部分
c = 3*a + b
print c
print "========&：按位与运算，所谓的按位与就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算========="
‘‘‘
7    00000111
18   00010010按位进行与运算，
结果:00000010,然后我们将00000010转化为十进制得到2
‘‘‘
a = 7 & 18  # 执行一下；为什么7跟18会得到2呢；
print a
print "========|：按位或运算，所谓的按位或就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算========="
‘‘‘
7    00000111
18   00010010按位进行与运算，
结果:00010011,然后我们将00010011转化为十进制得到23
‘‘‘
a = 7 | 18
print a
print "========^：按位异或运算（不同则为1，相同则为0），所谓的按位异或就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算========="
‘‘‘
7    00000111
18   00010010按位进行与运算，
结果:00010001,然后我们将00010011转化为十进制得到21
‘‘‘
a = 7 ^ 18
print a
print "========~：按位翻转运算（~x=-(x+1)）========="
# ~18 = -(18+1) = -19
a = ~18
print a
print "===============<<:左移====================="
‘‘‘
比如18左移就是将他的二进制形式00010010左移，即移后成为00100100,即成为36,左移动2个单位相当于乘以4,左移动3个单位相当于乘以8,左移动n个单位相当于乘以2的n次幂,
‘‘‘
a = 18 << 1  # 36
print a
b = 3 << 3  # 24
print b
print "===============>>:右移====================="
‘‘‘
比如18右移就是将他的二进制形式00010010右移，即移后成为00100100,即成为36,右移动2个单位相当于乘以4,右移动3个单位相当于乘以8,右移动n个单位相当于除以2的n次幂,
‘‘‘
a = 18 >> 1  # 9
print a
b = 3 >> 3  # 0
print b
print "==========<=:小于或等于,返回一个bool值==========="
a = 3 <= 3
print a
b = 4 <= 3
print b
print "==========>=:大于或等于,返回一个bool值==========="
a = 3 >= 3
print a
b = 4 >= 3
print b
print "============:等于,返回一个bool值==========="
a = 3 == 3
print a
b = "samy" == "samy"
print b
print "============and:逻辑与==========="
‘‘‘
True and True 等于 True
True and False 等于 False
False and True 等于 False
‘‘‘
a = True and True
print a
print "============or:逻辑或==========="
‘‘‘
True and True 等于 True
True and False 等于 True
False and False 等于 False
‘‘‘
a = True and False
print a
print "============not:逻辑非==========="
a = True
b = not a
print b
c = False
print not c

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
输入输出演示部分
接收用户的输入： input()
输出格式：str(),format
input：会根据用户的输入来做类型的转换
raw_input：则会把用户的输入都作为一个字符串来处理
@author: samy
‘‘‘
str_1 = input("enter a string:")
str_2 = input("enter another string:")
print("str_1 is :" + str_1 + " str_2 is :" +str_2)
print("str_1 is :{} str_2 is :{}".format(str_1, str_2))
print ("abc" )#打印abc并换行
print ("abc%s" % "d")#打印abcd
print("abc%s --> %s" % ("d", "g"))#打印abcd --->g

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
控制流演示部分
　　1. if 语句
 　　2. while语句
    3.range语句(其实不属于控制流里面的东东)
 　　3. for 循环 for..in
 　　4. break语句
 　　终止循环语句，如果从for或while中终止，任何对应循环的else将不执行。
 　　5. continue语句
     continue语句用来调过当前循环的剩余语句，然后继续下一轮循环。
@author: samy
‘‘‘
print("=====================if 语句演示：note:please input 59===============")
number = 59
#这里要求的必须的int型，要不然就会报错 
guess = int(input("Enter on integer :"))
if guess == number:
    print("Bingo! you guessed it right.")
    print("(but you do not win any prizes)")
elif guess < number:
    print("No, the number is higher than that")
else:
    print("No, the number is lower than that")
print("Done")
print("===================== while语句演示===============")
guess_flag = False
while guess_flag == False:
    guess = int(input("Enter on integer :"))
    if guess == number:
        guess_flag = True
    elif guess < number:
        print("No, the number is higher than that")
    else:
        print("No, the number is lower than that")
print("Bingo! you guessed it right.")
print("(but you do not win any prizes)")
print("Done")
print("===================== range语句演示===============")
num_chances = 3
print("you have only 3 chances to guess!")
for i in range(1,num_chances +1):
    print("chance "+ str(i))
    guess = int(input("Enter on integer :"))
    if guess == number:
        print("Bingo! you guessed it right.")
        print("(but you do not win any prizes)")
        break
    elif guess < number:
        print("No, the number is higher than that, keep guessing, you have "+ str(num_chances-i)+" chances left")
    else:
        print("No, the number is lower than that, keep guessing, you have "+ str(num_chances-i)+" chances left")
print("Done")
print("=====================for 循环 for..in演示===============")
# 当for循环结束后执行else语句；
#  range(a, b)返回一个序列，从a开始到b为止，但不包括b，
# range默认步长为1，可以指定步长，range(0,10,2)；
for i in range(1,10):
    print(i)
else:
#     pass
    print("the for loop is over")
    
print("=====================for循环遍历list,tuple,dict===============")
a_list = [1,3,5,7,9]
for i in a_list:
    print(i)
    
a_tuple = (1,3,5,7,9)
for i in a_tuple:
    print(i)
    
a_dict = {"Samy":"1111","Tom":"4444","Jenny":"3333"}
for i in a_dict:
    print(i)
    print(a_dict[i])
for key in a_dict.keys(): #　keys()　　---返回一个包含字典中所有键的列表
    print (key)    
for value in a_dict.values():#values()　　---返回一个包含字典中所有值的列表
    print (value)
for key ,vale in a_dict.items():
    print(key,vale)
print("=====================break语句和 continue语句演示===============")
while True:
# while guess_flag == False:
    guess = int(input("Enter on integer :"))
    if guess == number:
#         guess_flag = True
        break
    elif guess < number:
        print("No, the number is higher than that")
        continue
    else:
        print("No, the number is lower than that")
        continue
print("Bingo! you guessed it right.")
print("(but you do not win any prizes)")
print("Done")
# Python continue 语句跳出本次循环，而break跳出整个循环。
# continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
# continue 语句用在while和for循环中。
# Python pass是空语句，是为了保持程序结构的完整性。
print("=====================continue语句和pass 语言的不同演示===============")
a_list2 = [0,1,4]
print("using continue:")
for i in a_list2:
    if not i:#
        continue
    print(i)
    
print("using pass:")
for i in a_list2:
    if not i:
       pass
    print(i)
# using continue:
# 1
# 4
# using pass:
# 0
# 1
# 4
for letter in ‘Python‘: 
   if letter == ‘h‘:
      pass
      print (‘This is pass block‘)
   print (‘Current Letter :‘, letter)
print ("Good bye!")

#全局变量与局部变量
print("====================全局变量与局部变量==============")
x =60
def foo(x):
    print("x is : "+str(x))#60
    x = 3
    print("change local x to : "+str(x))#3
foo(x)
print("x is still: "+str(x))#60
y =60
def foo2():
    global y #　global语句， 为定义在函数外的变量赋值时使用global语句。
    print("y is : "+str(y))#60
    y = 3
    print("change local y to : "+str(y))#3
foo2()
print("y is still: "+str(y))#3

#有默认参数，返回值
print("====================有默认参数，返回值==============")
def repeat_str1(str,times = 1):
    repeated_strs = str*times
    return repeated_strs
repeated_strs = repeat_str1("samy haha! ")  
print(repeated_strs)
repeated_strs = repeat_str1("samy haha! ",3)  
print(repeated_strs)

#关键字参数：调用函数时，选择性的传入部分参数
#不能在有默认参数后面跟没有默认参数
#f(a ,b =2) 合法
#f(a = 2 ,b) 不合法
print("====================关键字参数：调用函数时，选择性的传入部分参数=============")
def func2(a, b=4,c=8):
    print("a is ",a, "and b is", b, "and c is ", c)
func2(13, 17)
func2(125, c= 24)
func2(c = 40, a = 80)

#DocStrings (文档字符串)
print("============DocStrings (文档字符串)=========")
def func():
    ‘‘‘This is self-defined function
Do nothing‘‘‘
    pass
print (func.__doc__)

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-3
列表List演示部分
List
    创建
    访问
    更新
    删除
    脚本操作符
    函数方法
@author: samy
‘‘‘
from filecmp import cmp
‘‘‘
创建List
‘‘‘
print("======================创建List======================")
number_list = [1, 3, 5, 7, 10]
print("number_list: " + str(number_list))
# 注意这里用print打印时里面有字符串时，其他字符串都得转换成String型：str(***)
string_list = ["abc", "python", "java"]
print("string_list: " + str(string_list))
mixed_list = [1, 3, 5, "abc", "python", "java"]
print("mixed_list: " + str(mixed_list))
‘‘‘
访问List中元素数据
‘‘‘
print("======================访问List中元素数据======================")
second_num = number_list[1]
third_string = string_list[2]
fourth_mixed = mixed_list[3]
print("second_num:{0}; third_string:{1};  fourth_mixed:{2};".format(second_num, third_string, fourth_mixed))
‘‘‘
更新List中元素数据
‘‘‘
print("======================更新List中元素数据======================")
print("number_list before" + str(number_list))
number_list[1] = 50
print("number_list after" + str(number_list))
‘‘‘
删除List中元素数据
‘‘‘
print("======================删除List中元素数据======================")
print("number_list before" + str(number_list))
del number_list[0]
print("number_list after" + str(number_list))
‘‘‘
Python脚本语言
‘‘‘
print("======================Python脚本语言======================")
print("长度:", str(len([1, 2, 3])))
print("组合:" + str([1, 2, 3] + [4, 5, 8]))
print("重复:" + str(["Samy" * 4]))
print("某个元素在列表中:" + str(3 in[1, 2, 3]))
‘‘‘
列表的截取
‘‘‘
print("======================列表的截取======================")
abcd_list = ["a", "b", "c", "d"]
print(abcd_list[2])
print(abcd_list[2:])  # 输出数组中位置2以后的元素,返回的是一个数组
print(abcd_list[-2])  # 注意这里从倒序取数据
‘‘‘
列表操作包含以下函数
‘‘‘
print("======================列表操作包含以下函数======================")
# number1 = 23
# number2 = 23
# print(cmp(number1,number2))#比较两个列表的元素
# print(list(seq))#将元组转换成列表
print(max(number_list))
print(min(number_list))
print(number_list.append(133))  # 在列表末尾添加新的对象
print(number_list)
print(number_list.count(7))  # 统计某个元素在列表中出现的次数
number_list2 = [13,24]
number_list.extend(number_list2)  # 在列表末尾一次性追加一个序列中的多个值（用新列表扩展原来的列表）
print(number_list)
number_list.index(7) # 　index(value, [start, [stop]])　　---返回列表中第一个出现的值为value的索引，如果没有，则异常 ValueError
# number_list.index(0,100) # 　insert(i, value)向列表i位置插入项vlaue，如果没有i，则添加到列表尾部
print(number_list)
number_list.insert(0, "samy")  # 将对象插入列表
print(number_list)
number_list.remove(10) # 移除列表中某个值得第一个匹配项
print(number_list)
number_list.reverse()  # 反向列表中元素列表反转
print(number_list)
# 　pop([i])--返回i位置项，并从列表中删除；如果不提供参数，则删除最后一个项；如果提供，但是i超出索引范围，则异常IndexError
l = [0, 1, 2, 3, 4, 5]
print (l.pop())# 5
print (l.pop(1)) #1
# try:
#     l.pop(100)
# except IndexError, ie:
#     print ("index out of range")
# print(number_list.sort(key=None, reverse=True))  # 对原列表进行排序
l5 = [10, 5, 20, 1, 30]
l5.sort()
print (l5) #[1, 5, 10, 20, 30]
l6 = ["bcd", "abc", "cde", "bbb"]
# l6.sort(cmp = lambda s1, s2: cmp(s1[0],s2[1]))//cmp这个还有点问题
print (l6) #[‘abc‘, ‘bbb‘, ‘bcd‘, ‘cde‘]
l7 = ["bcd", "abc", "cde", "bbb", "faf"]
l7.sort(key = lambda s: s[1])
print (l7) #[‘faf‘, ‘abc‘, ‘bbb‘, ‘bcd‘, ‘cde‘]

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-5
字典演示部分
Dict
    创建
    访问
    更新
    删除
    脚本操作符
    函数方法
@author: samy
‘‘‘
‘‘‘
创建Dict
‘‘‘
print("======================创建Dict======================")
phone_book = {"Tom":123,"samy":455,"hong":788}
mixed_dict = {"Tom":"samy",23:23.55}
del_test = {}
del_test["1"] = "one"
del_test["2"] = "two"
del_test["3"] = "three"
‘‘‘
访问Dict中元素数据
‘‘‘
print("======================访问Dict中元素数据======================")
print("samy has number: " + str(phone_book["samy"]))
print("mixed_dict: " + str(mixed_dict))
for key, value in del_test.items():
    print("%s --> %s" % (key, value))
    
d6 = {1:"one", 2:"two", 3:"three"}#　has_key(key)　　---判断字典中是否有键key
# print (d6.has_key(1))  #True 好像3.0以上版本没有这个属性；AttributeError: ‘dict‘ object has no attribute ‘has_key‘
# print (d6.has_key(5))  #False
d7 = {1:"one", 2:"two", 3:"three"}
for item in d7.items(): #items()　　---返回一个包含字典中(键, 值)对元组的列表
    #打印默认键值对格式
    print(item)
    
for key, value in d7.items():
    #打印自己想要的格式
    print ("%s -- %s" % (key, value))
d8 = {1:"one", 2:"two", 3:"three"}
for key in d8.keys(): #　keys()　　---返回一个包含字典中所有键的列表
    print (key)    
for value in d8.values():#values()　　---返回一个包含字典中所有值的列表
    print (value)
‘‘‘
更新Dict中元素数据
‘‘‘
print("======================更新Dict中元素数据======================")
#添加数据
phone_book["Heath"] = "Health"
print("the added book is: " + str(phone_book))
#修改数据
phone_book["samy"] = 999
print("samy has number: " + str(phone_book["samy"]))
‘‘‘
删除Dict中元素数据
‘‘‘
print("======================删除Dict中元素数据======================")
del phone_book["Tom"]
print("the phone_book after del is: " + str(phone_book))
phone_book.clear()#删除字典中所有元素
print("the phone_book after del is: " + str(phone_book))
del phone_book #其后面注释掉，为了后面程序运行，表示这个Dict全部清空
# print("the phone_book after del all is: " + str(phone_book))#表示已经删除后，后面肯定查看不到数据；NameError: name ‘phone_book‘ is not defined
del del_test["3"]
# 遍历Dict map的键值对；
for key, value in del_test.items():
    print("%s --> %s" % (key, value))
    
‘‘‘
Dict的特性
‘‘‘
print("======================Dict的特性======================")
# 不允许同一个值出现多次；后面的数据会把前面的数据冲突掉
rep_test = {"name":"samy","age":5,"name":"samy33"}
print("rep_test: " +str(rep_test))
#键必须不可变，所以可以用书，字符串或者元组充当，列表list不可以；
# list_dict= {["Name"]:"samy","Age":23}#TypeError: unhashable type: ‘list‘
list_dict= {("Name"):"samy","Age":23}
‘‘‘
字典内置函数&方法
‘‘‘
# Python字典包含了以下内置函数：
#　pop(key, [default])　　---若字典中key键存在，删除并返回dict[key]，若不存在，且未给出default值，引发KeyError异常
d9 = {1:"one", 2:"two", 3:"three"}
print (d9.pop(1)) #one
print (d9) #{2: ‘two‘, 3: ‘three‘}
print (d9.pop(5, None)) #None
# try:
#    print(d9.pop(5))  # raise KeyError
# except KeyError, ke:
#     print  "KeyError:", ke #KeyError:5
#popitem()　　---删除任意键值对，并返回该键值对，如果字典为空，则产生异常KeyError
d10 = {1:"one", 2:"two", 3:"three"}
print (d10.popitem())  #(1, ‘one‘)
print (d10)  #{2: ‘two‘, 3: ‘three‘}
#setdefault(key,[default])　　---若字典中有key，则返回vlaue值，若没有key，则加上该key，值为default，默认None
d = {1:"one", 2:"two", 3:"three"}
print (d.setdefault(1))  #one
print (d.setdefault(5))  #None
print (d)  #{1: ‘one‘, 2: ‘two‘, 3: ‘three‘, 5: None}
print (d.setdefault(6, "six")) #six
print (d)  #{1: ‘one‘, 2: ‘two‘, 3: ‘three‘, 5: None, 6: ‘six‘}
#update(dict2)　　---把dict2的元素加入到dict中去，键字重复时会覆盖dict中的键值
d = {1:"one", 2:"two", 3:"three"}
d2 = {1:"first", 4:"forth"}
d.update(d2)
print (d)  #{1: ‘first‘, 2: ‘two‘, 3: ‘three‘, 4: ‘forth‘}
# 　viewitems()　　---返回一个view对象，（key, value）pair的列表，类似于视图。
# 优点是，如果字典发生变化，view会同步发生变化。在迭代过程中，字典不允许改变，否则会报异常
d = {1:"one", 2:"two", 3:"three"}
# for key, value in d.viewitems():#这儿在高版本3有点问题；AttributeError: ‘dict‘ object has no attribute ‘viewitems‘
#     print ("%s - %s" % (key, value))
#viewkeys()　　---返回一个view对象，key的列表    
# for key in d.viewkeys():
#     print (key) #这儿在高版本3有点问题； AttributeError: ‘dict‘ object has no attribute ‘viewkeys‘
#viewvalues()　　---返回一个view对象，value的列表
# for value in d.viewvalues():
#     print (value) #这儿在高版本3有点问题； AttributeError: ‘dict‘ object has no attribute ‘viewvalues‘
‘‘‘
序列部分演示
　序列类型是指容器内的元素从0开始的索引顺序访问，一次可以访问一个或者多个元素；列表、元组和字符串都是序列；序列的两个主要特点是
　索引操作符和切片操作符；索引可以得到特定元素；切片可以得到部分序列；
　切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。 如果不指定第一个数，Python就从
　　序列首开始。如果没有指定第二个数，则Python会停止在序列尾。 注意，返回的序列从开始位置 开始 ，刚好在结束位置之前 结束。即开始位置是
　　包含在序列切片中的，而结束位置被排斥在切片外。 可以用负数做切片。负数用在从序列尾开始计算的位置。
‘‘‘
print("======================序列部分演示======================")
numbers = ["zero", "one", "two", "three", "four"]
print (numbers[1]) # one
print (numbers[-1]) # four
#print numbers[5] # raise IndexError
print (numbers[:]) # [‘zero‘, ‘one‘, ‘two‘, ‘three‘, ‘four‘]
print (numbers[3:]) # [‘three‘, ‘four‘]
print (numbers[:2]) # [‘zero‘, ‘one‘]
print (numbers[2:4]) # [‘two‘, ‘three‘]
print (numbers[1:-1]) # [‘one‘, ‘two‘, ‘three‘]
‘‘‘
字典中其他的内置方法
‘‘‘
print("======================字典中其他的内置方法=====================")
dict = {"name":"samy","age":5,"name":"samy33"}
# cmp(dict1,dict2)#比较两个字典元素
print (len(dict))#计算字典元素格式，即键的总数
print (type(dict))
print (dict.copy())#返回一个字典的浅复制
# dict.fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值；
# dict.has_key("1")
‘‘‘
绑定
　　当创建一个对象并给它赋一个变量的时候，这个变量仅仅“指向”那个对象，而不是表示这个对象本身！ 也就是说，变量名指向计算机中存储那个
　　对象的内存，这被称作名称到对象的绑定。
　　如果要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单对象），那么必须使用切片操作符来取得拷贝。
‘‘‘

‘‘‘
Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
函数	描述
int(x [,base])
将x转换为一个整数
long(x [,base] )
将x转换为一个长整数
float(x)
将x转换到一个浮点数
complex(real [,imag])
创建一个复数
str(x)
将对象 x 转换为字符串
repr(x)
将对象 x 转换为表达式字符串
eval(str)
用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)
将序列 s 转换为一个元组
list(s)
将序列 s 转换为一个列表
set(s)
转换为可变集合
dict(d)
创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)
转换为不可变集合
chr(x)
将一个整数转换为一个字符
unichr(x)
将一个整数转换为Unicode字符
ord(x)
将一个字符转换为它的整数值
hex(x)
将一个整数转换为一个十六进制字符串
oct(x)
将一个整数转换为一个八进制字符串
‘‘‘

# coding=utf-8
‘‘‘
 * @dec:集合的演示；
集合主要有两大功能：
1：建立关系；
2：消除重复元素
 * @author: samy(hongfeiliuxing@gmail.com) 
 * @datetime: 2015-05-23  10:34
‘‘‘  
a = set("abcddmedddsamy")
b = set("cdddzhan")
# lista = {"samy", "jenny", "zhang"} #这个设置显示的set集合；而不是字典；
# 交集
print "a&b交集: "+str(a & b)
print "a|b并集: "+str(a | b)
print "a-b差集: "+str(a - b)
print "ab集合去除重复元素"+str(set(a))

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
面向对象类（Class）和装饰器（Decorator）部分
__init__方法　　在类的一个对象被创建时调用该方法；相当于c++中的构造函数。
__del__方法　　在类的对象被销毁时调用该方法；相当于c++中的析构函数。在使用del删除一个对象时也就调用__del__方法。
Python中所有的类成员(包括数据成员)都是public的；只有一个例外，如果使用的数据成员以双下划线为前缀，则为私有变量。
@author: samy
‘‘‘
print("====================类配置基本配置用法================")
class Student1:
    def __init__(self, name, gradle):
        self.name = name
        self.gradle = gradle
    def instroduce(self):
        print("hi! I‘m " + str(self.name))
        print("my grade is: " + str(self.gradle))
    def improve(self, amount):
        self.gradle = self.gradle + amount
samy = Student1("samy", 28)
samy.instroduce()
samy.improve(10)
samy.instroduce()
print("====================属性配置================")
class Person:
    Count = 0
    def __init__(self, name, age):
        Person.Count += 1
        self.name = name
        self.__age = age  # __age表示age为Person私有属性
p = Person("samy", 25)
p1 = Person("jenny", 20)
print (Person.Count)  # 2
print (p.name)  # peter
# print (p.__age) #AttributeError: Person instance has no attribute ‘__age‘
print("=====================方法的配置巧妙用法===================")
def add_candles(cake_func):
    def insert_candles():
        return cake_func() + " candles"
    return insert_candles
# 方法一实现；
# def make_cake():
#     return "cake"
# gift_func = add_candles(make_cake)
# 方法二实现；（注意这里的使用配置说明）
@add_candles
def make_cake():
    return "cake"
# gift_func = add_candles(make_cake)
print(make_cake())
# print(gift_func())
print("===================继承：为了使用继承，基类的名称作为一个元组跟在类名称的后面；python支持多重继承。==================")
class SchoolMember:
    ‘‘‘Represent any school member.‘‘‘
    def __init__(self, name, age):
        self.name = name
        self.age = age
    print ("Initializing a school member.")
    
    def tell(self):
        ‘‘‘Tell my details‘‘‘
        print ("Name: %s, Age: %s, " % (self.name, self.age))
# 继承类
class Teacher(SchoolMember):
    ‘‘‘Represent a teacher.‘‘‘
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
    print ("Initializing a teacher")
 
    def tell(self):
         SchoolMember.tell(self)
         print ("Salary: %d" % self.salary)
 
class Student(SchoolMember):
    ‘‘‘Represent a student.‘‘‘
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print ("Initializing a student")
 
    def tell(self):
        SchoolMember.tell(self)
        print ("Marks: %d" % self.marks)
print (SchoolMember.__doc__)
print (Teacher.__doc__)
print (Student.__doc__)
t = Teacher("Mr. Li", 30, 9000)
s = Student("samy", 25, 90)
# 这里用法很好，借鉴下
members = [t, s]
 
for m in members:
     m.tell()
     
# 注意下这里的输出顺序
# Initializing a school member.
# Initializing a teacher
# Represent any school member.
# Represent a teacher.
# Represent a student.
# Initializing a student