python 基础语法和基本概念

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量487 收藏 2
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45799465/article/details/131792770
版权

目录

注释

标识符

变量

字面量

数据类型转化

运算符

控制流

数据结构

列表操作

元组操作

集合操作

字典操作

字符串操作

本文只记录python的基础语法，方便查阅。

注释

单行注释

使用#符号来注释单行代码。在#之后的所有内容都会被解释器忽略。

# 这是一个单行注释

多行注释

使用三重引号(""")或三个单引号(''')来注释多行代码。这种注释通常用于函数、类或模块级别的说明。 

"""
这是一个多行注释的示例。
这里可以写更多的内容来解释代码。
"""

函数注释

在函数定义的行上方使用文档字符串来描述函数的目的、参数和返回值。文档字符串是多行注释的一种特殊形式。

def add_numbers(a, b):
    """
    这个函数用于将两个数字相加。
    参数：
    - a: 第一个数字
    - b: 第二个数字
    返回值：
    两个数字的和
    """
    return a + b

类注释

在类定义的行上方使用文档字符串来描述类的目的、属性和方法。文档字符串也是多行注释的一种形式。

class Person:
    """
    这个类表示一个人的属性和行为。
    属性：
    - name: 姓名
    - age: 年龄
    方法：
    - greet(): 打招呼
    """
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"你好，我是{self.name}，今年{self.age}岁。")

标识符

在Python中，标识符是用于命名变量、函数、类、模块以及其他对象的名称。标识符有一些规则和约定，这些规则和约定包括：

  1. 标识符由字母、数字和下划线（_）组成。
  2. 标识符必须以字母（a-z、A-Z）或下划线（_）开头，不能以数字开头。
  3. 标识符区分大小写，这意味着myvariable和myVariable是不同的标识符。
  4. Python关键字（保留字）不能用作标识符，因为它们具有特殊的含义。一些常见的关键字包括if、else、for、while、class等。

以下是一些有效的Python标识符示例：

my_variable
myVariable
count_1
PI
AnimalClass

以下是一些无效的Python标识符示例：

2variable  # 以数字开头
my-variable  # 包含连字符
for  # 关键字不能用作标识符
class  # 关键字不能用作标识符

除了这些基本规则，还有一些命名约定，用于提高代码的可读性。例如，变量名通常使用小写字母，用下划线分隔单词，而类名通常使用大写字母开头的单词，采用驼峰命名法。这些约定不是强制性的，但它们有助于编写更清晰和易于理解的代码。

变量

在Python中，变量是用于存储数据的名称。变量是程序中的标识符，用于引用内存中的数据对象。当您将数据赋给变量时，Python会自动分配内存以存储该数据，并将变量与该内存位置关联。

以下是创建和使用变量的基本规则：

  1. 变量的命名：变量的命名需要遵循标识符规则，如前面所述。变量名应具有描述性，以便易于理解变量所存储的数据。

  2. 变量赋值：要将数据分配给变量，使用等号（=）运算符。例如，x = 10 表示将整数值 10 分配给变量 x。

  3. 动态类型：Python是一种动态类型语言，这意味着您不需要显式指定变量的数据类型。Python会根据分配给变量的值自动确定其数据类型。

# 创建一个整数变量
x = 10

# 创建一个字符串变量
name = "Alice"

# 创建一个列表变量
my_list = [1, 2, 3]

# 变量可以随时重新赋值不同类型的数据
x = "Hello"

  1. 变量引用：在代码中使用变量时，只需使用变量名即可。例如，print(x) 会输出变量 x 的值。

  2. 变量的作用域：变量的作用域指的是变量在代码中可见的范围。在函数内部定义的变量只能在该函数内部访问，而在函数外部定义的变量则具有全局作用域，可以在整个程序中访问。

示例：

# 全局作用域
global_var = 100

def my_function():
    # 局部作用域
    local_var = 50
    print(local_var)

my_function()
print(global_var)  # 可以访问全局变量

字面量

在Python中，字面量是一种表示数据值的语法表达方式，它们表示不同数据类型的常量值。以下是一些常见的Python字面量：

  1. 整数字面量：表示整数值的字面量。可以是十进制、八进制（以0o或0O开头）、十六进制（以0x或0X开头）或二进制（以0b或0B开头）。例如：

    x = 42  # 十进制
y = 0o52  # 八进制，等于十进制的42
z = 0x2A  # 十六进制，等于十进制的42
binary = 0b101010  # 二进制，等于十进制的42

  2. 浮点数字面量：表示浮点数值的字面量，可以包含小数点。例如：

    a = 3.14
b = 2.0

  3. 字符串字面量：表示文本字符串的字面量，可以使用单引号、双引号或三引号（用于多行字符串）。例如：

    s1 = 'Hello, World!'
s2 = "Python is great!"
s3 = """This is a
multi-line string."""

  4. 布尔字面量：表示布尔值的字面量，只有两个值：True 和 False。

    is_true = True
is_false = False

  5. None 字面量：表示空值的字面量，用于表示缺少值或占位符。

    empty_value = None

  6. 列表字面量：表示列表数据结构的字面量，使用方括号 [] 包围元素。

    my_list = [1, 2, 3]

  7. 字典字面量：表示字典数据结构的字面量，使用花括号 {} 包围键-值对。

    my_dict = {"name": "Alice", "age": 30}

  8. 集合字面量：表示集合数据结构的字面量，使用花括号 {} 包围元素，但没有键-值对。

    my_set = {1, 2, 3}

数据类型转化

在Python中，您可以进行不同数据类型之间的转换，以满足特定的需求。以下是一些常见的数据类型转换方法：

  1. 隐式类型转换：在某些情况下，Python会自动进行隐式类型转换，以使表达式成立。例如，在整数和浮点数之间的运算会将整数转换为浮点数。

    x = 5
y = 2.0
z = x + y  # x会隐式转换为浮点数，z的值为 7.0

  2. 显式类型转换：您可以使用内置函数来执行显式的类型转换。以下是一些常见的类型转换函数：

    • int()：将一个值转换为整数类型。

      x = 3.7 y = int(x) # y的值为 3

    • float()：将一个值转换为浮点数类型。

      x = 5
y = float(x)  # y的值为 5.0

    • str()：将一个值转换为字符串类型。

      x = 42
y = str(x)  # y的值为 "42"

    • list()：将一个可迭代对象（如元组、字符串或集合）转换为列表。

      tpl = (1, 2, 3)
lst = list(tpl)  # lst的值为 [1, 2, 3]

    • tuple()：将一个可迭代对象转换为元组。

      lst = [1, 2, 3] tpl = tuple(lst) # tpl的值为 (1, 2, 3)

    • set()：将一个可迭代对象转换为集合。

      lst = [1, 2, 2, 3, 3] st = set(lst) # st的值为 {1, 2, 3}

    • dict()：将可迭代对象中的键-值对转换为字典。

      pairs = [("a", 1), ("b", 2)] d = dict(pairs) # d的值为 {'a': 1, 'b': 2}

  3. 请注意，进行显式类型转换时，确保数据能够合理地转换为目标类型，否则可能会引发异常。例如，将无法将非整数字符串转换为整数。类型转换通常用于确保正确的数据处理和运算。

运算符

在Python中，运算符是用于执行各种数学和逻辑操作的特殊符号或关键词。Python支持多种不同类型的运算符，包括算术运算符、比较运算符、逻辑运算符、赋值运算符等。以下是常见的运算符及其用法：

  1. 算术运算符：

    • +：加法
    • -：减法
    • *：乘法
    • /：除法
    • %：取余（模运算）
    • //：整数除法
    • **：幂运算 
      a = 10
b = 3
c = a + b  # 13
d = a / b  # 3.3333
e = a % b  # 1
f = a // b  # 3
g = a ** b  # 1000

  2. 比较运算符：

    • ==：等于
    • !=：不等于
    • <：小于
    • >：大于
    • <=：小于等于
    • >=：大于等于

    比较运算符返回布尔值（True 或 False）：

    x = 5
y = 10
result1 = x == y  # False
result2 = x < y   # True

  3. 逻辑运算符：

    • and：逻辑与
    • or：逻辑或
    • not：逻辑非

    逻辑运算符通常用于组合布尔表达式：

    a = True
b = False
result1 = a and b  # False
result2 = a or b   # True
result3 = not a    # False

  4. 赋值运算符：

    • =：赋值
    • +=：加法赋值
    • -=：减法赋值
    • *=：乘法赋值
    • /=：除法赋值
    • %=：取余赋值
    • //=：整数除法赋值
    • **=：幂赋值

    赋值运算符用于将右侧表达式的值赋给左侧的变量：

    x = 5
x += 2  # 等同于 x = x + 2，x的值变为7

  5. 成员运算符：

    • in：用于检查某个元素是否存在于序列（如列表、字符串、元组等）中。
    • not in：用于检查某个元素是否不存在于序列中。
    my_list = [1, 2, 3, 4, 5]
result1 = 3 in my_list  # True
result2 = 6 not in my_list  # True

  6. 身份运算符：

    • is：用于检查两个对象是否是同一个对象。
    • is not：用于检查两个对象是否不是同一个对象。
    a = [1, 2, 3]
b = a
result1 = a is b  # True
result2 = a is not b  # False

控制流

Python的控制流是一组结构和语句，用于管理程序的执行流程。控制流可以分为以下几个主要方面：

  1. 条件语句（if、elif、else）：

    条件语句允许根据条件的真假来执行不同的代码块。以下是条件语句的基本结构：

    if condition:
    # 如果条件为真，执行这里的代码
elif another_condition:
    # 如果另一个条件为真，执行这里的代码
else:
    # 如果以上条件都不为真，执行这里的代码



x = 10
if x > 5:
    print("x 大于 5")
elif x == 5:
    print("x 等于 5")
else:
    print("x 小于 5")

  2. 循环语句（for、while）：

    循环语句允许多次执行一组代码块。以下是两种主要类型的循环：

    • for循环：用于遍历可迭代对象（如列表、元组、字符串等）中的元素。

      if condition:
    # 如果条件为真，执行这里的代码
elif another_condition:
    # 如果另一个条件为真，执行这里的代码
else:
    # 如果以上条件都不为真，执行这里的代码

x = 10
if x > 5:
    print("x 大于 5")
elif x == 5:
    print("x 等于 5")
else:
    print("x 小于 5")

    • while循环：根据条件的真假来执行一组代码块，直到条件变为假。

      while condition:
    # 只要条件为真，就执行这里的代码

count = 0
while count < 5:
    print(count)
    count += 1

  3. 控制循环：

    • break：用于退出当前循环。
    • continue：用于跳过当前循环迭代，继续下一次迭代。
    for i in range(1, 10):
    if i % 2 == 0:
        continue  # 跳过偶数
    print(i)
    if i == 5:
        break  # 退出循环

  4. 异常处理（try、except）：

    异常处理允许您捕获和处理运行时错误，以避免程序崩溃。以下是异常处理的基本结构：

    try:
    # 尝试执行可能引发异常的代码
except ExceptionType as e:
    # 处理异常的代码
else:
    # 如果没有发生异常，执行这里的代码
finally:
    # 无论是否发生异常，都执行这里的代码


try:
    result = 10 / 0
except ZeroDivisionError as e:
    print("除以零错误:", e)
else:
    print("结果:", result)
finally:
    print("异常处理完成")

数据结构

在Python中，数据结构用于存储和组织数据，使其易于访问和操作。Python提供了多种内置的数据结构，包括以下一些常见的：

  1. 列表（List）：列表是有序的可变序列，用于存储多个元素。列表使用方括号 [] 表示，元素之间用逗号分隔。

  2. 元组（Tuple）：元组是有序的不可变序列，用于存储多个元素。元组使用圆括号 () 表示，元素之间用逗号分隔。

  3. 集合（Set）：集合是无序的独立元素的集合，用于存储唯一的元素。集合使用花括号 {} 表示，元素之间用逗号分隔。

  4. 字典（Dictionary）：字典是键-值对的集合，用于存储映射关系。字典使用花括号 {} 表示，键和值之间使用冒号 : 分隔，键-值对之间用逗号分隔。

  5. 字符串（String）：字符串是字符序列，用于存储文本数据。字符串可以用单引号 ''、双引号 "" 或三引号 ''' 表示。

  6. 栈（Stack）：栈是一种后进先出（LIFO）的数据结构，通常用于管理函数调用、表达式求值等。

  7. 队列（Queue）：队列是一种先进先出（FIFO）的数据结构，通常用于任务调度等。

  8. 堆（Heap）：堆是一种用于优先级队列和堆排序的数据结构。

  9. 链表（Linked List）：链表是一种动态数据结构，通常用于构建其他数据结构。

  10. 树（Tree）：树是一种层次结构，包括二叉树、二叉搜索树、堆、树等。

  11. 图（Graph）：图是一种用于表示各种关系的数据结构，包括有向图和无向图。

  12. 其他：Python还支持自定义数据结构，如命名元组、命名空间、枚举等。

列表操作

在Python中，列表（List）是一种有序的可变数据结构，用于存储一组元素。您可以执行各种操作来创建、访问、修改和处理列表。以下是一些常见的列表操作：

  1. 创建列表：

    您可以使用方括号 [] 来创建一个列表，并在其中包含元素。例如：

    my_list = [1, 2, 3, 4, 5]

  2. 访问列表元素：

    您可以使用索引来访问列表中的元素，索引从0开始。例如，my_list[0] 访问第一个元素，my_list[1] 访问第二个元素，以此类推。

  3. 列表切片：

    使用切片操作可以访问列表的一部分。语法为 list[start:end]，其中 start 是起始索引，end 是结束索引（不包括）。例如：

    sub_list = my_list[1:4] # 获取索引1到3的元素，结果为 [2, 3, 4]

  4. 修改列表元素：

    列表是可变的，可以通过索引赋值来修改元素的值。例如：

    my_list[2] = 100 # 将第三个元素修改为100

  5. 添加元素：

    使用 append() 方法可以在列表末尾添加元素。例如：

    my_list.append(6) # 添加元素6到列表末尾

  6. 插入元素：

    使用 insert() 方法可以在指定位置插入元素。例如：

    my_list.insert(2, 7) # 在索引2处插入元素7

  7. 删除元素：

    使用 remove() 方法可以删除指定值的元素，使用 pop() 方法可以删除指定索引的元素，或者使用 del 语句删除指定索引的元素。例如：

    my_list.remove(4) # 删除值为4的元素 
my_list.pop(2) # 删除索引为2的元素 
del my_list[0] # 删除第一个元素

  8. 查找元素：

    使用 index() 方法可以查找元素的索引，使用 in 运算符可以检查元素是否在列表中。例如：

    index = my_list.index(3) # 查找元素3的索引 
is_present = 4 in my_list # 检查元素4是否在列表中

  9. 列表长度：

    使用 len() 函数可以获取列表的长度（元素个数）。例如：

    length = len(my_list) # 获取列表长度

  10. 列表操作：

    列表支持多种操作，如连接两个列表、重复列表、排序、反转等。例如：

    new_list = my_list + [6, 7] # 连接两个列表 
repeated_list = my_list * 2 # 重复列表 
my_list.sort() # 排序列表 
my_list.reverse() # 反转列表

元组操作

元组（Tuple）是Python中的有序不可变数据结构，它类似于列表，但不支持修改元素。以下是一些常见的元组操作：

  1. 创建元组：

    您可以使用圆括号 () 来创建一个元组，并在其中包含元素。例如：

    my_tuple = (1, 2, 3, 4, 5)

    或者，如果元组只包含一个元素，需要在元素后面添加逗号，以区分它和普通的括号：

    single_element_tuple = (42,)

  2. 访问元组元素：

    您可以使用索引来访问元组中的元素，索引仍然从0开始。例如，my_tuple[0] 访问第一个元素，my_tuple[1] 访问第二个元素，以此类推。

  3. 元组切片：

    使用切片操作可以访问元组的一部分，语法为 tuple[start:end]，其中 start 是起始索引，end 是结束索引（不包括）。例如：

    sub_tuple = my_tuple[1:4] # 获取索引1到3的元素，结果为 (2, 3, 4)

  4. 元组拆包：

    您可以将元组中的元素赋值给多个变量，以便分别访问各个元素。这被称为元组拆包。例如：

    a, b, c = my_tuple # 将元组的元素分配给变量a、b和c

  5. 元组合并：

    使用 + 运算符可以将两个元组合并为一个新元组。例如：

    new_tuple = my_tuple + (6, 7) # 合并两个元组

  6. 元组重复：

    使用 * 运算符可以重复元组中的元素多次。例如：

    repeated_tuple = my_tuple * 2 # 重复元组

  7. 查找元组元素：

    使用 index() 方法可以查找元素的索引，使用 in 运算符可以检查元素是否在元组中。例如：

    index = my_tuple.index(3) # 查找元素3的索引 
is_present = 4 in my_tuple # 检查元素4是否在元组中

  8. 元组长度：

    使用 len() 函数可以获取元组的长度（元素个数）。例如：

    length = len(my_tuple) # 获取元组长度

集合操作

在Python中，集合（Set）是一种无序且具有唯一性的数据结构，用于存储不重复的元素。集合提供了多种操作，以便处理和操作集合中的数据。以下是一些常见的集合操作：

  1. 创建集合：

    您可以使用花括号 {} 或 set() 构造函数来创建一个集合。例如：

    my_set = {1, 2, 3, 4, 5}

  2. 添加元素：

    使用 add() 方法可以向集合中添加元素。元素必须是唯一的，如果添加已存在的元素，它将被忽略。例如：

    my_set.add(6) # 添加元素6到集合

  3. 删除元素：

    使用 remove() 方法可以从集合中删除指定元素，如果元素不存在，将引发KeyError异常。使用 discard() 方法可以删除元素，但如果元素不存在，不会引发异常。例如：

    my_set.remove(4) # 删除元素4 
my_set.discard(7) # 删除元素7（如果存在）

  4. 清空集合：

    使用 clear() 方法可以清空集合中的所有元素。例如：

    my_set.clear() # 清空集合

  5. 集合操作：

    集合支持各种操作，如并集、交集、差集等，可以使用相关方法来执行这些操作。例如：

    • 并集：union()
    • 交集：intersection()
    • 差集：difference()
    • 对称差集：symmetric_difference()

    示例：

    set1 = {1, 2, 3} 
set2 = {3, 4, 5} 
union_set = set1.union(set2) # 并集 
intersection_set = set1.intersection(set2) # 交集 
difference_set = set1.difference(set2) # 差集 
symmetric_difference_set = set1.symmetric_difference(set2) # 对称差集

  6. 子集和超集检查：

    使用 issubset() 和 issuperset() 方法可以检查一个集合是否是另一个集合的子集或超集。例如：

    subset_check = set1.issubset(set2) # 检查set1是否是set2的子集 
superset_check = set1.issuperset(set2) # 检查set1是否是set2的超集

  7. 集合长度：

    使用 len() 函数可以获取集合的长度（元素个数）。例如：

    length = len(my_set) # 获取集合长度

  8. 转换为列表：

    使用 list() 函数可以将集合转换为列表。例如：

    my_list = list(my_set) # 将集合转换为列表

字典操作

字典（Dictionary）是Python中的一种数据结构，用于存储键-值对的集合，键是唯一的，用于快速查找值。以下是一些常见的字典操作：

  1. 创建字典：

    您可以使用花括号 {} 来创建一个字典，其中包含键-值对。例如：

    my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

  2. 访问字典值：

    您可以使用键来访问字典中的值。例如，my_dict['name'] 返回键 'name' 对应的值 'Alice'。

  3. 添加或修改键值对：

    使用赋值语句可以添加或修改字典中的键值对。例如：

    my_dict['gender'] = 'Female' # 添加新的键值对 
my_dict['age'] = 31 # 修改年龄的值

  4. 删除键值对：

    使用 del 语句可以删除字典中的键值对。例如：

    del my_dict['city'] # 删除'city'键值对

  5. 检查键是否存在：

    使用 in 运算符可以检查键是否存在于字典中。例如：

    if 'name' in my_dict: print("Name is in the dictionary.")

  6. 获取所有键、所有值和键值对：

    使用 keys() 方法可以获取字典中的所有键，使用 values() 方法可以获取所有值，使用 items() 方法可以获取所有键值对。例如：

    keys = my_dict.keys() # 获取所有键 
values = my_dict.values() # 获取所有值 
items = my_dict.items() # 获取所有键值对

  7. 遍历字典：

    使用 for 循环可以遍历字典中的键，然后使用键来获取相应的值。例如：

    for key in my_dict: value = my_dict[key] print(key, value)

    或者，使用 items() 方法可以遍历键值对：

    for key, value in my_dict.items(): print(key, value)

  8. 复制字典：

    使用 copy() 方法可以复制一个字典，创建一个新的字典。例如：

    new_dict = my_dict.copy() # 复制字典

  9. 清空字典：

    使用 clear() 方法可以清空字典中的所有键值对。例如：

    my_dict.clear() # 清空字典

字符串操作

在Python中，字符串（String）是一种常见的数据类型，用于存储文本数据。Python提供了许多字符串操作方法，以便处理和操作字符串数据。以下是一些常见的字符串操作：

  1. 创建字符串：

    您可以使用单引号 ''、双引号 "" 或三引号 ''' 来创建字符串。例如：

    my_string = "Hello, World!"

  2. 字符串连接：

    使用 + 运算符可以将两个字符串连接在一起。例如：

    string1 = "Hello" string2 = "World" combined_string = string1 + ", " + string2 # 连接两个字符串

  3. 字符串重复：

    使用 * 运算符可以重复一个字符串多次。例如：

    repeated_string = "ABC" * 3 # 重复字符串3次

  4. 字符串长度：

    使用 len() 函数可以获取字符串的长度（字符数）。例如：

    length = len(my_string) # 获取字符串长度

  5. 字符串索引和切片：

    您可以使用索引来访问字符串中的单个字符，索引从0开始。还可以使用切片操作来访问字符串的一部分。例如：

    first_char = my_string[0] # 获取字符串的第一个字符 
sub_string = my_string[7:12] # 获取索引7到11的子字符串

  6. 字符串查找：

    使用 find() 方法可以查找子字符串在主字符串中的位置，或者使用 in 运算符来检查子字符串是否存在。例如：

    index = my_string.find("World") # 查找子字符串的位置 
is_present = "Hello" in my_string # 检查子字符串是否存在

  7. 字符串替换：

    使用 replace() 方法可以替换字符串中的子字符串。例如：

    new_string = my_string.replace("World", "Python") # 替换子字符串

  8. 字符串分割：

    使用 split() 方法可以将字符串拆分成子字符串列表，根据指定的分隔符。例如：

    words = my_string.split(", ") # 使用逗号和空格分割字符串

  9. 字符串格式化：

    使用字符串的 format() 方法或f-strings可以将变量的值插入到字符串中，以创建格式化字符串。例如：

    name = "Alice" 
age = 30 
formatted_string = "My name is {} and I am {} years old.".format(name, age)

    或使用f-strings：

    formatted_string = f"My name is {name} and I am {age} years old."

  10. 字符串大小写转换：

    使用 upper() 方法可以将字符串转为大写，使用 lower() 方法可以将字符串转为小写。例如：

    uppercase_string = my_string.upper() # 转为大写 
lowercase_string = my_string.lower() # 转为小写

大聪明码农徐
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python基础概念一
qq_41623000的博客
12-06 248
算术操作符 a=8/9 //py3里的除法已经变成了真正的除法而不是地板除法。 也可以使用地板除法，使用双斜杠//就行了。对双斜杠而言无论是整型还是浮点型都做地板除法 双星号**表示幂运算。幂运算符比其左侧的一元操作符优先级高，比右侧的一元操作符的优先级低。 -2**8 2**-2 py可以有效地避免悬挂else 获取类型信息type(),或者isinstance(待定，指定)，返回true或flase 断言assert，当断言后面的条件为假的时候，程序自动崩溃并抛出AssertionError异常，可以用
python基础--基本语法
Star_DustF的博客
05-24 492
python基础--基本语法一、运行Python二、python中的基本语法1.变量的定义2.标识符标识符命名规则python中的关键字标识符命名方法3.python的输入和输出格式化输出4.注释单行注释:多行注释:三、运算符1.算术运算符2.逻辑运算符3.比较运算符4.赋值运算符四、基本数据类型1.数据类型的分类2.数据类型之间的转换 一、运行Python cmd +回车 输入:python 输入:print(“hello world”) 回车 退出: exit() python +脚本 二、
Python入门教程+项目实战-11.2节: 元组的操作符
04-25 518
元组的操作符
python实现先进先出算法的完整程序
weixin_35755562的博客
02-19 675
Python实现先进先出算法的完整程序如下：class Queue: def init(self): self.items = [] def isEmpty(self): return self.items == [] def enqueue(self, item): self.items.insert(0,item) de...
Python程序里的注释和#号_python中以#开始的语句为
2401_84561420的博客
04-29 343
当然那是英文的，我们可以用中文写，请恕我装了装X再次说明，我不会再贴各种屏幕截图了。你应该明白上面的内容是输出内容的字面翻译，而python...和最后的之间才是你应该关心的内容。读者可以看看下面的习题弄清楚” #” 符号的作用。而且记住它的名字。( 中文为井号，英文为 octothorpe 或者 poundcharacter)。打开你的 ex2.py 文件，从后往前逐行检查。从最后一行开始，倒着逐个单词单词检查回去。有没有发现什么错误呢？有的话就改正过来 .
详解Python的元组(tuple)的12种操作方法,并附示例代码
昊虹AI笔记
06-22 5753
Python 的元组与列表类似，不同之处在于元组的元素不能修改，也不能增加元素或删除元素，以上操作不能进行的原因大家从其名字也可以看出嘛，“元”的意义有最小单位，不可修改之意。元组使用小括号 ( )，列表使用方括号 [ ]。 关于列表的操作方法，大家可参考我的另一篇博文，链接如下： https://blog.csdn.net/wenhao_ir/article/details/125400072元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可，甚至不要括号也可以哦。 示例代码如下： 运行结果如下：
【Python学习笔记】第十节 Python 元组
yubao0723的专栏
02-02 656
Python学习笔记之 Python 元组
python队列--先进先出和先进后出
tudoujun123的博客
11-08 3175
什么是先进先出： 简单来说就是先进来的就先出去，可以实现多线程中直接使用，可以使用列表来实现线程间的同步 什么是先进后出？ 就像叠衣服一样，最后一件叠好的衣服最先拿出，第一件叠好的衣服，最后取出一样，倒叙顺序取值。 list=[] while True: res=input('输入姓名（q退出）') if res=='q': break list.append(res) print(list) #先进先出取值，按进入顺序排列取值 for i
Python基础语法合集.pdf
06-06
Python是一种高级编程语言，以其简洁明了的语法...以上就是Python基础语法的主要内容，包括基本的输入输出、变量命名、条件判断和数据类型。学习这些基础知识是掌握Python编程的第一步，对于进一步的编程实践至关重要。
python基础语法合集68页.pdf
05-08
Python是一种强大的解释型、面向对象、动态数据类型的高级程序设计语言。它的语法简洁明了，易于学习，且具有丰富的库支持，广泛应用...无论是初学者还是有经验的程序员，熟悉并掌握这些基本概念和用法都是至关重要的。
python 基础语法 pdf版本
02-05
这份"python基础语法 pdf版本"文档，由传智教育出品，旨在帮助初学者从零开始掌握Python的核心概念和基本语法。 首先，Python的语法结构清晰，它使用缩进来表示代码块，这使得代码看起来更加整洁。在Python中，每个...
Python3基础语法详解（含示例）
04-29
本文章关于Python基础语法的说明，内容详尽且全面，为读者提供了一份深入浅出的学习指南。文章从Python的基本构成开始，详细阐述了变量、数据类型、运算符、控制流语句等核心概念，为读者构建了一个扎实的Python语言...
python基础语法.zip
02-09
"Python基础语法.zip"这个压缩包很可能包含了关于Python编程的基本概念、语法结构和常见操作的教学材料。下面将详细讨论Python的基础知识。 1. **变量与数据类型**：Python中的变量不需要预先声明类型，可以直接...
49.Python进阶_队列01_先进先出队列
安小静--
09-16 1912
Python的Quene模块中提供了同步的，线程安全的队列类，包括 - FIFO(先进先出)队列Queue, LIFO(先进后出)队列LifoQueue, 优先级队列PriorityQueue 这些队列都实现了锁原语，能够在多线程中直接使用，可以使用列表来实现线程间同步； 初始化Queue()对象时，如果（q=Queue(),若括号中没有指定最大可接受的消息数量，或者数量为负值，那么代表可接受...
Python｜一文简单看懂 深度&广度 优先算法
python学习者的博客
01-06 1133
一、前言 以后尽量每天更新一篇，也是自己的一个学习打卡！加油！今天给大家分享的是，Python里深度/广度优先算法介绍及实现。 更多Python视频、源码、资料加群683380553免费获取 二、深度、广度优先算法简介 1. 深度优先搜索(DepthFirstSearch) 深度优先搜索的主要特征就是，假设一个顶点有不少相邻顶点，当我们搜索到该顶点，我们对于它的相邻顶点并不是现在就对...
世界上最简单的会计书（先进先出法VS后进先出法）
02-24 3512
上周情况 上周交易情况 本周交易明细 1.从小卖铺以40美分的价格，赊账50个柠檬，共花费20美元 2.50个柠檬+5磅白糖（每磅40美分，共计2美元）制作了60杯的柠檬汁，成本是12美元（你现在总共有100个柠檬，其中50个的成本是10美元，50个的成本是20美元） 3.60杯的柠檬汁全部卖出，其中50杯子是现金支付，另外10杯是赊销，由于是以50美分每杯子卖出的，销售收入是30美元，其中现金是...
linux fifo python,python使用deque实现fifo(先进先出)
weixin_30652105的博客
05-12 317
#2：deque还提供了append和pop方法，在序列的两端都能以相同的速度执行#例子2:使用deque实现fifo(先进先出)，如下:fromcollectionsimportdequeimportprofile,statimportsysqeque=deque()defadd1(data):qeque.append(data)defadd2():qeque.pop()big_...
python算法（基础）----队列（先进先出，FIFO）
狼性书生
05-25 8808
队列被构造为在队尾添加项的有序集 合，并且从队首移除。队列保持 FIFO 排序属性。 队列操作如下。 Queue() 创建一个空的新队列。 它不需要参数，并返回一个空队列。 equeue(item) 将新项添加到队尾。 它需要 item 作为参数，并不返回任何内容。 dequeue() 从队首移除项。它不需要参数并返回 item。 队列被修改 isEmpty() 查看队列是否为空。它不需要...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 829
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大聪明码农徐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值