字典
#!/usr/bin/python
dict={Name:Zara,Age:7,Class:First};print"dict[Alice]:",dict[Alice];Python字典(Dictionary)字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中,格式如下所示：
d={key1:value1,key2:value2}键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict={Alice:,Beth:,Cecil:}也可如此创建字典：
dict1={abc:};dict2={abc:,98.6:37};访问字典里的值把相应的键放入熟悉的方括弧，如下实例:
#!/usr/bin/pythondict={Name:Zara,Age:7,Class:First};print"dict[Name]:",dict[Name];print"dict[Age]:",dict[Age];以上实例输出结果：
dict[Name]:Zaradict[Age]:7如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/pythondict={Name:Zara,Age:7,Class:First};print"dict[Alice]:",dict[Alice];以上实例输出结果：
dict[Alice]:Traceback(mostcentcalllast):File"test.py",line5,inmoduleprint"dict[Alice]:",dict[Alice];KeyError:Alice修改字典向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/pythondict={Name:Zara,Age:7,Class:First};dict[Age]=8;#updateexistingentrydict[School]="DPSSchool";#Addnewentryprint"dict[Age]:",dict[Age];print"dict[School]:",dict[School];以上实例输出结果：
dict[Age]:8dict[School]:DPSSchool删除字典元素能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
#!/usr/bin/python#-*-coding:UTF-8-*-dict={Name:Zara,Age:7,Class:First};deldict[Name];#删除键是Name的条目dict.clear();#清空词典所有条目deldict;#删除词典print"dict[Age]:",dict[Age];print"dict[School]:",dict[School];但这会引发一个异常，因为用del后字典不再存在：
dict[Age]:Traceback(mostcentcalllast):File"test.py",line8,inmoduleprint"dict[Age]:",dict[Age];TypeError:typeobjectisunsubscriptable注：del()方法后面也会讨论。
字典键的特性字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/pythondict={Name:Zara,Age:7,Name:Manni};print"dict[Name]:",dict[Name];以上实例输出结果：
dict[Name]:Manni2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
#!/usr/bin/pythondict={[Name]:Zara,Age:7};print"dict[Name]:",dict[Name];以上实例输出结果：
Traceback(mostcentcalllast):File"test.py",line3,inmoduledict={[Name]:Zara,Age:7};TypeError:listobjectsaunhashable字典内置函数方法Python字典包含了以下内置函数：
序号函数及描述1cmp(dict1,dict2)比较两个字典元素。2len(dict)计算字典元素个数，即键的总数。3str(dict)输出字典可打印的字符串表示。4type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。Python字典包含了以下内置方法：
序号函数及描述1dict.clear()删除字典内所有元素2dict.copy()返回一个字典的浅复制3dict.fromkeys(seq[,val]))创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值4dict.get(key,default=None)返回指定键的值，如果值不在字典中返回default值5dict.has_key(key)如果键在字典dict里返回true，否则返回false6dict.items()以列表返回可遍历的(键,值)元组数组7dict.keys()以列表返回一个字典所有的键8dict.setdefault(key,default=None)和get()类似,但如果键不存在于字典中，将会添加键并将值设为default9dict.update(dict2)把字典dict2的键/值对更新到dict里10dict.values()以列表返回字典中的所有值日期和时间
Python程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
Python提供了一个time和calendar模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从年1月1日午夜（历元）经过了多长时间来表示。
Python的time模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳,如下实例:
#!/usr/bin/python#-*-coding:UTF-8-*-importtime;#引入time模块ticks=time.time()print"当前时间戳为:",ticks以上实例输出结果：
当前时间戳为:.51时间戳单位最适于做日期运算。但是年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到年。
什么是时间元组？很多Python函数用一个元组装起来的9组数字处理时间:
序号字段值04位数年月1到日1到小时0到分钟0到秒0到61(60或61是闰秒)6一周的第几日0到6(0是周一)7一年的第几日1到(儒略历)8夏令时-1,0,1,-1是决定是否为夏令时的旗帜上述也就是struct_time元组。这种结构具有如下属性：
序号属性值0tm_yeartm_mon1到tm_mday1到tm_hour0到tm_min0到tm_sec0到61(60或61是闰秒)6tm_wday0到6(0是周一)7tm_yday1到(儒略历)8tm_isdst-1,0,1,-1是决定是否为夏令时的旗帜获取当前时间从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
#!/usr/bin/python#-*-coding:UTF-8-*-importtimelocaltime=time.localtime(time.time())print"本地时间为:",localtime以上实例输出结果：
本地时间为:time.struct_time(tm_year=,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-*-importtimelocaltime=time.asctime(time.localtime(time.time()))print"本地时间为:",localtime以上实例输出结果：
本地时间为:ThuApr:05:21格式化日期我们可以使用time模块的strftime方法来格式化日期，：
time.strftime(format[,t])#!/usr/bin/python#-*-coding:UTF-8-*-importtime#格式化成-03-:45:39形式printtime.strftime("%Y-%m-%d%H:%M:%S",time.localtime())#格式化成SatMar:24:24形式printtime.strftime("%a%b%d%H:%M:%S%Y",time.localtime())#将格式字符串转换为时间戳a="SatMar:24:24"printtime.mktime(time.strptime(a,"%a%b%d%H:%M:%S%Y"))以上实例输出结果：
-04-0:25:09ThuApr0:25:09145917.0python中时间日期格式化符号：
%y两位数的年份表示（00-99）
%Y四位数的年份表示（-）
%m月份（01-12）
%d月内中的一天（0-31）
%H24小时制小时数（0-23）
%I12小时制小时数（01-12）
%M分钟数（00=59）
%S秒（00-59）
%a本地简化星期名称
%A本地完整星期名称
%b本地简化的月份名称
%B本地完整的月份名称
%c本地相应的日期表示和时间表示
%j年内的一天（-）
%p本地A.M.或P.M.的等价符
%U一年中的星期数（00-53）星期天为星期的开始
%w星期（0-6），星期天为星期的开始
%W一年中的星期数（00-53）星期一为星期的开始
%x本地相应的日期表示
%X本地相应的时间表示
%Z当前时区的名称
%%%号本身
获取某月日历Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
#!/usr/bin/python#-*-coding:UTF-8-*-importcalendarcal=calendar.month(,1)print"以下输出年1月份的日历:"printcal;以上实例输出结果：
以下输出年1月份的日历:JanuaryMoTuWeThFrSaSu789101718192022Time模块Time模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：
序号函数及描述1time.altzone返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。2time.asctime([tupletime])接受时间元组并返回一个可读的形式为"TueDec:07:"（年12月11日周二18时07分14秒）的24个字符的字符串。3time.clock()用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。4time.ctime([secs])作用相当于asctime(localtime(secs))，未给参数相当于asctime()5time.gmtime([secs])接收时间辍（纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为06time.localtime([secs])接收时间辍（纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。7time.mktime(tupletime)接受时间元组并返回时间辍（纪元后经过的浮点秒数）。8time.sleep(secs)推迟调用线程的运行，secs指秒数。9time.strftime(fmt[,tupletime])接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。10time.strptime(str,fmt=%a%b%d%H:%M:%S%Y)根据fmt的格式把一个时间字符串解析为时间元组。11time.time()返回当前时间的时间戳（纪元后经过的浮点秒数）。12time.tzset()根据环境变量TZ重新初始化时间相关设置。Time模块包含了以下2个非常重要的属性：
序号属性及描述1time.timezone属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（0，美洲;=0大部分欧洲，亚洲，非洲）。2time.tzname属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。日历（Calendar）模块此模块的函数都是日历相关的，例如打印某月的字符月历。
星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：
序号函数及描述1calendar.calendar(year,w=2,l=1,c=6)返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。每日宽度间隔为w字符。每行长度为21*W+18+2*C。l是每星期行数。2calendar.firstweekday()返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。3calendar.isleap(year)是闰年返回True，否则为false。4calendar.leapdays(y1,y2)返回在Y1，Y2两年之间的闰年总数。5calendar.month(year,month,w=2,l=1)返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7*w+6。l是每星期的行数。6calendar.monthcalendar(year,month)返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。7calendar.monthrange(year,month)返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。8calendar.prcal(year,w=2,l=1,c=6)相当于printcalendar.calendar(year,w,l,c).9calendar.prmonth(year,month,w=2,l=1)相当于printcalendar.calendar（year，w，l，c）。10calendar.setfirstweekday(weekday)设置每周的起始日期码。0（星期一）到6（星期日）。11calendar.timegm(tupletime)和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间辍（纪元后经过的浮点秒数）。12calendar.weekday(year,month,day)返回给定日期的日期码。0（星期一）到6（星期日）。月份为1（一月）到12（12月）。函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。定义一个函数你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以def关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
turn[表达式]结束函数，选择性地返回一个值给调用方。不带表达式的turn相当于返回None。
语法deffunctionname(parameters):"函数_文档字符串"function_suiteturn[expssion]默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。
实例以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。
defprintme(str):"打印传入的字符串到标准显示设备上"printstrturn函数调用定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：
#!/usr/bin/python#-*-coding:UTF-8-*-#定义函数defprintme(str):"打印任何传入的字符串"printstr;turn;#调用函数printme("我要调用用户自定义函数!");printme("再次调用同一函数");以上实例输出结果：
我要调用用户自定义函数!再次调用同一函数参数传递在python中，类型属于对象，变量是没有类型的：
a=[1,2,3]a="Runoob"以上代码中，[1,2,3]是List类型，"Runoob"是String类型，而变量a是没有类型，她仅仅是一个对象的引用（一个指针），可以是List类型对象，也可以指向String类型对象。
可更改(mutable)与不可更改(immutable)对象在python中，strings,tuples,和numbers是不可更改的对象，而list,dict等则是可以修改的对象。
不可变类型：变量赋值a=5后再赋值a=10，这里实际是新生成一个int值对象10，再让a指向它，而5被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值la=[1,2,3,4]后再赋值la[2]=5则是将listla的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python函数的参数传递：
不可变类型：类似c++的值传递，如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在fun（a）内部修改a的值，只是修改另一个复制的对象，不会影响a本身。
可变类型：类似c++的引用传递，如列表，字典。如fun（la），则是将la真正的传过去，修改后fun外部的la也会受影响
python中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
python传不可变对象实例#!/usr/bin/python#-*-coding:UTF-8-*-defChangeInt(a):a=10b=2ChangeInt(b)printb#结果是2实例中有int对象2，指向它的变量是b，在传递给ChangeInt函数时，按传值的方式复制了变量b，a和b都指向了同一个Int对象，在a=10时，则新生成一个int值对象10，并让a指向它。
传可变对象实例#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明defchangeme(mylist):"修改传入的列表"mylist.append([1,2,3,4]);print"函数内取值:",mylistturn#调用changeme函数mylist=[10,20,30];changeme(mylist);print"函数外取值:",mylist实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：
函数内取值:[10,20,30,[1,2,3,4]]函数外取值:[10,20,30,[1,2,3,4]]参数以下是调用函数时可使用的正式参数类型：
必备参数
关键字参数
默认参数
不定长参数
必备参数必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：
#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明defprintme(str):"打印任何传入的字符串"printstr;turn;#调用printme函数printme();以上实例输出结果：
Traceback(mostcentcalllast):File"test.py",line11,inmoduleprintme();TypeError:printme()takesexactly1argument(0given)关键字参数关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。
以下实例在函数printme()调用时使用参数名：
#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明defprintme(str):"打印任何传入的字符串"printstr;turn;#调用printme函数printme(str="Mystring");以上实例输出结果：
Mystring下例能将关键字参数顺序不重要展示得更清楚：
#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明defprintinfo(name,age):"打印任何传入的字符串"print"Name:",name;print"Age",age;turn;#调用printinfo函数printinfo(age=50,name="miki");以上实例输出结果：
Name:mikiAge50缺省参数调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：
#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明defprintinfo(name,age=35):"打印任何传入的字符串"print"Name:",name;print"Age",age;turn;#调用printinfo函数printinfo(age=50,name="miki");printinfo(name="miki");以上实例输出结果：
Name:mikiAge50Name:mikiAge35不定长参数你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
deffunctionname([formal_args,]*var_args_tuple):"函数_文档字符串"function_suiteturn[expssion]加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例：
#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明defprintinfo(arg1,*vartuple):"打印任何传入的参数"print"输出:"printarg1forvarinvartuple:printvarturn;#调用printinfo函数printinfo(10);printinfo(70,60,50);以上实例输出结果：
输出:10输出:匿名函数python使用lambda来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法lambda函数的语法只包含一个语句，如下：
lambda[arg1[,arg2,.....argn]]:expssion如下实例：
#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明sum=lambdaarg1,arg2:arg1+arg2;#调用sum函数print"相加后的值为:",sum(10,20)print"相加后的值为:",sum(20,20)以上实例输出结果：
相加后的值为:30相加后的值为:40turn语句turn语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的turn语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：
#!/usr/bin/python#-*-coding:UTF-8-*-#可写函数说明defsum(arg1,arg2):#返回2个参数的和."total=arg1+arg2print"函数内:",totalturntotal;#调用sum函数total=sum(10,20);以上实例输出结果：
函数内:30变量作用域一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量
局部变量
全局变量和局部变量定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：
#!/usr/bin/python#-*-coding:UTF-8-*-total=0;#这是一个全局变量#可写函数说明defsum(arg1,arg2):#返回2个参数的和."total=arg1+arg2;#total在这里是局部变量.print"函数内是局部变量:",totalturntotal;#调用sum函数sum(10,20);print"函数外是全局变量:",total以上实例输出结果：
函数内是局部变量:30函数外是全局变量:0模块
Python模块(Module)，是一个Python文件，以.py结尾，包含了Python对象定义和Python语句。模块让你能够有逻辑地组织你的Python代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。模块能定义函数，类和变量，模块里也能包含可执行的代码。
例子
下例是个简单的模块support.py：
support.py模块：defprint_func(par):print"Hello:",parturnimport语句模块的引入模块定义好后，我们可以使用import语句来引入模块，语法如下：
importmodule1[,module2[,...moduleN]比如要引用模块math，就可以在文件最开始的地方用importmath来引入。在调用math模块中的函数时，必须这样引用：
模块名.函数名当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块support.py，需要把命令放在脚本的顶端：
test.py文件代码：#!/usr/bin/python#-*-coding:UTF-8-*-#导入模块importsupport#现在可以调用模块里包含的函数了support.print_func("Runoob")以上实例输出结果：
Hello:Runoob一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
From…import语句Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
frommodnameimportname1[,name2[,...nameN]]例如，要导入模块fib的fibonacci函数，使用如下语句：
fromfibimportfibonacci这个声明不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入到执行这个声明的模块的全局符号表。
From…import*语句把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
frommodnameimport*这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
例如我们想一次性引入math模块中所有的东西，语句如下：
frommathimport*搜索路径当你导入一个模块，Python解析器对模块位置的搜索顺序是：
1、当前目录
2、如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
PYTHONPATH变量作为环境变量，PYTHONPATH由装在一个列表里的许多目录组成。PYTHONPATH的语法和shell变量PATH的一样。
在Windows系统，典型的PYTHONPATH如下：
setPYTHONPATH=c:\python27\lib;在UNIX系统，典型的PYTHONPATH如下：
setPYTHONPATH=/usr/local/lib/python命名空间和作用域变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给全局变量在一个函数里赋值，必须使用global语句。
globalVarName的表达式会告诉Python，VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。
例如，我们在全局命名空间里定义一个变量Money。我们再在函数内给变量Money赋值，然后Python会假定Money是一个局部变量。然而，我们并没有在访问前声明一个局部变量Money，结果就是会出现一个UnboundLocalError的错误。取消global语句的注释就能解决这个问题。
#!/usr/bin/python#-*-coding:UTF-8-*-Money=2defAddMoney():#想改正代码就取消以下注释:#globalMoneyMoney=Money+1printMoneyAddMoney()printMoneydir()函数dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：
#!/usr/bin/python#-*-coding:UTF-8-*-#导入内置math模块importmathcontent=dir(math)printcontent;以上实例输出结果：
[__doc__,__file__,__name__,acos,asin,atan,atan2,ceil,cos,cosh,deges,e,exp,fabs,floor,fmod,fxp,hypot,ldexp,log,log10,modf,pi,pow,radians,sin,sinh,sqrt,tan,tanh]在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。
globals()和locals()函数根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。
load()函数当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用load()函数。该函数会重新导入之前导入过的模块。语法如下：
load(module_name)在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载hello模块，如下：
load(hello)Python中的包包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在__init__.py文件,该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。
考虑一个在package_runoob目录下的runoob1.py、runoob2.py、__init__.py文件，test.py为测试调用包的代码，目录结构如下：
test.pypackage_runoob--__init__.py
--runoob1.py
--runoob2.py
源代码如下：
package_runoob/runoob1.py#!/usr/bin/python#-*-coding:UTF-8-*-defrunoob1():print"Iminrunoob1"package_runoob/runoob2.py#!/usr/bin/python#-*-coding:UTF-8-*-defrunoob2():print"Iminrunoob2"现在，在package_runoob目录下创建__init__.py：package_runoob/__init__.py#!/usr/bin/python#-*-coding:UTF-8-*-if__name__==__main__:print作为主程序运行else:printpackage_runoob初始化然后我们在package_runoob同级目录下创建test.py来调用package_runoob包test.py#!/usr/bin/python#-*-coding:UTF-8-*-#导入Phone包frompackage_runoob.runoob1importrunoob1frompackage_runoob.runoob2importrunoob2runoob1()runoob2()以上实例输出结果：
package_runoob初始化Iminrunoob1Iminrunoob2如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。你也可以在这些文件里定义Python的类，然后为这些类建一个包。
文件I/O
本章只讲述所有基本的的I/O函数，更多函数请参考Python标准文档。打印到屏幕最简单的输出方法是用print语句，你可以给它传递零个或多个用逗号隔开的表达式。此函数把你传递的表达式转换成一个字符串表达式，并将结果写到标准输出如下：
#!/usr/bin/python#-*-coding:UTF-8-*-print"Python是一个非常棒的语言，不是吗？";你的标准屏幕上会产生以下结果：
Python是一个非常棒的语言，不是吗？读取键盘输入Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：
raw_input
input
raw_input函数raw_input([prompt])函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）：
#!/usr/bin/python#-*-coding:UTF-8-*-str=raw_input("请输入：");print"你输入的内容是:",str这将提示你输入任意字符串，然后在屏幕上显示相同的字符串。当我输入"HelloPython！"，它的输出如下：
请输入：HelloPython！你输入的内容是:HelloPython！input函数input([prompt])函数和raw_input([prompt])函数基本类似，但是input可以接收一个Python表达式作为输入，并将运算结果返回。
#!/usr/bin/python#-*-coding:UTF-8-*-str=input("请输入：");print"你输入的内容是:",str这会产生如下的对应着输入的结果：
请输入：[x*5forxinrange(2,10,2)]你输入的内容是:[10,20,30,40]打开和关闭文件现在，您已经可以向标准输入和输出进行读写。现在，来看看怎么读写实际的数据文件。
Python提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用file对象做大部分的文件操作。
fileobject=open(file_name[,access_mode][,buffering])open函数你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
语法：
fileobject=open(file_name[,access_mode][,buffering])各个参数的细节如下：
file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
不同模式打开文件的完全列表：
模式描述r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。r+打开一个文件用于读写。文件指针将会放在文件的开头。rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。File对象的属性一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
属性描述file.closed返回true如果文件已被关闭，否则返回false。file.mode返回被打开文件的访问模式。file.name返回文件的名称。file.softspace如果用print输出后，必须跟一个空格符，则返回false。否则返回true。如下实例：
#!/usr/bin/python#-*-coding:UTF-8-*-#打开一个文件fo=open("foo.txt","wb")print"文件名:",fo.nameprint"是否已关闭:",fo.closedprint"访问模式:",fo.modeprint"末尾是否强制加空格:",fo.softspace以上实例输出结果：
文件名:foo.txt是否已关闭:False访问模式:wb末尾是否强制加空格:0close()方法File对象的close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python会关闭之前的文件。用close（）方法关闭文件是一个很好的习惯。
语法：
fileObject.close();例子：
#!/usr/bin/python#-*-coding:UTF-8-*-#打开一个文件fo=open("foo.txt","wb")print"文件名:",fo.name#关闭打开的文件fo.close()以上实例输出结果：
文件名:foo.txt读写文件：
file对象提供了一系列方法，能让我们的文件访问更轻松。来看看如何使用ad()和write()方法来读取和写入文件。
write()方法write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(\n)：
语法：
fileObject.write(string);在这里，被传递的参数是要写入到已打开文件的内容。
例子：
#!/usr/bin/python#-*-coding:UTF-8-*-#打开一个文件fo=open("foo.txt","wb")fo.write("