python 学习 D14 内置函数

Posted 2020-11-06 HoneyCY

内置函数
　　作用域相关 
　　　　# **globals() 已字典的形式返回全局变量
 
       # **locals() 已字典的形式返回当前位置的局部变量

# q = 666
# def wrapper(argv):
#     a = 3
#     print(locals())  # 1 {a:3,argv:2}
#     def inner(argv1):
#         b = 4
#         c = 5
#         print(locals())  # 2 {b:4 c:5,argv1:6}
#     inner(6)
#
# wrapper(2)
# print(globals())  # 3

　　　　其他相关

　　　　

#1.2.1 字符串类型代码的执行 eval，exec，complie

　　#***eval 去除字符串的引号，返回对应内部的值

# s = ‘{"a":1,"b":3}‘
# dic = eval(s)
# print(dic,type(dic))
# print(eval(‘2 + 2‘))
# print(eval(‘print(666)‘))

　　#*** exec  执行字符串内部的代码

# print(exec(‘1 + 1‘))

# s = """
# for i in range(10):
#     print(i)
# """
# exec(s)

 

　　#compile: pass

 输入输出相关  input  print  

 

# name = input(‘请%s输入名字:‘ % ‘alex‘)
# print(name)

# print(1, 2, 3,sep=‘*‘)  # 设定打印元素的连接方式
# print(‘alex‘, end=‘‘)  # end控制的是换行
# print(‘老男孩‘)

# ***f1 = open(‘log‘, encoding=‘utf-8‘, mode=‘w‘)
# print(‘666‘, file=f1)  # file 操作文件句柄，写入文件。
# f1.close()

内存相关 hash id

# print(hash(‘name‘))
# print(hash(‘age‘))
# print(hash((1, 2, 3,)))
# print(hash(1))
# print(hash(1))
# print(hash(100))

# *print(id(‘name‘))

文件操作相关

　　# open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

模块相关__import__　

　　# __import__：函数用于动态加载类和函数 。

帮助

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

调用相关

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

# def func1():
#     print(666)
#
# age = 16
# print(callable(‘name‘))
# print(callable(age))
# print(callable(func1))

查看内置属性

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

# print(dir(str))

迭代器生成器相关

*** range  iter() next()

# print(len(range(100)))
# l = [1, 2, 3, 4, 5]
# l_obj = l.__iter__()
# l_obj = iter(l)
# print(l_obj)
# print(l_obj.__next__())
# print(next(l_obj))

View Code

数字相关
　　数据类型

# bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。

# int：函数用于将一个字符串或数字转换为整型。

# print(int(‘123‘))
# print(int(1.234))
# print(int(1.768))

# float：函数用于将整数和字符串转换成浮点数。

# i = 3.1415
# print(i, type(i))
# s = ‘1.234‘
# print(int(1.234))
# print(float(s))
# print(float(100))

# complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。

# 如果第一个参数为字符串，则不需要指定第二个参数。。

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

# print(bin(100))

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

# print(oct(10))

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

# print(hex(13))
# print(hex(18))

　　数学运算

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

# print(abs(-5))

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

# print(divmod(7, 3))

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

# print(round(1.234,2))

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

# print(pow(2, 3)) # 2的三次幂
# print(pow(2, 3, 3))  # 2的三次幂对3取余数

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

# print(sum([1, 2, 3, 4]))
# print(sum([1, 2, 3, 4], 100))

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

# print(min([1, 3, 5, 7, -4]))
# print(min([1, 3, 5, 7, -4], key=abs))

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

# print(max([1, 3, 5, 7, -4]))
# print(max([1, 3, 5, 7, -9], key=abs))

和数据结构相关

列表和元祖（2）

# 　　　　list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
#
# 　　　　tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。

# tu = (1, 2, 3)
# print(list(tu))
# l1 = list((1, 2, 3))
# l1 = list({‘name‘:‘alex‘,‘age‘:1000})

相关内置函数

*** reversed：将一个序列翻转，并返回此翻转序列的迭代器。

# l1 = [11, 22, 33, 44, 77, 66]
# l_obj = reversed(l1)
# # print(l_obj)
# for i in l_obj:
#     print(i)

slice：构造一个切片对象，用于列表的切片。

# l1 = [11, 22, 33, 44, 77, 66]
# l2 = [111, 222, 333, 444, 777, 666]
# # print(l1[1::2])
# rule = slice(1, len(l2), 2)
# print(l2[rule])

字符串相关

str：将数据转化成字符串。

format:与具体数据相关，用于计算各种小数，精算等。

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

*** bytes：
　　str---> bytes

# s1 = ‘alex‘
# # b1 = s1.encode(‘utf-8‘)
# b2 = bytes(s1,encoding=‘utf-8‘)
# print(b1)
# print(b2)

bytearray

# ret = bytearray(‘alex‘, encoding=‘utf-8‘)  # 类比：[97,103,....]
# print(id(ret))
# print(ret)  # bytearray(b‘alex‘)
# print(ret[0])
# ret[0] = 65
# print(ret)
# print(id(ret))

memoryview

# 分字节去转换成str
# b1 = bytes(‘你好‘,encoding=‘utf-8‘)
# print(b1)
# ret = memoryview(b1)
# # print(len(ret))
# # print(ret)
# print(bytes(ret[:3]).decode(‘utf-8‘))
# print(bytes(ret[3:]).decode(‘utf-8‘))

ord:输入字符找该字符编码的位置

# print(ord(‘a‘))
# print(ord(‘中‘))  # unicode

chr:输入位置数字找出其对应的字符

# print(chr(65))
# print(chr(20013)) # unicode

ascii:是ascii码中的返回该值，不是就返回/u...

# print(ascii(‘a‘))
# print(ascii(1))
# print(ascii(‘中‘))

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

# msg = ‘小数%f‘ %(1.234)
# print(msg)
# msg = ‘姓名：%r‘ % ( ‘alex‘)
# print(msg)

# print(repr(‘{"name":"alex"}‘))
# print(‘{"name":"alex"}‘)

数据集合

dict：创建一个字典。

# dic = dict({‘name‘: ‘alex‘})
# print(dic)

set：创建一个集合。

# set1 = set((‘alex‘,‘wusir‘))
# print(set1)

frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

相关内置函数

*** len:返回一个对象中元素的个数。

*** sorted：对所有可迭代的对象进行排序操作。 返回的是列表

# print(sorted([1, 2, 3, 4, 5, -6]))

# print(sorted([1, 2, 3, 4, 5, -6], key=abs))

# L = [(‘a‘, 1), (‘c‘, 2), (‘d‘, 4), (‘b‘, 3), ]
# print(sorted(L))

# def func1(x):
#     return x[1]
# L = [(‘a‘, 1), (‘c‘, 2), (‘d‘, 4),(‘b‘, 3), ]
# print(sorted(L, key=func1))

*all：可迭代对象中，全都是True才是True

# print(all([1, ‘alex‘, True, (1,2,3)]))
# print(all([0, ‘alex‘, True, (1,2,3)]))

*any：可迭代对象中，有一个True 就是True

# print(any([0, ‘‘, False, (1,2,3)]))
# print(any([0, ‘‘, False, ()]))

***zip 拉链方法 返回的是一个迭代器

# l1 = [1, 2, 3, 4]
# tu1 = (‘老男孩‘, ‘alex‘, ‘wusir‘)
# l2 = [‘*‘, ‘**‘, ‘***‘, "****"]
# obj = zip(l1,tu1,l2)
# for i in obj:
#     print(i)

***map: 循环模式

# def func2(x):
#     return x**2
# obj = map(func2, [1, 2, 3, 4])
# for i in obj:
#     print(i)
# print((i**2 for i in [1, 2, 3, 4]))

# def func2(x, y):
#     return x + y
# obj1 = map(func2, [1, 2, 3, 4, 6], (2, 3, 4, 5))
# for i in obj1:
#     print(i)

***filter  筛选模式

# def func(x):
#     return x % 2 == 0
# ret = filter(func,[1, 2, 3, 4, 5, 6, 7])
# print(ret)
# for i in ret:
#     print(i)

# print((i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0))

***lambda 匿名函数 一句话函数

# def func(x): return x % 2 == 0
# def func1(x, y):
#     return x + y
#
# ret = lambda x, y: x+y
#
# print(ret(2,3))

# def func1(x, y):
#     return x if x > y else y
#
# ret = lambda x, y: x if x > y else y
#
# print(ret(2,3))

# def func(x):
#     return x % 2 == 0

# ret = filter(lambda x:x % 2 == 0, [1, 2, 3, 4, 5, 6, 7])
# print(ret)
# for i in ret:
#     print(i)

# [1, 2, 3, 4, 5, 6, 7]  [1,4,9,16...]  map  lambda

# ret2 = map(lambda x:x**2,[1, 2, 3, 4, 5, 6, 7])
# for i in ret2:
#     print(i)