Python 函数与内置函数

1.函数的基本定义

def 函数名称（参数）
         执行语句
return 返回值

def : 定义函数的关键字；

函数名称：顾名思义，就是函数的名字，可以用来调用函数，不能使用关键字来命名，做好是用这个函数的功能的英文名命名，可以采用驼峰法与下划线法；

参数：用来给函数提供数据，有形参和实参的区分；

执行语句：也叫函数体，用来进行一系列的逻辑运算；

返回值：执行完函数后，返回给调用者的数据，默认为None，所以没有返回值时，可以不写return。

2.函数的普通参数

最直接的一对一关系的参数，如:

def fun_ex(a,b):            #a,b是函数fun_ex的形式参数，也叫形参
    sum=a+b
print('sum =',sum)
fun_ex(1,3)                  #1，3是函数fun_ex的实际参数，也叫实参

#运行结果
sum = 4

3.函数的默认参数

给参数定义一个默认值,如果调用函数时,没有给指定参数,则函数使用默认参数,默认参数需要放在参数列表的最后,如:

def fun_ex(a,b=6):    #默认参数放在参数列表最后，如b=6只能在a后面
    sum=a+b
print('sum =',sum)
fun_ex(1,3)
fun_ex(1)

#运行结果
sum = 4
sum = 7

4.函数的动态参数

不需要指定参数是元组或字典,函数自动把它转换成元组或字典,如:

 1 #转换成元组的动态参数形式，接受的参数需要是可以转成元组的形式，就是类元组形式的数据，如数值，列表，元组。
 2 
 3 def func(*args):
 4     print(args,type(args))
 5 
 6 func(1,2,3,4,5)
 7 
 8 date_ex1=('a','b','c','d')
 9 func(*date_ex1)
10 
11 #运行结果
12 (1, 2, 3, 4, 5) <class 'tuple'>
13 ('a', 'b', 'c', 'd') <class 'tuple'>

动态参数形式一

 1 #转换成字典的动态参数形式，接收的参数要是能转换成字典形式的，就是类字典形式的数据，如键值对，字典
 2 
 3 def func(**kwargs):
 4     print(kwargs,type(kwargs))
 5 
 6 func(a=11,b=22)
 7 
 8 date_ex2={'a':111,'b':222}
 9 func(**date_ex2)
10 
11 #运行结果
12 {'b': 22, 'a': 11} <class 'dict'>
13 {'b': 222, 'a': 111} <class 'dict'>

动态参数形式二

 1 #根据传的参数转换成元组和字典的动态参数形式，接收的参数可以是任何形式。
 2 def func(*args,**kwargs):
 3     print(args, type(args))
 4     print(kwargs,type(kwargs))
 5 
 6 func(123,321,a=999,b=666)
 7 
 8 date_ex3={'a':123,'b':321}
 9 func(**date_ex3)
10 
11 #运行结果
12 (123, 321) <class 'tuple'>
13 {'b': 666, 'a': 999} <class 'dict'>
14 () <class 'tuple'>
15 {'b': 321, 'a': 123} <class 'dict'>

动态参数形式三

5.函数的返回值

运行一个函数，一般都需要从中得到某个信息，这时就需要使用return来获取返回值，如：

def fun_ex(a,b):
    sum=a+b
return sum      #返回sum值

re=fun_ex(1,3)   
print('sum =',re)

#运行结果
sum = 4

6.lambda表达式

用来表达简单的函数，如：

#普通方法定义函数
def sum(a,b):
return a+b
sum=sum(1,2)
print(sum)

#lambda表达式定义函数
myLambda = lambda a,b : a+b
sum=myLambda(2,3)
print(sum)

#运行结果
3
5

7.内置函数

1）内置函数列表

		Built-in Functions
`abs()`	`dict()`	`help()`	`min()`	`setattr()`
`all()`	`dir()`	`hex()`	`next()`	`slice()`
`any()`	`divmod()`	`id()`	`object()`	`sorted()`
`ascii()`	`enumerate()`	`input()`	`oct()`	`staticmethod()`
`bin()`	`eval()`	`int()`	`open()`	`str()`
`bool()`	`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()`
`delattr()`	`hash()`	`memoryview()`	`set()`

官方说明文档地址：https://docs.python.org/3/library/functions.html

中文版官方说明文档地址：http://python.usyiyi.cn/translate/python_352/index.html

2）内置函数功能

运算类内置函数：

ads(x): 取绝对值，参数是复数，返回它的模；

max(iterable, *[, key, default])/max(arg1, arg2, *args[, key]): 取所有元素的最大值；

min(iterable, *[, key, default])/min(arg1, arg2, *args[, key]): 取所有元素的最小值；

divmod(a, b): 返回a,b两数的商和余数的一对数字（可用于分页显示功能）；

实例：

1 a=abs(-10)
2 b=abs(3)
3 print(a)
4 print(b)
5 
6 #运行结果
7 10
8 3

ads()

1 a=max(1,2,*(3,4))
2 b=max(*(1,2),*[5,6])
3 print(a)
4 print(b)
5 
6 #运行结果
7 4
8 6

max()

1 a=min(1,2,*(3,4))
2 b=min(*(0,1,2),*[5,6])
3 print(a)
4 print(b)
5 
6 #运行结果
7 1
8 0

min()

1 a=divmod(5,2)
2 print(a)
3 
4 #运行结果
5 (2, 1)

divmod()

类型转换类内置函数：

int(x): 把数据转换成整数型；

ascii(object): 类似repr()，返回一个可打印的对象字符串方式表示。当遇到非ASCII码时，就会输出\x，\u或\U等字符来表示；

bin(x): 将一个整数转化成一个二进制字符串；

class bool([x]): 根据给的数据，返回一个布尔值，True 或 False；

class bytearray([source[, encoding[, errors]]]): 返回一个byte数组；

class bytes([source[, encoding[, errors]]]): 返回一个新的字节对象，是一个在 0<= x < 256之间的不可变的整数序列；

chr(i): 返回表示Unicode码点为整数i的字符的字符串，它是ord()的逆操作。参数的有效范围为0到1,114,111（基址16中的0x10FFFF）。如果i超出该范围，则会引发ValueError报错；

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1): 将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值；

class complex([real[, imag]]): 返回值形式为real + imag * j的复数，或将字符串(数字形式的字符串）或数字转换为复数；

enumerate(iterable, start=0): 返回一个枚举对象。iterable 必须是一个序列、一个迭代器，或者其它某种支持迭代的对象；

eval(expression, globals=None, locals=None): 还原字符串中的数据结构；

实例：

 1 a=3.14159
 2 b="12"
 3 c=int(a)
 4 d=int(b)
 5 print(a,type(a))
 6 print(b,type(b))
 7 print(c,type(c))
 8 print(d,type(d))
 9 
10 运行结果
11 3.14159 <class 'float'>
12 12 <class 'str'>
13 3 <class 'int'>
14 12 <class 'int'>

int()

 1 print(ascii('a'))
 2 print(ascii(999999))
 3 print(ascii('\11'))
 4 print(ascii('\200'))
 5 
 6 #运行结果
 7 'a'
 8 999999
 9 '\t'
10 '\x80'

ascii()

1 a=bin(5)
2 print(a,type(a))
3 
4 #运行结果
5 0b101 <class 'str'>

bin()

1 a=bool(5)
2 b=bool(0)
3 print(a)
4 print(b)
5 
6 #运行结果
7 True
8 False

bool()

 1 #如果source为空，则返回一个长度为0的字节数组
 2 a=bytearray()
 3 print(a,len(a))
 4 
 5 #如果source为字符串，则按照指定的encoding将字符串转换为字节序列
 6 b=bytearray('abcd中文','utf-8 ')
 7 print(b)
 8 
 9 #如果source为整数，则返回一个长度为source整数的初始化数组
10 c=bytearray(5)
11 print(c,len(c))
12 
13 #如果source为可迭代类型，则元素必须为[0 ,255]中的整数
14 d=bytearray([9,8,7])
15 print(d)
16 
17 #运行结果
18 bytearray(b'') 0
19 bytearray(b'abcd\xe4\xb8\xad\xe6\x96\x87')
20 bytearray(b'\x00\x00\x00\x00\x00') 5
21 bytearray(b'\t\x08\x07')

bytearray() Python 函数与内置函数

 1 a='abcd'
 2 b='中文'
 3 
 4 #转换成字节编码
 5 c=bytes(a,encoding='gbk')
 6 d=bytes(b,encoding='utf-8')
 7 e=bytes(b,encoding='gbk')
 8 
 9 #解码过程,用什么规则编码，就用什么解码
10 f=d.decode('utf-8')
11 h=e.decode('gbk')
12 
13 #打印信息
14 print(c)
15 print(d)
16 print(e)
17 print(f)
18 print(h)
19 
20 #运行结果
21 '''
22 b'abcd'
23 b'\xe4\xb8\xad\xe6\x96\x87'
24 b'\xd6\xd0\xce\xc4'
25 中文
26 中文
27 '''

bytes()

 1 print(chr(65))
 2 print(chr(0))
 3 print(chr(33))
 4 print(chr(1114111))
 5 
 6 #运行结果
 7 A
 8 
 9 !
10

秒客网

Python 函数与内置函数

相关文章