python一行就是一句代码 不需要以;结尾
/ 操作的结果是小数就是小数不会取整
python不需要声明类型 可以声明类型 只需要在变量后面加上 : 类型 即可
x**y 就是进行 x的y次幂操作
= 表示赋值 python中的判等不是==
驼峰命名 personInfo 除了第一个单词小写后面的单词首字母大写
蛇形命名 person_info 单词中间使用下划线分开
打印出a的类型使用 type()函数 print(type(a))
在python中整数只有int类型 int表示的范围可以是无穷大无穷小 int默认长度是4个字节 但是超过了这个范围会自动扩容 在python中浮点数只有float类型 表示的就是双精度浮点数 相当于C++中的double 字符串类型就是str
python中字符串类型用一对单引号 或者一对双引号包起来就是字符串
若是引号里面又有引号 那么不能使用相同的引号 #e = "my name is "zhangsan"" 这样是错误的 若是有字符串同时包含双引号和单引号 那么最外层使用三引号包起来''' ...... ''' g = '''my 'name' is "zhangsan"'''
字符串拼接 直接使用+ 注意+不能使用在int和str类型之间
求字符串长度使用函数len()
python中bool假用False表示 真用True表示
python中允许动态类型 动态类型指的是变量的类型在程序运行过程中仍然可以改变 和变量声明为什么类型无关 而C++中的变量为静态类型 类型一旦声明就无法改变
a:int = 10
print(type(a))
a:str = 'hello'
print(type(a))
a:float = 10.99
print(type(a))
打印的结果依次为 int str float
动态类型很灵活 但是这也是它的缺点 在大型项目中追求稳定性一般使用非灵活的语言 因为灵活可能带来错误 在小型项目中 python的灵活性很适配
使用 '#'写在开头表示一行注释 注释也可以写在代码后面 但是建议写在开头
注释文档字符串使用 """......""" 或者'''......''' 三引号中间多行文档都被注释
"""
这是一个文档字符串
"""
使用ctrl+/可以进行多行代码的注释和取消注释
Python里面的格式化打印 Python里面采用f-str的方式格式化打印 str中的{}里面可以写变量或者表达式 最终打印时会转化为值 例如现在有一个a变量值为10 想打印出 a = 10
a = 10
print(f"a = { a }")
print(f"a = { a + 10 }")
b = 'hello'
print(f"res = {b + ' world'}!!!")
f的""中的{}中的变量会被自动替换
Python输入以及类型转换 Python中的输入使用内嵌函数input 返回值是一个字符串 也就是我们输入在控制台的内容 由于可能输入的内容需要拿来计算 但是却是一个字符串类型 那么就需要进行类型转换
a = input("请输入一个数字 : ")
b = input("请输入一个数字 : ")
print(f"a + b = {a + b}") # 输出是1020 也就是字符串拼接 不是数字相加
类型转换
a = int(a)
b = int(b)
print(f"a + b = {a + b}") #现在输出的就是a + b = 30
python中的运算符
1、算数运算符
括号括起来的运算优先级更高
/ 表示除法 规则和数学中的一样 可以有小数 和C++不一样 print(7 / 2)
% 表示取余数 print(7 % 2)
** 表示幂运算 当**后面是小数的时候就是开方运算 print(7 ** 2) print(4 ** 0.5)
// 表示向下取整 print(7 // 2) print(-7 // 2) 结果依次为3 -4
2、关系运算符
> < >= <= == !=
中文字符串比较没有意义 字符串的比较相等或者不相等和C++的一样 直接使用 == 或者 != 即可
关系运算符比较之后的返回值是bool类型的
3、针对于浮点数之间的关系运算可能出现误差 这是浮点数存储的原因 在进行计算之后可能出现误差
print(0.1 + 0.2 == 0.3)
print(f"0.1 + 0.2 = {0.1 + 0.2}") #0.1 + 0.2 = 0.30000000000000004
实际上这个小误差可以忽略 因为工程师站在工程上的角度 忽略很小的误差 所以只要两个浮点数相加误差在一个很小的范围之内我们就把结果出现的误差忽略
print(-0.000001 < 0.1 + 0.2 - 0.3 < 0.000001)
在Python中支持连续比较 就如上述代码一样
4、逻辑运算符
and or not分别代表C++中的&& || !
5、赋值运算符
重点是多元赋值 a, b, c= 30, 40, 50 # 用逗号隔开就可以多个变量同时赋值
当进行变量交换的时候 不需要创建中间变量tmp 使用多元赋值 因为多元赋值各个变量的赋值是同时进行的 a,b = b,a
6、复合赋值运算符
比如 += -= *= **= %= //=
Python中不持支++ --这样的操作 但是前置++和前置--可以编译通过 原因是将它看作了两个正号、两个负号
条件语句
a = input("请输入字符串 : ")
if a == '1':
print("aaa1")
elif a == '2':
print("aaa2")
else:
print("输入错误!")
可以观察到 python的条件语句条件判断不需要括号 直接写 但是要在后面写上 ':'
else if 简写成elif
在python中 就算什么都不想做 由于代码块的缩进 也需要使用空语句pass 来避免语法错误
a = int(input("请输入一个数字 : "))
if a == 1:
什么都不做
pass
else:
print("输入正确")
循环语句
while循环 格式 while condition : # 依然遵循tab代码块模式
for循环语句 语法格式表示i遍历range里面的内容 range是一个内置函数 range左闭右开 可以设置步长 也就是第三个参数
theSum = 0
for i in range(2, 11, 2):
theSum += i
print(f'sum = {theSum}')
continue 和 break 语句
python中的函数
函数开始需要有一个def 并且函数列表后面需要接上冒号 返回值不需要写
Python中的函数只要求参数个数匹配 而由于动态类型不要求类型匹配 但是要保证传过去的参数在函数体内能够被正确的运算
函数的返返回值可以有多个 返回值使用逗号隔开即可 同时接收的变量也是逗号隔开的多个变量 可以只接收多个返回值中其中一部分的值 这个时候用'_'接收忽略的返回值即可
函数变量的作用域只是在当前函数代码块 也就是说在函数体之外的作用域看不到这个变量 ；条件、循环、选择语句中定义的变量的作用域是全局的 使用global关键字可以将函数体内定义的变量的作用域改为全局的
链式调用 : 一个函数的返回值可以作为另一个函数的参数
嵌套调用 : 一个函数中可以调用其他的函数
函数栈帧 : 每一个函数都在内存上开辟了一块空间 这块空间存着对应函数的变量 这就是函数栈帧 函数调完之后栈帧摧毁
函数参数可以设置缺省值
def test(x, y, default = False):
if default:
print(f'x = {x}, y = {y}')
x = 10
y = 20
test(x, y)
test(x, y, True)
python中的传参可以使用关键字参数 这种传参的好处就是可以无视传参顺序 指定传的参数
def test(x, y, z):
print(f'x = {x}, y = {y}, z = {z}')
test(y = 100, x = 200, z = 0)
列表list和元组tuple
列表和元组相似 唯一区别就是列表可以修改 而元组不能修改
空列表的创建 a = [] 或者 b = list()
列表指定初始值 c = [1, 2, 3, 4]
一个列表里面可以存放不同类型的变量 d = [1, 'hello', [4, 5, 6], True]
可以使用下标访问列表 可以使用下标修改列表 下标超过有效范围会报错
使用内建函数len()可以计算列表的长度 和字符串类似 len()函数可以接收很多类型的参数 这是因为动态类型
python中的下标可以是负数 表示的位置是列表的长度加上这个负数所在的下标 e = [1,2,3,4,5,6,7] print(e[-1] ) # 的等价于print(e[len[e] - 1])
列表的切片
index1:index2\]内指定切片的范围 左闭右开 这两个下标都可以省略 省略前面表示从 0 下标开始 省略后面表示一直取到最后一个下标 #切片是一个很高效的操作 这是因为切片并不涉及到数据的拷贝 只是取出原来列表中的一部分 a = \[1, 2, 3, 4, 5, 6
print(a[1:3]) print(a[:4]) print(a[4:]) print(a[:])
可以搭配负数下标进行操作 print(a[1:-1])
切片可以指定步长 就是range一样 也就是第三个操作数 print(a[::2])
当步长为负数的时候表示从后面开始切片 print(a[::-1])
当切片左边范围超过列表合法下标之后 不会报错 而是直接将后面数据取尽 print(a[0:1000])
列表的遍历
可以使用for循环
a = [1, 2, 3, 4, 5, 6 ,7, 8, 9, 0]
for elem in a:
print(elem)
elem += 10
print(a)
或者使用下标遍历
for i in range(0, len(a)):
print(a[i])
a[i] = a[i] + 10
print(a)
elem只是另外开的一个变量 和列表a不相干 只是一直覆盖记录了列表a的值 所以修改elem元素不影响列表a 若是拿着下标修改 则a中的元素会被改变
使用while循环遍历
j = 0
while j < len(a):
print(a[j])
j += 1
列表插入元素
使用append方法在列表后面添加元素 append不是一个函数 而是对象内部定义的方法
a = [1, 2, 3, 4]
a.append('hello')
还可以使用insert方法 往列表的任意位置插入元素
a.insert(1, 'next1')
若是超出了合法下标位置 那么插入就是相当于append
a.insert(100, 'tail')
查找列表中元素的位置
a = [1, 2, 3, 4] 使用in判断元素在列表中存不存在
print(1 in a)
使用index()查看一个元素在列表中的下标
print(a.index(1))
print(a.index(10)) # 不存在的元素使用index方法会出错
列表中删除元素
a = [1, 2, 3, 4]
使用pop()删除列表最后一个元素
pop()可以传一个下标过去 指定删除下标处的元素
a.pop()
a.pop(2)
使用remove可以指定删除一个值
b = ['aa', 'bb', 'cc']
b.remove('bb')
列表的拼接
使用 + 号拼接 原列表没有发生变化 生成了一个新列表
a = [1,2,3,4]
b = [5,6,7,8]
c = a + b
使用extend拼接 此时对原列表进行了改变 没有生成中间临时列表
c = a.extend(b) # 将b拼接在a后面 这个方法没有返回值 写一个接收返回值默认为None 相当于C++中的nullptr
使用c += d 等价于 c = c + d 此时生成了临时中间列表并且还有一步赋值操作 赋值之后还有一个释放操作
而extend直接拼接没有任何的中间过程 效率相比而言更高效
元组
元组和列表类似 就是元组一旦定义出来就不能被修改
元组的创建
a = () 或者 b = tuple()
创建元组指定初始值 元组中也是可以存不同类型数据的
a = (1, 2, 3, 4)
b = (1, 'bbb', (5, 6, 7), 1.1198)
通过下标访问元组中的元素
print(a[0])
print(b[-1])
使用循环遍历元组
for elem in b:
print(elem)
使用in判断数据在一个元组中存不存在 使用index方法查找元素在元组中的下标
print(1 in b)
print('aaa' in b)
print('bbb' in b)
print(b.index('bbb'))
print(b.index((5, 6, 7)))
- 拼接元组
c = a + b
print(c)
元组不支持修改操作
a[1] = 100 报错 TypeError: 'tuple' object does not support item assignment
对应的append、pop、extend方法也不能使用
当一次性对多个遍历进行赋值的时候实际上是按照元组的方式工作的
def func():
x = 10
y = 20
return x, y
x, y = func()
print(type((x, y))) 类型时tuple
print(type(func()))
字典dict
kv结构使得字典增删查改很快 哈希表直接映射
创建字典
a = {} 或者 b = dict()
创建时设置初始值
其中:前面的是key 后面的是value kv合在一起称为一个键值对
a = {'id' : 1, 'name' : 'zhangsan'}
key有要求 1、可哈希 2、在一个字典中不能重复 ； value没有要求
in 判断key存不存在于字典中 这个操作和value没有关系 not in判断key是否不在字典中
使用[]来找到key对应的value 当key值不存在时报错 对于字典来说使用in判断key存在与否或者使用[]找key对应的value是高效的 因为底层哈希表 ； 对于元组 列表来说使用in比较低效因为要遍历容器一遍 而[]是高效的 直接索引
字典中的增删
a = {'id' : 1, 'name' : 'zhangsan'}
增加新的键值对 直接使用[]即可 若是key已经存在就是修改value 若是不存在就插入了新的键值对
a['id'] = 10
a['hello'] = 'world'
插入的键值对是有序的（和插入的顺序一样） 也就是插入在尾部 不像C++中哈希表是无序的
Python中的字典不是单纯的哈希表
删除使用pop方法 传入key值 那么对应的键值对就会被删除
字典的遍历操作
a = {'id' : 1, 'name' : 'zhangsan', 'score' : 100}
使用for循环遍历
for key in a:
print(key, a[key])
针对于key value kv的函数
keys()函数可以获取字典的key值 放到一个类似于但不是列表的自定义类型中
print(a.keys())
values获取字典所有value值
print(a.values())
items()获取所有的键值对 一个键值对先放到元组中 多个元组再放到类似于但不是列表的自定义类型中
于是遍历可以这样写
for key,value in a.items():
print(key, value)
前面说key值有限制 其中一点是不能重复 另一个就是可哈希才行
什么是可哈希 在Python中可以使用函数hash()判断 可哈希就会返回一个值
print(hash(1))
print(hash('aaa'))
print(hash([1,2,3])) # 不可哈希
print(hash((1,2,3)))
print(hash({1:3, 2:4})) 不可哈希
数字,字符串,元组可哈希 这些都是不能被改变的值 ; 列表,字典不可哈希 这些都可以被改变
结论就是只有不能被改变的值才是可以被哈希的 也就是说字典中的key值必须不能被改变
文件操作
打开一个文件
打开文件使用open函数 返回值是一个文件对象 通过这个文件对象就可以操作打开的文件
打开的文件的路径就是open的第一个参数 打开的方式用很多 比如读方式'r'、写方式'w'、追加写方式'a'
打开文件必须关闭
f = open('D:/CodeLog/GitteTwo/python/Python代码/test.txt', 'r')
print(f) # 打印的文件对象
print(type(f)) # 打印的就是这个文件对象类型名称
f.close()
打开文件为什么要关闭 打开的文件申请了系统资源 不及时关闭就会造成资源泄露
使用w、r、a来练习
w：打开一个文件 存在则清空写 不存在即新建写
写调用的方法为write
f = open('D:/CodeLog/GitteTwo/python/Python代码/test1.txt', 'w')
f.write('hello Python')
f.close()
a：追加写 文件存在每次打开写入的时候不会清空而是向后面追加写
f = open('D:/CodeLog/GitteTwo/python/Python代码/test1.txt', 'a')
f.write('hello Python\n')
f.close()
r：读文件
read方法 参数为想要读几个字符
当读的文件是中文是 可能出现编码不一致的问题 此时在open函数里面指明第三个参数encoding 一般是utf8
f = open('D:/CodeLog/GitteTwo/python/Python代码/test.txt', 'r', encoding = 'utf8')
a = f.read(5)
f.close()
读整个文件的方式 循环读 每次读一行
f = open('D:/CodeLog/GitteTwo/python/Python代码/test.txt', 'r', encoding = 'utf8')
for line in f:
print(line, end = '') # print函数可以指明输出结束字符
f.close()
还有一种方式 使用接口readlines 以行为单位 将文件内容放到一个列表里面
f = open('D:/CodeLog/GitteTwo/python/Python代码/test.txt', 'r', encoding = 'utf8')
f_lines = f.readlines()
print(f_lines)
f.close()
python中的上下文管理器 自动关闭打开的文件
def func():
with open(' D:\CodeLog\GitteTwo\python\Python代码/text.txt', encoding = 'utf8') as f:
这里有很多行代码
......
if cond:
return
这里有很多行代码
......
使用上下文管理器的优点就是在多行代码中避免漏掉某一个关闭文件的操作 在打开文件的代码块结束的时候自动关闭打开的文件 避免内存泄漏
python中的库 分为内置库和第三方库
一个简单例子 使用库中的方法
计算两个合法日期之间的时间间隔 直接使用库 简化开发
使用库的时候需要导入你想要使用的那个 import
import datetime
导入的写法
from datetime import datetime # 这种写法可以直接使用datetime对象
import datetime as dt # 这种写法给导入的库起了一个别名
datetime出现两次 因为在这个库中有一个对象就是datetime 这里先定义出datetime对象
date1 = datetime.datetime(year = 2025, month = 10, day = 13)
date2 = datetime.datetime(year = 2025, month = 11, day = 18)
print(date2 - date1)
第二种导入方式对应使用写法
date1 = datetime(year = 2025, month = 10, day = 13)
date2 = datetime(year = 2025, month = 11, day = 18)
print(date2 - date1)
第三种导入方式对应使用写法
date1 = dt.datetime(year = 2025, month = 10, day = 13)
date2 = dt.datetime(year = 2025, month = 11, day = 18)
print(date2 - date1)
补充
python中控制输出小数位数写法 print(f'{a:.3f}') 也就是变量后面接上:.nf表示四舍五入控制为几位小数
print("保留2位小数：{:.2f}".format(num))
input输入的都是字符串 若是转为整数用int(input()) 转为浮点数用float(input()) 但是有一个方式更简单 输入的是什么就转为什么 比如输入的是整数就转为整数 是浮点数就转为浮点数 即使用eval(input())
print()可以指定输出变量之间用什么样的分隔符 可以指定输出的一行用什么结尾print(year, month, date, sep = '-', end = '\n') sep默认是' ' end默认是'\n'
sum函数用法sum(range(start, end, step)) 计算start到end之间的和 步长为step
round(a, b) 函数设置a保留b位小数 这个函数的优势是可以同时处理整数和浮点数 当a是整数的时候无论b是几 输出的都是整数a
限制输入只能一行输入的格式控制写法
map()函数可以将多个数据转换成指定数据类型
split()函数可以将字符串按照指定分隔符进行间隔并生成数据列表
a, b = input().split() # 将输入的以空格分隔的两个数命名为a和b
a, b = map(int,input().split(',')) # 将输入的以逗号分隔的两个值，转换为整数后命名为a和b
导入的datetime库 想要单独获取该日期天数 直接在datetime对象后面加上.days即可
使用sqrt函数求开方要导入库math 之后math.sqrt这样使用
判断字符是不是数字字符的函数 c.isdigit()
大小写字母转换的函数 str.upper() 小全转大 / str.lower() 大全转小 / str.swapcase() 大转小小转大 / str.capitalize() 把字符串 str 的第一个字符大写
这些转换函数实际上没有改变原来的str 要使用改变之后的需要使用另一个字符串接收 turnstr = str.upper()
python中种随机数种子
当如模块random random.seed() 种子可以是任意类型也可以不设置
使用random.random() 或者random.randint(l,r)生成随机数或者范围类的整数随机数
python中判断素数的模块 sympy 使用方法 sympy.isprime() 针对于判断大素数的场景