Python初学者的宝藏笔记：基础要点全掌握_python3.8系统入门+进阶笔记-优快云博客

本文链接：https://blog.youkuaiyun.com/sq91fra/article/details/145166944

python基础

认识python

Python是一种高级、易于学习的编程语言，具有简洁的语法和强大的功能。它是一种通用的编程语言，可以用于科学计算、数据分析、Web开发、游戏开发、人工智能等领域。
Python具有简洁的语法，使得初学者可以轻松地学习。它的缩进风格使得代码更加清晰易读。Python还具有丰富的库和工具，可以轻松地处理各种任务。

版本：初学者推荐3.8稳定版本

环境：

venv：更轻量级，适用于纯Python项目。它主要用于管理Python包，不适合管理非Python依赖项。
conda：可以管理Python包以及其他语言的包和依赖项。它更适合于复杂的项目，特别是涉及到多种语言或非Python依赖项的项目。

conda配置镜像：

channels:
  - defaults
show_channel_urls: true
default_channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  deepmodeling: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/
envs_dirs:
  - D:\dev\Anaconda\envs
pkgs_dirs:
  - D:\dev\Anaconda\pkgs

使用conda创建环境：

conda create -n env名称 python=python版本

例如：
conda create -n gameEnv python=3.8

查看当前 conda 版本：
conda --version

 当前存在的 conda 虚拟环境: 
conda env list

 查看当前已经安装的包：
conda list

激活其中一个虚拟环境(需要管理员)：
conda init
conda activate new_name

退出当前虚拟环境：
conda deactivate

删除其中一个虚拟环境：
conda remove -n new_name --all

conda install 依赖

例如
conda install numpy

conda 安装依赖包环境
conda install --yes --file requirements.txt


导出到.yml文件
conda env export > freeze.yml

直接创建conda环境
conda env create -f freeze.yml

基本语法

注释

# 单行注释

"""
多行注释
"""

变量

Python变量的声明无需指定类型，解释器会自动识别

基本语法：

<var_name> = <value>

示例：

age = 56
name = "Nora"

标识符与关键字

关键字不能作为变量名

可以使用下面代码打印python关键字

import keyword

var = keyword.kwlist
print(var)

输入与输出

使用input()函数接收键盘输入，使用print函数输出

name = input('请输入姓名：')

print(f'你好,{name}')

格式化输出

在Python中，格式化输出是一种将变量插入到字符串中的方法，以便生成具有特定格式的文本。

Python提供了多种格式化输出的方法，包括旧式的 % 运算符方法、str.format() 方法，以及Python 3.6引入的f-strings（格式化字符串字面量）。

%** 运算符方法**：这是Python最早的一种格式化输出方式。它使用 % 符号将值插入到字符串的占位符中。
%d

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

输出将是：“My name is Alice and I am 30 years old.”

str.format()** 方法**：这是一种更现代、更灵活的格式化方法。它使用花括号 {} 作为占位符，并通过 format() 方法将变量传递给字符串。例如：

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

输出将是：“My name is Alice and I am 30 years old.”

f-strings（格式化字符串字面量）：这是Python 3.6及以后版本中引入的一种非常简洁和直观的格式化方法。它允许你直接在字符串字面量中嵌入表达式，用大括号 {} 包围。例如：

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

输出将是：“My name is Alice and I am 30 years old.”

f-strings通常被认为是最现代、最易读的格式化方法，因为它们允许在字符串中直接嵌入表达式，并且可以轻松地格式化数值和日期等。

缩进和多行语句

多行语句：python一行编写一个语句，不需要;分隔语句
缩进语句：python使用缩进替代其他语言中循环判断等特殊语句的{}

示例：

a = 1

if a == 1:
    print('a=1')
elif a == 2:
    print('a=2')
else:
    print('a不为1或2')

数据类型

整数（Integers） - 用于表示没有小数部分的数字，例如：1, -100, 0。
浮点数（Floats） - 用于表示带有小数点的数字，例如：3.14, -0.001, 2.0。
字符串（Strings） - 用于表示文本数据，由引号包围，例如："hello", 'Python'。
布尔值（Booleans） - 表示真（True）或假（False）的值。
列表（Lists） - 用于存储有序的元素集合，元素可以是不同的类型，例如：[1, 2, 3], ["apple", "banana", "cherry"]。
元组（Tuples） - 类似于列表，但一旦创建就不能修改，例如：(1, 2, 3), ("red", "green", "blue")。
字典（Dictionaries） - 用于存储键值对，每个键都映射到一个值，例如：{"name": "Alice", "age": 25}。
集合（Sets） - 用于存储无序且唯一的元素集合，例如：{1, 2, 3}。

运算符和表达式

注意：python中，没有自增(i++)和自减(1–)

语句

判断

Python中的判断语句主要包括if语句、elif语句和else语句。

if语句：

if语句用于判断一个条件是否为真，如果条件为真，则执行if后的代码块。

elif语句：

elif语句用于判断多个条件中的一个是否为真，如果条件为真，则执行elif后的代码块。elif语句必须与if语句一起使用，不能单独使用。

else语句：

else语句用于判断所有条件都不为真时，执行else后的代码块。else语句也必须与if语句一起使用，不能单独使用。

例如：

age = 16

if age > 18:
    print("成年了")
elif age == 18:
    print("刚满18岁~~")
else:
    print("未成年")

注意，if、elif和else语句的代码块必须使用缩进，且缩进量相同。

示例：

a = 1

if a == 1:
    print('a=1')
    #    print('a=1') #错误
elif a == 2:
    print('a=2')
    print('a=2') # 正确
else:
    print('a不为1或2')

循环

Python中的循环语句主要包括for循环和while循环。

for循环：用于遍历序列（如列表、元组、字符串等）中的元素。for循环通常用于在序列中的每个元素上执行相同的操作。

# 从0开始，到11结束，步进为3
for i in range(0, 11, 3):
    print(i)

# 从-10开始，到-100结束，步进为5
for i in range(-10, -100, -5):
    print(i)

# 迭代字符串
for char in "hello":
    print(char, end="\t")

# 迭代列表
arr = ["a", "b", "c", "d"]
for i in range(len(arr)):
    print(i, arr[i])

while循环：用于在满足某个条件时反复执行一段代码。当条件为假时，while循环将停止执行。

# 使用while循环求和1-100
res = 0
i = 1
while i <= 100:
    res += i
    i += 1
print(res)

while else语句(了解)：

i = 0
while i <= 100:
    print(i)
    i += 20
else:
    print("循环结束")

break、continue、pass

break语句用于提前结束循环。当执行到break语句时，循环会立即停止，不再执行循环内剩余的代码。
continue语句用于跳过当前循环的剩余部分，进入下一次循环。当执行到continue语句时，循环会立即停止执行当前迭代，然后开始下一轮迭代。
pass语句用于表示一个代码块，但什么都不做。当需要定义一个空函数、空循环或其他空代码块时，可以使用pass语句。

在for循环和while循环中，还可以使用range()函数生成一个整数序列，作为循环的次数。

#使用for循环打印1到10
for i in range(1, 11):
    print(i)

练习：打印九九乘法表

for i in range(0, 10):
    for j in range (0,i+1):
        print(f'{i}*{j}={i*j}',end=" ") 
    print()

数据类型

数字

Python 中的数字类型：整数（Integers），浮点数（Floats），复数（Complex）

复数有一个实部和一个带有j的虚部。你可以通过complex()来创建复数。complex()的第一个参数是实部，第二个参数是虚部。

a = complex(3.4, 3.4)
print(a) # 输出(3.4+3.4j)
print(type(a)) # a的类型为complex

强制类型转换：

使用int()、float()、str()、bool()、list()、dict()等方法

例如：

tuple_num = (1, 2, 3)
list_num = list(tuple_num)  # 结果为 [1, 2, 3]

字符串

python中没有字符概念，只有字符串

如果我们用双引号""定义字符串，那我们可以在字符串中使用单引号。反之，如果我们使用单引号''定义字符串，那我们可以在字符串中使用双引号。

"I'm 20 years old"

'My favorite book is "Sense and Sensibility"'

常用转义字符：

\n - 换行符，用于在字符串中创建新的一行。
\t - 制表符，用于在字符串中创建水平制表。
\\ - 反斜杠本身，用于在字符串中表示一个反斜杠。
\' - 单引号，用于在用单引号包围的字符串中包含一个单引号。
\" - 双引号，用于在用双引号包围的字符串中包含一个双引号。

print("She said, \"Hello!\"")

字符串的常见操作：

字符串拼接：

str1 = "Hello"
str2 = "World"
result = str1 + " " + str2  # 结果是 "Hello World"

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

字符串复制：

str = "Hi"
result = str * 3  # 结果是 "HiHiHi"

- 使用 `*` 运算符将字符串重复多次。

字符串索引：

s = 'apple'
for i in range(len(s)):
    print(s[i],end='')
print()
for i in range(len(s)):
    print(s[-(i+1)],end='')

- 在 Python 程序中，我们可以使用索引来访问字符串中的字符。索引是一个整数，表示字符串中的一个特定位置。
- 我们还可以用负的索引来访问字符串中字符，通常用`-1`来访问字符串中的最后一个字符。

字符串切片：

str = "Hello World!"

# [起始位置:结束位置:步进值]
print(str[2:5])
print(str[2:]) 
print(str[:2]) 
print(str[1:7:2])

- 使用切片操作获取字符串的子串。

str = "Hello World!"

# [起始位置:结束位置:步进值]
print(str[0])
print(str[2:5])
print(str[2:]) 
print(str[:2]) 
print(str[1:7:2])
# 输出两次
print(str * 2)

r模式忽略转义字符

print(r"123\n456")

常用方法：

字符串长度：

str = "Python"
length = len(str)  # 结果是 6

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

字符串包含：

str = "Python"
result = "Py" in str  # 结果是 True

- 使用 `in` 关键字检查一个字符串是否包含另一个字符串。

字符串查找：

str = "Python"
pos = str.find("th")  # 结果是 2

- 使用 `find()` 或 `index()` 方法查找子字符串在字符串中的位置。

字符串替换：

str = "Python"
new_str = str.replace("Py", "By")  # 结果是 "Bython"

- 使用 `replace()` 方法替换字符串中的子串。

字符串分割：

str = "apple,banana,cherry"
fruits = str.split(",")  # 结果是 ['apple', 'banana', 'cherry']

- 使用 `split()` 方法将字符串分割成列表。

字符串大小写转换：

str = "Python"
upper_str = str.upper()  # 结果是 "PYTHON"

- 使用 `upper()`、`lower()`、`capitalize()`、`title()` 等方法进行大小写转换。

字符串去除空白：

str = "  Python  "
stripped_str = str.strip()  # 结果是 "Python"

- 使用 `strip()`、`lstrip()`、`rstrip()` 方法去除字符串前后的空白字符。

字符串格式化：

name = "Alice"
age = 30
formatted_str = f"My name is {name} and I am {age} years old."

- 使用 `format()` 方法或 f-strings 进行字符串格式化。

连接字符串：

strs = ["hello","world","hello","China"]
res = " ".join(strs)
print(res)

列表 list

Python列表（List）是一种可变的序列类型，可以存储不同类型的元素。

以下是一些常用的Python列表方法：

增加：

append()：

fruits = ["apple", "banana"]
fruits.append("cherry")
# 结果是 ["apple", "banana", "cherry"]

- 向列表末尾添加一个元素。

extend()：

fruits = ["apple", "banana"]
more_fruits = ["cherry", "orange"]
fruits.extend(more_fruits)
# 结果是 ["apple", "banana", "cherry", "orange"]

- 将另一个列表中的所有元素添加到当前列表末尾。

insert()：

fruits = ["apple", "banana"]
fruits.insert(1, "cherry")
# 结果是 ["apple", "cherry", "banana"]

- 在列表的指定位置插入一个元素。

删除：

fruits = ["apple", "banana", "cherry"]
del fruits[1]
# 结果是 ["apple", "cherry"]

remove()：

fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")
# 结果是 ["apple", "cherry"]

- 移除列表中第一个匹配的元素。

pop()：

fruits = ["apple", "banana", "cherry"]
last_fruit = fruits.pop()
# 结果是 ["apple", "banana"]，last_fruit 是 "cherry"

- 移除列表中指定位置的元素（默认为最后一个元素）并返回它。

clear()：

fruits = ["apple", "banana", "cherry"]
fruits.clear()
# 结果是 []

- 清空列表中的所有元素。

index()：

fruits = ["apple", "banana", "cherry"]
index = fruits.index("banana")
# 结果是 1

- 返回列表中第一个匹配元素的索引。
- 参数：(元素,查找起始索引，查找结束索引)
- 范围区间左闭右开

in /not in

# 查找 in /not in
fruits = ["apple", "banana", "cherry"]
if "apple" in fruits:
    print("apple在列表中")
else:
    print("apple不在列表中")

count()：

fruits = ["apple", "banana", "cherry", "apple"]
count = fruits.count("apple")
# 结果是 2

- 返回列表中某个元素出现的次数。

排序与反转

reverse()：

fruits = ["apple", "banana", "cherry"]
fruits.reverse()
# 结果是 ["cherry", "banana", "apple"]

- 反转列表中元素的顺序。

sort()：

numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()
# 结果是 [1, 1, 2, 3, 4, 5, 9]
numbers.sort(reverse=True)

- 对列表中的元素进行排序（可指定排序规则）。

# 使用枚举函数，同时拿到列表的下标和元素
fruits = ["apple", "banana", "cherry"]
for index, value in enumerate(fruits):
    print(index, value)

元组 tuple*

# 空元组
tup1 = ()

# 含有一个元素的元组
tup2 = (1,)

# 含有多个元素的元组
tup3 = (1, 2, "tom", 4, [1, 2, 3])

# 元组切片
print(tup3[:3])

# 元组是不可变的，不能直接修改元组中的元素
# tup3[0] = 1 # 报错
# 但是元组中的列表是可变的，可以修改列表中的元素
tup3[4][0] = 10
print(tup3)  # (1, 2, 'tom', 4, [10, 2, 3])

# 连接两个元组
tup4 = tup3 + tup2
print(tup4)   # (1, 2, 'tom', 4, [10, 2, 3], 1)

字典 dict

# 定义字典
stu = {
    "name": "张三",
    "age": 18,
    "gender": "男",
    "address": "北京"
}

# 字典的访问
print(stu["name"])
# 如果访问了不存在的键会报错
# print(stu["gender"])

# 使用字典的get方法，如果不存在会打印None
print(stu.get("gender"))
# 打印指定的内容
print(stu.get("gender", "男"))
# 给字典增加一个键
stu["gender"] = "男"
print(stu)

# 删除字典的一个键值对
del stu["gender"]
print(stu)

# 修改字典的值
stu["age"] = 20

# 遍历字典
for key in stu:
    print(key, stu[key])
for key, value in stu.items():
    print(key, value)
for value in stu.values():
    print(value)



# 清空字典
stu.clear()
print(stu)

# 销毁字典
del stu

集合 set*

Python中的set类型是一种无序且不包含重复元素的集合。

集合通常用于成员资格测试、从序列中去除重复项以及数学上的集合运算，如并集、交集和差集。
创建集合可以使用大括号 {} 或 set() 函数。例如：

# 使用大括号创建集合
my_set = {1, 2, 3}
# 使用set()函数创建集合
my_set = set([1, 2, 3])

集合的特性包括：

无序性：集合中的元素没有固定的顺序，因此不能通过索引来访问。
唯一性：集合中的元素是唯一的，重复的元素会被自动去除。
集合支持多种操作，包括：

添加元素：使用 add() 方法添加单个元素，使用 update() 方法添加多个元素。
删除元素：使用 remove() 方法删除指定元素，使用 discard() 方法删除元素（如果元素不存在不会报错）。
集合运算：包括并集（union() 或 |），交集（intersection() 或 &），差集（difference() 或 -），对称差集（symmetric_difference() 或 ^）等。
成员测试：使用 in 关键字检查元素是否在集合中。
例如：

# 创建集合
A = {1, 2, 3}
B = {3, 4, 5}
C = set() # 创建一个空集合
# 并集
print(A | B)  # 输出 {1, 2, 3, 4, 5}
# 交集
print(A & B)  # 输出 {3}
# 差集
print(A - B)  # 输出 {1, 2}
# 成员测试
print(2 in A)  # 输出 True

如果要创建一个新集合，必须使用set()创建

s = set() # 创建一个空集合

lst = [ 5, 6, 7, 8, 9, 9]

# 将列表中的元素添加到集合中
s = set(lst)

# 打印集合
print(s)

tup = (1, 2, 3, 4, 5, 5)
# 将元组转换为集合
s = set(tup)
# 打印集合
print(s)

函数

格式

def 函数名(参数列表):
    函数体

# 定义函数
def py():
    print("-"*10)
    print("人生苦短，我学python")
    print("-" * 10)

# 调用函数
py()


# 带参数的函数
def addNum(a,b):
    print(a, b)

# 带返回值的函数
def addNum2(a,b):
    return a+b

# 返回多个参数的函数
def divNum(a,b):
    # 返回数的商和余数
    return a//b, a%b

sh,yu = divNum(5,2)
print(f"商：{sh}余数：{yu}")

数据类型

可以通过 :设置参数列表的数据类型，通过->设置返回值的数据类型

# 设置参数列表的数据类型
def addNum3(a: int, b: int):
    return a+b
# 调用函数
print(addNum3(1,2))

# 设置返回值的数据类型
def addNum4(a: int, b: int) -> int:
    return a + b

默认参数

当调用函数时，如果没有为该参数提供值，那么将使用默认值。

# 设置默认参数
def addNum5(a: int, b: int = 0):
    return a + b

局部变量和全局变量

局部变量：

局部变量是在函数内部定义的变量，它的作用范围仅限于该函数内部。在函数外部无法访问局部变量。

例如：

def my_function():
    x = 10
    print(x)

my_function()  # 输出：10
print(x)  # 报错：NameError: name 'x' is not defined

全局变量：

全局变量是在函数外部定义的变量，它的作用范围是整个程序。在函数内部可以访问全局变量，但在函数内部对全局变量的修改不会影响到全局变量。

例如：

x = 10

def my_function():
    print(x)

my_function()  # 输出：10
x = 20
my_function()  # 输出：10

在上述例子中，x是一个全局变量，它在整个程序中都可以访问。在my_function函数内部，可以访问全局变量x，但不能修改它。当在函数内部需要修改全局变量时，需要使用global关键字声明。

例如：

x = 10

def my_function():
    global x
    x = 20

my_function()
print(x)  # 输出：20

练习：

students = {}

def show():
    if not students:
        print("没有学生记录。")
        return
    print("No\tName\tGender\tAge")
    for no, info in students.items():
        print(f"{no}\t{info['Name']}\t{info['Gender']}\t{info['Age']}")

def insert(no, name, gender, age):
    if no in students:
        print("学号已存在。")
    else:
        students[no] = {'Name': name, 'Gender': gender, 'Age': age}
        print("插入成功。")

# 判断数据是否合法
def is_valid(no, name, gender, age):
    if no == "" or name == "" or gender == "" or age == "":
        print("学号、姓名、性别和年龄不能为空。")
        return False
    if not no.is_integer():
        print("学号必须是数字。")
        return False
    if gender not in ["男", "女"]:
        print("性别必须是男或女。")
        return False
    if not age.is_integer():
        print("年龄必须是数字。")
        return False
    if age < 15 or age > 25:
        print("年龄必须在15到25之间。")
    return True

def update(no, name, gender, age):
    if no not in students:
        print("学号不存在。")
    else:
        students[no] = {'Name': name, 'Gender': gender, 'Age': age}
        print("更新成功。")

def delete(no):
    if no not in students:
        print("学号不存在。")
    else:
        del students[no]
        print("删除成功。")

while True:
    cmd = input(">")
    if cmd == "show":
        show()
    elif cmd.startswith("insert"):
        no = input("学号：")
        no = int(no)
        name = input("姓名：")
        gender = input("性别：")
        age = input("年龄：")
        age = int(age)
        if is_valid(no, name, gender, age):
            insert(no, name, gender, age)
    elif cmd.startswith("update"):
        no = input("学号：")
        name = input("姓名：")
        gender = input("性别：")
        age = input("年龄：")
        if is_valid(no, name, gender, age):
            update(no, name, gender, age)
    elif cmd.startswith("delete"):
        no = input("学号：")
        delete(no)
    elif cmd == "exit":
        break
    else:
        print("请输入正确的命令。")
        print("show: 显示所有学生信息")
        print("insert: 插入学生信息")
        print("update: 更新学生信息")
        print("delete: 删除学生信息")
        print("exit: 退出程序")

文件操作

Python中的文件操作涉及读取和写入文件。Python提供了内置的函数和模块来处理文件，其中最常用的是 open() 函数，它用于打开文件并返回一个文件对象。文件操作通常包括打开文件、读取或写入内容、以及关闭文件。
以下是Python文件操作的基本步骤：

打开文件：
使用 open() 函数打开文件，可以指定文件路径、打开模式（如读取 r、写入 w、追加 a、以二进制格式打开文件rb、以二进制格式写入文件wb 等）和编码（如 utf-8）。

file = open("example.txt", "r", encoding="utf-8")

读取文件内容：

- 使用 `read()` 方法，读取指定的字符，开始时定位在文件头部，每执行一次向后移动指定字符数
- 使用 `readline()` 方法读取文件中的一行。
- 使用 `readlines()` 方法读取文件中的所有行到一个列表中。

content = file.read(5)
line = file.readline()
lines = file.readlines()

写入文件内容：

file.write("Hello, World!")
file.writelines(["Line 1\n", "Line 2\n"])

- 使用 `write()` 方法写入字符串到文件。
- 使用 `writelines()` 方法写入一个字符串列表到文件。

关闭文件：

file.close()

- 使用 `close()` 方法关闭文件。这是非常重要的，因为它会释放系统资源。

文件指针操作：

file.seek(0)  # 将文件指针移动到文件开头
position = file.tell()  # 获取当前文件指针的位置

- 使用 `seek()` 方法移动文件指针到文件的不同位置。
- 使用 `tell()` 方法获取当前文件指针的位置。

使用with语句：

with open("example.txt", "r", encoding="utf-8") as file:
    content = file.read()
# 文件在此处自动关闭

- 使用 `with` 语句可以自动管理文件的打开和关闭，这是推荐的文件操作方式。

使用os模块进行文件删除、重命名等操作

异常处理

Python中的异常处理是一种机制，用于处理程序执行过程中可能出现的错误或异常情况。

异常是程序运行时发生的错误，可能会导致程序崩溃或产生不期望的结果。使用异常处理，可以更优雅地处理这些错误，避免程序的非正常终止，并允许程序在错误发生后继续执行。
Python异常处理的关键字包括 try、except、finally 和 else。

try** 块**：

- `try` 块用于包含可能引发异常的代码。
- 如果 `try` 块中的代码正常执行，则程序继续执行 `try` 块之后的代码。
- 如果 `try` 块中的代码引发异常，则程序会跳转到相应的 `except` 块。

except** 块**：

- `except` 块用于捕获并处理 `try` 块中引发的异常。
- 可以指定捕获特定类型的异常，也可以捕获所有异常。
- 如果异常被捕获，则 `except` 块中的代码会被执行。

finally** 块**：

- `finally` 块用于定义无论是否发生异常都会执行的代码。
- 它通常用于释放资源，如关闭文件或网络连接。
- `finally` 块在 `try` 和 `except` 块之后执行，无论是否发生异常。

else** 块**：

- `else` 块是可选的，它紧跟在 `try` 块之后。
- 如果 `try` 块中的代码没有引发异常，则执行 `else` 块中的代码。
- `else` 块在 `except` 块之前执行。

下面是一个简单的异常处理示例：

try:
    # 尝试执行可能会引发异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 捕获特定类型的异常
    print("不能除以零")
except Exception as e:
    # 捕获所有其他异常
    print(f"发生错误：{e}")
else:
    # 如果没有异常发生，执行这里的代码
    print("计算成功")
finally:
    # 无论是否发生异常，都会执行这里的代码
    print("执行结束")

抛出异常：

语法格式：raise Exception

while True:
    try:
        number = int(input("请输入一个整数: "))
        if number==0:
            raise Exception("输入不能为0")
        break
    except ValueError:
        print("那不是一个有效的整数，请重试！")
print("你输入的数字是:", number)

库的安装与引入

pip

使用pip安装包安装第三方库-0:

pip是python2安装包的工具，pip3是python3安装包的工具

# 使用pip3安装pandas
pip3 install --user pandas

为了加快下载第三方库的速度，可以设置pip下载工具的国内镜像:

# 配置镜像
pip install pip -U
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

引入模块

Python中引入模块的方式主要有两种：使用import语句和from ... import ...语句。

使用import语句引入模块：

在代码的开头使用import语句，可以引入整个模块。引入整个模块后，可以使用模块中的所有函数和类。

例如，引入math模块：

import math

print(math.sqrt(9))  # 输出：3.0

使用from ... import ...语句引入模块中的特定函数或类：

使用from ... import ...语句，可以从模块中引入特定的函数或类，而不必引入整个模块。

例如，从math模块中引入sqrt函数：

from math import sqrt

print(sqrt(9))  # 输出：3.0

此外，还可以使用as关键字给引入的函数或类起别名。

例如，从math模块中引入sqrt函数，并将其命名为my_sqrt：

from math import sqrt as my_sqrt

print(my_sqrt(9))  # 输出：3.0

内建模块

math

Python的math模块提供了许多数学函数，可以方便地进行数学计算。

math模块中的函数主要分为以下几类：

取整函数：

math.ceil(x)：返回大于或等于x的最小整数。
math.floor(x)：返回小于或等于x的最大整数。
math.round(x)：返回最接近x的整数。

三角函数：

math.sin(x)：返回x的正弦值。
math.cos(x)：返回x的余弦值。
math.tan(x)：返回x的正切值。
math.asin(x)：返回x的反正弦值。
math.acos(x)：返回x的反余弦值。
math.atan(x)：返回x的反正切值。

指数函数：

math.exp(x)：返回e的x次幂。
math.log(x)：返回x的自然对数。
math.log10(x)：返回x以10为底的对数。

算术函数：

math.sqrt(x)：返回x的平方根。
math.pow(x, y)：返回x的y次幂。
math.factorial(x)：返回x的阶乘。

三角函数：

math.degrees(x)：将x从弧度转换为角度。
math.radians(x)：将x从角度转换为弧度。

注意，math模块中的函数返回的结果是浮点数。在使用这些函数时，需要考虑精度问题。如果需要进行精确的计算，可以考虑使用Python的内置库decimal。

示例：

import math

def calculate_area(radius):
    return math.pi * radius ** 2

radius = float(input("Enter the radius of the circle: "))
area = calculate_area(radius)

datetime

Python的datetime模块提供了丰富的日期和时间处理功能，包括日期、时间和时间戳等。

日期和时间：

datetime.date(year, month, day)：创建一个日期对象。
datetime.time(hour, minute, second, microsecond)：创建一个时间对象。
datetime.datetime(year, month, day, hour, minute, second, microsecond)：创建一个日期时间对象。

日期和时间的计算：

datetime1 + datetime2：两个日期时间对象的相加。
datetime1 - datetime2：两个日期时间对象的相减。
datetime.timedelta(days, seconds, microseconds)：创建一个时间间隔对象。

日期和时间的格式化：

datetime.strptime(date_string, format)：将日期字符串解析为日期时间对象。
datetime.strftime(format)：将日期时间对象格式化为日期字符串。

获取当前日期和时间：

datetime.now()：获取当前日期和时间。
datetime.utcnow()：获取当前UTC日期和时间。

日期和时间的比较：

datetime1 < datetime2：比较两个日期时间对象的大小。
datetime1 > datetime2：比较两个日期时间对象的大小。
datetime1 == datetime2：比较两个日期时间对象是否相等。

datetime模块中的类主要有date、time、datetime和timedelta等。使用这些类可以方便地进行日期和时间的计算、格式化、解析等操作。

例如，获取当前日期和时间：

from datetime import datetime

now = datetime.now()
print(now)

输出结果：

2024-10-08 16:48:37.882883

random

Python的random模块提供了丰富的随机数生成函数，可以生成各种类型的随机数，如整数、浮点数、随机选择等。

生成随机整数：

random.randint(a, b)：生成一个在a和b之间的随机整数（包括a和b）。
random.randrange(start, stop[, step])：生成一个在start和stop之间的随机整数（包括start，但不包括stop），step表示间隔。

生成随机浮点数：

random.uniform(a, b)：生成一个在a和b之间的随机浮点数。

随机选择：

random.choice(sequence)：从sequence（列表、元组、字符串等）中随机选择一个元素。

生成随机数种子：

random.seed(a=None)：初始化随机数生成器的种子。

random模块中的函数主要使用random类实现。使用这些函数可以方便地进行随机数的生成和随机选择等操作。

例如，生成一个1到10之间的随机整数：

import random

num = random.randint(1, 10)
print(num)

输出结果：

生成一个0到1之间的随机浮点数：

import random

num = random.uniform(0, 1)
print(num)

输出结果：

0.5432109876543211

从列表中随机选择一个元素：

import random

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

输出结果：

OS 文件/目录方法

Python的os模块提供了丰富的操作系统相关功能，如文件和目录操作、环境变量操作等。

os.mkdir(path)：创建一个目录。
os.rmdir(path)：删除一个目录。
os.makedirs(path, mode=0o777)：创建多级目录。
os.removedirs(path)：删除多级目录。
os.rename(src, dst)：重命名文件或目录。
os.renames(src, dst)：重命名多级文件或目录。
os.stat(path)：获取文件或目录的状态信息。
os.lstat(path)：获取文件或目录的符号链接状态信息。
os.path.exists(path)：检查文件或目录是否存在。
os.path.isdir(path)：检查是否为目录。
os.path.isfile(path)：检查是否为文件。
os.path.getsize(path)：获取文件大小。
os.path.join(path, *paths)：连接两个或多个路径组件。
os.path.normpath(path)：归一化路径。
os.path.abspath(path)：获取绝对路径。
os.path.dirname(path)：获取目录部分。
os.path.basename(path)：获取文件名部分。

环境变量操作：

os.environ：获取系统环境变量。
os.getenv(var, default=None)：获取指定环境变量，如果未找到则返回默认值。
os.putenv(var, value)：设置环境变量。
os.unsetenv(var)：删除环境变量。

例如，创建一个目录：

import os

path = "my_dir"
os.mkdir(path)

删除一个目录：

import os

path = "my_dir"
os.rmdir(path)

获取当前目录：

import os

current_dir = os.getcwd()
print(current_dir)

输出结果：

/path/to/current/dir

获取指定文件的属性：

import os

path = "my_file.txt"
file_stat = os.stat(path)
print(file_stat)

输出结果：

os.stat_result(st_mode=33188, st_ino=1055046, st_dev=869, st_nlink=1, st_uid=1000, st_gid=1000, st_size=0, st_atime=1658168200, st_mtime=1658168200, st_ctime=1658168200)

补充

lambda（匿名函数）

Python 使用 lambda 来创建匿名函数。
lambda 函数是一种小型、匿名的、内联函数，它可以具有任意数量的参数，但只能有一个表达式。
匿名函数不需要使用 def 关键字定义完整函数。

lambda 语法格式：lambda arguments: expression

lambda是 Python 的关键字，用于定义 lambda 函数。
arguments 是参数列表，可以包含零个或多个参数，但必须在冒号(:)前指定。
expression 是一个表达式，用于计算并返回函数的结果。

实例：

f = lambda: "Hello, world!"
print(f())  # 输出: Hello, world!
print(type(f)) #类型为函数

# 使用 lambda 创建匿名函数，函数参数 a 与 b 相乘，并返回结果
x = lambda a, b : a * b
print(x(5, 6))