python开发函数进阶：内置函数

一，内置函数

#内置的模块
#拿过来直接就用的：内置的函数

#!/usr/bin/env python
#_*_coding:utf-8_*_

#内置的模块
#拿过来直接就用的：内置的函数
#作用域相关（2）（了解）
#1.globals()==获取全局变量的字典
#2.locals()==获取执行方法所在命名空间内的局部变量的字典


#str类型代码执行相关(3)
#1.eval()==将字符串类型的代码执行并返回结果==(掌握)
#print(eval('1+2+3+4'))
#print(eval('{'a':1}'))

#2.exec()==将自字符串类型的代码执行==(掌握)
#print(exec("1+2+3+4"))
#exec("print('hello,world')")

#3.compile()==（了解）
#将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值
#http://www.cnblogs.com/Eva-J/articles/7266087.html
#正常代码执行过程   读代码》执行
#                  字符串》转换成代码》执行
#compile()帮你去完成字符串》转化的过程
# com = compile('1+2+3','',mode='eval')  编译  节省时间
# print(eval(com))
# print(eval(com))
# 上面代码和下面代码结果一样，但是上面是先编译后执行的，下面代码每一次执行都要编译
# print(eval('1+2+3'))
# print(eval('1+2+3'))
#mode 有 eval（有返回值） exec（无返回值）
# single   # 这个模式千万不要用，会把内存改的乱七八糟   ********* 没懂
# s = "name = input('user:')"
# com = compile(s,'',mode='single')
# exec(com)


#其他（11）
#输入输出（2）(了解)
#1.input()==输入==输入的值str数据类型
#2.print()==输出
# def print(self, *args, sep=' ', end='
', file=None): # known special case of print
"""
# print源码剖析

    print(value, ..., sep=' ', end='
', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格，必须关键字传参，seq = ','
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存

f = open('tmp_file','w')  #######################  未来写日志用
print(123,456,sep=',',file = f,flush=True)
"""

#数据类型（1）（掌握）
#type(o)==返回变量o的数据类型

#内存相关（2）（掌握）
#id(o)==o是参数，返回一个变量的内存地址
#hash(o)==o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错
'''
hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。
*每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。
t = (1,2,3)
l = [1,2,3]
print(hash(t))  #可hash
print(hash(l))  #会报错
结果：
TypeError: unhashable type: 'list'
hash实例
当你需要唯一的值需要的时候才会用到
'''

#身份运算（课外补充）
#is  比对值和内存地址  id
#==  只是比对值

#文件操作相关（1）（掌握）
#open()==打开一个文件，返回一个文件操作符(文件句柄)
#r,w,a,r+,w+,a+,(都可以+b)
# f = open('tmp','r+')
# print(f.read(3))
# f.seek(5)
# f.write('ccccccc')
# #不要一边写一边读
# f.close()
#r+打开文件
#如果直接写 从头覆盖
#如果读了再写 追加
#如果seek指定了光标的位置 就在从该位置开始覆盖着写

#模块操作相关（1）（掌握）
#_import_==import==导入一个模块 import相当于_import_语法糖
# print(1+2)
# print(sum(1,2))

#帮助（1）（了解）
#help()==帮助模式，可以随意输入变量或者变量的类型。输入q退出。或者直接执行help(o)，o是参数，查看和变量o有关的操作。

#调用相关（1）（了解） 判断是不是可调用
#callable(o)==o是参数，看这个变量是不是可调用。
            #如果o是一个函数名，就会返回True
'''
def func():pass
print(callable(func))  #参数是函数名，可调用，返回True
print(callable(123))   #参数是数字，不可调用，返回False
'''
# print(callable(123)) FALSE
# print(callable(open)) TRUE

#查看参数所属类型的所有内置方法（1）（掌握）
#dir()==默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量
'''
print(dir(list))  #查看列表的内置方法
print(dir(int))  #查看整数的内置方法
'''
# print(dir(__builtins__))  #告诉所有内置的名称
# print(dir(int))
# print(dir(list))
# print(set(dir(list)) - set(dir(tuple)))  #list方法有，tuple里面没有的


#数字相关（14）
#数据类型相关（4）
#bool==
#int==
#float==
#complex==复数==（了解）

#进制转换相关（3）=（了解）
#bin==二进制
#oct==八进制
#hex==六进制

#数学运算（7）
#abs==计算绝对值
#divmod==返回（除，余）
# divmod(7.3) == (2,1)
#min==计算最小值
#min(list,数字)，可以使序列，可以使散列
#max==计算最大值，可以是序列，可以是散列
#sum==求和==参数必须是一个序列类型
# print(1+2) == print(int(1).__add__(2))
#round==小数的精确
#pow==幂次方的运算
# print(pow(2,2))


#数据结构相关（24）
#序列（13）
#列表和元祖（2）
#相关内置函数（2）
#1.reversed()==顺序的反转
# l = [1,2,3,4]
# print(list(reversed(l)))  #生成一个新列表,迭代器
# l.reverse()  #更改了源列表
# print(l)
#2.slice()略过
#字符串（9）
#1.str()==关键字
#2.format()
# print(format('test', '<20')) 左对齐，开辟20个空间
# print(format('test', '>40')) 右对其
# print(format('test', '^40')) 居中
#3.bytes()==（掌握）
# s = "你好"
# sb = bytes(s,encoding='utf-8')
# print(sb)
# ret = sb.decode('utf-8')
# print(ret)
#4.bytearray()==字节数组
# sb2 = bytearray(s,encoding='utf-8')  #列表
# print(sb2)
# sb2[0] = 229
# print(sb2.decode('utf-8'))
# print(sd(s))
#5.memoryview()
#6.ord()==字符按照unicode转数字
#7.chr（）==数字按照unicode转字符
#8.ascii（）==字符串转ascii
#9.repr==用于%r的格式化输出==（掌握）
# print(repr('1234'))
# print(repr(1234))
# print('name : %r'%('egon')) 保留引号

#数据集合（3）
#字典（1）
#dict()
#集合（2）
#set()
#frozenset()不可变得集合,括号内加集合



#相关内置函数（8）
#len()  字典也是有长度的 == (掌握)
#enumerate()==有一个拆包过程 == （掌握）
# for i,j in enumerate(l,1):
#     print(i,j)
#all()==有一个不是真，就返回false
# print(all([1,2,3]))
# print(all([0,2,3]))
# any()
# print(any([0,1,0]))
# print(any([0,0,0]))
# zip()
# l = [1,2,3]
# l2 = [4,5,6]
# print(zip(l,l2))  #地址
# print(list(zip(l,l2)))  #只取前面匹配住的，超过按短的来.字典也可以
# l = [1,2,3]      #3
# l2 = {'k':'v'}  #1
# print(zip(l,l2))
# print(list(zip(l,l2)))
#sorted()==排序==（掌握）
#sort针对list的成员函数sort进行排序，不返回副本
# l = [1,3,5,-2,-4,-6]
# l.sort()
# print(l)

# l2 = [1,3,5,-2,-4,-6]
# print(sorted(l2,key=abs,reverse=True))  #创建新的内存地址，返回了一个新的列表，也不修改原列表
# print(sorted(l2))     #abs按绝对值排序，reverse降序
# print(l2)

# filer（） #从一个列表当中找到符合筛选条件的组成新列表==（掌握）
# map（）   #对一个列表当中每一个值，做一样的操作，组成新的列表

# filter  第一个参数，判断函数，第二个参数，可迭代对象
# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
# 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
# 语法：filter(function, iterable) filter返回迭代器
def is_odd(n):
    return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(newlist)  # <filter object at 0x102079b00>
for i in newlist:
    print(i) # 13579
# 匿名函数写法
print(list(filter(lambda x:x%2==1,[1,2,3])))

# map() 会根据提供的函数对指定序列做映射。第一个是函数，第二个是可迭代对象，第三个一样。。。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
# 语法 map(function, iterable, ...)
def square(x,Y) :            # 计算平方，如果参数多个，那么是相对位置
    return x ** 2,Y ** 2

print(map(square, [1,2,3,4,5]))   # 计算列表各个元素的平方，返回迭代器
for i in map(square, [1,2,3,4,5],[6,7,8]):
    print(i)
'''
(1, 36)
(4, 49)
(9, 64)
'''
    
# 匿名函数写法
print(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))  # 使用 lambda 匿名函数
# 提供了两个列表，对相同位置的列表数据进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])