19.Python基础篇-内置函数

说明

某个方法属于某个数据类型，就用.调用

如果某个方法不依赖任何数据类型，就直接调用。这种都是内置函数或者自定义函数。

作用域相关

locals()

返回当前局部命名空间中的所有变量（即局部变量）的字典。局部命名空间包括在函数或方法内部定义的变量、参数和临时值。它返回的是当前作用域内的局部变量的拷贝。

# 全局作用域中调用 locals()
x = 10
y = 20
print(locals())  
# 输出: {'x': 10, 'y': 20, ...}（显示当前全局作用域中的局部变量）

# 在函数中使用 locals()
def my_function():
    a = 1
    b = 2
    print(locals())

my_function()  
# 输出: {'a': 1, 'b': 2}（显示函数内部的局部变量）

globals()

返回当前全局命名空间中的所有变量（即全局变量）的字典。全局命名空间包括在脚本、模块、函数外部定义的变量。

# 定义全局变量
x = 10
y = 20

# 打印全局变量
print(globals())  
# 输出: {'x': 10, 'y': 20, ...}（显示全局作用域中的变量）

# 在函数中调用 globals()
def my_function():
    a = 1
    b = 2
    print(globals())  

my_function()  
# 输出: {'x': 10, 'y': 20, ...}（仅显示全局变量）

生成器迭代器

next()

从迭代器中获取下一个元素。每次调用 next()，都会返回迭代器的下一个值。当迭代器耗尽时，如果没有为 next() 提供默认值，则会引发 StopIteration 异常。

iter()

返回一个可迭代对象的迭代器。迭代器是一个实现了 __iter__() 和 __next__() 方法的对象，允许我们使用 next() 按顺序获取元素。可以使用 iter() 将一个可迭代对象（如列表、字符串、元组等）转换为迭代器。

# 使用 next() 获取列表迭代器的下一个元素
my_list = [1, 2, 3]
it = iter(my_list)  # 使用iter()方法，获取列表的迭代器
print(next(it))     # 输出: 1
print(next(it))     # 输出: 2
print(next(it))     # 输出: 3
# print(next(it))   # 如果继续调用，会引发 StopIteration 异常

# 使用默认值避免 StopIteration 异常
print(next(it, 'end'))  # 输出: 'end'

range()

• start: 计数从 start 开始。默认是从 0 开始。
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

for i in range(1, 6, 2):
    print(i)

输出结果：
1
3
5

其它

dir()

返回一个对象的属性和方法列表。如果没有提供参数，它会返回当前作用域的名称列表。非常有用的内建函数，用于检查模块或类中的可用属性和方法。

示例: dir(list) 会返回 list 对象的方法和属性。

print(dir(list))

# 结果：
# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

help()

显示指定参数对象的文档字符串和相关信息。

print(help(str))

callable()

检查对象是否可以被调用。如果对象可以被调用（例如函数或具有 __call__() 方法的对象），则返回 True；否则返回 False。

示例: callable(print) 会返回 True，因为 print 是可调用的。

print(callable(print))  # True

 

class A:
    def func(self):
        pass
a = A()
print(callable(a))  # False,a对象没有实现__call__方法，所以为false

class B:
    def __call__(self, *args, **kwargs):
        pass
b = B()
print(callable(b))  # True，b对象实现了__call__方法，所以为true

import()

动态导入模块。import() 函数可以在运行时导入模块，功能类似于 import 语句。name 是要导入的模块名，可以使用 fromlist 指定导入子模块。

示例: import('math') 动态导入 math 模块。

pass

open()

打开文件并返回文件对象。file 是文件路径，mode 指定打开文件的模式（如 'r' 读取、'w' 写入、'a' 追加等）。可以指定编码、缓冲等。

id()

返回对象的内存地址

print(id((5)))  # 140711424169872

hash()

返回对象的哈希值，通常用于字典键、集合或其他哈希集合的数据结构中。可哈希对象是不可变的对象，如 int、float、str。

print(hash(123))  # 123
print(hash(1.2))  # 461168601842738689
print(hash('hello'))  # 8149501313017243430

input()

读取用户输入。如果提供了 prompt，它会在用户输入前显示该提示信息。返回输入的字符串。

print()

sep 参数指定对象之间的分隔符，这个参数默认是空格符

end 参数指定行的结束符，默认是\n换行符

file 参数可以指定输出流，比如输出到指定文件中

with open('test.txt','w') as f:
    print('123', '456', sep='---', end='', file=f)

eval()、exec()、compilie()

# eval() 和 exec() 都可以执行字符串类型的代码
eval('print(123)')  # 123
exec('print(123)')  # 123

# eval() 和 exec()的区别：eval有返回值，evex没有返回值
print(eval('1+2'))  # 3
print(exec('1+2'))  # None

# compilie()
code1 = 'print(123)'
compile1 = compile(code1, '', 'exec')  # 将字符串代码转换成字节码，赋值给compile1变量
exec(compile1)  # 执行字节码

code2 = '1+2+3+4'
compile2 = compile(code2, '' , 'eval')
print(eval(compile2))

code3 = "name = input('输入名字')"
compile3 = compile(code3, '', 'single')
exec(compile3)
print(name)  # name虽然在pycharm中提示报错，实际执行起来是不会报错的

eval和exec和compilie三个方法的区别：

eval(): 用于计算表达式，并返回结果。适用于简单的表达式。

exec(): 用于执行多条语句，适用于复杂的代码块。不会返回值。

compile(): 将字符串代码编译为代码对象，之后可以用 eval() 或 exec() 执行。

基础数据类型

数据类型

bool()

将值转换为bool类型

print(bool(1))      # 输出: True
print(bool(0))      # 输出: False
print(bool([]))     # 输出: False（空列表）
print(bool([1, 2])) # 输出: True（非空列表）

int()

将一个值转换为整数。int() 函数可以将数字或字符串形式的数字转换为整数。如果提供浮点数，它会去除小数部分。如果提供字符串，它会尝试将字符串解析为整数（支持进制转换）。

# 将浮点数转换为整数
print(int(3.14))      # 输出: 3

# 将字符串转换为整数
print(int('42'))      # 输出: 42

# 将二进制字符串转换为整数
print(int('101', 2))  # 输出: 5

# 将十六进制字符串转换为整数
print(int('A', 16))   # 输出: 10

float()

将一个值转换为浮点数。float() 函数可以将整数、浮点数或字符串形式的数字转换为浮点数。

# 将整数转换为浮点数
print(float(10))      # 输出: 10.0

# 将字符串转换为浮点数
print(float('3.14'))  # 输出: 3.14

# 将整数字符串转换为浮点数
print(float('42'))    # 输出: 42.0

进制转换

bin()、oct()、hex()

bin(): 将整数转换为二进制字符串，前缀为 '0b'。

oct(): 将整数转换为八进制字符串，前缀为 '0o'。

hex(): 将整数转换为十六进制字符串，前缀为 '0x'。

print(bin(10))  # 0b1010
print(oct(10))  # 0o12
print(hex(10))   # 输出: '0xa'

数字运算

abs()

返回数字的绝对值

print(abs(10))  # 10的绝对值是10
print(abs(-10))  # -10的绝对值是10
# 结果：
10
10

divmod()

同时返回商和余数

print(divmod(10, 3))   # 10除3 商多少，余多少
# 输出: (3, 1)  商3余1

round()

对数字进行四舍五入

print(round(3.14159, 2))  # 取3.14159这个数字的小数点后两位
# 输出: 3.14

pow()

返回幂运算结果，支持可选的模运算

print(pow(2, 3))        # 输出: 8（2^3 2的三次方）

sum()

对可迭代对象中的元素求和

print(sum([1, 2, 3, 4]))  # 结果：10

min()

返回最小值。

print(min(1 ,2, 3, 4))  # 结果：1

max()

返回最大值。

print(max(1 ,2, 3, 4))  # 结果：4

 数据结构

reversed()

保留原列表，返回一个反转的迭代器

lis = [1,2,3,4,5]
l1 = reversed(lis)
print(l1)

# 结果：
<list_reverseiterator object at 0x000002590FD28F40>

slice()

定一个切片规则，其他变量都可以用这个规则进行切片

lis = [1,2,3,4,5]
s = slice(0,4)
print(lis[s])
print(lis[0:4])
# 上面两种写法，结果一样
# 结果：
[1, 2, 3, 4]
[1, 2, 3, 4]

format()

格式化输出

简单演示：

name = '小明'
age = 18
print('我叫：{}，今年{}岁'.format(name,age))  # 我叫：小明，今年18岁

# 开辟x个空间，左对齐，右对齐，居中

print(format('test','<20'))#左对齐
print(format('test','>20'))#右对齐
print(format('test','^20'))#居中
# 输出结果：
test                
                test
        test       

bytes()

转换编码方式

print(bytes('你好', encoding='GBK'))  # 将Unicode编码的你好，转换为GBK。因为Python解释器默认的编码方式是Unicode

print(bytes('你好',encoding='GBK').decode('GBK'))#将字符串’你好‘从unicode转换成GBK。并解码
print(bytes('你好',encoding='utf-8').decode('utf-8'))#将字符串’你好‘从unicode转换成utf-8的bytes。

# 一个GBK编码的数据
gbk_b = bytes('hello', encoding='GBK')
# 将这个GBK编码的数据转换为utf-8
unicode_s = gbk_b.decode('GBK')  # 1.先解码GBK数据，解为Unicode编码
utf8_s = unicode_s.encode('utf-8')  # 2.将Unicode编码解成utf-8
print(utf8_s)

 

将GBK编码转为utf-8需要Unicode为中介。先转为Unicode，再从Unicode转换到utf-8。

 

ord() 和 chr()

ord:将字符按照Unicode转成数字

chr:将数字按照Unicode转成字符

print(ord('a'))  # 97

print(chr(97))  # a

ascii()

只要是ASCII码中的内容，就打印出来，不是就转换成\u

print(ascii('好'))
print(ascii('a'))

'\u597d'
'a'

repr()

将变量的值原封不动的打印出来

a = '1'
b = 1
print(a)  # 1(没带双引号，光看控制台无法确定输出的是字符串还是数字
print(b)  # 1

print(repr(a))  # 使用repr后会带着引号打印出来
print(repr(b))

dict()

用于创建字典

# 使用关键字参数创建字典
my_dict = dict(name="Alice", age=30)
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30}

# 使用可迭代对象创建字典
my_list = [('name', 'Bob'), ('age', 25)]
my_dict = dict(my_list)
print(my_dict)  # 输出: {'name': 'Bob', 'age': 25}

set()

创建一个集合

# 创建一个空集合
my_set = set()
print(my_set)  # 输出: set()

frozenset()

创建一个不可变的集合，类似于 set()，但不能修改。它的元素也是唯一的，常用于需要保证集合不被修改的场景。

# 创建一个 frozenset
my_frozenset = frozenset([1, 2, 3, 2])
print(my_frozenset)  # 输出: frozenset({1, 2, 3})

# 尝试修改 frozenset（将引发错误）
# my_frozenset.add(4)  # AttributeError: 'frozenset' object has no attribute 'add'

重要的内置函数

len()

返回对象的长度或元素个数

print(len("hello"))          # 输出: 5

enumerate()

返回一个枚举对象，将可迭代对象中的每个元素及其索引一起返回，通常用于在 for 循环中获取元素及其索引。

my_list = ['a', 'b', 'c']
for index, value in enumerate(my_list):
    print(index, value)

all()

检查可迭代对象中的所有元素是否都为 True，若所有元素为 True 则返回 True，否则返回 False。空的可迭代对象返回 True。

print(all([True, True, True]))    # 输出: True
print(all([True, False, True]))   # 输出: False
print(all([]))                    # 输出: True（空列表）

any()

检查可迭代对象中是否至少有一个元素为 True，如果存在，则返回 True，否则返回 False。空的可迭代对象返回 False。

print(any([False, False, True]))  # 输出: True
print(any([False, False, False])) # 输出: False
print(any([]))                    # 输出: False（空列表）

zip()

将多个可迭代对象中的元素配对，返回一个元组组成的迭代器。长度按最短的可迭代对象对齐。（助记：拉链）

list1 = [1, 2, 3]
list2 = ['A', 'B', 'C']
print(zip(list1, list2))  # zip返回一个迭代器
for i in zip(list1, list2):
    print(i)
# 结果：
(1, 'A')
(2, 'B')
(3, 'C')


list1 = [1, 2, 3]
list2 = ['A', 'B', 'C', 'D']  # 3个元素的变量与4个元素的变量，使用zip拉链会有什么效果
print(zip(list1, list2))
for i in zip(list1, list2):
    print(i)
# 结果：
(1, 'A')
(2, 'B')
(3, 'C')

***filter()

根据指定的函数筛选可迭代对象中的元素，返回一个过滤后的迭代器。

def is_odd(x):
    return x % 2 ==1

ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
print(ret)  # <filter object at 0x00000180A818B970>
for i in ret:
    print(i)

结果：
1
7
9
17

***map()

将指定的函数应用到可迭代对象的每个元素，返回一个结果组成的迭代器。

def sum_num(x):
    x += 1
    return x
list1 = [1, 4, 6, 7, 9, 12, 17]
squared = map(sum_num, list1)  # 将list1中的每个元素+1，存到squared变量中。返回值为迭代器
for i in squared:  # 遍历返回的迭代器
    print(i)
2
5
7
8
10
13
18

***sorted()

返回排序后的新列表，而不修改原始序列。可以指定排序规则和顺序。

numbers = [3, 1, 4, 2]
sorted_num = sorted(numbers)
print(numbers)  # [3, 1, 4, 2]  原来的list不变
print(sorted_num)  # [1, 2, 3, 4]


numbers = [3, 1, 4, 2]
sort_num = numbers.sort()
print(numbers)  # [1, 2, 3, 4]  改变了原来的list
print(sort_num)  # None sort方法没有返回值

sort与sorted的区别：

sort改变原list，sorted则是生成一个新的list，作为返回值返回。

sort没有返回值，sorted有返回值

注意：sorted会生成一个新list，所以要比sort更占用内存。

 匿名函数

 关键字lambda。以“ : ”分割，冒号前为参数，多个参数逗号分割；冒号后为返回值。匿名函数不能换行

add = lambda x,y:x+y
print(add(1,1))