python3内置函数

• dict() 函数用于创建一个字典。
• min() 方法返回给定参数的最小值，参数可以为序列。
• setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
• all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
• dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
• hex() 函数用于将一个指定数字转换为 16 进制数。
• next() 返回迭代器的下一个项目。next() 函数要和生成迭代器的 iter() 函数一起使用。
• slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
• any() 用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
• divmod() 把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
• id() 函数返回对象的唯一标识符，标识符是一个整数。(返回对象的内存地址。)
• sorted() 函数对所有可迭代的对象进行排序操作。
• enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
• oct() 函数将一个整数转换成 8 进制字符串，8 进制以 0o 作为前缀表示。
• input() 接受一个标准输入数据，返回为字符串类型。
• @staticmethod 修饰符返回函数的静态方法(一般用在自定义类，声明方法为静态方法)。
• bin(x)  返回一个整数 int 的二进制表示
• eval() 函数用来执行一个字符串表达式，并返回表达式的值。
• open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
  open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
• str() 将对象转化为适于人阅读的形式。返回一个对象的string格式。
• bool() 用于将给定参数转换为布尔类型，如果没有参数，返回 False。bool 是 int 的子类。
• exec() 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
• isinstance(object, classinfo) 判断一个对象是否是一个已知的类型，类似 type()。
• ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
• sum(iterable[, start]) 对序列进行求和计算，start -- 指定相加的参数，如果没有设置这个值，默认为0。
• bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
• filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
• issubclass(class, classinfo) 用于判断参数 class 是否是类型参数 classinfo 的子类
• pow(x, y[, z]) 方法返回 xy（x 的 y 次方） 的值。 如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。
• super(type[, object-or-type]) 用于调用父类(超类)的一个方法
• bytes() 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
• float() 函数用于将整数和字符串转换成浮点数。
• iter() 函数用来生成迭代器。
• print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) 打印信息
• tuple() 函数将可迭代系列（如列表）转换为元组。
• len() 方法返回对象（字符、列表、元组等）长度或项目个数。
• type() 函数如果你只有第一个参数则返回对象的类型。
• frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
• list() 方法用于将元组或字符串转换为列表。
• range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
• vars() 函数返回对象object的属性和属性值的字典对象。
• @classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
• getattr() 函数用于返回一个对象属性值。
• locals() 函数会以字典类型返回当前位置的全部局部变量。
• repr() 函数将对象转化为供解释器读取的形式。
• zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
• compile() 函数将一个字符串编译为字节代码。
• globals() 函数会以字典类型返回当前位置的全部全局变量。
• map() 函数会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
• reversed() 函数返回一个反转的迭代器。
• set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
• round() 函数返回number舍入到小数点后ndigits位的浮点值。如果省略ndigits，将返回最接近输入的整数。

使用示例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

"""
内置函数使用示例
内置函数不用导入任何模块就可以在任何位置使用
以下我们就简单的介绍各个内置函数的使用
"""

"""
abs() 函数返回数字的绝对值
【参数】
1）x -- 数值表达式，可以是整数，浮点数，复数。
【返回值】
函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。
"""
print("************ abs()")
print("abs(-1)：", abs(-1))
"""
dict() 函数用于创建一个字典。
【语法】
1）class dict(**kwarg)
2）class dict(mapping, **kwarg)
3）class dict(iterable, **kwarg)
【参数】
1）**kwargs -- 关键字。
2）mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
3）iterable -- 可迭代对象。
【返回值】
返回一个字典
"""
print("************ dict()")
# 创建空字典
dict()
# 传入关键字
print(dict(a='a', b='b', t='t'))
print(dict([('x', 5), ('y', -5)], z=8))
# 映射函数方式来构造字典
print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))
# 可迭代对象方式来构造字典
print(dict([('one', 1), ('two', 2), ('three', 3)]))

"""
min() 方法返回给定参数的最小值，参数可以为序列。
【语法】
min( x, y, z, .... )
【参数】
1）x -- 数值表达式。
2）y -- 数值表达式。
3）z -- 数值表达式。
【返回值】
返回给定参数的最小值。
"""
print("************ min()")
print("min(80, 100, 1000) : ", min(80, 100, 1000))
print("min(-20, 100, 400) : ", min(-20, 100, 400))
print("min(-80, -20, -10) : ", min(-80, -20, -10))
print("min(0, 100, -400) : ", min(0, 100, -400))

"""
setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
【语法】
setattr(object, name, value)
【参数】
1）object -- 对象。
2）name -- 字符串，对象属性。
3）value -- 属性值。
"""
print("************ setattr()")


class A():
    name = "runoob"


a = A()
setattr(a, "age", 28)
print(a.age)

"""
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、None、False 外都算 True。
Python 2.5 以上版本可用。
【语法】
all(iterable)
【参数】
iterable -- 元组或列表。
【返回值】
如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
注意：空元组、空列表返回值为True，这里要特别注意。
"""
print("************ all()")
print("all()：", all([1, 2, 3]))

"""
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
【语法】
dir([object])
【参数】
object -- 对象、变量、类型。
【返回值】
返回模块的属性列表。
"""
print("************ dir()")
# 获得当前模块的属性列表
dir()
# 查看列表的方法
dir([])

"""
hex() 函数用于将一个指定数字转换为 16 进制数。
【语法】
hex(x)
【参数】
x -- 一个整数
【返回值】
返回一个字符串，以 0x 开头。
"""
print("************ hex()")
print(hex(255))
print(hex(-42))
print(hex(12))

"""
next() 返回迭代器的下一个项目。
next() 函数要和生成迭代器的 iter() 函数一起使用。
【语法】
next(iterable[, default])
【参数】
1）iterable -- 可迭代对象
2）default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
【返回值】
返回下一个项目。
"""
print("************ next()")
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
"""
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
【语法】
1）class slice(stop)
2）class slice(start, stop[, step])
【参数】
1）start -- 起始位置
2）stop -- 结束位置
3）step -- 间距
【返回值】
返回一个切片对象。
"""
print("************ slice()")
myslice = slice(5)  # 设置截取5个元素的切片
print(slice(None, 5, None))
arr = range(10)
print(arr[myslice])  # 截取5个元素
for item in arr[myslice]:
    print(item, end=',')
print()

"""
用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、False 外都算 TRUE。
Python 2.5 以上版本可用。
【语法】
any(iterable)
【参数】
iterable -- 元组或列表。
【返回值】
如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
"""
print("************ any()")
print(any([0, False]))
print(any([]))  # 空列表
print(any(()))  # 空元组

"""
divmod() 把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
在 python 2.3 版本之前不允许处理复数
【语法】
divmod(a, b)
【参数】
1）a: 数字，非复数。
2）b: 数字，非复数。
如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。
如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。
如果 a % b 的求余结果不为 0 ，则余数的正负符号跟参数 b 是一样的，若 b 是正数，余数为正数，若 b 为负数，余数也为负数，并且 0 <= abs(a % b) < abs(b)。
"""
print("************ divmod()")
print(divmod(10, 3))  # 输出(3, 1)

"""
id() 函数返回对象的唯一标识符，标识符是一个整数。
【语法】
id([object])
【返回值】
返回对象的内存地址。
"""
print("************ id()")
print(id("Rubbon"))

"""
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
【语法】
sorted(iterable, key=None, reverse=False)  
【参数】
1）iterable -- 可迭代对象。
2）key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
3）reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
【返回值】
返回重新排序的列表。
"""
print("************ sorted()")
# 默认为升序
print(sorted([5, 2, 3, 1, 4]))

# 你也可以使用 list 的 list.sort() 方法。
# 这个方法会修改原始的 list（返回值为None）。通常这个方法不如sorted()方便-如果你不需要原始的 list，list.sort()方法效率会稍微高一些。
a = [5, 2, 3, 1, 4]
print(a.sort())

example_list = [5, 0, 6, 1, 2, 7, 3, 4]
print(sorted(example_list, reverse=True))

"""
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
【语法】
enumerate(sequence, [start=0])
【参数】
1）sequence -- 一个序列、迭代器或其他支持迭代对象。
2）start -- 下标起始位置。
【返回值】
返回 enumerate(枚举) 对象。
"""
print("************ enumerate()")
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
enum = enumerate(seasons)
for i, element in enum:
    print(i, element)

"""
Python3.x 中的 input() 函数接受一个标准输入数据，返回为字符串类型。
【语法】
input([prompt])
【参数】
prompt: 提示信息
当输入hello后，控制台将打印出：请输入信息：hello
"""
# msg = input("请输入信息：")
# print(msg)

"""
oct() 函数将一个整数转换成 8 进制字符串，8 进制以 0o 作为前缀表示。
【语法】
oct(x)
【参数】
x -- 整数。
【返回值】
返回 8 进制字符串。
"""
print("************ oct()")
print(oct(10))

"""
python staticmethod 返回函数的静态方法。
"""
print("************ staticmethod")


class C(object):
    @staticmethod
    def f():
        print('runoob');


C.f()  # 静态方法无需实例化
cobj = C()
cobj.f()  # 也可以实例化后调用

"""
bin(x)  返回一个整数 int 的二进制表示
"""
print(bin(10))  # 输出 0b1010

"""
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
【语法】
eval(expression[, globals[, locals]])
1）expression -- 表达式。
2）globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
3）locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
【返回值】
返回表达式计算结果。
"""
print("************ eval()")
print(eval('3 * 2'))
print(eval('{"name":"harvey", "age": 12}'))
print(eval('{"name":"harvey", "age": age}', {"age": 1822}, {"age": 1823}))
# eval传递本地变量，既有global和local时，变量值先从local中查找。
age = 18
print(eval("{'name':'linux','age':age}", {"age": 1822}, locals()))
print(eval("{'name':'linux','age':age}"))

"""
int() 将一个字符串或数字转换为整型, 如果字符串不是数字，则会报ValueError异常
"""
print("************ int()")
print(int("10"))

"""
Python open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
【语法】
open(file, mode='r')
完整的语法形式：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
【参数】
1）file: 必需，文件路径（相对或者绝对路径）。
2）mode: 可选，文件打开模式
3）buffering: 设置缓冲
4）encoding: 一般使用utf8
5）errors: 报错级别
6）newline: 区分换行符
7）closefd: 传入的file参数类型

mode的常用选项有：
1）t	文本模式 (默认)。
2）x	写模式，新建一个文件，如果该文件已存在则会报错。
3）b	二进制模式。
4）+	打开一个文件进行更新(可读可写)。
5）r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
6）rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
7）r+	打开一个文件用于读写。文件指针将会放在文件的开头。
8）rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
9）w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
10）wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
11）w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
12）wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
13）a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
14）ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
15）a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
16）ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
"""
print("************ open()")
f = open('test.txt')
print(f.read())

"""
str() 将对象转化为适于人阅读的形式
【返回值】
返回一个对象的string格式。
"""
print("************ str()")
print(str({'runoob': 'runoob.com', 'google': 'google.com'}))

"""
用于将给定参数转换为布尔类型，如果没有参数，返回 False。
bool 是 int 的子类。
【返回值】
返回 True 或 False。
"""
print("************ bool()")
print(bool(0))  # False
print(bool(1))  # True
print(bool(2))  # True

"""
exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
【语法】
exec(object[, globals[, locals]])
【参数】
1）object：必选参数，表示需要被指定的 Python 代码。它必须是字符串或 code 对象。如果 object 是一个字符串，该字符串会先被解析为一组 Python 语句，然后再执行（除非发生语法错误）。
如果 object 是一个 code 对象，那么它只是被简单的执行。
2）globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
3）locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与 globals 相同的值。
【返回值】
exec 返回值永远为 None。
"""
print("************ exec()")
exec('print("Hello World")')
# 单行语句字符串
exec("print ('runoob.com')")

#  多行语句字符串
exec("""for i in range(5):
            print ("iter time: %d" % i)
    """)

"""
isinstance(object, classinfo) 判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
1）type() 不会认为子类是一种父类类型，不考虑继承关系。
2）isinstance() 会认为子类是一种父类类型，考虑继承关系。
3）如果要判断两个类型是否相同推荐使用 isinstance()。
"""
print("************ isinstance()")
a = 2
isinstance(a, int)
isinstance(a, str)
# 是元组中的一个返回 True
isinstance(a, (str, int, list))

"""
ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
【语法】
ord(c)
【参数】
c -- 字符。
【返回值】
返回值是对应的十进制整数。
"""
print("************ ord()")
print(ord('a'))
print(ord('€'))

"""
sum(iterable[, start]) 对序列进行求和计算
start -- 指定相加的参数，如果没有设置这个值，默认为0。
"""
print("************ sum()")
print(sum([1, 2, 3, 4], 1))  # 输出11

"""
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
*语法*：
class bytearray([source[, encoding[, errors]]])
*参数*：
1）如果 source 为整数，则返回一个长度为 source 的初始化数组；
2）如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
3）如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
4）如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
5）如果没有输入任何参数，默认就是初始化数组为0个元素。
*返回值*：
返回新字节数组。
"""
print("************ bytearray()")
print(bytearray([1, 2, 3]))
print(bytearray('runoob', 'utf-8'))

"""
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
【语法】
filter(function, iterable)
【参数】
1）function -- 判断函数。
2）iterable -- 可迭代对象。
【返回值】
返回一个迭代器对象
"""
print("************ filter()")


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


interator = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
for ele in interator:
    print(ele, end=',')  # 使用逗号分隔
print()

"""
issubclass(class, classinfo) 用于判断参数 class 是否是类型参数 classinfo 的子类
"""
print("************ issubclass()")


class A:
    pass


class B(A):
    pass


print(issubclass(B, A))  # 返回 True

"""
pow(x, y[, z]) 方法返回 xy（x 的 y 次方） 的值。 如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。
"""
print("************ pow()")
print(pow(100, 2))

"""
super(type[, object-or-type]) 用于调用父类(超类)的一个方法
参数：
1）type -- 类。
2）object-or-type -- 类，一般是 self
"""
print("************ super()")


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)  # 3

"""
bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
*语法*：
class bytes([source[, encoding[, errors]]])

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

*返回值*：
返回一个新的 bytes 对象。
"""
print("************ bytes()")
print(bytes([1, 2, 3, 4]))
print(bytes('hello', 'ascii'))

"""
float() 函数用于将整数和字符串转换成浮点数。
【语法】
class float([x])
【参数】
x -- 整数或字符串
【返回值】
返回浮点数。
"""
print("************ float()")
print(float(112))
print(float(-123.6))
print(float('123'))  # 字符串

"""
iter() 函数用来生成迭代器。
【语法】
iter(object[, sentinel])
【参数】
object -- 支持迭代的集合对象。
sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），
此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
【返回值】
迭代器对象。
"""
print("************ iter()")
lst = [1, 2, 3]
for i in iter(lst):
    print(i)

"""
说明：print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。
【语法】
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
【参数】
1）objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
2）sep -- 用来间隔多个对象，默认值是一个空格。
3）end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
4）file -- 要写入的文件对象。
5）flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
"""
print("************ print()")
print("www", "runoob", "com", sep=".")  # 设置间隔符

# 使用 flush 参数生成一个 Loading 的效果：
# print("---RUNOOB EXAMPLE ： Loading 效果---")
# import time
#
# print("Loading", end="")
# for i in range(20):
#     print(".", end='', flush=True)
#     time.sleep(0.5)

"""
tuple 函数将可迭代系列（如列表）转换为元组。
tuple( iterable )
"""
print("************ tuple()")
print(tuple([1, 2, 3, 4]))

"""
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
len( s )
"""
print("************ len()")
# 字符串长度
print(len("runoob"))
# 列表元素个数
print(len([1, 2, 3, 4, 5]))

"""
type() 函数如果你只有第一个参数则返回对象的类型
"""
print("************ type()")
print("obj type：", type(1))  # 输出int
print("obj type", type('runoob'))  # 输出str
print("obj type", type([2]))  # 输出list
print("obj type", type({0: 'zero'}))  # 输出dict
x = 1
type(x) == int  # 判断类型是否相等

"""
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
【语法】
class frozenset([iterable])
【参数】
iterable -- 可迭代的对象，比如列表、字典、元组等等。
【返回值】
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
"""
print("************ frozenset()")
# 生成一个新的不可变集合
print(frozenset(range(10)))
print(frozenset('runoob'))

"""
list() 方法用于将元组或字符串转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
【语法】
list( seq )
【参数】
seq -- 要转换为列表的元组或字符串。
【返回值】
返回列表。
"""
print("************ list()")
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print("列表元素 : ", list1)

str = "Hello World"
list2 = list(str)
print("列表元素 : ", list2)

"""
Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。
Python2 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()")
a = range(5)
for i in a:
    print(i)
print(list(a))

"""
vars() 函数返回对象object的属性和属性值的字典对象。
【语法】
vars([object])
【参数】
object -- 对象
【返回值】
返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。
"""
print("************ vars()")
print(vars())


class Runoob:
    a = 1


print(vars(Runoob))
runoob = Runoob()
print(vars(runoob))

"""
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
"""
print("************ 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])
【参数】
1）object -- 对象。
2）name -- 字符串，对象属性。
3）default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
【返回值】
返回对象属性值。

"""
print("************ getattr()")


class A(object):
    bar = 1


a = A()

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

"""
locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
"""
print("************ locals()")


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


runoob(4)

"""
repr() 函数将对象转化为供解释器读取的形式。
【语法】
repr(object)
【返回值】
返回一个对象的 string 格式。
"""
print("************ repr()")
s = 'RUNOOB'
print(repr(s))
dict1 = {'runoob': 'runoob.com', 'google': 'google.com'}
repr(dict1)

"""
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
在 Python 2.x zip() 返回的是一个列表。
【语法】
zip([iterable, ...])
【参数】
iterable -- 一个或多个迭代器;
【返回值】
返回一个对象

"""
print("************ zip()")
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)  # 返回一个对象
print(list(zipped))  # list() 转换为列表
print(list(zip(a, c)))  # 元素个数与最短的列表一致
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是用来控制编译源码时的标志
【返回结果】
返回表达式执行结果。
"""
print("************ compile()")
str = "for i in range(0,10): print(i)"
c = compile(str, '', 'exec')  # 编译为字节代码对象

"""
globals() 函数会以字典类型返回当前位置的全部全局变量。
【语法】
globals()
【返回】
返回全局变量的字典。
"""
print("************ globals()")
a = 'runoob'
print(globals())  # globals 函数返回一个全局变量的字典，包括所有导入的变量。

"""
map() 函数会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
【语法】
map(function, iterable, ...)
【参数】
1）function -- 函数
2）iterable -- 一个或多个序列
【返回值】
返回一个迭代器。
"""
print("************ map()")


# 计算平方数
def square(x):
    return x ** 2


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

"""
reversed 函数返回一个反转的迭代器。
【语法】
reversed(seq)
【参数】
seq -- 要转换的序列，可以是 tuple, string, list 或 range。
【返回值】
返回一个反转的迭代器。
"""
print("************ reversed()")
# 字符串
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)))

"""
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
【语法】
class set([iterable])
【参数】
iterable -- 可迭代对象对象；
【返回值】
返回新的集合对象。
"""
print("************ set()")
x = set('runoob')
y = set('google')
# 交集
print(x & y)
# 并集
print(x | y)
# 差集
print(x - y)

"""
round返回number舍入到小数点后ndigits位的浮点值。如果省略ndigits，将返回最接近输入的整数。
【语法】
round(number[, ndigits])
【参数】
第一个参数是一个浮点数，第二个参数是保留的小数位数，可选，如果不写的话默认保留到整数
"""
print(round(1.34))  # 输出 1
print(round(1.34, 1))  # 输出1.3
print(round(-1.34))  # 输出-1
print(round(-1.34, 1))  # 输出 -1.3
print(round(3.4))  # 输出3