标签：__ 10 内置函数 list num print my

内置函数

一、数据类型转换 (8个)

强制类型转换的方法：

强转成字符串（str()）
强转成整数（int()）
强转成浮点数（float()）
强转成布尔类型（bool()）
强转成列表类型（list()）
强转成元组类型（tuple()）
强转成集合类型（set()）
强转成字典类型（dict()）

二、进制转换（3个）

# 十进制转二进制 ， 0b 开头的就是二进制
print(bin(100))  # 0b1100100

# 十进制转八进制 ， 0o 开头的就是八进制
print(oct(100))  # 0o144

# 十进制转十六进制 ， 0x 开头的就是十六进制
print(hex(100))  # 0x64

三、数学运算（8个）

[1]绝对值（`abs()`）

print(abs(-8)) # 8

[2]获取商和余数（`divmod(被除数,除数)` ）--- 分页的时候会用到它

print(divmod(7, 3))  # (2, 1)

[3]四舍五入（`round(浮点数，要保留的小数位数（默认不保留小数）)`）

print(round(2.05))  # 2 
print(round(2.051, 1))  # 2.1

#round函数有一个区别去真正数学运算的特性，要进行四舍五入的那一位不仅要自身大于等于5还要满足后一位数也有值
# 比如说2.5 进行四舍五入 不仅需要第一位小数的值大于5，还需要满足5后面还有值 2.50进行四舍五入结果就是2
print(round(2.49))  # 2
print(round(2.50))  # 2
print(round(2.51))  # 3

[4]幂次方（`abs(x,y,z)`）

参数介绍
- x — 数值表达式(整数或者浮点数)
- y — 数值表达式(整数或者浮点数)
- z — 数值表达式(整数或者浮点数)，默认不设置z值
- 返回值：返回 x^y(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) %z；

# pow(底数,幂次方,除数) --> 取模
print(pow(3, 3))  # 27
#  设置了z值 等价于 3 * 3 * 3 % 5
print(pow(3, 3, 5))  # 2
print(3 * 3 * 3 % 5)  # 2
# 底数和幂次方都可以为小数，且任意一个值为小数时，结果都会是小数
print(pow(3, 3.0))  # 27.0
print(3.0 * 3.0 * 3.0)  # 27.0

[5]求和（`sum()`）

只能放可迭代类型

print(sum([11, 22, 33, 44]))  # 110

print(sum((12, 34)))  # 46

[6]求最大值（`max()`）

print(max([1, 22, 3, 44, 5, 66, 7]))  # 66

[7]绝对值（`min()`）

print(min([11, 2, 33, 4, 55, 6, 77]))  # 2

[8]复数（`complex()`）

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

num_1 = complex(1, 2)
print(num_1)  # (1+2j)

num_2 = complex(3, 4)
print(num_2)  # (3+4)

res = num_1 + num_2
print(res)  # (4+6j)

四、序列化相关（5个）

[1]翻转（`reversed()`）

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = reversed(num_list)
#翻转过的列表会转换成翻转对象需要强制转换成列表
print(new_list)  # <list_reverseiterator object at 0x0000019DDF01B760>
print(list(new_list))  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

[2]切片（`slice()`）

my_str = "my name is Xanadu"
slice_str = my_str[slice(5, 10, 2)]
print(slice_str)  # m s
print(my_str[5:10:2])  # m s

[3]计算长度（`len()`）

name = "Xanadu"
print(len(name))  # 6

[4]排序（`sorted()`）

num_list = [11, 2, 33, 4, 55, 6, 77]
#默认是从小到大排序
new_list = sorted(num_list)
print(new_list)  # [2, 4, 6, 11, 33, 55, 77]
#将reverse值设置为True时，就会从大到小排序
new_list_2 = sorted(num_list, reverse=True)
print(new_list_2)  # [77, 55, 33, 11, 6, 4, 2]

[5]枚举（`enumerate()`）

my_list = ["Xanadu", "bridge", "water", 11, 88, 66]
#列表经过枚举后变换成枚举对象
enumerate_list = enumerate(my_list)
print(enumerate_list)  # <enumerate object at 0x0000021B35108E80>

#可以直接使用for循环，解压出索引和元素
for index, item in enumerate_list:
    print(index, item)

'''
0 Xanadu
1 bridge
2 water
3 11
4 88
5 66
'''

六、字符串相关（7个）

[1]格式化输出（`format()`）

name = "Xanadu"
print(format(name, "^10"))  #  Xanadu   在左右添加空格到长度为10为止（居中）
print(format(name, "<10"))  #Xanadu     在右边添加空格到长度为10为止（左对齐）
print(format(name, ">10"))  #    Xanadu 在左边添加空格到长度为10为止（右对齐）


print(format(99, 'b'))  # 二进制:1100011
print(format(99, 'c'))  # 转换成unicode字符:c
print(format(99, 'd'))  # ⼗进制:99
print(format(99, 'o'))  # 八进制:143
print(format(99, 'x'))  # 十六进制:63
print(format(99, 'n'))  # 和d⼀样:99
print(format(99))  # 和d⼀样:99

print(format(9874563210, 'e'))  # 科学计数法. 默认保留6位小数:9.874563e+09
print(format(9874563210, '0.2e'))  # 科学计数法. 保留2位小数(小写):9.87e+09
print(format(9874563210, '0.2E'))  # 科学计数法. 保留2位小数(大写):9.87E+09
print(format(9.87456321, 'f'))  # 小数点计数法. 保留6位小数:9.874563
print(format(9.87456321, '0.2f'))  # 小数点计数法. 保留2位小数:9.87
print(format(9.87456321, '0.10f'))  # 小数点计数法. 保留10位小数:9.8745632100

[2]字符串转 bytes

b_str = bytes('桃源', encoding='utf8')
print(b_str)  # b'\xe6\xa1\x83\xe6\xba\x90'

[3]获取字节数组（`bytearray()`）

res = bytearray('桃源', encoding='utf8')
# 一个英文占一个字节，一个中文占三个字节
print(list(res))  # [230, 161, 131, 230, 186, 144]

[4]返回对象的字符串格式（`repr()`）

my_str = "今天\n吃了%s顿\t饭" % 3
print(my_str)
'''
今天
吃了3顿	饭
'''

# 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
print(repr(my_str))
# '今天\n吃了3顿\t饭'

[5]根据给定的Unicode 字符找数字（`ord()`）

print(ord('Q'))  # 81

[6]根据数字找 Unicode 字符（`chr()`）

print(chr(99))  # c

[7]根据数字找 ASCII字符（`ascii()`）

# 如果返回一个字符串，表示对象的可打印 ASCII 码形式;非 ASCII 字符会用 \x、\u 和 \U 进行转义。
print(ascii("桃源"))  # '\u6843\u6e90'

七、数据集合（1个）

创建一个冻结的集合(frozenset)
frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。
注释: frozenset() 函数返回一个不可变的 frozenset 对象，适用于作为字典的键或集合的元素。

num_set = {11, 2, 33, 4, 55, 6, 77}
new_set = frozenset(num_set)
print(new_set)  # frozenset({33, 2, 4, 6, 11, 77, 55})

八、判断条件（2个）

# all : 参数是可迭代类型， 参数里面所有为真才为真
if 0 and 'Xanadu' and [1, 2]:
    print(True)
else:
    print(False)
# 结果为False
print(all([0, 'Xanadu', [1, 2]]))  # 结果为False
# any : 参数是可迭代类型 ， 参数里面任一为真就为真
print(any([0, 'Xanadu', [1, 2]]))  # 结果为True

九、高阶函数（3个）

[1]`zip()`函数

lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['雷雨', '麦克白', '伪君子', '女店主', '钦差大臣', '群鬼']
lst3 = ['中国', '英国', '法国', '意大利', '挪威']

print(list(zip(lst1, lst2)))
# [(1, '雷雨'), (2, '麦克白'), (3, '伪君子'), (4, '女店主'), (5, '钦差大臣'), (6, '群鬼')]
# 如果一个列表中的元素相较于另一个列表中的元素少，那就会按照元素少的列表进行打包
lst1 = [1, 2, 3, 4, 5]
print(list(zip(lst1, lst2)))
# [(1, '雷雨'), (2, '麦克白'), (3, '伪君子'), (4, '女店主'), (5, '钦差大臣')]

[2]`filter()`函数

语法：fiter(用来筛选的函数，可迭代对象)
- 在ﬁlter中会自动的把可迭代对象中的元素传递给函数
- 然后根据函数返回的True或者False来判断是否保留留此项数据

def func(i):  
    return i > 5


lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

#  l1是迭代器
l1 = filter(func, lst)
print(l1)  # <filter object at 0x000002031B89ACE0>
print(list(l1))  # [6, 7, 8, 9]

[3]`map()`函数

语法：map(用来映射的函数，可迭代对象)
- 可以对可迭代对象中的每一个元素进行映射. 分别去执行函数

def func(i):
    return i * 2


num_list = [1, 2, 3, 4, 5, 6]
print(map(func, num_list))  # <map object at 0x000001ECFB14A680>
print(list(map(func, num_list)))  # [2, 4, 6, 8, 10, 12]
print(list(map(lambda x: x * 2, (1, 2, 3, 4, 5, 6))))  # 还可以使用匿名函数
# [2, 4, 6, 8, 10, 12]

十、作用域（2个）

locals() 返回当前作用域中的名字
globals() 返回全局作用域中的名字

name = "Xanadu"


def func():
    print("-----------------------------")
    age = 18
    print(f"这是当前作用域中的内容 :>>>> {locals()}")
    print(f"这是全局作用域中的内容 :>>>> {globals()}")
    print("这是在函数内部")
    print("-----------------------------")


func()
print(f"这是全局作用域中的内容 :>>>> {globals()}")
print("这是在函数外部")

'''
-----------------------------
这是当前作用域中的内容 :>>>> {'age': 18}
这是全局作用域中的内容 :>>>> {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001C11CF47C70>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\project\\python\\project_study\\re模块.py', '__cached__': None, 're': <module 're' from 'D:\\app\\python\\3.10\\lib\\re.py'>, 'name': 'Xanadu', 'func': <function func at 0x000001C11CFA3EB0>}
这是在函数内部
-----------------------------
这是全局作用域中的内容 :>>>> {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001C11CF47C70>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\project\\python\\project_study\\re模块.py', '__cached__': None, 're': <module 're' from 'D:\\app\\python\\3.10\\lib\\re.py'>, 'name': 'Xanadu', 'func': <function func at 0x000001C11CFA3EB0>}
这是在函数外部

'''

十一、迭代器生成器（3个）

[1]循环生成数据（`range()`）

range(开头数字，结尾数字)，顾头不顾尾

# 生成数据，需要循环取值
range(1, 10)
print([i for i in range(1, 10)])  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

[2]获取迭代器（`iter()`）

获取迭代器, 内部实际使用的是__ iter__()方法来获取迭代器

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_iter = iter(my_list)
print(my_iter)  # <list_iterator object at 0x00000233DA70B760>

[3]向下执行（`next()`）

迭代器向下执行一次, 内部实际使用了__ next__()方法返回迭代器的下一个项目

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#先生成迭代器
my_iter = iter(my_list)
# 使用next向下执行
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))

'''
1
2
3
4
5
'''

十二、字符串类型代码的执行（3个）

[1]指定指令并返回结果（`eval()`）

只能执行一行的代码，多行或者代码块都不能执行
直接返回内容

eval('print("Hell0 Word!")')
# Hello Word!

[2]指定指令不返回结果（`exec()`）

可以执行多行代码和代码块
没有返回值

exec('''
a = 1
b = 1
c = a + b
print(c)
''')
# 2

[3]编码指令（`compile()`）

compile并不会执行你的代码.只是编译

code1 = "for i in range(3): print(i)"
# compile并不会执行你的代码.只是编译
com = compile(code1, "", mode="exec")
# 执行编译的结果 : 可以让 eval 执行，也可以让 exec 执行
eval(com)
exec(com)
# 0
# 1
# 2

十三、输入输出（2个）

print() : 打印输出

print("Xanadu", "bridge", sep="|", end="*") 
# sep:打印出的内容用什么连接
# end:以什么为结尾
# Xanadu*bridge@

input() : 获取用户输出的内容

十四、哈希

哈希算法又称摘要算法，处理过的字符串具有唯一性。

s = 'Xanadu'
print(hash(s))  # -3597524617337753711

十五、文件、帮助、导入（3个）

# 打开文件语法
f = open(file=...,mode=...,encoding=...)

# 导入模块语法
exec('import os')
os = __import__('os')
print(os.listdir())

# 帮助函数
import os
print(help(os))

十六、调度和查看属性（2个）

# 变量名是否可被调用 ： 能 变量名() 就能被调用
a = 10
# 变量a不能被调用

print(callable(a))


# False

def f():
    print("hello")


# 函数是可以被调用的
print(callable(f))
# True


# 查看内置属性或方法 dir

print(dir(list))

标签：__,10,内置,函数,list,num,print,my
From： https://www.cnblogs.com/taoyuanshi/p/17932209.html

内置函数

内置函数

一、数据类型转换 (8个)

二、进制转换（3个）

三、数学运算（8个）

[1]绝对值（abs()）

[2]获取商和余数 （divmod(被除数,除数) ）--- 分页的时候会用到它

[3]四舍五入（round(浮点数，要保留的小数位数（默认不保留小数）)）

[4]幂次方（abs(x,y,z)）

[5]求和（sum()）

[6]求最大值（max()）

[7]绝对值（min()）

[8]复数（complex()）

四、序列化相关（5个）

[1]翻转（reversed()）

[2]切片（slice()）

[3]计算长度（len()）

[4]排序（sorted()）

[5]枚举（enumerate()）

六、字符串相关（7个）

[1]格式化输出（format()）

[2]字符串转 bytes

[3]获取字节数组（bytearray()）

[4]返回对象的字符串格式（repr()）

[5]根据给定的Unicode 字符找数字（ord()）

[6]根据数字找 Unicode 字符（chr()）

[7]根据数字找 ASCII字符（ascii()）

七、数据集合（1个）

八、判断条件（2个）

九、高阶函数（3个）

[1]zip()函数

[2]filter()函数

[3]map()函数

十、作用域（2个）

十一、迭代器生成器（3个）

[1]循环生成数据（range()）

[2]获取迭代器（iter()）

[3]向下执行（next()）

十二、字符串类型代码的执行（3个）

[1]指定指令并返回结果（eval()）

[2]指定指令不返回结果（exec()）

[3]编码指令（compile()）

十三、输入输出（2个）

十四、哈希

十五、文件、帮助、导入（3个）

十六、调度和查看属性（2个）

相关文章

赞助商

阅读排行

[1]绝对值（`abs()`）

[2]获取商和余数（`divmod(被除数,除数)` ）--- 分页的时候会用到它

[3]四舍五入（`round(浮点数，要保留的小数位数（默认不保留小数）)`）

[4]幂次方（`abs(x,y,z)`）

[5]求和（`sum()`）

[6]求最大值（`max()`）

[7]绝对值（`min()`）

[8]复数（`complex()`）

[1]翻转（`reversed()`）

[2]切片（`slice()`）

[3]计算长度（`len()`）

[4]排序（`sorted()`）

[5]枚举（`enumerate()`）

[1]格式化输出（`format()`）

[3]获取字节数组（`bytearray()`）

[4]返回对象的字符串格式（`repr()`）

[5]根据给定的Unicode 字符找数字（`ord()`）

[6]根据数字找 Unicode 字符（`chr()`）

[7]根据数字找 ASCII字符（`ascii()`）

[1]`zip()`函数

[2]`filter()`函数

[3]`map()`函数

[1]循环生成数据（`range()`）

[2]获取迭代器（`iter()`）

[3]向下执行（`next()`）

[1]指定指令并返回结果（`eval()`）

[2]指定指令不返回结果（`exec()`）

[3]编码指令（`compile()`）