yyz notes
YiZhang-You
2023-05-10
目录

常用内置函数分类

# 作用域相关

# locals()

# globals()

# vars()

上面实例

# 迭代器相关

# range()

range() 函数可创建一个整数列表，一般用在for循环中，函数语法为【range(start, stop[, step])】，其中start是开始计数，stop是停止，step是步长。

参数说明：

  • start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
  • stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
  • step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

例：打印一个从1到20且相隔3的数字序列

x = range(1, 20, 3)
for n in x:
  print(n)

# 输出结果为：1 4 7 10 13 16 19
1
2
3
4
5

注意：range函数中所有的参数必须要是整数但是可以是正整数或者负整数，索引是从0开始的而不是1

# next()

next() 返回迭代器的下一个项目。

next() 函数要和生成迭代器的 iter() 函数一起使用。

next 语法：

next(iterable[, default])

iterable -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
1
2
3
4
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

1
2
3
4
5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# iter()

获取迭代器, 内部实际使用的是iter()方法来获取迭代器

# 字符串类型代码的执行

# eval()

eval() 函数的语法格式为：

eval(expression, globals=None, locals=None, /)

执行部分字符串类型的代码,并返回最终结果

print(eval("2+2"))
# 4n = 8print(eval("2+n"))
# 10def func():    print(666)eval("func()")# 666
1
2
3

# exec()

而 exec() 函数的语法格式如下：

exec(expression, globals=None, locals=None, /)

执行字符串类型的代码

msg = '''
def func():
    print('有计划没行动等于零')
func()
'''
exec(msg)
1
2
3
4
5
6

以上这两个在公司开发中禁止使用,如果里边出现del就会出现很大的问题

eval() 执行完会返回结果，而 exec() 执行完不返回结果。

# 内存相关

# hash()

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

print(hash('123'))
结果:
-6822401661081700707
1
2
3

这样是求出数据结构,如果能够获取到哈希值就是可以当做字典的键

# id()

获取到对象的内存地址

# 文件操作相关

# open()

用于打开一个文件, 创建一个文件句柄

# 帮助

# help()

函数用于查看函数或模块用途的详细说明

help(print)
结果:
Help on built-in function print in module builtins:
print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
Process finished with exit code 0
1
2
3
4
5
6
7
8
9
10
11
12

# 调用相关

# callable()

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

print(callable(print))
结果:
True
1
2
3

# 查看内置属性

# dir()

查看对象的内置属性

方法.访问的是对象中的dir()⽅方法

print(dir(list))
结果:
['__add__', '__class__', '__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']
1
2
3

# 数字相关

bool() 将给定的数据转换成bool值. 如果不给值. 返回False

int() 将给定的数据转换成int值. 如果不给值, 返回0

float() 将给定的数据转换成float值. 也就是小数

complex() 创建一个复数. 第一个参数为实部, 第二个参数为虚部. 或者第一个参数直接 用字符串来描述复数

# 数学运算

# abs() 返回绝对值

print(abs(-1))
结果:
1
1
2
3

# divmod() 返回商和余数

print(divmod(15,2))
结果:
(7, 1)
1
2
3

# round() 四舍五入

print(round(15.1111,2))  # 保留2位小数
结果:
15.11
1
2
3

# pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余

print(pow(15,2,3))
结果:
0
1
2
3

# sum() 求和

print(sum([12,3,4]))  #sum里边的参数是一个可迭代对象
结果:
19
1
2
3

# min() 求最小值

print(min([12,3,4]))  # 寻找最小的数字
结果:
3
1
2
3

# max() 求最大值

print(max([12,3,4]))  # 寻找最大的数字
结果:
12
1
2
3

# 数据结构相关

列表和元组:

list() 将一个可迭代对象转换成列表

tuple() 将一个可迭代对象转换成元组

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

# reversed

l = reversed('你好')  # l 获取到的是一个生成器
print(list(l))
1
2

# 字符串相关:

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

format() 与具体数据相关, 用于计算各种小数, 精算等

print(format('meet','>20'))   # 右对齐
print(format('meet','<20'))   # 左对齐
print(format('meet','^20'))   # 居中
1
2
3

数值

#数值
print(format(3,'b'))    # 二进制
print(format(97,'c'))   # 转换成unicodezif
print(format(11,'d'))   #十进制
print(format(56))     #和d一样
print(format(11,'n'))   #十进制
print(format(11,'o'))   #八进制
print(format(11,'x'))  # 十六进制(小写字母)
print(format(11,'X'))  # 十六进制(大写字母)
# 浮点数
print(format(1234567890,'e'))  #科学计算法,默认使用6位
print(format(123456789,'0.2e'))# 科学计算,保留2位小数(小写)
print(format(123456789,'0.2E'))# 科学计算,保留2位小数(大写)
print(format(1.23456789,'f')) #小数点计数法,保留6位小数
print(format(1.23456789,'0.2f')) # 小数点计数法,保留2位数
print(format(1.23456789,'0.10f')) # 小数点计数法,保留2位数
print(format(1.23456789e+1000,'F')) # 小数点计数法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

s = '你好武大'bs = s.encode('utf-8')print(bs)结果:b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\xad\xa6\xe5\xa4\xa7's1 = bs.decode('utf-8')print(s1)结果: 你好武大s = '你好'bs = bytes(s,encoding='utf-8')print(bs)# 将字符串转换成字节bs1 = str(bs,encoding='utf-8')print(bs1)# 将字节转换成字符串
1

repr() 返回一个对象的官方表示形式

# repr 输出一个字符串的官方表示形式.print(repr('大家好,\n \t我叫周杰伦')) print('大家好我叫周杰伦')# %r%r用的就是reprname = 'taibai'print('我叫%r' % name)
1

# 数据集合

dict() 创建一个字典

set() 创建一个集合

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

# 其他相关

# len() 返回一个对象的元素个数

# enumerate() 获取枚举对象

enumerate() 举例

lst = ['alex','wusir','taibai']
for i,k in enumerate(lst):
    print('这是序号',i)
    print('这是元素',k)
1
2
3
4

# all() 可迭代对象中全部是True,结果才是True

lst = [1,2,3,4,True,0,False]
lst1 = [1,2,3,4,True]
print(all(lst))
print(all(lst1))
结果:
False
True
1
2
3
4
5
6
7

# any() 可迭代对象中有一个是True,就是True

lst = [1,2,3,4,True,0,False]
lst1 = [1,2,3,4,True]
print(any(lst))
print(any(lst1))
结果:
False
True
1
2
3
4
5
6
7

zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元祖,

然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回

lst1 = [1,2,3]
lst2 = ['a','b','c','d']
lst3 = (11,12,13,14,15)
for i in zip(lst1,lst2,lst3):
    print(i)
结果:
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)
1
2
3
4
5
6
7
8
9

# sorted

排序函数

语法:sorted(iterable,key=None,reverse=False)

iterable : 可迭代对象

key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

reverse :是否是倒叙,True 倒叙 False 正序

lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst)    #原列表不会改变
print(lst2)   #返回的新列表是经过排序的
lst3 = sorted(lst,reverse=True)
print(lst3)   #倒叙
结果:
[1, 3, 2, 5, 4]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
1
2
3
4
5
6
7
8
9
10

字典使用sorted排序

dic = {1:'a',3:'c',2:'b'}
print(sorted(dic))   # 字典排序返回的就是排序后的key
结果:
[1,2,3]
1
2
3
4

和函数组合使用

# 定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
# 计算字符串的长度
def func(s):
    return len(s)
print(sorted(lst,key=func))
# 结果:
# ['西游记', '红楼梦', '天龙八部', '三国演义']
1
2
3
4
5
6
7
8

和lambda组合使用

lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s)))
结果:
['西游记', '红楼梦', '天龙八部', '三国演义']
lst = [{'id':1,'name':'alex','age':18},
    {'id':2,'name':'wusir','age':17},
    {'id':3,'name':'taibai','age':16},]
# 按照年龄对学生信息进行排序
print(sorted(lst,key=lambda e:e['age']))
结果:
[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]
1
2
3
4
5
6
7
8
9
10
11

# filter() 过滤

filter(function,iterable) :function:判断的条件 ,iterable可迭代对象

必须要返回True和False,因为filter只判断True和False看保留与否

"""
filter(function,iterable)  通过一定的条件过滤可迭代对象中的元素

工作原理：把传入的函数依次作用于可迭代对象的每一个元素，根据返回的布尔值【True或者False】决定是否保留元素
如果返回True，则表示需要保留该元素；如果返回False，则表示需要过滤掉该元素
"""
# 将列表中的偶数筛选出来
list1 = [1, 2, 3, 4, 5, 6, 7, 8]

def func(num):
    # 保留偶数元素
    if num % 2 == 0:
        return True
    # 过滤奇数元素
    return False

# 依次遍历list1列表中的值，并放到func函数中判断，如果返回的为True就保留下来，并放入列表。为False就舍弃
newList4 = list(filter(func, list1))
print(newList4)

# 将爱好为"无"的数据剔除掉
data = [['姓名', '爱好', '年龄'], ['tom', '无', 10], ['jack', '唱歌', 28]]

def func2(s):
    if s == "无":
        return False
    return True

for line in data:
    result = list(filter(func2, line))
    print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# map() 映射

map(function,Iterable); function对象每个迭代对象进行处理,iterable:可迭代对象

function对象中一定要有返回值

"""
map(function,Iterable)  会根据的函数对指定的序列做出映射
function：函数
iterable：可迭代对象，序列
工作原理：函数会以序列中的每一个元素作为参数，返回包含函数的功能的新列表
功能：将传入的函数依次作用于序列中的每一个元素，并把结果作为新的iterable返回
"""

"""
传给map的函数的要求：
 a.参数只能有一个【默认将可迭代对象的一个元素传递给该函数】
 b.该函数必须有返回值，否则得到的可迭代对象中的元素为None
"""
# 计算列表中各个元素的平方
list1 = [1, 2, 3, 4, 5]

# 方式一:
# map[def定义的函数]
def func(x):
    return x ** 2  # 必须要有返回值

result = map(func, list1)  # 将列表list1中的元素每个元素迭代，经过函数func的处理返回值
print(result)  # map对象 <map object at 0x02C770E8
newList4 = list(result)
print(newList4)

# 方式二：map[匿名函数]
newList5 = list(map(lambda x: x ** 2, list1))
print(newList5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# reduce() 迭代[累积]

reduce(function,iterable) function:需要进行的处理 iterable可迭代对象

  • function对象中一定要有返回值
  • 函数里面必须要有两个参数
"""
导入模块：functools
reduce(function,iterable):函数会对序列中的元素进行累积
功能：用传给reduce的函数先序列中的第1,2个元素进行操作，
用得到的结果和第3个元素进行操作，用得到的结果和第4个元素进行操作。。。。

举例：
f,[a,b,c,d]
reduce(f,[a,b,c,d])
工作原理：f(f(f(a,b),c),d),类似于递归 其实就是[1,2,3,4] (((1+2)+3)+4)
"""

"""
函数的注意事项：
 a.必须有两个参数
 b.必须设置返回值【报错：TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'】
"""
from functools import reduce
# 计算一个整数列表中元素的和

# 一：reduce【def定义函数】
def mySum(x, y):
    return x + y  # 函数必须设置返回值

result0 = reduce(mySum, list1)
print(result0)
"""
mySum(1,2)---->3
mySum(3,3)---->6
mySum(6,4)---->10
mySum(10,5)---->15
"""

# 二：reduce[匿名函数]
result1 = reduce(lambda x, y: x + y, list1)
print(result1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# 面试题

from functools import reduce

# 将[1,3,5,7,9]转换为整数13579
list1 = [1, 3, 5, 7, 9]

def func(num, y): # 函数里面必须要有两个参数
    return (num * 10) + y # 必须要有返回值

new = reduce(func, list1)
print(new)

from functools import reduce

# 自定义一个函数，实现str转换为int的函数  int(xx)
def charToNum(s):
    # 自定义字符串和整型之间的映射关系
    digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

    return digits[s]  # 返回字典对应的key

def func(num, y):  # 函数里面必须要有两个参数
    return (num * 10) + y

# 需求：“24356”------》24356
# a.产生映射关系
r0 = list(map(charToNum, "243567890"))  # 把返回的值添加到列表中
print(r0)
# b.使用reduce累积
r1 = reduce(func, r0)
print(r1)
print(type(r1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
编辑 (opens new window)
上次更新: 2023/05/17, 23:08:21
内置函数概述
面向对象、面向过程

← 面向对象、面向过程→

最近更新
01
配置yun源
05-24
02
linux-配置python虚拟环境
05-24
03
linux文件目录管理
05-24
更多文章>
Theme by Vdoing | Copyright © 2023-2023 yizhang | MIT License