小朋友学Python

Posted 2021-01-04 Alan_Fire

运算符

一、基本运算符

Python运算符多数与C/C++/Java类似，但有少数不一样。
“/”表示求商，“//”求商的整数部分。11 / 2 = 5.500000, 11 // 2 = 5
“**”表示求幂。2 ** 5 = 32

例1

a = 10
b = 3

x = a / b
y = a // b
z = a**b
print x,y,z 

c = float(b)
m = a / c
n = a // c
print m,n

运行结果：

3 3 1000
3.33333333333 3.0

二、成员运算符in和not in

in : 如果在指定的序列中找到值返回 True，否则返回 False
not in : 如果在指定的序列中没有找到值返回 True，否则返回 False

例2

a = 1
b = 20
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print "a is in the list"
else:
   print "a is not in the list"
   
if ( b not in list ):
   print "b is not in the list"
else:
   print "b is in the list"

运行结果：

a is in the list
b is not in the list

三、身份运算符is和is not

is : 判断两个标识符是不是引用自一个对象
is not : 判断两个标识符是不是引用自不同的对象

例3

a = 20
b = 20
 
if ( a is b ):
   print "a and b is the same object"
else:
   print "a and b is not the same object"
 
if ( a is not b ):
   print "a and b is not the same object"
else:
   print "a and b is the same object"
 
b = 30
if ( a is b ):
   print "a and b is the same object"
else:
   print "a and b is not the same object"

运行结果：

a and b is the same object
a and b is the same object
a and b is not the same object

is与==的区别
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等

例4 （以下代码位于Python交互式环境）

>>> a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

说明，b =a[:]，这里冒号前面和后面都没有数字，表示取a的第一个元素到最后一个元素，放到另一个对象b里。所以b与a里的数据相同，但不是同一个对象。

四、运算符优先级

运算符	描述
（）	括号（最高优先级）
**	指数
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 \'AND\'
^	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is, is not	身份运算符
in, not in	成员运算符
not, or, and	逻辑运算符

 

循环

一、while循环

例1

count = 0
while (count < 9):
   print \'The count is:\', count
   count = count + 1
 
print "Good bye!"

运行结果：

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

例2 （while…else句式）

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"

运行结果：

0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5

二、for循环

例3

# -*- coding: UTF-8 -*-
 
for letter in \'Python\':     # 第一个实例
   print \'当前字母 :\', letter
 
fruits = [\'banana\', \'apple\',  \'mango\']
for fruit in fruits:        # 第二个实例
   print \'当前水果 :\', fruit
 
print "Good bye!"

运行结果：

当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : h
当前字母 : o
当前字母 : n
当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!

三、Pass语句

例4

# -*- coding: UTF-8 -*- 

# 输出 Python 的每个字母
for letter in \'Python\':
   if letter == \'h\':
      pass
      print \'这是 pass 块\'
   print \'当前字母 :\', letter

print "Good bye!"

运行结果：

当前字母 : P
当前字母 : y
当前字母 : t
这是 pass 块
当前字母 : h
当前字母 : o
当前字母 : n
Good bye!

日期和时间

一、获取当前时间戳

例1

import time

now = time.time()
print now

运行结果：

1512884891.53

说明：
这里得到的时间是时间戳（timestamp），是从1970年1月1日0时0分开始计算的，单位是秒。
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。

二、获取当前时间

例2

import time

localtime = time.localtime(time.time())
print localtime

运行结果：

time.struct_time(tm_year=2018, tm_mon=1, tm_mday=2, tm_hour=17, tm_min=27, tm_sec=59, tm_wday=1, tm_yday=2, tm_isdst=0)

说明：
struct_time叫做时间元组，其数据结构为

属性	意义	值
tm_year	四位数的年	2018
tm_mon	月	1到12
tm_mday	日	1到31
tm_hour	小时	0到23
tm_min	分钟	0到59
tm_sec	秒	0到60（60是闰秒）
tm_wday	星期几	0到6（0是星期一）
tm_yday	一年的第几日	1到366
tm_isdst	夏令时	1：夏令时; 0：非夏令时

三、获取格式化的时间

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime()

例3

import time

localtime = time.localtime(time.time())
formatTime = time.asctime(localtime)
print formatTime

运行结果：

Tue Jan 02 17:51:42 2018

四、格式化日期

例4

import time

print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) 

print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) 
  
# convert time to timestamp
a = "Sat Mar 28 22:24:24 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

运行结果：

2018-01-02 17:57:19
Tue Jan 02 17:57:19 2018
1459175064.0

python中时间日期格式化符号：

%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 当前时区的名称
%% %号本身

五、获取某月日历

例5

import calendar

cal = calendar.month(2016, 1)
print cal

运行结果：

  January 2016
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

函数

函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。
Python提供了许多内建函数，比如print()。但编程人员也可以自己创建函数，这叫做用户自定义函数。

一、定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

例1

def printme( str ):
   " Print input string "
   print str
   return

二、函数调用

定义一个函数只是给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，可以通过另一个函数调用执行，也可以直接从Python提示符执行。

例2

# define function 
def printme( str ):
   "Print input string"
   print str;
   return;
 
# invoke function
printme("invoke self defined function!");
printme("invoke the same function again");

运行结果:

invoke self defined function!
invoke the same function again!

三、参数传递

在 python 中，类型属于对象，变量是没有类型的：

a = [1,2,3]

a = "Newbie"

以上代码中，[1,2,3] 是 List 类型，"Newbie" 是 String 类型，而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

（一）可更改(mutable)与不可更改(immutable)对象

在 python 中，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没有动，只是其内部的一部分值被修改了。

（二）python 函数的参数传递

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

（三）python 传不可变对象的例子

例3

def ChangeInt( a ):
    a = 10

b = 2
ChangeInt(b)
print b

运行结果：

2

（四）传可变对象例子

例4

def changeme( mylist ):
    "modify input list"
    mylist.append([1,2,3]);
    print mylist
    return
 
mylist = [10,20,30];
changeme( mylist );
print mylist

因为list是可变对象，所以函数内外的mylist指向了同一个对象，值自然也就相同。故运行结果如下：

[10, 20, 30, [1, 2, 3]]
[10, 20, 30, [1, 2, 3]]

四、参数类型

以下是调用函数时可使用的正式参数类型：
必备参数
关键字参数
默认参数
不定长参数

（一）必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：

例5

def printme( str ):
   print str;
   return;
 
printme();

运行结果：

Traceback (most recent call last):
  File "test.py", line 5 in <module>
    printme();
TypeError: printme() takes exactly 1 argument (0 given)

（二）关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名做为关键字：

例6

def printme( str ):
   print str;
   return;
   
printme( str = "Hello World!");

运行结果：

Hello World!

注意，这里str是关键字，所以不能改为别的名称。以下都是错的：

s = “Hello World!”
abc = “Hello World!”

下例能将关键字参数顺序不重要展示得更清楚：

例7

def printinfo( name, age ):
   print "Name: ", name;
   print "Age: ", age;
   return;
 
printinfo( age=9, name="Theodore" );

运行结果：

Name: Theodore
Age: 9

（三）缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是取默认值。

例8

def printinfo( name, age = 18 ):
   print "Name: ", name
   print "Age ", age;
   return;
 
printinfo( age=9, name="Theodore" )
printinfo( name="Li Lei" )

运行结果：

Name: Theodore
Age: 9
Name: Li Lei
Age: 18

（四）不定长参数

你在定义函数时可能事先不知道函数被调用时会传入多少个参数，这时你可以声明不定长参数。
不定长参数声明时不会命名，基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数说明"
   function_suite
   return [expression]

加了星号的变量名会存放所有未命名的变量参数。

例9

def printinfo( arg1, *vartuple ):
   print arg1
   for var in vartuple:
      print var
   return
 
printinfo( 10 )
printinfo( 70, 60, 50 )

运行结果：

10
70
60
50

五、匿名函数

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

语法
lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

例10

sum = lambda arg1, arg2: arg1 + arg2;
print sum( 10, 20 )
print sum( 20, 20 )

运行结果：

30
40

模块

一、模块的定义

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。

例1: printinfo.py

def print_info(info):
    print "Hello:", info
    return

二、模块的引入

模块定义好后，我们可以使用 import 语句来引入模块，语法如下：

import module1[, module2[,... moduleN]]

例2：test.py

import printinfo

printinfo.print_info("Python")

运行结果：

Hello: Python

注意，这里printinfo.py和test.py要放在同一个目录下。

三、from … import

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 a的 b 函数，使用如下语句：

from a import b

这个声明不会把整个 a 模块导入到当前的命名空间中，它只会将 a 里的 b 函数引入到执行这个声明的模块的全局符号表。

四、包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py用于标识当前文件夹是一个包。

例3

考虑一个在 package_demo目录下的 module1.py、module2.py、__init__.py 文件，test.py 为测试调用包的代码，目录结构如下：

test.py
package_demo
|-- __init__.py
|-- module1.py
|-- module2.py

 

1.png

 

2.png

__init__.py中的代码

print \'package_demo initialize\'

module1.py的代码

def func1():
    print "I am in function 1"

module2.py的代码

def func2():
    print "I am in function 2"

test.py的代码

from package_demo import module1
from package_demo import module2

module1.func1()
module2.func2()

运行结果：

 

文件

Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。

一、打开和关闭文件

例1

（1）创建名为test1.txt的文件，内容为
This is a test file.
（2）在同一目录下新建file1.py文件，内容如下

file = open("test1.txt", "wb")
print "File name: ", file.name
print "Access mode: ", file.mode
print "Closed or not? ", file.closed

file.close()
print "Closed or not? ", file.closed

运行结果：

File name: test1.txt
Access mode: wb
Closed or not? False
Closed or not? True

说明：

（一）open 函数

你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。

语法：
file object = open(file_name [, access_mode][, buffering])

各个参数的细节如下：
（1）file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
（2）access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。下表是这些模式的总结。

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

（3）buffering: 是一个可选的参数，用来表示缓冲区的策略选择。设置为0时，表示不使用缓冲区，直接读写，仅在二进制模式下有效。设置为1时，表示在文本模式下使用行缓冲区方式。设置为大于1时，表示缓冲区的设置大小。如果参数buffering没有给出，使用默认时，会采用下面策略来选择：
① 对于二进制文件模式时，采用固定块内存缓冲区方式，内存块的大小根据系统设备的分配的磁盘块来决定，如果获取系统磁盘块的大小失败，就使用内部常量io.DEFAULT_BUFFER_SIZE定义的大小。一般的操作系统上，块的大小是4096或者8192字节大小。
② 对于交互的文本文件（采用isatty()判断为True）时，采用一行缓冲区的方式。其它文本文件使用跟二进制一样的方式。

（二）File对象的属性

一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：

属性	描述
file.closed	返回true如果文件已被关闭，否则返回false。
file.mode	返回被打开文件的访问模式。
file.name	返回文件的名称。

（三）close()方法

close()方法方法关闭打开的文件。关闭的文件无法读取或写入更多东西。文件已被关闭之后任何操作都会引发ValueError。但是调用close()多次是可以的。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。
用 close（）方法关闭文件是一个很好的习惯。

二、读取文件内容

例2

file = open("test1.txt", "r+")

content = file.read(10)
print content

file.close()

运行结果：

This is a

read()方法

read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不仅仅是文字。

语法：
fileObject.read([count]);

在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

三、写入文件

例3

file = open("test2.txt", "wb")
file.write( "I like study Python.");
 
file.close()

运行结果：

生成test2.txt，并向其写入
I like study Python.

说明：

write()方法

write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不仅仅是文字。
write()方法不会在字符串的结尾添加换行符(\'\\n\')：

语法：
fileObject.write(string);
在这里，被传递的参数是要写入到已打开文件的内容。

四、文件定位

例4

file = open("test1.txt", "r+")
content = file.read(10);
print content
 
position = file.tell();
print "Current positon: ", position
 
position = file.seek(0, 0);
content = file.read(5);
print content

position = file.tell();
print "Current positon: ", position

file.close()

运行结果：

This is a
Current position: 10
This
Current position: 5

说明：

（一）tell()方法

告诉你文件内的当前位置；换句话说，下一次的读写会发生在文件开头这么多字节之后。

（二）seek（offset [,from]）方法

改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

五、重命名和删除文件

Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。
要使用这个模块，你必须先导入它，然后才可以调用相关的各种功能。

rename()方法

rename()方法需要两个参数，当前的文件名和新文件名。

语法：
os.rename(current_file_name, new_file_name)

例5

import os

os.rename( "test1.txt", "test5.txt" )

remove()方法

你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。

语法：
os.remove(file_name)

例6

import os

os.remove("test5.txt")

目录

Python的os模块有许多方法能帮你创建，删除和更改目录。

一、创建目录

mkdir()方法

可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。

语法：
os.mkdir("dirname")

例1：在当前目录下创建一个新目录testdir

import os
os.mkdir("testdir")

二、获取当前目录

getcwd()方法

getcwd()方法显示当前的工作目录。

语法：
os.getcwd()

注意，这里cwd是current working directory的缩写。

例2

import os
print os.getcwd()

运行结果：

E:\\PythonProjects

三、改变目录

chdir()方法

可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。

语法：
os.chdir("newdirname")
这里chdir是change directory的简写。

例3

import os

os.chdir("D:\\\\Doc")
print os.getcwd()

os.chdir("E:\\\\PythonProjects")
print os.getcwd()

运行结果：
D:\\Doc
E:\\PythonProjects

四、删除目录

rmdir()方法

rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。

语法：
os.rmdir(\'dirname\')

例4

import os
os.rmdir("testdir")

运行结果：
在E:\\PythonProjects目录下执行这个程序，E:\\PythonProjects\\testdir被删除

异常

一、什么是异常

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

二、异常处理

捕捉异常可以使用try…except语句。
try…except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：
以下为简单的try....except...else的语法

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

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。

如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

例1

try:
    fh = open("mytest", "w")
    fh.write("This is a file to test exception!")
except IOError:
    print "Error: No file found or read file error!"
else:
    print "Write cotent to file succeed!"
fh.close()

运行结果：

This is a file to test exception!

查看mytest文件中的内容：

This is a file to test exception

例2

将mytest文件的写权限去掉

chmod -w mytest

再次执行test.py，结果为

Error: 
Error: No file found or read file error!

三、使用except而不带任何异常类型

你可以不带任何异常类型使用except

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
如果没有异常执行这块代码

以上方式try…except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。

四、try…except…finally语句

finally 中的代码无论是否发生异常都将被执行

例3：除0异常

try:
    1 / 0
except Exception as e:
    print "0 can not be divided!"
else:
    print "No exception!"
finally:
    print "Anyway, statement in finally block will be executed!"

运行结果：

0 can not be divided!
Anyway, statement in finally block will be executed!

五、raise触发异常

例4

#define function
def test_func( level ):
    if level < 1:
        raise Exception("Invalid level!", level)

try:
    #invoke function
    test_func(0)                
except "any":
    print 1
else:
    print 2
finally:
    print 3

运行结果：

3
Traceback (most recent call last):
  File “test.py”, line 8, in <module>
test_func(0)
  File “test.py”, line 4, in test_func
raise Exception(“Invalid level!”, level)
Exception: (‘Invalid level!’,0)

从运行结果可以看出，raise抛出异常后，except和else中的语句都没有被打印出来，但是finally中的语句被打印出来了。

面向对象

一、类与对象

例1

class Employee:
   \'Base class of employee\'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
 
   def showInfo(self):
      print "Name : ", self.name,  ", Salary : ", self.salary
 
# Create the first instance
emp1 = Employee("Zhang San", 8000)
# Create the second instance
emp2 = Employee("Li Si", 15000)
emp1.showInfo()
emp2.showInfo()
print "Total Employee : %d" % Employee.empCount

运行结果：

Name : Zhang San, Salary : 8000
Name: Li Si, Salary : 15000
Total Employee : 2

分析：
（1）__init__是构造函数。C++/Java中的构造函数名和类名一样，而Python的构造函数名为__init__
（2）self相当于C++或Java中的this, 是一个指针。当创建一个实例后，self指向该实例
（3）name和salary是实例变量，empCount是类变量
（4）C++/Java创建实例需要使用new关键字，Python不需要
（5）最后一行的第二个百分号，相当于C语言printf中的逗号

二、Python的内置类属性

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

例2

class Employee:
   \'Base class of employee\'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
 
   def showInfo(self):
      print "Name : ", self.name,  ", Salary : ", self.salary
 
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__

运行结果：

Employee.__doc__: Base class of employee
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: 
{\'showInfo\': <function showInfo at 0x10a93caa0>,
\'__module__\': \'__main__\', 
\'empCount\': 0,
\'__doc__\': \' Base class of employee \',
\'__init__\': <function __init__ at 0x10a939578>}

三、引用计数

Python 使用了引用计数这一技术来跟踪和回收垃圾。
在 Python 内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

例3

import sys
class Point:
   def __init__( self, x = 0, y = 0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "Destroyed!"
 
pt1 = Point()
print sys.getrefcount(pt1)
pt2 = pt1
print sys.getrefcount(pt1)
pt3 = pt2
print sys.getrefcount(pt1)

del pt3
print sys.getrefcount(pt1)
del pt2
print sys.getrefcount(pt1)
del pt1

运行结果：

2
3
4
3
2
Point Destroyed!

分析：
pt1 = Point()，等号右侧创建了一个对象，引用计数为1；等号左侧让引用pt1指向这个对象，引用计数加1变为2
pt2 = pt1，引用计数加1 变为3
pt3 = pt1，引用计数加1 变为4
del pt3，引用计数减1变为3
del pt2, 引用计数减1变为2
del pt1，引用计数减1，同时因为最初创建的对象没用引用指向他，对象会被释放，引用计数再减去1，变为0。析构函数__del__被调用。
注意，因为引用计数为0，所以不能用 print sys.getrefcount(pt1)来查看引用计数。若查看会抛出异常。

继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特点：

1：在继承中基类的构造（init()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

语法：

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):

例1

class Parent:       
   number = 100
   def __init__(self):
      print "Invoke parent constructor method"
 
   def parentMethod(self):
      print \'Invoke parent method\'
 
   def setNumber(self, num):
      self.number = num
 
   def getNumber(self):
      print "Parent\'s number :", self.number
 
class Child(Parent): 
   def __init__(self):
      print "Invoke child constructor method"
 
   def childMethod(以上是关于小朋友学Python的主要内容，如果未能解决你的问题，请参考以下文章
 
 小朋友学Python
 小朋友学Python
 有没有学脉冲神经网络的朋友
 教女朋友学Python运行环境搭建
 Python面向对象学习之八，装饰器
 想了解Python中的super 函数么