python中node函数的意思_python中函数学习笔记

求随机数的函数

import random

def generate_random():

for i in range(10):

ran = random.randint(1, 20)

print(ran, end=' ')

generate_random()

str1 = 'abc'

str2 = str1

str1 = str1.replace('b','')

print(str1)

函数：

增加代码复用性，减少代码冗余

定义函数：

def 函数名([形参,...]):

函数体

例：

定义：

def add(实参):

result = 1+3

print(result)

调用：

add() ---->4

* 固定参数个数：

定义:

def add(a, b):

pass

# 调用

add(1, 3)

# 可变参数

# 定义方式

# 形式一

def add(*args):

print(args)

add() # ---->空元祖

add(1, 2) # ----> (1,2)

add(1, 2, 3, 4) # ----> (1,2,3,4)

# 混合形式一

# 可变参数必须在固定参数的后面

# 错误：

def add(*args, name):

print(args, name) # 报错

# 正确：

def add(name, age, *args):

print(args, name, age)

# 混合形式二:可变参数+关键字参数(key=value)

def add(a, b=10): # 关键字参数

result = a + b

print(result)

add(5) # ---->15

add(4, 7) # ---->11

def add(a, b=10, c=4):

result = a + b + c

print(result)

add(2, c=6) # ---->18

# 拆包与装包：调用的时候两个*的装用是拆包，定义的时候两个*的作用是装包

# def aa(**kwargs):

# print(kwargs)

#

#

# dict1 = {'a': 1, 'b': 'hello', 'c': 'tom'}

#

# aa(**dict1) # a=1,b='hello',c='tom' 两个*的作用在这里是拆包

# def bb(a, b, *c, **d):

# print(a, b, c, d)

#

#

# bb(1, 2) # ----> 1 2 () {}

# bb(1, 2, 3, 4) # ----> 1 2 (3, 4) {}

# bb(1, 2, x=100, y=200) # ----> 1 2 () {'x':100,'y':200}

# bb(1, 2, 3, x=100) # ----> 1 2 (3,) {'x':100}

# bb(1, 2, x=100, 5, 6) # ---->报错 ()

# def func(a, *args):

# print(a, args)

#

#

# func(2, 3, 4, 5) # ----> 2 (3,4,5)

# func(2, [1, 2, 3, 4]) # ----> 2 ([1,2,3,4],)

# func(2, 3, [1, 2, 3, 4, 5]) # ----> 2 (3,[1,2,3,4,5])

# func(5, 6, (4, 5, 7), 9) # ----> 5 (6,(4,5,7),9)

# def func(a, b=10, c=3, **kwargs):

# print(a, b, c, kwargs)

#

#

# func(1) # ----> 1 10 3 {}

# func(2, b=10) # ----> 2 10 3 {}

# func(3, 5, 7, a=1, b=2) # ----> 报错 不能重复给b传参

def func(a, *args, **kwargs):

print(a, args, kwargs)

def func2(a, b, *args, **kwargs):

print(a, b, args, kwargs)

t = (1, 2, 3, 4)

func(1, t) # ---->1 ((1,2,3,4),) {}

func2(1, t) # ----> 1 (1,2,3,4) () {}

list1 = [2, 5, 8]

# func(1, list1, a=9, b=6) # ----> 报错 不能重复给a传参

func(1, list1, x=9, y=6) # ----> 1 ([2,5,8],) {'x':9,'y':6}

func2(1, list1, x=9, y=6) # ----> 1 [2,5,8] () {'x':9,'y':6}

dict1 = {'1': 'a', '2': 'b', '3': 'c'}

# 列表类型的参数用一个 * 拆包，字典类型的参数用两个 * 拆包

# 案例一

# list1 通过一个*拆包变成 2，5，8这种形式的参数，dict1通过两个*拆包成 '1'='a','2'='b','3'='c'这种形式的参数

# func(1, *list1, **dict1) # ----> 1 (2, 5, 8) {'1': 'a', '2': 'b', '3': 'c'}

#

#

# func(1, 2, 3, 4, 5, dict1) # 1 (2,3,4,5,{'1': 'a', '2': 'b', '3': 'c'}) {}

# func(1, 2, 3, 4, 5, **dict1) # 1 (2,3,4,5) {'1': 'a', '2': 'b', '3': 'c'}

# 案例二

def func1(name, *args):

if len(args) > 0:

for i in args:

print('{}学过了{}'.format(name, i))

else:

print('没有学过任何编程知识！')

course = ['html', 'mysql', 'python']

# 调用函数

func1('lucy', course) # ----> lucy学过了['html', 'mysql', 'python']

# func1('lucy', *course) #拆包

# 结果：

# lucy学过了html

# lucy学过了mysql

# lucy学过了python

总结：

无参数函数：

1.普通函数

def func(name,age):

pass

func('aa',18) ---->形参和实参的个数要一致

2.可变参数

A.def func(*args):

pass

func() ----> 函数调用时，参数的个数可以没有，也可以多个 *不能是关键字参数

B.def func(**kwargs):

pass

func('a'=1,'b'=2) ---->函数调用时，实参的个数可以没有，也可以多个 **必须是关键字参数

C.def func(*args,**kwargs):

pass

list1=[1,3]

dict1=['1':'a','2':'b']

func(*list1,**dict1) # func(1,3,'1'='a','2'='b')

D. 混用

def func(name,*args,**kwargs):

pass

func('tom') ---->必须赋值

3.默认值+关键字

def func(name,age=18):

pass

func('tom') ----> tom 18

func('tom',age=18) ----> 关键字赋值

# return 返回值

# 1. return 后面可以是一个参数，在调用的时候可以用一个变量来接收

# 2. return 后面页可以是多个参数，如果是多个参数则底层会将多个参数放在一个元组中，将元组作为一个整体返回

# 3. 接收的时候也可以是多个：return 'hello'，'world' x,y = ('hello','world') ----> x='hello' y='world'