一、函数
python
# 函数
# 函数的定义以 def 关键字开头，后面接函数名，括号里是参数，函数体缩进，return是返回
# 函数的命名和变量一样，尽量使用小写字母和下划线
# _开头的变量名是python的保护变量，只能子类和同包下访问，但这不是python语法，而是约定俗成
# __开头的变量名是python的私有变量，不能被外部访问，但这不是python语法，而是约定俗成
def add(a, b):
return a + b
# 函数入参默认值
def add_default(a, b=1): # 如果b没有传值，则默认为1
return a + b
# 定义函数标准的写法
# 1. 有文档注释，且在描述下方空一行
# 2. 指定入参变量类型、默认值，也指定返回值类型
# 例： 入参两个int类型变量，默认值是1，返回值是int类型
def add_default_type(a: int, b: int = 1) -> int:
"""
两数相加
:param a:
:param b:
:return:
"""
return a + b
# 全局变量和局部变量
# 全局变量是指在函数外定义的变量，局部变量是指在函数内定义的变量
# 局部变量的作用域是函数内，函数外无法访问
# 变量的取值原则遵循就近原则，先从方法内部开始查找，找不到再从上层方法找，找不到再从全局变量找，找不到再从python库中找，如果都没有，则报错
# global 关键字，声明在函数内部使用或定义全局变量
a = 100
def foo():
# 全局变量
global a
a = 200
print(a)
foo() # 输出200
print(a) # 输出200
# nonlocal关键字，声明在函数内部使用上层嵌套函数的变量
b = 100
def foo():
# 局部变量
b = 200
def bar():
nonlocal b
b = 300
print(b)
bar()
print(b)
foo() # 输出300 300
print(b) # 输出100
# 给变量格式化输出，补全缺失的位数
ball = 1
print(f"{ball:0>2d}") # 输出01
def foo(a, b, c):
print(a, b, c)
# 位置参数
# 正常传参对号入座，这种参数称为位置参数
foo(1, 2, 3)
# 关键字参数，可以不用对号入座
foo(b=1, a=2, c=3)
# 命名关键字参数
# 写在 * 后面的参数，称为命名关键字参数， 这些参数在传参时必须指定参数名
# 关键字参数只能出现在位置参数的后面
def foo(a, b, *, c):
print(a, b, c)
print(foo(1, 2, c=3)) # * 后面的参数必须指定参数名
# 可变参数
# 可变参数前面用 * 号修饰，函数调用时，可变参数会以元组方式传入，可接收0个或多个参数
# 可变参数只能接受位置参数不能接受关键字参数
def foo(*args):
print(args, type(args)) # (1, 2, 3) <class 'tuple'>
foo(1, 2, 3)
# 如果即要接受可变参数，又要接受关键字参数，那么可以使用 ** 来修饰，函数调用时，** 后面的参数必须指定参数名
# ** 后面的参数以 字典的方式传入，可接收0个或多个参数
# ** 后面的参数只能接受关键字参数不能接受位置参数
# 注意，同时出现位置参数和关键字参数，位置参数一定要写在前面
def foo2(*args, **kwargs):
print(kwargs, type(kwargs)) # {'d': 4, 'e': 5} <class 'dict'>
print(args, type(args)) # (1, 2, 3) <class 'tuple'>
foo2(1, 2, 3, d=4, e=5)
# Python中的函数是一等函数
# 1. 函数可以作为参数传递给其他函数
# 2. 函数可以作为函数的返回值返回
# 3. 函数可以作为变量赋值给其他变量
# 如果把函数作为参数传递给其他函数，那么这个函数就称为高阶函数
# Lambda 表达式
# 1. 匿名函数，即没有函数名
# 2. 通常一句代码就能搞定，表达式就是函数的返回值
def add(a, b):
return a + b
# 上述函数转为lambda表达式
add = lambda a, b: a + b二、引用函数
如果不清楚一个函数的具体用法，可以选择这个函数，使用 shift + F1 调出它的官网文档查看使用说明
math
python
# 导入math模块的modf函数，并重命名为m
from math import modf as m
# 取模
print(m(3.5))
import math # 导入math模块以使用其提供的数学函数
# 基本数学函数
# math.ceil返回大于或等于4.3的最小整数
print(math.ceil(4.3)) # 输出: 5
# math.floor返回小于或等于4.7的最大整数
print(math.floor(4.7)) # 输出: 4
# math.fabs返回-5的绝对值
print(math.fabs(-5)) # 输出: 5.0
# math.factorial返回5的阶乘（5! = 5 * 4 * 3 * 2 * 1）
print(math.factorial(5)) # 输出: 120
# math.fmod返回7除以3的余数
print(math.fmod(7, 3)) # 输出: 1.0
# math.gcd返回48和18的最大公约数
print(math.gcd(48, 18)) # 输出: 6
# math.isfinite如果x不是无穷大或NaN，则返回True
print(math.isfinite(10)) # 输出: True
# math.isinf如果x是正无穷大或负无穷大，则返回True
print(math.isinf(float('inf'))) # 输出: True
# math.isnan如果x是NaN（非数字），则返回True
print(math.isnan(float('nan'))) # 输出: True
# math.trunc返回x的截断整数值
print(math.trunc(4.7)) # 输出: 4
# 幂和对数函数
# math.exp返回e的1次幂（即自然常数e的值）
print(math.exp(1)) # 输出: 2.718281828459045
# math.log返回10在以10为底的对数
print(math.log(10, 10)) # 输出: 1.0
# math.log10返回10的以10为底的对数
print(math.log10(10)) # 输出: 1.0
# math.pow返回2的3次幂
print(math.pow(2, 3)) # 输出: 8.0
# math.sqrt返回16的平方根
print(math.sqrt(16)) # 输出: 4.0
# 三角函数
# math.sin返回π/2（90度）的正弦值
print(math.sin(math.pi / 2)) # 输出: 1.0
# math.cos返回0弧度（0度）的余弦值
print(math.cos(0)) # 输出: 1.0
# math.tan返回π/4（45度）的正切值
print(math.tan(math.pi / 4)) # 输出: 0.9999999999999999
# math.asin返回1的反正弦值，结果在[-π/2, π/2]之间
print(math.asin(1)) # 输出: 1.5707963267948966 (π/2)
# math.acos返回1的反余弦值，结果在[0, π]之间
print(math.acos(1)) # 输出: 0.0
# math.atan返回1的反正切值，结果在[-π/2, π/2]之间
print(math.atan(1)) # 输出: 0.7853981633974483 (π/4)
# math.atan2返回1/1的反正切值，结果在[-π, π]之间
print(math.atan2(1, 1)) # 输出: 0.7853981633974483 (π/4)
# 双曲函数
# math.sinh返回1的双曲正弦值
print(math.sinh(1)) # 输出: 1.1752011936438014
# math.cosh返回1的双曲余弦值
print(math.cosh(1)) # 输出: 1.5430806348152437
# math.tanh返回1的双曲正切值
print(math.tanh(1)) # 输出: 0.7615941559557649
# math.asinh返回1的反双曲正弦值
print(math.asinh(1)) # 输出: 0.881373587019543
# math.acosh返回2的反双曲余弦值
print(math.acosh(2)) # 输出: 1.3169578969248166
# math.atanh返回0.5的反双曲正切值
print(math.atanh(0.5)) # 输出: 0.5493061443340549
# 常量
# 常量π的值
print(math.pi) # 输出: 3.141592653589793
# 常量e的值
print(math.e) # 输出: 2.718281828459045time
python
# 导入time模块
import time
import datetime
# 时间获取与转换
# time.time() 返回当前时间的时间戳（自1970年1月1日以来的秒数）
print(time.time()) # 输出: 1684394400.0 (示例时间戳)
# time.sleep(seconds) 暂停程序执行指定的秒数
time.sleep(1) # 程序暂停1秒
# time.localtime([timestamp]) 将时间戳转换为本地时间元组
local_time = time.localtime()
print(local_time) # 输出: time.struct_time(tm_year=2024, tm_mon=5, tm_mday=25, tm_hour=21, tm_min=23, tm_sec=45, tm_wday=5, tm_yday=146, tm_isdst=0)
# 使用datetime模块将时间元组转换为时间戳
datetime_object = datetime.datetime(*local_time[:6])
timestamp = datetime_object.timestamp()
print(timestamp) # 输出: 1684394096.0 (示例时间戳)
# time.strftime(format[, t]) 根据给定格式和时间元组生成字符串
formatted_time = time.strftime('%Y-%m-%d %H:%M:%S', local_time)
print(formatted_time) # 输出: '2023-05-27 12:34:56' (示例格式化时间字符串)
# time.strptime(string, format) 将字符串解析为时间元组
parsed_time = time.strptime('2023-05-27 12:34:56', '%Y-%m-%d %H:%M:%S')
print(parsed_time) # 输出: time.struct_time(tm_year=2023, tm_mon=5, tm_mday=27, tm_hour=12, tm_min=34, tm_sec=56, tm_wday=5, tm_yday=147, tm_isdst=-1) (示例解析后的时间元组，包含时区信息)
# 时间差计算
# time.time() 用于计算两个时间戳之间的差值
start_time = time.time()
# 执行一些操作...
end_time = time.time()
execution_time = end_time - start_time
print(execution_time) # 输出: 0.001234 (示例操作执行时间，单位：秒)
# datetime 模块结合使用
now = datetime.datetime.now()
future = now + datetime.timedelta(hours=2)
diff = future - now
print(diff.total_seconds()) # 输出: 7200.0 (示例时间差，单位：秒)random
python
# 导入random模块
import random
# 基本随机数生成
# random.random() 生成0到1之间的浮点数（包括0但不包括1）
print(random.random()) # 输出: 0.12345678901234567
# random.uniform(a, b) 生成a和b之间（包括两端点）的浮点数
print(random.uniform(1, 10)) # 输出: 3.456789
# random.randint(a, b) 生成a和b之间（包括两端点）的整数
print(random.randint(1, 10)) # 输出: 8
# random.choice(seq) 从序列中随机选择一个元素
my_list = ['apple', 'banana', 'cherry']
print(random.choice(my_list)) # 输出: 'banana'
# random.shuffle(lst) 将列表中的元素就地打乱顺序
my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
print(my_list) # 输出: [3, 1, 5, 2, 4]
# random.sample(population, k) 从总体中无放回地抽取k个不同的元素
population = [1, 2, 3, 4, 5, 6]
sample = random.sample(population, 3)
print(sample) # 输出: [2, 4, 5]
# 分布函数
# random.normalvariate(mu, sigma) 生成符合正态分布的随机数，μ是均值，σ是标准差
print(random.normalvariate(0, 1)) # 输出: 0.987654
# random.paretovariate(alpha) 生成帕累托分布的随机数，α是形状参数
print(random.paretovariate(2)) # 输出: 2.345678
# random.weibullvariate(alpha, beta) 生成威布尔分布的随机数，α和β是分布参数
print(random.weibullvariate(1, 2)) # 输出: 1.789012
# random.expovariate(lambd) 生成指数分布的随机数，λ是率参数
print(random.expovariate(0.5)) # 输出: 4.321098
# 其他函数
# random.seed(value=None) 设置随机数生成器的种子，可选参数value用于确定随机数序列
random.seed(42) # 使用42作为种子
# random.getstate() 获取随机数生成器的状态，可以用于恢复随机数序列
state = random.getstate()
random.setstate(state) # 恢复之前的状态
# random.randrange(stop) 或 random.randrange(start, stop[, step]) 生成指定范围内的随机整数
print(random.randrange(10)) # 输出: 7
print(random.randrange(1, 10, 2)) # 输出: 3os
python
import os
# 获取操作系统类型
print("Operating system name:", os.name)
# 获取当前工作目录
current_dir = os.getcwd()
print("Current working directory:", current_dir)
# 改变当前工作目录
new_dir = "./test_directory" # 替换为你的路径
os.chdir(new_dir)
print("Changed to:", os.getcwd())
# 获取环境变量
env_var = os.environ.get("USER")
print(f"User environment variable: {env_var}")
# 创建目录
os.mkdir("new_folder") # 创建一个名为new_folder的目录
# 创建多级目录
os.makedirs("subdir1/subdir2") # 创建多级目录，如果中间目录不存在
# 清单目录内容
files_in_dir = os.listdir(".")
print("Files in current directory:", files_in_dir)
# 判断文件或目录是否存在
file_path = "test.txt"
if os.path.exists(file_path):
print(f"{file_path} exists.")
else:
print(f"{file_path} does not exist.")
# 删除单个文件
if os.path.isfile(file_path):
os.remove(file_path)
print(f"{file_path} has been removed.")
else:
print(f"{file_path} was not found to remove.")
# 删除目录（必须为空）
dir_to_remove = "new_folder"
if os.path.isdir(dir_to_remove) and os.listdir(dir_to_remove) == []:
os.rmdir(dir_to_remove)
print(f"{dir_to_remove} has been removed.")
else:
print(f"{dir_to_remove} is not empty or not a directory.")
# 重命名文件或目录
old_name = "test.txt"
new_name = "renamed_test.txt"
os.rename(old_name, new_name)
print(f"{old_name} has been renamed to {new_name}.")
# 清除屏幕上的输出
os.system('cls' if os.name == 'nt' else 'clear')requests
python
import requests
reponse = requests.get('http://192.168.122.65:8080/data-warehouse/pdd/mall/allMall')
print(reponse.text)operator
python
# operator 模块
# operator 模块提供了一些操作符的函数，这些函数可以当作方法来使用,比如： 加减法、字符串拼接、比较、取反等。
import operator
# 加法
print(operator.add(1, 2))datetime
python
# 日期操作
from datetime import datetime, timedelta
# 获取当前日期
now = datetime.now()
print(now)
print(now.year)
print(now.month)
print(now.day)
print(now.hour)
print(now.minute)
print(now.second)
print(now.timestamp())
# 设置指定时间
now = datetime(2020, 1, 1, 8, 10, 10)
print(now) # 2020-01-01 08:10:10
# 计算两个时间的时间差
now = datetime.now()
print(now) # 2024-05-29 18:26:31.161507
date = datetime(2020, 1, 1, 8, 10, 10)
delta = now - date
print(delta) # 输出：1610 days, 10:16:21.161507
# 获取两个时间差的天数、秒数
print(delta.days) # 1610
print(delta.seconds) # 37075
# 日期格式转换
now = datetime.now()
print(now.strftime('%Y-%m-%d %H:%M:%S')) # 2024-05-29 18:26:31