python之内置函数介绍

'''
    内置函数：通俗点将，只要不经过def定义的，直接能带括号()使用的方法就是内置函数
'''
# 与作用域相关的两个内置函数
# print(locals()) # 返回本地作用域中的所有名字
# print(globals()) # 返回全局作用域中的所有名字

# 迭代器、生成器相关的三个内置函数
# 迭代器.__next__() = next(迭代器)
# iter(可迭代的) = 可迭代的.__iter__() = 迭代器
# __len__ = len()

# dir 查看一个变量的所有方法
# print(dir([]))
# print(dir(1))

# 判断一个变量名是否为可调用的，如：
# a = 1
# print(callable(a))
# print(callable(print))

# hash函数:hash函数只能用于可哈希的数据类型，比如字符串，元组，数字，对于不可哈希的数据无法使用，比如列表
# 使用hash函数可以用来判断两个字符串是否想到，在一次程序执行过程中，相同的字符串的哈希值是一直不变的
# print(hash(1234))
# print(hash("aaaaaaaaaaaa"))

# print 函数
# print("1111", end="888") # end指定输出的结束符
# print(1,2,3,4, sep='|') # sep指定输出多个值的分隔符
# f = open('file', 'w') # 打开文件，获得文件句柄
# print("1111", file=f) # file默认打印到控制台，当赋值一个文件句柄时，会将打印的内容写入到文件中

# 下面是利用print方法打印进度条的例子
# import time
# for i in range(0, 101, 2):
#     time.sleep(0.1)
#     char_num = i // 2
#     # 三元运算符   条件1为真进行的操作 if 条件1 else 条件1不为真进行的操作
#     per = '\r%s%%: %s\n' %(i, "*" *char_num) if i == 100 else '\r%s%%: %s' %(i, '*' *char_num) #\r的意识是回到行首 这里就是一个三元运算符
#     print(per, end='', flush=True) # flush 表示将内容立刻输出到控制台上

# evel 和 evec方法
# eval('print(123)') # 打印123
# exec('print(123)') # 打印123
# print(eval('1+2+3'))  # 打印 6
# print(exec('1*2*3'))  # 打印 None
'''
eval和exec方法都可以执行符合python语法的字符串代码，唯一的区别就是exec没有返回值，所以在进行计算的时候打印的是None
eval只能用在明确知道要执行什么代码的地方，，这个方法使用不安全
exec 用于简单流程控制
eval 有结果的简单计算
'''

# complie 编译方法
# code = '1 + 2 + 3 + 4'
# compile1 = compile(code,'',"eval") # complie("要执行的代码字符串",如果从文件读取，则填入文件名称，否则填入空字符串，执行对应代码的方法)
# print(eval(compile1)) # 简单的计算用eval
#
# code = 'for i in range(10): print(i)'
# compile2 = compile(code,"","exec") # 简单的流程控制用eval
# exec(compile2) # 简单的流程控制用eval

# code = 'name = input(":")'
# compile3 = compile(code,"","single") # 交互命令用single
# exec(compile3) # 执行编译完的也用exec

# divmod方法  div 除法， mod 求余 divmod除余
# print(divmod(7,2)) #(3, 1) 元组中第一个数是商，第二个是余数
# print(divmod(9,5)) #(1, 4)

# round用于小数精确 精确到小数点后第几位 会四舍五入
# print(round(1.13141516, 3))

# pow(x,y,z)方法用于进行幂运算
# print(pow(2,3)) # 只有两个参数的时候，计算 x的y次方
# print(pow(2,3,3)) # 有三个参数的时候，计算 x的y次方对z的余数

# reverse 对列表进行反转，改变列表的原顺序
# l = [1,2,3,4,5]
# l.reverse()
# print(l)
# reversed 也是对列表进行反转，它与reverse的区别在于，它会保留列表，返回一个反向的迭代器
# l = [1,2,3,4,5]
# l = reversed(l)
# print(l)

# bytes()方法，将对象转换为bytes类型,可以用在转换编码的情况
# 网络编程，传输文件，爬虫等等。
# print(bytes('你好', encoding='GBK'))    # unicode转换成gbk
# print(bytes('你好', encoding='UTF-8'))  # unicode转换成utf-8

'''
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
enumerate(sequence, [start=0])
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
返回 enumerate(枚举) 对象。
'''
# seq = ['one', 'two', 'three']
# for i, element in enumerate(seq):
#     print (i, element)  # 0 one 1 two 2 three

'''
 zip (拉链方法）
 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
在 Python 3.x 中为了减少内存，zip() 返回的是一个对象
'''
# a = [1,2,3]
# b = [4,5,6]
# c = [4,5,6,7,8]
# dic = {'a':1, 'b':2}
# zipped = zip(a,b)     # 打包为元组的列表
# for i in zipped:
#     print(i)  # [(1, 4), (2, 5), (3, 6)]
#
# for i in zip(a,c):
#     print(i)              # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)]
#
# for i in zip(a,dic):
#     print(i)        # 元素个数与最短的字典一致

'''
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回迭代器对象。
filter(function, iterable)
该接收两个参数，第一个为函数名（用于过滤的函数），第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新的
序列中。
filter只管筛选，不会改变原来的值
'''
# def is_odd(n):
#     return n % 2 == 1
#
# newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# for i in newlist:
#     print(i)

'''
map() 会根据提供的函数对指定序列做映射。
map(function, iterable, ...)
function -- 函数
iterable -- 一个或多个序列
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
Python 3.x 返回迭代器。
执行前后元素不变，值可能发生改变
'''
# def square(x) :            # 计算平方数
#     return x ** 2
#
# for i in map(square, [1,2,3,4,5]):   # 计算列表各个元素的平方
#     print(i)    # [1, 4, 9, 16, 25]
# for i in map(lambda x: x ** 2, [1, 2, 3, 4, 5]):
#     print(i)  # 使用 lambda 匿名函数 [1, 4, 9, 16, 25]
#
# # 提供了两个列表，对相同位置的列表数据进行相加
# for i in map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]):
#     print(i) # [3, 7, 11, 15, 19]

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

L=[('b',2),('a',1),('c',3),('d',4)]
print(sorted(L, key=lambda x:x[1]))    # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students, key=lambda s: s[2]))     # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
print(sorted(students, key=lambda s: s[2], reverse=True))       # 按降序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]