Python之路-变量和基本数据类型详解（变量、数据类型、）

一、注释

注释的作用：

　　增加程序的可读性

　　作为调试用

　　提高团队的合作效率

注释的分类

　　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

#右移运算符 >>
#把“ >>”左边的运算数的各二进位全部右移若干位，由">>"右边的数字决定移动的位数