1. 布尔类

True 真

False 假

None 空

2. 逻辑类

and 与

or 或

not 非

3. 判断类

if 条件判断

elif 条件判断

else 条件判断

4. 循环类

for 迭代循环

while 判断循环

break 跳出整个循环

continue 跳出当前循环

5. 定义类

class 类与对象

def 自定义函数

lambda 匿名函数

global 声明全局变量

nonlocal 嵌套函数变量引用

return 返回函数结果

6. 模块类

import / from 导入模块

as 取别名

7. 判断类

in 判断对象是否属于另一个对象成员

is 判断对象内存地址是否一致

8. 异常类

try 捕获异常

assert 断言

raise 手动抛出错误

9. 其他类

async 异步执行

with 资源管理

yield 构造生成器函数

del 删除对象

pass 占位符

1. 布尔类

True 真

python中表示真，比如：

>>> print(2>1)
True

2肯定大于1，说明这句话是真的，用True表示

False 假

python中表示假，比如：

>>> print(2<1)
False

2小于1，说明这句话是假的，用False表示

None 空

None是python的特殊的常量，表示不确定或空缺的值，比如：

>>> def func(n=None):
        print(n)

>>> func()
None

表示不传入参数n默认为None，调用函数时未传参输出None（空缺的值）

此时我们传入一个参数

>>> def func(n=None):
        print(n)

>>> func(1)
1

调用函数不再是None，因为给了一个具体的值

2. 逻辑类

and 与

and是python中的逻辑运算，用于比较两个表达式（必须必须全部为真，则为真，否则假）

>>> print( 2>1 and 3>2 and 4>3 )
True

3个都为真，返回真

>>> print( 2<1 and 3>2 and 4>3 )
False

其中一个条件为假(2<1)，返回假

or 或

or是python中的逻辑运算，用于比较两个表达式（任意一个条件为真，则为真；全部为假，则为假）

>>> print( 2>1 or 3>2 or 4>3 )
True

3个都为真，返回真

>>> print( 2>1 or 3<2 or 4<3 )
True

存在一个条件为真，返回真

>>> print( 2<1 or 3<2 or 4<3 )
False

全部为假，返回假

not 非

not是python中的逻辑运算，用于取反一个表达式

>>> print( not True)
False
>>> print( not False)
True

True取反为False，False取反为True

>>> print(2>1)
True
>>> print(not 2>1)
False

2>1本身为真，但是取反后为假

3. 判断类

if 条件判断

if 是 Python 中的一个关键字，用于进行条件判断

>>> if (2>1):
>>>    print('判断为真，执行该代码')
判断为真，执行该代码

2>1 为真，执行缩进内代码

>>> if (2<1):
>>>    print('判断为真，执行该代码')

2<1 为假，所以该缩进内代码不执行

elif 条件判断

elif 是 Python 中的一个关键字，用于进行条件判断。语法如下：

#elif 的上层必须是 if
if [条件判断]:
    """if为真的代码块"""
elif [条件判断]:
    """elif为真的代码块"""

如果上层的 if 为真，那么执行上层，elif 不执行

>>> if True:
        print('执行if')
>>> elif True:
        print('执行elif')
执行if

如果上层的 if 为假，那么执行 elif

>>> if False:
        print('执行if')
>>> elif True:
        print('执行elif')
执行elif

如果有多层 elif，那么会逐层判断，仅执行最上方为真的代码

>>> if False:
        print('执行if')
>>> elif False:
        print('执行 elif 第1层')
>>> elif True:
        print('执行 elif 第2层')
>>> elif True:
        print('执行 elif 第3层')
>>> elif False:
        print('执行 elif 第4层')
执行 elif 第2层

else 条件判断

else 是 Python 中的一个关键字，if 和 elif 都为假才执行。语法如下：

if [条件判断]:
    """if为真的代码块"""
elif [条件判断]:
    """elif为真的代码块"""
else:
    """if 和 elif 都为假，执行代码块"""

if 为真，不会执行else

>>> if True:
        print('执行 if')
>>> else:
        print('执行 else')
执行 if

elif 为真，也不会执行else

>>> if False:
        print('执行 if')
>>> elif True:
        print('执行 elif')
>>> else:
        print('执行 else')
执行 elif

if 和 elif 都为假，才执行else

>>> if False:
        print('执行 if')
>>> elif False:
        print('执行 elif')
>>> else:
        print('执行 else')
执行 else

4. 循环类

for 迭代循环

for 在 python 用于迭代循环，语法如下：

for [变量] in [可迭代对象]:
    代码块

变量：自定义的变量名，将迭代对象循环的赋值给这个变量
可迭代对象：比如字符串、列表、元组、字典、集合，而数字是不可迭代的

>>> for i in 'abc':
        print(i)
a
b
c

详细使用方法请参考：Python循环遍历

while 判断循环

while 在 python 用于判断循环，语法如下：

while [条件判断]:
    代码块

条件判断：判断为真后循环执行

如果条件一直为真，那么会无限循环

>>> while True:
        print('无限循环代码块')
无限循环代码块
无限循环代码块
无限循环代码块
......

不想让 while 无限循环可以增加条件判断

>>> n = 0
>>> while n < 3:
        print(f'循环n：{n}')
        n += 1
循环n：0
循环n：1
循环n：2

详细用法可以参考：Python循环遍历

break 跳出整个循环

break 仅作用于循环（for、while），跳出整个循环

for循环示例

>>> for i in [1,2,3,4,5]:
        if i == 3:     #如果i=3，那么跳出整个循环
            break
        print(f'i的值为:{i}')
i的值为:1
i的值为:2

while 循环示例

>>> i = 1
>>> while True:
        if i == 3:    #如果i=3，那么跳出整个循环
            break
        print(f'i的值：{i}')
        i += 1
i的值：1
i的值：2

continue 跳出当前循环

continue 仅作用于循环（for、while），跳出当前循环

for循环示例

>>> for i in [1,2,3,4,5]:
        if i == 3:     #如果i=3，那么跳出当前循环
            continue
        print(f'i的值为:{i}')
i的值为:1
i的值为:2
i的值为:4
i的值为:5

while 循环示例

>>> i = 1
>>> while i<=5:
        if i == 3:    #如果i=3，那么跳出当前循环
            continue
        print(f'i的值：{i}')
        i += 1
i的值：1
i的值：2
i的值：4
i的值：5

5. 定义类

class 类与对象

class 是 Python 中的一个关键字，用于定义一个类。在面向对象编程中，类是一个关键的概念，用于封装数据和方法，以便更好地组织和管理代码。

语法

class [类名]([继承对象]):
    封装方法
        方法中的代码块

定义一个类

class MyClass(object):
    def func(self):
        print('这是一个类方法')

调用这个类

#方法1（直接调用）
>>> MyClass().func()
这是一个类方法

#方法2（实例化对象后调用）
>>> m = MyClass()
>>> m.func()
这是一个类方法

详细使用方法见：Python类与对象

def 自定义函数

在 Python 中，函数是用于封装和重用代码的基本单元，用于将一组相关的代码组织在一起，以便更好地管理和维护。

语法

def [函数名]:
    代码块

定义一个没有参数的函数

>>> def func1():
        print('这是一个没有参数的函数')
>>> func1()    #调用函数时，不需要传入参数
这是一个没有参数的函数

定义一个有参数的函数

>>> def func1(n):
        print(f'这是一个有参数的函数,参数为：{n}')
>>> func1(10)    #调用函数时需要传入一个参数
这是一个有参数的函数,参数为：10

lambda 匿名函数

lambda 用于创建一个没有名称的函数，这是一种比较简洁的方式，一般用于一些简单的函数功能

语法

#定义匿名函数
lambda [参数] : [表达式]
lambda [参数1],[参数2],[参数3] : [表达式]

#传参方式1
a = lambda [参数] : [表达式]
a([传参])

#传参方式2
(lambda [参数] : [表达式])  ([传参])

举例

定义一个函数
>>> def func(a, b):
        return a + b
>>> print(func(1,2))
3

用lambda写法，赋值给一个变量
>>> func = lambda a,b: a+b
>>> print(func(1,2))
3

也可以不用赋值，直接传参(将lambda语句括起来，再将参数括起来)
>>> (lambda a,b: a+b) (1,2)
3

结合判断语句

>>> func = lambda a,b: 'a大于b' if (a>b) else 'a小于b'
>>> print(func(1,2))
a小于b

结合map函数

#map函数的使用
>>> def func(n):
        return n*2
>>> result = map(func, range(1,4))
>>> print(list(result))
[2, 4, 6]

#map函数结合lambda
>>> result = map(lambda x: x*2, range(1,4))
>>> print(list(result))
[2, 4, 6]

global 声明全局变量

在局部变量中声明为全局变量

举个例子（未声明全局变量）

>>> a = 1   #定义一个全局变量
>>> def func():
        a = 2       #定义一个局部变量
        print(a)    #打印的也是局部变量

>>> func()      #调用函数，打印变量a
>>> print(a)    #直接打印变量a
2
1

函数 func 中定义了 a=2，func中打印a也是2，但是全局打印时仍然是1。使用 global 来看：

>>> a = 1   #定义一个全局变量
>>> def func():
        global a       #将a声明为全局变量变量
        a = 2
        print(a)

>>> func()      #调用函数，打印变量a
>>> print(a)    #直接打印变量a
2
2

此时在函数中将 a 声明为了一个全局变量，所以后面打印 a 的全局也就变成了 2

nonlocal 嵌套函数变量引用

nonlocal 用于在嵌套函数中引用外部函数作用域中的变量，不过可能会导致代码的可读性和可维护性降低，需要注意变量的命名和封装。

>>> def func1():
        a = 1    #定义函数中的变量a

        def func2():    #定义一个嵌套函数
            nonlocal a  #引用嵌套中的变量
            a = 2       #更改变量

        func2()         #调用嵌套函数
        print(a)        #打印这个变量

>>> func1()
2

return 返回函数结果

返回执行结果

#返回单个结果
>>> def func():
        return 1
>>> print(func())
1

#返回多个结果
>>> def func():
        return 1,2,3
>>> print(func())
(1, 2, 3)
>>> print(type(func()))
<class 'tuple'>

返回参数结果

>>> def func(n):
        return n
>>> print(func(10))
10

返回代码执行结果

>>> def func(n,m):
        return n * m
>>> print(func(2,3))
6

也可以返回列表、元组、字典、集合

>>> def func():
        return [1, 2, 3]
>>> print(func())
[1, 2, 3]

>>> def func():
        return (1, 2, 3)
>>> print(func())
(1, 2, 3)

>>> def func():
        return {'a':1, 'b':2}
>>> print(func())
{'a':1, 'b':2}

>>> def func():
        return {'a', 'b', 'c'}
>>> print(func())
{'a', 'b', 'c'}

6. 模块类

import / from 导入模块

导入整个模块

#导入单个模块
import os

#导入多个模块(逗号分割)
import os, time

#导入模块并重命名
import numpy as np    #将模块numpy重命名为np

导入某个小模块

#导入os模块中的一个小模块cpu_count
from os import cpu_count

#在使用的过程中就不需要再去调用大模块，例如：
print(cpu_count())

#如果没有导入子模块，需要调用就等通过主模块，例如：
print(os.cpu_count())

导入某个文件

#导入同级文件
import tmp1_file

#导入不同级文件
from Locust.Test import tmp2_file

#导入文件中某个类
from tmp2 import MyClass

#导入某个目录下全部文件，或者某个文件中全部
from Locust.Test import *

as 取别名

为导入的模块取别名

>>> import random as rd        #将random取一个简单的名字 rd
>>> print(rd.randint(1, 10))   #使用别名rd也可以使用random模块中的方法
9

为异常输出取别名

>>> try:
        print(abc)
>>> except Exception as result:
        print(f'抛出异常，详细原因：{result}')
抛出异常，详细原因：name 'abc' is not defined

7. 判断类

in 判断对象是否属于另一个对象成员

判断某个字符串是否属于另一个字符串的成员

>>> print('a' in 'abc')
True

判断列表、元组、字典、集合

>>> print('a' in ['a', 'b', 'c'])
True

>>> print('a' in ('a', 'b', 'c'))
True

>>> print('a' in {'a':1, 'b':2})
True

>>> print('a' in {'a', 'b', 'c'})
True

is 判断对象内存地址是否一致

判断字符串（字符一致，id一致）

>>> a = 'a'
>>> b = 'a'
>>> print(a is b)
True
>>> print('a的id：{}, b的id：{}'.format(id(a), id(b)))
a的id：2154799128816, b的id：2154799128816

判断列表（字符一致，id不一致）

>>> a = [1,2,3]
>>> b = [1,2,3]
>>> print(a is b)
False
>>> print('a的id：{}, b的id：{}'.format(id(a), id(b)))
a的id：2167719852032, b的id：2167719818624

判断元组（字符一致，id一致）

>>> a = (1,2,3)
>>> b = (1,2,3)
>>> print(a is b)
True
>>> print('a的id：{}, b的id：{}'.format(id(a), id(b)))
a的id：2089505034304, b的id：2089505034304

判断字典（字符一致，id不一致）

>>> a = {'a':1,'b':2}
>>> b = {'a':1,'b':2}
>>> print(a is b)
False
>>> print('a的id：{}, b的id：{}'.format(id(a), id(b)))
a的id：2790215892032, b的id：2790215892288

判断集合（字符一致，id不一致）

>>> a = {1,2,3}
>>> b = {1,2,3}
>>> print(a is b)
False
>>> print('a的id：{}, b的id：{}'.format(id(a), id(b)))
a的id：1299165422400, b的id：1299168349760

8. 异常类

try 捕获异常

try 可以帮助我们保护程序执行，捕捉异常，并提供异常处理和恢复机制。

成功捕获到异常类型后，不会终止程序。
未成功捕获到异常类型时，会自动终止程序。

语法

try:
    [可能有异常的代码]
except [异常类型]:
    [捕获到异常类型后，执行此段代码]
else:
    [try代码没有异常时，执行此段代码]

基础写法(捕获到异常后，不会终止程序)

>>> try:
        print(a)    #这段代码可能有异常(没有定义变量a)
>>> except NameError as err:    #捕获的类型是NameError，并将异常信息赋值给err变量
        print('try 代码有异常')
        print(f'try 代码有异常，输出官方异常：{err}')

>>> print('其他程序继续执行')
try 代码有异常
try 代码有异常，输出官方异常：name 'a' is not defined
其他程序继续执行

基础写法(未捕获到异常类型，终止程序)

>>> try:
        print(a)    #这段代码可能有异常(没有定义变量a)
>>> except ZeroDivisionError as err:    #捕获的类型是NameError，并将异常信息赋值给err变量
        print('try 代码有异常')
        print(f'try 代码有异常，输出官方异常：{err}')

>>> print('其他程序继续执行')
NameError: name 'a' is not defined

同时捕获多个异常 except (类型1，类型2，类型3......)

>>> try:
        print(a)    #这段代码可能有异常(没有定义变量a)
>>> except (NameError, ZeroDivisionError) as err:
        print('try 代码有异常')
        print(f'try 代码有异常，输出官方异常：{err}')

>>> print('其他程序继续执行')
try 代码有异常
try 代码有异常，输出官方异常：name 'a' is not defined
其他程序继续执行

捕获全部异常 Exception

>>> try:
        print(a)
>>> except Exception as err:
        print(f'try 代码有异常：{err}')
try 代码有异常：name 'a' is not defined

输出代码无异常 else

>>> a = 1
>>> try:
        print(a)
>>> except NameError:
        print('try 代码有异常')
>>> else:
        print('try 代码无异常')
try 代码无异常

无论代码是否异常，都执行某段代码

>>> try:
        print(a)
>>> except (NameError, ZeroDivisionError) as err:
        print(f'try 代码有异常：{err}')
>>> finally:
        print('无论代码是否异常，都执行此项')
try 代码有异常：name 'a' is not defined
无论代码是否异常，都执行此项

assert 断言

assert 一般用于调试程序，并不适用于让程序真正的依赖它。程序实际运行使用 try 会更好

语法

assert [条件判断] [提示信息]

断言为False，那么就会根据自定义的"提示信息"抛出错误，并终止程序

>>> assert False, "断言异常，抛出此错误"    #False表示异常，抛出信息，终止程序
>>> print('abc')        #程序已经被终止，无法执行
AssertionError: 断言异常，抛出此错误

断言为True，那么跳过此项，继续执行下一行代码

>>> assert True, "断言异常，抛出此错误"    #True表示正常，通过此项
>>> print('abc')
abc

举个例子，判断一个变量

#判断为True
>>> a = 10
>>> assert isinstance(a, int), "参数a必须是整型"
>>> print(a)
10

#判断为False
>>> a = 10.1
>>> assert isinstance(a, int), "参数a必须是整型"
>>> print(a)    #已经被终止，无法执行
AssertionError: 参数a必须是整型

raise 手动抛出错误

>>> raise ZeroDivisionError('手动抛出xxx错误')
ZeroDivisionError: 手动抛出xxx错误

>>> a = 0
>>> if a == 0:
        raise ZeroDivisionError('变量a不能为0')
ZeroDivisionError: 变量a不能为0

9. 其他类

async 异步执行

定义一个异步函数

async def func():
    pass

基本使用方法

import asyncio

async def func():
    print('开始异步执行程序...')
    await asyncio.sleep(1)    #设置休眠时长
    print('异步执行结束！')

asyncio.run(func())    #调用异步函数

简单示例

import asyncio

async def func1():
    '''模拟协程1'''
    await asyncio.sleep(2)          #每2s开始干活
    print('开始执行func1...')

async def func2():
    '''模拟协程2'''
    global global_control          #声明变量 global_control 为全局变量
    while global_control:          #通过 global_control 来判断是否终止
        print('开始执行func2...')   #开始干自己的活
        asyncio.create_task(func1())    #创建协程1，让它也干活
        await asyncio.sleep(3)     #每3s执行一次

async def control_func():
    '''控制异步时长'''
    global global_control          #声明变量 global_control 为全局变量
    await asyncio.sleep(10)        #控制异步的时长
    global_control = False         #到达指定时长后将全局变量设置为 False，func2中while循环终止

async def call_func():
    '''总调用函数'''
    await asyncio.wait([
        asyncio.create_task(control_func()),    #先创建控制时长的协程
        asyncio.create_task(func2())            #再创建真正干活的协程
    ])

global_control = True      #这个变量用于控制全局(func2中的while循环)
asyncio.run(call_func())   #运行

输出结果

开始执行func2...
开始执行func1...
开始执行func2...
开始执行func1...
开始执行func2...
开始执行func1...
开始执行func2...
开始执行func1...

with 资源管理

使用 with 关键字会自动关闭管理的资源，避免资源泄漏和其他不安全的问题，提高程序的健壮性和可靠性。

使用 with 读取文件，不必手动的去关闭文件（自动关闭）

>>> with open('./tmp_file.txt', 'r', encoding='utf-8') as file:
        print(file.read())
临时文件,临时内容

使用 with 连接 socket，不必手动关闭套接字

import socket

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect(('www.baidu.com', 80))
    s.sendall(b'GET / HTTP/1.1\r\nHost: www.baidu.com\r\nConnection: close\r\n\r\n')
    data = s.recv(1024)
    print(data.decode())

使用 with 避免锁竞争

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:
        for i in range(1000000):
            counter += 1

threads = [threading.Thread(target=increment) for i in range(4)]
for t in threads:
    t.start()

for t in threads:
    t.join()

print(counter)

yield 构造生成器函数

yield 将函数构造成一个生成器，实现迭代器协议。在需要的时候生成一个值，并暂停函数执行，等待下一次调用或迭代。

>>> def func(num):        #定义一个函数
        while num < 5:
            yield num     #如果参数小于5，则将函数转换为生成器，并返回参数值
            num += 1

>>> for i in func(2):     #传入一个小于5的参数，将生成器结果遍历
        print(i)
2
3
4

del 删除对象

一般 del 关键字用于删除一个对象，将相关的对象进行销毁，并释放资源，可以帮助我们更好的管理内存。

删除变量

a = 1
del a

删除列表、元组、字典、集合

a = [1,2,3]
del a

a = (1,2,3)
del a

a = {'小明':18, '小李':20}
del a

a = {1, 2, 3}
del a

删除函数

def func():
    print('这是一个函数')

del func

删除类

class MyClass(object):
    print('这是一个类')

del MyClass

pass 占位符

pass表示什么也不干，为待写代码块占一个位置，以免报错。一般用于写框架时占用

def func():
    '''用来xxx的程序，暂时搁置'''
    pass

Python3内置关键字大全

1. 布尔类

True 真

False 假

None 空

2. 逻辑类

and 与

or 或

not 非

3. 判断类

if 条件判断

elif 条件判断

else 条件判断

4. 循环类

for 迭代循环

while 判断循环

break 跳出整个循环

continue 跳出当前循环

5. 定义类

class 类与对象

def 自定义函数

lambda 匿名函数

global 声明全局变量

nonlocal 嵌套函数变量引用

return 返回函数结果

6. 模块类

import / from 导入模块

as 取别名

7. 判断类

in 判断对象是否属于另一个对象成员

is 判断对象内存地址是否一致

8. 异常类

try 捕获异常

assert 断言

raise 手动抛出错误

9. 其他类

async 异步执行

with 资源管理

yield 构造生成器函数

del 删除对象

pass 占位符

相关文章