python学习笔记(一)—基础知识

python学习笔记

一、变量声明

在Python中，你只需要为变量指定一个名称，并为其赋值，变量的类型将根据所赋的值自动确定。这种动态类型的特性使得变量的定义变得简洁而灵活。

请记住，尽管在Python中变量的类型是自动推断的，但它们仍然具有类型，并且变量的类型在运行时是可变的。这意味着你可以将一个变量赋予不同类型的值，而无需显式地更改变量的类型声明。

• Python的动态类型使得变量声明更加简洁灵活。
• 还有其他常用变量类型，如字节串和空值类型，可根据需要进一步学习和探索。

赋值操作
变量赋值使用等号（=）进行，将一个值赋给变量

x = 5

二、Python常见数据类型及操作示例

在Python中，有许多常见的数据类型，每种类型都有其特定的用途和操作。下面是一些常见的数据类型及其相关操作的示例：

1. 布尔类型（Bool）

• 布尔类型用于表示逻辑值，包括两个取值：True和False。
• 布尔类型的变量可以通过直接赋值True或False来声明。
• 布尔类型的变量可用于条件判断和逻辑运算。

# 布尔类型声明方式
bool1 = True
bool2 = False

# 布尔类型的逻辑运算
print(bool1 and bool2)  # 逻辑与运算
print(bool1 or bool2)   # 逻辑或运算
print(not bool1)        # 逻辑非运算

2. 字符串类型（String）

• 字符串类型用于表示文本数据，由字符序列组成。
• 字符串可以使用单引号、双引号或三引号来声明。
• 字符串提供了许多内置方法，用于处理和操作文本数据。

# String 类型声明方式
str1 = 'Hello'
str2 = "World"

# 字符串的拼接
result = str1 + ' ' + str2
print(result)  # 输出：Hello World

# 字符串的长度
print(len(str1))  # 输出：5

# 字符串的索引和切片
print(str1[0])     # 输出：H
print(str1[1:3])   # 输出：el
print(str1[-1])    # 输出：o

# 字符串的常用方法
print(str1.upper())      # 将字符串转为大写
print(str2.lower())      # 将字符串转为小写
print(str1.replace('H', 'J'))  # 将字符串中的字符替换
print(str2.split('o'))   # 使用指定字符分割字符串

3. 整数类型（Integer）

• 整数类型用于表示整数值，包括正整数、负整数和零。
• 整数可以直接赋值给变量来声明。
• 整数支持常见的数学运算，如加法、减法、乘法和除法。

# int 声明方式
int1 = 10
int2 = 5

# 数学运算
print(int1 + int2)   # 加法
print(int1 - int2)   # 减法
print(int1 * int2)   # 乘法
print(int1 / int2)   # 除法，得到浮点数
print(int1 // int2)  # 除法，得到整数部分
print(int1 % int2)   # 求余数
print(int1 ** int2)  # 指数运算

4. 浮点数类型（Float）

• 浮点数类型用于表示带有小数部分的数值。
• 浮点数可以直接赋值给变量来声明。
• 浮点数支持数学运算，并提供一些常用的数学函数。

# float 声明方式
float1 = 3.14
float2 = 2.718

# 数学运算
print(float1 + float2)   # 加法
print(float1 - float2)   # 减法
print(float1 * float2)   # 乘法
print(float1 / float2)   # 除法
print(float1 ** float2)  # 指数运算

# 常用数学函数
print(abs(-3.14))    # 绝对值
print(round(3.1415))  # 四舍五入
print(max(float1, float2))  # 最大值
print(min(float1, float2))  # 最小值

5. 列表类型（List）

• 列表类型用于存储多个值，可以包含不同类型的元素。
• 列表使用方括号 [] 来声明，元素之间使用逗号分隔。
• 列表提供了丰富的方法来操作和访问列表中的元素。

# list 声明方式
list1 = [1, 2, 3, 4, 5]
list2 = ['a', 'b', 'c']

# 访问列表元素
print(list1[0])    # 输出：1
print(list2[-1])   # 输出：c

# 修改列表元素
list1[0] = 10
print(list1)   # 输出：[10, 2, 3, 4, 5]

# 添加元素
list2.append('d')
print(list2)   # 输出：['a', 'b', 'c', 'd']

# 列表切片
print(list1[1:4])    # 输出：[2, 3, 4]
print(list2[:2])     # 输出：['a', 'b']

# 列表排序
list3 = [3, 1, 5, 2, 4]
list3.sort()
print(list3)   # 输出：[1, 2, 3, 4, 5]

# 列表长度
print(len(list1))   # 输出：5

# 列表的常用方法
print(list1.count(3))   # 统计元素出现的次数
print(list2.index('b'))  # 返回元素的索引位置

6. 字典类型（Dictionary）

• 字典类型用于存储键-值对的数据，类似于映射或哈希表。
• 字典使用花括号 {} 来声明，键和值之间使用冒号 : 分隔。
• 字典提供了一系列方法来操作和访问字典中的键和值。

# 字典声明方式
dict1 = {'name': 'Alice', 'age': 25, 'country': 'USA'}

# 访问字典中的值
print(dict1['name'])    # 输出：Alice
print(dict1.get('age'))  # 输出：25

# 修改字典中的值
dict1['age'] = 26
print(dict1)   # 输出：{'name': 'Alice', 'age': 26, 'country': 'USA'}

# 添加键值对
dict1['gender'] = 'female'
print(dict1)   # 输出：{'name': 'Alice', 'age': 26, 'country': 'USA', 'gender': 'female'}

# 删除键值对
del dict1['country']
print(dict1)   # 输出：{'name': 'Alice', 'age': 26, 'gender': 'female'}

# 字典长度
print(len(dict1))   # 输出：3

# 字典的常用方法
print(dict1.keys())    # 返回所有键
print(dict1.values())  # 返回所有值
print(dict1.items())   # 返回所有键值对

7. 集合类型（Set）

• 集合类型用于存储一组唯一的元素，不包含重复值。
• 集合使用花括号 {} 或 set() 函数来声明。
• 集合提供了一系列方法来执行集合操作，如并集、交集和差集。

# set 声明方式
set1 = {1, 2, 3}
set2 = set([3, 4, 5])

# 添加元素
set1.add(4)
print(set1)   # 输出：{1, 2, 3, 4}

# 移除元素
set1.remove(2)
print(set1)   # 输出：{1, 3, 4}

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

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

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

# 判断元素是否在集合中
print(2 in set1)   # 输出：False
print(3 in set2)   # 输出：True

# 集合的长度
print(len(set1))   # 输出：3

# 集合的常用方法
set3 = {3, 4, 5, 6}
print(set1.issubset(set3))   # 判断是否是子集
print(set3.issuperset(set1))  # 判断是否是超集

8. 元组类型（Tuple）

• 元组类型用于存储不可变的序列，一旦创建就不能修改。
• 元组使用圆括号 () 或 tuple() 函数来声明。
• 元组可以包含不同类型的元素，通过索引访问。

# tuple 元组声明方式
tuple1 = ('apple', 'banana', 'cherry')
tuple2 = tuple([1, 2, 3])

# 访问元组中的元素
print(tuple1[0])   # 输出：apple
print(tuple2[-1])  # 输出：3

# 元组的切片
print(tuple1[1:3])    # 输出：('banana', 'cherry')
print(tuple2[:2])     # 输出：(1, 2)

 元组长度
print(len(tuple1))   # 输出：3

# 元组的常用方法
print(tuple1.count('banana'))  # 统计元素出现的次数
print(tuple2.index(2))         # 返回元素的索引位置

以上是Python中常见的数据类型及其操作示例。这些数据类型在实际编程中非常常用，你可以根据需要选择合适的数据类型来存储和处理数据。

三、运算符和表达式

在Python中，运算符和表达式用于执行各种计算和操作。通过运算符和表达式，你可以进行数值运算、逻辑判断和数据处理。

1. 算术运算符

Python提供了一系列算术运算符，用于执行基本的数值计算：

• 加法：+
• 减法：-
• 乘法：*
• 除法：/
• 取模（取余数）：%
• 整除（取商的整数部分）：//
• 幂运算：**

# 算术运算符示例
x = 10
y = 3

sum = x + y      # 13
difference = x - y   # 7
product = x * y      # 30
quotient = x / y     # 3.3333333333333335
remainder = x % y    # 1
integer_division = x // y   # 3
power = x ** y      # 1000

2. 比较运算符

比较运算符用于比较两个值之间的关系，并返回布尔值（True或False）：

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

# 比较运算符示例
x = 5
y = 10

result1 = x == y    # False
result2 = x != y    # True
result3 = x > y     # False
result4 = x < y     # True
result5 = x >= y    # False
result6 = x <= y    # True

3. 逻辑运算符

逻辑运算符用于对布尔值进行逻辑操作，并返回布尔值结果：

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

# 逻辑运算符示例
x = True
y = False

result1 = x and y   # False
result2 = x or y    # True
result3 = not x     # False

4. 赋值运算符

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

• 简单赋值：=
• 加法赋值：+=
• 减法赋值：-=
• 乘法赋值：*=
• 除法赋值：/=
• 取模赋值：%=
• 整除赋值：//=
• 幂赋值：**=

# 赋值运算符示例
x = 10
x += 5    # x = x + 5，结果为15
x -= 3    # x = x - 3，结果为12
x *= 2    # x = x * 2，结果为24
x /= 4    # x = x / 4，结果为6.0
x %= 3    # x = x % 3，结果为0.0
x //= 2   # x = x // 2，结果为0.0
x **= 3   # x = x ** 3，结果为0.0

5. 其他算符

除了上述常见的运算符，Python还提供了其他类型的运算符，如位运算符、成员运算符和身份运算符。这些运算符在特定情况下使用，用于执行更复杂的操作。

• 位运算符：用于对二进制位进行操作，包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）等。
• 成员运算符：用于检查一个值是否属于某个序列，包括in和not in。
• 身份运算符：用于比较对象的身份（内存地址），包括is和is not。

# 其他运算符示例
x = 10
y = 20
numbers = [1, 2, 3]

result1 = x & y         # 0 
result2 = x | y         # 30 
result3 = x ^ y         # 30
result4 = ~x            # -11
result5 = 2 in numbers  # True
result6 = 4 not in numbers   # True
result7 = x is y        # False
result8 = x is not y    # True

运算符和表达式是Python中常用的工具，它们能够进行各种计算和逻辑操作。掌握了这些基本知识后，你将能够进行数据处理、条件判断和循环控制等任务。

四、条件语句

条件语句用于根据条件的真假执行不同的代码块。在Python中，条件语句使用if、elif（可选）和else（可选）关键字来构建。

1. if语句

if语句用于执行一个代码块，当条件为真时执行。if语句的语法如下：

if condition:
    # 执行代码块

• condition是一个布尔表达式，当其值为True时，执行代码块中的语句。
• 代码块必须使用缩进（通常是四个空格），表示属于if语句的范围。

# if语句示例
x = 10

if x > 5:
    print("x大于5")

2. if-else语句

if-else语句用于在条件为真和条件为假时分别执行不同的代码块。if-else语句的语法如下：

if condition:
    # 执行代码块1
else:
    # 执行代码块2

• 当条件为真时，执行代码块1；否则，执行代码块2。

# if-else语句示例
x = 10

if x > 5:
    print("x大于5")
else:
    print("x不大于5")

3. if-elif-else语句

if-elif-else语句用于在多个条件中选择执行不同的代码块。if-elif-else语句的语法如下：

if condition1:
    # 执行代码块1
elif condition2:
    # 执行代码块2
else:
    # 执行代码块3

• 当条件1为真时，执行代码块1；否则，检查条件2。
• 当条件2为真时，执行代码块2；否则，执行代码块3。

# if-elif-else语句示例
x = 10

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

条件语句是Python中控制程序流程的重要工具。通过合理使用条件语句，可以根据不同的条件执行不同的代码逻辑，实现灵活的程序控制。

五、循环语句

循环语句用于重复执行一段代码块，直到满足特定条件为止。Python提供了两种主要的循环语句：**for循环和while**循环。

1. for循环

**for循环用于遍历可迭代对象（如列表、元组、字符串等），并对其中的每个元素执行相应的操作。for**循环的语法如下：

for element in iterable:
    # 执行代码块

• **element**是每次迭代过程中取得的当前元素。
• **iterable**是一个可迭代对象，包含要遍历的元素。
• 代码块是要在每次迭代中执行的操作。

# for循环示例
fruits = ['apple', 'banana', 'cherry']

for fruit in fruits:
    print(fruit)

上述代码会依次输出列表**fruits**中的每个水果。

2. while循环

**while循环用于在满足条件的情况下重复执行代码块，直到条件变为假为止。while**循环的语法如下：

while condition:
    # 执行代码块

• **condition是一个布尔表达式，当其值为True时，继续执行代码块；当其值为False**时，跳出循环。
• 代码块是要重复执行的操作。

# while循环示例
count = 0

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

上述代码会从0开始逐步递增，每次循环打印当前的**count值，直到count**大于等于5时跳出循环。

3. 循环控制语句

在循环过程中，我们可以使用循环控制语句来控制循环的流程。Python提供了以下三种常用的循环控制语句：

• **break**语句：用于完全终止循环，并跳出循环体。
• **continue**语句：用于跳过当前循环迭代，进入下一次循环迭代。
• **pass**语句：用作占位符，表示一个空的代码块。

# 循环控制语句示例
for i in range(10):
    if i == 3:
        break
    if i == 1:
        continue
    if i == 5:
        pass
    print(i)

上述代码会打印出0、2、4，并在i等于3时终止循环。

循环语句是Python中实现重复执行的强大工具。通过合理使用循环语句，可以有效地处理重复性任务，提高代码的复用性和效率。

六、函数

函数是一段可重复使用的代码块，用于完成特定的任务。通过将代码组织成函数，我们可以实现模块化的编程，提高代码的复用性和可维护性。

在Python中，函数的定义使用关键字def，并遵循以下的语法结构：

def function_name(parameters):
    # 执行代码块
    return value

• function_name是函数的名称，用于在调用函数时进行引用。
• parameters是函数的参数，可以根据需要指定零个或多个参数。
• 代码块是函数要执行的操作。
• return语句用于指定函数的返回值。

下面是一个简单的函数示例：

def greet(name):
    message = f"Hello, {name}!"
    return message

# 调用函数
result = greet("Alice")
print(result)

在上述代码中，greet()函数接受一个参数name，然后构造一个问候消息并返回。最后，在调用函数时，我们将名字传递给函数，并打印函数的返回值。

1.参数

函数可以接受不同类型和数量的参数，以满足不同的需求。在Python中，参数可以分为以下几种类型：

• 位置参数：按照参数的位置进行传递，调用时必须按照定义的顺序提供参数。
• 默认参数：为参数提供默认值，如果在调用时未指定该参数的值，将使用默认值。
• 关键字参数：通过指定参数名来传递参数，可以任意顺序地指定参数。
• 可变参数：接受可变数量的参数，可以是位置参数或关键字参数。

下面是一些参数的示例：

# 位置参数示例
def add_numbers(a, b):
    return a + b

result = add_numbers(3, 5)
print(result)

# 默认参数示例
def greet(name, message="Hello"):
    return f"{message}, {name}!"

result1 = greet("Alice")
result2 = greet("Bob", "Hi")
print(result1)
print(result2)

# 关键字参数示例
def personal_info(name, age, country):
    return f"{name} is {age} years old and lives in {country}."

result = personal_info(name="Alice", country="USA", age=25)
print(result)

# 可变参数示例
def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

result = sum_numbers(1, 2, 3, 4, 5)
print(result)

2.返回值

函数可以使用return语句返回一个值或一组值。如果函数没有明确的返回语句，将默认返回None。

def multiply(a, b):
    return a * b

result = multiply(3, 4)
print(result)

在上述代码中，**multiply()函数接受两个参数并返回它们的乘积。我们将函数的返回值存储在变量result**中，并打印出来。

3.作用域

在函数中声明的变量拥有函数级的作用域，也称为局部作用域。这意味着这些变量只能在函数内部访问。

def calculate():
    result = 10 + 20
    return result

print(calculate())  # 输出结果为 30
print(result)  # 会抛出 NameError 异常

在上述代码中，变量**result是在函数calculate()内部声明的，因此只能在函数内部访问。在函数外部尝试访问该变量将引发NameError**异常。

4.递归函数

递归函数是一种调用自身的函数。它可以用于解决需要重复执行相同任务的问题。在递归函数中，必须包含一个或多个停止条件，以避免无限循环。

下面是一个计算阶乘的递归函数示例：

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

result = factorial(5)
print(result)

在上述代码中，factorial()函数使用递归调用来计算一个数的阶乘。当传递参数为0时，函数返回1，否则返回n * factorial(n-1)。

5.Lambda函数

Lambda函数是一种匿名函数，可以用于简化代码和处理简单的函数逻辑。Lambda函数由关键字**lambda**引导，并可以接受任意数量的参数。

add_numbers = lambda a, b: a + b
result = add_numbers(3, 4)
print(result)

在上述代码中，我们创建了一个Lambda函数**add_numbers**，它接受两个参数并返回它们的和。然后，我们将参数传递给Lambda函数并打印结果。

以上是关于函数的简要介绍，函数是Python编程中非常重要的概念，能够提高代码的复用性和可读性。熟练掌握函数的使用方法将对你的编程技能和项目开发非常有益。