python学习（一）数据类型和运算符

目录

1、print（）函数

2、转义字符与原字符

        2.1 转义字符

        2.2 原字符

3、 二进制与字符编码

        3.1.字节和位

        3.2 字节和字符

        3.3 chr()函数与ord()函数

4、python中的标识符和保留字

        4.1 保留字

        4.2 标识符

5、变量的定义和使用

        5.1 变量

6、python中常见的数据类型

          6.1 整数类型

        6.2 浮点类型

        6.3 bool类型

        6.4 字符串类型

7、数据类型转换

        7.1类型转换str()和int()函数

8、python中的注释

9、input函数的使用

        9.1 输入函数input()

        9.2 input（）函数的高级使用

10. python中的运算符

        10.1 算术运算符

        10.2 赋值运算符

        10.3 比较运算符

        10.4 布尔运算符

        10.5 位运算符

11. 运算符的优先级

---

1、print（）函数

双引号和单引号是直接告诉计算机，不用去理解是什么意思，直接去输出就好了。

print('hello world')
print("yes")

#含有运算符的表达式
print(3+1)
print('3+1')

#结果：
hello world
yes
4
3+1

将数据输出在文件中，注意：1、所指定的盘要存在；2、使用file=pq

pq=open('D:\工作\TEST','a+')#a+:如果文件不存在就创建，如果存在就在文件内容的后面继续追加

print('hello',file=pq)

pq.close()

#不进行换行输出 

#不进行换行输出
print('wa','yes','no')
#结果：
wa yes no

2、转义字符与原字符

        2.1 转义字符

        反斜杠+想要实现的转义功能的首字母
        为什么需要转义字符：当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时。必须使用反斜杠对这些字符进行转义

        2.2 原字符

        让转义字符不起作用，原字符就是在字符串之前加上r或者R。但要注意，最后一个字符不能是反斜杠

#转义字符：\n,\t,\b

print('hello\nworld')#\n是换行
print('helloworld')
print('hello\tworld')#\t是制表符，四个代表一个位
print('helloo\tworld')
print('hellooo\tworld')
print('helloooo\tworld')
print('helloooo\bworld')#\b是退格，往回退一个

print('老师说：\"大家哈皮\"')
print('http:\\\www.baidu.com')

#原字符
print(r'hello\nworld')

结果：

#换行后：
hello
world
#换行前：
helloworld
#制表之后
hello	world
helloo	world
hellooo	world
helloooo	world
helloooworld

#使用\将""直接输出

老师说："大家哈皮"

#使用\将\\直接输出
http:\\www.baidu.com

#原字符实现了换行不起作用
hello\nworld

3、 二进制与字符编码

        3.1.字节和位

        位是最小的存储单位，一字节=8位；bit：位；byte：字节

8bit=1byte；1024byte=1kb；1024kb=1MB；1024MB=1GB；1024GB=1TB

0

0

00，01，10，11；两个位组成四种；八位则组成256种（一字节有256种）；对应现实生活中256种符号

        3.2 字节和字符

        在不同的编码格式里，字节和字符的对应关系不同

        1、ASCII码：一个英文字母（不区分大小写）占一个字节的空间；一个中文汉字占两个字节的空间。

        一般为8位二进制数，换算十进制，最小值为0，最大值为255.

        2、UTF-8：一个英文字符等于一个字节，一个中文等于3个字节

        3、Unicode：一个英文等于两个字节，一个中文等于两个字节

        符号：英文标点占一个字节，中文标点占两个字节

        4、UTF-16：一个英文字母字符或一个汉字字符存储都需要2个字节

        5、UTF-32：世界上任何字符的存储都需要4个字节

        字符：a、A、中、+、*、の......均表示一个字符；

        3.3 chr()函数与ord()函数

         chr()函数表示返回一个字符串

        相反ord（）函数就是用来返回单个字符的ascii值（0-255）或者unicode数值（）

        print(chr(0b100111001011000))#0b表示二进制，如果不写，则识别不出来

        print(ord('乘')) print(chr(65))#将整数（十进制）返回为ASCII表中的字符的值

        print(ord('A'))#将字符A返回为ASCII表中的十进制的值

#chr()函数表示返回一个字符串；
#相反ord（）函数就是用来返回单个字符的ascii值（0-255）或者unicode数值（）
print(chr(0b100111001011000))#0b表示二进制，如果不写，则识别不出来；
print(ord('乘'))
print(chr(65))#将整数（十进制）返回为ASCII表中的字符的值
print(ord('A'))#将字符A返回为ASCII表中的十进制的值
#结果：
乘
20056
A
65

4、python中的标识符和保留字

        4.1 保留字

        有一些单词背赋予了特定的意义，这些单词你在给你的任何对象起名字的时候都不能用

比如建立python文件时，取名keyword；

import keyword

print(keyword.kwlist)

        4.2 标识符

        变量、函数、类、模块和其他对象的起的名字就叫标识符

        规则：字母、数字、下划线

               (1) 不能以数字开头

               (2) 不能是我的保留字

               (3) 严格区分大小写

5、变量的定义和使用

        5.1 变量

其值可以改变的量，内存当中带标签的盒子

如：标签在盒子里。name表示标签，玛丽亚是数据，将数据放入这个盒子，=表示赋值运算符

即： name='玛丽亚'  （变量名 赋值运算符 值）： 将值通过赋值运算符放入在带标签的盒子

  变量由三部分组成：

(1)标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取

(2)类型：表示的是对象的数据类型，使用内置函数type(obj)来获取

(3)值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出

        内存分析图

name='玛丽亚'
print('标识:',id(name))
print('类型:',type(name))
print('值:',name)
#结果：
标识: 2654078816432
类型: <class 'str'>
值: 玛丽亚

         变量可以多次赋值，以最后赋值的为最终结果，之前的内存地址（标识/id）变为内存垃圾

name='玛丽亚'
name='小宝'
print(name)
print('标识:',id(name))
print('类型:',type(name))
print('值:',name)

#结果：
小宝
标识: 1853820327120
类型: <class 'str'>
值: 小宝

6、python中常见的数据类型

        整数类型：int->98

        浮点类型：float->3.1415

        布尔类型：bool->True，False

        字符串类型：string->人生苦短，我用Python

注意：在输入变量的时候，如果是同行输入，则注意是“;”分隔；而分行则不用。

        而每输出一个值，都需要用“,”隔开。或者可以用“+”这个连接符来连接，不过如果数据类型不一致的话，需要进行转换，这个在7.1会详细说明。转换的输出代码如下：

print('结果'+str(n1)+'是'+str(type(n1))+'类型'+';'+'\n'+str(n2)+'是'+str(type(n2))+'类型'+';'+'\n'+str(n3)+'是'+str(type(n3))+'类型')

目前还是以“，”分割来先将其输出，代码如下

n1=45;n2='你好';n3=3.12
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
print('结果：',n1,type(n3),n2,type(n2),n3,type(n3))
#结果：
45 <class 'int'>
你好 <class 'str'>
3.12 <class 'float'>
结果： 45 <class 'float'> 你好 <class 'str'> 3.12 <class 'float'>

print('结果',n1,'是',type(n1),'类型',';','\n',n2,'是',type(n2),'类型',';','\n',n3,'是',type(n3),'类型')

#结果：
结果 45 是 <class 'int'> 类型 ; 
 你好 是 <class 'str'> 类型 ; 
 3.12 是 <class 'float'> 类型

          6.1 整数类型

        integer，简称int，可以表示正数、负数和零

        整数的不同进制表示方式：

                十进制->默认的进制

                二进制->以0b开头

                八进制->以0o开头

                十六进制->以0x开头

print('十进制',75)
print('二进制',0b01001011)#表示01001011该二进制，换算的来十进制的结果是什么
print('八进制',0o113)#表示113的八进制，换算得来十进制的结果是什么
print('十六进制',0x4B)#表示4B的十六进制，换算十进制的结果是什么
#结果：
十进制 75
二进制 75
八进制 75
十六进制 75

验证结果：int类型默认为十进制；因为其他进制需以0b/0o/0x来进行换算，但整型却未加，而最终结果却是一致的。

        6.2 浮点类型

        （1）整数部分和小数部分组成

        （2）浮点数存储不精确性：使用浮点数进行计算时，可能会出现小数位数不确定的情况

a1=3.1
a2=3.2
print(a1+a2)
#结果：
6.300000000000001

为了解决这个问题，可以进行如下方法：

        解决方案：导入模块decimal

a1=3.1
a2=3.2
#未导入模块时得计算结果
print(a1+a2)

#导入模块的代码如下：
from decimal import Decimal
print(Decimal('3.1')+Decimal('3.2'))

导入模块后计算就正确了

#未导入前，计算结果偏差
6.300000000000001
#导入模块后，计算结果正确
6.3

但不是所有的浮点数进行相加都会出现不准确性，如：1.1+2.2，其结果就是3.3

a1=1.1
a2=2.1
print(a1+a2)

from decimal import Decimal
print(Decimal('3.1')+Decimal('3.2'))

结果：

3.2
6.3

        6.3 bool类型

        用来表示真（True）或假（False）；布尔值可以转化为整数，true->1;false->0

        为变量赋值时，要使用大写：True，因为如果输入true报错提示未定义

f1=True
f2=False
print(f1,type(f1))
f3=true

结果：

Traceback (most recent call last):
  File "D:\工作\python script\test0\test3.py", line 4, in <module>
    f3=true
NameError: name 'true' is not defined. Did you mean: 'True'?  #f3的true未定义
#这是f1的输出结果
True <class 'bool'>

        bool类型可以转为整数去计算，因为真为1，假为0，验证代码如下：

f1=True
f2=False
print(f1,type(f1))
#bool类型可以转成整数计算：
print(f1+1)#f1是真，表示1+1
print(f2+1)#f2是假，表示0+1

验证结果：

True <class 'bool'>
2
1

        6.4 字符串类型

        字符串类型又被称为不可变的字符序列

        可以使用单引号''，双引号""，三引号''''''或""""""

        单引号和双引号定义的字符串必须在一行

        三引号定义的字符串可以分布在连续的多行

str='人生苦短'
str1="人生苦短"
str2='''好好学习'''
str3='''好好
学习'''
str4="""好好学
习，天天
向上
"""
print(str,str1,str2,str3,str4)

结果：三引号分行写，也分行显示

人生苦短 人生苦短 好好学习 好好
学习 好好学
习，天天
向上

7、数据类型转换

        为什么要将数据类型进行转换，因为这是为了让不同的数据类型连接在一起。

        7.1类型转换str()和int()函数

str和int不能直接连接，如果直接连接则会报错

name='张三'
age=20
print(type(name),type(age))#得出name和age的数据类型不相同
print('我是'+name+'我今年'+age+'岁')#所以用+（这个连接符）去连接的话，就会报错

报错结果如下：

Traceback (most recent call last):
  File "D:\工作\python script\test0\test3.py", line 5, in <module>
    print('我是'+name+'我今年'+age+'岁')
TypeError: can only concatenate str (not "int") to str

转换数据类型的代码如下： 

name='张三'
age=20
print(type(name),type(age))#得出name和age的数据类型不相同
#print('我是'+name+'我今年'+age+'岁')#所以用+（这个连接符）去连接的话，就会报错
print('我是'+name+'我今年'+str(age)+'岁')#将int类型转化为str类型

结果就不会报错了：

<class 'str'> <class 'int'>
我是张三我今年20岁

同理，其他类型的也是可以去转换，但是要注意的是：        

        int()：文字类的和小数类的字符串，无法转换成整数；浮点数转换成int，则会抹零取整。

比如小数类：123.12，文字类：hello，这种（非数字串，且是非整数数字串的）是无法转换成功的，会报错。

报错结果如下：小数类

s1='123'
s2='123.12'
f1=4.4
b1=False
s3='hello'
print(type(s1),type(f1),type(b1))
print(int(s1),type(int(s1)))#将str转为int类型，字符串为数字字符串，不会报错
print(int(f1),type(int(f1)))#将float转为int，验证是否抹零
print(int(b1),type(int(b1)))#将bool转为int，验证是否成功
print(int(s2),type(int(s2))) #将str转为int类型，字符串为小数类字符串，则会报错
#print(int(s3),type(int(s3)))

Traceback (most recent call last):
  File "D:\工作\python script\test0\test3.py", line 11, in <module>
    print(int(s2),type(int(s2))) #将str转为int类型，字符串为小数类字符串，则会报错
ValueError: invalid literal for int() with base 10: '123.12'
<class 'str'> <class 'float'> <class 'bool'>
123 <class 'int'>#字符串为数字串的（非小数的），转换成功
4 <class 'int'>#float转为int的，已转换成功，且已经抹零
0 <class 'int'>#bool型的也能转为int类型，且，False就是0

文字类：

s1='123'
s2='123.12'
f1=4.4
b1=False
s3='hello'
print(type(s1),type(f1),type(b1))
print(int(s1),type(int(s1)))#将str转为int类型，字符串为数字字符串，不会报错
print(int(f1),type(int(f1)))
print(int(b1),type(int(b1)))
#print(int(s2),type(int(s2)))
print(int(s3),type(int(s3)))#将str转为int类型，字符串为文字类字符串，则会报错

<class 'str'> <class 'float'> <class 'bool'>
123 <class 'int'>
4 <class 'int'>
0 <class 'int'>
Traceback (most recent call last):
  File "D:\工作\python script\test0\test3.py", line 12, in <module>
    print(int(s3),type(int(s3)))#将str转为int类型，字符串为文字类字符串，则会报错
ValueError: invalid literal for int() with base 10: 'hello'

float()：文字类无法转换成整数；整数类型转换为float时，末尾为.0。代码如下：

s1='123'
s2='123.12'
f1=4
b1=False
s3='hello'
print(type(s1),type(s2),type(f1),type(b1),type(s3))
print(float(f1),type(float(f1)))#整型转为浮点型，验证后面加个.0，即4.0
print(float(s1),type(float(s1)))#整数字符串，转为浮点型，验证123.0
print(float(s2),type(float(s2)))#小数类字符串，转为浮点型，验证123.12
print(float(b1),type(float(b1)))#bool转为浮点型，False本身为0，转后即：0.0
print(float(s3),type(float(s3)))#文字类字符串无法转为整数，也无法转换为浮点型，所以会报错

验证结果：

<class 'str'> <class 'str'> <class 'int'> <class 'bool'> <class 'str'>
4.0 <class 'float'>#整数类型转换成功
123.0 <class 'float'>#整数类字符串转换成功
123.12 <class 'float'>#小数类字符串转换成功
0.0 <class 'float'>#bool转换转换成功
Traceback (most recent call last):
  File "D:\工作\python script\test0\test3.py", line 12, in <module>
    print(float(s3),type(float(s3)))#文字类字符串无法转为整数，也无法转换为浮点型，所以会报错
ValueError: could not convert string to float: 'hello'

        eval()是将字符串里的值转换为它原本对应的类型

 注意：变量的值必须是字符串

a='1'
b='2.2'
c='[1,2,3]'
d='(1,2,3,4)'
print(eval(a),type(eval(a)))
print(eval(b),type(eval(b)))
print(eval(c),type(eval(c)))
print(eval(d),type(eval(d)))
#结果：
1 <class 'int'>
2.2 <class 'float'>
[1, 2, 3] <class 'list'>
(1, 2, 3, 4) <class 'tuple'>#tuple是一个元组类型

8、python中的注释

        单行注释：以“#”开头，直到换行结束

        多行注释：并没有单独的多行注释标记。将一对三引号之间的代码称为多行注释（前提：在以三引号不赋给任何变量的时候）

        中文编码声明注释：在文件开头加上中文声明注释，用以指定源码文件的编码格式

9、input函数的使用

        9.1 输入函数input()

        input函数的作用：接收来自用户的输入

        input的返回值类型：输入值的类型为str

        input的值的存储：使用=对输入的值进行存储

           present = input('输入提示语')

present是变量，=是赋值运算符，input（）函数是一个输入函数。将输入函数的结果赋值给变量present。

a=input('请输入您的密码')
print(f'您输入的密码是{a}')
#结果
请输入您的密码1
您输入的密码是1

#或者
a=input('请输入您的密码')
print(a)
#结果
请输入您的密码1
1

        9.2 input（）函数的高级使用

                因为input（）函数输入的值的类型时str，所以如果直接运算符相加的话，只是一种输出值的连接，并不会进行相加。

a=input('请输入一个整数：')
b=input('请再输入一个整数：')
print(a+b)
print(type(a),type(b))

因为可以查看a和b的类型都是str型的，直接a+b是表示连接，而不是运算

请输入一个整数：10
请再输入一个整数：20
1020
<class 'str'> <class 'str'>

        实现将两个数相加，写入代码有三种方式。

        （1）在输出的时候进行类型的转换

        （2）在输入后，将输入的值进行转换，转换后输出的时候就可以直接相加

        （3）直接在输入的时候就进行转换，输出时直接相加

#这是在输出的时候进行类型的转换
a=input('请输入一个整数：')
b=input('请再输入一个整数：')
print(type(a),type(b))
print(int(a)+int(b))

#结果：
请输入一个整数：10
请再输入一个整数：20
<class 'str'> <class 'str'>
30

#这是在输入后，将输入的值进行转换，转换后输入的时候就可以直接相加了
a=input('输入一个整数：')
b=input('输入另一个整数')
a=int(a)
b=int(b)
print(a+b)

#结果：
输入一个整数：20
输入另一个整数30
50

#这是直接在输入的时候就进行转换，输出时直接相加
a=int(input('输入一个整数：'))
b=int(input('再输入一个吧：'))
print(a+b)

#结果：
输入一个整数：30
再输入一个吧：40
70

10. python中的运算符

        10.1 算术运算符

        包括：标准算术运算符，取余运算符，幂运算符

                10.1.1 标准算术运算符：加（+）、减（-）、乘（X）、除（/）、整除（//）

print(2+3)
print(3-1)
print(2*4)
print(1/4)#除法
print(1//4)#整除
#结果：
5
2
8
0.25#除法后的值
0#整除后的值

                10.1.2 取余运算符：%

print(11%2)
#结果
1

                10.1.3 幂运算符：##

print(3**3)#表示3的3次方
print(3**4)#表示3的4次方
#结果
27
81

       当一正一负时，整除的话，要向下取整。如：-9//4，结果为-3

print(-9//-4)
print(9//-4)#一正一负的时候会向下取整-9除以4结果是-2.25,取整为-3
print(-9//4)
print(9/4)
print(9//4)
#结果：
2 #-9除以-4的结果
-3 #一正一负的结果
-3 #一正一负的结果
2.25 #9除以4
2 #9整除以4

        当一正一负取余的时候，要遵循公式：余数=被除数-除数乘以商

        同时别忘了商在一正一负的情况下，要向下取整。

print(-9%-4)
print(9%-4)
print(-9%4)
print(9%4)
#取余的话，一正一负的适合要遵循公式，公式：余数=被除数-除数乘以商
# （这个商也要遵循一正一负向下取整，所以当一正一负时，变成了-3）
#结果：余数=-9-（-4）*（2）=-1
#结果：余数=9-（-4）*（-3）=-3
#结果：余数=-9-（4）*（3）=3

#结果：
-1
-3
3
1

        10.2 赋值运算符

                10.2.1 执行顺序：从右->左

                10.2.2 支持链式赋值-> a=b=c=20

                10.2.3 支持参数赋值：+=，-+，*=，/=，//+，%=

a=30
a+=20  #a加上20后再赋值给a
print(a)  #a=50
a-=30
print(a)  #a=20
a*=40
print(a)  #a=800
print(type(a)) #a的类型是int型
a//=50    #a整除以50
print(a)  #a=16
print(type(a)) #a的类型是int型
#结果：
50
20
800
<class 'int'>
16
<class 'int'>

a=30
a+=20  #a加上20后再赋值给a
print(a)  #a=50
a-=30
print(a)  #a=20
a*=40
print(a)  #a=800
a/=4  #因为除以的话是有余数的，所以是浮点型
print(a) #a=200.0
print(type(a))#a的类型是float型
#结果：
50
20
800
200.0
<class 'float'>

                10.2.4 支持系列解包赋值：a,b,c=20,30,40

a=b=c=10,23,34,3
print(a,b,c)
#结果：
(10, 23, 34, 3) (10, 23, 34, 3) (10, 23, 34, 3)

a=b=c=10
print(a,b,c)
#结果：
10 10 10

a,b=10,20
print(a,b)
#结果：
10 20

a,b=10,20,30  #值和变量的个数要相等，否则会报错
print(a,b)
#结果：
    a,b=10,20,30
ValueError: too many values to unpack (expected 2)

 在python中，可以不通过中间变量的方式去实现两个值的交换。使用交换代码：a,b=b,a。

a,b=10,20
print(a,b)
#交换两个变量的值可以不需要中间变量，使用交换代码即可：
a,b =b,a
print(a,b)
#结果：
10 20
20 10

        10.3 比较运算符

                对变量或表达式的结果进行大小，真假等比较

                (1) >,<,>=,<=,!=

                (2) ==  （对象value的比较）         

a,b=10,44
print(a>b)
print(a!=b)
print(a<b)
print(a<=b)
print(a==b)
print('a不等于b吗',a!=b)
#结果：
False
True
True
True
False
a不等于b吗 True

                (3) is,is not   （对象的id（标识）的比较）

a,b=10,44
print(id(a),id(b))
print('a和b的标识是不是相同？',a is b)
#a和b的标识是不一致的，id不一致的，所以是False
#结果：
2424971919888 2424971920976
a和b的标识是不是相同？ False
#--------------
a,b=10,10
print(id(a),id(b))
print('a和b的标识是不是相同？',a is b)
#a和b的标识是一致的，id是一致的，所以是True
#结果：
1685260403216 1685260403216
a和b的标识是不是相同？ True

但是当是数组时，虽然数组的值都是一样的，但是存储的标识（id）却会不一致

list1=[1,2,3]
list2=[1,2,3]
print(list1==list2)
print(id(list1),id(list2))
print('list1和list2的标识是一致的吗？',list1 is list2)
#或者：
list1,list2=[1,2,3],[1,2,3]
print(list1==list2)
print(id(list1),id(list2))
print('list1和list2的标识是一致的吗？',list1 is list2)
#结果：list1和list2的id就是不一致的
True
2656185348992 2656185315456
list1和list2的标识是一致的吗？ False
#--------------------
#对比单个值：
a,b=10,10
print(id(a),id(b))
print('a和b的标识是不是相同？',a is b)
#结果：
1685260403216 1685260403216
a和b的标识是不是相同？ True
#a和b的标识是一致的，id是一致的，所以是True

        10.4 布尔运算符

        布尔运算符：and，or，not，in，not in

        and的需要都是真，才为真；or只需要有一个为真，那就是真

a,b=1,2
print(type(a),type(b))
print(a==1 and b==2)
print(a<1 and b==2)
print(a<1 or b==2)
print(a<1 or b<2)
#结果：
<class 'int'> <class 'int'>
True
False
True
False
#表明：and的需要都是真，才为真；or只需要有一个为真，那就是真

        not表示非

q=True
w=False
print(not q)
print(not w)
#结果：
False
True
#即取反

         in和not in，表示在或者不在

a='abcdefg'
print(type(a))
print('a'in a)
print('b'in a)
print('h' in a )
print('h'not in a)
#结果
<class 'str'>
True#字符a确实在a里
True#字符b确实在a里
False#字符h不在a里，所以是false
True#字符h不在a里，所以是true

        10.5 位运算符

        位运算符：将数据转成二进制进行计算

        （1）位与&：对应数位都是1，结果数位才是1，否则为0

        （2）位与|：对应数位都是0，结果数位才是0，否则为1

0	0	0	0	0	1	0	0		4
0	0	0	0	1	0	0	0		8
0	0	0	0	0	0	0	0	&	结果：0
0	0	0	0	0	1	0	0		4
0	0	0	0	1	0	0	0		8
0	0	0	0	1	1	0	0	|	结果：12

        "&"和"|"的逻辑代码及验证结果如下：

a=4
b=8
print(a&b)
print(a|b)
#结果：
0
12

        （3）左移位运算符<<：高位溢出舍弃，低位补0

        （4）右移位运算符>>：低位溢出舍弃，高位补0

左移：高位溢出舍弃，低位补0

高位溢出（舍弃）	0	0	0	0	0	1	0	0		4
0	0	0	0	0	1	0	0	低位补0
结果：	0	0	0	0	1	0	0	0		8
结论：向左移动一位，相当于乘以2
高位溢出（舍弃）	0	0	0	0	1	0	0	0		8
0	0	0	0	1	0	0	0	低位补0
结果	0	0	0	1	0	0	0	0		16
在8的基础上又去左移了一位，结果为16，所以：左移一位乘以2

        可以理解为：2^2，2^3，2^4，左移一位加一 

右移：低位溢出舍弃，高位补0

16		0	0	0	1	0	0	0	0
		高位补0	0	0	0	1	0	0	0	0	低位溢出（舍弃）
8		0	0	0	0	1	0	0	0		结果
结论：向右移动一位，相当于除以2
8		0	0	0	0	1	0	0	0
			0	0	0	0	1	0	0	0	低位溢出（舍弃）
4		0	0	0	0	0	1	0	0		结果
在8的基础上又去右移了一位，结果为4，所以：右移一位除以2

代码逻辑如下：

a=16
print(a<<1)#a左移一位，乘以2，结果为32
print(a>>2)#a右移两位，除以4，结果为4
print(a>>1)#a右移一位，除以2，结果为8
#结果：
32
4
8

11. 运算符的优先级

      有括号先计算括号：（）>算术运算符>位运算>比较运算>布尔运算>赋值运算