Python基础知识点【笔记】

• 多行注释：""" 注释内容 """
• 单行注释：# 注释内容

1. 变量的4个类型

   1. 字符串：str
   2. 布尔（真 or 假）：bool（0 代表 False，非零为True）
   3. 浮点型：float
   4. 整型：int

2. 标识符

   1. 第一个字符必须是字母或下划线
   2. 不能以数字开头
   3. 类名 一般用 大驼峰命名法：每个单词首字母大写（MyName）
   4. 变量名 一般用 小驼峰命名法：首个单词小写，之后每个首字母大写（myFirstName）

3. 关键字

   1. 随机数：random

      1. 获取随机数：import random
      2. 产生[a~b] 的随机数：random.randint（a,b）

   2. global

      1. 局部变量 变 全局变量：global 变量名

4. 输出

   1. 占位符

      1. 字符串：% s
      2. 整数：% d
      3. 小数：% f
   2. 5位数，0填充：% 05 d
   3. 2位小数，四舍五入：% . 2 f
   4. 插值表达式：f “ 正常写内容 { 变量 ：条件 } ”
   5. 换行：end = ' \n '
   6. 连在一起：end = ' '  或者 print ( )
   7. 制表符：end = ' \ t '

5. 运算符

   1. 算数

      1. //：取整除
      2. %：取余
      3. **：次幂

   2. 赋值：=（左边必是变量）

   3. 比较

      1. ==：等于
      2. !=：不等于

   4. 逻辑

      1. and
      2. or
      3. not
      4. 操作数字时（0为False，非0为True）
         1. and：有0则0，否则取最后一个（非0）值
         2. or：有（非0）则取第一个（非0）值，否则为0

            3 and 4    # 取4
            0 and 3    # 取0
            
            3 or 4    # 取3
            0 or 4    # 取4
            

   5. 三目表达式：变量名 = 值1 if 条件 else 值2

6. 数据类型转换：eval（）就是把引号去掉

7. 语法

   1. 判断

      if 条件:    # a < 0
          方法体
      elif 条件:    # a < 60  细节：默认 a > 0
          方法体
      else:        # a >= 60
          方法体
      

   2. 循环

      1. while（循环次数不固定）

         i = 0
         while i < 3:
             print('hello')    # 方法体
             i += 1
         

      2. for（循环次数固定）

         for 临时变量 in 容器类型:
             方法体

         1. range（起始值，结束值，步长）细节 [ 包左不包右 )
         2. range（5）= range（0，5，1）

      3. 循环中断

         1. break：退出循环
         2. continue：结束本次循环

      4. 有else 时

         1. break退出，则不执行else的内容
         2. 正常退出，则执行

      5. 死循环：while True

   3. 容器类型

      1. 字符串 str

         1. 转义符：\

            # 当你想输出 I'm Tom! ，如何让计算机区分该引号是字符串的内容
            s1 = ' I \'m Tom! '    # 这时就需要转义符

         2. 常用函数

            1. 字符串 . find（子串，起始索引，结束索引）
               1. 找子串第一次出现的位置，找不到返回 -1
            2. 字符串 . index（子串，起始索引，结束索引）
               1. 找子串第一次出现的位置，找不到 报错
            3. 字符串 . rfind （子串，起始索引，结束索引）
               1. 找子串最后一次出现的位置，找不到返回 -1
            4. 字符串 . rindex（子串，起始索引，结束索引）
               1. 找子串最后一次出现的位置，找不到 报错
            5. 字符串 . replace（旧串，新串，替换次数） 细节：原串不变
            6. 字符串 . split（切割符，切割次数）
               1. 返回列表
            7. 移除 字符串 两端的空格
               1. “字符串” . strip ( )
            8. len：看长度
            9. 变量名 . startsWith ( ) ：开头
            10. 变量名 . endswith ( ) ：结尾
            11. contains ( ) ：包含
            12. lower ：字符串变小写
            13. title ：首字母大写

      2. 列表（可变类型）

         1. 切片 ：列表名[ 起始：结束：步长 ]        # 包左不包右
         2. 格式 ：list = [10，20，30]

         3. 操作（CURD）

            1. 增
               1. 列表变量名 . append ( 任意1个元素)
               2. 列表变量名 . extend ( 任意1个可迭代的变量 )
               3. 列表变量名 . insert ( 索引，元素)
            2. 删
               1. del
                  1. del 列表名
                  2. del 列表名 [ 索引 ]
               2. pop
                  1. 列表名 . pop（索引）
                     1. 无索引默认删 最后一个
                     2. 返回被删除的元素
               3. remove
                  1. 列表名 . remove（元素值）        # 删第一个
               4. clear
                  1. 列表名 . clear（）
            3. 改
               1. 列表变量名 [ 索引 ] = 值
               2. 反转 ：列表名 . reverse ( )
               3. 排序
                  1. 列表名 . sort ( )
                     1. 默认升序
                  2. 列表名 . sort ( reverse = True)
                     1. 降序
            4. 查
               1. 列表变量名 . index ( 元素值，起始索引，结束索引 )
                  1. 查 第一次出现 的位置
               2. 出现次数：列表变量名 . count ( 元素值 )
               3. 判断元素是否存在：元素值 in 列表变量名
               4. 不存在：元素值 not in 列表变量名
         4. 列表的嵌套
            1. 列表名 [ 外索引 ] [ 内索引 ]

      3. 元组（不可变类型）

         1. 格式
            1. 只有一个值时：t1 = （ 10，）
            2. t2 = （10，20，30）
            3. t3 = tuple ( )
         2. 元组嵌套列表：列表中的值可变

         3. 操作

            1. 根据索引获取元组：元组名[ 索引 ]
            2. 查找元素第一次出现的位置：元组名.Index（）
            3. 次数：count（）

      4. 字典

         1. dict = { "name": "小林"，"age": 23 }        # 键值对

         2. 操作

            1. 查
               1. 根据 键 获取 值 ：字典名 . get（键，默认值）
                  1. 查不到 键 返回 默认值，没有默认值 返回None
               2. 所有 键：字典名 . keys（）
               3. 所有 值：字典名 . values（）
               4. items（）
            2. 增 / 改：字典名 [ 键 ] = 值
            3. 删：del 字典名 [ 键 ]

      5. 集合

         1. set = {10，20，30}
         2. 用来去重（但顺序会变）

      6. 公共运算符

         1. + ：合并
         2. * ：复制
         3. in
         4. not in

      7. 公共方法

         1. len()
         2. del
         3. max()
         4. min()
         5. range(start, end, step)
         6. enumerate()：将可迭代的数据对象，组成1个索引序列

   4. 推导式

      1. 列表：变量名= [ 表达式 for 变量 in 列表 if 判断条件 ]
      2. 集合：变量名= { 表达式 for 变量 in 列表 if 判断条件 }

   5. 索引

      变量名 [ 索引 ]
      1. 逆向索引：-3，-2，-1
      2. 正向索引： 0， 1， 2，3