03_Python基础语法

1.表达式(expression)

    1.表达式由数字或数字和运算符组成
    2.通常是让计算机做一些事情并返回结果,例如: 1 + 2 * 3  # 结果为7
    3.括号分组子表达式: 用()可以将表达式分组,()内部的表达式先进行计算,例如: (1 + 2) * 3  # 结果为9
    4.混合类型返回值类型自动升级,例如: 1 + 2.14  # 返回值3.14类型为浮点型

2.运算符(operator)

1.算术运算符(+ - * / // % **)

        +(加法): 10 + 10  # 20
        -(减法): 20 - 10  # 10
        *(乘法): 10 * 10  # 100
        /(除法): 10 / 30  # 0.3333333333333333(python中的除法不会丢掉小数部分)
        //(地板除): 7 // 3  # 2
        %(取余): 7 % 3  # 1
        **(幂运算): 5 ** 2  # 25
        算数运算符的优先级:
            (高) **
            (中) * / // %
            (低) + -

2.复合赋值算术运算符(+= -= *= /= //= %= **=)

        y += x  等同于 y = y + x
        y -= x  等同于 y = y - x
        y *= x  等同于 y = y * x
        y /= x  等同于 y = y / x
        y //= x 等同于 y = y // x
        y %= x  等同于 y = y +% x
        y **= x 等同于 y = y +** x

3.比较运算符(< <= > >= == !=)

        <   小于
        <=  小于等于
        >   大于
        >=  大于等于
        ==  等于
        !=  不等于
        语法: 左表达式 < 右表达式  # 比较运算符返回布尔类型的值

4.布尔运算符(not and or)

        1.布尔运算符也常被叫做逻辑运算符
        2.布尔非运算 not
            语法: not x  # 对x进行布尔取非,bool(x)为True则返回False,否则返回True
            示例:
                not True  # 返回False
                not False  # 返回True
                not 0  # 返回True
                not 2  # 返回False
        3.布尔与运算 and
            语法: x and y  # 优先返回假值对象,单x的布尔值为False时返回x,否则返回y
            示例1:
                True and True  # 返回True
                True and False  # 返回False
                False and False  # 返回False
                False and True  # 返回False
                1 and 2  # 返回2
                0 and 2  # 返回0
                1 and 0  # 返回0
            示例2:
                x = int(input("请输入月份:") or "0")  # or "0"避免输入空字符串时程序报错
                if x >= 1 and x <= 12:
                   print("合法的月份")
                else:
                   print("您输入的月份不合法")
        4.布尔或运算 or
            语法: x or y  # 优先返回真值对象,当x为True时返回x,否则返回y
            示例1:
                True or True  # 返回True
                True or False  # 返回True
                False or False  # 返回Flase
                False or True  # 返回True
                1 or 2  # 返回1
                0 or 2  # 返回2
                1 or 0  # 返回1
            示例2:
                x = int(input("请输入月份:") or "0")  # or "0"避免输入空字符串时程序报错
                if x < 1 or x > 12:
                   print("您输入的月份不合法")
                else:
                   print("合法的月份")
        5.布尔运算符优先级
            在没有()的情况下,not优先级高于and,and优先级高于or,同一优先级时从左到右计算
            优先级顺序: () 高于 not 高于 and 高于 or

5.正负号运算符(+ -)

        正号/负号运算符是一元运算符即只有一个元素参加运算
        语法:
            +表达式
            -表达式
        示例:
            a = -5
            b = -a
            c = +a
            d = (2-3j)  # type(d)为复数complex
            e = -d  # (-2+3j)

6.身份运算符(is is not)

        is: 判断两个对象是否是同一个对象,如果是同一个对象返回True,否则返回False
        is not: 判断两个对象是否是同一个对象,如果是同一个对象返回False,否则返回True
        语法示例:
            x = 1
            y = x
            x is y  # True
            x is not y  # False

7.成员运算符(in not in)

        if 1 in [1, 2, 3]:
            print("1在列表中")  # 1在列表中

        for i in range(10):
            print(i, end=",")  # 0,1,2,3,4,5,6,7,8,9,

        if "e" not in "abcde":
            print("ok")
        else:
            print("no")  # no

8.按位运算符(& | ^ ~ << >>)

        1.按位运算符是把数字看作二进制来进行按位计算
        2.按位与运算符 &
            参与运算的两个值如果两个相应位都为1,则该位的结果为1,否则为0
            60 & 13  # 输出结果为12,二进制解释: 0000 1100
        3.按位或运算 |
            只要对应的两个二进制有一个为1时,结果位就为1
            60 | 13  # 输出结果为61,二进制解释: 0011 1101
        4.按位异或运算符 ^
            当两个对应的二进制位相异时,结果位就为1
            60 ^ 13  # 输出结果为49,二进制解释: 0011 0001
        5.按位取反运算符 ~
            对数据的每个二进制位取反,即1变0,0变1,~x类似于-x-1
            ~60  # 输出结果为-61,二进制解释: 1100 0011,一个有符号二进制数的补码形式
        6.左移动运算符 <<
            运算符的各二进制位全部左移若干位,由<<右边的数字指定移动的位数,高位丢弃,低位补0
            60 << 2  # 输出结果为240,二进制解释: 1111 0000
        7.右移动运算符 >>
            运算数的各二进制位全部右移若干位,由>>右边的数字指定移动的位数,低位丢弃,高位补0
            60 >> 2  # 输出结果为15,二进制解释: 0000 1111
        示例:
            a = 60  # 0011 1100
            b = 13  # 0000 1101

            a & b  # 12 = 0000 1100
            a | b  # 61 = 0011 1101
            a ^ b  # 49 = 0011 0001
            ~a  # -61 = 1100 0011
            a << 2  # 240 = 1111 0000
            a >> 2  # 15 = 0000 1111

9.运算符优先级总结

        1.逻辑运算符(and or not)        优先级小于   比较运算符(< <= > >= !=)
        2.比较运算符(< <= > >= !=) 优先级小于   算术运算符(+ - * / // % **)
        3.正负号运算符(+ -)               优先级仅次于 **

3.常量(constant)

    概述: 在python中不存在绝对的常量,一种约定俗成全部字母大写,单词与单词之间使用_下划线连接,None是一个特殊的常量
    示例: PI = 3.141592654

4.变量(variable)

1.变量概述:

        1.变量是关联一个对象的标识符(符号),用来绑定一个数据对象用于重复使用
        2.Python中定义变量不需要知道变量的类型,在运行时Python解释器会根据变量右侧的数据自动推导出数据类型
        3.变量名的查找规则(由内到外的顺序查找): 查找本地变量-->查找包裹此函数的外部嵌套函数内部的变量-->全局变量-->内置变量

2.变量的命名规范

        1.变量必须以字母(a-zA-Z)或下划线(_)开头,后面跟字母下划线或数字(0-9)
        2.不能使用python的关键字(保留字),不能使用中文
        3.变量名区分大小写,变量的命名要有意义,即见名知意
        4.驼峰和下划线命名
            1.小驼峰: 第一个单词以小写单词开始,后续单词首字母大写, 例如: fileName listName tcpWebServer
            2.大驼峰: 每一个单词首字母都采用大写字母, 例如: FileName HttpWebServer
            3.下划线: 单词与单词之间使用_下划线连接, 例如: tcp_server http_web_server
        5.PEP8编码规范推荐python中变量命名使用下划线命名法
        6.合法的变量名: a a1 b bbb _aa __ad var get_value Add
        7.不合法的变量名: 1a 123 $A +a -b ### @ABC a1& a#b

3.在交互模式下查看当前作用域内变量的方法

        ipython
        In [1]: help("__main__")
        退出键: q

4.变量的引用

        1.变量和数据都是保存在内存中且分开存储的,数据保存在内存中的一个位置,变量中保存着数据所在内存中的地址
        2.变量中记录数据的地址叫做引用,变量赋值本质上是修改了数据的引用,使用id()函数可以查看变量中保存数据所在内存中的内存地址
        3.变量绑定流程图: https://www.processon.com/view/link/5ed43cf063768906e2d0ce80

5.局部变量local

        1.局部变量是在函数内部定义的变量,在函数调用时才会创建且只能在函数内部使用,在函数执行结束后,函数内部的局部变量会被系统回收
        2.不同的函数可以定义相同的局部变量,彼此间不会产生影响,函数的形参也是局部变量,在函数内部的赋值语句不会对全局变量造成影响
        3.在函数内首次对变量赋值是创建局部变量,再次为变量赋值是修改局部变量的绑定关系
        4.局部变量示例:
            def demo1():
                # 定义一个局部变量,在函数内部的局部变量不能在其他位置使用
                num = 10
                print("在demo1函数内部的变量是%d" % num)


            def demo2():
                num = 11
                print("在demo2函数内部的变量是%d" % num)


            demo1()  # 在demo1函数内部的变量是10
            demo2()  # 在demo2函数内部的变量是11

6.全局变量global

        1.全局变量是在函数外部定义的变量,所有的函数都可以使用,模块内部的变量称为全局变量
        2.函数内部不允许直接修改全局变量的的绑定关系,必须修改时需要使用global声明一下全局变量
        3.在开发时,应该把模块中的所有全局变量定义在所有函数的上方,以保证所有的函数都可以访问
        4.全局变量示例:
            # 全局变量
            num = 10


            def demo1():
                # 在python中不允许直接修改全局变量的值,如果使用赋值语句会在函数内部定义一个局部变量
                num = 12
                print("在demo1函数中变量num值是%d" % num)


            def demo2():
                # 希望修改全局变量的值时,使用global声明一下全局变量即可
                global num
                num = 11
                print("在demo2函数中变量num值是%d" % num)


            demo1()  # 在demo1函数中变量num值是12
            demo2()  # 在demo2函数中变量num值是11

7.Python的作用域

        1.Python的四层作用域流程图: https://www.processon.com/view/link/5eda5b8163768918621ab90d
        2.作用域概述:
            作用域就是一个 Python 程序可以直接访问命名空间的作用区域
            在一个python 程序中,直接访问一个变量,会从内到外依次访问所有的作用域直到找到,否则会报未定义的错误
        3.作用域分类(四个作用域LEGB):
            作用域 ------------------> 英文解释 --------------------> 英文简写
            局部作用域(函数内) -------> Local(function) ---------------> L
            外部嵌套函数作用域 -------> Enclosing function locals ------> E
            函数定义所在模块的作用域 --> Global(module) --------------> G
            Python 内置模块的作用域 --> Builtin(python) ---------------> B
        4.作用域规则顺序: L –> E –> G –>B 在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内置中找
        5.作用域示例:
            g_count = 0  # 全局作用域


            def outer():
                o_count = 1  # 闭包函数外的函数中

                def inner():
                    i_count = 2  # 局部作用域

8.Python的命名空间

        1.命名空间概述:
            命名空间: 当程序执行时将变量与值的关系存放在一个空间中
            临时命名空间: 当程序执行时将变量与值的关系存放在一个空间中,这个空间会随着函数的执行结束而销毁
        2.名称空间分类:
            内置名称(built-in names): Python语言内置的名称,比如函数名abs和异常名称Exception等
            全局名称(global names): 模块中定义的名称,记录了模块的变量,包括函数,类,其它导入的模块,模块级的变量和常量
            局部名称(local names): 函数中定义的名称,记录了函数的变量,包括函数的参数和局部定义的变量(类中定义的也是)
        3.命名空间查找顺序:
            假设我们要使用变量 runoob,则 Python 的查找顺序为: 局部的命名空间 -> 全局命名空间 -> 内置命名空间
            如果找不到变量 runoob,它将放弃查找并引发一个 NameError 异常
        4.命名空间的生命周期:
            命名空间的生命周期取决于对象的作用域,如果对象执行完成,则该命名空间的生命周期就结束
            所以无法从外部命名空间访问内部命名空间的对象
        5.命名空间示例:
            # var1 是全局名称
            var1 = 5
            def some_func():
                # var2 是局部名称
                var2 = 6

                def some_inner_func():
                    # var3 是内嵌的局部名称
                    var3 = 7

5.反斜杠折行符

    语法: 折行符是告诉解释器下一行的内容也是此句的内容,
        PEP8规定每行代码的长度不要超过80个字符

6.隐式换行

    概述: 所有的括号中内容换行时,解释器会自动去下一行找到相应的括号,PEP8规范用一对()让代码成为一个整体,折行后添加4个缩进
    示例:
        if ((1 == 1
                or 2 == 2
                or 3 == 3)):
            print("OK")

7.=赋值语句(statement)

    1.赋值语句概述:
        1.用于将一个变量绑定(关联)在一个对象上,当变量不存在时,会创建该变量并绑定这个对象,当变量存在时,改变这个变量的绑定关系
        2.一个变量只能绑定一个对象,多个变量可以同时绑定同一个对象
    2.赋值语句语法
        变量名 = 表达式
        变量名1 = 变量名2 = 表达式
        变量名1, 变量名2 = 序列
    3.赋值语句示例:
        a = 10
        b = c = 20
        a, b = 100, 200

8.del语句(delete)

    作用: 用于删除变量同时解除与对象的关联关系,如果可能则释放对象
    语法: del 变量名

9.if语句

    作用: 让程序根据条件选择性的执行某条语句或某些语句
    语法:
        if 真值表达式1:
            语句块1...
        elif 真值表达式2:
            语句块2...
        elif 真值表达式3:
            语句块3...
        ...
        else
            语句块4...
    语法说明
        1.真值判断会自上而下进行,如果有一条为True则执行其中语句然后结束if语句的执行
        2.如果所有的真值表达式都为False,则执行else子句中的语句,elif子句可以有0个,1个或多个,但else子句只有0个,或1个

10.语法糖-if条件表达式(三元表达式)

    语法: 表达式1 if 真值表达式 else 表达式2
    作用: 如果真值表达式的布尔值为True则执行表达式1并返回对象的引用,否则执行表达式2并返回对象的引用
    示例1:
        money = int(input("请输入商品金额:"))
        pay = money - 20 if money >= 100 else money
        print("您需要支付:%d$" % pay)  # 输入50结果为50,输入100结果为80
    示例2:
        name = "Coco"
        res = "ok" if name == "Coco" else "error"
        print(res)  # ok

11.pass语句

    作用: 填充语法空白避免程序报错
    示例:
        def func():
            pass

12.while循环语句

    作用: 根据一定条件,重复执行一条语句或多条语句,考虑代码规范计数器从0开始
    语法:
        while 真值表达式:
            语句块1...
        else:
            语句块2...
    while语句嵌套
        while 真值表达式1:
            ...
            while 真值表达式2:
                ...
            else:
                ...
        else:
            ...
    语法说明
        1.先执行真值表达式,测试布尔值为True或False,如果真值表达式为True,则执行语句1,然后返回到第一步重复进行测试
        2.如果真值表达式为False,则执行else子句中的语句块2,然后结束此while语句的执行
        3.如果真值表达式为False时没有else子句则直接结束while语句执行(else子句部分可以省略)
    while语句注意事项
        1.要控制循环的真值表达式的值来防止死循环,通常用真值表达式中的循环变量来控制循环条件
        2.通常在循环语句块内需要修改循环变量来控制循环的次数和变量的走向
        3.while循环中当循环条件为假时执行else子句部分,break跳出循环则不会执行else子句部分

13.for循环语句

    作用: 用来遍历可迭代对象的数据元素,考虑代码规范计数器从0开始
    语法:
        for 变量列表 in 可迭代对象:
            语句块1...
        else:
            语句块2...
    语法说明:
        1.可迭代对象每次提供一个元素依次赋值给变量列表中的变量,赋值完毕后执行语句块1,依次类推执行
        2.当可迭代对象不能够提供数据时,执行else子句部分的语句块2,然后退出循环,else子句部分可以省略
        3.当在语句内部用break终止循环时,else子句部分语句块2不会执行

14.死循环

    概述: 死循环是指循环条件一直成立的循环,死循环的else语句永远不会执行,死循环通常用break语句来终止循环
    避免方法: 配合if判定和break跳出循环,如果是在递归中,首先要写好递归出口

15.break跳出语句

    作用: 用于循环语句(while或for)语句中,用来终止当前循环语句的执行
    语法说明:
        1.当break语句执行后,循环语句break之后的语句将不再执行,break终止时,循环语句else子句将不再执行
        2.break语句只能终止当前循环的执行,如果有循环嵌套时,不会跳出嵌套的外层循环
        3.break语句只能在循环语句(while或for)语句内部使用,break通常和if语句组合使用

16.continue跳过语句

    作用: 用于循环语句(while语句,for语句)中,不再执行本次循环内continue之后的语句,重新开始新的一次循环
    语法说明:
        1.在while语句中执行continue语句将直接跳转到while语句的真值表达式处重新开始循环条件
        2.在for语句执行continue语句将会从可迭代对象中取下一个元素,绑定变量后再次进行循环

17.input基本输入函数

    语法: 从标准输入的设备上读取一个字符串,末尾的换行字符会被自动删除
    示例: s_str = input("提示字符串")  # 返回一个字符串用变量绑定,提示字符串可以为空

18.print基本输出函数

    语法:
        print("要打印的东西")
        print(1, 2, sep=" ", end=" ")
        关键字参数:
            sep: 两个值之间的分隔符,默认位一个空格" "
            end: 输出完毕后在末尾自动追加一个字符串,默认为换行符" "
    示例:
        print("hello world!")  # hello world!
        print(1 + 2 + 3)  # 6
        # 多个数据打印时使用逗号隔开
        print(1 + 5, 3 + 3, 6)  # 6 6 6

19.id函数

    语法: id(x) # 返回一个对象在内存中的地址
    示例:
        a = 10
        id(a)  # 4302659632

20.help函数

    语法: help(function)  # 查看函数的帮助文档
    示例: help(abs)  # 查看abs函数的帮助文档,q退出查看

21.数值对象构建函数-float, int, complex, bool

    float(obj)              用字符串或数字转换为浮点数,不给参数则则返回 0.0
    int(x="0", base=10)     用数字或字符串转换为整数,不给参数则返回 0
    complex(r=0.0, i=0.0)   用数字创建一个复数(实部为r,虚部为i),不给参数则返回 0j
    bool(x)                 用x创建一个布尔值(True/Flase),不给参数则返回 False

22.预置的数值函数-abs, round, pow

    abs(x)  # 取x的绝对值
    round(number, ndigits)  # 对数值进行四舍五入,ndigits是小数向右取整数的位数,负数表示向左取整,不能用于高精度运算
    # 小数位大于5进位小于等于5舍去
    round(4.5)  # 4
    round(4.5001)  # 5
    pow(x, y, z=None)  # 相当于 x**y 或 x**y%z

23.字符串构建函数-str

    作用: 将对象转换为字符串
    语法: str(obj="")
    示例: str(123)  # '123'

24.字符串编码转换函数-ord, chr

    ord(c): 返回一个字符为Unicode值
    chr(i): 返回i这个值所对应的字符
    示例:
        i = ord("C")
        print(i)  # 67
        c = chr(67)
        print(c)  # C

25.整数转换为字符串函数

    hex(i): 将整数转换为十六进制字符串 hex(15)  # '0xf'
    oct(i): 将整数转换为八进制字符串    oct(15)  # '0o17'
    bin(i): 将整数转换为二进制字符串    bin(15)  # '0b1111'

26.常用的序列函数-len, max, min, sum, any, all, str, list, tuple, reversed, sorted

    len(x): 返回序列的长度
    max(x): 返回序列的最大值元素
    min(x): 返回序列的最小值元素
    sum(x): 返回序列中所有元素的和(元素必须时数值类型)
    any(x): 真值测试,如果容器内有一个布尔值为True则返回True,否则返回False
    all(x): 真值测试,容器内所有元素的布尔值为True则返回True,否则返回False
    str(object): 将对象序列化为字符串
    list(iterable): 将可迭代对象序列化为列表
    tuple(iterable): 将可迭代对象序列化为元组
    reversed(seq): 返回反向顺序的迭代器对象
    sorted(iterable, reverse=False): 返回以排序的列表,默认值False为升序,True为降序

27.range函数-整数序列生成器

    作用: 用来创建一个生成一系列整数的可迭代对象
    语法:
        range(stop)  # 从零开始,每次生成一个整数后加1操作,直到stop为止(不含stop)
        range(start, stop, step)  # 从start开始,每次生成一个整数后移动step(step可为负数),直到stop为止(不含stop)
    示例:
        range(4)  # 生成 0 1 2 3
        range(3, 6)  # 生成 3 4 5
        range(1, 10, 2)  # 生成 1 3 5 7 9
        range(5, 0, -2)  # 生成 5 3 1
        range(4, 1)  # 空

28.赋值(不拷贝),浅拷贝(shallow copy)和深拷贝(deep copy)

1.赋值: 赋值操作时实际上是引用内存地址的赋值

        变量赋值流程图: https://www.processon.com/view/link/5ed43cf063768906e2d0ce80
        示例:
            list1 = [1, 2, 3, 4]
            list2 = list1  # 此时内存中只有一个列表,两个变量指向一个列表
            list2.append(5)  # 对其中一个列表操作,另一个列表也跟着改变
            print(list1)  # [1, 2, 3, 4, 5]
            print(list2)  # [1, 2, 3, 4, 5]

2.浅拷贝(copy): 在复制过程中只复制一层变量,不会复制深层变量绑定的对象的过程

        浅拷贝流程图: https://www.processon.com/view/link/5ed7c7426376891862152182
        示例1:
            li = [3.1, 3.2]
            li1 = [1, 2, li]  # [1, 2, [3.1, 3.2]]
            li2 = li1.copy()  # [1, 2, [3.1, 3.2]]浅拷贝
            li1.append(3)
            print(li1)  # [1, 2, [3.14, 3.2], 3]
            print(li2)  # [1, 2, [3.14, 3.2]]
            li[0] = 3.14
            print(li1)  # [1, 2, [3.14, 3.2], 3]
            print(li2)  # [1, 2, [3.14, 3.2]]
            # li[2]和li2[2]共同拥有li绑定的对象
        示例2:
            a = [1, 2]
            a[1] = a
            print(a)  # [1, [...]]

3.深拷贝(deepcopy): 在复制过程中复制所有层级,深拷贝通常只对可变对象进行深层复制,不可变对象通常不会复制

        深拷贝流程图: https://www.processon.com/view/link/5ed7d80e5653bb6c309b719a
        示例:
            import copy  # 导入copy模块

            li = [3.1, 3.2]
            li1 = [1, 2, li]  # [1, 2, [3.1, 3.2]]
            li2 = copy.deepcopy(li1)  # [1, 2, [3.1, 3.2]]深拷贝
            li[0] = 3.14
            print(li1)  # [1, 2, [3.14, 3.2]]
            print(li2)  # [1, 2, [3.1, 3.2]]此表不受影响