【Python基础语法详解】一篇文章带你快速入门Python

前言:本文章是在已经学习了C语言之后作者角度下进行书写的一篇关于python当中基础的语法说明。

文章目录

  • 快速深入理解python当中的语法
  • 基本数据类型
  • 算数运算符
  • 类型的查看与转换
  • 变量的输入与输出
  • 条件语句
  • 比较运算符和逻辑运算符
  • if、elif、else
  • 三目运算符
  • 循环语句
  • while循环
  • for循环
  • break和continue
  • 序列类型的操作
  • 字符串的增删查改
  • 字符串中常见的转义字符
  • 列表的增删查改
  • 列表推导表达式
  • 元组的操作
  • 散列类型的操作
  • 快速深入理解python当中的语法

    Python 简介:
    Python 是一种高级编程语言,因其简单易学、可读性强以及多功能性而备受欢迎。Python 支持多种编程范式,包括面向对象、过程化编程和函数式编程。
    

    基本数据类型

    整数类型 (int):整数类型用于表示没有小数部分的数值,正负均可。
    Python 中的整数不受大小限制,可以表示任意大的数

    浮点数类型 (float):浮点数表示带有小数部分的数值,可以是正数或负数。
    Python 中浮点数是双精度的,通常可以提供足够的精度来处理大部分场景下的小数运算。

    布尔类型 (bool):布尔类型用于表示逻辑值,只有两个可能的值:True(真)和 False(假)。
    布尔类型经常用于条件判断和逻辑操作。

    字符串类型 (str):字符串用于存储文本数据。它由一对单引号或双引号包围的字符序列构成。
    字符串是不可变的,即一旦创建就不能修改其内容。

    算数运算符

    # 加法
    add_result = 3 + 5
    print("加法结果: 3 + 5 =", add_result)
    
    # 减法
    sub_result = 10 - 4
    print("减法结果: 10 - 4 =", sub_result)
    
    # 乘法
    mul_result = 6 * 7
    print("乘法结果: 6 * 7 =", mul_result)
    
    # 除法
    div_result = 15 / 3
    print("除法结果: 15 / 3 =", div_result)
    
    # 取整除法
    floordiv_result = 15 // 4
    print("取整除法结果: 15 // 4 =", floordiv_result)
    
    # 取余
    mod_result = 10 % 3
    print("取余结果: 10 % 3 =", mod_result)
    
    # 幂运算
    pow_result = 2 ** 3
    print("幂运算结果: 2 ** 3 =", pow_result)
    

    以上就是python当中最基本的一些运算符
    并且为了方便计算

    1. 一元负号 (-)
    2. 增量运算符 (+=)
    3. 减量运算符 (-=)
    4. 乘量运算符 (*=)
    5. 除量运算符 (/=)
    6. 幂量运算符 (**=)
    7. 取余运算符 (%=)

    示例:

    # 基础算数运算符
    add_result = 3 + 5
    print("加法结果: 3 + 5 =", add_result)
    
    sub_result = 10 - 4
    print("减法结果: 10 - 4 =", sub_result)
    
    mul_result = 6 * 7
    print("乘法结果: 6 * 7 =", mul_result)
    
    div_result = 15 / 3
    print("除法结果: 15 / 3 =", div_result)
    
    floordiv_result = 15 // 4
    print("取整除法结果: 15 // 4 =", floordiv_result)
    
    mod_result = 10 % 3
    print("取余结果: 10 % 3 =", mod_result)
    
    pow_result = 2 ** 3
    print("幂运算结果: 2 ** 3 =", pow_result)
    
    # 扩展运算符
    neg_result = -5
    print("一元负号结果: -5 =", neg_result)
    
    x = 5
    x += 3
    print("增量运算结果: 5 += 3 =", x)
    
    x = 10
    x -= 4
    print("减量运算结果: 10 -= 4 =", x)
    
    x = 6
    x *= 2
    print("乘量运算结果: 6 *= 2 =", x)
    
    x = 15
    x /= 3
    print("除量运算结果: 15 /= 3 =", x)
    
    x = 2
    x **= 3
    print("幂量运算结果: 2 **= 3 =", x)
    
    x = 10
    x %= 3
    print("取余运算结果: 10 %= 3 =", x)
    
    

    类型的查看与转换

    查看变量类型:
    Python 提供了内置的 type() 函数,用于查看变量的类型。这个函数会返回对象的类型信息。
    示例:

    x = 10
    y = 3.14
    z = "Hello"
    is_active = True
    
    print(type(x))        # 输出: <class 'int'>
    print(type(y))        # 输出: <class 'float'>
    print(type(z))        # 输出: <class 'str'>
    print(type(is_active)) # 输出: <class 'bool'>
    
    

    type() 返回值为对象的类型,如 int、float、str、bool 等。
    类型转换:
    Python 提供了许多内置函数来进行不同数据类型之间的转换,常见的类型转换函数包括 int()、float()、str()、bool() 等。
    示例:

    #1. 整数转换 (int())
    # 浮点数转换为整数
    x = int(3.14)  # 输出: 3
    print(x)
    
    # 布尔类型转换为整数
    z = int(True)  # 输出: 1
    print(z)
    
    #2. 浮点数转换 (float())
    # 整数转换为浮点数
    x = float(10)  # 输出: 10.0
    print(x)
    
    # 布尔类型转换为浮点数
    z = float(False)  # 输出: 0.0
    print(z)
    
    # 3. 字符串转换 (str())
    # 整数转换为字符串
    x = str(10)  # 输出: '10'
    print(x)
    
    # 布尔类型转换为字符串
    z = str(True)  # 输出: 'True'
    print(z)
    
    # 4. 布尔类型转换 (bool())
    # 数字转换为布尔值
    x = bool(0)  # 输出: False
    print(x)
    
    # 空字符串转换为布尔值
    z = bool("")  # 输出: False
    print(z)
    

    变量的输入与输出

    1. 输入变量
      使用 input() 函数可以从用户那里获取输入。
      input() 函数会将所有输入作为字符串返回,所以通常需要转换成合适的类型(如 int 或 float)。
      示例:
    # 从用户获取输入并转换为整数
    num = int(input("请输入一个数字: "))
    print(f"你输入的数字是: {num}")
    
    1. 输出变量
      使用 print() 函数可以将变量输出到屏幕。
      你可以直接输出变量,也可以通过格式化字符串来控制输出格式。
      示例:
    # 简单输出
    name = "Alice"
    print(name)
    
    # 格式化输出
    age = 25
    print(f"{name} 今年 {age} 岁")
    
    1. 多个输入和输出也叫做f-string
      可以一次获取多个输入并同时输出多个变量,使用 split() 函数将输入字符串拆分为多个部分。
      示例:
    # 输入多个变量
    a, b = input("请输入两个数字,用空格分隔: ").split()
    a = int(a)
    b = int(b)
    # 输出多个变量
    print(f"第一个数字是: {a}, 第二个数字是: {b}")
    

    示例:

    1.变量插值:
    name = "Bob"
    print(f"Hello, {name}!")
    # 输出: Hello, Bob!
    
    2.表达式插值:
    a = 5
    b = 3
    print(f"{a} + {b} = {a + b}")
    # 输出: 5 + 3 = 8
    
    3.格式化输出:
    pi = 3.1415926535
    print(f"圆周率的近似值: {pi:.2f}")  # 保留两位小数
    # 输出: 圆周率的近似值: 3.14
    
    4.调用函数:
    def greet(name):
        return f"Hello, {name}!"
    print(f"{greet('Alice')}")
    # 输出: Hello, Alice!
    
    5.多行 f-string:
    name = "Eve"
    age = 27
    info = f"""
    姓名: {name}
    年龄: {age}
    """
    print(info)
    

    条件语句

    比较运算符和逻辑运算符

    比较运算符:“==”、“!=”、“<”、“>”、“>=”、“<=”

    1. == (等于)
      检查两个值是否相等,如果相等返回 True,否则返回 False。

    2. != (不等于)
      检查两个值是否不相等,如果不相等返回 True,否则返回 False。

    3. < (小于)
      检查左边的值是否小于右边的值,如果小于返回 True,否则返回 False。

    4. (大于) 检查左边的值是否大于右边的值,如果大于返回 True,否则返回 False。

    5. = (大于等于)检查左边的值是否大于或等于右边的值,如果是,返回 True,否则返回 False。

    6. <= (小于等于)
      检查左边的值是否小于或等于右边的值,如果是,返回 True,否则返回 False。

    逻辑运算符:“and”、“or”、“not”

    1. and (与)
      and 运算符用于同时检查多个条件。如果所有条件都为 True,则返回 True;如果有一个条件为 False,则返回 False。
    2. or (或)
      or 运算符用于检查多个条件。如果其中一个条件为 True,则返回 True;只有当所有条件都为 False 时,才返回 False。
    3. not (非)
      not 运算符用于取反。如果条件为 True,则 not 会将其变为 False;如果条件为 False,则 not 会将其变为 True。

    if、elif、else

    1. if 语句
      if 语句用于测试一个条件。如果条件为真(True),则执行 if 块中的代码。
      示例:
    x = 10
    if x > 5:
        print("x 大于 5")
    
    1. elif 语句
      elif 是 “else if” 的缩写,用于测试另一个条件。如果前面的 if 条件为假(False),则程序会继续检查 elif 条件。如果该条件为真,执行相应的代码块。
      示例:
    x = 10
    if x > 15:
        print("x 大于 15")
    elif x > 5:
        print("x 大于 5,但小于等于 15")
    
    1. else 语句
      else 是最后的 “兜底” 语句,如果 if 和所有 elif 条件都为假(False),则会执行 else 后面的代码块。
      示例:
    x = 3
    if x > 5:
        print("x 大于 5")
    elif x == 5:
        print("x 等于 5")
    else:
        print("x 小于 5")
    

    三目运算符

    三目运算符(也叫条件表达式)是用来简洁地表达 if-else 语句的,它允许在一行中根据条件返回不同的值。
    其语法:

    结果1 if 条件 else 结果2
    

    条件:这是一个布尔表达式,如果为真(True),将返回 结果1。
    结果1:当条件为真时,返回的值。
    结果2:当条件为假(False)时,返回的值。

    示例:

    x = 10
    y = 20
    
    # 使用三目运算符
    result = "x 大于 y" if x > y else "x 小于或等于 y"
    print(result)
    #输出结果:x 小于或等于 y
    

    三目运算符的优势:
    可以在一行中实现 if-else 逻辑,使代码更简洁,并且增加代码的可读性。

    循环语句

    while循环

    while 循环在条件为真(True)时,反复执行代码块。当条件变为假(False)时,循环结束。

    while 条件:
        执行的代码
    

    示例:

    #打印从一到五
    i = 1
    while i <= 5:
        print(i)
        i += 1  # 每次循环后 i 加 1
    

    for循环

    for 循环用于遍历一个可迭代对象(如列表、字符串、元组、字典、集合等),对其中的每个元素执行相同的操作。

    for 变量 in 可迭代对象:
        执行的代码
    

    示例:

    #遍历列表中的每个元素
    numbers = [1, 2, 3, 4, 5]
    for num in numbers:
        print(num)
    

    break和continue

    break:用于提前终止循环。
    continue:跳过当前迭代,直接进入下一次循环。

    这两个的使用用法在python当中与C当中使用情况是一样的

    序列类型的操作

    字符串的增删查改

    字符串是不可变的序列类型,因此在修改字符串时只能创建一个新的字符串。

    增(插入字符)
    通过切片和拼接在字符串的指定位置插入字符。
    示例:

    my_string = "HelloWorld"
    
    # 在索引5处插入字符 "Python"
    new_string = my_string[:5] + " Python " + my_string[5:]
    print(new_string)  # 输出:Hello Python World
    

    删(删除字符)
    通过切片或 replace() 方法删除字符或子串。
    示例:

    # 使用切片删除索引5的字符
    my_string = "HelloWorld"
    new_string = my_string[:5] + my_string[6:]
    print(new_string)  # 输出:Helloorld
    
    # 使用 replace() 删除所有的 "l"
    new_string = my_string.replace("l", "")
    print(new_string)  # 输出:HeoWord
    

    查(查找字符或子串)
    find():查找子串第一次出现的位置,找不到返回 -1。
    index():与 find() 类似,但找不到会抛出异常。
    count():返回子串出现的次数。
    in 运算符:检查子串是否存在。
    示例:

    my_string = "HelloWorld"
    print(my_string.find("o"))     # 输出:4
    print(my_string.index("World")) # 输出:5
    print(my_string.count("l"))     # 输出:3
    print("Hello" in my_string)     # 输出:True
    

    改(修改字符)
    通过切片和拼接,或使用 replace() 进行修改。
    示例:

    # 将 "World" 修改为 "Python"
    new_string = my_string[:5] + "Python"
    print(new_string)  # 输出:HelloPython
    
    # 使用 replace() 修改字符
    new_string = my_string.replace("l", "x")
    print(new_string)  # 输出:HexxoWorxd
    

    字符串中常见的转义字符

    \:反斜杠
    ':单引号
    ":双引号
    \n:换行
    \t:制表符
    \r:回车
    示例

    # 插入转义字符
    my_string = "He said, \"Hello World!\""
    print(my_string)  # 输出:He said, "Hello World!"
    
    # 插入换行符
    my_string = "Hello\nWorld"
    print(my_string)
    # 输出:
    # Hello
    # World
    

    列表的增删查改

    列表是可变的序列类型,因此可以直接进行增删查改操作。
    增(插入元素)
    append():在列表末尾添加元素。
    insert():在指定索引处插入元素。
    extend():将另一个列表中的所有元素添加到列表末尾。
    示例:

    my_list = [1, 2, 3]
    
    # 在末尾添加元素
    my_list.append(4)
    print(my_list)  # 输出:[1, 2, 3, 4]
    
    # 在索引1处插入元素
    my_list.insert(1, 5)
    print(my_list)  # 输出:[1, 5, 2, 3, 4]
    
    # 扩展列表
    my_list.extend([6, 7])
    print(my_list)  # 输出:[1, 5, 2, 3, 4, 6, 7]
    

    删(删除元素)
    remove():删除第一次出现的指定元素。
    pop():删除并返回指定索引的元素,默认删除最后一个。
    clear():清空列表。
    del 关键字:删除列表中的指定元素或整个列表。
    示例:

    my_list = [1, 2, 3, 4, 5]
    
    # 删除指定元素
    my_list.remove(3)
    print(my_list)  # 输出:[1, 2, 4, 5]
    
    # 删除指定索引的元素
    my_list.pop(1)
    print(my_list)  # 输出:[1, 4, 5]
    
    # 清空列表
    my_list.clear()
    print(my_list)  # 输出:[]
    
    # 使用 del 删除索引2的元素
    my_list = [1, 2, 3, 4, 5]
    del my_list[2]
    print(my_list)  # 输出:[1, 2, 4, 5]
    

    查(查找元素)
    index():返回第一次出现的元素索引。
    count():统计元素出现的次数。
    in:判断元素是否在列表中。
    示例:

    my_list = [1, 2, 3, 4, 3]
    
    # 查找元素3第一次出现的索引
    print(my_list.index(3))  # 输出:2
    
    # 统计元素3出现的次数
    print(my_list.count(3))  # 输出:2
    
    # 判断元素是否在列表中
    print(4 in my_list)  # 输出:True
    

    改(修改元素)
    直接通过索引修改元素。
    示例:

    my_list = [1, 2, 3, 4, 5]
    
    # 修改索引1的元素
    my_list[1] = 10
    print(my_list)  # 输出:[1, 10, 3, 4, 5]
    

    列表推导表达式

    列表推导式是简洁的方式来生成列表,通常用于替代 for 循环。它允许在一行代码中创建列表,并可以包含条件表达式。
    语法:

    [表达式 for 变量 in 可迭代对象 if 条件]
    

    示例:

    # 生成一个包含0到9的列表
    numbers = [x for x in range(10)]
    print(numbers)  # 输出:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    # 生成一个包含偶数的列表
    evens = [x for x in range(10) if x % 2 == 0]
    print(evens)  # 输出:[0, 2, 4, 6, 8]
    
    # 将列表中的元素平方
    squares = [x**2 for x in range(10)]
    print(squares)  # 输出:[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    元组的操作

    元组(tuple)是不可变的序列类型,不能直接修改其内容,但支持查找、切片、拼接等操作。

    创建元组
    元组用小括号创建,逗号分隔元素。
    示例:

    my_tuple = (1, 2, 3)
    print(my_tuple)  # 输出:(1, 2, 3)
    

    查(查找元素)
    index():返回元素第一次出现的索引。
    count():统计元素出现的次数。
    in:检查元素是否在元组中。
    示例:

    my_tuple = (1, 2, 3, 4, 3)
    
    # 查找元素3的索引
    print(my_tuple.index(3))  # 输出:2
    
    # 统计元素3的出现次数
    print(my_tuple.count(3))  # 输出:2
    

    切片
    可以通过切片操作从元组中获取子元组。
    示例:

    my_tuple = (1, 2, 3, 4, 5)
    
    # 获取元组的切片
    print(my_tuple[1:4])  # 输出:(2, 3, 4)
    

    拼接
    可以通过 + 操作符拼接两个元组。
    示例:

    tuple1 = (1, 2, 3)
    tuple2 = (4, 5)
    
    # 拼接两个元组
    new_tuple = tuple1 + tuple2
    print(new_tuple)  # 输出:(1, 2, 3, 4, 5)
    


    总结对比:
    可变性:字符串和元组不可变,列表可变。
    有序性:三者都是有序序列,支持索引和切片。
    元素类型:列表和元组可以包含任意类型的数据,字符串只能包含字符。

    散列类型的操作

    散列类型(也称为哈希类型)主要包括 字典(dict) 和 集合(set)。它们的操作方式与序列类型不同,主要用于基于键值对(dict)或集合中独特元素(set)的快速查找。接下来将对这两种散列类型的操作进行详细总结。
    1. 字典(dict)
    字典是 Python 中的一种哈希映射类型,用于存储键值对,键必须是可散列的(通常是不可变类型,如字符串、数字、元组),值可以是任意类型。

    字典的常见操作:
    增(添加键值对)
    可以通过使用键添加新值或修改现有的键值对。
    示例:

    my_dict = {"name": "Alice", "age": 25}
    
    # 添加新键值对
    my_dict["city"] = "New York"
    print(my_dict)  # 输出:{'name': 'Alice', 'age': 25, 'city': 'New York'}
    
    # 修改已有的键值对
    my_dict["age"] = 26
    print(my_dict)  # 输出:{'name': 'Alice', 'age': 26, 'city': 'New York'}
    

    删(删除键值对)
    pop(key):删除指定键,并返回对应的值。
    popitem():删除并返回最后插入的键值对(字典是无序的,Python 3.7+ 中有顺序)。
    clear():清空字典。
    del:使用 del 关键字删除键值对或整个字典。
    示例:

    my_dict = {"name": "Alice", "age": 25, "city": "New York"}
    
    # 删除指定键
    my_dict.pop("age")
    print(my_dict)  # 输出:{'name': 'Alice', 'city': 'New York'}
    
    # 删除最后一个键值对
    my_dict.popitem()
    print(my_dict)  # 输出:{'name': 'Alice'}
    
    # 清空字典
    my_dict.clear()
    print(my_dict)  # 输出:{}
    
    # 使用 del 删除字典中的键
    del my_dict["name"]
    

    查(查找键值对)
    通过键查找值,如果键不存在会抛出 KeyError 异常,可以使用 get() 方法避免异常。
    keys():返回字典中所有的键。
    values():返回字典中所有的值。
    items():返回字典中的所有键值对。
    in:用于检查键是否存在于字典中。
    示例:

    my_dict = {"name": "Alice", "age": 25, "city": "New York"}
    
    # 查找键 "name" 对应的值
    print(my_dict["name"])  # 输出:Alice
    
    # 使用 get() 查找键(如果键不存在不会报错)
    print(my_dict.get("age", "不存在"))  # 输出:25
    
    # 获取所有键、值和键值对
    print(my_dict.keys())    # 输出:dict_keys(['name', 'age', 'city'])
    print(my_dict.values())  # 输出:dict_values(['Alice', 25, 'New York'])
    print(my_dict.items())   # 输出:dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])
    
    # 检查键是否存在
    print("age" in my_dict)  # 输出:True
    

    改(修改键值对)
    通过指定键直接修改对应的值。
    示例:

    my_dict = {"name": "Alice", "age": 25, "city": "New York"}
    
    # 修改键 "age" 的值
    my_dict["age"] = 30
    print(my_dict)  # 输出:{'name': 'Alice', 'age': 30, 'city': 'New York'}
    

    其他操作
    update():将另一个字典的键值对更新到当前字典中。
    copy():返回字典的浅拷贝。

    my_dict = {"name": "Alice", "age": 25}
    new_dict = {"city": "New York", "job": "Engineer"}
    
    # 使用 update() 方法
    my_dict.update(new_dict)
    print(my_dict)  # 输出:{'name': 'Alice', 'age': 25, 'city': 'New York', 'job': 'Engineer'}
    

    2. 集合(set)
    集合是一种无序、不重复的元素集合。集合主要用于成员资格测试、去重和集合操作(如并集、交集等)。

    增(添加元素)
    add():向集合中添加单个元素。
    update():向集合中添加多个元素(可以是列表、元组等)。
    示例:

    my_set = {1, 2, 3}
    
    # 添加单个元素
    my_set.add(4)
    print(my_set)  # 输出:{1, 2, 3, 4}
    
    # 添加多个元素
    my_set.update([5, 6, 7])
    print(my_set)  # 输出:{1, 2, 3, 4, 5, 6, 7}
    

    删(删除元素)
    remove():删除指定元素,若元素不存在则抛出异常。
    discard():删除指定元素,若元素不存在不会抛出异常。
    pop():删除并返回集合中的任意元素(集合无序)。
    clear():清空集合。
    del:删除整个集合。
    示例:

    my_set = {1, 2, 3, 4}
    
    # 删除指定元素
    my_set.remove(2)
    print(my_set)  # 输出:{1, 3, 4}
    
    # 删除不存在的元素(不会抛异常)
    my_set.discard(5)
    
    # 删除集合中的任意元素
    my_set.pop()
    print(my_set)  # 输出:{3, 4}
    
    # 清空集合
    my_set.clear()
    print(my_set)  # 输出:set()
    

    查(查找键值对)
    查(查找元素)
    使用 in 运算符判断元素是否在集合中。
    集合中无重复元素,所有的元素都独一无二。
    示例:

    my_set = {1, 2, 3, 4}
    
    # 判断元素是否存在于集合中
    print(3 in my_set)  # 输出:True
    print(5 in my_set)  # 输出:False
    

    集合运算
    并集(| 或 union()):返回两个集合的并集。
    交集(& 或 intersection()):返回两个集合的交集。
    差集(- 或 difference()):返回当前集合与另一个集合的差集。
    对称差集(^ 或 symmetric_difference()):返回只存在于其中一个集合中的元素。
    示例:

    set1 = {1, 2, 3}
    set2 = {3, 4, 5}
    
    # 并集
    print(set1 | set2)  # 输出:{1, 2, 3, 4, 5}
    
    # 交集
    print(set1 & set2)  # 输出:{3}
    
    # 差集
    print(set1 - set2)  # 输出:{1, 2}
    
    # 对称差集
    print(set1 ^ set2)  # 输出:{1, 2, 4, 5}
    

    作者:酷酷的崽798

    物联沃分享整理
    物联沃-IOTWORD物联网 » 【Python基础语法详解】一篇文章带你快速入门Python

    发表回复