封装函数系列

“”"
函数：
概念：
一般情况下，某段代码具有一定的功能，可能会被多次复用，封装成函数

封装函数语法：
    def  函数名():
        实现功能的代码

调用：
    函数名()

需求：
封装一个可以使用"*"打印5行8列的矩阵的函数

“”"

list1 = [1,10,2,5]

v = max(list1)

封装了一个可以打印99乘法表的函数

def show99():
for i in range(1, 10):
for j in range(1, i + 1):
print(f’{j} * {i} = {j * i}’, end=’\t’)
print()
show99()
pass
show99()
pass
print(’----’*20)
show99()

“”"
需求：
封装一个可以使用"“打印5行8列的矩阵的函数
封装一个可以使用”"打印6行10列的矩阵的函数

可以存在同名函数，以最新定义的为准

定义：
def 函数名(形式参数...):
    pass

调用：
    函数名(实际参数...)

实参个数与形参个数一致

“”"
def func1(a,b):
for i in range(a):
for j in range(b):
print(’’,end=’ ‘)
print()
def func2():
for i in range(6):
for j in range(10):
print(’’,end=’ ')
print()

func1(5,8)
print(’------’*20)
func1(6,10)

func2()

“”"
1.元组
定义：
t = ()
特点：
不可变，有序，可以重复
长度：
len(t)
索引：
同列表
操作：
+连接
*重复
查询：
index()
in
not in
count()

2.字典:
定义：
d = {}
特点：
键值对，无序(没有索引，3.5之后有添加顺序)
key: key唯一，只能是不可变类型，一般情况下使用字符串做key
不可变类型：
数值类型
str
tuple
可变类型：
list，dict，set

操作：
    增
        d[key] = value
        update()
        setdefault()
    删
        pop(key)
        popitem()
        del d[key]
    查(默认查key)
        in
        not in

    改
        d[key] = value
        update()
        setdefault()

    字典中获取元素：
        d[key]
        d.get(key)

3.集合set
定义：
s = set()
s = {1,}
特点：
无序，唯一
可以存储：
跟字典的key一样
只能存储不可变类型

&
    交集
^
    反交集
丨
    并集

4.函数
概念：
拥有一定功能，可能会被多次复用，封装成函数（封装自定义函数）
定义：
def 函数名(形式参数1,…):
实现功能的代码

调用：
    函数名(实际参数1,....)

注意：
    函数在调用时，给的实际参数的个数，取决于函数定义时，形参的个数

    在调用时，对应位置的实参的值，会赋值给形参

“”"

d = {}

d.update(a=1,b=2)

d.update(a=2)

print(d)

def func(a,b):
for i in range(a):
for j in range(b):
print(’*’,end=’ ')
print()
func(5,8)

“”"
进制转换问题：
十进制：
0-9
二进制：
0-1
八进制：
0-7
十六进制：
0-9，A-F

十进制->其他进制
10-2

二进制字符串 =  bin(十进制数字)
'0b'

10-8
八进制字符串 = oct(十进制数字)
‘0o’
10-16
十六进制字符串 = hex(十进制数字)
‘0x’

其他进制转十进制
‘0x45’
int(‘进制字符串’,进制数)

“”"
a = 10
r1 = bin(a) # 0b1010
print(r1)

r2 = oct(a) # 0o12
print(r2)

r3 = hex(a) # 0xa
print(r3)

r4 = int(‘0x45’,16)
print(r4)
print(’–’*20)
r5 = int(‘0xa’,16)
print(r5)
r6 = int(‘0b1010’,2)
print(r6)
r7 = int(‘0o12’,8)
print(r7)

d1 = {‘a’:1}

list1 = [d1,10,2]

del list1[0]

清除字典中的所有数据

d1.clear()
print(d1)

从内存中直接干掉

del d1
print(d1)

“”"
函数定义时：
形参

函数调用时：
实参

形参与实参的关系：
在调用时，实参的个数取决于定义形参的个数
一般情况下，二者的位置，个数，必须一致
特殊情况：
参数位置特殊情况
1.位置参数
2.关键字参数
实参给形参赋值的时候，按关键给的

参数个数特殊情况
    3.默认参数
        def 函数名(形参1=默认值，...):
        如果一个函数在定义时，参数为默认参数，调用时，可给可不给
        如果不给，形参以默认值为准，如果给了，以实参的具体值为准

    4.可变参数
        *args:
            在调用可以给0个，1个，多个，任意类型的参数都是可以的
            args 会当成元组类型来处理，传进来每一个参数都会被当成元组的一个元素

        **kwargs
            要求接受的实参必须是减值对类型的，可以给0，1，多个键值对

“”"

def func1(a,b):

print(f’a = {a},b = {b}’)

func1(5,10)

func1(b=5,a=10)

func1(b=5,10)

func1(10,a=5)

func1(10,a=5,b=20)

list1 = [1,20,3,2]

list2 = sorted(list1,reverse=True)

print(list2)

def func2(a=5,b=10):

print(f’a = {a} b = {b}’)

# func2(10,20)

func2(10)

func2()

可变参数

def func3(*args):

print(type(args))

print(args)

func3()

func3(1)

func3(1,2)

func3(1,2,3)

print(’-------------’)

func3([1,2,3])

def func4(**kwargs):
print(type(kwargs))
print(kwargs)

func4()

不可以给这种类型的参数

func4(1)

只能给减值对类型的参数

func4(a=1)
func4(a=1,b=2)

def func5(*args,**kwargs):

pass

“”"
函数的返回值问题：

return:
1.结束函数
2.用于函数的返回值

注意：
一个函数如果有返回值，接收到的变量，便是对应的返回值类型

如果一个函数没有返回值，则接受到的是None（系统默认返回的）

函数可以存在多个返回值：
如果使用一个变量接收多个返回值，则这个变量默认是tuple类型

也可以使用对应个数的变量接收对应的个数的返回值。

案例：
封装一个可以求两个数字和的函数

def get_sum(a,b):
    return a + b

“”"

v = input(‘请输入:’)

print(v)

v1 = print(‘HelloWorld’)

print(v1)

list1 = [1,10,2,4]

# 自定求列表中最大值的函数

def get_max(list1):

m = list1[0]

for i in range(1,len(list1)):

if m < list1[i]:

m = list1[i]

return m

# return None

v2 = max(list1)

print(f’系统查找最大值：{v2}’)

v3 = get_max(list1)

print(f’自定义查找最大值：{v3}’)

封装一个函数，可以完成一个字典中，键值的反转 {‘a’:1} ===> {1:‘a’}

d1 = {‘a’:1,‘b’:2}

# v = d1.items()

# print(type(v))

def func1(d):

d_new = {}

for k,v in d.items():

# print(k,v)

d_new[v] = k

return d_new

d2 = func1(d1)

print(d2)

函数中是否可以存在多个返回值？

def func2():
return 1,2

v,v1 = func2() # v,v1 = 1,2

v1 = 1,2,3

print(v1)

print(type(v))
print(v)

“”"
需求1： 封装函数，判断一个数字是否为偶数
需求2： 封装函数，判断一个数字是否为质数()

“”"

判断数字n是否为偶数，如果是，返回True，否则，返回False

def is_even_number(n):

if n % 2 == 0:

return True

# print(‘偶数’)

else:

return False

# print(‘不是偶数’)

def is_even_number(n):

return True if n % 2 == 0 else False

def is_even_number(n):
return n % 2 == 0

判断数字n是否为质数

def is_prime_number(n):
# 用来记录数字是否为质数
v = True
for i in range(2,n):
# 判断n是否能被i整除，如果能被整除，说明，不是质数
if n % i == 0:
v = False
break
return v
print(is_prime_number(991))

函数之间的调用

封装一个函数， 打印a,b之间所有的质数

def show_prime_numbers(a,b):
# 逐个判断a-b之间所有的数字
for i in range(a,b+1):
if is_prime_number(i):
print(i)

show_prime_numbers(10,20)