python内置函数

# 1， python3中一共有68个内置函数
# 2，函数分类
# 数字函数（7个）
# 类型转换（24个）
# 序列操作（8个）
# 对象操作（7个）
# 反射操作（8个）
# 变量操作（2个）
# 交互操作（2个）
# 编译执行（4个）
# 装饰器（3个)
# 4,数据转换
# bool：根据传入的参数返回一个新的布尔值
# (1,)bool() #未传入参数
# False
# (2,)bool(0) #数值0、空序列等值为False
# False
# (3,)bool(1)

# int:根据传入的参数创建一个整数
# (1,)int() #不传入参数时，得到结果0。
# 0
# (2,)int(3)
# 3
# (3,)int(3.6)
# 3

# float：根据传入的参数创建一个新的浮点数
# (1,)float() #不提供参数的时候，返回0.0
# 0.0
# (2,)float(3)
# 3.0
# (3,)float('3')
# 3.0

# str：返回一个对象的字符串表现形式(给用户)
# 复制代码
# (1,)str(None)
# 'None'
# (2,)str('abc')
# 'abc'
# (3,)str(123)
# '123'
# tuple：根据传入的参数创建一个新的元组
# (1,)tuple() #不传入参数，创建空元组
# ()
# (2,)tuple('121') #传入可迭代对象。使用其元素创建新的元组
# ('1', '2', '1')

# list：根据传入的参数创建一个新的列表
# (1,)list() # 不传入参数，创建空列表
# []
# (2,)list('abcd') # 传入可迭代对象，使用其元素创建新的列表
# ['a', 'b', 'c', 'd']

# dict：根据传入的参数创建一个新的字典
# 复制代码
# (1,)dict() # 不传入任何参数时，返回空字典。
# {}
# (2,)dict(a = 1,b = 2) #  可以传入键值对创建字典。
# {'b': 2, 'a': 1}
# (3,)dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。
# {'b': 2, 'a': 1}
# (4,)dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。
# {'b': 2, 'a': 1}

# set：根据传入的参数创建一个新的集合
# (1,)set() # 不传入参数，创建空集合
# set()
# (2,)a = set(range(10)) # 传入可迭代对象，创建集合
# print(a)
# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# enumerate：根据可迭代对象创建枚举对象
# seasons = ['Spring', 'Summer', 'Fall', 'Winter']
# print(list(enumerate(seasons)))
# print(list)
# <class 'list'>指是什么类型
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
# (2,)list(enumerate(seasons, start=1)) #指定起始值
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

# range：根据传入的参数创建一个新的range对象
# a = range(10)
# b = range(1,10)
# c = range(1,10,3)
# a,b,c # 分别输出a,b,c
# (range(0, 10), range(1, 10), range(1, 10, 3))
# list(a),list(b),list(c) # 分别输出a,b,c的元素
# ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])

# 序列操作

# all：判断可迭代对象的每个元素是否都为True值
# (1,)all([1,2]) #列表中每个元素逻辑值均为True，返回True
# True
# (2,)all([0,1,2]) #列表中0的逻辑值为False，返回False
# False
# (3,)all(()) #空元组
# True
# all({}) #空字典
# True

# filter：使用指定方法过滤可迭代对象的元素
# a = list(range(1,10)) #定义序列
# a
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# def if_odd(x): #定义奇数判断函数
#     return x%2==1
# list(filter(if_odd,a)) #筛选序列中的奇数
# [1, 3, 5, 7, 9]

# #新内容的个数等于原内容的个数
# ret = map(abs,[-1,-5,6,-7])   #abs(-1) = 1   abs(-5) = 5
# print(list(ret))

# #filter和map
# #参数很相近：都是一个函数名+可迭代对象
# #且返回值页很相近：都是返回可迭代对象
# #区别
# #filter是做筛选的，结果还是原来就在可迭代对象中的项
# #map是对可迭代对象中的每一项做操作的，结果不一定是原来就在可迭代对象中的项
#
# #有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理
# def func(x):
#     return x*x
# ret = map(func,[1,2,3,4,5,6,7,8])
# print(list(ret))
# [1, 4, 9, 16, 25, 36, 49, 64]
# #sort 是直接修改原列表的顺序，节省内存
# #sorted 是生成一个新列表，不改变原来的列表
# #key = func
# # print(sorted([-5,3,-4,2,-1],reverse=True))
# # print(sorted([-5,3,-4,2,-1],key=abs))
#
# # l2 = ['ajkhs',(1,2),'a',[1,2,3,4]]
# # print(sorted(l2,key=len,reverse=True))
#
# # print(ascii('a'))
# # # print(ascii(1))
#
# zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
# x = [1, 2, 3]  # 长度3
# y = [4, 5, 6, 7, 8]  # 长度5
# list(zip(x, y))  # 取最小长度3
# [(1, 4), (2, 5), (3, 6)]

# 对象操作
# id：返回对象的唯一标识符
# a = 'some text'
# id(a)
# 69228568

# len：返回对象的长度
#
# len('abcd') # 字符串
# len(bytes('abcd','utf-8')) # 字节数组
# len((1,2,3,4)) # 元组
# len([1,2,3,4]) # 列表
# len(range(1,5)) # range对象
# len({'a':1,'b':2,'c':3,'d':4}) # 字典
# len({'a','b','c','d'}) # 集合
# len(frozenset('abcd')) #不可变集合

# 变量操作
# globals：改完后使用全局变量
# locals：内部函数使用外部函数变量、

# 文件操作
# open使用指定的模式和编码方式打开文件，返回文件读写对象

# eval：执行动态表达式求值
# eval('1+2+3+4')
# 10
# exec：执行动态语句块
# exec('a=1+2') #执行语句
# a
# 3

# reversed：反转序列生成新的可迭代对象、
# a = reversed(range(10)) # 传入range对象
# a # 类型变成迭代器
# print(list(a))
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]