第一章——开启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()函数创建
       

       1. 布尔类型

          • 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 itcastMy 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 = '''Helloworld'''
  # 用三引号定义的字符串可以实现多行定义并且按原格式多行输出
  

• 字符串的索引于切片

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

  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_oneprint(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:@classmethoddef use_classmet(cls):print('我是类方法')test=Test()
    # 类名或对象名均可调用类方法
    test.use_classmet()
    Test.use_classmet()
    

  • 修改类属性

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

    例：

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

• 静态方法

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

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

  例：

  class Example:num=10@staticmethoddef 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)
       

     1. 多继承

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

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

     2. 方法的重写

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

        例：

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

     3. 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()
        

     4. 多态

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

        例：

        class Animal(object):def move(self):passclass 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/belse :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:passraise 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__()方法在语句体执行之后执行。

1. 自定义上下文管理器

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

第十一章——正则表达式

• 元字符

  常用的元字符及其功能

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

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

第十三章——进程和线程

第十四章——网络编程

第十五章——数据库编程

第十六章——Django框架介绍

Python（1-10章）知识点相关推荐

1. 小牛叔讲Python第10章:化繁为简的推导式

   上一篇:小牛叔讲Python第9章:函数是你走过的套路 下一篇:小牛叔讲Python第11章:函数的高级用法以及匿名函数 目录 前言 1.推导式的形式 2.生成器 - () 3.推导式与交互使用 4. ...

2. 冈萨雷斯DIP第10章知识点

   文章目录 10.2 点.线和边缘检测 10.2.2 孤立点的检测 10.2.3 线检测 10.2.4 边缘模型 10.3 阈值处理 10.3.4 使用图像平滑改进全局阈值处理 10.3.5 使用边缘改 ...

3. Android高级终端开发学习笔记（《疯狂Android讲义》第2章-第10章）

   Android疯狂讲义前10章知识点总结 /-------------------------10-31号晚上学习笔记----------------------------/ 在设置了最小支持版本为 ...

4. 《Python游戏趣味编程》 第10章 拼图游戏

   10 拼图游戏 图书简介可以看这里: 童晶:<Python游戏趣味编程>新书上架了 本章我们将编写一个拼图游戏,鼠标先后点击两个小拼图块,交换其坐标,直到全部达到正确位置,效果如图10-1 ...

5. python为啥这么受欢迎_Python为什么这么受欢迎？原因竟在于它的10个知识点

   Python被誉为全世界高效的编程语言,同时也被称作是"胶水语言".Python 是一个高层次的结合了解释性.编译性.互动性和面向对象的脚本语言.设计具有很强的可读性,相比其他语言 ...

6. 【信息系统项目管理师】第10章 下篇-项目干系人管理 知识点详细整理

   个人资料,仅供学习使用 教程:信息系统项目管理师(第3版) 修改时间--2021年10月4日 09:19:27 参考资料: 信息系统项目管理师(第3版) 题目书(2021下半年)--马军 本文包括: ...

7. 【信息系统项目管理师】第10章 上篇-项目沟通管理 知识点详细整理

   个人资料,仅供学习使用 教程:信息系统项目管理师(第3版) 修改时间--2021年10月3日 18:43:45 参考资料: 信息系统项目管理师(第3版) 题目书(2021下半年)--马军 本文包括: ...

8. 《Python自然语言处理（第二版）-Steven Bird等》学习笔记：第10章 分析句子的意思

   第10章 分析句子的意思 10.1 自然语言理解 查询数据库 自然语言.语义和逻辑 10.2 命题逻辑 10.3 一阶逻辑 一阶定理证明 一阶逻辑语言总结 真值模型 独立变量和赋值 量化 量词范围歧义 ...

9. python入门学习笔记——详细基础知识篇（第10章 正则表达式（重点）与JSON）

   第10章 正则表达式(重点)与JSON 初识正则表达式 元字符与普通字符 字符集 概括字符集 数量词 贪婪与非贪婪 匹配0次1次或者无限多次 边界匹配符(^ .$) 组 匹配模式参数 re.sub正则 ...

10. 第10章 数据库恢复技术 | 数据库知识点整理

    第10章 数据库恢复技术 了解 数据库的一致性状态 数据库运行中可能产生的故障类型,它们如何影响事务的正常执行,如何破坏数据库数据 数据转储的概念及分类 数据库的镜像功能 掌握 事务的基本概念和事务的 ...

最新文章

1. Msql sql（优化三）
2. android 5.0新增 ui 控件,android3.0新增ui控件示例说明.doc
3. Hello, Android 快速入门
4. 二进制（1)：无符号编码和补码编码
5. python 顺序表
6. 运筹优化（三）--线性规划之单纯形法
7. VS2015 设置项目依赖项
8. 新装主机测试性能软件,装机必看 如何快速测试电脑性能?
9. BaseTestCase system 1.0 体验版
10. Linux网卡驱动(4)—DM9000网卡驱动程序完全分析
11. 人脸识别眨眼张嘴软件_手机端APP活体真活人检测扫描人脸识别SDK之张嘴摇头眨眼点头确认真人非...
12. 分号（；）和逗号（，）的用法
13. matlab的from模块_Matlab中SIMULINK的模块库以及比较常用的模块
14. 微信小程序开发（十五）小程序使用scrollview实现滚动导航栏
15. 解决java中使用getImage（）导入图片失败问题
16. 首页布局跟小程序如何配置Iconfont—小程序入门与实战（七）
17. 企业物流营销组合模式探讨 (zt)
18. 苏宁java二面,苏宁二面面试
19. ols最小二乘法是什么|OLS最小二乘法是如何推导的
20. Python男友日记 | 获取TaoBao上4000+条的口红数据，我发现了…

热门文章

1. 内核文件管理-IRP(一)创建或打开文件
2. 服装行业要渡“疫情劫”，赢家时尚凭什么成为增长样本？
3. 用Python把B站视频弹幕爬下来，绘制词云图看看大家最关心什么！
4. maven中遇到的问题，报错
5. 高级PHP工程师必备的编码技巧及思维（收藏）
6. 王姨劝我学HarmonyOS鸿蒙2.0系列教程之二应用知识梳理逻辑！
7. HBuilderX代码提示失效解决方案
8. Android热更新，Android面试题整理
9. 微信公众号如何嵌入照片征集视频征集小程序
10. 仿文献高级检索多关键词查询的网页实现