• [PY3]——基本语法


    Python3基本语法-xmind图

    常量/变量

    1. 常量:一旦赋值就不可再改变。不能对它重新赋值。python不存在常量
    2. 字面常量:一个单独出现的量,未赋值给任何变量或常量
    3. 变量:

    i=3
    print(i)
    3

    类型系统

    1. python是动态类型语言:指的是变量可以重新赋值为其他类型

    In [5]: i=4;type(i)
    Out[5]: int
    In [6]: i='4';type(i)
    Out[6]: str

    2. python是强类型语言:强类型指的是不同类型之间不能相互计算

    In [7]: 4+'4'
    TypeError: unsupported operand type(s) for +: 'int' and 'str'

    3. python中一切都是引用,所以一切都是指针

    4. python的基本类型:

    (1)int整型:python里面可以说int型没有溢出,而只受限于物理内存

    In [8]: i=1000000000000000000000000000000000000000000000000000000000000000000000
       ...: 000000000000000000000000000000000000000000000000000000000000000000000000
    In [9]: type(i)
    Out[9]: int
    In [10]: i**2
    Out[10]: 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

    (2)float浮点型:(py3里面没有double类型),浮点型会损失精度

    In [11]: type(1.0)
    Out[11]: float
    In [12]: type(3.14159)
    Out[12]: float

    (3)bool布尔型:True Flase
    (4)none:None指的是没有指向任何内存

    运算符

    1. 算术运算符:

    # 算术运算符只能对int和float运算,int会隐式转换成float
    # +  加
        In [5]: 1+1.0
        Out[5]: 2.0
    
    # -  减
        In [6]: 1-2
        Out[6]: -1
    
    # *  乘
        In [11]: 2*3
        Out[11]: 6
    
    # /  自然除(结果都是float型)
        In [1]: 3/2
        Out[1]: 1.5
        In [2]: type(3/2)
        Out[2]: float
    
    # // 取整除(结果取整故都是int型)
        In [3]: 3//2
        Out[3]: 1
        In [4]: type(3//2)
        Out[4]: int
    
    # ** 求幂
        In [12]: 2**3
        Out[12]: 8
    
    # %  取模
        In [19]: 4%3
        Out[19]: 1

    2. 比较运算符

    # 比较运算返回值都是bool型
    #    >   大于
    #    <   小于
    #    == 等于
    #    !=  不等于
    #    >= 大于等于
    #    <= 小于等于
    In [20]: type(1>2)
    Out[20]: bool
    
    In [21]: 1>2
    Out[21]: False
    
    In [22]: 1<2
    Out[22]: True
    
    In [23]: 1!=2
    Out[23]: True

    3. 逻辑运算符

    # or  或
    # and 且
    # not 非
    # 逻辑运算符的操作数与返回值都是bool类型
    In [24]: True or False
    Out[24]: True
    
    In [25]: True and False
    Out[25]: False
    
    In [26]: not True
    Out[26]: False
    
    In [27]: type(True or False)
    Out[27]: bool
    
    # 所有参与逻辑运算的操作数都会隐式转换成bool类型,其中0和None会隐式转换为False、非0则隐式转换为True
    In [31]: 0 or 1  //0=Flase or 1=True
    Out[31]: 1       //非0=True
    
    # 逻辑运算的短路操作:从左到右执行,当左边的计算已经可以直接得出结果时,将停止计算,提前返回
    In [32]: def true():
                 print('True')
                 return True
    In [34]: def false():
                 print('False')
                 return False
             
    In [35]: true() or false()    
    True                           //or运算时左边为true已可以得到结果,故只执行了true()
    Out[35]: True
    
    In [36]: false() and true()
    False                         //and运算时左边为false已可以得到结果,故只执行了false()
    Out[36]: False
    
    In [37]: false() or true()   //左边还不能得到结果的时候,true()和false()都执行了
    False
    True
    Out[37]: True

    4. 成员运算符

    #用于判断一个元素是否在容器中(和集合类型有关)
    # in       在
    # not in 不在
    In [43]: 3 in [1,2,3,5]
    Out[43]: True
    
    In [46]: 'a' not in 'love python'
    Out[46]: True
    
    In [47]: 10 in (0,2,8,11)
    Out[47]: False
    
    In [44]: 10 in {0,2,8,11}
    Out[44]: False
    
    # 集合的成员运算远高于其他线性结构做成员运算
    
    # 列子1:
    In [49]: lst=list(range(1000000));
    In [50]: s=set(range(1000000));
    
    In [51]: %%timeit
        ...: -1 in lst
    100 loops, best of 3: 13.1 ms per loop
    
    In [52]: %%timeit
        ...: -1 in s
    The slowest run took 28.53 times longer than the fastest. This could mean that an intermediate result is being cached.
    10000000 loops, best of 3: 44.6 ns per loop
    
    #例子2:
    In [53]: lst2=list(range(100))
    In [54]: s2=set(range(100))
    
    In [55]: %%timeit
        ...: -1 in lst2
    1000000 loops, best of 3: 1.36 us per loop
    
    In [56]: %%timeit
        ...: -1 in s2
    The slowest run took 26.28 times longer than the fastest. This could mean that an intermediate result is being cached.
    10000000 loops, best of 3: 46.3 ns per loop
    
    # 通过下面的例子我们可以得到如下结论:
    # 做成员运算时,
    #   *集合的时间复杂度是O(1),其效率和集合的规模无关 ==>当规模大时我们转化为集合来做运算效率会高很多
    #   *线性结构的复杂度是O(n),其效率和列表的规模有关 ==>当规模小时其实线性结构的效率未必不会更好

    5. 身份运算符

    # 面向对象

    6. 位运算符

    # 位运算符是直接操作二进制的
    # <<
    # >>
    # &
    # |
    # ^

    7. 赋值运算符    

    # 赋值运算符是可以和算术运算符、比较运算符、位运算符一起使用   
    In [12]: a=1+2;print(a);type(a)
    3
    int
    
    In [13]: a=1>2;print(a);type(a)
    False
    bool
    
    In [14]: a=True or False;print(a);type(a)
    True
    bool

    8. 运算符优先级

    算术运算符>比较运算符>逻辑运算符
    可以通过使用括号来改变优先级

    程序结构

    1. 顺序结构

    2. 分支结构

    (1)单分支                                                                                              (2)双分支                                                            

                                  

    (3)多分支

    # 单分支    
    开始

    if 条件:

    操作

    结束
    In [1]: a=5 In [2]: if a<10: print('a less then 10') # 双分支双分支结构里,永远只有一个分支会被执行
    开始

    if 条件:

    操作1

    else:

    操作2

    结束
    In [3]: a=5 In [4]: if a<10: print(a,'less then 10') else: print(a,'great then 10') # 多分支多分支结构里,永远只有0个或1个分支会执行条件只能是bool类型或者是可以隐式转化为bool类型的 In [5]: a=50 In [6]: if a<10: print('a<10') elif a<20: print('a<20') elif a<30: print('a<30') else print('a>30')

    3. 循环

    (1)while循环                                                            (2)for in循环

                          

    # 一定要有某种机制修改调制使其退出循环,通常是在循环体里修改条件
    # for in 循环里永远不要修改可迭代对象()
    # 如何选择使用哪种循环?
    对已知的可迭代对象做遍历,选择for in
    对未知的条件做循环,选择while
    # while循环
    开始

    while 条件:

    操作

    结束
    In [18]: i=0 In [19]: while i<10: print(i) i+=2 0 2 4 6 8 # for in循环
    开始

    for 元素 in 可迭代对象:

    操作

    结束
    In [62]: for i in range(0,10,2): print(i) 0 2 4 6 8

    4. 提前终止与跳过

    # break 和 continue只针对最近的一层
    # break和continue只能用在循环里
    
    # break
    In [66]: for i in range(0,3):
        ...:     for j in range(0,5):
        ...:         if j>2:
        ...:             break
        ...:         print('i={},j={}'.format(i,j))
        ...:
    i=0,j=0
    i=0,j=1
    i=0,j=2
    i=1,j=0
    i=1,j=1
    i=1,j=2
    i=2,j=0
    i=2,j=1
    i=2,j=2
    
    # continue
    In [67]: for i in range(0,3):
        ...:     for j in range(0,5):
        ...:         if j!=2:
        ...:             continue
        ...:         print('i={},j={}'.format(i,j))
        ...:
    i=0,j=2
    i=1,j=2
    i=2,j=2

    5. else子句(python中else可以和循环语句一起使用)

    # 当循环没有被break(被中断/提前退出)时,会执行else子句
    In [68]: for i in range(0,5):
        ...:     pass
        ...: else:
        ...:     print('not exit')
        ...:
    not exit
    
    In [69]: for i in range(0,5):
        ...:     continue
        ...: else:
        ...:     print('not exit')
        ...:
    not exit
    
    In [70]: for i in range(0,5):
        ...:     break
        ...: else:
        ...:     print('not exit')
        ...:




  • 相关阅读:
    自考-信息系统开发与管理(一)首篇概述
    html乱码问题
    Failed to create client: error while trying to communicate with apiserver: 报错解决
    Helm(bitnami)部署zookeeper和kafka集群
    Helm部署RabbitMQ集群
    Kubernetes通过插件,自动发现注册Rabbitmq集群
    Kubernetes使用operator安装Redis集群
    Kubernetes部署单Redis
    Kubernetes搭建RooK+Ceph
    Kubernetes的服务质量(QoS)
  • 原文地址:https://www.cnblogs.com/snsdzjlz320/p/6555476.html
Copyright © 2020-2023  润新知