超详细的 Python 基础语句总结(多实例视频讲解持续更新)

Posted 2021-05-20 Amo Xiang

目录

• 一、运算符
• • 1.1 + ——两个对象相加
  • 1.2 - ——得到负数或是一个数减去另一个数
  • 1.3 * ——两个数相乘或是返回一个被重复若干次的字符串、列表、元组
  • 1.4 / ——两个数相除
  • 1.5 // ——返回商的整数部分（向下取整）
  • 1.6 % ——返回除法的余数
  • 1.7 ** ——返回一个数的幂
  • 1.8 = —— 简单的赋值
  • 1.9 += —— 加法赋值
  • 1.10 -= —— 减法赋值
  • 1.11 *= —— 乘法赋值
  • 1.12 /= —— 除法赋值运算符
  • 1.13 %= —— 取模赋值运算符
  • 1.14 **= —— 幂赋值运算符
  • 1.15 //= —— 取整除赋值运算符
  • 1.16 == —— 等于运算符
  • 1.17 != —— 不等于运算符
  • 1.18 > —— 大于运算符
  • 1.19 < —— 小于运算符
  • 1.20 >= —— 大于等于运算符
  • 1.21 <= —— 小于等于运算符
  • 1.22 and —— 与运算符
  • 1.23 or—— 或运算符
  • 1.24 not—— 非运算符
  • 1.25 & —— 按位与运算符
  • 1.26 | —— 按位或运算符
  • 1.27 ^ —— 按位异或运算符
  • 1.28 ~ —— 按位取反运算符
  • 1.29 << —— 左移动运算符
  • 1.30 >> —— 右移动运算符
  • 1.31 in —— 在指定的序列中查找
  • 1.32 not in —— 在指定的序列中查找
  • 1.33 is —— 判断两个标识是否引自同一个对象
  • 1.34 is not —— 判断两个标识是否引自同一个对象
• 二、流程控制
• • 2.1 if 语句--简单的条件判断
  • 2.2 if…else 语句 --二分支条件判断
  • 2.3 if…elif…else 语句--多分支条件判断
  • 2.4 for 语句--循环
  • 2.5 for…else 语句--循环
  • 2.6 while 语句--循环
  • 2.7 while…else 语句--循环
  • 2.8 break 语句--终止当前循环
  • 2.9 continue 语句--终止本次循环进入下一次循环
  • 2.10 条件表达式(三目运算符、三元表达式)
• 三、函数
• • 3.1 def 语句--自定义函数
  • 3.2 lambda 表达式--匿名函数
  • 3.3 pass 语句--空语句
  • 3.4 yield 语句--生成器
• 四、程序调试与异常处理
• • 4.1 assert 语句--应用断言调试程序
  • 4.2 raise 语句--抛出异常
  • 4.3 try…except 语句--捕获异常
  • 4.4 try…except…else 语句--捕获异常
  • 4.5 try…except…finally 语句--捕获异常

一、运算符

1.1 + ——两个对象相加

+ 运算符用于实现 2 个对象的相加。视频讲解链接如下：

https://www.bilibili.com/video/BV1Ao4y1m7nh

【示例1】数字相加。在 Python 中，经常会遇到使用 + 进行数值相加的情况，常用应用如下：

a = 13
b = 2
c = 4.0
d = 5.0
print(a + b)  # 整数相加 15
print(c + d)  # 浮点数相加 9.0
print(a + c)  # 整数和浮点数相加 17.0
print(a + .5)  # 整数和省略零的浮点数相加 13.5

【示例2】字符串相加。在 Python 中，如果 + 号的两侧是字符串类型数据，则表示将 2 个字符串进行拼接。常用应用如下：

s1 = 'Amo'
s2 = 'Xiang'
print(s1 + s2)  # 字符串拼接
print(s1 + ' ' + s2)  # 2个字符串间添加空格
print(s1 + '\\n' + s2)  # 2个字符串间添加换行符

程序执行结果如下图所示：

【示例3】元组、列表相加。当元组、列表使用 + 相加时，返回合并后的元组、列表。常用应用如下：

t1 = (1, 2, 3)
t2 = (4, 5, 6)
t3 = ('a', 'b', 'c')
t4 = ('d', 'e', 'f')
t5 = (('o', 'p', 'q'), ('x', 'y', 'z'))
print(t1 + t2)  # (1, 2, 3, 4, 5, 6)
# (1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e', 'f')
print(t1 + t2 + t3 + t4)
# (1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e', 'f', ('o', 'p', 'q'), ('x', 'y', 'z'))
print(t1 + t2 + t3 + t4 + t5)

print("*" * 90)
l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = [['a', 'b', 'c']]
l4 = [['d', 'e', 'f']]
l5 = [['o', 'p', 'q'], ('x', 'y', 'z')]
print(l1 + l2)  # [1, 2, 3, 4, 5, 6]
# [['a', 'b', 'c'], ['d', 'e', 'f']]
print(l3 + l4)
# [1, 2, 3, 4, 5, 6, ['a', 'b', 'c'], ['d', 'e', 'f'], ['o', 'p', 'q'], ('x', 'y', 'z')]
print(l1 + l2 + l3 + l4 + l5)

说明：字典和集合不能使用“+”进行操作。

说明：不同数据类型，不能直接进行 + 运算。如下：

1.2 - ——得到负数或是一个数减去另一个数

- 运算符在 Python 中有两个作用，一个是作为负号使用，在数字前表示负数；另一个是作为减号，表示前一个数字减去后一个数字。

【示例1】作为负号使用。作为负号使用时，注意负负为正。常用应用如下：

num1 = 4
num2 = -5
num3 = -6.0
print(-num1)  # -4
print(num2)  # -5
print(-num3)  # 6.0

【示例2】作为减号使用。作为减号使用时，常用应用如下：

num1 = 5
num2 = 1
num3 = 10
num4 = 8.0
print(num1 - num2)  # 4
print(num1 - num3)  # -5
print(num1 - num4)  # -3.0

1.3 * ——两个数相乘或是返回一个被重复若干次的字符串、列表、元组

* 运算符在 Python 中有两个作用，一个是作为乘号使用，表示两个数相乘；另一个是和整数 n 组合，作为重复符号使用，表示字符串、列表、元组重复 n 次。

【示例1】作为乘号使用。作为乘号使用时，常用应用如下：

num1 = 3
num2 = 4
num3 = 5.5
num4 = -6
print(num1 * num2)  # 12
print(num1 * num3)  # 16.5
print(num1 * num4)  # -18

【示例2】对字符串使用*号。使用“*”作为重复符号，打印一个等腰三角形。代码如下：

print(' ' * 2 + '*' + ' ' * 2)
print(' ' + '*' * 3 + ' ')
print('*' * 5)

【示例3】对元组使用*号。“*”号作为重复符号，同样可以作用在元组上。

l1 = (1, 2, 3)
l2 = (('a', 'b', 'c'), ('d', 'e', 'f'))
# (1, 2, 3, 1, 2, 3, 1, 2, 3)
print(l1 * 3)
# (('a', 'b', 'c'), ('d', 'e', 'f'), ('a', 'b', 'c'), ('d', 'e', 'f'))
print(l2 * 2)

【示例4】对列表使用*号。“*”号作为重复符号，同样可以作用在列表上。

l1 = [1, 2, 3]
l2 = [['a', 'b', 'c']]
board = [['-'] * 3 for i in range(3)]  # 使用列表解析式
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
print(l1 * 3)
# [['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
print(l2 * 3)
# [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]
print(board)

1.4 / ——两个数相除

/ 运算符用于实现 2 个对象的相除。

【示例1】实现人民币和美元的转换。已知1美元兑换人民币 6.78 元，编写程序实现人民币转换成美元的功能。代码如下：

exchange_rate = 6.78  # 汇率
RMB = input('请输入人民币金额：')
try:
    US = float(RMB) / exchange_rate
    print('转化后的美元是:{:.2f}'.format(US))
except ValueError:
    print('请输入正确的数值类型。')

程序执行结果如下图所示：

1.5 // ——返回商的整数部分（向下取整）

// 运算符用于取整除，返回商的整数部分，注意向下取整。例如 8 // 3 = 2。

【示例1】将描述“秒”转化为“分 秒”的格式。在考试系统中需要记录用户的答题时间。通常答题时间是以秒为单位记录的。比如用时“100”秒，为了增加可读性，需要将“100秒”转化为“1分钟40秒“的形式。如下代码，可以实现该功能：

def second_format(seconds):
    minutes = seconds // 60  # 计算分钟数
    if minutes > 0:
        seconds = seconds - minutes * 60  # 计算剩余秒数
    return minutes, seconds


i = 2
while i > 0:
    seconds = input('请输入秒数：')
    result = second_format(int(seconds))
    print(f'{seconds}秒可以转化为{result[0]}分{result[1]}秒')
    i -= 1

程序执行结果如下图所示：

【示例2】统计程序运行所占用的内存。psutil 是个跨平台库模块，能够轻松实现获取系统运行的进程和系统利用率，包括CPU、内存、磁盘、网络等信息。使用“pip install psutil”命令安装psutil模块，然后统计程序运行所占用的内存，并将其转化MB单位大小。代码如下：

import os
import psutil


def show_memory_info(hint):
    """显示当前Python程序占用的内存大小"""
    pid = os.getpid()
    p = psutil.Process(pid)
    info = p.memory_full_info()
    memory = info.uss / 1024. / 1024  # 1MB = 1024KB = 1024B
    print('{} memory used: {} MB'.format(hint, memory))


# 测试函数占用多少内存
show_memory_info('initial')
list_val = [i for i in range(10000000)]
show_memory_info('finished')

程序执行结果如下图所示：

1.6 % ——返回除法的余数

% 运算符用于取模，返回除法的余数，例如 8%2 结果为 0，8%3 结果为2。

【示例1】负数使用%求余数。计算下面的除法求余结果：

result1 = 8 % 3
result2 = -8 % 3
result3 = 8 % -3
result4 = 0 % -3  # 0
result5 = 0 % 6  # 0
print(f"8  % 3 的结果是：{result1}")  # 2
print(f"-8 % 3 的结果是：{result2}")  # 1
print(f"8 % -3 的结果是：{result3}")  # -1

上面的结果可能与很多人的预期不符，这个结果是由 Python 机制决定的。在 Python 中取余数遵循下面的公式：

r=a-n*(a//n)
# r=a-n*(a//n)
# 8 % 3 ==> a=8,n=3 ==> 8-3*(8//3) ==> 8-3*2 ==> 2
# 注意：-8//3 计算时向下取整，结果为-3，而不是-2。
# -8 % 3 ==> a=-8,n=3 ==> -8-3*(-8//3) ==> -8-3*(-3) ==> -8+9 ==> 1
# 8 % -3 ==> a=8,n=-3 ==> 8-(-3)*(8//-3) ==> 8+3*(-3) ==> 8-9 ==> -1

1.7 ** ——返回一个数的幂

** 运算符用于返回一个数的幂，例如 2 ** 2 结果为4 ，2 ** 3 结果为8。

【示例1】用 3 种方式求 x 的 y 次幂。

import math

# 计算x的y次幂
x = 10
y = 3
# 方式1
print(x ** y)  # 1000
# 方式2
print(pow(x, y))  # 1000
# 方式3
print(math.pow(x, y))  # 返回类型为浮点型: 1000.0

1.8 = —— 简单的赋值

= 是简单的赋值运算符，例如将 a=1，表示将数值 1 赋值给变量 a。

【示例1】不同类型数据的赋值。

# 常用数据类型赋值
num = 123  # 数值
str_val = "Amo"  # 字符串
tuple_val = (1, 2, 3)  # 元组
list_val = [1, 2, 3]  # 列表
dict_val = {"name": "Amo", "age": 18}  # 字典
set_val = {1, 2, 3}  # 集合


def fun():
    print("函数赋值")


f = fun  # 函数赋值
f()  # 调用函数：函数赋值


class Student:

    def __init__(self):
        print("类赋值")


s = Student  # 类赋值
s()  # 类的实例化：类赋值

1.9 += —— 加法赋值

+= 是加法赋值运算符，例如将 a +=1,等价于 a=a+1。

【示例1】计算字典中各值的累加和。

basket = {"fruit": 45.80, "meat": 20.45, "juice": 10}  # 购物车数据
total = 0  # 初始化总价
# 方式1：
for item in basket.values():
    total += item
print(f'方式1的计算结果为{total}')
# 方式2：
total = sum(basket.values())
print(f'方式2的计算结果为{total}')

【示例2】将数字0-9自动转化为汉字。

numbers = input("请输入0-9之间的数字:")
digits_mapping = {
    "0": "零",
    "1": "壹",
    "2": "贰",
    "3": "叁",
    "4": "肆",
    "5": "伍",
    "6": "陆",
    "7": "柒",
    "8": "捌",
    "9": "玖",
}

output = ""
for number in numbers:  # 遍历输入的数字
    output += digits_mapping.get(number, "!") + " "  # 匹配字典的键，然后将结果连接在一起
print(output)

1.10 -= —— 减法赋值

-= 是减法赋值运算符，如加法运算符类似，例如将a -=1,等价于a=a-1。

【示例1】“逢7过”游戏。“逢7过”是一个锻炼头脑敏捷性的益智游戏。游戏规则是大家围成一圈，然后从1开始依序喊数字，如果数字是7或者7的倍数，就不能喊出这个数字，必须做一个动作。使用Python 计算出200以内的7的倍数。例如7、14、28等。代码如下：

value = 200  # 初始值
L = []
while value > 0:
    if value % 7 == 0:  # 如果被7整除
        L.append(value)  # 添加到列表
    value -= 1
L.reverse()  # 列表反转
print(L)  # 输出列表

1.11 *= —— 乘法赋值

“*=”是乘法赋值运算符，如加法运算符类似，例如将a *=3,等价于a = a*3。

【示例1】多种类型使用乘法赋值。对不同类型数据使用乘法赋值运算，代码如下：

# 数字
num = 5
num *= 3
print(num)  # 15
# 字符串
str_val = "Amo"
str_val *= 3
print(str_val)  # AmoAmoAmo
# 元组
tuple_val = (1, 2, 3)
tuple_val *= 3
print(tuple_val)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)
# 列表
list_val = [1, 2, 3]
list_val *= 3
print(list_val)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

【示例2】计算摆满国际象棋所需要的麦子数。国际象棋共有64个格子，如果第一个小格内放入一粒麦子，在第二个小格内放入两粒，第三小格内放入给四粒，以此类推，每一小格内都比前一小格加一倍的麦子，直至放满64个格子，总共需要多少颗麦子。代码如下：

def getNumberOfWheat(grid):
    """
    获取放grid格时的麦子数
    :param grid: 格子数
    :return: 返回放满格子数时的麦子数量
    """
    g_sum = 0
    numberOfWhearInGrid = 1  # 第一个格子放置1粒
    g_sum += numberOfWhearInGrid  # 第一个格子的总粒数
    for i in range(2, grid + 1):  # 从第2个格子开始，遍历每一个格子
        numberOfWhearInGrid *= 2  # 下一个格子是前一个格子的2倍
        g_sum += numberOfWhearInGrid  # 计算所有格子中总粒数
    return g_sum


print(f"放满4个格子需要{getNumberOfWheat(4)}颗麦子")  # 由于第1个格子默认放置1，所以从第2个开始计算共63个格子
print(f'放满64个格子需要{getNumberOfWheat(64)}颗麦子')  # 由于第1个格子默认放置1，所以从第2个开始计算共63个格子

1.12 /= —— 除法赋值运算符

/= 是除法赋值运算符，例如将 a /=3,等价于 a = a/3。

【示例1】用2种方式对列表中的元素批量相除。

list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i / 2 for i in list_value]  # 使用列表解析式
print(new_value)  # [0.5, 1.0, 1.5, 2.0, 2.5]
# 方式2：
new_value = []
for i in list_value:
    i /= 2  # 除法赋值运算
    new_value.append(i)  # 追加到新列表
print(new_value)  # [0.5, 1.0, 1.5, 2.0, 2.5]

1.13 %= —— 取模赋值运算符

%= 是取模运算符，例如将 a %= 3,等价于a = a%3。

【示例1】对列表中的元素批量取模。

list_value = [10, 11, 12, 13, 14, 15]
new_value = []
for i in list_value:
    i %= 2  # 取模运算
    val = '奇数' if i else '偶数'  # 三元表达式
    new_value.append(val)  # 追加到新列表
print(new_value)  # ['偶数', '奇数', '偶数', '奇数', '偶数', '奇数']

1.14 **= —— 幂赋值运算符

“**=”是幂赋值运算符，例如将a **= 3,等价于a = a**3。

【示例1】用3种方式对列表中的元素批量求平方。

list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i ** 2 for i in list_value]  # 使用列表解析式
print(new_value)  # [1, 4, 9, 16, 25]
# 方式2
new_value = []
for i in list_value:
    i **= 2  # 幂赋值操作
    new_value.append(i)  # 追加到新列表
print(new_value)  # [1, 4, 9, 16, 25]
# 方式3
new_value = list(map(lambda x: x ** 2, list_value))
print(new_value)  # [1, 4, 9, 16, 25]

1.15 //= —— 取整除赋值运算符

“//=”是取整除赋值运算符，例如将a //= 3,等价于a = a//3。

【示例1】用3种方式对列表中的元素批量取整数赋值

list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i // 2 for i in list_value]  # 使用列表解析式
print(new_value)  # [0, 1, 1, 2, 2]
# 方式2
new_value = []
for i in list_value:
    i //= 2
    new_value.append(i)  # 追加到新列表
print(new_value)  # [0, 1, 1, 2, 2]
# 方式3
new_value = list(map超详细的 MySQL 学习教程(多实例附练习视频讲解持续更新)

 超详细的 MySQL 学习教程(多实例附练习视频讲解持续更新)
 Python 课课练 ：函数课后练习题
 十年Python大牛花了三天总结出来的python基础知识实例，超详细！
 十年Python大牛花了三天总结出来的python基础知识实例，超详细！
 Java多线程学习（吐血超详细总结）