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}")
格式化的精度控制
数据类型转换
-
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('我要挣钱养家')
循环语句
while循环
i = 0
while i < 5:
print('循环print')
i += 1
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 返回值
# 函数调用
函数名(参数)
注：
- 参数或返回值如不需要，可以省略
- 函数必须先定义后使用
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
随机数
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（字符串）
同样可以通过下标访问每个字符。字符串也是无法修改的，对其操作只会得到新字符串，原本字符串仍然不变。
字符串的常用操作
# 查 - 字符串.index(字符串1) 查找某段字符1的首字符索引
# 替换 - 字符串.replace(字符串1, 字符串2) 将字符串1的内容替换为字符串2，得到一个新的字符串
# 分割 - 字符串.split(分割字符串的符号) 得到一个新的列表对象
# 规整 - 字符串.strip() 去掉前后的空格
# - 字符串.strip(字符串1) 去掉前后指定字符（串1）
# 统计次数 - 字符串.count(字符串1)
数据容器（序列）的切片
序列：内容连续、有序，可使用下标索引的一类数据容器。比如：列表、元组、字符串…
# 切片：从一个序列中取出一个子序列，得到新的序列
# 序列[起始下标:结束下标:步长]
# 起始下标留空视为从头开始，结束下标留空视为截取到结尾，步长是负数为反向截取，截取元素不含结束下标
set（集合）
# 定义集合 变量名称 = {元素, 元素, ...} 空集合 -> 变量名称 = set()
# 变量结果会进行去重且无序
集合常用功能
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)
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:
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./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
|
