Python是一种怎样的语言 ：Python是一门跨平台、开源、免费的解释型高级动态编程语言，支持伪编译将Python源程序转换为字节码来优化程序和提高运行速度，支持使用py2exe（更新到2008年）、pyinstaller（-F生成单一文件exe，-p搜索路径）、py2app（适用于 macOS）或cx_Freeze工具将Python程序转换为二进制可执行文件。
Python支持命令式编程、函数式编程，完全支持面向对象程序设计，语法简洁清晰，拥有大量的几乎支持所有领域应用开发的成熟扩展库。
胶水语言：可以把多种不同语言编写的程序融合到一起实现无缝拼接，更好地发挥不同语言和工具的优势，满足不同应用领域的需求。
默认编程环境：IDLE。其他常用开发环境：Eclipse+PyDev、pyCharm、wingIDE、Eric、PythonWin、Anaconda
使用pip管理第三方包
pip命令示例说明pip download SomePackage[==version]下载扩展库的指定版本，不安装pip freeze [> requirements.txt]以requirements的格式列出已安装模块pip list列出当前已安装的所有模块pip install SomePackage[==version]在线安装SomePackage模块的指定版本pip install SomePackage.whl通过whl文件离线安装扩展库pip install package1 package2 …依次（在线）安装package1、package2等扩展模块pip install -r requirements.txt安装requirements.txt文件中指定的扩展库pip install --upgrade SomePackage升级SomePackage模块pip uninstall SomePackage[==version]卸载SomePackage模块的指定版本Python属于强类型编程语言，Python解释器会根据赋值或运算来自动推断变量类型。Python还是一种动态类型语言，变量的类型也是可以随时变化的。
>>> x = 3 >>> print(type(x)) <class 'int'> >>> x = 'Hello world.' >>> print(type(x)) #查看变量类型 <class 'str'> >>> x = [1,2,3] >>> print(type(x)) <class 'list'> >>> isinstance(3, int) #测试对象是否是某个类型的实例 True >>> isinstance('Hello world', str) True如果变量出现在赋值运算符或复合赋值运算符（例如+=、*=等等）的左边则表示创建变量或修改变量的值，否则表示引用该变量的值，这一点同样适用于使用下标来访问列表、字典等可变序列以及其他自定义对象中元素的情况。
>>> x = 3 #创建整型变量 >>> print(x**2) 9 >>> x += 6 #修改变量值 >>> print(x) #读取变量值并输出显示 9 >>> x = [1,2,3] #创建列表对象 >>> x[1] = 5 #修改列表元素值 >>> print(x) #输出显示整个列表 [1, 5, 3] >>> print(x[2]) #输出显示列表指定元素 3字符串和元组属于不可变序列，不能通过下标的方式来修改其中的元素值，试图修改元组中元素的值时会抛出异常。
>>> x = (1,2,3) >>> print(x) (1, 2, 3) >>> x[1] = 5 Traceback (most recent call last): File "<pyshell#7>", line 1, in <module> x[1] = 5 TypeError: 'tuple' object does not support item assignment在Python中，允许多个变量指向同一个值，例如：
>>> x = 3 #x指向3 >>> id(x) 1786684560 >>> y = x #y指向3 >>> id(y) 1786684560 >>> 然而，当为其中一个变量修改值以后，其内存地址将会变化，但这并不影响另一个变量，例如接着上面的代码再继续执行下面的代码： >>> x += 6 #x指向9 >>> id(x) 1786684752 >>> y 3 >>> id(y) 1786684560Python采用的是基于值的内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只有一份，多个变量指向同一块内存地址。
>>> x = 3 >>> id(x) 10417624 >>> y = 3 >>> id(y) 10417624 >>> x = [1, 1, 1, 1] >>> id(x[0]) == id(x[1]) TruePython具有自动内存管理功能，对于没有任何变量指向的值，Python自动将其删除。Python会跟踪所有的值，并自动删除不再有变量指向的值。因此，Python程序员一般情况下不需要太多考虑内存管理的问题。尽管如此，显式使用del命令删除不需要的值或显式关闭不再需要访问的资源，仍是一个好的习惯，同时也是一个优秀程序员的基本素养之一。
在定义变量名的时候，需要注意以下问题：
变量名必须以字母或下划线开头，但以下划线开头的变量在Python中有特殊含义；变量名中不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等等）；不能使用关键字作变量名，可以导入keyword模块后使用print(keyword.kwlist)查看所有Python关键字；不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名，这将会改变其类型和含义，可以通过dir(__builtins__)查看所有内置模块、类型和函数；变量名对英文字母的大小写敏感，例如student和Student是不同的变量。数字是不可变对象，可以表示任意大小的数字。
>>> a=99999999999999999999999999999999 >>> a*a 9999999999999999999999999999999800000000000000000000000000000001 >>> a**3 999999999999999999999999999999970000000000000000000000000000000299999999999999999999999999999999Python的IDEL交互界面可以当做简便计算器来使用。
>>> ((3**2) + (4**2)) ** 0.5 5.0Python数类型可以分为：
十进制整数如，0、-1、9、123
十六进制整数，需要16个数字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f来表示整数，必须以0x开头，如0x10、0xfa、0xabcdef
八进制整数，只需要8个数字0、1、2、3、4、5、6、7来表示整数，必须以0o开头，如0o35、0o11
二进制整数，只需要2个数字0、1来表示整数，必须以0b开头如，0b101、0b100
浮点数又称小数：15.0、0.37、-11.2、1.2e2、314.15e-2
Python内置支持复数类型：
>>> a = 3+4j >>> b = 5+6j >>> c = a+b >>> c (8+10j) >>> c.real #查看复数实部 8.0 >>> c.imag #查看复数虚部 10.0 >>> a.conjugate() #返回共轭复数 (3-4j) >>> a*b #复数乘法 (-9+38j) >>> a/b #复数除法 (0.6393442622950819+0.03278688524590165j)字符串合并
>>> a = 'abc' + '123' #生成新对象字符串格式化
>>> a = 3.6674 >>> '%7.3f' % a >>> ' 3.667' >>> "%d:%c"%(65,65) >>> '65:A' >>> """My name is %s, and my age is %d""" % ('Dong Fuguo',39) >>> 'My name is Dong Fuguo, and my age is 39'转义字符用法
>>> print('Hello\nWorld') #包含转义字符的字符串 Hello World >>> print('\101') #三位八进制数对应的字符 A >>> print('\x41') #两位十六进制数对应的字符 A >>> print('我是\u8463\u4ed8\u56fd') #四位十六进制数表示的Unicode字符 我是董付国字符串界定符前面加字母r表示原始字符串，其中的特殊字符不进行转义，**但字符串的最后一个字符不能是**。原始字符串主要用于正则表达式、文件路径或者URL的场合。
>>> path = 'C:\Windows\notepad.exe' >>> print(path) #字符\n被转义为换行符 C:\Windows otepad.exe >>> path = r'C:\Windows\notepad.exe' #原始字符串，任何字符都不转义 >>> print(path) C:\Windows\notepad.exe+运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或连接。
>>> [1, 2, 3] + [4, 5, 6] #连接两个列表 [1, 2, 3, 4, 5, 6] >>> (1, 2, 3) + (4,) #连接两个元组 (1, 2, 3, 4) >>> 'abcd' + '1234' #连接两个字符串 'abcd1234' >>> 'A' + 1 #不支持字符与数字相加，抛出异常 TypeError: Can't convert 'int' object to str implicitly >>> True + 3 #Python内部把True当作1处理 4 >>> False + 3 #把False当作0处理 3*运算符不仅可以用于数值乘法，还可以用于列表、字符串、元组等类型，当列表、字符串或元组等类型变量与整数进行“*”运算时，表示对内容进行重复并返回重复后的新对象。
>>> 2.0 * 3 #浮点数与整数相乘 6.0 >>> (3+4j) * 2 #复数与整数相乘 (6+8j) >>> (3+4j) * (3-4j) #复数与复数相乘 (25+0j) >>> "a" * 10 #字符串重复 'aaaaaaaaaa' >>> [1,2,3] * 3 #列表重复 [1, 2, 3, 1, 2, 3, 1, 2, 3] >>> (1,2,3) * 3 #元组重复 (1, 2, 3, 1, 2, 3, 1, 2, 3)Python中的除法有两种，“/”和“//”分别表示除法和整除运算，并且Python 2.x和Python 3.x对“/”运算符的解释也略有区别。在Python 3.5.2中运算结果如下：
>>> 3/5 0.6 >>> 3//5 0 >>> 3.0/5 0.6 >>> 3.0//5 0.0 >>> 13//10 1 >>> -13//10 -2上面的表达式在Python 2.7.12中运算结果如下：
>>> 3/5 0 >>> 3//5 0 >>> 3.0/5 0.6 >>> 3.0//5 0.0 >>> 13//10 1 >>> -13//10 -2%运算符除去可以用于字符串格式化之外，还可以对整数和浮点数计算余数。但是由于浮点数的精确度影响，计算结果可能略有误差。
>>> 3.1%2 1.1 >>> 6.3%2.1 #精确度影响 2.0999999999999996 >>> 6%2 0 >>> 6.0%2 0.0 >>> 6.0%2.0 0.0 >>> 5.7%4.8 0.9000000000000004关系运算符可以连用
>>> 1 < 3 < 5 #等价于1 < 3 and 3 < 5 True >>> 'Hello' > 'world' #比较字符串大小 False >>> [1, 2, 3] < [1, 2, 4] #比较列表大小 True >>> 'Hello' > 3 #字符串和数字不能比较 TypeError: unorderable types: str() > int() >>> {1, 2, 3} < {1, 2, 3, 4} #测试是否子集成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素。
>>> 3 in [1, 2, 3] #测试3是否存在于列表[1, 2, 3]中 True >>> 5 in range(1, 10, 1) #range()是用来生成指定范围数字的内置函数 True >>> 'abc' in 'abcdefg' #子字符串测试 True >>> for i in (3, 5, 7): #循环，成员遍历 print(i, end='\t') 3 5 7同一性测试运算符（identity comparison）is用来测试两个对象是否是同一个，如果是则返回True，否则返回False。如果两个对象是同一个，二者具有相同的内存地址。
>>> 3 is 3 True >>> x = [300, 300, 300] >>> x[0] is x[1] #基于值的内存管理，同一个值在内存中只有一份 True >>> x = [1, 2, 3] >>> y = [1, 2, 3] >>> x is y #上面形式创建的x和y不是同一个列表对象 False位运算符只能用于整数，其内部执行过程为：首先将整数转换为二进制数，然后右对齐，必要的时候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字返回。
>>> 3 << 2 #把3左移2位 12 >>> 3 & 7 #位与运算 3 >>> 3 | 8 #位或运算 11 >>> 3 ^ 5 #位异或运算 6集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现（注意，并集运算符不是加号）。
>>> {1, 2, 3} | {3, 4, 5} #并集，自动去除重复元素 {1, 2, 3, 4, 5} >>> {1, 2, 3} & {3, 4, 5} #交集 {3} >>> {1, 2, 3} ^ {3, 4, 5} #对称差集 {1, 2, 4, 5} >>> {1, 2, 3} - {3, 4, 5} #差集 {1, 2}逻辑运算符and和or具有惰性求值特点。
>>> 3>5 and a>3 #注意，此时并没有定义变量a False >>> 3>5 or a>3 #3>5的值为False，所以需要计算后面表达式 NameError: name 'a' is not defined >>> 3<5 or a>3 #3<5的值为True，不需要计算后面表达式 True >>> 3 and 5 #最后一个计算的表达式的值作为整个表达式的值 5 >>> 3 and 5>2 True >>> 3 not in [1, 2, 3] #逻辑非运算not False >>> 3 is not 5 #not的计算结果只能是True或False之一 TruePython 3.5增加了一个新的矩阵相乘运算符@
>>> import numpy #numpy是用于科学计算的Python扩展库 >>> x = numpy.ones(3) #ones()函数用于生成全1矩阵 >>> m = numpy.eye(3)*3 #eye()函数用于生成单位矩阵 >>> m[0,2] = 5 #设置矩阵指定位置上元素的值 >>> m[2, 0] =3 >>> x @ m #矩阵相乘 array([ 6., 3., 8.])逗号并不是运算符，只是一个普通分隔符。
>>> 'a' in 'b', 'a' (False, 'a') >>> 'a' in ('b', 'a') True >>> x = 3, 5 >>> x (3, 5) >>> 3 == 3, 5 (True, 5) >>> x = 3+5, 7 >>> x (8, 7)在Python中，单个任何类型的对象或常数属于合法表达式，使用运算符连接的变量和常量以及函数调用的任意组合也属于合法的表达式。
>>> a = [1,2,3] >>> b = [4,5,6] >>> c = a + b >>> c [1, 2, 3, 4, 5, 6] >>> d = list(map(str, c)) >>> d ['1', '2', '3', '4', '5', '6'] >>> import math >>> list(map(math.sin, c)) [0.8414709848078965, 0.9092974268256817, 0.1411200080598672, -0.7568024953079282, -0.9589242746631385, -0.27941549819892586] >>> 'Hello' + ' ' + 'world' 'Hello world' >>> 'welcome ' * 3 'welcome welcome welcome ' >>> ('welcome,'*3).rstrip(',')+'!' 'welcome,welcome,welcome!'内置函数不需要导入任何模块即可使用，执行下面的命令可以列出所有内置函数
>>> dir(__builtins__)dir()函数可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作。 help()函数则返回指定模块或函数的说明文档。 ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符，str()则直接将其任意类型参数转换为字符串。
>>> ord('a') 97 >>> chr(65) 'A' >>> chr(ord('A')+1) 'B' >>> str(1) '1' >>> str(1234) '1234' >>> str([1,2,3]) '[1, 2, 3]' >>> str((1,2,3)) '(1, 2, 3)' >>> str({1,2,3}) 'set([1, 2, 3])'max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。
>>> import random >>> a = [random.randint(1,100) for i in range(10)] #列表推导式 >>> a [72, 26, 80, 65, 34, 86, 19, 74, 52, 40] >>> print(max(a), min(a), sum(a)) 86 19 548 #如果需要计算该列表中的所有元素的平均值，可以直接这样用： >>> sum(a)*1.0/len(a) #Python 2.7.12 54.8 >>> sum(a)/len(a) #Python 3.5.2 54.8 #内置函数max()和min()的key参数可以用来指定比较规则 >>> x = ['21', '1234', '9'] >>> max(x) '9' >>> max(x, key=len) '1234' >>> min(x, key=len) '9' >>> max(x, key=int) '1234'内置函数type()和isinstance()可以判断数据类型。
>>> type([3]) #查看[3]的类型 <class 'list'> >>> type({3}) in (list, tuple, dict) #判断{3}是否为list,tuple或dict类型的实例 False >>> isinstance(3, int) #判断3是否为int类型的实例 True >>> isinstance(3j, (int, float, complex)) #判断3是否为int,float或complex类型 Truesorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表，reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。
>>> x = ['aaaa', 'bc', 'd', 'b', 'ba'] >>> sorted(x, key=lambda item: (len(item), item)) #先按长度排序，长度一样的正常排序 ['b', 'd', 'ba', 'bc', 'aaaa'] >>> reversed(x) #逆序，返回reversed对象 <list_reverseiterator object at 0x0000000003089E48> >>> list(reversed(x)) #reversed对象是可迭代的 [5, 1, 9, 3, 8, 7, 10, 6, 0, 4, 2] #比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。因此，如果我们要实现倒序排序，只需要编写一个reversed_cmp函数： def reversed_cmp(x, y): if x > y: return -1 if x < y: return 1 return 0 #这样，调用 sorted() 并传入 reversed_cmp 就可以实现倒序排序： >>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5]enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。
>>> list(enumerate('abcd')) #枚举字符串中的元素 [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')] >>> list(enumerate(['Python', 'Greate'])) #枚举列表中的元素 [(0, 'Python'), (1, 'Greate')] >>> list(enumerate({'a':97, 'b':98, 'c':99}.items())) #枚举字典中的元素 [(0, ('c', 99)), (1, ('a', 97)), (2, ('b', 98))] >>> for index, value in enumerate(range(10, 15)): #枚举range对象中的元素 print((index, value), end=' ') (0, 10) (1, 11) (2, 12) (3, 13) (4, 14)内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CShRGz6A-1587948519831)(第01章 基础知识01.png)]
>>> list(map(str, range(5))) #把列表中元素转换为字符串 ['0', '1', '2', '3', '4'] >>> def add5(v): #单参数函数 return v+5 >>> list(map(add5, range(10))) #把单参数函数映射到一个序列的所有元素 [5, 6, 7, 8, 9, 10, 11, 12, 13, 14] >>> def add(x, y): #可以接收2个参数的函数 return x+y >>> list(map(add, range(5), range(5,10))) #把双参数函数映射到两个序列上 [5, 7, 9, 11, 13]标准库functools中的函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UFGEI3dm-1587948519835)(第01章 基础知识02.png)]
>>> from functools import reduce >>> seq = list(range(1, 10)) >>> reduce(lambda x, y: x+y, seq) 45 #Python内置了求和函数sum()，但没有求积的函数，请利用reduce()来求积。内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。
>>> seq = ['foo', 'x41', '?!', '***'] >>> def func(x): return x.isalnum() #测试是否为字母或数字 >>> filter(func, seq) #返回filter对象 <filter object at 0x000000000305D898> >>> list(filter(func, seq)) #把filter对象转换为列表 ['foo', 'x41'] #删除 None 或者空字符串： def is_not_empty(s): return s and len(s.strip()) > 0 >>>filter(is_not_empty, ['test', None, '', 'str', ' ', 'END']) ['test', 'str', 'END'] #注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下： >>> a = ' 123' >>> a.strip() '123' >>> a = '\t\t123\r\n' >>> a.strip() '123'range()是Python开发中非常常用的一个内置函数，语法格式为range([start,] end [, step] )。该函数返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1。
>>> range(5) #start默认为0，step默认为1 range(0, 5) >>> list(_) [0, 1, 2, 3, 4] >>> list(range(1, 10, 2)) #指定起始值和步长 [1, 3, 5, 7, 9] >>> list(range(9, 0, -2)) #步长为负数时，start应比end大 [9, 7, 5, 3, 1]zip()函数用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，如同拉拉链一样。
>>> list(zip('abcd', [1, 2, 3])) #压缩字符串和列表 [('a', 1), ('b', 2), ('c', 3)] >>> list(zip('123', 'abc', ',.!')) #压缩3个序列 [('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')] >>> x = zip('abcd', '1234') >>> list(x) [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]在Python中具有自动内存管理功能，Python解释器会跟踪所有的值，一旦发现某个值不再有任何变量指向，将会自动删除该值。尽管如此，自动内存管理或者垃圾回收机制并不能保证及时释放内存。显式释放自己申请的资源是程序员的好习惯之一，也是程序员素养的重要体现之一。
在Python中，可以使用del命令来显式删除对象并解除与值之间的指向关系。删除对象时，如果其指向的值还有别的变量指向则不删除该值，如果删除对象后该值不再有其他变量指向，则删除该值。
>>> x = [1,2,3,4,5,6] >>> y = 3 >>> z = y >>> print(y) 3 >>> del y #删除对象 >>> print(y) NameError: name 'y' is not defined >>> print(z) 3 >>> del z >>> print(z) NameError: name 'z' is not defined >>> del x[1] #删除列表中指定元素 >>> print(x) [1, 3, 4, 5, 6] >>> del x #删除整个列表 >>> print(x) NameError: name 'x' is not defined #del命令无法删除元组或字符串中的元素，只可以删除整个元组或字符串，因为这两者均属于不可变序列。用Python进行程序设计，输入是通过input( )函数来实现的，imput( )的一般格式为：x = input(‘提示：’)。该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。
尽管形式一样，Python 2.x和Python 3.x对该函数的解释略有不同。在Python 2.x中，该函数返回结果的类型由输入值时所使用的界定符来决定，例如下面的Python 2.7.12代码：
>>> x = input("Please input:") Please input:3 #没有界定符，整数 >>> print type(x) <type 'int'> >>> x = input("Please input:") Please input:'3' #单引号，字符串 >>> print type(x) <type 'str'> >>> x = input("Please input:") Please input:[1,2,3] #方括号，列表 >>> print type(x) <type 'list'>在Python 2.x中，还有另外一个内置函数raw_input()也可以用来接收用户输入的值。与input()函数不同的是，raw_input()函数返回结果的类型一律为字符串，而不论用户使用什么界定符。例如：
>>> x = raw_input("Please input:") Please input:[1,2,3] >>> print type(x) <type 'str'>在Python 3.x中，不存在raw_input()函数，只提供了input()函数用来接收用户的键盘输入。在Python 3.x中，不论用户输入数据时使用什么界定符，input()函数的返回结果都是字符串，需要将其转换为相应的类型再处理。例如下面的Python 3.5.2代码：
>>> x = input('Please input:') Please input:3 >>> print(type(x)) <class 'str'> >>> x = input('Please input:') Please input:'1' >>> print(type(x)) <class 'str'> >>> x = input('Please input:') Please input:[1,2,3] >>> print(type(x)) <class 'str'> >>> x = raw_input('Please input:') NameError: name 'raw_input' is not definedPython 2.x和Python 3.x的输出方法也不一样。在Python 2.x中，使用print语句进行输出。Python 3.x中使用print()函数进行输出。
默认情况下，Python将结果输出到IDLE或者标准控制台，在输出时也可以进行重定向，例如可以把结果输出到指定文件。在Python 2.7.12中使用下面的方法进行输出重定向：
>>> fp = open(r'C:\mytest.txt', 'a+') >>> print >>fp, "Hello,world" >>> fp.close() #而在Python 3.5.2中则需要使用下面的方法进行重定向： >>> fp = open(r'D:\mytest.txt', 'a+') >>> print('Hello,world!', file = fp) >>> fp.close() #另外一个重要的不同是，对于Python 2.x而言，在print语句之后加上逗号“,”则表示输出内容之后不换行，例如： >>> for i in range(10): print i, 0 1 2 3 4 5 6 7 8 9 #在Python 3.x中，为了实现上述功能则需要使用下面的方法： >>> for i in range(10,20): print(i, end=' ') 10 11 12 13 14 15 16 17 18 19Python默认安装仅包含部分基本或核心模块，但用户可以安装大量的扩展模块，pip是管理模块的重要工具。在Python启动时，仅加载了很少的一部分模块，在需要时由程序员显式地加载（可能需要先安装）其他模块。减小运行的压力，仅加载真正需要的模块和功能，且具有很强的可扩展性。
#可以使用sys.modules.items()显示所有预加载模块的相关信息。 >>> import sys >>> sys.modules.items() #可以使用dir函数查看任意模块中所有的对象列表，如果调用不带参数的dir()函数，则返回当前所有名字列表。 >>> import math >>> dir(math) #可以使用help函数查看任意模块或函数的使用帮助。 >>> import math >>> help(math)from 模块名 import 对象名[ as 别名] #可以减少查询次数，提高执行速度。
>>> from math import * #谨慎使用 >>> from math import sin >>> sin(3) 0.1411200080598672 >>> from math import sin as f #别名 >>> f(3) 0.141120008059867在2.x中可以使用reload函数重新导入一个模块，在3.x中，需要使用imp模块的reload函数。
Python首先在当前目录中查找需要导入的模块文件，如果没有找到则从sys模块的path变量所指定的目录中查找。可以使用sys模块的path变量查看python导入模块时搜索模块的路径，也可以向其中append自定义的目录以扩展搜索路径。
在导入模块时，会优先导入相应的pyc文件，如果相应的pyc文件与py文件时间不相符，则导入py文件并重新编译该模块。
导入模块时的文件搜索顺序：当前文件夹 >>> sys.path变量指定的文件夹 >>> 优先导入pyc文件
如果需要导入多个模块，一般建议按如下顺序进行导入：标准库 >>> 成熟的第三方扩展库 >>> 自己开发的库
（1）缩进
类定义、函数定义、选择结构、循环结构，行尾的冒号表示缩进的开始。python程序是依靠代码块的缩进来体现代码之间的逻辑关系的，缩进结束就表示一个代码块结束了。同一个级别的代码块的缩进量必须相同。一般而言，以4个空格为基本缩进单位。（2）注释
一个好的、可读性强的程序一般包含30%以上的注释。常用的注释方式主要有两种： 以#开始，表示本行#之后的内容为注释包含在一对三引号’’’…’’'或"""…"""之间且不属于任何语句的内容将被解释器认为是注释 在IDLE开发环境中，可以通过下面的操作快速注释/解除注释大段内容：Format >>> Comment Out Region/Uncomment Region（3）每个import只导入一个模块
（4）如果一行语句太长，可以在行尾加上\来换行分成多行，但是更建议使用括号来包含多行内容。
（5）必要的空格与空行运算符两侧、函数参数之间、逗号两侧建议使用空格分开。不同功能的代码块之间、不同的函数定义之间建议增加一个空行以增加可读性。
（6）适当使用异常处理结构进行容错，后面将详细讲解。
（7）软件应具有较强的可测试性，测试与开发齐头并进。
每个Python脚本在运行时都有一个__name__属性。如果脚本作为模块被导入，则其__name__属性的值被自动设置为模块名；如果脚本独立运行，则其__name__属性值被自动设置为__main__。例如，假设文件nametest.py中只包含下面一行代码：print(__name__)。
#在命令行提示符环境中运行该程序文件时，运行结果如下：__main__ #而将该文件作为模块导入时得到如下执行结果： >>> import nametest nametest利用__name__属性即可控制Python程序的运行方式。例如，编写一个包含大量可被其他程序利用的函数的模块，而不希望该模块可以直接运行，则可以在程序文件中添加以下代码：
if name == 'main': print('Please use me as a module.')这样一来，程序直接执行时将会得到提示“Please use me as a module.”，而使用import语句将其作为模块导入后可以使用其中的类、方法、常量或其他成员。
在包的每个目录中都必须包含一个__init__.py文件，该文件可以是一个空文件，仅用于表示该目录是一个包。
__init__.py文件的主要用途是设置__all__变量以及所包含的包初始化所需的代码。其中__all__变量中定义的对象可以在使用from …import *时全部正确导入。
例1-1：用户输入一个三位自然数，计算并输出其佰位、十位和个位上的数字。
x = input('请输入一个三位数：') x = int(x) a = x // 100 b = x // 10 % 10 c = x % 10 print(a, b, c) #想一想，还有别的办法吗？还可以这样写
x = input('请输入一个三位数：') x = int(x) a, b = divmod(x, 100) b, c = divmod(b, 10) print(a, b, c) 还可以再简单些吗？居然可以这样？OMG
x = input('请输入一个三位数：') a, b, c = map(int, x) print(a, b, c)例1-2：已知三角形的两边长及其夹角，求第三边长。
mport math x = input('输入两边长及夹角（度）：') a, b, theta = map(float, x.split()) c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(theta*math.pi/180)) print('c=', c)例1-3：任意输入三个英文单词，按字典顺序输出。
s = input('x,y,z=') x, y, z = s.split(',') if x > y: x, y = y, x if x > z: x, z = z, x if y > z: y, z = z, y print(x, y, z) #或直接写为： s = input('x,y,z=') x, y, z = s.split(',') x, y, z = sorted([x, y, z]) print(x, y, z)例1-4：Python程序框架生成器。
import os import sys import datetime head = '# '+'-'*20+'\n'+\ '# Function description:\n'+\ '# '+'-'*20+'\n'+\ '# Author: Dong Fuguo\n'+\ '# QQ: 306467355\n'+\ '# Email: dongfuguo2005@126.com\n'+\ '#'+'-'*20+'\n' desFile = sys.argv[1] if os.path.exists(desFile) or not desFile.endswith('.py'): print('%s already exist or is not a Python code file.!'%desFile) sys.exit() fp = open(desFile, 'w') today = str(datetime.date.today()) fp.write('# -*- coding:utf-8 -*-\n') fp.write('# Filename: '+desFile+'\n') fp.write(head) fp.write('# Date: '+today+'\n') fp.write('# '+'-'*20+'\n') fp.close()