排序、函数、参数

python-排序、函数、参数

一、排序

1、冒泡排序：两两比较，最大的放在尾部

交换两变量的值

常见方式：
a = 10
b = 20
c = a    # 要定义以一个临时变量
a = b
b = c
print(a)
print(b)
# python中更加方便的表达
a , b = b , a
print(a)
print(b)

对数组的元素进行排序

nums = [23,45,62,32,85,12,74]
# 第一种表达方式
for j in range(0,len(nums) - 1):
    if nums[j] > nums[j + 1]:
        nums[j],nums[j + 1] = nums[j + 1],nums[j]
for j in range(0,len(nums) - 1):
    if nums[j] > nums[j + 1]:
        nums[j],nums[j + 1] = nums[j + 1],nums[j]
print(nums)

# 第二种表达方式
for i in range(0,len(nums)-1):
    for j in range(0, len(nums) - 1):
        if nums[j] > nums[j + 1]:
            nums[j], nums[j + 1] = nums[j + 1], nums[j]
print(nums)

输出结果：
[12, 23, 32, 45, 62, 74, 85]

2、选择排序：找最小值，与假设的最小值进行互换

nums = [23,14,52,999,21,65,35]

for i in range(0,len(nums)-1):
    min = i
    for j in range(i+1,len(nums)):
        if nums[j] < nums[min]:
            min = j
    if i != min:
        nums[i],nums[min] = nums[min],nums[i]
print(nums)

输出结果：
[14, 21, 23, 35, 52, 65, 999]

3、插入排序：默认第一个元素是有序的，之后依次插入后面的每一个值（多次比较），最终得到排序结果

nums = [15,91,5,42,3,32,8,1]
# 排序原理：[5,11,42,32,8,1] --> [5,11,32,42,8,1] --> [5,8,11,32,42,1] --> [1,5,8,11,32,42]

for i in range(0,len(nums)-1):
    for j in range(i+1,0,-1):
        if nums[j] < nums[j-1]:
            nums[j],nums[j-1] = nums[j-1],nums[j]

print(nums)

输出结果：
[1, 3, 5, 8, 15, 32, 42, 91]

4、计数排序：创建容器最大值与最小值的偏值的数组并清空为0

5、二分查找（折半查找）：在这有序序列中高效的查找指定的元素

nums = [1,2,33,44,55,66,77,123,456,789,888]
a = 456       # 设置指定元素的值，用于后面查找它在数组中的位置

left = 0
right = len(nums)-1
while left <= right:
    mid = int((left + right)/2)
    guess = nums[mid]
    if guess == a:
        print(mid)
        break
    elif guess > a:
        right = mid - 1
    else:
        left = mid + 1

二、函数

1、函数定义：可以重复使用的，用于实现特定功能的代码块

常见的函数定义：int() input() print() float()

2、python中函数的定义

def 函数名(参数1,参数2....(形参)):
    函数体
    return 语句

3、函数在使用时要先调用

格式：函数名 （实参)

def my_abs(x):
    if x < 0:
        return -x
    else:
        return x
# return 返回函数的返回值
# 没有return时，会返回一个None值
a = my_abs(-5)
print(a)

4、函数赋值

赋值报错

def my_abs(x):
    if x < 0:
        return -x
    else:
        return x
my_abs(1,2)    # 赋值只能有一个，不然会报错

传入参数的类型检查

def my_abs(x):
    if not isinstance(x,(int,float)):
        raise TypeError
        # raise关键字在python中是抛出异常
a = my_abs(2)
print(a)

my_abs('djd')

isinstance：判断某一个数据是以知的什么数据类型，返回的是True或False

5、返回值----return

return关键字：事实上，函数返回的是一个元组，多个变量可以同时接收一个元组

def sum_01():
    a = 1
    b = 2
    return a,b     # 元组可以省略（）

a,b = sum_01()
print(a)
print(b)

v,b,n = [1,2,3]     # 多个变量可以同时接受一个元组
print(v)
print(b)
print(n)

三、参数

1、在定义函数的时候，确定参数名和参数位置

2、位置参数–会按照位置一一对应

例：两数求和
def sum_01(x,y):
    print(x+y)

sum_01(1,2)

注意：

数量必须与定义时一致

位置必须与定义时一致

3、默认值参数

def abc(a,b=10):
    print(a)
    print(b)

abc(1,2)
abc(1)    
# 只有一个参数时，会报错，因为没有给b赋值，要解决该问题需给b一个默认值（b=10）

#默认值只会执行一次；默认值参数后面必须也是默认值参数

#官方推荐：默认参数尽量使用不可变类型，原因在于可变对象会存储在后续调用过程中传递给它的参数

#函数在定义时，默认参数b的值会被计算出来，即为一个空列表[]，因为默认参数b也是变量，指向对象[ ]，每次调用函数，如果改变了b里边的内容，则在下一次调用时，默认参数的内容也会改变。

def abc(a,b=[]):
    b.append(a)
    print(b)

abc(100)
abc(200)  
abc(300)  
输出结果：
[100]
[100, 200]
[100, 200, 300]

# 解决方法：
def abc(a,b=None):   # b=None --> b暂时为空
    if b == None:
        b = []
        b.append(a)
        print(b)

abc(100)
abc(200)
输出结果：
[100]
[200]

4、关键字参数

关键字参数：函数调用时，指定参数的名称

关键字参数必须是放在普通（位置）参数的后面

def abc(x,a,b):
    print(x)
    print(a)
    print(b)

abc(100,a=2,b=4)

5、命名关键字参数：限定后边的参数是以关键字形式传参

def abc(a,b,*,c,d):  # * 后面的参数必须为关键字形参
    print(a)
    print(b)
    print(c)
    print(d)

abc(1,2,c=3,d=4)

6、可变参数

*参数：常见的 *args，args变量指向一个tuple对象；

可变参数自动接收所有的未匹配的位置参数，到一个tuple对象里

def abc(a,*b):
    print(a)
    print(b)

abc(11,12,13,14,15,16,17)

**参数：所有未匹配的位置参数存储到一个字典里面去

常见的有：**kwargs

def abc(a,**b):
    print(a)
    print(b)

abc(10,name="zs")

7、python参数的解包

1.参数类型是字符串、列表、元组、集合、字典的时候，可以解包

2.传递实参时，可以在序列类型的参数前面添加*

3.* 的作用：自动将序列中的元素依次作为参数传递

def abc(a,b,c):
    print(a)
    print(b)
    print(c)

abc(*"123")    # 传入数据为字符串
abc(*[4,5,6])  # 传入数据为数组

d = {          # 传入数据为字典
    "uname":"zs",
    "age":18,
    "技能":"python"
}
abc(*d)

d = {
    "a":"zs",
    "b":18,
    "c":"python"
}
abc(**d)    # 想要拿字典拆包，字典中的键一定要与形参的名字一样

8、参数解包与可变参数一起用

def abc(a,*args):
    print(a)
    print(args)

abc(100,*(1,2,3))

9、函数调用函数

def fun_01():
    print("11111")

def fun_02():
    print("22222")
    fun_01()     # 调用函数01

fun_02()

10、函数递归

如果一个函数内部调用了自己本身，那么这个函数就是递归函数

求阶乘：
'''
9!=8!*9
9!=7!*8*9
...

9!=1*2*3*4*5*6*7*8*9

n!=(n-1)!*n
递归出口：1
'''

def fact(n):
    if n == 1:
        return 1
    else:
        return fact(n-1)*n

a = fact(5)
print(a)

注：递归函数在使用的时候，注意防止栈溢出

练习

1、冒泡排序（由小到大)

num = [55, 44, 35, 46, 1, 3, 21]
for i in range(0, len(num)-1):
    for j in range(0,len(num)-1):
        if num[j] > num[j + 1]:
            num[j], num[j + 1] = num[j +1], num[j]
print(num)

结果：
D:\py的项目\venv\Scripts\python.exe D:\py的项目\01-冒泡排序.py 
[1, 3, 21, 35, 44, 46, 55]

进程已结束，退出代码为 0

2、选择排序（由大到小）

nums = [11, 22, 2, 1, 43, 234, 21]
for i in range(0, len(nums)-1):
    min = i
    for j in range(i+1, len(nums)):
        if nums[j] < nums[min]:
            min = j
    if i != min:
        nums[i], nums[min] = nums[min], nums[i]
print(nums)

结果D:\py的项目\venv\Scripts\python.exe D:\py的项目\02-选择排序.py 
[1, 2, 11, 21, 22, 43, 234]

进程已结束，退出代码为 0

3、可变参数练习

def sum(*b):
    a = 0
    for i in b:
        a += i
    return a

a = sum(22, 11, 33)
print(a)

结果
D:\py的项目\venv\Scripts\python.exe D:\py的项目\10月10日\06-练习.py 
66

进程已结束，退出代码为 0

4，求阶乘问题

def fact(n):
    if n==1:
        return 1
    else:
        return fact(n-1)*n


a = fact(5)
print(a)

结果
D:\py的项目\venv\Scripts\python.exe D:\py的项目\10月10日\10-函数递归.py 
120

进程已结束，退出代码为 0

5、编写一个递归函数fibonacci(n)，用于计算斐波那契数列的第n个数字（斐波那契数列的定义是：前两个数是0和1，后续的每个数都是前两个数之和)

def fibonacci(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)


a = fibonacci(3)
print(a)

结果
D:\py的项目\venv\Scripts\python.exe D:\py的项目\10月10日\练习.py 
5

进程已结束，退出代码为 0

作业

1、输入三边的长度，求三角行的面积和周长

import math

# 输入三角形的三边长度
a = int(input("请输入三角形的第一条边长的长度："))
b = int(input("请输入三角形的第二条边长的长度："))
c = int(input("请输入三角形的第三条边长的长度："))


# 求三角形的周长
def perimeter(a, b, c):
    perimeter = a + b + c
    print("三角形的周长为：", perimeter)


# 求三角形的面积
def area(a, b, c):
    p = (a + b + c) / 2
    area = math.sqrt(p * (p - a) * (p - b) * (p - c))
    print("三角形的面积为：", area)


perimeter(a, b, c)
area(a, b, c)

结果
D:\py的项目\venv\Scripts\python.exe D:\py的项目\10月10日\作业.py 
请输入三角形的第一条边长的长度：3
请输入三角形的第二条边长的长度：4
请输入三角形的第三条边长的长度：5
三角形的周长为： 12
三角形的面积为： 6.0

进程已结束，退出代码为 0

2、鸡兔同笼，从上边看35个头，从下边看94只脚，请问鸡有几只，兔子有几只

def chicken_and_rabbit():
    # 解方程组
    for x in range(36):
        y = 35 - x
        if 2*x + 4*y == 94:
            return x, y
    return None

result = chicken_and_rabbit()
if result:
    chicken_count, rabbit_count = result
    print("鸡的数量为：", chicken_count)
    print("兔子的数量为：", rabbit_count)
else:
    print("无法确定鸡和兔子的数量！")
    结果
    D:\py的项目\venv\Scripts\python.exe D:\py的项目\10月10日\作业2.py 
鸡的数量为： 23
兔子的数量为： 12

进程已结束，退出代码为 0

3、编写一个函数，接受一个整数作为参数，判断该整数是否为素数（质数），并返回True或False。 如果一个数可以被2或3整除，那么它就不是素数

a = int(input("请输入一个整数："))
def num(a):
    if a > 1:
        for i in range(2,int(a/2) + 1):
            if (a % i) == 0:
                return False
        return True
    else:
        return False
b = num(a)
print(b)
结果
D:\py的项目\venv\Scripts\python.exe D:\py的项目\10月10日\作业3.py 
请输入一个整数：8
False

进程已结束，退出代码为 0

4、一对兔子，每对兔子从出生的第三个月开始，每个月都会生一对小兔子，而每对兔子都会在出生后的第一个月达到性成熟，之后每月都会再生一对小兔子。问题的关键是：如果我们从一对刚出生的兔子开始，经过多少个月后，会有多少对兔子？

def rabbit(months):
    if months <= 0:
        return 0

    rabbit = [1, 1]  # 初始有一对兔子（刚出生和1个月大）

    for i in range(2, months):
        new_pairs = rabbit[i-1] + rabbit[i-2]  # 新出生的兔子对数等于上个月和上上个月的兔子对数之和
        rabbit.append(new_pairs)

    return rabbit[-1]  # 返回最后一个月的兔子对数


months = int(input("请输入经过的月数："))
result = rabbit(months)
print("经过", months, "个月后，共有", result, "对兔子。")
结果
D:\py的项目\venv\Scripts\python.exe D:\py的项目\10月10日\作业4.py 
请输入经过的月数：5
经过 5 个月后，共有 5 对兔子。

进程已结束，退出代码为 0