Python 3 教程

2017年4月13日

10:51

   

查看python版本

我们可以使用以下命令来查看我们使用的Python版本：

python -V

以上命令执行结果如下：

Python 3.3.2

你也可以进入Python的交互式编程模式，查看版本：

Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>

   

第一个Python3.x程序

对于大多数程序语言，第一个入门编程代码便是"Hello World！"，以下代码为使用Python输出"Hello World！"：

实例(Python 3.0+)

#!/usr/bin/python3

print("Hello, World!");

运行实例 »

你可以将以上代码保存在hello.py文件中并使用python命令执行该脚本文件。

$ python3 hello.py

以上命令输出结果为：

Hello, World!

   

Python2.x与3​​.x版本区别

2017年4月13日

14:19

   

Python的3​​.0版本，常被称为Python 3000，或简称Py3k。相对于Python的早期版本，这是一个较大的升级。

为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下相容。

许多针对早期Python版本设计的程式都无法在Python 3.0上正常执行。

为了照顾现有程式，Python 2.6作为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移，允许使用部分Python 3.0的语法与函数。

新的Python程式建议使用Python 3.0版本的语法。

除非执行环境无法安装Python 3.0或者程式本身使用了不支援Python 3.0的第三方库。目前不支援Python 3.0的第三方库有Twisted, py2exe, PIL等。

大多数第三方库都正在努力地相容Python 3.0版本。即使无法立即使用Python 3.0，也建议编写相容Python 3.0版本的程式，然后使用Python 2.6, Python 2.7来执行。

Python 3.0的变化主要在以下几个方面:

   

print 函数

print语句没有了，取而代之的是print()函数。 Python 2.6与Python 2.7部分地支持这种形式的print语法。在Python 2.6与Python 2.7里面，以下三种形式是等价的：

print "fish"
print ("fish") #注意print后面有个空格
print("fish") #print()不能带有任何其它参数

然而，Python 2.6实际已经支持新的print()语法：

from __future__ import print_function
print("fish", "panda", sep=', ')

   

Unicode

Python 2 有 ASCII str() 类型，unicode() 是单独的，不是 byte 类型。

现在， 在 Python 3，我们最终有了 Unicode (utf-8) 字符串，以及一个字节类：byte 和 bytearrays。

由于 Python3.X 源码文件默认使用utf-8编码，这就使得以下代码是合法的：

>>> 中国 = 'china'
>>>print(中国)
china

Python 2.x

>>> str = "我爱北京天安门"
>>> str
'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8'
>>> str = u"我爱北京天安门"
>>> str
u'\u6211\u7231\u5317\u4eac\u5929\u5b89\u95e8'

Python 3.x

>>> str = "我爱北京天安门"
>>> str
'我爱北京天安门'

   

除法运算

Python中的除法较其它语言显得非常高端，有套很复杂的规则。Python中的除法有两个运算符，/和//

首先来说/除法:

在python 2.x中/除法就跟我们熟悉的大多数语言，比如Java啊C啊差不多，整数相除的结果是一个整数，把小数部分完全忽略掉，浮点数除法会保留小数点的部分得到一个浮点数的结果。

在python 3.x中/除法不再这么做了，对于整数之间的相除，结果也会是浮点数。

Python 2.x:

>>> 1 / 2
0
>>> 1.0 / 2.0
0.5

Python 3.x:

>>> 1/2
0.5

而对于//除法，这种除法叫做floor除法，会对除法的结果自动进行一个floor操作，在python 2.x和python 3.x中是一致的。

python 2.x:

>>> -1 // 2
-1

python 3.x:

>>> -1 // 2
-1

注意的是并不是舍弃小数部分，而是执行floor操作，如果要截取小数部分，那么需要使用math模块的trunc函数

python 3.x:

>>> import math
>>> math.trunc(1 / 2)
0
>>> math.trunc(-1 / 2)
0

   

异常

在 Python 3 中处理异常也轻微的改变了，在 Python 3 中我们现在使用 as 作为关键词。

捕获异常的语法由 except exc, var 改为 except exc as var。

使用语法except (exc1, exc2) as var可以同时捕获多种类别的异常。 Python 2.6已经支持这两种语法。

• 1. 在2.x时代，所有类型的对象都是可以被直接抛出的，在3.x时代，只有继承自BaseException的对象才可以被抛出。
• 2. 2.x raise语句使用逗号将抛出对象类型和参数分开，3.x取消了这种奇葩的写法，直接调用构造函数抛出对象即可。

  在2.x时代，异常在代码中除了表示程序错误，还经常做一些普通控制结构应该做的事情，在3.x中可以看出，设计者让异常变的更加专一，只有在错误发生的情况才能去用异常捕获语句来处理。

     

  xrange

  在 Python 2 中 xrange() 创建迭代对象的用法是非常流行的。比如： for 循环或者是列表/集合/字典推导式。

  这个表现十分像生成器（比如。"惰性求值"）。但是这个 xrange-iterable 是无穷的，意味着你可以无限遍历。

  由于它的惰性求值，如果你不得仅仅不遍历它一次，xrange() 函数 比 range() 更快（比如 for 循环）。尽管如此，对比迭代一次，不建议你重复迭代多次，因为生成器每次都从头开始。

  在 Python 3 中，range() 是像 xrange() 那样实现以至于一个专门的 xrange() 函数都不再存在（在 Python 3 中 xrange() 会抛出命名异常）。

  import timeit

  n = 10000
  def test_range(n):
  return for i in range(n):
  pass

  def test_xrange(n):
  for i in xrange(n):
  pass

  Python 2

  print 'Python', python_version()

  print '\ntiming range()'
  %timeit test_range(n)

  print '\n\ntiming xrange()'
  %timeit test_xrange(n)

  Python 2.7.6

  timing range()
  1000 loops, best of 3: 433 µs per loop

  timing xrange()
  1000 loops, best of 3: 350 µs per loop

  Python 3

  print('Python', python_version())

  print('\ntiming range()')
  %timeit test_range(n)

  Python 3.4.1

  timing range()
  1000 loops, best of 3: 520 µs per loop

  print(xrange(10))
  ---------------------------------------------------------------------------
  NameError Traceback (most recent call last)
  <ipython-input-5-5d8f9b79ea70> in <module>()
  ----> 1 print(xrange(10))

  NameError: name 'xrange' is not defined

     

  八进制字面量表示

  八进制数必须写成0o777，原来的形式0777不能用了；二进制必须写成0b111。

  新增了一个bin()函数用于将一个整数转换成二进制字串。 Python 2.6已经支持这两种语法。

  在Python 3.x中，表示八进制字面量的方式只有一种，就是0o1000。

  python 2.x

  >>> 0o1000
  512
  >>> 01000
  512

  python 3.x

  >>> 01000
  File "<stdin>", line 1
  01000
  ^
  SyntaxError: invalid token
  >>> 0o1000
  512

     

  不等运算符

  Python 2.x中不等于有两种写法 != 和 <>

  Python 3.x中去掉了<>, 只有!=一种写法，还好，我从来没有使用<>的习惯

     

  去掉了repr表达式``

  Python 2.x 中反引号``相当于repr函数的作用

  Python 3.x 中去掉了``这种写法，只允许使用repr函数，这样做的目的是为了使代码看上去更清晰么？不过我感觉用repr的机会很少，一般只在debug的时候才用，多数时候还是用str函数来用字符串描述对象。

  def sendMail(from_: str, to: str, title: str, body: str) -> bool:
  pass

     

  多个模块被改名（根据PEP8）

StringIO模块现在被合并到新的io模组内。 new, md5, gopherlib等模块被删除。 Python 2.6已经支援新的io模组。

httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, Cookie, cookielib被合并到http包内。

取消了exec语句，只剩下exec()函数。 Python 2.6已经支援exec()函数。

   

5.数据类型

1）Py3.X去除了long类型，现在只有一种整型——int，但它的行为就像2.X版本的long

2）新增了bytes类型，对应于2.X版本的八位串，定义一个bytes字面量的方法如下：

>>> b = b'china'
>>> type(b)
<type 'bytes'>

str对象和bytes对象可以使用.encode() (str -> bytes) or .decode() (bytes -> str)方法相互转化。

>>> s = b.decode()
>>> s
'china'
>>> b1 = s.encode()
>>> b1
b'china'

3）dict的.keys()、.items 和.values()方法返回迭代器，而之前的iterkeys()等函数都被废弃。同时去掉的还有 dict.has_key()，用 in替代它吧 。

   

   

Python3 基础语法

2017年4月13日

10:55

   

   

编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

   

标识符

• 第一个字符必须是字母表中字母或下划线'_'。
• 标识符的其他的部分有字母、数字和下划线组成，允许汉字。
• 标识符对大小写敏感。

  在Python 3中，非-ASCII 标识符也是允许的了。

     

  python保留字

  保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

  >>> import keyword
  >>> keyword.kwlist
  ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

     

  注释

  Python中单行注释以 # 开头，实例如下：

  #!/usr/bin/python3

  # 第一个注释
  print ("Hello, Python!") # 第二个注释

  执行以上代码，输出结果为：

  Hello, Python!

  多行注释可以用多个 # 号：

  #!/usr/bin/python3

  # 第一个注释
  # 第二个注释

  print ("Hello, Python!")

  执行以上代码，输出结果为：

  Hello, Python!

     

  行与缩进

  python最具特色的就是使用缩进来表示代码块，不需要使用大括号({})。

  缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：

  if True:
          print ("True")
  else:
          print ("False")

  以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

  if True:
  print ("Answer")
  print ("True")
  else:
  print ("Answer")
  print ("False") # 缩进不一致，会导致运行错误

  以上程序由于缩进不一致，执行后会出现类似以下错误：

  File "test.py", line 6
  print ("False") # 缩进不一致，会导致运行错误
  ^
  IndentationError: unindent does not match any outer indentation level

     

  多行语句

  Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\)来实现多行语句，例如：

  total = item_one + \
  item_two + \
  item_three

  在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)，例如：

  total = ['item_one', 'item_two', 'item_three',
  'item_four', 'item_five']

     

  数据类型

  python中数有四种类型：整数、长整数、浮点数和复数。

• 整数， 如 1
• 长整数 是比较大的整数
• 浮点数 如 1.23、3E-2
• 复数 如 1 + 2j、 1.1 + 2.2j

     

  字符串

• python中单引号和双引号使用完全相同。
• 使用三引号('''或""")可以指定一个多行字符串。
• 转义符 '\'
• 自然字符串， 通过在字符串前加r或R。 如 r"this is a line with \n" 则\n会显示，并不是换行。
• python允许处理unicode字符串，加前缀u或U， 如 u"this is an unicode string"。
• 字符串是不可变的。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。

  word = '字符串'
  sentence = "这是一个句子。"

  paragraph = """这是一个段落，
  可以由多行组成"""

     

  空行

  函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

  空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

  记住：空行也是程序代码的一部分。

     

  等待用户输入

  执行下面的程序在按回车键后就会等待用户输入：

  #!/usr/bin/python3

  input("\n\n按下 enter 键后退出。")

  以上代码中 ，"\n\n"在结果输出前会输出两个新的空行。一旦用户按下键时，程序将退出。

     

  同一行显示多条语句

  Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，以下是一个简单的实例：

  #!/usr/bin/python3

  import sys; x = 'runoob'; sys.stdout.write(x + '\n')

  执行以上代码，输入结果为：

  $ python3 test.py
  runoob

     

  多个语句构成代码组

  缩进相同的一组语句构成一个代码块，我们称之代码组。

  像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

  我们将首行及后面的代码组称为一个子句(clause)。

  如下实例：

  if expression :
  suite
  elif expression :
  suite
  else :
  suite

     

  Print 输出

  print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

  #!/usr/bin/python3

  x="a"
  y="b"
  # 换行输出
  print( x )
  print( y )

  print('---------')
  # 不换行输出
  print( x, end=" " )
  print( y, end=" " )
  print()

  以上实例执行结果为：

  a
  b
  ---------
  a b

     

  import 与 from...import

  在 python 用 import 或者 from...import 来导入相应的模块。

  将整个模块(somemodule)导入，格式为： import somemodule

  从某个模块中导入某个函数,格式为： from somemodule import somefunction

  从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

  将某个模块中的全部函数导入，格式为： from somemodule import *

  导入 sys 模块

  import sys

  print('================Python import mode==========================');

  print ('命令行参数为:')

  for i in sys.argv:

  print (i)

  print ('\n python 路径为',sys.path)

  导入 sys 模块的 argv,path 成员

  from sys import argv,path # 导入特定的成员

  print('================python from import===================================') print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

     

  命令行参数

  很多程序可以执行一些操作来查看一些基本信，Python可以使用-h参数查看各参数帮助信息：

  $ python -h
  usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
  Options and arguments (and corresponding environment variables):
  -c cmd : program passed in as string (terminates option list)
  -d : debug output from parser (also PYTHONDEBUG=x)
  -E : ignore environment variables (such as PYTHONPATH)
  -h : print this help message and exit

  [ etc. ]

  我们在使用脚本形式执行 Python 时，可以接收命令行输入的参数，具体使用可以参照 Python 3 命令行参数。

   

Python3 命令行参数

2017年4月13日

15:16

   

   

Python 提供了 getopt 模块来获取命令行参数。

$ python test.py arg1 arg2 arg3

Python 中也可以所用 sys 的 sys.argv 来获取命令行参数：

• sys.argv 是命令行参数列表。
• len(sys.argv) 是命令行参数个数。

  注：sys.argv[0] 表示脚本名。

  实例

  test.py 文件代码如下：

  #!/usr/bin/python3

  import sys

  print ('参数个数为:', len(sys.argv), '个参数。')
  print ('参数列表:', str(sys.argv))

  执行以上代码，输出结果为：

  $ python3 test.py arg1 arg2 arg3
  参数个数为: 4 个参数。
  参数列表: ['test.py', 'arg1', 'arg2', 'arg3']

   

注释

2017年4月25日

8:14

   

1. 注释的引入

<1> 看以下程序示例（未使用注释）

<2> 看以下程序示例（使用注释）

<3> 小总结（注释的作用）

• 通过用自己熟悉的语言，在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强程序的可读性

  2. 注释的分类

  <1> 单行注释

  以#开头，#右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用

  
  # 我是注释，可以在里写一些功能说明之类的哦
  print('hello world')

  <2> 多行注释

  
  '''我是多行注释，可以写很多很多行的功能说明
  这就是我牛X指出

  哈哈哈。。。
  '''

  '''
  下面的代码完成 ，打印一首诗
  名字叫做：春江花月夜
  作者，忘了
  '''

  print('╔═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╤═╗')
  print('║　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│ ║')
  print('║　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　║')
  print('║　│春│滟│江│空│江│江│人│不│白│谁│可│玉│此│鸿│昨│江│斜│不│　║')
  print('║　│江│滟│流│里│天│畔│生│知│云│家│怜│户│时│雁│夜│水│月│知│　║')
  print('║　│潮│随│宛│流│一│何│代│江│一│今│楼│帘│相│长│闲│流│沉│乘│　║')
  print('║　│水│波│转│霜│色│人│代│月│片│夜│上│中│望│飞│潭│春│沉│月│　║')
  print('║　│连│千│绕│不│无│初│无│待│去│扁│月│卷│不│光│梦│去│藏│几│　║')
  print('║春│海│万│芳│觉│纤│见│穷│何│悠│舟│徘│不│相│不│落│欲│海│人│　║')
  print('║江│平│里│甸│飞│尘│月│已│人│悠│子│徊│去│闻│度│花│尽│雾│归│　║')
  print('║花│，│，│，│，│，│，│，│，│，│，│，│，│，│，│，│，│，│，│　║')
  print('║月│海│何│月│汀│皎│江│江│但│青│何│应│捣│愿│鱼│可│江│碣│落│　║')
  print('║夜│上│处│照│上│皎│月│月│见│枫│处│照│衣│逐│龙│怜│潭│石│月│　║')
  print('║　│明│春│花│白│空│何│年│长│浦│相│离│砧│月│潜│春│落│潇│摇│　║')
  print('║　│月│江│林│沙│中│年│年│江│上│思│人│上│华│跃│半│月│湘│情│　║')
  print('║　│共│无│皆│看│孤│初│望│送│不│明│妆│拂│流│水│不│复│无│满│　║')
  print('║　│潮│月│似│不│月│照│相│流│胜│月│镜│还│照│成│还│西│限│江│　║')
  print('║　│生│明│霰│见│轮│人│似│水│愁│楼│台│来│君│文│家│斜│路│树│　║')
  print('║　│。│。│。│。│。│？│。│。│。│？│。│。│。│。│。│。│。│。│　║')
  print('║　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　║')
  print('║　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　║')
  print('╚═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╧═╝')

   

标示符和关键字

2017年4月25日

8:14

   

标示符和关键字

<1>标示符

• 什么是标示符，看下图:
• 

  开发人员在程序中自定义的一些符号和名称
  标示符是自己定义的,如变量名 、函数名等

     

  <2>标示符的规则

• 标示符由字母、下划线和数字组成，且数字不能开头
  思考：下面的标示符哪些是正确的，哪些不正确为什么
  fromNo12
  from#12
  my_Boolean
  my-Boolean
  Obj2
  2ndObj
  myInt
  test1
  Mike2jack
  My_tExt
  _test
  test!32
  haha(da)tt
  int
  jack_rose
  jack&rose
  GUI
  G.U.I
• python中的标识符是区分大小写的
• 

  <3>命名规则

• 见名知意
  起一个有意义的名字，尽量做到看一眼就知道是什么意思(提高代码可 读性) 比如: 名字 就定义为 name , 定义学生 用 student
• 驼峰命名法

  小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
  大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName
  不过在程序员中还有一种命名法比较流行，就是用下划线"_"来连接所有的单词，比如send_buf

  

  <4>关键字

  • 什么是关键字
    python一些具有特殊功能的标示符，这就是所谓的关键字
    关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标示符
  • 

   

输入与输出

2017年4月25日

8:17

   

输入与输出

<1>输出

• 生活中的"输出"
• 
•  
• 
• 软件中的"输出"
• 
• python中变量的输出

  
  # 打印提示
  print('hello world')

  print('给我的卡---印度语，你好的意思')

  # 输出变量
  url = 'itcast.cn'
  print('我们的网址是%s'%url)

  <2>输入

  

  咱们在银行ATM机器前取钱时，肯定需要输入密码，对不？

  那么怎样才能让程序知道咱们刚刚输入的是什么呢？？

  大家应该知道了，如果要完成ATM机取钱这件事情，需要先从键盘中输入一个数据，然后用一个变量来保存，是不是很好理解啊

  在Python中，获取键盘输入的数据的方法是采用 raw_input 函数（至于什么是函数，咱们以后的章节中讲解），那么这个 raw_input 怎么用呢?

  看如下示例:

  password = raw_input("请输入密码:")
  print '您刚刚输入的密码是:', password

  运行结果:

     

  • 注意:
  • raw_input("")的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示
  • raw_input("")在从键盘获取了数据以后，会存放到等号右边的变量中

   

   

Python3 基本数据类型

2017年4月13日

10:55

   

   

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

实例(Python 3.0+)

#!/usr/bin/python3

counter = 100 # 整型变量

miles = 1000.0 # 浮点型变量

name = "runoob" # 字符串

print (counter)

print (miles)

print (name)

运行实例 »

执行以上程序会输出如下结果：

100
1000.0
runoob

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

   

标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Sets（集合）
• Dictionary（字典）

     

  Number（数字）

  Python3 支持 int、float、bool、complex（复数）。

  在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

  像大多数语言一样，数值类型的赋值和计算都是很直观的。

  内置的 type() 函数可以用来查询变量所指的对象类型。

  >>> a, b, c, d = 20, 5.5, True, 4+3j
  >>> print(type(a), type(b), type(c), type(d))
  <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

  此外还可以用 isinstance 来判断：

  >>> a = 111
  >>> isinstance(a, int)
  True
  >>>

  isinstance 和 type 的区别在于：

  class A:
  pass

  class B(A):
  pass

  isinstance(A(), A) # returns True
  type(A()) == A # returns True
  isinstance(B(), A) # returns True
  type(B()) == A # returns False

  区别就是:

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

  注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

  当你指定一个值时，Number 对象就会被创建：

  var1 = 1
  var2 = 10

  您也可以使用del语句删除一些对象引用。

  del语句的语法是：

  del var1[,var2[,var3[....,varN]]]]

  您可以通过使用del语句删除单个或多个对象。例如：

  del var
  del var_a, var_b

  数值运算

  >>> 5 + 4 # 加法
  9
  >>> 4.3 - 2 # 减法
  2.3
  >>> 3 * 7 # 乘法
  21
  >>> 2 / 4 # 除法，得到一个浮点数
  0.5
  >>> 2 // 4 # 除法，得到一个整数
  0
  >>> 17 % 3 # 取余
  2
  >>> 2 ** 5 # 乘方
  32

  注意：

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
• 4、在混合计算时，Python会把整型转换成为浮点数。

  数值类型实例

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

   

String（字符串）

Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。实例如下：

#!/usr/bin/python3

str = 'chinatop'

print (str) # 输出字符串 chinatop
print (str[0:-1]) # 输出第一个个到倒数第二个的所有字符 chinato
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次
print (str + "TEST") # 连接字符串

执行以上程序会输出如下结果：

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。

     

  List（列表）

  List（列表） 是 Python 中使用最频繁的数据类型。

  列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

  列表是写在方括号([])之间、用逗号分隔开的元素列表。

  和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

  列表截取的语法格式如下：

  变量[头下标:尾下标]

  索引值以 0 为开始值，-1 为从末尾的开始位置。

  加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

  #!/usr/bin/python3

  list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
  tinylist = [123, 'runoob']

  print (list) # 输出完整列表
  print (list[0]) # 输出列表第一个元素
  print (list[1:3]) # 从第二个开始输出到第三个元素
  print (list[2:]) # 输出从第三个元素开始的所有元素
  print (tinylist * 2) # 输出两次列表
  print (list + tinylist) # 连接列表

  以上实例输出结果：

  ['abcd', 786, 2.23, 'runoob', 70.2]
  abcd
  [786, 2.23]
  [2.23, 'runoob', 70.2]
  [123, 'runoob', 123, 'runoob']
  ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

  与Python字符串不一样的是，列表中的元素是可以改变的：

  >>> a = [1, 2, 3, 4, 5, 6]
  >>> a[0] = 9
  >>> a[2:5] = [13, 14, 15]
  >>> a
  [9, 2, 13, 14, 15, 6]
  >>> a[2:5] = [] # 删除
  >>> a
  [9, 2, 6]

  List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

  注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接。
• 4、List中的元素是可以改变的。

     

  Tuple（元组）

  元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。

  元组中的元素类型也可以不相同：

  #!/usr/bin/python3

  tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
  tinytuple = (123, 'runoob')

  print (tuple) # 输出完整元组
  print (tuple[0]) # 输出元组的第一个元素
  print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
  print (tuple[2:]) # 输出从第三个元素开始的所有元素
  print (tinytuple * 2) # 输出两次元组
  print (tuple + tinytuple) # 连接元组

  以上实例输出结果：

  ('abcd', 786, 2.23, 'runoob', 70.2)
  abcd
  (786, 2.23)
  (2.23, 'runoob', 70.2)
  (123, 'runoob', 123, 'runoob')
  ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

  元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

  其实，可以把字符串看作一种特殊的元组。

  >>> tup = (1, 2, 3, 4, 5, 6)
  >>> print(tup[0])
  1
  >>> print(tup[1:5])
  (2, 3, 4, 5)
  >>> tup[0] = 11 # 修改元组元素的操作是非法的
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: 'tuple' object does not support item assignment
  >>>

  虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

  构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

  tup1 = () # 空元组
  tup2 = (20,) # 一个元素，需要在元素后添加逗号

  string、list和tuple都属于sequence（序列）。

  注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含0或1个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接。

     

  Set（集合）

  集合（set）是一个无序不重复元素的序列。

  基本功能是进行成员关系测试和删除重复元素。

  可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

  #!/usr/bin/python3

  student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

  print(student) # 输出集合，重复的元素被自动去掉

  # 成员测试
  if('Rose' in student) :
  print('Rose 在集合中')
  else :
  print('Rose 不在集合中')

  # set可以进行集合运算
  a = set('abracadabra')
  b = set('alacazam')

  print(a)

  print(a - b) # a和b的差集

  print(a | b) # a和b的并集

  print(a & b) # a和b的交集

  print(a ^ b) # a和b中不同时存在的元素

  以上实例输出结果：

  {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
  Rose 在集合中
  {'b', 'a', 'c', 'r', 'd'}
  {'b', 'd', 'r'}
  {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
  {'a', 'c'}
  {'l', 'r', 'z', 'm', 'b', 'd'}

     

  Dictionary（字典）

  字典（dictionary）是Python中另一个非常有用的内置数据类型。

  列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

  字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

  键(key)必须使用不可变类型。

  在同一个字典中，键(key)必须是唯一的。

  #!/usr/bin/python3

  dict = {}
  dict['one'] = "1 - 菜鸟教程"
  dict[2] = "2 - 菜鸟工具"

  tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

  print (dict['one']) # 输出键为 'one' 的值
  print (dict[2]) # 输出键为 2 的值
  print (tinydict) # 输出完整的字典
  print (tinydict.keys()) # 输出所有键
  print (tinydict.values()) # 输出所有值

  以上实例输出结果：

  1 - 菜鸟教程
  2 - 菜鸟工具
  {'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
  dict_keys(['name', 'site', 'code'])
  dict_values(['runoob', 'www.runoob.com', 1])

  构造函数 dict() 可以直接从键值对序列中构建字典如下：

  >>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
  {'Taobao': 3, 'Runoob': 1, 'Google': 2}

  >>> {x: x**2 for x in (2, 4, 6)}
  {2: 4, 4: 16, 6: 36}

  >>> dict(Runoob=1, Google=2, Taobao=3)
  {'Taobao': 3, 'Runoob': 1, 'Google': 2}

  另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

  注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

     

  Python数据类型转换

  有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

  以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

   

类型小结

2017年4月25日

8:15

   

• 生活中的"类型"的例子:
• 
• 程序中:
  为了更充分的利用内存空间以及更有效率的管理内存，变量是有不同的类型的，如下所示:
• 
• 怎样知道一个变量的类型呢？
• 在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别
• 可以使用type(变量的名字)，来查看变量的类型

   

   

Python3 解释器

2017年4月13日

10:55

   

   

Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。

安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。

$ PATH=$PATH:/usr/local/python3/bin/python3 # 设置环境变量
$ python3 --version
Python 3.4.0

在Window系统下你可以通过以下命令来设置Python的环境变量，假设你的Python安装在 C:\Python34 下:

set path=%path%;C:\python34

   

交互式编程

我们可以在命令提示符中输入"Python"命令来启动Python解释器：

$ python3

执行以上命令后，出现如下窗口信息：

$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

在 python 提示符中输入以下语句，然后按回车键查看运行效果：

print ("Hello, Python!");

以上命令执行结果如下：

Hello, Python!

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

>>> flag = True
>>> if flag :
... print("flag 条件为 True!")
...
flag 条件为 True!

   

脚本式编程

将如下代码拷贝至 hello.py文件中：

print ("Hello, Python!");

通过以下命令执行该脚本：

python3 hello.py

输出结果为：

Hello, Python!

在Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：

#! /usr/bin/env python3

然后修改脚本权限，使其有执行权限，命令如下：

$ chmod +x hello.py

执行以下命令：

./hello.py

输出结果为：

Hello, Python!

   

   

Python3 注释

2017年4月13日

10:55

   

   

确保对模块, 函数, 方法和行内注释使用正确的风格

Python中的注释有单行注释和多行注释：

Python中单行注释以#开头，例如：：

# 这是一个注释
print("Hello, World!")

多行注释用三个单引号（'''）或者三个双引号（"""）将注释括起来，例如:

1、单引号（'''）

#!/usr/bin/python3
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, World!")

2、双引号（'''）

#!/usr/bin/python3
"""
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
"""
print("Hello, World!")

   

   

Python3 运算符

2017年4月13日

10:55

   

什么是运算符？

本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操作数，"+" 称为运算符。

Python语言支持以下类型的运算符:

算术运算符

比较（关系）运算符

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

运算符优先级

接下来让我们一个个来学习Python的运算符。

   

Python算术运算符

以下假设变量a为10，变量b为21：

以下实例演示了Python所有算术运算符的操作：

#!/usr/bin/python3

a = 21
b = 10
c = 0

c = a + b
print ("1 - c 的值为：", c)

c = a - b
print ("2 - c 的值为：", c)

c = a * b
print ("3 - c 的值为：", c)

c = a / b
print ("4 - c 的值为：", c)

c = a % b
print ("5 - c 的值为：", c)

# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print ("6 - c 的值为：", c)

a = 10
b = 5
c = a//b
print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2

   

Python比较运算符

以下假设变量a为10，变量b为20：

以下实例演示了Python所有比较运算符的操作：

#!/usr/bin/python3

a = 21
b = 10
c = 0

if ( a == b ):
print ("1 - a 等于 b")
else:
print ("1 - a 不等于 b")

if ( a != b ):
print ("2 - a 不等于 b")
else:
print ("2 - a 等于 b")

if ( a < b ):
print ("3 - a 小于 b")
else:
print ("3 - a 大于等于 b")

if ( a > b ):
print ("4 - a 大于 b")
else:
print ("4 - a 小于等于 b")

# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print ("5 - a 小于等于 b")
else:
print ("5 - a 大于 b")

if ( b >= a ):
print ("6 - b 大于等于 a")
else:
print ("6 - b 小于 a")

以上实例输出结果：

1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a

   

Python赋值运算符

以下假设变量a为10，变量b为20：

以下实例演示了Python所有赋值运算符的操作：

#!/usr/bin/python3

a = 21
b = 10
c = 0

c = a + b
print ("1 - c 的值为：", c)

c += a
print ("2 - c 的值为：", c)

c *= a
print ("3 - c 的值为：", c)

c /= a
print ("4 - c 的值为：", c)

c = 2
c %= a
print ("5 - c 的值为：", c)

c **= a
print ("6 - c 的值为：", c)

c //= a
print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864

   

   

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

以上实例输出结果：

#!/usr/bin/python3

a = 10
b = 20

if ( a and b ):
print ("1 - 变量 a 和 b 都为 true")
else:
print ("1 - 变量 a 和 b 有一个不为 true")

if ( a or b ):
print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print ("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值
a = 0
if ( a and b ):
print ("3 - 变量 a 和 b 都为 true")
else:
print ("3 - 变量 a 和 b 有一个不为 true")

if ( a or b ):
print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print ("4 - 变量 a 和 b 都不为 true")

if not( a and b ):
print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
print ("5 - 变量 a 和 b 都为 true")

以上实例输出结果：

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

   

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

以下实例演示了Python所有成员运算符的操作：

#!/usr/bin/python3

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 中")

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中

   

Python身份运算符

身份运算符用于比较两个对象的存储单元

以下实例演示了Python所有身份运算符的操作：

#!/usr/bin/python3

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 没有相同的标识

   

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

以下实例演示了Python所有运算符优先级的操作：

#!/usr/bin/python3

a = 20
b = 10
c = 15
d = 5
e = 0

e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：", e)

e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：", e)

e = (a + b) * (c / d); # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：", e)

e = a + (b * c) / d; # 20 + (150/5)
print ("a + (b * c) / d 运算结果为：", e)

以上实例输出结果：

(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0

   

   

Python3 数字(Number)

2017年4月13日

10:55

   

   

Python 数字数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变数字数据类型得值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

您也可以使用del语句删除一些数字对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象的引用，例如：

del var
del var_a, var_b

Python 支持三种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

  我们可以使用十六进制和八进制来代表整数：

  >>> number = 0xA0F # 十六进制
  >>> number
  2575

  >>> number=0o37 # 八进制
  >>> number
  31

• Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

     

  Python 数字类型转换

  有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

  以下实例将浮点数变量 a 转换为整数：

  >>> a = 1.0
  >>> int(a)
  1

     

  Python 数字运算

  Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

  表达式的语法很直白： +, -, * 和 / 和其它语言（如Pascal或C）里一样。例如：

  >>> 2 + 2
  4
  >>> 50 - 5*6
  20
  >>> (50 - 5*6) / 4
  5.0
  >>> 8 / 5 # 总是返回一个浮点数
  1.6

  注意：在不同的机器上浮点运算的结果可能会不一样。

  在整数除法中，除法（/）总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：

  >>> 17 / 3 # 整数除法返回浮点型
  5.666666666666667
  >>>
  >>> 17 // 3 # 整数除法返回向下取整后的结果
  5
  >>> 17 % 3 # ％操作符返回除法的余数
  2
  >>> 5 * 3 + 2
  17

  等号（=）用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。

  >>> width = 20
  >>> height = 5*9
  >>> width * height
  900

  Python 可以使用 ** 操作来进行幂运算：

  >>> 5 ** 2 # 5 的平方
  25
  >>> 2 ** 7 # 2的7次方
  128

  变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误：

  >>> n # 尝试访问一个未定义的变量
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  NameError: name 'n' is not defined

  不同类型的数混合运算时会将整数转换为浮点数：

  >>> 3 * 3.75 / 1.5
  7.5
  >>> 7.0 / 2
  3.5

  在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：

  >>> tax = 12.5 / 100
  >>> price = 100.50
  >>> price * tax
  12.5625
  >>> price + _
  113.0625
  >>> round(_, 2)
  113.06

  此处， _ 变量应被用户视为只读变量。

     

  数学函数

   

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

   

三角函数

Python包括以下三角函数：

   

数学常量

   

   

数学函数

2017年4月13日

15:37

   

abs() 函数

2017年4月13日

15:37

   

描述

abs() 函数返回数字的绝对值。

   

语法

以下是 abs() 方法的语法:

abs( x )

   

参数

• x -- 数值表达式，可以是整数，浮点数，复数。

     

  返回值

  函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。

     

  实例

  以下展示了使用 abs() 方法的实例：

  #!/usr/bin/python3

  print ("abs(-40) : ", abs(-40))
  print ("abs(100.10) : ", abs(100.10))

  以上实例运行后输出结果为：

  abs(-40) : 40
  abs(100.10) : 100.1

   

ceil() 函数

2017年4月13日

15:37

   

描述

ceil(x) 函数返回一个大于或等于 x 的的最小整数。

   

语法

以下是 ceil() 方法的语法:

import math

math.ceil( x )

注意：ceil()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

   

参数

x -- 数值表达式。

   

返回值

函数返回返回一个大于或等于 x 的的最小整数。

   

实例

以下展示了使用 ceil() 方法的实例：

#!/usr/bin/python3
import math # 导入 math 模块

print ("math.ceil(-45.17) : ", math.ceil(-45.17))
print ("math.ceil(100.12) : ", math.ceil(100.12))
print ("math.ceil(100.72) : ", math.ceil(100.72))
print ("math.ceil(math.pi) : ", math.ceil(math.pi))

以上实例运行后输出结果为：

math.ceil(-45.17) : -45
math.ceil(100.12) : 101
math.ceil(100.72) : 101
math.ceil(math.pi) : 4

   

exp() 函数

2017年4月13日

15:37

   

描述

exp() 方法返回x的指数,e^x。

   

语法

以下是 exp() 方法的语法:

import math

math.exp( x )

注意：exp()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

   

参数

• x -- 数值表达式。

     

  返回值

  返回x的指数,e^x。

     

  实例

  以下展示了使用 exp() 方法的实例：

  #!/usr/bin/python3
  import math # 导入 math 模块

  print ("math.exp(-45.17) : ", math.exp(-45.17))
  print ("math.exp(100.12) : ", math.exp(100.12))
  print ("math.exp(100.72) : ", math.exp(100.72))
  print ("math.exp(math.pi) : ", math.exp(math.pi))

  以上实例运行后输出结果为：

  math.exp(-45.17) : 2.4150062132629406e-20
  math.exp(100.12) : 3.0308436140742566e+43
  math.exp(100.72) : 5.522557130248187e+43
  math.exp(math.pi) : 23.140692632779267

   

fabs() 函数

2017年4月13日

15:37

   

描述

fabs() 方法返回数字的绝对值，如math.fabs(-10) 返回10.0。

fabs() 函数类似于 abs() 函数，但是他有两点区别:

• abs() 是内置函数。 fabs() 函数在 math 模块中定义。
• fabs() 函数只对浮点型跟整型数值有效。 abs() 还可以运用在复数中。

     

  语法

  以下是 fabs() 方法的语法:

  import math

  math.fabs( x )

  注意：fabs()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

     

  参数

• x -- 数值表达式。

     

  返回值

  返回数字的绝对值。

     

  实例

  以下展示了使用 fabs() 方法的实例：

  #!/usr/bin/python3
  import math # 导入 math 模块

  print ("math.fabs(-45.17) : ", math.fabs(-45.17))
  print ("math.fabs(100.12) : ", math.fabs(100.12))
  print ("math.fabs(100.72) : ", math.fabs(100.72))
  print ("math.fabs(math.pi) : ", math.fabs(math.pi))

  以上实例运行后输出结果为：

  math.fabs(-45.17) : 45.17
  math.fabs(100.12) : 100.12
  math.fabs(100.72) : 100.72
  math.fabs(math.pi) : 3.141592653589793

   

floor() 函数

2017年4月13日

15:37

   

描述

floor(x) 返回数字的下舍整数，小于或等于 x。

   

语法

以下是 floor() 方法的语法:

import math

math.floor( x )

注意：floor()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

   

参数

• x -- 数值表达式。

     

  返回值

  返回小于或等于 x 的整数。

     

  实例

  以下展示了使用 floor() 方法的实例：

  #!/usr/bin/python
  import math # 导入 math 模块

  print ("math.floor(-45.17) : ", math.floor(-45.17))
  print ("math.floor(100.12) : ", math.floor(100.12))
  print ("math.floor(100.72) : ", math.floor(100.72))
  print ("math.floor(math.pi) : ", math.floor(math.pi))

  以上实例运行后输出结果为：

  math.floor(-45.17) : -46
  math.floor(100.12) : 100
  math.floor(100.72) : 100
  math.floor(math.pi) : 3

   

log() 函数

2017年4月13日

15:37

   

描述

log() 方法返回x的自然对数，x > 0。

   

语法

以下是 log() 方法的语法:

import math

math.log( x )

注意：log()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

   

参数

• x -- 数值表达式。

     

  返回值

  返回x的自然对数，x>0。

     

  实例

  以下展示了使用 log() 方法的实例：

  #!/usr/bin/python3
  import math # 导入 math 模块

  print ("math.log(100.12) : ", math.log(100.12))
  print ("math.log(100.72) : ", math.log(100.72))
  print ("math.log(math.pi) : ", math.log(math.pi))

  以上实例运行后输出结果为：

  math.log(100.12) : 4.6063694665635735
  math.log(100.72) : 4.612344389736092
  math.log(math.pi) : 1.1447298858494002

   

log10() 函数

2017年4月13日

15:37

   

描述

log10() 方法返回以10为基数的x对数，x>0。

   

语法

以下是 log10() 方法的语法:

import math

math.log10( x )

注意：log10()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

   

参数

• x -- 数值表达式。

     

  返回值

  返回以10为基数的x对数，x>0。

     

  实例

  以下展示了使用 log10() 方法的实例：

  #!/usr/bin/python3
  import math # 导入 math 模块

  print ("math.log10(100.12) : ", math.log10(100.12))
  print ("math.log10(100.72) : ", math.log10(100.72))
  print ("math.log10(119) : ", math.log10(119))
  print ("math.log10(math.pi) : ", math.log10(math.pi))

  以上实例运行后输出结果为：

  math.log10(100.12) : 2.0005208409361854
  math.log10(100.72) : 2.003115717099806
  math.log10(119) : 2.075546961392531
  math.log10(math.pi) : 0.4971498726941338

   

max() 函数

2017年4月13日

15:37

   

描述

max() 方法返回给定参数的最大值，参数可以为序列。

   

语法

以下是 max() 方法的语法:

max( x, y, z, .... )

   

参数

• x -- 数值表达式。
• y -- 数值表达式。
• z -- 数值表达式。

     

  返回值

  返回给定参数的最大值。

     

  实例

  以下展示了使用 max() 方法的实例：

  #!/usr/bin/python3

  print ("max(80, 100, 1000) : ", max(80, 100, 1000))
  print ("max(-20, 100, 400) : ", max(-20, 100, 400))
  print ("max(-80, -20, -10) : ", max(-80, -20, -10))
  print ("max(0, 100, -400) : ", max(0, 100, -400))

  以上实例运行后输出结果为：

  max(80, 100, 1000) : 1000
  max(-20, 100, 400) : 400
  max(-80, -20, -10) : -10
  max(0, 100, -400) : 100

   

min() 函数

2017年4月13日

15:37

   

描述

min() 方法返回给定参数的最小值，参数可以为序列。

   

语法

以下是 min() 方法的语法:

min( x, y, z, .... )

   

参数

• x -- 数值表达式。
• y -- 数值表达式。
• z -- 数值表达式。

     

  返回值

  返回给定参数的最小值。

     

  实例

  以下展示了使用 min() 方法的实例：

  #!/usr/bin/python3

  print ("min(80, 100, 1000) : ", min(80, 100, 1000))
  print ("min(-20, 100, 400) : ", min(-20, 100, 400))
  print ("min(-80, -20, -10) : ", min(-80, -20, -10))
  print ("min(0, 100, -400) : ", min(0, 100, -400))

  以上实例运行后输出结果为：

  min(80, 100, 1000) : 80
  min(-20, 100, 400) : -20
  min(-80, -20, -10) : -80
  min(0, 100, -400) : -400

   

modf() 函数

2017年4月13日

15:37

   

描述

modf() 方法返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

   

语法

以下是 modf() 方法的语法:

import math

math.modf( x )

注意：modf()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

   

参数

• x -- 数值表达式。

     

  返回值

  返回x的整数部分与小数部分，

     

  实例

  以下展示了使用 modf() 方法的实例：

  #!/usr/bin/python3
  import math # 导入 math 模块

  print ("math.modf(100.12) : ", math.modf(100.12))
  print ("math.modf(100.72) : ", math.modf(100.72))
  print ("math.modf(119) : ", math.modf(119))
  print ("math.modf(math.pi) : ", math.modf(math.pi))

  以上实例运行后输出结果为：

  math.modf(100.12) : (0.12000000000000455, 100.0)
  math.modf(100.72) : (0.7199999999999989, 100.0)
  math.modf(119) : (0.0, 119.0)
  math.modf(math.pi) : (0.14159265358979312, 3.0)

   

pow() 函数

2017年4月13日

15:37

   

描述

pow() 方法返回 x^y（x的y次方） 的值。

   

语法

以下是 math 模块 pow() 方法的语法:

import math

math.pow( x, y )

内置的 pow() 方法

pow(x, y[, z])

函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

   

参数

• x -- 数值表达式。
• y -- 数值表达式。
• z -- 数值表达式。

     

  返回值

  返回 x^y（x的y次方） 的值。

     

  实例

  以下展示了使用 pow() 方法的实例：

  #!/usr/bin/python3
  import math # 导入 math 模块

  print ("math.pow(100, 2) : ", math.pow(100, 2))
  # 使用内置，查看输出结果区别
  print ("pow(100, 2) : ", pow(100, 2))
  print ("math.pow(100, -2) : ", math.pow(100, -2))
  print ("math.pow(2, 4) : ", math.pow(2, 4))
  print ("math.pow(3, 0) : ", math.pow(3, 0))

  以上实例运行后输出结果为：

  math.pow(100, 2) : 10000.0
  pow(100, 2) : 10000
  math.pow(100, -2) : 0.0001
  math.pow(2, 4) : 16.0
  math.pow(3, 0) : 1.0

   

round() 函数

2017年4月13日

15:37

   

描述

round() 方法返回浮点数x的四舍五入值。

   

语法

以下是 round() 方法的语法:

round( x [, n] )

   

参数

• x -- 数值表达式。
• n -- 数值表达式。

     

  返回值

  返回浮点数x的四舍五入值。

     

  实例

  以下展示了使用 round() 方法的实例：

  #!/usr/bin/python3

  print ("round(70.23456) : ", round(70.23456))
  print ("round(56.659,1) : ", round(56.659,1))
  print ("round(80.264, 2) : ", round(80.264, 2))
  print ("round(100.000056, 3) : ", round(100.000056, 3))
  print ("round(-100.000056, 3) : ", round(-100.000056, 3))

  以上实例运行后输出结果为：

  round(70.23456) : 70
  round(56.659,1) : 56.7
  round(80.264, 2) : 80.26
  round(100.000056, 3) : 100.0
  round(-100.000056, 3) : -100.0

   

sqrt() 函数

2017年4月13日

15:37

   

描述

sqrt() 方法返回数字x的平方根。

   

语法

以下是 sqrt() 方法的语法:

import math

math.sqrt( x )

注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

   

参数

• x -- 数值表达式。

     

  返回值

  返回数字x的平方根。

     

  实例

  以下展示了使用 sqrt() 方法的实例：

  #!/usr/bin/python3
  import math # 导入 math 模块

  print ("math.sqrt(100) : ", math.sqrt(100))
  print ("math.sqrt(7) : ", math.sqrt(7))
  print ("math.sqrt(math.pi) : ", math.sqrt(math.pi))

  以上实例运行后输出结果为：

  math.sqrt(100) : 10.0
  math.sqrt(7) : 2.6457513110645907
  math.sqrt(math.pi) : 1.7724538509055159

   

随机数函数

2017年4月13日

15:58

   

choice() 函数

2017年4月13日

15:58

   

描述

choice() 方法返回一个列表，元组或字符串的随机项。

   

语法

以下是 choice() 方法的语法:

import random

random.choice( seq )

注意：choice()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

   

参数

• seq -- 可以是一个列表，元组或字符串。

     

  返回值

  返回随机项。

     

  实例

  以下展示了使用 choice() 方法的实例：

  #!/usr/bin/python3
  import random

  print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))
  print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
  print ("从字符串中 'Runoob' 返回一个随机字符 : ", random.choice('Runoob'))

  以上实例运行后输出结果为：

  从 range(100) 返回一个随机数 : 68
  从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : 2
  从字符串中 'Runoob' 返回一个随机字符 : u

   

randrange() 函数

2017年4月13日

15:58

   

描述

randrange() 方法返回指定递增基数集合中的一个随机数，基数缺省值为1。

   

语法

以下是 randrange() 方法的语法:

import random

random.randrange ([start,] stop [,step])

注意：randrange()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

   

参数

• start -- 指定范围内的开始值，包含在范围内。
• stop -- 指定范围内的结束值，不包含在范围内。
• step -- 指定递增基数。

     

  返回值

  从给定的范围返回随机项。

     

  实例

  以下展示了使用 randrange() 方法的实例：

  #!/usr/bin/python3
  import random

  # 从 1-100 中选取一个奇数
  print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))

  # 从 0-99 选取一个随机数
  print ("randrange(100) : ", random.randrange(100))

  以上实例运行后输出结果为：

  randrange(1,100, 2) : 97
  randrange(100) : 42

   

random() 函数

2017年4月13日

15:58

   

描述

random() 方法返回随机生成的一个实数，它在[0,1)范围内。

   

语法

以下是 random() 方法的语法:

import random

random.random()

注意：random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

   

参数

• 无

     

  返回值

  返回随机生成的一个实数，它在[0,1)范围内。

     

  实例

  以下展示了使用 random() 方法的实例：

  #!/usr/bin/python3
  import random

  # 第一个随机数
  print ("random() : ", random.random())

  # 第二个随机数
  print ("random() : ", random.random())

  以上实例运行后输出结果为：

  random() : 0.09690599908884856
  random() : 0.8732120512570916

   

seed() 函数

2017年4月13日

15:58

   

描述

seed() 方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。。

   

语法

以下是 seed() 方法的语法:

import random

random.seed ( [x] )

注意：seed()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

   

参数

• x -- 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

     

  返回值

  本函数没有返回值。

     

  实例

  以下展示了使用 seed(() 方法的实例：

  #!/usr/bin/python3
  import random

  random.seed()
  print ("使用默认种子生成随机数：", random.random())

  random.seed(10)
  print ("使用整数种子生成随机数：", random.random())

  random.seed("hello",2)
  print ("使用字符串种子生成随机数：", random.random())

  以上实例运行后输出结果为：

  使用默认种子生成随机数： 0.9186252047469824
  使用整数种子生成随机数： 0.5714025946899135
  使用字符串种子生成随机数： 0.3537754404730722

   

shuffle() 函数

2017年4月13日

15:58

   

描述

shuffle() 方法将序列的所有元素随机排序。

   

语法

以下是 shuffle() 方法的语法:

import random

random.shuffle (lst )

注意：shuffle()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

   

参数

• lst -- 可以是一个序列或者元组。

     

  返回值

  返回随机排序后的序列。

     

  实例

  以下展示了使用 shuffle() 方法的实例：

  #!/usr/bin/python3
  import random

  list = [20, 16, 10, 5];
  random.shuffle(list)
  print ("随机排序列表 : ", list)

  random.shuffle(list)
  print ("随机排序列表 : ", list)

  以上实例运行后输出结果为：

  随机排序列表 : [20, 5, 16, 10]
  随机排序列表 : [5, 20, 10, 16]

   

uniform() 函数

2017年4月13日

15:58

   

描述

uniform() 方法将随机生成下一个实数，它在[x,y]范围内。

   

语法

以下是 uniform() 方法的语法:

import random

random.uniform(x, y)

注意：uniform()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

   

参数

• x -- 随机数的最小值。
• y -- 随机数的最大值。

     

  返回值

  返回一个浮点数。

     

  实例

  以下展示了使用 uniform() 方法的实例：

  #!/usr/bin/python3
  import random

  print ("uniform(5, 10) 的随机浮点数 : ", random.uniform(5, 10))

  print ("uniform(7, 14) 的随机浮点数 : ", random.uniform(7, 14))

  以上实例运行后输出结果为：

  uniform(5, 10) 的随机浮点数 : 7.054602800254241
  uniform(7, 14) 的随机浮点数 : 12.552229882744296

   

三角函数

2017年4月13日

16:14

   

acos() 函数

2017年4月13日

16:14

   

描述

acos() 返回x的反余弦弧度值。

   

语法

以下是 acos() 方法的语法:

import math

math.acos(x)

注意：acos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- -1到1之间的数值。如果x是大于1，会产生一个错误。

     

  返回值

  返回x的反余弦弧度值。

     

  实例

  以下展示了使用 acos() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("acos(0.64) : ", math.acos(0.64))
  print ("acos(0) : ", math.acos(0))
  print ("acos(-1) : ", math.acos(-1))
  print ("acos(1) : ", math.acos(1))

  以上实例运行后输出结果为：

  acos(0.64) : 0.8762980611683406
  acos(0) : 1.5707963267948966
  acos(-1) : 3.141592653589793
  acos(1) : 0.0

   

asin() 函数

2017年4月13日

16:14

   

描述

asin() 返回x的反正弦弧度值。

   

语法

以下是 asin() 方法的语法:

import math

math.asin(x)

注意：asin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- -1到1之间的数值。如果x是大于1，会产生一个错误。

     

  返回值

  返回x的反正弦弧度值。

     

  实例

  以下展示了使用 asin() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("asin(0.64) : ", math.asin(0.64))
  print ("asin(0) : ", math.asin(0))
  print ("asin(-1) : ", math.asin(-1))
  print ("asin(1) : ", math.asin(1))

  以上实例运行后输出结果为：

  asin(0.64) : 0.694498265626556
  asin(0) : 0.0
  asin(-1) : -1.5707963267948966
  asin(1) : 1.5707963267948966

   

atan() 函数

2017年4月13日

16:14

   

描述

atan() 返回x的反正切弧度值。

   

语法

以下是 atan() 方法的语法:

import math

math.atan(x)

注意：atan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。

     

  返回值

  返回x的反正切弧度值。

     

  实例

  以下展示了使用 atan() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("atan(0.64) : ", math.atan(0.64))
  print ("atan(0) : ", math.atan(0))
  print ("atan(10) : ", math.atan(10))
  print ("atan(-1) : ", math.atan(-1))
  print ("atan(1) : ", math.atan(1))

  以上实例运行后输出结果为：

  atan(0.64) : 0.5693131911006619
  atan(0) : 0.0
  atan(10) : 1.4711276743037347
  atan(-1) : -0.7853981633974483
  atan(1) : 0.7853981633974483

   

atan2() 函数

2017年4月13日

16:14

   

描述

atan2() 返回给定的 X 及 Y 坐标值的反正切值。

   

语法

以下是 atan2() 方法的语法:

import math

math.atan2(y, x)

注意：atan2()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。
• y -- 一个数值。

     

  返回值

  返回给定的 X 及 Y 坐标值的反正切值。

     

  实例

  以下展示了使用 atan2() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("atan2(-0.50,-0.50) : ", math.atan2(-0.50,-0.50))
  print ("atan2(0.50,0.50) : ", math.atan2(0.50,0.50))
  print ("atan2(5,5) : ", math.atan2(5,5))
  print ("atan2(-10,10) : ", math.atan2(-10,10))
  print ("atan2(10,20) : ", math.atan2(10,20))

  以上实例运行后输出结果为：

  atan2(-0.50,-0.50) : -2.356194490192345
  atan2(0.50,0.50) : 0.7853981633974483
  atan2(5,5) : 0.7853981633974483
  atan2(-10,10) : -0.7853981633974483
  atan2(10,20) : 0.4636476090008061

   

cos() 函数

2017年4月13日

16:14

   

描述

cos() 返回x的弧度的余弦值。

   

语法

以下是 cos() 方法的语法:

import math

math.cos(x)

注意：cos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。

     

  返回值

  返回x的弧度的余弦值,-1 到 1 之间。

     

  实例

  以下展示了使用 cos() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("cos(3) : ", math.cos(3))
  print ("cos(-3) : ", math.cos(-3))
  print ("cos(0) : ", math.cos(0))
  print ("cos(math.pi) : ", math.cos(math.pi))
  print ("cos(2*math.pi) : ", math.cos(2*math.pi))

  以上实例运行后输出结果为：

  cos(3) : -0.9899924966004454
  cos(-3) : -0.9899924966004454
  cos(0) : 1.0
  cos(math.pi) : -1.0
  cos(2*math.pi) : 1.0

   

hypot() 函数

2017年4月13日

16:14

   

描述

hypot() 返回欧几里德范数 sqrt(x*x + y*y)。

   

语法

以下是 hypot() 方法的语法:

import math

math.hypot(x, y)

注意：hypot()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。
• y -- 一个数值。

     

  返回值

  返回欧几里德范数 sqrt(x*x + y*y)。

     

  实例

  以下展示了使用 hypot() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("hypot(3, 2) : ", math.hypot(3, 2))
  print ("hypot(-3, 3) : ", math.hypot(-3, 3))
  print ("hypot(0, 2) : ", math.hypot(0, 2))

  以上实例运行后输出结果为：

  hypot(3, 2) : 3.605551275463989
  hypot(-3, 3) : 4.242640687119285
  hypot(0, 2) : 2.0

   

sin() 函数

2017年4月13日

16:14

   

描述

sin() 返回的x弧度的正弦值。

   

语法

以下是 sin() 方法的语法:

import math

math.sin(x)

注意：sin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。

     

  返回值

  返回的x弧度的正弦值，数值在 -1 到 1 之间。

     

  实例

  以下展示了使用 sin() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("sin(3) : ", math.sin(3))
  print ("sin(-3) : ", math.sin(-3))
  print ("sin(0) : ", math.sin(0))
  print ("sin(math.pi) : ", math.sin(math.pi))
  print ("sin(math.pi/2) : ", math.sin(math.pi/2))

  以上实例运行后输出结果为：

  sin(3) : 0.1411200080598672
  sin(-3) : -0.1411200080598672
  sin(0) : 0.0
  sin(math.pi) : 1.2246467991473532e-16
  sin(math.pi/2) : 1.0

   

tan() 函数

2017年4月13日

16:14

   

描述

tan() 返回x弧度的正弦值。

   

语法

以下是 tan() 方法的语法:

import math

math.tan(x)

注意：tan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。

     

  返回值

  返回x弧度的正弦值，数值在 -1 到 1 之间。

     

  实例

  以下展示了使用 tan() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("(tan(3) : ", math.tan(3))
  print ("tan(-3) : ", math.tan(-3))
  print ("tan(0) : ", math.tan(0))
  print ("tan(math.pi) : ", math.tan(math.pi))
  print ("tan(math.pi/2) : ", math.tan(math.pi/2))
  print ("tan(math.pi/4) : ", math.tan(math.pi/4))

  以上实例运行后输出结果为：

  (tan(3) : -0.1425465430742778
  tan(-3) : 0.1425465430742778
  tan(0) : 0.0
  tan(math.pi) : -1.2246467991473532e-16
  tan(math.pi/2) : 1.633123935319537e+16
  tan(math.pi/4) : 0.9999999999999999

   

degrees() 函数

2017年4月13日

16:14

   

描述

degrees() 将弧度转换为角度。

   

语法

以下是 degrees() 方法的语法:

import math

math.degrees(x)

注意：degrees()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。

     

  返回值

  返回一个角度值。

     

  实例

  以下展示了使用 degrees() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("degrees(3) : ", math.degrees(3))
  print ("degrees(-3) : ", math.degrees(-3))
  print ("degrees(0) : ", math.degrees(0))
  print ("degrees(math.pi) : ", math.degrees(math.pi))
  print ("degrees(math.pi/2) : ", math.degrees(math.pi/2))
  print ("degrees(math.pi/4) : ", math.degrees(math.pi/4))

  以上实例运行后输出结果为：

  degrees(3) : 171.88733853924697
  degrees(-3) : -171.88733853924697
  degrees(0) : 0.0
  degrees(math.pi) : 180.0
  degrees(math.pi/2) : 90.0
  degrees(math.pi/4) : 45.0

   

radians() 函数

2017年4月13日

16:27

   

描述

radians() 方法将角度转换为弧度。

   

语法

以下是 radians() 方法的语法:

import math

math.radians(x)

注意：radians()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

   

参数

• x -- 一个数值。

     

  返回值

  返回一个角度的弧度值。

     

  实例

  以下展示了使用 radians() 方法的实例：

  #!/usr/bin/python3
  import math

  print ("radians(3) : ", math.radians(3))
  print ("radians(-3) : ", math.radians(-3))
  print ("radians(0) : ", math.radians(0))
  print ("radians(math.pi) : ", math.radians(math.pi))
  print ("radians(math.pi/2) : ", math.radians(math.pi/2))
  print ("radians(math.pi/4) : ", math.radians(math.pi/4))

  以上实例运行后输出结果为：

  radians(3) : 0.05235987755982989
  radians(-3) : -0.05235987755982989
  radians(0) : 0.0
  radians(math.pi) : 0.05483113556160755
  radians(math.pi/2) : 0.027415567780803774
  radians(math.pi/4) : 0.013707783890401887

   

数学常量

2017年4月13日

16:29

   

   

   

字符串

2017年4月13日

10:55

   

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Runoob"

   

Python 访问字符串中的值

Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

#!/usr/bin/python3

var1 = 'Hello World!'
var2 = "Runoob"

print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

以上实例执行结果：

var1[0]: H
var2[1:5]: unoo

   

Python字符串更新

你可以对已存在的字符串进行修改，并赋值给另一个变量，如下实例：

#!/usr/bin/python3

var1 = 'Hello World!'

print ("已更新字符串 : ", var1[:6] + 'Runoob!')

以上实例执行结果

已更新字符串 : Hello Runoob!

   

Python转义字符

在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：

   

Python字符串运算符

下表实例变量a值为字符串 "Hello"，b变量值为 "Python"：

实例

#!/usr/bin/python3

a = "Hello"
b = "Python"

print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])

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')

以上实例输出结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

   

Python字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

如下实例：

#!/usr/bin/python3

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

以上实例输出结果：

我叫 小明 今年 10 岁!

python字符串格式化符号:

<tbody

</tbody

格式化操作符辅助指令:

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

   

Python三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下

#!/usr/bin/python3

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

以上实例执行结果为：

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。

errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')

   

Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串。

   

Python 的字符串内建函数

Python 的字符串常用内建函数如下：

   

   

字符串索引

2017年4月25日

8:28

   

字符串的索引(下标)

所谓"下标"，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间

• 生活中的 " 下标"
  超市储物柜

  高铁二等座

  高铁一等座

  绿皮车

• 

     

• 

     

• 

     

• 
• 字符串中"下标"的使用
• 
• 如果有字符串: name = 'abcdef' ，在内存中的实际存储如下:

  如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）
  
  name = 'abcdef'
  
  print(name[0])
  print(name[1])
  print(name[2])
  
  运行结果: 

  如果取出一部分，则可以在中括号[]中，使用:
  
  name = 'abcdef'
  
  print(name[0:3]) # 取 下标0~2 的字符
  
  运行结果: 

  
  name = 'abcdef'
  
  print(name[0:5]) # 取 下标为0~4 的字符
  
  运行结果: 

  
  name = 'abcdef'
  
  print(name[3:5]) # 取 下标为3、4 的字符
  
  运行结果: 

  
  name = 'abcdef'
  
  print(name[2:]) # 取 下标为2开始到最后的字符
  
  运行结果: 

  
  name = 'abcdef'
  
  print(name[1:-1]) # 取 下标为1开始 到 最后第2个 之间的字符
  
  运行结果: 

   

Python 的字符串内建函数

2017年4月13日

16:44

   

capitalize()方法

2017年4月13日

16:45

   

描述

Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。

语法

capitalize()方法语法：

str.capitalize()

参数

• 无。

  返回值

  该方法返回一个首字母大写的字符串。

  实例

  以下实例展示了capitalize()方法的实例：

  #!/usr/bin/python3

  str = "this is string example from runoob....wow!!!"

  print ("str.capitalize() : ", str.capitalize())

  以上实例输出结果如下：

  str.capitalize() : This is string example from runoob....wow!!!

   

center()方法

2017年4月13日

16:45

   

center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

语法

center()方法语法：

str.center(width[, fillchar])

参数

• width -- 字符串的总宽度。
• fillchar -- 填充字符。

  返回值

  返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

  实例

  以下实例展示了center()方法的实例：

  #!/usr/bin/python3

  str = "[www.runoob.com]"

  print ("str.center(40, '*') : ", str.center(40, '*'))

  以上实例输出结果如下：

  str.center(40, '*') : ************[www.runoob.com]************

   

count()方法

2017年4月13日

16:45

   

描述

count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法

count()方法语法：

str.count(sub, start= 0,end=len(string))

参数

• sub -- 搜索的子字符串
• start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

  返回值

  该方法返回子字符串在字符串中出现的次数。

  实例

  以下实例展示了count()方法的实例：

  #!/usr/bin/python3

  str="www.runoob.com"
  sub='o'
  print ("str.count('o') : ", str.count(sub))

  sub='run'
  print ("str.count('run', 0, 10) : ", str.count(sub,0,10))

  以上实例输出结果如下：

  str.count('o') : 3
  str.count('run', 0, 10) : 1

   

bytes.decode()方法

2017年4月13日

16:45

   

描述

decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。

语法

decode()方法语法：

bytes.decode(encoding="utf-8", errors="strict")

参数

• encoding -- 要使用的编码，如"UTF-8"。
• errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

  返回值

  该方法返回解码后的字符串。

  实例

  以下实例展示了decode()方法的实例：

  #!/usr/bin/python3

  str = "菜鸟教程";
  str_utf8 = str.encode("UTF-8")
  str_gbk = str.encode("GBK")

  print(str)

  print("UTF-8 编码：", str_utf8)
  print("GBK 编码：", str_gbk)

  print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
  print("GBK 解码：", str_gbk.decode('GBK','strict'))

  以上实例输出结果如下：

  菜鸟教程
  UTF-8 编码： b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
  GBK 编码： b'\xb2\xcb\xc4\xf1\xbd\xcc\xb3\xcc'
  UTF-8 解码： 菜鸟教程
  GBK 解码： 菜鸟教程

   

encode()方法

2017年4月13日

16:45

   

描述

encode() 方法以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。

语法

encode()方法语法：

str.encode(encoding='UTF-8',errors='strict')

参数

• encoding -- 要使用的编码，如: UTF-8。
• errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

  返回值

  该方法返回编码后的字符串，它是一个 bytes 对象。

  实例

  以下实例展示了encode()方法的实例：

  #!/usr/bin/python3

  str = "菜鸟教程";
  str_utf8 = str.encode("UTF-8")
  str_gbk = str.encode("GBK")

  print(str)

  print("UTF-8 编码：", str_utf8)
  print("GBK 编码：", str_gbk)

  print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
  print("GBK 解码：", str_gbk.decode('GBK','strict'))

  以上实例输出结果如下：

  菜鸟教程
  UTF-8 编码： b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
  GBK 编码： b'\xb2\xcb\xc4\xf1\xbd\xcc\xb3\xcc'
  UTF-8 解码： 菜鸟教程
  GBK 解码： 菜鸟教程

   

endswith()方法

2017年4月13日

16:45

   

描述

endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

语法

endswith()方法语法：

str.endswith(suffix[, start[, end]])

参数

• suffix -- 该参数可以是一个字符串或者是一个元素。
• start -- 字符串中的开始位置。
• end -- 字符中结束位置。

  返回值

  如果字符串含有指定的后缀返回True，否则返回False。

  实例

  以下实例展示了endswith()方法的实例：

  #!/usr/bin/python3

  Str='Runoob example....wow!!!'
  suffix='!!'
  print (Str.endswith(suffix))
  print (Str.endswith(suffix,20))
  suffix='run'
  print (Str.endswith(suffix))
  print (Str.endswith(suffix, 0, 19))

  以上实例输出结果如下：

  True
  True
  False
  False

   

expandtabs()方法

2017年4月13日

16:45

   

描述

expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。

语法

expandtabs()方法语法：

str.expandtabs(tabsize=8)

参数

• tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。

  返回值

  该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。

  实例

  以下实例展示了expandtabs()方法的实例：

  #!/usr/bin/python3

  str = "this is\tstring example....wow!!!"

  print ("原始字符串: " + str)
  print ("替换 \\t 符号: " + str.expandtabs())
  print ("使用16个空格替换 \\t 符号: " + str.expandtabs(16))

  以上实例输出结果如下：

  原始字符串: this is string example....wow!!!
  替换 \t 符号: this is string example....wow!!!
  使用16个空格替换 \t 符号: this is string example....wow!!!

   

find()方法

2017年4月13日

16:45

   

描述

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。

语法

find()方法语法：

str.find(str, beg=0, end=len(string))

参数

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

  返回值

  如果包含子字符串返回开始的索引值，否则返回-1。

  实例

  以下实例展示了find()方法的实例：

  #!/usr/bin/python3

  str1 = "Runoob example....wow!!!"
  str2 = "exam";

  print (str1.find(str2))
  print (str1.find(str2, 5))
  print (str1.find(str2, 10))

  以上实例输出结果如下：

  7
  7
  -1

   

index()方法

2017年4月13日

16:45

   

描述

index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

语法

index()方法语法：

str.index(str, beg=0, end=len(string))

参数

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

  返回值

  如果包含子字符串返回开始的索引值，否则抛出异常。

  实例

  以下实例展示了index()方法的实例：

  #!/usr/bin/python3

  str1 = "Runoob example....wow!!!"
  str2 = "exam";

  print (str1.index(str2))
  print (str1.index(str2, 5))
  print (str1.index(str2, 10))

  以上实例输出结果如下(未发现的会出现异常信息)：

  7
  7
  Traceback (most recent call last):
  File "test.py", line 8, in <module>
  print (str1.index(str2, 10))
  ValueError: substring not found

  注意：在接下来的几个章节中，我们会详细介绍Python Exception的使用。

   

isalnum()方法

2017年4月13日

16:45

   

描述

isalnum() 方法检测字符串是否由字母和数字组成。

语法

isalnum()方法语法：

str.isalnum()

参数

• 无。

  返回值

  如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

  实例

  以下实例展示了isalnum()方法的实例：

  实例(Python 2.0+)

  #!/usr/bin/python3

  str = "runoob2016" # 字符串没有空格

  print (str.isalnum())

  str = "www.runoob.com"

  print (str.isalnum())

  以上实例输出结果如下：

  True
  False

   

isalpha()方法

2017年4月13日

16:45

   

描述

Python isalpha() 方法检测字符串是否只由字母组成。

语法

isalpha()方法语法：

str.isalpha()

参数

• 无。

  返回值

  如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

  实例

  以下实例展示了isalpha()方法的实例：

  #!/usr/bin/python3

  str = "runoob"
  print (str.isalpha())

  str = "Runoob example....wow!!!"
  print (str.isalpha())

  以上实例输出结果如下：

  True
  False

   

isdigit()方法

2017年4月13日

16:45

   

描述

Python isdigit() 方法检测字符串是否只由数字组成。

语法

isdigit()方法语法：

str.isdigit()

参数

• 无。

  返回值

  如果字符串只包含数字则返回 True 否则返回 False。

  实例

  以下实例展示了isdigit()方法的实例：

  #!/usr/bin/python3

  str = "123456";
  print (str.isdigit())

  str = "Runoob example....wow!!!"
  print (str.isdigit())

  以上实例输出结果如下：

  True
  False

   

islower()方法

2017年4月13日

16:45

   

描述

islower() 方法检测字符串是否由小写字母组成。

语法

islower()方法语法：

str.islower()

参数

• 无。

  返回值

  如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

  实例

  以下实例展示了islower()方法的实例：

  #!/usr/bin/python3

  str = "RUNOOB example....wow!!!"
  print (str.islower())

  str = "runoob example....wow!!!"
  print (str.islower())

  以上实例输出结果如下：

  False
  True

   

isnumeric()方法

2017年4月13日

16:45

   

描述

isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。

注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可，具体可以查看本章节例子。

语法

isnumeric()方法语法：

str.isnumeric()

参数

• 无。

  返回值

  如果字符串中只包含数字字符，则返回 True，否则返回 False

  实例

  以下实例展示了isnumeric()方法的实例：

  #!/usr/bin/python3

  str = "runoob2016"
  print (str.isnumeric())

  str = "23443434"
  print (str.isnumeric())

  以上实例输出结果如下：

  False
  True

   

isspace()方法

2017年4月13日

16:45

   

描述

Python isspace() 方法检测字符串是否只由空格组成。

语法

isspace()方法语法：

str.isspace()

参数

• 无。

  返回值

  如果字符串中只包含空格，则返回 True，否则返回 False.

  实例

  以下实例展示了isspace()方法的实例：

  #!/usr/bin/python3

  str = " "
  print (str.isspace())

  str = "Runoob example....wow!!!"
  print (str.isspace())

  以上实例输出结果如下：

  True
  False

   

istitle()方法

2017年4月13日

16:45

   

描述

istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。

语法

istitle()方法语法：

str.istitle()

参数

• 无。

  返回值

  如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.

  实例

  以下实例展示了istitle()方法的实例：

  #!/usr/bin/python3

  str = "This Is String Example...Wow!!!"
  print (str.istitle())

  str = "This is string example....wow!!!"
  print (str.istitle())

  以上实例输出结果如下：

  True
  False

   

isupper()方法

2017年4月13日

16:45

   

描述

isupper() 方法检测字符串中所有的字母是否都为大写。

语法

isupper()方法语法：

str.isupper()

参数

• 无。

  返回值

  如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

  实例

  以下实例展示了isupper()方法的实例：

  #!/usr/bin/python3

  str = "THIS IS STRING EXAMPLE....WOW!!!"
  print (str.isupper())

  str = "THIS is string example....wow!!!"
  print (str.isupper())

  以上实例输出结果如下：

  True
  False

   

join()方法

2017年4月13日

16:45

   

描述

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

语法

join()方法语法：

str.join(sequence)

参数

• sequence -- 要连接的元素序列。

  返回值

  返回通过指定字符连接序列中元素后生成的新字符串。

  实例

  以下实例展示了join()的使用方法：

  #!/usr/bin/python3

  s1 = "-"
  s2 = ""
  seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
  print (s1.join( seq ))
  print (s2.join( seq ))

  以上实例输出结果如下：

  r-u-n-o-o-b
  runoob

   

len()方法

2017年4月13日

16:45

   

描述

len() 方法返回字符串长度。

语法

len()方法语法：

len( str )

参数

• 无。

  返回值

  返回字符串长度。

  实例

  以下实例展示了len()的使用方法：

  #!/usr/bin/python

  str = "Runoob example....wow!!!";

  print("字符串长度: ", len(str))

  以上实例输出结果如下：

  字符串长度: 24

   

ljust()方法

2017年4月13日

16:45

   

描述

ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法

ljust()方法语法：

str.ljust(width[, fillchar])

参数

• width -- 指定字符串长度。
• fillchar -- 填充字符，默认为空格。

  返回值

  返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

  实例

  以下实例展示了ljust()的使用方法：

  #!/usr/bin/python3

  str = "Runoob example....wow!!!"

  print (str.ljust(50, '*'))

  以上实例输出结果如下：

  Runoob example....wow!!!**************************

   

lower()方法

2017年4月13日

16:45

   

描述

Python lower() 方法转换字符串中所有大写字符为小写。

语法

lower()方法语法：

str.lower()

参数

• 无。

  返回值

  返回将字符串中所有大写字符转换为小写后生成的字符串。

  实例

  以下实例展示了lower()的使用方法：

  #!/usr/bin/python3

  str = "Runoob EXAMPLE....WOW!!!"

  print( str.lower() )

  以上实例输出结果如下：

  runoob example....wow!!!

   

lstrip()方法

2017年4月13日

16:45

   

描述

lstrip() 方法用于截掉字符串左边的空格或指定字符。

语法

lstrip()方法语法：

str.lstrip([chars])

参数

• chars --指定截取的字符。

  返回值

  返回截掉字符串左边的空格或指定字符后生成的新字符串。

  实例

  以下实例展示了lstrip()的使用方法：

  #!/usr/bin/python3

  str = " this is string example....wow!!! ";
  print( str.lstrip() );
  str = "88888888this is string example....wow!!!8888888";
  print( str.lstrip('8') );

  以上实例输出结果如下：

  this is string example....wow!!!
  this is string example....wow!!!8888888

   

maketrans()方法

2017年4月13日

16:45

   

描述

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

注：两个字符串的长度必须相同，为一一对应的关系。

语法

maketrans()方法语法：

str.maketrans(intab, outtab)

参数

• intab -- 字符串中要替代的字符组成的字符串。
• outtab -- 相应的映射字符的字符串。

  返回值

  返回字符串转换后生成的新字符串。

  实例

  以下实例展示了使用maketrans() 方法将所有元音字母转换为指定的数字：

  #!/usr/bin/python3

  intab = "aeiou"
  outtab = "12345"
  trantab = str.maketrans(intab, outtab)

  str = "this is string example....wow!!!"
  print (str.translate(trantab))

  以上实例输出结果如下：

  th3s 3s str3ng 2x1mpl2....w4w!!!

   

max()方法

2017年4月13日

16:45

   

描述

max() 方法返回字符串中最大的字母。

语法

max()方法语法：

max(str)

参数

• str -- 字符串。

  返回值

  返回字符串中最大的字母。

  实例

  以下实例展示了max()函数的使用方法：

  #!/usr/bin/python3

  str = "runoob"
  print ("最大字符: " + max(str))

  以上实例输出结果如下：

  最大字符: u

   

min()方法

2017年4月13日

16:45

   

描述

Python min() 方法返回字符串中最小的字母。

语法

min()方法语法：

min(str)

参数

• str -- 字符串。

  返回值

  返回字符串中最小的字母。

  实例

  以下实例展示了min()函数的使用方法：

  #!/usr/bin/python3

  str = "runoob";
  print ("最小字符: " + min(str));

  以上实例输出结果如下：

  最小字符: b

   

replace()方法

2017年4月13日

16:45

   

描述

replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

语法

replace()方法语法：

str.replace(old, new[, max])

参数

• old -- 将被替换的子字符串。
• new -- 新字符串，用于替换old子字符串。
• max -- 可选字符串, 替换不超过 max 次

  返回值

  返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

  实例

  以下实例展示了replace()函数的使用方法：

  #!/usr/bin/python3

  str = "www.w3cschool.cc"
  print ("菜鸟教程新地址：", str)
  print ("菜鸟教程新地址：", str.replace("w3cschool.cc", "runoob.com"))

  str = "this is string example....wow!!!"
  print (str.replace("is", "was", 3))

  以上实例输出结果如下：

  菜鸟教程新地址： www.w3cschool.cc
  菜鸟教程新地址： www.runoob.com
  thwas was string example....wow!!!

   

rfind()方法

2017年4月13日

16:45

   

描述

Python rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

语法

rfind()方法语法：

str.rfind(str, beg=0 end=len(string))

参数

• str -- 查找的字符串
• beg -- 开始查找的位置，默认为0
• end -- 结束查找位置，默认为字符串的长度。

  返回值

  返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

  实例

  以下实例展示了rfind()函数的使用方法：

  #!/usr/bin/python3

  str1 = "this is really a string example....wow!!!"
  str2 = "is"

  print (str1.rfind(str2))

  print (str1.rfind(str2, 0, 10))
  print (str1.rfind(str2, 10, 0))

  print (str1.find(str2))
  print (str1.find(str2, 0, 10))
  print (str1.find(str2, 10, 0))

  以上实例输出结果如下：

  5
  5
  -1
  2
  2
  -1

   

rindex()方法

2017年4月13日

16:45

   

描述

rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。

语法

rindex()方法语法：

str.rindex(str, beg=0 end=len(string))

参数

• str -- 查找的字符串
• beg -- 开始查找的位置，默认为0
• end -- 结束查找位置，默认为字符串的长度。

  返回值

  返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。

  实例

  以下实例展示了rindex()函数的使用方法：

  #!/usr/bin/python3
  str1 = "this is really a string example....wow!!!"
  str2 = "is"

  print (str1.rindex(str2))
  print (str1.rindex(str2,10))

  以上实例输出结果如下：

  5
  Traceback (most recent call last):
  File "test.py", line 6, in <module>
  print (str1.rindex(str2,10))
  ValueError: substring not found

   

rjust()方法

2017年4月13日

16:45

   

描述

rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。

语法

rjust()方法语法：

str.rjust(width[, fillchar])

参数

• width -- 指定填充指定字符后中字符串的总长度.
• fillchar -- 填充的字符，默认为空格。

  返回值

  返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串

  实例

  以下实例展示了rjust()函数的使用方法：

  #!/usr/bin/python3

  str = "this is string example....wow!!!"
  print (str.rjust(50, '*'))

  以上实例输出结果如下：

  ******************this is string example....wow!!!

   

rstrip()方法

2017年4月13日

16:45

   

描述

rstrip() 删除 string 字符串末尾的指定字符（默认为空格）.

语法

rstrip()方法语法：

str.rstrip([chars])

参数

• chars -- 指定删除的字符（默认为空格）

  返回值

  返回删除 string 字符串末尾的指定字符后生成的新字符串。

  实例

  以下实例展示了rstrip()函数的使用方法：

  #!/usr/bin/python3

  str = " this is string example....wow!!! "
  print (str.rstrip())
  str = "*****this is string example....wow!!!*****"
  print (str.rstrip('*'))

  以上实例输出结果如下：

  this is string example....wow!!!
  *****this is string example....wow!!!

   

split()方法

2017年4月13日

16:45

   

描述

split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

语法

split()方法语法：

str.split(str="", num=string.count(str)).

参数

• str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num -- 分割次数。

  返回值

  返回分割后的字符串列表。

  实例

  以下实例展示了split()函数的使用方法：

  #!/usr/bin/python3

  str = "this is string example....wow!!!"
  print (str.split( ))
  print (str.split('i',1))
  print (str.split('w'))

  以上实例输出结果如下：

  ['this', 'is', 'string', 'example....wow!!!']
  ['th', 's is string example....wow!!!']
  ['this is string example....', 'o', '!!!']

   

splitlines()方法

2017年4月13日

16:45

   

描述

Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

语法

splitlines()方法语法：

str.splitlines([keepends])

参数

• keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。

  返回值

  返回一个包含各行作为元素的列表。

  实例

  以下实例展示了splitlines()函数的使用方法：

  >>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
  ['ab c', '', 'de fg', 'kl']
  >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
  ['ab c\n', '\n', 'de fg\r', 'kl\r\n']
  >>>

   

startswith()方法

2017年4月13日

16:45

   

描述

startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

语法

startswith()方法语法：

str.startswith(str, beg=0,end=len(string));

参数

• str -- 检测的字符串。
• strbeg -- 可选参数用于设置字符串检测的起始位置。
• strend -- 可选参数用于设置字符串检测的结束位置。

  返回值

  如果检测到字符串则返回True，否则返回False。

  实例

  以下实例展示了startswith()函数的使用方法：

  #!/usr/bin/python3

  str = "this is string example....wow!!!"
  print (str.startswith( 'this' ))
  print (str.startswith( 'string', 8 ))
  print (str.startswith( 'this', 2, 4 ))

  以上实例输出结果如下：

  True
  True
  False

   

strip()方法

2017年4月13日

16:45

   

描述

Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）。

语法

strip()方法语法：

str.strip([chars]);

参数

• chars -- 移除字符串头尾指定的字符。

  返回值

  返回移除字符串头尾指定的字符生成的新字符串。

  实例

  以下实例展示了strip()函数的使用方法：

  #!/usr/bin/python3

  str = "*****this is string example....wow!!!*****"
  print (str.strip( '*' ))

  以上实例输出结果如下：

  this is string example....wow!!!

   

swapcase()方法

2017年4月13日

16:45

   

描述

swapcase() 方法用于对字符串的大小写字母进行转换。

语法

swapcase()方法语法：

str.swapcase();

参数

• NA。

  返回值

  返回大小写字母转换后生成的新字符串。

  实例

  以下实例展示了swapcase()函数的使用方法：

  #!/usr/bin/python3

  str = "this is string example....wow!!!"
  print (str.swapcase())

  str = "This Is String Example....WOW!!!"
  print (str.swapcase())

  以上实例输出结果如下：

  THIS IS STRING EXAMPLE....WOW!!!
  tHIS iS sTRING eXAMPLE....wow!!!

   

title()方法

2017年4月13日

16:45

   

描述

Python title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。

语法

title()方法语法：

str.title();

参数

• NA。

  返回值

  返回"标题化"的字符串,就是说所有单词都是以大写开始。

  实例

  以下实例展示了 title()函数的使用方法：

  #!/usr/bin/python

  str = "this is string example from runoob....wow!!!"
  print (str.title())

  以上实例输出结果如下：

  This Is String Example From Runoob....Wow!!!

   

translate()方法

2017年4月13日

16:45

   

描述

translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。

语法

translate()方法语法：

str.translate(table[, deletechars]);

参数

• table -- 翻译表，翻译表是通过maketrans方法转换而来。
• deletechars -- 字符串中要过滤的字符列表。

  返回值

  返回翻译后的字符串。

  实例

  以下实例展示了 translate()函数的使用方法：

  #!/usr/bin/python3

  intab = "aeiou"
  outtab = "12345"
  trantab = str.maketrans(intab, outtab)

  str = "this is string example....wow!!!"
  print (str.translate(trantab))

  以上实例输出结果如下：

  th3s 3s str3ng 2x1mpl2....w4w!!!

  以上实例去除字符串中的 'x' 和 'm' 字符：

  #!/usr/bin/python

  from string import maketrans # Required to call maketrans function.

  intab = "aeiou"
  outtab = "12345"
  trantab = maketrans(intab, outtab)

  str = "this is string example....wow!!!";
  print str.translate(trantab, 'xm');

  以上实例输出结果：

  th3s 3s str3ng 21pl2....w4w!!!

   

upper()方法

2017年4月13日

16:45

   

描述

Python upper() 方法将字符串中的小写字母转为大写字母。

语法

upper()方法语法：

str.upper()

参数

• NA。

  返回值

  返回小写字母转为大写字母的字符串。

  实例

  以下实例展示了 upper()函数的使用方法：

  #!/usr/bin/python3

  str = "this is string example from runoob....wow!!!";

  print ("str.upper() : ", str.upper())

  以上实例输出结果如下：

  str.upper() : THIS IS STRING EXAMPLE FROM RUNOOB....WOW!!!

   

zfill()方法

2017年4月13日

16:45

   

描述

Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。

语法

zfill()方法语法：

str.zfill(width)

参数

• width -- 指定字符串的长度。原字符串右对齐，前面填充0。

  返回值

  返回指定长度的字符串。

  实例

  以下实例展示了 zfill()函数的使用方法：

  #!/usr/bin/python3

  str = "this is string example from runoob....wow!!!"
  print ("str.zfill : ",str.zfill(40))
  print ("str.zfill : ",str.zfill(50))

  以上实例输出结果如下：

  str.zfill : this is string example from runoob....wow!!!
  str.zfill : 000000this is string example from runoob....wow!!!

   

isdecimal()方法

2017年4月13日

17:50

   

描述

isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。

语法

isdecimal()方法语法：

str.isdecimal()

参数

• 无

  返回值

  如果字符串是否只包含十进制字符返回True，否则返回False。

  实例

  以下实例展示了 isdecimal()函数的使用方法：

  #!/usr/bin/python3

  str = "runoob2016"
  print (str.isdecimal())

  str = "23443434"
  print (str.isdecimal())

  以上实例输出结果如下：

  False
  True

   

   

列表

2017年4月13日

10:55

   

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

   

访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

#!/usr/bin/python3

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

   

   

   

运行实例 » 

以上实例输出结果：

list1[0]: Google
list2[1:5]: [2, 3, 4, 5]

   

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]

print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

注意：我们会在接下来的章节讨论append()方法的使用

以上实例输出结果：

第三个元素为 : 1997
更新后的第三个元素为 : 2001

   

删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例：

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]

print (list)
del list[2]
print ("删除第三个元素 : ", list)

以上实例输出结果：

删除第三个元素 : ['Google', 'Runoob', 2000]

注意：我们会在接下来的章节讨论remove()方法的使用

   

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

   

Python列表截取与拼接

Python的列表截取与字符串操作类型，如下所示：

L=['Google', 'Runoob', 'Taobao']

操作：

>>> L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

列表还支持拼接操作：

>>> squares = [1, 4, 9, 16, 25]
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

   

嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

   

Python列表函数&方法

Python包含以下函数:

Python包含以下方法:

   

   

列表函数

2017年4月13日

19:18

   

List len()方法

2017年4月13日

19:18

   

描述

len() 方法返回列表元素个数。

语法

len()方法语法：

len(list)

参数

• list -- 要计算元素个数的列表。

  返回值

  返回列表元素个数。

  实例

  以下实例展示了 len()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao']
  print (len(list1))
  list2=list(range(5)) # 创建一个 0-4 的列表
  print (len(list2))

  以上实例输出结果如下：

  3
  5

   

List max()方法

2017年4月13日

19:18

   

描述

max() 方法返回列表元素中的最大值。

语法

max()方法语法：

max(list)

参数

• list -- 要返回最大值的列表。

  返回值

  返回列表元素中的最大值。

  实例

  以下实例展示了 max()函数的使用方法：

  #!/usr/bin/python3

  list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]

  print ("list1 最大元素值 : ", max(list1))
  print ("list2 最大元素值 : ", max(list2))

  以上实例输出结果如下：

  list1 最大元素值 : Taobao
  list2 最大元素值 : 700

   

List min()方法

2017年4月13日

19:18

   

描述

min() 方法返回列表元素中的最小值。

语法

min()方法语法：

min(list)

参数

• list -- 要返回最小值的列表。

  返回值

  返回列表元素中的最小值。

  实例

  以下实例展示了 min()函数的使用方法：

  #!/usr/bin/python3

  list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]

  print ("list1 最小元素值 : ", min(list1))
  print ("list2 最小元素值 : ", min(list2))

  以上实例输出结果如下：

  list1 最小元素值 : Google
  list2 最小元素值 : 200

   

List list()方法

2017年4月13日

19:21

   

描述

list() 方法用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

语法

list()方法语法：

list( seq )

参数

• list -- 要转换为列表的元组。

  返回值

  返回列表。

  实例

  以下实例展示了 list()函数的使用方法：

  #!/usr/bin/python3

  aTuple = (123, 'Google', 'Runoob', 'Taobao')
  list1 = list(aTuple)
  print ("列表元素 : ", list1)

  str="Hello World"
  list2=list(str)
  print ("列表元素 : ", list2)

  以上实例输出结果如下：

  列表元素 : [123, 'Google', 'Runoob', 'Taobao']
  列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

   

列表方法

2017年4月13日

20:42

   

List append()方法

2017年4月13日

20:42

   

描述

append() 方法用于在列表末尾添加新的对象。

语法

append()方法语法：

list.append(obj)

参数

• obj -- 添加到列表末尾的对象。

  返回值

  该方法无返回值，但是会修改原来的列表。

  实例

  以下实例展示了 append()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao']
  list1.append('Baidu')
  print ("更新后的列表 : ", list1)

  以上实例输出结果如下：

  更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']

   

List count()方法

2017年4月13日

20:42

   

描述

count() 方法用于统计某个元素在列表中出现的次数。

语法

count()方法语法：

list.count(obj)

参数

• obj -- 列表中统计的对象。

  返回值

  返回元素在列表中出现的次数。

  实例

  以下实例展示了 count()函数的使用方法：

  #!/usr/bin/python3

  aList = [123, 'Google', 'Runoob', 'Taobao', 123];

  print ("123 元素个数 : ", aList.count(123))
  print ("Runoob 元素个数 : ", aList.count('Runoob'))

  以上实例输出结果如下：

  123 元素个数 : 2
  Runoob 元素个数 : 1

   

List extend()方法

2017年4月13日

20:42

   

描述

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

语法

extend()方法语法：

list.extend(seq)

参数

• seq -- 元素列表。

  返回值

  该方法没有返回值，但会在已存在的列表中添加新的列表内容。

  实例

  以下实例展示了 extend()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao']
  list2=list(range(5)) # 创建 0-4 的列表
  list1.extend(list2) # 扩展列表
  print ("扩展后的列表：", list1)

  以上实例输出结果如下：

  扩展后的列表： ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]

   

List index()方法

2017年4月13日

20:42

   

描述

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

语法

index()方法语法：

list.index(obj)

参数

• obj -- 查找的对象。

  返回值

  该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

  实例

  以下实例展示了 index()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao']
  print ('Runoob 索引值为', list1.index('Runoob'))
  print ('Taobao 索引值为', list1.index('Taobao'))

  以上实例输出结果如下：

  Runoob 索引值为 1
  Taobao 索引值为 2

   

List insert()方法

2017年4月13日

20:42

   

描述

insert() 函数用于将指定对象插入列表的指定位置。

语法

insert()方法语法：

list.insert(index, obj)

参数

• index -- 对象obj需要插入的索引位置。
• obj -- 要插入列表中的对象。

  返回值

  该方法没有返回值，但会在列表指定位置插入对象。

  实例

  以下实例展示了 insert()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao']
  list1.insert(1, 'Baidu')
  print ('列表插入元素后为 : ', list1)

  以上实例输出结果如下：

  列表插入元素后为 : ['Google', 'Baidu', 'Runoob', 'Taobao']

   

List pop()方法

2017年4月13日

20:42

   

描述

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法

pop()方法语法：

list.pop(obj=list[-1])

参数

• obj -- 可选参数，要移除列表元素的对象。

  返回值

  该方法返回从列表中移除的元素对象。

  实例

  以下实例展示了 pop()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao']
  list1.pop()
  print ("列表现在为 : ", list1)
  list1.pop(1)
  print ("列表现在为 : ", list1)

  以上实例输出结果如下：

  列表现在为 : ['Google', 'Runoob']
  列表现在为 : ['Google']

   

List remove()方法

2017年4月13日

20:42

   

描述

remove() 函数用于移除列表中某个值的第一个匹配项。

语法

remove()方法语法：

list.remove(obj)

参数

• obj -- 列表中要移除的对象。

  返回值

  该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

  实例

  以下实例展示了 remove()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
  list1.remove('Taobao')
  print ("列表现在为 : ", list1)
  list1.remove('Baidu')
  print ("列表现在为 : ", list1)

  以上实例输出结果如下：

  列表现在为 : ['Google', 'Runoob', 'Baidu']
  列表现在为 : ['Google', 'Runoob']

   

List reverse()方法

2017年4月13日

20:42

   

描述

reverse() 函数用于反向列表中元素。

语法

reverse()方法语法：

list.reverse()

参数

• NA。

  返回值

  该方法没有返回值，但是会对列表的元素进行反向排序。

  实例

  以下实例展示了 reverse()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
  list1.reverse()
  print ("列表反转后: ", list1)

  以上实例输出结果如下：

  列表反转后: ['Baidu', 'Taobao', 'Runoob', 'Google']

   

List sort()方法

2017年4月13日

20:42

   

描述

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法

sort()方法语法：

list.sort([func])

参数

• func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

  返回值

  该方法没有返回值，但是会对列表的对象进行排序。

  实例

  以下实例展示了 sort()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
  list1.sort()
  print ("列表排序后 : ", list1)

  以上实例输出结果如下：

  列表排序后 : ['Baidu', 'Google', 'Runoob', 'Taobao']

   

List clear()方法

2017年4月13日

20:42

   

描述

clear() 函数用于清空列表，类似于 del a[:]。

语法

clear()方法语法：

list.clear()

参数

• 无。

  返回值

  该方法没有返回值。

  实例

  以下实例展示了 clear()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
  list1.clear()
  print ("列表清空后 : ", list1)

  以上实例输出结果如下：

  列表清空后 : []

   

List copy()方法

2017年4月13日

20:42

   

描述

copy() 函数用于复制列表，类似于 a[:]。

语法

copy()方法语法：

list.copy()

参数

• 无。

  返回值

  返回复制后的新列表。

  实例

  以下实例展示了 copy()函数的使用方法：

  #!/usr/bin/python3

  list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
  list2 = list1.copy()
  print ("list2 列表: ", list2)

  以上实例输出结果如下：

  list2 列表: ['Google', 'Runoob', 'Taobao', 'Baidu']

   

   

元组

2017年4月13日

10:55

   

   

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

如下实例：

tup1 = ('Google', 'Runoob', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,);

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

   

访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

#!/usr/bin/python3

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：

tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)

   

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#!/usr/bin/python3

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3)

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')

   

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/python3

tup = ('Google', 'Runoob', 1997, 2000)

print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

删除后的元组 tup :
Traceback (most recent call last):
File "test.py", line 8, in <module>
print (tup)
NameError: name 'tup' is not defined

   

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

   

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('Google', 'Taobao', 'Runoob')

运行实例如下：

>>> L = ('Google', 'Taobao', 'Runoob')
>>> L[2]
'Runoob'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'Runoob')

   

元组内置函数

Python元组包含了以下内置函数

   

   

字典

2017年4月13日

10:55

   

   

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(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/python3

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

以上实例输出结果：

dict['Name']: Runoob
dict['Age']: 7

如果用字典里没有的键访问数据，会输出错误如下：

#!/usr/bin/python3

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'};

print ("dict['Alice']: ", dict['Alice'])

以上实例输出结果：

Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'

   

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

#!/usr/bin/python3

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8; # 更新 Age
dict['School'] = "菜鸟教程" # 添加信息

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

以上实例输出结果：

dict['Age']: 8
dict['School']: 菜鸟教程

   

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

#!/usr/bin/python3

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name'] # 删除键 'Name'
dict.clear() # 删除字典
del dict # 删除字典

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

但这会引发一个异常，因为用执行 del 操作后字典不再存在：

Traceback (most recent call last):
File "test.py", line 9, in <module>
print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable

注：del() 方法后面也会讨论。

字典键的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

#!/usr/bin/python3

dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}

print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

dict['Name']: 小菜鸟

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

#!/usr/bin/python3

dict = {['Name']: 'Runoob', 'Age': 7}

print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

   

字典内置函数&方法

Python字典包含了以下内置函数：

Python字典包含了以下内置方法：

   

字典内置方法

2017年4月13日

20:53

   

clear()方法

2017年4月13日

20:53

   

描述

Python 字典 clear() 函数用于删除字典内所有元素。

语法

clear()方法语法：

dict.clear()

参数

• NA。

  返回值

  该函数没有任何返回值。

  实例

  以下实例展示了 clear()函数的使用方法：

  #!/usr/bin/python3

  dict = {'Name': 'Zara', 'Age': 7}

  print ("字典长度 : %d" % len(dict))
  dict.clear()
  print ("字典删除后长度 : %d" % len(dict))

  以上实例输出结果为：

  字典长度 : 2
  字典删除后长度 : 0

   

copy()方法

2017年4月13日

20:53

   

描述

Python 字典 copy() 函数返回一个字典的浅复制。

语法

copy()方法语法：

dict.copy()

参数

• NA。

  返回值

  返回一个字典的浅复制。

  实例

  以下实例展示了 copy()函数的使用方法：

  实例

  #!/usr/bin/python3

  dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

  dict2 = dict1.copy()

  print ("新复制的字典为 : ",dict2)

  以上实例输出结果为：

  新复制的字典为 : {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}

     

  直接赋值和 copy 的区别

  可以通过以下实例说明：

  实例

  #!/usr/bin/python

  # -*- coding: UTF-8 -*-

  dict1 = {'user':'runoob','num':[1,2,3]}

  dict2 = dict1 # 浅拷贝: 引用对象

  dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用

  # 修改 data 数据

  dict1['user']='root'

  dict1['num'].remove(1)

  # 输出结果

  print(dict1)

  print(dict2)

  print(dict3)

  实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。

  {'user': 'root', 'num': [2, 3]}
  {'user': 'root', 'num': [2, 3]}
  {'user': 'runoob', 'num': [2, 3]}

   

fromkeys()方法

2017年4月13日

20:53

   

描述

Python 字典 fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

语法

fromkeys()方法语法：

dict.fromkeys(seq[, value]))

参数

• seq -- 字典键值列表。
• value -- 可选参数, 设置键序列（seq）的值。

  返回值

  该方法返回列表。

  实例

  以下实例展示了 fromkeys()函数的使用方法：

  #!/usr/bin/python3

  seq = ('name', 'age', 'sex')

  dict = dict.fromkeys(seq)
  print ("新的字典为 : %s" % str(dict))

  dict = dict.fromkeys(seq, 10)
  print ("新的字典为 : %s" % str(dict))

  以上实例输出结果为：

  新的字典为 : {'age': None, 'name': None, 'sex': None}
  新的字典为 : {'age': 10, 'name': 10, 'sex': 10}

   

get() 方法

2017年4月13日

20:53

   

描述

Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值。

语法

get()方法语法：

dict.get(key, default=None)

参数

• key -- 字典中要查找的键。
• default -- 如果指定键的值不存在时，返回该默认值值。

  返回值

  返回指定键的值，如果值不在字典中返回默认值 None。

  实例

  以下实例展示了 get()函数的使用方法：

  #!/usr/bin/python3

  dict = {'Name': 'Runoob', 'Age': 27}

  print ("Age 值为 : %s" % dict.get('Age'))
  print ("Sex 值为 : %s" % dict.get('Sex', "NA"))

  以上实例输出结果为：

  Age 值为 : 27
  Sex 值为 : NA

   

in 操作符

2017年4月13日

20:53

   

描述

Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。

语法

has_key()方法语法：

key in dict

参数

• key -- 要在字典中查找的键。

  返回值

  如果键在字典里返回true，否则返回false。

  实例

  以下实例展示了 in 操作符在字典中的使用方法：

  #!/usr/bin/python3

  dict = {'Name': 'Runoob', 'Age': 7}

  # 检测键 Age 是否存在
  if 'Age' in dict:
  print("键 Age 存在")
  else :
          print("键 Age 不存在")

  # 检测键 Sex 是否存在
  if 'Sex' in dict:
  print("键 Sex 存在")
  else :
  print("键 Sex 不存在")

  以上实例输出结果为：

  键 Age 存在
  键 Sex 不存在

   

items() 方法

2017年4月13日

20:53

   

描述

Python 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组。

语法

items()方法语法：

dict.items()

参数

• NA。

  返回值

  返回可遍历的(键, 值) 元组数组。

  实例

  以下实例展示了 items() 方法的使用方法：

  #!/usr/bin/python3

  dict = {'Name': 'Runoob', 'Age': 7}

  print ("Value : %s" % dict.items())

  以上实例输出结果为：

  Value : dict_items([('Age', 7), ('Name', 'Runoob')])

   

keys() 方法

2017年4月13日

20:53

   

描述

Python 字典 keys() 方法以列表返回一个字典所有的键。

语法

keys()方法语法：

dict.keys()

参数

• NA。

  返回值

  返回一个字典所有的键。

  实例

  以下实例展示了 keys() 方法的使用方法：

  #!/usr/bin/python3

  dict = {'Name': 'Runoob', 'Age': 7}

  print ("字典所有的键为 : %s" % dict.keys())

  以上实例输出结果为：

  字典所有的键为 : dict_keys(['Age', 'Name'])

   

setdefault() 方法

2017年4月13日

20:53

   

描述

Python 字典 setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。

语法

setdefault()方法语法：

dict.setdefault(key, default=None)

参数

• key -- 查找的键值。
• default -- 键不存在时，设置的默认键值。

  返回值

  该方法没有任何返回值。

  实例

  以下实例展示了 setdefault() 方法的使用方法：

  #!/usr/bin/python3

  dict = {'Name': 'Runoob', 'Age': 7}

  print ("Age 键的值为 : %s" % dict.setdefault('Age', None))
  print ("Sex 键的值为 : %s" % dict.setdefault('Sex', None))
  print ("新字典为：", dict)

  以上实例输出结果为：

  Age 键的值为 : 7
  Sex 键的值为 : None
  新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}

   

update() 方法

2017年4月13日

20:53

   

描述

Python 字典 update() 函数把字典dict2的键/值对更新到dict里。

语法

update()方法语法：

dict.update(dict2)

参数

• dict2 -- 添加到指定字典dict里的字典。

  返回值

  该方法没有任何返回值。

  实例

  以下实例展示了 update()函数的使用方法：

  #!/usr/bin/python3

  dict = {'Name': 'Runoob', 'Age': 7}
  dict2 = {'Sex': 'female' }

  dict.update(dict2)
  print ("更新字典 dict : ", dict)

  以上实例输出结果为：

  更新字典 dict : {'Sex': 'female', 'Age': 7, 'Name': 'Runoob'}

   

values() 方法

2017年4月13日

20:53

   

描述

Python 字典 values() 方法以列表返回字典中的所有值。

语法

values()方法语法：

dict.values()

参数

• NA。

  返回值

  返回字典中的所有值。

  实例

  以下实例展示了 values() 方法的使用方法：

  #!/usr/bin/python3

  dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}

  print ("字典所有值为 : ", list(dict.values()))

  以上实例输出结果为：

  字典所有值为 : ['female', 'Zara', 7]

   

   

Python3 编程第一步

2017年4月13日

10:55

   

   

在前面的教程中我们已经学习了一些 Python3 的基本语法知识，下面我们尝试来写一个斐波纳契数列。

实例如下：

#!/usr/bin/python3

# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:
print(b)
a, b = b, a+b

执行以上程序，输出结果为：

1
1
2
3
5
8

这个例子介绍了几个新特征。

• 第一行包含了一个复合赋值：变量 a 和 b 同时得到新值 0 和 1。最后一行再次使用了同样的方法，可以看到，右边的表达式会在赋值变动之前执行。右边表达式的执行顺序是从左往右的。

  >>> i = 256*256
  >>> print('i 的值为：', i)
  i 的值为： 65536

  end 关键字

  关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：

  #!/usr/bin/python3

  # Fibonacci series: 斐波纳契数列
  # 两个元素的总和确定了下一个数
  a, b = 0, 1
  while b < 1000:
  print(b, end=',')
  a, b = b, a+b

  执行以上程序，输出结果为：

  1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

     

   

   

Python3 条件控制

2017年4月13日

10:55

   

   

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

   

if 语句

Python中if语句的一般形式如下所示：

if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3

• 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
• 如果 "condition_1" 为False，将判断 "condition_2"
• 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
• 如果 "condition_2" 为False，将执行"statement_block_3"块语句

  Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

  注意：

• 1、每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在Python中没有switch – case语句。

  实例

  以下是一个简单的 if 实例：

  #!/usr/bin/python3

  var1 = 100
  if var1:
  print ("1 - if 表达式条件为 true")
  print (var1)

  var2 = 0
  if var2:
  print ("2 - if 表达式条件为 true")
  print (var2)
  print ("Good bye!")

  执行以上代码，输出结果为：

  1 - if 表达式条件为 true
  100
  Good bye!

  从结果可以看到由于变量 var2 为 0，所以对应的 if 内的语句没有执行。

  以下实例演示了狗的年龄计算判断：

  #!/usr/bin/python3

  age = int(input("请输入你家狗狗的年龄: "))
  print("")
  if age < 0:
          print("你是在逗我吧!")
  elif age == 1:
          print("相当于 14 岁的人。")
  elif age == 2:
          print("相当于 22 岁的人。")
  elif age > 2:
          human = 22 + (age -2)*5
          print("对应人类年龄: ", human)

  ### 退出提示
  input("点击 enter 键退出")

  将以上脚本保存在dog.py文件中，并执行该脚本：

  $ python3 dog.py
  请输入你家狗狗的年龄: 1

  相当于 14 岁的人。
  点击 enter 键退出

  以下为if中常用的操作运算符:

实例

#!/usr/bin/python3

# 程序演示了 == 操作符
# 使用数字
print(5 == 6)
# 使用变量
x = 5
y = 8
print(x == y)

以上实例输出结果：

False
False

high_low.py文件演示了数字的比较运算：

#!/usr/bin/python3

# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
guess = int(input("请输入你猜的数字："))

if guess == number:
print("恭喜，你猜对了！")
elif guess < number:
print("猜的数字小了...")
elif guess > number:
print("猜的数字大了...")

执行以上脚本，实例输出结果如下：

$ python3 high_low.py
数字猜谜游戏!
请输入你猜的数字：1
猜的数字小了...
请输入你猜的数字：9
猜的数字大了...
请输入你猜的数字：7
恭喜，你猜对了！

   

if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

if 表达式1:
语句
if 表达式2:
语句
elif 表达式3:
语句
else
语句
elif 表达式4:
语句
else:
语句

实例

# !/usr/bin/python3

num=int(input("输入一个数字："))
if num%2==0:
if num%3==0:
print ("你输入的数字可以整除 2 和 3")
else:
print ("你输入的数字可以整除 2，但不能整除 3")
else:
if num%3==0:
print ("你输入的数字可以整除 3，但不能整除 2")
else:
print ("你输入的数字不能整除 2 和 3")

将以上程序保存到 test_if.py 文件中，执行后输出结果为：

$ python3 test.py
输入一个数字：6
你输入的数字可以整除 2 和 3

   

   

Python3 循环语句

2017年4月13日

10:55

   

   

本章节将为大家介绍Python循环语句的使用。

Python中的循环语句有 for 和 while。

Python循环语句的控制结构图如下所示：

   

while 循环

Python中while语句的一般形式：

while 判断条件：
语句

同样需要注意冒号和缩进。另外，在Python中没有do..while循环。

以下实例使用了 while 来计算 1 到 100 的总和：

#!/usr/bin/env python3

n = 100

sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1

print("1 到 %d 之和为: %d" % (n,sum))

执行结果如下：

1 到 100 之和为: 5050

无限循环

我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下：

#!/usr/bin/python3

var = 1
while var == 1 : # 表达式永远为 true
num = int(input("输入一个数字 :"))
print ("你输入的数字是: ", num)

print ("Good bye!")

执行以上脚本，输出结果如下：

输入一个数字 :5
你输入的数字是: 5
输入一个数字 :

你可以使用 CTRL+C 来退出当前的无限循环。

无限循环在服务器上客户端的实时请求非常有用。

while 循环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块：

#!/usr/bin/python3

count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")

执行以上脚本，输出结果如下：

0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 大于或等于 5

简单语句组

类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：

#!/usr/bin/python

flag = 1

while (flag): print ('欢迎访问菜鸟教程!')

print ("Good bye!")

注意：以上的无限循环你可以使用 CTRL+C 来中断循环。

执行以上脚本，输出结果如下：

   

   

for 语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>:
<statements>
else:
<statements>

Python loop循环实例：

>>> languages = ["C", "C++", "Perl", "Python"]
>>> for x in languages:
... print (x)
...
C
C++
Perl
Python
>>>

以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

#!/usr/bin/python3

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")

执行脚本后，在循环到 "Runoob"时会跳出循环体：

循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

   

range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

>>> for i in range(5):
... print(i)
...
0
1
2
3
4

你也可以使用range指定区间的值：

>>> for i in range(5,9) :
print(i)

5
6
7
8
>>>

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'):

>>> for i in range(0, 10, 3) :
print(i)

0
3
6
9
>>>

负数：

>>> for i in range(-10, -100, -30) :
print(i)

-10
-40
-70
>>>

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

>>> a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

还可以使用range()函数来创建一个列表：

>>> list(range(5))
[0, 1, 2, 3, 4]
>>>

   

break和continue语句及循环中的else子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下：

#!/usr/bin/python3

for letter in 'Runoob': # 第一个实例
if letter == 'b':
break
print ('当前字母为 :', letter)

var = 10 # 第二个实例
while var > 0:
print ('当期变量值为 :', var)
var = var -1
if var == 5:
break

print ("Good bye!")

执行以上脚本输出结果为：

当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
Good bye!

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

#!/usr/bin/python3

for letter in 'Runoob': # 第一个实例
if letter == 'o': # 字母为 o 时跳过输出
continue
print ('当前字母 :', letter)

var = 10 # 第二个实例
while var > 0:
var = var -1
if var == 5: # 变量为 5 时跳过输出
continue
print ('当前变量值 :', var)
print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
当前字母 : b
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

如下实例用于查询质数的循环例子:

#!/usr/bin/python3

for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等于', x, '*', n//x)
break
else:
# 循环中没有找到元素
print(n, ' 是质数')

执行以上脚本输出结果为：

2 是质数
3 是质数
4 等于 2 * 2
5 是质数
6 等于 2 * 3
7 是质数
8 等于 2 * 4
9 等于 3 * 3

   

pass 语句

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句，如下实例

>>> while True:
... pass # 等待键盘中断 (Ctrl+C)

最小的类:

>>> class MyEmptyClass:
... pass

以下实例在字母为 o 时 执行 pass 语句块:

#!/usr/bin/python3

for letter in 'Runoob':
if letter == 'o':
pass
print ('执行 pass 块')
print ('当前字母 :', letter)

print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

   

   

Python3 迭代器与生成器

2017年4月13日

10:55

   

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list) # 创建迭代器对象
>>> print (next(it)) # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规for语句进行遍历：

#!/usr/bin/python3

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")

执行以上程序，输出结果如下：

1 2 3 4

也可以使用 next() 函数：

#!/usr/bin/python3

import sys # 引入 sys 模块

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象

while True:
try:
print (next(it))
except StopIteration:
sys.exit()

执行以上程序，输出结果如下：

1
2
3
4

   

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

>>> g = (x * x for x in range(10))
>>> for n in g:
... print(n)
...
0
1
4
9
16
25
36
49
64
81

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

举个简单的例子，定义一个generator，依次返回数字1，3，5：

def odd():
print('step 1')
yield 1
print('step 2')
yield(3)
print('step 3')
yield(5)

调用该generator时，首先要生成一个generator对象，然后用next()函数不断获得下一个返回值：

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

可以看到，odd不是普通函数，而是generator，在执行过程中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield可以执行了，所以，第4次调用next(o)就报错。

   

   

yield 与 return

在一个生成器中，如果没有return，则默认执行到函数完毕时返回StopIteration；

Python

   

如果遇到return,如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

Python

   

如果在return后返回一个值，那么这个值为StopIteration异常的说明，不是程序的返回值。

生成器没有办法使用return来返回值。

Python

   

   

   

   

   

   

   

   

以下实例使用 yield 实现斐波那契数列：

#!/usr/bin/python3

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55

   

   

Python3生成器

2017年5月13日

7:31

   

生成器(generator)概念

生成器不会把结果保存在一个系列中，而是保存生成器的状态，在每次进行迭代时返回一个值，直到遇到StopIteration异常结束。

生成器语法

生成器表达式： 通列表解析语法，只不过把列表解析的[]换成()

生成器表达式能做的事情列表解析基本都能处理，只不过在需要处理的序列比较大时，列表解析比较费内存。

Python

生成器函数： 在函数中如果出现了yield关键字，那么该函数就不再是普通函数，而是生成器函数。

但是生成器函数可以生产一个无线的序列，这样列表根本没有办法进行处理。

yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator。

下面为一个可以无穷生产奇数的生成器函数。

Python

   

生成器支持的方法

2017年5月13日

7:38

   

生成器支持的方法

Python

   

close()

手动关闭生成器函数，后面的调用会直接返回StopIteration异常。

Python

 send()

生成器函数最大的特点是可以接受外部传入的一个变量，并根据变量内容计算结果后返回。

这是生成器函数最难理解的地方，也是最重要的地方，实现后面我会讲到的协程就全靠它了。

Python

执行流程：

1. 通过g.send(None)或者next(g)可以启动生成器函数，并执行到第一个yield语句结束的位置。此时，执行完了yield语句，但是没有给receive赋值。yield value会输出初始值0注意：在启动生成器函数时只能send(None),如果试图输入其它的值都会得到错误提示信息。
2. 通过g.send('aaa')，会传入aaa，并赋值给receive，然后计算出value的值，并回到while头部，执行yield value语句有停止。此时yield value会输出"got: aaa"，然后挂起。
3. 通过g.send(3)，会重复第2步，最后输出结果为"got: 3″
4. 当我们g.send('e')时，程序会执行break然后推出循环，最后整个函数执行完毕，所以会得到StopIteration异常。

最后的执行结果如下：

Python

   

   

   

Python3 函数

2017年4月13日

10:55

   

   

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

   

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

     

  语法

  Python 定义函数使用 def 关键字，一般格式如下：

  def 函数名（参数列表）:
  函数体

  默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

  实例

  让我们使用函数来输出"Hello World！"：

  >>> def hello() :
  print("Hello World!")

  >>> hello()
  Hello World!
  >>>

  更复杂点的应用，函数中带上参数变量:

  #!/usr/bin/python3

  # 计算面积函数
  def area(width, height):
  return width * height
  
  def print_welcome(name):
  print("Welcome", name)

  print_welcome("Runoob")
  w = 4
  h = 5
  print("width =", w, " height =", h, " area =", area(w, h))

  以上实例输出结果：

  Welcome Runoob
  width = 4 height = 5 area = 20

     

  函数调用

  定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

  这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

  如下实例调用了 printme() 函数：

  #!/usr/bin/python3
  
  # 定义函数
  def printme( str ):
  "打印任何传入的字符串"
  print (str);
  return;
  
  # 调用函数
  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 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

  python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

  python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

  python 传不可变对象实例

  #!/usr/bin/python3
  
  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 指向它。

  传可变对象实例

  可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

  #!/usr/bin/python3
  
  # 可写函数说明
  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()函数，你必须传入一个参数，不然会出现语法错误：

  #!/usr/bin/python3
  
  #可写函数说明
  def printme( str ):
  "打印任何传入的字符串"
  print (str);
  return;
  
  #调用printme函数
  printme();

  以上实例输出结果：

  Traceback (most recent call last):
  File "test.py", line 10, in <module>
  printme();
  TypeError: printme() missing 1 required positional argument: 'str'

  关键字参数

  关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

  使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

  以下实例在函数 printme() 调用时使用参数名：

  #!/usr/bin/python3
  
  #可写函数说明
  def printme( str ):
  "打印任何传入的字符串"
  print (str);
  return;
  
  #调用printme函数
  printme( str = "菜鸟教程");

  以上实例输出结果：

  菜鸟教程

  以下实例中演示了函数参数的使用不需要使用指定顺序：

  #!/usr/bin/python3
  
  #可写函数说明
  def printinfo( name, age ):
  "打印任何传入的字符串"
  print ("名字: ", name);
  print ("年龄: ", age);
  return;
  
  #调用printinfo函数
  printinfo( age=50, name="runoob" );

  以上实例输出结果：

  名字: runoob
  年龄: 50

  默认参数

  调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

  #!/usr/bin/python3
  
  #可写函数说明
  def printinfo( name, age = 35 ):
  "打印任何传入的字符串"
  print ("名字: ", name);
  print ("年龄: ", age);
  return;
  
  #调用printinfo函数
  printinfo( age=50, name="runoob" );
  print ("------------------------")
  printinfo( name="runoob" );

  以上实例输出结果：

  名字: runoob
  年龄: 50
  ------------------------
  名字: runoob
  年龄: 35

  不定长参数

  你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

  def functionname([formal_args,] *var_args_tuple ):
  "函数_文档字符串"
  function_suite
  return [expression]

  加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

  #!/usr/bin/python3
  
  # 可写函数说明
  def printinfo( arg1, *vartuple ):
  "打印任何传入的参数"
  print ("输出: ")
  print (arg1)
  for var in vartuple:
  print (var)
  return;
  
  # 调用printinfo 函数

  printinfo( 10 );
  printinfo( 70, 60, 50 );

  以上实例输出结果：

  输出:
  10
  输出:
  70
  60
  50

     

  匿名函数

  python 使用 lambda 来创建匿名函数。

  所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

  语法

  lambda 函数的语法只包含一个语句，如下：

  lambda [arg1 [,arg2,.....argn]]:expression

  如下实例：

  #!/usr/bin/python3
  
  # 可写函数说明
  sum = lambda arg1, arg2: arg1 + arg2;
  
  # 调用sum函数
  print ("相加后的值为 : ", sum( 10, 20 ))
  print ("相加后的值为 : ", sum( 20, 20 ))

  以上实例输出结果：

  相加后的值为 : 30
  相加后的值为 : 40

     

  return语句

  return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

  #!/usr/bin/python3

  # 可写函数说明
  def sum( arg1, arg2 ):
  # 返回2个参数的和."
  total = arg1 + arg2
  print ("函数内 : ", total)
  return total;

  # 调用sum函数
  total = sum( 10, 20 );
  print ("函数外 : ", total)

  以上实例输出结果：

  函数内 : 30
  函数外 : 30

     

  变量作用域

  Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

  变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4中，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内建作用域

  以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

  x = int(2.9) # 内建作用域
  
  g_count = 0 # 全局作用域
  def outer():
  o_count = 1 # 闭包函数外的函数中
  def inner():
  i_count = 2 # 局部作用域

  Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问，如下代码：

  >>> if True:
  ... msg = 'I am from Runoob'
  ...
  >>> msg
  'I am from Runoob'
  >>>

  实例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。

  如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：

  >>> def test():
  ... msg_inner = 'I am from Runoob'
  ...
  >>> msg_inner
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  NameError: name 'msg_inner' is not defined
  >>>

  从报错的信息上看，说明了 msg_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。

     

  全局变量和局部变量

  定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

  局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

  #!/usr/bin/python3

  total = 0; # 这是一个全局变量
  # 可写函数说明
  def sum( arg1, arg2 ):
  #返回2个参数的和."
  total = arg1 + arg2; # total在这里是局部变量.
  print ("函数内是局部变量 : ", total)
  return total;

  #调用sum函数
  sum( 10, 20 );
  print ("函数外是全局变量 : ", total)

  以上实例输出结果：

  函数内是局部变量 : 30
  函数外是全局变量 : 0

  global 和 nonlocal关键字

  当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

  以下实例修改全局变量 num：

  #!/usr/bin/python3

  num = 1
  def fun1():
  global num # 需要使用 global 关键字声明
  print(num)
  num = 123
  print(num)
  fun1()

  以上实例输出结果：

  1
  123

  如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

  #!/usr/bin/python3
  
  def outer():
  num = 10
  def inner():
  nonlocal num # nonlocal关键字声明
  num = 100
  print(num)
  inner()
  print(num)
  outer()

  以上实例输出结果：

  100
  100

  另外有一种特殊情况，假设下面这段代码被运行：

  #!/usr/bin/python3
  
  a = 10
  def test():
  a = a + 1
  print(a)
  test()

  以上程序执行，报错信息如下：

  Traceback (most recent call last):
  File "test.py", line 7, in <module>
  test()
  File "test.py", line 5, in test
  a = a + 1
  UnboundLocalError: local variable 'a' referenced before assignment

  错误信息为局部作用域引用错误，因为函数的内部使用外部作用域的变量时，这个变量是只读的，是不能修改。

     

   

   

Python3 面向对象

2017年4月13日

10:55

   

   

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

   

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 实例变量：定义在方法中的变量，只作用于当前实例的类。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

  和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

  Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

  对象可以包含任意数量和类型的数据。

  类定义

  语法格式如下：

  class ClassName:
  <statement-1>
  .
  .
  .
  <statement-N>

  类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

  类对象

  类对象支持两种操作：属性引用和实例化。

  属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

  类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

  #!/usr/bin/python3

  class MyClass:
  """一个简单的类实例"""
  i = 12345
  def f(self):
  return 'hello world'

  # 实例化类
  x = MyClass()

  # 访问类的属性和方法
  print("MyClass 类的属性 i 为：", x.i)
  print("MyClass 类的方法 f 输出为：", x.f())

  实例化类：

  # 实例化类
  x = MyClass()
  # 访问类的属性和方法

  以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

  执行以上程序输出结果为：

  MyClass 类的属性 i 为： 12345
  MyClass 类的方法 f 输出为： hello world

     

  很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法（构造方法），像下面这样：

  def __init__(self):
  self.data = []

  类定义了 __init__() 方法的话，类的实例化操作会自动调用 __init__() 方法。所以在下例中，可以这样创建一个新的实例:

  x = MyClass()

  当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:

  >>> class Complex:
  ... def __init__(self, realpart, imagpart):
  ... self.r = realpart
  ... self.i = imagpart
  ...
  >>> x = Complex(3.0, -4.5)
  >>> x.r, x.i
  (3.0, -4.5)

  self代表类的实例，而非类

  类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

  class Test:
  def prt(self):
  print(self)
  print(self.__class__)
  
  t = Test()
  t.prt()

  以上实例执行结果为：

  <__main__.Test instance at 0x100771878>
  __main__.Test

  从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

  self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:

  class Test:
  def prt(runoob):
  print(runoob)
  print(runoob.__class__)
  
  t = Test()
  t.prt()

  以上实例执行结果为：

  <__main__.Test instance at 0x100771878>
  __main__.Test

     

  类的方法

  在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数:

  #!/usr/bin/python3

  #类定义
  class people:
  #定义基本属性
  name = ''
  age = 0
  #定义私有属性,私有属性在类外部无法直接进行访问
  __weight = 0
  #定义构造方法
  def __init__(self,n,a,w):
  self.name = n
  self.age = a
  self.__weight = w
  def speak(self):
  print("%s 说: 我 %d 岁。" %(self.name,self.age))

  # 实例化类
  p = people('runoob',10,30)
  p.speak()

  执行以上程序输出结果为：

  runoob 说: 我 10 岁。

     

  继承

  Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

  class DerivedClassName(BaseClassName1):
  <statement-1>
  .
  .
  .
  <statement-N>

  需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。

  BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

  class DerivedClassName(modname.BaseClassName):

  实例

  #!/usr/bin/python3

  #类定义
  class people:
  #定义基本属性
  name = ''
  age = 0
  #定义私有属性,私有属性在类外部无法直接进行访问
  __weight = 0
  #定义构造方法
  def __init__(self,n,a,w):
  self.name = n
  self.age = a
  self.__weight = w
  def speak(self):
  print("%s 说: 我 %d 岁。" %(self.name,self.age))

  #单继承示例
  class student(people):
  grade = ''
  def __init__(self,n,a,w,g):
  #调用父类的构函
  people.__init__(self,n,a,w)
  self.grade = g
  #覆写父类的方法
  def speak(self):
  print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

  s = student('ken',10,60,3)
  s.speak()

  执行以上程序输出结果为：

  ken 说: 我 10 岁了，我在读 3 年级

     

  多继承

  Python同样有限的支持多继承形式。多继承的类定义形如下例:

  class DerivedClassName(Base1, Base2, Base3):
  <statement-1>
  .
  .
  .
  <statement-N>

  需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

  #!/usr/bin/python3

  #类定义
  class people:
  #定义基本属性
  name = ''
  age = 0
  #定义私有属性,私有属性在类外部无法直接进行访问
  __weight = 0
  #定义构造方法
  def __init__(self,n,a,w):
  self.name = n
  self.age = a
  self.__weight = w
  def speak(self):
  print("%s 说: 我 %d 岁。" %(self.name,self.age))

  #单继承示例
  class student(people):
  grade = ''
  def __init__(self,n,a,w,g):
  #调用父类的构函
  people.__init__(self,n,a,w)
  self.grade = g
  #覆写父类的方法
  def speak(self):
  print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

  #另一个类，多重继承之前的准备
  class speaker():
  topic = ''
  name = ''
  def __init__(self,n,t):
  self.name = n
  self.topic = t
  def speak(self):
  print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

  #多重继承
  class sample(speaker,student):
  a =''
  def __init__(self,n,a,w,g,t):
  student.__init__(self,n,a,w,g)
  speaker.__init__(self,n,t)

  test = sample("Tim",25,80,4,"Python")
  test.speak() #方法名同，默认调用的是在括号中排前地父类的方法

  执行以上程序输出结果为：

  我叫 Tim，我是一个演说家，我演讲的主题是 Python

     

  方法重写

  如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

  #!/usr/bin/python3

  class Parent: # 定义父类
  def myMethod(self):
  print ('调用父类方法')

  class Child(Parent): # 定义子类
  def myMethod(self):
  print ('调用子类方法')

  c = Child() # 子类实例
  c.myMethod() # 子类调用重写方法

  执行以上程序输出结果为：

  调用子类方法

     

  类属性与方法

  类的私有属性

  __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

  类的方法

  在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数

  类的私有方法

  __private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods。

  实例

  类的私有属性实例如下：

  #!/usr/bin/python3

  class JustCounter:
  __secretCount = 0 # 私有变量
  publicCount = 0 # 公开变量

  def count(self):
  self.__secretCount += 1
  self.publicCount += 1
  print (self.__secretCount)

  counter = JustCounter()
  counter.count()
  counter.count()
  print (counter.publicCount)
  print (counter.__secretCount) # 报错，实例不能访问私有变量

  执行以上程序输出结果为：

  1
  2
  2
  Traceback (most recent call last):
  File "test.py", line 16, in <module>
  print (counter.__secretCount) # 报错，实例不能访问私有变量
  AttributeError: 'JustCounter' object has no attribute '__secretCount'

  类的私有方法实例如下：

  #!/usr/bin/python3

  class Site:
          def __init__(self, name, url):
                  self.name = name # public
                  self.__url = url # private

  def who(self):
                  print('name : ', self.name)
                  print('url : ', self.__url)

  def __foo(self): # 私有方法
                  print('这是私有方法')

  def foo(self): # 公共方法
                  print('这是公共方法')
                  self.__foo()

  x = Site('菜鸟教程', 'www.runoob.com')
  x.who() # 正常输出
  x.foo() # 正常输出
  x.__foo() # 报错

  以上实例执行结果：

  

  类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __div__: 除运算
• __mod__: 求余运算
• __pow__: 称方

  运算符重载

  Python同样支持运算符重载，我么可以对类的专有方法进行重载，实例如下：

  #!/usr/bin/python3

  class Vector:
  def __init__(self, a, b):
  self.a = a
  self.b = b

  def __str__(self):
  return 'Vector (%d, %d)' % (self.a, self.b)
  
  def __add__(self,other):
  return Vector(self.a + other.a, self.b + other.b)

  v1 = Vector(2,10)
  v2 = Vector(5,-2)
  print (v1 + v2)

  以上代码执行结果如下所示:

  Vector(7,8)

     

   

静态方法与类方法

2017年5月15日

7:47

   

静态方法和类方法

1. 类方法

是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。

class people:
country = 'china'

#类方法，用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country

p = people()
print p.getCountry() #可以用过实例对象引用
print people.getCountry() #可以通过类对象引用

类方法还有一个用途就是可以对类属性进行修改：

class people:
country = 'china'

#类方法，用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country

@classmethod
def setCountry(cls,country):
cls.country = country

p = people()
print p.getCountry() #可以用过实例对象引用
print people.getCountry() #可以通过类对象引用

p.setCountry('japan')

print p.getCountry()
print people.getCountry()

   

结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变

2. 静态方法

需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数

class people:
country = 'china'

@staticmethod
#静态方法
def getCountry():
return people.country

print people.getCountry()

总结

从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用

   

Object-父类

2017年5月15日

14:00

   

Python中关于object的说明很少，甚至只有一句话:

 

Python代码 收藏代码

class object

The most base type

   

   

 

 

   

   

   

Python内置类属性

2017年5月15日

13:53

   

Python内置类属性

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）

__doc__ :类的文档字符串

__name__: 类名

__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

Python内置类属性调用实例如下：

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

 

class Employee:

'所有员工的基类'

empCount = 0

 

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

 

def displayCount(self):

print "Total Employee %d" % Employee.empCount

 

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

 

print "Employee.__doc__:", Employee.__doc__

print "Employee.__name__:", Employee.__name__

print "Employee.__module__:", Employee.__module__

print "Employee.__bases__:", Employee.__bases__

print "Employee.__dict__:", Employee.__dict__

   

Super

2017年5月15日

13:41

   

python类的体系中如果出现了继承,子类如果没有写自己的初始化方法,会自动继承第一个父类的方法,所以我们需要自己写子类的初始化:如果像下面的代码:

   

class A:

def __init__(self):

print("Enter A")

print("Leave A")

   

class B(A):

def __init__(self):

print("Enter B")

A.__init__(self)

print("Leave B")

   

class C(A):

def __init__(self):

print("Enter C")

A.__init__(self)

print("Leave C")

   

class D(A):

def __init__(self):

print("Enter D")

A.__init__(self)

print("Leave D")

   

class E(B, C, D):

def __init__(self):

print("Enter E")

B.__init__(self)

C.__init__(self)

D.__init__(self)

print("Leave E")

s=E()

会造成公共父类A被调用多次.

   

正确的办法是使用super,它会把当前的类返回一个父类的对象,注意你在体系中使用了super那么所有的地方都要使用super,否则可能造成父类多次被调用或者不能调用所有的父类方法(这是由super的机制造成的,具体实现不懂),super保证所有父类只会执行一次，而且修改代码时也很方便:

   

class A(object):

def __init__(self):

print('Enter A')

self.__test = 0

class C(object):

def __init__(self):

print('Enter C')

super().__init__()

self.__test2 = 3

class D(object):

def __init__(self):

super().__init__()

print('enter D')

class B(A):

def __init__(self):

print('Enter B')

super().__init__()

def set(self):

self.__test = 2

def display(self):

print(dir(self))

class E(C,D):

def __init__(self):

print('Enter E')

super().__init__();

   

isinstance

2017年5月15日

13:46

   

语法：isinstance（object，type）

   

作用：来判断一个对象是否是一个已知的类型。

   

其第一个参数（object）为对象，第二个参数（type）为类型名(int...)或类型名的一个列表((int,list,float)是一个列表)。其返回值为布尔型（True or flase）。

   

若对象的类型与参数二的类型相同则返回True。若参数二为一个元组，则若对象类型与元组中类型名之一相同即返回True。

   

下面是两个例子：

   

例一

   

>>> a = 4

>>> isinstance (a,int)

True

>>> isinstance (a,str)

False

>>> isinstance (a,(str,int,list))

True

   

 

   

例二

   

>>> a = "b"

>>> isinstance(a,str)

True

>>> isinstance(a,int)

False

>>> isinstance(a,(int,list,float))

False

>>> isinstance(a,(int,list,float,str))

True

   

 

   

一、isinstance()

   

在Python中可以使用type()与isinstance()这两个函数判断对象类型，而isinstance()函数的使用上比type更加方便。

   

   

复制代码 代码如下:

   

   

# coding=utf-8

 

a = 10

 

def b():

pass

 

print isinstance(a,(int,str))

print isinstance(a,(float,str))

print isinstance(b,(str,int))

 

class c:

pass

 

obj = c()

 

print isinstance(obj,(c,int))

   

   

执行结果：

   

复制代码 代码如下:

   

   

True

False

False

True

   

   

   

二、isinstance 和 type的区别

   

isinstance 和 type的区别在于：

   

   

复制代码 代码如下:

   

   

class A:

pass

   

class B(A):

pass

   

isinstance(A(), A) # returns True

type(A()) == A # returns True

isinstance(B(), A) # returns True

type(B()) == A # returns False

   

   

区别就是 对于subclass之类的 type就不行了，所以,强烈建议不要使用type判断对象类型。

   

   

多态

2017年5月15日

7:45

   

多态

多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚"鸭子类型"。

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态

• Python伪代码实现Java或C#的多态
  
  class F1:
  pass
  
  class S1(F1):
  def show(self):
  print 'S1.show'
  
  class S2(F1):
  def show(self):
  print 'S2.show'
  
  # 由于在Java或C#中定义函数参数时，必须指定参数的类型
  # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
  # 而实际传入的参数是：S1对象和S2对象
  
  def Func(F1 obj):
  """Func函数需要接收一个F1类型或者F1子类的类型"""
  
  print obj.show()
  
  s1_obj = S1()
  Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
  
  s2_obj = S2()
  Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
• Python "鸭子类型"
  class F1:
  pass
  
  class S1(F1):
  
  def show(self):
  print 'S1.show'
  
  class S2(F1):
  
  def show(self):
  print 'S2.show'
  
  def Func(obj):
  print obj.show()
  
  s1_obj = S1()
  Func(s1_obj)
  
  s2_obj = S2()
  Func(s2_obj)

   

   

Python3 数据结构

2017年4月13日

10:55

   

   

本章节我们主要结合前面所学的知识点来介绍Python数据结构。

   

列表

Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

以下是 Python 中列表的方法：

下面示例演示了列表的大部分方法：

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

注意：类似 insert, remove 或 sort 等修改列表的方法没有返回值。

   

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

   

将列表当作队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

   

列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

这里我们将列表中每个数值乘三，获得一个新的列表：

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

现在我们玩一点小花样：

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

这里我们对序列里每一个元素逐个调用某方法：

>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']

我们可以用 if 子句作为过滤器：

>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]

以下是一些关于循环和其它技巧的演示：

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

列表推导式可以使用复杂表达式或嵌套函数：

>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

   

嵌套列表解析

Python的列表还可以嵌套。

以下实例展示了3X4的矩阵列表：

>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]

以下实例将3X4的矩阵列表转换为4X3列表：

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

以下实例也可以使用以下方法来实现：

>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另外一种实现方法：

>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

   

del 语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。例如：

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

也可以用 del 删除实体变量：

>>> del a

   

元组和序列

元组由若干逗号分隔的值组成，例如：

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

   

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下一节我们会介绍这个数据结构。

以下是一个简单的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 删除重复的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 检测成员
True
>>> 'crabgrass' in basket
False

>>> # 以下演示了两个集合的操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # a 中唯一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 在 a 中的字母，但不在 b 中
{'r', 'd', 'b'}
>>> a | b # 在 a 或 b 中的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 在 a 和 b 中都有的字母
{'a', 'c'}
>>> a ^ b # 在 a 或 b 中的字母，但不同时在 a 和 b 中
{'r', 'd', 'b', 'm', 'z', 'l'}

集合也支持推导式：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

   

字典

另一个非常有用的 Python 内建数据类型是字典。

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。

一对大括号创建一个空的字典：{}。

这是一个字典运用的简单例子：

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

此外，字典推导可以用来创建任意键和值的表达式词典：

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

   

遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.

要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear

   

   

   

Python3 输入和输出

2017年4月13日

10:55

   

   

在前面几个章节中，我们其实已经接触了 Python 的输入输出的功能。本章节我们将具体介绍 Python 的输入输出。

   

输出格式美化

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

• str()： 函数返回一个用户易读的表达形式。
• repr()： 产生一个解释器易读的表达形式。

  例如

  >>> s = 'Hello, Runoob'
  >>> str(s)
  'Hello, Runoob'
  >>> repr(s)
  "'Hello, Runoob'"
  >>> str(1/7)
  '0.14285714285714285'
  >>> x = 10 * 3.25
  >>> y = 200 * 200
  >>> s = 'x 的值为： ' + repr(x) + ', y 的值为：' + repr(y) + '...'
  >>> print(s)
  x 的值为： 32.5, y 的值为：40000...
  >>> # repr() 函数可以转义字符串中的特殊字符
  ... hello = 'hello, runoob\n'
  >>> hellos = repr(hello)
  >>> print(hellos)
  'hello, runoob\n'
  >>> # repr() 的参数可以是 Python 的任何对象
  ... repr((x, y, ('Google', 'Runoob')))
  "(32.5, 40000, ('Google', 'Runoob'))"

  这里有两种方式输出一个平方与立方的表:

  >>> for x in range(1, 11):
  ... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
  ... # 注意前一行 'end' 的使用
  ... print(repr(x*x*x).rjust(4))
  ...
  1 1 1
  2 4 8
  3 9 27
  4 16 64
  5 25 125
  6 36 216
  7 49 343
  8 64 512
  9 81 729
  10 100 1000

  >>> for x in range(1, 11):
  ... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
  ...
  1 1 1
  2 4 8
  3 9 27
  4 16 64
  5 25 125
  6 36 216
  7 49 343
  8 64 512
  9 81 729
  10 100 1000

  注意：在第一个例子中, 每列间的空格由 print() 添加。

  这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

  还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。

  另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：

  >>> '12'.zfill(5)
  '00012'
  >>> '-3.14'.zfill(7)
  '-003.14'
  >>> '3.14159265359'.zfill(5)
  '3.14159265359'

  str.format() 的基本使用如下:

  >>> print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))
  菜鸟教程网址： "www.runoob.com!"

  括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

  在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

  >>> print('{0} 和 {1}'.format('Google', 'Runoob'))
  Google 和 Runoob
  >>> print('{1} 和 {0}'.format('Google', 'Runoob'))
  Runoob 和 Google

  如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

  >>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
  菜鸟教程网址： www.runoob.com

  位置及关键字参数可以任意的结合:

  >>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob',
  other='Taobao'))
  站点列表 Google, Runoob, 和 Taobao。

  '!a' (使用 ascii()), '!s' (使用 str()) 和 '!r' (使用 repr()) 可以用于在格式化某个值之前对其进行转化:

  >>> import math
  >>> print('常量 PI 的值近似为： {}。'.format(math.pi))
  常量 PI 的值近似为： 3.141592653589793。
  >>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
  常量 PI 的值近似为： 3.141592653589793。

  可选项 ':' 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位：

  >>> import math
  >>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
  常量 PI 的值近似为 3.142。

  在 ':' 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。

  >>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
  >>> for name, number in table.items():
  ... print('{0:10} ==> {1:10d}'.format(name, number))
  ...
  Runoob ==> 2
  Taobao ==> 3
  Google ==> 1

  如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。

  最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值 :

  >>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
  >>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; '
  'Taobao: {0[Taobao]:d}'.format(table))
  Runoob: 2; Google: 1; Taobao: 3

  也可以通过在 table 变量前使用 '**' 来实现相同的功能：

  >>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
  >>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
  Runoob: 2; Google: 1; Taobao: 3

     

  旧式字符串格式化

  % 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

  >>> import math
  >>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
  常量 PI 的值近似为：3.142。

  因为 str.format() 比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

     

  读取键盘输入

  Python提供了 input() 置函数从标准输入读入一行文本，默认的标准输入是键盘。

  input 可以接收一个Python表达式作为输入，并将运算结果返回。

  #!/usr/bin/python3

  str = input("请输入：");
  print ("你输入的内容是: ", str)

  这会产生如下的对应着输入的结果：

  请输入：菜鸟教程
  你输入的内容是: 菜鸟教程

     

  读和写文件

  open() 将会返回一个 file 对象，基本语法格式如下:

  open(filename, mode)

• filename：filename 变量是一个包含了你要访问的文件名称的字符串值。
• mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

  不同模式打开文件的完全列表：

以下实例将字符串写入到文件 foo.txt 中：

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()

• 第一个参数为要打开的文件名。
• 第二个参数描述文件如何使用的字符。 mode 可以是 'r' 如果文件只读, 'w' 只用于写 (如果存在同名文件则将被删除), 和 'a' 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. 'r+' 同时用于读写。 mode 参数是可选的; 'r' 将是默认值。

  此时打开文件 foo.txt,显示如下：

  $ cat /tmp/foo.txt
  Python 是一个非常好的语言。
  是的，的确非常好!!

     

  文件对象的方法

  本节中剩下的例子假设已经创建了一个称为 f 的文件对象。

  f.read()

  为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

  size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

  以下实例假定文件 foo.txt 已存在（上面实例中已创建）：

  #!/usr/bin/python3

  # 打开一个文件
  f = open("/tmp/foo.txt", "r")

  str = f.read()
  print(str)

  # 关闭打开的文件
  f.close()

  执行以上程序，输出结果为：

  Python 是一个非常好的语言。
  是的，的确非常好!!

  f.readline()

  f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

  #!/usr/bin/python3

  # 打开一个文件
  f = open("/tmp/foo.txt", "r")

  str = f.readline()
  print(str)

  # 关闭打开的文件
  f.close()

  执行以上程序，输出结果为：

  Python 是一个非常好的语言。

  f.readlines()

  f.readlines() 将返回该文件中包含的所有行。

  如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

  #!/usr/bin/python3

  # 打开一个文件
  f = open("/tmp/foo.txt", "r")

  str = f.readlines()
  print(str)

  # 关闭打开的文件
  f.close()

  执行以上程序，输出结果为：

  ['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']

  另一种方式是迭代一个文件对象然后读取每行:

  #!/usr/bin/python3

  # 打开一个文件
  f = open("/tmp/foo.txt", "r")

  for line in f:
  print(line, end='')

  # 关闭打开的文件
  f.close()

  执行以上程序，输出结果为：

  Python 是一个非常好的语言。
  是的，的确非常好!!

  这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用。

  f.write()

  f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

  #!/usr/bin/python3

  # 打开一个文件
  f = open("/tmp/foo.txt", "w")

  num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
  print(num)
  # 关闭打开的文件
  f.close()

  执行以上程序，输出结果为：

  29

  如果要写入一些不是字符串的东西, 那么将需要先进行转换:

  #!/usr/bin/python3

  # 打开一个文件
  f = open("/tmp/foo1.txt", "w")

  value = ('www.runoob.com', 14)
  s = str(value)
  f.write(s)

  # 关闭打开的文件
  f.close()

  执行以上程序，打开 foo1.txt 文件：

  $ cat /tmp/foo1.txt
  ('www.runoob.com', 14)

  f.tell()

  f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

  f.seek()

  如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

  from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

• seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x,1) ： 表示从当前位置往后移动x个字符
• seek(-x,2)：表示从文件的结尾往前移动x个字符

  from_what 值为默认为0，即文件开头。下面给出一个完整的例子：

  >>> f = open('/tmp/foo.txt', 'rb+')
  >>> f.write(b'0123456789abcdef')
  16
  >>> f.seek(5) # 移动到文件的第六个字节
  5
  >>> f.read(1)
  b'5'
  >>> f.seek(-3, 2) # 移动到文件的倒数第三字节
  13
  >>> f.read(1)
  b'd'

  f.close()

  在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

  当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

  >>> f.close()
  >>> f.read()
  Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  ValueError: I/O operation on closed file
  <pre>
  <p>
  当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:</p>
  <pre>
  >>> with open('/tmp/foo.txt', 'r') as f:
  ... read_data = f.read()
  >>> f.closed
  True

  文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。

     

  pickle 模块

  python的pickle模块实现了基本的数据序列和反序列化。

  通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

  通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

  基本接口：

  pickle.dump(obj, file, [,protocol])

  有了 pickle 这个对象, 就能对 file 以读取的形式打开:

  x = pickle.load(file)

  注解：从 file 中读取一个字符串，并将它重构为原来的python对象。

  file: 类文件对象，有read()和readline()接口。

  实例1：

  #!/usr/bin/python3
  import pickle

  # 使用pickle模块将数据对象保存到文件
  data1 = {'a': [1, 2.0, 3, 4+6j],
  'b': ('string', u'Unicode string'),
  'c': None}

  selfref_list = [1, 2, 3]
  selfref_list.append(selfref_list)

  output = open('data.pkl', 'wb')

  # Pickle dictionary using protocol 0.
  pickle.dump(data1, output)

  # Pickle the list using the highest protocol available.
  pickle.dump(selfref_list, output, -1)

  output.close()

  实例2：

  #!/usr/bin/python3
  import pprint, pickle

  #使用pickle模块从文件中重构python对象
  pkl_file = open('data.pkl', 'rb')

  data1 = pickle.load(pkl_file)
  pprint.pprint(data1)

  data2 = pickle.load(pkl_file)
  pprint.pprint(data2)

  pkl_file.close()

   

   

Python3 File(文件) 方法

2017年4月13日

10:55

   

   

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

   

file 对象常用的函数

2017年4月13日

21:11

   

File close() 方法

2017年4月13日

21:11

   

概述

close() 方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作， 否则会触发 ValueError 错误。 close() 方法允许调用多次。

当 file 对象，被引用到操作另外一个文件时，Python 会自动关闭之前的 file 对象。 使用 close() 方法关闭文件是一个好的习惯。

语法

close() 方法语法如下：

fileObject.close();

参数

• 无

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 close() 方法的使用：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "wb")
  print("文件名为: ", fo.name)

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt

   

File flush() 方法

2017年4月13日

21:11

   

概述

flush() 方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。

一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。

语法

flush() 方法语法如下：

fileObject.flush();

参数

• 无

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 flush() 方法的使用：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "wb")
  print ("文件名为: ", fo.name)

  # 刷新缓冲区
  fo.flush()

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt

   

File fileno() 方法

2017年4月13日

21:11

   

概述

fileno() 方法返回一个整型的文件描述符(file descriptor FD 整型)，可用于底层操作系统的 I/O 操作。

语法

fileno() 方法语法如下：

fileObject.fileno();

参数

• 无

  返回值

  返回文件描述符。

  实例

  以下实例演示了 fileno() 方法的使用：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "wb")
  print ("文件名为: ", fo.name)

  fid = fo.fileno()
  print ("文件描述符为: ", fid)

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  文件描述符为: 3

   

File isatty() 方法

2017年4月13日

21:11

   

概述

isatty() 方法检测文件是否连接到一个终端设备，如果是返回 True，否则返回 False。

语法

isatty() 方法语法如下：

fileObject.isatty();

参数

• 无

  返回值

  如果连接到一个终端设备返回 True，否则返回 False。

  实例

  以下实例演示了 isatty() 方法的使用：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "wb")
  print ("文件名为: ", fo.name)

  ret = fo.isatty()
  print ("返回值 : ", ret)

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  返回值 : False

   

next() 方法

2017年4月13日

21:11

   

概述

Python 3 中的 File 对象不支持 next() 方法。 Python 3 的内置函数 next() 通过迭代器调用 __next__() 方法返回下一项。 在循环中，next()方法会在每次循环中调用，该方法返回文件的下一行，如果到达结尾(EOF),则触发 StopIteration

语法

next() 方法语法如下：

next(iterator[,default])

参数

• 无

  返回值

  返回文件下一行。

  实例

  以下实例演示了 next() 方法的使用：

  文件 runoob.txt 的内容如下：

  这是第一行
  这是第二行
  这是第三行
  这是第四行
  这是第五行

  循环读取文件的内容：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "r")
  print ("文件名为: ", fo.name)

  for index in range(5):
  line = next(fo)
  print ("第 %d 行 - %s" % (index, line))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  第 0 行 - 这是第一行

  第 1 行 - 这是第二行

  第 2 行 - 这是第三行

  第 3 行 - 这是第四行

  第 4 行 - 这是第五行

   

read() 方法

2017年4月13日

21:11

   

概述

read() 方法用于从文件读取指定的字节数，如果未给定或为负则读取所有。

语法

read() 方法语法如下：

fileObject.read();

参数

• size -- 从文件中读取的字节数。

  返回值

  返回从字符串中读取的字节。

  实例

  以下实例演示了 read() 方法的使用：

  文件 runoob.txt 的内容如下：

  这是第一行
  这是第二行
  这是第三行
  这是第四行
  这是第五行

  循环读取文件的内容：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "r+")
  print ("文件名为: ", fo.name)

  line = fo.read(10)
  print ("读取的字符串: %s" % (line))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  读取的字符串: 这是第一行
  这是第二

   

readline() 方法

2017年4月13日

21:11

   

概述

readline() 方法用于从文件读取整行，包括 "\n" 字符。如果指定了一个非负数的参数，则返回指定大小的字节数，包括 "\n" 字符。

语法

readline() 方法语法如下：

fileObject.readline();

参数

• size -- 从文件中读取的字节数。

  返回值

  返回从字符串中读取的字节。

  实例

  以下实例演示了 readline() 方法的使用：

  文件 runoob.txt 的内容如下：

  1:www.runoob.com
  2:www.runoob.com
  3:www.runoob.com
  4:www.runoob.com
  5:www.runoob.com

  循环读取文件的内容：

  #!/usr/bin/python
  # -*- coding: UTF-8 -*-

  # 打开文件
  fo = open("runoob.txt", "r+")
  print ("文件名为: ", fo.name)

  line = fo.readline()
  print ("读取第一行 %s" % (line))

  line = fo.readline(5)
  print ("读取的字符串为: %s" % (line))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  读取第一行 1:www.runoob.com

  读取的字符串为: 2:www

   

readlines() 方法

2017年4月13日

21:11

   

概述

readlines() 方法用于读取所有行(直到结束符 EOF)并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。

如果碰到结束符 EOF 则返回空字符串。

语法

readlines() 方法语法如下：

fileObject.readlines( sizehint );

参数

• sizehint -- 从文件中读取的字节数。

  返回值

  返回列表，包含所有的行。

  实例

  以下实例演示了 readline() 方法的使用：

  文件 runoob.txt 的内容如下：

  1:www.runoob.com
  2:www.runoob.com
  3:www.runoob.com
  4:www.runoob.com
  5:www.runoob.com

  循环读取文件的内容：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "r+")
  print ("文件名为: ", fo.name)

  line = fo.readlines()
  print ("读取的数据为: %s" % (line))

  line = fo.readlines(2)
  print ("读取的数据为: %s" % (line))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  读取的数据为: ['1:www.runoob.com\n', '2:www.runoob.com\n', '3:www.runoob.com\n', '4:www.runoob.com\n', '5:www.runoob.com\n']
  读取的数据为: []

   

seek() 方法

2017年4月13日

21:11

   

概述

seek() 方法用于移动文件读取指针到指定位置。

语法

seek() 方法语法如下：

fileObject.seek(offset[, whence])

参数

• offset -- 开始的偏移量，也就是代表需要移动偏移的字节数
• whence：可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

  返回值

  该函数没有返回值。

  实例

  以下实例演示了 readline() 方法的使用：

  文件 runoob.txt 的内容如下：

  1:www.runoob.com
  2:www.runoob.com
  3:www.runoob.com
  4:www.runoob.com
  5:www.runoob.com

  循环读取文件的内容：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "r+")
  print ("文件名为: ", fo.name)

  line = fo.readline()
  print ("读取的数据为: %s" % (line))

  # 重新设置文件读取指针到开头
  fo.seek(0, 0)
  line = fo.readline()
  print ("读取的数据为: %s" % (line))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  读取的数据为: 1:www.runoob.com

  读取的数据为: 1:www.runoob.com

   

tell() 方法

2017年4月13日

21:11

   

概述

tell() 方法返回文件的当前位置，即文件指针当前位置。

语法

tell() 方法语法如下：

fileObject.tell(offset[, whence])

参数

• 无

  返回值

  返回文件的当前位置。

  实例

  以下实例演示了 tell() 方法的使用：

  文件 runoob.txt 的内容如下：

  1:www.runoob.com
  2:www.runoob.com
  3:www.runoob.com
  4:www.runoob.com
  5:www.runoob.com

  循环读取文件的内容：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "r+")
  print ("文件名为: ", fo.name)

  line = fo.readline()
  print ("读取的数据为: %s" % (line))

  # 获取当前文件位置
  pos = fo.tell()
  print ("当前位置: %d" % (pos))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  读取的数据为: 1:www.runoob.com

  当前位置: 17

   

truncate() 方法

2017年4月13日

21:11

   

概述

truncate() 方法用于截断文件，如果指定了可选参数 size，则表示截断文件为 size 个字符。 如果没有指定 size，则重置到当前位置。

语法

truncate() 方法语法如下：

fileObject.truncate( [ size ])

参数

• size -- 可选，如果存在则文件截断为 size 字节。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 truncate() 方法的使用：

  文件 runoob.txt 的内容如下：

  1:www.runoob.com
  2:www.runoob.com
  3:www.runoob.com
  4:www.runoob.com
  5:www.runoob.com

  循环读取文件的内容：

  #!/usr/bin/python3

  fo = open("runoob.txt", "r+")
  print ("文件名: ", fo.name)

  line = fo.readline()
  print ("读取行: %s" % (line))

  fo.truncate()
  line = fo.readlines()
  print ("读取行: %s" % (line))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名: runoob.txt
  读取行: 1:www.runoob.com

  读取行: ['2:www.runoob.com\n', '3:www.runoob.com\n', '4:www.runoob.com\n', '5:www.runoob.com\n']

  以下实例截取 runoob.txt 文件的10个字节：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "r+")
  print ("文件名为: ", fo.name)

  # 截取10个字节
  fo.truncate(10)

  str = fo.read()
  print ("读取数据: %s" % (str))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: runoob.txt
  读取数据: 1:www.runo

   

write() 方法

2017年4月13日

21:11

   

概述

write() 方法用于向文件中写入指定字符串。

在文件关闭前或缓冲区刷新前，字符串内容存储在缓冲区中，这时你在文件中是看不到写入的内容的。

语法

write() 方法语法如下：

fileObject.write( [ str ])

参数

• str -- 要写入文件的字符串。

  返回值

  该方法没有返回值。

  实例

  文件 runoob.txt 的内容如下：

  1:www.runoob.com
  2:www.runoob.com
  3:www.runoob.com
  4:www.runoob.com
  5:www.runoob.com

  以下实例演示了 write() 方法的使用：

  #!/usr/bin/python3

  # 打开文件
  fo = open("runoob.txt", "r+")
  print ("文件名: ", fo.name)

  str = "6:www.runoob.com"
  # 在文件末尾写入一行
  fo.seek(0, 2)
  line = fo.write( str )

  # 读取文件所有内容
  fo.seek(0,0)
  for index in range(6):
  line = next(fo)
  print ("文件行号 %d - %s" % (index, line))

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件行号 0 - 1:www.runoob.com

  文件行号 1 - 2:www.runoob.com

  文件行号 2 - 3:www.runoob.com

  文件行号 3 - 4:www.runoob.com

  文件行号 4 - 5:www.runoob.com

  文件行号 5 - 6:www.runoob.com

  查看文件内容：

  $ cat runoob.txt
  1:www.runoob.com
  2:www.runoob.com
  3:www.runoob.com
  4:www.runoob.com
  5:www.runoob.com
  6:www.runoob.com

   

writelines() 方法

2017年4月13日

21:21

   

概述

writelines() 方法用于向文件中写入一序列的字符串。

这一序列字符串可以是由迭代对象产生的，如一个字符串列表。

换行需要制定换行符 \n。

语法

writelines() 方法语法如下：

fileObject.writelines( [ str ])

参数

• str -- 要写入文件的字符串序列。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 writelines() 方法的使用：

  #!/usr/bin/python3

  # 打开文件
  fo = open("test.txt", "w")
  print ("文件名为: ", fo.name)
  seq = ["菜鸟教程 1\n", "菜鸟教程 2"]
  fo.writelines( seq )

  # 关闭文件
  fo.close()

  以上实例输出结果为：

  文件名为: test.txt

  查看文件内容：

  $ cat test.txt
  菜鸟教程 1
  菜鸟教程 2

   

   

Python3 OS 文件/目录方法

2017年4月13日

10:55

   

   

os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

   

os.access() 方法

2017年4月13日

21:25

   

概述

os.access() 方法使用当前的uid/gid尝试访问路径。大部分操作使用有效的 uid/gid, 因此运行环境可以在 suid/sgid 环境尝试。

语法

access()方法语法格式如下：

os.access(path, mode);

参数

• path -- 要用来检测是否有访问权限的路径。
• mode -- mode为F_OK，测试存在的路径，或者它可以是包含R_OK, W_OK和X_OK或者R_OK, W_OK和X_OK其中之一或者更多。
• os.F_OK: 作为access()的mode参数，测试path是否存在。
• os.R_OK: 包含在access()的mode参数中 ， 测试path是否可读。
• os.W_OK 包含在access()的mode参数中 ， 测试path是否可写。
• os.X_OK 包含在access()的mode参数中 ，测试path是否可执行。

  返回值

  如果允许访问返回 True , 否则返回False。

  实例

  以下实例演示了 access() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 假定 /tmp/foo.txt 文件存在，并有读写权限

  ret = os.access("/tmp/foo.txt", os.F_OK)
  print ("F_OK - 返回值 %s"% ret)

  ret = os.access("/tmp/foo.txt", os.R_OK)
  print ("R_OK - 返回值 %s"% ret)

  ret = os.access("/tmp/foo.txt", os.W_OK)
  print ("W_OK - 返回值 %s"% ret)

  ret = os.access("/tmp/foo.txt", os.X_OK)
  print ("X_OK - 返回值 %s"% ret)

  执行以上程序输出结果为：

  F_OK - 返回值 True
  R_OK - 返回值 True
  W_OK - 返回值 True
  X_OK - 返回值 False

   

os.chdir() 方法

2017年4月13日

21:25

   

概述

os.chdir() 方法用于改变当前工作目录到指定的路径。

语法

chdir()方法语法格式如下：

os.chdir(path)

参数

• path -- 要切换到的新路径。

  返回值

  如果允许访问返回 True , 否则返回False。

  实例

  以下实例演示了 chdir() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  path = "/tmp"

  # 查看当前工作目录
  retval = os.getcwd()
  print ("当前工作目录为 %s" % retval)

  # 修改当前工作目录
  os.chdir( path )

  # 查看修改后的工作目录
  retval = os.getcwd()

  print ("目录修改成功 %s" % retval)

  执行以上程序输出结果为：

  当前工作目录为 /www
  目录修改成功 /tmp

   

os.chflags() 方法

2017年4月13日

21:25

   

概述

os.chflags() 方法用于设置路径的标记为数字标记。多个标记可以使用 OR 来组合起来。

只支持在 Unix 下使用。

语法

chflags()方法语法格式如下：

os.chflags(path, flags)

参数

• path -- 文件名路径或目录路径。
• flags -- 可以是以下值：
• stat.UF_NODUMP: 非转储文件
• stat.UF_IMMUTABLE: 文件是只读的
• stat.UF_APPEND: 文件只能追加内容
• stat.UF_NOUNLINK: 文件不可删除
• stat.UF_OPAQUE: 目录不透明，需要通过联合堆栈查看
• stat.SF_ARCHIVED: 可存档文件(超级用户可设)
• stat.SF_IMMUTABLE: 文件是只读的(超级用户可设)
• stat.SF_APPEND: 文件只能追加内容(超级用户可设)
• stat.SF_NOUNLINK: 文件不可删除(超级用户可设)
• stat.SF_SNAPSHOT: 快照文件(超级用户可设)

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 chflags() 方法的使用：

  #!/usr/bin/python3

  import os,stat

  path = "/tmp/foo.txt"

  # 为文件设置标记，使得它不能被重命名和删除
  flags = stat.SF_NOUNLINK
  retval = os.chflags( path, flags )
  print ("返回值: %s" % retval)

  执行以上程序输出结果为：

  返回值: None

   

os.chmod() 方法

2017年4月13日

21:25

   

概述

os.chmod() 方法用于更改文件或目录的权限。

语法

chmod()方法语法格式如下：

os.chmod(path, mode)

参数

• path -- 文件名路径或目录路径。
• flags -- 可用以下选项按位或操作生成， 目录的读权限表示可以获取目录里文件名列表， ，执行权限表示可以把工作目录切换到此目录 ，删除添加目录里的文件必须同时有写和执行权限 ，文件权限以用户id->组id->其它顺序检验,最先匹配的允许或禁止权限被应用。
• stat.S_IXOTH: 其他用户有执行权0o001
• stat.S_IWOTH: 其他用户有写权限0o002
• stat.S_IROTH: 其他用户有读权限0o004
• stat.S_IRWXO: 其他用户有全部权限(权限掩码)0o007
• stat.S_IXGRP: 组用户有执行权限0o010
• stat.S_IWGRP: 组用户有写权限0o020
• stat.S_IRGRP: 组用户有读权限0o040
• stat.S_IRWXG: 组用户有全部权限(权限掩码)0o070
• stat.S_IXUSR: 拥有者具有执行权限0o100
• stat.S_IWUSR: 拥有者具有写权限0o200
• stat.S_IRUSR: 拥有者具有读权限0o400
• stat.S_IRWXU: 拥有者有全部权限(权限掩码)0o700
• stat.S_ISVTX: 目录里文件目录只有拥有者才可删除更改0o1000
• stat.S_ISGID: 执行此文件其进程有效组为文件所在组0o2000
• stat.S_ISUID: 执行此文件其进程有效用户为文件所有者0o4000
• stat.S_IREAD: windows下设为只读
• stat.S_IWRITE: windows下取消只读

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 chmod() 方法的使用：

  #!/usr/bin/python3

  import os, sys, stat

  # 假定 /tmp/foo.txt 文件存在，设置文件可以通过用户组执行

  os.chmod("/tmp/foo.txt", stat.S_IXGRP)

  # 设置文件可以被其他用户写入
  os.chmod("/tmp/foo.txt", stat.S_IWOTH)

  print ("修改成功!!")

  执行以上程序输出结果为：

  修改成功!!

   

os.chown() 方法

2017年4月13日

21:25

   

概述

os.chown() 方法用于更改文件所有者，如果不修改可以设置为 -1, 你需要超级用户权限来执行权限修改操作。

只支持在 Unix 下使用。

语法

chown()方法语法格式如下：

os.chown(path, uid, gid);

参数

• path -- 设置权限的文件路径
• uid -- 所属用户 ID
• gid -- 所属用户组 ID

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 lchmod() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 假定 /tmp/foo.txt 文件存在.
  # 设置所有者 ID 为 100
  os.chown("/tmp/foo.txt", 100, -1)

  print ("修改权限成功!!")

  执行以上程序输出结果为：

  修改权限成功!!

   

os.chroot() 方法

2017年4月13日

21:25

   

概述

os.chroot() 方法用于更改当前进程的根目录为指定的目录，使用该函数需要管理员权限。

语法

chroot()方法语法格式如下：

os.chroot(path);

参数

• path -- 要设置为根目录的目录。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 chroot() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 设置根目录为 /tmp

  os.chroot("/tmp")

  print ("修改根目录成功!!")

  执行以上程序输出结果为：

  修改根目录成功!!

   

os.close() 方法

2017年4月13日

21:25

   

概述

os.close() 方法用于关闭指定的文件描述符 fd。

语法

close()方法语法格式如下：

os.close(fd);

参数

• fd -- 文件描述符。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 close() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test")

  # 关闭文件
  os.close( fd )

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  关闭文件成功!!

   

os.closerange() 方法

2017年4月13日

21:25

   

概述

os.closerange() 方法用于关闭所有文件描述符 fd，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略。

语法

closerange()方法语法格式如下：

os.closerange(fd_low, fd_high);

参数

• fd_low -- 最小文件描述符
• fd_high -- 最大文件描述符

  该方法类似于：

  for fd in xrange(fd_low, fd_high):
  try:
  os.close(fd)
  except OSError:
  pass

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 closerange() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test")

  # 关闭文件
  os.closerange( fd, fd)

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  关闭文件成功!!

   

os.dup() 方法

2017年4月13日

21:25

   

概述

os.dup() 方法用于复制文件描述符 fd。

语法

dup()方法语法格式如下：

os.dup(fd);

参数

• fd -- 文件描述符

  返回值

  返回复制的文件描述符。

  实例

  以下实例演示了 dup() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 复制文件描述符
  d_fd = os.dup( fd )

  # 使用复制的文件描述符写入文件
  os.write(d_fd, "This is test")

  # 关闭文件
  os.closerange( fd, d_fd)

  print ("关闭所有文件成功!!")

  执行以上程序输出结果为：

  关闭所有文件成功!!

   

os.dup2() 方法

2017年4月13日

21:25

   

概述

os.dup2() 方法用于将一个文件描述符 fd 复制到另一个 fd2。

Unix, Windows 上可用。

语法

dup2()方法语法格式如下：

os.dup2(fd, fd2);

参数

• fd -- 要被复制的文件描述符
• fd2 -- 复制的文件描述符

  返回值

  没有返回值。

  实例

  以下实例演示了 dup2() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test")

  # 文件描述符为 1000
  fd2 = 1000
  os.dup2(fd, fd2);

  # 在新的文件描述符上插入数据
  os.lseek(fd2, 0, 0)
  str = os.read(fd2, 100)
  print ("读取的字符串是 : ", str)

  # 关闭文件
  os.close( fd )

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  读取的字符串是 : This is test
  关闭文件成功!!

   

os.fchdir() 方法

2017年4月13日

21:25

   

概述

os.fchdir() 方法通过文件描述符改变当前工作目录。

Unix, Windows 上可用。

语法

fchdir()方法语法格式如下：

os.fchdir(fd);

参数

• fd -- 文件描述符

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 fchdir() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 首先到目录 "/var/www/html"
  os.chdir("/var/www/html" )

  # 输出当前目录
  print ("当前工作目录为 : %s" % os.getcwd())

  # 打开新目录 "/tmp"
  fd = os.open( "/tmp", os.O_RDONLY )

  # 使用 os.fchdir() 方法修改到新目录
  os.fchdir(fd)

  # 输出当前目录
  print ("当前工作目录为 : %s" % os.getcwd())

  # 关闭打开的目录
  os.close( fd )

  执行以上程序输出结果为：

  当前工作目录为 : /var/www/html
  当前工作目录为 : /tmp

   

os.fchmod() 方法

2017年4月13日

21:25

   

概述

os.fchmod() 方法用于改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。

Unix上可用。

语法

fchmod()方法语法格式如下：

os.fchmod(fd, mode);

参数

• fd -- 文件描述符
• mode -- 可以是以下一个或多个组成，多个使用 "|" 隔开：
• stat.S_ISUID:设置 UID 位
• stat.S_ISGID: 设置组 ID 位
• stat.S_ENFMT: 系统文件锁定的执法行动
• stat.S_ISVTX: 在执行之后保存文字和图片
• stat.S_IREAD: 对于拥有者读的权限
• stat.S_IWRITE: 对于拥有者写的权限
• stat.S_IEXEC: 对于拥有者执行的权限
• stat.S_IRWXU:对于拥有者读、写、执行的权限
• stat.S_IRUSR: 对于拥有者读的权限
• stat.S_IWUSR: 对于拥有者写的权限
• stat.S_IXUSR: 对于拥有者执行的权限
• stat.S_IRWXG: 对于同组的人读写执行的权限
• stat.S_IRGRP: 对于同组读的权限
• stat.S_IWGRP:对于同组写的权限
• stat.S_IXGRP: 对于同组执行的权限
• stat.S_IRWXO: 对于其他组读写执行的权限
• stat.S_IROTH: 对于其他组读的权限
• stat.S_IWOTH: 对于其他组写的权限
• stat.S_IXOTH:对于其他组执行的权限

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 fchmod() 方法的使用：

  #!/usr/bin/python3

  import os, sys, stat

  # 打开文件 "/tmp/foo.txt"
  fd = os.open( "/tmp", os.O_RDONLY )

  # 设置文件可通过组执行

  os.fchmod( fd, stat.S_IXGRP)

  # 设置文件可被其他用户写入
  os.fchmod(fd, stat.S_IWOTH)

  print ("修改权限成功!!")

  # 关闭文件
  os.close( fd )

  执行以上程序输出结果为：

  修改权限成功!!

   

os.fchown() 方法

2017年4月13日

21:25

   

概述

os.fchown() 方法用于修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。

Unix上可用。

语法

fchown()方法语法格式如下：

os.fchown(fd, uid, gid)

参数

• fd -- 文件描述符
• uid -- 文件所有者的用户id
• gid -- 文件所有者的用户组id

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 fchown() 方法的使用：

  #!/usr/bin/python3

  import os, sys, stat

  # 打开文件 "/tmp/foo.txt"
  fd = os.open( "/tmp", os.O_RDONLY )

  # 设置文件的用户 id 为 100
  os.fchown( fd, 100, -1)

  # 设置文件的用户组 id 为 100
  os.fchown( fd, -1, 50)

  print ("修改权限成功!!")

  # 关闭文件
  os.close( fd )

  执行以上程序输出结果为：

  修改权限成功!!

   

os.fdatasync() 方法

2017年4月13日

21:25

   

概述

os.fdatasync() 方法用于强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。如果你需要刷新缓冲区可以使用该方法。

Unix上可用。

语法

fdatasync()方法语法格式如下：

os.fdatasync(fd);

参数

• fd -- 文件描述符

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 fdatasync() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件 "/tmp/foo.txt"
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test")

  # 使用 fdatasync() 方法
  os.fdatasync(fd)

  # 读取文件
  os.lseek(fd, 0, 0)
  str = os.read(fd, 100)
  print ("读取的字符是 : ", str)

  # 关闭文件
  os.close( fd )

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  读取的字符是 : This is test
  关闭文件成功!!

   

os.fdopen() 方法

2017年4月13日

21:25

   

概述

os.fdopen() 方法用于通过文件描述符 fd 创建一个文件对象，并返回这个文件对象。

Unix, Windows上可用。

语法

fdopen()方法语法格式如下：

os.fdopen(fd, [, mode[, bufsize]]);

参数

• fd -- 打开的文件的描述符，在Unix下，描述符是一个小整数。
• mode -- 可选，和buffersize参数和Python内建的open函数一样，mode参数可以指定『r,w,a,r+,w+,a+,b』等，表示文件的是只读的还是可以读写的，以及打开文件是以二进制还是文本形式打开。这些参数和C语言中的<stdio.h>中fopen函数中指定的mode参数类似。
• bufsize -- 可选，指定返回的文件对象是否带缓冲：buffersize=0，表示没有带缓冲；bufsize=1，表示该文件对象是行缓冲的；bufsize=正数，表示使用一个指定大小的缓冲冲，单位为byte，但是这个大小不是精确的；bufsize=负数，表示使用一个系统默认大小的缓冲，对于tty字元设备一般是行缓冲，而对于其他文件则一般是全缓冲。如果这个参数没有制定，则使用系统默认的缓冲设定。

  返回值

  通过文件描述符返回的文件对象。

  实例

  以下实例演示了 fdopen() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 获取以上文件的对象
  fo = os.fdopen(fd, "w+")

  # 获取当前文章
  print ("Current I/O pointer position :%d" % fo.tell())

  # 写入字符串
  fo.write( "Python is a great language.\nYeah its great!!\n");

  # 读取内容
  os.lseek(fd, 0, 0)
  str = os.read(fd, 100)
  print ("Read String is : ", str)

  # 获取当前位置
  print ("Current I/O pointer position :%d" % fo.tell())

  # 关闭文件
  os.close( fd )

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  Current I/O pointer position :0
  Read String is : This is testPython is a great language.
  Yeah its great!!

  Current I/O pointer position :45
  关闭文件成功!!

   

os.fpathconf() 方法

2017年4月13日

21:25

   

概述

os.fpathconf() 方法用于返回一个打开的文件的系统配置信息。

Unix上可用。

语法

fpathconf()方法语法格式如下：

os.fpathconf(fd, name)

参数

• fd -- 打开的文件的描述符。
• name -- 可选，和buffersize参数和Python内建的open函数一样，mode参数可以指定『r,w,a,r+,w+,a+,b』等，表示文件的是只读的还是可以读写的，以及打开文件是以二进制还是文本形式打开。这些参数和C语言中的<stdio.h>中fopen函数中指定的mode参数类似。
• bufsize -- 检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。一些平台也定义了一些额外的名字。这些名字在主操作系统上pathconf_names的字典中。对于不在pathconf_names中的配置变量，传递一个数字作为名字，也是可以接受的。

  返回值

  返回一个打开的文件的系统配置信息。

  实例

  以下实例演示了 fpathconf() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  print ("%s" % os.pathconf_names)

  # 获取最大文件连接数
  no = os.fpathconf(fd, 'PC_LINK_MAX')
  print ("文件最大连接数为 :%d" % no)

  # 获取文件名最大长度
  no = os.fpathconf(fd, 'PC_NAME_MAX')
  print ("文件名最大长度为 :%d" % no)

  # 关闭文件
  os.close( fd )

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  {'PC_MAX_INPUT': 2, 'PC_VDISABLE': 8, 'PC_SYNC_IO': 9,
  'PC_SOCK_MAXBUF': 12, 'PC_NAME_MAX': 3, 'PC_MAX_CANON': 1,
  'PC_PRIO_IO': 11, 'PC_CHOWN_RESTRICTED': 6, 'PC_ASYNC_IO': 10,
  'PC_NO_TRUNC': 7, 'PC_FILESIZEBITS': 13, 'PC_LINK_MAX': 0,
  'PC_PIPE_BUF': 5, 'PC_PATH_MAX': 4}

  文件最大连接数为 :127
  文件名最大长度为 :255
  Closed the file successfully!!

   

os.fstat() 方法

2017年4月13日

21:25

   

概述

os.fstat() 方法用于返回文件描述符fd的状态，类似 stat()。

Unix，Windows上可用。

fstat 方法返回的结构:

• st_dev: 设备信息
• st_ino: 文件的i-node值
• st_mode: 文件信息的掩码，包含了文件的权限信息，文件的类型信息(是普通文件还是管道文件，或者是其他的文件类型)
• st_nlink: 硬连接数
• st_uid: 用户ID
• st_gid: 用户组 ID
• st_rdev: 设备 ID (如果指定文件)
• st_size: 文件大小，以byte为单位
• st_blksize: 系统 I/O 块大小
• st_blocks: 文件的是由多少个 512 byte 的块构成的
• st_atime: 文件最近的访问时间
• st_mtime: 文件最近的修改时间
• st_ctime: 文件状态信息的修改时间（不是文件内容的修改时间）

  语法

  fstat()方法语法格式如下：

  os.fstat(fd)

  参数

• fd -- 文件的描述符。

  返回值

  返回文件描述符fd的状态。

  实例

  以下实例演示了 fstat() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 获取元组
  info = os.fstat(fd)

  print ("文件信息 :", info)

  # 获取文件 uid
  print ("文件 UID :%d" % info.st_uid)

  # 获取文件 gid
  print ("文件 GID :%d" % info.st_gid)

  # 关闭文件
  os.close( fd)

  执行以上程序输出结果为：

  文件信息 : (33261, 3753776L, 103L, 1, 0, 0,
  102L, 1238783197, 1238786767, 1238786767)
  文件 UID :0
  文件 GID :0

   

os.fstatvfs() 方法

2017年4月13日

21:25

   

概述

os.fstatvfs() 方法用于返回包含文件描述符fd的文件的文件系统的信息，类似 statvfs()。

Unix上可用。

fstatvfs 方法返回的结构:

• f_bsize: 文件系统块大小
• f_frsize: 分栈大小
• f_blocks: 文件系统数据块总数
• f_bfree: 可用块数
• f_bavail:非超级用户可获取的块数
• f_files: 文件结点总数
• f_ffree: 可用文件结点数
• f_favail: 非超级用户的可用文件结点数
• f_fsid: 文件系统标识 ID
• f_flag: 挂载标记
• f_namemax: 最大文件长度

  语法

  fstatvfs()方法语法格式如下：

  os.fstatvfs(fd)

  参数

• fd -- 文件的描述符。

  返回值

  返回包含文件描述符fd的文件的文件系统的信息。

  实例

  以下实例演示了 fstatvfs() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 获取元组
  info = os.fstatvfs(fd)

  print ("文件信息 :", info)

  # 获取文件名最大长度
  print ("文件名最大长度 :%d" % info.f_namemax)

  # 获取可用块数
  print ("可用块数 :%d" % info.f_bfree)

  # 关闭文件
  os.close( fd)

  执行以上程序输出结果为：

  文件信息 : (4096, 4096, 2621440L, 1113266L, 1113266L,
  8929602L, 8764252L, 8764252L, 0, 255)
  文件名最大长度 :255
  可用块数 :1113266

   

os.fsync() 方法

2017年4月13日

21:25

   

概述

os.fsync() 方法强制将文件描述符为fd的文件写入硬盘。在Unix, 将调用fsync()函数;在Windows, 调用 _commit()函数。

如果你准备操作一个Python文件对象f, 首先f.flush(),然后os.fsync(f.fileno()), 确保与f相关的所有内存都写入了硬盘.在unix，Windows中有效。

Unix、Windows上可用。

语法

fsync()方法语法格式如下：

os.fsync(fd)

参数

• fd -- 文件的描述符。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 fsync() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test")

  # 使用 fsync() 方法.
  os.fsync(fd)

  # 读取内容
  os.lseek(fd, 0, 0)
  str = os.read(fd, 100)
  print ("读取的字符串为 : ", str)

  # 关闭文件
  os.close( fd)

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  读取的字符串为 : This is test
  关闭文件成功!!

   

os.ftruncate() 方法

2017年4月13日

21:25

   

概述

os.ftruncate() 裁剪文件描述符fd对应的文件, 它最大不能超过文件大小。

Unix上可用。

语法

ftruncate()方法语法格式如下：

os.ftruncate(fd, length)¶

参数

• fd -- 文件的描述符。
• length -- 要裁剪文件大小。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 ftruncate() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test - This is test")

  # 使用 ftruncate() 方法
  os.ftruncate(fd, 10)

  # 读取内容
  os.lseek(fd, 0, 0)
  str = os.read(fd, 100)
  print ("读取的字符串是 : ", str)

  # 关闭文件
  os.close( fd)

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  读取的字符串是 : This is te
  关闭文件成功!!

   

os.getcwd() 方法

2017年4月13日

21:25

   

概述

os.getcwd() 方法用于返回当前工作目录。

语法

getcwd()方法语法格式如下：

os.getcwd()

参数

• 无

  返回值

  返回当前进程的工作目录。

  实例

  以下实例演示了 getcwd() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 切换到 "/var/www/html" 目录
  os.chdir("/var/www/html" )

  # 打印当前目录
  print ("当前工作目录 : %s" % os.getcwd())

  # 打开 "/tmp"
  fd = os.open( "/tmp", os.O_RDONLY )

  # 使用 os.fchdir() 方法修改目录
  os.fchdir(fd)

  # 打印当前目录
  print ("当前工作目录 : %s" % os.getcwd())

  # 关闭文件
  os.close( fd )

  执行以上程序输出结果为：

  当前工作目录 : /var/www/html
  当前工作目录 : /tmp

   

os.getcwdu() 方法

2017年4月13日

21:25

   

概述

os.getcwdu() 方法用于返回一个当前工作目录的Unicode对象。

Unix, Windows 系统下可用。

语法

getcwdu()方法语法格式如下：

os.getcwdu()

参数

• 无

  返回值

  返回一个当前工作目录的Unicode对象。

  实例

  以下实例演示了 getcwdu() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 切换到 "/var/www/html" 目录
  os.chdir("/var/www/html" )

  # 打印当前目录
  print ("当前工作目录 : %s" % os.getcwdu())

  # 打开 "/tmp"
  fd = os.open( "/tmp", os.O_RDONLY )

  # 使用 os.fchdir() 方法修改目录
  os.fchdir(fd)

  # 打印当前目录
  print ("当前工作目录 : %s" % os.getcwdu())

  # 关闭文件
  os.close( fd )

  执行以上程序输出结果为：

  当前工作目录 : /var/www/html
  当前工作目录 : /tmp

   

os.isatty() 方法

2017年4月13日

21:25

   

概述

os.isatty() 方法用于判断如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。

语法

isatty()方法语法格式如下：

os.isatty()

参数

• 无

  返回值

  如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。

  实例

  以下实例演示了 isatty() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  str = "This is runoob.com site"
  os.write(fd,bytes(str, 'UTF-8'))

  # 使用 isatty() 查看文件
  ret = os.isatty(fd)

  print ("返回值: ", ret)

  # 关闭文件
  os.close( fd )

  执行以上程序输出结果为：

  返回值: False

   

os.lchflags() 方法

2017年4月13日

21:25

   

概述

os.lchflags() 方法用于设置路径的标记为数字标记，类似 chflags()，但是没有软链接。

只支持在 Unix 下使用。

语法

lchflags()方法语法格式如下：

os.lchflags(path, flags)

参数

• path -- 设置标记的文件路径
• flags -- 可以由一个或多个标记组合，多个使用"|"隔开：
• UF_NODUMP: 非转储文件
• UF_IMMUTABLE: 文件是只读的
• UF_APPEND: 文件只能追加内容
• UF_NOUNLINK: 文件不可删除
• UF_OPAQUE: 目录不透明，需要通过联合堆栈查看
• SF_ARCHIVED: 可存档文件(超级用户可设)
• SF_IMMUTABLE: 文件是只读的(超级用户可设)
• SF_APPEND: 文件只能追加内容(超级用户可设)
• SF_NOUNLINK: 文件不可删除(超级用户可设)
• SF_SNAPSHOT: 快照文件(超级用户可设)

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 lchflags() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  path = "/var/www/html/foo.txt"
  fd = os.open( path, os.O_RDWR|os.O_CREAT )

  # 关闭文件
  os.close( fd )

  # 修改文件标记
  ret = os.lchflags(path, os.UF_IMMUTABLE )

  print ("修改文件标记成功!!")

  执行以上程序输出结果为：

  修改文件标记成功!!

   

os.lchmod() 方法

2017年4月13日

21:25

   

概述

os.lchmod() 方法用于修改连接文件权限。

只支持在 Unix 下使用。

语法

lchmod()方法语法格式如下：

os.lchmod(path, mode)

参数

• path -- 设置标记的文件路径
• mode -- 可以是以下一个或多个组成，多个使用 "|" 隔开：
• stat.S_ISUID:设置 UID 位
• stat.S_ISGID: 设置组 ID 位
• stat.S_ENFMT: 系统文件锁定的执法行动
• stat.S_ISVTX: 在执行之后保存文字和图片
• stat.S_IREAD: 对于拥有者读的权限
• stat.S_IWRITE: 对于拥有者写的权限
• stat.S_IEXEC: 对于拥有者执行的权限
• stat.S_IRWXU:对于拥有者读、写、执行的权限
• stat.S_IRUSR: 对于拥有者读的权限
• stat.S_IWUSR: 对于拥有者写的权限
• stat.S_IXUSR: 对于拥有者执行的权限
• stat.S_IRWXG: 对于同组的人读写执行的权限
• stat.S_IRGRP: 对于同组读的权限
• stat.S_IWGRP:对于同组写的权限
• stat.S_IXGRP: 对于同组执行的权限
• stat.S_IRWXO: 对于其他组读写执行的权限
• stat.S_IROTH: 对于其他组读的权限
• stat.S_IWOTH: 对于其他组写的权限
• stat.S_IXOTH:对于其他组执行的权限

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 lchmod() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  path = "/var/www/html/foo.txt"
  fd = os.open( path, os.O_RDWR|os.O_CREAT )

  # 关闭文件
  os.close( fd )

  # 修改文件权限
  # 设置文件可以通过组执行
  os.lchmod( path, stat.S_IXGRP)

  # 设置文件可以被其他用户写入
  os.lchmod("/tmp/foo.txt", stat.S_IWOTH)

  print ("修改权限成功!!")

  执行以上程序输出结果为：

  修改权限成功!!

   

os.lchown() 方法

2017年4月13日

21:25

   

概述

os.lchown() 方法用于更改文件所有者，类似 chown，但是不追踪链接。

只支持在 Unix 下使用。

语法

lchown()方法语法格式如下：

os.lchown(path, uid, gid)

参数

• path -- 设置权限的文件路径
• uid -- 所属用户 ID
• gid -- 所属用户组 ID

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 lchown() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  path = "/var/www/html/foo.txt"
  fd = os.open( path, os.O_RDWR|os.O_CREAT )

  # 关闭打开的文件
  os.close( fd )

  # 修改文件权限
  # 设置文件所属用户 ID
  os.lchown( path, 500, -1)

  # 设置文件所属用户组 ID
  os.lchown( path, -1, 500)

  print ("修改权限成功!!")

  执行以上程序输出结果为：

  修改权限成功!!

   

os.link() 方法

2017年4月13日

21:25

   

概述

os.link() 方法用于创建硬链接，名为参数 dst，指向参数 src。

该方法对于创建一个已存在文件的拷贝是非常有用的。

只支持在 Unix, Windows 下使用。

语法

link()方法语法格式如下：

os.link(src, dst)

参数

• src -- 用于创建硬连接的源地址
• dst -- 用于创建硬连接的目标地址

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 link() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  path = "/var/www/html/foo.txt"
  fd = os.open( path, os.O_RDWR|os.O_CREAT )

  # 关闭文件
  os.close( fd )

  # 创建以上文件的拷贝
  dst = "/tmp/foo.txt"
  os.link( path, dst)

  print ("创建硬链接成功!!")

  执行以上程序输出结果为：

  创建硬链接成功!!

   

os.listdir() 方法

2017年4月13日

21:25

   

概述

os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表。这个列表以字母顺序。 它不包括 '.' 和'..' 即使它在文件夹中。

只支持在 Unix, Windows 下使用。

语法

listdir()方法语法格式如下：

os.listdir(path)

参数

• path -- 需要列出的目录路径

  返回值

  返回指定路径下的文件和文件夹列表。

  实例

  以下实例演示了 listdir() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  path = "/var/www/html/"
  dirs = os.listdir( path )

  # 输出所有文件和文件夹
  for file in dirs:
  print (file)

  执行以上程序输出结果为：

  test.htm
  stamp
  faq.htm
  _vti_txt
  robots.txt
  itemlisting
  resumelisting
  writing_effective_resume.htm
  advertisebusiness.htm
  papers
  resume

   

os.lseek() 方法

2017年4月13日

21:25

   

概述

os.lseek() 方法用于设置文件描述符 fd 当前位置为 pos, how 方式修改。

在Unix，Windows中有效。

语法

lseek()方法语法格式如下：

os.lseek(fd, pos, how)

参数

• fd -- 文件描述符。
• pos -- 这是相对于给定的参数 how 在文件中的位置。。
• how -- 文件内参考位置。SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 lseek() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test")

  # 所有 fsync() 方法
  os.fsync(fd)

  # 从开始位置读取字符串
  os.lseek(fd, 0, 0)
  str = os.read(fd, 100)
  print ("Read String is : ", str)

  # 关闭文件
  os.close( fd )

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  关闭文件成功!!

   

os.lstat() 方法

2017年4月13日

21:25

   

概述

os.lstat() 方法用于类似 stat() 返回文件的信息,但是没有符号链接。在某些平台上，这是fstat的别名，例如 Windows。

语法

lstat()方法语法格式如下：

os.lstat(path)

参数

• path -- 要返回信息的文件。

  返回值

  返回文件信息。

  实例

  以下实例演示了 lstat() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  path = "/var/www/html/foo.txt"
  fd = os.open( path, os.O_RDWR|os.O_CREAT )

  # 关闭打开的文件
  os.close( fd )

  # 获取元组
  info = os.lstat(path)

  print ("文件信息 :", info)

  # 获取文件 uid
  print ("文件 UID :%d" % info.st_uid)

  # 获取文件 gid
  print ("文件 GID :%d" % info.st_gid)

  执行以上程序输出结果为：

  文件信息 : (33261, 3450178L, 103L, 1, 500, 500, 0L,
  1238866944, 1238866944, 1238948312)
  文件 UID :500
  文件 GID :500

   

os.major() 方法

2017年4月13日

21:25

   

概述

os.major() 方法用于从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。

语法

major()方法语法格式如下：

os.major(device)

参数

• device -- 原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。

  返回值

  返回设备major号码。

  实例

  以下实例演示了 major() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  path = "/var/www/html/foo.txt"

  # 获取元组
  info = os.lstat(path)

  # 获取 major 和 minor 设备号
  major_dnum = os.major(info.st_dev)
  minor_dnum = os.minor(info.st_dev)

  print ("Major 设备号 :", major_dnum)
  print ("Minor 设备号 :", minor_dnum)

  执行以上程序输出结果为：

  Major 设备号 : 0
  Minor 设备号 : 103

   

os.makedev() 方法

2017年4月13日

21:25

   

概述

os.makedev() 方法用于以major和minor设备号组成一个原始设备号。

语法

makedev()方法语法格式如下：

os.makedev(major, minor)

参数

• major -- Major 设备号。
• minor -- inor 设备号。

  返回值

  返回设备号。

  实例

  以下实例演示了 makedev() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  path = "/var/www/html/foo.txt"

  # 获取元组
  info = os.lstat(path)

  # 获取 major 和 minor 设备号
  major_dnum = os.major(info.st_dev)
  minor_dnum = os.minor(info.st_dev)

  print ("Major 设备号 :", major_dnum)
  print ("Minor 设备号 :", minor_dnum)

  # 生成设备号
  dev_num = os.makedev(major_dnum, minor_dnum)
  print ("设备号 :", dev_num)

  执行以上程序输出结果为：

  Major 设备号 : 0
  Minor 设备号 : 103
  设备号 : 103

   

os.makedirs() 方法

2017年4月13日

21:25

   

概述

os.makedirs() 方法用于递归创建目录。像 mkdir(), 但创建的所有intermediate-level文件夹需要包含子目录。

语法

makedirs()方法语法格式如下：

os.makedirs(path, mode=0o777)

参数

• path -- 需要递归创建的目录。
• mode -- 权限模式。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 makedirs() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 创建的目录
  path = "/tmp/home/monthly/daily"

  os.makedirs( path, 0755 );

  print ("路径被创建")

  执行以上程序输出结果为：

  路径被创建

   

os.minor() 方法

2017年4月13日

21:25

   

概述

os.minor() 方法用于从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。

语法

minor()方法语法格式如下：

os.minor(device)

参数

• device -- 原始的设备(使用stat中的st_dev或者st_rdev field )

  返回值

  返回设备 minor 号。

  实例

  以下实例演示了 minor() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  path = "/var/www/html/foo.txt"

  # 获取元组
  info = os.lstat(path)

  # 获取 major 和 minor 设备号
  major_dnum = os.major(info.st_dev)
  minor_dnum = os.minor(info.st_dev)

  print ("Major 设备号 :", major_dnum)
  print ("Minor 设备号 :", minor_dnum)

  执行以上程序输出结果为：

  Major 设备号 : 0
  Minor 设备号 : 103

   

os.mkdir() 方法

2017年4月13日

21:25

   

概述

os.mkdir() 方法用于以数字权限模式创建目录。默认的模式为 0777 (八进制)。

语法

mkdir()方法语法格式如下：

os.mkdir(path[, mode])

参数

• path -- 要创建的目录
• mode -- 要为目录设置的权限数字模式

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 mkdir() 方法的使用：

  #!/usr/bin/python
  # -*- coding: UTF-8 -*-

  import os, sys

  # 创建的目录
  path = "/tmp/home/monthly/daily/hourly"

  os.mkdir( path, 0755 )

  print ("目录已创建")

  执行以上程序输出结果为：

  目录已创建

   

os.mkfifo() 方法

2017年4月13日

21:25

   

概述

os.mkfifo() 方法用于创建指令路径的管道，并设置权限模式。默认的模式为 0666 (八进制)。

语法

mkfifo()方法语法格式如下：

os.mkfifo(path[, mode])

参数

• path -- 要创建的目录
• mode -- 要为目录设置的权限数字模式

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 mkfifo() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 创建的目录
  path = "/tmp/hourly"

  os.mkfifo( path, 0644 )

  print ("路径被创建")

  执行以上程序输出结果为：

  路径被创建

   

os.mknod() 方法

2017年4月13日

21:25

   

概述

os.mknod() 方法用于创建一个指定文件名的文件系统节点（文件，设备特别文件或者命名pipe）。

语法

mknod()方法语法格式如下：

os.mknod(filename[, mode=0600[, device=0]])

参数

• filename -- 创建的文件系统节点
• mode -- mode指定创建或使用节点的权限, 组合 (或者bitwise) stat.S_IFREG, stat.S_IFCHR, stat.S_IFBLK, 和stat.S_IFIFO (这些常数在stat模块). 对于 stat.S_IFCHR和stat.S_IFBLK, 设备定义了 最新创建的设备特殊文件 (可能使用 os.makedev()),其它都将忽略。
• device -- 可选，指定创建文件的设备

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 mknod() 方法的使用：

  #!/usr/bin/python3

  import os
  import stat

  filename = '/tmp/tmpfile'
  mode = 0600|stat.S_IRUSR

  # 文件系统节点指定不同模式
  os.mknod(filename, mode)

  执行以上程序输出结果为：

  -rw-------. 1 root root 0 Apr 30 02:38 tmpfile

   

os.open() 方法

2017年4月13日

21:25

   

概述

os.open() 方法用于打开一个文件，并且设置需要的打开选项，模式参数mode参数是可选的，默认为 0777。

语法

open()方法语法格式如下：

os.open(file, flags[, mode]);

参数

• file -- 要打开的文件
• flags -- 该参数可以是以下选项，多个使用 "|" 隔开：
• os.O_RDONLY: 以只读的方式打开
• os.O_WRONLY: 以只写的方式打开
• os.O_RDWR : 以读写的方式打开
• os.O_NONBLOCK: 打开时不阻塞
• os.O_APPEND: 以追加的方式打开
• os.O_CREAT: 创建并打开一个新文件
• os.O_TRUNC: 打开一个文件并截断它的长度为零（必须有写权限）
• os.O_EXCL: 如果指定的文件存在，返回错误
• os.O_SHLOCK: 自动获取共享锁
• os.O_EXLOCK: 自动获取独立锁
• os.O_DIRECT: 消除或减少缓存效果
• os.O_FSYNC : 同步写入
• os.O_NOFOLLOW: 不追踪软链接
• mode -- 类似 chmod()。

  返回值

  返回新打开文件的描述符。

  实例

  以下实例演示了 open() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  # 写入字符串
  os.write(fd, "This is test")

  # 关闭文件
  os.close( fd )

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  关闭文件成功!!

   

os.openpty() 方法

2017年4月13日

21:25

   

概述

os.openpty() 方法用于打开一个新的伪终端对。返回 pty 和 tty的文件描述符。

语法

openpty()方法语法格式如下：

os.openpty()

参数

• 无

  返回值

  返回文件描述符对，主从。

  实例

  以下实例演示了 openpty() 方法的使用：

  #!/usr/bin/python3

  import os

  # 主 pty, 从 tty
  m,s = os.openpty()

  print (m)
  print (s)

  # 显示终端名
  s = os.ttyname(s)
  print (m)
  print (s)

  执行以上程序输出结果为：

  3
  4
  3
  /dev/pty0

   

os.pathconf() 方法

2017年4月13日

21:25

   

概述

os.pathconf() 方法用于返回一个打开的文件的系统配置信息。

Unix 平台下可用。

语法

fpathconf()方法语法格式如下：

os.fpathconf(fd, name)

参数

• name -- 文件描述符
• name -- 检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。一些平台也定义了一些额外的名字。这些名字在主操作系统上pathconf_names的字典中。对于不在pathconf_names中的配置变量，传递一个数字作为名字，也是可以接受的。

  返回值

  返回文件的系统信息。

  实例

  以下实例演示了 fpathconf() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT )

  print ("%s" % os.pathconf_names)

  # 获取文件最大连接数
  no = os.fpathconf(fd, 'PC_LINK_MAX')
  print ("Maximum number of links to the file. :%d" % no)

  # 获取文件名最大长度
  no = os.fpathconf(fd, 'PC_NAME_MAX')
  print ("Maximum length of a filename :%d" % no)

  # 关闭文件
  os.close( fd)

  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  关闭文件成功!!

   

os.pipe() 方法

2017年4月13日

21:25

   

概述

os.pipe() 方法用于创建一个管道, 返回一对文件描述符(r, w) 分别为读和写。

语法

pipe()方法语法格式如下：

os.pipe()

参数

• 无

  返回值

  返回文件描述符对。

  实例

  以下实例演示了 pipe() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  print ("The child will write text to a pipe and ")
  print ("the parent will read the text written by child...")

  # 文件描述符 r, w 用于读、写
  r, w = os.pipe()

  processid = os.fork()
  if processid:
  # 父进程
  # 关闭文件描述符 w
  os.close(w)
  r = os.fdopen(r)
  print ("Parent reading")
  str = r.read()
  print ("text =", str)
  sys.exit(0)
  else:
  # 子进程
  os.close(r)
  w = os.fdopen(w, 'w')
  print ("Child writing")
  w.write("Text written by child...")
  w.close()
  print ("Child closing")
  sys.exit(0)

  执行以上程序输出结果为：

  The child will write text to a pipe and
  the parent will read the text written by child...
  Parent reading
  Child writing
  Child closing
  text = Text written by child...

   

os.popen() 方法

2017年4月13日

21:25

   

概述

os.popen() 方法用于从一个命令打开一个管道。

在Unix，Windows中有效

语法

popen()方法语法格式如下：

os.popen(command[, mode[, bufsize]])

参数

• command -- 使用的命令。
• mode -- 模式权限可以是 'r'(默认) 或 'w'。
• bufsize -- 指明了文件需要的缓冲大小：0意味着无缓冲；1意味着行缓冲；其它正值表示使用参数大小的缓冲（大概值，以字节为单位）。负的bufsize意味着使用系统的默认值，一般来说，对于tty设备，它是行缓冲；对于其它文件，它是全缓冲。如果没有改参数，使用系统的默认值。

  返回值

  返回一个文件描述符号为fd的打开的文件对象

  实例

  以下实例演示了 popen() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 使用 mkdir 命令
  a = 'mkdir nwdir'

  b = os.popen(a,'r',1)

  print (b)

  执行以上程序输出结果为：

  open file 'mkdir nwdir', mode 'r' at 0x81614d0

   

os.read() 方法

2017年4月13日

21:25

   

概述

os.read() 方法用于从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。

在Unix，Windows中有效

语法

read()方法语法格式如下：

os.read(fd,n)

参数

• fd -- 文件描述符。
• n -- 读取的字节。

  返回值

  返回包含读取字节的字符串

  实例

  以下实例演示了 read() 方法的使用：

  #!/usr/bin/python3

  import os, sys
  # 打开文件
  fd = os.open("f1.txt",os.O_RDWR)
  
  # 读取文本
  ret = os.read(fd,12)
  print (ret)

  # 关闭文件
  os.close(fd)
  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  This is test
  关闭文件成功!!

   

os.readlink() 方法

2017年4月13日

21:25

   

概述

os.readlink() 方法用于返回软链接所指向的文件。可能返回绝对火相对路径。

在Unix中有效

语法

readlink()方法语法格式如下：

os.readlink(path)

参数

• path -- 要查找的软链接路径

  返回值

  返回软链接所指向的文件

  实例

  以下实例演示了 readlink() 方法的使用：

  #!/usr/bin/python3

  import os

  src = '/usr/bin/python'
  dst = '/tmp/python'

  # 创建软链接
  os.symlink(src, dst)

  # 使用软链接显示源链接
  path = os.readlink( dst )
  print (path)

  执行以上程序输出结果为：

  /usr/bin/python

   

os.remove() 方法

2017年4月13日

21:25

   

概述

os.remove() 方法用于删除指定路径的文件。如果指定的路径是一个目录，将抛出OSError。

在Unix, Windows中有效

语法

remove()方法语法格式如下：

os.remove(path)

参数

• path -- 要移除的文件路径

  返回值

  该方法没有返回值

  实例

  以下实例演示了 remove() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 列出目录
  print ("目录为: %s" %os.listdir(os.getcwd()))

  # 移除
  os.remove("aa.txt")

  # 移除后列出目录
  print ("移除后 : %s" %os.listdir(os.getcwd()))

  执行以上程序输出结果为：

  目录为:
  [ 'a1.txt','aa.txt','resume.doc' ]
  移除后 :
  [ 'a1.txt','resume.doc' ]

   

os.removedirs() 方法

2017年4月13日

21:25

   

概述

os.removedirs() 方法用于递归删除目录。像rmdir(), 如果子文件夹成功删除, removedirs()才尝试它们的父文件夹,直到抛出一个error(它基本上被忽略,因为它一般意味着你文件夹不为空)。

语法

removedirs()方法语法格式如下：

os.removedirs(path)

参数

• path -- 要移除的目录路径

  返回值

  该方法没有返回值

  实例

  以下实例演示了 removedirs() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 列出目录
  print ("目录为: %s" %os.listdir(os.getcwd()))

  # 移除
  os.removedirs("/test")

  # 列出移除后的目录
  print ("移除后目录为:" %os.listdir(os.getcwd()))

  执行以上程序输出结果为：

  目录为:
  [ 'a1.txt','resume.doc','a3.py','test' ]
  移除后目录为:
  [ 'a1.txt','resume.doc','a3.py' ]

   

os.rename() 方法

2017年4月13日

21:25

   

概述

os.rename() 方法用于命名文件或目录，从 src 到 dst,如果dst是一个存在的目录, 将抛出OSError。

语法

rename()方法语法格式如下：

os.rename(src, dst)

参数

• src -- 要修改的目录名
• dst -- 修改后的目录名

  返回值

  该方法没有返回值

  实例

  以下实例演示了 rename() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 列出目录
  print ("目录为: %s"%os.listdir(os.getcwd()))

  # 重命名
  os.rename("test","test2")

  print ("重命名成功。")

  # 列出重命名后的目录
  print ("目录为: %s" %os.listdir(os.getcwd()))

  执行以上程序输出结果为：

  目录为:
  [ 'a1.txt','resume.doc','a3.py','test' ]
  重命名成功。
  [ 'a1.txt','resume.doc','a3.py','test2' ]

   

os.renames() 方法

2017年4月13日

21:25

   

概述

os.renames() 方法用于递归重命名目录或文件。类似rename()。

语法

renames()方法语法格式如下：

os.renames(old, new)

参数

• old -- 要重命名的目录
• new --文件或目录的新名字。甚至可以是包含在目录中的文件，或者完整的目录树。

  返回值

  该方法没有返回值

  实例

  以下实例演示了 renames() 方法的使用：

  #!/usr/bin/python3

  import os, sys
  print ("当前目录为: %s" %os.getcwd())

  # 列出目录
  print ("目录为: %s"%os.listdir(os.getcwd()))

  # 重命名 "aa1.txt"
  os.renames("aa1.txt","newdir/aanew.txt")

  print ("重命名成功。")

  # 列出重命名的文件 "aa1.txt"
  print ("目录为: %s" %os.listdir(os.getcwd()))

  执行以上程序输出结果为：

  当前目录为: /tmp
  目录为:
  [ 'a1.txt','resume.doc','a3.py','aa1.txt','Administrator','amrood.admin' ]
  重命名成功。
  目录为:
  [ 'a1.txt','resume.doc','a3.py','Administrator','amrood.admin' ]

   

os.rmdir() 方法

2017年4月13日

21:25

   

概述

os.rmdir() 方法用于删除指定路径的目录。仅当这文件夹是空的才可以, 否则, 抛出OSError。

语法

rmdir()方法语法格式如下：

os.rmdir(path)

参数

• path -- 要删除的目录路径

  返回值

  该方法没有返回值

  实例

  以下实例演示了 rmdir() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 列出目录
  print ("目录为: %s"%os.listdir(os.getcwd()))

  # 删除路径
  os.rmdir("mydir")

  # 列出重命名后的目录
  print ("目录为: %s" %os.listdir(os.getcwd()))

  执行以上程序输出结果为：

  目录为:
  [ 'a1.txt','resume.doc','a3.py','mydir' ]
  目录为:
  [ 'a1.txt','resume.doc','a3.py' ]

   

os.stat() 方法

2017年4月13日

21:25

   

概述

os.stat() 方法用于在给定的路径上执行一个系统 stat 的调用。

语法

stat()方法语法格式如下：

os.stat(path)

参数

• path -- 指定路径

  返回值

  stat 结构:

• st_mode: inode 保护模式
• st_ino: inode 节点号。
• st_dev: inode 驻留的设备。
• st_nlink: inode 的链接数。
• st_uid: 所有者的用户ID。
• st_gid: 所有者的组ID。
• st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
• st_atime: 上次访问的时间。
• st_mtime: 最后一次修改的时间。
• st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

  实例

  以下实例演示了 stat() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 显示文件 "a2.py" 信息
  statinfo = os.stat('a2.py')

  print (statinfo)

  执行以上程序输出结果为：

  posix.stat_result(st_mode=33188, st_ino=3940649674337682L, st_dev=277923425L, st
  _nlink=1, st_uid=400, st_gid=401, st_size=335L, st_atime=1330498089, st_mtime=13
  30498089, st_ctime=1330498089)

   

os.stat_float_times() 方法

2017年4月13日

21:25

   

概述

os.stat_float_times() 方法用于决定stat_result是否以float对象显示时间戳。

语法

stat_float_times()方法语法格式如下：

os.stat_float_times([newvalue])

参数

• newvalue -- 如果为 True, 调用 stat() 返回 floats,如果 False, 调用 stat 返回 ints。如果没有该参数返回当前设置。

  返回值

  返回 True 或 False。

  实例

  以下实例演示了 stat_float_times() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # Stat 信息
  statinfo = os.stat('a2.py')

  print (statinfo)
  statinfo = os.stat_float_times()
  print (statinfo)

  执行以上程序输出结果为：

  posix.stat_result(st_mode=33188, st_ino=3940649674337682L, st_dev=277923425L,
  st_nlink=1, st_uid=400, st_gid=401, st_size=335L, st_atime=1330498089, st_mtime=13
  30498089, st_ctime=1330498089)
  True

   

os.statvfs() 方法

2017年4月13日

21:25

   

概述

os.statvfs() 方法用于返回包含文件描述符fd的文件的文件系统的信息。

语法

statvfs()方法语法格式如下：

os.statvfs([path])

参数

• path -- 文件路径。

  返回值

  返回的结构:

• f_bsize: 文件系统块大小
• f_frsize: 分栈大小
• f_blocks: 文件系统数据块总数
• f_bfree: 可用块数
• f_bavail:非超级用户可获取的块数
• f_files: 文件结点总数
• f_ffree: 可用文件结点数
• f_favail: 非超级用户的可用文件结点数
• f_fsid: 文件系统标识 ID
• f_flag: 挂载标记
• f_namemax: 最大文件长度

  实例

  以下实例演示了 statvfs() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 显示 "a1.py" 文件的 statvfs 信息
  stinfo = os.statvfs('a1.py')

  print (stinfo)

  执行以上程序输出结果为：

  posix.statvfs_result(f_bsize=4096, f_frsize=4096, f_blocks=1909350L, f_bfree=1491513L,
  f_bavail=1394521L, f_files=971520L, f_ffree=883302L, f_fvail=883302L, f_flag=0,
  f_namemax=255)

   

os.symlink() 方法

2017年4月13日

21:25

   

概述

os.symlink() 方法用于创建一个软链接。

语法

symlink()方法语法格式如下：

os.symlink(src, dst)

参数

• src -- 源地址。
• dst -- 目标地址。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 symlink() 方法的使用：

  #!/usr/bin/python3

  import os

  src = '/usr/bin/python'
  dst = '/tmp/python'

  # 创建软链接
  os.symlink(src, dst)

  print ("软链接创建成功")

  执行以上程序输出结果为：

  软链接创建成功

   

os.tcgetpgrp() 方法

2017年4月13日

21:25

   

概述

os.tcgetpgrp() 方法用于回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组。

语法

tcgetpgrp()方法语法格式如下：

os.tcgetpgrp(fd)

参数

• fd -- 文件描述符。

  返回值

  该方法返回进程组。

  实例

  以下实例演示了 tcgetpgrp() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 显示当前目录
  print ("当前目录 :%s" %os.getcwd())

  # 修改目录到 /dev/tty
  fd = os.open("/dev/tty",os.O_RDONLY)

  f = os.tcgetpgrp(fd)

  # 显示进程组
  print ("相关进程组: ")
  print (f)

  os.close(fd)
  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  当前目录 :/tmp
  相关进程组:
  2670
  关闭文件成功!!

   

os.tempnam() 方法

2017年4月13日

21:25

   

概述

os.tempnam() 方法用于返回唯一的路径名用于创建临时文件。

语法

tempnam()方法语法格式如下：

os.tempnam(dir, prefix)

参数

• dir -- 要创建的临时文件路径。
• prefix -- 临时文件前缀

  返回值

  该方法返回唯一路径。

  实例

  以下实例演示了 tempnam() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 前缀为 runoob 的文件
  tmpfn = os.tempnam('/tmp/runoob,'runoob')

  print ("这是一个唯一路径:")
  print (tmpfn)

  执行以上程序输出结果为：

  这是一个唯一路径:
  /tmp/runoob/runoobIbAco8

   

os.tmpfile() 方法

2017年4月13日

21:25

   

概述

os.tmpfile() 方法用于返回一个打开的模式为(w+b)的临时文件对象，这文件对象没有文件夹入口，没有文件描述符，将会自动删除。

语法

tmpfile()方法语法格式如下：

os.tmpfile

参数

• 无

  返回值

  返回一个临时文件对象。

  实例

  以下实例演示了 tmpfile() 方法的使用：

  #!/usr/bin/python3

  import os

  # 创建临时文件对象
  tmpfile = os.tmpfile()
  tmpfile.write('临时文件在这创建了.....')
  tmpfile.seek(0)

  print (tmpfile.read())
  tmpfile.close

  执行以上程序输出结果为：

  临时文件在这创建了.....

   

os.tmpnam() 方法

2017年4月13日

21:25

   

概述

os.tmpnam() 方法用于为创建一个临时文件返回一个唯一的路径。

语法

tmpnam()方法语法格式如下：

os.tmpnam

参数

• 无

  返回值

  返回一个唯一的路径。

  实例

  以下实例演示了 tmpnam() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 生成临时路径
  tmpfn = os.tmpnam()

  print ("这是一个唯一的路径:")
  print (tmpfn)

  执行以上程序输出结果为：

  这是一个唯一的路径:
  /tmp/fileUFojpd

   

os.ttyname() 方法

2017年4月13日

21:25

   

概述

os.ttyname() 方法用于返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。

语法

ttyname()方法语法格式如下：

os.ttyname(fd)

参数

• fd -- 文件描述符

  返回值

  返回一个字符串，它表示与文件描述符fd 关联的终端设备。

  实例

  以下实例演示了 ttyname() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 显示当前目录
  print ("当前目录 :%s" %os.getcwd())

  # 修改目录为 /dev/tty
  fd = os.open("/dev/tty",os.O_RDONLY)

  p = os.ttyname(fd)
  print ("关联的终端为: ")
  print (p)
  print ("done!!")

  os.close(fd)
  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  当前目录 :/tmp
  关联的终端为:
  /dev/tty
  done!!
  关闭文件成功!!

   

os.unlink() 方法

2017年4月13日

21:25

   

概述

os.unlink() 方法用于删除文件,如果文件是一个目录则返回一个错误。

语法

unlink()方法语法格式如下：

os.unlink(path)

参数

• path -- 删除的文件路径

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 unlink() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 列出目录
  print ("目录为: %s" %os.listdir(os.getcwd()))

  os.unlink("aa.txt")

  # 删除后的目录
  print ("删除后的目录为 : %s" %os.listdir(os.getcwd()))

  执行以上程序输出结果为：

  目录为:
  [ 'a1.txt','aa.txt','resume.doc']
  删除后的目录为 :
  [ 'a1.txt','resume.doc' ]

   

os.utime() 方法

2017年4月13日

21:25

   

概述

os.utime() 方法用于设置指定路径文件最后的修改和访问时间。

在Unix，Windows中有效。

语法

utime()方法语法格式如下：

os.utime(path, times)

参数

• path -- 文件路径
• times -- 如果时间是 None, 则文件的访问和修改设为当前时间 。 否则, 时间是一个 2-tuple数字, (atime, mtime) 用来分别作为访问和修改的时间。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 utime() 方法的使用：

  #!/usr/bin/python
  # -*- coding: UTF-8 -*-

  import os, sys

  # 显示文件的 stat 信息
  stinfo = os.stat('a2.py')
  print (stinfo)

  # 使用 os.stat 来接收文件的访问和修改时间
  print ("a2.py 的访问时间: %s" %stinfo.st_atime)
  print ("a2.py 的修改时间: %s" %stinfo.st_mtime)

  # 修改访问和修改时间
  os.utime("a2.py",(1330712280, 1330712292))
  print ("done!!")

  执行以上程序输出结果为：

  posix.stat_result(st_mode=33188, st_ino=3940649674337682L, st_dev=277923425L, st
  _nlink=1, st_uid=400, st_gid=401, st_size=335L, st_atime=1330498070, st_mtime=13
  30498074, st_ctime=1330498065)
  a2.py 的访问时间: 1330498070
  a2.py 的修改时间: 1330498074
  done!!

   

os.walk() 方法

2017年4月13日

21:25

   

概述

os.walk() 方法用于通过在目录树种游走输出在目录中的文件名，向上或者向下。

在Unix，Windows中有效。

语法

walk()方法语法格式如下：

os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])

参数

• top -- 根目录下的每一个文件夹(包含它自己), 产生3-元组 (dirpath, dirnames, filenames)【文件夹路径, 文件夹名字, 文件名】。
• topdown --可选，为True或者没有指定, 一个目录的的3-元组将比它的任何子文件夹的3-元组先产生 (目录自上而下)。如果topdown为 False, 一个目录的3-元组将比它的任何子文件夹的3-元组后产生 (目录自下而上)。
• onerror -- 可选，是一个函数; 它调用时有一个参数, 一个OSError实例。报告这错误后，继续walk,或者抛出exception终止walk。
• followlinks -- 设置为 true，则通过软链接访问目录。

  返回值

  该方法没有返回值。

  实例

  以下实例演示了 walk() 方法的使用：

  #!/usr/bin/python3

  import os
  for root, dirs, files in os.walk(".", topdown=False):
  for name in files:
  print(os.path.join(root, name))
  for name in dirs:
  print(os.path.join(root, name))

  执行以上程序输出结果为：

  ./.bash_logout
  ./amrood.tar.gz
  ./.emacs
  ./httpd.conf
  ./www.tar.gz
  ./mysql.tar.gz
  ./test.py
  ./.bashrc
  ./.bash_history
  ./.bash_profile
  ./tmp
  ./tmp/test.py

   

os.write() 方法

2017年4月13日

21:25

   

概述

os.write() 方法用于写入字符串到文件描述符 fd 中. 返回实际写入的字符串长度。

在Unix中有效。

语法

write()方法语法格式如下：

os.write(fd, str)

参数

• fd -- 文件描述符。
• str -- 写入的字符串。

  返回值

  该方法返回写入的实际位数。

  实例

  以下实例演示了 write() 方法的使用：

  #!/usr/bin/python3

  import os, sys

  # 打开文件
  fd = os.open("f1.txt",os.O_RDWR|os.O_CREAT)

  # 写入字符串
  str = "This is runoob.com site"
  ret = os.write(fd,bytes(str, 'UTF-8'))

  # 输入返回值
  print ("写入的位数为: ")
  print (ret)

  print ("写入成功")

  # 关闭文件
  os.close(fd)
  print ("关闭文件成功!!")

  执行以上程序输出结果为：

  写入的位数为:
  23
  写入成功
  关闭文件成功!!

   

   

Python3 错误和异常

2017年4月13日

10:55

   

   

作为Python初学者，在刚学习Python编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。

Python有两种错误很容易辨认：语法错误和异常。

语法错误

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax

这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号（:）。

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

异常

即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:

>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。

错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。

异常处理

以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

>>> while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print("Oops! That was no valid number. Try again ")

try语句按照如下方式工作；

• 首先，执行try子句（在关键字try和关键字except之间的语句）
• 如果没有异常发生，忽略except子句，try子句执行后结束。
• 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
• 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

  一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

  处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

  一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

  except (RuntimeError, TypeError, NameError):
  pass

  最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

  import sys

  try:
  f = open('myfile.txt')
  s = f.readline()
  i = int(s.strip())
  except OSError as err:
  print("OS error: {0}".format(err))
  except ValueError:
  print("Could not convert data to an integer.")
  except:
  print("Unexpected error:", sys.exc_info()[0])
  raise

  try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:

  for arg in sys.argv[1:]:
  try:
  f = open(arg, 'r')
  except IOError:
  print('cannot open', arg)
  else:
  print(arg, 'has', len(f.readlines()), 'lines')
  f.close()

  使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。

  异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:

  >>> def this_fails():
  x = 1/0
  
  >>> try:
  this_fails()
  except ZeroDivisionError as err:
  print('Handling run-time error:', err)
  
  Handling run-time error: int division or modulo by zero

     

  抛出异常

  Python 使用 raise 语句抛出一个指定的异常。例如:

  >>> raise NameError('HiThere')
  Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  NameError: HiThere

  raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

  如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

  >>> try:
  raise NameError('HiThere')
  except NameError:
  print('An exception flew by!')
  raise
  
  An exception flew by!
  Traceback (most recent call last):
  File "<stdin>", line 2, in ?
  NameError: HiThere

     

  用户自定义异常

  你可以通过创建一个新的exception类来拥有自己的异常。异常应该继承自 Exception 类，或者直接继承，或者间接继承，例如:

  >>> class MyError(Exception):
  def __init__(self, value):
  self.value = value
  def __str__(self):
  return repr(self.value)
  
  >>> try:
  raise MyError(2*2)
  except MyError as e:
  print('My exception occurred, value:', e.value)
  
  My exception occurred, value: 4
  >>> raise MyError('oops!')
  Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  __main__.MyError: 'oops!'

  在这个例子中，类 Exception 默认的 __init__() 被覆盖。

  <p异常的类可以像其他的类一样做任何事情，但是通常都会比较简单，只提供一些错误相关的属性，并且允许处理异常的代码方便的获取这些信息。< p="" style="color: rgb(51, 51, 51); font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, STHeiti, "Microsoft Yahei", sans-serif; font-size: 12px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(255, 255, 255);">

  当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

  class Error(Exception):
  """Base class for exceptions in this module."""
  pass

  class InputError(Error):
  """Exception raised for errors in the input.

  Attributes:
  expression -- input expression in which the error occurred
  message -- explanation of the error
  """

  def __init__(self, expression, message):
  self.expression = expression
  self.message = message

  class TransitionError(Error):
  """Raised when an operation attempts a state transition that's not
  allowed.

  Attributes:
  previous -- state at beginning of transition
  next -- attempted new state
  message -- explanation of why the specific transition is not allowed
  """

  def __init__(self, previous, next, message):
  self.previous = previous
  self.next = next
  self.message = message

  大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

     

  定义清理行为

  try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

  >>> try:
  raise KeyboardInterrupt
          finally:
  print('Goodbye, world!')
  
  Goodbye, world!
  KeyboardInterrupt

  以上例子不管try子句里面有没有发生异常，finally子句都会执行。

  如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。

  下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:

  >>> def divide(x, y):
  try:
  result = x / y
  except ZeroDivisionError:
  print("division by zero!")
  else:
  print("result is", result)
  finally:
  print("executing finally clause")
  
  >>> divide(2, 1)
  result is 2.0
  executing finally clause
  >>> divide(2, 0)
  division by zero!
  executing finally clause
  >>> divide("2", "1")
  executing finally clause
  Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
  TypeError: unsupported operand type(s) for /: 'str' and 'str'

     

  预定义的清理行为

  一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

  这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

  for line in open("myfile.txt"):
  print(line, end="")

  以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

  关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

  with open("myfile.txt") as f:
  for line in f:
  print(line, end="")

  以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

  </p异常的类可以像其他的类一样做任何事情，但是通常都会比较简单，只提供一些错误相关的属性，并且允许处理异常的代码方便的获取这些信息。<>

   

Python自带异常

2017年5月17日

7:54

   

这里有一个列表中的所有Python可用的标准异常：

   

Python断言

2017年5月17日

7:40

   

断言是一个理智检查，可以打开或关闭在程序做测试时。

断言的最简单的方法是将其比喻为触发-if语句(或者更准确，触发，如果未声明)。一个表达式进行测试，如果结果出现false，将引发异常。

断言是由assert语句，最新的关键字是Python版本1.5引入的。

程序员常常放置在一个函数来检查的有效输入开始断言和函数调用后检查有效输出。

assert语句：

当它遇到一个assert语句，Python计算表达式。如果表达式为false，Python会引发一个AssertionError异常。

断言的语法是：

assert Expression[, Arguments]

如果断言失败，Python使用ArgumentExpression作为AssertionError的参数。 AssertionError的异常可以被捕获，并像使用在try-except语句的任何其他异常处理，但如果不处理，他们将终止程序并产生回溯。

例子：

这里是一个函数，它把来自开氏度到华氏温度的温度下。自零开氏度是因为它得到寒冷，如果它看到一个负温度函数退出：

#!/usr/bin/python

def KelvinToFahrenheit(Temperature):
assert (Temperature >= 0),"Colder than absolute zero!"
return ((Temperature-273)*1.8)+32

print KelvinToFahrenheit(273)
print int(KelvinToFahrenheit(505.78))
print KelvinToFahrenheit(-5)

当执行上面的代码，产生以下结果：

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

   

   

Python3 模块

2017年4月13日

10:55

   

   

在前面的几个章节中我们脚本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。

为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

下面是一个使用 python 标准库中模块的例子。

#!/usr/bin/python3
# 文件名: using_sys.py

import sys

print('命令行参数如下:')
for i in sys.argv:
print(i)

print('\n\nPython 路径为：', sys.path, '\n')

执行结果如下所示：

$ python using_sys.py 参数1 参数2
命令行参数如下:
using_sys.py
参数1
参数2

Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']

• 1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
• 2、sys.argv 是一个包含命令行参数的列表。
• 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

     

  import 语句

  想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

  import module1[, module2[,... moduleN]

  当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

  搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：

  support.py 文件代码为：

  #!/usr/bin/python3
  # Filename: support.py

  def print_func( par ):
  print ("Hello : ", par)
  return

  test.py 引入 support 模块：

  #!/usr/bin/python3
  # Filename: test.py
  
  # 导入模块
  import support
  
  # 现在可以调用模块里包含的函数了
  support.print_func("Runoob")

  以上实例输出结果：

  $ python3 test.py
  Hello : Runoob

  一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

  当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？

  这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。

  这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。

  搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量，做一个简单的实验，在交互式解释器中，输入以下代码：

  >>> import sys
  >>> sys.path
  ['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
  >>>

  sys.path 输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），亦即我们执行python解释器的目录（对于脚本的话就是运行的脚本所在的目录）。

  因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。

  了解了搜索路径的概念，就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。

  现在，在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件，代码如下：

  # 斐波那契(fibonacci)数列模块

  def fib(n): # 定义到 n 的斐波那契数列
  a, b = 0, 1
  while b < n:
  print(b, end=' ')
  a, b = b, a+b
  print()

  def fib2(n): # 返回到 n 的斐波那契数列
  result = []
  a, b = 0, 1
  while b < n:
  result.append(b)
  a, b = b, a+b
  return result

  然后进入Python解释器，使用下面的命令导入这个模块：

  >>> import fibo

  这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里，只是把模块fibo的名字写到了那里。

  可以使用模块名称来访问函数：

  >>> fibo.fib(1000)
  1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
  >>> fibo.fib2(100)
  [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
  >>> fibo.__name__
  'fibo'

  如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：

  >>> fib = fibo.fib
  >>> fib(500)
  1 1 2 3 5 8 13 21 34 55 89 144 233 377

     

  from…import 语句

  Python的from语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

  from modname import name1[, name2[, ... nameN]]

  例如，要导入模块 fibo 的 fib 函数，使用如下语句：

  >>> from fibo import fib, fib2
  >>> fib(500)
  1 1 2 3 5 8 13 21 34 55 89 144 233 377

  这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。

     

  From…import* 语句

  把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

  from modname import *

  这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

     

  深入模块

  模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。

  每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。

  所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞花。

  从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。

  模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。

  还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。比如:

  >>> from fibo import fib, fib2
  >>> fib(500)
  1 1 2 3 5 8 13 21 34 55 89 144 233 377

  这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo 这个名称是没有定义的）。

  这还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:

  >>> from fibo import *
  >>> fib(500)
  1 1 2 3 5 8 13 21 34 55 89 144 233 377

  这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

     

  __name__属性

  一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

  #!/usr/bin/python3
  # Filename: using_name.py

  if __name__ == '__main__':
  print('程序自身在运行')
  else:
  print('我来自另一模块')

  运行输出如下：

  $ python using_name.py
  程序自身在运行

  $ python
  >>> import using_name
  我来自另一模块
  >>>

  说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

     

  dir() 函数

  内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
  </p>
  <pre>
  >>> import fibo, sys
  >>> dir(fibo)
  ['__name__', 'fib', 'fib2']
  >>> dir(sys)
  ['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
  '__package__', '__stderr__', '__stdin__', '__stdout__',
  '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
  '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
  'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
  'call_tracing', 'callstats', 'copyright', 'displayhook',
  'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
  'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
  'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
  'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
  'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
  'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
  'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
  'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
  'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
  'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
  'thread_info', 'version', 'version_info', 'warnoptions']

  如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

  >>> a = [1, 2, 3, 4, 5]
  >>> import fibo
  >>> fib = fibo.fib
  >>> dir() # 得到一个当前模块中定义的属性列表
  ['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
  >>> a = 5 # 建立一个新的变量 'a'
  >>> dir()
  ['__builtins__', '__doc__', '__name__', 'a', 'sys']
  >>>
  >>> del a # 删除变量名a
  >>>
  >>> dir()
  ['__builtins__', '__doc__', '__name__', 'sys']
  >>>

     

  标准模块

  Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。

  有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。

  这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。

  应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:

  >>> import sys
  >>> sys.ps1
  '>>> '
  >>> sys.ps2
  '... '
  >>> sys.ps1 = 'C> '
  C> print('Yuck!')
  Yuck!
  C>

     

  包

  包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

  比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

  就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。

  这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。

  不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。

  现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一组不断增加的模块，用来在不同的格式之间转换。

  并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所你还需要一组怎么也写不完的模块来处理这些操作。

  这里给出了一种可能的包结构（在分层的文件系统中）:

  sound/ 顶层包
  __init__.py 初始化 sound 包
  formats/ 文件格式转换子包
  __init__.py
  wavread.py
  wavwrite.py
  aiffread.py
  aiffwrite.py
  auread.py
  auwrite.py
  ...
  effects/ 声音效果子包
  __init__.py
  echo.py
  surround.py
  reverse.py
  ...
  filters/ filters 子包
  __init__.py
  equalizer.py
  vocoder.py
  karaoke.py
  ...

  在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

  目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

  最简单的情况，放一个空的 :file:__init__.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。

  用户可以每次只导入一个包里面的特定模块，比如:

  import sound.effects.echo

  这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:

  sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

  还有一种导入子模块的方法是:

  from sound.effects import echo

  这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:

  echo.echofilter(input, output, delay=0.7, atten=4)

  还有一种变化就是直接导入一个函数或者变量:

  from sound.effects.echo import echofilter

  同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:

  echofilter(input, output, delay=0.7, atten=4)

  注意当使用from package import item这种形式的时候，对应的item既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。

  import语法会首先把item当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，恭喜，一个:exc:ImportError 异常被抛出了。

  反之，如果使用形如import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

     

  从一个包中导入*

  设想一下，如果我们使用 from sound.effects import *会发生什么？

  Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。

  但是很不幸，这个方法在 Windows平台上工作的就不是非常好，因为Windows是一个大小写不区分的系统。

  在这类平台上，没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO。

  （例如，Windows 95就很讨厌的把每一个文件的首字母大写显示）而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。

  为了解决这个问题，只能烦劳包作者提供一个精确的包的索引了。

  导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

  作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊。你说我就不这么做，我就不使用导入*这种用法，好吧，没问题，谁让你是老板呢。这里有一个例子，在:file:sounds/effects/__init__.py中包含如下代码:

  __all__ = ["echo", "surround", "reverse"]

  这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。

  如果 __all__ 真的没有定义，那么使用from sound.effects import *这种语法的时候，就不会导入包 sound.effects 里的任何子模块。他只是把包sound.effects和它里面定义的所有内容导入进来（可能运行__init__.py里定义的初始化代码）。

  这会把 __init__.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:

  import sound.effects.echo
  import sound.effects.surround
  from sound.effects import *

  这个例子中，在执行from...import前，包sound.effects中的echo和surround模块都被导入到当前的命名空间中了。（当然如果定义了__all__就更没问题了）

  通常我们并不主张使用*这种方法来导入模块，因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫，而且一些模块都设计成了只能通过特定的方法导入。

  记住，使用from Package import specific_submodule这种方法永远不会有错。事实上，这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。

  如果在结构中包是一个子包（比如这个例子中对于包sound来说），而你又想导入兄弟包（同级别的包）你就得使用导入绝对的路径来导入。比如，如果模块sound.filters.vocoder 要使用包sound.effects中的模块echo，你就要写成 from sound.effects import echo。

  from . import echo
  from .. import formats
  from ..filters import equalizer

  无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"__main__"，一个Python应用程序的主模块，应当总是使用绝对路径引用。

  包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，你得在其他__init__.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。

  这个功能并不常用，一般用来扩展包里面的模块。

   

   

Python3 日期和时间

2017年4月13日

11:20

   

   

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:

#!/usr/bin/python3

import time; # 引入time模块

ticks = time.time()
print ("当前时间戳为:", ticks)

以上实例输出结果：

当前时间戳为: 1459996086.7115328

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。

   

什么是时间元组？

很多Python函数用一个元组装起来的9组数字处理时间:

上述也就是struct_time元组。这种结构具有如下属性：

   

获取当前时间

从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。

#!/usr/bin/python3

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=28, tm_sec=49, tm_wday=3, tm_yday=98, tm_isdst=0)

   

获取格式化的时间

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():

#!/usr/bin/python3

import time

localtime = time.asctime( time.localtime(time.time()) )
print ("本地时间为 :", localtime)

以上实例输出结果：

本地时间为 : Thu Apr 7 10:29:13 2016

   

格式化日期

我们可以使用 time 模块的 strftime 方法来格式化日期，：

time.strftime(format[, t])

#!/usr/bin/python3

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:29:46
Thu Apr 07 10:29:46 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/python3

  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模块包含了以下2个非常重要的属性：

   

日历（Calendar）模块

此模块的函数都是日历相关的，例如打印某月的字符月历。

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：

   

   

Datetime详解

2017年5月17日

14:01

   

dir(datetime)

包含的数据：

MAXYEAR -- 能表示的最大年份

MINYEAR -- 能表示的最小年份

datetime_CAPI -- C语言api访问的对象，可以help(datetime.datetime_CAPI)

   

   

   

   

 

dir(datetime)

包含的对象：

date -- 日期对象

datetime -- 日期时间对象

time -- 时间对象

timedelta -- 日期时间间隔对象

tzinfo -- 时区信息对象

包含的数据：

day -- 日号数值

month -- 月份数值

year -- 年份数值

max = datetime.date(9999, 12, 31)-- 最大的年、月、日的数值

min = datetime.date(1, 1, 1) -- 最小的年、月、日的数值

resolution = datetime.timedelta(1) -- 时间间隔单位为1天

   

   

   

   

dir(datetime.date)

   

包含的函数：

date(year, month, day) -- 构造函数，接受年、月、日三个参数，返回一个date object

ctime() -- 返回字符串格式的时间表示格式。不接受参数

fromordinal() -- 接受一个整型的天数数值，返回一个天数所等价的年数、月数、日数的date对象。

fromtimestamp() -- 接收一个浮点型的时间戳，返回一个从1970年起+时间戳的值对应的年、月、日的date对象。

isocalendar() -- 返回一个ISO标准的日历形式的3元元组，分别代表ISO year, week number, and weekday，不接收参数

isoformat() -- 返回一个ISO格式的日期字符串。格式为YYYY-MM-DD，不接收参数

isoweekday() -- 返回一个ISO格式的周表示。Monday == 1 ... Sunday == 7，不接收参数

replace() -- 返回一个替换指定日期字段的新date对象。参数3个可选参数，分别为year,month,day。注意替换是产生新对象，不影响原date对象。

strftime() -- 返回一个格式化的字符串形式日期。接收一个format参数，如：'%Y-%d-%m'

timetuple() -- 返回一个time的时间格式对象。等价于time.localtime()

today() -- 返回当前date或datetime对象。等价于fromtimestamp(time.time())

toordinal() -- 返回公元公历开始到现在的天数。公元1年1月1日为1

weekday() -- 返回日期表示的周期。Monday == 0 ... Sunday == 6

   

包含的数据：

hour -- 小时表示数值

microsecond -- 微秒表示数值

minute -- 分钟表示数值

second -- 秒表示数值

tzinfo -- 时区表示数值

max = datetime.time(23, 59, 59, 999999) -- 最大的时间表示数值

min = datetime.time(0, 0) -- 最小的时间表示数值

resolution = datetime.timedelta(0, 0, 1) -- 时间间隔单位为分钟

   

   

   

   

dir(datetime.time)

包含的函数：

time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) -- 构造函数，返回一个time对象。所有参数均为可选

dst() -- 返回时区信息的描述。如果实例是没有tzinfo参数则返回空

isoformat() -- 返回ISO 8601格式字符串, HH:MM:SS[.mmmmmm][+HH:MM].

replace() -- 返回一个替换指定时间字段的新time对象。4个可选参数，分别为hour,minute,second,microsecond。注意替换是产生新对象，不影响原time对象。

strftime() -- 接收一个format参数，返回一个对应格式的字符串。如:'%H:%M:%S'

tzname() -- 返回时区的名称。如果实例是没有tzinfo参数则返回空

utcoffset() -- 返回self.tzinfo.utcoffset(self)

   

   

继承自date的数据：

day

month

year

   

继承自date的函数：

fromordinal(...)

isocalendar(...)

isoweekday(...)

strftime(...)

today(...)

toordinal(...)

weekday(...)

 

包含的数据：

hour

microsecond

minute

second

tzinfo

max = datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)

min = datetime.datetime(1, 1, 1, 0, 0)

resolution = datetime.timedelta(0, 0, 1)

   

   

   

dir(datetime.datetime)

包含的函数：

datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]]) -- 构造函数，返回一个datetime对象。year, month, day为必选参数

astimezone(...) -- 根据给定的timezone对象，返回转换为本地时区的timezone对象。

combine(...) -- 根据给定date, time对象合并后，返回一个对应值的datetime对象。

ctime(...) -- 返回ctime格式的字符串。

date(...) -- 返回具有相同year, month, day的date对象

dst(...) -- 返回self.tzinfo.dst(self).

fromtimestamp(...) -- 根据时间戳数值，返回一个datetime对象。

isoformat(...) -- 返回ISO 8601格式的字符串,如：YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM]

now(...) -- 根据给定的时区，返回当地的当前时间。

replace(...) -- 返回一个替换了指定日期时间字段的新datetime对象

strptime(...) -- 根据string, format2个参数，返回一个对应的datetime对象。

time(...) -- 返回一个带有相同time，但没有tzinfo的time对象。

timetuple(...) -- 返回一个时间元素, 等价于time.localtime().

timetz(...) -- 返回一个带有相同time和tzinfo的time对象。

tzname(...) -- 返回self.tzinfo.tzname(self).

utcfromtimestamp(...) -- 返回UTC时间戳的datetime对象，时间戳值为time.time()

utcnow(...) -- 返回UTC当前时间的datetime对象.

utcoffset(...) -- Return self.tzinfo.utcoffset(self).

utctimetuple(...) -- 返回UTC时间元组对象, 等价于time.localtime().

   

说明：

datetime.time对象调用了time模块的基础方法。并封装之。

datetime.date对象同样调用了time模块的基础方法，并封装之。

datetime.datetime对象继承了datetime.date类，并调用了time模块的方法。

   

包含的数据：

days -- 天数

microseconds -- 微秒数(>= 0 and less than 1 second).

seconds -- 秒数 (>= 0 and less than 1 day).

   

max = datetime.timedelta(999999999, 86399, 999999)

min = datetime.timedelta(-999999999)

resolution = datetime.timedelta(0, 0, 1)

   

   

 

包含的函数：

timedelta() -- 构造函数，接收3个参数，天、秒、微秒

total_seconds() -- 时间间隔的总秒数

   

datetime

2017年5月17日

13:46

   

Python中用datetime包进行对时间的一些操作

   

1. 计算给出两个时间之间的时间差

   

import datetime as dt

# current time

cur_time = dt.datetime.today()

# one day

pre_time = dt.date(2016, 5, 20) # eg: 2016.5.20

delta = cur_time - pre_time

# if you want to get discrepancy in days

print delta.days

# if you want to get discrepancy in hours

print delta.hours

# and so on

2. 获取n天前的时间

   

cur_time = dt.now()

# previous n days

pre_time = dt.timedelta(days=n)

3. 将给定的时间精确到天或者其他单位

   

cur_time = dt.now()

# get day of current time

cur_day = cur_time.replace(hour=0, minute=0, second=0, mircrosecond=0)

4. 获取一连串的时间序列（返回list）

   

cur_time = dt.datetime.today()

datelist = [cur_time - dt.timedelta(days=x) for x in range(0, 100)]

或者

   

import pandas as pd

datelist = pd.date_range(pd.datetime.today(), periods=100).tolist()

5. 将时间字符串转化为datetime类型

   

date_formate = "%Y-%m-%d" # year-month-day

time = dt.strptime('2016-06-22', date_format)

6. 将时间类型转化为字符串类型

   

time_str = dt.strftime("%Y-%m-%d", dt.now()) # return like "2016-06-22"

   

   

Python3 标准库概览

2017年4月13日

10:55

   

   

操作系统接口

os模块提供了不少与操作系统相关联的函数。

>>> import os
>>> os.getcwd() # 返回当前的工作目录
'C:\\Python34'
>>> os.chdir('/server/accesslogs') # 修改当前的工作目录
>>> os.system('mkdir today') # 执行系统命令 mkdir
0

建议使用 "import os" 风格而非 "from os import *"。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。

在使用 os 这样的大型模块时内置的 dir() 和 help() 函数非常有用:

>>> import os
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>

针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')

   

文件通配符

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

#获取指定目录下的所有图片

print glob.glob(r"E:/Picture/*/*.jpg")

   

#获取上级目录的所有.py文件

print glob.glob(r'../*.py') #相对路径

   

   

   

   

命令行参数

通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。例如在命令行中执行 "python demo.py one two three" 后可以得到以下输出结果:

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']

   

   

字符串正则匹配

re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

如果只需要简单的功能，应该首先考虑字符串方法，因为它们非常简单，易于阅读和调试:

>>> 'tea for too'.replace('too', 'two')
'tea for two'

   

数学

math模块为浮点运算提供了对底层C函数库的访问:

>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

random提供了生成随机数的工具。

>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(range(100), 10) # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random() # random float
0.17970987693706186
>>> random.randrange(6) # random integer chosen from range(6)
4

   

访问 互联网

有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib:

>>> from urllib.request import urlopen
>>> for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
... line = line.decode('utf-8') # Decoding the binary data to text.
... if 'EST' in line or 'EDT' in line: # look for Eastern Time
... print(line)

<BR>Nov. 25, 09:43:32 PM EST

>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('[email protected]', '[email protected]',
... """To: [email protected]
... From: [email protected]
...
... Beware the Ides of March.
... """)
>>> server.quit()

注意第二个例子需要本地有一个在运行的邮件服务器。

   

日期和时间

datetime模块为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。

该模块还支持时区处理:

>>> # dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'

>>> # dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

   

数据压缩

以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

   

性能度量

有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。

例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。

>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。

   

测试模块

开发高质量软件的方法之一是为每一个函数开发测试代码，并且在开发过程中经常进行测试

doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。

测试构造如同简单的将它的输出结果剪切并粘贴到文档字符串中。

通过用户提供的例子，它强化了文档，允许 doctest 模块确认代码的结果是否与文档一致:

def average(values):
"""Computes the arithmetic mean of a list of numbers.

>>> print(average([20, 30, 70]))
40.0
"""
return sum(values) / len(values)

import doctest
doctest.testmod() # 自动验证嵌入测试

unittest模块不像 doctest模块那么容易使用，不过它可以在一个独立的文件里提供一个更全面的测试集:

import unittest

class TestStatisticalFunctions(unittest.TestCase):

def test_average(self):
self.assertEqual(average([20, 30, 70]), 40.0)
self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
self.assertRaises(ZeroDivisionError, average, [])
self.assertRaises(TypeError, average, 20, 30, 70)

unittest.main() # Calling from the command line invokes all tests

   

Python抓取网页

2017年5月17日

16:47

   

在爬虫的过程中，总会遇到要获取网页内容的时候，下面就对如何获取网页内容进行总结。

方法一：

>import urllib
>url="http://www.baidu.com" #这里是需要获取的网页
>content=urllib.open(url).read() #使用urllib模块获取网页内容
>print content #输出网页的内容 功能相当于查看网页源代码

方法二：

>import urllib2
>from bs4 import BeautifulSoup #这里需要导入BeautifulSoup
>url="http://www.baidu.com"
>content=urllib2.urlopen(url)
>soup=BeautifulSoup(content) #将网页内容转化为BeautifulSoup 格式的数据
>print soup

方法三：

>import requests
>content=requests.get(url).content
>print content

这里是使用的python的requests模块获取网页的内容。

方法四：

>import codecs #导入codecs模块
>f=codecs.open(url,"r","utf-8") #使用codecs函数以打开的方式打开url 设置默认的编码方式为utf-8
>content=f.read()
>f.close()
>print content

   

Python打开浏览器方法

2017年5月17日

16:49

   

   

1.startfile方法

import os
os.startfile("C:\Program Files (x86)\Google\Chrome\Application\chrome.exe")

2.system方法

import os
os.system(r'C:\"Program Files (x86)"\"Google"\"Chrome"\"Application"\chrome.exe')

3.更好地解决方案WEBBROWER

import webbrowser
webbrowser.open("http://www.baidu.com")