器→工具, 编程语言

Python学习之基础知识

钱魏Way · · 39 次浏览

基本语法

注释和文档字符串

在Python编程中,注释和文档字符串是非常重要的工具,用于提高代码的可读性和可维护性。它们可以帮助你更好地解释代码的功能和逻辑,方便他人或自己在将来阅读和理解代码。

注释

注释是用于解释代码的文本,不会被Python解释器执行。注释可以分为单行注释和多行注释。

单行注释

单行注释使用井号(#)开头,后面的文本直到行尾都是注释内容。

示例:

# 这是一个单行注释
x = 10  # 变量x被赋值为10
print(x)  # 输出变量x的值

多行注释

Python没有专门的多行注释语法,但你可以使用连续的单行注释或者使用多行字符串(虽然它们通常用于文档字符串)。

方式1:使用连续的单行注释:

# 这是一个多行注释
# 第一行
# 第二行
# 第三行

方式2:使用多行字符串: 虽然多行字符串不会被解释器执行,但它们并不是正式的注释方式。为了多行注释,你可以使用三个引号(单引号或双引号)包围的字符串。

"""
这是一个多行注释
第一行
第二行
第三行
"""

需要注意的是,多行字符串通常用于文档字符串,而不是注释。因此,读者应该明白这两者的使用场景。

文档字符串(Docstrings)

文档字符串是一种特殊的字符串,用于为模块、类、方法和函数添加说明文档。文档字符串通常使用三个双引号(”””)或三个单引号(”’)包围。

文档字符串的使用

文档字符串通常放在模块、类、方法或函数的开头,用于描述其功能和用途。

模块文档字符串:

"""
这个模块用于演示Python的文档字符串。
"""

函数文档字符串:

def add(a, b):
    """
    这个函数用于计算两个数的和。

    参数:
    a -- 第一个数
    b -- 第二个数

    返回值:
    两个数的和
    """
    return a + b

类文档字符串:

class MyClass:
    """
    这个类用于演示类的文档字符串。
    """

    def __init__(self, value):
        """
        初始化方法。

        参数:
        value -- 设置为实例的初始值
        """
        self.value = value

    def get_value(self):
        """
        获取实例的值。

        返回值:
        实例的值
        """
        return self.value

访问文档字符串

文档字符串可以通过对象的__doc__属性来访问。

示例:

def add(a, b):
    """
    这个函数用于计算两个数的和。
    """
    return a + b

print(add.__doc__)

输出:

这个函数用于计算两个数的和。

文档字符串的标准格式

为了提高文档的可读性和一致性,建议遵循一些标准的格式。最常见的格式是Google风格和NumPy/SciPy风格。

Google风格:

def add(a, b):
    """
    计算两个数的和。

    Args:
        a (int): 第一个数
        b (int): 第二个数

    Returns:
        int: 两个数的和
    """
    return a + b

NumPy/SciPy风格:

def add(a, b):
    """
    计算两个数的和。

    Parameters
    ----------
    a : int
        第一个数
    b : int
        第二个数

    Returns
    -------
    int
        两个数的和
    """
    return a + b

变量和数据类型(字符串、整数、浮点数、布尔值)

在Python中,变量和数据类型是构建程序的基础。了解变量如何定义以及各种数据类型的特性,可以帮助你更有效地进行编程。以下是对Python变量和四种基本数据类型(字符串、整数、浮点数、布尔值)的详细介绍。

变量

变量是存储数据的命名位置。它们可以存储各种类型的数据,并且在程序的执行过程中可以改变其值。

变量的命名规则

  • 变量名必须以字母(a-z, A-Z)或下划线(_)开头。
  • 变量名的其他字符可以是字母、数字(0-9)或下划线。
  • 变量名对大小写敏感(例如,myVar和 myvar 是不同的变量)。
  • 变量名不能是Python的关键字(例如,if、for、while等)。

变量的定义和赋值

在Python中,变量不需要显式声明。赋值操作会自动创建变量,并分配内存来存储相应的数据值。

示例:

# 定义变量并赋值
name = "Alice"
age = 25
height = 5.7
is_student = True

# 打印变量的值
print(name)      # 输出: Alice
print(age)       # 输出: 25
print(height)    # 输出: 5.7
print(is_student) # 输出: True

数据类型

Python支持多种数据类型,其中基本的数据类型包括字符串、整数、浮点数和布尔值。

字符串(str)

字符串是由字符组成的序列,用于表示文本数据。字符串可以使用单引号(’)、双引号(”)或三引号(”’ 或 “””)定义。

示例:

# 定义字符串
str1 = "Hello, World!"
str2 = 'Python is awesome'
str3 = """This is a 
multiline string"""

# 打印字符串
print(str1)  # 输出: Hello, World!
print(str2)  # 输出: Python is awesome
print(str3)  # 输出: This is a \n multiline string

字符串具有许多内置方法,用于操作和处理字符串数据。

示例:

# 字符串拼接
str1 = "Hello"
str2 = "World"
result = str1 + ", " + str2 + "!"
print(result)  # 输出: Hello, World!

# 字符串长度
length = len(result)
print(length)  # 输出: 13

# 转换为大写
uppercase = result.upper()
print(uppercase)  # 输出: HELLO, WORLD!

# 查找子字符串
position = result.find("World")
print(position)  # 输出: 7

整数(int)

整数是没有小数部分的数值。Python的整数类型没有大小限制,可以表示任意大小的整数。

示例:

# 定义整数
a = 10
b = -5
c = 12345678901234567890

# 打印整数
print(a)  # 输出: 10
print(b)  # 输出: -5
print(c)  # 输出: 12345678901234567890

整数支持各种算术运算,如加法、减法、乘法和除法。

示例:

# 算术运算
sum_result = a + b
diff_result = a - b
prod_result = a * b
div_result = a / b

print(sum_result)  # 输出: 5
print(diff_result) # 输出: 15
print(prod_result) # 输出: -50
print(div_result)  # 输出: -2.0

浮点数(float)

浮点数是具有小数部分的数值。浮点数在Python中用于表示实数。

示例:

# 定义浮点数
x = 3.14
y = -2.0
z = 1.23e4  # 科学计数法表示 1.23 * 10^4

# 打印浮点数
print(x)  # 输出: 3.14
print(y)  # 输出: -2.0
print(z)  # 输出: 12300.0

浮点数同样支持各种算术运算。

示例:

# 算术运算
sum_result = x + y
diff_result = x - y
prod_result = x * y
div_result = x / y

print(sum_result)  # 输出: 1.1400000000000001
print(diff_result) # 输出: 5.14
print(prod_result) # 输出: -6.28
print(div_result)  # 输出: -1.57

布尔值(bool)

布尔值只有两个值:True 和 False。布尔值常用于条件判断。

示例:

# 定义布尔值
is_python_fun = True
is_snowing = False

# 打印布尔值
print(is_python_fun)  # 输出: True
print(is_snowing)     # 输出: False

布尔值通常通过比较运算和逻辑运算得到。

示例:

# 比较运算
a = 10
b = 5
print(a > b)   # 输出: True
print(a == b)  # 输出: False

# 逻辑运算
x = True
y = False
print(x and y)  # 输出: False
print(x or y)   # 输出: True
print(not x)    # 输出: False

基本输入输出(print和input)

在Python编程中,基本的输入和输出操作是必不可少的。Python 提供了内置的函数 print() 用于输出信息,input() 用于从用户获取输入。以下是对这两个函数的详细介绍。

输出函数 print()

print() 函数用于将内容输出到控制台。它是一个非常灵活和强大的输出函数,支持多种格式化和参数。

基本用法

示例:

print("Hello, World!")
print(42)
print(3.14)

输出:

Hello, World!
42
3.14

输出多个值

print() 函数可以同时输出多个值,使用逗号分隔,默认情况下会在值之间插入一个空格。

示例:

name = "Alice"
age = 30
print("Name:", name, "Age:", age)

输出:

Name: Alice Age: 30

使用 sep 参数

sep 参数用于指定输出值之间的分隔符。

示例:

print("apple", "banana", "cherry", sep=", ")

输出:

apple, banana, cherry

使用 end 参数

end 参数用于指定输出结束时的字符,默认是换行符。

示例:

print("Hello", end=" ")
print("World")

输出:

Hello World

使用 format 方法

format 方法用于字符串格式化,可以使输出更灵活。

示例:

name = "Alice"
age = 30
print("Name: {}, Age: {}".format(name, age))

输出:

Name: Alice, Age: 30

使用 f-string (格式化字符串字面量)

Python 3.6 及以上版本支持使用 f-string 进行字符串格式化,它更加简洁。

示例:

name = "Alice"
age = 30
print(f"Name: {name}, Age: {age}")

输出:

Name: Alice, Age: 30

输入函数 input()

input() 函数用于从用户获取输入。它读取一行输入并返回一个字符串。

基本用法

示例:

name = input("Enter your name: ")
print("Hello, " + name + "!")

如果用户输入 Alice,输出将是:

Enter your name: Alice
Hello, Alice!

获取数值输入

由于 input() 函数返回字符串,如果需要获取数值输入,需要进行类型转换。

示例:

age = input("Enter your age: ")
age = int(age)  # 将字符串转换为整数
print(f"Next year, you will be {age + 1} years old.")

如果用户输入 30,输出将是:

Enter your age: 30
Next year, you will be 31 years old.

防止类型转换错误

为了防止用户输入非数值导致的类型转换错误,可以使用 try-except 来捕获异常。

示例:

try:
    age = int(input("Enter your age: "))
    print(f"Next year, you will be {age + 1} years old.")
except ValueError:
    print("Please enter a valid number.")

如果用户输入 thirty,输出将是:

Enter your age: thirty
Please enter a valid number.

综合示例

以下是一个综合示例,结合了 print() 和 input() 函数,演示了如何进行基本的用户交互。

示例:

def main():
    # 获取用户输入
    name = input("Enter your name: ")
    age = input("Enter your age: ")
    
    try:
        age = int(age)  # 将字符串转换为整数
        print(f"Hello, {name}! Next year, you will be {age + 1} years old.")
    except ValueError:
        print("Please enter a valid number for age.")

    # 其他输出示例
    print("Output multiple values:", name, age, sep=" | ")
    print("This is the end of the program.", end="\n\n")

if __name__ == "__main__":
    main()

输出:

Enter your name: Alice
Enter your age: 30
Hello, Alice! Next year, you will be 31 years old.
Output multiple values: Alice | 30
This is the end of the program.

运算符

Python的运算符涵盖了各种操作,包括数学运算、比较运算、逻辑运算、位运算等。

算术运算符

算术运算符用于进行数学计算。

运算符 描述 示例
+ 加法 2 + 3
减法 5 – 2
* 乘法 3 * 4
/ 除法 10 / 2
% 取模(余数) 7 % 3
** 幂(次方) 2 ** 3
// 整除 7 // 3

示例:

a = 10
b = 3

print(a + b)  # 13
print(a - b)  # 7
print(a * b)  # 30
print(a / b)  # 3.3333333333333335
print(a % b)  # 1
print(a ** b) # 1000
print(a // b) # 3

比较运算符

比较运算符用于比较两个值,并返回布尔值(True或False)。

运算符 描述 示例
== 等于 a == b
!= 不等于 a != b
> 大于 a > b
< 小于 a < b
>= 大于等于 a >= b
<= 小于等于 a <= b

示例:

a = 10
b = 3

print(a == b)  # False
print(a != b)  # True
print(a > b)   # True
print(a < b)   # False
print(a >= b)  # True
print(a <= b)  # False

逻辑运算符

逻辑运算符用于布尔逻辑计算,常用于控制语句中。

运算符 描述 示例
and 逻辑与 a and b
or 逻辑或 a or b
not 逻辑非 not a

示例:

a = True
b = False

print(a and b)  # False
print(a or b)   # True
print(not a)    # False

赋值运算符

赋值运算符用于将右侧的值赋给左侧的变量。

运算符 描述 示例
= 赋值 a = 5
+= 加法赋值 a += 3
-= 减法赋值 a -= 2
*= 乘法赋值 a *= 4
/= 除法赋值 a /= 2
%= 取模赋值 a %= 3
**= 幂赋值 a **= 2
//= 整除赋值 a //= 2

示例:

a = 5

a += 3  # 等价于 a = a + 3
print(a)  # 8

a -= 2  # 等价于 a = a - 2
print(a)  # 6

a *= 4  # 等价于 a = a * 4
print(a)  # 24

a /= 2  # 等价于 a = a / 2
print(a)  # 12.0

a %= 3  # 等价于 a = a % 3
print(a)  # 0.0

a **= 2  # 等价于 a = a ** 2
print(a)  # 0.0

a //= 2  # 等价于 a = a // 2
print(a)  # 0.0

位运算符

位运算符用于按位操作整数。

运算符 描述 示例
& 按位与 a & b
` ` 按位或
^ 按位异或 a ^ b
~ 按位取反 ~a
<< 左移 a << 1
>> 右移 a >> 1

示例:

a = 60    # 60 = 0011 1100
b = 13    # 13 = 0000 1101

print(a & b)  # 12 = 0000 1100
print(a | b)  # 61 = 0011 1101
print(a ^ b)  # 49 = 0011 0001
print(~a)     # -61 = 1100 0011 (补码表示)
print(a << 2) # 240 = 1111 0000
print(a >> 2) # 15 = 0000 1111

身份运算符

身份运算符用于比较两个对象的内存地址,判断是否为同一个对象。

运算符 描述 示例
is 是同一个对象 a is b
is not 不是同一个对象 a is not b

示例:

a = [1, 2, 3]
b = a
c = a.copy()

print(a is b)      # True
print(a is c)      # False
print(a is not c)  # True

成员运算符

成员运算符用于测试序列(如列表、元组、字符串等)中包含某个值。

运算符 描述 示例
in 在指定序列中找到值 a in b
not in 在指定序列中找不到值 a not in b

示例:

a = [1, 2, 3]
print(2 in a)      # True
print(4 in a)      # False
print(4 not in a)  # True

条件表达式(海象运算符)

Python 3.8中引入了赋值表达式(海象运算符),用于在表达式中进行赋值操作。

运算符 描述 示例
:= 赋值表达式 res := len(a)

示例:

a = [1, 2, 3, 4]

if (n := len(a)) > 3:
    print(f"List is too long ({n} elements, expected <= 3)")  # List is too long (4 elements, expected <= 3)

控制结构

Python的控制结构是控制程序执行流程的基本构建块,主要包括条件语句、循环语句和循环控制语句。掌握这些控制结构可以帮助你编写逻辑清晰、结构合理的代码。

条件语句

条件语句用于根据特定条件执行代码块。Python的条件语句主要包括if、elif和else。

基本语法:

if condition1:
    # 当condition1为真时执行
elif condition2:
    # 当condition1为假且condition2为真时执行
else:
    # 当condition1和condition2都为假时执行

示例:

x = 10

if x > 15:
    print("x is greater than 15")
elif x == 10:
    print("x is equal to 10")
else:
    print("x is less than 10")

循环语句

循环语句用于重复执行代码块,直到满足特定条件。Python的循环语句包括for循环和while循环。

for循环

for循环用于遍历序列(如列表、元组、字符串)或其他可迭代对象。

基本语法:

for variable in iterable:
    # 循环体

示例:

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 使用range函数生成序列
for i in range(5):
    print(i)

while循环

while循环在条件为真时重复执行代码块。

基本语法:

while condition:
    # 循环体

示例:

# 使用while循环
count = 0
while count < 5:
    print(count)
    count += 1

循环控制语句

循环控制语句用于控制循环的执行流程,包括break、continue和pass。

break语句

break语句用于提前终止循环。

示例:

for i in range(10):
    if i == 5:
        break
    print(i)
# 输出: 0 1 2 3 4

continue语句

continue语句用于跳过当前循环的剩余部分,并立即开始下一次循环。

示例:

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)
# 输出: 1 3 5 7 9

pass语句

pass语句用于在语法上需要一个语句但不需要执行任何操作的场合。

示例:

for i in range(5):
    if i == 3:
        pass  # 什么也不做
    print(i)
# 输出: 0 1 2 3 4

循环中的else子句

Python循环中的else子句在循环正常结束(没有遇到break语句)时执行。

基本语法:

for variable in iterable:
    # 循环体
else:
    # 循环正常结束时执行

while condition:
    # 循环体
else:
    # 循环正常结束时执行

示例:

for i in range(5):
    print(i)
else:
    print("Loop ended normally without break")

# 示例2
for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print("This will not be printed because loop was terminated by break")

嵌套循环

嵌套循环是指在一个循环内部包含另一个循环。可以使用多个嵌套循环来处理多维数据结构。

示例:

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

输出:

i=0, j=0
i=0, j=1
i=1, j=0
i=1, j=1
i=2, j=0
i=2, j=1

条件表达式(Ternary Operator)

条件表达式,也称为三元运算符,用于在一行中简洁地编写条件判断操作。

基本语法:

value_if_true if condition else value_if_false

示例:

x = 10
result = "Greater than 5" if x > 5 else "Less than or equal to 5"
print(result)  # 输出: Greater than 5

匿名函数中的条件表达式

在匿名函数(lambda函数)中,也可以使用条件表达式。

示例:

is_even = lambda x: "Even" if x % 2 == 0 else "Odd"
print(is_even(10))  # 输出: Even
print(is_even(3))   # 输出: Odd

数据结构

Python 提供了多种内置的数据结构,用于组织和存储数据。这些数据结构包括列表(List)、元组(Tuple)、集合(Set)和字典(Dictionary)。每种数据结构都有其独特的特性和用途。以下是对这些数据结构的详细介绍。

列表(List)

列表是一个有序、可变的数据结构,可以包含任意类型的元素。列表使用方括号 [] 定义,元素之间用逗号分隔。

创建和访问列表

示例:

# 创建列表
my_list = [1, 2, 3, "apple", "banana"]

# 访问列表元素
print(my_list[0])  # 输出: 1
print(my_list[3])  # 输出: apple

# 修改列表元素
my_list[1] = "orange"
print(my_list)  # 输出: [1, 'orange', 3, 'apple', 'banana']

列表操作

示例:

# 添加元素
my_list.append("cherry")
print(my_list)  # 输出: [1, 'orange', 3, 'apple', 'banana', 'cherry']

# 插入元素
my_list.insert(1, "grape")
print(my_list)  # 输出: [1, 'grape', 'orange', 3, 'apple', 'banana', 'cherry']

# 删除元素
my_list.remove("apple")
print(my_list)  # 输出: [1, 'grape', 'orange', 3, 'banana', 'cherry']

# 列表长度
print(len(my_list))  # 输出: 5

# 列表拼接
another_list = [7, 8, 9]
combined_list = my_list + another_list
print(combined_list)  # 输出: [1, 'grape', 'orange', 3, 'banana', 'cherry', 7, 8, 9]

元组(Tuple)

元组是一个有序、不可变的数据结构,也可以包含任意类型的元素。元组使用小括号 () 定义,元素之间用逗号分隔。

创建和访问元组

示例:

# 创建元组
my_tuple = (1, 2, 3, "apple", "banana")

# 访问元组元素
print(my_tuple[0])  # 输出: 1
print(my_tuple[3])  # 输出: apple

# 尝试修改元组元素(会导致错误)
# my_tuple[1] = "orange"  # 将引发 TypeError: 'tuple' object does not support item assignment

元组操作

示例:

# 元组长度
print(len(my_tuple))  # 输出: 5

# 元组拼接
another_tuple = (7, 8, 9)
combined_tuple = my_tuple + another_tuple
print(combined_tuple)  # 输出: (1, 2, 3, 'apple', 'banana', 7, 8, 9)

集合(Set)

集合是一个无序、不重复的数据结构。集合使用花括号 {} 定义,元素之间用逗号分隔。

创建和访问集合

示例:

# 创建集合
my_set = {1, 2, 3, "apple", "banana"}

# 添加元素
my_set.add("cherry")
print(my_set)  # 输出: {1, 2, 3, 'apple', 'banana', 'cherry'}

# 删除元素
my_set.remove("apple")
print(my_set)  # 输出: {1, 2, 3, 'banana', 'cherry'}

集合操作

示例:

# 集合长度
print(len(my_set))  # 输出: 5

# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 并集
union_set = set1.union(set2)
print(union_set)  # 输出: {1, 2, 3, 4, 5}

# 交集
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出: {3}

# 差集
difference_set = set1.difference(set2)
print(difference_set)  # 输出: {1, 2}

字典(Dictionary)

字典是一个无序、可变的数据结构,用于存储键值对(key-value)。键和值之间用冒号 : 分隔,键值对之间用逗号分隔。字典使用花括号 {} 定义。

创建和访问字典

示例:

# 创建字典
my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 访问字典元素
print(my_dict["name"])  # 输出: Alice
print(my_dict["age"])   # 输出: 25

# 修改字典元素
my_dict["age"] = 26
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}

字典操作

示例:

# 添加键值对
my_dict["email"] = "alice@example.com"
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'}

# 删除键值对
del my_dict["city"]
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'email': 'alice@example.com'}

# 字典长度
print(len(my_dict))  # 输出: 3

# 获取所有键
keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['name', 'age', 'email'])

# 获取所有值
values = my_dict.values()
print(values)  # 输出: dict_values(['Alice', 26, 'alice@example.com'])

# 获取所有键值对
items = my_dict.items()
print(items)  # 输出: dict_items([('name', 'Alice'), ('age', 26), ('email', 'alice@example.com')])

列表推导式

列表推导式是一种简洁的创建列表的方式,使用一种类似于数学集合表达式的语法。

示例:

# 创建一个包含1到10的平方的列表
squares = [x**2 for x in range(1, 11)]
print(squares)  # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 过滤列表中的元素
evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)  # 输出: [2, 4, 6, 8, 10]

字典推导式

字典推导式是一种简洁的创建字典的方式,类似于列表推导式。

示例:

# 创建一个字典,其中键是1到5,值是它们的平方
squares_dict = {x: x**2 for x in range(1, 6)}
print(squares_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 过滤字典中的键值对
filtered_dict = {k: v for k, v in squares_dict.items() if v > 10}
print(filtered_dict)  # 输出: {4: 16, 5: 25}

参考链接:

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注