Python基础入门笔记-优快云博客

url = 'http://www.baidu.com'
print(url.removeprefix('http://'))
# www.baidu.com

num = 1_000_000_000
print(num)
# 1000000000

列表

phones = ['华为','苹果','三星','一加']
print(phones)
# ['华为', '苹果', '三星', '一加']

# 获取
print(phones[0])

# 修改
phones[1] = '苹果2'
print(phones)
# ['华为', '苹果2', '三星', '一加']

# 追加
phones.append('小米')
print(phones)
# ['华为', '苹果2', '三星', '一加', '小米']

# 插入  (下标,值)
phones.insert(2,'红米')
print(phones)
# ['华为', '苹果2', '红米', '三星', '一加', '小米']

# 删除 给出要删除的元素下标
del phones[2]
print(phones)
# ['华为', '苹果2', '三星', '一加', '小米']

# 要删除的元素下标
delph = phones.pop(2)
print(delph)
# 三星
print(phones)
# ['华为', '苹果2', '一加', '小米']

# 根据值删除元素
phones.remove('苹果2')
print(phones)
# ['华为', '一加', '小米']

print("-"*20)

# 对列表元素排列顺序的修改永久
num = [3,5,2,8,5,9]
num.sort()
print(num)
# [2, 3, 5, 5, 8, 9]

# True 倒序
num.sort(reverse=True)
print(num)
# [9, 8, 5, 5, 3, 2]

# sorted 保留列表元素原来的排列顺序
num1 = [5,7,9,4,2]
print(sorted(num1,reverse=True))
print(num1)
# [5, 7, 9, 4, 2]

元组

# 定义只包含⼀个元素的元组，必须在这个元素后⾯加上逗号
my_t = (3,)

字典

dir1 = {"name":'小牛',"age":10,"sex":'男'}

print(dir1['name'])
# 小牛

"""
如果是一个不存在的键，会报错，采用get(),如果键不存在，返回一个None
"""
# 报错
# print(dir1['score'])

# 采用get()
result = dir1.get('age')
print(result)
# 10

data = dir1.get('score')
print(data)
# 返回None

列表推导式

print([i for i in range(3,31) if i%3==0])


print([i**3 for i in range(1,6)])

复制列表

arr = [2,3,4,5,6,7,8,9]
arr1 = arr[:]

格式化输出

name = '小王'
age = 119
print(f"姓名:{name},年龄:{age}")

print("姓名:{0},年龄:{1}".format(name,age))

参数

默认参数

def info (name,age=18,sex='女'):
    print(f"{name}---{age}---{sex}")

# 老王---18---女
info("老王")

# 小路---19---女
info("小路",age=19)


# 如果中间是默认，那么最后一个参数要指明
info("小刘",sex="男")

可变参数

# 不确定参数个数
def To(*a):
    # print(a)  此时的a是一个元组 (3, 4, 6, 7, 8, 9)
    result = 0
    for i in a:
        result += i
    return result

t = To(3,4,6,7,8,9)
print(t)    # 37

list1 = [2,3,4]
print(To(*list1))    # 9


# 可变参数  字典
def info(**keys):
    for key,value in keys.items():
        print(key,value)

dir1 = {"name":'小李',"age":18}
info(**dir1)
# name 小李
# age 18

匿名函数

m = lambda x,y:x+y

# 3
print(m(1,2))

递归

走楼梯

def F(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    elif n == 2:
        return 2
    else:
        return F(n-1)+F(n-2)

print(F(8))

斐波拉契

def F(n):
    if n ==0:
        return 
    if n == 1 or n == 2:
        return 1
    else:
        return F(n-1)+F(n-2)
print(F(8))

正则表达式

import  re

# 检测字符串是否为纯数字
result = re.match(r'\d+','8096875498')
print(result)

# 数字字母下划线
result = re.match(r'\w+','hello*64644')
print(result)

# 空白字符
result = re.match(r'\s+','    ')
print(result)

turule

import turtle
pen = turtle.Turtle()
pen.speed(0)
for i in range(100):
    pen.forward(50)
    pen.left(89)
input()

文件

import os

"""读取文件
path = os.getcwd()
# 得到当前文件所在的文件夹目录:D:\python_project
print(path)
# 拼接
filepath = path + '/test.txt'
# D:\python_project/test.txt
print(filepath)
with open(filepath,'r',encoding='utf-8') as f:
    word = f.readlines()
    print(word)
    # hello word
f.close()"""


"""path = os.getcwd()
filepath = path + '/test.txt'
data = '半亩方塘一鉴开,\n天光云影共徘徊.\n问渠那得清如许,\n唯有源头活水来.'
with open(filepath,'w',encoding='utf-8') as f:
    f.write(data)
# 文件存在，会覆盖。否则创建
with open(filepath,'r',encoding='utf-8') as f:
    lines = f.read()
    print(lines)

    半亩方塘一鉴开,
    天光云影共徘徊.
    问渠那得清如许,
    唯有源头活水来.

f.close()"""

# 追加
path = os.getcwd()
filepath = path + '/test.txt'
data = '何须浅碧深红色,\n自是花中第一流.'
with open(filepath,'a',encoding='utf-8') as f:
    f.write(data)
f.close()
'''
半亩方塘一鉴开,
天光云影共徘徊.
问渠那得清如许,
唯有源头活水来.何须浅碧深红色,
自是花中第一流.
'''

csv

import csv
"""with open("./t.csv",'r',encoding='utf-8') as f:
    text = csv.reader(f)
    for line in text:
        print(line)
        # ['name', 'age', 'sex']
        # ['小李', '200', '男']
        # ['小徐', '100，女']
f.close()"""

"""with open("./t.csv",'r',encoding='utf-8') as f:
    text = csv.reader(f)
    # 获取头部信息
    head = next(text)
    score = []
    for line in text:
        # print(line)
        # ['小李', '200', '男']
        # ['小徐', '100，女']

        score.append(int(line[1]))
    print(score)
    # ['200', '100']
    print(sum(score)/len(score))
f.close()
"""

with open("./t.csv",'a',encoding='utf-8') as f:
    line = csv.writer(f)
    # 单行
    line.writerow(['小赵','180','女'])
    # 多行
    data = [['小赵', '180', '女'],['小柳', '109', '女'],['小王', '180', '男']]
    line.writerows(data)

面向对象

实例属性

class Person(object):
    # 初始化函数（构造函数）
    def __init__(self,age,name,sex):
        self.age = age
        self.name = name
        self.sex = sex

man1 =  Person(19,"小赵","男")
print(man1.age,man1.name,man1.sex)
# 19 小赵 男

man1.age = 100
print(man1.age,man1.name,man1.sex)
# 100 小赵 男


man1.height = 1000
print(man1.__dict__)      # 获取对象的所有属性
# {'age': 100, 'name': '小赵', 'sex': '男', 'height': 1000}

类属性

class Person:
    # 类属性
    id = 0
    adult = 18
    def __init__(self,name,age,sex):
        # 实例属性
        self.name= name
        self.age = age
        self.sex = sex
        Person.id += 1
        if age < Person.adult:
            print('未成年')
        else:
            print('成年人')

man = Person("小王",19,"男")
print(man.name,man.age,man.sex)
# 成年
# 小王 19 男

print(man.__dict__)
# {'name': '小王', 'age': 19, 'sex': '男'}

print(f"这个人的ID为：{Person.id}")
# 这个人的ID为：1
print(Person.adult)
# 18

woman = Person("小韩",17,"女")
print(woman.name,woman.age,woman.sex)
# 未成年
# 小韩 17 女

实例方法

class Person:
    def __init__(self,name,age,sex):
        # 实例属性
        self.name= name
        self.age = age
        self.sex = sex
    def show(self):
        print(f"姓名:{self.name},年龄:{self.age},性别:{self.sex}")

man = Person("小王",19,"男")
man.show()
# 姓名:小王,年龄:19,性别:男

类方法

class Person:
    # 类属性
    count = 0
    def __init__(self,name,age,sex):
        # 实例属性
        self.name= name
        self.age = age
        self.sex = sex
        Person.count += 1

    # 类方法-----统计创建的实例个数
    @classmethod
    def get_user(cls):
        print(cls.count)

woman = Person('小玉',19,'女')
Person.get_user()   # 1

man = Person('小刚',19,'男')
Person.get_user()   # 2

静态方法

class Person:
    def __init__(self,name,age,sex):
        # 实例属性
        self.name= name
        self.age = age
        self.sex = sex

    # 静态方法
    @staticmethod
    def Sta(**keys):
        if keys['age'] > 18:
            return True
        else:
            return False
        # print(keys)
        # {'name': '小团', 'age': 19, 'sex': '女'}


info = {"name":'小团','age':19,'sex':'女'}
# 判断字典中的age是否符合，True-创建、反之

if Person.Sta(**info):
    woman = Person('小团', 100, '女')
    print(woman.name,woman.age,woman.sex)
    # 小团 19 女
else:
    print('重新输入')

继承

class Person:
    def __init__(self,name,age,sex):
        # 实例属性
        self.name= name
        self.age = age
        self.sex = sex
    def lifa(self):
        print('这是父类中的方法 -----理发')

class man(Person):
    def __init__(self,name,age,sex,height,wight):

        # 继承父类
        super().__init__(name,age,sex)

        # 子类特有的实例属性
        self.height = height
        self.wight = wight
    def eat(self):
        print('我是子类的方法---吃东西')
    def show(self):
        print(f"{self.name},{self.age},{self.sex},{self.height},{self.wight}")

X_h = man('小黄',19,'男',50,120)

X_h.show()
X_h.lifa()
X_h.eat()

多态

class Animal:
    def make_sound(self):
        pass  # 抽象方法，需要子类来实现

class Dog(Animal):
    def make_sound(self):
        print("汪汪")

class Cat(Animal):
    def make_sound(self):
        print("喵喵")

def animal_sound(animal):
    """此函数接受任何Animal的实例作为参数，演示多态"""
    animal.make_sound()

# 创建不同类型的动物对象
dog = Dog()
cat = Cat()

# 调用函数，传入不同类型的动物，观察多态行为
animal_sound(dog)  # 输出: 汪汪
animal_sound(cat)  # 输出: 喵喵

封装

class Person():
    def __init__(self,name,age):
        self._name = name       # 受保护的变量
        self.__age = age        # 私有变量
    """def show(self):
        print(f"大家好，我是{self._name},我今年{self.__age}岁")"""

    """def _show(self):
        print(f"大家好，我是{self._name},我今年{self.__age}岁")"""

    def __show(self):
        print(f"大家好，我是{self._name},我今年{self.__age}岁")

man = Person('小黄',19)
print(man._name)
# 小黄

# print(man.__age)    # 报错

# man.show()
# 大家好，我是小黄,我今年19岁

# man._show()
# 大家好，我是小黄,我今年19岁

# man.__show()   报错

print(man.__dict__)
# {'_name': '小黄', '_Person__age': 19}

print(man._Person__age)
# 19

print(dir(man))
# '_Person__age', '_Person__show',

man._Person__show()
# 大家好，我是小黄,我今年19岁

get\set

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

    def get_Age(self):
        return self.__age

    def set_Age(self,age):
        if isinstance(age,int):
            self.__age = age
        else:
            raise Exception('年龄必须为整数')

    def __show(self):
        print(f"大家好，我是{self._name},我今年{self.__age}岁")

man = Person('小黄',19)

print(man.get_Age())
# 19

man.set_Age(29)
print(man.get_Age())
# 29

man.set_Age('二十五')
print(man.get_Age())
"""
Traceback (most recent call last):
  File "D:\python_project\01-test.py", line 27, in <module>
    man.set_Age('二十五')
  File "D:\python_project\01-test.py", line 13, in set_Age
    raise Exception('年龄必须为整数')
Exception: 年龄必须为整数
"""

@

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

    """
        把函数当变量使用
            @property:获取变量
            @age.setter:修改变量
            def 变量名 ():
        """
    @property       # 获取变量
    def age(self):
        return self.__age
    @age.setter     # 变量的修改器
    def age(self,age):
        if isinstance(age,int):
            self.__age = age
        else:
            raise Exception('年龄必须为整数')

man = Person('小黄',19)
print(man.age)
# 19

man.age = 29
print(man.age)
# 29


man.age = '三十'
print(man.age)
"""
Traceback (most recent call last):
  File "D:\python_project\01-test.py", line 29, in <module>
    man.age = '三十'
    ^^^^^^^
  File "D:\python_project\01-test.py", line 15, in age
    raise Exception('年龄必须为整数')
Exception: 年龄必须为整数
"""

魔法方法

class Person():
    def __init__(self,name):
        print('__init__被调用')
        self.name = name
    def __str__(self):
        return f"{self.name}"

    def __add__(self, other):
        return self.name + other.name

man = Person('小玉')
woman = Person('小黄')
# __init__被调用

"""
如果Person里没有__str__方法，则调用默认str方法
"""

print(str(man))
# 小玉

# 默认str方法
# print(str(man))
# <__main__.Person object at 0x00000252AA62D4C0>


print(man+woman)
# 小玉小黄

读文件

from pathlib import Path

path = Path("a.txt")
#print(path)
#a.txt

contexts = path.read_text()
#print(contexts)
"""
hello world
hi
python
c
java
"""

lines = contexts.splitlines()
# print(lines)
# ['hello world', 'hi', 'python', 'c', 'java']

for line in lines:
    print(line)
    """
    hello world
    hi
    python
    c
    java
    """

写入

from pathlib import Path

path = Path('a.txt')

line = ('半亩方塘一鉴开\n'
        '天光云影共徘徊\n')

path.write_text(line)

# 会将原来的内容覆盖掉

异常

1. 异常分类

Python 异常大致分为两大类：

内置异常：由Python解释器直接抛出，涵盖了各种常见的编程错误，如语法错误、类型错误、逻辑错误、IO错误、网络错误等。内置异常都是从BaseException类派生出来的，常见的有：
- SyntaxError：语法错误，编译阶段就会发现。
- TypeError：类型错误，如运算符应用于不兼容类型的对象。
- ValueError：值错误，当操作或函数接收到合理类型但不符合预期值时抛出。
- ZeroDivisionError：除以零错误。
- IOError/FileNotFoundError：与文件或输入/输出相关的错误。
- KeyError：尝试访问字典中不存在的键时抛出。
- IndexError：索引超出序列范围时抛出。
- RuntimeError：通用运行时错误。
- Exception：所有内置非系统退出异常的基类，通常用来捕获所有标准异常（不包括SystemExit、KeyboardInterrupt等特殊情况）。
自定义异常：程序员可以根据需要定义自己的异常类，通常继承自已有的内置异常或其他自定义异常，以便更好地描述特定的应用程序错误条件。自定义异常可以增强代码的可读性和可维护性。

2. 异常处理语句

Python 提供了以下几种异常处理语句来捕获和处理异常：

a. `try-except`

最基本的异常处理结构，用于捕获并处理在 try 块中可能出现的异常。

try:
    # 可能引发异常的代码
    risky_operation()
except TypeError:
    # 处理特定类型异常
    print("A TypeError occurred.")
except Exception as e:
    # 处理所有其他异常，并将异常对象赋值给变量e
    print(f"An unexpected error occurred: {e}")

在上面的例子中，如果 risky_operation() 函数引发了 TypeError，对应的 except 子句会被执行；如果没有引发 TypeError 但引发了其他类型的异常（继承自 Exception），第二个 except 子句会被执行，同时异常对象被赋值给变量 e，可以用于获取详细的错误信息。

b. `try-except-else`

else 子句在 try 块成功执行且没有引发任何异常时执行。

try:
    # 可能引发异常的代码
    data = load_data_from_file(filename)
except FileNotFoundError:
    print(f"File {filename} not found.")
else:
    # 如果没有异常，处理数据
    process_data(data)

在这个例子中，如果 load_data_from_file() 成功读取文件，else 子句中的 process_data() 函数会被调用；如果文件不存在，引发 FileNotFoundError，则执行 except 子句的代码。

c. `try-finally`

finally 子句无论是否发生异常，都会被执行。它通常用于资源清理，确保在程序退出异常处理部分时，必要的清理操作（如关闭文件、释放锁等）能够得到执行。

try:
    file = open('example.txt', 'w')
    # 执行可能引发异常的操作
    write_to_file(file)
except IOError as e:
    print(f"An I/O error occurred: {e}")
finally:
    # 不论是否发生异常，都会关闭文件
    file.close()

3. 抛出异常

使用 raise 关键字可以主动抛出一个异常，无论是内置异常还是自定义异常。

raise ValueError("Invalid input value")
class CustomError(Exception):
    pass
raise CustomError("This is a custom error message")

4. 自定义异常

创建自定义异常类通常通过继承内置异常类实现。

class InvalidUserInputError(ValueError):
    def __init__(self, message):
        super().__init__(message)

try:
    user_input = input("Enter a number: ")
    if not user_input.isdigit():
        raise InvalidUserInputError("Non-numeric input provided.")
    number = int(user_input)
except InvalidUserInputError as e:
    print(f"Error: {e}")

在这个例子中，我们定义了一个名为 InvalidUserInputError 的自定义异常类，它继承自 ValueError。当用户输入非数字字符时，我们主动抛出这个自定义异常，并在 except 子句中捕获并打印出错误信息。

5. `exit` 方法与上下文管理器

除了使用 try-except 语句，Python 还支持使用上下文管理器（通过 with 语句）来自动处理异常。这通常涉及定义一个类，该类实现了 __enter__ 和 __exit__ 方法。__exit__ 方法在 with 块结束时被调用，可以接收异常信息并进行适当的清理操作。

class ManagedResource:
    def __enter__(self):
        self.resource = acquire_resource()
        return self.resource

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is not None:
            handle_exception(exc_val)
        release_resource(self.resource)

with ManagedResource() as resource:
    use_resource(resource)

JSON

Python 中的 json 模块提供了对 JavaScript Object Notation (JSON) 数据格式的编码（序列化）和解码（反序列化）功能。JSON 是一种轻量级、易于人阅读和机器解析的数据交换格式，广泛应用于 Web 服务、配置文件、API 接口等场景中。以下是关于 Python 中 JSON 库的主要内容和使用示例：

1. JSON 格式

JSON 数据格式由两种基本结构组成：

对象（Object）：键值对的集合，键（key）是字符串，值（value）可以是字符串、数字、布尔值、数组、另一个对象，或者 null。对象用花括号 {} 包围，键与值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。
```
{
  "name": "Alice",
  "age": 30,
  "is_student": false
}
```
数组（Array）：有序的值列表，值可以是任何 JSON 支持的数据类型（包括其他数组和对象）。数组用方括号 [] 包围，元素之间用逗号 , 分隔。
```
[
  "apple",
  "banana",
  {
    "color": "yellow",
    "weight": 90
  }
]
```

2. Python `json` 模块的主要函数

a. `json.dumps()`

将 Python 对象序列化为 JSON 字符串。

import json

data = {
    "name": "Bob",
    "age": 35,
    "hobbies": ["reading", "gaming"],
    "address": {
        "street": "123 Main St.",
        "city": "Anytown",
        "country": "USA"
    }
}

json_string = json.dumps(data)
print(json_string)

b. `json.loads()`

将 JSON 字符串解析为 Python 对象（通常是 dict 和 list 结构）。

import json
json_string = '{"name": "Alice", "age": 25}'
parsed_data = json.loads(json_string)
print(parsed_data)

c. `json.dump()`

将 Python 对象序列化为 JSON 并写入到一个文件中。

with open("data.json", "w") as f:
    json.dump(data, f)

d. `json.load()`

从一个文件中读取 JSON 数据并解析为 Python 对象

with open("data.json", "r") as f:
    loaded_data = json.load(f)
print(loaded_data)

3. 参数选项

上述函数接受一些可选参数以定制序列化和反序列化的行为，例如：

indent：指定缩进层级，使得生成的 JSON 字符串更易读。默认值为 None（无缩进），设置为正整数可添加缩进。
```
pretty_json = json.dumps(data, indent=4)
```
sort_keys：若为 True，会按字典键的顺序排序后再序列化。默认为 False。
```
sorted_json = json.dumps(data, sort_keys=True)
```

default：提供一个函数，用于将无法直接转换为 JSON 的对象处理为可序列化形式。例如，将自定义类实例转换为字典。

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

person = Person("Charlie", 40)

def person_to_dict(obj):
    return {"name": obj.name, "age": obj.age}

json_str = json.dumps(person, default=person_to_dict)

4. 注意事项

数据类型对应：Python 中的 dict, list, tuple, str, int, float, bool, None 类型可以直接转换为 JSON 对应的数据结构。反之亦然，JSON 解析后得到的是 Python 中的相应类型。
不可序列化类型：某些 Python 类型（如 set, complex, datetime, bytes, NoneType 的实例，以及其他自定义类实例）不能直接转换为 JSON。对于这些类型，需要使用 default 参数提供自定义转换逻辑，或者先将数据转换为可序列化形式。
循环引用：Python 对象间存在循环引用（如对象 A 的属性引用对象 B，而对象 B 又反过来引用对象 A）时，json 模块无法直接处理。需要预先消除循环引用或使用其他库（如 jsonpickle）支持序列化带循环引用的对象。
Unicode：JSON 默认使用 Unicode 编码。在处理包含非 ASCII 字符的字符串时，Python json 模块会自动处理编码和解码。

pip

pip 是 Python 的官方包管理工具，全称为 "Pip Installs Packages" 或 "Pip Installs Python"，用于安装、升级、卸载和管理 Python 软件包及其依赖关系。它是 Python 开发者生态系统中的核心组件，极大地简化了第三方库的获取和维护工作。以下是关于 pip 的详细介绍：

pip --version

查看安装的包的位置

1. 功能

a. 安装包

pip 允许用户通过命令行轻松安装 Python 包。只需提供包名，pip 会从默认的 Python 包索引——Python Package Index (PyPI)——检索并下载所需包及其依赖项，然后将其安装到当前 Python 环境中。基本命令格式如下：

pip install <package_name>

b. 升级包

当需要更新已安装包到最新版本时，pip 提供了升级功能：

pip install --upgrade <package_name>

c. 卸载包

如果不再需要某个包，可以使用 pip 来卸载：

pip uninstall <package_name>

d. 列出已安装包

要查看当前环境中所有已安装的 Python 包及其版本，运行：

pip list

e. 特定版本安装

pip 支持安装特定版本的包，通过在包名后面指定版本号：

pip install <package_name>==<version>

f. 从其他源安装

除了 PyPI，pip 还可以从本地文件系统、Git、Mercurial、Subversion 等多种源安装包，例如：

pip install git+https://github.com/user/repo.git

g. 虚拟环境支持

pip 与 Python 的虚拟环境（如 venv 或 conda 等）无缝集成，使用户能够在独立的环境中安装和管理包，避免不同项目之间的依赖冲突。

2. 历史与集成

pip 由 Ian Bicking 在 2008 年创建，并在随后几年逐渐成为 Python 社区的标准包管理器。自 Python 2.7.9 和 Python 3.4 及更高版本开始，pip 已作为 Python 安装的一部分被默认包含，无需单独安装。对于较早版本的 Python，用户可能需要手动安装 pip。

3. 优势

便捷性：pip 提供了一致且简洁的命令行接口，使得安装、升级、卸载和管理包变得简单快捷。
依赖管理：在安装包时，pip 自动处理其依赖关系，确保所需的所有库都得到正确安装。
版本控制：用户可以指定安装包的确切版本或版本范围，有助于项目稳定性和重现性。
标准化：作为 Python 官方推荐的包管理工具，pip 促进了社区内的标准化和互操作性。
广泛的包库：PyPI 存储了大量可供 pip 安装的开源 Python 包，覆盖了各种应用场景，如 Web 开发、数据分析、机器学习、科学计算等。

4. 使用场景

日常开发：Python 开发者在项目开发过程中频繁使用 pip 安装、更新和管理项目依赖。
环境配置：在项目文档中，开发者通常会提供一个 requirements.txt 文件，列出项目所需的特定版本的包。用户可以通过 pip install -r requirements.txt 快速搭建一致的开发或生产环境。
持续集成/部署：自动化构建和部署流程中，pip 被用来确保运行环境具备正确的软件包版本。
教学与学习：初学者和教师利用 pip 快速安装教学示例或课程所需的库

界面开发

WxPython

import wx

def onclick(event):
    print('点击按钮')
# 创建应用程序对象
app = wx.App()
# 创建窗口
# size:宽高  pos:x  y
frm = wx.Frame(None,size=(500,500),pos=(100,100),title="案例")
# 显示窗口
frm.Show()

# 创建面板
pl = wx.Panel(frm,size=(200,200),pos=(50,50))
pl.Show()

# 创建静态文本
staticText = wx.StaticText(pl,label="欢迎光临",pos=(50,50))
staticText.Show()

# 创建按钮
btn = wx.Button(pl,label="按钮",size=(40,40),pos=(90,90))
btn.Show()

# 给按钮绑定事件
frm.Bind(wx.EVT_BUTTON,onclick,btn)

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

抽奖

import wx
import random

class MyFrame(wx.Frame):
    # 抽奖名单
    list = ['小黄','小赵','小王','小李','小玉','小孙','小于','小胡']
    def __init__(self):
        wx.Frame.__init__(self,None,title='抽奖器',pos=(300,300),size=(500,500))
        # 创建面板
        self.pl = wx.Panel(self,pos=(0,0),size=(500,500))

        # 设置背景颜色
        self.SetBackgroundColour((255,0,100))

        # 创建静态文本
        self.staticText = wx.StaticText(self.pl,label=random.choice(self.list),pos=(220,50),style=wx.TE_CENTER)

        # 创建字体  字体大小、字体包、字体风格、加粗
        font = wx.Font(24,wx.FONTFAMILY_SWISS,wx.FONTSTYLE_NORMAL,wx.FONTWEIGHT_BOLD)
        self.staticText.SetFont(font)

        # 创建按钮
        self.btn1 = wx.Button(self.pl,label='开始抽奖',pos=(100,200))
        self.btn2 = wx.Button(self.pl, label='停止抽奖', pos=(300, 200))
        # 绑定事件
        self.Bind(wx.EVT_BUTTON,self.onClick,self.btn1)
        self.Bind(wx.EVT_BUTTON, self.Stop, self.btn2)
    def onClick(self,event):
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER,self.updata_name,self.timer)
        self.timer.Start(100)
    def updata_name(self,event):
        self.staticText.SetLabelText(random.choice(self.list))
    def Stop(self,event):
        self.timer.Stop()

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

计算机

import wx

class MyFrame(wx.Frame):
    pos_x,pos_y = 10,70
    btn_w,btn_h = 50,50
    def __init__(self):
        # 创建窗口
        wx.Frame.__init__(self,None,title='计算机',pos=(100,100),size=(350,500))
        # 创建面板
        self.pl = wx.Panel(self,pos=(0,0),size=(400,400))
        # 创建输入框
        self.entry = wx.TextCtrl(self.pl,pos=(10,10),size=(300,50),style=wx.TE_RIGHT)
        # 创建按钮
        self.btn_1 = wx.Button(self.pl,label='C',pos=(self.pos_x,self.pos_y),size=(self.btn_w,self.btn_h))
        self.btn_2 = wx.Button(self.pl, label='/', pos=(self.pos_x+80, self.pos_y), size=(self.btn_w, self.btn_h))
        self.btn_3 = wx.Button(self.pl, label='*', pos=(self.pos_x+160, self.pos_y), size=(self.btn_w, self.btn_h))
        self.btn_4 = wx.Button(self.pl, label='<=', pos=(self.pos_x+240, self.pos_y), size=(self.btn_w, self.btn_h))

        self.btn_5 = wx.Button(self.pl, label='7', pos=(self.pos_x, self.pos_y+80), size=(self.btn_w, self.btn_h))
        self.btn_6 = wx.Button(self.pl, label='8', pos=(self.pos_x+80, self.pos_y+80), size=(self.btn_w, self.btn_h))
        self.btn_7 = wx.Button(self.pl, label='9', pos=(self.pos_x+160, self.pos_y+80), size=(self.btn_w, self.btn_h))
        self.btn_8 = wx.Button(self.pl, label='-', pos=(self.pos_x+240, self.pos_y+80), size=(self.btn_w, self.btn_h))

        self.btn_9 = wx.Button(self.pl, label='4', pos=(self.pos_x, self.pos_y+160), size=(self.btn_w, self.btn_h))
        self.btn_10 = wx.Button(self.pl, label='5', pos=(self.pos_x + 80, self.pos_y+160), size=(self.btn_w, self.btn_h))
        self.btn_11 = wx.Button(self.pl, label='6', pos=(self.pos_x + 160, self.pos_y+160), size=(self.btn_w, self.btn_h))
        self.btn_12 = wx.Button(self.pl, label='+', pos=(self.pos_x + 240, self.pos_y+160), size=(self.btn_w, self.btn_h))

        self.btn_13 = wx.Button(self.pl, label='1', pos=(self.pos_x, self.pos_y+240), size=(self.btn_w, self.btn_h))
        self.btn_14 = wx.Button(self.pl, label='2', pos=(self.pos_x + 80, self.pos_y+240), size=(self.btn_w, self.btn_h))
        self.btn_15 = wx.Button(self.pl, label='3', pos=(self.pos_x + 160, self.pos_y+240), size=(self.btn_w, self.btn_h))
        self.btn_16 = wx.Button(self.pl, label='=', pos=(self.pos_x + 240, self.pos_y+240), size=(self.btn_w, self.btn_h))

        self.btn_17 = wx.Button(self.pl, label='0', pos=(self.pos_x, self.pos_y + 320),size=(self.btn_w, self.btn_h))
        self.btn_18 = wx.Button(self.pl, label='.', pos=(self.pos_x + 240, self.pos_y + 320),size=(self.btn_w, self.btn_h))

        # 绑定按钮
        self.Bind(wx.EVT_BUTTON,self.On_btn_1,self.btn_1)
        self.Bind(wx.EVT_BUTTON, self.On_btn_2, self.btn_2)
        self.Bind(wx.EVT_BUTTON, self.On_btn_3, self.btn_3)
        self.Bind(wx.EVT_BUTTON, self.On_btn_4, self.btn_4)
        self.Bind(wx.EVT_BUTTON, self.On_btn_5, self.btn_5)
        self.Bind(wx.EVT_BUTTON, self.On_btn_6, self.btn_6)
        self.Bind(wx.EVT_BUTTON, self.On_btn_7, self.btn_7)
        self.Bind(wx.EVT_BUTTON, self.On_btn_8, self.btn_8)
        self.Bind(wx.EVT_BUTTON, self.On_btn_9, self.btn_9)
        self.Bind(wx.EVT_BUTTON, self.On_btn_10, self.btn_10)
        self.Bind(wx.EVT_BUTTON, self.On_btn_11, self.btn_11)
        self.Bind(wx.EVT_BUTTON, self.On_btn_12, self.btn_12)
        self.Bind(wx.EVT_BUTTON, self.On_btn_13, self.btn_13)
        self.Bind(wx.EVT_BUTTON, self.On_btn_14, self.btn_14)
        self.Bind(wx.EVT_BUTTON, self.On_btn_15, self.btn_15)
        self.Bind(wx.EVT_BUTTON, self.On_btn_16, self.btn_16)
        self.Bind(wx.EVT_BUTTON, self.On_btn_17, self.btn_17)
        self.Bind(wx.EVT_BUTTON, self.On_btn_18, self.btn_18)

    def On_btn_1(self,event):
        self.entry.Clear()

    def On_btn_2(self,event):
        self.entry.AppendText('/')

    def On_btn_3(self,event):
        self.entry.AppendText('*')

    def On_btn_4(self,event):
        text = self.entry.GetValue()
        self.entry.SetValue(text[:-1])

    def On_btn_5(self,event):
        self.entry.AppendText('7')

    def On_btn_6(self,event):
        self.entry.AppendText('8')

    def On_btn_7(self,event):
        self.entry.AppendText('9')

    def On_btn_8(self,event):
        self.entry.AppendText('-')

    def On_btn_9(self,event):
        self.entry.AppendText('4')

    def On_btn_10(self,event):
        self.entry.AppendText('5')

    def On_btn_11(self,event):
        self.entry.AppendText('6')

    def On_btn_12(self,event):
        self.entry.AppendText('+')

    def On_btn_13(self,event):
        self.entry.AppendText('1')

    def On_btn_14(self,event):
        self.entry.AppendText('2')

    def On_btn_15(self,event):
        self.entry.AppendText('3')

    def On_btn_16(self,event):
        text = self.entry.GetValue()
        result = str(eval(text))
        self.entry.SetValue(result)

    def On_btn_17(self, event):
        self.entry.AppendText('0')
    def On_btn_18(self, event):
        self.entry.AppendText('.')



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