1.1找出字典中的key
info = {'name': 'AI浩', ?'sex': 'f', 'address': '中国北京'}
dicKeys=list(info.keys())
print(dicKeys)
print(dicKeys[0])
输出一个列表 列表中对应的是字典中的key 然后通过索引寻找key
?1.2 找出字典中的所有value
info = {'name': 'AI浩', ?'sex': 'f', 'address': '中国北京'}
dicvalues=list(info.values())
print(dicvalues)
print(dicvalues[0])
方法同第一个一样 输出列表
?需要注意的是key是键 在前 value 是值 值在后面
1.3 找出字典中的（键值）
属性items 返回一个包含所有键值元祖的列表
info = {'name': 'AI浩', ?'sex': 'f', 'address': '中国北京'}
dicItems=info.items()
print(dicItems)
?1.4 判断key是否存在
key in dict 如果键在字典dict 中则返回true? 否则则返回false
info = {'name': 'AI浩', ?'sex': 'f', 'address': '中国北京'}
ss='name' in info
print(ss)
?1.5 遍历字典的几种方式
（1） 遍历字典中的所有key 键
info = {'name': 'AI浩', ?'sex': 'f', 'address': '中国北京'}
for key in info.keys():
? ? print(key)
（2） 遍历字典中的所有value 值
info = {'name': 'AI浩', ?'sex': 'f', 'address': '中国北京'}
for value in info.values():
? ? print(value)
?（3） 遍历字典中的项（元素）
info = {'name': 'AI浩', ?'sex': 'f', 'address': '中国北京'}
for item in info.items():
? ? print(item)
?2 函数 关于函数 函数是组织好的 可重复使用的 用来实现单一，或相关联的功能代码段
函数能提高应用的模块性 和代码的重复利用率 Python中提供许多内建函数 比如print 与此同时也可以创建函数 叫做自定义函数
2.1定义函数
语法：
def 函数名（参数列表）:
? ? 函数体
# 定义一个函数，能够完成打印信息的功能
def printInfo():
? ? print ('------------------------------------')
? ? print (' ? ? ? ? 人生苦短，我用Python')
? ? print ('------------------------------------')
定义函数的规则
1.函数代码块以def关键词开头，后接函数标识符名称和圆括号（）
2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
3.函数的第一行语句可以选择性地使用文档字符串用于存放函数说明
4.函数内容以冒号：起始 并且缩进
return （表达式）结束函数时 选择性返回一个值给调用方，不代表达式的return 相当于返回None
2.2 调用函数
定义函数之后 就相当于是有一个具有某些功能的代码 如果想让这些代码能够执行 需要调用函数 通过函数名（）即可完成调用
? ? # 定义完函数后，函数是不会自动执行的，需要调用它才可以
? ? printInfo()
2.3 函数的注释
在函数定义下面使用''' 进行注释 使用help函数可以查看函数的注释
def test(a1, a2):
? ? '''
? ? 用来完成对2个数求和"
? ? :param a1:第一个参数
? ? :param a2:第二个参数
? ? :return:无
? ? '''
? ? print("%d" % (a1 + a2))
print(help(test))
2.4 函数的参数
2.4.1 函数的定义
参数分为形参 和 实参?
形参：函数定义时括号内的参数
实参：函数调用时括号内的参数
形参相当于变量 实参相当于变量的值
?def add2num(a, b):
? ? c = a + b
? ? print(c)
? ??
add2num(11, 22) ?# 调用带有参数的函数时，需要在小括号中，传递数据
a,b为形参；11,12为实参
形参：只在被调用时，才分配内存单元，调用结束 立刻释放所分配的内存
只有在函数内部有效
实参：可以是变量 常量 表达式 函数
进行函数调用时，实参必须是确定的值
?2.4.2 参数的分类
python中的函数除了正常的定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码
（1）未知参数
位置形参： 函数定义时，从左往右写的参数 比如上面的 a，b
位置实参： 函数调用时，从左往右写的参数，比如上面的11.12
位置形参定义多少个 调用时位置实参必须写上多少个 多一个少一个都不行
（2）关键参数
正常情况下，给函数传参数，要按顺序 如果不想按顺序 就用关键参数
指定参数名的参数就叫做关键参数
函数调用时，func（a=1，b=2） 这种指定了参数名的参数 就是关键参数
调用函数时，关键参数可以和位置参数一起用，但是关键参数必须在位置参数的后面 不然会报错
def add2num(a, b):
? ? c = a + b
? ? print(c)
#正确的调用方式
add2num(11, b=22) ?# 调用带有参数的函数时，需要在小括号中，传递数据
add2num(a=11, b=22)
add2num(b=11, a=22)
# 错误的调用方式。
#add2num(22, a=22)
#add2num(b=11,22)? ?也就是说比如第二个是b 那么第一个不能是b=xxx 如果第一个是a 那么不能第二个等于a=xxx
（3）默认参数
函数定义时，默认参数必须在位置形参的后面
函数调用时，指定参数名的参数，叫做关键参数
而在函数定义时，给函数名指定值的时候，这个参数叫做默认参数
关键参数 和默认参数两个参数写法一样
关键参数是在函数调用时，指定实参的参数名，也可以说指定值的参数名
默认参数是在函数定义时，指定参数名的值
定义时，如果有默认参数的话，调用时，这个实参可以不写，如果实参不写的话，这个形参的参数值是他的默认值
def add2num(a, b=100):
? ? c = a + b
? ? print(c)
add2num(11, b=22) ?# 调用带有参数的函数时，需要在小括号中，传递数据
add2num(11)
（4）动态参数 *args **kwargs
*args 针对函数定义时的*
def func（a,b,*args）
pass
*args 会接受函数调用时 传入的多余的位置实参
*args 是一个元祖
例：func（1,2,3,4,5,6）函数调用时，因为函数定义时，*args 前面有形参a，形参b，*args 就接受调用时多余的位置实参
a为1，b为2，*args为（3,4,5,6）是一个元祖
针对函数调用时的*
func（1,2，*[1,2,3,4]）==func(1,2,1,2,3,4)
函数调用时有* 就应该like将后面的列表，元祖，字符串之类的迭代器打散成位置参数来看
注意如果*后面是一个字典的话，那么打散成的位置参数就是字典的key
*可以看做是for循环
形参中*args 只能接受多余的位置实参 成为一个元祖 但不能接受关键实参
def calc(*numbers):
? ? sum = 0
? ? for n in numbers:
? ? ? ? sum = sum + n * n
? ? return sum
nums = [1, 2, 3]
# 调用方式1
print(calc(nums[0], nums[1], nums[2]))
#调用方式2
print(calc(*nums))
调用的时候*nums 直接成了一个元祖！
?**kwargs
针对函数定义时，站在形参的角度看**
接受多余的关键实参，成为一个字典dict
字典的key是关键实参的变量名，字典的value 是关键实参的值
将字典交给**后面的变量名，这里是kwargs
站在实参的角度看**
d={‘x’：1，‘y’：2，‘z’：333}
func（**d）#等价于func（x=1,y=2,z=333）
函数调用时，后面可以接一个字典 然后会吧字典打散成关键参数的形式?也就是key=value的形式
def person(name, age, **kw):
? ? print('name:', name, 'age:', age, 'other:', kw)
#调用方式1
print(person('Michael', 30))
#调用方式2
print(person('Bob', 35, city='Beijing'))
#调用方式3
print(person('Adam', 45, gender='M', job='Engineer'))
（5）混合参数时，参数的顺序
函数定义时：
从左往右：位置形参>*args>默认参数>**kwargs
位置形参>默认参数>*args>**kwargs也可以
因为函数调用时给的实参满足了位置形参、默认参数之后，会吧多余的位置实参留给args 这样并不会报错
但是**kwargs 必须在*args 后面
默认形参必须在位置形参后面
函数调用时 从左到右：位置实参>*args>关键参数>**kwargs
因为*args 在函数调用时，会被打散成位置实参，而关键参数必须在位置实参的后面，否则会报错
SyntaxError: positional argument follows keyword argument
*args 必须在**kwargs 后面 否则会报语法错误：SyntaxError: iterable argument unpacking follows keyword argument unpacking
总结
python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数
默认参数一定要用不可变的对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法
*args 是可变参数 ，args接受的是一个tuple
**kw是关键字参数，kw接受的是一个dict
以及调用函数时，如何传入可变参数和关键字参数的语法
可变参数可以直接传入：func（1,2,3） 又可以先组装list或tuple 在通过*args 传入：func（*（1,2,3））； 关键字参数既可以直接传入： func（a=1,b=2） 又可以先组装dict 在通过**kw传入：func（**{‘a’:1,'b':2}）
使用*args 和**kwargs? 是python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法
命名的关键字参数是未来限制调用者可以传入的参数名 同时可以提供默认值
定义命名的关键字参数在没有可变参数的情况下，不要忘记了写分隔符* 否则定义的是位置参数
2.4.3 参数的传递
Python参数传递采用的肯定是传对象引用的方式 这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典或者列表的引用）就能修改对象的原始值?
attrList = [0, 1, 2, 3, 4, 5]
print("改变前————————————————————————————————")
print(attrList)
def func(i, attrList):
? ? attrList[i] = attrList[i] * 10
print("改变后————————————————————————————————")
for i in range(3):
? ? func(i, attrList)
print(attrList)
?List发生了改变 由于在0,1,2 位置均*10 如果传入不可变的元素呢？
a = 10
print("改变前————————————————————————————————")
print(a)
def func(c):
? ? print(id(c))
? ? c += 2
? ? print(id(c))
? ? print("func函数的c值：", c)
print(id(a))
func(a)
print("改变后————————————————————————————————")
print(a)
print(id(a))
将a变量作为参数传递给了func函数，传递了a的一个引用，把a的地址传递过去了，所以在函数内获取的变量c的低值跟变量a的低值是一样的，但是在函数内，对c进行赋值运算，c的值从10变成了12，实际上10和12所占的内存空间都还是村爱的，赋值运算后，c指向12所在的内存。而a仍然指向10所在的内存，所以后面打印a，其值还是10
2.5 函数的返回值
想要把函数中的结果返回给调用者，需要在函数中使用return 例：
def add2num(a, b):
? ? c = a + b
? ? return c
print(add2num(1, 2))
可以返回多个返回值，例：
def divid(a, b):
? ? shang = a // b
? ? yushu = a % b
? ? return shang, yushu
sh, yu = divid(5, 2)
print(sh,yu)
2.6 局部变量与全局变量
?局部变量就是定义在一个函数体内部的变量
全局变量就是定义在外面的变量
a = 1
def f():
? ? b = 2
其中这几行代码中 a就是全局变量，而b是局部变量。局部比阿娘只在函数体内部有效，出了函数体 外面是访问不到的 而全局变量则对下面的代码都有效
全局变量可以直接在函数体内部使用，可以直接访问 但是值得注意的是 如果对于不可变类型的数据 如果在函数里面进行了赋值操作，则对外面的全局变量不产生应县 因为相当于新建了一个局部变量，只是名字和全局一样，而对于可变类型如果用赋值语句 同样对外部不产生影响
g_b = 3
g_l1 = [1, 2]
g_l2 = [1, 2, 3]
def t1():
? ? g_b = 2
? ? g_l1 = []
? ? g_l2.append(7)
t1()
print(g_b, g_l1, g_l2)
?global 关键字
上面说到，如果使用的是赋值语句 ，在函数内部相当于新建了一个变量，并且重新给了指向，但是有时候我们想把这个变量就是外部的那个全局变量，在赋值操作的时候，就是对全局变量给了重新的指向，这个时候可以通过global 关键字表示我在函数里面的这个变量是使用的全局那个
g_b = 3
def t1():
? ? global g_b
? ? g_b = 2
t1()
print(g_b)
?这个时候发现全局变量g-b也重新指向 了 这是因为global gb 表示指定了函数中的外面那个
9.13? 下次任务递归函数
?
?