Python基础篇（上） 学习笔记

快速入门

创建项目，打印 hello world

# 入口
if __name__ == '__main__':
    print('hello world')

运行：

基础语法

数据类型

数值型

整数（int）

age = 18        # 正整数
score = -5      # 负整数
zero = 0        # 零

浮点数（float）

comp = 3 + 4j   # 复数
print(comp.real)  # 输出实部：3.0
print(comp.imag)  # 输出虚部：4.0
print(type(comp)) # 输出：<class 'complex'>

字符串型（str）

name = "张三"       # 双引号字符串
msg = 'hello'       # 单引号字符串
# 三引号多行字符串
long_text = '''     
这是多行文本
第二行内容
'''
empty_str = ""      # 空字符串
print(type(name))   # 输出：<class 'str'>

布尔型（bool）

is_student = True   # 真
is_adult = False    # 假
print(type(is_student))  # 输出：<class 'bool'>
print(True + 1)     # 输出：2（True 等价于1）
print(False * 5)    # 输出：0（False 等价于0）

空类型（None）

print(None); # 输出：None

判断变量类型

用 type() 函数可直接查看变量的基础类型

num = 10
print(type(num))  # <class 'int'>
text = "test"
print(type(text)) # <class 'str'>

基础类型之间的转换

# 数值转字符串
str_num = str(18)       # "18"
# 字符串转整数（需字符串为纯数字）
int_str = int("20")     # 20
# 浮点数转整数（直接截断小数部分）
int_float = int(3.9)    # 3
# 任意类型转布尔值：0/空字符串/空值为False，其余为True
bool(0)        # False
bool("")       # False
bool("abc")    # True
bool(1.2)      # True

列表（list）

核心特性：可变，有序，可重复

定义方式：[] 包裹，元素用，分隔

arr = ['a', 'b', 'c']; #创建数组
print(arr); # 输出：['a', 'b', 'c']
print(len(arr)); # 输出：3（数组大小）
print(arr[0]);# 输出：a（数组下标为0的元素）
print(type(arr)); # 输出：<class 'list'>
print(type(arr[0])); # 输出：<class 'str'>

元组（tuple）

核心特性：不可变，有序，可重复

定义方式：() 包裹，元素用，分隔

arr = (1,'a',True) #创建元组
print(arr) #输出：(1, 'a', True)

字典（dict）

核心特性：可变，键唯一，无序（3.7 + 有序）

定义方式：{} 键值对 {k:v}

# 创建字典类型
user = {
    'name' : 'John',
    'age' : 22,
}
print(user) # 输出：{'name': 'John', 'age': 22}
print(user['name']) # 输出：John
print(user.get('age')) # 输出：22

集合（set）

核心特性：可变，无序，无重复

定义方式：{} 或 set ()

# 定义（空集合必须用set()，{}是空字典）
s = {1, 2, 2, 3}  # 自动去重 → {1,2,3}
s2 = set([3, 3, 4, 5])  # 列表转集合,自动去重
print(s) # {1, 2, 3}
print(s2) # {3, 4, 5}
# 集合运算
print(s & s2)  # {3}（交集：同时存在的元素）
print(s | s2)  # {1,2,3,4,5}（并集：所有元素）
print(s - s2)  # {1,2}（差集：s有但s2没有的元素）

运算符

运算符分为 6 大类

算术运算符（数值计算）

运算符	作用	示例	结果
+	加法	10 + 3	13
-	减法	10 - 3	7
*	乘法	10 * 3	30
/	除法	10 / 3	3.333
//	整除（取整）	10 // 3	3
%	取余	10 % 3	1
**	幂运算	10 ** 2	100

赋值运算符（给变量赋值）

a = 10          # 基础赋值
a += 3          # 等价于 a = a + 3 → a=13
a -= 2          # 等价于 a = a - 2 → a=11
a *= 2          # 等价于 a = a * 2 → a=22

比较运算符（判断关系，返回布尔值）

运算符	作用	示例	结果
==	等于	10 == 10	True
!=	不等于	10 != 3	True
>	大于	10 > 3	True
<	小于	10 < 3	False
>=	大于等于	10 >= 10	True
<=	小于等于	10 <= 3	False

逻辑运算符（组合条件判断，返回布尔值）

运算符	作用	示例	结果
and	与（都真才真）	True and False	False
or	或（有真就真）	True or False	True
not	非（取反）	not True	False

成员运算符（判断元素是否在集合中）

运算符	作用	示例	结果
in	元素在容器中	"a" in "abc"	True
not in	元素不在容器中	4 not in [1,2,3]	True

身份运算符（判断变量是否指向同一内存地址）

运算符	作用	示例	结果
is	地址相同	a=10; b=10; a is b	True
is not	地址不同	a=[1]; b=[1]; a is b	False

注意：is 不等于 == (== 判断值，is 判断地址）

a = [1,2]
b = [1,2]
print(a == b)  # True（值相同）
print(a is b)  # False（地址不同）

流程控制

条件判断（if-elif-else）

if 1 == 1:
    print('1等于1是真');
else:
    print('假')
# 结果：1等于1是真

a = 2
if a == 1:
    print('a == 1')
elif a == 2:
    print('a == 2')
else:
    print('a未知')
# 结果：a == 2

三目运算符（简化 if-else）

将简单的 if-else 语句简化为一行代码

dog = '狗'
# 普通if语句
if dog == '狗':
    print('是狗')
else:
    print('不是狗')

# 三目运算
print( '是狗' if dog == '狗' else '不是狗')

循环（for /while）

for 循环：遍历 "可迭代对象"（列表、字符串、range 等），执行固定次数；

while 循环：只要条件成立，就持续执行（次数不固定）。

for 循环（遍历型循环）

1. 遍历列表 / 字符串

# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit) # 依次输出：苹果 香蕉 橙子

# 遍历字符串
s = "hello"
for char in s:
    print(char)  # 依次输出：h e l l o

2. 遍历数字序列（range () 函数）
   range(start, end, step)：生成从start到end-1的整数序列，step是步长（默认 1）

# 遍历1-5（range(1,6) → 1,2,3,4,5）
for i in range(1, 6):
    print(i)

# 步长为2：1,3,5
for i in range(1, 7, 2):
    print(i)

# 从0开始（省略start）：0,1,2,3,4
for i in range(5):
    print(i)

3. 遍历字典（常用方式）

user = {"name": "小明", "age": 18, "gender": "男"}
for k, v in user.items():
    print(k,v)
# 输出为以下内容：
# name 小明
# age 18
# gender 男

while 循环（条件型循环）

i = 1
while i < 3 :
    print(i) # 输出：1 2
    i+=1

循环控制关键字（break/continue/pass）

关键字	核心作用	示例场景
break	立即终止整个循环，后续循环不再执行	找到目标值后停止循环
continue	跳过当前次循环的剩余代码，直接进入下一次	过滤掉不需要的元素
pass	空语句，仅占位（无任何操作）	暂时没想好代码，先占位置

基础函数

函数的核心价值是封装可复用的代码块，把重复执行的逻辑抽离成函数，避免代码冗余。

函数的定义与调用（创建函数并调用）

# 创建函数
def say_hello():
    print('hello');

#调用函数say_hello
say_hello(); # 输出：hello

def toSomeOneSayHello(name):
    print(f'{name} hello');

#调用函数toSomeOneSayHello
toSomeOneSayHello('xiri'); # 输出：xiri hello

函数的参数

位置参数

定义：函数定义时按顺序声明的参数，调用时必须按顺序、按个数传入值；

特点：缺一不可、顺序严格；

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

result = num_sum(1,2)
print(result)

关键字参数

定义：调用函数时，通过参数名=值的形式传参，顺序可任意；

特点：可读性高，可混合位置参数（但位置参数必须在前）；

def print_info(name,age):
    print(f'{name} 是 {age} 岁哦')

# 纯关键字传参（顺序任意）
print_info(age=18,name='张三') # 输出：张三 是 18 岁哦

默认参数

定义：函数定义时给参数指定默认值，调用时可省略该参数（使用默认值）；

特点：可选传参，默认值仅在函数定义时初始化一次；

#给age设置默认值，可以不传参
def print_info(name,age=18):
    print(f'{name} 是 {age} 岁哦')

# 纯关键字传参（顺序任意）
print_info(age=19,name='张三') # 输出：张三 是 19 岁哦
#使用默认值
print_info(name='李四') # 输出：李四 是 18 岁哦

可变参数

1. 可变位置参数 *args

定义：函数定义时用*args，调用时可传入任意数量位置参数，内部打包成元组

def print_num(*args):
    #进行对元组遍历
    for s in args:
        print(s)

print_num(1,2,3) # 依次输出：1 2 3

2. 可变关键字参数 **kwargs

定义：函数定义时用**kwargs，调用时可传入任意数量关键字参数，内部打包成字典

def print_info(**kwargs):
    for k,v in kwargs.items():
        print(k,v)

print_info(name="zs",age=18) # 依次输出：name zs，age 18

3. 参数组合顺序（重要）

当函数同时使用多种参数时，必须遵循以下顺序：位置参数 → 默认参数 → *args → 关键字参数 → **kwargs

函数的返回值

返回值是函数执行后给调用者的 "结果"，通过return关键字实现。
核心规则

return 会立即终止函数执行（后续代码不运行）；

无return的函数，默认返回None；

可返回单个值、多个值（实际返回元组）、任意类型（列表 / 字典 / 函数等）。

无返回值（默认返回 None）

def print_name(name):
    print(name)

result = print_name('张三')
print(result) # 输出：None

返回单个值

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

print(sum(1,2)) # 输出：3

返回多个值（自动打包成元组）

def getInfo():
    return '张三',18

print(getInfo()) # 输出：('张三', 18)

局部变量与全局变量（作用域）

类型	定义位置	可访问范围	修改规则
局部变量	函数内部	仅函数内部	直接定义 / 修改，不影响外部
全局变量	函数外部（全局）	整个程序（函数内可只读）	函数内修改需用global关键字

基础 IO

控制台 IO：print（输出）& input（输入）

print：向控制台输出内容

核心作用：将数据打印到控制台，是程序 "输出结果" 的基础。

关键参数说明（日常开发高频用前 3 个）：

objects：要输出的内容（多个用逗号分隔）；

sep：多个内容之间的分隔符（默认空格）；

end：输出结束后追加的字符（默认换行符\n）。

print('hello', sep=' ', end='\n') #输出：hello
import sys
print('123', sep=' ', end='\n', file=sys.stdout, flush=False) #输出：123

input：从控制台获取用户输入

核心作用：暂停程序运行，等待用户输入文本，按回车后返回输入内容（默认返回字符串类型）。

name = input("请输入你的姓名：") #输入：zs
print(f"你的名字：{name}") #输出：你的名字：zs

文件 IO：文件读写（open + with 语句）

核心作用：程序与磁盘文件交互（读取文件内容、写入内容到文件），Python 中通过open函数打开文件，结合with语句可自动关闭文件（避免资源泄漏）。

文件打开模式（open 函数的关键参数）

模式	含义	注意事项
r	只读（默认）	文件不存在则报错
w	只写（覆盖写）	文件不存在则创建，存在则清空内容
a	追加写	文件不存在则创建，内容追加到末尾
r+	读写（先读，写覆盖）	文件不存在则报错
w+	读写（先清空，再写 / 读）	文件不存在则创建
a+	追加读写（写追加，读需先移动指针）	文件不存在则创建
b	二进制模式（如rb/wb）	用于非文本文件（图片、视频等）

with 语句（推荐写法）

with是 "上下文管理器"，会在代码块结束后自动调用 close () 关闭文件，避免手动关闭遗漏导致的资源占用。

文件读取（核心：r 模式）

常用读取方法：

read()：读取全部内容（返回字符串）；

readline()：读取一行内容（返回字符串）；

readlines()：读取所有行（返回列表，每行是一个元素）。

使用文件IO

with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello Python!\n")  # \n表示换行
    f.write("文件写入示例")

创建文件并且写文本内容

with open("output.txt", "r", encoding="utf-8") as f:
    print(f.read())
    print(f.read())

读取文件文本内容

异常处理（try-except-else-finally）

程序运行时的错误（如文件不存在、类型错误、除以零）称为 "异常"，若不处理会导致程序崩溃；异常处理可捕获错误并优雅处理，保证程序继续运行。

常见异常类型

异常类型	触发场景
TypeError	类型错误（如字符串和数字相加）
FileNotFoundError	文件不存在（如 r 模式打开不存在的文件）
ValueError	值错误（如 int ("abc")，字符串无法转整数）
ZeroDivisionError	除以零（如 10/0）
IndexError	索引越界（如列表取不存在的索引）
KeyError	字典键不存在

异常处理核心语法

try:
    # 可能触发异常的代码块（重点：只放可能出错的代码）
except 异常类型1:
    # 捕获到异常类型1时执行的代码
except 异常类型2 as e:
    # 捕获到异常类型2时执行，e是异常对象（可查看错误信息）
else:
    # try代码块无异常时执行（可选）
finally:
    # 无论是否有异常，最终都会执行（可选，常用于释放资源）

使用异常处理

try:
    a = 0/0
except Exception as e:
    print(e) #输出：division by zero