python内置方法的使用方法及示例

演示python内置方法的使用方法及示例：

1. eval()

*eval()*函数将字符串转换为可执行代码，并返回运行结果。使用eval()函数需要注意安全性问题，因为它可以执行任何可执行的代码。以下是一个示例：

a = "1 + 2"
b = eval(a)
print(b)  # 输出结果为 3

2. all()

*all()*函数判断一个可迭代对象中所有元素是否全部为真，若全部为真返回True，否则返回False。以下是一个示例：

a = [1, 2, 3, 4]
b = all(a)
print(b)  # 输出结果为 Truec = [1, 0, 3, 4]
d = all(c)
print(d)  # 输出结果为 False

3. any()

*any()*函数判断一个可迭代对象中任何一个元素为真，即返回True，否则返回False。以下是一个示例：

a = [0, 0, 0, 4]
b = any(a)
print(b)  # 输出结果为 Truec = [0, 0, 0, 0]
d = any(c)
print(d)  # 输出结果为 False

4. ascii()

*ascii()*函数将一个对象编程一个可打印的字符串。以下是一个示例：

a = "你好"
b = ascii(a)
print(b)  # 输出结果为 '\\u4f60\\u597d'

5. bin()

*bin()*函数将十进制数字转换为二进制。以下是一个示例：

a = 10
b = bin(a)
print(b)  # 输出结果为 '0b1010'

6. bool()

*bool()*函数判断真假返回True或者False。以下是一个示例：

a = 0
b = bool(a)
print(b)  # 输出结果为 Falsec = "Hello"
d = bool(c)
print(d)  # 输出结果为 True

7. bytearray()
   bytearray 是 Python 内置的一种可变序列类型，用于表示二进制数据。bytearray 可以像字符串一样进行切片、索引等操作。与 bytes 类型不同的是，bytearray 中的元素可以修改。
   *bytearray()*函数定义可以修改的二进制字符串。以下是一个示例：

a = bytearray(b"hello")
print(a)  # 输出结果为 bytearray(b'hello')a[0] = 104
print(a)  # 输出结果为 bytearray(b'hello')

# 创建一个 bytearray 对象
b = bytearray(b'hello')# 修改 bytearray 中的元素
b[0] = ord('H')# 输出修改后的结果
print(b)  # b'Hello'

8. callable()
   Python 中的函数是可调用对象。callable() 函数用于判断一个对象是否是可调用的。如果是可调用的，则返回 True，否则返回 False。

*callable()*函数判断一个对象是否可调用，函数是可以调用的。以下是一个示例：

a = 1
b = callable(a)
print(b)  # 输出结果为 Falsedef func():passc = callable(func)
print(c)  # 输出结果为 True

# 判断函数是否可调用
def foo():passprint(callable(foo))  # True# 判断类是否可调用
class Bar:passprint(callable(Bar))  # False# 判断实例是否可调用
bar = Bar()
print(callable(bar))  # False

9. chr()、ord()

*chr()*函数输入数字，返回相应字符；ord()函数输入字符，返回对应数字代号。以下是一个示例：

# 将 ASCII 码转换为字符
print(chr(65))  # A# 将字符转换为 ASCII 码
print(ord('A'))  # 65

a = 97
b = chr(a)
print(b)  # 输出结果为 'a'c = 'a'
d = ord(c)
print(d)  # 输出结果为 97

10. hex()

*hex()*函数将10进制数字转换为16进制。以下是一个示例：

a = 10
b = hex(a)
print(b)  # 输出结果为 '0xa'

# 将十进制整数转换为十六进制字符串
print(hex(255))  # 0xff

11. compile()

compile() 函数用于将一个字符串编译为 Python 代码对象，可以通过 exec() 函数或 eval() 函数执行这些代码。以下是一个示例：

a = "print('hello')"
b = compile(a, "", "exec")
exec(b)  # 输出结果为 hello

# 将字符串编译为 Python 代码对象
code = compile('print("hello world")', '<string>', 'exec')# 执行 Python 代码
exec(code)  # hello world

12. dict()
    dict() 函数用于创建一个字典对象。

示例：

# 创建一个字典
d = dict(a=1, b=2, c=3)# 访问字典的元素
print(d['a'])  # 1

*dict()*函数生成一个字典。以下是一个示例：

a = dict(a=1, b=2)
print(a)  # 输出结果为 {'a': 1, 'b': 2}

13. dir()
    dir() 函数用于获取对象的所有属性和方法。

示例：

# 定义一个类
class Person:def __init__(self, name):self.name = namedef say_hello(self):print(f'Hello, {self.name}!')# 创建一个对象
p = Person('Alice')# 查看对象的属性和方法
print(dir(p))

*dir()*函数用于查看一个对象有哪些方法。以下是一个示例：

a = "hello"
b = dir(a)
print(b)  # 输出结果为 ['capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', '

14. divmod() 函数
    数学计算，计算商和余数。
    divmod() 函数用于计算两个数的商和余数。

示例：

# 计算两个数的商和余数
x, y = divmod(10, 3)
print(x, y)  # 3 1

>>> divmod(10, 3)
(3, 1)

15. enumerate() 函数
    enumerate() 函数用于给一个可遍历的对象添加一个索引，返回一个枚举对象。

示例：

# 给列表添加索引
lst = ['a', 'b', 'c']
for i, x in enumerate(lst):print(i, x)

>>> fruits = ['apple', 'banana', 'orange']
>>> for i, fruit in enumerate(fruits):
...     print(i, fruit)
... 
0 apple
1 banana
2 orange

16. eval() 函数
    eval() 函数用于执行一个字符串表达式，并返回结果。
    进行简单计算，将字符串转换为可执行代码，如将字典字符串"转换为真的字典

>>> dict_str = "{'name': 'Tom', 'age': 18}"
>>> dict_obj = eval(dict_str)
>>> print(dict_obj)
{'name': 'Tom', 'age': 18}

# 执行一个字符串表达式
x = eval('1 + 2 + 3')
print(x)  # 6

17.delattr()
delattr() 函数用于删除对象的属性。

示例：

# 定义一个类
class Person:def __init__(self, name):self.name = name# 创建一个对象
p = Person('Alice')# 删除对象的属性
delattr(p, 'name')# 访问对象的属性
print(p.name)  # AttributeError: 'Person' object has no attribute 'name'

18. exec() 函数
    exec() 函数用于执行动态生成的可执行代码字符串，可以在运行时动态生成代码并立即执行。

>>> code_str = "print('Hello, world!')"
>>> exec(code_str)
Hello, world!

19. lambda 表达式
    lambda 关键字用于创建匿名函数，可以快速定义一个简单的函数，一般用于函数式编程中。

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

20. filter() 函数
    filter() 函数用于过滤序列，返回一个迭代器，其中包含满足条件的元素。

# 过滤出列表中的偶数
lst = [1, 2, 3, 4, 5, 6]
result = filter(lambda x: x % 2 == 0, lst)
print(list(result))  # 输出 [2, 4, 6]

上面的代码中，filter() 函数使用了一个 lambda 表达式作为过滤条件，过滤出了列表中的偶数，并将结果转换为列表输出。

20. reduce() 函数
    reduce() 函数用于对列表等序列中的元素进行归约操作，返回一个单一的结果。

>>> from functools import reduce
>>> nums = [1, 2, 3, 4]
>>> product = reduce(lambda x, y: x*y, nums)
>>> print(product)
24

# 对列表中的数值进行累加操作
lst = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, lst)
print(result)  # 输出 15

在上面的代码中，reduce() 函数使用了一个 lambda 表达式对列表中的数值进行累加操作，并返回了累加后的结果。

需要注意的是，reduce() 函数在 Python 3 中被移动到了 functools 模块中，需要先导入该模块才能使用。代码示例如下：

from functools import reduce# 对列表中的数值进行累加操作
lst = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, lst)
print(result)  # 输出 15

21. format() 函数
    format() 函数用于格式化输出字符串，可以使用占位符 {} 传递变量内容。

>>> name = 'Tom'
>>> age = 18
>>> print('My name is {}, and I am {} years old.'.format(name, age))
My name is Tom, and I am 18 years old.

22. frozenset() 函数
    frozenset() 函数用于定义一个不可变集合。

>>> my_set = set([1, 2, 3])
>>> my_frozenset = frozenset(my_set)
>>> print(my_frozenset)
frozenset({1, 2, 3})

23. globals() 函数
    globals() 函数用于获取当前文件中所有变量对象的键值对，返回一个字典。

>>> my_var = 'Hello, world!'
>>> print(globals())
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 'Hello, world!', 'add': <function <lambda> at 0x7fe2ee3b48b0>, 'my_set': {1, 2, 3}, 'my_frozenset': frozenset({1, 2, 3})}

24. help() 函数
    help() 函数用于查看函数或模块的帮助文档。

>>> help(list)
Help on class list in module builtins:class list(object)|  list(iterable=(), /)|  |  Built-in mutable sequence.|  |  If no argument is given, the constructor creates a new empty list.|  The argument must be an iterable if specified.|  |  Methods defined here:|  |  __add__(self, value, /)|      Return self+value.（省略部分输出）

25. id() 函数
    id() 函数用于获取对象在内存中的地址。

>>> my_var = 'Hello, world!'
>>> print(id(my_var))
140349155239120

26. iter() 函数
    iter() 函数用于将可迭代对象转换为迭代器。

>>> nums = [1, 2, 3, 4]
>>> num_iter = iter(nums)
>>> print(next(num_iter))
1
>>> print(next(num_iter))
2

27. isinstance() 函数
    isinstance() 函数用于判断一个对象是否是指定类或其子类的实例。

>>> my_list = [1, 2, 3]
>>> print(isinstance(my_list, list))
True
>>> print(isinstance(my_list, set))
False

28 len() 函数
len() 函数用于计算字符串、列表、元组等序列的长度。

>>> my_list = [1, 2, 3]
>>> print(len(my_list))
3

29. locals() 函数
    locals() 函数用于获取当前作用域中所有变量对象的键值对，返回一个字典。

>>> def my_func():
...     name = 'Tom'
...     age = 18
...     print(locals())
... 
>>> my_func()
{'name': 'Tom', 'age': 18}

30. map() 函数
    map() 函数用于对列表等序列中的每个元素进行操作，并返回一个新的序列。

>>> nums = [1, 2, 3, 4]
>>> sq_nums = list(map(lambda x: x**2, nums))
>>> print(sq_nums)
[1, 4, 9, 16]

>>> nums = [1, 2, 3, 4]
>>> sq_nums = list(map(lambda x: x**

31. map(function, iterable)：将可迭代对象iterable的每个元素都传入function中进行处理，并返回处理后的结果。示例：

# 将列表中的数字都乘以2
lst = [1, 2, 3, 4]
new_lst = list(map(lambda x: x * 2, lst))
print(new_lst)  # [2, 4, 6, 8]

32. max(iterable)：返回可迭代对象iterable中的最大值。示例：

# 找出列表中的最大值
lst = [1, 2, 3, 4]
print(max(lst))  # 4

33. min(iterable)：返回可迭代对象iterable中的最小值。示例：

# 找出列表中的最小值
lst = [1, 2, 3, 4]
print(min(lst))  # 1

34. next(iterator)：返回迭代器iterator中的下一个元素。示例：

# 迭代器示例
lst = [1, 2, 3, 4]
it = iter(lst)# 依次输出列表中的元素
print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
print(next(it))  # 4

35. object：是所有类的基类。示例：

# 创建一个空对象
obj = object()
print(obj)  # <object object at 0x7fcb1b5d5e00>

36. oct(x)：将整数x转换为8进制字符串。示例：

# 将10转换为8进制
num = 10
oct_num = oct(num)
print(oct_num)  # 0o12

37. open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：打开文件file并返回文件对象。示例：

# 打开并读取文件内容
with open('example.txt', 'r') as f:content = f.read()print(content)

38. ord(c)：返回字符c对应的 ASCII 码值。示例：

# 返回字符'A'的ASCII码值
print(ord('A'))  # 65

39. pow(x, y)：返回x的y次幂的结果。示例：

# 求2的8次幂
print(pow(2, 8))  # 256

40. print()：打印输出。示例：

# 输出一行字符
print('Hello, world!')

41. reversed(seq)：返回序列seq的反转版本。示例：

# 反转列表
lst = [1, 2, 3, 4]
new_lst = list(reversed(lst))
print(new_lst)  # [4, 3, 2, 1]

42. round(number[, ndigits])：将number四舍五入到ndigits位小数。示例：

# 将3.1415926保留2位小数
num = 3.1415926
new_num = round(num, 2)
print(new_num)  # 3.14

43. set(iterable)：将可迭代对象iterable转换为集合。示例：

# 将列表转换为集合
lst = [1, 2, 3, 4]
new_set = set(lst)
print(new_set)  # {1, 2, 3, 4}

44. setattr(obj, name, value)：给对象obj的属性name设置值value。示例：

# 给对象添加属性
class Person:passp = Person()
setattr(p, 'name', 'John')
setattr(p, 'age', 20)
print(p.name)  # John
print(p.age)  # 20

45. staticmethod：静态方法是指在类中定义的没有使用类变量和实例变量的方法，可以通过类名直接调用，而无需创建类的实例。静态方法使用@staticmethod装饰器来定义。示例代码如下：

class MyClass:@staticmethoddef my_static_method(a, b):return a + b# 调用静态方法
result = MyClass.my_static_method(1, 2)
print(result) # 输出：3

46. str()：将一个对象转换成字符串类型，如果是数字、列表、元组等可迭代对象，则会将其转换成字符串格式。示例代码如下：

num = 123
str_num = str(num)
print(str_num) # 输出：'123'list_num = [1, 2, 3]
str_list_num = str(list_num)
print(str_list_num) # 输出：'[1, 2, 3]'

47. sum()：用于求和，可以求多个数字的和，也可以求列表、元组、字典等可迭代对象中数字的和。示例代码如下：

# 求多个数字的和
result = sum(1, 2, 3)
print(result) # 输出：6# 求列表中数字的和
nums = [1, 2, 3]
result = sum(nums)
print(result) # 输出：6

48. super()：用于调用父类的方法，通常用于子类重写父类方法后调用父类方法。示例代码如下：

class ParentClass:def __init__(self):self.parent_var = 1class ChildClass(ParentClass):def __init__(self):super().__init__()self.child_var = 2child_obj = ChildClass()
print(child_obj.parent_var) # 输出：1
print(child_obj.child_var) # 输出：2

49. type()：用于查看数据类型，也可以用于定义新的数据类型。示例代码如下：

# 查看数据类型
num = 123
print(type(num)) # 输出：<class 'int'># 定义新的数据类型
MyClass = type('MyClass', (object,), {'x': 1, 'y': 2})
my_obj = MyClass()
print(my_obj.x) # 输出：1
print(my_obj.y) # 输出：2

50. zip()：用于将两个可迭代对象按照索引一一对应，组成一个新的可迭代对象，其中每个元素为一个元组。示例代码如下：

nums = [1, 2, 3]
words = ['one', 'two', 'three']
zipped = zip(nums, words)
print(list(zipped)) # 输出：[(1, 'one'), (2, 'two'), (3, 'three')]

51. __import__('XXX')：用于动态导入模块，参数为字符串格式的模块名。示例代码如下：

# 导入 math 模块
import math
print(math.sqrt(4)) # 输出：2.0# 动态导入 math 模块
math_module = __import__('math')
print(math_module.sqrt(4)) # 输出：2.0