Python的函数都有哪些？

Python 函数

创新互联公司-专业网站定制、快速模板网站建设、高性价比涿鹿网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式涿鹿网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖涿鹿地区。费用合理售后完善，10余年实体公司更值得信赖。

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def functionname( parameters ):   "函数_文档字符串"

function_suite

return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

实例

以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

实例(Python 2.0+)

def printme( str ):   "打印传入的字符串到标准显示设备上"

print str

return

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 定义函数def printme( str ):   "打印任何传入的字符串"

print str

return

# 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")

以上实例输出结果：

我要调用用户自定义函数!再次调用同一函数

参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]

a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

def ChangeInt( a ):    a = 10

b = 2ChangeInt(b)print b # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明def changeme( mylist ):   "修改传入的列表"

mylist.append([1,2,3,4])

print "函数内取值: ", mylist

return

# 调用changeme函数mylist = [10,20,30]changeme( mylist )print "函数外取值: ", mylist

实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数

以下是调用函数时可使用的正式参数类型：

必备参数

关键字参数

默认参数

不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printme( str ):   "打印任何传入的字符串"

print str

return

#调用printme函数printme()

以上实例输出结果：

Traceback (most recent call last):

File "test.py", line 11, in module

printme()TypeError: printme() takes exactly 1 argument (0 given)

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printme( str ):   "打印任何传入的字符串"

print str

return

#调用printme函数printme( str = "My string")

以上实例输出结果：

My string

下例能将关键字参数顺序不重要展示得更清楚：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printinfo( name, age ):   "打印任何传入的字符串"

print "Name: ", name

print "Age ", age

return

#调用printinfo函数printinfo( age=50, name="miki" )

以上实例输出结果：

Name:  mikiAge  50

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可写函数说明def printinfo( name, age = 35 ):   "打印任何传入的字符串"

print "Name: ", name

print "Age ", age

return

#调用printinfo函数printinfo( age=50, name="miki" )printinfo( name="miki" )

以上实例输出结果：

Name:  mikiAge  50Name:  mikiAge  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):   "函数_文档字符串"

function_suite

return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明def printinfo( arg1, *vartuple ):   "打印任何传入的参数"

print "输出: "

print arg1

for var in vartuple:      print var

return

# 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )

以上实例输出结果：

输出:10输出:706050

匿名函数

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数print "相加后的值为 : ", sum( 10, 20 )print "相加后的值为 : ", sum( 20, 20 )

以上实例输出结果：

相加后的值为 :  30相加后的值为 :  40

return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可写函数说明def sum( arg1, arg2 ):   # 返回2个参数的和."

total = arg1 + arg2

print "函数内 : ", total

return total

# 调用sum函数total = sum( 10, 20 )

以上实例输出结果：

函数内 :  30

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

全局变量

局部变量

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

total = 0 # 这是一个全局变量# 可写函数说明def sum( arg1, arg2 ):   #返回2个参数的和."

total = arg1 + arg2 # total在这里是局部变量.

print "函数内是局部变量 : ", total

return total

#调用sum函数sum( 10, 20 )print "函数外是全局变量 : ", total

以上实例输出结果：

函数内是局部变量 :  30函数外是全局变量 :  0

python 8个常用内置函数解说

8个超好用内置函数set（），eval（），sorted（），reversed（），map（），reduce（），filter（），enumerate（）

python中有许多内置函数，不像print那么广为人知，但它们却异常的强大，用好了可以大大提高代码效率。

这次来梳理下8个好用的python内置函数

1、set()

当需要对一个列表进行去重操作的时候，set()函数就派上用场了。

用于创建一个集合，集合里的元素是无序且不重复的。集合对象创建后，还能使用并集、交集、差集功能。

2、eval()之前有人问如何用python写一个四则运算器，输入字符串公式，直接产生结果。用eval()来做就很简单：eval(str_expression)作用是将字符串转换成表达式，并且执行。

3、sorted()在处理数据过程中，我们经常会用到排序操作，比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted() ，它可以对任何可迭代对象进行排序，并返回列表。对列表升序操作：

对元组倒序操作：

使用参数：key，根据自定义规则，按字符串长度来排序：

根据自定义规则，对元组构成的列表进行排序：

4、reversed()如果需要对序列的元素进行反转操作，reversed()函数能帮到你。reversed()接受一个序列，将序列里的元素反转，并最终返回迭代器。

5、map()做文本处理的时候，假如要对序列里的每个单词进行大写转化操作。这个时候就可以使用map()函数。

map()会根据提供的函数，对指定的序列做映射，最终返回迭代器。也就是说map()函数会把序列里的每一个元素用指定的方法加工一遍，最终返回给你加工好的序列。举个例子，对列表里的每个数字作平方处理：

6、reduce()前面说到对列表里的每个数字作平方处理，用map()函数。那我想将列表里的每个元素相乘，该怎么做呢？这时候用到reduce()函数。

reduce()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作，生成的结果再和第三个元素进行函数操作，以此类推，最终生成所有元素累积运算的结果。再举个例子，将字母连接成字符串。

你可能已经注意到，reduce()函数在python3里已经不再是内置函数，而是迁移到了functools模块中。这里把reduce()函数拎出来讲，是因为它太重要了。

7、filter()一些数字组成的列表，要把其中偶数去掉，该怎么做呢？

filter()函数轻松完成了任务，它用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。filter()函数和map()、reduce()函数类似，都是将序列里的每个元素映射到函数，最终返回结果。我们再试试，如何从许多单词里挑出包含字母w的单词。

8、enumerate()这样一个场景，同时打印出序列里每一个元素和它对应的顺序号，我们用enumerate()函数做做看。

enumerate翻译过来是枚举、列举的意思，所以说enumerate()函数用于对序列里的元素进行顺序标注，返回(元素、索引)组成的迭代器。再举个例子说明，对字符串进行标注，返回每个字母和其索引。

如何按行枚举 python enumerate

enumerate()说明

enumerate()是python的内置函数

enumerate在字典上是枚举、列举的意思

对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值

enumerate多用于在for循环中得到计数

例如对于一个seq，得到：

(0, seq[0]), (1, seq[1]), (2, seq[2])

1

1

enumerate()返回的是一个enumerate对象，例如：

enumerate()使用

如果对一个列表，既要遍历索引又要遍历元素时，首先可以这样写：

list1 = ["这", "是", "一个", "测试"]

for i in range (len(list1)):

print i ,list1[i]123123

上述方法有些累赘，利用enumerate()会更加直接和优美：

list1 = ["这", "是", "一个", "测试"]

for index, item in enumerate(list1):

print index, item

0 这

1 是

2 一个

3 测试1234567812345678

enumerate还可以接收第二个参数，用于指定索引起始值，如：

list1 = ["这", "是", "一个", "测试"]

for index, item in enumerate(list1, 1):

print index, item

1 这

2 是

3 一个

4 测试1234567812345678

补充

如果要统计文件的行数，可以这样写：

count = len(open(filepath, 'r').readlines())11

这种方法简单，但是可能比较慢，当文件比较大时甚至不能工作。

可以利用enumerate()：

count = -1

for index, line in enumerate(open(filepath,'r'))：

count += 1

python中ls【】【】是什么意思？

【CSDN 编者按】Python 风头正盛，未来一段时间内想必也会是热门编程语言之一。因此，熟练掌握 Python 对开发者来说极其重要，说不定能给作为开发者的你带来意想不到的财富。

作者 | Sebastian Opałczyński

编译 | 弯月 责编 | 张文

出品 | CSDN（ID：CSDNnews）

在本文中，我们来看一看日常工作中经常使用的一些 Python 小技巧。

集合

开发人员常常忘记 Python 也有集合数据类型，大家都喜欢使用列表处理一切。

集合（set）是什么？简单来说就是：集合是一组无序事物的汇集，不包含重复元素。

如果你熟练掌握集合及其逻辑，那么很多问题都可以迎刃而解。举个例子，如何获取一个单词中出现的字母？

myword = "NanananaBatman"set(myword){'N', 'm', 'n', 'B', 'a', 't'}

就这么简单，问题解决了，这个例子就来自 Python 的官方文档，大可不必过于惊讶。

再举一个例子，如何获取一个列表的各个元素，且不重复？

# first you can easily change set to list and other way aroundmylist = ["a", "b", "c","c"]# let's make a set out of itmyset = set(mylist)# myset will be:{'a', 'b', 'c'}# and, it's already iterable so you can do:for element in myset:print(element)# but you can also convert it to list again:mynewlist = list(myset)# and mynewlist will be:['a', 'b', 'c']

我们可以看到，“c”元素不再重复出现了。只有一个地方你需要注意，mylist 与 mynewlist 之间的元素顺序可能会有所不同：

mylist = ["c", "c", "a","b"]mynewlist = list(set(mylist))# mynewlist is:['a', 'b', 'c']

可以看出，两个列表的元素顺序不同。

下面，我们来进一步深入。

假设某些实体之间有一对多的关系，举个更加具体的例子：用户与权限。通常，一个用户可以拥有多个权限。现在假设某人想要修改多个权限，即同时添加和删除某些权限，应当如何解决这个问题？

# this is the set of permissions before change;original_permission_set = {"is_admin","can_post_entry", "can_edit_entry", "can_view_settings"}# this is new set of permissions;new_permission_set = {"can_edit_settings","is_member", "can_view_entry", "can_edit_entry"}# now permissions to add will be:new_permission_set.difference(original_permission_set)# which will result:{'can_edit_settings', 'can_view_entry', 'is_member'}# As you can see can_edit_entry is in both sets; so we do notneed# to worry about handling it# now permissions to remove will be:original_permission_set.difference(new_permission_set)# which will result:{'is_admin', 'can_view_settings', 'can_post_entry'}# and basically it's also true; we switched admin to member, andadd# more permission on settings; and removed the post_entrypermission

总的来说，不要害怕使用集合，它们能帮助你解决很多问题，更多详情，请参考 Python 官方文档。

日历

当开发与日期和时间有关的功能时，有些信息可能非常重要，比如某一年的这个月有多少天。这个问题看似简单，但是我相信日期和时间是一个非常有难度的话题，而且我觉得日历的实现问题非常多，简直就是噩梦，因为你需要考虑大量的极端情况。

那么，究竟如何才能找出某个月有多少天呢？

import calendarcalendar.monthrange(2020, 12)# will result:(1, 31)# BUT! you need to be careful here, why? Let's read thedocumentation:help(calendar.monthrange)# Help on function monthrange in module calendar:# monthrange(year, month)# Return weekday (0-6~ Mon-Sun) and number of days (28-31) for# year, month.# As you can see the first value returned in tuple is a weekday,# not the number of the first day for a given month; let's try# to get the same for 2021calendar.monthrange(2021, 12)(2, 31)# So this basically means that the first day of December 2021 isWed# and the last day of December 2021 is 31 (which is obvious,cause# December always has 31 days)# let's play with Februarycalendar.monthrange(2021, 2)(0, 28)calendar.monthrange(2022, 2)(1, 28)calendar.monthrange(2023, 2)(2, 28)calendar.monthrange(2024, 2)(3, 29)calendar.monthrange(2025, 2)(5, 28)# as you can see it handled nicely the leap year;

某个月的第一天当然非常简单，就是 1 号。但是，“某个月的第一天是周X”，如何使用这条信息呢？你可以很容易地查到某一天是周几：

calendar.monthrange(2024, 2)(3, 29)# means that February 2024 starts on Thursday# let's define simple helper:weekdays = ["Monday", "Tuesday","Wednesday", "Thursday", "Friday","Saturday", "Sunday"]# now we can do something like:weekdays[3]# will result in:'Thursday'# now simple math to tell what day is 15th of February 2020:offset = 3 # it's thefirst value from monthrangefor day in range(1, 29):print(day,weekdays[(day + offset - 1) % 7])1 Thursday2 Friday3 Saturday4 Sunday...18 Sunday19 Monday20 Tuesday21 Wednesday22 Thursday23 Friday24 Saturday...28 Wednesday29 Thursday# which basically makes sense;

也许这段代码不适合直接用于生产，因为你可以使用 datetime 更容易地查找星期：

from datetime import datetimemydate = datetime(2024, 2, 15)datetime.weekday(mydate)# will result:3# or:datetime.strftime(mydate, "%A")'Thursday'

总的来说，日历模块有很多有意思的地方，值得慢慢学习：

# checking if year is leap:calendar.isleap(2021) #Falsecalendar.isleap(2024) #True# or checking how many days will be leap days for given yearspan:calendar.leapdays(2021, 2026) # 1calendar.leapdays(2020, 2026) # 2# read the help here, as range is: [y1, y2), meaning that second# year is not included;calendar.leapdays(2020, 2024) # 1

枚举有第二个参数

是的，枚举有第二个参数，可能很多有经验的开发人员都不知道。下面我们来看一个例子：

mylist = ['a', 'b', 'd', 'c', 'g', 'e']for i, item in enumerate(mylist):print(i, item)# Will give:0 a1 b2 d3 c4 g5 e# but, you can add a start for enumeration:for i, item in enumerate(mylist, 16):print(i, item)# and now you will get:16 a17 b18 d19 c20 g21 e

第二个参数可以指定枚举开始的地方，比如上述代码中的 enumerate(mylist,16)。如果你需要处理偏移量，则可以考虑这个参数。

if-else 逻辑

你经常需要根据不同的条件，处理不同的逻辑，经验不足的开发人员可能会编写出类似下面的代码：

OPEN = 1IN_PROGRESS = 2CLOSED = 3def handle_open_status():print('Handling openstatus')def handle_in_progress_status():print('Handling inprogress status')def handle_closed_status():print('Handling closedstatus')def handle_status_change(status):if status == OPEN:handle_open_status()elif status ==IN_PROGRESS:handle_in_progress_status()elif status == CLOSED:handle_closed_status()handle_status_change(1) #Handling open statushandle_status_change(2) #Handling in progress statushandle_status_change(3) #Handling closed status

虽然这段代码看上去也没有那么糟，但是如果有 20 多个条件呢？

那么，究竟应该怎样处理呢？

from enum import IntEnumclass StatusE(IntEnum):OPEN = 1IN_PROGRESS = 2CLOSED = 3def handle_open_status():print('Handling openstatus')def handle_in_progress_status():print('Handling inprogress status')def handle_closed_status():print('Handling closedstatus')handlers = {StatusE.OPEN.value:handle_open_status,StatusE.IN_PROGRESS.value: handle_in_progress_status,StatusE.CLOSED.value:handle_closed_status}def handle_status_change(status):if status not inhandlers:raiseException(f'No handler found for status: {status}')handler =handlers[status]handler()handle_status_change(StatusE.OPEN.value) # Handling open statushandle_status_change(StatusE.IN_PROGRESS.value) # Handling in progress statushandle_status_change(StatusE.CLOSED.value) # Handling closed statushandle_status_change(4) #Will raise the exception

在 Python 中这种模式很常见，它可以让代码看起来更加整洁，尤其是当方法非常庞大，而且需要处理大量条件时。

enum 模块

enum 模块提供了一系列处理枚举的工具函数，最有意思的是 Enum 和 IntEnum。我们来看个例子：

from enum import Enum, IntEnum, Flag, IntFlagclass MyEnum(Enum):FIRST ="first"SECOND ="second"THIRD ="third"class MyIntEnum(IntEnum):ONE = 1TWO = 2THREE = 3# Now we can do things like:MyEnum.FIRST ## it has value and name attributes, which are handy:MyEnum.FIRST.value #'first'MyEnum.FIRST.name #'FIRST'# additionally we can do things like:MyEnum('first') #, get enum by valueMyEnum['FIRST'] #, get enum by name

使用 IntEnum 编写的代码也差不多，但是有几个不同之处：

MyEnum.FIRST == "first" # False# butMyIntEnum.ONE == 1 # True# to make first example to work:MyEnum.FIRST.value == "first" # True

在中等规模的代码库中，enum 模块在管理常量方面可以提供很大的帮助。

enum 的本地化可能有点棘手，但也可以实现，我用django快速演示一下：

from enum import Enumfrom django.utils.translation import gettext_lazy as _class MyEnum(Enum):FIRST ="first"SECOND ="second"THIRD ="third"@classmethoddef choices(cls):return [(cls.FIRST.value, _('first')),(cls.SECOND.value, _('second')),(cls.THIRD.value, _('third'))# And later in eg. model definiton:some_field = models.CharField(max_length=10,choices=MyEnum.choices())

iPython

iPython 就是交互式 Python，它是一个交互式的命令行 shell，有点像 Python 解释器。

首先，你需要安装 iPython：

pip install ipython

接下来，你只需要在输入命令的时候，将 Python 换成 ipython：

# you should see something like this after you start:Python 3.8.5 (default, Jul 28 2020, 12:59:40)Type 'copyright', 'credits' or 'license' for more informationIPython 7.18.1 -- An enhanced Interactive Python. Type '?' forhelp.In [1]:

ipython 支持很多系统命令，比如 ls 或 cat，tab 键可以显示提示，而且你还可以使用上下键查找前面用过的命令。更多具体信息，请参见官方文档。

参考链接：

python内置函数有哪些

python常见的内置函数有：

1. abs()函数返回数字的绝对值。

2. all() 函数用于判断给定的参数中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True。

3. any() 函数用于判断给定的参数是否全部为False，是则返回False，如果有一个为True，则返回True。 元素除了是 0、空、False外都算 TRUE。

4. bin()函数返回一个整数int或者长整数long int的二进制表示。

5. bool() 函数用于将给定参数转换为布尔类型，如果参数不为空或不为0，返回True；参数为0或没有参数，返回False。

6. bytearray()方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 = x 256（即0-255）。即bytearray()是可修改的二进制字节格式。

7. callable()函数用于检查一个对象是否可调用的。对于函数、方法、lambda函式、类以及实现了 __call__ 方法的类实例, 它都返回 True。（可以加括号的都可以调用）

8. chr()函数用一个范围在range(256)内（即0～255）的整数作参数，返回一个对应的ASCII数值。

9. dict()函数用来将元组/列表转换为字典格式。

10. dir()函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

扩展资料：

如何查看python3.6的内置函数？

1、首先先打开python自带的集成开发环境IDLE；

2、然后我们直接输入"dir(__builtins__)",需要注意的是builtins左右的下划线都是两个；

3、回车之后我们就可以看到python所有的内置函数；

4、接下来我们学习第二种查看python内置函数的方法，我们直接在IDLE中输入"import builtins",然后输入"dir(builtins)"；

5、然后回车，同样的这个方法也可以得到所有的python内置的函数；

6、这里我们可以使用python内置函数len（）来查看python内置函数的个数，这里我们直接输入"len(dir(builtins))"；

7、回车之后我们可以看到系统返回值153，说明我们现在这个版本中有153个内置函数；

8、最后我们介绍一个比较有用的内置函数"help"，python内置函数有一百多个，我们当然不能记住所有的函数，这里python提供了一个"help"函数，我们来看一个例子一起来体会一下help函数的用法，这里我们直接输入"help(len)",然后回车，会看到系统给我们对于内置函数"len"的解释，当然对于其他函数可能会有更加详细的解释以及用法提示。

python常用函数

1、complex()

返回一个形如 a+bj 的复数，传入参数分为三种情况：

参数为空时，返回0j；参数为字符串时，将字符串表达式解释为复数形式并返回；参数为两个整数(a,b)时，返回 a+bj；参数只有一个整数 a 时，虚部 b 默认为0，函数返回 a+0j。

2、dir()

不提供参数时，返回当前本地范围内的名称列表；提供一个参数时，返回该对象包含的全部属性。

3、divmod(a,b)

a -- 代表被除数，整数或浮点数；b -- 代表除数，整数或浮点数；根据 除法运算 计算 a,b 之间的商和余数，函数返回一个元组(p,q) ，p 代表商 a//b ，q 代表余数 a%b。

4、enumerate(iterable,start=0)

iterable -- 一个可迭代对象，列表、元组序列等；start -- 计数索引值，默认初始为0‘该函数返回枚举对象是个迭代器，利用 next() 方法依次返回元素值，每个元素以元组形式存在，包含一个计数元素(起始为 start )和 iterable 中对应的元素值。

当前文章：python枚举函数 python枚举类型enum用法
网站URL：http://azwzsj.com/article/hhdipj.html