python学习1

0.说明

学习网址：http://www.runoob.com/python/python-operators.html
github地址：https://github.com/Eyrane/python

若运行的时候出现如下错误：
bash: ./test: /usr/bin/python^M: 解释器错误: 没有那个文件或目录 //文件编辑格式出错
vim filename
:set ff
:set ff=unix

1.基础语法和变量类型

#!/usr/bin/python
# -*- coding: UTF-8 -*-

print "hello";
print "你好";

# “#”为注释

# 标识符由字母、数字、下划线组成，不能以数字开头，区分大小写

# 用缩进表示模块，而不是{}
if 1:
    print "Ture1"
    print "Ture2"  #严格按照缩进
else:
    print "false1"
    print "false2"


#使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串,三引号可以由多行组成
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""    
print word,sentence,paragraph  # 不换行输出
print word
print sentence
print paragraph


#Python 中的变量赋值不需要类型声明
x = 100
y = 100.1

total = x + \
        y  #用\将一行语句分为多行
print total

#多个变量赋值
a ,b ,c = 1, 2.1, 'join'
print a,b,c

#字符串
print "************字符串"
print c[1:3] #输出字符串中第2个到第5个之间的字符串
print c * 2  #字符串输出两次
print c + "test" #输出连接的字符串

#列表[]. 支持字符，数字，字符串甚至可以包含列表（即嵌套）.
print "************列表"
list = ['runoob', 1, 2.1, 'join', 40.2]
tinylist = [123, 'join']
print list
print list[0]
print list[1:3]
print list [2:]
print tinylist * 2
print list + tinylist
list[0] = 111
print list

#元组（类似list），不能二次赋值，相当于只读list
print "************元组"
tuple = ('runoob', 1, 2.1, 'join', 40.2)
tinytuple = (123, 'join')
print tuple
print tuple + tinytuple

#字典{},由索引(key)和它对应的值value组成,是无序的对象集合。
print "************字典"
dict = {}
dict['one'] = 'this is one'
dict[2] = 'this is two'
tinydict = {'name':'join', 'code':'22', 'dept':'sales'}
print dict
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

2.运算符、条件语句、循环语句

#!/usr/bin/python
# -*- coding: UTF-8 -*-

print "************算术运算符"
#**幂 - 返回x的y次幂   //取整除 - 返回商的整数部分
a = 21; b = 10; c = 1
print "a+b:",a+b, "a-b:",a-b, "a*b:",a*b ,"a/b:",a/b, "a%b:",a%b, "float a/b:",float(a)/float(b), "(0.0+a)/(0.0+b):",(0.0+a)/(0.0+b) 


print "************比较运算符"
#<>相当于!=
print "a==b:",a==b, "a!=b:",a!=b, "a<>b:",a<>b, "a>b:",a>b, "a,a"a>=b:",a>=b, "a<=b:",a<=b 


print "************赋值运算符"
#不能 print "a+=b:",a+=b //因为 a=a+b 是一个语句，不能作为一个变量输出
# += -= *= /=   **=  //=
a+=b; b-=c;
print "a+=b:",a, "b-=c:",b


print "************位运算符"
# ^异或：不同为1  
a = 60 #0011 1100
b = 13 #0000 1101
print "a&b=",a&b, "a|b=",a|b, "a^b=",a^b, "~a=",~a, "a<<2=",a<<2, "a>>2=",a>>2


print "************逻辑运算符"
# and or not
print "a and b:", a and b, "a or b:", a or b, "not a:", not a
a=0
print "a=0 a and b:", a and b, "a or b:", a or b, "not a:", not a

print "************成员运算符"
# in:在指定序列中找到值返回true； not in:与in相反
list = [1, 2, 3, 4, 5]
print "a=",a, "a in list:",a in list, "a not in list:",a not in list
a=1
print "a=",a, "a in list:",a in list, "a not in list:",a not in list

print "************身份运算符"
# is：判断两个标识符是否引用自同一个对象   is not
# x is y 类似 id(x)==id(y)       x is not y 类似 id(x)!=id(y)
a = 10; b = 10 #交互模式下，如果变量写在同一行,将会指向同一个对象，脚本模式是否写在一行，都指向同一个对象
print "a=",a, "b=",b, "a is b",a is b, "a is not b",a is not b
b = 20
print "a=",a, "b=",b, "a is b",a is b, "a is not b",a is not b


#优先级：**  >  ~  >  */% //  >  +-  >  &  >  ^|  >  比较运算符  >  <>==!=  >  赋值运算符 > 身份运算符 > 成员运算符 > 逻辑运算符


print "############条件语句"
#   if 条件1:
#       语句1
#   elif 条件2:
#       语句2
#   elif 条件3:
#       语句3
#   else:
#       语句4
# python 并不支持 switch 语句
n = 15
if n >= 0 and n <= 10:
    print "0<=n<=10"
elif n < 0:
    print "n<0"
elif n > 10:
    print "n>10"
else:
    print "wrong"



print "############循环语句"
# while for 嵌套；  break continue pass(空语句）
print "############while"
i = 1
while i < 10:
    i += 1
    if i % 2 > 0:
        continue  #跳过本次循环
    if i > 8:
        break   #退出循环
    print i
else:
    print i
print "############for"
for j in range(1,9):
    if j % 2 > 0:
        continue
    if j > 8:
        break
    print j
else:
    print j

3.列表、元组和字典

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#  len()返回对象（字符、列表、元组等）长度或项目个数
#  pop()移除列表中最后一个元素，并返回该元素的值
#  append()在列表尾部添加新对象。。以上均为内置函数

#  del为内置关键字（如import、return等），删除一个对象（list、变量、类的实例等）


print "##############列表"   # []
list1 = ['physic', 'chemistry', 1992, 2000]
list2 = [1, 2, 3, 4, 5, 6]

a = list1.pop();
list2.append(a)
print list1
print list2
print list2[-2]

del list2[2]
print list2
print 'len(list1+list2)=',len(list1+list2)

print 'list2  max=',max(list2), 'min=',min(list2), 'cmp(list1,list2)=',cmp(list1,list2)
print '\n'
print "list1=",list1
print "list2=",list2
print list1+list2
print list1 * 2
print 2 in list2
for x in list1:
    print x

    print '\n'  
print list1.count(2)  #count()：统计某个元素在list中出现的次数
list1.extend(list2)  #extend():在列表末尾一次性追加另一个序列中的多个值
print "list1=",list1   
print list2.index(2000)  #index():在列表中找出某个值第一个匹配项的索引位置

list1.insert(2,'hello')  #insert():将对象插入列表中
print list1

list1.remove(1992)  #remove():移除列表中某个值的第一个匹配项
print list1

list2.reverse()   #reverse():反向列表中的元素
print list2

list2.sort()  #sort():对列表进行从小到大排序
print list2

print '\n\n\n'
print "##############元组"  # () 与列表类似，但值不可改
print ('all'),('all',)  #如果元组只有1个元素，就必须加一个逗号，防止被当作括号运算
print tuple(list1)  #tuple():将列表转换为元组
print list( tuple(list1) )  #list():将元组转换为列表



print '\n\n\n'
print "##############字典"  #{key1 : value1, key2 : value2 , ...}  key必须不同，且不可变（所以list不能做key）
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8   #修改字典
dict['School'] = 'DPS School'  #增加对象
print dict

test1 = dict.pop('School')  # pop():删除字典给定键 key 所对应的值，返回值为被删除的value
print 'pop:',test1,dict

test2 = dict.popitem() #popitem():随机返回并删除字典中的一对键和值
print 'popitem:',test2,dict

print len(dict)
print str(dict)   #输出字典可打印的字符串表示
print type(dict)  #返回输入的变量类型，如果变量是字典就返回字典类型

del dict['Name']  #删除对象
print dict
dict.clear()   #情况字典
print dict
del dict   #删除字典

dict1 = {'user':'runoob','num':[1,2,3]}
dict2 = dict1  # 浅拷贝: 引用对象
dict3 = dict1.copy()  # 深拷贝：不会随dict1 修改而修改

dict1['user']='root'
dict1['num'].remove(1)  #修改dict1的值

print 'dict1=',dict1, 'dict2=',dict2, 'dict3=',dict3

for a,b in dict1.items():   #items():以列表返回可遍历的(键, 值) 元组数组
    print a,b

print dict1.keys()  #keys():以列表返回一个字典所有的键

dict3 = {'Name': 'Zara', 'Age': 7}
dict1.update(dict3)  #update():把字典dict3的键/值对更新到dict里。
print dict1

4.时间和日期

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#  time和calendar模块  用于处理日期和时间
print '***********time模块'
import time  #引入time模块
print time.time() #当前时间戳
print time.localtime( time.time() )  #获取当前时间
print time.asctime( time.localtime( time.time() ) )  #获取格式化的时间

print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) #格式化日期
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) 
a = "Sat Mar 28 22:24:24 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))  # 将格式字符串转换为时间戳

'''
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
'''

print '\n *************calendar模块'
import calendar
print calendar.month(2018,2)


print '\n *************datetime模块'
import datetime
i = datetime.datetime.now()
print ("当前的日期和时间是 %s" % i)
print ("ISO格式的日期和时间是 %s" % i.isoformat() )
print ("当前的年份是 %s" %i.year)
print ("当前的月份是 %s" %i.month)
print ("当前的日期是  %s" %i.day)
print ("dd/mm/yyyy 格式是  %s/%s/%s" % (i.day, i.month, i.year) )
print ("当前小时是 %s" %i.hour)
print ("当前分钟是 %s" %i.minute)
print ("当前秒是  %s" %i.second)

5.函数

#!/usr/bin/python
# -*- coding: UTF-8 -*-

print '***********函数'
'''
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]
'''
def printme( str ):
    "print on the screen"
    print str
    return
printme('hello')
printme('你好')

'''
类型属于对象，变量是没有类型的。strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
'''

def chang( a ):
    'test parameters change or not'
    print 'before chang a=',a
    a = 10
    print 'after chang a=',a

def changlist( a ):
    'test parameters change or not'
    print 'before chang a=',a
    a.append([1,2,3,4])
    print 'after chang a=',a
    return
b = 2
chang(b)
print b  #numbers,strings, tuples做参数时，不影响实参
c = [10, 20 ,30]
chang(c[1]) #相当于实参为int，不影响实参
print c
changlist(c) #list,dict做参数时，影响实参
print c


#使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def printinfo( name, age ):
    '测试参数顺序'
    print 'name=',name, 'age=',age
    return

printinfo( age=50, name='lily' )



print '***********不定长参数'
'''
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]
'''
def print1( arg1, *vartuple ):  #第一个参数传给arg1，其他当作一个元组传给vartuple
    '打印任何长度的参数'
    print '输出：'
    print arg1
    print vartuple
    for var in vartuple:
        print var
    return
print1(10)
print1(70,60,50)
print1( (10,20,30) ,50,60 )
print1( (10,20,30) ,(50,60) )
print1( (10,20,30) ,(50,60), (70,80) )

print '***********匿名参数'
#lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda arg1,arg2: arg1+arg2
print sum(10,20)

def chang2( a ):
    'test return'
    print 'before chang a=',a
    a = 10
    print 'after chang a=',a
    return a
b = 2
b = chang2(b)
print b

6.自定义的模块并调用

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import test6

print test6.add(2,3)
print test6.printadd([4,5])

#!/usr/bin/python
# -*- coding: UTF-8 -*-

'''
内置模块、自定义模块、第三方模块
'''
#本文件自定义一个模块test6，该模块必须以.py为文件名，调用模块时要import test6


'module test' #任何模块代码的第一个字符串都被视为模块的文档注释
_author_ = 'Eyrane'  #_author_声明作者

#以下为模块的代码
import sys
def test():
    args = sys.argv
    if len(args)==1:
        print 'Hello, world!'
    elif len(args)==2:
        print 'Hello, %s!' % args[1]
    else:
        print 'Too many arguments!'

def add(a, b):
    return a+b


#在命令行运行本模块文件时，Python解释器把一个特殊变量__name__置为__main__，
#而如果在其他地方导入该模块时，if判断将失败
#即直接运行本文件时，if成立；把本文件当中模块使用时，if不成立
if __name__=='__main__':  
    test()
    print add(2,3)

def printadd( a ):
    a+=[1,2,3]
    return a

7.控制台io和文件io

#!/usr/bin/python
# -*- coding: UTF-8 -*-

print '*************控制台IO'
str = raw_input("please input:") # raw_input():从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
print 'you input is:',str

str = input("please input:") #input():所有输入为字符串，返回字符串类型 （如：输入'hello',返回hello）
print 'you input is:',str

'''
raw_input():把所有输入当成字符串，如输入1+2，返回1+2
input():可以输入表达式，如输入1+2，返回3
'''

print '\n*************文件IO'
fp = open( "readme.txt","r" ) #打开文件
print '文件名：',fp.name, '是否关闭：',fp.closed, '访问模式：',fp.mode, '末尾是否强制加空格：',fp.softspace

str = fp.read(10) #若可写的模式下，fp.write('hello') 写入文件
print str
print fp.tell() # 查找当前位置

fp.seek(0,1) 
#seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
#如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

print fp.read(10)

print fp.next() #返回文件的下一行

fp.seek(0,0) 
print fp.readline() #从文件读取整行，包括 "\n" 字符。如果指定了一个非负数的参数，则返回该行中指定大小的字节数

for line in fp.readlines(): #用于读取所有的行，常用于for...in...结构
    line = line.strip() #strip() 方法用于移除字符串头尾指定的字符（默认为空格）
    print line

fp.close() #关闭文件

'''
os.rename(current_file_name, new_file_name) 重命名
os.remove(file_name)  删除文件
'''

8.异常处理

#!/usr/bin/python
# -*- coding: UTF-8 -*-

'''
try:
    <语句>        #运行别的代码
except ：
    <语句>        #如果在try部份引发了'name'异常
except ，<数据>:
    <语句>        #如果引发了'name'异常，获得附加的数据
else:
    <语句>        #如果没有异常发生


try:
    <语句>
finally:
    <语句>    #退出try时总会执行
raise
'''
try:
    1 / 0
except Exception as e:
    '''异常的父类，可以捕获所有的异常'''
    print "0不能被除"
else:
    '''保护不抛出异常的代码'''
    print "没有异常"
finally:
    print "最后总是要执行我"


try:
    fh = open("testfile", "r")  
    try:
        fh.write("这是一个测试文件，用于测试异常!!")
    finally:
        print "关闭文件"
        fh.close()
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()
'''
若testfile存在时：
 当文件是"r"时，出现异常，结果为：关闭文件   Error: 没有找到文件或读取文件失败  
 当文件是"w"时，没有出现异常，结果为：关闭文件   内容写入文件成功 
综上：try和finally的语句都会运行，excpet对应异常才会运行，else没有异常运行

若testfile不存在时：
当文件是"r"时，出现异常，结果为：Error: 没有找到文件或读取文件失败  //不会运行try  finally部分
'''


def temp_convert(var):
    try:
        return int(var)
    except ValueError, Argument: #一个异常可以带上参数，可作为输出的异常信息参数
        print "参数没有包含数字\n", ValueError, Argument

temp_convert("xyz");


'''
一个异常可以是一个字符串，类或对象,我们可以使用raise语句自己触发异常
raise [Exception [, args [, traceback]]]   
''' 
#过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类。
class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg
try:
    raise Networkerror("Bad hostname")
except Networkerror,e:
    print e.args

9.类

#!/usr/bin/python
# -*- coding: UTF-8 -*-

'''
类：用来描述具有相同的属性和方法的对象的集合，类包括了类变量和方法（函数）
class ClassName:
   '类的帮助信息'   #类说明文档字符串
   class_suite  #类体
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self
'''
class Employee:
   '所有员工的基类'
   empCount = 0 #类变量,它的值将在这个类的所有实例之间共享

   def __init__(self, name, salary):  #构造函数，当创建了这个类的实例时就会调用该方法
      self.name = name     #self代表类的实例,self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "销毁"

emp1 = Employee("Zara", 2000)  #"创建 Employee 类的对象
emp2 = Employee("Manni", 5000)
emp1.displayEmployee() #访问对象的属性
emp2.displayEmployee()
emp1.displayCount()
emp2.displayCount()
print "Total Employee %d" % Employee.empCount

emp1.age = 7  # 添加一个 'age' 属性
emp1.age = 8  # 修改 'age' 属性
del emp1.age  # 删除 'age' 属性

setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
print hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
print getattr(emp1, 'age')    # 返回 'age' 属性的值
delattr(emp1, 'age')    # 删除属性 'age'



'''
内置类属性
__dict__ : 类的属性（包含一个字典，由类的数据属性组成） 
__doc__ :类的文档字符串 
__name__: 类名 
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod） 
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组） 
'''
print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__


print '*************删除对象'
'''
当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时
a = 40      # 创建对象  <40>
b = a       # 增加引用， <40> 的计数
c = [b]     # 增加引用.  <40> 的计数

del a       # 减少引用 <40> 的计数
b = 100     # 减少引用 <40> 的计数
c[0] = -1   # 减少引用 <40> 的计数
'''
emp3 = emp1
print id(emp1), id(emp2), id(emp3) # 打印对象的id ,emp3和emp1相同
del emp1
print '1111111'
del emp2
print '2222222'
del emp3     #删除所有引用时，会自动调用析构函数
print '3333333'



print '\n*************类的继承'
'''
class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。
'''
class Parent1:
    parentAttr = 100    # 公开变量
    __privateAttr = 1000  # 私有变量,只能在本类中用函数调用，不能在本类的外部使用
    def __init__(self):
        print "调用父类1构造函数"
    def myMethod(self):
        print "调用父类1方法myMethod"
    def parentMethod(self):
        print "调用父类1方法"
    def setAtt(self, att):
        Parent1.parentAttr = att
    def setAtt1(self, att):
        self.parentAttr = att #self 代表类的实例
    def getAtt(self):
        print "父类1属性:",Parent1.parentAttr
    def getAtt1(self):
        print "父类1属性:",self.parentAttr
    def __del__(self):
        class_name = self.__class__.__name__
        print class_name, "销毁"

class Parent2:
    parentAttr = 200
    def __init__(self):
        print "调用父类2构造函数"
    def parentMethod(self):
        print "调用父类方法"
    def parent2Method(self):
        print "父类2的方法parent2Method"

class Child(Parent1, Parent2):#继承多个类，先找Parent1，若Parent1没有再找Parent2
    def __init__(self):  #若子类没有构造函数，会自动调用父类构造函数
        print "调用子类构造函数"
    def myMethod(self):
        print "方法重写，调用子类方法myMethod"
    def childMethod(self):
        print "调用子类方法"
    def __del__(self):#本文件所有代码执行完后，会自动调用
        class_name = self.__class__.__name__
        print class_name, "销毁"

c = Child()
c.myMethod()  #方法重写，子类的方法会覆盖父类的
c.childMethod()
c.parentMethod()  #子类会继承父类的所有属性和方法
c.parent2Method()
c.setAtt(200)
c.getAtt() 
c.getAtt1()
c.setAtt1(300)
c.getAtt() 
c.getAtt1()
print issubclass(Child,Parent1)  #issubclass(sub,sup) - 布尔函数判断一个类是另一个类的子类或者子孙类
print isinstance(c,Parent1)  #isinstance(obj, Class) 布尔函数判断obj是Class类的实例对象或者是一个Class子类的实例对象

'''
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
'''

'''
子类会继承父类的所有属性，若子类调用的函数在子类中存在，则直接调用子类的函数，若不存在，调用父类的函数
多继承，会先寻址最先继承的
public,protected,private
'''
print '\n*********私有和共有变量'
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print self.__secretCount
    def count2(self):
        print self.__secretCount

counter = JustCounter()
counter.count()
# 在类的对象生成后,调用含有类私有属性的函数时就可以使用到私有属性.
counter.count()
#第二次同样可以.
print 'publicCount=',counter.publicCount
print '__secretCount=', counter._JustCounter__secretCount  # 不改写报错，实例不能访问私有变量
try:
    counter.count2()
except IOError:
    print "不能调用非公有属性!"
else:
    print "ok!" #现在呢!证明是滴!


print '\n*********新式类和经典类的区别'   
'''
D 继承了 object 和不继承程序输出不一样，继承 object 会调用 C 类的 foo，否则会调用 Ａ 的。
使用 super 进行父类构造调用那么必须使用 object 继承的新式类，否则报错。
'''
class A:
   def foo(self):
      print('called A.foo()')
class B(A):
   pass
class C(A):
   def foo(self):
      print('called C.foo()')
class D(B, C,object):#新式类
   pass
class E(B, C):
    pass

if __name__ == '__main__':
   d = D()
   d.foo()
   e = E()
   e.foo()
'''
B、C 是 A 的子类，D 多继承了 B、C 两个类，其中 C 重写了 A 中的 foo() 方法。
如果 A 是经典类（如上代码），当调用 D 的实例的 foo() 方法时，Python 会按照深度优先的方法去搜索 foo() ，路径是 B-A-C ，执行的是 A 中的 foo() ；
如果 A 是新式类，当调用 D 的实例的 foo() 方法时，Python 会按照广度优先的方法去搜索 foo() ，路径是 B-C-A ，执行的是 C 中的 foo() 。
因为 D 是直接继承 C 的，从逻辑上说，执行 C 中的 foo() 更加合理，因此新式类对多继承的处理更为合乎逻辑。
在 Python 3.x 中的新式类貌似已经兼容了经典类，无论 A 是否继承 object 类， D 实例中的 foo() 都会执行 C 中的 foo() 。
但是在 Python 2.7 中这种差异仍然存在，因此还是推荐使用新式类，要继承 object 类。
'''

10.GUI编程

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# GUI编程(Tkinter) 图形界面
# Tkinter   wxPython   Jython

#不能再xshell上运行，因为xshell不支持图形
#在ubuntu的终端上运行：搜索计算机->Terminal

def func1():
    import Tkinter # 导入 Tkinter 库
    top = Tkinter.Tk() #创建控件,指定这个控件的 master， 即这个控件属于哪一个
    top.mainloop() #告诉 GM(geometry manager) 有一个控件产生了,会产生一个窗口
#func1()

def func2():
    from Tkinter import *  # 导入 Tkinter 库
    root = Tk()  # 创建窗口对象的背景色
    li = ['C','python','php','html','SQL','java']
    movie = ['CSS','jQuery','Bootstrap']
    listb  = Listbox(root)    #  创建两个列表组件
    listb2 = Listbox(root)

    for item in li:   # 第一个小部件插入数据
        listb.insert(0,item)
    for item in movie:
        listb2.insert(0,item)

    listb.pack() # 将小部件放置到主窗口中
    listb2.pack()
    root.mainloop()# 进入消息循环
#func2()

'''
Tkinter 控件:
Button        按钮控件；在程序中显示按钮。
Canvas        画布控件；显示图形元素如线条或文本
Checkbutton   多选框控件；用于在程序中提供多项选择框
Entry         输入控件；用于显示简单的文本内容
Frame         框架控件；在屏幕上显示一个矩形区域，多用来作为容器
Label         标签控件；可以显示文本和位图
Listbox       列表框控件；在Listbox窗口小部件是用来显示一个字符串列表给用户
Menubutton    菜单按钮控件，由于显示菜单项。
Menu          菜单控件；显示菜单栏,下拉菜单和弹出菜单
Message       消息控件；用来显示多行文本，与label比较类似
Radiobutton   单选按钮控件；显示一个单选的按钮状态
Scale         范围控件；显示一个数值刻度，为输出限定范围的数字区间
Scrollbar     滚动条控件，当内容超过可视化区域时使用，如列表框。.
Text          文本控件；用于显示多行文本
Toplevel      容器控件；用来提供一个单独的对话框，和Frame比较类似
Spinbox       输入控件；与Entry类似，但是可以指定输入范围值
PanedWindow   是一个窗口布局管理的插件，可以包含一个或者多个子控件。
LabelFrame    是一个简单的容器控件。常用与复杂的窗口布局。
tkMessageBox  用于显示你应用程序的消息框。

所有控件的共同属性:
Dimension     控件大小；
Color         控件颜色；
Font          控件字体；
Anchor        锚点；
Relief        控件样式；
Bitmap        位图；
Cursor        光标；

几何管理,管理整个控件区域组织:
pack()        包装；
grid()        网格；
place()       位置；
'''

#画图，学用circle画圆形
def func3():
    from Tkinter import *
    canvas = Canvas(width=300, height=200, bg='yellow')
    canvas.pack()
    canvas.create_oval(40,40,100,100, fill='pink') # 圆形 在矩形(40,40)->(100,100)内画圆
    canvas.create_oval(120,120,100,70, fill='red') # 椭圆形
    canvas.create_line(200,200,150,150, width=5, fill='green') #直线(200，200)->(150，150)
    canvas.create_rectangle(150,80,200,130,fill='pink')
    mainloop()
#rectangle(int left, int top, int right, int bottom) (left ，top )为矩形的左上坐标，(right,bottom)为矩形的右下坐标，两者可确定一个矩形的大小
#func3()

11.练习实例1

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#例1：有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

def func1():
    n = 0
    for i in range(1,5):
        for j in range(1,5):
            for k in range(1,5):
                if ( i!=j and j!=k and i!=k ):
                    n += 1
                    print i,j,k
    print '个数为',n

#func1()

'''
出现错误：IndentationError: unindent does not match any outer indentation level
原因：空格或Tab没有统一
解决方法：使用notepad编辑的代码，视图->显示符合->显示空格与制表符
          将空格和制表符统一
'''

'''
企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；
利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；
60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，
从键盘输入当月利润I，求应发放奖金总数？
'''
def func2():
    print 'please input a number:'
    n = input()
    if n <= 10:
        print 0.1*n
    elif 10 < n <= 20:
        print 0.1*10 + 0.075*(n-10)
    elif 20 < n <= 40:
        print 0.1*10 + 0.075*10 + 0.05*(n-20)
    elif 40 < n <= 60:
        print 0.1*10 + 0.075*10 + 0.05*20 + 0.03*(n-40)
    elif 60 < n <= 100:
        print 0.1*10 + 0.075*10 + 0.05*20 + 0.03*30 + 0.015*(n-60)
    elif n > 100:
        print 0.1*10 + 0.075*10 + 0.05*20 + 0.03*30 + 0.015*40 + 0.01*(n-100)
    else:
        print "wrong input!"
#func2()


#一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
'''
x+100 = n*n      x+100+168 = m*m
m*m -n*n = 168 = (m+n)*(m-n) = i*j   i=(m+n) j=(m-n)
i+j = 2m    i-j =2n
得到条件：
1. i*j = 168
2. i,j为偶数， j>=2，则 1 < i < 168 / 2 + 1
'''
def func3():
    for i in range(1,85):
        if (168 % 2 == 0):
            j = 168/i
            if ( i>j and (i+j)%2==0 and (i-j)%2==0 ):
                m = (i+j)/2
                n = (i-j)/2
                x = n*n -100
                print 'i=',i, 'j=',j, 'm=',m, 'n=',n, 'x=',x
#func3()



#斐波那契数列（Fibonacci sequence），又称黄金分割数列，
#指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……
def func4(a):
    if (a==0 or a==1):
        return a
    else:
        return func4(a-1) + func4(a-2)
#print "please input a int:"
#a = input()
#print func4(a)


#将一个列表的数据复制到另一个列表中
def func5():
    print '请输入一个列表'
    a = input()
    b = []
    #b = a[:]
    #b = copy.copy[a]
    #b = a.copy()
    for i in a:
        b.append(i)
    print b
#func5()


#输出 9*9 乘法口诀表
def func6():
    for i in range(1,10):
        print
        for j in range(1,i+1):
            print '%d*%d=%d' % (i,j,i*j),  #最后面必须加上”，“
#func6()




#判断101-200之间有多少个素数，并输出所有素数
import math
def func7():
    n = 0
    flag = 1
    for i in range(101,201):
        for j in range(2,int(math.sqrt(i+1))+1):
            if ( i%j==0 ):
                flag = 0
                break   #跳出最近的循环
        if (flag == 1):
            print i
            n += 1
        flag = 1
    print 'total number=',n
#func7()


#打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
#例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方
def func8():
    for n in range(100,1000):
        i = n/100
        j = (n-i*100)/10
        k = n-i*100-j*10
        if (n==i**3+j**3+k**3):
            print n
#func8()


#将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5
'''
xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。
xrange(5)   list(xrange(5))
要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间
'''
def func9(n):
    print '{}'.format(n)  #格式化字符串
    if ( not isinstance(n,int) ): #isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()
        print '请输入一个正整数：'
        exit(0)
    while (n not in [1]): # n==1退出while
        for index in xrange(2,n+1):  #range会直接生成一个list对象,xrange则不会直接生成一个list，而是每次调用返回其中的一个值
            if (n%index == 0):
                n /= index
                if (n==1):
                    print index
                else:
                    print '%d*' % index,
                break
#func9(100)


#输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
def func10():
    print '请输入一行字符串:'
    str = raw_input()
    letters = 0
    space =0 
    digit = 0 
    others = 0
    for i in str:
        if i.isalpha() :
            letters += 1
        elif i.isspace() :
            space += 1
        elif i.isdigit() :
            digit += 1
        else:
            others += 1
    print 'char = %d,space = %d,digit = %d,others = %d' % (letters,space,digit,others)
#func10()

#求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字
def func11(n, a):
    Tn = 0
    Sn = []
    for idx in range(n):
        Tn += a
        a *= 10
        Sn.append(Tn) #存储的是每一项的值
    Sn = reduce( lambda x,y: x+y ,Sn)  
    # lambda匿名函数: lambda [arg1 [,arg2,.....argn]]:expression
    # reduce(function, iterable[, initializer]) 函数会对参数序列中元素进行累积
    print '和为：',Sn
#func11(4,4)



#一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数
def func12():
    for i in range(2,1001):
        m = [] #存放i的因子
        for j in range(1,i):
            if (i%j==0):
                m.append(j)
        if ( i==reduce( lambda x,y: x+y ,m) ):
            print i
            print m
            m = []
#func12()



#一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
def func13():
    n = 100.0
    s = 0.0
    for i in range(1,10):
        s += n
        n /= 2
        s += n
    s += n
    print '总高度=',s,'第十次反弹高度=',n
#func13()


'''
猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。
求第一天共摘了多少。
'''
def func14():
    n = 1
    for i in range(9):
        n = (n+1)*2
    print n
#func14()

#打印n行菱形
def func15(n):
    for i in range(1,n/2+2):
        print 
        for j in range((n-2*i+1)/2):
            print ' ',
        for j in range(2*i-1):
            print '*',
        print ' ',
    for i in range(1,n/2+1):
        print
        for j in range(i):
            print ' ',
        for j in range(-2*i+n):
            print '*',
        print ' ',
#func15(19) #必须为奇数


#有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
def func16():
    m = 2.0
    n = 1.0
    a = [m/n]
    for i in range(1,20):
        n,m = m,m+n  #从右向左赋值
        a.append( (0.0+m)/(0.0+n))
    print reduce( lambda x,y:x+y, a)
#func16()
'''
a, b = a, a + b
右边的 a, a+b 会返回一个tuple  然后这个左边的a, b 会分别赋值为这个tuple里的第一个和第二个
'''
def test():
    a = 1
    b = 2
    c = a, a+b  # 这里 c=(1,3)
    print type(c)  # 
    a, b = a, a + b +10
    print a, b # 1 13
    a, b = c
    print a, b  # 1 3
#test()

#求1+2!+3!+...+20!的和
def func17(n):
    sum = 0
    a = 1
    for i in range(1,n+1):
        for j in range(1,i+1):
            a *= j
        sum += a
        a = 1
    print 'sum=',sum
#func17(20)

#利用递归方法求5!
def func18(n):
    if n==1 or n==0:
        return 1
    else:
        return n*func18(n-1)
#print '值为',func18(3)




#按相反的顺序输出列表的值,按逗号分隔列表
def func19():
    a = ['one', 'two', 'three']
    for i in a[::-1]:
        print i
    s1 = ','.join(str(n) for n in a) #join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
    print s1
#func19()



#练习函数调用
def hello_world():
    print 'hello world'

def three_hellos():
    for i in range(3):
        hello_world()
if __name__ == '__main__':
    three_hellos()


#求一个3*3矩阵主对角线元素之和   二维数组
def func20():
    a = []
    sum = 0.0
    for i in range(3):
        a.append([])
        for j in range(3):
            a[i].append( float(raw_input("input num:\n")) )
    for i in range(3):
        sum += a[i][i]
    print 'sum=',sum
    print a
#func20()


#全局变量和局部变量
num = 2  #全局变量
def autofunc():
    num = 1  #局部变量
    print 'internal block num = %d' % num
    num += 1
for i in range(3):
    print 'The num = %d' % num
    num += 1
    autofunc()

12.练习实例2

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
def func1():
    n = int( input('请输入总人数:') )
    num = []
    for i in range(n):
        num.append(i+1)

    i = 0   #记录了第几个人
    k = 0   #记录了报号数
    m = 0   #记录了退出圈子的人数

    while m1 :
        if num[i]!=0:
            k += 1
        if k==3:
            num[i] = 0  #报到3时，退出圈子
            k = 0
            m += 1
        i += 1
        if i==n :  #总共n个人
            i = 0
    for i in range(len(num)):
        if num[i]!=0:
            print num[i]
#func1()


#打印出杨辉三角形
def func2():
    n = int( input('请输入总行数:') )
    a = []
    for i in range(n):
        a.append([])
        for j in range(n):
            a[i].append(0)
    for i in range(n):
        a[i][0] = 1
        a[i][i] = 1
    for i in range(2,n):
        for j in range(1,i):
            a[i][j] = a[i-1][j-1] + a[i-1][j]
    for i in range(n):
        for j in range(i+1):
            print '%2d'% (a[i][j]),
        print 
    #倒三角形式打印
    for i in range(n):
        if i%2==0:
            for j in range((n-i)/2):
                print '  ',
            for j in range(i+1):
                print '%2d'% (a[i][j]),
        else :
            print ' ',
            for j in range((n-i)/2-1):
                print '  ',
            for j in range(i+1):
                print '%2d'% (a[i][j]),
        print 
#func2()



#有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
def func3():
    n = input('输入一个队列:\n')
    m = int(raw_input('向后移 m 个位置为:\n'))
    print '原始队列为：',n

    while m>0 :
        end = n[len(n)-1]
        for i in range(len(n)-1,-1,-1):
            n[i] = n[i-1]
        n[0] = end
        m -= 1
    print '移动队列为：',n
#func3()



#编写input()和output()函数输入，输出5个学生的数据记录
def input_stu(stu):
    for i in range(len(stu)):
        print '请输入第%d个学生的信息:' % (i+1)
        stu[i].append(raw_input('input student name:\n'))
        stu[i].append(raw_input('input student sex:\n'))
        stu[i].append(int(raw_input('score:\n')))


def output_stu(stu):
    print '学生的信息如下:'
    for i in range(len(stu)):
        for j in range(len(stu[i])):
            print stu[i][j],
        print 

def func4():
    n = input('输入学生数:\n')
    student = []
    for i in range(n):
        student.append([])
    input_stu(student)   #以数组做实参，其值会改变；以变量做实参，值不会改变
    output_stu(student)
#func4()


#字符串排序。
def func5():
    str1 = raw_input('input string:\n')
    str2 = raw_input('input string:\n')
    str3 = raw_input('input string:\n')
    print str1,str2,str3

    if str1 > str2 : str1,str2 = str2,str1
    if str1 > str3 : str1,str3 = str3,str1
    if str2 > str3 : str2,str3 = str3,str2

    print 'after being sorted.'
    print str1,str2,str3
#func5()


'''
海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，
第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
'''
def func6():
    i = 0
    j = 0
    x = 0
    while i<5 :  #5只猴子
        x = 4*j  #标记桃子的个数
        for i in range(5):#5只猴子
            if(x%4!=0):  #逆向思考，必须为4的倍数
                break;
            else:
                i += 1
            x = (x/4)*5+1   #逆向思考
        j += 1 #j控制x
    print x
#func6()



#列表转换为字典。
def func7():
    i = ['a', 'b']
    l = [1, 2]
    print dict([i,l])

    dict1 = {}
    for key in range(len(i)):
        dict1[i[key]] = l[key]
    print dict1

    b=dict(zip(i,l))
    print b

    print({i[j]: l[j] for j in range(len(i))})

    d = {}
    for j in range(len(i)):
        d.setdefault(i[j],l[j])
    print d
#func7()



#多维数组
def func8():
    matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
    print matrix  
    print matrix[1]  
    col2 = [row[1] for row in matrix]#get a  column from a matrix  
    print col2  
    col2even = [row[1] for row in matrix if  row[1] % 2 == 0]#filter odd item  
    print col2even
#func8()