公告

日历

将列表中各字符串值为键，各字符串的长度为值，组成键值对

newdict = {key:len(key) for key in listdemo}
newdict

通过 id() 函数来查看内存地址变化：

迭代器
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：iter() 和 next()。

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")

生成器
yield是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。

def countdown(n):
while n > 0:
yield n
n -= 1

创建生成器对象

generator = countdown(5)

通过迭代生成器获取值

print(next(generator)) # 输出: 5
print(next(generator)) # 输出: 4
print(next(generator)) # 输出: 3

使用 for 循环迭代生成器

for value in generator:
print(value) # 输出: 2 1

with语句用法

with open('example.txt', 'r') as file:
content = file.read()
print(content)
1.优先使用 with 管理资源：对于文件、网络连接、锁等资源，总是优先考虑使用with语句。
2.保持上下文简洁：with 块中的代码应该只包含与资源相关的操作。

函数
1.默认参数与关键字参数

设置默认参数，且不按照顺序

def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return

printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )
名字: runoob
年龄: 50

名字: runoob
年龄: 35

2.不定长参数
以元组方式导入：

def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

示例：

def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)

printinfo( 70, 60, 50 )
70
(60, 50)

以字典方式导入：

def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]

示例：

def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)

printinfo(1, a=2,b=3)
1

3.单独占位星号
示例

def f(a,b,*,c):
return a+b+c

f(1,2,3) # 报错
Traceback (most recent call last):
File "", line 1, in
TypeError: f() takes 2 positional arguments but 3 were given

f(1,2,c=3) # 正常
6

4.匿名函数
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数是匿名的，它们没有函数名称，只能通过赋值给变量或作为参数传递给其他函数来使用。
lambda 函数通常只包含一行代码，这使得它们适用于编写简单的函数。

lambda [arg1 [,arg2,.....argn]]:expression

示例：

sum = lambda arg1, arg2: arg1 + arg2

调用sum函数

print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

也可以将匿名函数封装在一个函数内
示例：

def myfunc(n):
return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11))
print(mytripler(11))

装饰器
装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。装饰器的语法使用 @decorator_name 来应用在函数或方法上。原函数→装饰器→新函数。
Python还提供了一些内置的装饰器，比如@staticmethod 和 @classmethod，用于定义静态方法和类方法。
1.正常用法
示例：

def my_decorator(func):
def wrapper():
print("在原函数之前执行")
func()
print("在原函数之后执行")
return wrapper

@my_decorator
def say_hello():
print("Hello!")

say_hello()
在原函数之前执行
Hello!
在原函数之后执行

my_decorator 是一个装饰器函数，它接受 say_hello 作为参数，并返回 wrapper 函数。
@my_decorator 将 say_hello 替换为 wrapper。

2.带参数的方法
示例：

def repeat(num_times):
def decorator(func):
def wrapper(args, **kwargs):
for _ in range(num_times):
func(args, **kwargs)
return wrapper
return decorator

@repeat(3)
def say_hello():
print("Hello!")

say_hello()

Hello!
Hello!
Hello!

3.类装饰器
·函数形式的类装饰器（接收类作为参数，返回新类）
·类形式的类装饰器（实现 call 方法，使其可调用）

python模块
support.py func()

import support
support.func()

from support import func
func()

from support import *
func()

每个模块都有一个 name 属性。
·如果模块是被直接运行，name 的值为 main。
·如果模块是被导入的，name 的值为模块名。

dir() 函数可以看到模块内定义的所有名称。

import sys
dir(sys)

包
比如一个模块的名称是 A.B，那么他表示一个包 A中的子模块 B 。比如一个模块的名称是 A.B，那么他表示一个包A中的子模块B。
·在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
·目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。
·最简单的情况，放一个空的 :file:init.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。

示例：
sound/ 顶层包
init.py 初始化 sound 包
formats/ 文件格式转换子包
init.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ 声音效果子包
init.py
echo.py
surround.py
reverse.py
...
filters/ filters 子包
init.py
equalizer.py
vocoder.py
karaoke.py
...

import sound.effects.echo

此时必须全名访问：sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

from sound.effects import echo

此时可以echo.echofilter(input, output, delay=0.7, atten=4)

from sound.effects.echo import echofilter

此时直接echofilter(input, output, delay=0.7, atten=4)

总而言之，from Package import specific_submodule

try&except语句

示例：

try:
runoob()
except AssertionError as error:
print(error)
else:
try:
with open('file.log') as file:
read_data = file.read()
except FileNotFoundError as fnf_error:
print(fnf_error)
finally:
print('这句话，无论异常是否发生都会执行。')

使用raise触发异常：

x = 10
if x > 5:
raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

执行以上代码会触发异常：

Traceback (most recent call last):
File "test.py", line 3, in
raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10

使用assert触发异常：
assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常

assert True # 条件为 true 正常执行
assert False # 条件为 false 触发异常
Traceback (most recent call last):
File "", line 1, in
AssertionError
assert 11 # 条件为 true 正常执行
assert 12 # 条件为 false 触发异常
Traceback (most recent call last):
File "", line 1, in
AssertionError

assert 1==2, '1 不等于 2'
Traceback (most recent call last):
File "", line 1, in
AssertionError: 1 不等于 2

类和对象
1.构造函数

class Complex:
def init(self, realpart, imagpart): #当定义一个类，并在类中定义方法时，第一个参数通常被命名为self
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i) # 输出结果：3.0 -4.5

2.继承

class people:
#定义构造方法
def init(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))

单继承示例

class student(people):
grade = ''
def init(self,n,a,w,g):
#调用父类的构函
people.init(self,n,a,w) #至关重要
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()
ken 说: 我 10 岁了，我在读 3 年级

3.多继承

类定义

class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def init(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))

单继承示例

class student(people):
grade = ''
def init(self,n,a,w,g):
#调用父类的构函
people.init(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

另一个类，多继承之前的准备

class speaker():
topic = ''
name = ''
def init(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

多继承

class sample(speaker,student):
a =''
def init(self,n,a,w,g,t):
student.init(self,n,a,w,g)
speaker.init(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默认调用的是在括号中参数位置排前父类的方法
我叫 Tim，我是一个演说家，我演讲的主题是 Python

子类重写父类的函数会覆盖。

4.类的私有

attributes

class Site:
def init(self, name, url):
self.name = name # public
self.__url = url # private
def who(self):
    print('name  : ', self.name)
    print('url : ', self.__url)

def __foo(self):          # 私有方法
    print('这是私有方法')

def foo(self):            # 公共方法
    print('这是公共方法')
    self.__foo()

x = Site('菜鸟教程', 'www.runoob.com')
x.who() # 正常输出
x.foo() # 正常输出
x.__foo() # 报错

5.运算符重载

class Vector:
def init(self, a, b):
self.a = a
self.b = b

def str(self):
return 'Vector (%d, %d)' % (self.a, self.b)

def add(self,other):
return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
Vector（7,8）

虚拟环境

查看版本

python3 --version

创建虚拟环境

python3 -m venv 环境名称 #感觉不如conda create -n venv python=3.10

导出包依赖

(.venv) pip freeze > requirements.txt

安装包依赖

(.venv) pip install -r requirements.txt

创建继承包的环境

python -m venv --system-site-packages .venv

查看在哪个虚拟环境中

which python

类型注释

没有类型注解

def greet(name):
return f"Hello, {name}"

有类型注解

def greet(name: str) -> str:
return f"Hello, {name}"
如果注解错了会怎么样--类型检查器会报错，但程序仍然可以运行。注解只是"提示"而不是"强制"。

常见包
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 等。

pip --version 查看已安装包的版本
pip list 查看已安装的包

openai包
示例

import os
from openai import OpenAI

client = OpenAI(
# This is the default and can be omitted
api_key="你申请的 API key",
)

response = client.responses.create(
model="gpt-4o",
instructions="You are a coding assistant that talks like a pirate.",
input="How do I check if a Python object is an instance of a class?",
)

print(response.output_text)

pyecharts用法
https://www.runoob.com/python3/python-pyecharts.html
sys用法
https://www.runoob.com/python3/python-sys.html

PyQt5用法
pip install PyQt5
pip install PyQt5-tools

posted on 2025-12-11 21:00 coins30 阅读(9) 评论(1) 收藏举报

刷新页面返回顶部


博客园 © 2004-2026 浙公网安备 33010602011771号浙ICP备2021040463号-3

导航