一.Python中标识符的命名规则
1 区分大小写：Myname与myname是两个不同的标识符。
2 首字符可以是下画线（_）或字母，但不能是数字。
3 除首字符外的其他字符必须是下画线、字母和数字。
4 关键字不能作为标识符。
5 不要使用Python的内置函数作为自己的标识符。
6 Unicode命名规则
二.变量、语句、注释
1.定义变量不需要定义类型，后续也可以修改
2.语句结束后不需要加分号，形如：a=b=c=3 这种链式赋值语句可以同时给多个变量相同的值
3.注释：单行注释 #
三.模块
1.import 模块名 这样可以导入模块所有代码元素，在访问时前缀模块名字
import m2
y=20
print(m2.x)
x=20.0
from m2 import x
y=20
print(x)2.from 模块 import x 意为导入模块中的x元素，访问时不需要加模块名字
from m2 import x as x2
x=100
y=20
print(x2)3.from 模块 import 代码元素 as 代码元素别名：
与第二种情况类似，在当前m1模块的代码元素（x变量)与要导入的m2模块的代码元素（x变量）名称有冲突时，可以给要导入的代码元素（m2中的x）一个别名x2
示例
# py1.py
x="你好"
# py2.py
# import py1
# print(py1.x)
# from py1 import x
# print(x)
from py1 import x as x1
print(x1)四.数据类型（数字）
在Python中所有的数据类型都是类，每个数据值都是类的“实例”。
在Python中有6种主要的内置数据类型：数字、字符串、列表、元组、集合和字典。列表、元组、集合和字典统称容器类型。
Python中的数字类型有4种：整数类型、浮点类型、复数类型和布尔类型。需要注意的是，布尔类型也是数字类型，它事实上是整数类型的一种
1.整数类型
a=type(28) #返回数据类型
a=0b11100 #二进制
a=0o34 #八进制
a=0x1c #十六进制
print(a)2.浮点类型
a=type(1.0) #返回数据类型
a=3.36e2 #科学计数法
a=.336e-2 #省略前缀0
print(a)3.复数类型
a=type(1+2j) # 返回数据类型<complex>
a=(1+2j) + (2+3j) # 复数相加
print(a)4.布尔类型
python中的数据类型转换很灵活，任何类型的数据都可以通过 bool()函数转换为布尔值 ，，空值和0值会被转换为False，反之会被转换为True
空值包括空字符串‘’，空列表[]，空字典{}
5.数字类型转换
隐式转换（也就是默认的自动的转换）
布尔和整数类型运算，结果是整数
布尔或整数和浮点运算，结果是浮点数
a=1
b=True
print(a+b) # 2
c=2.0
print(a+b+c) # 4.0显式转换
int() bool() float()
a=(1.0)+1
print(int(a)) # 2
print(float(a)) # 2.0
print(bool(a)) # True五.运算符
1.算术运算符
2.比较运算符
1.比较字符串的大小时，逐一遍历比较字符编码的大小，如果两个字符串第一个字符不能比较出大小，则比较两个字符串的第二个字符，直到比较出结果
2.比较列表大小，即逐一比较其中元素的大小，如果两个列表中的第一个元素不能比较出大小，则比较两个字符串的第二个字符，直到比较出结果。（两个列表中元素类型要兼容）
3.逻辑运算符
4.位运算符
位运算都是相对于二进制位数来运算的
按位取反公式：~a=(a+1)*(-1)
5.赋值运算符
6.运算符优先级
优先级从高到低大概是：算术运算符，位运算符，关系运算符，逻辑运算符，赋值运算符
六.程序流程控制
1.分支语句
'''
if 条件:
语句组
'''
score=int(input("请输入一个0~100的整数：")) # input() 函数从控制台获取用户输入的字符串
if score >=85:
print("您很优秀！")
if score <60:
print("您需要继续努力")
if (score>=60) and (score<85):
print("您的成绩还可以，仍需努力")'''
if 条件:
语句组1
else:
语句组2
'''
score=int(input("请输入一个0~100的整数：")) # input() 函数从控制台获取用户输入的字符串
if score >=60:
if score>=85:
print("您很优秀！")
else:
print("您的成绩还可以，仍需努力")
else:
print("您仍需努力")'''
if 条件:
语句组1
elif 条件2:
语句组2
elif 条件3:
语句组3
else:
语句组
'''
score=int(input("请输入一个0~100的整数：")) # input() 函数从控制台获取用户输入的字符串
if score >=90:
grade = 'A'
elif score >=80:
grade = 'B'
elif score >=70:
grade = 'C'
elif score >=60:
grade = 'D'
else:
grade = 'F'
print("Grade = "+grade)2.循环语句
1.while
'''
while 循环条件:
循环体语句组
[else:
语句组] #中括号部分可以省略
'''
i=0
while i*i<1000:
i+=1
print("i="+str(i)) # str() 函数为将括号内元素转换为字符串
else:
print("while over!")若while循环体没有中断，而是正常执行完结束，就执行else语句
循环控制：break中断，continue继续，
2.for
由于简单的设计理念，python中只有一种for语句，就是for-in语句，可以遍历任意可迭代对象中的元素
'''
for 变量 in 可迭代对象:
循环体语句组
[else:
语句组]
'''
print("----字符串-----")
for item in 'Hello':
print(item)
# 声明一个整数列表
numbers = [43,32,55,74]
print("-----整数列表-----")
for items in numbers:
print(item)range(数字)函数，返回整数序列，取值大于等于0且小于数字，共有数字个整数
# 计算水仙花数
i = 101
while i<=999:
a = i // 100
b = i // 10 % 10
c = i % 10
if (a**3+b**3+c**3) == i:
print(str(i))
i+=1七.容器类型的数据
Python内置的数据类型如序列（列表、元组等）、集合和字典等可以容纳多项数据，我们称它们为容器类型的数据
1.序列
序列（sequence）是一种可迭代的、元素有序的容器类型的数据
序列包括列表（list）、字符串（str）、元组（tuple）和字节序列（bytes）等。
a.索引
序列中的元素都是有序的，每一个元素都带有序号，这个序号叫作索引。索引有正值索引和负值索引之分。
a = 'hello'
print(a[0])
print(a[4])
print(a[-5])
print(max(a)) # max()函数用于返回最后一个元素
print(min(a)) # min()函数用于返回第一个元素
print(len(a)) # len()函数用于获取序列的长度b.加和乘操作
加（+）和乘（）运算符也可以用于序列中的元素操作。加（+）运算符可以将两个序列连接起来，乘（）运算符可以将两个序列重复多次。
a='hello'
print(a*2)
print(a+',,,')
a+='world'
print(a)c.切片操作
序列的切片（Slicing）就是从序列中切分出小的子序列
切片运算符的语法形式为[start：end：step]。其中，start是开始索引，end是结束索引，step是步长（切片时获取的元素的间隔，可以为正整数，也可以为负整数）
注意：切下的小切片包括start位置的元素，但不包括end位置的元素，start和end都可以省略。
d.成员测试
成员测试运算符有两个：in和not in，in用于测试是否包含某一个元素，not in用于测试是否不包含某一个元素。
a="hello"
print('e' in a)
print('1' in a)2.列表
列表（list）是一种可变序列类型，我们可以追加、插入、删除和替换列表中的元素。
a.创建列表
创建列表有两种方法。
1、list（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）。
2、 [元素1，元素2，元素3，⋯]：指定具体的列表元素，元素之间以逗号分隔，列表元素需要使用中括号括起来
# 方式1
a=[20,10,20,5]
b=['aa',1,2,3,'bb']
c=[]
# 方式2
d=list('hello')
print(a)
print(b)
print(c)
print(d)
'''结果
[20, 10, 20, 5]
['aa', 1, 2, 3, 'bb']
[]
['h', 'e', 'l', 'l', 'o']
'''b.追加元素
列表是可变的序列对象，列表可以追加元素。
1 、在列表中追加单个元素时，可以使用列表的append（x）方法。
2 、在列表中追加多个元素时，可以使用加（+）运算符或列表的extend（t）方法。
问题：append(x)是方法，list(iterable)是函数，方法和函数有什么区别？
在Python中方法和函数是有区别的，方法隶属于类，通过类或对象调用方法，例如在list.append(x)中，list是列表对象;函数不属于任何类，直接调用即可，例如list(iterable)
list = [20,10,50,30]
list.append(80) # 追加单个元素
print(list)
t=[1,2,3,4]
list+=t # 使用+=追加多个元素
print(list)
list.extend(t) # 使用extend()方法追加多个元素
print(list)c.插入元素
想向列表中插入元素时，可以使用列表的list.insert（i，x）方法，其中，i指定索引位置，x是要插入的元素。
list = [20,10,50,30]
list.insert(2,80) # 在索引2的位置之前插入一个元素，新元素的索引是2
print(list)d.替换元素
list = [19,20,21,22]
list[1]=30
print(list)e.删除元素
想在列表中删除元素时，可使用列表的list.remove（x）方法，如果找到匹配的元素x，则删除该元素，如果找到多个匹配的元素，则只删除第一个匹配的元素。
list = [19,20,21,22]
list.remove(20) # 删掉20
print(list)
list = [19,20,19,21,19]
list.remove(19) # 删掉第一个19
print(list)3.元组
元组（tuple）是一种不可变序列类型。
a.创建元组
创建元组时有两种方法。
1 tuple（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）。
2 （元素1，元素2，元素3，⋯）：指定具体的元组元素，元素之间以逗号分隔。对于元组元素，可以使用小括号括起来，也可以省略小括号
a=5,6,7,8 # 元组创建可以省略括号
print(a)
print(type(a)) # 元组
b=(5,6,7,8) # 元组指定元素创建
print(b)
print(type(b)) # 元组
c=tuple([5,6,7,8]) # tuple()函数创建元组
print(c)
print(type(c))
d=tuple(1,) # 创建只有一个元素的元组，元素后面的逗号不能省略
d=1,b.元组拆包
创建元组，并将多个数据放到元组中，这个过程被称为元组打包。
与元组打包相反的操作是拆包，就是将元组中的元素取出，分别赋值给不同的变量
s_id,s_name=(102,'张三') # 分别赋值装包
print(s_id) # 拆包
print(s_name) # 拆包问题：本例元组(102,'张三'）中的两个元素分别是不同的数据类型，这种情况是否允许？
答：当然允许，不仅是元组，事实上所有容器类型的数据中都可以保存任意类型的数据，只不过通常在容器中只保存相同类型的容器
4.集合
集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据。
a.创建集合
序列中的元素是有序的；集合中的元素是无序的，但元素不能重复
我们可以通过以下两种方式创建集合。
1 set（iterable）函数：参数iterable是可迭代对象（字符串、列表、
元组、集合和字典等）。
2 {元素1，元素2，元素3，⋯}：指定具体的集合元素，元素之间以
逗号分隔。对于集合元素，需要使用大括号括起来
a = set('hello')
print(a) # 无序不重复随机输出
b= {'o','e','l','l','h'}
print(b) # 无序不重复随机输出
c={}
print(type(b)) # <class 'set'>
print(type(c)) # <class 'dict'>b.修改集合
修改集合类似于修改列表，可以向其中插入和删除元素。修改可变集合有如下常用方法。
add（elem）：添加元素，如果元素已经存在，则不能添加，不会抛出错误。
remove（elem）：删除元素，如果元素不存在，则抛出错误。
clear（）：清除集合
s_set = {'张三','李四','王五'}
s_set.add('懂六')
print(s_set) # {'王五', '张三', '李四', '懂六'}
s_set.remove('李四')
print('李四' in s_set) # False
s_set.clear()
print(s_set) # set()5.字典
字典（dict）是可迭代的、通过键（key）来访问元素的可变的容器类型的数据。
字典由两部分视图构成：键视图和值视图。键视图不能包含重复的元素，值视图能。在键视图中，键和值是成对出现的。
a.创建字典
我们可以通过以下两种方法创建字典。
1 dict（）函数
2 {key1：value1，key2：value2，...，key_n：value_n}：指定具体的字典键值对，键值对之间以逗号分隔，最后用大括号括起来
a=dict({102:'zy',103:'ls',106:'ww'}) # dict()函数创建字典，参数是另一个字典
b=dict(((102,'zy'),(103,'ls'),(106,'ww'))) # dict()函数创建字典，参数是一个元组，元组里至少有三个只有两个元素的元组
c=dict([(102,'zy'),(103,'ls'),(106,'ww')]) # dict()函数创建字典，参数是一个列表，列表里至少有三个只有两个元素的元组
d=dict(zip([102,105,106],['zy','ls','ww'])) # zip()函数将两个可迭代对象打包成元组，第一个参数是字典的键，第二个参数是字典值，个数相同，一一对应
e={102:'zy',103:'ls',106:'ww'}
print(a) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(b) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(c) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(d) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(e) # {102: 'zy', 103: 'ls', 106: 'ww'}b.修改字典
字典可以被修改，但都是针对键和值同时操作的，对字典的修改包括添加、替换和删除。
dict1={102:'zs',103:'ls',104:'ww'}
print(dict1[104]) # ww
dict1[110]='yh' # 若此时字典里有110，就修改为‘yh';反之，添加110，’yh‘
print(dict1) # {102: 'zs', 103: 'ls', 104: 'ww', 110: 'yh'}
dict1.pop(102) # pop(key)函数删除键值对
print(dict1) # {103: 'ls', 104: 'ww', 110: 'yh'}c.访问字典视图
我们可以通过字典中的三种方法访问字典视图。
items（）：返回字典的所有键值对视图。keys（）：返回字典键视图。values（）：返回字典值视图。
dict1 = {102:'zs',103:'ls',104:'ww'}
print(dict1.items()) # 返回字典的所有键值对视图dict_items([(102, 'zs'), (103, 'ls'), (104, 'ww')])
print(list(dict1.items())) # dict_items可以使用list()函数返回键值对列表[(102, 'zs'), (103, 'ls'), (104, 'ww')]
print(dict1.keys()) # 返回字典键视图dict_keys([102, 103, 104])
print(list(dict1.keys())) # dict_keys可以使用list()函数返回键列表[102, 103, 104]
print(dict1.values()) # 返回字典值视图dict_values(['zs', 'ls', 'ww'])
print(list(dict1.values())) # dict_values可以使用list()函数返回键列表['zs', 'ls', 'ww']d.遍历字典
遍历就是从容器中取出每一个元素的过程，我们在进行序列和集合遍历时使用for循环就可以了
字典有两个视图，在遍历时，可以只遍历值视图，也可以只遍历键视图，还可以同时遍历，具体遍历哪个视图就要看你的业务需求了，这些遍历都是通过for循环实现的
s_dict={102:'zs',103:'ls',104:'ww'}
print('----遍历键----')
for s_id in s_dict.keys():
print('学号：'+str(s_id))
print('----遍历值----')
for s_name in s_dict.values():
print('姓名：'+str(s_name))
print('----遍历键：值---')
for s_id,s_name in s_dict.items():
print('学号：{0} - 姓名：{1}'.format(s_id,s_name))容器类型都是可迭代的，最大的特点如下：
1.序列元素是有序的，其中列表是可变的，元组是不可变的
2.集合元素是无序的，不可重复的
3.字典通过键来访问元素，由键视图和值视图构成，键视图不能包含重复的元素
八.字符串
在Python中，字符串（str)是一种不可变的字符序列，序列操作完全适用于字符串
1.字符串的表示方式：
字符串有三种表示方式：普通字符串、原始字符串和长字符串。
a.普通字符串
普通字符串是指用单引号或双引号括起来的字符串
字符转义：如果想在字符串中包含一些特殊的字符，例如换行符、制表符等，在普通字符串中需要转义，前面要加反斜杠（\）
b.原始字符串
实际开发中，普通字符串可能有很多转义符，特别麻烦，这时候我们可以使用原始字符串（raw string)表示，原始字符串中的特殊字符不需要被转义，按照字符串的本来样子呈现，在普通字符串前加r就是原始字符串了
a='hello \n world'
print(a)
b=r'hello \n world'
print(b)c.长字符串
如果要使用字符串表示一篇文章，其中包含了换行、缩进等排版字符，则可以使用长字符串表示。对于长字符串，要使用三个单引号（'''）或三个双引号（＂＂＂）括起来。
s='''
锦瑟
锦瑟无端五十弦，一弦一柱思华年
庄生晓梦迷蝴蝶，望帝春心托杜鹃
沧海月明珠有泪，蓝田日暖玉生烟
此情可待成追忆，只是当时已惘然
'''
print(s)2.字符串与数字的相互转换
字符串与数字互不兼容，只能通过函数进行显式转换
a.将字符串转换为数字
将字符串转换为数字，可以使用int（）和float（）实现，如果成功则返回数字，否则引发异常
num='80'
print(int(num))
num='AB'
print(int(num,16)) # 指定按照十六进制转换numb.将数字转换为字符串
将数字转换为字符串，可以使用str（）函数，str（）函数可以将很多类型的数据都转换为字符串
3.格式化字符串
字符串的format()方法，不仅可以实现字符串的拼接，还可以格式化字符串，例如在计算的金额需要保留小数点后四位、数字需要右对齐等时，可以使用该方法
a.使用占位符
要想将表达式的计算结果插入字符串中，则需要用到占位符。对于占位符，使用一对大括号（{}）表示
i=32
s='i * i = '+str(i*i) # 方法1
print(s)
s='i * i = {}'.format(i *i) # 方法2
print(s)
s='{0} * {1} = {2}'.format(i,i,i*i) # 方法3
print(s)
s='{p1} * {p1} = {p3}'.format(p1=i,p3=i*i) # 方法4
print(s)b.格式化控制符
在占位符中还可以有格式化控制符，对字符串的格式进行更加精准的控制。
字符串的格式化控制符及其说明如下表所示。
格式化控制符位于占位符索引或占位符名字的后面，之间用冒号分隔，语法：{参数序号：格式控制符}或{参数名：格式控制符}。
money = 5834.5678
name = 'Tony'
s='{0:s}今年{1:d}岁，工资是{2:f}元'.format(name,20,money)
print(s)
s='{0}年龄{1}，工资是{2:0.2f}元'.format(name,20,money)
print(s)
s='{0}今天收入是{1:G}元'.format(name,money)
print(s)
s='{0}今天收入是{1:e}元'.format(name,money)
print(s)
s='十进制数{0:d}的八进制表示为{0:o}'.format(18)
print(s)
s='十进制数{0:d}的十六进制表示为{0:x}'.format(18)
print(s)4.操作字符串
a.字符串查找
字符串的find（）方法用于查找子字符串。该方法的语法为str.find（sub[，start[，end]]），表示：在索引start到end之间查找子字符串sub，如果找到，则返回最左端位置的索引；如果没有找到，则返回-1。
s='hello world'
print(s.find('e')) # 在s里找第一个e的下标
print(s.find('l',4)) # 在s里从4号元素开始往后找第一个l
print(s.find('l',4,8)) # 在s的4到8号元素中找第一个lb.字符串替换
若想进行字符串替换，则可以使用replace（）方法替换匹配的子字符串，返回值是替换之后的字符串。
该方法的语法为str.replace（old，new[，count]），表示：用new子字符串替换old子字符串。
count参数指定了替换old子字符串的个数，如果count被省略，则替换所有old子字符串
s= 'ab cd ef gh ij'
print(s.replace(' ','|',2)) # ab|cd|ef gh ij
print(s.replace(' ','|',1)) # ab|cd ef gh ij
print(s.replace(' ','|')) # ab|cd|ef|gh|ijc.字符串分割
若想进行字符串分割，则可以使用split（）方法，按照子字符串来分割字符串，返回字符串列表对象。该方法的语法为str.split（sep=None，maxsplit=-1），表示：使用sep子字符串分割字符串str。maxsplit是最大分割次数，如果maxsplit被省略，则表示不限制分割次数。默认为所有的空字符，包括空格、换行符、制表符等等
text = 'ab cd ef gh ij'
a=text.split(' ') # ['ab', 'cd', 'ef', 'gh', 'ij']
print(a)
a=text.split(' ',maxsplit=0) # ['ab cd ef gh ij']
print(a)
a=text.split(' ',maxsplit=1) # ['ab', 'cd ef gh ij']
print(a)
a=text.split(' ',maxsplit=2) # ['ab', 'cd', 'ef gh ij']
print(a)5.统计英文文章中单词出现的频率
wordstring = '''
it was the best of times id was the worst of times.
it was the age of wisdom it was the age of foolishness.
'''
# 先替换标点符号
wordstring = wordstring.replace('.','')
# 分割单词
a=wordstring.split() # 默认为所有的空字符，包括空格、换行符、制表符等等
wordfreq=[]
for w in a:
# 统计单词出现个数
wordfreq.append(a.count(w)) # count()方法可以返回列表a中w元素的个数
d= dict(zip(a,wordfreq)) # # zip()函数将两个可迭代对象打包成元组，第一个参数是字典的键，第二个参数是字典值，个数相同，一一对应
print(d)
#{'it': 3, 'was': 4, 'the': 4, 'best': 1, 'of': 4, 'times': 2, 'id': 1, 'worst': 1, 'age': 2, 'wisdom': 1, 'foolishness': 1}九.函数
程序中需要反复执行的某些代码可以封装在函数里
函数有函数名、参数和返回值。Python中的函数很灵活：可以在模块中但是类之外定义，作用于是当前模块，我们称之为函数；也可以在别的函数中定义，我们称之为嵌套函数；还可以在类中定义，我们称之为方法。
1.定义函数
自定义函数的语法格式如下：
以英文半角冒号结尾
def 函数名(形式参数列表):
函数体
return 返回值什么是形式参数？
由于定义函数时的参数不是实际数据，会在 调用函数时传递给它们实际数据，所以我们称定义函数时的参数为形式参数；称调用函数时传递的实际数据为实际参数。
def rect_area(width,height):
area=width*height
return area
def print_area(width,height):
area=width*height
print("{0} x {1} 长方形的面积：{2}".format(width,height,area))2.调用函数
a.使用位置参数调用函数
在调用函数时传递的实参与定义函数时的形参顺序一致，这是调用函数的基本形式。
def rect_area(width,height):
area=width*height
return area
r_area=rect_area(320,480)
print("{0} x {1} 长方形的面积:{2:.2f}".format(320,480,r_area))b.使用关键字参数调用函数
在调用函数时可以采用“关键字=实参”的形式，其中，关键字的名称就是定义函数时形参的名称。
def rect_area(width,height):
area=width*height
return area
r_area = rect_area(width=320, height=480)
print("{0} x {1} 长方形的面积:{2:.2f}".format(320,480,r_area))
r_area = rect_area(height=480, width=320) # 实参不再受形参的顺序限制
print("{0} x {1} 长方形的面积:{2:.2f}".format(320,480,r_area))使用关键字参数调用函数时，调用者能清晰地看出所传递参数的含义，提高函数调用的可读性
3.参数的默认值
C语言有函数重载，即可以定义多个同名函数，但是参数列表不同，这样在调用时可以传递不同的实参，使用起来非常方便。在Python中是否也有函数重载的概念？
没有，函数重载会增加代码量，所以在Python中没有函数重载的概念，而是为函数的参数提供默认值实现的。
def make_coffee(name='卡布奇诺'):
return "制作一杯{0}咖啡".format(name)
coffee1=make_coffee("拿铁")
coffee2=make_coffee()
print(coffee1) # 制作一杯拿铁咖啡
print(coffee2) # 制作一杯卡布奇诺咖啡4. 可变参数
我发现一个很奇怪的问题：在使用格式化字符串的format()方法时，有时可以传递1个参数，有时可以传递3个参数，这是怎么回事？
print("320 x 480 长方形的面积：{0:.2f}".format(r_area))
print("{0} x {1} 长方形的面积：{2:.2f}".format(320,480,r_area))
Python中的函数可以定义接收不确定数量的参数，这种参数被称为可变参数，可变参数有两种，即在参数前加*或**
a.基于元组的可变参数(*可变参数)
*可变参数在函数中被组装成一个元组
def sum(*numbers):
total=0.0
for number in numbers:
totals += number
return total
print(sum(100.0,20.0,30.0)) # 输出150.0
print(sum(30.0,80.0)) # 输出110.0b.基于字典的可变参数（**可变参数）
**可变参数在函数中被组装成一个字典
def show_info(**info)
print('----show_info------')
for key,value in info.items():
print('{0} - {1}'.format(key, value))
show_info(name='Tony',age=18,sex=True)
# 多个参数被组装成字典info，字典的健是name\age\sex，字典的值是‘Tony'、18、True
show_info(student_name='Tony',student_no='1000')
# 多个参数备组装成字典info，字典的健是student_name,student_no,字典的值是'Tony''1000'5.函数中变量的作用域
变量可以在模块中创建，作用域（变量的有效范围）是整个模块，被称为全局变量。变量也可以在函数中创建，在默认情况下作用域是整个函数，被称为局部变量。
x=20 # 在模块中定义变量X,作用域是整个模块
def print_value():
x=10 # 在模块中定义变量x，作用域是整个函数，它会屏蔽模块变量x
print("函数中x = {0}".format(x))
print_value()
print("全局变量x = {0}".format(x))对于模块和函数中各定义的一个同名变量，如果在函数中将其声明为global ，则会将函数中的这个同名变量提升为全局变量，就会与原本的全局变量产生命名冲突。把原来的数值抵消掉
x=20
def print_value():
global x # 将x变量提升为全局变量
x = 10
print("函数中x = {0}".format(x))
print_value()
print("全局变量x = {0}".format(x)) # x=106.函数类型
Python中的任意一个函数都有数据类型，这种数据类型是function，被称为函数类型。
a.理解函数类型
函数类型的数据与其他类型的数据是一样的，任意类型的数据都可以作为函数返回值使用，还可以作为函数参数使用。因此，一个函数可以作为另一个函数返回值使用，也可以作为另一个函数参数使用。
# 定义加法函数
def add(a,b):
return a + b
# 定义减法函数
def sub(a,b):
return a - b
# 定义计算函数
def calc(opr):
if opr == '+':
return add
else:
return sub
f1=calc('+') # f1实际上是add()函数
f2=calc('-') # f1实际上是sub()函数
print("10 + 5 = {0}".format(f1(10, 5)))
print("10 - 5 = {0}".format(f2(10, 5)))函数类型的差别：主要是函数参数列表，有两个参数的函数和有一个参数的函数是不同的函数类型
b.过滤函数filter()
在Python中定义了一些用于数据处理的函数，如filter（）和map（）等。我们先介绍filter（）函数。
filter（）函数用于对容器中的元素进行过滤处理。
filter（）函数的语法如下：filter(function,iterable)
参数function是一个提供过滤条件的函数，返回布尔值。
参数iterable是容器类型的数据。
在调用filter()函数时，iterable会被遍历，它的元素会被逐一传入function()函数中，function()函数若返回True，则元素会被保留；若返回False，则元素被过滤。最后遍历完成，已保留的元素被放到一个新的容器数据中
# 提供过滤条件函数
def f1(x):
return x > 50 # 找出大于50元素
data1 = [66,15,91,28,98,50,7,80,99]
filtered = filter(f1,data1)
data2 = list(filtered) # 转换为列表
print(data2)filter()函数的返回值并不是一个列表，如果需要返回列表类型的数据，则还需要通过list()函数进行转换
c.映射函数map()
map（）函数用于对容器中的元素进行映射（或变换）。例如：我想将列表中的所有元素都乘以2，返回新的列表。
map(function,iterable)
参数function是一个提供变换规则的函数，返回变换之后的元素。
参数iterable是容器类型的数据。
def f1(x):
return x *2 # 变换规则乘以2
data1=[66,15,91,28,98,50,7,80,99]
mapped = map(f1,data1)
data2 = list(mapped) # 转换为列表
print(data2)7.lambda()函数
我们之前学习的函数都是有名称的函数，例如rect_area（）函数，rect_area就是其函数名。我们也可以定义匿名函数，匿名函数就是没有名称的函数。
在Python中使用lambda关键字定义匿名函数。lambda关键字定义的函数也被称为lambda（）函数，定义lambda（）函数的语法如下。
lambda 参数列表:lambda体
注意：lambda体部分不能是一个代码块，不能包含多条语句，只有一条语句，语句会计算一个结果并返回给lambda()函数，但与有名称的函数不同的是，不需要使用return语句返回
lambda（）函数与有名称的函数一样，都是函数类型，所以上面的add（）和sub（）函数可以被lambda（）函数替代。修改上面的代码示例如下：
# 定义计算函数
def calc(opr):
if opr == '+':
return lambda a,b:(a+b) # 替代add()函数
else:
return lambda a,b:(a-b) # 替代sub()函数
f1=calc('+') # f1实际上是add()函数
f2=calc('-') # f1实际上是sub()函数
print("10 + 5 = {0}".format(f1(10, 5)))
print("10 - 5 = {0}".format(f2(10, 5)))lambda()函数可以减少代码量
data1 = [66,15,91,28,50,98,7,80,99]
filtered = filter(lambda x:(x > 50),data1)
data2 = list(filtered)
print(data2)
mapped = map(lambda x:(x*2),data1)
data3 = list(mapped)
print(data3)十、异常处理
为增强程序的健壮性，我们也需要考虑异常处理方面的内容。例如，在读取文件时需要考虑文件不存在、文件格式不正确等异常情况。这就是本章要介绍的异常处理。
1.除零异常
在数学中，任何整数都不能除以0，如果在计算机程序中将整数除以0，则会引发异常。
2.捕获异常
我们不能防止用户输入0，但在出现异常后我们能捕获并处理异常，不至于让程序发生终止并退出。亡羊补牢，为时未晚。
a. try-except语句
异常捕获是通过try-except语句实现的，基本的try-except语句的语法如下。
在try代码块中包含在执行过程中可能引发异常的语句，如果没有发生异常，则跳到except代码块执行，这就是异常捕获。
i = input('请输入数字：')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except:
print("不能除以0")指定异常
i = input('请输入数字：')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except ZeroDivisionError as e:
print("不能除以0,异常：{}".format(e))b.多个except代码块
多条语句可能会引发多种不同的异常，对每一种异常都会采用不同的处理方式。
c.多重异常捕获
如果同时出现多个异常
i = input('请输入数字：')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except (ZeroDivisionError, ValueError) as e:
print("异常发生：{}".format(e))d. try-except语句嵌套
i = input('请输入数字：')
n = 8888
try:
i2 = int(i)
try:
result = n/i2
print('{0}除以{1}等于{2}'.format(n,i2,result))
except ZeroDivisionError as e1:
print('不能除0')
except ValueError as e2:
print('输入的是无效数字，异常')3.使用finally代码块释放资源
有时在try-except语句中会占用一些资源，例如打开的文件、网络连接、打开的数据库及数据结果集等都会占用计算机资源，需要程序员释放这些资源。为了确保这些资源能够被释放，可以使用finally代码块。
在try-except语句后面还可以跟一个finally代码块，语法如下。
无论是try代码块正常结束还是except代码块异常结束，都会执行finally代码块。
4. 自定义异常类
5.动动手——手动引发异常
class ZhijieketangException(Exception):
def __init__(self,message):
super().__init__(message)
i = input('请输入数字：')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except ZeroDivisionError as e:
raise ZhijieketangException('不能除以0')
except ValueError as e:
raise ZhijieketangException('输入的是无效数字')