变量不说“定义”!

使用变量 “ 变量名称 = 变量类型 ”

a = {'name':'tom','sex':'wm'}

变量命名规范:

首字母不能是数字,字母数字下划线组合,_1 = 1 是合法的
注意:保留字不能用,但函数名可以用,但不要用!
type = 1;不报错,但是type(1)时则报错!
变量是动态赋值,num = 1; num = True 是合法的

变量接收的赋值类型,后续操作若操作引用类型,则源头修改,下游皆改

对一般赋值·后来者与数据源无关   [值类型]
    a = 1;b = a;a = 2;          print(b) = 1
    a = 'a';b = a;a = 2;        print(b) = 'a'
    a = (1,2);b = a;a = 2;      print(b) = (1,2)
对于传递后修改了数据源的动态类型,那么则会传导!!    [引用类型]
    a = [1,2];b = a;a[0] = 2;   print(b) = [2,2]    //注意!
    a = (1,2);b = a;a[0] = 2;   print(b)            //会报错
总结:(两类型与是否为序列无关)
    值类型:    字符串str、整形int、元组tuple
    引用类型:  列表list、集合set,字典dict

对于字符串(字符串是值类型,不可改变)相加:

对于a = '1',a += '2' 结果为'12',其并不是原串的改变
    >>> a = '1'     id(a) = 10322752    初始赋值的内存地址
    >>> a += '2'    id(a) = 55621088    相加后a的地址发生改变
上述结果不违背str是值类型,故'string'[0] = 'a',是错误的!

tuple list的区别

访问:
    两者均可通过Array[id]访问元素,并可以多维访问[i][j]
    a = (1,2,[3,4,[5]]);    a[2][2][0] = 5
赋值:
    列表list:
        >>> a = [1,2,3]     hex(id(a)) = '0x34d2f48'
        >>> a[0] = 2        hex(id(a)) = '0x34d2f48'
    元组tuple:
        >>> a = (1,2,3) a[0] = 2 这是错误的,因为元组是值类型
    注意:对于元组中的可变类型,依然可以动态修改
        >>> a = (1,2,[3,4,[5]]) a[2][0] = 8;
        >>> a = (1,2,[8,4,[5]]) 正常完成修改
追加元素:
    列表list:
        >>> b = [1,2]    b.append(4)  b = [1, 2, 4]
    元组tuple:
        值类型,没有append方法
总结:列表是动态的,元组定义后不可变的,这是针对元素的说法,
      与包装外皮无关,比如元组中的列表依然可以修改

运算符

python特有的运算符
    算术运算符
        +       'a' + 'b' = 'ab'
        -       {1,2} - {1} = {2}
        *       [1,2] * 2 = [1,2,1,2]
        /       3/2 = 1.5 3//2 = 1
        %       5 % 2 = 1           取余
        **      2 ** 2 = 4          N次方
    赋值运算符          
        *=      算数运算符后跟等号
                python没有自增运算符,i++ 是错误的
    比较、关系运算符    
        ==      比较两个类型是否相等,
                对于元组等复杂类型,元素类型相同时可以比较长度
                返回结果是bool类型!
    逻辑运算符          
        and     True and True = True            且
        or      False or False = False          或
        not     单目运算符:not False = True    非
                返回值不一定是bool类型的形式!
    成员运算符          
        in      在,一个元素是否在另外一组元素
        not in  不在
                返回值为bool类型!
    身份运算符          
        is      (object)
        is not  (object)
                返回值为bool类型!
    位运算符
        &       按位与,双目
        |       按位或
        ^       按位异或
        ~       按位取反
        <<      左移
        >>      右移
                注意:均会转化为二进制数运算

运算符结合顺序:从右往左
    b = 1, b+=b>=1 即 b = b + True

复杂类型的比较:
    'a' > 'b' = False       因为 ord('a') < ord('b')
    'ab'> 'aa'= True        字典比较
    [1,2] < [2,3] = True    相同的按元素比较
    (1,2) < (2,3) = True    同上,注意 (1,2) < (2,1) = True
    对于动态类型列表和集合{},其不能比较,返回值均为false

复杂类型逻辑运算:
    not 0 = True
    not 'a' = False 
    本质只能操作bool类型,整形和字符串都能转换为bool类型
    转换规则:
        对于int,float,0被认为是False,其余均是True
        对于str,空串''被认为是False,其余均是True
        对于list,空列表[]被认为是False,其余均为True
        其余类似
        [] or [1] = [1] 返回的是True值的形式,但不一定是bool型
        '' and 'a' = '' 返回False值的形式,''即为False形式
        注意:
            1 and 2 = 2, 2 and 1 = 1 必须检测后者,就近返回
            1 or 2  = 1, 2 or 1 = 2  此处只需看前者,就近返回

复杂成员运算:
    对于非数值类型,str、tuple、list、set、dict判断元素在不在
        对于除字典以外:'a' in (1,(1,'a')) = False,只
        对于dict:只能检查key值在不在,不能检查value
    对于数值类型,包括int、float、bool,不能使用,否则会报错

身份运算符:
    与关系运算符 == 无关!
    身份符比较的是身份!身份:暂时理解为内存地址的比较
    >>> 1 is 1 = True        值类型
    >>> {1} is {1} = False   引用型
    >>> (1,2) == (2,1) False 序列,位置固定,按位置比较
    >>> (1,2) is (2,1) False 内存不同
    >>> {1,2} == {2,1} True  无序集合,表示内容相同!不说‘相等’!
    >>> {1,2} is {2,1} False 内存不同

对于两个变量、或对象的三特征:值(==)、身份(is)、类型(isinstance)    
    a = 'hello', type(a)==str是True,这种方式不推荐
    注意:
        上述方法不能判断a的子类是否是str
        下面的方法可以判断a的子类是不是某种类型
    判断对象类型:
        isinstance(a,str) = True
        isinstance(a,(int,str))) = True 可以一次判断多种类型

位运算符
    按位与      2 & 3 = 0b10 & 0b11 = 0b10 = 2    
    按位或      2 | 3 = 0b10 & 0b11 = 0b11 = 3
    按位异或    2 ^ 3 = 0b10 & 0b11 = 0b01 = 1

表达式

表达式 Expression = 运算符 operator + 操作数 operand
注意:
    上述运算符,包括上一节中的七大运算符
    运算符都有优先级顺序:1 or 2 and 3 = 1 or (2 and 3) = 1 or 3 = 1 
    括号优先级最高!然后是次幂运算
    详细优先级可查
    执行顺序原则:
        不同优先级:按优先级进行先后计算
        相同优先级:解释器从左向右解释(左结合),
        上述比较的是优先级,而不是运算符类型,自定义顺序推荐用(括号)
        对于 = :
        其优先级高于or,但是a = 1 or 0,则会先计算or,不会按优先级顺序


上述叫做基本类型与基本概念 命令行操作
正经编程开发,需要使用文件,在cmd中用   python file.py 运行
常用IDE:
    pycharm     复杂项目首选,自动化步骤,功能强大
    vscode      初学推荐 
    sublime

vscode:
    ctrl+` 弹出终端,目录可能不对,点击文件,在终端中即可打开
    零插件即可运行python代码
    智能感知(完整需要安装插件python、terminal)、断点调试
    语句不强制要求加分号,不需要加大括号,不建议使用分号
    注意:
        Python是使用‘缩进’来区分代码段,不能压缩,开源友好
        #单行注释
        三引号:多行注释