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='\n', file=None): # known special case of print
 """
 # print源码剖析

     print(value, ..., sep=' ', end='\n', 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])