日常作业及笔记

#输入三角形的三遍求三角形的周长和面积

def len(a,b,c):

  import math

  if a + b > c > a - b:

    l = a + b + c

    print("周长为%d"%l)

  else:

     print("不是三角形")

def s(a,b,c):

    import math

    if a + b > c > a - b:

      p = (a + b +c)/2

      area = math.sqrt(p * (p - a) * (p - b) * (p - c))

      print("面积为%d"%area)

    else:

       print("不是三角形")

   

a = int(input("请输入边长a:"))

b = int(input("请输入边长b:"))

c = int(input("请输入边长c:"))

len(a,b,c)

s(a,b,c)

#鸡兔同笼，从上边数35个头，从下面看94只脚，问鸡和兔各几只

 

def x(n,m):

  a = (m - 2 * n)/2

  b = n - a

  print("兔有:%d"%a)

  print("鸡有:%d"%b)

n = int(input("请输入一共多少头："))

m = int(input("请输入一共多少脚："))

x(n,m)

 

#若果一个整数能被2或3整除那它就不是素数

def su(n):

  if n % 2 == 0:

    print("不是素数")

    return False

  if n % 3 == 0:

    print("不是素数")

    return False

  else:

    print("是素数")

    return True

   

n = int(input("请输入一个整数："))

su(n)

#一对兔子在第三个月开始每个月都生一对兔子，而每对小兔子出身一个月后开始每个月生一对小兔子问从一对刚出生小兔子开始经过多少月后有多少小兔子

def f(n):

  if n == 1:

   return 1

  if n == 2:

   return 1

  else:

    return f(n-2) + f(n-1)

a = f(6)

print(a)

排序
1.如何去交换两个变量的值：

例子：
a = 10
b = 20

临时变量
c = a
a = b
b = c
print(a)
print(b)

冒泡排序：两两比较最大的放尾部
例子：
1，2  2，3  3，4直到遇到比自己大的
nums = [30,20,1,2,22,33]
for i in range(0,len(nums)-1):#循环的次数
   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)

优化：
nums = [30,20,1,2,22,33]
for i in range(0,len(nums)-1):
   for j in range(0,len(nums)-1-i):# 
   每循环一次可以少比较一次（因为每次比较会把最大的放到最后了，可以少比较一次）
    if nums[j] > nums[j+1]:
     nums[j], nums[j+1]= nums[j+1],nums[j]
print(nums)

选择排序：找最小值与假设的最小值进行互换
例子：
nums = [30,20,1,2,22,33,11,121]
for i in range(0,len(nums)-1):
  min = i #指定一个i是最小的
  for j in range(i+1,len(nums)-1):
    if nums[j] < nums[min]:#将i与j进行比较
      min = j
    if i != min :
      nums[i],nums[min] = nums[min],nums[i]
print(nums)
 

插入排序：默认第一个元素是有序的，之后一次插入后面的每一个值（多次比较），最终得到比较结果
（保证前面的的序列是有序的，把后的元素与前面的元素进行比较，一个一个往前插，直到遇到比自己小的）

例子：
nums = [30,20,1,2,22,33,11,121]
for i in range(0,len(nums)-1):
  for j in range(i+1,0,-1):#-1倒过来从后往前进行比较
    if nums[j] < nums[j-1]:
      nums[j-1],nums[j] = nums[j],nums[j-1]
print(nums)

计数：创建容器最大值与最小值的偏值的数组并清空为0
arr = [1,3,2,5,4,6,8,9]

arr0=[0111111011]----- >arr0[12345689]

0123456789

二分查找（折半查找）：在有序序列中高效的查找指定的元素
例子：
nums = [1,33,44,66,77,567,5677]
a = 567

left = 0#下标从0开始
right = len(nums) - 1
while left <= right:
  mid = int((left + right) / 2)#中间的下标
  guess = nums[mid]#令guess等于中间值
  if guess == a:#如果中间值等于要找的值则输出mid中间值下标
    print(mid)
    break
  elif guess > a:#如果中间值比要找的值大则令最右边下标变为中间值的下标-1
    right = mid - 1
  else:
    left = mid + 1#如果比中间值大则最左边的下标变为中间值下标+1
 

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

int（）

input（）

print（）

float（）

def 关键字 函数名（参数1，参数2......）:

函数体

return 语句

（返回函数的返回值，可以返回多个值，事实上是返回了一个元组，多个变量可以同时接受一个元组）

例子：
def my_abs(x):
  if x < 0:
    return -x
  else:
    return x 
  
a = my_abs(-3)
print(a)

例子：
def n():#函数n输出11111
  print("11111")

b = n()#带小括号输出None
print(b)

c = n
c()#不带小括号c可以作为函数n的别名

例子：
类型检查
#传入参数类型检查   raise 抛出异常
def my_abc(x):
  if not isinstance(x,(int,float)):
    raise TypeError
a = my_abc(2)
print(a)

my_abc('ddd')

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

例子：

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(n)
print(b)
 

暂时不用可以用pass语句来作为占位符

函数可以返回多个值，其实就是一个tuple（元组）

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

位置参数
def sum_01(x,y):
  print(x+y)

sum_01(1,3)

1，数量必须与定义一致

2，位置必须与定义时一致

默认值参数
def abc(a,b = 10):
  print(a)
  print(b)

abc(1,2)

abc(1)

默认值只执行一次

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

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

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

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

abc(100)
abc(200)
结果：
[100]
[100, 200]

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

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

关键字参数：函数调用时，指定参数的名称，即为关键字参数
关键字参数必须放在普通参数后面
def abc(x,a,b):
    print(x)
    print(a)
    print(b)

abc(100,b=200,a=300)

命名关键字参数
def abc(x,a=10,b=20):
    print(x)
    print(a)
    print(b)

abc(100,200,300)

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

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

abc(100,200,c=300,d=400)

可变参数
*参数(可变参数)：常见的*args
默认自动接受所有未匹配的位置参数，到一个元组对象里
def abc(a,*b):
    print(a)
    print(b)
    

abc(100,1,2,3,5,66)
结果：
100
(1, 2, 3, 5, 66)

弄一个求和函数并且可变参数可以继续加参数
我的：
def abc(*b):
    
    sum = 0
    
    print(b)
    for i in range(0,len(b)):#对元组b进行遍历，对容器进行迭代
      sum += b[i]
    print(sum)
    
abc(100,200,33,66,44,665)
结果：
100
(200, 33, 66, 44, 665)
1108

老师的：
def sum_01(*b):#b可变参数
    
    sum = 0
    for i in b:#获取元组中的元素
      sum += i
    return sum
    
a = sum_01(1,22,3,66,55,44,11)
print(a)

结果：202

**参数：所有未匹配的未知参数存储到一个字典里去
**kwargs

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

abc(100,name="zs",pwd="123456")
结果：
100
{'name': 'zs', 'pwd': '123456'}

 

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

传递参数时，可以在序列烈性的参数前边添加*

自动将序列中的元素以此作为参数传递

参数解包与可变参数一起用
def abc(a,*b):
  print(a)
  print(b)
​
abc(1,2,3)
函数调用函数
def abc():
  print("00000")
  

def n():
  print("11111")
  abc()

n()

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

递归次数限制在1000次，超过会报错

递归函数在使用的时候要小心zai溢出

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

fn()

求7的阶层
def fact(n):
  if n == 1:
    return 1
  else:
    return fact(n - 1) * n
  
a = fact(7)
print(a)
结果：5040

编写一个函数，用于计算斐波那契数列的第n
个数
斐波那契数列：前两个数都是1，后续的每个数都是前两个数相加的和
例子:1 1 2 3 5 8
def fibonacci(n):
  if n == 1:
   return 1
  if n == 2:
   return 1
  else:
    return fibonacci(n-2) + fibonacci(n-1)
  
a = fibonacci(6)
print(a)
结果：8

从上到下，有n个盘子从小到大在A柱上，要移动到C柱上中间有B作为辅助
def nan(n,A,B,C):
  if n > 0:
    nan(n-1,A,C,B)#把n-1个盘子放到b上，把最后一个大的移到c上
    print(f"盘子{n}从{A}移动到了{C}")
    nan(n-1,B,A,C)把n-个盘子移到c
    上

nan(2,'A','B','C')

结果：
盘子1从A移动到了B
盘子2从A移动到了C
盘子1从B移动到了C