02-python 基础语法知识-03-内置函数

02-python 基础语法知识-03-内置函数

概述

上一节 中 ,有写到 python的基础语法函数,今天 我们继续来看下 python中有哪些内置函数呢?

所谓内置函数,就是当我们安装了python 的环境后,python解释器 已经帮助我们 创建很多的函数,这些函数功能,一般都是比较常用的,所以 叫做 内置函数 .

内置函数 其实还有很多 ,我尽量把它都说明白 ,有很多的函数可能现在用不到 ,之后随着你学习python的深入 你就能 发现 很多是可以用到的.

官方的内置函数 有下面那么多, 我看了一下 有 69个 .

内置函数

Python 解释器内置了很多函数和类型，您可以在任何时候使用它们。以下按字母表顺序列出它们。

		内置函数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

14 *5 =70 -1 ==69

看似 很多 其实 只要分类一下 ,就没有多少.

简单分类一下

• 进制转换函数
• 函数式编程函数
• 真值检测
• any vs all 函数
• 数值类型转换
• 数学公式

进制转换的函数

有时候 我们 需要进行进制转换的时候,可以使用 以下 三个函数 进制函数 进行转换 .

常用的一些转换

bin() 十进制 转二进制

hex() 十进制 转十六进制

oct() 十进制 转八进制

#十进制转二进制
bin(x)

#十进制转十六进制
hex()

#十进制转八进制
oct()

>>> num =16
>>> oct(num)
'0o20'
>>> bin(num)
'0b10000'
>>> hex(num)
'0x10'

用法 比较简单 直接 传入一个数字,就可以了.

比如 16 对应的二进制数字, 10000, 但是 解释 返回的是 0b10000 这里 0b 就是代表 二进制的意思

同理 0x 代表16进制 , 0o 代表八进制

注意 这里用进制转换函数后 ,返回的类型 str ,即字符串类型 ,此时就不是数字类型了.

函数式编程

• map

• filter

• zip

函数式编程 是一个比较大的概念,这里 我只是简单说一下 这几个函数

map

map(function, iterable, …)¶

如果 你想对一个 序列 或者可迭代对象 进行批量操作,就可以使用这个函数来处理

举例 :

1. 比如 我想对一个序列中的每一个数字 进行 +1的操作

if __name__ == '__main__':
    m = map(lambda x: x + 1, [1, 2, 3, 4])

    for i in m:
        print(i)

这里的意思 就是 list 中每一个数字 ,使用前面的函数 调用一下,返回一个 map 对象, 然后这个对象 可以迭代.

通过迭代就可以取值了.

结果如下:

2
3
4
5	

2. 我想对一组序列 实现 乘*2 这样的操作,

   相信你 已经知道怎么做了

   if __name__ == '__main__':
       m = map(lambda x: x*2, [1, 2, 3, 4])
   
       for i in m:
           print(i)
           
   

3. 我想 对一组数 取 绝对值 的操作

   if __name__ == '__main__':
       m = map(lambda x: abs(x), [1, -2, -3, 4])
   
       for i in m:
           print(i)
   

是不是很简单,这个就是map 的作用,如果想对一组数据进行批量的相同 的操作,就可以考虑使用map 来实现这功能,

当然 你可以不使用map 也可以实现,直接 for 循环然后调用函数 也是可以的, 但是一般情况,内置的函数 效率会相对高一些.

filter

filter(function, iterable)¶

filter 看意思就是过滤的意思, 当你想从一组数据里面 过滤一部分数据的时候可以使用.

用法和map 类似, 也是 传入一个函数,传入一个可迭代对象 .

如果函数 返回一个 True 则这个对象 将会被留下来,

如果函数返回False,则这个对象 将会过滤掉.

举例1

如果 从一个可迭代对象 获取 是偶数的值 ,就可以 使用 filter 来 实现.

def is_even(x) -> bool:
    """
     x是偶数
    :param x:
    :return:
    """
    return x % 2 == 0


if __name__ == '__main__':

    f = filter(is_even, range(10))
    for i in f:
        print(i, end=' ')
    print('\n')

过滤奇数 ,只要改变 function 的过滤条件就可以 了.

def is_even(x) -> bool:
    """
    是偶数
    :param x:
    :return:
    """
    return x % 2 == 0


def is_odd(x) -> bool:
    """
    是奇数
    :param x:
    :return:
    """
    return x % 2 == 1


if __name__ == '__main__':
    f = filter(is_even, range(10))

    evens = [i for i in f]
    print(evens)
    f2 = filter(is_odd, range(10))
    l = [i for i in f2]
    print(l)

zip

zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器。

假设 我有两组 数据

一组 是姓名, 一组是排名 ,我想把两组数据关联起来,这个时候 可以考虑 使用zip

zip 会分别从每组中去一个元素, 然后组成一个元祖 ,按顺序拿值

if __name__ == '__main__':
    names = ['laoda', 'laoer', 'weilaosan', 'frank']
    rank = [1, 2, 3, 4]
    m = zip(names, rank)

    print(list(m))
	

结果如下:

[('laoda', 1), ('laoer', 2), ('weilaosan', 3), ('frank', 4)]

我们可以把它组成字典, 还记得 字典的创建方法吗, 有一种是可以通过这种结果来创建

>>> names = ['laoda', 'laoer', 'weilaosan', 'frank']
... rank = [1, 2, 3, 4]
>>> m = zip(names, rank)
... 
>>> dict(m)
{'laoda': 1, 'laoer': 2, 'weilaosan': 3, 'frank': 4}

>>> # 注意这里
>>> dict(m)
{}

我们发现 第一次 我成功创建了字典, 而当我 在使用dict 构造一个字典的时候 ,发现 返回了一个空字典?

这里 你可能会有疑惑, 其实 这就是 迭代器的特点. 每次 迭代 返回一个元素,当迭代完成的时候,迭代器 中已经没有 数据了. 下一次 在迭代的时候 ,也就没有数据了.所以返回是空字典. 可能有点难理解, 之后 我有时间 在详细 解释一下 这个问题吧, 现在 先留在这里吧.

如果 zip 中有三个 可迭代对象呢?

还是一样的, 还是从每一个对象拿出来一个,然后组成一个元祖. 组成的元素 就是 一个元祖来自三个 迭代对象.

if __name__ == '__main__':
    names = ['laoda', 'laoer', 'weilaosan', 'frank']
    rank = [1, 2, 3, 4]
    heights = ['165cm', '170cm', '175cm', '165cm']
    m = zip(names, rank, heights)

    for item in m:
        print(item)   

结果如下:

('laoda', 1, '165cm')
('laoer', 2, '170cm')
('weilaosan', 3, '175cm')
('frank', 4, '165cm')

你可能 会有疑惑 ,如果可迭代对象的长度 不一样呢? zip 会报错吗 ?

答案是不会,

而是以最短的迭代对象 为主,如果没有元素 就停止 组成元祖, 即最后结果是 最短的那个可迭代对象的长度 .

举个例子

names 长度 是5 , rank 长度是4

经过zip 操作后, 返回 长度是4 ,并且 'laowu' 被丢掉了.

>>> names = ['laoda', 'laoer', 'weilaosan', 'frank', 'laowu']
... rank = [1, 2, 3, 4]
... 
>>> 
>>> m = zip(names,rank)
>>> list(m)
[('laoda', 1), ('laoer', 2), ('weilaosan', 3), ('frank', 4)]

rank 的长度是4 , names 长度是3,同样 是丢掉了rank 最后一个元素.

>>> names = ['laoda', 'laoer', 'weilaosan']
... rank = [1, 2, 3, 4]
>>> 
>>> m = zip(names,rank)
>>> list(m)
[('laoda', 1), ('laoer', 2), ('weilaosan', 3)]

有的时候 我们 可能 想保存 最大的那个长度的数据,如果没有对应的值,可以给一个默认值来填充?

其实 是有办法的, 不过这里 我先不介绍了,之后 查一查资料 ,或者搜索 相信你会有收获的.(zip_longest)

好了 zip 的用法就基本 说完了, 这个函数方便 把几组数据关联起来.

真值检测

bool() 还记得 之前我们学习的 真值检测吗? 当时我说 如果你不确定 这个值 是否是真值怎么办?

就可以 使用这个函数 可以检测 这个表达式是否为真值

02-python 基础语法知识-01流程控制 -真值检测

这个函数 返回一个布尔值 True or False

如果你不确定这个 元素,或者对象 是否为真值,就可以调用这个函数来判断了.

注意 python3.7 中 : x 只能是位置参数

>>> bool("hello")
True

>>> bool("Love is the most beautiful things.")
True

>>> bool(0)
False
>>> bool(1)
True
>>> bool("believe In love")
True

你看看 计算机 都 '相信爱情', 所以 我们没有理由不相信. 爱情会来的,面包也会有的.

any vs. all 的函数

any 只要一组序列中有真值,则返回真,否则返回假.

all 一组序列中所有的都为真值,则返回真, 否则 返回假 .

>>> any([1,2,3,4])
True
>>> any([1,2,3,4,False])
True
>>> any([1,2,3,4,False])
True
>>> all([1,2,3,4,False])
False

#注意这里,对一个空list操作返回 True 
>>> all([])
True

slice

slice 是切片,可以返回一个切片, 然后可以给切片 起个名字 .

还记得 list 中可以使用切片吗?

>>> number = [1, 3, 4, 5, 7]
... 
>>> 
>>> number[1:3]
[3, 4]

这里 1:3 其实就是说 就是一个切片.

看下面的例子,这里 如果我想获取中间的元素, 不要 第一个 和最后一个元素,

就可以使用切片来完成. 有时候 可以使用切片,给要截取的数据一个更好的名称,方便 我们以后查看自己代码的时候,当初 为啥要截取那个一段. 这个是时候 就可以通过切片来给要截取的那一段进行命名。

>>> number = [1, 3, 4, 5, 7]
... 
... mid = slice(1, 4, 1)
>>> 
>>> 
>>> print(number[mid])
... 
... print(number[1:4])
[3, 4, 5]
[3, 4, 5]
>>> 

enumerate

有时候 在我们 迭代 可迭代对象的时候,可以定义一个计算器,代表第几个元素.

enumerate 会返回两个值,一个是这个值的索引一个是这个值本身

>>> number = [1, 3, 4, 5, 7]
>>> for  i ,n in enumerate(number):
...     print(i,n)
...     
0 1
1 3
2 4
3 5
4 7

enumerate(iterable, start=0)¶

有一个参数 start 代表你想一个索引从多少开始,默认 start =0 ,即 0,1,2,…

如果start =2 , 则索引就是 2,3,4 …

看下面的例子

>>> number = [1, 3, 4, 5, 7]
>>> for  i ,n in enumerate(number,start=2):
...     print(i,n)
...     
2 1
3 3
4 4
5 5
6 7

help

这个函数 几乎看名字 也能知道是什么意思了? 如果你不清楚某个东西如何使用,可以调用help 来查看它的用法.

>>> number
[1, 3, 4, 5, 7]
>>> help(number)
Help on list object:

class list(object)
 |  list(iterable=(), /)
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 ....

几乎 你可以往 help 放入 任何东西,

>>> help(1)
Help on int object:

class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |  
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero.
 |  
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 ...

如果你对某个用法记不清楚了,可以通过 help 去查看 文档

比如查看 字典的有哪些方法

>>> help(dict)
Help on class dict in module builtins:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:

迭代器 切片

https://python3-cookbook.readthedocs.io/zh_CN/latest/c04/p07_taking_slice_of_iterator.html

创建容器的基础工厂类

这里应该是叫 类 ,而不是函数,但是 它们都是可调用的.

list() set() tuple() dict() str() 这些用于构造容器的空对象

l = list()
l = set()
l = tuple()
l = str()
l = dict()

这些空对象,就可以 通过这些类 构造一个没有内容的空对象.

数值类型转换

float(x)

int(x,base)

complex .

ascii()

complex

这个有在 之前的数据类型有介绍过,翻看之前 讲数据类型的文章。

float

float 接收一个字符串, 然后 返回一个float 类型的数字 ,如果 传入的字符串 是不能转的类型,会报错 ValueError.

>>> float('344.232132')
344.232132
>>> float('   44.232132   ')
44.232132
>>> 
>>> float('+1.23')
1.23

>>> float('+1.23avc')
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: could not convert string to float: '+1.23avc'

int

int 这个可以接收 x和base 默认 是十进制,base 就是转成多少进制的数字 .

返回一个转换好的数字

注意 x 要是 str 类型 ,base 要转成 多少进制数,默认值 base =10

如果不能转 ,会报错, ValueError .

>>> int('10001',2)
17
>>> int('10001',10)
10001
>>> int('10001',10)
10001
>>> int('10001',10)
10001
>>> int('16',2)
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: invalid literal for int() with base 2: '16'

‘16’ 就不能 转成 二进制,因为二进制 要求 字符 只能有 01 这两种字符. 所以这里会报错.

ascii 函数

​ 这个函数 和 repr() 这个函数有点类似 返回一个字符串的表示， 这个函数并不是 讲一个字符 转化为一个 ascii 码 ，如果你需要 讲一个字符 转化为对应的ASCII 码 可以使用 chr() 这个函数。

下面就是官方的解释

就像函数 repr()，返回一个对象可打印的字符串，但是 repr() 返回的字符串中非 ASCII 编码的字符，会使用 \x、\u 和 \U 来转义。生成的字符串和 Python 2 的 repr() 返回的结果相似。

>>> ascii('frank')
"'frank'"
>>> ascii(b'frank')
"b'frank'"
>>> ascii(range(10))
'range(0, 10)'
>>> ascii([1,2,3])
'[1, 2, 3]'
>>> ascii({"name":"frank","age":18})
"{'name': 'frank', 'age': 18}"

数学公式相关

这里涉及一些 数值 计算,数值转换的一些 函数

pow(x,y) 求 x 的y 次方

max(),min(), sum() 求最大 ,最小 ,求和

round(number,ndigits) 类似 于 四舍五入吧

abs() 用来 取绝对值

divmod 获取整除的值，和取余的结果

>>> max(range(10))
9
>>> min(range(10))
0
>>> sum(range(10))
45

>>> pow(2,5)
32
>>> pow(2,3)
8
>>> pow(3,3)
27


>>> abs(10)
10
>>> abs(-10)
10
>>> abs(-1.5)
1.5
>>> abs(1.5)
1.5
>>> abs(0)
0

这里比较简单 就不说了. 只要记住 函数名称 就可以了 .

round(number,ndigits) 类似于 四舍五入吧.

number 你要传入的数字, ndigits 你要保留几位有效数字

round官方文档

>>> round(2.3456,2)
2.35
>>> round(2.3456,3)
2.346
>>> round(-2.3456,2)
-2.35


# 注意这里
>>> round(2.675,2)
2.67

官网 给出 一个解释 说 这是由于 小数 在计算机中表示 不精确导致的问题.

divmod(a, b)¶

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致

这个函数返回结果是一个元祖

>>> divmod(13,3)
(4, 1)

>>> divmod(15,2)
(7, 1)

排序 sorted

排序函数,可以对一个 可迭代对象进行排序

sorted(iterable, *, key=None, reverse=False)¶

排序函数,可以对一个 可迭代对象进行排序

key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。 key 很多的时候 使用 lamba 表达式来完成 的。

reverse 是一个bool 值， 默认是False 即升序排列。 reverse=True 则为降序排序。

这个函数会返回一个 已经排好序的对象，不会对 iterable 参数任何影响。

还有 sorted 保证排序是稳定的。

给一个list 进行排序

>>> t
[5, 7, 2, 3, 9, 1, 8, 4, 0, 6]
>>> sorted(t)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> # t 的顺序本身没有改变
>>> t
[5, 7, 2, 3, 9, 1, 8, 4, 0, 6]

再看一个例子 对应元祖的某个位置进行排序

可以使用 lambda 表达式来构造一个匿名函数 来实现

可以借助 operator模块里面的 itemgetter 也可以实现类似排序的功能。

from operator import itemgetter


if __name__ == '__main__':
    persons = [
        ('frank', 19, 56),
        ('laoda', 20, 86),
        ('weiliang', 22, 59),
        ('lile', 23, 79),

    ]

    sorted_p = sorted(persons, key=lambda e: e[2])
    print(sorted_p)

    # 也可以使用 itemgetter 这种方式排序
    sorted_p = sorted(persons, key=itemgetter(2))
    print(sorted_p)
    # [('frank', 19, 56), ('weiliang', 22, 59), ('lile', 23, 79), ('laoda', 20, 86)]
    pass

排序 是一个比较大的话题，有时间的话，我会写一下 关于python的一些排序 list.sort() vs. sorted() 的一些区别等。这里可以先了解一下 可以 指定key 来实现排序， reverse 来控制是升序还是降序排序。

面向对象编程相关的类

object

所有的类 都默认继承 object 这个类， 这是所有python 类的基类。 当然我这句话 说的不够严谨。 之后会在面向对象里面的继续讲解。

classmethod

这个将一个函数变成一个类方法 ，如果你还不知道面向对象的知识，先知道有这个方法即可，有时间 我会继续 写一下 面向对象的知识。 这里说一下基本用法

class Factory:
    
    @classmethod
    def f(cls, arg1, arg2):
        pass
    

只需要这样写就可以了，就可以将一个普通的函数 变成一个类方法了。

staticmethod

这个就是讲一个函数 强行到放到一个类中，这个函数 和这个类 本身没有什么关系，放到类中 只是希望 在类中可以访问这个函数，不希望 类的外面使用这个函数， 之后又时间 会在 面向对象编程的章节继续详解 这些方法的区别 .

下面add 方法 就是一个static method

class Factory:
    @classmethod
    def f(cls, arg1, arg2):
        pass
    
    @staticmethod
    def add(a:int,b:int)-> int:
        return a+b 

property

这个翻译过来应该叫特性吧， 将以属性变成一个特性。 这个一般 需要对属性进行 控制的时候 会用到这个的。

python3中的特性property介绍

之前我写的一篇文章 ，比较详细的介绍了这个property 的用法。

hasattr

这个用来查看一个 对象中是否包含一个属性 ，如果有返回True，否则返回False. 之后再面向对象编程里面 会说一下这个方法。

getattr

这个用来获取某个对象的这个属性的值，之后再面向对象编程里面 会说一下这个方法。

delattr

用来 删除对象的 一些属性，用的比较少。之后再面向对象编程里面 会说一下这个方法。

delattr()

callable()

这个 函数 挺重要的 ， 这个可以判断 一个对象是否为可调用的， 如果是可调用的返回为True，否则返回为False。

举个例子，一般函数是 可调用的。

看个例子

>>> 
... def say_hello():
...     print("hello frank")
...     

>>> callable(say_hello)
True

以这个例子为例

定义了一个学生类

class Student:

    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def __str__(self):
        return '%s(name:%s,age:%s,score:%s)' % (self.__class__.__name__, self.name, self.age, self.score)

    __repr__ = __str__

>>> callable(Student)
True
>>> s = Student('frank',18,89)
>>> callable(s)
False

可以看到 Student 这个类 是可调用的， 但是s 却是不可调用的。

你可能会好奇 为啥呢？

其实没有那么复杂 ，判断 是否可以调用 只要看这个对象 能否 执行 obj(*args,**kw)这个代码，如果可以 就是可调用的，否则就不行。

关于这个话题 我之前 有写过一个文章，看下这个文章 应该就可以理解了

python中什么是 可调用的，什么是不可调用的

杂项

chr 函数

chr(i)

返回 Unicode 码位为整数 i 的字符的字符串格式

实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

>>> chr(97)
'a'
>>> chr(65)
'A'
>>> chr(127)
'\x7f'
>>> chr(12799)
'ㇿ'

ord 函数

ord© 是 chr 的逆函数, 这里将 一个字符 转换成一个整数

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。例如 ord('a') 返回整数 97

>>> ord('c')
99
>>> ord('f')
102
>>> ord('r')
114
>>> ord('a')
97
>>> ord('n')
110
>>> ord('k')
107

id

id() 函数, 返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。 即两个对象 不会有 相同的 id 值。

a = 10 
b = 20 

>>> id(a)
140733509497376
>>> id(b)
140733509497696

看这里 就可以看出 id 值不相同，我们认为 a,b 不是同一个对象。 所以以后如果要判断 两个对象是不是同一个对象 ，就可以看 id 值 是否一样就可以了。

open

这个 一般用来打开文件的时候用到的。 我之前有写过一个文章 。

03-python中的文件操作-01

bytes

这个之前 的文章 基础类型有讲过，只要记得 bytes 和str 如何转换就可以了。

eval

eval 这个函数 比较强大，可以执行 代码的字符串

就是说一段 本来 是代码，现在变成了一个字符串 ，通过这个函数就可以执行这段代码。

>>> eval('1 + 23')
24
>>> eval('1 + 520')
521
>>> eval(' 3* 5')
15

>>> eval('pow(2,4)')
16

>>> x =10
>>> eval('x +15')
25

​ 看到这个函数功能 挺强大的吧， 就是只要是一段代码的字符串 ，就可以直接运行。 这样感觉非常酷。 但是实际上最好不要使用这个函数，就是安全性的问题，因为 你并不知道 字段字符串里面会写什么操作，如果是一些比较复杂的操作，比如删除一些操作系统核心的文件，或者恶意破坏的程序。 这样 直接执行一段 代码 是比较危险的行为。

len

看到这个名称 就知道用来求长度，大部分对象 都可以通过这个方法来获取长度。

len() 中可以放 很多东西， 常用的一些容器类，list ,str ,dict ,set ,tuple 等这些都是可以求长度的，

就是对应容器 有多少个元素。

之后我们 学习 面向对象编程的时候，就可以自己定义 一个对象的长度啦。

>>> sentences
'I am Frank'
>>> 
>>> del  setences 
>>> sentences
'I am Frank'
>>> len(sentences)
10
>>> len(10)
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: object of type 'int' has no len()
>>> len([1,2,3,4])
4
>>> len((1,2,3,4))
4
>>> d = {
...     "name": "frank",
... }
>>> d
{'name': 'frank'}
>>> person = {
...     "name": "frank",
...     "age": 18,
...     "hobby": "swimming",
...     "language": ["java", "php", "c", "goland"]
... }
>>> len(person)
4
>>> len(set([1,2,4,5,6]))
5

总结

​ 本文 主要写 了一些 比较常用的一些内置方法， 还有一些 没有讲到，有时间 在继续补充一下，很多的时候 我们 只用到 一部分，更多的时候，我们可以查看官方文档，就知道如何使用了。 这里 介绍 一下 比较常用的一些 内置函数。 加油，好好学习，天天向上。

参考文档

python3.7 内置函数整理

python3.x常用内置函数

Python --内置函数（68个）讲解

bulit funcitions

分享快乐,留住感动. 2020-05-24 23:02:48 --frank