Python学习笔记

最新推荐文章于 2024-04-30 21:03:59 发布

不李姐这些东西

最新推荐文章于 2024-04-30 21:03:59 发布

阅读量761

点赞数

分类专栏： python学习笔记文章标签： python

本文链接：https://blog.csdn.net/weixin_52953225/article/details/121019257

版权

python学习笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

参考教材：python3.6从入门到精通-王英英编著-清华大学出版社

python的基础语法

2.1程序结构

2.1.1缩进分层

python特色：缩进分层

所有的代码块语句必须包含相同的缩进空白数量、相同的缩进方式（wab键、两个或四个空格）

2.1.2换行问题

换行符：\n
程序代码超过一行：

每一行结尾加反斜杠\
用小括号()中括号[]大括号{}包含起来的语句，不使用反斜杠就可以直接分成数行

将多行表达为一行：行尾加分号;

2.1.3代码注释

单行注释：以#开用
多行注释：用三个单引号’’’或三个双引号”””将注释括起来

2.2 python的输入和输出

2.2.1接收键盘输入：input（）

2.2.2输出处理结果：print（value.....，sep=’’,end=’\n’）

value表示用户要输出的信息，省略号表示有多个要输出的信息。

sep用于设置多个要输出信息之间的分隔符，默认为一个空格。

end是一个print（）函数中所有要输出信息之后添加的符号，默认值为换行符。

2.3变量：变量不需要声明类型，但需要赋值

2.4标识符与保留字

标识符:用来识别变量、函数、类、模块及对象的名称。由（A-Z，a-z，0-9，和下划线_）

限制：

第一个字符必须是字幕或下划线，并且变量名称之间不能有空格
标识符有大小写区分。

2.5简单数据类型

2.5.1数字类型

int（整数）：可用十六进制数值来表示整数，十六进制表示法是在数字之前加上0x。

float（浮点型）：可以使用小数点，也可以使用指数。指数符号可以使用字母e或E,指数可以使用+-符号，也可以在指数数值前加上数值0.，还可以在整数前加上数值0。

bool（布尔值）包括True和False，与整数中1和0对应。

comples（复数）用双精度浮点数来表示实数与虚数的部分，复数符号可以使用字母j或J

可以使用real和imag属性分别取数复数的实数和虚数部分。

数值之间可以使用运算符，加减乘除取余%，乘方**

数字运算时注意：

数值的除法总是返回一个浮点数，要获取整数使用（//）操作符。

在整数和浮点数混合计算时，会把整形转换为浮点型。

2.5.2字符串类型

python将字符串视为一连串的字符组合。

创建字符串时，将其用单引号、双引号或三引号包含起来。其开头和结尾引号要一致。

字符串长度跨行时用三引号，因为单引号和双引号不能跨行。

2.5.3数值类型的相互转换：将数据类型作为函数名。

转换为整形
转换为浮点型
转换为字符串类型

2.6python结构数据类型

2.6.1集合类型（Sets）

Set（集合）是一个无序不重复元素的集。主要功能是自动清除重复的元素。创建集合时用大括号{}来包含其元素。

2.6.2列表类型（List）：支持数字、字符串、甚至可以包括列表。写在中括号[ ]中，用逗号分隔开的元素列表。

2.6.3元组类型（Tuple）：与列表对象类似，但不可以新增、修改与删除。可以使用小括号（）来包含其元素。也可以省略小括号，直接将元素列出。

2.6.4字典类型（Dictionary）：字典使用大括号{ }将元素列出。

元素由键值（key）和数值（value）组成，中间以冒号（：）隔开。
键值必须是字符串、数字或元组，这些对象是不可变动的。
数值可以是任何数据类型。字典的元素排列没有顺序。

2.7运算符和优先级

2.7.1算术运算符

加减乘除取余

**乘方

//取整除

2.7.2比较运算符

== != > < >= <=

2.7.3赋值运算符

一个运算符号加等号：例c=+a等价于c=c+a。

2.7.4逻辑运算符

and or not

2.7.5位运算符

&	按位算，相同取1	（12&6）=4，二进制为：0000 0100
\|	按位算，只要对应的二进制有一个为1，结果就是1
^	按位异或，两个对应的二进制相异时，结果为1，否则为0
~	按位取反，把每个数据的二级制取反
<<	左移动，把’<<’左边的运算数的各个二进位全部左移若干位，高位丢弃，低位补0
>>	右移动，把’<<’右边的运算数的各个二进位全部右移若干位。低位丢弃，高位补0

2.7.6成员运算符（in 和 not in）

x in y 表示若x在y序列中则返回True ; x not in y表示若x不在y序列中则返回True。

2.7.7身份运算符（is 和 not is）

is判断两个标识符是不是引用自同一个对象；is not 判断两个标识符是不是引用自不同对象。

2.7.8运算符的优先级

列表、元组和字典的基本操作

3.1列表的基本操作

3.1.1列表对象的特性

列表中元素可以是不同的类型
列表中元素可以是另一个列表
访问列表从0开始
列表可以嵌套，嵌套的列表用另一个中括号[ ]索引

3.1.2列表的常见操作

获取某个元素的返回值index（c）方法。（c是元素内容）
改变列表对象的元素值，
在列表中插入新元素aa[3:]=[“元素内容”,····]表示从左侧数第四个位置开始添加新元素。
删除列表中的元素，使用del语句

3.1.3列表的操作符+和*

+用于组合列表，*用于重复列表

3.1.4内置的函数和方法

列表的函数len（），max（），min（），list（）

len（）返回列表的长度
max（）返回列表元素中的最大值。
min（）返回列表元素中的最小值

列表的方法

append（object）方法在列表对象的解为，加上新对象object。
clear（）函数用于清空列表，类似于del a[:]
copy（）函数用于复制列表。
count（value）方法针对列表对象中的相同元素值value计算其数目。
extend（list）方法将参数list列表对象中的元素加到此列表中，成为此列表的新元素。
index（value）方法将列表对象中元素值为value的索引值返回。

insert（index，object）方法将在列表对象中索引值为index的元素之前插入新元素object。
pop（[index]）方法将列表对象中索引值为index的元素删除。如果没有指定index的值，就将最后一个元素删除。
remove（value）方法将列表对象中元素值为value的删除。
reverse（）方法将列表对象中的元素颠倒排列。
sort（）方法将列表对象中的元素依照打校顺序排列。

3.1.5递推式构造列表：使用列表内的元素创建新的列表

3.2元组的基本操作（元组的对象不能修改）

3.2.1元组对象的常用操作

创建一个只有一个元素的元组，需要在元素后加上逗号（，）否则python会认为此元素是设置给变量的值
元组的对象值不能修改。
删除元组内的对象
获取元组对象的元素值：元组对象支持使用索引值的方式来返回元素值
组合元组：虽然元组值不可以修改，但是可以组合。
删除整个元组：使用del语句

3.2.2元组的内置函数

len（）函数：返回元组的长度
max（）函数：返回元组的最大值
min（）函数：返回元组的最小值
tuple（）函数：返回元组中所有元素的和

3.3字典的基本操作

3.3.1字典对象的常用操作

获取字典中的元素值：使用键值作为索引（需保证键值存在）

修改字典中的元素值
删除字典中的元素：使用del语句
定义字典键值时需要注意的问题

不允许同一个键值多次出现。
不能使用列表作为键值

3.3.2字典的内置函数和方法

字典的内置函数

len（dict）：计算字典元素的个数，即键值的总数
str（dict）：将字典的元素转化为可打印的字符串形式。

type（variable）返回输入的变量类型，变量是字典，就返回字典类型。

字典的内置方法

clear（）清除字典中的所有元素。
copy（）复制字典
get（k[，d])：k是字典的索引值，d是索引值的默认值，若k存在，就返回其值，否则返回d。
keys（）：使用字典中的键值创建一个列表对象。
popitem（）：删除字典中的最后一个元素
setdefault（k[，d]）：k是字典的键值，d是键值的默认值。若k存在，返回其值，否则返回d。
update（E）:E是字典对象，由字典对象E来更新此字典。
values（）：使用字典中键值的数值创建一个列表对象。

操作字符串

4.1字符串的常用操作

4.1.1访问字符串中的值

使用方括号来截取字符串
若索引值是复数，则从后向前数

4.1.2分割指定范围的字符

使用冒号（：） a[x:y]
若省略开始索引值，分割字符串就由第一个字符道结尾索引值
若省略结尾索引值，分割字符串就由开始索引值道最后一个字符串。

4.1.3更新字符串

4.1.4使用转义字符：有时需要在字符串内设置单引号、双引号、换行符等，可使用转义字符。反斜杠（\）与一个字符。

换行字符（\n）
双引号（\”）
各进制的ASCII码
加入反斜杠字符，在字符串的引号前加上r或R

4.2使用字符串运算符

加号+，连接两个字符串

乘号*，可以将字符串的内容复制数次

逻辑运算符大于（>）等于（==）小于（<）比较两个字符串的大小

in 和not in测试某个字符是否存在于字符串内。

4.3格式化字符串

字符串格式化使用字符串操作符百分号（%）来实现。在百分号的左侧放置一个字符串，右侧放置希望被格式的值。

%c	格式化字符串及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%f	格式化浮点数字，可指定小数点后的精度（要格式浮点数，则可以提供u送需要的精度，即一个句点加上需要保留的小数点位数%.2f）（默认为6为小数）
%e	用科学计数法格式化浮点数
%p	用十六进制数格式化变量的地址

4.4内置的字符串方法

4.4.1capitalize（）方法：将字符串的第一个字符转化为大写，其他字符转化为小写。

4.4.2count方法：用于统计字符串中某个字符出现的次数，可选参数为在字符串搜索的开始与结束位置

使用方法：str.count（sub，start=0，end=len（string））

str是字符串，sub是要搜索的字符串，start为字符串开始搜索的位置，默认为第一个字符。end为字符串解说搜索的地址，默认为字符串的最后一个位置。

4.4.3find（）方法：检测字符串中是否包含子字符串，如果包含子字符串，就返回开始的索引值。否则返回-1.

语法格式：str.find(str,beg=0,end=len(string))

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

4.4.4

4.4.5

4.4.6

4.4.7

4.4.8

4.4.9

4.4.10

4.4.11

4.4.12

4.4.13

4.4.14

第五章程序的控制结构

5.1概述

顺序结构

选择结构

循环结构

5.2基本处理流程

5.3多样的赋值语句

5.3.1基本赋值：赋予变量的值，使之能够参与运算

python中变量不需要声明，但是每个变量在使用前都需要赋值。

5.3.2序列解包：一次性给多个变量赋值

5.3.3链式赋值：将同一个值赋给多个变量，一次性为不同变量赋予一个值

5.3.4其他赋值方法

5.4顺序结构

5.5布尔表达式

将其他形式转为布尔型

5.6选择结构与语句

5.6.1选择结构（分支结构）

5.6.2 if语句

if 表达式1：每个条件后都要使用冒号

语句1 使用缩进划分语句块，相同缩进数的语句在一起组成一个语句块

elif表达式 2：没有switch。。。case语句

语句2

.......

5.6.3 if嵌套

5.6.4多重条件判断

用and和or

5.7循环控制语句

5.7.1 while语句

while 判断条件：

语句注意冒号和缩进

5.7.2 for语句

for 变量 in 列表：

语句

else ：

语句

break——跳出循环

5.7.3continue语句和else语句

使用continue语句，python将跳过当前循环块中的剩余语句，继续进行下一轮循环

5.7.4pass语句

pass是主语句，主要为了保持程序结构的完整性。

pass不做任何事情，一般用于占位语句。

range用法：

使用anger会生成数列
可以指定区间值
可以指定增量
利用range和len遍历

第六章函数

6.1函数优势

函数指的是一组语句的集合，通过函数名封装起来，

6.2调用内置函数

abs（x）返回x的绝对值
chr（i）i是ASCII码0~255，chr（i）返回i的单字符字符串

······

6.3定义函数

函数定义方法使用def关键字

语法格式：

def 函数名称（参数1，参数2···）：

“文件字符串”————可以省略，用来作为描述此函数的字符串

<语句>

6.4函数的参数

python的参数传递都是使用传址调用的方式。将该参数的内存地址传过去，若参数在函数内被更改，则会影响到原有的参数。

参数的数据类型剋是模块、类、实例或者其他函数，用户不必在参数内设置参数的数据类型。

6.4.1必须参数

要求用户必须以正确的顺序传入函数。调用时的数量必须和声明时的一样，设置函数的参数时，需依照他们的位置排列顺序。

6.4.2关键字参数

用户可以直接设置参数的名称及其默认值，这种类型的参数属于关键字参数。

在设置函数的参数时，可以不依照他们的位置排列顺序，python解释器能够用参数名匹配参数值。

6.4.3默认参数

调用函数时，若没有传递参数，会使用默认参数值。

6.4.4可变参数

如果用户在声明参数时不能确定需要使用多少个参数，就是用可变参数。

基本语法：

def functionname（[formal_args,]*var_args_tuplr）:

“函数_文档字符串”

fuction_suite

return[expression]

加了星号*的变量名会存放所有未命名的变量参数。如果在函数调用时灭有指定参数，他就是一个空元组。用户也可以不向函数传递未命名的变量。

**arg代表一个字典对象

6.5有返回值的函数和无返回值的函数

不带参数值的return语句返回none

函数的返回值可以是一个表达式

返回值可以是多个 return x，y

6.6形参和实参

形式参数：函数定义时出现的参数

实际参数：函数调用时给出的参数

发生函数调用时，实参的值会传递给形参

6.7变量的作用域

函数之外定义的变量叫做全局变量

这里的x是一个全局变量

当用户在函数内定义的变量名称与全局变量名称相同时，函数内定义的变量不会改变全局变量的值。因为函数内定义的变量属于局部命名空间，而全局变量则属于全局命名空间。

如果要在函数内改变全局变量的值，就必须使用global关键字。

6.8返回函数

函数不仅可以作为其他函数的参数，还可以作为其他函数的返回结果。

如果在一个内部函数里对外部作用域（不是全局作用域）的变量进行引用，内部函数就成为闭包。

6.9递归函数

如果一个函数在调用时直接或间接地调用了自身，就称为函数的递归调用，该函数为递归函数。

6.9.1使用递归函数

6.9.2使用递归函数解决汉诺塔问题

6.9.3防止栈溢出

使用递归函数需要防止栈溢出。在计算机中，函数调用是通过栈这种数据结构实现的。进入一个函数调用，就加一层栈帧，当函数返回，就减一层栈帧。栈的大小不是无限的，会产生栈溢出。

解决栈溢出的方法是通过尾递归优化：即在函数返回时调用函数本身。

6.10匿名函数

所谓匿名，即不再使用def语句这样的标准形式定义一个函数。python用lambda创建一个匿名函数。

冒号前面是参数（可以有多个）用逗号隔开冒号右边的返回值

6.11偏函数

通过设置参数的默认值，可以降低函数调用的难度。

functools.partial就是帮助用户创建偏函数的

6.12函数的内置属性和命名空间

6.12输入和输出函数

input函数：从标准输入读入一行文本

print（）函数：可以输出格式化的数据

实现不换行输出，变量末尾加上end=“”

类与对象

面向对象的基本概念，面向对象的三个重要特征（封装性、继承性、多态性）声明创建类和对象的方法

7.1理解面向对象程序设计

7.1.1什么是对象

对象是面向对象技术的核心。

对象是类的实例化，对象分为静态特征和动态特征两种。静态特征指对象的外观、性质、属性等。动态特征指对象具有的功能行为等。

人们将对象的静态特征抽象为属性，用数据来描述，在python中称之为变量。

将对象的动态特征抽象为行为，用一组代码来表示，完成对数据的操作，在python中称之为方法

一个对象由一组属性和一系列对属性进行操作的方法构成。

在python中，包含内置对象和自定义对象。

7.1.2面向对象的特征

面向对象方法（object-oriented method）是一种把面向对象的思想应用于软件开发过程中指导开发活动的系统方法。

对象是由数据和容许的操作组成的封装体，与客观实体有着直接对应的关系。

一个对象类定义了具有相似性质的一组对象，继承性是对具有层次关系的类的属性和操作进行共享的一种方式。

封装性：数据仅能通过一组接口函数来存取，经过封装的数据能够确保信息的隐秘性。

继承性：通过继承的特性，衍生类继承了其基础类的成员变量与类方法。衍生类也叫做次类或子类，基础类叫做父类。

多态性：多态允许一个函数有多种不同的接口。依照调用函数时使用的参数，类指导使用哪一种接口。python使用动态类型与后期绑定实现多态功能。

7.1.3什么是类

将具有相同属性及相同行为的一组对象称为类。类是由使用封装的数据及操作这些数据的接口函数组成的一群对象的集合。创建对象时所使用的模板。

7.2类的定义

python使用关键字class来定义类。

语法格式：

class <Classname>：

‘类的帮助信息’

class_suite #类体

7.3类的构造方法和内置属性

7.4类实例

类实例是一个python对象，它是使用类所创建的对象。

7.4.1创建类实例

只需要指定变量与类名称即可。

例如： f是一个类实例变量，注意类名称之后须加上小括号。

init要两个下划线

这个类的构造方法中，设置name，city与price的默认值都是none

创建类时，可以不声明属性，等到创建类的实例后，再动态创建类的属性。

7.4.2类实例的内置属性

obj._ _dict_ _：类实例内的属性是以字典对象的方式存储的。_dict_属性为该字典对象的值。
obj._ _class_ _:_ _class_ _属性返回创建此类实例所用的类名称。

7.5类的内置方法（开头结尾都是双下划线字符）

7.6重载运算符

重载运算符	函数	说明
_add_(a,b)	add(a,b)	返回a+b，a与b是数字
_sub_(a,b)	sub(a,b)	返回a-b
_mul_(a,b)	mul(a,b)	返回a*b
_mod_(a,b)	mod(a,b)	返回a%b
_neg_(a)	neg(a)	返回-a
_pos_(a)	pos(a)	返回+a
_abs_(a)	abs(a)	返回a的绝对值
_inv_(a)	inv(a)	返回a的二进制码的相反是。如果原来位是1，那么其结果为0
_invert_(a)	invert(a)	与inv（a）相同
_lshift_(a,b)	lshift(a,b)	返回a左移b位的值
_rshift_(a,b)	rshift(a,b)	返回a右移b位的值

7.7类的继承

所谓类的继承，就是新类继承旧类的属性与方法，这种行为成为派生子类。

继承的新类成为派生类，被继承的旧类成为基类。

当用户创建派生类后，就可以在派生类内新增或改写基类的任何方法。

语法：

class<类名称>[(基类1，基类2····)]：

[“文件字符串”]

<语句>

一个衍生类可以同时继承自多个基类，多个基类之间用逗号（，）隔开。

1.派生类的构造方法

基类

创建Student类的派生类

派生类的构造方法必须调用基础类的构造方法，并使用完整的基类名称。

Student.__init__(self,name,sex,phone)中的self参数，用来告诉基类现在调用的是哪一个派生类。

创建一个派生类person的实例变量

2.名称空间的搜索顺序

当用户在类内编写函数时，要记得类函数名称空间的搜索顺序是：类的实例➡类➡基类。

下面定义三个类：ABC。B继承自A，C继承自B。ABC三个类都有一个相同名称的函数—printName（）

类的多继承

python同样有限地支持多继承形式

7.8类的多态

类的多态指的是：类可以有多个名称相同，参数类型却不同的函数。

C++中将多态成为方法重载，允许类内有多个名称相同，参数却不同的函数存在。python却不允许这么做，如果用户在python的类内声明多个名称相同，参数却不同的函数，那么python会使用类内最后一个声明的函数。

上面示例中，调用myClass类中的handle函数时，python会使用有三个参数的函数handle（self，x，y，z）。因此当只提供一个参数时会报错。

解决方法如下，利用handle（）函数的参数数目，来决定调用类中的哪一个函数

7.9类的封装

所谓类的封装，就是指类将其属性（变量与方法）封装在该类中，只有该类中的成员才可以使用该类中的其他成员。这种被封装的变量与方法，成为该类的私有变量与私有方法。

如果属性名称的第一个字符是单下划线，那么该属性视为类的内部变量，外面的变量不可以引用该属性。

如果属性名称的前两个字符都是单下划线，那么在编译时属性名称attributeName会被改成_className_attributeName，className是该类的名称。由于属性名称之前加上了类的名称，因此与类中原有的属性名称有差异。

7.10python的垃圾回收机制

python使用引用计数这一简单技术来跟踪和回收垃圾。在python内部有一个跟踪变量，记录着所用使用中的对象各有多少引用，称为一个引用计数器。

当对象被创建时，就同时创建一个引用计数，当这个对象不再被需要，其引用技术变为0时，就被垃圾回收。解释器在适当的时机将垃圾对象占用的内存回收。

7.11面向对象中常用的技术术语及其含义

类：用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或实例变量用于处理类及其实例对象的相关数据。
方法重写：如果从父类继承的方法不能满足子类的需求，那么可以对其进行改写，这个过程叫方法的覆盖，也称为方法的重写。
实例变量：定义在方法中的变量只作用于当前实例的类。
继承：即一个派生类继承基类的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

程序调试和异常处理

8.1什么是异常

bug

8.2常见的错误和异常

缺少冒号引起错误
赋值运算符=与比较运算符==
代码结构的缩进错误
修改元组和字符串的值是错误
连接字符串和非字符串
字符串首尾忘记加冒号
变量或函数名拼写错误
引用超过列表的最大索引值
使用关键字作为变量名
变量没有初始值时使用增值操作符
误用自增++和自减--操作符
忘记为方法的第一个参数添加self参数

8.3熟悉内置异常

8.4使用try···except语句处理异常

语法格式：

try：

<语句>

except [ < 异常的名称 > [ , <异常类的实例变量名称>] ]

<异常的处理语句>

[else:

<没有异常产生时的处理语句 > ]

中括号内的语句 [ ] 表示是可以省略的。使用try····except语句的原理如下：

执行try子句，在关键字try和关键字except之间的语句。
如果没有异常发生，就忽略except语句，try子句执行后结束。
如果执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果二厂的类型和except之后的名称相符，那么对应的except子句将被执行。
如果一个异常没有与任何的except匹配，那么这个异常将会传递到上层的try中。

8.5全捕捉

下面使用一个expect语句处理所有异常

8.6异常中的else

下面使用else语句处理没有异常时的情况。注意：使用else语句时一定要有except语句。

没有异常时会执行else语句

8.7异常中的pass

用户可以在except语句内使用pass语句来忽略所发生的异常。

可见sm的值时可转换的元素100，200的和。上述代码中的int（）函数将字符串转换为整数。当int（）函数无法将字符串转换为整数时，就会输出ValueError异常，在except语句中使用pass语句可以忽略所发生的ValueError异常。

8.8异常类的实例

每当有一个异常发生，该异常类就会创建一个实例。每一个异常类实例都有一个args属性。srgs属性是一个元组格式，这个元组格式可能只包含错误信息的字符串（1-tuple），也可能包含连个以上的元素。

在except语句的右方加一个inst变量，它是一个异常类实例。当IndexError异常发生时，inst实例就会被创建。inst实例的args属性值是一个元组，输出该元组的第一个字符串就是IndexError的错误信息：list index out of range。

异常类实例的args属性可能包含两个以上的元素。

下面的示例会输出File Not FoundError的异常，args属性的tuple格式是“错误号码，错误信息字符串，[文件名称]”，文件名称有可能不出现。

下面的示例会输出SyntaxError的异常，args属性的元组格式是“错误信息字符串，（文件名称，行号，行内偏移值，文字）”

使用下面的方式，可以将python解释器提供的错误信息字符串输出。

8.9清楚异常

try...finally语句可以当作清除异常使用，不管try语句内是否运行失败，finally语句一定会被运行。注意：except和finally语句不能放在一起使用。

8.10抛出异常

当遇到异常情况，用户可通过抛出异常做相应地处理.

8.10.1 raise语句

python使用raise语句抛出一个指定的异常。

8.10.2 结束解释器的运行

用户可以通过输入SystemExit异常强制结束python解释器的运行。

8.10.3 离开嵌套循环

break语句可以离开最内层的循环，raise语句可以离开嵌套循环。

8.11自定义异常

8.12程序调试

8.12.1使用assert语句：可以帮助用户检测程序代码中的错误

语法：

assert < 测试码 > [ , 参数 ]

测试码是一段返回True或False的程序代码。若测试码返回True，则继续运行后面的程序代码；若测试码返回False，assert语句则会输出一个AssertionError异常，并输出assert语句的 [ 参数 ] 作为错误信息字符串。

8.12.2使用__debug__内置变量

python解释器有一个内置变量__debug__，在正常情况下值为True

下面的示例检测函数的参数类型是否是字符串，如果函数的参数类型不是字符串，就输出一个AssertionError异常。

模块与类库

当一个程序比较简单时，将程序代码写入一个文件即可。随着项目复杂度的增加，需要将代码写入不同的文件中，这里不同的文件即不同的模块。

利用模块方式组织代码便于管理和维护项目代码。

9.1什么是模块？

模块（Module）是由一组类、函数与变量所组成的，这些类等都存储在文本文件中。

模块可能是使用C或是python编写的。模块文件的扩产名可能是.py（原始文本文件）

或.pic（编译过的.py文件）。在python目录的Lib文件夹中可以找到这些模块的.py文件。

在使用某个模块之前，必须先试用import语句加载这个模块，语法格式如下：

import <模块名称>

使用一个import加载多个模块时，模块名称之间以逗号（，）隔开。

例：import os,says,types

9.2 什么是类库

类库是由一组相同文件夹的模块所组成的，类库的名称必须是sys.path所列的文件夹的子文件夹。

每一个类库的文件夹中必须至少有一个__init__.py文件。

类库可以包含子类库，子类库位于该文件夹下，子类库的文件夹中也必须至少有一个__init__.py文件。

用户可以使用下面的语法加载类库中的模块。

import 类库.模块

例如加载xml类库中的dom模块：》》》import xml.dos

9.3模块和类库的基本操作

1.将模块改名，语法如下：
import 模块 as 新名称例：import sys as newsys

或

from 模块 import 函数 as 新名称

2.模块的内置办法

（1）m.__dict__：显示模块的字典

（2）m.__doc__：显示模块的文件字符串

（3）m.__name__：显示模块的名称

（4）m.__file__：显示模块的完整文件路径

3.删除模块

用户可以使用del语句删除加载的模块，被删除的模块即从内存中清除。

del types

9.4模块的名称空间

加载string模块，python会配置一个string命名空间。

用户可以在该模块的命名空间内找到所有属性。

》〉import string

》〉print（string.capwords（“客从远方来”））

用户可以使用下面语法加载模块中的某个函数，而不会加载整个模块。注意：若属性名称的第一个字符是下划线（_）那么就不能使用此语法来加载。

from 模块 import 函数

例如：from string import capwords

print（capwords（“客从远方来”））

使用此方法时，就无法使用string模块的其他函数。

若用户曾自己定义过capwords（）函数，from string import capwords加载的capwprds（）函数就会覆盖用户自定义的capwords（）函数。

用户可以使用下面的语法来加载模块内的所有属性：

from 模块 import *

用户可以使用下面的语法来加载类库中的某个字类库、模块、类、函数或变量等。

from 类库 import 对象

当用户使用如下方式加载类库中的所有模块时，并不能保证类库中的所有模块都会被加载：

from 类库 import *

必须在该类库的__init__.py文件中设置一个程序代码：

__all__=[”模块1”,”模块2”,”模块3”,….]

其中__all__变量是一个列表对象，包含需要被加载的模块名称。

如果使用：from 类库.字类库.模块 import *

python保证类库的__init__.py文件会最先加载，然后加载字类库的__init__.py文件，最后才会加载模块。

9.5自定义模块

如果想将自定义的python源文件作为模块导入，就可以使用import语句。当解释器遇到import语句时，会在当前路径下搜索该模块文件

放在同一根目录下

9.6将模块打包

如果先要使用一个存放在其他目录的python程序，或者是其它系统的python程序，就可以将这些python程序制作成一个安装包，然后安装到本地，安装的位置可以选择sys.path中的任何一个目录。这样用户就可以在任何想要使用该python程序的地方直接使用import导入了。

例：

打包的模块mm.py

在其同名根目录下新建一个文件setup.py

以管理员身份运行命令提示符，进入mm.py文件的目录，执行下面命令

运行后在mm.py文件的目录中多出一个dist的文件，进入文件夹发现一个压缩包

在需要加载mm模块的机器上将压缩文件解压，以管理员身份于性命令提示符，进入解压的目录，执行下面的命令可自动安装mm模块

安装完成之后即可加载mm模块。

9.7熟悉运行期服务模块

sys

types

operator

traceback

linecache

pickle

shelve

copy

marshall

warnings

imp

code

codeop

pprint

site

__builtin__

__main__

9.8掌握字符串处理模块

日期和时间

10.1认识日期和时间

10.1.1时间戳

时间戳使之格林威治时间1970年1月1日00时00分00秒，即北京时间1970年1月1日08时00分00秒起至现在的总秒数。

import time
print(time.time())

10.1.2 struct_time元组

struct_time元组共有9组数字处理时间，即年、月、日、时、分、秒、一年中第几周、第几天、是否为夏令时。

使用localtime可以将当前时间戳转化为时间元组

t=time.time()
print(time.localtime(t))

struct_time元组的九个属性：

tt = time.localtime(t)
for i in range(9):
print(tt[i])

tm_year

tm_mon

tm_mady

tm_hour

tm_min

tm_sec

tm_wday

tm_yday （1~366，一年中的第几天）

tm_isdst (值为1是夏令时，为0不是夏令时)

10.1.3格式化时间：使用time模块的strftime（）函数

time . strftime ( format [ , tuple ] ) :将日期和时间元组转换为一个格式为format的字符串

综合应用时间格式化符号

print(time.strftime('%Y',time.localtime())) #获取完整年份
print(time.strftime('%y',time.localtime())) #获取简写年份
print(time.strftime('%m',time.localtime())) #获取月
print(time.strftime('%d',time.localtime())) #获取日
print(time.strftime('%Y-%m-%d',time.localtime())) #获取年-月-日
print(time.strftime('%H',time.localtime())) #获取时，24小时制
print(time.strftime('%I',time.localtime())) #获取时，12小时制
print(time.strftime('%M',time.localtime())) #获取分
print(time.strftime('%S',time.localtime())) #获取秒
print(time.strftime('%H:%M:%S',time.localtime())) #获取时:分:秒
print(time.strftime('%a',time.localtime())) #本地简化星期
print(time.strftime('%A',time.localtime())) #本地完整星期
print(time.strftime('%b',time.localtime())) #本地简化月份
print(time.strftime('%B',time.localtime())) #本地完整月份
print(time.strftime('%c',time.localtime())) #本地日期和时间表示
print(time.strftime('%j',time.localtime())) #一年中的第几天
print(time.strftime('%p',time.localtime())) #P.M等价符
print(time.strftime('%U',time.localtime())) #一年中的第几个星期，星期天为星期的开始
print(time.strftime('%w',time.localtime())) #星期几,星期天为星期的开始
print(time.strftime('%W',time.localtime())) #一年中的第几个星期，星期一为星期的开始
print(time.strftime('%x',time.localtime())) #本地日期表示
print(time.strftime('%X',time.localtime())) #本地时间表示
print(time.strftime('%Z',time.localtime())) #当前时区
print(time.strftime('%%',time.localtime())) #输出%本身
print(time.strftime('%Y-%m-%d %H:%M:%S %w-%Z',time.localtime()))

10.2日历模块

Calendar模块有很多方法处理日历

calendar . month （year ， month ， w=2 ， l=1）

返回一个多行字符串格式的year年month月历。两行标题。一周一行。

每行间隔宽度为w字符每行长度为7*w+6.l是每星期的行数。（wl可以省略）

calendar . isleap（year）

如果year是闰年就返回True，否则返回False。

calendar . leapdays（y1，y2）

返回y1、y2两年之间的闰年总数。

calendar . monthrange（year，month）

返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日），范围内的日子都由该月第几日表示，从1开始。

calendar . monthcalendar（year，month）

返回一个整数的单层嵌套列表。每个子列表装载代表1个星期的整数。year年month月外的日子都设为0，范围内的日子都由该月第几日表示，从1开始。

import calendar
#返回指定年的某月
def get_month(year, month):
    return calendar.month(year, month)
#返回指定年的日历
def get_calendar(year):
    return calendar.calendar(year)
#判断某一年是否为闰年，如果是，返回True，如果不是，则返回False
def is_leap(year):
    return calendar.isleap(year)
#返回某个月的weekday的第一天和这个月的所有天数
def get_month_range(year, month):
    return calendar.monthrange(year, month)
#返回某个月以每一周为元素的序列
def get_month_calendar(year, month):
    return calendar.monthcalendar(year, month)
def main():
    year = 2021
    month = 9
    test_month = get_month(year, month)
    print(test_month)
    print('#' * 50)
    #print(get_calendar(year))
    print('{0}这一年是否为闰年？：{1}'.format(year, is_leap(year)))
    print(get_month_range(year, month))
    print(get_month_calendar(year, month))
if __name__ == '__main__':
    main()

10.3 time模块

讲解time模块中一些常见的函数。

10.4 datetime模块

datetime模块定义了5个类：

date：表示日期的类，常用的属性有year、month和day
time：表示时间的类，常用的属性有hour、minute、second、microsecond和tzinfo
datetime：表示日期和时间的组合，常用的属性有year、month和dayhour、minute、second、microsecond和tzinfo。
timedelta：表示时间间隔类，即两个时间点之间的长度。
tzinfo：表示时区信息类。

10.4.1 date类

import datetime
a=datetime.date.today()#返回当前本地时间
print(a)
print(a.year)
print(a.month)
print(a.day)

用于比较日期大小相等的方法

a . _ _eq_ _(b):判断两个日期是否相等。
a . _ _ge_ _(b):判断时间a是否大于等于时间b。
a . _ _gt_ _(b):判断时间a是否都大于时间b。
a . _ _le_ _(b):判断时间a是否小于等于时间b。
a . _ _lt_ _(b):判断时间a是否小于时间b。
a . _ _ne_ _(b):判断两个日期是否不相等。

import datetime
a = datetime.date.today()
b = datetime.date(2001,4,2)
print(a.__eq__(b))
print(a.__ge__(b))
print(a.__gt__(b))
print(a.__le__(b))
print(a.__lt__(b))
print(a.__ne__(b))

计算两个日期相差多少天

x . _ _sub_ _(y)等价于x-y
x . _ _rsub_ _(y)等价于y-x

print(a.__sub__(b))
print(a.__rsub__(b))

10.4.2 time类

time类由小时、分钟、秒、毫秒、时区组成。

import datetime
a = datetime.time(11,10,32,888)
print(a)
print(a.hour)
print(a.minute)
print(a.second)
print(a.microsecond)
print(a.tzinfo)

10.4.3 datetime类

datetime类可以看作date类和time类的合体，属性包括年到秒、毫秒、时区

import datetime
a = datetime.datetime.now() #now（）返回当前日期的datetime对象
print(a)
print(a.time()) #time()返回datetime对象的时间部分
print(a.utctimetuple()) #返回UTC时间元组
b = datetime.datetime.utcnow() #返回当前日期时间的UTC datetime对象
print(b)

10.4.4 timedelta类

用于计算两个datetime对象的差值。包含以下属性：

days天数
microseconde微秒数，大于0小于1秒
seconds秒数，大于0小于1天

import datetime
now = datetime.datetime.now()
delta = datetime.timedelta(days=100)
print(delta)
newtime = now-delta
print(newtime)

10.4.5 tzinfo类

关于时区的类。是一个抽象类，不能被实例化。

from datetime import datetime, tzinfo,timedelta
class UTC(tzinfo):
    """UTC"""
    def __init__(self,offset = 0):
        self._offset = offset
    def utcoffset(self, dt):
        return timedelta(hours=self._offset)
    def tzname(self, dt):
        return "UTC +%s" % self._offset
    def dst(self, dt):
        return timedelta(hours=self._offset)
#北京时间
beijing = datetime(2018,11,11,0,0,0,tzinfo = UTC(8))
#曼谷时间
bangkok = datetime(2018,11,11,0,0,0,tzinfo = UTC(7))
#北京时间转成曼谷时间
beijing.astimezone(UTC(7))
#计算时间差时也会考虑时区的问题
timespan = beijing -bangkok
print(timespan)

10.5日期和时间的常用操作

获取当前时间

import datetime
now =datetime.datetime.now()
today = datetime.datetime.today()
print(datetime.datetime.now())
print(today)
print(now.date())
print(now.time())

（2）获取上个月第一天和最后一天的日期

import datetime
today = datetime.datetime.today()
mlastday = datetime.date(today.year,today.month,1)-datetime.timedelta(1)
print(mlastday)
mfirstday = datetime.date(mlastday.year,mlastday.month,1)
print(mfirstday)

（3）获取时间差

import datetime
start_time = datetime.datetime.now()
end_time = datetime.datetime.now()
print((end_time-start_time).seconds)

计算当前时间向后10个小时的时间。

import datetime
d1 = datetime.datetime.now()
d2 = d1 + datetime.timedelta(hours=10)
print(d2)

计算上周一和周日的日期。

import datetime
today = datetime.datetime.today()
today_weekday = today.isoweekday()
last_sunday = today - datetime.timedelta(days = today_weekday)
last_monday = last_sunday - datetime.timedelta(days=6)

print(today_weekday)
print(last_sunday)
print(last_monday)

计算指定日期当月最后一天的日期和本月天数。

计算指定日期下个月当天的日期

迭代器、生成器和装饰器

迭代是访问结合元素的一种方法。迭代器是一个可以记住遍历位置的对象，在遍历字符串、列表或元组对象时非常有用。

生成器是函数中包含yield语句的一类特殊的函数。

修饰器的灵活性很强，可以为一个对象添加新的功能，或者给函数插入相关的功能。

11.1迭代器

11.1.1什么是可迭代对象

若给定一个list或tuple，可以通过for循环来遍历这个list或tuple，这种遍历称为迭代（iteration），被遍历的list或tuple称为可迭代对象。除了list或tuple外，还有可迭代对象如str、set、tuple等。

x = [100,200,300]
y = iter(x)
z = iter(y)
print(next(y))
print(next(y))
print(next(z))
print(type(x))
print(type(y))

这里x是一个可迭代对象。y和z是两个相互独立的迭代器，迭代器内部持有一个状态，该状态用于记录当前迭代所在的位置，以便下次迭代时获取正确的元素

11.1.1什么是迭代器

迭代器是一个可以记住遍历位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。

迭代器有两个基本方法：

iter（）：用于创建迭代器对象。

next（）：用于遍历对现代个元素。

list = ["apple","tube","dove","pasture"]
y = iter(list)
print(next(y))
print(next(y))
print(next(y))
print(next(y))
# next(y)#超过遍历的范围会报错

迭代器对象可以使用常规的for语句进行遍历：

list = ["apple","tube","dove","pasture"]
y = iter(list)
for a in y:
print(a,end=" ")

也可以在while语句中进行遍历。

import sys      #引入sys模块
list = ["dove","pasture","ulimate","herb"]
y = iter(list)
while True:
    try:
        print(next(y))
    except StopIteration:
        sys.exit()

11.1.3自定义迭代器

通过定义一个实现迭代器协议方法的类，即可自定义一个迭代器。

class MyIterator:   #自定义迭代器MyIterator

    def __init__(self,x=3,xmax=300):    #定义构造方法，初始化实例属性
        self.__mul,self.__x = x,x
        self.__xmax = xmax

    def __iter__(self): #定义迭代器的协议方法，返回类自身
        return self

    def __next__(self): #定义迭代器协议方法
        if self.__x and self.__x != 1:
            self.__mul *= self.__x
            if self.__mul <= self.__xmax:
                return self.__mul   #返回值
            else:
                raise StopIteration #引发StopIteration错误
        else:
            raise StopIteration

if __name__ == '__main__':
    myiter = MyIterator()   #实例化迭代器
    for i in myiter:    #遍历并输出值
        print('迭代的数据元素为：',i)

在其构造方法中，初始化了两个私有变量x=3和xmax=300，用于产生序列和控制序列产生的最大值。该迭代器总是返回所给数的n次方，但其值不能超过xmax，否则会引发StopIteration错误，并结束迭代。最后实例化迭代器，并遍历迭代器的值序列并进行输出。

11.1.4内置迭代器工具

在itertools模块中，也提供了丰富的迭代器工具itertools模块包含创建有效迭代器的函数，可用各种方式对数据进行循环操作，此模块中的所有函数返回的迭代器都可以与for循环语句及其他包含迭代器的函数联合使用。asdawd

itertools模块中提供的迭代器工具函数主要由三类：

1.无限迭代器

常用的无限迭代器函数如下:

(1)count(start,[step]):从start开始,以step为步行计数迭代.start默认为0,step默认为.

import itertools
ns = itertools.count(10,20)
for n in ns:
print(n)

嗷嗷迭,停不下来.

(2)cycle(terable):无限循环迭代terable。terable为可迭代对象,该函数的作用是保存迭代对象每个元素的副本,无限地重复返回每个元素的副本.

import itertools
ns = itertools.cycle(["lxy","lyt"])
for n in ns:
print(n)

(3)repeat(object,[n]):循环迭代object,次数为n,若不指定n则无限迭代.

import itertools
ns = itertools.repeat(["lxy","lyt"],10)
for n in ns:
print(n)

2.迭代短序列

(1)chain(*iterables):将多个迭代器作为参数,但只返回单个迭代器.

*iterables是一个或多个可迭代序列

import itertools
ns = itertools.chain(["lxy","lyt"],["李欣宇",'李昀潼'])
for n in ns:
print(n)

(2)compress(data,selectors):根据selector的值选择迭代data序列中的值,若selectors的值为真则输出data中的值.

import itertools
ns = itertools.compress(["lxy","lyt","李欣宇",'love','李昀潼'],[True,False,0,1,5])
for n in ns:
print(n)

组合迭代序列

(1)product(*iterables):迭代排列出所有的排列.

import itertools
ns = itertools.product(["lxy","lyt","李欣宇"],['love','李昀潼'])
for n in ns:
print(n)

(2)permutations(p,r):迭代序列中r个元素的排列.

import itertools
ns = itertools.permutations('lxyt',3)
for n in ns:
print(n)

(3)combinations(p,r):迭代序列中r个元素的组合.

import itertools
ns = itertools.combinations('lxyt',3)
for n in ns:
print(n)

11.2生成器

使用生成器可以生成一个值的序列用于迭代,并且这个值的序列不是一次生成的,而是使用一个再生成一个,可以使程序节约大量内存.

使用yield的函数被称为生成器,与普通函数不同,生成器将返回一个迭代器的函数,并且生成器只能用于迭代操作,因此说生成器是一个特殊的迭代器.

在调用生成器运行的过程中,每次遇到yield时函数就会暂停,并保存当前所有的运行信息,返回yield的值.在下一次执行next()方法时,会从当前位置继续运行.

list =[[1,2],[3,4],[5,6],[7,8]] #生成一个嵌套列表
def qtlb(list): #创建生成器
    for aa in list:
        for bb in aa:
            yield bb

for nn in qtlb(list):
    print(nn)

def myYield(n):                      #定义一个生成器（函数）
    while n>0:
        print("开始生成...:",end=' ')
        yield n                      #yield语句，用于返回给调用者其后表达式的值
        print("完成一次...:")
        n -= 1
if __name__ == '__main__':
    for i in myYield(6):                #yield语句，用于返回给调用者其后表达式的值
        print("遍历得到的值：",i,end=' ')
    print()
    my_yield = myYield(3)
    print('已经实例化生成器对象',end=' ')
    my_yield.__next__()
    print('第二次调用__next__()方法：')
    my_yield.__next__()

文件与文件系统

11.3 装饰器

装饰器是一种增加函数或类的功能的方法,可以快速地给不同的函数或类插入相同的功能.

11.3.1什么是装饰器

装饰器的语法是在函数或类前添加”@”符号;

例如:用装饰器修饰函数或类就是用”@装饰器名称”放在函数或类的定义行之前.

@disp_ff #装饰器名称disp_ff
def dd_ff():
pass

11.3.2装饰函数

def aa(fun):                     #定义一个装饰器aa
    def ww(*args,**kwargs):      #定义装饰器函数
        print('开始运行...')
        fun(*args,**kwargs)      #调用被装饰函数
        print('运行结束！')
    return ww                    #返回装饰器函数
@aa                             #装饰函数语句
def dd(x):                      #定义普通函数，被装饰器装饰
    a = []
    for i in range(x):
        a.append(i)
    print(a)
@aa                            #定义普通函数，被装饰器装饰
def hh(n):
    print('最喜欢的水果是： ',n)
if __name__ == '__main__':
    dd(6)
    print()
    hh('苹果')

11.3.3修饰类

def aa(myclass):                                #定义类装饰器
    class InnerClass:                           #定义内嵌类
        def __init__(self,c=100):
            self.c = 100
            self.wrapper = myclass()             #实例化被装饰类

        def pp(self):
            self.wrapper.pp()
            print('c的值是:',self.c)
    return InnerClass                             #返回新定义的类
@aa                                           #修饰器修饰类
class cc:
    def __init__(self,a=100,b=100):
        self.a = a
         self.b =b
    def pp(self):
        print('a的值是:',self.a)
        print('b的值是:',self.b)
if __name__ == '__main__':
    coor = cc()                   #实例化被修饰的类
    coor.pp()                     #调用方法pp()

第十二章文件与文件系统

12.1打开文件

f = open("test.txt","w") #打开文件,w:以写入的模式,若没该该文件则新建

参数名称	说明
r	默认方式,以读方式代开文件,文件的指针放在开头
rb	默认方式,只读,二进制格式打开文件,文件的指针放在开头
r+	读写方式打开文件,文件指针在开头.
rb+	读写方式,二进制格式,文件指针在开头.
w	写入方式,若该文件已存在则覆盖,不存在则新建
wb	二进制格式,同w
w+	读写方式,同w
wb+	读写,二进制格式,同w
a	追加打开文件,若文件存在,文件指针放在文件结尾;不存在则新建
ab	二进制同a
a+	读写,同a
ab+	同ab

12.2读取文件

打开文件后,可用python提供的方法读取文件.

12.2.2读取文件read()方法

read()方法用于从文件读取制定的字符数,若为给定或为负,则读取所有.

语法: 文件名.read(返回字符数)

12.2.2逐行读取readline()方法

语法: 文件名.readline(返回字符数)

12.2.3返回文件各行内容的列表readlines()方法

语法: 文件名.readlines(返回字符数)

f = open("test.txt","r")
print('文件名为:',f.name)
for line in f.readlines():
line = line.strip() #去掉每行头尾空白
print("读取的内容为:%s"%(line))

f.close()

12.2.4放回文件的当前位置tell()方法

print(f.tell())

12.2.5截断文件truncate()方法

语法: 文件名.truncate(size)

size为可选参数,若指定size则表示截断文件为size字符;未指定则重置到当前位置

12.2.6设置文件当前位置seek()方法

seek()方法用于移动文件读取指针到指定位置.

语法: 文件名.seek(offset,whence)

offset表示开始的偏移量,即需要移动偏移的字节数.

whence为可选参数,表示从哪个位置开始偏移,默认值为0,若值为1则从当前位置算起,若值为2则从文件末尾算起.

12.3写入文件

12.3.1将字符串写入到文件

write()方法用于向文件中写入指定字符串.在文件关闭前或缓冲区刷新前,字符串内容存储在缓冲区中,此时在文件夹中看不到写入的内容.

语法: 文件名.write([需要写入的字符串])

12.3.2写入多行writelines()

可以向文件写入一个序列字符串列表,若要换行,则加入每行的换行符.

12.3.3修改文件内容

使用writelines()方法还可以修改文件的内容.

f = open(r"iltt.txt")

lines=f.readlines()
f.close()
lines[0]="lxy\n"
f = open(r"iltt.txt","w")
f.writelines(lines)
f.close()

12.3.4附加到文件

先把要加的文件读取,

然后把内容write到另一个文件的结尾处(用”a”)

12.4关闭和刷新文件

12.4.1关闭文件

f.close()

12.4.2刷新文件

f.flush()用于刷新缓冲区,将缓冲区中的数据立刻写入文件,同时清空缓冲区,无须被动地等待缓冲区写入.

基于tkinter的GUI编程

13.1常用的python GUI

图形用户界面（Graphical User Interface）

13.2使用thinker创建GUI程序

后缀为pyw

带按钮的GUI

13.3认识tkinter的控件

控件名称	说明
Button	按钮控件，在程序中显示按钮
Cancas	画布空间，用来话图形，如线条或多边形
Checkbutton	多选框控件，用于在程序中提供多项选择看
Entry	输入控件，定义一个简单的文字输入字段。
Frame	框架空间，定义一个窗体，以作为其他控件的容器
Label	标签控件，定义一个文字或图片标签
Listbox	列表框控件，定义一个下拉方块
Menu	菜单空间，定义一个菜单栏，下拉菜单和弹出菜单
Menubutton	菜单按钮控件，用于显示菜单项
Radiobutton	单选按钮控件，定义一个单选按钮
Mseeage	消息控件，定义一个对话框
Scale	范维控件，定义一个滑动条，以帮助用户设置数值
Scrollbar	滑动条控件，定义一个滚动条
Text	文本控件，定义一个文本框
Toplevel	与Frame控件类似，可以作为其他控件的容器。但是此控件有自己打的最上层窗口，可以提供窗口管理接口。

颜色名称阐述
大小的测量单位

Button控件的文字与边框之间的水平距离为20像素；

共同属性

anchor：定义控件在窗口内的位置或文字信息在空间内的位置。可以是N、NE\E\SE\S\SW\W\NW或CENTRER。
background（bg）：定义控件的背景颜色，颜色值可以是表中的名称，也可以是’#rrggbb’形式的数字。用户可以使用background或bg。

下面示例定义一个背景颜色为绿色的文字标签，以及一个背景颜色为SystemHightlight的文字标签。

bitmap：定义显示在空间内的bitmap图片文件
borderwidth：定义控件的边框宽度，单位是像素。

command：当控件有特定的动作发生时，如单击按钮，此属性定义动作发生时所调用的python函数。
cursor：定义当鼠标指针移到控件上时，鼠标指针的类型。可使用的鼠标指针类型有crosshair、watch、xterm、fleur及arrow

font：如果控件支持标题文字，就可以使用此属性来定义标题文字的字体格式。

此属性是一个元组格式：（字体、大小、字体样式），字体样式可以是bold、italic、underline及overstrike。用户可以同时设置多个字体样式，中间以空白隔开。

foreground(fg):定义控件的前景(文字)颜色，颜色值可以是表中，也可以是#rrggbb形式的数字。可以使用foreground或fg。

height：如果Button，Label或Text的控件，此属性定义以字符数目为单位的高度。其他控件则是定义以像素为单位的高度。
width：如果Button，Label或Text的控件，此属性定义以字符数目为单位的宽度度。其他控件则是定义以像素为单位的宽度。

13.4 几何位置的设置

13.4.1 pack（）方法

（1）expand：让控件使用所有的剩下空间，窗口改变大小时，若expand=1，窗体会占满整个窗口剩余的空间。expand=0时则维持不变。

（2）fill：决定控件如何填满parcel的空间，可以是X、BOTH或NONE，此选项必须在expand=1时才有作用。X（Y）占满X（Y）方向的剩余空间，BOTH占满整个窗口的剩余空间，NONE窗口维持不变。

（3）ipadx，ipady：与fill选项共同使用，定义窗体内控件与窗体边界之间的距离。单位是像素，也可以是厘米、英寸等。

（4）

from tkinter import *
#主窗口
win = Tk()

#第一个窗体
frame1 = Frame(win, relief=RAISED, borderwidth=2)
#创建第一个frame控件，以作为窗体。此窗体的外形突起，边框厚度为2像素。
frame1.pack(side=TOP, fill=BOTH, ipadx=13, ipady=13, expand=0)
#此窗体在窗口的顶端（side=TOP），当窗体大小改变是，窗体本赢回占满整个窗口的剩余空间（fill=BOTH），但因设置expand=0，所以窗体维持不变。控件与窗体边界之间的水平和垂直距离是13像素。
Button(frame1, text="Button 1").pack(side=LEFT, padx=13, pady=13)
Button(frame1, text="Button 2").pack(side=LEFT, padx=13, pady=13)
Button(frame1, text="Button 3").pack(side=LEFT, padx=13, pady=13)
#在第一个窗体内创建三个按钮。这三个按钮从窗体的左边开始排列（side=LEFT），空间之间的水平距离是13像素，垂直距离是13像素。

#第二个窗体
frame2 = Frame(win, relief=RAISED, borderwidth=2)
#创建第二个frame控件，以作为窗体。此窗体的外形突起，边框厚度为2像素。
frame2.pack(side=BOTTOM, fill=NONE, ipadx="1c", ipady="1c", expand=1)
#此窗体在窗口的底端（side=BOTTOM），当窗口改变大小时，窗体不会占满整个窗口的剩余空间（fill=NONE）。控件与窗口边界之间的水平和垂直距离是1厘米。
Button(frame2, text="Button 4").pack(side=RIGHT, padx="1c", pady="1c")
Button(frame2, text="Button 5").pack(side=RIGHT, padx="1c", pady="1c")
Button(frame2, text="Button 6").pack(side=RIGHT, padx="1c", pady="1c")
#三个按钮从窗体的右边开始排列（side=GIRIGHT），空间之间的水平和垂直距离是1厘米。

#第三个事件窗口
frame3 = Frame(win, relief=RAISED, borderwidth=2)
#创建第三个frame控件，以作为窗体。此窗体的外形突起，边框厚度为2像素。
frame3.pack(side=LEFT, fill=X, ipadx="0.1i", ipady="0.1i", expand=1)
#此窗件在窗口的左边（side=LEFT），当篡改口改变大小时，窗体会占满整个窗口的剩余水平空间（fill=X），控件与窗口边界之间的水平和垂直距离是0.1英寸
Button(frame3, text="Button 7").pack(side=TOP, padx="0.1i", pady="0.1i")
Button(frame3, text="Button 8").pack(side=TOP, padx="0.1i", pady="0.1i")
Button(frame3, text="Button 9").pack(side=TOP, padx="0.1i", pady="0.1i")

#第四个窗体
frame4 = Frame(win, relief=RAISED, borderwidth=2)
frame4.pack(side=RIGHT, fill=Y, ipadx="13p", ipady="13p", expand=1)
Button(frame4, text="Button 10").pack(side=BOTTOM, padx="13p", pady="13p")
Button(frame4, text="Button 11").pack(side=BOTTOM, padx="13p", pady="13p")
Button(frame4, text="Button 12").pack(side=BOTTOM, padx="13p", pady="13p")

#开始窗口事件的循环
win.mainloop()

13.4.2 grid（）方法

将控件依照表格的行列方式，来放置在窗体或窗口内。

row：设置控件在表格的第几列
column：设置控件在表格的第几栏
columnspan：设置控件在表格中合并栏的数目
rowspan：设置控件在表格中合并列的数目。

from tkinter import *
#主窗口
win = Tk()

#创建窗体
frame = Frame(win, relief=RAISED, borderwidth=2)
frame.pack(side=TOP, fill=BOTH, ipadx=5, ipady=5, expand=1)

#创建按钮数组
for i in range(5):
for j in range(5):
Button(frame, text="(" + str(i)+","+str(j)+")").grid(row=i, column=j)
#创建一个按钮，按钮上的文字是（row，column）。str（i）是将数字类型的变量i转换为字符串类型。
#开始窗口的事件循环
win.mainloop()

13.4.3 place（）方法

设置控件在窗体或窗口内的绝对地址或相对地址。

anchor：定义空间在窗体或窗口内的方位，可以是N、NE、E、SE、S、SW、W、NW或CENTER。默认值是NW，表示在左上角方位。

13.5 tkinter事件

设置好事件处理例程（此函数为callback），就可以在控件内处理这些事件。

使用的语法如下：

def function(event):

...

widget.bind(“<event>”,function)

widget是tkinter控件的实例变量。

<event>是事件的名称。

function是事件处理例程。tkinter会传给事件处理例程一个event变量，此变量内包含事件发生时的x，y坐标（鼠标事件）及ASCII码（键盘事件）等。

13.5.1事件的属性

当有事件发生时，tkinter会传给事件处理例程一个event变量，此变量包含以下属性。

char：键盘的字符码，如a键的char属性等于“a”，F1的char属性无法显示。
Keycode:键盘的ASCII码，如a的ASCII码为65.
keysym：键盘的符号，a的keysym符号为‘a’，F1的keysym符号为F1.
height，width：控件的新高度与宽度，单位是像素。
num:事件发生时的鼠标按键码。
widget：事件发生时所在的控件实例变量。
x，y：目前的鼠标光标位置。
x_root,y_root：相对于屏幕左上角的目前鼠标光标位置。
type：显示事件的种类。

13.5.2：事件绑定方法。

13.5.3：鼠标事件

当处理鼠标事件时，1代表鼠标左键，2代表中键，3代表右键

<Enter>:此事件在鼠标指针进入控件时发生。
<Leave>：此事件在鼠标指针离开控件时发生。
<Button-1>,<ButtonPress-1>或<1>，此事件在控件上单击鼠标左键时发生。同理，<Button-2>在空间上单机鼠标中间键时发生。<Button-3>右键
<B1-Motion>：此事件在单击鼠标左键，移动控件时发生。
<ButtonRelease-1>:此事件在释放鼠标左键时发生。
<Double-Button-1>：此事件在双击鼠标左键时发生。

from tkinter import *

#处理鼠标光标进入窗体时的事件
def handleEnterEvent(event):
    label1["text"] = "You enter the frame"
    label2["text"] = ""
    label3["text"] = ""

#处理鼠标光标离开窗体时的事件
def handleLeaveEvent(event):
    label1["text"] = "You leave the frame"
    label2["text"] = ""
    label3["text"] = ""

#处理在窗体内单击鼠标左键的事件
def handleLeftButtonPressEvent(event):
    label1["text"] = "You press the left button"
    label2["text"] = "x = " + str(event.x)
    label3["text"] = "y = " + str(event.y)

#处理在窗体内单击鼠标中间键的事件
def handleMiddleButtonPressEvent(event):
    label1["text"] = "You press the middle button"
    label2["text"] = "x = " + str(event.x)
    label3["text"] = "y = " + str(event.y)

#处理在窗体内单击鼠标右键的事件
def handleRightButtonPressEvent(event):
    label1["text"] = "You press the right button"
    label2["text"] = "x = " + str(event.x)
    label3["text"] = "y = " + str(event.y)

#处理在窗体内单击鼠标左键,然后移动鼠标光标的事件
def handleLeftButtonMoveEvent(event):
    label1["text"] = "You are moving mouse with the left button pressed"
    label2["text"] = "x = " + str(event.x)
    label3["text"] = "y = " + str(event.y)

#处理在窗体内放开鼠标左键的事件
def handleLeftButtonReleaseEvent(event):
    label1["text"] = "You release the left button"
    label2["text"] = "x = " + str(event.x)
    label3["text"] = "y = " + str(event.y)

#处理在窗体内连续按两下鼠标左键的事件
def handleLeftButtonDoubleClickEvent(event):
    label1["text"] = "You are double clicking the left button"
    label2["text"] = "x = " + str(event.x)
    label3["text"] = "y = " + str(event.y)

#创建主窗口
win = Tk()

#创建窗体
frame = Frame(win, relief=RAISED, borderwidth=2, width=300, height=200)

frame.bind("<Enter>", handleEnterEvent)
frame.bind("<Leave>", handleLeaveEvent)
frame.bind("<Button-1>", handleLeftButtonPressEvent)
frame.bind("<ButtonPress-2>", handleMiddleButtonPressEvent)
frame.bind("<3>", handleRightButtonPressEvent)
frame.bind("<B1-Motion>", handleLeftButtonMoveEvent)
frame.bind("<ButtonRelease-1>", handleLeftButtonReleaseEvent)
frame.bind("<Double-Button-1>", handleLeftButtonDoubleClickEvent)

#文字标签,显示鼠标事件的种类
label1 = Label(frame, text="No event happened", foreground="#0000ff", \
  background="#00ff00")
label1.place(x=16, y=20)

#文字标签,显示鼠标事件发生时的x坐标
label2 = Label(frame, text="x = ", foreground="#0000ff", background= "#00ff00")
label2.place(x=16, y=40)

#文字标签,显示鼠标事件发生时的y坐标
label3 = Label(frame, text="y = ", foreground="#0000ff", background= "#00ff00")
label3.place(x=16, y=60)

#设置窗体的位置
frame.pack(side=TOP)

#开始窗口的事件循环
win.mainloop()

13.5.4键盘事件

可以处理所有的键盘事件，包括Ctrl,Alt,F1,Home等特殊键。

<Key>：此事件在按下ASCII码为48~90时发生，即数字键、字母键即+，-等符号
<Control-Up>：此事件在按下Ctrl+Up组合键时发生。同理可以使用类似的名称在ALT、Shift键加上Up，Down，Left与Right键。
其他按键，使用其按键名称。包括<Return><Escape><F1><F2><F3><Num_lock><Delete>等等。。。

from tkinter import *

#处理在窗体内按下键盘按键(非功能键)的事件
def handleKeyEvent(event):
    label1["text"] = "You press the " + event.keysym + " key\n"
    label1["text"] += "keycode = " + str(event.keycode)

#创建主窗口
win = Tk()

#创建窗体
frame = Frame(win, relief=RAISED, borderwidth=2, width=300, height=200)

#将主窗口与键盘事件连结
eventType = ["Key", "Control-Up", "Return", "Escape", "F1", "F2", "F3", "F4", "F5",
  "F6", "F7", "F8", "F9", "F10", "F11", "F12", "Num_Lock", "Scroll_Lock",
  "Caps_Lock", "Print", "Insert", "Delete", "Pause", "Prior", "Next", "BackSpace",
  "Tab", "Cancel", "Control_L", "Alt_L", "Shift_L", "End", "Home", "Up", "Down",
  "Left", "Right"]

for type in eventType:
    win.bind("<" + type + ">", handleKeyEvent)

#文字标签,显示键盘事件的种类
label1 = Label(frame, text="No event happened", foreground="#0000ff", background="#00ff00")
label1.place(x=16, y=20)

#设置窗体的位置
frame.pack(side=TOP)

#开始窗口的事件循环
win.mainloop()

13.5.5 系统协议

tkinter提供拦截系统信息的机制，用户可以拦截这些系统信息，然后设置成自己的处理例程，这个机制成为协议处理例程（protocol handler）。

通常处理的协议如下：

WM_DELETE_WINDOW:当系统要关闭该窗口时发生。
WM_TAKE_FOCUS：当应用程序得到焦点时发生。
WM_SAVE_YOURSELF：当应用程序需要存储内容时发生。

虽然这个机制是由X system成立的，但是Tk函数库可以在所有操作系统上处理这个机制，要将协议与处理例程连接，其语法如下：

widget.protocol(protocol, function_handler)

注意：widget必须是一个Toplevel控件。

from tkinter import *
import tkinter.messagebox

#处理WM_DELETE_WINDOW事件
def handleProtocol():
    #打开一个[确定/取消]对话框
    if tkinter.messagebox.askokcancel("提示", "您确定要关闭窗口吗？"):
       #确定要结束应用程序
       win.destroy()

#创建主窗口
win = Tk()

#创建协议
win.protocol("WM_DELETE_WINDOW", handleProtocol)

#开始窗口的事件循环
win.mainloop()

13.6 Button控件

Button控件用于创建按钮，按钮内可以显示文字或图片。

Button控件的方法如下。

flash（）：将前景与背景颜色互换，以产生闪烁的效果。
invoke（）：执行command属性所定义的函数。

Button widget的属性如下：

activebackground：按钮在作用时的背景颜色。
activeforeground：按钮在作用使得前景颜色。

from tkinter import *
win = Tk()
Button(win, activeforeground="#ff0000", activebackground="#00ff00", text="关闭", command=win.quit).pack()
win.mainloop()

bitmap：显示按钮上的位图，此属性只有在忽略image属性时才有用。此属性一般可设置为gray12、gray25、gray50、gray75、hourglass、error、questhead、info、warning或qusetion。也可以直接使用XBM（X Bitmap）文件，在XBM文件名称前添加一个@符号，如bitmap=@hello.xbm。

Button(win, bitmap="question", command=win.quit).pack()
Button(win, bitmap="error", command=win.quit).pack()
Button(win, bitmap="gray12", command=win.quit).pack()
Button(win, bitmap="gray25", command=win.quit).pack()
Button(win, bitmap="gray50", command=win.quit).pack()
Button(win, bitmap="hourglass", command=win.quit).pack()

default：若设置此属性，则按钮为默认按钮
disableforeground：按钮在无作用时的前景颜色。
image：显示在按钮上的图片，此属性的顺序在text与bitmap属性之前。
state：定义按钮的状态，可以时NORMAL，ACTIVE或DISABLED。
takefocus：定义用户是否可以使用Tab键，以改变按钮的焦点。
text：显示在按钮上的文字。如果定义了bitmap或image属性，text属性就不会被使用。
underline：一个整数偏移位，表示按钮上的文字那一个字符要加下划线。第一个字符的偏移位是0.

from tkinter import *
win = Tk()
Button(win, text="公司主页面", underline=0, command=win.quit).pack()
win.mainloop()

wraplength：一个以屏幕单位（screen unit）为单位的距离值，用来决定按钮上的文字在哪里需要换成多行。默认值是不换行。

13.7 Canvas控件

canvas控件用于创建与显示图形，如弧形、位图、图片、线条、椭圆形、多边形及矩形等。

方法如下：

create_arc(coord,start,extend,fill):创建一个弧形，其中参数coord定义画弧形区块的左上角与右下角坐标；参数start定义画弧形区块的起始角度（逆时针方向）；参数extent定义话户型区块的结束角度（逆时针方向）；参数fill定义填满弧形区块的颜色。

from tkinter import *
win = Tk()
coord = 13, 50, 240, 210
canvas = Canvas(win)
canvas.create_arc(coord, start=0, extent=270, fill="red")
canvas.pack()
win.mainloop()

create_bitmap(x,y,bitmap):创建一个位图，其中，参数x与参数y定义位图的左上角坐标；参数bitmap定义位图的来源，可谓gray12、gray25、gray50、gray75、hourglass、error、qusethead、info、warning或question。也可以直接使用XBM（X Bitmap）文件，在XBM文件名称前添加一个@符号，如bitmap=@hello.xbm。

from tkinter import *
win =Tk()
canvas = Canvas(win)
canvas.create_bitmap(40, 40, bitmap="warning")
canvas.create_bitmap(40, 80, bitmap="questhead")
canvas.create_bitmap(40, 120, bitmap="info")
canvas.create_bitmap(80, 40, bitmap="hourglass")
canvas.pack()
win.mainloop()

（4）creat_image(x,y,image):创建一个图片。其中参数x和y定义图片左上角的坐标；参数image定义图片的来源，必须是tkinter模块的BitmapImage类或PhotoImag类的实例变量。

from tkinter import *
win = Tk()
img = PhotoImage(file="13.1.gif")
canvas = Canvas(win)
canvas.create_image(200, 200, image=img)
canvas.pack()
win.mainloop()

create_line(x0,y0,x1,y1,...,xn,yn,opions):创建一个线条。其中，参数x0,y0,x1,y1,...,xn,yn定义线条的坐标；参数,opions可以是width或fill。width定义线条的宽度，默认值是1像素，fill定义线条的颜色，默认值是black。

from tkinter import *
win = Tk()
canvas = Canvas(win)
canvas.create_line(10, 10, 40, 120, 230, 270, width=3, fill="green")
canvas.pack()
win.mainloop()

create_oval(x0,y0,x1,y1,option):创建一个圆形或椭圆形，其中参数x0与y0定义绘图区域的左上角坐标；参数x1与y定义绘图区域的右下角坐标；参数options可以是fill或outline。fill定义填满原型或椭圆形的颜色，默认值是empty。outline定义圆形或椭圆形的外围颜色。

from tkinter import *
win = Tk()
canvas = Canvas(win)
canvas.create_oval(10,10,200,100,fill="blue",outline="red")
canvas.pack()
win.mainloop()

（6）creat_polygon(x0,y0,x1,y1,....xn,yn,options):创建一个至少三个点的多边形。参数option可以是fill、outline或splinesteps。fill定义填满多边形的颜色，默认值是black。ouline定义多边形的外围颜色，默认值是black。splinestepsg是一个整数，定义曲线的平滑度。

from tkinter import *
win = Tk()
canvas = Canvas(win)
canvas.create_polygon(10,10,30,40,10,70,40,50,70,70,50,40,70,10,40,30,10,10,fill="blue",outline="red",splinesteps=1)
canvas.pack()
win.mainloop()

create_rectangle(x0,y0,x1y1,options)：创建一个矩形，options可以是fill或outline。outline=””外围颜色是空字符串，表示不画举行的外围。
create_text(x0,y0,text,options):创建一个文本字符串。x0，y0定义字符串的左上角坐标；参数text定义文字字符串的文字；参数options可以是anchor或fill。anchor定义（x0，y0）在文字字符串内的位置，可以是N、NE、E.....默认值是CENTER。fill定义文本字符串的颜色，默认值是empyt（透明）。

from tkinter import *
win = Tk()
canvas=Canvas()
canvas.create_text(40,40,text='草长莺飞二月天，忽如一夜春风来!',fill="black")
canvas.pack()
win.mainloop()

13.8 Checkbutton控件

checkbutton控件用于创建复选框，属性如下：

onvalue,offvalue：设置Checkbutton空间的variable属性指定的变量，所要存储的数值。若复选框没有被选中，则此变量的值位offvalue；若被选中，值为onvalue。
indicatoron：设置此属性为0，可以将整个控件变为复选框。

Checkbutton控件的方法如下：

select（）：选中复选框，并设置变量的值为onvalue。

from tkinter import *
win = Tk()
check1 = Checkbutton(win, text="苹果")
check2 = Checkbutton(win, text="香蕉")
check3 = Checkbutton(win, text="橘子")
check1.select()
check1.pack(side=LEFT)
check2.pack(side=LEFT)
check3.pack(side=LEFT)
win.mainloop()

flash（）：将前景与背景颜色互换，形成闪烁的效果。
invoke（）：执行command属性所定义的函数。
toggle（）：改变复选框的状态，如果复选框现在状态是on就改为off。

13.9 Entry控件

用于在窗体或窗口内创建一个单行文本框。

Entry控件的属性为textvariable，此属性为用户输入的文字，或要显示在Entry控件内的文字。

Entry控件的方法为get()，此方法可以读取Entry widget内的文字。

from tkinter import *
win = Tk()
#创建窗体
frame = Frame(win)
#创建一个计算式
def calc():
    #将用户输入的表达式,计算结果后转换成字符串
    result = "= " + str(eval(expression.get()))
    #将计算的结果显示在Label控件上
    label.config(text = result)
#创建一个Label控件
label = Label(frame)
#创建一个Entry控件
entry = Entry(frame)
#读取用户输入的表达式
expression = StringVar()
#将用户输入的表达式显示在Entry控件上
entry["textvariable"] = expression
#创建一个Button控件.当用户输入完毕后,按此钮即计算表达式的结果
button1 = Button(frame, text="等于", command=calc)
#设置Entry控件为焦点所在
entry.focus()
frame.pack()
#Entry控件位在窗体的上方
entry.pack()
#Label控件位在窗体的左方
label.pack(side=LEFT)
#Button控件位在窗体的右方
button1.pack(side=RIGHT)
#开始程序循环
frame.mainloop()

Label控件

用于创建一个显示方块，可以在这个显示方块内放置文字或图片。当用户在Entry控件内输入数值时，其值会存储在tkinter的StringVar类内。可以将Entry控件的textvariable属性设置成StringVar的实例变量，使用户输入的数值自动显示在Entry控件上。

expression = StringVar()

entry = Entry(frame, textvalriable=expression)

entry.pack()

此方式也适用于Label控件上。可以使用StringVar（）类的set方法直接写入Label空间要显示的文字。

expression = StringVar()
Label(frame, textvariable=expression).pack()
expression.set("Hello Python")

案例：

from tkinter import *
win = Tk()

#设置图片文件的路径
path = "D:\\圆桌面\\python\\本书源代码\\ch13\\"
img = []
#将9张图片放入一个列表中
for i in range(9):
    img.append(PhotoImage(file=path + "a" + str(i) + ".gif"))

#创建9个窗体
frame = []
for i in range(3):
    for j in range(3):
        frame.append(Frame(win, relief=RAISED, borderwidth=1, width=158,height=112))
        #创建9个Label控件
        Label(frame[j+i*3], image=img[j+i*3]).pack()
        #将窗体编排成3×3的表格
        frame[j+i*3].grid(row=j, column=i)

#开始程序循环
win.mainloop()

13.11 Listbox控件

用于创建一个列表框。列表框内包含许多选项，用户可以只选一项或多项。

属性如下：

height：此属性设置列表框的行数目。若此属性为0，就自动设置为能找到的最大选择项数目。
selectmode：此属性设置列表框的种类，可以是SINGLE、EXTEMNDED、MULTIOPLE、或BROWSE。
width：此属性设置每一行的字符数目。若此属性为0，就自动设置为能找到的最大字符数目。

Lisbox的方法如下：

delete（row[，lastrow]）：删除指定行row，或删除row到lastrow之间的行。
get（row）：取得指定行row内的字符串。
insret（row，string）：在指定列row插入字符串string。
see（row）：将指定行row变成可视。
select_clear()：清除选择项。
select_set（startrow，endrow）：选择startrow和lastrow之间的行。

from tkinter import *
win = Tk()
#创建窗体
frame = Frame(win)
#创建列表框选项列表
name = ["香蕉", "苹果", "橘子", "西瓜", "桃子", "菠萝", "柚子", "橙子"]
#创建Listbox控件
listbox = Listbox(frame)
#清除Listbox控件的内容
listbox.delete(0, END)
#在Listbox控件内插入选项
for i in range(8):
    listbox.insert(END, name[i])
listbox.pack()
frame.pack()
#开始程序循环
win.mainloop()

13.12 Menu控件

用于创建三种类型的菜单，及pop-up（快捷式菜单）、tiolevel（主目录）及pull-down（下拉式菜单）。

Menu控件的方法如下：

add_command(optiion):新增一个菜单项。
add_separator（）：新增一个分割线。

Menu空间方法如下。

accelerator:设置菜单项的快捷键，快捷键会显示在菜单项目的右边。此选项不会自动将快捷键与菜单项连接在一起，需要另行设置。
command：选择菜单项时执行的函数。
label：定义菜单项内的文字。
mune：此属性与add_cascade()方法一起使用，用于新增菜单项的子菜单项。

from tkinter import *
import tkinter.messagebox
#创建主窗口
win = Tk()
#执行菜单命令,显示一个对话框
def doSomething():
tkinter.messagebox.askokcancel("菜单", "您正在选择菜单命令")
#创建一个主目录(toplevel)
mainmenu = Menu(win)
#新增菜单项
mainmenu.add_command(label="文件", command=doSomething)
mainmenu.add_radiobutton(label="单选按钮菜单项")
mainmenu.add_checkbutton(label="复选框菜单项",)
mainmenu.add_separator()
mainmenu.add_cascade(label="级联菜单？")
#设置主窗口的菜单
win.config(menu=mainmenu)
#开始程序循环
win.mainloop()

创建下拉菜单与菜单按钮快捷键

#创建一个下拉式菜单(pull-down)
mainmenu = Menu(win)

#新增"文件"菜单的子菜单
filemenu = Menu(mainmenu, tearoff=0)
#新增"文件"菜单的菜单项
filemenu.add_command(label="新建", command=doFileNewCommand, accelerator="Ctrl-N")
filemenu.add_command(label="打开", command=doFileOpenCommand,accelerator="Ctrl-O")
filemenu.add_command(label="保存", command=doFileSaveCommand,accelerator="Ctrl-S")
filemenu.add_separator()
filemenu.add_command(label="退出", command=win.quit)
#新增"文件"菜单
mainmenu.add_cascade(label="文件", menu=filemenu)

#设置主窗口的菜单
win.config(menu=mainmenu)

win.bind("<Control-n>", doFileNewCommand)
win.bind("<Control-N>", doFileNewCommand)
win.bind("<Control-o>", doFileOpenCommand)
win.bind("<Control-O>", doFileOpenCommand)
win.bind("<Control-s>", doFileSaveCommand)

创建一个单击右键后出现的快捷式菜单

#创建一个快捷式菜单(pop-up)
popupmenu = Menu(win, tearoff=0)
#新增快捷式菜单的项目
popupmenu.add_command(label="复制", command=doSomething)
popupmenu.add_command(label="粘贴", command=doSomething)
popupmenu.add_command(label="剪切", command=doSomething)
popupmenu.add_command(label="删除", command=doSomething)
#在单击鼠标右键的窗口(x,y)坐标处,显示此快捷式菜单
def showPopUpMenu(event):
popupmenu.post(event.x_root, event.y_root)
#设置单击鼠标右键后,显示此快捷式菜单
win.bind("<Button-3>", showPopUpMenu)

13.13 Message控件

与Label控件的功能相似，多了自动编排的功能。用于显示多行、不可编辑的文字。

txt = "暮云收尽溢清寒，银汉无声转玉盘。此生此夜不长好，明月明年何处看。"
msg = Message(win, text=txt)
msg.pack()

win.mainloop()

13.14 Radiobutton控件：用于创建单选按钮 P342

13.15 Scale控件：用于创建标尺式的滑动条对象

13.16 Scrollbar控件：用于创建水平或垂直的滚动条。

13.17 Text控件：用于创建一个多行格式化的文本框，用户可以改变文本框内的字体及文字颜色。

13.18 Toplevel控件：用于创建一个独立窗口

13.19对话框

13.19.1 messagebox模块

messagebox模块提供以下方法打开供用户选择项目的对话框。

askokcancel（title=None，Message=None）：打开一个“确定/取消”的对话框。
askquestion（title=None，Message=None）：打开一个“是/否”的对话框。
asktrycancel（title=None，Message=None）：打开一个“重试/取消”的对话框。
askyesno（title=None，Message=None）：打开一个“是/否”的对话框。
showerror（title=None，Message=None）：打开一个错误提示的对话框。
showinfo（title=None，Message=None）：打开一个信息提示对话框。
showwarning（title=None，Message=None）：打开一个警告提示对话框。

13.19.2 filedialog模块

tkinter.filedialog模块可以打开“打开旧文件”和“另存新文件”对话框。

open（master=None，filetypes=None）：打开一个“打开旧文件”的对话框。filetypes是要打开的文件类型，为一个列表。
SaveAs（master=None，filetypes=None）：打开一个“另存新文件”的对话框。filetypes是要打开的文件类型，为一个列表。

from tkinter import *
import tkinter.filedialog
#创建主窗口
win = Tk()
win.title(string = "打开文件和保存文件")
#打开一个[打开旧文件]对话框
def createOpenFileDialog():
myDialog1.show()
#打开一个[另存新文件]对话框
def createSaveAsDialog():
myDialog2.show()
#按下按钮后,即打开对话框
Button(win, text="打开文件", command=createOpenFileDialog).pack(side=LEFT)
Button(win, text="保存文件",command=createSaveAsDialog).pack(side=LEFT)
#设置对话框打开的文件类型
myFileTypes = [('Python files', '*.py *.pyw'), ('All files', '*')]
#创建一个[打开旧文件]对话框
myDialog1 = tkinter.filedialog.Open(win, filetypes=myFileTypes)
#创建一个[另存新文件]对话框
myDialog2 = tkinter.filedialog.SaveAs(win, filetypes=myFileTypes)
#开始程序循环
win.mainloop()

13.19.3 colorchooser模块

colorchooser模块用于打开“颜色”对话框

不李姐这些东西

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Python学习笔记

参考教材：python3.6从入门到精通-王英英编著-清华大学出版社python的基础语法2.1程序结构2.1.1缩进分层python特色：缩进分层所有的代码块语句必须包含相同的缩进空白数量、相同的缩进方式（wab键、两个或四个空格）2.1.2换行问题换行符：\n 程序代码超过一行：每一行结尾加反斜杠\ 用小括号()中括号[]大括号{}包含起来的语句，不使用反斜杠就可以直接分成数行将多行表达为一行：行尾加分号;2.1.3代码注释单行注释：以#开用...
复制链接

扫一扫