python之内置函数

作用域相关 *****

• globals(): 返回一个字典：包含全部的全局变量。
• locals() ：返回一个字典：包含的是当前作用域的所有的变量

# b = 2
# def func():
#     a = 1
#     print(locals())
#     print(globals())
#
# func()

字符串类型代码的执行 eval, exec, compile 不建议使用***
eval: 执行字符串类型的代码，并返回最终结果

s1 = '1+2+3'
print(s1) #1+2+3
print(eval(s1),type(eval(s1))) # 6 <class 'int'>
s2 = "{'name':'alex'}"
print(eval(s2),type(eval(s2)))  # {'name': 'alex'} <class 'dict'>

exec：执行字符串类型的代码，不返回结果。 代码流

s3 = '''for i in range(3):
    print(i)
'''
# print(exec(s3))
exec(s3)

compile: 将字符串类型的代码编译。代码对象能够通过eval或exec进行求值

输入输出相关 input ，print *****

• input: 函数接受一个标准输入数据，返回为string类型
• print:打印输出

print(*[1,2,3])  # 1 2 3
def func2(*args): # 函数的定义：*聚合
    print(*args)  # (*(1,2,3))  函数的执行： *打散 print(1,2,3)


func2(1,2,3)   # 1 2 3

# sep 打印多个内容时 分隔符默认是空格
print(1,2,3,sep='|')  #1|2|3
# end 默认换行
print(1, end=' ')
print(222)
# file
with open('t1', encoding='utf-8',mode='w') as f:
    print(666,file=f)

内存相关hash id ***
hash:获取一个对象（可哈希对象：int，str， bool， tuple）的哈希值
id：获取该对象的内存地址
hash()
字典：会将你所有的key在内存中转化成id

dic = {'name':'alex', 'sdkfdsg':'123'}
print(hash('name'))  # 对于字符串的内存地址为，等长度的地址
print(hash('hsdfjsdj'))
print(hash(1))
print(hash(888))  # 对于数字就返回888

文件操作相关 *****
　　open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
模块相关__import__　***
　　__import__：函数用于动态加载类和函数 。
帮助**
　　help：函数用于查看函数或模块用途的详细说明

print(help(list))

　　

调用相关***
　　callable：函数用于检查一个对象是否是可调用的。
如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

name = 'alex'
def func1():
    pass
print(callable(name))  # False
print(callable(func1)) # True

查看内置属性 ***
　　dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__di
该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

name = 'alex'
print(dir(name))

　　

range：函数可创建一个整数对象，一般用在 for 循环中。
python2x:range(3)--->[0, 1, 2]
xrange(3)--->迭代器
python3x:range(3)--->range(0, 3) 可迭代对象
　　next：内部实际使用了__next__方法，返回迭代器的下一个项目。
　iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。

进制转换：

　　　　bin：将十进制转换成二进制并返回。

　　　　oct：将十进制转化成八进制字符串并返回。

　　　　hex：将十进制转化成十六进制字符串并返回。

print(bin(100)) # 0b1100100
print(oct(100))  # 0o144
print(oct(7))  # 0o7
print(oct(8))  # 0o10
print(hex(100))  # 0x64
print(hex(10))  # 0xa

　　

数学运算：

　　　　abs：函数返回数字的绝对值。

　　　　divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

　　　　round：保留浮点数的小数位数，默认保留整数。

　　　　pow：求x**y次幂。（三个参数为x**y的结果对z取余）

print(divmod(12,5))
print(round(3.141592653,5))
print(pow(2,5))
print(pow(2,5,12))

　　

　　　　sum：对可迭代对象进行求和计算（可设置初始值）。

　　　　min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。

　　　　max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。

print(min([1,-2,3,-8,101], key=abs)) # 导入函数


l = [('alex',1000),('taibai',18),('wuris',500)]  # 求出最小年龄的元组
# 方法一：
# min1 = min([i[1] for  i in l])
# for i in l:
#     if i[1]==min1:
#         print(i)

# 方法二：
def func(x):
    return x[1]
print(min([('alex',1000),('taibai',18),('wuris',500)], key=func))
'''
1. 他会将iterable的每一个元素当作函数的参数传进去
2. 他会按照返回值去比较大小。
3. 返回的是遍历的元素 x
'''

dic2 = {'a':3,'b':2,'c':1}
# def func3(x):
#     return dic2[x]
# print(min(dic2,key=func3))

def func4(x):
    return x[1]
print(min(dic2.items(),key=func4))

列表和元祖（2）
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。
相关内置函数（2）
reversed：将一个序列翻转，并返回此翻转序列的迭代器。 字典不能翻转*****
slice：构造一个切片对象，用于列表的切片。***

l1 = [1, 2, 4, 5, 6]
print(reversed(l1))  # 得到的是迭
s1 = 'qwer'
for i in reversed(s1):
    print(i)
字典不能翻转
l1 = [i for i in range(10)]
l2 = l1[:5:2]
l3 = [i for i in range(10, 2
sli_obj = slice(0, 5, 2)
print(l3[sli_obj])
l4 = ['a', 'b', 'c', 'd', 'e
print(l4[sli_obj])

字符串相关（9）

str：将数据转化成字符串。
format:与具体数据相关，用于计算各种小数，精算等。**

print(format('test', '<20'))  # 左对齐
print(format('test', '>20'))  # 右对齐
print(format('test', '^20'))  # 居中

bytes：unicode --->bytes 类型 ****

a1 = '太白'
print(a1.encode('utf-8'))  # b'xe5xa4xaaxe7x99xbd'
print(a1.encode('utf-8').decode('utf-8'))  #太白
a1 = '太白'
b1 = bytes(a1, encoding='utf-8')
print(b1)

ord:输入字符找该字符编码的位置 unicode **
chr:输入位置数字找出其对应的字符 **
ascii:是ascii码中的返回该值，不是就返回他在Unicode的位置（16进制） **

print(ord('a'))
print(ord('中'))
print(chr(97))
print(chr(20013))
print(ascii('a'))
print(ascii('中'))   # 'u4e2d'

repr:返回一个对象的string形式（原形毕露）。*****

print(repr('alex, x'))
print(repr("{'alex': 'sb'}"))
'''
repr()  jason pickle 序列化模块 特殊字符串，python字符串的区别
'''

格式化输出%rr

msg = 'alex 是%s 的人' % ('德高望重')
print(msg)
# 格式化输出%rr
msg = 'alex 是%r 的人' % ('德高望重')
print(msg)

dict：创建一个字典。
set：创建一个集合。
frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
相关内置函数（8）
len:返回一个对象中元素的个数。
sorted：对所有可迭代的对象进行排序操作。*****

l1 = [1, 6, 3, 7, 7, 3, 8, 0]
# l1.sort()  # 原列表改变
# print(l1)
print(sorted(l1))  # 形成了新列表
print(l1)  # 原列表不变
l2 = [(1, 1000), (2, 18), (4, 250), (3, 500)]
print(sorted(l2))  # 按照元组第一个元素排序
def func(x):
    return x[1]
print(sorted(l2, key=func))  # 按照元组第二个元素排序

enumerate:枚举，返回一个枚举对象。
all：可迭代对象中，全都是True才是True ***多做条件判断

any：可迭代对象中，有一个True 就是True ***多做条件判断

l1 = [1, '', 5]
print(all(l1))
l2 = [1, 2, 5]
print(all(l2))
#
print(any(l1))
print(any(l2))

zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，
然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
拉链方法 将多个iter纵向组成一个元组（以最短为准）*****

l1 = [1, 2, 3, 4, 5, 6]
tu1 = ('alex', '太白', 'wusir', '女神',)
dic = {'name': '日天', 'age': 28, 'hobby': 'tea', 'job': 'IT'}
print(zip(l1, tu1, dic))  # 迭代器
for i in zip(l1, tu1, dic):
    print(i)

filter：过滤·。迭代器 *****

l1 = [i for i in range(10)]
def func(x):
    return x % 2 ==0
print(list(filter(func, l1)))

map:会根据提供的函数对指定序列做映射。 循环模式

l1 = [1, 2, 3, 4]
def func(x):
    return x**2
print(list(map(func, l1)))
print([i**2 for i in l1])
print([pow(i, 2) for i in l1])

*****

print() sum reversed

key :min max sorted filter zip

匿名函数 lambda 表达式 一行函数

普通函数 有且只有返回值的才可以用匿名函数进行简化。 一行函数

函数名 = lambda 函数的参数：函数的返回值
func = lambda x:x*2
def func(x):
    return x*2

　　

func = lambda x,y:x+y
print(func(2,3))

# 匿名函数 不单独使用，多与内置函数结合

dic={'k1':10,'k2':100,'k3':30}
#1,利用内置函数匿名函数将dic按照值进行排序。
print(dict(sorted(dic.items(), key=lambda x:x[1])))

l1 = [1,5,7,4,8]
# 利用内置函数匿名函数 计算列表的每个数的2倍。
print(list(map(lambda x:x*2,l1)))

l2 = [5,8,11,9,15]
# 利用内置函数匿名函数，将值大于10的留下来。
print(list(filter(lambda x:x>10,l2)))


# lambda 返回值可以放三元运算
func2 = lambda x: x if x > 2 else x * 2