Python 基础笔记
数据的输入和输出
print("数据") # 这是数据的输出
name = input() # 这是数据的输入，并将输入的数据赋值给name。而且无论输入的何种类型的数据，最终的结果都是 字符串 类型的数据
pint 输出不换行：
# print 输出会自动换行
print('hello', end='')
print('hello', end='')
# 加上end='' 即可输出不换行
数据类型
type(被查看类型的数据) -> 来验证数据的类型
字符串
字符串的定义方式
text1 = '我是字符串'
test2 = "我也是字符串"
test3 = """我即是字符串，还能做注释"""
字符串的引号嵌套
字符串本身包含引号，双引号：
- 单引号内可以包含双引号，双引号内也可以包含单引号
- 可以使用转义字符（ \ ）来将引号解除效用，变成普通字符
字符串拼接
字符串之间直接用+拼接，字符串无法和非字符串进行拼接
字符串格式化
- 格式化方法一：
price = '9.15'
cloth = 'shirt'
message = 'the price of the %s is %f' % (cloth, price)
print(message)
%表示占位，s表示将变量变成字符串放入占位的地方，d表示把内容变成整数放入占位的地方，f表示把内容变成浮点数放入占位的地方
- 格式化方法二：
price = '9.15'
cloth = 'shirt'
print(f'the price of the {cloth} is {price}')
注：这种写法不做精度控制，也不理会类型
表达式的格式化
print("1 + 1 的结果是：%d" % (1 + 1))
print(f"1 + 1 的结果是：{1 + 1}")
格式化的精度控制
-
m，控制宽度，要求是数字，设置宽度小于自身时不生效 -
n，控制小数点精度，要求是数字，会进行四舍五入例：对11.345设置
%7.2f后，结果是[空格][空格]11.35。小数点和小数部分都算入宽度计算。只有%7f或者%.2f都是合理的。
数据类型转换
-
int(x)：将x转换为一个整数
-
float(x)：将x转换为一个浮点数
-
str(x)：将对象x转换为字符串
注：
- 任何类型都可以通过str() 转换为字符串
- 字符串内必须真的是数字，才可以将字符串转换为数字
None类型
应用：
- 函数无返回值
if判断，等同于False- 定义变量不需要具体值： name = None
注释
# 我是单行注释
"""
我是多行注释
"""
运算符
算术运算符
赋值运算符
判断语句
age = 10
if age < 18:
print('我要学习')
elif age < 25:
print('我要谈恋爱')
else:
print('我要挣钱养家')
# 当需要判断多个条件
# if x > 0 and y > 0
# if x > 0 or y > 0
循环语句
while循环
j = 0
while j < 5:
print('循环print')
j += 1
# 循环 n 次
for i in range(n):
# 遍历文件 f 的每一行
for line in f:
# 遍历字符串
for c in s:
# 遍历列表 ls
for item in ls
# 扩展模式(else语句只在循环正常执行并结束后才会执行，比如中间break就不会执行else)，while 同理
for s in "BIT":
print("循环进行中: "+s);
else:
s = "循环正常结束"
print(s)
for循环
name = "kun"
for x in name
print(x) # 会遍历输出字符串的每个字符
for i in range(5)
print(i) # 循环遍历range序列
range语句
range(num) # 获取一个从 0 开始，到 num （不含num）结束的数字序列
range(num1, num2) # 获取一个从 num1 开始，到 num2 （不含num2）结束的数字序列
range(num1, num2, step) # 获取一个从 num1 开始，到 num2 （不含num2）结束的数字序列，step为步长
# 如 range(5, 10, 2) -> [5, 7, 9]
continue 和 break
- continue 用于中断本次循环，直接进入下一次循环
- break 用于直接结束所在循环
函数
函数定义
# 函数定义
def 函数名(传入参数):
函数体
return 返回值
# 函数调用
函数名(参数)
f = lambda x, y : x + y
print(f(1, 2)) # 3
def fn1(num, str2 = "str2"):
print(num*str2)
fn1(2) # str2str2
# 可选参数必须定义在非可选参数的后面
# 带 * 表示可变数量参数，只能出现在参数列表的最后
def fun(a, *b) :
print(type(b))
for n in b:
a += n
print(a)
fun(1,2,3,4,5) # <class 'tuple'> 15
def fn(num, str2):
print(num*str2)
fn(str2 = 2, num = "str22")
def func1(a,b):
return a,b
result = func1(1,2)
print(result, type(result)) # (1, 2) <class 'tuple'>
n = 1
def func2(a, b):
global n
n = b
return a * b
s = func2(1, 2)
print(n) # 2
# 列表等组合数据类型的操作都是对已创建列表的引用
ls = []
def func3(a, b):
ls.append(b)
return a * b
s = func3("str", 2)
print(s, ls) # strstr [2]
# 递归
def func4(n):
if n == 1:
return 1
return n * func(n - 1)
# 字符串反转
def reverse(s):
return reverse(s[1:]) + s[0] if s else "" # 终止条件：如果输入字符串为空，则递归终止，返回空字符串。
# 等同于
def func(s):
if s == "":
return s
else:
return func(s[1:]) + s[0]
注：
- 参数或返回值如不需要，可以省略
- 函数必须先定义后使用
# 找出以下代码中的问题：
x = 50
def func():
print(x)
x = 100
func()
# 在函数内部，当我们对变量进行赋值时，Python会将其视为一个局部变量，并覆盖同名的全局变量。因此，在函数func中，对x赋值后，会创建一个新的局部变量x，并将其值设置为100。然而，在print(x)这一行尝试访问x时，由于该局部变量尚未被赋值，Python将抛出一个UnboundLocalError异常。
# 为了解决这个问题，你可以在函数内部通过global关键字来声明对全局变量进行操作，即将x声明为全局变量。
# 在函数内部使用global关键字时，只能用于声明对全局变量进行操作，而不能用于直接定义全局变量。
global 关键字
num = 100
def testA():
print(num)
def testB():
# global 关键字在函数内部声明变量为全局变量
global num
num = 200
print(num)
testA() # 100
testB() # 200
print(f'num = {num}') # num = 200
随机数
# 引用
from random import *
# 或者 import random
num = random.randint(1, 100) # 生成 1~100 之间的随机数，包括 1 和 100
# 随机数种子是一个整数，种子相同，每次生成的随机数也相同。
数据容器
分类
- 列表（list）
- 元组（tuple）
- 字符串（str）
- 集合（set）
- 字典（dict）
list（列表）
变量名称 = [元素1, 元素2, …]
这些元素数据可以为不同的数据类型
索引: 1. 从前往后 0 ~ n 2. 从后往前 -1 ~ -n
列表的常用操作（方法）
-
查
# 列表.index(元素) 查找索引值，找不到报错：ValueError # 统计列表中有多少元素 len(列表) -
改
# 列表[下标] = 值 # 插入：列表.insert(下标, 元素) # 追加：1. 列表.append(元素) 2. 列表.entend(其他数据容器) -> 将其他数据容器的内容取出进行追加 # 删除： 1. del 列表[下标] # 2. 列表.pop(下标) # 3. 删除某元素在列表中的第一个匹配项 列表.remove(元素) # 4. 清空列表内容 列表.clear() # 5. 统计某元素在列表中的数量 列表.count(元素)
列表的遍历
# while 循环
index = 0
while index < len(列表):
print('列表[index]')
index += 1
# for 循环
for i in 列表:
print(i) # 每一个循环将列表中的元素取出，赋值给 i
tuple（元组）
# 元组一旦定义完成，就不可修改内容
# 定义元组 当只有一个元素，要在后面加`,`
变量名称 = (元素, 元素, ...)
# 定义空元祖
变量名称 = () # 方式一
变量名称 = tuple() # 方式二
# 但是可以修改里面的list的内容，不可以替换list为其他的list或其他类型
t1 = (1, 2, ['kun', 'c'])
t1[2][1] = 'cc' # 正确
t1[2] = [1, 2, 3] # 错误
元组的相关操作
str（字符串）
同样可以通过下标访问每个字符。字符串也是无法修改的，对其操作只会得到新字符串，原本字符串仍然不变。
字符串的常用操作
len()：返回字符串的长度（字符数量）。lower()和upper()：分别将字符串中的字符转换为小写或大写形式。strip()、lstrip()和rstrip()：去除字符串两端或指定一侧的空格或其他指定字符。split()：将字符串按照指定的分隔符分割成一个列表。join()：将列表中的元素连接成一个字符串，使用指定的连接符。replace()：替换字符串中的指定字符或子字符串。startswith()和endswith()：判断字符串是否以指定的前缀或后缀开头或结尾。isalpha()、isdigit()、isalnum()、isspace()等：检查字符串是否只包含字母、数字、字母和数字的组合或空格。find()和index()：在字符串中查找指定的子字符串，并返回其第一个出现的位置。count()：计算指定子字符串在字符串中出现的次数。isdigit()和isnumeric()：检查字符串是否仅由数字组成。capitalize()：将字符串的首字母大写。swapcase()：将字符串中的字母大小写互换。
# 查 - 字符串.index(字符串1) 查找某段字符1的首字符索引
# 替换 - 字符串.replace(字符串1, 字符串2) 将字符串1的内容替换为字符串2，得到一个新的字符串
# 分割 - 字符串.split(分割字符串的符号) 得到一个新的列表对象
# 规整 - 字符串.strip() 去掉前后的空格
# - 字符串.strip(字符串1) 去掉前后指定字符（串1）
# 统计次数 - 字符串.count(字符串1)
数据容器（序列）的切片
序列：内容连续、有序，可使用下标索引的一类数据容器。比如：列表、元组、字符串…
# 切片：从一个序列中取出一个子序列，得到新的序列
# 序列[起始下标:结束下标:步长]
# 起始下标留空视为从头开始，结束下标留空视为截取到结尾，步长是负数为反向截取，截取元素不含结束下标
set（集合）
定义集合 变量名称 = {元素, 元素, …} 空集合 -> 变量名称 = set()
与列表和元组不同的是，集合是无序的，且不允许重复元素。集合对象在遍历时不保证元素的顺序，导致for不能遍历集合。
集合常用功能
dict（字典、映射）
# 定义字典变量
my_dict = {key1: value1, key2: value2, ...}
# 定义空字典
my_dict1 = {}
my_dict2 = dict()
# 获取value
my_dict["key1"] # value1
字典的常用操作
# 遍历字典
stu_score = {
'a': 23,
'b': 34
}
keys = stu_score.keys()
for key in keys:
print(f"学生：{key}, 分数：{stu_score[key]}")
数据容器通用功能
统计功能
- len(容器)：统计容器中元素的个数
- max(容器)：统计容器中最大的元素
- min(容器)：统计容器中最小的元素
转换功能
- list(容器) - 将给定容器转换为列表
- str(容器) - 将给定容器转换为字符串
- tuple(容器) - 将给定容器转换为元组
- set(容器) - 将给定容器转换为集合
排序功能
sorted(容器, [reverse=True]) - 排序后都会得到列表（list）对象 - reverse=True表示降序
函数进阶
函数多返回值
def test_return()：
return 1, 2
x, y = test_return()
print(x) # 1
print(y) # 2
函数多种传参方式
位置参数
传递的参数和定义的参数的顺序及位置个数必须一致
def user_info(name, age):
print(f'your name is {name}, age id {age}')
user_info('kun', 20)
关键字参数
函数调用时，如果有位置参数，位置参数必须是在关键字参数前面，且顺序一定；关键字参数之间不存在先后顺序
def user_info(name, nickname, age, gender):
print(f"your name is {name}, nickname is {nickname}, age is {age}, gender is {gender}")
user_info("kun", "kunkun", gender="male", age=20)
缺省参数（默认参数）
为参数提供默认值，调用函数时可以不传该默认参数的值（所有位置参数必须出现在默认参数前，包括函数定义和调用）
不定长参数（可变参数）
-
位置传递
def user_info(*args): print(args) user_info('kun', 20) # 传递的所有参数都会被args变量收集，然后合并成一个元组 -
关键字传递
def user_info(**kwargs): print(kwargs) user_info(name="kun", age=18, id=100) # 参数是键值对的形式下，kwargs会根据键值对组成字典
匿名函数
函数作为参数传递
def test_func(compute):
result = compute(1, 2)
print(result)
def compute(x, y):
return x + y
lambda匿名函数
lambda关键字定义匿名函数，只可临时使用一次
def test_func(compute):
result = compute(1, 2)
print(result)
test_func(lambda x, y: x + y) # result = 3
文件操作
文件的读取
open() 打开函数
# open(name, mode, encoding)
# name：要打开的目标文件名的字符串（可以包含文件所在的具体路径）
# mode：设置打开文件的模式（访问模式）：只读，写入，追加等
# encoding：编码格式（推荐使用UTF-8）
f = open("C:/python.txt", 'r', encoding="UTF-8")
# 这个函数实际上有很多参数,encoding并不在第三位,所以不能用位置参数,要用关键字参数直接指定
# f 这里是文件对象，拥有属性和方法
mode 常用的三种基础访问模式
操作汇总
文件的写入
f = open('python.txt', 'w')
# 文件如果存在，'w'模式将原有内容清空；如果不存在，创建新文件
f.write("hello world")
# 内容刷新
f.flush()
# 直接调用write，内容写到内存（缓冲区），未写入文件；flush调用时，写入文件
文件的追加
f = open('python.txt', 'a')
# 文件如果存在，'a'模式将追加写入；如果不存在，创建新文件
f.write("hello world")
f.flush()
异常、模块与包
异常
# 捕获常规异常
try:
可能发生错误的代码
except:
如果出现异常，则改为该代码执行
# 捕获指定异常
try:
print(name)
# NameError 捕获到输入类型错误 或者 写成：except NameError:
except NameError as e:
print("name 变量名称为定义错误") # 直接print(e) 则会输出描述信息
# 如果尝试执行的代码（print(name)）的异常类型和要捕获的异常类型（NameError）不一致，则无法捕获异常，其中 e 可以是任意别名
# 一般try下方只放一行尝试执行的代码
# 捕获多个异常
try:
print(1/0)
except(NameError, ZeroDivisionError): # 要捕获异常类型的名字，用元组的方式书写
print("ZeroDivision错误...")
# 捕获所有异常
try:
print(name)
except Exception as e:
print(e)
# 没有异常时， 还会执行的代码
try:
print(1)
except Exception as e:
print(e)
# else 当 try 中语句块正常执行且没有发生异常时会执行
else:
print("我是else，是没有异常时还会执行的代码")
# 无论是否有异常时都会执行的代码
try:
f = open("test.txt", 'r')
except Exception as e:
f = open("test.txt", 'w')
else:
print("没有异常")
finally:
f.close() # 无论是否有异常时都会执行的代码
# 异常具有传递性，故可以在main()函数中设置捕获异常，确保所有异常都会被捕获
模块
模块的导入
# [from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]
# 导入模块
# import 模块名1，模块名2...
import time
print("start")
time.sleep(1) # 让程序睡眠1s（阻塞）
print("end")
# from time import sleep 导入时间模块中的sleep方法
# 直接 sleep(1) 即可
# from time import * 导入时间模块中的所有方法
自定义模块
测试模块：
# my_module1.py
def test(a, b):
print(a + b)
test(1, 1) # 测试代码
# 为解决 不论是当前文件还是其他已经导入该模块的文件，运行时都会自动执行`test`函数的调用 的问题
# my_module1.py
def test(a, b):
print(a + b)
# 只有在当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行test函数调用
if__name__ == '__main__':
test(1, 1) # 测试代码
# 当导入多个模块时，且模块内有同名功能，调用到的是最后导入的模块的功能
# 如果一个模块文件中有`__all__`变量，当使用`from xx import *`导入时，只能导入这个列表中的元素 例：`__all__ = {'test_A'}` -> 只能导入`test_A`函数
包
自定义包
导入方式：
- import 包名.模块名.方法名
- 在
__init.py文件中添加__all__ = []，控制允许导入的模块列表
安装第三方包
- 打开命令提示符，输入
pip install 包名称，或者通过国内清华镜像网站安装，输入pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称 - 通过PyCharm安装第三方包
面向对象
类和对象
# 设计类
class Student:
name = None # 类的属性，成员变量
def say_hi(self, msg): # 类的行为，成员方法，self必须填写
print(f"hi~,我是{self.name}，{msg}")
# 创建类对象
stu = Student()
# 对象属性赋值，调用成员方法
stu.name = "kun"
stu.say_hi("很高兴认识大家") # seld代表类自身，传参时只看后面的参数
构造方法
类中使用__init__方法，成为构造方法
class Student:
name = None
age = None
def __init__(self, name, age):
self.name = name
self.age = age
stu = Student("kun", 28)
其他内置方法
在Python中，所有以双下划线__包起来的方法，统称为Magic Method（魔术方法），它是一种的特殊方法，普通方法需要调用，而魔术方法不需要调用就可以自动执行。
__str__字符串方法
当类对象需要被转换为字符串时，会输出（print(student)）内存地址，可通过该方法，控制类转换为字符串的行为。
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"Student类对象，name={self.name}，age={self.age}"
student = Student("kun", 29)
print(student) # Student类对象，name=kun，age=29
__lt__小于符号比较方法
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __lt__(self, other):
return self.age < other.age
stu1 = Student("kun", 11)
stu2 = Student("kunkun", 13)
print(stu1 < stu2) # True
# 大于比较符号是`__gt__`
__Le__小于等于比较符号
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __le__(self, other):
return self.age <= other.age
stu1 = Student("kun", 11)
stu2 = Student("kunkun", 13)
print(stu1 <= stu2) # True
# 大于比较符号是`__ge__`
__eq__比较运算符实现方法
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __eq__(self, other):
return self.age == other.age
stu1 = Student("kun", 11)
stu2 = Student("kunkun", 11)
print(stu1 == stu2) # True
# 不使用`__eq__`比较的是内存地址
封装
封装：定义类，描述属性和方法。
私有成员
变量名或者方法名以__开头即为私有成员变量或者私有成员方法。私有方法无法直接被类对象使用，私有变量无法被类对象赋值，也无法获取值。但是类内其他成员访问私有成员。
继承
单继承和多继承
# 单继承
class Phone:
producer = None
def call_by_4g(self):
print('4g通话')
class Phone2023(Phone):
face_id = True
def call_by_5g(self):
print('5g通话')
# 多继承
# class 类名(父类1，父类2，...): # 同名继承，左边的父类优先级更高
# 类内容体 # pass关键字是占位语句，表示类定义完整，但无内容
复写
class Phone:
producer = "MI"
def call_by_5g(self):
print('父类5g通话')
class Phone2023(Phone):
producer = "GUO" # 复写父类属性
def call_by_5g(self):
print('子类5g通话') # 复写父类方法
#方式1调用父类成员
print(f"父类的producer是：{Pyone.producer}")
Phone.call_by_5g(self)
#方式2调用父类成员
print(f"父类的producer是：{super().producer}")
super().call_by_5g()
phone = Phone2023()
phone.call_by_5g() # 通过子类调用复写后的方法 和 调用父类原成员
# 一旦复写父类成员，那么类对象调用成员时，就会调用复写后的新成员。如需使用被复写的父类的成员，只能在子类内调用父类原有的的同名成员，子类的类对象直接调用会调用子类复写的成员
类型注解
类型注解只是对开发者的提示作用，不是决定性的。
# 变量的类型注解
var_1: int = 10
class Student:
pass
stu: Student = Student()
my_list: list = [1, 2, 3]
my_tuple: tuple[str, int bool] = ("kun", 23, True)
# 如果将元组设置类型详细注解，需要将每一个元素标记出来
# 字典设置类型详细注解，需要2个类型，key和value
# 除了 变量: 这种方式，还可以在注释中进行类型注解
class Student:
pass
var_1 = random.randint(1, 20) # type: int
var_2 = json.loads(data) # type: dict[str, int]
var_3 = func() # type: Student
def add(x: int, y: int) -> int:
return x + y
# Union类型
from typing import Union
my_list: list[Union(int, str)] = [1, 2, 'kun']
my_dict: dict[str, Union[str, int]] = {"name": "kun", "age": 32}
def func(data: Union[int, str]) -> Union[int, str]:
pass
多态
完成某个行为时，不用的对象会得到不同的状态
class Animal:
def speak(self): # 抽象类（接口）：含有抽象方法
pass # 抽象方法：方法体是空实现
class Dog(Animal):
def speak(self):
print("wang")
class Cat(Animal):
def speak(self):
print("miao")
def make_noise(animal: Animal):
animal.speak()
dog = Dog()
cat = Cat()
make_noise(dog) # wang
make_noise(cat) # miao
扫一扫
308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
