python - 函数 / 字典 / 集合

一.函数

形参和实参：

>>> 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.0

global可将局部变量声明为全局变量

>>> 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()
25

lambda表达式

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
True

clear()可清空一个字典

>>> 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