Python基础学习笔记

第一章：初识Python

注释

块注释

以#开始，一直到本行结束都是注释

为了保证代码的可读性，#后面建议先添加一个空格，然后再编写相应的说明文字（PEP8规范），如下

1

## 注释内容

行内注释

一般在#前面至少有两个空格（PEP8规范）

1

print(666)  # 注释内容

多行注释

要在python 程序中使用多行注释，可以用一对连续的三个引号(单引号和双引号都可以)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


'''
注释内容
注释内容
注释内容
'''

"""
注释内容
注释内容
注释内容
"""


## 注释内容
## 注释内容
## 注释内容

输出

print()函数

print()函数：print(*objects, sep=' ', end='\n', file=None, flush=False)

sep：设置多个内容之间的分隔符，默认分隔符、空格

end: 设置结束符，默认结束符’\n'

想要在一行中打印多个内容，可以在print()函数中使用逗号隔开多个内容，如下

1

print("今年是", 2025, "年")  # 输出：今年是 2025 年

逗号默认会转化为空格，可以通过设置sep来改变分隔符，如下

1
2


print("今年是", 2025, "年", sep="")  # 输出：今年是2025年
print("今年是", 2025, "年", sep="-")  # 输出：今年是-2025-年

输出结果独占一行是因为print()函数结尾默认是转义字符\n，即换行

1
2
3


print("今年是2025年", end="\t")
print("今天是1月9日", end="!")
## 输出：今年是2025年	今天是1月9日!

格式化输出

如果希望输出文字信息的同时，一起输出数据，就需要使用到格式化操作符

% 被称为格式化操作符，专门用于处理字符串中的格式
- 包含 % 的字符串，被称为格式化字符串
- % 和不同的字符连用，不同类型的数据需要使用不同的格式化字符

print("格式化字符串" % (变量1, 变量2...))

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d 表示输出的整数显示6位数，不足的地方使用 0 补全
%f	浮点数，%.2f 表示小数点后只显示两位
%%	输出 %

1
2
3
4


year = 2025
month = 1
print("现在是%d年%02d月" % (year, month))
输出：现在是2025年01月

输入

input()函数

在 Python 中，如果要获取用户在键盘上的输入信息，需要使用到 input 函数

用户输入的任何内容 Python 都认为是一个 字符串

1
2
3


temp1 = input("请输入第一个数：")
temp2 = input("请输入第二个数：")
print(temp1 + temp2)

输出：

类型转换

可以通过类型转换改变输出的类型

1
2
3


temp1 = int(input("请输入第一个数："))
temp2 = int(input("请输入第二个数："))
print(temp1 + temp2)

输出：

第二章：变量与简单数据类型

变量

多个变量的赋值

1
2
3
4
5


## 多个变量的值相同时
num1 = num2 = num3 = 10

## 多个变量的值不同，元组赋值
a, b = 10, 20

变量的修改

在Python中不同类型的变量也可以进行修改、重新赋值

1
2
3


money = 10
money = "10元"
print(money)  # 输出：10元

变量的数据类型

可以使用type()和isinstance()来判断变量的数据类型

1
2
3
4


temp = "hello"
print(type(temp))  # 输出：<class 'str'>
print(isinstance(temp, str))  # 输出：True
print(isinstance(temp, int))  # 输出：False

Python中的数据类型有如下几个

常量

Python中没有专门的常量类型，一般约定俗成使用大写表示常量

浮点数的误差

可以使用round(表达式, 保留几位)函数四舍五入，在一定程度上消除误差

1
2
3
4
5


n1 = 0.1
n2 = 0.2
print(n1 + n2)  # 输出：0.30000000000000004
print(round(n1 + n2, 2))  # 输出：0.3  （因为计算结果只有1位）
print(round(0.6666, 2))  # 输出：0.67

也可以使用math库里的取整函数

1
2
3
4
5
6
7
8


## 导入math库
import math

## 向上取整 ceil()
print(math.ceil(3.14))  # 输出：4

## 向下取整 floor()
print(math.floor(3.14))  # 输出：3

布尔型

在Python中布尔型的变量只有True和False两种值，注意首字母大写

在Python中，能够解释为假的值有：

None、0、0.0、False、所有的空容器（空列表、空元组、空字典、空集合、空字符串）

字符串

多行字符串

在 Python 中可以使用一对双引号 " 或者一对单引号 ’ 定义一个字符串。

字符串是以单引号或者双引号括起来的任意文本，也可以是以三引号’‘‘或者"““引起来的任意文本。

1
2
3
4
5
6
7


## 多行字符串
str = '''welcome to
my world'''
print(str)
## 输出：
welcome to
my world

字符串乘法

1
2


## 字符串乘法
print("你好" * 3)  # 输出：你好你好你好

字符串索引

可以使用索引获取一个字符串中指定位置的字符，索引计数从 0 开始。

1
2
3
4
5
6
7


str = "0123456"
print(str[0], str[-1])  # 输出：0 6
## 切片   变量名[起始索引:结束索引+1:步数]
## 起始索引默认为0，可省略; 结束索引默认为-1，可省略; 步数默认为1，可省略
print(str[1:-1])  # 输出：12345
print(str[1:-1:2])  # 输出：135  (最后一个值表示读取间隔，默认为1)
print(str[::2])  # 输出：0246

利用切片实现字符串反转

1
2
3


str = "0123456"
strNew = str[::-1]
print(strNew)  # 输出：6543210

数据类型转换

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


## 转换为int
print(int('2024'))  # 输出：2024
## print(int('nihao'))  # 无法转换，会报错
## print(int('2024.1.10'))  # 无法转换，会报错
print(int(2.999))  # 输出：2
print(int(True), int(False))  # 输出：1 0
print(int('15', 10))  # 表示将内容是10进制整数的字符串转换为10进制整数，输出：15
print(int('100110', 2))  # 表示将内容是2进制整数的字符串转换为10进制整数，输出：38
print(int('1f', 16))  # 表示将内容是16进制整数的字符串转换为10进制整数，输出：31
print(int('11', 8))  # 表示将内容是8进制整数的字符串转换为10进制整数，输出：9

## 转换为bool
print(bool(''))  # 输出：False
print(bool('0'))  # 输出：True

第三章：运算符与表达式

算数运算符

运算符优先级

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

运算符优先级

第四章：条件判断

单分支

双分支

多分支

match语句

与其他语言中的switch分支类似

第五章：循环

while循环

1
2
3
4
5
6
7


## 从1加到100的和
num = 1
sum = 0
while num <= 100:
    sum += num
    num += 1
print(sum)

for循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


for i in range(3):
    print(i, end="\t")
## 输出：0	1	2	


## 从1加到100的和
num = 1
sum = 0
for i in range(100):
    sum += num
    num += 1
print(sum)

循环控制

break

continue

pass

第六章：组合数据类型

序列

在python中，有这样一些类型，它们的成员是有序排列的，并且可以通过下标访问成员，这些类型称之为序列。

包括：列表、range、元组和字符串；

序列的通用操作

列表（数组）

List（列表）是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做数组
专门用于存储 一串信息
列表用 [ ] 定义，数据之间使用 , 分隔
列表的索引从 0 开始
索引就是数据在列表中的位置编号，索引又可以被称为下标
注意：从列表中取值时，如果 超出索引范围，程序会报错

创建列表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


## 创建列表
## 语法：
## 列表名 = [元素1, 元素2, ...]

list1 = []
print(type(list1))  # 输出：<class 'list'>

list2 = [123, "你好", True]
print(type(list2), list2)  # 输出：<class 'list'> [123, '你好', True]

list3 = list()  # 类型转换：把参数转换为列表
print(type(list3))

list4 = list("hello")
print(type(list4), list4)  # 输出：<class 'list'> ['h', 'e', 'l', 'l', 'o']

列表的运算

1
2
3
4
5
6
7
8
9


list1 = list("123")
list2 = list("456")
print(list1 + list2)  # 输出：['1', '2', '3', '4', '5', '6']
print(list1 * 2)  # 输出：['1', '2', '3', '1', '2', '3']
print("4" in list1, "4" in list2)  # 输出：False True

## 比较规则：每个数依次比较，若相同则比较各自的下一位，若不同则直接出结果
print([2, 3, 4, 5] < [1, 9, 9, 9])  # 输出：False
print([2, 3, 4, 5] < [3, 0])  # 输出：True

列表内置的部分函数

1
2
3
4
5
6
7


list1 = list("0123456789")
print(len(list1))  # 输出：10
print(max(list1))  # 输出：9
print(min(list1))  # 输出：0

list = [1, 2, 3, 4, 5]
print(sum(list))  # 输出：15

列表的遍历

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


## 直接遍历
list = list("hello")
for i in list:
    print(i, end="\t")
## 输出：h	e	l	l	o	

## 想要索引和内容一起打印可以使用枚举函数enumerate()
list = list("hello")
for index,value in enumerate(list):  # 枚举
    print(index, value)
## 输出：
## 0 h
## 1 e
## 2 l
## 3 l
## 4 o

## 通过索引遍历
list = list("hello")
for i in range(len(list)):
    print(list[i], end="\t")
## 输出：h	e	l	l	o	

列表的常用方法

分类	关键字 / 函数 / 方法	说明
增加	列表.insert (索引，数据)	在指定位置插入数据
增加	列表.append (数据)	在末尾追加数据
增加	列表.extend (列表 2)	将列表 2 的数据追加到列表

修改	列表 [索引] = 数据	修改指定索引的数据

删除	del 列表 [索引]	删除指定索引的数据
删除	列表.remove [数据]	删除第一个出现的指定数据
删除	列表.pop	删除末尾数据
删除	列表.pop (索引)	删除指定索引数据
删除	列表.clear	清空列表

统计	len (列表)	列表长度
统计	列表.count (数据)	数据在列表中出现的次数

排序	列表.sort ()	升序排序
排序	列表.sort (reverse=True)	降序排序
排序	列表.reverse ()	逆序、反转

元组

• Tuple（元组）与列表类似，不同之处在于元组的元素不能修改

• 元组表示多个元素组成的序列

• 用于存储一串信息，数据之间使用 , 分隔

• 元组用 () 定义

1
2
3
4
5
6
7
8
9


tuple1 = (6, "hello", True)
print(tuple1)  # 输出：(6, 'hello', True)
print(type(tuple1))  # 输出：<class 'tuple'>

## 当元组中只存一个数时，为了避免被识别为别的数据类型，要在最后加一个,
tuple1 = (1)
print(type(tuple1))  # 输出：<class 'int'>
tuple2 = (1,)
print(type(tuple2))  # 输出：<class 'tuple'>

元组的常用方法

1
2
3
4
5


tuple1 = (123, 123, 456, "hello")
print(tuple1.count(123))  # 输出：2
print(tuple1.count("he"))  # 输出：0

print(tuple1.index("hello"))  # 输出：3

range

• 系统提供的内建函数range(start=0, end, [step=1])，生成一个等差序列 [start, end)

• 注意序列属于不可变序列，不支持元素修改，不支持+和*操作。

• range一般用于for-in循环遍历

1
2
3


print(list(range(10)))  # end  输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 10)))  # start, end  输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 10, 2)))  # start, end, step  输出：[1, 3, 5, 7, 9]

水仙花练习（利用Python的字符串索引）

三位数，每一位数字的立方和加起来等于这个三位数本身

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


for i in range(100, 1000):
    num = str(i)
    a = int(num[2])
    b = int(num[1])
    c = int(num[0])
    if a**3 + b**3 + c**3 == i:
        print(i)
        
## 输出：
## 153
## 370
## 371
## 407

字符串

字符串也可以使用序列的通用操作

字符串常用方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


s = "  686  hello  "
## 判断含有的字母是否全是小写
print(s.islower())  # 输出：True

## 判断含有的字母是否全是大写
print(s.isupper())  # 输出：False

## 消除字符串首尾的空格
print(s.strip())  # 输出：686  hello

## 将字符串按照给出的分隔符拆成列表
print(s.split('  '))  # 输出：['', '686', 'hello', '']

## 将列表按照指定分隔符连接成字符串
print("/".join(["2024", "1", "12"]))  # 输出：2024/1/12

## 查找指定内容，可以指定起止位置，找不到则返回-1
print(s.find("6"))  # 输出：2
print(s.find("6", 3))  # 输出：4
print(s.find("hi"))  # 输出：-1

字典（dict）

dictionary（字典）是除列表以外 python 之中最灵活的数据类型
字典同样可以用来存储多个数据
通常用于存储描述一个物体的相关信息
和列表的区别

列表是有序的对象集合

字典是无序的对象集合

字典用{}定义，字典使用键值对存储数据，键值对之间使用 , 分隔

• 键 key 是索引

• 值 value 是数据

• 键和值之间使用 : 分隔

• 键必须是唯一的

• 值可以取任何数据类型，但键只能使用字符串、数字或元组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


d = {
    "name": "Lihua",  # 键值对
    "gender": "male",
    "height": 168.5
}
print(d)  # 输出：{'name': 'Lihua', 'gender': 'male', 'height': 168.5}
## 获取键值对
print(d['gender'])  # 输出：male

## 新增键值对
d['salary'] = 3000
print(d)  # 输出：{'name': 'Lihua', 'gender': 'male', 'height': 168.5, 'salary': 3000}

## 修改键值对
d['height'] = 169
print(d)  # 输出：{'name': 'Lihua', 'gender': 'male', 'height': 169, 'salary': 3000}

## 删除键值对
del d['salary']
print(d)  # 输出；{'name': 'Lihua', 'gender': 'male', 'height': 169}

字典的遍历

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


d = {
    "name": "Lihua",
    "gender": "male",
    "height": 168.5
}
print(d.items())  # 输出：dict_items([('name', 'Lihua'), ('gender', 'male'), ('height', 168.5)])
for key, value in d.items():
    print(key, value)
    
## 输出：
## name Lihua
## gender male
## height 168.5

集合（set）

• 不允许有重复元素，如果添加重复元素，则会自动过滤，可以进行交集、并集的运算。

• 是一种无序且无重复元素的数据结构

• 与dict类似，是一组key的集合(不存储value)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


set1 = {1, 2, 3, 1, 2}
print(set1)  # 输出：{1, 2, 3}

set1 = set([1, 2, 4, 1, 2, 4])  # list --> set
print(set1)  # 输出：{1, 2, 4}

set1 = set((1, 2, 3))  # tuple --> set
print(set1)  # 输出：{1, 2, 3}

set1 = set("123")  # str --> set
print(set1)  # 输出：{'2', '3', '1'}  （顺序随机）

set1 = set({'name':'zhangsan', 'age':23})  # dict --> set
print(set1)  # 输出：{'age', 'name'}

print('age' in set1)  # 输出：True
print(len(set1))  # 输出：2

交集和并集

1
2
3
4


set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 & set2)  # 交集，输出：{1, 3, 5}
print(set1 | set2)  # 并集，输出：{1, 2, 3, 4, 5, 7, 9}

用户登录系统小练习

需求：用户输入用户名、密码后，根据用户是否已经注册，用户是否在黑名单中，提示用户是否登录成功

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


## 用户名、密码、黑名单
users = {
    '小红':{'name':'小红', 'password':'123', 'status':True},
    'mia':{'name':'mia', 'password':'456', 'status':True},
    'jack':{'name':'jack', 'password':'789', 'status':False},
}
for j in range(3):
    user = input('请输入你的用户名：')
    pwd = input('请输入你的密码：')
    if user in users and pwd==users[user]['password'] and users[user]['status']:
        print('登录成功！')
        break
    elif user in users and not users[user]['status']:
        print('账号失效，请联系管理员！')
    elif user in users and pwd!=users[user]['password']:
        print('密码输入错误，请重试！')
    else:
        print('用户不存在，请先注册！')

计算天数小练习

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


## 题目要求：输入xxxx-xx-xx(如2025-1-12), 输出这一天是这一年的第多少天
date = input('请输入日期：').split('-')
year = int(date[0])
month = int(date[1])
day = int(date[2])

days = [0,31,28,31,30,31,30,31,31,30,31,30,31]
## 如果是闰年2月加一天
if (not year % 4  and year % 100 ) or not year % 400:
    days[2] += 1

result = 0
for i in range(month):
    result += days[i]
result += day
print('这一天是这一年的第%d天' % result)

第七章：异常处理

常见异常类型

报错类型	描述
AssertionError	当 assert 断言条件为假的时候抛出的异常。
AttributeError	当访问的对象属性不存在的时候抛出的异常
IndexError	超出对象索引的范围时抛出的异常。
KeyError	在字典中查找一个不存在的 key 抛出的异常
NameError	访问一个不存在的变量时抛出的异常。
OSError	操作系统产生的异常。
SyntaxError	语法错误时会抛出此异常。
TypeError	类型错误，通常是不同类型之间的操作会出现此异常。
ZeroDivisionError	进行数学运算时除数为 0 时会出现此异常。

try-except语句（try-catch）

1、首先执行try中【代码块A】，如果出现异常，立即终止代码执行，转而到except块中进行异常处理

2、异常处理except模块可以多个，从上往下匹配，如果能够匹配成功，立即执行相应的异常处理代码块，执行完毕后，不在往下匹配，转到3执行

3、执行异常处理完毕后，如果有finally字句则执行finally字句，如果没有则执行【后续语句】

4、如果匹配不到异常，有finally则执行finally，然后则抛出错误，终止程序执行。

5、如果没有异常，如果有else字句则执行else字句，执行完else后，有finally字句则执行，没有则执行【后续语句】

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


try:
    print("第一行成功运行")
    print(第二行成功运行)
    print("第三行成功运行")
except:
    print("出现异常")

## 输出：
## 第一行成功运行
## 出现异常

## ---------------------------------------------------

try:
    print("第一行成功运行")
    print("1" + 1)
except NameError:
    print("中文给我加引号！")
except TypeError:
    print("Python里不能这么玩")

## 输出：
## 第一行成功运行
## Python里不能这么玩

## ---------------------------------------------------

try:
    print("第一行成功运行")
    print("1" + 1)
except NameError:
    print("中文给我加引号！")
except TypeError as e:
    print("Python里不能这么玩")
    print("报错信息：", e)
else:
    print("else成功运行")
finally:
    print("finally成功运行")

## 输出：
## 第一行成功运行
## Python里不能这么玩
## 报错信息： can only concatenate str (not "int") to str
## finally成功运行

## ---------------------------------------------------

try:
    print("第一行成功运行")
except NameError:
    print("中文给我加引号！")
except TypeError as e:
    print("Python里不能这么玩")
    print("报错信息：", e)
else:
    print("else成功运行")
finally:
    print("finally成功运行")

## 输出：
## 第一行成功运行
## else成功运行
## finally成功运行

raise关键字（throw）

手动抛出一个指定类型的异常，无论是哪种异常类都可以带一个字符串参数，对异常进行描述。

raise不带参数会把错误原样抛出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


try:
    print("第一行成功运行")
    raise Exception ("主动抛出异常")
    print("1111")
except Exception as e:
    print(e)

## 输出：
## 第一行成功运行
## 主动抛出异常

简易计算器小练习

支持加减乘除四则运算，输入不符合规范的时候给出相应提示

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


while True:
    try:
        op = input('请输入一个四则运算算式（例如1+2）：')
        if '+' in op:#加法 14+256
            a = op.split('+')
            result = int(a[0]) + int(a[1])
            print(result)
        elif '-' in op:
            a = op.split('-')
            result = int(a[0]) - int(a[1])
            print(result)
        elif '*' in op:
            a = op.split('*')
            result = int(a[0]) * int(a[1])
            print(result)
        elif '/' in op:
            a = op.split('/')
            result = int(a[0]) / int(a[1])
            print(result)
        elif op=='C':
            print('感谢您使用本计算器！')
            break
        else:
            raise Exception('请按1+2这个格式输入算式！')
    except ZeroDivisionError:
        print('注意除法运算，除数不能为0！')
    except Exception as e:
        print(e)

第八章：函数

函数的定义和调用

使用关键字def

1
2
3
4
5


## 定义函数
def test():
    print("函数被调用")
## 调用函数
test()  # 输出：函数被调用

默认参数

有参数传入时使用传入的参数，没有参数传入时使用默认参数，具有默认值的形参写在最后

1
2
3
4
5


def f(x, y=1):
    return x * y

print(f(2, 3))  # 2*3=6, 输出：6
print(f(2))  # 2*1=2, 输出2

可变参数

在形参前面加一个*号表示该参数为可变参数，可变参数可以自适应传入参数的个数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


def f(*args):  # 可变参数
    sum = 0
    for i in args:
        sum += i
    return sum

print(f(1, 2, 3))  # 输出：6
print(f(1, 2, 3, 4))  # 输出：10

## -----------------------------------------

def f(**kwargs):
    for key, value in kwargs.items():
        print(key, ':', value)
d = {
    'name': 'zhangsan',
    'gender': 'male'
}
f(**d)

## 输出：
## name : zhangsan
## gender : male

## -----------------------------------------

def f(*args):  # 可变参数
    sum = 0
    for i in args:
        sum += i
    return sum

a = [1, 2, 3]
## 传入列表时要在前面加一个*来解列表
print(f(*a))  # 输出：6

变量作用域

在Python中可以通过global在局部修改全局变量

1
2
3
4
5
6
7


num1 = 1
def f():
    global num1  # 声明在f中使用的num1是全局变量num1
    num1 = 2
    print(num1)
f()  # 输出：2
print(num1)  # 输出：2

匿名函数

补充：map()函数

1
2
3
4
5
6
7


## map(函数, 数据集)
## map函数的功能就是把数据集之中的数据依次取出，并将其作为参数传入左边的函数
def Square(x):
    return x**2
list1 = [1, 2, 3, 4]
result = map(Square, list1)
print(list(result))  # 输出：[1, 4, 9, 16]

补充：reduce()累计函数

1
2
3


from functools import reduce  # 导入函数
result = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(result)  # 输出：15

补充：filter()过滤函数

1
2


result = filter(lambda x: x % 2 == 0, range(1,6))  # 只留偶数
print(list(result))  # 输出：[2, 4]

匿名函数的使用

1
2
3
4
5
6
7
8
9


fun = lambda a, b: a + b  # 匿名函数 lambda 形参: 函数体
result = fun(1, 2)
print(result)

## -----------------------------------------

list1 = [1, 2, 3, 4]
result = map(lambda x: x**2, list1)
print(list(result))  # 输出：[1, 4, 9, 16]

内置函数

函数	用途
abs()	对传入参数取绝对值
bool()	对传入参数取布尔值，None, 0, ‘’,[],{},() 这些参数传入 bool 后，返回 False
all()	所有传入参数为真，才为真
any()	任何一个传入参数为真，才为真
ascii()	自动执行传入参数的_repr_方法（将对象转换为字符串）
bin()	接收一个十进制，转换成二进制
oct()	接收一个十进制，转换成八进制
hex()	接收一个十进制，转换成十六进制
bytes()	字符串转换成字节。第一个传入参数是要转换的字符串，第二个参数按什么编码转换为字节
str()	字节转换成字符串。第一个传入参数是要转换的字节，第二个参数是按什么编码转换成字符串
chr(65)	数字转字母，查看 ASCII 码表
ord(‘A’)	字母转数字，查看 ASCII 码表
compile()	接收.py 文件或字符串作为传入参数，将其编译成 python 字节码
eval()	执行 python 代码，并返回其执行结果。
exec()	执行 python 代码（可以是编译过的，也可以是未编译的），没有返回结果（返回 None）
dir()	接收对象作为参数，返回该对象的所有属性和方法
help()	接收对象作为参数，更详细地返回该对象的所有属性和方法
divmod(100,10)	返回一个元组（10,0），第一个元素的 100/10 的商，第二个元素的 100/10 的余数
enumerate()	接收序列化类型的数据，返回一个迭代器（对象）
isinstance(object, class)	判断对象是否是某个类的实例
filter()	对可迭代对象中的每一个元素，将其作为实参传入函数（或 lambda 表达式），如果函数返回 False，将该元素丢弃，如果函数返回 True，将该元素添加到 filter 的返回值中。注意 filter 返回的是一个 filter 对象，实际应用中往往需要用 list 或 tuple 将其转换为列表或元组类型
map()	对可迭代的每一个元素，将其作为实参传入函数，将每一次调用函数返回的结果都添加到 map 的返回值中
format()	字符串格式化
frozenset()	转换为不可变的集合
globals()	返回一个字典，包括所有的全局变量与它的值所组成的键值对
locals()	返回一个字典，包括所有的局部变量与它的值所组成的键值对
hash()	对传入参数取哈希值并返回
id()	返回内存地址，可用于查看两个变量是否指向相同一块内存地址
input(‘please input:’)	提示用户输入，返回用户输入的内容（不论输入什么，都转换成字符串类型）
issubclass(subclass,class)	查看这个类是否是另一个类的派生类，如果是返回 True，否则返回 False
len()	返回长度
max()	接收序列化类型数据，返回其中值最大的元素
min()	返回其中值最小的元素
memoryview()	查看内存地址
next()	通常与迭代器一起使用，用于获取迭代器的下一个元素。
iter()	用于将一个可迭代对象转换为迭代器。
object()	是所有类的基类，创建一个新的对象。
pow(x,y)	求次方，返回 x**y 的结果
pow(x,y,z)	返回 x**y% z 的结果
property()	获取对象的所有属性
range()	获取随机数或随机字符 eg. range (10) 从 0 到 10 的随机数（此处 range () 函数的用途描述有误，range () 函数用于生成一个整数序列，而不是获取随机数或随机字符）
repr()	执行传入对象中的_repr_方法
reversed()	对序列化类型数据反向排序，返回一个新的对象。注意与对象的 reverse 方法区别，后者是就地改变对象
sorted()	对序列化类型数据正向排序，返回一个新的对象。注意与对象的 sort 方法区别，后者是就地改变对象
slice()	对序列化类型数据切片，返回一个新的对象
round()	返回四舍五入后的结果
int()	转换为整型
list()	转换为列表类型
set()	转换为集合类型
str()	转换为字符串类型
tuple()	转换为元组类型
type()	返回对象类型
staticmethod()	返回静态方法
super()	返回基类
vars()	返回当前模块中的所有变量
zip()	接收多个序列化类型的数据，对各序列化数据中的元素，按索引位置分类成一个个元组

名片管理系统小练习

需求：

程序启动，显示名片管理系统欢迎界面，并显示功能菜单
用户用数字选择不同的功能
根据功能选择，执行不同的功能
用户名片需要记录用户的姓名、电话、QQ、邮箱
如果查询到指定的名片，用户可以选择修改或者删除名片

展示菜单：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


cards = [{'name': 'mia', 'phone': '213', 'qq': '3546', 'email': '123'},
{'name': 'jack', 'phone': '124235', 'qq': '23423434', 'email': '3465'},
         {'name': 'tom', 'phone': '234', 'qq': '234', 'email': '09877'}]
def menu():
    print('*'*30)
    print('''欢迎使用【名片管理系统】
    1.新建名片
    2.显示全部
    3.查询名片
    0.退出系统''')
    print('*'*30)
def new_card(name,phone,qq,email):
    user = {
        'name':name,
        'phone':phone,
        'qq':qq,
        'email':email
    }
    cards.append(user)
    return True

def modify_card():
    pass

def del_card():
    pass

def show_card():
    for card in cards:
        print(card)

def query_card(kw):
    for card in cards:
        for k,v in card.items():
            if kw == v:
                return card
    return False

def quit():
    print('欢迎下次使用【名片管理系统】')

menu()
while True:
    op = input('请输入你要操作的序号：')
    if op=='1':
        name = input('请输入你的姓名：')
        phone = input('请输入你的电话：')
        qq = input('请输入你的qq号：')
        email = input('请输入你的电子邮箱：')
        result = new_card(name,phone,qq,email)
        if result:
            print('成功新建名片')
        else:
            print('请重试')
    elif op=='2':
        show_card()
    elif op=='3':
        kw = input('请输入查询的关键字：')
        result = query_card(kw)
        if result:
            print(result)
            op2 = input('输入4修改名片，输入5删除名片：')
            if op2 =='4':
                modify_card()
            if op2=='5':
                del_card()

        else:
            print('没有查到相关信息')
    elif op=='0':
        quit()
        break
    else:
        print('请重试')

第九章：模块

模块的导入

• 模块就好比是工具包，要想使用这个工具包中的工具，就需要导入 import 这个模块

• 每一个以扩展名 py 结尾的 python 源代码文件都是一个模块

• 在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具

可以只导入一个模块中的部分函数，可以防止导入函数过多导致的重名问题

包的使用

• 包是Python模块的一种组织形式，将多个模块组合在一起，形成一个大的Python工具库。包通常是一个拥有__init__.py文件的目录，它定义了包的属性和方法。

常见的标准库

模块	用途
os	os 模块提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等。
sys	sys 模块提供了与 Python 解释器和系统相关的功能，例如解释器的版本和路径，以及与 stdin、stdout 和 stderr 相关的信息。
time	time 模块提供了处理时间的函数，例如获取当前时间、格式化日期和时间、计时等。
datetime	datetime 模块提供了更高级的日期和时间处理函数，例如处理时区、计算时间差、计算日期差等。
random	random 模块提供了生成随机数的函数，例如生成随机整数、浮点数、序列等。
math	math 模块提供了数学函数，例如三角函数、对数函数、指数函数、常数等。
re	re 模块提供了正则表达式处理函数，可以用于文本搜索、替换、分割等。
json	json 模块提供了 JSON 编码和解码函数，可以将 Python 对象转换为 JSON 格式，并从 JSON 格式中解析出 Python 对象。
urllib	urllib 模块提供了访问网页和处理 URL 的功能，包括下载文件、发送 POST 请求、处理 cookies 等。

re库的正则表达式

1
2
3
4
5


import re

## 用正则表达式匹配时，要在正则表达式前面加个r，否则会报错
result = re.match(r'\d+', '1234abcd')
print(result)  # 输出；<re.Match object; span=(0, 4), match='1234'>

time库

1
2
3
4
5
6
7
8
9


import time

print(time.time())  # 获取当前时间戳，输出：1737124413.686656

print(time.localtime())  # 获取结构化的当前时间，输出：time.struct_time(tm_year=2025, tm_mon=1, tm_mday=17, tm_hour=22, tm_min=33, tm_sec=33, tm_wday=4, tm_yday=17, tm_isdst=0)

## 百分号加某个字母表示哪个时间是规定好的
s = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
print(s)  # 输出：2025-01-17 22:33:33

turtle绘图库

1
2
3
4
5
6
7
8


import turtle
pen = turtle.Turtle()
pen.speed(0)
step = 1
while True:
    pen.forward(step)
    pen.left(61)
    step += 1

第十章：文件及IO操作

文件的打开模式

mode	解释
r	只读【默认模式，文件必须存在，不存在则抛出异常】
w	只写，写之前会清空文件的内容，如果文件不存在，会创建新文件
a	追加的方式，在原本内容中继续写，如果文件不存在，则会创建新文件
r+	可读可写
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
b	rb、wb、ab、rb+、wb+、ab + 意义和上面一样，用于二进制文件操作

文件读取

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


## 打开文件
f = open('./text.txt', mode='r', encoding='utf-8')

## 读取文件
context = f.read()
print(context)
## 输出：
## 你好，world
## welcome
## to my
## 世界

## 关闭文件
f.close()

## ----------------------------------------

## 也可以只读文件的部分内容，避免读取文件过大导致崩溃
## 打开文件
f = open('./text.txt', mode='r', encoding='utf-8')
## 读取文件
context = f.read(4)
print(context)  # 输出：你好，w
## 关闭文件
f.close()

## ----------------------------------------

## 还可以按行读，将存成列表形式
## 打开文件
f = open('./text.txt', mode='r', encoding='utf-8')
## 读取文件
context = f.readlines()  # readline()就是只读一行
print(context)  # 输出：['你好，world\n', 'welcome\n', 'to my\n', '世界']
## 关闭文件
f.close()

## ----------------------------------------

## 假设同目录下有一个名为text.txt的文件，内容为：
你好，world
welcome
to my
世界

文件写入和追加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


## 写入内容
## 打开文件
f = open('./text.txt', mode='w', encoding='utf-8')
## 写入文件
context = f.write('你好，世界\nHello,World')
## 关闭文件
f.close()

## 文件写入后的效果：
你好，世界
Hello,World

## -----------------------------------------

## 追加内容
## 打开文件
f = open('./text.txt', mode='a', encoding='utf-8')
## 写入文件
context = f.write('\n我是追加的内容')
## 关闭文件
f.close()

## 文件追加后的效果：
你好，世界
Hello,World
我是追加的内容

with语句

用with语句就不需要手动关闭文件了

1
2
3
4


with open('./text.txt', mode='r', encoding='utf-8') as f:
    # 读取文件
    context = f.read()
    print(context)

csv表格文件的读取和写入

现有一个Test.csv文件，内容如图

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


## 用普通文件的读取方式
with open('./Test.csv', mode='r', encoding='utf-8') as f:
    context = f.read()
    print(context)

## 输出：
A1,B1,
,,C2

## -----------------------------------------------------

## 用csv库的读取方式
import csv
with open('./Test.csv', mode='r', encoding='utf-8') as f:
    cf = csv.reader(f)
    # print(type(cf))  # 输出：<class '_csv.reader'>
    for i in cf:
        print(i)

## 输出：
['A1', 'B1', '']
['', '', 'C2']

## -----------------------------------------------------

## 用csv库的写入方式
import csv
## 不写newline=''时，写入的每行之间都会空一行
with open('./Test.csv', mode='a', encoding='utf-8', newline='') as f:
    cf = csv.writer(f)
    # 一次写入多行可以用二维列表
    lista = [['A3','','C3'], ['', 'B4', '']]
    cf.writerows(lista)

## 此时的文件内容为：
A1,B1,
,,C2
A3,,C3
,B4,

第十一章：面向对象程序设计

类的定义

类的创建与实例化

1
2
3
4
5


class Animal(object):  # object是基类，表示Animal类继承自object，不写时默认为object
    pass

animal = Animal()  # 类的实例化
print(type(animal))  # 输出：<class '__main__.Animal'>

实例属性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Animal(object):  # object是基类
    def __init__(self, breed, name):  # 初始化函数（构造函数），实例化时自动调用
        self.breed = breed  # 实例属性
        self.name = name  # 实例属性

animal1 = Animal('狗', '小白')  # 类的实例化
print(animal1.breed, animal1.name)  # 输出：狗 小白

## __dict__方法用于获取实例对象的所有属性，以字典形式返回
print(animal1.__dict__)  # 输出：{'breed': '狗', 'name': '小白'}

animal2 = Animal('', '')  # 有构造函数时，实例化的时候就不能空着不写，空着会报错
## 所以即使是填''也不能空着直接写Animal()，默认属性有几个就要写几个，空一个都会报错

类属性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


class Player():
    num = 0  # 类属性
    def __init__(self, name):
        self.name = name  # 实例属性
        Player.num += 1

print('当前玩家有%d个玩家' % Player.num)  # 输出：当前玩家有0个玩家
xiaoming = Player('小明')
print('新增玩家', xiaoming.name)  # 输出：新增玩家 小明
print('当前玩家有%d个玩家' % Player.num)  # 输出：当前玩家有1个玩家

## -------------------------------------------------------------

## 类属性的常见用法演示
class Player():
    num = 0
    levelMax = 100
    stage = ['初级', '中级', '高级', '未知']
    def __init__(self, name, level, stage):
        self.name = name
        self.level = level
        self.stage = stage
        Player.num += 1
        if level > Player.levelMax:
            raise Exception('等级异常')
        if stage not in Player.stage:
            raise Exception('阶段异常')

try:
    herta = Player('沉鱼落雁', 100, '未知')
    print('登入成功，登录用户:%s  当前等级:%d  所处阶段:%s' % (herta.name, herta.level, herta.stage))
    wolf = Player('从不作弊', 999, '初级')
except Exception as e:
    print('登录失败', e)
    
## 运行结果：
登入成功，登录用户:沉鱼落雁  当前等级:100  所处阶段:未知
登录失败 等级异常

实例方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Player():
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def show(self):  # 实例的方法
        print('当前玩家：%s，性别：%s' % (self.name, self.gender))

xiaoming = Player('小明', '男')
xiaoming.show()  # 输出：当前玩家：小明，性别：男

类方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class Player():
    num = 0
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
        Player.num += 1

    @classmethod
    def get_num(cls):  # 类方法
        return cls.num

print('当前玩家数：', Player.get_num())  # 输出：当前玩家数： 0
xiaoming = Player('小明', '男')
print('当前玩家数：', Player.get_num())  # 输出：当前玩家数： 1

静态方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Player():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @staticmethod
    def isvalid(**kwargs):  # 静态方法
        if kwargs['age'] >= 18:
            return True
        return False

infos = {'name': '小明', 'age': 16}
if Player.isvalid(**infos):
    xiaoming = Player(**infos)
    print(xiaoming.name, '成功登录')
else:
    print('去学习')

## 运行结果：
去学习

类的继承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class Player():  # 父类
    def __init__(self, name):
        self.name = name

    def show(self):
        print('低贱的普通玩家：%s' % self.name)

class VIP(Player):  # 子类
    # 构造函数重写
    def __init__(self, name, status):
        # 调用父类的构造函数
        super().__init__(name)
        self.status = status

    # 实例方法重写
    def show(self):
        print('至高无上的尊贵玩家：%s' % self.name)

Istar = VIP('Istar', '尊贵的VIP')
print(Istar.name, Istar.status)  # 输出：Istar 尊贵的VIP
Istar.show()  # 输出：至高无上的尊贵玩家：Istar

多态

在编程中，多态是指同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。简单来说，就是用同一种方式去调用不同对象的方法，这些方法可以根据对象的类型做出不同的响应。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class Animal(object):
    # 多态可以大致理解为：父类当形参，子类当实参
    # 父类只是表明有这么个方法，具体实现方式靠子类重写
    def speak(self):
        print("动物叫")

class Dog(Animal):
    def speak(self):
        print("狗叫")

class Cat(Animal):
    def speak(self):
        print("猫叫")

dog = Dog()
cat = Cat()
dog.speak()  # 输出：狗叫
cat.speak()  # 输出：猫叫

封装

在python中，在变量前加一个_表示这是个受保护的变量，加两个_表示这是个私有变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85


class User(object):
    def __init__(self, name, age):
        self._name = name  # 受保护的变量
        self.__age = age  # 私有变量

star = User('星', 2)
print(star._name)  # 输出：星
print(star.__age)  # 报错

## ---------------------------------------------------

## 封装后的修改和获取
class User(object):
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_name(self, name):
        if not isinstance(name, str):
            raise TypeError('Name must be str')
        self.__name = name

    def set_age(self, age):
        if not isinstance(age, int):
            raise TypeError('Age must be int')
        self.__age = age


star = User('星', 2)
print(star.get_age())  # 输出：2
star.set_age(3)
print(star.get_age())  # 输出：3

## ---------------------------------------------------

## 运用装饰器把函数当成变量使用：
"""
用法：
@property
def 变量名():  # 获取变量
	pass
	
@变量名.setter
def 变量名():  # 修改变量
	pass
	
## 注：变量名必须一致
"""
class User(object):
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    @property
    def 名字(self):
        return self.__name

    @property
    def 年龄(self):
        return self.__age

    @名字.setter
    def 名字(self, name):  # 函数名必须与对应@property的函数名一致
        if not isinstance(name, str):
            raise TypeError('Name must be str')
        self.__name = name

    @年龄.setter
    def 年龄(self, age):  # 函数名必须与对应@property的函数名一致
        if not isinstance(age, int):
            raise TypeError('Age must be int')
        self.__age = age


star = User('星', 2)

print(star.名字)  # 输出：星
star.年龄 = 3
print(star.年龄)  # 输出：3

第十二章：界面开发

第三方库wxpython

首先要在终端输入 pip install wxpython下载wxpython库

使用时使用import wx导入wxpython库

简单布局

一个普通的窗口布局如下图所示

下面是简单演示wxpython库的部分功能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import wx
## 定义点击事件
def onClick(event):
    print('btn被点击')


## 创建应用程序对象
app = wx.App()
## 创建窗口,size表示大小，pos表示位置
frm = wx.Frame(None, title='窗口学习', size=(500, 400), pos=(500, 200))
## 显示窗口
frm.Show()
## 在frm窗口上创建面板
pl = wx.Panel(frm, size=(500, 400))
## 显示面板
pl.Show()
## 在pl面板上创建静态文本
staticText = wx.StaticText(pl, label='欢迎学习Python！', pos=(200, 150))
## 在pl面板上创建按钮
btn = wx.Button(pl, label='点击', pos=(200, 200))
## 给frm窗口绑定点击btn按钮的事件
frm.Bind(wx.EVT_BUTTON, onClick, btn)

## 进入主循环，让窗口一直显示
app.MainLoop()

运行效果：

窗口类

接下来用面向对象的思想来写窗口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import wx

class MyFrame(wx.Frame):
    # 构造方法
    def __init__(self):
        wx.Frame.__init__(self, None, title='窗口类的学习')
        # 创建面板
        pl = wx.Panel(self)
        # 创建静态文本
        staticText = wx.StaticText(pl, label='欢迎学习Python！')
        # 创建按钮
        btn = wx.Button(pl, label='按钮', pos=(100,100))


## 创建应用程序对象
app = wx.App()
## 创建窗口
frm = MyFrame()
## 显示窗口
frm.Show()

运行效果：

抽奖器练习

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


import wx
import random

class MyFrame(wx.Frame):
    # 构造方法
    def __init__(self):
        wx.Frame.__init__(self, None, title='抽奖器', size=(500, 200), pos=(500, 300))
        # 创建面板
        self.pl = wx.Panel(self, size=(500, 200), pos=(0, 0))
        # 设置背景颜色
        self.SetBackgroundColour((255, 255, 90))
        # 创建静态文本，文本高度设置为0时，会根据字体大小自动选择合适大小，style=wx.TE_CENTRE表示文字居中
        self.staticText = wx.StaticText(self.pl, label='欢迎使用抽奖器！', pos=(0, 30), size=(500, 0), style=wx.TE_CENTRE)
        # 创建字体
        # Font()函数的参数分别为：字体大小，字体包，字体风格，字体加粗
        font = wx.Font(26, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD)
        # 将静态文本设置为创建的字体
        self.staticText.SetFont(font)
        # 创建按钮
        self.btn1 = wx.Button(self.pl, label='开始抽奖', pos=(150,100))
        self.btn2 = wx.Button(self.pl, label='停止抽奖', pos=(250,100))
        # 绑定事件
        self.Bind(wx.EVT_BUTTON, self.onClick, self.btn1)
        self.Bind(wx.EVT_BUTTON, self.stop_update, self.btn2)

    def onClick(self, event):
        self.timer = wx.Timer(self)  # 创建一个定时器
        self.Bind(wx.EVT_TIMER, self.update_name, self.timer)
        self.timer.Start(100)  # 每隔100毫秒调用一次绑定的函数
        # 此处不用担心多次点击造成开启多个定时器的问题

    def update_name(self, event):
        # 随机设置面板内容
        self.staticText.SetLabelText(str(random.randint(1, 100)))

    def stop_update(self, event):
        try:
         self.timer.Stop()  # 关闭定时器
        except:
            print('请先开始抽奖')


if __name__ == '__main__':  # 表示Python程序的主入口
    # 创建应用程序对象
    app = wx.App()
    # 创建窗口
    frm = MyFrame()
    # 显示窗口
    frm.Show()
    # 让窗口一直显示
    app.MainLoop()

效果：

抽奖演示