Python 内置函数（未完待续）

已于 2024-01-10 12:30:35 修改
阅读量818 收藏 18
点赞数 21
分类专栏： python 函数 文章标签： python 开发语言
于 2023-12-26 15:07:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48183870/article/details/135222593
版权

【一】什么是内置函数

在这里插入图片描述

【二】数据类型转换

【1】数字类型

# str to int 
int("1")		# 1
int("1.1")		# 错误

# float to int
int(1)			# 1
int(1.1)   		# 1, 精度损失

# str to float
float("1.1")	# 1.1

# int to float
float(1)		# 1.0 自动补零

【2】字符串类型（str）

# others to str
str()

【3】布尔类型（bool）

True 
# 0、空字符串、空列表、空元组、空字典、空集合

False
# 其他

【4】列表(list)、元组(tuple)、字典(dict)、集合(set)

# 可迭代的对象 to list
list()

# 可迭代的对象 to tuple
tuple()

# 键值对
dict() 

# 可迭代的对象 to set
set()

【三】进制转换

# 十进制 to 二进制 
bin(31)				# 0b11111

# 十进制 to 八进制 
oct(31)				# 0o37

# 十进制 to 十六进制 
hex(31)				# 0x1f

# 二进制（八进制）（十六进制） to 十进制
int(进制数据, 具体进制)
int(hex(31), 16)

【四】数学运算

【1】绝对值abs

a = -1
print(abs(-1))		# 1

【2】获取商和余数divmod

dividend = 9
divisor = 2
res = divmod(dividend, divisor)
print(res, type(res))			# (4, 1) <class 'tuple'>
discuss, remainder = res
print(discuss, remainder)		# 4 1

【3】银行家舍入法round

round(number[, ndigits])
# 默认ndigits = 0， 表示取整
  • 也称为"四舍六入五留双"。在两个可能的舍入值中，选择那个末尾数字是偶数的值
  • 这有助于在大量舍入操作中减小累积误差。
a = 3.5
b = 4.5
print(round(a, 0))  # 4.0
print(round(b, 0))  # 4.0
  • 处理精确小数计算时，round() 不一定能避免二进制浮点数表示的精度问题。
a = 3.35
b = 4.45
c = 5.55
print(round(a, 1))  # 3.4
print(round(b, 1))  # 4.5
print(round(c, 1))  # 5.5

【4】幂次pow

# 两个参数，幂次
# 3的2次方
pow(3, 2)		# 9

# 三个参数，幂次取余数
# 3的2次方，再对2进行取余数
pow(3, 2, 2)	# 1

【5】求和sum、最小值min、最大值max

# 可迭代是整型或者浮点型
print(sum([1, 3.0, 5]))		# 9.0
print(min([1, 3.0, 5]))		# 1
print(max([1, 3.0, 5]))		# 5

【6】复数complex

# complex(re, im) : 具有实部 re、虚部 im 的复数。im 默认为零。

print(complex(3))       # (3+0j)
print(complex(3, 5))    # (3+5j)

【五】数据结构相关

【1】序列

（1）翻转reversed
  • 返回的是迭代器
# 字符串
a = "Bruce"
b = reversed(a)
print(b, type(b))   # <reversed object at 0x000001E3AE20AE00> <class 'reversed'>
print(list(b))      # ['e', 'c', 'u', 'r', 'B']

# 列表
a = [1, 2, 3, 4, 5]
b = reversed(a)
print(b, type(b))   # <list_reverseiterator object at 0x0000016AEB740D90> <class 'list_reverseiterator'>
print(list(b))      # [5, 4, 3, 2, 1]
（2）切片slice、计算长度len
a = [1, 2, 3, 4, 5]
print(a[::-1])      # [5, 4, 3, 2, 1]
s = slice(0, 5, 2)
print(a[s])         # [1, 3, 5]


a = [1, 2, 3, 4, 5]
b = (1,)
c = {"a": 12}
print(len(a), len(b), len(c))
（3）排序sorted
  • 语法：sorted(Iterable, key=函数(排序规则), reverse=False)
    • Iterable: 可迭代对象
    • key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
    • reverse:True: 倒叙, False: 正序
# 简单列表
a = [1, 6, 3, 9, 5]
print(sorted(a))
# [1, 3, 5, 6, 9]

# 使用lambda函数列表， 根据列表内容长度排序
a = ["111111", "11", "1", "1111", "111"]
print(sorted(a, key=lambda x: len(x)))
# ['1', '11', '111', '1111', '111111']


# 字典排序
a = {2: "a", 1: "c", 3: "b"}
print(sorted(a))
print(sorted(a.values()))
print(sorted(a.items()))
print(sorted((a.items()), key=lambda x: x[1]))
# [1, 2, 3]
# ['a', 'b', 'c']
# [(1, 'c'), (2, 'a'), (3, 'b')]
# [(2, 'a'), (3, 'b'), (1, 'c')]
（4）枚举enumerate（常用）
# 默认
a = [1, 6, 3]
for index, data in enumerate(a):
    print(f"index:{index},data:{data}")
# index:0,data:1
# index:1,data:6
# index:2,data:3


# 指定开始数字
a = ["apple-10", "banana-12", "peach-20"]
for index, data in enumerate(a, start=1):
    name, price = data.split("-")
    print(f"商品编号{index},商品名称:{name},商品价格{price}")
# 商品编号1,商品名称:apple,商品价格10
# 商品编号2,商品名称:banana,商品价格12
# 商品编号3,商品名称:peach,商品价格20

【2】字符串

（1）格式化输出format
# 对齐方式

s = "hello world!"
print(format(s, "^20"))  # 居中
#     hello world!
print(format(s, "<20"))  # 左对齐
# hello world!
print(format(s, ">20"))  # 右对齐
#         hello world!

# 进制转换

print(format(97, 'b'))  # 二进制:1100001
print(format(97, 'c'))  # 转换成unicode字符:a
print(format(97, 'd'))  # ⼗进制:97
print(format(97, 'n'))  # 和d⼀样:11
print(format(97))       # 和d⼀样:11
print(format(97, 'o'))  # 八进制:141
print(format(10, 'x'))  # 十六进制(⼩写字母):a
print(format(10, 'X'))  # 十六进制(大写字母):A

# 科学计数法

print(format(123456789, 'e'))  # 科学计数法. 默认保留6位小数，自动补零:1.234568e+08
print(format(123456789, '0.2e'))  # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E'))  # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f'))  # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f'))  # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F'))  # 小数点计数法. 很大的时候输出INF:1234.567890
（2）字符串转字节bytes、获取字节数组bytearray、获取对象的字符串格式repr
# bytes() 把字符串转化成bytes类型
print(bytes("hello, 小明", encoding="utf8"))
# b'hello, \xe5\xb0\x8f\xe6\x98\x8e'


# bytearray返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256),一个字节的大小
a = "小明"
bytearray_ = bytearray(a, encoding="utf8")
print(bytearray_, type(bytearray_))
# bytearray(b'\xe5\xb0\x8f\xe6\x98\x8e') <class 'bytearray'>
print(bytearray_[0])
# 229


# repr() 返回一个对象的string形式
text = "my\nname\nis\bruce"
print(text)
print(repr(text))
# my
# name
# iruce
# 'my\nname\nis\x08ruce'

【3】字符串编码

# ord根据字符寻找unicode编码对应的位置
unicode_code = ord('🐅')
print(unicode_code)
# 128005


# chr更具unicode编码对应位置找字符
character = chr(128005)
print(character)
# 🐅


# ascii转义成ascii字符，没有就是unicode码的位置，十六进制表示
print(ascii("a"))
print(ascii("你"))
# 'a'
# '\u4f60'

【4】不可变集合frozenset

# 这是不可变集合
# 所以也是不支持切片，可去重
# 但是不支持添加和删除
a = frozenset([1, 2, 2])
print(a, type(a))
for i in a:
    print(i)
# frozenset({1, 2}) <class 'frozenset'>
# 1
# 2

【5】判断条件

（1）全真为真all
  • 和and同理
name = "bruce"
age = "18"
flag = name == "bruce" and age == "18"
print(flag)             
flag = all([name == "bruce", age == "18"])
print(flag)
# True
# True
（2）有假即假any
  • 和or同理
name = "bruce"
age = "18"
flag = name == "bruce" and age == "18"
print(flag)
flag = all([name == "bruce", age == "20"])
print(flag)
# True
# False

【6】高阶函数

（1）打包zip（拉链函数）
  • 将多个可迭代对象（例如列表、元组等）中的对应元素打包成元组。这个函数返回一个迭代器，可以生成这些元组。
name = ["bruce", "tom", "lucy"]
age = ["15", "18", "27"]
zip_ = zip(name, age)
print(zip, type(zip))
# <class 'zip'> <class 'type'>
for i in zip_:
    print(i)
# <class 'zip'> <class 'type'>
# ('bruce', '15')
# ('tom', '18')
# ('lucy', '27')
  • 如果存在元素个数不相等的情况，以少的为基准
name = ["bruce", "tom", ]
age = ["15", "18", "27"]
zip_ = zip(name, age)
for i in zip_:
    print(i)
# ('bruce', '15')
# ('tom', '18')
  • 生成字典
name = ["bruce", "tom", "lucy"]
age = ["15", "18", "27"]
zip_ = zip(name, age)
dict_ = dict(zip_)
print(dict_)
# {'bruce': '15', 'tom': '18', 'lucy': '27'}
（2）过滤filter
  • fiter(function, Iterable)
    • function: 用来筛选的函数，返回判断结果
      • 在filter中会自动的把iterable中的元素传递给function
      • 然后根据function返回的True或者False来判断是否保留留此项数据
    • Iterable: 可迭代对象
def func(i):
    # 保留奇数
    return i % 2


num_list = [i for i in range(1, 10)]
filter_ = filter(func, num_list)
print(filter_, type(filter_))
print(list(filter_))
# <filter object at 0x000001F67E77B640> <class 'filter'>
# [1, 3, 5, 7, 9]
  • 使用匿名函数
num_list = [i for i in range(1, 10)]
filter_ = filter(lambda x: x % 2, num_list)
print(filter_, type(filter_))
print(list(filter_))
# <filter object at 0x000001F67E77B640> <class 'filter'>
# [1, 3, 5, 7, 9]
（3）映射map
  • map(function, iterable)
    • function: 用于处理每个元素的函数。
    • iterable: 要处理的可迭代对象，如列表、元组等。
def func(i):
    # 获取立方
    return i ** 3


num_list = [i for i in range(1, 6)]
map_ = map(func, num_list)
print(map_, type(map_))
print(list(map_))
# <map object at 0x00000264F209B640> <class 'map'>
# [1, 8, 27, 64, 125]
  • 使用匿名函数
num_list = [i for i in range(1, 6)]
map_ = map(lambda x: x ** 3, num_list)
print(map_, type(map_))
print(list(map_))
# <map object at 0x00000264F209B640> <class 'map'>
# [1, 8, 27, 64, 125]

【六】作用域

  • locals() 返回当前作用域中的名字
  • globals() 返回全局作用域中的名字，局部作用域的内容不会再这里
def func():
    age = 20
    print("函数内局部作用域".center(20, "-"))
    print(f"当前作用域内容：{locals()}")
    print(f"全局作用域内容：{globals()}")


name = "bruce"
func()
print("全局作用域".center(20, "-"))
print(f"当前作用域内容：{locals()}")
print(f"全局作用域内容：{globals()}")
# ------函数内局部作用域------
# 当前作用域内容：{'age': 20}
# 全局作用域内容：{'name': 'bruce', 'func': <function func at 0x00>}
# -------全局作用域--------
# 当前作用域内容：{'name': 'bruce', 'func': <function func at 0x00>}
# 全局作用域内容：{'name': 'bruce', 'func': <function func at 0x00>}

【七】迭代器(iterator)和生成器(generator)

【1】循环生成数据range

range_ = range(10)
print(range_, type(range_))
# range(0, 10) <class 'range'>

【2】获取迭代器iter

list_ = [i for i in range(10)]
iter_ = iter(list_)
print(iter_, type(iter_))
# <list_iterator object at 0x000002216550B640> <class 'list_iterator'>

【3】向下执行next

list_ = [i for i in range(3)]
iter_ = iter(list_)
print(next(iter_))
print(next(iter_))
print(next(iter_))
# 0
# 1
# 2

【八】字符串代码执行

【1】执行字符串并返回表达式结果eval（慎用）

# 有返回结果
res = eval("12+13")
print(res)
# 25


# 交互型 有返回结果
res = eval("input('name:>>>')")
print(res)
# name:>>>bruce
# bruce


# 交互型 没返回结果
name = "bruce"
res = eval("print(f'name:>>>{name}')")
print(res)
# name:>>>bruce
# None

【2】执行字符串没有返回值exec（慎用）

  • exec和eval比较
    • eval：返回表达式的值；计算单一表达式，不适用于执行多个语句
    • excel：只返回None；可执行多个语句和代码块
# 没有返回结果
res = exec("result = 12+13")
print(f"res:{res}, result:{result}")
# res:None, result:25



# 执行多条语句
username_password = """
username = input('username:>>>')
password = input('password:>>>')
"""
exec(username_password)
print(f"username:{username},passord:{password}")
# username:>>>bruce
# password:>>>000
# username:bruce,passord:000


# 执行代码块
func_str = """
def func():
    print('It is func.')

func()    
"""
exec(func_str)
# It is func.


# 导入模块
module_input = """
import random
import time
"""
exec(module_input)
print(random.randint(1,2))      
print(time.localtime().tm_year)
# 2
# 2023

【3】编译字符串compile（慎用）

  • 将源代码字符串编译为代码对象
  • 通常在需要动态生成和执行代码的情况下使用
  • 第二个参数filename是代码的文件名，如果代码不来自文件，则使用一个字符串。
# 执行eval
content = "12+13"
compile_ = compile(content, "", mode="eval")
res = eval(compile_)
print(res)
# 25



# 执行代码块exec
func_str = """
def func():
    print('It is func.')

func()    
"""
compile_ = compile(func_str, "", mode="exec")
exec(compile_)
# It is func.

【九】输入输出

【1】输入input

  • 值是字符串
age = input("age:>>>")
print(age, type(age))
# age:>>>18
# 18 <class 'str'>

【2】输出print

  • 常用参数
    • sep：单个输出中，多单参数之间的间隔内容，默认是空格
    • end：再输出结尾的内容，默认是换行
# sep
print("apple", "orange", "banana", sep=", ")
# apple, orange, banana

# end
print("name:bruce", end="\t")
print("age:18")
# name:bruce	age:18

【十】算法

【1】hash计算给定对象的哈希值

  • 哈希值是一种固定长度的整数，通常用于快速比较对象是否相等
  • 要计算哈希值的对象，可以是数字、字符串、元组等不可变类型的对象。只有不可变的对象才能被哈希，因为哈希值在对象的生命周期内不能改变。
  • 不同的输入可能会产生相同的哈希值（哈希冲突），但这种情况应该很少见。
# set_ = {"da", 12, "ab", "1", 1}
# print(set_)
# for i in set_:
#     print(hash(i))
#
int_ = 1
str_ = "a"
tuple_ = (1,)
list_ = [1]
print(hash(int_))       # 1
print(hash(str_))       # -6644214454873602895
print(hash(tuple_))     # -5718621942318842139
print(hash(list_))      # 报错，列表不能

【2】补充：讲解集合元素无序性

  • 集合内的元素是按照哈希值排序的
  • 在一个声明周期内，顺序是确定的，不在同一个声明周期内，顺序不定
set_ = {"apple", 18}
print(set_)
for data in set_:
    print(hash(data))

# 第一次运行结果
# {18, 'apple'}
# 18
# -2441579320494278381

# 第二次运行结果
# {'apple', 18}
# 3900157648609508282
# 18
  • 两次运行，两次的排序结果都不同，是因为两次字符串的hash值计算都不一样，我们还可以看出来，集合内的排序是按照hash值从大到小排序的

【十一】文件操作(open)、导入模块__import__

  • open：用于打开一个文件, 创建一个文件句柄
# 文件操作
f = open('01.txt',mode='r',encoding='utf8')
f.read()
f.close()


# 导入模块
module_name = input("time module name:>>>").strip()
time = __import__(module_name)
print(time.localtime().tm_year)
# time module name:>>>time
# 2023

【十二】帮助help、查看内置属性dir

# help():函数用于查看函数或模块用途的详细说明
print(help(str))  
# 在pycharm按住ctrl点击int也可以查看详细说明


# dir():查看对象内置属性和方法
print(help(dict))  
# 在pycharm按住ctrl点击dict也可以查看内置属性和方法

【十三】是否可被调度callable

  • 对象是否可被调用

  • False：不可被调度

  • True：可被调度

int_ = 1
print(callable(int_))  # False


def func():
    return None
print(callable(func))  # True
在飞行-米龙
关注
  • 21
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python 内置函数汇总详解
09-18
在Python中，内置函数是预定义的、可以直接使用的函数，无需额外导入任何模块。本篇文章将详细汇总并解释Python的内置函数，以帮助你更好地理解和应用它们。 1. **强制类型转换**： - `dict()`: 将可迭代的对象...
python内置函数.pdf
06-12
在"python内置函数.pdf"这份文档中，主要介绍了四个关键部分：常用函数、内置类型转换函数、序列处理函数以及String模块。下面将详细阐述这些知识点。 1. **常用函数** - `abs(x)`：这个函数返回数字（包括复数）...
python函数—未完待续
weixin_45953165的博客
10-06 180
python函数的定义与调用 python定义函数使用def关键字，格式如下： def 函数名（参数列表）： 函数体 eg: def myFirstFunc(): #定义函数 print("Hello!") myFirstFunc() #调用函数 函数的参数 eg: #定义接收2个参数的函数 def add2num(a,b): c=a+b print(c) #调用带有参数的函数 add2num(11,22) 调用函数时，如果没有传递参数，则会使用默认参数 eg: def prin
Python内置函数
Hackeryuan的博客
09-21 325
文章目录1.setattr()和getattr() 1.setattr()和getattr() getattr(object,name[,default]) 用于返回一个对象属性值。如果不提供default，在没有对应属性时，将触发 AttributeError。 代码示例： >>>class A(object): ... bar = 1 ... >>&gt...
Python基础（未完待续）
lisi_123的博客
05-26 751
【代码】Python基础。
python：部分内置函数的使用
一名小测试
12-02 1046
最近几天都没更新文章了，项目有点小忙，本打算继续更新魔术方法的，发现总结的还没到位，索性先搁置下吧。 今天就聊聊部分内置函数的使用，当然，还有一部分没罗列出来，有兴趣的可去官网详解下哦！！！ abs(x) 描述： 返回一个数的绝对值。 参数可以是整数、浮点数或任何实现了 abs 的对象。 如果参数是一个复数，则返回它的模。 示例说明： print(abs(-5)) print(abs(2.4+5.6j)) 运行结果： 5 6.092618484691126 Processfin.
python内置对象都封装在_Python内置函数与math标准库函数功能期末考点汇总 #第三周 (未完待续)...
weixin_30198949的博客
03-02 85
Python内置函数功能汇总from IPython.core.interactiveshell import InteractiveShell InteractiveShell.ast_node_interactivity = 'all' #对独占一行的所有变量或者语句都自动显示%matplotlib inline#将matplotlib绘制的图形像是在jupyter notebook内impo...
python内置函数
Dis_illusion's Blog
09-22 705
文章目录abs()divmod()input() abs() 返回参数的绝对值。 >>> help(abs) Help on built-in function abs in module builtins: abs(x, /) Return the absolute value of the argument. #例子 >>> abs(-5) 5 ...
python内置函数整理
进击的萌小只的博客
11-07 307
小只刚开始学习Python，在此对Python的内置函数做一个简单的汇总，具体的用法参照官方文档：https://docs.python.org/3/library/functions.html#all 1.abs(x) 返回一个数的绝对值； 2.all(iterable) 如果可迭代的对象的所有元素全部非空（或空迭代对象），则返回True。这个函数主要用来判断列表(list)、元组(t
Python内置函数与math标准库函数功能期末考点汇总 #第三周 (未完待续)
intWesty的博客
03-13 428
感觉最近写博客 from IPython.core.interactiveshell import InteractiveShell InteractiveShell.ast_node_interactivity = ‘all’ #对独占一行的所有变量或者语句都自动显示
python之基本内置函数
Once_day的回忆
02-21 447
Python基础内置函数(builtins)详解 author：Once Day date:2022年2月19日 本文档在于总结相关内容，零散的知识难以记忆学习。 本文档基于windows平台。 全系列文档查看：python基础_CSDN博客。 文章目录Python基础内置函数(builtins)详解1.序言2.数学类函数2.1 abs() 绝对值2.2 bin() / oct() /hex() 十进制转换2/8/16进制2.3 bool() 类函数，判断bool值2.4.1 ord() 返回单字符字
Python内置函数dir详解
09-22
主要介绍了Python内置函数dir详解,本文讲解了命令介绍、使用实例、使用dir查找module下的所有类、如何找到当前模块下的类等内容,需要的朋友可以参考下
python内置函数大全
06-05
最近一直在看python 的document ，打算在基础方面重点看一下。罗列一下了基础的内置函数，分类可能不准确，一起交流学习
python 内置函数filter
09-21
主要介绍了python 内置函数filter的相关资料,需要的朋友可以参考下
使用Python的Turtle库绘制动态风车
最新发布
爱写代码的小朋友
07-20 378
python绘制风车
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 438
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
【Python 中的内存管理有哪些优缺点】
qq_36253366的博客
07-19 431
Python中的内存管理是一个复杂而高效的系统，它通过自动化和抽象化的方式极大地简化了程序员的内存管理负担，但同时也存在一些潜在的缺点。
N7翻译实战
tjl521314_21的博客
07-17 335
本周完成项目实战用于训练一个简单的序列到序列（seq2seq）模型以实现英语到法语的翻译。数据预处理、模型构建、训练以及可视化损失的过程。本周学习了构建和训练一个简单的seq2seq模型用于英语到法语的翻译，对前面的知识做了一个综合的运用。
Python内置函数详解：从基础到高级
"Python内置函数是Python编程语言中预定义的、无需事先导入即可使用的功能。这些函数提供了基本的操作和数据类型转换，如计算绝对值、检查对象是否可调用、进行比较操作、执行除法和取余运算、判断对象类型、获取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值