保留字¶
None¶
表示空 ，函数么有return的时候返回结果为None，判断是否为none需要用is，例如:
def no_return(): """ 这个函数没有使用return语句返回值 :return: """ print(1 + 1) a = no_return() print(a) print(a == a)运行结果:
2 None True True
True/False¶
布尔值只有两个值：True,False或者1，0表示真或假,在Python中可以直接用True,False来表示布尔值，也可以通过计算得到；
>>> True True >>> False False >>> 3 > 2 True >>> 3 > 5 False
and/or/not¶
and 和 or 是Python中的两个逻辑运算符，可以进行多个条件的判断
and 表示所有条件为真时，该条件才为真：
>>> True and True True >>> True and False False >>> False and False False >>> 5 > 3 and 3 > 1 True注解
当and前面一个表达式为False的时候，and后面表达式不会执行
or表示只有一个条件为真，该条件就为真：
>>> True or True True >>> True or False True >>> False or False False >>> 5 > 3 or 1 > 3 True注解
当or前面一个表达为True的时候，or后面表达式不会执行
not是非运算，把True变成False，或把False变成Ture:
>>> not True False >>> not False True >>> not 1 > 2 True
in/not in¶
in用来判断值是存在列表当中，not in与in相反，用来判断值不存在列表当中：
>>> name=['bob','lancy','mark','jony'] >>> if 'bob' in name: ... print('bob' 'is exists') ... else: ... print('bob' 'is not exists')输出
bob is exists
is¶
is是Python中的同一运算符，用来比较对象间的身份标识(id)是否相同：
>>> A=B=(1,2,3,4) >>> C=(1,2,3,4) >>> A is B True >>> A is C False >>> id(A) 2597831708328 >>> id(B) 2597831708328 >>> id(C) 2597831708248==也是起对对象进行比较判断的作用，但是==与is本质的区别是：==是用来比较值（value）是否相等：
>>> A=B=(1,2,3,4) >>> C=(1,2,3,4) >>> A is B True >>> A is C False >>> id(A) 2597831708328 >>> id(B) 2597831708328 >>> id(C) 2597831708248 >>> A==B True >>> A==C True
del¶
del,remove,pop都是Python中的删除方法。但是他们三者的用法又有不同。
del是对列表的下标进行检索删除，不返回删除值：
>>> L=[7,8,9,10] >>> del L[2] >>> L [7, 8, 10]
if/elif/else¶
if是Python中的条件判断，判断条件是否为true，为true执行命令行，为false不执行命令行。也可以在if后面添加一个else语句，当 条件判断是false的时候，执行else后面的语句：
>>> n=range(100) >>> m=110 >>> if m in n: ... print('m属于n') ... else: ... print('m不属于n')
- 输出
m不属于n
当然上面的判断很粗略，可以用elif来做更加精细的判断：
>>> score=76 >>> if score<60: ... print('不及格') ... elif score<=80: ... print('合格') ... else: ... print('优秀')输出
合格
for...in/else¶
for...in是循环语句，依次把list的元素迭代出来进行重复计算：
例如要计算1-100的和：
>>> n=range(101) >>> b=0 >>> for x in n: ... b=b+x >>> print(b)输出
5050
for...in语句也可以同else子句同时使用，在for循环正常执行后，else子句里面的内容也会正常执行：
>>> for x in range(10): ... print(x) ... else: ... print('再见 ')输出
0 1 2 3 4 5 6 7 8 9 再见
但是当for循环被break中断后，else语句不执行：
>>> for x in range(10): ... print(x) ... break ... else: ... print('再见')输出
0
可以看出break后面的else语句没有执行
while/else¶
while也是一种循环语句，只要条件满足就不断进行循环，不满足就退出循环：
- 例如要计算1-100中的奇数的和：
输出
2500
while循环后面加else语句和for循环加else语句用法一样：在while循环正常执行后，else子句里面的内容也会正常执行 当while循环被break中断后，else语句不执行
break/continue¶
break使用在循环语句中可以提前退出循环：
>>> n=1 >>> while n<=100: ... if n>10: ... break(当n大于10的时候退出循环） ... print(n) ... n=n+1依次输出
1 2 3 4 5 6 7 8 9 10
continue使用在循环语句中，起到跳过当前循环的作用：
>>> n=0 >>> while n<10: ... n=n+1 ... if n%2==0: ... continue(当n是偶数的时候结束当前循环，后面的print不执行) ... print(n)
- 输出
1 3 5 7 9
pass¶
pass是空语句，不做任何事情，常用作占位语句，是为了保持程序结构的完整性。当要定义一个函数，但是暂时不知道怎么写，可以 pass来占位使程序可以不报错，可以正常运行:
>>> def n(): ... pass
def/return¶
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:然后，在缩进块中编写函数体，函数 的返回值用return语句返回：
>>> nums=range(10) >>> def sum(n): ... sum=0 ... for x in n: ... sum=sum+x*x ... return sum >>> sum(nums)
- 输出
285
lambda¶
lambda表达式通常是用来命名匿名函数。当函数很简单，重新定义一个函数很繁琐的时候可以使用lambda来定义，比如： 求x的平方，用lambda可以表达为：
>>> n=lambda x:x*x >>> n(10) 100用def函数来表达为：
>>> def n(x): ... return x*x ... >>> n(10) 100在这里lambda简化了函数定义的书写形式，两者都可以用来定义函数，但是def更加正式，函数必须要有一个名字
class¶
class是Python中定义类的关键字，类是抽象的模板，实例是根据类创建的具体的对象，每个对象拥有相同的方法，但是数据可能不同 让我们先来定义一个类：
>>> class Classmates(): ... pass再来创建一个实例，实例是通过 类名+（）实现的：
>>> part=Classmates() >>> part <__main__.Classmates object at 0x0000018433CEDB38>可以看出实例BOB创建成功，内存地址是0x0000018433CEDB38
给实例变量绑定属性，例如给part绑定一个name属性：
>>> part.name='Bob' >>> part.name 'Bob'但是当实例变量有很多属性时，可以同时绑定多个属性：
>>> class Classmates(): ... def __init__(self,name,age,score): ... self.name=name ... self.age=age ... self.score=score>>> part=Classmates('Bob',24,85) >>> part.name 'Bob' >>> part.age 24 >>> part.score 85和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。 除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数
from/import/as¶
form import和import都是数据导入的方法，但是他们的使用方法和作用都有所差别：
form import用来导入模块中指定的模块属性，语法是:
form module import name1[name2[,......nameN]]而import是用来导入整个模块，语法为:
import module1[module2[,.....moduleN]]form import 和import 都可以加as,有时候你导入的模块或是模块属性名称已经在你的程序中使用了, 或者你不想使用导入的名字。 可能是它太长不便输入什么的, 总之你不喜欢它。使用自己想要的名字替换模块的原始名称。一个普遍的解决方案是把模块赋值给 一个变量:
try/except/else/finally/raise¶
在代码运行中经常会有错误提示，在运行代码之前不知道代码是否会出错，一旦出错一级一级找错误也很麻烦，这样就可以在语句中 嵌入一个try语句
try必须和except同时使用：
>>> try: ... x=9/0 ... print(x) ... except ZeroDivisionError as e: ... print('false') ... else: ... print('correct') ... finally: ... print('end')执行结果 ：
false end
当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理 代码，即except语句块，可以在except语句块后面加一个else，当没有错误发生时，会自动执行else语句，最后执行finally语句，不管 代码是否有误，finally都会被执行。
可以用raise手工出发一个异常，这样做程序不会因为异常终止，而是运行报错：
>>> def num(x,y): ... if y==0: ... raise ZeroDivisionError('除数为零') ... else: ... return x/y ... >>> num(6,0)
- 执行结果：
- Traceback (most recent call last):
File "<stdin>", line 1, in <module> File "<stdin>", line 3, in num
ZeroDivisionError: 除数为零
assert¶
assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达示为假，用来测试表达式，其返回值为假，就会触发异常。
>>> assert 4==4(布尔值为ture) >>> assert 4==5(布尔值为false，触发异常反应) Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError可以在assert后面添加异常参数，就是在断言表达式后添加字符串信息，用来解释断言并更好的知道是哪里出了问题，格式为：
assert 表达式 [, 参数]，例如：
>>> assert 4==5,'4不等于5' Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError: 4不等于5
yield/yield from¶
带有yield的语句是一个生成器：
>>> def h(): ... yield'hello' ... yield'python' ... >>> h() <generator object h at 0x000002BA64D3C570> >>> b=h() >>> next(b) 'hello' >>> next(b) 'python'为了让生成器（带yield函数），能简易的在其他函数中直接调用，就产生了yield from：
>>> def h2(): ... yield from h() ... >>> h2() <generator object h2 at 0x000002BA64D3C570> >>> c=h2() >>> next(c) 'hello' >>> next(c) 'python'yield from也可以这样用：
>>> def h3(): ... yield from 'hello' ... yield from 'python' ... >>> d=h3() >>> next(d) 'h' >>> next(d) 'e'