Python基础

最新推荐文章于 2023-10-11 14:28:28 发布

kingov

最新推荐文章于 2023-10-11 14:28:28 发布

阅读量719

点赞数 1

分类专栏： 2 Python 人工智能文章标签： python

本文链接：https://blog.csdn.net/kingov/article/details/63680000

版权

2 Python 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

人工智能

1 篇文章 0 订阅

订阅专栏

1-0 基本知识
2-0 语法
3-0模块

1-0 基本知识

1-1 中文输出

#coding = utf-8
print('你好世界！')

1-2 注释

单行注释以#开头
#coding = utf-8
print('你好世界！')  #打印中文，#开头的后面是单行注释

多行注释是3个单引号
'''
这里是多行注释的内容
'''

2-0 语法

2-1 数据类型

Numbers(数字)
- int (有符号整型)
- long (长整形，可以代表八进制和十六进制)
- float (浮点型)
- complex (复数)
Boolean (布尔)
- 两个值，true，false
String (字符串)
List (列表)
Tuple (元组)
Dictionary (字典)

2-2 标示符

标示符由字符，下划线和数字自称，但不能以数字开头，区分大小写

2-3 输入/输出

输出

name = 'tom'
age = 19

# %s用来替换字符串

print(" 名字：%s , 年龄：%s " %(name , age) )

# 控制台打印 名字：tom , 年龄：19

输入

vl = raw_input("请输入内容")   #输入100
print(vl)  #打印了"100"，输入的是数字打印的是字符串

2-4 运算符

运算符	功能	案例
+	加
-	减
*	乘
/	除
%	取余	4%3==1 , 3%4==3
**	幂	2**3==8 , 2的3次幂
//	相除取整	8//3==2 , 2//3==0
+=	求和	a += b 相当于a = a + b

字符串相加

str1 = 'tom' 
str2 = 'jack' 
print( str1 + str2 )   #tomjack

字符串乘数字

str1 = 'tom' 
print( str1 * 3 )   #tomtomtom

2-5 判断语句和循环语句

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3则（a == b) 为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a != b) 为 true.
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a <> b) 为 true。这个类似于 != 运算符
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a > b) 为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a < b) 为 false.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a >= b) 为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a <= b) 为 true.

if/else语句

fg = 1

if fg == 1 :
    print('抢购成功')
else:
    print('再接再厉')

elif语句
相当于if else if

num = 100 
if num < 60 
    printf('不及格')
elif 60<num<80
    printf('良好')
elif 80<num<90
    printf('优秀')
else
    printf('good!')

while语句

num = 1
while num<5 :
    num += 1
    print("num的值是：%d" %num)
'''
num的值是：2
num的值是：3
num的值是：4
num的值是：5
'''

2-6 函数

定义函数

def fn():
    print('执行函数')
fn()    #调用函数
fn()    #调用函数

引入内部函数

import time
nowTme = time.asctime( time.localtime(time.time()))
print( '现在的时间是' , nowTme ) #现在的时间是 Sun Mar 19 11:33:31 2017

不定长形参

def fn( arg1 , *args ) :
    print(arg1)
    print( args )

fn( 1 , 2 , 3 )  #1     (2,3)

默认形参

def fn( arg1 , arg2=3 ) :
    print(arg1)
    print( arg2 )

fn( 1 )    #1   3
fn( 1 , 2 )   #1   2

函数嵌套

def fa(a):
    c = a + 1
    fb(c)
    print(a)

def fb(b):
    print(b)
#执行完函数fb再执行fa后面的函数
fa(1)      #2    1

函数内访问全局变量

a = 1   #全局变量
def fn( ):
    global a
    a = 3   #修改了全局变量
    print(a)     #3

fn()
print(a)     #3

递归求阶乘

def fn(num):
    if num >=1 :
        result = num * fn(num-1)
    else:
        result = 1
    return result

print( fn(4) )   #24

匿名函数lambda

#lambda 定义简单的匿名函数，并且只能返回一个表达式
fn = lambda arg1 , arg2 : arg1 + 10 + arg2*arg1
print( fn(1,2) )   #3

2-7 字符串

2-7-1 字符串的输入和输出

字符串输出

str = 'China'
print( '我来自%s' %str  )   #我来自China

字符串输入

str = raw_input('请输入你的名字')
print('你的名字是：%s' %str)

2-7-2 字符串的下标

#字符串的索引从0开始
str = 'abcdef'
print( str[2] )  #c

#取出一部分字符串
str = 'abcdef'
print( str[0:3] )  #abc , 取出下表0到2的字符串

#取出一部分字符串
str = 'abcdef'
print( str[1:4] )  #bcd , 取出下表1到3的字符串

#取出一部分字符串
str = 'abcdef'
print( str[1:-1] )  #bcde ,

2-7-3 格式化符号

格式符号	转换
%c	字符
%s	通过str() 字符串转换来格式化
%i	有符号十进制整数
%d	有符号十进制整数
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写字母）
%X	十六进制整数（大写字母）
%e	索引符号（小写’e’）
%E	索引符号（大写“E”）
%f	浮点实数
%g	％f和％e 的简写
%G	％f和％E的简写

2-7-4 字符串常用操作

find( ) 查找某个字符在字符串中的位置

str = 'abcdefedbca'
print( str.find('d') )  #3
print( str.find('d' , 5 , 10 ) )  #7
print( str.find('d' , 5 , 7 ) )  #-1

rfind( ) 从右边开始查找某个字符在字符串中的位置

str = 'abcdefedbcarrr'
print( str.rfind('d') )  #7
print( str.rfind('d' , 1 , 5 ) )  #3
print( str.rfind('d' , 5 , 7 ) )  #-1

index( ) 查找某个字符在字符串中的位置

str = 'abcdefedbca'
print( str.index('d') )  #3
print( str.index('d' , 5 , 10 ) )  #7
print( str.index('d' , 5 , 7 ) )  #报错

rindex( ) 从右边开始查找查找某个字符在字符串中的位置

str = 'abcdefedbcarrr'
print( str.rindex('d') )  #7
print( str.rindex('d' , 5 , 10 ) )  #7
print( str.rindex('d' , 1 , 7 ) )  #3

count( ) 检测某个字符出现的次数

str = 'abcdefedbca'
print( str.count('d') )  #2,字母d出现了2次
print( str.count('d' , 5 , 10 ) )  #1，在下标5到10之间d出现了1次

replace() 替换字符串

str = 'efedefe'
print( str.replace( 'e' , 'u') )  #ufudufu ， 替换所有

str = 'efedefe'
print( str.replace( 'e' , 'u' , 2 ) )  #ufudefe , 指定只替换2次

split() 字符串切割成数组

str = 'ef-ed-ef-e'
print( str.split( '-' ) )  #['ef', 'ed', 'ef', 'e']

capitalize() 第一个字母大写

str = 'abcd'
print( str.capitalize() )

startswith（）判断是否已某个字符开头

str = 'abcd'
print( str.startswith('a') )  #True
print( str.startswith('ab') )  #True
print( str.startswith('c') )  #False

endswith（）判断是否已某个字符结束

lower/upper 小写/大写

str = 'ABCD'
print( str.lower() )  #abcd

str = 'abcd'
print( str.upper() )  #ABCD

ljust/rjust 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

str = 'ABCD'
print( str.ljust(8) , '用空格往后填充至长度为8' )  #ABCD     用空格往后填充至长度为8

str = 'ABCD'
print( str.rjust(8) )  #    ABCD   左边有4个空格

str = 'ABCD'
print( str.center(12) )   ##    ABCD    , 左右各4个空格，总共12个空格

lstrip/rstrip 删除左/右空格

str = '    ABCD'
print( str.lstrip() )   #ABCD

str = '    ABCD    '
print( str.rstrip() )   #    ABCD

partition 以某个字符为界限左中右分成3部分

str = 'aaabbbccc'
print( str.partition('bbb') )  #('aaa', 'bbb', 'ccc')

rpartition 从右开始以某个字符为界限左中右分成3部分

str = 'hello am tom'
print( str.rpartition('am') )  #('hello ', 'am', ' tom')

未完。。。

2-7-5 字符串的长度

str = 'abcd' 
print( len(str) )   #4

2-8 列表（就是数组）

std = [ ‘tom’ , ‘jack’ , ‘jim’ ]

访问列表

std = [ 'tom' , 'jack' , 'jim' ]
std[0]   //tom
std[1]   //jack

遍历列表

std = [ 'tom' , 'jack' , 'jim' ]
for k in std :
    printf(k)    //tom    jack    jim

列表长度

arr = [ 1,2,3,4,5 ]
print( len(arr) )   #5

数组的增删改查

//增
std = [ 'tom' , 'jack' , 'jim' ]
std.append( 'bim' )

//删
del
std = [ 'tom' , 'jack' , 'jim' ]
del std[1]
printf( std )  //[ 'tom' , 'jim' ]

pop
std = [ 'tom' , 'jack' , 'jim' ]
std.pop()
printf( std )           //[ 'tom' , 'jack' ]

remove
std = [ 'tom' , 'jack' , 'jim' ]
std.remove( 'tom' )
printf( std )           //[ 'jack' , 'jim' ]

判断列表里的元素

std = [ 'tom' , 'jack' , 'jim' ]
if 'tim' not in std :
    print('there is no tim')  //tim如果不在std里返回True

insert( 位置，元素) 在指定位置插入元素

arr = [1,2,3,4,5]
arr.insert( 2 , 6 )
print( arr )   #[1, 2, 6, 3, 4, 5]

pop(位置) 从后面删除（可指定位置）

arr = [1,2,3,4,5]
arr.pop(  )
print( arr )  #[1, 2, 3, 4]

arr = [1,2,3,4,5]
arr.pop( 2 )
print( arr )  #[1, 2, 4 , 5]

2-9 函数

实参和形参个数不一致，形参默认值
def f( a , b=2 ):
    c = a*b
    print( 'a和b的乘积是%d' %c )
    return c
# 第二个参数没有传，会用b=2默认值
f( 2 )  #a和b的乘积是4


参数顺序不一样
def f( a , b=2 ):
    c = a*b
    print( 'a和b的乘积是%d' %c )
    return c

f( b=3 , a=5 )  #a和b的乘积是4

参数的长度不固定

def f( num , *arr ) :
    return num + arr[0] + arr[2]

print( f(1,2,3,4) )  #7

形参一旦固定了实参必须和形参一直

def fn( a , b ):
    c = a + b
    print(c)
fn(1,3)   #4

def fn( a , b ):
    c = 9
    print(c)
fn()   #报错

def fn( a  ):
    c = 9
    print(c)
fn(1，2)   #报错

匿名函数

fn = lambda num1 , num2 : num1 + num2
print( fn(1,2) )   #3
lambda函数内不能换行，如果换行也要用转移符\ 
不能写return，只有一行表达式
匿名函数里不能写print() , 因为只需一行表达式

2-10 全局变量和局部变量

num = 100 
def fn():
    print( num )  #可以打印出100
fn()

num = 100

def ff():
    num = 200
    print( num )  #200 , 打印的是局部变量num=200，并没有改变全局变量
ff()
print( num )   #100 ， 打印的是全局变量num=100

def ff():
    num = 200
    print( num )  #200 , 打印的是局部变量num=200，并没有改变全局变量
ff()
print( num )   #100 ， 打印的是全局变量num=100

列表里的值可以不同

arr = [ 1 , 'a' , ['a' , 2] , 3 ]

2-11 数据类型转换

函数	说明
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 转换为一个列表
chr(x )	将一个整数转换为一个字符
unichr(x )	将一个整数转换为Unicode字符
ord(x )	将一个字符转换为它的整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串

2-11 字典

len(obj) 字典的长度

obj = { 'name':'tom' , 'age':18 , 'addr':'usa' }
print( len(obj) )   #3

obj.keys() 获取字典的所有属性

obj = { 'name':'tom' , 'age':18 , 'addr':'usa' }
print( obj.keys() )   #dict_keys(['name', 'age', 'addr'])

obj.values() 获取字典的所有值

obj = { 'name':'tom' , 'age':18 , 'addr':'usa' }
print( obj.values() )   #dict_values(['tom', 18, 'usa'])

obj.items() 获取字典的所有键值对以元组的形式展示

obj = { 'name':'tom' , 'age':18 , 'addr':'usa' }
print( obj.items() )   #dict_items([('name', 'tom'), ('age', 18), ('addr', 'usa')])

has_key() 判断字典有无该属性？？？

obj.get(‘attr’) obj中如果有attr属性则返回属性值否则返回None

obj = { 'name':'tom' , 'age':19 }
print( obj.get('addr') )   #None
print( obj.get('addr') , -1 )   #None -1

访问字典

obj = {'name':'tom','age':20}

obj['addr'] = 'usa'  # 新增

print( obj['name'])  # tom
print( obj['age'])  # 20
print( obj['addr'])  # us

del dict['Name']; # 删除键是'Name'的条目
dict.clear();     # 清空词典所有条目
del dict ;        # 删除词典

2-12 元组

元组和列表一样区别在于元组不能修改

元组的操作

元组操作	结果	作用
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x	1 2 3	迭代
L[2]	‘SPAM!’	读取第三个元素
L[-2]	‘Spam’	反向读取；读取倒数第二个元素
L[1:]	(‘Spam’, ‘SPAM!’)	截取元素
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple)	计算元组元素个数。
max(tuple)	返回元组中元素最大值。
min(tuple)	返回元组中元素最小值。
tuple(seq)	将列表转换为元组。

元祖的读取

yu = (1,2)

print(yu[0]) # 1
print(yu[1]) # 2

arr = [(1,2),('a','b'),(1,'a')]

for item in arr :
    print(item[0])

多维元组

>>> tuple1 = [(2,3),(4,5)]
>>> tuple1[0]
(2, 3)
>>> tuple1[0][0]
2
>>> tuple1[0][2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> tuple1[0][1]
3
>>> tuple1[2][2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> tuple2 = tuple1+[(3)]
>>> tuple2
[(2, 3), (4, 5), 3]
>>> tuple2[2]
3
>>> tuple2[2][0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not subscriptable

2-13 文件操作

文件访问模式

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

write读文件并且写入内容

f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()

read读文件

#使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
#idx.txt的内容是happy birthday

f = open('idx.txt', 'r')

content = f.read(5)  #读5个字节

print(content)   #happy   

content = f.read()   #读取全部内容

print(content)    #happy birthday

f.close()

readlines按行读取，返回列表

#就像read没有参数时一样，readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
'''
word.txt的内容
 hellow-world-1
 hellow-world-2
 hellow-world-3
'''
#coding=utf-8

f = open('word.txt', 'r')

content = f.readlines()

print(type(content))  #<class 'list'>

i=1
for temp in content:
    #%d是数字，%s是字符串
    print("%d:%s"%(i, temp))
    i+=1
f.close()

#打印结果
1: hellow-world-1
2: hellow-world-2
3: hellow-world-3

readline读数据，指定某一行

#coding=utf-8

f = open('word.txt', 'r')

content = f.readline()
print("第一行:%s"%content)   #第一行: hellow-world-1

content = f.readline()
print("第二行:%s"%content)   #第二行: hellow-world-2

content = f.readline()
print("第三行:%s"%content)   #第三行: hellow-world-3

f.close()

大文件读写？

应用：复制文件

#coding=utf-8

oldFileName = raw_input("请输入要拷贝的文件名字:")

oldFile = open(oldFileName,'rb')

# 如果打开文件
if oldFile:

    # 提取文件的后缀
    fileFlagNum = oldFileName.rfind('.')
    if fileFlagNum > 0:
        fileFlag = oldFileName[fileFlagNum:]

    # 组织新的文件名字
    newFileName = oldFileName[:fileFlagNum] + '[复件]' + fileFlag

    # 创建新文件
    newFile = open(newFileName, 'wb')

    # 把旧文件中的数据，一行一行的进行复制到新文件中
    for lineContent in oldFile.readlines():
        newFile.write(lineContent)

    # 关闭文件
    oldFile.close()
    newFile.close()

获取当前读写位置

#在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取
'''
word.txt的内容
1hellow-world-1
2hellow-world-2
3hellow-world-3
4hellow-world-4
5hellow-world-5
'''

#coding = utf-8

# 打开一个已经存在的文件
f = open("word.txt", "r")
str = f.read(3)
print( str )    #1he    读取三个字符

# 查找当前位置
position = f.tell()
print( position )    #3，当前的位置在第三个字符

str = f.read(3)     #接着上一个位置往后读三个字符
print( str )    #llo

# 查找当前位置
position = f.tell()
print( position )    #6

f.close()

定位到某个位置

如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek()

seek(offset, from)有2个参数
- offset:偏移量
- from:方向
  - 0:表示文件开头
  - 1:表示当前位置
  - 2:表示文件末尾
    demo:把位置设置为：从文件开头，偏移5个字节

# 打开一个已经存在的文件
f = open("test.txt", "r")
str = f.read(30)
print "读取的数据是 : ", str

# 查找当前位置
position = f.tell()
print "当前文件位置 : ", position

# 重新设置位置
f.seek(5,0)

# 查找当前位置
position = f.tell()
print "当前文件位置 : ", position

f.close()

练习:把位置设置为离文件末尾，3字节处

# 打开一个已经存在的文件
f = open("test.txt", "r")

# 查找当前位置
position = f.tell()
print "当前文件位置 : ", position

# 重新设置位置
f.seek(-3,2)

# 读取到的数据为：文件最后3个字节数据
str = f.read()
print "读取的数据是 : ", str

f.close()

文件操作模块OS

文件重命名

import os

os.rename("world.txt", "hello-world.txt")

删除文件

import os

os.remove("毕业论文.txt")

创建文件

import os

os.mkdir("张三")

获取当前目录

import os

os.getcwd()

改变默认目录

import os

os.chdir("../")

获取目录列表

import os

os.listdir("./")

删除文件夹

import os

os.rmdir("张三")

批量修改文件名

#coding=utf-8

# 批量在文件名前加前缀

import os

funFlag = 1 # 1表示添加标志  2表示删除标志

folderName = './renameDir/'

# 获取指定路径的所有文件名字
dirList = os.listdir(folderName)

# 遍历输出所有文件名字
for name in dirList:
   print name

   if funFlag == 1:
       newName = '[东哥出品]-' + name
   elif funFlag == 2:
       num = len('[东哥出品]-')
       newName = name[num:]
   print newName

   os.rename(folderName+name, folderName+newName)

2-14异常

捕获异常

说明:
此程序看不到任何错误，因为用except 接收了产生IOError错误，并添加了处理错误的方法
pass 表示实现了相应的实现，但什么也不做；如果把pass改为print语句，那么就会输出其他信息
小总结:
把可能出现问题的代码，放在try中
把处理异常的代码，放在except中

try:
    print '-----test--1---'
    open('123.txt','r')
    print '-----test--2---'
except IOError:
    pass

捕获多个异常

如果想捕获所有的异常，可以省略 except后面的变量
但是这种方法不建议大家使用，会隐藏一些开发者没有想到的异常情况

#coding=utf-8
try:
    print '-----test--1---'
    # 如果123.txt文件不存在，那么会产生 IOError 异常
    open('123.txt','r')
    print '-----test--2---'
    # 如果num变量没有定义，那么会产生 NameError 异常
    print num
except (IOError,NameError), errorMsg: 
    #如果想通过一次except捕获到多个异常可以用一个元组的方式

    # errorMsg里会保存捕获到的错误信息
    print errorMsg

try…finally…

不管线捕捉到的是什么错误，无论错误是不是发生，这些代码“必须”运行，比如文件关闭，释放锁，把数据库连接返还给连接池等

import time
try:
    f = file('poem.txt')
    while True: # our usual file-reading idiom
        line = f.readline()
        if len(line) == 0:
            break
        time.sleep(2)
        print line,


finally:
    f.close()
    print 'Cleaning up...closed the file'

程序读poem.txt文件中每一行数据打印，但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些。在程序运行的时候，按Ctrl-c中断/取消程序。

我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。

else

在if中，它的作用是当条件不满足时执行的实行；同样在try…except…中也是如果，即如果没有捕获到异常，那么就执行else中的事情

try:
    num = 100
    print num
except NameError, errorMsg:
    print('有错误了:%s'%errorMsg)
else:
    print('没有捕获到异常')
finally:
    print('一定执行')

抛出异常

用raise语句来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类
下面是一个引发异常的例子:

class ShortInputException(Exception):
    '''你定义的异常类。'''
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    s = raw_input('请输入 --> ')

    if len(s) < 3:
        # raise引发一个你定义的异常
        raise ShortInputException(len(s), 3)

except EOFError:
    print '/n你输入了一个结束标记EOF'
except ShortInputException, x:#x这个变量被绑定到了错误的实例
    print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'% (x.length, x.atleast))
else:
    print '没有异常发生.'

结果

$ python raising.py
请输入 -->
你输入了一个结束标记EOF

$ python raising.py
请输入 --> --> ab
ShortInputException: 输入的长度是 2, 长度至少应是 3

$ python raising.py
请输入 --> abc
没有异常发生.

3-0模块

3-1引入模块

在Python中用关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。

import 模块一,模块二...

引入数学模块

import math
print( math.sqrt(4) )   #2.0

3-2引入模块中的某个函数或者变量

#有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以以下方法实现

    from 模块名 import 函数名1,函数名2....
'''
不仅可以引入函数，还可以引入一些变量
注意:
通过这种方式引入的时候，调用函数时只能给出函数名，不能给出模块名，但是当两个模块中含有相同名称函数的时候，后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( )，在模块B中也有函数function( )，如果引入A中的function在先、B中的function在后，那么当调用function函数的时候，是去执行模块B中的function函数。
如果想一次性引入math中所有的东西，还可以通过from math import *来实现，但是不建议这么做
'''

3-3 from…import

#Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。
#语法如下：
    from modname import name1[, name2[, ... nameN]]
#例如，要导入模块fib的fibonacci函数，使用如下语句：
    from fib import fibonacci
#这个声明不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入

3-4 from … import *

#把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
    from modname import *
#这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

3-5 定位模块

当你导入一个模块，Python解析器对模块位置的搜索顺序是：
当前目录
如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

3-6 模块制作

定义模块

在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。
比如有这样一个文件mod.py，在mod.py中定义了函数sum
mod.py的内容

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

调用模块

import mod
num = mod.sum(2,4)
print( num )    #6

name

用于判断模块文件是在本文件运行还是在将其引入的文件中运行

#运行mod.py
def tst(a , b):
    print(__name__)    #__main__
tst()

#mod.py内容
def tst(a , b):
    print(__name__)


#idx.py内容
import mod 
mod.tst()    #mod

3-7 包

引包里的单个模块

多个模块放到一个文件夹里，这个文件夹就叫做包
文件结构
目录结构
a.py内容

#coding=utf8
def fa():
    print('我是a')

b.py内容

# coding=utf8
def fb():
    print('我是b')

init.py是空文件

idx.py内容

#coding=utf8

import bao.a
import bao.b

bao.a.fa()   #我是a
bao.b.fb()   #我是b

引包里的所有模块

init.py增加内容

__all__=['a','b']

a.py和b.py保持不变

idx.py

#coding=utf8

from bao import *

a.fa()   #我是a
b.fb()   #我是b

3-8 模块发布

init.py

__all__ = [ 'mySalary' , 'noMoney']

mySalary.py

def myMoney():
    print('i have a lot fo money!')

noMoney.py

def pool():
    print('i have no money!')

setup.py

from distutils.core import setup

setup(name="kg", version="1.0", description="kg's module", author="kg", py_modules=['myM.mySalary', 'myM.noMoney'] )

构建模块
在myTestModule文件中执行下面语句之后会在当前目录中生成一个build文件

python setup.py build

发布压缩包
在myTestModule文件中执行下面语句之后会在当前目录下生成一个dist文件，里面有一个压缩包kg-1.0.tar.gz这就是已经发布的模块，可以拷给其他人安装使用

python setup.py sdist

安装模块
加入一个同事从你这里拿到了kg-1.0.tar.gz压缩包，他要使用该压缩包，首先解压，在解压的文件中（文件名改成英文）输入命令

# 这样是安装到系统目录
python setup.py install

# 如果不想安装到系统目录可以执行下列语句
python setup.py install --prefix=路径

安装完成之后这时在系统的任意目录都可以加载到myM这个模块

from myM import *

mySalary.myMoney()   #i have a lot fo money!
noMoney.pool()      #i have no money!