python学习笔记（汇总）

一.基础知识

1. print函数
   字符串要加引号，数字可不加引号，如

   print(123.4)  print('小谢') print("洛天依")
   

   还可输入表达式，如

   print(1+3)
   

   如果使用三引号，print打印的内容可不在同一行

   print("line1
   line2
   line3")
   

2. 转义字符

   • \n换行
   • \t水平制表符
   • \r回车，覆盖前面字符
   • \b退一格
   • 若想在输出结果中加引号，要加\

     print('老师说:\"惠yyds\"')
     

     输出老师说:"惠yyds"

3. 原字符
   若不希望转义字符起作用，使用原字符r或R
   如print(r"aa\naa")
   输出aa\naa
   注意：最后一个字符不能是一个反斜杠，可以是两个

4. 二进制与字符编码
   8bit(位)=1byte(字节) 1024byte=1KB 1024kb=1MB 1024mb=1g 1024g=1t

5. python中的标识符和保留字
   python中对象名不能是保留字
   查看保留字

   import keyword          
   print(keyword,kwlist)
   

   标识符可以是I字母、数字、下划线；不能以数字开头；不能是保留字；严格区分大小写

6. 变量组成
   变量由三部分组成：标识（id,表示对象所存储的内存地址）、类型（type，表示对象的数据类型）、值(value,表示对象所储存的具体数据）

7. 注释

   • 单行注释# (快捷键ctrl+/)
   • 多行注释 ‘’‘-------’‘’

8. input函数
   获取用户输入的数据，引号内可以写提示语

   a=input("请输入您的密码")
   

   input的输出结果是str类型！！！

二.python中的数据类型

1. python中常见的数据类型
   整数类型int、浮点数类型float、布尔类型bool、字符串类型str

2. 整数类型
   可以表示正数、负数、零
   整数不同进制表示方式：十进制（默认的进制）、二进制（0b）、八进制（0o）、十六进制（0x）
   python允许在数字中加_，如100_000_00和10000000相等
   复数：实数根+复数根+j
   complex(re[,im]) 实部为re，虚部为im

3. 浮点数类型
   浮点数由整数部分和小数部分组成、使用浮点数进行计算时可能出现小数点位数不确定的情况
   解决该问题可以导入模块decimal

   from decimal import Decimal       print(Decimal('1.1')+Decimal('2.2'))
   

   这样得到的结果就是精确的，但是大部分情况下我们不需要导入decimal模块

4. 布尔类型(boolen)
   True表示1、False表示0
   对象的布尔值

   • 布尔值为False:False、0、None、空字符串、空列表、空元组、空字典、空集合
   • 除上述对象外，其他对象布尔值为True
   • 若把对象直接放在条件表达式去判断，则判断布尔值，如

   age=int(input('请输入您的年龄'))    #输入年龄并将其转为int类型      
   if age:               #如果布尔值为True，即年龄不为0  
       print(age)     
   else:                  #年龄为0
       print('年龄为',age)
   

5. 字符串类型
   可以使用引号来定义字符串、单双引号定义的字符串必须在同一行、三引号定义的字符串可以不在同一行
   字符串操作符：

   • x+y 连接两个字符串
   • xn 或nx 复制n次字符串
   • x in s 判断x是否是s的子返回值为布尔数
   • str[i] 索引，返回第i个字符
   • str[N:M] 切片，返回索到M的子串，不包括M

6. 数据类型转换
   将不同类型数据拼接在一起：

   str()    int()   float()
   

   若浮点数类型转为整数类型，只截取整数部分；将字符串转换为整数类型时，数据必须是整数

三.运算符

1. 算数运算符
   标准运算符：加（+）、减（-）、乘（）、除（/）、整除（//）
   取余运算符（%）
   幂运算符（**）
   一正一负整除时，向下取整-9//4=-3，余数=被除数-除数整除的商
   算数运算符优先级：** ~± */%// ±

2. 赋值运算符
   执行顺序从右向左、支持链式赋值（如a=b=c=20）、支持参数赋值（+= -= *= /= //=）、支持系列解包赋值（如a,b,c=1,2,3）
   交换 a,b=b,a

3. 比较运算符
   比较的是值，结果是布尔类型；符号（> < = >= <= == !=）
   =为赋值运算符，==为比较运算符
   比较对象的标识使用is，如：

   a=b=1
   print(a is b)
   print(a is not b)
   

4. 布尔运算符

   • and(两个运算符都为True时，其结果才是True)
   • or（只要有一个运算数为True，其结果就是True）
   • not(结果与运算数相反)

5. 位运算
   （将数据转成二进制进行计算）

   • 位与& 对应数位都是1时，结果数位才是1，否则为0
   • 位或| 对应数位都为0，结果数位才为0，否则为1
   • 左移位运算符<< 高位溢出舍弃，低位补0
   • 右移位运算符>> 低位溢出舍弃，高位补0
     左移几位就相当于乘以几，右移相当于除，与左移类似
     如

   print(4<<3)
   

   输出32

   print(32>>3) 
   

   输出4

6. 运算符的优先级
   先算术运算符（先算乘除后算加减，幂运算最优先），然后位运算，然后比较运算，然后布尔运算，最后赋值运算
   优先计算括号中内容

四.程序的控制结构

1. 计算机的流程控制
   顺序结构、选择结构（if语句）、循环结构（while语句、for-in语句）

2. 顺序结构
   程序从上到下的执行代码，中间没有任何判断和跳转，直到程序结束

3. 选择结构

   • 单分支结构： if———:
   • 双分支结构： if———： else:
   • 多分支结构： if———： elif:(可有无数个elif) else:(可省略)
   • 嵌套if的使用：先执行外层条件表达式
   • 条件表达式（不常用），是if————else的简写，语法结构：(x) if 判断条件 else (y) 如

   a=eval(input())
   b=eval(input())
   print(("a>=b") if a>=b else ("a))
   

4. 循环结构

   • while循环
     判断N+1次，执行N次
     四步循环法：初始化变量、条件判断、条件执行体（循环体）、改变变量
     练习题：使用while计算一到一百间的偶数和

     sum=0          
     a=1             #初始化变量
     while a<101:    #条件判断     
         if a%2==0:  #条件执行体     
             sum+=a         
         a+=1        #改变变量（否则a一直为1将陷入死循环）
     print(sum)
     

   • for-in循环
     in表示从（字符串、序列等）中依次取值，又称为遍历
     for-in遍历的对象必须是可迭代对象
     for-in语法结构：
     for 自定义变量 in 可迭代对象:
     循环体
     练习题：使用for-in循环计算一到一百间的偶数和

     sum=0                      
     for i in range(1,101):   #range函数在下面第5点介绍
         if i%2==0:  
             sum+=i
     print(sum)
     

   • 嵌套循环
     嵌套循环中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行
     练习题：九九乘法表

     for i in range(1,10):            #行数
         for j in range(1,i+1):            #每行表达式个数
             print(j,'*',i,'=',i*j,end='\t')
         print()         #换行
     

5. 一些补充知识

   • pass语句：只做一个占位符用在语法上需要语句的地方，在已经搭建好语法结构，还没想好代码怎么写时使用。（使程序不会报错）
   • 内置函数range()
     用于生成一个整数序列
     语法结构:range(start,stop,step)
     生成一个[start,stop),步长为step的整数序列
     start若不写，默认为0，step默认为1
   • break语句：结束循环结构，跳出当前循环体，继续执行之后的代码，通常与分支结构if一起使用
   • continue语句：结束当前循环，进行下一次循环，通常与分支结构中if一起使用
   • break和continue仅控制本层循环
   • else语句：当和循环搭配使用时候，循环正常结束时执行else（没有break和return语句）

   for i in range(4):
       print("2")
       break
   else:
       print("1")
   

   输出结果为2

   for i in range(4):
       pass
   else:
       print("1")
   

   输出结果为1

五.列表

1. 列表：可储存n多个元素，程序可方便地对这些数据进行整体操作

   2. 列表的创建：使用中括号[]或内置函数list()，数据间用,隔开 如：

   lista=[123,"加藤惠",520]
   

2. 列表的特点

   • 列表元素按顺序有序排序
   • 索引映射唯一一个数据（（正向从第一个元素索引为0开始，列表中按序依次增加；反向从最后一个元素索引为-1开始，按序依次减小））
   • 列表可以存储重复数据
   • 任意数据类型混存
   • 根据需要动态分配和回收内存

3. 获取指定元素的索引
   如果列表中存在多个相同元素，只返回相同元素中第一个元素的索引；如果查询的元素在列表中不存在，抛出ValueError；还可在指定的start和stop中查找，
   语法格式为 (列表名.index(‘元素’,start,stop))
   如

   lista=[123,"加藤惠",520,123,123]
   print(lista.index("123",1,3))       #注意不包括stop
   

   输出3

4. 获取列表中的元素

   • 获取指定元素
     列表名[索引]
   • 获取多个元素（切片）
     列表名[start:stop:step]
     切片结果是原列表片段的拷贝，是新列表；范围是[start,stop)，左闭右开；
     若step为负数，从start开始向左切片

5. 列表元素的判断
   使用in和not in
   if 元素 in 列表名:————

6. 列表元素的遍历
   for 自定义变量 in 列表名:
   print(自定义变量)
   如

   lista=[123,"加藤惠",520]
   for i in lista:
       print(i)
   

   输出

   123
   加藤惠
   520
   

7. 列表元素的增加操作

   • append()
     在列表的末尾添加一个元素
     列表名.apppend(元素)
     若使用append添加另一个列表，会将列表作为一个元素添加至原列表
   • extend()
     在列表的末尾至少添加一个元素(列表)
     列表名.extend(另一个列表名)
   • insert()
     在列表的任意位置添加一个元素
     列表名.insert(索引,元素)
   • 切片
     在列表的任意位置添加至少一个元素
     切片：把切掉的部分用新列表替换
     原列表名[start:stop]=新列表名
   • 还可以直接使用+
     如 lista=lista+[元素]

8. 列表元素的删除操作

   • remove()
     一次移除一个元素；重复元素只移除第一个；元素不存在抛出ValueError
     列表名.remove(元素)
   • pop()
     删除指定索引位置上的元素；指定索引不存在则抛出ValueError;不指定索引则删除列表中最后一个元素
     列表名.pop(索引)
   • 切片
     一次至少删除一个元素；产生新列表
     新列表名=原列表[start:stop:step]
   • clear()
     清空列表
     列表名.clear()
   • del()
     删除列表
     列表名.del()

9. 列表元素的修改操作
   为指定索引的元素赋予一个新值；为指定的切片赋予一个新值
   列表名[索引]=新元素
   列表名[start:stop]=另一个列表

10. 列表元素的排序操作
    调用sort()方法 列表中所有元素默认按照从小到大的顺序进行排列，可以指定reserve=True，进行降序排序
    升序排序：列表名.sort()
    降序排序：列表名.sort(reserve=True)
    调用内置函数sorted() 可以指定reserve=True,进行降序排序，原列表不发生改变
    升序：新列表名=sorted(原列表名)
    降序：新列表名=sorted(原列表名.reserve=True)
    sorted函数可以对所有可迭代类型使用，如对字典使用返回值是key排序后的列表！！！

    如果要返回排序后的字典

    sorted_dict = dict(sorted(orig_dict.items(), key=lambda kv: (kv[0])))
    

11. 列表生成式
    列表名=[生成列表元素的表达式 for 自定义变量 in range(start,stop,step)]
    如

    lst=[i+2 for i in range(5)] 
    

    输出[2, 3, 4, 5, 6]

六.字典

1. 字典

   • 字典是一个可变序列，以键值对的方式存储数据
   • 字典是无序数据；冒号前为键，冒号后为值
   • 键必须是不可变序列(非列表)
   • 字典依据key查找value所在位置
   • 字典的键不能重复，值可以重复

2. 字典的创建

   • 使用{}
     字典名={key:value,key:value,…}
   • dict()
     字典名=dict(key:value,key:value,…)
     *key是否加单引号取决于key的数据类型，键值对中是冒号
     空字典就是{}

3. 字典元素的获取

   • 使用[]
     字典名.[key]
   • 使用get()方法
     字典名.get(key，value)
   • 区别在于若查找的key不存在，[]会报错；get()方法不会报错，输出None或者自己指定的value

4. key的判断
   in/not in

5. 字典元素的删除
   del 字典名[key]
   清空字典元素：字典名.clear()

6. 字典元素的新增
   字典名[key]=value 修改元素也用此方法

7. 获取字典视图

   • keys()获取字典中所有key
   • values()获取字典中所有value
   • items()获取字典中所有的键值对
     如

   dicta={"A":1,"B":2,"C":3}
   print(dicta.keys())
   print(dicta.values())
   print(dicta.items())
   

   输出

   dict_keys(['A', 'B', 'C'])
   dict_values([1, 2, 3])
   dict_items([('A', 1), ('B', 2), ('C', 3)])
   

8. 字典元素的遍历

   • 获取key for 变量 in 字典
   • 获取value for 变量 in 字典.values
   • 同时获取key和value for 变量1,变量2 in 字典.items （变量1存储key，变量2存储value）

9. 字典生成式
   现有两个列表，若要将它们组成字典，使用内置函数zip()
   字典名={key:value for key,value in zip(列表1，列表2)}
   若两个列表元素个数不同，则’木板效应’
   如

   items=['笔','本子','文具盒']         
   prices=[2,5,10]         
   d={item:price for item,price in zip(items,prices)}          
   print(d)
   

   输出{'笔': 2, '本子': 5, '文具盒': 10}
   还可 变量=zip(列表1，列表2)
   如

   lst=zip(items,prices)      
   print(list(lst))      
   

   输出[('笔', 2), ('本子', 5), ('文具盒', 10)]

10. 可变序列和不可变序列

    • 可变序列：（列表、字典、集合）：可以对序列执行增、删、改操作，对象地址不发生改变；
    • 不可变序列（字符串、元组）：没有增、删、改操作

七.元组

1. 元组

   • 不可变序列，使用小括号()进行定义 ；
   • 元组中存储的是对象的引用，若元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变，若元组中的对象是不可变对象，则不能再引用其他对象
   • 可向元组中的列表中增加元素，如

   a=(1,2,[4,5])                   
   a[2].append(55)               
   print(a) 
   

   输出(1, 2, [4, 5, 55])

2. 元组的创建方式

   • 直接使用小括号：
     元组名=(元素对象,元素对象,元…)
   • 使用内置函数tuple()：
     元组名=tuple((元素对象,元素对象,元素对象…))
   • 只包含一个元组的元素需要使用逗号和小括号
     元组名=(元素对象,)
   • 空元组：元组名=() 或 元组名=tuple()

3. 为什么将元组设计为不可变序列
   在多任务环境下，同时操作元组对象时不需要加锁；因此，在程序中尽量使用不可变序列

4. 获取元组中元素
   获取元组中元素可使用索引
   元组名[索引]

5. 元组的遍历
   元组是可迭代对象，可用for–in进行遍历

八.集合

1. 集合

   • 集合是python语言提供的内置数据结构
   • 是可变序列
   • 集合是没有value的字典（无序）

2. 集合的创建方式

   • 直接{} 如 a={1,2,3}
   • 使用内置函数set() ：可将列表、元组、字符串、集合转成集合中的元素
   • 定义空集合：集合=set()
     如seta=set('python')

3. 集合的相关操作
   使用in 和 not in 判断集合中是否存在相关元素

4. 集合元素的新增

   • 使用add()方法，一次添加一个元素
   • 使用update()方法至少添加一个元素
     集合名.update(元素,元素…)

5. 集合元素的删除

   • remove() 一次删除一个指定元素，若指定元素不存在则抛出KeyError
   • discard() 一次删除一个指定元素，若指定元素不存在则不抛异常
   • pop() 一次删除一个任意元素，不能指定参数
   • clear() 清空集合

6. 集合间的关系

   • 两个集合是否相等：使用==或!=进行判断
   • 一个集合是否是另一个集合的子集，调用issubset进行判断
   • 一个集合是否是另一个集合的超集，调用issuperset；
   • 两个集合是否没有交集，调用isdisjoint

7. 集合的数学操作
   设两集合分别为a和b

   • 交集：
     print(a.intersection(b)) 或 print(a&b)
   • 并集：
     print(a.union(b)) 或 print(a|b)
   • 差集(a中有但b中没有的)：
     print(a.difference(b)) 或 print(a-b)
   • 对称差集(a和b中去除交集后的集合)：
     print(a.symmetric_difference(b)) 或 print(a^b)

8. 集合生成式
   将列表生成式中的[]改成{}就ok
   集合名={生成集合元素的表达式 for 自定义变量 in range(start,stop,step)}

九.字符串

1. 字符串
   python中的基本数据类型，是不可变的字符序列；使用单、双、三引号定义

2. 字符串的驻留机制
   仅保存一份相同且不可变字符串的方法，对相同的字符串只保留一份拷贝

3. 符合驻留机制的几种情况（交互模式）

   • 字符串的长度为0或1时；符合标识符的字符串（含字母、数字、下划线）；
   • 字符串只在编译时进行驻留，而非运行时；
   • [-5，256]之间的整数数字
   • pycharm对字符串进行了优化处理，字符串都符合驻留机制
   • 若要使字符串强行驻留，使用sys中的intern方法

   import sys            
   stra=sys.intern(stra)       #stra为字符串名
   

   • 需要进行字符串拼接时使用str类型的join方法，而非+，效率高

4. 字符串的查询操作

   • index()和find()查找子串第一次出现的位置
   • rindex()和rfind()查找子串最后一次出现的位置
   • 若查找的子串不存在，index()和rindex()抛出ValueError，find()和rfind()返回-1
     举例：

   a='hello,hello'                      
   print(a.index('lo')) 
   

   输出3

5. 字符串的大小写转换操作的方法

   • upper()所有字符转成大写
   • lower()所有字符转成小写
   • swapcase()把字符串中所有字符大小写颠倒；
   • capitalize()把第一个字符转成大写，其余小写
   • title()把每个单词的第一个字符转换成大写，其余小写
     举例：

   a='hello,world,python'                  
   b=a.title() 
   print(b)
   

   输出Hello,World,Python

6. 字符串内容对齐的方法

   • center()居中对齐
   • ljust()左对齐
   • rjust()右对齐
   • 括号内第一个参数指定宽度，第二个字符指定填充符(非str要加引号)，默认空格，若设置宽度小于实际宽度则返回原字符串
   • zfill()右对齐，该方法指定一个参数宽度，用0填充；若有负号，0填充到负号后

7. 字符串的劈分

   • split()从字符串的左边开始劈分
   • rsplit()从字符串的右边开始劈分
   • 若未指定最大劈分次数，这两种方法效果一样
     注：
   • 默认劈分字符是空格，返回值是一个列表
   • 通过参数sep指定劈分符
   • 通过参数maxsplit指定最大劈分次数，超过最大劈分次数后，剩余的子串单独作为一部分

   a='hello,hello,wwwww,起飞'                    
   print(a.split(sep=',',maxsplit=2))                  
   

   输出['hello', 'hello', 'wwwww,起飞']

8. 字符串的判断方法

   • isidentifier()判断指定的字符串是不是合法的标识符
   • isspace()判断指定字符串是否全部由空白字符组成（回车、换行、水平制表符）
   • isalpha()判断指定字符串是否全部由字母组成（汉字也算字母）
   • isdecimal()判断指定字符串是否全部由十进制的数字组成（罗马数字不算十进制数字）
   • isnumeric()判断指定字符串是否全部由数字组成
   • isalnum()判断指定字符串是否全部由字母和数字组成

9. 字符串的替换与合并

   • replace()第一个参数指定被替换的字符；第二个参数指定替换字符的字符串，该方法返回替换后的字符串，替换前的字符串不发生改变；第三个参数指定最大替换次数
     举例：

   a='hello,python,python'           
   print(a.replace('python','java',1))           
   

   输出hello,java,python

   • join()将列表或元组或字符串序列中的字符串合并成一个字符串
     举例：

   lst=['java','python',str(255)]           
   print('|'.join(lst))       
   

   输出java|python|255

   输出javapython255

   print('*'.join('python')) 
   

   输出p*y*t*h*o*n

10. 字符串的比较操作

    • 运算符：> >= < <= == !=
    • 比较规则：首先比较两个字符串的第一个字符，如果相等则比较下一个，依次比较直到字符不相等
    • 比较原理：比较的是字符的ordinal value(原始值)，调用内置函数ord可以得到，与ord对应的是内置函数chr,调用chr时指定原始值可以得到对应字符
      (ord只能用来获得单个字符的编码)
    • ==比较的是value is比较的是id

11. 字符串的切片操作
    字符串的是不可变类型，切片操作将产生新的对象
    [start:stop:step]
    举例

    a='hello,python'               
    print(a[::-1])    
    #start默认为0，stop若不写，默认为最后一个元素（包括它）  
    

    输出nohtyp,olleh

12. 格式化字符串

    • %作占位符
      举例：

      print('我叫%s,今年%d岁' % (name,age))
      

      %d整数 %f浮点数 %s字符串 %x十六进制整数 %%表示% （如果不确定用什么，就用%s）
      可指定宽度和精度：举例：print(‘%10.3f’ % 3.1415926) 返回3.142 # 格式为 %宽度.精度

    • {}作占位符
      举例：

      print('我的名字是{0},今年{1}岁，我真的是{0}'.format(name,age))
      

      {}中填写format()中的占位符顺序，name和age是自定义变量名
      索引从0开始

    • 指定宽度和精度
      举例：

      print('{0:10.3}'.format(3.1415926))         
      

      输出3.142
      格式为 {占位符顺序:宽度.精度},

      • 若想要居中输出，在宽度前加^，右对齐，在宽度前加>
      • 若想要指定宽度补0，在宽度前面加0，填充符写在宽度前

    • f格式化
      举例：

      print(f'我叫{name},今年{age}岁')
      

13. 字符串的编码与解码

    • 编码
      将字符串转换为二进制数据(bytes)：

      a='你是人间理想'         
      byte=a.encode(encoding='GBK')      
      print(byte)
      

      输出b'\xc4\xe3\xca\xc7\xc8\xcb\xbc\xe4\xc0\xed\xcf\xeb'
      在GBK编码格式中，一个中文占两个字节；在UTF-8编码格式中，一个中文占三个字节
    • 解码
      将bytes类型的数据转换成字符串类型：

      print(byte.decode(encoding='GBK'))        
      

      输出：你是人间理想
      byte为解码返回的结果
      编码和解码所用的编码格式必须相同
    • utf-8
      在代码中加如下代码
      -*- coding: utf-8 -*-
      注释后文件就会使用utf-8解码

十.函数

1. 函数：执行特定任务以完成特定功能的一段代码

2. 为什么需要函数
   复用代码，隐藏实现细节，提高可维护性，提高可读性便于调试

3. 函数的创建
   语法结构:

   def 函数名(输入参数):
       函数体
       [return ...]    #不一定有return函数
   

   举例：

   def calc(a,b):       #输入参数为a和b两个参数，a和b为形参
       c=a+b
       return c        #函数返回值为参数a和b之和
   print(calc(10,20))  #调用函数,10和20为实参
   

   输出30
   形参和实参名称可以不同

4. 匿名函数
   语法结构：

   <函数名>=lambda<参数列表>:<表达式>
   

   举例：

   f=lambda x,y:x+y
   print(f(1,2))
   

   输出3
   匿名函数用于在一行内定义一个简单的函数

5. 函数分类

   • 来源：python标准库函数（内置函数、模块函数）、第三方库函数、用户自定义函数
   • 长度：单行（匿名函数）、多行（命名函数）
   • 嵌套：无嵌套、简单嵌套、自嵌套（递归函数）

6. 函数调用的参数传递

   • 位置实参
     根据形参的对应位置进行实参传递
     举例：

     def calc(a,b):
         c=a/b
         return c
     print(calc(1,2))
     

     输出0.5

   • 关键字实参
     根据形参名称进行实参传递
     以上面calc函数为例

     print(calc(b=1,a=2))
     

     输出2.0

   • 默认参数
     指定参数的默认值，但输入的实参小于形参个数，即使用默认值
     举例：

     def calc(a,b=1):
         c=a+b
         return c
     print(calc(2))
     

     输出3
     （形参a的值为给定的实参2，b的值为默认参数1）

   • 关键字参数
     定义函数时在变量前加**，这些关键字参数在函数内部自动组装为一个dict（关键字参数可给定任意数量参数）
     举例：

     def person(name,age,**kw):
         print('name:',name,'age:',age,'other:',kw)
     person('bob',35,m=1,n=2)
     person('bob',35,m=1,n=2,t=3)
     

     输出

     {'m': 1, 'n': 2}
     {'m': 1, 'n': 2, 't': 3}
     

   • 命名关键字参数
     可以限制关键字参数的名字，命名关键字参数需要一个特殊分隔符*,*后面的参数被视为命名关键字参数
     举例：

     def person(name,age,*,city,job):
         print(name,age,city,job)
     person('jack',128,city='beijing',job='engineer')
     

     输出jack 128 beijing engineer

     但如果

     person('jack',128,'beijing','engineer')
     

     就会报错（因为没有输入关键字参数的名字）

7. 参数补充知识

   • 在函数调用过程中，进行参数的传递，如果是不可变对象，在函数体的修改不会影响实参的值，如果是可变对象，在函数体的修改会影响实参的值
     举例：

   def fun(a):         
       a=1000           
       return a          
   b=1             
   print(fun(b))          
   print(b)
   

   输出

   1000
   1
   

   b调用函数后为1000，但其本身仍然未改变，是1

   • 当定义函数时即使用默认参数也使用可变参数，默认参数会退化为普通参数

   • 参数定义的顺序：必选参数、默认参数、可变参数、命名关键字参数、关键字参数

8. 函数的返回值
   函数返回多个值时，结果为元组

9. 全局变量和局部变量
   函数内定义的变量是局部变量，在函数体外部不可使用，函数外定义的变量是全局变量。
   如果要在函数内定义全局变量，使用global
   举例

   x = 1
   def f():
       global x
       x = 2
   f()
   print(x)
   

   输出2

十一.解决bug

1. bug由来
   粗心导致的语法错误、索引越界、知识点掌握不熟练、思路不清…

2. try-except结构
   语法结构：

   try:
       可能会出现异常的代码
   except 异常类型（可省略）:
       报错后执行的代码
   

   多个except结构时，捕获异常的顺序按照先子类后父类的顺序，最大的父类是BaseException
   举例：

   try:
       a=int(input('请输入第一个数'))
       b=int(input('请输入第二个数'))
       #a和b使用int函数进行强制类型转换
       result=a/b
       print(result)
   except ZeroDivisionError:      #b为0时
       print('对不起，除数不能为0')
   except BaseException:1         
       print('对不起，您似乎没有输入整数')
   

3. try-except-else结构
   果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块

4. try-except-else-finally结构
   无论是否异常都执行finally块

5. python中常见异常类型

   • ZeroDivisionError:除（取模）0
   • indexError:序列中没有此索引
   • KeyError；映射中没有这个键
   • NameError:未声明/初始化对象
     l x
     x = 2
     f()
     print(x)

   输出```2```