Python学习—(4)Python函数-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_51321564/article/details/134873578

函数

文章目录

函数

1.函数基础

def printinfo(name):
    '''
    函数说明
    :return:
    '''
    print('1的名字%s'%name)
    print('2')
    print('3')
    print('4')
    pass

# 函数调用
printinfo('zqz')

1的名字zqz
2
3
4

2.函数参数

（1）必选参数

def sum(a,b): # 形参，无实际意义
    sum=a+b
    print(sum)
    pass

sum(1,2) # 实参，占用内存地址
print()
# sum() #没给参数赋值，报错

（2）默认参数

def sum1(a = 20,b = 30):
    print('默认参数%d'%(a+b))
    pass
sum1() # 调用时未赋值，使用默认值
sum1(10) # 给第一个参数赋值，第二个仍用默认值
sum1(10, 20) # 给两个参数都赋值

默认参数50
默认参数40
默认参数30

（3）可变长参数

def sumabs(*args):
    print(args) # args是元组类型
    pass
sumabs(1)
sumabs(1, 'd')

(1,)
(1, ‘d’)

（4）关键字可变参数

def keyfunc(**kwargs): # 字典类型
    print(kwargs)
    pass
keyfunc()
dictA={'name': 'jkl'}
keyfunc(**dictA)
keyfunc(height=30)

{}
{‘name’: ‘jkl’}
{‘height’: 30}

（5）参数的混合使用

def complexfunc(*args, **kwargs):
    print(args)
    print(kwargs)
    pass
complexfunc()
complexfunc(1, 2, age=25)
complexfunc({'name': 'ghu'})
complexfunc(**{'name': 'ghu'})

()
{}
(1, 2)
{‘age’: 25}
({‘name’: ‘ghu’},)
{}
()
{‘name’: ‘ghu’}

3.函数返回值

def Sum(a, b):
    sum = a + b
    return sum # 将计算的结果返回
    return sum - 1
    pass

rs = Sum(10, 20) # 计算结果返回到调用的地方
print(rs)

4.函数的嵌套调用

def fun1():
    print('开始执行1')
    print('代码')
    print('结束执行')
    pass
    
def fun2():
    print('开始执行2')
    fun1()
    print('结束执行')
    pass
    
fun2()

开始执行2
开始执行1
代码
结束执行
结束执行

5.函数的全局变量和局部变量

# 局部变量: 函数内部定义的变量, 作用域在函数内部
pro = 'cs' # 全局变量
name = 'qwe'

def printinfo():
    name = 'jkl' # 全局变量和局部变量重复定义，优先执行内部定义变量
    print('printinfo的打印:', name, pro)
    pass

def TJ():
    print('TJ的打印:', name)
    pass

def yim():
    name = 'uio'
    print('yim的打印:', name, pro)
    pass

def changeglob(): # 修改全局变量，关键字global
    global pro
    pro = 'gis'
    pass

changeglob()
print('全局变量:', pro)
printinfo()
TJ()
yim()

全局变量: gis
printinfo的打印: jkl gis
TJ的打印: qwe
yim的打印: uio gis

6.函数参数引用传值

（1）不可变类型

a = 1 # 不可变类型
def func(x):
    print('x值地址{}'.format(id(x)))
    x=2
    print('x值修改之后的地址{}'.format(id(x)))
    print(x)
    pass
print('a的地址:{}'.format(id(a)))
func(a)
print('a的值:{}'.format(a))
print('a的地址:{}'.format(id(a)))

a的地址:2301912443184
x值地址2301912443184
x值修改之后的地址2301912443216
2
a的值:1
a的地址:2301912443184

（2）可变类型

li = [98]
def tE(params):
    li.append(35) # 对列表操作，则在原来的基础上操作
    # global li
    # li=[35] # 若是对全局变量进行修改，重新分配内存
    print('li修改之后的地址:{}'.format(id(li)))
    print('params的地址:{}'.format(id(params)))
    print('params的值:{}'.format(params))
    pass
print('li的地址:{}'.format(id(li)))
tE(li)
print('li的值:{}'.format(li))

li的地址:2302100200960
li修改之后的地址:2302100200960
params的地址:2302100200960
params的值:[98, 35]
li的值:[98, 35]

7.匿名函数

# 匿名函数
M = lambda x, y : x+y # 通过变量去调用和接收
print(M(23, 87))

# 替代传统双分支
rs = lambda x, y : x if x > y else y
print(rs(2, 5))

110
5

8.递归函数

# 递归函数：阶乘
def dg(n):
    if n == 1:
        return 1
    else:
        return n * dg(n - 1)
    pass

print(dg(4))

9.内置函数

（1）取绝对值

print('绝对值:', abs(-5))

绝对值: 5

（2）取近似值

print('近似值:', round(3.193, 1))

近似值: 3.2

（3）指数运算

print('指数运算:', pow(2, 3))

指数运算: 8

（4）取最大值

print('求最大值:', max([23, 154, 8]))
print('求最大值:', max('abc'))

求最大值: 154
求最大值: c

（5）求商和余数

print('求商和余数:', divmod(8, 3))

求商和余数: (2, 2)

（6）求和

print('求和:', sum([0, 1, 2], 6))

求和: 9

（7）执行字符串表达式的值

a, b, c = 1, 2, 3
print('求字符串表达式的值:', eval('a + b - c'))

求字符串表达式的值: 0

（8）进制转换函数

print('二进制:', bin(11)) # 二进制
print('十六进制:', hex(22)) # 十六进制

二进制: 0b1011
十六进制: 0x16

（9）类型转换函数

# 元组转换为列表
tup = (1, 2)
li = list(tup)
print('将元组转换为列表:', li)
# 将列表转换为元组
tu = tuple(li)
print('将列表转换为元组:',tu)
# 转换为字典形式
dic = dict(a=1, b='l')
print('字典dic:', dic)

将元组转换为列表: [1, 2]
将列表转换为元组: (1, 2)
字典dic: {‘a’: 1, ‘b’: ‘l’}

10.序列操作

（1）all()

# all()
print(all([]))
print(all(()))
print(all([0, 1, 2]))
print(all([False, 1, 2]))
print(all(['', 1, 2]))

True
True
False
False
False

（2）any()

print(any([0, 1]))
print(any([0, False]))

True
False

（3）sort排序

li = [1, 58, 46]
li.sort()
print('li排序后:', li)

li排序后: [1, 46, 58]

（4）sorted排序

li1 = [1, 87, 56]
print('li1排序前', li1)
sorted(li1)
print('li1排序后', li1) # 不是在原来的基础上修改，返回一个新的列表
vs = sorted(li1, reverse=True) # 接受新列表
print('列表vs:', vs)

li1排序前 [1, 87, 56]
li1排序后 [1, 87, 56]
列表vs: [87, 56, 1]

（5）打包操作

s1 = [1, 2, 3]
s2 = [4, 5, 6, 7]
print('打包s1:', list(zip(s1)))
print('打包s1和s2:', list(zip(s1, s2)))

打包s1: [(1,), (2,), (3,)]
打包s1和s2: [(1, 4), (2, 5), (3, 6)]

（6）同时列出数据项和下标

litu = ['a', 'b', 'c']
print(tuple(enumerate(litu, 3))) # 3表示起始下标

((3, ‘a’), (4, ‘b’), (5, ‘c’))

11.集合

（1）创建集合

set1 = {1, 2, 3}

（2）强制类型转换

li = [1, 2, 3]
set_x = set(li)
print('将列表转换为元组:', set_x)

将列表转换为元组: {1, 2, 3}

（3）添加操作

set1.add('jkl')
print('将元组set1添加后:', set1)

将元组set1添加后: {1, 2, 3, ‘jkl’}

（4）清空操作

set1.clear()
print('将元组set1清空后:', set1)

将元组set1清空后: set()

（5）差集操作

set2 = {1, 2, 3}
set3 = {1, 3, 4}
ghu = set2.difference(set3)# set2有的,set3没有
print('set2和set3的差集:', ghu)

set2和set3的差集: {2}

（6）交集操作

ty = set2.intersection(set3)
print('set2和set3的交集:', ty)

set2和set3的交集: {1, 3}

（7）并集操作

ty1 = set2.union(set3)
print('set2和set3的并集:', ty1)

set2和set3的并集: {1, 2, 3, 4}

（8）从集合中随机拿走数据并在集合中删除

qwe = set2.pop()
print('随机拿走的数据:', qwe)
print('随机拿走的数据后的set2:', set2)

随机拿走的数据: 1
随机拿走的数据后的set2: {2, 3}

（9）移除指定元素

set3.discard(1)
print('移除指定元素后的set3:', set3)

移除指定元素后的set3: {3, 4}

（10）集合的更新

set2.update(set3)
print('将set3更新到set2的set2:', set2)

将set3更新到set2的set2: {2, 3, 4}