【Python】内置函数

这篇具有很好参考价值的文章主要介绍了【Python】内置函数。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

反射相关【4】

基础数据类型相关【38】

和数字相关(14)

数据类型 <4>

bool([x])

定义: 将给定参数转换为布尔类型,如果没有参数,返回 False。

print(bool())  # False
print(bool(0)) # False
print(bool(1)) # True
int((x, base=10)

定义: 将一个字符串或数字转换为整型。
参数说明:

  • x – 字符串或数字。
  • base – 进制数,默认十进制。
print(int())           # 0 不传入参数,得到结果0
print(int(3.6))        # 3
print(int('12', 16))   # 18 如果是带参数base的话,12要以字符串的形式进行输入,12为16进制
print(int('0xa', 16))  # 10
float([x])

定义: 将整数和字符串转换成浮点数。

print(float(1))         # 1.0
print(float(-1.5))      # -1.5
print(float('123.35'))  # 123.35
complex([real[, imag]])

定义: 创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。

print(complex(1))           # (1+0j)
print(complex(1, 2))        # (1+2j)
print(complex("1+2j"))      # (1+2j) 注意:这个地方在"+"号两边不能有空格,否则会报错

进制转换 <3>

bin(x)

定义: 返回一个整数 int 或者长整数 long int 的二进制表示。

print(bin(5))   # 0b101
print(0b101)    # 5
oct(x)

定义: 将一个整数转换成 8 进制字符串。

print(oct(9))   # 0o11
print(0o11)     # 9
hex(x)

定义: 将10进制整数转换成16进制,以字符串形式表示。

print(hex(10))  # 0xa	0-f
print(0xa)      # 10

数学运算(7)

abs(x)

定义: 返回数字的绝对值。

print(abs(-5.5))    # 绝对值 5.5
divmod(a, b)

定义: 把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(10, 3))    # (3, 1) 除法 (商,余数)
round(x [, n] )

定义: 返回浮点数x的四舍五入值。

print(round(9.12))          # 9
print(round(-100.965, 2))   # -100.97
pow(x, y[, z])

定义: 返回x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y)%z。

print(pow(2, 3))    # 8
print(pow(2, 3, 5))    # 3
print(2**3)         # 8

# 以下是 math 模块 pow() 方法的语法:
import math
print(math.pow(2,3))    # 8.0

注意: pow()通过内置的方法直接调用,内置方法会把参数作为整型,而math模块则会把参数转换为 float。

sum(iterable[, start])

定义: 对序列进行求和计算。
参数说明:

  • iterable – 可迭代对象,如:列表、元组、集合。
  • start – 指定相加的参数,如果没有设置这个值,默认为0。
print(sum([0, 1, 2]))       # 3
print(sum([0, 1, 2], 5))    # 8  列表计算总和后再加5
min( x, y, z, … )

定义: 返回给定参数的最小值,参数可以为序列。

print(min(1, 0, 2))     # 0
print(min([1, 0, 2]))   # 0
print(min('012'))       # 0
max( x, y, z, … )

定义: 返回给定参数的最大值,参数可以为序列。

print(max(1, 0, 2))     # 2
print(max([1, 0, 2]))   # 2
print(max('012'))       # 2

和数据结构相关(24)

序列 <13>

列表和元组 2
list(tup)

定义: 将元组转换为列表。

print(list((1, 'a', 'b')))      # [1, 'a', 'b']
tuple(iterable)

定义: 将可迭代对象转换为元组。

print(tuple([1, 'a', 'b']))     # ( 1, 'a', 'b')
print(tuple('abc'))             # ('a', 'b', 'c')
相关内置函数 2
reversed(list)

定义: 用于反向列表中元素。

lst = [123, 'b', 'a']
rlst = reversed(lst)
print(list(rlst))		# ['a', 'b', 123]
slice(start, stop[, step])

定义: 实现切片对象,主要用在切片操作函数里的参数传递。

s = '今天天气不好'
s1 = '明天天气很差'
ss = slice(1, 6, 2)
print(s[ss])               # 天气好
print(s1[ss])              # 天气差
字符串 9
str()

定义: 将对象转化为适于人阅读的形式。

format()
# 字符串
print(format('test', '<20'))    # 左对齐 test
print(format('test', '>20'))    # 右对齐                 test
print(format('test', '^20'))    # 居中         test

# 数值
print(format(3, 'b'))   # 二进制 11
print(format(97, 'c'))   # 转换成unicode字符 a
print(format(11, 'd'))   # 十进制 11
print(format(11, 'o'))   # 八进制 13
print(format(11, 'x'))   # 十六进制(小写字母) b
print(format(11, 'X'))   # 十六进制(大写字母) B
print(format(48, '08d'))    # 00000048
print(format(11, 'n'))   # 和d一样 11
print(format(11))        # 和d一样 11

# 浮点数
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("hello", "python"))     # hello python 不设置指定位置,按默认顺序
print("{1} {0}".format("python", "hello"))     # hello python 设置指定位置
# 通过字典设置参数
dict = {"name": "百度", "url": "www.baidu.com"}
print("网站名:{name}, 地址:{url}".format(**dict))    # 网站名:百度, 地址:www.baidu.com
# 通过列表索引设置参数
lst = ['百度', 'www.baidu.com']
print("网站名:{0[0]}, 地址:{0[1]}".format(lst))  # 网站名:百度, 地址:www.baidu.com       0是必须的!!
bytes 【已废弃】
bytearry

定义: 返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。

print(bytearray([1,2,3]))   # bytearray(b'\x01\x02\x03')
memoryview(obj)

定义: 返回给定参数的内存查看对象

mv = memoryview(bytearray('abcd', 'utf-8'))
print(mv[1])
print(mv[0:2].tobytes())    # b'ab'
ord(c)

定义: 以一个字符(长度为1的字符串)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值,如果所给的 Unicode 字符超出了你的 Python 定义范围,则会引发一个 TypeError 的异常。

print(ord('中'))     # 20013
print(ord('a'))      # 97
chr(i)

定义: 用一个范围在 range(256)内的(就是0~255)整数作参数,返回一个对应的字符。

print(chr(20013))     # 中 十进制
print(chr(0x61))      # a 十六进制

for i in range(32, 126):     # 第 33~126 号(共94个)是字符,其中第 48~57 号为 0~9 十个阿拉伯数字,65~90 号为 26 个大写英文字母,97~122 号为 26 个小写英文字母,其余为一些标点符号、运算符号等。
    print(chr(i), end=' ')
ascii(c)
print(ascii('中'))		#'\u4e2d'
repr(object)

定义: 将对象转化为供解释器读取的形式。

print(str("你好,我叫\t'Jessica'"))        # 你好,我叫'Jessica'
print(repr("你好,我叫\t'Jessica'"))       # "你好,我叫'Jessica'"

数据集合 <3>

字典 1
dict()

定义: 用于创建一个字典。

d1 = dict()
print(d1)       # 空字典 {}

d2 = dict(a=1, b=2, c=3)
print(d2)       # 传入关键字 {'a': 1, 'b': 2, 'c': 3}

d3 = dict([('a', 1), ('b', 2), ('c', 3)])
print(d3)       # 可迭代对象方式来构造字典 {'a': 1, 'b': 2, 'c': 3}

d4 = dict(zip(['a', 'b', 'c'], [1, 2, 3]))
print(d4)       # 映射函数方式来构造字典 {'a': 1, 'b': 2, 'c': 3}
集合 2
  • list vs tuple
    list::有序,可重复,可变序列
    tuple:有序,可重复,不可变序列(只读)
  • set vs frozenset
    set:无序,不可重复,可变序列
    frozenset:无序,不可重复,不可变序列(只读)
set([iterable])

定义: 创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。

x = set('hello')
y = set('python')
print(x, y)         # {'e', 'o', 'h', 'l'} {'t', 'y', 'p', 'o', 'h', 'n'}   重复的被删除
print(x & y)        # {'o', 'h'} 交集
print(x | y)        # {'y', 'h', 'e', 'p', 'l', 'n', 't', 'o'} 并集
print(x - y)        # {'l', 'e'} 差集
frozenset([iterable])

定义: 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。

s = frozenset(range(3))
print(s)        # frozenset({0, 1, 2})
s2 = frozenset([1, 1, 2, 3])
print(s2)       # frozenset({1, 2, 3})

相关内置函数 <8>

len(s)

定义: 返回对象(字符、列表、元组等)长度或项目个数。

print(len('hello'))  # 5 字符串长度
print(len([1, 2, 3, 4, 5]))  # 5 列表元素个数
sorted(iterable, key=None, reverse=False)

定义: 对所有可迭代的对象进行排序操作。

sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

lst = ['john', 'ken', 'jessica']
# 按名字长度排序
new_lst = sorted(lst, key=lambda item: len(item))
print(new_lst)      # ['ken', 'john', 'jessica']


lst = [('john', 'm', 15), ('ken', 'm', 20), ('jessica', 'f', 18)]
# 按年龄降序排序
new_lst = sorted(lst, key=lambda l:l[2], reverse=True)
print(new_lst)      # [('ken', 'm', 20), ('jessica', 'f', 18), ('john', 'm', 15)]

lst = [{'name': 'john', 'age': 15}, {'name': 'ken', 'age': 20}, {'name': 'jessica', 'age': 18}]
# 按年龄排序
new_lst = sorted(dict, key=lambda dict: dict['age'])
print(new_lst)  # [{'name': 'john', 'age': 15}, {'name': 'jessica', 'age': 18}, {'name': 'ken', 'age': 20}]
enumerate(sequence, [start=0])

定义: 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
参数说明:

  • sequence – 一个序列、迭代器或其他支持迭代对象。
  • start – 下标起始位置的值。
seasons = ['Sprint', 'Summer', 'Autumn', 'Winter']
print(list(enumerate(seasons)))             # [(0, 'Sprint'), (1, 'Summer'), (2, 'Autumn'), (3, 'Winter')]
print(list(enumerate(seasons, start=1)))    # [(1, 'Sprint'), (2, 'Summer'), (3, 'Autumn'), (4, 'Winter')]  下标从1开始

for item in enumerate(seasons):
    print(item)

for i, item in enumerate(seasons, start=1):
    print(i, item)

结果如下:
【Python】内置函数

all(iterable)

定义: 判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False。

print(all(['a', 'b', 'c']))     # True
print(all(['a', '', 'c']))      # False 存在一个为空的元素
print(all([0, 1, 2, 3]))        # False 存在一个未0的元素
any(iterable)

定义: 于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。

print(any(['a', 'b', 'c', '']))             # True
print(any(['', 0, False, [], (), {}]))      # False 存在一个为空的元素
zip([iterable, …])

定义: 用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

lst1 = [1, 2, 3]
lst2 = ['a', 'b', 'c', 'd']
z = zip(lst1, lst2)
print(list(z))      # [(1, 'a'), (2, 'b'), (3, 'c')] 元素个数与最短的列表保持一致

l1, l2 = zip(*zip(lst1, lst2))      # 与zip相反,zip(*)可理解为解压,返回二维矩阵式
print(list(l1))     # [1, 2, 3]
print(list(l2))     # ['a', 'b', 'c']
filter(function, iterable)

定义: 用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。

# 过滤列表中的奇数
odd_filter = filter(lambda x: x % 2 == 1, range(1, 10))
print(list(odd_filter))  # [1, 3, 5, 7, 9]

# 筛选年龄大于18的数据
lst = [{'name': 'june', 'age': 27},
       {'name': 'ken', 'age': 39},
       {'name': 'bob', 'age': 10}]

age_filter = filter(lambda dict: dict['age'] > 18, lst)
print(list(age_filter))     # [{'name': 'june', 'age': 27}, {'name': 'ken', 'age': 39}]
map(function, iterable, …)

定义: 根据提供的函数对指定序列做映射。可以对可迭代对象中的每一个元素进行映射,分别去执行fuction。

# 计算列表中每个元素的平方
mp = map(lambda x: x ** 2, range(1, 10, 2))
print(list(mp))  # [1, 9, 25, 49, 81]
# 等价于:
print([i**2 for i in range(1, 10, 2)])      # [1, 9, 25, 49, 81]

# 计算2个列表中相同位置的数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [6, 7, 8, 9, 10]
mp = map(lambda x, y: x + y, lst1, lst2)
print(list(mp))     # [7, 9, 11, 13, 15]

作用域相关【2】

locals()

定义: 返回字典类型的局部变量。

globals()

定义: 返回全局变量的字典。

a = 10
def func():
    a = 20
    print(locals())

func()
print(globals())	# 查看全局作用域所有内容
print(locals())		# 查看当前作用域中的内容

结果如下:
【Python】内置函数

面向对象相关【9】

迭代器/生成器相关【3】

range(start, stop[, step])

for i in range(10):
    print(i)

next(iterable[, default])

定义: 返回迭代器的下一个项目。
参数说明:

  • iterable – 可迭代对象
  • default – 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。

iter(object[, sentinel])

定义: 用来生成迭代器。
参数说明:

  • object – 支持迭代的集合对象。
  • sentinel – 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。
lst = [1, 2, 3]
it = lst.__iter__()
print(it.__next__())     # 1
it2 = iter(lst)          # 等价于:lst.__iter__()
print(next(it2))         # 1 等价于:lst__next__()

# def iter(obj):
#     return obj.__iter__()
# 
# def next(obj):
#     return obj.__next__()

其他【12】

字符串类型代码的执行(3)

eval(expression[, globals[, locals]])

定义: 执行字符串类型的代码,并返回最终结果。
参数说明:

  • expression – 表达式。
  • globals – 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
  • locals – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
r = eval('1+1')     # 可以把字符串当成代码去执行,有返回值
print(r)    # 2

exec(expression)

定义: 执行字符串类型的代码,返回值永远为 None。
执行储存在字符串或文件中的Python语句,相比于eval,exec可以执行更复杂的Python代码。

# 单行语句字符串
exec('print("Hello Python")')	# Hello Python

# 多行语句字符串
exec("""
for i in range(5):
    print(i)
""")

'''
# 结果如下:
0
1
2
3
4
'''

compile(source, filename, mode[, flags[, dont_inherit]])

定义: 将一个字符串编译成字节代码。把一段字符串代码加载,后面可以通过exec和eval执行。
参数说明:

  • source – 字符串或者AST(Abstract Syntax Trees)对象。。
  • filename – 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
  • mode – 指定编译代码的种类。可以指定为 exec, eval, single。
  • flags – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
  • flags和dont_inherit是用来控制编译源码时的标志。
str = "for i in range(1, 3): print(i)"
c = compile(str, '', 'exec')    # 编译成字节代码对象
exec(c)	# 1 2

str = "3 * 4 + 5"
r = compile(str, '', 'eval')
print(eval(r))      # 17

输入输出(2)

input([prompt])

定义: 接受控制台输入数据,返回为 string 类型。
参数说明: 提示信息

a = input('Please input: ')
print(type(a))

结果如下:
【Python】内置函数

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

定义: 打印输出
参数说明:

  • objects – 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
  • sep – 用来间隔多个对象,默认值是一个空格。
  • end – 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串。
  • file – 要写入的文件对象。
  • flush – 输出是否被缓存通常决定于 file,但如果 flush 关键字参数为 True,流会被强制刷新。
print("www","baidu","com",sep=".")  # 设置间隔符 www.baidu.com

内存相关(2)

hash(object)

** 定义:** 返回对象的哈希值。

print(hash('呵呵'), hash('哈哈'))	# -855838824 538020339 (每次运行值都不同)

id([object])

定义: 返回对象的内存地址。

lst1 = [1, 2, 3]
lst2 = [1, 2, 3]
print(id(lst1), id(lst2))   # 20858360 20859520 (每次运行值都不同)

文件操作相关(1)

open(“filePah”, mode=“”, encoding=“utf-8”)

f = open("xxx", mode="", encoding="utf-8")
f.rea()
for line in f:
    pass

f.write()

with open() as f:
    pass

模块相关(1)

_import_(moduleName)

定义: 动态加载一个模块。

# 已知导入模块:
import os
# 未知,输入导入模块:
mo = input('>>>')   # "os"
__import__(mo)      # 动态加载一个模块

帮助(1)

help([object])

定义: 用于查看函数或模块用途的详细说明。

print(help(str))	# 查看 str 数据类型的帮助

调用相关(1)

callable(object)

定义: 判断object是否是可以被调用的。

def func():
    pass

print(callable(func))   # True
print(callable(123))    # False
def run():
    print('I can run.')

def func(fn):
    if callable(fn):    # 判断该内容是否可以被调用
        fn()
    else:
        print('The input func can not callable.')

func(run)	# I can run.
func(123)	# The input func can not callable.

查看内置属性(1)

dir([object])

定义: 不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。
参数说明: object – 对象、变量、类型。文章来源地址https://www.toymoban.com/news/detail-461176.html

print(dir())
# ['__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print(dir(str))
# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

到了这里,关于【Python】内置函数的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Python 内置数据类型详解

    在编程中,数据类型是一个重要的概念。 变量可以存储不同类型的数据,不同类型可以执行不同的操作。 Python默认内置了以下这些数据类型,分为以下几类: 文本类型:str 数值类型:int、float、complex 序列类型:list、tuple、range 映射类型:dict 集合类型:set、frozenset 布尔类

    2024年02月08日
    浏览(40)
  • 【Python 零基础入门】常用内置函数 初探

    Python 是一种解释性, 高级和通用的变成语言. Python 由 Guido van Rossum 创建并 1991 年首次发布. Python 的设计强调代码的可读性, 其雨大允许我们使用相较于 C++ 或 Java 更少的代码表达概念. Python 使得变成变得更简单, 更快捷. 下面就跟着小白我来一起看一下 Python 常用的内置函数.

    2024年02月05日
    浏览(73)
  • 【Python 零基础入门】常用内置函数 再探

    Python 是一种解释性, 高级和通用的变成语言. Python 由 Guido van Rossum 创建并 1991 年首次发布. Python 的设计强调代码的可读性, 其雨大允许我们使用相较于 C++ 或 Java 更少的代码表达概念. Python 使得变成变得更简单, 更快捷. 下面就跟着小白我来一起看一下 Python 常用的内置函数.

    2024年02月04日
    浏览(43)
  • 【0基础入门Python笔记】三、python 之函数以及常用内置函数

    函数是一种用于封装可重复使用代码块的工具,能够将一系列操作组织成一个逻辑单元。 函数定义 在Python中,函数通过def进行定义,后面跟着函数的名称、参数列表和冒号。函数的主体代码块缩进,并在需要时使用return返回值。 在上面的示例中,我们定义了一

    2024年02月12日
    浏览(71)
  • Python的数据类型的内置方法

    可变与不可变数据类型 字典的内置方法 元组的内置方法 集合的内置方法

    2024年02月10日
    浏览(34)
  • 【Python数据分析】Python常用内置函数(一)

    🎉欢迎来到Python专栏~Python常用内置函数(一) ☆* o(≧▽≦)o *☆ 嗨 ~我是 小夏与酒 🍹 ✨ 博客主页: 小夏与酒的博客 🎈该系列 文章专栏: Python学习专栏 文章作者技术和水平有限,如果文中出现错误,希望大家能指正🙏 📜 欢迎大家关注! ❤️ Python技能树:Python入门技

    2024年02月15日
    浏览(51)
  • 【Python数据分析】Python常用内置函数(二)

    🎉欢迎来到Python专栏~Python常用内置函数(二) ☆* o(≧▽≦)o *☆ 嗨 ~我是 小夏与酒 🍹 ✨ 博客主页: 小夏与酒的博客 🎈该系列 文章专栏: Python学习专栏 文章作者技术和水平有限,如果文中出现错误,希望大家能指正🙏 📜 欢迎大家关注! ❤️ Python技能树:Python入门技

    2024年02月14日
    浏览(44)
  • 【Python数据分析】常用内置函数(一)

    🙋‍ 哈喽大家好,本次是python数据分析、挖掘与可视化专栏第四期 ⭐本期内容:常用内置函数 🏆系列专栏:Python数据分析、挖掘与可视化 👍“总有一段时光悄悄过去然后永远怀念.” 本期内容为python的常用内置函数~ 参考书籍:《Python数据分析、挖掘与可视化》 在python中

    2024年02月04日
    浏览(49)
  • Go语言内置类型和函数

    1.1.1 值类型 1.1.2 引用类型:(指针类型) Go 语言拥有一些不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作,例如:len、cap 和 append,或必须用于系统级的操作,例如:panic。因此,它们需要直接获得编译器的支持。

    2024年02月08日
    浏览(54)
  • 【python基础语法五】python函数和函数相关概念

    概念:功能 (包裹一部分代码 实现某一个功能 达成某一个目的) 特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理 python中的函数可以像变量一样,动态创建,销毁,当参数传递,作为值返回,叫第一类对象.其他语言功能有限 函数名是个特殊的变量,可以当做变量赋值

    2024年02月02日
    浏览(81)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包