# 注意：内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，最精准的还是以内存地址为准。
# is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型
以下优先列出需要掌握的内置函数
print(abs(-1)) # 1 取绝对值
print(all([2, 3, 4, 'sss', 'True'])) # 里面的值全为Ture，则返回True，如果里面的的值为空也返回True
print(any('3')) #里面的值只要有一个为Ture，择返回True，如果里面的值为空，则返回False
print(bytes('你好，albert', encoding='utf-8')) # 把utf-8编码的字符串转化为二进制
print(callable('d'.strip)) # 判断里面的值是不是可迭代类型 后面可以加（）的都是，比如‘abc’.strip() 、 max() 等等
print(bin(11)) #十进制转二进制
print(oct(11)) #十进制转八进制
print(hex(11)) #十进制转十六进制
print(bool(0)) #0,None,空的布尔值为假
res='你好egon'.encode('utf-8') # unicode按照utf-8进行编码，得到的结果为bytes类型
res=bytes('你好egon',encoding='utf-8') # 同上
print(res)
def func():
pass
print(callable('aaaa'.strip)) #判断某个对象是否是可以调用的，可调用指的是可以加括号执行某个功能
print(chr(90)) #按照ascii码表将十进制数字转成字符
print(ord('Z')) #按照ascii码表将字符转成十进制数字
print(dir('abc')) # 查看某个对象下可以用通过点调用到哪些方法
输出：
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
print(divmod(1311,25)) # 输出一个元祖，包含商和余数 （52,11）
eval 重点介绍，可用于文件读写操作
# 将字符内的表达式拿出运行一下，并拿到该表达式的执行结果
res=eval('{"name":"egon","age":18}')
print(res,type(res))
输出：{'name': 'egon', 'age': 18} <class 'dict'>
# eval 在文件中的应用
with open('db.txt','r',encoding='utf-8') as f:
s=f.read()
dic=eval(s)
print(dic,type(dic))
print(dic['egon'])
# eval 可以吧默认文件打开得到的字符串表达式拿出来运行一下，并拿到表达式的执行结果， 转化成原本的数据类型，进而更方便进行读写操作
fset=frozenset({1,2,3}) #集合是一个可变类型，frozenset可以制造不可变集合，fset已没有.add方法。
print(len({'x':1,'y':2})) #{'x':1,'y':2}.__len__()
obj=iter('egon') #'egon'.__iter__()
print(next(obj)) #obj.__next__()
print(next(obj))#obj.__next__()
print(iter(obj))#obj.__next__()
输出结果
e
g
<str_iterator object at 0x00000000021E7160>
# pow 三个参数，
print(pow(2,3,3)) #2 ** 3 % 3 取余数 输出2
# reversed 顺序翻转，不进行大小排序
l=[1,4,3,5]
res=reversed(l)
print(list(res))
print(l)
# round 里面写一个float 类型，四舍五入输出
print(round(3.5)) # 4
print(round(3.4)) # 3
# slice 取出一个切片
sc=slice(1,5,2) #1:5:2
l=['a','b','c','d','e','f']
# print(l[1:5:2])
print(l[sc]) # sc = slice(1,5,2) = [1:5:2]
t=(1,2,3,4,5,6,7,8)
# print(t[1:5:2])
print(t[sc])
# sum 求和，只用于求和，from functools import reduce ‘reduce’ 有很多作用，其中一个也可用于求和
sum
print(sum([1,2,3,4]))
vars
vars()
# zip 拉链函数，让上下两个数据一对一交合
left='hello'
right={'x':1,'y':2,'z':3}
res=zip(left,right)
print(list(res)) # [('h', 'x'), ('e', 'y'), ('l', 'z')]
exec()是Python的built-in函数。其作用很好描述，就是执行以string类型存储的Python代码。
一：map
map(...)
map(function, sequence[, sequence, ...]) -> list
说明：
对sequence中的item依次执行function(item)，执行结果输出为list。
例子：
>>> map(str, range(5)) #对range(5)各项进行str操作
['0', '1', '2', '3', '4'] #返回列表
>>> def add(n):return n+n
...
>>> map(add, range(5)) #对range(5)各项进行add操作
[0, 2, 4, 6, 8]
>>> map(lambda x:x+x,range(5)) #lambda 函数，各项+本身
[0, 2, 4, 6, 8]
>>> map(lambda x:x+1,range(10)) #lambda 函数，各项+1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> map(add,'zhoujy')
['zz', 'hh', 'oo', 'uu', 'jj', 'yy']
#想要输入多个序列，需要支持多个参数的函数，注意的是各序列的长度必须一样，否则报错：
>>> def add(x,y):return x+y
...
>>> map(add,'zhoujy','Python')
['zP', 'hy', 'ot', 'uh', 'jo', 'yn']
>>> def add(x,y,z):return x+y+z
...
>>> map(add,'zhoujy','Python','test') #'test'的长度比其他2个小
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: add() takes exactly 2 arguments (3 given)
>>> map(add,'zhoujy','Python','testop')
['zPt', 'hye', 'ots', 'uht', 'joo', 'ynp']
二：reduce
reduce(...)
reduce(function, sequence[, initial]) -> value
说明：
对sequence中的item顺序迭代调用function，函数必须要有2个参数。要是有第3个参数，则表示初始值，可以继续调用初始值，返回一个值。
例子：
>>> def add(x,y):return x+y
...
>>> reduce(add,range(10)) #1+2+3+...+9
>>> reduce(add,range(11)) #1+2+3+...+10
>>> reduce(lambda x,y:x*y,range(1,3),5) #lambda 函数，5是初始值， 1*2*5
>>> reduce(lambda x,y:x*y,range(1,6)) #阶乘，1*2*3*4*5
>>> reduce(lambda x,y:x*y,range(1,6),3) #初始值3，结果再*3
>>> reduce(lambda x,y:x+y,[1,2,3,4,5,6]) #1+2+3+4+5+6
三：filter
filter(...)
filter(function or None, sequence) -> list, tuple, or string
说明：
对sequence中的item依次执行function(item)，将执行结果为True（！=0）的item组成一个List/String/Tuple（取决于sequence的类型）返回，False则退出（0），进行过滤。
例子：
>>> def div(n):return n%2
...
>>> filter(div,range(5)) #返回div输出的不等于0的真值
[1, 3]
>>> filter(div,range(10))
[1, 3, 5, 7, 9]
>>> filter(lambda x : x%2,range(10)) #lambda 函数返回奇数，返回列表
[1, 3, 5, 7, 9]
>>> filter(lambda x : not x%2,range(10))
[0, 2, 4, 6, 8]
>>> def fin(n):return n!='z' #过滤'z' 函数，出现z则返回False
...
>>> filter(fin,'zhoujy') #'z'被过滤
'houjy'
>>> filter(lambda x : x !='z','zhoujy') #labmda返回True值
'houjy'
>>> filter(lambda x : not x=='z','zhoujy') #返回：字符串
'houjy'
上面的这些例子中都用到了一个 lambda表达式
>>> a=lambda x:x+3 >>> a(2) 5 >>> a=lambda x,y:x+y >>> a(2,3) 5
四，应用map，reduce，filter
1）：实现5!+4!+3!+2!+1!
#!/usr/bin/env python
#-*- coding:utf-8 -*-
def add_factorial(n):
empty_list=[] #声明一个空列表，存各个阶乘的结果，方便这些结果相加
for i in map(lambda x:x+1,range(n)): #用传进来的变量(n)来生成一个列表，用map让列表都+1，eg：range(5) => [1,2,3,4,5]
a=reduce(lambda x,y:x*y,map(lambda x:x+1,range(i))) #生成阶乘，用map去掉列表中的0
empty_list.append(a) #把阶乘结果append到空的列表中
return empty_list
if __name__ == '__main__':
import sys
#2选1
#(一)
try:
n = input("Enter a Number(int) : ")
result=add_factorial(n) #传入变量
print reduce(lambda x,y:x+y,result) #阶乘结果相加
except (NameError,TypeError):
print "That's not a Number!"
#(二)
# result = add_factorial(int(sys.argv[1])) #传入变量
# print reduce(lambda x,y:x+y,result) #阶乘结果相加
2）：将100~200以内的质数挑选出来
思路：
质数是指：只有1和它本身两个因数，如2、3、5、7都是质数，即能被1和本身整除，1不是质数。
比如一个数字N，看它是否质数的话，就要看：有没有能整除【2，N】之间的数X（不包含本身），即N%X是否为0，要是没有就为质数。
所以我们要实现的算法是：拿一个数字N，去除以【2，N】之间的数X，来得到质数，即：N/2，N/3，……，N/N-2，N/N-1 ===> N/range(2，N）
#!/usr/bin/env python
#-*- coding:utf-8 -*-
def is_prime(start,stop):
stop = stop+1 #包含列表右边的值
prime = filter(lambda x : not [x%i for i in range(2,x) if x%i == 0],range(start,stop)) #取出质数,x从range(start,stop) 取的数
print prime
if __name__ == '__main__':
try :
start = input("Enter a start Number :")
except :
start = 2 #开始值默认2
try :
stop = input("Enter a stop Number :")
except :
stop = 0 #停止数，默认0，即不返回任何值
is_prime(start,stop)