### 内置函数
> 内置函数就是在系统安装完python解释器时，由python解释器给提供好的函数
### [`range()`](https://docs.python.org/zh-cn/3.7/library/stdtypes.html#range) 函数
> 如果你确实需要遍历一个数字序列，内置函数 [`range()`](https://docs.python.org/zh-cn/3.7/library/stdtypes.html#range) 会派上用场。它生成算术级数
```
range()函数
功能：能够生成一个指定的数字序列
参数：
start : 开始的值 ，默认值为0
stop ： 结束的值
[, step]： 可选，步进值 默认值为1
返回值： 可迭代的对象，数字序列
```
使用案例：
```python
#range函数的使用方式
# 只写一个参数，就是从零开始到10之前，9
# res = range(11)
# 两个参数时，第一个参数是开始的值，第二个参数是结束的值（在结束值之前）
# res = range(5,10)
# 三个参数， 参数1是开始值，参数2是结束值，参数三是步进值
# res = range(1,10,3)
# 获取一个倒叙的数字序列
# res = range(10,0,-1)
# res = range(10,0,-2)
res = range(-10,-20,-1)
res = range(-20,-10)
res = range(-10,10)
print(list(res))
```
提取range()函数返回的数字序列的方法：
```python
# 获取range函数返回的数字序列的方法
# res = range(10)
# 1。转为list列表数据
# print(list(res))
# 2。通过 for循环 进行遍历
# for i in res:
# print(i)
# 3。转为迭代器，使用next函数调用
# res = iter(res)
# print(next(res))
# print(next(res))
```
### zip() 函数
```
zip()
功能：zip 函数是可以接受多个可迭代的对象，然后把每个可迭代对象中的第i个元素组合在一起，形成一个新的迭代器
参数：*iterables，任意个的 可迭代对象
返回值： 返回一个元组的迭代器
```
示例：
```python
var1 = '1234'
var2 = ['a','b','c']
var3 = ('A','B','C','D')
# 调用zip函数，组成新的元组迭代器
res = zip(var1,var2,var3)
# print(res,type(res))
for i in res:
print(i)
'''
('1', 'a', 'A')
('2', 'b', 'B')
('3', 'c', 'C')
('4', 'd', 'D')
'''
# zip() 与 * 运算符相结合可以用来拆解一个列表:
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))
print(zip(x, y)) # 迭代器对象，
print(*zip(x, y))# 组合好的多个元组数据
```
## 其它内置函数
### 数据类型转换相关内置函数
int() 将其它类型数据转为整型
float() 转为浮点类型
bool() 转为布尔类型
complex() 转为复数
str() 转为字符串类型
list 转为列表类型
tuple 转为元组类型
dict 转为字典类型
set 转为集合类型
### 变量相关函数
id() 获取当前数据的ID标识
type() 获取当前数据的类型字符串
print() 数据的打印
input() 获取输入的数据
isinstance() 检测是否为指定的数据类型
### 数学相关函数
```python
# 数学相关函数
# 获取一个数的绝对值
# print(abs(-99.99))
# 求和 从 start 开始自左向右对 iterable 中的项求和并返回总计值
# print(sum([1,2,3]))
# 获取最大值
# print(max([1,2,3]))
# print(max(99,12,45))
# 获取最小值
# print(min([2,1,6,-9]))
# print(min(6,7,1,0,-2))
# 幂运算 返回 x 的 y 次幂
# print(pow(2,3))
# 四舍五入
# r = round(3.1415926)
# r = round(3.1415926,2) # 小数点保留几位
# r = round(4.5) # 奇进偶退 1.5 = 2 2.5=2,3.5=4,4.5=4
# print(r)
```
### 进制相关函数
```python
# bin() 将数值类型转为二进制
# print(bin(123)) # 0b1111011
# int() 将二进制转为整型
# print(int(0b1111011)) #1 23
# oct() 转为八进制数 01234567
# print(oct(123)) # 0o173
# hex() 转为十六进制数 0123456789abcdef
# print(hex(123)) # 0x7b
```
### Ascii码及字符集
Ascii 共计 128个字符，更新于 1986年 主要用于显示现代英语和其他西欧语言。
GB2312-80 是 1980 年制定的中国汉字编码国家标准。共收录 7445 个字符，其中汉字 6763 个。
GBK 于1995年制定 收录了 21003 个汉字。GBK向下与 GB 2312 编码兼容，
GBK18030 2001年的1月正式强制执行，是我国制订的以汉字为主并包含多种我国少数民族文字（如藏、蒙古、傣、彝、朝鲜、维吾尔文等）的超大型中文编码字符集强制性标准，其中收入汉字70000余
Unicode（统一码、万国码、单一码）是计算机科学领域里的一项业界标准，包括字符集、编码方案等。
它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。1990年开始研发，1994年正式公布。
UTF-8 以字节为单位对Unicode进行编码。
```python
# 将字符转为 ascii
r = ord('a')
print(r)
# 将ascii转为字符
r = chr(65)
print(r)
```
## 高阶函数
### sorted(iterable,[reverse,key])
```
sorted()
运行原理：
把可迭代数据里面的元素，一个一个的取出来，放到key这个函数中进行处理，
并按照函数中return的结果进行排序，返回一个新的列表
功能： 排序
参数：
iterable 可迭代的数据 （容器类型数据，range数据序列，迭代器）
reverse 可选，是否反转，默认为False，不反转， True反转
key 可选， 函数，可以是自定义函数，也可以是内置函数
返回值： 排序后的结果
```
示例：
```python
arr = [3,7,1,-9,20,10]
# 默认按照从小到大的方式进行排序
# res = sorted(arr) # [-9, 1, 3, 7, 10, 20]
# 可以按照从大到小的方式进行排序
# res = sorted(arr,reverse=True) # [20, 10, 7, 3, 1, -9]
# 使用abs这个函数(求绝对值）作为sorted的key关键字参数使用
res = sorted(arr,key=abs)
# print(res)
# 使用自定义函数
# def func(num):
# print(num,num % 2)
# return num % 2
#
# arr = [3,2,4,6,5,7,9]
#
# # 在sorted函数中使用自定义函数对数据进行处理
# res = sorted(arr,key=func)
# print(res)
## 优化版
arr = [3,2,4,6,5,7,9]
res = sorted(arr,key=lambda x:x%2)
print(res)
```
### map(func, *iterables)
> 对传入的可迭代数据中的每个元素进行处理，返回一个新的迭代器
```
map(func, *iterables)
功能： 对传入的可迭代数据中的每个元素放入到函数中进行处理，返回一个新的迭代器
参数：
func 函数 自定义函数|内置函数
iterables：可迭代的数据
返回值：迭代器
```
示例：
```python
# （1）把一个字符串数字的列表转为 整型的数字列表
# ['1','2','3','4'] # ==> [1,2,3,4]
# 普通的处理方法
# varlist = ['1','2','3','4'] # ==> [1,2,3,4]
# newlist = []
# for i in varlist:
# newlist.append(int(i))
# print(newlist)
# 使用map函数进行处理
# varlist = ['1','2','3','4']
# res = map(int,varlist) # <map object at 0x104ea8890>
# print(list(res))
# (2) [1,2,3,4] ==> [1,4,9,16]
# 普通方法
# varlist = [1,2,3,4]
# newlist = []
# for i in varlist:
# res = i ** 2
# newlist.append(res)
# print(newlist)
# 使用map函数处理这个数据
varlist = [1,2,3,4]
# def myfunc(x):
# return x ** 2
# res = map(myfunc,varlist)
# print(res,list(res))
# 优化版
# res = map(lambda x:x**2,varlist)
# print(res,list(res))
# 练习作业
# (3) ['a','b','c','d'] ==> [65,66,67,68]
```
### reduce(func,iterable)
```
reduce(func,iterable)
功能：
每一次从 iterable 拿出两个元素，放入到func函数中进行处理，得出一个计算结果，
然后把这个计算结果和iterable中的第三个元素，放入到func函数中继续运算，
得出的结果和之后的第四个元素，加入到func函数中进行处理，以此类推，直到最后的元素都参与了运算
参数：
func： 内置函数或自定义函数
iterable： 可迭代的数据
返回值：最终的运算处理结果
注意： 使用 reduce函数时，需要导入 from functools import reduce
```
示例：
```python
from functools import reduce
### (1) [5,2,1,1] ==> 5211
# 普通方法
# varlist = [5,2,1,1]
# res = ''
# for i in varlist:
# res = str(i)
# res = int(res)
# print(res,type(res))
'''
5 2 1 1
5 * 10 2 == 52
52 * 10 1 == 521
521 * 10 1 == 5211
'''
# 使用 reduce完成
# def myfunc(x,y):
# return x*10 y
# varlist = [5,2,1,1]
# # 调用函数
# res = reduce(myfunc,varlist)
# print(res,type(res))
# （2） 把字符串的 '456' ==> 456
# 要求不能使用int方法进行类型的转换时，如何解决上面的问题
# 定义函数，给定一个字符串的数字，返回一个整型的数字
def myfunc(s):
vardict = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
return vardict[s]
# 1.先使用 map函数，把数字字符串，转为整型的数字
iter1 = map(myfunc,'456')
# 2. 把数字列表中的值，使用lambda进行二次处理
iter2 = reduce(lambda x,y:x*10 y,iter1)
print(iter2)
```
### filter(func,iterable)
```
filter(func,iterable)
功能： 过滤数据，把 iterable 中的每个元素拿到 func 函数中进行处理，
如果函数返回True则保留这个数据，返回False则丢弃这个数据
参数：
func 自定义函数
itereble： 可迭代的数据
返回值：保留下来的数据组成的 迭代器
```
示例：
```python
# 要求 保留所有的偶数，丢弃所有的奇数
varlist = [1,2,3,4,5,6,7,8,9]
# 普通方法实现
# newlist = []
# for i in varlist:
# if i % 2 == 0:
# newlist.append(i)
# print(newlist)
# 使用 filter 进行处理
# 定义一个函数，判断当前这个函数是否为偶数，偶数返回True，奇数返回False
# def myfunc(n):
# if n % 2 == 0:
# return True
# else:
# return False
#
# # 调用 过滤器 函数进行处理
# it = filter(myfunc,varlist)
# print(it,list(it))
# 优化版
it = filter(lambda n:True if n % 2 == 0 else False,varlist)
print(it,list(it))
```
