Python学习笔记

Python学习笔记

学习地址

https://player.bilibili.com/player.html?bvid=BV1eZ421b7ag&autoplay=0

Print

1、print（’xxx’,’xxx1’,seq=”*”,end=’\n’） #seq多个字符串以什么间隔，最后以\n结束

2、打印内容

3、print(‘xxx%d,xxx%.2f’%(age,name)) print(f’xxx{name}xxx{age}’)

input

a = input(‘请输入你的名字’)

看变量是什么类型 type(a) isinstance(a,str)

用户输入的任何内容Python都认为是一个字符串

变量

代码：处理数据用的

变量：存储数据的

变量定义之后，后续就可以直接使用了

变量必须先定义后使用

=两遍要留一个空格

**变量的命名规则：**1、必须由字母、数字、下划线组成 2、不能以数字开头 3、严格区分大小写 4、不能使用内置关键字

常量

程序再运行的过程中，值永远不会发生改变的量称之为常量

python没有专门的变量类型，一般约定大写代表常量

标识符就是程序员定义的变量名、函数名 名字需要有见名知义的效果

标识符可以由字母、下划线和数字组成 不能以数字开头 不能与关键字重名

关键字就是在Python内部已经使用的标识符

关键字具有特殊的功能和含义

开发 这不允许定义和顾安安子相同的名字的标识符

关键字查看方式：

1
2
import keyword
print(keyword.kwlist)

命名规则：

命名规则可以被视为一种惯例，并无绝对与强制

目的是为了增加点的识别和可读性

在Python中，如果变量名需要有二个或多个多个单词组成时，可以按照一下方式命名

  • 每个单词都使用小写字母
  • 单词与单词之间使用_下划线链接
  • 驼峰命名法：小驼峰、大驼峰

数据类型：

整型（Integers）、浮点数、复数、布尔型、字符串、列表、元组（类似list，不可变）、集合、字典

浮点数：四舍五入 n3 = round(n1+n2,2) 向上取整 n4 = math.ceil(n1+n2)

向下取整 n4 = math.floor(n1+n2)

数据类型转换：

bool(‘xxx’) 有内容判断为真 空字符串为False

进制转换：s = ‘1a’ print(int(s,16))

Python中的小整数，通常指的是-5至256之间的整数 小整数缓存池 id()函数功能获取变量地址

运算符和表达式

算数运算法

+-*/ // % **

/默认保留一位小数

赋值运算符

= += -= /= //= %= **=

比较运算符

== != > < >= <=

字符串的比较运算：每个字符的ascii码值

逻辑运算符

and or not 与或非

位运算符

& 按位与

| 按位或

^ 按位异或

~ 按位取反

<< 左移动运算符

>> 右移动运算符

在计算机中，数字存储时最高位为符号位，
符号位为0时表示正数，符号位为1时表示负数。
数字在计算机中是以补码的形式进行存储的，
整数的补码与原码相同，
负数的补码是在原码的基础上除符号位外，按位取反后，再加1.

+1，原码为0 0001，补码为 0 0001.
-1 ，原码为1 0001，补码为：1 1111。
+2，原码为：0 0010，补码为：0 0010.
-2，原码为：1 0010，补码为：1 1110

负数 -1 取反得到原码

成员运算符

in 如果在指定的序列中找到值返回True，否则返回False

not in 如果在指定的序列中没有找到值返回True，否则返回False

运算符优先级

算数运算符 > 按位运算符 > 比较运算法 > 赋值运算法 > 成员运算法 > 逻辑运算法

0.1+0.2是不等于0.3 

1
2
3
4
from decimal import Decimal
a = Decimal('0.1')
b = Decimal('0.2')
print(a + b) # 输出 0.3

小数10进制转2进制方法：

0.5125乘2,得1.025所以2进制小数第一位是1
0.025乘2, 得0.05所以2进制小数的第二位是0
0.05乘以2,得0.1所以2进制小数的第三位是0
0.1乘以2, 得0.2所以2进制小数的第四位是0
0.2乘以2, 得0.4所以2进制小数的第五位是0
0.4乘以2, 得0.8所以2进制小数的第六位是0
0.8乘以2, 得1.6所以2进制小数的第七位是1
0.6乘以2, 得1.2所以2进制小数的第八位是1
所以(0.5125)10 = (0.10000011)2

条件判断

单分支选择结构

if 要判断的条件：

条件成立时，要做的时期…

多分支选择结构

if 条件1 :

elif 条件2：

elif 条件3：

else

嵌套选择

if 条件1：

if 条件2：

match语句

python3.10及以后版本中引入的新特性，用于模式匹配

它允许你根据对象的模式来检查对象，并执行相应的代码快

1
2
3
4
5
6
7
8
x = 10
match x :
 case 1:
     print("x is 1")
 case 2:
     print("x is 2")
 case _:
     print("x is not 1 or 2")

match语句特别适用于处理复杂的数据结构，如元组、列表、字典等，以及自定义类的实例。

列表[] 元组() 字典{}

代码规范：四个空格或者一个tab键为一个缩进

判断你是数字

>>> a = ‘1’

>>> print(a.isdigit())

True

判断闰年的经验：普通闰年的年份是4的倍数，且不是100的倍数；世纪闰年的年份必须是400的倍数

循环

while

循环的作用就是让指定的代码重复的执行

while循环最常用的应用场景就是让执行的代码按照指定的次数重复执行

1
2
while 条件：
    print("hello python!")

for

1
2
3
for i in rang(5):
    print("hello world!")
print(list(rang(10)))

break

作用：退出循环

注意：只能跳出距离最近的for或者while循环

continue

作用：跳过本次循环后面的剩余语句，然后继续下一次循环

注意：只能跳出举例最近的for或者while循环

与else结合

else的下级代码

没有通过break退出循环，循环结束后，会执行的代码

1
2
3
4
5
6
7
8
9
num = 1
sum = 0
while num <= 5:
    sum = sum + num
    if sum == 10:
        break
    num += 1
else:
    print("没有执行break语句 ")

pass

作用：当语句要求不希望任何命令或代码来执行时使用

说明：

pass语句表示一个空操作，在执行时没有任何的响应，pass的位置最终应该有代码来执行，只不过暂时写不出来

可以使用在流程控制和循环语句中

1
2
if 1:
    pass

组合数据类型

序列

在Python中，有这样一些类型，它们的成员是有序排列的，并且可以通过下标访问成员，这些类型称之为序列，包括：列表、range、元组和字符串

函数 描述 备注
len(item) 计算容器中元素个数
del(item) 删除变量 del有两种方式
max（item） 返回容器中元素最大值 如果是字典，只针对key比较
min(item) 返回容器中元素最小值 如果是字典，只针对key比较

切片 “0123456789”[::-2] 结果：”97531” 支持的数据类型：字符串、列表、元组

列表

List（列表）是Python中使用最频繁的数据类型，在其他语言中通常叫做数组

专门用于存储一串信息

列表用[]定义，数据之间使用，分隔

列表的索引从0开始

索引就是数据中列表中的位置编号，索引又可以被称为下标

注意：从列表中取值时，如果超出索引范围，程序会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for i in rang(5):
    print(i,list[i])
for i,j in enumerate(list):
    print(i,j)
#列表添加元素
list.append()
#列表添加列表
list.extend([1,2,3])
#列表插入元素
list.insert(index,'hello')
#根据索引删除元素
list.pop(3)
list.remove('hello')
#清空列表
list.clear()
list.reverse()

元祖

Tuple(元祖)与列表类似，不同之处在于元祖的元素不能修改

元组表示多个元素组成的序列

用于存储一串信息，数据之间使用,分隔

元组用()定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#元组的创建
info_tuple = ("zhangsan",18,1.75)
#如果元组里只有一个元素时，定义时需要加一个都好
tuple1 = (1,)
#如果元组一个东西都没有
tuple3 = tuple() #空元组
tuple4 = ()
#转换
tuple5 = tuple('hello')
print(tuple5)
#list -> tuple
tuple([1,2,3,4])
#tuple -> Lisy
list((1,2,3))
#tuple -> str
str(tuple)

元组的基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#索引
print(tuple[1])
#切片
print(tuple[::-1])
#len
print(len(tuple))
#max min
print(max(tuple),min(tuple))
#del
del tuple5
print(tuple5)
#+ 拼接
print(tuple1+tuple6)
# * 倍数
print(tuple*3)
# in
print(1 in tuple1)
# 列表的元素是可以修改的，元组不能修改
list = [1,2,3,4]
list[2] = 5
print(list)

tuple = (1,2,3)
tuple[2] = 2 #

#元组的常用方法
tuple1.count() #计数
tuple1.index(2) # 找值为2的元素下标

#元组的遍历
for i intuple1:
    print(i)

for index,value in enumerate(tuple):
    print(index,value)

for i in range(len(tuple)):
    print(i,tuple[i])

range

range start end step 生成一个等差序列，包左不包右

注意序列属于不可变序列，不支持元素修改，不支持+和*操作

range一般用于for-in循环遍历

字符串(String)

字符串是一串字符，是编程语言中表示文本的数据类型

在Python中可以使用一堆双引号”或者一堆单引号’定义一个字符串。

字符串是以单引号或者双引号括起来的任意文本，也可以是三引号’’’或者”””引起来的任意文本

操作：字符串加法、字符串乘法

1
2
3
4
5
6
7
8
9
print(s1.islower())
print(s1.isupper())
print(s1.strip())
print(s1.split(' ')) #分隔字符串
print(s1.find('o')) #打印坐标
print(s1.find('o',5)) #从5开始o来找
print('#'.join([1,2,3])) #以#作为连接符
#判定是数字、字母
print(str.isdigit(),str.isalpha())

字典(dict)

dictionary(字典)是除列表以外python之中最灵活的数据类型

字典同样可以用来存储多个数据

通常用于存储描述一个物体的相关信息

和列表的区别：

列表是有序的对象集合

字典是无序的对象集合

字典用{}定义

字典使用键值对存储数据，键值对之间使用,分隔

键key是索引

值value是数据

键和值之间使用:分隔

键必须是唯一的

值可以取任何数据类型，但键只能使用字符串、数字或元组

1
2
3
4
5
6
7
8
9
10
11
12
for k,v in d.items():
    print(k,v)
for k in d.keys():
    print(k)
for v in d.values():
    print((v)
d.pop('name')
d.copy()
d.clear()
d.get('age')
d.popitem() #从后删除一个 出栈入栈
d.update({'age':18})

集合（set）

不允许有重复元素，如果添加重复元素，则会自动过滤，可以进行交集、并集的运算

是一种无需且无重复元素的数据结果

与dict类似，是一组key的集合（不存储value）

1
2
3
4
5
6
s = set()
print({1,2,3,4})
# list -> set tuple -> set str -> set dict->set key
#交集、并集
print(s & s2,s | s2)
# score.count(i) i在score有多少个

可变类型 & 不可变类型

不可变类型：1、数字 2、字符串 3、元组 4、布尔类型

  • int（整数）
  • float（浮点数）
  • str（字符串）
  • tuple（元组）
  • frozenset
  • bool

可变类型：1、列表、2、字典、3、集合

  • list（列表）
  • dict（字典）
  • set（集合）
  • bytearray

用户登录系统

1、注册用户账号密码，确认白黑名单 列表->字典 key变成人名

2、循环遍历用户名，白黑名单，密码

3、核对账号密码是否匹配，匹配则登陆成功

异常处理

异常

1、如果代码没有语法问题，可以运行，但会出运行时的错误，例如除零错误。下标越界等问题，这种在运行期间检测到的错误被称为一串

2、出现了异常必须处理否则程序会终止执行，用户体验会很差

3、python支持程序员自己处理检测到的异常

4、可以使用try-except语句进行一串的检测和处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
try:
    print(1/0)
except:
    print("如果出现了异常，进入该代码块执行")

try:
    print(1/0)
except ZeroDivisionError as e:
    print("除数不能为0")
    print("原始报错信息",e)
except:
    print("请输入一个数字")
else:
    print("else模块")
finally:
    print("finally模块")

#抛出异常
raise Exception("出现异常啦！")
#有异常记得调试

函数

基本概念

使用关键词def

确定函数名称、参数名词、参数个数、编写函数体（用于实现函数功能的代码）

1
2
3
def func():
    print("python")
func()

函数的调用：

通过函数名进行调用函数

定义好函数之后，只表示这个函数封装了一段代码而已，如果不主动调用函数，函数是不会主动执行的

函数的参数：

形参：就是函数定义时小括号里的参数，是用来接收参数用的，在函数内部作为变量使用

实参：函数调用的时候，小括号里的参数，是用来吧数据传递到函数内部用的

函数可以没有形参和实参

函数的返回值：

返回值是函数完成工作后，最后给调用者的一个记过

在函数中使用return关键字可以返回结果

调用函数一方，可以使用变量来接收函数的返回结果

默认参数

位置参数：

要求实参顺序必须和形参顺序完全一致，由形参顺序决定实参顺序

缺省参数：

定义函数时，可以给某个参数指定一个默认值。具有默认值的参数就叫做缺省参数

可变参数：

传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个

1
2
def total(*args) #可变参数，参数不固定
def f(**kwargs) #可变参数，接收字典

变量作用域

局部变量：

在函数内部定义的变量，只能在函数内部使用

全局变量：

在函数外部定义的变量，所有函数内部都可以使用这个变量

1
2
3
4
5
num1 = 10
def f():
    global num1
    num1 = 20
    #可变数据类型就不用声明global

匿名函数：

lambda函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方，优点：让代码更加精简，不需要考虑命名的问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#常规函数
def fun(x,y):
    return x+y
#匿名函数
fun = lambda x,y:x+y
print(fun(2,3))

#map映射
a = [1,2,3,4]
def f(x):
    return x**2
result = map(f,a)
result = map(lambda x:x**2,a)
print(list(result))

#reduce函数：累积
from functools import reduce
result = reduce(lambda x,y:x+y,a)
print(result)

#filter过滤
reuslt = filter(lambda x:X%2==0,a)
print(list(result))

# [1,2,3,40,5,6,6,5] 123405665 
result = reduce(lambda x,y:x*10**len(str(y))+y,a)

# 内置函数
'''
abs
bool
all 全真为真
any 一个为真就为真
ascii 自动执行传入参数的_repr_方法（将对象转换为字符串）
bin 接收一个十进制，转换成二进制
oct：八进制
hex：十六进制
bytes：转换为字节
str:字节转换为字符串
chr:数字转字母 ascii
ord:字母转数字 ascii
compile 接收.py文件或字符串作为传入参数
eval 执行python代码，并返回其运行结果
exec 执行python代码（可以是编译过的，也可以是未编译的），没有返回结果（返回None）
dir 接收对象作为参数，返回该对象的所有属性和方法
help 接收对象作为参数，更详细地返回对象的所有属性和方法
divmod（100,10） 返回一个元组，第一个元素的100/10的商，第二个元素的100/10的余数
enumerate：接收序列化类型的数据，返回一个迭代器（对象）
isinstance（object，class） 判断对象是否是某个类的实例
filter 过滤
map 映射
format 字符串格式化
frozenset 转换为不可变集合
global 返回一个字典，包括所有的全局变量与他的值所组成的键值对
locals 返回一个字典，包括所有的局部变量与它的值所组成的键值对
hash 对传入参数哈希值并返回
id 返回内存地址，可用于查看两个变量是否指向相同一块内存地址
input 提示用户输入，返回用户输入的内容（不论输入什么，都转换成字符串类型）
issubclass（subclass，class） 查看这个类是否是另一个类的派生类，如果是返回True，否则返回False
len 返回长度
max 最大值
min 最小值
memoryview 查看内存地址
next
iter
object
pow(x,y) 求次方，返回x**y的结果
pow(x,y,z) 返回x**y%z的结果
property 获取对象的所有属性
random 获取随机数或随机字符
repr 执行传入对象中的——repr——方法
reversed 反向排序
sorted 正向排序
slice 对序列类型的数据切片，返回一个新的对象
round 四舍五入的结果
int 整型
list 列表
set 集合
str 字符串
tuple 元组
type 类型
staticmethod 静态方法
super 返回基类f
vars 返回当前模块中的所有变量
zip 接收多个序列化类型的数据，对各序列化数据的元素，按索引位置分类成一个个元组
'''

递归的过程

1、写出临界条件

2、找这一次和上一次的关系

3、假设当前函数已经能用，调用自身技术啊上一次结果，再求出本次结果当参数满足一个条件时，函数不再执行

模块

模块

模块就好比是工具包，要想使用这个工具包中的工具，就需要导入import这个模块

每一个以扩展名py结尾的python源代码文件都是一个模块

在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具

1
2
3
4
from A import add #不用前缀
import A #需要前缀
from A import * #引入所有方法
from A import add as f

包

包是python模块的一种组织形式，将多个模块组成在一起，形成一个大的python工具库。包通常是一个拥有__init__.py文件的目录，它定义了包的属性和方法

1
2
import pack1.module1
from pack1 import module1

常见的标准库

1

正则表达式

1

1
2
result = re.match(r'^a|b|b$','d')
result = re.match(r'^abc{2,5}$','d') #没有匹配到Nobe

time

1
2
3
import time
t = time.localtime()
s = time.strftime('%Y-%m-%d %H:%M:%S',t)

turtle

用于画图的库，可用于在电子时钟等一系列的

socket

网络编程

1
2
3
4
5
6
7
import socket
sk = socket.socket()
#监听
sk.listen(5)
#等待客户端连接
conn,addr = sk.accept()
#客户端 服务端

pip

–upgrade -U 升级包

文件

文件是以计算机硬件为载体存储在计算机上的信息集合，文件可以是文本文档、图片、程序等等。计算机文件基本上分为两种：二进制文件 （没有统一的字符编码）和纯文本文件（有统一的编码，可以被看做存储在磁盘上的长字符串）。

纯文本文件编码格式常见的有ASCII、ISO-8859-1、GB2312、GBK、UTF-16等

二进制文件与文本文件的一个最主要的区别在于是否有统一的字符编码格式、二进制文件顾名思义是直接由0和1组成，无统一的字符编码。如图片文件（jpg、png）,视频文件（avi）等。

路径问题：绝对路径、相对路径

打开文件-操作文件-关闭文件

1
2
3
4
5
6
7
8
9
10
11
12
#打开文件
f = open('test.txt') #同级目录
#读取文件
context = f.read()
print(context)
#关闭文件
f.close

#path
import os 
path = os.gecwd() #获取当前路径
print(path)

打开文件的格式：

1

1
2
3
4
5
6
7
8
f = open(filename,mode = 'r') #
f = open(filename,mode = 'r',encoding = 'UTF-8')
context = f.read(5) #读取
context = f.readline() #读取一行
context = f.readlines() #读取所有行，保存在列表里
# 写入和读取的编码方式要对齐
f.write #写入内容
f.writelines(['你好,我是mia\n','你是谁\n'])

with语句：

1
2
3
4
5
with open('test.txt',mode = 'r',encoding = 'utf-8') as f:
    # f.readlines()
    context = f.read()
    print(context)
#with语句会自动关闭文件

csv格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
with open('data.csv',mode = 'r',encoding = 'utf-8') as f:
    context = f.read()
    contexts = f.readlines() #列表获取
    print(context)

#引入csv格式,遍历每一行
import csv
with open('demo.txt',mode = 'r',encoding = 'utf-8') as f:
    cf = csv.read(f)
    head = next(cf) #去除表头信息，迭代器不支持索引操作
    for i in cf:
        print(i)

#csv写入
with open('data.csv',mode = 'a',encoding = 'utf-8') as f:
    cf = csv.write(f)
    cf.writerow(['tom','c','50'])
    # cf.writerows([['lil','c','70']])

面向对象的程序设计

基本概念

类的定义：

class：表面这是一个类

classname：类的名字

{}：父类集合的开始和技术

object：父亲的名字，定义的类继承自父类，可以不写，默认是object，object是所有类的直接或间接父类

1
2
3
4
5
class Player（object）: #object基类
    pass
tom = Player()
print(type(tom))
print(isinstance(tom,Player)) #判断类型

实例属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Player(object):
    pass
mia = Player() #对象
#实例的属性
mia.name = 'mia'
mia.age = 24
mia.city = '上海'
print（mia.name,mia.age,mia.city） #实例属性

#创建一个函数
class Player(object):
    def __init__(self,name,age,city):
        #初始化函数
        print('11111')
        self.name = name
        self.age = age
        self.city = city

tom = Player('tom',34,'重庆')
print(tom.name)

print(tom.__dict__，type(tom.__dict__)) #所有属性

类属性

1
2
3
4
5
6
7
8
9
10
11
12
class Player(object):
    #类属性 玩家数量
    numbers = 0 #类属性
    def __init__(self,name,age,city):
        #初始化函数
        # 实例属性
        self.name = name
        self.age = age
        self.city = city
        #又有一个玩家来注册了
        Player.numbers += 1

实例方法

1
2
3
4
5
6
7
8
9
10
11
12
13
class Player(object):
    #类属性 玩家数量
    numbers = 0 #类属性
    def __init__(self,name,age,city):
        #初始化函数
        # 实例属性
        self.name = name
        self.age = age
        self.city = city
        #又有一个玩家来注册了
        Player.numbers += 1
    def show(self):
        return 1

类方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Player(object):
    #类属性 玩家数量
    numbers = 0 #类属性
    def __init__(self,name,age,city):
        #初始化函数
        # 实例属性
        self.name = name
        self.age = age
        self.city = city
        #又有一个玩家来注册了
        Player.numbers += 1
        
    @classmethod
    def get_players(cls):
        print('荣誉王者的用户数量已达到了%d人'%cls.number)

静态方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Player(object):
    #类属性 玩家数量
    numbers = 0 #类属性
    def __init__(self,name,age,city):
        #初始化函数
        # 实例属性
        self.name = name
        self.age = age
        self.city = city
        #又有一个玩家来注册了
        Player.numbers += 1
        
    @staticmethod #装饰器，比较独立的方法
    def isvalid()
        return true

面向对象的三大特性

封装

封装是指将数据和方法包装在类中，对外提供接口控制访问权限，隐藏内部实现细节。

1
2
3
4
5
6
7
8
@property #简约获取格式 
def get_age(self):
    pass
mia.get_age

@age.setter
def set_age(self):
    pass

继承

继承是指子类自动获得父类的属性和方法，可以减少重复代码。

1
2
3
4
class VIP(Player): #VIP是Player的子类

super().__init__(x,y,z) #调用父类的构造函数
self.coin = coin

多态

多态是指不同类的对象可以通过统一接口调用各自的方法，提升代码灵活性。

魔法方法

Python中的魔法方法（也称为特殊方法或双下划线方法）是一种在类定义中使用的特殊命名约定的方法。

当Python遇到某些内置操作时，它会尝试在对象上调用这些魔法方法

这些操作包括但不限于算数运算、属性访问、类型转换等

print -> def str(self): 默认执行

add(self，other)

eq(self，other)

系统实战

分析需求：学生、老师、课程、班级

然后针对不同的类，写初始变量以及相应类的后函数，要分析除父子类

管理系统-对话系统-连接千帆API实现智能问答

Python学习笔记
https://smiledebuger.github.io/2025/07/02/hello-world/
作者
smileDebuger
发布于
2025年7月2日
许可协议