一.函数
形参和实参：
>>> def MyFirstFunction(name):
'函数定义过程中的name是叫形参'
... print('传递进来的' + name + '叫做实参，因为Ta是具体的参数值！')
print前面要加缩进tab，否则会出错。
>>> MyFirstFunction('小红')
小红
传进来的小红是实参关键字参数：
关键字参数，用在调用函数的实参的位置，其目的就是给形参下一个定义，这样的话，python会按照关键字去索引，而不是用顺序去索引。
>>> def SaySome(name,words):
... print(name + '->' + words)
>>> SaySome('小红','小蓝')
小红->小蓝
>>> SaySome(words = '小红',name = '小蓝')
小蓝->小红默认参数
默认参数(即形参中给定默认值，则在未给实参时会以默认值输出)
>>> def SaySome(name = 'Hadley',words = 'Great'):
... print(name + 'is' + words)
...
>>> SaySome()
HadleyisGreat
>>> SaySome('abc','def')
abcisdef收集参数（可变参数）
>>> def test(*params):
... print('参数的长度是：',len(params))
... print('第二个参数是：',params[1])
...
>>> test(1,'abc',2,3,4,5)
参数的长度是： 6
第二个参数是： abc函数与过程
再谈谈返回值
如果有返回值，函数则返回对应值；如果没有，则返回None。
>>> def back():
... return [1,'Hadley',0.66]
...
>>> back()
[1, 'Hadley', 0.66]
>>> def back():
... return (1,'Hadley',0.66)
...
>>> back()
(1, 'Hadley', 0.66)
>>> c = back()
>>> c[0]
1
>>> c[1]
'Hadley'
>>> c[2]
0.66局部变量与全局变量
局部变量：在局部生效如在函数中定义的变量
全局变量：作用于整个模块。函数内若试图修改全局变量，Python会新建一个同名局部变量用于存储修改值，原全局变量的值不变。不要在函数内部去修改全局变量。
>>> def discounts(price, rate):
... final_price = price * rate
... old_price = 88 #这里试图修改全局变量
... print('修改后old_price的值是：', old_price)
... return final_price
...
>>> old_price = float(input('请输入原价：'))
请输入原价：100
>>> rate = float(input('请输入折扣率：'))
请输入折扣率：0.8
>>> new_price = discounts(old_price, rate)
修改后old_price的值是： 88
>>> print('修改后old_price的值是：', old_price)
修改后old_price的值是： 100.0
>>> print('打折后价格是：', new_price)
打折后价格是： 80.0global可将局部变量声明为全局变量
>>> count = 5
>>> def Myfun():
... count = 10
... print(count)
...
>>> Myfun()
10
>>> print(count)
5
>>> def Myfun():
... global count
... count = 10
... print(count)
...
>>> Myfun()
10
>>> print(count)
10内嵌函数和闭包
内嵌函数：
>>> def fun1():
... print('fun1正在被调用')
... def fun2():
... print('fun2正在被调用')
... fun1()
...
>>> fun1()
fun1正在被调用
fun1正在被调用
fun1正在被调用
fun1正在被调用
fun1正在被调用
....>>> def fun1():
... print('fun1正在被调用')
... def fun2():
... print('fun2正在被调用')
... fun2()
...
>>> fun1()
fun1正在被调用
fun2正在被调用闭包（closure）
>>> def funX(x):
... def funY(y):
... return x*y
... return funY
...
>>> i = funX(5)
>>> i(8)
40
>>> funX(5)(8)
40>>> def fun1():
... x = 5
... def fun2():
... nonlocal x
... x*=x
... return x
... return fun2()
...
>>> fun1()
25lambda表达式
lambda表达式用法。lambda表达式是匿名函数，没有名字def
lambda x : 2 * x +1
x是参数，2* x +1是表达式
返回值是函数对象
>>> def ds(x):
... return 2*x+1
...
>>> ds(5)
11
>>>
>>> lambda x : 2*x + 1
<function <lambda> at 0x0000022A95C23060>
>>> g = lambda x: 2*x + 1
>>> g(5)
11>>> def add(x,y):
... return x+y
...
>>> add(3,4)
7
>>> lambda x,y:x+y
<function <lambda> at 0x0000022A95C23100>
>>> g = lambda x,y:x+y
>>> g(3,4)
7递归
递归必须满足哪两个基本条件
（1）函数调用自己；
（2）函数设置了正确的返回值。
eg：•写一个求阶乘的函数
正整数阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。
例如所给的数是5，则阶乘式是1×2×3×4×5，得到的积是120，所以120就是4的阶乘。
假设我们n的值传入是5，那么：
>>> def factorial(n):
... if n==1:
... return 1
... else:
... return n*factorial(n-1)
...
>>> nember = int(input('请输入一个正整数：'))
请输入一个正整数：5
>>> result = factorial(nember)
>>> print(result)
120二.字典
fromkey()方法用于创建并返回一个新的字典。它有两个参数，第一个参数是字典的键；第二个参数是可选的，是传入键的值。如果不提供，默认是None
>>> dict1 = {}
>>> dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}>>> dict2 = {}
>>> dict2.fromkeys((1,2,3),"Number")
{1: 'Number', 2: 'Number', 3: 'Number'}>>> dict3 = {}
>>> dict3.fromkeys((1,2,3),('one','two','three'))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}访问字典的方法有key()、values()和items()
key()用于返回字典中的键，value()用于返回字典中所有的值，item()当然就是返回字典中所有的键值对（也就是项）
>>> dict1 = dict1.fromkeys(range(5),'好')
>>> dict1.keys()
dict_keys([0, 1, 2, 3, 4])
>>> dict1.values()
dict_values(['好', '好', '好', '好', '好'])
>>> dict1.items()
dict_items([(0, '好'), (1, '好'), (2, '好'), (3, '好'), (4, '好')])get()方法提供了更宽松的方式去访问字典项，当键不存在的时候，get()方法并不会报错，只是默默第返回一个None，表示啥都没找到：
>>> dict1.get(10)
>>> dict1.get(4)
'好'如果希望找不到数据时返回指定的值，可以在第二个参数设置对应的默认返回值：
>>> dict1.get(32,'木有')
'木有'如果不知道一个键是否在字典中，可以使用成员资格操作符（in 或 not in）来判断
>>> 31 in dict1
False
>>> 4 in dict1
Trueclear()可清空一个字典
>>> dict1
{0: '好', 1: '好', 2: '好', 3: '好', 4: '好'}
>>> dict1.clear()
>>> dict1
{}copy()方法是复制字典（全拷贝）
>>> a = {1:'one',2:'two',3:'three'}
>>> b = a.copy()
>>> id(a)
2460458286784
>>> id(b)
2460455583296
>>> a[1] = 'four'
>>> a
{1: 'four', 2: 'two', 3: 'three'}
>>> b
{1: 'one', 2: 'two', 3: 'three'}pop()是给定键弹出对应的值，popitem()是随机弹出一个项
>>> a
{1: 'four', 2: 'two', 3: 'three'}
>>> a.pop(1)
'four'>>> a.popitem()
(3, 'three')
>>> a.popitem()
(2, 'two')setdefault()方法与get()方法相似，但setdefault()在字典中找不到相应的键值时会自动添加
>>> a = {1:'one',2:'two',3:'three'}
>>> a.setdefault(2)
'two'
>>> a.setdefault(3)
'three'update()方法可以更新字典
>>> a = {1:'one','小白':None}
>>> b = {'小白':'狗'}
>>> a.update(b)
>>> a
{1: 'one', '小白': '狗'}三.集合
字典的表亲--集合（在python3中，如果用大括号括起一堆数字但没有体现映射关系，那么就会认为这堆玩意儿就是个集合）
>>> num1 = {}
>>> type(num1)
<class 'dict'>
>>> num2 = {1,2,3}
>>> type(num2)
<class 'set'>集合中的元素都是唯一的（集合会自动帮我们把重复的数据清理掉，集合是无序的，所以不能试图去索引集合中的某一个元素）
>>> num = {1,2,3,3,4,5}
>>> num
{1, 2, 3, 4, 5}如何创建一个集合有两种方法：1、直接把一堆元素用大括号括起来；2、用set()
1、直接把一堆元素用大括号括起来
>>> set1 = {'小红','小蓝','小绿'}2、用set()
>>> set1 = {'小红','小蓝','小绿'}
>>> set2 = set(['小红','小蓝','小绿'])
>>> set1 == set2
True
