Python4-CSDN博客

本文链接：https://blog.csdn.net/hjdjfn/article/details/133823814

冒泡排序

两两比较，最大的放尾部

a=20
b=10
#临时变量
c=a
a=b
b=c
print(a)
print(b)

nums = [30,20,1,3,21,11]
for j in range(0,len(nums)-1):#0 1 2 3 4
    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-i): #0 1 2 3 4
        if nums[j]>nums[j+1]:
            nums[j],nums[j+1] = nums[j+1],nums[j]
print(nums)

选择排序

类似于冒泡排序，每一次都找到最小值

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)

插入排序

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

nums = [11,2,12,13,1,4]
#[2,11,12,13,1,4]
#[1,2,11,12,13,4]
#[1,2,4,11,12,13]

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)

计数

创建容器最大值与最小值的偏值的数组并清空为0

arr = [2,3,1,6,5,7]
arr0 = [0,0,0,0,0,0]===》[1,2,3,5,6,7]
		0 1 2 3 4 5 6 7

二分查找（折半查找）

在有序序列中高效的查找指定的元素

nums = [1,33,44,66,77,567,5677]
a = 567

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

函数

组织好的，可以重复使用的，用于实现特定功能的代码块

'''
def 函数名(参数1，参数2...):
	函数体
	return  语句
'''
def my_abs(x):
	if x < 0:
		return -x
	else:
		return x

# my_abs(1,2)
# my_abs('A')

#传入参数的类型检查
def my_abs(x):
	if not isinstance(x,int,float)):
		raise TypeError
a = my_abs(2)
print(a)

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)

#事实上，函数返回的是一个元组，多个变量可以同时接收一个元组

sum_01()

参数

#定义函数的时候，确定参数名和参数位置

#位置参数

def sum_01(x,y):
	print(x+y)
	
sum_01(1,2)

#1.数量必须与定义时一致
#2.位置必须与定义时一致

#默认参数

def abc(a,b):
    print(a)
    print(b)
    
abc(1,2)
abc(1)

'''
默认值只会执行一次
官方推荐，默认参数尽量使用不可变类型,原因在于可变对象会存储在后期调用过程中传递给它的参数

默认参数之后必须也是默认参数

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

'''

def abc(a,b=[])
	b.append(a)
    print(b)
    
    
abc(100)
abc(200)   #[100,200]

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

关键字参数

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

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

abc(a=2,b=4)

关键字参数必须放在普通参数的后面

命名关键字参数

限定后面的参数必须是以关键字形式传参

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

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

可变参数

def abc(a,*b):   #可变参数*
	print(a)     #可变参数自动接收所有未匹配的位置参数储存到一个元组对象中
	print(b)

abc(11,12,13,14,344)      #=>  11
                               (12,13,14,344)

def abc(a,**b): #可变参数**
	print(a)    #所有未匹配的位置参数存储到一个字典中 
	print(b)

abc(10)

def sum_01(*args):
	sum1 = 0
	for i in args:
		sum1 += i
	return sum1

a = sum_01(1,22,34,6,7)
print(a)

参数的解包

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

传递实参时，

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)

函数递归

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

def fn()
	print("我是递归函数")
	fn()

fn()

#阶乘
'''
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(3)
print(a)

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

汉诺塔

def hanno(n,A,B,C):
	if n > 0:
		hanno(n-1,A,C,B)
		print(f"盘子{n}从{A}=》{C}")
		hanno(n-1,B,A,C)
		
hanno(3,'A','B','C')