【一】什么是内置函数
内置函数就是python提供的可以直接拿来用的函数，例如print,input
【二】数据类型转换（8）
【1】数字类型转换
（1）整数类型转换（int）
int : 整型(整数)
# int(x) : x 转换为整数 res = '1' print(res, type(res)) # 1 <class 'str'> # 将可以转换为整数的类型转换为整数 res_int = int(res) print(res_int, type(res_int)) # 1 <class 'int'>
（2）浮点数类型转换(float)
float : 浮点型(小数)
# float(x) : x 转换为浮点数 start = 1 print(start, type(start)) # 1 <class 'int'> start_float = float(start) print(start_float, type(start_float)) # 1.0 <class 'float'>
【2】字符串类型转换（str）
str() 将数据转化成字符串
print(str(123)+'456') #123456
【3】布尔类型转换(bool)
bool: 布尔类型(True / False)
# True / False res = 1 print(res, type(res)) # 1 <class 'int'> res_bool = bool(res) print(res_bool, type(res_bool)) # True <class 'bool'> res = 0 print(res, type(res)) # 0 <class 'int'> res_bool = bool(res) print(res_bool, type(res_bool)) # False <class 'bool'>
【4】列表类型转换(list)
list() 将一个可迭代对象转换成列表
print(list((1,2,3,4,5,6))) # [1, 2, 3, 4, 5, 6]
【5】元祖类型转换(tuple)
tuple() 将一个可迭代对象转换成元组
print(tuple([1,2,3,4,5,6])) # (1, 2, 3, 4, 5, 6)
【6】字典类型转换(dict)
字典：dict 创建一个字典
注释:
dict()函数可接受可迭代对象，用键值对初始化字典。
# 示例
dictionary = dict([(1, 'one'), (2, 'two'), (3, 'three')])
print(dictionary)
# 输出：{1: 'one', 2: 'two', 3: 'three'}
【7】集合类型转换(set)
集合：set 创建一个集合
注释:
set()函数用于创建一个集合，自动去除重复元素。
# 示例
my_set = set([1, 2, 3, 3, 4, 5])
print(my_set)
# 输出：{1, 2, 3, 4, 5}
【三】进制换行（3）
【1】十进制转二进制（bin）
bin() 将给的参数转换成二进制
number = 15 # 十进制转二进制 number_bin = bin(number) print(number_bin) # 0b1111
【2】十进制转八进制（oct）
oct() 将给的参数转换成八进制
number = 15 # 十进制转八进制 number_oct = oct(number) print(number_oct) # 0o17
【3】十进制转十六进制(hex)
hex() 将给的参数转换成十六进制
number = 10 # 十进制转十六进制 number_hex = hex(number) print(number_hex) # 0xa
【四】数学运算（8）
（1）获取绝对值（abs）
abs() 返回绝对值
number = -1 # 获取当前整数的绝对值 number_abs = abs(number) print(number_abs) # 1
（2）获取商和余数（divmod）
divmod() 返回商和余数
number_start = 9 number_end = 4 # (被除数，除数) result = divmod(number_start, number_end) print(result) # (2, 1) number_discuss, number_remainder = divmod(number_start, number_end) print(number_discuss) # 2 print(number_remainder) # 1
（3）四舍五入(round)
round() 四舍五入
给定数字的四舍五入版本，有指定的小数位数。
默认情况下，小数点的数量是0。
因此，如果你调用 round() 时没有第二个参数，该函数将返回最近的整数。
# 我们可以看到，对 4.51 的值为 5 print(round(4.51)) # 我们可以看到，对 4.50 的值为 4 print(round(4.50)) # 我们可以看到，对 4.49 的值为 4 print(round(4.49))
# 这一次我们在 round() 函数中加入了可选的第二个参数。 # 这里我们把 作为第一个参数，把 1 作为第二个参数。 # 我们可以看到，对 4.051 的值为 4.1 print(round(4.051, 1)) # 我们可以看到，对 4.050 的值为 4.0 print(round(4.050, 1)) # 我们可以看到，对 4.049 的值为 4.0 print(round(4.049, 1))
# 这一次我们在 round() 函数中加入了可选的第二个参数。 # 这里我们把 作为第一个参数，把 2 作为第二个参数。 # 我们可以看到，对 4.0051 的值为 4.01 print(round(4.0051, 2)) # 我们可以看到，对 4.0050 的值为 4.0 print(round(4.0050, 2)) # 我们可以看到，对 4.0049 的值为 4.0 print(round(4.0049, 2))
（4）a的b次幂（pow）
pow(a,b)求a的b次幂，如果有三个参数，则求完次幂以后对第三数取余
'''
参数介绍：
x — 数值表达式(整数或者浮点数)；
y — 数值表达式(整数或者浮点数)；
z — 数值表达式(整数或者浮点数)，默认不设置z值；
返回值：返回 xy(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) %z；
'''
pow(x, y[, z])
pow函数常规使用
print(pow(2,5)) # 等价 2*2*2*2*2 = 32 print(pow(2,3)) # 等价 2*2*2 = 8 print(pow(2,3,5)) # 等价 2*2*2%5 = 8 % 5 = 3 print(2*2*2%5) # 等价 pow(2,3,5) = 3
pow函数所有的参数必须是数值类型
print(pow(2,'2')) ''' TypeError: unsupported operand type(s) for ** or pow(): 'int' and 'str' '''
若x，y中有一个是浮点数，那么结果也会转换为浮点数
print(pow(2,3.2)) print(pow(2,3.0)) # 9.18958683997628 # 8.0
（5）求和（sum）
print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55
（6）最小值（min）
min() 求最小值
print(min(5,3,9,12,7,2)) # 求最小值:2
（7）最大值（max）
max() 求最大值
print(max(7,3,15,9,4,13)) # 求最大值:15
（8）复数转换（complex）
complex : 复数
# complex(re, im) : 具有实部 re、虚部 im 的复数。im 默认为零。 start = complex(3, 4) print(start) # (3+4j) second = complex(5, 9) print(second) # (5+9j) res = start + second print(res) # (8+13j)
【五】数据结构相关（18）
【1】序列相关（5）
（1）翻转（reversed）
reversed() 将一个序列翻转, 返回翻转序列的迭代器
lst = "你好！" # 不会改变原列表，返回一个迭代器 se = reversed(lst) print(list(se)) # ['！', '好', '你']
（2）切片（slice）
slice()列表的切片
lst = [1, 2, 3, 4, 5, 6, 7] # 第一个是起始位置，第二个是结束位置，第三个是步长（默认跳过起始位置） print(lst[2:4:1]) s = slice(1, 5, 2) print(lst[s])
（3）计算长度(len)
len() 返回一个对象中的元素的个数
（4）排序（sorted）
语法：sorted(Iterable, key=函数(排序规则), reverse=False)
lterable：可迭代对象
key：排序规则（排序函数），在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse:是否是倒序，True：倒序，False：正序
sorted()对可迭代对象进行排序操作（lamda）
list_ = [5,9,7,8,3,2,6] list_.sort() print(list_) # 内置函数，返回了一个新列表 且被排序了 l1 = sorted(list_) print(l1) # [2, 3, 5, 6, 7, 8, 9] # 倒序 l2 = sorted(list_,reverse=True) print(l2) # [9, 8, 7, 6, 5, 3, 2]
根据字符串长度给列表排序
list_ = ['one','two','three','four','five']
def f(s):
return len(s)
l1 = sorted(list_,key=f)
print(l1) # ['one', 'two', 'four', 'five', 'three']
（5）枚举（enumerate）
enumerate()获取集合的枚举对象
list_ = ['one','two','three','four','five']
for index, el in enumerate(list_,1): # list_是列表，数字1表示从数字1起始枚举可以改起始数字
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
【2】字符串（4）
（1）格式化输出（format）
对齐方式
ki = "hello world" # 居中 print(format(ki,"^20")) # hello world # 左对齐 print(format(ki, "<20")) # hello world # 右对齐 print(format(ki, ">20")) # hello world
进制转换
print(format(3, 'b')) # 二进制:11 print(format(97, 'c')) # 转换成unicode字符:a print(format(11, 'd')) # ⼗进制:11 print(format(11, 'o')) # 八进制:13 print(format(11, 'x')) # 十六进制(⼩写字母):b print(format(11, 'X')) # 十六进制(大写字母):B print(format(11, 'n')) # 和d⼀样:11 print(format(11)) # 和d⼀样:11
科学计数法
print(format(123456789, 'e')) # 科学计数法. 默认保留6位小数:1.234568e+08 print(format(123456789, '0.2e')) # 科学计数法. 保留2位小数(小写):1.23e+08 print(format(123456789, '0.2E')) # 科学计数法. 保留2位小数(大写):1.23E+08 print(format(1.23456789, 'f')) # 小数点计数法. 保留6位小数:1.234568 print(format(1.23456789, '0.2f')) # 小数点计数法. 保留2位小数:1.23 print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数:1.2345678900 print(format(1.23456789e+3, 'F')) # 小数点计数法. 很大的时候输出INF:1234.567890
（2）字符串转bytes
bytes() 把字符串转化成bytes类型
bs = bytes("今天吃饭了吗", encoding="utf-8")
print(bs)
# b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
（3）获取字节数组（bytearray）
bytearray()
返回一个新字节数组，这个数字的元素是可变的，并且每一个元素的值范围是[0,256]
ret = bytearray("knight",encoding="utf-8")
# 输出第零个字符的ASCII码值
print(ret[0]) # 107
# 输出修改前的字符串
print(ret) # bytearray(b'knight')
# 将ASCII码第66位置的B值，赋给ret字符串中的第零个字符
ret[0] = 66
# 输出修改后的字符串
print(str(ret)) # bytearray(b'Bnight')
（4）返回对象的字符串格式（repr）
repr() 返回一个对象的string形式
word = "今天\n吃了%s顿\t饭" % 3 print(word) # 原样输出，过滤掉转义字符\n \t \r 不管百分号% print(repr(word)) # 今天 # 吃了3顿 饭 # '今天\n吃了3顿\t饭'
【3】字符编码（3）
（1）字符编码找数字（ord）
ord() 输入字符找代字符编码的位置
print(ord('A')) # 65
print(ord('国')) # 22269
（2）数字找字符编码（chr）
chr()输入位置数字找出对应的字符
print(chr(65)) # A print(chr(52099)) # 쮃
（3）数字转ASCII码
ascii() 是ASCII码中的值就会返回，如果不是就会返回u
for i in range(6): # 打印出0-6的字符
print(chr(i), end="")
print(ascii("@")) # '@'
【4】数据集合（1）
创建一个冻结的集合 （frozenset）
feozenset() 创建了一个冻结的集合，冻结的集合不能进行添加和删除操作
注释:
frozenset()函数返回一个不可变的 frozenset 对象，适用于作为字典的键或集合的元素。
frozen_set = frozenset([1,2,3,4])
print(frozen_set)
# frozenset({1, 2, 3, 4})
【5】判断条件（2）
（1）所有为真（all）
all()可迭代对象中全部是True，结果才是True
print(all([1,'hello',True,0])) # False print(all([1,'hello',True])) # True
（2）任意为真（any）
any()可迭代对象中有一个是True，结果即True
print(any([1,'hello',True,0])) # True
【6】高阶函数（3）
（1）打包（zip）
zip() 函数
用于将可迭代的对象作为参数
将对象中对应的元素打包成一个元组
然后返回到，由这些元组组成的列表中
如果各个迭代器的元素个数不一致，则返回的列表长度与元素个数最少的相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst1, lst3)) # <zip object at 0x00000256CA6C7A88>
for el in zip(lst1, lst2, lst3):
print(el)
# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
# (6, '被嫌弃的松子的一生', '日本')
列表3中少了一个"日本"元素，输出时就按照最少的元素个数输出。
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国']
print(zip(lst1, lst1, lst3)) # <zip object at 0x00000256CA6C7A88>
for el in zip(lst1, lst2, lst3):
print(el)
# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
（2）过滤（filter）
语法：fiter(function. iterable)
function: 用来筛选的函数.
在filter中会自动的把iterable中的元素传递给function.
然后根据function返回的True或者False来判断是否保留留此项数据
Iterable: 可迭代对象
filter() 过滤 (lamda)
def func(i):
return i % 2 == 1
list_ = [1,2,3,4,5,6,7,8,9,10]
l1 = filter(func, list_)
print(l1) # <filter object at 0x0000018E16EC6050>
print(list(l1)) # [1, 3, 5, 7, 9]
（3）映射（map）
语法 : map(function, iterable)
可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
map() 会根据提供的函数对指定序列列做映射(lamda)
def f(i):
return i
list_ = [1,2,3,4,5,6,7,8,9]
# 把可迭代对象中的每一个元素传递给前面的函数进行处理.
# 处理的结果会返回成迭代器print(list(it))
it = map(f,list_)
print(it) # <map object at 0x0000017FD5BE6050>
# 如果要查看 map 的结果需要用 list 强转
print(list(it)) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
【六】作用域（2）
locals() 返回当前作用域中的名字
globals() 返回全局作用域中的名字
name = "knight"
def func():
a = 6
# 当前作用域中的内容
print(f"这是当前作用域中的内容 :>>>> {locals()}")
# 全局作用域中的内容
print(f"这是全局作用域中的内容 :>>>> {globals()}")
print("我是函数func内部")
func()
# 这是当前作用域中的内容 :>>>> {'a': 6}
# 这是全局作用域中的内容 :>>>> {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000219FC164940>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'H:\\pycharm projects\\day\\高阶函数\\内置函数.py', '__cached__': None, 'number_start': 9, 'number_end': 4, 'result': (2, 1), 'name': 'knight', 'func': <function func at 0x00000219FC1CB640>}
# 我是函数func内部
【七】迭代器
【1】循环生成数据（range）
range() 生成数据
print(range(1,10)) # range(1, 10) print([i for i in range(1,10)]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
【2】获取迭代器（iter）
iter()
获取迭代器，内部实际使用的是
__iter__方法来获取迭代器
list_ = [1,2,3,4,5] # __iter__()获得迭代器 it = iter(list_) print(it) # <list_iterator object at 0x0000022432258220>
【3】向下执行（next）
next()
迭代器向下执行一次，内部实际使用了
__next__()方法返回迭代器的下一个项目
list_ = [1,2,3,4,5] # 获得迭代器 it = iter(list_) print(it) # <list_iterator object at 0x000001B0F003A800> print(next(it)) # 1 print(next(it)) # 2 print(next(it)) # 3 print(next(it)) # 4 print(next(it)) # 5
【八】字符串类型代码的执行（3）
【1】指定指令并返回结果(eval)
eval()执行字符串类型的代码，并返回最终结果
s1 = input("请输入a*b：")
# 2*2
print(eval(s1))
# 4
【2】指定指令不返回结果（exec）
s2 = "for i in range(6):print(i)"
# exec 执行代码不返回任何内容
a = exec(s2)
# 0
# 1
# 2
# 3
# 4
# 5
print(a) # None
# 动态执行代码
exec("""
def func():
print("wszjl")
""")
func() # wszjl
【3】编码指令
compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
code = "for i in range(3): print(i)" # comile 不会执行代码，只是编译 com = compile(code,"",mode="exec") # 执行编译的结果 exec(com) # 0 # 1 # 2
code2 = "5+6+7" com2 = compile(code2, "", mode="eval") print(eval(com2)) # 18
code3 = "name = input('请输入你的名字:')"
# 输入:knight
com3 = compile(code3, "", mode="single")
exec(com3)
print(name) # knight
【九】输入输出（2）
print():打印输出
input():获取用户输出的内容
【十】算法（1）
hash() :
获取到对象的哈希值(int, str, bool, tuple).
k = 'knight' print(hash(k)) # -2046328051854413876
列表不允许hash
lst = [1, 2, 3, 4, 5] print(hash(lst)) # 报错,列表是不可哈希的 # TypeError: unhashable type: 'list'
hash算法:
(1) 目的是唯一性
(2) dict 查找效率非常高
hash表：
用空间换的时间 比较耗费内存
【十一】文件操作（1）
open(): 用于打开一个文件，创建一个文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()
【十二】导入模块（1）
# 让用户输入一个要导入的模块
name = input("请输入要导入的模块：")
json = __import__(name)
# 可以动态导入模块
print(json.dumps({"name":"knight"}))
# {"name":"knight"}
【十三】帮助（1）
help():函数用于查看函数或模块用途的详细说明
# 查看字符串的用途 print(help(str))
【十四】调度相关（1）
callable():用于检查一个对象是否可调用的
如果返回True，object有可能调用失败
如果返回False，那么一定不会调用成功
a = 6
# 变量a不能被调用
print(callable(a))
# False
def f():
print("knight")
print(callable(f))
# True
【十五】查看内置属性（1）
dir():
查看对象的内置属性
访问的是对象中的
__dir__()方法
# 查看元组的方法 print(dir(tuple))
