python 基础知识整理

#第一篇：
print和input输出
    print()：直接输出括号内的数值。
    input():a = input("请输入第一个加数：");   b = input("请输入第二个加数：")
    print(type(a));  print(type(b))     # 上面都是str类型，所以+是代表拼接=》1+2合并=》12
    print(a+b)

    # int()+input()=>意思就是把input里面的数据类型转换为int类型
    a = int(input("请输入第一个加数："))  ;  b = int(input("请输入第二个加数："))
    print(type(a))  ;  print(type(b))    # 上面都是int类型，所以+是数学运算=》1+2=》3
    print(a+b)

#第二篇：
    变量 ：存储数值    ；     注释： 单行注释用 # ； 多行注释用 ”“” “”“
    数据类型：-number类型 数字类型  （-int类型  整型 整数 ； -float类型 浮点类型 小数）
    -bool 布尔类型 -》True和False
    -str 字符串类型
    -list 列表类型      -dict 字典类型
    -tuple 元组类型     -set 集合类型
    
    标识符：（python的命名规范：）  大小驼峰法
    1.首字符：下划线，字母大小写
    2.组合：下划线，字母大小写以及数字
    3.不能：不能是关键字（为了后面不要与内置函数冲突，加上内置函数名）
    ！注意：有括号是函数，没有括号才是关键字   ；    关键字：True, del，False，in，not in，None

#第三篇：
    运算符：1.算术运算符：+ - * / // ** %  ；   2.赋值运算符：=  ；   3.复合运算符：+=  -=  *=  /=  //=  **=  %=
    字符串：即文本信息 （用‘’或“” 引用）    
        字符串的嵌套使用：用不同引号引用
        字符串的转义: 1.转义单引号：\'   2.转义双引号: \"   3.转义换行：\n   4.转义制表: \t   5.部分取消转义: \\   6.全部取消转义:r+字符串
    
    有序序列：作用:储存多个数值,而且有index(下标值)     一般从左往右：从0开始=》0123456789...
    切片与步长方法：
        第一步：你要标出每一个数值的下标值
        第二步：写出切片公式：序列名[起点,终点+1，步长] 步长：后一个下标值-前一个下标值
        第三步：标出起点，终点，算出步长，套进公式就行

#第四篇：
   1. 列表:特征：[]，逗号是隔开的作用，不在数值里面，也不占用index下标值
        作用：和有序序列一样，用来储存数据的
        特点：可以修改，也是有序序列唯一可以修改的序列
        ！字符串：有序序列->字符串有特殊性：  如果里面要求是数值，字符串就是数值；如果里面要求是有序序列，字符串就是有序序列
    list增:
        append(数值) -》追加，数值添加到末尾
        insert(下标值, 数值) -》在输入的下标值插入数值
        extend(有序序列) ->根据有序序列的下标值依次插入目标列表末尾
    list删：
        pop(下标值)：=》根据下标值删除，如果不写就是默认一个，如果超过就是报错
        remove(数值): -》根据匹配的数值上传，如果相同数值就是删除最左边一个，如果匹配不到会报错，如果不写，就报错
        del:   del 序列名 物理删除     del 切片 删除切片内容结果
        clear(): 清除数值
    list改:序列名[index] = 数值
    list查询： 1.count(数值) 统计个数    2.index(数值) 查询index
  2.元组：特征：() + 逗号，数值也是逗号隔开

    作用：和列表一样储存数值
    特点：不可以修改数值
　  tuple查询：有序序列的查询   序列名[index]
　　tuple合并： 序列A + 序列B
　　list 与 tuple 互换： 如， a = [~]  ;  b = tuple(a)  ; print(b)==> (~)

　　3.字符串方法:
    代替方法：replace(old,new,number) old：原来的字符 ; new:代替的字符  ;  number:代替的个数，如果没有设置number:-1 全部 
    代替的方向：从左往右
    删除方法：strip(字符) -》删除左右连续指定的字符
            lstrip(字符) -》删除左边连续指定的字符
            rstrip(字符) -》删除右边连续指定的字符
    全大写upper()，   全小写lower()，   大驼峰title()
    字符串查找方法:  find(数值) -》 输出下标值，如果相同数值，只输出最左边一个     拓展：find(数值，起点，终点) 终点是开区间，和切片一样的
                   如果查询不到输出-1
    查询后缀名：  endswith(字符)
    判断是否为纯数字 :  isdigit()
    *分割:  split(字符，number) 字符:作为分割点，该数值就分割后删除了       number ->分割的次数，默认是-1（全部）
         拓展： 如果相同相邻的分割点数值，第一个会删除，后面的会用空字符代替， 如果最开头或者最后为分割点统一要用空字符代替
         
    格式化输出：  %s 格式输出字符串
                %d 格式化输出int类型形式 =》本身还是字符串 
                %f 格式化输出float类型形式 =》本身还是字符串
                format   如： "{0}{1}".format(数值1,数值2)
                        注意format的右边数值的下标值一定要大于左边下标值最大值
                        {变量名1}{变量名2}.format(变量名1=数值,变量名2=数值)      变量名要符合标识符
                f-String    变量名 = 数值    f"{变量名}
  4.字典：无序序列      格式：字典名={key: value}      特征：数值可以改变，但是没有下标值，没有切片，有key值进行定位

　　dict增加与修改：1.update(dict)    如果里面存在相同的key，只更新value值     如果没有key，就是增加一个键值对
              2.setdefualt(key,defualt) default值可以不写，默认为None       如果遇到相同的key，不修改       如果用不相同key，增加
              3.dict[key] = value
　　dict删除：pop(key,default) -> 这里list是没有的       如果你写了default，没有匹配到key就是返回default      如果没有写default，没有匹配到key报错
        popitem()删除字典最后一个，随机删除
        del：   1.del dict[key]           2.del dict
        dict.clear()   清除数值
　　dict查询：dict[key] 通过key值匹配value值，如果没有匹配到key值，直接报错
         get(key,default) 其中default默认值None      如果是没有匹配到key值，也没有设置default=》返回值None
                                                如果你没有匹配到key值，但是设置default => 返回值default值
　　dict常用方法:dict.items()     # 查询全部key值和value值，返回形式：以列表形式储存，元组为数值，我们要进行嵌套序列的拆解   即 [(key,value),]
            dict.keys() # 查询全部key值，返回形式：list列表形式
            dict.values()  # 查询全部value数值，返回形式：list
            dict.fromkeys(keys,value) value的默认值是None      使用时需要用一个变量储存   即 a = dict.fromkeys()


　　集合：特征：1.没有key值，也没有index值，真正的无序，也没有查询不了具体数值      2.数值没有重复，可以去重，只能什么类型：str，number，bool，tuple
    　　# 如何创建一个空集合     a = set()
　　set添加：add(数值) 添加数值
　　set删除：remove(数值), discard(数值)           remove 如果没有匹配到数值报错    ;    discard 如果没有匹配到就返回None

#第五篇：
    流程控制：
        比较运算符:>,<,==,>=,<=，!=
        逻辑运算符:or and not
        顺序控制：自上而下
        分支控制：根据条件选择不同的代码
            单分支   if 条件语句:   代码块
            双分支： if 条件语句:  代码块   ;  else： 代码块
            多分支： if 条件语句:  代码块  ;elif 条件语句:  代码块 ... ;  else: (# 你可以不需要else结尾)  代码块
    循环控制:
        for 变量名 in 可迭代对象：  代码块  ;  (#可迭代对象: list,str,tuple,dict,set)
            range(start,end,length) length 相当于步长间距  ;  range和切片类似，end是开区间
            while 条件语句:  代码块  (#while 相当于 for 加 if )
        终止循环：continue 与break   共同点：都是终止程序的意思   ！！不同点： continue 跳过本次循环  ；  break： 直接结束循环

　　

　　函数：作用：储存代码       格式： def func():  代码块   
      # 调用  func()
    返回值：作用：结束程序，返回结果   格式  return  + 返回值     返回值默认为None
        注：函数中运行到返回值时直接结束，即不再运行return下面的代码
　　　　#单参数与多参数   def 函数名(单参数或多参数（形参）):   代码块   #调用： 函数名(实参)      ！注：传入的函数的实参和形参是一一对应的，不能多也不能少
　　　　　其中多参数一般分元组型（*args）与字典型（**kwargs）
　　内置函数： max()最大值  min()最小值  len()长度函数  sorted()排序  sum() 求和     （！注：如max min sum 要在list中使用。）
　　匿名函数：  格式： lambda 变量名: 代码块      作用：减少代码量，简化我们的程序复杂性
 　　　　如：a = lambda x,y: x+y ； print(a(1, 2))

#第六篇：
　　函数对象，可视为高级变量   1.函数可以赋值    2.作为元素使用    3.函数可以传入另一个函数（装饰器）
　　名称空间：存储变量名和函数名的地方
　　作用域：一个数值的使用范围
　　　　

　　　　global +局部变量：可以让局部变量去修改全局变量
　　　　nonlocal：只能嵌套函数里面使用，只能影响嵌套函数上一个变量   ==》 即nonlocal只能在内层函数中使用， 且如果第n层使用了nonlocal，将会从n-1层开始向上层函数

#第七篇：
　　闭包： 就是一个嵌套函数    （一个简单的闭包是没有任何意义）
　　装饰器：其实就是一个特殊闭包      作用：在[不修改源代码]和[调用方式不修改]情况下，给源代码添加或者修改功能　　　　(语法糖：@装饰器名)

　　递归：函数本身调用自己的函数运行程序
    # 需要一个终止的条件  
    eg. def func(number):
        　　if number == 1:
            　　return number
        　　return number + func(number-1)
    　　print(func(int(input("请输入数值"))))
    
　　迭代器（iter）：操作有意义的数据=》更新或者迭代       ！注：遍历不是迭代
    格式： 变量名 = iter(可迭代对象)
    
　　next（对象）：   作用：执行下一个项目  
    格式： next(迭代器, default),如果下一个项目为空，没有设置到default会报错，如果设置了就是返回default值
    
　　生成器：     生成器的作用：指定规则，生成数据        本质：是一个特殊的迭代器       生成器的关键字：yield
    # 一种不需要函数不需要yield进行定义的生成器
    # 生成器表达式进行制定规则，生成数据

#第八篇：
　　绝对路径和相对路径：
　　　　绝对路径：从磁盘符开始，一直到具体文件位置
　　　　相对路径：以文件为参考点，进行一个位置模糊定义
　　

　　文件操作：    格式：  open(文件名/文件地址， 操作模式+字符模式，字符编码)        操作模式：“w”,“a”,“r”        字符模式：b， t
　　with：
   　　 优点： 不需要自己写一个关闭文件代码
    　　格式：   with open(文件名/文件地址， 操作模式+字符模式，字符编码) as f：
            f.write()
    　　# 一般不要从最顶部开始，一般一两个上级参考物就行，同级没有相同文件夹名
        如： with open("../AllLogin/1.txt", "rb") as f:
            a = f.read()
            print(a)