len()

len(iterable)：返回给定序列（可迭代对象）的长度或元素个数。

list1 = [1, 2, 3, 4, 5]
print("列表长度:", len(list1))

issubclass()

issubclass(class, classinfo)：检查一个类是否是另一个类的子类，返回 True 或 False。

class Base:
    pass

class Derived(Base):
    pass

print(issubclass(Derived, Base))  # 输出: True

abs()

返回一个数的绝对值。

print(abs(-5))  # 输出: 5

round()

round(number, ndigits)：返回浮点数 number 的四舍五入值，可以指定保留的小数位数 ndigits。

print(round(3.14159, 2))  # 输出: 3.14

pow()

pow(x, y, z=None)：计算 x 的 y 次方，如果提供 z 参数，则计算结果取模。(x**y) % z

print(pow(2, 3))  # 输出: 8
print(pow(2, 3, 3))  # 输出: 2

range()

range([start,] stop[, step])：成一个从 start 到 stop 的整数序列，间隔为 step。

for i in range(0, 5):
    print(i)  # 输出: 0, 1, 2, 3, 4

divmod() 

divmod(a, b)：以元组 (a // b, a % b) 的形式返回两个数的商和余数。

print(divmod(8, 3))  # 输出: (2, 2)

sum() 

sum(iterable[, start]): 计算 iterable 的所有项的总和，如果提供了 start，则从这个值开始累加。

print(sum([1, 2, 3]))  # 输出: 6
print(sum([1, 2, 3], 10))  # 输出: 16

sorted()

功能：sorted() 函数用于对可迭代对象进行排序，并返回一个新的已排序列表。
语法：sorted(iterable, key=None, reverse=False)
        iterable：待排序的可迭代对象。
        key：可选参数，用于指定排序的规则函数。
        reverse：可选参数，为 True 时按降序排列，默认为 False。

# 基本排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

# 按字符串长度排序
words = ["banana", "apple", "cherry"]
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出: ['apple', 'banana', 'cherry']

# 逆序排序
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

# 使用 key 参数按绝对值排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
sorted_numbers_abs = sorted(numbers, key=abs)
print("按绝对值排序:", sorted_numbers_abs)

reversed() 

功能：reversed() 函数用于反转序列中的元素，返回一个逆序的迭代器。
语法：reversed(sequence)

# 反转列表
numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print(reversed_numbers)  # 输出: [5, 4, 3, 2, 1]

# 反转字符串
hello = "hello"
reversed_hello = ''.join(reversed(hello))
print(reversed_hello)  # 输出: 'olleh'

enumerate()

功能：enumerate() 函数用于将可迭代对象组合为一个索引序列，同时列出数据和数据下标。
语法：enumerate(iterable, start=0)
        iterable：待枚举的可迭代对象。
        start：可选参数，指定下标起始值，默认为 0。

# 枚举列表
names = ["Alice", "Bob", "Charlie"]
for index, name in enumerate(names):
    print(f"{index}: {name}")
# 输出:
# 0: Alice
# 1: Bob
# 2: Charlie

# 从指定索引开始枚举
for index, name in enumerate(names, start=1):
    print(f"{index}: {name}")
# 输出:
# 1: Alice
# 2: Bob
# 3: Charlie

id()

id(object)：返回对象的唯一标识符，即对象在内存中的地址。每个对象在内存中都有一个唯一的标识符。

# 使用 id() 获取对象的内存地址
num = 10
print("对象 num 的内存地址:", id(num))   # 输出: 对象 num 的内存地址: 140732046623816

hash()

hash(object)：返回对象的哈希值，如果对象是可哈希的（即不可变的），则返回其哈希值。哈希值是一种用于快速比较对象的值是否相同的机制。

num = 10
hash_num = hash(num)
print("对象 num 的哈希值:", hash_num)   # 输出: 对象 num 的哈希值: 10

input()

input(prompt)：从标准输入（通常是键盘）获取用户输入，并返回用户输入的字符串。

name = input("请输入你的名字：")
print("你好，" + name + "!")

type()

type() 函数用于返回对象的类型。

其语法如下：

type(object)   
  object：要获取其类型的对象
  
type(name, bases, dict, **kwds)

type() 函数返回对象的类型。如果只传入一个参数，则返回该对象的类型；如果传入三个参数，则返回一个新的类型对象。

# 获取对象的类型
num = 10
print(type(num))  # <class 'int'>，num 是整数类型

# 获取函数的类型
def greet():
    print("Hello!")

print(type(greet))  # <class 'function'>，greet 是函数类型

# 获取类的类型
class Person:
    pass

print(type(Person))  # <class 'type'>，Person 是类类型

# 获取实例的类型
class Dog:
    pass

my_dog = Dog()
print(type(my_dog))  # <class '__main__.Dog'>，my_dog 是 Dog 类的实例

# 获取类型的类型
print(type(int))  # <class 'type'>，int 是类型对象
print(type(str))  # <class 'type'>，str 是类型对象

# 使用三个参数创建新的类型对象
NewClass = type('NewClass', (object,), {'attr': 10})
print(type(NewClass))  # <class 'type'>，NewClass 是新的类型对象


# 返回字符串对象的类型
string = "hello"
type_str = type(string)
print(type_str)  # 输出：<class 'str'>

# 返回列表对象的类型
list1 = [1, 2, 3]
type_list = type(list1)
print(type_list)  # 输出：<class 'list'>

# 隐式转换
print(type(1+True))     # 输出：<class 'int'>
print(type(1+True+2.0)) # 输出：<class 'float'>

# 获取自定义类的实例的类型
class MyClass:
    pass

obj = MyClass()
print(type(obj))  # 输出：<class '__main__.MyClass'>

isinstance()

isinstance() 是 Python 内置函数，用于检查一个对象是否是指定类或类型中的一个。

其语法如下：
isinstance(object, classinfo)

object：要检查的对象
classinfo：要检查的类、类型或元组

如果 object 是 classinfo 类或类型的实例，或者是其子类的实例，则返回 True；否则返回 False。

# 检查对象是否是指定类的实例
num = 10
print(isinstance(num, int))  # True，num 是整数类型
print(isinstance(num, str))  # False，num 不是字符串类型

# 检查对象是否是多个类或类型中的一个
num = 10
print(isinstance(num, (int, float)))  # True，num 是整数或浮点数类型中的一个
print(isinstance(num, (str, float)))  # False，num 不是字符串或浮点数类型中的一个

# 结合继承关系进行检查
class Animal:
    pass

class Dog(Animal):
    pass

my_dog = Dog()
print(isinstance(my_dog, Animal))  # True，my_dog 是 Animal 类的实例
print(isinstance(my_dog, Dog))     # True，my_dog 是 Dog 类的实例

callable()

callable() 是 Python 内置函数，用于检查对象是否可调用（callable）。可调用的对象包括函数、方法、类和某些类的实例等。

其语法如下：

callable(object)

object：要检查的对象

如果 object 可以调用，则返回 True；否则返回 False。

# 检查函数是否可调用
def greet():
    print("Hello!")

print(callable(greet))  # True，函数 greet 可调用

# 检查方法是否可调用
class Person:
    def greet(self):
        print("Hello!")

p = Person()
print(callable(p.greet))  # True，方法 greet 可调用

# 检查类是否可调用
class Dog:
    pass

print(callable(Dog))  # True，类 Dog 可调用，创建类实例

# 检查实例是否可调用
class Calculator:
    def calculate(self, x, y):
        return x + y

c = Calculator()
print(callable(c.calculate))  # True，实例 c 的方法 calculate 可调用

# 检查不可调用的对象
num = 10
print(callable(num))  # False，整数对象 num 不可调用

iter()

iter() 是 Python 内置函数，用于获取可迭代对象的迭代器。

其语法如下：
iter(object, sentinel)

object：要创建迭代器的可迭代对象
sentinel：可选参数，指定在迭代器到达特定值时停止迭代

iter() 函数返回一个迭代器对象，该对象可以用于遍历可迭代对象的元素。

# 获取列表的迭代器
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)

print(next(my_iter))  # 1，获取迭代器的下一个元素
print(next(my_iter))  # 2
print(next(my_iter))  # 3

# 获取字符串的迭代器
my_string = "Hello"
my_iter = iter(my_string)

print(next(my_iter))  # 'H'，获取迭代器的下一个字符
print(next(my_iter))  # 'e'
print(next(my_iter))  # 'l'

# 使用 sentinel 参数创建迭代器
def my_generator():
    yield 1
    yield 2
    yield 3

gen_iter = iter(my_generator(), 2)  # 当迭代器产生值为2时停止迭代

for value in gen_iter:
    print(value)  # 1，迭代器产生值为2时停止

# 迭代字典的键
my_dict = {'a': 1, 'b': 2, 'c': 3}
key_iter = iter(my_dict)

print(next(key_iter))  # 'a'，获取字典键的迭代器
print(next(key_iter))  # 'b'
print(next(key_iter))  # 'c'

hasattr()

hasattr() 是 Python 内置函数，用于检查对象是否具有指定属性。

其语法如下：
hasattr(object, name)

object：要检查的对象
name：要检查的属性名称

如果对象具有指定属性，则返回 True；否则返回 False。

# 检查对象是否具有属性
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(hasattr(person, "name"))  # True，person 对象具有属性 "name"
print(hasattr(person, "gender"))  # False，person 对象不具有属性 "gender"

# 检查模块是否具有属性
import math
print(hasattr(math, "pi"))  # True，math 模块具有属性 "pi"
print(hasattr(math, "sin"))  # True，math 模块具有属性 "sin"

# 检查内置类型是否具有属性
print(hasattr(int, "bit_length"))  # True，整数类型具有属性 "bit_length"
print(hasattr(float, "real"))  # True，浮点数类型具有属性 "real"

# 检查实例方法是否具有属性
class Car:
    def drive(self):
        print("Driving the car")

car = Car()
print(hasattr(car.drive, "__call__"))  # True，实例方法 "drive" 可调用

# 检查字符串是否具有属性
my_string = "Hello"
print(hasattr(my_string, "upper"))  # True，字符串具有属性 "upper"
print(hasattr(my_string, "split"))  # True，字符串具有属性 "split"

getattr()

getattr() 是 Python 内置函数，用于获取对象的属性值。

其语法如下：
getattr(object, name, default)

object：要获取属性的对象
name：要获取的属性名称
default：可选参数，如果属性不存在，则返回默认值

如果对象具有指定属性，则返回该属性的值；如果属性不存在且未提供默认值，则引发 AttributeError 异常。

# 获取对象的属性值
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(getattr(person, "name"))  # 'Alice'，获取对象 person 的属性 "name" 的值
print(getattr(person, "age"))   # 30，获取对象 person 的属性 "age" 的值

# 获取模块的属性值
import math
print(getattr(math, "pi"))  # 3.141592653589793，获取 math 模块的属性 "pi" 的值
print(getattr(math, "sin"))  # <built-in function sin>，获取 math 模块的属性 "sin"，为函数对象

# 提供默认值
class Person:
    pass

person = Person()
print(getattr(person, "name", "Unknown"))  # 'Unknown'，属性 "name" 不存在，返回默认值

# 处理不存在的属性
class Person:
    def __init__(self, name):
        self.name = name

person = Person("Alice")
print(getattr(person, "age", None))  # None，属性 "age" 不存在，返回 None

# 获取内置类型的属性值
print(getattr(str, "upper"))  # <method 'upper' of 'str' objects>，获取字符串类型的属性 "upper"
print(getattr(int, "bit_length"))  # <method 'bit_length' of 'int' objects>，获取整数类型的属性 "bit_length"

issubclass()

issubclass() 是 Python 内置函数，用于检查一个类是否是另一个类的子类。

其语法如下：
issubclass(class, classinfo)

class：要检查的类
classinfo：要检查的类或类的元组

如果 class 是 classinfo 类或其子类，则返回 True；否则返回 False。

# 检查类是否是另一个类的子类
class Animal:
    pass

class Dog(Animal):
    pass

print(issubclass(Dog, Animal))  # True，Dog 是 Animal 的子类

# 检查内置类型是否是指定类型的子类
print(issubclass(bool, int))  # True，布尔类型是整数类型的子类
print(issubclass(float, int))  # False，浮点数类型不是整数类型的子类

# 检查类是否是元组中任一类的子类
class Shape:
    pass

class Circle(Shape):
    pass

class Square(Shape):
    pass

print(issubclass(Circle, (Shape, int)))  # True，Circle 是 Shape 或 int 的子类
print(issubclass(Square, (Shape, int)))  # False，Square 不是 Shape 或 int 的子类

# 检查类是否是自身的子类
class Parent:
    pass

class Child(Parent):
    pass

print(issubclass(Child, Child))  # True，Child 是自身的子类

# 检查内置类型是否是基本类型的子类
print(issubclass(str, object))  # True，字符串类型是基本类型 object 的子类
print(issubclass(list, object))  # True，列表类型是基本类型 object 的子类

map()

map() 函数是Python内置的高阶函数，用于对可迭代对象中的每个元素应用一个指定的函数，然后返回一个包含所有函数返回值的新的可迭代对象。

map()函数的语法如下：
map(function, iterable, *iterables)
  function：要对每个元素应用的函数。
  iterable：一个或多个可迭代对象，如列表、元组、集合等。

zip()

zip() 函数用于将多个可迭代对象中对应位置的元素打包成一个元组，然后返回一个包含这些元组的迭代器。
默认情况下，zip() 在最短的迭代完成后停止。较长可迭代对象中的剩余项将被忽略，结果会裁切至最短可迭代对象的长度。
zip() 与 * 运算符相结合可以用来拆解一个列表。

zip()函数的语法如下：
zip(iterable1, iterable2, ...,strict=False)
  iterable1, iterable2, ...：多个可迭代对象，可以是列表、元组、集合等。
  strict：如果设置strict=True，则会在长度不匹配时引发ValueError异常。

# 将两个列表中对应位置的元素打包成元组
list1 = [1, 2, 3]
list2 = ['d', 'e', 'f', 'g']
zipped = list(zip(list1, list2))
print(zipped)      # 输出：[(1, 'd'), (2, 'e'), (3, 'f')]

# 使用zip()函数同时遍历多个列表
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for num, letter in zip(list1, list2):
    print(num, letter)
# 输出：
# 1 a
# 2 b
# 3 c

# 将字典的键和值分别打包成元组
my_dict = {'a': 1, 'b': 2, 'c': 3}
zipped = list(zip(my_dict.keys(), my_dict.values()))
print(zipped)
# 输出：[('a', 1), ('b', 2), ('c', 3)]

# 使用zip()函数合并多个列表成为一个字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
print(my_dict)
# 输出：{'a': 1, 'b': 2, 'c': 3}

# 解压缩元组列表
data = [(1, 'a'), (2, 'b'), (3, 'c')]
numbers, letters = zip(*data)
print(numbers)
print(letters)
# 输出：
# (1, 2, 3)
# ('a', 'b', 'c')

# 解压缩字典的键和值
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys, values = zip(*my_dict.items())
print(keys)
print(values)
# 输出：
# ('a', 'b', 'c')
# (1, 2, 3)

max()

用于从一组参数中返回最大值。这些参数可以是数字、字符串或者可迭代对象（如列表、元组等）。

语法: max(arg1, arg2, *args, key=None, default=None)
参数： 
    arg1, arg2, *args: 用于比较大小的参数，可以是数字、字符串或者可迭代对象。
    key (可选): 用于指定一个函数，该函数将应用于每个参数以进行比较。
    default (可选): 如果参数为空，则返回该默认值，否则引发 ValueError。
返回值：返回参数中的最大值。

# 作为独立函数使用
max(3, 6, 1, 8, 4)  # 输出: 8

# 通过指定 key 函数来进行比较
words = ['apple', 'banana', 'cherry', 'dragonfruit']
max_word = max(words, key=len)  # 输出: 'dragonfruit'

chr()

描述：chr(i) 方法将一个 Unicode 编码点转换为对应的字符。
用法：chr(i)  i 必须是一个整数，表示 Unicode 编码点。
返回值：返回表示该编码点的字符。

print(chr(65))      # 输出: 'A'
print(chr(8364))    # 输出: '€'
print(chr(128516))  # 输出: '

标签：输出,内置,函数,迭代,python,my,iter,print,True	

From： https://www.cnblogs.com/wangguishe/p/18084841