python3内置全局函数

目录

abs()函数--返回数字的绝对值

divomd()函数--返回一个包含商余数的元组

 input()函数--接收一个标准输入数据，返回为string类型。

dict()函数--用于创建一个字典

help()函数--用于查看函数或者模块用途的详细说明

min()函数--返回给定参数的最小值，参数可以为序列

setattr()函数--用于设置属性值，该属性不一定是存在的

all()函数--用于判断给定的可迭代参数iterable中的所有元素是否都为True，返回True否则返回False

dir()函数

hex()函数--将一个指定数字转换为16进制数。

next()函数--返回迭代器的下一个项目。

slice()函数-- 实现切片对象，主要用在切片操作函数里的参数传递。

any()函数--用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True

id()函数--返回对象的唯一标识符，标识符是一个整数

sorted()函数--随所有可迭代的对象进行排序操作

ascii()函数--返回一个表示对象的字符串

enumerate()函数--将一个可便利的数据对象（如列表、元组或者字符串）组合为一个索引序列，同时列出数据和下表

oct()函数--将一个整数转换成八进制字符串

bin()函数--返回一个整数int类型的二进制

eval()函数--用来执行一个字符串表达式，并返回表达式的值

int()函数--用于将一个字符串或数字转换为整型

open()函数--用于打开一个文件，并返回文件对象

str()函数--将对象转换为适于人阅读的形式（字符串）

bool()函数--用于将给定参数类型转换为布尔类型，如果没有参数，返回False

exec()函数--执行储存在字符串或文件中的 Python 语句

isinstantce()函数--来判断一个对象是否是一个已知的类型，类似 type()。

ord()函数--以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值

sum()函数--对序列进行求和计算

bytearray()函数--返回一个新字节数组。

filter()函数--用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。

issubclass()函数--用于判断参数class是否是类型参数classinfo的子类型

pow()函数--返回​编辑(x的y次方)的值

super()函数--调用父类(超类)的方法。

bytes()函数--返回一个新的bytes对象。

float()函数--用于将整数和字符串转换成浮点型

iter()函数--用来生成迭代器。

 print()函数--用于打印输出，最常见的一个函数。

tuple()函数--将可迭代系列(如列表)转换为元组

callable()函数--检查一个函数是否被调用。

 format()格式化函数

len()方法--返回对象(字符，列表，元组等) 长度或项目个数

property()函数--返回属性值

type()函数--返回参数的对象的类型

chr()函数--用一个整数作为参数，返回一个对应的字符

frozenset()函数--返回一个冻结的集合，冻结后集合不能在添加或删除任何元素。

List list()方法--用于将元组或字符串转换为列表

range()函数--函数返回的是一个可迭代对象

var()函数--返回对象object的属性和属性值的字典对象

classmethod 修饰符

getattr()函数--用于返回一个对象属性值

locals() 函数--以字典类型返回当前位置的全部局部变量

 repr() 函数-- 将对象转化为供解释器读取的形式

zip()函数

compile()函数--将一个字符串编译为字节代码。

globals()函数--会以字典类型返回当前位置的全部全局变量

map()函数--会根据提供的函数对指定序列做映射。

reversed()函数--返回一个反转的迭代器

__import__()函数-- 用于动态加载类函数。

complex()函数--用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数

hasattr()函数-- 用于判断对象是否包含对应的属性。

max()函数--返回给定参数的最大值，参数可以是序列

round()函数--返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端

reload()函数--用于重新载入之前的模块

delattr()函数--用于删除属性

hash()函数--用于获取取一个(字符串或者数值等)的哈希值

memoryview()函数--返回给定参数的内存查看对象

set()函数--创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

---

abs()函数--返回数字的绝对值

语法：abs(x)                # x--数值

返回值：函数返回x(数字)的绝对值

示例：

print("abs(-45):", abs(-45))
print("abs(45):", abs(45))
 

运行结果：

divomd()函数--返回一个包含商余数的元组

语法：divomd(a, b)       # a, b 都为数字（非复数）

• 如果参数a与b都为整数，函数返回的结果相当于（a // b, a % b）。
• 如果其中一个参数为浮点数时，函数返回的结果相当于(q, a%b),q通常是math.floor(a/b),但也有可能是1
• 如果a%b的求余结果部位0，则余数的正负符号跟参数b是一样的。

实例：

print("divmod(7, 2):", divmod(7, 2))
print("divmod(8, 2)", divmod(8, 2))

运行结果：

 input()函数--接收一个标准输入数据，返回为string类型。

语法：input([prompt])                #prompt:提示信息

实例：

name = input("请输入一个名字：")
print("我接受到了你的名字：", name, type(name))

运行结果：

dict()函数--用于创建一个字典

语法：

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

参数：
        **kwarge -- 关键字
        mapping--元素容器，映射类型（Mapping Type） 是一种关联式的容器类型，它储存了
                        对象与对象之间的关系。
        iterable--可迭代的对象、

返回值：返回一个字典。

实例：

dict_test = dict(a='a', b='b', c='c')
print("dict_test:", dict_test, type(dict_test))
 
dict_test2 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
print("dict_test2:", dict_test2, type(dict_test2))
 
dict_test3 = dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
print("dict_test3:", dict_test3, type(dict_test3))

运行结果：

help()函数--用于查看函数或者模块用途的详细说明

语法：help([object])                # objecr：对象

返回值：返回对象的帮助信息

实例：

help(list)

运行结果：

min()函数--返回给定参数的最小值，参数可以为序列

语法：min(x, y, z, ......)                # x, y, z 都为数值表达式

返回值：给定参数的最小值

实例：

print("min(80, 100, 1000) : ", min(80, 100, 1000))
print("min(-20, 100, 400) : ", min(-20, 100, 400))
list1 = [2, 3, 1, -5, 10, -1]
print("min(list1):", min(list1))

运行结果：

setattr()函数--用于设置属性值，该属性不一定是存在的

语法：setattr(object, name, value)   

参数：

• object：对象
• name：字符串
• value：属性值       

返回值：无

实例：

class A(object):
    bar = 1
 
 
a = A()
print(getattr(a, 'bar'))
setattr(a, 'bar', 5)
print(a.bar)
 
print("="*10)
 
 
class B():
    name = "runoob"
 
 
b = B()
setattr(b, "age", 10)
print(b.age, b.name)

运行结果

all()函数--用于判断给定的可迭代参数iterable中的所有元素是否都为True，返回True否则返回False

注意：除元素0,空,None,False外都算是True

语法：all(iterable)                # iterable :元组或者列表

返回值：

        所有元素都为Ture则返回True，否则返回False

实例：

print(all(['a', 'b', 'c']))     # 列表list，元素都不为空或0
print(all([]))       # 空列表
print(all(()))       # 空元组
print(all((0, 1, 3, 5, 10)))    # 元组tuple，存在一个为空的元素
print(all(('a', 'g', '')))      # 元组tuple，存在一个为空的元素

运行结果：

dir()函数

描述：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

语法：dir([object])                # object:对象、变量、类型

返回值：返回模块的属性列表

实例：

print(dir())        # 获取当前模块的属性列表
 
print(dir([]))   # 查看列表的方法

运行结果：

hex()函数--将一个指定数字转换为16进制数。

语法：hex(x)                # x：一个整数

返回值：返回一个字符串，以0x开头

实例：

print("12的十六进制数为:", hex(12))
print("34的十六进制数为:", hex(34))
print("100的十六进制数为:", hex(100))

运行结果：

next()函数--返回迭代器的下一个项目。

        函数要和生成迭代器的iter()函数一起使用。

语法：next(iterable[, default])

参数：

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

返回值：返回下一个项目

实例：

# 获得Iterator对象
it = iter([1, 2, 3, 4, 5])
# 循环
while True:
    try:
        # 获取下一个值
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration 就退出
        break

运行结果：

slice()函数-- 实现切片对象，主要用在切片操作函数里的参数传递。

语法：

class slice(stop)
class slice(start, stop[, step])

参数：

• start--起始位置
• stop--结束位置
• step--间距

返回值：返回一个切片对象

实例：

myslice = slice(5)      # 设置截取5个元素的切片
print(myslice)
 
arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(arr[myslice])

运行结果：

any()函数--用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True

注意：元素除了是 0、空、FALSE 外都算 TRUE。

语法：any(iterable)                # iterable:元组或者列表

返回值：

        如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。

实例：

print(any(['a', 'b', 'c', 'd']))        # 列表list，元素都不为空或0
print(any(['a', 'b', '', 'd']))         # 列表list，存在一个为空的元素
print(any([0, '', False]))              # 列表list,元素全为0,'',false
print(any(('a', 'b', 'c', 'd')))        # 元组tuple，元素都不为空或0
print(any([]))                          # 空列表
print(any(()))                          # 空元组

运行结果：

id()函数--返回对象的唯一标识符，标识符是一个整数

语法：id([object])                # object：对象

返回值：返回对象的内存地址

实例：

a = 'runoob'
print(id(a))
 
b = 1
print(id(b))

运行结果：

sorted()函数--随所有可迭代的对象进行排序操作

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法：

sorted(iterable, key=None, reverse=False)

参数：

• iterable：可迭代对象
• key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取决于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值：返回重新排序的列表

实例：

print(sorted([5, 2, 3, 1, 4]))                     # 默认为升序
 
# sorted() 函数可以接收任何的 iterable。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))
 
# 利用key进行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
 
# 要进行反向排序，也通过传入第三个参数 reverse=True
example_list1 = [5, 0, 6, 1, 2, 7, 3, 4]
print(sorted(example_list1, reverse=True))

运行结果：

ascii()函数--返回一个表示对象的字符串

注意：对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符

语法：ascii(object)                # 对象

返回值：返回字符串

实例

print(ascii('你好'))
print(ascii('a'))
print(ascii(10))

运行结果：

enumerate()函数--将一个可便利的数据对象（如列表、元组或者字符串）组合为一个索引序列，同时列出数据和下表

           提示：一般用于for循环中

语法：enumerate(sequence, []start=0])

参数：

• sequence：一个序列、迭代器或者其他支持迭代对象。
• start：下标起始位置

返回值：

        返回enumerate(枚举)类型

实例：

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
 
# 普通的for循环
seq = ['one', 'two', 'three']
for index, item in enumerate(seq):
    print(index, item)
    index += 

运行结果：

oct()函数--将一个整数转换成八进制字符串

        提示：八进制以0o作为前缀表示。

语法：oct(x)                # x--整数

返回值：返回八进制字符串

实例：

print(oct(10))
print(oct(100))
print(oct(7))

运行结果：

bin()函数--返回一个整数int类型的二进制

语法：bin(x)                # x ：int类型数据

返回值：字符串

实例：

print(bin(10))
print(bin(8))
print(bin(66))

运行结果：

eval()函数--用来执行一个字符串表达式，并返回表达式的值

语法：

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

参数：

• expression -- 表达式。
• globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
• locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值：返回表达式计算的结果

实例：

print('3 * 5')
print(eval('3 * 5'))
 
a = eval('input("请输入一个数:")')
print(a)

运行结果：

int()函数--用于将一个字符串或数字转换为整型

语法：

class int(x, base=10)

参数：

• x -- 字符串或数字。
• base -- 进制数，默认十进制

实例：

print(int(0x78))
print(int(3.6))
print(int("67"))
print(int('10', 7))

运行结果：

open()函数--用于打开一个文件，并返回文件对象

提示：在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。

语法格式：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数：

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener:

mode参数：

实例：

创建测试文本文件test.txt，内容如下：

        1234567

f = open('test.txt')
s = f.read()
print(s)

运行结果：

str()函数--将对象转换为适于人阅读的形式（字符串）

语法： class str(object='')                # object ：对象

返回值：返回一个对象的string格式

实例：

s = "hello world"
print(str(s))
 
b = 18
print(b, type(b))
c = str(18)
print(c, type(c))

运行结果：

bool()函数--用于将给定参数类型转换为布尔类型，如果没有参数，返回False

提示：bool为int的子类

语法：class bool([x])                # x：要进行转换的参数

返回值：返回True或者False

实例：

print(bool())
print(bool(1))
print(bool(0))
print(issubclass(bool, int))    # bool 是 int 子类

运行结果：

exec()函数--执行储存在字符串或文件中的 Python 语句

提示：相比于 eval，exec可以执行更复杂的 Python 代码。

语法：exec(object[, globals[, locals]])        

参数：

• object：必选参数，表示需要被指定的 Python 代码。它必须是字符串或 code 对象。如果 object 是一个字符串，该字符串会先被解析为一组 Python 语句，然后再执行（除非发生语法错误）。如果 object 是一个 code 对象，那么它只是被简单的执行。
• globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
• locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与 globals 相同的值。

返回值：无

实例：

exec('print("12345")')
exec("""for i in range(5):\
            print ("iter time: %d" % i)\
""")

运行结果：

isinstantce()函数--来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。

• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法：isinstance(object, classinfo)        

参数：

• object -- 实例对象。
• classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

a = 2
print(isinstance(a, int))
print(isinstance(a, str))
print(isinstance(a, (str, int, list)))      # 是元组中的一个返回 True
 
print("="*8)
 
 
# type() 与 isinstance()区别：
class A:
    pass
 
 
class B(A):
    pass
 
 
print(isinstance(A(), A))
print(type(A()) == A)
print(isinstance(B(), A))
print(type(B()) == A)

运行环境：

ord()函数--以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值

提示：ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数

语法：ord(c)        # c：字符

返回值：返回值对应的十进制整数。

print(ord('a'))
print(ord('A'))
print(ord('你'))

运行结果：

sum()函数--对序列进行求和计算

语法：sum(iterable[, start])

参数：

• iterable -- 可迭代对象，如：列表、元组、集合。
• start -- 指定相加的参数，如果没有设置这个值，默认为0。

返回值：返回计算结果。

实例：

list1 = [2, 3, 4, 5, 6]
print(sum(list1))
 
print(sum((3, 2, 12), 5))

运行结果：

bytearray()函数--返回一个新字节数组。

注意：这个数组的元素是可变的，并且每一个元素的取值范围：0<=x<=256.

语法： class bytearray([source[, encoding[, errors]]])

参数：

• 如果 source 为整数，则返回一个长度为 source 的初始化数组；
• 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
• 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
• 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
• 如果没有输入任何参数，默认就是初始化数组为0个元素。

返回值：返回新字节数组

实例：

print(bytearray())
print(bytearray([1, 2, 3]))
print(bytearray('runoob', 'utf-8'))

运行结果

filter()函数--用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。

提示：如果要转换为列表可以使用list()来转换。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法：filter(function, iterable)

参数：

• function -- 判断函数。
• iterable -- 可迭代对象

返回值：返回一个迭代器对象

实例：

import math
 
 
# 过滤出列表中的所有技术
def is_odd(n):
    return n % 2 == 1
 
 
tmlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8])
newlist = list(tmlist)
print(newlist)
 
 
# 过滤出1~100中平方根是整数的数
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
 
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)

运行结果

issubclass()函数--用于判断参数class是否是类型参数classinfo的子类型

语法：issubclass(class, classinfo)

参数：

• class -- 类。
• classinfo -- 类。

返回值：如果class是classinfo的子类返回True，否则返回False

实例：

class A:
    pass
 
 
class B(A):
    pass
 
 
print(issubclass(B, A))

运行结果：

pow()函数--返回(x的y次方)的值

语法：

• math模块的pow()方法：     math.pow( x, y )                # 注意：要先导入math模块
• 内置的pow()方法                 pow(x, y[, z])         #如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

参数：

• x -- 数值表达式。
• y -- 数值表达式。
• z -- 数值表达式。

返回值：返回的值

实例：

import math     # 导入math模块
print("math.pow(100,2):", math.pow(100, 2))
 
# 使用内置，查看输出结果区别
print("pow(100, 2) : ", pow(100, 2))
print("math.pow(100, -2) : ", math.pow(100, -2))
print("math.pow(2, 4) : ", math.pow(2, 4))
print("math.pow(3, 0) : ", math.pow(3, 0))

运行结果：

super()函数--调用父类(超类)的方法。

提示：super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

语法：super(type[, object-or-type])

参数：

• type -- 类。
• object-or-type -- 类，一般是 self

实例：

class A:
    def add(self, x):
        y = x + 1
        print(y)
 
 
class B(A):
    def add(self, x):
        super().add(x)
 
 
b = B()
b.add(2)

运行结果：

bytes()函数--返回一个新的bytes对象。

提示：该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

语法：class bytes([source[, encoding[, errors]]])

参数：

• 如果 source 为整数，则返回一个长度为 source 的初始化数组；
• 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
• 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
• 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
• 如果没有输入任何参数，默认就是初始化数组为0个元素。

返回值：返回一个新的bytes对象

实例：

a = bytes([1, 2, 3, 4])
print(a, type(a))
 
a = bytes('hello', 'ascii')
print(a, type(a))

运行结果：

float()函数--用于将整数和字符串转换成浮点型

语法：class float([x])                        # x：整数和字符串

返回值：返回浮点数

实例：

print(float(1), type(float(1)))
print(float("10"), type(float("10")))

运行结果：

iter()函数--用来生成迭代器。

语法：iter(object[, sentinel])

参数：

• object -- 支持迭代的集合对象。
• sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

返回值：迭代器

实例：

lst = [1, 2, 3]
for i in iter(lst):
    print(i)
 

运行结果：

 print()函数--用于打印输出，最常见的一个函数。

语法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数：

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

返回值：无

实例：

print(1)
print("hello world")
 
a = 1
b = 'runoob'
print(a, b)
 
print("aaa""bbb")
print("aaa", "bbb")
 
print("www", "runoob", "com", sep=".")      # 设置间隔符

运行结果：

tuple()函数--将可迭代系列(如列表)转换为元组

语法：tuple( iterable )                # 要转换为元组的可迭代序列

返回值：返回元组

实例：

list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1 = tuple(list1)
print(tuple1)
 
a = {'www': 123, 'aaa': 234}
print(tuple(a))
 
a = set('abcd')
print(a)
print(tuple(a))

运行结果：

callable()函数--检查一个函数是否被调用。

提示：如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。

语法：callable(object)             #对象

返回值：可调用返回 True，否则返回 False。

实例：

print(callable(0))
 
print(callable("runoob"))
 
 
def add(a, b):
    return a + b
 
 
print(callable(add))

运行结果：

 format()格式化函数

语法：基本语法是通过 {} 和 : 来代替以前的 %

                format函数可以接受不限个数，位置可以不按顺序

实例：

print("{} {}".format("hello", "world"))    # 不设置指定位置，按默认顺序
print("{0} {1}".format("hello", "world"))   # 设置指定位置
print("{1} {0} {1}".format("hello", "world"))    # 设置指定位置
 
# 设置参数
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

运行结果：

 数字格式化

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；  （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

len()方法--返回对象(字符，列表，元组等) 长度或项目个数

语法：len(s)                # s ：对象

返回值：返回对象的长度

实例：

str = "runoob"
print(len(str))
 
l = [1, 2, 3, 4, 5]
print(len(l))

运行结果：

property()函数--返回属性值

语法：class property([fget[, fset[, fdel[, doc]]]])

参数：

• fget -- 获取属性值的函数
• fset -- 设置属性值的函数
• fdel -- 删除属性值函数
• doc -- 属性描述信息

返回值：返回新式类属性

实例：

class C(object):
    def __init__(self):
        self._x = None
 
    def getx(self):
        return self._x
 
    def setx(self, value):
        self._x = value
 
    def delx(self):
        del self._x
 
    x = property(getx, setx, delx, "I'm the 'x' property.")
 
 
c = C()
print(c.x)
c.x = 4
print(c.x)

运行结果：

type()函数--返回参数的对象的类型

提示：如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。

• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法：

        type(object)

        type(name, bases, dict)

参数：

• name -- 类的名称。
• bases -- 基类的元组。
• dict -- 字典，类内定义的命名空间变量。

返回值：一个参数返回对象类型，三个参数，返回新的类型对象。

实例：

print(type(1))
print(type('runoob'))
print(type([2]))
print(type({0: 'zero'}))

运行结果：

chr()函数--用一个整数作为参数，返回一个对应的字符

语法：chr(i)       # i：可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 

返回值：返回值是当前整数对应的ASCII字符

实例：

print(chr(0x30))
print(chr(97))
print(chr(787))

运行结果：

frozenset()函数--返回一个冻结的集合，冻结后集合不能在添加或删除任何元素。

语法：class frozenset([iterable])             # iterable -- 可迭代的对象，比如列表、字典、元组等等。

返回值：返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

实例：

a = frozenset(range(10))     # 生成一个新的不可变集合
print(a)
 
b = frozenset('runoob')
print(b)

运行结果：

List list()方法--用于将元组或字符串转换为列表

语法：list( seq )                # seq：要转换为列表的元组或字符串。

返回值：返回列表

实例：

aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
 
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)

运行结果

range()函数--函数返回的是一个可迭代对象

        提示：而不是列表类型， 所以打印的时候不会打印列表。

语法：

        range(stop)

        range(start, stop[, step])

参数说明：

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

实例：

print(range(5))
 
for i in range(5):
    print(i)
 
print(list(range(5)))

运行结果：

var()函数--返回对象object的属性和属性值的字典对象

语法：vars([object])                # 对象

返回值：返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。

实例：

print(vars())
 
 
class Runoob:
    a = 1
 
 
print(vars(Runoob))

运行结果：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000014CC2A53348>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/pythonliu/lu.py', '__cached__': None}

{'__module__': '__main__', 'a': 1, '__dict__': , '__weakref__': , '__doc__': None}
 

classmethod 修饰符

描述：classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

语法：classmethod

参数：无

返回值：返回函数的类方法

class A(object):
    bar = 1
 
    def func1(self):
        print('foo')
 
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()  # 调用 foo 方法
 
 
A.func2()       # 不需要实例化

运行结果：

getattr()函数--用于返回一个对象属性值

语法：getattr(object, name[, default])

参数：

• object -- 对象。
• name -- 字符串，对象属性。
• default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

返回值：返回对象属性值

实例：

class A(object):
    bar = 1
 
 
a = A()
print(getattr(a, 'bar'))        # 获取属性bar值
print(getattr(a, 'bar2', 3))    # 属性 bar2 不存在，但设置了默认值
print(getattr(a, 'bar2'))       # 属性bar2不存在，触发异常

运行结果：

locals() 函数--以字典类型返回当前位置的全部局部变量

语法：locals()                

返回值：返回字典类型的局部变量

实例：

def runoob(arg):    # 两个局部变量：arg、z
    z = 1
    print(locals())
 
 
runoob(4)

运行结果：

 repr() 函数-- 将对象转化为供解释器读取的形式

语法：repr(object)                # object ： 对象

返回值：返回一个对象string格式

实例：

s = 'RUNOOB'
print(repr(s))
 
dict1 = {'runoob': 'runoob.com', 'google': 'google.com'}
print(repr(dict1))

运行结果：

zip()函数

描述：将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象

        我们可以使用 list() 转换来输出列表。

        如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

语法：zip([iterable, ...])                # iterable, ...：一个或者多个迭代器

返回值：返回一个对象

实例：

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)     # 返回一个对象
print(zipped)
 
print(list(zipped))  # list() 转换为列表
 
print(list(zip(a, )))       # 元素个数与最短的列表一致
 
a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
print(list(a1))
print(list(a2))

运行结果：

compile()函数--将一个字符串编译为字节代码。

语法：compile(source, filename, mode[, flags[, dont_inherit]])

参数：

• source -- 字符串或者AST（Abstract Syntax Trees）对象。。
• filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
• mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
• flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
• flags和dont_inherit是用来控制编译源码时的标志

返回值：返回表达式执行结果。

实例：

str1 = "for i in range(0,10): print(i)"
c = compile(str1, '', 'exec')   # 编译为字节代码对象
print(c)
 
print(exec(c))

运行结果：

globals()函数--会以字典类型返回当前位置的全部全局变量

语法：globals()

返回值：返回全局变量的字典。

实例：

a = 'runoob'
print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。

运行结果：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000021E62333348>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'E:/pythonliu/lu.py', '__cached__': None, 'a': 'runoob'}
 

map()函数--会根据提供的函数对指定序列做映射。

语法：map(function, iterable, ...)

参数：

• function -- 函数
• iterable -- 一个或多个序列

返回值：返回一个迭代器

def square(x) :         # 计算平方数
    return x ** 2
 
 
print(map(square, [1, 2, 3, 4, 5]))     # 计算列表各个元素的平方
print(list(map(square, [1, 2, 3, 4, 5])))   # 使用 list() 转换为列表
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数

运行结果：

reversed()函数--返回一个反转的迭代器

语法：reversed(seq)                # 要转换的序列，可以是tuple,string,list或range

返回值：返回一个反转的迭代器。

实例：

# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))
 
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
 
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
 
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

运行结果：

__import__()函数-- 用于动态加载类函数。

提示：如果一个模块经常变化就可以使用__import__()来动态载入

语法：__import__(name[, globals[, locals[, fromlist[, level]]]])              # name -- 模块名

返回值：返回元组列表

#  a.py文件代码
 
 
import os
 
print('在 a.py 文件中 %s' % id(os))

# b.py文件代码
 
 
import sys  
__import__('a')        # 导入 a.py 模块

运行结果：

complex()函数--用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数

        如果第一个参数为字符串，则不需要指定第二个参数

语法：class complex([real[, imag]])

参数：

• real -- int, long, float或字符串；
• imag -- int, long, float；

返回值：返回一个复数

实例：

print(complex(1, 2))
print(complex(1))
print(complex("1"))
 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(complex("1+2j"))

运行结果：

hasattr()函数-- 用于判断对象是否包含对应的属性。

语法：hasattr(object, name)

参数：

• object -- 对象。
• name -- 字符串，属性名。

返回值：如果对象有该属性返回 True，否则返回 False。

实例：

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性

运行结果：

max()函数--返回给定参数的最大值，参数可以是序列

语法：max( x, y, z, .... )

参数：

• x -- 数值表达式。
• y -- 数值表达式。
• z -- 数值表达式。

返回值：返回给定参数的最大值

实例：

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))

运行结果：

round()函数--返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端

提示：精度要求高的不建议使用该函数。

语法：round( x [, n] )

参数：

• x -- 数字表达式。
• n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。

返回值：返回浮点数x的四舍五入值

实例：

print("round(70.23456) : ", round(70.23456))
print("round(56.659,1) : ", round(56.659,1))
print("round(80.264, 2) : ", round(80.264, 2))
print("round(100.000056, 3) : ", round(100.000056, 3))
print("round(-100.000056, 3) : ", round(-100.000056, 3))

运行结果：

reload()函数--用于重新载入之前的模块

语法：

        import importlib

        importlib.reload(module)

        或者：

        from importlib import reload

        reload(module)

参数：module -- 模块对象。

返回值：返回模块对象

实例：

import sys, importlib
print(importlib.reload(sys))

运行结果：

delattr()函数--用于删除属性

        delattr(x, 'foobar') 相等于 del x.foobar

语法：delattr(object, name)

参数：

• object -- 对象。
• name -- 必须是对象的属性。

返回值：无

实例：

class Coordinate:
    x = 10
    y = -5
    z = 0
 
 
point1 = Coordinate()
 
print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ', point1.x)
print('y = ', point1.y)
 
# 触发错误
print('z = ', point1.z)

运行结果：

hash()函数--用于获取取一个(字符串或者数值等)的哈希值

语法：hash(object)                # object -- 对象；

返回值：返回对象的哈希值

实例：

print(hash('test'))
print(hash(str([1, 2, 3])))

运行结果：

memoryview()函数--返回给定参数的内存查看对象

        所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

语法：memoryview(obj)                # obj：对象

返回值：元组列表

实例：

v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
print(v[-1])
print(v[1:4])
print(v[1:4].tobytes())

运行结果：

set()函数--创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

语法：class set([iterable])                # iterable -- 可迭代对象对象；

返回值：返回新的集合对象。

实例：

x = set('runoob')
y = set('google')
print(x, y)         # 去重
 
print(x & y)        # 交集
print(x | y)        # 并集
print(x - y)        # 差集

运行结果：

参考网址：Python 基础教程 | 菜鸟教程