python 打工记 第3天 自定义函数

定义   以def关键字开头，后接函数名称和圆括号 ( ) ，括号后接冒号:

def theprint(str):
   "打印传入的字符串"
   print (str)
   return

   if a==0.0 and b!=0:
        x=-c/b
        return[x]
    elif:
        if   b**2-4*a*c==0:
            return[-b/2/a]
        elif b**2-4*a*c>0:
            x1=(-b+sqrt(b**2-4*a*c))/2/a
            x2=(-b-sqrt(b**2-4*a*c))/2/a
        else:
            re1=-b/2/a
            ima1=sqrt(4*a*c-b**2)/2/a
            re2=-b/2/a
            ima2=-sqrt(4*a*c-b**2)/2/a
            x1=complex(re1,ima1)
            x2=complex(re2,ima2)
        return[x1,x2]
    else:
        return['inf']

上面这个代码戳了，我实在搞不懂这道题想要表达什么。输入1,3,5，怎么可能会有无穷解啊啊啊啊啊啊？？？

下面这个代码是正确滴

# coding:utf-8 
from math import sqrt
a = float(input()); b = float(input()); c = float(input())
#请在此添加代码，求方程 ax^2+bx+c = 0的解,返回由方程根构成的列表,若方程有无数解，返回['inf']
#********** Begin *********#
x=[]
def roots(a,b,c):
    if b**2-4*a*c>0:
        x.append((-b+sqrt(b**2-4*a*c))/(2*a))
        x.append((-b-sqrt(b**2-4*a*c))/(2*a))
        return(x)
    elif b**2-4*a*c==0:
        x.append((-b+sqrt(b**2-4*a*c))/(2*a))
        return(x)
    else:
        return(['inf'])
#********** End **********#
print (roots(a,b,c))

---

函数递归

写法一

# coding:utf-8
Lst = input().split(',')

def abs_sum(L):
#请在此添加代码，以递归的方式设计函数abs_sum(L)返回列表L（假设其中全是整数）中所有整数绝对值之和
#********** Begin *********#
    if not L:
        return 0
    else:
        first,*rest=L
        return abs(int(first))+abs_sum(rest)
#**********  End  *********#

print(abs_sum(Lst))

写法二 

# coding:utf-8
Lst = input().split(',')

def abs_sum(L):
#请在此添加代码，以递归的方式设计函数abs_sum(L)返回列表L（假设其中全是整数）中所有整数绝对值之和
#********** Begin *********#
    if len(L) == 0:  # 如果列表为空
        return 0
    else:
        first = L[0]  # 获取列表的第一个元素
        rest = L[1:]  # 获取列表的剩余部分
        return abs(int(first)) + abs_sum(rest)
#**********  End  *********#

print(abs_sum(Lst))

1. 共性   return abs(int(first)) + abs_sum(rest)
2. 获取列表剩余部分的两种写法
3. *rest=L
4. rest = L[1:]     这个切片包含了从第二个元素直到列表末尾的所有元素。

以下为切片应用举例    理解为主

获取列表的一部分：

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]  # 从索引1开始到索引4之前，结果是 [1, 2, 3]
忽略开始索引：

sub_list = my_list[:4]  # 从列表开始到索引4之前，结果是 [0, 1, 2, 3]
忽略结束索引：

sub_list = my_list[2:]  # 从索引2开始到列表末尾，结果是 [2, 3, 4, 5]
使用负索引：

sub_list = my_list[-3:-1]  # 从倒数第三个元素开始到倒数第二个元素之前，结果是 [3, 4]
步长为2的切片：

sub_list = my_list[0:6:2]  # 从索引0开始到索引6之前，步长为2，结果是 [0, 2, 4]
反向切片：

reversed_list = my_list[::-1]  # 整个列表反向，结果是 [5, 4, 3, 2, 1, 0]
步长为-2的反向切片：

sub_list = my_list[-1:0:-2]  # 从列表末尾开始到索引0之前，步长为-2，结果是 [5, 3, 1]
在字符串上使用切片：

my_string = "Hello, World!"
sub_string = my_string[1:9]  # 从索引1开始到索引9之前，结果是 "ello, W"
提取子字符串：

sub_string = my_string[:5]  # 从字符串开始到索引5之前，结果是 "Hello"
使用切片跳过元素：

sub_list = my_list[::2]  # 从列表开始到末尾，步长为2，结果是 [0, 2, 4]

---

修改全局变量

global 关键字并不能直接与赋值操作一起使用。

需要先声明 counter 为全局变量，然后在函数内部对它进行操作。

  global counter
  counter += 1