Lazy loaded image
📘Python学习
字数 6555阅读时长 17 分钟
2024-10-22
2026-9-15
😀
一个简单的开头,潜学一下,让我能看懂python

一、Python基础语法

在python中,变量是没有类型的,变量存储的数据是有类型的
可以把变量当做一个存放物品的盒子

一、字面量

字面量:在代码中,被写下来固定的值

python中常见的值的类型

notion image

二、注释

三、变量

变量:在程序运行时,能储存计算结果 或 能表示值的抽象概念简单的说,
变量就是在程序运行时,记录数据用的
  1. print
      • 可以通过 , 输出多个变量
  1. type()
      • 返回 变量类型
  1. 数据类型转换
      • str()
      • float()
      • int()
      • 任何内容都可以转换为字符串
      • 字符串要转换为int或float类型,需要确保字符串中的内容只有数字

四、标识符

  1. 标识符命名:只能出现 英文中文数字下划线
      • 不推荐使用中文
      • 数字不能作为开头
  1. 标识符大小写敏感
  1. 不可占用关键字
    1. notion image

五、运算符

  1. 算数运算符
    1. notion image
  1. 赋值运算符
    1. =
  1. 复合赋值运算符
    1. notion image

六、字符串扩展

1. 字符串的定义

在Python中支持三种字符串的定义
  1. 单引号定义法: name = ‘你好’
  1. 双引号定义法: name = “”你好””
  1. 三引号定义法: name = “””你好”””
      • 三引号定义法,和多行注释的写法一样,同样支持换行操作.
      • 使用变量接收它,它就是字符串
      • 不使用变量接收它,就可以作为多行注释使用,
  1. 要定义的字符串本身,是包含:单引号、双引号自身
      • 单引号定义法,可以内含双引号
      • 双引号定义法,可以内含单引号
      • 可以使用转移字符()来将引号解除效用,变成普通字符串

2. 字符串的拼接

使用 +
但无法和非字符串类型拼接

3. 字符串格式化

  1. 占位型拼接
    1. 多个变量占位
      变量要用括号括起来
      并按照占位的顺序填入
      % 为占位符
      s 将变量变为字符串类型,放入占位的地方
  1. 通过语法:f"内容{变量}"的格式来快速格式化
      • 不关心精度问题,适合对精度没有要求的场合
      • 不会理会类型

4. 字符串格式化的精度控制

我们可以使用辅助符号"m.n"来控制数据的宽度和精度
  • m,控制宽度,要求是数字(很少使用),设置的宽度小于数字自身,不生效
  • .n,控制小数点精度,要求是数字,会进行小数的四舍五入
示例:
  • %5d: 表示将整数的宽度控制在5位,如数字1,被设置为5d,就会变成:[空格][空格][空格]111,用三个空格补足宽度。
  • %5.2f:表示将宽度控制为5,将小数点精度设置为2
    • 小数点和小数部分也算入宽度计算。如,对11.345设置了%7.2f后,结果是:[空格][空格]11.35。2个空格补足宽度,小数部分限制2位精度后,四舍五入为.35

5.表达式的格式化

以上四条都是对变量的格式化
下面是对表达式的格式化

七、数据输入

input()
input输入的数据,统统为字符串类型

八、布尔类型和比较运算符

  1. 布尔类型
      • xxx = True
      • xxx = Flase
  1. 比较运算符 返回值为布尔类型
      • ==
      • !=
        • <
            =
        • <=

    九、if语句

    基本格式

    height = int(input("请输入你的身高(cm):"))
    vip_level = int(input("请输入你的 VIP 等级(1-5):"))
    today_date = int(input("请告诉我今天几号:"))
    if height < 120:
    print("身高小于 120cm,可以免费。")
    elif vip_level > 3:
    print("vip 级别大于 3,可以免费。")
    elif today_date == 1:
    print("今天是 1 号免费日,可以免费")
    else:
    print("不好意思,条件都不满足,需要买票 10 元。")
    while 条件:
    条件满足时,做的事情1
    条件满足时,做的事情2
    条件满足时,做的事情3
    ···(省略)..
    for 临时变量i 待处理数据集:
    循环满足条件时执行的代码
    import random
    num = random.randint(1, 10)
    name = “liu”
    length = len(name)
    print(length)
    3
    def 函数名 (传入的参数1,传入的参数n):
    """
    函数说明
    :param x: 形参x说明
    :param y: 形参y说明
    :return: 返回值的说明
    """
    函数体
    return 返回值

    字面量

    [元素1,元素2,元素3,元素4 ……]

    定义变量

    变量名称 = [[元素1,元素2,元素3,元素4 ……]

    定义空列表

    变量名称 = []
    变量名称 = list()
    名称名称 = [ [元素1,元素2,元素3],[ 元素1,元素2,元素3] ]
    name_list = ['1','2','3']
    print(name_list[0]) >'1'
    print(name_list[1]) >'2'
    print(name_list[2]) >'3'
    print(name_list[-1]) >'3'
    print(name_list[-2]) >'2'
    print(name_list[-3]) >'1'
    class Student:
    def add(x, y)
    return x + y
    studen = Studen() #创建实例
    num = studen.add(1, 2)
    • 查找指定元素在列表的下标。如果找不到,报错ValueError!
    • 语法:列表.index(元素)
    1. 对某下标的元素重新赋值
        • 语法:列表[] = xxx
    1. 插入元素
        • 在指定的下标位置,插入指定的元素,后面的元素往后排
        • 语法:列表.insert(下标, xxx)
    1. 追加元素(1)
        • 将指定元素,追加到列表尾部
        • 语法:列表.append(元素)
    1. 追加元素(2)
        • 将其他容器的内容取出,依次 追加到列表尾部
        • 语法:列表.extend(其他数据容器)3
    1. 删除元素
        • 语法1: 列表.pop(下标)
        • 语法2:del 列表[下标]
    1. 删除元素
        • 删除某元素在列表中的第一个匹配项
        • 语法:列表.remove(元素)
    1. 清空列表
        • 语法:列表.clear(列表)
    1. 统计元素在列表中的数量
        • 语法:列表.count(元素)
    1. 统计元素的数量
        • 语法:len(列表)

    6. 列表的循环遍历

    遍历:把容器内的数据依次取出,并处理。又叫迭代
    while循环和for循环,都是循环语句,但细节不同:
    在循环控制上:
    • while循环可以自定循环条件,并自行控制
    • for循环不可以自定循环条件,只可以一个个从容器内取出数据
    在无限循环上:
    • while循环可以通过条件控制做到无限循环
    • for循环理论上不可以,因为被遍历的容器容量不是无限的
    在使用场景上:
    • while循环适用于任何想要循环的场景
    • for循环适用于,遍历数据容器的场景或简单的固定次数循环场景
     

    四、元组

    1. 介绍

    元组和列表的最大不同!
    元组一旦定义完成,就不可修改

    2.元组的定义

    元组定义: 定义元组使用小括号,且使用逗号隔开各个数据,数据可以是不同的数据类型。
    定义的注意事项:
    • 定义1个元素的元组必须带有逗号,否则不是元组类型

      3. 元组的常用操作方法

      1. index()
          • 查找某个数据,如果数据存在返回对应的下标,否则报错
          • 语法:元组.index(查找的元素)
          • 返回查找的元素的下标
      1. count()
          • 统计某个数据在当前元组出现的次数
          • 语法:元组.count(要统计的元素)
          • 返回这个元素的个数
      1. len(元组)
          • 统计元组内的元素个数
          • 语法:len(元组)
          • 返回元素个数
       

      4. 元组特点

      • 可以容纳多个数据
      • 可以容纳不同类型的数据(混装)
      • 数据是有序存储的(下标索引)
      • 允许重复数据存在
      • 不可以修改(增加或删除元素等)
      • 支持for循环
      • 元素中如果有列表,可以修改元组的元素中的列表的内部元素

      五、字符串

      1. 介绍

      字符串时字符的容器,一个字符串可以存放任意数量的字符
      • 和其他容器一样,字符串也是支持下标的
      • 字符串不可以 修改 移出 或者追加
      • 字符串可以 查找、和替换

      2. 字符串的常用操作方法

      1. 字符串的替换
          • 语法:字符串.replace(字符串1,字符串2)
          • 功能:将字符串内的全部:字符串1替换为字符串2
          • 注意:是局部替换,但是要注意,这个返回值是一个新的字符串,不是在老字符串上进行修改
      1. 字符串的分割
          • 语法:字符串.split(分隔符字符串)
          • 功能:按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表对象中
          • 注意:字符串本身不变,而是得到了一个列表对象
          • 示例:
        1. 字符串的规整操作
          1. 去除前后空格
              • 语法:字符串.strip()
              • 示例:
            1. 去除前后指定字符串
                • 语法:字符串.strip(字符串)
                • 注意:传入“12”,的意思是,‘’1‘和‘’2’‘都会移出,是按照单个字符
                • 示例:
            1. 统计字符串中某个字符出现的次数
                • 统计某个数据在当前元组出现的次数
                • 语法:字符串.count(要统计的元素)
                • 返回这个元素的个数
            1. 统计字符串的长度
                • 统计元组内的元素个数
                • 语法:len(字符串)
                • 返回元素个数

            3. 字符串的特点

            • 只可以存储字符串
            • 长度任意(取决于内存大小)
            • 支持下标索引
            • 允许重复字符串存在
            • 不可以修改(增加或删除元素等)
            • 支持for循环

            六、数据容器(序列)的切片操作

            1. 什么是序列

            • 序列是指:内容连续、有序,可使用下标索引的一类数据容器
            • 列表、元组、字符串,均可以可以视为序列

            2. 序列的常用操作

            序列支持切片,即:列表、元组、字符串,均支持进行切片操作
            切片:从一个序列中,取出一个子序列
            语法:序列[起始下标:结束下标:步长]
            表示从序列中,从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列:
            • 起始下标表示从何处开始,可以留空,留空视作从头开始
            • 结束下标(不含)表示何处结束,可以留空,留空视作截取到结尾
            • 步长表示,依次取元素的间隔
              • 步长1表示,一个个取元素
              • 步长2表示,每次跳过1个元素取
              • 步长N表示,每次跳过N-1个元素取
              • 步长为负数表示,反向取 (注意,起始下标和结束下标也要反向标记)
            切片不会影响序列本身,而是得到一个新的序列
            起始和结束的下标也能不写,默认为从头到尾。步长也可以不写,默认为1
            范围为 左闭右开
            可以这样用my_str[::-1][9:14]

            七、集合

            1. 集合的介绍:

            • 集合 set
            • 集合会去重,不能重复
            • 集合内容是无序的(所以不支持下标索引访问)

            2. 集合的定义

            集合 set

            3. 集合的一些方法

            1. 添加新元素
                • 语法:集合.add(元素)
            1. 移出元素
                • 语法:集合.remove(元素)
            1. 随机取出一个元素
                • 语法:集合.pop()
                • 注意:真 取出来了,原本的集合没了
              1. 清空集合
                  • 语法:集合.clear()
              2. 取出2个集合的差集
                  • 语法:集合1.difference(集合2)
                  • 功能:取出集合1和集合2的差集.,集合1有 而 集合2没有的
                  • 结果:得到一个新集合,集合1和集合2不变
              3. 消除2个集合的差集
                  • 语法:集合1.difference_update(集合2)
                  • 功能:对比集合1和集合2,在集合1内,删除和集合2相同的元素。
                  • 结果:集合1被修改,集合2不变
              4. 2个集合合并
                  • 语法:集合1.unior(集合2)
                  • 功能:将集合1和集合2组合成新集合
                  • 结果:得到新集合,集合1和集合2不变
              5. 统计集合元素的数量
                  • 语法:len(集合)
              6. 集合的遍历
                  • 集合不支持下标索引,所以不支持 while循环
                  • 集合支持for循环

            4. 集合的特点

            • 可以容纳多个数据
            • 可以容纳不同类型的数据(混装)
            • 数据是无序存储的(不支持下标索引)
            • 不允许重复数据存在
            • 可以修改(增加或删除元素等)
            • 支持for循环

            八、字典

            通过字典,可以实现用key 取出 value的操作

            1. 字典的定义

            字典中存储的元素 叫 : 键值对
            • 字典不允许重复,新的会把老的覆盖掉
            • 字典不允许下标索引
            • 字典的key不允许为字典,value 不受限制,可以嵌套字典

            2. 字典的常用操作

            1. 新增元素
                • 语法:字典[Key] = Value
                • 结果:字典被修改,新增了元素
            1. 更新元素
                • 语法:字典[Key] = Value
                • 结果:字典被修改,元素被更新
                • 注意:字典key不可以重复,如果key已经有了,再执行就是更新元素
            1. 删除元素
                • 语法:字典.pop(key)
                • 结果:获得指定key的value,同时字典被修改,指定key的数据被删除
            1. 清空元素
                • 语法:字典.clear()
            1. 获取全部的Key
                • 语法:字典.keys()
            1. 统计字典内的元素数量
                • 语法:len(字典)
            1. 遍历字典
                • 通过获取全部的key来遍历字典
                  • 直接对字典进行for循环,每次循环都是直接得到key

                3.字典的特点

                • 可以容纳多个数据
                • 可以容纳不同类型的数据
                • 每一份数据是KeyValue键值对
                • 可以通过Key获取到Value,Ktv不可重复(重复会覆盖)
                • 不支持下标索引
                • 可以修改(增加或删除更新元素等)
                • 支持for循环,
                • 不支持while循环

                九、五种容器总结

                1. 容器的分类

                分类
                元组
                集合
                字典
                字符串
                列表
                元素数量
                支持多个
                支持多个
                支持多个
                支持多个
                支持多个
                元素类型
                任意
                任意
                Key: Value Key: 除字典外任意类型 Value: 任意类型
                仅字符
                任意
                下标索引
                支持
                不支持
                不支持
                支持
                支持
                重复元素
                支持
                不支持
                不支持
                支持
                支持
                可修改性
                不支持
                支持
                支持
                不支持
                支持
                数据有序
                使用场景
                不可修改、可重复的一批数据记录场景
                不可重复的数据记录场景
                以 Key 检索 Value 的数据记录场景
                一串字符的记录场景
                可修改、可重复的一批数据记录场景
                • 五类容器都支持for循环
                • 集合和字典不支持while循环

                2. 容器的通用操作

                通用统计功能
                1. len(容器)
                    • 统计元素个数
                1. max(容器)
                    • 统计容器的最大元素
                1. min(容器)
                    • 统计容器的最小元素
                通用转换功能
                • 注意字典在转换为非字符串的时候,会丢失value
                1. list(容器)
                    • 将给定容器转换为列表
                1. str(容器)
                    • 将给定容器转换为字符串
                1. tuple(容器)
                    • 将给定容器转换为元组
                1. set(容器)
                    • 将给定容器转换为集合
                通用排序功能
                1. sorted(容器,[reverse=True])
                    • 将给定容器进行排序
                    • 注意:会放到列表中,字典在排序的时候会丢失value
                💡
                欢迎您在底部评论区留言,一起交流~
                上一篇
                CubeMX的RT-Thread配置笔记
                下一篇
                嘉立创梁山派GD32F470ZGT6+CUbeMX配置工程模板

                评论
                Loading...