Python简介

#!/usr/bin/python

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

第一个 Python 程序

Python 可以同一行显示多条语句,方法是用分号 ; 分开, Python可以在同一行中使用多条语句,语句之间使用分号(;)分割

print "hello word!哈;";print "12"

Python 的代码块不使用大括号 {} 来控制类,函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块,缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行,否则就会报错!

Python语句中一般以新行作为为语句的结束符。 \

但是我们可以使用斜杠( \)将一行的语句分为多行显示

total = item_one + \

        item_two + \

        item_three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符

days = ['Monday', 'Tuesday', 'Wednesday',

        'Thursday']

raw_input('\n 请证明?')

输出: 默认输出是换行的,如果要实现不换行需要在变量末尾加上逗号,

缩进相同的一组语句构成一个代码块,我们称之代码组。

像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)

Python 中的变量赋值不需要类型声明, 每个变量在内存中创建,都包括变量的标识,名称和数据这些信息, 每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建, 等号(=)用来给变量赋值, 等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值

多变量赋值

a, b, c = 1, 2, "john"

Python有五个标准的数据类型:, 弱类型语言自动会创建类型

    Numbers (数字)   存储数字(int整型 float浮点型 long长整型 complex复数)

    String (字符串) 

        存储字符串 由数字、字母、下划线组成的一串字符

        截取字符串的话可以使用变量 [头下标:尾下标]  stri = 'abcdefghijklnmopqrst';print stri[0:7]

 加号(+)是字符串连接运算符,星号(*)是重复操作 s = "hello word";print s, s + " a ", s * 2

        逗号 ( , ) 是间隔一个空格,不换行

    List (列表)

        列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。

        列表用 [ ] 标识,是 python 最通用的复合数据类型

        截取列表也是用 变量[头下标:尾下标], 截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾, 加号 + 是列表连接运算符,星号 * 是重复操作

    Tuple (元组)

        元素类似list , 用(), 不能二次赋值

    Dictionary (字典)

        列表是有序的对象结合,字典是无序的对象集合, 字典通过下表来取值,而不是通过偏移存取。字典用"{ }"标识。字典由索引(key)和它对应的值value组成

        dict = {1:'32',2:3,3:44};

        dict['a'] = "this is aaa";

        dict['b'] = "this is bbb";

        print dict

        print dict.keys();

        print dict.values();

        集合set

        1.set用于存储一组不重复的key值集合,但是不存储其value。

        2.set有两种创建方式:

        用set函数,参数是list集合,例如:s=set([1,2,3,4,5]);

        用大括号包起来的集合字面量,例如: s={1,3}。

    数据类型转换

Python 运算符

    算术运算符

    a = 10;

    b = 20;

    print a + b;

    print a - b;

    print a * b;

    print b / a; 取模 - 返回除法的余数, 注意:Python2.x 里,整数除整数,只能得出整数。如果要得到小数部分,把其中一个数改成浮点数即可。

    print a % b; 除数

    print a ** b; 幂

    print b // a 取整除 - 返回商的整数部分

    比较运算符

    == 等于 - 比较对象是否相等

    != 不等于 - 比较两个对象是否不相等

    <> 不等于 - 比较两个对象是否不相等

    >  大于 - 返回x是否大于y

    <  小于 - 返回x是否小于y

    >= 大于等于    - 返回x是否大于等于y。

    <= 小于等于 -    返回x是否小于等于y

    赋值运算符

    = 简单的赋值运算符

    += 加法赋值运算符 c += a 等效于 c = c + a

    -= 减法赋值运算符    c -= a 等效于 c = c - a

    *=    乘法赋值运算符    c *= a 等效于 c = c * a

    /=    除法赋值运算符    c /= a 等效于 c = c / a

    %=    取模赋值运算符    c %= a 等效于 c = c % a

    **=    幂赋值运算符    c **= a 等效于 c = c ** a

    //=    取整除赋值运算符    c //= a 等效于 c = c // a

    位运算符

    &    按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

    |    按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。

    ^    按位异或运算符:当两对应的二进位相异时,结果为1

    ~    按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1

    <<    左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。

    >>    右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,">>"右边的数指定移动的位数

    逻辑运算符

    and    x and y    布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。

    or    x or y    布尔"或"    - 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。

 not    not x    布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。

    成员运算符

    in    如果在指定的序列中找到值返回 True,否则返回 False。    x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

    not in    如果在指定的序列中没有找到值返回 True,否则返回 False。    x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

    身份运算符 (身份运算符用于比较两个对象的存储单元)

is is 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False

    is not    is not 是判断两个标识符是不是引用自不同对象    x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。

     id() 函数用于获取对象内存地址

    is 与 == 区别:

    is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。

Python 条件语句

    Python程序语言指定任何非0和非空(null)值为true,0 或者 null为false。

    if 判断条件:

            执行语句……

    else:

            执行语句……

Python 循环语句

    Python提供了for循环和while循环

    while 判断条件:

        执行语句……

    [还可以加else:]

    count = 0;

    while (count < 9):

        count += 1

        if(count == 3): break/continue

        print "nihao ", count

    print "good bye"

    遍历 

    for iterating_var in sequence:

       statements(s)

    fruits = ['banana', 'apple',  'mango']

    for index in range(len(fruits)):

       print '当前水果 :', fruits[index]

    sequence = [12, 34, 34, 23, 45, 76, 89]

    for i, j in enumerate(sequence):

        print i,j


    for v in iter(sequence):

          print v

    循环控制语句

    break 语句    在语句块执行过程中终止循环,并且跳出整个循环

    continue 语句    在语句块执行过程中终止当前循环,跳出该次循环,执行下一次循环。

    pass 语句    pass是空语句,是为了保持程序结构的完整性。

Python 数学函数

 * abs(x)    返回数字的绝对值,如abs(-10) 返回 10

    ceil(x)    返回数字的上入整数,如math.ceil(4.1) 返回 5

    floor(x)    返回数字的下舍整数,如math.floor(4.9)返回 4

 * cmp(x, y)    如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

    exp(x)    返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

    fabs(x)    返回数字的绝对值,如math.fabs(-10) 返回10.0

    log(x)    如math.log(math.e)返回1.0,math.log(100,10)返回2.0

    log10(x)    返回以10为基数的x的对数,如math.log10(100)返回 2.0

 * max(x1, x2,...)    返回给定参数的最大值,参数可以为序列。

 * min(x1, x2,...)    返回给定参数的最小值,参数可以为序列。

    modf(x)    返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。   

 * pow(x, y)    x**y 运算后的值。

 * round(x [,n])    返回浮点数x的4舍5入值,如给出n值,则代表舍入到小数点后的位数

    sqrt(x)    返回数字x的平方根,数字可以为负数,返回类型为实数,如math.sqrt(4)返回 2+0j

Python随机数函数, import random

    random()    随机生成下一个实数,它在[0,1)范围内。 random.random()

    uniform(x, y)    随机生成下一个实数,它在[x,y]范围内。 random.uniform(x, y)

    choice(seq)    从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。返回被挑出来的哪个元素

    shuffle(lst)    将序列的所有元素随机排序  打乱序列排序的, 没有返回值

    randrange ([start,] stop [,step])    从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1

 seed([x])  改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。可以在调用其他随机模块函数之前调用此函数,设置相同的seed 生成的随机数相同

Python数学常量

    pi    数学常量 pi(圆周率,一般以π来表示) math.pi

    e    数学常量 e,e即自然常数(自然常数)     math.e

Python字符串转义字符

    在需要在字符中使用特殊字符时,python用反斜杠(\)转义字符

    \(在行尾时)    续行符

    \\    反斜杠符号

    \'    单引号

    \"    双引号

    \a    响铃

    \b    退格(Backspace)

    \e    转义

    \000    空

    \n    换行

    \v    纵向制表符

    \t    横向制表符

    \r    回车

    \f    换页

    \oyy    八进制数,yy代表的字符,例如:\o12代表换行

        十六进制数,yy代表的字符,例如:代表换行

    \other    其它的字符以普通格式输出

Python字符串运算符

    +    字符串连接     a + b    'HelloPython'

    *    重复输出字符串    a * 2 'HelloHello'

    []    通过索引获取字符串中字符  a[1] 'e'

    [:]    截取字符串中的一部分  a[1:4] 'ell'

    in    成员运算符 - 如果字符串中包含给定的字符返回 True    "H" in a    True

    not in    成员运算符 - 如果字符串中不包含给定的字符返回 True    "M" not in a True

 r/R  原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符  print r'\n'

 %    格式字符串

    print "我是 %s 今年 %d 岁" % ('王二小',33)

    print "我是 {1} {0} {2}".format('王小二',41,'交换生')

    str.format()来格式化字符串:

    "{0} {1}".format("hello", "world")    hello word

Python三引号(triple quotes)

    python中三引号可以将复杂的字符串进行复制:

    python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。

    三引号的语法是一对连续的单引号或者双引号(通常都是成对的用)。

Python Unicode 字符串 

    str = u'Hello World !'

python的字符串内建函数

    string.capitalize()   把字符串的第一个字符大写

    string.center(width[, filleable])  返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

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

    string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

    string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string,如果出错默认报一个ValueError的异常 除非errors指定的是'ignore'或者'replace'

    string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace'

    string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.

    string.expandtabs(tabsize=8)    把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8。

    string.format()    格式化字符串

string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中,如果 beg 和 end 指定范围,则检查是否包含在指定范围内,如果是返回开始的索引值,否则返回-1

    string.index(str, beg=0, end=len(string)) 跟find()方法一样,只不过如果str不在 string中会报一个异常.

    string.isalnum()    如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False(就是字符串没有空格True, 有空格就是false)

    string.isalpha()    如果 string 至少有一个字符并且所有字符都是字母则返回 True,    否则返回 False 同上, 有数字也是False

    string.isdecimal()    如果 string 只包含十进制数字则返回 True 否则返回 False. string必须是Unicode字符串

    string.isdigit()    如果 string 只包含数字则返回 True 否则返回 False.

    string.islower() 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False,

    string.isnumeric()    如果 string 中只包含数字字符,则返回 True,否则返回 False Unicode字符串

    string.isspace()    如果 string 中只包含空格,则返回 True,否则返回 False.

    string.istitle()    如果 string 是标题化的(见 title())则返回 True,否则返回 False 如果字符串中所有的单词拼写首字母是否为大写,且其他字母为小写则返回 True,否则返回 False.

    string.isupper()

    如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False

string.join(seq) 以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串, 返回通过指定字符连接序列中元素后生成的新字符串。 序列 转为 字符串 ,  print ','.join(str) 序列数组转换为字符串

    string.lower() 转换 string 中所有大写字符为小写.

    string.lstrip()    截掉 string 左边的空格

    string.rstrip()    删除 string 字符串末尾的空格.

    string.strip([obj])    在 string 上执行 lstrip()和 rstrip(), 默认是空格,obj -- 移除字符串头尾指定的字符。

string.maketrans(intab, outtab])    maketrans() 方法用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。返回字符串转换后生成的新字符串。 字符串替换

    string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

        from string import maketrans   # 必须调用 maketrans 函数。

        str =  "This is my spking";

        ts = maketrans('hi','12');

        print str.translate(ts);

 * max(str) 返回字符串 str 中最大的字母。

 * min(str) 返回字符串 str 中最小的字母。

    string.partition(str)     有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.

    string.rpartition(str)     类似于 partition()函数,不过是从右边开始查找.

string.replace(str1, str2,  num=string.count(str1))     把 string 中的 str1 替换成 str2,如果 num 指定,则替换不超过 num 次.字符串替换

    string.rfind(str, beg=0,end=len(string) )    类似于 find()函数,不过是从右边开始查找. 返回的下标是按左边顺序查找

    string.rindex( str, beg=0,end=len(string))    类似于 index(),不过是从右边开始. 返回的小标是按照左边的顺序

    string.rjust(width)    返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

    string.split(str="", num=string.count(str))    以 str 为分隔符切片 string,如果 num有指定值,则仅分隔 num 个子字符串

    string.splitlines([keepends])    按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。

    string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查.

    string.swapcase()    翻转 string 中的大小写, 大写改为小写,小写改为大写

    string.title()    返回"标题化"的 string,就是说所有单词都是以大写开始,其余字母均为小写

    string.upper()转换 string 中的小写字母为大写

    string.zfill(width)     返回长度为 width 的字符串,原字符串 string 右对齐,前面填充0

Python 列表(List)

    序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。

    Python有6个序列的内置类型,但最常见的是列表和元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型

    访问列表中的值    list[0] list[1:5]

    更新列表       list[0] = 'new'

    删除列表元素   del list1[2]

    Python列表脚本操作符

        列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。

        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    迭代

    Python列表截取   

        L = ['Google', 'Runoob', 'Taobao'];

        L[2]    'Taobao'    读取列表中第三个元素

        L[-2]    'Runoob'    读取列表中倒数第二个元素

        L[1:]    ['Runoob', 'Taobao']    从第二个元素开始截取列表

        L[:2]    ['google', 'Runoob'] 从第0个元素开始截取

    Python列表函数&方法

        cmp(list1, list2)  比较两个列表的元素

            如果比较的元素是同类型的,则比较其值,返回结果。

            如果两个元素不是同一种类型,则检查它们是否是数字。

            如果是数字,执行必要的数字强制类型转换,然后比较。

            如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的",字符串大与数字原则)

            否则,通过类型名字的字母顺序进行比较。

            如果有一个列表首先到达末尾,则另一个长一点的列表"大"。

            从下标为0开始比较,立马返回

            如果我们用尽了两个列表的元素而且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0。

 len(list)           列表元素个数

        max(list)             返回列表元素最大值

        min(list)           返回列表元素最小值

        list(seq)           将元组转换为列表

        list.append(obj)        在列表末尾添加新的对象

        list.count(obj)           统计某个元素在列表中出现的次数

        list.extend(seq)         在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表), 注意没有返回值, 扩充了list

        list.index(obj)         从列表中找出某个值第一个匹配项的索引位置, index表示索引位置

        list.insert(index, obj)    将对象插入列表

        list.pop(obj=list[-1])    移除列表中的一个元素(默认最后一个元素),并且返回该元素的值

        list.remove(obj)        移除列表中某个值的第一个匹配项

        list.reverse()            反向列表中元素

        list.sort([func])        对原列表进行排序 默认按大小顺序排列

Python 元组

    Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

    t = '1','a','c' 创建元组

    t = (1,2,3) 创建元组

    t = ()  空元组

    t = (5,) 一个元素的元组必须用,结尾

    访问元组  t[0]  t[1:5]

    修改元组

        元组中的元素值是不允许修改的,但我们可以对元组进行连接组合 t * 4 或 t + t1

    删除元组

        元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组 del t

    元组运算符

        与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。

        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 = ('spam', 'Spam', 'SPAM!')

        L[2]    'SPAM!'    读取第三个元素

        L[-2]    'Spam'    反向读取;读取倒数第二个元素

        L[1:]    ('Spam', 'SPAM!')    截取元素

    元组内置函数

        cmp(tuple1, tuple2)     比较两个元组元素。

        len(tuple)                计算元组元素个数。

        max(tuple)                返回元组中元素最大值。

        min(tuple)                返回元组中元素最小值。

        tuple(seq)                将列表转换为元组。

Python 字典(Dictionary)

    字典是另一种可变容器模型,且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中

    键必须是唯一的,但值则不必。

    值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。

    访问字典里的值

        把相应的键放入熟悉的方括弧

    修改字典

        向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对, 在列表中要用函数append 或extend才能添加

    删除字典    del d['ac']   del d

清空字典 d.clear()

    字典键的特性

    字典值可以没有限制地取任何python对象,既可以是标准的对象,也可以是用户定义的,但键不行。

        不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会覆盖前一个   

键必须不可变,所以可以用数字,字符串或元组充当,所以用列表就不行

            {'a':'aaa', 'b':'bbb', 123:123, 'd':123,(5,):'555'}

    字典内置函数&方法

        cmp(dict1, dict2)        比较两个字典元素。

        len(dict)                计算字典元素个数,即键的总数。

        str(dict)                输出字典可打印的字符串表示。

        type(variable)            返回输入的变量类型,如果变量是字典就返回字典类型。

        dict.clear()            删除字典内所有元素, 操作函数返回nil

        dict.copy()                返回一个字典的浅拷贝

赋值:        其实就是对象的引用(别名)

            浅拷贝:        拷贝父对象,不会拷贝对象的内部的子对象。

            深拷贝:    copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。copy.deepcopy()

        dict.fromkeys(seq[, val]))    创建一个新字典,以序列 seq(list/tuple) 中元素做字典的键 ,val 为字典所有键对应的初始值 , d = dict.fromkeys()

如果seq是字典,就获取字典中的下标做键    print dict.fromkeys([1,25,6],'aaac')

        dict.get(key, default=None)        返回指定键的值,如果值不在字典中返回default值 d.get

        dict.has_key(key)                如果键在字典dict里返回true,否则返回false

        dict.items()                    以列表返回可遍历的(键, 值) 元组数组 d.items() 键值分别作为一个元组的两个元素, 最外面是list包裹

        dict.keys()        以列表返回一个字典所有的键

        dict.setdefault(key, default=None)    和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default

        dict.update(dict2)

        把字典dict2的键/值对更新到dict里

        pop(key[,default])

        删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。

        popitem() 随机返回并删除字典中的一对键和值。

Python 日期和时间

        Python 程序能用很多方式处理日期和时间,转换日期格式是一个常见的功能。

        Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

        时间间隔是以秒为单位的浮点小数。

        每个时间戳都以自从1970年1月1日午夜(历元)经过了多长时间来表示。

        Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳

    什么是时间元组?

        很多Python函数用一个元组装起来的9组数字处理时间:

        序号

        0    4位数年    2008

        1    月    1 到 12

        2    日    1到31

        3    小时    0到23

        4    分钟    0到59

        5    秒    0到61 (60或61 是闰秒)

        6    一周的第几日    0到6 (0是周一)

        7    一年的第几日    1到366 (儒略历)

        8    夏令时    -1, 0, 1, -1是决定是否为夏令时的旗帜

    上述也就是struct_time元组。这种结构具有如下属性:

        序号    属性    值

        0    tm_year    2008

        1    tm_mon    1 到 12

        2    tm_mday    1 到 31

        3    tm_hour    0 到 23

        4    tm_min    0 到 59

        5    tm_sec    0 到 61 (60或61 是闰秒)

        6    tm_wday    0到6 (0是周一)

        7    tm_yday    1 到 366(儒略历)

        8    tm_isdst    -1, 0, 1, -1是决定是否为夏令时的旗帜


    获取当前时间戳

        time.time()   

    获取当前时间

        time.localtime(time.time())


        返回一个元组time time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

    格式化的时间

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

        time.asctime(time.localtime(time.time()))

        Fri Jun 30 11:36:59 2017

    格式化日期

        使用 time 模块的 strftime 方法来格式化日期

        // 格式化时间

        time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) //2017-07-04 19:36:15

        // 转换成时间戳

        time.mktime(time.strptime(a,'%Y-%m-%d %H:%M:%S')) // 1499168323.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 当前时区的名称

%% %号本身

获取某月日历

Calendar模块有很广泛的方法用来处理年历和月历,例如打印某月的月历:

importcalendar

print calendar.month(2016, 1)  打印出了一个月的日历

Time 模块

Time 模块包含了以下内置函数,既有时间处理相的,也有转换时间格式的:

序号函数及描述

1time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值(如西欧,包括英国)

2time.asctime([tupletime])

接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"(2008年12月11日 周二18时07分14秒)的24个字符的字符串。time.localtime(time.time()) 会返回一个元组time ,     time.time() 返回当前时间戳

3time.clock( )

用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时,比time.time()更有用。 还没清楚使用场景

4time.ctime([secs])

作用相当于asctime(localtime(secs)),未给参数相当于asctime() , 就是把参数时间戳转换成asctime形式, 没有参数默认是time.time()

5time.gmtime([secs])

接收时间辍(1970纪元后经过的浮点秒数)并返回格林威治天文时间下的时间元组t。注:t.tm_isdst始终为0

6time.localtime([secs])

接收时间辍(1970纪元后经过的浮点秒数)并返回当地时间下的时间元组t(t.tm_isdst可取0或1,取决于当地当时是不是夏令时)。

7time.mktime(tupletime)

接受时间元组并返回时间辍(1970纪元后经过的浮点秒数)。

8time.sleep(secs)

推迟调用线程的运行,secs指秒数。

9time.strftime(fmt[,tupletime])

接收以时间元组,并返回以可读字符串表示的当地时间,格式由fmt决定。 

10time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')

根据fmt的格式把一个时间字符串解析为时间元组。

11time.time( )

返回当前时间的时间戳(1970纪元后经过的浮点秒数)。

12time.tzset()

根据环境变量TZ重新初始化时间相关设置。 设置区间的意思!!!!!

返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值(如西欧,包括英国)

Time模块包含了以下2个非常重要的属性:

序号属性及描述

1time.timezone

属性time.timezone是当地时区(未启动夏令时)距离格林威治的偏移秒数(>0,美洲;<=0大部分欧洲,亚洲,非洲)。

2time.tzname

属性time.tzname包含一对根据情况的不同而不同的字符串,分别是带夏令时的本地时区名称,和不带的。

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

// 使用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)

日历(Calendar)模块

此模块的函数都是日历相关的,例如打印某月的字符月历。

星期一是默认的每周第一天,星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数:

序号函数及描述

1calendar.calendar(year,w=2,l=1,c=6)

返回一个多行字符串格式的year年年历,3个月一行,间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。

2calendar.firstweekday( )

返回当前每周起始日期的设置。默认情况下,首次载入caendar模块时返回0,即星期一。

3calendar.isleap(year)

是闰年返回True,否则为false。

4calendar.leapdays(y1,y2)

返回在Y1,Y2两年之间的闰年总数。

5calendar.month(year,month,w=2,l=1)

返回一个多行字符串格式的year年month月日历,两行标题,一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。

6calendar.monthcalendar(year,month)

返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示,从1开始。

7calendar.monthrange(year,month)

返回两个整数。第一个是该月的星期几的日期码,第二个是该月的日期码。日从0(星期一)到6(星期日);月从1到12。

8calendar.prcal(year,w=2,l=1,c=6)

相当于 print calendar.calendar(year,w,l,c).

9calendar.prmonth(year,month,w=2,l=1)

相当于 print calendar.calendar(year,w,l,c)。

10calendar.setfirstweekday(weekday)

设置每周的起始日期码。0(星期一)到6(星期日)。

11calendar.timegm(tupletime)

和time.gmtime相反:接受一个时间元组形式,返回该时刻的时间辍(1970纪元后经过的浮点秒数)。

12calendar.weekday(year,month,day)

返回给定日期的日期码。0(星期一)到6(星期日)。月份为 1(一月) 到 12(12月)。

Python 函数

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

函数能提高应用的模块性,和代码的重复利用率

定义一个函数

你可以定义一个由自己想要功能的函数,以下是简单的规则:

函数代码块以def关键词开头,后接函数标识符名称和圆括号()

任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始,并且缩进。

return [表达式]结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def functionname( parameters ):  "函数_文档字符串"  function_suite

  return [expression]

默认情况下,参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

参数传递

在 python 中,类型属于对象,变量是没有类型的:

a=[1,2,3]

a

="Runoob"

以上代码中,[1,2,3] 是 List 类型,"Runoob"是 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 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。 这句话说的太形象了, 传不可变对象就是传值嘛, 传可变对象就是传引用撒

          举个例子:

          python 传不可变对象实例(传值)

def ChangeInt( a ):

    a = 10

b = 2

ChangeInt(b)

print b # 结果是 2

        

        传可变对象实例(传引用)

def changeme( mylist ):"修改传入的列表"

mylist

.append([1,2,3,4]);print "函数内取值: ",mylist

return


# 调用changeme函数

mylist

= [10,20,30];

changeme( mylist );

print "函数外取值: ", mylist  

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]

函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数 调用类型

必备参数

必须以正确的顺序传入函数,调用数量必须和声明时一样,否则就会报错

关键字参数

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

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

默认参数

调用函数时,缺省参数的值如果没有传入,则被认为是默认值。 记住把默认参数写在参数最后,不然会有歧义

 non-default argument follows default argument

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数, 记住把不定长参数写在参数最后,不然就搞不清了

def functionname([formal_args,] *var_args_tuple ):"函数_文档字符串"

function_suite

return [expression]

加了星号(*)的变量名会存放所有未命名的变量参数。选择不多传参数也可

def printinfo( arg1, *vartuple ):"打印任何传入的参数"print "输出: "printarg1

for var in vartuple: print varreturn;

# 调用printinfo 函数

printinfo

( 10 );

printinfo

( 70, 60, 50 );

匿名函数

     python 使用 lambda 来创建匿名函数。 希腊的第11个字母 lambda

lambda只是一个表达式,函数体比def简单很多。

lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句,如下:

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

# 可写函数说明

sum

= lambda arg1, arg2: arg1 + arg2;

# 调用sum函数

print "相加后的值为 : ", sum( 10, 20 )

print "相加后的值为 : ", sum( 20, 20 )

return 语句

return语句[表达式]退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:

全局变量

局部变量

定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。  全局变量想作用于函数内,需加 global, 在函数中也能更改全局变量!

局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。

Python 模块

Python 模块(Module),是一个 Python 文件,以 .py 结尾,包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的 Python 代码段。

import 语句

模块的引入

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

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

比如要引用模块 math,就可以在文件最开始的地方用import math来引入。在调用 math 模块中的函数时,必须这样引用:

模块名.函数名

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。 一个模块只会被导入一次,不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。 如想要导入模块 support.py,需要把命令放在脚本的顶端, 调用: support.funcname()

From…import 语句

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

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

例如,要导入模块 fib 的 fibonacci 函数,使用如下语句:

from fib import fibonacci

这个声明不会把整个 fib 模块导入到当前的命名空间中,它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。

From…import* 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

例如我们想一次性引入 math 模块中所有的东西,语句如下:

from math import *

from..import   与  import 区别:   

from numpy import zeros

       那么你可以直接调用 zeros()函数

import numpy.zeros

        那么你只能使用全名 numpy.zeros()

搜索路径

当你导入一个模块,Python 解析器对模块位置的搜索顺序是:

1、当前目录

2、如果不在当前目录,Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。

3、如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录。

命名空间和作用域

变量是拥有匹配对象的名字(标识符)。命名空间是一个包含了变量名称们(键)和它们各自相应的对象们(值)的字典。

一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名,则局部变量会覆盖全局变量。

每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。

Python 会智能地猜测一个变量是局部的还是全局的,它假设任何在函数内赋值的变量都是局部的。

因此,如果要给函数内的全局变量赋值,必须使用 global 语句。

global VarName 的表达式会告诉 Python, VarName 是一个全局变量,这样 Python 就不会在局部命名空间里寻找这个变量了。

dir()函数

dir() 函数一个排好序的字符串列表,内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块,变量和函数。如下一个简单的实例

import math print dir(math)

['__doc__', '__file__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

特殊字符串变量__name__指向模块的名字,

     __name__系统变量指示模块应如何被加载,他的值为"__main__"时表示当前模块是被直接执行。

      如果模块是被导入,__name__的值为模块名字

,__file__指向该模块的导入文件名 , 就是当前文件路径!

.pyc文件是由.py文件经过编译后生成的字节码文件,其加载速度相对于之前的.py文件有所提高,而且还可以实现源码隐藏,以及一定程度上的反编译。比如,  Python3.3编译生成的.pyc文件,Python3.4就别想着去运行

globals() 和 locals() 函数

根据调用地方的不同,globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。

如果在函数内部调用 locals(),返回的是所有能在该函数里访问的命名。

如果在函数内部调用 globals(),返回的是所有在该函数里能访问的全局名字。

两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

a = 'aa'

z = 'zzzzz'

def f(a,b):

     x = 1;

     y = 2;

     for i in range(10):

         k = i

     print locals()

 f(3,4)

 print globals()

{'a': 3, 'b': 4, 'i': 9, 'k': 9, 'y': 2, 'x': 1}

{'a': 'aa', 'f': , '__builtins__': , '__file__': 'c.py', '__package__': None, '__name__': '__main__', 'z': 'zzzzz', '__doc__': None}

reload() 函数

当一个模块被导入到一个脚本,模块顶层部分的代码只会被执行一次。

因此,如果你想重新执行模块里顶层部分的代码,可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下:

reload(module_name)

在这里,module_name要直接放模块的名字,而不是一个字符串形式。比如想重载 hello 模块,如下:

reload(hello)

Python中的包

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

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

内置模块(不用import就可以直接使用)常用内置函数

help(obj) 在线帮助, obj可是任何类型

callable

(obj) 查看一个obj是不是可以像函数一样调用

repr

(obj) 得到obj的表示字符串,可以利用这个字符串eval重建该对象的一个拷贝

eval_r

(str) 表示合法的python表达式,返回这个表达式

dir

(obj) 查看obj的name space中可见的name

hasattr

(obj,name) 查看一个obj的name space中是否有name

getattr

(obj,name) 得到一个obj的name space中的一个name

setattr

(obj,name,value) 为一个obj的name

space

中的一个name指向vale这个object

delattr

(obj,name) 从obj的name space中删除一个name

vars

(obj) 返回一个object的name space。用dictionary表示

locals

() 返回一个局部name space,用dictionary表示

globals

() 返回一个全局name space,用dictionary表示

type

(obj) 查看一个obj的类型

isinstance

(obj,cls) 查看obj是不是cls的instance

issubclass

(subcls,supcls) 查看subcls是不是supcls的子类

##################    类型转换  ##################

chr

(i) 把一个ASCII数值,变成字符

ord

(i) 把一个字符或者unicode字符,变成ASCII数值

oct

(x) 把整数x变成八进制表示的字符串

hex

(x) 把整数x变成十六进制表示的字符串

str

(obj) 得到obj的字符串描述

list

(seq) 把一个sequence转换成一个list

tuple

(seq) 把一个sequence转换成一个tuple

dict

(),dict(list) 转换成一个dictionary

int(x) 转换成一个integer

long(x) 转换成一个longinterger

float(x) 转换成一个浮点数

complex

(x) 转换成复数

max

(...) 求最大值   

min(...) 求最小值 

Python 文件I/O

最简单的输出方法是用print语句,你可以给它传递零个或多个用逗号隔开的表达式

读取键盘输入

Python提供了两个内置函数从标准输入读入一行文本,默认的标准输入是键盘。如下:

raw_input

input

raw_input函数

raw_input([prompt]) 函数从标准输入读取一个行,并返回一个字符串(去掉结尾的换行符):

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

str

= raw_input("请输入:");print "你输入的内容是: ", str

input函数

input([prompt])函数和raw_input([prompt])函数基本类似,但是 input 可以接收一个Python表达式作为输入,并将运算结果返回。, 如果是输入字符串, 必须加引号否则报错

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

str

= input("请输入:");print "你输入的内容是: ", str

打开和关闭文件

现在,您已经可以向标准输入和输出进行读写。现在,来看看怎么读写实际的数据文件。

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

open 函数

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

语法:

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

各个参数的细节如下:

file_name:file_name变量是一个包含了你要访问的文件名称的字符串值。

access_mode:access_mode决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读(r)。

buffering:如果buffering的值被设为0,就不会有寄存。如果buffering的值取1,访问文件时会寄存行。如果将buffering的值设为大于1的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认。

不同模式打开文件的完全列表:

模式描述

r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

r+打开一个文件用于读写。文件指针将会放在文件的开头。

rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。

wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。

w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。

wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。

a打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。

ab以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。

a+打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。

ab+以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。

File对象的属性

一个文件被打开后,你有一个file对象,你可以得到有关该文件的各种信息。

以下是和file对象相关的所有属性的列表:

属性描述

file.closed返回true如果文件已被关闭,否则返回false。

file.mode返回被打开文件的访问模式。

file.name返回文件的名称。

file.softspace如果用print输出后,必须跟一个空格符,则返回false。否则返回true。

close()方法

File 对象的 close()方法刷新缓冲区里任何还没写入的信息,并关闭该文件,这之后便不能再进行写入。

当一个文件对象的引用被重新指定给另一个文件时,Python 会关闭之前的文件。用 close()方法关闭文件是一个很好的习惯。

语法:

fileObject.close();

# 打开一个文件

fo

= open("foo.txt", "wb")print "文件名: ", fo.name

# 关闭打开的文件

fo

.close()

write()方法

write()方法可将任何字符串写入一个打开的文件。需要重点注意的是,Python字符串可以是二进制数据,而不是仅仅是文字。

write()方法不会在字符串的结尾添加换行符('\n'):

语法:

fileObject.write(string);

在这里,被传递的参数是要写入到已打开文件的内容。

# 打开一个文件

fo

= open("foo.txt", "wb")

fo

.write( "www.runoob.com!\nVery good site!\n");

# 关闭打开的文件

fo

.close()

read()方法

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

语法:

fileObject.read([count]);

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

fo = open("foo.txt", "r+")

str

= fo.read(10);print "读取的字符串是 : ",str

# 关闭打开的文件

fo

.close()

文件定位

tell()方法告诉你文件内的当前位置;换句话说,下一次的读写会发生在文件开头这么多字节之后

seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

如果from被设为0,这意味着将文件的开头作为移动字节的参考位置。

如果设为1,则使用当前的位置作为参考位置。

如果它被设为2,那么该文件的末尾将作为参考位置。

# 打开一个文件

fo

= open("foo.txt", "r+")

str

= fo.read(10);print "读取的字符串是 : ",str

# 查找当前位置

position

= fo.tell();print "当前文件位置 : ",position

# 把指针再次重新定位到文件开头

position = fo.seek(0, 0);    # seek 第一个参数 offset 是指偏移字符数,可以为负数, from 如上,  seek(-10, 2)

str = fo.read(10);print "重新读取字符串 : ",str

# 关闭打开的文件

fo

.close()

Python File(文件) 方法

file 对象使用 open 函数来创建,下表列出了 file 对象常用的函数:

序号方法及描述

1file.close()

关闭文件。关闭后文件不能再进行读写操作。

2file.flush()

刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

3file.fileno()

返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。

4file.isatty()

如果文件连接到一个终端设备返回 True,否则返回 False。

5file.next()

返回文件下一行。

6file.read([size])

从文件读取指定的字节数,如果未给定或为负则读取所有。

7file.readline([size])

读取整行,包括 "\n" 字符。

8file.readlines([sizehint])

读取所有行并返回列表,若给定sizeint>0,返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。

9file.seek(offset[, whence])

设置文件当前位置

10file.tell()

返回文件当前位置。

11file.truncate([size])

截取文件,截取的字节通过size指定,默认为当前文件位置。

12file.write(str)

将字符串写入文件,没有返回值。

13file.writelines(sequence)

向文件写入一个序列字符串列表,如果需要换行则要自己加入每行的换行符。

重命名

Python的os模块提供了帮你执行文件处理操作的方法,比如重命名和删除文件。

要使用这个模块,你必须先导入它,然后才可以调用相关的各种功能。

rename()方法:

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

语法:

os.rename(current_file_name, new_file_name)

删除文件 remove()方法

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

语法:

os.remove(file_name)

Python里的目录:

所有文件都包含在各个不同的目录下,不过Python也能轻松处理。os模块有许多方法能帮你创建,删除和更改目录。

mkdir()方法

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

语法:

os.mkdir("newdir")

chdir()方法

可以用chdir()方法来改变当前目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。更改目录后创建文件直接在放在新的目录!!!!!

语法:

os.chdir("newdir")

getcwd()方法

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

语法:

os.getcwd()

rmdir()方法

rmdir()方法删除目录,目录名称以参数传递。

在删除这个目录之前,它的所有内容应该先被清除。

语法:

os.rmdir('dirname')

OS 对象方法: 提供了处理文件及目录的一系列方法。

Python 异常处理

python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。

什么是异常?

异常即是一个事件,该事件会在程序执行过程中发生,影响了程序的正常执行。

一般情况下,在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语句

#!/usr/bin/python

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

try:

fh

= open("testfile", "w")

    fh.write("这是一个测试文件,用于测试异常!!")

except IOError:

    print "Error: 没有找到文件或读取文件失败"

else:

    print "内容写入文件成功"

fh

.close()

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

你可以不带任何异常类型使用except,如下实例:

try: 正常的操作

......................

except:

    发生异常,执行这块代码

......................

else:

    如果没有异常执行这块代码

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

使用except而带多种异常类型

你也可以使用相同的except语句来处理多个异常信息,如下所示:

try: 正常的操作

   ......................

except(Exception1[, Exception2[,...ExceptionN]]]):

   发生以上多个异常中的一个,执行这块代码

   ......................

else:

    如果没有异常执行这块代码

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

try:<语句>

finally:<语句>    #退出try时总会执行

raise

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

try:

fh

= open("testfile", "w") try:

fh

.write("这是一个测试文件,用于测试异常!!") finally: print "关闭文件"

        fh.close()

except IOError:

    print "Error: 没有找到文件或读取文件失败"

异常的参数

一个异常可以带上参数,可作为输出的异常信息参数。

你可以通过except语句来捕获异常的参数,如下所示:

try: 正常的操作

   ......................

except ExceptionType, Argument:

    你可以在这输出 Argument 的值...

变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。

元组通常包含错误字符串,错误数字,错误位置。

触发异常

我们可以使用raise语句自己触发异常

raise语法格式如下:

raise [Exception [, args [, traceback]]]

语句中Exception是异常的类型(例如,NameError)参数是一个异常参数值。该参数是可选的,如果不提供,异常的参数是"None"。

最后一个参数是可选的(在实践中很少使用),如果存在,是跟踪异常对象。

实例

一个异常可以是一个字符串,类或对象。 Python的内核提供的异常,大多数都是实例化的类,这是一个类的实例的参数。

定义一个异常非常简单,如下所示:

def functionName( level ):    if level < 1:        raise Exception("Invalid level!", level)        # 触发异常后,后面的代码就不会再执行

注意:为了能够捕获异常,"except"语句必须有用相同的异常来抛出类对象或者字符串。

例如我们捕获以上异常,"except"语句如下所示:

try: 正常逻辑except "Invalid level!": 触发自定义异常else: 其余代码

用户自定义异常

通过创建一个新的异常类,程序可以命名它们自己的异常。异常应该是典型的继承自Exception类,通过直接或间接的方式。

以下为与RuntimeError相关的实例,实例中创建了一个类,基类为RuntimeError,用于在异常触发时输出更多的信息。

在try语句块中,用户自定义的异常后执行except块语句,变量 e 是用于创建Networkerror类的实例。

class Networkerror(RuntimeError):    def __init__(self, arg):        self.args = arg

在你定义以上类后,你可以触发该异常,如下所示:

try: raise Networkerror("Bad hostname")except Networkerror,e: print e.args

Python 内置函数

内置函数

abs()divmod()input()open()staticmethod()

all()enumerate()int()ord()str()

any()eval()isinstance()pow()sum()

basestring()execfile()issubclass()print()super()

bin()file()iter()property()tuple()

bool()filter()len()range()type()

bytearray()float()list()raw_input()unichr()

callable()format()locals()reduce()unicode()

chr()frozenset()long()reload()vars()

classmethod()getattr()map()repr()xrange()

cmp()globals()max()reversed()zip()

compile()hasattr()memoryview()round()__import__()

complex()hash()min()set()

delattr()help()next()setattr()

dict()hex()object()slice()

dir()id()oct()sorted()exec 内置表达式

推荐阅读更多精彩内容