def func(param):
    if isinstance(param, list):
        result = 0
        for item in param:
            if isinstance(item, int) or isinstance(item, float):
                result += item
        return result
    elif isinstance(param, tuple):
        result = 1
        for item in param:
            if isinstance(item, int) or isinstance(item, float):
                result *= item
        return result
    return None

def my_abs(x):
    if not isinstance(x, int) or not isinstance(x, float):
        print('param type error.')
        return None
    if x >= 0:
        return x
    else:
        return -x

i = 0

sumn = 0

while i<=100:

    sumn+=i

    i+=1

print(sumn)

def fact(n):

    if n==1:

        return 1

    return n+fact(n-1)

print(fact(100))

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。

%  表示取模

二进制   0b

十六进制    0x

0用None代替

转义字符：

还可以在多行字符串前面添加r，把这个多行字符串也变成一个raw字符串：

r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

1、Python中 0、空字符串和None  值为 False？？？其他数值和非空字符串都看成True

2、True and 0  #==> 0

3、False and 0  #==> False

4、0 or 99  #==>99

5、0 and 99  #==>0

5、not 计算优先级高于 and 和 or

在函数内部调用其他函数，是非常常见的，通过合理拆分逻辑，可以降低程序的复杂度。如果在一个函数内部调用其自身，这个函数就是递归函数。

# coding=utf-8

def sub_sum(L):

    index = 0

    sum1 = 0

    sum2 = 0

    for item in L:

        if index % 2 == 0:

            sum1 += item

        else:

            sum2 += item

        index += 1

    return sum1, sum2

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

result = sub_sum(L)

print('奇数项的和 = {}'.format(result[0]))

print('偶数项的和 = {}'.format(result[1]))

tuple和list一样，可以包含 0 个、1个和任意多个元素。
包含多个元素的 tuple，前面我们已经创建过了。

包含 0 个元素的 tuple，也就是空tuple，直接用()表示：

T = ()
print(T) # ==> ()

接着，我们创建包含一个元素的tuple。

T = (1)
print(T) # ==> 1

这和我们期望的输出有些差异，为什么包含一个元素的元组打印出来之后没有小括号，而是只有一个数字1呢？
回顾一下前面数字的四则运算。

result = 3 * 4 - 2
print(result) # ==> 10
# 改变优先级，先运算减法
result = 3 * (4 - 2)
print(result) # ==> 6

可以看到，改变优先级我们是通过()来实现的，这和元组的定义有冲突，这就解释了前面只有一个元素的元组，为什么打印出来却得到一个数字的结果了。
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
因此，要定义只有一个元素的tuple，需要在元素后面添加一个逗号,。

T = (1, )
print(T) # ==> (1, )

而对于多个元素的tuple，则加和不加这个逗号，效果是一样的。

>>> T = (1, 2, 3,)
>>> print(T) # ==> (1, 2, 3)

短路计算

1. 在计算a and b时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

2. 在计算a or b时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

任务

请运行如下代码，并解释打印的结果：

a = 'python'
print('hello,', a or 'world')
b = ''
print('hello,', b or 'world')

def square_of_sum(L):

    result =0

    for num in L:

        result =result+ num**2

    return result

L = [1,2,3]

result = square_of_sum(L)

print(result)

除了使用Python内置的函数以外，在编程过程中，我们也经常需要自己定义函数。
在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号()、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。

请注意，return表示返回的意思，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。
这样子我们就定义了一个sum_list()的函数，注意，在最后return，我们把求和的结果result返回了，这样就可以在外部调用函数后获得result。