一、注释
注释的作用：
增加程序的可读性
作为调试用
提高团队的合作效率
注释的分类
1、单行注释
以井号（#）开头，右边的所有内容当做说明
2、多行注释
以三对单引号（’’’注释内容’’’）将注释包含起来
其他语法
Python的语法比较简单，采用缩进的方式。
# print absolute value of an integer:
a = 100
if a >= 0:
print(a)
else:
print(-a)
上面代码中，以‘# ’是注释的标识符，可以记录当前代码所代表的意义，解释器会自动忽略这部分内容。
当语句以‘：’结尾时，缩进语句视为代码块。
在Python中，通常我们以4个空格的缩进来进行区分。可以在每句结束之后加一个‘;’号。通常在Python中，默认以换行为新的一行，若想在一行输入多句语句，一定要加‘;’，否则报错。
注意： 由于Python采用缩进的语法，在你复制，粘贴语句时，一定要注意，重新检查当前代码的缩进格式。 在Python中，对大小写十分敏感，如果大小写错误，会报错。
二、变量
标识符
什么是标识符
标识符是自己定义的,如变量名 、函数名等
标识符命名规则
1、只能包含字母、数字和下划线。变量名可以以字母或者下划线开头。但是不能以数字开头。
2、不能包含空格，但可以使用下划线来分隔其中的单词。
3、不能使用Python中的关键字作为变量名
4、建议使用驼峰命名法，驼峰式命名分为大驼峰（UserName）。和小驼峰（userName）。
常用关键字
系统有一些常用关键字不可以用来当做标识符。
在Python中查看
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
三、数据类型
Number
int:
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样。
float:
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。
complex:
一个实数和一个虚数的组合构成一个复数。
bool:
bool值是特殊的整型，取值范围只有两个值，也就是True和False。
字符串
字符串就是一系列任意文本。Python中的字符串用单引号或者双引号括起来，同时可以使用反斜杠（\）转义特殊字符。
单引号（’’）和双引号（"”）本身只是一种表示方式，不是字符串的一部分，因此，字符串’hello’只有h,e,l,l,o这五个字符。如果’本身也是字符的话，那么就可以用””括起来，比如”I’m OK” 当中包含了一个 ’ 。如果字符串内部包含 ’ 或者 ” ，但是又想当成普通字符串处理怎么办？这个时候就要用转义字符（\）来标识。
操作字符串
截取字符串语法：变量[开始下标：结束下标]
加号（+）是字符串的连接符
星号（*）表示复制当前字符串
格式化输入
通过它能够完成从键盘获取数据，然后保存到指定的变量中 input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存
格式化输出
常用的格式符号:%[(name)][flags][width].[precision]typecode
字符串下标与切片
下标就是编号,字符串实际是字符的组合。
声明一个字符串str1值为：abcd
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]
字符串常用函数
字符串练习：
# -*- coding:utf-8 -*- '''
格式化输出
''' # name = 'joe'
# age = 18
# address = '上海'
# print('大家好我叫%s，我今年%d岁，我来自%s'%(name,age,address))
# print('大家好我叫%s'%name) '''
字符串常用函数
'''
#find
# str = 'I love python'
# print(str.find('o'))#返回的是该字符的位置
# print(str.find('w')) #没有的化返回-1 #index
# str = 'I love python'
# print(str.index'o'))#返回的是该字符的位置
# print(str.index('o')) #没有的化返回报错信息 #count
# str = 'I love python'
# print(str.count('o'))#返回的是该字符出现的次数
# print(str.index('o',2,6)) #在指定位置查找出现的次数 #replace
# str = 'I love python'
# print(str.replace('p','P'))#替换并输出 I love Python #split
# str = 'I love python o'
# print(str.split(' '))#指定字符切分 ['I', 'love', 'python', 'o']
#capitalize
# str = 'i love python o'
# print(str.capitalize()) #将字符串的首字母大写I love python o #capitalize
# str = 'i love python o'
# print(str.title()) #将字符串中每个单词的的首字母大写I Love Python O #startswith
# str = 'i love python o'
# print(str.startswith('i')) #检测字符串是否以指定的字符开头 是则返回True 否则False #swith
# str = 'i love python o'
# print(str.endswith('p')) #检测字符串是否以指定的字符结尾 是则返回True 否则False #upper
# str = 'i love python o'
# print(str.upper()) #所有字母转化为大写 #lower
# str = 'I LOVE PYTHON O'
# print(str.lower()) #字符串转化为小写 #ljust
# str = 'hello'
# print(str.ljust(10)) #返回一个原字符串左对齐，并使用空格填充至长度width的新字符串hello #rjust
# str = 'hello'
# print(str.rjust(10)) #返回一个原字符串右对齐，并使用空格填充至长度width的新字符串 hello #center
# str = 'hello'
# print(str.center(10)) #返回一个原字符串居中，并使用空格填充至长度width的新字符串 hello #lstrip
# str = ' hello'
# print(str.lstrip()) #除去字符串左边的空白字符hello #rstrip
# str = 'hello '
# print(str.rstrip()) #除去字符串右边的空白字符hello #partition
# str = 'hello world hello china'
# print(str.partition('world')) #可以将字符串以str进行分割成三部分 str前，str,str后('hello ', 'world', ' hello china') #join
# str = 'hello world hello china'
# str1 = '-'
# print(str1.join(str)) #str中每个字符后面插入str1,构造出新的字符串h-e-l-l-o- -w-o-r-l-d- -h-e-l-l-o- -c-h-i-n-a #isspace
# str = 'hello world hello china'
# print(str.isspace()) #如果str中只包含空格，则返回true 否则返回false #isalnum
# str = 'hello'
# print(str.isalnum()) #如果str中所有字符都是字母或者数字，则返回true 否则返回false #isdigit
# str = '8765'
# print(str.isdigit()) #如果str中只包含数字，则返回true 否则返回false #isalpha
str = 'hello china'
print(str.isalpha()) #如果str中所有字符都是字母，则返回true 否则返回false
列表
列表写在[ ]内，元素之间用逗号隔开：
注意：
List写在方括号之间，元素用逗号隔开
和字符串一样，List可以被索引和切片
List可以使用加号（+）操作进行拼接
List中的元素是可以被改变的
列表的访问：
列表是由一系列按特定顺序排列的元素组成，列表能存储多种类型的数据，其中的元素之间可以没有任何关系
列表索引
列表的操作：
修改列表元素
修改列表元素的语法和访问列表元素的语法类似，指定列表名和要修改元素的索引，再指定新值
以下列表名为：students，需要将jack修改为tom
添加列表元素1：
在列表末尾追加元素：使用append()方法将元素追加到列表的末尾。也可以用append()方法来动态创建列表
以下列表名为：students，需要将‘篮球添加到列表的末尾’，使用append()方法
添加列表元素2：
在列表中插入元素：通过指定新元素的索引和值，使用insert()方法可以在列表的任何位置添加新元素
以下列表名为：students，需要将‘音乐插入到男的后面，使用insert()方法
删除列表元素
使用pop()方法删除元素：pop方法用于移出列表中的一个元素（默认是最后一个元素），可以指定元素索引，并且返回该元素的值。
使用del语句删除元素：如果知道要删除的元素在列表中的位置，可使用del语句删除元素，元素一旦被删除之后就再无法访问
使用remove()方法删除元素：当不知道元素索引，只知道元素值的时候，使用remove()方法删除元素
查找列表元素
所谓的查找，就是看看指定的元素是否存在
in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false
Python列表函数
列表练习：
# -*- coding:utf-8 -*- #列表：是由一系列特定顺序排列的元素组成
# 列表可以存储多种类型的数据，
# 元素之间没有任何关系 '''
访问列表
''' # list01 = ['jack','jane','joe','black','']
# print(list01[2]) #通过下标访问 #二维列表
# list02 = ['jack','jane',['leonado','joe'],'black','']
# print(list02[2])
# print(list02[2][0]) #获取leonado # list02 = ['jack','jane',['leonado','joe'],'black','']
# list02[0] = 'lili' #通过下标获取到元素，并且给其赋新的值
# list02[2][0] = 'susan'
# print(list02) #列表是一个可变的类型数据，允许我们对其里面的数据进行修改 '''
列表的操作-追加
append列表末尾追加
insert指定位置插入
''' #append
# list02 = ['jack','jane','joe']
# list02.append('susam')
# print(list02) #insert
# list02 = ['jack','jane','joe','black']
# print('插入之前')
# print(list02)
# print('_'*20)
# #指定位置插入
# list02.insert(1,'susan')
# print(list02) '''
删除元素
pop默认从最后删除,还可以通过指定索引删除
del通过指定位置删除
remove通过值删除
# '''
# list02 = ['jack','jane','joe','black']
# print('删除之前')
# print(list02)
# print('_'*20)
# print(list02.pop()) #执行删除操作 并且返回删除的元素
# print(list02)
# print('继续删除')
# print('_'*20)
# print(list02.pop(1)) #执行删除操作 并且返回删除的元素
# print(list02)
#del
# list02 = ['jack','jane','joe','black']
# print('删除之前')
# print(list02)
# print('_'*20)
# del list02[1] #指定索引删除 彻底删除
# del list02 #默认将整个列表 从内存中彻底删除，
# print(list02) #remove 在不知道下标，但是知道具体值的时候通过值来删除
# list02 = ['jack','jane','joe','black']
# print('删除之前')
# print(list02)
# print('_'*20)
# list02.remove('jane') #通过元素的值进行删除
# print(list02) '''
查找元素是否存在
in
not in
'''
# list02 = ['jack','jane','joe','black']
# name = 'jack'
# name2 = 'lee'
# print(name in list02)
# print(name2 in list02) # list02 = ['jack','jane','joe','black']
# name = 'jack'
# name2 = 'lee'
# print(name not in list02)
# print(name2 not in list02)
# -*- coding:utf-8 -*- '''
列表函数
''' # list05 = ['jack','jane','joe','black','12']
# #查看列表长度 返回列表元素个数
# print(len(list05)) #类似于一个方法，将参数传入 # list05 = ['jack','jane','joe','black'] #如果是字符类型，取字母靠后的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最大值。
# print(max(list05)) #类似于一个方法，将参数传入 # list05 = ['jack','jane','joe','black'] #如果是字符类型，取字母靠迁的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最小值。
# print(min(list05)) #类似于一个方法，将参数传入 # list05 = ['jack','jane','joe','black','joe','jane']
# print(list05.count('joe')) #统计元素出现的次数 # list05 = ['jack','jane','joe','black']
# list06 = ['aaa','bc']
# list05.extend(list06) #扩展列表 在一个列表末尾一次性追加一个新列表 传入参数为一个列表 类似于单个元素使用append追加
# print(list05.extend(list06)) #必须先追加再输出
# print(list05) # list05 = ['jack', 'jane', 'joe', 'black','joe']
# print(list05.index('joe')) #从一个列表中找出某一个值第一次出现的位置的索引 # list05 = ['jack', 'jane', 'joe', 'black','joe']
# list05.reverse() #对列表中的元素做反向旋转
# print(list05)
# print(list05.reverse()) #不可以在输出里面做旋转，必须先反向旋转再单独输出 和追加extend一样 # list06 = [2,3,5,9,6,12,40]
# list06.sort() #对列表进行排序
# 'print(list06.sort()) #先做排序 在输出
# print(list06) # list05 = ['jack', 'jane', 'joe', 'black','joe']
# list05.clear() #用于清空列表
# print(list05) # list05 = ['jack', 'jane', 'joe', 'black','joe']
# list07 = list05.copy() #复制列表
# print(list07) #
# list = ['lee','jone','jack']
# list.insert(0,'teacher')
# list.insert(list.__len__(),'bzr')
# print(list)
# # print(list.__len__())
# print(list[1][3])
元组
元祖写在小括号内，元素之间用逗号隔开
注意：
tuple的元素不可改变，但是可以包含可变的对象，比如list
构造包含0个或者1个元素的元祖有特殊语法规则：
tuple1=() #空元祖
tuple2=(1,) #一个元素，需要在元素后添加逗号
访问元组：
元组索引：以下元组成名为students，要访问元祖中的tom
删除元组
元祖和列表不一样，元祖中的元素值是不允许被单独修改和删除的，但是我们可以使用del语句来删除整个元祖
删除元祖语法： del 元组名
元组截取
元组的元素虽然不能够被改变，但是元组也是一个序列，也可以通过索引去访问和截取元组中指定位置的元素
以下元组名为：students，需要截取students的前三个元素
多维元组
多维元祖就是元祖中的元祖，元祖中的元素可以是一个新的元祖
以下列元祖为：students，需要获取元祖中的tom
Python元祖函数
元祖练习：
# -*- coding:utf-8 -*- '''
Python 里面的元祖和列表类似，不同之处在于元祖中的元素不能被修改，而列表中的元素可以被修改
也可以进行分片和连接。元祖使用小括号，列表使用方括号。
''' '''
元祖 不可修改 提供了删除del 彻底删除（没法通过下标删除）
元祖中的元素虽然不能被改变，但是元祖也是一个序列，也可以通过索引去访问和截取元祖指定位置的元素
多维元祖：元祖中的元祖
'''
# tup01 = (1,2,3,4,5)
# print(tup01[3]) '''
元祖函数：
''' # tup01 = (1,2,3,4,5)
# print(len(tup01)) #计算元祖中元素的个数 # tup01 = (1,2,3,4,5)
# print(max(tup01)) #计算元祖中最大的元素 # tup01 = (1,2,3,4,5)
# print(min(tup01)) #计算元祖中最小的元素 # list = ['jack','joe','black']
# print(type(list))
# print(tuple(list)) #将列表转化为元祖
# print(type(tuple(list))) # tup01 = (1,2,3,4,5)
# print(list(tup01)) #将元祖转为列表 可以实现对元祖的修改
字典
字典是一种映射类型，使用{ }表示，他是一个无序的键（key）值（value）对集合
字典是另外一种可变容器类型，且可以存储任意类型对象。
列表元素进行修改的话，通过索引进行修改，如果当前元素的顺序发生改变，此时还需要修改索引才能成功完成元素的修改.
字典既能存储多个数据，又能很方便准确的定位元素呢
字典创建语法：字典的创建使用{}，每个键值（key=>value）对用冒号（：）分割，每对之间用逗号（,）分割。
访问字典
字典中根据键访问值，可以指定自点名和放在方括号内的键。以下字典想要获取学员姓名。
字典：students={'name':'tom','age':18,'sex‘:’男'}
修改字典元素
字典元素也是可以修改的，通过key找到具体元素之后，给一个新的元素值即可。
如：以下字典将学员的年龄修改为20
字典：students={'name':'tom','age':18,'sex‘:’男'}
添加元素
动态的向字典中添加元素的时候，只要添加的键在字典中不存在，就会新增这个元素。
在以下字典中添加一个住址信息
字典：students={'name':'tom','age':18,'sex':'男'}
删除字典元素
使用del语句删除元素：del既可以删除指定的字典元素(列表也可以指定)，也可以删除整个字典，如果不指定key，代表删除整个字典。
语法如下：
del 字典名[key]
使用clear()方法清空整个字典：被清空的字典最后会剩下一个空的字典在，而用del删除的字典在程序当中就不存在了。语法如下：
字典名.clear()
注意：
字典是一种映射类型，它的元素是键值对
键(key)必须使用不可变类型（字符串、数值、元组），在同一个字典中，键必须是唯一的。
创建空字典使用{ }
字典函数：
字典方法：
字典练习：
# -*- coding:utf-8 -*- '''
字典是用户自己创建索引 通过前面的下标操作
'''
# dict = {'name':'job','age':18,'address':'上海'}
# print(dict)
#访问
# print(dict['name']) #修改
# dict = {'name':'job','age':18,'address':'上海'}
# dict['name'] = 'jack'
# print(dict) #添加元素
# dict = {'name':'job','age':18,'address':'上海'}
# dict['hobby'] = '足球'
# print(dict)#多次运行发现输出的顺序不一样，不一定在最后 #删除
# dict = {'name':'job','age':18,'address':'上海'}
# del dict['address'] #删除某一个
# del dict #整个字典彻底从内存删除 表名都不存在了
# print(dict) # dict = {'name':'job','age':18,'address':'上海'}
# dict.clear()
# print(dict) #{} 清空所有元素 '''
字典函数
'''
# dict = {'name':'job','age':18,'address':'上海'}
# print(len(dict)) #计算字典中元素的个数 # dict = {'name':'job','age':18,'address':'上海'}
# print((str(dict)) #输出字典，以可打印的字符串表示。转为str类型
# print(type(str(dict))) #dict.fromkeys(seq[,]value)
#创建一个新的字典，以seq中的元素作为字典的前半部分的key值,value为字典所有键对应的默认初始化的值
# seq = ('name','age','sex')
# dict01 = dict.fromkeys(seq)
# print('新字典为：',dict01)
# dict02 = dict.fromkeys(seq,'jack') #对vlue赋值
# print('新字典为：',dict02) #dict.get(key,default=None)
#返回指定键的值 如果不在字典里面返回default值
# dict = {'name':'job','age':18,'address':'上海'}
# print('age键的值为：',dict.get('age'))
# print('sex键的值为：',dict.get('sex')) #没有返回默认none
# print('sex键的值为：',dict.get('sex','男')) #字典里面没有可以手动指定
# print('ddress键的值为：',dict.get('ddress','北京'))#如果建值字典里面有，但是自己手动指定则已手动指定的输出 #key in dict
#如果键在字典dict里面返回true,否则返回false
# dict = {'name':['job','tom'],'age':18,'address':'上海'}
# if 'age' in dict:
# print('键age在字典里面存在')
# else:
# print('键age不在字典里面存在') # dict.keys()
# 以列表形式返回字典里面所有的键 值
# dict = {'name':['job','tom'],'age':18,'address':'上海'}
# print(dict.keys()) #dict_keys(['age', 'address', 'name'])
# print(dict.values()) #dict_values([18, ['job', 'tom'], '上海']) # dict = {'name':['job','tom'],'age':18,'address':'上海'}
#以键值对形式保存在列表中
# print(dict.items()) #dict_items([('address', '上海'), ('age', 18), ('name', ['job', 'tom'])])
集合（无序）
集合set是基本数据类型的一种，它有可变集合(set)和不可变集合(frozenset)两种。创建集合set、集合set添加、集合删除、交集、并集、差集的操作都是非常实用的方法。
浅拷贝与深拷贝
可变(mutable)参数和不可变(immutable)参数
Python中string、tuple和number是不可变对象，而dict、list等是可变对象；不可变对象在进行重新赋值的时候，实际上是将原始值丢弃，将变量指向一个新值；可变对象的可变性实质上是指更改可变对象中的子对象，比如list中的item元素的更改。
直接赋值：其实就是对象的引用（别名)。
代码：
#直接赋值
# a = [1,2,3]
# b = a
# print(a)
# print(b)
# print(id(a))#通过id查看变量在内存中的地址
# print(id(b))
# a[0] = 5
# print(a)
# print(b)
浅拷贝：不拷贝子对象(针对子对象中的item)，当子对象进行更改的时候，原始对象也会改变。
常见操作：列表的切片[:]操作、list()操作，字典的copy()函数、copy模块的copy()函数（两个一模一样的双胞胎）
# #浅拷贝 切片 只拷贝父类
# a = [1,2,3]
# b = [11,22,33]
# c = [111,222,333]
#
# list01 = [a,b,c]
# print(id(list01))
# list02 = list01[:]
# #查看list01和list02
# print(list01)
# print(list02)
# #检查List01和list02在内存中的地址
# print('_'*20)
# print(id(list01))
# print(id(list02))
#
# #修改一下
# a[0] = 5
# print(a)
# print('_'*20)
# print(list01)
# print(list02)#一起改变 因为都指向了同一个子元素
深拷贝：会拷贝子对象，当对原始对象子对象进行更改的时候，原始对象不会改变。
常见操作：copy模块的deepcopy()函数
练习：
#深拷贝 引入copy模块 从父到子 递归一起拷贝了
import copy
a = [1,2,3]
b = [11,22,33]
c = [111,222,333] list01 = [a,b,c]
print(id(list01))
# list02 = list01[:]
list02 = copy.deepcopy(list01)
#查看list01和list02
print(list01)
print(list02)
#检查List01和list02在内存中的地址
print('_'*20)
print(id(list01))
print(id(list02)) # 修改一下
a[0] = 5
print(a)
print('_'*20)
print(list01)
print(list02)#没有影响 子元素一起复制 list01 list02 各自都有自己的子元素
四、运算符
算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
算术运算符
以下假设变量a=10，变量b=20
赋值运算符
比较运算符
以下假设变量a=10，变量b=20
逻辑运算符
位运算符
a = 60 b = 13
练习：
# -*- coding:utf-8 -*- '''
int
''' # a = 1
# print(type(a)) #type是python里面用来查看数据类型的函数 '''
boolean
True 不为零 False 为零
'''
# a = True
# print(type(a)) '''
字符串 string
一般使用单引号 或者双引号
'''
# a = '刘德华'
# name= "黎明"
# num = '1'
# num2 = 'True' #带上引号的都是字符串
# print(type(a))
# print(type(name))
# print(type(num)) # str1 = '"ni hao"' #双引号成了字符串本身
# print(str1) # str2 = "'你 好'" #单引号成了字符串本身
# print(str2) # str3 = 'aaa\'bbb' #最外面的单引号是一对 里面的单引号通过\转义
# print(str3) #字符串截取
# str = 'abcdefg'
# print(str)
# print(str[1:5]) #含头不含尾
# print(str[-1]) #输出g 从最后开始输出
# print(str[2:]) #默认输出到最后
# print(str[:2])
# print(str[1:5:2]) #截取1到5 2是步长 隔一个拿取第二个
# print(str[1:5:1]) #等价于print(str[1:5]) 一个一个拿取
# print(str[::-1]) #反向输出
# print(str[5:2:-1]) #运算符
#+
# num1 = 10
# num2 = 3
# print(num1 + num2)
# print(num1 - num2)
# print(num1 * num2)
# print(num1 / num2)
# print(num1 % num2)
# print(num1 // num2) #返回商的整数部分，
# print(num1 ** num2) #幂 num1的num2次幂 '''
赋值运算
'''
# str = 'a' # num = 1
# num += 1 #num = num + 1 先加
# print(num) # num = 10
# num -= 1 #num = num - 1 先减
# num *= 2 #num = num * 2
# num /= 2 #num = num / 2
# num %= 2 #num = num % 2
# num **= 2 #num = num ** 2
# num //= 2 #num = num // 2
# print(num) '''
比较运算
'''
# a = 10
# b = 5
# print(a == b)
# print(a != b)
# print(a > b)
# print(a < b)
# print(a >= b)
# print(a <= b) '''
逻辑运算
'''
#and
# a = 10
# b = 5
# print(a > b and a < b) #两个条件为真，则为真，否则为假
# print(a > b or a < b) #两个条件有一个为真，则为真
# print(not a > b) #非 # str = '' #空的字符串返回 bool False
# str = [] #空的列表返回 bool False
# str = () #空的元组返回 bool False
# str = {} #空的字典返回 bool False
# str = 0 #0 返回 bool False
# print(bool(str)) '''
位运算
'''
a = 4
b = 2
'''
十进制：1，2,3,4,5,6,7,8,9,10,11
二进制：0000，0001,0010,0011,0100
0000 0100 表示4
0000 0010 2
$ 0000 0000 0 #对应位同时为1则为1 否则为0
| 0000 0110 6
'''
#按位与运算符 &
#参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0
# print(a & b ) #0 #按位或运算符 |
#参与运算的两个值，只要对应的两个二进制有一个为1，则该位的结果为1
# print(a | b) #6 #按位异或运算符 ~
#参与运算的两个值，当对应的两个二进制相异时，则该位的结果为1
# print(a ^ b) #按位取反运算符~
#对数据的每个二进制取反，即把1变为0，把0变为1
# print( ~ a ) # -4-1 -5 (取负数 再减1) #左移运算符 <<
#运算数的各二进位全部左移若干位，由"<<"右边的数字决定移动的位数
#高位丢弃，低位补0 #右移运算符 >>
#把“ >>”左边的运算数的各二进位全部右移若干位，由">>"右边的数字决定移动的位数