Python语法基础篇（包含类型转换、拷贝、可变对象/不可变对象，函数，拆包，异常，模块，闭包，装饰器）

发布于：2025-06-04 ⋅ 阅读:(18) ⋅ 点赞:(0)

Python语法基础篇（二）

🐹🐹🐹🐹🐹一只正在努力学习计算机技术的小仓鼠，尾部有课程链接哦~🐹🐹🐹🐹🐹

类型转换

  • int()：转换成整型
    print(int(1.8))
  • float()：转换成浮点型
    print(float(5))
  • str()：转换成字符串
    print(str(5.00))
  • eval()：实现list、dict、tuple和string之间的转换 — 去引号，但是不安全（详见RCE）
    s = "[[1,2,3],[4,5,6]]"
slist = eval(s)
print(slist,type(slist))
  • list()：将可迭代对象转换成列表  注：可迭代对象指能用for循环遍历的对象；支持转换为list的类型: string、tuple、dict、set
    # str -> list
print(list('abc'))
# tuple -> list
print(list((1,2,3,4)))
# dict -> list
print(list({'name':'zhangsan', 'age':18}))
# set -> list
print(list({'a','b','c','d','e','f','g','h'}))

拷贝

  • 深拷贝：创建一个新对象，新对象涵盖所有层级的对象属性和数组元素，新对象与原对象不共用内存。
    import copy
a = [1,2,3,[4,5,6]]
acopy = copy.deepcopy(a)
print(id(a),id(acopy))
a[3].append(7)
print(a,acopy)
  • 浅拷贝：创建一个新对象，只复制指针，该指针指向与原数据共同的对象。
    import copy
a = [1,2,3,[4,5,6]]
acopy = copy.copy(a)
print(id(a),id(acopy))
a[3].append(7)
print(a,acopy)
  • 浅拷贝与深拷贝的区别详解

可变对象与不可变对象

可变对象

  • 概念：存储空间保存的数据允许被增加、删除或修改，但内存地址不会发生改变，这种数据就是可变类型。Python中可变对象有list、set、dict
    li = [1,2,3,4]
print(li,id(li))
li.append(5)
print(li,id(li))

不可变对象

  • 概念：变量对应的值不能被修改，如果修改就会生成一个新的值从而分配新的内存空间。Python中不可变对象有tuple、int、float、string
    st = 'hello'
print(id(st))
st = 'bingbing'
print(id(st))

函数

  • 概念：将独立的代码块组织成一个整体，使其具有特定功能。
  • 普通函数
    • 格式
      def 函数名():
	函数体
	return 返回值1, 返回值2 ...

# 调用
函数名()
    • 返回值类型
      • 没有返回值：None
      • 一个返回值：该值
      • 多个返回值：元组
    • 参数类型
      • 必备参数，默认参数  注：必备参数必须在默认参数前面。
        # x,y为必备参数；z为默认参数
def my_add(x,y,z=10):
	return x+y+z

p = my_add(1,2)
q = my_add(1,2,3)
print(p,q)
      • 可变参数：传入参数类型为元组，数量可以改变。
        def afunc(*args):
	tuple_to_list = list(args)
	print(args)
	print(tuple_to_list)
afunc(1, 2, [3, 4])
      • 关键字参数：参数以字典的形式传值。
        def bfunc(**kwargs):
	for i in kwargs.keys():
		print(i, type(i))
		print(kwargs[i], type(kwargs[i]))
bfunc(name='zhangsan',age=18)
    • 函数嵌套：在一个函数里定义另一个函数
      def cfunc():
	print('this is cfunc')
	def dfunc():
		print('this is dfunc')
	# 定义和调用同级（同缩进）
	dfunc()
cfunc()
    • 作用域：按照变量生效范围可分为全局变量和局部变量
      • 全局变量
        a = 100
def test1():
	print('a的值为%d' % a)
test1()

        # 全局变量__name__
# 作用：用于控制py文件在不同的应用场景执行不同的逻辑
	# 文件在当前程序执行：__name__ == '__main__'
	# 文件被当作模块导入时，不执行__name__ == '__main__'
import pytest_1
pytest_1.test()

# pytest_1.py
print('这是pytest2作为模块会显示的内容')
def test():
    print('哈哈哈')
if __name__ == '__main__':
    print('这是pytest2作为模块不会显示的内容')
      • 局部变量
        a = 120
def test2():
	a = 100
print('a的值为%d' % a)
test2()
print('a的值为%d' % a)
      • global 变量名：将变量声明为全局变量，用于修改全局变量值
        a = 120
def test2():
    global a
    a = 100
    print('a的值为%d' % a)
test2()
print('a的值为%d' % a)
      • nonlocal 变量名：用于声明外层的局部变量
        def test3():
    a = 100
    def inner_func():
        nonlocal a
        a = 120
        print('a的值为%d' % a)
    inner_func()
    print('a的值为%d' % a)
test3()
  • 匿名函数
    • 无参数
      funa = lambda : '一桶水果茶'
fruit_tea = funa()
print(fruit_tea)
    • 必要参数 函数名 = lambda 形参:返回值(表达式)
      add = lambda a,b:a+b    #a,b就是匿名函数的形参，a+b是返回值的表达式
total = add(1,2)
print(total)
    • 默认参数：默认参数必须写在必要参数后面
      funb = lambda name,age=18:(name,age)
info_a = funb('张三')
info_b = funb('李四', 20)
print(info_a,'\n',info_b)
    • 可变参数
      func = lambda **kwargs:kwargs
print([func(name='张三',age=18)])
    • lambda与if函数结合(三目运算符)
      fund = lambda a,b:a if a<b else b
print(fund(1,2))
  • 内置函数
    • 查看所有内置函数：大写字母开头一般是内置常量名，小写字母开头一般是内置函数名
      import builtins
print(dir(builtins))
    • abs()：返回绝对值
    • sum()：求和 — 元组，集合，数组
      print(sum([2,3]))
    • min()：求最小值
    • max()：求最大值
      print(min(-2,3, key=abs))
    • zip()：将可迭代对象作为参数，将对象中的元素一一对应打包成元组（如果元素不一致，就按照长度最短的返回）
      l1 = [1,2,3]
l2 = ['a','b']
print(zip(l1,l2))
for i in zip(l1,l2):
    print(i, type(i))
# 转换成列表打印（条件：必须是可迭代对象）
print(list(zip(l1,l2)))
    • map(function, iterable)：对可迭代对象中的每一个元素进行映射。
      list1 = [1,2,3]
def func(a,b=1):
    return a+b
# 对象形式的数据有两种提取方式: (1)数组 (2)for循环
print(list(map(func,list1)))
print(list(map(lembda a,b=1:a+b, list1)))
    • reduce(function, sequence)：将对象中的两个元素取出作为函数的实参进行运算，运算的结果和第三个元素作为函数的实参再进行运算。function：必须是有且仅有两个必要参数的函数sequence：必须是可迭代对象
      from functools import reduce
list2 = [1,2,3]
def add(x, y, z=1):
    return x+y+z 
print(reduce(add, list2))
  • 递归函数
    • 概念：如果一个函数在内部不调用其他函数, 而是调用它本身, 这个函数就是递归函数。
      def acc(number):
if number == 0:
    return 0
else:
    return number + acc(number-1)
print(acc(10))
# 斐波那契数列
def fabnacci(number):
    if number == 1 or number == 2:
        return 1
    else:
        return fabnacci(number-1) + fabnacci(number-2)
for i in range(31):
    if i > 0:
        print(fabnacci(i), end=',')

拆包

  • 概念：对于函数中的多个返回数据，去掉元组、列表或字典，直接获取数据的过程
    tua = (1,2,3)
print(tua,type(tua))
# 拆解方法一
a,b,c = tua
print(a,b,c)
# 拆解方法二
a, *b = tua
print(a, *b)
# 一般在函数调用时使用
def funa(a,b,*args):
    print(a,b)
    print(args,type(args))
arg = [1,2,3,4,5,6]
funa(*arg)

异常

  • 概念：当Python检测到一个错误时，解释器就无法继续执行下面的语句，反而会出现一些错误的提示。
  • 异常类型
    异常类型 释义
    AttributeError 尝试访问或设置一个对象不存在的属性或方法
    IOError 输入/输出异常，例如无法打开文件
    ImportError 无法引入模块和包，例如路径错误或名称错误
    IndentationError 语法错误(的子类)，例如代码没有正确对齐
    IndexError 下标索引超出序列边界
    KeyError 视图访问字典里不存在的键
    SyntaxError 代码非法, 代码不能编译
    TypeError 传入对象类型与要求的不符合
    ValueError 传入一个调用者不期望的值
  • 异常处理：程序有异常时，整个程序仍能正常运行
    • 语法：
      try:
	可能引发异常现象的代码
except:
	出现异常现象的处理代码
else:
	只有在没有异常时才会执行的代码
finally:
	try代码块结束后执行的代码
    • 示例：
      # 方法1:
try:
    print(abc)
except NameError as e:
    print(e)
# 方法2 -- 捕获任何异常
try:
    print(abc)
except Exception as e:
    print(e)
# 方法3 -- 多分支异常
try:
    print(abc)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except NameError as e:
    print(e)
# else
dic = {'name':'zhangsan'}
try:
    print(dic['age'])
except Exception as e:
    print('出现错误')
else:
    print(dic)
# finally
try:
    print(dic['age'])
except Exception as e:
    print(e)
finally:
    print(dic)
  • 抛出异常 raise
    1. 创建一个Exception(‘xxx’)对象
    2. raise抛出这个异常对象
    # 需求：密码长度不足六位就重新输入，输入超过三次错误就报异常
def login():
    for i in range(3):
        pwd = input('请输入密码:')
        if len(pwd) >= 6:
            return '密码输入成功'
        elif i != 2:
            print('密码长度不足六位，请重新输入')
    raise Exception('输入错误超过三次，退出')
try:
    login()
except Exception as e:
    print(e)

模块

  • 概念：一个py文件就是一个模块，即导入一个模块本质上就是执行一个py文件。
  • 分类
    1. 内置模块：random、time、os、logging
    2. 第三方模块：pip install 包名
    3. 自定义模块：自己在项目中定义的模块
    # 导入模块
import numpy
# 调用功能
l1 = [1,2,3]
l1 = numpy.append(l1,[4,5,6])
print(l1)
# 从模块中导入指定的部分
from numpy import split
# as起别名
import pandas as pd
  • 包
    • 概念：项目结构中的文件夹/目录。包的本质是模块，包可以包含包。
    • 作用：将有联系的模块放到同一个文件夹下，并且在该文件夹中创建一个__init__.py的文件。包能够有效避免模块名称的冲突问题，使结构更清晰。
    # import导入包时, 首先执行__init__.py文件
# __all__ 本质是一个列表, 列表里面的元素代表要导入的模块。

# Pack_01是Python Package
from Pack_01 import *
Register.reg()

# __init__.py
# 不建议在__init__.py中写过多代码, 尽量保证init的内容简单
# 主要作用: 导入这个包内的其它模块
# from Pack_01 import Register
__all__ = ['Register']

# Register.py
def reg():
	print('这是reg函数')

闭包

  • 内部函数构成闭包的条件：
    1. 嵌套函数
    2. 内部函数使用外部函数的变量
    3. 外部函数返回内部函数
  • 无参数
    def funcA():
    a = 10
    def funcB():
        print(a)
    return funcB
# 第一种调用方法
print(funcA())
funcA()()
# 第二种调用方法
ot = funcA()
ot()
  • 默认参数
    # 函数名保存函数地址，()理解成指针
def outer(m):
    n = 10
    def inner(p):
        print(m+n+p)
    return inner
ot = outer(5)
ot(5)
  • 思维训练
    def result(**kwargs):
    identity = {'code':0}
    identity['code'] = kwargs['add']
    def tup(*args):
        for i in args:
            identity['code'] += i
        def outer(a,b=1):
            identity['code'] += a+b
            return kwargs.get('add')
        return outer
    return tup
result(add=10)(1,2,3,4)(9)
# 每次开启内函数都在使用同一份闭包变量
print(result(add=10)(1,2,3,4)(9))

装饰器

  • 概念：装饰器本质上是一个闭包函数，它可以让其他函数不需要做任何变动的情况下增加额外功能，装饰器的返回值是一个函数对象。
  • 作用：在不改变原有代码情况下添加新的功能
  • 条件:
    1. 不修改源程序或函数的代码
    2. 不改变函数或程序的调用方法
  • 单个装饰器
    # 形参是函数
def test(fn):
    print('test')
    fn()
def HaHa():
    print('HaHa')
test(HaHa)

# 标准版装饰器
def send():
    print('send message')
def outer(fn):
    def inner():
        # 原有功能 --- send()
        fn()
        # 新功能
        print('check message info')
    return inner
outer(send)()
  • 多个装饰器
    def deco_1(fn):
    def inner():
        return "哈哈哈"+fn()+"呵呵呵"
    return inner
def deco_2(fn):
    def inner():
        return "nice"+fn()+"excellent"
    return inner
# 多个装饰器的装饰过程，距离函数最近的装饰器先装饰。
# deco_2 -> "nice"+test()+"excellent"
# deco_1 -> "哈哈哈"+demo_2()+"呵呵呵"
@deco_1
@deco_2
def test():
    return "晚上在学习python"
print(test())
  • 语法糖
    • 格式：@装饰器名称
    • 无参数
      def outer(fn):
    def inner():
        fn()
        print('send message')
    return inner
@outer
def YYDS():
    print('YYDS')
YYDS()
    • 有参数
      # 有参数
user = [{'username':'zhangsan', 'password':'123456'}]
def outer(fn):
    def inner(user):
        for i in range(len(user)):
            for j in user[i].keys():
                if j == 'username':
                    print(f'用户:{user[i][j]}',end=',')
                else:
                    print(f'密码:{user[i][j]}')
        fn(user)
    return inner
@outer
def login(user):
    while True:
        username = input('请输入用户名:')
        pwd = input('请输入至少六位密码:')
        if len(pwd) < 6:
            print('请重新输入')
            continue
        else:
            user.append({'username':username, 'password':pwd})
            break
    for i in range(len(user)):
        for j in user[i].keys():
            if j == 'username':
                print(f'用户:{user[i][j]}', end=',')
            else:
                print(f'密码:{user[i][j]}')
login(user)

课程链接

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布