1、if、elif、else
条件判断语句，例如：
num = 5 if num < 0: print("num小于0") elif num == 0: print("num等于0") else: print("num大于0")
num大于0
2、True、False
布尔类型，True表示真，False表示假，例如：
if True: print("True!")
True!
3、None
Python中，一切皆可看作对象，“None”表示一个“空对象”，它不同于“NULL”，比如说当“None”作为判断语句的条件时，永远返回False，例如：
if None: print("我永远不会输出！")
4、and、or、not
其一：x or y 的值只可能是x或y； x为真，输出x ; x为假，输出y，例如：
print(1 or 0) print(0 or 1)
1 1
其二：x and y 的值只可能是x或y；x为真，输出y；x为假，输出x，例如：
print(1 and 0) print(0 and 1)
0 0
其三：在不加括号时，and 优先级大于 or，例如：
print(0 or 1 and 2)
2
注：在Python中，空字符串为假，非空字符串为真，非零的数为真，例如：
print('' or 1)
1
其四：not关键字表示取反的意思，例如：
print(not True) print(not 0)
False True
5、pass
pass关键字的主要作用就是占据位置，让代码整体完整，比如说如果一个if条件语句中的内容还没有想好，可以先用pass填坑，例如：
if True: pass
6、class
class关键字表示定义一个类，class之后紧跟着类名，类名加括号表示该类的一个对象，例如：
class A: pass a = A() print(type(a))
<class '__main__.A'>
其中，a为类A()的一个对象
7、def、return
def关键字表示定义一个函数，def之后紧跟函数名，括号内部为函数的参数，不管有没有参数，括号都是不可省略的，函数中包含return返回值，若省略，则返回默认空值，例如：
def sum(x, y): return x + y print(sum(1, 2))
3
8、try、except、finally
对于异常处理，可以用此类关键字操作。try中的代码在执行过程中若出现错误，便会执行except中的代码，否则，except中的代码不执行，但不论有没有错误，finally中的语句都会执行，例如：
def f(): try: print(1 / 0) except: print('2') finally: print('3') return '3' print(f())
2 3 3
从上面这个例子中可以看到，函数f()的返回值return语句放在了finally中，当然也可以放在其他地方，例如：
def f(): try: print('1') return '1' except: print('2') return '2' finally: print('3') return '3' print(f())
1 3 3
上面这个例子中，try、except和finally模块中都有return语句。此时，就会出现一个问题，到底会返回哪个值呢？
也许你猜对了！当然是finally中的return，具体原因为：首先执行try中的代码，此时return返回'1'，由于没有报错，所以except并不执行，但是finally一定会执行，而且finally中也有return语句，执行到该return时，'3'会覆盖'1'，所以最后返回的仍然是'3'
除此之外，有时候也会用到else语句，例如：
def f(): try: print('1') except: return '2' else: print('3') finally: print('4') return '4' print(f())
1 3 4 4
else语句存在的前提条件是try中没有return语句，否则else中的语句永远不会被执行。
此时，首先执行try，然后执行else，最后执行finally。
9、with、as
其一：with语句是什么？
有一些任务，可能事先需要设置，事后做清理工作。对于这种场景，Python的with语句提供了一种非常方便的处理方式。
一个很好的例子是文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。
首先，在.py文件的同级目录下创建一个hello.txt的文档，该文档中的语句为：Hello World！
（一）不用with语句，例如：
file = open("./hello.txt") data = file.read() file.close() print(data)
Hello World!
这样，就会出现两个问题。一，可能忘记关闭文件句柄；二，文件读取数据可能发生异常，没有进行任何处理。下面是处理异常的加强版本：
file = open("./hello.txt") try: data = file.read() finally: file.close() print(data)
Hello World!
虽然这段代码可以解决异常处理，但是太冗长了。这时候就需要用到with来进行处理，例如：
with open("./hello.txt") as file: data = file.read() print(data)
Hello World！
其二：with如何工作？
基本思想：with所求值得对象必须有一个_enter_()方法和一个_exit()_方法
执行流程：with后面的语句先执行，返回对象的_enter_()方法被调用，这个方法的返回值将被赋值给as后面的变量，然后执行：后面的语句，最后将调用前面返回对象的_exit_()方法
举个例子：
class Sample: def __enter__(self): print("In _enter_()") return "Foo" def __exit__(self, exc_type, exc_val, exc_tb): print("In _exit_()") def get_sample(): return Sample() with get_sample() as sample: print("sample:", sample)
In _enter_() sample: Foo In _exit_()
正如你所看到的，
1. _enter_()方法被执行
2. _enter_()方法返回的值"Foo"被赋值给sample
3. 执行：后面的代码
4. _exit_()方法被执行
其三：with最大的优点在于它可以处理异常。在如上所示的代码中，_enter_()方法和_exit_()方法都有一定的参数，这些参数在处理异常时相当有用，例如：
class Sample: def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): print("self:", self) print("exc_type", exc_type) print("exc_val", exc_val) print("exc_tb", exc_tb) def do_something(self): bar = 1 / 0 return bar + 10 with Sample() as sample: sample.do_something()
Traceback (most recent call last): self: <__main__.Sample object at 0x000000000278ECF8> exc_type <class 'ZeroDivisionError'> exc_val division by zero File "D:/WorkPlace/Python/test/hello.py", line 319, in <module> exc_tb <traceback object at 0x00000000027A7588> sample.do_something() File "D:/WorkPlace/Python/test/hello.py", line 315, in do_something bar = 1 / 0 ZeroDivisionError: division by zero
实际上，在with后面的代码块抛出任何异常时，_exit_()方法都会被执行。正如上例所示，异常抛出时，与之关联的exc_type、exc_val和exc_tb传给_exit_()方法，因此抛出的ZeroDivisionError异常被打印出来了。
类似，在开发库时，清理资源、关闭文件等操作都可以放在_exit_()方法中
因此，Python的with语句是提供一个有效的机制，让代码更简练，同时在异常产生时，处理工作更简单。
10、for、in
for循环可以遍历任何序列的项目，如一个列表或者一个字符串，例如：
str = "Hello World!" lis = [1, 2, 3, 4, 5] for s in str: print(s, end=',') for index in range(len(lis)): print(lis[index], end=',') else: print("已全部输出!")
H,e,l,l,o, ,W,o,r,l,d,!,1,2,3,4,5,已全部输出!
print中的end=','表示输出在一行上，且以'，'进行分割
第二个for循环是通过序列索引进行迭代，其中，len()和range()为内置函数，len()返回列表的长度，range()返回一个序列的数
第二个for循环后面加上else，表示执行完for循环后执行else中的语句
in除了用于for循环中，还可用于判断某一元素是否在序列中，例如：
print(1 in range(10))
True
11、while
while用于循环执行程序，即在某条件下，循环执行某段程序，当条件不满足时，退出循环，例如：
count = 0 while count < 5: print("count is:", count) count += 1
count is: 0
count is: 1
count is: 2
count is: 3
count is: 4
同样，while循环中也可以使用else语句，同for中的else
12、break、continue
break关键字用于退出整个循环，continue关键字用于退出本次循环，例如：
str = "hello" for x in str: if x == 'e': break print(x) print('---') for x in str: if x == 'l': continue print(x)
h --- h e o
13、assert
assert关键字，即断言，判断后面的condition真假，若condition为false，就会返回一个AssertionError出来，例如：
assert 1 == 1 assert 1 == 0
AssertionError
为assert断言语句添加异常参数，就是在断言表达式后添加字符串信息，用来解释断言并更好的知道是哪里出了问题，例如：
str = "hello" assert len(str) >= 6, '字符串长度小于6'
AssertionError: 字符串长度小于6
注意，断言语句与异常参数之间用','隔开
14、del
del关键字作用在变量上，而不是数据值上。由于Python都是引用，而Python有GC机制，所以，del所删除的是数据的引用，而不是数据值，例如：
a = 1 b = a c = a del a del b print("c:", c)
c: 1
15、import、from
import和from关键字都可用于导入某个模块，import可导入整个模块，而from可导入某个模块中的某个方法，例如：
import math print(math.pi)
3.141592653589793
from math import pi print(pi)
3.141592653589793
后续持续更新中...
16、global、nonlocal
首先，你要了解LEGB规则
在Python中，当引用一个变量的时候，对这个变量的搜索是按照局部作用域（Local）、闭包函数外中的函数中（Enclosing）、全局作用域（Global）、内建作用域（Built-in）的规则查找的，在局部找不到，便会去局部外的局部找，再找不到就会去全局找，再者去内建中找
例如：
x = int(1.5) # 内建作用域 y = 2 # 全局作用域 def outer(): a = 3 # 闭包函数外的函数中 def inner(): d = 4 # 局部作用域
然而，当在一个函数内部为一个变量赋值时，并不是按照上面所说的LEGB规则来首先找到变量，之后为该变量赋值。有这样一条规则：“当在函数中给一个变量名赋值时（而不是在一个表达式中对其进行引用），Python总是创建或改变本地作用域的变量名。除非它已经在那个函数中被声明为全局变量."
看如下例子：
x = 1 def outer(): x = 2 outer() print(x)
1上面的例子中，因为outer函数中没有变量x，因此Python会在outer函数的本地作用域创建一个变量x，也就是说此x并非x=1中的x，而print输出的是全局变量x
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了
修改全局变量，例如：
x = int(1.5) # 内建作用域 y = 2 # 全局作用域 def outer(): global x, y x = 3 y = 3 outer() print("x:", x) print("y:", y)
x: 3 y: 3
修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量则需要nonlocal关键字了，例如：
def outer(): a = 3 # 闭包函数外的函数中 def inner(): b = 4 # 局部作用域 nonlocal a a = 4 inner() return a print("a:", outer())
a: 4
17、is
在Python中，会用到两个对象的比较，可以用is，也可以用==，它们之间的区别是：
is 比较的是两个对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同
== 比较的是两个对象的内容是否相等，即内存地址可以不一样，内容一样就行了
例如：
a = 1 b = a # 通过引用赋值，赋值的都是引用 print("a id:", id(a), "\nb id:", id(b)) print("a is b:", a is b) print("a == b:", a == b) c = ["c","d"] d = c[:] # 通过切片赋值 print("c id:", id(c), "\nd id:", id(d)) print("c is d:", c is d) print("c == d:", c == d)
a id: 8791443841136 b id: 8791443841136 a is b: True a == b: True c id: 5923464 d id: 5923528 c is d: False c == d: True
注意：小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用，而其他整数对象用is比较时会出现相反的结果，而在P有charm或者保存为文件执行，结果仍然相同，这是因为解释器做了一部分优化，例如：
>>> a = 1 >>> b = 1 >>> a is b True >>> a = 257 >>> b = 257 >>> a is b False
以上试例为在cmd命令窗口中
注意：is运算符比==效率高，因为is不能被重载，不用进行特殊的函数调用，少了函数调用的开销而直接比较两个整数id，而a==b则是等同于a._eq_(b)
注意：在变量和None进行比较时，应该使用is
18、raise
当程序出现错误，Python会自动引发异常，也可以通过raise显示地引发异常
一旦执行了raise语句，raise后面的语句将不能执行，例如：
s = None if s is None: raise NameError print("is here?")
raise NameError
但是在try、except中仍可以捕获该异常，例如：
try: s = None if s is None: raise NameError except: print("空对象没有长度")
空对象没有长度
19、lambda
Python使用lambda来创建匿名函数
所谓匿名，意即不再使用def语句这样标准的形式定义一个函数，例如：
sum = lambda a, b: a + b print(type(sum)) print(sum(1, 2)) # 等同于 def sum(a, b): return a + b print(type(sum)) print(sum(1, 2))
<class 'function'> 3 <class 'function'> 3
20、yield
在Python中，使用了yield的函数被称为生成器
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作
在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值，并在下一次执行next()方法时从当前位置继续运行
以下实例使用yield实现斐波那契数列：
import sys def fibonacci(n): a, b, counter = 0, 1, 0 while True: if (counter > n): return yield a a, b = b, a + b counter += 1 f = fibonacci(10) while True: try: print(next(f), end=' ') except StopIteration: sys.exit()
0 1 1 2 3 5 8 13 21 34 55
如有疑问，可随时与楼主联系
期待您的指教！
扫一扫
4184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
