python基础内容

欢迎观看，欢迎指正，共同学习

注释

 单行注释，快捷键:ctrl + /
 注释是对代码的解释说明，解析器不会执行，所以不会输出到控制台
​
"""
多行注释
第一行
第二行
"""
'''
多行注释
'''

变量

变量:
    变量定义格式：变量名 = 值
    变量名的规则
        1.可以有数字，字母，下划线
        2.不能以数字开头，但是可以结尾
        3.严格区分大小写
        4.不能使用内置的关键字来定义
    变量名/标识符的命名规范:
        1.大驼峰:所有单词首字母全部大写，其余小写
            常用于：类名
        2.小驼峰:第一个单词首字母小写，其他单词首字母大写，其他的字母全部小写
            常用于：变量名，函数名
        3.蛇皮走位:多个单词之间使用下划线来分隔
            常用于：变量名，函数名
注意：
    1.变量一定要先定义，再使用
    2.变量永远是等号右侧赋值给等号左侧

数据类型

常用的数据类型
    1.数值类型
        整数:int
        浮点数:float
    2.布尔类型
        值有:
            1.True
            2.False
    3.字符串

输入输出

格式化输出
    方式1：%格式，占位符
    方式2：使用format格式化
​
字符串接收一切基本类型
%s:字符串
%d:整数
%f:浮点数
字符串不能和数字进行运算
注意：所有input函数的返回值都是字符串类型
ctrl + d 快速向下复制一行

格式化转换

int(x):将x转换成整数类型
float(x):将x转换成浮点数类型
str(x):将x转换成字符串类型
eval(x):去掉x最外围的引号，将引号去掉，展示最原始的内容的类型
将浮点数转换成整数   
注意:
    1、如果是浮点数转换成整数，会有精度损失
    2、浮点类型的字符串不能转换成整数类型，会报错

运算符

算数运算符

+
-
*
/
//:整除    10 // 3  = 3
%:取余/取模  10 % 3 = 1
**:幂指数，2**3 = 8
():优先计算

复合赋值运算符

+=
-=
*=
/=
//=:整除
%=:取余/取模
**=:幂指数，

比较运算符

==
!=
>
<
>= ： 大于 或者 等于
<= ：大于 或者 等于
所有的比较运算符返回结果:
    1.True  真
    2.False  假

逻辑运算符

and：和，并且
or: 或，或者
not：非，取反
​
and:必须全部条件成立，才成立
or:只要有一个条件成立，就成立
not:成立代表不成立，不成立代表成立
​
批量编辑:shift + alt + 鼠标选中
ctrl + r

循环语句

if判断结构

if判断结构
    1.单分支结构
        只有if
        有if .... else的
    2.多分支结构
格式:
    1.1只有if
        if 条件:
            条件成立执行的语句
    1.2 有 if ... else
        if 条件:
            条件成立执行的语句
        else:
            条件不成立执行的语句
    2.多分支
        if 条件1:
            条件1成立时执行的语句
        elif 条件2:
            条件2成立时执行的语句
        ...
        else....

while循环

1.顺序结构：从上到下，从左到右依次检验，执行1次
2.分支结构：从上到下，遇到条件成立，就进去，执行1次
3.循环结构：执行n次
​
    while循环:一眼望过去，猜不到结果，你不知道要循环多少次
        折纸:一张无穷大的纸，对折几次，可以比珠穆朗玛峰高
    for循环：你知道要循环多少次
        从100个数里面，找到所有的偶数
while循环结构
    变量1
    while 条件2:
        循环体3
        控制条件4
死循环一定要注意，很容易造成服务器内存溢出
断点:当程序执行到断点位置时，听程序员的号令
F7:一行一行执行，你系统底层是怎么执行的，就怎么执行
F8：进入到方法体中(自定义方法)，暂时可以理解为和F7效果一毛一样
F9:从一个断点直接到下一个断点

break和continue

break：直接退出当前循环
continue：结束当前循环，继续下次循环
如果循环有嵌套:外层循环执行1，内存循环执行n次

for循环

for循环
    结构:
    序列：可以理解为 容器
        容器：
            字符串，列表(list),元组(tuple),集合(set),字典(dict)
        for 变量名 in 序列:
            循环体
python for循环有没有死循环
    没有死循环
java for循环有
range(起始值,结束值,步长)
    起始值:从几开始
    结束值:到几结束 （不包含结束值）
    步长:从开始值 + 步长是下一个值
    注意:如果步长不写，默认是1，如果起始值不写，默认从0开始

for...else 结构

    for i in 容器:
        循环体
    else:
        循环正常结束后执行的内容
注意：
    如果你的循环是非正常结束(break结束的是非正常结束)，那么不会打印else的内容，只有正常结束的会打印else

字符串的定义

    格式:
        1.单引号包裹：'内容'
        2.双引号包裹： "内容"
        3.三引号包裹：三引号  内容  三引号   特点：可以原样输出你写的内容
​
\ :代表转移符号，告诉解释器，你转义后的内容要直接输出
​
外单内双，内双外单

字符串切片：

   字符串的整数索引是从0开始，倒数索引是从-1开始
    字符串
    整数:      0   1   2   3   4   5
    字符串     a   b   c   d   e   f
    倒数：     -6  -5  -4  -3  -2 -1
切片的格式:
    字符串变量名[开始索引:结束索引:步长]
               [::负值]  -------->负几就是删除最后几位
                    例如:str1=[1,2,3,4]
                         str1=str1[:-1]
                         print(str1)
​
      1. 开始索引默认从0开始，结束索引默认是到索引的最后一个值，步长，默认是1
         束索引是不包含的，开始索引是包含的

字符串的函数

字符串可以理解为是一个常量，值不能修改，只能重新赋值
内置函数:系统已经帮你定义好的，可以直接重复使用的一段代码块
函数调用:
    变量名.函数名称(参数 ...)
        注意：有的函数是有返回值的，变量名 =  变量名.函数名称(参数 ...)
    查找函数:
        find() --- 查找,有没有返回内容，有返回内容的，
            find("子串")：查找子串，返回第一个遇到的子串的第一个字母的索引
                如果没有找到子串，返回 -1
        index() --- 索引，有没有返回内容，有返回内容
            index("子串")：查找子串，返回第一个遇到的子串的第一个字母的索引
                如果没有找到，直接报错
    其他函数:
        replace() --- 替换
            str1.repalce(你要替换谁，你要替换成什么)
        split() --- 将字符串按照指定内容进行切割，得到的是一个 list
            list1 = str1.split(要按照什么内容切割)
        join() --- 将字符串按照指定内容进行拼接
            str1.join(要拼接的内容)"""

容器

能存储多个元素的python数据类型
list-->列表
set-->集合
dict-->字典
tuple-->元组

字符串

str 引号，不可变

list列表

注意：在java中使用中括号包裹的，称之为  数组 array
​
•    定义格式:
•    list1 = [值1,值2,.....]
•    list2 = []
•    list3 = list()
list特点:
•    1.可以存储任一类型的数据，建议同一类型
•    2.数据可以重复
•    3.有序 ---> 不是内容有序，而是 存取有序(第一个存的，第一个取)
•    4.list中的值可以修改
list获取值
•    1.有索引，索引从0开始
•        list变量名[索引]

list增加数据

    append():向列表中追加内容，追加到末尾，如果追加列表，是将整个列表看成一个内容追加到末尾，它可以追加任意数据
    extend():向列表中追加内容，追加到末尾，如果追加列表，会将列表中的内容，按顺序追加到原列表的末尾，它只能追加可迭代(变量)的内容
    insert():向列表的指定索引的前面插入数据，如果追加列表，是将整个列表看成一个内容追加到末尾

list删除

del:删除指定索引的内容 del 列表名[索引] 或者是 删除 列表 del 列表名
pop():
    删除的内容变量名 = list变量.pop(索引)--- 移除指定索引内容，并返回删除的内容
    删除最后一个元素 = list变量.pop() -- 将列表的最后一个内容移除，并返回移除的内容
remove(元素1):将列表中的遇到的第一个元素1 删除,没有返回值
​
如果要删除的元素不存在，则报错

list查询

list的查询方法
    index(内容):查看内容在列表的索引
        如果不存在，就报错，如果存在就返回对应元素在列表的索引值(索引从0开始)
    count(内容):查看内容在列表的数量
        如果存在，返回个数，如果不存在，返回0
        如果没有返回-1
    in:查看内容是否在列表中，如果有返回TRUE
    not in:查看内容是否不在列表中

list修改

list的修改操作
    列表名称[索引] = 新值
    reverse():将元素内容反转输出
    sort():排序，默认是从小到大，sort（reverse = TUre）,排序从大到小

list列表的循环遍历

循环遍历
    遍历/迭代:一个一个的拿出来
while和for循环

二维列表

​# 示例 1：创建二维列表（类似表格或矩阵）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 访问元素（行索引 → 列索引）
print(matrix[0][1])  # 输出：2（第0行第1列）
print(matrix[2][2])  # 输出：9（第2行第2列）

# 示例 2：动态创建二维列表（列表推导式）
chessboard = [[(i+j) % 2 for i in range(8)] for j in range(8)]
# 生成国际象棋棋盘（0=黑格，1=白格）

# 示例 3：学生成绩表（混合数据类型）
students = [
    ["姓名", "数学", "语文", "英语"],
    ["张三", 90, 85, 92],
    ["李四", 78, 88, 95],
    ["王五", 85, 90, 87]
]

# 遍历二维列表
print("\n学生成绩表：")
for row in students:
    for item in row:
        print(f"{str(item):<6}", end="")  # 对齐输出
    print()

# 修改元素
matrix[1][2] = 66  # 将第二行第三列改为66

# 添加新行
matrix.append([10, 11, 12])

# 输出结果
print("\n修改后的矩阵：")
for row in matrix:
    print(row)
"""

tuple元组

    1.tuple = (1,2,3,4,5)
    2.tuple = tuple()
    3.tuple = ()
    4.tuple = (1,)
元组的特点
    1.不可以修改元组的元素值
    2.有索引，索引从0开始
    3.可以存储任一类型数据，建议同一类型
    4.有序，存取有序
    5.可以存储重复元素
内置函数
    index():
        查看指定元素在元组中出现第一次的时候的，第一个字符的索引，如果不存在，就会报错
    count():
        查看指定元素在元组中有几个，如果不存在，返回0
    len():返回元组的个数
        in:查看内容是否在列表中，如果有返回TRUE
    not in:查看内容是否不在列表中
    删除：del tuple名

dict字典

    字典的定义:
        1.dict1 = {}
        2.dict2 = dict()
        3.dict3 = {"键1":"值1","键2":"值2","键3":"值3",.....}
字典特点:
    1.键值对形式存在，键是唯一的，值不唯一
    2.元素值可以进行修改
    3.无索引
    4.有序
字典的
    增/改
        字典名[key] = 值；
            注意：如果键存在，那么就是修改值操作，如果不存在，就是新增
    删
        del 字典名[key] 
        del 字典名  删除字典
        clear() 清空字典
    查
        keys():获取所有的键,返回值是一个理解是一个列表
            键获取到后，是不是可以根据键获取值  print(字典名[key])
        vaules():获取所有的值，返回值是一个理解是一个列表
        items():获取所有的键值对，ps:键值对是一个整体，返回值是一个元组类型
        字典名[]        根据键获取值
        字典名.get(键)  根据键获取值

dict嵌套list表

dict1 = {'人工智能':['张三','李四','王五'],
         '大数据':['喜羊羊','美羊羊','村长'],
         'Java':['熊大','熊二','光头强']}

set集合

    定义格式：
        1.set2 = {1,2,3,4}
        2.set3 = set()
        set1 = {}  ---> 它是字典类型
特点：
    1.没有重复值，会进行自动去重
    2.无序，存取无序(注意打印或者是遍历都可以实现无序效果)
    注意：java中set无序的，存取无序，但是第一次后，就固定了， 也就是每次取都是一样的
    3.内容可以修改
    4.没有索引，只能通过for循环进行元素获取
    5.可以存储不同类型
方法：
    增
        add():效果等同于 append函数
    删
        del:可以删除整个集合
        remove(元素):删除指定元素,如果没有，报错
    查
        in:查看元素是否在集合中，如果在，返回True，如果不在返回False
        not in:查看元素是否在集合中，如果在，返回False，如果不在返回True

容器类型转换

1、转换类型函数
    int()
    float()
    str()
    bppl()
    eval()  去掉引号，查看类型
2、容器类型转换函数
    list(内容) 将内容转换成列表                                   （可变类型）
    set(内容) 将内容转换成集合 # 无序，去重，需求，对列表元素进行去重操作，并最终形成一个列表（可变类型）
    dict(内容) 将内容转换成字典                                   （可变类型）
    
    tuple(内容) 将内容转换成元组 ---特殊（不能修改，转换为就为死数据）
    1、将集合转换成列表
    list()
    2、将字典转换成列表
    如果是将字典转换成列表，那么列表中存储的是字典的键
    
    3、将列表元素内容进行去重，并返回列表
    
    4、将集合转换成字典,无意义
    
    5、将列转换成元组类型

推导式

格式：
        变量名 = [表达式 for 变量 in 列表]
        变量名 = [表达式 for 变量 in 列表 if 条件]
        变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]
    列表的推导式
        列表名称 = [变量名 for 变量名 in 容器 [if 条件判断]]
        list = [i for i  in range (1,10) if i % 2 == 0]
    集合的推导式
        集合名称 = [变量名 for 变量名 in 容器 [if 条件判断]]
        set = {d for d  in range (1,10) if d % 2 == 0}
    字典的推导式
        字典名称 = [k:V for k:V in 字典名.items() [if 条件判断]]
        dict2 = {k:v for k:v in dict1.items()}
        用一个字典推导另外一个字典有啥用？
         加if
    元祖推导式
        tuple = (d for d in range(1,10))
        最终是输出一个生成器
目的：简化开发，简化代码编写

函数

在文件中，只要出现两次一摸一样的代码，那就代表你写的代码有问题
定义：
    （所谓的函数就是一个被命名的、独立的、完成特定功能的代码段）
     提前定义好的，可以重复使用的一段代码块，可以称之为函数
格式：
    def 函数名称([参数1, 参数2, ...]):
        函数体
        ...
        [return 返回值]
函数调用：
    函数名(参数列表)
函数定义：
    1、有参数，无返回值
    2、有参数，有返回值
    3、无参数，无返回值
    4、有参数，有返回值  --- 几乎没用
注意：
    1、函数名建议是见名知意，小驼峰/蛇皮走位
    2、函数是先定义，后调用
    3、函数在调用时，如果函数定义时带几个参数，调用函数时，必须传递几个参数
        形参:就是形式参数，不调用函数，没有固定的值
        实参:实际调用函数时，传递的值(已经赋值的变量名)
    4、函数遇到return代表函数结束
函数解释说明文档
    直接在函数体中使用三引号即可
    
如果只是为了看一下谁大谁小，不需要返回值
如果你需要拿到最大值，并展示最大值的**2 需要返回值
​
参数？
看想要死值还是  变值（需要传参）
什么时候需要参数？
每次要的结果都不一样时，需要传参
什么时候需要返回值？
后续代码会用到函数的返回值
​
函数的说明文档
    在函数体的第一行，添加三引号+enter

函数嵌套

函数嵌套：一个函数调用了另外一个函数
函数里面还有函数：

main函数先进栈后出栈（项目在运行中遇到阻塞，回去寻找下一个函数）

pycharm运行后按 f7 ：走程序走的路

变量的作用域：

​作用域：也就是变量在哪可以用，在哪不能用（看变量是否顶头写，只要顶头写，就是全局的，不顶头就是局部的（ps.不加global关键字的前提下））
    全局变量：在.py文件中顶格定义的变量;随处可以用
    局部变量：在函数内部定义的变量;随处用不了
    global关键字的用法
    * 实现在局部位置对全局变量做修改.

函数的参数进阶

位置参数，关键字参数，默认参数（缺省参数），不定长参数
    位置参数：你的实参会按照顺序一次去给形参赋值，位置参数主要针对的是实参（你传递的值）
        实参：实际参数，你的各种值
        形参：形式参数，你写的各种变量名，没有实际的值，必须等调用方法时传递
    关键字参数：传参时，直接使用    制定形参名称 = 值 这种方式来传递参数  
    默认参数（缺省参数）：可以在形参上进行赋值，如果调用函数是传递了参数，那么是按照传的打印参数，如果没有传实参，按照默认来赋值
    不给定参数：可以传递任意数量的实参
        *args：会将所有的实参封装到元祖中
        **kwargs（key word args）：传递关键字参数，会将所有的实参，封装成字典
注意：
    1、如果位置参数和关键字参数混在一起使用，那么位置参数必须在关键字参数之前使用
    2、默认参数（缺省参数）必须放在最后
    3、不定长参数和默认值参数如果同时存在，那么不定长参数必须放后面（**kwargs参数建议放在参数的最后）
    4、如果有默认值参数和不定长参数（*args）在一起，那么建议将默认值参数放在不定长参数后设置值

可变与不可变数据类型

常见类型
    int,float,bool,str,list,tuple,set,dict
    数值分类：
        1、单数值:int，float,bool,str
        2、多数值:list,set,tuple,dict
    可变不可变：
        1、可变:list,set,dict
        2、不可变:tuple,int,float,bool,str
可变类型
不可变类型
引用传递和值传递
    list1是引用传递，a是值传递
    引用传递的值可以发生变化
    值传递的值是不会发生变化
​
查看地址值方式：
    id（变量名/值）

元组拆包

拆包:将容器中的元素，拆开多个变量
装包:将多个值，存放到容器中
​
拆包应用:变量值交换，例子 a,b = b,a 
变量值交换

lambda函数

普通函数与匿名函数

lambda表达式
    应用场景：可以使用lambda表达式来进行简化代码
        1、如果你的函数只有一行函数体
        2、如果你的函数只有一个返回值
    格式：
        变量 = lambda 函数参数:表达式（函数代码 + return返回值）
        lambda 形参：函数体
        
# 调用变量
变量()
    注意事项：
        
    实际应用：
        1、lambda可以直接用一个变量来接收，此时lambda是一个值，作为函数的实参来用
        2、作为函数的实参来用
        3、lambda表达式可以作为一个匿名函数来使用
    注意事项：
        1、lambda会自动将内容返回
        2、它会生成一个匿名函数

文件

作用:用来存储数据
分类:txt，MP4，MP3，.py，.java,.json....
open函数:会有一个返回值，返回值代表  文件本身(对象)
    格式:文件对象名 = open(name.mode)
        name: 路径/文件名
        mode: 文件的操作模式
            r:只读，如果文件不存在，就报错
            w:只写(覆盖写入)，如果文件不存在，就创建
            a:追加写入，如果文件不存在，就创建
    如果文件存在，那就是打开文件，如果文件不存在，那就是新建文件（只针对于写操作），读操作如果没有文件，那就是报错
写到中文a.txt
中文编码问题解决
    乱码是因为:编码解码不一致
    编码:
        GBK：中文，一个中文汉字解析成2个字节
        UTF-8：万国码，主要是为了输入中文，不会乱码 一个中文汉字解析成3个字节
    你好-->先转换成二进制-->存入电脑--> 编码
    从电脑底层读取-->先将二进制--> 解码

文件写操作

write
注意：
    1、如果是字节形式导入，那么不能写字符
    2、无返回值

文件读操作

1、read():读操作
    read():读取所有
    read(字符/字节数量):指定数量读取
2、readline()一次读取一行内容
    一次读取一行内容，每行的最后都会有一个\n
3、randlines()一次读取所有行，最终封装到一个列表中
一字节方式读写文件
    模式选择:
        rb:以二进制的方式进行读取
        wb:以二进制格式打开一个文件只用于写入

close函数

关闭资源：变量名.close() #释放资源

os模块

1、rename():对文件进行重命名
2、remove():删除文件
3、mkdir():创建文件夹
4、chdir():改变当前的工作路径 #change
5、rmdir():删除空文件夹
    注意:不能删除非空文件夹
6、listdir():查看文件夹下的内容
    注意：只看当前路径下的所有内容，不包含子目录内容，孙子目录更不行
7.getcwd():或者当前的工作目录  #current workd irectory

with open语法

格式：
    with open(文件名,mode,编码集) as 别名,open(文件名,mode,编码集) as 别名2:
    代码体
为什么with open语法不需要手动close
    上下文管理器
        __enter__:当你进入到代码体中的时候，会自动调用__enter()__
        __exit__:当你离开with语法的时候，会自动调用__exit()__

python异常

异常：代码运行期间，出现了非正常结果
python：error
java：
    error
    exception：编译能过，但运行出错(.java->.class,编译失败，报错)
异常出现后：
    1、不管它，调代码
    2、捕获异常
异常的格式：
try：
    正常的代码
except：
    上述代码出现异常后，执行的内容
else：
    如果代码正常执行，后会执行的内容
finally： #文件复制 f.close()
    不管“正常代码”会不会出现异常（问题），都会执行
注意：
    1、try不能单独出现，必须结合except使用
    2、一旦出现异常，try中异常，后续的代码不会执行
1、try.....except...
2、try.....except...else
3、try.....except...else...finally
4、try.....except Exception as 变量名...else...finally
​
​
异常格式：
    try:
        正常业务代码
    except Exception as 变量名:
        出现异常时，执行的代码
    else：
        没有出现异常时，执行的代码
    finally：
        无论是否有异常都会执行的代码

Python内置模块

模块:
    1、只要是以.py结尾的都是模块
模块分类
     1、内置模块
     2、自定义模块
模块的导入方式：
    1、import 模块名
    2、import 模块名 as 别名
    3、import 模块名1，模块名2,....
        注意：
            1、如果你是导入的模块，那么想调用模块内的功能(函数)，只能通过 模块名.功能名(参数...)
            2、你导入了模块之后，可以使用该模块下的所有功能
    4、from 模块名 import 功能名
    5、from 模块名 import 功能名 as别名
    6、from 模块名 import *
    from 模块名 import 功能名1，功能名2，.....
    注意：
        1、如果是只导入了某个功能，那么其他功能是不能使用的，必须导入才能使用
        2、调用时，可以直接写功能名(参数1，参数2，...)
--thread time 线程的时间

自定义模块导入

自定义模块:我们自己创建的.py文件
​
注意：
    如果你导入了模块，模块中打印了__name__，你在导入的位置去执行，那么__name__打印的是模块名，如果你是在模块内部打印，那么__name__打印的是main这个函数
切记：
    模块名称(python文件名)不要是中文，特殊字符，数字开头