导图社区 python
- 540
- 74
- 5
- 举报
python
Python高级应用技巧。Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。
编辑于2021-06-01 18:01:47- python知…
- python笔记
- 性能培训知识点
性能知识架构包含业务及架构知识、工具知识、系统知识、编程知识。具体内容包括性能测试类型，工具等、实战siege性能测试、HTTP协议、测试教程网的介绍、HTTP消息、cookie特性2、jemter录制回放、jemter插件机函数介绍等。
- 接口测试
接口测试是测试系统组件间接口的一种测试。接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点。测试的重点是要检查数据的交换，传递和控制管理过程，以及系统间的相互逻辑依赖关系等。
- python
Python高级应用技巧。Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。
python
社区模板帮助中心，点此进入>>
- 性能培训知识点
性能知识架构包含业务及架构知识、工具知识、系统知识、编程知识。具体内容包括性能测试类型，工具等、实战siege性能测试、HTTP协议、测试教程网的介绍、HTTP消息、cookie特性2、jemter录制回放、jemter插件机函数介绍等。
- 接口测试
接口测试是测试系统组件间接口的一种测试。接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点。测试的重点是要检查数据的交换，传递和控制管理过程，以及系统间的相互逻辑依赖关系等。
- python
Python高级应用技巧。Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。
- 相似推荐
- 大纲
python
环境搭建
python语法
交互式编程
脚本式编程
Python标识符
标识符有字母、数字、下划线组成。
所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头
标识符是区分大小写的
以下划线开头的标识符是有特殊意义的
以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用"from xxx import *"而导入；
以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__（）代表类的构造函数。
Python保留字符
and exec not assert finally or break for pass class from print continue global raise def if return del import try elif in while else is with except lambda yield
行和缩进
多行语句
可以使用斜杠（ \）将一行的语句分为多行显示
total = item_one + \ item_two + \ item_three
语句中包含[], {} 或 () 括号就不需要使用多行连接符
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
Python 引号
Python 接收单引号(' )，双引号(" )，三引号(''' """) 来表示字符串， 引号的开始与结束必须的相同类型的
word = 'word' sentence = "这是一个句子" paragraph = """这是一个段落 包含了多个语句"""
Python注释
python中单行注释采用 # 开头。
python 中多行注释使用三个单引号(''')或三个双引号(""")
Python空行
等待用户输入
下面的程序在按回车键后就会等待用户输入： #!/usr/bin/python raw_input("\n\nPress the enter key to exit.") 以上代码中 ，"\n\n"在结果输出前会输出两个新的空行。一旦用户按下键时，程序将退出。
同一行显示多条语句
#!/usr/bin/python import sys; x = 'w3cschool'; sys.stdout.write(x + '\n')
$ python test.py w3cschool
命令行参数
Python可以使用-h参数查看各参数帮助信息：
python变量
变量赋值
等号（=）用来给变量赋值。
多个变量赋值
Python允许你同时为多个变量赋值 a = b = c = 1
a, b, c = 1, 2, "john" 两个整型对象1和2的分配给变量a和b，字符串对象"john"分配给变量c。
标准数据类型（五个标准）
Numbers（数字）不可改变的数据类型
支持四种不同的数值类型
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）
String（字符串）
由数字、字母、下划线组成的一串字符
2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
List（列表）
支持字符，数字，字符串甚至可以包含列表（所谓嵌套）
列表用[ ]标识。是python最通用的复合数据类型
列表是有序的对象结合，字典是无序的对象集合
Tuple（元组）
元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开
但是元素不能二次赋值，相当于只读列表。
Dictionary（字典）
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型
列表是有序的对象结合，字典是无序的对象集合
字典用"{ }"标识
字典由索引(key)和它对应的值value组成
Python数据类型转换
Python 运算符
算术运算符
+ - * / %
**
幂 - 返回x的y次幂
//
取整除 - 返回商的整数部分
比较（关系）运算符
==
等于 - 比较对象是否相等 (a == b) 返回 False。
!=
不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。这个运算符类似 != 。
>
>=
赋值运算符
=
简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+=
加法赋值运算符 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
逻辑运算符
and
or
not
位运算符
成员运算符
in
not in
运算符优先级
**
指数 (最高优先级)
~ + -
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //
+ -
>> <<
&
位 'AND'
^ |
位运算符
<= < > >=
比较运算符
<> == !=
等于运算符
= %= /= //= -= += *= **=
赋值运算符
is is not
身份运算符
in not in
成员运算符
not or and
逻辑运算符
Python 条件语句
Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false
Python 编程中 if 语句用于控制程序的执行
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句
if 语句的判断条件可以用>（大于）、=（大于等于）、<=（小于等于）来表示其关系
Python 循环语句
循环语句
while 循环
在给定的判断条件为 true 时执行循环体，否则退出循环体。
无限循环
for 循环
重复执行语句
语法
for循环的语法格式如下： for iterating_var in sequence: statements(s)
通过序列索引迭代
#!/usr/bin/python # -*- coding: UTF-8 -*- fruits = ['banana', 'apple', 'mango'] for index in range(len(fruits)): print '当前水果 :', fruits[index] print "Good bye!"
循环使用 else 语句
for … else
嵌套循环
你可以在while循环体中嵌套for循环
语法
Python for 循环嵌套语法：
for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s)
Python while 循环嵌套语法：
while expression: while expression: statement(s) statement(s)
循环控制语句
break 语句
在语句块执行过程中终止循环，并且跳出整个循环
for letter in 'Python': # First Example if letter == 'h': break print 'Current Letter :', letter var = 10 # Second Example while var > 0: print 'Current variable value :', var var = var -1 if var == 5: break print "Good bye!"
Current Letter : P Current Letter : y Current Letter : t Current variable value : 10 Current variable value : 9 Current variable value : 8 Current variable value : 7 Current variable value : 6 Good bye!
像在C语言中，打破了最小封闭for或while循环
用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句
break语句用在while和for循环中
continue 语句
在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
for letter in 'Python': # 第一个实例 if letter == 'h': continue print '当前字母 :', letter var = 10 # 第二个实例 while var > 0: var = var -1 if var == 5: continue print '当前变量值 :', var print "Good bye!"
当前字母 : P 当前字母 : y 当前字母 : t 当前字母 : o 当前字母 : n 当前变量值 : 9 当前变量值 : 8 当前变量值 : 7 当前变量值 : 6 当前变量值 : 4 当前变量值 : 3 当前变量值 : 2 当前变量值 : 1 当前变量值 : 0 Good bye!
continue 语句跳出本次循环，而break跳出整个循环
continue语句用在while和for循环中。
pass 语句
pass是空语句，是为了保持程序结构的完整性。
# 输出 Python 的每个字母 for letter in 'Python': if letter == 'h': pass print '这是 pass 块' print '当前字母 :', letter print "Good bye!"
子主题 1当前字母 : P 当前字母 : y 当前字母 : t 这是 pass 块 当前字母 : h 当前字母 : o 当前字母 : n Good bye!
passass 不做任何事情，一般用做占位语句
python五种数据类型
Python 数字
Python 数字数据类型用于存储数值
数据类型是不允许改变的
支持四种不同的数值类型
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）
Python数学函数
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]范围内。
Python三角函数
Python数学常量
Python 字符串
可以使用引号('或")来创建字符串
访问字符串中的值
不支持单字符类型，单字符也在Python也是作为一个字符串使用
访问子字符串，可以使用方括号来截取字符串
#!/usr/bin/python var1 = 'Hello World!' var2 = "Python Runoob" print "var1[0]: ", var1[0] print "var2[1:5]: ", var2[1:5]
var1[0]: H var2[1:5]: ytho
字符串更新
对已存在的字符串进行修改，并赋值给另一个变量
var1 = 'Hello World!' print "更新字符串 :- ", var1[:6] + 'Runoob!'
更新字符串 :- Hello Runoob!
转义字符
字符串运算符
+ 、* 、[] 、[：]、 in 、not in、r/R
字符串格式化
最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中
字符串格式化使用与 C 中 sprintf 函数一样的语法
#!/usr/bin/python print "My name is %s and weight is %d kg!" % ('Zara', 21)
My name is Zara and weight is 21 kg!
python字符串格式化符号
%c
格式化字符及其ASCII码
%s
格式化字符串
%d
格式化整数
%u
格式化无符号整型
%o
格式化无符号八进制数
%x
格式化无符号十六进制数
%X
格式化无符号十六进制数（大写）
%f
格式化浮点数字，可指定小数点后的精度
%e
用科学计数法格式化浮点数
%E
作用同%e，用科学计数法格式化浮点数
%g
子主题 1%f和%e的简写
%p
用十六进制数格式化变量的地址
Python三引号
三引号可以将复杂的字符串进行复制
三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）
>>> hi = '''hi there''' >>> hi # repr() 'hi\nthere' >>> print hi # str() hi there
Unicode 字符串
Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单
>>> u'Hello World !' u'Hello World !'
引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码
>>> u'Hello\u0020World !' u'Hello World !'
字符串内建函数
这些方法实现了string模块的大部分方法
所有的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的
Python 列表(List)
属性
第一个索引是0，第二个索引是1，依此类推
序列都可以进行的操作包括索引，切片，加，乘，检查成员
Python有6个序列的内置类型，但最常见的是列表和元组
Python已经内置确定序列的长度以及确定最大和最小的元素的方法
list1 = ['physics', 'chemistry', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; list3 = ["a", "b", "c", "d"];
访问列表中的值
list1 = ['physics', 'chemistry', 1997, 2000]; list2 = [1, 2, 3, 4, 5, 6, 7 ]; print "list1[0]: ", list1[0] print "list2[1:5]: ", list2[1:5]
list1[0]: physics list2[1:5]: [2, 3, 4, 5]
更新列表
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项
#!/usr/bin/python list = ['physics', 'chemistry', 1997, 2000]; print "Value available at index 2 : " print list[2]; list[2] = 2001; print "New value available at index 2 : " print list[2];
Value available at index 2 : 1997 New value available at index 2 : 2001
删除列表元素
可以使用 del 语句来删除列表的的元素
#!/usr/bin/python list1 = ['physics', 'chemistry', 1997, 2000]; print list1; del list1[2]; print "After deleting value at index 2 : " print list1;
['physics', 'chemistry', 1997, 2000] After deleting value at index 2 : ['physics', 'chemistry', 2000]
Python列表脚本操作符
属性
子主题 1列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
表达式
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] 'Taobao' 读取列表中第三个元素
L[-2] 'Runoob' 读取列表中倒数第二个元素
L[1:] ['Runoob', 'Taobao'] 从第二个元素开始截取列表
Python列表函数&方法
函数
cmp(list1, list2) 比较两个列表的元素
len(list) 列表元素个数
max(list) 返回列表元素最大值
min(list) 返回列表元素最小值
list(seq) 将元组转换为列表
方法
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort([func]) 对原列表进行排序
Python 元组
属性
元组使用小括号，列表使用方括号
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
Python的元组与列表类似，不同之处在于元组的元素不能修改
访问元组
元组可以使用下标索引来访问元组中的值
#!/usr/bin/python tup1 = ('physics', 'chemistry', 1997, 2000); tup2 = (1, 2, 3, 4, 5, 6, 7 ); print "tup1[0]: ", tup1[0] print "tup2[1:5]: ", tup2[1:5]
tup1[0]: physics tup2[1:5]: (2, 3, 4, 5)
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1 = (12, 34.56); tup2 = ('abc', 'xyz'); # 以下修改元组元素操作是非法的。 # tup1[0] = 100; # 创建一个新的元组 tup3 = tup1 + tup2; print tup3;
1(12, 34.56, 'abc', 'xyz')
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
#!/usr/bin/python tup = ('physics', 'chemistry', 1997, 2000); print tup; del tup; print "After deleting tup : " print tup;
('physics', 'chemistry', 1997, 2000) After deleting tup : Traceback (most recent call last): File "test.py", line 9, in <module> print tup; NameError: name 'tup' is not defined
元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算
表达式
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!') 截取元素
无关闭分隔符
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
元组内置函数
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值
tuple(seq) 将列表转换为元组
Python 字典(Dictionary)
属性
字典的每个键值(key=>value)对用冒号(:)分割， 每个对之间用逗号(,)分割，整个字典包括在花括号({})中, 示例：d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。值可以取任何数据类型， 但键必须是不可变的，如字符串，数字或元组
访问字典里的值
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; print "dict['Name']: ", dict['Name']; print "dict['Age']: ", dict['Age'];
dict['Name']: Zara dict['Age']: 7
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; dict['Age'] = 8; # update existing entry dict['School'] = "DPS School"; # Add new entry print "dict['Age']: ", dict['Age']; print "dict['School']: ", dict['School'];
dict['Age']: 8 dict['School']: DPS School
删除字典元素
能删单一的元素也能清空字典 清空只需一项操作。 显示删除一个字典用del命令
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}; del dict['Name']; # 删除键是'Name'的条目 dict.clear(); # 清空词典所有条目 del dict ; # 删除词典 print "dict['Age']: ", dict['Age']; print "dict['School']: ", dict['School'];
字典键的特性
1）不允许同一个键出现两次。 创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当， 所以用列表就不行
#!/usr/bin/python dict = {['Name']: 'Zara', 'Age': 7}; print "dict['Name']: ", dict['Name'];
Traceback (most recent call last): File "test.py", line 3, in <module> dict = {['Name']: 'Zara', 'Age': 7}; TypeError: list objects are unhashable
字典内置函数&方法
函数
cmp(dict1, dict2) 比较两个字典元素。
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典可打印的字符串表示。
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
方法
dict.clear() 删除字典内所有元素
dict.copy() 返回一个字典的浅复制
dict.fromkeys(seq[, val])) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
dict.has_key(key) 如果键在字典dict里返回true，否则返回false
dict.items() 以列表返回可遍历的(键, 值) 元组数组
dict.keys() 以列表返回一个字典所有的键
dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2) 把字典dict2的键/值对更新到dict里
dict.values() 以列表返回字典中的所有值
Python 日期和时间
属性
很多方式处理日期和时间，转换日期格式是一个常见的功能
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间
时间间隔是以秒为单位的浮点小数
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示
Python 的 time 模块下有很多函数可以转换常见日期格式。 如函数time.time()用于获取当前时间戳
import time; # 引入time模块 ticks = time.time() print "当前时间戳为:", ticks
当前时间戳为: 1459994552.51
获取当前时间
从返回浮点数的时间辍方式向时间元组转换， 只要将浮点数传递给如localtime之类的函数。
import time localtime = time.localtime(time.time()) print "本地时间为 :", localtime
本地时间为 : 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():
import time localtime = time.asctime( time.localtime(time.time()) ) print "本地时间为 :", localtime
本地时间为 : Thu Apr 7 10:05:21 2016
格式化日期
使用 time 模块的 strftime 方法来格式化日期 time.strftime(format[, t])
import time # 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 格式化成Sat Mar 28 22:24:24 2016形式 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"))
获取某月日历
Calendar模块
import calendar cal = calendar.month(2016, 1) print "以下输出2016年1月份的日历:" print cal;
以下输出2016年1月份的日历: 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
Time 模块
time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
time.asctime([tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
time.ctime([secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime()
time.gmtime([secs]) 接收时间辍（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
time.mktime(tupletime) 接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）。
time.sleep(secs) 推迟调用线程的运行，secs指秒数。
time.strftime(fmt[,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据fmt的格式把一个时间字符串解析为时间元组。
time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
time.tzset() 根据环境变量TZ重新初始化时间相关设置。
日历（Calendar）模块
calendar.calendar(year,w=2,l=1,c=6) 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
calendar.firstweekday( ) 返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。
calendar.isleap(year) 是闰年返回True，否则为false。
calendar.leapdays(y1,y2) 返回在Y1，Y2两年之间的闰年总数。
calendar.month(year,month,w=2,l=1) 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
calendar.monthcalendar(year,month) 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
calendar.monthrange(year,month) 返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
calendar.prcal(year,w=2,l=1,c=6) 相当于 print calendar.calendar(year,w,l,c).
calendar.prmonth(year,month,w=2,l=1) 相当于 print calendar.calendar（year，w，l，c）。
calendar.setfirstweekday(weekday) 设置每周的起始日期码。0（星期一）到6（星期日）。
calendar.timegm(tupletime) 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间辍（1970纪元后经过的浮点秒数）。
calendar.weekday(year,month,day) 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。
Python 函数
属性
已创建好可以使用的为内建函数
也可以自己创建函数，这被叫做用户自定义函数
定义一个函数
规则
以 def 关键词开头，后接函数标识符名称和圆括号()
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
语法
def printme( str ): "打印传入的字符串到标准显示设备上" print str return
函数调用
# 定义函数 def printme( str ): "打印任何传入的字符串" print str; return; # 调用函数 printme("我要调用用户自定义函数!"); printme("再次调用同一函数");
参数传递
在 python 中，strings, tuples, 和 numbers 是不可更改的对象， 而 list,dict 等则是可以修改的对象
参数
参数类型
必备参数
关键字参数
默认参数
不定长参数
return 语句
属性
return语句[表达式]退出函数，选择性地向调用方返回一个表达式
不带参数值的return语句返回None
示例
# 可写函数说明 def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print "函数内 : ", total return total; # 调用sum函数 total = sum( 10, 20 );
函数内 : 30
变量作用域
类型
全局变量
局部变量
示例
total = 0; # 这是一个全局变量 # 可写函数说明 def sum( arg1, arg2 ): #返回2个参数的和." total = arg1 + arg2; # total在这里是局部变量. print "函数内是局部变量 : ", total return total; #调用sum函数 sum( 10, 20 ); print "函数外是全局变量 : ", total
函数内是局部变量 : 30 函数外是全局变量 : 0
Python 模块
import 语句
import module1[, module2[,... moduleN]
当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入
如想要导入模块 support.py，需要把命令放在脚本的顶端
# 导入模块 import support # 现在可以调用模块里包含的函数了 support.print_func("Runoob")
一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行
From…import 语句
从模块中导入 一个指定的部分 到当前命名空间中
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句： from fib import fibonacci 这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。
From…import* 语句
把一个模块的所有内容全都导入到当前的命名空间from modname import *
对模块的搜索顺序是
1、当前目录
2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
注意：模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
PYTHONPATH 变量
典型的 PYTHONPATH 如下： set PYTHONPATH=c:\python27\lib;
在 UNIX 系统，典型的 PYTHONPATH 如下： set PYTHONPATH=/usr/local/lib/python
命名空间和作用域
dir()函数
dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字
使用dir()函数可以查看对像内所有属于及方法
操作方法很简单，只需要把你想要查询和对像添写到( )括号中就可以使用了
要查看python某个模块可以干什么，先要导入模块，之后用上面讲过的方式查看就可以。比如要查看sys模块都可以干什么，可以像下边这样操作：
import sys dir(sys)
globals() 和 locals() 函数
locals - 局部名字空间
globals - 全局名字空间
reload() 函数
作用：重新执行模块里顶层部分的代码，示例：reload(module_name)
module_name要直接放模块的名字，而不是一个字符串形式。 比如想重载 hello 模块，如下：reload(hello)
Python中的包
简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包
知识点
import sys 系统相关的信息模块
sys.argv 是一个 list,包含所有的命令行参数. sys.stdout sys.stdin sys.stderr 分别表示标准输入输出,错误输出的文件对象. sys.stdin.readline() 从标准输入读一行 sys.stdout.write("a") 屏幕输出a sys.exit(exit_code) 退出程序 sys.modules 是一个dictionary，表示系统中所有可用的module sys.platform 得到运行的操作系统环境 sys.path 是一个list,指明所有查找module，package的路径.
import os 操作系统相关的调用和操作
os.environ 一个dictionary 包含环境变量的映射关系 os.environ["HOME"] 可以得到环境变量HOME的值 os.chdir(dir) 改变当前目录 os.chdir('d:\\outlook') 注意windows下用到转义 os.getcwd() 得到当前目录 os.getegid() 得到有效组id os.getgid() 得到组id os.getuid() 得到用户id os.geteuid() 得到有效用户id os.setegid os.setegid() os.seteuid() os.setuid() os.getgruops() 得到用户组名称列表 os.getlogin() 得到用户登录名称 os.getenv 得到环境变量 os.putenv 设置环境变量 os.umask 设置umask os.system(cmd) 利用系统调用，运行cmd命令
内置模块 不用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
类型转换
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) 转换成一个long interger float(x) 转换成一个浮点数 complex(x) 转换成复数 max(...) 求最大值 min(...) 求最小值
Python 文件I/O
打印到屏幕
print语句
读取键盘输入
raw_input
raw_input([prompt]) 从标准输入读取一个行，并返回一个字符串（去掉结尾换行符）
#!/usr/bin/python # -*- coding: UTF-8 -*- str = raw_input("请输入："); print "你输入的内容是: ", str
请输入：Hello Python！ 你输入的内容是: Hello Python！
input
input 可以接收一个Python表达式作为输入，并将运算结果返回。
#!/usr/bin/python # -*- coding: UTF-8 -*- str = input("请输入："); print "你输入的内容是: ", str
请输入：[x*5 for x in range(2,10,2)] 你输入的内容是: [10, 20, 30, 40]
打开和关闭文件
打开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.closed 返回true如果文件已被关闭，否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
file.softspace 如果用print输出后跟一个空格符，则返回false。否则返回true。
close()方法
fileObject.close();
write()方法
write()方法可将任何字符串写入一个打开的文件
Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符('\n')：
格式：fileObject.write(string);
read()方法
格式：fileObject.read([count]);
从已打开文件中读取的字节计数
该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
文件定位
tell()定位当前文件位置
seek（offset [,from]）方法改变当前文件的位置
Offset变量表示要移动的字节数
From变量指定开始移动字节的参考位置。
0，将文件的开头作为移动字节的参考位置
1，使用当前的位置作为参考位置
2，该文件的末尾将作为参考位置
重命名和删除文件（OS）
使用这个模块，你必须先导入它，然后才可以调用相关的各种功能。
rename()重命名方法
需要两个参数，当前的文件名和新文件名 os.rename(current_file_name, new_file_name)
remove()删除方法
os.remove(file_name)
Python里的目录
mkdir()创建方法
os.mkdir("newdir")
chdir()改变当前路径方法
os.chdir("newdir")
getcwd()显示当前工作目录
os.getcwd()
rmdir()删除方法
os.rmdir('dirname')
Python File(文件) 方法
file.close() 关闭文件。关闭后文件不能再进行读写操作
file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno(） 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
file.next() 返回文件下一行。
file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有
file.readline([size]) 读取整行，包括 "\n" 字符。
file.readlines([sizehint]) 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
file.seek(offset[, whence]) 设置文件当前位置
file.tell() 返回文件当前位置
file.truncate([size]) 截取文件，截取的字节通过size指定，默认为当前文件位置
file.write(str) 将字符串写入文件，没有返回值
file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符
Python 异常处理
标准异常
异常处理
捕捉异常 - try/except语句
try语句 使用缩进结构，可选else语句块
try: <语句> #运行别的代码 except <名字>： <语句> #如果在try部份引发了'name'异常 except <名字>，<数据>: <语句> #如果引发了'name'异常，获得附加的数据 else: <语句> #如果没有异常发生
excep语句
使用except而不带任何异常类型
try: 正常的操作 ...................... except: 发生异常，执行这块代码 ...................... else: 如果没有异常执行这块代码
使用except而带多种异常类型
try: 正常的操作 ...................... except(Exception1[, Exception2[,...ExceptionN]]]): 发生以上多个异常中的一个，执行这块代码 ...................... else: 如果没有异常执行这块代码
try-finally 语句
无论是否发生异常都将执行最后的代码
异常的参数
触发异常
使用raise语句
raise [Exception [, args [, traceback]]]
Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是"None"。
最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象
用户自定义异常
Python 内置函数