• 1. Python 基础语法
  • 1.1. 注释
  • 1.2. 缩进
  • 1.3. 续行
  • 1.4. 标识符
  • 1.5. 转义序列
  • 1.6. 数字
  • 1.7. 字符串
  • 1.8. 其他
• 2. Python 运算符
  • 2.1. 赋值运算符
  • 2.2. 算数运算符
  • 2.3. 关系运算符(比较运算符)
  • 2.4. 逻辑运算符
  • 2.5. 位运算符
    • 2.5.1. 原码、反码、补码、负数表示法
    • 2.5.2. 位运算符
  • 2.6. 成员、身份运算符
  • 2.7. 运算符优先级（由高到低）
• 3. Python 内存管理
  • 3.1. Python 的内存特性
  • 3.2. Python 的 GC 管理
• 4. 程序控制
  • 4.1. 分支结构
    • 4.1.1. 单分支
    • 4.1.2. 多分支
    • 4.1.3. 分支嵌套
    • 4.1.4. 小结
  • 4.2. 循环
  • 4.3. for 循环
  • 4.4. while 循环
  • 4.5. 循环 continue 语句
  • 4.6. 循环 break 语句
  • 4.7. 循环 else 子句

1. Python 基础语法

1.1. 注释

  在 Python 中主要的使用的注释方式是 # 号，# 号后面紧跟注释内容，当然在某些情况下三个单引号/双引号也是可以的，比如在函数中可以作为函数的说明。

num = int(input('Please input a number: '))    # 输入一个数字
if num >= 1000:               # 条件判断
    if num >= 10000:          # 大于 10000
        print('5')           # 打印 5 位
    else:                     ''' 否则 '''
        print('4')           ''' 打印 4'''
else:
    if num >= 100:
        print('3')
    elif num >= 10:
        print('2')
    else:
        print('1')

1.2. 缩进

  C 语言用花括号来表示层级关系，不够简洁，而 Python 使用的是缩进的方式表示层级关系，一般约定 4 个空格 缩进为一个层级，层次明确清晰，代码格式规范统一，可读性高。

1.3. 续行

  当一行代码超过了一屏能显示的最大长度后，为了直观，我们会另起一行接着写，在 Python 中在行尾使用 \ 标识续行，但如果在表达式或者某一段代码中使用了括号，那么 Python 认为括号内是一个整体，内部跨行不需要使用 \。

1.4. 标识符

  很多时候，我们写代码的过程中会对我们需要的数据进行存储并命名，方便后续使用，这个命名被称为标识符，针对标识符 Python 有如下要求：

1. 一个名字，用来指代一个值
2. 只能是字母、数字下划线的组合
3. 只能以字母或者下划线开头
4. 不能是 Python 的关键字，例如 def、class 就不能作为标识符
5. Python 是大小写敏感的

  为了避免误解，造成不必要的麻烦，在我们写代码的过程中还应遵循下列约定：

1. 不允许使用中文
2. 不允许使用歧义单词，例如 class_
3. 在 Python 中不要随便使用下划线开头的标识符

1.5. 转义序列

  python 中内置了很多特殊的符号，比如换行、制表符等，部分含义如下：

• \\：单个 \ 表示转义，\\ 就指代 \ 这个符号。
• \t：制表符，一般用来进行输出格式调整，比如对齐等
• \r：回车符
• \n： 换行符

1.6. 数字

  在 Python 中数字主要分为三种类型：整型，浮点数,复数。

• 整型：在 Python3 中，不区分 long 和 int，所有整型均为 int 类型，当然还包括了不同进制，比如 2 进制，8 进制，16 进制等，都为 int 类型。需要注意的是 Python 中的 bool 型 属于整型的子类，所以 bool 的两个值，用整型可以表示为，0：False； 非 0：True。
• 浮点数：即带小数点的 float 型
• 复数：用于科学计算，比如 1+2j 等

1.7. 字符串

  在 Python 中，成对使用单引号 ' 或双引号 " 括起来表示引用字符的序列，成对使用三个单引号 ''' 或双引号 """，则可以跨行，并且在其中自由的使用单双引号。除此之外还可以在字符串前加一定的符号来确切的表示字符串。

• r： 字符串前加 r 或者 R，表示该字符串不做任何处理，所见即所得
• f： 3.6 版本开始新增的前缀，表示格式化字符串，例如变量引用

str1 = r'hello\nworld'   # 由于使用了 r 前缀，所以并不会把 \n 解释为换行
str2 = f'nihao {str1}'   # 类似于 'nihao {}'.format(str1)

print(str1)   
hello\nworld

print(str2)   
nihao hello\nworld

1.8. 其他

  在 Python 中还有一些地方和其他语言有很大区别，比如：

1. 常量：本身指代一旦赋值就不能被改变的标识符，但是 Python 中无法定义常量，换句话说就是，Python 中，只要你看得到的东西，都是可以进行修改的。
2. 字面常量：一个单独的量，看字面意思就知其含义，比如 12、"abc"、'2341356514.03e-9'
3. 变量：赋值后，可以改变值的标识符。

注意：在 Python 中是不需要提前申明变量的类型的，所以变量的赋值即定义

# 定义了一个 total 变量，它的值是 2500，类型是整数型。 赋值即定义
total = 2500   

2. Python 运算符

  在 Python 中，运算符是比较重要的知识了，因为很多地方都需要知道多个数据的大小关系、逻辑关系，当然赋值也是需要用到运算符的，根据类型的不同，主要分为 赋值运算符、算数运算符、关系运算符、逻辑运算符 以及 位运算符。

2.1. 赋值运算符

  我们日常使用的 = 号 就属于赋值运算符的一种，在 Python 还有如下算数运算符：

• =：赋值，例如：x=3,y='abc'
• += ：自加，例如：x+=2，则表示 x=x+2
• -=：自减，例如：x-=2，表示 x=x-2
• *=：自乘，例如：x=2, 表示 x=x2
• /=：自除，例如：x/=2，表示 x=x/2
• %=：自取余，例如：x%=2，表示 x=x%2。 x 对 2 取余数，假如 x=6，那么取余为 0

  当把数字赋值给一个变量的时候不用加引号，而将字符串赋值给变量的时候需要加引号，否则 python 会认为你赋值的是另一个变量，而非字符串。

2.2. 算数运算符

  数学计算中的 +，-，* 等都属于算数运算符的一种，其他的运算符如下：

• +：加，用来计算数字，如果字符串、列表等相加，等于是把两个对象拼接到一起
• -：减，同数学减
• *：乘，同数学乘
• /：自然除，结果是浮点数，4 / 3 答案是 1.33333。注：2.x中 / 和 // 都是整除
• //：整除，运算结果只取整数，如果用 4 // 3 答案是 1
• %：表示取余数，10 % 2 余 0，10%3 余 1
• **：表示乘方 2**3 表示 2 的 3 次方

2.3. 关系运算符(比较运算符)

  关系运算符顾名思义就是判断关系的，比如大于，小于，等等，需要注意的是返回值为布尔值：即 True 或者 False。更多的符号有：

• >：大于，例如 1>2，值是 False
• <：小于，例如 1<2，值是 True
• >=：大于等于，例如 1>=2，值是 False
• <=: 小于等于，例如 1<=2，值是 True
• ==：是否等于，例如 1==2，值是 False
• !=：不等于，例如 1!=2，值是 True

2.4. 逻辑运算符

  逻辑运算符主要包含了三个:and,or,not

• and：逻辑与，只要有 1 个是 False 那么值就是 False，1==2 and 1<2 的值是 False，1!=2 and 1<2 的值是 True
• or：逻辑或，只要有一个是 True 那么值就是 True，1=2 and 1<2 的值是 True
• not：逻辑非，取反 not 1<2 的值是 False

逻辑运算符又被称为短路运算符：

1. and 如果第一个表达式为 False，后面就没必要计算了，这个逻辑表达式一定为 False
2. or 如果第一个表达式为 True，后面就没必要计算了，这个逻辑表达式一定为 True

2.5. 位运算符

  故名思议，位运算符主要是针对位进行的计算的，它比加减运算略快，通常也比乘除法运算要快很多。说到位就不得不提补码了，因为计算机存储负数时使用的都是补码。

2.5.1. 原码、反码、补码、负数表示法

  早期数字电路的CPU中的运算器实现了加法器，但是没有减法器，减法要转换成加法，如何理解呢？例如 5-1，在计算机中进行计算的时候实际上用的是 5+(-1), 而负数在内存中并不会直接写个 -0b1, 负数在计算机中使用的是补码进行存储和运算的，计算机中有关数字的都有什么玛？什么是补码？

• 原码：即人类可读的二进制位(0b101,0b1)
• 反码：正数的反码与原码相同；负数的反码符号位不变其余按位取反
• 补码：正数的补码与原码相同；负数的补码符号位不变其余按位取反后 + 1

  需要注意的是：负数在计算机中使用补码进行存储，比如 -1 在计算机存储的是 1111 1111，负数补码的补码就表示负数本身。正数的原码反码补码都是相同的，计算机存储内存中的数字都为二进制位，当我们想要查看具体代表的值时，计算机会转换为人类可读的原码进行显示，即：如果最高的符号位是 0，那么认为它是正数，不进行去补，而最高的符号位如果是 1，那么它会认为它是负数，会按照负数的取补的规则进行计算后展示。

例题：计算机计算 5 - 1 的过程

# 计算机中计算的是
5 + -1

# 推导步骤：

 0000 0101   # 5 的原码

 1000 0001   # -1 的原码
 1111 1110   # -1 的反码
 1111 1111   # -1 的补码

 0000 0101   # 5 是正数，补码与原码相同
 1111 1111   # -1 的补码
10000 0100   # 溢出位舍去

 0000 0100   # 5-1 的结果为 4

例题：计算～12

# ~12 表示取反
# 先将初始数转换为二进制，再对补码去取反

0000 1100 # 12 的补码与原码相同
1111 0011 # 12 按位取反，得到一个补码
1000 1100 # 要转换成原码便于人类阅读，补码再次取反，得到反码
1000 1101 # +1 得到原码

转换为 10 进制就是 -13 了

2.5.2. 位运算符

  针对位的运算符主要有:& | ~ ^ << >>.

• &：按位与，相当于按位相乘( 1101 & 0001 , 按位与结果是 0001 )
• |：按位或，相当于按位相加，不进位( 1101 | 0001，按位或结果是 1101 )
• ^：按位异或
• ~：取反
• <<：左移(位)
• >>：右移(位)，例如 32 >> 3 等于 32 // 8 , 结果是 4

位运算符，日常使用的不多，但是如果你想做一个高级程序员，那么位运算是你必备的技能哦

2.6. 成员、身份运算符

• in / not in 成员测试，测试一个元素是否在一个序列中
• is / is not 统一性的测试

2.7. 运算符优先级（由高到低）

小结：

1. 算数运算符 > 位运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
2. 单目运算符 > 双目运算符 （一元运算符 > 二元运算符）
3. 记不住优先级的话，可以用括号，括号内的优先级更高
4. 长表达式，多用括号，易懂易读。

注意：在 Python 中，赋值即定义，如果一个变量已经定义，赋值相当于重新定义

3. Python 内存管理

  计算机的内存大多是线性编址的(1001,1002,1003 门牌号，挨着排列的)，现在有一个变量 var1 需要 1001～1007 空间，var2 需要 1008～1012 空间，如下图

memory1.png

  过了一段时间以后，var1 中的 1002，和 1005 不用了，var2 的 1010 也不用了，内存就变成了如下的情况：

memory2.png

  这时又来了一个 var3 需要申请 3 个连续的空间，在当前情况下就没办法进行分配了

memory3.png

  这种情况就是我们常说的内存空洞了，也叫内存碎片化，如果没办法进行碎片整理，那么这些分散的内存空间将没有办法被重新使用

3.1. Python 的内存特性

1. 变量无需事先声明，也不需要指定类型，这是动态语言的特性
2. Python 使用引用计数记录所有对象的引用数。
3. 当对象的引用数变为 0，它就可以被垃圾回收 GC（Garbage Collection）
   • 当对变量进行赋值时，同时会增加该对象的引用计数
   • 函数或代码块运行完毕，变量会消亡，那么引用计数会减少

3.2. Python 的 GC 管理

  Python 在对内存进行管理时会像 Java 那样对内存进行分类，Java 中将内存分为了老生代，新生代，持久化代，而 Python 中则分成了 0，1，2 三代，其中 0 代可以理解为临时存储，1 代为短期存储，2 代为长期存储，当应用申请内存时，会根据内存情况先分配 0 带给程序使用，然后定期检查各个区的使用情况，如果某个程序在 0 区待的够久，那么在 Python 启动 GC 的时候，就会把它从 0 区移动到 1 区，同理在 1 区时间够久的，移动到 2 区。当然在启动 GC 的时候还会检查引用计数为 0 的对象，然后清理掉。
  需要注意的是，Python 启动 GC 的同时，不能进行其它的任务。频繁的垃圾回收将大大降低 Python 的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python 只会在特定条件下，自动启动垃圾回收。当 Python 运行时，会记录其中分配对象(object allocation) 和取消分配对象(object deallocation) 的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。

memory4.png

所以：

1. Python 编程中一般无需关心变量的存亡，一般也不用关心内存的管理，由 Python 的 GC 统一进行垃圾回收
2. 当有关 Python 性能问题的时候，就需要考虑变量引用的问题，尽量不要释放内存，交由 Python GC 来操作，除非你更懂它。

# 查看引用计数
# 由于 1，2，15 等这种常数，同时被 Python 语言解释器本身等引用，所以直接打印计数器它的引用计数并不会是 1。
>>> import sys
>>> x = []
>>> print(sys.getrefcount(x))    # 函数在执行时会进行参数传递操作，会使引用计数 + 1
2
>>> print(sys.getrefcount([])) 
1
>>> 

4. 程序控制

  Python 的程序控制主要分为顺序，分支，循环，这也和大多数语言是相同的。

• 顺序结构：按照先后顺序一条一条执行，比如：先起床，再刷牙，再吃饭
• 分支结构：根据不同的情况判断，条件满足后执行相应的操作，比如你去买个西红柿，如果西红柿新鲜就买两个，如果不新鲜就只买一个
• 循环结构：条件满足就反复执行，不满足就不执行或者不再执行(循环完毕)，比如吃饭，在吃饱这个条件满足之前一口一口不停地吃，直到吃饱为止

4.1. 分支结构

  计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。在 Python 中主要通过 if 以及 else 的搭配来完成条件判断的工作。条件判断主要有三种基本用法：单分支、多分支、分支嵌套。

4.1.1. 单分支

  顾名思义即如果怎么样，就怎么样。(if)

if expression:
    block

注意：
python 使用缩进作为其语句分组的方法，请使用 4 个空格
expression 表示条件表达式（比如：a>b）
statement 表示要执行的代码
表达式：是将不同的数据（包括变量、函数）用运算符号按一定规则连接起来的一种式子。

4.1.2. 多分支

  多分支有分为两种情况：

1. 如果满足条件，就怎么样；否则，就怎么样。(if、else)
2. 如果满足条件 1，就怎么样；如果满足条件 2，就怎么样；...；否则，就怎么样（if、elif、else）

if expression:
    block
else:
    block
 
# if、elif、else 都属于同级
  
if expression:
    block
elif expression:
    block
else:
    block

4.1.3. 分支嵌套

  分支嵌套，就是将多个两个或多个 if 判断进行层级嵌套，完成更精确的判断。

if expression:
    block           # 非必须，看情况
    if expression:
        block
    else:           # 非必须，看情况
        block       # 非必须，看情况
else:
    block
 

4.1.4. 小结

1. 条件的写法非常多，可以写一个表达式或者多个表达式都可以，表达式的值为 0，就表示 False，非 0，则表示 True。
2. if 就是判断，主要就是对表达式的逻辑值进行判断
3. 逻辑值（bool）包含了两个值：
   • True：表示非空的量（比如：string、tuple、list、set、dictionary），所有非零数。
   • False：表示 0，None，空的量(空字符串，空字典，空列表，空即可，空元祖) 等。这些对象与 False 等价

4.2. 循环

  为了让计算机能反复执行某一操作，我们需要循环语句来完成。Python 中的循环主要有两种：for 循环和 while 循环。

4.3. for 循环

  基本所有语言都有 for 关键字，它的曝光率远远超过其它关键字，但每个语言有它自己的格式，在 Python 中它的格式为

for element in iterable:
    block

element 在循环时表示元素的变量（自行指定）
iterable：这里表示一个可迭代对象，比如字符串，列表
block 表示要执行的代码段

  在很多情况下，我们需要循环一定次数，我们一般使用 range 函数来构建可迭代对象。

# range 用法说明：
range(stop) --> range object
range(start, stop [, step]) --> range object

  range 函数，接受一个变量，做为停止位，从 0 到 stop 开始依次循环，但是不包含停止位本身，所以我们称它为前包后不包

4.4. while 循环

语法：

while condition:
    block

  当条件满足即 condition 为 True，进入循环体，执行 block，每执行一次 block 都会检查一遍 condition，当 condition 为 False 时跳出循环体

4.5. 循环 continue 语句

  循环 continue 语句的作用是中断当前循环的当次执行，继续下一次循环

举例：计算10以内的偶数（for循环）

for i in range(10):
    if not i % 2:  # 与 2 相除没有余数，则为偶数
        print(i)

  还有其它的实现吗？

举例：计算10以内的偶数（for循环）

for i in range(0,10,2): # 减少迭代次数
    print(i)
    
for i in range(0,10): # 使用位与
    if i & 1:         # 奇数转换为二进制数后，最低位一定是 1
        continue
    print(i)

4.6. 循环 break 语句

  循环 break 语句的作用是终止当前循环

举例：计算1000以内的正整数能被7整除的前20个数（for循环）

count = 1
for i in range(7, 1000, 7):
    print(i)
    if count == 20:
        break
    count += 1

循环 continue、break 语句小结：

• continue 和 break 是循环的控制语句，只影响当前循环，包括 while、for 循环
• 如果循环嵌套，continue 和 break 也只影响语句所在的那一层循环
• continue 和 break 不是跳出语句块，所以 if cond: break 不是跳出 if，而是终止 if 外的 break 所在的循环

4.7. 循环 else 子句

语法：

while condition:
    block
else:
    block

for element in iterable:
    block
else:
    block

• 如果循环正常的执行结束，就执行 else 子句，即使循环都没有进去
• 如果使用 break 终止，else 子句不会执行