目录
Python版本
标识符
字母、下划线和数字组成，第一个字符必须是字母或下划线，对大小写敏感
保留字
保留字即关键字，不能用作标识符名称。下面的keyword 模块，可以输出当前版本的所有关键字。
>>> import keyword
>>> keyword.kwlist注释
单行注释以 # 开头，多行注释可用 # 或 ' ' ' 或 " " " ，嵌套多行注释会导致语法错误，单行注释嵌套在多行注释中是合法的。
# 单行注释
'''
多行注释
多行注释
'''
"""
多行注释
多行注释
"""缩进
使用缩进来表示代码块，缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
if True:
print ("True")
else:
print ("False")多行语句
语句很长，可以使用反斜杠 \ 来实现多行语句。在 [], {}, 或 () 中的多行语句，不需要用反斜杠 \ 。
total = item_one + \
item_two + \
item_three
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']同一行显示多条语句
在同一行中使用多条语句，语句之间使用分号 ; 分割。
import sys; x = 'runoob'; sys.stdout.write(x + '\n')import 与 from...import
Python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
将某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
变量
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。等号（=）用来给变量赋值，等号左边是一个变量名，等号右边是存储在变量中的值。
number = 100 # 整型变量
longth = 1000.0 # 浮点型变量
name = "Linda" # 字符串Python允许同时为多个变量赋值，也可以为多个对象指定多个变量。
a = b = c = 1 #创建一个整型对象，从后向前赋值1，三个变量被赋予相同的数值
a, b, c = 1, 2, "hi" #两个整型对象1和2分配给变量a和b，字符串对象"hi"分配给变量c。
数据类型
Python3 中常见的数据类型：
Number（数字）、String（字符串）、Bool（布尔类型）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）
不可变：Number（数字）、String（字符串）、Tuple（元组）
可变：List（列表）、Dictionary（字典）、Set（集合）
Number（数字）
数字类型
整数(int) ：通常被称为整型，是正或负整数，不带小数点。只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
可用多种进制表示整数：十进制、二进制（0b或0B开头，由0和1组成）、八进制（以0o或0O开头，由 0~7 组成）、十六进制（以0x或0X开头，由 0~9 和 A~F（或 a~f）组成）
浮点数(float) ：浮点数也就是小数，如1.23，3.14，-9.01等，小数的指数形式 aEn 或 aen (a×10n) a表示尾数部分，十进制数；n是指数部分，十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分；如：2.1E5 = 2.1×105、3.7E-2 = 3.7×10-2 等。
复数(complex) ：复数由实部和虚部组成，形式为 a + bj，其中 a 是实部，b 是虚部，j 表示虚数单位。如 1 + 2j、 1.1 + 2.2j 等。
数值运算
在混合计算时，Python会把整型转换成为浮点数。
>>> 5 + 4 # 加法
>>> 9
>>> 4.3 - 2 # 减法
>>> 2.3
>>> 3 * 7 # 乘法
>>> 21
>>> 2 / 4 # 除法，得到一个浮点数
>>> 0.5
>>> 2 // 4 # 除法，得到一个整数
>>> 0
>>> 17 % 3 # 取余
>>> 2
>>> 2 ** 5 # 乘方
>>> 32String（字符串）
单引号和双引号使用完全相同，使用三引号( ''' 或 """ )可以指定一个多行字符串。
Python没有单独的字符类型，一个字符就是长度为 1 的字符串。字符串不能改变，可以用 + 运算符连接在一起，用 * 运算符重复，会按字面意义级联字符串。反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
>>> '字符串1'+'字符串2'
>>> '字符串1字符串2'
>>> 'hi'*3
>>> 'hihihi'
>>> "this " "is " "string"
>>> "this is string"
>>> r"this is a line with \n"
>>> "this is a line with \n"字符串切片 str[start:end:step]，其中 start（包含）是切片开始的索引，end（不包含）是切片结束的索引，step是步长参数。字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
>>> str='123456'
>>> print(str[0:5:2]) # 输出从第一个开始到最后一个且每隔一个的字符（步长为2）
>>> 135
>>> print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
>>> 12345
>>> print(str[0]) # 输出字符串第一个字符
>>> 1
>>> print(str[2:]) # 输出从第三个开始后的所有字符
>>> 3456
>>> print(str[:-4]) # 输出从倒数第四个开始前面的所有字符
>>> 12bool（布尔类型)
布尔类型只有两个值：True 和 False，True 和 False 都是关键字
Python3 中，bool 是 int 的子类，布尔值可以被看作整数来使用，True等价于1、False等价于0 ；布尔类型可以和其他数据类型进行比较，在比较时，Python 会将 True 视为 1，False 视为 0； 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。
>>> True+1
2
>>> False+1
1
>>> True<2
True
>>> False>-1
True
可以使用 bool() 函数将其他类型的值转换为布尔值。以下值在转换为布尔值时为 False：None、False、零 (0、0.0、0j)、空序列（如 ''、()、[]）和空映射（如 {}）。其他所有值转换为布尔值时均为 True。
print(bool(0)) # False
print(bool('')) # False
print(bool([])) # False
print(bool(42)) # True
print(bool('Python')) # True
print(bool([1, 2, 3])) # True布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。
print(True and False) # False
print(True or False) # True
print(not True) # False布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。
if True:
print("This will always print")List（列表）
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同，它支持数字、字符串甚至可以包含列表（嵌套）。
和字符串一样，列表同样可以被索引和截取，加号+进行列表连接，星号*进行重复操作，与字符串不一样的是，列表中的元素是可以改变的。
>>> a = [1, 2, 3, 'hi', [5, 6]]
>>> print(a[1])
>>> 2
>>> print(a[2:])
>>> [3, 'hi', [5, 6]]
>>> b = [7, 'hello']
>>> print(a + b)
>>> [1, 2, 3, 'hi', [5, 6], 7, 'hello']
>>> print(b * 2)
>>> [7, 'hello', 7, 'hello']
>>> a[1] = 'linda'
>>> print(a)
>>> [1, 'linda', 3, 'hi', [5, 6]]Tuple（元组）
元组与列表相似，元组中的元素类型也可以不相同，但元组写在小括号 () 里，元素之间用逗号隔开，且元组的元素不能修改（虽然tuple的元素不可改变，但它可以包含可变的对象，如list列表）。和字符串一样，元组同样可以被索引和截取，加号+进行元组连接，星号*进行重复操作。
>>> tup1 = (1, 2, 'hi', [3,4])
>>> print(tup1[0])
>>> 1
>>> print(tup1[2:])
>>> ('hi', [3,4])
>>> tup2 = (1, 2)
>>> print(tup1 + tup2)
>>> (1, 2, 'hi', [3,4], 1, 2)
>>> print(tup2 * 2)
>>> (1, 2, 1, 2)构造包含 0 个或 1 个元素的元组比较特殊，如果没有逗号，Python会将括号解释为数学运算中的括号，而不是元组的表示。
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
tup3 = (6) # tup3将是整数类型而不是元组类型注：string、list 和 tuple 都属于 sequence（序列）。
Set（集合）
Set（集合）是一种无序、可变的数据类型，用于存储唯一的元素；集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作；集合使用大括号 {} 表示，元素之间用逗号 , 分隔。也可以使用 set() 函数创建集合。
>>> sites = {'Google', 'Baidu', 'Facebook'}
>>> print(sites)
>>> {'Google', 'Baidu', 'Facebook'}
>>> a = set('abracadabra')
>>> print(a) # 输出集合，重复的元素被自动去掉
>>> {'a','b','r','c','d'}
>>> b = set('alczm')
>>> print(a - b) # a 和 b 的差集
>>> {'r', 'b', 'd'}
>>> print(a | b) # a 和 b 的并集
>>> {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
>>> print(a & b) # a 和 b 的交集
>>> {'c', 'a'}
>>> print(a ^ b) # a 和 b 中不同时存在的元素
>>> {'z', 'b', 'm', 'r', 'l', 'd'}Dictionary（字典）
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合，键(key)必须使用不可变类型，在同一个字典中，键(key)必须是唯一的。字典当中的元素是通过键来存取的，而不是通过偏移存取。
>>> tinydict = {}
>>> tinydict['name'] = 'Joe'
>>> tinydict['age'] = 18
>>> print(tinydict)
>>> {'name': 'Joe', 'age': 18}
>>> tinydict2 = {'name': 'Zhangsan', 'age': 19}
>>> print(tinydict2['age']) # 输出键为 'age' 的值
>>> 19
>>> print (tinydict.keys()) # 输出所有键
>>> dict_keys(['name', 'age'])
>>> print (tinydict2.values()) # 输出所有值
>>> dict_values(['Zhangsan', 19])构造函数 dict() 可以直接从键值对序列中构建字典，也可以使用字典推导式构建字典。
>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
>>> {'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> dict(Runoob=1, Google=2, Taobao=3)
>>> {'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
>>> {2: 4, 4: 16, 6: 36}查询变量所指的对象类型
内置的 type() 函数可以用来查询变量所指的对象类型，可以用 isinstance 来判断。
>>> a, b, c, d, e, list = 20, 5.5, True, 4+3j, Ture, ['sdf',234]
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'> <class 'bool'> <class 'list'>
>>> num = 1000
>>> isinstance(num, int)
>>> True
isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型；sinstance()会认为子类是一种父类类型。
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> isinstance(B(), A)
True
>>> type(B()) == A
False
数据类型转换
数据类型转换可以分为两种：
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
隐式类型转换
Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。如下例，Python 会将较小的数据类型（整型）转换为较大的数据类型（浮点型），以避免数据丢失。
>>> num_int = 123
>>> num_flo = 1.23
>>> num_new = num_int + num_flo
>>> print("num_int 数据类型为:",type(num_int))
>>> num_int 数据类型为: <class 'int'>
>>> print("num_flo 数据类型为:",type(num_flo))
>>> num_flo 数据类型为: <class 'float'>
>>> print("num_new 值为:",num_new,",num_new 数据类型为:",type(num_new))
>>> num_new 值为: 124.23 ,num_new 数据类型为: <class 'float'>显式类型转换
用户将对象的数据类型转换为所需的数据类型，如使用 int()、float()、str() 等预定义函数来执行显式类型转换。
>>> a = int(2.8) # int()强制转换为整型, a输出结果为2
>>> b = float("3") # float()强制转换为浮点型, b输出结果为3.0
>>> c = str(6) # str()强制转换为字符串类型, c输出结果为'6'
>>> num_int = 123
>>> num_str = "456"
>>> num_str = int(num_str) # 强制转换为整型
>>> num_sum = num_int + num_str
>>> print("num_sum 值为:",num_sum,",num_sum 数据类型为:",type(num_sum))
>>> num_sum 值为: 579 ,num_sum 数据类型为: <class 'int'>以下几个内置的函数可以执行数据类型之间的转换，这些函数返回一个新的对象，表示转换的值。
运算符
算术运算符
+ 加、- 减、* 乘、 / 除、 %取模、 **幂、 //整除（得到整数）
比较运算符
==等于、 !=不等于、 >大于、 <小于、 >=大于等于、 <=小于等于
赋值运算符
=简单赋值、 +=加法赋值（b += a 等价于 b = b + a）、-=减法赋值、 *=乘法赋值、 /=除法赋值、 %=取模赋值、 **=幂赋值、//=取整赋值、:=海象运算符（Python3.8新增）
# 传统写法
n = 10
if n > 5:
print(n)
# 使用海象运算符，作用简化循环条件或表达式中的重复计算
if (n := 10) > 5:
print(n)位运算符
位运算符是把数字看作二进制来进行计算
&按位与运算符（两者同为1，则结果为1，否则为0）、 | 按位或（有一个为1，则结果为1）、^ 按位异或（两者相异，则结果为1）、 ~按位取反（1变0，0变1）、 <<左移运算符（由"<<"右边的数指定移动的位数，高位丢弃，低位补0）、 >>右移运算符（低位丢弃，高位补0）
a = 0011 1100 # a为60，a换成二进制
b = 0000 1101 # b为13，b换成二进制
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
a = 0011 1100
~a = 1100 0011
a<<2 = 1111 0000
a>>2 = 0000 1111逻辑运算符
and 布尔“与” or 布尔“或” not 布尔“非”
python中逻辑运算符and，or的用法以及运算的核心思想——“短路逻辑”超详细讲解
只运算bool类型
a and b （当a和b都为真时，结果才为真，否则为假）
a or b （当a和b有一个为真，结果就为真，否则为假）
not a （当a为真，结果为假，反之结果为真）
>>> a = 1>2 and 1<2 #and的左边为False，右边为True
>>> print(a)
>>> False
>>> b = 1>2 or 1<2 #or的左边为False，右边为True
>>> print(b)
>>> True运算其它类型
a and b （若 a 为 False，表达式返回 a 的值，否则返回 b 的值）
a or b （若 a 为 True，表达式返回 a 的值，否则返回 b 的值）
与运算中，一个为假，整个运算都为假；a and b，如果a已经为假了，不管b的真假，结果都为假，所以直接返回a的值；如果a为真，不确定b的真假，要继续运算，所以返回b的值。
或运算，只要一个为真，整个运算都为真；a or b，只要a是真，结果就为真，所以直接返回a的值；反之，返回b的值。
在python中：None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了 __ nonzero __ () 或 __ len __ () 方法且方法返回 0 或False，则其实例也被当作False，其他对象均为True。
a = 1
b = 0
c = "Hello World"
d = ""
print(a and b) #输出结果为 0
print(a or b) #输出结果为 1
print(c and d) #输出结果为 "" /（即什么都不输出）
print(c or d) #输出结果为 Hello World
print(a and c) #输出结果为 Hello World
短路逻辑
若and左侧为false，则短路之后所有的and表达式，直到出现or，则返回and左侧表达式的值继续与or的右侧参与运算。
若or左侧为true，则短路之后所有的表达式，不管是or还是and，直接输出or左侧表达式的值。
若 or 的左侧为 False ，或者 and 的左侧为 True 则不能使用短路逻辑。
>>> result1 = 0 and 100 and 200 and 300 and 400
>>> print(result1)
>>> 0
>>> result2 = 10 or 0 or "" or {} or ()
>>> print(result2)
>>> 10
>>> result3 = 10 or 0 and 20 and 30
>>> print(result3)
>>> 10
>>> result4 = 10 and 0 or {} and 30
>>> print(result4)
>>> {}成员运算符
in 如果在指定的序列中找到值返回 True，否则返回 False。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。
>>> a = 1
>>> b = [1,2,3]
>>> print(a in b)
>>> True
>>> print(6 not in b)
>>> True身份运算符
is 判断两个标识符是不是引用自一个对象
is not 判断两个标识符是不是引用自不同对象
>>> c = 10
>>> d = 10
>>> e = 20
>>> print(c is d)
>>> True
>>> print(id(c) == id(d)) #id() 函数用于获取对象内存地址
>>> True
>>> print(c is not e)
>>> True注意：is 用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。
参考：
68万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
