zoukankan      html  css  js  c++  java
  • Python 第十五天 串讲

    Python: 弱类型的.解释型的高级编程语言

      特点:简单.优雅.明确

      变量:程序运行过程中产生的中间值,供给后面的程序使用.

      变量的命名规范:

        1.由数字.字母.下划线组成

        2.不能以数字开头,更不能是存数字

        3.不能用关键字

        4.不要太长

        5.不要用汉字

        6.要有意义

        7.区分大小写

        8.推荐使用驼峰或下划线

      变量的数据类型:

        1.int:整数  + - * / // %   bit_length  得到二进制长度

        2.str:字符串   +拼接  *重复 %格式化输出

          索引和切片[start:end:step]  end取不到

          upper() 大写  strip() 去掉左右两端的空格  spilt 切割 按什么切什么就没有了得到的是列表

          replace(old,new) 替换  join() 把列表中的元素拼接成字符串

          startswith() 以什么开头   find()/index() 查找  count() 计数  len()长度

          编码:

            encode()编码   decode() 解码

            1.ASCII  1byte(位)  8bit(字符)

            2.GBK   2byte(位) 16bit(字符)

            3.UNICODE  4byte(位)  32bit(字符)

            4.UTF-8  

              英文:1byte(位)  8bit(字符)

              欧洲; 2byte(位)  16bit(字符)

              中文: 3byte(位)  24bit(字符)

         3.bool: 布尔值
           取值: True, False
           用来判断
           类型转换:
            False: 0, '', None, [], {}, tuple(), set()
            True: 除了上面的都是True


         4.list: 列表. 由[]表示.每个元素与元素之间用逗号隔开, 可以装任意类型的数据.
           列表是可变的. 并且列表由索引和切片功能
           1. 增
            append() 追加
            insert(索引, 数据)
            extend(Iterable) 迭代添加
           2. 删除
            pop()
            remove(元素)
            del 切片删
            clear() 清空
           3. 修改
            索引切片修改
            lst[i] = "新元素"
           4. 查询
            一般用索引
            for循环

           5. 操作
            count(). 计数
            index() 查找元素
            sort()排序
            reverse() 翻转

            列表不能直接在循环中删除. 因为涉及到元素移动.需要把要删除的内容添加到新列表中. 循环新列表. 删除老列表

          拷贝:
            1. = 赋值操作. 没有创建对象. 两个变量使用同一个对象.
            2. 浅拷贝. 只拷贝一层. list.copy(), list[:]
            3. 深拷贝. 和这个对象相关的内部信息全部拷贝一份. deepcopy() 原型模式

          推导式: [结果 for循环 if判断]

        5.dict 字典:
          由{}表示. 内部存储key:value. key必须是可哈希的数据类型. 不可变. value:没有限制
          字典没有索引和切片
          1. 增
            dic[新key] = value
            dic.setdefault(key, value)
          2. 删除
            pop(key)
            popitems() 随机删一个
            del
            clear() 清空
          3. 修改
            dic[老key] = 新value
            dic.update({}) 把xxx字典更新到字典中

          4. 查询:
            通过key来查询
            get(key, default)
            setdefault(key, value)
          5. 常用操作
            keys() 获取所有的key
            values()获取所有的value
            items() 获取所有的键值对(key, value)

            可以进行for循环
              for key in dict:
                print(key, dict[key])

              for key in dict.keys():
                print(key, dict[key])

              for value in dict.values():
                print(value)

              for k, v in dict.items():
                print(k,v)

            len() 计算键值对的个数

            字典在迭代的时候不可以改变大小把要删除的key保存在列表中. 循环列表. 删除字典

            dict.fromkeys(key, value)
              1. 返回给你新列表.
              2. 所有的key公用同一个value

            推导式: {key: value for循环 if}

        6.tuple元组:
          不可变.不可变指的是第一层基本上没有操作 count()  index()   len(): __len__()   可迭代    for 循环

        7.set 集合
          无序, 不重复, 可哈希(元素)
          去重.
          也可以循环.
          fronzenset() 冻结的集合, 不可变, 可哈希

          基本语法:
            运算符:
              1. 算数运算: +-*/ // % **
              2. 比较运算:> < == >= <= != <>
              3. 逻辑运算:
                and 并且的含义. 左右两端必须同时为真. 结果才能是真
                or 或者. 左右两端有一个是真. 结果就是真
                not 非. 非真既假, 非假既真

                顺序:() => not => and => or
                a or b
                如果a非零。 返回a。 否则返回b
                and和or相反
                a and b
                如果a非零。 返回b。 否则返回0
              4. 赋值运算
                += -= *= /= %=
                a+=b a = a + b

              5. 成员运算
                xxx in xxxx
              6. is和 ==
                is: 比较的是内存地址
                ==: 比较的是值
                小数据池(常量池): 会对str, int, bool进行缓存. 节省内存. 方便调用.

              print(打印的内容, xxx, end="结束符", sep="分隔符")
              str = input("提示") 用户交互


        8.文件操作
          open(文件路径, mode="模式", encoding="编码")
          模式: r, w, a, r+, w+, a+, rb, wb, ab
          for循环可以迭代文件句柄. 拿到的是一行一行的内容   for line in f
          seek()移动光标
          tell()查看光标位置

          with open(xxxx) as f:
          操作

           文件修改:
            从源文件中读取内容. 修改, 然后写入到新文件中. 删除源文件. 重命名新文件

        函数部分:
          函数: 对功能或者动作的封装 类中的函数一般是方法
          语法:
            def 函数名(参数):
              函数体(return)

            ret = 函数名(实参)

          函数名: 函数名就是一个变量名. 可以进行赋值. 可以作为参数, 可以作为返回值. 还可以作为集合类的元素
          参数:
            给函数传递的信息
            1. 形参:
              在函数声明的位置定义的变量.
            分类:
              1. 位置参数
              2. 默认值参数, 共享
              3. 动态传参
                1. *args 动态接收位置参数
                2. **kwargs 动态接收关键字参数
                *,** 在形参位置表示聚合
                *,** 在实参位置表示打散
              顺序:
                位置, *args, 默认值, **kwargs

              def func(*args, **kwargs): 无敌传参
                pass

            2. 实参:
              在函数调用的时候给函数传递的具体的值.
            分类:
              1. 位置参数
              2. 关键字参数
              3. 混合参数. 位置在前, 关键字在后
            3. 传参:
              把实参传递给形参的过程叫传参

            名称空间:
              1. 内置名称
              2. 全局名称
              3. 局部名称
            作用域:
              1. 全局作用域
              2. 局部作用域
              globals() 查看全局作用域中的内容
              locals() 查看当前作用域中的内容

              global 在局部引入全局变量, 创建全局变量
              nonlocal 在局部, 引入离他最近的上一个变量

          闭包: 内层函数访问外层函数中的变量. 最好是返回内层函数
            作用:
              1. 保护变量不被更改
              2. 可以让一个变量常驻内存

            def func():
              a = 10
              def inner():
                return a
              return inner
          迭代器:
            可迭代对象: 在数据类型中包含了__iter__.
            迭代器: 访问__iter__可以获取到该数据类型的迭代器. 包含__iter__和__next__

            特点:
              1. 省内存
              2. 惰性机制
              3. 只能向前
            模拟for循环
              lst = []
              it = lst.__iter__() # iter(lst)
              while 1:
                try:
                  it.__next__() # next(it)
                except StopIteration:
                  break

          生成器:
            生成器的本质是迭代器
            生成器有三种方式来创建:
              1. 生成器函数
              2. 生成器表达式
              3. 类型转换(range())
            生成器函数:
              生成器函数中包含yield
              yield表示返回. 可以分段的执行函数

              生成器函数在被调用的时候. 获取生成器. 而不是执行函数
              def func():
                yield xxxx
              func() # 获取生成器

            生成器使用:
              1. __next__() 执行到下一个yield
              2. send() 可以给上一个yield传值

            yield from:
              把一个可迭代对象转换成生成器

            生成器表达式:
              (结果 for if)

          内置函数: 68个.

            lambda:
              匿名函数
              lambda 参数: 返回值

  • 相关阅读:
    9、Spring Boot 2.x 集成 Thymeleaf
    【专题】Spring Boot 2.x 面试题
    8、Spring Boot 2.x 服务器部署
    7、Spring Boot 2.x 集成 Redis
    6、Spring Boot 2.x 集成 MyBatis
    5、Spring Boot 2.x 启动原理解析
    4、Spring Boot 2.x 自动配置原理
    3、Spring Boot 2.x 核心技术
    2、Spring Boot 2.x 快速入门
    centOS下安装JDK1.8.60,glassfish4.1.1以及MySQL
  • 原文地址:https://www.cnblogs.com/sophie99/p/9687166.html
Copyright © 2011-2022 走看看