Python关键字

我们在写代码时，所有应用到的关键字如下

import keyword
keyword.kwlist

目录

1  False与True

2  None

3  and,not,or 

3.1  与运算

3.2  非运算

3.3  或运算

4  面向对象 class，def与return yield

4.1  def,return,yield

4.1.1  def

4.1.2  return

4.1.3  yield

4.2  class

4.2.1  属性

4.2.2  方法

5  from与import

5.1  导入库

5.2  导入py文件

5.3  导入库中的某一类或方法

5.4  导入py文件的类

6  try,except,finally

7  with与as

7.1  with...as...

7.2  import...as...

7.3  Exception...as...

8  if elif else

9  break,continue,for,while

9.1  for break

9.2  for continue

9.3  while break

9.4  while continue

10  pass

11  lambda

12  global 与 nonlocal

12.1  global

12.2  nonlocal

13  in

14  is

15  assert

16  del

17  raise

---

1  False与True

False与True应用于判断，当我们进行判断时只会出现这两个结果

下面我们举个例子

1 == 2

2 == 2

2  None

 None表示空值，但空值不代表为空对象

None == []

在我们使用执行类函数时，我们的返回值就是None 

None == print(1)

如果在函数的结尾没加入return，则默认返回值为None

def func():
    print(1)
    return 0
a = func()

print(a)

3  and,not,or 

逻辑运算

• and 与运算
• not 非运算
• or 或运算

我们一般用逻辑运算计算True和False

3.1  与运算

如果所有参与 与运算 的值都为True则为True,否则为False

3.2  非运算

取反

3.3  或运算

如果所有参与 或运算 的值有一个为True则为True,否则为False

4  面向对象 class，def与return yield

这三个关键字涉及到python面向对象的思想

我们之前的编程方式为面向过程

比如说

上面的cell就是面向过程

我们接下来看面向对象

4.1  def,return,yield

我们先用def创建一个函数

4.1.1  def

def test_func(a):
    if a == 1 :
        print('a的值为1')
    else:
        print('a的值不是1')

在这个函数中，a作为我们的传入值，即使我们没有定义a的值，我们依然可以没有报错运行

我们现在就调用一下这个方法

发现可以成功调用，并且在执行代码中简洁了许多

这个就是我们面向对象的特点之一：封装

我们在这里也说一下return，每一个函数都有其对应的返回值，如果没有设置返回值，返回值自动为None

我们设置b为刚刚定义函数的返回值

发现函数的返回值是None

我们现在更改一下我们定义的函数

4.1.2  return

def test_func(a):
    if a == 1 :
        print('a的值为1')
    else:
        print('a的值不是1')
    return '函数执行完毕'

 发现返回值已被定义，我们的返回值根据不同函数的要求设置任意类型的变量

4.1.3  yield

yield同样是函数的返回值

如果我们使用yield进行返回，那么这个函数就变成了一个可迭代的函数，我们下面使用yield与return对比一下

• yield

def func_4(value):
    b = 0
    c = 0
    while b < value:
        b = b + 1
        print(b)
    yield c

• return 

def func_4(value):
    b = 0
    c = 0
    while b < value:
        b = b + 1
        print(b)
    return c

前面的1-5是print(b)的执行结果，最后的0是返回c的结果

4.2  class

class为创建类的关键字，一个类中会有若干的方法也会有若干个属性

4.2.1  属性

我们先说属性，再说方法

属性分两种，类属性和实例属性，这两种属性中又包括公有属性和私有属性

我们在学习之前先看一个图，不要搞乱了

4.2.1.1  类属性

类属性又分为两种，公有类属性和私有类属性

我们先看公有类属性

4.2.1.1.1 公有类属性

class test_class():
    a = 1

 上面这个例子中a就是test_class()的类属性，我们可以理解为类中的变量就叫类属性

类属性是不用实例化就可以获取的属性

• 实例化：将一个类赋值给一个变量

当然我们也可以实例化获取公有类属性

我们先将类实例化

b = test_class()

这样也可以调用类的属性

4.2.1.1.2 私有类属性

私有类属性会在前面加两个__

class test_class():
    a = 1
    __b = 2

 私有类属性是这样调用的

4.2.1.2  实例属性

实例属性是放在def中的属性

class test_class2():
    a = 1
    def __init__(self):
        self.b = 2

 上面的self.b就为实例属性，下面是调用方法

我们也可以不把实例属性放在__init__()中 

class test_class2():
    a = 1
    def __init__(self):
        self.test_func1()
    def test_func1(self):
        self.b = 2

实例属性主要用与方法之间的属性传递，比如

class test_class2():
    a = 1
    def __init__(self):
        self.test_func1()
    def test_func1(self):
        self.b = 2
    def test_func2(self):
        b = self.b
        print(b)

 我们上面说的是实例属性的公有属性，我们的实例属性也是有私有属性的

class test_class2():
    a = 1
    def __init__(self):
        self.test_func1()
    def test_func1(self):
        self.__b = 2

调用方式和上面的类属性是一样的

class test_class2():
    a = 1
    def __init__(self):
        self.test_func1()
    def test_func1(self):
        self.__b = 2
    def test_func2(self):
        b = self.__b
        print(b)

也可以用于属性的传递

我们现在再看一下这个图，应该会有不同的理解

之后我们再说方法

4.2.2  方法

方法一共有三种，分别为实例方法，静态方法与类方法

4.2.2.1  实例方法

我们现在先把刚刚的方法放到类中

class test_class():
    def test_func(self,a):
        if a == 1 :
            print('a的值为1')
        else:
            print('a的值不是1')
        return '函数执行完毕'

 我们发现方法后面的参数多了一个self,这是因为我们调用方法就要实例化该类，实例化调用后，我们会把实例化的变量自动传入self中

4.2.2.2  静态方法

那我们现在觉得每个方法还都要加入self太麻烦，我们这个时候需要用到@staticmethod来标定静态方法

class test_class():
    def test_func(self,a):
        if a == 1 :
            print('a的值为1')
        else:
            print('a的值不是1')
        return '函数执行完毕'
    @staticmethod
    def test_func2(a):
        if a == 2 :
            print('a的值为2')
        else:
            print('a的值不是2')
        return '函数执行完毕'

静态方法的好处是我们不用实例化即可调用方法

4.2.2.3  类方法

在方法前加入@classmethod

class test_class():
    b = 3
    def test_func(self,a):
        if a == 1 :
            print('a的值为1')
        else:
            print('a的值不是1')
        return '函数执行完毕'
    @staticmethod
    def test_func2(a):
        if a == 2 :
            print('a的值为2')
        else:
            print('a的值不是2')
        return '函数执行完毕'
    @classmethod
    def test_func3(b):
        if b == 3 :
            print('b的值为3')
        else:
            print('b的值不是3')
        return '函数执行完毕'

发现有属性，不用传参

我们刚刚说了面向对象有封装的特点，这里我们将其余的两个特点也展示出来：

• 封装
• 继承
• 多态

下面我们先看继承,我们搞两个类，一个类的名字叫father,我们把它作为父类(被继承类）。

另一个类我们把它叫做son,我们把它作为子类(继承类）

class father():
    def func(self):
        print(1)
        
class son(father):
    age = 10

现在我们可以看到son是没有func这个函数的

但是我们依然可以给它调用出来，原因是子类会继承父类的所有属性与方法

现在我们再来看多态

多态的体现为重新定义父类的方法与属性

class father():
    age = 40
    def func(self):
        print(1)
        
class son(father):
    age = 10
    def func(self):
        print(2)
        print(self.age)

我们可以发现子类覆盖了父类的属性与方法

5  from与import

5.1  导入库

import random

5.2  导入py文件

我们在同级目录中有一个test.py，内容如下

 导入文件

import test

实例化

a = test.test_class()

调用方法 

a.test_func()

5.3  导入库中的某一类或方法

from random import randint

我们如果不导入指定方法是这样用的

 我们导入之后就可以这样用

5.4  导入py文件的类

其实库就是其他人写好的文件，区别为他们将库封装好，以便我们直接import

我们还是用上面的test文件

我们在同级目录中有一个test.py，内容如下

导入文件中的一个方法

from test import test_class

实例化

 如果想使用函数不能直接导入函数，只能从类中的函数调用

6  try,except,finally

关键字try和except是成对使用的，如果语句在try中不会报错就不会走到except中，如果会报错则运行完不会报错的语句后会走到except中

我们先看一下try可以走通的情况

try:
    print(1)
except:
    print(2)

他只执行了try而没有执行except

我们再看一下走不通的情况

我在当前目录下没有abc.py这个文件,我导入它自然会报错

try:
    print(1)
    import abc.py
except:
    print(2)

 他执行了try没有错误的语句后，又执行了except语句

我们也可以在try,except的配合中最后加入finally

finally的意思是无论尝试结果如何，都会走最后finally的路

没出现问题时：

try:
    print(1)
except:
    print(2)
finally:
    print(3)

出现了问题时 

try:
    print(1)
    import abc.py
except:
    print(2)
finally:
    print(3)

try也可以配合else，当可以try通时，不会执行except而是会执行else

try:
    print(1)
except:
    print(2)
else:
    print(3)

 

7  with与as

with的用法为配合as使用

as一般有三种用法

• with...as... 打开文件
• import...as...导入库
• except...as...捕获异常对象

7.1  with...as...

我们首先在notebook的同级目录下搞一个名为python关键字的文本文档，在其中输入python

 我们发现他把open的对象赋值给了f,当然我们也可以使用别的变量

 效果是一样的

上面是在txt中读取一些内容，我们写入内容在python内建方法_potato123232的博客-CSDN博客中的print部分有介绍

7.2  import...as...

我们一般导入库是这样的

import requests

然后我们只能这样用库中的某一个方法 

如果每次调用的库内方法的话输入这么多的字符是很麻烦的，我们现在使用import...as...

import requests as re

 我们这个时候就可以这样用了

7.3  Exception...as...

我们使用刚刚request中的get方法，get需要一个参数，现在我不给它参数，他就会报错，走到except的分支

except后面可以跟一个参数Exception

这个类是报错的类，我们想要看其内容需要加上as

 我们可以看到错误信息，少了一个参数url

8  if elif else

9  break,continue,for,while

这四个关键字都是循环中用的

我把这四种配合都列出来

9.1  for break

到2的时候中断循环

9.2  for continue

到2的时候中断此轮循环

9.3  while break

9.4  while continue

当a=2时，跳过了那一次的循环

10  pass

当我们遇到一个地方需要写语句，但现在还不想写时，用pass占位，这样程序不会报错

11  lambda

这个关键字的名字为匿名函数

我们每次用def定义函数的时候都需要给一个名字,比如

我们可以这样替代

 如果不以返回值为目的时，我们需要给lambda赋值进行调用

上面这个是无参数的，下面我们来搞一个有参数的

以上都是无返回值的，下面我们来搞有返回值的

ambda诞生的目的是让代码看起来更加简洁，因此lambda只能传入1条语句

如果我们想使用lambda搞这样的def是搞不了的

def func(x):
    print(x)
    print(x)
    return 'hello'

 lambda的执行语句只能有一条，但是在冒号前可以加入无限赋值语句定义参数,但是不能同一变量重复定义两次

12  global 与 nonlocal

12.1  global

global会使变量变为全局变量

• 全局变量：能在代码所有位置被调用
• 局部变量：只能在代码部分位置被调用

 此时我们使用global,我们将语句置于定义变量之前

12.2  nonlocal

nonlocal只用于嵌套函数,声明在外函数func_1()与内函数func_2()内有效

语句置于定义变量之后

如果在其他位置调用则无效

13  in

如果我们in的判断对象是字典的话，它的意思为指定的键有没有在字典中

而不是值

14  is

is 与 == 的区别是

当值相等时 == 返回值就为True,地址无所谓

当值与地址都相同时，is的返回值才为True

15  assert

用于判断一个表达式，在表达式条件为 false 的时候触发异常。

我们可以使用这个方法即使中断程序，避免运行中出现意外造成的损失

16  del

删除变量

17  raise

raise可以使我们自己定义异常的信息，以便隔一段时间后再运行代码出错时可以获取自己当时写的提示信息