《Python编程从入门到实战》学习笔记

最新推荐文章于 2024-06-24 18:14:21 发布

鱼鱼大仙111

最新推荐文章于 2024-06-24 18:14:21 发布

阅读量579

点赞数 20

文章标签： python 学习笔记

本文链接：https://blog.csdn.net/q17817125151/article/details/139398113

版权

三周的学习收获

format函数及其他占位符的使用:

`format()` 函数是Python中用于格式化字符串的内置方法。它允许将变量插入到字符串中，并指定它们的显示格式。

示例:

name = "Alice"
age = 30

# 使用 format() 格式化字符串
message = "My name is {} and I am {} years old.".format(name, age)

print(message)

在这个例子中，`{ }` 是占位符，`format()` 方法中的参数按顺序填充到字符串中的占位符位置。输出将是："My name is Alice and I am 30 years old." 这样的格式。

其他能将参数填充的字符串中的方法：

1，f-strings：经了解后个人更喜欢的方法，很方便。

它允许在字符串前加上 f 或 F 前缀，并在字符串中使用 {} 表达式来插入变量。

示例：

name = "Alice"
age = 30
print (f'My name is {name} and I am {age} years old.')

2，% 操作符：这是一种传统的字符串格式化方法，使用 `%` 操作符和格式化说明符（例如 `%s`、`%d`、`%f`）来将变量插入到字符串中。

%s:对应字符串，%d:对应整数，%f:对应浮点数

示例：

age = 30
message = "I am %d years old." % age
print(message)  # 输出：I am 30 years old.

学习python的常用数据类型:

整型（int）：

用于表示整数，例如 x = 10。整型数据是不可变的，可以进行加减乘除等基本算术运算。

浮点型（float）：

用于表示带有小数点的数字，例如 y = 3.14。浮点型数据在计算机中以近似值存储，因此可能存在精度问题。

字符串型（str）：

用于表示文本数据，例如 name = "Alice"。字符串可以包含字母、数字、特殊字符等，可以使用单引号、双引号或三重引号来定义。

布尔型（bool）：

用于表示逻辑值 True 或 False，例如 is_valid = True。布尔类型通常用于控制流程和条件判断。

复数型（complex）：

用于表示复数，由实部和虚部组成，例如 z = 3 + 4j。在 Python 中，虚部用 j 表示。

if语句：

if 语句是控制流程的基本构建块之一，用于根据条件执行代码块。

基本语法：

if 语句的基本结构如下：

if condition:
    # 在条件成立时执行的代码块

条件表达式：

condition 是一个逻辑表达式，如果条件为真（True），则执行缩进的代码块。例如：

x = 10
if x > 5:
    print("x is greater than 5")

缩进：

在Python中，代码块的缩进非常重要，用于表示代码的层次结构。通常使用4个空格作为缩进。

多条件判断：

可以使用 elif 和 else 来处理多个条件的情况。示例：

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

random 模块：

生成随机数：

使用 random.random() 可以生成 0 到 1 之间的随机浮点数

import random

rand_num = random.random()
print(rand_num)

生成指定范围内的随机整数：

使用 random.randint(a, b) 可以生成 a 和 b 之间（包括 a 和 b）的随机整数。

import random

rand_int = random.randint(1, 100)
print(rand_int)

打乱序列：

使用 random.shuffle(seq) 可以对列表进行就地打乱，重新排列列表中元素的顺序。

import random

my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
print(my_list)

随机选择：

使用 random.choice(seq) 可以从序列中随机选择一个元素

import random

my_list = [1, 2, 3, 4, 5]
random_choice = random.choice(my_list)
print(random_choice)

math模块：

提供了许多数学函数和常量，用于执行各种数学运算

常用数学函数：

math 模块包含许多常见的数学函数，如三角函数、指数函数、对数函数等。

import math

# 计算正弦值
sin_val = math.sin(math.pi/2)
print(sin_val)

# 计算指数值
exp_val = math.exp(2)
print(exp_val)

# 计算对数值
log_val = math.log(10)
print(log_val)

常用数学常量：

math 模块还提供了一些常用的数学常量，如圆周率 π 和自然对数的底数 e

import math

# 圆周率
pi_value = math.pi
print(pi_value)

# 自然对数的底数
e_value = math.e
print(e_value)

数学运算:

math 模块中还包含一些数学运算函数，如取整操作、绝对值、平方根等。

import math

# 向下取整
floor_val = math.floor(3.7)
print(floor_val)

# 绝对值
abs_val = math.fabs(-10)
print(abs_val)

# 平方根
sqrt_val = math.sqrt(25)
print(sqrt_val)

range函数：

基本语法：

range() 函数的基本语法如下：

range(stop)
range(start, stop[, step])

生成范围内的整数序列：

range 函数可以生成从指定起始值（默认为0）到指定结束值之前的整数序列。

# 生成范围为 [0, 5) 的整数序列
for i in range(5):
    print(i)

指定起始值和步长：

通过指定起始值和步长，可以生成具有特定间隔的整数序列。

# 生成范围为 [1, 10) 的偶数序列
for i in range(2, 10, 2):
    print(i)

转换成列表：

使用 list() 函数可以将 range 生成的整数序列转换为列表。

num_list = list(range(1, 6))
print(num_list)  # 输出：[1, 2, 3, 4, 5]

for-in语句：

通过 for 循环和 in 关键字，可以遍历序列中的每个元素并执行相应的操作

基本语法：

`for-in` 循环的基本语法如下：

for item in sequence:
    # 在每次迭代中处理 item

遍历列表：

使用 for-in 循环可以轻松遍历列表中的元素。

fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

遍历字典：

在字典中，可以通过 for-in 遍历键或值，或者同时遍历键和值

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

# 遍历键
for key in person:
    print(key)

# 遍历值
for value in person.values():
    print(value)

# 遍历键值对
for key, value in person.items():
    print(key, value)

遍历范围：

结合 range 函数，可以在 for-in 循环中创建指定范围的迭代。

for i in range(5):
    print(i)

while语句：

用于根据条件重复执行代码块，直到条件不再满足为止。while 循环在条件为真时重复执行，直到条件变为假或循环被显式中断

基本语法：while 循环的基本语法如下：

while condition:
    # 在条件为真时执行的代码块

条件判断：

在每次循环迭代开始前，都会检查循环条件。只要条件为真，就会执行循环体中的代码块。

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

无限循环：

如果循环条件永远为真，循环将成为无限循环。可以使用 break 语句来退出无限循环

while True:
    response = input("Enter 'exit' to quit: ")
    if response == 'exit':
        break

continue，break的使用：

使用 `continue`：

continue 用于跳过当前循环中的剩余代码，直接进入下一次迭代。

通常在需要跳过某些特定情况下的迭代时使用。

# 示例：使用 continue 跳过奇数并打印偶数
for i in range(1, 11):
    if i % 2 != 0:
        continue  # 跳过奇数
    print(i)

使用 `break`：

break 用于完全终止循环，在满足某个条件时提前退出循环。

常用于查找特定元素、避免无限循环等场景。

# 示例：使用 break 在找到目标数字后退出循环
target = 7
found = False

for i in range(1, 11):
    if i == target:
        found = True
        break  # 找到目标数字后退出循环
    print(i)

if found:
    print("Target number found!")
else:
    print("Target number not found.")

学习字符串的基本使用：

创建字符串：

使用单引号 '、双引号 " 或三重引号 ''' 或 """ 来创建字符串

my_string = "Hello, World!"

访问字符串中的字符：

通过索引访问字符串中的单个字符（从0开始）。

print(my_string[0])  # 输出：H

切片操作：

使用切片操作提取部分字符串。

print(my_string[7:12])  # 输出：World

字符串拼接：

使用 + 运算符将两个字符串连接起来。

new_string = "Python" + " is fun!"

字符串格式化：

使用 % 操作符或 .format() 方法对字符串进行格式化。

name = "Alice"
age = 30
formatted_string = "My name is %s and I am %d years old." % (name, age)

常用字符串方法：

Python 提供了许多内置方法来处理字符串，如 upper()、lower()、split() 等。

my_string = "Hello, World!"
print(my_string.upper())     # 输出：HELLO, WORLD!
print(my_string.lower())     # 输出：hello, world!
words = my_string.split(",")  # 输出：['Hello', ' World!']

字符串长度：

使用 len() 函数获取字符串的长度。

my_string = "Hello, World!"
length = len(my_string)
print(length)  # 输出：13

列表的使用：

列表是一种灵活的数据结构，可以存储多个元素

创建列表：

使用方括号 [] 来创建列表，并在其中放置元素。

my_list = [1, 2, 3, 'apple', 'banana']

访问列表元素：

使用索引访问列表中的单个元素（从0开始）。

print(my_list[0])  # 输出：1

切片操作：

使用切片操作提取部分列表。

print(my_list[2:4])  # 输出：[3, 'apple']

修改列表元素：

利用索引赋值来修改列表中的元素。

my_list[3] = 'orange'

列表方法：

列表有许多实用的方法，如 append()、pop()、remove() 等。

my_list.append('cherry')    # 在末尾添加元素
popped_element = my_list.pop()  # 删除最后一个元素并返回它
my_list.remove('banana')    # 删除指定元素

遍历列表：

使用循环遍历列表中的所有元素。

for item in my_list:
    print(item)

列表长度：

使用 len() 函数获取列表的长度。

length = len(my_list)
print(length)  # 输出：4

列表的特点：

列表是可变的（mutable），可以动态添加、删除或修改元素。
列表中的元素可以是不同的数据类型。
列表支持嵌套，即列表中可以包含其他列表。

元组的基本使用：

是 Python 中另一种重要的数据结构，与列表类似但具有不可变性

创建元组:

使用圆括号 () 来创建元组，并在其中放置元素。

my_tuple = (1, 2, 'apple', 'banana')

访问元组元素:

使用索引访问元组中的单个元素（从0开始）。

print(my_tuple[0])  # 输出：1

切片操作:

使用切片操作提取部分元组。

print(my_tuple[2:4])  # 输出：('apple', 'banana')

遍历元组:

使用循环遍历元组中的所有元素。

for item in my_tuple:
    print(item)

元组长度:

使用 len() 函数获取元组的长度。

length = len(my_tuple)
print(length)  # 输出：4

元组解包:

可以通过元组解包将元组中的值赋给多个变量

a, b, c, d = my_tuple

元组不可变性:

元组是不可变的，意味着一旦创建就无法修改其内容。
尝试修改元组会导致错误。

集合的基本使用：

集合适用于需要存储唯一元素并进行集合运算（如并集、交集等）的情况。它们提供了高效的成员检查操作。

创建集合：

使用大括号 {} 或 set() 函数来创建集合

my_set = {1, 2, 3, 'apple', 'banana'}

集合特点：

集合中的元素是唯一且无序的，不允许重复。
集合是可变的数据结构。

访问集合：

由于集合是无序的，不能通过索引访问单个元素。

添加和删除元素：

使用 add() 方法向集合添加元素，使用 remove() 或 discard() 方法删除元素。

my_set.add('cherry')    # 添加元素
my_set.remove('banana')   # 删除元素，如果不存在会引发 KeyError
my_set.discard('apple')   # 删除元素，如果不存在不会引发错误

遍历集合：

使用循环遍历集合中的所有元素。

for item in my_set:
    print(item)

集合操作：

可以执行集合操作，如并集、交集、差集等。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)        # 并集
intersection_set = set1.intersection(set2)  # 交集
difference_set = set1.difference(set2)    # 差集

集合长度：

使用 len() 函数获取集合的大小（元素个数）。

size = len(my_set)
print(size)

字典的基本使用：

学习字典的基本使用对于在 Python 中管理键值对数据非常重要，字典是一种灵活且强大的数据结构，用于存储和管理各种类型的数据。掌握字典的基本用法可以帮助在 Python 编程中更有效地组织和操作数据

创建字典：

使用大括号 {} 来创建字典，并用冒号 : 分隔键值对。

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

访问字典元素：

使用键来访问字典中的值。

print(my_dict['name'])  # 输出：Alice

修改字典元素：

可以通过键来修改字典中的值。

my_dict['age'] = 31

添加新键值对：

直接为不存在的键赋值即可添加新的键值对。

my_dict['gender'] = 'Female'

删除键值对：

使用 del 关键字或 pop() 方法删除字典中的键值对。

del my_dict['city']   # 删除键为 'city' 的键值对
popped_value = my_dict.pop('age')  # 删除键为 'age' 的键值对并返回其值

遍历字典：

使用循环遍历字典中的所有键、值或键值对。

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

for value in my_dict.values():
    print(value)

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

字典方法：

字典有许多实用的方法，如 keys()、values()、items() 等。

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

字典长度：

使用 len() 函数获取字典中键值对的数量。

length = len(my_dict)
print(length)

编写python函数：

定义函数：

就像你有一个魔法盒子，可以做一些特殊的事情。

def my_function():
    # 在这里放你的神奇指令
    print("Hello, I am a magic box!")

调用函数：

当你想使用魔法盒子时，只需呼唤它并看它执行操作。

my_function()  # 这将会打印出 "Hello, I am a magic box!"

函数参数：

有时候你需要给魔法盒子一些东西才能执行特定的任务。

def greet(name):
    print("Hello, " + name + "!")

greet("Alice")  # 这将会打印出 "Hello, Alice!"

返回值

魔法盒子可以给你一些东西返回，就像它送你精彩礼物一样。

def add_numbers(a, b):
    return a + b

result = add_numbers(3, 5)  # 结果将是 8

学习python面向对象的编程语法：

类与对象：

想象你有一本魔法书，里面可以制造各种神奇的东西。类就像这本魔法书，而对象就是书中具体制造出来的东西。

class MagicBook:
    def __init__(self, title):
        self.title = title

    def cast_spell(self):
        print(self.title + " casts a spell!")

spell_book = MagicBook("Spell Book")
spell_book.cast_spell()  # 输出：Spell Book casts a spell!

属性和方法：

在你的魔法书中，每个制造出来的东西都有自己的特殊能力和动作。

class MagicItem:
    def __init__(self, name, power):
        self.name = name
        self.power = power

    def use(self):
        print("Using", self.name, "with power", self.power)

wand = MagicItem("Magic Wand", 10)
wand.use()  # 输出：Using Magic Wand with power 10

继承：

有时候，你会从一个故事中学到的东西，并应用在另一个故事里。

class Sword(MagicItem):
    def slash(self):
        print("Sword slashing!")

sword = Sword("Excalibur", 15)
sword.use()   # 输出：Using Excalibur with power 15
sword.slash()  # 输出：Sword slashing!

封装:

保护你的魔法书内容，让别人不易了解它的秘密。

class SecretBook:
    def __init__(self, secret):
        self.__secret = secret

    def reveal_secret(self):
        print("The secret is:", self.__secret)

book = SecretBook("Hidden message")
book.reveal_secret()  # 输出：The secret is: Hidden message
# 不能直接访问私有属性：print(book.__secret)  # 这将引发错误

如何捕捉异常：

捕捉特定类型的异常：

当你尝试做一些事情，但出现问题时，就像玩游戏时不小心摔倒了。你可以学会如何正确地摔倒，并且不受伤。

try:
    result = 10 / 0  # 尝试做除法运算，但除数为零会引发 ZeroDivisionError
except ZeroDivisionError as e:
    print("Error:", e)
    print("Oops! You can't divide by zero.")

捕捉通用的异常：

有时候问题可能来自任何地方，就像找到了一个神奇的防护罩，可以保护你免受意外伤害。

try:
    age = int(input("Please enter your age: "))
except Exception as e:
    print("Error:", e)
    print("Oops! Something went wrong. Please enter a valid age.")

处理多个异常：

不同的问题需要不同的处理方式，就像你对待掉了玩具和忘记做家庭作业两种情况。

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ValueError:
    print("Oops! That's not a valid number.")
except ZeroDivisionError:
    print("Oops! You can't divide by zero.")

最终处理（无论是否出现异常都执行）：

有时候无论你成功与否，最终都得做一些清理工作，就像玩完了所有游戏后需要整理房间一样。

try:
    file = open("example.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("Oops! File not found.")
finally:
    if 'file' in locals():
        file.close()  # 确保文件被关闭