精华内容
下载资源
问答
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    ' 原始字符串 •好像反斜杠是一个好东西,但不妨试试打印: >>> str = 'C:\now' •我们可以用反斜杠对自身进行转义: >>> str = 'C:\\now' •原始字符串的使用非常简单,只需要在字符串前边加一个英文字母r即可(则...

    小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等)请往我的资源(https://download.csdn.net/download/qq_32809093/13099592查看

    目录:

    000 愉快的开始
    001 我和Python的第一次亲密接触
    002 用Python设计第一个游戏
    003 小插曲之变量和字符串
    004 改进我们的小游戏
    005 闲聊之Python的数据类型
    006 Pyhon之常用操作符
    007 了不起的分支和循环
    008 了不起的分支和循环2
    009 了不起的分支和循环3
    010 列表:一个打了激素的数组
    011列表:一个打了激素的数组2
    012列表:一个打了激素的数组3
    013元组:戴上了枷锁的列表
    014字符串:各种奇葩的内置方法
    015字符串:格式化
    016 序列!序列!
    017函数:Python的乐高积木
    018 函数:灵活即强大
    019函数:我的地盘听我的(局部变量与全局变量)
    020函数:内嵌函数和闭包
    021函数:lambda表达式
    022 函数:递归是神马
    023 递归:这帮小兔崽子
    024 递归:汉诺塔
    025 字典:当索引不好用时
    026 字典:当索引不好用时2
    027 集合:在我的世界里,你就是唯一
    028 文件:因为懂你,所以永恒
    029 文件:一个任务
    030 文件系统:介绍一个高大上的东西
    031 永久存储:腌制一缸美味的泡菜(pickle)
    032 异常处理:你不可能总是对的
    033 异常处理:你不可能总是对的2
    034 丰富的else语句及简洁的with语句
    035 图形用户界面入门:EasyGui
    036 类和对象:给大家介绍对象
    037 类和对象:面向对象编程
    038 类和对象:继承
    039 类和对象:拾遗
    040 类和对象:一些相关的BIF
    041 魔法方法:构造和析构
    042 魔法方法:算术运算
    043 魔法方法:算术运算2
    044 魔法方法:简单定制
    045 魔法方法:属性访问
    046 魔法方法:描述符(Property的原理)
    047 魔法方法:定制序列
    048 魔法方法:迭代器
    049 乱入:生成器
    050 模块:模块就是程序
    051 模块:__name__='__main__'、搜索路径和包
    052 模块:像个极客一样去思考
    053 论一只爬虫的自我修养
    054 论一只爬虫的自我修养2:实战
    055 论一只爬虫的自我修养3:隐藏

    064 GUI的终极选择:Tkinter
    065 GUI的终极选择:Tkinter2
    066 GUI的终极选择:Tkinter3
    067 GUI的终极选择:Tkinter4
    068 GUI的终极选择:Tkinter5
    069 GUI的终极选择:Tkinter6
    070 GUI的终极选择:Tkinter7
    071 GUI的终极选择:Tkinter8
    073 GUI的终极选择:Tkinter10
    074  GUI的终极选择:Tkinter11
    075 GUI的终极选择:Tkinter12
    076 GUI的终极选择:Tkinter13
    077 GUI的终极选择:Tkinter14

    078 Pygame:初次见面,请大家多多关照

     

    000 愉快的开始

    python跨平台。
    应用范围:操作系统、WEB、3D动画、企业应用、云计算
    大家可以学到什么Python3的所有常用语法、面向对象编程思维、运用模块进行编程、游戏编程、计算机仿真

    Python 是脚本语言
    脚本语言(Scripting language)是电脑编程语言,因此也能让开发者藉以编写出让电脑听命行事的程序。以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则,基于这项原则,使得脚本语言通常比 C 语言、C++语言 或 Java 之类的系统编程语言要简单容易。也让脚本语言另有一些属于脚本语言的特性:
    •  语法和结构通常比较简单
    •  学习和使用通常比较简单
    •  通常以容易修改程序的“解释”作为运行方式,而不需要“编译”
    •  程序的开发产能优于运行性能
    一个脚本可以使得本来要用键盘进行的相互式操作自动化。一个 Shell 脚本主要由原本需要在命令行输入的命令组成,或在一个文本编辑器中,用户可以使用脚本来把一些常用的操作组合成一组串行。主要用来书写这种脚本的语言叫做脚本语言。很多脚本
    语言实际上已经超过简单的用户命令串行的指令,还可以编写更复杂的程序。

    IDLE 是一个 Python Shell,shell 的意思就是“外壳”,基本上来说,就是一个通过键入文本与程序交互的途径!像我们 Windows 那个 cmd 窗口,像 Linux 那个黑乎乎的命令窗口,他们都是 shell,利用他们,我们就可以给操作系统下达命令。同样的,我们可以利用 IDLE 这个 shell 与 Python 进行互动。

    注:在 Python 中不能把两个完全不同的东西加在一起,比如说数字和文本

    如果我需要在一个字符串中嵌入一个双引号,正确的做法是:你可以利用反斜杠(\)对双引号转义:\",或者用单引号引起这个字符串

    001 我和Python的第一次亲密接触

    IDLE启动Python

    IDLE是一个Python Shellshell的意思就是“外壳”,基本上来说,就是一个通过键入文本与程序交互的途径

    我们看到>>>这个提示符,Ta的含义是告诉你,Python已经准备好了,在等着你键入Python指令呢

    好了,大家试试在IDLE里输入:

    >>>print (“I love fishc.com”)

    我们尝试点儿新的东西,我们输入

    >>>print(5+3)

    或者直接输入

    >>>5+3

    不妨在试试计算

    >>>1234567890987654321*987654321012345678

    还有我们可以将两个字符串“相加”在一起,这种做法叫做拼接字符串

    >>>print("well water"+"river")

    先试试

    >>> print("I love fishc.com"*2)

    >>> print("I love fishc.com\n"* 2)

    002 用Python设计第一个游戏

    实例1:

    print("---------我爱鱼C工作室----------")
    temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字:")
    guess = int(temp)
    if guess == 8:
        print("我草,你是小甲鱼心里的蛔虫嘛?!")
        print("哼,猜中了也没有奖励!")
    else:
        print("猜错了,小甲鱼现在心里想的是8!")
        print("游戏结束,不玩啦")

    BIF 就是 Built-in Functions,内置函数。为了方便程序员快速编写脚本程序(脚本就是要编程速度快快快!!!),Python 提供了非常丰富的内置函数,我们只需要直接调用即可,例如 print() 的功能是“打印到屏幕”,input() 的作用是接收用户输入。

    在 Python 或 IDLE 中,输入 dir(__builtins__) 可以看到 Python 提供的内置方法列表(注意,builtins 前后是两个下划线哦)其中小写的就是 BIF。如果想具体查看某个BIF 的功能,比如 input(),可以在 shell 中输入 help(input),就会得到这个 BIF 的功能描述。哦,答案应该是 68 个

    >>> dir(__builtins__)  查看 Python 提供的内置方法列表

    >>> help(input)  查看input的具体使用说明 

    注:

    只有当标识符已经赋值后( Python 的变量是不用先声明的)才能在代码中使用,未赋值的标识符直接使用会导致运行时错误

    缩进是 Python 的灵魂

    Python 不允许 if 条件中赋值,所以 if c = 1: 会报错!

     

    003 小插曲之变量和字符串

    插曲之变量

    变量名就像我们现实社会的名字,把一个值赋值给一个名字时,Ta会存储在内存中,称之为变量(variable),在大多数语言中,都把这种行为称为“给变量赋值”或“把值存储在变量中”。

    不过Python与大多数其他计算机语言的做法稍有不同,Ta并不是把值存储在变量中,而更像是把名字贴在值的上边。

    所以有些Python程序员会说“Python”没有“变量”,只有“名字”。

    需要注意的地方

    在使用变量之前,需要对其先赋值。

    变量名可以包括字母、数字、下划线,但变量名不能以数字开头

    字母可以是大写或小写,但大小写是不同的。也就是说fishcFishC对于Python来说是完全不同的两个名字

    等号(=)是赋值的意思,左边是名字,右边是值,不可写反咯。

    插曲之字符串

    到目前为止,我们所认知的字符串就是引号内的一切东西,我们也把字符串叫做文本,文本和数字是截然不同的,咱看例子:>>>5+8

    >>> '5'+'8'

    要告诉Python你在创建一个字符串,就要在字符两边加上引号,可以是单引号或者双引号Python女士表示不挑剔。但必须成对,你不能一边单引号,另一边却花心的用上双引号结尾。

    如果字符串中需要出现单引号或双引号怎么办

    例如我想打印字符串:Let’s go!

    有两种方法,第一种比较常用,就是使用我们的转义符号(\)对字符串中的引号进行转义:

    >>> 'Let\'s go!'

    原始字符串

    好像反斜杠是一个好东西,但不妨试试打印:

    >>> str = 'C:\now'

    我们可以用反斜杠对自身进行转义:

    >>> str = 'C:\\now'

    原始字符串的使用非常简单,只需要在字符串前边加一个英文字母r即可(则都会以原始字符串输出):

    >>>str = r'C:\now'

    长字符串

    如果希望得到一个跨越多行的字符串,例如:

    我爱鱼C

    正如我爱小甲鱼,

    久久不肯散去……

    这我们就需要使用到三重引号字符串!

     

    004 改进我们的小游戏

    第一个改进要求:猜错的时候程序提示用户当前的输入比答案大了还是小了

    与操作and

    第二个改进要求:程序应该提供多次机会给用户猜测,专业点来讲就是程序需要重复运行某些代码。

    条件分支

    while循环

    实例1:找8

    temp = input("请输入一个数据:")
    guess = int(temp)
    i=0
    while guess != 8 and i < 3:
        i = i + 1
        temp = input("哎呀,猜错了,请重新输入吧:")
        guess = int(temp)
        if guess == 8:
            print("我草,你是小甲鱼心里的蛔虫嘛?")
            print("哼,猜对了也没有奖励")
        else:
            if guess > 8:
                print("哥,大了大了~~")
            else:
                print("嘿,小了!小了!!")
    print("游戏结束,不玩啦~~")

    random模块里边有一个函数叫做:randint()Ta会返回一个随机的整数。

    实例2:找随机数

    import random#导入随机数函数
    secret = random.randint(1,5)#随机生成1到5的一个随机数
    temp = input("请输入一个1-5的数据:")
    guess = int(temp)
    i=0
    while guess != secret and i < 6:
        i = i + 1
        guess = int(temp)
        if guess == secret:
            print("我草,你是小甲鱼心里的蛔虫嘛?")
            print("哼,猜对了也没有奖励")
        else:
            if guess > secret:
                print("哥,大了大了~~")
            else:
                print("嘿,小了!小了!!")      
            temp = input("请重新输入吧:")
    print("游戏结束,不玩啦~~")

     

    005 闲聊之Python的数据类型

    Python的一些数值类型:整型、布尔类型(True与False)、浮点型、e记法、复数类型等

    e记法(e4相当于10的四次方,e-10相当于10的-10次方)

    类型转换

    字符型转换为整型

    其它同上

    type()函数(可查看变量类型)

    isinstance()函数(用来判断两个输入参数类型是否一致)

     

    006 Pyhon之常用操作符

    算术操作符

    注:python中 \ 为除法, \\ 为整除 ,% 为取余

    幂运算(3的二次方)

    3的二次方后取负

    注:先幂运算、然后乘除、后加减、后逻辑

    3的负二次方

    比较操作符

    逻辑操作符

    优先级问题

    007 了不起的分支和循环

    打飞机游戏框架:

    加载背景音乐

    播放背景音乐(设置单曲循环)

    我方飞机诞生

    while True:
        if 用户是否点击了关闭按钮:
           推出程序
           
        interval += 1;
        if interval == 50:
           interval = 0;
           小飞机诞生
        小飞机移动一个位置
        屏幕刷新
        
        if 用户鼠标产生移动:
           我方飞机中心位置 = 用户鼠标位置
           屏幕刷新
           
        if 我方飞机与小飞机发生肢体冲突:
           我方挂,播放撞机音乐
           修改我方飞机图案
           打印“Game over"
           停止背景音乐,最好淡出

     

    008 了不起的分支和循环2

    现在小甲鱼来考考大家:

    按照100分制,90分以上成绩为A8090B6080C60以下为D,写一个程序,当用户输入分数,自动转换为ABCD的形式打印。

    score = int(input('请输入一个分数:'))
    if 100 >= score >= 90:
        print('A')
    elif 90 > score >= 80:
        print('B')
    elif 80 > score >= 60:
        print('C')
    elif 60 > score >= 0:
        print('D')
    else:
        print('输入错误!')

    条件表达式(三元操作符)

    有了这个三元操作符的条件表达式,你可以使用一条语句来完成以下的条件判断和赋值操作:

    x, y = 4, 5

    if x < y:

      small = x

    else:

      small = y

    例子可以改进为

    small = x if x < y else y    #如果x小于y,则small等于x,否则等于y

    断言(assert)

    assert这个关键字我们称之为“断言”,当这个关键字后边的条件为假的时候,程序自动崩溃并抛出AssertionError的异常。

    举个例子:

    >>> assert 3 > 4

    一般来说我们可以用Ta再程序中置入检查点,当需要确保程序中的某个条件一定为真才能让程序正常工作的话,assert关键字就非常有用了

     

    009 了不起的分支和循环3

    while循环

    while 条件:

                      循环体

    for循环

    虽然说Python是由C语言编写而来的,但是Tafor循环跟C语言的for循环不太一样,Pythonfor循环显得更为智能和强大!

    语法:

    for 目标 in 表达式:

         循环体

    每次取FishC中一个字符及空格输出

    range()函数

    语法:range( [strat],[stop],[step] )

    这个BIF有三个参数,其中用中括号括起来的两个表示这两个参数是可选的。

    step=1表示第三个参数的值默认值是1setp为每步距离

    range这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列

     

    break语句(结束本层循环)

    实例:

    bingo = '小甲鱼是帅哥'
    answer = input('请输入小甲鱼最想听的一句话:')

    while True:
        if answer == bingo:
            break
        answer = input('抱歉,错了,请重新输入(答案正确才能退出游戏):')

    print('哎哟,帅哦~')
    print('您真是小甲鱼肚子里的蛔虫啊^_^')

    continue语句(当前位置结束本次循环,重新开始下次循环)

    实例:

    for i in range(10):
        if i%2 != 0:
            print(i)
            continue
        i += 2
        print(i)

    010 列表:一个打了激素的数组

    列表一个打了激素的数组

    创建列表

    创建一个普通列表

    创建一个混合列表

    创建一个空列表

    向列表添加元素

    append()函数向列表末尾添加一个元素

    extend()函数向列表末尾添加多个元素

    insert(n,xxx)函数向列表中第n个元素前插入一个元素

    注:0表示第一个元素

    011列表:一个打了激素的数组2

    从列表中获取元素

    跟数组一样,我们可以通过元素的索引值(index)从列表获取单个元素,注意,列表索引值是从 0 开始的。

    从列表删除元素

    remove()函数表示从列表中删除某个元素

    del()函数也表示从列表中删除某个元素

    pop()函数从列表中取出最后一个元素

    列表分片(Slice

    利用索引值,每次我们可以从列表获取一个元素,但是我们总是贪心的,如果一次性需要获取多个元素,有没有办法实现呢?利用列表分片,我们可以简单的实现这个要求。

    member[0:2]表示从第1个元素开始拷贝,一共拷贝两个元素,即member[0]和member[1]

    列表的拷贝

    012列表:一个打了激素的数组3

    列表的一些常用操作符

    比较操作符

    逻辑操作符

    连接操作符

    重复操作符

    成员关系操作符

    关于分片“拷贝”概念的补充

    >>> dir(list)可查看所有列表的操作函数

    count()函数可计算列表中相同元素个数

    index()函数可索引列表元素

    reverse()将列表中元素倒序

    sort()将列表中元素从小到大排序

    关于分片“拷贝”概念的补充

    注:list13=list11相当于多了个指向列表的标签,list12 = list[:]是实实在在的拷贝

    013元组:戴上了枷锁的列表

    由于和列表是近亲关系,所以元组和列表在实际使用上是非常相似的。

    我们这节课主要通过讨论元组和列表到底有什么不同来学习元组,酱紫大家就不会觉得老是重复一样的内容

    我们主要从以下几个点来讨论学习:

    创键和访问一个元组

    创建元组(括号可以没有,但逗号一定要有)

    访问元组前两个元素

    更新和删除一个元组

    更新一个元组

    注:其并未对原元组进行修改,而是生成了一个新的元组,并贴上temp名字标签而已。原元组由于标签没有了,则会被自动回收。

    删除一个元组

    元组相关的操作符

    注:元组不允许修改和删除。

    014字符串:各种奇葩的内置方法

     

    015字符串:格式化

    由于花括号被解释掉,所以不打印后面中文

    字符串格式化符号含义

    将ASCII码97对应的字符输出

    格式化整数

    格式化操作符辅助命令

    5表示输出为五位数

    Python 的转义字符及其含义

     

    016 序列!序列!

    列表、元组和字符串的共同点

    都可以通过索引得到每一个元素

    默认索引值总是从0开始

    可以通过分片的方法得到一个范围内的元素的集合

    有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)

    使用list方法

    元组转换为列表

    注:元组为小括号,列表为中括号。

    max() 返回序列或者参数集合中的最大值

    min() 返回序列或者参数集合中的最小值

    sum(iterable[,start=0]) 返回序列iterable和可选参数start的总和

    sorted()将元素从小到大重新排列

    reversed()将元素倒序排列

    注:元组是不可以修改和删除的,所以不可以直接对元组使用sorted与reversed命令

    enumerate()将每个元素插入枚举

    zip()返回由各个参数的序列组成的元组

     

    017函数:Python的乐高积木

    定义一个函数和调用

     

    018 函数:灵活即强大

    形参和实参

    >>> def MyFirstFunction(name):

      '函数定义过程中的name是叫形参'

      #因为Ta只是一个形式,表示占据一个参数位置

      print('传递进来的' + name + '叫做实参,因为Ta是具体的参数值!')

    >>> MyFirstFunction('小甲鱼')

    传递进来的小甲鱼叫做实参,因为Ta是具体的参数值!

    关键字参数

    默认参数(即形参中给定默认值,则在未给实参时会以默认值输出)

    收集参数

     

    019函数:我的地盘听我的

    函数与过程

    再谈谈返回值

    如果有返回值,函数则返回对应值;如果没有,则返回None

    可以返回多个值

    019函数:我的地盘听我的(局部变量与全局变量)

    def discounts(price, rate):
        final_price = price * rate
        old_price = 88 #这里试图修改全局变量
        print('修改后old_price的值是:', old_price)
        return final_price

    old_price = float(input('请输入原价:'))
    rate = float(input('请输入折扣率:'))
    new_price = discounts(old_price, rate)
    print('修改后old_price的值是:', old_price)
    print('打折后价格是:', new_price)

    global可将局部变量声明为全局变量

    020函数:内嵌函数和闭包

    内嵌函数

    闭包(closure

    注:使用nonlocal语句将x强制为不是局部变量

    021函数:lambda表达式

    lambda表达式的作用

    Python写一些执行脚本时,使用lambda就可以省下定义函数过程,比如说我们只是需要写个简单的脚本来管理服务器时间,我们就不需要专门定义一个函数然后再写调用,使用lambda就可以使得代码更加精简

    对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数,有时候给函数起个名字也是比较头疼的问题,使用lambda就不需要考虑命名的问题了

    简化代码的可读性,由于普通的屌丝函数阅读经常要跳到开头def定义部分,使用lambda函数可以省去这样的步骤。

    过滤函数filter可筛选出非零元素

    筛选出奇数

    注:lambda x:x%2用来判断是否为奇,x为奇则输出1,否则输出0;range(10)可生成0-9的10个整数,filter用来筛选非零元素;如果为偶数,则被筛选掉;如果为奇数,则保留,但输出的是rang(10)产生的原始数,因为lambda只是用来判断是否为奇偶

    range生成的0-9给了x,x经过2倍运算后再赋值给x

    022 函数:递归是神马

    汉诺塔游戏

    树结构的定义

    谢尔宾斯基三角形

    递归求阶乘

    写一个求阶乘的函数

    正整数阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。

    例如所给的数是5,则阶乘式是1×2×3×4×5,得到的积是120,所以120就是4的阶乘。

    假设我们n的值传入是5,那么:

    实例:求阶乘

    def factorial(n):
        result = n
        for i in range(1, n):
            result *= i

        return result

    number = int(input('请输入一个正整数:'))
    result = factorial(number)
    print("%d 的阶乘是:%d"  % (number, result))#格式化为整数类型

    实例2:递归求阶乘

    def factorial(n):
        if n == 1:
            return 1
        else:
            return n * factorial(n-1)

    number = int(input('请输入一个正整数:'))
    result = factorial(number)
    print("%d 的阶乘是:%d" % (number, result))

    023 递归:这帮小兔崽子

    坑爹的兔子

    斐波那契数列的迭代实现

    我们都知道兔子繁殖能力是惊人的,如下图:

    我们可以用数学函数来定义:

    课间练习:假设我们需要求出经历了20个月后,总共有多少对小兔崽子?(迭代 vs 递归

    def fab(n):
        n1 = 1
        n2 = 1
        n3 = 1

        if n < 1:
            print('输入有误!')
            return -1

        while (n-2) > 0:
            n3 = n2 + n1
            n1 = n2
            n2 = n3
            n -= 1
        
        return n3

    result = fab(20)
    if result != -1:
        print('总共有%d对小兔崽子诞生!' % result)

    斐波那契数列的递归实现

    递归实现(递归计算时间将拉长)

    def fab(n):
        if n < 1:
            print('输入有误!')
            return -1

        if n == 1 or n == 2:
            return 1
        else:
            return fab(n-1) + fab(n-2)

    result = fab(35)
    if result != -1:
        print('总共有%d对小兔崽子诞生!' % result)

    注:迭代计算时间远比递归少,因为递归要循环出入栈

    024 递归:汉诺塔

    递归求解汉诺塔

     

    对于游戏的玩法,我们可以简单分解为三个步骤

    将前63个盘子从X移动到Y上。

    将最底下的第64个盘子从X移动到Z上。

    Y上的63个盘子移动到Z上。

    问题一:将X上的63个盘子借助Z移到Y上;

    问题二:将Y上的63个盘子借助X移到Z上。

     

    对于游戏的玩法,我们可以简单分解为三个步骤

    将前63个盘子从X移动到Y上。

    将最底下的第64个盘子从X移动到Z上。

    Y上的63个盘子移动到Z上。

    问题一:将X上的63个盘子借助Z移到Y上;

    问题二:将Y上的63个盘子借助X移到Z上。

    实例:

    def hanoi(n, x, y, z):
        if n == 1:
            print(x, ' --> ', z)
        else:
            hanoi(n-1, x, z, y) # 将前n-1个盘子从x移动到y上
            print(x, ' --> ', z) # 将最底下的最后一个盘子从x移动到z上
            hanoi(n-1, y, x, z) # 将y上的n-1个盘子移动到z上

    n = int(input('请输入汉诺塔的层数:'))
    hanoi(n, 'X', 'Y', 'Z')

    025 字典:当索引不好用时

    映射

    创建和访问字典

    >>> dict4 = dict(小甲鱼='让编程改变世界',李宁='一切皆有可能')
    >>> dict4
    {'小甲鱼': '让编程改变世界', '李宁': '一切皆有可能'}

    >>> dict4['爱迪生'] = '天才是99%的汗水加1%的灵感'
    >>> dict4
    {'小甲鱼': '让编程改变世界', '李宁': '一切皆有可能', '爱迪生': '天才是99%的汗水加1%的灵感'}

    026 字典:当索引不好用时2

    fromkey()方法用于创建并返回一个新的字典它有两个参数,第一个参数是字典的键;第二个参数是可选的,是传入键的值。如果不提供,默认是None

    >>> dict1 = {}
    >>> dict1.fromkeys((1,2,3))
    {1: None, 2: None, 3: None}
    >>> dict2 = {}
    >>> dict2.fromkeys((1,2,3),"Number")
    {1: 'Number', 2: 'Number', 3: 'Number'}
    >>> dict3 = {}
    >>> dict3.fromkeys((1,2,3),('one','two','three'))
    {1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

    访问字典的方法有key()、values()和items()

    key()用于返回字典中的键,value()用于返回字典中所有的值,item()当然就是返回字典中所有的键值对(也就是项)

    >>> dict1 = dict1.fromkeys(range(5),'赞')
    >>> dict1.keys()
    dict_keys([0, 1, 2, 3, 4])
    >>> dict1.values()
    dict_values(['赞', '赞', '赞', '赞', '赞'])
    >>> dict1.items()
    dict_items([(0, '赞'), (1, '赞'), (2, '赞'), (3, '赞'), (4, '赞')])

    get()方法提供了更宽松的方式去访问字典项,当键不存在的时候,get()方法并不会报错,只是默默第返回一个None,表示啥都没找到:

    >>> dict1.get(10)
    >>> dict1.get(4)
    '赞'

    如果希望找不到数据时返回指定的值,可以在第二个参数设置对应的默认返回值:

    >>> dict1.get(32,'木有')
    '木有'

    如果不知道一个键是否在字典中,可以使用成员资格操作符(in 或 not in)来判断
    >>> 31 in dict1
    False
    >>> 4 in dict1

    clear()可清空一个字典

    >>> dict1
    {0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞'}
    >>> dict1.clear()
    >>> dict1
    {}

    copy()方法是复制字典(全拷贝)

    >>> a = {1:'one',2:'two',3:'three'}
    >>> b = a.copy()
    >>> id(a)
    52448840
    >>> id(b)
    52503624
    >>> a[1] = 'four'
    >>> a
    {1: 'four', 2: 'two', 3: 'three'}
    >>> b
    {1: 'one', 2: 'two', 3: 'three'}

    pop()是给定键弹出对应的值,popitem()是随机弹出一个项

    >>> a.pop(2)
    'two'
    >>> a
    {1: 'four', 3: 'three'}
    >>> a.popitem()
    (1, 'four')
    >>> a
    {3: 'three'}

    setdefault()方法与get()方法相似,但setdefault()在字典中找不到相应的键值时会自动添加

    >>> a = {1:'one',2:'two',3:'three'}
    >>> a.setdefault(2)
    'two'
    >>> a.setdefault(4)
    >>> a
    {1: 'one', 2: 'two', 3: 'three', 4: None}

    update()方法可以更新字典

    >>> a = {1:'one','小白':None}

    >>> b = {'小白':'狗'}
    >>> a.update(b)
    >>> a
    {1: 'one', '小白': '狗'}

    027 集合:在我的世界里,你就是唯一

    字典的表亲--集合(在python3中,如果用大括号括起一堆数字但没有体现映射关系,那么就会认为这堆玩意儿就是个集合)

    >>> num1 = {}
    >>> type(num1)
    <class 'dict'>
    >>> num2 = {1,3,4}
    >>> type(num2)
    <class 'set'>

    集合中的元素都是唯一的(集合会自动帮我们把重复的数据清理掉,集合是无序的,所以不能试图去索引集合中的某一个元素

    >>> num = {1,2,3,4,5,5,4,3,2,1}
    >>> num
    {1, 2, 3, 4, 5}

    如何创建一个集合有两种方法:1、直接把一堆元素用大括号括起来;2、用set()

    一种是直接把一堆元素用花括号括起来

    >>> set1 = {'小甲鱼','小鱿鱼','小甲鱼'}

    一种是使用set()工厂函数

    >>> set2 = set(['小甲鱼','小鱿鱼','小甲鱼'])
    >>> set1 == set2
    True

    课堂搞搞看

    要求:去掉列表中重复的元素

    [0, 1, 2, 3, 4, 5, 5, 3, 1]

    方法一、

    >>> list1 = [1,2,3,4,5,5,3,1,0]

    >>> temp = list1[:]
    >>> list1.clear()
    >>> list1
    []
    >>> for each in temp:
        if each not in list1:
            list1.append(each) #append()表示向列表中添加元素

    方法二、

    >>> list1 = list(set(list1))
    >>> list1
    [0, 1, 2, 3, 4, 5]

    #set(list1)先将list1列表转变为集合, list(set(list1))再讲集合转变为列表

    如何访问集合中的值

    由于集合中的元素是无序的,所以并不能像序列那样用下标来进行访问,但是可以使用迭代把集合中的数据一个个读取出来

    可以使用for把集合中的数据一个个读取出来

    >>> set1 = {1,2,3,4,5,4,3,2,1,0}
    >>> for each in set1:
        print(each,end = ' ')

        
    0 1 2 3 4 5 

    •也可以通过innot in判断一个元素是否在集合中已经存在

    >>> 0 in set1
    True
    >>> 8 in set1
    False

    使用add()方法可以为集合添加元素,使用remove()方法可以删除集合中已知的元素:

    >>> set1.add(6)
    >>> set1
    {0, 1, 2, 3, 4, 5, 6}
    >>> set1.remove(5)
    >>> set1
    {0, 1, 2, 3, 4, 6}

    不可变集合(把元素给froze冰冻起来)(像元组一样不能随意地增加或删除集合中的元素)

    028 文件:因为懂你,所以永恒

    大多数u程序都是:首先接收输入数据,然后按照要求进行处理,最后输出数据

    虽然当前数据放在内存中存取的速度要比硬盘中快,但一旦断电则会丢失,所以尽量ctrl+s保持到硬盘中


    什么是文件

    打开文件

    open(file, mode='r', buffering=-1, encoding=None,errors=None, newline=None, closefd=True, opener=None)

    open()的第一个参数是传入的文件名,第二个参数是指定文件的打开模式

    文件对象方法

    >>> f = open("D:\\python3.3.2\Hello.txt")
    >>> f
    <_io.TextIOWrapper name='D:\\python3.3.2\\Hello.txt' mode='r' encoding='cp936'>
    >>> f.read()
    "A. HISTORY OF THE SOFTWARE\n==========================\n\nPython was created in the early 1990s by Guido van Rossum at Stichting\nMathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands\nas a successor of a language called ABC.  Guido remains Python's\nprincipal author, although it includes many contributions from others.\n\nIn 1995, Guido continued his work on Python at the Corporation for\nNational Research Initiatives (CNRI, see http://www.cnri.reston.va.us)\nin Reston, Virginia where he released several versions of the\nsoftware."
    >>> f.close()
    >>> f = open("D:\\python3.3.2\Hello.txt")
    >>> f.read(5)
    'A. HI'
    >>> f.tell()   #返回当前光标所在文件的位置
    5
    >>> f.readline()
    'STORY OF THE SOFTWARE\n'
    将f放入到列表

    >>> f = open("D:\\python3.3.2\Hello.txt",'w')#w模式写入会覆盖已存在的文件(即原文件内容全部被删除),a模式则在末尾追加写入
    >>> f.write('who are you')          #返回的是写入的字符数
    11
    >>> f.close()

    029 文件:一个任务

    任务:将文件(record.txt)中的数据进行分割并按照以下规律保存起来:

    小甲鱼的对话单独保存为boy_*.txt的文件(去掉“小甲鱼:”)

    小客服的对话单独保存为girl_*.txt的文件(去掉“小客服:”)

    文件中总共有三段对话,分别保存为boy_1.txt, girl_1.txtboy_2.txt, girl_2.txt, boy_3.txt, gril_3.txt6个文件(提示:文件中不同的对话间已经使用“==========分割

    test1:

    f = open("record.txt")

    boy = []
    girl = []
    count = 1

    for each_line in f:
        if each_line[:6] != '======':#判断是否连续读到六个=
            (role,line_spoken) = each_line.split(':',1)#split以:进行字符切割,
            #将切得到的两部分内容依次存放在role与line_spoken中
            if role == '小甲鱼':
                boy.append(line_spoken)#将小甲鱼说的内容添加到列表boy中
            if role == '小客服':
                girl.append(line_spoken)#将小客服说的内容添加到列表girl中
        else:
            file_name_boy = 'boy_' + str(count) + '.txt'
            file_name_girl = 'girl_' + str(count) + '.txt'

            boy_file = open(file_name_boy,'w')#以w模式新建一个以file_name_boy命名的txt文件
            girl_file = open(file_name_girl,'w')#并贴上boy_file的标签

            boy_file.writelines(boy)#将列表boy中的内容写入到boy_file文件中
            girl_file.writelines(girl)

            boy_file.close()#关闭boy_file文件
            girl_file.close()

            boy = []#清空列表boy
            girl = []
            count += 1

    file_name_boy = 'boy_' + str(count) + '.txt'
    file_name_girl = 'girl_' + str(count) + '.txt'

    boy_file = open(file_name_boy,'w')
    girl_file = open(file_name_girl,'w')

    boy_file.writelines(boy)
    girl_file.writelines(girl)

    boy_file.close()
    girl_file.close()#记得关闭文件

    test2:

     

    def save_file(boy,girl,count):
        file_name_boy = 'boy_' + str(count) + '.txt'
        file_name_girl = 'girl_' + str(count) + '.txt'

        boy_file = open(file_name_boy,'w')
        girl_file = open(file_name_girl,'w')

        boy_file.writelines(boy)
        girl_file.writelines(girl)

        boy_file.close()
        girl_file.close()

    def split_file(file_name):
        f = open(file_name)

        boy = []
        girl = []
        count = 1

        for each_line in f:
            if each_line[:6] != '======':
                (role,line_spoken) = each_line.split(':',1)#split以:进行字符切割,
                #将切得到的两部分内容依次存放在role与line_spoken中
                if role == '小甲鱼':
                    boy.append(line_spoken)
                if role == '小客服':
                    girl.append(line_spoken)
            else:
                save_file(boy,girl,count)

                boy = []
                girl = []
                count += 1


        save_file(boy,girl,count)
        f.close()

    split_file('record.txt')

    030 文件系统:介绍一个高大上的东西

    os模块中关于文件/目录常用的函数使用方法

    >>> import os
    >>> os.getcwd()
    'D:\\python3.3.2\\小甲鱼python\\python程序\\第二十九课'

    >>> os.listdir('D:\\python3.3.2\\小甲鱼python\\python程序\\第二十九课')
    ['boy_1.txt', 'boy_2.txt', 'boy_3.txt', 'girl_1.txt', 'girl_2.txt', 'girl_3.txt', 'record.txt', 'test.py', 'test2.py']

    os.path模块中关于路径常用的函数使用方法

     >>> os.path.getsize('python.exe')  #获取文件的尺寸,返回值以字节为单位


    031 永久存储:腌制一缸美味的泡菜(pickle)

    python提供了一个标准的模块pickle可以非常容易地将列表、字典这类复杂的数据类型存储为文件。它几乎可以把所有python的对象都转化为二进制的形式存放,这个过程称为pickling,从二进制转换回对象的过程称为unpickling

    pickling过程

    >>> import pickle
    >>> my_list = [123,3,14,'小甲鱼',['another list']]

    >>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十节课\my_list.pkl','wb')  #二进制写形式打开文件
    >>> pickle.dump(my_list,pickle_file)
    >>> pickle_file.close()

    unpickling过程       

    >>> import pickle
    >>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十节课\my_list.pkl','rb')#以二进制读形式打开文件
    >>> my_list = pickle.load(pickle_file)
    >>> print(my_list)
    [123, 3, 14, '小甲鱼', ['another list']]

    实例:城市天气打包

    >>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十一节课\city_data.pkl','wb')
    >>> pickle.dump(city,pickle_file)
    >>> pickle_file.close()

    032 异常处理:你不可能总是对的

    实例1:

    file_name = input('请输入需要打开的文件名:')
    file = open(file_name)
    print('文件的内容是:')
    for each_line in file:
        print(each_line)
    file.close()

    注:py文件与要打开的文件在同一个文件下则不需要加路径

    Python标准异常总结

    以下是 Python 内置异常类的层次结构:

            

    033 异常处理:你不可能总是对的2

    try-except语句

    try:

      检测范围

    except Exception[as reason]:

      出现异常(Exception)后的处理代码

    实例1:

    try:
        f = open('TE.txt')
        print(f.read())
        f.close()
    except OSError:
        print('文件打开过程中出错了!!!')

    实例2:

    try:
        f = open('TE.txt')
        print(f.read())
        f.close()
    except OSError as reason:
        print('文件打开出错原因是:\n' + str(reason))

    实例3:

    try:
        sum = 1 + '1'
        f = open('TE.txt')
        print(f.read())
        f.close()
    except OSError as reason:
        print('文件打开出错原因是:\n' + str(reason))
    except TypeError as reason:
        print('类型出错原因是:\n' + str(reason))

    实例4(多个异常统一处理):

    try:
        sum = 1 + '1'
        f = open('TE.txt')
        print(f.read())
        f.close()
    except(OSError, TypeError):
        print('出错了')

    注:try语句一旦检测到异常,剩下的语句将不会被执行

    try-finally语句

    try:

      检测范围

    except Exception[as reason]:

      出现异常(Exception)后的处理代码

    finally:

      无论如何都会被执行的代码

    实例5:

    try:
        f = open('test.txt')
        print(f.read())
        sum = 1 + '1'
    except (OSError,TypeError)as reason:
        print('出错了\n原因是:' + str(reason))
    finally:
        f.close()

    raise语句可以自己抛出一个异常

    034 丰富的else语句及简洁的with语句

    丰富的else语句

    要么怎样,要么不怎样

    if 条件:
        条件为真执行
    else:
        条件为假执行
          

    干完了能怎样,干不完就别想怎样

    实例1:

    def showMaxFactor(num):
        count = num // 2#//为整除,判断是素数,只需依次判断当前数num除以1到(num // 2)都不能整除即可
        while count > 1:
            if num % count == 0:#判断是否整除
                print('%d最大的约数是%d' % (num, count))
                break#跳出循环后else并不执行
            count -= 1
        else:#当while循环不成立时,或者理解为while循环完全被执行完了,没有给中途跳出(即break)
            print('%d是素数!' % num)

    num = int(input('请输入一个数:'))
    showMaxFactor(num)

    注:else与for语句搭配与while语句相同

    没有问题?那就干

    只要try语句块里没有出现任何异常,那么就会执行else语句块里的内容啦

    实例2:

    try:#尝试运行以下程序
        print(int('abc'))
    except ValueError as reason:#如果程序有异常时
        print('出错了:' + str(reason))
    else:#程序无异常时
        print('没有任何异常!')

    实例3:

    try:
        print(int('123'))
    except ValueError as reason:
        print('出错了:' + str(reason))
    else:
        print('没有任何异常!')

    简洁的with语句(with会自动帮你关闭文件)

    实例4:

    try:
        with open('test.txt','w') as f:
            for each_line in f:
                print(each_line)
    except (OSError,TypeError) as reason:
        print('出错了\n原因是:' + str(reason))

    035 图形用户界面入门:EasyGui

    图形用户界面编程,也就是平时常说的GUI(Graphical User  Interface),python有一个非常简单的GUI工具包:EasyGui

    GUI的安装

    导入方法一:

    >>> import easygui         #导入EasyGui
    >>> easygui.msgbox('嗨,亦我飞也')

    导入方法二:

    >>> from easygui import *
    >>> msgbox('嗨,亦我飞也')

    导入方法三(推荐使用):

    >>> import easygui as g
    >>> g.msgbox('嗨,亦我飞也')

    显示图片(注:图片需要为GIF格式,且存放在python.exe通目录

    >>> easygui.buttonbox(msg='你喜欢以下哪种水果',title='亦我飞也',choices=('草莓','西瓜','芒果'),image='aa.gif')

    实例1:

    import easygui as g
    import sys
     
    while 1:
        g.msgbox("嗨,欢迎进入第一个界面小游戏")
        msg = "请问你希望在鱼C工作室学习到什么知识呢"
        title="小游戏互动"
        choices=["谈恋爱","编程","OOXX","琴棋书画"]
        choice=g.choicebox(msg,title,choices)
     
        #note that we convert choice to string,in case
        #the user cancelled the choice,and we got None
        g.msgbox("你的选择是:"+str(choice),"结果")
        msg="你希望重新开始小游戏吗?"
        title=" 请选择"
        if g.ccbox(msg,title):  #show a Contiue/Cancel dialog
            pass #user chose Contonue
        else:
            sys.exit(0)  #user chose Cancel

    修改窗口大小(choicebox)

    修改文字大小(PROPORTIONAL_FONT)

    036 类和对象:给大家介绍对象

    给大家介绍对象

    把乱七八糟的数据扔进列表里,称数据层面的封装

    把常用的代码段打包成一个函数,称语句层面的封装

    把数据和代码都封装在一起,称对象层面的封装

    对象 = 属性 + 方法

    对象可以从静态(属性)动态(方法)两个特征来描述

    OO(面向对象)的特征

    继承

    class Turtle: # Python 中的类名约定以大写字母开头
        """关于类的一个简单例子"""
        # 属性
        color = 'green'
        weight = 10
        legs = 4
        shell = True
        mouth = '大嘴'

        # 方法
        def climb(self):
            print("我正在很努力的向前爬......")

        def run(self):
            print("我正在飞快的向前跑......")

        def bite(self):
            print("咬死你咬死你!!")

        def eat(self):
            print("有得吃,真满足^_^")

        def sleep(self):
            print("困了,睡了,晚安,Zzzz")

    调用类中的方法:

    >>> tt = Turtle()     #声明tt对象继承Turtle()
    >>> tt.climb()
    我正在很努力的向前爬......
    >>> tt.bite()
    咬死你咬死你!!

    定义一个带列表类MyList,将list2对象继承于它,则列表的功能继承它的对象都可以使用

    >>> class MyList(list):
        pass

    >>> list2 = MyList()

    >>> list2.append(5)
    >>> list2.append(6)

    >>> list2.append(1)
    >>> list2
    [5, 6, 1]
    >>> list2.sort()
    >>> list2
    [1, 5, 6]

    多态(下例中都调用的名字相同的方法,但实现不一样)

    >>> class A:
        def fun(self):
            print('我是小A。。。')

            
    >>> class B:
        def fun(self):
            print('我是小B。。。')

            
    >>> a = A()
    >>> b = B()
    >>> a.fun()
    我是小A。。。
    >>> b.fun()
    我是小B。。。

    037 类和对象:面向对象编程

    self是什么?

    Python的self其实就相当于C++的this指针。由同一个类可以生产无数对象,当一个对象的方法被调用的时候,对象会将自身的引用作为第一个参数传给该方法,那么python就知道需要操作哪个对象的方法了。

    >>> class Ball:
        def setName(self,name):
            self.name = name
        def kick(self):
            print('我叫%s,该死的,谁踢我。。。' % self.name)

            
    >>> a = Ball()

    >>> a.setName('球A')
    >>> b = Ball()

    >>> b.setName('球B')

    >>> a.kick()
    我叫球A,该死的,谁踢我。。。
    >>> b.kick()
    我叫球B,该死的,谁踢我。。。

    你听说过Python的魔法方法吗?

    python的这些具有魔法的方法,总是被双下划线所包围,例如__init__(),即构造方法,也称构造函数,这个方法会在对象被创建时自动调用。其实,实例化对象时是可以传入参数的,这些参数会自动传入__init__()方法中,可以通过重写这个方法来自定义对象的初始化操作

    实例:

    >>> class Ball():
        def __init__(self,name):
            self.name = name
        def kick(self):
            print('我叫%s,该死的,谁踢我。。。' % self.name)

            
    >>> b = Ball('小土豆')
    >>> b.kick()
    我叫小土豆,该死的,谁踢我。。。

    公有和私有?python内部采用了一种叫 name mangling(名字改编)的技术

    默认上对象的属性和方法都是公开的,可以直接通过点操作符(.)进行访问:

    >>> class Person:
        name = '亦我飞也'

        
    >>> p = Person()
    >>> p.name
    '亦我飞也'

    为了实现定义私有变量,只需要在变量名或函数名前加上"__"两个下划线,那么这个函数或变量就会变成私有的了:

    私有变量不可以直接由外部访问

    >>> class Person:
        __name = '亦我飞也'

        
    >>> p = Person()
    >>> p.__name
    Traceback (most recent call last):
      File "<pyshell#65>", line 1, in <module>
        p.__name
    AttributeError: 'Person' object has no attribute '__name'

    室友变量可以由内部(内部函数)进行访问

    >>> class Person:
        __name = '亦我飞也'
        def getName(self):
            return self.__name

        
    >>> p = Person()
    >>> p.__name
    Traceback (most recent call last):
      File "<pyshell#72>", line 1, in <module>
        p.__name
    AttributeError: 'Person' object has no attribute '__name'

    >>> p.getName()
    '亦我飞也'

    其实,name mangling(名字改编)技术,只是把双下划线开头的变量进行了改名而已。实际上在外部使用“_类名__变量名“即可访问双下划线开头的私有变量了

    >>> p._Person__name
    '亦我飞也'

    038 类和对象:继承

    继承

                      子类                              父类

    class DerivedClassName(BaseClassName):

    ……

    实例:一个子类可以继承它的父类的所有属性和方法

    >>> class Parent:
        def hello(self):
            print('正在调用父类的方法。。。')

            

    >>> class Child(Parent):    #子类继承父类
        pass     #直接往下执行

    >>> p = Parent()
    >>> p.hello()
    正在调用父类的方法。。。
    >>> c = Child()
    >>> c.hello()
    正在调用父类的方法。。。

    如果子类中定义与父类同名的方法或属性,则会自动覆盖父类对应的方法和属性(即子类方法属性改变,父类是不变的)

    >>> class Child(Parent):
        def hello(self):
            print('正在调用子类的方法')

            
    >>> c = Child()
    >>> c.hello()
    正在调用子类的方法
    >>> p.hello()
    正在调用父类的方法。。。

    实例2:

    import random as r
    class Fish:
        def __init__(self):
            self.x = r.randint(0,10)
            self.y = r.randint(0,10)

        def move(self):
            self.x -= 1
            print('我的位置是:',self.x,self.y)


    class Goldfish(Fish):
        pass

    class Garp(Fish):
        pass

    class Shark(Fish):
        def __init__(self):
            self.hungry = True

        def eat(self):
            if self.hungry:
                print('吃货的梦想就是天天有的吃')
                self.hungry = False
            else:
                print('太撑了,吃不下了!')

    >>> fish = Fish()
    >>> fish.move()
    我的位置是: -1 10
    >>> fish.move()
    我的位置是: -2 10
    >>> goldfish = Goldfish()
    >>> goldfish.move()
    我的位置是: 2 3
    >>> goldfish.move()
    我的位置是: 1 3
    >>> shark = Shark()
    >>> shark.eat()
    吃货的梦想就是天天有的吃
    >>> shark.eat()
    太撑了,吃不下了!
    >>> shark.move()    #报错原因时因为子类重写构造函数,覆盖了父类D的构造函数
    Traceback (most recent call last):
      File "<pyshell#9>", line 1, in <module>
        shark.move()
      File "D:\python3.3.2\小甲鱼python\python程序\第三十八节课\fish.py", line 8, in move
        self.x -= 1
    AttributeError: 'Shark' object has no attribute 'x'

    注:继承父类属性的子类,其变量值只属于当前子类,是子类的局部变量

    报错修改部分解决方法一:调用未绑定的父类方法

    >>> shark = Shark()
    >>> shark.move()
    我的位置是: 2 1
    >>> shark.move()
    我的位置是: 1 1

    报错修改部分解决方法二:使用super函数super函数会帮我们自动找到基类的方法,而且还自动为我们传入self参数

    >>> shark = Shark()
    >>> shark.move()
    我的位置是: 1 1
    >>> shark.move()
    我的位置是: 0 1

    多重继承

    class DerivedClassName(Base1, Base2, Base3):

    ……

    实例:子类c同时继承基类Base1和基类Base2

    >>> class Base1:
        def fool1(self):
            print('我是fool1,我为Base1代言。。。')

            
    >>> class Base2:
        def fool2(self):
            print('我是fool2,我为Base2代言。。。')

            
    >>> class C(Base1,Base2):
        pass

    >>> c = C()
    >>> c.fool1()
    我是fool1,我为Base1代言。。。
    >>> c.fool2()
    我是fool2,我为Base2代言。。。

    039 类和对象:拾遗

    组合(将需要的类一起进行实例化并放入新的类中)

    实例:

    class Turtle:
        def __init__(self,x):
            self.num = x

    class Fish:
        def __init__(self,x):
            self.num = x

    class Pool:
        def __init__(self,x,y):
            self.turtle = Turtle(x)
            self.fish = Fish(y)

        def print_num(self):
            print('水池里一共有乌龟 %d 条,鱼 %d 条' % (self.turtle.num,self.fish.num))

    >>> pool = Pool(5,2)
    >>> pool.print_num()
    水池里一共有乌龟 5 条,鱼 2 条

    现在要求定义一个类,叫水池,水池里要有乌龟和鱼。

    类、类对象和实例对象

    以下例子可见,对实例对象c的count属性赋值后,就相当于覆盖了类对象C的count属性。如果没有赋值覆盖,那么引用的是类对象的count属性

    >>> a = C()
    >>> b = C()
    >>> c = C()
    >>> print(a.count,b.count,c.count)
    0 0 0
    >>> c.count += 10
    >>> print(a.count,b.count,c.count)
    0 0 10
    >>> C.count += 100
    >>> print(a.count,b.count,c.count)
    100 100 10

    另外,如果属性的名字跟方法名相同,属性会覆盖方法:

    >>> class C:
        def x(self):
            print('X-man')

            
    >>> c = C()
    >>> c.x()
    X-man
    >>> c.x = 1              #新定义对象c的一个x属性,并赋值为1
    >>> c.x
    1
    >>> c.x()     #可见,方法x()已经被属性x给覆盖了
    Traceback (most recent call last):
      File "<pyshell#8>", line 1, in <module>
        c.x()
    TypeError: 'int' object is not callable

    结论:不要试图在一个类里边定义出所有能想到的特性和方法,应该利用继承和组合机制来进行扩展;用不同的词性命名,如属性名用名词、方法名用动词,并使用骆驼命名法等。

    到底什么是绑定?

    实例1:(python严格要求需要有实例才能被调用,即绑定概念)

    >>> class BB:
        def printBB():        #缺少self,导致无法绑定具体对象
            print('no zuo no die')

            
    >>> BB.printBB()
    no zuo no die
    >>> bb = BB()
    >>> bb.printBB()        #出现错误原因是由于绑定机制,自动把bb对象作为第一个参数传入
    Traceback (most recent call last):
      File "<pyshell#15>", line 1, in <module>
        bb.printBB()
    TypeError: printBB() takes 0 positional arguments but 1 was given

     

    Python严格要求方法需要有实例才能被调用,这种限制其实就是Python所谓的绑定概念。

    040 类和对象:一些相关的BIF

    一些相关的BIF

    issubclass(class, classinfo)  如果第一个参数(class)是第二个参数(classinfo)的一个子类,则返回True,否则返回False

    >>> class A:
        pass

    >>> class B(A):
        pass

    >>> issubclass(B,A)
    True
    >>> issubclass(B,B)   #一个类被认为是其自身的子类
    True
    >>> issubclass(B,object)      # object是所有类的基类
    True
    >>> class C:
        pass

    >>> issubclass(B,C)
    False

    isinstance(object, classinfo)  如果第一个参数(object)是第二个参数(classinfo)的实例对象,则返回True,否则返回False

    >>> issubclass(B,C)       注:第一个参数如果不是对象,则永远返回False
    False
    >>> b1 = B()
    >>> isinstance(b1,B)
    True
    >>> isinstance(b1,C)
    False
    >>> isinstance(b1,A)
    True
    >>> isinstance(b1,(A,B,C))
    True

    hasattr(object, name)  用来测试一个对象里是否有指定的属性,第一个参数(object)是对象,第二个参数(name)是属性名(属性的字符串名字)

    >>> class C:
        def __init__(self,x=0):
            self.x = x

            
    >>> c1 = C()
    >>> hasattr(c1,'x')    
    #注意,属性名要用引号括起来
    True

     

    getattr(object, name[, default])  返回对象指定的属性值,如果指定的属性不存在,则返回default(可选参数);若没有设置default参数,则抛出异常

    >>> getattr(c1,'x')
    0
    >>> getattr(c1,'y')

    Traceback (most recent call last):
      File "<pyshell#25>", line 1, in <module>
        getattr(c1,'y')
    AttributeError: 'C' object has no attribute 'y'

    setattr(object, name, value)  可以设置对象中指定属性的值,如果指定的属性不存在,则会新建属性并赋值
    >>> setattr(c1,'y','FishC')
    >>> getattr(c1,'y')
    'FishC'

    delattr(object, name)  用于删除对象中指定的属性,如果属性不存在,抛出异常。

    >>> delattr(c1,'y')
    >>> delattr(c1,'Z')

    Traceback (most recent call last):
      File "<pyshell#30>", line 1, in <module>
        delattr(c1,'Z')
    AttributeError: Z

    property(fget=None, fset=None, fdel=None, doc=None)  用来通过属性设置属性,第一个参数是获取属性的方法名,第二个参数是设置属性的方法名,第三个参数是删除属性的方法名

    >>> class C:
        def __init__(self,size =10):
            self.size = size
        def getSize(self):
            return self.size
        def setSize(self,value):
            self.size = value
        def delSize(self):
            del self.size
        x=property(getSize,setSize,delSize)

        

    >>> c = C()
    >>> c.x         #调用getSize()
    10
    >>> c.x = 12      #调用SetSize()
    >>> c.x
    12
    >>> c.size
    12
    >>> del c.x      #调用DelSize()
    >>> c.size
    Traceback (most recent call last):
      File "<pyshell#53>", line 1, in <module>
        c.size
    AttributeError: 'C' object has no attribute 'size'

    041 魔法方法:构造和析构

    __init__(self[, ...]) 方法是类在实例化成对象的时候首先会调用的一个方法

    >>> class Rectangle:
        def __init__(self,x,y):
            self.x = x
            self.y = y
        def getPeri(self):
            return (self.x + self.y) * 2
        def getArea(self):
            return self.x * self.y

    >>> rect = Rectangle(5,2)
    >>> rect.getPeri()
    14
    >>> rect.getArea()
    10

       注:__init__()方法的返回值一定是None 

    其实,__new__()才是在一个对象实例化时候所调用的第一个方法,它的第一个参数是这个类(cla),而其他的参数会直接传递给__init__()方法

    __new__(cls[, ...])

    >>> class CapStr(str):
        def __new__(cls,string):
            string = string.upper()
            return str.__new__(cls,string)

        
    >>> a = CapStr('hello world')
    >>> a
    'HELLO WORLD

    __del__(self)  当对象将要被销毁的时候,这个方法就会被调用。但要注意,并非del x就相当于调用x.__del__(),__del__()方法是当垃圾回收机制回收这个对象的时候才调用的。

    >>> class C:
        def __init__(self):
            print('我是__init__方法,我被调用了...')
        def __del__(self):
            print('我是__del__方法,我被调用l...')

            
    >>> c1 = C()     #创建对象c1
    我是__init__方法,我被调用了...
    >>> c2 = c1
    >>> c3 = c2
    >>> del c1
    >>> del c2
    >>> del c3   #删除c3时,对象c1才会彻底被删除(即没有标签指向对象c1时,其才会被回收)
    我是__del__方法,我被调用l...

    042 魔法方法:算术运算

    python2.2以后,对类和类型进行了统一,做法就是讲int()、float()、str()、list()、tuple()这些BIF转换为工厂函数(类对象):

    >>> type(len)
    <class 'builtin_function_or_method'>            #普通的BIF
    >>> type(int)
    <class 'type'>             #工厂函数(类对象),当调用它们的时候,其实就是创建了一个相应的实例对象
    >>> type(dir)
    <class 'builtin_function_or_method'>
    >>> type(list)
    <class 'type'>

    >>> a = int('123')        #创建一个相应的实例对象a
    >>> b = int('345')
    >>> a + b              #python在两个对象进行相加操作
    468

    举个例子,下面定义一个比较特立独行的类:

    >>> class New_int(int):
        def __add__(self,other):
            return int.__sub__(self,other)
        def __sub__(self,other):
            return int.__add__(self,other)

        
    >>> a = New_int(3)
    >>> b = New_int(5)
    >>> a + b    #两个对象相加,触发 __add__(self,other)方法
    -2
    >>> a - b
    8
    >>>

    实例2:

    >>> class New_int(int):
        def __add__(self,other):
            return (int(self) + int(other))       #将self与other强制转换为整型,所以不会出现两个对象相加触发__add__()方法
        def __sub__(self,other):
            return (int(self) - int(other))

        
    >>> a = New_int(3)
    >>> b = New_int(5)
    >>> a + b
    8

    043 魔法方法:算术运算2

    实例1:

    >>> class int(int):
        def __add__(self,other):
            return int.__sub__(self,other)

        
    >>> a = int(3)
    >>> b = int(2)
    >>> a + b
    1

    反运算:

    反运算与算术运算符的不同之处是,反运算多了一个'r',例如 __add__()的反运算对应为 __radd__()

    >>> a + b

    这里a是加数,b是被加数,如果a对象的__add__()方法没有实现或者不支持相应的操作,那么python就会自动调用b的__radd__()方法

    实例:

    >>> class Nint(int):
        def __radd__(self,other):
            return int.__sub__(self,other)

        
    >>> a = Nint(5)
    >>> b = Nint(3)
    >>> a + b      #由于a对象默认有__add__()方法,所以b的__radd__()没有执行
    8

    实例2:

    >>> class Nint(int):
        def __radd__(self,other):
            return int.__sub__(self,other)

        
    >>> b = Nint(5)
    >>> 3 + b         #由于3无__add__()方法,所以执行b的反运算__radd__(self,other)方法,其中self是b对象
    2

    注:在重写反运算魔法方法时,一定要注意顺序问题。

    增量赋值运算:

    比较操作符:

    其它操作符:

    044 魔法方法:简单定制

    简单定制

    基本要求:

    定制一个计时器的类

    startstop方法代表启动计时和停止计时

    假设计时器对象t1print(t1)和直接调用t1均显示结果

    当计时器未启动或已经停止计时,调用stop方法会给予温馨的提示

    两个计时器对象可以进行相加:t1 + t2

    只能使用提供的有限资源完成

    你需要这些资源

    使用time模块的localtime方法获取时间

    扩展阅读:time 模块详解(时间获取和转换)

    有关time模块的localtime方法获取时间(参考:

    https://fishc.com.cn/forum.php?mod=viewthread&tid=51326&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403

    time.localtime返回struct_time的时间格式

    表现你的类:__str__ __repr__

    实例:

    import time as t   #导入时间模块,调用对象t

    class Mytimer():
        def __init__(self):
            self.unit = ['年','月','天','小时','分钟','秒']
            self.prompt = "未开始计时"
            self.lasted = []
            self.begin = 0  #属性
            self.end = 0
        def __str__(self):
            return self.prompt

        __repr__ = __str__

        def __add__(self,other):   #重写加法操作符,运行时间相加
            prompt = "总共运行了"
            result = []
            for index in range(6):
                result.append(self.lasted[index] + other.lasted[index])
                if result[index]:
                    prompt += (str(result[index]) + self.unit[index])
            return prompt
                               
        #开始计时
        def start(self):    #方法,属性名和方法名不能相同
            if not self.stop:
                self.prompt = ("提示:请先调用stop()停止计时!")
            else:
                self.begin = t.localtime()
                print('计时开始...')

        #停止计时
        def stop(self):
            if not self.begin:
                print('提示:请先调用start()进行计时!')
            else:
                self.end = t.localtime()
                self._calc()
                print('计时结束!')

        #内部方法,计算运行时间
        def _calc(self):
            self.prompt = "总共运行了"
            for index in range(6):
                self.lasted.append(self.end[index] - self.begin[index])
                if self.lasted[index]:
                    self.prompt += (str(self.lasted[index]) + self.unit[index])
            #为下一轮计时初始化变量
            self.begin = 0
            self.end = 0

    >>> t1 = Mytimer()
    >>> t1.stop()
    提示:请先调用start()进行计时!
    >>> t1.start()
    计时开始...
    >>> t1.stop()
    计时结束!
    >>> t1
    总共运行了4秒
    >>> t2 = Mytimer()
    >>> t2.start()
    计时开始...
    >>> t2.stop()
    计时结束!
    >>> t2
    总共运行了4秒
    >>> t1 + t2
    '总共运行了8秒'        

    进阶定制

    如果开始计时的时间是202222216:30:30,停止时间是202512315:30:30,那按照我们用停止时间减开始时间的计算方式就会出现负数3-11-1小时)你应该对此做一些转换

    现在的计算机速度都非常快,而我们这个程序最小的计算单位却只是秒,精度是远远不够的

    045 魔法方法:属性访问

    属性访问

    __getattr__(self, name)

    定义当用户试图获取一个不存在的属性时的行为

    __getattribute__(self, name)

    定义当该类的属性被访问时的行为

    __setattr__(self, name, value)

    定义当一个属性被设置时的行为

    __delattr__(self, name)

    定义当一个属性被删除时的行为

    实例1:

    class C:
        def __getattribute__(self, name):
            print('getattribute')
            # 使用 super() 调用 object 基类的 __getattribute__ 方法
            return super().__getattribute__(name)

        def __setattr__(self, name, value):
            print('setattr')
            super().__setattr__(name, value)

        def __delattr__(self, name):
            print('delattr')
            super().__delattr__(name)

        def __getattr__(self, name):
            print('getattr')

    >>> c = C()
    >>> c.x
    getattribute
    getattr
    >>> c.x = 1
    setattr
    >>> c.x
    getattribute
    1
    >>> del c.x
    delattr
    >>> setattr(c,'y','Yellow')
    setattr

    练习要求

    写一个矩形类,默认宽和高两个属性

    如果为一个叫square的属性赋值,那么说明这是一个正方形,值就是正方形的边长,此时宽和高都应该等于边长。

    实例2:

    class Rectangle:
        def __init__(self, width=0, height=0):
            self.width = width
            self.height = height

        def __setattr__(self, name, value):#一发生赋值操作,则会触发__setattr__()魔法方法
            if name == 'square':#判断name属性是否为正方形
                self.width = value
                self.height = value
            else:
                self.__dict__[name] = value

        def getArea(self):
            return self.width * self.height

    >>> r1 = Rectangle(4,5)
    >>> r1.getArea()
    20
    >>> r1.square = 10
    >>> r1.getArea()
    100

    046 魔法方法:描述符(Property的原理)

    描述符

    描述符就是将某种特殊类型的类的实例指派给另一个类的属性。

    __get__(self, instance, owner)

    用于访问属性,它返回属性的值

    __set__(self, instance, value)

    将在属性分配操作中调用,不返回任何内容

    __delete__(self, instance)

    控制删除操作,不返回任何内容

    实例:

    >>> class MyDecriptor:
        def __get__(self,instance,owner):
            print("getting...",self,instance,owner)
        def __set__(self,instance,value):
            print("setting...",self,instance,value)
        def __delete__(self,instance):
            print("deleting...",self,instance)

     

    >>> class Test:
        x = MyDecriptor()   #取Mydecriptor类的实例指派给Test类的属性x

    >>> test = Test()
    >>> test.x
    getting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98> <class '__main__.Test'>
    >>> test
    <__main__.Test object at 0x000000000335EF98>
    >>> test.x = "X-man"
    setting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98> X-man
    >>> del test.x
    deleting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98>

     

    实例2:

    >>> class MyProperty:
        def __init__(self,fget = None,fset = None,fdel = None):
            self.fget = fget
            self.fset = fset
            self.fdel = fdel
        def __get__(self,instance,owner):
            return self.fget(instance)
        def __set__(self,instance,value):
            self.fset(instance,value)
        def __delete__(self,instance):
            self.fdel(instance)

            
    >>> class C:
        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 = MyProperty(getX,setX,delX)

        
    >>> c = C()
    >>> c.x = "HELLOW"
    >>> c.x
    'HELLOW'
    >>> c._x
    'HELLOW'
    >>> del c.x
    >>> c._x
    Traceback (most recent call last):
      File "<pyshell#70>", line 1, in <module>
        c._x
    AttributeError: 'C' object has no attribute '_x'

    练习要求

    先定义一个温度类,然后定义两个描述符类用于描述摄氏度和华氏度两个属性

    要求个属性会自动进行转换,也就是说你可以给摄氏度这个属性赋值,然后打印的华氏度属性是自动转换后的结果。

    实例3:

    ss Celsius:  #摄氏度描述符类
        def __init__(self,value = 26.0):#self为描述符类自身(此为摄氏度描述符类)的实例(此为cel)
            self.value = float(value)
        def __get__(self,instance,owner):#instance是这个描述符的拥有者所在的类的实例(此为temp)
            return self.value
        def __set__(self,instance,value):#owner是这个描述符的拥有者所在的类本身(此为温度类)
            self.value = float(value)

    class Fahrenheit:   #华氏度描述符类
        def __get__(self,instance,owner):
            return instance.cel * 1.8 +32  #摄氏度转华氏度
        def __set__(self,instance,value):
            instance.cel = ((float)(value)- 32)/ 1.8   #华氏度转摄氏度
            
    class Temperature:   #温度类
        cel = Celsius()   #设置摄氏度属性(描述符类的实例指派给了温度类的属性)
        fah = Fahrenheit()#设置华氏度属性

    >>> temp = Temperature()
    >>> temp.cel
    26.0
    >>> temp.fah
    78.80000000000001
    >>> temp.fah = 78.8
    >>> temp.cel
    25.999999999999996

    047 魔法方法:定制序列

    协议是什么?

    协议(Protocols)与其他编程语言中的接口很相似,它规定你哪些方法必须要定义。然而,在Python中的协议就显得不那么正式。事实上,在Python中,协议更像是一种指南

    容器类型的协议

    如果说你希望定制的容器是不可变的话,你只需要定义__len__()__getitem__()方法。

    如果你希望定制的容器是可变的话,除了__len__()__getitem__()方法,你还需要定义__setitem__()__delitem__()两个方法。

    练习要求

    编写一个不可改变的自定义列表,要求记录列表中每个元素被访问的次数。

    class CountList:  #定义记录列表中每个元素访问次数类
        def __init__(self,*args): #参数是可变类型的
            self.values = [x for x in args]#将args的数据存入列表self.values中
            self.count = {}.fromkeys(range(len(self.values)),0)#创建字典,初试化为0

        def __len__(self):  #返回容器中元素的个数
            return len(self.values)#len方法用于返回参数的长度 
        def __getitem__(self,key):  #获取容器中指定元素的行为,key为访问对应的键
            self.count[key] += 1#每访问一次,字典键对应的键值加1
            return self.values[key]

    >>> c1 = CountList(1,3,5,7,9)
    >>> c2 = CountList(2,4,6,8,10)
    >>> c1[1]  #c1[1]第一次访问
    3
    >>> c2[2]
    6
    >>> c1[1] + c2[2] #c1[1]第二次访问
    9
    >>> c1.count
    {0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
    >>> c2.count
    {0: 0, 1: 0, 2: 2, 3: 0, 4: 0}

    048 魔法方法:迭代器

    迭代的意思类似于循环,每一次重复的过程被称为一次迭代的过程,而每一次迭代得到的结果会被用来作为下一次迭代的初始值。提供迭代方法的容器称为迭代器(如序列(列表、元组、字符串)、字典等)。

    对一个容器对象调用iter()就得到它的迭代器,调用next()迭代器就会返回下一个值。入托迭代器没有值可以返回了,就会抛出异常。

    •iter()

    –__iter__()

    •next()

    –__next__()

    实例1:

    >>> string = "FishC"
    >>> it = iter(string)
    >>> next(it)
    'F'
    >>> next(it)
    'i'
    >>> next(it)
    's'
    >>> next(it)
    'h'
    >>> next(it)
    'C'
    >>> next(it)
    Traceback (most recent call last):
      File "<pyshell#8>", line 1, in <module>
        next(it)
    StopIteration

    一个容器如果是迭代器,那就必须实现__iter__()魔法方法,这个方法实际上就是返回迭代器本身。重点要实现的是__next__()魔法方法,因为它决定了迭代的规则。

    实例2:

    >>> class Fibs:
        def __init__(self):
            self.a = 0
            self.b = 1
        def __iter__(self):
            return self
        def __next__(self):
            self.a,self.b = self.b,self.a + self.b
            return self.a

        
    >>> fibs = Fibs()
    >>> for each in fibs:
        if each < 20:
            print(each)
        else:
            break

        
    1
    1
    2
    3
    5
    8
    13

    实例3:

     

    >>> class Fibs:
        def __init__(self,n =20):
            self.a = 0
            self.b = 1
            self.n = n
        def __iter__(self):
            return self
        
        def __next__(self):
            self.a,self.b = self.b,self.a + self.b
            if self.a > self.n:
                raise StopIteration
            return self.a

        
    >>> fibs = Fibs()
    >>> for each in fibs:
        print(each)

        
    1
    1
    2
    3
    5
    8
    13

     

    >>> fibs = Fibs(10)
    >>> for each in fibs:
        print(each)

        
    1
    1
    2
    3
    5
    8

     

    049 乱入:生成器

    所谓协同程序,就是可以运行的独立函数调用,函数可以暂停或者挂起,并在需要的时候从程序离开的地方继续或者重新开始。

    生成器可以暂时挂起函数,并保留函数的局部变量等数据,然后在再次调用它的时候,从上次暂停的位置继续执行下去。

    一个函数中如果有yield语句,则被定义为生成器。

    实例1:

    >>> def myGen():
        print("生成器被执行了!")
        yield 1   #暂停一次,相当于return,返回1
        yield 2     #暂停一次,相当于return,返回2

        
    >>> myG = myGen()
    >>> next(myG)
    生成器被执行了!
    1
    >>> next(myG)
    2

    像前面介绍的斐波那契的例子,也可以用生成器来实现:

    >>> def fibs():
        a = 0
        b = 1
        while True:
            a,b = b,a + b
            yield a

            
    >>> for each in fibs():
        if each > 100:
            break
        print(each)

        
    1
    1
    2
    3
    5
    8
    13
    21
    34
    55
    89

    列表推导式表达:

    100以内,能被2整除,但不能被3整除的所有整数

    >>> a = [i for i in range(100) if not (i % 2) and (i % 3 )]
    >>> a
    [2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]

    字典推导式:

    10以内是否为偶数

    >>> a = {i:i % 2 == 0 for i in range(10)}
    >>> a
    {0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

    集合推导式:

    >>> a = {i for i in [1,2,3,3,4,5,5,5,6,7,7,8]}
    >>> a
    {1, 2, 3, 4, 5, 6, 7, 8}

    元组生成器推导式:

    >>> e = (i for i in range(5))
    >>> next(e)
    0
    >>> next(e)
    1
    >>> next(e)
    2

    050 模块:模块就是程序

    什么是模块

    容器 -> 数据封装

    函数 -> 语句封装

    -> 方法和属性的封装

    模块 -> 模块就是程序

    命名空间

    爱的宣言:世界上只有一个名字,使我这样牵肠挂肚,像有一根看不见的线,一头牢牢系在我心尖上,一头攥在你手中,这个名字就叫做鱼C工作室计算机一班的小花……

    导入模块

    第一种:import 模块名

    实例1:import导入模块

    实例2:import导入模块

    第二种:from 模块名 import 函数名(不推荐使用)

    第三种:import 模块名 as 名字(推荐使用)

    TemperatureConversion文件:

    def c2f(cal):
        return cal * 1.8 + 32
    def f2c(fah):
        return (fah - 32)/1.8

    calc文件:

    import TemperatureConversion as tc  #tc为取得新名字

    print("32摄氏度 = %.2f 华氏度\n" % tc.c2f(32))
    print("99华氏度 = %.2f 摄氏度" % tc.f2c(99))

    051 模块:__name__='__main__'、搜索路径和包

    模块!模块!

    实例1:为TemperatureConversion添加测试程序(TemperatureConversion被作为程序运行)

    def c2f(cal):
        return cal * 1.8 + 32

    def f2c(fah):
        return (fah - 32)/1.8

    def test():
        print("0摄氏度 = %.2f 华氏度\n" % c2f(0))
        print("0华氏度 = %.2f 摄氏度" % f2c(0))

    test()

    运行calc文

    当希望TemperatureConversion被调用时作为模块导入时

    def c2f(cal):
        return cal * 1.8 + 32

    def f2c(fah):
        return (fah - 32)/1.8

    def test():
        print("0摄氏度 = %.2f 华氏度" % c2f(0))
        print("0华氏度 = %.2f 摄氏度" % f2c(0))

    if __name__ == "__main__":#当此文件当做程序运行时,执行test(),否则不执行
        test()

    运行calc文件

    if __name__ == ‘__main__’

    搜索路径(系统会首先搜索的路径)

    >>> import sys
    >>> sys.path
    ['D:\\python3.3.2\\小甲鱼python\\python程序\\第五十节课\\Temperature', 'D:\\python3.3.2\\Lib\\idlelib', 'C:\\windows\\system32\\python33.zip', 'D:\\python3.3.2\\DLLs', 'D:\\python3.3.2\\lib', 'D:\\python3.3.2', 'D:\\python3.3.2\\lib\\site-packages']

    添加搜索路径:

    >>> import TemperatureConversion
    Traceback (most recent call last):
      File "<pyshell#0>", line 1, in <module>
        import TemperatureConversion
    ImportError: No module named 'TemperatureConversion'

    >>> import sys
    >>> sys.path.append("D:\\python3.3.2\WODE\Temperature")
    >>> sys.path
    ['', 'D:\\python3.3.2\\Lib\\idlelib', 'C:\\windows\\system32\\python33.zip', 'D:\\python3.3.2\\DLLs', 'D:\\python3.3.2\\lib', 'D:\\python3.3.2', 'D:\\python3.3.2\\lib\\site-packages', 'D:\\python3.3.2\\WODE\\Temperature']
    >>> import TemperatureConversion
    >>> TemperatureConversion.f2c(59)
    15.0

    package

    1.创建一个文件夹,用于存放相关的模块,文件夹的名字即包的名字;

    2.文件夹中创建一个__init__.py的模块文件,内容可以为空;

    3.相关的模块放入文件夹中

    052 模块:像个极客一样去思考

    使用print调用__doc__属性,可以带格式查看这个模块的简介

    使用dir()可以查询到该模块定义了哪些变量、函数和类

    053 论一只爬虫的自我修养

    Python如何访问互联网?

     

    URL的一般格式为(带方括号[]的为可选项)

    protocol :// hostname[:port] / path / [;parameters][?query]#fragment

    URL由三部分组成:

    第一部分是协议httphttpsftpfileed2k…

    第二部分是存放资源的服务器的域名系统或IP地址(有时候要包含端口号,各种传输协议都有默认的端口号,如http的默认端口为80)。

    第三部分是资源的具体地址,如目录文件名

    054 论一只爬虫的自我修养2:实战

    import urllib.request

    response = urllib.request.urlopen('http://placekitten.com/g/500/600')#  返回文件对象response
    cat_imag = response.read()

    with open('cat_500_600.jpg','wb') as f:
        f.write(cat_imag)

    >>> response.geturl()
    'http://placekitten.com/g/500/600'
    >>> response.info()
    <http.client.HTTPMessage object at 0x00000000034EAA20>
    >>> print(response.info())
    Date: Sat, 27 Jul 2019 02:44:18 GMT
    Content-Type: image/jpeg
    Transfer-Encoding: chunked
    Connection: close
    Set-Cookie: __cfduid=d3cd08233581619b9ef8464ae93f7d5ff1564195458; expires=Sun, 26-Jul-20 02:44:18 GMT; path=/; domain=.placekitten.com; HttpOnly
    Access-Control-Allow-Origin: *
    Cache-Control: public, max-age=86400
    Expires: Sun, 28 Jul 2019 02:44:18 GMT
    CF-Cache-Status: HIT
    Age: 66459
    Vary: Accept-Encoding
    Server: cloudflare
    CF-RAY: 4fcb454ecc35ce6b-LHR


    >>> response.getcode()
    200

    055 论一只爬虫的自我修养3:隐藏

    修改 headers

    通过Requestheaders参数修改

    通过Request.add_header()方法修改

    代理

    步骤:

    1. 参数是一个字典 {‘类型’:‘代理ip:端口号’}

    proxy_support = urllib.request.ProxyHandler({})

     

    2. 定制、创建一个 opener

    opener = urllib.request.build_opener(proxy_support)

     

    3a. 安装 opener

    urllib.request.install_opener(opener)

    3b. 调用 opener

    opener.open(url)

     

    064 GUI的终极选择:Tkinter

     

    >>> import tkinter   #Tkinter是python默认的GUI库,导入Tkinter模块
    >>> 

    实例1:

    import tkinter as tk

    root = tk.Tk()#创建一个主窗口,用于容纳整个GUI程序
    root.title("FishC Demo")#设置主窗口对象的标题栏

    #添加一个Label组件,可以显示文本、图标或者图片(此处显示文本)
    theLabel = tk.Label(root,text = "我的第二个窗口程序")
    theLabel.pack()#调用Label组件的pack方法,用于自动调节组件自身尺寸

    root.mainloop()#执行此语句后,窗口才会显示,程序进入主事件循环

    实例2:

    import tkinter as tk

    class App:#创建类App
        def __init__(self,root):#self为指向App类的指针
            #创建一个框架,然后在里面添加一个Button按钮组件,框架用来将复杂布局中按钮分组
            frame = tk.Frame(root)
            frame.pack(side = tk.RIGHT,padx = 10,pady = 10)#调节框架自身尺寸,此处设置为右对齐(右上角为原点),偏移(10,10)
            
            #创建一个按钮组件,fg(foreground),设置前景色
            #创建一个Button按钮,属性为self.hi_there,属于frame框架,按钮按下时调用self.say_hi方法
            #设置前景色为黑色,背景色为白色
            self.hi_there = tk.Button(frame,text = "打招呼",bg = "black",fg = "white",command = self.say_hi)
            self.hi_there.pack()#自动调节自身尺寸
            
            #say_hi()方法定义实现   
        def say_hi(self):
            print("互联网广大朋友们好,我是亦我飞也!")
            
            
    root = tk.Tk()#创建一个主窗口(toplever的根窗口),并把它作为参数实例化app对象,用于容纳整个GUI程序,
    app = App(root)#创建类App的一个实例对象app,传入参数为root

    app.mainloop()#执行此语句后,窗口才会显示,程序进入主事件循环
     

    065 GUI的终极选择:Tkinter2

    实例1:Label组件显示文字与gif图片

    #导入tkinter模块的所有内容
    from tkinter import *

    #创建主窗口
    root = Tk()
    #创建一个文本Label对象,文字为左对齐,离左边边框距离为10
    textLabel = Label(root,
                      text = "您下载的影片含有未成年人限制内容,\n请满18周岁后再点击观看!",
                      justify = LEFT,padx = 10)
    #Label组件为左对齐
    textLabel.pack(side = LEFT)

    #创建一个图像Label对象
    #用PhotoImage实例化一个图片对象(支持gif格式的图片)
    photo = PhotoImage(file = "18.gif")
    imgLabel = Label(root,image = photo)
    imgLabel.pack(side = RIGHT)

    mainloop()
     

    实例2:

    例2:文字显示在图片上

    #导入tkinter模块的所有内容
    from tkinter import *

    #创建主窗口
    root = Tk()

    #创建一个图像Label对象
    photo = PhotoImage(file = "bg.gif")
    #创建一个文本Label对象
    textLabel = Label(root,
                      text = "学Python\n到FishC!",
                      font = ("宋体",20),
                      fg = "white",
                      justify = LEFT,  #文字左对齐
                      image = photo,
                      compound = CENTER, #设置文本和图像的混合模式
                      )
    #文本Label对象偏移,离左窗口与上窗口都为10
    textLabel.pack(side = LEFT,padx =10,pady =10)

    mainloop()
     

    实例2:Button组件

    #导入tkinter模块的所有内容
    from tkinter import *

    def callback():
        var.set("吹吧你,我才不信呢~")

    #创建主窗口
    root = Tk()
    #设置主窗口对象的标题栏
    root.title("TK")

    frame1 = Frame(root)#框架1
    frame2 = Frame(root)#框架2

    #创建一个文本Label对象,文字为左对齐
    var = StringVar()
    var.set("您下载的影片含有未成年人限制内容,\n请满18周岁后再点击观看!")
    textLabel = Label(frame1,
                      textvariable = var, #Button显示一个StringVar的变量
                      justify = LEFT)
    #Label组件为左对齐
    textLabel.pack(side = LEFT)

    #创建一个图像Label对象
    #用PhotoImage实例化一个图片对象(支持gif格式的图片)
    photo = PhotoImage(file = "18.gif")
    imgLabel = Label(root,image = photo)
    imgLabel.pack(side = RIGHT)

    #加一个按钮
    theButton = Button(frame2,text = "已满18周岁",command = callback)
    theButton.pack()
    frame1.pack(padx = 10,pady = 10)
    frame2.pack(padx = 10,pady = 10)

    mainloop()

    066 GUI的终极选择:Tkinter3

    实例1:Checkbutton 组件

    from tkinter import *

    root = Tk()
    #需要一个Tkinter变量,用于表示该按钮是否被选中
    v = IntVar()
    c = Checkbutton(root,text="测试一下",variable = v)

    c.pack()
    #如果被选中,那么变量v被赋值为1,否则为0
    #可以用个Label标签动态地给大家展示:
    lable = Label(root,textvariable = v)
    lable.pack()

    mainloop()

    实例2:

    from tkinter import *

    root = Tk()

    GIRLS = ["貂蝉","王昭君","西施","杨玉环"]
    v = []
    for girl in GIRLS:
        v.append(girl)
        c = Checkbutton(root,text = girl,variable = v[-1])#-1表示每次取v列表中最后一个元素,即刚加入的那个元素
        c.pack(anchor = W)#W(western)向左对齐

    mainloop()

    实例3:Radiobutton 组件

    from tkinter import *

    root = Tk()

    v = IntVar()#如果被选中,v被赋值为1,否则为0
    Radiobutton(root,text = "One",variable = v,value = 1).pack(anchor = W)
    #value表示第一个按钮被选中时,v的值赋值给variable

    Radiobutton(root,text = "Two",variable = v,value = 2).pack(anchor = W)

    Radiobutton(root,text = "Three",variable = v,value = 3).pack(anchor = W)

    Radiobutton(root,text = "Four",variable = v,value = 4).pack(anchor = W)

    mainloop()

    实例4:循环处理

    from tkinter import *

    root = Tk()

    LANGS = [
        ("Python",1),
        ("Perl",2),
        ("Ruby",3),
        ("Lua",4)]
         

    v = IntVar()#如果被选中,v被赋值为1,否则为0
    v.set(1)#将1设置为默认值
    for lang,num in LANGS:
        b= Radiobutton(root,text = lang,variable = v,value = num)
        b.pack(anchor = W)
    #value表示第一个按钮被选中时,v的值赋值给variable

    mainloop()

    实例5:改成按钮形式

    from tkinter import *

    root = Tk()

    LANGS = [
        ("Python",1),
        ("Perl",2),
        ("Ruby",3),
        ("Lua",4)]
         

    v = IntVar()#如果被选中,v被赋值为1,否则为0
    v.set(1)#将1设置为默认值
    for lang,num in LANGS:
        b= Radiobutton(root,text = lang,variable = v,value = num,indicatoron = False)
        b.pack(fill = X)#表示横向填充
    #value表示第一个按钮被选中时,v的值赋值给variable

    mainloop()

    实例6:LabelFrame 组件

    from tkinter import *

    root = Tk()

    group = LabelFrame(root,text = "最好的脚本语言是?",padx = 10,pady = 10)#按钮相对边框的偏移
    group.pack(padx = 10,pady = 10)#框架相对边框的偏移

    LANGS = [
        ("Python",1),
        ("Perl",2),
        ("Ruby",3),
        ("Lua",4)]
         

    v = IntVar()#如果被选中,v被赋值为1,否则为0
    v.set(1)#将1设置为默认值
    for lang,num in LANGS:
        b= Radiobutton(group,text = lang,variable = v,value = num,indicatoron = False)
        b.pack(fill = X)
    #value表示第一个按钮被选中时,v的值赋值给variable

    mainloop()

    067 GUI的终极选择:Tkinter4

    实例1:

    from tkinter import *

    root = Tk()#创建主窗口
    e = Entry(root)#在主窗口中插入输入框
    e.pack(padx = 20,pady = 20)

    e.delete(0,END)#清空输入框
    e.insert(0,"默认文本...")#设置输入框内容

    mainloop()

    实例2:

    from tkinter import *

    def button1_show():
        print("作品:《%s》" % e1.get())#将e1.get()中得到的输入框1的内容格式化为字符串
        print("作者:%s" % e2.get())

    root = Tk()#创建主窗口

    Label(root,text = "作品:",padx = 20,pady = 10).grid(row=0,column=0)#第1行第1列,偏移是相对于当前操作组件的相邻x轴或y轴的偏移距离
    Label(root,text = "小甲鱼:").grid(row=1,column=0)#第1行第0列


    e1 = Entry(root)#在主窗口中插入输入框,文本框的内容通过e1调用
    e2 = Entry(root)#在主窗口中插入输入框
    e1.grid(row=0,column=1,padx=10)#x方向偏移是相对于"作品"的x方向偏移的;y方向偏移表示此输入框与y方向相邻物体或边框之间偏移的距离(y方向偏移)
    e2.grid(row=1,column=1,padx=10,pady=20)#x方向偏移是相对于"小甲鱼"的x方向偏移的;y方向偏移表示此输入框与y方向相邻上下物体或边框偏移的距离(y方向偏移)


    #加两个按钮
    Button1 = Button(root,text = "获取信息",command = button1_show)\
              .grid(row = 2,column = 0,sticky = W,padx = 10,pady=10)#加入反斜杠可实现分行编辑,方位设置为最西边(即靠左)
    Button2 = Button(root,text = "退出",command = root.quit).grid(row = 2,column = 1,sticky = E,padx=10)#方位设置为最东边(即靠右)

    #注:双击打开文件时退出才有效
    e1.delete(0,END)#清空输入框
    e1.insert(0,"零基础入门学习Python")#设置输入框内容

    e2.delete(1,END)#清空输入框
    e2.insert(1,"小甲鱼")#设置输入框内容

    mainloop()

    按下获取信息

    更改输入框数据,然后按下获取信息

    实例2:账号密码设置

    from tkinter import *

    def show():
        print("作品:《%s》" % e1.get())#将e1.get()中得到的输入框1的内容格式化为字符串
        print("作者:%s" % e2.get())
        e1.delete(0,END)#清空输入框1
        e2.delete(0,END)#清空输入框2

    root = Tk()#创建主窗口
    #Tkinter总共提供了三种布局组件的方法:pack()、grid()和place()
    #grid()方法允许你用表格的形式来管理组件的位置
    #row选项代表行,coulumn选项代表列
    #row = 1,column = 2表示第二行第三列(0表示第一行)

    Label(root,text = "账号:").grid(row=0)#第1行
    Label(root,text = "密码:").grid(row=1)#第2行
    v1 = StringVar()
    v2 = StringVar()

    e1 = Entry(root,textvariable = v1)#在主窗口中插入输入框,文本框的内容通过e1调用
    e2 = Entry(root,textvariable = v2,show="*")#在主窗口中插入输入框
    e1.grid(row=0,column=1,padx=10,pady=5)#x方向偏移是相对于"作品"的x方向偏移的;y方向偏移表示此输入框与y方向相邻物体或边框之间偏移的距离(y方向偏移)
    e2.grid(row=1,column=1,padx=10,pady=5)#x方向偏移是相对于"小甲鱼"的x方向偏移的;y方向偏移表示此输入框与y方向相邻上下物体或边框偏移的距离(y方向偏移)


    #可以使用sticky选项来设置组件的位置
    #使用N、E、S、W以及他们的组合NE、SE、SW、NW来表示方位

    #加两个按钮
    Button(root,text = "芝麻开门",command = show)\
              .grid(row = 2,column = 0,sticky = W,padx = 10,pady=5)#加入反斜杠可实现分行编辑,方位设置为最西边(即靠左)
    Button(root,text = "退出",command = root.quit).grid(row = 2,column = 1,sticky = E,padx=10)#方位设置为最东边(即靠右)

    mainloop()

    实例3:验证函数validatecommand

    from tkinter import *

    master = Tk()

    def test():
        if e1.get() == "小甲鱼":
            print("正确!")
            return True
        else:
            print("错误!")
            e1.delete(0, END)
            return False

    v = StringVar()

    #focusout表示Entry组件失去焦点的时候验证,调用validatecommand的test函数

    e1 = Entry(master, textvariable=v, validate="focusout", validatecommand=test)
    e2 = Entry(master)
    e1.pack(padx=10, pady=10)
    e2.pack(padx=10, pady=10)

    mainloop()
     

    实例4:invalidcommand函数

    from tkinter import *

    master = Tk()

    def test():
        if e1.get() == "小甲鱼":
            print("正确!")
            return True
        else:
            print("错误!")
            e1.delete(0, END)
            return False

    def test2():
        print("我被调用了...")

    v = StringVar()

    #focusout表示Entry组件失去焦点的时候验证,调用validatecommand的test函数
    #invalidcommand选项指定的函数只有在validatecommand的返回值为False的时候才被调用
    e1 = Entry(master, textvariable=v, validate="focusout", validatecommand=test,\
               invalidcommand=test2)
    e2 = Entry(master)
    e1.pack(padx=10, pady=10)
    e2.pack(padx=10, pady=10)

    mainloop()
     

    实例5:验证函数提供一些额外的选项

    validatecommand(f,s1,s2,...)

    其中,f是验证函数名,s1,s2,s3是额外的选项,这些选项会作为参数一次传给f函数。在此之前,需要调用register()方法将验证函数包装起来。

    from tkinter import *

    master = Tk()

    v = StringVar()

    def test(content, reason, name):
        if content == "小甲鱼":
            print("正确!")
            print(content, reason, name)
            return True
        else:
            print("错误!")
            print(content, reason, name)
            return False

    testCMD = master.register(test)
    e1 = Entry(master, textvariable=v, validate="focusout", \
               validat
               ecommand=(testCMD, '%P', '%v', '%W'))
    e2 = Entry(master)
    e1.pack(padx=10, pady=10)
    e2.pack(padx=10, pady=10)

    mainloop()
     

    实例6:设计一个 计算器

    from tkinter import *
    #计算函数
    def calc():
        result = int(v1.get())+int(v2.get())#强制转换为整型
        v3.set(result)#将result中的内容放到v3中

    #创建窗口
    root = Tk()
    #创建窗口中的一个frame框架
    frame = Frame(root)
    #设置框架位置并显示
    frame.pack(padx = 10,pady = 10)

    v1 = StringVar()
    v2 = StringVar()
    v3 = StringVar()

    #注意,这里不能使用e1.get()或者v1.get()来获取输入的内容,因为validate选项
    #指定为“key"的时候,有任何输入操作都会被拦截到这个函数中
    #也就是说先拦截,只有这个函数返回True,那么输入的内容才会到变量里去
    #所以要用%P来获取最新的输入框内容
    def test(content):
        if content.isdigit():
            return True
        else:
            return False

    #创建三个Entry组件
    testCMD = frame.register(test)
    #创建2个输入组件,输入的数据赋值给v1、v2
    e1 = Entry(frame, textvariable=v1,width=10, validate="key",\
               validatecommand=(testCMD, '%P'))
    e2 = Entry(frame, textvariable=v2,width=10, validate="key",\
               validatecommand=(testCMD, '%P'))
    #一个输出组件,设置为只读模式(readonly),v3的数据赋值给textvariable进行输出显示
    e3 = Entry(frame, textvariable=v3,width=10, validate="key",\
               validatecommand=(testCMD, '%P'),state="readonly")
    #位置设置
    e1.grid(row=0,column=0,padx=10,pady=10)
    e2.grid(row=0,column=2,padx=10)
    e3.grid(row=0,column=4,padx=10)

    #创建两个Label组件
    Label(frame,text="+").grid(row=0,column=1)
    Label(frame,text="=").grid(row=0,column=3)

    #创建一个按钮,宽度为10
    button=Button(frame,text="计算结果",width=10,command=calc)
    button.grid(row=1,column=2,pady=10)

    mainloop()

    068 GUI的终极选择:Tkinter5

    Listbox组件

    如果需要提供选项给用户选择,单选可以用Radiobutton组件,多选可以用Checkbutton,如果提供的选项非常多,可以考虑使用Listbox组件。Listbox是以列表的形式显示出来,并支持滚动条操作。

    实例1:

    from tkinter import *

    root = Tk()#创建主窗口

    theLB = Listbox(root,setgrid = True,selectmode=EXTENDED)#创建一个空列表
    theLB.pack()

    #往列表里添加数据
    for item in ["鸡蛋","鸭蛋","鹅蛋","李狗蛋"]:
        theLB.insert(END,item)#每次在列表最后插入一个数据

    #创建一个按钮,ACTIVE表示当前选中的数据
    theButton = Button(root,text="删除",command = lambda x = theLB:x.delete(ACTIVE))
    theButton.pack()

    #theLB.delete(0,END)删除所有列表数据

    mainloop()

    注:listbox.delete(0,END)可以删除列表中所有项目

    实例2:添加height选项

    from tkinter import *

    root = Tk()#创建主窗口

    #height=11表示可以显示11个项目
    theLB = Listbox(root,setgrid = True,\
                    selectmode=BROWSE,height=11)#创建一个空列表,选择模式为单选
    theLB.pack()

    #往列表里添加数据
    for item in range(11):
        theLB.insert(END,item)#每次在列表最后插入一个数据

    #创建一个按钮,ACTIVE表示当前选中的数据
    theButton = Button(root,text="删除",command = lambda x = theLB:x.delete(ACTIVE))
    theButton.pack()

    #theLB.delete(0,END)删除所有列表数据

    mainloop()

    Scrollbar组件

    实例1:

    from tkinter import *

    root = Tk()#创建主窗口

    sb = Scrollbar(root)
    sb.pack(side=RIGHT,fill=Y)

    lb = Listbox(root,yscrollcommand=sb.set)#创建一个空列表
    for i in range(1000):
        lb.insert(END,i)
    lb.pack(side=LEFT,fill=BOTH)

    sb.config(command = lb.yview)

    mainloop()

    事实上,这是一个互联互通的过程。当用户操作滚动条时,滚动条响应滚动并同时通过Listbox组件的yview()方法滚动列表框里的内容;同样,当列表框中可视范围发生改变的时候,Listbox组件通过调用Scrollbar组件的set()方法设置滚动条的最新位置。

    Scale组件

    Scale组件主要是通过滑块来表示某个范围内的一个数字,可以通过修改选项设置范围以及分辨率(精度)

    实例1:

    from tkinter import *

    root = Tk()#创建主窗口
    Scale(root,from_=0,to=42).pack()#创建铅锤方向滚动条
    Scale(root,from_=0,to=200,orient=HORIZONTAL).pack()#创建水平方向滚动条

    mainloop()

    实例2:打印当前位置

    from tkinter import *

    def show():
        print(s1.get(),s2.get())#使用get()方法获取当前滑块的位置

    root = Tk()#创建主窗口
    s1 = Scale(root,from_=0,to=42)#创建铅锤方向滚动条
    s1.pack()
    s2 = Scale(root,from_=0,to=200,orient=HORIZONTAL)#创建水平方向滚动条
    s2.pack()

    #创建一个按钮
    Button(root,text="获取位置",command=show).pack()

    mainloop()

    实例3:通过resolution选项控制分辨率(步长),通过tickinterval选项设置刻度

    from tkinter import *

    def show():
        print(s1.get(),s2.get())#使用get()方法获取当前滑块的位置

    root = Tk()#创建主窗口
    #tickinterval表示设置刻度,即每隔多少显示一个刻度
    #length表示滚动条的长度所占的像素数
    #resolution用来控制分辨率(步长)
    s1 = Scale(root,from_=0,to=42,tickinterval=5,length=200,\
               resolution=5,orient=VERTICAL)#创建铅锤方向滚动条
    s1.pack()
    s2 = Scale(root,from_=0,to=200,tickinterval=10,\
               length=600,orient=HORIZONTAL)#创建水平方向滚动条
    s2.pack()

    #创建一个按钮
    Button(root,text="获取位置",command=show).pack()

    mainloop()

    069 GUI的终极选择:Tkinter6

    Text组件

    Text(文本)组件用于显示和处理多种任务。虽然该组件的主要目的是显示多行文本,但它常常也被用于作为简单的文本编辑器和网页浏览器使用。

    实例1:插入内容

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=2)
    text.pack()
    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love\n")#光标当前的位置插入

    #END,对应Text组件的文本缓存区最后一个字符的下一个位置
    text.insert(END,"FishC.com!")

    mainloop()

    实例2:插入image对象windows组件

    from tkinter import *

    def show():
        print("哟,我被点了一下~")

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入

    #创建一个按钮
    b1=Button(root,text="点我点我",command=show)
    text.window_create(INSERT,window=b1)

    mainloop()
     

    实例3:单击按钮显示一张图片

    from tkinter import *

    def show():
        text.image_create(INSERT,image=photo)

    root = Tk()
    text = Text(root,width=30,height=50)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入

    photo = PhotoImage(file='fishc.gif')

    #创建一个按钮
    b1=Button(root,text="点我点我",command=show)
    text.window_create(INSERT,window=b1)

    mainloop()

    Indexer用法

    实例1:“line.column”

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    print(text.get(1.2,1.6))#获取第一行第2列到第一行第六列的数据

    mainloop()

    实例2:“line.end”

    行号加上字符串".end"格式表示为该行最后一个字符的位置

    实例:

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    print(text.get("1.2","1.end"))#获取第一行第2列到第一行第六列的数据

    mainloop()

    Mask用法

    mask(标记)通常是嵌入到Text组件文本中的不可见对象。事实上,Marks是指定字符间的位置,并跟随相应的字符一起移动。

    实例:Mark事实上就是索引,用于表示位置

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.mark_set("here","1.2")#设置光标位置为1.2
    text.insert("here","插")

    mainloop()

    实例2:如果Mark前面的内容发生改变,Mark的位置也会跟着移动

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.mark_set("here","1.2")#设置当前光标位置为1.2
    text.insert("here","插")#执行后当前光标位置(Mark位置)变成了1.3
    text.insert("here","入")
    #text.insert("1.3","入")

    mainloop()

    实例3:如果Mark周围的文本被删除了,Mark仍然存在

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.mark_set("here","1.2")#设置当前光标位置为1.2
    text.insert("here","插")#执行后当前光标位置变成了1.3
    text.delete("1.0",END)
    text.insert("here","入")#here表示当前Mark的位置,如果Mark左边并没有数据则会插入到最左边

    mainloop()

    例4:只有mark_unset()方法可以解除Mark的封印

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.mark_set("here","1.2")#设置当前光标位置为1.2
    text.insert("here","插")#执行后当前光标位置变成了1.3
    text.mark_unset("here")

    text.delete("1.0",END)
    text.insert("here","入")#here表示当前Mark的位置

    mainloop()

    默认插入内容是插入到Mark左侧(就是说插入一个字符后,Mark向后移动了一个字符的位置)

    实例5:插入内容到Mark的右侧

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.mark_set("here","1.2")#设置当前Mark位置为1.2
    text.mark_gravity("here",LEFT)

    text.insert("here","插")#执行后当前Mark位置变成了1.3
    text.insert("here","入")#here表示当前Mark的位置

    mainloop()

    070 GUI的终极选择:Tkinter7

    实例1:添加Tags

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,,与1.14设置Tag样式
    text.tag_config("tag1",background ="yellow",foreground="red")

    mainloop()

    实例2:Tags覆盖

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,,与1.14设置Tag样式
    text.tag_add("tag2","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,,与1.14设置Tag样式

    text.tag_config("tag1",background ="yellow",foreground="red")
    text.tag_config("tag2",background ="blue")

    mainloop()
     

    实例2:降低Tag优先级

    from tkinter import *

    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,,与1.14设置Tag样式
    text.tag_add("tag2","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,,与1.14设置Tag样式

    text.tag_config("tag1",background ="yellow",foreground="red")
    text.tag_config("tag2",background ="blue")

    text.tag_lower("tag2")#降低tag2的优先级

    mainloop()

    实例3:Tags事件绑定

    from tkinter import *
    import webbrowser#导入网页模块

    def show_hand_cursor(event):
        text.config(cursor="arrow")

    def show_arrow_cursor(event):
        text.config(cursor="xterm")

    def click(event):
        webbrowser.open("http://www.fishc.com")
        
    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    text.tag_add("link","1.7","1.16")#1.7(第一行第八列)到1.16
    #设置蓝色前景色并底部划线
    text.tag_config("link",foreground="blue",underline=True)

    #当进入绑定文本段时,鼠标样式切换为“arrow"形态
    text.tag_bind("link","<Enter>",show_hand_cursor)
    #当离开绑定文本段时,鼠标样式切换为“xterm"形态
    text.tag_bind("link","<Leave>",show_arrow_cursor)
    #当触发鼠标“左键单击”时,使用默认浏览器打开鱼C网址
    text.tag_bind("link","<Button-1>",click)

    mainloop()

    实例4:判断内容是否发生改变

    from tkinter import *
    import hashlib

    def getSig(contents):
        m = hashlib.md5(contents.encode())
        return m.digest()

    def check():#检查
        contents = text.get(1.0,END)
        if sig!=getSig(contents):
            print("警报,内容发生变动")
        else:
            print("风平浪静")
        
    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
    #注意,行号从1开始,列号则从0开始
    #获取文本内容
    contents=text.get(1.0,END)

    sig = getSig(contents)

    Button(root,text="检查",command=check).pack()

    mainloop()

    实例5:查找操作(使用search()方法可以搜索Text组件中的内容)

    from tkinter import *
    import hashlib

    #将任何格式的索引号统一为元组(行,列)的格式输出
    def getIndex(text,index):
        #split这里以"."拆分字符串,将1.3拆分为字符1和3,然后通过map将字符转换为整型
        return tuple(map(int,str.split(text.index(index),".")))
        
    root = Tk()
    text = Text(root,width=30,height=5)
    text.pack()

    #INSERT索引表示插入光标当前的位置
    text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入

    #将任何格式的索引号统一为元组(行、列)的格式输出
    start = 1.0
    while True:
        pos = text.search("o",start,stopindex=END)#从开始到结束全文搜索
        if not pos:
            break
        print("找到了,位置是:",getIndex(text,pos))
        start = pos + "+1c"#将start指向找到的字符位置的下一个字符,以便进行下一次搜索

    mainloop()

    Text组件内部有一个栈专门用于记录内容的每次变动,所以每次“撤销”操作就是一次弹栈操作,“恢复”就是再次压栈。

    实例6:撤销

    from tkinter import *

    #将任何格式的索引号统一为元组(行,列)的格式输出
    def show():
        text.edit_undo()
        
    root = Tk()
    text = Text(root,width=30,height=5,undo=True)
    text.pack()
    text.insert(INSERT,"I love FishC")

    Button(root,text="撤销",command=show).pack()

    mainloop()


    实例7:每次撤销一个字符

    from tkinter import *

    def callback(event):
        text.edit_separator()

    def show():
        text.edit_undo()#执行撤回操作
        
    root = Tk()

    #autoseparators表示一次完整的操作结束后自动插入“分隔符”,此处设置为False
    text = Text(root,width=30,height=5,autoseparators=False,undo=True,maxundo=10)
    text.pack()

    text.insert(INSERT,"I love FishC!")
    text.bind('<Key>',callback)#每次有输入就插入一个“分隔符”

    Button(root,text="撤销",command=show).pack()

    mainloop()

    071 GUI的终极选择:Tkinter8

    Canvas(画布)组件

    一个可以让你随心所欲绘制界面的组件。通常用于显示和编辑图形,可以用它来绘制直线、图形、多边形,甚至是绘制其他组件。

    实例1:

    from tkinter import *
    root = Tk()
    #创建canvas对象框,设置其宽度、高度与背景色
    w = Canvas(root,width=200,height=100,background="black")
    w.pack()

    #画一条黄色的线
    w.create_line(0,50,200,50,fill="yellow")
    #画一条红色的竖线(虚线)
    w.create_line(100,0,100,100,fill="red")
    #中间画一个蓝色的矩形
    w.create_rectangle(50,25,150,75,fill="blue")

    mainloop()

    实例2:

    from tkinter import *
    root = Tk()
    #创建canvas对象框,设置其宽度、高度与背景色
    w = Canvas(root,width=200,height=100,background="black")
    w.pack()

    #画一条黄色的线(参数为其x、y轴坐标)
    line1 = w.create_line(0,50,200,50,fill="yellow")
    #画一条红色的竖线(虚线)
    line2 = w.create_line(100,0,100,100,fill="red")
    #中间画一个蓝色的矩形
    rect1 = w.create_rectangle(50,25,150,75,fill="blue")

    w.coords(line1,0,25,200,25)#将line1移动到新的坐标
    w.itemconfig(rect1,fill="red")#重新设置矩形的填充色为红色
    w.delete(line2)#删除线2

    #创建一个按钮,按下时删除所有图形
    Button(root,text="删除全部",command=(lambda x=ALL:w.delete(x))).pack()

    mainloop()

    实例3:在Canvas上显示文本

    from tkinter import *
    root = Tk()
    #创建canvas对象框,设置其宽度、高度与背景色
    w = Canvas(root,width=200,height=100,background="black")
    w.pack()

    #画一条绿色的斜线(参数为其x、y轴坐标),宽度为三个像素点
    line1 = w.create_line(0,0,200,100,fill="green",width=3)
    #画一条绿色的斜线
    line2 = w.create_line(200,0,0,100,fill="green",width=3)
    #中间画两个矩形
    rect1 = w.create_rectangle(40,20,160,80,fill="blue")
    rect2 = w.create_rectangle(60,30,140,70,fill="yellow")
    #在矩形正中(默认)显示文本,坐标为文本正中坐标
    w.create_text(100,50,text="Hadley")

    #创建一个按钮,按下时删除所有图形
    Button(root,text="删除全部",command=(lambda x=ALL:w.delete(x))).pack()

    mainloop()

    实例4:绘制椭圆

    from tkinter import *
    root = Tk()
    #创建canvas对象框,设置其宽度、高度与背景色
    w = Canvas(root,width=200,height=100,background="white")
    w.pack()

    #绘制一个虚线的矩形
    w.create_rectangle(40,20,160,80,dash=(4,4))
    #绘制椭圆,粉色填充
    w.create_oval(40,20,160,80,fill="pink")
    #在矩形正中(默认)显示文本,坐标为文本正中坐标
    w.create_text(100,50,text="Hadley")

    mainloop()
    实例5:绘制圆形

    from tkinter import *
    root = Tk()
    #创建canvas对象框,设置其宽度、高度与背景色
    w = Canvas(root,width=200,height=100,background="white")
    w.pack()

    #绘制一个虚线的矩形
    w.create_rectangle(40,20,160,80,dash=(4,4))
    #绘制圆形,粉色填充
    #w.create_oval(40,20,160,80,fill="pink")
    w.create_oval(70,20,130,80,fill="pink")
    #在矩形正中(默认)显示文本,坐标为文本正中坐标
    w.create_text(100,50,text="Hadley")

    mainloop()

    实例6:绘制多边形

    from tkinter import *
    import math as m

    root = Tk()
    w=Canvas(root,width=200,height=150,background="red")
    w.pack()
    center_x = 100
    center_y = 80
    r = 70
    points = [
        #左上角A
        center_x - int(r*m.sin(2*m.pi/5)),
        center_y - int(r*m.cos(2*m.pi/5)),
        #右上角C
        center_x + int(r*m.sin(2*m.pi/5)),
        center_y - int(r*m.cos(2*m.pi/5)),
        #左下角E
        center_x - int(r*m.sin(m.pi/5)),
        center_y + int(r*m.cos(m.pi/5)),
        #顶点D
        center_x,
        center_y - r,
        #右下角B
        center_x + int(r*m.sin(m.pi/5)),
        center_y + int(r*m.cos(m.pi/5)),
        ]
    #创建多边形方法,会自动按ACEDBA的形式连线,如果构成闭环,则会自动填充
    w.create_polygon(points,outline="green",fill="yellow")

    w.create_text(100,80,text="Hadley")

    mainloop()

    实例7:

    from tkinter import *

    root = Tk()
    w=Canvas(root,width=400,height=200,background="white")
    w.pack()

    def paint(event):#画小圆
        x1,y1 = (event.x - 1),(event.y -1)
        x2,y2 = (event.x + 1),(event.y +1)
        w.create_oval(x1,y1,x2,y2,fill="red")

    w.bind("<B1 - Motion>",paint)#画布与鼠标进行绑定
    Label(root,text="按住鼠标左键并移动,开始绘制你的理想蓝图吧。。。").pack(side=BOTTOM)

    mainloop()

    073 GUI的终极选择:Tkinter10

    Munu组件

    Tkinter提供了一个Menu组件,用于实现顶级菜单、下拉菜单和弹出菜单。

    实例1:创建一个顶级菜单(或称窗口主菜单

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()


    menubar = Menu(root)#创建一个顶级菜单
    menubar.add_command(label="Hello",command=callback)#创建一个顶级菜单对象
    menubar.add_command(label="Quit",command=root.quit)

    #显示菜单
    root.config(menu=menubar)

    mainloop()

    实例2:创建添加到主菜单上的下拉菜单

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()

    #创建一个顶级菜单
    menubar = Menu(root)

    #创建下拉菜单filemenu包含内容
    filemenu=Menu(menubar,tearoff=False)#创建一个从属于menubar的子菜单(下拉菜单)filemenu
    filemenu.add_command(label="打开",command=callback)#创建一个下拉菜单对象
    filemenu.add_command(label="保存",command=callback)
    filemenu.add_separator()#插入分隔线
    filemenu.add_command(label="退出",command=root.quit)
    #创建一个顶级菜单对象“文件”,filemenu从属于这个对象(或称将filemenu添加到顶级菜单“文件”中)
    menubar.add_cascade(label="文件",menu=filemenu)

    #创建另一个下拉菜单editmenu包含内容
    editmenu=Menu(menubar,tearoff=False)#创建一个从属于menubar的子菜单(下拉菜单)editmenu
    editmenu.add_command(label="剪切",command=callback)
    editmenu.add_command(label="拷贝",command=callback)
    editmenu.add_separator()#插入分隔线
    editmenu.add_command(label="粘贴",command=callback)
    #创建一个顶级菜单对象“编辑”,editmenu从属于这个对象(或称将editmenu添加到顶级菜单“编辑”中)
    menubar.add_cascade(label="编辑",menu=editmenu)

    #显示菜单
    root.config(menu=menubar)

    mainloop()

    实例3:创建一个弹出菜单方法

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()

    def popup(event):
        menu.post(event.x_root,event.y_root)#在此时鼠标位置弹出显示窗口
        
    #创建一个顶级菜单menu
    menu = Menu(root,tearoff=False)

    #创建顶级菜单menu包含内容
    menu.add_command(label="撤销",command=callback)#创建一个顶级菜单对象
    menu.add_command(label="重做",command=callback)
    #创建一个框架
    frame = Frame(root,width=100,height=100)
    frame.pack()

    #将鼠标右键与popup方法绑定
    frame.bind("<Button-3>",popup)

    #显示菜单
    #root.config(menu=menu)

    mainloop()

    实例4:菜单弹出

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()

    def popup(event):
        menu.post(event.x_root,event.y_root)#在此时鼠标位置弹出显示窗口
        
    #创建一个顶级菜单menu
    menu = Menu(root,tearoff=True)

    #创建顶级菜单menu包含内容
    menu.add_command(label="撤销",command=callback)#创建一个顶级菜单对象
    menu.add_command(label="重做",command=callback)
    #创建一个框架
    frame = Frame(root,width=500,height=500)
    frame.pack()

    #将鼠标右键与popup方法绑定
    frame.bind("<Button-3>",popup)

    #显示菜单
    #root.config(menu=menu)

    mainloop()

    实例5:添加单选组件radiobutton和多选按钮checkbutton

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()

    #创建一个顶级菜单
    menubar = Menu(root)
    #创建checkbutton关联变量
    openVar = IntVar()
    saveVar = IntVar()
    exitVar = IntVar()
    #创建下拉菜单filemenu包含内容
    filemenu=Menu(menubar,tearoff=True)#创建一个从属于menubar的子菜单(下拉菜单)filemenu
    filemenu.add_checkbutton(label="打开",command=callback,variable=openVar)#创建一个下拉菜单对象
    filemenu.add_checkbutton(label="保存",command=callback,variable=saveVar)
    filemenu.add_separator()#插入分隔线
    filemenu.add_checkbutton(label="退出",command=root.quit,variable=exitVar)
    #创建一个顶级菜单对象“文件”,filemenu从属于这个对象(或称将filemenu添加到顶级菜单“文件”中)
    menubar.add_cascade(label="文件",menu=filemenu)

    #创建radiobutton关联变量
    editVar = IntVar()
    editVar.set(1)

    #创建另一个下拉菜单editmenu包含内容
    editmenu=Menu(menubar,tearoff=True)#创建一个从属于menubar的子菜单(下拉菜单)editmenu
    editmenu.add_radiobutton(label="剪切",command=callback,variable=editVar,value=1)
    editmenu.add_radiobutton(label="拷贝",command=callback,variable=editVar,value=2)
    editmenu.add_separator()#插入分隔线
    editmenu.add_radiobutton(label="粘贴",command=callback,variable=editVar,value=3)
    #创建一个顶级菜单对象“编辑”,editmenu从属于这个对象(或称将editmenu添加到顶级菜单“编辑”中)
    menubar.add_cascade(label="编辑",menu=editmenu)

    #显示菜单
    root.config(menu=menubar)

    mainloop()

    Menubutton组件(希望菜单按钮出现在其它位置时)

    Menubutton组件是一个与Menu组件相关联的按钮,它可以放在窗口中的任意位置,并且在被按下时弹出下拉菜单

    实例1:

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()

    #创建一个顶级菜单Menubutton按钮,设置为浮起显示(RAISED)
    mb = Menubutton(root,text="点我",relief=RAISED)

    mb.pack(side=RIGHT)#设置为右中显示

    #创建下拉菜单filemenu包含内容
    filemenu = Menu(mb,tearoff=False)#创建一个从属于mb的下拉菜单filemenu
    filemenu.add_checkbutton(label="打开",command=callback,selectcolor="yellow")
    filemenu.add_command(label="保存",command=callback)#创建一个下拉菜单对象"保存“
    filemenu.add_separator()
    filemenu.add_command(label="退出",command=root.quit)
    #显示菜单
    mb.config(menu=filemenu)

    mainloop()

    OptionMenu(选项菜单)组件

    选项菜单的发明弥补了Listbox组件无法实现下拉列表框的遗憾

    实例1:

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()

    variable = StringVar()#创建字符串变量variable
    variable.set("one")#初始值设置为"one"
    w = OptionMenu(root,variable,"one","two","three")
    w.pack()

    mainloop()

    实例2:多个选项添加到选项菜单中

    from tkinter import *

    def callback():
        print("被调用了")
        
    root = Tk()

    OPTIONS = [
        "Hadley",
        "小土豆",
        "yiwofeiye",
        "RAN"
        ]

    variable = StringVar()#创建字符串变量variable
    variable.set(OPTIONS[0])#初始值设置为"one"
    w = OptionMenu(root,variable,*OPTIONS)
    w.pack()

    def callback():
        print(variable.get())

    Button(root,text="点我",command=callback).pack()

    mainloop()
     

    074  GUI的终极选择:Tkinter11

    事件绑定

    对于每个组件来说,可以通过bind()方法将函数或方法绑定到具体的事件上。当被触发的事件满足该组件绑定的事件时,Tkinter就会带着事件描述去调用handler()方法

    实例1:捕获单击鼠标位置

    from tkinter import*

    root = Tk()

    def callback(event):
        print("点击位置:",event.x,event.y)

    frame = Frame(root,width=200,height=200)
    #Button表示鼠标点击事件
    #1代表左键 2代表中间滚轮点击 3代表右键
    frame.bind("<Button-1>",callback)#按键按下时,调用callback方法
    frame.pack()

    mainloop()

    实例2:捕获键盘事件

    #捕获单击鼠标的位置
    from tkinter import*

    root = Tk()

    def callback(event):
        print("敲击位置:",repr(event.char))#打印当前按下按键的字符
        print(event.char)

    frame = Frame(root,width=200,height=200)
    #Key为键盘事件
    frame.bind("<Key>",callback)#按键按下时,调用callback方法
    frame.focus_set()#获得焦点
    frame.pack()

    mainloop()

    实例3:捕获鼠标在组件上的运动轨迹

    #当鼠标在组件内移动的整个过程均触发该事件

    from tkinter import*

    root = Tk()

    def callback(event):
        print("当前位置:",event.x,event.y)#打印当前按下按键的字符

    frame = Frame(root,width=200,height=200)
    frame.bind("<Motion>",callback)#按键按下时,调用callback方法
    frame.pack()

    mainloop()

    事件序列

    Tkinter使用一种称为事件序列的机制来允许用户定义事件,用户需要使用bind()方法将具体的事件序列与自定义的方法绑定

    Event对象(按键名keysym和按键码keycode)

    实例1:打印当前按下按键的按键名

    from tkinter import*

    root = Tk()

    def callback(event):
        print(event.keysym)#打印当前按下按键的按键名
        print(event.char)

    frame = Frame(root,width=200,height=200)
    #Key为键盘事件
    frame.bind("<Key>",callback)#按键按下时,调用callback方法
    frame.focus_set()#获得焦点
    frame.pack()

    mainloop()

    075 GUI的终极选择:Tkinter12

    Message组件

    Message(消息)组件是Label组件的变体,用于显示多行文本信息。Message组件能够自动换行,并调整文本的尺寸使其适应给定得尺寸。

    实例1:

    from tkinter import *

    root = Tk()
    w1 = Message(root,text="这是一则消息",width=100)
    w1.pack()
    w2 = Message(root,text="这是一条骇人听闻的长消息!",width=100)
    w2.pack()

    mainloop()

    Spinbox组件

    Entry组件的变体,用于从一些固定的值中选取一个。使用Spinbox组件,可以通过返回或者元组指定允许用户输入的内容。

    实例1:

    from tkinter import *

    root = Tk()

    #w = Spinbox(root,from_=0,to=10)#指定输入值为0-10
    w = Spinbox(root,value=("Hadley","小土豆","雅馨"))#指定输入
    w.pack()

    mainloop()

    PanedWindow组件

    与Frame类似,都是为组件提供一个框架,但其还允许让用户调整应用程序的空间划分

    实例1:两窗格

    from tkinter import *

    root = Tk()

    m = PanedWindow(orient = VERTICAL)#设置为上下分布
    m.pack(fill=BOTH,expand=1)#设置为框架覆盖全局

    top = Label(m,text="top pane")#顶窗格
    m.add(top)

    bottom = Label(m,text="bottom pane")#底窗格
    m.add(bottom)

    mainloop()

    实例2:三窗格

    from tkinter import *

    root = Tk()

    m1 = PanedWindow()#默认为左右分布
    m1.pack(fill=BOTH,expand=1)
    left = Label(m1,text="left pane")#左窗格
    m1.add(left)

    m2 = PanedWindow(orient=VERTICAL)
    m1.add(m2)
    top=Label(m2,text="top pane")#顶窗格
    m2.add(top)
    bottom = Label(m2,text="bottom pane")#底窗格
    m2.add(bottom)

    mainloop()

    实例3:显示“分割线”

    from tkinter import *

    root = Tk()

    #showhandle=True表示显示“手柄”
    #sashrelief=SUNKEN表示分隔线的样式设置为向下凹
    m1 = PanedWindow(showhandle=True,sashrelief=SUNKEN)
    m1.pack(fill=BOTH,expand=1)
    left = Label(m1,text="left pane")
    m1.add(left)

    m2 = PanedWindow(orient=VERTICAL,showhandle=True,sashrelief=SUNKEN)
    m1.add(m2)
    top=Label(m2,text="top pane")
    m2.add(top)
    bottom = Label(m2,text="bottom pane")
    m2.add(bottom)

    mainloop()

    Toplevel组件

    Topleve(顶级窗口)l组件类似于Frame组件,但其是一个独立的顶级窗口,通常拥有标题栏、边框等部件。通常用在显示额外的窗口、对话框和其他弹出窗口中。

    实例1:按钮按下创建一个顶级窗口

    from tkinter import *

    def create():
        top = Toplevel()#创建一个独立的顶级窗口
        top.title("FishC Demo")
        msg = Message(top,text="I love FishC.com")
        msg.pack()
        
    root = Tk()
    Button(root,text="创建顶级窗口",command=create).pack()

    mainloop()

    实例2:Toplevel的窗口设置为50%透明

    from tkinter import *

    def create():
        top = Toplevel()
        top.title("FishC Demo")
        top.attributes("-alpha",0.5)#设置为50%透明度
        msg = Message(top,text="I love FishC.com")
        msg.pack()
        
    root = Tk()
    Button(root,text="创建顶级窗口",command=create).pack()

    mainloop()

    076 GUI的终极选择:Tkinter13

    布局管理器

    布局管理器就是管理你的那些组件如何排列的家伙。Tkinter有三个布局管理器,分别是pack、grid和place

    pack:按添加顺序排列组件

    grid:按行/列形式排列组件

    place:允许程序员指定组件的大小和位置

    pack

    实例1:生成一个Listbox组件并将它填充到root窗口

    from tkinter import *

    root = Tk()
    listbox = Listbox(root)
    #fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
    #BOTH表示同时横向和纵向扩展;X表示横向;Y表示纵向
    #expand选项是告诉窗口管理器是否将父组件的额外空间也填满(任意拉伸窗口依旧会填满)

    #默认情况下pack是将添加的组件依次纵向排列
    listbox.pack(fill=BOTH,expand=True)
    for i in range(10):
        listbox.insert(END,str(i))

    mainloop()

    实例2:纵向排列,横向填充

    from tkinter import *

    root = Tk()
    #fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
    #BOTH表示同时横向和纵向扩展;X表示横向;Y表示纵向
    #expand选项是告诉窗口管理器是否将父组件的额外空间也填满

    #默认情况下pack的side属性是将添加的组件依次纵向排列
    Label(root, text="red", bg="red", fg="white").pack(fill=X)
    Label(root, text="green", bg="green", fg="black").pack(fill=X)
    Label(root, text="blue", bg="blue", fg="white").pack(fill=X)

    mainloop()

    实例3:横向排列,纵向填充

    from tkinter import *

    root = Tk()
    #fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
    #BOTH表示同时横向和纵向扩展;X表示横向;Y表示纵向
    #expand选项是告诉窗口管理器是否将父组件的额外空间也填满

    #将pack设置为横向排列
    Label(root, text="red", bg="red", fg="white").pack(side=LEFT)
    Label(root, text="green", bg="green", fg="black").pack(side=LEFT)
    Label(root, text="blue", bg="blue", fg="white").pack(side=LEFT)

    mainloop()

    grid

    使用一个grid就可以简单地实现你用很多个框架和pack搭建起来的效果。使用grid排列组件,只需告诉它你想要将组件放置的位置(行row/列column)。

    实例1:

    from tkinter import *

    root = Tk()

    #column默认值是0
    #默认情况下组件会居中显示在对应的网格里
    #Label(root,text="用户名").grid(row=0)
    #Label(root,text="密码").grid(row=1)
    #设置sticky=W使Label左对齐
    Label(root,text="用户名").grid(row=0,sticky=W)#左对齐
    Label(root,text="密码").grid(row=1,sticky=W)

    Entry(root).grid(row=0,column=1)
    Entry(root,show="*").grid(row=1,column=1)

    mainloop()

    实例2:设置rowspan与columnspan实现跨行和跨列功能

    from tkinter import *

    root = Tk()

    #column默认值是0
    #默认情况下组件会居中显示在对应的网格里
    #Label(root,text="用户名").grid(row=0)
    #Label(root,text="密码").grid(row=1)
    #设置sticky=W使Label左对齐
    #创建Label文本
    Label(root,text="用户名").grid(row=0,sticky=W)
    Label(root,text="密码").grid(row=1,sticky=W)
    #创建输入
    Entry(root).grid(row=0,column=1)
    Entry(root,show="*").grid(row=1,column=1)
    #插入Label图像
    photo = PhotoImage(file="logo.gif")
    #rowspan=2跨两行,边距5
    Label(root,image=photo).grid(row=0,column=2,rowspan=2,padx=5,pady=5)
    #columnspan=3跨三列(默认为居中显示),边距5
    Button(text="提交",width=10).grid(row=2,columnspan=3,pady=5)

    mainloop()

    place

    通常情况下不建议使用place布局管理器

    实例1:将子组件显示在父组件的正中间

    from tkinter import *

    def callback():
        print("正中靶心")
    root = Tk()
    #relx和rely指定的是子组件相对于父组件的位置,范围是(00`1.0),0.5则表示一半,正中间
    #anchor=CENTER表示正中显示
    Button(root,text="点我",command=callback).place(relx=0.5,rely=0.5,anchor=CENTER)

    mainloop()

    实例2:Button组件覆盖Label组件

    from tkinter import *

    def callback():
        print("正中靶心")
    root = Tk()

    photo = PhotoImage(file="logo_big.gif")
    Label(root,image=photo).pack()
    #relx和rely指定的是子组件相对于父组件的位置,范围是(00`1.0),0.5则表示一半,正中间
    Button(root,text="点我",command=callback).place(relx=0.5,rely=0.5,anchor=CENTER)

    mainloop()

    实例3:

    from tkinter import *

    root = Tk()

    #relx和rely指定的是子组件相对于父组件的位置,范围是(00`1.0),0.5则表示一半,正中间
    #relwidth和relheight选项指定相对父组件的尺寸
    Label(root,bg="red").place(relx=0.5,rely=0.5,relheight=0.75,relwidth=0.75,anchor=CENTER)
    Label(root,bg="yellow").place(relx=0.5,rely=0.5,relheight=0.5,relwidth=0.5,anchor=CENTER)
    Label(root,bg="green").place(relx=0.5,rely=0.5,relheight=0.25,relwidth=0.25,anchor=CENTER)

    mainloop()

    077 GUI的终极选择:Tkinter14

    Tkinter提供了三种标准对话框模块,分别是:messagebox、filedialog、colorchooser

    messagebox(消息对话框)

    实例1:askokcancel函数

    from tkinter import *

    print(messagebox.askokcancel("FishC Demo","发射核弹?"))

    mainloop()

    实例2:askquestion函数

    实例3:asiretrycancel函数

    实例4:askyesno函数

    实例5:showerror函数

    from tkinter import *

    #print(messagebox.askokcancel("FishC Demo","发射核弹?"))
    #print(messagebox.askquestion("FishC Demo","买个U盘?"))
    #print(messagebox.askretrycancel("FishC Demo","启动失败,重启?"))
    #print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
    print(messagebox.showerror("FishC Demo","Error!!!"))

    mainloop()

    实例6:showinfo函数

    from tkinter import *

    #options参数可设置为default、icon与parent
    #print(messagebox.askokcancel("FishC Demo","发射核弹?"))
    #print(messagebox.askquestion("FishC Demo","买个U盘?"))
    #print(messagebox.askretrycancel("FishC Demo","启动失败,重启?"))
    #print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
    #print(messagebox.showerror("FishC Demo","Error!!!"))
    messagebox.showinfo("Hadley","Great!!!",icon="info")

    mainloop()

    实例7:showwarning函数

    from tkinter import *

    #options参数可设置为default、icon与parent
    #print(messagebox.askokcancel("FishC Demo","发射核弹?"))
    #print(messagebox.askquestion("FishC Demo","买个U盘?"))
    #print(messagebox.askretrycancel("FishC Demo","启动失败,重启?"))
    #print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
    #print(messagebox.showerror("FishC Demo","Error!!!"))
    #messagebox.showinfo("Hadley","Great!!!",icon="info")
    messagebox.showwarning("Hadley","Warning!!!",icon="warning")

    mainloop()

    filedialog(文本对话框)

    当应用程序需要使用打开文件或保存文件的功能时

    实例1:

    from tkinter import *

    root = Tk()

    def callback():
        #askopenfilename函数用来打开文件
        #asksaveasfilename函数用来保存文件
        fileName = filedialog.askopenfilename()
        print(fileName)

    Button(root,text="打开文件夹",command=callback).pack()

    mainloop()

    实例2:限制打开文件类型

    from tkinter import *

    root = Tk()

    def callback():
        #askopenfilename函数用来打开文件
        #asksaveasfilename函数用来保存文件
        #fileName = filedialog.askopenfilename()
        #限制打开文件类型
        fileName = filedialog.askopenfilename(filetypes=[("PNG",".png"),("GIF",".gif")])
        print(fileName)

    Button(root,text="打开文件夹",command=callback).pack()

    mainloop()

    colorchooser(颜色选择对话框)

    颜色对话框提供一个让用户选择颜色的界面

    实例1:

    from tkinter import *

    root = Tk()

    def callback():
        #colorchooser函数用于打开颜色选择对话框
        fileName = colorchooser.askcolor()
        print(fileName)

    Button(root,text="打开文件夹",command=callback).pack()

    mainloop()

    对应的RGB值及其对应的16进制值

    078 Pygame:初次见面,请大家多多关照

     

    展开全文
  • matlab人脸识别论文

    万次阅读 多人点赞 2019-10-11 17:41:51
    该系统首先利用离散小波变换获取包含人脸图像大部分原始信息的低频分量,对图像数据进行降维;再由PCA算法对人脸图像进行主成分特征提取,进--步降低图像数据的处理量;最后使用经过训练后的BP神经网络对待测人脸进行...

    摘 要

     本文设计了一种基于BP神经网络的人脸识别系统,并对其进行了性能分析。该系统首先利用离散小波变换获取包含人脸图像大部分原始信息的低频分量,对图像数据进行降维;再由PCA算法对人脸图像进行主成分特征提取,进--步降低图像数据的处理量;最后使用经过训练后的BP神经网络对待测人脸进行分类识别。详细介绍了离散小波变换PCA特征提取以及BP神经网络分类设计。通过系统仿真实验与分析发现:人脸特征的提取是该系统的关键;同时,由于人脸灰度信息的统计特征与有监督训练BP神经网络分类器,使该系统只在固定类别,并且光照均匀的人脸识别应用场景中具有较高的识别准确率。因此,很难在复杂环境中应用。
    

    关键词:人脸识别;人工神经网络;离散小波变换; PCA; BP神经网络
    Abstract
    In this paper, a face recognition system based on BP neural network is designed and its performance is analyzed. The system first uses discrete wavelet transform to obtain the low-frequency components which contain most of the original information of the face image, and then uses PCA algorithm to extract the principal component features of the face image, progressively reducing the processing capacity of the image data. Finally, the trained BP neural network is used to classify and recognize the tested face. Discrete wavelet transform PCA feature extraction and BP neural network classification design are introduced in detail. Through the system simulation experiment and analysis, it is found that the extraction of facial features is the key of the system. At the same time, because of the statistical features of gray information and the supervised training of BP neural network classifier, the system only has a high recognition accuracy in fixed categories and uniform illumination of face recognition application scenarios. Therefore, it is difficult to apply in complex environment.

    Key words: face recognition; artificial neural network; discrete wavelet transform; PCA; BP neural network
    1绪论

      人脸识别是模式识别研究的一个热点,它在身份鉴别、信用卡识别,护照的核对及监控系统等方面有着I泛的应用。人脸图像由于受光照、表情以及姿态等因索的影响,使得同一个人的脸像矩阵差异也比较大。因此,进行人脸识别时,所选取的特征必须对上述因素具备-一定的稳定性和不变性。主元分析(PCA)方法是一种有效的特征提取方法,将人脸图像表示成一一个列向量,经过PCA变换后,不仅可以有效地降低其维数,同时又能保留所需要的识别信息,这些信息对光照、表情以及姿态具有一定的不敏感性。 在获得有效的特征向量后,关键问题是设计具有良好分类能力和鲁棒性的分类器、支持向量机(SVI )模式识别方法,兼顾调练误差和泛化能力,在解决小样本、非线性及高维模式识别问题中表现出许多特有的优势。
    

    1.1人脸识别技术的细节

    一般来说,人脸识别系统包括图像提取、人脸定位、图形预处理、以及人脸识别(身份确认或者身份查找)。系统输入一般是一张或者一系列含有未确定身份的人脸图像,以及人脸数据库中的若干已知身份的人脸图像或者相应的编码,而其输出则是一系列相似度得分,表明待识别的人脸的身份。
    1.2人脸识别技术的广泛应用

    一项技术的问世和发展与人类的迫切需求是密切相关的,快速发展的社会经济和科学技术使得人类对安全(包括人身安全、隐私保护等)得认识越来越重视。人脸识别得一个重要应用就是人类的身份识别。一-般来说, 人类得身份识别方式分为三类:
    1.特征物品,包括各种证件和凭证,如身份证、驾驶证、房门钥匙、印章等;
    2.特殊知识,包括各种密码、口令和暗号等;

    3.人类生物特征,包括各种人类得生理和行为特征,如人脸、指纹、手形、掌纹、虹膜. DNA、签名、语音等。前两类识别方式属于传统的身份识别技术,其特点是方便、快捷,但致命的缺点是安全性差、易伪造、易窃取。特殊物品可能会丢失、偷盗和复制,特殊知识可以被遗忘、混淆和泄漏。相比较而言,由于生物特征使人的内在属性,具有很强的自身稳定性和个体差异性,因此生物特征是身份识别的最理想依据。基于以上相对独特的生物特征,结合计算机技术,发展了众多的基于人类生物特征的身份识别技术,如DNA识别技术、指纹识别技术、虹膜识别技术、语音识别技术和人脸识别技术等。生物识别技术在上个世纪已经有了- -定得发展,其中指纹识别技术已经趋近成熟,但人脸识别技术的研究还处于起步阶段。指纹、虹膜、掌纹等识别技术都需要被识别者的配合,有的识别技术还需要添置复杂昂贵的设备。人脸识别可以利用已有的照片或是摄像头远距离捕捉图像,无需特殊的采集设备,系统的成本低。并且自动人脸识别可以在当事人毫无觉察的情况下完成身份确认识别工作,这对反恐怖活动有非常重要的意义。基于人脸识别技术具有如此多的优势,因此它的应用前最非常广阔,已成为最具潜力的生物特征识别技术之一
    1.3人脸识别技术的难点

      虽然人类可以毫不困难地根据人脸来辨别一个人,但是利用计算机进行完全自动的人脸识别仍然有许多困难。人脸模式差异性使得人脸识别成为-个非常困难的问题,表现在以下方面:
    
      1.人脸表情复杂,人脸具有多样的变化能力,人的脸上分布着Ii十多块面部肌肉,这些肌肉的运动导致不同面部表情的出现,会造成人脸特征的显著改变。
    
      2.随着年龄而改变,随着年龄的增长,皱纹的出现和面部肌肉的松驰使得人脸的结构和纹理都将发生改变。
    
      3.人脸有易变化的附加物,例如改变发型,留胡须,戴帽子或眼镜等饰物。4.人脸特征遮掩,人脸全部、部分遮掩将会造成错误识别。
    
      5.人脸图像的畸变,由于光照、视角、摄取角度不同,可能造成图像的灰度。
    

    1.4国内外研究状况

    人脸识别是人类视觉最杰出的能力之-。 它的研究涉及模式识别、图像处理、生物学、心理学、认知科学,与基于其它生物特征的身份鉴别方法以及计算机人机感知交互领域都有密切联系。人脸识别早在六七十年代就引起了研究者的强烈兴趣。20世纪60年代,Bledsoe 提出了人脸识别的半自动系统模式与特征提取方法。70年代,美、英等发达国家开始重视人脸识别的研究工作并取得进展。1972 年,Harmon 用交互人脸识别方法在理论上与实践上进行了详细的论述。同年,Sakai 设计了人脸图像自动识别系统。80年代初
    T. Minami 研究出了优于Sakai的人脸图像自动识别系统。但早期的人脸识别一般都需要人的某些先验知识,无法摆脱人的干预。进入九十年代,由于各方面对人脸识别系统的迫切需求,人臉识别的研究变的非常热门。人脸识别的方法有了重大突破,进入了真正的机器自动识别阶段,如Kartbunen-Loeve变换等或新的神经网络技术。人脸识别研究

    得到了前所未有的重视,国际上发表有关人脸识别等方面的论文数量大幅度增加,仅从1990年到2000年之间,sCl 及EI可检索到的相关文献多达数千篇,这期间关于人脸识别的综述也屡屡可见。国外有许多学校在研究人脸识别技术,研究涉及的领域很广。这些研究受到军方、警方及大公司的高度重视和资助,国内的一些知名院校也开始从事人脸识别的研究。

      人脸识别是当前模式识别领域的一个前沿课题,但目前人脸识别尚处于研究课题阶段,尚不是实用化领域的活跃课题。虽然人类可以毫不困难地由人脸辨别一个人,但利用计算机进行完全自动的人脸识别存在许多困难,其表现在:人脸是非刚体,存在表情变化:人脸随年龄增长面变化:发型、眼镜等装饰对人脸造成遮挡:人脸所成图像受光照、成像角度、成像距离等影响。人脸识别的困难还在于图像包括大量的数据,输入的像素可能成百上千,每个像素都含有各自不同的灰度级,由此带来的计算的复杂度将会增加。现有的识别方法中,通过从人脸图像中提取出特征信息,来对数据库进行检索的方法速度快,而利用拓扑属性图匹配来确定匹配度的方法则相对较快。
    

    1.5人脸识别的研究内容

    人脸识别技术(AFR)就是利用计算机技术,根据数据库的人脸图像,分析提取出有效的识别信息,用来“辨认”身份的技术。人脸识别技术的研究始于六十年代末七十年代初,其研究领城涉及图像处理、计算机视觉、模式识别、计算机智能等领城,是伴随着现代化计算机技术、数据库技术发展起来的综合交叉学科。
    1.5.1人脸识别研究内容

      人脸识别的研究范围广义上来讲大致包括以下hi个方面的内容。
    
      1.人脸定位和检测(Face Detection) :即从动态的场景与复杂的背景中检测出人臉的存在并且确定其位置,最后分离出来。这一任务主要受到光照、噪声、面部倾斜以及各种各样遮挡的影响。
    
      2.人脸表征(Face Representation) (也称人脸特征提取) :即采用某种表示方法来表示检测出人脸与数据库中的已知人脸。通常的表示方法包括几何特征(如欧氏距离、曲率、角度)、代数特征(如矩阵特征向量)、固定特征模板等。
    
      3.人脸识别(Face Recogni tion) :即将待识别的人脸与数据库中已知人脸比较,得出相关信息。这一过程的核心是选择适当的人脸表征方法与匹配策略。
    
      4.表情姿态分析(Expression/Gesture Analysis) :即对待识别人脸的表情或姿态信息进行分析,并对其加以归类。
    
    
      5.生理分类(Physical Classi fication) :即对待识别人脸的生理特征进行分析,得出其年龄、性别等相关信息,或者从几幅相关的图像推导出希望得到的人脸图像,如从父母图像推导出孩子脸部图像和基于年龄增长的人脸图像估算等。
    
      人臉识别的研究内容,从生物特征技术的应用前景来分类,包括以下两个方面:人脸验证与人脸识别。
    
      1.人脸验证((Face Veri ficat ion/Authenticat ion):即是回答“是不是某人?"的问题.它是给定一幅待识别人脸图像,判断它是否是某人的问题,属于一对一的两类模式分类问题,主要用于安全系统的身份验证。
    
      2.人脸识别(Face 。Recognition) :即是回答“是谁”的问题。它是给定-幅待识别人脸图像,再已有的人脸数据库中,判断它的身份的问题。它是个“-对多”的多类模式分类问题,通常所说的人脸识别即指此类问题,这也是本文的主要研究内容。
    

    1.5.2人脸识别系统的组成

      在人脸识别技术发展的几十年中,研究者们提出了多种多样的人脸识别方法,但大部分的人脸识别系统主要由三部分组成:图像预处理、特征提取和人脸的分类识别。一个完整的自动人脸识别系统还包括人脸检测定位和数据库的组织等模块,如图1.1.其中人脸检测和人脸识别是整个自动人脸识别系统中非常重要的两个环节,并且相对独立。下面分别介绍这两个环节。
    

    人脸检测与定位,检测图像中是否由人脸,若有,将其从背景中分割出来,并确定其在图
    像中的位置。在某些可以控制拍摄条件的场合,如警察拍罪犯照片时将人脸限定在标尺内,此时人脸的定位很简单。证件照背景简单,定位比较容易。在另一些情况下,人脸在图像
    中的位置预先是未知的,比如在复杂背景下拍摄的照片,这时人脸的检测与定位将受以下因素的影响: :

      1.人脸在图像中的位置、角度、不固定尺寸以及光照的影响:
    
      2.发型、眼睛、胡须以及人脸的表情变化等,3.图像中的噪声等。
    
      特征提取与人脸识别,特征提取之前一般都要敌几何归一化和灰度归一化的工作。前者指根据人脸定位结果将图像中的人脸变化到同一位置和大小:后者是指对图像进行光照补偿等处理,以克服光照变化的影响,光照补偿能够一定程度的克服光照变化的影响而提高识别率。提取出待识别的人脸特征之后,即进行特征匹配。这个过程是一对多或者一对一的匹配过程,前者是确定输入图像为图象库中的哪一个人(即人脸识别),后者是验证输入图像的人的身份是否属实(人脸验证).  
    

    以上两个环节的独立性很强。在许多特定场合下人脸的检测与定位相对比较容易,因此“特征提取与人脸识别环节”得到了更广泛和深入的研究。近几年随着人们越来越关心各种复杂的情形下的人臉自动识别系统以及多功能感知研究的兴起,人脸检测与定位才作为一个独立的模式识别问题得到了较多的重视。本文主要研究人脸的特征提取与分类识别的问题。

    2基于bp神经网络的人脸识别算法

      虽然人脸识别方法的分类标准可能有所不同,但是8前的研究主要有两个方向,一类是从人脸图像整体(Holistic Approaches)出发,基于图像的总体信息进行分类识别,他重点考虑了模式的整体属性,其中较为著名的方法有:人工神经网络的方法、统计模式的方法等。另一类是基于提取人脸图像的几何特征参数(Feature-Based Approaches), 例如眼、嘴和鼻子的特征,再按照某种距离准则进行分类识别。这种方法非常有效,因为人脸不是刚体,有着复杂的表情,对其严格进行特征匹配会出现困难。面分别介绍- -些常 用的方法,前两种方法属于从图像的整体方面进行研究,后三种方法主要从提取图像的局部特征讲行研究。
    
    
      2.1基于特征脸的方法
    

    特征脸方法(cigenface)是从生元分析方法PCA c Principal ComponentAnalysis 导出的一种人脸分析识别方法,它根据一-组人脸图像构造主元子空间,由于主元具有人脸的形状也称作特征脸。识别时将测试图像投影到主元子空间上得到了-组投影系数,然后和各个已知人的人脸图像进行比较识别,取得了很好的识别效果。在此基础上出现了很多特征脸的改进算法。

      特征脸方法原理简单、易于实现,它把人脸作为一个整体来处理,大大降低了识别复杂度。但是特征脸方法忽视了人脸的个性差异,存在着一定的理论缺陷。研究表明:特征脸方法随光线角度及人脸尺寸的影响,识别率会有所下降。
    

    2.2基于bp神经网络的方法

    一、实验要求采用三层前馈BP神经网络实现标准人脸YALE数据库的识别,编程语言为C系列语言。
    二、BP神经网络的结构和学习算法实验中建议采用如下最简单的三层BP神经网络,输入层为,有n个神经元节点,输出层具有m个神经元,网络输出为,隐含层具有k个神经元,采用BP学习算法训练神经网络。BP神经网络的结构BP网络在本质上是一种输入到输出的映射,它能够学习大量的输入与输出之间的映射关系,而不需要任何输入和输出之间的精确的数学表达式,只要用已知的模式对BP网络加以训练,网络就具有输入输出对之间的映射能力。BP网络执行的是有教师训练,其样本集是由形如(输入向量,期望输出向量)的向量对构成的。在开始训练前,所有的权值和阈值都应该用一些不同的小随机数进行初始化。BP算法主要包括两个阶段:

    2.2.1向前传播阶段

    ①从样本集中取一个样本(Xp,Yp),将Xp输入网络,其中Xp为输入向量,Yp为期望输出向量。
    ②计算相应的实际输出Op。在此阶段,信息从输入层经过逐级的变换,传送到输出层。这个过程也是网络在完成训练后正常运行时执行的过程。在此过程中,网络执行的是下列运算:

    (2) 向后传播阶段
    ①计算实际输出Op与相应的理想输出Yp的差;
    ②按极小化误差的方法调整权矩阵。这两个阶段的工作一般应受到精度要求的控制

    (1)作为网络关于第p个样本的误差测度(误差函数)。

    (2)如前所述,之所以将此阶段称为向后传播阶段,是对应于输入信号的正常传播而言的,也称之为误差传播阶段。为了更清楚地说明本文所使用的BP网络的训练过程,首先假设输入层、中间层和输出层的单元数分别是N、L和M。X=(x0,x1,…,xN-1)是加到网络的输入矢量,H=(h0,h1,…,hL-1)是中间层输出矢量,Y=(y0,y1,…,yM-1)是网络的实际输出矢量,并且用D=(d0,d1,…,dM-1)来表示训练组中各模式的目标输出矢量。输出单元i到隐单元j的权值是Vij,而隐单元j到输出单元k的权值是Wjk。另外用θk和Φj来分别表示输出单元和隐单元的阈值。于是,中间层各单元的输出为:

    (3)而输出层各单元的输出是:

    其中f(*)是激励函数,采用S型函数:

    2.2.2在上述条件下,网络的训练过程如下:

    (1) 选定训练集。由相应的训练策略选择样本图像作为训练集。
    (2) 初始化各权值Vij,Wjk和阈值Φj,θk,将其设置为接近于0的随机值,并初始化精度控制参数ε和学习率α。
    (3) 从训练集中取一个输入向量X加到网络,并给定它的目标输出向量D。
    (4) 利用式(3)计算出一个中间层输出H,再用式(4)计算出网络的实际输出Y。
    (5) 将输出矢量中的元素yk与目标矢量中的元素dk进行比较,计算出M个输出

    误差项:

    对中间层的隐单元也计算出L个误差项:

    (6) 依次计算出各权值和阈值的调整量:

    (8) 当k每经历1至M后,判断指标是否满足精度要求:E≤ε,其中E是总误差函数。

    如果不满足,就返回(3),继续迭代。如果满足,就进入下一步。
    (9) 训练结束,将权值和阈值保存在文件中。这时可以认为各个权值已经达到稳定,分类器形成。再一次进行训练时,直接从文件导出权值和阈值进行训练,不需要进行初始化。

    YALE数据库是由耶鲁大学计算视觉与扼制中心创立,包括15位志愿者,每个人有11张不同姿势、光照和表情的图片,共计165张图片,图片均为80*100像素的BMP格式图像。我们将整个数据库分为两个部分,每个人的前5幅图片作为网络的训练使用,后6副图片作为测试使用。测试样例:

    输入输出:

      神经网络在人脸识别应用中有很长的历史。早期用于人脸识别的神经网络主要是Kohonen自联想映射神经网络,用于人脸的“回忆”。所谓“回忆”是指当输入图像上的人脸受噪声污染严重或部分缺损时,能用Kohonen网络恢复出原来完整的人脸。Intrator 等人用一个无监督/监督混合神经网络进行人脸识别。其输入是原始图像的梯度图像,以此可以去除光照的变化。监督学习目的是寻找类的特征,有监督学习的目的是减少训练样本被错分的比例。这种网络提取的特征明显,识别率高,如果用几个网络同时运算,求其平均,识别效果还会提高。
    
      与其他类型的方法相比,神经网络方法在人脸识别上有其独到的优势,它避免了复:杂的特征提取工作,可以通过学习的过程获得其他方法难以实现的关于人脸识别的规律和规则的隐性表达。此外,神经网络以时示方式处理信息,如果能用硬件实现,就能显著提高速度。神经网络方法除了用于人脸识别外,还适用于性别识别、种族识别等。
    

    2.3弹性图匹配法

    弹性图匹配方法是-种基于动态链接结构DLA C Dynamic Link Architecture的方法。它将人脸用格状的稀疏图表示,图中的节点用图像位置的Gabor小波分解得到的特征向量标记,图的边用连接节点的距离向量标记。匹配时,首先J找与输入图像最相似的模型图,再对图中的每个节点位置进行最佳匹配,这样产生-一个变形图,其节点逼近模型图的对应点的位置。弹性图匹配方法对光照、位移、旋转及尺度变化都敏感。此方法的主要缺点是对每个存储的人臉需计算其模型图,计算量大,存储量大。为此,Wiskott 在原有方法的基础上提出聚東图匹配,部分克服了这些缺点。在聚束图中,所有节点都已经定位在相应目标上。对于大量数据库,这样可以大大减少识别时间。另外,利用聚束图还能够匹配小同人的最相似特征,因此可以获得关于未知人的性别、胡须和眼镜等相关信息。
    2.4基于模板匹配的方法
    模板匹配法是一-种经典的模式识别方法,这种方法大多是用归一一化和互相关,直接计算两副图像之间的匹配程度。由于这种方法要求两副图像上的目标要有相同的尺度、取向和光照条件,所以预处理要做尺度归一化和灰度归一化的工作。最简单的人脸模板是将人脸看成-一个椭圆,检测人臉也就是检测图像中的椭圆。另一种方法是将人脸用一-组独立的小模板表示,如眼睛模板、嘴巴模板、鼻子模板、眉毛模板和下巴模板等。但这些模板的获得必须利用各个特征的轮廓,而传统的基于边缘提取的方法很难获得较高的连续边缘。即使获得了可靠度高的边缘,也很难从中自动提取所需的特征量。模板匹配方法在尺度、光照、旋转角度等各种条件稳定的状态下,它的识别的效果优于其它方法,但它对光照、旋转和表情变化比较敏感,影响了它的直接使用。2.5基于人脸特征的方法人脸由眼睛、鼻子、嘴巴、下巴等部件构成,正因为这些部件的形状、大小和结构上的各种差异才使得世界上每个人脸千差万别,因此对这些部件的形状和结构关系的几何描述,可以作为人脸识别的重要特征。几何特征最早是用于人脸检测轮廓的描述与识别,首先根据检测轮廓曲线确定若干显著点,并由这些显著点导出- -组用于识别的特征度量如距离、角度等。采用儿何特征进行正面人脸识别一般是通过提取人眼、口、鼻等重要特征点的位置和眼睛等重要器官的几何形状作为分类特征。
    定位眼睛往往是提取人脸几何特征的第-步。由于眼睛的对称性以及眼珠呈现为低灰度值的圆形,因此在人脸图像清晰瑞正的时候,眼睛的提取是比较容易的。但是如果人脸图像模糊,或者噪声很多,则往往需要利用更多的信息(如眼睛和眉毛、鼻子的相对位置等),而且.这将使得眼睛的定位变得很复杂。而且实际图像中,部件未必轮廓分明,有时人用眼看也只是个大概,计算机提取就更成问题,因而导致描述同-一个人的不同人脸时,其模型参数可能相差很大,面失去识别意义。尽管如此,在正确提取部件以及表情变化微小的前提下,该方法依然奏效,因此在许多方面仍可应用,如对标准身份证照片的应用。

    2.5九个人脸库介绍

    1. FERET人脸数据库
      http://www.nist.gov/itl/iad/ig/colorferet.cfm
      由FERET项目创建,此图像集包含大量的人脸图像,并且每幅图中均只有一个人脸。该集中,同一个人的照片有不同表情、光照、姿态和年龄的变化。包含1万多张多姿态和光照的人脸图像,是人脸识别领域应用最广泛的人脸数据库之一。其中的多数人是西方人,每个人所包含的人脸图像的变化比较单一。

    2. CMU Multi-PIE人脸数据库
      http://www.flintbox.com/public/project/4742/
      由美国卡耐基梅隆大学建立。所谓“PIE”就是姿态(Pose),光照(Illumination)和表情(Expression)的缩写。CMU Multi-PIE人脸数据库是在CMU-PIE人脸数据库的基础上发展起来的。包含337位志愿者的75000多张多姿态,光照和表情的面部图像。其中的姿态和光照变化图像也是在严格控制的条件下采集的,目前已经逐渐成为人脸识别领域的一个重要的测试集合。

    3. YALE人脸数据库(美国,耶鲁大学)
      http://cvc.cs.yale.edu/cvc/projects/yalefaces/yalefaces.html
      由耶鲁大学计算视觉与控制中心创建,包含15位志愿者的165张图片,包含光照、表情和姿态的变化。
      Yale人脸数据库中一个采集志愿者的10张样本,相比较ORL人脸数据库Yale库中每个对象采集的样本包含更明显的光照、表情和姿态以及遮挡变化。

    4. YALE人脸数据库B
      https://computervisiononline.com/dataset/1105138686
      包含了10个人的5850幅在9种姿态,64种光照条件下的图像。其中的姿态和光照变化的图像都是在严格控制的条件下采集的,主要用于光照和姿态问题的建模与分析。由于采集人数较少,该数据库的进一步应用受到了比较大的限制。

    5. MIT人脸数据库
      由麻省理工大学媒体实验室创建,包含16位志愿者的2592张不同姿态(每人27张照片),光照和大小的面部图像。

    6. ORL人脸数据库
      https://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html
      由英国剑桥大学AT&T实验室创建,包含40人共400张面部图像,部分志愿者的图像包括了姿态,表情和面部饰物的变化。该人脸库在人脸识别研究的早期经常被人们采用,但由于变化模式较少,多数系统的识别率均可以达到90%以上,因此进一步利用的价值已经不大。
      ORL人脸数据库中一个采集对象的全部样本库中每个采集对象包含10幅经过归一化处理的灰度图像,图像尺寸均为92×112,图像背景为黑色。其中采集对象的面部表情和细节均有变化,例如笑与不笑、眼睛睁着或闭着以及戴或不戴眼镜等,不同人脸样本的姿态也有变化,其深度旋转和平面旋转可达20度。

    7. BioID人脸数据库
      https://www.bioid.com/facedb/
      包含在各种光照和复杂背景下的1521张灰度面部图像,眼睛位置已经被手工标注。

    8. UMIST图像集
      由英国曼彻斯特大学建立。包括20个人共564幅图像,每个人具有不同角度、不同姿态的多幅图像。

    9. 年龄识别数据集IMDB-WIKI
      https://data.vision.ee.ethz.ch/cvl/rrothe/imdb-wiki/
      包含524230张从IMDB和Wikipedia爬取的名人数据图片。应用了一个新颖的化回归为分类的年龄算法。本质就是在0-100之间的101类分类后,对于得到的分数和0-100相乘,并将最终结果求和,得到最终识别的年龄

    3matlab分析人脸方法介绍
    人脸识别之一:查找图片中的人脸并用方框圈出
    这种类似于智能手机拍照时,屏幕里那个框任务头部的红框。大致步骤为:获取RGB图片—>转换为灰度图像—>图像处理—>人脸识别。代码如下:clear all
    clc

    %获取原始图片
    i=imread(‘face.jpg’);
    I=rgb2gray(i);
    BW=im2bw(I); %利用阈值值变换法将灰度图像转换成二进制图像
    figure(1);
    imshow(BW);
    %最小化背景
    [n1 n2]=size(BW);
    r=floor(n1/10);
    c=floor(n2/10);
    x1=1;x2=r;
    s=r*c;

    for i=1:10
    y1=1;y2=c;
    for j=1:10
    if(y2<=c || y2>=9c) || (x11 || x2r10)
    loc=find(BW(x1:x2,y1:y2)==0);
    [o p]=size(loc);
    pr=o*100/s;
    if pr<=100
    BW(x1:x2,y1:y2)=0;
    r1=x1;r2=x2;s1=y1;s2=y2;
    pr1=0;
    end
    imshow(BW);
    end
    y1=y1+c;
    y2=y2+c;
    end
    x1=x1+r;
    x2=x2+c;
    end
    figure(2)
    subplot(1,2,1);
    imshow(BW)
    title(‘图像处理’);
    %人脸识别
    L=bwlabel(BW,8);
    BB=regionprops(L,‘BoundingBox’);
    BB1=struct2cell(BB);
    BB2=cell2mat(BB1);

    [s1 s2]=size(BB2);
    mx=0;
    for k=3:4:s2-1
    p=BB2(1,k)*BB2(1,k+1);
    if p>mx && (BB2(1,k)/BB2(1,k+1))<1.8
    mx=p;
    j=k;
    end
    end
    subplot(1,2,2);
    title(‘人脸识别’);
    imshow(I);
    hold on;
    rectangle(‘Position’,[BB2(1,j-2),BB2(1,j-1),BB2(1,j),BB2(1,j)],‘EdgeColor’,‘r’)实验效果图:

             从实验效果图中,可以看出红框框出了人脸部分。
    

    人脸识别之二:由输入的人像识别出数据库中人像
    这种情况类似于手机人脸解锁,通过当前的人脸去和保存的人脸做比对来实现解锁等功能;从网上看了好多资料,由于个人能力有限大多都没仿真出来,最后通过学习PCA算法,了解到可通过PCA算法对输入矩阵降维,提取特征值和特征向量的方式来做人脸比对。具体的PCA的东西在这里不作介绍,主要介绍一下如何实现人脸比对。
    大致步骤:制作人脸数据样本—>PCA提取样本数据特征值—>人脸比对1.人脸样本
    从网上搜集了10张人脸图片,来制作成样本。

                         %读取转换10张图片,生成数据矩阵function ImgData = imgdata()  
    

    %导入图片
    picture1 = rgb2gray(imread(‘1.jpg’));
    picture2 = rgb2gray(imread(‘2.jpg’));
    picture3 = rgb2gray(imread(‘3.jpg’));
    picture4 = rgb2gray(imread(‘4.jpg’));
    picture5 = rgb2gray(imread(‘5.jpg’));
    picture6 = rgb2gray(imread(‘6.jpg’));
    picture7 = rgb2gray(imread(‘7.jpg’));
    picture8 = rgb2gray(imread(‘8.jpg’));
    picture9 = rgb2gray(imread(‘9.jpg’));
    picture10 = rgb2gray(imread(‘10.jpg’));
    [m,n] = size(picture1);
    picture_ten = {picture1,picture2,picture3,picture4,picture5,picture6,picture7,picture8,picture9,picture10};
    for i=1:10
    %把mn的矩阵变换成1(mn)的矩阵
    ImgData(i,:) = reshape(picture_ten{i},1,m
    n);
    end
    %数据范围缩小到0到1之间
    ImgData = double(ImgData)/255;

    PCA分析function Cell_ten = PCA(imgdata,k)
    [m,n] = size(imgdata);
    img_mean = mean(imgdata); %计算每列平均值
    img_mean_ten = repmat(img_mean,m,1); %复制m行平均值至矩阵img_mean_ten
    Z = imgdata - img_mean_ten;
    T = Z’Z;%协方差矩阵
    [V,D] = eigs(T,k); %计算T中最大的前k个特征值与特征向量
    img_new = imgdata
    V*D; %低维度下的各个人脸的数据
    Cell_ten = {img_new,V,D};3.通过输入测试人脸从数据库中找到相对应人脸function face= facefind(Cell_ten,testdata)%此函数代码借鉴于他人,还未征求其同意,这里就暂时略过这里testdata是测试图片的数据4.主程序调用img=imgdata(); %图片矩阵数据
    Cell_ten=PCA(img,2);% PCA
    face1=facefind(Cell_ten,imread(‘test.jpg’));%识别
    subplot(1,2,1)
    imshow(‘test.jpg’)
    title(‘测试图像’)
    subplot(1,2,2)
    imshow(strcat(num2str(face1),’.jpg’))
    title(‘数据库图像’)测试效果: 使用这个方式可以实现简单的人脸识别,但精确度不高;

    4 分析算法
    在人脸识别系统中有许多关键环节,其中最重要的莫过于特征提取。利用主成分分析法(PCA)进行特征提取是目前应用最多的提取方法。作为一种科学的统计方法,它在模式识别、信号处理、数字图像处理等等领域都有广泛涉猎。基于PCA中空间原始数据主要特征提取,减少数据冗余的思想,一些在低维特征空间的数据被处理,并合理保留了原始数据中有用的信息,数据空间中维数过高的问题也得以解决。
    4.1  主成分分析的基本原理

    实际上主成分分析就是一种数学降维演算方法,用若干个综合变量来代替原本更多的变量,让这些综合变量尽可能的实现对原有变量信息的取代,并保持彼此之间不存在关联。这种多变量化为少数相互无关的变量且信息量不变的统计分析方法就叫做主成分分析法。
      假设F1表示原变量的首个线性组合所组成的主要成分指标,就有F1=a11X1+a21X2+…ap1Xp。根据这个数学式可知,如果在每一个主成分中提取一个信息量,即可用方差(F1)进行度量,随着方差F1的增大,F1所包含的信息也就越多,同时它的线性组合选取也可表示为X1、X2…XP,它们都被称为方差F1中的第一主成分。如果第一主成分不足以代表原有的P个变量信息时,就可以考虑选取F2,即第二个线性组合,借由它来反映原本的有效信息。在F2中可以不显示第一主成分中已有的信息,以数学语言来表达要求的话即Cov(F1,F2)=0,其中F2为第二主成分。所以按照实际原变量的变化需求,就可以构造出多个主成分指标。
      4.2人脸识别的技术特点

    人脸识别是模式识别中的重要分支,它是指通过计算机系统来分析人脸图像,从中获取有价值的识别信息,从而辨识身份。所以说从技术特点上来看,人脸识别具有以下几个关键特色。
     1、PCA算法
    算法大致步骤:
    设有m条n维数据。
    1)将原始数据按列组成n行m列矩阵X;
    2)将X的每一行(这里是图片也就是一张图片变换到一行)进行零均值化,即减去这一行的均值(样本中心化和标准化);将所有的样本融合到一个矩阵里面特征向量就是变换空间的基向量U=[u1,u2,u3,u4,…],脑袋里面要想到一个样本投影变换就是该空间的一个点,然后对于许多点可以用KNN等不同的方法进行分类。
    3)求出协方差矩阵C=1mXXTC=1mXXT C=\frac {1 }{m } XX^TC=m1XXT;
    4)求出协方差矩阵的特征值及对应的特征向量;
    5)将特征向量按对应特征值大小从上到下按行排列成矩阵,取前k行组成矩阵P;
    6)Y=PXY=PX Y=PXY=PX即为降维到kk kk维后的数据。
      对数据进行中心化预处理,这样做的目的是要增加基向量的正交性,便于高维度向低纬度的投影,即便于更好的描述数据。
      对数据标准化的目的是消除特征之间的差异性,当原始数据不同维度上的特征的尺度不一致时,需要标准化步骤对数据进行预处理,使得在训练神经网络的过程中,能够加速权重参数的收敛。
      过中心化和标准化,最后得到均值为0,标准差为1的服从标准正态分布的数据。
      求协方差矩阵的目的是为了计算各维度之间的相关性,而协方差矩阵的特征值大小就反映了变换后在特征向量方向上变换的幅度,幅度越大,说明这个方向上的元素差异也越大(越有投影的必要,矩阵相乘的过程就是投影),故而选取合适的前k个能以及小的损失来大量的减少元数据的维度。

    2、PCA原理推导
    基于K-L展开的PCA特征提取:

    5.算法优化方法
    我用了三种方法对其进行优化
    1.采用动量梯度下降算法训练 BP 网络。
    训练样本定义如下:
    输入矢量为
    p =[-1 -2 3 1
    -1 1 5 -3]
    目标矢量为 t = [-1 -1 1 1]
    2. 采用贝叶斯正则化算法提高 BP 网络的推广能力。在本例中,我们采用两种训练方法,即 L-M 优化算法(trainlm)和贝叶斯正则化算法(trainbr),用以训练 BP 网络,使其能够拟合某一附加有白噪声的正弦样本数据。其中,样本数据可以采用如下MATLAB 语句生成:
    输入矢量:P = [-1:0.05:1];
    目标矢量:randn(’seed’,78341223);
    T = sin(2piP)+0.1randn(size§);
    3. 采用“提前停止”方法提高 BP 网络的推广能力。对于和例 2相同的问题,在本例中我们将采用训练函数 traingdx 和“提前停止”相结合的方法来训练 BP 网络,以提高 BP 网络的推广能力。在利用“提前停止”方法时,首先应分别定义训练样本、验证样本或测试样本,其中,验证样本是必不可少的。在本例中,我们只定义并使用验证样本,即有
    验证样本输入矢量:val.P = [-0.975:.05:0.975]
    验证样本目标矢量:val.T = sin(2
    pival.P)+0.1randn(size(val.P))
    值得注意的是,尽管“提前停止”方法可以和任何一种 BP 网络训练函数一起使用,但是不适合同训练速度过快的算法联合使用,比如 trainlm 函数,所以本例中我们采用训练速度相对较慢的变学习速率算法 traingdx 函数作为训练函数。
    参考文献

    [1] HongZiquan.AlgbricFeatureExcaciofmftfoReonino[JPatteo Recognition. 1991. 22 (1) :43~44.
    [2] Yuille A L Detcction Templates for Face Recognitio[JCognitive Neuroscience , 1991. 191-200
    [3]卢春雨张长水局城区城特征的快速人脸检测法[D北京:清华大学学报.1999.96 (1) ;4-6.
    [4]陈刚,减飞虎实用人脸识别系统的本征脸法实现[D]2001年5月230():45-46.
    [
    5]杜平,徐大为,刘重庆,基F整体特征的人脸识别方法的研究[12003年6月49 (3) ;382-383.
    [6] Chow G, Li X. Towards A System for Automatic Facial Feature Detctio[U] 1993. 2903)2-3.
    [7]杨变若,王煎法,杨未来人脸全局特iE识别研究[Z]1997年11月3(5):; 871-875.
    [8]边肇棋,张学工阎平凡等模式识别D]北京:清华大学出版社2000 302)16-17.

    致 谢

      从毕业设计的选题到论文的指导到最后定稿,期间遇到了无数的困难和阻碍,也曾想过对自己降低要求,也曾想过放弃最初想要坚持的设计,但是最后在孙老师和同学的鼓励和陪伴下,努力克服了所有的困难,独立完成了毕业设计和论文的书写。尤其是要感射我的论文指导老师孙老师,不厌其烦的对我的设计进行指导修改,耐心的帮助我改进设计帮助我搜集相关的资料,感谢孙老师如母亲--般的关怀,在孙老师身上不仅学习到了对学术严谨的态度,更被孙老师亲切无私的个人魅力所感染。
    
      还要感谢我的同学和其他所有的老师,他们严谨的学术态度,宽容待人严于律己的处世风范都使我受益良多。
    
    展开全文
  • 建模方法(四)-因子分析定义和应用

    万次阅读 多人点赞 2018-08-20 20:58:05
    因子分析(factor analysis)也是...原始的变量是可观测的显在变量,而 因子一般是不可观测的潜在变量。 例如:商店的环境、商店 的服务和商品的价格作为因子,这三个方面除了价格外,商店的环境 和服务质量,都是客观...

    因子分析(factor analysis)也是一种降维、简化数据的技术。 它通过研究众多变量之间的内部依赖关系,使用少数几个“抽象”的变量来表示其基本的 数据结构。这几个抽象的变量被称作“因子”,能反映原来 众多变量的主要信息。原始的变量是可观测的显在变量,而 因子一般是不可观测的潜在变量。 例如:商店的环境、商店 的服务和商品的价格作为因子,这三个方面除了价格外,商店的环境 和服务质量,都是客观存在的、抽象的影响因素,都不便于 直接测量,只能通过其它具体指标进行间接反映。因子分析 就是一种通过显在变量测评潜在变量,通过具体指标测评抽 象因子的统计分析方法。

    因子分析类型分为R型因子分析和Q型因子分析。就像聚类分析分为R型和Q型一样,R型的因子分析是对变量作因子分析, Q型因子分析是对样品作因子分析。

    下面我们以R型为例,介绍因子分析。

    R型因子分析的模型如下所示:

    R因子分析中的公共因子是不可直接观测但又客观存在的共 同影响因素,每一个变量都可以表示成公共因子的线性函数 与特殊因子之和,即 

    式中的F1 ,F2,...Fm称为公共因子,εi称为 Xi的特殊因子,Xi为可测变量。

    模型的矩阵形式如下:

    (7.2)

    以上式子满足:

    (1)式很好理解,因为我们目的是降维所以因子的数量一般都小于变量数量,不然没有任何意义。

    (2)式需要概率论基础,Cov表示协方差,相关系数的分子为协方差,而相关系数描述变量间的线性相关性,如果相关系数为0,表示变量线性无关,因为特殊因子如果与公共因子有线性关系,则特殊因子可以合并到公共因子里面。

    (3)与(2)类似,从这里可以看出为什么要用因子分析,各个变量相互相关,因子分析就是找出互不相关因子,揭示这些变量数据背后的结构,找出各个变量表达的主要信息。

    (4)可以这样理解因为ε是变量的特殊因子,所以只与变量有关。

    如果想要理解上诉的公式,可以参考概率论相关章节,如果只想知道如何应用因子分析,不知道概率论公式不影响。

    模型中的aij称为因子“载荷”,是第i个变量在第j个因子上 的负荷,因此矩阵 A 称为因子载荷矩阵。注意因子载荷矩阵A不是唯一的,在实际的应用中常常利 用这一点,通过因子的变换,使得新的因子有更好的实际意 义。 实 际上因子载荷矩阵存在明显的统计意义。

    aij是 变量Xi和因子Fj的相关系数(需要标准化Xi和Fj得出),它一方面表示Xi对Fj的依赖程度,绝对值 越大,密切程度越高;另一方面也反映了变量Xi对公共因子Fj 的相对重要性。

    下面介绍变量的共同度。

    设因子载荷矩阵为A,称第i行元素的平方和,即 

    为变量Xi的共同度。 
     由因子模型,知 

    对Xi做标准化处理后,得:

    (7.8)式说明变量Xi的方差由两部分组成: 第一部分为变量Xi的共同度,它描述了全部公共因子对变量Xi 的总方差所作的贡献,反映了公共因子对变量Xi的影响 程度。第二部分为特殊因子εi 对变量Xi的方差的贡献, 通常称为个性方差。

    上面是对载荷矩阵A的一行的计算,下面对列计算,即公因子Fj对全部变量的贡献。

    设因子载荷矩阵为A,称第j列元素的平方和,即 

    为公共因子Fj对所有变量的贡献,即上述结果表示同一公共因子Fj对 各变量所提供的方差贡献之总和,它是衡量每一个公共因子 相对重要性的一个尺度。他对于选择公因子的数量有很大的作用。

     

    求解因子载荷矩阵方法有主成分分析法、主因子法、大似然估计法,下面介绍主成分分析法:

    因为因子数<变量数,所以m+1~p是没有任何意义的,即图中红色标记,分解中将红色部分作为特殊因子的方差忽略。在式(7.5)中因随机向量X的协方差矩阵在X标准化以后就是相关矩阵,有如下式子

     

    上述绿色部分的p*m矩阵就是因子载荷矩阵A。

    因子旋转用于给各个公因子取一个描述性名字,像之前提到的使用商店的环境、商店 的服务和商品的价格作为描述商品的因子。因为我们得到的载荷矩阵中的因子的系数载荷在各个变量上的值很难看出差异,也就很难看出因子对于哪些变量很重要,也就难以得出因子的含义。而因子旋转使同一列上的载荷尽可能地向靠近 1和靠近0两极分离。这时就突出了每个公共因子和其载荷较 大的那些变量的联系,矛盾的主要方面显现出来了,该公共 因子的含义也就能通过这些载荷较大变量做出合理的说明, 这样也显示了该公共因子的主要性质。 它的原理这里就不给出了,matlab中仅需一行代码就可以得到因子旋转的结果。

    matlab命令:rotatefactors(A, 'method', 'varimax')

    给出一个例子:

    按上述求解因子载荷矩阵的方法确定矩阵,如下

    因子载荷矩阵可以看出,除第一因子中所有的变量在公共因子 上有较大的正载荷,可以称为一般运动因子。其他的3个因子不太 容易解释。似乎是跑和投掷的能力对比,似乎是长跑耐力和短跑速 度的对比。于是考虑旋转因子,得下表 

    因子得分:根据变量X反过来推出因子的值,因为X的值可观测,最后就得出以因子为指标的结果,可以对结果进行聚类分析等,下面给一个因子分析的完整例子。

    因子分析法在环境质量评价中的应用实例
            环境作为人类赖以生存的基础对经济社会的发展起 着巨大的作用。基于国家统计局统计数据库2008年的数 据,采用因子分析法对中国31个省市的环境质量进行了排 序。        分析结果显示,环保建设和环境污染在环境质量评价 中起主要作用,地区在注重保护基础环境的同时更要加强 对环境的补偿。

    1 环境质量评价指标体系构建
    依据国家统计局统计数据库2008年统计数据,选取 14项具体指标,作为中国区域环境质量评价指标体系。 这些指标分别为:        X1(生活污水排放量)、X2(废水治理设施数)、X3(工 业废气排放量)、X4(工业烟尘排放量)、X5(工业粉尘排 放量)、X6(生活烟尘排放量)、X7(工业废气治理设施数)、 X8(工业固体废弃物排放量)、X9(林业用地面积)、X10(森 林覆盖率)、X11(林业重点工程造林面积)、X12(森林病虫 鼠害防治率)、X13(工业污染治理项目本年投资完成额)、 X14(林业系统营林固定资产投资完成额)。

    2 因子分析
        因子分析首先将原始数据标准化处理,建立相关系数矩 阵并计算其特征值和特征向量,接着从中选择特征值大于等 于1的特征值个数为公共因子数,或者根据因子对X的累计贡献 率大于80%来确定公共因子,求得因子载荷矩阵, 后计算公因子得分和综合得分。

    这里注意相关系数矩阵为非单位阵,故可实施因子分析,因为因子分析的前提是变量Xi之间存在内部关系,这样才能分解为各因子。

    由于初始因子载荷阵结构不够简明,各因子的含义不突出。为此采用方差大正 交旋转变化,使各变量在某个因子上产生较高载荷,而在其余因子上载荷较小, 得到旋转后因子载荷矩阵,如表3所示。

    (注:F的表达式里面的-是+,图片有误)

     

     

    总结:

    因子分析通常包括以下五个步骤:

    1.选择分析的变量     用定性分析和定量分析的方法选择变量,因子分析的前提条件 是观测变量间有较强的相关性,因为如果变量之间无相关性或相 关性较小的话,他们不会有共享因子,所以原始变量间应该有较强 的相关性。

    2.计算所选原始变量的相关系数矩阵   相关系数矩阵描述了原始变量之间的相关关系。可以帮助判 断原始变量之间是否存在相关关系,这对因子分析是非常重要 的,因为如果所选变量之间无关系,做因子分析是不恰当的 并且相关系数矩阵是估计因子结构的基础。 

    3.提取公共因子     这一步要确定因子求解的方法和因子的个数,根据相关系数矩阵(协方差矩阵的标准化)来做。需要根据研 究者的设计方案或有关的经验或知识事先确定。因子个数的 确定可以根据因子方差的大小。只取方差大于1(或特征值大 于1)的那些因子,因为方差小于1的因子其贡献可能很小;按 照因子的累计方差贡献率来确定,一般认为要达到70%才能 符合要求; 

    4.因子旋转     通过坐标变换使每个原始变量在尽可能少的因子之间有密 切的关系,这样因子解的实际意义更容易解释,并为每个潜在 因子赋予有实际意义的名字。

     5.计算因子得分    求出各样本的因子得分,有了因子得分值,则可以在许多 分析中使用这些因子,例如以因子的得分做聚类分析的变量, 做回归分析中的回归因子。 在数学建模中可以直接使用因子得分公式。

    ==打赏博主==

    展开全文
  • 基于MATLAB的语音信号处理

    万次阅读 多人点赞 2018-07-15 01:21:20
    显然采样率越高,计算机提取的图片越多,对于原始音频的还原也越加精确。 1.2 实现平台MATLAB 7.0介绍 1.2.1 MatLab 软件基本介绍  MATLAB 产生于 1982 年,是一种效率高、功能强的数值计算和可视化计算机高级语言...

    基于MATLAB的语音信号处理


    摘要:语音信号处理是目前发展最为迅速的信息科学研究领域中的一个,是目前极为活跃和热门的研究领域,其研究成果具有重要的学术及应用价值。语音信号处理的研究,对于机器语言、语音识别、语音合成等领域都具有很大的意义。MATLAB软件以其强大的运算能力可以很好的完成对语音信号的处理。通过MATLAB可以对数字化的语音信号进行时频域分析,方便地展现语音信号的时域及频域曲线,并且根据语音的特性对语音进行分析。本文主要研究了基于MATLAB软件对语音信号进行的一系列特性分析及处理,帮助我们更好地发展语音编码、语音识别、语音合成等技术。本文通过应用MATLAB对语音信号进行处理仿真,包括短时能量分析、短时自相关分析等特性分析,以及语音合成等。

    关键词:语音信号;MATLAB;特性分析;语音合成

    引言

            人类交换信息最方便的、最快捷的一种方式是语言。在高度发达的信息社会中,用数字化的方法进行语音的识别、合成、增强、传送和储存等是整个数字化通信网中最重要、最基本的组成部分之一。数字电话通信、高音质的窄带语音通信系统、智能机器人、声控打字机、语言学习机、自动翻译机等,都要用到语音信号处理技术,随着现在集成电路和微电子技术的飞速发展,语音信号处理系统逐步走向实用化[1]

            语音信号处理是一个新兴的交叉学科,是语音和数字信号处理两个学科的结合产物。与认知科学、心理学、语言学、计算机科学、模式识别和人工智能学科有着密切的联系。语音信号处理技术的发展依赖于这些学科的发展,语音信号处理技术的进步也将促进这些领域的进展。语音信号处理目的是得到一些语音特征参数,以便高效的传输或存储,或通过某种处理以达到特定目的,如语音合成,辨识出讲话者、识别出讲话的内容等。随着现代科学技术和计算机技术的发展,除了人与人的自然语言的沟通,人机对话和智能机领域也开始使用语言。这些人造的语言拥有词汇,语法,语法结构和语义内容等。

            语音信号处理的研究可以追溯到1876年贝尔电话的发明,其在真正意义上首次用声电,电声转换技术实现了远距离语音传输。 1939Homer Dudley提出并研制成功第一个声码器,奠定了语音产生模型的基础,其在语音信号处理领域具有划时代的意义。在20世纪40年代,一种语言声学的专用仪器语谱图仪问世。它可以让你把语音的时变频谱用语图表示出来,得到一个“可见的语言 1984年哈斯金斯实验室研制成功语音回放机,此仪器可以自动转换手工绘制的语谱图成为语言,并进行语音合成。随着计算机的出现,语音分析技术可以在计算机上进行。此时语音信号处理无论是在基础研究或在技术应用,都已取得了突破性进展。现在语音信号可分为三个主要分支,即语音编码,语音识别和语音合成技术[10]

            语音编码技术。语音编码的目的就是在保证一定语音质量的前提下,尽可能降低编码比特率来节省频率资源。语音编码技术的研究开始于1939年, Homer Dudley提出并实现了在低带宽电话电报上传输语音信号的通道声码器,第一个研制成功了语音编码技术。到20世纪70年代,国际电联于1972年发布了64kbit/s脉冲编码调制(PCM)语音编码算法的G.711建议,它被广泛应用于数字交换机、数字通信等领域,从而占据统治地位。在199511ITU-T SG15全会上共轭代数码激励线性预测(CS-ACELP)的8kbit/s语音编码G.729建议被通过,并于19966ITU-T SG15会议上通过G.729附件A:减少复杂度的8kbit/s CS-ACELP语音编解码器,正式成为国际标准[1]

            语音识别技术。语音识别的研究开始于20世纪50年代贝尔实验室的Audry系统,它是第一个可以识别10个英文数字的语音识别系统, 1959FryDenes等人采用频谱分析和模式匹配来进行识别决策构建音素识别器来辨别9个辅音和4个元音。20世纪60年代末单语音识别的研究取得实质性进展,并将其作为一个重要的课题。一方面是因为计算机的计算能力有了迅速的提高,计算机能够提供实现复杂算法的硬件、软件;另一方面,数字信号处理在当时有了蓬勃发展,从而自20世纪60年代末开始引起了语音识别的研究热潮。

            语音合成技术。第一个合成器是在1835年由W.von Kempelen发明,经过Weston改进的机械讲话机。机器完全模仿人的生理过程,分别应用了特别设计的哨和软管模拟肺部空气动力和口腔。Homer Dudley1939年发明了第一台电子语音合成器,它不是一个简单的生理过程的模拟,而是在电子电路基础上来实现语音产生源。本文关于语音信号处理方面主要研究了语音合成。语音合成已经在许多方面得到了实际应用,方便了人们的生活,创造了很好的经济效益和社会效益,如公共交通中的自动报站、各种场合的自动报警、电话自动查询服务、文本校对中的语音提示等。综观语言合成技术的研究,语音合成发展方向为提高合成语音的自然度、丰富合成语音的表现力、降低语音合成技术的复杂度等。

    一、语音信号处理基本知识与仿真环境介绍

    1.1 语音信号处理基本知识

    1.1.1语音信号分析技术

            语音信号分析是语音信号处理的前提和基础,只有分析出可表示语音信号本质特征的参数,才有可能利用这些参数进行高效的语音通信、语音合成和语音识别等处理。而且,语音合成的音质好坏,语音识别率的高低,也都取决于对语音信号分析的准确性和精确性。因此语音信号分析在语音信号处理应用中具有举足轻重的地位。

            贯穿于语音分析全过程的是“短时分析技术”。语音信号从整体来看其本质特征的参数是随时间而变化的,所以它是一个非稳态过程,不能用处理稳信号的数字信号处理技术对其进行分析处理。但是,由于不同的语音是由人的口腔肌肉运动构成声道某种形状而产生的响应,而这种口腔肌肉运动相对于语音频率来说是非常缓慢的,所以从另一方面看,虽然语音倍号具有时变特性,但是在一个短时间范围内(一般认为在1030ms的短时间内),其特性基本保持不变即相对稳定,因可以将其看作是一个准稳态过程,即语音信号具有短时平稳性。所以任何语音信号的分析和处理必须建立在“短时”的基础上.即进行“短时分析”将语音信号分为一段一段来分析其特征参数,其中每一段称为一“帧”,帧长一般取为1030ms。这样,对于整体的语音信号来讲,分析出的是由每一帧特征参数组成的特征参数时间序列[4]

            根据所分析参数的性质的不同,可将语音信号分析分为时域分析、频域分析、倒领域分析等;时域分析方法具有简单、计算量小、物理意义明确等优点,但由于语音信号最重要的感知特性反映在功率谱中,而相位变化只起着很小的作用,所以相对于时域分析来说频域分析更为重要。

    1.1.2语音信号处理理论依据

        采样定理。在进行模拟/数字信号的转换过程中,当采样频率大于信号中最高频率的2倍时,采样之后的数字信号完整地保留了原始信号中的信息,一般实际应用中保证采样频率为信号最高频率的5~10倍。采样定理又称奈奎斯特定理。

            采样位数。采样位数即采样值或取样值,用来衡量声音波动变化的参数,是指声卡在采集和播放声音文件时所使用数字声音信号的二进制位数。

        采样频率。样频率是指计算机每秒钟采样多少个声音样本,是描述声音文件的音质、音调,衡量声卡、声音文件的质量标准。采样频率越高,即采样的间隔时间越短,则在单位时间内计算机得到的声音样本数据就越多,对声音波形的表示也越精确。采样频率与声音频率之间有一定的关系,根据奈奎斯特理论,只有采样频率高于声音信号最高频率的两倍时,才能把数字信号表示的声音还原成为原来的声音。这就是说采样频率是衡量声卡采集、记录和还原声音文件的质量标准。

            采样位数与采样频率的关系。采样位数和采样率对于音频接口来说是最为重要的两个指标,也是选择音频接口的两个重要标准。无论采样频率如何,理论上来说采样的位数决定了音频数据最大的力度,每增加一个采样位数相当于力度范围增加了6dB,采样位数越多则捕捉到的信号越精确,对于采样率来说你可以想象它类似于一个照相机,44.1khz意味着音频流进入计算机时计算机每秒会对其拍照达441000次。显然采样率越高,计算机提取的图片越多,对于原始音频的还原也越加精确。

    1.2 实现平台MATLAB 7.0介绍

    1.2.1 MatLab软件基本介绍

            MATLAB产生于1982年,是一种效率高、功能强的数值计算和可视化计算机高级语言,它将信号处理、数值分析和图形显示结合一体,形成了一个极其方便又强大的操作环境,为科学研究、工程设计以及必须进行有效数值计算的众多科学领域提供了一种全面的解决方案,并在很大程度上摆脱了传统非交互式程序设计语言的编辑模式,代表了当今国际科学计算软件的先进水平[7]

            MATLAB7.0是美国MathWorks公司出品的商业数学软件,用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境。MATLAB 7.0 的应用范围非常广,包括信号和图像处理、通讯、控制系统设计、测试和测量、财务建模和分析以及计算生物学等众多应用领域

    1.2.2 MatLab与语音处理的关系

            MATLAB软件以其强大的运算能力可以很好的完成对语音信号的处理。通过MATLAB可以对数字化的语音信号进行时频域分析,方便地展现语音信号的时域及频域曲线,并且根据语音的特性对语音进行分析。例如,请浊音的幅度差别、语音信号的端点、信号在频域中的共振峰频率、加不同窗和不同窗长对信号的影响、LPC分析、频谱分析等[3]

            同时,通过MATLAB可以对数字化的语音信号进行估计和判别。例如,根据语音信号的短时参数,一级不同语音信号的短时参数的性质对一段给定的信号进行有无声和请浊音的判断、对语音信号的基音周期进行估计等。另外,通过利用MATLAB编程可以对语音信号进行各种处理。由于MATLAB是一种面向科学和工程计算的高级语言,允许用数学形式的语言编程,又有大量的库函数,所以编程简单、编程效率高、易学易懂,我们可以对信号进行加噪去噪、滤波、截取语音等,也可进行语音编码、语音识别、语音合成的处理等。总之,对于语音信号进行分析处理,MATLAB软件是当今比较高效的平台。

    二、语音信号的特点与采集

    2.1语音信号的特点分析

            语音信号的特点可以分为时域方面和频域方面。

            在时域内,语音信号具有短时性的特点,即在总体上,语音信号的特征是随着时间而变化的,但在一段较短的时间间隔内,语音信号保持平稳。

            在频域内,语音信号的频谱分量主要集中在300~3400Hz的范围内。利用这个特点,可以按8kHz的采样率对语音信号进行采样,得到离散的语音信号。语音信号的这两种特点均可通过MATLAB软件表现出来,如图2.1和图2.2所示。


    图2.1 语音信号时域图


    图2.2 语音信号频域分析

    2.2语音信号的采集

    2.2.1语音信号的量化编码采样

            在将语音信号进行数字化前,必须先进行防混叠预滤波,预滤波的目的有两个,一是抑制输入信导各领域分量中频率超出/2的所有分量(为采样频率),以防止混叠干扰;二是抑制50Hz的电源工频干扰。这样,预滤波器必须是一个带通滤波器,设其上、下截止颜率分别是和,则对于绝人多数语音编译码器,=3400Hz、=60~100Hz、采样率为=8kHz;而对于语音识别而言,当用于电话用户时,指标与语音编译码器相同。当使用要求较高或很高的场合时=4500Hz或8000Hz、=60Hz、=10kHz或20kHz。

            为了将原始模拟语音信号变为数字信号,必须经过采样和量化两个步骤,从而得到时间和幅度上均为离散的数字语音信号。采样也称抽样,是信号在时间上的离散化,即按照一定时间间隔△t在模拟信号x(t)上逐点采取其瞬时值。采样时必须要注意满足奈奎斯特定理,即采样频率必须以高于受测信号的最高频率两倍以上的速度进行取样,才能正确地重建波它是通过采样脉冲和模拟信号相乘来实现的。

            在采样的过程中应注意采样间隔的选择和信号混淆:对模拟信号采样首先要确定采样间隔。如何合理选择△t涉及到许多需要考虑的技术因素。一般而言,采样频率越高,采样点数就越密,所得离散信号就越逼近于原信号。但过高的采样频率并不可取,对固定长度(T)的信号,采集到过大的数据量(N=T/△t),给计算机增加不必要的计算工作量和存储空间;若数据量(N)限定,则采样时间过短,会导致一些数据信息被排斥在外。采样频率过低,采样点间隔过远,则离散信号不足以反映原有信号波形特征,无法使信号复原,造成信号混淆。根据采样定理,当采样频率大于信号的两倍带宽时,采样过程不会丢失信息,利用理想滤波器可从采样信号中不失真地重构原始信号波形。量化是对幅值进行离散化,即将振动幅值用二进制量化电平来表示。量化电平按级数变化,实际的振动值是连续的物理量。具体振值用舍入法归到靠近的量化电平上。

            语音信号经过预滤波和采样后,由A/D变换器变换为二进制数字码。这种防混叠滤波通常与模数转换器做在一个集成块内,因此目前来说,语音信号的数字化的质量还是有保证的。市面上购买到的普通声卡在这方面做的都很好,语音声波通过话筒输入到声卡后直接获得的是经过防混叠滤波、A/D变换、量化处理的离散的数字信号。

    2.2.2利用Windows录音器采集语音信号

    在本次设计中,可以利用Windows自带的录音机录制语音文件,图2.3是基于PC机的语音信号采集过程,声卡可以完成语音波形的A/D转换,获得WAV文件,为后续的处理储备原材料。调节录音机保存界面的更改选项,可以存储各种格式的WAV文件。

      

    2.3 基于PC机的语音采集过程

    第三章 语音信号的分析

    3.1 语音信号的短时能量分析
            一定时宽的语音信号,其能量的大小随时间有明显的变化。清音信号和浊音信号之间的能量差别相当显著。其中清音段(以清音为主要成份的语音段),其能量比浊音段小得多[10]。因此,对语音的短时能量进行分析,可以描述语音的这种特征变化情况。定义短时能量为如式(3-1)所示。
                                                     (3-1)
    其中N为窗长。特殊地,当采用矩形窗时,可简化为如式(3-2)所示。
                                                            (3-2)
    也可以从另外一个角度来解释。令
                                                              (3-3)                                         
    则 可表示为如式(3-4)所示。
                                              (3-4)  
            可以理解为,首先语音信号各个样点值平方,然后通过一个冲击响应为h(n)的滤波器,输出为由短时能量构成的时间序列。
            短时能量的计算直接受冲击响应的选择即窗函数的选择的影响。如果冲击响应的幅度是恒定的,它的序列长度N(即窗长)会很长,将其等效为非常窄的低通滤波器,这时冲击响应对 产生的平滑的作用比较明显,使短时能量基本没有很大的变化,将不能表现出语音的时变的特性。相反,如果冲击响应的序列长度过于小,等效窗就不能提供出够用的平滑,以导致语音的振幅在瞬时的变化的许多细节仍被留了下来,进而不能看出振幅包络变化的规律,一般我们要求窗长是几个基音周期的数量级。
            图3.1为采样率8000kHZ,16位,单声道的一个语音信号(单词“earth”)在不同矩形窗长时的短时能量函数,我们会发现:语音信号的幅度变化在被短时能量所反映时,窗长的长短都有影响。
     
    图3.1 不同矩形窗长的短时能量函数
            我们知道,单词earth前半部分是浊音,后半部分是清音。由以上分析结果可知,浊音部分的能量较之清音部分要大得多,而清音部分的能量相当小,几乎为零。
            对语音信号进行短时能量函数运算,可实现以下三点应用:
    (1)可用于区分清音段与浊音段。En值大对应于浊音段,En值小对应于清音段。
    (2)可用于区分浊音变为清音或清音变为浊音的时间(根据En值的变化趋势)。
    (3)对高信噪比的语音信号,也可以用来区分有无语音(语音信号的开始点或终
    止点)。无信号(或仅有噪声能量)时,En值很小,有语音信号时,能量显著增大。
    3.2短时自相关分析
            对于确定性信号序列,自相关函数定义如式(3-5)所示。
                                                      (3-5)
            对于随机性信号序列或周期性信号序列,自相关函数的定义如式(3-6)所示。
                                                (3-6)
            自相关函数具有以下几项性质:
        (1)若序列是周期性的,假设序列周期为 ,那么其自相关函数也是具有相同周期的周期函数,即 
        (2)自相关函数是偶函数,即R(k)=R(-k);
        (3)当k=0时,自相关函数有极大值,即
        (4)R(0)为随机性序列的平均功率或确定性信号序列的能量。
            自相关函数的上述性质,完全可以适用于语音信号的时域分析中。例如,浊音语音波形序列具有周期性,因此可用自相关函数求出这个周期,即是基音周期。此外,自相关函数也可用在语音信号的线性预测分析中。
    短时自相关函数的定义如式(3-7)所示。 
                                        (3-7)
    令 ,并且 ,可以得到如下式子,如(3-8)所示。
                                  (3-8)
            如图3.2是在不同的矩形窗窗长条件下单词earth的语音自相关的函数的波形。
            对两图分析可得:清音信号的短时自相关函数的波形不具有周期性,也没有明显的峰值,且随着延时k的增大迅速变小,因此其接近于随机噪声;浊音是具有周期性的信号,浊音信号的周期为自相关函数的周期,由此可知,语音信号的性质是浊音还是清音,如果是浊音,还可以得出它的基音周期,它的基音周期可由自相关函数波形中的第一个峰值的位置来估计。所以,自相关函数常用作一下两种作用:
    (1) 区分语音信号是清音还是浊音;
    (2) 估计浊音语音信号的基音周期[4]。
     

    图3.2 不同的矩形窗窗长下短时自相关

    第四章 语音合成

    4.1 语音合成技术概述
    4.1.1 语音合成技术的意义                                                   
            语音合成技术涉及声学、语言学、数字信号处理技术、多媒体技术等多个领域, 是当今世界强国竞相研究的热门技术之一。语音合成技术可分为参数合成和波形拼接两种方法。早期的研究主要是采用参数合成方法, 它是计算发音器官的参数, 从而对人的发音进行直接模拟。语音合成已经在许多方面得到了实际应用,方便了人们的生活,创造了很好的经济效益和社会效益,如公共交通中的自动报站、各种场合的自动报警、电话自动查询服务、文本校对中的语音提示等[8]。
            本文主要利用载波调制技术进行语音合成。基于载波调制的语音信号合成是以语音信号处理技术、数字信号处理技术为基础,依托于电子计算机、Windows操作系统、MATLAB处理软件等工具将两个信号合成为一个信号。具有较强的实用性、可操作性等特点。
    4.1.2 基于载波调制语音合成的基本原理
                语音信号合成是一个“分析—存储—合成”的过程。一般是选择合适的基本单元,将基本单元用一定的参数编码方式或波形方式进行存储,形成一个语音库。合成时,根据待合成语音信号,从语音库中取出基本单元进行合成,并将其还原成语音信号。在语音合成中,为了便于存储和后续分析,必须先将语音信号进行预分析、预处理、波形变换等一系列操作。其中,基元是语音合成处理的最小单元,待合成的语音库就是所有语音基元的某中集合。根据基元的选择方式以及其存储形式的不同,可以将合成方法笼统的分为波形合成方法和参数合成方法。
            波形合成是一种相对简单的语音合成技术。它把人的发音波形直接存储或者进行进行简单的波形编码后存储,组成一个合成的语音库;合成时,根据待合成的信息,在语音库中取出相应单元的波形数据,拼接或编辑到一起,经过解码还原成语音。该语音合成技术具有一定的局限和不足,但对语音信号具有数据量庞大的特点,这种误差在某种范围内是可以接受的。
            基于载波调制的语音信号合成是基于信号的振幅调制原理而实现的。将低频信号加载到高频载波信号的过程,或者说把信息加载到信息载体上以便传输的处理过程,称为调制。所谓“加载”,其实质是使高频载波信号(信息载体)的某个特性参数随信息信号幅值的大小程线性变化。基于载波调制的语音信号合成是以语音一信号作为调制信号,语音二信号为载波信号来进行合成一种以语音二信号声色表述语音一内容的新信号。这种调制方式是用传递的低频信号(如代表语言、音乐、图像的电信号)去控制作为传送载体的高频振荡波(称为载波)的幅度,是已调波的幅度随调制信号的大小线性变化,而保持载波的角频率不变。
    4.2 基于载波调制的语音合成基本知识
    4.2.1 关键函数希尔伯特变换介绍
            本文语音合成的设计思路是用一个语音信号的包络去调制另一个语音信号,实现语音的合成。这就用到了一个关键的函数,希尔伯特变换。在数学与信号处理的领域中,一个实值函数的希尔伯特变换是将信号s(t)与1/(πt)做卷积,以得到s'(t)。因此,希尔伯特变换结果s'(t)可以被解读为输入是s(t)的线性时不变系统的输出,而此系统的脉冲响应为1/(πt)。这是一项有用的数学工具,用在描述一个以实数值载波做调制的信号之复数包络,出现在通讯理论中发挥着重要作用[9]。
            希尔伯特变换的频域数学表达式如式(4-1)所示。                       
                                                          (4-1)
    其中F是傅里叶变换,i是虚数单位,ω是角频率。
            希尔伯特变换等效于 π/2的相移,对正频率产生-π/2的相移,对负频率产生π/2相移,或者说,在时域信号每一频率成分移位1/4波长,因此,希尔伯特变换又称为90度移相器。
            MATLAB提供了计算Hilbert变换的函数,其格式为y=Hilbert(x)。但需注意的是,该函数计算出的结果是序列的解析信号,其虚部才是序列的Hilbert变换。
            希尔伯特变换在语音信号处理中具有两个性质: 序列x(n)通过Hilbert变换器后,信号频谱的幅度不发生变化,这是因为Hilbert变换器是全通滤波器,引起频谱变化的只是其相位; 序列x(n)与其Hilbert变换是正交的[6]。
    4.2.2 信号调制
            所谓调制,就是将调制信号加载在三个参数中的某一个参数上,或幅值、或频率、或相位,随调制信号大小成线性或非线性变化的过程。主要有三种基本调制方法,第一种是把调制信号加载在载波信号的幅值上,称为幅度调制 ,简称AM;第二种是把调制信号加载在载波的频率上,称为频率调制,简称FM。 第三种是把调制信号装载在载波的相位上,称为相位调制,简称PM[10]。 本设计采用的是第一种方法,用采集到的语音二信号去对语音一信号进行幅度调制,实现语音合成的目的。
            采用调幅调制是因为其以下特点在语音信号处理中得到很好的应用。一是调幅波的振幅(包络)随调制信号变化,而且包络的变化规律与调制信号波形一致,表明调制信号(信息)记载在调幅波的包络中;二是调制系数反应了调幅的强弱程度,一般情况下,调制系数越大调幅度越深。
            当调制系数为0时,表示未调幅,即无调幅作用;
            当调制系数为1时,此时包络的振幅最小值为0;
            当调制系数大于1时,已调波的包络与调制信号不一样,产生严重的包络失真,称为过量调幅。
    4.3 语音信号合成过程
    4.3.1 语音信号合成流程图
            用MATLAB 处理音频信号的基本流程是:先将WAV 格式音频信号经wavread 函数转换MATLAB 列数组变量;再用MATLAB 强大的运算能力进行数据分析和处理,如时域分析、频域分析、数字滤波、信号合成、信号变换、识别和增强等等;处理后的数据如是音频数据,则可用wavwrite函数 转换成WAV 格式文件或用sound、wavplay 等函数直接回放。本设计的语音合成流程图如图4.1所示。
     
    图4.1  语音信号合成流程图
    4.3.2 语音信号的采集
            分析和处理音频信号,首先要对声音信号进行采集,MATLAB 的数据采集工具箱提供了一整套命令和函数,通过调用这些函数和命令,可直接控制声卡进行数据采集。Windows 自带的录音机程序也可驱动声卡来采集语音信号,并能保存为WAV 格式文件,供MATLAB 相关函数直接读取、写入或播放。本文以WAV 格式音频信号作为分析处理的输入数据。
    4.3.3 语音信号的合成
            声音信号是一种非平稳信号,如果采用简单的时变系统的分析方法,将会产生很大的失真,但是在一小段时间内声音信号完全可以视为平稳信号。因此必须对语音信号做预处理。在本次语音信号合成中采用加窗截断,分帧处理将非平稳信号近似转换为平稳信号。
            声音信号特征量提取。声音信号特征量提取包括语音一声音信号声色(频率)的提取和语音二声音信号包络的提取。语音二声音信号包络的提取采用希尔伯特变换实现,得到语音二声音信号的复数包络。
            获取语音信号起始位置。在录音过程中控制两段声音从相同的起点开始录取并不是一件容易的事,但是如果不确定语音信号的起始位置直接对语音信号进行合成既存在数据量大又会带来较大的误差。本设计语音合成中拟定连续四个时间点的语音信号强度不为0,则认为语音信号开始,也即找到信号起始位置。
            语音信号合成。语音信号合成即是一个调幅载波的过程,是以语音一信号作为载波信号,语音二信号包络作为调幅信号来实现语音合成。实际的载波是一个物理可实现的复杂过程,本语音合成中采用语音一信号点乘包络信号,实际的载波是一个物理可实现的复杂过程,并非简单地乘积运算,然而,得到的合成声音信号效果并不理想,但其波形仍能反应载波过程的实质。
    4.4 语音信号合成结果及分析
    4.4.1 语音信号预处理结果及分析
            该处理过程以语音一信号和语音二声音信号为分析样本。使用Windows系统自带录音器分别录下语音一和语音二,分别命名为one和two,保存为WAV格式。通过MATLAB对所录语音进行采样,采样频率 为16000Hz,获取语音信号并进行加窗。语音一和语音二的时域波形图如图4.2所示,时域图反映出了语音信号的非平稳性。
            对采集到的语音信号分别做傅里叶变换进行频谱分析,并显示频谱图,观察各自的幅频谱特性。语音一和语音二的声音信号幅频特性如图4.3所示,语音一和语音二的声音FFT图如图4.2和图4.3。该频谱图横坐标并未进行对应关系处理,但仍不失其频谱特性的本质,由频谱图可清楚地看到样本声音主要以低频为主。人的语音信号频率一般集中在1kHz之前,从声音频谱的包络来看, 根据采样定理,信号宽度近似取为1kHz,重放语音后仍可较清晰的听出原声, 不存在声音混叠现象。
     
    图4.2  信号预处理之后时域图
     
    图4.3 信号预处理之后频域图
    4.4.2 合成语音信号结果及分析
            合成语音信号的实质是用语音二信号的包络调制语音一信号振幅的结果。语音二信号包络提取结果如图4.4,该图是语音二信号经希尔伯特—黄变换的虚部显示,因为希尔伯特—黄变换是一个时域信号与1/(πt)的卷积,其结果是载波做调制信号之复数包络,必然蕴含虚部成分,取其虚部的结果必然与时域信号有着直观上的差别,但仍是信号的包络成分。
     
    图4.4 语音二信号包络图
            合成信号的时域显示结果如图4.5所示,该合成信号是以语音一信号的特性和语音二信号的幅度变化的,由其快速傅里叶变换的结果更证实了这一点,其幅频特性与语音一信号的幅频特性更接近。
     
    图4.5 合成语音信号的时域波形
     
    图4.6 合成语音信号的幅频特性

     

    图4.7 合成语音信号快速傅里叶变换结果


    结  论

            随着语音技术的逐渐成熟,语音信号处理技术也在不断发展,不断完善。本文主要研究了通过对语音信号短时能量、短时自相关等特性参数的分析,使我进一步了解了语音信号的特性,明白了只有准确分析并提取出语音信号的特征参数,才能够利用这些参数进行语音编码、语音合成等处理。另外在语音处理方面,我选择了语音合成这一处理方式。基于载波调制的语音处理实现简单,运用广泛,研究这一语音合成方法及特性,对于更加深入地进行各种语音处理有着重要的意义。这次设计我是通过了MATLAB这一平台,MATLAB软件以其强大的运算能力可以很好的完成对语音信号的处理,因此,近一步的加强对MATLAB的研究对我以后的学习会起到很大的帮助。
            至此,设计基本符合要求。但是由于个人能力的有限,采集的语音信号清、浊音区分不明显,导致对语音进行短时自相关得出的波形特征不明显。考虑解决方案是通过专业的设备采集语音信号。除此之外,本设计必有其他欠妥之处,请各位老师给予指正!

    参考文献

    [1] 张雪英.数字语音处理[M].北京:电子工业出版社, 2010.
    [2] 郑君里,应启绗,杨为理.信号与系统[M].北京:高等教育出版社,2000.
    [3] 薛年喜.MATLAB在数字信号处理中的应用[M].北京:清华大学出版社,2003.
    [4] 胡航.语音信号处理[M].哈尔滨:哈尔滨工业大学出版社, 2000.
    [5] 易克初,田斌,付强.语音信号处理[M].北京:国防工业出版社, 2000.
    [6] 万永革.数字信号处理的MATLAB实现[M].北京:科学出版社,2007.
    [7] 刘卫国. MATLAB程序设计与应用[M].北京:高等教育出版社,2006.
    [8]王嘉梅.基于MATLAB的数字信号处理与时间开发[J].西安:西安电子科技大学出版社,2007:10-14.
    [9] 程佩青.数字信号处理教程(第二版)[M].北京:清华大学出版社,2010.
    [10] 韩纪庆 张磊 郑铁然.语音信号处理[M].北京:清华大学出版社,2004.
    [11] 徐明远,邵玉斌. Matlab仿真在通信与电子工程中的应用[M].西安:西安电子科技大学出版社,2005. 
    [12] 邓华. Matlab通信仿真及应用实例详解[M].北京:人民邮电出版社,2005. 
    [13] 张照明,刘政波,刘斌等. 应用Matlab实现信号分析处理[C].北京:科学出版社,2006.
    [14] 徐守时. 信号与系统理论方法和应用[M].合肥:中国科学技术大学出版,1999. 

    [15] 高俊斌. Matlab语言与程序设计[M].武汉:华中理工大学出版社,1998. 

    附  录

    附录A   语音信号特性分析程序

    %语音信号时域频域显示%
    [y,Fs,bits]=wavread('biye.wav');%读出信号、采样率和采样位数
    y=y(:,1);%取单声道
    sigLength=length(y);
    Y=fft(y,sigLength); 
    Pyy=Y.* conj(Y) / sigLength;
    halflength=floor(sigLength/2);
    f=Fs*(0:halflength)/sigLength;
    figure;plot(f,Pyy(1:halflength+1));
    xlabel('Frequency(Hz)');
    t=(0:sigLength-1)/Fs;
    figure;
    plot(t,y);
    xlabel('Time(s)');
    
    %语音信号短时能量%
    x=wavread('biye.wav');
    %x=fscanf(fid,'% f');
    %fclose(fid);
    s=fra(50,25,x)
    s2=s.^2;
    energy=sum(s2,2)
    subplot(2,2,1)
    plot(energy);
    xlabel('帧数')
    ylabel('短时能量 E')
    legend('N=50')
    %axis({0,1500,0,10*10^5})
    s=fra(100,50,x)
    s2=s.^2;
    energy=sum(s2,2)
    subplot(2,2,2)
    plot(energy);
    xlabel('帧数')
    ylabel('短时能量 E')
    legend('N=100')
    %axis({0,750,0,2*10^6}) 
    s=fra(400,200,x)
    s2=s.^2;
    energy=sum(s2,2)
    subplot(2,2,3)
    plot(energy);
    xlabel('帧数')
    ylabel('短时能量 E')
    legend('N=400')
    %axis({0,190,0,7*10^6})
    s=fra(800,400,x)
    s2=s.^2;
    energy=sum(s2,2)
    subplot(2,2,4)
    plot(energy);
    xlabel('帧数')
    ylabel('短时能量 E')
    legend('N=800') 
    %axis({0,95,0,14*10^6})
    
    %语音信号短时自相关%
    x=wavread('biye.wav');
    s1=x(1:320);
    N=320;   %选择的窗长,加N=320的矩形窗
    A=[];
    for k=1:320;
    sum=0;
    for m=1:N-(k-1);
    sum=sum+s1(m)*s1(m+k-1);   %计算自相关
    end
    A(k)=sum;
      end
    for k=1:320
    A1(k)=A(k)/A(1);        %归一化A(k)
       end
    N=160;                  %选择的窗长,%加N=160的矩形窗
    B=[];
    for k=1:320;
    sum=0;
    for m=1:N-(k-1);
    sum=sum+s1(m+k-1);   %计算自相关
    end
    B(k)=sum;
    end
    for k=1:320
    B1(k)=B(k)/B(1);      %归一化B(k)
    end
    N=70;                 %选择的窗长,加N=70的矩形窗
    C=[];
    for k=1:320;
    sum=0;
    for m=1:N-(k-1);
    sum=sum+s1(m)*s1(m+k-1);        %计算自相关
    end
    C(k)=sum;
    end
    for k=1:320
    C1(k)=C(k)/C(1);                %归一化C(k)
    end
    s2=s1/max(s1)
    figure(1)
    subplot(4,1,1)
    plot(s2)
    title('语音信号')
    xlabel('样点数')
    ylabel('幅值')
    axis([0,320,-2,2])
    subplot(4,1,2)
    plot(A1)
    xlabel('延时k')
    ylabel('R(k)')
    axis([1,320,-2,2]);
    legend('N=320')
    subplot(4,1,3)
    plot(B1);
    xlabel('延时k')
    ylabel('R(k)')
    axis([1,320,-2,2]);
    legend('N=160')
    subplot(4,1,4)
    plot(C1);
    xlabel('延时k')
    ylabel('R(k)')
    axis([0,320,-2,2]);
    legend('N=70')
    附录B  语音合成主程序
    [y1,fs,bits]=wavread('one');      %读取语音一信号
    [y2,fs,bits]=wavread('two');      %读取语音二信号
    L1=length(y1);                    %测定语音一信号长度
    L2=length(y2);                    %测定语音二信号长度
    a1=y1.*hamming(L1);               %加窗预处理
    a2=y2.*hamming(L2);               %加窗预处理
    L1=length(a1);                    %测定语音一信号长度
    L2=length(a2);                    %测定语音二信号长度
    %采样信号的时域显示
    figure(1);
    subplot(211);
    plot(a1);
    title('语音一载波信号时域波形');
    subplot(212);
    plot(a2);
    title('语音二调幅信号时域波形');
    %傅里叶频谱绘制
    F1=fft(a1,L1);                    
    F2=fft(a2,L2);
    AF1=abs(F1);
    AF2=abs(F2);
    figure(2);
    subplot(211);
    plot(AF1);
    title('语音一载波信号幅频特性显示');
    subplot(212);
    plot(AF2);
    title('语音二调幅信号幅频特性显示');
    figure(3);
    freqz(F1);
    title('语音一载波信号FFT频谱显示');
    figure(4);
    freqz(F2);
    title('语音二载波信号FFT频谱显示');
    %获取语音一信号的开始位置
    for i=1:L1-4
         g(i)=a1(i).*a1(i+1).*a1(i+2).*a1(i+3).*a1(i+4);%认为连续4个幅值不为0的信号即为开始
         if g(i)~=0
             break;
         else i=i+1;
         end
    end
    I=i;
     
    % 获取语音二信号开始位置
    for j=1:L2-4
         m(j)=a2(j).*a2(j+1).*a2(j+2).*a2(j+3).*a2(j+4);
         if m(j)~=0
             break;
         else j=j+1;
         end
    end
    J=j;
    %语音二信号hilbert变换
    H=hilbert(a2);
    figure(5);
    plot(abs(H));
    title('语音二信号包络显示');
    %信号对齐,语音二包络调制语音一振幅
    max1=max(I,J);
    for k=1:L1-max1
        N(k)=a1(i).*H(j);
        i=i+1;
        j=j+1;
    end
    %N=N';
    N = N/(max(abs(N)) * 1.05);
    wavwrite(N,16000,16,'HC.wav');
    figure(6);
    plot(imag(N));
    title('合成信号时域显示');
    pause(1);
    sound(10*N,fs);
    FN=fft(N);
    figure(7);
    freqz(FN);
    title('合成声音信号FFT显示');
    figure(8);
    plot(abs(FN));
    title('合成声音信号的幅频特性');
    

    展开全文
  • 基于MATLAB的水果分级设计

    万次阅读 多人点赞 2018-06-14 14:19:35
    如果能够好好的利用这项技术,对于国内社会可以提高人民群众的生活品质,在国际社会也可以提高国际声誉,拉动中外友谊。这项技术必将对国家的发展产生有利的影响。 1.3 研究内容 本课题是基于计算机视觉的水果分级...
  • 图片轻松转文字-天若OCR

    千次阅读 2019-06-03 20:55:57
    你还停留在手动敲击的原始社会吗?那就太OUT了 使用图片转文字的OCR软件可以方便的解放生产力 2.天若OCR简介 天若OCR,只有1.4M,但是识别度非常的高,特别的简单易用。 快捷键如下,F4可迅速启动识别: 使用实例:...
  • 区块链,如瑞士仪表般精密,如互联网般惊世骇俗,它在以神一般的节奏颠覆社会。 当新兴技术来临时,你可以选择规避——如果明天也可以规避的话。区块链也一样。 作为一个现象级概念,金融科技创新在过去几年迎来了...
  • 在线文档与图片分享平台。 针对以上国内的共享文库,都可以通过注册账号,上传分享资料赚取积分,通过积分可以下载文库资料。 如果有些文档看过后不错想保存下来积分不够,可以通过文库下载器来免费下载保存,文库...
  • 压缩图片并转换为BASE64编码字符串

    千次阅读 2019-10-24 16:48:38
    调用全国人口信息社会应用平台的人像比对服务,请求参数之一“公民人像BASE64编码字符串”,限制大小为30KB; 使用谷歌处理图片的开源工具(thumbnailator),可以对图片进行缩放,旋转,压缩,剪裁,添加水印,...
  • 除了最微不足道的经济、政治和社会交易之外,身份对其它一切交易都有重要意义。 -图片来自Morgan Davis的网络相簿- 你在做任何交易之时,都要对你的交易对手(某人、某物或某公司)的身份有一定的把握。许多交易...
  • 图片是我辛苦拍摄的,熬夜处理的,但是在其它网站居然被轻松挪用,严重者甚至整个一个山寨版摄影专栏!但是举证艰难,官网客服根本不予理睬,真是欲哭无泪!”这是一位摄影师曾经面临图片侵权时的内心真实写照。 ...
  • 它的网址是这个:https://storage.googleapis.com/openimages/web/index.html我推荐的其它深度学习相关文章:利用搜索引擎和ffmpeg生成深度学习图片数据集深度学习tensorflow object detect 之识别社会人小猪佩奇滴滴...
  • Harvard-MIT Data Center 1960年在哈佛大学作为对政治和社会科学的原始数据中心而成立,它是定量社会科学机构的一个成员。使命是研发和提供世界顶级的研究计算资源、数据服务和支持信息技术,为了将社会科学研究和...
  • python识别图片验证码

    千次阅读 2017-07-07 10:39:29
    字符型图片验证码识别完整过程及Python实现 1 摘要 验证码是目前互联网上非常常见也是非常重要的一个事物,充当着很多系统的 防火墙 功能,但是随时OCR技术的发展,验证码暴露出来的安全问题也越来越严峻。...
  • 第九章 客户端攻击和社会工程 作者:Gilberto Najera-Gutierrez 译者:飞龙 协议:CC BY-NC-SA 4.0 简介我们目前所见的大部分技巧都尝试利用服务端的漏洞或设计缺陷,并访问它来从数据库中提取信息。有另外不...
  • 大数据原始数据从那些途径获取?200个国内外经济金融行研咨询数据网站大全 大数据资料搜集是个相当繁琐与累的工作,也是投资入门的基本,良好的信息资料搜集能力有利于我们快速了解投资主体的基本情况,为后续的...
  • 爬虫应遵守社会主义核心价值观,不要无脑爬,给站长造成不必要的麻烦 爬取的网址:添加链接描述 只是从第二页开始爬取,第一页网址稍微有点变化… 注意!!!看清楚原图网址,不要爬成缩略图。。。 效果图: 代码...
  • 结绳计数——最原始的备忘录

    千次阅读 2018-08-21 20:26:24
    ☞ 欢迎来到神奇的01世界 ☜ 上古结绳而治,后世圣人易之以书契,百官以治,万民以察。 ——《周易·系辞》 引言 前面讲到手指计数和石子计数。手指「随身携带」,拿出来就是,...图片来自网络 据文献记载及考古...
  • 基于jsp(java)超市管理系统的设计和开发(含源文件)

    万次阅读 多人点赞 2020-02-09 13:24:26
    缺乏实时分析功能,管理人员对及时传递资料的要求始终得不到满足,随着超市形态的高速发展,其经营管理也变的愈加复杂,日常所需处理的数据量也逐渐增大,商业运转的中间环节也越来越多,原始的人工管理已无法应对这...
  • Harvard-MIT Data Center 1960年在哈佛大学作为对政治和社会科学的原始数据中心而成立,它是定量社会科学机构的一个成员。使命是研发和提供世界顶级的研究计算资源、数据服务和支持信息技术,为了将社会科学研究和...
  • 第三方社会化评论系统评测

    千次阅读 2015-10-08 15:30:59
    友言、友荐同属jiathis旗下产品,友言定位于专业的社会化评论系统。初看到友言,就想到了 Facebook评论。确实友言这种模式在国外已经有 Facebook Comments、Disqus等先例,不过咱们苦逼的大陆站长用不了。如果你不是...
  • 大数据对社会影响

    千次阅读 2014-07-06 09:00:28
    1 数据的原始积累, 飞轮效应,最开始每一圈都很累,但是达到一定推力时,飞轮自身重力和冲力就会成为推动力一部分,此时你无须在很用力气飞轮依旧会很快转动,数据积累也是如此,初期都是笨功夫。后期则成为宝贵...
  • 在线文档与图片分享平台。   针对以上国内的共享文库,都可以通过注册账号,上传分享资料赚取积分,通过积分可以下载文库资料。如果有些文档看过后不错想保存下来积分不够,可以通过文库下载器来免费下载保存,文库...
  • 这篇文章将详细讲解WHUCTF隐写和逆向题目,包括文字解密、图片解密、佛语解码、冰蝎流量分析、逆向分析。第一次参加CTF,还是学到了很多东西。人生路上,要珍惜好每一天与家人陪伴的日子。感谢武汉大学,感谢这些...
  • 第三方社会化评论插件

    千次阅读 2019-07-20 18:27:04
    WordPress的优点在于可定制性强,社会化的有点在于传播范围广,这两者的结合目前是博客社会化的最简单途径。由于Wordpress自带评论功能比较单一,而且仅局限于站内,于是出现了很多统一托管多平台交叉的第三方社会化...
  • 大数据驱动社会治理的创新转向

    千次阅读 2017-08-01 14:40:00
    面对社会运行的复杂性和艰巨性,大数据驱动社会治理创新要求必须改变传统的治理思路和模式,必须对社会变化的风险实施预测和分析,必须建立监测灵敏的社会反应和治理体系。因此,开放式治理、流动性治理、精准化...
  • 表情识别(二)

    千次阅读 2018-07-24 12:07:19
    fer2013中的图片以“标签 图像向量”的形式保存在.csv文件中,即每一个列向量是一张图片,第一个数字是标签,剩下的数字是图片数据(将图片矩阵按列展开存储的),可以利用matlab的reshape函数将图片还原出来,图像...
  • 网络可视化 自定义或根据数据设置节点的大小、节点颜色、边的粗细、边的颜色及节点与边的标签的颜色及大小 用户自定义:手动设置大小、颜色等 根据数据设定:原始数据本身携带的可以用于设置的数值;通过 gephi 统计...
  • 字符型图片验证码识别完整过程及Python实现 1 摘要 验证码是目前互联网上非常常见也是非常重要的一个事物,充当着很多系统的 防火墙 功能,但是随时OCR技术的发展,验证码暴露出来的安全问题也越来越严峻。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,836
精华内容 3,934
关键字:

原始社会图片