二、Python基本语法

已于 2023-07-12 14:50:20 修改
阅读量72 收藏
点赞数
分类专栏： Python 文章标签： python 开发语言 学习方法
于 2023-07-06 14:43:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dalishi3/article/details/131480472
版权

二、基本语法

(一)、说明

   语法是任何一种编程语言基本具备的东西，没有语法就没有后边的程序了。
  那么什么是语法呢？ 简单的理解就是编程内容定义与编程规则定义。
举例来说：
  就像我们小时候学拼音，拼音分为 生母、韵母；声母在前韵母在后；音调书写等规则，我们根据这些规则就可以写拼音了。
  又比如我们学语文，要分主语、谓语、宾语、修饰词等等的这些，然后按照主谓宾组成句子。

(二)、内容

1、注释

  注释是用来解释代码的目的和功能，注释的内容不会被程序执行。在Python中，使用#符号来表示单行注释，使用'''或"""来表示多行注释。

# 这里是单行注释， 下边 age是年龄 赋值 10岁
age = 10

'''
这里是多行注释
可以写很多行呢
下边要将age变量的值通过print打印到控制台了
'''
"""
双引号也可以的
"""
print(age)

2、变量

  变量是用于存储和表示数据的名称。在编程中，变量可以被看作是一个容器，用于存储各种类型的数据，如数字、文本、列表、字典等。通过给变量赋值，我们可以将特定的值存储在变量中，并在程序中使用该变量来引用这个值。
  在Python中，变量的创建和赋值是通过使用等号（=）来完成的。例如，以下代码创建了一个名为"age"的变量，并将值18赋给它：(变量定义名称时一般用字母或_开头)

age = 18

在这个例子中，"age"是变量的名称，18是存储在该变量中的值。一旦变量被赋值，我们可以在程序的其他地方使用该变量来获取或修改存储的值。

3、数据类型

  程序运行时，实际上就是将一些我们已知的数据经过逻辑处理变换成我们想要的数据。这些数据有个基本的分类，这就是数据类型：

  • 整数（int）：表示整数值，例如：1、-5、100。

  • 浮点数（float）：表示带有小数点的数值，例如：3.14、-0.5、2.0。

  • 字符串（str）：表示文本数据，用单引号或双引号括起来，例如：“Hello”、‘Python’。

  • 布尔值（bool）：表示真（True）或假（False）的值，用于逻辑判断和条件控制。

  • 列表（list）：表示有序的元素集合，可以包含不同类型的数据，用方括号括起来，例如：[1, 2, 3]、[‘apple’, ‘banana’, ‘orange’]。

  • 元组（tuple）：与列表类似，但是元组是不可变的，用圆括号括起来，例如：(1, 2, 3)、(‘apple’, ‘banana’, ‘orange’)。

  • 字典（dict）：表示键值对的集合，用花括号括起来，例如：{‘name’: ‘John’, ‘age’: 25, ‘city’: ‘New York’}。

  • 集合（set）：表示无序且不重复的元素集合，用花括号或set()函数创建，例如：{1, 2, 3}、set([4, 5, 6])。
    print()是Python的控制台输出函数

# 整数
age = 25
print(age)  # 输出：25

# 浮点数
pi = 3.14
print(pi)  # 输出：3.14

# 字符串
name = "Alice"
print(name)  # 输出："Alice"

# 布尔值
is_student = True
print(is_student)  # 输出：True

# 列表
numbers = [1, 2, 3, 4, 5]
print(numbers)  # 输出：[1, 2, 3, 4, 5]

# 元组
fruits = ('apple', 'banana', 'orange')
print(fruits)  # 输出：('apple', 'banana', 'orange')

# 字典
person = {'name': 'John', 'age': 25, 'city': 'New York'}
print(person)  # 输出：{'name': 'John', 'age': 25, 'city': 'New York'}

# 集合
numbers_set = {1, 2, 3, 4, 5}
print(numbers_set)  # 输出：{1, 2, 3, 4, 5}

4、列表和字典

  列表和字典是Python中常用的数据结构，用于存储和组织数据

  1. 列表（List）：

    • 定义：

      列表是一个有序、可变的数据集合，可以存储多个元素，每个元素可以是不同的数据类型（如整数、浮点数、字符串等）。

    • 特点：

      • 使用方括号[]来表示列表。
      • 列表中的元素可以通过索引访问，索引从0开始。
      • 列表是可变的，可以通过索引来修改、添加或删除元素。

示例：

# 定义一个列表
fruits = ['apple', 'banana', 'orange']

# 访问列表中的元素
print(fruits[0])  # 输出：apple

# 修改列表中的元素
fruits[1] = 'grape'
print(fruits)  # 输出：['apple', 'grape', 'orange']

# 添加元素到列表末尾
fruits.append('pear')
print(fruits)  # 输出：['apple', 'grape', 'orange', 'pear']

# 删除列表中的元素
del fruits[0]
print(fruits)  # 输出：['grape', 'orange', 'pear']

# 循环列表内容
for fruit in fruits:
	print(fruit) 
	""" 输出： 
	'grape'
	'orange'
	'pear'
	"""

  1. 字典（Dictionary）：

    • 定义：
        字典是一种键值对（key-value）的数据集合，每个键（key）对应一个值（value），用于存储和查找数据。

    • 特点：

      • 使用花括号{}来表示字典。
      • 字典中的键必须是唯一的，而值可以是任意类型的数据。
      • 字典是可变的，可以通过键来修改、添加或删除键值对。

示例：

# 定义一个字典
student = {'name': 'Alice', 'age': 18, 'grade': 'A'}

# 访问字典中的值
print(student['name'])  # 输出：Alice

# 修改字典中的值
student['age'] = 19
print(student)  # 输出：{'name': 'Alice', 'age': 19, 'grade': 'A'}

# 添加键值对到字典
student['gender'] = 'female'
print(student)  # 输出：{'name': 'Alice', 'age': 19, 'grade': 'A', 'gender': 'female'}

# 删除字典中的键值对
del student['grade']
print(student)  # 输出：{'name': 'Alice', 'age': 19, 'gender': 'female'}

# 循环获取数据
student = {'name': 'Alice', 'age': 18, 'grade': 'A'}
for key, value in student.items():
    print(key + "->" + str(value))  # 因为其中age是整数，所以加了str转换
""" 输出：
name->Alice
age->18
grade->A
"""

5、输入和输出

  当使用Python编写程序时，我们经常需要与用户进行交互，获取输入并输出结果。这可以通过输入函数input()和输出函数print()来实现。
  下面是一个示例，演示如何使用input()函数获取用户输入，并使用print()函数打印输出结果：

name = input("请输入您的姓名：")
age = input("请输入您的年龄：")
print("您好，" + name + "！您的年龄是：" + age + "岁。")

  在这个例子中，input()函数用于获取用户输入。在调用input()函数时，我们可以在括号中传入一个提示信息，作为用户输入的提示。用户输入的内容将被存储在变量name和age中。
  然后，使用print()函数将输出结果打印到屏幕上。在这个例子中，我们使用了字符串的拼接操作符+来将文本和变量的值连接起来，形成输出的字符串。
  当程序运行时，它会提示用户输入姓名和年龄，并将输入的值打印出来。在这里插入图片描述

6、字符串操作

  针对字符串我们会进行很多处理，一般会进行字符串连接、切片、查找、替换、大小写转换等。

以下是一些常见的字符串操作：

  1. 字符串连接：

    • 使用+运算符可以将两个字符串连接起来
    • 示例：
str1 = "Hello"
str2 = "World"
result = str1 + " " + str2
print(result)  # 输出：Hello World

  1. 字符串切片：

    • 使用索引来获取字符串中的子串，可以通过指定起始索引和结束索引来截取子串。
    • 注意：索引从0开始，结束索引不包含在切片结果中。
    • 示例：
str = "Hello World"
print(str[0:5])  # 输出：Hello
print(str[6:])  # 输出：World
print(str[:5])  # 输出：Hello

  1. 字符串查找：

    • 使用in关键字可以判断一个字符串是否包含另一个子串。
    • 使用find()方法可以查找子串在字符串中的位置，如果找不到则返回-1。
    • 示例：
str = "Hello World"
print("World" in str)  # 输出：True
print(str.find("World"))  # 输出：6

  1. 字符串替换：

    • 使用replace()方法可以将字符串中的指定子串替换为新的子串。
    • 示例：
str = "Hello World"
new_str = str.replace("World", "Python")
print(new_str)  # 输出：Hello Python

  1. 字符串大小写转换：

    • 使用lower()方法可以将字符串转换为小写形式。
    • 使用upper()方法可以将字符串转换为大写形式。
    • 示例：
str = "Hello World"
print(str.lower())  # 输出：hello world
print(str.upper())  # 输出：HELLO WORLD

7、运算符

  运算符是用于执行各种数学或逻辑操作的符号或特殊字符。在Python中，有多种类型的运算符，包括算术运算符、比较运算符、逻辑运算符、赋值运算符、位运算符和成员运算符。

  1. 算术运算符：
    • 加法：+，用于两个数相加。
    • 减法：-，用于从一个数中减去另一个数。
    • 乘法：*，用于两个数相乘。
    • 除法：/，用于将一个数除以另一个数。
    • 除法取整：//, 用于将一个数除以另一个数，结果取整数部分。
    • 取余：%，用于获取除法运算的余数。
    • 幂运算：**，用于计算一个数的指数幂。
      示例：
a = 10
b = 5
print(a + b)  # 输出结果为 15
print(a - b)  # 输出结果为 5
print(a * b)  # 输出结果为 50
print(a / b)  # 输出结果为 2.0
print(a % b)  # 输出结果为 0
print(a ** b)  # 输出结果为 100000

result = 10 / 3
print(result)  # 输出 3.3333333333333335

# 整数相除
result = 10 // 3
print(result)  # 输出 3

# 浮点数相除
result = 10.5 // 3.2
print(result)  # 输出 3.0
  1. 比较运算符：
    • 相等：==，用于检查两个值是否相等。
    • 不等：!=，用于检查两个值是否不相等。
    • 大于：>，用于检查一个值是否大于另一个值。
    • 小于：<，用于检查一个值是否小于另一个值。
    • 大于等于：>=，用于检查一个值是否大于等于另一个值。
    • 小于等于：<=，用于检查一个值是否小于等于另一个值。
      示例：
a = 10
b = 5
print(a == b)  # 输出结果为 False
print(a != b)  # 输出结果为 True
print(a > b)  # 输出结果为 True
print(a < b)  # 输出结果为 False
print(a >= b)  # 输出结果为 True
print(a <= b)  # 输出结果为 False
  1. 逻辑运算符：
    • 与：and，用于检查多个条件是否同时为真。
    • 或：or，用于检查多个条件是否有至少一个为真。
    • 非：not，用于取反一个条件的真假值。
      示例：
a = 10
b = 5
c = 3
print(a > b and b > c)  # 10>5=True and 5>3=True 输出结果为 True
print(a > b or b < c)  # 10>5=True or 5<3=False 输出结果为 True
print(not(a > b))  # not(10>5=True)输出结果为 False
  1. 赋值运算符：
    • 简单赋值：=
    • 加法赋值：+=
    • 减法赋值：-=
    • 乘法赋值：*=
    • 除法赋值：/=
    • 取余赋值：%=
    • 幂运算赋值：**=
      示例：
a = 10
b = 5
a += b  # 等价于 a = a + b
print(a)  # 输出结果为 15
  1. 位运算符：

  位运算是一种对二进制数进行操作的运算方式。它直接对二进制数的位进行操作，而不考虑数值的大小。位运算符包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）和右移（>>）。
  位运算常用于处理二进制数据、位掩码、图像处理等领域。它们可以高效地处理大量数据，并且在一些特定的场景下，位运算可以比其他运算符更快速地完成任务。
  异或操作在编程中有许多应用，例如数据加密、校验和计算、去重操作等。它也可以用于快速判断两个数是否相等、找出数组中出现奇数次的元素等
0 表示 False 1 表示 True

  • 按位与（&）：将两个数的对应位进行与操作，结果为1的位保留，结果为0的位清零。例如：
a = 5  # 二进制表示为 0101
b = 3  # 二进制表示为 0011
# a 的二进制有4位分别是0101
# b 的二进制有4位分别是0011
# 进行与操作时 ： 
# 第1位 0 0 -> 0  即 False and False ->False 
# 第2位 1 0 -> 0  即 True and False ->False 
# 第3位 0 1 -> 0  即 False and True->False 
# 第4位 1 1 -> 1  即 True and True ->True
result = a & b  # 结果为 0001，即 1
  • 按位或（|）：将两个数的对应位进行或操作，结果为1的位保留，结果为0的位置1。例如：
a = 5  # 二进制表示为 0101
b = 3  # 二进制表示为 0011
# a 的二进制有4位分别是0101
# b 的二进制有4位分别是0011
# 进行或操作时 ： 
# 第1位 0 0 -> 0  即 False or False ->False 
# 第2位 1 0 -> 1  即 True or False ->True
# 第3位 0 1 -> 1  即 False or True->True
# 第4位 1 1 -> 1  即 True or True ->True
result = a | b  # 结果为 0111，即 7

  • 按位异或（^）：它对两个二进制数的对应位进行异或运算。异或操作的结果为1的条件是两个操作数的对应位不相同，否则结果为0。

    1.相同数值的异或结果为0，不同数值的异或结果为1。例如：

a = 5  # 二进制表示为 0101
b = 3  # 二进制表示为 0011
# 进行异或操作时 ： 
# 第1位 0 0 -> 0  即 0 not 0 ->False 
# 第2位 1 0 -> 0  即 1 not 0 ->True 
# 第3位 0 1 -> 0  即 0 not 1 ->True 
# 第4位 1 1 -> 1  即 1 not 1 ->False 
result = a ^ b  # 结果为 0110，即 6

    2.异或操作满足交换律和结合律。即 a ^ b = b ^ a 和 (a ^ b) ^ c = a ^ (b ^ c)。例如：

a = 5
b = 3
result1 = a ^ b  # 结果为 0110，即 6
result2 = b ^ a  # 结果为 0110，即 6

c = 2
result3 = (a ^ b) ^ c  # 结果为 0100，即 4
result4 = a ^ (b ^ c)  # 结果为 0100，即 4

在上面的例子中，无论是先对a和b进行异或，还是先对b和a进行异或，得到的结果都是相同的。

    3.异或操作可以用于交换两个数的值。例如：

a = 5
b = 3

a = a ^ b
b = a ^ b
a = a ^ b

print("a =", a)  # 输出 3
print("b =", b)  # 输出 5

在上面的例子中，通过异或操作交换了变量a和b的值。

  • 按位取反（~）：对一个数的每个位进行取反操作，即0变为1，1变为0。例如：
a = 5  # 二进制表示为 0101
# a 的二进制有4位分别是0101
# 进行取反操作时 ： 
# 第1位 0-> 1  即 not False ->True 
# 第2位 1-> 0  即 not True ->False
# 第3位 0-> 1  即 not False ->True
# 第4位 1-> 0  即 not True ->False
result = ~a  # 结果为 1010（补码表示），即 -6
  • 左移（<<）：将一个数的二进制表示向左移动指定的位数。例如：
a = 5  # 二进制表示为 0101
# a 的二进制有4位分别是0101
# 进行左移操作时 ：在右边补0 即 0101 00
result = a << 2  # 结果为 10100，即 20
  • 右移（>>）：将一个数的二进制表示向右移动指定的位数。例如：
a = 5  # 二进制表示为 0101
# a 的二进制有4位分别是0101
# 进行右移移操作时 ：向右移动 即 0101移动两位 变成 01，不够4位前位补0 即 00 01
result = a >> 2  # 结果为 0001，即 1
  1. 成员运算符：
      成员运算符用于判断一个值是否属于某个序列（如字符串、列表、元组等）。Python提供了两个成员运算符：in和not in。
    • in，用于检查一个值是否存在于一个序列中。
    • not in，用于检查一个值是否不存在于一个序列中。
      示例：

    1. 使用in运算符判断字符串中是否包含某个字符：

string = "Hello, World!"
print('H' in string)  # True
print('X' in string)  # False

    2. 使用in运算符判断列表中是否包含某个元素：

list = [1, 2, 3, 4, 5]
print(3 in list)  # True
print(6 in list)  # False

    3. 使用not in运算符判断元组中是否不包含某个值：

tuple = (1, 2, 3, 4, 5)
print(6 not in tuple)  # True
print(2 not in tuple)  # False

8、条件语句

  我们在做一些逻辑处理的时候，往往会需要判断一下条件是否符合要求，这时候要使用条件语句来根据条件执行不同的代码块。常见的条件语句有if语句、if-else语句和if-elif-else语句。

  1. if语句：用于在满足条件时执行一段代码块，如果条件不满足，则不执行。语法如下：
if condition:
    # 在条件满足时执行的代码块

示例：

# 判断一个数是否为正数
num = 10
if num > 0:
    print("这是一个正数")
  1. if-else语句：在满足条件时执行一个代码块，如果条件不满足，则执行另一个代码块。语法如下：
if condition:
    # 在条件满足时执行的代码块
else:
    # 在条件不满足时执行的代码块

示例：

# 判断一个数是否为正数
num = -5
if num > 0:
    print("这是一个正数")
else:
    print("这是一个负数或零")
  1. if-elif-else语句：用于在满足不同条件时执行不同的代码块，可以有多个elif语句，最后可以有一个可选的else语句。语法如下：
if condition1:
    # 在条件1满足时执行的代码块
elif condition2:
    # 在条件2满足时执行的代码块
else:
    # 在条件1和条件2都不满足时执行的代码块

示例：

# 判断一个数的正负性
num = 0
if num > 0:
    print("这是一个正数")
elif num < 0:
    print("这是一个负数")
else:
    print("这是零")

9、循环语句

  我们在反复执行一段逻辑的时候，可以使用循环语句来重复执行这段代码。常见的循环语句有for循环和while循环。

  1. for循环：用于遍历一个可迭代对象（如列表、字符串等），对其中的每个元素执行一段代码。语法如下：
for element in iterable:
    # 在每次迭代时执行的代码块

示例：

# 遍历列表中的元素并打印
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
	print(fruit)
  1. while循环：在满足条件时重复执行一段代码，直到条件不再满足为止。语法如下：
while condition:
	# 在条件满足时执行的代码块

示例：

# 使用wile循环计算 1到 5的和
sum = 0
num = 1
while num <= 5: # 判断当前数字num是不是大于5，大于5就停止下边的代码块计算；否则进行下边代码块计算求和
	sum = num+sum # 总和加上当前的值得出一个新的和 如：num=1 ，则sum = 1 + 0 
	num = num + 1 # 将下一个数字赋值给num，这里是取下一个数 num = 2，然后再去循环比对 num <= 5 ;也就是2<=5 继续循环，以此类推

需要注意:在使用循环时，要确保循环条件最终能够达到不满足的状态，否则可能会导致无限循环。

10、函数

  在编程中，函数是一段可重复使用的代码块，用于实现特定的功能。它可以接受输入参数（可选），执行一系列操作，并返回一个结果（可选）。函数的使用可以提高代码的可读性、可维护性和重用性。
  函数的基本结构如下：

def function_name(parameters):
	# 函数体，包含一系列操作
	# 返回结果(可选)，使用return语句返回结果；若不用返回则不用写
	return
  • def 定义一下内容为函数；
  • function_name 函数名称，也就是这个给这个代码块起个名字，一般以字母、_下划线开头，我们起名时最好能够展示出下边代码块的作用，方便以后自己或别人用的时候一下就能看懂
  • parameters 参数，代码块中处理逻辑的时候可能需要一些外部给出的参数来进行辅助，所以需要传递参数（可选）；多个参数 用,分割。
  • 函数体 是由缩进的代码块组成，也就是我们要做一些业务逻辑操作。
  • return 用于返回结果(可选，不需要返回结果就不写return)，将结果传递给调用函数的位置。

示例：

# 定义函数
def greet(name):
	""" 打招呼 """
	print("Hello, " + name + "!")

# 调用函数
greet("大D")

### ####
##控制台会输出  ： Hello, 大D

# 定义函数 年龄和
def age_sum(age1, age2):
	""" 算一下两个人年龄加起来多大啦"""
	age = age1 + age2
	return age # 将结果返回

# 调用函数
# 张三 10岁
# 李四 13岁
age = age_sum(10, 13)
print("张三和李四的年龄：" + str(age))

### ####
# 上边 输出的时候 "张三和李四的年龄："是字符串 而 age是数字，所以要转换一下数据类型 str 字符串的意思
##控制台会输出  ： 张三和李四的年龄：23

11、匿名函数

  匿名函数，也称为lambda函数，是一种在Python中定义简单函数的快捷方式。与普通函数不同，匿名函数没有函数名，并且可以在定义的地方直接使用。它通常用于需要一个简单的函数，但不想为其定义一个完整的函数的情况。
参考: python中匿名函数 lambda

12、类和对象

  对象是对现实世界中某个实体或概念的抽象表示。
  对象具有状态（属性）和行为（方法）。状态是对象的特征或属性，描述了对象的特定特点。行为是对象可以执行的操作或功能，描述了对象能够做什么。
对象是根据类的定义创建的。类定义了对象的结构和行为，并提供了创建对象的模板。通过创建对象，我们可以访问和操作类中定义的属性和方法。

下面是一个更详细的说明：

  • 对象是类的实例化：对象是根据类创建的，通过调用类的构造函数来实例化对象。一个类可以有多个对象。

  • 对象具有属性：属性是对象的状态，描述了对象的特定特征。属性可以是变量，用于存储对象的数据。每个对象都有自己的属性值，它们可以在对象创建时初始化，也可以在对象的生命周期中进行修改。

  • 对象具有方法：方法是对象的行为，描述了对象可以执行的操作或功能。方法是类中定义的函数，用于操作对象的属性或实现特定的功能。通过调用对象的方法，我们可以执行相应的操作。

  • 对象具有唯一性：每个对象都是唯一的，具有自己的标识。即使两个对象的属性值相同，它们仍然是不同的对象。

  • 对象之间可以相互交互：不同的对象可以相互交互，通过调用对方的方法来实现协作。这种交互可以通过对象之间的消息传递来实现。

总之，对象是类的实例化，是具体的实体，具有状态和行为。通过创建对象，我们可以访问和操作类中定义的属性和方法，实现代码的模块化和可重用性。对象是面向对象编程的核心概念之一，它使得程序的设计和实现更加灵活和可扩展。

上边说了很多，可能都绕迷糊了，举例来说好理解一些：

# 假设 对象是 车子
class Car:
    def __init__(self, brand, model, year):
    	# 车子的属性：品牌、车型、出产年份
        self.brand = brand
        self.model = model
        self.year = year

	# 定义方法 开动车子
    def start_engine(self):
        print(f" {self.brand} {self.model}的引擎被启动了！")
	
	# 定义方法 关闭车子
    def stop_engine(self):
        print(f"{self.brand} {self.model}的引擎被关闭了！")

# 创建对象
car1 = Car("Toyota", "Corolla", 2020)
car2 = Car("Honda", "Civic", 2021)

# 访问对象的属性
print(car1.brand)  # 输出：Toyota
print(car2.model)  # 输出：Civic

# 调用对象的方法
car1.start_engine()  # 输出：Toyota Corolla的引擎被启动了！
car2.stop_engine()  # 输出：Honda Civic的引擎被关闭了！
# 定义对象 购买用户
class User:
    def __init__(self, name):
        # 用户属性 姓名
        self.name = name

    # 定义用户行为(方法) 试驾
    def test_drive(self, car):
        print(f"{self.name}将")
        car.start_engine()
        print(f"{self.name}开了10分钟")
        car.stop_engine()

# 创建对象
user1 = User("王大帅")

# 访问对象的属性
print(user1.name)  # 输出：王大帅

# 调用对象的方法
user1.test_drive(car1) 
"""输出
王大帅将
Toyota Corolla的引擎被启动了！
王大帅开了10分钟
Toyota Corolla的引擎被关闭了！
"""

13、模块和包

  当我们在编写代码时，可以将相关的功能代码组织成模块，这样可以提高代码的可读性和可维护性。模块是一个包含了函数、类、变量等定义的文件，它可以被其他程序引入和使用。

  • Python中的模块（也就是xxx.py文件）是以.py为扩展名的文件，可以通过import语句来引入模块。例如，我们可以创建一个名为my_module.py的文件，并在其中定义一些函数和变量：
# my_module.py

def greet(name):
    print(f"Hello, {name}!")

def square(n):
    return n ** 2

message = "Welcome to my module!"

然后，在另一个文件中可以使用import语句来引入这个模块，并使用其中的函数和变量：

import my_module

my_module.greet("Alice")  # 输出：Hello, Alice!
print(my_module.square(5))  # 输出：25
print(my_module.message)  # 输出：Welcome to my module!

除了使用import语句引入整个模块，还可以使用from语句从模块中导入特定的函数、类或变量。例如：

from my_module import greet, square

greet("Bob")  # 输出：Hello, Bob!
print(square(3))  # 输出：9

此外，还可以使用as关键字给模块、函数或变量起别名，以简化代码。例如：

import my_module as mm

mm.greet("Charlie")  # 输出：Hello, Charlie!
print(mm.square(4))  # 输出：16

包（也就是文件夹）是一种组织模块的方式，它是一个包含了多个模块的目录。包的目录中必须包含一个名为__init__.py的文件，它可以是一个空文件，也可以包含一些初始化代码。包可以有多层次的结构，每一级目录都是一个包。
例如，我们可以创建一个名为my_package的包，其中包含了两个模块module1.py和module2.py：

my_package/
    __init__.py
    module1.py
    module2.py

在module1.py中定义了一个函数hello()：

# module1.py

def hello():
    print("Hello from module1!")

在module2.py中定义了一个函数bye()：

# module2.py

def bye():
    print("Goodbye from module2!")

然后，在另一个文件中可以使用import语句来引入包和其中的模块，并使用其中的函数：

import my_package.module1
import my_package.module2

my_package.module1.hello()  # 输出：Hello from module1!
my_package.module2.bye()  # 输出：Goodbye from module2!

也可以使用from语句从包中导入特定的模块或函数：

from my_package import module1, module2

module1.hello()  # 输出：Hello from module1!
module2.bye()  # 输出：Goodbye from module2!

总结：包就是一个文件夹，文件夹中要存在__init__.py文件，文件可以为空内容，也可以初始一些内容；模块就是一个.py文件，文件内写入的是我们要实现功能的属性、方法等；
使用方法：在其他模块引用
from 包 import 模块 --整个模块导入
from 包.模块 import 函数、属性等–按照需要导入
import 模块 – 在同一个包下 导入整个模块
from 模块 import 函数、属性等 – 在同一个包下，按需导入
from aaaa import bbb as cc – 导入之后给bbb起了个小名叫cc，使用的时候 使用cc调用bbb的属性、方法等

14、异常处理

  异常处理是一种用于处理程序运行时出现的错误或异常情况的机制。在Python中，可以使用try-except语句来捕获和处理异常。try块中包含可能引发异常的代码，而except块中包含处理异常的代码。
以下是异常处理的基本语法结构：

try:
	# 正常逻辑的代码块(可能会引发异常，也就是不符合程序的突发情况)
except ExceptionType1:
	# 处理 ExceptionType1 异常的代码
except ExceptionType2:
    # 处理 ExceptionType2 异常的代码
...
else:
    # 如果没有引发异常，执行的代码
finally:
    # 无论是否引发异常，都会执行的代码

在try块中，我们编写可能引发异常的代码。如果try块中的代码引发了某种类型的异常，那么对应的except块将会执行。如果没有引发异常，那么else块中的代码将会执行。无论是否引发异常，finally块中的代码都会执行。

下面是一个示例，演示如何使用异常处理来处理除零错误：

try:
    num1 = 10
    num2 = 0
    result = num1 / num2
    print(result)
except ZeroDivisionError:
    print("除零错误发生！")

在上面的代码中，我们尝试将一个数除以0。由于除零是一个错误的操作，会引发ZeroDivisionError异常。当异常发生时，程序将跳转到except块中，并打印出相应的错误信息。

异常处理使我们能够优雅地处理程序中的错误情况，避免程序崩溃，并提供适当的错误提示或处理方式。在实际开发中，我们可以根据具体情况选择不同的异常类型，并编写相应的处理代码。

15、文件操作

  文件操作是指在计算机中对文件进行读取、写入、修改和删除等操作。Python提供了丰富的内置函数和模块，使文件操作变得非常简单和灵活。
下面是一些常见的文件操作函数和方法：

  1. 打开文件：使用内置函数open()来打开一个文件，并返回一个文件对象。可以指定文件路径、打开模式和编码方式等参数。
file = open("example.txt", "r")
  1. 打开文件：使用内置函数open()来打开一个文件，并返回一个文件对象。可以指定文件路径、打开模式和编码方式等参数。
content = file.read()  # 读取整个文件内容
line = file.readline()  # 读取一行内容
  1. 打开文件：使用内置函数open()来打开一个文件，并返回一个文件对象。可以指定文件路径、打开模式和编码方式等参数。
file.write("Hello, World!")  # 写入内容到文件
  1. 关闭文件：使用文件对象的close()方法来关闭文件，以释放资源。…
file.close()  # 关闭文件

完整示例：

# 打开文件
file = open("example.txt", "w")

# 写入内容到文件
file.write("Hello, World!\n")
file.write("This is an example file.")

# 关闭文件
file.close()

# 打开文件并读取内容
file = open("example.txt", "r")
content = file.read()
print(content)

# 关闭文件
file.close()

在上面的示例中，我们首先打开一个名为"example.txt"的文件，并使用写入模式（“w”）打开。然后，我们使用write()方法向文件中写入两行文本内容。接下来，我们关闭文件，并再次打开它以读取内容。最后，我们使用read()方法读取整个文件的内容，并打印出来。最后，我们再次关闭文件。

输出结果为：

Hello, World!
This is an example file.

除了上述基本操作，Python还提供了其他一些常用的文件操作函数和模块，例如：

  • os模块：提供了一些与文件和目录相关的函数，如文件重命名、删除文件、创建目录等。
import os

# 获取当前工作目录
current_dir = os.getcwd()
print("当前工作目录：", current_dir)

# 创建目录
new_dir = "new_directory"
os.mkdir(new_dir)
print("目录已创建：", new_dir)

# 重命名文件
old_name = "old_file.txt"
new_name = "new_file.txt"
os.rename(old_name, new_name)
print("文件已重命名：", new_name)

# 删除文件
file_to_delete = "file_to_delete.txt"
os.remove(file_to_delete)
print("文件已删除：", file_to_delete)

# 删除目录
dir_to_delete = "directory_to_delete"
os.rmdir(dir_to_delete)
print("目录已删除：", dir_to_delete)

这里是部分功能，要了解更多去看os文档吧 https://docs.python.org/3/library/os.html

  • shutil模块：提供了一些高级的文件操作函数，如复制文件、移动文件、归档文件等。
import shutil

# 复制文件
src_file = "source_file.txt"
dst_file = "destination_file.txt"
shutil.copy(src_file, dst_file)
print("文件已复制：", dst_file)

# 移动文件
src_file = "source_file.txt"
dst_folder = "destination_folder"
shutil.move(src_file, dst_folder)
print("文件已移动到目录：", dst_folder)

# 复制目录
src_folder = "source_folder"
dst_folder = "destination_folder"
shutil.copytree(src_folder, dst_folder)
print("目录已复制：", dst_folder)

# 删除目录（包括目录下的所有文件和子目录）
dir_to_delete = "directory_to_delete"
shutil.rmtree(dir_to_delete)
print("目录已删除：", dir_to_delete)

# 创建归档文件（压缩文件）
folder_to_archive = "folder_to_archive"
archive_name = "archive.zip"
shutil.make_archive(archive_name, 'zip', folder_to_archive)
print("归档文件已创建：", archive_name)

这里是部分功能，要了解更多去看shutil文档吧 https://docs.python.org/3/library/shutil.html

  • csv模块：用于读写CSV文件，可以方便地处理逗号分隔的数据。
import csv

# 读取CSV文件
with open('data.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

# 写入CSV文件
data = [
    ['Name', 'Age', 'Country'],
    ['John', 25, 'USA'],
    ['Alice', 30, 'Canada'],
    ['Bob', 35, 'UK']
]

with open('output.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(data)

在上面的示例中，首先使用open()函数打开一个CSV文件，并传入参数’r’表示读取模式。然后，使用csv.reader()函数创建一个reader对象，它可以用于逐行读取CSV文件的内容。通过遍历reader对象，可以逐行获取CSV文件中的数据。

接下来，使用open()函数打开一个新的CSV文件，并传入参数’w’表示写入模式。使用csv.writer()函数创建一个writer对象，它可以用于将数据写入CSV文件。通过调用writer.writerows()函数，可以将数据写入CSV文件中。

请注意，在写入CSV文件时，我们使用了newline=''参数，这是为了避免在Windows系统中出现额外的空行。
更多的使用方法参考csv文档https://docs.python.org/3/library/csv.html

  • json模块：用于读写JSON文件，可以方便地处理JSON格式的数据。
import json

# 读取JSON文件
with open('data.json', 'r') as file:
    data = json.load(file)
    print(data)

# 写入JSON文件
data = {
    'name': 'John',
    'age': 25,
    'country': 'USA'
}

with open('output.json', 'w') as file:
    json.dump(data, file)

在上面的示例中，首先使用open()函数打开一个JSON文件，并传入参数’r’表示读取模式。然后，使用json.load()函数将文件内容加载为JSON对象。通过打印data变量，可以查看JSON数据的内容。

接下来，使用open()函数打开一个新的JSON文件，并传入参数’w’表示写入模式。使用json.dump()函数将数据写入JSON文件。通过传入要写入的数据和文件对象，可以将数据以JSON格式写入文件。

更多的使用方法参考json文档https://docs.python.org/3/library/json.html

16、生成器

  生成器是一种特殊的函数，它可以在迭代过程中动态生成值，而不是一次性生成所有的值。这样可以节省内存和计算资源，特别适用于处理大型数据集合或无限序列。

生成器函数使用yield关键字来定义，而不是return关键字。当生成器函数被调用时，它会返回一个生成器对象，该对象可以用于迭代获取生成的值。每次调用生成器的next()函数或使用for循环迭代时，生成器函数会从上次停止的位置继续执行，并在遇到yield语句时生成一个值。

下面是一个简单的示例，演示了如何使用生成器生成斐波那契数列：

def fibonacci_generator():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 创建生成器对象
fib = fibonacci_generator()

# 通过迭代获取斐波那契数列的前10个值
for i in range(10):
    print(next(fib))

输出结果为：

0
1
1
2
3
5
8
13
21
34

在上面的示例中，fibonacci_generator()是一个生成器函数，它使用无限循环来生成斐波那契数列。每次调用yield a语句时，生成器会生成当前的斐波那契数，并在下一次迭代时从yield语句处继续执行。

通过调用next(fib)函数或使用for循环迭代生成器对象fib，我们可以获取斐波那契数列的前10个值。由于生成器是惰性生成值的，它不会一次性生成所有的值，因此可以处理很大的数列而不会占用太多的内存。

人生重启
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
python基本语法练习实例
09-21
下面小编就为大家带来一篇python基本语法练习实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
python基本语法
LilGaage的博客
10-21 4373
一、概述 由guido开发，是一种面向对象的更符合人类逻辑思维的编程思想。python2和python3向下兼容，但两个互不兼容，python3个别版本不支持win7。 优点：简单易学，容易入门；是一种胶水语言，能够和其他语言配合做开发；可移植性、可扩展性；免费开源；拥有丰富的第三方库。 缺点：不能加密；中文资料不多；运行速度相对于c\java较慢 解释器：不需要经过编译，直接通过操作系统解释执行，运行的就是源代码本身，没有编译的过程，...
Python基本语法
tongyiman的博客
04-27 4947
一：基本语法元素 1、缩进 在java、c/c++等语言中，用“{ }”代表代码块。 Python使用缩进（空格）来表示代码块，连续的多条具有相同缩进量的语句为一个代码块。例如：if 、for、 while、 def 、 class等语句都会使用到代码块。通常，语句末尾的冒号代表代码块的开始，示例如下： if x>0: y=1 else: y=-1 （注意：同一个代码块中的语句，其缩进量应相同，否则会出现 indentationError (缩进
python基本语法结构
艾
04-19 1363
python基本语法结构目录1.0 变量2.0 数据类型3.0 类型转换4.0 字符串结语 目录 1.0 变量 在 Python 中，当你给它赋值时就会创建变量：Python 没有用于声明变量的命令。变量在第一次为其赋值时创建。（和matlab一样） 2.0 数据类型 List列表是一个有序且可变的集合。允许重复成员。 turple元组是一个有序且不可更改的集合。允许重复成员。 Set集合是一个无序且无索引的集合。没有重复的成员。 dict字典是一个有序 * 且可变的集合。没有重复的成员。从Python
Python的基本语法
m0_69919595的博客
05-15 1394
目录 1. print函数 2.变量 3. 常量 4. 标识符 5. 关键字（保留字） 6. input函数 7. 基本数据类型--数字类型 8. 算术运算符 9.赋值运算符 10.比较运算符（关系型运算符） 11.逻辑运算符 12.成员运算符 13.运算符优先级关系 练习：判断一年是闰年还是平年。 1. print函数 功能：在屏幕上输出要输出的内容 语法： print(“输出内容”) 如果分别输出多个不同的内容时，可以用逗号隔开 示例： 2.变..
Python基础-基本语法
Gwais的博客
04-27 1万+
什么是编程语言 是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算 机发送指令，让计算机完成对应的工作。 简单来说，编程语言就是人类和计算机进行交流的语言 一、python的简介 1.1：python发展的背景 Python的作者，Guido von Rossum（吉多·范·罗苏姆，中国Python程序员都叫他 龟叔），荷兰人。Python 本身也是由诸多其他语言发展而来的，Python目前有两个版本，Python2.x和Python3.x 1
python基本语法有哪些？
q762459510的博客
10-12 2417
学Python中，自我感觉学的还不错的亚子~想做点什么来练练手，然后我疯狂的找各种小游戏的教程源码什么的，于是我就疯狂的找呀找呀，就找到了一大堆，哈哈哈毕竟我是从小就有一个游戏梦，现在就弥补一下自己小时候没有玩过瘾的游戏补上叭~提示：爱学习哦，不要沉迷游戏，平时打发一下无聊时间最好啦拿走源码的还请留言说一下好吗？‘’‘配置文件’‘’import os。
Python语言基本语法元素
why9264的博客
03-08 2893
Python语言基本语法元素 考纲考点 程序的基本语法元素：程序的格式框架、缩进、注释、变量、命名、保留字、数据类型、赋值语句、引用 程序的格式框架 缩进 Python语言采用严格的“缩进”来表明程序的格式框架。缩进指每行代码 开始前的空白区域,用来耘示代码之间的包含和层欠关系。 1个缩进 = 4个空格 缩进是 Python语言中表明程序框架的唯一手段 当表达分支、循环暾数类等程序含义时,在讦、 while、for、def、 class等保留字所在完整语句后通过英文冒号(:)结尾并在之后进行缩进,表明后续代
Python基础语法
热门推荐
个人学习笔记库，一篇一篇记录成长的足迹
03-19 2万+
简介 Python 是一个高层次的结合了解释性、交互性和面向对象的脚本语言。解释型语言： 这意味着开发过程中没有了编译这个环节。作为解释型语言，意味着开发过程中没有了编译这个环节，对代码逐行解析。 Python还具有可嵌入性，如Python无法运行的代码可以使用C或C++完成程序，然后从的Python程序中调用。也提供了数据库接口和GUI编程。 Python作为解释性语言，内核时Python解析器，任何安装了解析器的系统都可以运行Python文件。
python的基本语法
change_0922的博客
10-14 2963
一、if 1、if 如果 如果的意思，如果程序符合某种条件，那么就可以做什么事情 就是做判断，判断有几个结果？？ True False 得到True或False的运算 a、比较运算 b、成员运算 in /not in c、逻辑运算 and、or、not 语法：if 条件表达式： 2、if...else... 如果...否则... 3、if...elif...elif...else... 如果...否则如果...否则如果...否则......
【Python】语法基本结构
m0_61151031的博客
07-18 1976
if在英语中有如果，假设的意思。放到Python中，if保留了原来表示判断的意思，其可以作为一个分支的入口条件。其中与它常一起用的还有else，当if不满足时就会进入else语句执行。其中if语句的语法结构是if后面跟一个判断条件，在条件末尾加上一个冒号，然后在下一行前空四个空格的距离开始编写if语句的内容。if判断条件内容1...else内容2..循环结构一般由三个要素组成，循环条件、循环内容、循环条件处理。从0开始将会给我们带来很大的方便。死循环图1图2。......
Python基本语法经典教程
09-21
主要介绍了Python基本语法,较为详细的分析了Python基本语法所涉及的流程控制语句,表达式,函数,对象,类型,数学运算等概念与使用技巧,需要的朋友可以参考下
python基本语法和常用词汇
10-26
python作为一种编程语言对英语有一定的基础要求。本资源内涵python中常用的各种英文单词，帮助大家更好的学习。并包含python的基本语法，帮助大家快速学习和记忆，并且在编程中，如果遗忘也可快速查询
第五节课《LMDeploy 量化部署 LLM 实践》
fanre的专栏
05-06 583
PDF链接：https://pan.baidu.com/s/1JFtvBWgEGFWJq8pHafvIUg?pwd=6666提取码：6666。
【 书生·浦语大模型实战营】作业（六）：Lagent & AgentLego 智能体应用搭建
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
05-03 1258
本篇笔记内容主要为 【书生·浦语大模型实战营】作业（六）：Lagent & AgentLego 智能体应用搭建智能体的作业 ，主要对智能体应用理论部分及具体搭建流程详细介绍，并分别进行实战应用及可视化展示，欢迎大家交流学习！
链表刷题集
yajunjiao的专栏
04-30 971
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Python 自动化脚本系列：介绍
最新发布
代码说，代码让世界更美好。
05-08 541
Python 自动化脚本系列：介绍
Kubernetes基础(二十九)-资源预留
sre救赎之路
05-05 892
如果还设置了对应的 --system-reserved-cgroup 和 --kube-reserved-cgroup参数，Pod能实际使用的资源上限不会改变（即kubepods.limit_in_bytes不变），但系统进程与kube进程也会受到资源上限的限制。比如某个节点的内存的allocatable为10Gi，有三个Pod（requests.memory=3Gi）已经调度到该节点上，那么第4个Pod就无法调度到该节点上，即使该Node上的空闲内存大于3Gi。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

人生重启

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

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

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

打赏作者

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

抵扣说明：

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

余额充值