python 输出 "Hello, World!"，英文没有问题，可是若是你输出中文字符"你好，世界"就有可能会碰到中文编码问题。
html
解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就好了 python
在python里，标识符有字母、数字、下划线组成。 git
在python中，全部标识符能够包括英文、数字以及下划线（_），但不能以数字开头。 shell
python中的标识符是区分大小写的。 api
如下划线开头的标识符是有特殊意义的。以单下划线开头（_foo）的表明不能直接访问的类属性，需经过类提供的接口进行访问，不能用"from xxx import *"而导入； 数组
以双下划线开头的（__foo）表明类的私有成员；以双下划线开头和结尾的（__foo__）表明python里特殊方法专用的标识，如__init__（）表明类的构造函数。 数据结构
python中单行注释采用 # 开头。python没有块注释，因此如今推荐的多行注释也是采用的 # app
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。 dom
空行与代码缩进不一样，空行并非Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。可是空行的做用在于分隔两段不一样功能或含义的代码，便于往后代码的维护或重构。 函数
记住：空行也是程序代码的一部分。
python能够在同一行中使用多条语句，语句之间使用分号(;)分割
缩进相同的一组语句构成一个代码块，咱们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行以后的一行或多行代码构成代码组。咱们将首行及后面的代码组称为一个子句(clause)。
$ python -h usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... Options and arguments (and corresponding environment variables): -c cmd : program passed in as string (terminates option list) -d : debug output from parser (also PYTHONDEBUG=x) -E : ignore environment variables (such as PYTHONPATH) -h : print this help message and exit [ etc. ]
Python中的变量不须要声明，变量的赋值操做既是变量声明和定义的过程。
每一个变量在内存中建立，都包括变量的标识，名称和数据这些信息。
每一个变量在使用前都必须赋值，变量赋值之后该变量才会被建立。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
使用del语句删除单个或多个对象， del 语句来删除列表的的元素
Python容许你同时为多个变量赋值。例如：
也能够为多个对象指定多个变量。例如：
python标准数据类型：
| int | long | float | complex |
|---|---|---|---|
| 10 | 51924361L | 0.0 | 3.14j |
| 100 | -0x19323L | 15.20 | 45.j |
| -786 | 0122L | -21.9 | 9.322e-36j |
| 080 | 0xDEFABCECBDAECBFBAEl | 32.3+e18 | .876j |
| -0490 | 535633629843L | -90. | -.6545+0J |
| -0x260 | -052318172735L | -32.54e100 | 3e+26J |
| 0x69 | -4721885298529L | 70.2-E12 | 4.53e-7j |
python的字串列表有2种取值顺序:
若是你的实要取得一段子串的话，能够用到变量[头下标:尾下标]，就能够截取相应的字符串，其中下标是从0开始算起，能够是正数或负数，下标能够为空表示取到头或尾。
List（列表） 是 Python 中使用最频繁的数据类型。列表能够完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至能够包含列表（所谓嵌套）。
列表用[ ]标识，用逗号分开。是python最通用的复合数据类型。看这段代码就明白。
列表中的值得分割也能够用到变量[头下标:尾下标]，就能够截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标能够为空表示取到头或尾。
加号（+）是列表链接运算符，星号（*）是重复操做。以下实例：
元组是另外一个数据类型，相似于List（列表）。
元组用"()"标识，内部元素用逗号隔开。可是元素不能二次赋值，至关于只读列表。
字典(dictionary)是除列表之外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。
二者之间的区别在于：字典当中的元素是经过键来存取的，而不是经过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成，
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
| 函数 | 描述 |
|---|---|
| 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 转换为一个列表 |
| set(s) |
转换为可变集合 |
| dict(d) |
建立一个字典。d 必须是一个序列 (key,value)元组。 |
| frozenset(s) |
转换为不可变集合 |
| chr(x) |
将一个整数转换为一个字符 |
| unichr(x) |
将一个整数转换为Unicode字符 |
| ord(x) |
将一个字符转换为它的整数值 |
| hex(x) |
将一个整数转换为一个十六进制字符串 |
| oct(x) |
将一个整数转换为一个八进制字符串 |
如下假设变量a为10，变量b为20
| 算术运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 获得负数或是一个数减去另外一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
| 比较运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等 | (a <> b) 返回 true。这个运算符相似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。全部比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (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 |
| 位运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
| 逻辑运算符 | 描述 | 实例 |
|---|---|---|
| and | 布尔"与" - 若是x为False，x and y返回False，不然它返回y的计算值。 | (a and b) 返回 true。 |
| or | 布尔"或" - 若是x是True，它返回True，不然它返回y的计算值。 | (a or b) 返回 true。 |
| not | 布尔"非" - 若是x为True，返回False。若是x为False，它返回True。 | not(a and b) 返回 false。 |
| 成员运算符 | 描述 | 实例 |
|---|---|---|
| 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) , is 返回结果 1 |
| is not | is not是判断两个标识符是否是引用自不一样对象 | x is not y, 若是 id(x) 不等于 id(y). is not 返回结果 1 |
if 判断条件1: 执行语句1…… elif 判断条件2: 执行语句2…… elif 判断条件3: 执行语句3…… else: 执行语句4……
while 判断条件：
执行语句……
for iterating_var in sequence: statements(s)
| 循环控制语句 | 描述 |
|---|---|
| break | 在语句块执行过程当中终止循环，而且跳出整个循环 |
| continue | 在语句块执行过程当中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass | pass是空语句，是为了保持程序结构的完整性。 |
| 函数 | 返回值 ( 描述 ) |
|---|---|
| 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.sqrt(4)返回 2+0j |
| 随机函数 | 描述 |
|---|---|
| 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]范围内。 |
| 三角函数 | 描述 | |
|---|---|---|
| acos(x) | 返回x的反余弦弧度值。 | |
| asin(x) | 返回x的反正弦弧度值。 | |
| atan(x) | 返回x的反正切弧度值。 | |
| atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。 | |
| cos(x) | 返回x的弧度的余弦值。 | |
| hypot(x, y) | 返回欧几里德范数 sqrt(x*x + y*y)。 | |
| sin(x) | 返回的x弧度的正弦值。 | |
| tan(x) | 返回x弧度的正切值。 | |
| degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 | |
| radians(x) | 将角度转换为弧度 |
| 数学常量 | 描述 |
|---|---|
| pi | 数学常量 pi（圆周率，通常以π来表示） |
| e | 数学常量 e，e即天然常数（天然常数）。 |
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy表明的字符，例如：\o12表明换行 |
| \xyy | 十六进制数，yy表明的字符，例如：\x0a表明换行 |
| \other | 其它的字符以普通格式输出 |
| 字符串操做符 | 描述 | 实例 |
|---|---|---|
| + | 字符串链接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 经过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 若是字符串中包含给定的字符返回 True | H in a 输出结果 1 |
| not in | 成员运算符 - 若是字符串中不包含给定的字符返回 True | M not in a 输出结果 1 |
| r/R | 原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（能够大小写）之外，与普通字符串有着几乎彻底相同的语法。 | print r'\n' prints \n 和 print R'\n'prints \n |
| % | 格式字符串 | 请看下一章节 |
python字符串格式化符号:
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 做用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操做符辅助指令:
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用作左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'仍是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(若是可用的话) |
python中三引号能够将复杂的字符串进行复制:
python三引号容许一个字符串跨多行，字符串中能够包含换行符、制表符以及其余特殊字符。
三引号的语法是一对连续的单引号或者双引号（一般都是成对的用）。
引号前小写的"u"表示这里建立的是一个 Unicode 字符串。若是你想加入一个特殊字符，可使用 Python 的 Unicode-Escape 编码。以下例所示：
>>> u'Hello\u0020World !' u'Hello World !'
被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。
这些方法实现了string模块的大部分方法，以下表所示列出了目前字符串内建支持的方法，全部的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。
| 方法 | 描述 |
|---|---|
| 把字符串的第一个字符大写 |
|
| 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
|
| 返回 str 在 string 里面出现的次数，若是 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
|
| 以 encoding 指定的编码格式解码 string，若是出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' |
|
| 以 encoding 指定的编码格式编码 string，若是出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
|
| 检查字符串是否以 obj 结束，若是beg 或者 end 指定则检查指定的范围内是否以 obj 结束，若是是，返回 True,不然返回 False. |
|
| 把字符串 string 中的 tab 符号转为空格，默认的空格数 tabsize 是 8. |
|
| 检测 str 是否包含在 string 中，若是 beg 和 end 指定范围，则检查是否包含在指定范围内，若是是返回开始的索引值，不然返回-1 |
|
| 跟find()方法同样，只不过若是str不在 string中会报一个异常. |
|
| 若是 string 至少有一个字符而且全部字符都是字母或数字则返 回 True,不然返回 False |
|
| 若是 string 至少有一个字符而且全部字符都是字母则返回 True, 不然返回 False |
|
| 若是 string 只包含十进制数字则返回 True 不然返回 False. |
|
| 若是 string 只包含数字则返回 True 不然返回 False. |
|
| 若是 string 中包含至少一个区分大小写的字符，而且全部这些(区分大小写的)字符都是小写，则返回 True，不然返回 False |
|
| 若是 string 中只包含数字字符，则返回 True，不然返回 False |
|
| 若是 string 中只包含空格，则返回 True，不然返回 False. |
|
| 若是 string 是标题化的(见 title())则返回 True，不然返回 False |
|
| 若是 string 中包含至少一个区分大小写的字符，而且全部这些(区分大小写的)字符都是大写，则返回 True，不然返回 False |
|
| Merges (concatenates)以 string 做为分隔符，将 seq 中全部的元素(的字符串表示)合并为一个新的字符串 |
|
| 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
|
| 转换 string 中全部大写字符为小写. |
|
| 截掉 string 左边的空格 |
|
| maketrans() 方法用于建立字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示须要转换的字符，第二个参数也是字符串表示转换的目标。 |
|
| 返回字符串 str 中最大的字母。 |
|
| 返回字符串 str 中最小的字母。 |
|
| 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),若是 string 中不包含str 则 string_pre_str == string. |
|
| 把 string 中的 str1 替换成 str2,若是 num 指定，则替换不超过 num 次. |
|
| 相似于 find()函数，不过是从右边开始查找. |
|
| 相似于 index()，不过是从右边开始. |
|
| 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
|
| string.rpartition(str) |
相似于 partition()函数,不过是从右边开始查找. |
| 删除 string 字符串末尾的空格. |
|
| 以 str 为分隔符切片 string，若是 num有指定值，则仅分隔 num 个子字符串 |
|
| 按照行分隔，返回一个包含各行做为元素的列表，若是 num 指定则仅切片 num 个行. |
|
| 检查字符串是不是以 obj 开头，是则返回 True，不然返回 False。若是beg 和 end 指定值，则在指定范围内检查. |
|
| 在 string 上执行 lstrip()和 rstrip() |
|
| 翻转 string 中的大小写 |
|
| 返回"标题化"的 string,就是说全部单词都是以大写开始，其他字母均为小写(见 istitle()) |
|
| 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 |
|
| 转换 string 中的小写字母为大写 |
|
| 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
|
| isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
cmp：
若是比较的元素是同类型的,则比较其值,返回结果。
若是两个元素不是同一种类型,则检查它们是不是数字。
若是有一个列表首先到达末尾,则另外一个长一点的列表"大"。
若是咱们用尽了两个列表的元素并且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0。
| 序号 | 函数 |
|---|---|
| 1 | cmp(list1, list2) 比较两个列表的元素 |
| 2 | len(list) 列表元素个数 |
| 3 | max(list) 返回列表元素最大值 |
| 4 | min(list) 返回列表元素最小值 |
| 5 | list(seq) 将元组转换为列表 |
| 序号 | 方法 |
|---|---|
| 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]) 对原列表进行排序 |
元组中的元素值是不容许删除的，但咱们可使用del语句来删除整个元组。
元组使用小括号，列表使用方括号。
元组建立很简单，只须要在括号中添加元素，并使用逗号隔开便可。
以下实例：
tup1 = ('physics', 'chemistry', 1997, 2000); tup2 = (1, 2, 3, 4, 5 ); tup3 = "a", "b", "c", "d";
建立空元组
tup1 = ();
元组中只包含一个元素时，须要在元素后面添加逗号
tup1 = (50,);
元组与字符串相似，下标索引从0开始，能够进行截取，组合等。
python 字典
能删单一的元素也能清空字典，清空只需一项操做。
显示删除一个字典用del命令，以下实例：
#coding=utf-8
#!/usr/bin/python
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 | 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() 以列表返回字典中的全部值 |
如下实例示了 update()函数的使用方法：
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2)
print "Value : %s" % dict
以上实例输出结果为：
Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
#!/usr/bin/python import time; # This is required to include time module. ticks = time.time() print "Number of ticks since 12:00am, January 1, 1970:", ticks
localtime
Number of ticks since 12:00am, January 1, 1970: 7186862.73399
#!/usr/bin/python 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=198, tm_isdst=0)
calendar
#!/usr/bin/python import calendar 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
按值传参和按引用传参数：全部参数（自变量）在Python里都是按引用传递。若是你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了
必备参数
#coding=utf-8 #!/usr/bin/python #可写函数说明 def printme( str ): "打印任何传入的字符串" print str; return; #调用printme函数 printme(); #缺乏必备参数，发生错误
命名参数
#coding=utf-8 #!/usr/bin/python #可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" );缺省参数
#coding=utf-8 #!/usr/bin/python #可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" ); printinfo( name="miki" );不定长参数
#coding=utf-8
#!/usr/bin/python
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple:
print var
return;
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 ); 匿名函数
#coding=utf-8 #!/usr/bin/python #可写函数说明 sum = lambda arg1, arg2: arg1 + arg2; #调用sum函数 print "Value of total : ", sum( 10, 20 ) print "Value of total : ", sum( 20, 20 )return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。以前的例子都没有示范如何返回数值
定义在函数内部的变量拥有一个局部做用域，定义在函数外的拥有全局做用域。
局部变量只能在其被声明的函数内部访问，而全局变量能够在整个程序范围内访问。调用函数时，全部在函数内声明的变量名称都将被加入到做用域中。
Python模块import语句
#coding=utf-8
#!/usr/bin/python
# 导入模块
import support
# 如今能够调用模块里包含的函数了
support.print_func("Zara") from ...import .../*
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
个函数都有本身的命名空间。类的方法的做用域规则和一般函数的同样。
Python会智能地猜想一个变量是局部的仍是全局的，它假设任何在函数内赋值的变量都是局部的。
所以，若是要给全局变量在一个函数里赋值，必须使用global语句。
global VarName的表达式会告诉Python， VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。
dir()函数一个排好序的字符串列表，在一个模块里定义的全部模块，变量和函数
#coding=utf-8 #!/usr/bin/python # 导入内置math模块 import math content = dir(math) print content;
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境。
考虑一个在Phone目录下有以下文件：
如今，在Phone目录下建立file __init__.py：
from Pots import Pots from Isdn import Isdn from G3 import G3当你把这些代码添加到__init__.py以后，导入Phone包的时候这些类就全都是可用的了。
#coding=utf-8 #!/usr/bin/python # Now import your Phone Package. import Phone Phone.Pots() Phone.Isdn() Phone.G3()
捕捉异常可使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
若是你不想在异常发生时结束你的程序，只需在try里捕获它。
try-finally 语句不管是否发生异常都将执行最后的代码#!/usr/bin/python
try:
fh = open("testfile", "w")
fh.write("This is my test file for exception handling!!")
except IOError: #异常类型，可无，可多个
print "Error: can\'t find file or read data"
else:
print "Written content in the file successfully"