《Python学习》-- 入门篇二

一、函数

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.718281828459045

time

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)) # 输出: 3

os

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