Python（1-10章）知识点

第一章——开启python学习之旅

• 除法运算

1/2	#输出结果：0
1.0/2.0	#输出结果：0.    5

• 输入函数

input() #`input()`函数给出提示并接收用户输入

• 变量的定义

  name = '马里奥'
  print(name)  # 直接写变量名，是输出变量存的数据；
  print('标识', id(name))  # id()获取变量的地址；
  print('类型', type(name))  # type()获取变量的类型；
  

• 代码布局

  1. 每行最大长度79；
  2. 换行可以用反斜杠\;

• 括号的使用

  1. 右括号前不加空格；
  2. 逗号，冒号，分号前不要加空格；
  3. 函数的左括号前不要加空格，如 fun(1);
  4. 序列的左括号前不要加空格，如 list[2];
  5. 不要将多条语句写在同一行；
  6. if，for，while语句中，即使执行语句只有一句，也必须另起一行；

• 代码注释

  1. 块注释使用 #；

• 命名规范

  1. 不要使用字母 l (L的小写)、O（大写O）、I（大写I）作为单字符变量名；
  2. 模块包、包名应该简短且全为小写；

• 数据的表示——变量

  变量名=数据
  

  • 变量名命名规则
    1. 由字母和下划线组成，且不以数字开头；
    2. 区分大小写；

• 基本输出/输入

  1. input()函数

     input(*args, **kwargs)  # input函数用于接收一个标准输入数据，该函数返回一个字符类型的数据
     

  2. print()函数

     print(*objects, sep=' ', end='\n' , file=sys.stdout)  
     

     print()函数用于向控制台中输出数据，它可以输出任何类型的数据

     print()函数中各个参数的具体含义如下：

     • objects : 表示输出的对象。输出多个对象时，需要用逗号隔开；
     • sep : 用于间隔多个对象；
     • end : 用于设置以什么结尾。默认值时换行符\n;
     • file : 表示数据输出的文件对象；

• 输入python中的所有保留字；

  import* keyword
  print(keyword.kwlist)
  

第二章——数字类型与字符串

• 字符类型的表示方法

  1. 整型

     • 二进制：0B或0b开头；

     • 八进制：0o或0O开头；

     • 十六进制：0x或oX开头；

     • 十进制：(默认表示方法);

  2. 浮点型

     • python 的浮点数一般以十进制形式表示，对于比较大的或比较小的浮点数，可以使用科学计数法

       例：

       num_one=3.14 # 十进制形式表示
       num_two=2e2  # 科学计数法表示
       num_thrd=2e-2  # 科学计数法表示
       

  3. 复数类型

     • 复数的特点

       1. 一般形式real+imagj ；

       2. 实部``real和虚部imag`都是浮点型；

       3. 虚部必须有后缀 j或J；

          例：

       num_one=3+2j  # 按照复数格式使用赋值运算赋值直接创建
       num_two=complex(3,2)  # 使用内置函数complex()函数创建
       

       4. 布尔类型

          • python 中布尔类型(bool)只有两个取值：Ture和False；

          • python 中的任何对象都可以转换为布尔类型，若要转换，需要符合以下条件：

          • None;

          • 任何为0的数字类型，如``0、0.0、0j`；

          • 任何空序列，如“ ”、()(元组)、[]（列表）;

          • 任何空字典；

          • 用户定义的类型实例；

            除以上对象外，其他的对象都会被转换成为True；

       • bool为空的对象

         print("以下对象的bool值都为False,除这些以外的对象bool值都是True")
         print(bool(False))
         print(bool(0))
         print(bool(None))
         print(bool(0.0))
         print(bool(''))
         print(bool(""))
         print(bool([]))  # 空列表
         print(bool(list()))  # 空列表
         print(bool(()))  # 空元组
         print(bool({}))  # 空字典
         print(bool(set()))  # 空集合
         print(bool(dict()))  # 空字典
         print(bool(tuple()))  # 空元组
         

• 转义字符

  print("hello\nworld")  # 换行；
  print("hello\tworld")  # 一个tab位置；
  print("hellooo\tworld")
  ''' 一个\t占1~4个字符的位置，如果\t
  前的字符没有占满四个字符的位置则\t不
  重开位置，否则将重开一个位置；'''
  print("hello\rworld")  # world将hello进行覆盖，只覆盖等位置的字符；
  print("hello\bworld")  # 退一个字符；
  

• 类型转换函数

  函数	说明
  int()	将浮点型、布尔类型和符号数值类型规范的字符串转换为整型
  float()	将整型和复合数值类型规范的字符串转换为浮点型
  str()	将数值类型转换为字符串

  使用类型转换函数注意事项：

  1. int()函数、flaot()函数只能转换复合数字类型格式规范的字符串；
  2. 使用int()·函数将浮点数转换为整数时，若有必要会发生截断(取整)，而非四舍五入；

• 精度控制输出

  from decimal *import* Decimal # 精确浮点数的输出
  print(Decimal('1.1')+Decimal('2.2'))
  

• 字符串

  字符串的驻留机制：

  仅保留一份相同切不可变得字符串得方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

  驻留机制的几种情况(交互模式)：

  字符串的长度为0或1时；

  符合标识符的字符串；

  字符串只在编译时进行驻留，而非运行时；

  [-5,266]之间的整数数字；

  字符串驻留机制的优缺点：

  ​ 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建销毁，提升效率和节约内存，因此拼接字符串是会比较影响性能的；

  ​ 在需要进行字符串拼接时建议使用str类型的join()方法，而非+，因为join()方法是先计算出所有字符串中的长度，然后再拷贝，只new一次对象，效率要比“+”效率高；

• 字符串的查询操作方法：

  功能	方法名称	作用
  查询方法	index()	查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError
  	rindex()	查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
  查询方法	find()	查找子串substr第一次出现的位置，如果查找的子串不存在，则返回-1
  	rfind()	查找子串substr最后一次出现的位置，如果查找的子串不存在，则返回-1

• 字符串的大小写转换操作的方法：

  功能	方法名称	作用
  	upper()	把字符串中所有字符都转成大写字母
  	lower()	把字符串中所有字符都转成小写字母
  大小写转换	swapcase()	把字符串所有大写字母转成小写字母，把所有小写字母都转成大写字母
  	capitalize()	把第一个字符转换为大写，把其余字符串转化为小写
  	title()	把每个单词的第一个字符串转换为大写，把每个单词的剩余字符转换为大小写

• 字符串内容对齐操作的方法：

  功能	方法名称	作用
  	center()	居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串；
  	ljust()	左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格如果设置宽度小于实际宽度则返回原字符串
  	rjust()	右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格如果设置宽度小于实际宽度则返回原字符串
  	zfill()	右对齐，左边用0填充，该方法只接受一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

• 字符串劈分操作的方法

  功能	方法名称	作用
  字符串的劈分	split()	从字符串的左边开始劈开，默认的劈分字符是空格字符串，返回的值都是一个列表
  	split()	以通过参数sep指定劈分字符串是劈分符
  	split()	通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次数劈之后，剩余的子串会单独作为一部分
  	rsplit()	从字符串的右边开始劈开，默认的劈分字符是空格字符串，返回的值都是一个列表
  	rsplit()	以通过参数sep指定劈分字符串是劈分符
  	rsplit()	通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次数劈之后，剩余的子串会单独作为一部分

• 判断字符串操作的方法：

  功能	方法名称	作用
  	isidentifier()	判断指定的字符串是不是合法的标识符
  	isspace()	判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
  	isalpha()	判断指定的字符串是否全部由字母组成
  判断字符串的方法	isdecimal()	判断指定的字符串是否全部由十进制的数字组成
  	isnumeric()	判断指定的字符串是否全部由数字组成
  	isalnum()	判断指定的字符串是否全部由字母和数字组成

• 字符串的其他操作

  功能	方法名称	作用
  字符串替换	replace()	第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不会发生变换，调用该方法是可以通过第三个参数指定最大替换次数
  字符串的合并	join()	将列表或元组中的字符串合并成一个字符串

• 字符串的比较操作

  运算符：>,>=,<,<=,==,!=

  • 比较规则：首先比较连个字符串的第一个字符，如果相等则继续比较下一个字符，依次比较下去，知道两个字符串中的字符不相等，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较；
  • 比较原理：两个以上字符进行比较时，比较的是ordinal value（原始值），调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符。

• 字符串时不可变序列

  不具备增、删、改等操作；

  切片操作会产生新的对象；

python支持使用单引号、双引号、三引号定义字符串，其中单引号和双引号通常用于定义单行字符串，三引号通常用于定义多行字符串；

1. 定义单行字符

   single_symbol='Hello itcast' # 使用单引号定义字符串
   double_symbol="Hello itcast" # 使用双引号定义字符串
   

2. 定义多行字符串

   three_symbol="""My name is itcast
   				My name is itcast""" # 使用单引号定义字符串
   

   注意：定义字符串时单引号双引号可以嵌套使用，需要注意的是，使用双引号表示的字符串允许嵌套单引号，但不允许包含单引号；

• 字符串的格式化输出

  python 的字符串可通过占位符%、formant()、f-strings；

  1. 占位符%

     利用占位符%对字符串进行格式化时，python会使用一个带有格式符的字符串作为模板，这个格式符用于为真实值预留位置，并说明真是值应该呈现的格式。

     name = '李强'
     age = 12
     print('你好我叫%s' % name)
     print('你好，我叫%s，今年%d岁了；' % (name, age))
     # 一个字符串可以同时包含多个占位符；
     # 上述的因为需要对两个变量进行格式化输出，所以可以使用`（）`将这连个变量储存起来
     

     • 常见的占位符

       符号	说明	符号	说明
       %s	字符串	%X	十六进制整数(A~F为大写)
       %d	十进制整数	%e	指数(底写为e)
       %o	八进制整数	%f	浮点数
       %x	十六进制整数(a~f为小写)

       注意：使用占位符%号需要注意变量的类型，若变量的类型与占位符不匹配时程序会产生异常；

  2. format()方法

     format()方法同样可以对字符串进行格式化输出，与占位符不同的是，使用format()方法不需要关注变量的类型；

     • format()方法的基本使用格式：

       <字符串>.format(<参数列表>)
       

     • 在format()方法中使用“{}”为变量预留位置。

       例：

       name='李强'
       age=12
       print('你好，我的名字是：{}，今年我{}岁了'.format(name,age))
       

       如果字符串中包含多个“{}”，并且“{}”内没有指定任何序号（从0开始），那么默认按照“{}”出现的顺序分别用format()方法中的参数进行替换；如果字符串“{}”中明确指定了序号，那么按照序号对应的format()方法的参数进行替换。

       例：

       name='李强'
       age=123
       print('你好，我的名字是：{1}，今年我{0}岁了'.format(name,age)) # 注意替换从0开始	
       

     • format()方法还可以对数字进行格式化，包括保留n位小数、数字补齐和现实百分比；

       1. 保留n位小数

          • 基本格式：{:.nf}

            其中n表示保留的小数位数；

       2. 数字补齐

          • 基本格式：{:m>nd}

            其中m表示补齐的数字，n表示补齐后数字的长度，>表示在原数字左侧进行补充,<表示在原数字右侧补充；

       3. 显示百分比

          • 基本格式：{:.n%}

            其中n表示保留的小数位；

  3. f_strings

     f_strings在格式上以f或F引领字符串，字符串中使用{}表明被格式化的变量。f_strings本质上不再是字符串常量，而是在运行时求值的表达式，所以在效率上优于占位符%和format()方法；

     • 使用f_strings不需要关注变量的类型，但是仍然需要关注变量传入的位置；

       例：

       name='张天'
       age=20
       gender='男'
       print(f'我的名字时{name},今年{age}岁了，我的性别是{gender}.')
       

• 字符串的常见操作

  1. 字符串拼接

     字符串的拼接可以直接用“+”符号实现

     例：

     str_one='人生苦短'
     str_twp='我用Python'
     print(str_one+str_two)
     

  2. 字符串的替换

     字符串的replace()方法可以使用新的子串替换目标字符串中的原有子串

     • 基本语法：str.replace(old,new,count=None)

       其中参数old表示原有子串；参数new表示新的子串；参数count用于设置替换次数；如果在字符串中没有找到匹配的子串，会直接返回字符串；

  3. 字符串分割

     字符串split()方法可以使用分隔符把字符串分割成序列

     • 基本语法：str.split(sep=None,maxplit=-1)

       其中，sep(分隔符)默认为空字符，包括空格、换行(\n)、制表符(\t)等。如果maxsplit有定值，则split()方法将字符串str分割为maxsplit个子串，并返回一个分割以后的字符串列表；

  4. 去除字符串两侧空格

     字符串对象的strip()方法一般用于去除字符串两侧的空格；

     • 基本格式：str.strip(chars=None)

       strip()方法的参数chars用于设置要去除的字符，默认要去除的字符为空格；

• 字符串的初始化

  str1 = 'Hello World'
  str2 = "Hello World"
  str3 = '''Hello
  
         world'''
  # 用三引号定义的字符串可以实现多行定义并且按原格式多行输出
  

• 字符串的索引于切片

  索引和切片功能可以提取字符串中的特定字符和子串；

  1. 索引

     字符串是一个由元素组成的序列，每个元素所处的位置是固定的，并且对应着一个位置编号，编号从0开始，依次递增，这个位置编号被称为索引或者下标；

     • 基本语法：字符串[索引]

       如果索引自-1开始，从右至左依次递减，则索引为反向索引。

       注意：当使用索引访问字符串值时，索引的范围不能越界，否则程序会报错；

  2. 切片

     • 基本语法：[起始:结束:步长]

       注意：切片的默认步长为1,切片选取的区间属于左闭右开型，切下的子串包含起始位，但不保包含结束位，切片的步长可以是负数。

• 运算符

  1. 算数运算符

     运算符	功能
     //	整除：使两个操作数相除，获取操作数的商
     **	幂：使两个操作数进行幂运算，获取obj1的obj2次幂

     print(9/4) # 输出结果为浮点数
     print(9//4) # 输出结果为整型数据
     print(-9//4)  # 一正一负的整数公式，向下取整
     print(-9 % 4)  # 余数=被除数-除数*商 余数不能为负数
     

     其余运算符与C语言中的用法一致；

     python中的算术运算符支持对相同或不同类型的数字进行混合运算。

     无论参加运算的操作数是什么类型，解释器都能给出运算后的正确结果，这是因为python在对不同类型的对象进行运算时，会强制将对象的类型进行临时类型转换。

     • 转换遵循如下规律：布尔类型在进行算数运算时，被视为数值0或1；
       1. 整型与浮点型运算时，将整型转化为浮点型；
       2. 其他类型与复数运算时，将其他类型转换为复数类型；

  2. 比较运算符

     • 比较运算不会对操作数自身造成影响，比较运算符与操作数的表达式的结果只能是True或False,这种表达式通常用于布尔测试。

       比较运算符与C中的比较运算符使用方法相同。

  3. 赋值运算符

     赋值运算符与C中的比较运算符使用方法相同；

     注意：与C语言不同，python中在进行赋值运算时，即便两侧操作数的类型不同也不会报错，且左值可正确地获取右操作数的值（不会发生截断）。

• 逻辑运算符

  python中分别用or、and、not这三个关键字作为逻辑运算符“或” “与” “非”的运算，其中or与and为双目运算符，not为单目运算符。逻辑运算符的操作可以为表达式或对象。

  1. or

     当使用运算符or连接连个操作数时，左操作数的布尔值为True，则返回左操作数，否则返回有操作数或起计算结果（若为表达式）

  2. and

     当使用运算符and连接两个操作数，若左操作数的布尔值为False,则返回左操作数或其计算结果（若为表达式），否则返回右操作数的执行结果；

  3. not

     当使用运算符not时，若操作数的布尔值为False，则返回True,否则返回False;

• 位运算符

  运算符	说明
  <<	按位左移。按二进制形式把所有的数字向左移动对应的位数，高位移除（舍弃），低位的空位补零
  >>	按位右移。按二进制形式把所有的数字向右移动对应的位数，高位移除（舍弃），低位的空位补零
  &	按位与。全一出一
  |	按位或。有一出一
  ^	按位异或。相同为0，不同为1
  ~	按位取反。位为1，则取其反0，位为0，则取其反（包括符号位）

第三章——流程控制

python中的分支语句有双分支if…else语句、单分支if语句和多分支语句if…elif…else语句；

• if语句的格式

  1. if语句

     • 基本格式：

       if 条件表达式:
           代码块
       

     • 特色

       if 90 <= score <= 100: # python特有的写法，直接按照数学公式来写；
           String
       

  2. if…else语句

     • 基本格式：

       if 条件表达式:
           代码块1
       else :
           代码块2
       

  3. if…elif…else语句

     • 基本格式：

       if 条件表达式1:
          代码块1
       elif 条件表示是2:
          代码块2
       elif 条件表示是3:
          代码块3 
       elif 条件表示是n-1:
          代码块n-1
       else: 
           代码块n
       

       Tips:python中if语句可以像C语言中嵌套使用；

  4. 条件表达式

     • 基本格式

       x if 判断条件 else y
       例子：
       a = 1
       b = 2
       print((str(a) + '大于' + str(b)) if a >= b else (str(a)+'小于'+str(b))) # 类似c中的三目表达式；
       # 当条件判断为True时输出左边的表达式结果，为False时输出右边的表达式结果；
       

  5. pass语句

     pass语句什么都不做，只是一个占位符，用在语法需要语句的地方；

     在搭建语法结构是，没想好代码怎样写时用来暂时代替语句;

  6. 内置函数range()

     range()函数用于生成一个整数序列

     • 创建range()对象的三种方法：

       range(stop) # 创建一个[0,stop]之间的整数序列，步长为1；
       range(start,stop) # 创建一个[start,stop]之间的整数序列，步长为1；
       range(start,stop,step) # 创建一个[start,stop]之间的整数序列，步长为step；
       

       range()返回值是一个迭代器对象

• 循环语句

  1. for循环

     for循环可以对迭代对象进行遍历；

     • 基本格式：

       for 临时变量 in 可迭代对象:
           执行语句1
           执行语句2
           ……
       

       没执行一次循环，临时变量都会被赋值为迭代对象的当前元素，提供给执行语句使用；

• for—in循环与range()函数

  基本语法结构：

  for 自定义变量 in 可迭代对象：
  	循环体
  

  例：

  for item in 'Python':
      print(item)
  

  如果在循环体中不需要使用到自定义变量，可将自定义变量写为“__”(下划线)；

  例:

  for _ in range(5):
      print("人生苦短，我用Python;")
  

  for循环常与range()函数搭配使用，以控制for循环中代码段的执行次数。

  例：

  for i in range(3)
  	print("Hello")
  

• while循环

  while循环是一个条件循环语句，当满足条件时重复执行代码块，知道条件不满足为止；

  while 条件表达式：
  	代码块
  

  Tips：python中的for循环和while循环使用规则与C中一致；

• break和continue语句

  break和continue语句在python中不能单独使用，使用效果和C语言中的一样；

• else语句

  else的三种使用情况：

  if……else # if条件不成立时执行else
  while……else
  for……else
  #当循环体执行时没有遇到break时执行else中的语句
  

第四章——列表与元组

• 在python中，创建列表可以使用中括号“[]”创建，也可以使用内置的list()函数快速创建；

  列表的特点：

  1. 列表元素按顺序有序排序；
  2. 索引映射唯一一个数据；
  3. 列表可以存储重复数据；
  4. 任意数据类型混存
  5. 更具需要动态分配和回收内存；

  1. 使用中括号“[]”创建列表

     • 使用中括号“[]”创建列表，只需要在中括号“[]”中使用逗号分隔每个元素即可；

       例：

       list_one # 空列表
       list_two=['p','y','t','h','o','n'] # 列表中元素类型为字符串类型
       list_two=[1,'a','&',2.3] # 列表中的元素类型不同
       

  2. 使用list()函数创建列表

     • 使用list()函数同样可以创建列表，需要注意的时该函数接收的参数必须是一个可迭代类型的数据；

       例：

       li_one=list(1) # 因为int类型数据不是可迭代类型，所以列表创建失败
       li_tow=list('python') # 字符串类型是可迭代的
       li_three=list([1,'python']) # 列表类型是可迭代的
       

• 列表生成式

  • 语法格式

    list=[i for i in range(start,stop)] # 生成一个start到stop的整数里列表
    list=[i*8 for i in range(start,stop)]
    

    其中：第一个i的位置表示列表元素的表达式，第二个i的位置是自定义变量，range是可迭代对象；

• 可迭代对象

  使用isinstance()函数可以进行判断一个对象是否可以迭代；

  例：

  from collections import Iterable
  print(isinstance([],Iterable))
  

• 访问列表元素

  列表中的元素可以通过索引或切片的方式访问；

  1. 使用索引方式访问列表元素

     使用列表元素可以获取列表中的指定元素：
     例：

     list_demo01=["Java","C#","python","PHP"]
     print(list_demo01[2])
     print(list_demo01[-1])
     

  2. 使用切片方式访问列表元素

     使用切片可以截取列表中的部分元素，得到一个新列表：

     • 语法格式：

       列表名[start:stop:step] # 默认步长是1，step可以是负数
       

     例：

     li_one=['p','y','t','h','o','n']
     print(li_one[1:4:2])
     print(li_one[2:])
     print(li_one[:3])
     print(li_one[:])
     

  3. index()函数

     index() 函数用于从列表中找出某个值第一个匹配项的索引位置；

     • 基本语法格式：

       list.index(x, start, end)
       

       其中：x– 查找的对象。start– 可选，查找的起始位置。end– 可选，查找的结束位置。

       该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

• 列表的遍历和排序

  1. 列表的遍历

     列表是一个可迭代对象，它可以通过for循环遍历元素；

     例：

     list_one={'张三','李四','武田','李逵','李庚','张平'}
     print("今日促销通知！！！")
     for i in list_one
     	print(f"嗨，{i}！今日促销，赶快来抢吧！")
     

  2. 列表的排序

     • 列表中常用的排序方法有sort(),reverse() ,sorted();

       1. sort()方法

          • 基本格式：

            list.sort(key=None,reverse=False)
            

            其中，参数key表示指定的排序规则，该参数可以是列表支持的函数；参数reverse表示控制列表元素排序的方式，该参数可以取值Ture或者False,如果reverse的值为True，表示降序排列；如果reverse的值为False（默认值），表示升序排列；

            注意：使用sort()方法对列表排序后，排序后的列表会覆盖原来的列表，即对原列表进行操作；

       2. sorted方法

          • sorted()方法用于将列表元素升序排列，该方法返回值时升序排列后的新列表，原列表不受影响；

            li_one=[4,3,2,1]
            li_two=sorted(li_one) # 默认升序排列
            print(li_one)
            print(li_two)
            li_three=sorted(li_two,reverse=True) # 也可以改为降序排列
            

  3. reverse()方法

     • reverse()方法 用于将列表中的元素倒序排列，即把原列表中的元素从右至左依次排列存放

        li_one=['a','b','c','d']
        li_one.reverse()
        print(li_one)
       

• 添加删除和修改列表元素

  1. 添加元素列表

     • append()方法

       append方法用于在列表末尾添加新的元素；

       list_one=[1,2,3,4]
       list_one.append(5)
       print(list_one)
       

     • extend()方法

       extend()方法用于在列表末尾一次性添加另一个序列中的所有元素，及使用新列表扩展原来的列表；

       list_str=['a','b','c','c']
       list_num=[1,2,3]
       list_str.extend(list_num)
       print(list_num)
       print(list_str)
       

     • insert()方法

       insert()方法用于将元素插入列表的指定位置；

       names=['bady','Lucy','Alise']
       names.insert(2,'Peter')
       print(names)
       

     • 切片

       在列表的任意位置添加至少一个元素

       例：

       lst_1 = [1, 2, 3, 4, 5, 6]
       lst_2 = ['a', 'b', 'c', 'd', 'e']
       lst_1[1::] = lst_2[2::3]
       print(lst_1)
       

  2. 删除列表元素

     删除列表元素的常用方式有del语句、remover()方法、pop()方法；

     • del语句

       del语句用于删除列表指定位置的元素，也可以直接删除整个列表；

       name=['baby','Lucy','Alise']
       dle names[0]
       print(names)
       

     • clear()方法

       clear()方法用于清空整个列表；

     • remove()方法

       remove()方法用于移除列表中的某个元素，若列表中有多个匹配的元素，只会移除匹配到的第一个元素；

       chars=['h','e','l','l','e']
       chars.remove('e') # 只会删除一个匹配的元素
       print(chars)
       

     • pop()方法

       pop()方法用于移除列表中的某个元素，如果不指定具体元素，那么移除列表中的最后一个元素；

       numbers=[1,2,3,4,5]
       print(numbers.pop()) # 移除列表中的最后一元素
       print(numbers.pop(1)) # 移除列表中索引为1的元素
       print(numbers)
       

     • 切片删除

       切片删除操作至少删除一个元素，将会产生一个新的列表对象；

       例__1：

       list=[1,2,3,4,5]
       new_list=list[1:3]
       print(list)
       print(new_list)
       

       例_2：

       用空列表代替切片的位置，不产生新的列表对象，而是删除列表中的内容；

       list=[1,2,3,4,5]
       list[1:3]=[]
       print(list)
       

  3. 修改列表元素

     修改列表中的元素就是通过索引获取元素并对该元素重新赋值；

     names=['baby','Lucy','Alise']
     names[0]='Harry' # 建索引为0的元素'baby'重新赋值为'Harry'
     print(name)
     

• 认识元组

  元组是python内置的数据结构之一，是一个不可变序列；

  • 不可变序列：字符串、元组;没有增、删、改的操作

  • 可变序列：列表、字典；可对序列执行增、删、改操作，对象地址不发生改变

  元组的创建方式与列表的创建方式相似，可以通过括号“()”或内置的tuple()函数快速创建；

  1. 使用圆括号()创建元组

     使用圆括号()创建元组，并将元组中的元素用逗号进行隔开；

     例：

     tu_one=() # 空元组
     tu_None=tuple()
     tu_two=('t','u','p','l','e') # 元组中元素类型均为字符串类型
     tu_three=(0.3,1,'python','&') # 元组中元素类型不同
     

  2. 使用tuple()函数创建元组

     使用tuple()函数创建元组时，如果不传入任何数据，就会创建一个空元组；如果要创建包含元素的元组，就需要传入可迭代类型的数据；

     tuple_null=tuple()
     print(tuple_null) # 输出：()
     tuple_str=tuple('abc')
     print(tuple_str) # 输出： ('a','b','c')
     tuple_list=tuple([1,2,3])
     print(tuple_list) # 输出：(1,2,3)
     

  注意：当元组中只包含一个元组的元素需要使用逗号和小括号，否则会认为是本身的数据类型；

  t3=('python',) # 逗号不能省略
  

• 访问元组元素

  可以通过索引或切片的方式来访问元组中的元素；

• 为什么要将元组设计成不可变序列：

  在多任务环境下，同时操作对象是不需要加锁；

  因此，在程序中尽量使用不可变序列

  • 注意：元组中的存储的是对象的引用

    1. 如果元组对象本身不可对象，则不能在引用其它对象；
    2. 如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变；

• 若元素中的某个元素是可变类型的数据，则可以将列表中的元素进行修改。

  例：

  tuple_char=('a','b',['1','2'],'c')
  tuple_char[2][0]='c'
  tuple_char[2][1]='d'
   # tuple_char[1]='c' # 报错
  

第五章——字典与集合

• 字典的创建方式

  1. 使用花括号{}创建字典

     使用花括号{}创建字典时，字典中的键（key）和值（value)使用冒号连接；

     • 基本语法格式

       {键1:值1,键2:值2,……}
       {key1:value1,key2:value2,……}
       demo_dict={} # 空字典
       

  2. 使用内置的dict()函数创建字典

     使用dict()创建字典时，字典中的键（key）和值（value)使用=连接

     • 基本语法格式

       dict{key1:value1,key2:value2,……}
       dict{} # 空字典
       

• 字典中的元素获取

  []取值与使用get()取值得区别

  []如果字典中不存在指定得key，抛出keyError异常；

  get()方法取值，如果字典中不存在指定得key，并不会抛出keyError而是返回None，可以通过参数设置默认值为value，以便指定得key不存在时返回；

  • 基本语法格式

    scores = {'张三': 90, '李四': 98, '王五': 10}
     # 方法一
    print(scores['张三'])
    # print(scores['ss']) 程序会报错
     # 方法二
    print(scores.get('张三'))
    print(scores.get('ss', 99))  # 输出None
    

• 字典的常用操作

  1. key的判断

     in指定的key在字典中存在返回值True

     not in 指定的key不在字典内存在返回值True

  2. 字典元素的删除

     基本语法格式：

     del scores['张三']
     

     清除字典元素语法格式：

     1. pop()

        pop()方法可根据指定的键值删除字典中的指定元素，若删除成功，该方法返回目标元素的值；

        scores = {'张三': 90, '李四': 98, '王五': 10}
        print(scores.pop('张三'))
        print(scores)
        

     2. popitem()

        popitem()方法可以随机删除字典中的元素，实际上popitem()之所以能删除随机元素，是因为字典元素本身是无序的，没有所谓的第一项或最后一项；若删除成功，popitem()方法返回目标元素；

        scores = {'张三': 90, '李四': 98, '王五': 10}
        print(scores.popitem())
        print(scores)
        

     3. clear()方法

        clear()方法用于清空字典中的元素；

        scores = {'张三': 90, '李四': 98, '王五': 10}
        scores.clear()
        print(scores)
        

  3. 字典元素的新增

     基本语法格式：

     score['程六']=90
     

  4. 获取字典视图的三个方法

     • key()：获取字典中所有的key

       scores = {'张三': 90, '李四': 98, '王五': 10}
       keys = scores.keys()
       print(keys)
       print(type(keys)) # 获取keys的数据类型
       print(list(keys)) # 将会获取的字典数据转换为列表
       

     • value()：获取字典中所有的value

       scores = {'张三': 90, '李四': 98, '王五': 10}
       values = scores.values()
       print(scores.values())
       print(values)
       print(type(values))
       print(list(values))
       

     • items()：获取字典中所有key、value对；

       scores = {'张三': 90, '李四': 98, '王五': 10}
       items = scores.items()
       print(items)
       

  5. 字典元素的遍历

     基本语法格式

     scores = {'张三': 90, '李四': 98, '王五': 10}
     for item in scores:
         print(item) # 输出字典键
         print(scores[item]) # 输出字典值
         print(scores.get(item)) #输出字典值
     

  • 字典的特点：

    1. 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复

    2. 字典中的元素是无序的

    3. 字典中的key必须是不可变对象

    4. 字典也可以根据需要动态地伸缩

    5. 字典会浪费较大的内存空间，是一种使用空间换时间的数据结构

  • 字典生成式

    • 内置函数zip()

      用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回有这些元组组成的列表；

      基本语法格式：

      {item:price for item,price in zip(items,prices)}
      

      例：

      items = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
      price = ['1', '2', '3', '4', '5', '6', '7']
      d = {items: price for items, price in zip(items, price)}
      print(d)
      

• 集合的创建

  python中的集合分为可变集合与不可变集合，可变集合由set()函数构成，集合中的元素可以动态的增删改；不可变集合由frozenset()函数创建，集合中的元素不可变；

  • 集合中元素不允许重复，会自动清除重复元素；

  • 集合中的元素无序；

  • 集和是没有value的字典；

  • 基本语法格式：

    set([iterable]) # iterable 是一个可迭代对象
    frozenset([iterable])
    

    • 集合生成式：

      基本格式：

      {i for in range(start,end)}
      

      元组没有生成式；

1. 可变集合的创建

   使用set()函数创建可变集合；

   例：

   set_one=set([1,2,3]) # 使用set()函数创建可变集合，传入一个列表
   set_two=set((1,2,3)) # 使用set()函数创建可变集合，传入一个元组
   

2. 不可变集合的创建

   使用frozenset()函数创建的集合是不可变集合；

   例：

   frozenset_one=frozenset(('a','b','c','d','e')) # 传入一个元组
   frozenset_one=frozenset(['a','b','c','d','e']) # 传入一个列表
   

• 集合操作与操作符

  1. 添加元素

     可变集合的add()方法或update()方法都可以实现向集合中添加元素，不同的是，add()方法只能添加一个元素，而update()方法可以添加多个元素；

     例：

     demo_set=set()
     demo_set.add('py') # add方法是将'py'作为一个整体添加到集合demo_set中去
     demo_set.update('thon') # update方法将"thon"拆分成多元素添加到集合demo_set中
     demo_set.update([1,2,3,4])
     print(demo_set)
     

  2. 删除元素

     python使用remover()方法、discard()方法和pop()方法删除可变集合中的元素；

     • remove()方法：用于删除可变集合中指定的元素；

       例：

       remove_set={'red','green','black'}
       remove_set.remove('red')
       print(remove)
       
       

       注意：若指定的元素不在集合中，则会出现KeyError错误；

     • discard()方法：可以删除指定的元素，但若指定的元素不存在，该方法不会执行任何操作；

       discard_set={'red','green','black'}
       discard_set.discard('red')
       discard_set.discard('black')
       print(discard_set)
       

     • pop()方法：用于删除可变集合中的随机元素；

       discard_set={'red','green','black'}
       discard_set.pop() # pop() 不能加参数
       print(discard_set)
       

     • 清空set集合元素

       如果需要清空可变集合元素，可以使用clear()方法实现；

       例：

       discard_set={'red','green','black'}
       discard_set.clear()
       print(discard_set)
       

  3. 结合类型的操作符

     已知有set_a={‘a’,’b’,’c’}和set_b={b’,’c’}

     • 联合操作符（|）——union()

       联合操作是将集合set_a与集合set_b合并成一个新的集合；

       例：

       print(set_a | set_b)
       print(set_a.union(set_b))
       

     • 交集操作符（&）——intersection()

       交集操作是将集合set_a与集合set_b中相同的元素提取为一个新的集合；

       例：

       print(set_a & set_b)
       print(set_a.intersection(set_b))
       

     • 补差操作符（-）——difference()

       补差操作是保留属于集合set_a或者只属于集合set_b的元素作为一个新的集合；

       例：

       print(set_a - set_b)
       print(set_a.difference(set_b))
       

     • 对称差分操作符（^）——symmetric_difference()

       对称差分操作是保留只属于集合set_a与只属于集合set_b的元素作为一个新的集合；

       例：

       print(set_a ^ set_b)
       print(set_a.symmetric_difference(set_b))
       

• 列表、元组、字典、集合的区别

  类型	可变性	唯一性	有序性
  列表：[]	可变	可重复	有序
  元组：()	不可变	可重复	有序
  字典：{key:value}	可变	可重复	无序
  集合：{}	可变、不可变	不可重复	无序

第六章——函数

• 函数的定义

  Python中，使用关键字定义函数，其语法格式如下:

  def 函数名([参数列表]):
      ["函数文档字符串"]
      函数体
      [return语句]
  

  说明：

  1. def关键字：函数以def关键字开头，其后跟函数名和与圆括号();
  2. 函数名：用于标识函数的名称，遵循标识符的命名规则；
  3. 参数列表：用于接收传入函数中的数据，可以为空；
  4. 冒号：用于标识函数体的开始；
  5. 函数文档字符串：一对由三引号包含的字符串，是函数的说明信息，可以省略
  6. 函数体：实现函数功能的具体代码；
  7. return语句：用于将函数的处理结果返回给函数的调用者，若函数没有返回值，return语句可以省略；

• 函数的调用

  函数的调用格式：

  函数名([参数列表])
  

• 函数的参数传递

  函数的参数传递是指将实际参数传递给形式参数的过程，更具不同的传递方式，函数的参数可分为位置参数、关键字参数、默认值参数、不定长参数；

  1. 位置参数

     调用函数时，编译器会将函数的实际参数按照位置一次传递给形式参数，即将第一个实际参数传递给第一个形式参数，将第二个实际参数传递给第二个形式参数，以此类推：

     例：

     def division(num_one,num_two):
         print(num_one/num_two)
         
     division(6,2) # 位置参数传递
     #上边的代码6传给了num_one,2传给了num_two
     

  2. 关键字参数

     关键字参数传递通过“形式参数=实际参数”的格式将实际参数与形式参数相关联，根据形式参数的名称进行参数传递

     例：

     def info(name,age,address):
         print(f'姓名:{name}')
         print(f'年龄:{age}')
         print(f'地址:{address}')
         
     info(name='张三',age=10,address='山东')
     info(age=10,name='张三',address='山东') # 关键参数对参数的位置没有要求
     

  3. 默认参数

     定义函数时可以指定形式参数的默认值，调用函数时，若没有给带有默认值的形式参数传值，则直接使用参数的默认值；若给带有默认值的形式参数传值，则实际参数会覆盖默认参数

     例：

     def connect(ip,port=3306): # 默认参数在其他参数之后
         print(f"连接地址为:{ip}")
         print(f"连接端口号为:{port}")
         print("连接成功")
         
     connect('127.0.0.1') # port使用默认值
     connect(ip='127.0.0.1',port=8080) # port的默认值被覆盖
     connect('127.0.0.1',8080)
     

     注意：若函数中包含默认参数，调用该函数时默认参数应在其他参数之后；

  4. 不定长参数

     若要传入函数中的参数的个数不确定，可以使用不定长参数。不定长参数也称可变参数，此种参数接收参数的数量可以任意改变。

     基本语法格式：

     def 函数名([formal_args,]*args,**kwargs):
         ["函数_文档字符串"]
         函数体
         [return语句]
     

     参数*args和参数**kwargs都是不定长参数，可以搭配使用，也可单独使用；

     • *args

       不定长参数*args用于接收不定数量的位置参数，调用函数时传入的所有参数被*args接收后以元组的形式保存；

       例：

       def test(*args):
           print(args)
           
       test(1，2，3，a,b,c,d,e,……) # 可以传入任意个实参
       
       输出结果为：
       (1，2，3，'a','b','c'，'d','e',……)
       

     • **kargs

       不定长参数**kargs用于接收不定数量的关键字参数，调用函数时传入的所有参数被**kargs接收后以字典的形式保存；

       例：

       def test(**kargs):
           print(kargs)
           
       test(a=1,b=2,c=3,d=4,……) # 可以传入任意个实参
       
       输出结果为：
       {'c':3,'a':1,'d':4,'b'=2} # 由于字典是无序的所以不会按顺序输出
       

• 变量作用域

  变量作用域是指变量的作用范围。

  1. 局部变量

     局部变量是在函数内定义的变量，只在定义它的函数内生效；

     例：

     def use_var():
         nmae='Python' # 局部变量
         print(name) # 函数内访问局部变量
        
     use_var()
     print(name) # 函数外无法访问局部变量(此行代码会是程序报错)
     

  2. 全局变量

     全局变量是在函数外定义的变量，它在程序中任何位置都可以被调用。

     例：

     count=10 # 全局变量
     def use_var():
         print(count) # 函数内访问全局变量
       
     use_var()
     print(count) # 函数外访问全局变量
     

     函数中只能访问全局变量，但不能修改全局变量。若要在函数内修改全局变量的值，需要在函数内使用关键字global进行声明;

     例：

     count=10 # 全局变量
     def use_var():
         global count # 声明全局变量
         count+=10 # 修改全局变量
         print(count) # 函数内访问全局变量
       
     use_var()
     print(count) # 函数外访问全局变量
     

• 函数的特殊形式

  匿名函数和递归函数

  1. 匿名函数

     匿名函数是无需函数名标识的函数，他的函数体只能是单个表达式。Python中使用关键字lambda定义匿名函数，基本语法格式如下：

     lambda [arg1 [,arg2,……，argn]]:expression
     

     例：

     area=lambda a,h:(a*h)*0.5 # 为方便使用匿名函数，应使用变量记录这个函数；
     print(area(3,4))
     

     “[arg1 [,arg2,……，argn]]”表示匿名函数的表达式，expression是一个表达式；

     • 匿名函数与普通函数主要有以下不同：
       1. 普通函数需要使用函数进行标识；匿名函数不需要使用函数名进行标识；
       2. 普通函数的函数体中可以有多条语句；匿名函数只能有一个表达式；
       3. 普通函数可以实现比较复杂的功能；匿名函数只能实现比较单一的功能；
       4. 普通函数可以被其他程序调用；匿名函数不能被其他程序使用；

• Python常用的内置函数

  函数	说明
  abs()	计算绝对值，其参数必须是数字类型
  len()	返回序列对象（字符串、列表、元组等）的长度
  map()	根据提供的函数对只当的序列做映射
  help()	用于查看函数或模块的使用说明
  ord()	用于返回Unicode字符对应的码值
  chr()	与ord()功能相反，用于返回码值对应的Unicode字符
  filter()	用于过滤序列，返回由符合条件的元素组成的新列表

第七章——类与面向对象

• 类的定义与访问

  在程序中创建对象之前需要先定义类。类是对象的抽象，是一种自定义数据类型，它用于描述一组对象的共同特征和行为。类中可以定义数据成员和成员函数，数据成员用于描述对象特征，成员函数用于描述对象行为，其中数据成员也被称为属性，成员函数也称为方法；

  类的定义格式如下：

  class 类名: # 使用class定义类
      属性名=属性值	# 定义属性
      def 方法名(self): # 定义方法
          方法体
  

  以上格式中的class时定义类的关键字，其后的类名是类的标识符，类名首字母一般为大写。类名后的冒号(:)必不可少，之后的属性和方法都是类的成员，但需要注意的是，方法中有一个指向对象的默认参数self。

• 对象的创建与使用

  类定义完成以后不能直接使用，程序中的累需要实例化为对象才能实现其意义。

  1. 创建对象

     创建对象的格式：

     对象名=类名()
     

  2. 访问对象成员

     访问格式：

     对象名.属性
     对象名.方法()
     

• 访问权限

  类中定义的属性和方法默认为公有属性和方法，该类的对象可以任意访问类的公有成员，但考虑到封装思想，类中的代码不应该被外部代码轻易访问 。为了契合封装原则，Python支持将类的成员设置为私有成员，在一定程度上限制对象对类成员的访问；

  1. 定义私有成员

     Python通过在类成员名之前添加双下划线(__)来限制成员的访问权限，语法格式如下：

     __属性名
     __方法名
     

     例：

     class PersonInfo:
         __weight=55 # 私有属性
         def __info(self):  # 私有方法
                 print(f"我的体重是:{__weight}")
     

  2. 私有成员的访问

     # y下代码均为错误示范
     person=PersonInfo()
     person.__weight
     person.__info()
     

     对象无法直接访问类的私有成员

     • 访问私有属性：

       访问私有属性可在公有方法中通过指代类本身的默认参数self访问，类外部可通过公有方法间接获取类的私有属性；

       例：

       class PersonInfo:
           __weight=55 
           def get__weight(self)::
                   print(f"我的体重是:{self.__weight}")
                  
       person=PersonInfo()
       person.get__weight()
       

     • 访问私有方法：

       私有方法同样在公有方法中通过参数self访问，修改PersonInfo类，在私有方法__info()中通过self参数访问私有属性__weight

       ,并在公有方法get__weight()中通过self参数访问私有方法__info(),代码如下：

       class PersonInfo:
           __weight=55 
           def __info(self):  # 私有方法
                   print(f"我的体重是:{__weight}")
           def get__weight(self)::
                   print(f"体重是:{self.__weight}kg")
                   self.__info()
                  
       person=PersonInfo()
       person.get__weight()
       

• 构造方法和析构方法

  类中有两个特殊的方法：构造方法__init__()和析构方法__del__()。这两个方法分别在类创建和销毁时自动调用；

  1. 构造方法

     每个类都有一个默认的__init__()方法，如果在定义时显式地定义了__init__()方法，则创建对象是Python解释器会调用显式定义的__init__()方法；如果定义类时没有显式定义__init__()方法，那么Python解释器会调用默认的__init__()方法。

     __init__()方法按照参数的有无（self除外）可分为有参构造方法和无参构造方法，无参构造方法中可以为属性设置初始值，此时使用该方法的所有对象都具有相同的初始值。若希望每次创建的对象都有不同的初始值，则可以使用有参数方法实现。

     注意：前面在类中定义的属性是类属性，可以通过对象或类进行访问；在构造方法中定义的属性是实例属性，只能通过对象进行访问。

  2. 析构方法

     在创建对象时，系统自动调用__init__()方法，在对象被清理时，系统也会自动调用一个__del__()方法。

     Python中的垃圾回收主要采用的是引用计数。引用计数是一种内存管理技术，它通过引用计数器记录所有对象的应用数量，当对象的引用计数值为0时，就会将该对象视为垃圾进行回收。getrefcount()函数时sys模块中用于统计对象引用数量的函数，其返回结果通常比预期的结果大1，这是因为getrefcount()函数时也会统计临时对象的引用；

     例：

     import sys
     class Destruction:
         def __init__(self):
     		print('对象被创建')
         def __del__(self):
             print('对象被释放')
      # 创建对象des，调用`getrefcount()`函数返回Destruction类的对象的引用计数器的值；
     des=Destruction()
     print(sys.getrefcount(des))
     

• 类方法和静态方法

  1. 类方法

     类方法和实例方法有以下不同：

     • 类方法使用装饰器@classmethod修饰；
     • 类方法的第一个参数为cls而非self，他代表类本身；
     • 类方法即可由对象调用，亦可直接由类调用；
     • 类方法可以修改类属性，实例方法无法修改类属性；

  • 定义类方法：

    类方法可以通过类名或对象名进行调用，基本语法格式如下：

    类名.类方法
    对象名.类方法
    

    例：

    class Test:
    	@classmethod
        def use_classmet(cls):
            print('我是类方法')
            
    test=Test()
    # 类名或对象名均可调用类方法
    test.use_classmet()
    Test.use_classmet()
    

  • 修改类属性

    在实例方法汇中无法修改属性的值，但在类方法中可以将类属性的值进行修改；

    例：

    class Apple(object):
        count=0
        def add_one(self):
            self.count=1
        @classmethod
        def add_two(cls):
            cls.count=2
            
    apple=Apple()
    apple.add_one()
    print(Apple.count)
    Apple.add_tow()
    print(Apple.count)
    

• 静态方法

  静态方法与示例方法有以下不同：

  1. 静态方方法没有self参数，它需要使用@staticmethod修饰
  2. 静态方法中需要以“类名.方法/属性名”的形式访问类的成员；
  3. 静态方法即可由对象调用，亦可直接由类调用；

  例：

  class Example:
      num=10
      @staticmethod
      def static_method():
          print(f"类属性的值为：{Example.num}")
          print("---静态方法")
          
  example=Example()
  example.static_method()
  Exmaple.static_method()
  

• 类方法和静态方法的区别

  类方法和静态方法最主要的区别在于类方法有一个cls参数，使用该参数可以在类方法中访问类的成员；静态方法没有设置任何默认参数（如cls），他无法使用默认参数访问类的成员。因此，静态方法更适合与类无关的操作。

• 继承

  1. 单继承

     单继承指的是子类只能继承一个父类，其语法格式如下：

     class 子类（父类）：
     	……
     

     例：

     class Amphibian:
         name="两栖动物"
         def features(self):
             print("幼年时用鳃呼吸")
             print("成年用肺兼皮肤呼吸")
             
     # 子类继承父类以后，就拥有了从父类继承的属性和方法，它既可以调用自己的方法，又可以调用从父类继承的方法。
     class Frog(Amphibian):
         def attr(self):
             print(f"青蛙是{self.name}")
             print("我会呱呱叫")
             
             
     frog=Frog()
     print(frog.name)
     frog.features()
     frog.attr()
     

     • 多学一招

       Python提供了两个和继承相关的函数，分别是isinstance()函数和issubclass()函数

       isinstance(o,t)函数用于检查对象的类型，它有两个参数，第一个参数是要判断的对象（o），第二个参数时类型（t）,如果o是t类型的对象，则函数返回True，否则返回False。

       例：

       isinstance(frog,Frog)
       

       函数issubclass(cls,classinfo)用于检查类的继承关系，它有两个参数：第一个参数是要判断的子类的类型（cls）；第二个参数是要判断的父类类型（classinfo）。如果cls类型是classinfo类型的子类，则函数返回True，否则返回False。

       例：

       issubclass(Frog,AmphAnimal)
       

     2. 多继承

        多继承指的是一个子类继承多个父类，其语法格式如下：

        class 子类(父类A,父类B)
        

        例：

        class English(object):
            def eng_know(self):
                print('具备英语知识')
        
        
        class Math:
            def math_know(self):
                print('具备数学知识')
        
        
        class Student(English, Math):
            def study(self):
                print('学生的任务是学习')
        
        
        s = Student()
        s.eng_know()
        s.math_know()
        s.study()
        

     3. 方法的重写

        子类可以继承父类的属性和方法，若父类的方法不能满足子类的要求，子类可以重写父类的方法。

        例：

        class Felines:
            def speciality(self):
                print("猫科动物特特长是爬树")
        
        
        class Cat(Felines):
            name = "猫"
        
            def speciality(self):
                print(f'{self.name}会抓老鼠')
                print(f'{self.name}会爬树')
        
        
        cat = Cat()
        cat.speciality()
        

     4. super()函数

        如果子类重写了父类的方法，但仍希望调用父类中的方法，就可以使用super()函数，使用该函数可以调用父类中的方法。

        super()函数使用的方法如下：

        super().方法名()
        

        例：

        class Cat_Black(Felines):
            name = "黑猫"
        
            def speciality(self):
                print(f'{self.name}会抓老鼠')
                print(f'{self.name}会爬树')
                super().speciality()
        
        
        cat_b = Cat_Black()
        cat_b.specialit()
        

     5. 多态

        Python中并不需要显式指定对象的类型，只要对象具有预期的方法和表达式操作符，就可以适用对象。也可以说，只要对象支持所预期的“接口”，就可以使用，从而实现多态。

        例：

        class Animal(object):
            def move(self):
                pass
        
        
        class Rabbit(Animal):
            def move(self):
                print("兔子蹦蹦跳跳")
        
        
        class Snail(Animal):
            def move(self):
                print("蜗牛缓慢爬行")
        
        
        def test(obj):
            obj.move()
        
        
        rabbit = Rabbit()
        test(rabbit)
        snail = Snail()
        test(snail)
        

第八章——模块

1. 模块的导入方式：

   Python模块的导入方式分为使用import导入和使用from…import…导入两种；

   • 使用import导入

     import支持一次导入多个模块，每个模块之间使用逗号隔开；

     基本语法格式为：

     improt 模块1,模块2,……
     

     模块导入后便可通过“.”使用模块中的函数或类，基本语法格式如下：

     模块名.函数名()/类名
     

     如果在开发中需要导入一些名称比长的模块，可使用as为这些模块起别名，基本语法格式如下：

     import 模块名 as 别名
     

2. 使用from…import…导入

   使用“from…import…”方式导入模块之后，无需添加，可以像使用当前程序中的内容一样使用模块中的内容，其基本语法格式为：

   from 模块名 import 函数/类/变量
   

   from…import…也支持一次导入多个函数、类或变量，多个函数，多个变量之间使用逗号隔开

   例：

   from time import sleep，time
   

   利用通配符“*”可以使用from…import…导入模块中的全部内容，语法格式如下：

   from 模块名 import *
   

   from…import…支持为模块或模块中的函数起别名，语法格式如下：

   from 模块名 import 函数名 as 别名
   

   注意：虽然“from…import…”方式可简化模块中内容的引用，但可能会出现函数重名问题，因此，相对而言使用import语句导入魔魁啊更为安全；

3. 常见的标准化模块

   • sys模块

     sys模块中提供了一系列与Python解释器交互的函数和变量，用于操控Python的运行时环境。

     变量/函数	说明
     sys.argv	获取命令行参数列表，该类表中的第一个元素是程序自身所在路径
     sys.version	获取Python解释器的版本信息
     sys.path	获取模块的搜索路径，该变量的初始值为环境便变量PYTHONPATH的值
     sys.platform	返回操作系统平台的名称
     sys.exit()	退出当前程序，可为该函数传递参数，已设置返回值或退出信息，正常退出返回值为0

   • os模块

     os模块中提供了访问操作系统服务的功能

     函数	说明
     os.getcwd()	获取当前工作路径，即当前Python脚本所在位置
     os.chdir()	改变当前脚本工作路径
     os.remove()	删除指定文件
     os._exit()	终止Python程序
     os.path.abspath(path)	返回path规范化的绝对路径
     os.path.split(path)	将path分隔为形如（目录，文件名）的二元组并返回

     exit()是os模块中的终止程序函数，该函数与sys模块中中的exit()函数略有不同，执行os模块中的_exit()函数后，程序会立即结束，之后的代码也不会在执行；而执行sys模块中的exit()函数会引发一个SystemExit异常，若没有捕获该异常退出程序，后面的代码不会再执行；若捕获到该异常，则后续的代码仍然会执行。

   • random模块

     random模块为随机数模块，该模块中定义了多个可产生各种随机数的函数。

     函数	说明
     random.random()	返回(0,1]之间的随机实数
     random.randint()	返回[x,y]之间的随机数
     random.choice(seq)	从序列seq中随机返回一个元素
     random.uniform(x,y)	返回[x,y]之间的随机浮点数

   • time模块

     time模块中提供了一系列处理时间的函数；

     函数	说明
     time.time()	获取当前时间，结果为实数，单位为秒
     time.sleep(secs)	进入休眠，市场有参数secs指定，单位为秒
     time.strptime(string[,foramt])	将一个时间格式的字符解析为时间元组
     time.localtime([secs])	以struct_time类型输出本地时间
     time.asctime([tuple])	获取时间字符串，或将时间元组转换为字符串。
     time.mktime(tuple)	将时间元组转换为秒数
     strftime(format[,tuple])	返回字符串表示的当地时间，格式有format决定

• 自定义模块

  自定义模块的导入：

  1. 与标准模块相同，自定义模块也通过import语句和from…import…语句导入

  2. 在程序开发过程中，如果需要导入其他目录下的模块，可以将被导入模块的目录添加到Python模块的搜索路径中，否则程序会因为搜索不到路径出现错误。

     把其他目录下的模块路径添加到当前模块路径下：

     sys.path.append(需要添加模块的路径名)
     

• 模块的导入特性

  1. __all__属性

     Python模块中的开通通常会定义一个__all__属性，该属性实际上是一个列表，该列表中包含元素决定了在使用“from…import*”语句导入模块内容是通配符“*”所包含的内容。如果__all__中只包含模块的部分内容，那么“from…import*”语句只会将__all__中包含的部分内容导入程序中。

     例：

     # 自定义模块 calc.py
     """
     在calc模块中设置__all__属性为["add","subtract"]，此时其他Python文件导入calc模块后，只能使用calc模块中的add()与subtract()函数
     """
     __all__=["add","subtract"]
     def add(a,b):
         return a+b
     def subtract(a,b):
         return a-b
     def multiply(a,b):
         return a*b
     def divide(a,b):
     	if (b):
             return a/b
         else :
             print("error")
             
             
     # 通过“`from…import*`”方式导入calc模块，然后使用该模块中的add()函数与subtract()函数
     from calc import *
     print(add(2,3))
     print(subtract(2,3))
     """
     错误代码
     print(multipty(2,3))
     print(divide(2,3))
     """
     

  2. __name__属性

     在比较大的项目开发中，一个项目通过有多名开发人员共同开发，每名开发人员负责不同的模块，为了保证自己编写的程序在整合后可以正常运行，开发人员通常需要整合前额外编写测试代码，对自己负责的模块进行测试，然而，对整个项目而言，这些测试代码是无用的，为了避免项目运行这些测试代码，Python中增加了__name__属性；

     __name__属性通常与if条件语句一起使用，若当前模块是启动模块，则其__name__的值为__main__；若模块被其它程序导入，则__name__的值为文件名。

     if __name__=="__main__":
         print(add(3,5))
         print(subtract(3,5))
         print(mulitply(3,4))
         print(divide(3,4))
     else:
         print(__name__)
     

• Python中的包

  1. 包的结构

     为了更好地组织Python代码，开发人员通常会根据不同业务将模块进行归类划分，并将功能相近的模块放到同以目录下。如果想要导入该目录下的模块，就需要先导入包；

     Python中的包是一个包含__init__.py文件的目录，该目录下还包括一些模块和子包；

     __init__.py文件的两个作用：

     1. 表示当前目录是一个Python包；

     2. 模糊导入；

        如果__init__.py文件中没有声明__all__属性，那么使用“from…import*”导入内容为空。

  2. 包的导入

     包的导入与模块的导入方法大致相同，亦可使用import或“from…import…”实现：

     • 使用import导入

       使用import导入包中的模块是，需要在模块名的前面加上包名，格式为“包名.模块名”。若要使用已导入模块中的函数，需要通过“包名.模块名.函数名”实现。

     • 使用“from…import…”导入

       通过“from…import…”导入包模块包含的内容时，若需要使用导入模块中的函数，需要通过“模块.函数”实现

       例：from 包名import 模块名

第九章——文件与文件路径操作

• 文件的打开和关闭

  要想将数据写入到文件中，需要先打开文件，数据写入完毕后，需要将文件关闭以释放计算机内存。

1. 打开文件

   Python内置的open()函数用于打开文件，该函数调用成功会返回一个文件对象，其语法格式为：

   open(file,mode='r',encoding=None)
   

   open()函数中的参数file接收待打开的文件名，参数encoding表示文件的编码格式；参数mode设置文件的打开模式。其常用模式有r/w/a,这些模式的含义分别为：

   1）r：以只读的方式打开文件，默认值；

   2）w：以只写的方式打开文件；

   3）a：以追加的方式打开文件；

   打开模式	名称	描述
   r/rb	只读模式	以只读的方式打开文本文件/二进制文件，若文件不存在或无法找到，open()函数将调用失败
   w/wb	只写模式	以只写的方式打开文本文件/二进制文件，若文件已存在，则重写文件，否则创建文件
   a/ab	追加模式	以只写的形式打开文本文件/二进制文件，只允许在该文件末尾追加数据，若文件不存在，则创建新文件
   r+/rb+	读取（更新）模式	以读/写的形式打开文本文件/二进制文件，如果文件不存在，open()函数调用失败
   w+/wb+	写入（更新）模式	以读/写的形式创建文本文件/二进制文件，若文件已存在，则重写文件
   a+/ab+	追加（更新）模式	以读/写的形式打开文本/二进制文件，但只允许在文件末尾添加数据，若文件不存在，则创建新文件

• 关闭文件

  Python内置close()方法用于关闭文件，该方法没有参数，直接调用即可。

  使用方法：文件对象.close()

  程序执行完毕后，系统会自动关闭又该程序打开的文件，但计算机中可打开的文件数量有限，每打开一个文件，可打开文件数量就会减一；打开的文件占用系统资源，若打开的文件过多，会降低系统性能。因此，编写程序时应使用close()方法主动关闭不再使用的文件。

• 从文件中读取数据

  1. read()方法

     read()方法可以从指定文件中读取指定数据，其语法格式如下：

     文件对象.read([size])
     # 参数size用于设置读取数据的字节数，若参数size缺省，则一次读取指定文件中的所有数据
     

  2. readline()方法

     readline()方法可以从指定文件中读取一行数据，其语法格式如下：

     文件对象.raedline()
     # readline()方法每执行一次只会读取文件中的一行数据
     

  3. readlines()

     readlines()方法可以一次读取文件中的所有数据，其语法格式如下：

     文件对象.readlines()
     # readlines()方法在读取数据后会返回一个列表，文件中的每一行对应列表中的一个元素
     

     其中read()（参数缺省时）和readline()方法都可以一次读取文件中全部数据，但这两种操作不够安全。因为计算机内存是有限的，若文件较大，read()和readline()的一次读取便会耗尽系统内存，为了保证读取安全，通常多次调用read()方法，每次读取size字节的数据。

• 向文件中写入数据

  1. write()方法

     使用write()方法向文件中写入数据，其语法格式为：

     文件对象.write(str)
     # str表示要写入的字符串。若字符串写入成功，write()返回本次写入文件的长度
     

  2. writelines()方法

     writelines()方法用于向文件中写入字符串序列，其语法格式为：

     文件对象.writelines([str])
     

• 文件的定位读取

  在文件的一次打开与关闭之间进行操作的读/写操作都是连续的，程序总是从上次读写的位置继续向下进行读/写操作。实际上，每个文件对象都有一个称为“文件读/写位置”的属性，该属性用于记录文件当前读/写的位置。

  Python提供了用于获取文件读/写位置以及修改文件读/写位置的方法tell()与seek().

  1. tell()方法

     tell()方法用于获取当前文件读/写的位置，其语法格式如下：

     文件对象.tell()
     

  2. seek()方法

     seek()方法用于设置当前文件读/写位置，其语法格式为：

     文件对象.seek(offset,from)
     

     seek()方法的参数offset表示偏移量，即读/写位置需要移动的字节数；参数from用于指定文件的读/写位置，该参数的取值有0、1、2，它们代表的含义分别如下：

     ​ 1）0：代表在开始位置读/写

     ​ 2）1：代表在当前位置读/写

     ​ 3）2：代表在末尾位置读/写

  3. 文件的复制与重命名

     文件复制即创建文件的副本，此项操作的本是仍然是文件的打开、关闭于读/写。基本逻辑如下：

     1. 打开文件；
     2. 读取文件内容；
     3. 创建新文件，将数据写入到新文件中；
     4. 关闭文件，保存数据；

  4. 文件重命名

     Python提供了用于更改文件名的函数——rename()，该函数存在于os模块中，其语法格式如下：

     rename(原文件名,新文件名)
     # 待重命名的文件必须已存在，否则解释器会报错
     

     对操作系统而言，文件和文件夹都是文件，因此rename()函数亦可用于文件的重命名；

• 目录操作

  1. 创建目录

     os模块中的mkdir()函数用于创建目录，其语法格式为：

     os.mkdir(path,mode)
     # 参数path表示要创建的目录，参数mode表示目录的数字权限，该参数在Windows系统下可忽略
     

  2. 删除目录

     使用Python内置模块shutil中的rmtree()函数可以删除目录，其语法格式如下：

     rmtree(path)
     # 参数path表示要删除的目录
     

  3. 获取目录的文件列表

  os模块中的listdir()函数用于获取文件夹下文件或文件夹名的列表，该列表以字母顺序排序，其语法格式如下：

  listdir(path)
  # path表示要获取的目录列表
  

• 文件路径的操作

  1. 相对路径与绝对路径：

     • isabs()函数

       当目标路径为绝对路径时，exists()函数会返回True，否则返回False，基本语法格式如下：

       os.path.isabs(path)
       

     • abspath()函数

       当前路径为相对路径时，使用abspath()函数可以将目标路径规范化为绝对路径，基本语法格式如下：

       os.path.abspath(path)
       

  2. 获取当前路径

     当前路径即文件、程序或目录当前所在的路径。os模块中的getcwd()函数用于获取当前路径，其基本语法格式如下:

     os.getcwd()
     

  3. 检查路径的有效性

     os模块中的exists()函数用于判断路径是否存在，如果存在返回True，否则返回False；

     os.path.exists(文件对象)
     

  4. 路径的拼接

     os.path模块中的join()函数用于拼接路径，其语法格式如下:

     os.path.join(path1[,path2[,…]])
     

     若最后一个路径为空，则生成的路径将以一个“\”结尾

     例：D:\Python项目\

第十章——错误与异常

• Python中的所有的异常类均由类实现，所有的异常类都继承子基类BaseException；

  类名	描述
  SyntaxError	发生语法错误时引发
  FileNotFoundError	未找到指定文件或目录时引发
  NameError	找不到指定名称的变量时引发
  ZeroDivisionError	除数为0时引发
  IndexError	当使用超出列表范围的索引时引发
  KeyError	当使用字典不存在键时引发
  AttributeError	当尝试访问未知对象属性时引发
  TypeError	当试图在使用a类型的场合使用b类型时引发

• 异常捕获

  1. try…except语句

     try…except语句用于捕获程序运行时的异常，其语法格式为：

     tyr:
         # 可能出现错误的代码
         ……
     except [异常类型]:
         # 错误处理语句
         ……
     

     try…except语句的执行过程如下：

     1. 先执行try子句，即try于except之间的代码；
     2. 若try子句中没有产生异常，则忽略except子句中的代码；
     3. 若try子句产生异常，则忽略try子句的剩余代码，执行except子句的代码；

  2. 捕获异常信息

     try…except语句可以捕获和处理程序运行时的单个异常、多个异常、所有异常，也可以在except子句中使用关键字as获取系统反馈的具体信息。

     • 捕获程序运行时的单个异常

       使用try…except语句捕获和处理单个异常时，需要except子句的后面指定具体的异常类。

       例：

       try:
       	for i int 2:
               print(i)
       except TypeError as e:
           print(f"异常原因：{e}")
        
       # 注意：如果知道指定的异常与程序产生的异常不一致，程序运行时仍会崩溃
       

     • 捕获程序运行时的多个异常

       一段代码可能会产生多个异常，此时可以将多个具体的异常类组成元组方法在except语句后处理，也可以联合使用多个except语句：

       例：

       # 单个except语句
       try:
           print(count)
           demo_list=["a","b","c","d"]
           print(demo_list[5])
       except (NameError,IndexError) as error:
           print(f"错误的原因：{error}")
           
       # 多个except语句
       try:
           print(count)
           demo_list=["a","b","c","d"]
           print(demo_list[5])
       except NameError as error:
           print(f"错误的原因：{error}")    
       except IndexError as error:
           print(f"错误的原因：{error}")    
       

     • 捕获程序运行是的所有异常

       在Python中，使用try…except语句捕获素有异常有两种方式：指定异常类为Exception类和省略异常类；

       1. 指定异常类为Exception类。在except子句的后面指定具体的异常类为Exception，由于Exception类时常见异常类的父类，一次它可以指代所有常见的异常类；

       2. 省略异常类。在except子句的后面省略异常类，表明处理所有捕获到的异常类。‘

          注意：虽然使用省略异常类的方式也能捕获所有常见的异常类，但这种方式不能获取异常的具体信息。

  3. else子句

     Python中try…except语句还可以于else子句联合使用，该子句放在except语句之后，当try字句没有出现错误时应执行else语句中的代码，基本语法格式如下：

     try:
         #可能出现错误的语句
         ……
     except:
          #出现错误后的执行语句
         ……
     else:
          #未出现错误的执行语句
         ……
     

  4. finally语句

     finally子句与try…except语句连用时，无论try…except是否捕获到异常，finally子句后的代码都要执行，其语法格式如下：

     try:
         #可能出现错误的语句
         ……
     except:
          #出现错误后的执行语句
         ……
     finally:
          #无论是否出错都会执行的代码
         ……
         
     

     Python在处理文件时，为避免打开的文件占用过多的系统资源，在完成对文件的操作后需要使用close()方法关闭文件。为了确保文件一定会关闭，可以将文件关闭操作放在finally子句中。

• 抛出异常

  Python程序中的异常不仅可以由系统抛出，还可以由开发人员使用关键字raise主动抛出。只要异常没有被处理，异常就会向上传递，直至最顶级也未处理，则会使用系统默认的方式处理（程序崩溃）。另外，程序开发阶段还可以使用assert语句检测一个表达式是否符合要求，不符合要求则抛出异常。

  1. raise语句

     raise语句用于引发特定的异常，其使用方式大致可分为3种；

     1. 由异常类名引发异常；
     2. 由异常对象引发异常；
     3. 由程序中出现过的异常引发异常

     • 使用类名引发异常

       在raise语句后添加具体的异常类，使用类名引发异常，语法格式如下：

       raise 异常类名
       # 当raise语句指定了异常的类名时，Python解释器会自动创建该异常类的对象。
       

       例：

       raise NameError
       

     • 使用异常对象引发异常

       raise 异常对象
       

       例：

       name_error=NameError()
       raise name_error
       

     • 由异常引发异常

       仅使用raise关键字可重新引发刚才发生的异常，其语法格式如下：

       raise
       

       例：

       try:
           num
       except NameError as e:
           
       

  2. 异常的传递

     如果程序中的异常没有被处理，默认情况下该异常传递给上一级，如果上一级仍然没有处理，会继续向上传递，直至亦常被吃力或程序崩溃；

  3. assert断言语句

     assert断言语句用于判定一个表达式是否为真，如果表达式为True，不做任何操作，否则引发AssertionError异常。

     assert断言语句格式如下：

     assert 表达式[,参数]
     # 以上格式中，表达式时assert语句的判定对象，参数通常是一个自定义得描述一场具体信息得字符串。
     

     assert断言语句多用于程序开发测试阶段，其主要目的是确保代码的正确性。如果开发人员能确保程序正确执行，那么不建议再使用assert语句抛出异常。

• 自定义异常类

  自定义异常类，只需要创建一个类，让它继承Exception类或其它异常类即可；

  例：

  class CustomError(Exception):
      pass 
  
  try:
      pass
  	raise CustomError("出现错误")
  except CustoError as error:
      print(error)
  

• with语句与上下文管理器

  使用finally子句虽然能处理关闭文件得操作，但这种方式过于繁琐，每次都需要编写调用close()方法的代码。因此，Python引入了with语句代替finally子句中调用close()方法释放资源的操作。with语句支持创建资源、抛出异常、释放资源等操作，并且可以简化代码。

  1. with语句

     with语句适用于对资源进行访问的场合，无论资源在使用过程中是否发生异常，都可以使用with语句保证执行释放资源操作。

     with语句得语法格式如下：

     with 上下文表达式 [as 资源对象]：
     	语句体
         
     # 资源对象可以是单个变量，也可以是元组。
     

     注意：不是所有对象都可以使用with语句，只有支持上下文管理协议的对象才可以使用，目前支持该协议的对象如下：file、decimal.Context、thread.LockType、threading.BoundedSemaphore、threading.Condition、threading.Lock、threading.Rlock、thread.Semaphore.

  2. 上下文管理器

     with语句之所以能够自动关闭资源，是因为它使用了一种名为上下文管理的技术管理资源。

     • 上下文管理协议（Context Manager Protocol）

       上下文管理协议包括__enter__()和__exit__()方法，支持该协议的对象均需要实现这连个方法。__enter__()和__exit__()方法的含义与用途如下：

       （1）__enter__(self)：进入上下文管理器时调用此方法，它的返回值被放入with…as语句的as说句名符指定的变量中。

       （2）__exit__(self,type,value,traceback)：离开上下文管理器时调用此方法。在__exit__()方法中，参数type、value、traceback的含义分别为异常的类型、异常值、异常回溯追踪。如果__exit__()方法内部引发异常，该异常会覆盖掉其执行体中的引发的异常。处理异常时不需要重新抛出异常，只需要返回False。

     • 上下文管理（Context Manager）

       支持上下文协议的对象就是上下文管理器，这种对象实现了__enter__()和__exit__()方法。通过with语句即可调用上下文管理，它负责建立运行时的上下文。

     • 上下文表达式（Context Expression）

       with语句中关键字with之后的表达式返回一个支持上下文管理协议的对象，也就是返回一个上下文管理。

     • 运行时上下文

       由上下文管理器创建，通过上下文管理器的__enter__()和__exit__()方法实现。__enter__()方法在语句体执行之前执行，__exit__()方法在语句体执行之后执行。

3. 自定义上下文管理器

   在开发中可以根据实际情况自定义上下文管理器，只需要让定义的类支持上下文管理协议，并实现__enter__()和__exit__()方法即可；

第十一章——正则表达式

• 元字符

  常用的元字符及其功能

元字符	说明
.	匹配任何一个字符（除换行符外）
^	脱字符，匹配行的开始
$	美元字符，匹配行的开始
|	连接多个可选元素，匹配表达中出现的任意子项
[]	字符组，匹配其中出现的任意一个字符
-	连字符，表示范围，如“1-5”等价于“1、2、3、4、5”
?	匹配其前导元素0次或1次
*	匹配其前导元素0次或多次
+	匹配其前导元素1次或多次
{n}/{m,n}	匹配其前导元素n次/匹配其前导元素m~n
()	在模式中划分出子模式，并保存字模式的匹配结果

第十二章——图形用户界面编程

第十三章——进程和线程

第十四章——网络编程

第十五章——数据库编程

第十六章——Django框架介绍