任务：

# 请分别使用循环和递归的形式定义函数，求出1~100的和。

# 循环的方式：
def sum_xunhuan(x):
    sums = 0
    for i in range(1, x+1):
        sums += i;
    return sums;

# 递归的方式：
def sum_digui(x):
    if x == 0:
        return x
    return x + sum_digui(x-1)

y = sum_xunhuan(100)  
z = sum_digui(100)
print(y, z)

函数内部调用其他函数，是非常常见的，通过合理拆分逻辑，可以降低程序的复杂度。

如果在一个函数内部调用其自身，这个函数就是递归函数。

计算阶乘 n! = 1 * 2 * 3 * ... * n，用函数 fact(n)表示：

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

fact(n)可以表示为 n * fact(n-1)，只有n=1时需要特殊处理。

可以拆解fact(5)计算的详细逻辑：

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

递归函数的优点是定义简单，逻辑清晰。使用递归函数需要注意防止栈溢出。

函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。RecursionError: maximum recursion depth exceeded in comparison

有时候函数是没有返回结果的，这个时候从函数获取到的是一个空值None。
对list_sum()这个函数进行简单的修改，在函数内把结果打印出来，不通过return返回结果。

任务：

# 定义一个函数sub_sum()，这个函数接收一个列表作为参数，函数返回列表所有奇数项的和以及所有偶数项的和。

# coding=utf-8
L = [0, 1, 2, 3, 4, 5, 6, 7, 8]
def sub_sum(L):
    sum_even = 0
    sum_odd = 0
    for i in range(len(L)):
        if i % 2 == 0:
            sum_even += L[i]
        if i % 2 != 0:
            sum_odd += L[i]
    return sum_odd, sum_even
    
result = sub_sum(L)
sum_odd = result[0]
sum_even = result[1]
print('奇数和 = {}'.format(sum_odd))
print('偶数和 = {}'.format(sum_even))

在dict中，每一项包含一个key和一个value，key和value是一一对应的,使用花括号{}表示这是一个dict，然后key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。

判断顺序不了解

要定义只有一个元素的tuple，需要在元素后面添加一个逗号,否则会出现优先级问题

count()统计tuple中某个元素出现的次数 ，元组名称.tuple(查询 元素名称)

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

if-elif-else

if score >=90:
    print('90+')
elif score >=80:
    print('80+')
else:
    print()

for

s = 'ABCD'
for ch in s:
    print(ch)

字符串模板format

temp = 'Hello {}'
result = temp.format('world')   ==> Hello world

#制定顺序
result= 'Hello {0}, hello {1}'.format('world','python')

#命名
result= 'Hello {a}, hello {b}'.format(a='world',b='python')

字符串切片

s='ABC'
ab = s[0:2]      ==>AB

地板除    (得到整数部分)

10//2.5 ==>4.0
10//3 ==> 3

小数点位数 round

# round(数，保留位数)

num = 10 / 3    ==> 3.3333333333333335
#round保留两位
round(num, 2)  ==>3.33

短路计算

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

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

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

raw字符串

r'...'   #单行
r'''...''' #多行

元组——tuple，用（）将元素括起来，有序容器，内容固定

元组数据类型可以把不是元组的容器转换为元组，比如将列表转换成元组，也可将元组转换为列表，列表内容可变

定义一个函数要使用 def 语句，依次写出函数名、括号()、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。

return语句表示返回的意思，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。

任务：

# 请定义一个square_of_sum()函数，它接收一个list，返回list中每个元素平方的和。

# Enter a code
def square_of_sum(list1):
    sum = 0
    for i in list1:
        sum += (i*i)
    return sum
L = [1, 2, 3, 4]
x = square_of_sum(L)
print(x)

可以使用函数，把重复的逻辑代码封装起来。

把封装重复逻辑代码的过程就做抽象，抽象是数学中非常常见的概念。

函数就是最基本的一种代码抽象的方式。

Python内置的大部分函数参考网址：https://docs.python.org/3/library/functions.html
要调用一个函数，需要知道函数的名称和参数。

需要注意的是，传递的参数数量一定要和函数要求的一致，不然将会引起错误。

如果传入的参数数量是对的，但是参数的类型不能被函数所接受，也会引起错误。

int()函数可以将合法的其它类型数据转换为整数，str()函数可以将其它类型的数据转换为字符串。

任务：

# sum()函数接收一个list作为参数，并返回list所有元素之和。请计算 1*1 + 2*2 + 3*3 + ... + 100*100。

# Enter a code
list1 = []
for i in range(1, 101):
    list1.append(i*i)
sum1 = sum(list1)
print(sum1)

1. 使用remove()方法删除元素以外，还可以使用discard()方法删除元素。

当元素不存在时，使用discard()并不会引发错误，所以使用discard()是更加高效的一个方法。

2. set也提供了clear()方法，可以快速清除set中的所有元素。

3. set提供方法判断两个set之间的关系，比如判断其中一个set是否为另外一个set的子集的issubset()方法或者超集的issuperset()方法。

# 判断s1是否为s2的子集
s1.issubset(s2) # ==> True
# 判断s2是否为s1的超集
s2.issuperset(s1) # ==> True

4. set提供isdisjoint()方法，可以快速判断两个集合是否有重合，如果有重合，返回False，否则返回True。

任务

已知两个集合s1、s2，请判断两个集合是否有重合，如果有，请把重合的元素打印出来。s1 = set([1, 2, 3, 4, 5])    s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])

# Enter a code
s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
same  = set([])
for i in s1:
  for j in s2:
    if i == j:
      same.add(i)
print(same)

# Enter a code
s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
same = set([])
for i in s1:
    if i in s2:
        same.add(i)
print(same)