python小甲鱼笔记
提示：python小甲鱼笔记
文章目录
- 前言
- 〇、函数
-
- 1.常用基本函数
- 2.常用表函数
- 3.常用子函数
- 4.输入、输出
- 5.字符串函数
- 5.快捷键
- 一、常用函数案例
-
- 1.文本输出
- 2.猜数 if 实例
- 3.字符串实例
- 4.随机-循环-猜数字小游戏
- 4.数据类型
- 5.运算符号
- 6.循环
- 10.列表
- 11.元组
- 12.字符串格式化操作符
- 13.列序、列表
- 14.子函数
- 20.变量
- 21.闭包
- 22.匿名函数
- 23.筛查、映射、递归
- 23.递归（大型循环时慢）
- 24.实例【坑爹的兔子】（斐波那契数列）
- 25.字典、集合
- 25.txt写入、输出
- 二、模块
-
- 31.os模块
- 32.os.path模块
- 33.pickle模块
- 34.异常解决
- 35.EasyGUI
- 三、面向对象
-
- 36.1分类
- 36.2【继承】小鱼吃大鱼
- 36.3【多重继承】
- 36.4继承【组合】
- 36.5.魔法方法【构造】
- 43.魔法算数运算
- 45.计时器
- 46.属性访问
- 47.描述符
- 48.订制协议
- 49.迭代器
- 49.生成器
- 50.模块就是程序
- 四.爬虫的自我修养
-
- 54.隐藏、代理ip
- 54.正则表达式
- 58.正则表达式
- 64.Scrapy框架（Xpath专业查找）
- 五.Tkinter（UGI界面）
-
- 66.button函数
- 66.place()函数
- 66.Tk函数
- 66.标签
- 67.按钮功能响应
- 68.图片
- 69.图片及按钮响应
- 70.多选按钮
- 70.单选按钮
- 71.LabelFrame组
- 71.本文输入提取
- 72.列表框及删除及滚动条
- 73.滚动条
- 71.text
- 72.canvas（画布）五角星
- 74.菜单
- 75.事件
- 76.事件
- 77.布局管理器
- 六、游戏
-
- 78.移动-翻转-更新
- 七、仿真器
- 总结
前言
1. 应用范围：操作系统、web、3d动画、云计算、企业应用
2. 版本：2.5于3不同
3. 学习思路：（1）常用语法、（2）面向对象、（3）模块、（4）游戏、（5）仿真器
4. 学习捷径：验证例子、课后实践、搜素、心态
5.
-
安装
www.python.org
安装过程：略（下一步-下一步-完成）
1.IDLE交互性界面（程序）
2.测试-- print（"是否成功"） 成功则输出
错误则
安装失败，则查看https://blog.csdn.net/Joyine2017/article/details/78575653
提示：本文档为个人笔记，具体以教材为准
〇、函数
1.常用基本函数
| 函数名称 | 功能及用法 |
|---|---|
| dir(_ builtins _) | 查询builtins内置函数 |
| help(input) | 查看input用法 |
| 打印到屏幕 | |
| input | 输入字符串 |
| if:…else: | 如果…否则 |
| let’s go! | 转义字符\ 反斜杠 |
| r’c:\桌面 | 字符串\输入 |
| （“”我是长字符串”“） | 长字符串双引号，可换行 |
| “”“我是分^p段字符串”"" | ‘’’'三引号表示换行 |
| “共有%d对兔子” % ff) | 连接文字 |
| ！= | 不等于 |
| while | 条件循环 |
| str | 转字符串 |
| int | 转整数 |
| float | 转浮点数 |
| type | 查询类型 |
| assert 3>4 | 断言…则退出程序，终止程序 |
| while | 当条件为真则循环 |
| for 目标 in 表达式 | 表达式成立循环 |
| end=“ ” | 分解加空格 |
| len | 数组个数 |
| range( [strat,] stop[, step=1] ) | 起始增值 |
| break | 跳出 |
| continue | 跳出重头开始 |
| Exception | 异常、终止程序 |
| with…as… | 在…里面 |
2.常用表函数
| 表操作函数 | 说明 |
|---|---|
| .append（） | 添加元素 |
| extend（【】） | 批量添加元素 |
| insert（第几位，元素） | 添加元素到第几位 |
| del | 删除元素或第几位 |
| . remove | 移除列表内元素 |
| .POP （第几位数/默认最后一个） | 提取及删除元素或第几位 |
| . count(元素) | 计算元素出现的次数 |
| . index(元素，起，始位) | 元素所在表中位置 |
| . reverse | 元素位置颠倒 |
| list( reversed()) | 元素位置颠倒-元组 |
| list | 元素位置颠倒 |
| . sort | 元素小到大排序 |
| sorted() | 元素小到大排序-元组 |
| format | 预留字符串位置 |
| ”lvioe {1}".format | 预留字符串位置 |
| list（） | 列表 |
| max（） | 最大；字符则为siic码 |
| min（） | 最小；统一类型 |
| sum（） | 求和 |
| enumerate | 列表转元组 |
| zip | 合并列表成组 |
3.常用子函数
| 表达式 | 说明 |
|---|---|
| globals （） | 自变量返回全局变量 |
| return | 转回子函数 |
| nonlocal | 强制转换自变量 |
| globals | 强制转换全局变量 |
| lambda | 匿名调用 |
| filter | 筛查 |
| dict{1：sad，2：saf} | –字典 |
| set {1，2,3，2,1，4} | 唯一集合/去重复 |
| frozen | 不和编辑的集合 |
4.输入、输出
| 文件打开模式 表达式 | 说明 |
|---|---|
| r | 以只读方式打开文件(默认) |
| w | 以写入的方式打开文件，会覆盖已存在的文件 |
| x | 如果文件已经存在，使用此模式打开将引发异常 |
| a | 以写入模式打开，如果文件存在，则在末尾追加写入 |
| b | 以二进制模式打开文件 |
| t | 以文本模式打开(默认) |
| + | 可读写模式(可添加到其他模式中使用) |
| U | 通用换行符支持 |
| encoding=“cp936” | 打开cp936编码txt |
| encoding=“utf-8” | 打开utf-8 |
| 文件对象方法 | 说明 |
|---|---|
| f.close() | 关闭文件 |
| f.read([size=-1]) | 从文件读取size个字符，当未给定size或给定负值的时候，读取剩余的所有字符，然后作为字符串返回 |
| f.readline([size=-1]) | 从文件中读取并返回一行（包括行结束符），如果有size有定义则返回size个字符 |
| f.write(str) | 将字符串str写入文件 |
| f.writelines(seq) | 向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象 |
| f.seek(offset, from) | 在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节 |
| f.tell() | 返回当前在文件中的位置 |
| f.truncate([size=file.tell()]) | 截取文件到size个字节，默认是截取到文件指针当前位置 |
5.字符串函数
| 表达式 | 说明 |
|---|---|
| capitalize() | 把字符串的第一个字符改为大写 |
| casefold() | 把整个字符串的所有字符改为小写 |
| center(width) | 将字符串居中，并使用空格填充至长度 width 的新字符串 |
| count(sub[, start[, end]]) | 返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。 |
| encode(encoding=‘utf-8’, errors=‘strict’) | 以 encoding 指定的编码格式对字符串进行编码。 |
| endswith(sub[, start[, end]]) | 检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。 |
| expandtabs([tabsize=8]) | 把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。 |
| find(sub[, start[, end]]) | 检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。 |
| index(sub[, start[, end]]) | 跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。 |
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。 |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。 |
| isdecimal() | 如果字符串只包含十进制数字则返回 True，否则返回 False。 |
| isdigit() | 如果字符串只包含数字则返回 True，否则返回 False。 |
| islower() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。 |
| isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False。 |
| isspace() | 如果字符串中只包含空格，则返回 True，否则返回 False。 |
| istitle() | 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。 |
| isupper() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。 |
| join(sub) | 以字符串作为分隔符，插入到 sub 中所有的字符之间。 |
| ljust(width) | 返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。 |
| lower() | 转换字符串中所有大写字符为小写。 |
| lstrip() | 去掉字符串左边的所有空格 |
| partition(sub) | 找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 (‘原字符串’, ‘’, ‘’) |
| replace(old, new[, count]) | 把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。 |
| rfind(sub[, start[, end]]) | 类似于 find() 方法，不过是从右边开始查找。 |
| rindex(sub[, start[, end]]) | 类似于 index() 方法，不过是从右边开始。 |
| rjust(width) | 返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。 |
| rpartition(sub) | 类似于 partition() 方法，不过是从右边开始查找。 |
| rstrip() | 删除字符串末尾的空格。 |
| split(sep=None, maxsplit=-1) | 不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。 |
| splitlines(([keepends])) | 在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。。 |
| startswith(prefix[, start[, end]]) | 检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。 |
| strip([chars]) | 删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。 |
| swapcase() | 翻转字符串中的大小写。 |
| title() | 返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。 |
| translate(table) | 根据 table 的规则（可以由 str.maketrans(‘a’, ‘b’) 定制）转换字符串中的字符。 |
| upper() | 转换字符串中的所有小写字符为大写。 |
| zfill(width) | 返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。 |
| 操作符 | 说明 |
| – | – |
| %c | 格式化字符及其 ASCII 码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同 %e，用科学计数法格式化浮点数 |
| %g | 根据值的大小决定使用 %f 或 %e |
| %G | 作用同 %g，根据值的大小决定使用 %f 或者 %E |
| 格式化操作符辅助命令 | |
| 符号 | 说明 |
| m.n | m 是显示的最小总宽度，n 是小数点后的位数 |
| - | 用于左对齐 |
| + | 在正数前面显示加号（+） |
| # | 在八进制数前面显示 ‘0o’，在十六进制数前面显示 ‘0x’ 或 ‘0X’ |
| 0 | 显示的数字前面填充 ‘0’ 取代空格 |
| Python 的转义字符及其含义 | |
| 符号 | 说明 |
| ’ | 单引号 |
| " | 双引号 |
| \a | 发出系统响铃声 |
| \b | 退格符 |
| \n | 换行符 |
| \t | 横向制表符（TAB） |
| \v | 纵向制表符 |
| \r | 回车符 |
| \f | 换页符 |
| \o | 八进制数代表的字符 |
| \x | 十六进制数代表的字符 |
| \0 | 表示一个空字符 |
| \ | 反斜杠 |
5.快捷键
| 快捷键 | 功能 |
|---|---|
| Ctrl+c | 强制停止 |
| 选中ctrl+/ | 注释；批量注释 |
| Ctrl+f | 查找替换 |
一、常用函数案例
1.文本输出
>>>print"我是文本"
>>>>我是文本
1.1文本重复打印输出
>>>print"我是文本"*5
>>>>我是文本我是文本我是文本我是文本
提示：本文档为个人笔记，具体以教材为准。
1.2课后作业
https://fishc.com.cn/forum-243-1.html
【动手】1.2.5第5题. 为什么 >>>print('I love fishc.com ’ * 5) 可以正常执行，但 >>>print('I love fishc.com ’ + 5) 却报错？
答：字符串不能与数值相连
【动手题】第2题. 一年有几秒？
print('计算一年有多少秒')
DayPerYear = 365
HoursPerDay = 24
MinutesPerHour = 60
SecondsPerMinute = 60
sum = DayPerYear * HoursPerDay * MinutesPerHour * SecondsPerMinute
print('一年有：',sum,'秒')
提示：本文档为个人笔记，具体以教材为准。
扩展：区分平年、瑞年
y = int(input("你要计算的年:"))
if y%4 == 0 and y%100 != 0 or y%400 == 0:
d = 366
else:
d = 365
print (d*24*60*60)
2.猜数 if 实例
print('猜数？')
sr=input('输入你的数字')#输入内容为文本
sz=int(sr)#转换数值
if sz == 8:#判断转换后是否等于8（注意英文：）
print('正确')
else:#否则
print('错误')
print('游戏结束')
扩展:2.1.输入正确才结束
print('猜数？')
sr=input('输入你的数字')#输入内容为文本
while int(sr) != 8:#循环条件成立往下执行
print('错误')
sr = input('输入你的数字') # 输入内容为文本
else:#否则
print('正确')
print('游戏结束')
【动手】2.3和python对话
name=input('输入你的名字：')
print('你好啊！'+name+'，我是python。')
【动手】2.4判断大与小
sr=input('输入数值：判断是否大于100')
if int(sr) > 100:
print('大于100')
else:
print('小于100')
提示：本文档为个人笔记，具体以教材为准。
3.字符串实例
重点：‘…输入 及 ‘ /…输入；r’长字符串输入
st=(
"我爱鱼C，\n"
"正如我爱小甲鱼，\n"
"他那呱唧呱唧的声音，\n"
"总缠绕于我的脑海，\n"
"久久不肯散去……\n")
print(st)
我爱鱼C，
正如我爱小甲鱼，
他那呱唧呱唧的声音，
总缠绕于我的脑海，
久久不肯散去……
4.随机-循环-猜数字小游戏
import random
computer=random.randint(1,100)
while True:
number=int(input("请输入100以内的整数："))
if(number>computer):
print("大了")
elif(number<computer):
print("小了")
else:
print("恭喜你赢了")
break
4.数据类型
| 表示 | 类型 |
|---|---|
| 123 | 整数 |
| 123 .123 | 浮点数 |
| 15e4…15000 | 15x10四次方 e记法 |
| true…false | 布尔运算 |
| str | 转字符串 |
| int | 转整数 |
| float | 转整数 |
| type | 查询类型 |
5.运算符号
| 操作符 | 运用 |
|---|---|
| a=1;a=a+3…a+=3 | >>>a=4 |
| b=3;b=b-1…b-=1 | >>>a=2 |
| 3.0//1>>>1.0 | 除整数 |
| % …12%2;7%2 | 余数…0:1 |
| 12**3 | 12x12x12…幂 |
比较操作符
优先级（）
逻辑操作符
| 操作符 | 运用 |
|---|---|
| not | 不等于0 |
| and | 和 |
| or | 或者 |
6.循环
6.1小飞机游戏
https://blog.csdn.net/weixin_46163658/article/details/106582579
6.2判断分数
cj=int(input("输入一个数值"))
if cj>100:
print('输入错误')
elif 100>=cj >=90:
print("优秀")
elif 89>=cj >=60:
print("合格")
else: print("不合格")
【扩展，求最大公约数】
def ss(a):
cs=a//2
while cs>1:
if a % cs==0:
print("%d最大的约束是%d" %(a,cs) )
break
cs-=1
else:
print("%d是素素数！" % a)
a=int(input('输入数值'))
ss(a)
6.2.1三元操作符
x,y=4,5
samll=x if x < y else y#如果4小于5.则4等于samll，否则等于y
print(samll)
6.2.2断言 assert 3>4 则退出程序
6.3while循环 当条件为真则循环
6.4.for案例
stra="fuck"
for i in stra:
print(i,end=' ')
stra=["fuck","python","my","lvoe","you"]
for i in stra:
print(i,len(stra))
6.5range( [strat,] stop[, step=1] )|
for i in range(0,10):
print(i)
6.7跳出break
s="abc"
v1 = input("输入你猜的英文：")
while True:
if v1 == s:
break
v1=input("输入错误：")
print("游戏结束！")
10.列表
10.1列表添加
append及extend
x=[12,15,12]
x.append("sd")#加入到最后
x.extend(["as",123,12.36])#批量加入
x.insert(0,"wode ")#添加第一个位置
print(x)
print(len(x))
10.2位置调换
x=["my","lovw",521]
print(x)
s=x[2]
y=x[0]
x[0]=s
x[2]=y
print(x)
10.3删除元素
x=[12,123,135,156,135,156,135,12,56,12,5615,123]
del x[1]
print( ( x[0:2] *3))#切片，提取
print(x)#删除第2位数字
print(x.count(12))#查找12有几个
print(x.index(12,0,10))#第几位数
x.reverse()#颠倒
print(x)
x.sort()#小到大排序
print(x)
x.sort(reverse=True)#大到小排序
print(x)
11.元组
x=8*(8,)#创建元祖8个8元祖表
print(x)
x=x[:1] + ("aaa",)+x[1:]#增加到元组
print(x)
12.字符串格式化操作符
详见-字符串函数表
x="{0} lvioe {1}".format("i" , "you")#关键字后变量
print(x)
13.列序、列表
a="wodejiasf"
a=list(a)#输出单字符
print(a)
b=(1,2,5,6,8)
print(max(b))#最大
print(min(b))#最小
print(list(enumerate(a)))#列表转元组，加序列
print(list(zip(a,b)))#合并列表成组
14.子函数
def bas(a=5,b=8):#bas子函数；可设置默认参数
'参数：a,b为实数，求和函数'
#函数说明，可用help（）查询
c=a+b
print(c)
def aaa(*ss,ff):#收集参数,参数
print("长度",len(ss))
print("第一个为：",ss[0])
bas(1,2)
aaa("sad",1,2,6,5,8,9,ff = 8)
20.变量
def ss(aa,vv):
"全局变量，局部变量"
sa=float(aa) * float(vv)
print(sa ,"元")#sa局部变量
aa=(input("单价"))
vv = (input("折扣"))
ss(aa,vv)
print("全局变量，原价" , aa,"元")
globals(sa)
print("自局变量转全局" , sa,"元")
nonlocal(sa)
print("自局变量转全局" , sa,"元")
21.闭包
def funx(a):
def funy(b):
return a * b
return funy
print(funx(5)(8))
22.匿名函数
la=lambda x:x-1+8*x
print(la(5))
la=lambda x,y:x-1+8*x-y+x
print(la(5,6))
23.筛查、映射、递归
s=list(range(10))
print(s)
def ss(x):
return x % 2
p=filter(ss,s)#条件-集合
print(list(p))
#简化
print(list(filter(lambda x: x%2,range(10))))#简化邱10内奇数
print(list(map(lambda x: x * 2,range(10))))#0到10x2
23.递归（大型循环时慢）
def ss(n):
sd=n
for i in range(1,n):
sd *=i
return sd
x=int(input("输入数值："))
print(float(x),"阶乘是" ,ss(x))
#递归
def xx(n):
if n==1:
return 1
else:
return n * xx(n-1)#n!=1,循环本程序相乘
print(float(x),"递归法--阶乘是" ,xx(x))
24.实例【坑爹的兔子】（斐波那契数列）
def ss(n):
if n<1:
print("输入错误")
return -1
if n==1 or n==2:
return 1
else:
return ss(n-1) +ss(n-2)
ff=ss(20)
print("共有%d对兔子" % ff)
汉诺塔https://download.csdn.net/download/lswliushengwang/11974507
25.字典、集合
| 表达式 | 说明 |
|---|---|
| dict{1：sad，2：saf} | –字典 |
| set {1，2,3，2,1，4} | 唯一集合/去重复 |
lisq=[1,2,3,4,5,6,5,3,1,0]
tem=[]
for i in lisq:
if i not in tem:#如果不存在则添加
tem.append(i)
print(tem)
#简写
print(list(set(lisq)))
#sq=frozenset{[1,2,3,4]} 不可改动集合
#sq.add[2]；错误
25.txt写入、输出
#文本写入
str1="""a以只读方式打开文件(默认)
b以写入的方式打开文件，会覆盖已存在的文件
c如果文件已经存在，使用此模式打开将引发异常
a以写入模式打开，如果文件存在，则在末尾追加写入
b以二进制模式打开文件
c以文本模式打开(默认)
a可读写模式(可添加到其他模式中使用)
b通用换行符支持
c以文本模式打开(默认)
a可读写模式(可添加到其他模式中使用)
b通用换行符支持
c以文本模式打开(默认)"""
ff=open("12.txt","w")
ff.write(str1)
ff.close()
# 文件读取
mane=input("输入名称")
print("文件内容为：")
f=open(mane,encoding="utf-8")
for tet in f:
print(tet)
#提取a、b、c说的话
f= open('12.txt', encoding='utf-8', mode = 'r') # 打开文件
a=[]
b=[]
c=[]
an=open("00a.txt","w")
bn=open("00b.txt","w")
cn=open("00c.txt","w")
for i in f:
if i[:1] == "a":
a.append(i[1:])
an.writelines(i[1:])
#进行分割
elif i[:1] == "b":
b.append(i[1:])
bn.writelines(i[1:])
#分IE保存
elif i[:1] == "c":
c.append(i[1:])
cn.writelines(i[1:])
an.close()
bn.close()
cn.close()
f.close()
【扩展txt加序号】
f=open("12.txt", "r",encoding="cp936")#encoding=utf-8编码会出错
lines = f.readlines()
with open("12.txt", "w", encoding="utf8") as f1:
for i,j in enumerate(lines): # i 表示行号，j 表示每行内容
f1.write("{}: {}".format(i+1,j)) # 枚举默认从0开始，这里进行+1后就是按照从第一行为1进行写入
二、模块
import os
os.system("calc")#command调用计算器
31.os模块
31.1os模块中关于文件/目录常用的函数使用方法
| 函数名 | 使用方法 |
|---|---|
| getcwd() | 返回当前工作目录 |
| chdir(path) | 改变工作目录 |
| listdir(path=’.’) | 列举指定目录中的文件名（’.‘表示当前目录，’…'表示上一级目录） |
| mkdir(path) | 创建单层目录，如该目录已存在抛出异常 |
| makedirs(path) | 递归创建多层目录，如该目录已存在抛出异常，注意：'E:\a\b’和’E:\a\c’并不会冲突 |
| remove(path) | 删除文件 |
| rmdir(path) | 删除单层目录，如该目录非空则抛出异常 |
| removedirs(path) | 递归删除目录，从子目录到父目录逐层尝试删除，遇到目录非空则抛出异常 |
| rename(old, new) | 将文件old重命名为new |
| system(command) | 运行系统的shell命令 |
| walk(top) | 遍历top路径以下所有的子目录，返回一个三元组：(路径, [包含目录], [包含文件])【具体实现方案请看：第30讲课后作业_】以下是支持路径操作中常用到的一些定义，支持所有平台 |
| os.curdir | 指代当前目录（’.’） |
| os.pardir | 指代上一级目录（’…’） |
| os.sep | 输出操作系统特定的路径分隔符（Win下为’\’，Linux下为’/’） |
| os.linesep | 当前平台使用的行终止符（Win下为’\r\n’，Linux下为’\n’） |
| os.name | 指代当前使用的操作系统（包括：‘posix’, ‘nt’, ‘mac’, ‘os2’, ‘ce’, ‘java’） |
32.os.path模块
31.2os.path模块中关于路径常用的函数使用方法
| 函数名 | 使用方法 |
|---|---|
| basename(path) | 去掉目录路径，单独返回文件名 |
| dirname(path) | 去掉文件名，单独返回目录路径 |
| join(path1[, path2[, …]]) | 将path1, path2各部分组合成一个路径名 |
| split(path) | 分割文件名与路径，返回(f_path, f_name)元组。如果完全使用目录，它也会将最后一个目录作为文件名分离，且不会判断文件或者目录是否存在 |
| splitext(path) | 分离文件名与扩展名，返回(f_name, f_extension)元组 |
| getsize(file) | 返回指定文件的尺寸，单位是字节 |
| getatime(file) | 返回指定文件最近的访问时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算） |
| getctime(file) | 返回指定文件的创建时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算） |
| getmtime(file) | 返回指定文件最新的修改时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算） |
| 以下为函数返回 True 或 False | |
| exists(path) | 判断指定路径（目录或文件）是否存在 |
| isabs(path) | 判断指定路径是否为绝对路径 |
| isdir(path) | 判断指定路径是否存在且是一个目录 |
| isfile(path) | 判断指定路径是否存在且是一个文件 |
| islink(path) | 判断指定路径是否存在且是一个符号链接 |
| ismount(path) | 判断指定路径是否存在且是一个挂载点 |
| samefile(path1, paht2) | 判断path1和path2两个路径是否指向同一个文件 |
33.pickle模块
import pickle
str1=[123,35145,"fdsg"]
ff=open("str1.tt","wb")#wb形式,存成数据包
pickle.dump(str1,ff)
ff.close()
dd=open("str1.tt","rb")
ss=pickle.load(dd)
print(ss)
34.异常解决
Python 标准异常总结：小甲鱼地址
try:
s=4/0
sr=1+"s"
f=open("我不存在.txt")
print(f.read())
f.close()
except OSError as cw:
print("文件出错了！" , str(cw))
except TypeError as cw1:
print("文件出错了！", str(cw1))
finally:#写入错误是，执行保存
f.close()
raise ZeroDivisionError("除数不能为0")
else:
print('没有任何异常')
try:
with open('dat.txt','w') as f:
for i in f:
print("asdfsf")
except OSError as ss:
print('出错了！'+str (ss))
finally:
f.close()
35.EasyGUI
EasyGUI 学习文档【超详细中文版】
import easygui as ea
#提示框
ea.msgbox(msg="你好" + "easygui",title="你好",ok_button="你好",image="图片1.png")#按钮加图像,只有确定
ea.ccbox(msg="你好",choices=("确定",'取消'))#确定，取消按钮
#按钮
ea.ynbox(msg='我是按钮选择',choices=("[y] yes",'[n] not'))#键盘控制2ge,
ea.buttonbox(msg="你喜欢哪个按钮",choices=('吃的[1]','玩得[2]','用的[3]'))#键盘控制多个,
ea.buttonbox(msg="我帅补水",image='图片1.png',choices=('谁啊','帅','不帅'))#图形组合按钮
#下拉选项
ea.choicebox(msg='Pick an item', title='ds', choices=["das",'fasf','dsfsdf','sdad'], preselect=0, callback=None, run=True)
#多行提示
ea.multenterbox('【真实姓名】为必填项\n【手机号码为必填项】\n【E-mail】为必填项\n',title='帐号中心',fields=['你'],values=())
#文本输入框
ea.enterbox(msg='Enter something.', title=' ', default='', strip=True, image=None, root=None)
#文本输入框组合框
ea.multenterbox(msg='【真实姓名】为必填项\n【手机号码为必填项】\n【E-mail】为必填项\n',fields=['【真实姓名】为必填项',"【手机号码为必填项】",'【E-mail】为必填项'])
#密码
ea.passwordbox(msg='密码',)
#账户密码
ea.multpasswordbox(msg='misj',title="sd",fields=["zhangf","mims"])
#读取文本
ss=open('001.txt',encoding="utf-8")
ff=ss.read()
print(ff)
ea.textbox(msg="文件内容为：",text=ff)#textbox(codebox=True)不换行
#文件夹路径
ea.diropenbox(msg="选择文件路径",title="shazi",default="ss")
#保存路径
ea.filesavebox(default="*.py")
#打开路径
s=ea.fileopenbox(default="*.txt")
print(s)
35.1记住用户选择
from easygui import EgStore
# 定义一个叫做“Settings”的类，继承自EgStore类
class Settings(EgStore):
def __init__(self, filename): # 需要指定文件名
# 指定要记住的属性名称
self.author = ""
self.book = ""
# 必须执行下面两个语句
self.filename = filename
self.restore()
# 创建“Settings”的实例化对象“settings”
settingsFilename = "settings.txt"
settings = Settings(settingsFilename)
author = "小甲鱼"
book = "《零基础入门学习Pyhon》"
# 将上面两个变量的值保存到“settings”对象中
settings.author = author
settings.book = book
settings.store()
print("\n保存完毕\n")
35.2获取easygui异常
try:
print('I Love FishC.com!')
int('FISHC') # 这里会产生异常
except:
exceptionbox()
三、面向对象
36.1分类
【对象】：属性-动作-
【类class】：继承-封装-多态
1.class类似调动子函数
_init - (self)构造方法
#变量可以被外部调用
class cname:
__name__="小甲鱼"
def gname(self):
return self.__name__
p=cname()
print(p.__name__)
36.2【继承】小鱼吃大鱼
# 小鱼吃大鱼，累不跑
import random as r
class Yu:
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 Dayu(Yu):
pass
class xiaoyu(Yu):
pass
class Shayu(Yu):
def __init__(self):
#yu.__init__(self)#继承父级
super().__init__()
self.el=True
def eat(self):
if self.el:
print('吃饱了')
else:
print('吃多了')
yu=Yu()
yu.move()
dayu=Dayu()
dayu.move()
xy=xiaoyu()
xy.move()
sha=Shayu()
sha.eat()
sha.eat()
sha.move()
36.3【多重继承】
# 多重继承
class cs1:
def foo1(self):
print("我是f1，我为cs1代言")
class cs2:
def foo2(self):
print("我是f2，我为cs2代言")
class C(cs2,cs1):
pass
x=C()
x.foo1()
x.foo2()
36.4继承【组合】
#池塘、乌龟和鱼
class wg:#类定义
def __init__(self,x):#类对象
self.num=x
class yu:
def __init__(self,x):
self.num=x
class pool:
def __init__(self,x,y):
self.wg=wg(x)
self.yu=yu(y)
def print_num(self):
print("水池共有乌龟%d 只，小鱼%d 条！" %(self.wg.num,self.yu.num))
pp=pool(1,20)#实例对象
pp.print_num()
| 名称 | 介绍 |
|---|---|
| issubclass | 检查父类是否包含 |
| isinstance(,) | 参数是否在一个类里 |
| hasattr(对象,“属性”) | 查询对象里的属性 |
| getattr(r(对象,“属性”,错误值)) | 同上返回错误制 |
| delattr(对象,属性) | 删除属性 |
| property() | 该属性对象 |
class B:
pass
class C(B):
pass
print(issubclass(B,C))
print(issubclass(C,B))
36.5.魔法方法【构造】
| 表达式 | 说明 |
|---|---|
| __init—(self,) | 对象构造 |
| __new—(class,self,) | 新建替换 |
| –del– | 删除构造 |
#求周长及面积__init---
class cfx:
def __init__(self,x,y):
self.x=x
self.y=y
def zc(self):
return (self.x+self.y) *2
def mj(self):
return self.x *self.y
rec=cfx(12,5)
print(rec.mj())
print(rec.zc())
#_new--转大写
class shuru(str):
def __new__(cls, str):
str=str.upper()
return str.__new__(cls,str)
a=shuru('wo SHi PHton!')
print(a)
#--del————删除
class C:
def __init__(self):
print('我是init,我被调用了')
def __del__(self):
print('我是del..我被调用了')
c1=C()
c2=c1
c3=c2
del c3
del c2
del c1
43.魔法算数运算
| 表达式 | 说明 |
|---|---|
| def __add–(self, other): | 加法 |
| def –sub–(self, other): | 减法 |
| def -_mul-_(self, other): | 乘法 |
| def -_trunc-_(self): | 除法 |
| 反运算表达式 | 说明 |
| def __radd–(self, other): | 加法 |
| def –rsub–(self, other): | 减法 |
| 增量运算符 | 说明 |
| a +=b | a=a+b |
| a -=b | a=a-b |
class sd:
def __add__(self, other):
pass
def __sub__(self, other):
pass
def __mul__(self, other):
pass
def __trunc__(self):
pass
45.计时器
#错误稿件
import time as t
class myt():
def __init__(self):
self.progpt="未开始"
self.lasted = []
self.stop1=0
self.st=0
def st(self):
self.st = t.localtime()
print('计算开始')
def stop(self):
self.stop1=t.localtime()
self._calc=[]
print('记时结束')
def _calc(self):
self.lasted=[]
self.pat='运行几秒'
for ix in range(6):
self.lasted.append(self.stop[ix]-self.st[ix])
self.pat == str(self.lasted[ix])
print(self.pat)
t1=myt
print(t1.st())
46.属性访问
| 表达式 | 说明 |
|---|---|
| getattr(c,‘y’,‘没有这个属性’) | 属性查询 |
| def getattr(self, item): | 没有这个属性用ltem |
#_setattr_使用！！错误
class c:
def __init__(self,ww=0,hh=0):
self.ww = ww
self.hh = hh
def __setattr__(self, name, value):
if name == 'cfx':
self.ww=value
self.hh=value
else:
super().__setattr__(name,value)
def get(self):
return self.ww=self.hh
s=c(5,6)
print(s.get())
47.描述符
class ss:
def __get__(self,ins,oo):
print('woshhi get ',self,ins,oo)
def __set__(self,ins,oo):
print('woshhi set ',self,ins,oo)
def __delete__(self, instance):
print("sadf del",self,instance)
class test:
x=ss()
print(test)
print(test.x)
#摄氏度换华氏摄氏度
class dd:
def __init__(self,value=26.0):
self.value=float(value)
def __get__(self,ins,oo):
return self.value
def __set__(self,ins,value):
self.value=float(value)
class ff:
def __get__(self,ins,oo):
return ins.ssd=1.8+22#错误点
def __set__(self, instance, value):
instance.ssd=(float(value)-32 /1.8)
class ss:
ssd=dd()
hsd=ff()
ssa=
48.订制协议
| 表达式 | 说明 |
|---|---|
| _-len-() | 容器个数 |
| _getitem- |
#访问次数
class ss:
def __init__(self,*lsi):
self.vls=[x for x in lsi]
self.cou={}.fromkeys(range(len(self.vls)),0)
def __len__(self):
return len(self.vls)
def __getitem__(self, item):
self.cou[item]==1
return self.vls[item]
c1=ss(1,56,5,1,5,47,2,85,5)
c2=ss(1365,15,6,35,5,4,8,2,)
print(c2[2])
print(c1[3])
print(c1.cou)
print(c2.cou)
49.迭代器
| 表达式 | 说明 |
|---|---|
| next | 下一个 |
| iter | 拆分循环 |
#字典迭代打印
zd={'sad':214,'xxx':123,'sad':56656,'ssss':3515}
for i in zd:
print('%s-------%s' % (i,zd[i]))
#next下一个
st='safsaf'
it=iter(st)
print(next(it))
#迭代器
class c:
def __init__(self,n=10):
self.a=0
self.b=1
self.n=10
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
return self.a
cc=c()
for i in cc:
if i < 20:
print(i)
else:
break
49.生成器
def ss():
print('执行')
yield 1
yield 2
m=ss()
print(next(m))
print(next(m))
#偶数不能被3整除
a =[i for i in range(100) if not (i % 2) and i % 3]
print(a)
>>>sum(i for i in range(100) if i % 2)
50.模块就是程序
| 表达式 | 说明 |
|---|---|
| from 函数名 import 子函数,子函数 | |
| import 函数名 as 赋值 | |
| -name- | |
| 包 | 文件名。空文件——init——.py |
| -doc- | 查询模块的方法 |
| dir(sys)(_ builtins _) | 查询builtins内置函数 |
| help(input) | 查看input用法 |
#测试程序
def ss(ssd):
hsd=ssd*1.8+32
return hsd
def hsd(ss):
ssd=ss/1.8-32
return ssd
def tt():
print("转换为 %f" % ss(20))
if __name__=='__name__':
tt()
#导入路径
import sys
sys.path
['D:\\pycharm\\PyCharm Community Edition 2021.1.1\\plugins\\python-ce\\helpers\\pydev', 'D:\\pycharm\\PyCharm Community Edition 2021.1.1\\plugins\\python-ce\\helpers\\third_party\\thriftpy', 'D:\\pycharm\\PyCharm Community Edition 2021.1.1\\plugins\\python-ce\\helpers\\pydev', 'C:\\Program Files\\python\\python38.zip', 'C:\\Program Files\\python\\DLLs', 'C:\\Program Files\\python\\lib', 'C:\\Program Files\\python', 'E:\\桌面\\坚持\\Python\\venv', 'E:\\桌面\\坚持\\Python\\venv\\lib\\site-packages', 'E:\\桌面\\坚持\\Python', 'E:/桌面/坚持/Python']
sys.path.append('E:\\桌面')
四.爬虫的自我修养
| 表达式 | 说明 |
|---|---|
| urllib.request | 导入这个模块 |
| urlopen | 打开链接 |
| print(res.geturl()) | 获取地址 |
| print(res.info()) | 返回对象属性 |
| resource.add_header | 隐藏；转换对象后 |
| haa={}；haa[‘User-Agent:’]='Mozilla/5.0 | 隐藏；转换对象前 |
#抓一只猫
import urllib.request
# urllib.request.Request()#为本转化对象
res=urllib.request.urlopen('http://placekitten.com/g/500/600')#地址
cat=res.read()
with open('cat.jpg','wb') as f:
f.write(cat)
# 简写
print(res.geturl())#获取地址
print(res.info)#返回对象
print(res.info())#返回对象属性
文章教程https://blog.csdn.net/weixin_44124397/article/details/108047466
#翻译
import json
import time
import requests
# 7.循环
while True:
# 1.控制台获取等待翻译文本
content=input("输入中文:")
# 8.退出
if content == "":
print("输个什么玩意?爷退了")
exit()
# 2.设定待请求url
# 有道云坏的很加了个_o防止爬虫
# url="http://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule"
url="http://fanyi.youdao.com/translate?smartresult=dict&smartresult=rule"
# #隐藏-生成对象前
# haa={}
# haa['User-Agent:']='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
# # 隐藏生成对象前
# 3.建立post表单
post_form={
"i": content,
"from": "AUTO",
"to": "AUTO",
"smartresult": "dict",
"client": "fanyideskweb",
"salt": "15975710195066",
"sign": "1c7317b4699d018e5ae031c0077d7b80",
"lts": "1597571019506",
"bv": "9ef72dd6d1b2c04a72be6b706029503a",
"doctype": "json",
"version": "2.1",
"keyfrom": "fanyi.web",
"action": "FY_BY_REALTlME",
}
# 4.提交post请求
# response接受返回的json格式
response=requests.post(url, data = post_form)
# # 隐藏生成对象后
# resource.add_header('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36')
# # 隐藏生成对象后
# 5.接受相应结果,解析提取
trans_json = response.text
trans_dict=json.loads(trans_json)
trans_text=trans_dict["translateResult"][0][0]["tgt"]
# 6.打印翻译结果
print("翻译结果:%s" % trans_text)
time.sleep(1)#睡一秒
#查询本机ip
import requests
url = 'http://icanhazip.com'
try:
response = requests.get(url) #不使用代理
print(response.status_code)
if response.status_code == 200:
print(response.text)
except requests.ConnectionError as e:
print(e.args)
54.隐藏、代理ip
#抓取煎蛋网图片
import urllib.request as u_request
import os, re, base64, requests
#隐藏
header ={}
header['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 11_1_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'
#隐藏
def url_open(url):
html = requests.get(url, headers=header).text
return html
def find_images(url):
html = url_open(url)
m = r'
match = re.findall(m, html)
for each in range(len(match)):
match[each] = 'http:' + match[each]
print(match[each])
return match
def save_images(folder, img_addrs):
for each in img_addrs:
try:
req = u_request.Request(each, headers = header)
response = u_request.urlopen(req)
cat_image = response.read()
filename = each.split('/')[-1]
with open(filename,'wb') as f:
f.write(cat_image)
#print(each)
except OSError as error:
print(error)
continue
except ValueError as error:
print(error)
continue
def web_link_encode(url, folder):
for i in range(180,200):
string_date = '20201216-'
string_date += str(i)
string_date = string_date.encode('utf-8')
str_base64 = base64.b64encode(string_date)
page_url = url + str_base64.decode() + '=#comments'
print(page_url)
img_addrs = find_images(page_url)
save_images(folder, img_addrs)
def download_the_graph(url):
folder = 'graph'
os.mkdir(folder)
os.chdir(folder)
web_link_encode(url, folder)
if __name__ == '__main__':
url = 'http://jandan.net/girl/'
download_the_graph(url)
54.正则表达式
| 表达式 | 说明 |
|---|---|
| re | 模块 |
| re.search(‘d’,‘safsfd’) | 字符所在范围；参数：。通配符；、/n。;/d所有数值；[0-9];数值;[a-z]小写字符；‘ab[3,6]c’–b循环3-6次/abbbbc |
| re.findall | 搜索组成列表 |
| compiler(r’A-Z’) | 转换为对象 |
58.正则表达式
如何优雅地使用正则表达式
import re
print(re.search(r'a','cdfasva'))#第一次出现的范围woshi nibaba"
#贴吧抓图！！错误
import urllib.request
import re
def open_ur(ur):
req=urllib.request(ur)
req.add_hader('user-agent','Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36')
paga1=urllib.request.urlopen(req)
html=paga1.read().decode('utf-8')
return html
def get_img(html):
r=r'src="(http://[^"]+\.jpg)" width="100%" height="100%" class="img">'
asdd =re.findall(r,html)
for i in asdd:
print(i)
for i in asdd:
neme=i.split('/')[-1]
urllib.request.urlretrieve(i,neme,None)
if __name__ == "__name__":
ur="https://tieba.baidu.com/p/7490381978"
get_img(open(ur))
#贴吧抓图！！错误
#抓ip！！错误
import urllib.request
import re
ur = "http://www.66ip.cn/"
def open_ur(ur):
req=urllib.request(ur)
req.add_hader('user-agent','Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36')
paga1=urllib.request.urlopen(req)
html=paga1.read().decode('utf-8')
return html
def get_img(html):
r=r'(([0-1]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])\.){3}[0-1]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5]'
asdd =re.findall(r,html)
for i in asdd:
print(i)
# for i in asdd:#保存
# neme=i.split('/')[-1]
# urllib.request.urlretrieve(i,neme,None)
if __name__ == "__name__":
ur="http://www.66ip.cn/"
get_img(open(ur))
#抓ip！！错误
64.Scrapy框架（Xpath专业查找）
看不到懂！！！！
五.Tkinter（UGI界面）
| 表达式 | 说明 |
|---|---|
| tkinter | 模块 |
| Frame | 窗体 |
| pack | 默认位置；(side=LEFT)左；(side=RIGHT)右; |
| Button | 按钮；text=?；fg='blue’字体颜色；bg=‘bluck’按钮背景色；command命令 |
| label | 文本；text=？；\n换行；ustify=LEFT左对齐 |
66.button函数
| button | |
|---|---|
| PhotoImage(file=‘f1.png’) | 图形按钮地址 |
| bg=‘white’ | 白色背景 |
| compound=‘top’ | top下方； |
| padx=5 | 间距 |
| .pack（side=） | LEFT；左边；right右边 |
| anchor | 指定按钮上文本的位置； |
| background(bg) | 指定按钮的背景色； |
| bitmap | 指定按钮上显示的位图； |
| borderwidth(bd) | 指定按钮边框的宽度； |
| command | 指定按钮消息的回调函数； |
| cursor | 指定鼠标移动到按钮上的指针样式； |
| font | 指定按钮上文本的字体； |
| foreground(fg) | 指定按钮的前景色； |
| height | 指定按钮的高度； |
| image | 指定按钮上显示的图片； |
| state | 指定按钮的状态（disabled）； |
| text | 指定按钮上显示的文本； |
| width | 指定按钮的宽度 |
| padx | 设置文本与按钮边框x的距离，还有pady; |
| activeforeground | 按下时前景色 |
| textvariable | 可变文本，与StringVar等配合着用 |
66.place()函数
| anchor | 部件其他选项的确切位置，请参阅：可能是N，E，S，W，东北，西北，东南或西南，罗盘方向指示的widget的角落，双方默认是净重（部件上左上角） |
| bordermode | INSIDE（默认）表示其他选项是指父母的内（忽略父级的边界）;以外地方，否则. |
| height, width | 以像素为单位的高度和宽度. |
| relheight, relwidth | 高度和宽度为0.0和1.0之间浮动，父widget的一小部分的高度和宽度. |
| relx, rely | 水平和垂直偏移为0.0和1.0之间浮动，父widget的一小部分的高度和宽度. |
| x, y | 水平和垂直像素偏移. |
66.Tk函数
66.标签
#我是标签
import tkinter as tk
app=tk.Tk()
app.title('我是窗体标题')
tabel=tk.Label(app,text='我是标签')
tabel.pack()#自动位置，调整尺寸
app.mainloop()#主视觉循环
67.按钮功能响应
#功能响应
import tkinter as tk
class APP:
def __init__(self,ast):
fname=tk.Frame(ast)
fname.pack(side=tk.LEFT,padx=10,pady=10)#默认位置;往左；间距10px
self.hi_there=tk.Button(fname,text='打招呼',fg='blue',command=self.dzf)
self.hi_there.pack()
def dzf(selfs):
print('大家好')
root=tk.Tk()
app=APP(root)
root.mainloop()#主视觉循环
68.图片
#禁止观看
from tkinter import *
root=Tk()
txtla=Label(root,text='下载有静止18岁，啊啊啊啊啊啊啊啊啊啊,\n你还小不能看',
justify=LEFT,padx=10,pady=10)
txtla.pack(side=LEFT)
ph=PhotoImage(file='图片1.PNG')
imgla=Label(root,image=ph)
imgla.pack(side=RIGHT)
mainloop()
69.图片及按钮响应
#背景图片航打字
from tkinter import *
root = Tk()
pho = PhotoImage(file='捕获.PNG')#地址
tl = Label(root,
text='我是你爷爷，你想较我爷爷吗？\n叫下我教你Python',
justify=LEFT,#左对齐
image=pho,
compound=CENTER,#图层叠加混合
font=("宋体", 50),
fg='white')
tl.pack()
mainloop()
#禁止观看加按钮
from tkinter import *
root=Tk()
def cask():
var.set('吹吧，我不要')
fr1=Frame(root)
fr2=Frame(root)
var=StringVar()
var.set('下载有静止18岁，啊啊啊啊啊啊啊啊啊啊,\n你还小不能看')
txtla=Label(fr1,
textvariable=var,#内容变化
justify=LEFT,
padx=10,
pady=10)
txtla.pack(side=LEFT)
ph=PhotoImage(file='图片1.PNG')
imgla=Label(fr1,image=ph)
imgla.pack(side=RIGHT)
bo=Button(fr2,text='我已18',
command=cask)
bo.pack()
fr1.pack()
fr2.pack()
mainloop()
70.多选按钮
#多选按钮
from tkinter import *
root=Tk()
lst=['我的','亚索','王昭君']
v=[]
for o in lst:
v.append(IntVar())
b=Checkbutton(root,text=o,variable=v[-1])#多选按钮
b.pack(anchor=W)#z左对齐
mainloop()
70.单选按钮
#单选按钮--简写
from tkinter import *
root=Tk()
v=IntVar()
Radiobutton(root,text="wode",variable=v,value=1).pack(anchor=W)
Radiobutton(root,text="wode1",variable=v,value=2).pack(anchor=W)
Radiobutton(root,text="wode2",variable=v,value=3).pack(anchor=W)
mainloop()
#单选按钮--按钮形状
from tkinter import *
root=Tk()
v=IntVar()#取值
v.set(1)
lis=[('saf',1),('saf1',2),('saf2',3),('saf3',4)]
for i,num in lis:
b=Radiobutton(root,text=i,variable=v,value=num,indicatoron=False,)
b.pack(fill=X)#x宽度对齐
mainloop()
71.LabelFrame组
from tkinter import *
root=Tk()
gr=LabelFrame(root,text="单选按钮",padx=5,pady=5)
gr.pack(padx=10,pady=10)
v=IntVar()#取值
v.set(1)
lis=[('saf',1),('saf1',2),('saf2',3),('saf3',4)]
for i,num in lis:
b=Radiobutton(gr,text=i,variable=v,value=num,indicatoron=False,)#放到组里
b.pack(fill=X)#x宽度对齐
mainloop()
71.本文输入提取
| validate | 验证文本框内容 |
|---|---|
| Scale | 滚动条 |
from tkinter import *
root=Tk()
Label(root,text='作品').grid(row=0,column=0)
Label(root,text='作者').grid(row=1,column=0)
e1=Entry(root)
e2=Entry(root)
e1.grid(row=0,column=1,padx=10, pady=5)
e2.grid(row=1,column=1,padx=10, pady=5)
def show():
print("作品：%s" % e1.get())
print("作者：%s" % e2.get())
Button(root,text='获取信息',width=10,command=show)\
.grid(row=3,column=0,sticky=W,padx=10,pady=5)
Button(root,text='退出',width=10,command=root.quit) \
.grid(row=3, column=1, sticky=E, padx=10, pady=5)
mainloop()
#登录框
from tkinter import *
root=Tk()
Label(root,text='账号').grid(row=0,column=0)
Label(root,text='密码').grid(row=1,column=0)
v1=StringVar()
v2=StringVar()
e1=Entry(root,textvariable=v1)
e2=Entry(root,textvariable=v2,show="*")
e1.grid(row=0,column=1,padx=10, pady=5)
e2.grid(row=1,column=1,padx=10, pady=5)
def show():
print("账号：%s" % e1.get())
print("密码：%s" % e2.get())
Button(root,text='登录',width=10,command=show)\
.grid(row=3,column=0,sticky=W,padx=10,pady=5)
Button(root,text='退出',width=10,command=root.quit) \
.grid(row=3, column=1, sticky=E, padx=10, pady=5)
mainloop()
验证文本框内容
https://blog.csdn.net/w15977858408/article/details/104160155/
72.列表框及删除及滚动条
from tkinter import *
root=Tk()
#g滚动条
sb=Scrollbar(root)
sb.pack(side=RIGHT,fill=Y)
th1=Listbox(root,height=20,yscrollcommand=sb.set)#列表框，selectmode=？？：SINGLE单选，BROWSE 也是单选，MULTIPLE (多选)和EXTENDED (也是多选，
th1.pack()
for i in range(100):
th1.insert(END,i)
thb=Button(root,text='删除', command=lambda x=th1:x.delete(ACTIVE))
thb.pack()
sb.config(command=th1.yview)#滚动条
mainloop()
73.滚动条
#bug
from tkinter import *
root=Tk()
s1=Scale(root,from_=0,to=42,tickinterval=5,resolution=5,length=200)
s1.pack(anchor=E)
s2=Scale(root,from_=0,to=100,tickinterval=5,orient=HORIZONTAL,length=600)
s2.pack()#orient=HORIZONTAL横向
def shou():
print(s1.get(),s2.get())
Button(root,text='获取坐标',command=shou).pack()
Label(root,textvariable=shou,text=StringVar).pack()
mainloop()
71.text
#text插入按钮
from tkinter import *
root = Tk()
text = Text(root,width=30,height = 5)
text.pack()
text.insert(INSERT,"I love \n")
text.insert(END,"Study.com!")
def show():
print("哟，我被点了")
b1 = Button(text,text = "点我呀",command=show)
text.window_create(INSERT,window=b1)
mainloop()
text用法记事本https://blog.csdn.net/w15977858408/article/details/104173780
#线型界面
from tkinter import *
root=Tk()
w=Canvas(root,width=200,height=200)
w.pack()
l1=w.create_line(0,50,200,50,fill="yellow",width=3)#实线加宽
l2=w.create_line(100,0,100,100,fill="red",dash=(4,4),width=3)#虚线加宽
c=w.create_rectangle(50,20,150,75,fill="blue",width=3)#矩形
w.coords(l1,0,50,200,50)#修改
w.itemconfig(c,fill="red")#修改
w.delete(l2)#删除
Button(root,text="全部删除",command=(lambda x=ALL:w.delete(x) )).pack()#全部删除
mainloop()
72.canvas（画布）五角星
from tkinter import *
root=Tk()
import math as m
w=Canvas(root,width=200,height=100)
w.pack()
x=100
y=50
r=50
points=[
#左上角
x-int(r * m.sin(2 * m.pi / 5)),
y-int(r * m.cos(2 * m.pi /5)),
#右上角
x+int(r * m.sin(2 * m.pi / 5)),
y-int(r * m.cos(2* m.pi /5)),
#左下角
x-int(r * m.sin( m.pi / 5)),
y+int(r * m.cos(m.pi /5)),
# 顶点
x,
y-r,
#右下角
x+int(r * m.sin(m.pi / 5)),
y+int(r * m.cos(m.pi /5))
]
w.create_polygon(points,outline="green",fill="yellow")#空‘’等于透明
mainloop()
.
#模拟画板
from tkinter import *
root=Tk()
w=Canvas(root,width=400,height=200)
w.pack()
def pat(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("" ,pat)
Label(root,text="按住左键画画")
Button(root,text="全部删除",command=(lambda x=ALL:w.delete(x) )).pack()#全部删除
mainloop()
#画多啦A梦
from turtle import *
# 无轨迹跳跃
def my_goto(x, y):
penup()
goto(x, y)
pendown()
# 眼睛
def eyes():
fillcolor("#ffffff")
begin_fill()
tracer(False)
a = 2.5
for i in range(120):
if 0 <= i < 30 or 60 <= i < 90:
a -= 0.05
lt(3)
fd(a)
else:
a += 0.05
lt(3)
fd(a)
tracer(True)
end_fill()
# 胡须
def beard():
my_goto(-32, 135)
seth(165)
fd(60)
my_goto(-32, 125)
seth(180)
fd(60)
my_goto(-32, 115)
seth(193)
fd(60)
my_goto(37, 135)
seth(15)
fd(60)
my_goto(37, 125)
seth(0)
fd(60)
my_goto(37, 115)
seth(-13)
fd(60)
# 嘴巴
def mouth():
my_goto(5, 148)
seth(270)
fd(100)
seth(0)
circle(120, 50)
seth(230)
circle(-120, 100)
# 围巾
def scarf():
fillcolor('#e70010')
begin_fill()
seth(0)
fd(200)
circle(-5, 90)
fd(10)
circle(-5, 90)
fd(207)
circle(-5, 90)
fd(10)
circle(-5, 90)
end_fill()
# 鼻子
def nose():
my_goto(-10, 158)
seth(315)
fillcolor('#e70010')
begin_fill()
circle(20)
end_fill()
# 黑眼睛
def black_eyes():
seth(0)
my_goto(-20, 195)
fillcolor('#000000')
begin_fill()
circle(13)
end_fill()
pensize(6)
my_goto(20, 205)
seth(75)
circle(-10, 150)
pensize(3)
my_goto(-17, 200)
seth(0)
fillcolor('#ffffff')
begin_fill()
circle(5)
end_fill()
my_goto(0, 0)
# 脸
def face():
fd(183)
lt(45)
fillcolor('#ffffff')
begin_fill()
circle(120, 100)
seth(180)
# print(pos())
fd(121)
pendown()
seth(215)
circle(120, 100)
end_fill()
my_goto(63.56,218.24)
seth(90)
eyes()
seth(180)
penup()
fd(60)
pendown()
seth(90)
eyes()
penup()
seth(180)
fd(64)
# 头型
def head():
penup()
circle(150, 40)
pendown()
fillcolor('#00a0de')
begin_fill()
circle(150, 280)
end_fill()
# 画哆啦A梦
def Doraemon():
# 头部
head()
# 围脖
scarf()
# 脸
face()
# 红鼻子
nose()
# 嘴巴
mouth()
# 胡须
beard()
# 身体
my_goto(0, 0)
seth(0)
penup()
circle(150, 50)
pendown()
seth(30)
fd(40)
seth(70)
circle(-30, 270)
fillcolor('#00a0de')
begin_fill()
seth(230)
fd(80)
seth(90)
circle(1000, 1)
seth(-89)
circle(-1000, 10)
# print(pos())
seth(180)
fd(70)
seth(90)
circle(30, 180)
seth(180)
fd(70)
# print(pos())
seth(100)
circle(-1000, 9)
seth(-86)
circle(1000, 2)
seth(230)
fd(40)
# print(pos())
circle(-30, 230)
seth(45)
fd(81)
seth(0)
fd(203)
circle(5, 90)
fd(10)
circle(5, 90)
fd(7)
seth(40)
circle(150, 10)
seth(30)
fd(40)
end_fill()
# 左手
seth(70)
fillcolor('#ffffff')
begin_fill()
circle(-30)
end_fill()
# 脚
my_goto(103.74, -182.59)
seth(0)
fillcolor('#ffffff')
begin_fill()
fd(15)
circle(-15, 180)
fd(90)
circle(-15, 180)
fd(10)
end_fill()
my_goto(-96.26, -182.59)
seth(180)
fillcolor('#ffffff')
begin_fill()
fd(15)
circle(15, 180)
fd(90)
circle(15, 180)
fd(10)
end_fill()
# 右手
my_goto(-133.97, -91.81)
seth(50)
fillcolor('#ffffff')
begin_fill()
circle(30)
end_fill()
# 口袋
my_goto(-103.42, 15.09)
seth(0)
fd(38)
seth(230)
begin_fill()
circle(90, 260)
end_fill()
my_goto(5, -40)
seth(0)
fd(70)
seth(-90)
circle(-70, 180)
seth(0)
fd(70)
#铃铛
my_goto(-103.42, 15.09)
fd(90)
seth(70)
fillcolor('#ffd200')
# print(pos())
begin_fill()
circle(-20)
end_fill()
seth(170)
fillcolor('#ffd200')
begin_fill()
circle(-2, 180)
seth(10)
circle(-100, 22)
circle(-2, 180)
seth(180-10)
circle(100, 22)
end_fill()
goto(-13.42, 15.09)
seth(250)
circle(20, 110)
seth(90)
fd(15)
dot(10)
my_goto(0, -150)
# 画眼睛
black_eyes()
if __name__ == '__main__':
screensize(800,600, "#f0f0f0")
pensize(3) # 画笔宽度
speed(9) # 画笔速度
Doraemon()
my_goto(100, -300)
write('な☆log', font=("Bradley Hand ITC", 30, "bold"))
mainloop()
74.菜单
from tkinter import *
root=Tk()
def cal():
print('你好')
me=Menu(root)
me.add_command(label="hello",command=cal)
me.add_command(label='退出',command=root.quit)
root.config(menu=me)#广联
mainloop()
#下拉菜单
from tkinter import *
root=Tk()
def ss():
print('我是内容')
me=Menu(root)#主菜单窗体
f1=Menu(me,tearoff=False)#下拉窗体#tearoff窗体分离
f1.add_command(label='打开',command=ss)
f1.add_separator()#分割线
f1.add_command(label='退出',command=root.quit)#add_checkbutton()多选按钮；赋值；add_radiobutton()单选按钮
me.add_cascade(label="文件",menu=f1) #下拉窗体名称及返回
root.config(menu=me)#返回主菜单窗体
mainloop()
#右键弹出下拉菜单
from tkinter import *
root=Tk()
def ss():
print('我是内容')
me=Menu(root)#主菜单窗体
me.add_command(label='打开',command=ss)
me.add_command(label='退出',command=root.quit)
f1=Frame(root,width=500,height=521)
f1.pack()
def pop(ev):
me.post(ev.x_root,ev.y_root)
f1.bind("" ,pop)
root.config(menu=me)#返回主菜单窗体
mainloop()
#下拉选择菜单按钮
from tkinter import *
root=Tk()
va1=StringVar()
va1.set("1")
w=OptionMenu(root,va1,"1","2","3")
w.pack()
mainloop()
#扩展
from tkinter import *
root=Tk()
ls=["sad",
"231s",
"sda",
'sad']
va1=StringVar()
va1.set(ls[0])
w=OptionMenu(root,va1,*ls)
w.pack()
mainloop()
75.事件
#鼠标左键事件
from tkinter import *
root=Tk()
def callback(ev):
print('点击的位置',ev.x,ev.y)
fr=Frame(root,width=200,height=200)
fr.bind("" ,callback)#鼠标左键，2；右键
fr.pack()
mainloop()
#按键
from tkinter import *
root=Tk()
def callback(ev):
print(ev.char)#按键
fr=Frame(root,width=200,height=200)
fr.bind("" ,callback)#按键
fr.focus_set()#按键
fr.pack()
mainloop()
#自动获取鼠标位置
from tkinter import *
root=Tk()
def callback(ev):
print('鼠标的位置', ev.x,ev.y)#按键
fr=Frame(root,width=200,height=200)
fr.bind("" ,callback)#按键
fr.pack()
mainloop()
76.事件
#自动换行及强制换行
from tkinter import *
root=Tk()
w1=Message(root,text='这是一张消息',width=100)
w1.pack()
w2=Message(root,text='njasikfisdnfdskndskn\ngs!',width=100).pack()
mainloop()
#限定字符
from tkinter import *
root=Tk()
# w1=Spinbox(root,from_=0,to=10)#;wrap;不限制
w1=Spinbox(root,values=('sda','sadf','safsd'))
w1.pack()
mainloop()
#窗体分割
from tkinter import *
root=Tk()
w1=PanedWindow(showhandle=True,sashrelief=SUNKEN)
w1.pack(fill=BOTH,expand=1)
w2=PanedWindow(orient=VERTICAL,showhandle=True,sashrelief=SUNKEN)
w1.add(w2)
le=Label(w1,text='dsadfaf')
w1.add(le)
top=Label(w2,text='dsaf')
w2.add(top)
bu1=Label(w2,text='dsaf')
w2.add(bu1)
mainloop()
#创建独立窗口
from tkinter import *
root=Tk()
def ss():
top=Toplevel()
top.title('sadf')
msg=Message(top,text='dsafsaf')
Button(root,text='sda',command=ss).pack()
mainloop()
#透明窗口
from tkinter import *
root=Tk()
def ss():
top=Toplevel()
top.attributes('-alpha',0.5)
top.title('sadf')
msg=Message(top,text='dsafsaf')
Button(root,text='sda',command=ss).pack()
mainloop()
77.布局管理器
布局
https://blog.csdn.net/ryuhfxz/article/details/82952622
#按钮右布局
from tkinter import *
root=Tk()
Label(root,text="sadf",bg="red").pack(side=LEFT)
Label(root,text="sadf",).pack(side=LEFT)
Label(root,text="sadf",bg="red").pack(side=LEFT)
mainloop()
#登录布局
from tkinter import *
root=Tk()
pg=PhotoImage(file='QQ截图20210817093650.png')
Label(root,image=pg).grid(row=0,column=2,rowspan=2,padx=5,pady=5)#rowspan=2跨2行；
Label(root,text="用户名").grid(row=0,sticky=W)#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)
Button(text='提交',width=10).grid(row=2,columnspan=3,padx=5,pady=5)#columnspan=3跨3磊局中
mainloop()
#按钮中布局
from tkinter import *
root=Tk()
ph=PhotoImage(file="QQ截图20210817093650.png")
Label(root,image=ph).pack()
def ss():
print('中心')
Button(root,text='sad',command=ss).place(relx=0.5,rely=0.5,anchor=CENTER)
mainloop()
#place按钮中布局
from tkinter import *
root=Tk()
Label(root,bg="red").place(relx=0.5,rely=0.5,relwidth=0.75,relheight=0.75,anchor=CENTER)
Label(root,).place(relx=0.5,rely=0.5,relwidth=0.5,relheight=0.5,anchor=CENTER)
Label(root,bg="red").place(relx=0.5,rely=0.5,relwidth=0.25,relheight=0.25,anchor=CENTER)
mainloop()
Tkinter 模块：标准对话框
https://blog.csdn.net/qq_41556318/article/details/85599883
#打开文件路径
import tkinter as tk
root = tk.Tk()
def callback():
fileName = tk.filedialog.askopenfilename()
print(fileName)
tk.Button(root, text="打开文件", command=callback).pack()
root.mainloop()
#选择颜色
import tkinter as tk
root = tk.Tk()
def callback():
fileName = tk.colorchooser.askcolor()
print(fileName)
tk.Button(root, text="选择颜色", command=callback).pack()
root.mainloop()
六、游戏
78.移动-翻转-更新
#p18_1.py
import pygame
import sys
#初始化
pygame.init()
size = width, height = 1200 ,800
speed = [-2, 1]
bg = (255, 255, 255)
#创建指定大小的窗口
screen = pygame.display.set_mode(size)
#设置窗口标题
pygame.display.set_caption("初次见面，请大家多多关照！")
kfc = pygame.image.load("t015b9754cce0f0249e.png")
#获得图像的位置矩形
position = kfc.get_rect()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
#移动图像
position = position.move(speed)
if position.left < 0 or position.right > width:
#翻转图像
kfc = pygame.transform.flip(kfc, True, False)
#反方向移动
speed[0] = -speed[0]
if position.top < 0 or position.bottom > height:
speed[1] = -speed[1]
#填充背景
screen.fill(bg)
#更新图像
screen.blit(kfc,position)
#更新界面
pygame.display.flip()
#延时 10ms
pygame.time.delay(10)
七、仿真器
总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class Zzck(QMainWindow):
def __init__(self):
super(Zzck, self).__init__()
self.iniUI()
# 主界面布局
def iniUI(self): # 主窗体布局
self.setWindowTitle("我是主窗体")
self.resize(800, 400) #
# self.getGeometry(400, 400, 400, 400)
# 提示信息
self.ts = self.statusBar() # 创建提示功能
self.ts.showMessage("存在5秒消息", 5000)
# 提示信息及局中-sub
self.cetan() # 局中
QToolTip.setFont(QFont("宋体", 12))
self.setToolTip('今天是星期五')
# self.setGeometry(100,100,200,300)
# 退出用用程序按钮button
self.button = QPushButton()
self.button.setText('退出用用程序按')
self.button.clicked.connect(self.on_exit)
# 坐标信息
self.button1 = QPushButton()
self.button1.setText("我是坐标按钮")
self.button1.setToolTip('我是一个提示信息')
self.button1.clicked.connect(self.on_xx1) # 信息槽
# 布局按钮
# 退出用用程序按钮button-布局
# label布局----------------------------------------------------------------------
self.label1 = QLabel(self) # 创建 label 实例
self.label2 = QLabel(self)
label3 = QLabel(self)
label4 = QLabel(self)
# 1
self.label1.setText("这是一个文本标签。") # lable11 添加文字
self.label1.setAutoFillBackground(True)
palette = QPalette() # 创建调色板类实例
palette.setColor(QPalette.Window, Qt.red) # 设置为蓝色
self.label1.setPalette(palette)
self.label1.setAlignment(Qt.AlignCenter) # 设置居中
# 创建滑动块
self.hdk=QSlider(Qt.Horizontal)#创建滑动块(Qt.Vertical)--垂直按钮
self.hdk.setMaximum(25)#最大值
self.hdk.setMinimum(10)#最小值
self.hdk.setSingleStep(1)#步长
self.hdk.setValue(15)#当前值
self.hdk.setTickPosition(QSlider.TicksBelow)#刻度在下方
self.hdk.setTickInterval(1)#设置刻度间隔
self.hdk.valueChanged.connect(self.hdk_1)
#字体切换
self.xzzt = QPushButton('选择字体')
self.xzzt.clicked.connect(self.get_zt)
self.bjys = QPushButton('设置字体颜色')
self.bjys.clicked.connect(self.get_zt1)
self.ztys = QPushButton('设置背景颜色')
self.ztys.clicked.connect(self.get_zt2)
#添加字体大小滑动按钮
self.label2.setText("欢迎使用Python GUI 应用")
label3.setAlignment(Qt.AlignCenter)
label3.setToolTip('这是一个图片标签') # 设置鼠标移动上的一个提示语
label3.setPixmap(QPixmap("img.png")) # 设置 lab12为 图片
label4.setText("欢迎访问百度")
label4.setAlignment(Qt.AlignRight)
label4.setToolTip('这是一个超链接标签')
xzzy = QHBoxLayout() # 字体设置
xzzy.addWidget(self.xzzt)
xzzy.addWidget(self.bjys)
xzzy.addWidget(self.ztys)
# 2
vbox = QVBoxLayout() # 创建一个layout
vbox.addWidget(self.label1) # layout中添加 组件
vbox.addLayout(xzzy)
vbox.addStretch() # 按照比例 分配大小
vbox.addWidget(self.hdk)
vbox.addWidget(self.label2)
vbox.addStretch()
vbox.addWidget(label3)
vbox.addStretch()
vbox.addWidget(label4)
# 3
self.label1.setOpenExternalLinks(True)
# 打开允许访问超链接,默认是不允许，需要使用 setOpenExternalLinks(True)允许浏览器访问超链接
label4.setOpenExternalLinks(False) # 如果改成 True 点击就会访问 链接的网址
# 点击文本框绑定槽事件
def link_clicked():
print("sadf")
label4.linkActivated.connect(link_clicked)
# 划过文本框绑定槽事件
def link_hovered():
print("sadf")
self.label2.linkHovered.connect(link_hovered)
self.label1.setTextInteractionFlags(Qt.TextSelectableByMouse)
# QLineEdit样式--------------------------------------------------
form = QFormLayout() # 表单布局
ed1 = QLineEdit()
ed2 = QLineEdit()
ed3 = QLineEdit()
ed4 = QLineEdit()
form.addRow("Norml", ed1)
form.addRow("NoEcho", ed2)
form.addRow("Password", ed3)
form.addRow("PasswordEchoOnEdit", ed4)
#提示信息
ed1.setPlaceholderText("正常输入")
ed2.setPlaceholderText("回显")
ed3.setPlaceholderText("密码")
ed4.setPlaceholderText("密码半显")
ed1.setEchoMode(QLineEdit.Normal)
ed2.setEchoMode(QLineEdit.NoEcho)
ed3.setEchoMode(QLineEdit.Password)
ed4.setEchoMode(QLineEdit.PasswordEchoOnEdit)
# QLineEdit效验--------------------------------------------------
ed5= QLineEdit()
ed6 = QLineEdit()
ed7 = QLineEdit()
form.addRow("整数", ed5)
form.addRow("浮点", ed6)
form.addRow("数值", ed7)
# 提示信息
ed5.setPlaceholderText("输入整数[1-99]")
ed6.setPlaceholderText("输入浮点数[-999.99~999.99]")
ed7.setPlaceholderText("数值a-A,0-9")
#整数效应器
xde5=QIntValidator(self)
xde5.setRange(1,99)
# 浮点数效应器
xed6=QDoubleValidator(self)
xed6.setRange(-360,360)
xed6.setNotation(QDoubleValidator.StandardNotation)
#两位小数
xed6.setDecimals(2)
# 数值效应器
reg=QRegExp('[a-zA-z0-9]+$')
xe7=QRegExpValidator(self)
xe7.setRegExp(reg)
#设置效应器
ed5.setValidator(xde5)
ed6.setValidator(xed6)
ed7.setValidator(xe7)
# 遮荫马输入
ed8 = QLineEdit()
ed9 = QLineEdit()
ed10 = QLineEdit()
ed11 = QLineEdit()
ed8.setInputMask('000.000.000.000;_')
ed9.setInputMask('HH:HH:HH:HH;_')
ed10.setInputMask('0000-00-00')
ed11.setInputMask('>AAAAA-AAAAA-AAAAA;#')
form.addRow('数字遮掩',ed8)
form.addRow('Mac遮掩', ed9)
form.addRow('日期遮掩', ed10)
form.addRow('许可证遮掩', ed11)
# 长度、文本变化、只读
ed12 = QLineEdit()
ed13 = QLineEdit()
ed14 = QLineEdit('我是不可编辑文本')
ed12.setValidator(QIntValidator())
ed12.setMaxLength(4)#长度不大于4
ed12.setAlignment(Qt.AlignRight)#右侧输入
ed12.setFont(QFont('宋体',20))
ed12.setPlaceholderText("字体20；限制4位数值")
ed13.textChanged.connect(self.on_bh)
ed14.setReadOnly(True)
form.addRow("右侧输入:",ed12)
form.addRow("文本变化:", ed13)
form.addRow("我不渴编辑:", ed14)
# 多行文本
self.ded1=QTextEdit()
button3=QPushButton('显示文本')
button4 = QPushButton('改文本样式')
button5 = QPushButton('获取显示文本')
button6 = QPushButton('获取该文本样式')
#信息操
button3.clicked.connect(self.on_b3)
button4.clicked.connect(self.on_b4)
button5.clicked.connect(self.on_b5)
button6.clicked.connect(self.on_b6)
#属相布局
sxla=QVBoxLayout()
sxla.addWidget(self.ded1)
sxla.addWidget(button3)
sxla.addWidget(button4)
sxla.addWidget(button5)
sxla.addWidget(button6)
#调用本参数名称\
self.button7=QPushButton()
self.button7.setText('我是开关按钮')
self.button7.setCheckable(True)
self.button7.toggle()
#位置调用开光反向
self.button7.clicked.connect(lambda: self.kg_an(self.button7))
self.button7.clicked.connect(self.kg_an1)
# 调用图像按钮
self.button8 = QPushButton()
self.button8.setText('图像按钮1')
self.button8.setIcon(QIcon(QPixmap('img.png')))
self.button8.clicked.connect(lambda: self.kg_an(self.button8))
button9 = QPushButton()
button9.setText('不可用按钮1')
button9.setEnabled(False)
#只能由一个默认按钮
self.button10 = QPushButton('&默认按钮')
self.button10.setDefault(True)
self.button8.clicked.connect(lambda: self.kg_an(self.button10))
#单选按钮
self.rad1=QRadioButton('单选按钮1')
self.rad1.setChecked(True)
self.rad1.toggled.connect(self.rad_an)
self.rad2 = QRadioButton('单选按钮2')
self.rad2.toggled.connect(self.rad_an)
self.rad2.toggled.connect(self.rad_an)
#复选框按钮
self.fxk1=QCheckBox('复选框1')
self.fxk1.setChecked(True)
# self.fxk1.stateChanged.connect(lambda: self.xk_an(self.fxk1))
self.fxk2 = QCheckBox('复选框2')
# self.fxk2.stateChanged.connect(lambda: self.xk_an(self.fxk2))
self.fxk3 = QCheckBox('半选中')
# self.fxk3.stateChanged.connect(lambda: self.xk_an(self.fxk3))
self.fxk3.setTristate(True)
self.fxk3.setCheckState(Qt.PartiallyChecked)
#下拉列表---addItems加入字典-----------
self.la1=QLabel('选择学习语言')
self.cd=QComboBox()
self.cd.addItem('c++')
self.cd.addItem('python')
self.cd.addItem('Java')
self.cd.addItems(['c#','JS','VB'])
self.cd.currentIndexChanged.connect(self.cd_an)
vbox.addWidget(self.la1)
vbox.addWidget(self.cd)
#计数器控件
self.la2 = QLabel() # 显示框
self.sb=QSpinBox()#创建计数器
self.sb.setValue(15)
self.sb.setRange(10,30)#最大和最小值
self.sb.valueChanged.connect(self.sb_sub1)
#对话框
self.button11=QPushButton('提示框QWidget')
self.button11.clicked.connect(self.showQW)
# 另类对话框
self.button15 = QPushButton('关于对话框')
self.button15.clicked.connect(self.showQW1)
self.button16 = QPushButton('消息对话框')
self.button16.clicked.connect(self.showQW1)
self.button17 = QPushButton('警告对话框')
self.button17.clicked.connect(self.showQW1)
self.button18 = QPushButton('错误对话框')
self.button18.clicked.connect(self.showQW1)
self.button19 = QPushButton('提问对话框')
self.button19.clicked.connect(self.showQW1)
#弹出消息获取内容
self.button20= QPushButton('获取列表')
self.dit=QLineEdit()
self.button20.clicked.connect(self.getlb)
self.button21 = QPushButton('获取输入')
self.dit1 = QLineEdit()
self.button21.clicked.connect(self.getwz)
self.button22 = QPushButton('获取整值')
self.dit2 = QLineEdit()
self.button22.clicked.connect(self.getzs)
# label布局----------------------------------------------------------------------
#表布局
bla=QFormLayout()
bla.addRow(self.button20, self.dit)
bla.addRow(self.button21, self.dit1)
bla.addRow(self.button22, self.dit2)
#计数器区域
jsxla=QHBoxLayout()
jsxla.addWidget(self.la2)
jsxla.addWidget(self.sb)
#提示按钮
xlad=QHBoxLayout()
xlad.addWidget(self.button11)
xlad.addWidget(self.button15)
xlad.addWidget(self.button16)
xlad.addWidget(self.button17)
xlad.addWidget(self.button18)
xlad.addWidget(self.button19)
#单选按钮区域
dxla=QHBoxLayout()
dxla.addWidget(self.rad1)
dxla.addWidget(self.rad2)
#复选框
# 单选按钮区域
fxkxla = QHBoxLayout()
fxkxla.addWidget(self.fxk1)
fxkxla.addWidget(self.fxk2)
fxkxla.addWidget(self.fxk3)
#区域2-2\label下方
vbox1=QVBoxLayout()
vbox1.addLayout(vbox)
vbox1.addLayout(xzzy)
vbox1.addLayout(bla)
vbox1.addLayout(jsxla)
vbox1.addLayout(dxla)
vbox1.addLayout(fxkxla)
#区域下1按钮
yla = QHBoxLayout()
yla.addWidget(self.button)
yla.addWidget(self.button1)
yla.addWidget(self.button7)
yla.addWidget(self.button8)
yla.addWidget(button9)
yla.addWidget(self.button10)
#区域2
qy1 = QHBoxLayout() # 区域1
qy1.addLayout(form)
# qy1.addStretch(0)#增加缩进
qy1.addLayout(vbox1)
qy1.addLayout(sxla)
#布局比例
qy1.setStretch(0, 1)
qy1.setStretch(1, 1)
# 区域2
# 全局布局
alllayout = QVBoxLayout() # 创建全局布局
alllayout.addLayout(qy1) # 将布局方式加入全局布局
alllayout.addLayout(yla) # 将布局方式加入全局布局
alllayout.addLayout(xlad)
widget = QWidget() # 创建窗口
widget.setLayout(alllayout) # 窗口设为全局布局
self.setCentralWidget(widget)
# label布局----------------------------------------------------------------------
def cetan(self): # 局中
pmzb = QDesktopWidget().screenGeometry() # 获取屏幕宽度、高度
ckzb = self.geometry() # 界面宽度、高度
gg = (pmzb.width() - ckzb.width()) / 2
ww = (pmzb.height() - ckzb.height()) / 2
self.move(int(gg), int(ww))
def on_exit(self): # 退出
sed = self.sender() # 自定义的槽
print(sed.text() + '按钮被点击')
app = QApplication.instance() # 得到一个实例
app.quit() # 退出程序
# 获取窗体信息
def on_xx1(self):
zct = QWidget() # 创建Qt窗口
print('x= %d' % zct.x())
print('y= %d' % zct.y())
print('界面宽度= %d' % zct.width())
print('界面高度= %d' % zct.height())
def on_bh(self, text):
print("输入内容" + text)
def on_b3(self):
self.ded1.setPlainText("你好！\n"
"我是python")
def on_b4(self):
self.ded1.setHtml(' 你好,我是pyhton '+ '我是\n'
'页眉')
def on_b5(self):
print(self.ded1.toPlainText())
def on_b6(self):
print(self.ded1.toHtml())
def kg_an(self,btn):
print('按钮被点击<'+ btn.text() +'>')
def kg_an1(self):
if self.button7.isChecked():
print('按钮被选中')
else:
print('按钮未选中')
def rad_an(self):
radioButton=self.sender()
if radioButton.isChecked() == True:
print('<'+ radioButton.text() + '>被选中')
else:
print('<' + radioButton.text() + '>未选中')
def fxk_an(self):
# chtus1=self.fxk1.text() +'isChecked=' + str(self.fxk1.isChecked()) + "checkstate=" + str(self.fxk1.checkState()) + '\n'
# # chtus2 = self.fxk2.text() + ',isChecked=' + str(self.fxk2.isChecked()) + "checkstate=" + str(self.fxk2.checkState()) + '\n'
# # chtus3 = self.fxk3.text() + ',isChecked=' + str(self.fxk3.isChecked()) + "checkstate=" + str(self.fxk3.checkState()) + '\n'
# # print(chtus1 + chtus2 + chtus3)
# print(chtus1)
print('复选按钮被点击')
def cd_an(self,i):
self.la1.setText('你选择的是:' + self.cd.currentText())
self.la1.adjustSize()
for count in range(self.cd.count()):
print('itme'+str(count) + "=" + self.cd.itemText(count))
print('你选择的是',i,'相对应的是',self.cd.currentText())
def hdk_1(self):
print('当前值：%s' % self.hdk.value())
sizz=self.hdk.value()
self.label1.setFont(QFont('Arial', sizz)) # 设置字体大小
def sb_sub1(self):
self.la2.setText('当前值:' + str(self.sb.value()))
def gettp1(self):
fname,_=QFileDialog.getOpenFileName(self,'打开文件',".",'图形文件(*.jpg *.png)')
self.labea.setPixmap(QPixmap(fname))
def gettp2(self):
dialong=QFileDialog()
dialong.setFileMode(QFileDialog.AnyFile)
dialong.setFilter(QDir.Files)
if dialong.exec():
fils=dialong.selectedFiles()
f=open(fils[0],'r')
with f:
data=f.read()
self.edtxt.setText(data)
#窗体嵌套
def showQW(self):
dia=QDialog()
dia.resize(400,400)
dia.setWindowTitle('子窗口')
dia.setWindowModality(Qt.ApplicationModal)
self.button12=QPushButton('退出按钮',dia)
# self.button12.move(10,20)
self.button13 = QPushButton('新建窗口', dia)
# self.button13.move(10, 60)
self.button12.clicked.connect(dia.close)
self.button13.clicked.connect(self.shouzQW1)
#加载图片
self.button12a = QPushButton('加载图片', dia)
# self.button12a.move(10, 100)
self.labea=QLabel()
# self.labea.move(10, 160)
self.button12a.clicked.connect(self.gettp1)
# 加载文本
self.button12b = QPushButton('加载文本', dia)
# self.button12b.move(10, 140)
self.edtxt=QTextEdit()
self.button12b.clicked.connect(self.gettp2)
jahla=QVBoxLayout()
jahla.addWidget(self.button12a)
jahla.addWidget(self.labea)
jahla.addWidget(self.button12b)
jahla.addWidget(self.edtxt)
jahla.addWidget(self.button12)
jahla.addWidget(self.button13)
dia.setLayout(jahla)
dia.exec_()
def shouzQW1(self):
dia1 = QDialog()
dia1.move(300,300)
dia1.resize(400, 400)
dia1.setWindowTitle('子窗口')
dia1.setWindowModality(Qt.ApplicationModal)
self.button14 = QPushButton('退出按钮', dia1)
self.button14.move(10, 20)
# self.close()关闭前面窗口
self.button14.clicked.connect(dia1.close)
dia1.exec_()
def showQW1(self):
tex=self.sender().text()
if tex=='关于对话框':
QMessageBox.about(self,'关于','这是一个关于对话框')
elif tex =='消息对话框':
reply=QMessageBox.information(self,'消息','这是一个消息对话框',QMessageBox.Yes |QMessageBox.No)
print(reply == QMessageBox.Yes)
if reply == QMessageBox.Yes:
print('点击确定YES')
elif tex =='警告对话框':
QMessageBox.warning(self,'警告','这是一个警告对话框',QMessageBox.Yes |QMessageBox.No)
elif tex == '错误对话框':
QMessageBox.critical(self, '错误', '这是一个错误对话框', QMessageBox.Yes | QMessageBox.No)
elif tex == '提问对话框':
QMessageBox.question(self, '错误', '这是一个错误对话框', QMessageBox.Yes | QMessageBox.No)
#获取列表
def getlb(self):
tims=('c','c++','python','java')
tim,ok=QInputDialog.getItem(self,'选择语音','列表',tims)
if ok and tim:
self.dit.setText(tim)
# # 获取文字
def getwz(self):
txt, ok = QInputDialog.getText(self, '输入文本框', '请输入文字')
if ok and txt:
self.dit1.setText(txt)
# # 获取整数
def getzs(self):
sum, ok = QInputDialog.getInt(self, '输入文本框', '请输入文字')
if ok and sum:
self.dit2.setText(str(sum))
def get_zt(self):
font,ok=QFontDialog.getFont()
if ok:
self.label1.setFont(font)
#字体颜色
def get_zt1(self):
clor=QColorDialog.getColor()
pp=QPalette()
pp.setColor(QPalette.WindowText, clor)
self.label1.setPalette(pp)
#背景颜色
def get_zt2(self):
clor = QColorDialog.getColor()
pp = QPalette()
pp.setColor(QPalette.Window, clor)
self.label1.setAutoFillBackground(True)
self.label1.setPalette(pp)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = Zzck() # 这里设置图标可以生成应用程序图标
main.show()
sys.exit(app.exec_())