python能做什么？

• 科学计算
• 图形化开发
• 系统脚本
• web服务器
• 网络爬虫
• 服务器集群自动化运维

1、基础类型

1.1 基础数据类型

• 整型：通常被称为整型或证书，是正或负整数，不带小数点
• 长整型：无限大小的整数，整数最后一个大写(或小写)L
• 浮点型：浮点型由整型部分与小数部分组成，浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 10^2 = 250 )
• 复数：复数的虚部以字母J或j结尾：如：2+3j
  -布尔类型：True,False
• 字符串：单引号，双引号，三个单引号括号括起来

获取变量的数据类型 type(var_name)

主提示符  >>> 在等待下一条语句
次提示符  ...     在等待当前语句的其他部分

1.2变量

1.2.1变量本质

1. python中的变量不需要先定义，再使用，可以直接使用，还有重新使用用以存储不同类型的值
2. 变量命名遵循C命名风格
3. 大小写敏感
4. 变量引用计数
5. del语句可以直接释放资源，变量名删除，引用计数减1
6. 变量内存自动管理回收，垃圾收集
7. 指定编码在文件开头加入# -- coding:UTF-8 -- 或者 #coding=utf-8

>>> a = 12 #无需定义，直接使用，python解释器根据右值决定左侧类型

>>> print a
12

>>> id(a) #变量a在内存中的编号
136776784

>>> type(a) #a的类型为int类型
<class 'int'>

>>> b = 12.34
>>> print b
12.34

>>> id(b) #变量b在内存中所占内存编号
3071447616

>>> type(b)
<class 'float'> #b的类型为float

>>> a = "itcast" #变量a从新指向一个字符串
>>> print a
itcast

>>> id(a) #变量a在内存中的编号为保存“itcast”地方，原来a所指向的内存编号里内容并没有立即释放
3071127936

>>> type(a) #变量a现在指向一个字符串
<class 'str'>

>>> c = b
>>> print c
12.34
>>> id(c) #变量c保存的内存中的编号和b一致
3071447616
>>> type(c)
<class 'float'>

>>> b = 12 #解释器在内存中发现有保存12的这个单
元，于是变量b指向了此单元，减少了存储空间的反复申请与释放
>>> id(b)
136776784
>>> type(b)
<class 'int'>
>>> print b
12

>>> print a
itcast
>>> del(a)
>>> print a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

1.3 简单函数

函数定义格式

def add(x, y):#因为没有{}，所以一定要退格缩进
  z = x + y       
  return z

res = add(3, 5)
print res
8

1. def 是定义函数的关键字
2. x和y是形参，不需要类型修饰
3. 函数定义行需 " : "
4. 函数体整体缩进
5. 函数可以拥有返回值，若无返回值，返回None，相当于C中的NULL

1.4输入输出函数

#输出
#print函数
>>> print "%s is %d hello world "%("tody",1)
tody is 1 hello world

#输入
>>> a = raw_input()
>>> 123
>>> print a
#raw_input() 从标准输入获取数据 返回的数据是字符串类型 需要使用int()进行转换

1.5局部变量和全局变量

代码1. 局部变量作用域覆盖全局变量

def p_num():
    num=5
    print num

num=10
p_num()
print num
#结果: 5 10

代码2. 函数内部有局部变量定义，解释器不适用全局变量，局部变量的定义晚于被引用，报错

def p_num():
    print num
    num=5
    print num

num=10
p_num()
print num
# 结果出错

代码3. 函数内部可以直接访问全局变量

def p_num():
    print num
    num=10

p_num()
print num
# 结果: 10 10

代码4. 函数内修改全局变量，使用global关键字

def p_num():
    global num
    print num
    num = 20
    print num

num=10
p_num()
print num

#结果：10 20 20

1.6 特殊变量

_xxx     from module import *无法导入
__xxx__  系统定义的变量
__xxx    类的本地变量

1.7 表达式

1.7.1 算数表达式

+a          结果符号不变
-a          对结果符号取负
a + b       a加b
a - b       a减b
a ** b      a的b次幂
a * b       a乘以b
a / b       a除以b，真正除，浮点数保留小数
a // b      a除以b，向下取整
a % b       a对b取余数

1.7.2 逻辑表达式

not a     a的逻辑非     bool
a and b   a和b逻辑与    bool
a or b    a和b逻辑或    bool
a is b    a和b是同一个对象     bool
a is not b a和b不是同一个对象  bool

1.7.3 关系表达式

运算结果为布尔类型

== 等于
!= 不等于
<> 不等于(废弃)
> 大于
< 小于
>= 大于等于
<= 小于等于

1.8 位运算

~a 按位取反
a << n a左移n位
a >> n a右移n位
a & b a和b按位与
a | b a和b按位或
a ^ b a和b按位异或

1.9 语法格式

缩进表示关系，函数，分支，循环语句后面带 " : "

1.10 分支语句

#if-else
  if a > b:
    print("aaa")
  else:
      print("bbb")

#if-elif-else
  if a > b:
    print("a>b")
  elif a == b:
    print("a==b")
  else:
    print("a<b")

1.11循环语句

python里的控制语句和循环语句和C中的非常相似，毕竟python是用C实现的

注意语句后面的':'不能丢掉，这一点C/C++程序员刚上手python的时候很容易犯的错误

while 判断条件：
    执行语句

var = 1
while var == 1 : # 该条件永远为true，循环将无限执行下去
    num = raw_input("Enter a number :")
    print "You entered: %d", num


print "Good bye!"

Python for循环可以遍历任何系列的项目，如一个列表或者一个字符串

for iterating_var in sequence:
    执行语句

for letter in 'Python': # First Example
  print 'Current Letter :', letter

fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # Second Example
  print'Current fruit :', fruit

在python中，for...else表示这样的意思，for中的语句和普通的没有区别，else中的语句会在循环正常执行完(即for不是通过break跳出而中断的)的情况执行，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

1.11.1break

Python break语句，就像在C语言中，打破了最小封闭for或while循环

break语句用来终止循环语句，即循环条件没有false条件或者序列还没被完全递归完，也会停止执行循环语句

break语句用在while和for循环中

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码

1.11.2 continue

Python continue语句跳出本次循环，而break跳出整个循环

continue语句用来高数Python跳出当前循环的剩余语句，然后继续进行下一轮循环

continue语句用在while和for循环中

1.12 list列表

序列都可以进行的操作包括索引，切片，加，乘，检查 成员

序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，以此类推

列表和元组二者均能保存任意类型的python对象，索引访问元素从0开始

列表元素用[ ] 包括，元素个数，值都可以改变

元组元素用 ( )包括，通过切片[:]得到子集，此操作作用于字符串相关操作

切片使用的基本样式 [下限:上限:步长]

1.12.1 访问列表中的值

>>>aList = [1,2,3,4]
>>>aList
[1,2,3,4]

>>>aList[0]
1

>>>aList[2:]
[3,4]

>>>aList[:3]
[1,2,3]

1.12.2 更新列表中的值

>>>aList[1] = 5
>>>aList
[1,5,3,4]

1.12.3 删除列表中的值

>>> del aList[1]
>>>aList
[1,3,4]

1.12.4 Python列表脚本操作符

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

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]:       1 2 3             迭代
  print x 

1.12.5Python列表截取

Python的列表截取与字符串操作类型，如下所示

L = ['spam', 'Spam', 'SPAM!']
操作：

Python表达式     结果       描述
L[2]           'SPAM!'    读取列表中第三个元素
L[-2]          'Spam'     读取列表中倒数第二个元素(从右数0,1,2)
L[1:]      ['Spam', 'SPAM!'] 从第二个元素开始截取列表

1.12.6Python 列表 函数&方法

dir(list)可查看

Python包含以下函数:
序号   函数
1   cmp(list1, list2) 比较两个列表的元素
2   len(list) 列表元素个数
3   max(list) 返回列表元素最大值
4   min(list) 返回列表元素最小值
5   list(seq) 将元组转换为列表

Python包含以下方法:
序号   方法
1   list.append(obj)      在列表末尾添加新的对象
2   list.count(obj)       统计某个元素在列表中出现的次数
3   list.extend(seq)      在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4   list.index(obj)       从列表中找出某个值第一个匹配项的索引位置
5   list.insert(index, obj)  将对象插入列表
6   list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7   list.remove(obj)       移除列表中某个值的第一个匹配项
8   list.reverse()         反向列表中元素
9   list.sort([func])      对原列表进行排序

1.13 内建range函数

range([start,]end[,step])

>>> range(1,5) #代表从1到5(不包含5)
[1, 2, 3, 4]

>>> range(1,5,2) #代表从1到5，间隔2(不包含5)
[1, 3]

>>> range(5) #代表从0到5(不包含5)
[0, 1, 2, 3, 4]

>>>for eachNum in [0,1,2]:
... print eachNum

>>>for eachNum in range(3):
... print eachNum

>>>mystr = 'abc'
>>>for c in mystr:
... print c

range()函数还经常和len()函数一起用于字符串索引

1.14 元组 Tuple

Python的元组和列表类似，不同之处在于元组的元素不能修改。也可进行分片 和 连接操作。元组使用小括号，列表使用方括号

>>>aTuple = ('et',77,99.9)
>>>aTuple
('et',77,99.9)

1.14.1访问元素

>>>aTuple[2]
99

1.14.2修改元组

>>>aTuple[1] = 5 #真的不能修改呀
   报错啦

>>>tup2 = (1, 2, 3, 4, 5, 6, 7 )
>>>print "tup2[1:5]: ", tup2[1:5]
>>>tup2[1:5]: (2, 3, 4, 5)

>>>tup3 = tup2 + aTuple;
>>>print tup3
(1, 2, 3, 4, 5, 6, 7,'et',77,99.9)

1.14.3删除元素

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

1.14.4元组运算符

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

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

1.14.5元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中一段元素

L = ('spam', 'Spam', 'SPAM!')
Python 表达式 结果 描述
L[2] 'SPAM!' 读取第三个元素
L[-2] 'Spam' 反向读取；读取倒数第二个元素
L[1:] ('Spam', 'SPAM!') 截取元素

1.14.6无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组，如下实例

print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;
以上实例结果：

abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2

1.14.8多维元组访问的实例

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

1.15字典Dictionary

字典是python中的映射数据类型，由键值(key-value)构成，类似于关联数组或哈希表。key一般以数字和字符串居多，值则可以是任意类型的python对象，如其他容器模型。字典元素用大括号{ }包括，比如

>>>dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>>aDict = {'host':'noname'}

每个键与值用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})
键key必须独一无二，但值则不必。值value可以取任何数据类型，但必须是不可变的

1.15.1访问字典里的值

>>>aDict['host']
'noname'
>>> for key in aDict
... print key,aDict[key]
...
host noname
port 80

>>>aDict.keys()
['host','port']
>>>aDict.values()

1.15.2修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

>>>aDict['port'] = 80 #如果有port key,值将会被更新 否则会被新建一个port key
>>>aDict
{'host':'noname','port':80}

1.15.3删除字典元素

能删单一的元素也能清空字典，清空只需一项操作

删除一个字典用del命令

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dict['Name'];   # 删除键是'Name'的条目
dict.clear();       # 清空词典所有条目
del dict ;          # 删除词典

1.15.4字典键(key)的特性

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

两个重要的点需要记住：

1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个会被记住

>>>dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};
>>>print "dict['Name']: ", dict['Name'];
>>>dict['Name']: Manni

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

>>>dict = {['Name']: 'Zara', 'Age': 7};
>>>print "dict['Name']: ", dict['Name'];
    raceback (most recent call last):
    File "test.py", line 3, in <module>

>>>dict = {['Name']: 'Zara', 'Age': 7};
    TypeError: list objects are unhashable

#######1.15.5字典内置函数&方法
Python字典包含了以下内置函数

序号     函数及描述
1     cmp(dict1, dict2) 比较两个字典元素。
2     len(dict) 计算字典元素个数，即键的总数。
3     str(dict) 输出字典可打印的字符串表示。
4     type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置函数：
序号     函数及描述
1     radiansdict.clear() 删除字典内所有元素
2     radiansdict.copy() 返回一个字典的浅复制
3     radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4     radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5     radiansdict.has_key(key) 如果键在字典dict里返回true，否则返回false
6     radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7     radiansdict.keys() 以列表返回一个字典所有的键
8     radiansdict.setdefault(key, default=None)和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
9     radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10     radiansdict.values() 以列表返回字典中的所有值
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值

1.16 Python数字类型转换

int(x [,base ]) 将x转换为一个整数
long(x [,base ]) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返
回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串

1.17 Python数学函数

函数返回值 ( 描述 )
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
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
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
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的四舍五入值，如给出n值，则代表舍入到小数点后
的位数。
sqrt(x) 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sq
rt(4)返回 2+0j

1.18 Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性

函数 描述
choice(seq)  从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

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

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

seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

shuffle(lst) 将序列的所有元素随机排序

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

>>>import random
>>>dir(random) #查看文档

>>>mylist = [1,3,5,7,9]
>>>random.choice(mylist);  #在mylist中随机取值
>>>random.randrange(100)   #[1~100)随机取值
>>>random.random()         #[0,1)随机小数
>>>random.shuffle(mylist)  #乱序

2.字符串处理与特殊函数

用括号括起来的字符集合称之为字符串。引号可以是一对单引号，双引号，三引号（单/双）

备注：python中三引号可以将复杂的字符串进行复制：
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Python Programming"
var3 = '''hello chuanzhiboke'''
var4 = """hello chuanzhiboke"""

但是如果需要输出 Hello "dear"怎么办呢？

print "hello \"dear\"" #利用\的转义意义
print '''hello "dear"'''

2.1Python访问字符串中的值

Python不支持单字符类型，单字符也在Python作为一个字符串使用

Python访问子字符串，可以使用方括号来截取字符串——即分片操作

var1 = 'Hello World!'
var2 = "Python Programming"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

以上实例执行结果：
var1[0]: H
var2[1:5]: ytho

2.2 Python字符串更新

var1 = 'Hello World!'
print "Updated mystr :- ", var1[:6] + 'Python'
Updated mystr :- Hello Python

2.3Python字符串运算符

下表实例变量a值为字符串"Hello",b变量值为"Python"

操作符     描述&实例
+    字符串连接 a + b 输出结果： HelloPython
*    重复输出字符串 a*2 输出结果：HelloHello
[]   通过索引获取字符 a[1] 输出结果 e
[:]  截取字符串中的一部分 a[1:4] 输出结果 ell
in   成员运算符 如果字符串中包含给定的字符返回 True
not in 成员运算符 如果字符串中不包含给定的字符返回 True
r/R  原始字符串 字符串直接按照字面的意思来使用，没有转义或不能打印的
字符

原始字符串除在字符串的第一个引号前加上字母“r”（可以大小写）以外，与普通字符串有着几乎完全相同的语法

print r'hello\n' #hello\n

2.4Python字符串格式化

Python 支持格式化字符串的输出 。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
print "My name is %s and weight is %d kg!" % ('Zara', 21)

2.5字符串各种函数

以下start和end可以缺省参数

mystr = 'hello world itcast and itcastcpp'

检查str是否包含在mystr中，如果是 返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr))

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

返回str在start和end之间在mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))

3.时间和日期

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

Python有一个time and calendar模组可以帮忙

3.1什么是Tick

时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
Python附带的受欢迎的time模块下有很多函数可以转换常见日期格式。
如函数time.time()用ticks计时单位返回从12:00am, January 1, 1970(epoch)
开始的记录的当前操作系统时间.
>>>ticks = time.time()
print "Number of ticks since 12:00am, January 1, 1970:", ticks
Number of ticks since 12:00am, January 1, 1970: 7186862.73399

3.2什么是时间元组

序号  属性    值
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是决定是否为夏令时的旗帜

3.3获取当前时间

从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给localtime之类的函数

>>>import time;
>>>localtime = time.localtime(time.time())
>>>print "Local current time :", localtime

Local current time : time.struct_time(tm_year=2013, tm_mon=7,
tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=19
8, tm_isdst=0)

3.4获取格式化时间

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
localtime = time.asctime( time.localtime(time.time()) )
print "Local current time :", localtime
Local current time : Tue Jan 13 10:17:09 2009

3.5获取某月日历

>>>cal = calendar.month(2008, 1)
>>>print "Here is the calendar:"
>>>print cal;
Here is the calendar:
January 2008
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

3.6Time模块的内置函数

1 time.asctime([tupletime]) 
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二 18时07分14秒）的24个字符的字符串。

2 time.clock( )  
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。

3 time.sleep(secs) 
推迟调用线程的运行，secs指秒数。

4 time.time( ) 
返回当前时间的时间戳（1970纪元后经过的浮点秒数）Time模块包含了以下2个非常重要的属性：

序号 属性及描述
1 time.timezone
属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美
洲;<=0大部分欧洲，亚洲，非洲）。
2 time.tzname
属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。