python的学习

基础知识学习和扩展算法，包含如果多个线程共同队某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

python学习

• 基础知识
  • 基础语法
    • 编码
      • python3以下是以UTF-8编码
      • 所有的字符串是Unicode字符串
    • 标识符
      • 第一个字符必须是字母或者_
      • 字符的组成是字母和数字_组成的
      • 字符对大小写敏感
    • 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中单行开头注释前面加上#
        • # 第一个注释
      • python中多行注释可用多个#，也可以用'''和"""
        • # 第一个注释 # 第二个注释 ''' 第三注释 第四注释 ''' """ 第五注释 第六注释 """
    • 行与缩进
      • python中最特色的就是使用缩进代表代码块，不需要使用{}
      • 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进数
        • if True: print ("True") else: print ("False")
      • 最后的一个缩进是错误的就会报错
        • if True: print ("Answer") print ("True") else: print ("Answer") print ("False") # 缩进不一致，会导致运行错误
    • 多行语句
      • python中如果有一行写不完，但是语句较长，我们可以用反斜杠\来进项分割换行
        • total = item_one + \ item_two + \ item_three
      • 在[](){}中的多行语句，不需要使用反斜杠\
        • total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five']
    • 数字（number）类型
      • python中有四种类型：整数、浮点数、布尔型和复数
      • int（整数）只用一种整数型用int，表示长整数型，在python2中没有Long
      • bool（布尔），如True
      • float（浮点），如1.23，3E-2
      • complex（复数），如1+2j,1.1+2.2j
    • 字符串（String）
      • python中单引号'和双引号"用法使用完全相同
      • 使用三个引号（'''和"""）表示一个多行字符串
        • word = '字符串' sentence = "这是一个句子。" paragraph = """这是一个段落， 可以由多行组成"""
      • 转义符\
      • 反斜杠可以用来表示转义，使用r可以让不发生转义
        • 如 r"this is a line with \n" 则 \n 会显示，并不是换行
      • 按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is string
      • 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
      • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始
      • 这里的 r 指 raw，即 raw string，会自动将反斜杠转义
        • >>> print('\n') # 输出空行 >>> print(r'\n') # 输出 \n \n >>>
      • python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始
      • python中的字符串不能改变
      • python中没有单独的字符串类型，一个字符串类型就是1的字符串
        • str='123456789' print(str) # 输出字符串 print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 print(str[0]) # 输出字符串第一个字符 print(str[2:5]) # 输出从第三个开始到第五个的字符 print(str[2:]) # 输出从第三个开始后的所有字符 print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2） print(str * 2) # 输出字符串两次 print(str + '你好') # 连接字符串 print('------------------------------') print('hello\nword') # 使用反斜杠(\)+n转义特殊字符 print(r'hello\nword') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
          • 输出的结果 123456789 12345678 1 345 3456789 24 123456789123456789 123456789你好 ------------------------------ hello word hello\nword
    • 空行
      • 函数之间或类的方法之间用空行分隔，表示一段代码新的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始
      • 空行与代码缩不同，空行不是python的语法一部分，书写时不加入空行，python运行也不会出错，但是空行作用在于分隔两段不同功能或含义的代码，以便日后代码维护和重构。
      • 空行也是代码的一部分
    • 等待客户输入
      • input("\n\n按下 enter 键后退出。")
        • 以上代码中 ，\n\n 在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出
    • 同一行显示多条语句
      • python中可以同一行使用多条语句，用；分隔
        • import sys; x = 'word'; sys.stdout.write(x + '\n')
          • 使用脚本执行以上代码，输出结果为：word
      • 交互式命令
        • >>> import sys; x = 'word'; sys.stdout.write(x + '\n') word 5
          • 此处的 5 表示字符数，word 有 4 个字符，\n 表示一个字符，加起来 5 个字符
        • >>> import sys >>> sys.stdout.write(" hi ") # hi 前后各有 1 个空格 hi 4
    • 多个语句构成的代码组
      • 缩进相同的一组语句构成一个代码块，我们称之为代码组
      • 像if、while、del和class这样复合语句，首先以关键字开始，以冒号（：）结束，该行之后的一行或多行代码构成代码组。
        • if expression : suite elif expression : suite else : suite
      • 我们首行以及后面的代码组称为一个句子（clause）
    • print输出
      • print默认输出是换行，如果要实现不换行需要在变量末尾加上end=""
        • 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
        • import sys print('================Python import mode==========================') print ('命令行参数为:') for i in sys.argv: print (i) print ('\n python 路径为',sys.path)
      • 将某个函数模块导入多个函数，格式from somemodule import firstfunc，secondfunc，thirdfunc
        • from sys import argv,path # 导入特定的成员 print('================python from import===================================') print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path
      • 将某个模块全部导入from somemodule import *
    • 命令行参数
      • 很多程序可以执行一些操作来查看一些基本信息，python可以使用-h参数查看各参数帮助信息
  • 基本数据类型
    • 介绍
      • python中的变量不需要声明。每个变量在使用前都必须要赋值，变量赋值以后才会被创建
      • 在python中，变量就是变量，它没有类型，我们所说的“类型”是变量所指的内存中的对象类型。
      • 等号（=）用来给变量赋值
      • 等会（=）运算符左边是一个变量名，等号（=）运算符右边是存储在变量中的值
        • counter = 100 # 整型变量 miles = 1000.0 # 浮点型变量 name = "word" # 字符串 print (counter) print (miles) print (name)
          • 100 1000.0 word
    • 多个变量的赋值
      • python允许你同时为多个变量赋值
        • a = b = c = 1
          • 以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值
      • 你也可以为多个对象指定多个变量
        • a, b, c = 1, 2, "word"
          • 以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "word" 分配给变量 c
    • 标准数据类型
      • 有六个标准类型
        • Number（数字）
        • String（字符串）
        • List（列表）
        • Tuple（元组）
        • Set（集合）
        • Dictionary（字典）
      • 标准数据类型
        • 3个不可变数据类型
          • Number（数字）
          • String（字符串）
          • Tuple（元组）
        • 3个可变数据类型
          • List（列表）
          • Set（集合）
          • Dictionary（字典）
    • Number（数字）
      • 支持int、float、bool、complex（复数型）
      • 在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long
      • 像大多数语言一样，数值类型的赋值和计算都是很直观的
        • >>> 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'>
      • 内置的 type() 函数可以用来查询变量所指的对象类型
      • 此外还可以用isinstance来判断
        • >>> a = 111 >>> isinstance(a, int) True
      • isinstance和type的区别在于
        • type（）不会认为子类是一种父类类型
        • isinstance（）会认为子类是一种类型父类
          • >>> class A: ... pass >>> class B(A): ... pass >>> isinstance(A(), A) True >>> type(A()) == A True >>> isinstance(B(), A) True >>> type(B()) == A False
        • 注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型
          • >>> issubclass(bool, int) True >>> True==1 True >>> False==0 True >>> True+1 2 >>> False+1 1 >>> 1 is True False >>> 0 is False False
        • 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True
      • 当你指定一个值时，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
      • 注意
        • python可以同时为多个变量赋值，如a,b=1,2
        • 一个变量可以通过赋值指向不同类型对象
        • 数值的除法包含两种运算符：\返回一个浮点数，\\返回一个整数
        • 在混合时计算，python会把整数变成浮点数
      • 数值类型实例
        • int float complex 10 0.0 3.14j 100 15.20 45.j -786 -21.9 9.322e-36j 080 32.3e+18 .876j -0490 -90. -.6545+0J -0x260 -32.54e100 3e+26J 0x69 70.2E-12 4.53e-7j
        • Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
    • String（字符串）
      • Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符
      • 字符串的截取的语法格式如下
        • 变量[头下标:尾下标]
      • 索引值以 0 为开始值，-1 为从末尾的开始位置。
      • 加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数
        • str = 'Runoob' print (str) # 输出字符串 print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 print (str[0]) # 输出字符串第一个字符 print (str[2:5]) # 输出从第三个开始到第五个的字符 print (str[2:]) # 输出从第三个开始的后的所有字符 print (str * 2) # 输出字符串两次，也可以写成 print (2 * str) 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'会导致错误
      • 注意
        • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义
        • 字符串可以用+运算符连接在一起，用*运算符重复
        • Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
        • Python中的字符串不能改变
    • List（列表）
      • List（列表） 是 Python 中使用最频繁的数据类型
      • 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）
      • 列表是写在方括号 [] 之间、用逗号分隔开的元素列表
      • 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表
      • 列表截取的语法格式
        • 变量[头下标:尾下标]
      • 索引值以 0 为开始值，-1 为从末尾的开始位置
      • 加号 + 是列表连接运算符，星号 * 是重复操作
        • 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() 等等
      • 注意
        • List写在方括号之间，元素用逗号隔开
        • 和字符串一样，list可以被索引和切片
        • List可以使用+操作符进行拼接
        • List中的元素是可以改变的
      • Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
      • 如果第三个参数为负数表示逆向读取
        • def reverseWords(input): # 通过空格将字符串分隔符，把各个单词分隔为列表 inputWords = input.split(" ") # 翻转字符串 # 假设列表 list = [1,2,3,4], # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) # inputWords[-1::-1] 有三个参数 # 第一个参数 -1 表示最后一个元素 # 第二个参数为空，表示移动到列表末尾 # 第三个参数为步长，-1 表示逆向 inputWords=inputWords[-1::-1] # 重新组合字符串 output = ' '.join(inputWords) return output if __name__ == "__main__": input = 'I like runoob' rw = reverseWords(input) print(rw)
          • 输出结果为：
          • runoob like I
    • Tuple（元组）
      • 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开
      • 元组中的元素类型也可以不相同
        • 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（序列）
      • 注意
        • 与字符串一样，元组的元素不能修改
        • 元组也可以被索引和切片，方法一样
        • 注意构造包含 0 或 1 个元素的元组的特殊语法规则
        • 元组也可以使用+操作符进行拼接
    • Set（集合）
      • 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员
      • 基本功能是进行成员关系测试和删除重复元素
      • 可以使用大括号{}或者set（）函数创建集合，注意创建一个空集合必须时set（）而不是{}，因为{}是创建一个空字典
        • 创建格式
          • parame = {value01,value02,...} 或者 set(value)
      • 例子
        • sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'} print(sites) # 输出集合，重复的元素被自动去掉 # 成员测试 if 'Runoob' in sites : print('Runoob 在集合中') else : print('Runoob 不在集合中') # 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 中不同时存在的元素
          • 输出结果
          • {'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'} Runoob 在集合中 {'b', 'c', 'a', 'r', 'd'} {'r', 'b', 'd'} {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'} {'c', 'a'} {'z', 'b', 'm', 'r', 'l', 'd'}
    • Dictionary（字典）
      • 字典（dictionary）是Python中另一个非常有用的内置数据类型
      • 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
      • 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
      • 键（key）必须使用不可变类型。
        • 在同一个字典中，键（key）必须是唯一的
          • dict = {} dict['one'] = "1 - 你好中国" dict[2] = "2 - 你好世界" tinydict = {'name': 'baidu','code':1, 'site': 'www.baidub.com'} print (dict['one']) # 输出键为 'one' 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值
            • 输出结果
            • 1 - 你好中国 2 - 你好世界 {'name': 'baidu', 'code': 1, 'site': 'www.baidu.com'} dict_keys(['name', 'code', 'site']) dict_values(['baidu', 1, 'www.baidu.com'])
      • 构造函数 dict() 可以直接从键值对序列中构建字典
        • >>> dict([('baidu', 1), ('Google', 2), ('Taobao', 3)]) {'baidu': 1, 'Google': 2, 'Taobao': 3} >>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36} >>> dict(baidu=1, Google=2, Taobao=3) {'baidu': 1, 'Google': 2, 'Taobao': 3}
      • 另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等
      • 注意
        • 字典是一种映射类型，它的元素是键值对
        • 字典的关键字必须为不可变类型，且不能重复
        • 创建空字典使用 { }
    • python数据类型转换
      • 有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可
      • 内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值
        • 函数 描述 int(x [,base]) 将x转换为一个整数 float(x) 将x转换到一个浮点数 complex(real [,imag]) 创建一个复数 str(x) 将对象 x 转换为字符串 repr(x) 将对象 x 转换为表达式字符串 eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象 tuple(s) 将序列 s 转换为一个元组 list(s) 将序列 s 转换为一个列表 set(s) 转换为可变集合 dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。 frozenset(s) 转换为不可变集合 chr(x) 将一个整数转换为一个字符 ord(x) 将一个字符转换为它的整数值 hex(x) 将一个整数转换为一个十六进制字符串 oct(x) 将一个整数转换为一个八进制字符串
  • 注释
    • 介绍
      • 确保对模块, 函数, 方法和行内注释使用正确的风格
      • Python中的注释有单行注释和多行注释
      • ython中单行注释以 # 开头
        • # 这是一个注释 print("Hello, World!")
      • 多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来
    • 单引号（'''）
      • ''' 这是多行注释，用三个单引号 这是多行注释，用三个单引号 这是多行注释，用三个单引号 ''' print("Hello, World!")
    • 多引号（"""）
      • """ 这是多行注释，用三个双引号 这是多行注释，用三个双引号 这是多行注释，用三个双引号 """ print("Hello, World!")
  • 运算符
    • 介绍
      • 举个简单的例
        • 4 + 5 = 9
          • 例子中，4 和 5 被称为操作数，+ 称为运算符
    • python算术运算符
      • 假设变量 a=10，变量 b=21
        • 运算符 描述 实例 + 加 - 两个对象相加 a + b 输出结果 31 - 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11 * 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210 / 除 - x 除以 y b / a 输出结果 2.1 % 取模 - 返回除法的余数 b % a 输出结果 1 ** 幂 - 返回x的y次幂 a**b 为10的21次方 // 取整除 - 向下取接近商的整数 >>> 9//2 4 >>> -9//2 -5
          • 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
        • 运算符 描述 实例 == 等于 - 比较对象是否相等 (a == b) 返回 False。 != 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。 > 大于 - 返回x是否大于y (a > b) 返回 False。 < 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 True。 >= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。 <= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。
          • 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
        • 运算符 描述 实例 = 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c += 加法赋值运算符 c += a 等效于 c = c + a -= 减法赋值运算符 c -= a 等效于 c = c - a *= 乘法赋值运算符 c *= a 等效于 c = c * a /= 除法赋值运算符 c /= a 等效于 c = c / a %= 取模赋值运算符 c %= a 等效于 c = c % a **= 幂赋值运算符 c **= a 等效于 c = c ** a //= 取整除赋值运算符 c //= a 等效于 c = c // a := 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。 在这个示例中，赋值表达式可以避免调用 len() 两次: if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")
          • 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位运算符
      • 按位运算符是把数字看作二进制来进行计算的
      • a 为 60，b 为 13二进制格式
        • a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011
          • 运算符 描述 实例 & 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100 | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101 ^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 ~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 << 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000 >> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
            • a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0 c = a & b # 12 = 0000 1100 print ("1 - c 的值为：", c) c = a | b # 61 = 0011 1101 print ("2 - c 的值为：", c) c = a ^ b # 49 = 0011 0001 print ("3 - c 的值为：", c) c = ~a # -61 = 1100 0011 print ("4 - c 的值为：", c) c = a << 2 # 240 = 1111 0000 print ("5 - c 的值为：", c) c = a >> 2 # 15 = 0000 1111 print ("6 - c 的值为：", c)
              • 输出结果
              • 1 - c 的值为： 12 2 - c 的值为： 61 3 - c 的值为： 49 4 - c 的值为： -61 5 - c 的值为： 240 6 - c 的值为： 15
    • python逻辑运算符
      • Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20
        • 运算符 逻辑表达式 描述 实例 and x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 (a and b) 返回 20。 or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。 not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
          • 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还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组
        • 运算符 描述 实例 in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
          • 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身份运算符
      • 身份运算符用于比较两个对象的存储单元
        • 运算符 描述 实例 is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
          • 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 没有相同的标识
      • is 与 == 区别： is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等
        • >>> a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a True
    • python运算符优先级
      • 从最高到最低优先级的所有运算符
        • 运算符 描述 ** 指数 (最高优先级) ~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) * / % // 乘，除，求余数和取整除 + - 加法减法 >> << 右移，左移运算符 & 位 'AND' ^ | 位运算符 <= < > >= 比较运算符 == != 等于运算符 = %= /= //= -= += *= **= 赋值运算符 is is not 身份运算符 in not in 成员运算符 not and or 逻辑运算符
          • 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
  • 数字（Number）
    • 介绍
      • 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 类型。布尔(bool)是整型的子类型
        • 浮点型(float)
          • 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
        • 复数( (complex))
          • 数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
      • 我们可以使用十六进制和八进制来代表整数
        • >>> number = 0xA0F # 十六进制 >>> number 2575 >>> number=0o37 # 八进制 >>> number 31
          • int float complex 10 0.0 3.14j 100 15.20 45.j -786 -21.9 9.322e-36j 080 32.3e+18 .876j -0490 -90. -.6545+0J -0x260 -32.54e100 3e+26J 0x69 70.2E-12 4.53e-7j
      • 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
      • 注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系
        • >>> 7//2 3 >>> 7.0//2 3.0 >>> 7//2.0 3.0 >>>
      • 等号 = 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果
        • >>> 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
          • 此处， _ 变量应被用户视为只读变量
    • 数字函数
      • abs(x) 返回数字的绝对值，如abs(-10) 返回 10
        • 描述
          • abs() 函数返回数字的绝对值。
        • 语法
          • 以下是 abs() 方法的语法:
            • abs( x )
        • 参数
          • x -- 数值表达式，可以是整数，浮点数，复数。
        • 返回值
          • 函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。
        • 实例
          • 以下展示了使用 abs() 方法的实例
            • print ("abs(-40) : ", abs(-40)) print ("abs(100.10) : ", abs(100.10))
              • abs(-40) : 40 abs(100.10) : 100.1
      • ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
        • 描述
          • ceil(x) 函数返回一个大于或等于 x 的的最小整数。
        • 语法
          • 以下是 ceil() 方法的语法:
            • import math
              • math.ceil( x )
                • 注意：ceil()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 函数返回返回一个大于或等于 x 的的最小整数。
        • 实例
          • 以下展示了使用 ceil() 方法的实例
            • 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
      • cmp(x, y)
        • 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
      • exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
        • 描述
          • exp() 方法返回x的指数,ex。
        • 语法
          • 以下是 exp() 方法的语法:
            • import math
              • math.exp( x )
                • 注意：exp()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 返回x的指数,ex。
        • 实例
          • 以下展示了使用 exp() 方法的实例
            • 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(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
        • 描述
          • fabs() 方法返回数字的绝对值，如math.fabs(-10) 返回10.0。
          • fabs() 函数类似于 abs() 函数，但是他有两点区别:
          • abs() 是内置函数。 fabs() 函数在 math 模块中定义。
          • fabs() 函数只对浮点型跟整型数值有效。 abs() 还可以运用在复数中。
        • 语法
          • 以下是 fabs() 方法的语法:
            • import math
            • math.fabs( x )
            • 注意：fabs()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 返回数字的绝对值。
        • 实例
          • 以下展示了使用 fabs() 方法的实例
            • 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(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
        • 描述
          • floor(x) 返回数字的下舍整数，小于或等于 x。
        • 语法
          • 以下是 floor() 方法的语法:
            • import math
            • math.floor( x )
            • 注意：floor()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 返回小于或等于 x 的整数。
        • 实例
          • 以下展示了使用 floor() 方法的实例
            • 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(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
        • 描述
          • log() 方法返回x的自然对数，x > 0。
        • 语法
          • 以下是 log() 方法的语法:
            • import math
            • math.log( x )
            • 注意：log()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 返回x的自然对数，x>0。
        • 实例
          • 以下展示了使用 log() 方法的实例
            • 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(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
        • 描述
          • log10() 方法返回以10为基数的x对数，x>0。
        • 语法
          • 以下是 log10() 方法的语法:
            • import math
            • math.log10( x )
            • 注意：log10()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 返回以10为基数的x对数，x>0。
        • 实例
          • 以下展示了使用 log10() 方法的实例
            • 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(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
        • 描述
          • max() 方法返回给定参数的最大值，参数可以为序列。
        • 语法
          • 以下是 max() 方法的语法:
            • max( x, y, z, .... )
        • 参数
          • x -- 数值表达式。
          • y -- 数值表达式。
          • z -- 数值表达式。
        • 返回值
          • 返回给定参数的最大值。
        • 实例
          • 以下展示了使用 max() 方法的实例
            • 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(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
        • 描述
          • min() 方法返回给定参数的最小值，参数可以为序列。
        • 语法
          • 以下是 min() 方法的语法:
            • min( x, y, z, .... )
        • 参数
          • x -- 数值表达式。
          • y -- 数值表达式。
          • z -- 数值表达式。
        • 返回值
          • 返回给定参数的最小值。
        • 实例
          • 以下展示了使用 min() 方法的实例
            • 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(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
        • 描述
          • modf() 方法返回 x 的整数部分与小数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示。
        • 语法
          • 以下是 modf() 方法的语法:
            • import math
            • math.modf( x )
            • 注意：modf()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 返回x的整数部分与小数部分，
        • 实例
          • 以下展示了使用 modf() 方法的实例
            • 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(x, y) x**y 运算后的值。
        • 描述
          • pow() 方法返回 xy（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 -- 数值表达式。
        • 返回值
          • 返回 xy（x的y次方） 的值。
        • 实例
          • 以下展示了使用 pow() 方法的实例
            • 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(x [,n])
        • 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
          • 描述
            • round() 方法返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。
              • 精度要求高的，不建议使用该函数。
          • 语法
            • 以下是 round() 方法的语法:
              • round( x [, n] )
          • 参数
            • x -- 数字表达式。
            • n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。
          • 返回值
            • 返回浮点数x的四舍五入值。
          • 实例
            • 以下展示了使用 round() 方法的实例
              • 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
            • 看下官网给的一个例子
              • >>> round(2.675, 2) 2.67
              • 按我们的想法返回结果应该是 2.68，可结果却是 2.67，为什么？ 这跟浮点数的精度有关。我们知道在机器中浮点数不一定能精确表达，因为换算成一串 1 和 0 后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离 2.67 要更近一点点，所以保留两位小数时就近似到了 2.67。
        • 其实准确的说是保留值将保留到离上一位更近的一端。
      • sqrt(x) 返回数字x的平方根。
        • 描述
          • sqrt() 方法返回数字x的平方根。
        • 语法
          • 以下是 sqrt() 方法的语法:
            • import math
            • math.sqrt( x )
            • 注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
        • 参数
          • x -- 数值表达式。
        • 返回值
          • 返回数字x的平方根。
        • 实例
          • 以下展示了使用 sqrt() 方法的实例
            • 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
    • 随机函数
      • 随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性
      • 常用随机数函数
        • choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
          • 描述
            • choice() 方法返回一个列表，元组或字符串的随机项。
          • 语法
            • 以下是 choice() 方法的语法:
              • import random
              • random.choice( seq )
              • 注意：choice()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
          • 参数
            • seq -- 可以是一个列表，元组或字符串。
          • 返回值
            • 返回随机项。
          • 实例
            • 以下展示了使用 choice() 方法的实例
              • 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 ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
          • 描述
            • randrange() 方法返回指定递增基数集合中的一个随机数，基数默认值为1。
          • 语法
            • 以下是 randrange() 方法的语法:
              • import random
              • random.randrange ([start,] stop [,step])
              • 注意：randrange()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
          • 参数
            • start -- 指定范围内的开始值，包含在范围内。
            • stop -- 指定范围内的结束值，不包含在范围内。
            • step -- 指定递增基数。
          • 返回值
            • 从给定的范围返回随机项。
          • 实例
            • 以下展示了使用 randrange() 方法的实例
              • 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() 随机生成下一个实数，它在[0,1)范围内。
          • 描述
            • random() 方法返回随机生成的一个实数，它在[0,1)范围内。
          • 语法
            • 以下是 random() 方法的语法:
              • import random
              • random.random()
              • 注意：random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
          • 参数
            • 无
          • 返回值
            • 返回随机生成的一个实数，它在[0,1)范围内。
          • 实例
            • 以下展示了使用 random() 方法的实例
              • import random # 第一个随机数 print ("random() : ", random.random()) # 第二个随机数 print ("random() : ", random.random())
                • random() : 0.09690599908884856 random() : 0.8732120512570916
        • seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
          • 描述
            • seed() 方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。。
          • 语法
            • 以下是 seed() 方法的语法:
              • import random
              • random.seed ( [x] )
              • 我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。
              • 注意：seed()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
          • 参数
            • x -- 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
          • 返回值
            • 本函数没有返回值。
          • 实例
            • 以下展示了使用 seed(() 方法的实例
              • import random random.seed() print ("使用默认种子生成随机数：", random.random()) print ("使用默认种子生成随机数：", random.random()) random.seed(10) print ("使用整数 10 种子生成随机数：", random.random()) random.seed(10) print ("使用整数 10 种子生成随机数：", random.random()) random.seed("hello",2) print ("使用字符串种子生成随机数：", random.random())
                • 使用默认种子生成随机数： 0.7908102856355441 使用默认种子生成随机数： 0.81038961519195 使用整数 10 种子生成随机数： 0.5714025946899135 使用整数 10 种子生成随机数： 0.5714025946899135 使用字符串种子生成随机数： 0.3537754404730722
        • shuffle(lst) 将序列的所有元素随机排序
          • 描述
            • shuffle() 方法将序列的所有元素随机排序。
          • 语法
            • 以下是 shuffle() 方法的语法:
              • import random
              • random.shuffle (lst )
              • 注意：shuffle() 是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
          • 参数
            • lst -- 列表。
          • 返回值
            • 返回 None。
          • 实例
            • 以下展示了使用 shuffle() 方法的实例
              • 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(x, y) 随机生成下一个实数，它在[x,y]范围内。
          • 描述
            • uniform() 方法将随机生成下一个实数，它在 [x,y] 范围内。
          • 语法
            • 以下是 uniform() 方法的语法:
              • import random
              • random.uniform(x, y)
              • 注意：uniform()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
          • 参数
            • x -- 随机数的最小值，包含该值。
            • y -- 随机数的最大值，包含该值。
          • 返回值
            • 返回一个浮点数 N，取值范围为如果 x<y 则 x <= N <= y，如果 y<x 则y <= N <= x。
          • 实例
            • 以下展示了使用 uniform() 方法的实例
              • 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
    • 三角函数
      • 三角函数
        • acos(x) 返回x的反余弦弧度值。
          • 描述
            • acos() 返回x的反余弦弧度值。
          • 语法
            • 以下是 acos() 方法的语法:
              • import math
              • math.acos(x)
              • 注意：acos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- -1到1之间的数值。如果x是大于1，会产生一个错误。
          • 返回值
            • 返回x的反余弦弧度值。
          • 实例
            • 以下展示了使用 acos() 方法的实例
              • 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(x) 返回x的反正弦弧度值。
          • 描述
            • asin() 返回x的反正弦弧度值。
          • 语法
            • 以下是 asin() 方法的语法:
              • import math
              • math.asin(x)
              • 注意：asin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- -1到1之间的数值。如果x是大于1，会产生一个错误。
          • 返回值
            • 返回x的反正弦弧度值。
          • 实例
            • 以下展示了使用 asin() 方法的实例
              • 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(x) 返回x的反正切弧度值。
          • 描述
            • atan() 返回x的反正切弧度值。
          • 语法
            • 以下是 atan() 方法的语法:
              • import math
              • math.atan(x)
              • 注意：atan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个数值。
          • 返回值
            • 返回x的反正切弧度值。
          • 实例
            • 以下展示了使用 atan() 方法的实例
              • 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(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
          • 描述
            • atan2() 返回给定的 X 及 Y 坐标值的反正切值。
          • 语法
            • 以下是 atan2() 方法的语法:
              • import math
              • math.atan2(y, x)
              • 注意：atan2()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个数值。
            • y -- 一个数值。
          • 返回值
            • 返回给定的 X 及 Y 坐标值的反正切值。
          • 实例
            • 以下展示了使用 atan2() 方法的实例
              • 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(x) 返回x的弧度的余弦值。
          • 描述
            • cos() 返回x的弧度的余弦值。
          • 语法
            • 以下是 cos() 方法的语法:
              • import math
              • math.cos(x)
              • 注意：cos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个数值。
          • 返回值
            • 返回x的弧度的余弦值,-1 到 1 之间。
          • 实例
            • 以下展示了使用 cos() 方法的实例
              • 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))
                • 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))
        • hypot(x, y) 返回欧几里德范数 sqrt(x*x + y*y)。
          • 描述
            • hypot() 返回欧几里德范数 sqrt(x*x + y*y)。
          • 语法
            • 以下是 hypot() 方法的语法:
              • import math
              • math.hypot(x, y)
              • 注意：hypot()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个数值。
            • y -- 一个数值。
          • 返回值
            • 返回欧几里德范数 sqrt(x*x + y*y)。
          • 实例
            • 以下展示了使用 hypot() 方法的实例
              • 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(x) 返回的x弧度的正弦值。
          • 描述
            • sin() 返回的x弧度的正弦值。
          • 语法
            • 以下是 sin() 方法的语法:
              • import math
              • math.sin(x)
              • 注意：sin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个数值。
          • 返回值
            • 返回的x弧度的正弦值，数值在 -1 到 1 之间。
          • 实例
            • 以下展示了使用 sin() 方法的实例
              • 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(x) 返回x弧度的正切值。
          • 描述
            • tan() 返回 x 弧度的正切值。
          • 语法
            • 以下是 tan() 方法的语法:
              • import math
              • math.tan(x)
              • 注意：tan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个数值。
          • 返回值
            • 返回 x 弧度的正切值，数值在 -1 到 1 之间。
          • 实例
            • 以下展示了使用 tan() 方法的实例
              • 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(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
          • 描述
            • degrees() 将弧度转换为角度。
          • 语法
            • 以下是 degrees() 方法的语法:
              • import math
              • math.degrees(x)
              • 注意：degrees()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个数值。
          • 返回值
            • 返回一个角度值。
          • 实例
            • 以下展示了使用 degrees() 方法的实例
              • 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(x) 将角度转换为弧度
          • 描述
            • radians() 方法将角度转换为弧度。
              • 角度和弧度关系是：2π 弧度 = 360°。从而 1°≈0.0174533 弧度，1 弧度≈57.29578°。
              • 1) 角度转换为弧度公式：弧度=角度÷180×π
              • 2)弧度转换为角度公式： 角度=弧度×180÷π
          • 语法
            • 以下是 radians() 方法的语法:
              • import math
              • math.radians(x)
              • 注意：radians()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
          • 参数
            • x -- 一个角度数值，默认单位是角度 °。
          • 返回值
            • 返回一个角度的弧度值。
          • 实例
            • 以下展示了使用 radians() 方法的实例
              • import math print ("radians(90) : ", math.radians(90)) # 1 弧度等于大概 57.3° print ("radians(45) : ", math.radians(45)) print ("radians(30) : ", math.radians(30)) print ("radians(180) : ", math.radians(180)) # 180 度的弧度为 π print("180 / pi : ", end ="") print (math.radians(180 / math.pi))
                • radians(90) : 1.5707963267948966 radians(45) : 0.7853981633974483 radians(30) : 0.5235987755982988 radians(180) : 3.141592653589793 180 / pi : 1.0
    • 数学常量
      • 常量 描述 pi 数学常量 pi（圆周率，一般以π来表示） e 数学常量 e，e即自然常数（自然常数）
  • 字符串
    • 介绍
      • 字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串
      • 创建字符串很简单，只要为变量分配一个值即可
        • var1 = 'Hello World!' var2 = "Work"
    • python访问字符串的值
      • Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用
      • Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式
        • 变量[头下标:尾下标]
      • 索引值以 0 为开始值，-1 为从末尾的开始位置
        • • • 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字符串更新
      • 你可以截取字符串的一部分并与其他字段拼接
        • var1 = 'Hello World!' print ("已更新字符串 : ", var1[:6] + 'Runoob!')
          • 实例执行结果
            • 已更新字符串 : Hello Runoob!
      • 在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符
    • python转义字符
      • 转义字符 描述 实例 \(在行尾时) 续行符 >>> print("line1 \ ... line2 \ ... line3") line1 line2 line3 \\ 反斜杠符号 >>> print("\\") \ \' 单引号 >>> print('\'') ' \" 双引号 >>> print("\"") " \a 响铃 >>> print("\a")执行后电脑有响声。 \b 退格(Backspace) >>> print("Hello \b World!") Hello World! \000 空 >>> print("\000") >>> \n 换行 >>> print("\n") >>> \v 纵向制表符 >>> print("Hello \v World!") Hello World! \t 横向制表符 >>> print("Hello \t World!") Hello World! \r 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 >>> print("Hello\rWorld!") World! >>> print('google runoob taobao\r123456') 123456 runoob taobao \f 换页 >>> print("Hello \f World!") Hello World! \yyy 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 >>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World! \xyy 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 >>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World! \other 其它的字符以普通格式输出
    • python字符串运算符
      • 实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"
        • 操作符 描述 实例 + 字符串连接 a + b 输出结果： HelloPython * 重复输出字符串 a*2 输出结果：HelloHello [] 通过索引获取字符串中字符 a[1] 输出结果 e [ : ] 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 a[1:4] 输出结果 ell in 成员运算符 - 如果字符串中包含给定的字符返回 True 'H' in a 输出结果 True not in 成员运算符 - 如果字符串中不包含给定的字符返回 True 'M' not in a 输出结果 True r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 print( r'\n' ) print( R'\n' ) % 格式字符串 请看下一节内容。
          • 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 的字符串中。
        • 字符串格式化使用与 C 中 sprintf 函数一样的语法
      • print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
        • 我叫 小明 今年 10 岁!
      • python字符串格式化符号
        • 符 号 描述 %c 格式化字符及其ASCII码 %s 格式化字符串 %d 格式化整数 %u 格式化无符号整型 %o 格式化无符号八进制数 %x 格式化无符号十六进制数 %X 格式化无符号十六进制数（大写） %f 格式化浮点数字，可指定小数点后的精度 %e 用科学计数法格式化浮点数 %E 作用同%e，用科学计数法格式化浮点数 %g %f和%e的简写 %G %f 和 %E 的简写 %p 用十六进制数格式化变量的地址
      • 格式化操作符辅助指令
        • 符号 功能 * 定义宽度或者小数点精度 - 用做左对齐 + 在正数前面显示加号( + ) <sp> 在正数前面显示空格 # 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') 0 显示的数字前面填充'0'而不是默认的空格 % '%%'输出一个单一的'%' (var) 映射变量(字典参数) m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
      • Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
        • Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。 基本语法是通过 {} 和 : 来代替以前的 % 。 format 函数可以接受不限个参数，位置可以不按顺序。
          • >>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 'hello world' >>> "{0} {1}".format("hello", "world") # 设置指定位置 'hello world' >>> "{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'
    • python三引号
      • python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
        • 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) ''')
    • f-String
      • f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
      • 之前我们习惯用百分号 (%):
        • >>> name = 'Runoob' >>> 'Hello %s' % name 'Hello Runoob'
      • f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去
        • >>> name = 'word' >>> f'Hello {name}' # 替换变量 'Hello word' >>> f'{1+2}' # 使用表达式 '3' >>> w = {'name': 'word', 'url': 'www.word.com'} >>> f'{w["name"]}: {w["url"]}' 'word: www.word.com'
          • 用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d
          • 在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果
            • >>> x = 1 >>> print(f'{x+1}') # Python 3.6 2 >>> x = 1 >>> print(f'{x+1=}') # Python 3.8 x+1=2
    • Unicode字符串
      • 在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u
      • 在Python3中，所有的字符串都是Unicode字符串
    • python的字符串内建函数
      • capitalize()
        • 将字符串的第一个字符转换为大写
          • 描述
            • Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。
          • 语法
            • capitalize()方法语法：
              • str.capitalize()
          • 参数
            • 无。
          • 返回值
            • 该方法返回一个首字母大写的字符串。
          • 实例
            • 以下实例展示了capitalize()方法的实例
              • str = "this is string example from runoob....wow!!!" print ("str.capitalize() : ", str.capitalize())
                • str.capitalize() : This is string example from runoob....wow!!!
      • center(width, fillchar)
        • 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
          • 语法
            • center()方法语法：
              • str.center(width[, fillchar])
          • 参数
            • width -- 字符串的总宽度。
              • fillchar -- 填充字符。
          • 返回值
            • 返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。
          • 实例
            • 以下实例展示了center()方法的实例
              • str = "[runoob]" print ("str.center(40, '*') : ", str.center(40, '*'))
                • str.center(40, '*') : ****************[runoob]****************
      • count(str, beg= 0,end=len(string))
        • 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
          • 描述
            • count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
          • 语法
            • count()方法语法：
              • str.count(sub, start= 0,end=len(string))
          • 参数
            • sub -- 搜索的子字符串
              • start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
                • end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
          • 返回值
            • 该方法返回子字符串在字符串中出现的次数。
          • 实例
            • 以下实例展示了count()方法的实例
              • 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(encoding="utf-8", errors="strict")
        • Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
          • 描述
            • 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()方法的实例
              • 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(encoding='UTF-8',errors='strict')
        • 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
          • 描述
            • 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()方法的实例
              • 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(suffix, beg=0, end=len(string))
        • 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
          • 描述
            • endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 "start" 与 "end" 为检索字符串的开始与结束位置。
          • 语法
            • endswith()方法语法：
              • str.endswith(suffix[, start[, end]])
          • 参数
            • suffix -- 该参数可以是一个字符串或者是一个元素。
              • start -- 字符串中的开始位置。
                • end -- 字符中结束位置。
          • 返回值
            • 如果字符串含有指定的后缀返回 True，否则返回 False。
          • 实例
            • 以下实例展示了endswith()方法的实例
              • 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(tabsize=8)
        • 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
          • 描述
            • expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
          • 语法
            • expandtabs() 方法语法：
              • str.expandtabs(tabsize=8)
          • 参数
            • tabsize -- 指定转换字符串中的 tab 符号 \t 转为空格的字符数。
          • 返回值
            • 该方法返回字符串中的 tab 符号 \t 转为空格后生成的新字符串。
          • 实例
            • 以下实例展示了 expandtabs() 方法的实例
              • str = "runoob\t12345\tabc" print('原始字符串:', str) # 默认 8 个空格 # runnob 有 6 个字符，后面的 \t 填充 2 个空格 # 12345 有 5 个字符，后面的 \t 填充 3 个空格 print('替换 \\t 符号:', str.expandtabs()) # 2 个空格 # runnob 有 6 个字符，刚好是 2 的 3 倍，后面的 \t 填充 2 个空格 # 12345 有 5 个字符，不是 2 的倍数，后面的 \t 填充 1 个空格 print('使用 2 个空格替换 \\t 符号:', str.expandtabs(2)) # 3 个空格 print('使用 3 个空格:', str.expandtabs(3)) # 4 个空格 print('使用 4 个空格:', str.expandtabs(4)) # 5 个空格 print('使用 5 个空格:', str.expandtabs(5)) # 6 个空格 print('使用 6 个空格:', str.expandtabs(6))
                • 原始字符串: runoob 12345 abc 替换 \t 符号: runoob 12345 abc 使用 2 个空格替换 \t 符号: runoob 12345 abc 使用 3 个空格: runoob 12345 abc 使用 4 个空格: runoob 12345 abc 使用 5 个空格: runoob 12345 abc 使用 6 个空格: runoob 12345 abc
      • find(str, beg=0, end=len(string))
        • 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
          • 描述
            • find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
          • 语法
            • find()方法语法：
              • str.find(str, beg=0, end=len(string))
          • 参数
            • str -- 指定检索的字符串
              • beg -- 开始索引，默认为0。
                • end -- 结束索引，默认为字符串的长度。
          • 返回值
            • 如果包含子字符串返回开始的索引值，否则返回-1。
          • 实例
            • 以下实例展示了find()方法的实例
              • str1 = "Runoob example....wow!!!" str2 = "exam"; print (str1.find(str2)) print (str1.find(str2, 5)) print (str1.find(str2, 10))
                • 7 7 -1
            • >>>info = 'abca' >>> print(info.find('a')) # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0 0 >>> print(info.find('a', 1)) # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3 3 >>> print(info.find('3')) # 查找不到返回-1 -1
      • index(str, beg=0, end=len(string))
        • 跟find()方法一样，只不过如果str不在字符串中会报一个异常。
          • 描述
            • index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
          • 语法
            • index()方法语法：
              • str.index(str, beg=0, end=len(string))
          • 参数
            • str -- 指定检索的字符串
              • beg -- 开始索引，默认为0。
                • end -- 结束索引，默认为字符串的长度。
          • 返回值
            • 如果包含子字符串返回开始的索引值，否则抛出异常。
          • 实例
            • 以下实例展示了index()方法的实例
              • 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
      • isalnum()
        • 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
          • 描述
            • isalnum() 方法检测字符串是否由字母和数字组成。
          • 语法
            • isalnum()方法语法：
              • str.isalnum()
          • 参数
            • 无。
          • 返回值
            • 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
          • 实例
            • 以下实例展示了isalnum()方法的实例
              • str = "runoob2016" # 字符串没有空格 print (str.isalnum()) str = "www.runoob.com" print (str.isalnum())
                • True False
      • isalpha()
        • 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
          • 描述
            • Python isalpha() 方法检测字符串是否只由字母或文字组成。
          • 语法
            • isalpha()方法语法：
              • str.isalpha()
          • 参数
            • 无。
          • 返回值
            • 如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。
          • 实例
            • 以下实例展示了isalpha()方法的实例
              • str = "runoob" print (str.isalpha()) # 字母和中文文字 str = "runoob菜鸟教程" print (str.isalpha()) str = "Runoob example....wow!!!" print (str.isalpha())
                • True True False
      • isdigit()
        • 如果字符串只包含数字则返回 True 否则返回 False..
          • 描述
            • Python isdigit() 方法检测字符串是否只由数字组成。
          • 语法
            • isdigit()方法语法：
              • str.isdigit()
          • 参数
            • 无。
          • 返回值
            • 如果字符串只包含数字则返回 True 否则返回 False。
          • 实例
            • 以下实例展示了isdigit()方法的实例
              • str = "123456"; print (str.isdigit()) str = "Runoob example....wow!!!" print (str.isdigit())
                • True False
      • islower()
        • 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
          • 描述
            • islower() 方法检测字符串是否由小写字母组成。
          • 语法
            • islower()方法语法：
              • str.islower()
          • 参数
            • 无。
          • 返回值
            • 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
          • 实例
            • 以下实例展示了islower()方法的实例
              • str = "RUNOOB example....wow!!!" print (str.islower()) str = "runoob example....wow!!!" print (str.islower())
                • False True
      • isnumeric()
        • 如果字符串中只包含数字字符，则返回 True，否则返回 False
          • 描述
            • isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。
              • 指数类似 ² 与分数类似 ½ 也属于数字。
                • # s = '½'
                  • s = '\u00BD'
          • 语法
            • isnumeric()方法语法：
              • str.isnumeric()
          • 参数
            • 无。
          • 返回值
            • 如果字符串中只包含数字字符，则返回 True，否则返回 False
          • 实例
            • 以下实例展示了 isnumeric() 方法的实例
              • str = "runoob2016" print (str.isnumeric()) str = "23443434" print (str.isnumeric())
                • False True
            • Unicode 数字
              • #s = '²3455' s = '\u00B23455' print(s.isnumeric()) # s = '½' s = '\u00BD' print(s.isnumeric()) a = "\u0030" #unicode for 0 print(a.isnumeric()) b = "\u00B2" #unicode for ² print(b.isnumeric()) c = "10km2" print(c.isnumeric())
                • True True True True False
      • isspace()
        • 如果字符串中只包含空白，则返回 True，否则返回 False.
          • 描述
            • Python isspace() 方法检测字符串是否只由空白字符组成。
          • 语法
            • isspace() 方法语法：
              • str.isspace()
          • 参数
            • 无。
          • 返回值
            • 如果字符串中只包含空格，则返回 True，否则返回 False.
          • 实例
            • 以下实例展示了isspace()方法的实例
              • str = " " print (str.isspace()) str = "Runoob example....wow!!!" print (str.isspace())
                • True False
      • istitle()
        • 如果字符串是标题化的(见 title())则返回 True，否则返回 False
          • 描述
            • istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
          • 语法
            • istitle()方法语法：
              • str.istitle()
          • 参数
            • 无。
          • 返回值
            • 如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
          • 实例
            • 以下实例展示了istitle()方法的实例
              • str = "This Is String Example...Wow!!!" print (str.istitle()) str = "This is string example....wow!!!" print (str.istitle())
                • True False
      • isupper()
        • 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
          • 描述
            • isupper() 方法检测字符串中所有的字母是否都为大写。
          • 语法
            • isupper()方法语法：
              • str.isupper()
          • 参数
            • 无。
          • 返回值
            • 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
          • 实例
            • 以下实例展示了isupper()方法的实例
              • str = "THIS IS STRING EXAMPLE....WOW!!!" print (str.isupper()) str = "THIS is string example....wow!!!" print (str.isupper())
                • True False
      • join(seq)
        • 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
          • 描述
            • Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
          • 语法
            • join()方法语法：
              • str.join(sequence)
          • 参数
            • sequence -- 要连接的元素序列。
          • 返回值
            • 返回通过指定字符连接序列中元素后生成的新字符串。
          • 实例
            • 以下实例展示了join()的使用方法
              • 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(string)
        • 返回字符串长度
          • 描述
            • Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
          • 语法
            • len()方法语法：
              • len( s )
          • 参数
            • s -- 对象。
          • 返回值
            • 返回对象长度。
          • 实例
            • 以下实例展示了 len() 的使用方法
              • >>>str = "runoob" >>> len(str) # 字符串长度 6 >>> l = [1,2,3,4,5] >>> len(l) # 列表元素个数 5
      • ljust(width[, fillchar])
        • 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
          • 描述
            • ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
          • 语法
            • ljust()方法语法：
              • str.ljust(width[, fillchar])
          • 参数
            • width -- 指定字符串长度。
              • fillchar -- 填充字符，默认为空格。
          • 返回值
            • 返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
          • 实例
            • 以下实例展示了ljust()的使用方法
              • str = "Runoob example....wow!!!" print (str.ljust(50, '*'))
                • Runoob example....wow!!!**************************
      • lower()
        • 转换字符串中所有大写字符为小写.
          • 描述
            • Python lower() 方法转换字符串中所有大写字符为小写。
          • 语法
            • lower()方法语法：
              • str.lower()
          • 参数
            • 无。
          • 返回值
            • 返回将字符串中所有大写字符转换为小写后生成的字符串。
          • 实例
            • 以下实例展示了lower()的使用方法
              • str = "Runoob EXAMPLE....WOW!!!" print( str.lower() )
                • runoob example....wow!!!
      • lstrip()
        • 截掉字符串左边的空格或指定字符。
          • 描述
            • lstrip() 方法用于截掉字符串左边的空格或指定字符。
          • 语法
            • lstrip()方法语法：
              • str.lstrip([chars])
          • 参数
            • chars --指定截取的字符。
          • 返回值
            • 返回截掉字符串左边的空格或指定字符后生成的新字符串。
          • 实例
            • 以下实例展示了lstrip()的使用方法
              • 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()
        • 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
          • 描述
            • maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
              • 两个字符串的长度必须相同，为一一对应的关系。
                • 注：Python3.4 已经没有 string.maketrans() 了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans() 。
          • 语法
            • maketrans()方法语法：
              • str.maketrans(intab, outtab)
          • 参数
            • intab -- 字符串中要替代的字符组成的字符串。
              • outtab -- 相应的映射字符的字符串。
          • 返回值
            • 返回字符串转换后生成的新字符串。
          • 实例
            • 以下实例展示了使用maketrans() 方法将所有元音字母转换为指定的数字
              • 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(str)
        • 返回字符串 str 中最大的字母。
          • 描述
            • max() 方法返回字符串中最大的字母。
          • 语法
            • max()方法语法：
              • max(str)
          • 参数
            • str -- 字符串。
          • 返回值
            • 返回字符串中最大的字母。
          • 实例
            • 以下实例展示了max()函数的使用方法
              • str = "runoob" print ("最大字符: " + max(str))
                • 最大字符: u
      • min(str)
        • 返回字符串 str 中最小的字母。
          • 描述
            • Python min() 方法返回字符串中最小的字母。
          • 语法
            • min()方法语法：
              • min(str)
          • 参数
            • str -- 字符串。
          • 返回值
            • 返回字符串中最小的字母。
          • 实例
            • 以下实例展示了min()函数的使用方法
              • str = "runoob"; print ("最小字符: " + min(str))
                • 最小字符: b
      • replace(old, new [, max])
        • 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
          • 描述
            • replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
          • 语法
            • replace()方法语法：
              • str.replace(old, new[, max])
          • 参数
            • old -- 将被替换的子字符串。
              • new -- 新字符串，用于替换old子字符串。
                • max -- 可选字符串, 替换不超过 max 次
          • 返回值
            • 返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
          • 实例
            • 以下实例展示了replace()函数的使用方法
              • 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(str, beg=0,end=len(string))
        • 类似于 find()函数，不过是从右边开始查找.
          • 描述
            • Python rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
          • 语法
            • rfind()方法语法：
              • str.rfind(str, beg=0 end=len(string))
          • 参数
            • str -- 查找的字符串
              • beg -- 开始查找的位置，默认为0
                • end -- 结束查找位置，默认为字符串的长度。
          • 返回值
            • 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
          • 实例
            • 以下实例展示了rfind()函数的使用方法
              • 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( str, beg=0, end=len(string))
        • 类似于 index()，不过是从右边开始.
          • 描述
            • rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
          • 语法
            • rindex()方法语法：
              • str.rindex(str, beg=0 end=len(string))
          • 参数
            • str -- 查找的字符串
              • beg -- 开始查找的位置，默认为0
                • end -- 结束查找位置，默认为字符串的长度。
          • 返回值
            • 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。
          • 实例
            • 以下实例展示了rindex()函数的使用方法
              • 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(width,[, fillchar])
        • 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
          • 描述
            • rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
          • 语法
            • rjust()方法语法：
              • str.rjust(width[, fillchar])
          • 参数
            • width -- 指定填充指定字符后中字符串的总长度.
              • fillchar -- 填充的字符，默认为空格。
          • 返回值
            • 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
          • 实例
            • 以下实例展示了rjust()函数的使用方法
              • str = "this is string example....wow!!!" print (str.rjust(50, '*'))
                • ******************this is string example....wow!!!
      • rstrip()
        • 删除字符串末尾的空格或指定字符。
          • 描述
            • rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
          • 语法
            • rstrip()方法语法：
              • str.rstrip([chars])
          • 参数
            • chars -- 指定删除的字符（默认为空白符）
          • 返回值
            • 返回删除 string 字符串末尾的指定字符后生成的新字符串。
          • 实例
            • 以下实例展示了 rstrip() 函数的使用方法
              • random_string = 'this is good ' # 字符串末尾的空格会被删除 print(random_string.rstrip()) # 'si oo' 不是尾随字符，因此不会删除任何内容 print(random_string.rstrip('si oo')) # 在 'sid oo' 中 'd oo' 是尾随字符，'ood' 从字符串中删除 print(random_string.rstrip('sid oo')) # 'm/' 是尾随字符，没有找到 '.' 号的尾随字符, 'm/' 从字符串中删除 website = 'www.runoob.com/' print(website.rstrip('m/.')) # 移除逗号(,)、点号(.)、字母 s、q 或 w，这几个都是尾随字符 txt = "banana,,,,,ssqqqww....." x = txt.rstrip(",.qsw") print(x) # 删除尾随字符 * str = "*****this is string example....wow!!!*****" print (str.rstrip('*'))
                • this is good this is good this is g www.runoob.co banana *****this is string example....wow!!!
      • split(str="", num=string.count(str))
        • 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
          • 描述
            • split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
          • 语法
            • split() 方法语法：
              • str.split(str="", num=string.count(str))
          • 参数
            • str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
              • num -- 分割次数。默认为 -1, 即分隔所有。
          • 返回值
            • 返回分割后的字符串列表。
          • 实例
            • 以下实例展示了 split() 函数的使用方法
              • str = "this is string example....wow!!!" print (str.split( )) # 以空格为分隔符 print (str.split('i',1)) # 以 i 为分隔符 print (str.split('w')) # 以 w 为分隔符
                • ['this', 'is', 'string', 'example....wow!!!'] ['th', 's is string example....wow!!!'] ['this is string example....', 'o', '!!!']
            • 以下实例以 # 号为分隔符，指定第二个参数为 1，返回两个参数列表
              • txt = "Google#Runoob#Taobao#Facebook" # 第二个参数为 1，返回两个参数列表 x = txt.split("#", 1) print(x)
                • ['Google', 'Runoob#Taobao#Facebook']
      • splitlines([keepends])
        • 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
          • 描述
            • 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(substr, beg=0,end=len(string))
        • 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
          • 描述
            • startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
          • 语法
            • startswith()方法语法：
              • str.startswith(substr, beg=0,end=len(string));
          • 参数
            • str -- 检测的字符串。
              • substr -- 指定的子字符串。
                • strbeg -- 可选参数用于设置字符串检测的起始位置。
                  • strend -- 可选参数用于设置字符串检测的结束位置。
          • 返回值
            • 如果检测到字符串则返回True，否则返回False。
          • 实例
            • 以下实例展示了startswith()函数的使用方法
              • str = "this is string example....wow!!!" print (str.startswith( 'this' )) # 字符串是否以 this 开头 print (str.startswith( 'string', 8 )) # 从第九个字符开始的字符串是否以 string 开头 print (str.startswith( 'this', 2, 4 )) # 从第2个字符开始到第四个字符结束的字符串是否以 this 开头
                • True True False
      • strip([chars])
        • 在字符串上执行 lstrip()和 rstrip()
          • 描述
            • Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
              • 注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
          • 语法
            • strip()方法语法：
              • str.strip([chars]);
          • 参数
            • chars -- 移除字符串头尾指定的字符序列。
          • 返回值
            • 返回移除字符串头尾指定的字符序列生成的新字符串。
          • 实例
            • 以下实例展示了 strip() 函数的使用方法
              • str = "*****this is **string** example....wow!!!*****" print (str.strip( '*' )) # 指定字符串 *
                • this is **string** example....wow!!!
                • 从结果上看，可以注意到中间部分的字符并未删除
            • 只要头尾包含有指定字符序列中的字符就删除
              • str = "123abcrunoob321" print (str.strip( '12' )) # 字符序列为 12
                • 3abcrunoob3
      • swapcase()
        • 将字符串中大写转换为小写，小写转换为大写
          • 描述
            • Python swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。
          • 语法
            • swapcase() 方法语法：
              • str.swapcase();
          • 参数
            • NA。
          • 返回值
            • 返回大小写字母转换后生成的新字符串。
          • 实例
            • 以下实例展示了 swapcase() 函数的使用方法
              • str = "RUNOOB!!!"; print ( str.swapcase() ); str = "runoob!!!"; print ( str.swapcase() ); str = "abCDE--RuNOob!!!"; print ( str.swapcase() );
                • runoob!!! RUNOOB!!! ABcde--rUnoOB!!!
      • title()
        • 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
          • 描述
            • Python title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写(见 istitle())。
          • 语法
            • title()方法语法：
              • str.title();
          • 参数
            • NA。
          • 返回值
            • 返回"标题化"的字符串,就是说所有单词的首字母都转化为大写。
          • 实例
            • 以下实例展示了 title()函数的使用方法
              • str = "this is string example from runoob....wow!!!" print (str.title())
                • This Is String Example From Runoob....Wow!!!
            • 请注意，非字母后的第一个字母将转换为大写字母
              • txt = "hello b2b2b2 and 3g3g3g" x = txt.title() print(x)
                • Hello B2B2B2 And 3G3G3G
      • translate(table, deletechars="")
        • 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
          • 描述
            • translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。
          • 语法
            • translate()方法语法：
              • str.translate(table)
                • bytes.translate(table[, delete])
                  • bytearray.translate(table[, delete])
          • 参数
            • table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
              • deletechars -- 字符串中要过滤的字符列表。
          • 返回值
            • 返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射 。
          • 实例
            • 以下实例展示了 translate() 函数的使用方法
              • 描述 translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。 语法 translate()方法语法： str.translate(table) bytes.translate(table[, delete]) bytearray.translate(table[, delete]) 参数 table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。 deletechars -- 字符串中要过滤的字符列表。 返回值 返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射 。 实例 以下实例展示了 translate() 函数的使用方法
                • th3s 3s str3ng 2x1mpl2....w4w!!!
            • 如何过滤掉的字符 o
              • # 制作翻译表 bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ') # 转换为大写，并删除字母o print(b'runoob'.translate(bytes_tabtrans, b'o'))
                • b'RUNB'
      • upper()
        • 转换字符串中的小写字母为大写
          • 描述
            • Python upper() 方法将字符串中的小写字母转为大写字母。
          • 语法
            • upper()方法语法：
              • str.upper()
          • 参数
            • NA。
          • 返回值
            • 返回小写字母转为大写字母的字符串。
          • 实例
            • 以下实例展示了 upper()函数的使用方法
              • str = "this is string example from runoob....wow!!!"; print ("str.upper() : ", str.upper())
                • str.upper() : THIS IS STRING EXAMPLE FROM RUNOOB....WOW!!!
      • zfill (width)
        • 返回长度为 width 的字符串，原字符串右对齐，前面填充0
          • 描述
            • Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
          • 语法
            • zfill()方法语法：
              • str.zfill(width)
          • 参数
            • width -- 指定字符串的长度。原字符串右对齐，前面填充0。
          • 返回值
            • 返回指定长度的字符串。
          • 实例
            • 以下实例展示了 zfill()函数的使用方法
              • 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()
        • 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
          • 描述
            • isdecimal() 方法检查字符串是否只包含十进制字符。
          • 语法
            • isdecimal() 方法语法：
              • str.isdecimal()
          • 参数
            • 无
          • 返回值
            • True - 如果字符串中的所有字符都是十进制字符。
              • False - 至少一个字符不是十进制字符。
          • 实例
            • 以下实例展示了 isdecimal() 函数的使用方法
              • str = "runoob2016" print (str.isdecimal()) str = "23443434" print (str.isdecimal())
                • False True
  • 列表List
    • 介绍
      • 序列是 Python 中最基本的数据结构
      • 序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推
      • Python 有 6 个序列的内置类型，但最常见的是列表和元组
      • 列表都可以进行的操作包括索引，切片，加，乘，检查成员
      • 此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法
      • 列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现
      • 列表的数据项不需要具有相同的类型
      • 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
        • list1 = ['Google', 'Runoob', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ["a", "b", "c", "d"] list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
    • 访问列表中的值
      • 与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。 通过索引列表可以进行截取、组合等操作。
        • • list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[0] ) print( list[1] ) print( list[2] )
            • red green blue
      • 索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推
        • • list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[-1] ) print( list[-2] ) print( list[-3] )
            • black white yellow
      • 使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符
        • • nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] print(nums[0:4])
            • [10, 20, 30, 40]
      • 使用负数索引值截取
        • list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"] # 读取第二位 print ("list[1]: ", list[1]) # 从第二位开始（包含）截取到倒数第二位（不包含） print ("list[1:-2]: ", list[1:-2])
          • list[1]: Runoob list[1:-2]: ['Runoob', 'Zhihu']
    • 更新列表
      • 你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项
        • list = ['Google', 'Runoob', 1997, 2000] print ("第三个元素为 : ", list[2]) list[2] = 2001 print ("更新后的第三个元素为 : ", list[2]) list1 = ['Google', 'Runoob', 'Taobao'] list1.append('Baidu') print ("更新后的列表 : ", list1)
          • 注意：我们会在接下来的章节讨论 append() 方法的使用。
          • 第三个元素为 : 1997 更新后的第三个元素为 : 2001 更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']
    • 删除列表中的元素
      • 可以使用 del 语句来删除列表的的元素
        • list = ['Google', 'Runoob', 1997, 2000] print ("原始列表 : ", list) del list[2] print ("删除第三个元素 : ", list)
          • 原始列表 : ['Google', 'Runoob', 1997, 2000] 删除第三个元素 : ['Google', 'Runoob', 2000]
            • 注意：我们会在接下来的章节讨论 remove() 方法的使用
    • python列表脚本操作符
      • 列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
        • Python 表达式 结果 描述 len([1, 2, 3]) 3 长度 [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合 ['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复 3 in [1, 2, 3] True 元素是否存在于列表中 for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代
    • python列表截取与拼接
      • Python的列表截取与字符串操作类型
        • L=['Google', 'baidu', 'Taobao']
      • 操作
        • Python 表达式 结果 描述 L[2] 'Taobao' 读取第三个元素 L[-2] 'baidu' 从右侧开始读取倒数第二个元素: count from the right L[1:] ['baidu', 'Taobao'] 输出从第二个元素开始后的所有元素
      • 列表还支持拼接操作
        • >>>squares = [1, 4, 9, 16, 25] >>> squares += [36, 49, 64, 81, 100] >>> squares [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包含以下函数
        • 1 len(list)
          • 列表元素个数
            • 描述
              • len() 方法返回列表元素个数。
            • 语法
              • len()方法语法：
                • len(list)
            • 参数
              • list -- 要计算元素个数的列表。
            • 返回值
              • 返回列表元素个数。
            • 实例
              • 以下实例展示了 len()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao'] print (len(list1)) list2=list(range(5)) # 创建一个 0-4 的列表 print (len(list2))
                  • 3 5
        • 2 max(list)
          • 返回列表元素最大值
            • 描述
              • max() 方法返回列表元素中的最大值。
            • 语法
              • max()方法语法：
                • max(list)
            • 参数
              • list -- 要返回最大值的列表。
            • 返回值
              • 返回列表元素中的最大值。
            • 实例
              • 以下实例展示了 max()函数的使用方法
                • list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200] print ("list1 最大元素值 : ", max(list1)) print ("list2 最大元素值 : ", max(list2))
                  • list1 最大元素值 : Taobao list2 最大元素值 : 700
        • 3 min(list)
          • 返回列表元素最小值
            • 描述
              • min() 方法返回列表元素中的最小值。
            • 语法
              • min()方法语法：
                • min(list)
            • 参数
              • list -- 要返回最小值的列表。
            • 返回值
              • 返回列表元素中的最小值。
            • 实例
              • 以下实例展示了 min()函数的使用方法
                • list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200] print ("list1 最小元素值 : ", min(list1)) print ("list2 最小元素值 : ", min(list2))
                  • list1 最小元素值 : Google list2 最小元素值 : 200
        • 4 list(seq)
          • 将元组转换为列表
            • 描述
              • list() 方法用于将元组或字符串转换为列表。
                • 注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
            • 语法
              • list()方法语法：
                • list( seq )
            • 参数
              • seq -- 要转换为列表的元组或字符串。
            • 返回值
              • 返回列表。
            • 实例
              • 以下实例展示了 list()函数的使用方法
                • 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']
      • Python包含以下方法
        • 1 list.append(obj)
          • 在列表末尾添加新的对象
            • 描述
              • append() 方法用于在列表末尾添加新的对象。
            • 语法
              • append()方法语法：
                • list.append(obj)
            • 参数
              • obj -- 添加到列表末尾的对象。
            • 返回值
              • 该方法无返回值，但是会修改原来的列表。
            • 实例
              • 以下实例展示了 append()函数的使用方
                • list1 = ['Google', 'Runoob', 'Taobao'] list1.append('Baidu') print ("更新后的列表 : ", list1)
                  • 更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']
        • 2 list.count(obj)
          • 统计某个元素在列表中出现的次数
            • 描述
              • count() 方法用于统计某个元素在列表中出现的次数。
            • 语法
              • count()方法语法：
                • list.count(obj)
            • 参数
              • obj -- 列表中统计的对象。
            • 返回值
              • 返回元素在列表中出现的次数。
            • 实例
              • 以下实例展示了 count()函数的使用方法
                • aList = [123, 'Google', 'Runoob', 'Taobao', 123]; print ("123 元素个数 : ", aList.count(123)) print ("Runoob 元素个数 : ", aList.count('Runoob'))
                  • 123 元素个数 : 2 Runoob 元素个数 : 1
        • 3 list.extend(seq)
          • 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
            • 描述
              • extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
            • 语法
              • extend()方法语法：
                • list.extend(seq)
            • 参数
              • seq -- 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。
            • 返回值
              • 该方法没有返回值，但会在已存在的列表中添加新的列表内容。
            • 实例
              • 以下实例展示了 extend()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao'] list2=list(range(5)) # 创建 0-4 的列表 list1.extend(list2) # 扩展列表 print ("扩展后的列表：", list1)
                  • 扩展后的列表： ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]
              • 不同数据类型
                • # 语言列表 language = ['French', 'English', 'German'] # 元组 language_tuple = ('Spanish', 'Portuguese') # 集合 language_set = {'Chinese', 'Japanese'} # 添加元组元素到列表末尾 language.extend(language_tuple) print('新列表: ', language) # 添加集合元素到列表末尾 language.extend(language_set) print('新列表: ', language)
                  • 新列表: ['French', 'English', 'German', 'Spanish', 'Portuguese'] 新列表: ['French', 'English', 'German', 'Spanish', 'Portuguese', 'Chinese', 'Japanese']
        • 4 list.index(obj)
          • 从列表中找出某个值第一个匹配项的索引位置
            • 描述
              • index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
            • 语法
              • index()方法语法：
                • list.index(x[, start[, end]])
            • 参数
              • x-- 查找的对象。
                • start-- 可选，查找的起始位置。
                  • end-- 可选，查找的结束位置。
            • 返回值
              • 该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
            • 实例
              • 以下实例展示了 index()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao'] print ('Runoob 索引值为', list1.index('Runoob')) print ('Taobao 索引值为', list1.index('Taobao'))
                  • Runoob 索引值为 1 Taobao 索引值为 2
        • 5 list.insert(index, obj)
          • 将对象插入列表
            • 描述
              • insert() 函数用于将指定对象插入列表的指定位置。
            • 语法
              • insert()方法语法：
                • list.insert(index, obj)
            • 参数
              • index -- 对象obj需要插入的索引位置。
                • obj -- 要插入列表中的对象。
            • 返回值
              • 该方法没有返回值，但会在列表指定位置插入对象。
            • 实例
              • 以下实例展示了 insert()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao'] list1.insert(1, 'Baidu') print ('列表插入元素后为 : ', list1)
                  • 列表插入元素后为 : ['Google', 'Baidu', 'Runoob', 'Taobao']
        • 6 list.pop([index=-1])
          • 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
            • 描述
              • pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
            • 语法
              • pop()方法语法：
                • list.pop([index=-1])
            • 参数
              • index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
            • 返回值
              • 该方法返回从列表中移除的元素对象。
            • 实例
              • 以下实例展示了 pop()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao'] list1.pop() print ("列表现在为 : ", list1) list1.pop(1) print ("列表现在为 : ", list1)
                  • 列表现在为 : ['Google', 'Runoob'] 列表现在为 : ['Google']
        • 7 list.remove(obj)
          • 移除列表中某个值的第一个匹配项
            • 描述
              • remove() 函数用于移除列表中某个值的第一个匹配项。
            • 语法
              • remove()方法语法：
                • list.remove(obj)
            • 参数
              • obj -- 列表中要移除的对象。
            • 返回值
              • 该方法没有返回值但是会移除列表中的某个值的第一个匹配项。
            • 实例
              • 以下实例展示了 remove()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.remove('Taobao') print ("列表现在为 : ", list1) list1.remove('Baidu') print ("列表现在为 : ", list1)
                  • 表现在为 : ['Google', 'Runoob', 'Baidu'] 列表现在为 : ['Google', 'Runoob']
        • 8 list.reverse()
          • 反向列表中元素
            • 描述
              • reverse() 函数用于反向列表中元素。
            • 语法
              • reverse()方法语法：
                • list.reverse()
            • 参数
              • NA。
            • 返回值
              • 该方法没有返回值，但是会对列表的元素进行反向排序。
            • 实例
              • 以下实例展示了 reverse()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.reverse() print ("列表反转后: ", list1)
                  • 列表反转后: ['Baidu', 'Taobao', 'Runoob', 'Google']
        • 9 list.sort( key=None, reverse=False)
          • 对原列表进行排序
            • 描述
              • sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
            • 语法
              • sort()方法语法：
                • list.sort( key=None, reverse=False)
            • 参数
              • key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
                • reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
            • 返回值
              • 该方法没有返回值，但是会对列表的对象进行排序。
            • 实例
              • 以下实例展示了 sort() 函数的使用方法
                • aList = ['Google', 'Runoob', 'Taobao', 'Facebook'] aList.sort() print ( "List : ", aList)
                  • List : ['Facebook', 'Google', 'Runoob', 'Taobao']
              • 以下实例降序输出列表
                • # 列表 vowels = ['e', 'a', 'u', 'o', 'i'] # 降序 vowels.sort(reverse=True) # 输出结果 print ( '降序输出:', vowels )
                  • 降序输出: ['u', 'o', 'i', 'e', 'a']
              • 以下实例演示了通过指定列表中的元素排序来输出列表
                • # 获取列表的第二个元素 def takeSecond(elem): return elem[1] # 列表 random = [(2, 2), (3, 4), (4, 1), (1, 3)] # 指定第二个元素排序 random.sort(key=takeSecond) # 输出类别 print ('排序列表：', random)
                  • 排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]
        • 10 list.clear()
          • 清空列表
            • 描述
              • clear() 函数用于清空列表，类似于 del a[:]。
            • 语法
              • clear()方法语法：
                • list.clear()
            • 参数
              • 无。
            • 返回值
              • 该方法没有返回值。
            • 实例
              • 以下实例展示了 clear()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.clear() print ("列表清空后 : ", list1)
                  • 列表清空后 : []
        • 11 list.copy()
          • 复制列表
            • 描述
              • copy() 函数用于复制列表，类似于 a[:]。
            • 语法
              • copy()方法语法：
                • list.copy()
            • 参数
              • 无。
            • 返回值
              • 返回复制后的新列表。
            • 实例
              • 以下实例展示了 copy()函数的使用方法
                • list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list2 = list1.copy() print ("list2 列表: ", list2)
                  • list2 列表: ['Google', 'Runoob', 'Taobao', 'Baidu']
  • 元组Tuple
    • 介绍
      • Python 的元组与列表类似，不同之处在于元组的元素不能修改
      • 元组使用小括号 ( )，列表使用方括号 [ ]
      • 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
        • • >>> tup1 = ('Google', 'Runoob', 1997, 2000) >>> tup2 = (1, 2, 3, 4, 5 ) >>> tup3 = "a", "b", "c", "d" # 不需要括号也可以 >>> type(tup3) <class 'tuple'>
      • 创建空元组
        • tup1 = ()
      • 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用
        • >>> tup1 = (50) >>> type(tup1) # 不加逗号，类型为整型 <class 'int'> >>> tup1 = (50,) >>> type(tup1) # 加上逗号，类型为元组 <class 'tuple'>
      • 元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等
    • 访问元组
      • 元组可以使用下标索引来访问元组中的值
        • 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)
    • 修改元组
      • 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
        • tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3)
          • (12, 34.56, 'abc', 'xyz')
    • 删除元组
      • 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
        • 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
    • 元组运算符
      • 与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组
        • Python 表达式 结果 描述 len((1, 2, 3)) 3 计算元素个数 (1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接 ('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') 复制 3 in (1, 2, 3) True 元素是否存在 for x in (1, 2, 3): print (x,) 1 2 3 迭代
    • 元组索引，截取
      • 因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素
        • 元组
          • tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
            • • Python 表达式 结果 描述 tup[1] 'Runoob' 读取第二个元素 tup[-2] 'Weibo' 反向读取，读取倒数第二个元素 tup[1:] ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') 截取元素，从第二个开始后的所有元素。 tup[1:4] ('Runoob', 'Taobao', 'Wiki') 截取元素，从第二个开始到第四个元素（索引为 3）。
                • >>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin') >>> tup[1] 'Runoob' >>> tup[-2] 'Weibo' >>> tup[1:] ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') >>> tup[1:4] ('Runoob', 'Taobao', 'Wiki')
    • 元组内置函数
      • Python元组包含了以下内置函数
        • 序号 方法及描述 实例 1 len(tuple) 计算元组元素个数。 >>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> 2 max(tuple) 返回元组中元素最大值。 >>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> 3 min(tuple) 返回元组中元素最小值。 >>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> 4 tuple(iterable) 将可迭代系列转换为元组。 >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')
    • 相关元组是不可变的
      • 所谓元组的不可变指的是元组所指向的内存中的内容不可变
        • >>> tup = ('r', 'u', 'n', 'o', 'o', 'b') >>> tup[0] = 'g' # 不支持修改元素 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> id(tup) # 查看内存地址 4440687904 >>> tup = (1,2,3) >>> id(tup) 4441088800 # 内存地址不一样了
          • 从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。
  • 字典Dictionary
    • 介绍
      • 字典是另一种可变容器模型，且可存储任意类型对象
      • 字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示
        • d = {key1 : value1, key2 : value2, key3 : value3 }
      • 注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
      • 键必须是唯一的，但值则不必
        • 值可以取任何数据类型，但键必须是不可变的，如字符串，数字
          • tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
            • • 也可如此创建字典
              • tinydict1 = { 'abc': 456 } tinydict2 = { 'abc': 123, 98.6: 37 }
    • 创建字典
      • 使用大括号 { } 创建空字典
        • # 使用大括号 {} 来创建空字典 emptyDict = {} # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:", len(emptyDict)) # 查看类型 print(type(emptyDict))
          • 输出结果
          • {} Length: 0 <class 'dict'>
      • 使用内建函数 dict() 重建字典
        • emptyDict = dict() # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:",len(emptyDict)) # 查看类型 print(type(emptyDict))
          • 输出结果
          • {} Length: 0 <class 'dict'>
    • 访问字典的值
      • 把相应的键放入到方括号中
        • tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} print ("tinydict['Name']: ", tinydict['Name']) print ("tinydict['Age']: ", tinydict['Age'])
          • 输出结果
          • tinydict['Name']: Runoob tinydict['Age']: 7
      • 如果用字典里没有的键访问数据，会输出错误
        • tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} print ("tinydict['Alice']: ", tinydict['Alice'])
          • 输出结果
          • Traceback (most recent call last): File "test.py", line 5, in <module> print ("tinydict['Alice']: ", tinydict['Alice']) KeyError: 'Alice'
    • 修改字典
      • 向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值
        • tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} tinydict['Age'] = 8 # 更新 Age tinydict['School'] = "京东" # 添加信息 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School'])
          • 输出结果
          • tinydict['Age']: 8 tinydict['School']: 京东
    • 删除字典元素
      • 能删单一的元素也能清空字典，清空只需一项操作。 显示删除一个字典用del命令
        • tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} del tinydict['Name'] # 删除键 'Name' tinydict.clear() # 清空字典 del tinydict # 删除字典 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School'])
          • 但这会引发一个异常，因为用执行 del 操作后字典不再存在
            • Traceback (most recent call last): File "/runoob-test/test.py", line 9, in <module> print ("tinydict['Age']: ", tinydict['Age']) NameError: name 'tinydict' is not defined
    • 字典键的特性
      • 字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。 两个重要的点需要记住
        • 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
          • tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'} print ("tinydict['Name']: ", tinydict['Name'])
            • tinydict['Name']: 小菜鸟
        • 2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
          • tinydict = {['Name']: 'Runoob', 'Age': 7} print ("tinydict['Name']: ", tinydict['Name'])
            • Traceback (most recent call last): File "test.py", line 3, in <module> tinydict = {['Name']: 'Runoob', 'Age': 7} TypeError: unhashable type: 'list'
    • 字典内置函数&方法
      • 内置函数
        • 函数及描述 实例 len(dict) 计算字典元素个数，即键的总数。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(tinydict) 3 str(dict) 输出字典，可以打印的字符串表示。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(tinydict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}" type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(tinydict) <class 'dict'>
      • 内置方法
        • 1 radiansdict.clear()
          • 删除字典内所有元素
            • 描述
              • Python 字典 clear() 函数用于删除字典内所有元素。
            • 语法
              • clear()方法语法：
                • dict.clear()
            • 参数
              • NA。
            • 返回值
              • 该函数没有任何返回值。
            • 实例
              • 以下实例展示了 clear()函数的使用方法
                • tinydict = {'Name': 'Zara', 'Age': 7} print ("字典长度 : %d" % len(tinydict)) tinydict.clear() print ("字典删除后长度 : %d" % len(tinydict))
                  • 字典长度 : 2 字典删除后长度 : 0
        • 2 radiansdict.copy()
          • 返回一个字典的浅复制
            • 描述
              • Python 字典 copy() 函数返回一个字典的浅复制。
            • 语法
              • copy()方法语法：
                • dict.copy()
            • 参数
              • NA。
            • 返回值
              • 返回一个字典的浅复制。
            • 实例
              • 以下实例展示了 copy()函数的使用方法
                • dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} dict2 = dict1.copy() print ("新复制的字典为 : ",dict2)
                  • 新复制的字典为 : {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}
            • 直接赋值和 copy 的区别
              • 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]}
            • Python 直接赋值、浅拷贝和深度拷贝解析
              • 直接赋值：其实就是对象的引用（别名）。
              • 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
              • 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象
              • 字典浅拷贝实例
                • >>>a = {1: [1,2,3]} >>> b = a.copy() >>> a, b ({1: [1, 2, 3]}, {1: [1, 2, 3]}) >>> a[1].append(4) >>> a, b ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
              • 深度拷贝需要引入 copy 模块
                • >>>import copy >>> c = copy.deepcopy(a) >>> a, c ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}) >>> a[1].append(5) >>> a, c ({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})
                • 1、b = a: 赋值引用，a 和 b 都指向同一个对象。
                • 2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。
                • b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
              • 以下实例是使用 copy 模块的 copy.copy（ 浅拷贝 ）和（copy.deepcopy ）
                • import copy a = [1, 2, 3, 4, ['a', 'b']] #原始对象 b = a #赋值，传对象的引用 c = copy.copy(a) #对象拷贝，浅拷贝 d = copy.deepcopy(a) #对象拷贝，深拷贝 a.append(5) #修改对象a a[4].append('c') #修改对象a中的['a', 'b']数组对象 print( 'a = ', a ) print( 'b = ', b ) print( 'c = ', c ) print( 'd = ', d )
                  • ('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5]) ('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5]) ('c = ', [1, 2, 3, 4, ['a', 'b', 'c']]) ('d = ', [1, 2, 3, 4, ['a', 'b']])
        • 3 radiansdict.fromkeys()
          • 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
            • 描述
              • Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
            • 语法
              • fromkeys() 方法语法：
                • dict.fromkeys(seq[, value])
            • 参数
              • seq -- 字典键值列表。
              • value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。
            • 返回值
              • 该方法返回一个新字典。
            • 实例
              • 以下实例展示了 fromkeys()函数的使用方法
                • seq = ('name', 'age', 'sex') tinydict = dict.fromkeys(seq) print ("新的字典为 : %s" % str(tinydict)) tinydict = dict.fromkeys(seq, 10) print ("新的字典为 : %s" % str(tinydict))
                  • 新的字典为 : {'age': None, 'name': None, 'sex': None} 新的字典为 : {'age': 10, 'name': 10, 'sex': 10}
              • 不指定值
                • x = ('key1', 'key2', 'key3') thisdict = dict.fromkeys(x) print(thisdict)
                  • {'key1': None, 'key2': None, 'key3': None}
        • 4 radiansdict.get(key, default=None)
          • 返回指定键的值，如果键不在字典中返回 default 设置的默认值
            • 描述
              • Python 字典 get() 函数返回指定键的值。
            • 语法
              • get()方法语法：
                • dict.get(key, default=None)
            • 参数
              • key -- 字典中要查找的键。
                • default -- 如果指定的键不存在时，返回该默认值。
            • 返回值
              • 返回指定键的值，如果键不在字典中返回默认值 None 或者指定的默认值。
            • 实例
              • 以下实例展示了 get() 函数的使用方法
                • tinydict = {'Name': 'Runoob', 'Age': 27} print ("Age 值为 : %s" % tinydict.get('Age')) print ("Sex 值为 : %s" % tinydict.get('Sex', "NA"))
                  • Age 值为 : 27 Sex 值为 : NA
        • 5 key in dict
          • 如果键在字典dict里返回true，否则返回false
            • 描述
              • Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
                • 而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。
            • 语法
              • in 操作符语法：
                • key in dict
            • 参数
              • key -- 要在字典中查找的键。
            • 返回值
              • 如果键在字典里返回true，否则返回false。
            • 实例
              • 以下实例展示了 in 操作符在字典中的使用方法
                • thisdict = {'Name': 'Runoob', 'Age': 7} # 检测键 Age 是否存在 if 'Age' in thisdict: print("键 Age 存在") else : print("键 Age 不存在") # 检测键 Sex 是否存在 if 'Sex' in thisdict: print("键 Sex 存在") else : print("键 Sex 不存在") # not in # 检测键 Age 是否存在 if 'Age' not in thisdict: print("键 Age 不存在") else : print("键 Age 存在")
                  • 键 Age 存在 键 Sex 不存在 键 Age 存在
        • 6 radiansdict.items()
          • 以列表返回一个视图对象
            • 描述
              • Python 字典 items() 方法以列表返回视图对象，是一个可遍历的key/value 对。
                • dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
                  • 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
                  • 我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
            • 语法
              • items()方法语法：
                • dict.items()
            • 参数
              • NA。
            • 返回值
              • 返回可视图对象。
            • 实例
              • 以下实例展示了 items() 方法的使用方法
                • tinydict = {'Name': 'Runoob', 'Age': 7} print ("Value : %s" % tinydict.items())
                  • Value : dict_items([('Age', 7), ('Name', 'Runoob')])
        • 7 radiansdict.keys()
          • 返回一个视图对象
            • 描述
              • Python3 字典 keys() 方法返回一个视图对象。
                • dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
                  • 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
                  • 我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
                  • 注意：Python2.x 是直接返回列表
            • 语法
              • keys()方法语法：
                • dict.keys()
            • 参数
              • NA。
            • 返回值
              • 返回一个视图对象。
            • 实例
              • 以下实例展示了 keys() 方法的使用方法
                • >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500} >>> keys = dishes.keys() >>> values = dishes.values() >>> # 迭代 >>> n = 0 >>> for val in values: ... n += val >>> print(n) 504 >>> # keys 和 values 以相同顺序（插入顺序）进行迭代 >>> list(keys) # 使用 list() 转换为列表 ['eggs', 'sausage', 'bacon', 'spam'] >>> list(values) [2, 1, 1, 500] >>> # 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化 >>> del dishes['eggs'] >>> del dishes['sausage'] >>> list(keys) ['bacon', 'spam']
        • 8 radiansdict.setdefault(key, default=None)
          • 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
            • 描述
              • Python 字典 setdefault() 方法和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
            • 语法
              • setdefault()方法语法：
                • dict.setdefault(key, default=None)
            • 参数
              • key -- 查找的键值。
                • default -- 键不存在时，设置的默认键值。
            • 返回值
              • 如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
            • 实例
              • 以下实例展示了 setdefault() 方法的使用方法
                • tinydict = {'Name': 'Runoob', 'Age': 7} print ("Age 键的值为 : %s" % tinydict.setdefault('Age', None)) print ("Sex 键的值为 : %s" % tinydict.setdefault('Sex', None)) print ("新字典为：", tinydict)
                  • Age 键的值为 : 7 Sex 键的值为 : None 新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}
        • 9 radiansdict.update(dict2)
          • 把字典dict2的键/值对更新到dict里
            • 描述
              • Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
            • 语法
              • update() 方法语法：
                • dict.update(dict2)
            • 参数
              • dict2 -- 添加到指定字典dict里的字典。
            • 返回值
              • 该方法没有任何返回值。
            • 实例
              • 以下实例展示了 update()函数的使用方法
                • tinydict = {'Name': 'Runoob', 'Age': 7} tinydict2 = {'Sex': 'female' } tinydict.update(tinydict2) print ("更新字典 tinydict : ", tinydict)
                  • 更新字典 tinydict : {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}
        • 10 radiansdict.values()
          • 返回一个视图对象
            • 描述
              • Python3 字典 values() 方法返回一个视图对象。
                • dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
                  • 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
                  • 我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
            • 语法
              • values()方法语法：
                • dict.values()
            • 参数
              • NA。
            • 返回值
              • 返回视图对象。
            • 以下实例展示了 values() 方法的使用方法
              • >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500} >>> keys = dishes.keys() >>> values = dishes.values() >>> # 迭代 >>> n = 0 >>> for val in values: ... n += val >>> print(n) 504 >>> # keys 和 values 以相同顺序（插入顺序）进行迭代 >>> list(keys) # 使用 list() 转换为列表 ['eggs', 'sausage', 'bacon', 'spam'] >>> list(values) [2, 1, 1, 500] >>> # 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化 >>> del dishes['eggs'] >>> del dishes['sausage'] >>> list(values) [1, 500] >>> #相同两个 dict.values() 比较返回都是 False >>> d = {'a': 1} >>> d.values() == d.values() False
        • 11 pop(key[,default])
          • 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
            • 描述
              • Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
            • 语法
              • pop()方法语法：
                • pop(key[,default])
            • 参数
              • key: 要删除的键值
                • default: 如果没有 key，返回 default 值
            • 返回值
              • 返回被删除的值。
            • 实例
              • 以下实例展示了 pop() 方法的使用方法
                • >>> site= {'name': '百度', 'alexa': 10000, 'url': 'www.runoob.com'} >>> pop_obj=site.pop('name') >>> print(pop_obj) 百度
        • 12 popitem()
          • 随机返回并删除字典中的最后一对键和值。
            • 描述
              • Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。
                • 如果字典已经为空，却调用了此方法，就报出KeyError异常。
            • 语法
              • popitem()方法语法：
                • popitem()
            • 参数
              • 无
            • 返回值
              • 返回一个键值对(key,value)形式，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。
            • 实例
              • 以下实例展示了 popitem() 方法的使用方法
                • site= {'name': '百度', 'alexa': 10000, 'url': 'www.baidu.com'} pop_obj=site.popitem() print(pop_obj) print(site)
                  • ('url', 'www.baidu.com') {'name': '百度', 'alexa': 10000}
  • 集合Set
    • 介绍
      • 集合（set）是一个无序的不重复元素序列
      • 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
        • parame = {value01,value02,...} 或者 set(value)
          • >>> 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', '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的元素 {'r', 'd', 'b', 'm', 'z', 'l'}
      • 类似列表推导式，同样集合支持集合推导式(Set comprehension)
        • >>> a = {x for x in 'abracadabra' if x not in 'abc'} >>> a {'r', 'd'}
    • 集合的基本操作
      • 1.添加元素
        • 语法格式
          • s.add( x )
        • 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作
          • >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.add("Facebook") >>> print(thisset) {'Taobao', 'Facebook', 'Google', 'Runoob'}
        • 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式
          • s.update( x )
        • x 可以有多个，用逗号分开
          • >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.update({1,3}) >>> print(thisset) {1, 3, 'Google', 'Taobao', 'Runoob'} >>> thisset.update([1,4],[5,6]) >>> print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
      • 2.移除元素
        • 语法格式
          • s.remove( x )
            • 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
              • >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.remove("Taobao") >>> print(thisset) {'Google', 'Runoob'} >>> thisset.remove("Facebook") # 不存在会发生错误 Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'Facebook'
        • 此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式
          • s.discard( x )
            • >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.discard("Facebook") # 不存在不会发生错误 >>> print(thisset) {'Taobao', 'Google', 'Runoob'}
        • 我们也可以设置随机删除集合中的一个元素，语法格式
          • s.pop()
            • thisset = set(("Google", "Runoob", "Taobao", "Facebook")) x = thisset.pop() print(x)
              • 输出结果
              • Runoob
        • 多次执行测试结果都不一样
        • set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除
      • 3.计算集合元素个数
        • 语法格式
          • len(s)
            • 计算集合 s 元素个数
              • >>> thisset = set(("Google", "Runoob", "Taobao")) >>> len(thisset) 3
      • 4.清空集合
        • 语法格式
          • s.clear()
        • 清空集合 s
          • >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.clear() >>> print(thisset) set()
      • 5.判断元素是否在集合中存在
        • 语法格式
          • x in s
            • 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False
              • >>> thisset = set(("Google", "Runoob", "Taobao")) >>> "Runoob" in thisset True >>> "Facebook" in thisset False
    • 集合内置方法完整列表
      • 方法 描述 add() 为集合添加元素 clear() 移除集合中的所有元素 copy() 拷贝一个集合 difference() 返回多个集合的差集 difference_update() 移除集合中的元素，该元素在指定的集合也存在。 discard() 删除集合中指定的元素 intersection() 返回集合的交集 intersection_update() 返回集合的交集。 isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 issubset() 判断指定集合是否为该方法参数集合的子集。 issuperset() 判断该方法的参数集合是否为指定集合的子集 pop() 随机移除元素 remove() 移除指定元素 symmetric_difference() 返回两个集合中不重复的元素集合。 symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 union() 返回两个集合的并集 update() 给集合添加元素
        • add() 为集合添加元素
          • 描述 add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
          • 语法 add()方法语法
            • set.add(elmnt)
          • 参数
            • elmnt -- 必需，要添加的元素。
          • 返回值
            • 无。
          • 实例
            • 以下实例展示了 add() 方法的使用
              • fruits = {"apple", "banana", "cherry"} fruits.add("orange") print(fruits)
                • {'apple', 'banana', 'orange', 'cherry'}
            • 已存在的元素，则不执行添加操作
              • fruits = {"apple", "banana", "cherry"} fruits.add("apple") print(fruits)
                • {'apple', 'banana', 'cherry'}
        • clear() 移除集合中的所有元素
          • 描述
            • clear() 方法用于移除集合中的所有元素。
          • 语法
            • clear()方法语法：
              • set.clear()
          • 实例
            • 移除 fruits 集合中的所有元素
              • fruits = {"apple", "banana", "cherry"} fruits.clear() print(fruits)
                • set()
        • copy() 拷贝一个集合
          • 描述
            • copy() 方法用于拷贝一个集合。
          • 语法
            • copy() 方法语法：
              • set.copy()
          • 实例
            • 拷贝 fruits 集合
              • fruits = {"apple", "banana", "cherry"} x = fruits.copy() print(x)
                • {'cherry', 'banana', 'apple'}
        • difference() 返回多个集合的差集
          • 描述
            • difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。
          • 语法
            • difference() 方法语法：
              • set.difference(set)
          • 参数
            • set -- 必需，用于计算差集的集合
          • 返回值
            • 返回一个新的集合。
          • 实例
            • 返回一个集合，元素包含在集合 x ，但不在集合 y
              • x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"} z = x.difference(y) print(z)
                • {'cherry', 'banana'}
        • difference_update() 移除集合中的元素，该元素在指定的集合也存在。
          • 描述
            • difference_update() 方法用于移除两个集合中都存在的元素。
              • difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。
          • 语法
            • difference_update() 方法语法：
              • set.difference_update(set)
          • 参数
            • set -- 必需，用于计算差集的集合
          • 实例
            • 移除两个集合都包含的元素
              • x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"} x.difference_update(y) print(x)
                • {'cherry', 'banana'}
        • discard() 删除集合中指定的元素
          • 描述
            • discard() 方法用于移除指定的集合元素。
              • 该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
          • 语法
            • discard() 方法语法：
              • set.discard(value)
          • 参数
            • value -- 必需，要移除的元素
          • 实例
            • 移除集合中的元素 banana
              • fruits = {"apple", "banana", "cherry"} fruits.discard("banana") print(fruits)
                • {'cherry', 'apple'}
        • intersection() 返回集合的交集
          • 描述
            • intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。
          • 语法
            • intersection() 方法语法：
              • set.intersection(set1, set2 ... etc)
          • 参数
            • set1 -- 必需，要查找相同元素的集合
            • set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开
          • 返回值
            • 返回一个新的集合。
          • 实例
            • 返回一个新集合，该集合的元素既包含在集合 x 又包含在集合 y 中
              • x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.intersection(y) print(z)
                • {'apple'}
        • intersection_update() 返回集合的交集。
          • 描述
            • intersection_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集。
              • intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。
          • 语法
            • intersection_update() 方法语法：
              • set.intersection_update(set1, set2 ... etc)
          • 参数
            • set1 -- 必需，要查找相同元素的集合
            • set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开
          • 返回值
            • 无。
          • 实例
            • 移除 x 集合中不存在于 y 集合中的元素
              • x = {"apple", "banana", "cherry"} # y 集合不包含 banana 和 cherry，被移除 y = {"google", "runoob", "apple"} x.intersection_update(y) print(x)
                • {'apple'}
            • 计算多个集合的并集
              • x = {"a", "b", "c"} y = {"c", "d", "e"} z = {"f", "g", "c"} x.intersection_update(y, z) print(x)
                • {'c'}
        • isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
          • 描述
            • isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。。
          • 语法
            • isdisjoint() 方法语法：
            • set.isdisjoint(set)
          • 参数
            • set -- 必需，要比较的集合
          • 返回值
            • 返回布尔值，如果不包含返回 True，否则返回 False。
          • 实例
            • 判断集合 y 中是否有包含 集合 x 的元素
              • x = {"apple", "banana", "cherry"} y = {"google", "runoob", "facebook"} z = x.isdisjoint(y) print(z)
                • True
            • 如果包含返回 Fals
              • x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.isdisjoint(y) print(z)
                • False
        • issubset() 判断指定集合是否为该方法参数集合的子集。
          • 描述
            • issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。
          • 语法
            • issubset() 方法语法：
            • set.issubset(set)
          • 参数
            • set -- 必需，要比查找的集合
          • 返回值
            • 返回布尔值，如果都包含返回 True，否则返回 False。
          • 实例
            • 判断集合 x 的所有元素是否都包含在集合 y 中
              • x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"} z = x.issubset(y) print(z)
                • True
            • 如果没有全部包含返回 False
              • x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b"} z = x.issubset(y) print(z)
                • False
        • issuperset() 判断该方法的参数集合是否为指定集合的子集
          • 描述
            • issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。
          • 语法
            • issuperset() 方法语法：
              • set.issuperset(set)
          • 参数
            • set -- 必需，要比查找的集合
          • 返回值
            • 返回布尔值，如果都包含返回 True，否则返回 False。
          • 实例
            • 判断集合 y 的所有元素是否都包含在集合 x 中
              • x = {"f", "e", "d", "c", "b", "a"} y = {"a", "b", "c"} z = x.issuperset(y) print(z)
                • True
            • 如果没有全部包含返回 False
              • x = {"f", "e", "d", "c", "b"} y = {"a", "b", "c"} z = x.issuperset(y) print(z)
                • False
        • pop() 随机移除元素
          • 描述
            • pop() 方法用于随机移除一个元素。
          • 语法
            • pop() 方法语法：
              • set.pop()
          • 参数
            • 无
          • 返回值
            • 返回移除的元素。
          • 实例
            • 随机移除一个元素
              • fruits = {"apple", "banana", "cherry"} fruits.pop() print(fruits)
                • {'apple', 'banana'}
            • 输出返回值
              • fruits = {"apple", "banana", "cherry"} x = fruits.pop() print(x)
                • banana
        • remove() 移除指定元素
          • 描述
            • remove() 方法用于移除集合中的指定元素。
              • 该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
          • 语法
            • remove() 方法语法：
              • set.remove(item)
          • 参数
            • item -- 要移除的元素
          • 返回值
            • 没有返回值。
          • 实例
            • 移除元素 banana
              • fruits = {"apple", "banana", "cherry"} fruits.remove("banana") print(fruits)
                • {'cherry', 'apple'}
        • symmetric_difference() 返回两个集合中不重复的元素集合。
          • 描述
            • symmetric_difference() 方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。
          • 语法
            • symmetric_difference() 方法语法：
              • set.symmetric_difference(set)
          • 参数
            • set -- 集合
          • 返回值
            • 返回一个新的集合。
          • 实例
            • 返回两个集合组成的新集合，但会移除两个集合的重复元素
              • x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.symmetric_difference(y) print(z)
                • {'google', 'cherry', 'banana', 'runoob'}
        • symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
          • 描述
            • symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
          • 语法
            • symmetric_difference_update() 方法语法：
              • set.symmetric_difference_update(set)
          • 参数
            • set -- 要检测的集合
          • 返回值
            • 无。
          • 实例
            • 在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中
              • x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.symmetric_difference_update(y) print(x)
                • {'google', 'cherry', 'banana', 'runoob'}
        • union() 返回两个集合的并集
          • 描述
            • union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。
          • 语法
            • union() 方法语法：
              • set.union(set1, set2...)
          • 参数
            • set1 -- 必需，合并的目标集合
            • set2 -- 可选，其他要合并的集合，可以多个，多个使用逗号 , 隔开。
          • 返回值
            • 返回一个新集合。
          • 实例
            • 合并两个集合，重复元素只会出现一次
              • x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.union(y) print(z)
                • {'cherry', 'runoob', 'google', 'banana', 'apple'}
            • 合并多个集合
              • x = {"a", "b", "c"} y = {"f", "d", "a"} z = {"c", "d", "e"} result = x.union(y, z) print(result)
                • {'c', 'd', 'f', 'e', 'b', 'a'}
        • update() 给集合添加元素
          • 描述
            • update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
          • 语法
            • update() 方法语法：
              • set.update(set)
          • 参数
            • set -- 必需，可以是元素或集合
          • 返回值
            • 无。
          • 实例
            • 合并两个集合，重复元素只会出现一次
              • x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.update(y) print(x)
                • {'banana', 'apple', 'google', 'runoob', 'cherry'}
  • 条件控制
    • 介绍
      • 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语句
      • 实例
        • 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 内的语句没有执行
      • 以下实例演示了狗的年龄计算判断
        • 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中常用的操作运算符
        • 操作符 描述 < 小于 <= 小于或等于 > 大于 >= 大于或等于 == 等于，比较两个值是否相等 != 不等于
          • # 程序演示了 == 操作符 # 使用数字 print(5 == 6) # 使用变量 x = 5 y = 8 print(x == y)
            • False False
      • high_low.py文件演示了数字的比较运算
        • # 该实例演示了数字猜谜游戏 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: 语句
      • 实例
        • 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")
          • $ python3 test.py 输入一个数字：6 你输入的数字可以整除 2 和 3
  • 循环语句
    • 介绍
      • Python 中的循环语句有 for 和 while。
      • Python 循环语句的控制结构图如下所示
    • while 循环
      • Python 中 while 语句的一般形式
        • while 判断条件(condition)： 执行语句(statements)……
      • 执行流程图如下
      • 同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环
      • 以下实例使用了 while 来计算 1 到 100 的总和
        • n = 100 sum = 0 counter = 1 while counter <= n: sum = sum + counter counter += 1 print("1 到 %d 之和为: %d" % (n,sum))
          • 1 到 100 之和为: 5050
    • 无限循环
      • 我们可以通过设置条件表达式永远不为 false 来实现无限循环
        • var = 1 while var == 1 : # 表达式永远为 true num = int(input("输入一个数字 :")) print ("你输入的数字是: ", num) print ("Good bye!")
          • 输入一个数字 :5 你输入的数字是: 5 输入一个数字 :
      • 你可以使用 CTRL+C 来退出当前的无限循环。 无限循环在服务器上客户端的实时请求非常有用
    • while循环使用else语句
      • 如果 while 后面的条件语句为 false 时，则执行 else 的语句块
      • 语法格式如下
        • while <expr>: <statement(s)> else: <additional_statement(s)>
      • expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。 循环输出数字，并判断大小
        • 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写在同一行中， 如下所示
        • flag = 1 while (flag): print ('欢迎访问菜鸟教程!') print ("Good bye!")
          • 注意：以上的无限循环你可以使用 CTRL+C 来中断循环
            • 欢迎访问菜鸟教程! 欢迎访问菜鸟教程! 欢迎访问菜鸟教程! 欢迎访问菜鸟教程! 欢迎访问菜鸟教程! ……
    • for语句
      • Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串
      • for循环的一般格式如下
        • for <variable> in <sequence>: <statements> else: <statements>
      • 流程图
      • Python for 循环实例
        • >>>languages = ["C", "C++", "Perl", "Python"] >>> for x in languages: ... print (x) ... C C++ Perl Python >>>
      • 以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体
        • 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 执行流程图
      • continue 执行流程图
      • while 语句代码执行过程
      • for 语句代码执行过程
      • break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
      • continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
      • 实例
        • while 中使用 break
          • n = 5 while n > 0: n -= 1 if n == 2: break print(n) print('循环结束。')
            • 4 3 循环结束。
        • while 中使用 continue
          • n = 5 while n > 0: n -= 1 if n == 2: continue print(n) print('循环结束。')
            • 4 3 1 0 循环结束。
        • 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!
        • 以下实例循环字符串 Runoob，碰到字母 o 跳过输出
          • 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 终止时不执行。
      • 如下实例用于查询质数的循环例子:
        • 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 语句块
        • 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!
    • Python 循环嵌套
      • Python 语言允许在一个循环体里面嵌入另一个循环。
      • Python for 循环嵌套语法：
        • for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s)
      • Python while 循环嵌套语法：
        • while expression: while expression: statement(s) statement(s)
      • 你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。
      • 实例：
        • 以下实例使用了嵌套循环输出2~100之间的素数：
          • # -*- coding: UTF-8 -*- i = 2 while(i < 100): j = 2 while(j <= (i/j)): if not(i%j): break j = j + 1 if (j > i/j) : print i, " 是素数" i = i + 1 print "Good bye!"
            • 2 是素数 3 是素数 5 是素数 7 是素数 11 是素数 13 是素数 17 是素数 19 是素数 23 是素数 29 是素数 31 是素数 37 是素数 41 是素数 43 是素数 47 是素数 53 是素数 59 是素数 61 是素数 67 是素数 71 是素数 73 是素数 79 是素数 83 是素数 89 是素数 97 是素数 Good bye!
  • 迭代器与生成器
    • 迭代器
      • 介绍
        • 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
        • 迭代器是一个可以记住遍历的位置的对象。
        • 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
        • 迭代器有两个基本的方法：iter() 和 next()。
        • 字符串，列表或元组对象都可用于创建迭代器
          • >>> list=[1,2,3,4] >>> it = iter(list) # 创建迭代器对象 >>> print (next(it)) # 输出迭代器的下一个元素 1 >>> print (next(it)) 2
        • 迭代器对象可以使用常规for语句进行遍历
          • list=[1,2,3,4] it = iter(list) # 创建迭代器对象 for x in it: print (x, end=" ")
            • 1 2 3 4
        • 也可以使用 next() 函数
          • 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
      • 创建迭代器
        • 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
        • 如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。
        • 更多内容查阅：Python3 面向对象
        • __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
        • __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
        • 创建一个返回数字的迭代器，初始值为 1，逐步递增 1：
          • class MyNumbers: def __iter__(self): self.a = 1 return self def __next__(self): x = self.a self.a += 1 return x myclass = MyNumbers() myiter = iter(myclass) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter))
            • 1 2 3 4 5
    • Stoplteration
      • StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代
      • 在 20 次迭代后停止执行
        • class MyNumbers: def __iter__(self): self.a = 1 return self def __next__(self): if self.a <= 20: x = self.a self.a += 1 return x else: raise StopIteration myclass = MyNumbers() myiter = iter(myclass) for x in myiter: print(x)
          • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
    • 生成器
      • 介绍
        • 在 Python 中，使用了 yield 的函数被称为生成器（generator）。
        • 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
        • 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
        • 调用一个生成器函数，返回的是一个迭代器对象。
      • 以下实例使用 yield 实现斐波那契数列
        • 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
  • 函数
    • 介绍
      • 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
      • 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
    • 定义一个函数
      • 你可以定义一个由自己想要功能的函数，以下是简单的规则：
      • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
      • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
      • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
      • 函数内容以冒号 : 起始，并且缩进。
      • return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None
    • 语法
      • Python 定义函数使用 def 关键字，一般格式如下
        • def 函数名（参数列表）: 函数体
      • 默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的
        • 让我们使用函数来输出"Hello World！
          • def hello() : print("Hello World!") hello()
        • 更复杂点的应用，函数中带上参数变量
          • def max(a, b): if a > b: return a else: return b a = 4 b = 5 print(max(a, b))
            • 5
      • 计算面积函数:
        • # 计算面积函数 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() 函数
        • # 定义函数 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传不可变对象
        • 通过 id() 函数来查看内存地址变化
          • def change(a): print(id(a)) # 指向的是同一个对象 a=10 print(id(a)) # 一个新对象 a=1 print(id(a)) change(a)
            • 4379369136 4379369136 4379369424
        • 可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id
      • 传可变对象实例
        • 可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了
          • # 可写函数说明 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() 函数，你必须传入一个参数，不然会出现语法错误
            • #可写函数说明 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() 调用时使用参数名
            • #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str) return #调用printme函数 printme( str = "菜鸟教程")
              • 菜鸟教程
          • 以下实例中演示了函数参数的使用不需要使用指定顺序
            • #可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数 printinfo( age=50, name="runoob" )
              • 名字: runoob 年龄: 50
        • 默认参数
          • 调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值
            • #可写函数说明 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]
          • 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
            • # 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vartuple) # 调用printinfo 函数 printinfo( 70, 60, 50 )
              • 输出: 70 (60, 50)
          • 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例
            • # 可写函数说明 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
          • 还有一种就是参数带两个星号 **基本语法如下
            • def functionname([formal_args,] **var_args_dict ): "函数_文档字符串" function_suite return [expression]
          • 加了两个星号 ** 的参数会以字典的形式导入
            • # 可写函数说明 def printinfo( arg1, **vardict ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vardict) # 调用printinfo 函数 printinfo(1, a=2,b=3)
              • 输出: 1 {'a': 2, 'b': 3}
          • 声明函数时，参数中星号 * 可以单独出现，例如
            • def f(a,b,*,c): return a+b+c
          • 如果单独出现星号 * 后的参数必须用关键字传入
            • >>> def f(a,b,*,c): ... return a+b+c ... >>> f(1,2,3) # 报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: f() takes 2 positional arguments but 3 were given >>> f(1,2,c=3) # 正常 6
    • 匿名函数
      • python 使用 lambda 来创建匿名函数。
      • 所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数
        • lambda 只是一个表达式，函数体比 def 简单很多。
        • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
        • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
        • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
      • 语法
        • lambda 函数的语法只包含一个语句，如下：
          • lambda [arg1 [,arg2,.....argn]]:expression
        • 实例
          • # 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数 print ("相加后的值为 : ", sum( 10, 20 )) print ("相加后的值为 : ", sum( 20, 20 ))
            • 相加后的值为 : 30 相加后的值为 : 40
    • return语句
      • return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法
        • # 可写函数说明 def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print ("函数内 : ", total) return total # 调用sum函数 total = sum( 10, 20 ) print ("函数外 : ", total)
          • 函数内 : 30 函数外 : 30
    • 强制位置参数
      • Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
      • 在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参
        • def f(a, b, /, c, d, *, e, f): print(a, b, c, d, e, f)
      • 以下使用方法是正确的
        • f(10, 20, 30, d=40, e=50, f=60)
      • 以下使用方法会发生错误
        • f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式 f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式
  • 数据结构
    • 列表
      • Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
      • 以下是 Python 中列表的方法
        • 方法 描述 list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。 list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。 list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。 list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。 list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。） list.clear() 移除列表中的所有项，等于del a[:]。 list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。 list.count(x) 返回 x 在列表中出现的次数。 list.sort() 对列表中的元素进行排序。 list.reverse() 倒排列表中的元素。 list.copy() 返回列表的浅复制，等于a[:]。
      • 下面示例演示了列表的大部分方法
        • >>> 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
  • 模块
    • 介绍
      • 在前面的几个章节中我们基本上是用 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，需要把命令放在脚本的顶端
        • #!/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__属性来使该程序块仅在该模块自身运行时执行。
        • # Filename: using_name.py if __name__ == '__main__': print('程序自身在运行') else: print('我来自另一模块')
          • $ python using_name.py 程序自身在运行
          • >>> import using_name 我来自另一模块 >>>
      • 说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
      • 说明：__name__ 与 __main__ 底下是双下划线， _ _ 是这样去掉中间的那个空格。
    • dir（）函数
      • 内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
        • >>> 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('Runoob!') Runoob! 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 是一个不区分大小写的系统。
      • 在 Windows 平台平台上，我们无法确定一个叫做 ECHO.py 的文件导入为模块是 echo 还是 Echo，或者是 ECHO。
      • 为了解决这个问题，我们只需要提供一个精确包的索引。
      • 导入语句遵循如下规则：如果包定义文件 __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被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。
      • 这个功能并不常用，一般用来扩展包里面的模块。
  • 输入和输出
    • 在前面几个章节中，我们其实已经接触了 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)) ... Google ==> 1 Runoob ==> 2 Taobao ==> 3
      • 如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
      • 最简单的就是传入一个字典, 然后使用方括号 [] 来访问键值 :
        • >>> 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() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。
      • 实例
        • str = input("请输入："); print ("你输入的内容是: ", str)
          • 这会产生如下的对应着输入的结果：
            • 请输入：菜鸟教程 你输入的内容是: 菜鸟教程
    • 读和写文件
      • open() 将会返回一个 file 对象，基本语法格式如下:
        • open(filename, mode)
      • filename：包含了你要访问的文件名称的字符串值。
      • mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
      • 不同模式打开文件的完全列表
        • 模式 描述
        • r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
        • rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
        • r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
        • rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
        • w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        • ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        • a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
        • ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
      • 下图很好的总结了这几种模式：
        • 模式 r r+ w w+ a a+ 读 + + + + 写 + + + + + 创建 + + + + 覆盖 + + 指针在开始 + + + + 指针在结尾 + +
      • 以下实例将字符串写入到文件 foo.txt 中：
        • # 打开一个文件 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 已存在（上面实例中已创建）：
          • # 打开一个文件 f = open("/tmp/foo.txt", "r") str = f.read() print(str) # 关闭打开的文件 f.close()
            • Python 是一个非常好的语言。 是的，的确非常好!!
      • f.readline()
        • f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
          • # 打开一个文件 f = open("/tmp/foo.txt", "r") str = f.readline() print(str) # 关闭打开的文件 f.close()
            • Python 是一个非常好的语言。
      • f.readlins()
        • f.readlines() 将返回该文件中包含的所有行。
        • 如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
          • # 打开一个文件 f = open("/tmp/foo.txt", "r") str = f.readlines() print(str) # 关闭打开的文件 f.close()
            • ['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']
        • 另一种方式是迭代一个文件对象然后读取每行:
          • # 打开一个文件 f = open("/tmp/foo.txt", "r") for line in f: print(line, end='') # 关闭打开的文件 f.close()
            • Python 是一个非常好的语言。 是的，的确非常好!!
        • 这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用。
      • f.write()
        • f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
        • 实例
          • # 打开一个文件 f = open("/tmp/foo.txt", "w") num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" ) print(num) # 关闭打开的文件 f.close()
            • 29
        • 如果要写入一些不是字符串的东西, 那么将需要先进行转换:
          • # 打开一个文件 f = open("/tmp/foo1.txt", "w") value = ('www.runoob.com', 14) s = str(value) f.write(s) # 关闭打开的文件 f.close()
            • $ 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
        • 当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:
          • >>> 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
        • 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
        • 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()
  • File（文件）方法
    • open（）方法
      • Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
      • 注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
      • open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
        • open(file, mode='r')
      • 完整的语法格式为：
        • open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
      • 参数说明:
        • file: 必需，文件路径（相对或者绝对路径）。
        • mode: 可选，文件打开模式
        • buffering: 设置缓冲
        • encoding: 一般使用utf8
        • errors: 报错级别
        • newline: 区分换行符
        • closefd: 传入的file参数类型
        • opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
      • mode 参数有：
        • 模式 描述
        • t 文本模式 (默认)。
        • x 写模式，新建一个文件，如果该文件已存在则会报错。
        • b 二进制模式。
        • + 打开一个文件进行更新(可读可写)。
        • U 通用换行模式（Python 3 不支持）。
        • r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
        • rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
        • r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
        • rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
        • w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
        • w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
        • a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        • ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        • a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
        • ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
      • 默认为文本模式，如果要以二进制模式打开，加上 b 。
    • file对象
      • file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：
        • file.close()
          • 关闭文件。关闭后文件不能再进行读写操作。
            • 概述
              • close() 方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作， 否则会触发 ValueError 错误。 close() 方法允许调用多次。
              • 当 file 对象，被引用到操作另外一个文件时，Python 会自动关闭之前的 file 对象。 使用 close() 方法关闭文件是一个好的习惯。
            • 语法
              • close() 方法语法如下：
                • fileObject.close();
            • 参数
              • 无
            • 返回值
              • 该方法没有返回值。
            • 实例
              • 以下实例演示了 close() 方法的使用：
                • # 打开文件 fo = open("runoob.txt", "wb") print("文件名为: ", fo.name) # 关闭文件 fo.close()
                  • 文件名为: runoob.txt
        • file.flush()
          • 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
            • 概述
              • flush() 方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。
              • 一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。
            • 语法
              • flush() 方法语法如下：
                • fileObject.flush();
            • 参数
              • 无
            • 返回值
              • 该方法没有返回值。
            • 实例
              • 以下实例演示了 flush() 方法的使用：
                • # 打开文件 fo = open("runoob.txt", "wb") print ("文件名为: ", fo.name) # 刷新缓冲区 fo.flush() # 关闭文件 fo.close()
                  • 文件名为: runoob.txt
        • file.fileno()
          • 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
            • 概述
              • fileno() 方法返回一个整型的文件描述符(file descriptor FD 整型)，可用于底层操作系统的 I/O 操作。
            • 语法
              • fileno() 方法语法如下：
                • fileObject.fileno();
            • 参数
              • 无
            • 返回值
              • 返回文件描述符。
            • 实例
              • 以下实例演示了 fileno() 方法的使用：
                • # 打开文件 fo = open("runoob.txt", "wb") print ("文件名为: ", fo.name) fid = fo.fileno() print ("文件描述符为: ", fid) # 关闭文件 fo.close()
                  • 文件名为: runoob.txt 文件描述符为: 3
        • file.isatty()
          • 如果文件连接到一个终端设备返回 True，否则返回 False。
            • 概述
              • isatty() 方法检测文件是否连接到一个终端设备，如果是返回 True，否则返回 False。
            • 语法
              • isatty() 方法语法如下：
                • fileObject.isatty();
            • 参数
              • 无
            • 返回值
              • 如果连接到一个终端设备返回 True，否则返回 False。
            • 实例
              • 以下实例演示了 isatty() 方法的使用：
                • # 打开文件 fo = open("runoob.txt", "wb") print ("文件名为: ", fo.name) ret = fo.isatty() print ("返回值 : ", ret) # 关闭文件 fo.close()
                  • 文件名为: runoob.txt 返回值 : False
        • file.next()
          • Python 3 中的 File 对象不支持 next() 方法。
            • 返回文件下一行。
              • 概述
                • Python 3 中的 File 对象不支持 next() 方法。
                • Python 3 的内置函数 next() 通过迭代器调用 __next__() 方法返回下一项。 在循环中，next()方法会在每次循环中调用，该方法返回文件的下一行，如果到达结尾(EOF),则触发 StopIteration
              • 语法
                • next() 方法语法如下：
                  • next(iterator[,default])
              • 参数
                • 无
              • 返回值
                • 返回文件下一行。
              • 实例
                • 以下实例演示了 next() 方法的使用：
                  • 文件 runoob.txt 的内容如下：
                    • 这是第一行 这是第二行 这是第三行 这是第四行 这是第五行
                • 循环读取文件的内容：
                  • # 打开文件 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 行 - 这是第五行
        • file.read([size])
          • 从文件读取指定的字节数，如果未给定或为负则读取所有。
            • 概述
              • read() 方法用于从文件读取指定的字节数，如果未给定或为负则读取所有。
            • 语法
              • read() 方法语法如下：
                • fileObject.read([size]);
            • 参数
              • size -- 从文件中读取的字节数，默认为 -1，表示读取整个文件。
            • 返回值
              • 返回从字符串中读取的字节。
            • 实例
              • 以下实例演示了 read() 方法的使用：
                • 文件 runoob.txt 的内容如下：
                  • 这是第一行 这是第二行 这是第三行 这是第四行 这是第五行
            • 循环读取文件的内容
              • 实例
                • # 打开文件 fo = open("runoob.txt", "r+") print ("文件名为: ", fo.name) line = fo.read(10) print ("读取的字符串: %s" % (line)) # 关闭文件 fo.close()
                  • 文件名为: runoob.txt 读取的字符串: 这是第一行 这是第二
        • file.readline([size])
          • 读取整行，包括 "\n" 字符。
            • 概述
              • 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
              • 实例
                • # 打开文件 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
        • file.readlines([sizeint])
          • 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
            • 概述
              • readlines() 方法用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由 Python 的 for... in ... 结构进行处理。 如果碰到结束符 EOF 则返回空字符串。
              • 如果碰到结束符 EOF 则返回空字符串。
            • 语法
              • readlines() 方法语法如下：
                • fileObject.readlines( );
            • 参数
              • 无。
            • 返回值
              • 返回列表，包含所有的行。
            • 实例
              • 以下实例演示了 readline() 方法的使用：
                • 文件 runoob.txt 的内容如下：
                  • 1:www.runoob.com 2:www.runoob.com 3:www.runoob.com 4:www.runoob.com 5:www.runoob.com
            • 循环读取文件的内容
              • # 打开文件 fo = open("runoob.txt", "r") print ("文件名为: ", fo.name) for line in fo.readlines(): #依次读取每行 line = line.strip() #去掉每行头尾空白 print ("读取的数据为: %s" % (line)) # 关闭文件 fo.close()
                • 文件名为: runoob.txt 读取的数据为: 1:www.runoob.com 读取的数据为: 2:www.runoob.com 读取的数据为: 3:www.runoob.com 读取的数据为: 4:www.runoob.com 读取的数据为: 5:www.runoob.com
        • file.seek(offset[, whence])
          • 移动文件读取指针到指定位置
            • 概述
              • seek() 方法用于移动文件读取指针到指定位置。
            • 语法
              • seek() 方法语法如下：
                • fileObject.seek(offset[, whence])
            • 参数
              • offset -- 开始的偏移量，也就是代表需要移动偏移的字节数，如果是负数表示从倒数第几位开始。
              • whence：可选，默认值为 0。给 offset 定义一个参数，表示要从哪个位置开始偏移；0 代表从文件开头开始算起，1 代表从当前位置开始算起，2 代表从文件末尾算起。
            • 返回值
              • 如果操作成功，则返回新的文件位置，如果操作失败，则函数返回 -1。
            • 实例
              • 以下实例演示了 seek() 方法的使用：
                • >>> f = open('workfile', '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'
                  • 1:www.runoob.com 2:www.runoob.com 3:www.runoob.com 4:www.runoob.com 5:www.runoob.com
                • 循环读取文件的内容
                  • # 打开文件 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
        • file.tell()
          • 返回文件当前位置。
            • 概述
              • tell() 方法返回文件的当前位置，即文件指针当前位置。
            • 语法
              • tell() 方法语法如下：
                • fileObject.tell()
            • 参数
              • 无
            • 返回值
              • 返回文件的当前位置。
            • 实例
              • 以下实例演示了 tell() 方法的使用：
                • 文件 runoob.txt 的内容如下：
                  • 1:www.runoob.com 2:www.runoob.com 3:www.runoob.com 4:www.runoob.com 5:www.runoob.com
              • 循环读取文件的内容
                • # 打开文件 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
        • file.truncate([size])
          • 从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
            • 概述
              • truncate() 方法用于从文件的首行首字节开始截断，截断文件为 size 个字节，无 size 表示从当前位置截断；截断之后 V 后面的所有字节被删除，其中 Widnows 系统下的换行代表2个字节大小。 。
            • 语法
              • 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
              • 循环读取文件的内容
                • 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个字节
                • # 打开文件 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
        • file.write(str)
          • 将字符串写入文件，返回的是写入的字符长度。
            • 概述
              • write() 方法用于向文件中写入指定字符串。
                • 在文件关闭前或缓冲区刷新前，字符串内容存储在缓冲区中，这时你在文件中是看不到写入的内容的。
                • 如果文件打开模式带 b，那写入文件内容时，str (参数)要用 encode 方法转为 bytes 形式，否则报错：TypeError: a bytes-like object is required, not 'str'。
            • 语法
              • 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() 方法的使用
                • # 打开文件 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
        • file.writelines(sequence)
          • 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
            • 概述
              • writelines() 方法用于向文件中写入一序列的字符串。
              • 这一序列字符串可以是由迭代对象产生的，如一个字符串列表。
              • 换行需要制定换行符 \n。
            • 语法
              • writelines() 方法语法如下：
                • fileObject.writelines( [ str ])
            • 参数
              • str -- 要写入文件的字符串序列。
            • 返回值
              • 该方法没有返回值。
            • 实例
              • 以下实例演示了 writelines() 方法的使用
                • # 打开文件 fo = open("test.txt", "w") print ("文件名为: ", fo.name) seq = ["菜鸟教程 1\n", "菜鸟教程 2"] fo.writelines( seq ) # 关闭文件 fo.close()
                  • 文件名为: test.txt
                • 查看文件内容
                  • $ cat test.txt 菜鸟教程 1 菜鸟教程 2
  • os 文件/目录方法
    • os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示
    • os.access(path, mode)
      • 检验权限模式
        • 概述
          • 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() 方法的使用
            • 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(path)
      • 改变当前工作目录
        • 概述
          • os.chdir() 方法用于改变当前工作目录到指定的路径。
        • 语法
          • chdir()方法语法格式如下：
            • os.chdir(path)
        • 参数
          • path -- 要切换到的新路径。
        • 返回值
          • 如果允许访问返回 True , 否则返回False。
        • 实例
          • 以下实例演示了 chdir() 方法的使用：
            • import os, sys path = "/tmp" # 查看当前工作目录 retval = os.getcwd() print ("当前工作目录为 %s" % retval) # 修改当前工作目录 os.chdir( path ) # 查看修改后的工作目录 retval = os.getcwd() print ("目录修改成功 %s" % retval)
              • 当前工作目录为 /www 目录修改成功 /tmp
    • os.chflags(path, flags)
      • 设置路径的标记为数字标记。
        • 概述
          • 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() 方法的使用
            • import os,stat path = "/tmp/foo.txt" # 为文件设置标记，使得它不能被重命名和删除 flags = stat.SF_NOUNLINK retval = os.chflags( path, flags ) print ("返回值: %s" % retval)
              • 返回值: None
    • os.chmod(path, mode)
      • 更改权限
        • 概述
          • os.chmod() 方法用于更改文件或目录的权限。
          • Unix 系统可用。
        • 语法
          • 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() 方法的使用：
            • 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(path, uid, gid)
      • 更改文件所有者
        • 概述
          • os.chown() 方法用于更改文件所有者，如果不修改可以设置为 -1, 你需要超级用户权限来执行权限修改操作。
          • 只支持在 Unix 下使用。
        • 语法
          • chown()方法语法格式如下：
            • os.chown(path, uid, gid);
        • 参数
          • path -- 设置权限的文件路径
          • uid -- 所属用户 ID
          • gid -- 所属用户组 ID
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 chown() 方法的使用：
            • import os, sys # 假定 /tmp/foo.txt 文件存在. # 设置所有者 ID 为 100 os.chown("/tmp/foo.txt", 100, -1) print ("修改权限成功!!")
              • 修改权限成功!!
    • os.chroot(path)
      • 改变当前进程的根目录
        • 概述
          • os.chroot() 方法用于更改当前进程的根目录为指定的目录，使用该函数需要管理员权限。
          • 在 unix 中有效。
        • 语法
          • chroot()方法语法格式如下：
          • os.chroot(path);
        • 参数
          • path -- 要设置为根目录的目录。
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 chroot() 方法的使用：
            • import os, sys # 设置根目录为 /tmp os.chroot("/tmp") print ("修改根目录成功!!")
              • 修改根目录成功!!
    • os.close(fd)
      • 关闭文件描述符 fd
        • 概述
          • os.close() 方法用于关闭指定的文件描述符 fd。
        • 语法
          • close()方法语法格式如下：
          • os.close(fd);
        • 参数
          • fd -- 文件描述符。
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 close() 方法的使用：
            • 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(fd_low, fd_high)
      • 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
        • 概述
          • 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() 方法的使用：
            • 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(fd)
      • 复制文件描述符 fd
        • 概述
          • os.dup() 方法用于复制文件描述符 fd。
        • 语法
          • dup()方法语法格式如下：
            • os.dup(fd);
        • 参数
          • fd -- 文件描述符
        • 返回值
          • 返回复制的文件描述符。
        • 实例
          • 以下实例演示了 dup() 方法的使用：
            • 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".encode()) # 关闭文件 os.closerange( fd, d_fd) print ("关闭所有文件成功!!")
              • 关闭所有文件成功!!
    • os.dup2(fd, fd2)
      • 将一个文件描述符 fd 复制到另一个 fd2
        • 概述
          • os.dup2() 方法用于将一个文件描述符 fd 复制到另一个 fd2。
          • Unix, Windows 上可用。
        • 语法
          • dup2()方法语法格式如下：
            • os.dup2(fd, fd2);
        • 参数
          • fd -- 要被复制的文件描述符
          • fd2 -- 复制的文件描述符
        • 返回值
          • 没有返回值。
        • 实例
          • 以下实例演示了 dup2() 方法的使用：
            • import os # 打开一个文件 f=open('txt','a') # 将这个文件描述符代表的文件，传递给 1 描述符指向的文件（也就是 stdout） os.dup2(f.fileno(), 1) # 关闭文件 f.close() # print 输出到标准输出流，就是文件描述符1 print('runoob') print('google')
              • runoob google
    • os.fchdir(fd)
      • 通过文件描述符改变当前工作目录
        • 概述
          • os.fchdir() 方法通过文件描述符改变当前工作目录。
          • Unix 上可用。
        • 语法
          • fchdir()方法语法格式如下：
            • os.fchdir(fd);
        • 参数
          • fd -- 文件描述符
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 fchdir() 方法的使用：
            • 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(fd, mode)
      • 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
        • 概述
          • 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: 对于拥有者读的权限，Unix V7 版本中 stat.S_IRUSR 的代名词
            • stat.S_IWRITE: 对于拥有者写的权限，Unix V7 版本中 stat.S_IWUSR 的代名词
            • stat.S_IEXEC: 对于拥有者执行的权限，Unix V7 版本中 stat.S_IXUSR 的代名词
            • 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() 方法的使用：
            • 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(fd, uid, gid)
      • 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
        • 概述
          • os.fchown() 方法用于修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
          • Unix上可用。
        • 语法
          • fchown()方法语法格式如下：
            • os.fchown(fd, uid, gid)
        • 参数
          • fd -- 文件描述符
          • uid -- 文件所有者的用户id
          • gid -- 文件所有者的用户组id
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 fchown() 方法的使用：
            • import os, sys, stat # 打开文件 "/tmp/foo.txt" fd = os.open( "/tmp", os.O_RDONLY ) # 设置文件的用户 id 为 100 os.fchown( fd, 100, -1) # 设置文件的用户组 id 为 50 os.fchown( fd, -1, 50) print ("修改权限成功!!") # 关闭文件 os.close( fd )
              • 修改权限成功!!
    • os.fdatasync(fd)
      • 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
        • 概述
          • os.fdatasync() 方法用于强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。如果你需要刷新缓冲区可以使用该方法。
          • Unix上可用。
        • 语法
          • fdatasync()方法语法格式如下：
            • os.fdatasync(fd);
        • 参数
          • fd -- 文件描述符
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 fdatasync() 方法的使用：
            • 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(fd[, mode[, bufsize]])
      • 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
        • 概述
          • os.fdopen() 方法用于通过文件描述符 fd 创建一个文件对象，并返回这个文件对象。
          • 该方法是内置函数 open() 的别名，可以接收一样的参数，唯一的区别是 fdopen() 的第一个参数必须是整型。
        • 语法
          • fdopen()方法语法格式如下：
            • os.fdopen(fd, [, mode[, bufsize]]);
        • 参数
          • fd -- 打开的文件的描述符，在Unix下，描述符是一个小整数。
          • mode -- 可选，和 Python 内建的 open 函数一样，mode参数可以指定『r,w,a,r+,w+,a+,b』等，表示文件的是只读的还是可以读写的，以及打开文件是以二进制还是文本形式打开。这些参数和C语言中的<stdio.h>中fopen函数中指定的mode参数类似。
          • bufsize -- 可选，指定返回的文件对象是否带缓冲：bufsize=0，表示没有带缓冲；bufsize=1，表示该文件对象是行缓冲的；bufsize=正数，表示使用一个指定大小的缓冲冲，单位为byte，但是这个大小不是精确的；bufsize=负数，表示使用一个系统默认大小的缓冲，对于tty字元设备一般是行缓冲，而对于其他文件则一般是全缓冲。如果这个参数没有制定，则使用系统默认的缓冲设定。
        • 返回值
          • 通过文件描述符返回的文件对象。
        • 实例
          • 以下实例演示了 fdopen() 方法的使用：
            • 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(fd, name)
      • 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
        • 概述
          • 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参数类似。
        • 返回值
          • 返回一个打开的文件的系统配置信息。
        • 实例
          • 以下实例演示了 fpathconf() 方法的使用：
            • 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(fd)
      • 返回文件描述符fd的状态，像stat()。
        • 概述
          • 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() 方法的使用：
            • 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(fd)
      • 返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
        • 概述
          • os.fstatvfs() 方法用于返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 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() 方法的使用：
            • 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(fd)
      • 强制将文件描述符为fd的文件写入硬盘。
        • 概述
          • 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() 方法的使用：
            • 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(fd, length)
      • 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
        • 概述
          • os.ftruncate() 裁剪文件描述符fd对应的文件, 它最大不能超过文件大小。
          • Unix上可用。
        • 语法
          • ftruncate()方法语法格式如下：
            • os.ftruncate(fd, length)¶
        • 参数
          • fd -- 文件的描述符。
          • length -- 要裁剪文件大小。
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 ftruncate() 方法的使用：
            • 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()
      • 返回当前工作目录
        • 概述
          • os.getcwd() 方法用于返回当前工作目录。
        • 语法
          • getcwd()方法语法格式如下：
            • os.getcwd()
        • 参数
          • 无
        • 返回值
          • 返回当前进程的工作目录。
        • 实例
          • 以下实例演示了 getcwd() 方法的使用：
            • 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.getcwdb()
      • 返回一个当前工作目录的Unicode对象
        • 概述
          • os.getcwdb() 方法用于返回一个字节串（bytestring），表示当前工作目录。
          • ByteString 是一个可以对应所有可能的字节序列的 UTF-8 字符串。
          • 该方法在 Python3.8 版中进行了更改：该函数在 Windows 上使用 UTF-8 编码，而不是 ANSI。
        • 语法
          • getcwdb()方法语法格式如下：
            • os.getcwdb()
        • 参数
          • 无
        • 返回值
          • 返回一个当前工作目录的 Unicode 对象。
        • 实例
          • 以下实例演示了 getcwdb() 方法的使用：
            • import os, sys # 切换到 "/var/www/html" 目录 os.chdir("/var/www/html" ) # 打印当前目录 print ("当前工作目录 : %s" % os.getcwdb()) # 打开 "/tmp" fd = os.open( "/tmp", os.O_RDONLY ) # 使用 os.fchdir() 方法修改目录 os.fchdir(fd) # 打印当前目录 print ("当前工作目录 : %s" % os.getcwdb()) # 关闭文件 os.close( fd )
              • 当前工作目录 : b'/var/www/html' 当前工作目录 : b'/private/tmp'
    • os.isatty(fd)
      • 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
        • 概述
          • os.isatty() 方法用于判断如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
        • 语法
          • isatty()方法语法格式如下：
            • os.isatty()
        • 参数
          • 无
        • 返回值
          • 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
        • 实例
          • 以下实例演示了 isatty() 方法的使用：
            • 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(path, flags)
      • 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
        • 概述
          • 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() 方法的使用：
            • 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(path, mode)
      • 修改连接文件权限
        • 概述
          • 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() 方法的使用：
            • 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(path, uid, gid)
      • 更改文件所有者，类似 chown，但是不追踪链接。
        • 概述
          • os.lchown() 方法用于更改文件所有者，类似 chown，但是不追踪链接。
          • 只支持在 Unix 下使用。
        • 语法
          • lchown()方法语法格式如下：
            • os.lchown(path, uid, gid)
        • 参数
          • path -- 设置权限的文件路径
          • uid -- 所属用户 ID
          • gid -- 所属用户组 ID
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 lchown() 方法的使用：
            • 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(src, dst)
      • 创建硬链接，名为参数 dst，指向参数 src
        • 概述
          • os.link() 方法用于创建硬链接，名为参数 dst，指向参数 src。
          • 该方法对于创建一个已存在文件的拷贝是非常有用的。
          • 只支持在 Unix, Windows 下使用。
        • 语法
          • link()方法语法格式如下：
            • os.link(src, dst)
        • 参数
          • src -- 用于创建硬连接的源地址
          • dst -- 用于创建硬连接的目标地址
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 link() 方法的使用：
            • 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(path)
      • 返回path指定的文件夹包含的文件或文件夹的名字的列表。
        • 概述
          • os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表。这个列表以字母顺序。 它不包括 . 和 .. 即使它在文件夹中。
          • 只支持在 Unix, Windows 下使用。
        • 语法
          • listdir()方法语法格式如下：
            • os.listdir(path)
        • 参数
          • path -- 需要列出的目录路径
        • 返回值
          • 返回指定路径下的文件和文件夹列表。
        • 实例
          • 以下实例演示了 listdir() 方法的使用：
            • 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
            • 目录中存在中文的情况不需要特别处理，也可以正常输出，因为 Python3 默认是 utf8 编码。目录结构如下
            • 例子
              • import os # 打开文件 path = "./git-test" upath = unicode(path,'utf-8') dirs = os.listdir( upath ) # 输出所有文件和文件夹 for file in dirs: print (file)
                • runoob runoob-git-test another-runoob-name 中文目录测试
    • os.lseek(fd, pos, how)
      • 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
        • 概述
          • 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() 方法的使用：
            • 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(path)
      • 像stat(),但是没有软链接
        • 概述
          • os.lstat() 方法用于类似 stat() 返回文件的信息,但是没有符号链接。在某些平台上，这是fstat的别名，例如 Windows。
        • 语法
          • lstat()方法语法格式如下：
          • os.lstat(path)
        • 参数
          • path -- 要返回信息的文件。
        • 返回值
          • 返回文件信息。
        • 实例
          • 以下实例演示了 lstat() 方法的使用：
            • 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(device)
      • 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
        • 概述
          • os.major() 方法用于从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
        • 语法
          • major()方法语法格式如下：
          • os.major(device)
        • 参数
          • device -- 原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
        • 返回值
          • 返回设备major号码。
        • 实例
          • 以下实例演示了 major() 方法的使用：
            • 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(major, minor)
      • 以major和minor设备号组成一个原始设备号
        • 概述
          • os.makedev() 方法用于以major和minor设备号组成一个原始设备号。
        • 语法
          • makedev()方法语法格式如下：
            • os.makedev(major, minor)
        • 参数
          • major -- Major 设备号。
          • minor -- inor 设备号。
        • 返回值
          • 返回设备号。
        • 实例
          • 以下实例演示了 makedev() 方法的使用：
            • 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(path[, mode])
      • 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
        • 概述
          • os.makedirs() 方法用于递归创建目录。
          • 如果子目录创建失败或者已经存在，会抛出一个 OSError 的异常，Windows上Error 183 即为目录已经存在的异常错误。
          • 如果第一个参数 path 只有一级，则 mkdir() 函数相同。
        • 语法
          • makedirs()方法语法格式如下：
            • os.makedirs(path, mode=0o777)
        • 参数
          • path -- 需要递归创建的目录，可以是相对或者绝对路径。
          • mode -- 权限模式。
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 makedirs() 方法的使用：
            • import os, sys # 创建的目录 path = "/tmp/home/monthly/daily" os.makedirs( path, 0o777 ); print ("路径被创建")
              • 路径被创建
    • os.minor(device)
      • 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
        • 概述
          • os.minor() 方法用于从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
        • 语法
          • minor()方法语法格式如下：
            • os.minor(device)
        • 参数
          • device -- 原始的设备(使用stat中的st_dev或者st_rdev field )
        • 返回值
          • 返回设备 minor 号。
        • 实例
          • 以下实例演示了 minor() 方法的使用：
            • 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(path[, mode])
      • 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
        • 概述
          • os.mkdir() 方法用于以数字权限模式创建目录。默认的模式为 0777 (八进制)。
          • 如果目录有多级，则创建最后一级，如果最后一级目录的上级目录有不存在的，则会抛出一个 OSError。
        • 语法
          • mkdir()方法语法格式如下：
            • os.mkdir(path[, mode])
        • 参数
          • path -- 要创建的目录，可以是相对或者绝对路径。
          • mode -- 要为目录设置的权限数字模式
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 mkdir() 方法的使用：
            • # -*- coding: UTF-8 -*- import os, sys # 创建的目录 path = "/tmp/home/monthly/daily/hourly" os.mkdir( path, 0755 ) print ("目录已创建")
              • 目录已创建
    • os.mkfifo(path[, mode])
      • 创建命名管道，mode 为数字，默认为 0666 (八进制)
        • 概述
          • os.mkfifo() 方法用于创建指令路径的管道，并设置权限模式。默认的模式为 0666 (八进制)。
        • 语法
          • mkfifo()方法语法格式如下：
            • os.mkfifo(path[, mode])
        • 参数
          • path -- 要创建的目录
          • mode -- 要为目录设置的权限数字模式
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 mkfifo() 方法的使用：
            • import os, sys # 创建的目录 path = "/tmp/hourly" os.mkfifo( path, 0644 ) print ("路径被创建")
              • 路径被创建
    • os.mknod(filename[, mode=0600, device])
      • 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
        • 概述
          • 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() 方法的使用：
            • 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(file, flags[, mode])
      • 打开一个文件，并且设置需要的打开选项，mode参数是可选的
        • 概述
          • 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() 方法的使用：
            • import os, sys # 打开文件 fd = os.open( "foo.txt", os.O_RDWR|os.O_CREAT ) # 写入字符串 os.write(fd, str.encode("This is test")) # 关闭文件 os.close( fd ) print ("关闭文件成功!!")
              • 关闭文件成功!!
    • os.openpty()
      • 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
        • 概述
          • os.openpty() 方法用于打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
        • 语法
          • openpty()方法语法格式如下：
            • os.openpty()
        • 参数
          • 无
        • 返回值
          • 返回文件描述符对，主从。
        • 实例
          • 以下实例演示了 openpty() 方法的使用：
            • 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(path, name)
      • 返回相关文件的系统配置信息。
        • 概述
          • os.pathconf() 方法用于返回一个打开的文件的系统配置信息。
          • Unix 平台下可用。
        • 语法
          • fpathconf()方法语法格式如下：
          • os.fpathconf(fd, name)
        • 参数
          • fd -- 文件描述符
          • name -- 检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。一些平台也定义了一些额外的名字。这些名字在主操作系统上pathconf_names的字典中。对于不在pathconf_names中的配置变量，传递一个数字作为名字，也是可以接受的。
        • 返回值
          • 返回文件的系统信息。
        • 实例
          • 以下实例演示了 fpathconf() 方法的使用：
            • 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()
      • 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
        • 概述
          • os.pipe() 方法用于创建一个管道, 返回一对文件描述符(r, w) 分别为读和写。
        • 语法
          • pipe()方法语法格式如下：
          • os.pipe()
        • 参数
          • 无
        • 返回值
          • 返回文件描述符对。
        • 实例
          • 以下实例演示了 pipe() 方法的使用：
            • 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(command[, mode[, bufsize]])
      • 从一个 command 打开一个管道
        • 概述
          • os.popen() 方法用于从一个命令打开一个管道。
          • 在Unix，Windows中有效
        • 语法
          • popen()方法语法格式如下：
            • os.popen(command[, mode[, bufsize]])
        • 参数
          • command -- 使用的命令。
          • mode -- 模式权限可以是 'r'(默认) 或 'w'。
          • bufsize -- 指明了文件需要的缓冲大小：0意味着无缓冲；1意味着行缓冲；其它正值表示使用参数大小的缓冲（大概值，以字节为单位）。负的bufsize意味着使用系统的默认值，一般来说，对于tty设备，它是行缓冲；对于其它文件，它是全缓冲。如果没有改参数，使用系统的默认值。
        • 返回值
          • 返回一个文件描述符号为fd的打开的文件对象
        • 实例
          • 以下实例演示了 popen() 方法的使用：
            • 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(fd, n)
      • 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
        • 概述
          • os.read() 方法用于从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
          • 在Unix，Windows中有效
        • 语法
          • read()方法语法格式如下：
            • os.read(fd,n)
        • 参数
          • fd -- 文件描述符。
          • n -- 读取的字节。
        • 返回值
          • 返回包含读取字节的字符串
        • 实例
          • 以下实例演示了 read() 方法的使用：
            • 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(path)
      • 返回软链接所指向的文件
        • 概述
          • os.readlink() 方法用于返回软链接所指向的文件，可能返回绝对或相对路径。
          • 在Unix中有效
        • 语法
          • readlink()方法语法格式如下：
          • os.readlink(path)
        • 参数
          • path -- 要查找的软链接路径
        • 返回值
          • 返回软链接所指向的文件
        • 实例
          • 以下实例演示了 readlink() 方法的使用：
            • import os src = '/usr/bin/python' dst = '/tmp/python' # 创建软链接 os.symlink(src, dst) # 使用软链接显示源链接 path = os.readlink( dst ) print (path)
              • /usr/bin/python
    • os.remove(path)
      • 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
        • 概述
          • os.remove() 方法用于删除指定路径的文件。如果指定的路径是一个目录，将抛出OSError。
          • 在Unix, Windows中有效
        • 语法
          • remove()方法语法格式如下：
            • os.remove(path)
        • 参数
          • path -- 要移除的文件路径
        • 返回值
          • 该方法没有返回值
        • 实例
          • 以下实例演示了 remove() 方法的使用：
            • 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(path)
      • 递归删除目录。
        • 概述
          • os.removedirs() 方法用于递归删除目录。像rmdir(), 如果子文件夹成功删除, removedirs()才尝试它们的父文件夹,直到抛出一个error(它基本上被忽略,因为它一般意味着你文件夹不为空)。
        • 语法
          • removedirs()方法语法格式如下：
            • os.removedirs(path)
        • 参数
          • path -- 要移除的目录路径
        • 返回值
          • 该方法没有返回值
        • 实例
          • 以下实例演示了 removedirs() 方法的使用：
            • 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(src, dst)
      • 重命名文件或目录，从 src 到 dst
        • 概述
          • os.rename() 方法用于命名文件或目录，从 src 到 dst,如果dst是一个存在的目录, 将抛出OSError。
        • 语法
          • rename()方法语法格式如下：
            • os.rename(src, dst)
        • 参数
          • src -- 要修改的目录名
          • dst -- 修改后的目录名
        • 返回值
          • 该方法没有返回值
        • 实例
          • 以下实例演示了 rename() 方法的使用：
            • 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(old, new)
      • 递归地对目录进行更名，也可以对文件进行更名。
        • 概述
          • os.renames() 方法用于递归重命名目录或文件。类似rename()。
        • 语法
          • renames()方法语法格式如下：
            • os.renames(old, new)
        • 参数
          • old -- 要重命名的目录
          • new --文件或目录的新名字。甚至可以是包含在目录中的文件，或者完整的目录树。
        • 返回值
          • 该方法没有返回值
        • 实例
          • 以下实例演示了 renames() 方法的使用：
            • 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','newdir','amrood.admin' ] 重命名成功。 目录为: [ 'a1.txt','resume.doc','a3.py','Administrator','newdir','amrood.admin' ]
    • os.rmdir(path)
      • 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
        • 概述
          • os.rmdir() 方法用于删除指定路径的目录。仅当这文件夹是空的才可以, 否则, 抛出OSError。
        • 语法
          • rmdir()方法语法格式如下：
            • os.rmdir(path)
        • 参数
          • path -- 要删除的目录路径
        • 返回值
          • 该方法没有返回值
        • 实例
          • 以下实例演示了 rmdir() 方法的使用：
            • 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(path)
      • 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
        • 概述
          • 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() 方法的使用：
            • 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([newvalue])
      • 决定stat_result是否以float对象显示时间戳
        • 概述
          • 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() 方法的使用：
            • 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(path)
      • 获取指定路径的文件系统统计信息
        • 概述
          • 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() 方法的使用：
            • 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(src, dst)
      • 创建一个软链接
        • 概述
          • os.symlink() 方法用于创建一个软链接。
        • 语法
          • symlink()方法语法格式如下：
            • os.symlink(src, dst)
        • 参数
          • src -- 源地址。
          • dst -- 目标地址。
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 symlink() 方法的使用：
            • import os src = '/usr/bin/python' dst = '/tmp/python' # 创建软链接 os.symlink(src, dst) print ("软链接创建成功")
              • 软链接创建成功
    • os.tcgetpgrp(fd)
      • 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
        • 概述
          • os.tcgetpgrp() 方法用于回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组。
        • 语法
          • tcgetpgrp()方法语法格式如下：
            • os.tcgetpgrp(fd)
        • 参数
          • fd -- 文件描述符。
        • 返回值
          • 该方法返回进程组。
        • 实例
          • 以下实例演示了 tcgetpgrp() 方法的使用：
            • 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.tcsetpgrp(fd, pg)
      • 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
        • 概述
          • os.tcsetpgrp() 方法用于设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
          • 可用系统: Unix。
        • 语法
          • tcsetpgrp()方法语法格式如下：
            • os.tcsetpgrp(fd, pg)
        • 参数
          • fd -- 文件描述符。
          • pg -- 关联的进程组。
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 tcsetpgrp() 方法的使用：
            • 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.tcsetpgrp(fd,2672) print( "done" ) os.close(fd) print( "关闭文件成功!!" )
              • 当前目录 :/tmp 关联进程组: 2672 done 关闭文件成功!!
    • os.tempnam([dir[, prefix]])
      • Python3 中已删除。返回唯一的路径名用于创建临时文件。
    • os.tmpfile()
      • Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
    • os.tmpnam()
      • Python3 中已删除。为创建一个临时文件返回一个唯一的路径
    • os.ttyname(fd)
      • 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
        • 概述
          • os.ttyname() 方法用于返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
        • 语法
          • ttyname()方法语法格式如下：
            • os.ttyname(fd)
        • 参数
          • fd -- 文件描述符
        • 返回值
          • 返回一个字符串，它表示与文件描述符fd 关联的终端设备。
        • 实例
          • 以下实例演示了 ttyname() 方法的使用：
            • 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(path)
      • 删除文件路径
        • 概述
          • os.unlink() 方法用于删除文件,如果文件是一个目录则返回一个错误。
        • 语法
          • unlink()方法语法格式如下：
            • os.unlink(path)
        • 参数
          • path -- 删除的文件路径
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 unlink() 方法的使用：
            • 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(path, times)
      • 返回指定的path文件的访问和修改的时间。
        • 概述
          • os.utime() 方法用于设置指定路径文件最后的修改和访问时间。
          • 在Unix，Windows中有效。
        • 语法
          • utime()方法语法格式如下：
            • os.utime(path, times)
        • 参数
          • path -- 文件路径
          • times -- 如果时间是 None, 则文件的访问和修改设为当前时间 。 否则, 时间是一个 2-tuple数字, (atime, mtime) 用来分别作为访问和修改的时间。
        • 返回值
          • 该方法没有返回值。
        • 实例
          • 以下实例演示了 utime() 方法的使用：
            • 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(top[, topdown=True[, onerror=None[, followlinks=False]]])
      • 输出在文件夹中的文件名通过在树中游走，向上或者向下。
        • 概述
          • os.walk() 方法可以创建一个生成器，用以生成所要查找的目录及其子目录下的所有文件。
          • os.walk() 方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下。
          • 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() 方法的使用：
            • 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(fd, str)
      • 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
        • 概述
          • os.write() 方法用于写入字符串到文件描述符 fd 中. 返回实际写入的字符串长度。
          • 在Unix中有效。
        • 语法
          • write()方法语法格式如下：
            • os.write(fd, str)
        • 参数
          • fd -- 文件描述符。
          • str -- 写入的字符串。
        • 返回值
          • 该方法返回写入的实际位数。
        • 实例
          • 以下实例演示了 write() 方法的使用：
            • 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 写入成功 关闭文件成功!!
    • os.path 模块
      • 获取文件的属性信息。
        • os.path 模块主要用于获取文件的属性。
        • 以下是 os.path 模块的几种常用方法：
          • 方法 说明
          • os.path.abspath(path) 返回绝对路径
          • os.path.basename(path) 返回文件名
          • os.path.commonprefix(list) 返回list(多个路径)中，所有path共有的最长的路径
          • os.path.dirname(path) 返回文件路径
          • os.path.exists(path) 路径存在则返回True,路径损坏返回False
          • os.path.lexists 路径存在则返回True,路径损坏也返回True
          • os.path.expanduser(path) 把path中包含的"~"和"~user"转换成用户目录
          • os.path.expandvars(path) 根据环境变量的值替换path中包含的"$name"和"${name}"
          • os.path.getatime(path) 返回最近访问时间（浮点型秒数）
          • os.path.getmtime(path) 返回最近文件修改时间
          • os.path.getctime(path) 返回文件 path 创建时间
          • os.path.getsize(path) 返回文件大小，如果文件不存在就返回错误
          • os.path.isabs(path) 判断是否为绝对路径
          • os.path.isfile(path) 判断路径是否为文件
          • os.path.isdir(path) 判断路径是否为目录
          • os.path.islink(path) 判断路径是否为链接
          • os.path.ismount(path) 判断路径是否为挂载点
          • os.path.join(path1[, path2[, ...]]) 把目录和文件名合成一个路径
          • os.path.normcase(path) 转换path的大小写和斜杠
          • os.path.normpath(path) 规范path字符串形式
          • os.path.realpath(path) 返回path的真实路径
          • os.path.relpath(path[, start]) 从start开始计算相对路径
          • os.path.samefile(path1, path2) 判断目录或文件是否相同
          • os.path.sameopenfile(fp1, fp2) 判断fp1和fp2是否指向同一文件
          • os.path.samestat(stat1, stat2) 判断stat tuple stat1和stat2是否指向同一个文件
          • os.path.split(path) 把路径分割成 dirname 和 basename，返回一个元组
          • os.path.splitdrive(path) 一般用在 windows 下，返回驱动器名和路径组成的元组
          • os.path.splitext(path) 分割路径中的文件名与拓展名
          • os.path.splitunc(path) 把路径分割为加载点与文件
          • os.path.walk(path, visit, arg) 遍历path，进入每个目录都调用visit函数，visit函数必须有3个参数(arg, dirname, names)，dirname表示当前目录的目录名，names代表当前目录下的所有文件名，args则为walk的第三个参数
          • os.path.supports_unicode_filenames 设置是否支持unicode路径名
        • 实例
          • 以下实例演示了 os.path 相关方法的使用：
            • import os.path # 当前文件名 print(__file__) # 当前文件名的绝对路径 print( os.path.abspath(__file__) ) # 返回当前文件的路径 print(os.path.dirname( os.path.abspath(__file__) ))
              • test.py /runoob/runoob-test-py/test.py /runoob/runoob-test-py
          • 实例
            • import os print( os.path.basename('/root/runoob.txt') ) # 返回文件名 print( os.path.dirname('/root/runoob.txt') ) # 返回目录路径 print( os.path.split('/root/runoob.txt') ) # 分割文件名与路径 print( os.path.join('root','test','runoob.txt') ) # 将目录和文件名合成一个路径
              • runoob.txt /root ('/root', 'runoob.txt') root/test/runoob.txt
          • 实例
            • import os import time file='/root/runoob.txt' # 文件路径 print( os.path.getatime(file) ) # 输出最近访问时间 print( os.path.getctime(file) ) # 输出文件创建时间 print( os.path.getmtime(file) ) # 输出最近修改时间 print( time.gmtime(os.path.getmtime(file)) ) # 以struct_time形式输出最近修改时间 print( os.path.getsize(file) ) # 输出文件大小（字节为单位） print( os.path.abspath(file) ) # 输出绝对路径 print( os.path.normpath(file) ) # 规范path字符串形式
              • 1539052805.5735736 1539052805.5775735 1539052805.5735736 time.struct_time(tm_year=2018, tm_mon=10, tm_mday=9, tm_hour=2, tm_min=40, tm_sec=5, tm_wday=1, tm_yday=282, tm_isdst=0) 7 /root/runoob.txt /root/runoob.txt
    • os.pardir()
      • 获取当前目录的父目录，以字符串形式显示目录名。
        • 概述
          • os.pardir() 获取当前目录的父目录（上一级目录），以字符串形式显示目录名。
          • 注意: Windows 和 POSIX 返回 ..。
        • 语法
          • pardir()方法语法格式如下：
            • os.pardir
        • 参数
          • 无。
        • 返回值
          • 返回当前目录的父目录，默认值为 ..。
        • 实例
          • 以下实例演示了 pardir() 方法的使用：
            • import os # 输出默认值 .. print(os.pardir)
              • ..
        • 打印当前目录的父目录：
          • import os # 当前工作目录 path = os.getcwd() print("当前工作目录: ", path) # 父目录 parent = os.path.join(path, os.pardir) # 父目录 print("\n父目录:", os.path.abspath(parent))
            • 当前工作目录: /Users/runoob/python 父目录: /Users/runoob
  • 错误和异常
    • 作为 Python 初学者，在刚学习 Python 编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。
    • Python 有两种错误很容易辨认：语法错误和异常。
    • Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
    • 语法错误
      • Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例
        • >>> while True print('Hello world') File "<stdin>", line 1, in ? while True print('Hello world') ^ SyntaxError: invalid syntax
        • 这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号 : 。
        • 语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。
    • 异常
      • 即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
      • 大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:
        • >>> 10 * (1/0) # 0 不能作为除数，触发异常 Traceback (most recent call last): File "<stdin>", line 1, in ? ZeroDivisionError: division by zero >>> 4 + spam*3 # spam 未定义，触发异常 Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'spam' is not defined >>> '2' + 2 # int 不能与 str 相加，触发异常 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate str (not "int") to str
        • 异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。
        • 错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。
    • 异常处理
      • try/except
        • 异常捕捉可以使用 try/except 语句。
        • 以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。
          • while True: try: x = int(input("请输入一个数字: ")) break except ValueError: print("您输入的不是数字，请再次尝试输入！")
        • try 语句按照如下方式工作；
          • 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
          • 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
          • 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
          • 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
            • 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子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
        • 处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
        • 一个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
        • try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。
        • else 子句将在 try 子句没有发生任何异常的时候执行。
        • 以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容：
          • 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
      • try-finally语句
        • try-finally 语句无论是否发生异常都将执行最后的代码。
        • 以下实例中 finally 语句无论异常是否发生都会执行：
          • try: runoob() except AssertionError as error: print(error) else: try: with open('file.log') as file: read_data = file.read() except FileNotFoundError as fnf_error: print(fnf_error) finally: print('这句话，无论异常是否发生都会执行。')
    • 抛出异常
      • Python 使用 raise 语句抛出一个指定的异常。
      • raise语法格式如下：
      • raise [Exception [, args [, traceback]]]
      • 以下实例如果 x 大于 5 就触发异常:
        • x = 10 if x > 5: raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
      • 执行以上代码会触发异常：
        • Traceback (most recent call last): File "test.py", line 3, in <module> raise Exception('x 不能大于 5。x 的值为: {}'.format(x)) Exception: x 不能大于 5。x 的值为: 10
      • 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 类，可以直接继承，或者间接继承，例如:
        • >>> 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__() 被覆盖。
      • 当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:
        • 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! Traceback (most recent call last): File "<stdin>", line 2, in <module> 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 总是会关闭。
      • 更多 with 关键字内容参考：Python with 关键字
        • Python 中的 with 语句用于异常处理，封装了 try…except…finally 编码范式，提高了易用性。
        • with 语句使代码更清晰、更具可读性， 它简化了文件流等公共资源的管理。
        • 在处理文件对象时使用 with 关键字是一种很好的做法。
        • 我们可以看下以下几种代码实例：
        • 不使用 with，也不使用 try…except…finally
          • file = open('./test_runoob.txt', 'w') file.write('hello world !') file.close()
          • 以上代码如果在调用 write 的过程中，出现了异常，则 close 方法将无法被执行，因此资源就会一直被该程序占用而无法被释放。 接下来我们呢可以使用 try…except…finally 来改进代码：
            • file = open('./test_runoob.txt', 'w') try: file.write('hello world') finally: file.close()
            • 以上代码我们对可能发生异常的代码处进行 try 捕获，发生异常时执行 except 代码块，finally 代码块是无论什么情况都会执行，所以文件会被关闭，不会因为执行异常而占用资源。
          • 使用 with 关键字：
            • 实例
              • with open('./test_runoob.txt', 'w') as file: file.write('hello world !')
            • 使用 with 关键字系统会自动调用 f.close() 方法， with 的作用等效于 try/finally 语句是一样的。
            • 我们可以在执行 with 关键字后检验文件是否关闭：
              • 实例
                • >>> with open('./test_runoob.txt') as f: ... read_data = f.read() >>> # 查看文件是否关闭 >>> f.closed True
            • with 语句实现原理建立在上下文管理器之上。
            • 上下文管理器是一个实现 __enter__ 和 __exit__ 方法的类。
            • 使用 with 语句确保在嵌套块的末尾调用 __exit__ 方法。
            • 这个概念类似于 try...finally 块的使用。
            • 实例
              • with open('./test_runoob.txt', 'w') as my_file: my_file.write('hello world!')
              • 以上实例将 hello world! 写到 ./test_runoob.txt 文件上。
              • 在文件对象中定义了 __enter__ 和 __exit__ 方法，即文件对象也实现了上下文管理器，首先调用 __enter__ 方法，然后执行 with 语句中的代码，最后调用 __exit__ 方法。 即使出现错误，也会调用 __exit__ 方法，也就是会关闭文件流。
    • 相关内容
      • python assert （断言）
        • Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
        • 断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况，例如我们的代码只能在 Linux 系统下运行，可以先判断当前系统是否符合条件。
        • 语法格式如下：
          • assert expression
          • 等价于：
            • if not expression: raise AssertionError
        • assert 后面也可以紧跟参数:
          • assert expression [, arguments]
          • 等价于：
            • if not expression: raise AssertionError(arguments)
        • 以下为 assert 使用实例：
          • >>> assert True # 条件为 true 正常执行 >>> assert False # 条件为 false 触发异常 Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError >>> assert 1==1 # 条件为 true 正常执行 >>> assert 1==2 # 条件为 false 触发异常 Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError >>> assert 1==2, '1 不等于 2' Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError: 1 不等于 2
        • 以下实例判断当前系统是否为 Linux，如果不满足条件则直接触发异常，不必执行接下来的代码：
          • import sys assert ('linux' in sys.platform), "该代码只能在 Linux 下执行" # 接下来要执行的代码
      • python with 关联字
        • ython 中的 with 语句用于异常处理，封装了 try…except…finally 编码范式，提高了易用性。
        • with 语句使代码更清晰、更具可读性， 它简化了文件流等公共资源的管理。
        • 在处理文件对象时使用 with 关键字是一种很好的做法。
        • 我们可以看下以下几种代码实例：
        • 不使用 with，也不使用 try…except…finally
        • 实例
          • file = open('./test_runoob.txt', 'w') file.write('hello world !') file.close()
        • 以上代码如果在调用 write 的过程中，出现了异常，则 close 方法将无法被执行，因此资源就会一直被该程序占用而无法被释放。 接下来我们呢可以使用 try…except…finally 来改进代码：
        • 实例
          • file = open('./test_runoob.txt', 'w') try: file.write('hello world') finally: file.close()
        • 以上代码我们对可能发生异常的代码处进行 try 捕获，发生异常时执行 except 代码块，finally 代码块是无论什么情况都会执行，所以文件会被关闭，不会因为执行异常而占用资源。
        • 使用 with 关键字：
        • 实例
          • with open('./test_runoob.txt', 'w') as file: file.write('hello world !')
        • 使用 with 关键字系统会自动调用 f.close() 方法， with 的作用等效于 try/finally 语句是一样的。
        • 我们可以在执行 with 关键字后检验文件是否关闭：
        • 实例
          • >>> with open('./test_runoob.txt') as f: ... read_data = f.read() >>> # 查看文件是否关闭 >>> f.closed True
        • with 语句实现原理建立在上下文管理器之上。
        • 上下文管理器是一个实现 __enter__ 和 __exit__ 方法的类。
        • 使用 with 语句确保在嵌套块的末尾调用 __exit__ 方法。
        • 这个概念类似于 try...finally 块的使用。
        • 实例
          • with open('./test_runoob.txt', 'w') as my_file: my_file.write('hello world!')
        • 以上实例将 hello world! 写到 ./test_runoob.txt 文件上。
        • 在文件对象中定义了 __enter__ 和 __exit__ 方法，即文件对象也实现了上下文管理器，首先调用 __enter__ 方法，然后执行 with 语句中的代码，最后调用 __exit__ 方法。 即使出现错误，也会调用 __exit__ 方法，也就是会关闭文件流。
  • 面向对象
    • 介绍
      • Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。
      • 如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。
      • 接下来我们先来简单的了解下面向对象的一些基本特征。
    • 面向对象技术介绍
      • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
      • 方法：类中定义的函数。
      • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
      • 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
      • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
      • 局部变量：定义在方法中的变量，只作用于当前实例的类。
      • 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
      • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
      • 实例化：创建一个类的实例，类的具体对象。
      • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
      • 和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。
      • Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
      • 对象可以包含任意数量和类型的数据。
    • 类定义
      • 语法格式如下：
        • class ClassName: <statement-1> . . . <statement-N>
      • 类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
    • 类对象
      • 类对象支持两种操作：属性引用和实例化。
      • 属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。
      • 类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:
        • class MyClass: """一个简单的类实例""" i = 12345 def f(self): return 'hello world' # 实例化类 x = MyClass() # 访问类的属性和方法 print("MyClass 类的属性 i 为：", x.i) print("MyClass 类的方法 f 输出为：", x.f())
        • 以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。
        • 执行以上程序输出结果为：
          • MyClass 类的属性 i 为： 12345 MyClass 类的方法 f 输出为： hello world
      • 类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：
        • def __init__(self): self.data = []
      • 类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。如下实例化类 MyClass，对应的 __init__() 方法就会被调用:
        • x = MyClass()
      • 当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:
        • class Complex: def __init__(self, realpart, imagpart): self.r = realpart self.i = imagpart x = Complex(3.0, -4.5) print(x.r, x.i) # 输出结果：3.0 -4.5
    • self代表类的实例，而非类
      • 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
        • lass 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, 且为第一个参数，self 代表的是类的实例。
        • #类定义 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(BaseClassName): <statement-1> . . . <statement-N>
      • 子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。
      • BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:
      • class DerivedClassName(modname.BaseClassName):
        • #类定义 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从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
      • 实例
        • #类定义 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
    • 方法重写
      • 如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：
        • class Parent: # 定义父类 def myMethod(self): print ('调用父类方法') class Child(Parent): # 定义子类 def myMethod(self): print ('调用子类方法') c = Child() # 子类实例 c.myMethod() # 子类调用重写方法 super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
          • 调用子类方法 调用父类方法
      • super() 函数是用于调用父类(超类)的一个方法。
        • 描述
          • super() 函数是用于调用父类(超类)的一个方法。
          • super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
          • MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
        • 语法
          • 以下是 super() 方法的语法:
            • super(type[, object-or-type])
        • 参数
          • type -- 类。
          • object-or-type -- 类，一般是 self
          • Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
            • Python3.x 实例：
              • class A: def add(self, x): y = x+1 print(y) class B(A): def add(self, x): super().add(x) b = B() b.add(2) # 3
            • Python2.x 实例：
              • # -*- coding: UTF-8 -*- class A(object): # Python2.x 记得继承 object def add(self, x): y = x+1 print(y) class B(A): def add(self, x): super(B, self).add(x) b = B() b.add(2) # 3
        • 返回值
          • 无。
        • 实例
          • 以下展示了使用 super 函数的实例：
            • 实例
              • # -*- coding: UTF-8 -*- class FooParent(object): def __init__(self): self.parent = 'I\'m the parent.' print ('Parent') def bar(self,message): print ("%s from Parent" % message) class FooChild(FooParent): def __init__(self): # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象 super(FooChild,self).__init__() print ('Child') def bar(self,message): super(FooChild, self).bar(message) print ('Child bar fuction') print (self.parent) if __name__ == '__main__': fooChild = FooChild() fooChild.bar('HelloWorld')
                • Parent Child HelloWorld from Parent Child bar fuction I'm the parent.
    • 类属性与方法
      • 类的私有属性
        • __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
      • 类的方法
        • 在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
        • self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。
      • 类的私有方法
        • __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。
      • 实例
        • 类的私有属性实例如下：
          • 实例(Python 3.0+)
            • 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'
        • 类的私有方法实例如下：
          • 实例(Python 3.0+)
            • 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__
          • 比较运算
        • __cal__
          • 函数调用
        • __add__
          • 加运算
        • __sub__
          • 减运算
        • __mul__
          • 乘运算
        • __turediv__
          • 除运算
        • __mod__
          • 求余运算
        • __pow__
          • 乘方
    • 运算符重载
      • Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：
        • 实例(Python 3.0+)
          • 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)
  • 命名空间和作用域
    • 命名空间
      • 先看看官方文档的一段话：
        • A namespace is a mapping from names to objects.Most namespaces are currently implemented as Python dictionaries。
      • 命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。
      • 命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。
      • 我们举一个计算机系统中的例子，一个文件夹(目录)中可以包含多个文件夹，每个文件夹中不能有相同的文件名，但不同文件夹中的文件可以重名。
      • 一般有三种命名空间：
        • 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
        • 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
        • 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）
      • 命名空间查找顺序:
        • 假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。
        • 如果找不到变量 runoob，它将放弃查找并引发一个 NameError 异常:
          • NameError: name 'runoob' is not defined。
      • 命名空间的生命周期：
        • 命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束。
        • 因此，我们无法从外部命名空间访问内部命名空间的对象。
        • 实例
          • # var1 是全局名称 var1 = 5 def some_func(): # var2 是局部名称 var2 = 6 def some_inner_func(): # var3 是内嵌的局部名称 var3 = 7
      • 如下图所示，相同的对象名称可以存在于多个命名空间中。
    • 作用域
      • A scope is a textual region of a Python program where a namespace is directly accessible. "Directly accessible" here means that an unqualified reference to a name attempts to find the name in the namespace.
      • 作用域就是一个 Python 程序可以直接访问命名空间的正文区域。
      • 在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误。
      • Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
      • 变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python 的作用域一共有4种，分别是：
      • 有四种作用域：
        • L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
        • E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
        • G（Global）：当前脚本的最外层，比如当前模块的全局变量。
        • B（Built-in）： 包含了内建的变量/关键字等，最后被搜索。
      • 规则顺序： L –> E –> G –> B。
      • 在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。
      • g_count = 0 # 全局作用域 def outer(): o_count = 1 # 闭包函数外的函数中 def inner(): i_count = 2 # 局部作用域
      • 内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量:
        • >>> import builtins >>> dir(builtins)
      • 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 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。
    • 全局变量和局部变量
      • 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
      • 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：
        • 实例(Python 3.0+)
          • 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：
        • 实例(Python 3.0+)
          • num = 1 def fun1(): global num # 需要使用 global 关键字声明 print(num) num = 123 print(num) fun1() print(num)
            • 1 123 123
      • 如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：
        • 实例(Python 3.0+)
          • def outer(): num = 10 def inner(): nonlocal num # nonlocal关键字声明 num = 100 print(num) inner() print(num) outer()
            • 100 100
      • 另外有一种特殊情况，假设下面这段代码被运行：
        • 实例(Python 3.0+)
          • 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
      • 错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。
      • 修改 a 为全局变量：
        • 实例
          • a = 10 def test(): global a a = a + 1 print(a) test() 执行输出结果为： 11
      • 也可以通过函数参数传递：
        • a = 10 def test(a): a = a + 1 print(a) test(a) 执行输出结果为： 11
  • 标准库概览
    • 操作系统接口
      • os模块提供了不少与操作系统相关联的函数。
      • 建议使用 "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']
    • 命令行参数
      • 通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。例如在命令行中执行 "python demo.py one two three" 后可以得到以下输出结果:
        • >>> import sys >>> print(sys.argv) ['demo.py', 'one', 'two', 'three']
    • 错误输出重定向和程序终止
      • sys 还有 stdin，stdout 和 stderr 属性，即使在 stdout 被重定向时，后者也可以用于显示警告和错误信息。
        • >>> sys.stderr.write('Warning, log file not found starting a new one\n') Warning, log file not found starting a new one
      • 大多脚本的定向终止都使用 "sys.exit()"。
    • 字符串正则匹配
      • 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('[e-mail]', '[e-mail]', ... """To: [e-mail] ... From: [e-mail] ... ... 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 正则表达式
    • 正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。
    • Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。
    • re 模块使 Python 语言拥有全部的正则表达式功能。
    • compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。
    • re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。
    • 本章节主要介绍 Python 中常用的正则表达式处理函数，如果你对正则表达式不了解，可以查看我们的 正则表达式 - 教程。
      • 正则表达式 - 教程
        • 正则表达式 - 简介
          • 除非您以前使用过正则表达式，否则您可能不熟悉一些术语。但是，毫无疑问，您已经使用过不涉及脚本的某些正则表达式概念。
          • 例如，您很可能使用 ? 和 * 通配符来查找硬盘上的文件。? 通配符匹配文件名中的 0 个或 1 个字符，而 * 通配符匹配零个或多个字符。像 data(\w)?\.dat 这样的模式将查找下列文件：
            • data.dat data1.dat data2.dat datax.dat dataN.dat
          • 使用 * 字符代替 ? 字符扩大了找到的文件的数量。data.*\.dat 匹配下列所有文件：
            • data.dat data1.dat data2.dat data12.dat datax.dat dataXYZ.dat
          • 尽管这种搜索方法很有用，但它还是有限的。通过理解 * 通配符的工作原理，引入了正则表达式所依赖的概念，但正则表达式功能更强大，而且更加灵活。
          • 正则表达式的使用，可以通过简单的办法来实现强大的功能。下面先给出一个简单的示例：
            • ^ 为匹配输入字符串的开始位置。
            • [0-9]+匹配多个数字， [0-9] 匹配单个数字，+ 匹配一个或者多个。
            • abc$匹配字母 abc 并以 abc 结尾，$ 为匹配输入字符串的结束位置。
          • 我们在写用户注册表单时，只允许用户名包含字符、数字、下划线和连接字符(-)，并设置用户名的长度，我们就可以使用以下正则表达式来设定。
          • 以上的正则表达式可以匹配 runoob、runoob1、run-oob、run_oob， 但不匹配 ru，因为它包含的字母太短了，小于 3 个无法匹配。也不匹配 runoob$, 因为它包含特殊字符。
            • 实例
              • var str = "123abc"; var patt1 = /^[0-9]+abc$/; document.write(str.match(patt1)); 以下标记的文本是获得的匹配的表达式： 123abc
            • 继续阅读本教程将让您也可以自由应用这样的代码。
          • 为什么使用正则表达式？
            • 典型的搜索和替换操作要求您提供与预期的搜索结果匹配的确切文本。虽然这种技术对于对静态文本执行简单搜索和替换任务可能已经足够了，但它缺乏灵活性，若采用这种方法搜索动态文本，即使不是不可能，至少也会变得很困难。
            • 通过使用正则表达式，可以：
              • 测试字符串内的模式。
                • 例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。
              • 替换文本。
                • 可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。
              • 基于模式匹配从字符串中提取子字符串。
                • 可以查找文档内或输入域内特定的文本。
            • 例如，您可能需要搜索整个网站，删除过时的材料，以及替换某些 HTML 格式标记。在这种情况下，可以使用正则表达式来确定在每个文件中是否出现该材料或该 HTML 格式标记。此过程将受影响的文件列表缩小到包含需要删除或更改的材料的那些文件。然后可以使用正则表达式来删除过时的材料。最后，可以使用正则表达式来搜索和替换标记。
          • 发展历史
            • 正则表达式的"祖先"可以一直上溯至对人类神经系统如何工作的早期研究。Warren McCulloch 和 Walter Pitts 这两位神经生理学家研究出一种数学方式来描述这些神经网络。
            • 1956 年, 一位叫 Stephen Kleene 的数学家在 McCulloch 和 Pitts 早期工作的基础上，发表了一篇标题为"神经网事件的表示法"的论文，引入了正则表达式的概念。正则表达式就是用来描述他称为"正则集的代数"的表达式，因此采用"正则表达式"这个术语。
            • 随后，发现可以将这一工作应用于使用 Ken Thompson 的计算搜索算法的一些早期研究，Ken Thompson 是 Unix 的主要发明人。正则表达式的第一个实用应用程序就是 Unix 中的 qed 编辑器。
            • 如他们所说，剩下的就是众所周知的历史了。从那时起直至现在正则表达式都是基于文本的编辑器和搜索工具中的一个重要部分。
          • 应用领域
            • 目前，正则表达式已经在很多软件中得到广泛的应用，包括 *nix（Linux, Unix等）、HP 等操作系统，PHP、C#、Java 等开发环境，以及很多的应用软件中，都可以看到正则表达式的影子。
          • C# 正则表达式
            • 在我们的 C# 教程中，C# 正则表达式 这一章节专门介绍了有关 C# 正则表达式的知识。
          • Java 正则表达式
            • 在我们的 Java 教程中，Java 正则表达式 这一章节专门介绍了有关 Java 正则表达式的知识。
          • JavaScript 正则表达式
            • 在我们的 JavaScript 教程中，JavaScript RegExp 对象 这一章节专门介绍了有关 JavaScript 正则表达式的知识，同时我们还提供了完整的 JavaScript RegExp 对象参考手册。
          • Python 正则表达式
            • 在我们的 Python 基础教程中，Python 正则表达式 这一章节专门介绍了有关 Python 正则表达式的知识。
          • Ruby 正则表达式
            • 在我们的 Ruby 教程中，Ruby 正则表达式 这一章节专门介绍了有关 Ruby 正则表达式的知识。
              • 命令或环境 . [ ] ^ $ \( \) \{ \} ? + | ( ) vi √√√√√ 　 　 　 　 　 Visual C++ √√√√√ 　 　 　 　 　 awk √√√√ 　awk是支持该语法的，只是要在命令 行加入 --posix or --re-interval参数即可，可见 man awk中的interval expression √√√√ sed √√√√√√ 　 　 　 　 delphi √√√√√ 　 √√√√ python √√√√√√ √√√√ java √√√√√√ √√√√　 javascript√√√√√ 　 √√√√ php √√√√√ 　 　 　 　 　 perl √√√√√ 　 √√√√ C# √√√√ 　 √√√√
        • 正则表达式 - 语法
          • 正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
          • 例如：
            • runoo+b，可以匹配 runoob、runooob、runoooooob 等，+ 号代表前面的字符必须至少出现一次（1次或多次）。
            • runoo*b，可以匹配 runob、runoob、runoooooob 等，* 号代表前面的字符可以不出现，也可以出现一次或者多次（0次、或1次、或多次）。
            • colou?r 可以匹配 color 或者 colour，? 问号代表前面的字符最多只可以出现一次（0次、或1次）。
          • 构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与运算符可以将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。
          • 正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为"元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
          • 普通字符
            • 普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。
              • 字符 描述 [ABC] 匹配 [...] 中的所有字符，例如 [aeiou] 匹配字符串 "google runoob taobao" 中所有的 e o u a 字母。 [^ABC] 匹配除了 [...] 中字符的所有字符，例如 [^aeiou] 匹配字符串 "google runoob taobao" 中除了 e o u a 字母的所有字母。 [A-Z] [A-Z] 表示一个区间，匹配所有大写字母，[a-z] 表示所有小写字母。 . 匹配除换行符（\n、\r）之外的任何单个字符，相等于 [^\n\r]。 [\s\S] 匹配所有。\s 是匹配所有空白符，包括换行，\S 非空白符，不包括换行。 \w 匹配字母、数字、下划线。等价于 [A-Za-z0-9_]
          • 测试工具
            • 修饰符： g [0-9]+ 匹配文本： 123abc456edf789
          • 非打印字符
            • 非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：
              • 字符 描述 \cx 匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。 \f 匹配一个换页符。等价于 \x0c 和 \cL。 \n 匹配一个换行符。等价于 \x0a 和 \cJ。 \r 匹配一个回车符。等价于 \x0d 和 \cM。 \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。 \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 \t 匹配一个制表符。等价于 \x09 和 \cI。 \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
          • 特殊字符
            • 所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 *，简单的说就是表示任何字符串的意思。如果要查找字符串中的 * 符号，则需要对 * 进行转义，即在其前加一个 \，runo\*ob 匹配字符串 runo*ob。
            • 许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符\ 放在它们前面。下表列出了正则表达式中的特殊字符：
              • 特别字符 描述 $ 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。 ( ) 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。 * 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。 + 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。 . 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \. 。 [ 标记一个中括号表达式的开始。要匹配 [，请使用 \[。 ? 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。 \ 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。 ^ 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 \^。 { 标记限定符表达式的开始。要匹配 {，请使用 \{。 | 指明两项之间的一个选择。要匹配 |，请使用 \|。
          • 限定符
            • 限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。
            • 正则表达式的限定符有：
              • 字符 描述
              • * 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
              • + 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
              • ? 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy" 中的 "do" 。? 等价于 {0,1}。
              • {n} n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
              • {n,} n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
              • {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
            • 以下正则表达式匹配一个正整数，[1-9]设置第一个数字不是 0，[0-9]* 表示任意多个数字：
              • /[1-9][0-9]*/
            • 请注意，限定符出现在范围表达式之后。因此，它应用于整个范围表达式，在本例中，只指定从 0 到 9 的数字（包括 0 和 9）。
            • 这里不使用 + 限定符，因为在第二个位置或后面的位置不一定需要有一个数字。也不使用 ? 字符，因为使用 ? 会将整数限制到只有两位数。
            • 如果你想设置 0~99 的两位数，可以使用下面的表达式来至少指定一位但至多两位数字。
              • /[0-9]{1,2}/
            • 上面的表达式的缺点是，只能匹配两位数字，而且可以匹配 0、00、01、10 99 的章节编号仍只匹配开头两位数字。
            • 改进下，匹配 1~99 的正整数表达式如下：
              • /[1-9][0-9]?/
              • 或
              • /[1-9][0-9]{0,1}/
            • * 和 + 限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个 ? 就可以实现非贪婪或最小匹配。
            • 例如，您可能搜索 HTML 文档，以查找在 h1 标签内的内容。HTML 代码如下：
              • <h1>RUNOOB-菜鸟教程</h1>
            • 贪婪：下面的表达式匹配从开始小于符号 (<) 到关闭 h1 标记的大于符号 (>) 之间的所有内容。
              • /<.*>/
            • 非贪婪：如果您只需要匹配开始和结束 h1 标签，下面的非贪婪表达式只匹配 <h1>。
              • /<.*?>/
            • 也可以使用以下正则表达式来匹配 h1 标签，表达式则是：
              • /<\w+?>/
            • 通过在 *、+ 或 ? 限定符之后放置 ?，该表达式从"贪婪"表达式转换为"非贪婪"表达式或者最小匹配。
          • 定位符
            • 定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。
            • 定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\b 描述单词的前或后边界，\B 表示非单词边界。
            • 正则表达式的定位符有：
              • 字符 描述
              • ^ 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。
              • $ 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。
              • \b 匹配一个单词边界，即字与空格间的位置。
              • \B 非单词边界匹配。
            • 注意：不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式。
            • 若要匹配一行文本开始处的文本，请在正则表达式的开始使用 ^ 字符。不要将 ^ 的这种用法与中括号表达式内的用法混淆。
            • 若要匹配一行文本的结束处的文本，请在正则表达式的结束处使用 $ 字符。
            • 若要在搜索章节标题时使用定位点，下面的正则表达式匹配一个章节标题，该标题只包含两个尾随数字，并且出现在行首：
              • /^Chapter [1-9][0-9]{0,1}/
            • 真正的章节标题不仅出现行的开始处，而且它还是该行中仅有的文本。它既出现在行首又出现在同一行的结尾。下面的表达式能确保指定的匹配只匹配章节而不匹配交叉引用。通过创建只匹配一行文本的开始和结尾的正则表达式，就可做到这一点。
              • /^Chapter [1-9][0-9]{0,1}$/
            • 匹配单词边界稍有不同，但向正则表达式添加了很重要的能力。单词边界是单词和空格之间的位置。非单词边界是任何其他位置。下面的表达式匹配单词 Chapter 的开头三个字符，因为这三个字符出现在单词边界后面：
              • /\bCha/
            • \b 字符的位置是非常重要的。如果它位于要匹配的字符串的开始，它在单词的开始处查找匹配项。如果它位于字符串的结尾，它在单词的结尾处查找匹配项。例如，下面的表达式匹配单词 Chapter 中的字符串 ter，因为它出现在单词边界的前面：
              • /ter\b/
            • 下面的表达式匹配 Chapter 中的字符串 apt，但不匹配 aptitude 中的字符串 apt：
              • /\Bapt/
            • 字符串 apt 出现在单词 Chapter 中的非单词边界处，但出现在单词 aptitude 中的单词边界处。对于 \B 非单词边界运算符，位置并不重要，因为匹配不关心究竟是单词的开头还是结尾。
          • 选择
            • 用圆括号 () 将所有选择项括起来，相邻的选择项之间用 | 分隔。
            • () 表示捕获分组，() 会把每个分组里的匹配的值保存起来， 多个匹配值可以通过数字 n 来查看(n 是一个数字，表示第 n 个捕获组的内容)。
            • 但用圆括号会有一个副作用，使相关的匹配会被缓存，此时可用 ?: 放在第一个选项前来消除这种副作用。
            • 其中 ?: 是非捕获元之一，还有两个非捕获元是 ?= 和 ?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。
          • 以下列出 ?=、?<=、?!、?<! 的使用区别
            • exp1(?=exp2)：查找 exp2 前面的 exp1。
          • 反向引用
            • 对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用 \n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
            • 可以使用非捕获元字符 ?:、?= 或 ?! 来重写捕获，忽略对相关匹配的保存。
            • 反向引用的最简单的、最有用的应用之一，是提供查找文本中两个相同的相邻单词的匹配项的能力。以下面的句子为例：
              • Is is the cost of of gasoline going up up?
            • 上面的句子很显然有多个重复的单词。如果能设计一种方法定位该句子，而不必查找每个单词的重复出现，那该有多好。下面的正则表达式使用单个子表达式来实现这一点：
              • var str = "Is is the cost of of gasoline going up up"; var patt1 = /\b([a-z]+) \1\b/ig; document.write(str.match(patt1));
            • 捕获的表达式，正如 [a-z]+ 指定的，包括一个或多个字母。正则表达式的第二部分是对以前捕获的子匹配项的引用，即，单词的第二个匹配项正好由括号表达式匹配。\1 指定第一个子匹配项。
            • 单词边界元字符确保只检测整个单词。否则，诸如 "is issued" 或 "this is" 之类的词组将不能正确地被此表达式识别。
            • 正则表达式后面的全局标记 g 指定将该表达式应用到输入字符串中能够查找到的尽可能多的匹配。
            • 表达式的结尾处的不区分大小写 i 标记指定不区分大小写。
            • 多行标记指定换行符的两边可能出现潜在的匹配。
            • 反向引用还可以将通用资源指示符 (URI) 分解为其组件。假定您想将下面的 URI 分解为协议（ftp、http 等等）、域地址和页/路径：
              • http://www.runoob.com:80/html/html-tutorial.html
            • 下面的正则表达式提供该功能：
              • var str = "http://www.runoob.com:80/html/html-tutorial.html"; var patt1 = /(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/; arr = str.match(patt1); for (var i = 0; i < arr.length ; i++) { document.write(arr[i]); document.write("<br>"); }
            • 第三行代码 str.match(patt1) 返回一个数组，实例中的数组包含 5 个元素，索引 0 对应的是整个字符串，索引 1 对应第一个匹配符（括号内），以此类推。
            • 第一个括号子表达式捕获 Web 地址的协议部分。该子表达式匹配在冒号和两个正斜杠前面的任何单词。
            • 第二个括号子表达式捕获地址的域地址部分。子表达式匹配非 : 和 / 之后的一个或多个字符。
            • 第三个括号子表达式捕获端口号（如果指定了的话）。该子表达式匹配冒号后面的零个或多个数字。只能重复一次该子表达式。
            • 最后，第四个括号子表达式捕获 Web 地址指定的路径和 / 或页信息。该子表达式能匹配不包括 # 或空格字符的任何字符序列。
            • 将正则表达式应用到上面的 URI，各子匹配项包含下面的内容：
              • 第一个括号子表达式包含 http
              • 第二个括号子表达式包含 www.runoob.com
              • 第三个括号子表达式包含 :80
              • 第四个括号子表达式包含 /html/html-tutorial.html
        • 正则表达式 - 修饰符（标记）
          • 标记也称为修饰符，正则表达式的标记用于指定额外的匹配策略。
          • 标记不写在正则表达式里，标记位于表达式之外，格式如下：
            • /pattern/flags
          • 下表列出了正则表达式常用的修饰符：
            • 修饰符 含义 描述
            • i ignore - 不区分大小写 将匹配设置为不区分大小写，搜索时不区分大小写: A 和 a 没有区别。
            • g global - 全局匹配 查找所有的匹配项。
            • m multi line - 多行匹配 使边界字符 ^ 和 $ 匹配每一行的开头和结尾，记住是多行，而不是整个字符串的开头和结尾。
            • s 特殊字符圆点 . 中包含换行符 \n 默认情况下的圆点 . 是 匹配除换行符 \n 之外的任何字符，加上 s 修饰符之后, . 中包含换行符 \n。
          • g 修饰符
            • g 修饰符可以查找字符串中所有的匹配项：
          • 实例
            • 在字符串中查找 "runoob":
              • var str="Google runoob taobao runoob"; var n1=str.match(/runoob/); // 查找第一次匹配项 var n2=str.match(/runoob/g); // 查找所有匹配项
          • i 修饰符
            • i 修饰符为不区分大小写匹配，实例如下：
          • 实例
            • 在字符串中查找 "runoob":
              • var str="Google runoob taobao RUNoob"; var n1=str.match(/runoob/g); // 区分大小写 var n2=str.match(/runoob/gi); // 不区分大小写
          • m 修饰符
            • m 修饰符可以使 ^ 和 $ 匹配一段文本中每行的开始和结束位置。
            • g 只匹配第一行，添加 m 之后实现多行。
            • 以下实例字符串中使用 \n 来换行：
              • 实例
                • 在字符串中查找 "runoob":
                  • var str="runoobgoogle\ntaobao\nrunoobweibo"; var n1=str.match(/^runoob/g); // 匹配一个 var n2=str.match(/^runoob/gm); // 多行匹配
          • s 修饰符
            • 默认情况下的圆点 . 是 匹配除换行符 \n 之外的任何字符，加上 s 之后, . 中包含换行符 \n。
            • s 修饰符实例如下：
              • 实例
                • 在字符串中查找:
                  • var str="google\nrunoob\ntaobao"; var n1=str.match(/google./); // 没有使用 s，无法匹配\n var n2=str.match(/runoob./s); // 使用 s，匹配\n
        • 正则表达式 - 元字符
          • 下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为：
            • 字符 描述
            • \
            • 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
            • ^
            • 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
            • $
            • 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
            • *
            • 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
            • +
            • 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
            • ?
            • 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。
            • {n}
            • n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
            • {n,}
            • n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
            • {n,m}
            • m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
            • ?
            • 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
            • .
            • 匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用像"(.|\n)"的模式。
            • (pattern)
            • 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。
            • (?:pattern)
            • 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
            • (?=pattern)
            • 正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
            • (?!pattern)
            • 正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
            • (?<=pattern) 反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，"(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"。
            • (?<!pattern) 反向否定预查，与正向否定预查类似，只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"。
            • x|y
            • 匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
            • [xyz]
            • 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
            • [^xyz]
            • 负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。
            • [a-z]
            • 字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
            • [^a-z]
            • 负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
            • \b
            • 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
            • \B
            • 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
            • \cx
            • 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
            • \d
            • 匹配一个数字字符。等价于 [0-9]。
            • \D
            • 匹配一个非数字字符。等价于 [^0-9]。
            • \f
            • 匹配一个换页符。等价于 \x0c 和 \cL。
            • \n
            • 匹配一个换行符。等价于 \x0a 和 \cJ。
            • \r
            • 匹配一个回车符。等价于 \x0d 和 \cM。
            • \s
            • 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
            • \S
            • 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
            • \t
            • 匹配一个制表符。等价于 \x09 和 \cI。
            • \v
            • 匹配一个垂直制表符。等价于 \x0b 和 \cK。
            • \w
            • 匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。
            • \W
            • 匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。
            • \xn
            • 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。
            • \num
            • 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。
            • \n
            • 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
            • \nm
            • 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
            • \nml
            • 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
            • \un
            • 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。
          • 实例
            • 接下来我们分析一个匹配邮箱的正则表达式，如下图：
              • 实例
                • var str = "abcd [e-mail] 1234"; var patt1 = /\b[\w.%+-]+@[\w.-]+\.[a-zA-Z]{2,6}\b/g; document.write(str.match(patt1));
        • 正则表达式 - 运算符优先级
          • 正则表达式从左到右进行计算，并遵循优先级顺序，这与算术表达式非常类似。
          • 相同优先级的从左到右进行运算，不同优先级的运算先高后低。下表从最高到最低说明了各种正则表达式运算符的优先级顺序：
            • 运算符 描述
            • \ 转义符
            • (), (?:), (?=), [] 圆括号和方括号
            • *, +, ?, {n}, {n,}, {n,m} 限定符
            • ^, $, \任何元字符、任何字符 定位点和序列（即：位置和顺序）
            • | 替换，"或"操作
            • 字符具有高于替换运算符的优先级，使得"m|food"匹配"m"或"food"。若要匹配"mood"或"food"，请使用括号创建子表达式，从而产生"(m|f)ood"。
        • 正则表达式 - 匹配规则
          • 基本模式匹配
          • 一切从最基本的开始。模式，是正则表达式最基本的元素，它们是一组描述字符串特征的字符。模式可以很简单，由普通的字符串组成，也可以非常复杂，往往用特殊的字符表示一个范围内的字符、重复出现，或表示上下文。例如：
            • ^once
          • 这个模式包含一个特殊的字符 ^，表示该模式只匹配那些以 once 开头的字符串。例如该模式与字符串 "once upon a time" 匹配，与 "There once was a man from NewYork" 不匹配。正如如 ^ 符号表示开头一样，$ 符号用来匹配那些以给定模式结尾的字符串。
            • bucket$
          • 这个模式与 "Who kept all of this cash in a bucket" 匹配，与 "buckets" 不匹配。字符 ^ 和 $ 同时使用时，表示精确匹配（字符串与模式一样）。例如：
            • ^bucket$
          • 只匹配字符串 "bucket"。如果一个模式不包括 ^ 和 $，那么它与任何包含该模式的字符串匹配。例如模式：
            • once
          • 与字符串
            • There once was a man from NewYork Who kept all of his cash in a bucket.
          • 是匹配的。
          • 在该模式中的字母 (o-n-c-e) 是字面的字符，也就是说，他们表示该字母本身，数字也是一样的。其他一些稍微复杂的字符，如标点符号和白字符（空格、制表符等），要用到转义序列。所有的转义序列都用反斜杠 \ 打头。制表符的转义序列是 \t。所以如果我们要检测一个字符串是否以制表符开头，可以用这个模式：
            • ^\t
          • 类似的，用 \n 表示"新行"，\r 表示回车。其他的特殊符号，可以用在前面加上反斜杠，如反斜杠本身用 \\ 表示，句号 . 用 \. 表示，以此类推。
          • 字符簇
            • 在 INTERNET 的程序中，正则表达式通常用来验证用户的输入。当用户提交一个 FORM 以后，要判断输入的电话号码、地址、EMAIL 地址、信用卡号码等是否有效，用普通的基于字面的字符是不够的。
            • 所以要用一种更自由的描述我们要的模式的办法，它就是字符簇。要建立一个表示所有元音字符的字符簇，就把所有的元音字符放在一个方括号里：
              • [AaEeIiOoUu]
            • 这个模式与任何元音字符匹配，但只能表示一个字符。用连字号可以表示一个字符的范围，如：
              • [a-z] // 匹配所有的小写字母 [A-Z] // 匹配所有的大写字母 [a-zA-Z] // 匹配所有的字母 [0-9] // 匹配所有的数字 [0-9\.\-] // 匹配所有的数字，句号和减号 [ \f\r\t\n] // 匹配所有的白字符
          • 同样的，这些也只表示一个字符，这是一个非常重要的。如果要匹配一个由一个小写字母和一位数字组成的字符串，比如 "z2"、"t6" 或 "g7"，但不是 "ab2"、"r2d3" 或 "b52" 的话，用这个模式：
            • ^[a-z][0-9]$
          • 尽管 [a-z] 代表 26 个字母的范围，但在这里它只能与第一个字符是小写字母的字符串匹配。
          • 前面曾经提到^表示字符串的开头，但它还有另外一个含义。当在一组方括号里使用 ^ 时，它表示"非"或"排除"的意思，常常用来剔除某个字符。还用前面的例子，我们要求第一个字符不能是数字：
            • ^[^0-9][0-9]$
          • 这个模式与 "&5"、"g7"及"-2" 是匹配的，但与 "12"、"66" 是不匹配的。下面是几个排除特定字符的例子：
            • [^a-z] //除了小写字母以外的所有字符 [^\\\/\^] //除了(\)(/)(^)之外的所有字符 [^\"\'] //除了双引号(")和单引号(')之外的所有字符
          • 特殊字符 .(点，句号)在正则表达式中用来表示除了"新行"之外的所有字符。所以模式 ^.5$ 与任何两个字符的、以数字5结尾和以其他非"新行"字符开头的字符串匹配。模式 . 可以匹配任何字符串，换行符（\n、\r）除外。
          • PHP的正则表达式有一些内置的通用字符簇，列表如下：
            • 字符簇 描述 [[:alpha:]] 任何字母 [[:digit:]] 任何数字 [[:alnum:]] 任何字母和数字 [[:space:]] 任何空白字符 [[:upper:]] 任何大写字母 [[:lower:]] 任何小写字母 [[:punct:]] 任何标点符号 [[:xdigit:]] 任何16进制的数字，相当于[0-9a-fA-F]
          • 确定重复出现
            • 到现在为止，你已经知道如何去匹配一个字母或数字，但更多的情况下，可能要匹配一个单词或一组数字。一个单词有若干个字母组成，一组数字有若干个单数组成。跟在字符或字符簇后面的花括号({})用来确定前面的内容的重复出现的次数。
              • 字符簇 描述
              • ^[a-zA-Z_]$ 所有的字母和下划线
              • ^[[:alpha:]]{3}$ 所有的3个字母的单词
              • ^a$ 字母a
              • ^a{4}$ aaaa
              • ^a{2,4}$ aa,aaa或aaaa
              • ^a{1,3}$ a,aa或aaa
              • ^a{2,}$ 包含多于两个a的字符串
              • ^a{2,} 如：aardvark和aaab，但apple不行
              • a{2,} 如：baad和aaa，但Nantucket不行
              • \t{2} 两个制表符
              • .{2} 所有的两个字符
          • 这些例子描述了花括号的三种不同的用法。一个数字 {x} 的意思是前面的字符或字符簇只出现x次 ；一个数字加逗号 {x,} 的意思是前面的内容出现x或更多的次数 ；两个数字用逗号分隔的数字 {x,y} 表示 前面的内容至少出现x次，但不超过y次。我们可以把模式扩展到更多的单词或数字：
            • ^[a-zA-Z0-9_]{1,}$ // 所有包含一个以上的字母、数字或下划线的字符串 ^[1-9][0-9]{0,}$ // 所有的正整数 ^\-{0,1}[0-9]{1,}$ // 所有的整数 ^[-]?[0-9]+\.?[0-9]+$ // 所有的浮点数
          • 最后一个例子不太好理解，是吗？这么看吧：以一个可选的负号 ([-]?) 开头 (^)、跟着1个或更多的数字([0-9]+)、和一个小数点(\.)再跟上1个或多个数字([0-9]+)，并且后面没有其他任何东西($)。下面你将知道能够使用的更为简单的方法。
          • 特殊字符 ? 与 {0,1} 是相等的，它们都代表着： 0个或1个前面的内容 或 前面的内容是可选的 。所以刚才的例子可以简化为：
            • ^\-?[0-9]{1,}\.?[0-9]{1,}$
          • 特殊字符 * 与 {0,} 是相等的，它们都代表着 0 个或多个前面的内容 。最后，字符 + 与 {1,} 是相等的，表示 1 个或多个前面的内容 ，所以上面的4个例子可以写成：
            • ^[a-zA-Z0-9_]+$ // 所有包含一个以上的字母、数字或下划线的字符串 ^[1-9][0-9]*$ // 所有的正整数 ^\-?[0-9]+$ // 所有的整数 ^[-]?[0-9]+(\.[0-9]+)?$ // 所有的浮点数
          • 当然这并不能从技术上降低正则表达式的复杂性，但可以使它们更容易阅读。
        • 正则表达式 - 示例
          • 简单表达式
            • 正则表达式的最简单形式是在搜索字符串中匹配其本身的单个普通字符。例如，单字符模式，如 A，不论出现在搜索字符串中的何处，它总是匹配字母 A。下面是一些单字符正则表达式模式的示例：
              • /a/ /7/ /M/
            • 可以将许多单字符组合起来以形成大的表达式。例如，以下正则表达式组合了单字符表达式：a、7 和 M。
              • /a7M/
            • 请注意，没有串联运算符。只须在一个字符后面键入另一个字符。
          • 字符匹配
            • 句点 (.) 匹配字符串中的各种打印或非打印字符，只有一个字符例外。这个例外就是换行符 (\n)。下面的正则表达式匹配 aac、abc、acc、adc 等等，以及 a1c、a2c、a-c 和 a#c：
              • /a.c/
            • 若要匹配包含文件名的字符串，而句点 (.) 是输入字符串的组成部分，请在正则表达式中的句点前面加反斜杠 (\) 字符。举例来说明，下面的正则表达式匹配 filename.ext：
              • /filename\.ext/
            • 这些表达式只让您匹配"任何"单个字符。可能需要匹配列表中的特定字符组。例如，可能需要查找用数字表示的章节标题（Chapter 1、Chapter 2 等等）。
          • 中括号表达式
            • 若要创建匹配字符组的一个列表，请在方括号（[ 和 ]）内放置一个或更多单个字符。当字符括在中括号内时，该列表称为"中括号表达式"。与在任何别的位置一样，普通字符在中括号内表示其本身，即，它在输入文本中匹配一次其本身。大多数特殊字符在中括号表达式内出现时失去它们的意义。不过也有一些例外，如：
              • 如果 ] 字符不是第一项，它结束一个列表。若要匹配列表中的 ] 字符，请将它放在第一位，紧跟在开始 [ 后面。
              • \ 字符继续作为转义符。若要匹配 \ 字符，请使用 \\。
            • 括在中括号表达式中的字符只匹配处于正则表达式中该位置的单个字符。以下正则表达式匹配 Chapter 1、Chapter 2、Chapter 3、Chapter 4 和 Chapter 5：
              • /Chapter [12345]/
            • 请注意，单词 Chapter 和后面的空格的位置相对于中括号内的字符是固定的。中括号表达式指定的只是匹配紧跟在单词 Chapter 和空格后面的单个字符位置的字符集。这是第九个字符位置。
            • 若要使用范围代替字符本身来表示匹配字符组，请使用连字符 (-) 将范围中的开始字符和结束字符分开。单个字符的字符值确定范围内的相对顺序。下面的正则表达式包含范围表达式，该范围表达式等效于上面显示的中括号中的列表。
              • /Chapter [1-5]/
            • 当以这种方式指定范围时，开始值和结束值两者都包括在范围内。注意，还有一点很重要，按 Unicode 排序顺序，开始值必须在结束值的前面。
            • 若要在中括号表达式中包括连字符，请采用下列方法之一：
              • 用反斜杠将它转义：
                • [\-]
              • 将连字符放在中括号列表的开始或结尾。下面的表达式匹配所有小写字母和连字符：
                • [-a-z] [a-z-]
              • 创建一个范围，在该范围中，开始字符值小于连字符，而结束字符值等于或大于连字符。下面的两个正则表达式都满足这一要求：
                • [!--] [!-~]
            • 若要查找不在列表或范围内的所有字符，请将插入符号 (^) 放在列表的开头。如果插入字符出现在列表中的其他任何位置，则它匹配其本身。下面的正则表达式匹配1、2、3、4 或 5 之外的任何数字和字符：
              • /Chapter [^12345]/
            • 在上面的示例中，表达式在第九个位置匹配 1、2、3、4 或 5 之外的任何数字和字符。这样，例如，Chapter 7 就是一个匹配项，Chapter 9 也是一个匹配项。
            • 上面的表达式可以使用连字符 (-) 来表示：
              • /Chapter [^1-5]/
            • 中括号表达式的典型用途是指定任何大写或小写字母或任何数字的匹配。下面的表达式指定这样的匹配：
              • /[A-Za-z0-9]/
          • 替换和分组
            • 替换使用 | 字符来允许在两个或多个替换选项之间进行选择。例如，可以扩展章节标题正则表达式，以返回比章标题范围更广的匹配项。但是，这并不象您可能认为的那样简单。替换匹配 | 字符任一侧最大的表达式。
            • 您可能认为，下面的表达式匹配出现在行首和行尾、后面跟一个或两个数字的 Chapter 或 Section：
              • /^Chapter|Section [1-9][0-9]{0,1}$/
            • 很遗憾，上面的正则表达式要么匹配行首的单词 Chapter，要么匹配行尾的单词 Section 及跟在其后的任何数字。如果输入字符串是 Chapter 22，那么上面的表达式只匹配单词 Chapter。如果输入字符串是 Section 22，那么该表达式匹配 Section 22。
            • 若要使正则表达式更易于控制，可以使用括号来限制替换的范围，即，确保它只应用于两个单词 Chapter 和 Section。但是，括号也用于创建子表达式，并可能捕获它们以供以后使用，这一点在有关反向引用的那一节讲述。通过在上面的正则表达式的适当位置添加括号，就可以使该正则表达式匹配 Chapter 1 或 Section 3。
            • 下面的正则表达式使用括号来组合 Chapter 和 Section，以便表达式正确地起作用：
              • /^(Chapter|Section) [1-9][0-9]{0,1}$/
            • 尽管这些表达式正常工作，但 Chapter|Section 周围的括号还将捕获两个匹配字中的任一个供以后使用。由于在上面的表达式中只有一组括号，因此，只有一个被捕获的"子匹配项"。
            • 在上面的示例中，您只需要使用括号来组合单词 Chapter 和 Section 之间的选择。若要防止匹配被保存以备将来使用，请在括号内正则表达式模式之前放置 ?:。下面的修改提供相同的能力而不保存子匹配项：
              • /^(?:Chapter|Section) [1-9][0-9]{0,1}$/
            • 除 ?: 元字符外，两个其他非捕获元字符创建被称为"预测先行"匹配的某些内容。正向预测先行使用 ?= 指定，它匹配处于括号中匹配正则表达式模式的起始点的搜索字符串。反向预测先行使用 ?! 指定，它匹配处于与正则表达式模式不匹配的字符串的起始点的搜索字符串。
            • 例如，假设您有一个文档，该文档包含指向 Windows 3.1、Windows 95、Windows 98 和 Windows NT 的引用。再进一步假设，您需要更新该文档，将指向 Windows 95、Windows 98 和 Windows NT 的所有引用更改为 Windows 2000。下面的正则表达式（这是一个正向预测先行的示例）匹配 Windows 95、Windows 98 和 Windows NT：
              • /Windows(?=95 |98 |NT )/
            • 找到一处匹配后，紧接着就在匹配的文本（不包括预测先行中的字符）之后搜索下一处匹配。例如，如果上面的表达式匹配 Windows 98，将在 Windows 之后而不是在 98 之后继续搜索。
          • 其他示例
            • 下面列出一些正则表达式示例：
              • 正则表达式 描述
              • /\b([a-z]+) \1\b/gi 一个单词连续出现的位置。
              • /(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/ 将一个URL解析为协议、域、端口及相对路径。
              • /^(?:Chapter|Section) [1-9][0-9]{0,1}$/ 定位章节的位置。
              • /[-a-z]/ a至z共26个字母再加一个-号。
              • /ter\b/ 可匹配chapter，而不能匹配terminal。
              • /\Bapt/ 可匹配chapter，而不能匹配aptitude。
              • /Windows(?=95 |98 |NT )/ 可匹配Windows95或Windows98或WindowsNT，当找到一个匹配后，从Windows后面开始进行下一次的检索匹配。
              • /^\s*$/ 匹配空行。
              • /\d{2}-\d{5}/ 验证由两位数字、一个连字符再加 5 位数字组成的 ID 号。
              • /<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*\/\1\s*>/ 匹配 HTML 标记。
    • re.match函数
      • re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
      • 函数语法：
      • re.match(pattern, string, flags=0)
      • 函数参数说明：
        • 参数 描述
        • pattern 匹配的正则表达式
        • string 要匹配的字符串。
        • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
      • 匹配成功re.match方法返回一个匹配的对象，否则返回None。
      • 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
        • 匹配对象方法 描述
        • group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
        • groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
      • 实例
        • import re print(re.match('www', 'www.runoob.com').span()) # 在起始位置匹配 print(re.match('com', 'www.runoob.com')) # 不在起始位置匹配
          • 以上实例运行输出结果为：
          • (0, 3) None
      • 实例
        • import re line = "Cats are smarter than dogs" # .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符 # (.*?) 表示"非贪婪"模式，只保存第一个匹配到的子串 matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I) if matchObj: print ("matchObj.group() : ", matchObj.group()) print ("matchObj.group(1) : ", matchObj.group(1)) print ("matchObj.group(2) : ", matchObj.group(2)) else: print ("No match!!")
          • matchObj.group() : Cats are smarter than dogs matchObj.group(1) : Cats matchObj.group(2) : smarter
    • re.search函数
      • re.search 扫描整个字符串并返回第一个成功的匹配。
      • 函数语法：
        • re.search(pattern, string, flags=0)
      • 函数参数说明：
        • 参数 描述
        • pattern 匹配的正则表达式
        • string 要匹配的字符串。
        • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
      • 匹配成功re.search方法返回一个匹配的对象，否则返回None。
      • 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
        • 匹配对象方法 描述
        • group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
        • groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
      • 实例
        • import re print(re.search('www', 'www.runoob.com').span()) # 在起始位置匹配 print(re.search('com', 'www.runoob.com').span()) # 不在起始位置匹配
          • (0, 3) (11, 14)
      • 实例
        • import re line = "Cats are smarter than dogs" searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I) if searchObj: print ("searchObj.group() : ", searchObj.group()) print ("searchObj.group(1) : ", searchObj.group(1)) print ("searchObj.group(2) : ", searchObj.group(2)) else: print ("Nothing found!!")
          • searchObj.group() : Cats are smarter than dogs searchObj.group(1) : Cats searchObj.group(2) : smarter
    • re.match和re.search的区别
      • re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而 re.search 匹配整个字符串，直到找到一个匹配。
      • 实例
        • import re line = "Cats are smarter than dogs" matchObj = re.match( r'dogs', line, re.M|re.I) if matchObj: print ("match --> matchObj.group() : ", matchObj.group()) else: print ("No match!!") matchObj = re.search( r'dogs', line, re.M|re.I) if matchObj: print ("search --> matchObj.group() : ", matchObj.group()) else: print ("No match!!")
          • No match!! search --> matchObj.group() : dogs
    • 检索和替换
      • Python 的re模块提供了re.sub用于替换字符串中的匹配项。
      • 语法：
        • re.sub(pattern, repl, string, count=0, flags=0)
      • 参数：
        • pattern : 正则中的模式字符串。
        • repl : 替换的字符串，也可为一个函数。
        • string : 要被查找替换的原始字符串。
        • count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
        • flags : 编译时用的匹配模式，数字形式。
      • 前三个为必选参数，后两个为可选参数。
      • 实例
        • import re phone = "2004-959-559 # 这是一个电话号码" # 删除注释 num = re.sub(r'#.*$', "", phone) print ("电话号码 : ", num) # 移除非数字的内容 num = re.sub(r'\D', "", phone) print ("电话号码 : ", num)
          • 电话号码 : 2004-959-559 电话号码 : 2004959559
      • repl 参数是一个函数
        • 以下实例中将字符串中的匹配的数字乘于 2：
        • 实例
          • import re # 将匹配的数字乘于 2 def double(matched): value = int(matched.group('value')) return str(value * 2) s = 'A23G4HFD567' print(re.sub('(?P<value>\d+)', double, s))
            • A46G8HFD1134
      • compile 函数
        • compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
        • 语法格式为：
          • re.compile(pattern[, flags])
        • 参数：
          • pattern : 一个字符串形式的正则表达式
          • flags 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
            • re.I 忽略大小写
            • re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
            • re.M 多行模式
            • re.S 即为' . '并且包括换行符在内的任意字符（' . '不包括换行符）
            • re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
            • re.X 为了增加可读性，忽略空格和' # '后面的注释
        • 实例
          • 实例
            • >>>import re >>> pattern = re.compile(r'\d+') # 用于匹配至少一个数字 >>> m = pattern.match('one12twothree34four') # 查找头部，没有匹配 >>> print( m ) None >>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配 >>> print( m ) None >>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配 >>> print( m ) # 返回一个 Match 对象 <_sre.SRE_Match object at 0x10a42aac0> >>> m.group(0) # 可省略 0 '12' >>> m.start(0) # 可省略 0 3 >>> m.end(0) # 可省略 0 5 >>> m.span(0) # 可省略 0 (3, 5)
          • 在上面，当匹配成功时返回一个 Match 对象，其中：
            • group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
            • start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
            • end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
            • span([group]) 方法返回 (start(group), end(group))。
          • 再看看一个例子：
            • >>>import re >>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I) # re.I 表示忽略大小写 >>> m = pattern.match('Hello World Wide Web') >>> print( m ) # 匹配成功，返回一个 Match 对象 <_sre.SRE_Match object at 0x10bea83e8> >>> m.group(0) # 返回匹配成功的整个子串 'Hello World' >>> m.span(0) # 返回匹配成功的整个子串的索引 (0, 11) >>> m.group(1) # 返回第一个分组匹配成功的子串 'Hello' >>> m.span(1) # 返回第一个分组匹配成功的子串的索引 (0, 5) >>> m.group(2) # 返回第二个分组匹配成功的子串 'World' >>> m.span(2) # 返回第二个分组匹配成功的子串索引 (6, 11) >>> m.groups() # 等价于 (m.group(1), m.group(2), ...) ('Hello', 'World') >>> m.group(3) # 不存在第三个分组 Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: no such group
      • findall
        • 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
          • 注意： match 和 search 是匹配一次 findall 匹配所有。
        • 语法格式为：
          • re.findall(pattern, string, flags=0)
          • 或
          • pattern.findall(string[, pos[, endpos]])
        • 参数：
          • pattern 匹配模式。
          • string 待匹配的字符串。
          • pos 可选参数，指定字符串的起始位置，默认为 0。
          • endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。
        • 查找字符串中的所有数字：
          • 实例
            • import re result1 = re.findall(r'\d+','runoob 123 google 456') pattern = re.compile(r'\d+') # 查找数字 result2 = pattern.findall('runoob 123 google 456') result3 = pattern.findall('run88oob123google456', 0, 10) print(result1) print(result2) print(result3)
              • ['123', '456'] ['123', '456'] ['88', '12']
          • 多个匹配模式，返回元组列表：
            • 实例
              • import re result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10') print(result)
                • [('width', '20'), ('height', '10')]
      • re.finditer
        • 和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
          • re.finditer(pattern, string, flags=0)
        • 参数：
          • 参数 描述
          • pattern 匹配的正则表达式
          • string 要匹配的字符串。
          • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
        • 实例
          • import re it = re.finditer(r"\d+","12a32bc43jf3") for match in it: print (match.group() )
            • 12 32 43 3
      • re.split
        • split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
          • re.split(pattern, string[, maxsplit=0, flags=0])
        • 参数：
          • 参数 描述
          • pattern 匹配的正则表达式
          • string 要匹配的字符串。
          • maxsplit 分割次数，maxsplit=1 分割一次，默认为 0，不限制次数。
          • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
        • 实例
          • >>>import re >>> re.split('\W+', 'runoob, runoob, runoob.') ['runoob', 'runoob', 'runoob', ''] >>> re.split('(\W+)', ' runoob, runoob, runoob.') ['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', ''] >>> re.split('\W+', ' runoob, runoob, runoob.', 1) ['', 'runoob, runoob, runoob.'] >>> re.split('a*', 'hello world') # 对于一个找不到匹配的字符串而言，split 不会对其作出分割 ['hello world']
    • 正则表达式对象
      • re.RegexObject
        • re.compile() 返回 RegexObject 对象。
      • re.MatchObject
        • group() 返回被 RE 匹配的字符串。
        • start() 返回匹配开始的位置
        • end() 返回匹配结束的位置
        • span() 返回一个元组包含匹配 (开始,结束) 的位置
    • 正则表达式修饰符-可选标志
      • 正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：
        • 修饰符 描述
        • re.I 使匹配对大小写不敏感
        • re.L 做本地化识别（locale-aware）匹配
        • re.M 多行匹配，影响 ^ 和 $
        • re.S 使 . 匹配包括换行在内的所有字符
        • re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
        • re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
    • 正则表达式模式
      • 模式字符串使用特殊的语法来表示一个正则表达式。
      • 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
      • 多数字母和数字前加一个反斜杠时会拥有不同的含义。
      • 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
      • 反斜杠本身需要使用反斜杠转义。
      • 由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 \\t )匹配相应的特殊字符。
      • 下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。
      • 模式 描述
        • ^ 匹配字符串的开头
        • $ 匹配字符串的末尾。
        • . 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
        • [...] 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
        • [^...] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
        • re* 匹配0个或多个的表达式。
        • re+ 匹配1个或多个的表达式。
        • re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
        • re{ n} 匹配n个前面表达式。例如，"o{2}"不能匹配"Bob"中的"o"，但是能匹配"food"中的两个o。
        • re{ n,} 精确匹配n个前面表达式。例如，"o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。
        • re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
        • a| b 匹配a或b
        • (re) 匹配括号内的表达式，也表示一个组
        • (?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
        • (?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
        • (?: re) 类似 (...), 但是不表示一个组
        • (?imx: re) 在括号中使用i, m, 或 x 可选标志
        • (?-imx: re) 在括号中不使用i, m, 或 x 可选标志
        • (?#...) 注释.
        • (?= re) 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
        • (?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
        • (?> re) 匹配的独立模式，省去回溯。
        • \w 匹配数字字母下划线
        • \W 匹配非数字字母下划线
        • \s 匹配任意空白字符，等价于 [\t\n\r\f]。
        • \S 匹配任意非空字符
        • \d 匹配任意数字，等价于 [0-9]。
        • \D 匹配任意非数字
        • \A 匹配字符串开始
        • \Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
        • \z 匹配字符串结束
        • \G 匹配最后匹配完成的位置。
        • \b 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
        • \B 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
        • \n, \t, 等。 匹配一个换行符。匹配一个制表符, 等
        • \1...\9 匹配第n个分组的内容。
        • \10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
    • 正则表达式实例
      • 字符匹配
        • 实例 描述
        • python 匹配 "python".
      • 字符类
        • 实例 描述
        • [Pp]ython 匹配 "Python" 或 "python"
        • rub[ye] 匹配 "ruby" 或 "rube"
        • [aeiou] 匹配中括号内的任意一个字母
        • [0-9] 匹配任何数字。类似于 [0123456789]
        • [a-z] 匹配任何小写字母
        • [A-Z] 匹配任何大写字母
        • [a-zA-Z0-9] 匹配任何字母及数字
        • [^aeiou] 除了aeiou字母以外的所有字符
        • [^0-9] 匹配除了数字外的字符
      • 特殊字符类
        • 实例 描述
        • . 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
        • \d 匹配一个数字字符。等价于 [0-9]。
        • \D 匹配一个非数字字符。等价于 [^0-9]。
        • \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
        • \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
        • \w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
        • \W 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
  • CGI编程
    • 介绍
      • CGI 目前由NCSA维护，NCSA定义CGI如下：
      • CGI(Common Gateway Interface),通用网关接口,它是一段程序,运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口。
    • 网页浏览
      • 为了更好的了解CGI是如何工作的，我们可以从在网页上点击一个链接或URL的流程：
        • 1、使用你的浏览器访问URL并连接到HTTP web 服务器。
        • 2、Web服务器接收到请求信息后会解析URL，并查找访问的文件在服务器上是否存在，如果存在返回文件的内容，否则返回错误信息。
        • 3、浏览器从服务器上接收信息，并显示接收的文件或者错误信息。
      • CGI程序可以是Python脚本，PERL脚本，SHELL脚本，C或者C++程序等。
    • CGI架构图
    • Web服务器支持与配置
      • 在你进行CGI编程前，确保您的Web服务器支持CGI及已经配置了CGI的处理程序。
      • Apache 支持CGI 配置：
      • 设置好CGI目录：
        • ScriptAlias /cgi-bin/ /var/www/cgi-bin/
      • 所有的HTTP服务器执行CGI程序都保存在一个预先配置的目录。这个目录被称为CGI目录，并按照惯例，它被命名为/var/www/cgi-bin目录。
      • CGI文件的扩展名为.cgi，python也可以使用.py扩展名。
      • 默认情况下，Linux服务器配置运行的cgi-bin目录中为/var/www。
      • 如果你想指定其他运行CGI脚本的目录，可以修改httpd.conf配置文件，如下所示：
        • <Directory "/var/www/cgi-bin"> AllowOverride None Options +ExecCGI Order allow,deny Allow from all </Directory>
      • 在 AddHandler 中添加 .py 后缀，这样我们就可以访问 .py 结尾的 python 脚本文件：
        • AddHandler cgi-script .cgi .pl .py
    • 第一个CGI程序
      • 我们使用Python创建第一个CGI程序，文件名为hello.py，文件位于/var/www/cgi-bin目录中，内容如下：
        • 实例
          • print ("Content-type:text/html") print () # 空行，告诉服务器结束头部 print ('<html>') print ('<head>') print ('<meta charset="utf-8">') print ('<title>Hello Word - 我的第一个 CGI 程序！</title>') print ('</head>') print ('<body>') print ('<h2>Hello Word! 我是来自菜鸟教程的第一CGI程序</h2>') print ('</body>') print ('</html>')
      • 文件保存后修改 hello.py，修改文件权限为 755：
        • chmod 755 hello.py
      • 以上程序在浏览器访问显示结果如下：
      • 这个的hello.py脚本是一个简单的Python脚本，脚本第一行的输出内容"Content-type:text/html"发送到浏览器并告知浏览器显示的内容类型为"text/html"。
      • 用 print 输出一个空行用于告诉服务器结束头部信息。
    • HTTP头部
      • hello.py文件内容中的" Content-type:text/html"即为HTTP头部的一部分，它会发送给浏览器告诉浏览器文件的内容类型。
      • HTTP头部的格式如下：
        • HTTP 字段名: 字段内容
      • 例如：
        • Content-type: text/html
      • 以下表格介绍了CGI程序中HTTP头部经常使用的信息：
        • 头 描述
        • Content-type: 请求的与实体对应的MIME信息。例如: Content-type:text/html
        • Expires: Date 响应过期的日期和时间
        • Location: URL 用来重定向接收方到非请求URL的位置来完成请求或标识新的资源
        • Last-modified: Date 请求资源的最后修改时间
        • Content-length: N 请求的内容长度
        • Set-Cookie: String 设置Http Cookie
    • CGI环境变量
      • 所有的CGI程序都接收以下的环境变量，这些变量在CGI程序中发挥了重要的作用：
        • 变量名 描述
        • CONTENT_TYPE 这个环境变量的值指示所传递来的信息的MIME类型。目前，环境变量CONTENT_TYPE一般都是：application/x-www-form-urlencoded,他表示数据来自于HTML表单。
        • CONTENT_LENGTH 如果服务器与CGI程序信息的传递方式是POST，这个环境变量即使从标准输入STDIN中可以读到的有效数据的字节数。这个环境变量在读取所输入的数据时必须使用。
        • HTTP_COOKIE 客户机内的 COOKIE 内容。
        • HTTP_USER_AGENT 提供包含了版本数或其他专有数据的客户浏览器信息。
        • PATH_INFO 这个环境变量的值表示紧接在CGI程序名之后的其他路径信息。它常常作为CGI程序的参数出现。
        • QUERY_STRING 如果服务器与CGI程序信息的传递方式是GET，这个环境变量的值即使所传递的信息。这个信息经跟在CGI程序名的后面，两者中间用一个问号'?'分隔。
        • REMOTE_ADDR 这个环境变量的值是发送请求的客户机的IP地址，例如上面的192.168.1.67。这个值总是存在的。而且它是Web客户机需要提供给Web服务器的唯一标识，可以在CGI程序中用它来区分不同的Web客户机。
        • REMOTE_HOST 这个环境变量的值包含发送CGI请求的客户机的主机名。如果不支持你想查询，则无需定义此环境变量。
        • REQUEST_METHOD 提供脚本被调用的方法。对于使用 HTTP/1.0 协议的脚本，仅 GET 和 POST 有意义。
        • SCRIPT_FILENAME CGI脚本的完整路径
        • SCRIPT_NAME CGI脚本的的名称
        • SERVER_NAME 这是你的 WEB 服务器的主机名、别名或IP地址。
        • SERVER_SOFTWARE 这个环境变量的值包含了调用CGI程序的HTTP服务器的名称和版本号。例如，上面的值为Apache/2.2.14(Unix)
      • 以下是一个简单的CGI脚本输出CGI的环境变量：
        • import os print ("Content-type: text/html") print () print ("<meta charset=\"utf-8\">") print ("<b>环境变量</b><br>") print ("<ul>") for key in os.environ.keys(): print ("<li><span style='color:green'>%30s </span> : %s </li>" % (key,os.environ[key])) print ("</ul>")
        • 将以上点保存为 test.py ,并修改文件权限为 755，执行结果如下：
        • 浏览器客户端通过两种方法向服务器传递信息，这两种方法就是 GET 方法和 POST 方法。
    • GET和POST方法
      • 使用GET方法传输数据
        • GET方法发送编码后的用户信息到服务端，数据信息包含在请求页面的URL上，以"?"号分割, 如下所示：
          • http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2
        • 有关 GET 请求的其他一些注释：
          • GET 请求可被缓存
          • GET 请求保留在浏览器历史记录中
          • GET 请求可被收藏为书签
          • GET 请求不应在处理敏感数据时使用
          • GET 请求有长度限制
          • GET 请求只应当用于取回数据
      • 简单的url实例：GET方法
        • 以下是一个简单的URL，使用GET方法向hello_get.py程序发送两个参数：
          • /cgi-bin/test.py?name=菜鸟教程&url=http://www.runoob.com
        • 以下为 hello_get.py 文件的代码：
          • 实例
            • # CGI处理模块 import cgi, cgitb # 创建 FieldStorage 的实例化 form = cgi.FieldStorage() # 获取数据 site_name = form.getvalue('name') site_url = form.getvalue('url') print ("Content-type:text/html") print () print ("<html>") print ("<head>") print ("<meta charset=\"utf-8\">") print ("<title>菜鸟教程 CGI 测试实例</title>") print ("</head>") print ("<body>") print ("<h2>%s官网：%s</h2>" % (site_name, site_url)) print ("</body>") print ("</html>")
        • 文件保存后修改 hello_get.py，修改文件权限为 755：
          • chmod 755 hello_get.py
            • 浏览器请求输出结果：
      • 简单的表单实例：GET方法
        • 以下是一个通过HTML的表单使用GET方法向服务器发送两个数据，提交的服务器脚本同样是hello_get.py文件，hello_get.html 代码如下：
          • 实例
            • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/cgi-bin/hello_get.py" method="get"> 站点名称: <input type="text" name="name"> <br /> 站点 URL: <input type="text" name="url" /> <input type="submit" value="提交" /> </form> </body> </html>
        • 默认情况下 cgi-bin 目录只能存放脚本文件，我们将 hello_get.html 存储在 test 目录下，修改文件权限为 755：
        • chmod 755 hello_get.html
        • Gif 演示如下所示：
      • 使用POST方法传递数据
        • 使用POST方法向服务器传递数据是更安全可靠的，像一些敏感信息如用户密码等需要使用POST传输数据。
        • 以下同样是hello_get.py ，它也可以处理浏览器提交的POST表单数据:
          • 实例
            • # CGI处理模块 import cgi, cgitb # 创建 FieldStorage 的实例化 form = cgi.FieldStorage() # 获取数据 site_name = form.getvalue('name') site_url = form.getvalue('url') print ("Content-type:text/html") print () print ("<html>") print ("<head>") print ("<meta charset=\"utf-8\">") print ("<title>菜鸟教程 CGI 测试实例</title>") print ("</head>") print ("<body>") print ("<h2>%s官网：%s</h2>" % (site_name, site_url)) print ("</body>") print ("</html>")
        • 以下为表单通过POST方法（method="post"）向服务器脚本 hello_get.py 提交数据:
          • 实例
            • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/cgi-bin/hello_get.py" method="post"> 站点名称: <input type="text" name="name"> <br /> 站点 URL: <input type="text" name="url" /> <input type="submit" value="提交" /> </form> </body> </html> </form>
    • 通过CGI程序传递checkbox数据
      • checkbox用于提交一个或者多个选项数据，HTML代码如下：
        • 实例
          • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/cgi-bin/checkbox.py" method="POST" target="_blank"> <input type="checkbox" name="runoob" value="on" /> 菜鸟教程 <input type="checkbox" name="google" value="on" /> Google <input type="submit" value="选择站点" /> </form> </body> </html>
      • 以下为 checkbox.py 文件的代码：
        • 实例
          • # 引入 CGI 处理模块 import cgi, cgitb # 创建 FieldStorage的实例 form = cgi.FieldStorage() # 接收字段数据 if form.getvalue('google'): google_flag = "是" else: google_flag = "否" if form.getvalue('runoob'): runoob_flag = "是" else: runoob_flag = "否" print ("Content-type:text/html") print () print ("<html>") print ("<head>") print ("<meta charset=\"utf-8\">") print ("<title>菜鸟教程 CGI 测试实例</title>") print ("</head>") print ("<body>") print ("<h2> 菜鸟教程是否选择了 : %s</h2>" % runoob_flag) print ("<h2> Google 是否选择了 : %s</h2>" % google_flag) print ("</body>") print ("</html>")
      • 修改 checkbox.py 权限：
        • chmod 755 checkbox.py
    • 通过CGI程序传递Radio数据
      • Radio 只向服务器传递一个数据，HTML代码如下：
        • 实例
          • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/cgi-bin/radiobutton.py" method="post" target="_blank"> <input type="radio" name="site" value="runoob" /> 菜鸟教程 <input type="radio" name="site" value="google" /> Google <input type="submit" value="提交" /> </form> </body> </html>
      • radiobutton.py 脚本代码如下：
        • 实例
          • # 引入 CGI 处理模块 import cgi, cgitb # 创建 FieldStorage的实例 form = cgi.FieldStorage() # 接收字段数据 if form.getvalue('site'): site = form.getvalue('site') else: site = "提交数据为空" print ("Content-type:text/html") print () print ("<html>") print ("<head>") print ("<meta charset=\"utf-8\">") print ("<title>菜鸟教程 CGI 测试实例</title>") print ("</head>") print ("<body>") print ("<h2> 选中的网站是 %s</h2>" % site) print ("</body>") print ("</html>")
      • 修改 radiobutton.py 权限：
        • chmod 755 radiobutton.py
    • 通过CGI程序传递Textarea数据
      • Textarea 向服务器传递多行数据，HTML 代码如下：
        • 实例
          • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/cgi-bin/textarea.py" method="post" target="_blank"> <textarea name="textcontent" cols="40" rows="4"> 在这里输入内容... </textarea> <input type="submit" value="提交" /> </form> </body> </html>
      • textarea.py 脚本代码如下：
        • 实例
          • # 引入 CGI 处理模块 import cgi, cgitb # 创建 FieldStorage的实例 form = cgi.FieldStorage() # 接收字段数据 if form.getvalue('textcontent'): text_content = form.getvalue('textcontent') else: text_content = "没有内容" print ("Content-type:text/html") print () print ("<html>") print ("<head>") print ("<meta charset=\"utf-8\">") print ("<title>菜鸟教程 CGI 测试实例</title>") print ("</head>") print ("<body>") print ("<h2> 输入的内容是：%s</h2>" % text_content) print ("</body>") print ("</html>")
      • 修改 textarea.py 权限：
        • chmod 755 textarea.py
    • 通过CGI程序下拉数据
      • HTML 下拉框代码如下：
        • 实例
          • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/cgi-bin/dropdown.py" method="post" target="_blank"> <select name="dropdown"> <option value="runoob" selected>菜鸟教程</option> <option value="google">Google</option> </select> <input type="submit" value="提交"/> </form> </body> </html>
      • dropdown.py 脚本代码如下所示：
        • 实例
          • # 引入 CGI 处理模块 import cgi, cgitb # 创建 FieldStorage的实例 form = cgi.FieldStorage() # 接收字段数据 if form.getvalue('dropdown'): dropdown_value = form.getvalue('dropdown') else: dropdown_value = "没有内容" print ("Content-type:text/html") print () print ("<html>") print ("<head>") print ("<meta charset=\"utf-8\">") print ("<title>菜鸟教程 CGI 测试实例</title>") print ("</head>") print ("<body>") print ("<h2> 选中的选项是：%s</h2>" % dropdown_value) print ("</body>") print ("</html>")
      • 修改 dropdown.py 权限：
        • chmod 755 dropdown.py
    • CGI中使用Cookie
      • 在 http 协议一个很大的缺点就是不对用户身份的进行判断，这样给编程人员带来很大的不便， 而 cookie 功能的出现弥补了这个不足。
      • cookie 就是在客户访问脚本的同时，通过客户的浏览器，在客户硬盘上写入纪录数据 ，当下次客户访问脚本时取回数据信息，从而达到身份判别的功能，cookie 常用在身份校验中。
      • Cookie的语法
        • http cookie的发送是通过http头部来实现的，他早于文件的传递，头部set-cookie的语法如下：
          • Set-cookie:name=name;expires=date;path=path;domain=domain;secure
        • name=name: 需要设置cookie的值(name不能使用";"和","号),有多个name值时用 ";" 分隔，例如：name1=name1;name2=name2;name3=name3。
        • expires=date: cookie的有效期限,格式： expires="Wdy,DD-Mon-YYYY HH:MM:SS"
        • path=path: 设置cookie支持的路径,如果path是一个路径，则cookie对这个目录下的所有文件及子目录生效，例如： path="/cgi-bin/"，如果path是一个文件，则cookie指对这个文件生效，例如：path="/cgi-bin/cookie.cgi"。
        • domain=domain: 对cookie生效的域名，例如：domain="www.runoob.com"
        • secure: 如果给出此标志，表示cookie只能通过SSL协议的https服务器来传递。
        • cookie的接收是通过设置环境变量HTTP_COOKIE来实现的，CGI程序可以通过检索该变量获取cookie信息。
      • Cookie设置
        • Cookie的 设置非常简单，cookie 会在 http 头部单独发送。以下实例在 cookie 中设置了 name 和 expires：
          • 实例
            • print ('Set-Cookie: name="菜鸟教程";expires=Wed, 28 Aug 2016 18:30:00 GMT') print ('Content-Type: text/html') print () print (""" <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <h1>Cookie set OK!</h1> </body> </html> """)
        • 将以上代码保存到 cookie_set.py，并修改 cookie_set.py 权限：
          • chmod 755 cookie_set.py
        • 以上实例使用了 Set-Cookie 头信息来设置 Cookie 信息，可选项中设置了 Cookie 的其他属性，如过期时间 Expires，域名 Domain，路径 Path。这些信息设置在 "Content-type:text/html" 之前。
      • 检索Cookie信息
        • Cookie信息检索页非常简单，Cookie信息存储在CGI的环境变量HTTP_COOKIE中，存储格式如下：
          • key1=value1;key2=value2;key3=value3....
        • 以下是一个简单的CGI检索cookie信息的程序：
          • 实例
            • # 导入模块 import os import http.cookies print ("Content-type: text/html") print () print (""" <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <h1>读取cookie信息</h1> """) if 'HTTP_COOKIE' in os.environ: cookie_string=os.environ.get('HTTP_COOKIE') c= http.cookies.SimpleCookie() # c=Cookie.SimpleCookie() c.load(cookie_string) try: data=c['name'].value print ("cookie data: "+data+"<br>") except KeyError: print ("cookie 没有设置或者已过去<br>") print (""" </body> </html> """)
        • 将以上代码保存到 cookie_get.py，并修改 cookie_get.py 权限：
          • chmod 755 cookie_get.py
            • 以上 cookie 设置演示 Gif 如下所示：
        • 文件上传实例
          • HTML设置上传文件的表单需要设置 enctype 属性为 multipart/form-data，代码如下所示：
            • 实例
              • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form enctype="multipart/form-data" action="/cgi-bin/save_file.py" method="post"> <p>选中文件: <input type="file" name="filename" /></p> <p><input type="submit" value="上传" /></p> </form> </body> </html>
          • save_file.py 脚本文件代码如下：
            • 实例
              • import cgi, os import cgitb; cgitb.enable() form = cgi.FieldStorage() # 获取文件名 fileitem = form['filename'] # 检测文件是否上传 if fileitem.filename: # 设置文件路径 fn = os.path.basename(fileitem.filename) open('/tmp/' + fn, 'wb').write(fileitem.file.read()) message = '文件 "' + fn + '" 上传成功' else: message = '文件没有上传' print ("""\ Content-Type: text/html\n <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <p>%s</p> </body> </html> """ % (message,))
          • 将以上代码保存到 save_file.py，并修改 save_file.py 权限：
            • chmod 755 save_file.py
              • 以上 cookie 设置演示 Gif 如下所示：
          • 如果你使用的系统是Unix/Linux，你必须替换文件分隔符，在window下只需要使用open()语句即可：
            • fn = os.path.basename(fileitem.filename.replace("\\", "/" ))
        • 文件下载对话框
          • 我们先在当前目录下创建 foo.txt 文件，用于程序的下载。
            • 文件下载通过设置HTTP头信息来实现，功能代码如下：
              • 实例
                • # HTTP 头部 print ("Content-Disposition: attachment; filename=\"foo.txt\"") print () # 打开文件 fo = open("foo.txt", "rb") str = fo.read(); print (str) # 关闭文件 fo.close()
  • Python MySQL - mysql-connector 驱动
    • MySQL 是最流行的关系型数据库管理系统，如果你不熟悉 MySQL，可以阅读我们的 MySQL 教程。
    • 本章节我们为大家介绍使用 mysql-connector 来连接使用 MySQL， mysql-connector 是 MySQL 官方提供的驱动器。
    • 我们可以使用 pip 命令来安装 mysql-connector：
      • python -m pip install mysql-connector
    • 使用以下代码测试 mysql-connector 是否安装成功：
      • demo_mysql_test.py:
        • import mysql.connector
    • 执行以上代码，如果没有产生错误，表明安装成功。
      • 注意：如果你的 MySQL 是 8.0 版本，密码插件验证方式发生了变化，早期版本为 mysql_native_password，8.0 版本为 caching_sha2_password，所以需要做些改变：
      • 先修改 my.ini 配置：
        • [mysqld]
        • default_authentication_plugin=mysql_native_password
      • 然后在 mysql 下执行以下命令来修改密码：
        • ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '新密码';
      • 更多内容可以参考：Python MySQL8.0 链接问题。
    • 创建数据库连接
      • 可以使用以下代码来连接数据库：
        • demo_mysql_test.py:
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", # 数据库主机地址 user="yourusername", # 数据库用户名 passwd="yourpassword" # 数据库密码 ) print(mydb)
      • 创建数据库
        • 创建数据库使用 "CREATE DATABASE" 语句，以下创建一个名为 runoob_db 的数据库：
          • demo_mysql_test.py:
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456" ) mycursor = mydb.cursor() mycursor.execute("CREATE DATABASE runoob_db")
        • 创建数据库前我们也可以使用 "SHOW DATABASES" 语句来查看数据库是否存在：
          • demo_mysql_test.py:
            • 输出所有数据库列表：
              • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456" ) mycursor = mydb.cursor() mycursor.execute("SHOW DATABASES") for x in mycursor: print(x)
        • 或者我们可以直接连接数据库，如果数据库不存在，会输出错误信息：
          • demo_mysql_test.py:
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" )
    • 创建数据表
      • 创建数据表使用 "CREATE TABLE" 语句，创建数据表前，需要确保数据库已存在，以下创建一个名为 sites 的数据表：
        • demo_mysql_test.py:
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("CREATE TABLE sites (name VARCHAR(255), url VARCHAR(255))")
      • 执行成功后，我们可以看到数据库创建的数据表 sites，字段为 name 和 url。
      • 我们也可以使用 "SHOW TABLES" 语句来查看数据表是否已存在：
        • demo_mysql_test.py:
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("SHOW TABLES") for x in mycursor: print(x)
      • 主键设置
        • 创建表的时候我们一般都会设置一个主键（PRIMARY KEY），我们可以使用 "INT AUTO_INCREMENT PRIMARY KEY" 语句来创建一个主键，主键起始值为 1，逐步递增。
        • 如果我们的表已经创建，我们需要使用 ALTER TABLE 来给表添加主键：
          • demo_mysql_test.py:
            • 给 sites 表添加主键。
              • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("ALTER TABLE sites ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY")
          • 如果你还未创建 sites 表，可以直接使用以下代码创建。
            • demo_mysql_test.py:
              • 给表创建主键。
                • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("CREATE TABLE sites (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), url VARCHAR(255))")
    • 插入数据
      • 插入数据使用 "INSERT INTO" 语句：
        • demo_mysql_test.py:
          • 向 sites 表插入一条记录。
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "INSERT INTO sites (name, url) VALUES (%s, %s)" val = ("RUNOOB", "https://www.runoob.com") mycursor.execute(sql, val) mydb.commit() # 数据表内容有更新，必须使用到该语句 print(mycursor.rowcount, "记录插入成功。")
              • 1 记录插入成功
      • 批量插入
        • 批量插入使用 executemany() 方法，该方法的第二个参数是一个元组列表，包含了我们要插入的数据：
          • demo_mysql_test.py:
            • 向 sites 表插入多条记录。
              • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "INSERT INTO sites (name, url) VALUES (%s, %s)" val = [ ('Google', 'https://www.google.com'), ('Github', 'https://www.github.com'), ('Taobao', 'https://www.taobao.com'), ('stackoverflow', 'https://www.stackoverflow.com/') ] mycursor.executemany(sql, val) mydb.commit() # 数据表内容有更新，必须使用到该语句 print(mycursor.rowcount, "记录插入成功。")
                • 4 记录插入成功。
        • 执行以上代码后，我们可以看看数据表的记录：
        • 如果我们想在数据记录插入后，获取该记录的 ID ，可以使用以下代码：
          • demo_mysql_test.py:
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "INSERT INTO sites (name, url) VALUES (%s, %s)" val = ("Zhihu", "https://www.zhihu.com") mycursor.execute(sql, val) mydb.commit() print("1 条记录已插入, ID:", mycursor.lastrowid)
              • 1 条记录已插入, ID: 6
    • 查询数据
      • 查询数据使用 SELECT 语句：
        • demo_mysql_test.py:
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM sites") myresult = mycursor.fetchall() # fetchall() 获取所有记录 for x in myresult: print(x)
            • (1, 'RUNOOB', 'https://www.runoob.com') (2, 'Google', 'https://www.google.com') (3, 'Github', 'https://www.github.com') (4, 'Taobao', 'https://www.taobao.com') (5, 'stackoverflow', 'https://www.stackoverflow.com/') (6, 'Zhihu', 'https://www.zhihu.com')
      • 也可以读取指定的字段数据：
        • demo_mysql_test.py:
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("SELECT name, url FROM sites") myresult = mycursor.fetchall() for x in myresult: print(x)
            • ('RUNOOB', 'https://www.runoob.com') ('Google', 'https://www.google.com') ('Github', 'https://www.github.com') ('Taobao', 'https://www.taobao.com') ('stackoverflow', 'https://www.stackoverflow.com/') ('Zhihu', 'https://www.zhihu.com')
      • 如果我们只想读取一条数据，可以使用 fetchone() 方法：
        • demo_mysql_test.py:
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM sites") myresult = mycursor.fetchone() print(myresult)
            • (1, 'RUNOOB', 'https://www.runoob.com')
      • where 条件语句
        • 如果我们要读取指定条件的数据，可以使用 where 语句：
          • demo_mysql_test.py
          • 读取 name 字段为 RUNOOB 的记录：
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "SELECT * FROM sites WHERE name ='RUNOOB'" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x)
              • (1, 'RUNOOB', 'https://www.runoob.com')
      • 也可以使用通配符 %：
        • demo_mysql_test.py
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "SELECT * FROM sites WHERE url LIKE '%oo%'" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x)
            • (1, 'RUNOOB', 'https://www.runoob.com') (2, 'Google', 'https://www.google.com')
      • 为了防止数据库查询发生 SQL 注入的攻击，我们可以使用 %s 占位符来转义查询的条件：
        • demo_mysql_test.py
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "SELECT * FROM sites WHERE name = %s" na = ("RUNOOB", ) mycursor.execute(sql, na) myresult = mycursor.fetchall() for x in myresult: print(x)
      • 排序
        • 查询结果排序可以使用 ORDER BY 语句，默认的排序方式为升序，关键字为 ASC，如果要设置降序排序，可以设置关键字 DESC。
          • demo_mysql_test.py
          • 按 name 字段字母的升序排序：
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "SELECT * FROM sites ORDER BY name" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x)
              • (3, 'Github', 'https://www.github.com') (2, 'Google', 'https://www.google.com') (1, 'RUNOOB', 'https://www.runoob.com') (5, 'stackoverflow', 'https://www.stackoverflow.com/') (4, 'Taobao', 'https://www.taobao.com') (6, 'Zhihu', 'https://www.zhihu.com')
        • 降序排序实例：
          • demo_mysql_test.py
            • 按 name 字段字母的降序排序：
              • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "SELECT * FROM sites ORDER BY name DESC" mycursor.execute(sql) myresult = mycursor.fetchall() for x in myresult: print(x)
                • (6, 'Zhihu', 'https://www.zhihu.com') (4, 'Taobao', 'https://www.taobao.com') (5, 'stackoverflow', 'https://www.stackoverflow.com/') (1, 'RUNOOB', 'https://www.runoob.com') (2, 'Google', 'https://www.google.com') (3, 'Github', 'https://www.github.com')
      • Limit
        • 如果我们要设置查询的数据量，可以通过 "LIMIT" 语句来指定
          • demo_mysql_test.py
          • 读取前 3 条记录：
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM sites LIMIT 3") myresult = mycursor.fetchall() for x in myresult: print(x)
              • (1, 'RUNOOB', 'https://www.runoob.com') (2, 'Google', 'https://www.google.com') (3, 'Github', 'https://www.github.com')
        • 也可以指定起始位置，使用的关键字是 OFFSET：
          • demo_mysql_test.py
          • 从第二条开始读取前 3 条记录：
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() mycursor.execute("SELECT * FROM sites LIMIT 3 OFFSET 1") # 0 为 第一条，1 为第二条，以此类推 myresult = mycursor.fetchall() for x in myresult: print(x)
              • (2, 'Google', 'https://www.google.com') (3, 'Github', 'https://www.github.com') (4, 'Taobao', 'https://www.taobao.com')
    • 删除记录
      • 删除记录使用 "DELETE FROM" 语句：
        • demo_mysql_test.py
        • 删除 name 为 stackoverflow 的记录：
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "DELETE FROM sites WHERE name = 'stackoverflow'" mycursor.execute(sql) mydb.commit() print(mycursor.rowcount, " 条记录删除")
            • 1 条记录删除
        • 注意：要慎重使用删除语句，删除语句要确保指定了 WHERE 条件语句，否则会导致整表数据被删除。
        • 为了防止数据库查询发生 SQL 注入的攻击，我们可以使用 %s 占位符来转义删除语句的条件：
          • demo_mysql_test.py
            • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "DELETE FROM sites WHERE name = %s" na = ("stackoverflow", ) mycursor.execute(sql, na) mydb.commit() print(mycursor.rowcount, " 条记录删除")
              • 1 条记录删除
    • 更新表数据
      • 数据表更新使用 "UPDATE" 语句：
        • demo_mysql_test.py
        • 将 name 为 Zhihu 的字段数据改为 ZH：
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "UPDATE sites SET name = 'ZH' WHERE name = 'Zhihu'" mycursor.execute(sql) mydb.commit() print(mycursor.rowcount, " 条记录被修改")
            • 1 条记录被修改
        • 注意：UPDATE 语句要确保指定了 WHERE 条件语句，否则会导致整表数据被更新。
      • 为了防止数据库查询发生 SQL 注入的攻击，我们可以使用 %s 占位符来转义更新语句的条件：
        • demo_mysql_test.py
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "UPDATE sites SET name = %s WHERE name = %s" val = ("Zhihu", "ZH") mycursor.execute(sql, val) mydb.commit() print(mycursor.rowcount, " 条记录被修改")
            • 1 条记录被修改
    • 删除表
      • 删除表使用 "DROP TABLE" 语句， IF EXISTS 关键字是用于判断表是否存在，只有在存在的情况才删除：
        • demo_mysql_test.py
          • import mysql.connector mydb = mysql.connector.connect( host="localhost", user="root", passwd="123456", database="runoob_db" ) mycursor = mydb.cursor() sql = "DROP TABLE IF EXISTS sites" # 删除数据表 sites mycursor.execute(sql)
  • Python3 MySQL 数据库连接 - PyMySQL 驱动
    • 本文我们为大家介绍 Python3 使用 PyMySQL 连接数据库，并实现简单的增删改查。
    • 什么是 PyMySQL？
      • PyMySQL 是在 Python3.x 版本中用于连接 MySQL 服务器的一个库，Python2中则使用mysqldb。
      • PyMySQL 遵循 Python 数据库 API v2.0 规范，并包含了 pure-Python MySQL 客户端库。
    • PyMySQL 安装
      • 在使用 PyMySQL 之前，我们需要确保 PyMySQL 已安装。
      • PyMySQL 下载地址：https://github.com/PyMySQL/PyMySQL。
      • 如果还未安装，我们可以使用以下命令安装最新版的 PyMySQL：
        • $ pip3 install PyMySQL
    • 如果你的系统不支持 pip 命令，可以使用以下方式安装：
      • 1、使用 git 命令下载安装包安装(你也可以手动下载)：
        • $ git clone https://github.com/PyMySQL/PyMySQL $ cd PyMySQL/ $ python3 setup.py install
      • 2、如果需要制定版本号，可以使用 curl 命令来安装：
        • $ # X.X 为 PyMySQL 的版本号 $ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz $ cd PyMySQL* $ python3 setup.py install $ # 现在你可以删除 PyMySQL* 目录
      • 注意：请确保您有root权限来安装上述模块。
        • 安装的过程中可能会出现"ImportError: No module named setuptools"的错误提示，意思是你没有安装setuptools，你可以访问https://pypi.python.org/pypi/setuptools 找到各个系统的安装方法。
        • Linux 系统安装实例：
          • $ wget https://bootstrap.pypa.io/ez_setup.py $ python3 ez_setup.py
    • 数据库连接
      • 连接数据库前，请先确认以下事项：
        • 您已经创建了数据库 TESTDB.
        • 在TESTDB数据库中您已经创建了表 EMPLOYEE
        • EMPLOYEE表字段为 FIRST_NAME, LAST_NAME, AGE, SEX 和 INCOME。
        • 连接数据库TESTDB使用的用户名为 "testuser" ，密码为 "test123",你可以可以自己设定或者直接使用root用户名及其密码，Mysql数据库用户授权请使用Grant命令。
        • 在你的机子上已经安装了 Python MySQLdb 模块。
        • 如果您对sql语句不熟悉，可以访问我们的 SQL基础教程
      • 实例：
        • 以下实例链接 Mysql 的 TESTDB 数据库：
          • 实例(Python 3.0+)
            • import pymysql # 打开数据库连接 db = pymysql.connect(host='localhost', user='testuser', password='test123', database='TESTDB') # 使用 cursor() 方法创建一个游标对象 cursor cursor = db.cursor() # 使用 execute() 方法执行 SQL 查询 cursor.execute("SELECT VERSION()") # 使用 fetchone() 方法获取单条数据. data = cursor.fetchone() print ("Database version : %s " % data) # 关闭数据库连接 db.close()
              • 执行以上脚本输出结果如下：
              • Database version : 5.5.20-log
    • 创建数据库表
      • 如果数据库连接存在我们可以使用execute()方法来为数据库创建表，如下所示创建表EMPLOYEE：
        • 实例(Python 3.0+)
          • import pymysql # 打开数据库连接 db = pymysql.connect(host='localhost', user='testuser', password='test123', database='TESTDB') # 使用 cursor() 方法创建一个游标对象 cursor cursor = db.cursor() # 使用 execute() 方法执行 SQL，如果表存在则删除 cursor.execute("DROP TABLE IF EXISTS EMPLOYEE") # 使用预处理语句创建表 sql = """CREATE TABLE EMPLOYEE ( FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, SEX CHAR(1), INCOME FLOAT )""" cursor.execute(sql) # 关闭数据库连接 db.close()
    • 数据库插入操作
      • 以下实例使用执行 SQL INSERT 语句向表 EMPLOYEE 插入记录：
        • 实例(Python 3.0+)
          • import pymysql # 打开数据库连接 db = pymysql.connect(host='localhost', user='testuser', password='test123', database='TESTDB') # 使用cursor()方法获取操作游标 cursor = db.cursor() # SQL 插入语句 sql = """INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES ('Mac', 'Mohan', 20, 'M', 2000)""" try: # 执行sql语句 cursor.execute(sql) # 提交到数据库执行 db.commit() except: # 如果发生错误则回滚 db.rollback() # 关闭数据库连接 db.close()
          • 以上例子也可以写成如下形式：
            • 实例(Python 3.0+)
              • import pymysql # 打开数据库连接 db = pymysql.connect(host='localhost', user='testuser', password='test123', database='TESTDB') # 使用cursor()方法获取操作游标 cursor = db.cursor() # SQL 插入语句 sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \ LAST_NAME, AGE, SEX, INCOME) \ VALUES ('%s', '%s', %s, '%s', %s)" % \ ('Mac', 'Mohan', 20, 'M', 2000) try: # 执行sql语句 cursor.execute(sql) # 执行sql语句 db.commit() except: # 发生错误时回滚 db.rollback() # 关闭数据库连接 db.close()
                • 以下代码使用变量向SQL语句中传递参数:
                • .................................. user_id = "test123" password = "password" con.execute('insert into Login values( %s, %s)' % \ (user_id, password)) ..................................
    • 数据库查询操作
      • Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。
        • fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
        • fetchall(): 接收全部的返回结果行.
        • rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。
      • 实例：
        • 查询EMPLOYEE表中salary（工资）字段大于1000的所有数据：
          • 实例(Python 3.0+)
            • import pymysql # 打开数据库连接 db = pymysql.connect(host='localhost', user='testuser', password='test123', database='TESTDB') # 使用cursor()方法获取操作游标 cursor = db.cursor() # SQL 查询语句 sql = "SELECT * FROM EMPLOYEE \ WHERE INCOME > %s" % (1000) try: # 执行SQL语句 cursor.execute(sql) # 获取所有记录列表 results = cursor.fetchall() for row in results: fname = row[0] lname = row[1] age = row[2] sex = row[3] income = row[4] # 打印结果 print ("fname=%s,lname=%s,age=%s,sex=%s,income=%s" % \ (fname, lname, age, sex, income )) except: print ("Error: unable to fetch data") # 关闭数据库连接 db.close()
              • 以上脚本执行结果如下：
              • fname=Mac, lname=Mohan, age=20, sex=M, income=2000
    • 数据库更新操作
      • 更新操作用于更新数据表的数据，以下实例将 TESTDB 表中 SEX 为 'M' 的 AGE 字段递增 1：
        • 实例(Python 3.0+)
          • import pymysql # 打开数据库连接 db = pymysql.connect(host='localhost', user='testuser', password='test123', database='TESTDB') # 使用cursor()方法获取操作游标 cursor = db.cursor() # SQL 更新语句 sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M') try: # 执行SQL语句 cursor.execute(sql) # 提交到数据库执行 db.commit() except: # 发生错误时回滚 db.rollback() # 关闭数据库连接 db.close()
    • 删除操作
      • 删除操作用于删除数据表中的数据，以下实例演示了删除数据表 EMPLOYEE 中 AGE 大于 20 的所有数据：
        • 实例(Python 3.0+)
          • import pymysql # 打开数据库连接 db = pymysql.connect(host='localhost', user='testuser', password='test123', database='TESTDB') # 使用cursor()方法获取操作游标 cursor = db.cursor() # SQL 删除语句 sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20) try: # 执行SQL语句 cursor.execute(sql) # 提交修改 db.commit() except: # 发生错误时回滚 db.rollback() # 关闭连接 db.close()
    • 执行事务
      • 事务机制可以确保数据一致性。
      • 事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
        • 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
        • 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
        • 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
        • 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
      • Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。
        • 实例
          • 实例(Python 3.0+)
            • # SQL删除记录语句 sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20) try: # 执行SQL语句 cursor.execute(sql) # 向数据库提交 db.commit() except: # 发生错误时回滚 db.rollback()
        • 对于支持事务的数据库， 在Python数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。
        • commit()方法游标的所有更新操作，rollback（）方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。
    • 错误处理
      • DB API中定义了一些数据库操作的错误及异常，下表列出了这些错误和异常:
        • 异常 描述
        • Warning 当有严重警告时触发，例如插入数据是被截断等等。必须是 StandardError 的子类。
        • Error 警告以外所有其他错误类。必须是 StandardError 的子类。
        • InterfaceError 当有数据库接口模块本身的错误（而不是数据库的错误）发生时触发。 必须是Error的子类。
        • DatabaseError 和数据库有关的错误发生时触发。 必须是Error的子类。
        • DataError 当有数据处理时的错误发生时触发，例如：除零错误，数据超范围等等。 必须是DatabaseError的子类。
        • OperationalError 指非用户控制的，而是操作数据库时发生的错误。例如：连接意外断开、 数据库名未找到、事务处理失败、内存分配错误等等操作数据库是发生的错误。 必须是DatabaseError的子类。
        • IntegrityError 完整性相关的错误，例如外键检查失败等。必须是DatabaseError子类。
        • InternalError 数据库的内部错误，例如游标（cursor）失效了、事务同步失败等等。 必须是DatabaseError子类。
        • ProgrammingError 程序错误，例如数据表（table）没找到或已存在、SQL语句语法错误、 参数数量错误等等。必须是DatabaseError的子类。
        • NotSupportedError 不支持错误，指使用了数据库不支持的函数或API等。例如在连接对象上 使用.rollback()函数，然而数据库并不支持事务或者事务已关闭。 必须是DatabaseError的子类。
  • Python3 网络编程
    • Python 提供了两个级别访问的网络服务。：
      • 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。
      • 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。
    • 什么是 Socket?
      • Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。
    • socket()函数
      • Python 中，我们用 socket() 函数来创建套接字，语法格式如下：
        • socket.socket([family[, type[, proto]]])
    • 参数
      • family: 套接字家族可以是 AF_UNIX 或者 AF_INET
      • type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM
      • protocol: 一般不填默认为0.
    • Socket 对象(内建)方法
      • 函数 描述
      • 服务器端套接字
      • s.bind() 绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。
      • s.listen() 开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
      • s.accept() 被动接受TCP客户端连接,(阻塞式)等待连接的到来
      • 客户端套接字
      • s.connect() 主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
      • s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
      • 公共用途的套接字函数
      • s.recv() 接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
      • s.send() 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
      • s.sendall() 完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
      • s.recvfrom() 接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
      • s.sendto() 发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
      • s.close() 关闭套接字
      • s.getpeername() 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
      • s.getsockname() 返回套接字自己的地址。通常是一个元组(ipaddr,port)
      • s.setsockopt(level,optname,value) 设置给定套接字选项的值。
      • s.getsockopt(level,optname[.buflen]) 返回套接字选项的值。
      • s.settimeout(timeout) 设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
      • s.gettimeout() 返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
      • s.fileno() 返回套接字的文件描述符。
      • s.setblocking(flag) 如果 flag 为 False，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用 recv() 没有发现任何数据，或 send() 调用无法立即发送数据，那么将引起 socket.error 异常。
      • s.makefile() 创建一个与该套接字相关连的文件
    • 简单实例
      • 服务端
        • 我们使用 socket 模块的 socket 函数来创建一个 socket 对象。socket 对象可以通过调用其他函数来设置一个 socket 服务。
        • 现在我们可以通过调用 bind(hostname, port) 函数来指定服务的 port(端口)。
        • 接着，我们调用 socket 对象的 accept 方法。该方法等待客户端的连接，并返回 connection 对象，表示已连接到客户端。
        • 完整代码如下：
          • # 文件名：server.py # 导入 socket、sys 模块 import socket import sys # 创建 socket 对象 serversocket = socket.socket( socket.AF_INET, socket.SOCK_STREAM) # 获取本地主机名 host = socket.gethostname() port = 9999 # 绑定端口号 serversocket.bind((host, port)) # 设置最大连接数，超过后排队 serversocket.listen(5) while True: # 建立客户端连接 clientsocket,addr = serversocket.accept() print("连接地址: %s" % str(addr)) msg='欢迎访问菜鸟教程！'+ "\r\n" clientsocket.send(msg.encode('utf-8')) clientsocket.close()
      • 客户端
        • 接下来我们写一个简单的客户端实例连接到以上创建的服务。端口号为 9999。
        • socket.connect(hosname, port ) 方法打开一个 TCP 连接到主机为 hostname 端口为 port 的服务商。连接后我们就可以从服务端获取数据，记住，操作完成后需要关闭连接。
        • 完整代码如下：
          • # 文件名：client.py # 导入 socket、sys 模块 import socket import sys # 创建 socket 对象 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 获取本地主机名 host = socket.gethostname() # 设置端口号 port = 9999 # 连接服务，指定主机和端口 s.connect((host, port)) # 接收小于 1024 字节的数据 msg = s.recv(1024) s.close() print (msg.decode('utf-8'))
      • 现在我们打开两个终端，第一个终端执行 server.py 文件：
        • $ python3 server.py
      • 第二个终端执行 client.py 文件：
        • $ python3 client.py
        • 欢迎访问菜鸟教程！
      • 这时我们再打开第一个终端，就会看到有以下信息输出：
        • 连接地址： ('192.168.0.118', 33397)
    • Python Internet 模块
      • 以下列出了 Python 网络编程的一些重要模块：
        • 协议 功能用处 端口号 Python 模块
        • HTTP 网页访问 80 httplib, urllib, xmlrpclib
        • NNTP 阅读和张贴新闻文章，俗称为"帖子" 119 nntplib
        • FTP 文件传输 20 ftplib, urllib
        • SMTP 发送邮件 25 smtplib
        • POP3 接收邮件 110 poplib
        • IMAP4 获取邮件 143 imaplib
        • Telnet 命令行 23 telnetlib
        • Gopher 信息查找 70 gopherlib, urllib
  • Python3 SMTP发送邮件
    • SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议,它是一组用于由源地址到目的地址传送邮件的规则，由它来控制信件的中转方式。
    • python的smtplib提供了一种很方便的途径发送电子邮件。它对smtp协议进行了简单的封装。
    • Python创建 SMTP 对象语法如下：
      • import smtplib smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )
    • 参数说明：
      • host: SMTP 服务器主机。 你可以指定主机的ip地址或者域名如:runoob.com，这个是可选参数。
      • port: 如果你提供了 host 参数, 你需要指定 SMTP 服务使用的端口号，一般情况下SMTP端口号为25。
      • local_hostname: 如果SMTP在你的本机上，你只需要指定服务器地址为 localhost 即可。
    • Python SMTP对象使用sendmail方法发送邮件，语法如下：
      • SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options]
    • 参数说明：
      • from_addr: 邮件发送者地址。
      • to_addrs: 字符串列表，邮件发送地址。
      • msg: 发送消息
    • 这里要注意一下第三个参数，msg是字符串，表示邮件。我们知道邮件一般由标题，发信人，收件人，邮件内容，附件等构成，发送邮件的时候，要注意msg的格式。这个格式就是smtp协议中定义的格式。
    • 实例
      • 以下是一个使用Python发送邮件简单的实例：
        • 实例
          • import smtplib from email.mime.text import MIMEText from email.header import Header sender = '[e-mail]' receivers = ['[e-mail]'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱 # 三个参数：第一个为文本内容，第二个 plain 设置文本格式，第三个 utf-8 设置编码 message = MIMEText('Python 邮件发送测试...', 'plain', 'utf-8') message['From'] = Header("菜鸟教程", 'utf-8') # 发送者 message['To'] = Header("测试", 'utf-8') # 接收者 subject = 'Python SMTP 邮件测试' message['Subject'] = Header(subject, 'utf-8') try: smtpObj = smtplib.SMTP('localhost') smtpObj.sendmail(sender, receivers, message.as_string()) print ("邮件发送成功") except smtplib.SMTPException: print ("Error: 无法发送邮件")
            • 我们使用三个引号来设置邮件信息，标准邮件需要三个头部信息： From, To, 和 Subject ，每个信息直接使用空行分割。
            • 我们通过实例化 smtplib 模块的 SMTP 对象 smtpObj 来连接到 SMTP 访问，并使用 sendmail 方法来发送信息。
            • 执行以上程序，如果你本机安装sendmail，就会输出：
              • $ python3 test.py 邮件发送成功
        • 查看我们的收件箱(一般在垃圾箱)，就可以查看到邮件信息：
      • 如果我们本机没有 sendmail 访问，也可以使用其他服务商的 SMTP 访问（QQ、网易、Google等）。
        • 实例
          • import smtplib from email.mime.text import MIMEText from email.header import Header # 第三方 SMTP 服务 mail_host="smtp.XXX.com" #设置服务器 mail_user="XXXX" #用户名 mail_pass="XXXXXX" #口令 sender = '[e-mail]' receivers = ['[e-mail]'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱 message = MIMEText('Python 邮件发送测试...', 'plain', 'utf-8') message['From'] = Header("菜鸟教程", 'utf-8') message['To'] = Header("测试", 'utf-8') subject = 'Python SMTP 邮件测试' message['Subject'] = Header(subject, 'utf-8') try: smtpObj = smtplib.SMTP() smtpObj.connect(mail_host, 25) # 25 为 SMTP 端口号 smtpObj.login(mail_user,mail_pass) smtpObj.sendmail(sender, receivers, message.as_string()) print ("邮件发送成功") except smtplib.SMTPException: print ("Error: 无法发送邮件")
    • 使用Python发送HTML格式的邮件
      • Python发送HTML格式的邮件与发送纯文本消息的邮件不同之处就是将MIMEText中_subtype设置为html。具体代码如下：
        • 实例
          • import smtplib from email.mime.text import MIMEText from email.header import Header sender = '[e-mail]' receivers = ['[e-mail]'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱 mail_msg = """ <p>Python 邮件发送测试...</p> <p><a href="http://www.runoob.com">这是一个链接</a></p> """ message = MIMEText(mail_msg, 'html', 'utf-8') message['From'] = Header("菜鸟教程", 'utf-8') message['To'] = Header("测试", 'utf-8') subject = 'Python SMTP 邮件测试' message['Subject'] = Header(subject, 'utf-8') try: smtpObj = smtplib.SMTP('localhost') smtpObj.sendmail(sender, receivers, message.as_string()) print ("邮件发送成功") except smtplib.SMTPException: print ("Error: 无法发送邮件")
            • 执行以上程序，如果你本机安装sendmail，就会输出：
            • $ python3 test.py 邮件发送成功
        • 查看我们的收件箱(一般在垃圾箱)，就可以查看到邮件信息：
    • Python 发送带附件的邮件
      • 发送带附件的邮件，首先要创建MIMEMultipart()实例，然后构造附件，如果有多个附件，可依次构造，最后利用smtplib.smtp发送。
        • 实例
          • import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.header import Header sender = '[e-mail]' receivers = ['[e-mail]'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱 #创建一个带附件的实例 message = MIMEMultipart() message['From'] = Header("菜鸟教程", 'utf-8') message['To'] = Header("测试", 'utf-8') subject = 'Python SMTP 邮件测试' message['Subject'] = Header(subject, 'utf-8') #邮件正文内容 message.attach(MIMEText('这是菜鸟教程Python 邮件发送测试……', 'plain', 'utf-8')) # 构造附件1，传送当前目录下的 test.txt 文件 att1 = MIMEText(open('test.txt', 'rb').read(), 'base64', 'utf-8') att1["Content-Type"] = 'application/octet-stream' # 这里的filename可以任意写，写什么名字，邮件中显示什么名字 att1["Content-Disposition"] = 'attachment; filename="test.txt"' message.attach(att1) # 构造附件2，传送当前目录下的 runoob.txt 文件 att2 = MIMEText(open('runoob.txt', 'rb').read(), 'base64', 'utf-8') att2["Content-Type"] = 'application/octet-stream' att2["Content-Disposition"] = 'attachment; filename="runoob.txt"' message.attach(att2) try: smtpObj = smtplib.SMTP('localhost') smtpObj.sendmail(sender, receivers, message.as_string()) print ("邮件发送成功") except smtplib.SMTPException: print ("Error: 无法发送邮件")
            • $ python3 test.py 邮件发送成功
            • 查看我们的收件箱(一般在垃圾箱)，就可以查看到邮件信息：
    • 在 HTML 文本中添加图片
      • 邮件的 HTML 文本中一般邮件服务商添加外链是无效的，正确添加图片的实例如下所示：
        • 实例
          • import smtplib from email.mime.image import MIMEImage from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText from email.header import Header sender = '[e-mail]' receivers = ['[e-mail]'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱 msgRoot = MIMEMultipart('related') msgRoot['From'] = Header("菜鸟教程", 'utf-8') msgRoot['To'] = Header("测试", 'utf-8') subject = 'Python SMTP 邮件测试' msgRoot['Subject'] = Header(subject, 'utf-8') msgAlternative = MIMEMultipart('alternative') msgRoot.attach(msgAlternative) mail_msg = """ <p>Python 邮件发送测试...</p> <p><a href="http://www.runoob.com">菜鸟教程链接</a></p> <p>图片演示：</p> <p><img src="cid:image1"></p> """ msgAlternative.attach(MIMEText(mail_msg, 'html', 'utf-8')) # 指定图片为当前目录 fp = open('test.png', 'rb') msgImage = MIMEImage(fp.read()) fp.close() # 定义图片 ID，在 HTML 文本中引用 msgImage.add_header('Content-ID', '<image1>') msgRoot.attach(msgImage) try: smtpObj = smtplib.SMTP('localhost') smtpObj.sendmail(sender, receivers, msgRoot.as_string()) print ("邮件发送成功") except smtplib.SMTPException: print ("Error: 无法发送邮件")
            • $ python3 test.py 邮件发送成功
            • 查看我们的收件箱(如果在垃圾箱可能需要移动到收件箱才可正常显示)，就可以查看到邮件信息：
            • QQ 邮箱通过生成授权码来设置密码：
      • QQ 邮箱 SMTP 服务器地址：smtp.qq.com，ssl 端口：465。
      • 以下实例你需要修改：发件人邮箱（你的QQ邮箱），密码，收件人邮箱（可发给自己）。
        • QQ SMTP
          • import smtplib from email.mime.text import MIMEText from email.utils import formataddr my_sender='[e-mail]' # 发件人邮箱账号 my_pass = 'xxxxxxxxxx' # 发件人邮箱密码 my_user='[e-mail]' # 收件人邮箱账号，我这边发送给自己 def mail(): ret=True try: msg=MIMEText('填写邮件内容','plain','utf-8') msg['From']=formataddr(["FromRunoob",my_sender]) # 括号里的对应发件人邮箱昵称、发件人邮箱账号 msg['To']=formataddr(["FK",my_user]) # 括号里的对应收件人邮箱昵称、收件人邮箱账号 msg['Subject']="菜鸟教程发送邮件测试" # 邮件的主题，也可以说是标题 server=smtplib.SMTP_SSL("smtp.qq.com", 465) # 发件人邮箱中的SMTP服务器，端口是25 server.login(my_sender, my_pass) # 括号中对应的是发件人邮箱账号、邮箱密码 server.sendmail(my_sender,[my_user,],msg.as_string()) # 括号中对应的是发件人邮箱账号、收件人邮箱账号、发送邮件 server.quit() # 关闭连接 except Exception: # 如果 try 中的语句没有执行，则会执行下面的 ret=False ret=False return ret ret=mail() if ret: print("邮件发送成功") else: print("邮件发送失败")
            • $ python test.py 邮件发送成功
            • 发送成功后，登陆收件人邮箱即可查看：
  • Python3 多线程
    • 多线程类似于同时执行多个不同程序，多线程运行有如下优点：
      • 使用线程可以把占据长时间的程序中的任务放到后台去处理。
      • 用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。
      • 程序的运行速度可能加快。
      • 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
    • 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
    • 每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。
    • 指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。
      • 线程可以被抢占（中断）。
      • 在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。
    • 线程可以分为:
      • 内核线程：由操作系统内核创建和撤销。
      • 用户线程：不需要内核支持而在用户程序中实现的线程。
    • Python3 线程中常用的两个模块为：
      • _thread
      • threading(推荐使用)
    • thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用"thread" 模块。为了兼容性，Python3 将 thread 重命名为 "_thread"。
    • 开始学习Python线程
      • Python中使用线程有两种方式：函数或者用类来包装线程对象。
      • 函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:
        • _thread.start_new_thread ( function, args[, kwargs] )
      • 参数说明:
        • function - 线程函数。
        • args - 传递给线程函数的参数,他必须是个tuple类型。
        • kwargs - 可选参数。
      • 实例
        • import _thread import time # 为线程定义一个函数 def print_time( threadName, delay): count = 0 while count < 5: time.sleep(delay) count += 1 print ("%s: %s" % ( threadName, time.ctime(time.time()) )) # 创建两个线程 try: _thread.start_new_thread( print_time, ("Thread-1", 2, ) ) _thread.start_new_thread( print_time, ("Thread-2", 4, ) ) except: print ("Error: 无法启动线程") while 1: pass
          • 执行以上程序输出结果如下：
          • Thread-1: Wed Jan 5 17:38:08 2022 Thread-2: Wed Jan 5 17:38:10 2022 Thread-1: Wed Jan 5 17:38:10 2022 Thread-1: Wed Jan 5 17:38:12 2022 Thread-2: Wed Jan 5 17:38:14 2022 Thread-1: Wed Jan 5 17:38:14 2022 Thread-1: Wed Jan 5 17:38:16 2022 Thread-2: Wed Jan 5 17:38:18 2022 Thread-2: Wed Jan 5 17:38:22 2022 Thread-2: Wed Jan 5 17:38:26 2022
          • 执行以上程后可以按下 ctrl-c 退出。
    • 线程模块
      • Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。
      • _thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。
      • threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：
        • threading.currentThread(): 返回当前的线程变量。
        • threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
        • threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
      • 除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
        • run(): 用以表示线程活动的方法。
        • start():启动线程活动。
        • join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
        • isAlive(): 返回线程是否活动的。
        • getName(): 返回线程名。
        • setName(): 设置线程名。
    • 使用 threading 模块创建线程
      • 我们可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法：
        • 实例
          • import threading import time exitFlag = 0 class myThread (threading.Thread): def __init__(self, threadID, name, delay): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.delay = delay def run(self): print ("开始线程：" + self.name) print_time(self.name, self.delay, 5) print ("退出线程：" + self.name) def print_time(threadName, delay, counter): while counter: if exitFlag: threadName.exit() time.sleep(delay) print ("%s: %s" % (threadName, time.ctime(time.time()))) counter -= 1 # 创建新线程 thread1 = myThread(1, "Thread-1", 1) thread2 = myThread(2, "Thread-2", 2) # 开启新线程 thread1.start() thread2.start() thread1.join() thread2.join() print ("退出主线程")
            • 以上程序执行结果如下；
            • 开始线程：Thread-1 开始线程：Thread-2 Thread-1: Wed Jan 5 17:34:54 2022 Thread-2: Wed Jan 5 17:34:55 2022 Thread-1: Wed Jan 5 17:34:55 2022 Thread-1: Wed Jan 5 17:34:56 2022 Thread-2: Wed Jan 5 17:34:57 2022 Thread-1: Wed Jan 5 17:34:57 2022 Thread-1: Wed Jan 5 17:34:58 2022 退出线程：Thread-1 Thread-2: Wed Jan 5 17:34:59 2022 Thread-2: Wed Jan 5 17:35:01 2022 Thread-2: Wed Jan 5 17:35:03 2022 退出线程：Thread-2 退出主线程
    • 线程同步
      • 如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
      • 使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：
      • 多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。
      • 考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。
      • 那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。
      • 锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。
      • 经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。
      • 实例
        • import threading import time class myThread (threading.Thread): def __init__(self, threadID, name, delay): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.delay = delay def run(self): print ("开启线程： " + self.name) # 获取锁，用于线程同步 threadLock.acquire() print_time(self.name, self.delay, 3) # 释放锁，开启下一个线程 threadLock.release() def print_time(threadName, delay, counter): while counter: time.sleep(delay) print ("%s: %s" % (threadName, time.ctime(time.time()))) counter -= 1 threadLock = threading.Lock() threads = [] # 创建新线程 thread1 = myThread(1, "Thread-1", 1) thread2 = myThread(2, "Thread-2", 2) # 开启新线程 thread1.start() thread2.start() # 添加线程到线程列表 threads.append(thread1) threads.append(thread2) # 等待所有线程完成 for t in threads: t.join() print ("退出主线程")
          • 执行以上程序，输出结果为：
          • 开启线程： Thread-1 开启线程： Thread-2 Thread-1: Wed Jan 5 17:36:50 2022 Thread-1: Wed Jan 5 17:36:51 2022 Thread-1: Wed Jan 5 17:36:52 2022 Thread-2: Wed Jan 5 17:36:54 2022 Thread-2: Wed Jan 5 17:36:56 2022 Thread-2: Wed Jan 5 17:36:58 2022 退出主线程
    • 线程优先级队列（ Queue）
      • Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。
      • 这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。
      • Queue 模块中的常用方法:
        • Queue.qsize() 返回队列的大小
        • Queue.empty() 如果队列为空，返回True,反之False
        • Queue.full() 如果队列满了，返回True,反之False
        • Queue.full 与 maxsize 大小对应
        • Queue.get([block[, timeout]])获取队列，timeout等待时间
        • Queue.get_nowait() 相当Queue.get(False)
        • Queue.put(item) 写入队列，timeout等待时间
        • Queue.put_nowait(item) 相当Queue.put(item, False)
        • Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
        • Queue.join() 实际上意味着等到队列为空，再执行别的操作
      • 实例
        • import queue import threading import time exitFlag = 0 class myThread (threading.Thread): def __init__(self, threadID, name, q): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.q = q def run(self): print ("开启线程：" + self.name) process_data(self.name, self.q) print ("退出线程：" + self.name) def process_data(threadName, q): while not exitFlag: queueLock.acquire() if not workQueue.empty(): data = q.get() queueLock.release() print ("%s processing %s" % (threadName, data)) else: queueLock.release() time.sleep(1) threadList = ["Thread-1", "Thread-2", "Thread-3"] nameList = ["One", "Two", "Three", "Four", "Five"] queueLock = threading.Lock() workQueue = queue.Queue(10) threads = [] threadID = 1 # 创建新线程 for tName in threadList: thread = myThread(threadID, tName, workQueue) thread.start() threads.append(thread) threadID += 1 # 填充队列 queueLock.acquire() for word in nameList: workQueue.put(word) queueLock.release() # 等待队列清空 while not workQueue.empty(): pass # 通知线程是时候退出 exitFlag = 1 # 等待所有线程完成 for t in threads: t.join() print ("退出主线程")
          • 以上程序执行结果：
          • 开启线程：Thread-1 开启线程：Thread-2 开启线程：Thread-3 Thread-3 processing One Thread-1 processing Two Thread-2 processing Three Thread-3 processing Four Thread-1 processing Five 退出线程：Thread-3 退出线程：Thread-2 退出线程：Thread-1 退出主线程
  • Python3 XML 解析
    • 什么是 XML？
      • XML 指可扩展标记语言（eXtensible Markup Language），标准通用标记语言的子集，是一种用于标记电子文件使其具有结构性的标记语言。 你可以通过本站学习 XML 教程
      • XML 被设计用来传输和存储数据。
      • XML 是一套定义语义标记的规则，这些标记将文档分成许多部件并对这些部件加以标识。
      • 它也是元标记语言，即定义了用于定义其他与特定领域有关的、语义的、结构化的标记语言的句法语言。
    • Python 对 XML 的解析
      • 常见的 XML 编程接口有 DOM 和 SAX，这两种接口处理 XML 文件的方式不同，当然使用场合也不同。
      • Python 有三种方法解析 XML，SAX，DOM，以及 ElementTree:
    • 1.SAX (simple API for XML )
      • Python 标准库包含 SAX 解析器，SAX 用事件驱动模型，通过在解析 XML 的过程中触发一个个的事件并调用用户定义的回调函数来处理 XML 文件。
    • 2.DOM(Document Object Model)
      • 将 XML 数据在内存中解析成一个树，通过对树的操作来操作 XML。
      • 本章节使用到的 XML 实例文件 movies.xml 内容如下：
      • 实例
        • <collection shelf="New Arrivals"> <movie title="Enemy Behind"> <type>War, Thriller</type> <format>DVD</format> <year>2003</year> <rating>PG</rating> <stars>10</stars> <description>Talk about a US-Japan war</description> </movie> <movie title="Transformers"> <type>Anime, Science Fiction</type> <format>DVD</format> <year>1989</year> <rating>R</rating> <stars>8</stars> <description>A schientific fiction</description> </movie> <movie title="Trigun"> <type>Anime, Action</type> <format>DVD</format> <episodes>4</episodes> <rating>PG</rating> <stars>10</stars> <description>Vash the Stampede!</description> </movie> <movie title="Ishtar"> <type>Comedy</type> <format>VHS</format> <rating>PG</rating> <stars>2</stars> <description>Viewable boredom</description> </movie> </collection>
    • Python 使用 SAX 解析 xml
      • SAX 是一种基于事件驱动的API。
      • 利用 SAX 解析 XML 文档牵涉到两个部分: 解析器和事件处理器。
      • 解析器负责读取 XML 文档，并向事件处理器发送事件，如元素开始跟元素结束事件。
      • 而事件处理器则负责对事件作出响应，对传递的 XML 数据进行处理。
        • 1、对大型文件进行处理；
        • 2、只需要文件的部分内容，或者只需从文件中得到特定信息。
        • 3、想建立自己的对象模型的时候。
      • 在 Python 中使用 sax 方式处理 xml 要先引入 xml.sax 中的 parse 函数，还有 xml.sax.handler 中的 ContentHandler。
      • ContentHandler 类方法介绍
        • characters(content) 方法
          • 调用时机：
            • 从行开始，遇到标签之前，存在字符，content 的值为这些字符串。
            • 从一个标签，遇到下一个标签之前， 存在字符，content 的值为这些字符串。
            • 从一个标签，遇到行结束符之前，存在字符，content 的值为这些字符串。
            • 标签可以是开始标签，也可以是结束标签。
        • startDocument() 方法
          • 文档启动的时候调用。
        • endDocument() 方法
          • 解析器到达文档结尾时调用。
        • startElement(name, attrs) 方法
          • 遇到XML开始标签时调用，name 是标签的名字，attrs 是标签的属性值字典。
        • endElement(name) 方法
          • 遇到XML结束标签时调用。
    • make_parser 方法
      • 以下方法创建一个新的解析器对象并返回。
        • xml.sax.make_parser( [parser_list] )
      • 参数说明:
        • parser_list - 可选参数，解析器列表
    • parser 方法
      • 以下方法创建一个 SAX 解析器并解析xml文档：
        • xml.sax.parse( xmlfile, contenthandler[, errorhandler])
      • 参数说明:
        • xmlfile - xml文件名
        • contenthandler - 必须是一个 ContentHandler 的对象
        • errorhandler - 如果指定该参数，errorhandler 必须是一个 SAX ErrorHandler 对象
    • parseString 方法
      • parseString 方法创建一个 XML 解析器并解析 xml 字符串：
        • xml.sax.parseString(xmlstring, contenthandler[, errorhandler])
      • 参数说明:
        • xmlstring - xml字符串
        • contenthandler - 必须是一个 ContentHandler 的对象
        • errorhandler - 如果指定该参数，errorhandler 必须是一个 SAX ErrorHandler对象
    • Python 解析XML实例
      • 实例
        • import xml.sax class MovieHandler( xml.sax.ContentHandler ): def __init__(self): self.CurrentData = "" self.type = "" self.format = "" self.year = "" self.rating = "" self.stars = "" self.description = "" # 元素开始调用 def startElement(self, tag, attributes): self.CurrentData = tag if tag == "movie": print ("*****Movie*****") title = attributes["title"] print ("Title:", title) # 元素结束调用 def endElement(self, tag): if self.CurrentData == "type": print ("Type:", self.type) elif self.CurrentData == "format": print ("Format:", self.format) elif self.CurrentData == "year": print ("Year:", self.year) elif self.CurrentData == "rating": print ("Rating:", self.rating) elif self.CurrentData == "stars": print ("Stars:", self.stars) elif self.CurrentData == "description": print ("Description:", self.description) self.CurrentData = "" # 读取字符时调用 def characters(self, content): if self.CurrentData == "type": self.type = content elif self.CurrentData == "format": self.format = content elif self.CurrentData == "year": self.year = content elif self.CurrentData == "rating": self.rating = content elif self.CurrentData == "stars": self.stars = content elif self.CurrentData == "description": self.description = content if ( __name__ == "__main__"): # 创建一个 XMLReader parser = xml.sax.make_parser() # 关闭命名空间 parser.setFeature(xml.sax.handler.feature_namespaces, 0) # 重写 ContextHandler Handler = MovieHandler() parser.setContentHandler( Handler ) parser.parse("movies.xml")
          • 以上代码执行结果如下：
          • *****Movie***** Title: Enemy Behind Type: War, Thriller Format: DVD Year: 2003 Rating: PG Stars: 10 Description: Talk about a US-Japan war *****Movie***** Title: Transformers Type: Anime, Science Fiction Format: DVD Year: 1989 Rating: R Stars: 8 Description: A schientific fiction *****Movie***** Title: Trigun Type: Anime, Action Format: DVD Rating: PG Stars: 10 Description: Vash the Stampede! *****Movie***** Title: Ishtar Type: Comedy Format: VHS Rating: PG Stars: 2 Description: Viewable boredom
          • 完整的 SAX API 文档请查阅Python SAX APIs
    • 使用xml.dom解析xml
      • 文件对象模型（Document Object Model，简称DOM），是W3C组织推荐的处理可扩展置标语言的标准编程接口。
      • 一个 DOM 的解析器在解析一个 XML 文档时，一次性读取整个文档，把文档中所有元素保存在内存中的一个树结构里，之后你可以利用DOM 提供的不同的函数来读取或修改文档的内容和结构，也可以把修改过的内容写入xml文件。
      • Python 中用 xml.dom.minidom 来解析 xml 文件，实例如下：
        • 实例
          • from xml.dom.minidom import parse import xml.dom.minidom # 使用minidom解析器打开 XML 文档 DOMTree = xml.dom.minidom.parse("movies.xml") collection = DOMTree.documentElement if collection.hasAttribute("shelf"): print ("Root element : %s" % collection.getAttribute("shelf")) # 在集合中获取所有电影 movies = collection.getElementsByTagName("movie") # 打印每部电影的详细信息 for movie in movies: print ("*****Movie*****") if movie.hasAttribute("title"): print ("Title: %s" % movie.getAttribute("title")) type = movie.getElementsByTagName('type')[0] print ("Type: %s" % type.childNodes[0].data) format = movie.getElementsByTagName('format')[0] print ("Format: %s" % format.childNodes[0].data) rating = movie.getElementsByTagName('rating')[0] print ("Rating: %s" % rating.childNodes[0].data) description = movie.getElementsByTagName('description')[0] print ("Description: %s" % description.childNodes[0].data)
            • 以上程序执行结果如下：
            • Root element : New Arrivals *****Movie***** Title: Enemy Behind Type: War, Thriller Format: DVD Rating: PG Description: Talk about a US-Japan war *****Movie***** Title: Transformers Type: Anime, Science Fiction Format: DVD Rating: R Description: A schientific fiction *****Movie***** Title: Trigun Type: Anime, Action Format: DVD Rating: PG Description: Vash the Stampede! *****Movie***** Title: Ishtar Type: Comedy Format: VHS Rating: PG Description: Viewable boredom
          • 完整的 DOM API 文档请查阅Python DOM APIs。
  • Python3 JSON 数据解析
    • JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。
    • 如果你还不了解 JSON，可以先阅读我们的 JSON 教程。
    • Python3 中可以使用 json 模块来对 JSON 数据进行编解码，它包含了两个函数：
      • json.dumps(): 对数据进行编码。
      • json.loads(): 对数据进行解码。
    • 在 json 的编解码过程中，Python 的原始类型与 json 类型会相互转换，具体的转化对照如下：
    • Python 编码为 JSON 类型转换对应表：
      • Python JSON dict object list, tuple array str string int, float, int- & float-derived Enums number True true False false None null
    • JSON 解码为 Python 类型转换对应表：
      • JSON Python object dict array list string str number (int) int number (real) float true True false False null None
    • json.dumps 与 json.loads 实例
      • 以下实例演示了 Python 数据结构转换为JSON：
        • 实例(Python 3.0+)
          • import json # Python 字典类型转换为 JSON 对象 data = { 'no' : 1, 'name' : 'Runoob', 'url' : 'http://www.runoob.com' } json_str = json.dumps(data) print ("Python 原始数据：", repr(data)) print ("JSON 对象：", json_str)
            • 执行以上代码输出结果为：
            • Python 原始数据： {'url': 'http://www.runoob.com', 'no': 1, 'name': 'Runoob'} JSON 对象： {"url": "http://www.runoob.com", "no": 1, "name": "Runoob"}
      • 通过输出的结果可以看出，简单类型通过编码后跟其原始的repr()输出结果非常相似。
        • 接着以上实例，我们可以将一个JSON编码的字符串转换回一个Python数据结构：
        • 实例(Python 3.0+)
          • import json # Python 字典类型转换为 JSON 对象 data1 = { 'no' : 1, 'name' : 'Runoob', 'url' : 'http://www.runoob.com' } json_str = json.dumps(data1) print ("Python 原始数据：", repr(data1)) print ("JSON 对象：", json_str) # 将 JSON 对象转换为 Python 字典 data2 = json.loads(json_str) print ("data2['name']: ", data2['name']) print ("data2['url']: ", data2['url'])
            • 执行以上代码输出结果为：
            • Python 原始数据： {'name': 'Runoob', 'no': 1, 'url': 'http://www.runoob.com'} JSON 对象： {"name": "Runoob", "no": 1, "url": "http://www.runoob.com"} data2['name']: Runoob data2['url']: http://www.runoob.com
      • 如果你要处理的是文件而不是字符串，你可以使用 json.dump() 和 json.load() 来编码和解码JSON数据。例如：
        • 实例(Python 3.0+)
          • # 写入 JSON 数据 with open('data.json', 'w') as f: json.dump(data, f) # 读取数据 with open('data.json', 'r') as f: data = json.load(f)
      • 更多资料请参考：https://docs.python.org/3/library/json.html
  • Python 日期和时间
    • Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
    • Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
    • 时间间隔是以秒为单位的浮点小数。
    • 每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
    • Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:
      • 实例(Python 2.0+)
        • # -*- coding: UTF-8 -*- import time # 引入time模块 ticks = time.time() print "当前时间戳为:", ticks
          • 当前时间戳为: 1459994552.51
    • 时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
    • 什么是时间元组？
      • 很多Python函数用一个元组装起来的9组数字处理时间:
        • 序号 字段 值 0 4位数年 2008 1 月 1 到 12 2 日 1到31 3 小时 0到23 4 分钟 0到59 5 秒 0到61 (60或61 是闰秒) 6 一周的第几日 0到6 (0是周一) 7 一年的第几日 1到366 (儒略历) 8 夏令时 -1, 0, 1, -1是决定是否为夏令时的旗帜
    • 上述也就是struct_time元组。这种结构具有如下属性：
      • 序号 属性 值 0 tm_year 2008 1 tm_mon 1 到 12 2 tm_mday 1 到 31 3 tm_hour 0 到 23 4 tm_min 0 到 59 5 tm_sec 0 到 61 (60或61 是闰秒) 6 tm_wday 0到6 (0是周一) 7 tm_yday 1 到 366(儒略历) 8 tm_isdst -1, 0, 1, -1是决定是否为夏令时的旗帜
    • 获取当前时间
      • 从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
      • 实例(Python 2.0+)
        • # -*- coding: UTF-8 -*- import time localtime = time.localtime(time.time()) print "本地时间为 :", localtime
          • 本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)
    • 获取格式化的时间
      • 你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
      • 实例(Python 2.0+)
        • # -*- coding: UTF-8 -*- import time localtime = time.asctime( time.localtime(time.time()) ) print "本地时间为 :", localtime
          • 本地时间为 : Thu Apr 7 10:05:21 2016
    • 格式化日期
      • 我们可以使用 time 模块的 strftime 方法来格式化日期，：
        • time.strftime(format[, t])
      • 实例演示：
        • 实例(Python 2.0+)
          • # -*- coding: UTF-8 -*- import time # 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 格式化成Sat Mar 28 22:24:24 2016形式 print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) # 将格式字符串转换为时间戳 a = "Sat Mar 28 22:24:24 2016" print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
            • 2016-04-07 10:25:09 Thu Apr 07 10:25:09 2016 1459175064.0
      • python中时间日期格式化符号：
        • %y 两位数的年份表示（00-99）
        • %Y 四位数的年份表示（000-9999）
        • %m 月份（01-12）
        • %d 月内中的一天（0-31）
        • %H 24小时制小时数（0-23）
        • %I 12小时制小时数（01-12）
        • %M 分钟数（00-59）
        • %S 秒（00-59）
        • %a 本地简化星期名称
        • %A 本地完整星期名称
        • %b 本地简化的月份名称
        • %B 本地完整的月份名称
        • %c 本地相应的日期表示和时间表示
        • %j 年内的一天（001-366）
        • %p 本地A.M.或P.M.的等价符
        • %U 一年中的星期数（00-53）星期天为星期的开始
        • %w 星期（0-6），星期天为星期的开始
        • %W 一年中的星期数（00-53）星期一为星期的开始
        • %x 本地相应的日期表示
        • %X 本地相应的时间表示
        • %Z 当前时区的名称
        • %% %号本身
    • 获取某月日历
      • Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
      • 实例(Python 2.0+)
        • # -*- coding: UTF-8 -*- import calendar cal = calendar.month(2016, 1) print "以下输出2016年1月份的日历:" print cal
          • 以下输出2016年1月份的日历: January 2016 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
      • Time 模块
        • Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：
          • 序号 函数及描述
          • 1 time.altzone
            • 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
              • 描述
                • Python time altzone() 函数返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
              • 语法
                • altzone()方法语法：
                  • time.altzone
              • 参数
                • NA。
              • 返回值
                • 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。
              • 实例
                • 以下实例展示了 altzone()函数的使用方法：
                  • import time print "time.altzone %d " % time.altzone
                    • time.altzone() 25200
          • 2 time.asctime([tupletime])
            • 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
              • 描述
                • Python time asctime() 函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
              • 语法
                • asctime()方法语法：
                  • time.asctime([t]))
              • 参数
                • t -- 9个元素的元组或者通过函数 gmtime() 或 localtime() 返回的时间值。
              • 返回值
                • 返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
              • 实例
                • 以下实例展示了 asctime()函数的使用方法：
                  • import time t = time.localtime() print "time.asctime(t): %s " % time.asctime(t)
                    • time.asctime(t): Tue Feb 17 09:42:58 2009
          • 3 time.clock( )
            • 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
              • 描述
                • Python 3.8 已移除 clock() 方法 可以使用 time.perf_counter() 或 time.process_time() 方法替代。
                • Python time clock() 函数以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
                • 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）
              • 语法
                • clock()方法语法：
                  • time.clock()
              • 参数
                • NA。
              • 返回值
                • 该函数有两个功能，
                  • 在第一次调用的时候，返回的是程序运行的实际时间；
                  • 以第二次之后的调用，返回的是自第一次调用后,到这次调用的时间间隔
                  • 在win32系统下，这个函数返回的是真实时间（wall time），而在Unix/Linux下返回的是CPU时间。
              • 实例
                • 以下实例展示了 clock()函数的使用方法：
                  • import time def procedure(): time.sleep(2.5) # measure process time t0 = time.clock() procedure() print time.clock() - t0, "seconds process time" # measure wall time t0 = time.time() procedure() print time.time() - t0, "seconds wall time"
                    • 3.3e-05 seconds process time 2.50329995155 seconds wall time
          • 4 time.ctime([secs])
            • 作用相当于asctime(localtime(secs))，未给参数相当于asctime()
              • 描述
                • Python time ctime() 函数把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。 如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于 asctime(localtime(secs))。
              • 语法
                • ctime()方法语法：
                  • time.ctime([ sec ])
              • 参数
                • sec -- 要转换为字符串时间的秒数。
              • 返回值
                • 该函数没有任何返回值。
              • 实例
                • 以下实例展示了 ctime() 函数的使用方法：
                  • import time print "time.ctime() : %s" % time.ctime()
                    • time.ctime() : Tue Feb 17 10:00:18 2013
          • 5 time.gmtime([secs])
            • 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
              • 描述
                • Python time localtime() 函数类似gmtime()，作用是格式化时间戳为本地的时间。 如果sec参数未输入，则以当前时间为转换标准。 DST (Daylight Savings Time) flag (-1, 0 or 1) 是否是夏令时。
              • 语法
                • localtime()方法语法：
                  • time.localtime([ sec ])
              • 参数
                • sec -- 转换为time.struct_time类型的对象的秒数。
              • 返回值
                • 该函数没有任何返回值。
              • 实例
                • 以下实例展示了 localtime() 函数的使用方法：
                  • import time print "time.localtime() : %s" % time.localtime()
                    • time.localtime() : time.struct_time(tm_year=2016, tm_mon=11, tm_mday=27, tm_hour=10, tm_min=26, tm_sec=5, tm_wday=6, tm_yday=332, tm_isdst=0)
          • 6 time.localtime([secs])
            • 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
              • 描述
                • Python time localtime() 函数类似gmtime()，作用是格式化时间戳为本地的时间。 如果sec参数未输入，则以当前时间为转换标准。 DST (Daylight Savings Time) flag (-1, 0 or 1) 是否是夏令时。
              • 语法
                • localtime()方法语法：
                  • time.localtime([ sec ])
              • 参数
                • sec -- 转换为time.struct_time类型的对象的秒数。
              • 返回值
                • 该函数没有任何返回值。
              • 实例
                • 以下实例展示了 localtime() 函数的使用方法：
                  • import time print "time.localtime() : %s" % time.localtime()
                    • time.localtime() : time.struct_time(tm_year=2016, tm_mon=11, tm_mday=27, tm_hour=10, tm_min=26, tm_sec=5, tm_wday=6, tm_yday=332, tm_isdst=0)
          • 7 time.mktime(tupletime)
            • 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
              • 描述
                • Python time mktime() 函数执行与gmtime(), localtime()相反的操作，它接收struct_time对象作为参数，返回用秒数来表示时间的浮点数。
                • 如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError。
              • 语法
                • mktime()方法语法：
                  • time.mktime(t)
              • 参数
                • t -- 结构化的时间或者完整的9位元组元素。
              • 返回值
                • 返回用秒数来表示时间的浮点数。
              • 实例
                • 以下实例展示了 mktime() 函数的使用方法：
                  • import time t = (2009, 2, 17, 17, 3, 38, 1, 48, 0) secs = time.mktime( t ) print "time.mktime(t) : %f" % secs print "asctime(localtime(secs)): %s" % time.asctime(time.localtime(secs))
                    • time.mktime(t) : 1234915418.000000 asctime(localtime(secs)): Tue Feb 17 17:03:38 2009
          • 8 time.sleep(secs)
            • 推迟调用线程的运行，secs指秒数。
              • 描述
                • Python time sleep() 函数推迟调用线程的运行，可通过参数secs指秒数，表示进程挂起的时间。
              • 语法
                • sleep()方法语法：
                  • time.sleep(t)
              • 参数
                • t -- 推迟执行的秒数。
              • 返回值
                • 该函数没有返回值。
              • 实例
                • 以下实例展示了 sleep() 函数的使用方法：
                  • import time print "Start : %s" % time.ctime() time.sleep( 5 ) print "End : %s" % time.ctime()
                    • Start : Tue Feb 17 10:19:18 2013 End : Tue Feb 17 10:19:23 2013
          • 9 time.strftime(fmt[,tupletime])
            • 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
              • 描述
                • Python time strftime() 函数用于格式化时间，返回以可读字符串表示的当地时间，格式由参数 format 决定。
              • 语法
                • strftime()方法语法：
                  • time.strftime(format[, t])
              • 参数
                • format -- 格式字符串。
                • t -- 可选的参数 t 是一个 struct_time 对象。
              • 返回值
                • 返回以可读字符串表示的当地时间。
              • 说明
                • 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 当前时区的名称
                  • %% %号本身
              • 实例
                • 以下实例展示了 strftime() 函数的使用方法：
                  • # -*- coding: UTF-8 -*- # 通过导入 __future__ 包来兼容 Python3.x print # 如果使用了 Python3.x 可以删除此行引入 from __future__ import print_function from datetime import datetime now = datetime.now() # current date and time year = now.strftime("%Y") print("year:", year) month = now.strftime("%m") print("month:", month) day = now.strftime("%d") print("day:", day) time = now.strftime("%H:%M:%S") print("time:", time) date_time = now.strftime("%Y-%m-%d, %H:%M:%S") print("date and time:",date_time)
                    • year: 2020 month: 09 day: 25 time: 10:24:28 date and time: 2020-09-25, 10:24:28
          • 10 time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
            • 根据fmt的格式把一个时间字符串解析为时间元组。
              • 描述
                • Python time strptime() 函数根据指定的格式把一个时间字符串解析为时间元组。
              • 语法
                • strptime()方法语法：
                  • time.strptime(string[, format])
              • 参数
                • string -- 时间字符串。
                • format -- 格式化字符串。
              • 返回值
                • 返回struct_time对象。
              • 说明
                • 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），星期天为 0，星期一为 1，以此类推。
                  • %W 一年中的星期数（00-53）星期一为星期的开始
                  • %x 本地相应的日期表示
                  • %X 本地相应的时间表示
                  • %Z 当前时区的名称
                  • %% %号本身
              • 实例
                • 以下实例展示了 strptime() 函数的使用方法：
                  • # -*- coding: UTF-8 -*- import time struct_time = time.strptime("30 Nov 00", "%d %b %y") print "返回的元组: %s " % struct_time
                    • 返回的元组: time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)
          • 11 time.time( )
            • 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
              • 描述
                • Python time time() 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
              • 语法
                • time()方法语法：
                  • time.time()
              • 参数
                • NA。
              • 返回值
                • 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
              • 实例
                • 以下实例展示了 time() 函数的使用方法：
                  • import time print "time.time(): %f " % time.time() print time.localtime( time.time() ) print time.asctime( time.localtime(time.time()) )
                    • time.time(): 1234892919.655932 (2009, 2, 17, 10, 48, 39, 1, 48, 0) Tue Feb 17 10:48:39 2009
          • 12 time.tzset()
            • 根据环境变量TZ重新初始化时间相关设置。
              • 描述
                • Python time tzset() 根据环境变量TZ重新初始化时间相关设置。
              • 标准TZ环境变量格式：
                • std offset [dst [offset [,start[/time], end[/time]]]]
              • 参数
                • std 和 dst:三个或者多个时间的缩写字母。传递给 time.tzname.
                • offset: 距UTC的偏移，格式： [+|-]hh[:mm[:ss]] {h=0-23, m/s=0-59}。
                • start[/time], end[/time]: DST 开始生效时的日期。格式为 m.w.d — 代表日期的月份、周数和日期。w=1 指月份中的第一周，而 w=5 指月份的最后一周。'start' 和 'end' 可以是以下格式之一：
                  • Jn: 儒略日 n (1 <= n <= 365)。闰年日（2月29）不计算在内。
                  • n: 儒略日 (0 <= n <= 365)。 闰年日（2月29）计算在内
                  • Mm.n.d: 日期的月份、周数和日期。w=1 指月份中的第一周，而 w=5 指月份的最后一周。
                  • time:（可选）DST 开始生效时的时间（24 小时制）。默认值为 02:00（指定时区的本地时间）。
              • 语法
                • time.tzset()
              • 参数
                • NA。
              • 返回值
                • 该函数没有返回值。
              • 实例
                • 以下实例展示了 tzset() 函数的使用方法：
                  • import time import os os.environ['TZ'] = 'EST+05EDT,M4.1.0,M10.5.0' time.tzset() print time.strftime('%X %x %Z') os.environ['TZ'] = 'AEST-10AEDT-11,M10.5.0,M3.5.0' time.tzset() print time.strftime('%X %x %Z')
                    • 13:00:40 02/17/09 EST 05:00:40 02/18/09 AEDT
      • Time模块包含了以下2个非常重要的属性：
        • 序号 属性及描述
        • 1 time.timezone
        • 属性 time.timezone 是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲<=0大部分欧洲，亚洲，非洲）。
        • 2 time.tzname
        • 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。
    • 日历（Calendar）模块
      • 此模块的函数都是日历相关的，例如打印某月的字符月历。
      • 星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：
        • 序号 函数及描述
        • 1 calendar.calendar(year,w=2,l=1,c=6)
          • 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
        • 2 calendar.firstweekday( )
          • 返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。
        • 3 calendar.isleap(year)
          • 是闰年返回 True，否则为 False。
            • >>> import calendar >>> print(calendar.isleap(2000)) True >>> print(calendar.isleap(1900)) False
        • 4 calendar.leapdays(y1,y2)
          • 返回在Y1，Y2两年之间的闰年总数。
        • 5 calendar.month(year,month,w=2,l=1)
          • 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
        • 6 calendar.monthcalendar(year,month)
          • 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
        • 7 calendar.monthrange(year,month)
          • 返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
        • 8 calendar.prcal(year,w=2,l=1,c=6)
          • 相当于 print calendar.calendar(year,w=2,l=1,c=6)。
        • 9 calendar.prmonth(year,month,w=2,l=1)
          • 相当于 print calendar.month(year,month,w=2,l=1) 。
        • 10 calendar.setfirstweekday(weekday)
          • 设置每周的起始日期码。0（星期一）到6（星期日）。
        • 11 calendar.timegm(tupletime)
          • 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
        • 12 calendar.weekday(year,month,day)
          • 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。
      • 其他相关模块和函数
        • 在Python中，其他处理日期和时间的模块还有：
          • datetime模块
            • https://docs.python.org/3/library/datetime.html#module-datetime
          • pytz模块
          • dateutil模块
            • http://labix.org/python-dateutil
  • Python 内置函数
    • abs()
      • 描述
        • abs() 函数返回数字的绝对值。
      • 语法
        • 以下是 abs() 方法的语法:
          • abs( x )
      • 参数
        • x -- 数值表达式。
      • 返回值
        • 函数返回x（数字）的绝对值。
      • 实例
        • 以下展示了使用 abs() 方法的实例：
          • print "abs(-45) : ", abs(-45) print "abs(100.12) : ", abs(100.12) print "abs(119L) : ", abs(119L)
            • abs(-45) : 45 abs(100.12) : 100.12 abs(119L) : 119
    • divmod()
      • python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
      • 在 python 2.3 版本之前不允许处理复数。
      • 函数语法
        • divmod(a, b)
      • 参数说明：
        • a: 数字
        • b: 数字
      • 实例
        • >>>divmod(7, 2) (3, 1) >>> divmod(8, 2) (4, 0) >>> divmod(1+2j,1+0.5j) ((1+0j), 1.5j)
    • input()
      • Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
      • Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。
      • raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）。
        • 注意：input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
      • 除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
      • 注意：python3 里 input() 默认接收到的是 str 类型。
      • 函数语法
        • input([prompt])
      • 参数说明：
        • prompt: 提示信息
      • 实例
        • Python2.x: input() 需要输入 python 表达式
          • >>>a = input("input:") input:123 # 输入整数 >>> type(a) <type 'int'> # 整型 >>> a = input("input:") input:"runoob" # 正确，字符串表达式 >>> type(a) <type 'str'> # 字符串 >>> a = input("input:") input:runoob # 报错，不是表达式 Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<string>", line 1, in <module> NameError: name 'runoob' is not defined <type 'str'>
        • Python2.x: raw_input() 将所有输入作为字符串看待
          • >>>a = raw_input("input:") input:123 >>> type(a) <type 'str'> # 字符串 >>> a = raw_input("input:") input:runoob >>> type(a) <type 'str'> # 字符串
      • Python3 input() 函数
        • Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
        • 注意：在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
        • 函数语法
          • input([prompt])
        • 参数说明：
          • prompt: 提示信息
        • 实例
          • input() 需要输入 python 表达式
            • >>>a = input("input:") input:123 # 输入整数 >>> type(a) <class 'str'> # 字符串 >>> a = input("input:") input:runoob # 正确，字符串表达式 >>> type(a) <class 'str'> # 字符串
          • input() 接收多个值
            • #输入三角形的三边长 a,b,c = (input("请输入三角形三边的长：").split()) a= int(a) b= int(b) c= int(c) #计算三角形的半周长p p=(a+b+c)/2 #计算三角形的面积s s=(p*(p-a)*(p-b)*(p-c))**0.5 #输出三角形的面积 print("三角形面积为：",format(s,'.2f'))
              • 请输入三角形三边的长：3 4 5 三角形面积为： 6.00
    • open()
      • python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
        • 更多文件操作可参考：Python 文件I/O。
      • 函数语法
        • open(name[, mode[, buffering]])
      • 参数说明：
        • name : 一个包含了你要访问的文件名称的字符串值。
        • mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
        • buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
      • 不同模式打开文件的完全列表：
        • 模式 描述
        • t 文本模式 (默认)。
        • x 写模式，新建一个文件，如果该文件已存在则会报错。
        • b 二进制模式。
        • + 打开一个文件进行更新(可读可写)。
        • U 通用换行模式（不推荐）。
        • r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
        • rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
        • r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
        • rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
        • w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
        • w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
        • wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
        • a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        • ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
        • a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
        • ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
      • file 对象方法
        • file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
        • file.readline()：返回一行。
        • file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
        • for line in f: print line ：通过迭代器访问。
        • f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。
        • f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的字节数)。
        • f.seek(偏移量,[起始位置])：用来移动文件指针。
        • 偏移量: 单位为字节，可正可负
        • 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
        • f.close() 关闭文件
      • 实例
        • 测试文件 test.txt，内容如下：
          • RUNOOB1 RUNOOB2
            • >>>f = open('test.txt') >>> f.read() 'RUNOOB1\nRUNOOB2\n'
    • staticmethod()
      • python staticmethod 返回函数的静态方法。
        • 该方法不强制要求传递参数，如下声明一个静态方法：
          • class C(object): @staticmethod def f(arg1, arg2, ...): ...
        • 以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()。
      • 函数语法
        • staticmethod(function)
      • 参数说明：
        • 无
      • 实例
        • # -*- coding: UTF-8 -*- class C(object): @staticmethod def f(): print('runoob'); C.f(); # 静态方法无需实例化 cobj = C() cobj.f() # 也可以实例化后调用
          • runoob runoob
    • all()
      • 描述
        • all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
        • 元素除了是 0、空、None、False 外都算 True。
        • 函数等价于：
          • def all(iterable): for element in iterable: if not element: return False return True
        • Python 2.5 以上版本可用。
      • 语法
        • 以下是 all() 方法的语法:
          • all(iterable)
      • 参数
        • iterable -- 元组或列表。
      • 返回值
        • 如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
        • 注意：空元组、空列表返回值为True，这里要特别注意。
      • 实例
        • 以下展示了使用 all() 方法的实例：
          • >>> all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0 True >>> all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素 False >>> all([0, 1，2, 3]) # 列表list，存在一个为0的元素 False >>> all(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0 True >>> all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素 False >>> all((0, 1, 2, 3)) # 元组tuple，存在一个为0的元素 False >>> all([]) # 空列表 True >>> all(()) # 空元组 True
    • enumerate()
      • 描述
        • enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
        • Python 2.3. 以上版本可用，2.6 添加 start 参数。
      • 语法
        • 以下是 enumerate() 方法的语法:
          • enumerate(sequence, [start=0])
      • 参数
        • sequence -- 一个序列、迭代器或其他支持迭代对象。
        • start -- 下标起始位置。
      • 返回值
        • 返回 enumerate(枚举) 对象。
      • 实例
        • 以下展示了使用 enumerate() 方法的实例：
          • >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] >>> list(enumerate(seasons, start=1)) # 下标从 1 开始 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
      • 普通的 for 循环
        • >>>i = 0 >>> seq = ['one', 'two', 'three'] >>> for element in seq: ... print i, seq[i] ... i +=1 ... 0 one 1 two 2 three
      • for 循环使用 enumerate
        • >>>seq = ['one', 'two', 'three'] >>> for i, element in enumerate(seq): ... print i, element ... 0 one 1 two 2 three
    • int()
      • 描述
        • int() 函数用于将一个字符串或数字转换为整型。
      • 语法
        • 以下是 int() 方法的语法:
        • class int(x, base=10)
      • 参数
        • x -- 字符串或数字。
        • base -- 进制数，默认十进制。
      • 返回值
        • 返回整型数据。
      • 实例
        • 以下展示了使用 int() 方法的实例：
          • >>>int() # 不传入参数时，得到结果0 0 >>> int(3) 3 >>> int(3.6) 3 >>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18 >>> int('0xa',16) 10 >>> int('10',8) 8
    • ord()
      • 描述
        • ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
      • 语法
        • 以下是 ord() 方法的语法:
          • ord(c)
      • 参数
        • c -- 字符。
      • 返回值
        • 返回值是对应的十进制整数。
      • 实例
        • 以下展示了使用 ord() 方法的实例：
          • >>>ord('a') 97 >>> ord('b') 98 >>> ord('c') 99
    • str()
      • 描述
        • str() 函数将对象转化为适于人阅读的形式。
      • 语法
        • 以下是 str() 方法的语法:
        • class str(object='')
      • 参数
        • object -- 对象。
      • 返回值
        • 返回一个对象的string格式。
      • 实例
        • 以下展示了使用 str() 方法的实例：
          • >>>s = 'RUNOOB' >>> str(s) 'RUNOOB' >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> str(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}" >>>
    • any()
      • 描述
        • any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
        • 元素除了是 0、空、FALSE 外都算 TRUE。
        • 函数等价于：
          • def any(iterable): for element in iterable: if element: return True return False
        • Python 2.5 以上版本可用。
      • 语法
        • 以下是 any() 方法的语法:
          • any(iterable)
      • 参数
        • iterable -- 元组或列表。
      • 返回值
        • 如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
      • 实例
        • 以下展示了使用 any() 方法的实例：
          • >>>any(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0 True >>> any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素 True >>> any([0, '', False]) # 列表list,元素全为0,'',false False >>> any(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0 True >>> any(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素 True >>> any((0, '', False)) # 元组tuple，元素全为0,'',false False >>> any([]) # 空列表 False >>> any(()) # 空元组 False
    • eval()
      • 描述
        • eval() 函数用来执行一个字符串表达式，并返回表达式的值。
      • 语法
        • 以下是 eval() 方法的语法:
          • eval(expression[, globals[, locals]])
      • 参数
        • expression -- 表达式。
        • globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
        • locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
      • 返回值
        • 返回表达式计算结果。
      • 实例
        • 以下展示了使用 eval() 方法的实例：
          • >>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> n=81 >>> eval("n + 4") 85
    • isinstance()
      • 描述
        • isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
        • isinstance() 与 type() 区别：
        • type() 不会认为子类是一种父类类型，不考虑继承关系。
        • isinstance() 会认为子类是一种父类类型，考虑继承关系。
        • 如果要判断两个类型是否相同推荐使用 isinstance()。
      • 语法
        • 以下是 isinstance() 方法的语法:
          • isinstance(object, classinfo)
      • 参数
        • object -- 实例对象。
        • classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
      • 返回值
        • 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
      • 实例
        • 以下展示了使用 isinstance 函数的实例：
          • >>>a = 2 >>> isinstance (a,int) True >>> isinstance (a,str) False >>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True True
      • type() 与 isinstance()区别：
        • 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
    • pow()
      • 描述
        • pow() 方法返回 xy（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 -- 数值表达式。
      • 返回值
        • 返回 xy（x的y次方） 的值。
      • 实例
        • 以下展示了使用 pow() 方法的实例：
          • # -*- coding: UTF-8 -*- 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
    • sum()
      • 描述
        • sum() 方法对序列进行求和计算。
      • 语法
        • 以下是 sum() 方法的语法:
          • sum(iterable[, start])
      • 参数
        • iterable -- 可迭代对象，如：列表、元组、集合。
        • start -- 指定相加的参数，如果没有设置这个值，默认为0。
      • 返回值
        • 返回计算结果。
      • 实例
        • 以下展示了使用 sum 函数的实例：
          • >>>sum([0,1,2]) 3 >>> sum((2, 3, 4), 1) # 元组计算总和后再加 1 10 >>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2 12
    • basestring()
      • 描述
        • basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为 str 或者 unicode 的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
        • 注意：Python3 不支持 basestring() 函数，改用 str() 函数。
      • 语法
        • 以下是 basestring() 方法的语法:
          • basestring()
      • 参数
        • 无
      • 返回值
        • 无。
      • 实例
        • 以下展示了使用 basestring 函数的实例：
          • >>>isinstance("Hello world", str) True >>> isinstance("Hello world", basestring) True
    • execfile()
      • 描述
        • execfile() 函数可以用来执行一个文件。
      • 语法
        • 以下是 execfile() 方法的语法:
          • execfile(filename[, globals[, locals]])
      • 参数
        • filename -- 文件名。
        • globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
        • locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
      • 返回值
        • 返回表达式执行结果。
      • 实例
        • 以下展示了使用 execfile 函数的实例：
          • 假设文件 hello.py，内容如下：
            • print('runoob');
      • execfile 调用该文件
        • >>>execfile('hello.py') runoob
          • 子主题
    • issubclass()
      • 描述
        • issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
      • 语法
        • 以下是 issubclass() 方法的语法:
          • issubclass(class, classinfo)
      • 参数
        • class -- 类。
        • classinfo -- 类。
      • 返回值
        • 如果 class 是 classinfo 的子类返回 True，否则返回 False。
      • 实例
        • 以下展示了使用 issubclass 函数的实例：
          • # -*- coding: UTF-8 -*- class A: pass class B(A): pass print(issubclass(B,A)) # 返回 True
    • print()
      • 描述
        • print() 方法用于打印输出，最常见的一个函数。
        • 在 Python3.3 版增加了 flush 关键字参数。
        • print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。
      • 语法
        • 以下是 print() 方法的语法:
          • print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
      • 参数
        • objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
        • sep -- 用来间隔多个对象，默认值是一个空格。
        • end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
        • file -- 要写入的文件对象。
        • flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
      • 返回值
        • 无。
      • 实例
        • 以下展示了使用 print 函数的实例：
          • >>>print(1) 1 >>> print("Hello World") Hello World >>> a = 1 >>> b = 'runoob' >>> print(a,b) 1 runoob >>> print("aaa""bbb") aaabbb >>> print("aaa","bbb") aaa bbb >>> >>> print("www","runoob","com",sep=".") # 设置间隔符 www.runoob.com
        • 使用 flush 参数生成一个 Loading 的效果：
          • import time print("---RUNOOB EXAMPLE ： Loading 效果---") print("Loading",end = "") for i in range(20): print(".",end = '',flush = True) time.sleep(0.5)
        • 效果如下图：
      • Python3 print 函数用法总结
        • 1. 输出字符串和数字
          • >>>print("runoob") # 输出字符串 runoob >>> print(100) # 输出数字 100 >>> str = 'runoob' >>> print(str) # 输出变量 runoob >>> L = [1,2,'a'] # 列表 >>> print(L) [1, 2, 'a'] >>> t = (1,2,'a') # 元组 >>> print(t) (1, 2, 'a') >>> d = {'a':1, 'b':2} # 字典 >>> print(d) {'a': 1, 'b': 2}
        • 2. 格式化输出整数
          • 支持参数格式化，与 C 语言的 printf 类似
            • >>>str = "the length of (%s) is %d" %('runoob',len('runoob')) >>> print(str) the length of (runoob) is 6
          • python字符串格式化符号:
            • 符 号 描述
            • %c 格式化字符及其ASCII码
            • %s 格式化字符串
            • %d 格式化整数
            • %u 格式化无符号整型
            • %o 格式化无符号八进制数
            • %x 格式化无符号十六进制数
            • %X 格式化无符号十六进制数（大写）
            • %f 格式化浮点数字，可指定小数点后的精度
            • %e 用科学计数法格式化浮点数
            • %E 作用同%e，用科学计数法格式化浮点数
            • %g %f和%e的简写
            • %G %f 和 %E 的简写
            • %p 用十六进制数格式化变量的地址
          • 格式化操作符辅助指令:
            • 符号 功能
            • * 定义宽度或者小数点精度
            • - 用做左对齐
            • + 在正数前面显示加号( + )
            • <sp> 在正数前面显示空格
            • # 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
            • 0 显示的数字前面填充'0'而不是默认的空格
            • % '%%'输出一个单一的'%'
            • (var) 映射变量(字典参数)
            • m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
        • 3. 格式化输出16进制，十进制，八进制整数
          • #%x --- hex 十六进制
          • #%d --- dec 十进制
          • #%o --- oct 八进制
          • >>>nHex = 0xFF >>> print("nHex = %x,nDec = %d,nOct = %o" %(nHex,nHex,nHex)) nHex = ff,nDec = 255,nOct = 377
        • 4.格式化输出浮点数(float)
          • >>>pi = 3.141592653 >>> print('%10.3f' % pi) #字段宽10，精度3 3.142 >>> print("pi = %.*f" % (3,pi)) #用*从后面的元组中读取字段宽度或精度 pi = 3.142 >>> print('%010.3f' % pi) #用0填充空白 000003.142 >>> print('%-10.3f' % pi) #左对齐 3.142 >>> print('%+f' % pi) #显示正负号 +3.141593
        • 5. 自动换行
          • print 会自动在行末加上回车, 如果不需回车，只需在 print 语句的结尾添加一个逗号 , 并设置分隔符参数 end，就可以改变它的行为。
          • >>>for i in range(0,6): ... print(i) ... 0 1 2 3 4 5 >>> for i in range(0,6): ... print(i, end=" ") ... 0 1 2 3 4 5
        • 6. print 不换行
          • 在 Python 中 print 默认是换行的:
            • >>>for i in range(0,3): ... print (i) ... 0 1 2 >>>
          • 要想不换行你应该写成 print(i, end = '' )
            • >>>for i in range(0,3): ... print(i, end = '' ) ... 012
    • super()
      • 描述
        • super() 函数是用于调用父类(超类)的一个方法。
        • super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
        • MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
      • 语法
        • 以下是 super() 方法的语法:
        • super(type[, object-or-type])
      • 参数
        • type -- 类。
        • object-or-type -- 类，一般是 self
      • Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
        • Python3.x 实例：
          • class A: def add(self, x): y = x+1 print(y) class B(A): def add(self, x): super().add(x) b = B() b.add(2) # 3
        • Python2.x 实例：
          • #!/usr/bin/python # -*- coding: UTF-8 -*- class A(object): # Python2.x 记得继承 object def add(self, x): y = x+1 print(y) class B(A): def add(self, x): super(B, self).add(x) b = B() b.add(2) # 3
      • 返回值
        • 无。
      • 实例
        • 以下展示了使用 super 函数的实例：
          • # -*- coding: UTF-8 -*- class FooParent(object): def __init__(self): self.parent = 'I\'m the parent.' print ('Parent') def bar(self,message): print ("%s from Parent" % message) class FooChild(FooParent): def __init__(self): # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象 super(FooChild,self).__init__() print ('Child') def bar(self,message): super(FooChild, self).bar(message) print ('Child bar fuction') print (self.parent) if __name__ == '__main__': fooChild = FooChild() fooChild.bar('HelloWorld')
            • Parent Child HelloWorld from Parent Child bar fuction I'm the parent.
    • bin()
      • 描述
        • bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
      • 语法
        • 以下是 bin() 方法的语法:
          • bin(x)
      • 参数
        • x -- int 或者 long int 数字
      • 返回值
        • 字符串。
      • 实例
        • 以下展示了使用 bin 函数的实例：
          • >>>bin(10) '0b1010' >>> bin(20) '0b10100'
    • file()
      • 描述
        • file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。
        • 更多文件操作可参考：Python 文件I/O。
      • 语法
        • 以下是 file() 方法的语法:
          • file(name[, mode[, buffering]])
      • 参数
        • name -- 文件名
        • mode -- 打开模式
        • buffering -- 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。
      • 返回值
        • 文件对象。
      • 实例
        • 测试文件 test.txt，内容如下：
          • RUNOOB1 RUNOOB2
            • >>>f = file('test.txt') >>> f.read() 'RUNOOB1\nRUNOOB2\n'
    • iter()
      • 描述
        • iter() 函数用来生成迭代器。
      • 语法
        • 以下是 iter() 方法的语法:
          • iter(object[, sentinel])
      • 参数
        • object -- 支持迭代的集合对象。
        • sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
        • 打开模式
      • 返回值
        • 迭代器对象。
      • 实例
        • >>>lst = [1, 2, 3] >>> for i in iter(lst): ... print(i) ... 1 2 3
    • property()
      • 描述
        • property() 函数的作用是在新式类中返回属性值。
      • 语法
        • 以下是 property() 方法的语法:
          • class property([fget[, fset[, fdel[, doc]]]])
      • 参数
        • fget -- 获取属性值的函数
        • fset -- 设置属性值的函数
        • fdel -- 删除属性值函数
        • doc -- 属性描述信息
      • 返回值
        • 返回新式类属性。
      • 实例
        • 定义一个可控属性值 x
          • class C(object): def __init__(self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.")
      • 如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
      • 如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
      • 将 property 函数用作装饰器可以很方便的创建只读属性：
        • class Parrot(object): def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage
      • 上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
      • property 的 getter,setter 和 deleter 方法同样可以用作装饰器：
        • class C(object): def __init__(self): self._x = None @property def x(self): """I'm the 'x' property.""" return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x
      • 这个代码和第一个例子完全相同，但要注意这些额外函数的名字和 property 下的一样，例如这里的 x。
    • tuple()
      • 描述
        • Python 元组 tuple() 函数将列表转换为元组。
      • 语法
        • tuple()方法语法：
        • tuple( iterable )
      • 参数
        • iterable -- 要转换为元组的可迭代序列。
      • 返回值
        • 返回元组。
      • 实例
        • 以下实例展示了 tuple()函数的使用方法：
          • 实例 1
            • >>>tuple([1,2,3,4]) (1, 2, 3, 4) >>> tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple (1, 3) >>> tuple((1,2,3,4)) #元组会返回元组自身 (1, 2, 3, 4)
          • 实例 2
            • aList = [123, 'xyz', 'zara', 'abc']; aTuple = tuple(aList) print "Tuple elements : ", aTuple
          • 以上实例输出结果为：
            • Tuple elements : (123, 'xyz', 'zara', 'abc')
    • bool()
      • 描述
        • bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
        • bool 是 int 的子类。
      • 语法
        • 以下是 bool() 方法的语法:
          • class bool([x])
      • 参数
        • x -- 要进行转换的参数。
      • 返回值
        • 返回 True 或 False。
      • 实例
        • 以下展示了使用 bool 函数的实例：
          • >>>bool() False >>> bool(0) False >>> bool(1) True >>> bool(2) True >>> issubclass(bool, int) # bool 是 int 子类 True
    • filter()
      • 描述
        • filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
        • 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
        • 注意: Python2.7 返回列表，Python3.x 返回迭代器对象，具体内容可以查看：Python3 filter() 函数
      • 语法
        • 以下是 filter() 方法的语法:
        • filter(function, iterable)
      • 参数
        • function -- 判断函数。
        • iterable -- 可迭代对象。
      • 返回值
        • 返回列表。
      • 实例
        • 以下展示了使用 filter 函数的实例：
          • 过滤出列表中的所有奇数：
            • # -*- coding: UTF-8 -*- def is_odd(n): return n % 2 == 1 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print(newlist)
              • [1, 3, 5, 7, 9]
          • 过滤出1~100中平方根是整数的数：
            • # -*- coding: UTF-8 -*- import math def is_sqr(x): return math.sqrt(x) % 1 == 0 newlist = filter(is_sqr, range(1, 101)) print(newlist)
              • [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    • len()
      • 描述
        • Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
      • 语法
        • len()方法语法：
          • len( s )
      • 参数
        • s -- 对象。
      • 返回值
        • 返回对象长度。
      • 实例
        • 以下实例展示了 len() 的使用方法：
          • # coding=utf-8 str = "runoob" print( len(str) ) # 字符串长度 l = [1,2,3,4,5] print( len(l) ) # 列表元素个数
            • 6 5
    • range()
      • python2.x range() 函数可创建一个整数列表，一般用在 for 循环中。
      • 注意：Python3 range() 返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表，具体可查阅 Python3 range() 用法说明。
      • 函数语法
        • range(start, stop[, step])
      • 参数说明：
        • start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
        • stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
        • step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
      • 实例
        • >>>range(10) # 从 0 开始到 9 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(1, 11) # 从 1 开始到 10 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> range(0, 30, 5) # 步长为 5 [0, 5, 10, 15, 20, 25] >>> range(0, 10, 3) # 步长为 3 [0, 3, 6, 9] >>> range(0, -10, -1) # 负数 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> range(0) [] >>> range(1, 0) []
        • 以下是 range 在 for 中的使用，循环出runoob 的每个字母:
          • >>>x = 'runoob' >>> for i in range(len(x)) : ... print(x[i]) ... r u n o o b >>>
    • type()
      • 描述
        • type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
        • isinstance() 与 type() 区别：
          • type() 不会认为子类是一种父类类型，不考虑继承关系。
          • isinstance() 会认为子类是一种父类类型，考虑继承关系。
        • 如果要判断两个类型是否相同推荐使用 isinstance()。
      • 语法
      • 以下是 type() 方法的语法:
        • type(object) type(name, bases, dict)
      • 参数
        • name -- 类的名称。
        • bases -- 基类的元组。
        • dict -- 字典，类内定义的命名空间变量。
      • 返回值
        • 一个参数返回对象类型, 三个参数，返回新的类型对象。
      • 实例
        • 以下展示了使用 type 函数的实例：
          • # 一个参数实例 >>> type(1) <type 'int'> >>> type('runoob') <type 'str'> >>> type([2]) <type 'list'> >>> type({0:'zero'}) <type 'dict'> >>> x = 1 >>> type( x ) == int # 判断类型是否相等 True # 三个参数 >>> class X(object): ... a = 1 ... >>> X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X >>> X <class '__main__.X'>
      • type() 与 isinstance()区别：
        • 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
    • bytearray()
      • 描述
        • bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
      • 语法
        • bytearray()方法语法：
          • class bytearray([source[, encoding[, errors]]])
      • 参数
        • 如果 source 为整数，则返回一个长度为 source 的初始化数组；
        • 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
        • 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
        • 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
        • 如果没有输入任何参数，默认就是初始化数组为0个元素。
      • 返回值
        • 返回新字节数组。
      • 实例
        • 以下实例展示了 bytearray() 的使用方法：
          • >>>bytearray() bytearray(b'') >>> bytearray([1,2,3]) bytearray(b'\x01\x02\x03') >>> bytearray('runoob', 'utf-8') bytearray(b'runoob') >>>
    • float()
      • 描述
        • float() 函数用于将整数和字符串转换成浮点数。
      • 语法
        • float()方法语法：
          • class float([x])
      • 参数
        • x -- 整数或字符串
      • 返回值
        • 返回浮点数。
      • 实例
        • 以下实例展示了 float() 的使用方法：
          • >>>float(1) 1.0 >>> float(112) 112.0 >>> float(-123.6) -123.6 >>> float('123') # 字符串 123.0
    • list()
      • 描述
        • list() 方法用于将元组转换为列表。
        • 注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
      • 语法
        • list()方法语法：
          • list( tup )
      • 参数
        • tup -- 要转换为列表的元组。
      • 返回值
        • 返回列表。
      • 实例
        • 以下实例展示了 list() 函数的使用方法：
          • # -*- coding: UTF-8 -*- aTuple = (123, 'runoob', 'google', 'abc'); aList = list(aTuple) print ("列表元素 : ") print(aList)
            • 列表元素 : [123, 'runoob', 'google', 'abc']
    • raw_input()
      • python raw_input() 用来获取控制台的输入。
      • raw_input() 将所有输入作为字符串看待，返回字符串类型。
        • 注意：input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
        • 除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
        • 注意：python3 里 input() 默认接收到的是 str 类型。
      • 函数语法
        • raw_input([prompt])
      • 参数说明：
        • prompt: 可选，字符串，可作为一个提示语。
      • 实例
        • raw_input() 将所有输入作为字符串看待
          • >>>a = raw_input("input:") input:123 >>> type(a) <type 'str'> # 字符串 >>> a = raw_input("input:") input:runoob >>> type(a) <type 'str'> # 字符串 >>>
        • input() 需要输入 python 表达式
          • >>>a = input("input:") input:123 # 输入整数 >>> type(a) <type 'int'> # 整型 >>> a = input("input:") input:"runoob" # 正确，字符串表达式 >>> type(a) <type 'str'> # 字符串 >>> a = input("input:") input:runoob # 报错，不是表达式 Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<string>", line 1, in <module> NameError: name 'runoob' is not defined <type 'str'>
    • unichr()
      • 描述
        • unichr() 函数 和 chr() 函数功能基本一样， 只不过是返回 unicode 的字符。
        • 注意： Python3 不支持 unichr()，改用 chr() 函数。
      • 语法
        • 以下是 unichr() 方法的语法:
          • unichr(i)
      • 参数
        • i -- 可以是10进制也可以是16进制的形式的数字。
      • 返回值
        • 返回 unicode 的字符。
      • 实例
        • 以下展示了使用 unichr() 方法的实例：
          • >>>unichr(97) u'a' >>> unichr(98) u'b' >>> unichr(99) u'c'
    • callable()
      • 描述
        • 对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
      • 语法
        • callable()方法语法：
          • callable(object)
      • 参数
        • object -- 对象
      • 返回值
        • 可调用返回 True，否则返回 False。
      • 实例
        • 以下实例展示了 callable() 的使用方法：
          • >>>callable(0) False >>> callable("runoob") False >>> def add(a, b): ... return a + b ... >>> callable(add) # 函数返回 True True >>> class A: # 类 ... def method(self): ... return 0 ... >>> callable(A) # 类返回 True True >>> a = A() >>> callable(a) # 没有实现 __call__, 返回 False False >>> class B: ... def __call__(self): ... return 0 ... >>> callable(B) True >>> b = B() >>> callable(b) # 实现 __call__, 返回 True True
          • callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
    • format()
      • Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
      • 基本语法是通过 {} 和 : 来代替以前的 % 。
      • format 函数可以接受不限个参数，位置可以不按顺序。
      • 实例
        • >>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 'hello world' >>> "{0} {1}".format("hello", "world") # 设置指定位置 'hello world' >>> "{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'
      • 也可以设置参数：
        • 实例
          • # -*- coding: UTF-8 -*- print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")) # 通过字典设置参数 site = {"name": "菜鸟教程", "url": "www.runoob.com"} print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数 my_list = ['菜鸟教程', 'www.runoob.com'] print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
            • 网站名：菜鸟教程, 地址 www.runoob.com 网站名：菜鸟教程, 地址 www.runoob.com 网站名：菜鸟教程, 地址 www.runoob.com
        • 也可以向 str.format() 传入对象：
          • 实例
            • # -*- coding: UTF-8 -*- class AssignValue(object): def __init__(self, value): self.value = value my_value = AssignValue(6) print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
              • value 为: 6
      • 数字格式化
        • 下表展示了 str.format() 格式化数字的多种方法：
          • >>> print("{:.2f}".format(3.1415926)) 3.14
        • 数字 格式 输出 描述 3.1415926 {:.2f} 3.14 保留小数点后两位 3.1415926 {:+.2f} +3.14 带符号保留小数点后两位 -1 {:+.2f} -1.00 带符号保留小数点后两位 2.71828 {:.0f} 3 不带小数 5 {:0>2d} 05 数字补零 (填充左边, 宽度为2) 5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4) 10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4) 1000000 {:,} 1,000,000 以逗号分隔的数字格式 0.25 {:.2%} 25.00% 百分比格式 1000000000 {:.2e} 1.00e+09 指数记法 13 {:>10d} 13 右对齐 (默认, 宽度为10) 13 {:<10d} 13 左对齐 (宽度为10) 13 {:^10d} 13 中间对齐 (宽度为10)
        • 11 '{:b}'.format(11) 1011 进制 '{:d}'.format(11) 11 '{:o}'.format(11) 13 '{:x}'.format(11) b '{:#x}'.format(11) 0xb '{:#X}'.format(11) 0XB
        • ^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
        • + 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
        • b、d、o、x 分别是二进制、十进制、八进制、十六进制。
        • 此外我们可以使用大括号 {} 来转义大括号，如下实例：
      • 实例
        • # -*- coding: UTF-8 -*- print ("{} 对应的位置是 {{0}}".format("runoob"))
          • runoob 对应的位置是 {0}
    • locals()
      • 描述
        • locals() 函数会以字典类型返回当前位置的全部局部变量。
        • 对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
      • 语法
        • locals() 函数语法：
          • locals()
      • 参数
        • 无
      • 返回值
        • 返回字典类型的局部变量。
      • 实例
        • 以下实例展示了 locals() 的使用方法：
          • >>>def runoob(arg): # 两个局部变量：arg、z ... z = 1 ... print (locals()) ... >>> runoob(4) {'z': 1, 'arg': 4} # 返回一个名字/值对的字典 >>>
    • reduce()
      • 描述
        • reduce() 函数会对参数序列中元素进行累积。
        • 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
          • 注意：Python3.x reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：
          • from functools import reduce
      • 语法
        • reduce() 函数语法：
          • reduce(function, iterable[, initializer])
      • 参数
        • function -- 函数，有两个参数
        • iterable -- 可迭代对象
        • initializer -- 可选，初始参数
      • 返回值
        • 返回函数计算结果。
      • 实例
        • 以下实例展示了 reduce() 的使用方法：
      • 实例(Python 2.x)
        • # -*- coding: UTF-8 -*- def add(x, y) : # 两数相加 return x + y sum1 = reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数 print(sum1) print(sum2)
      • 实例(Python 3.x)
        • from functools import reduce def add(x, y) : # 两数相加 return x + y sum1 = reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数 print(sum1) print(sum2)
          • 15 15
    • unicode()
    • chr()
      • 描述
        • chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
      • 语法
        • 以下是 chr() 方法的语法:
          • chr(i)
      • 参数
        • i -- 可以是10进制也可以是16进制的形式的数字。
      • 返回值
        • 返回值是当前整数对应的 ASCII 字符。
      • 实例
        • 以下展示了使用 chr() 方法的实例：
          • >>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制 0 1 a >>> print chr(48), chr(49), chr(97) # 十进制 0 1 a
    • frozenset()
      • 描述
        • frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
      • 语法
        • frozenset() 函数语法：
          • class frozenset([iterable])
      • 参数
        • iterable -- 可迭代的对象，比如列表、字典、元组等等。
      • 返回值
        • 返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
      • 实例
        • 以下实例展示了 frozenset() 的使用方法：
          • >>>a = frozenset(range(10)) # 生成一个新的不可变集合 >>> a frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> b = frozenset('runoob') >>> b frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合 >>>
    • long()
      • 描述
        • long() 函数将数字或字符串转换为一个长整型。
        • Python3.x 版本已删除 long() 函数。
      • 语法
        • long() 函数语法：
          • class long(x, base=10)
      • 参数
        • x -- 字符串或数字。
        • base -- 可选，进制数，默认十进制。
      • 返回值
        • 返回长整型数。
      • 实例
        • 以下实例展示了 long() 的使用方法：
          • >>>long() 0L >>> long(1) 1L >>> long('123') 123L
    • reload()
      • 描述
        • reload() 用于重新载入之前载入的模块。
      • 语法
        • reload() 函数语法：
          • reload(module)
      • 参数
        • module -- 模块对象。
      • 返回值
        • 返回模块对象。
      • 实例
        • 以下实例展示了 reload() 的使用方法：
          • 重新载入 sys 模块，并设置默认编码为 utf8
            • >>>import sys >>> sys.getdefaultencoding() # 当前默认编码 'ascii' >>> reload(sys) # 使用 reload <module 'sys' (built-in)> >>> sys.setdefaultencoding('utf8') # 设置编码 >>> sys.getdefaultencoding() 'utf8'
    • vars()
      • 描述
        • vars() 函数返回对象object的属性和属性值的字典对象。
      • 语法
        • vars() 函数语法：
          • vars([object])
      • 参数
        • object -- 对象
      • 返回值
        • 返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
      • 实例
        • 以下实例展示了 vars() 的使用方法：
          • >>>print(vars()) {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None} >>> class Runoob: ... a = 1 ... >>> print(vars(Runoob)) {'a': 1, '__module__': '__main__', '__doc__': None} >>> runoob = Runoob() >>> print(vars(runoob)) {}
    • classmethod()
      • 描述
        • classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
      • 语法
        • classmethod 语法：
          • classmethod
      • 参数
        • 无。
      • 返回值
        • 返回函数的类方法。
      • 实例
        • 以下实例展示了 classmethod 的使用方法：
          • # -*- coding: UTF-8 -*- class A(object): bar = 1 def func1(self): print ('foo') @classmethod def func2(cls): print ('func2') print (cls.bar) cls().func1() # 调用 foo 方法 A.func2() # 不需要实例化
            • func2 1 foo
    • getattr()
      • 描述
        • getattr() 函数用于返回一个对象属性值。
      • 语法
        • getattr 语法：
          • getattr(object, name[, default])
      • 参数
        • object -- 对象。
        • name -- 字符串，对象属性。
        • default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
      • 返回值
        • 返回对象属性值。
      • 实例
        • 以下实例展示了 getattr 的使用方法：
          • >>>class A(object): ... bar = 1 ... >>> a = A() >>> getattr(a, 'bar') # 获取属性 bar 值 1 >>> getattr(a, 'bar2') # 属性 bar2 不存在，触发异常 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'A' object has no attribute 'bar2' >>> getattr(a, 'bar2', 3) # 属性 bar2 不存在，但设置了默认值 3
    • map()
      • 描述
        • map() 会根据提供的函数对指定序列做映射。
        • 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
      • 语法
        • map() 函数语法：
          • map(function, iterable, ...)
      • 参数
        • function -- 函数
        • iterable -- 一个或多个序列
      • 返回值
        • Python 2.x 返回列表。
        • Python 3.x 返回迭代器。
      • 实例
        • 以下实例展示了 map() 的使用方法：
          • Python2.x 实例
            • >>> def square(x) : # 计算平方数 ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25] >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]
          • Python3.x 实例
            • >>> def square(x) : # 计算平方数 ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 <map object at 0x100d3d550> # 返回迭代器 >>> list(map(square, [1,2,3,4,5])) # 使用 list() 转换为列表 [1, 4, 9, 16, 25] >>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25]
    • repr()
      • 描述
        • repr() 函数将对象转化为供解释器读取的形式。
      • 语法
        • 以下是 repr() 方法的语法:
          • repr(object)
      • 参数
        • object -- 对象。
      • 返回值
        • 返回一个对象的 string 格式。
      • 实例
        • 以下展示了使用 repr() 方法的实例：
          • >>> s = 'RUNOOB' >>> repr(s) "'RUNOOB'" >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> repr(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}"
    • xrange()
      • 描述
        • xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。
      • 语法
        • xrange 语法：
          • xrange(stop)
          • xrange(start, stop[, step])
      • 参数说明：
        • start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0， 5)
        • stop: 计数到 stop 结束，但不包括 stop。例如：xrange(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
        • step：步长，默认为1。例如：xrange(0， 5) 等价于 xrange(0, 5, 1)
      • 返回值
        • 返回生成器。
      • 实例
        • 以下实例展示了 xrange 的使用方法：
          • >>>xrange(8) xrange(8) >>> list(xrange(8)) [0, 1, 2, 3, 4, 5, 6, 7] >>> range(8) # range 使用 [0, 1, 2, 3, 4, 5, 6, 7] >>> xrange(3, 5) xrange(3, 5) >>> list(xrange(3,5)) [3, 4] >>> range(3,5) # 使用 range [3, 4] >>> xrange(0,6,2) xrange(0, 6, 2) # 步长为 2 >>> list(xrange(0,6,2)) [0, 2, 4]
    • cmp()
      • 描述
        • cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
      • 语法
        • 以下是 cmp() 方法的语法:
          • cmp( x, y )
      • 参数
        • x -- 数值表达式。
        • y -- 数值表达式。
      • 返回值
        • 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
      • 实例
        • 以下展示了使用 cmp() 方法的实例：
          • print "cmp(80, 100) : ", cmp(80, 100) print "cmp(180, 100) : ", cmp(180, 100) print "cmp(-80, 100) : ", cmp(-80, 100) print "cmp(80, -100) : ", cmp(80, -100)
            • cmp(80, 100) : -1 cmp(180, 100) : 1 cmp(-80, 100) : -1 cmp(80, -100) : 1
    • globals()
      • 描述
        • globals() 函数会以字典类型返回当前位置的全部全局变量。
      • 语法
        • globals() 函数语法：
          • globals()
      • 参数
        • 无
      • 返回值
        • 返回全局变量的字典。
      • 实例
        • 以下实例展示了 globals() 的使用方法：
          • >>>a='runoob' >>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。 {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
    • max()
      • 描述
        • max() 方法返回给定参数的最大值，参数可以为序列。
      • 语法
        • 以下是 max() 方法的语法:
          • max( x, y, z, .... )
      • 参数
        • x -- 数值表达式。
        • y -- 数值表达式。
        • z -- 数值表达式。
      • 返回值
        • 返回给定参数的最大值。
      • 实例
        • 以下展示了使用 max() 方法的实例：
          • 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
    • reverse()
      • 描述
        • reverse() 函数用于反向列表中元素。
      • 语法
        • reverse()方法语法：
          • list.reverse()
      • 参数
        • NA。
      • 返回值
        • 该方法没有返回值，但是会对列表的元素进行反向排序。
      • 实例
        • 以下实例展示了 reverse()函数的使用方法：
          • aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.reverse() print "List : ", aList
            • List : ['xyz', 'abc', 'zara', 'xyz', 123]
    • zip()
      • 描述
        • zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
          • 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
          • zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。
          • 如果需要了解 Python3 的应用，可以参考 Python3 zip()。
      • 语法
        • zip 语法：
          • zip([iterable, ...])
      • 参数说明：
        • iterabl -- 一个或多个迭代器;
      • 返回值
        • 返回元组列表。
      • 实例
        • 以下实例展示了 zip 的使用方法：
          • >>>a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)] >>> zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)] >>> zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]
    • compile()
      • 描述
        • compile() 函数将一个字符串编译为字节代码。
      • 语法
        • 以下是 compile() 方法的语法:
          • compile(source, filename, mode[, flags[, dont_inherit]])
      • 参数
        • source -- 字符串或者AST（Abstract Syntax Trees）对象。。
        • filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
        • mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
        • flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
        • flags和dont_inherit是用来控制编译源码时的标志
      • 返回值
        • 返回表达式执行结果。
      • 实例
        • 以下展示了使用 compile 函数的实例：
          • >>>str = "for i in range(0,10): print(i)" >>> c = compile(str,'','exec') # 编译为字节代码对象 >>> c <code object <module> at 0x10141e0b0, file "", line 1> >>> exec(c) 0 1 2 3 4 5 6 7 8 9 >>> str = "3 * 4 + 5" >>> a = compile(str,'','eval') >>> eval(a) 17
    • hasattr()
      • 描述
        • hasattr() 函数用于判断对象是否包含对应的属性。
      • 语法
        • hasattr 语法：
          • hasattr(object, name)
      • 参数
        • object -- 对象。
        • name -- 字符串，属性名。
      • 返回值
        • 如果对象有该属性返回 True，否则返回 False。
      • 实例
        • 以下实例展示了 hasattr 的使用方法：
          • # -*- coding: UTF-8 -*- class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print(hasattr(point1, 'x')) print(hasattr(point1, 'y')) print(hasattr(point1, 'z')) print(hasattr(point1, 'no')) # 没有该属性
            • True True True False
    • memoryview()
      • 描述
        • memoryview() 函数返回给定参数的内存查看对象(memory view)。
        • 所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
      • 语法
        • memoryview 语法：
          • memoryview(obj)
      • 参数说明：
        • obj -- 对象
      • 返回值
        • 返回元组列表。
      • 实例
        • 以下实例展示了 memoryview 的使用方法：
          • Python2.x 应用：
            • >>>v = memoryview('abcefg') >>> v[1] 'b' >>> v[-1] 'g' >>> v[1:4] <memory at 0x77ab28> >>> v[1:4].tobytes() 'bce'
          • Python3.x 应用：
            • >>>v = memoryview(bytearray("abcefg", 'utf-8')) >>> print(v[1]) 98 >>> print(v[-1]) 103 >>> print(v[1:4]) <memory at 0x10f543a08> >>> print(v[1:4].tobytes()) b'bce' >>>
    • round()
      • 描述
        • round() 方法返回浮点数x的四舍五入值。
      • 语法
        • 以下是 round() 方法的语法:
          • round( x [, n] )
      • 参数
        • x -- 数值表达式。
        • n -- 数值表达式，表示从小数点位数。
      • 返回值
        • 返回浮点数x的四舍五入值。
      • 实例
        • 以下展示了使用 round() 方法的实例：
          • print "round(80.23456, 2) : ", round(80.23456, 2) print "round(100.000056, 3) : ", round(100.000056, 3) print "round(-100.000056, 3) : ", round(-100.000056, 3)
            • round(80.23456, 2) : 80.23 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0
    • __import__()
      • 描述
        • __import__() 函数用于动态加载类和函数 。
        • 如果一个模块经常变化就可以使用 __import__() 来动态载入。
      • 语法
        • __import__ 语法：
          • __import__(name[, globals[, locals[, fromlist[, level]]]])
      • 参数说明：
        • name -- 模块名
      • 返回值
        • 返回元组列表。
      • 实例
        • 以下实例展示了 __import__ 的使用方法：
          • a.py 文件代码：
            • #encoding: utf-8 import os print ('在 a.py 文件中 %s' % id(os))
          • test.py 文件代码
            • #encoding: utf-8 import sys __import__('a') # 导入 a.py 模块
              • 在 a.py 文件中 4394716136
    • complex()
      • 描述
        • complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
      • 语法
        • complex 语法：
          • class complex([real[, imag]])
      • 参数说明：
        • real -- int, long, float或字符串；
        • imag -- int, long, float；
      • 返回值
        • 返回一个复数。
      • 实例
        • 以下实例展示了 complex 的使用方法：
          • >>>complex(1, 2) (1 + 2j) >>> complex(1) # 数字 (1 + 0j) >>> complex("1") # 当做字符串处理 (1 + 0j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 >>> complex("1+2j") (1 + 2j)
    • hash()
      • 描述
        • hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
      • 语法
        • hash 语法：
          • hash(object)
      • 参数说明：
        • object -- 对象；
      • 返回值
        • 返回对象的哈希值。
      • 实例
        • 以下实例展示了 hash 的使用方法：
          • >>>hash('test') # 字符串 2314058222102390712 >>> hash(1) # 数字 1 >>> hash(str([1,2,3])) # 集合 1335416675971793195 >>> hash(str(sorted({'1':1}))) # 字典 7666464346782421378
    • min()
      • 描述
        • min() 方法返回给定参数的最小值，参数可以为序列。
      • 语法
        • 以下是 min() 方法的语法:
          • min( x, y, z, .... )
      • 参数
        • x -- 数值表达式。
        • y -- 数值表达式。
        • z -- 数值表达式。
      • 返回值
        • 返回给定参数的最小值。
      • 实例
        • 以下展示了使用 min() 方法的实例：
          • 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
    • set()
      • 描述
        • set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
      • 语法
        • set 语法：
          • class set([iterable])
      • 参数说明：
        • iterable -- 可迭代对象对象；
      • 返回值
        • 返回新的集合对象。
      • 实例
        • 以下实例展示了 set 的使用方法：
          • >>>x = set('runoob') >>> y = set('google') >>> x, y (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除 >>> x & y # 交集 set(['o']) >>> x | y # 并集 set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u']) >>> x - y # 差集 set(['r', 'b', 'u', 'n'])
    • delattr()
      • 描述
        • delattr 函数用于删除属性。
          • delattr(x, 'foobar') 相等于 del x.foobar。
      • 语法
        • delattr 语法：
          • delattr(object, name)
      • 参数
        • object -- 对象。
        • name -- 必须是对象的属性。
      • 返回值
        • 无。
      • 实例
        • 以下实例展示了 delattr 的使用方法：
          • # -*- coding: UTF-8 -*- class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print('x = ',point1.x) print('y = ',point1.y) print('z = ',point1.z) delattr(Coordinate, 'z') print('--删除 z 属性后--') print('x = ',point1.x) print('y = ',point1.y) # 触发错误 print('z = ',point1.z)
            • ('x = ', 10) ('y = ', -5) ('z = ', 0) --删除 z 属性后-- ('x = ', 10) ('y = ', -5) Traceback (most recent call last): File "test.py", line 22, in <module> print('z = ',point1.z) AttributeError: Coordinate instance has no attribute 'z'
    • help()
      • 描述
        • help() 函数用于查看函数或模块用途的详细说明。
      • 语法
        • help 语法：
          • help([object])
      • 参数说明：
        • object -- 对象；
      • 返回值
        • 返回对象帮助信息。
      • 实例
        • 以下实例展示了 help 的使用方法：
          • >>>help('sys') # 查看 sys 模块的帮助 ……显示帮助信息…… >>>help('str') # 查看 str 数据类型的帮助 ……显示帮助信息…… >>>a = [1,2,3] >>>help(a) # 查看列表 list 帮助信息 ……显示帮助信息…… >>>help(a.append) # 显示list的append方法的帮助 ……显示帮助信息……
    • next()
      • 描述
        • next() 返回迭代器的下一个项目。
        • next() 函数要和生成迭代器的 iter() 函数一起使用。
      • 语法
        • next 语法：
          • next(iterable[, default])
      • 参数说明：
        • iterable -- 可迭代对象
        • default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
      • 返回值
        • 返回下一个项目。
      • 实例
        • 以下实例展示了 next 的使用方法：
          • # -*- coding: UTF-8 -*- # 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break
            • 1 2 3 4 5
    • setattr()
      • 描述
        • setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
      • 语法
        • setattr() 语法：
          • setattr(object, name, value)
      • 参数
        • object -- 对象。
        • name -- 字符串，对象属性。
        • value -- 属性值。
      • 返回值
        • 无。
      • 实例
        • 以下实例展示了 setattr() 函数的使用方法：
          • 对已存在的属性进行赋值：
            • >>>class A(object): ... bar = 1 ... >>> a = A() >>> getattr(a, 'bar') # 获取属性 bar 值 1 >>> setattr(a, 'bar', 5) # 设置属性 bar 值 >>> a.bar 5
          • 如果属性不存在会创建一个新的对象属性，并对属性赋值：
            • >>>class A(): ... name = "runoob" ... >>> a = A() >>> setattr(a, "age", 28) >>> print(a.age) 28 >>>
    • dict()
      • 描述
        • dict() 函数用于创建一个字典。
      • 语法
        • dict 语法：
          • class dict(**kwarg)
          • class dict(mapping, **kwarg)
          • class dict(iterable, **kwarg)
      • 参数说明：
        • **kwargs -- 关键字。
        • mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
        • iterable -- 可迭代对象。
      • 返回值
        • 返回一个字典。
      • 实例
        • 以下实例展示了 dict 的使用方法：
          • >>>dict() # 创建空字典 {} >>> dict(a='a', b='b', t='t') # 传入关键字 {'a': 'a', 'b': 'b', 't': 't'} >>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 {'three': 3, 'two': 2, 'one': 1}
      • 只使用关键字参数创建字典
        • 实例
          • numbers = dict(x=5, y=0) print('numbers =', numbers) print(type(numbers)) empty = dict() print('empty =', empty) print(type(empty))
            • numbers = {'y': 0, 'x': 5} <class 'dict'> empty = {} <class 'dict'>
      • 使用可迭代对象创建字典
        • numbers1 = dict([('x', 5), ('y', -5)]) print('numbers1 =',numbers1) # 设置关键字参数 numbers2 = dict([('x', 5), ('y', -5)], z=8) print('numbers2 =',numbers2) # zip() 创建可迭代对象 numbers3 = dict(dict(zip(['x', 'y', 'z'], [1, 2, 3]))) print('numbers3 =',numbers3)
          • numbers1 = {'y': -5, 'x': 5} numbers2 = {'z': 8, 'y': -5, 'x': 5} numbers3 = {'z': 3, 'y': 2, 'x': 1}
      • 使用映射来创建字典
        • 映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
        • 实例
          • numbers1 = dict({'x': 4, 'y': 5}) print('numbers1 =',numbers1) # 以下代码不需要使用 dict() numbers2 = {'x': 4, 'y': 5} print('numbers2 =',numbers2) # 关键字参数会被传递 numbers3 = dict({'x': 4, 'y': 5}, z=8) print('numbers3 =',numbers3)
            • numbers1 = {'x': 4, 'y': 5} numbers2 = {'x': 4, 'y': 5} numbers3 = {'x': 4, 'z': 8, 'y': 5}
    • hex()
      • 描述
        • hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
      • 语法
        • hex 语法：
          • hex(x)
      • 参数说明：
        • x -- 10进制整数
      • 返回值
        • 返回16进制数，以字符串形式表示。
      • 实例
        • 以下实例展示了 hex 的使用方法：
          • >>>hex(255) '0xff' >>> hex(-42) '-0x2a' >>> hex(1L) '0x1L' >>> hex(12) '0xc' >>> type(hex(12)) <class 'str'> # 字符串
    • object()
    • slice()
      • 描述
        • slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
      • 语法
        • slice 语法：
          • class slice(stop)
          • class slice(start, stop[, step])
      • 参数说明：
        • start -- 起始位置
        • stop -- 结束位置
        • step -- 间距
      • 返回值
        • 返回一个切片对象。
      • 实例
        • 以下实例展示了 slice 的使用方法：
          • >>>myslice = slice(5) # 设置截取5个元素的切片 >>> myslice slice(None, 5, None) >>> arr = range(10) >>> arr [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> arr[myslice] # 截取 5 个元素 [0, 1, 2, 3, 4]
    • dir()
      • 描述
        • dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
      • 语法
        • dir 语法：
          • dir([object])
      • 参数说明：
        • object -- 对象、变量、类型。
      • 返回值
        • 返回模块的属性列表。
      • 实例
        • 以下实例展示了 dir 的使用方法：
          • >>>dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice'] >>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    • id()
      • 描述
        • id() 函数返回对象的唯一标识符，标识符是一个整数。
        • CPython 中 id() 函数用于获取对象的内存地址。
      • 语法
        • id 语法：
          • id([object])
      • 参数说明：
        • object -- 对象。
      • 返回值
        • 返回对象的内存地址。
      • 实例
        • 以下实例展示了 id 的使用方法：
          • >>>a = 'runoob' >>> id(a) 4531887632 >>> b = 1 >>> id(b) 140588731085608
    • oct()
      • 描述
        • oct() 函数将一个整数转换成 8 进制字符串。
          • Python2.x 版本的 8 进制以 0 作为前缀表示。
          • Python3.x 版本的 8 进制以 0o 作为前缀表示。
      • 语法
        • oct 语法：
          • oct(x)
      • 参数说明：
        • x -- 整数。
      • 返回值
        • 返回 8 进制字符串。
      • 实例
        • 以下实例展示了 oct 的使用方法：
          • 实例(Python 2.0+)
            • >>> oct(10) '012' >>> oct(20) '024' >>> oct(15) '017'
          • 实例(Python 3.0+)
            • >>> oct(10) '0o12' >>> oct(20) '0o24' >>> oct(15) '0o17'
    • sorted()
      • 描述
        • sorted() 函数对所有可迭代的对象进行排序操作。
          • sort 与 sorted 区别：
            • sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
            • list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
      • 语法
        • sorted 语法：
          • sorted(iterable, cmp=None, key=None, reverse=False)
      • 参数说明：
        • iterable -- 可迭代对象。
        • cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
        • key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
        • reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
      • 返回值
        • 返回重新排序的列表。
      • 实例
        • 以下实例展示了 sorted 的使用方法：
          • >>>a = [5,7,6,3,4,1,2] >>> b = sorted(a) # 保留原列表 >>> a [5, 7, 6, 3, 4, 1, 2] >>> b [1, 2, 3, 4, 5, 6, 7] >>> L=[('b',2),('a',1),('c',3),('d',4)] >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] >>> sorted(L, key=lambda x:x[1]) # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)] >>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] >>> sorted(students, key=lambda s: s[2]) # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] >>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    • exec 内置表达式
      • 描述
        • exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。
        • 需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。
      • 语法
        • 以下是 exec 的语法:
          • exec obj
      • 参数
        • obj -- 要执行的表达式。
      • 返回值
        • exec 返回值永远为 None。
      • 实例
        • 以下展示了使用 exec 的实例：
          • 实例 1
            • >>>exec 'print "Hello World"' Hello World # 单行语句字符串 >>> exec "print 'runoob.com'" runoob.com # 多行语句字符串 >>> exec """for i in range(5): ... print "iter time: %d" % i ... """ iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4
          • 实例 2
            • x = 10 expr = """ z = 30 sum = x + y + z print(sum) """ def func(): y = 20 exec(expr) exec(expr, {'x': 1, 'y': 2}) exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4}) func()
              • 60 33 34
  • Python MongoDB
    • MongoDB 是目前最流行的 NoSQL 数据库之一，使用的数据类型 BSON（类似 JSON）。
    • MongoDB 数据库安装与介绍可以查看我们的 MongoDB 教程。
    • PyMongo
      • Python 要连接 MongoDB 需要 MongoDB 驱动，这里我们使用 PyMongo 驱动来连接。
    • pip 安装
      • pip 是一个通用的 Python 包管理工具，提供了对 Python 包的查找、下载、安装、卸载的功能。
      • 安装 pymongo:
        • $ python3 -m pip3 install pymongo
      • 也可以指定安装的版本:
        • $ python3 -m pip3 install pymongo==3.5.1
    • 更新 pymongo 命令：
      • $ python3 -m pip3 install --upgrade pymongo
    • easy_install 安装
      • 旧版的 Python 可以使用 easy_install 来安装，easy_install 也是 Python 包管理工具。
      • $ python -m easy_install pymongo
    • 更新 pymongo 命令：
      • $ python -m easy_install -U pymongo
    • 测试 PyMongo
      • 接下来我们可以创建一个测试文件 demo_test_mongodb.py，代码如下：
        • demo_test_mongodb.py 文件代码：
          • import pymongo
    • 执行以上代码文件，如果没有出现错误，表示安装成功。
    • 创建数据库
      • 创建一个数据库
        • 创建数据库需要使用 MongoClient 对象，并且指定连接的 URL 地址和要创建的数据库名。
        • 如下实例中，我们创建的数据库 runoobdb :
          • 实例
            • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"]
          • 注意: 在 MongoDB 中，数据库只有在内容插入后才会创建! 就是说，数据库创建后要创建集合(数据表)并插入一个文档(记录)，数据库才会真正创建。
      • 判断数据库是否已存在
        • 我们可以读取 MongoDB 中的所有数据库，并判断指定的数据库是否存在：
          • 实例
            • import pymongo myclient = pymongo.MongoClient('mongodb://localhost:27017/') dblist = myclient.list_database_names() # dblist = myclient.database_names() if "runoobdb" in dblist: print("数据库已存在！")
          • 注意：database_names 在最新版本的 Python 中已废弃，Python3.7+ 之后的版本改为了 list_database_names()。
    • 创建集合
      • MongoDB 中的集合类似 SQL 的表。
    • 创建一个集合
      • MongoDB 使用数据库对象来创建集合，实例如下：
        • 实例
          • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"]
        • 注意: 在 MongoDB 中，集合只有在内容插入后才会创建! 就是说，创建集合(数据表)后要再插入一个文档(记录)，集合才会真正创建。
    • 判断集合是否已存在
      • 我们可以读取 MongoDB 数据库中的所有集合，并判断指定的集合是否存在：
        • 实例
          • import pymongo myclient = pymongo.MongoClient('mongodb://localhost:27017/') mydb = myclient['runoobdb'] collist = mydb. list_collection_names() # collist = mydb.collection_names() if "sites" in collist: # 判断 sites 集合是否存在 print("集合已存在！")
        • 注意：collection_names 在最新版本的 Python 中已废弃，Python3.7+ 之后的版本改为了 list_collection_names()。
    • 增、删、改、查等操作
      • 下表列出了 MongoDB 的更多操作，详情可点击具体链接：
        • 添加数据
          • MongoDB 中的一个文档类似 SQL 表中的一条记录。
          • 插入集合
            • 集合中插入文档使用 insert_one() 方法，该方法的第一参数是字典 name => value 对。
            • 以下实例向 sites 集合中插入文档：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] mydict = { "name": "RUNOOB", "alexa": "10000", "url": "https://www.runoob.com" } x = mycol.insert_one(mydict) print(x) print(x)
                  • <pymongo.results.InsertOneResult object at 0x10a34b288>
          • 返回 _id 字段
            • insert_one() 方法返回 InsertOneResult 对象，该对象包含 inserted_id 属性，它是插入文档的 id 值。
              • 实例
                • mport pymongo myclient = pymongo.MongoClient('mongodb://localhost:27017/') mydb = myclient['runoobdb'] mycol = mydb["sites"] mydict = { "name": "Google", "alexa": "1", "url": "https://www.google.com" } x = mycol.insert_one(mydict) print(x.inserted_id)
                  • 5b2369cac315325f3698a1cf
            • 如果我们在插入文档时没有指定 _id，MongoDB 会为每个文档添加一个唯一的 id。
          • 插入多个文档
            • 集合中插入多个文档使用 insert_many() 方法，该方法的第一参数是字典列表。
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] mylist = [ { "name": "Taobao", "alexa": "100", "url": "https://www.taobao.com" }, { "name": "QQ", "alexa": "101", "url": "https://www.qq.com" }, { "name": "Facebook", "alexa": "10", "url": "https://www.facebook.com" }, { "name": "知乎", "alexa": "103", "url": "https://www.zhihu.com" }, { "name": "Github", "alexa": "109", "url": "https://www.github.com" } ] x = mycol.insert_many(mylist) # 输出插入的所有文档对应的 _id 值 print(x.inserted_ids)
                  • [ObjectId('5b236aa9c315325f5236bbb6'), ObjectId('5b236aa9c315325f5236bbb7'), ObjectId('5b236aa9c315325f5236bbb8'), ObjectId('5b236aa9c315325f5236bbb9'), ObjectId('5b236aa9c315325f5236bbba')]
            • insert_many() 方法返回 InsertManyResult 对象，该对象包含 inserted_ids 属性，该属性保存着所有插入文档的 id 值。
            • 执行完以上查找，我们可以在命令终端，查看数据是否已插入:
          • 插入指定 _id 的多个文档
            • 我们也可以自己指定 id，插入，以下实例我们在 site2 集合中插入数据，_id 为我们指定的：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["site2"] mylist = [ { "_id": 1, "name": "RUNOOB", "cn_name": "菜鸟教程"}, { "_id": 2, "name": "Google", "address": "Google 搜索"}, { "_id": 3, "name": "Facebook", "address": "脸书"}, { "_id": 4, "name": "Taobao", "address": "淘宝"}, { "_id": 5, "name": "Zhihu", "address": "知乎"} ] x = mycol.insert_many(mylist) # 输出插入的所有文档对应的 _id 值 print(x.inserted_ids)
                  • [1, 2, 3, 4, 5]
            • 执行完以上查找，我们可以在命令终端，查看数据是否已插入:
        • 查询数据
          • MongoDB 中使用了 find 和 find_one 方法来查询集合中的数据，它类似于 SQL 中的 SELECT 语句。
          • 本文使用的测试数据如下：
          • 查询一条数据
            • 我们可以使用 find_one() 方法来查询集合中的一条数据。
            • 查询 sites 文档中的第一条数据：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] x = mycol.find_one() print(x)
                  • {'_id': ObjectId('5b23696ac315325f269f28d1'), 'name': 'RUNOOB', 'alexa': '10000', 'url': 'https://www.runoob.com'}
          • 查询集合中所有数据
            • find() 方法可以查询集合中的所有数据，类似 SQL 中的 SELECT * 操作。
            • 以下实例查找 sites 集合中的所有数据：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] for x in mycol.find(): print(x)
                  • {'_id': ObjectId('5b23696ac315325f269f28d1'), 'name': 'RUNOOB', 'alexa': '10000', 'url': 'https://www.runoob.com'} {'_id': ObjectId('5b2369cac315325f3698a1cf'), 'name': 'Google', 'alexa': '1', 'url': 'https://www.google.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb6'), 'name': 'Taobao', 'alexa': '100', 'url': 'https://www.taobao.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb7'), 'name': 'QQ', 'alexa': '101', 'url': 'https://www.qq.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb8'), 'name': 'Facebook', 'alexa': '10', 'url': 'https://www.facebook.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb9'), 'name': '知乎', 'alexa': '103', 'url': 'https://www.zhihu.com'} {'_id': ObjectId('5b236aa9c315325f5236bbba'), 'name': 'Github', 'alexa': '109', 'url': 'https://www.github.com'}
          • 查询指定字段的数据
            • 我们可以使用 find() 方法来查询指定字段的数据，将要返回的字段对应值设置为 1。
            • 实例
              • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] for x in mycol.find({},{ "_id": 0, "name": 1, "alexa": 1 }): print(x)
                • {'name': 'RUNOOB', 'alexa': '10000'} {'name': 'Google', 'alexa': '1'} {'name': 'Taobao', 'alexa': '100'} {'name': 'QQ', 'alexa': '101'} {'name': 'Facebook', 'alexa': '10'} {'name': '知乎', 'alexa': '103'} {'name': 'Github', 'alexa': '109'}
            • 除了 _id 你不能在一个对象中同时指定 0 和 1，如果你设置了一个字段为 0，则其他都为 1，反之亦然。
            • 以下实例除了 alexa 字段外，其他都返回：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] for x in mycol.find({},{ "alexa": 0 }): print(x)
                  • {'_id': ObjectId('5b23696ac315325f269f28d1'), 'name': 'RUNOOB', 'url': 'https://www.runoob.com'} {'_id': ObjectId('5b2369cac315325f3698a1cf'), 'name': 'Google', 'url': 'https://www.google.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb6'), 'name': 'Taobao', 'url': 'https://www.taobao.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb7'), 'name': 'QQ', 'url': 'https://www.qq.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb8'), 'name': 'Facebook', 'url': 'https://www.facebook.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb9'), 'name': '知乎', 'url': 'https://www.zhihu.com'} {'_id': ObjectId('5b236aa9c315325f5236bbba'), 'name': 'Github', 'url': 'https://www.github.com'}
            • 以下代码同时指定了 0 和 1 则会报错：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] for x in mycol.find({},{ "name": 1, "alexa": 0 }): print(x)
                  • ... pymongo.errors.OperationFailure: Projection cannot have a mix of inclusion and exclusion. ...
          • 根据指定条件查询
            • 我们可以在 find() 中设置参数来过滤数据。
            • 以下实例查找 name 字段为 "RUNOOB" 的数据：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myquery = { "name": "RUNOOB" } mydoc = mycol.find(myquery) for x in mydoc: print(x)
                  • {'_id': ObjectId('5b23696ac315325f269f28d1'), 'name': 'RUNOOB', 'alexa': '10000', 'url': 'https://www.runoob.com'}
          • 高级查询
            • 查询的条件语句中，我们还可以使用修饰符。
            • 以下实例用于读取 name 字段中第一个字母 ASCII 值大于 "H" 的数据，大于的修饰符条件为 {"$gt": "H"} :
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myquery = { "name": { "$gt": "H" } } mydoc = mycol.find(myquery) for x in mydoc: print(x)
                  • {'_id': ObjectId('5b23696ac315325f269f28d1'), 'name': 'RUNOOB', 'alexa': '10000', 'url': 'https://www.runoob.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb6'), 'name': 'Taobao', 'alexa': '100', 'url': 'https://www.taobao.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb7'), 'name': 'QQ', 'alexa': '101', 'url': 'https://www.qq.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb9'), 'name': '知乎', 'alexa': '103', 'url': 'https://www.zhihu.com'}
          • 使用正则表达式查询
            • 我们还可以使用正则表达式作为修饰符。
            • 正则表达式修饰符只用于搜索字符串的字段。
            • 以下实例用于读取 name 字段中第一个字母为 "R" 的数据，正则表达式修饰符条件为 {"$regex": "^R"} :
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myquery = { "name": { "$regex": "^R" } } mydoc = mycol.find(myquery) for x in mydoc: print(x)
                  • {'_id': ObjectId('5b23696ac315325f269f28d1'), 'name': 'RUNOOB', 'alexa': '10000', 'url': 'https://www.runoob.com'}
          • 返回指定条数记录
            • 如果我们要对查询结果设置指定条数的记录可以使用 limit() 方法，该方法只接受一个数字参数。
            • 以下实例返回 3 条文档记录：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myresult = mycol.find().limit(3) # 输出结果 for x in myresult: print(x)
                  • {'_id': ObjectId('5b23696ac315325f269f28d1'), 'name': 'RUNOOB', 'alexa': '10000', 'url': 'https://www.runoob.com'} {'_id': ObjectId('5b2369cac315325f3698a1cf'), 'name': 'Google', 'alexa': '1', 'url': 'https://www.google.com'} {'_id': ObjectId('5b236aa9c315325f5236bbb6'), 'name': 'Taobao', 'alexa': '100', 'url': 'https://www.taobao.com'}
        • 修改数据
          • 我们可以在 MongoDB 中使用 update_one() 方法修改文档中的记录。该方法第一个参数为查询的条件，第二个参数为要修改的字段。
          • 如果查找到的匹配数据多于一条，则只会修改第一条。
          • 本文使用的测试数据如下(点击图片查看大图)：
          • 以下实例将 alexa 字段的值 10000 改为 12345:
            • 实例
              • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myquery = { "alexa": "10000" } newvalues = { "$set": { "alexa": "12345" } } mycol.update_one(myquery, newvalues) # 输出修改后的 "sites" 集合 for x in mycol.find(): print(x)
                • 执行输出结果为：
          • update_one() 方法只能修匹配到的第一条记录，如果要修改所有匹配到的记录，可以使用 update_many()。
          • 以下实例将查找所有以 F 开头的 name 字段，并将匹配到所有记录的 alexa 字段修改为 123：
            • 实例
              • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myquery = { "name": { "$regex": "^F" } } newvalues = { "$set": { "alexa": "123" } } x = mycol.update_many(myquery, newvalues) print(x.modified_count, "文档已修改")
                • 输出结果为：
                • 1 文档已修改
        • 数据排序
          • sort() 方法可以指定升序或降序排序。
          • sort() 方法第一个参数为要排序的字段，第二个字段指定排序规则，1 为升序，-1 为降序，默认为升序。
          • 本文使用的测试数据如下(点击图片查看大图)：
          • 对字段 alexa 按升序排序：
            • 实例
              • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] mydoc = mycol.find().sort("alexa") for x in mydoc: print(x)
                • 输出结果为：
          • 对字段 alexa 按降序排序：
            • 实例
              • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] mydoc = mycol.find().sort("alexa", -1) for x in mydoc: print(x)
                • 输出结果为：
        • 删除数据
          • 我们可以使用 delete_one() 方法来删除一个文档，该方法第一个参数为查询对象，指定要删除哪些数据。
          • 本文使用的测试数据如下(点击图片查看大图)：
          • 以下实例删除 name 字段值为 "Taobao" 的文档：
            • 实例
              • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myquery = { "name": "Taobao" } mycol.delete_one(myquery) # 删除后输出 for x in mycol.find(): print(x)
                • 输出结果为：
          • 删除多个文档
            • 我们可以使用 delete_many() 方法来删除多个文档，该方法第一个参数为查询对象，指定要删除哪些数据。
            • 删除所有 name 字段中以 F 开头的文档:
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] myquery = { "name": {"$regex": "^F"} } x = mycol.delete_many(myquery) print(x.deleted_count, "个文档已删除")
                  • 输出结果为：
                  • 1 个文档已删除
          • 删除集合中的所有文档
            • delete_many() 方法如果传入的是一个空的查询对象，则会删除集合中的所有文档：
            • 实例
              • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] x = mycol.delete_many({}) print(x.deleted_count, "个文档已删除")
                • 输出结果为：
                • 5 个文档已删除
          • 删除集合
            • 我们可以使用 drop() 方法来删除一个集合。
            • 以下实例删除了 customers 集合：
              • 实例
                • import pymongo myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["runoobdb"] mycol = mydb["sites"] mycol.drop()
              • 如果删除成功 drop() 返回 true，如果删除失败(集合不存在)则返回 false。
              • 我们使用以下命令在终端查看集合是否已删除：
                • > use runoobdb switched to db runoobdb > show tables;
  • Python urllib
    • Python urllib 库用于操作网页 URL，并对网页的内容进行抓取处理。
    • 本文主要介绍 Python3 的 urllib。
    • urllib 包 包含以下几个模块：
      • urllib.request - 打开和读取 URL。
      • urllib.error - 包含 urllib.request 抛出的异常。
      • urllib.parse - 解析 URL。
      • urllib.robotparser - 解析 robots.txt 文件。
    • urllib.request
      • urllib.request 定义了一些打开 URL 的函数和类，包含授权验证、重定向、浏览器 cookies等。
      • urllib.request 可以模拟浏览器的一个请求发起过程。
      • 我们可以使用 urllib.request 的 urlopen 方法来打开一个 URL，语法格式如下：
        • urllib.request.urlopen(url, data=None, [timeout, ]*, cafile=None, capath=None, cadefault=False, context=None)
        • url：url 地址。
        • data：发送到服务器的其他数据对象，默认为 None。
        • timeout：设置访问超时时间。
        • cafile 和 capath：cafile 为 CA 证书， capath 为 CA 证书的路径，使用 HTTPS 需要用到。
        • cadefault：已经被弃用。
        • context：ssl.SSLContext类型，用来指定 SSL 设置。
      • 实例如下：
        • 实例
          • from urllib.request import urlopen myURL = urlopen("https://www.runoob.com/") print(myURL.read())
      • 以上代码使用 urlopen 打开一个 URL，然后使用 read() 函数获取网页的 HTML 实体代码。
      • read() 是读取整个网页内容，我们可以指定读取的长度：
        • 实例
          • from urllib.request import urlopen myURL = urlopen("https://www.runoob.com/") print(myURL.read(300))
      • 除了 read() 函数外，还包含以下两个读取网页内容的函数：
        • readline() - 读取文件的一行内容
          • from urllib.request import urlopen myURL = urlopen("https://www.runoob.com/") print(myURL.readline()) #读取一行内容
        • readlines() - 读取文件的全部内容，它会把读取的内容赋值给一个列表变量。
          • from urllib.request import urlopen myURL = urlopen("https://www.runoob.com/") lines = myURL.readlines() for line in lines: print(line)
      • 我们在对网页进行抓取时，经常需要判断网页是否可以正常访问，这里我们就可以使用 getcode() 函数获取网页状态码，返回 200 说明网页正常，返回 404 说明网页不存在:
        • 实例
          • import urllib.request myURL1 = urllib.request.urlopen("https://www.runoob.com/") print(myURL1.getcode()) # 200 try: myURL2 = urllib.request.urlopen("https://www.runoob.com/no.html") except urllib.error.HTTPError as e: if e.code == 404: print(404) # 404
      • 更多网页状态码可以查阅：https://www.runoob.com/http/http-status-codes.html。
      • 如果要将抓取的网页保持到本地，可以使用 Python3 File write() 方法 函数：
        • 实例
          • from urllib.request import urlopen myURL = urlopen("https://www.runoob.com/") f = open("runoob_urllib_test.html", "wb") content = myURL.read() # 读取网页内容 f.write(content) f.close()
      • 执行以上代码，在本地就会生成一个 runoob_urllib_test.html 文件，里面包含了 https://www.runoob.com/ 网页的内容。
      • 更多Python File 处理，可以参阅：https://www.runoob.com/python3/python3-file-methods.html
      • URL 的编码与解码可以使用 urllib.request.quote() 与 urllib.request.unquote() 方法：
        • 实例
          • import urllib.request encode_url = urllib.request.quote("https://www.runoob.com/") # 编码 print(encode_url) unencode_url = urllib.request.unquote(encode_url) # 解码 print(unencode_url)
            • https%3A//www.runoob.com/ https://www.runoob.com/
    • 模拟头部信息
      • 我们抓取网页一般需要对 headers（网页头信息）进行模拟，这时候需要使用到 urllib.request.Request 类：
        • class urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
        • url：url 地址。
        • data：发送到服务器的其他数据对象，默认为 None。
        • headers：HTTP 请求的头部信息，字典格式。
        • origin_req_host：请求的主机地址，IP 或域名。
        • unverifiable：很少用整个参数，用于设置网页是否需要验证，默认是False。。
        • method：请求方法， 如 GET、POST、DELETE、PUT等。
      • 实例 - py3_urllib_test.php 文件代码
        • import urllib.request import urllib.parse url = 'https://www.runoob.com/?s=' # 菜鸟教程搜索页面 keyword = 'Python 教程' key_code = urllib.request.quote(keyword) # 对请求进行编码 url_all = url+key_code header = { 'User-Agent':'Mozilla/5.0 (X11; Fedora; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36' } #头部信息 request = urllib.request.Request(url_all,headers=header) reponse = urllib.request.urlopen(request).read() fh = open("./urllib_test_runoob_search.html","wb") # 将文件写入到当前目录中 fh.write(reponse) fh.close()
          • 打开 urllib_test_runoob_search.html 文件（可以使用浏览器打开），内容如下：
      • 表单 POST 传递数据，我们先创建一个表单，代码如下，我这里使用了 PHP 代码来获取表单的数据：
        • 实例
          • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com) urllib POST 测试</title> </head> <body> <form action="" method="post" name="myForm"> Name: <input type="text" name="name"><br> Tag: <input type="text" name="tag"><br> <input type="submit" value="提交"> </form> <hr> <?php // 使用 PHP 来获取表单提交的数据，你可以换成其他的 if(isset($_POST['name']) && $_POST['tag'] ) { echo $_POST["name"] . ', ' . $_POST['tag']; } ?> </body> </html>
        • 实例
          • import urllib.request import urllib.parse url = 'https://www.runoob.com/try/py3/py3_urllib_test.php' # 提交到表单页面 data = {'name':'RUNOOB', 'tag' : '菜鸟教程'} # 提交数据 header = { 'User-Agent':'Mozilla/5.0 (X11; Fedora; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36' } #头部信息 data = urllib.parse.urlencode(data).encode('utf8') # 对参数进行编码，解码使用 urllib.parse.urldecode request=urllib.request.Request(url, data, header) # 请求处理 reponse=urllib.request.urlopen(request).read() # 读取结果 fh = open("./urllib_test_post_runoob.html","wb") # 将文件写入到当前目录中 fh.write(reponse) fh.close()
        • 打开 urllib_test_post_runoob.html 文件（可以使用浏览器打开），显示结果如下：
    • urllib.error
      • urllib.error 模块为 urllib.request 所引发的异常定义了异常类，基础异常类是 URLError。
      • urllib.error 包含了两个方法，URLError 和 HTTPError。
      • URLError 是 OSError 的一个子类，用于处理程序在遇到问题时会引发此异常（或其派生的异常），包含的属性 reason 为引发异常的原因。
      • HTTPError 是 URLError 的一个子类，用于处理特殊 HTTP 错误例如作为认证请求的时候，包含的属性 code 为 HTTP 的状态码， reason 为引发异常的原因，headers 为导致 HTTPError 的特定 HTTP 请求的 HTTP 响应头。
      • 对不存在的网页抓取并处理异常:
        • 实例
          • import urllib.request import urllib.error myURL1 = urllib.request.urlopen("https://www.runoob.com/") print(myURL1.getcode()) # 200 try: myURL2 = urllib.request.urlopen("https://www.runoob.com/no.html") except urllib.error.HTTPError as e: if e.code == 404: print(404) # 404
    • urllib.parse
      • urllib.parse 用于解析 URL，格式如下：
      • urllib.parse.urlparse(urlstring, scheme='', allow_fragments=True)
      • urlstring 为 字符串的 url 地址，scheme 为协议类型，
      • allow_fragments 参数为 false，则无法识别片段标识符。相反，它们被解析为路径，参数或查询组件的一部分，并 fragment 在返回值中设置为空字符串。
        • 实例
          • from urllib.parse import urlparse o = urlparse("https://www.runoob.com/?s=python+%E6%95%99%E7%A8%8B") print(o)
            • 以上实例输出结果为：
            • ParseResult(scheme='https', netloc='www.runoob.com', path='/', params='', query='s=python+%E6%95%99%E7%A8%8B', fragment='')
          • 从结果可以看出，内容是一个元组，包含 6 个字符串：协议，位置，路径，参数，查询，判断。
      • 我们可以直接读取协议内容：
        • 实例
          • from urllib.parse import urlparse o = urlparse("https://www.runoob.com/?s=python+%E6%95%99%E7%A8%8B") print(o.scheme)
            • 以上实例输出结果为：
            • https
      • 完整内容如下：
        • 属性 索引 值 值（如果不存在） scheme 0 URL协议 scheme 参数 netloc 1 网络位置部分 空字符串 path 2 分层路径 空字符串 params 3 最后路径元素的参数 空字符串 query 4 查询组件 空字符串 fragment 5 片段识别 空字符串 username 用户名 None password 密码 None hostname 主机名（小写） None port 端口号为整数（如果存在） None
    • urllib.robotparser
      • urllib.robotparser 用于解析 robots.txt 文件。
      • robots.txt（统一小写）是一种存放于网站根目录下的 robots 协议，它通常用于告诉搜索引擎对网站的抓取规则。
      • urllib.robotparser 提供了 RobotFileParser 类，语法如下：
        • class urllib.robotparser.RobotFileParser(url='')
      • 这个类提供了一些可以读取、解析 robots.txt 文件的方法：
        • set_url(url) - 设置 robots.txt 文件的 URL。
        • read() - 读取 robots.txt URL 并将其输入解析器。
        • parse(lines) - 解析行参数。
        • can_fetch(useragent, url) - 如果允许 useragent 按照被解析 robots.txt 文件中的规则来获取 url 则返回 True。
        • mtime() -返回最近一次获取 robots.txt 文件的时间。 这适用于需要定期检查 robots.txt 文件更新情况的长时间运行的网页爬虫。
        • modified() - 将最近一次获取 robots.txt 文件的时间设置为当前时间。
        • crawl_delay(useragent) -为指定的 useragent 从 robots.txt 返回 Crawl-delay 形参。 如果此形参不存在或不适用于指定的 useragent 或者此形参的 robots.txt 条目存在语法错误，则返回 None。
        • request_rate(useragent) -以 named tuple RequestRate(requests, seconds) 的形式从 robots.txt 返回 Request-rate 形参的内容。 如果此形参不存在或不适用于指定的 useragent 或者此形参的 robots.txt 条目存在语法错误，则返回 None。
        • site_maps() - 以 list() 的形式从 robots.txt 返回 Sitemap 形参的内容。 如果此形参不存在或者此形参的 robots.txt 条目存在语法错误，则返回 None。
      • 实例
        • >>> import urllib.robotparser >>> rp = urllib.robotparser.RobotFileParser() >>> rp.set_url("http://www.musi-cal.com/robots.txt") >>> rp.read() >>> rrate = rp.request_rate("*") >>> rrate.requests 3 >>> rrate.seconds 20 >>> rp.crawl_delay("*") 6 >>> rp.can_fetch("*", "http://www.musi-cal.com/cgi-bin/search?city=San+Francisco") False >>> rp.can_fetch("*", "http://www.musi-cal.com/") True
  • Python uWSGI 安装配置
    • 本文主要介绍如何部署简单的 WSGI 应用和常见的 Web 框架。
    • 以 Ubuntu/Debian 为例，先安装依赖包：
      • apt-get install build-essential python-dev
    • Python 安装 uWSGI
      • 1、通过 pip 命令：
        • pip install uwsgi
      • 2、下载安装脚本：
        • curl http://uwsgi.it/install | bash -s default /tmp/uwsgi
        • 将 uWSGI 二进制安装到 /tmp/uwsgi ，你可以修改它。
      • 3、源代码安装：
        • wget http://projects.unbit.it/downloads/uwsgi-latest.tar.gz tar zxvf uwsgi-latest.tar.gz cd uwsgi-latest make
      • 安装完成后，在当前目录下，你会获得一个 uwsgi 二进制文件。
    • 第一个 WSGI 应用
      • 让我们从一个简单的 "Hello World" 开始，创建文件 foobar.py，代码如下：
        • def application(env, start_response): start_response('200 OK', [('Content-Type','text/html')]) return [b"Hello World"]
      • uWSGI Python 加载器将会搜索的默认函数 application 。
      • 接下来我们启动 uWSGI 来运行一个 HTTP 服务器，将程序部署在HTTP端口 9090 上：
        • uwsgi --http :9090 --wsgi-file foobar.py
    • 添加并发和监控
      • 默认情况下，uWSGI 启动一个单一的进程和一个单一的线程。
      • 你可以用 --processes 选项添加更多的进程，或者使用 --threads 选项添加更多的线程 ，也可以两者同时使用。
        • uwsgi --http :9090 --wsgi-file foobar.py --master --processes 4 --threads 2
      • 以上命令将会生成 4 个进程, 每个进程有 2 个线程。
      • 如果你要执行监控任务，可以使用 stats 子系统，监控的数据格式是 JSON：
        • uwsgi --http :9090 --wsgi-file foobar.py --master --processes 4 --threads 2 --stats 127.0.0.1:9191
      • 我们可以安装 uwsgitop（类似 Linux top 命令） 来查看监控数据：
        • pip install uwsgitop
    • 结合 Web 服务器使用
      • 我们可以将 uWSGI 和 Nginx Web 服务器结合使用，实现更高的并发性能。
      • 一个常用的nginx配置如下：
        • location / { include uwsgi_params; uwsgi_pass 127.0.0.1:3031; }
      • 以上代码表示使用 nginx 接收的 Web 请求传递给端口为 3031 的 uWSGI 服务来处理。
      • 现在，我们可以生成 uWSGI 来本地使用 uwsgi 协议：
        • uwsgi --socket 127.0.0.1:3031 --wsgi-file foobar.py --master --processes 4 --threads 2 --stats 127.0.0.1:9191
      • 如果你的 Web 服务器使用 HTTP，那么你必须告诉 uWSGI 本地使用 http 协议 (这与会自己生成一个代理的–http不同):
        • uwsgi --http-socket 127.0.0.1:3031 --wsgi-file foobar.py --master --processes 4 --threads 2 --stats 127.0.0.1:9191
    • 部署 Django
      • Django 是最常使用的 Python web 框架，假设 Django 项目位于 /home/foobar/myproject:
      • uwsgi --socket 127.0.0.1:3031 --chdir /home/foobar/myproject/ --wsgi-file myproject/wsgi.py --master --processes 4 --threads 2 --stats 127.0.0.1:9191
      • --chdir 用于指定项目路径。
      • 我们可以把以上的命令弄成一个 yourfile.ini 配置文件:
        • [uwsgi] socket = 127.0.0.1:3031 chdir = /home/foobar/myproject/ wsgi-file = myproject/wsgi.py processes = 4 threads = 2 stats = 127.0.0.1:9191
      • 接下来你只需要执行以下命令即可：
        • uwsgi yourfile.ini
    • 部署 Flask
      • Flask 是一个流行的 Python web 框架。
        • 创建文件 myflaskapp.py ，代码如下：
          • from flask import Flask app = Flask(__name__) @app.route('/') def index(): return "<span style='color:red'>I am app 1</span>"
    • 执行以下命令：
      • uwsgi --socket 127.0.0.1:3031 --wsgi-file myflaskapp.py --callable app --processes 4 --threads 2 --stats 127.0.0.1:9191
  • Python3 pip
    • pip 是 Python 包管理工具，该工具提供了对 Python 包的查找、下载、安装、卸载的功能。
    • 软件包也可以在 https://pypi.org/ 中找到。
    • 目前最新的 Python 版本已经预装了 pip。
      • 注意：Python 2.7.9 + 或 Python 3.4+ 以上版本都自带 pip 工具。
      • 如果没有安装可以参考：Python pip 安装与使用。
    • 查看是否已经安装 pip 可以使用以下命令：
      • pip --version
    • 下载安装包使用以下命令：
      • pip install some-package-name
    • 例如我们安装 numpy 包：
      • pip install numpy
    • 我们也可以轻易地通过以下的命令来移除软件包：
      • pip uninstall some-package-name
    • 例如我们移除 numpy 包：
      • pip uninstall numpy
    • 如果要查看我们已经安装的软件包，可以使用以下命令：
      • pip list
• Django 教程
  • 介绍
    • 基本介绍
      • Django 是一个由 Python 编写的一个开放源代码的 Web 应用框架。
      • 使用 Django，只要很少的代码，Python 的程序开发人员就可以轻松地完成一个正式网站所需要的大部分内容，并进一步开发出全功能的 Web 服务 Django 本身基于 MVC 模型，即 Model（模型）+ View（视图）+ Controller（控制器）设计模式，MVC 模式使后续对程序的修改和扩展简化，并且使程序某一部分的重复利用成为可能。
    • MVC 优势：
      • 低耦合
      • 开发快捷
      • 部署方便
      • 可重用性高
      • 维护成本低
      • ...
    • Python 加 Django 是快速开发、设计、部署网站的最佳组合。
    • 特点
      • 强大的数据库功能
      • 自带强大的后台功能
      • 优雅的网址
    • MVC 与 MTV模型
      • MVC 模型
        • MVC 模式（Model–view–controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。
      • MVC 以一种插件式的、松耦合的方式连接在一起。
        • 模型（M）- 编写程序应有的功能，负责业务对象与数据库的映射(ORM)。
        • 视图（V）- 图形界面，负责与用户的交互(页面)。
        • 控制器（C）- 负责转发请求，对请求进行处理。
      • 简易图：
      • 用户操作流程图：
    • MTV 模型
      • Django 的 MTV 模式本质上和 MVC 是一样的，也是为了各组件间保持松耦合关系，只是定义上有些许不同，Django 的 MTV 分别是指：
      • M 表示模型（Model）：编写程序应有的功能，负责业务对象与数据库的映射(ORM)。
      • T 表示模板 (Template)：负责如何把页面(html)展示给用户。
      • V 表示视图（View）：负责业务逻辑，并在适当时候调用 Model和 Template。
      • 除了以上三层之外，还需要一个 URL 分发器，它的作用是将一个个 URL 的页面请求分发给不同的 View 处理，View 再调用相应的 Model 和 Template，MTV 的响应模式如下所示：
      • 简易图：
      • 用户操作流程图：
    • 解析：
      • 用户通过浏览器向我们的服务器发起一个请求(request)，这个请求会去访问视图函数：
      • a.如果不涉及到数据调用，那么这个时候视图函数直接返回一个模板也就是一个网页给用户。
      • b.如果涉及到数据调用，那么视图函数调用模型，模型去数据库查找数据，然后逐级返回。
      • 视图函数把返回的数据填充到模板中空格中，最后返回网页给用户。
    • 参考地址：
      • [1]: https://www.cnblogs.com/liuhui0308/p/12189658.html
  • Django 安装
    • 在安装 Django 前，系统需要已经安装了Python的开发环境。接下来我们来具体看下不同系统下Django的安装。
    • Windows 下安装 Django
      • 如果你还未安装Python环境需要先下载Python安装包。
      • 1、Python 下载地址：https://www.python.org/downloads/
      • 2、Django 下载地址：https://www.djangoproject.com/download/
      • 注意：目前 Django 1.6.x 以上版本已经完全兼容 Python 3.x。
    • Python 安装(已安装的可跳过)
      • 安装 Python 你只需要下载 python-x.x.x.msi 文件，然后一直点击 "Next" 按钮即可。
    • 安装完成后你需要设置 Python 环境变量。 右击计算机->属性->高级->环境变量->修改系统变量 path，添加 Python 安装地址，本文实例使用的是 C:\Python33，你需要根据你实际情况来安装。
    • Django 安装
      • 下载 Django 压缩包，解压并和 Python安装目录放在同一个根目录，进入 Django 目录，执行 python setup.py install，然后开始安装，Django 将要被安装到 Python 的 Lib下site-packages。
      • 然后是配置环境变量，将这几个目录添加到系统环境变量中： C:\Python33\Lib\site-packages\django;C:\Python33\Scripts。 添加完成后就可以使用Django的django-admin.py命令新建工程了。
      • 检查是否安装成功
        • 输入以下命令进行检查:
          • >>> import django >>> django.get_version()
        • 如果输出了Django的版本号说明安装正确。
      • Linux 上安装 Django
        • yum 安装方法
          • 以下安装位于 Centos Linux 环境下安装，如果是你的 Linux 系统是 ubuntu 请使用 apt-get 命令。
          • 默认情况下 Linux 环境已经支持了Python。你可以在终端输入Python命令来查看是否已经安装。
          • Python 3.7.4 (default, Aug 1 2012, 05:14:39) [GCC 4.6.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>>
        • 安装 setuptools
          • 命令：
            • # Python3 安装 yum install python3-setuptools # Python2 安装 yum install python2-setuptools
          • 完成之后，就可以使用 easy_install 命令安装 django
            • easy_install django
          • 之后我们在 Python 解释器输入以下代码：
            • [root@solar django]# python Python 3.7.4 (default, May 15 2014, 14:49:08) [GCC 4.8.0] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import django >>> django.VERSION (3, 0, 6, 'final', 0)
          • 我们可以看到输出了Django的版本号，说明安装成功。
        • pip 命令安装方法
          • 如果你还未安装 pip 工具，可查看：Python pip 安装与使用。
            • sudo pip3 install Django -i https://pypi.tuna.tsinghua.edu.cn/simple
          • -i https://pypi.tuna.tsinghua.edu.cn/simple 指定清华镜像源，下载速度更快。
          • 指定 Django 的下载版本（3.0.6 可以改成你要的版本）：
            • sudo pip3 install Django==3.0.6 -i https://pypi.tuna.tsinghua.edu.cn/simple
          • 如果 pip < 1.4，安装方法如下：
            • pip install https://www.djangoproject.com/download/1.11a1/tarball/
        • 源码安装方法
          • 下载源码包：https://www.djangoproject.com/download/
          • 输入以下命令并安装：
            • tar xzvf Django-X.Y.tar.gz # 解压下载包 cd Django-X.Y # 进入 Django 目录 python setup.py install # 执行安装命令
          • 安装成功后 Django 位于 Python 安装目录的 site-packages 目录下。
        • Mac 下安装
          • 下载
          • 从这里下载最新的稳定版本：DJango-3.x.y.tar.gz，在页面右侧列表下载，如下图：
          • 记住是最新的官方版本哦。其中 x.y 是版本号。进入你下载该文件的文件夹目录，执行如下命令:（Mac下默认是/Users/xxx/Downloads，xxx是你的用户名）
            • $ tar zxvf Django-3.x.y.tar.gz
          • 你也可以从 Github 上下载最新版，地址：https://github.com/django/django：
            • git clone https://github.com/django/django.git
          • 安装
            • 进入解压后的目录：
              • cd Django-3.x.y sudo python setup.py install
            • 安装成功后会输出以下信息：
              • …… Processing dependencies for Django==3.x.y Finished processing dependencies for Django==3.x.y
            • 再进入我们的站点目录，创建 Django 项目：
              • $ django-admin.py startproject testdj
            • 启动服务：
              • cd testdj # 切换到我们创建的项目 $ python manage.py runserver …… Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.
            • 以上信息说明，项目已启动，访问地址为http://127.0.0.1:8000/。
      • Django 创建第一个项目
        • 本章我们将介绍Django 管理工具及如何使用 Django 来创建项目，第一个项目我们以 HelloWorld 来命令项目。
        • 测试版本说明：
          • Python 3.7.4
          • Django 3.0.6
        • Django 管理工具
          • 安装 Django 之后，您现在应该已经有了可用的管理工具 django-admin，Windows 如果没有配置环境变量可以用 django-admin。
          • 我们可以来看下django-admin 的命令介绍:
            • $ django-admin Type 'django-admin help <subcommand>' for help on a specific subcommand. Available subcommands: [django] check compilemessages createcachetable dbshell diffsettings dumpdata flush inspectdb loaddata makemessages makemigrations migrate runserver sendtestemail shell showmigrations sqlflush sqlmigrate sqlsequencereset squashmigrations startapp startproject test testserver ……省略部分……
        • 创建第一个项目
          • 使用 django-admin 来创建 HelloWorld 项目：
            • django-admin startproject HelloWorld
          • 创建完成后我们可以查看下项目的目录结构：
            • $ cd HelloWorld/ $ tree . |-- HelloWorld | |-- __init__.py | |-- asgi.py | |-- settings.py | |-- urls.py | `-- wsgi.py `-- manage.py
          • 目录说明：
            • HelloWorld: 项目的容器。
            • manage.py: 一个实用的命令行工具，可让你以各种方式与该 Django 项目进行交互。
            • HelloWorld/__init__.py: 一个空文件，告诉 Python 该目录是一个 Python 包。
            • HelloWorld/asgi.py: 一个 ASGI 兼容的 Web 服务器的入口，以便运行你的项目。
            • HelloWorld/settings.py: 该 Django 项目的设置/配置。
            • HelloWorld/urls.py: 该 Django 项目的 URL 声明; 一份由 Django 驱动的网站"目录"。
            • HelloWorld/wsgi.py: 一个 WSGI 兼容的 Web 服务器的入口，以便运行你的项目。
          • 接下来我们进入 HelloWorld 目录输入以下命令，启动服务器：
            • python3 manage.py runserver 0.0.0.0:8000
          • 0.0.0.0 让其它电脑可连接到开发服务器，8000 为端口号。如果不说明，那么端口号默认为 8000。
          • 在浏览器输入你服务器的 ip（这里我们输入本机 IP 地址： 127.0.0.1:8000） 及端口号，如果正常启动，输出结果如下：
        • 视图和 URL 配置
          • 在先前创建的 HelloWorld 目录下的 HelloWorld 目录新建一个 views.py 文件，并输入代码：
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.http import HttpResponse def hello(request): return HttpResponse("Hello world ! ")
          • 接着，绑定 URL 与视图函数。打开 urls.py 文件，删除原来代码，将以下代码复制粘贴到 urls.py 文件中：
          • HelloWorld/HelloWorld/urls.py 文件代码：
            • from django.conf.urls import url from . import views urlpatterns = [ url(r'^$', views.hello), ]
          • 整个目录结构如下：
            • $ tree . |-- HelloWorld | |-- __init__.py | |-- __init__.pyc | |-- settings.py | |-- settings.pyc | |-- urls.py # url 配置 | |-- urls.pyc | |-- views.py # 添加的视图文件 | |-- views.pyc # 编译后的视图文件 | |-- wsgi.py | `-- wsgi.pyc `-- manage.py
          • 完成后，启动 Django 开发服务器，并在浏览器访问打开浏览器并访问：
          • 我们也可以修改以下规则：
            • HelloWorld/HelloWorld/urls.py 文件代码：
              • from django.urls import path from . import views urlpatterns = [ path('hello/', views.hello), ]
          • 通过浏览器打开 http://127.0.0.1:8000/hello，输出结果如下：
            • 注意：项目中如果代码有改动，服务器会自动监测代码的改动并自动重新载入，所以如果你已经启动了服务器则不需手动重启。
          • path() 函数
            • Django path() 可以接收四个参数，分别是两个必选参数：route、view 和两个可选参数：kwargs、name。
            • 语法格式：
              • path(route, view, kwargs=None, name=None)
              • route: 字符串，表示 URL 规则，与之匹配的 URL 会执行对应的第二个参数 view。
              • view: 用于执行与正则表达式匹配的 URL 请求。
              • kwargs: 视图使用的字典类型的参数。
              • name: 用来反向获取 URL。
            • Django2. 0中可以使用 re_path() 方法来兼容 1.x 版本中的 url() 方法，一些正则表达式的规则也可以通过 re_path() 来实现 。
              • from django.urls import include, re_path urlpatterns = [ re_path(r'^index/$', views.index, name='index'), re_path(r'^bio/(?P<username>\w+)/$', views.bio, name='bio'), re_path(r'^weblog/', include('blog.urls')), ... ]
  • Django 模板
    • 在上一章节中我们使用 django.http.HttpResponse() 来输出 "Hello World！"。该方式将数据与视图混合在一起，不符合 Django 的 MVC 思想。
    • 本章节我们将为大家详细介绍 Django 模板的应用，模板是一个文本，用于分离文档的表现形式和内容。
    • 模板应用实例
      • 我们接着上一章节的项目将在 HelloWorld 目录底下创建 templates 目录并建立 runoob.html文件，整个目录结构如下：
        • HelloWorld/ |-- HelloWorld | |-- __init__.py | |-- __init__.pyc | |-- settings.py | |-- settings.pyc | |-- urls.py | |-- urls.pyc | |-- views.py | |-- views.pyc | |-- wsgi.py | `-- wsgi.pyc |-- manage.py `-- templates `-- runoob.html
      • runoob.html 文件代码如下：
        • HelloWorld/templates/runoob.html 文件代码：
          • <h1>{{ hello }}</h1>
      • 从模板中我们知道变量使用了双括号。
      • 接下来我们需要向Django说明模板文件的路径，修改HelloWorld/settings.py，修改 TEMPLATES 中的 DIRS 为 [os.path.join(BASE_DIR, 'templates')]，如下所示:
        • HelloWorld/HelloWorld/settings.py 文件代码：
          • ... TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], # 修改位置 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] ...
      • 我们现在修改 views.py，增加一个新的对象，用于向模板提交数据：
        • HelloWorld/HelloWorld/views.py 文件代码：
          • from django.shortcuts import render def runoob(request): context = {} context['hello'] = 'Hello World!' return render(request, 'runoob.html', context)
        • HelloWorld/HelloWorld/urls.py 文件代码：
          • from django.urls import path from . import views urlpatterns = [ path('runoob/', views.runoob), ]
      • 可以看到，我们这里使用 render 来替代之前使用的 HttpResponse。render 还使用了一个字典 context 作为参数。
      • context 字典中元素的键值 hello 对应了模板中的变量 {{ hello }}。
      • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
      • 这样我们就完成了使用模板来输出数据，从而实现数据与视图分离。
      • 接下来我们将具体介绍模板中常用的语法规则。
    • Django 模板标签
      • 变量
        • 模板语法：
          • view：｛"HTML变量名" : "views变量名"｝ HTML：｛｛变量名｝｝
        • HelloWorld/HelloWorld/views.py 文件代码：
          • from django.shortcuts import render def runoob(request): views_name = "菜鸟教程" return render(request,"runoob.html", {"name":views_name})
        • templates 中的 runoob.html ：
          • <p>{{ name }}</p>
        • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
      • 列表
        • templates 中的 runoob.html中，可以用 . 索引下标取出对应的元素。
        • HelloWorld/HelloWorld/views.py 文件代码：
          • from django.shortcuts import render def runoob(request): views_list = ["菜鸟教程1","菜鸟教程2","菜鸟教程3"] return render(request, "runoob.html", {"views_list": views_list})
        • HelloWorld/templates/runoob.html 文件代码：
          • <p>{{ views_list }}</p> # 取出整个列表 <p>{{ views_list.0 }}</p> # 取出列表的第一个元素
        • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
      • 字典
        • templates 中的 runoob.html中，可以用 .键 取出对应的值。
        • HelloWorld/HelloWorld/views.py 文件代码：
          • from django.shortcuts import render def runoob(request): views_dict = {"name":"菜鸟教程"} return render(request, "runoob.html", {"views_dict": views_dict})
        • HelloWorld/templates/runoob.html 文件代码：
          • <p>{{ views_dict }}</p> <p>{{ views_dict.name }}</p>
        • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
      • 过滤器
        • 模板语法：
          • {{ 变量名 | 过滤器：可选参数 }}
        • 模板过滤器可以在变量被显示前修改它，过滤器使用管道字符，如下所示：
          • {{ name|lower }}
        • {{ name }} 变量被过滤器 lower 处理后，文档大写转换文本为小写。
        • 过滤管道可以被* 套接* ，既是说，一个过滤器管道的输出又可以作为下一个管道的输入：
          • {{ my_list|first|upper }}
        • 以上实例将第一个元素并将其转化为大写。
        • 有些过滤器有参数。 过滤器的参数跟随冒号之后并且总是以双引号包含。 例如：
          • {{ bio|truncatewords:"30" }}
        • 这个将显示变量 bio 的前30个词。
        • 其他过滤器：
          • addslashes : 添加反斜杠到任何反斜杠、单引号或者双引号前面。
          • date : 按指定的格式字符串参数格式化 date 或者 datetime 对象，实例：
            • {{ pub_date|date:"F j, Y" }}
          • length : 返回变量的长度。
        • default
          • default 为变量提供一个默认值。
          • 如果 views 传的变量的布尔值是 false，则使用指定的默认值。
          • 以下值为 false：
            • 0 0.0 False 0j "" [] () set() {} None
              • 子主题
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): name =0 return render(request, "runoob.html", {"name": name})
          • HelloWorld/templates/runoob.html 文件代码：
            • {{ name|default:"菜鸟教程666" }}
        • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
        • length
          • 返回对象的长度，适用于字符串和列表。
          • 字典返回的是键值对的数量，集合返回的是去重后的长度。
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): name ="菜鸟教程" return render(request, "runoob.html", {"name": name})
        • HelloWorld/templates/runoob.html 文件代码：
          • {{ name|length}}
        • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
        • filesizeformat
          • 以更易读的方式显示文件的大小（即'13 KB', '4.1 MB', '102 bytes'等）。
          • 字典返回的是键值对的数量，集合返回的是去重后的长度。
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): num=1024 return render(request, "runoob.html", {"num": num})
          • HelloWorld/templates/runoob.html 文件代码：
            • {{ num|filesizeformat}}
        • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
          • 
        • date
          • 根据给定格式对一个日期变量进行格式化。
          • 格式 Y-m-d H:i:s返回 年-月-日 小时:分钟:秒 的格式时间。
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): import datetime now =datetime.datetime.now() return render(request, "runoob.html", {"time": now})
          • HelloWorld/templates/runoob.html 文件代码：
            • {{ time|date:"Y-m-d" }}
        • 再次访问 http://127.0.0.1:8000/runoob，可以看到页面：
        • truncatechars
          • 如果字符串包含的字符总个数多于指定的字符数量，那么会被截断掉后面的部分。
          • 截断的字符串将以 ... 结尾。
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): views_str = "菜鸟教程" return render(request, "runoob.html", {"views_str": views_str})
          • HelloWorld/templates/runoob.html 文件代码：
            • {{ views_str|truncatechars:2}}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
        • safe
          • 将字符串标记为安全，不需要转义。
          • 要保证 views.py 传过来的数据绝对安全，才能用 safe。
          • 和后端 views.py 的 mark_safe 效果相同。
          • Django 会自动对 views.py 传到HTML文件中的标签语法进行转义，令其语义失效。加 safe 过滤器是告诉 Django 该数据是安全的，不必对其进行转义，可以让该数据语义生效。
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): views_str = "<a href='https://www.runoob.com/'>点击跳转</a>" return render(request, "runoob.html", {"views_str": views_str})
          • HelloWorld/templates/runoob.html 文件代码：
            • {{ views_str|safe }}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
      • if/else 标签
        • 基本语法格式如下：
          • 基本语法格式如下：
            • {% if condition %} ... display {% endif %}
            • 或者：
            • {% if condition1 %} ... display 1 {% elif condition2 %} ... display 2 {% else %} ... display 3 {% endif %}
          • 根据条件判断是否输出。if/else 支持嵌套。
          • {% if %} 标签接受 and ， or 或者 not 关键字来对多个变量做判断 ，或者对变量取反（ not )，例如：
            • {% if athlete_list and coach_list %} athletes 和 coaches 变量都是可用的。 {% endif %}
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): views_num = 88 return render(request, "runoob.html", {"num": views_num})
          • HelloWorld/templates/runoob.html 文件代码：
            • {%if num > 90 and num <= 100 %} 优秀 {% elif num > 60 and num <= 90 %} 合格 {% else %} 一边玩去～ {% endif %}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
      • for 标签
        • {% for %} 允许我们在一个序列上迭代。
        • 与 Python 的 for 语句的情形类似，循环语法是 for X in Y ，Y 是要迭代的序列而 X 是在每一个特定的循环中使用的变量名称。
        • 每一次循环中，模板系统会渲染在 {% for %} 和 {% endfor %} 之间的所有内容。
        • 例如，给定一个运动员列表 athlete_list 变量，我们可以使用下面的代码来显示这个列表：
          • <ul> {% for athlete in athlete_list %} <li>{{ athlete.name }}</li> {% endfor %} </ul>
        • HelloWorld/HelloWorld/views.py 文件代码：
          • from django.shortcuts import render def runoob(request): views_list = ["菜鸟教程","菜鸟教程1","菜鸟教程2","菜鸟教程3",] return render(request, "runoob.html", {"views_list": views_list})
        • HelloWorld/templates/runoob.html 文件代码：
          • {% for i in views_list %} {{ i }} {% endfor %}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
          • 
        • 给标签增加一个 reversed 使得该列表被反向迭代：
          • {% for athlete in athlete_list reversed %} ... {% endfor %}
        • HelloWorld/templates/runoob.html 文件代码：
          • {% for i in views_list reversed%} {{ i }} {% endfor %}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
          • 
        • 遍历字典: 可以直接用字典 .items 方法，用变量的解包分别获取键和值。
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): views_dict = {"name":"菜鸟教程","age":18} return render(request, "runoob.html", {"views_dict": views_dict})
        • HelloWorld/templates/runoob.html 文件代码：
          • {% for i,j in views_dict.items %} {{ i }}---{{ j }} {% endfor %}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
          • 
        • 在 {% for %} 标签里可以通过 {{forloop}} 变量获取循环序号。
          • forloop.counter: 顺序获取循环序号，从 1 开始计算
          • forloop.counter0: 顺序获取循环序号，从 0 开始计算
          • forloop.revcounter: 倒序获取循环序号，结尾序号为 1
          • forloop.revcounter0: 倒序获取循环序号，结尾序号为 0
          • forloop.first（一般配合if标签使用）: 第一条数据返回 True，其他数据返回 False
          • forloop.last（一般配合if标签使用）: 最后一条数据返回 True，其他数据返回 False
        • HelloWorld/HelloWorld/views.py 文件代码：
          • from django.shortcuts import render def runoob(request): views_list = ["a", "b", "c", "d", "e"] return render(request, "runoob.html", {"listvar": views_list})
        • HelloWorld/templates/runoob.html 文件代码：
          • {% for i in listvar %} {{ forloop.counter }} {{ forloop.counter0 }} {{ forloop.revcounter }} {{ forloop.revcounter0 }} {{ forloop.first }} {{ forloop.last }} {% endfor %}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
          • 
        • {% empty %}
          • 可选的 {% empty %} 从句：在循环为空的时候执行（即 in 后面的参数布尔值为 False ）。
          • HelloWorld/HelloWorld/views.py 文件代码：
            • from django.shortcuts import render def runoob(request): views_list = [] return render(request, "runoob.html", {"listvar": views_list})
          • HelloWorld/templates/runoob.html 文件代码：
            • {% for i in listvar %} {{ forloop.counter0 }} {% empty %} 空空如也～ {% endfor %}
        • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
          • 
        • 可以嵌套使用 {% for %} 标签：
          • {% for athlete in athlete_list %} <h1>{{ athlete.name }}</h1> <ul> {% for sport in athlete.sports_played %} <li>{{ sport }}</li> {% endfor %} </ul> {% endfor %}
      • ifequal/ifnotequal 标签
        • {% ifequal %} 标签比较两个值，当他们相等时，显示在 {% ifequal %} 和 {% endifequal %} 之中所有的值。
        • 下面的例子比较两个模板变量 user 和 currentuser :
          • {% ifequal user currentuser %} <h1>Welcome!</h1> {% endifequal %}
        • 和 {% if %} 类似， {% ifequal %} 支持可选的 {% else%} 标签：8
          • {% ifequal section 'sitenews' %} <h1>Site News</h1> {% else %} <h1>No News Here</h1> {% endifequal %}
      • 注释标签
        • Django 注释使用 {# #}。
          • {# 这是一个注释 #}
      • include 标签
        • {% include %} 标签允许在模板中包含其它的模板的内容。
        • 下面这个例子都包含了 nav.html 模板：
          • {% include "nav.html" %}
      • csrf_token
        • csrf_token 用于form表单中，作用是跨站请求伪造保护。
        • 如果不用｛% csrf_token %｝标签，在用 form 表单时，要再次跳转页面会报403权限错误。
        • 用了｛% csrf_token %｝标签，在 form 表单提交数据时，才会成功。
        • 解析：
          • 首先，向服务器发送请求，获取登录页面，此时中间件 csrf 会自动生成一个隐藏input标签，该标签里的 value 属性的值是一个随机的字符串，用户获取到登录页面的同时也获取到了这个隐藏的input标签。
          • 然后，等用户需要用到form表单提交数据的时候，会携带这个 input 标签一起提交给中间件 csrf，原因是 form 表单提交数据时，会包括所有的 input 标签，中间件 csrf 接收到数据时，会判断，这个随机字符串是不是第一次它发给用户的那个，如果是，则数据提交成功，如果不是，则返回403权限错误。
      • 自定义标签和过滤器
        • 1、在应用目录下创建 templatetags 目录(与 templates 目录同级，目录名只能是 templatetags)。
          • HelloWorld/ |-- HelloWorld | |-- __init__.py | |-- __init__.pyc | |-- settings.py ... |-- manage.py `-- templatetags `-- templates
        • 2、在 templatetags 目录下创建任意 py 文件，如：my_tags.py。
        • 3、my_tags.py 文件代码如下：
          • from django import template register = template.Library() #register的名字是固定的,不可改变
        • 修改 settings.py 文件的 TEMPLATES 选项配置，添加 libraries 配置：
          • settings.py 配置文件
            • ... TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [BASE_DIR, "/templates",], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], "libraries":{ # 添加这边三行配置 'my_tags':'templatetags.my_tags' # 添加这边三行配置 } # 添加这边三行配置 }, }, ] ...
        • 4、利用装饰器 @register.filter 自定义过滤器。
          • 注意：装饰器的参数最多只能有 2 个。
          • @register.filter def my_filter(v1, v2): return v1 * v2
        • 5、利用装饰器 @register.simple_tag 自定义标签。
          • @register.simple_tag def my_tag1(v1, v2, v3): return v1 * v2 * v3
        • 6、在使用自定义标签和过滤器前，要在 html 文件 body 的最上方中导入该 py 文件。
          • {% load my_tags %}
        • 7、在 HTML 中使用自定义过滤器。
          • {{ 11|my_filter:22 }}
        • 8、在 HTML 中使用自定义标签。
          • {% my_tag1 11 22 33 %}
        • 9、语义化标签
          • 在该 py 文件中导入 mark_safe。
            • from django.utils.safestring import mark_safe
        • 定义标签时，用上 mark_safe 方法，令标签语义化，相当于 jQuery 中的 html() 方法。
        • 和前端HTML文件中的过滤器 safe 效果一样。
          • @register.simple_tag def my_html(v1, v2): temp_html = "<input type='text' id='%s' class='%s' />" %(v1, v2) return mark_safe(temp_html)
        • 在HTML中使用该自定义标签，在页面中动态创建标签。
          • {% my_html "zzz" "xxx" %}
    • 配置静态文件
      • 1、在项目根目录下创建 statics 目录。
        • 
      • 2、在 settings 文件的最下方配置添加以下配置：
        • STATIC_URL = '/static/' # 别名 STATICFILES_DIRS = [ os.path.join(BASE_DIR, "statics"), ]
        • 
      • 3、在 statics 目录下创建 css 目录，js 目录，images 目录，plugins 目录， 分别放 css文件，js文件，图片，插件。
      • 4、把 bootstrap 框架放入插件目录 plugins。
      • 5、在 HTML 文件的 head 标签中引入 bootstrap。
      • 注意：此时引用路径中的要用配置文件中的别名 static，而不是目录 statics。
        • <link rel="stylesheet" href="/static/plugins/bootstrap-3.3.7/dist/css/bootstrap.css">
      • 在模板中使用需要加入 {% load static %} 代码，以下实例我们从静态目录中引入图片。
        • HelloWorld/HelloWorld/views.py 文件代码：
          • from django.shortcuts import render def runoob(request): name ="菜鸟教程" return render(request, "runoob.html", {"name": name})
        • HelloWorld/templates/runoob.html 文件代码：
          • {% load static %} {{name}}<img src="{% static "images/runoob-logo.png" %}" alt="runoob-logo">
      • 再访问访问 http://127.0.0.1:8000/runoob，可以看到页面：
        • 
    • 模板继承
      • 模板可以用继承的方式来实现复用，减少冗余内容。
      • 网页的头部和尾部内容一般都是一致的，我们就可以通过模板继承来实现复用。
      • 父模板用于放置可重复利用的内容，子模板继承父模板的内容，并放置自己的内容。
      • 父模板
        • 标签 block...endblock: 父模板中的预留区域，该区域留给子模板填充差异性的内容，不同预留区域名字不能相同。
          • {% block 名称 %} 预留给子模板的区域，可以设置设置默认内容 {% endblock 名称 %}
      • 子模板
        • 子模板使用标签 extends 继承父模板：
          • {% extends "父模板路径"%}
        • 子模板如果没有设置父模板预留区域的内容，则使用在父模板设置的默认内容，当然也可以都不设置，就为空。
        • 子模板设置父模板预留区域的内容：
          • { % block 名称 % } 内容 {% endblock 名称 %}
      • 接下来我们先创建之前项目的 templates 目录中添加 base.html 文件，代码如下：
      • HelloWorld/templates/base.html 文件代码：
        • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <h1>Hello World!</h1> <p>菜鸟教程 Django 测试。</p> {% block mainbody %} <p>original</p> {% endblock %} </body> </html>
      • 以上代码中，名为 mainbody 的 block 标签是可以被继承者们替换掉的部分。
      • 所有的 {% block %} 标签告诉模板引擎，子模板可以重载这些部分。
      • runoob.html 中继承 base.html，并替换特定 block，runoob.html 修改后的代码如下：
      • HelloWorld/templates/runoob.html 文件代码：
        • {%extends "base.html" %} {% block mainbody %} <p>继承了 base.html 文件</p> {% endblock %}
      • 第一行代码说明 runoob.html 继承了 base.html 文件。可以看到，这里相同名字的 block 标签用以替换 base.html 的相应 block。
      • 重新访问地址 http://127.0.0.1:8000/runoob，输出结果如下：
        • 
  • Django 模型
    • Django 对各种数据库提供了很好的支持，包括：PostgreSQL、MySQL、SQLite、Oracle。
    • Django 为这些数据库提供了统一的调用API。 我们可以根据自己业务需求选择不同的数据库。
    • MySQL 是 Web 应用中最常用的数据库。本章节我们将以 Mysql 作为实例进行介绍。你可以通过本站的 MySQL 教程 了解更多 MySQL 的基础知识。
    • 如果你没安装 mysql 驱动，可以执行以下命令安装：
      • sudo pip3 install pymysql
    • Django ORM
      • Django 模型使用自带的 ORM。
      • 对象关系映射（Object Relational Mapping，简称 ORM ）用于实现面向对象编程语言里不同类型系统的数据之间的转换。
      • ORM 在业务逻辑层和数据库层之间充当了桥梁的作用。
      • ORM 是通过使用描述对象和数据库之间的映射的元数据，将程序中的对象自动持久化到数据库中。
      • 
      • 使用 ORM 的好处：
        • 提高开发效率。
        • 不同数据库可以平滑切换。
      • 使用 ORM 的缺点：
        • ORM 代码转换为 SQL 语句时，需要花费一定的时间，执行效率会有所降低。
        • 长期写 ORM 代码，会降低编写 SQL 语句的能力。
      • ORM 解析过程:
        • 1、ORM 会将 Python 代码转成为 SQL 语句。
        • 2、SQL 语句通过 pymysql 传送到数据库服务端。
        • 3、在数据库中执行 SQL 语句并将结果返回。
      • ORM 对应关系表：
        • 
    • 数据库配置
      • Django 如何使用 mysql 数据库
      • 创建 MySQL 数据库( ORM 无法操作到数据库级别，只能操作到数据表)语法：
        • create database 数据库名称 default charset=utf8; # 防止编码问题，指定为 utf8
      • 例如我们创建一个名为 runoob 数据库，编码指定为 utf8：
        • create database runoob default charset=utf8;
      • 我们在项目的 settings.py 文件中找到 DATABASES 配置项，将其信息修改为：
        • HelloWorld/HelloWorld/settings.py: 文件代码：
          • DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', # 数据库引擎 'NAME': 'runoob', # 数据库名称 'HOST': '127.0.0.1', # 数据库地址，本机 ip 地址 127.0.0.1 'PORT': 3306, # 端口 'USER': 'root', # 数据库用户名 'PASSWORD': '123456', # 数据库密码 } }
      • 如果你使用了 Python2.x 版本这里添加了中文注释，所以你需要在 HelloWorld/settings.py 文件头部添加 # -*- coding: UTF-8 -*-。
      • 上面包含数据库名称和用户的信息，它们与 MySQL 中对应数据库和用户的设置相同。Django 根据这一设置，与 MySQL 中相应的数据库和用户连接起来。
      • 接下来，告诉 Django 使用 pymysql 模块连接 mysql 数据库：
        • # 在与 settings.py 同级目录下的 __init__.py 中引入模块和进行配置 import pymysql pymysql.install_as_MySQLdb()
    • 定义模型
      • 创建 APP
        • Django 规定，如果要使用模型，必须要创建一个 app。我们使用以下命令创建一个 TestModel 的 app:
          • django-admin.py startapp TestModel
        • 目录结构如下：
          • HelloWorld |-- HelloWorld |-- manage.py ... |-- TestModel | |-- __init__.py | |-- admin.py | |-- models.py | |-- tests.py | `-- views.py
        • 我们修改 TestModel/models.py 文件，代码如下：
          • HelloWorld/TestModel/models.py: 文件代码：
            • # models.py from django.db import models class Test(models.Model): name = models.CharField(max_length=20)
        • 以上的类名代表了数据库表名，且继承了models.Model，类里面的字段代表数据表中的字段(name)，数据类型则由CharField（相当于varchar）、DateField（相当于datetime）， max_length 参数限定长度。
        • 接下来在 settings.py 中找到INSTALLED_APPS这一项，如下：
          • INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'TestModel', # 添加此项 )
            • 在命令行中运行：
            • $ python3 manage.py migrate # 创建表结构 $ python3 manage.py makemigrations TestModel # 让 Django 知道我们在我们的模型有一些变更 $ python3 manage.py migrate TestModel # 创建表结构
        • 看到几行 "Creating table…" 的字样，你的数据表就创建好了。
          • Creating tables ... …… Creating table TestModel_test #我们自定义的表 ……
        • 表名组成结构为：应用名_类名（如：TestModel_test）。
        • 注意：尽管我们没有在 models 给表设置主键，但是 Django 会自动添加一个 id 作为主键。
      • 常见报错信息
        • 如果执行以上命令时会出现如下报错信息:
          • 
        • 原因是 MySQLclient 目前只支持到 Python3.4，因此如果使用的更高版本的 python，需要修改如下：
        • 通过报错信息的文件路径找到 ...site-packages\Django-2.0-py3.6.egg\django\db\backends\mysql 这个路径里的 base.py 文件，把这两行代码注释掉（代码在文件开头部分）：
          • if version < (1, 3, 13): raise ImproperlyConfigured('mysqlclient 1.3.13 or newer is required; you have %s.' % Database.__version__)
          • 
        • 一般点报错的代码文件路径信息，会自动跳转到报错文件中行数，此时我们在报错的代码行数注释掉。
        • 如果出现以下报错信息:
          • 
        • 我们点报错的代码文件路径，跳转到报错文件中行数，此时我们在报错的代码行数之前加上:
          • query = query.encode()
          • 
      • 数据库操作
        • 接下来我们在 HelloWorld 目录中添加 testdb.py 文件（下面介绍），并修改 urls.py：
          • HelloWorld/HelloWorld/urls.py: 文件代码：
            • from django.urls import path from . import views,testdb urlpatterns = [ path('runoob/', views.runoob), path('testdb/', testdb.testdb), ]
        • 添加数据
          • 添加数据需要先创建对象，然后再执行 save 函数，相当于SQL中的INSERT：
            • HelloWorld/HelloWorld/testdb.py: 文件代码：
              • # -*- coding: utf-8 -*- from django.http import HttpResponse from TestModel.models import Test # 数据库操作 def testdb(request): test1 = Test(name='runoob') test1.save() return HttpResponse("<p>数据添加成功！</p>")
        • 访问 http://127.0.0.1:8000/testdb 就可以看到数据添加成功的提示。
        • 输出结果如下：
          • 
        • 获取数据
          • Django提供了多种方式来获取数据库的内容，如下代码所示：
            • HelloWorld/HelloWorld/testdb.py: 文件代码：
              • # -*- coding: utf-8 -*- from django.http import HttpResponse from TestModel.models import Test # 数据库操作 def testdb(request): # 初始化 response = "" response1 = "" # 通过objects这个模型管理器的all()获得所有数据行，相当于SQL中的SELECT * FROM list = Test.objects.all() # filter相当于SQL中的WHERE，可设置条件过滤结果 response2 = Test.objects.filter(id=1) # 获取单个对象 response3 = Test.objects.get(id=1) # 限制返回的数据 相当于 SQL 中的 OFFSET 0 LIMIT 2; Test.objects.order_by('name')[0:2] #数据排序 Test.objects.order_by("id") # 上面的方法可以连锁使用 Test.objects.filter(name="runoob").order_by("id") # 输出所有数据 for var in list: response1 += var.name + " " response = response1 return HttpResponse("<p>" + response + "</p>")
        • 更新数据
          • 修改数据可以使用 save() 或 update():
            • HelloWorld/HelloWorld/testdb.py: 文件代码：
              • # -*- coding: utf-8 -*- from django.http import HttpResponse from TestModel.models import Test # 数据库操作 def testdb(request): # 修改其中一个id=1的name字段，再save，相当于SQL中的UPDATE test1 = Test.objects.get(id=1) test1.name = 'Google' test1.save() # 另外一种方式 #Test.objects.filter(id=1).update(name='Google') # 修改所有的列 # Test.objects.all().update(name='Google') return HttpResponse("<p>修改成功</p>")
        • 删除数据
          • 删除数据库中的对象只需调用该对象的delete()方法即可：
            • HelloWorld/HelloWorld/testdb.py: 文件代码：
              • # -*- coding: utf-8 -*- from django.http import HttpResponse from TestModel.models import Test # 数据库操作 def testdb(request): # 删除id=1的数据 test1 = Test.objects.get(id=1) test1.delete() # 另外一种方式 # Test.objects.filter(id=1).delete() # 删除所有数据 # Test.objects.all().delete() return HttpResponse("<p>删除成功</p>")
  • Django 表单
    • HTML表单是网站交互性的经典方式。 本章将介绍如何用Django对用户提交的表单数据进行处理。
    • HTTP 请求
      • HTTP协议以"请求－回复"的方式工作。客户发送请求时，可以在请求中附加数据。服务器通过解析请求，就可以获得客户传来的数据，并根据URL来提供特定的服务。
    • GET 方法
      • 我们在之前的项目中创建一个 search.py 文件，用于接收用户的请求：
        • /HelloWorld/HelloWorld/search.py 文件代码：
          • from django.http import HttpResponse from django.shortcuts import render # 表单 def search_form(request): return render(request, 'search_form.html') # 接收请求数据 def search(request): request.encoding='utf-8' if 'q' in request.GET and request.GET['q']: message = '你搜索的内容为: ' + request.GET['q'] else: message = '你提交了空表单' return HttpResponse(message)
      • 在模板目录 templates 中添加 search_form.html 表单：
        • /HelloWorld/templates/search_form.html 文件代码：
          • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/search/" method="get"> <input type="text" name="q"> <input type="submit" value="搜索"> </form> </body> </html>
      • urls.py 规则修改为如下形式：
        • /HelloWorld/HelloWorld/urls.py 文件代码：
          • from django.conf.urls import url from . import views,testdb,search urlpatterns = [ url(r'^hello/$', views.runoob), url(r'^testdb/$', testdb.testdb), url(r'^search-form/$', search.search_form), url(r'^search/$', search.search), ]
      • 访问地址 http://127.0.0.1:8000/search-form/ 并搜索，结果如下所示:
        • 
          • 
    • POST 方法
      • 上面我们使用了GET方法。视图显示和请求处理分成两个函数处理。
      • 提交数据时更常用POST方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
      • 我们在 templates 创建 post.html：
        • /HelloWorld/templates/post.html 文件代码：
          • <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>菜鸟教程(runoob.com)</title> </head> <body> <form action="/search-post/" method="post"> {% csrf_token %} <input type="text" name="q"> <input type="submit" value="搜索"> </form> <p>{{ rlt }}</p> </body> </html>
      • 在模板的末尾，我们增加一个 rlt 记号，为表格处理结果预留位置。
      • 表格后面还有一个{% csrf_token %}的标签。csrf 全称是 Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。POST 方法提交的表格，必须有此标签。
      • 在HelloWorld目录下新建 search2.py 文件并使用 search_post 函数来处理 POST 请求：
        • /HelloWorld/HelloWorld/search2.py 文件代码：
          • # -*- coding: utf-8 -*- from django.shortcuts import render from django.views.decorators import csrf # 接收POST请求数据 def search_post(request): ctx ={} if request.POST: ctx['rlt'] = request.POST['q'] return render(request, "post.html", ctx)
      • urls.py 规则修改为如下形式：
        • /HelloWorld/HelloWorld/urls.py 文件代码：
          • from django.conf.urls import url from . import views,testdb,search,search2 urlpatterns = [ url(r'^hello/$', views.hello), url(r'^testdb/$', testdb.testdb), url(r'^search-form/$', search.search_form), url(r'^search/$', search.search), url(r'^search-post/$', search2.search_post), ]
      • 访问 http://127.0.0.1:8000/search-post/ 显示结果如下：
        • 
          • 
      • 完成以上实例后，我们的目录结构为：
        • HelloWorld |-- HelloWorld | |-- __init__.py | |-- __init__.pyc | |-- search.py | |-- search.pyc | |-- search2.py | |-- search2.pyc | |-- settings.py | |-- settings.pyc | |-- testdb.py | |-- testdb.pyc | |-- urls.py | |-- urls.pyc | |-- views.py | |-- views.pyc | |-- wsgi.py | `-- wsgi.pyc |-- TestModel | |-- __init__.py | |-- __init__.pyc | |-- admin.py | |-- admin.pyc | |-- apps.py | |-- migrations | | |-- 0001_initial.py | | |-- 0001_initial.pyc | | |-- __init__.py | | `-- __init__.pyc | |-- models.py | |-- models.pyc | |-- tests.py | `-- views.py |-- db.sqlite3 |-- manage.py `-- templates |-- base.html |-- hello.html |-- post.html `-- search_form.html
    • Request 对象
      • 每个视图函数的第一个参数是一个 HttpRequest 对象，就像下面这个 runoob() 函数:
        • from django.http import HttpResponse def runoob(request): return HttpResponse("Hello world")
      • HttpRequest对象包含当前请求URL的一些信息：
        • 属性 描述 path 请求页面的全路径,不包括域名—例如, "/hello/"。 method 请求中使用的HTTP方法的字符串表示。全大写表示。例如: if request.method == 'GET': do_something() elif request.method == 'POST': do_something_else() GET 包含所有HTTP GET参数的类字典对象。参见QueryDict 文档。 POST 包含所有HTTP POST参数的类字典对象。参见QueryDict 文档。 服务器收到空的POST请求的情况也是有可能发生的。也就是说，表单 form通过HTTP POST方法提交请求，但是表单中可以没有数据。因 此，不能使用语句if request.POST来判断是否使用HTTP POST方法； 应该使用if request.method == "POST" (参见本表的method属 性)。 注意: POST不包括file-upload信息。参见FILES属性。 REQUEST 为了方便，该属性是POST和GET属性的集合体，但是有特殊性，先查找 POST属性，然后再查找GET属性。借鉴PHP's $_REQUEST。 例如，如果GET = {"name": "john"} 和POST = {"age": '34'},则 REQUEST["name"] 的值是"john", REQUEST["age"]的值是"34". 强烈建议使用GET and POST,因为这两个属性更加显式化，写出的代 码也更易理解。 COOKIES 包含所有cookies的标准Python字典对象。Keys和values都是字符串。 FILES 包含所有上传文件的类字典对象。FILES中的每个Key都是<input type="file" name="" />标签中name属性的值. FILES中的每个value 同时也是一个标准Python字典对象，包含下面三个Keys: filename: 上传文件名,用Python字符串表示 content-type: 上传文件的Content type content: 上传文件的原始内容 注意：只有在请求方法是POST，并且请求页面中<form>有 enctype="multipart/form-data"属性时FILES才拥有数据。否则， FILES 是一个空字典。 META 包含所有可用HTTP头部信息的字典。 例如: CONTENT_LENGTH CONTENT_TYPE QUERY_STRING: 未解析的原始查询字符串 REMOTE_ADDR: 客户端IP地址 REMOTE_HOST: 客户端主机名 SERVER_NAME: 服务器主机名 SERVER_PORT: 服务器端口 META 中这些头加上前缀 HTTP_ 为 Key, 冒号(:)后面的为 Value， 例如: HTTP_ACCEPT_ENCODING HTTP_ACCEPT_LANGUAGE HTTP_HOST: 客户发送的HTTP主机头信息 HTTP_REFERER: referring页 HTTP_USER_AGENT: 客户端的user-agent字符串 HTTP_X_BENDER: X-Bender头信息 user 是一个django.contrib.auth.models.User 对象，代表当前登录的用户。 如果访问用户当前没有登录，user将被初始化为 django.contrib.auth.models.AnonymousUser的实例。 你可以通过user的is_authenticated()方法来辨别用户是否登录： if request.user.is_authenticated(): # Do something for logged-in users. else: # Do something for anonymous users. 只有激活Django中的AuthenticationMiddleware时该属性才可用 session 唯一可读写的属性，代表当前会话的字典对象。只有激活Django中的 session支持时该属性才可用。 raw_post_data 原始HTTP POST数据，未解析过。 高级处理时会有用处。
      • Request对象也有一些有用的方法：
        • 方法 描述
        • __getitem__(key) 返回GET/POST的键值,先取POST,后取GET。如果键不存在抛出 KeyError。
        • 这是我们可以使用字典语法访问HttpRequest对象。
        • 例如,request["foo"]等同于先request.POST["foo"] 然后 request.GET["foo"]的操作。
        • has_key() 检查request.GET or request.POST中是否包含参数指定的Key。
        • get_full_path() 返回包含查询字符串的请求路径。例如， "/music/bands/the_beatles/?print=true"
        • is_secure() 如果请求是安全的，返回True，就是说，发出的是HTTPS请求。
    • QueryDict对象
      • 在HttpRequest对象中, GET和POST属性是django.http.QueryDict类的实例。
      • QueryDict类似字典的自定义类，用来处理单键对应多值的情况。
      • QueryDict实现所有标准的词典方法。还包括一些特有的方法：
        • 方法 描述 __getitem__ 和标准字典的处理有一点不同，就是，如果Key对应多个 Value，__getitem__()返回最后一个value。 __setitem__ 设置参数指定key的value列表(一个Python list)。注意：它 只能在一个mutable QueryDict 对象上被调用(就是通过 copy()产生的一个QueryDict对象的拷贝). get() 如果key对应多个value，get()返回最后一个value。 update() 参数可以是QueryDict，也可以是标准字典。和标准字典的 update方法不同，该方法添加字典 items，而不是替换它们: >>> q = QueryDict('a=1') >>> q = q.copy() # to make it mutable >>> q.update({'a': '2'}) >>> q.getlist('a') ['1', '2'] >>> q['a'] # returns the last ['2'] items() 和标准字典的items()方法有一点不同,该方法使用单值逻辑的 __getitem__(): >>> q = QueryDict('a=1&a=2&a=3') >>> q.items() [('a', '3')] values() 和标准字典的values()方法有一点不同,该方法使用单值逻辑的 __getitem__():
      • 此外, QueryDict也有一些方法，如下表：
        • 方法 描述 copy() 返回对象的拷贝，内部实现是用Python标准库的copy.deepcopy()。 该拷贝是mutable(可更改的) — 就是说，可以更改该拷贝的值。 getlist(key) 返回和参数key对应的所有值，作为一个Python list返回。如果 key不存在，则返回空list。 It's guaranteed to return a list of some sort.. setlist(key,list_) 设置key的值为list_ (unlike __setitem__()). appendlist(key,item) 添加item到和key关联的内部list. setlistdefault(key,list) 和setdefault有一点不同，它接受list而不是单 个value作为参数。 lists() 和items()有一点不同, 它会返回key的所有值，作为一个 list, 例如: >>> q = QueryDict('a=1&a=2&a=3') >>> q.lists() [('a', ['1', '2', '3'])] urlencode() 返回一个以查询字符串格式进行格式化后的字符串(例 如："a=2&b=3&b=5")。
  • Django 视图
    • 视图层
      • 一个视图函数，简称视图，是一个简单的 Python 函数，它接受 Web 请求并且返回 Web 响应。
      • 响应可以是一个 HTML 页面、一个 404 错误页面、重定向页面、XML 文档、或者一张图片...
      • 无论视图本身包含什么逻辑，都要返回响应。代码写在哪里都可以，只要在 Python 目录下面，一般放在项目的 views.py 文件中。
      • 每个视图函数都负责返回一个 HttpResponse 对象，对象中包含生成的响应。
      • 视图层中有两个重要的对象：请求对象(request)与响应对象(HttpResponse)。
    • 请求对象: HttpRequest 对象（简称 request 对象）
      • 以下介绍几个常用的 request 属性。
      • 1、GET
        • 数据类型是 QueryDict，一个类似于字典的对象，包含 HTTP GET 的所有参数。
        • 有相同的键，就把所有的值放到对应的列表里。
        • 取值格式：对象.方法。
        • get()：返回字符串，如果该键对应有多个值，取出该键的最后一个值。
          • 实例
            • def runoob(request): name = request.GET.get("name") return HttpResponse('姓名：{}'.format(name))
          • 
      • 2、POST
        • 数据类型是 QueryDict，一个类似于字典的对象，包含 HTTP POST 的所有参数。
        • 常用于 form 表单，form 表单里的标签 name 属性对应参数的键，value 属性对应参数的值。
        • 取值格式： 对象.方法。
        • get()：返回字符串，如果该键对应有多个值，取出该键的最后一个值。
          • 实例
            • def runoob(request): name = request.POST.get("name") return HttpResponse('姓名：{}'.format(name))
          • 
      • 3、body
        • 数据类型是二进制字节流，是原生请求体里的参数内容，在 HTTP 中用于 POST，因为 GET 没有请求体。
        • 在 HTTP 中不常用，而在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML、Json 等。
          • 实例
            • def runoob(request): name = request.body print(name) return HttpResponse("菜鸟教程")
          • 
      • 4、path
        • 获取 URL 中的路径部分，数据类型是字符串。
          • 实例
            • def runoob(request): name = request.path print(name) return HttpResponse("菜鸟教程")
          • 
      • 5、method
        • 获取当前请求的方式，数据类型是字符串，且结果为大写。
          • 实例
            • def runoob(request): name = request.method print(name) return HttpResponse("菜鸟教程")
          • 
    • 响应对象：HttpResponse 对象
      • 响应对象主要有三种形式：HttpResponse()、render()、redirect()。
      • HttpResponse(): 返回文本，参数为字符串，字符串中写文本内容。如果参数为字符串里含有 html 标签，也可以渲染。
        • 实例
          • def runoob(request): # return HttpResponse("菜鸟教程") return HttpResponse("<a href='https://www.runoob.com/'>菜鸟教程</a>")
        • 
      • render(): 返回文本，第一个参数为 request，第二个参数为字符串（页面名称），第三个参数为字典（可选参数，向页面传递的参数：键为页面参数名，值为views参数名）。
        • 实例
          • def runoob(request): name ="菜鸟教程" return render(request,"runoob.html",{"name":name})
        • 
      • redirect()：重定向，跳转新页面。参数为字符串，字符串中填写页面路径。一般用于 form 表单提交后，跳转到新页面。
        • 实例
          • def runoob(request): return redirect("/index/")
      • render 和 redirect 是在 HttpResponse 的基础上进行了封装：
        • render：底层返回的也是 HttpResponse 对象
        • redirect：底层继承的是 HttpResponse 对象
  • Django 路由
    • 路由简单的来说就是根据用户请求的 URL 链接来判断对应的处理程序，并返回处理结果，也就是 URL 与 Django 的视图建立映射关系。
    • Django 路由在 urls.py 配置，urls.py 中的每一条配置对应相应的处理方法。
    • Django 不同版本 urls.py 配置有点不一样：
    • Django1.1.x 版本
      • url() 方法：普通路径和正则路径均可使用，需要自己手动添加正则首位限制符号。
        • 实例
          • from django.conf.urls import url # 用 url 需要引入 urlpatterns = [ url(r'^admin/$', admin.site.urls), url(r'^index/$', views.index), # 普通路径 url(r'^articles/([0-9]{4})/$', views.articles), # 正则路径 ]
    • Django 2.2.x 之后的版本
      • path：用于普通路径，不需要自己手动添加正则首位限制符号，底层已经添加。
      • re_path：用于正则路径，需要自己手动添加正则首位限制符号。
      • 实例
        • from django.urls import re_path # 用re_path 需要引入 urlpatterns = [ path('admin/', admin.site.urls), path('index/', views.index), # 普通路径 re_path(r'^articles/([0-9]{4})/$', views.articles), # 正则路径 ]
      • 总结：Django1.1.x 版本中的 url 和 Django 2.2.x 版本中的 re_path 用法相同。
    • 正则路径中的分组
      • 正则路径中的无名分组
        • 无名分组按位置传参，一一对应。
        • views 中除了 request，其他形参的数量要与 urls 中的分组数量一致。
          • urls.py
            • urlpatterns = [ path('admin/', admin.site.urls), re_path("^index/([0-9]{4})/$", views.index), ]
          • views.py
            • from django.shortcuts import HttpResponse def index(request，year): print(year) # 一个形参代表路径中一个分组的内容，按顺序匹配 return HttpResponse('菜鸟教程')
          • 
      • 正则路径中的有名分组
        • 语法：
          • (?P<组名>正则表达式)
        • 有名分组按关键字传参，与位置顺序无关。
        • views 中除了 request，其他形参的数量要与 urls 中的分组数量一致， 并且 views 中的形参名称要与 urls 中的组名对应。
          • urls.py
            • urlpatterns = [ path('admin/', admin.site.urls), re_path("^index/(?P[0-9]{4})/(?P[0-9]{2})/$", views.index), ]
          • views.py
            • from django.shortcuts import HttpResponse def index(request, year, month): print(year,month) # 一个形参代表路径中一个分组的内容，按关键字对应匹配 return HttpResponse('菜鸟教程')
          • 
      • 正则路径中的有名分组
        • 路由分发(include)
          • 存在问题：Django 项目里多个app目录共用一个 urls 容易造成混淆，后期维护也不方便。
          • 解决：使用路由分发（include），让每个app目录都单独拥有自己的 urls。
        • 步骤：
          • 1、在每个 app 目录里都创建一个 urls.py 文件。
          • 2、在项目名称目录下的 urls 文件里，统一将路径分发给各个 app 目录。
          • 实例
            • from django.contrib import admin from django.urls import path,include # 从 django.urls 引入 include urlpatterns = [ path('admin/', admin.site.urls), path("app01/", include("app01.urls")), path("app02/", include("app02.urls")), ]
          • 
        • 在各自 app 目录下，写自己的 urls.py 文件，进行路径跳转。
          • app01 目录:
            • from django.urls import path,re_path from app01 import views # 从自己的 app 目录引入 views urlpatterns = [ re_path(r'^login/(?P<m>[0-9]{2})/$', views.index, ), ]
          • app02 目录:
            • from django.urls import path,re_path from app02 import views # 从自己的 app 目录引入views urlpatterns = [ re_path("^xxx/(?P[0-9]{4})/$", views.xxx), ]
          • 
            • 
        • 在各自 app 目录下的 views.py 文件中写各自的视图函数。
    • 反向解析
      • 随着功能的增加，路由层的 url 发生变化，就需要去更改对应的视图层和模板层的 url，非常麻烦，不便维护。
      • 这时我们可以利用反向解析，当路由层 url 发生改变，在视图层和模板层动态反向解析出更改后的 url，免去修改的操作。
      • 反向解析一般用在模板中的超链接及视图中的重定向。
      • 普通路径
        • 在 urls.py 中给路由起别名，name="路由别名"。
          • path("login1/", views.login, name="login")
          • 
        • 在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名") 反向解析:
          • return redirect(reverse("login"))
          • 
        • 在模板 templates 中的 HTML 文件中，利用 {% url "路由别名" %} 反向解析。
          • <form action="{% url 'login' %}" method="post">
          • 
      • 正则路径（无名分组）
        • 在 urls.py 中给路由起别名，name="路由别名"。
          • re_path(r"^login/([0-9]{2})/$", views.login, name="login")
          • 
        • 在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名"，args=(符合正则匹配的参数,)) 反向解析。
          • return redirect(reverse("login",args=(10,)))
          • 
        • 在模板 templates 中的 HTML 文件中利用 {% url "路由别名" 符合正则匹配的参数 %} 反向解析。
          • <form action="{% url 'login' 10 %}" method="post">
          • 
      • 正则路径（有名分组）
        • 在 urls.py 中给路由起别名，name="路由别名"。
          • re_path(r"^login/(?P<year>[0-9]{4})/$", views.login, name="login")
          • 
        • 在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名"，kwargs={"分组名":符合正则匹配的参数}) 反向解析。
          • return redirect(reverse("login",kwargs={"year":3333}))
          • 
        • 在模板 templates 中的 HTML 文件中，利用 {% url "路由别名" 分组名=符合正则匹配的参数 %} 反向解析。
          • <form action="{% url 'login' year=3333 %}" method="post">
          • 
    • 命名空间
      • 命名空间（英语：Namespace）是表示标识符的可见范围。
      • 一个标识符可在多个命名空间中定义，它在不同命名空间中的含义是互不相干的。
      • 一个新的命名空间中可定义任何标识符，它们不会与任何重复的标识符发生冲突，因为重复的定义都处于其它命名空间中。
      • 存在问题：路由别名 name 没有作用域，Django 在反向解析 URL 时，会在项目全局顺序搜索，当查找到第一个路由别名 name 指定 URL 时，立即返回。当在不同的 app 目录下的urls 中定义相同的路由别名 name 时，可能会导致 URL 反向解析错误。
      • 解决：使用命名空间。
      • 普通路径
        • 定义命名空间（include 里面是一个元组）格式如下：
          • include(("app名称：urls"，"app名称"))
            • 实例：
              • path("app01/", include(("app01.urls","app01"))) path("app02/", include(("app02.urls","app02")))
            • 
          • 在 app01/urls.py 中起相同的路由别名。
            • path("login/", views.login, name="login")
            • 
          • 在 views.py 中使用名称空间，语法格式如下：
            • reverse("app名称：路由别名")
            • 实例：
              • return redirect(reverse("app01:login")
            • 
          • 在 templates 模板的 HTML 文件中使用名称空间，语法格式如下：
            • {% url "app名称：路由别名" %}
            • 实例：
              • <form action="{% url 'app01:login' %}" method="post">
            • 
  • Django Admin 管理工具
    • Django 提供了基于 web 的管理工具。
    • Django 自动管理工具是 django.contrib 的一部分。你可以在项目的 settings.py 中的 INSTALLED_APPS 看到它：
      • /HelloWorld/HelloWorld/settings.py 文件代码：
        • INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', )
      • django.contrib是一套庞大的功能集，它是Django基本代码的组成部分。
    • 激活管理工具
      • 通常我们在生成项目时会在 urls.py 中自动设置好，我们只需去掉注释即可。
      • 配置项如下所示：
        • /HelloWorld/HelloWorld/urls.py 文件代码：
          • # urls.py from django.conf.urls import url from django.contrib import admin urlpatterns = [ url(r'^admin/', admin.site.urls), ]
      • 当这一切都配置好后，Django 管理工具就可以运行了。
    • 使用管理工具
      • 启动开发服务器，然后在浏览器中访问 http://127.0.0.1:8000/admin/，得到如下界面：
        • 
      • 你可以通过命令 python manage.py createsuperuser 来创建超级用户，如下所示：
        • # python manage.py createsuperuser Username (leave blank to use 'root'): admin Email address: [e-mail] Password: Password (again): Superuser created successfully. [root@solar HelloWorld]#
      • 之后输入用户名密码登录，界面如下：
        • 
      • 为了让 admin 界面管理某个数据模型，我们需要先注册该数据模型到 admin。比如，我们之前在 TestModel 中已经创建了模型 Test 。修改 TestModel/admin.py:
        • HelloWorld/TestModel/admin.py: 文件代码：
          • from django.contrib import admin from TestModel.models import Test # Register your models here. admin.site.register(Test)
      • 刷新后即可看到 Testmodel 数据表:
        • 
    • 复杂模型
      • 管理页面的功能强大，完全有能力处理更加复杂的数据模型。
      • 先在 TestModel/models.py 中增加一个更复杂的数据模型：
        • HelloWorld/TestModel/models.py: 文件代码：
          • from django.db import models # Create your models here. class Test(models.Model): name = models.CharField(max_length=20) class Contact(models.Model): name = models.CharField(max_length=200) age = models.IntegerField(default=0) email = models.EmailField() def __unicode__(self): return self.name class Tag(models.Model): contact = models.ForeignKey(Contact, on_delete=models.CASCADE,) name = models.CharField(max_length=50) def __unicode__(self): return self.name
      • 这里有两个表。Tag 以 Contact 为外部键。一个 Contact 可以对应多个 Tag。
      • 我们还可以看到许多在之前没有见过的属性类型，比如 IntegerField 用于存储整数。
        • 
      • 在 TestModel/admin.py 注册多个模型并显示：
        • HelloWorld/TestModel/admin.py: 文件代码：
          • from django.contrib import admin from TestModel.models import Test,Contact,Tag # Register your models here. admin.site.register([Test, Contact, Tag])
      • 刷新管理页面，显示结果如下：
        • 
      • 在以上管理工具我们就能进行复杂模型操作。
        • 如果你之前还未创建表结构，可使用以下命令创建：
          • $ python manage.py makemigrations TestModel # 让 Django 知道我们在我们的模型有一些变更 $ python manage.py migrate TestModel # 创建表结构
    • 自定义表单
      • 我们可以自定义管理页面，来取代默认的页面。比如上面的 "add" 页面。我们想只显示 name 和 email 部分。修改 TestModel/admin.py:
        • HelloWorld/TestModel/admin.py: 文件代码：
          • from django.contrib import admin from TestModel.models import Test,Contact,Tag # Register your models here. class ContactAdmin(admin.ModelAdmin): fields = ('name', 'email') admin.site.register(Contact, ContactAdmin) admin.site.register([Test, Tag])
      • 以上代码定义了一个 ContactAdmin 类，用以说明管理页面的显示格式。
        • 里面的 fields 属性定义了要显示的字段。
        • 由于该类对应的是 Contact 数据模型，我们在注册的时候，需要将它们一起注册。显示效果如下：
          • 
      • 我们还可以将输入栏分块，每个栏也可以定义自己的格式。修改 TestModel/admin.py为：
        • HelloWorld/TestModel/admin.py: 文件代码：
          • from django.contrib import admin from TestModel.models import Test,Contact,Tag # Register your models here. class ContactAdmin(admin.ModelAdmin): fieldsets = ( ['Main',{ 'fields':('name','email'), }], ['Advance',{ 'classes': ('collapse',), # CSS 'fields': ('age',), }] ) admin.site.register(Contact, ContactAdmin) admin.site.register([Test, Tag])
      • 上面的栏目分为了 Main 和 Advance 两部分。classes 说明它所在的部分的 CSS 格式。这里让 Advance 部分隐藏：
        • 
      • Advance 部分旁边有一个 Show 按钮，用于展开，展开后可点击 Hide 将其隐藏，如下图所示：
        • 
    • 内联(Inline)显示
      • 上面的 Contact 是 Tag 的外部键，所以有外部参考的关系。
      • 而在默认的页面显示中，将两者分离开来，无法体现出两者的从属关系。我们可以使用内联显示，让 Tag 附加在 Contact 的编辑页面上显示。
      • 修改TestModel/admin.py：
        • HelloWorld/TestModel/admin.py: 文件代码：
          • from django.contrib import admin from TestModel.models import Test,Contact,Tag # Register your models here. class TagInline(admin.TabularInline): model = Tag class ContactAdmin(admin.ModelAdmin): inlines = [TagInline] # Inline fieldsets = ( ['Main',{ 'fields':('name','email'), }], ['Advance',{ 'classes': ('collapse',), 'fields': ('age',), }] ) admin.site.register(Contact, ContactAdmin) admin.site.register([Test])
      • 显示效果如下：
        • 
    • 列表页的显示
      • 在 Contact 输入数条记录后，Contact 的列表页看起来如下:
        • 
      • 我们也可以自定义该页面的显示，比如在列表中显示更多的栏目，只需要在 ContactAdmin 中增加 list_display 属性:
        • HelloWorld/TestModel/admin.py: 文件代码：
          • from django.contrib import admin from TestModel.models import Test,Contact,Tag # Register your models here. class TagInline(admin.TabularInline): model = Tag class ContactAdmin(admin.ModelAdmin): list_display = ('name','age', 'email') # list inlines = [TagInline] # Inline fieldsets = ( ['Main',{ 'fields':('name','email'), }], ['Advance',{ 'classes': ('collapse',), 'fields': ('age',), }] ) admin.site.register(Contact, ContactAdmin) admin.site.register([Test])
      • 刷新页面显示效果如下：
        • 
      • 搜索功能在管理大量记录时非常有，我们可以使用 search_fields 为该列表页增加搜索栏：
        • HelloWorld/TestModel/admin.py: 文件代码：
          • from django.contrib import admin from TestModel.models import Test,Contact,Tag # Register your models here. class TagInline(admin.TabularInline): model = Tag class ContactAdmin(admin.ModelAdmin): list_display = ('name','age', 'email') # list search_fields = ('name',) inlines = [TagInline] # Inline fieldsets = ( ['Main',{ 'fields':('name','email'), }], ['Advance',{ 'classes': ('collapse',), 'fields': ('age',), }] ) admin.site.register(Contact, ContactAdmin) admin.site.register([Test])
      • 在本实例中我们搜索了 name 为 runoob 的记录，显示结果如下：
        • 
      • Django Admin 管理工具还有非常多实用的功能，感兴趣的同学可以深入研究下。
  • Django ORM - 单表实例
    • 阅读本章节前你需要先阅读了 Django 模型 进行基础配置及了解常见问题的解决方案。
    • 接下来我们重新创建一个项目 app01（如果之前已创建过，忽略以下操作）:
      • django-admin.py startproject app01
    • 接下来在 settings.py 中找到 INSTALLED_APPS 这一项，如下：
      • INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'app01', # 添加此项 )
    • 接下来，告诉 Django 使用 pymysql 模块连接 mysql 数据库：
      • 实例
        • # 在与 settings.py 同级目录下的 __init__.py 中引入模块和进行配置 import pymysql pymysql.install_as_MySQLdb()
    • 创建模型
      • 在项目中的 models.py 中添加以下类：
        • app01/models.py
          • class Book(models.Model): id = models.AutoField(primary_key=True) # id 会自动创建,可以手动写入 title = models.CharField(max_length=32) # 书籍名称 price = models.DecimalField(max_digits=5, decimal_places=2) # 书籍价格 publish = models.CharField(max_length=32) # 出版社名称 pub_date = models.DateField() # 出版时间
        • 然后在命令行执行以下命令：
          • $ python3 manage.py migrate # 创建表结构 $ python3 manage.py makemigrations app01 # 让 Django 知道我们在我们的模型有一些变更 $ python3 manage.py migrate app01 # 创建表结构
      • 常见报错信息
        • 如果执行以上命令时会出现如下报错信息:
          • 
      • 原因是 MySQLclient 目前只支持到 Python3.4，因此如果使用的更高版本的 python，需要修改如下：
        • 通过报错信息的文件路径找到 ...site-packages\Django-2.0-py3.6.egg\django\db\backends\mysql 这个路径里的 base.py 文件，把这两行代码注释掉（代码在文件开头部分）：
          • if version < (1, 3, 13): raise ImproperlyConfigured('mysqlclient 1.3.13 or newer is required; you have %s.' % Database.__version__)
          • 
      • 一般点报错的代码文件路径信息，会自动跳转到报错文件中行数，此时我们在报错的代码行数注释掉。
      • 这时数据库 runoob 就会创建一个 app01_book 的表。
      • 接下来我们在app01 项目里添加 views.py 和 models.py 文件，app01 项目目录结构：
        • app01 |-- app01 | |-- __init__.py | |-- __pycache__ | |-- asgi.py | |-- migrations | |-- models.py | |-- settings.py | |-- urls.py | |-- views.py | `-- wsgi.py
    • 数据库添加
      • 规则配置：
        • app01/urls.py: 文件代码：
          • from django.contrib import admin from django.urls import path from . import views urlpatterns = [ path('add_book/', views.add_book), ]
      • 方式一：模型类实例化对象
        • 需从 app 目录引入 models.py 文件：
          • from app 目录 import models
        • 并且实例化对象后要执行 对象.save() 才能在数据库中新增成功。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): book = models.Book(title="菜鸟教程",price=300,publish="菜鸟出版社",pub_date="2008-8-8") book.save() return HttpResponse("<p>数据添加成功！</p>")
          • 
            • 
              • 
      • 方式二：通过 ORM 提供的 objects 提供的方法 create 来实现（推荐）
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.create(title="如来神掌",price=200,publish="功夫出版社",pub_date="2010-10-10") print(books, type(books)) # Book object (18) return HttpResponse("<p>数据添加成功！</p>")
        • 
          • 
            • 
    • 查找
      • 使用 all() 方法来查询所有内容。
      • 返回的是 QuerySet 类型数据，类似于 list，里面放的是一个个模型类的对象，可用索引下标取出模型类的对象。
      • app01/views.py: 文件代码：
        • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.all() print(books,type(books)) # QuerySet类型，类似于list，访问 url 时数据显示在命令行窗口中。 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
            • 
        • 
      • filter() 方法用于查询符合条件的数据。
        • 返回的是 QuerySet 类型数据，类似于 list，里面放的是满足条件的模型类的对象，可用索引下标取出模型类的对象。
        • pk=3 的意思是主键 primary key=3，相当于 id=3。
        • 因为 id 在 pycharm 里有特殊含义，是看内存地址的内置函数 id()，因此用 pk。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.filter(pk=5) print(books) print("//////////////////////////////////////") books = models.Book.objects.filter(publish='菜鸟出版社', price=300) print(books, type(books)) # QuerySet类型，类似于list。 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
            • 
      • exclude() 方法用于查询不符合条件的数据。
        • 返回的是 QuerySet 类型数据，类似于 list，里面放的是不满足条件的模型类的对象，可用索引下标取出模型类的对象。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.exclude(pk=5) print(books) print("//////////////////////////////////////") books = models.Book.objects.exclude(publish='菜鸟出版社', price=300) print(books, type(books)) # QuerySet类型，类似于list。 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
      • get() 方法用于查询符合条件的返回模型类的对象符合条件的对象只能为一个，如果符合筛选条件的对象超过了一个或者没有一个都会抛出错误。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.get(pk=5) books = models.Book.objects.get(pk=18) # 报错，没有符合条件的对象 books = models.Book.objects.get(price=200) # 报错，符合条件的对象超过一个 print(books, type(books)) # 模型类的对象 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
            • 
      • order_by() 方法用于对查询结果进行排序。
        • 返回的是 QuerySet类型数据，类似于list，里面放的是排序后的模型类的对象，可用索引下标取出模型类的对象。
        • 注意：
          • a、参数的字段名要加引号。
          • b、降序为在字段前面加个负号 -。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.order_by("price") # 查询所有，按照价格升序排列 books = models.Book.objects.order_by("-price") # 查询所有，按照价格降序排列 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
      • reverse() 方法用于对查询结果进行反转。
        • 返回的是 QuerySe t类型数据，类似于 list，里面放的是反转后的模型类的对象，可用索引下标取出模型类的对象。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): # 按照价格升序排列：降序再反转 books = models.Book.objects.order_by("-price").reverse() return HttpResponse("<p>查找成功！</p>")
        • 
          • 
      • count() 方法用于查询数据的数量返回的数据是整数。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.count() # 查询所有数据的数量 books = models.Book.objects.filter(price=200).count() # 查询符合条件数据的数量 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
      • first() 方法返回第一条数据返回的数据是模型类的对象也可以用索引下标 [0]。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.first() # 返回所有数据的第一条数据 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
            • 
      • last() 方法返回最后一条数据返回的数据是模型类的对象不能用索引下标 [-1]，ORM 没有逆序索引。
        • app01/views.py: 文件代码：
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.last() # 返回所有数据的最后一条数据 return HttpResponse("<p>查找成功！</p>")
        • 
          • 
            • 
      • exists() 方法用于判断查询的结果 QuerySet 列表里是否有数据。
        • 返回的数据类型是布尔，有为 true，没有为 false。
        • 注意：判断的数据类型只能为 QuerySet 类型数据，不能为整型和模型类的对象。
          • 实例
            • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.exists() # 报错，判断的数据类型只能为QuerySet类型数据，不能为整型 books = models.Book.objects.count().exists() # 报错，判断的数据类型只能为QuerySet类型数据，不能为模型类对象 books = models.Book.objects.first().exists() return HttpResponse("<p>查找成功！</p>")
          • 
            • 
      • values() 方法用于查询部分字段的数据。
        • 返回的是 QuerySet 类型数据，类似于 list，里面不是模型类的对象，而是一个可迭代的字典序列，字典里的键是字段，值是数据。
        • 注意：
          • 参数的字段名要加引号
          • 想要字段名和数据用 values
          • 实例
            • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): # 查询所有的id字段和price字段的数据 books = models.Book.objects.values("pk","price") print(books[0]["price"],type(books)) # 得到的是第一条记录的price字段的数据 return HttpResponse("<p>查找成功！</p>")
          • 
            • 
              • 
                • 
      • values_list() 方法用于查询部分字段的数据。
        • 返回的是 QuerySet 类型数据，类似于 list，里面不是模型类的对象，而是一个个元组，元组里放的是查询字段对应的数据。
        • 注意：
          • 参数的字段名要加引号
          • 只想要数据用 values_list
          • 实例
            • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): # 查询所有的price字段和publish字段的数据 books = models.Book.objects.values_list("price","publish") print(books) print(books[0][0],type(books)) # 得到的是第一条记录的price字段的数据 return HttpResponse("<p>查找成功！</p>")
          • 
            • 
      • distinct() 方法用于对数据进行去重。
        • 返回的是 QuerySet 类型数据。
        • 注意：
          • 对模型类的对象去重没有意义，因为每个对象都是一个不一样的存在。
          • distinct() 一般是联合 values 或者 values_list 使用。
          • 实例
            • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): # 查询一共有多少个出版社 books = models.Book.objects.values_list("publish").distinct() # 对模型类的对象去重没有意义，因为每个对象都是一个不一样的存在。 books = models.Book.objects.distinct() return HttpResponse("<p>查找成功！</p>")
          • 
            • 
      • filter() 方法基于双下划线的模糊查询（exclude 同理）。
        • 注意：filter 中运算符号只能使用等于号 = ，不能使用大于号 > ，小于号 < ，等等其他符号。
        • __in 用于读取区间，= 号后面为列表 。
        • 实例
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): # 查询价格为200或者300的数据 books = models.Book.objects.filter(price__in=[200,300]) return HttpResponse("<p>查找成功！</p>")
        • 
          • 
            • 
      • __gt 大于号 ，= 号后面为数字。
        • # 查询价格大于200的数据 books = models.Book.objects.filter(price__gt=200)
          • 
            • 
              • 
      • __lt 小于，=号后面为数字。
        • # 查询价格小于300的数据 books=models.Book.objects.filter(price__lt=300)
          • 
            • 
              • 
      • __lte 小于等于，= 号后面为数字。
        • # 查询价格小于等于300的数据 books=models.Book.objects.filter(price__lte=300)
          • 
            • 
              • 
      • __range 在 ... 之间，左闭右闭区间，= 号后面为两个元素的列表。
        • books=models.Book.objects.filter(price__range=[200,300])
          • 
            • 
              • 
      • __contains 包含，= 号后面为字符串。
        • books=models.Book.objects.filter(title__contains="菜")
          • 
            • 
              • 
      • __icontains 不区分大小写的包含，= 号后面为字符串。
        • books=models.Book.objects.filter(title__icontains="python") # 不区分大小写
          • 
            • 
              • 
      • __startswith 以指定字符开头，= 号后面为字符串。
        • books=models.Book.objects.filter(title__startswith="菜")
          • 
            • 
              • 
      • __endswith 以指定字符结尾，= 号后面为字符串。
        • books=models.Book.objects.filter(title__endswith="教程")
          • 
            • 
      • __year 是 DateField 数据类型的年份，= 号后面为数字。
        • books=models.Book.objects.filter(pub_date__year=2008)
          • 
            • 
              • 
      • __month 是DateField 数据类型的月份，= 号后面为数字。
        • books=models.Book.objects.filter(pub_date__month=10)
          • 
            • 
      • __day 是DateField 数据类型的天数，= 号后面为数字。
        • books=models.Book.objects.filter(pub_date__day=01)
          • 
            • 
              • 
    • 删除
      • 方式一：使用模型类的 对象.delete()。
        • 返回值：元组，第一个元素为受影响的行数。
          • books=models.Book.objects.filter(pk=8).first().delete()
            • 
              • 
      • 方式二：使用 QuerySet 类型数据.delete()(推荐)
        • 返回值：元组，第一个元素为受影响的行数。
        • books=models.Book.objects.filter(pk__in=[1,2]).delete()
          • 
            • 
              • 
      • 注意：
        • a. Django 删除数据时，会模仿 SQL约束 ON DELETE CASCADE 的行为，也就是删除一个对象时也会删除与它相关联的外键对象。
        • b. delete() 方法是 QuerySet 数据类型的方法，但并不适用于 Manager 本身。也就是想要删除所有数据，不能不写 all。
          • books=models.Book.objects.delete()　 # 报错 books=models.Book.objects.all().delete()　　 # 删除成功
    • 修改
      • 方式一：
        • 模型类的对象.属性 = 更改的属性值
        • 模型类的对象.save()
        • 返回值：编辑的模型类的对象。
          • books = models.Book.objects.filter(pk=7).first() books.price = 400 books.save()
          • 
            • 
              • 
      • 方式二：QuerySet 类型数据.update(字段名=更改的数据)（推荐）
        • 返回值：整数，受影响的行数
        • 实例
          • from django.shortcuts import render,HttpResponse from app01 import models def add_book(request): books = models.Book.objects.filter(pk__in=[7,8]).update(price=888) return HttpResponse(books)
        • 
          • 
            • 
  • Django ORM – 多表实例
    • 表与表之间的关系可分为以下三种：
      • 一对一: 一个人对应一个身份证号码，数据字段设置 unique。
      • 一对多: 一个家庭有多个人，一般通过外键来实现。
      • 多对多: 一个学生有多门课程，一个课程有很多学生，一般通过第三个表来实现关联。
      • 
    • 创建模型
      • 接下来我们来看下多表多实例。
        • 实例
          • class Book(models.Model): title = models.CharField(max_length=32) price = models.DecimalField(max_digits=5, decimal_places=2) pub_date = models.DateField() publish = models.ForeignKey("Publish", on_delete=models.CASCADE) authors = models.ManyToManyField("Author") class Publish(models.Model): name = models.CharField(max_length=32) city = models.CharField(max_length=64) email = models.EmailField() class Author(models.Model): name = models.CharField(max_length=32) age = models.SmallIntegerField() au_detail = models.OneToOneField("AuthorDetail", on_delete=models.CASCADE) class AuthorDetail(models.Model): gender_choices = ( (0, "女"), (1, "男"), (2, "保密"), ) gender = models.SmallIntegerField(choices=gender_choices) tel = models.CharField(max_length=32) addr = models.CharField(max_length=64) birthday = models.DateField()
      • 说明：
        • 1、EmailField 数据类型是邮箱格式，底层继承 CharField，进行了封装，相当于 MySQL 中的 varchar。
        • 2、Django1.1 版本不需要联级删除：on_delete=models.CASCADE，Django2.2 需要。
        • 3、一般不需要设置联级更新.
        • 4、外键在一对多的多中设置：models.ForeignKey("关联类名", on_delete=models.CASCADE)。
        • 5、OneToOneField = ForeignKey(...，unique=True)设置一对一。
        • 6、若有模型类存在外键，创建数据时，要先创建外键关联的模型类的数据，不然创建包含外键的模型类的数据时，外键的关联模型类的数据会找不到。
    • 表结构
      • 书籍表 Book：title 、 price 、 pub_date 、 publish（外键，多对一） 、 authors（多对多）
      • 出版社表 Publish：name 、 city 、 email
      • 作者表 Author：name 、 age 、 au_detail（一对一）
      • 作者详情表 AuthorDetail：gender 、 tel 、 addr 、 birthday
      • 以下是表格关联说明：
        • 
    • 插入数据
      • 我们在 MySQL 中执行以下 SQL 插入操作：
        • insert into app01_publish(name,city,email) values ("华山出版社", "华山", "[e-mail]"), ("明教出版社", "黑木崖", "[e-mail]") # 先插入 authordetail 表中多数据 insert into app01_authordetail(gender,tel,addr,birthday) values (1,13432335433,"华山","1994-5-23"), (1,13943454554,"黑木崖","1961-8-13"), (0,13878934322,"黑木崖","1996-5-20") # 再将数据插入 author，这样 author 才能找到 authordetail insert into app01_author(name,age,au_detail_id) values ("令狐冲",25,1), ("任我行",58,2), ("任盈盈",23,3)
          • 
    • ORM - 添加数据
      • 一对多(外键 ForeignKey)
        • 方式一: 传对象的形式，返回值的数据类型是对象，书籍对象。
          • 步骤：
            • a. 获取出版社对象
            • b. 给书籍的出版社属性 pulish 传出版社对象
            • app01/views.py 文件代码：
              • def add_book(request): # 获取出版社对象 pub_obj = models.Publish.objects.filter(pk=1).first() # 给书籍的出版社属性publish传出版社对象 book = models.Book.objects.create(title="菜鸟教程", price=200, pub_date="2010-10-10", publish=pub_obj) print(book, type(book)) return HttpResponse(book)
            • 
              • 
                • 
        • 方式二: 传对象 id 的形式(由于传过来的数据一般是 id,所以传对象 id 是常用的)。
          • 一对多中，设置外键属性的类(多的表)中，MySQL 中显示的字段名是:外键属性名_id。
          • 返回值的数据类型是对象，书籍对象。
          • 步骤：
            • a. 获取出版社对象的 id
            • b. 给书籍的关联出版社字段 pulish_id 传出版社对象的 id
            • app01/views.py 文件代码：
              • def add_book(request): # 获取出版社对象 pub_obj = models.Publish.objects.filter(pk=1).first() # 获取出版社对象的id pk = pub_obj.pk # 给书籍的关联出版社字段 publish_id 传出版社对象的id book = models.Book.objects.create(title="冲灵剑法", price=100, pub_date="2004-04-04", publish_id=pk) print(book, type(book)) return HttpResponse(book)
            • 
              • 
                • 
      • 多对多(ManyToManyField)：在第三张关系表中新增数据
        • 方式一: 传对象形式，无返回值。
          • 步骤：
            • a. 获取作者对象
            • b. 获取书籍对象
            • c. 给书籍对象的 authors 属性用 add 方法传作者对象
            • app01/views.py 文件代码：
              • def add_book(request): # 获取作者对象 chong = models.Author.objects.filter(name="令狐冲").first() ying = models.Author.objects.filter(name="任盈盈").first() # 获取书籍对象 book = models.Book.objects.filter(title="菜鸟教程").first() # 给书籍对象的 authors 属性用 add 方法传作者对象 book.authors.add(chong, ying) return HttpResponse(book)
            • 
              • 
        • 方式二: 传对象id形式，无返回值。
          • 步骤：
            • a. 获取作者对象的 id
            • b. 获取书籍对象
            • c. 给书籍对象的 authors 属性用 add 方法传作者对象的 id
            • app01/views.py 文件代码：
              • def add_book(request): # 获取作者对象 chong = models.Author.objects.filter(name="令狐冲").first() # 获取作者对象的id pk = chong.pk # 获取书籍对象 book = models.Book.objects.filter(title="冲灵剑法").first() # 给书籍对象的 authors 属性用 add 方法传作者对象的id book.authors.add(pk)
            • 
              • 
    • 关联管理器(对象调用)
      • 前提：
        • 多对多（双向均有关联管理器）
        • 一对多（只有多的那个类的对象有关联管理器，即反向才有）
      • 语法格式：
        • 正向：属性名 反向：小写类名加 _set
      • 注意：一对多只能反向
      • 常用方法：
      • add()：用于多对多，把指定的模型对象添加到关联对象集（关系表）中。
      • 注意：add() 在一对多(即外键)中，只能传对象（ *QuerySet数据类型），不能传 id（*[id表]）。
      • *[ ] 的使用:
        • # 方式一：传对象
          • book_obj = models.Book.objects.get(id=10) author_list = models.Author.objects.filter(id__gt=2) book_obj.authors.add(*author_list) # 将 id 大于2的作者对象添加到这本书的作者集合中 # 方式二：传对象 id book_obj.authors.add(*[1,3]) # 将 id=1 和 id=3 的作者对象添加到这本书的作者集合中 return HttpResponse("ok")
          • 
            • 
          • 反向：小写表名_set
            • ying = models.Author.objects.filter(name="任盈盈").first() book = models.Book.objects.filter(title="冲灵剑法").first() ying.book_set.add(book) return HttpResponse("ok")
          • 
      • create()：创建一个新的对象，并同时将它添加到关联对象集之中。
        • 返回新创建的对象。
          • pub = models.Publish.objects.filter(name="明教出版社").first() wo = models.Author.objects.filter(name="任我行").first() book = wo.book_set.create(title="吸星大法", price=300, pub_date="1999-9-19", publish=pub) print(book, type(book)) return HttpResponse("ok")
        • 
          • 
      • remove()：从关联对象集中移除执行的模型对象。
        • 对于 ForeignKey 对象，这个方法仅在 null=True（可以为空）时存在，无返回值。
          • 实例
            • author_obj =models.Author.objects.get(id=1) book_obj = models.Book.objects.get(id=11) author_obj.book_set.remove(book_obj) return HttpResponse("ok")
        • 
          • 
      • clear()：从关联对象集中移除一切对象，删除关联，不会删除对象。
        • 对于 ForeignKey 对象，这个方法仅在 null=True（可以为空）时存在。
        • 无返回值。
          • # 清空独孤九剑关联的所有作者 book = models.Book.objects.filter(title="菜鸟教程").first() book.authors.clear()
    • ORM 查询
      • 基于对象的跨表查询。
        • 正向：属性名称 反向：小写类名_set
      • 一对多
      • 查询主键为 1 的书籍的出版社所在的城市（正向）。
        • 实例
          • book = models.Book.objects.filter(pk=10).first() res = book.publish.city print(res, type(res)) return HttpResponse("ok")
        • 
          • 
      • 查询明教出版社出版的书籍名（反向）。
      • 反向：对象.小写类名_set(pub.book_set) 可以跳转到关联的表(书籍表)。
      • pub.book_set.all()：取出书籍表的所有书籍对象，在一个 QuerySet 里，遍历取出一个个书籍对象。
        • 实例
          • pub = models.Publish.objects.filter(name="明教出版社").first() res = pub.book_set.all() for i in res: print(i.title) return HttpResponse("ok")
        • 
          • 
      • 一对一
        • 查询令狐冲的电话（正向）
        • 正向：对象.属性 (author.au_detail) 可以跳转到关联的表(作者详情表)
          • 实例
            • author = models.Author.objects.filter(name="令狐冲").first() res = author.au_detail.tel print(res, type(res)) return HttpResponse("ok")
          • 
            • 
        • 查询所有住址在黑木崖的作者的姓名（反向）。
        • 一对一的反向，用 对象.小写类名 即可，不用加 _set。
        • 反向：对象.小写类名(addr.author)可以跳转到关联的表(作者表)。
          • 实例
            • addr = models.AuthorDetail.objects.filter(addr="黑木崖").first() res = addr.author.name print(res, type(res)) return HttpResponse("ok")
          • 
            • 
      • 多对多
        • 菜鸟教程所有作者的名字以及手机号（正向）。
        • 正向：对象.属性(book.authors)可以跳转到关联的表(作者表)。
        • 作者表里没有作者电话，因此再次通过对象.属性(i.au_detail)跳转到关联的表（作者详情表）。
          • 实例
            • book = models.Book.objects.filter(title="菜鸟教程").first() res = book.authors.all() for i in res: print(i.name, i.au_detail.tel) return HttpResponse("ok")
          • 
            • 
        • 查询任我行出过的所有书籍的名字（反向）。
          • 实例
            • author = models.Author.objects.filter(name="任我行").first() res = author.book_set.all() for i in res: print(i.title) return HttpResponse("ok")
          • 
            • 
    • 基于双下划线的跨表查询
      • 正向：属性名称__跨表的属性名称 反向：小写类名__跨表的属性名称
        • 一对多
          • 查询菜鸟出版社出版过的所有书籍的名字与价格。
          • 实例
            • res = models.Book.objects.filter(publish__name="菜鸟出版社").values_list("title", "price")
            • 
              • 
          • 反向：通过 小写类名__跨表的属性名称（book__title，book__price） 跨表获取数据。
            • 实例
              • res = models.Publish.objects.filter(name="菜鸟出版社").values_list("book__title","book__price") return HttpResponse("ok")
            • 
              • 
        • 多对多
          • 查询任我行出过的所有书籍的名字。
          • 正向：通过 属性名称__跨表的属性名称(authors__name) 跨表获取数据：
            • res = models.Book.objects.filter(authors__name="任我行").values_list("title")
          • 反向：通过 小写类名__跨表的属性名称（book__title） 跨表获取数据：
            • res = models.Author.objects.filter(name="任我行").values_list("book__title")
          • 
            • 
        • 一对一
          • 查询任我行的手机号。
          • 正向：通过 属性名称__跨表的属性名称(au_detail__tel) 跨表获取数据。
            • res = models.Author.objects.filter(name="任我行").values_list("au_detail__tel")
            • 
              • 
          • 反向：通过 小写类名__跨表的属性名称（author__name） 跨表获取数据。
            • res = models.AuthorDetail.objects.filter(author__name="任我行").values_list("tel")
            • 
              • 
  • Django ORM – 多表实例（聚合与分组查询）
    • 聚合查询（aggregate）
      • 聚合查询函数是对一组值执行计算，并返回单个值。
      • Django 使用聚合查询前要先从 django.db.models 引入 Avg、Max、Min、Count、Sum（首字母大写）。
        • from django.db.models import Avg,Max,Min,Count,Sum # 引入函数
      • 聚合查询返回值的数据类型是字典。
      • 聚合函数 aggregate() 是 QuerySet 的一个终止子句， 生成的一个汇总值，相当于 count()。
      • 使用 aggregate() 后，数据类型就变为字典，不能再使用 QuerySet 数据类型的一些 API 了。
      • 日期数据类型(DateField)可以用 Max 和 Min。
      • 返回的字典中：键的名称默认是（属性名称加上__聚合函数名），值是计算出来的聚合值。
      • 如果要自定义返回字典的键的名称，可以起别名：
        • aggregate(别名 = 聚合函数名("属性名称"))
      • 计算所有图书的平均价格:
        • 实例
          • from django.db.models import Avg,Max,Min,Count,Sum # 引入函数 ... res = models.Book.objects.aggregate(Avg("price")) print(res, type(res)) ...
        • 
          • 
      • 计算所有图书的数量、最贵价格和最便宜价格:
        • 实例
          • res=models.Book.objects.aggregate(c=Count("id"),max=Max("price"),min=Min("price")) print(res,type(res)
        • 
          • 
    • 分组查询（annotate）
      • 分组查询一般会用到聚合函数，所以使用前要先从 django.db.models 引入 Avg,Max,Min,Count,Sum（首字母大写）。
        • from django.db.models import Avg,Max,Min,Count,Sum # 引入函数
      • 返回值：
        • 分组后，用 values 取值，则返回值是 QuerySet 数据类型里面为一个个字典；
        • 分组后，用 values_list 取值，则返回值是 QuerySet 数据类型里面为一个个元组。
        • MySQL 中的 limit 相当于 ORM 中的 QuerySet 数据类型的切片。
      • 注意：
        • annotate 里面放聚合函数。
          • values 或者 values_list 放在 annotate 前面：values 或者 values_list 是声明以什么字段分组，annotate 执行分组。
          • values 或者 values_list 放在annotate后面： annotate 表示直接以当前表的pk执行分组，values 或者 values_list 表示查询哪些字段， 并且要将 annotate 里的聚合函数起别名，在 values 或者 values_list 里写其别名。
      • 准备数据和创建模型
        • models.py
          • class Emp(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() salary = models.DecimalField(max_digits=8, decimal_places=2) dep = models.CharField(max_length=32) province = models.CharField(max_length=32) class Emps(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() salary = models.DecimalField(max_digits=8, decimal_places=2) dep = models.ForeignKey("Dep", on_delete=models.CASCADE) province = models.CharField(max_length=32) class Dep(models.Model): title = models.CharField(max_length=32)
        • 数据:
          • 在 MySQL 命令行中执行：
            • INSERT INTO `app01_emp` (`id`, `name`, `age`, `salary`, `dep`, `province`) VALUES ('1', '令狐冲', '24', '6000.00', '销售部', '河南'); INSERT INTO `app01_emp` (`id`, `name`, `age`, `salary`, `dep`, `province`) VALUES ('2', '任盈盈', '18', '8000.00', '关公部', '广东'); INSERT INTO `app01_emp` (`id`, `name`, `age`, `salary`, `dep`, `province`) VALUES ('3', '任我行', '56', '10000.00', '销售部', '广东'); INSERT INTO `app01_emp` (`id`, `name`, `age`, `salary`, `dep`, `province`) VALUES ('4', '岳灵珊', '19', '6000.00', '关公部', '河南'); INSERT INTO `app01_emp` (`id`, `name`, `age`, `salary`, `dep`, `province`) VALUES ('5', '小龙女', '20', '8000.00', '关公部', '河北'); INSERT INTO `app01_dep` (`id`, `title`) VALUES ('1', '销售部'); INSERT INTO `app01_dep` (`id`, `title`) VALUES ('2', '关公部'); INSERT INTO `app01_emps` (`id`, `name`, `age`, `salary`, `province`, `dep_id`) VALUES ('2', '令狐冲', '24', '8000.00', '河南', '1'); INSERT INTO `app01_emps` (`id`, `name`, `age`, `salary`, `province`, `dep_id`) VALUES ('3', '任盈盈', '18', '9000.00', '广东', '2'); INSERT INTO `app01_emps` (`id`, `name`, `age`, `salary`, `province`, `dep_id`) VALUES ('4', '任我行', '57', '10000.00', '广东', '1'); INSERT INTO `app01_emps` (`id`, `name`, `age`, `salary`, `province`, `dep_id`) VALUES ('5', '岳灵珊', '19', '6000.00', '河南', '2'); INSERT INTO `app01_emps` (`id`, `name`, `age`, `salary`, `province`, `dep_id`) VALUES ('6', '小龙女', '20', '8000.00', '河北', '2');
        • 统计每一个出版社的最便宜的书的价格：
          • 实例
            • res = models.Publish.objects.values("name").annotate(in_price = Min("book__price")) print(res)
          • 命令行中可以看到以下输出：
            • <QuerySet [{'name': '菜鸟出版社', 'in_price': Decimal('100.00')}, {'name': '明教出版社', 'in_price': Decimal('300.00')}]>
          • 
            • 
        • 统计每一本书的作者个数：
          • 实例
            • res = models.Book.objects.annotate(c = Count("authors__name")).values("title","c") print(res)
        • 命令行中可以看到以下输出：
          • <QuerySet [{'title': '菜鸟教程', 'c': 1}, {'title': '吸星大法', 'c': 1}, {'title': '冲灵剑法', 'c': 1}]>
          • 
            • 
        • 统计每一本以"菜"开头的书籍的作者个数：
          • 实例
            • res = models.Book.objects.filter(title__startswith="菜").annotate(c = Count("authors__name")).values("title","c") print(res)
          • 
            • 
        • 统计不止一个作者的图书名称：
          • 实例
            • res = models.Book.objects.annotate(c = Count("authors__name")).filter(c__gt=0).values("title","c") print(res)
          • 命令行中可以看到以下输出：
            • <QuerySet [{'title': '菜鸟教程', 'c': 1}, {'title': '吸星大法', 'c': 1}, {'title': '冲灵剑法', 'c': 1}]>
          • 
            • 
        • 根据一本图书作者数量的多少对查询集 QuerySet 进行降序排序:
          • 实例
            • res = models.Book.objects.annotate(c = Count("authors__name")).order_by("-c").values("title","c") print(res)
          • 
            • 
        • 查询各个作者出的书的总价格:
          • 实例
            • res = models.Author.objects.annotate(all = Sum("book__price")).values("name","all") print(res)
      • F() 查询
        • F() 的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
        • 之前构造的过滤器都只是将字段值与某个常量做比较，如果想要对两个字段的值做比较，就需要用到 F()。
        • 使用前要先从 django.db.models 引入 F:
          • from django.db.models import F
        • 用法：
          • F("字段名称")
        • F 动态获取对象字段的值，可以进行运算。
        • Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取余的操作。
        • 修改操作（update）也可以使用 F() 函数。
        • 查询工资大于年龄的人：
          • 实例
            • from django.db.models import F ... book=models.Emp.objects.filter(salary__gt=F("age")).values("name","age") ...
        • 将每一本书的价格提高100元:
          • 实例
            • res = models.Book.objects.update(price=F("price")+100) print(res)
          • 
            • 
      • Q() 查询
        • 使用前要先从 django.db.models 引入 Q:
          • from django.db.models import Q
        • 用法：
          • Q(条件判断)
        • 例如：
          • Q(title__startswith="菜")
        • 之前构造的过滤器里的多个条件的关系都是 and，如果需要执行更复杂的查询（例如 or 语句），就可以使用 Q 。
        • Q 对象可以使用 & | ~ （与 或 非）操作符进行组合。
        • 优先级从高到低：~ & |。
        • 可以混合使用 Q 对象和关键字参数，Q 对象和关键字参数是用"and"拼在一起的（即将逗号看成 and ），但是 Q 对象必须位于所有关键字参数的前面。
        • 查询价格大于 350 或者名称以菜开头的书籍的名称和价格。
        • from django.db.models import Q
          • 实例
            • ... res=models.Book.objects.filter(Q(price__gt=350)|Q(title__startswith="菜")).values("title","price") print(res) ...
        • 查询以"菜"结尾或者不是 2010 年 10 月份的书籍:
          • 实例
            • res = models.Book.objects.filter(Q(title__endswith="菜") | ~Q(Q(pub_date__year=2010) & Q(pub_date__month=10))) print(res)
        • 查询出版日期是 2004 或者 1999 年，并且书名中包含有"菜"的书籍。
        • Q 对象和关键字混合使用，Q 对象要在所有关键字的前面:
          • 实例
            • res = models.Book.objects.filter(Q(pub_date__year=2004) | Q(pub_date__year=1999), title__contains="菜") print(res)
  • Django Form 组件
    • Django Form 组件用于对页面进行初始化，生成 HTML 标签，此外还可以对用户提交对数据进行校验（显示错误信息）。
    • 报错信息显示顺序：
      • 先显示字段属性中的错误信息，然后再显示局部钩子的错误信息。
      • 若显示了字段属性的错误信息，就不会显示局部钩子的错误信息。
      • 若有全局钩子，则全局钩子是等所有的数据都校验完，才开始进行校验，并且全局钩子的错误信息一定会显示。
    • 使用 Form 组件，需要先导入 forms：
      • from django import forms
    • 
    • 接下来我们在 app01 目录下创建一个 My_forms.py:
      • app01/My_forms.py
        • from django import forms from django.core.exceptions import ValidationError from app01 import models class EmpForm(forms.Form): name = forms.CharField(min_length=4, label="姓名", error_messages={"min_length": "你太短了", "required": "该字段不能为空!"}) age = forms.IntegerField(label="年龄") salary = forms.DecimalField(label="工资")
    • 字段属性：
      • label：输入框前面的文本信息。
      • error_message：自定义显示的错误信息，属性值是字典， 其中 required 为设置不能为空时显示的错误信息的 key。
      • app01/views.py
        • from django.shortcuts import render, HttpResponse from app01.My_Forms import EmpForm from app01 import models from django.core.exceptions import ValidationError # Create your views here. def add_emp(request): if request.method == "GET": form = EmpForm() return render(request, "add_emp.html", {"form": form}) else: form = EmpForm(request.POST) if form.is_valid(): # 进行数据校验 # 校验成功 data = form.cleaned_data # 校验成功的值，会放在cleaned_data里。 data.pop('r_salary') print(data) models.Emp.objects.create(**data) return HttpResponse( 'ok' ) # return render(request, "add_emp.html", {"form": form}) else: print(form.errors) # 打印错误信息 clean_errors = form.errors.get("__all__") print(222, clean_errors) return render(request, "add_emp.html", {"form": form, "clean_errors": clean_errors})
    • app01/urls.py 文件添加以下规则：
      • path('add_emp/', views.add_emp)
    • HTML 模版：
      • app01/add_emp.html
        • <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title></title> </head> <body> <h3>添加员工</h3> {#1、自己手动写HTML页面#} <form action="" method="post"> <p>姓名：<input type="text" name="name"></p> <p>年龄：<input type="text" name="age"></p> <p>工资：<input type="text" name="salary"></p> <input type="submit"> </form> {#2、通过form对象的as_p方法实现#} {#<form action="" method="post" novalidate>#} {# {% csrf_token %}#} {# {{ form.as_p }}#} {# <input type="submit">#} {#</form>#} {#3、手动获取form对象的字段#} {#<form action="" method="post" novalidate>#} {# {% csrf_token %}#} {# <div>#} {# <label for="id_{{ form.name.name }}">姓名</label>#} {# {{ form.name }} <span>{{ form.name.errors.0 }}</span>#} {# </div>#} {# <div>#} {# <label for="id_{{ form.age.name }}">年龄</label>#} {# {{ form.age }} <span>{{ form.age.errors.0 }}</span>#} {# </div>#} {# <div>#} {# <label for="id_salary">工资</label>#} {# {{ form.salary }} <span>{{ form.salary.errors.0 }}</span>#} {# </div>#} {# <input type="submit">#} {#</form>#} {#4、用for循环展示所有字段#} {#<form action="" method="post" novalidate>#} {# {% csrf_token %}#} {# {% for field in form %}#} {# <div>#} {# <label for="id_{{ field.name }}">{{ field.label }}</label>#} {# {{ field }} <span>{{ field.errors.0 }}</span>#} {# </div>#} {# {% endfor %}#} {# <input type="submit">#} {#</form>#} </body> </html>
    • 运行结果如下图所示：
      • 
        • 
    • 局部钩子和全局钩子
      • 定义 Form 类:
        • app01/My_forms.py
          • from django import forms from django.core.exceptions import ValidationError from app01 import models class EmpForm(forms.Form): name = forms.CharField(min_length=5, label="姓名", error_messages={"required": "该字段不能为空!", "min_length": "用户名太短。"}) age = forms.IntegerField(label="年龄") salary = forms.DecimalField(max_digits=5, decimal_places=2, label="工资") r_salary = forms.DecimalField(max_digits=5, decimal_places=2, label="请再输入工资") def clean_name(self): # 局部钩子 val = self.cleaned_data.get("name") if val.isdigit(): raise ValidationError("用户名不能是纯数字") elif models.Emp.objects.filter(name=val): raise ValidationError("用户名已存在！") else: return val def clean(self): # 全局钩子 确认两次输入的工资是否一致。 val = self.cleaned_data.get("salary") r_val = self.cleaned_data.get("r_salary") if val == r_val: return self.cleaned_data else: raise ValidationError("请确认工资是否一致。")
      • views.py 文件代码：
        • app01/views.py
          • def add_emp(request): if request.method == "GET": form = EmpForm() # 初始化form对象 return render(request, "add_emp.html", {"form":form}) else: form = EmpForm(request.POST) # 将数据传给form对象 if form.is_valid(): # 进行校验 data = form.cleaned_data data.pop("r_salary") models.Emp.objects.create(**data) return redirect("/index/") else: # 校验失败 clear_errors = form.errors.get("__all__") # 获取全局钩子错误信息 return render(request, "add_emp.html", {"form": form, "clear_errors": clear_errors})
      • 模板文件代码如下：
        • app01/add_emp.html
          • <form action="" method="post" novalidate> {% csrf_token %} <div> <label for="id_{{ form.name.name }}">姓名</label> {{ form.name }} <span>{{ form.name.errors.0 }}</span> </div> <div> <label for="id_{{ form.age.name }}">年龄</label> {{ form.age }} <span>{{ form.age.errors.0 }}</span> </div> <div> <label for="id_salary">工资</label> {{ form.salary }} <span>{{ form.salary.errors.0 }}{{ clear_errors.0 }}</span> </div> <div> <label for="id_r_salary">请再输入工资</label> {{ form.r_salary }} <span>{{ form.r_salary.errors.0 }}{{ clear_errors.0 }}</span> </div> <input type="submit"> </form>
      • 运行结果如下图所示：
        • 
          • 
            • 
        • 
  • Django 用户认证（Auth）组件
    • Django 用户认证（Auth）组件一般用在用户的登录注册上，用于判断当前的用户是否合法，并跳转到登陆成功或失败页面。
    • Django 用户认证（Auth）组件需要导入 auth 模块:
      • # 认证模块 from django.contrib import auth # 对应数据库 from django.contrib.auth.models import User
    • 返回值是用户对象。
    • 创建用户对象的三种方法：
      • create()：创建一个普通用户，密码是明文的。
      • create_user()：创建一个普通用户，密码是密文的。
      • create_superuser()：创建一个超级用户，密码是密文的，要多传一个邮箱 email 参数。
    • 参数：
      • username: 用户名。
      • password：密码。
      • email：邮箱 (create_superuser 方法要多加一个 email)。
        • from django.contrib.auth.models import User User.objects.create(username='runboo',password='123')
      • 
        • 
      • from django.contrib.auth.models import User User.objects.create_user(username='runbooo',password='123')
      • 
        • 
      • from django.contrib.auth.models import User User.objects.create_superuser(username='runboooo',password='123',email='[e-mail]')
      • 
        • 
      • 验证用户的用户名和密码使用 authenticate() 方法，从需要 auth_user 表中过滤出用户对象。
      • 使用前要导入：
        • from django.contrib import auth
      • 参数：
        • username：用户名
        • password：密码
      • 返回值：如果验证成功，就返回用户对象，反之，返回 None。
      • 实例
        • def login(request): if request.method == "GET": return render(request, "login.html") username = request.POST.get("username") password = request.POST.get("pwd") valid_num = request.POST.get("valid_num") keep_str = request.session.get("keep_str") if keep_str.upper() == valid_num.upper(): user_obj = auth.authenticate(username=username, password=password) print(user_obj.username)
      • 
        • 
          • 
      • 给验证成功的用户加 session，将 request.user 赋值为用户对象。
      • 登陆使用 login() 方法。
      • 使用前要导入：
        • from django.contrib import auth
      • 参数：
        • request：用户对象
      • 返回值：None
      • 实例
        • def login(request): if request.method == "GET": return render(request, "login.html") username = request.POST.get("username") password = request.POST.get("pwd") valid_num = request.POST.get("valid_num") keep_str = request.session.get("keep_str") if keep_str.upper() == valid_num.upper(): user_obj = auth.authenticate(username=username, password=password) print(user_obj.username) if not user_obj: return redirect("/login/") else: auth.login(request, user_obj) path = request.GET.get("next") or "/index/" print(path) return redirect(path) else: return redirect("/login/")
      • 
      • 注销用户使用 logout() 方法，需要清空 session 信息，将 request.user 赋值为匿名用户。
      • 使用前要导入：
        • from django.contrib import auth
      • 参数：
        • request：用户对象
      • 返回值：None
      • 实例
        • def logout(request): ppp = auth.logout(request) print(ppp) # None return redirect("/login/")
      • 设置装饰器，给需要登录成功后才能访问的页面统一加装饰器。
      • 使用前要导入：
        • from django.contrib.auth.decorators import login_required
      • 实例
        • from django.contrib.auth.decorators import login_required @login_required def index(request): return HttpResponse("index页面。。。")
      • 设置从哪个页面访问，登录成功后就返回哪个页面。
      • 解析：
        • django 在用户访问页面时，如果用户是未登录的状态，就给用户返回登录页面。
        • 此时，该登录页面的 URL 后面有参数：next=用户访问的页面的 URL。
        • 因此，设置在用户登录成功后重定向的 URL 为 next 参数的值。
        • 但是，若用户一开始就输入登录页面 logi，request.GET.get("next") 就取不到值，所以在后面加 or，可以设置自定义返回的页面。
        • 实例
          • # 如果直接输入 login、get() 就取不到值，path 可以自定义设置返回的页面 path = request.GET.get("next") or "/index/" return redirect(path)
        • 
  • Django cookie 与 session
    • Cookie 是存储在客户端计算机上的文本文件，并保留了各种跟踪信息。
    • 识别返回用户包括三个步骤：
      • 服务器脚本向浏览器发送一组 Cookie。例如：姓名、年龄或识别号码等。
      • 浏览器将这些信息存储在本地计算机上，以备将来使用。
      • 当下一次浏览器向 Web 服务器发送任何请求时，浏览器会把这些 Cookie 信息发送到服务器，服务器将使用这些信息来识别用户。
    • HTTP 是一种"无状态"协议，这意味着每次客户端检索网页时，客户端打开一个单独的连接到 Web 服务器，服务器会自动不保留之前客户端请求的任何记录。
    • 但是仍然有以下三种方式来维持 Web 客户端和 Web 服务器之间的 session 会话：
    • Cookies
      • 一个 Web 服务器可以分配一个唯一的 session 会话 ID 作为每个 Web 客户端的 cookie，对于客户端的后续请求可以使用接收到的 cookie 来识别。
      • 在Web开发中，使用 session 来完成会话跟踪，session 底层依赖 Cookie 技术。
      • 
      • Django 中 Cookie 的语法
        • 设置 cookie:
          • rep.set_cookie(key,value,...) rep.set_signed_cookie(key,value,salt='加密盐',...)
      • 获取 cookie:
        • request.COOKIES.get(key)
      • 删除 cookie:
        • rep =HttpResponse || render || redirect rep.delete_cookie(key)
      • 
    • 创建应用和模型
      • models.py
        • class UserInfo(models.Model): username = models.CharField(max_length=32) password = models.CharField(max_length=64)
      • 
      • urls.py
        • from django.contrib import admin from django.urls import path from cookie import views urlpatterns = [ path('admin/', admin.site.urls), path('login/', views.login), path('index/', views.index), path('logout/', views.logout), path('order/', views.order)
      • 
      • views.py
        • def login(request): if request.method == "GET": return render(request, "login.html") username = request.POST.get("username") password = request.POST.get("pwd") user_obj = models.UserInfo.objects.filter(username=username, password=password).first() print(user_obj.username) if not user_obj: return redirect("/login/") else: rep = redirect("/index/") rep.set_cookie("is_login", True) return rep def index(request): print(request.COOKIES.get('is_login')) status = request.COOKIES.get('is_login') # 收到浏览器的再次请求,判断浏览器携带的cookie是不是登录成功的时候响应的 cookie if not status: return redirect('/login/') return render(request, "index.html") def logout(request): rep = redirect('/login/') rep.delete_cookie("is_login") return rep # 点击注销后执行,删除cookie,不再保存用户状态，并弹到登录页面 def order(request): print(request.COOKIES.get('is_login')) status = request.COOKIES.get('is_login') if not status: return redirect('/login/') return render(request, "order.html")
      • 以下创建三个模板文件：login.html、index.html、order.html。
        • login.html
          • <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h3>用户登录</h3> <form action="" method="post"> {% csrf_token %} <p>用户名： <input type="text" name="username"></p> <p>密码： <input type="password" name="pwd"></p> <input type="submit"> </form> </body> </html>
        • index.html
          • <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h2>index 页面。。。</h2> <a href="/logout/">注销</a> </body> </html>
        • order.html
          • <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h2>order 页面。。。</h2> <a href="/logout/">注销</a> </body> </html>
        • 运行结果如下图所示：
          • 
            • 
        • Session(保存在服务端的键值对)
          • 服务器在运行时可以为每一个用户的浏览器创建一个其独享的 session 对象，由于 session 为用户浏览器独享，所以用户在访问服务器的 web 资源时，可以把各自的数据放在各自的 session 中，当用户再去访问该服务器中的其它 web 资源时，其它 web 资源再从用户各自的 session 中取出数据为用户服务。
          • 
          • 工作原理
            • a. 浏览器第一次请求获取登录页面 login。
            • b. 浏览器输入账号密码第二次请求，若输入正确，服务器响应浏览器一个 index 页面和一个键为 sessionid，值为随机字符串的 cookie，即 set_cookie ("sessionid",随机字符串)。
            • c. 服务器内部在 django.session 表中记录一条数据。
              • django.session 表中有三个字段。
                • session_key：存的是随机字符串，即响应给浏览器的 cookie 的 sessionid 键对应的值。
                • session_data：存的是用户的信息，即多个 request.session["key"]=value，且是密文。
                • expire_date：存的是该条记录的过期时间（默认14天）
            • d. 浏览器第三次请求其他资源时，携带 cookie :{sessionid:随机字符串}，服务器从 django.session 表中根据该随机字符串取出该用户的数据，供其使用（即保存状态）。
            • 注意: django.session 表中保存的是浏览器的信息，而不是每一个用户的信息。 因此， 同一浏览器多个用户请求只保存一条记录（后面覆盖前面）,多个浏览器请求才保存多条记录。
            • cookie 弥补了 http 无状态的不足，让服务器知道来的人是"谁"，但是 cookie 以文本的形式保存在浏览器端，安全性较差，且最大只支持 4096 字节，所以只通过 cookie 识别不同的用户，然后，在对应的 session 里保存私密的信息以及超过 4096 字节的文本。
            • session 设置：
              • request.session["key"] = value
            • 执行步骤：
              • a. 生成随机字符串
              • b. 把随机字符串和设置的键值对保存到 django_session 表的 session_key 和 session_data 里
              • c. 设置 cookie：set_cookie("sessionid",随机字符串) 响应给浏览器
              • session 获取：
                • request.session.get('key')
            • 执行步骤：
              • a. 从 cookie 中获取 sessionid 键的值，即随机字符串。
              • b. 根据随机字符串从 django_session 表过滤出记录。
              • c. 取出 session_data 字段的数据。
            • session 删除，删除整条记录（包括 session_key、session_data、expire_date 三个字段）：
              • request.session.flush()
            • 删除 session_data 里的其中一组键值对：
              • del request.session["key"]
            • 执行步骤：
              • a. 从 cookie 中获取 sessionid 键的值，即随机字符串
              • b. 根据随机字符串从 django_session 表过滤出记录
              • c. 删除过滤出来的记录
            • 实例
              • 创建路由:
                • urls.py
                  • from session import views as session_views urlpatterns = [ path('session_login/', session_views.login), path('s_index/', session_views.s_index), path('s_logout/', session_views.s_logout), ]
                • 
              • 创建视图函数:
                • views.py
                  • def login(request): if request.method == "GET": return render(request, "login.html") username = request.POST.get("username") password = request.POST.get("pwd") user_obj = models.UserInfo.objects.filter(username=username, password=password).first() print(user_obj.username) if not user_obj: return redirect("/session_login/") else: request.session['is_login'] = True request.session['user1'] = username return redirect("/s_index/") def s_index(request): status = request.session.get('is_login') if not status: return redirect('/session_login/') return render(request, "s_index.html") def s_logout(request): # del request.session["is_login"] # 删除session_data里的一组键值对 request.session.flush() # 删除一条记录包括(session_key session_data expire_date)三个字段 return redirect('/session_login/')
              • 模板文件：
                • s_index.html
                  • <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h2>session_index 页面。。。{{ request.session.user1 }}</h2> <a href="/s_logout/">注销</a> </body> </html>
                • 
                  • 
  • Django 中间件
    • Django 中间件是修改 Django request 或者 response 对象的钩子，可以理解为是介于 HttpRequest 与 HttpResponse 处理之间的一道处理过程。 浏览器从请求到响应的过程中，Django 需要通过很多中间件来处理，可以看如下图所示：
      • 
    • Django 中间件作用：
      • 修改请求，即传送到 view 中的 HttpRequest 对象。
      • 修改响应，即 view 返回的 HttpResponse 对象。
    • 中间件组件配置在 settings.py 文件的 MIDDLEWARE 选项列表中。
    • 配置中的每个字符串选项都是一个类，也就是一个中间件。
    • Django 默认的中间件配置：
      • MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ]
    • 自定义中间件
      • 中间件可以定义四个方法，分别是：
        • process_request(self,request) process_view(self, request, view_func, view_args, view_kwargs) process_exception(self, request, exception) process_response(self, request, response)
    • 自定义中间的步骤：
      • 在 app 目录下新建一个 py 文件，名字自定义，并在该 py 文件中导入 MiddlewareMixin：
        • from django.utils.deprecation import MiddlewareMixin
      • 
      • 自定义的中间件类，要继承父类 MiddlewareMixin:
        • class MD1(MiddlewareMixin): pass
      • 在 settings.py 中的 MIDDLEWARE 里注册自定义的中间件类:
        • MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'app01.middlewares.MD1', ]
    • 自定义中间件类的方法
      • 自定义中间件类的方法有：process_request 和 process_response。
        • 
      • process_request 方法
        • process_request 方法有一个参数 request，这个 request 和视图函数中的 request 是一样的。
        • process_request 方法的返回值可以是 None 也可以是 HttpResponse 对象。
          • 返回值是 None 的话，按正常流程继续走，交给下一个中间件处理。
          • 返回值是 HttpResponse 对象，Django 将不执行后续视图函数之前执行的方法以及视图函数，直接以该中间件为起点，倒序执行中间件，且执行的是视图函数之后执行的方法。
        • process_request 方法是在视图函数之前执行的。
        • 当配置多个中间件时，会按照 MIDDLEWARE中 的注册顺序，也就是列表的索引值，顺序执行。
        • 不同中间件之间传递的 request 参数都是同一个请求对象。
        • 实例
          • from django.utils.deprecation import MiddlewareMixin from django.shortcuts import render, HttpResponse class MD1(MiddlewareMixin): def process_request(self, request): print("md1 process_request 方法。", id(request)) #在视图之前执行
          • 
      • process_response
        • process_response 方法有两个参数，一个是 request，一个是 response，request 是请求对象，response 是视图函数返回的 HttpResponse 对象，该方法必须要有返回值，且必须是response。
        • process_response 方法是在视图函数之后执行的。
        • 当配置多个中间件时，会按照 MIDDLEWARE 中的注册顺序，也就是列表的索引值，倒序执行。
        • 实例
          • class MD1(MiddlewareMixin): def process_request(self, request): print("md1 process_request 方法。", id(request)) #在视图之前执行 def process_response(self,request, response): :#基于请求响应 print("md1 process_response 方法！", id(request)) #在视图之后 return response
        • 从下图看，正常的情况下按照绿色的路线进行执行,假设中间件1有返回值，则按照红色的路线走，直接执行该类下的 process_response 方法返回，后面的其他中间件就不会执行。
        • 
      • process_view
      • process_view 方法格式如下：
        • process_view(request, view_func, view_args, view_kwargs)
      • process_view 方法有四个参数：
        • request 是 HttpRequest 对象。
        • view_func 是 Django 即将使用的视图函数。
        • view_args 是将传递给视图的位置参数的列表。
        • view_kwargs 是将传递给视图的关键字参数的字典。
      • view_args 和 view_kwargs 都不包含第一个视图参数（request）。
      • process_view 方法是在视图函数之前，process_request 方法之后执行的。
      • 返回值可以是 None、view_func(request) 或 HttpResponse 对象。
        • 返回值是 None 的话，按正常流程继续走，交给下一个中间件处理。
        • 返回值是 HttpResponse 对象，Django 将不执行后续视图函数之前执行的方法以及视图函数，直接以该中间件为起点，倒序执行中间件，且执行的是视图函数之后执行的方法。
        • c.返回值是 view_func(request)，Django 将不执行后续视图函数之前执行的方法，提前执行视图函数，然后再倒序执行视图函数之后执行的方法。
        • 当最后一个中间件的 process_request 到达路由关系映射之后，返回到第一个中间件 process_view，然后依次往下，到达视图函数。
        • 实例
          • class MD1(MiddlewareMixin): def process_request(self, request): print("md1 process_request 方法。", id(request)) #在视图之前执行 def process_response(self,request, response): :#基于请求响应 print("md1 process_response 方法！", id(request)) #在视图之后 return response def process_view(self,request, view_func, view_args, view_kwargs): print("md1 process_view 方法！") #在视图之前执行 顺序执行 #return view_func(request)
          • 
            • 
        • 
        • process_exception
          • process_exception 方法如下：
            • process_exception(request, exception)
          • 参数说明：
            • request 是 HttpRequest 对象。
            • exception 是视图函数异常产生的 Exception 对象。
          • process_exception 方法只有在视图函数中出现异常了才执行，按照 settings 的注册倒序执行。
          • 在视图函数之后，在 process_response 方法之前执行。
          • process_exception 方法的返回值可以是一个 None 也可以是一个 HttpResponse 对象。
          • 返回值是 None，页面会报 500 状态码错误，视图函数不会执行。
          • process_exception 方法倒序执行，然后再倒序执行 process_response 方法。
          • 返回值是 HttpResponse 对象，页面不会报错，返回状态码为 200。
          • 视图函数不执行，该中间件后续的 process_exception 方法也不执行，直接从最后一个中间件的 process_response 方法倒序开始执行。
          • 若是 process_view 方法返回视图函数，提前执行了视图函数，且视图函数报错，则无论 process_exception 方法的返回值是什么，页面都会报错， 且视图函数和 process_exception 方法都不执行。
          • 直接从最后一个中间件的 process_response 方法开始倒序执行：
          • 实例
            • class MD1(MiddlewareMixin): def process_request(self, request): print("md1 process_request 方法。", id(request)) #在视图之前执行 def process_response(self,request, response): :#基于请求响应 print("md1 process_response 方法！", id(request)) #在视图之后 return response def process_view(self,request, view_func, view_args, view_kwargs): print("md1 process_view 方法！") #在视图之前执行 顺序执行 #return view_func(request) def process_exception(self, request, exception):#引发错误 才会触发这个方法 print("md1 process_exception 方法！") # return HttpResponse(exception) #返回错误信息
            • 
              • 
  • Django 视图 - FBV 与 CBV
    • FBV（function base views） 基于函数的视图，就是在视图里使用函数处理请求。
    • CBV（class base views） 基于类的视图，就是在视图里使用类处理请求。
    • FBV
      • 基于函数的视图其实我们前面章节一直在使用，就是使用了函数来处理用户的请求，查看以下实例：
      • 路由配置：
        • urls.py 文件
          • urlpatterns = [ path("login/", views.login), ]
        • views.py 文件
          • from django.shortcuts import render,HttpResponse def login(request): if request.method == "GET": return HttpResponse("GET 方法") if request.method == "POST": user = request.POST.get("user") pwd = request.POST.get("pwd") if user == "runoob" and pwd == "123456": return HttpResponse("POST 方法") else: return HttpResponse("POST 方法1")
        • 如果我们在浏览器中直接访问 http://127.0.0.1:8000/login/ ，输出结果为：
          • GET 方法
    • CBV
      • 基于类的视图，就是使用了类来处理用户的请求，不同的请求我们可以在类中使用不同方法来处理，这样大大的提高了代码的可读性。
      • 定义的类要继承父类 View，所以需要先引入库：
        • from django.views import View
      • 执行对应请求的方法前会优先执行 dispatch 方法(在get/post/put...方法前执行)，dispatch() 方法会根据请求的不同调用相应的方法来处理。
      • 其实，在我们前面学到的知识都知道 Django 的 url 是将一个请求分配给可调用的函数的，而不是一个类，那是如何实现基于类的视图的呢？ 主要还是通过父类 View 提供的一个静态方法 as_view() ，as_view 方法是基于类的外部接口， 他返回一个视图函数，调用后请求会传递给 dispatch 方法，dispatch 方法再根据不同请求来处理不同的方法。
      • 路由配置：
        • urls.py 文件
          • urlpatterns = [ path("login/", views.Login.as_view()), ]
        • views.py 文件
          • from django.shortcuts import render,HttpResponse from django.views import View class Login(View): def get(self,request): return HttpResponse("GET 方法") def post(self,request): user = request.POST.get("user") pwd = request.POST.get("pwd") if user == "runoob" and pwd == "123456": return HttpResponse("POST 方法") else: return HttpResponse("POST 方法 1")
        • 如果我们在浏览器中直接访问 http://127.0.0.1:8000/login/ ，输出结果为：
          • GET 方法
  • Django Nginx+uwsgi 安装配置
    • 在前面的章节中我们使用 python manage.py runserver 来运行服务器。这只适用测试环境中使用。
    • 正式发布的服务，我们需要一个可以稳定而持续的服务器，比如apache, Nginx, lighttpd等，本文将以 Nginx 为例。
      • 你也可以直接参考：Python uwsgi 安装配置
    • 安装基础开发包
      • Centos 下安装步骤如下：
        • yum groupinstall "Development tools" yum install zlib-devel bzip2-devel pcre-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel
      • CentOS 自带 Python 2.4.3，但我们可以再安装Python2.7.5：
        • cd ~ wget http://python.org/ftp/python/2.7.5/Python-2.7.5.tar.bz2 tar xvf Python-2.7.5.tar.bz2 cd Python-2.7.5 ./configure --prefix=/usr/local make && make altinstall
      • 安装Python包管理
        • easy_install 包 https://pypi.python.org/pypi/distribute
        • 安装步骤:
          • cd ~ wget https://pypi.python.org/packages/source/d/distribute/distribute-0.6.49.tar.gz tar xf distribute-0.6.49.tar.gz cd distribute-0.6.49 python2.7 setup.py install easy_install --version
        • pip 包: https://pypi.python.org/pypi/pip
        • 安装 pip 的好处是可以用 pip list、pip uninstall 管理 Python 包， easy_install 没有这个功能，只有 uninstall。
      • 安装 uwsgi
        • uwsgi:https://pypi.python.org/pypi/uWSGI
        • uwsgi 参数详解：http://uwsgi-docs.readthedocs.org/en/latest/Options.html
        • pip install uwsgi uwsgi --version # 查看 uwsgi 版本
        • 测试 uwsgi 是否正常：
        • 新建 test.py 文件，内容如下：
          • def application(env, start_response): start_response('200 OK', [('Content-Type','text/html')]) return "Hello World"
        • 然后在终端运行：
          • uwsgi --http :8001 --wsgi-file test.py
        • 在浏览器内输入：http://127.0.0.1:8001，查看是否有"Hello World"输出，若没有输出，请检查你的安装过程。
      • 安装 Django
        • pip install django
        • 测试 django 是否正常，运行：
          • django-admin.py startproject demosite cd demosite python2.7 manage.py runserver 0.0.0.0:8002
        • 在浏览器内输入：http://127.0.0.1:8002，检查django是否运行正常。
      • 安装 Nginx
        • 安装命令如下：
          • cd ~ wget http://nginx.org/download/nginx-1.5.6.tar.gz tar xf nginx-1.5.6.tar.gz cd nginx-1.5.6 ./configure --prefix=/usr/local/nginx-1.5.6 \ --with-http_stub_status_module \ --with-http_gzip_static_module make && make install
        • 你可以阅读 Nginx 安装配置 了解更多内容。
      • uwsgi 配置
        • uwsgi支持ini、xml等多种配置方式，本文以 ini 为例， 在/etc/目录下新建uwsgi9090.ini，添加如下配置：
        • [uwsgi] socket = 127.0.0.1:9090 master = true //主进程 vhost = true //多站模式 no-site = true //多站模式时不设置入口模块和文件 workers = 2 //子进程数 reload-mercy = 10 vacuum = true //退出、重启时清理文件 max-requests = 1000 limit-as = 512 buffer-size = 30000 pidfile = /var/run/uwsgi9090.pid //pid文件，用于下面的脚本启动、停止该进程 daemonize = /website/uwsgi9090.log
      • Nginx 配置
        • 找到nginx的安装目录（如：/usr/local/nginx/），打开conf/nginx.conf文件，修改server配置：
          • server { listen 80; server_name localhost; location / { include uwsgi_params; uwsgi_pass 127.0.0.1:9090; //必须和uwsgi中的设置一致 uwsgi_param UWSGI_SCRIPT demosite.wsgi; //入口文件，即wsgi.py相对于项目根目录的位置，“.”相当于一层目录 uwsgi_param UWSGI_CHDIR /demosite; //项目根目录 index index.html index.htm; client_max_body_size 35m; } }
        • 你可以阅读 Nginx 安装配置 了解更多内容。
        • 设置完成后，在终端运行：
          • uwsgi --ini /etc/uwsgi9090.ini & /usr/local/nginx/sbin/nginx
        • 在浏览器输入：http://127.0.0.1，你就可以看到 django 的 "It work" 了。
• python算法
• 外用模块包
  • NumPy 教程
    • NumPy Ndarray 对象
      • NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
      • ndarray 对象是用于存放同类型元素的多维数组。
      • ndarray 中的每个元素在内存中都有相同存储大小的区域。
      • ndarray 内部由以下内容组成：
        • 一个指向数据（内存或内存映射文件中的一块数据）的指针。
        • 数据类型或 dtype，描述在数组中的固定大小值的格子。
        • 一个表示数组形状（shape）的元组，表示各维度大小的元组。
        • 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。
      • ndarray 的内部结构:
        • 
        • 跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。
        • 创建一个 ndarray 只需调用 NumPy 的 array 函数即可：
          • numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
      • 参数说明：
        • 名称 描述
        • object 数组或嵌套的数列
        • dtype 数组元素的数据类型，可选
        • copy 对象是否需要复制，可选
        • order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
        • subok 默认返回一个与基类类型一致的数组
        • ndmin 指定生成数组的最小维度
      • 实例
        • 接下来可以通过以下实例帮助我们更好的理解。
          • 实例 1
            • import numpy as np a = np.array([1,2,3]) print (a)
              • [1 2 3]
          • 实例 2
            • # 多于一个维度 import numpy as np a = np.array([[1, 2], [3, 4]]) print (a)
              • [[1 2] [3 4]]
          • 实例 3
            • # 最小维度 import numpy as np a = np.array([1, 2, 3, 4, 5], ndmin = 2) print (a)
              • [[1 2 3 4 5]]
          • 实例 4
            • # dtype 参数 import numpy as np a = np.array([1, 2, 3], dtype = complex) print (a)
              • [1.+0.j 2.+0.j 3.+0.j]
      • ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素。
    • NumPy 数据类型
      • numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型。
        • 名称 描述
        • bool_ 布尔型数据类型（True 或者 False）
        • int_ 默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
        • intc 与 C 的 int 类型一样，一般是 int32 或 int 64
        • intp 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
        • int8 字节（-128 to 127）
        • int16 整数（-32768 to 32767）
        • int32 整数（-2147483648 to 2147483647）
        • int64 整数（-9223372036854775808 to 9223372036854775807）
        • uint8 无符号整数（0 to 255）
        • uint16 无符号整数（0 to 65535）
        • uint32 无符号整数（0 to 4294967295）
        • uint64 无符号整数（0 to 18446744073709551615）
        • float_ float64 类型的简写
        • float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
        • float32 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
        • float64 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
        • complex_ complex128 类型的简写，即 128 位复数
        • complex64 复数，表示双 32 位浮点数（实数部分和虚数部分）
        • complex128 复数，表示双 64 位浮点数（实数部分和虚数部分）
      • numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。
      • 数据类型对象 (dtype)
        • 数据类型对象（numpy.dtype 类的实例）用来描述与数组对应的内存区域是如何使用，它描述了数据的以下几个方面：：
          • 数据的类型（整数，浮点数或者 Python 对象）
          • 数据的大小（例如， 整数使用多少个字节存储）
          • 数据的字节顺序（小端法或大端法）
          • 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
          • 如果数据类型是子数组，那么它的形状和数据类型是什么。
        • 字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。
        • dtype 对象是使用以下语法构造的：
          • numpy.dtype(object, align, copy)
          • object - 要转换为的数据类型对象
          • align - 如果为 true，填充字段使其类似 C 的结构体。
          • copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用
        • 实例
          • 接下来我们可以通过实例来理解。
            • 实例 1
              • import numpy as np # 使用标量类型 dt = np.dtype(np.int32) print(dt)
                • int32
            • 实例 2
              • import numpy as np # int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替 dt = np.dtype('i4') print(dt)
                • int32
            • 实例 3
              • import numpy as np # 字节顺序标注 dt = np.dtype('<i4') print(dt)
                • int32
            • 下面实例展示结构化数据类型的使用，类型字段和对应的实际类型将被创建。
            • 实例 4
              • # 首先创建结构化数据类型 import numpy as np dt = np.dtype([('age',np.int8)]) print(dt)
                • [('age', 'i1')]
            • 实例 5
              • # 将数据类型应用于 ndarray 对象 import numpy as np dt = np.dtype([('age',np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a)
                • [(10,) (20,) (30,)]
            • 实例 6
              • # 类型字段名可以用于存取实际的 age 列 import numpy as np dt = np.dtype([('age',np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print(a['age'])
                • [10 20 30]
            • 下面的示例定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 dtype 应用到 ndarray 对象。
            • 实例 7
              • import numpy as np student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) print(student)
                • [('name', 'S20'), ('age', 'i1'), ('marks', 'f4')]
            • 实例 8
              • import numpy as np student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student) print(a)
                • [('abc', 21, 50.0), ('xyz', 18, 75.0)]
            • 每个内建类型都有一个唯一定义它的字符代码，如下：
              • 字符 对应类型
              • b 布尔型
              • i (有符号) 整型
              • u 无符号整型 integer
              • f 浮点型
              • c 复数浮点型
              • m timedelta（时间间隔）
              • M datetime（日期时间）
              • O (Python) 对象
              • S, a (byte-)字符串
              • U Unicode
              • V 原始数据 (void)
    • NumPy 数组属性
      • 本章节我们将来了解 NumPy 数组的一些基本属性。
      • NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。
      • 在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。
      • 很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。
      • NumPy 的数组中比较重要 ndarray 对象属性有：
        • 属性 说明
        • ndarray.ndim 秩，即轴的数量或维度的数量
        • ndarray.shape 数组的维度，对于矩阵，n 行 m 列
        • ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值
        • ndarray.dtype ndarray 对象的元素类型
        • ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
        • ndarray.flags ndarray 对象的内存信息
        • ndarray.real ndarray元素的实部
        • ndarray.imag ndarray 元素的虚部
        • ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
      • ndarray.ndim
        • ndarray.ndim 用于返回数组的维数，等于秩。
          • 实例
            • import numpy as np a = np.arange(24) print (a.ndim) # a 现只有一个维度 # 现在调整其大小 b = a.reshape(2,4,3) # b 现在拥有三个维度 print (b.ndim)
              • 1 3
      • ndarray.shape
        • ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。
        • ndarray.shape 也可以用于调整数组大小。
          • 实例
            • import numpy as np a = np.array([[1,2,3],[4,5,6]]) print (a.shape)
              • (2, 3)
        • 调整数组大小。
          • 实例
            • import numpy as np a = np.array([[1,2,3],[4,5,6]]) a.shape = (3,2) print (a)
              • [[1 2] [3 4] [5 6]]
        • NumPy 也提供了 reshape 函数来调整数组大小。
          • 实例
            • import numpy as np a = np.array([[1,2,3],[4,5,6]]) b = a.reshape(3,2) print (b)
              • [[1, 2] [3, 4] [5, 6]]
      • ndarray.itemsize
        • ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。
        • 例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。
        • 实例
          • import numpy as np # 数组的 dtype 为 int8（一个字节） x = np.array([1,2,3,4,5], dtype = np.int8) print (x.itemsize) # 数组的 dtype 现在为 float64（八个字节） y = np.array([1,2,3,4,5], dtype = np.float64) print (y.itemsize)
            • 1 8
      • ndarray.flags
        • ndarray.flags 返回 ndarray 对象的内存信息，包含以下属性：
          • 属性 描述
          • C_CONTIGUOUS (C) 数据是在一个单一的C风格的连续段中
          • F_CONTIGUOUS (F) 数据是在一个单一的Fortran风格的连续段中
          • OWNDATA (O) 数组拥有它所使用的内存或从另一个对象中借用它
          • WRITEABLE (W) 数据区域可以被写入，将该值设置为 False，则数据为只读
          • ALIGNED (A) 数据和所有元素都适当地对齐到硬件上
          • UPDATEIFCOPY (U) 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新
        • 实例
          • import numpy as np x = np.array([1,2,3,4,5]) print (x.flags)
            • C_CONTIGUOUS : True F_CONTIGUOUS : True OWNDATA : True WRITEABLE : True ALIGNED : True WRITEBACKIFCOPY : False UPDATEIFCOPY : False
    • NumPy 创建数组
    • NumPy 从已有的数组创建数组
      • 本章节我们将学习如何从已有的数组创建数组。
      • numpy.asarray
        • numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。
        • numpy.asarray(a, dtype = None, order = None)
        • 参数说明：
          • 参数 描述
          • a 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
          • dtype 数据类型，可选
          • order 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
        • 实例
          • 将列表转换为 ndarray:
            • 实例
              • import numpy as np x = [1,2,3] a = np.asarray(x) print (a)
                • [1 2 3]
          • 将元组转换为 ndarray:
            • 实例
              • import numpy as np x = (1,2,3) a = np.asarray(x) print (a)
                • [1 2 3]
          • 将元组列表转换为 ndarray:
            • 实例
              • import numpy as np x = [(1,2,3),(4,5)] a = np.asarray(x) print (a)
                • [(1, 2, 3) (4, 5)]
          • 设置了 dtype 参数：
            • 实例
              • import numpy as np x = [1,2,3] a = np.asarray(x, dtype = float) print (a)
                • [ 1. 2. 3.]
      • numpy.frombuffer
        • numpy.frombuffer 用于实现动态数组。
        • numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。
          • numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
          • 注意：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。
        • 参数说明：
          • 参数 描述
          • buffer 可以是任意对象，会以流的形式读入。
          • dtype 返回数组的数据类型，可选
          • count 读取的数据数量，默认为-1，读取所有数据。
          • offset 读取的起始位置，默认为0。
        • Python3.x 实例
          • import numpy as np s = b'Hello World' a = np.frombuffer(s, dtype = 'S1') print (a)
            • [b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
        • Python2.x 实例
          • import numpy as np s = 'Hello World' a = np.frombuffer(s, dtype = 'S1') print (a)
            • ['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']
      • numpy.fromiter
        • numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。
        • numpy.fromiter(iterable, dtype, count=-1)
        • 参数说明：
          • 参数 描述
          • iterable 可迭代对象
          • dtype 返回数组的数据类型
          • count 读取的数据数量，默认为-1，读取所有数据
        • 实例
          • import numpy as np # 使用 range 函数创建列表对象 list=range(5) it=iter(list) # 使用迭代器创建 ndarray x=np.fromiter(it, dtype=float) print(x)
            • [0. 1. 2. 3. 4.]
    • NumPy 从数值范围创建数组
      • 这一章节我们将学习如何从数值范围创建数组。
      • numpy.arange
        • numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
          • numpy.arange(start, stop, step, dtype)
        • 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
        • 参数说明：
          • 参数 描述
          • start 起始值，默认为0
          • stop 终止值（不包含）
          • step 步长，默认为1
          • dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
        • 实例
          • 生成 0 到 5 的数组:
            • 实例
              • import numpy as np x = np.arange(5) print (x)
                • [0 1 2 3 4]
          • 设置返回类型位 float:
            • 实例
              • import numpy as np # 设置了 dtype x = np.arange(5, dtype = float) print (x)
                • [0. 1. 2. 3. 4.]
          • 设置了起始值、终止值及步长：
            • 实例
              • import numpy as np x = np.arange(10,20,2) print (x)
                • [10 12 14 16 18]
      • numpy.linspace
        • numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：
          • np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
        • 参数说明：
          • 参数 描述
          • start 序列的起始值
          • stop 序列的终止值，如果endpoint为true，该值包含于数列中
          • num 要生成的等步长的样本数量，默认为50
          • endpoint 该值为 true 时，数列中包含stop值，反之不包含，默认是True。
          • retstep 如果为 True 时，生成的数组中会显示间距，反之不显示。
          • dtype ndarray 的数据类型
        • 以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。
          • 实例
            • import numpy as np a = np.linspace(1,10,10) print(a)
              • [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
          • 设置元素全部是1的等差数列：
            • 实例
              • import numpy as np a = np.linspace(1,1,10) print(a)
                • [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
          • 将 endpoint 设为 false，不包含终止值：
            • 实例
              • import numpy as np a = np.linspace(10, 20, 5, endpoint = False) print(a)
                • [10. 12. 14. 16. 18.]
        • 如果将 endpoint 设为 true，则会包含 20。
          • 以下实例设置间距。
            • 实例
              • import numpy as np a =np.linspace(1,10,10,retstep= True) print(a) # 拓展例子 b =np.linspace(1,10,10).reshape([10,1]) print(b)
                • (array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0) [[ 1.] [ 2.] [ 3.] [ 4.] [ 5.] [ 6.] [ 7.] [ 8.] [ 9.] [10.]]
        • numpy.logspace
          • numpy.logspace 函数用于创建一个于等比数列。格式如下：
            • np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
          • base 参数意思是取对数的时候 log 的下标。
            • 参数 描述
            • start 序列的起始值为：base ** start
            • stop 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
            • num 要生成的等步长的样本数量，默认为50
            • endpoint 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
            • base 对数 log 的底数。
            • dtype ndarray 的数据类型
          • 实例
            • import numpy as np # 默认底数是 10 a = np.logspace(1.0, 2.0, num = 10) print (a)
              • [ 10. 12.91549665 16.68100537 21.5443469 27.82559402 35.93813664 46.41588834 59.94842503 77.42636827 100. ]
          • 将对数的底数设置为 2 :
            • 实例
              • import numpy as np a = np.logspace(0,9,10,base=2) print (a)
                • [ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
    • NumPy 切片和索引
      • ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。
      • ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
        • 实例
          • import numpy as np a = np.arange(10) s = slice(2,7,2) # 从索引 2 开始到索引 7 停止，间隔为2 print (a[s])
            • [2 4 6]
          • 以上实例中，我们首先通过 arange() 函数创建 ndarray 对象。 然后，分别设置起始，终止和步长的参数为 2，7 和 2。
      • 我们也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：
        • 实例
          • import numpy as np a = np.arange(10) b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2 print(b)
            • [2 4 6]
      • 冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
        • 实例
          • import numpy as np a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9] b = a[5] print(b)
            • 5
      • 实例
        • import numpy as np a = np.arange(10) print(a[2:])
          • [2 3 4 5 6 7 8 9]
      • 实例
        • import numpy as np a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9] print(a[2:5])
          • [2 3 4]
      • 多维数组同样适用上述索引提取方法：
        • 实例
          • import numpy as np a = np.array([[1,2,3],[3,4,5],[4,5,6]]) print(a) # 从某个索引处开始切割 print('从数组索引 a[1:] 处开始切割') print(a[1:])
            • [[1 2 3] [3 4 5] [4 5 6]] 从数组索引 a[1:] 处开始切割 [[3 4 5] [4 5 6]]
      • 切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。
        • 实例
          • import numpy as np a = np.array([[1,2,3],[3,4,5],[4,5,6]]) print (a[...,1]) # 第2列元素 print (a[1,...]) # 第2行元素 print (a[...,1:]) # 第2列及剩下的所有元素
            • [2 4 5] [3 4 5] [[2 3] [4 5] [5 6]]
    • NumPy 高级索引
      • NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。
      • 整数数组索引
        • 以下实例获取数组中(0,0)，(1,1)和(2,0)位置处的元素。
        • 实例
          • import numpy as np x = np.array([[1, 2], [3, 4], [5, 6]]) y = x[[0,1,2], [0,1,0]] print (y)
            • [1 4 5]
        • 以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。
          • 实例
            • import numpy as np x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]]) print ('我们的数组是：' ) print (x) print ('\n') rows = np.array([[0,0],[3,3]]) cols = np.array([[0,2],[0,2]]) y = x[rows,cols] print ('这个数组的四个角元素是：') print (y)
              • 我们的数组是： [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] 这个数组的四个角元素是： [[ 0 2] [ 9 11]]
        • 返回的结果是包含每个角元素的 ndarray 对象。
        • 可以借助切片 : 或 … 与索引数组组合。如下面例子：
          • 实例
            • import numpy as np a = np.array([[1,2,3], [4,5,6],[7,8,9]]) b = a[1:3, 1:3] c = a[1:3,[1,2]] d = a[...,1:] print(b) print(c) print(d)
              • [[5 6] [8 9]] [[5 6] [8 9]] [[2 3] [5 6] [8 9]]
      • 布尔索引
        • 我们可以通过一个布尔数组来索引目标数组。
        • 布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
        • 以下实例获取大于 5 的元素：
          • 实例
            • import numpy as np x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]]) print ('我们的数组是：') print (x) print ('\n') # 现在我们会打印出大于 5 的元素 print ('大于 5 的元素是：') print (x[x > 5])
              • 我们的数组是： [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] 大于 5 的元素是： [ 6 7 8 9 10 11]
          • 以下实例使用了 ~（取补运算符）来过滤 NaN。
            • 实例
              • import numpy as np a = np.array([np.nan, 1,2,np.nan,3,4,5]) print (a[~np.isnan(a)])
                • [ 1. 2. 3. 4. 5.]
          • 以下实例演示如何从数组中过滤掉非复数元素。
            • 实例
              • import numpy as np a = np.array([1, 2+6j, 5, 3.5+5j]) print (a[np.iscomplex(a)])
                • [2.0+6.j 3.5+5.j]
      • 花式索引
        • 花式索引指的是利用整数数组进行索引。
        • 花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应下标的行，如果目标是二维数组，那么就是对应位置的元素。
        • 花式索引跟切片不一样，它总是将数据复制到新数组中。
          • 1、传入顺序索引数组
            • 实例
              • import numpy as np x=np.arange(32).reshape((8,4)) print (x[[4,2,1,7]])
                • [[16 17 18 19] [ 8 9 10 11] [ 4 5 6 7] [28 29 30 31]]
          • 2、传入倒序索引数组
            • 实例
              • import numpy as np x=np.arange(32).reshape((8,4)) print (x[[-4,-2,-1,-7]])
                • [[16 17 18 19] [24 25 26 27] [28 29 30 31] [ 4 5 6 7]]
          • 3、传入多个索引数组（要使用np.ix_）
            • 实例
              • import numpy as np x=np.arange(32).reshape((8,4)) print (x[np.ix_([1,5,7,2],[0,3,1,2])])
                • [[ 4 7 5 6] [20 23 21 22] [28 31 29 30] [ 8 11 9 10]]
    • NumPy 广播(Broadcast)
      • 广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
      • 如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
      • 实例
        • import numpy as np a = np.array([1,2,3,4]) b = np.array([10,20,30,40]) c = a * b print (c)
          • [ 10 40 90 160]
      • 当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：
        • 实例
          • import numpy as np a = np.array([[ 0, 0, 0], [10,10,10], [20,20,20], [30,30,30]]) b = np.array([1,2,3]) print(a + b)
            • [[ 1 2 3] [11 12 13] [21 22 23] [31 32 33]]
      • 下面的图片展示了数组 b 如何通过广播来与数组 a 兼容。
        • 
      • 4x3 的二维数组与长为 3 的一维数组相加，等效于把数组 b 在二维上重复 4 次再运算：
        • 实例
          • import numpy as np a = np.array([[ 0, 0, 0], [10,10,10], [20,20,20], [30,30,30]]) b = np.array([1,2,3]) bb = np.tile(b, (4, 1)) # 重复 b 的各个维度 print(a + bb)
            • [[ 1 2 3] [11 12 13] [21 22 23] [31 32 33]]
      • 广播的规则:
        • 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
        • 输出数组的形状是输入数组形状的各个维度上的最大值。
        • 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
        • 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
      • 简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：
        • 数组拥有相同形状。
        • 当前维度的值相等。
        • 当前维度的值有一个是 1。
      • 若条件不满足，抛出 "ValueError: frames are not aligned" 异常。
    • NumPy 迭代数组
      • NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
      • 迭代器最基本的任务的可以完成对数组元素的访问。
      • 接下来我们使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代。
        • 实例
          • import numpy as np a = np.arange(6).reshape(2,3) print ('原始数组是：') print (a) print ('\n') print ('迭代输出元素：') for x in np.nditer(a): print (x, end=", " ) print ('\n')
            • 原始数组是： [[0 1 2] [3 4 5]] 迭代输出元素： 0, 1, 2, 3, 4, 5,
      • 以上实例不是使用标准 C 或者 Fortran 顺序，选择的顺序是和数组内存布局一致的，这样做是为了提升访问的效率，默认是行序优先（row-major order，或者说是 C-order）。
      • 这反映了默认情况下只需访问每个元素，而无需考虑其特定顺序。我们可以通过迭代上述数组的转置来看到这一点，并与以 C 顺序访问数组转置的 copy 方式做对比，如下实例：
        • 实例
          • import numpy as np a = np.arange(6).reshape(2,3) for x in np.nditer(a.T): print (x, end=", " ) print ('\n') for x in np.nditer(a.T.copy(order='C')): print (x, end=", " ) print ('\n')
            • 0, 1, 2, 3, 4, 5, 0, 3, 1, 4, 2, 5,
      • 从上述例子可以看出，a 和 a.T 的遍历顺序是一样的，也就是他们在内存中的存储顺序也是一样的，但是 a.T.copy(order = 'C') 的遍历结果是不同的，那是因为它和前两种的存储方式是不一样的，默认是按行访问。
      • 控制遍历顺序
        • for x in np.nditer(a, order='F'):Fortran order，即是列序优先；
        • for x in np.nditer(a.T, order='C'):C order，即是行序优先；
        • 实例
          • import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ('原始数组是：') print (a) print ('\n') print ('原始数组的转置是：') b = a.T print (b) print ('\n') print ('以 C 风格顺序排序：') c = b.copy(order='C') print (c) for x in np.nditer(c): print (x, end=", " ) print ('\n') print ('以 F 风格顺序排序：') c = b.copy(order='F') print (c) for x in np.nditer(c): print (x, end=", " )
            • 原始数组是： [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] 原始数组的转置是： [[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]] 以 C 风格顺序排序： [[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]] 0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 以 F 风格顺序排序： [[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]] 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,
        • 可以通过显式设置，来强制 nditer 对象使用某种顺序：
        • 实例
          • import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ('原始数组是：') print (a) print ('\n') print ('以 C 风格顺序排序：') for x in np.nditer(a, order = 'C'): print (x, end=", " ) print ('\n') print ('以 F 风格顺序排序：') for x in np.nditer(a, order = 'F'): print (x, end=", " )
            • 原始数组是： [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] 以 C 风格顺序排序： 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 以 F 风格顺序排序： 0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55,
      • 修改数组中元素的值
        • nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式。
        • 实例
          • import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ('原始数组是：') print (a) print ('\n') for x in np.nditer(a, op_flags=['readwrite']): x[...]=2*x print ('修改后的数组是：') print (a)
            • 原始数组是： [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] 修改后的数组是： [[ 0 10 20 30] [ 40 50 60 70] [ 80 90 100 110]]
      • 使用外部循环
        • nditer 类的构造器拥有 flags 参数，它可以接受下列值：
          • 参数 描述
          • c_index 可以跟踪 C 顺序的索引
          • f_index 可以跟踪 Fortran 顺序的索引
          • multi_index 每次迭代可以跟踪一种索引类型
          • external_loop 给出的值是具有多个值的一维数组，而不是零维数组
        • 在下面的实例中，迭代器遍历对应于每列，并组合为一维数组。
          • 实例
            • import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ('原始数组是：') print (a) print ('\n') print ('修改后的数组是：') for x in np.nditer(a, flags = ['external_loop'], order = 'F'): print (x, end=", " )
              • 原始数组是： [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] 修改后的数组是： [ 0 20 40], [ 5 25 45], [10 30 50], [15 35 55],
      • 广播迭代
        • 如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。 假设数组 a 的维度为 3X4，数组 b 的维度为 1X4 ，则使用以下迭代器（数组 b 被广播到 a 的大小）。
          • 实例
            • import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ('第一个数组为：') print (a) print ('\n') print ('第二个数组为：') b = np.array([1, 2, 3, 4], dtype = int) print (b) print ('\n') print ('修改后的数组为：') for x,y in np.nditer([a,b]): print ("%d:%d" % (x,y), end=", " )
              • 第一个数组为： [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] 第二个数组为： [1 2 3 4] 修改后的数组为： 0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,
    • Numpy 数组操作
      • Numpy 中包含了一些函数用于处理数组，大概可分为以下几类：
        • 修改数组形状
        • 翻转数组
        • 修改数组维度
        • 连接数组
        • 分割数组
        • 数组元素的添加与删除
      • 修改数组形状
        • 函数说明
          • 函数 描述
          • reshape 不改变数据的条件下修改形状
          • flat 数组元素迭代器
          • flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
          • ravel 返回展开数组
        • numpy.reshape
          • numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下：
            • numpy.reshape(arr, newshape, order='C')
            • arr：要修改形状的数组
            • newshape：整数或者整数数组，新的形状应当兼容原有形状
            • order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。
          • 实例
            • import numpy as np a = np.arange(8) print ('原始数组：') print (a) print ('\n') b = a.reshape(4,2) print ('修改后的数组：') print (b)
              • 原始数组： [0 1 2 3 4 5 6 7] 修改后的数组： [[0 1] [2 3] [4 5] [6 7]]
        • numpy.ndarray.flat
          • numpy.ndarray.flat 是一个数组元素迭代器，实例如下:
          • 实例
            • import numpy as np a = np.arange(9).reshape(3,3) print ('原始数组：') for row in a: print (row) #对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器： print ('迭代后的数组：') for element in a.flat: print (element)
              • 原始数组： [0 1 2] [3 4 5] [6 7 8] 迭代后的数组： 0 1 2 3 4 5 6 7 8
        • numpy.ndarray.flatten
          • numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：
            • ndarray.flatten(order='C')
          • 参数说明：
            • order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
            • 实例
              • import numpy as np a = np.arange(8).reshape(2,4) print ('原数组：') print (a) print ('\n') # 默认按行 print ('展开的数组：') print (a.flatten()) print ('\n') print ('以 F 风格顺序展开的数组：') print (a.flatten(order = 'F'))
                • 原数组： [[0 1 2 3] [4 5 6 7]] 展开的数组： [0 1 2 3 4 5 6 7] 以 F 风格顺序展开的数组： [0 4 1 5 2 6 3 7]
        • numpy.ravel
          • numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。
          • 该函数接收两个参数：
            • numpy.ravel(a, order='C')
          • 参数说明：
            • order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
            • 实例
              • import numpy as np a = np.arange(8).reshape(2,4) print ('原数组：') print (a) print ('\n') print ('调用 ravel 函数之后：') print (a.ravel()) print ('\n') print ('以 F 风格顺序调用 ravel 函数之后：') print (a.ravel(order = 'F'))
                • 原数组： [[0 1 2 3] [4 5 6 7]] 调用 ravel 函数之后： [0 1 2 3 4 5 6 7] 以 F 风格顺序调用 ravel 函数之后： [0 4 1 5 2 6 3 7]
      • 翻转数组
        • 函数说明
          • 函数 描述
          • transpose 对换数组的维度
          • ndarray.T 和 self.transpose() 相同
          • rollaxis 向后滚动指定的轴
          • swapaxes 对换数组的两个轴
        • numpy.transpose
          • numpy.transpose 函数用于对换数组的维度，格式如下：
            • numpy.transpose(arr, axes)
          • 参数说明:
            • arr：要操作的数组
            • axes：整数列表，对应维度，通常所有维度都会对换。
          • 实例
            • import numpy as np a = np.arange(12).reshape(3,4) print ('原数组：') print (a ) print ('\n') print ('对换数组：') print (np.transpose(a))
              • 原数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] 对换数组： [[ 0 4 8] [ 1 5 9] [ 2 6 10] [ 3 7 11]]
          • numpy.ndarray.T 类似 numpy.transpose：
            • 实例
              • import numpy as np a = np.arange(12).reshape(3,4) print ('原数组：') print (a) print ('\n') print ('转置数组：') print (a.T)
                • 原数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] 转置数组： [[ 0 4 8] [ 1 5 9] [ 2 6 10] [ 3 7 11]]
        • numpy.rollaxis
          • numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下：
            • numpy.rollaxis(arr, axis, start)
          • 参数说明：
            • arr：数组
            • axis：要向后滚动的轴，其它轴的相对位置不会改变
            • start：默认为零，表示完整的滚动。会滚动到特定位置。
          • 实例
            • import numpy as np # 创建了三维的 ndarray a = np.arange(8).reshape(2,2,2) print ('原数组：') print (a) print ('获取数组中一个值：') print(np.where(a==6)) print(a[1,1,0]) # 为 6 print ('\n') # 将轴 2 滚动到轴 0（宽度到深度） print ('调用 rollaxis 函数：') b = np.rollaxis(a,2,0) print (b) # 查看元素 a[1,1,0]，即 6 的坐标，变成 [0, 1, 1] # 最后一个 0 移动到最前面 print(np.where(b==6)) print ('\n') # 将轴 2 滚动到轴 1：（宽度到高度） print ('调用 rollaxis 函数：') c = np.rollaxis(a,2,1) print (c) # 查看元素 a[1,1,0]，即 6 的坐标，变成 [1, 0, 1] # 最后的 0 和 它前面的 1 对换位置 print(np.where(c==6)) print ('\n')
              • 原数组： [[[0 1] [2 3]] [[4 5] [6 7]]] 获取数组中一个值： (array([1]), array([1]), array([0])) 6 调用 rollaxis 函数： [[[0 2] [4 6]] [[1 3] [5 7]]] (array([0]), array([1]), array([1])) 调用 rollaxis 函数： [[[0 2] [1 3]] [[4 6] [5 7]]] (array([1]), array([0]), array([1]))
        • numpy.swapaxes
          • numpy.swapaxes 函数用于交换数组的两个轴，格式如下：
            • numpy.swapaxes(arr, axis1, axis2)
            • arr：输入的数组
            • axis1：对应第一个轴的整数
            • axis2：对应第二个轴的整数
          • 实例
            • import numpy as np # 创建了三维的 ndarray a = np.arange(8).reshape(2,2,2) print ('原数组：') print (a) print ('\n') # 现在交换轴 0（深度方向）到轴 2（宽度方向） print ('调用 swapaxes 函数后的数组：') print (np.swapaxes(a, 2, 0))
              • 原数组： [[[0 1] [2 3]] [[4 5] [6 7]]] 调用 swapaxes 函数后的数组： [[[0 4] [2 6]] [[1 5] [3 7]]]
      • 修改数组维度
        • 描述
          • 维度 描述
          • broadcast 产生模仿广播的对象
          • broadcast_to 将数组广播到新形状
          • expand_dims 扩展数组的形状
          • squeeze 从数组的形状中删除一维条目
        • numpy.broadcast
        • numpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。
        • 该函数使用两个数组作为输入参数，如下实例：
        • 实例
          • import numpy as np x = np.array([[1], [2], [3]]) y = np.array([4, 5, 6]) # 对 y 广播 x b = np.broadcast(x,y) # 它拥有 iterator 属性，基于自身组件的迭代器元组 print ('对 y 广播 x：') r,c = b.iters # Python3.x 为 next(context) ，Python2.x 为 context.next() print (next(r), next(c)) print (next(r), next(c)) print ('\n') # shape 属性返回广播对象的形状 print ('广播对象的形状：') print (b.shape) print ('\n') # 手动使用 broadcast 将 x 与 y 相加 b = np.broadcast(x,y) c = np.empty(b.shape) print ('手动使用 broadcast 将 x 与 y 相加：') print (c.shape) print ('\n') c.flat = [u + v for (u,v) in b] print ('调用 flat 函数：') print (c) print ('\n') # 获得了和 NumPy 内建的广播支持相同的结果 print ('x 与 y 的和：') print (x + y)
            • 对 y 广播 x： 1 4 1 5 广播对象的形状： (3, 3) 手动使用 broadcast 将 x 与 y 相加： (3, 3) 调用 flat 函数： [[5. 6. 7.] [6. 7. 8.] [7. 8. 9.]] x 与 y 的和： [[5 6 7] [6 7 8] [7 8 9]]
        • numpy.broadcast_to
          • numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。
            • numpy.broadcast_to(array, shape, subok)
          • 实例
            • import numpy as np a = np.arange(4).reshape(1,4) print ('原数组：') print (a) print ('\n') print ('调用 broadcast_to 函数之后：') print (np.broadcast_to(a,(4,4)))
              • 原数组： [[0 1 2 3]] 调用 broadcast_to 函数之后： [[0 1 2 3] [0 1 2 3] [0 1 2 3] [0 1 2 3]]
        • numpy.expand_dims
          • numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下:
            • numpy.expand_dims(arr, axis)
          • 参数说明：
            • arr：输入数组
            • axis：新轴插入的位置
          • 实例
            • import numpy as np x = np.array(([1,2],[3,4])) print ('数组 x：') print (x) print ('\n') y = np.expand_dims(x, axis = 0) print ('数组 y：') print (y) print ('\n') print ('数组 x 和 y 的形状：') print (x.shape, y.shape) print ('\n') # 在位置 1 插入轴 y = np.expand_dims(x, axis = 1) print ('在位置 1 插入轴之后的数组 y：') print (y) print ('\n') print ('x.ndim 和 y.ndim：') print (x.ndim,y.ndim) print ('\n') print ('x.shape 和 y.shape：') print (x.shape, y.shape)
              • 数组 x： [[1 2] [3 4]] 数组 y： [[[1 2] [3 4]]] 数组 x 和 y 的形状： (2, 2) (1, 2, 2) 在位置 1 插入轴之后的数组 y： [[[1 2]] [[3 4]]] x.ndim 和 y.ndim： 2 3 x.shape 和 y.shape： (2, 2) (2, 1, 2)
        • numpy.squeeze
          • numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下：
            • numpy.squeeze(arr, axis)
          • 参数说明：
            • arr：输入数组
            • axis：整数或整数元组，用于选择形状中一维条目的子集
          • 实例
            • import numpy as np x = np.arange(9).reshape(1,3,3) print ('数组 x：') print (x) print ('\n') y = np.squeeze(x) print ('数组 y：') print (y) print ('\n') print ('数组 x 和 y 的形状：') print (x.shape, y.shape)
              • 数组 x： [[[0 1 2] [3 4 5] [6 7 8]]] 数组 y： [[0 1 2] [3 4 5] [6 7 8]] 数组 x 和 y 的形状： (1, 3, 3) (3, 3)
      • 连接数组
        • 描述
          • 函数 描述
          • concatenate 连接沿现有轴的数组序列
          • stack 沿着新的轴加入一系列数组。
          • hstack 水平堆叠序列中的数组（列方向）
          • vstack 竖直堆叠序列中的数组（行方向）
        • numpy.concatenate
        • numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：
          • numpy.concatenate((a1, a2, ...), axis)
        • 参数说明：
          • a1, a2, ...：相同类型的数组
          • axis：沿着它连接数组的轴，默认为 0
        • 实例
          • import numpy as np a = np.array([[1,2],[3,4]]) print ('第一个数组：') print (a) print ('\n') b = np.array([[5,6],[7,8]]) print ('第二个数组：') print (b) print ('\n') # 两个数组的维度相同 print ('沿轴 0 连接两个数组：') print (np.concatenate((a,b))) print ('\n') print ('沿轴 1 连接两个数组：') print (np.concatenate((a,b),axis = 1))
            • 第一个数组： [[1 2] [3 4]] 第二个数组： [[5 6] [7 8]] 沿轴 0 连接两个数组： [[1 2] [3 4] [5 6] [7 8]] 沿轴 1 连接两个数组： [[1 2 5 6] [3 4 7 8]]
        • numpy.stack
          • numpy.stack 函数用于沿新轴连接数组序列，格式如下：
            • numpy.stack(arrays, axis)
          • 参数说明：
            • arrays相同形状的数组序列
            • axis：返回数组中的轴，输入数组沿着它来堆叠
          • 实例
            • import numpy as np a = np.array([[1,2],[3,4]]) print ('第一个数组：') print (a) print ('\n') b = np.array([[5,6],[7,8]]) print ('第二个数组：') print (b) print ('\n') print ('沿轴 0 堆叠两个数组：') print (np.stack((a,b),0)) print ('\n') print ('沿轴 1 堆叠两个数组：') print (np.stack((a,b),1))
              • 第一个数组： [[1 2] [3 4]] 第二个数组： [[5 6] [7 8]] 沿轴 0 堆叠两个数组： [[[1 2] [3 4]] [[5 6] [7 8]]] 沿轴 1 堆叠两个数组： [[[1 2] [5 6]] [[3 4] [7 8]]]
        • numpy.hstack
          • numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。
          • 实例
            • import numpy as np a = np.array([[1,2],[3,4]]) print ('第一个数组：') print (a) print ('\n') b = np.array([[5,6],[7,8]]) print ('第二个数组：') print (b) print ('\n') print ('水平堆叠：') c = np.hstack((a,b)) print (c) print ('\n')
              • 第一个数组： [[1 2] [3 4]] 第二个数组： [[5 6] [7 8]] 水平堆叠： [[1 2 5 6] [3 4 7 8]]
        • numpy.vstack
          • numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。
          • 实例
            • import numpy as np a = np.array([[1,2],[3,4]]) print ('第一个数组：') print (a) print ('\n') b = np.array([[5,6],[7,8]]) print ('第二个数组：') print (b) print ('\n') print ('竖直堆叠：') c = np.vstack((a,b)) print (c)
              • 第一个数组： [[1 2] [3 4]] 第二个数组： [[5 6] [7 8]] 竖直堆叠： [[1 2] [3 4] [5 6] [7 8]]
      • 分割数组
        • 函数说明
          • 函数 数组及操作
          • split 将一个数组分割为多个子数组
          • hsplit 将一个数组水平分割为多个子数组（按列）
          • vsplit 将一个数组垂直分割为多个子数组（按行）
        • numpy.split
          • numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：
            • numpy.split(ary, indices_or_sections, axis)
          • 参数说明：
            • ary：被分割的数组
            • indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
            • axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。
          • 实例
            • import numpy as np a = np.arange(9) print ('第一个数组：') print (a) print ('\n') print ('将数组分为三个大小相等的子数组：') b = np.split(a,3) print (b) print ('\n') print ('将数组在一维数组中表明的位置分割：') b = np.split(a,[4,7]) print (b)
              • 第一个数组： [0 1 2 3 4 5 6 7 8] 将数组分为三个大小相等的子数组： [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])] 将数组在一维数组中表明的位置分割： [array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
          • axis 为 0 时在水平方向分割，axis 为 1 时在垂直方向分割：
            • 实例
              • import numpy as np a = np.arange(16).reshape(4, 4) print('第一个数组：') print(a) print('\n') print('默认分割（0轴）：') b = np.split(a,2) print(b) print('\n') print('沿垂直方向分割：') c = np.split(a,2,1) print(c) print('\n') print('沿水平方向分割：') d= np.hsplit(a,2) print(d)
                • 第一个数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]] 默认分割（0轴）： [array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], [12, 13, 14, 15]])] 沿垂直方向分割： [array([[ 0, 1], [ 4, 5], [ 8, 9], [12, 13]]), array([[ 2, 3], [ 6, 7], [10, 11], [14, 15]])] 沿水平方向分割： [array([[ 0, 1], [ 4, 5], [ 8, 9], [12, 13]]), array([[ 2, 3], [ 6, 7], [10, 11], [14, 15]])]
        • numpy.hsplit
          • numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
          • 实例
            • import numpy as np harr = np.floor(10 * np.random.random((2, 6))) print ('原array：') print(harr) print ('拆分后：') print(np.hsplit(harr, 3))
              • 原array： [[4. 7. 6. 3. 2. 6.] [6. 3. 6. 7. 9. 7.]] 拆分后： [array([[4., 7.], [6., 3.]]), array([[6., 3.], [6., 7.]]), array([[2., 6.], [9., 7.]])]
        • numpy.vsplit
          • numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。
          • 实例
            • import numpy as np a = np.arange(16).reshape(4,4) print ('第一个数组：') print (a) print ('\n') print ('竖直分割：') b = np.vsplit(a,2) print (b)
              • 第一个数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]] 竖直分割： [array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], [12, 13, 14, 15]])]
      • 数组元素的添加与删除
        • 函数说明
          • 函数 元素及描述
          • resize 返回指定形状的新数组
          • append 将值添加到数组末尾
          • insert 沿指定轴将值插入到指定下标之前
          • delete 删掉某个轴的子数组，并返回删除后的新数组
          • unique 查找数组内的唯一元素
        • numpy.resize
          • numpy.resize 函数返回指定大小的新数组。
          • 如果新数组大小大于原始大小，则包含原始数组中的元素的副本。
            • numpy.resize(arr, shape)
          • 参数说明：
            • arr：要修改大小的数组
            • shape：返回数组的新形状
          • 实例
            • import numpy as np a = np.array([[1,2,3],[4,5,6]]) print ('第一个数组：') print (a) print ('\n') print ('第一个数组的形状：') print (a.shape) print ('\n') b = np.resize(a, (3,2)) print ('第二个数组：') print (b) print ('\n') print ('第二个数组的形状：') print (b.shape) print ('\n') # 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了 print ('修改第二个数组的大小：') b = np.resize(a,(3,3)) print (b)
              • 第一个数组： [[1 2 3] [4 5 6]] 第一个数组的形状： (2, 3) 第二个数组： [[1 2] [3 4] [5 6]] 第二个数组的形状： (3, 2) 修改第二个数组的大小： [[1 2 3] [4 5 6] [1 2 3]]
        • numpy.append
          • numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
          • append 函数返回的始终是一个一维数组。
            • numpy.append(arr, values, axis=None)
          • 参数说明：
            • arr：输入数组
            • values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
            • axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。
          • 实例
            • import numpy as np a = np.array([[1,2,3],[4,5,6]]) print ('第一个数组：') print (a) print ('\n') print ('向数组添加元素：') print (np.append(a, [7,8,9])) print ('\n') print ('沿轴 0 添加元素：') print (np.append(a, [[7,8,9]],axis = 0)) print ('\n') print ('沿轴 1 添加元素：') print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))
              • 第一个数组： [[1 2 3] [4 5 6]] 向数组添加元素： [1 2 3 4 5 6 7 8 9] 沿轴 0 添加元素： [[1 2 3] [4 5 6] [7 8 9]] 沿轴 1 添加元素： [[1 2 3 5 5 5] [4 5 6 7 8 9]]
        • numpy.insert
          • numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
          • 如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。
            • numpy.insert(arr, obj, values, axis)
          • 参数说明：
            • arr：输入数组
            • obj：在其之前插入值的索引
            • values：要插入的值
            • axis：沿着它插入的轴，如果未提供，则输入数组会被展开
          • 实例
            • import numpy as np a = np.array([[1,2],[3,4],[5,6]]) print ('第一个数组：') print (a) print ('\n') print ('未传递 Axis 参数。 在插入之前输入数组会被展开。') print (np.insert(a,3,[11,12])) print ('\n') print ('传递了 Axis 参数。 会广播值数组来配输入数组。') print ('沿轴 0 广播：') print (np.insert(a,1,[11],axis = 0)) print ('\n') print ('沿轴 1 广播：') print (np.insert(a,1,11,axis = 1))
              • 第一个数组： [[1 2] [3 4] [5 6]] 未传递 Axis 参数。 在插入之前输入数组会被展开。 [ 1 2 3 11 12 4 5 6] 传递了 Axis 参数。 会广播值数组来配输入数组。 沿轴 0 广播： [[ 1 2] [11 11] [ 3 4] [ 5 6]] 沿轴 1 广播： [[ 1 11 2] [ 3 11 4] [ 5 11 6]]
        • numpy.delete
          • numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。
            • Numpy.delete(arr, obj, axis)
          • 参数说明：
            • arr：输入数组
            • obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
            • axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
          • 实例
            • import numpy as np a = np.arange(12).reshape(3,4) print ('第一个数组：') print (a) print ('\n') print ('未传递 Axis 参数。 在插入之前输入数组会被展开。') print (np.delete(a,5)) print ('\n') print ('删除第二列：') print (np.delete(a,1,axis = 1)) print ('\n') print ('包含从数组中删除的替代值的切片：') a = np.array([1,2,3,4,5,6,7,8,9,10]) print (np.delete(a, np.s_[::2]))
              • 第一个数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] 未传递 Axis 参数。 在插入之前输入数组会被展开。 [ 0 1 2 3 4 6 7 8 9 10 11] 删除第二列： [[ 0 2 3] [ 4 6 7] [ 8 10 11]] 包含从数组中删除的替代值的切片： [ 2 4 6 8 10]
        • numpy.unique
          • numpy.unique 函数用于去除数组中的重复元素。
            • numpy.unique(arr, return_index, return_inverse, return_counts)
            • arr：输入数组，如果不是一维数组则会展开
            • return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
            • return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
            • return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
          • 实例
            • import numpy as np a = np.array([5,2,6,2,7,5,6,8,2,9]) print ('第一个数组：') print (a) print ('\n') print ('第一个数组的去重值：') u = np.unique(a) print (u) print ('\n') print ('去重数组的索引数组：') u,indices = np.unique(a, return_index = True) print (indices) print ('\n') print ('我们可以看到每个和原数组下标对应的数值：') print (a) print ('\n') print ('去重数组的下标：') u,indices = np.unique(a,return_inverse = True) print (u) print ('\n') print ('下标为：') print (indices) print ('\n') print ('使用下标重构原数组：') print (u[indices]) print ('\n') print ('返回去重元素的重复数量：') u,indices = np.unique(a,return_counts = True) print (u) print (indices)
              • 第一个数组： [5 2 6 2 7 5 6 8 2 9] 第一个数组的去重值： [2 5 6 7 8 9] 去重数组的索引数组： [1 0 2 4 7 9] 我们可以看到每个和原数组下标对应的数值： [5 2 6 2 7 5 6 8 2 9] 去重数组的下标： [2 5 6 7 8 9] 下标为： [1 0 2 0 3 1 2 4 0 5] 使用下标重构原数组： [5 2 6 2 7 5 6 8 2 9] 返回去重元素的重复数量： [2 5 6 7 8 9] [3 2 2 1 1 1]
    • NumPy 位运算
      • NumPy "bitwise_" 开头的函数是位运算函数。
      • NumPy 位运算包括以下几个函数：
        • 函数 描述
        • bitwise_and 对数组元素执行位与操作
        • bitwise_or 对数组元素执行位或操作
        • invert 按位取反
        • left_shift 向左移动二进制表示的位
        • right_shift 向右移动二进制表示的位
      • 注：也可以使用 "&"、 "~"、 "|" 和 "^" 等操作符进行计算。
      • bitwise_and
        • bitwise_and() 函数对数组中整数的二进制形式执行位与运算。
        • 实例
          • import numpy as np print ('13 和 17 的二进制形式：') a,b = 13,17 print (bin(a), bin(b)) print ('\n') print ('13 和 17 的位与：') print (np.bitwise_and(13, 17))
            • 13 和 17 的二进制形式： 0b1101 0b10001 13 和 17 的位与： 1
        • 以上实例可以用下表来说明：
          • 
        • 位与操作运算规律如下：
          • 
      • bitwise_or
        • bitwise_or()函数对数组中整数的二进制形式执行位或运算。
        • 实例
          • import numpy as np a,b = 13,17 print ('13 和 17 的二进制形式：') print (bin(a), bin(b)) print ('13 和 17 的位或：') print (np.bitwise_or(13, 17))
            • 13 和 17 的二进制形式： 0b1101 0b10001 13 和 17 的位或： 29
        • 以上实例可以用下表来说明：
          • 
      • invert
        • invert() 函数对数组中整数进行位取反运算，即 0 变成 1，1 变成 0。
        • 对于有符号整数，取该二进制数的补码，然后 +1。二进制数，最高位为0表示正数，最高位为 1 表示负数。
        • 看看 ~1 的计算步骤：
          • 将1(这里叫：原码)转二进制 ＝ 00000001
          • 按位取反 ＝ 11111110
          • 发现符号位(即最高位)为1(表示负数)，将除符号位之外的其他数字取反 ＝ 10000001
          • 末位加1取其补码 ＝ 10000010
          • 转换回十进制 ＝ -2
          • 说明
            • 表达式 二进制值（2 的补数） 十进制值 5 00000000 00000000 00000000 0000010 5 ~5 11111111 11111111 11111111 11111010 -6
        • 实例
          • import numpy as np print ('13 的位反转，其中 ndarray 的 dtype 是 uint8：') print (np.invert(np.array([13], dtype = np.uint8))) print ('\n') # 比较 13 和 242 的二进制表示，我们发现了位的反转 print ('13 的二进制表示：') print (np.binary_repr(13, width = 8)) print ('\n') print ('242 的二进制表示：') print (np.binary_repr(242, width = 8))
            • 13 的位反转，其中 ndarray 的 dtype 是 uint8： [242] 13 的二进制表示： 00001101 242 的二进制表示： 11110010
      • left_shift
        • left_shift() 函数将数组元素的二进制形式向左移动到指定位置，右侧附加相等数量的 0。
        • 实例
          • import numpy as np print ('将 10 左移两位：') print (np.left_shift(10,2)) print ('\n') print ('10 的二进制表示：') print (np.binary_repr(10, width = 8)) print ('\n') print ('40 的二进制表示：') print (np.binary_repr(40, width = 8)) # '00001010' 中的两位移动到了左边，并在右边添加了两个 0。
            • 将 10 左移两位： 40 10 的二进制表示： 00001010 40 的二进制表示： 00101000
      • right_shift
        • right_shift() 函数将数组元素的二进制形式向右移动到指定位置，左侧附加相等数量的 0。
        • 实例
          • import numpy as np print ('将 40 右移两位：') print (np.right_shift(40,2)) print ('\n') print ('40 的二进制表示：') print (np.binary_repr(40, width = 8)) print ('\n') print ('10 的二进制表示：') print (np.binary_repr(10, width = 8)) # '00001010' 中的两位移动到了右边，并在左边添加了两个 0。
            • 将 40 右移两位： 10 40 的二进制表示： 00101000 10 的二进制表示： 00001010
    • NumPy 字符串函数
      • 以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。
      • 这些函数在字符数组类（numpy.char）中定义。
      • 说明
        • 函数 描述
        • add() 对两个数组的逐个字符串元素进行连接
        • multiply() 返回按元素多重连接后的字符串
        • center() 居中字符串
        • capitalize() 将字符串第一个字母转换为大写
        • title() 将字符串的每个单词的第一个字母转换为大写
        • lower() 数组元素转换为小写
        • upper() 数组元素转换为大写
        • split() 指定分隔符对字符串进行分割，并返回数组列表
        • splitlines() 返回元素中的行列表，以换行符分割
        • strip() 移除元素开头或者结尾处的特定字符
        • join() 通过指定分隔符来连接数组中的元素
        • replace() 使用新字符串替换字符串中的所有子字符串
        • decode() 数组元素依次调用str.decode
        • encode() 数组元素依次调用str.encode
      • numpy.char.add()
        • numpy.char.add() 函数依次对两个数组的元素进行字符串连接。
        • 实例
          • import numpy as np print ('连接两个字符串：') print (np.char.add(['hello'],[' xyz'])) print ('\n') print ('连接示例：') print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))
            • 连接两个字符串： ['hello xyz'] 连接示例： ['hello abc' 'hi xyz']
      • numpy.char.multiply()
        • numpy.char.multiply() 函数执行多重连接。
        • 实例
          • import numpy as np print (np.char.multiply('Runoob ',3))
            • Runoob Runoob Runoob
      • numpy.char.center()
        • numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。
        • 实例
          • import numpy as np # np.char.center(str , width,fillchar) ： # str: 字符串，width: 长度，fillchar: 填充字符 print (np.char.center('Runoob', 20,fillchar = '*'))
            • *******Runoob*******
      • numpy.char.capitalize()
        • numpy.char.capitalize() 函数将字符串的第一个字母转换为大写：
          • 实例
            • import numpy as np print (np.char.capitalize('runoob'))
              • Runoob
      • numpy.char.title()
        • numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写：
          • 实例
            • import numpy as np print (np.char.title('i like runoob'))
              • I Like Runoob
      • numpy.char.lower()
        • numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。
          • 实例
            • import numpy as np #操作数组 print (np.char.lower(['RUNOOB','GOOGLE'])) # 操作字符串 print (np.char.lower('RUNOOB'))
              • ['runoob' 'google'] runoob
      • numpy.char.upper()
        • numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。
          • 实例
            • import numpy as np #操作数组 print (np.char.upper(['runoob','google'])) # 操作字符串 print (np.char.upper('runoob'))
              • ['RUNOOB' 'GOOGLE'] RUNOOB
      • numpy.char.split()
        • numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。
          • 实例
            • import numpy as np # 分隔符默认为空格 print (np.char.split ('i like runoob?')) # 分隔符为 . print (np.char.split ('www.runoob.com', sep = '.'))
              • ['i', 'like', 'runoob?'] ['www', 'runoob', 'com']
      • numpy.char.splitlines()
        • numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。
          • 实例
            • import numpy as np # 换行符 \n print (np.char.splitlines('i\nlike runoob?')) print (np.char.splitlines('i\rlike runoob?'))
              • ['i', 'like runoob?'] ['i', 'like runoob?']
        • \n，\r，\r\n 都可用作换行符。
      • numpy.char.strip()
        • numpy.char.strip() 函数用于移除开头或结尾处的特定字符。
          • 实例
            • import numpy as np # 移除字符串头尾的 a 字符 print (np.char.strip('ashok arunooba','a')) # 移除数组元素头尾的 a 字符 print (np.char.strip(['arunooba','admin','java'],'a'))
              • shok arunoob ['runoob' 'dmin' 'jav']
      • numpy.char.join()
        • numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
          • 实例
            • import numpy as np # 操作字符串 print (np.char.join(':','runoob')) # 指定多个分隔符操作数组元素 print (np.char.join([':','-'],['runoob','google']))
              • r:u:n:o:o:b ['r:u:n:o:o:b' 'g-o-o-g-l-e']
      • numpy.char.replace()
        • numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。
          • 实例
            • import numpy as np print (np.char.replace ('i like runoob', 'oo', 'cc'))
              • i like runccb
      • numpy.char.encode()
        • numpy.char.encode() 函数对数组中的每个元素调用 str.encode 函数。 默认编码是 utf-8，可以使用标准 Python 库中的编解码器。
          • 实例
            • import numpy as np a = np.char.encode('runoob', 'cp500') print (a)
              • b'\x99\xa4\x95\x96\x96\x82'
      • numpy.char.decode()
        • numpy.char.decode() 函数对编码的元素进行 str.decode() 解码。
          • 实例
            • import numpy as np a = np.char.encode('runoob', 'cp500') print (a) print (np.char.decode(a,'cp500'))
              • b'\x99\xa4\x95\x96\x96\x82' runoob
    • NumPy 数学函数
      • NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。
      • 三角函数
        • NumPy 提供了标准的三角函数：sin()、cos()、tan()。
        • 实例
          • import numpy as np a = np.array([0,30,45,60,90]) print ('不同角度的正弦值：') # 通过乘 pi/180 转化为弧度 print (np.sin(a*np.pi/180)) print ('\n') print ('数组中角度的余弦值：') print (np.cos(a*np.pi/180)) print ('\n') print ('数组中角度的正切值：') print (np.tan(a*np.pi/180))
            • 不同角度的正弦值： [0. 0.5 0.70710678 0.8660254 1. ] 数组中角度的余弦值： [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 6.12323400e-17] 数组中角度的正切值： [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 1.63312394e+16]
        • arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。
        • 这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度。
        • 实例
          • import numpy as np a = np.array([0,30,45,60,90]) print ('含有正弦值的数组：') sin = np.sin(a*np.pi/180) print (sin) print ('\n') print ('计算角度的反正弦，返回值以弧度为单位：') inv = np.arcsin(sin) print (inv) print ('\n') print ('通过转化为角度制来检查结果：') print (np.degrees(inv)) print ('\n') print ('arccos 和 arctan 函数行为类似：') cos = np.cos(a*np.pi/180) print (cos) print ('\n') print ('反余弦：') inv = np.arccos(cos) print (inv) print ('\n') print ('角度制单位：') print (np.degrees(inv)) print ('\n') print ('tan 函数：') tan = np.tan(a*np.pi/180) print (tan) print ('\n') print ('反正切：') inv = np.arctan(tan) print (inv) print ('\n') print ('角度制单位：') print (np.degrees(inv))
            • 含有正弦值的数组： [0. 0.5 0.70710678 0.8660254 1. ] 计算角度的反正弦，返回值以弧度为单位： [0. 0.52359878 0.78539816 1.04719755 1.57079633] 通过转化为角度制来检查结果： [ 0. 30. 45. 60. 90.] arccos 和 arctan 函数行为类似： [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 6.12323400e-17] 反余弦： [0. 0.52359878 0.78539816 1.04719755 1.57079633] 角度制单位： [ 0. 30. 45. 60. 90.] tan 函数： [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 1.63312394e+16] 反正切： [0. 0.52359878 0.78539816 1.04719755 1.57079633] 角度制单位： [ 0. 30. 45. 60. 90.]
      • 舍入函数
        • numpy.around() 函数返回指定数字的四舍五入值。
          • numpy.around(a,decimals)
        • 参数说明：
          • a: 数组
          • decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
        • 实例
          • import numpy as np a = np.array([1.0,5.55, 123, 0.567, 25.532]) print ('原数组：') print (a) print ('\n') print ('舍入后：') print (np.around(a)) print (np.around(a, decimals = 1)) print (np.around(a, decimals = -1))
            • 原数组： [ 1. 5.55 123. 0.567 25.532] 舍入后： [ 1. 6. 123. 1. 26.] [ 1. 5.6 123. 0.6 25.5] [ 0. 10. 120. 0. 30.]
        • numpy.floor()
          • numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。
          • 实例
            • import numpy as np a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) print ('提供的数组：') print (a) print ('\n') print ('修改后的数组：') print (np.floor(a))
              • 提供的数组： [-1.7 1.5 -0.2 0.6 10. ] 修改后的数组： [-2. 1. -1. 0. 10.]
        • numpy.ceil()
          • numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。
          • 实例
            • import numpy as np a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) print ('提供的数组：') print (a) print ('\n') print ('修改后的数组：') print (np.ceil(a))
              • 提供的数组： [-1.7 1.5 -0.2 0.6 10. ] 修改后的数组： [-1. 2. -0. 1. 10.]
    • NumPy 算术函数
      • NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。
      • 需要注意的是数组必须具有相同的形状或符合数组广播规则。
      • 实例
        • import numpy as np a = np.arange(9, dtype = np.float_).reshape(3,3) print ('第一个数组：') print (a) print ('\n') print ('第二个数组：') b = np.array([10,10,10]) print (b) print ('\n') print ('两个数组相加：') print (np.add(a,b)) print ('\n') print ('两个数组相减：') print (np.subtract(a,b)) print ('\n') print ('两个数组相乘：') print (np.multiply(a,b)) print ('\n') print ('两个数组相除：') print (np.divide(a,b))
          • 第一个数组： [[0. 1. 2.] [3. 4. 5.] [6. 7. 8.]] 第二个数组： [10 10 10] 两个数组相加： [[10. 11. 12.] [13. 14. 15.] [16. 17. 18.]] 两个数组相减： [[-10. -9. -8.] [ -7. -6. -5.] [ -4. -3. -2.]] 两个数组相乘： [[ 0. 10. 20.] [30. 40. 50.] [60. 70. 80.]] 两个数组相除： [[0. 0.1 0.2] [0.3 0.4 0.5] [0.6 0.7 0.8]]
      • 此外 Numpy 也包含了其他重要的算术函数。
      • numpy.reciprocal()
        • numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。
        • 实例
          • import numpy as np a = np.array([0.25, 1.33, 1, 100]) print ('我们的数组是：') print (a) print ('\n') print ('调用 reciprocal 函数：') print (np.reciprocal(a))
            • 我们的数组是： [ 0.25 1.33 1. 100. ] 调用 reciprocal 函数： [4. 0.7518797 1. 0.01 ]
      • numpy.power()
        • numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
        • 实例
          • import numpy as np a = np.array([10,100,1000]) print ('我们的数组是；') print (a) print ('\n') print ('调用 power 函数：') print (np.power(a,2)) print ('\n') print ('第二个数组：') b = np.array([1,2,3]) print (b) print ('\n') print ('再次调用 power 函数：') print (np.power(a,b))
            • 我们的数组是； [ 10 100 1000] 调用 power 函数： [ 100 10000 1000000] 第二个数组： [1 2 3] 再次调用 power 函数： [ 10 10000 1000000000]
      • numpy.mod()
        • numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。
        • 实例
          • import numpy as np a = np.array([10,20,30]) b = np.array([3,5,7]) print ('第一个数组：') print (a) print ('\n') print ('第二个数组：') print (b) print ('\n') print ('调用 mod() 函数：') print (np.mod(a,b)) print ('\n') print ('调用 remainder() 函数：') print (np.remainder(a,b))
            • 第一个数组： [10 20 30] 第二个数组： [3 5 7] 调用 mod() 函数： [1 0 2] 调用 remainder() 函数： [1 0 2]
    • NumPy 排序、条件刷选函数
      • NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。
        • 种类 速度 最坏情况 工作空间 稳定性
        • 'quicksort'（快速排序） 1 O(n^2) 0 否
        • 'mergesort'（归并排序） 2 O(n*log(n)) ~n/2 是
        • 'heapsort'（堆排序） 3 O(n*log(n)) 0 否
      • numpy.sort()
        • numpy.sort() 函数返回输入数组的排序副本。函数格式如下：
          • numpy.sort(a, axis, kind, order)
        • 参数说明：
          • a: 要排序的数组
          • axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
          • kind: 默认为'quicksort'（快速排序）
          • order: 如果数组包含字段，则是要排序的字段
        • 实例
          • import numpy as np a = np.array([[3,7],[9,1]]) print ('我们的数组是：') print (a) print ('\n') print ('调用 sort() 函数：') print (np.sort(a)) print ('\n') print ('按列排序：') print (np.sort(a, axis = 0)) print ('\n') # 在 sort 函数中排序字段 dt = np.dtype([('name', 'S10'),('age', int)]) a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt) print ('我们的数组是：') print (a) print ('\n') print ('按 name 排序：') print (np.sort(a, order = 'name'))
            • 我们的数组是： [[3 7] [9 1]] 调用 sort() 函数： [[3 7] [1 9]] 按列排序： [[3 1] [9 7]] 我们的数组是： [(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)] 按 name 排序： [(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
      • numpy.argsort()
        • numpy.argsort() 函数返回的是数组值从小到大的索引值。
        • 实例
          • import numpy as np x = np.array([3, 1, 2]) print ('我们的数组是：') print (x) print ('\n') print ('对 x 调用 argsort() 函数：') y = np.argsort(x) print (y) print ('\n') print ('以排序后的顺序重构原数组：') print (x[y]) print ('\n') print ('使用循环重构原数组：') for i in y: print (x[i], end=" ")
            • 我们的数组是： [3 1 2] 对 x 调用 argsort() 函数： [1 2 0] 以排序后的顺序重构原数组： [1 2 3] 使用循环重构原数组 1 2 3
      • numpy.lexsort()
        • numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。
        • 这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。
        • 实例
          • import numpy as np nm = ('raju','anil','ravi','amar') dv = ('f.y.', 's.y.', 's.y.', 'f.y.') ind = np.lexsort((dv,nm)) print ('调用 lexsort() 函数：') print (ind) print ('\n') print ('使用这个索引来获取排序后的数据：') print ([nm[i] + ", " + dv[i] for i in ind])
            • 调用 lexsort() 函数： [3 1 0 2] 使用这个索引来获取排序后的数据： ['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']
        • 上面传入 np.lexsort 的是一个tuple，排序时首先排 nm，顺序为：amar、anil、raju、ravi 。综上排序结果为 [3 1 0 2]。
      • msort、sort_complex、partition、argpartition
        • 函数 描述
          • msort(a) 数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。
          • sort_complex(a) 对复数按照先实部后虚部的顺序进行排序。
          • partition(a, kth[, axis, kind, order]) 指定一个数，对数组进行分区
          • argpartition(a, kth[, axis, kind, order]) 可以通过关键字 kind 指定算法沿着指定轴对数组进行分区
        • 复数排序：
          • >>> import numpy as np >>> np.sort_complex([5, 3, 6, 2, 1]) array([ 1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j]) >>> >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]) array([ 1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])
        • partition() 分区排序：
          • >>> a = np.array([3, 4, 2, 1]) >>> np.partition(a, 3) # 将数组 a 中所有元素（包括重复元素）从小到大排列，3 表示的是排序数组索引为 3 的数字，比该数字小的排在该数字前面，比该数字大的排在该数字的后面 array([2, 1, 3, 4]) >>> >>> np.partition(a, (1, 3)) # 小于 1 的在前面，大于 3 的在后面，1和3之间的在中间 array([1, 2, 3, 4])
        • 找到数组的第 3 小（index=2）的值和第 2 大（index=-2）的值
          • >>> arr = np.array([46, 57, 23, 39, 1, 10, 0, 120]) >>> arr[np.argpartition(arr, 2)[2]] 10 >>> arr[np.argpartition(arr, -2)[-2]] 57
        • 同时找到第 3 和第 4 小的值。注意这里，用 [2,3] 同时将第 3 和第 4 小的排序好，然后可以分别通过下标 [2] 和 [3] 取得。
          • >>> arr[np.argpartition(arr, [2,3])[2]] 10 >>> arr[np.argpartition(arr, [2,3])[3]] 23
      • numpy.argmax() 和 numpy.argmin()
        • numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。
        • 实例
          • import numpy as np a = np.array([[30,40,70],[80,20,10],[50,90,60]]) print ('我们的数组是：') print (a) print ('\n') print ('调用 argmax() 函数：') print (np.argmax(a)) print ('\n') print ('展开数组：') print (a.flatten()) print ('\n') print ('沿轴 0 的最大值索引：') maxindex = np.argmax(a, axis = 0) print (maxindex) print ('\n') print ('沿轴 1 的最大值索引：') maxindex = np.argmax(a, axis = 1) print (maxindex) print ('\n') print ('调用 argmin() 函数：') minindex = np.argmin(a) print (minindex) print ('\n') print ('展开数组中的最小值：') print (a.flatten()[minindex]) print ('\n') print ('沿轴 0 的最小值索引：') minindex = np.argmin(a, axis = 0) print (minindex) print ('\n') print ('沿轴 1 的最小值索引：') minindex = np.argmin(a, axis = 1) print (minindex)
            • 我们的数组是： [[30 40 70] [80 20 10] [50 90 60]] 调用 argmax() 函数： 7 展开数组： [30 40 70 80 20 10 50 90 60] 沿轴 0 的最大值索引： [1 2 0] 沿轴 1 的最大值索引： [2 0 1] 调用 argmin() 函数： 5 展开数组中的最小值： 10 沿轴 0 的最小值索引： [0 1 1] 沿轴 1 的最小值索引： [0 2 0]
      • numpy.nonzero()
        • numpy.nonzero() 函数返回输入数组中非零元素的索引。
        • 实例
          • import numpy as np a = np.array([[30,40,0],[0,20,10],[50,0,60]]) print ('我们的数组是：') print (a) print ('\n') print ('调用 nonzero() 函数：') print (np.nonzero (a))
            • 我们的数组是： [[30 40 0] [ 0 20 10] [50 0 60]] 调用 nonzero() 函数： (array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
      • numpy.where()
        • numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
        • 实例
          • import numpy as np x = np.arange(9.).reshape(3, 3) print ('我们的数组是：') print (x) print ( '大于 3 的元素的索引：') y = np.where(x > 3) print (y) print ('使用这些索引来获取满足条件的元素：') print (x[y])
            • 我们的数组是： [[0. 1. 2.] [3. 4. 5.] [6. 7. 8.]] 大于 3 的元素的索引： (array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2])) 使用这些索引来获取满足条件的元素： [4. 5. 6. 7. 8.]
      • numpy.extract()
        • numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。
        • 实例
          • import numpy as np x = np.arange(9.).reshape(3, 3) print ('我们的数组是：') print (x) # 定义条件, 选择偶数元素 condition = np.mod(x,2) == 0 print ('按元素的条件值：') print (condition) print ('使用条件提取元素：') print (np.extract(condition, x))
            • 我们的数组是： [[0. 1. 2.] [3. 4. 5.] [6. 7. 8.]] 按元素的条件值： [[ True False True] [False True False] [ True False True]] 使用条件提取元素： [0. 2. 4. 6. 8.]
    • NumPy 字节交换
      • 在几乎所有的机器上，多字节对象都被存储为连续的字节序列。字节顺序，是跨越多字节的程序对象的存储规则。
        • 大端模式：指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
        • 小端模式：指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。
      • 例如在 C 语言中，一个类型为 int 的变量 x 地址为 0x100，那么其对应地址表达式&x的值为 0x100。且x的四个字节将被存储在存储器的 0x100, 0x101, 0x102, 0x103位置。
        • 
      • numpy.ndarray.byteswap()
        • numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。
        • 实例
          • import numpy as np a = np.array([1, 256, 8755], dtype = np.int16) print ('我们的数组是：') print (a) print ('以十六进制表示内存中的数据：') print (map(hex,a)) # byteswap() 函数通过传入 true 来原地交换 print ('调用 byteswap() 函数：') print (a.byteswap(True)) print ('十六进制形式：') print (map(hex,a)) # 我们可以看到字节已经交换了
            • 我们的数组是： [ 1 256 8755] 以十六进制表示内存中的数据： <map object at 0x104acb400> 调用 byteswap() 函数： [ 256 1 13090] 十六进制形式： <map object at 0x104acb3c8>
    • NumPy 副本和视图
      • 副本是一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置。
      • 视图是数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改，它会影响到原始数据，物理内存在同一位置。
      • 视图一般发生在：
        • 1、numpy 的切片操作返回原数据的视图。
        • 2、调用 ndarray 的 view() 函数产生一个视图。
      • 副本一般发生在：
        • Python 序列的切片操作，调用deepCopy()函数。
        • 调用 ndarray 的 copy() 函数产生一个副本。
      • 无复制
        • 简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符，类似于 C 中的指针。
        • 此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。
        • 实例
          • import numpy as np a = np.arange(6) print ('我们的数组是：') print (a) print ('调用 id() 函数：') print (id(a)) print ('a 赋值给 b：') b = a print (b) print ('b 拥有相同 id()：') print (id(b)) print ('修改 b 的形状：') b.shape = 3,2 print (b) print ('a 的形状也修改了：') print (a)
            • 我们的数组是： [0 1 2 3 4 5] 调用 id() 函数： 4349302224 a 赋值给 b： [0 1 2 3 4 5] b 拥有相同 id()： 4349302224 修改 b 的形状： [[0 1] [2 3] [4 5]] a 的形状也修改了： [[0 1] [2 3] [4 5]]
      • 视图或浅拷贝
        • ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数变化不会改变原始数据的维数。
        • 实例
          • import numpy as np # 最开始 a 是个 3X2 的数组 a = np.arange(6).reshape(3,2) print ('数组 a：') print (a) print ('创建 a 的视图：') b = a.view() print (b) print ('两个数组的 id() 不同：') print ('a 的 id()：') print (id(a)) print ('b 的 id()：' ) print (id(b)) # 修改 b 的形状，并不会修改 a b.shape = 2,3 print ('b 的形状：') print (b) print ('a 的形状：') print (a)
            • 数组 a： [[0 1] [2 3] [4 5]] 创建 a 的视图： [[0 1] [2 3] [4 5]] 两个数组的 id() 不同： a 的 id()： 4314786992 b 的 id()： 4315171296 b 的形状： [[0 1 2] [3 4 5]] a 的形状： [[0 1] [2 3] [4 5]]
        • 使用切片创建视图修改数据会影响到原始数组：
        • 实例
          • import numpy as np arr = np.arange(12) print ('我们的数组：') print (arr) print ('创建切片：') a=arr[3:] b=arr[3:] a[1]=123 b[2]=234 print(arr) print(id(a),id(b),id(arr[3:]))
            • 我们的数组： [ 0 1 2 3 4 5 6 7 8 9 10 11] 创建切片： [ 0 1 2 3 123 234 6 7 8 9 10 11] 4545878416 4545878496 4545878576
        • 变量 a,b 都是 arr 的一部分视图，对视图的修改会直接反映到原数据中。但是我们观察 a,b 的 id，他们是不同的，也就是说，视图虽然指向原数据，但是他们和赋值引用还是有区别的。
      • 副本或深拷贝
        • ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。
        • 实例
          • import numpy as np a = np.array([[10,10], [2,3], [4,5]]) print ('数组 a：') print (a) print ('创建 a 的深层副本：') b = a.copy() print ('数组 b：') print (b) # b 与 a 不共享任何内容 print ('我们能够写入 b 来写入 a 吗？') print (b is a) print ('修改 b 的内容：') b[0,0] = 100 print ('修改后的数组 b：') print (b) print ('a 保持不变：') print (a)
            • 数组 a： [[10 10] [ 2 3] [ 4 5]] 创建 a 的深层副本： 数组 b： [[10 10] [ 2 3] [ 4 5]] 我们能够写入 b 来写入 a 吗？ False 修改 b 的内容： 修改后的数组 b： [[100 10] [ 2 3] [ 4 5]] a 保持不变： [[10 10] [ 2 3] [ 4 5]]
    • NumPy 矩阵库(Matrix)
      • NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。
      • 一个 的矩阵是一个由行（row）列（column）元素排列成的矩形阵列。
      • 矩阵里的元素可以是数字、符号或数学式。以下是一个由 6 个数字元素构成的 2 行 3 列的矩阵：
        • 
      • 转置矩阵
        • NumPy 中除了可以使用 numpy.transpose 函数来对换数组的维度，还可以使用 T 属性。。
        • 例如有个 m 行 n 列的矩阵，使用 t() 函数就能转换为 n 行 m 列的矩阵。
          • 
            • 
          • 
        • 实例
          • import numpy as np a = np.arange(12).reshape(3,4) print ('原数组：') print (a) print ('\n') print ('转置数组：') print (a.T)
            • 原数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] 转置数组： [[ 0 4 8] [ 1 5 9] [ 2 6 10] [ 3 7 11]]
        • matlib.empty()
          • matlib.empty() 函数返回一个新的矩阵，语法格式为：
            • numpy.matlib.empty(shape, dtype, order)
          • 参数说明：
            • shape: 定义新矩阵形状的整数或整数元组
            • Dtype: 可选，数据类型
            • order: C（行序优先） 或者 F（列序优先）
          • 实例
            • import numpy.matlib import numpy as np print (np.matlib.empty((2,2))) # 填充为随机数据
              • [[-1.49166815e-154 -1.49166815e-154] [ 2.17371491e-313 2.52720790e-212]]
        • numpy.matlib.zeros()
          • numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。
          • 实例
            • import numpy.matlib import numpy as np print (np.matlib.zeros((2,2)))
              • [[0. 0.] [0. 0.]]
        • numpy.matlib.ones()
          • numpy.matlib.ones()函数创建一个以 1 填充的矩阵。
          • 实例
            • import numpy.matlib import numpy as np print (np.matlib.ones((2,2)))
              • [[1. 1.] [1. 1.]]
        • numpy.matlib.eye()
          • numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。
            • numpy.matlib.eye(n, M,k, dtype)
          • 参数说明：
            • n: 返回矩阵的行数
            • M: 返回矩阵的列数，默认为 n
            • k: 对角线的索引
            • dtype: 数据类型
          • 实例
            • import numpy.matlib import numpy as np print (np.matlib.eye(n = 3, M = 4, k = 0, dtype = float))
              • [[1. 0. 0. 0.] [0. 1. 0. 0.] [0. 0. 1. 0.]]
        • numpy.matlib.identity()
          • numpy.matlib.identity() 函数返回给定大小的单位矩阵。
          • 单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。
          • 
          • 实例
            • import numpy.matlib import numpy as np # 大小为 5，类型位浮点型 print (np.matlib.identity(5, dtype = float))
              • [[ 1. 0. 0. 0. 0.] [ 0. 1. 0. 0. 0.] [ 0. 0. 1. 0. 0.] [ 0. 0. 0. 1. 0.] [ 0. 0. 0. 0. 1.]]
        • numpy.matlib.rand()
          • numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。
          • 实例
            • import numpy.matlib import numpy as np print (np.matlib.rand(3,3))
              • [[0.23966718 0.16147628 0.14162 ] [0.28379085 0.59934741 0.62985825] [0.99527238 0.11137883 0.41105367]]
          • 矩阵总是二维的，而 ndarray 是一个 n 维数组。 两个对象都是可互换的。
          • 实例
            • import numpy.matlib import numpy as np i = np.matrix('1,2;3,4') print (i)
              • [[1 2] [3 4]]
          • 实例
            • import numpy.matlib import numpy as np j = np.asarray(i) print (j)
              • [[1 2] [3 4]]
          • 实例
            • import numpy.matlib import numpy as np k = np.asmatrix (j) print (k)
              • [[1 2] [3 4]]
    • NumPy 线性代数
      • NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能，可以看看下面的说明：
        • 函数 描述
        • dot 两个数组的点积，即元素对应相乘。
        • vdot 两个向量的点积
        • inner 两个数组的内积
        • matmul 两个数组的矩阵积
        • determinant 数组的行列式
        • solve 求解线性矩阵方程
        • inv 计算矩阵的乘法逆矩阵
      • numpy.dot()
        • numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。
          • numpy.dot(a, b, out=None)
        • 参数说明：
          • a : ndarray 数组
          • b : ndarray 数组
          • out : ndarray, 可选，用来保存dot()的计算结果
        • 实例
          • import numpy.matlib import numpy as np a = np.array([[1,2],[3,4]]) b = np.array([[11,12],[13,14]]) print(np.dot(a,b))
            • [[37 40] [85 92]]
        • 计算式为：
          • [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
      • numpy.vdot()
        • numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。
        • 实例
          • import numpy as np a = np.array([[1,2],[3,4]]) b = np.array([[11,12],[13,14]]) # vdot 将数组展开计算内积 print (np.vdot(a,b))
            • 130
        • 计算式为：
          • 1*11 + 2*12 + 3*13 + 4*14 = 130
      • numpy.inner()
        • numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。
        • 实例
          • import numpy as np print (np.inner(np.array([1,2,3]),np.array([0,1,0]))) # 等价于 1*0+2*1+3*0
            • 2
        • 多维数组实例
          • import numpy as np a = np.array([[1,2], [3,4]]) print ('数组 a：') print (a) b = np.array([[11, 12], [13, 14]]) print ('数组 b：') print (b) print ('内积：') print (np.inner(a,b))
            • 数组 a： [[1 2] [3 4]] 数组 b： [[11 12] [13 14]] 内积： [[35 41] [81 95]] 数组 a： [[1 2] [3 4]] 数组 b： [[11 12] [13 14]] 内积： [[35 41] [81 95]]
        • 内积计算式为：
          • 1*11+2*12, 1*13+2*14 3*11+4*12, 3*13+4*14
      • numpy.matmul
        • numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
        • 另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。
        • 对于二维数组，它就是矩阵乘法：
        • 实例
          • import numpy.matlib import numpy as np a = [[1,0],[0,1]] b = [[4,1],[2,2]] print (np.matmul(a,b))
            • [[4 1] [2 2]]
        • 二维和一维运算：
          • 实例
            • import numpy.matlib import numpy as np a = [[1,0],[0,1]] b = [1,2] print (np.matmul(a,b)) print (np.matmul(b,a))
              • [1 2] [1 2]
        • 维度大于二的数组 ：
          • 实例
            • import numpy.matlib import numpy as np a = np.arange(8).reshape(2,2,2) b = np.arange(4).reshape(2,2) print (np.matmul(a,b))
              • [[[ 2 3] [ 6 11]] [[10 19] [14 27]]]
      • numpy.linalg.det()
        • numpy.linalg.det() 函数计算输入矩阵的行列式。
        • 行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。
        • 换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为 ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。
        • 实例
          • import numpy as np a = np.array([[1,2], [3,4]]) print (np.linalg.det(a))
            • -2.0
        • 实例
          • import numpy as np b = np.array([[6,1,1], [4, -2, 5], [2,8,7]]) print (b) print (np.linalg.det(b)) print (6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))
            • [[ 6 1 1] [ 4 -2 5] [ 2 8 7]] -306.0 -306
      • numpy.linalg.solve()
        • numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。
        • 考虑以下线性方程：
          • x + y + z = 6 2y + 5z = -4 2x + 5y - z = 27
        • 可以使用矩阵表示为：
          • 
        • 如果矩阵成为A、X和B，方程变为：
          • AX = B 或 X = A^(-1)B
      • numpy.linalg.inv()
        • numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。
        • 逆矩阵（inverse matrix）：设A是数域上的一个n阶矩阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。
        • 实例
          • import numpy as np x = np.array([[1,2],[3,4]]) y = np.linalg.inv(x) print (x) print (y) print (np.dot(x,y))
            • [[1 2] [3 4]] [[-2. 1. ] [ 1.5 -0.5]] [[1.0000000e+00 0.0000000e+00] [8.8817842e-16 1.0000000e+00]]
        • 现在创建一个矩阵A的逆矩阵:
        • 实例
          • import numpy as np a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) print ('数组 a：') print (a) ainv = np.linalg.inv(a) print ('a 的逆：') print (ainv) print ('矩阵 b：') b = np.array([[6],[-4],[27]]) print (b) print ('计算：A^(-1)B：') x = np.linalg.solve(a,b) print (x) # 这就是线性方向 x = 5, y = 3, z = -2 的解
            • 数组 a： [[ 1 1 1] [ 0 2 5] [ 2 5 -1]] a 的逆： [[ 1.28571429 -0.28571429 -0.14285714] [-0.47619048 0.14285714 0.23809524] [ 0.19047619 0.14285714 -0.0952381 ]] 矩阵 b： [[ 6] [-4] [27]] 计算：A^(-1)B： [[ 5.] [ 3.] [-2.]]
        • 结果也可以使用以下函数获取：
          • x = np.dot(ainv,b)
    • NumPy IO
      • Numpy 可以读写磁盘上的文本数据或二进制数据。
      • NumPy 为 ndarray 对象引入了一个简单的文件格式：npy。
      • npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。
      • 常用的 IO 函数有：
        • load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。
        • savez() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。
        • loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)
      • numpy.save()
        • numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。
          • numpy.save(file, arr, allow_pickle=True, fix_imports=True)
        • 参数说明：
          • file：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
          • arr: 要保存的数组
          • allow_pickle: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
          • fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。
        • 实例
          • import numpy as np a = np.array([1,2,3,4,5]) # 保存到 outfile.npy 文件上 np.save('outfile.npy',a) # 保存到 outfile2.npy 文件上，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上 np.save('outfile2',a)
            • 我们可以查看文件内容：
            • $ cat outfile.npy ?NUMPYv{'descr': '<i8', 'fortran_order': False, 'shape': (5,), } $ cat outfile2.npy ?NUMPYv{'descr': '<i8', 'fortran_order': False, 'shape': (5,), }
        • 可以看出文件是乱码的，因为它们是 Numpy 专用的二进制格式后的数据。
        • 我们可以使用 load() 函数来读取数据就可以正常显示了：
        • 实例
          • import numpy as np b = np.load('outfile.npy') print (b)
            • [1 2 3 4 5]
      • np.savez
        • numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。
          • numpy.savez(file, *args, **kwds)
        • 参数说明：
          • file：要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上。
          • args: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …　。
          • kwds: 要保存的数组使用关键字名称。
        • 实例
          • import numpy as np a = np.array([[1,2,3],[4,5,6]]) b = np.arange(0, 1.0, 0.1) c = np.sin(b) # c 使用了关键字参数 sin_array np.savez("runoob.npz", a, b, sin_array = c) r = np.load("runoob.npz") print(r.files) # 查看各个数组名称 print(r["arr_0"]) # 数组 a print(r["arr_1"]) # 数组 b print(r["sin_array"]) # 数组 c
            • ['sin_array', 'arr_0', 'arr_1'] [[1 2 3] [4 5 6]] [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9] [0. 0.09983342 0.19866933 0.29552021 0.38941834 0.47942554 0.56464247 0.64421769 0.71735609 0.78332691]
      • savetxt()
        • savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。
          • np.loadtxt(FILENAME, dtype=int, delimiter=' ') np.savetxt(FILENAME, a, fmt="%d", delimiter=",")
        • 参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。
        • 实例
          • import numpy as np a = np.array([1,2,3,4,5]) np.savetxt('out.txt',a) b = np.loadtxt('out.txt') print(b)
            • [1. 2. 3. 4. 5.]
        • 使用 delimiter 参数：
          • 实例
            • import numpy as np a=np.arange(0,10,0.5).reshape(4,-1) np.savetxt("out.txt",a,fmt="%d",delimiter=",") # 改为保存为整数，以逗号分隔 b = np.loadtxt("out.txt",delimiter=",") # load 时也要指定为逗号分隔 print(b)
              • [[0. 0. 1. 1. 2.] [2. 3. 3. 4. 4.] [5. 5. 6. 6. 7.] [7. 8. 8. 9. 9.]]
    • NumPy Matplotlib
      • Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。
      • pip3 安装：
        • pip3 install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple
      • Linux 系统也可以使用 Linux 包管理器来安装：
        • Debian / Ubuntu：
          • sudo apt-get install python-matplotlib
        • Fedora / Redhat：
          • sudo yum install python-matplotlib
      • 安装完后，你可以使用 python -m pip list 命令来查看是否安装了 matplotlib 模块。
        • $ pip3 list | grep matplotlib
        • matplotlib 3.3.0
      • 实例
        • 实例
          • import numpy as np from matplotlib import pyplot as plt x = np.arange(1,11) y = 2 * x + 5 plt.title("Matplotlib demo") plt.xlabel("x axis caption") plt.ylabel("y axis caption") plt.plot(x,y) plt.show()
          • 以上实例中，np.arange() 函数创建 x 轴上的值。y 轴上的对应值存储在另一个数组对象 y 中。 这些值使用 matplotlib 软件包的 pyplot 子模块的 plot() 函数绘制。
          • 图形由 show() 函数显示。
            • 
      • 图形中文显示
        • Matplotlib 默认情况不支持中文，我们可以使用以下简单的方法来解决。
        • 这里我们使用思源黑体，思源黑体是 Adobe 与 Google 推出的一款开源字体。
        • 官网：https://source.typekit.com/source-han-serif/cn/
        • GitHub 地址：https://github.com/adobe-fonts/source-han-sans/tree/release/OTF/SimplifiedChinese
        • 打开链接后，在里面选一个就好了：
          • 
        • 你也可以在网盘下载: https://pan.baidu.com/s/14cRhgYvvYotVIFkRVd71fQ。
        • 可以下载个 OTF 字体，比如 SourceHanSansSC-Bold.otf，将该文件文件放在当前执行的代码文件中：
        • SourceHanSansSC-Bold.otf 文件放在当前执行的代码文件中：
        • 实例
          • import numpy as np from matplotlib import pyplot as plt import matplotlib # fname 为 你下载的字体库路径，注意 SourceHanSansSC-Bold.otf 字体的路径 zhfont1 = matplotlib.font_manager.FontProperties(fname="SourceHanSansSC-Bold.otf") x = np.arange(1,11) y = 2 * x + 5 plt.title("菜鸟教程 - 测试", fontproperties=zhfont1) # fontproperties 设置中文显示，fontsize 设置字体大小 plt.xlabel("x 轴", fontproperties=zhfont1) plt.ylabel("y 轴", fontproperties=zhfont1) plt.plot(x,y) plt.show()
            • 执行输出结果如下图：
            • 
          • 此外，我们还可以使用系统的字体：
            • from matplotlib import pyplot as plt import matplotlib a=sorted([f.name for f in matplotlib.font_manager.fontManager.ttflist]) for i in a: print(i)
          • 打印出你的 font_manager 的 ttflist 中所有注册的名字，找一个看中文字体例如：STFangsong(仿宋）,然后添加以下代码即可：
            • plt.rcParams['font.family']=['STFangsong']
        • 作为线性图的替代，可以通过向 plot() 函数添加格式字符串来显示离散值。 可以使用以下格式化字符。
          • 字符 描述 '-' 实线样式 '--' 短横线样式 '-.' 点划线样式 ':' 虚线样式 '.' 点标记 ',' 像素标记 'o' 圆标记 'v' 倒三角标记 '^' 正三角标记 '&lt;' 左三角标记 '&gt;' 右三角标记 '1' 下箭头标记 '2' 上箭头标记 '3' 左箭头标记 '4' 右箭头标记 's' 正方形标记 'p' 五边形标记 '*' 星形标记 'h' 六边形标记 1 'H' 六边形标记 2 '+' 加号标记 'x' X 标记 'D' 菱形标记 'd' 窄菱形标记 '&#124;' 竖直线标记 '_' 水平线标记
        • 以下是颜色的缩写：
          • 字符 颜色 'b' 蓝色 'g' 绿色 'r' 红色 'c' 青色 'm' 品红色 'y' 黄色 'k' 黑色 'w' 白色
        • 要显示圆来代表点，而不是上面示例中的线，请使用 ob 作为 plot() 函数中的格式字符串。
        • 实例
          • import numpy as np from matplotlib import pyplot as plt x = np.arange(1,11) y = 2 * x + 5 plt.title("Matplotlib demo") plt.xlabel("x axis caption") plt.ylabel("y axis caption") plt.plot(x,y,"ob") plt.show()
            • 执行输出结果如下图：
              • 
      • 绘制正弦波
        • 以下实例使用 matplotlib 生成正弦波图。
        • 实例
          • import numpy as np import matplotlib.pyplot as plt # 计算正弦曲线上点的 x 和 y 坐标 x = np.arange(0, 3 * np.pi, 0.1) y = np.sin(x) plt.title("sine wave form") # 使用 matplotlib 来绘制点 plt.plot(x, y) plt.show()
            • 执行输出结果如下图：
              • 
        • subplot()
          • subplot() 函数允许你在同一图中绘制不同的东西。
          • 以下实例绘制正弦和余弦值:
          • 实例
            • import numpy as np import matplotlib.pyplot as plt # 计算正弦和余弦曲线上的点的 x 和 y 坐标 x = np.arange(0, 3 * np.pi, 0.1) y_sin = np.sin(x) y_cos = np.cos(x) # 建立 subplot 网格，高为 2，宽为 1 # 激活第一个 subplot plt.subplot(2, 1, 1) # 绘制第一个图像 plt.plot(x, y_sin) plt.title('Sine') # 将第二个 subplot 激活，并绘制第二个图像 plt.subplot(2, 1, 2) plt.plot(x, y_cos) plt.title('Cosine') # 展示图像 plt.show()
              • 执行输出结果如下图：
                • 
        • bar()
          • pyplot 子模块提供 bar() 函数来生成条形图。
          • 以下实例生成两组 x 和 y 数组的条形图。
          • 实例
            • from matplotlib import pyplot as plt x = [5,8,10] y = [12,16,6] x2 = [6,9,11] y2 = [6,15,7] plt.bar(x, y, align = 'center') plt.bar(x2, y2, color = 'g', align = 'center') plt.title('Bar graph') plt.ylabel('Y axis') plt.xlabel('X axis') plt.show()
              • 执行输出结果如下图：
                • 
        • numpy.histogram()
          • numpy.histogram() 函数是数据的频率分布的图形表示。 水平尺寸相等的矩形对应于类间隔，称为 bin，变量 height 对应于频率。
          • numpy.histogram()函数将输入数组和 bin 作为两个参数。 bin 数组中的连续元素用作每个 bin 的边界。
          • 实例
            • import numpy as np a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) np.histogram(a,bins = [0,20,40,60,80,100]) hist,bins = np.histogram(a,bins = [0,20,40,60,80,100]) print (hist) print (bins)
              • [3 4 5 2 1] [ 0 20 40 60 80 100]
        • plt()
          • Matplotlib 可以将直方图的数字表示转换为图形。 pyplot 子模块的 plt() 函数将包含数据和 bin 数组的数组作为参数，并转换为直方图。
          • 实例
            • from matplotlib import pyplot as plt import numpy as np a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) plt.hist(a, bins = [0,20,40,60,80,100]) plt.title("histogram") plt.show()
              • 执行输出结果如下图：
                • 
  • Pandas 教程
    • Pandas 数据结构 - Series
      • Pandas Series 类似表格中的一个列（column），类似于一维数组，可以保存任何数据类型。
      • Series 由索引（index）和列组成，函数如下：
        • pandas.Series( data, index, dtype, name, copy)
      • 参数说明：
        • data：一组数据(ndarray 类型)。
        • index：数据索引标签，如果不指定，默认从 0 开始。
        • dtype：数据类型，默认会自己判断。
        • name：设置名称。
        • copy：拷贝数据，默认为 False。
      • 创建一个简单的 Series 实例：
      • 实例
        • import pandas as pd a = [1, 2, 3] myvar = pd.Series(a) print(myvar)
          • 输出结果如下：
            • 
      • 从上图可知，如果没有指定索引，索引值就从 0 开始，我们可以根据索引值读取数据：
      • 实例
        • import pandas as pd a = [1, 2, 3] myvar = pd.Series(a) print(myvar[1])
          • 2
      • 我们可以指定索引值，如下实例：
        • 实例
          • import pandas as pd a = ["Google", "Runoob", "Wiki"] myvar = pd.Series(a, index = ["x", "y", "z"]) print(myvar)
            • 输出结果如下：
              • 
      • 根据索引值读取数据:
        • 实例
          • import pandas as pd a = ["Google", "Runoob", "Wiki"] myvar = pd.Series(a, index = ["x", "y", "z"]) print(myvar["y"])
            • Runoob
      • 我们也可以使用 key/value 对象，类似字典来创建 Series：
        • 实例
          • import pandas as pd sites = {1: "Google", 2: "Runoob", 3: "Wiki"} myvar = pd.Series(sites) print(myvar)
            • 输出结果如下：
              • 
        • 从上图可知，字典的 key 变成了索引值。
      • 如果我们只需要字典中的一部分数据，只需要指定需要数据的索引即可，如下实例：
        • 实例
          • import pandas as pd sites = {1: "Google", 2: "Runoob", 3: "Wiki"} myvar = pd.Series(sites, index = [1, 2]) print(myvar)
            • 输出结果如下：
              • 
      • 设置 Series 名称参数：
        • 实例
          • import pandas as pd sites = {1: "Google", 2: "Runoob", 3: "Wiki"} myvar = pd.Series(sites, index = [1, 2], name="RUNOOB-Series-TEST" ) print(myvar)
            • 
    • Pandas 数据结构 - DataFrame
      • DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。
      • 
      • 
      • DataFrame 构造方法如下：
        • pandas.DataFrame( data, index, columns, dtype, copy)
      • 参数说明：
        • data：一组数据(ndarray、series, map, lists, dict 等类型)。
        • index：索引值，或者可以称为行标签。
        • columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。
        • dtype：数据类型。
        • copy：拷贝数据，默认为 False。
      • Pandas DataFrame 是一个二维的数组结构，类似二维数组。
        • 实例 - 使用列表创建
          • import pandas as pd data = [['Google',10],['Runoob',12],['Wiki',13]] df = pd.DataFrame(data,columns=['Site','Age'],dtype=float) print(df)
            • 
      • 以下实例使用 ndarrays 创建，ndarray 的长度必须相同， 如果传递了 index，则索引的长度应等于数组的长度。如果没有传递索引，则默认情况下，索引将是range(n)，其中n是数组长度。
      • ndarrays 可以参考：NumPy Ndarray 对象
        • 实例 - 使用 ndarrays 创建
          • import pandas as pd data = {'Site':['Google', 'Runoob', 'Wiki'], 'Age':[10, 12, 13]} df = pd.DataFrame(data) print (df)
            • 输出结果如下：
              • 
        • 从以上输出结果可以知道， DataFrame 数据类型一个表格，包含 rows（行） 和 columns（列）：
          • 
        • 还可以使用字典（key/value），其中字典的 key 为列名:
          • 实例 - 使用字典创建
            • import pandas as pd data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}] df = pd.DataFrame(data) print (df)
              • a b c 0 1 2 NaN 1 5 10 20.0
      • 没有对应的部分数据为 NaN。
        • Pandas 可以使用 loc 属性返回指定行的数据，如果没有设置索引，第一行索引为 0，第二行索引为 1，以此类推：
        • 实例
          • import pandas as pd data = { "calories": [420, 380, 390], "duration": [50, 40, 45] } # 数据载入到 DataFrame 对象 df = pd.DataFrame(data) # 返回第一行 print(df.loc[0]) # 返回第二行 print(df.loc[1])
            • calories 420 duration 50 Name: 0, dtype: int64 calories 380 duration 40 Name: 1, dtype: int64
      • 注意：返回结果其实就是一个 Pandas Series 数据。
      • 也可以返回多行数据，使用 [[ ... ]] 格式，... 为各行的索引，以逗号隔开：
        • 实例
          • import pandas as pd data = { "calories": [420, 380, 390], "duration": [50, 40, 45] } # 数据载入到 DataFrame 对象 df = pd.DataFrame(data) # 返回第一行和第二行 print(df.loc[[0, 1]])
            • calories duration 0 420 50 1 380 40
      • 注意：返回结果其实就是一个 Pandas DataFrame 数据。
      • 我们可以指定索引值，如下实例：
        • 实例
          • import pandas as pd data = { "calories": [420, 380, 390], "duration": [50, 40, 45] } df = pd.DataFrame(data, index = ["day1", "day2", "day3"]) print(df)
            • calories duration day1 420 50 day2 380 40 day3 390 45
      • Pandas 可以使用 loc 属性返回指定索引 对应到某一行：
        • 实例
          • import pandas as pd data = { "calories": [420, 380, 390], "duration": [50, 40, 45] } df = pd.DataFrame(data, index = ["day1", "day2", "day3"]) # 指定索引 print(df.loc["day2"])
            • calories 380 duration 40 Name: day2, dtype: int64
    • Pandas CSV 文件
      • CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。
      • CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。
      • Pandas 可以很方便的处理 CSV 文件，本文以 nba.csv 为例，你可以下载 nba.csv 或打开 nba.csv 查看。
      • 实例
        • import pandas as pd df = pd.read_csv('nba.csv') print(df.to_string())
      • to_string() 用于返回 DataFrame 类型的数据，如果不使用该函数，则输出结果为数据的前面 5 行和末尾 5 行，中间部分以 ... 代替。
        • 实例
          • import pandas as pd df = pd.read_csv('nba.csv') print(df)
            • Name Team Number Position Age Height Weight College Salary 0 Avery Bradley Boston Celtics 0.0 PG 25.0 6-2 180.0 Texas 7730337.0 1 Jae Crowder Boston Celtics 99.0 SF 25.0 6-6 235.0 Marquette 6796117.0 2 John Holland Boston Celtics 30.0 SG 27.0 6-5 205.0 Boston University NaN 3 R.J. Hunter Boston Celtics 28.0 SG 22.0 6-5 185.0 Georgia State 1148640.0 4 Jonas Jerebko Boston Celtics 8.0 PF 29.0 6-10 231.0 NaN 5000000.0 .. ... ... ... ... ... ... ... ... ... 453 Shelvin Mack Utah Jazz 8.0 PG 26.0 6-3 203.0 Butler 2433333.0 454 Raul Neto Utah Jazz 25.0 PG 24.0 6-1 179.0 NaN 900000.0 455 Tibor Pleiss Utah Jazz 21.0 C 26.0 7-3 256.0 NaN 2900000.0 456 Jeff Withey Utah Jazz 24.0 C 26.0 7-0 231.0 Kansas 947276.0 457 NaN NaN NaN NaN NaN NaN NaN NaN NaN
      • 我们也可以使用 to_csv() 方法将 DataFrame 存储为 csv 文件：
        • 实例
          • import pandas as pd # 三个字段 name, site, age nme = ["Google", "Runoob", "Taobao", "Wiki"] st = ["www.google.com", "www.runoob.com", "www.taobao.com", "www.wikipedia.org"] ag = [90, 40, 80, 98] # 字典 dict = {'name': nme, 'site': st, 'age': ag} df = pd.DataFrame(dict) # 保存 dataframe df.to_csv('site.csv')
        • 执行成功后，我们打开 site.csv 文件，显示结果如下：
          • 
      • 数据处理
        • head()
          • head( n ) 方法用于读取前面的 n 行，如果不填参数 n ，默认返回 5 行。
          • 实例 - 读取前面 5 行
            • import pandas as pd df = pd.read_csv('nba.csv') print(df.head())
              • Name Team Number Position Age Height Weight College Salary 0 Avery Bradley Boston Celtics 0.0 PG 25.0 6-2 180.0 Texas 7730337.0 1 Jae Crowder Boston Celtics 99.0 SF 25.0 6-6 235.0 Marquette 6796117.0 2 John Holland Boston Celtics 30.0 SG 27.0 6-5 205.0 Boston University NaN 3 R.J. Hunter Boston Celtics 28.0 SG 22.0 6-5 185.0 Georgia State 1148640.0 4 Jonas Jerebko Boston Celtics 8.0 PF 29.0 6-10 231.0 NaN 5000000.0
          • 实例 - 读取前面 10 行
            • import pandas as pd df = pd.read_csv('nba.csv') print(df.head(10))
              • Name Team Number Position Age Height Weight College Salary 0 Avery Bradley Boston Celtics 0.0 PG 25.0 6-2 180.0 Texas 7730337.0 1 Jae Crowder Boston Celtics 99.0 SF 25.0 6-6 235.0 Marquette 6796117.0 2 John Holland Boston Celtics 30.0 SG 27.0 6-5 205.0 Boston University NaN 3 R.J. Hunter Boston Celtics 28.0 SG 22.0 6-5 185.0 Georgia State 1148640.0 4 Jonas Jerebko Boston Celtics 8.0 PF 29.0 6-10 231.0 NaN 5000000.0 5 Amir Johnson Boston Celtics 90.0 PF 29.0 6-9 240.0 NaN 12000000.0 6 Jordan Mickey Boston Celtics 55.0 PF 21.0 6-8 235.0 LSU 1170960.0 7 Kelly Olynyk Boston Celtics 41.0 C 25.0 7-0 238.0 Gonzaga 2165160.0 8 Terry Rozier Boston Celtics 12.0 PG 22.0 6-2 190.0 Louisville 1824360.0 9 Marcus Smart Boston Celtics 36.0 PG 22.0 6-4 220.0 Oklahoma State 3431040.0
        • tail()
          • tail( n ) 方法用于读取尾部的 n 行，如果不填参数 n ，默认返回 5 行，空行各个字段的值返回 NaN。
          • 实例 - 读取末尾 5 行
            • import pandas as pd df = pd.read_csv('nba.csv') print(df.tail())
              • Name Team Number Position Age Height Weight College Salary 453 Shelvin Mack Utah Jazz 8.0 PG 26.0 6-3 203.0 Butler 2433333.0 454 Raul Neto Utah Jazz 25.0 PG 24.0 6-1 179.0 NaN 900000.0 455 Tibor Pleiss Utah Jazz 21.0 C 26.0 7-3 256.0 NaN 2900000.0 456 Jeff Withey Utah Jazz 24.0 C 26.0 7-0 231.0 Kansas 947276.0 457 NaN NaN NaN NaN NaN NaN NaN NaN NaN
          • 实例 - 读取末尾 10 行
            • import pandas as pd df = pd.read_csv('nba.csv') print(df.tail(10))
              • Name Team Number Position Age Height Weight College Salary 448 Gordon Hayward Utah Jazz 20.0 SF 26.0 6-8 226.0 Butler 15409570.0 449 Rodney Hood Utah Jazz 5.0 SG 23.0 6-8 206.0 Duke 1348440.0 450 Joe Ingles Utah Jazz 2.0 SF 28.0 6-8 226.0 NaN 2050000.0 451 Chris Johnson Utah Jazz 23.0 SF 26.0 6-6 206.0 Dayton 981348.0 452 Trey Lyles Utah Jazz 41.0 PF 20.0 6-10 234.0 Kentucky 2239800.0 453 Shelvin Mack Utah Jazz 8.0 PG 26.0 6-3 203.0 Butler 2433333.0 454 Raul Neto Utah Jazz 25.0 PG 24.0 6-1 179.0 NaN 900000.0 455 Tibor Pleiss Utah Jazz 21.0 C 26.0 7-3 256.0 NaN 2900000.0 456 Jeff Withey Utah Jazz 24.0 C 26.0 7-0 231.0 Kansas 947276.0 457 NaN NaN NaN NaN NaN NaN NaN NaN NaN
        • info()
          • info() 方法返回表格的一些基本信息：
          • 实例
            • import pandas as pd df = pd.read_csv('nba.csv') print(df.info())
              • <class 'pandas.core.frame.DataFrame'> RangeIndex: 458 entries, 0 to 457 # 行数，458 行，第一行编号为 0 Data columns (total 9 columns): # 列数，9列 # Column Non-Null Count Dtype # 各列的数据类型 --- ------ -------------- ----- 0 Name 457 non-null object 1 Team 457 non-null object 2 Number 457 non-null float64 3 Position 457 non-null object 4 Age 457 non-null float64 5 Height 457 non-null object 6 Weight 457 non-null float64 7 College 373 non-null object # non-null，意思为非空的数据 8 Salary 446 non-null float64 dtypes: float64(4), object(5) # 类型
          • non-null 为非空数据，我们可以看到上面的信息中，总共 458 行，College 字段的空值最多。
    • Pandas JSON
      • JSON（JavaScript Object Notation，JavaScript 对象表示法），是存储和交换文本信息的语法，类似 XML。
      • JSON 比 XML 更小、更快，更易解析，更多 JSON 内容可以参考 JSON 教程。
      • Pandas 可以很方便的处理 JSON 数据，本文以 sites.json 为例，内容如下：
        • 实例
          • [ { "id": "A001", "name": "菜鸟教程", "url": "www.runoob.com", "likes": 61 }, { "id": "A002", "name": "Google", "url": "www.google.com", "likes": 124 }, { "id": "A003", "name": "淘宝", "url": "www.taobao.com", "likes": 45 } ]
      • 实例
        • import pandas as pd df = pd.read_json('sites.json') print(df.to_string())
        • to_string() 用于返回 DataFrame 类型的数据，我们也可以直接处理 JSON 字符串。
      • 实例
        • import pandas as pd data =[ { "id": "A001", "name": "菜鸟教程", "url": "www.runoob.com", "likes": 61 }, { "id": "A002", "name": "Google", "url": "www.google.com", "likes": 124 }, { "id": "A003", "name": "淘宝", "url": "www.taobao.com", "likes": 45 } ] df = pd.DataFrame(data) print(df)
          • id name url likes 0 A001 菜鸟教程 www.runoob.com 61 1 A002 Google www.google.com 124 2 A003 淘宝 www.taobao.com 45
      • JSON 对象与 Python 字典具有相同的格式，所以我们可以直接将 Python 字典转化为 DataFrame 数据：
        • 实例
          • import pandas as pd data =[ { "id": "A001", "name": "菜鸟教程", "url": "www.runoob.com", "likes": 61 }, { "id": "A002", "name": "Google", "url": "www.google.com", "likes": 124 }, { "id": "A003", "name": "淘宝", "url": "www.taobao.com", "likes": 45 } ] df = pd.DataFrame(data) print(df)
            • id name url likes 0 A001 菜鸟教程 www.runoob.com 61 1 A002 Google www.google.com 124 2 A003 淘宝 www.taobao.com 45
      • JSON 对象与 Python 字典具有相同的格式，所以我们可以直接将 Python 字典转化为 DataFrame 数据：
        • 实例
          • import pandas as pd # 字典格式的 JSON s = { "col1":{"row1":1,"row2":2,"row3":3}, "col2":{"row1":"x","row2":"y","row3":"z"} } # 读取 JSON 转为 DataFrame df = pd.DataFrame(s) print(df)
            • col1 col2 row1 1 x row2 2 y row3 3 z
      • 从 URL 中读取 JSON 数据：
        • 实例
          • import pandas as pd URL = 'https://static.runoob.com/download/sites.json' df = pd.read_json(URL) print(df)
            • id name url likes 0 A001 菜鸟教程 www.runoob.com 61 1 A002 Google www.google.com 124 2 A003 淘宝 www.taobao.com 45
      • 内嵌的 JSON 数据
        • 假设有一组内嵌的 JSON 数据文件 nested_list.json ：
          • nested_list.json 文件内容
            • { "school_name": "ABC primary school", "class": "Year 1", "students": [ { "id": "A001", "name": "Tom", "math": 60, "physics": 66, "chemistry": 61 }, { "id": "A002", "name": "James", "math": 89, "physics": 76, "chemistry": 51 }, { "id": "A003", "name": "Jenny", "math": 79, "physics": 90, "chemistry": 78 }] }
          • 使用以下代码格式化完整内容：
            • 实例
              • import pandas as pd df = pd.read_json('nested_list.json') print(df)
                • school_name class students 0 ABC primary school Year 1 {'id': 'A001', 'name': 'Tom', 'math': 60, 'phy... 1 ABC primary school Year 1 {'id': 'A002', 'name': 'James', 'math': 89, 'p... 2 ABC primary school Year 1 {'id': 'A003', 'name': 'Jenny', 'math': 79, 'p...
          • 这时我们就需要使用到 json_normalize() 方法将内嵌的数据完整的解析出来：
            • 实例
              • import pandas as pd import json # 使用 Python JSON 模块载入数据 with open('nested_list.json','r') as f: data = json.loads(f.read()) # 展平数据 df_nested_list = pd.json_normalize(data, record_path =['students']) print(df_nested_list)
                • id name math physics chemistry 0 A001 Tom 60 66 61 1 A002 James 89 76 51 2 A003 Jenny 79 90 78
        • data = json.loads(f.read()) 使用 Python JSON 模块载入数据。
        • json_normalize() 使用了参数 record_path 并设置为 ['students'] 用于展开内嵌的 JSON 数据 students。
        • 显示结果还没有包含 school_name 和 class 元素，如果需要展示出来可以使用 meta 参数来显示这些元数据：
          • 实例
            • import pandas as pd import json # 使用 Python JSON 模块载入数据 with open('nested_list.json','r') as f: data = json.loads(f.read()) # 展平数据 df_nested_list = pd.json_normalize( data, record_path =['students'], meta=['school_name', 'class'] ) print(df_nested_list)
              • id name math physics chemistry school_name class 0 A001 Tom 60 66 61 ABC primary school Year 1 1 A002 James 89 76 51 ABC primary school Year 1 2 A003 Jenny 79 90 78 ABC primary school Year 1
        • 接下来，让我们尝试读取更复杂的 JSON 数据，该数据嵌套了列表和字典，数据文件 nested_mix.json 如下：
          • nested_mix.json 文件内容
            • { "school_name": "local primary school", "class": "Year 1", "info": { "president": "John Kasich", "address": "ABC road, London, UK", "contacts": { "email": "[e-mail]", "tel": "123456789" } }, "students": [ { "id": "A001", "name": "Tom", "math": 60, "physics": 66, "chemistry": 61 }, { "id": "A002", "name": "James", "math": 89, "physics": 76, "chemistry": 51 }, { "id": "A003", "name": "Jenny", "math": 79, "physics": 90, "chemistry": 78 }] }
          • nested_mix.json 文件转换为 DataFrame：
            • 实例
              • import pandas as pd import json # 使用 Python JSON 模块载入数据 with open('nested_mix.json','r') as f: data = json.loads(f.read()) df = pd.json_normalize( data, record_path =['students'], meta=[ 'class', ['info', 'president'], ['info', 'contacts', 'tel'] ] ) print(df)
                • 以上实例输出结果为：
                  • id name math physics chemistry class info.president info.contacts.tel 0 A001 Tom 60 66 61 Year 1 John Kasich 123456789 1 A002 James 89 76 51 Year 1 John Kasich 123456789 2 A003 Jenny 79 90 78 Year 1 John Kasich 123456789
        • 读取内嵌数据中的一组数据
          • 以下是实例文件 nested_deep.json，我们只读取内嵌中的 math 字段：
            • nested_deep.json 文件内容
              • { "school_name": "local primary school", "class": "Year 1", "students": [ { "id": "A001", "name": "Tom", "grade": { "math": 60, "physics": 66, "chemistry": 61 } }, { "id": "A002", "name": "James", "grade": { "math": 89, "physics": 76, "chemistry": 51 } }, { "id": "A003", "name": "Jenny", "grade": { "math": 79, "physics": 90, "chemistry": 78 } }] }
          • 这里我们需要使用到 glom 模块来处理数据套嵌，glom 模块允许我们使用 . 来访问内嵌对象的属性。
            • 第一次使用我们需要安装 glom：
              • pip3 install glom
            • 实例
              • import pandas as pd from glom import glom df = pd.read_json('nested_deep.json') data = df['students'].apply(lambda row: glom(row, 'grade.math')) print(data)
                • 0 60 1 89 2 79 Name: students, dtype: int64
    • Pandas 数据清洗
      • 数据清洗是对一些没有用的数据进行处理的过程。
      • 很多数据集存在数据缺失、数据格式错误、错误数据或重复数据的情况，如果要对使数据分析更加准确，就需要对这些没有用的数据进行处理。
      • 在这个教程中，我们将利用 Pandas包来进行数据清洗。
      • 本文使用到的测试数据 property-data.csv 如下：
        • 
      • 上表包含来四种空数据：
        • n/a
        • NA
        • —
        • na
      • Pandas 清洗空值
        • 如果我们要删除包含空字段的行，可以使用 dropna() 方法，语法格式如下：
          • DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
        • 参数说明：
          • axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
          • how：默认为 'any' 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how='all' 一行（或列）都是 NA 才去掉这整行。
          • thresh：设置需要多少非空值的数据才可以保留下来的。
          • subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
          • inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。
        • 我们可以通过 isnull() 判断各个单元格是否为空。
        • 实例
          • import pandas as pd df = pd.read_csv('property-data.csv') print (df['NUM_BEDROOMS']) print (df['NUM_BEDROOMS'].isnull())
            • 
          • 以上例子中我们看到 Pandas 把 n/a 和 NA 当作空数据，na 不是空数据，不符合我们要求，我们可以指定空数据类型：
          • 实例
            • import pandas as pd missing_values = ["n/a", "na", "--"] df = pd.read_csv('property-data.csv', na_values = missing_values) print (df['NUM_BEDROOMS']) print (df['NUM_BEDROOMS'].isnull())
              • 
        • 接下来的实例演示了删除包含空数据的行。
          • 实例
            • import pandas as pd df = pd.read_csv('property-data.csv') new_df = df.dropna() print(new_df.to_string())
              • 
        • 注意：默认情况下，dropna() 方法返回一个新的 DataFrame，不会修改源数据。
        • 如果你要修改源数据 DataFrame, 可以使用 inplace = True 参数:
        • 实例
          • import pandas as pd df = pd.read_csv('property-data.csv') df.dropna(inplace = True) print(df.to_string())
            • 
        • 我们也可以移除指定列有空值的行：
          • 实例
            • 移除 ST_NUM 列中字段值为空的行：
              • import pandas as pd df = pd.read_csv('property-data.csv') df.dropna(subset=['ST_NUM'], inplace = True) print(df.to_string())
                • 
        • 我们也可以 fillna() 方法来替换一些空字段：
          • 实例
            • 使用 12345 替换空字段：
              • import pandas as pd df = pd.read_csv('property-data.csv') df.fillna(12345, inplace = True) print(df.to_string())
                • 
        • 我们也可以指定某一个列来替换数据：
          • 实例
            • 使用 12345 替换 PID 为空数据：
              • import pandas as pd df = pd.read_csv('property-data.csv') df['PID'].fillna(12345, inplace = True) print(df.to_string())
                • 
        • 替换空单元格的常用方法是计算列的均值、中位数值或众数。
          • Pandas使用 mean()、median() 和 mode() 方法计算列的均值（所有值加起来的平均值）、中位数值（排序后排在中间的数）和众数（出现频率最高的数）。
          • 实例
            • 使用 mean() 方法计算列的均值并替换空单元格：
              • import pandas as pd df = pd.read_csv('property-data.csv') x = df["ST_NUM"].mean() df["ST_NUM"].fillna(x, inplace = True) print(df.to_string())
                • 
        • 实例
          • 使用 median() 方法计算列的中位数并替换空单元格：
            • import pandas as pd df = pd.read_csv('property-data.csv') x = df["ST_NUM"].median() df["ST_NUM"].fillna(x, inplace = True) print(df.to_string())
          • 以上实例输出结果如下，红框为计算的中位数替换来空单元格：
            • 
        • 实例
          • 使用 mode() 方法计算列的众数并替换空单元格：
            • import pandas as pd df = pd.read_csv('property-data.csv') x = df["ST_NUM"].mode() df["ST_NUM"].fillna(x, inplace = True) print(df.to_string())
              • 
      • Pandas 清洗格式错误数据
        • 数据格式错误的单元格会使数据分析变得困难，甚至不可能。
        • 我们可以通过包含空单元格的行，或者将列中的所有单元格转换为相同格式的数据。
        • 以下实例会格式化日期：
          • 实例
            • import pandas as pd # 第三个日期格式错误 data = { "Date": ['2020/12/01', '2020/12/02' , '20201226'], "duration": [50, 40, 45] } df = pd.DataFrame(data, index = ["day1", "day2", "day3"]) df['Date'] = pd.to_datetime(df['Date']) print(df.to_string())
              • Date duration day1 2020-12-01 50 day2 2020-12-02 40 day3 2020-12-26 45
      • Pandas 清洗错误数据
        • 数据错误也是很常见的情况，我们可以对错误的数据进行替换或移除。
        • 以下实例会替换错误年龄的数据：
          • 实例
            • import pandas as pd person = { "name": ['Google', 'Runoob' , 'Taobao'], "age": [50, 40, 12345] # 12345 年龄数据是错误的 } df = pd.DataFrame(person) df.loc[2, 'age'] = 30 # 修改数据 print(df.to_string())
              • name age 0 Google 50 1 Runoob 40 2 Taobao 30
          • 也可以设置条件语句：
            • 实例
            • 将 age 大于 120 的设置为 120:
              • import pandas as pd person = { "name": ['Google', 'Runoob' , 'Taobao'], "age": [50, 200, 12345] } df = pd.DataFrame(person) for x in df.index: if df.loc[x, "age"] > 120: df.loc[x, "age"] = 120 print(df.to_string())
                • name age 0 Google 50 1 Runoob 120 2 Taobao 120
          • 也可以将错误数据的行删除：
            • 实例
            • 将 age 大于 120 的删除:
              • import pandas as pd person = { "name": ['Google', 'Runoob' , 'Taobao'], "age": [50, 40, 12345] # 12345 年龄数据是错误的 } df = pd.DataFrame(person) for x in df.index: if df.loc[x, "age"] > 120: df.drop(x, inplace = True) print(df.to_string())
                • name age 0 Google 50 1 Runoob 40
      • Pandas 清洗重复数据
        • 如果我们要清洗重复数据，可以使用 duplicated() 和 drop_duplicates() 方法。
        • 如果对应的数据是重复的，duplicated() 会返回 True，否则返回 False。
          • 实例
            • import pandas as pd person = { "name": ['Google', 'Runoob', 'Runoob', 'Taobao'], "age": [50, 40, 40, 23] } df = pd.DataFrame(person) print(df.duplicated())
              • 0 False 1 False 2 True 3 False dtype: bool
        • 删除重复数据，可以直接使用drop_duplicates() 方法。
          • 实例
            • import pandas as pd persons = { "name": ['Google', 'Runoob', 'Runoob', 'Taobao'], "age": [50, 40, 40, 23] } df = pd.DataFrame(persons) df.drop_duplicates(inplace = True) print(df)
              • name age 0 Google 50 1 Runoob 40 3 Taobao 23