Python-语言基础入门

0. 常用类型 :

   0. number

      0. 整数 int
      1. 浮点数 float
      2. 布尔 bool
      3. 负数 complex：比如4+3j，j表示复数

   1. String

   2. List

   3. Tuple

   4. Set

   5. Dictionary

1. 注释的分类

   0. 单行注释是 #
   1. 多行注释是 """ 多行注释是三个双引号 """ ，主要是对于文件和类进行注释，支持换行

2. 和其他语言不同，python的使用十分的简单，不用在声明变量了，只需要直接将变量名等于变量值。

3. Python中的数据类型

   0. 应用type（） ，JS是应用typeof；可以直接

4. 数据类型转化

   0. 常见的数据转化语句

      0. int（x） ： 转化为int
      1. float（x）：转化为float
      2. str(x)：转换为string

   1. 万物都可以转换字符串，但是字符串中只有是数字的时候才能转化为数字；浮点数可以转化为数字，但是转化后会丢失精度。

      注意的是，PY中转化之后不会改变原来变量的数据类型，只有当转化语句出现的时候才进行了转化

      3. 标识符

         0. 用户在编程时候使用的一系列名字，比如变量、类、方法之类

         1. 限制：

            0. 内容限定：只能是中英文、下划线（_）和数字：数字不可以用作开头
            1. 大小写敏感：字母的大小写是完全区分的
            2. 不可以使用关键字，比如class

         2. 命名法：

            0. 下划线命名法：first_name
            1. 全部小写

      4. 运算符

         0. 算数运算符：+-*/（加减乘除），需要注意的是 //是取整数（例如9//2 最终是4）、 %是取余（10%2 结果是0）、是指数（10**2 是10的2次方）
         1. 赋值运算符 ： 就是变量 = 变量值，还有+=、-=
         2. 比较运算符 ： ><= <= >= != ==(和js不同)

      5. 字符串拓展

         0. 定义方式：

            0. 单引号
            1. 双引号
            2. 三引号： name = """三引号字符串""" ，如果前面有变量就是字符串、没有变量就是注释；换行也可以
            3. 以上主要是解决字符串的嵌套 “''”

         1. 引号的嵌套：可以使用:\来进行转义，也就是加上\之后引号没有了作用，相当于一个普通字符串

         2. 字符串的拼接:

            0. 用于字面量和字符串之间的拼接，就是不用原来的逗号了
            1. 在拼接的时候只能用于字符串拼接，不能把数字和字符串进行拼接

         3. 字符串格式化：

            0. 主要是解决上述问题，解决字符串和其他类型的拼接

            1. 用%进行占位，多个变量有几个就有几个%百分号，而且能够把数字转化为字符串进行拼接

            2. 注意一下多个变量占位，多个变量需要有多个%，并且最后要把变量括号括起来，中间用逗号隔开，而且要按照顺序书写。

            3. 数据类型占位

               0. %s ： 把内容转化为字符串，放入占入位置
               1. %f ： 把内容转化为浮点型，放入占入位置
               2. %d ： 把内容转化为数字型，放入占入位置

         4. 格式化的精度控制

            0. 数字精度控制：使用辅助符号m.n来控制数据的宽度和精确度

               0. m，控制宽度，要求是数字，设计的宽度小于数字本身

               1. .n控制小数点精度，要求是数字，会进行小数的四舍五入

                  0. 例如 %5d，表示将证书宽度控制在5位，设置成5d，变成空格空格空格11，用三个空格补齐
                  1. %5.2f就是将整数部分宽度为5，小数部分精度设置为2，
                  2. 也可以设置%.2f，只是控制小数

            1. 快速写法，通过%的好处就是能够进行占位了，还能进行精度控制，但是还有一种更快捷的写法，就是直接在字符串模板中加入{变量名}写法，前面要加f。但是不关心精度控制

            2. 表达式语句：一条有具体结果的就叫表达式，能够通过上述方法去格式化表达式

         5. input输入输出

            0. 获取键盘的输入，可以吧内容输出在屏幕上，使用变量接受input语句获取键盘输入数据
            1. 除了用 name = input() 还可以使用 name = input（“请告诉我你的名字”），效果是一样的
            2. 也就是用input（提示问题），input里面的变量可以是提示作用
            3. 键盘中无论输入什么类型的数据，获取到的数据就是字符串类型

         6. 判断语句

            0. true就是1，false就是0；表示布尔类型

            1. if判断语句： if 要判断的条件: （空格缩进）条件成立时，要做的事情

            3. if else条件语句判断：注意if和else同级，else不需要缩进

            5. if elif以及else的语句：用于多条件判断；

               0. 如果满足if条件，elif不会进行执行；如果满足elif第一个条件，那么elif以后的条件也不会执行

            6. while的循环操作：

               0. while条件： 条件满足时，做的事情
               1. 案例：求1-100的累加

            7. 补充：print语句不换行：使用end = '',记得与变量之间加上逗号。

            8. 制表符\t，中间用\t可以进行单词对齐，注意反斜杠是\t，不是/t

            9. for循环语句：

               0. 字符串中，定义相关字符串，然后for in打印出字符串中每一个单位

               1. 举例：for x in name： ,与js不同，PY不用加各种括号，用冒号代替

               2. 案例，数一下字符串有多少英文字母s，注意判断相等 是两个等号

               3. range语句：

                  0. for循环中的in后面就是所谓的待处理数据集，准确的说就是序列类型

                  1. 序列类型就是他的内容可以一个个依次取出来的一种类型，包括：字符串、列表、元祖等

                  2. range语句,必须要在for语句当中，不能单独拎出来

                     0. range（num）:获取一个从0开始到num结束的数字序列
                     1. range（num1,num2）:就是从num1开始，到num2结束的序列，不含num2本身
                     2. range（num1，num2，step）：step表示步长，比如步长是2，那么就是输出[1,3,5,7]

               4. for循环的临时变量域：在for循环外边可以输出，只是不符合规范

            10. break和continue：

                0. continue：主要用于中断本次循环，直接进入下一循环，用于for和while循环

                   0. 主要应用就是。因为某些原因，临时结束本次循环，放在语句之间,只是结束所在循环。

                1. break就是直接结束了，整个循环结束，如果有嵌套循环，那么只对自己的循环有影响

         7. 函数初体验

            0. 函数就是组织好的，可重复使用的实现特定功能的代码块
            1. 主要使用def来定义函数，格式 def 函数名（变量）:
            2. 执行函数千万别忘记调用!!
            3. 当然函数体是冒号之后，然后还有返回值return
            4. 遇到return就是把值返回给函数作为结果，当然遇到return函数肯定就已经终止了。
            5. return返回值为NONE的类型，没有return返回的话，函数的语句最终输出结果是NONE
            7. NONE主要是用于if判断，可以作为false使用；可以声明一些无意义的变量
            8. 函数的说明文档：在函数里三个引号之后按回车就可以
            9. 函数嵌套：一个函数里面嵌套了另外一个函数

         8. Python的数据容器

            0. 可以容纳多份数据，可以容纳多个数据类型，一个数据就是一个元素

            1. 列表：

               0. 定义就是和数组一样 [] 或者是list() ,每个元素用逗号隔开：注意，字符串要加引号，还有就是print可以打印多个变量

               1. 当然也可以定义嵌套列表，里面的数据类型也可以是不同的

               2. 列表的下标索引：和数组一样，从0开始的索引：list[0]

                  0. 但是要取嵌套列表的时候，需要取多次：不是在里面取而是在外面取，如图

               3. 列表的方法：将函数定义成class（类）的成员，那么函数就叫方法

                  0. 函数的调用方法不一样
                  1. 查找某元素的下标：语法：列表.index(元素)，注意的是：index里面的元素类型
                  3. 修改下标索引的值：列表[下标] = 值
                  4. 对列表元素插入的操作：insert，参数是插入的位置还有新元素
                  5. 对列表的追加，使用append
                  6. extend就是将一个列表追加到另外一个列表后面 直接就是list0.extend(list1)，事后返回新的列表
                  7. 删除方式就是del[指定下标]：del list[0],还有就是list0.pop（下标）
                  8. remove方法就是能够一处第一个匹配项，他的参数是一个元素，不是下标，只能删掉一个元素，还是第一次搜索的元素
                  9. 可以用count来统计出现的次数，参数是元素。

         9. 元组(TUPLE)：

            0. 和列表最大的不同就是不能进行修改，需要程序内封装数据，但是不希望篡改就是元组

            1. 定义：就是直接用（）来定义

            2. 如果定义空的元组是 a= tuple()

            3. 如果只有一个元素，需要在元素之后加上逗号

            4. 和列表一样都支持下标索引

            5. 方法：

               0. 用index，还有len
               1. 元组内的内容不可以修改，但是对于元组里面的列表可以进行修改

         10. 字符串的修改

             0. 不支持修改
             1. 可以使用index方法
             2. 字符串的替换，也就是replace：字符串.replace（字符串1，字符串2），将1修改为2，必须是字符串
             3. 字符串的分割。split，需要传入一个参数，按照什么进行切分，但是切割的字符是不存在的
             4. 字符串的strip：去除前后的空格，如果有参数就把头和尾的空格去掉，然后去掉字符串中所存在参数，去除参数，但是注意，参数是没有顺序的

         11. 数据容器的切片

             0. 序列就是内容连续，有序，可以使用下标索引的容器
             1. 切片就是从一个序列里面取出来一个小序列
             2. 语法：序列[开始：结束：步长]，注意是冒号，步长还可以是冒号，可以直接省略开始和结尾下标，但是注意冒号不可以省略，步长也可以省略，默认值为1
             3. 不会影响序列，只会得到一个新的序列

         12. Set* 集合*

             0. 列表和元组都可以支持元素重复和有序，但是元组不可修改

             1. 集合使用{}大括号，不存在重复的元素，可以进行去重；内容也是无序的，所以无法访问下标索引

                0. 如果有重复元素，那么不会显示

             2. 方法：

                0. 通过add添加新元素
                1. 通过.remove移除新元素
                2. 从集合中随机取出一个元素 .pop，但是在列表上就是取出最后一个
                3. .clear，就是集合被清空
                4. difference 集合1.difference(集合2)，取集合中的差集，也就是集合1中在集合2没有的
                5. 消除差集 difference_update（集合2）
                6. union，使用联合； 集合1.union（集合2）

         13. 字典

             0. 通过字典可以使用key来取出value的操作

             1. 和集合一样，使用{}和逗号进行分割，但是存储键值对

             2. 类型名字是dict，直接用{}来定义空字典，也可以用dict()来定义

             3. 字典的key不可以重复，只会覆盖掉

             4. 取得话直接使用[key]来取元素

             5. key不可以是字典，value都可以

             6. 字典的常用操作：

                0. 修改操作：字典[key] = value，key不存在就是新增，key存在就是替换
                1. pop就是移除字典中的key和value
                2. clear清空元素，全部被清空
                3. 获取全部key 就是 .keys方法，得到的结果key的字典

         14. 对于数据容器的总结：

             0. 下标索引

             1. 是否支持修改

             2. 是否存在重复元素

             3. 通过max和min找到最大最小的元素：

                0. 使用方法是max（容器）

             4. 可以使用容器转换，和转化float什么的差不多

                0. set（）转化为集合，数据会无序，字典value丢失
                1. 没有转化为字典的函数，有，但是会报错，缺乏value

             5. 容器的通用排序：sorted（，reverse=True）

         15. 函数：

             0. 函数的多个返回值，也就是定义多个变量

             1. 参数的使用形式

             2. func（name = '小明',age= 18）用关键字传参，就是指定参数

             3. （*args）位置传参，args传入后会传到一个元组内部（**kwargs）传入后会作为字典进行存在（需要key-value进行传递）

             4. 函数作为参数进行传递

             5. lambda匿名函数：

                0. def就是有名称，可以循环使用无数次
                1. lambda关键字就是无名称，只可以使用一次，函数体只能写一行，有点像js的箭头函数

         16. 关于文件的读取操作：

             0. open打开已经存在的文件，或者创建新文件 open（路径文件名，选择模式，编码方式）

                0. 示例：f = open('file.txt',"r",encoding = 'UTF-8')，此时f就会是一个文件对象
                1. 模式：r是只读；w是只用于写入；a是追加

             1. 读操作相关的方法

                0. .read（num），num是可以读取的区域，没有传入num就可以全读
                1. .readlines（）方法，按照行方式把整个文件的内容进行一次性读取，返回的是一个列表，每行数据是一个元素，就是只读取一行
                2. for循环也是可以一行一行的读取
                3. 停止是f.close()，也可以用with open（open方法中的参数）as f来替代close操作

             2. 文件的写出操作：

                0. f.write（‘写入的内容’），之后用f.flush()刷新文件

         17. 异常的捕获

             0. try： 可能出错的代码 except：如果出现异常的代码
             1. 捕获指定的异常：就是把出错的原因放到except后面，总结说就是针对这个问题来捕获异常
             2. 顶级的捕获方式：except Exception as e:
             3. 如果没有异常，可以用else进行处理
             4. finally：就是无论是否出现异常，我都会执行操作任务，一般都会用在文件的关闭上
             5. else和finally都是可选的
             6. 异常具有传递性

         18. Python 的模块

             0. 是一个python文件，里面有类、函数、变量等

             1. 导入形式：

                0. import 模块名 例如：import time ------time.sleep
                1. from 模块名 import功能名 功能名（）例如：from time from sleep ---------sleep
                2. from 模块名 import 功能名 as 别名 -----也就是给sleep设置别名

             2. 可以自己制作一个，设置一个py文件，py文件里面定义一个函数，import改文件，然后用.使用该功能调用

             3. ——main——:主要是解决import的文件在调用过程中自己自动执行输出，可以使用main变量阻止自动输出

             4. all ：如果模块里面有all变量：主要作用就是控制导入的来控制是否能够进行导入，因为不是要导入所有功能嘛，如果写了*但是只想用其中一个就可以通过all来控制

                0. 例子： ——alll—— ==['要使用的函数']

             5. 不同模块，也是分先后导入，后导入的会覆盖掉以前导入的

         19. 自定义Python包

             0. 包就是个文件，如果有——init——.py文件的话就是Py包
             1. 关于第三方包，使用pip进行安装

         20. 关于JSON

             0. 使用json.dumps方法能够将py数据转化为json数据
             1. 用json.loads能够将json转化为python数据

         21. 对象

             0. 生活中数据的组织

             1. 程序中数据容器使用混乱，列表，字典，字符串什么都有

             2. 使用对象对数据进行组织：

                0. 设计类 ： class Student：

                1. 创建对象 stu_1 = Student

                2. 对象属性复制 stu_1.name = '周杰伦'

                4. Class定义类：

                   0. 类的属性: 直接给属性赋值（成员变量）

                   1. 类的行为：对象 = 类名称() （成员方法）

                      0. 类的方法和函数有区别 def 方法名（self，形参）
                      1. 定义方法时候参数必须带上self，但是调用的时候不用带上self
                      2. 还需要注意的是要调用成员变量的时候需要用上self.变量
                      3. 注意，用对象等于类的时候，需要在类中带上（），比如

             3. 类和对象：

                0. 类相当于图纸，对象相当于具体根据图纸设计出来的实物。

         22. 构造方法

             0. 可以使用--init--方法进行构造，就是构造方法
             1. 创建类对象的时候，会自动执行
             2. 创建类对象的时候，将传入参数自动传递给--init--方法使用

Python高阶

1. 闭包：全局变量有修改的风险，出现了闭包

   1. 做两个嵌套的函数，内部函数使用外部函数变量，和JSreturn不同
   3. 如果要修改外部变量的值，在内部加入nonlocal关键字来修饰外部函数的变量，才可以在内部函数修改它

2. 装饰器：

   1. 其实也是一种闭包，功能就是不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能
   2. 其中的一种示例就是在外部函数的参数中加入函数，然后再内部函数进行相关调用
   3. 装饰器的语法糖：@outer，使用outer（outer是外部函数名），定义在目标函数（内部函数）之上
   4. 装饰器就是使用创建一个闭包函数，然后再闭包函数中调用目标函数
   5. 可以达到不改变目标函数，实现新增功能的要求

3. 设计模式和单例模式

   1. 常见的设计模式：面向对象、单例模式和工厂模式

   2. 单例模式

      1. 创建类的示例后，可以得到类对象，当然这两个类对象是完全不同的独立的两个对象，但是，有时候我们仅仅只需要一个类对象，节省内存开销
      2. 总结为：单例模式就是确保一个类只有一个实例存在，提供一个访问他的全局访问点
      3. 可以import解决这个一个类创建多个内存地址不同的对象的问题 ，新建一个py文件，然后通过s1来创建新的对象，就可以得到指向统一内存地址的对象了

   3. 工厂模式

      1. 需要大量创建一个类的实例的时候，可以选择工厂模式

      2. 优点：

         1. 大批量创建对象的时候有同意的入口， 易于代码的维护
         2. 发生修改的时候，修改工厂类的创建方法即可
         3. 符合现实世界的模式