【内置函数】

三元表达式

三元表达式是为了简化代码，一般二选一的时候推荐使用三元表达式
例子：如果输入名字为"Jason"则输出管理员，否则输出其他
三元表达式
值1 if 条件 else 值2
条件如果成立则使用值1(if前面的数据)
条件如果不成立则使用值2(else后面的数据)

# 如果是jason输出管理员，否则输出其他
# 方式一
name = input('请输入').strip()
if name == 'jason':
    print('管理员')

else:
    print('其他')
# 三元表达式
name = input('请输入').strip()
res = '管理员' if name == 'jason' else '其他'
print(res)

生成式

1. 列表生成式
   列表生成式的结构是在一个中括号里包含一个表达式,然后是一个for语句,然后是0个或多个for或者if语句。列表表达式可以是任意的,意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表,在这个以if和for语句为上下文的表达式运行完成之后产生。
   例子：

# 生成一个列表，列表元素分别为 [1*1,2*2,3*3……n*n]，假设n = 10。
# 一般的方法
# 创建一个空列表
l1 = []
for i in range(1,11):
    l1.append(i * i)

print(l1)

# 列表生成器
l1 = [i * i for i in range(1,11)]
print(l1)

2. 字典生成式
跟列表生成式一样，字典生成式用来快速生成字典,不同的是，字典需要两个值

# 2.字典生成式
l1 = ['name', 'age', 'pwd']
l2 = ['jason', 18, 123]
# 需求:将上述两个列表分别制作成字典的键值
# 1.定义一个空字典
new_dict = {}
# 2.每次循环都要拿到两个列表中对应的元素(索引相等)
for i in range(len(l1)):
# 3.索引取值即可
    new_dict[l1[i]] = l2[i]
print(new_dict)
# 字典生成式
res = {l1[i]: l2[i] for i in range(len(l1))}
print(res)  # {'name': 'jason', 'age': 18, 'pwd': 123}
res = {l1[i]: l2[i] for i in range(len(l1)) if i == 1}
print(res)  # {'age': 18}

3. 集合生成式
   集合生成式格式和列表生成式类似，不过用的是大括号：

res = {i for i in range(10)}
print(res)

注意：元祖没有生成式

匿名函数

匿名函数的意思就是没有函数名
没有函数名骂我们要怎么点用它？
需要结合其他函数一起使用
匿名函数的定义：lambda 形参:返回值

lambda x:x+2

关键字lambda表示匿名函数，冒号前面的x表示函数参数，可以有多个参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

有些函数在代码中只用一次，而且函数体比较简单，使用匿名函数可以减少代码量，看起来比较"优雅“

内置函数

内置函数就是Python给你提供的，拿来直接用的函数，比如print.，input等。

bool : 布尔型(True,False)
int : 整型(整数)
float : 浮点型(小数)
complex : 复数
进制转换
bin() 将给的参数转换成二进制
otc() 将给的参数转换成八进制
hex() 将给的参数转换成十六进制

print(bin(10))  # 二进制:0b1010
print(hex(10))  # 十六进制:0xa
print(oct(10))  # 八进制:0o12

数学运算
abs() 返回绝对值
divmode() 返回商和余数
round() 四舍五入
pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
sum() 求和
min() 求最小值
max() 求最大值

print(abs(-2))  # 绝对值:2
print(divmod(20,3)) # 求商和余数:(6,2)
print(round(4.50))   # 五舍六入:4
print(round(4.51))   #5
print(pow(10,2,3))  # 如果给了第三个参数. 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10]))  # 求和:55
print(min(5,3,9,12,7,2))  #求最小值:2
print(max(7,3,15,9,4,13))  #求最大值:15

list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
常见的可迭代对象包括：
a) 集合数据类型，如list、tuple、dict、set、str等；
b) 生成器(generator)，包括生成器和带yield的生成器函数(generator function)

str() 将数据转化成字符串

reversed() 将一个序列翻转, 返回翻转序列的迭代器
slice() 列表的切片

bytes() 把字符串转化成bytes类型

s = '你好啊 hello world!'
print(s.encode('utf8'))  # b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x95\x8a hello world!'
print(bytes(s, 'utf8'))  # b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x95\x8a hello world!'
'''针对编码解码 可以使用关键字encode与decode  也可以使用bytes和str'''

ord() 输入字符找带字符编码的位置
chr() 输入位置数字找出对应的字符
ascii() 是ascii码中的返回该值 不是就返回

print(ord('a'))  # 字母a在编码表中的码位:97
print(ord('中'))  # '中'字在编码表中的位置:20013

print(chr(65))  # 已知码位,求字符是什么:A
print(chr(19999))  #丟

for i in range(65536):  #打印出0到65535的字符
    print(chr(i), end=" ")

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

repr() 返回一个对象的string形式

字典：dict 创建一个字典
集合：set 创建一个集合
frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。

len() 返回一个对象中的元素的个数
sorted() 对可迭代对象进行排序操作 (lamda)
语法：sorted(Iterable, key=函数(排序规则), reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序

lst = [5,7,6,12,1,13,9,18,5]
lst.sort()  # sort是list里面的一个方法
print(lst)  #[1, 5, 5, 6, 7, 9, 12, 13, 18]

ll = sorted(lst) # 内置函数. 返回给你一个新列表  新列表是被排序的
print(ll)  #[1, 5, 5, 6, 7, 9, 12, 13, 18]

l2 = sorted(lst,reverse=True)  #倒序
print(l2)  #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
    return len(s)
l1 = sorted(lst, key=f, )
print(l1)  #['one', 'two', 'six', 'four', 'five', 'three']

enumerate() 获取集合的枚举对象

lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1):    # 把索引和元素一起获取,索引默认从0开始. 可以更改
    print(index)
    print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five

all() 可迭代对象中全部是True, 结果才是True
any() 可迭代对象中有一个是True, 结果就是True
（跟and和or）

print(all([1,'hello',True,9]))  #True
print(any([0,0,0,False,1,'good']))  #True

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

l1 = [11, 22, 33, 44]
l2 = ['jason','kevin','tony','oscar']
# 需求:将两个列表中的元素一一对应成对即可
res = zip(l1,l2)  # 结果是一个迭代器
print(res)  # 目前想看里面的数据 用list转换一下即可
print(list(res))  # [(11, 'jason'), (22, 'kevin'), (33, 'tony'), (44, 'oscar')]
'''zip可以整合多个数据集'''
l1 = [11, 22, 33, 44]
l2 = ['jason','kevin','tony','oscar']
l3 = [1,2,3,4]
l4 = [55,66,77,88]
res = zip(l1,l2,l3,l4)
print(list(res))
# 不使用zip也可以
res1 = [(l1[i],l2[i],l3[i],l4[i]) for i in range(len(l1))]
print(res1)
'''zip可以整合多个数据集 如果数据集之间个数不一致 那么依据短的'''
# l1 = [11, 22, 33, 44, 55]
# l2 = ['jason', 'kevin']
# res = zip(l1,l2)
# print(list(res))

fiter() 过滤 (lamda)
语法：fiter(function. Iterable)
function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象

def func(i):    # 判断奇数
    return i % 2 == 1
    lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst)  #l1是迭代器
print(l1)  #<filter object at 0x000001CE3CA98AC8>
print(list(l1))  #[1, 3, 5, 7, 9]

map() 会根据提供的函数对指定序列列做映射(lamda)
语法 : map(function, iterable)

def f(i):    return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it))  #[1, 2, 3, 4, 5, 6, 7]

可以对可迭代对象中的每一个元素进行映射. 分别去执行 function

reduce函数
reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(func,[1,2,3]) 等同于 func(func(1,2),3)

对于序列内所有元素进行累计操作

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

def func():
    a = 10
    print(locals())  # 当前作用域中的内容
    print(globals())  # 全局作用域中的内容
    print("今天内容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': 
# <_frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080>, 
# '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' 
# (built-in)>, '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,
#  'func': <function func at 0x0000026F8D6B97B8>}
# 今天内容很多

range() 生成数据
next() 迭代器向下执行一次, 内部实际使⽤用了__ next__()⽅方法返回迭代器的下一个项目
iter() 获取迭代器, 内部实际使用的是__ iter__()⽅方法来获取迭代器

for i in range(15,-1,-5):
    print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst)  #  __iter__()获得迭代器
print(it.__next__())  #1
print(next(it)) #2  __next__()  
print(next(it))  #3
print(next(it))  #4

eval() 执行字符串类型的代码. 并返回最终结果
exec() 执行字符串类型的代码
compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值

# print('print("有点饿了")')
# eval('print("有点饿了111")')
# exec('print("有点饿了222")')
res = """
for i in range(10):
    print(i)
"""
# eval(res)  只能识别简单逻辑的python代码
# exec(res)  能够识别具有与一定逻辑的python代码
# ps:课外扩展 可以百度搜一搜两者的实际应用

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

open() : 用于打开一个文件, 创建一个文件句柄

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

print(help(str))  #查看字符串的用途

callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功

a = 10
print(callable(a))  #False  变量a不能被调用
#
def f():
    print("hello")
    print(callable(f))   # True 函数是可以被调用的

dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法

print(dir(123))
print(dir('jason'))