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

递归函数的优点是定义简单，逻辑清晰；

理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。（函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧）

用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语句。
比如在前面的无限循环里面，只要在恰当的时机，我们使用break跳出循环，也可以求出1~100的和。

num = 1
sum = 0
while True:
    if num > 100:
        break
    sum = sum + num
    num = num + 1
print(sum)

同样的，对于字符串s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'，假如希望输出s的前20个字符，而不是所有字符，我们也可以使用break。

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
num = 1
for ch in s:
    if num > 20:
        break
    print(ch)

s = 'ABCD'
print(s[0])
print(s[1])
print(s[2])
print(s[3])

但是，这是字符串s比较短的情况下可以实现的，当s拥有成千上万个字符的时候，难道我们要为此书写上万行代码吗？这个时候for循环就可以派上用场了。

s = 'ABCD'
for ch in s:
    print(ch) # 注意缩进

在上述代码中，ch是在for循环中定义的，意思是把字符串s中的每一个元素依次赋值给ch，然后再把ch打印出来，直到打印出字符串s的最后一个字符为止。

当函数没有返回结果，这个时候从函数获取到的是一个空值None。

函数可以返回多个值，但多个值之间用逗号隔开且注意顺序。

# 指定顺序
template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.
# 调整顺序
template = 'Hello {3}, Hello {2}, Hello {1}, Hello {0}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello imooc, Hello Beijing, Hello China, Hello World.

除了使用顺序，还可以指定对应的名字，使得在format过程更加清晰。

# 指定{}的名字w,c,b,i
template = 'Hello {w}, Hello {c}, Hello {b}, Hello {i}.'
world = 'World'
china = 'China'
beijing = 'Beijing'
imooc = 'imooc'
# 指定名字对应的模板数据内容
result = template.format(w = world, c = china, b = beijing, i = imooc)
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.

定义函数：

使用 def 语句，依次写出函数名、括号()、括号中的参数和冒号；

在缩进块中编写函数体。（函数的返回值用 return 语句返回）

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

把重复的逻辑代码封装起来——函数。

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

https://docs.python.org/3/library/functions.html    （python内置的大部分函数）

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

 \n表示换行

a = 'python'

print('hello,', a or 'world')

b = ' '

print('hello,', b or 'world')

('hello,', 'python')
('hello,', 'world')

解释：通过 or 运算，可以把空字符串"变成"默认字符串，而非空字符串保持不变。

set中的其他方法：

不会报错的删除方法discard():

清除所有元素的方法clear():

name_set = set(['Jenny', 'Ellena', 'Alice', 
                'Candy', 'David', 'Hally', 'Bob', 
                'Isen', 'Karl'])
print(name_set)
name_set.clear()
print(name_set)

集合的子集和超集（两个集合间的关系）：

s1 = set([1, 2, 3, 4, ])
s2 = set([1, 2, 3, 4, 5, ])
# 判断s1是否为s2的子集
s1.issubset(s2) # ==> True
# 判断s2是否为s1的超集
s2.issuperset(s1) # ==> True

判断集合是否重合：

isdisjoint()方法：如果有重合，返回False，否则返回True。

s1 = set([1, 2, 3, 4, 5])
s2 = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
s1.isdisjoint(s2) # False

删除set中的元素

remove()方法

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
name_set.remove('Jenny')
print(name_set)

> 如果remove的元素不在set里面的话，那么将会引发错误。

往set中添加元素

1. 方法add()：一个一个添加

• names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
  name_set = set(names)
  name_set.add('Gina')

    2.update()方法：可以一次性给set添加多个元素。

• names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
  new_names = ['Hally', 'Isen', 'Jenny', 'Karl']
  name_set = set(names)
  name_set.update(new_names)  
  print(name_set)

访问set中的某个元素实际上就是判断一个元素是否在set中，这时可以用in来判断某个元素是否在set中。

> set元素是区分大小写的，必须大小写完全匹配，才能判断该元素在set里面。

set内也拥有一系列元素，且set里面的元素是不允许重复的，set里面的元素是没有顺序的。

创建set的方式是使用set()，并传入一个list，list的元素将会被转换成set的元素。

s = set([1, 4, 3, 2, 5])
print(s) #  set([1, 2, 3, 4, 5])

在向set传入包含相同元素的list时，相同元素只会保留一个。

dict中的其他方法：

获取所有的key：

使用keys()函数

d = {
     'Alice': [50, 61, 66], 
      'Bob': [80, 61, 66], 
      'Candy': [88, 75, 90]
      }
for key in d.keys():
    print(key)

获取所有的value：

使用values()函数

d = {
     'Alice': [50, 61, 66], 
      'Bob': [80, 61, 66], 
      'Candy': [88, 75, 90]
      }
for value in d.values():
    print(value)

清除所有元素：

使用clear()函数

d = {
     'Alice': [50, 61, 66], 
      'Bob': [80, 61, 66], 
      'Candy': [88, 75, 90]
      }
d.clear()
print(d)