基础语法
<img />技术小贴
变量
变量存储在内存中的值。这就意味着在创建变量时**在内存中开辟一个空间。
基于变量的数据类型，解释器**分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。
变量赋值
#coding=utf-8
#!/usr/bin/python
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print counter
print miles
print name
多个变量赋值
Python允许你同时为多个变量赋值,也可以为多个对象指定多个变量。
a = b = c = 1
a, b, c = 1, 2, "john"
查看变量类型
print(type('100'))
常量
Python当中没有明确定义常量，只是在定义的时候约定使用大写名称！
BIR_OF_CHINA = 1949
注释
#
三个单引号或三个双引号
中文编码
# -*- coding: UTF-8 -*- 或者 #coding=utf-8
行和缩进
python最具特色的就是用缩进来写模块，缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
如果是 IndentationError: unindent does not match any outer indentation level错误表明，你使用的缩进方式不一致，有的是 tab 键缩进，有的是空格缩进，改为一致即可。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用
多行语句
我们可以使用斜杠（ ）将一行的语句分为多行显示，如下所示：
total = item_one +
item_two +
item_three
语句中包含[], {} 或 () 括号就不需要使用多行连接符。如下实例：
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
用户交互
input
input() 函数和raw_input() 函数基本可以互换，但是input**假设你的输入是一个有效的Python表达式，并返回运算结果。
#!/usr/bin/python
str = input("Enter your input: ");
print "Received input is : ", str
raw_input
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
a = raw_input('please input your name:')
print a
输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号
#!/usr/bin/python
# -*- coding: UTF-8 -*-
x="a"
y="b"
# 换行输出
print x
print y
print '---------'
# 不换行输出
print x,
print y,
# 不换行输出
print x,y
运算符
算术运算符
运算符
描述
实例
输出结果
+
加 – 两个对象相加
a + b
30
–
减 – 得到负数或是一个数减去另一个数
a – b
-10
*
乘 – 两个数相乘或是返回一个被重复若干次的字符串
a * b
200
/
除 – x除以y
b / a
2
%
取模 – 返回除法的余数
b % a
0
**
幂 – 返回x的y次幂
a**b
100000000000000000000
//
取整除 – 返回商的整数部分
9//2 , 9.0//2.0
4 ， 4.0
比较运算符
运算符
描述
==
等于 – 比较对象是否相等
!=
不等于 – 比较两个对象是否不相等
<>
不等于 – 比较两个对象是否不相等
>
大于 – 返回x是否大于y
<
小于 – 返回x是否小于y。
>=
大于等于 – 返回x是否大于等于y。
<=
小于等于 – 返回x是否小于等于y。
赋值运算符
运算符
描述
实例
=
简单的赋值运算符
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
位运算符
按位运算符是把数字看作二进制来进行计算的。
运算符
别名
梨子
结果
&
按位与
10101010 & 01010101 (有假为假)
00000000
|
按位或
10101010 | 01010101 (有真为真)
11111111
^
按位异或
11110000 ^ 11110011 (相同为0,不同为1)
00000011
~
按位非
~1 (对于有符号数结果取补码形式)
-2
<<
左移
00000001 << 2
4
>>
右移
10000000 >> 2
32
逻辑运算符
运算符
逻辑表达式
描述
实例 (a = 10 b = 20)
and
x and y
布尔”与” – 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
(a and b) 返回 20。
or
x or y
布尔”或” – 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。
(a or b) 返回 10。
not
not x
布尔”非” – 如果 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。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print "1 - 变量 a 在给定的列表中 list 中"
else:
print "1 - 变量 a 不在给定的列表中 list 中"
if ( b not in list ):
print "2 - 变量 b 不在给定的列表中 list 中"
else:
print "2 - 变量 b 在给定的列表中 list 中"
# 修改变量 a 的值
a = 2
if ( a in list ):
print "3 - 变量 a 在给定的列表中 list 中"
else:
print "3 - 变量 a 不在给定的列表中 list 中"
身份运算符
身份运算符用于比较两个对象的存储单元
运算符
描述
实例
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
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 20
b = 20
if ( a is b ):
print "1 - a 和 b 有相同的标识"
else:
print "1 - a 和 b 没有相同的标识"
if ( id(a) == id(b) ):
print "2 - a 和 b 有相同的标识"
else:
print "2 - a 和 b 没有相同的标识"
# 修改变量 b 的值
b = 30
if ( a is b ):
print "3 - a 和 b 有相同的标识"
else:
print "3 - a 和 b 没有相同的标识"
if ( a is not b ):
print "4 - a 和 b 没有相同的标识"
else:
print "4 - a 和 b 有相同的标识"
以上实例输出结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
优先级
运算符
描述
**
指数 (最高优先级)
~ + –
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //
乘，除，取模和取整除
+ –
加法减法
>> <<
右移，左移运算符
&
位 ‘AND’
^ |
位运算符
<= < > >=
比较运算符
<> == !=
等于运算符
= %= /= //= -= += = *=
赋值运算符
is is not
身份运算符
in not in
成员运算符
not or and
逻辑运算符
数据类型
数字
创建数字对象
var1 = 1
var2 = 10
删除数字对象引用
del var
del var_a, var_b
数值类型
整型(Int) – 通常被称为是整型或整数，是正或负整数，不带小数点。
长整型(long integers) – 无限大小的整数，整数最后是一个大写或小写的L。
浮点型(floating point real values) – 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
复数( (complex numbers)) – 复数的虚部以字母J 或 j结尾,复数的实部a和虚部b都是浮点型 。如：2+3i
数字类型转换
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 ) 将一个整数转换为一个八进制字符串
math 模块、cmath 模块
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。
实例：
>>> import cmath
>>> cmath.sqrt(-1)
1j
>>> cmath.sqrt(9)
(3+0j)
>>> cmath.sin(1)
(0.8414709848078965+0j)
>>> cmath.log10(100)
(2+0j)
>>>
数学函数
函数
返回值 ( 描述 )
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(xx + yy)。
sin(x)
返回的x弧度的正弦值。
tan(x)
返回x弧度的正切值。
degrees(x)
将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)
将角度转换为弧度
数学常量
常量
描述
pi
数学常量 pi（圆周率，一般以π来表示）
e
数学常量 e，e即自然常数（自然常数）。
字符串
创建字符串
多行字符串：
var1 = 'Hello World!'
var2 = """
今天我想写首诗,
歌颂我的同桌,
你看他那乌黑的短发,
好像一只杂毛鸡。
"""
访问字符串中的值
#!/usr/bin/python
var1 = 'Hello World!'
var2 = "Python w3cschool"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]
以上实例执行结果：
var1[0]: H
var2[1:5]: ytho
字符串更新
可以对已存在的字符串进行修改，并赋值给另一个变量，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
var1 = 'Hello '
print "更新字符串 :- ", var1[:6] + 'World!!'
以上实例执行结果
更新字符串 :- Hello World!
转义字符
转义字符
描述
(在行尾时)
续行符
\
反斜杠符号
'
单引号
"
双引号
a
响铃
b
退格(Backspace)
e
转义
00
空
n
换行
v
纵向制表符
t
横向制表符
r
回车
f
换页
oyy
八进制数，yy代表的字符，例如：o12代表换行
xyy
十六进制数，yy代表的字符，例如：x0a代表换行
other
其它的字符以普通格式输出
字符串运算符
操作符
描述
实例 （a:”Hello”，b:”Python”)
结果
+
字符串连接
a + b 输出结果：
HelloPython
*
重复输出字符串
a*2 输出结果：
HelloHello
[]
通过索引获取字符串中字符
a[1] 输出结果 ****
e
[ : ]
截取字符串中的一部分
a[1:4] 输出结果 ****
ell
in
成员运算符
H in a 输出结果
1
not in
成员运算符
M not in a 输出结果
1
r/R
原始字符串
print r'n' print R'n'
n
%
格式字符串
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = "Hello"
b = "Python"
if( "H" in a) :
print "H 在变量 a 中"
else :
print "H 不在变量 a 中"
if( "M" not in a) :
print "M 不在变量 a 中"
else :
print "M 在变量 a 中"
print r'n'
print R'n'
以上程序执行结果为：
H 在变量 a 中
M 不在变量 a 中
n
n
字符串索引
通过索引可以获取Python字符串中的某字符
正向索引
s='ABCDEFGHIJKLMN'
print('s[0]:',s[0])
# 结果:A
反向索引
s='ABCDEFGHIJKLMN'
print('s[-1]:',s[-1])
# 结果:N
字符串切**
通过索引可以获取Python字符串中的某字符集
切**规则：
形式:s[beg:end:delta]
列表的下标有三个参数：beg（起始下标），end（终止下标），delta（变化量）
当delta小于0时:beg默认为-1，end默认为开头之前。
当delta大于0时:beg默认为0，end默认为最末之后。
当delta未给出时：delta默认为1
梨子1：
s='ABCDEFGHIJKLMN'
print('s[0:4]:',s[0:4])
# ABCD
print('s[0:-1]:',s[0:-1])
# ABCDEFGHIJKLM
当尾索引没有给出时，默认截取到字符串的末尾
当头索引没有给出的时候默认从字符串开头开始截取
当尾索引和头索引都没有给出的时候，默认返回整个字符串，不过这只是一个浅拷贝
梨子2：
s='ABCDEFGHIJKLMN'
print('s[:],s[0:]:',s[:],s[0:])
# ABCDEFGHIJKLMN ABCDEFGHIJKLMN
当尾索引大于总的字符串长度时，默认只截取到字符串末尾
梨子3：
s='ABCDEFGHIJKLMN'
print('s[:100]:',s[:100])
# ABCDEFGHIJKLMN
当头索引为负数时，则是指从字符串的尾部开始计数，最末尾的字符记为-1，以此类推
尾索引同样可以为负数，如果尾索引的值指明的字符串位置小于或等于头索引，此时返回的就是空字符串
梨子4：
s='ABCDEFGHIJKLMN'
print('s[-2:-4]:'s[-2:-4])
print('s[0:0]:'s[0:0])
# null null
切**还可以利用第三个参数，即步长让我们可以取非连续的字符，默认情况下的步长是1
梨子5：
s='ABCDEFGHIJKLMN'
print('s[0:5:2]:',s[0:5:2])
# ACE，隔2取1
print('s[0:6:2]:',s[0:6:2])
# ACE
print('s[0:7:2]:',s[0:7:2])
# ACEG
如果步长是负数的话，可以实现反转字符串
梨子6：
s='ABCDEFGHIJKLMN'
print('s[4:0:-1]:',s[4:0:-1])
# EDCB 实现反转
print('s[4:-1:-1]:',s[4:-1:-1])
# null
print('s[4::-1]:',s[4::-1])
# EDCBA 默认为开头之前
print('s[3::-2]:',s[3::-2])
# DB
print('s[-1::-1]:',s[-1::-1])
# NMLKJIHGFEDCBA
print('s[-2::-1]:',s[-2::-1])
# MLKJIHGFEDCBA
print('s[::-1]:',s[::-1])
# NMLKJIHGFEDCBA
字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能**用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
如下实例：
#!/usr/bin/python
print("My name is %s and weight is %d kg!" % ('Zara', 21))
格式化符号如下：
符 号
描述
%c
格式化字符及其ASCII码
%s
格式化字符串
%d
格式化整数
%u
格式化无符号整型
%o
格式化无符号八进制数
%x
格式化无符号十六进制数
%X
格式化无符号十六进制数（大写）
%f
格式化浮点数字，可指定小数点后的精度
%e
用科学计数法格式化浮点数
%E
作用同%e，用科学计数法格式化浮点数
%g
%f和%e的简写
%G
%f 和 %E 的简写
%p
用十六进制数格式化变量的地址
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）
#-*- encoding:utf-8 -*-
name=input("请输入姓名:")
age=input("请输入年龄:")
hobby=input("请输入爱好:")
print ''' ==============================
Name : %s
Age : %d
Hobby: %s
==============================
''' %(name,int(age),hobby)
print("我的名字:%s,今年:%d,爱好:%s" %(name,int(age),hobby))
以上程序执行结果为：
==============================
Name : 12
Age : 12
Hobby: 12
==============================
我的名字:12,今年:12,爱好:12
Unicode 字符串
>>>print u'Hello World !'
u'Hello World !'
字符串函数
方法
方法
描述
capitalize()
把字符串的第一个字符大写
center(width)
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
count(str, beg=0, end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
decode(encoding=’UTF-8’, errors=’strict’)
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 ‘ignore’ 或 者’replace’
encode(encoding=’UTF-8’, errors=’strict’)
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
endswith(obj, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，默认的空格数 tabsize 是 8.
find(str, beg=0, end=len(string))
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
index(str, beg=0, end)
跟find()方法一样，只不过如果str不在 string中**报一个异常.
isalnum()
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
isalpha()
如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
isdecimal()
如果 string 只包含十进制数字则返回 True 否则返回 False.
isdigit()
如果 string 只包含数字则返回 True 否则返回 False.
islower()
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isnumeric()
如果 string 中只包含数字字符，则返回 True，否则返回 False
isspace()
如果 string 中只包含空格，则返回 True，否则返回 False.
istitle()
如果 string 是标题化的(见 title())则返回 True，否则返回 False
isupper()
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
join(seq)
Merges (concatenates)以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len()
计算一个字符串的长度
ljust(self,width,fillchr)
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
lower()
转换 string 中所有大写字符为小写.
lstrip()
截掉 string 左边的空格
maketrans(intab, outtab])
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)
返回字符串 str 中最大的字母。
min(str)
返回字符串 str 中最小的字母。
partition(str)
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
replace(str1, str2, num)
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不**过 num 次.
rfind(str, beg=0,end)
类似于 find()函数，不过是从右边开始查找.
rindex( str, beg=0)
类似于 index()，不过是从右边开始.
rjust(self,width,fillchr)
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
rpartition(str)
类似于 partition()函数,不过是从右边开始查找.
rstrip()
删除 string 字符串末尾的空格.
split(str=””, num)
以 str 为分隔符切** string，如果 num有指定值，则仅分隔 num 个子字符串
splitlines(num=string.count(‘n’))
按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切** num 个行.
startswith(obj,beg=0,end)
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
strip([obj])
默认去除掉字符串的前后的空格，可以指定要去除的对象！
swapcase()
翻转 string 中的大小写
title()
返回”标题化”的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
translate(str, del=””)
根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
upper()
转换 string 中的小写字母为大写
zfill(width)
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
isdecimal()
isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
strip
strip(self,chars)
#!/usr/bin/python
# -*- encoding:utf-8 -*-
s = " iLove Python ! "
print s.strip()
s1 = "*%m%arvelous%*tranq*uil%"
print s1.strip('%')
print s1.strip('%*')
以上程序执行结果为：
iLove Python !
*%m%arvelous%*tranq*uil
m%arvelous%*tranq*uil
split
split(self,sep,maxsplit)
s2 = "TCP 0.0.0.0:80 0.0.0.0:0 LISTENING"
print s2.split() #['TCP', '0.0.0.0:80', '0.0.0.0:0', 'LISTENING']
print s2.split(':') #['TCP 0.0.0.0', '80 0.0.0.0', '0 LISTENING']
ljust
ljust(self,width,fillchars)
s3 = '602010'
print s3.ljust(8,'a') #602010aa
format
format(self,args,kwargs)
s14='我叫{},今年{},爱好{}'.format('小呆',18,'大白')
s15='我叫{0},今年{1},爱好{2}'.format('小呆',18,'大白')
s16='我叫{name},今年{age},爱好{hobby}'.format(age=18,name='小呆',hobby='大白')
print(s14) # 我叫小呆,今年18,爱好大白
print(s15) # 我叫小呆,今年18,爱好大白
print(s16) # 我叫小呆,今年18,爱好大白
列表
序列是Python中最基本的数据结构。
序列中的每个元素都分配一个数字 – 索引，列表索引从0开始。列表可以进行截取、组合等。
创建列表
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
访问列表中的值
#!/usr/bin/python
# -*- encoding:utf-8 -*-
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
print "list1[0]: ", list1[0] # list1[0]: physics
print "list2[1:5]: ", list2[1:5] # list2[1:5]: [2, 3, 4, 5]
列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
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 = ['spam', 'Spam', 'SPAM!']
操作：
Python 表达式
结果
描述
L[2]
‘SPAM!’
读取列表中第三个元素
L[-2]
‘Spam’
读取列表中倒数第二个元素
L[1:]
[‘Spam’, ‘SPAM!’]
从第二个元素开始截取列表
更新列表
list = [1, 2, 3, 4, 5 ];
list1.append(6)
删除元素
#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000];
print list1;
del list1[2];
print "After deleting value at index 2 : "
print list1;
常见方法
函数名
函数功能
cmp(list1, list2)
比较两个列表的元素
len(list)
列表元素个数
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
list(seq)
将元组/字符串转换为列表
方法
方法功能
list.append()
在列表末尾添加新的对象
list.count(obj)
统计某个元素在列表中出现的次数
list.extend(new_list)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)
将对象插入列表
list.pop(obj=list[-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)
移除列表中某个值的第一个匹配项
list.reverse()
反向列表中元素
list.sort([func])
对原列表进行排序
如果Python列表无法正常输出汉字，则可以采取以下的解决方法：
#encoding=utf-8
import json
list_words = [ '你', '我', '他' ]
print( list_words ) # 无法正常显示汉字
print( str(list_words).decode( 'string_escape' ) ) # 正常显示汉字
list_words_result = json.dumps( list_words, encoding='UTF-8', ensure_ascii=False )
print( list_words_result )
密码字典案例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
user = ['admin','root','administrator']
password = ['admin','admin888','123456']
password.append('123.com')
for i in admin:
for j in password:
print i,':',j
元组
元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表。
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
创建元组
tup = ()
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)
访问元组
元组可以使用下标索引来访问元组中的值，如下实例:
#!/usr/bin/python
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tup1[0] #tup1[0]: physics
print "tup2[1:5]: ", tup2[1:5] #tup2[1:5]: (2, 3, 4, 5)
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#coding=utf-8
#!/usr/bin/python
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3; #(12, 34.56, 'abc', 'xyz')
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/python
tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
print "After deleting tup : "
print tup; # NameError: name 'tup' is not defined
运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后**生成一个新的元组。
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
迭代
索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
元组：
L = ('spam', 'Spam', 'SPAM!')
Python 表达式
结果
描述
L[2]
‘SPAM!’
读取第三个元素
L[-2]
‘Spam’
反向读取；读取倒数第二个元素
L[1:]
(‘Spam’, ‘SPAM!’)
截取元素
无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组，如下实例：
#!/usr/bin/python
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
cmp(tuple1, tuple2)
比较两个元组元素。
2
len(tuple)
计算元组元素个数。
3
max(tuple)
返回元组中元素最大值。
4
min(tuple)
返回元组中元素最小值。
5
tuple(seq)
将列表转换为元组。
字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
创建字典
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
访问字典里的值
把相应的键放入熟悉的方括弧，如下实例:
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
print "dict['Alice']: ", dict['Alice'];
以上实例输出结果：
dict['Name']: Zara
dict['Age']: 7
KeyError: 'Alice'
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
print dict #{'School': 'DPS School', 'Age': 8, 'Name': 'Zara', 'Class': 'First'}
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用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'];
但这**引发一个异常，因为用del后字典不再存在：
dict['Age']:
Traceback (most recent call last):
File "test.py", line 8, in <module>
print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable
字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
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为字典所有键对应的初始值
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()
以列表返回字典中的所有值
小型数据库案例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
person = {
'小明':{
'name':'小明',
'age':18,
'sex':'M'
},
'小黑':{
'name':'小黑',
'age':18,
'sex':'M'
}
}
person['小辰'] = {'name':'小辰','age':17,'sex':'M'}
print person['小黑']['name'] # 小黑
集合
集合是一个无序的，不重复的数据组合，它的主要作用如下：
去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 创建集合,关键字set
print('---------关系测试-----------')
list_1=[1,4,1,2,3,26,3,6,7,9,7,5]
list_1=set(list_1)
list_2=set([2,1,2,44,2,4,5,6,4,7])
print(list_1,list_2)
t = set("Hello") #创建一个唯一字符的集合
# 取交集
print(list_1.intersection(list_2))
# 取并集
print(list_1.union(list_2))
# 取差集
print(list_1.difference(list_2))
print(list_2.difference(list_1))
# 子集判断
print(list_1.issubset(list_2))
# 父集判断
print(list_1.issuperset(list_2))
# 对称差集
print(list_1.symmetric_difference(list_2)) #两者中相互没有的
# 无交集判断
print(set([1,2]).isdisjoint(set([3,4])))
# 判断成员是否在集合中
print('x' in t)
print('x' not in t)
print("----------运算符----------")
# 交集
print(list_1&list_2)
# 并集
print(list_1|list_2)
# 差集
print(list_1-list_2)
print(list_2-list_1)
# 对称差集
print(list_1^list_2)
# 判断子集
print(list_1<=list_2)
print(set([1,2,3,4])>=set([1,2]))
print("------------基本操作------------")
#添加
t.add('xy')
print(t)
#添加多项
t.update('world')
print(t)
#删除
t.remove('xy') #不存在**报错
print(t)
# 随机删除
print(list_1.pop())
# 删除指定元素
t.discard('u') #不存在do nothing
print(t)
# 返回长度
print(len(t))
# 浅复制
s=t.copy()
print(s)
print(t)
s.add('q')
print(s)
print(t)
案例
购物车程序
需求:
启动程序后，让用户输入工资，然后打印商品列表
允许用户根据商品编号购买商品
用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
可随时退出，退出时，打印已购买商品和余额
#coding:utf-8
commodity = (
(1,"ipone",5800),
(2,"bike",800),
(3,"computer",5000),
(4,"watch",1800)
)
salary_input = input("请输入您的工资:")
balance = int(salary_input)
shop_list=[]
if salary_input.isdigit():
for i in range(len(commodity)):
print("%d:%s:%d" %(commodity[i][0],commodity[i][1],commodity[i][2]))
print("输入商品ID选择商品,输入q退出本次购物n")
while True:
choice = input("请输入您的选择:")
if choice.isdigit():
choice_format=int(choice)
if choice_format<len(commodity) and choice_format>0:
if int(balance) >= commodity[choice_format-1][2]:
balance -= commodity[choice_format-1][2]
shop_list.append(commodity[choice_format-1])
print("已经将%s添加入购物车,您的余额为:33[31;1m%d33[0m" %(commodity[choice_format-1],balance))
continue
else:
print("33[31;1m您的余额不够,还买个毛线啊33[0mn")
continue
else:
print("商品不存在,请重新输入")
continue
elif choice == 'q':
print("======您的购物清单======n")
for p in range(len(shop_list)):
print("商品:%s,价格:%dn" %(shop_list[p][1],shop_list[p][2]))
print("您的余额为:33[31;1m%d33[0m" %balance)
print("购物愉快")
exit()
else:
print("您的输入非法,请重新输入n")
else:
print("您的输入非法,请重新输入n")
购物车加强版
分支
if
if 5>4 :
print(666)
print(777)
if-else
if 4>3:
print('呆瓜')
else :
print('小呆')
if-elif-else
score = int(input('输入分数:'))
if score>100:
print("A")
elif score>90:
print("B")
elif score>60:
print("C")
else:
print("太笨了")
if嵌套
name=input("请输入名字:")
age=input('请输入年龄:')
if name == "小呆":
if age == "18":
print(name,age)
else:
print(333)
else:
print('错了')
由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现
如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功
使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行
此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下**比与或要优先判断。
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):
print 'hello'
else:
print 'undefine'
循环
标志语句
continue
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
break
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也**停止执行循环语句。
如果使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
pass
Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
# -*- coding: UTF-8 -*-
#!/usr/bin/python
# 输出 Python 的每个字母
for letter in 'Python':
if letter == 'h':
pass
print '这是 pass 块'
print '当前字母 :', letter
print "Good bye!"
以上实例执行结果：
当前字母 : P
当前字母 : y
当前字母 : t
这是 pass 块
当前字母 : h
当前字母 : o
当前字母 : n
Good bye!
while
count = 1
sum = 0
while True :
count= count + 1
sum = sum + count
if count > 100 :
break
print(sum)
j=1
while j<100:
j+=1
if j>5 and j<95:
continue
print("loop",j)
print("---out of while loop---")
while-else
we=0
while we<5:
we+=1
if we==3:
continue #若是break,则不**执行else
print("Loop",we)
else:
print("循环正常执行完啦")
print("---out of while loop---")
-----------
('Loop', 1)
('Loop', 2)
('Loop', 4)
('Loop', 5)
循环正常执行完啦
for
for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
语法格式如下：
for iterating_var in sequence:
statements(s)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
for i in range(1,11):
for k in range(1,i):
print k,
print "n"
以上实例输出结果:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
通过序列索引迭代
#!/usr/bin/python
# -*- coding: UTF-8 -*-
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print '当前水果 :', fruits[index]
print "Good bye!"
以上实例输出结果：
当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!
函数 len() 返回列表的长度，即元素的个数。 range返回一个序列的数。
for-else
即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print '%d 等于 %d * %d' % (num,i,j)
break # 跳出当前循环
else: # 循环的 else 部分
print num, '是一个质数'
以上实例输出结果：
10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数
循环嵌套
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)
函数
定义函数
规则
函数代码块以def关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
实例
以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。
def printme( str ):
"打印传入的字符串到标准显示设备上"
print str
函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：
#coding=utf-8
#!/usr/bin/python
# Function definition is here
def printme( str ):
"打印任何传入的字符串"
print str;
return;
# Now you can call printme function
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
以上实例输出结果：
我要调用用户自定义函数!
再次调用同一函数
参数传递
在python中，类型属于对象，变量是没有类型的：
a=[1,2,3]
a="w3cschool"
以上代码中，[1,2,3] 是 List 类型，”w3cschool”是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 传不可变对象实例
实例（Python 2.0+）
#!/usr/bin/python
# -*- coding: UTF-8 -*-
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print b # 结果是 2
实例中有int对象2，指向它的变量是b，在传递给ChangeInt函数时，按传值的方式复制了变量b，a和b都指向了同一个 Int 对象，在a=10时，则新生成一个int值对象 10，并让a指向它。
传可变对象
所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：
#coding=utf-8
#!/usr/bin/python
# 可写函数说明
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]]
参数
以下是调用函数时可使用的正式参数类型：
必备参数
命名参数
缺省参数
不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然**出现语法错误：
#coding=utf-8
#!/usr/bin/python
#可写函数说明
def printme( str ):
"打印任何传入的字符串"
print str;
return;
#调用printme函数
printme();
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 11, in <module>
printme();
TypeError: printme() takes exactly 1 argument (0 given)
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
#可写函数说明
def printme( str ):
"打印任何传入的字符串"
print str;
return;
#调用printme函数
printme( str = "My string");
以上实例输出结果：
My string
下例能将关键字参数顺序不重要展示得更清楚：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
#调用printinfo函数
printinfo( age=50, name="miki" );
以上实例输出结果：
Name: miki
Age 50
命名参数
命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。你可以跳过不传的参数或者乱序传参，因为Python解释器能够用参数名匹配参数值。用命名参数调用printme()函数：
#coding=utf-8
#!/usr/bin/python
#可写函数说明
def printme( str ):
"打印任何传入的字符串"
print str;
return;
#调用printme函数
printme( str = "My string");
以上实例输出结果：
My string
下例能将命名参数顺序不重要展示得更清楚：
#coding=utf-8
#!/usr/bin/python
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
#调用printinfo函数
printinfo( age=50, name="miki" );
以上实例输出结果：
Name: miki
Age 50
缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例**打印默认的age，如果age没有被传入：
#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" );
以上实例输出结果：
Name: miki
Age 50
Name: miki
Age 35
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不**命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号（*）的变量名**存放所有未命名的变量参数。选择不多传参数也可。如下实例：
#coding=utf-8
#!/usr/bin/python
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple:
print var
return;
f = ( 70, 60, 50 )
# 调用printinfo 函数
printinfo( 10 );
printinfo(f);
以上实例输出结果：
输出:
10
输出:
(70, 60, 50)
匿名函数
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下实例：
#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 )
以上实例输出结果：
Value of total : 30
Value of total : 40
return语句
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。
不带参数值的return语句返回None。
#coding=utf-8
#!/usr/bin/python
# 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print "Inside the function : ", total
return total;
# 调用sum函数
total = sum( 10, 20 );
print "Outside the function : ", total
以上实例输出结果：
Inside the function : 30
Outside the function : 30
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量定义在函数外的拥有全局作用域
局部变量定义在函数内部的变量拥有一个局部作用域
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
#coding=utf-8
#!/usr/bin/python
total = 0; # This is global variable.
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2; # total在这里是局部变量.
print "Inside the function local total : ", total
return total;
#调用sum函数
sum( 10, 20 );
print "Outside the function global total : ", total
以上实例输出结果：
Inside the function local total : 30
Outside the function global total : 0
时间相关
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间，时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
获取当前时间戳
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time; # 引入time模块
ticks = time.time()
print "当前时间戳为:", ticks # 1459994552.51
时间元组
序号
属性
值
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是决定是否为夏令时的旗帜
获取当前时间
从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
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():
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time
localtime = time.asctime( time.localtime(time.time()) )
print "本地时间为 :", localtime
以上实例输出结果：
本地时间为 : Thu Apr 7 10:05:21 2016
格式化日期
我们可以使用 time 模块的 strftime 方法来格式化日期，：
time.strftime(format[, t])
#!/usr/bin/python
# -*- coding: UTF-8 -*-
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"))
以上实例输出结果：
2016-04-07 10:25:09
Thu Apr 07 10:25:09 2016
1459175064.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模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
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模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：
函数
描述
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.localtime([secs]
接收时间辍（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
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重新初始化时间相关设置。
Time模块包含了以下2个非常重要的属性：
属性
描述
time.timezone
当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。
time.tzname
包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。
日历（Calendar）模块
此模块的函数都是日历相关的，例如打印某月的字符月历。
星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：
序号
函数及描述
calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21 W+18+2* C。l是每星期行数。
calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回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种，其他处理日期和时间的模块还有：
datetime模块
pytz模块
dateutil模块
模块
模块也是Python对象，具有随机的名字属性用来绑定或引用。
简单地说，模块就是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码。
import 语句
当解释器遇到import语句，如果模块在当前的搜索路径就**被导入。
搜索路径是一个解释器**先进行搜索的所有目录的列表。
想使用Python源文件，只需在另一个源文件里执行import语句，语法如下：
import module1[, module2[,... moduleN]
#support.py
def print_func( par ):
print "Hello : ", par
return
#coding=utf-8
#!/usr/bin/python
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Zara")
From…import 语句
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from modname import name1[, name2[, ... nameN]]
例如，要导入模块fib的fibonacci函数，使用如下语句：
from fib import fibonacci
这个声明不**把整个fib模块导入到当前的命名空间中，它只**将fib里的fibonacci单个引入到执行这个声明的模块的全局符号表。
From…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
定位模块
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
当前目录
如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
如果都找不到，Python**察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
PYTHONPATH变量
作为环境变量，PYTHONPATH由装在一个列表里的许多目录组成。PYTHONPATH的语法和shell变量PATH的一样。
在Windows系统，典型的PYTHONPATH如下：
set PYTHONPATH=c:pythonlib;
在UNIX系统，典型的PYTHONPATH如下：
set PYTHONPATH=/usr/local/lib/python
命名空间和作用域
变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量**覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python**智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给全局变量在一个函数里赋值，必须使用global语句。
global VarName的表达式**告诉Python， VarName是一个全局变量，这样Python就不**在局部命名空间里寻找这个变量了。
例如，我们在全局命名空间里定义一个变量Money。我们再在函数内给变量Money赋值，然后Python**假定Money是一个局部变量。
然而，我们并没有在访问前声明一个局部变量Money，结果就是**出现一个UnboundLocalError的错误。取消global语句的注释就能解决这个问题。
#coding=utf-8
#!/usr/bin/python
Money = 2000
def AddMoney():
# 想改正代码就取消以下注释:
global Money
Money = Money + 1
print Money #2000
AddMoney()
print Money #2001
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境。
考虑一个在Phone目录下的pots.py文件。这个文件有如下源代码：
#coding=utf-8
#!/usr/bin/python
def Pots():
print "I'm Pots Phone"
同样地，我们有另外两个保存了不同函数的文件：
Phone/Isdn.py 含有函数Isdn()
Phone/G3.py 含有函数G3()
现在，在Phone目录下创建file init.py：
Phone/init.py
当你导入Phone时，为了能够使用所有函数，你需要在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()
以上实例输出结果：
I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone
内置函数
dir()函数
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指向该模块的导入文件名。
globals()和locals()函数
根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。
reload()函数
当一个模块被导入到一个脚本，模块顶层部分的代码只**被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用reload()函数。该函数**重新导入之前导入过的模块。语法如下：
reload(module_name)
在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载hello模块，如下：
reload(hello)
文件
对文件操作流程
打开文件，得到文件句柄并赋值给一个变量
通过句柄对文件进行操作
关闭文件
文件读写
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+
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将**放在文件的结尾。如果该文件不存在，创建新文件用于读写。
下图很好的总结了这几种模式：
<img />
模式
r
r+
w
w+
a
a+
读
+
+
+
+
写
+
+
+
+
+
创建
+
+
+
+
覆盖
+
+
指针在开始
+
+
+
+
指针在结尾
+
+
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
属性
描述
file.closed
如果文件已被关闭返回true，否则返回false。
file.mode
返回被打开文件的访问模式。
file.name
返回文件的名称。
file.softspace
如果用print输出后，必须跟一个空格符，则返回false。否则返回true。
如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 打开一个文件
fo = open("foo.txt", "wb")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace
以上实例输出结果：
文件名: foo.txt
是否已关闭 : False
访问模式 : wb
末尾是否强制加空格 : 0
Close()
File对象的close（）方法**新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python**关闭之前的文件。用close（）方法关闭文件是一个很好的习惯。
语法：
fileObject.close();
例子：
#coding=utf-8
#!/usr/bin/python
# 打开一个文件
fo = open("foo.txt", "wb")
print "文件名: ", fo.name
# 关闭打开的文件
fo.close()
以上实例输出结果：
文件名: foo.txt
读写文件：
file对象提供了一系列方法，能让我们的文件访问更轻松。来看看如何使用read()和write()方法来读取和写入文件。
Write()
Write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
Write()方法不在字符串的结尾添加换行符(‘n’)：
语法：
fileObject.write(string);
在这里，被传递的参数是要写入到已打开文件的内容。
例子：
#coding=utf-8
#!/usr/bin/python
# 打开一个文件
fo = open("/tmp/foo.txt", "wb")
fo.write( "Python is a great language.nYeah its great!!n");
# 关闭打开的文件
fo.close()#!/usr/bin/python
上述方法**创建foo.txt文件，并将收到的内容写入该文件，并最终关闭文件。如果你打开这个文件，将看到以下内容:
Python is a great language.
Yeah its great!!
read()
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：
fileObject.read([count]);
在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它**尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
例子：
就用我们上面创建的文件foo.txt。
#coding=utf-8
#!/usr/bin/python
# 打开一个文件
fo = open("/tmp/foo.txt", "r+")
str = fo.read(10);
print "读取的字符串是: ", str
# 关闭打开的文件
fo.close()
以上实例输出结果：
读取的字符串是: Python is
文件位置：
tell()方法告诉你文件内的当前位置；换句话说，下一次的读写**发生在文件开头这么多字节之后：
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
例子：
就用我们上面创建的文件foo.txt。
#coding=utf-8
#!/usr/bin/python
# 打开一个文件
fo = open("/tmp/foo.txt", "r+")
str = fo.read(10);
print "读取的字符串是: ", str
# 查找当前位置
position = fo.tell();
print "当前文件位置: ", position
# 把指针再次重新定位到文件开头
position = fo.seek(0, 0);
str = fo.read(10);
print "重新读取字符串: ", str
# 关闭打开的文件
fo.close()
以上实例输出结果：
读取的字符串是: Python is
当前文件位置: 10
重新读取字符串: Python is
目录操作
所有文件都包含在各个不同的目录下，不过Python也能轻松处理。os模块有许多方法能帮你创建，删除和更改目录。
mkdir()
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
语法：
os.mkdir("newdir")
例子：
下例将在当前目录下创建一个新目录test。
#coding=utf-8
#!/usr/bin/python
import os
# 创建目录test
os.mkdir("test")
chdir()
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
语法：
os.chdir("newdir")
例子：
下例将进入”/home/newdir”目录。
#coding=utf-8
#!/usr/bin/python
import os
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
getcwd()
getcwd()方法显示当前的工作目录。
语法：
os.getcwd()
下例给出当前目录：
#coding=utf-8
#!/usr/bin/python
import os
# 给出当前的目录
os.getcwd()
rmdir()
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
语法：
os.rmdir('dirname')
以下是删除” /tmp/test”目录的例子。目录的完全合规的名称必须被给出，否则**在当前目录下搜索该目录。
#coding=utf-8
#!/usr/bin/python
import os
# 删除”/tmp/test”目录
os.rmdir( "/tmp/test" )
相关方法
三个重要的方法来源能对Windows和Unix操作系统上的文件及目录进行一个广泛且实用的处理及操控，如下：
File 对象方法: file对象提供了操作文件的一系列方法。
OS 对象方法: 提供了处理文件及目录的一系列方法。
序号
方法及描述
file.close()
关闭文件。关闭后文件不能再进行读写操作。
file.flush()
**新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno()
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty()
如果文件连接到一个终端设备返回 True，否则返回 False。
file.next()
返回文件下一行。
file.read(size)
从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline()
读取整行，包括 “n” 字符。
file.readlines(sizeint)
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizeint较大, 因为需要填充缓冲区。
file.seek(offset,whence)
设置文件当前位置
file.tell()
返回文件当前位置。
file.truncate(size)
截取文件，截取的字节通过size指定，默认为当前文件位置。
file.write(str)
将字符串写入文件，返回的是写入的字符。
filw.writelines(sequnce)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
序号
描述
os.rename( “test1.txt”, “test2.txt” )
将test1.txt重命名为test2.txt
os.remove(“text2.txt”)
删除一个已经存在的文件test2.txt
描述符
在 shell 程式中，最常使用的 FD (file descriptor) 大概有三个, 分别是:
0 是一个文件描述符，表示标准输入(stdin)
1 是一个文件描述符，表示标准输出(stdout)
2 是一个文件描述符，表示标准错误(stderr)
在标准情况下, 这些FD分别跟如下设备关联:
stdin(0): keyboard 键**输入,并返回在前端
stdout(1): monitor 正确返回值 输出到前端
stderr(2): monitor 错误返回值 输出到前端
重定向
就是把前面输出的内容重定向到后面指定的位置
一般来说, “1>” 通常可以省略成 “>”.
ls a.txt b.txt 1>file.out 2>file.err
ls a.txt b.txt >file.out 2>file.err
1>&2 正确返回值传递给2输出通道 &2表示2输出通道
& 是一个描述符，如果1或2前不加&，**被当成一个普通文件
1>&2 意思是把标准输出重定向到标准错误.等价于 >&2
2>&1 意思是把标准错误输出重定向到标准输出。
2>&1 错误返回值传递给1输出通道, 同样&1表示1输出通道.
ls a.txt b.txt 1>file.out 2>&1
[root@redhat box]# cat file.out
ls: b.txt: No such file or directory
a.txt
把 标准输出 重定向到文件 filename.txt，然后把 标准错误 重定向到 标准输出
所以最后的错误信息也通过标准输出写入到了文件中
异常
原创文章，作者：小嵘源码，如若转载，请注明出处：https://www.lcpttec.com/python/
