【一】什么是内置函数

• 内置函数就是Python给你提供的, 拿来直接用的函数
• 目前共有68个内置函数

【二】数据类型转换(8)

# 【1】整数 -- int
num = 1.0
print(num, type(num))
# 1.0 <class 'float'>
print(int(num), type(int(num)))
# 1 <class 'int'>

# 【2】浮点数 -- float
num = 1
print(num, type(num))
# 1 <class 'int'>
print(float(num), type(float(num)))
# 1.0 <class 'float'>

# 【3】字符串 -- str
num = 123
print(str(num) + '456')
# 123456

# 【4】列表 -- list
num_tuple = (1, 2, 3, 4, 5)
print(list(num_tuple))
# [1, 2, 3, 4, 5]

# 【5】字典 -- dict
user_list = [('username', 'ligo')]
print(dict(user_list))
# {'username': 'ligo'}

# 【6】元祖 -- tuple
num_list = [1, 2, 3, 4, 5]
print(tuple(num_list))
# (1, 2, 3, 4, 5)

# 【7】集合 -- set
num_list = [1, 2, 3, 4, 5, 2, 3, 4, 5]
print(set(num_list))
# {1, 2, 3, 4, 5}

# 【8】布尔 -- bool
num = 0
print(num, type(num))
# 0 <class 'int'>
print(bool(num), type(bool(num)))
# False <class 'bool'>

num = 1
print(num, type(num))
# 1 <class 'int'>
print(bool(num), type(bool(num)))
# True <class 'bool'>

【三】数学进制转换(3)

# 【1】十进制转二进制(bin)
num = 100
print(bin(num))
# 0b1100100

# 【1】十进制转八进制(oct)
num = 100
print(oct(num))
# 0o144

# 【1】十进制转十六进制(hex)
num = 100
print(hex(num))
# 0x64

【四】数学运算(8)

# 【1】获取绝对值 -- abs
num = -1
print(abs(num))  # 1

# 【2】获取商和余数 -- divmod
# divmod(被除数,除数)
num1 = 10
num2 = 3
print(divmod(num1, num2))  # (3, 1)

# 【3】四舍五入 -- round
# 如果后面的数字大于5进1
print(round(4.60))  # 5
# 如果后面的数字小于5不进1
print(round(4.40))  # 4
# 如果后面的数字等于5 5后面的数字如果大于0 进1
print(round(4.51))  # 5
# 如果后面的数字等于5 5后面的数字如果不大于0 不进1
print(round(4.50))  # 4

# 控制小数点的位数 ---> 不管是0/1都能进
# 如果后面的数字大于5进1
print(round(4.46, 1))  # 4.5
# 如果后面的数字小于5不进1
print(round(4.44, 1))  # 4.4
# 如果后面的数字等于5 5后面的数字如果大于0 进1
print(round(4.451, 1))  # 4.5
# 如果后面的数字等于5 5后面的数字如果不大于0 进1
print(round(4.450, 1))  # 4.5

# 【4】a的b次幂 -- pow
'''
参数介绍：
    x — 数值表达式(整数或者浮点数)；
    y — 数值表达式(整数或者浮点数)；
    z — 数值表达式(整数或者浮点数)，默认不设置z值；

返回值：返回 xy(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) %z；
'''
# 两个参数的是求当前的幂次方
print(pow(5, 3))  # 125
# 三个参数的时候是求完次幂后对第三个数取余
print(pow(5, 3, 2))  # 1
# 如果参数中有一个浮点数，则结果也变成浮点数
print(pow(3, 1.2))  # 3.7371928188465517

# 【5】求和 -- sum
print(sum(i for i in range(10)))  # 45

# 【6】最小值 -- min
num_list = [22, 9, 7, 13, 4, 47, 99]
print(min(num_list))  # 4

# 【7】最大值 -- max
print(max(num_list))  # 99

# 【8】复数转换 -- complex
# complex(re, im) : 具有实部 re、虚部 im 的复数。im 默认为零
start = complex(4, 6)
print(start)  # (4+6j)
end = complex(2, 9)
print(end)  # (2+9j)
print(start - end)  # (2-3j)
print(start + end)  # (6+15j)
print(start * end)  # (-46+48j)
print(start / end)  # (0.7294117647058824-0.28235294117647064j)

【五】数据结构相关

【1】序列相关(5)

# 【1】翻转 -- reversed
num_list = [1, 2, 3, 4, 5]
print(list(reversed(num_list)))  # [5, 4, 3, 2, 1]
# 不会改变原列表
print(num_list)  # [1, 2, 3, 4, 5]

# 【2】切片 -- slice
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(num_list[1:10:2])  # [2, 4, 6, 8, 10]
print(slice(1, 10, 3))  # slice(1, 10, 3)
print(num_list[slice(1, 10, 3)])  # [2, 5, 8]

# 【3】计算长度 -- len
num_list = [1, 2, 3, 4, 5]
print(len(num_list))  # 5

# 【4】排序 -- sorted
# 语法：sorted(可迭代对象, key=函数(排序规则), reverse=False)
# reverse: 是否是倒叙. True: 倒叙, False: 正序
# sorted() 对可迭代对象进行排序操作 (lambda)
# (1)sort方法
num_list = [9, 23, 1, 55, 12, 5, 3, 6, 40]
num_list.sort()
print(num_list)  # [1, 3, 5, 6, 9, 12, 23, 40, 55]
# (2)sorted:会生成一个新列表
print(sorted(num_list))  # [1, 3, 5, 6, 9, 12, 23, 40, 55]
#    倒序
print(sorted(num_list, reverse=True))  # [55, 40, 23, 12, 9, 6, 5, 3, 1]

# (3)根据字符串长度给列表排序
str_list = ['one', 'two', 'three', 'four', 'five', 'six']


def f(s):
    return len(s)


print(sorted(str_list, key=f))  
# ['one', 'two', 'six', 'four', 'five', 'three']
print(sorted(str_list, key=lambda s: len(s)))  
# ['one', 'two', 'six', 'four', 'five', 'three']
print(sorted(str_list, key=lambda s: len(s), reverse=True))  
# ['three', 'four', 'five', 'one', 'two', 'six']

# 【5】枚举 -- enumerate
num_list = [i for i in range(5)]
# 把索引和元素一起获取,索引默认从0开始. 可以更改
for index, data in enumerate(num_list):
    print(f"{index}:{data}")
# 0:0
# 1:1
# 2:2
# 3:3
# 4:4
# 将索引改为2
for index, data in enumerate(num_list, 2):
    print(f"{index}:{data}")
# 2:0
# 3:1
# 4:2
# 5:3
# 6:4

【2】字符串(4)

# 【1】格式化输出 -- format
# format() 与具体数据相关, 用于计算各种小数, 精算等
# (1)居中对齐方式
s = "hello world!"
print(format(s, "^20"))  # 居  中
#     hello world!
print(format(s, "<20"))  # 左对齐
# hello world!
print(format(s, ">20"))  # 右对齐
#         hello world!
# (2)进制转换
print(format(6, 'b'))  # 二进制:110
print(format(90, 'c'))  # 转换成unicode字符:Z
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
# (3)科学计数法
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
print(bytes('very good', 'utf8'))
# b'very good'
print(bytes('你真棒', 'utf8'))
# b'\xe4\xbd\xa0\xe7\x9c\x9f\xe6\xa3\x92'

# 【3】获取字节数组 -- bytearray
# 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)
res = bytearray("ligo", encoding='utf8')
print(res[1])  # 105
print(res)  # bytearray(b'ligo')
res[1] = 70
print(str(res))  # bytearray(b'lFgo')

# 【4】返回对象的字符串格式 -- repr
# repr() 返回一个对象的string形式
word = "今天\n吃了%s顿\t饭" % 10
print(word)
# 今天
# 吃了10顿	饭

# 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
print(repr(word))
# '今天\n吃了10顿\t饭'

【3】字符编码(3)

# 【1】字符编码找数字 -- ord
# ord() 输入字符找带字符编码的位置
print(ord("x"))  # 120
print(ord("强"))  # 24378

# 【2】数字找字符编码 -- chr
# chr() 输入位置数字找出对应的字符
print(chr(73))  # I
print(chr(24533))  # 忕

# 【3】数字找ASCII码 -- ascii
# ascii() 是ascii码中的返回该值 不是就返回u
for i in range(65536):
    print(chr(i), end=" ")

print(ascii("@"))  # '@'

【4】数据集合

• frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作

# frozenset() 函数返回一个不可变的 frozenset 对象，适用于作为字典的键或集合的元素
set_add = {1, 2, 3, 4}
set_add.add(5)
print(set_add)
# 正常的集合是可以添加元素的
num_set = frozenset([1, 2, 3, 4, 5])
print(num_set)

【5】条件判断(2)

# 【1】所有为真 -- all
# all() 可迭代对象中全部是True, 结果才是True
print(all([1, 'ligo', 666, True]))  # True
print(all([0, 'ligo', 666, True]))  # False

# 【2】任意为真 -- any
# any() 可迭代对象中有一个是True, 结果就是True
print(any([0, 'ligo', 0, False]))  # True

【6】高阶函数(3)

（1）打包 -- zip

• zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
• 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同

lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']

print(zip(lst1, lst2, lst3))
# <zip object at 0x00000229D7EDC140>
print(list(zip(lst1, lst2)))
# [(1, '醉乡民谣'), (2, '驴得水'), (3, '放牛班的春天'), (4, '美丽人生'), (5, '辩护人'), (6, '被嫌弃的松子的一生')]
print(list(zip(lst1, lst3)))
# [(1, '美国'), (2, '中国'), (3, '法国'), (4, '意大利'), (5, '韩国')]
print(list(zip(lst1, lst2, lst3)))
# [(1, '醉乡民谣', '美国'), (2, '驴得水', '中国'), (3, '放牛班的春天', '法国'), (4, '美丽人生', '意大利'), (5, '辩护人', '韩国'), (6, '被嫌弃的松子的一生', '日本')]

（2）过滤 -- filter

• 语法：fiter(用来筛选的函数. 可迭代对象)
• 用来过滤可迭代类型,只保留符合条件的数据
• filter() 过滤 (lambda)

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]


def func(i):
    return i % 2 == 0 #判断偶数


print(filter(func, num_list))  # <filter object at 0x00000270F5419E70>
print(list(filter(func, num_list)))  # [2, 4, 6, 8]
print(list(filter(lambda i: i % 2, num_list)))  # [1, 3, 5, 7, 9]

（3）映射 -- map

• 语法：map(用来筛选的函数. 可迭代对象)
• 映射函数将可迭代类型中的每一个元素作为参数传递给前面的函数
• map() 会根据提供的函数对指定序列列做映射(lambda)

# 把可迭代对象中的每一个元素传递给前面的函数进行处理，处理的结果会返回成迭代器
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]


def func(i):
    return i


print(map(func, num_list))  # <map object at 0x0000016DB825B0D0>
print(list(map(func, num_list)))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(map(lambda i: i, num_list)))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

【六】作用域(2)

# locals() 返回当前作用域中的名字
# globals() 返回全局作用域中的名字
a = 10


def func():
    b = 11
    print(f'{locals()}')
    # 当前作用域：{'b': 11}
    print(f'{globals()}')
    # 全局作用域：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000022065A748B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\Python\\pythonProject\\pythonProject1\\demo7.py', '__cached__': None, 're': <module 're' from 'D:\\lib\\re.py'>, 'a': 10, 'func': <function func at 0x00000220659B3E20>}


func()

【七】迭代器生成器(3)

# 【1】循环生成数据 -- range
print(range(1, 10))
# range(1, 10)
print([i for i in range(10)])
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 【2】获取迭代器 -- iter
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(iter(num_list))  # <list_iterator object at 0x000001106AC149D0>

# 【3】向下执行 -- next
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
res = iter(num_list)
print(next(res))  # 1
print(next(res))  # 2
print(next(res))  # 3
print(next(res))  # 4
print(next(res))  # 5

【八】字符串类型代码的执行(3)

# 【1】指定指令并返回结果 -- eval
num_str = input("请输入数据：").strip()
print(eval(num_str))
# 请输入数据：1+1
# 2

# 【2】指定指令不返回结果 -- exec
num_str = input("请输入数据：").strip()
print(exec(num_str))
# 请输入数据：1+1
# None -- 不返回任何结果

# 执行指令,exec允许执行多行代码块，但是eval只能执行单行代码
name_str = '''
def func():
    print('我是ligo')
func()
'''
print(exec(name_str))
# 我是ligo
# None
print(eval(name_str)) # SyntaxError: invalid syntax

# 【3】编码指令 -- compile
# compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
code_str_one = 'print([i for i in range(10) if i % 2 == 0])'
code_str = '''
def add(x,y):
    print(x+y)
add(1,5)
'''
code_eval = compile(code_str_one, '', mode="eval")
eval(code_eval)  # [0, 2, 4, 6, 8]
code_exec = compile(code_str, '', mode='exec')
exec(code_exec)  # 6

exec(code_eval)  # [0, 2, 4, 6, 8]
eval(code_exec)  # 6

【九】输入输出(2)

• print() : 打印输出
• input() : 获取用户输出的内容

【十】算法

• hash() :获取到对象的哈希值(int, str, bool, tuple)

name = 'ligo'
print(hash(name))
# -1977231548399644595
# 注意：列表是不可以哈希的
#hash算法:目的是唯一性，dict查找效率非常高

【十一】文件操作

#open() : 用于打开一个文件, 创建一个文件句柄
fp = open('file','r',encoding='utf-8')
fp.read()

【十二】导入模块

# 【1】
import 函数名

# 【2】__ import__() : 用于动态加载类和函数
name = input("请输入你要导入的模块:")
json = __import__(name)
# 可以动态导入模块
print(json.dumps({"name": "dream"}))

# {"name": "dream"}

【十三】帮助函数

# help() : 函数用于查看函数或模块用途的详细说明
print(help(str)) 

【十四】调度相关

# callable() : 用于检查一个对象是否是可调用的
a = 10


def name():
    print('ligo')


# 变量a不能被调用
print(callable(a))  # False
# 函数是可以被调用的
print(callable(name))  # True

【十五】查看内置属性

• dir() :查看对象的内置属性

• 访问的是对象中的 __dir__() 方法

print(dir(list))
# ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

【十六】调试器(breakpoint)

• 语法：breakpoint(*args, **kws)`
• *args, **kws---不定长参数

count = 0
while count <= 5:
    breakpoint()
    count += 1
    print(count)

【十七】判断你内存空间地址(id)

• id()函数返回该对象的内存地址，每个对象都有一个唯一的内存地址

print(id(1))  # 2979228942576
print(id('ligo'))  # 2979230255920