目录
说明：具体内容参考 菜鸟教程 。
Python 字符串连接
a = '123'+'456'
Python 访问字符串中的值
b = a[1:3]#23
b = a[1:]#3456
b = a[:3]#123
Python 转义字符
Python字符串运算符
* 、 + 、 [] 、 in 、 not in
Python 字符串格式化
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
Python三引号（triple quotes）
a='''ab
c'''
print a
输出：
ab
c
Unicode 字符串
引号前小写的"u"表示这里创建的是一个 Unicode 字符串。
print u'123' #123
python的字符串内建函数
string.capitalize() 把字符串的第一个字符大写
a='abc'
a=a.capitalize() #Abc
a='abc'
a.isalpha() #True a中是不是全为字母；
a.isdigit() #False a中是不是全为数字；
a='aBc'
a.swapcase() #AbC 翻转a中的大小写
Python 列表
a=["a", "b", "c", "d"] #['a', 'b', 'c', 'd']
访问列表中的值
print a[0] #a
print a[1:3] #['b', 'c']
更新列表
a.append('e')
print a #['a', 'b', 'c', 'd', 'e']
a[0] = 'f'
print a #['f', 'b', 'c', 'd', 'e']
删除列表元素
a=["a", "b", "c", "d"]
del a[3]
print a #['a', 'b', 'c']
Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
a=["a", "b", "c", "d"]+[1,'f']
print a*2 #['a', 'b', 'c', 'd', 1, 'f', 'a', 'b', 'c', 'd', 1, 'f']
print len(a) #6
print 'a' in a #True
a=["a", "b", "c"]
for x in a:
print x
输出：
a
a
c
Python列表截取
a=["a", "b", "c", "d"]
print a[2] #c 读取列表中第三个元素
print a[-2] #c 读取列表中倒数第二个元素
print a[2:] #['c', 'd'] 从第三个元素开始截取列表
Python列表函数&方法
a=['a','a','c','a']
print(max(a)) #c 列表中的最大值
print(min(a)) #a 列表中的最小值
print(a.count('a')) #3 a出现的次数
a.remove('a')
print(a) #['a', 'c', 'a'] a.remove('a') 移除列表中某个值的 第一个 匹配项
a=['a','b','c']
a.reverse()
print(a) #['c', 'b', 'a'] a.reverse() 反向列表中元素
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
a=("a", "b", "c", "d") #('a', 'b', 'c', 'd')
元组中只包含一个元素时，需要在元素后面添加逗号
a=("a", ) #('a', )
访问元组、元组索引，截取
元组可以使用下标索引来访问元组中的值（List）。如下实例:
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
a=("a", 'b','c','d')
print a[1:] #('b','c','d')
print a[:2] #("a", 'b')
print a[1:3] #('b','c')
print a[0] #a
print a[-1] #d
b=a[0:2]#("a", 'b')
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
a=(1,2)
b=(3,4)
# a[0]=1 #TypeError: 'tuple' object does not support item assignment 类型错误: 元组对象不支持项分配
c=a+b
print c #(1, 2, 3, 4)
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
a=(1,2)
del a
print a #NameError: name 'a' is not defined a 没有被定义
元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
a=(1,2,3)
b=(4,5,6)
print len(a) #3
print a+b #(1, 2, 3, 4, 5, 6) ''
print a*2 #(1, 2, 3, 1, 2, 3)
print 1 in a #True
for x in a :
print x #1 2 3
无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组，如下实例：
print '1','2' #1 2
a,b=3,4
print a,b #3 4
元组内置函数
Python元组包含了以下内置函数
a=(1,2)
b=(1,2)
c=(3,4)
d=[5,6]
print cmp(a,b) #0 比较两个元组元素。
print cmp(a,c) #-1
print len(a) #2 计算元组元素个数。
print max(a) #2 返回元组中元素最大值。
print min(a) #1 返回元组中元素最小值。
c=tuple(d)
print c #(5, 6) 将列表转换为元组。
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
a={'key1':'value','key2':'value2'} #{'key2': 'value2', 'key1': 'value'}
print a
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
a={'key1':'value','key2':'value2','key1':'value3'}
print a['key1'] #value3
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
b=(1,2)
c=[3,4]
a={'key1':b,'key2':c,'key3':3,'key4':'value4'}
print a #{'key3': 3, 'key2': [3, 4], 'key1': (1, 2), 'key4': 'value4'}
访问字典里的值
print a['key2'] #[3, 4]
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
a={'key1':1,'key2':2,'key3':3}
a['key1']=0 #更改 {'key3': 3, 'key2': 2, 'key1': 0}
print a
a['key4']=4 #添加 {'key3': 3, 'key2': 2, 'key1': 0, 'key4': 4}
print a
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
a={'key1':1,'key2':2,'key3':3}
# del a['key5']#KeyError: 'key5'
del a['key3']
print a #{'key2': 2, 'key1': 1}
a.clear()
print a #{}
del a
print a #NameError: name 'a' is not defined
字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
a={'key1':1,'key1':2,'key3':3}
print a['key1'] #2
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
b=(1,2)
a={1:1,b:2,'key3':3} #{(1, 2): 2, 1: 1, 'key3': 3}
print a
字典内置函数&方法
Python字典包含了以下内置函数：
a={'key1':1,'key2':2,'key3':3}
b={'key1':1,'key2':2,'key3':3}
c={'key1':1,'key2':2,'key4':4}
d={'key1':1,'key2':2}
print cmp(a,b) #0 比较两个字典元素。 0:相同，1：包含关系(前面包含后面)？，-1：有key或value 不相同
print cmp(a,c) #-1
print cmp(a,d) #1 a包含d
print len(a) #3 计算字典元素个数，即键的总数。
e= str(a) #输出字典可打印的字符串表示。此处e为字符串。即字典转字符串。
print e #{'key3': 3, 'key2': 2, 'key1': 1}
print e[0:5] # {'key
print type(a) # 返回输入的变量类型，如果变量是字典就返回字典类型。
f=[1,2]
print type(f) #
Python字典包含了以下内置方法：
a={'key1':1,'key2':2,'key3':3}
a.clear()
print a #{}
a={'key1':1,'key2':2,'key3':3}
b=a.copy() #返回一个字典的浅复制
print b #{'key3': 3, 'key2': 2, 'key1': 1}
print a.popitem() #('key3', 3) 返回并删除字典中的最后一对键和值。
print a.values() #[2, 1] 以列表返回字典中的所有值。
a={'key1':1,'key2':2}
b={'key3':3}
b.update(a)
print b #{'key3': 3, 'key2': 2, 'key1': 1} 把字典 a 的键/值对更新到 b 里
print a.has_key('key1') #True 如果键在字典dict里返回true，否则返回false
print a.get('key4',4) #4 返回指定键的值，如果值不在字典中返回default值
Python 日期和时间
Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:
import time
ticks = time.time() #1575276214.79
print ticks
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
什么是时间元组？
很多Python函数用一个元组装起来的9组数字处理时间,这种结构具有如下属性:
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之类的函数。
localTime = time.localtime(time.time())
#time.struct_time(tm_year=2019, tm_mon=12, tm_mday=2, tm_hour=16, tm_min=49, tm_sec=46, tm_wday=0, tm_yday=336, tm_isdst=0)
print localTime.tm_year #2019
获取格式化的时间
你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
localTime = time.asctime(time.localtime(time.time()))
print localTime # Mon Dec 2 16:54:31 2019
格式化日期
我们可以使用 time 模块的 strftime 方法来格式化日期，：
from1 = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()) # 格式化成 2019-12-02 16:57:50 形式
from2 = time.strftime('%A %b %d %H:%M:%S %Y', time.localtime()) # 格式化成 Monday Dec 02 16:59:59 2019 形式
a = "Mon Dec 02 16:59:59 2019"
from3 = time.mktime(time.strptime(a, '%a %b %d %H:%M:%S %Y')) # 将格式字符串，转换为时间戳： 1575277199.0
print from1
print from2
print from3
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模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
import calendar
cal = calendar.month(2019,12)
print cal
输出
December 2019
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 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：(具体参考链接)
print time.time() #1575336329.21
print time.clock() #用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
time.sleep(2) #推迟调用线程的运行，secs指秒数。
Time模块包含了以下2个非常重要的属性：???
print time.timezone #-28800 属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。
print time.tzname #('CST', 'CST') 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。
日历（Calendar）模块
此模块的函数都是日历相关的，例如打印某月的字符月历。
星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：(具体参考链接)
year=2019
print calendar.calendar(year,w=2,l=2,c=6) #输出 year 一年的日历，w:一个月内的列间距；l：月内的行间距；c:月份之间的列间距。 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
print calendar.firstweekday() #0 返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。
print calendar.isleap(2019) #False 是闰年返回 True，否则为 False。
print calendar.leapdays(1700,2019) #77 返回在Y1，Y2两年之间的闰年总数。Python 函数
其他相关模块和函数
在Python中，其他处理日期和时间的模块还有：
Python 函数
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例
以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。
def printtime( str ):
"打印传入的字符串到标准显示设备上"
print str
return
函数调
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：
printtime('你好啊') # 你好啊
参数传递
在 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 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
python 传不可变对象实例
# 实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print b #2
传可变对象实例
def channgeme( list ):
"修改传入的列表"
list.append([1,2,3,4]); #函数内取值: [10, 20, 30, (1, 2, 3, 4)]
print "函数内取值:",mylist
return
# 调用changeme 函数
mylist = [10,20,30]
channgeme( mylist )
print "函数外取值:",mylist #函数外取值: [10, 20, 30, (1, 2, 3, 4)]
参数
以下是调用函数时可使用的正式参数类型：
必备参数
关键字参数
默认参数
不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：
def printme( str ):
"打印任何输入的字符串"
print str
return
# 调用 printme 函数
printme('你好') #你好，如果不传入参数 运行就会出现语法错误。
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
参数传入的顺序不重要，
def printme( str1,str2 ):
"打印任何输入的字符串"
print str1,str2
return
printme(str2 ='你好',str1=1) #1 你好，
默认参数
调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：
def printinfo( nsme, age = 35 ):
"打印任何传入的字符串"
print 'name:',nsme,'age:',age
return
printinfo('张三','18') #name: 张三 age: 18
printinfo('张三') #name: 张三 age: 35
不定长参数
def prientinfo( arge1, *vartuple ):
"打印任何输入的参数"
print '开始输出'
print arge1
for var in vartuple:
print var
return
prientinfo(10) #开始输出 10
prientinfo(70,60,90) #开始输出 70 60 90
匿名函数
python 使用 lambda 来创建匿名函数。
sum = lambda arg1,arg2:arg1+arg2
print '相加后的值为', sum( 10, 20 ) #相加后的值为 30
print '相加后的值为', sum( 30, 30 ) #相加后的值为 60
return 语句
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：
def sum ( arg1,arg2 ):
sumvalue = arg2+arg1
print '函数内：',sumvalue
return sumvalue #函数内： 30
totle = sum(10,20)
print '函数外：',totle #函数内： 30
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：
total = 0 #这是一个全局变量
def sum ( arg1,arg2 ):
total = arg2+arg1 #total 在这里是局部变量
print '函数内：',total
return total #函数内： 30
total2 = sum(10,20)
print total,total2 #0 30
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
下例是个简单的模块 support.py：
def print_func( par ):
print 'hello :',par
return
def print_func_2( par ):
print 'hello :',par
return
import 语句
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：
import module1[, module2[,... moduleN]]
比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：
模块名.函数名
当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support.py，需要把命令放在脚本的顶端：
# 导入模块
import support
# 现在可以调用模块里包含的函数了
import support
support.print_func('Runoob') #hello : Runoob
一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from support import print_func
print print_func(12) #hello : 12
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。
from…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
from support import *
print_func(10) #hello : 10
print_func_2(20) #hello : 20
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
例如我们想一次性引入 math 模块中所有的东西，语句如下：
搜索路径
当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
1、当前目录
2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
PYTHONPATH 变量
作为环境变量，PYTHONPATH 由装在一个列表里的许多目录组成。PYTHONPATH 的语法和 shell 变量 PATH 的一样。
在 Windows 系统，典型的 PYTHONPATH 如下：set PYTHONPATH=c:\python27\lib;
在 UNIX 系统，典型的 PYTHONPATH 如下???：set PYTHONPATH=/usr/local/lib/python
命名空间和作用域
变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python 会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给函数内的全局变量赋值，必须使用 global 语句。
global VarName 的表达式会告诉 Python， VarName 是一个全局变量，这样 Python 就不会在局部命名空间里寻找这个变量了。
例如，我们在全局命名空间里定义一个变量 Money。我们再在函数内给变量 Money 赋值，然后 Python 会假定 Money 是一个局部变量。然而，我们并没有在访问前声明一个局部变量 Money，结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句前的注释符就能解决这个问题。
money = 100
def AddMoney():
global money #不写 global 编译会报错
money = money + 1
return
AddMoney()
print money #101
dir()函数
dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：
# 导入内置math模块
import math
content = dir(math)
print content #['__doc__', '__file__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。???
globals() 和 locals() 函数
根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
reload() 函数
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：
reload(module_name)
在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载 hello 模块，如下：
reload(support)
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、__init__.py 文件，test.py 为测试调用包的代码，目录结构如下：
test.py
package_runoob
|-- __init__.py
|-- runoob1.py
|-- runoob2.py
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、__init__.py 文件，test.py 为测试调用包的代码，目录结构如下：
test.py
package_runoob
|-- __init__.py
|-- runoob1.py
|-- runoob2.py
具体参考讲义；
package_runoob/runoob1.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-
def runoob1():
print "I'm in runoob1"
package_runoob/runoob2.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-
def runoob2():
print "I'm in runoob2"
现在，在 package_runoob 目录下创建 __init__.py(创建文件夹package_runoob的啥时候回自动创建)：
package_runoob/__init__.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-
if __name__ == '__main__':
print '作为主程序运行'
else:
print 'package_runoob 初始化'
然后我们在 package_runoob 同级目录下创建 test.py 来调用 package_runoob 包
test.py
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 导入 Phone 包
from package_runoob.runoob1 import runoob1
from package_runoob.runoob2 import runoob2
runoob1()
runoob2()
以上实例输出结果：
package_runoob 初始化
I'm in runoob1
I'm in runoob2
如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。你也可以在这些文件里定义Python的类，然后为这些类建一个包。
Python 文件I/O
本章只讲述所有基本的 I/O 函数，更多函数请参考Python标准文档。
打印到屏幕
最简单的输出方法是用print语句，你可以给它传递零个或多个用逗号隔开的表达式。此函数把你传递的表达式转换成一个字符串表达式，并将结果写到标准输出如下：
print 'python 是一个非常棒的语言'
读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：
raw_input
input
raw_input函数
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）：
str = raw_input('请输入：') #请输入：hello python
print '你输入的内容是：',str #你输入的内容是： hello python
这将提示你输入任意字符串，然后在屏幕上显示相同的字符串。当我输入"Hello Python！"，它的输出如下：
input函数
input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
str = input('请输入：') #请输入：[x*5 for x in range(2,10,2)]
print '你输入的内容是：',str #你输入的内容是： [10, 20, 30, 40]
打开和关闭文件
现在，您已经可以向标准输入和输出进行读写。现在，来看看怎么读写实际的数据文件。
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。
open 函数
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
语法：
file object = open(file_name [, access_mode][, buffering])
集体参考 学习链接
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
file.closed 果文件已被关闭 返回true如，否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。
# 打开一个文件
fo = open('foo.txt','w') # w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
print '文件名：',fo.name #文件名： foo.txt
print '是否已关闭：',fo.closed #是否已关闭： False
print '访问模式：',fo.mode #访问模式： w
print '末尾是否强制加空格：',fo.softspace #末尾是否强制加空格： 0
close()方法
File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。
语法：fileObject.close()
# 打开一个文件
fo = open("foo.txt", "w")
print "文件名: ", fo.name #文件名: foo.txt
# 关闭打开的文件
fo.close()
file对象提供了一系列方法，能让我们的文件访问更轻松。来看看如何使用read()和write()方法来读取和写入文件。
write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符('\n')：
语法：fileObject.write(string)
在这里，被传递的参数是要写入到已打开文件的内容。
of = open('foo.txt','w')
of.write('www.runoob.com!\nVery good site !\n')
of.closed
上述方法会创建foo.txt文件，并将收到的内容写入该文件，并最终关闭文件。如果你打开这个文件，将看到以下内容:
www.runoob.com!
Very good site !
read()方法
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：fileObject.read([count])
在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
fo = open("foo.txt", "r+")
str = fo.read(10)
print "读取的字符串是 : ", str #读取的字符串是 : www.runoob
fo.closed
文件定位
tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
例子：
就用我们上面创建的文件foo.txt。
#打开一个文件
fo = open('foo.txt','r+')
str = fo.read(10)
print '读取的字符串是：',str
#查找当前位置
position = fo.tell()
print '当前文件位置：',position #读取的字符串是： www.runoob
#把指针再次指定到文件开头
position = fo.seek(0,1) #Offset设置为0，变量表示要移动的字节数； from 设置为1：表示使用当前的位置作为参考位置
str = fo.read(10)
print '重新读取的字符串：',str #重新读取的字符串： .com!
#关闭打开的文件
print fo.closed #False
fo.close()
print fo.closed #True
重命名和删除文件
Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。
要使用这个模块，你必须先导入它，然后才可以调用相关的各种功能。
rename()方法：rename()方法需要两个参数，当前的文件名和新文件名。
语法：os.rename(current_file_name, new_file_name)
下例将重命名一个已经存在的文件test1.txt。
import os
# 重命名foo.txt到test2.txt
os.renames('foo.txt','test2.txt') #文件名已更改为：test2.txt
remove()方法
你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。
语法：os.remove(file_name)
# fo = open('test1.txt','w') #创建文件 test1.txt
例子：
下例将删除一个已经存在的文件 test1.txt。
删除一个已经存在的文件 test1.txt
os.remove('test1.txt') #test1.txt被成功删除
Python里的目录：
所有文件都包含在各个不同的目录下，不过Python也能轻松处理。os模块有许多方法能帮你创建，删除和更改目录。
mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
语法：os.mkdir("newdir")
下例将在当前目录下创建一个新目录test。
import os
#创建目录/package test
os.mkdir('test')
chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
语法：os.chdir("newdir")
# 将当前目录改为"/home/newdir" ???
os.chdir("/home/newdir")
getcwd()方法：
getcwd()方法显示当前的工作目录。
语法：os.getcwd()
print os.getcwd() #/Users/freevision/PycharmProjects/helloPython
rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
语法：os.rmdir('dirname')
os.rmdir('test') #test 目录被删除
文件、目录相关的方法
File 对象和 OS 对象提供了很多文件与目录的操作方法，可以通过点击下面链接查看详情：
File 对象方法: file 对象提供了操作文件的一系列方法。
OS 对象方法: 提供了处理文件及目录的一系列方法。
Python File(文件) 方法
open() 方法
Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
完整的语法格式为：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明:
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:
mode 参数有：
具体参考：mode 参数
默认为文本模式，如果要以二进制模式打开，加上 b 。
file 对象
file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：
具体参考：file 对象常用的函数
file.close() 关闭文件。关闭后文件不能再进行读写操作。
file.tell() 返回文件当前位置。
file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
obj = open('foo.txt','w')
obj.writelines('\n\naaa\n\nbbb\n\n') #只保留写入的内容，旧的内容都会被删掉
print obj.tell()
obj.close()
print obj.closed #True
Python 异常处理
python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。你可以使用该功能来调试python程序。
异常处理: 本站Python教程会具体介绍。
断言(Assertions):本站Python教程会具体介绍。
具体参考：Python 异常处理
什么是异常？
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
以下为简单的try....except...else的语法：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
实例:
try:
fh = open("testfile2", "w")#"k"
fh.write("这是一个测试文件，用于测试异常!!")
print fh
except : #mode 为"k"时，执行这一条语句
print "Error: 没有找到文件或读取文件失败"
else:
print "内容写入文件成功"
fh.close()
使用except而不带任何异常类型
你可以不带任何异常类型使用except，如下实例：
try:
正常的操作
......................
except:
发生异常，执行这块代码
......................
else:
如果没有异常执行这块代码
以上方式try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。
使用except而带多种异常类型
你也可以使用相同的except语句来处理多个异常信息，如下所示：
try:
正常的操作
......................
except(Exception1[, Exception2[,...ExceptionN]]]):
发生以上多个异常中的一个，执行这块代码
......................
else:
如果没有异常执行这块代码
try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句> #退出try时总会执行
raise
实例：
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print "Error: 没有找到文件或读取文件失败"
同样的例子也可以写成如下方式：
try:
fh = open("testfile", "w")
try:
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print "关闭文件"
fh.close()
except IOError:
print "Error: 没有找到文件或读取文件失败"
当在try块中抛出一个异常，立即执行finally块代码。
finally块中的所有语句执行后，异常被再次触发，并执行except块代码。
参数的内容不同于异常。
异常的参数
一个异常可以带上参数，可作为输出的异常信息参数。
你可以通过except语句来捕获异常的参数，如下所示：
try:
正常的操作
......................
except ExceptionType, Argument:
你可以在这输出 Argument 的值...
变量接收的异常值通常包含在异常的语句中。 在元组的表单中变量可以接收一个或者多个值。
元组通常包含错误字符串，错误数字，错误位置。
def temp_convert(var):
try:
return int(var)
except ValueError,Argument:
print '参数没有包含数字\n',Argument
#调用函数
temp_convert('xy2')
输出：
参数没有包含数字
invalid literal for int() with base 10: 'xy2'
触发异常
我们可以使用raise语句自己触发异常
raise语法格式如下：raise [Exception [, args [, traceback]]]
语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。
最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。
实例
一个异常可以是一个字符串，类或对象。 Python的内核提供的异常，大多数都是实例化的类，这是一个类的实例的参数。
定义一个异常非常简单，如下所示：???
def functionName( lever ):
if lever < 1:
raise Exception('Invalid level',lever)
# 触发异常后，后面的代码就不会再执行
try:
mye(0): #触发异常
except Exception,err:
print 1,err
else:
print 2
用户自定义异常
通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。
以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。
在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。
class Networkerror(RuntimeError):
def __init__(self,arg):
self.args = arg
try:
raise Networkerror('Bad hostname')
except Networkerror,e:
print e.args
输出：('B', 'a', 'd', ' ', 'h', 'o', 's', 't', 'n', 'a', 'm', 'e')
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：
os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
fd -- 文件描述符。n -- 读取的字节。
os.close(fd) 关闭文件描述符 fd
# 打开文件
fd = os.open("foo.txt",os.O_RDWR)
#fd 中读取最多 10 个字节
print os.read(fd,10) #aaabbbcccd
# 关闭文件
os.close(fd)
print "关闭文件成功!!"
os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
import os
os.renames('foo.txt','foo1.txt') #文件名 foo.txt 改为 foo1.txt
具体参考：Python OS 文件/目录方法
abs() 函数返回数字的绝对值。
print abs(-13.5) #13.5
divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
语法：divmod(a, b)
print divmod(7,3) #(2, 1)
print divmod(1+2j,1+0.5j) #((1+0j), 1.5j)
input() 函数
注意：input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
注意：python3 里 input() 默认接收到的是 str 类型。
a = input("input:")
print type (a) #
print a #123
b = raw_input("input:")
print type (b) #
print b
a=input() #直接输入字符串 aaa 提示：NameError: name 'aaa' is not defined 输入'aaa' 才会正常打印 aaa
print a
open() 函数
python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
函数语法:open(name[, mode[, buffering]])
参数说明：
name : 一个包含了你要访问的文件名称的字符串值。
mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
file 对象方法
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
f.close() 关闭文件
file.readline()：返回一行。
具体参考：Python open() 函数
file = open('foo.txt','r',1)
print file.readline() #返回一行。aaabbbcccdddeeefffggghhh
file.close()
print file.closed #True
staticmethod() 函数
python staticmethod 返回函数的静态方法。
该方法不强制要求传递参数，如下声明一个静态方法：
class C(object):
@staticmethod
def f():
print 'runoob'
C.f()
cobj = C()
cobj.f()
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、None、False 外都算 True。
iterable -- 参数要可迭代:如元组、列表、字符串.
如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
注意：空元组、空列表返回值为True，这里要特别注意。
print all('') #True
print all(()) #True
print all([]) #True
print all([1]) #True
print all([0]) #False
print all([1,1,0]) #False
print all([None,False,0]) #False
int() 函数用于将一个字符串或数字转换为整型。
int() 方法的语法: class int(x, base=10)
参数:
x -- 字符串或数字。
base -- 进制数，默认十进制。
print int() #0 不传入参数时，得到结果0
print int(3) #3
print int('3') #3
print int('0x0a',16) #10 如果是带参数base的话，a要以字符串的形式进行输入，a 为 16进制
print int('a',16) #10
print int('12',8) #10
print int('1010',2) #10
enumerate() 函数
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
语法：enumerate(sequence, [start=0])
参数：
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
返回值：返回 enumerate(枚举) 对象。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print list(enumerate(seasons)) #[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print list(enumerate(seasons, start=1)) # 下标从 1 开始 [(1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
i = 0
for element in seasons:
print i , element #seasons[i]
i +=1
for k , element in enumerate(seasons):
print k,element
输出：
0 Spring
1 Summer
2 Fall
3 Winter
0 Spring
1 Summer
2 Fall
3 Winter
人上的套路亦如此：语法，参数，返回值；
具体参考：Python 内置函数
贵有恒！
