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转换为字符串

  注：

  1. 任何类型都可以通过str() 转换为字符串
  2. 字符串内必须真的是数字，才可以将字符串转换为数字

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]}")

数据容器通用功能

统计功能

1. len(容器)：统计容器中元素的个数
2. max(容器)：统计容器中最大的元素
3. min(容器)：统计容器中最小的元素

转换功能

1. list(容器) - 将给定容器转换为列表
2. str(容器) - 将给定容器转换为字符串
3. tuple(容器) - 将给定容器转换为元组
4. 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)

缺省参数（默认参数）

为参数提供默认值，调用函数时可以不传该默认参数的值（所有位置参数必须出现在默认参数前，包括函数定义和调用）

不定长参数（可变参数）

1. 位置传递

   def user_info(*args):
       print(args)
   user_info('kun', 20)
   # 传递的所有参数都会被args变量收集，然后合并成一个元组
   

2. 关键字传递

   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`函数

包

自定义包

导入方式：

1. import 包名.模块名.方法名
2. 在__init.py文件中添加__all__ = []，控制允许导入的模块列表

安装第三方包

1. 打开命令提示符，输入pip install 包名称，或者通过国内清华镜像网站安装，输入pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
2. 通过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