Python自学 - 函数初步(内置函数、模块函数、自定义函数)

1 Python自学 - 函数初步(内置函数、模块函数、自定义函数)

1.1 内置函数

几乎所有的编程都会提供一些内置函数，以便完成一些最基本的任务，Python提供了丰富的内置函数，熟悉内置函数可以给工作带来极大便利。
Python官方的内置函数介绍网址：Python内置函数。

1.1.1 数学函数

abs():
abs(x)，返回一个数字的绝对值。参数可以是整数、浮点数或任何实现了 abs() 的对象。如果参数是一个复数，则返回它的模。
divmod():
divmod(a, b)，接受两个（非复数）数字作为参数并返回由当对其使用整数除法时的商和余数组成的数字对。
hash():
hash(object)，返回该对象的哈希值（如果它有的话）。
pow():
pow(base, exp, mod=None)，返回 base 的 exp 次幂
round():
round(number, ndigits=None)，返回 number 舍入到小数点后 ndigits 位精度的值。

1.1.2 字符串函数

ascii():
ascii(object)，与 repr() 类似，返回一个包含对象的可打印表示形式的字符串，但是使用 \x、\u 和 \U 对 repr() 返回的字符串中非 ASCII 编码的字符进行转义。
chr():
chr(i)，返回 Unicode 码位为整数 i 的字符的字符串格式。
format():
format(value, format_spec='')，将 value 转换为“格式化后”的形式，格式由 format_spec 进行控制。
ord():
ord(c)，对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
repr():
repr(object)，返回包含一个对象的可打印表示形式的字符串。
str():
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')，返回一个 str 版本的 object

1.1.3 统计函数

len():
len(s)，返回对象的长度（元素个数）。
max():
max(iterable, *, key=None)
max(iterable, *, default, key=None)
max(arg1, arg2, *args, key=None)
返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
min():
min(iterable, *, key=None)
min(iterable, *, default, key=None)
min(arg1, arg2, *args, key=None)，返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
sum():
sum(iterable, /, start=0)，从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

1.1.4 迭代函数

aiter():
aiter(async_iterable)，返回 asynchronous iterable 的 asynchronous iterator 。相当于调用 x.aiter()。
all():
all(iterable)，如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True 。
anext():
awaitable anext(async_iterator)
awaitable anext(async_iterator, default)，当进入 await 状态时，从给定 asynchronous iterator 返回下一数据项，迭代完毕则返回 default。
any():
any(iterable)，如果 iterable 的任一元素为真值则返回 True。如果可迭代对象为空，返回 False。
enumerate():
enumerate(iterable, start=0)，返回一个枚举对象。iterable 必须是一个序列，或 iterator，或其他支持迭代的对象。
filter():
filter(function, iterable)，使用 iterable 中 function 返回真值的元素构造一个迭代器。 iterable 可以是一个序列，一个支持迭代的容器或者一个迭代器。
iter():
iter(object)
iter(object, sentinel)，返回一个 iterator 对象。根据是否存在第二个参数，对第一个参数的解读会有很大的不同。如果没有第二个参数，object 必须是一个支持 iterable 协议 (有 iter() 方法) 的多项集对象，或者必须支持序列协议 (有 getitem() 方法并使用从 0 开始的整数参数)。
map():
map(function, iterable, *iterables)，返回一个将 function 应用于 iterable 的每一项，并产生其结果的迭代器。如果传入了额外的 iterables 参数，则 function 必须接受相同个数的参数并被用于到从所有可迭代对象中并行获取的项。
next():
next(iterator)
next(iterator, default)，通过调用 iterator 的 next() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。
range():
class range(stop)
class range(start, stop, step=1)，虽然被称为函数，但 range 实际上是一个不可变的序列类型

1.1.5 类型函数

bin():
bin(x)，将一个整数转换为带前缀 “0b” 的二进制数字符串。
bool():
class bool(object=False, /)，返回布尔值，即 True 或 False 中的一个。
bytearray():
class bytearray(source=b'')
class bytearray(source, encoding)
class bytearray(source, encoding, errors)，返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。
bytes():
class bytes(source=b'')
class bytes(source, encoding)
class bytes(source, encoding, errors)，返回一个新的“bytes”对象，这是一个不可变序列，包含范围为 0 <= x < 256 的整数。
complex():
class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)，将特定的字符串或数字转换为一个复数，或基于特定的实部和虚部创建一个复数。
dict():
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)，创建一个新的字典。dict 对象是一个字典类。
float():
class float(number=0.0, /)
class float(string, /)，返回基于一个数字或字符串构建的浮点数。
frozenset():
class frozenset(iterable=set())，返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素。
hex():
hex(x)，将整数转换为带前缀 “0x” 前缀的小写十六进制数字符串。
int():
class int(number=0, /)
class int(string, /, base=10)，返回从一个数字或字符串构建的整数对象，或者如果未给出参数则返回 0。
list():
class list
class list(iterable)，虽然被称为函数，list 实际上是一种可变序列类型
oct():
oct(x)，将整数转换为带前缀 “0o” 的八进制数字符串。
set():
class set、class set(iterable)，返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。
tuple():
class tuple、class tuple(iterable)，虽然被称为函数，但 tuple 实际上是一个不可变的序列类型

1.1.6 输入输出

input():
input()、input(prompt)，如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。
open():
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)，打开 file 并返回对应的 file object。如果该文件不能被打开，则引发 OSError。
print():
print(*objects, sep=' ', end='\n', file=None, flush=False)，将 objects 打印输出至 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep 、 end 、 file 和 flush 必须以关键字参数的形式给出。

1.1.7 类与对象函数

classmethod():
@classmethod，把一个方法封装成类方法。
delattr():
delattr(object, name)，这是 setattr() 的相关函数。其参数是一个对象和一个字符串。其中字符串必须是对象的某个属性的名称。
getattr():
getattr(object, name)
getattr(object, name, default)，object 中指定名称的属性的值。 name 必须是字符串。如果该字符串是对象的某一属性的名称，则结果将为该属性的值。
hasattr():
hasattr(object, name)，该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。
isinstance():
isinstance(object, classinfo)，如果 object 参数是 classinfo 参数的实例，或者是其 (直接、间接或虚拟) 子类的实例则返回 True。如果 object 不是给定类型的对象，则该函数总是返回 False。
issubclass():
issubclass(class, classinfo)，如果 class 是 classinfo 的子类（直接、间接或虚的），则返回 True。类将视为自己的子类。classinfo 可为类对象的元组（或递归地，其他这样的元组）或 union 类型，这时如果 class 是 classinfo 中任何条目的子类，则返回 True 。
memoryview():
class memoryview(object)，返回由给定实参创建的“内存视图”对象。
object():
class object，这是所有其他类的终极基类。它提供了所有 Python 类实例均具有的方法。当其构造器被调用时，它将返回一个新的基本对象。该构造器不接受任何参数。
property():
class property(fget=None, fset=None, fdel=None, doc=None)，返回 property 属性。fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。
reversed():
reversed(seq)，返回一个反向的 iterator。
setattr():
setattr(object, name, value)，本函数与 getattr() 相对应。其参数为一个对象、一个字符串和一个任意值。
slice():
class slice(stop)
class slice(start, stop, step=None)，返回一个表示由 range(start, stop, step) 指定的索引集的 slice 对象。 start 和 step 参数默认为 None。
sorted():
sorted(iterable, /, *, key=None, reverse=False)，根据 iterable 中的项返回一个新的已排序列表。
staticmethod():
@staticmethod，将方法转换为静态方法。
super():
class super
class super(type, object_or_type=None)，返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。这对于访问已在类中被重写的继承方法很有用。
type():
class type(object)
class type(name, bases, dict, **kwds)，传入一个参数时，返回 object 的类型。返回值是一个 type 对象并且通常与 object.class 所返回的对象相同。推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。
zip():
zip(*iterables, strict=False)，在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。

1.1.8 其他函数

breakpoint():
breakpoint(*args, **kws)，此函数会在调用位置进入调试器。
callable():
callable(object)，如果 object 参数是可调用的则返回 True，否则返回 False。如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 肯定不会成功。
compile():
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)，将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。source 可以是常规的字符串、字节字符串，或者 AST 对象。参见 ast 模块的文档了解如何使用 AST 对象。
dir():
dir()
dir(object)，如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。
eval():
eval(source, /, globals=None, locals=None)，expression 参数将作为一个 Python 表达式 (从技术上说，是一个条件列表) 使用 globals 和 locals 映射作为全局和局部命名空间被解析并求值。
exec():
exec(source, /, globals=None, locals=None, *, closure=None)，这个函数支持动态执行 Python 代码。 source 必须是字符串或代码对象。如果是字符串，那么该字符串将被解析为一组 Python 语句并随即被执行（除非发生语法错误）。
globals():
globals()，返回实现当前模块命名空间的字典。对于函数内的代码，这是在定义函数时设置的，无论函数在哪里被调用都保持不变。
help():
help()
help(request)，启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。
id():
id(object)，返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。
locals():
locals()，返回一个代表当前局部符号表的映射对象，以变量名称作为键，而以其当前绑定的引用作为值。
vars():
vars()
vars(object)返回模块、类、实例或任何其他具有 dict 属性的对象的 dict 属性。
__import__():
__import__(name, globals=None, locals=None, fromlist=(), level=0)，与 importlib.import_module() 不同，这是一个日常 Python 编程中不需要用到的高级函数。

🕮说明：
以上函数基于Python 3.13，后续版本更新可能会有内置函数的更新，请随时参数官方文档。

1.2 库函数(模块)

内置函数能解决的工作场景非常有限，那么怎么办呢，类似于其他语言，比如：C/C++，会有include xxx语句引入其他库，库可以是官方也可以是第3方提供，通过库函数解决的任务场景将大大提高，不需要工程师从头开始写代码，极大的提高了工作效率。
如果要查看当前支持哪些库，可以执行如下的代码：

print(help("modules"))

笔者本地的输出：

Please wait a moment while I gather a list of all available modules...

test_sqlite3: testing with SQLite version 3.45.3
__future__          _strptime           filecmp             rlcompleter
__hello__           _struct             fileinput           runpy
__phello__          _symtable           fnmatch             sched
_abc                _sysconfig          fractions           secrets
_aix_support        _testbuffer         ftplib              select
_android_support    _testcapi           functools           selectors
_ast                _testclinic         gc                  shelve
_asyncio            _testclinic_limited genericpath         shlex
_bisect             _testconsole        getopt              shutil
_blake2             _testimportmultiple getpass             signal
_bz2                _testinternalcapi   gettext             site
_codecs             _testlimitedcapi    glob                smtplib
_codecs_cn          _testmultiphase     graphlib            socket
_codecs_hk          _testsinglephase    gzip                socketserver
_codecs_iso2022     _thread             hashlib             sqlite3
_codecs_jp          _threading_local    heapq               sre_compile
_codecs_kr          _tkinter            hmac                sre_constants
_codecs_tw          _tokenize           html                sre_parse
_collections        _tracemalloc        http                ssl
_collections_abc    _typing             idlelib             stat
_colorize           _uuid               imaplib             statistics
_compat_pickle      _warnings           importlib           string
_compression        _weakref            inspect             stringprep
_contextvars        _weakrefset         io                  struct
_csv                _winapi             ipaddress           subprocess
_ctypes             _wmi                itertools           symtable
_ctypes_test        _zoneinfo           json                sys
_datetime           abc                 keyword             sysconfig
_decimal            antigravity         linecache           tabnanny
_elementtree        argparse            locale              tarfile
_functools          array               logging             tempfile
_hashlib            ast                 lzma                test
_heapq              asyncio             mailbox             textwrap
_imp                atexit              marshal             this
_interpchannels     base64              math                threading
_interpqueues       bdb                 mimetypes           time
_interpreters       binascii            mmap                timeit
_io                 bisect              modulefinder        tkinter
_ios_support        builtins            msvcrt              token
_json               bz2                 multiprocessing     tokenize
_locale             cProfile            netrc               tomllib
_lsprof             calendar            nt                  trace
_lzma               cmath               ntpath              traceback
_markupbase         cmd                 nturl2path          tracemalloc
_md5                code                numbers             tty
_multibytecodec     codecs              opcode              turtle
_multiprocessing    codeop              operator            turtledemo
_opcode             collections         optparse            types
_opcode_metadata    colorsys            os                  typing
_operator           compileall          pathlib             unicodedata
_osx_support        concurrent          pdb                 unittest
_overlapped         configparser        pickle              urllib
_pickle             contextlib          pickletools         uuid
_py_abc             contextvars         pip                 venv
_pydatetime         copy                pkgutil             warnings
_pydecimal          copyreg             platform            wave
_pyio               csv                 plistlib            weakref
_pylong             ctypes              poplib              webbrowser
_pyrepl             curses              posixpath           winreg
_queue              dataclasses         pprint              winsound
_random             datetime            profile             wsgiref
_sha1               dbm                 pstats              xml
_sha2               decimal             pty                 xmlrpc
_sha3               difflib             py_compile          xxsubtype
_signal             dis                 pyclbr              zipapp
_sitebuiltins       doctest             pydoc               zipfile
_socket             easygui             pydoc_data          zipimport
_sqlite3            email               pyexpat             zlib
_sre                encodings           queue               zoneinfo
_ssl                ensurepip           quopri              无标题2
_stat               enum                random              
_statistics         errno               re                  
_string             faulthandler        reprlib             

Enter any module name to get more help.  Or, type "modules spam" to search
for modules whose name or summary contain the string "spam".

None

🕮说明：
每个模块的具体用法，请参考Python官网或模块的官网，如果查看简短的帮助，可以在Python中执行：print(help("easygui"))语句。

1.3 自定义函数

自定义函数的语法格式如下：

def func_name([params]): #可以没有参数
    干活语句
    return 返回值  #可以没有返回

示例1：返回两数中的较大者

import easygui as eg
flds = ['参数1', '参数2'] #配置界面上显示两个参数
defs = ['11', '101'] #两个参数设置默认参数
ipt1, ipt2 = [int(x) for x in eg.multenterbox("请输入两数字：", "输入", flds, defs)]

# ---------------------------------------------------------------------------
# @fn         返回两者中的大值
# @param[in]  para1: 参数1，数字
# @param[in]  para2: 参数2，数字
# @return     返回较大者，数字
# @author     tyysoft
# @date       2025-00-04 13:37:40
# @code       py
# my_max(1,2)
# @encode     
# ---------------------------------------------------------------------------
def my_max(para1, para2):
    if para1 >= para2:
	    return para1
    else:
	    return para2

print(f'数字:{ipt1}, {ipt2}中较大的是：{my_max(ipt1, ipt2)}')
#输出：数字:11, 101中较大的是：101

1.3.1 默认参数

许多内置函数或库函数都带有默认参数，使用默认参数可以让函数的调用更简单，用户不需要每个参数都赋值，减轻工作量，提高效率，那么在自定义函数中，如何给参数设置默认值呢？

def print_list(length = 10):
	l = [x for x in range(length)]
	print(l)
	
print_list()
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

示例2：两个参数，其中一个参数带默认值

def print_list(step, length = 10):
	l = [x for x in range(0, length, step)]
	print(l)
	
print_list(2)
#输出：[0, 2, 4, 6, 8]

🕮说明：
一般要求带默认值的参数在参数列表的右侧！

1.3.2 参数收集器

函数定义时，如果参数名前带*号，表示该参数是收集器，即，函数在调用时，如果输入多个参数，将由这个收集器接收到一个元组中。

1.3.2.1 普通参数收集器

示例1：只有一个接收器参数

def func_1(*args):
	print(f'接收到的参数：{args}')

func_1(1, 2, 'string')
#输出：接收到的参数：(1, 2, 'string')

示例2：1个普通参数加1个接收器参数

def func_1(arg1, *others):
	print(f'参数1：{arg1}, 其他参数: {others}')

func_1(1, 2, 'string')
#输出：参数1：1, 其他参数: (2, 'string')

1.3.2.2 关键词参数收集器

如果用户稍加留意，部分函数在调用时，会输入参数名和参数值，比如：

#方法1：直接按顺序填写参数
c1 = complex(3.3, 6)
print(f'c1: {c1}')
#方法2：使用参数名输入参数
c2 = complex(imag =6, real = 3.3) #打乱了参数顺序
print(f'c2: {c2}')

在函数定义时使用关键词收集器：

def func_1(**args):
	print(f'输出参数：{args}')

func_1(name='小西瓜', sex='男', age=22)
#输出：输出参数：{'name': '小西瓜', 'sex': '男', 'age': 22}

注：如果函数调用时不指定参数名，则抛出异常：TypeError

1.3.3 传值还是传引用

在C/C++语言中，存在传递参数副本(传值)和传递参数地址(传引用)，传值的方式可以保护参数，即在函数体内对参数修改，函数外部也不会改变，而传引用，在函数体内修改后，函数外部也会改变。

示例1：传值，参数不会被函数修改

int_var = 10
float_var = 3.14
str_var = 'python'
tup_var = (12, 13)
def change_var(int_var, float_var, str_var, tup_var):
    int_var += 1
    float_var += 1
    str_var += ' tutorial'
    tup_var = (1,2,3,4)
    print(f'in function: int: {int_var}, float:{float_var}, str:{str_var}, tuple: {tup_var}')
    #输出：in function: int: 11, float:4.140000000000001, str:python tutorial, tuple: (1, 2, 3, 4)
change_var(int_var, float_var, str_var, tup_var)
print(f'out of function: int: {int_var}, float:{float_var}, str:{str_var}, tuple: {tup_var}')
#输出：out of function: int: 10, float:3.14, str:python, tuple: (12, 13)  参数没有被函数修改！

示例2：传引用，参数被函数修改

list_var = [1,2,3]
dict_var = {"x":1, "y":2}
set_var = {1,2,3}
def change_var(list_var, dict_var, set_var):
    list_var.append(4)
    dict_var.update(z=3)
    set_var.add(4)
    print(f'in function: list: {list_var}, dict: {dict_var}, set: {set_var}')
    #输出：in function: list: [1, 2, 3, 4], dict: {'x': 1, 'y': 2, 'z': 3}, set: {1, 2, 3, 4}
change_var(list_var, dict_var, set_var)
print(f'out of function: list: {list_var}, dict: {dict_var}, set: {set_var}')
#输出：out of function: list: [1, 2, 3, 4], dict: {'x': 1, 'y': 2, 'z': 3}, set: {1, 2, 3, 4}