Python3基本语法知识

2020年6月13日20:13:45
最开始打算看视频，后来觉得看文档更好。
推荐给大家，如果想学的话，看文档不要看视频。
参考：https://www.runoob.com/

一、必要知识

• Python 的 3.0 版本不向下兼容
• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 官网：https://www.python.org/
• 默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。
• 使用缩进来表示代码块，不需要使用大括号。
• 语句很长时，可以用反斜杠()来实现多行语句，在 [], {}, 或 () 中的多行语句，不需要使用反斜杠。
• 标识符的第一个字符必须是字母或_ ，其它部分由字母、数字和下划线组成，区分大小写
• Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字

import keyword
keyword.kwlist

惯例的Hello World

print ("Hello, World!")

二、基础语法

1.关于注释

print ("Hello, World!") #第一个注释
'''
第一种多行注释
'''
"""
第二种多行注释
"""

---

2.输出语句

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""

x="a"
y="b"
# 换行输出
print( x )
print( y )

# 不换行输出
print( x, end=" " )
print( y )

3.import 与 from…import

• 一个模块只会被导入一次，不管你执行了多少次import
• 模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。
• 每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。

导入相应的模块

#将整个模块(somemodule)导入
import somemodule
#从某个模块中导入某个函数
from somemodule import somefunction
#从某个模块中导入多个函数
from somemodule import firstfunc, secondfunc, thirdfunc
#将某个模块中的全部函数导入
from somemodule import *

导入实例

# noinspection PyUnresolvedReferences
# encoding:utf-8
#导入 sys 模块
import sys
print('Python import mode')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)
# 导入特定的成员
from sys import argv, path
print('python from import')
# 因为已经导入path成员，所以此处引用时不需要加sys.path
print('path:', path)

__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。
如果在模块被引入时，模块中的某一程序块不执行，可以用__name__属性来使该程序块仅在该模块自身运行时执行。

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)  
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
 '__package__', '__stderr__', '__stdin__', '__stdout__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
 '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
 'call_tracing', 'callstats', 'copyright', 'displayhook',
 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
 'thread_info', 'version', 'version_info', 'warnoptions']

如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

4.转义字符

\(在行尾时)	#续行符
\\	#反斜杠符号
\'	#单引号
\"	#双引号
\a	#响铃
\b	#退格(Backspace)
\000	#空
\n	#换行
\v	#纵向制表符
\t	#横向制表符
\r	#回车
\f	#换页
\oyy	#八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	#十六进制数，yy代表的字符，例如：\x0a代表换行
\other	#其它的字符以普通格式输出

三、基本数据类型

• 变量必须要依附于对象。
• 变量没有类型，对象有类型。
• 允许同时为多个变量赋值

a = b = c = 1
a, b, c = 1, 2, "world"

Python3 中有六个标准的数据类型：

• Number（数字）不可变数据
• String（字符串）不可变数据
• List（列表）
• Tuple（元组）不可变数据
• Set（集合）
• Dictionary（字典）

内置的 type() 函数可以用来查询变量所指的对象类型
也可以用 isinstance 来判断

sinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。
• type 主要用于判断未知数据类型
• isinstance 主要用于判断 A 类是否继承于 B 类

# 判断子类对象是否继承于父类
class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':
    print (type(son())==father)
    print (isinstance(son(),father))
    print (type(son()))
    print (type(son))

# noinspection PyUnresolvedReferences
# encoding:utf-8
a, b, c = 1, 2, "world"
print(type(a), type(b), type(c))
print(isinstance(a, int))

结果：

1.Number（数字）

• int (整数), 如 1, 不带小数点
• bool (布尔), 如 True
  True 和 False 的值是 1 和 0，它们可以和数字相加
• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j
  复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
• 数据类型是不允许改变的
• 改变数字数据类型的值，将重新分配内存空间。

# noinspection PyUnresolvedReferences
# encoding:utf-8
a = 2 / 4  # 除法，得到一个浮点数
b = 2 // 4 # 除法，得到一个整数
c = 2 ** 5 # 乘方
print(type(a), type(b), type(c))
print(a,b,c)

结果：

可以使用十六进制和八进制来代表整数

number = 0xA0F # 十六进制2575
number=0o37 # 八进制31

数据类型的转换

需要将数据类型作为函数名
python 不支持复数转换为整数或浮点数

x = y = 1
int(x) #将x转换为一个整数。
float(x) #将x转换到一个浮点数。
complex(x) #将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) #将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

数学函数

abs(x)	#返回数字的绝对值
ceil(x)	#返回数字的上入整数
cmp(x, y) #如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
exp(x)	#返回e的x次幂(ex
fabs(x)	#返回数字的绝对值
floor(x) #返回数字的下舍整数
log(x) #如math.log(math.e)返回1.0
log10(x) #返回以10为基数的x的对数
max(x1, x2,...)	#返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	#返回给定参数的最小值，参数可以为序列。
modf(x)	#返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) #x**y 运算后的值。
round(x [,n]) #返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。(保留到离上一位更近的一端)
sqrt(x)	#返回数字x的平方根。

随机数函数

choice(seq)	#从序列的元素中随机挑选一个元素
randrange ([start,] stop [,step])	#从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	#随机生成下一个实数，它在[0,1)范围内。
seed([x])	#改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	#将序列的所有元素随机排序
uniform(x, y)	#随机生成下一个实数，它在[x,y]范围内。
randint(x,y)　#随机生一个整数int类型，可以指定这个整数的范围
sample(sequence,length) 可以从指定的序列中，随机的截取指定长度的片断，不修改原序列。

del语句删除单个或多个对象

del var_a, var_b

2.字符串(String)

• python中单引号和双引号使用完全相同。
• 使用三引号可以指定一个多行字符串。
• 转义符 ‘’
• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义

print(r"this is a line with \n") #\n会显示，并不是换行。

• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
  
• Python中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式
  变量[头下标:尾下标:步长]
  是“左闭右开”的
• Python 字符串不能被改变。不能向一个索引位置赋值

str='world'
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的所有字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 连接字符串
print('hello\nworld')

3.List（列表）、

关于序列：
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。

• 写在方括号 [] 之间、用逗号分隔开的元素列表
• 和c的结构体差不多
• 列表可以嵌套
• 列表可以完成大多数集合类的数据结构实现。列表可以包含列表（嵌套）
• 和字符串一样，列表同样可以被索引和截取，被截取后返回新列表
  截取格式

变量[头下标:尾下标]

列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

# noinspection PyUnresolvedReferences
# encoding:utf-8
list = [ 'abcd', 786 , 2.23, '4rvfg', 70.2 ]
tinylist = [123, '2333']
print(list)            # 输出完整列表
print(list[0])         # 输出列表第一个元素
print(list[1:3])       # 从第二个开始输出到第三个元素
print(list[2:])        # 输出从第三个元素开始的所有元素
print(tinylist * 2)    # 输出两次列表
print(list + tinylist) # 连接列表
del list[2]            # 删除列表的的元素

第三个参数为负数表示逆向读取，可用于翻转字符串：

# noinspection PyUnresolvedReferences
# encoding:utf-8
def reverseWords(input):
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords = inputWords[-1::-1]
    # 重新组合字符串
    output = ' '.join(inputWords)
    return output
if __name__ == "__main__":
    input = 'hello world'
    rw = reverseWords(input)
    print(rw)

del 语句

使用 del 语句可以从一个列表中依索引删除一个元素。

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

列表函数&方法

#函数
len(list)#列表元素个数
max(list)#返回列表元素最大值
min(list)#返回列表元素最小值
list(seq)#将元组转换为列表
#方法
list.append(obj)#在列表末尾添加新的对象
list.count(obj)#统计某个元素在列表中出现的次数
list.extend(seq)#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)#从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)#将对象插入列表
list.pop([index=-1])#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)#移除列表中某个值的第一个匹配项
list.reverse()#反向列表中元素
list.sort( key=None, reverse=False)#对原列表进行排序
list.clear()#清空列表
list.copy()#复制列表

例子

#类似 insert, remove 或 sort 等修改列表的方法没有返回值
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

将列表当做堆栈使用

栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）
用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

将列表当作队列使用

队列里第一加入的元素，第一个取出来
效率不高：在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

列表推导式

看例子吧，我觉得例子更好理解

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
#if 子句作为过滤器
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
#循环
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
#以使用复杂表达式或嵌套函数
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

4.Tuple（元组）

• 元组（tuple）与列表类似，但是元组的元素不能修改。
• 元组写在小括号 () 里，元素之间用逗号隔开。

# noinspection PyUnresolvedReferences
# encoding:utf-8
tuple = ( 'abcdd', 786, 2.23, 'thrbrdfsudfssbnobrttbtnbtb', 70.2)
tinytuple = (123, 'hcdgfb')
print(tuple)             # 输出完整元组
print(tuple[0])          # 输出元组的第一个元素
print(tuple[1:3])        # 输出从第二个元素开始到第三个元素
print(tuple[2:])         # 输出从第三个元素开始的所有元素
print(tinytuple * 2)     # 输出两次元组
print(tuple + tinytuple) # 连接元组

• 元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。
• 可以把字符串看作一种特殊的元组。
• tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

• 函数返回多个值的时候，是以元组的方式返回的。
• string、list 和 tuple 都属于 sequence（序列）

元组内置函数

len(tuple)#计算元组元素个数。	
max(tuple)#返回元组中元素最大值。	
min(tuple)#返回元组中元素最小值。	
tuple(iterable)#将可迭代系列转换为元组。

元组的不可变指的是元组所指向的内存中的内容不可变
重新赋值的元组 ，绑定到新的对象，不是修改原来的对象。

5.Set（集合）

• 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
• 基本功能是进行成员关系测试和删除重复元素。
• 可以使用大括号 { } 或者 set() 函数创建集合。
• 创建一个空集合必须用 set() 而不是 { }
• { } 是用来创建一个空字典。
• 集合是无序的，所以不支持索引

parame = {value01,value02,...}
set(value)

# noinspection PyUnresolvedReferences
# encoding:utf-8
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)   # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Taobao' in sites :
    print('Taobao 在集合中')
else :
    print('Taobao 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

结果

集合内置方法

add()	#为集合添加元素
clear()	#移除集合中的所有元素
copy()	#拷贝一个集合
difference()	#返回多个集合的差集
difference_update()	#移除集合中的元素，该元素在指定的集合也存在。
discard()	#删除集合中指定的元素
intersection()	#返回集合的交集
intersection_update()	#返回集合的交集。
isdisjoint()	#判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	#判断指定集合是否为该方法参数集合的子集。
issuperset()	#判断该方法的参数集合是否为指定集合的子集
pop()	#随机移除元素
remove()	#移除指定元素
symmetric_difference()	#返回两个集合中不重复的元素集合。
symmetric_difference_update()	#移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	#返回两个集合的并集
update()	#给集合添加元素

集合推导式

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

6.Dictionary（字典）

• 列表是有序的对象集合，字典是无序的对象集合。
• 字典当中的元素是通过键来存取的，而不是通过偏移存取。
• 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
• 键(key)必须使用不可变类型。
• 在同一个字典中，键(key)必须是唯一的。
• 字典同样是无序的，但由于其元素是由键（key）和值（value）两个属性组成的键值对，可以通过键（key）来进行索引
• 使用了一个称为散列表（hashtable）的算法
  特点就是：不管字典中有多少项，in操作符花费的时间都差不多。
  如果把一个字典对象作为for的迭代对象，那么这个操作将会遍历字典的键：

# noinspection PyUnresolvedReferences
# encoding:utf-8
dict = {} #创建空字典
dict['one'] = "aaaaaaaaaaaa" # 添加信息
dict[2]= "bbbbbb" # 修改信息
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
tinydict = {'name': 'aaaaa','code':1, 'site': 'www.baidu.com'}
print(dict['one'])       # 输出键为 'one' 的值
print(dict[2])           # 输出键为 2 的值
print(tinydict)          # 输出完整的字典
print(tinydict.keys())   # 输出所有键
print(tinydict.values()) # 输出所有值

字典内置函数

len(dict)#计算字典元素个数，即键的总数
str(dict)#输出字典，以可打印的字符串表示
type(variable)#返回输入的变量类型，如果变量是字典就返回字典类型。

字典内置方法

radiansdict.clear()
#删除字典内所有元素
radiansdict.copy()
#返回一个字典的浅复制
radiansdict.fromkeys()
#创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)
#返回指定键的值，如果值不在字典中返回default值
key in dict
#如果键在字典dict里返回true，否则返回false
radiansdict.items()
#以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys()
#返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.setdefault(key, default=None)
#和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2)
#把字典dict2的键/值对更新到dict里
radiansdict.values()
#返回一个迭代器，可以使用 list() 来转换为列表
pop(key[,default])
#删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()
#随机返回并删除字典中的最后一对键和值。

遍历

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

序列遍历

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe
#同时遍历两个或更多的序列，可以使用 zip() 组合
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.
#要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数
>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1
#要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

7.Python数据类型转换

int(x [,base]) #将x转换为一个整数
float(x) #将x转换到一个浮点数
complex(real [,imag]) #创建一个复数
str(x) #将对象 x 转换为字符串
repr(x) #将对象 x 转换为表达式字符串
eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) #将序列 s 转换为一个元组
list(s) #将序列 s 转换为一个列表
set(s) #转换为可变集合
dict(d) #创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) #转换为不可变集合
chr(x) #将一个整数转换为一个字符
ord(x) #将一个字符转换为它的整数值
hex(x) #将一个整数转换为一个十六进制字符串
oct(x) #将一个整数转换为一个八进制字符串

四、Python3 解释器

• Python 解释器不止一种，有 CPython、IPython、Jython、PyPy 等。
• CPython 就是用 C 语言开发的了，是官方标准实现，拥有良好的生态，所以应用也就最为广泛了。
• IPython 是在 CPython 的基础之上在交互式方面得到增强的解释器（http://ipython.org/）。
• Jython 是专为 Java 平台设计的 Python 解释器（http://www.jython.org/），它把 Python 代码编译成 Java 字节码执行。
• PyPy 是 Python 语言（2.7.13和3.5.3）的一种快速、兼容的替代实现（http://pypy.org/），以速度快著称。
• Python 的编程模式分为两种：交互式，脚本式。

五、运算符

• 算术运算符（不说了）
• 比较（关系）运算符（不说了）
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

1.赋值运算符

**= 幂赋值运算符

c **= a #等效于 c = c ** a

//= 取整除赋值运算符

c //= a #等效于 c = c // a

:= 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。
在这个示例中，赋值表达式可以避免调用 len() 两次:

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

2.位运算符

按位运算符是把数字看作二进制来进行计算
&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1
^按位异或运算符：当两对应的二进位相异时，结果为1
~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
<<左移动运算符：运算数的各二进位全部左移若干位，由"<<“右边的数指定移动的位数，高位丢弃，低位补0
>>右移动运算符：把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数

# noinspection PyUnresolvedReferences
# encoding:utf-8
a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0
c = a & b;  # 12 = 0000 1100
print("c 的值为：", c)
c = a | b;  # 61 = 0011 1101
print("c 的值为：", c)
c = a ^ b;  # 49 = 0011 0001
print("c 的值为：", c)
c = ~a;  # -61 = 1100 0011
print("c 的值为：", c)
c = a << 2;  # 240 = 1111 0000
print("c 的值为：", c)
c = a >> 2;  # 15 = 0000 1111
print("c 的值为：", c)

结果：

3.逻辑运算符

# noinspection PyUnresolvedReferences
# encoding:utf-8
a = 10
b = 20
if (a and b):
    print("1 - 变量 a 和 b 都为 true")
else:
    print("1 - 变量 a 和 b 有一个不为 true")
if (a or b):
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")
# 修改变量 a 的值
a = 0
if (a and b):
    print("3 - 变量 a 和 b 都为 true")
else:
    print("3 - 变量 a 和 b 有一个不为 true")
if (a or b):
    print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("4 - 变量 a 和 b 都不为 true")
if not (a and b):
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")

4.成员运算符

in如果在指定的序列中找到值返回 True，否则返回 False。
not in如果在指定的序列中没有找到值返回 True，否则返回 False。

a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

5.身份运算符

is判断两个标识符是不是引用自一个对象。
x is y类似 id(x) == id(y) , 返回布尔值
is 通过 id 来判断两个变量是否是引用同一个内存地址
is not是判断两个标识符是不是引用自不同对象。
x is not y ， 类似 id(a) != id(b)，返回布尔值

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的对象")
else:
   print ("1 - a 和 b 没有相同的对象")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的对象")
else:
   print ("2 - a 和 b 没有相同的对象")

6.Python运算符优先级