目录
常量和表达式
Python在初学时可以当作一个计算器用于打印和计算
print(5+5-1)
print(5+5*1)
print(5 / 5 - 1)
解释：
1.print是Python的内置函数 我们直接使用就行
2.在括号内可以使用任意的四则运算符，它怎么都可以计算
3.在运算符于数字之间空格是否存在都不影响最终结构
注意：空格的意义
·空格在这里存在的意义是影响代码的美观性
·代码的美观性影响可读性有助于后期的维护和修正
在Python中 它不服C语言的一些运算规则
它放弃了 整数 除以 整数 只会是 整数 的规则
而且在编程中没有四舍五入的规则 上面的0.0也是浮点数
浮点数是按照IEEE754标准的规则，这个规则是存在误差的
此外：
我输入的这三行代码就是表达式，计算出的结果就是表达式的值
5 1 这样的数字是字面值常量
四则运算的符号 是运算符或者操作符
变量和类型
变量是什么
变量是在计算复杂程序过程中，用于保存中间结果的东西，这个东西一般是可变的量，也就是变量。
例如：
计算方差
1.计算平均值
2.计算每个数字与平均值的差值再平方
3.相加每一项平方值
4.除项数
Average = (77.5+88.5+99.5+100.5)/4
Total = (77.5-Average)**2 + (88.5-Average)**2 + (99.5-Average)**2 + (100.5-Average)**2
Result = Total / 3
print(Result)
注意：
· 其中 Averang Total Result 都是变量
· 我们的行为是给变量赋值
· **2是求平方和 **3就是求3次方 以此类推
变量是一个可以用来存储数据的空间，它会占用在内存上
变量的语法
定义变量
Average = (77.5+88.5+99.5+100.5)/4这就算是定义变量了
注意 “=” 是“赋值运算符” 不是用于比较的
变量命名的规则
1.变量名只能由 数字 字母 下划线 构成
2.变量不能由数字开头，不能包含特殊符号（a1可以，1a就不可以，a+a也不可以）
3.变量名不能和关键字重复（在语法中有特点含义的单词）
4.变量名区分大小写的，比如A和a就不是一个变量
5.给变量命名的时候尽量使用有意义的单词来命名，从名字看功能能更有助于后期的维护
使用变量
读取变量的值
a = 0
print（a）系应该变量的值
a = 20
print（a）第一次使用=是创建定义变量 第二次对变量使用=是修改变量
也可以给变量赋另一个变量的值
a = 0
b = 10
a = b
print（a）变量的类型
python中变量的类型不需要再定义的时候声明，只需要初始化语句它自动定义
整数
a = 0
print（type（a））
type也是python的内置函数，可以用来查看变量类型，p语言的int数值可以无限大
浮点数
a = 0.0 print(type(a))
python的小数只有这么一种类型，没有double类型
字符串
a = '0.0' print(type(a))
双引号也不影响,而且可以在单引号中包括双引号,让引号也作为字符串的内容存在
还有三引号引用
这里补充一个求字符串长度 len
a = ''''''''"""0.0"""'''''' print(type(a)) print(len(a))
还有拼接字符串的操作
a = 'hello' b = 'world' print(a+b)
注意:字符串不能和数字混合相加
布尔类型
a = True b = Falseprint(type(b)) print(a + b)
可以理解true就是1 false 就是 0 它主要用于逻辑判定
其它
它还可以有list,tuple,dict,或者等自定义类型
为什么要有这些类型?
1.不同的类型,占用的内存空间不同,占用的字节不同
int是4个字节
float固定八个字节
bool一个字节
str变长的
2.不同类型,进行的操作也不同
例如int和float是进行加减乘除的
str可以加但不可以其他操作 可以用len进行操作 整型就不可以
动态类型特征
指的是在程序运行的过程中,你改变一个变量的值也可以直接改变它的类型
a = 0 print(type(a)) a = '0' print(type(a))
两面性
对于中小型程序,可以打大大节约代码量
对于大型程序,却提高了程序的交互成本,也降低了可读性
注释
注释是什么
在编程中，注释是用于解释代码的功能、用途或实现细节的文字说明。
注释对于代码的可读性和可维护性非常重要，因为它们可以帮助其他开发人员（或未来的自己）理解代码的工作原理和设计意图。
注释在代码中以特定的语法标记，通常不会被编译器执行。根据编程语言的规范，注释可以有不同的形式。例如，在C和C++中，注释以“/”开始并以“/”结束；在Python中，注释以“#”符号开始。
例如:
# 用来判断变量的类型和更改变量的类型 # 定义一个初始化变量 a = 0 # 检测出这个初始化变量是什么类型? print(type(a)) # 改变这个变量的类型 a = '0' # 检测出这个初始化变量是什么类型? print(type(a))
他并不会影响代码的运行,只是批注作用 ,可以提高可读性等
作用
- 提供有关代码的背景信息：注释可以解释代码的用途、设计思路或历史背景。
- 解释复杂或难以理解的代码段：对于难以理解的代码段，注释可以提供额外的上下文或解释其工作原理。
- 记录代码更改：注释可以记录代码的修改历史、原因和日期，这对于跟踪代码的演变和了解代码库的状态非常有用。
- 指导其他开发者：注释可以作为开发指南，指导其他开发者如何使用或修改代码。
注释的语法
在Python中，注释的语法有两种方式：
单行注释：使用井号（#）开头，后面跟着注释内容。例如：
# 这是一个单行注释
print("这是一个单行注释")
多行注释：使用三引号（"""）或三单引号（'''）包裹注释内容。例如：
"""
这是一个多行注释的例子。
可以在多行注释中编写任意的内容。
"""
print("这是一个多行注释的例子")
注意:不要把注释写到要注释的代码的下面,也不要写到要注释的代码的左边
注释的规范
主要有以下几点 :
- 清晰简洁：注释应该清晰、简洁地说明代码的功能和意图。避免冗长和复杂的注释，尽量保持注释的长度适中。
- 解释代码逻辑：注释应该解释代码的逻辑和实现细节，帮助读者理解代码是如何工作的。
- 避免不必要的注释：不要为了注释而注释，只有在必要时才添加注释。避免重复编写代码的注释，因为这会使代码变得难以阅读和维护。
- 注释风格一致：在整个代码库中保持一致的注释风格。例如，选择单行注释还是多行注释，使用井号（#）还是三引号（"""）或三单引号（'''），都应该保持一致。
- 适当使用中文注释：如果项目需要多人协作，建议适当使用中文注释，以便团队成员更好地理解代码。同时，也要注意保持注释的清晰和简洁。
- 注释与代码同步：当代码发生变化时，相关的注释也应该进行相应的更新，保持注释与代码的同步。
- 使用文档字符串（docstrings）：对于复杂的函数、类或模块，建议使用文档字符串来提供详细的说明和文档。文档字符串应该清晰地描述函数、类或模块的用途、参数、返回值和异常处理等信息。
- 要文明注释: 不要弄乱七八糟带有负能量的注释.
输入输出
和用户交互
程序与用户交互工程中
用户把信息传送给程序的过程是 输入
程序把结果展示给用户的过程是 输出
输入输出的最简单的方法是利用控制台
例如
和
都是控制台,进行输入和输出的作用
但是: 我们常见的交互界面,例如QQ,浏览器,Wegame等,都不需要输入命令,大大简化了操作流程,用鼠标就可以操控,是属于图形化程序开发,拥有自己的的用户UI
通过控制台输出
Python使用print函数暑促到控制台
print('hello')
它能输出各种数字,字符串,还能输出其它类型的变量,基本能打印任何你想的东西
print(print('hello'))
更多时候,我们都是输出数字加变量的东西
num = 0
print(f'num = {num}')
注 意:
num = 0
print(f'num = {num + 1}')
也是可以的,记住这种方法来打印变量加字符串,其中的f是格式化字符串,不做过多了解
通过输入台输入
可以利用input函数,丛控制台读取用户的输入
num = input('请输入整数')
print(f'你输入的整数是 = {num}')
注意:
input的参数相当于一个"提示信息",他的存在只是用于提示
input的返回值结束用户输入的内容,是字符串类型
a = input('请输入第一个整数')
b = input('请输入第一个整数')
print(f'a + b = {a + b}')
只是进行了字符串拼接,并不是算数运算,如果想进行算术运算,需要转换类型
a = input('请输入第一个整数') b = input('请输入第一个整数') a = int(a) b = int(b) print(f'a + b = {a + b}')
运算符
算数运算符
例如+ - * / % ** //的运算符,成为算数运算符
1./是除法运算符,不能除0
2.整数除小数结果是小数
3.%是求余数而不是"百分数"
4.**是乘方,小数和整数都能算次方
关系运算符
例如 < <= >= == != 等运算符是关系运算符,他们在比较操作数之间的关系
其中特殊的是:
== 是 等于
!= 是 不等于
其它的就是正常的符合数学判断
在判断过程中,如何关系符合,会返回Ture(1),如果关系不符合则表达式返回False(0)
a = 1
b = 2
print(a > b)
print(a < b)
关系运算符还能对字符串进行比较
a = 'one'
b = 'tow'
print(a > b)
print(a < b)
print(a == b)
这玩意的比较规则,是首字母开始往后排序,在字典中字母越靠前比出的结果越小,但是对中文比较没意义的
注意:使用==去判断浮点数的关系存在一定的风险,因为浮点数有误差,进行计算时误差会变大
print(0.1+0.1 == 0.2)
因为这个玩意计算出来是0.200000000004 所以出现了flase
所以它的比较方式是
a = 0.1 + 0.1
b = 0.2
print( -0.000001 <(a - b)<0.000001 )
逻辑运算符
逻辑运算符主要有三个and or not
and 并且 若两操作数仅为True 则结果为True 否则为False (一假全假)
or 或者 若两操作数均为False 最终结果为 False 否则为True (一真全真)
not 逻辑取反 若操作数为True 结果取False,若为False 则取True (颠倒是非)
a = 1
b = 2
c = 3
print(a < b and a < c)
print(a > b or a > c)
print(not (a < b and a < c))
注意:短路求值
对于and操作来说,如果左侧出现了False 那么就全false 不会关注右操作符
对于 or 操作来说,如果左侧出现了 True 那么全是 True 不会关注右操作符
赋值运算符
· =
= 表示赋值,注意和==区分即可
= 可以链式赋值和多元赋值
链式赋值
a = b = 10
tip:不建议使用
多元赋值
a , b = 10 , 20
这个是a = 10,b = 20
·复合赋值运算符
例如+= -= *= /= %=
他们只是整合了运算符 比如 a += b 就是 a = a + b 以此类推
a = 1
a = a + 1
print(a)
b = 1
b += 1
print(b)
其它
有身份运算 成员运算 位运算 在此处咱是不介绍
小结
至此我们学完了python的语法基础的一部分
学习了常量 变量 注释 输入输出 运算符的最简单的部分
稍后我将继续更新(依然是先出各个部分然后整合成大块的文章)
谢谢!
顺序语句
python的代码是从上往下依次执行的
print('1')
print('2')
print('3')
条件语句
例如:按照"如果,则"的逻辑判定后按顺序触发
条件语句也叫做分支语句
语法格式
例如if else关键字表示的条件语句
event = 1
if event:
print("结果作为真")
else:
print("结果为假")
注意 " : " 的存在
这里解释 event 为 真(不是0)的时候 执行第一个 否则 结果为假
还有 if - elif - else
event1 = 1
event2 = 1
if event1:
print(event1)
elif event2:
print(event2)
else:
print(event1)
如果event1是真 则执行print(event1)
如果event1是假 且 evnet2 是真 则执行 print(event2)
如果event1是假 且 event2 是假 则执行else内容
注意 if后面没有()并且以:作为结尾
它后面的语句区块是以 缩进(一个tab或者四个空格)来判定的 (类似于{},但他不用)
多分支语句是else if的缩写 elif
我举一个栗子
scanf = input("输入1为真,输入0为假")
scanf = int(scanf)
if scanf:
print(f"你输的是{scanf}是真")
else:
print(f"你输的是{scanf}是假")
这个是转换为数字的结果
还有不转换的版本就是以字符串的形式对待
scanf = input("输入1为真")
if scanf == '1':
print(f"你输的是{scanf}是真")
else:
print(f"你输的是{scanf}是假")
缩进和代码块
代码块是放在一起执行的代码,在python缩进往往代表了代码块,相同缩进代表了一整个代码块,还有分级缩进进行代码嵌套
scanf = input()
if scanf == '1':
print('hello')
print('hello again')
scanf = input()
if scanf == '1':
print('hello')
print('不管你输入的是不是1,我这个hello的都要给你hello一下')
上述代码中 第一个代码执行的两个print是一个代码块 第二个代码的两个print不是一个代码块
此外,还有嵌套代码
scanf1 = input()
scanf2 = input()
if scanf1 == '1':
if scanf2 == '1':
print('你输入两个1')
print('我知道你的scanf1是1')
print('我在嵌套之外')
这里的二级条件就是scanf2的情况,第二个print和第二个if是同缩进,他俩是一个代码块
不能平白无故的缩进
空语句pass
pass表示空语句,不会滴程序执行有任何影响,只是占个位
例如
a = 1
if a != 1:
pass
else
print('hello')
如果把pass哪一行改为空行,程序会报错
循环语句
while循环
格式
while 条件:
语法块
条件为真循环 条件为假不循环了
eg:打印1-10
count = 0
while count < 10:
count += 1
print(count)
print('打印结束')
for循环
语法格式
for 循环变量 in 迭代对象:
循环体
python的for循环没有初始化语句,循环判定合格语句,循环更新语句
迭代对象计就是内部包含多个元素能一个个取出来的变量
例如
打印1-10
for i in range(1,11):
print(i)
打印2,4,6,8
for i in range(2,12,2):
print(i)
注意 range函数是 range(初始范围,结束范围,步长) 例如 (1,11) 是从[1,10] 且步长为1
打印10-1
for i in range(10,0,-1):
print(i)
continue 和 break
continue是立即结束此次循环,进入下一次循环
break是跳出循环
for i in range(1,6,1):
if i == 2:
continue
print(f'数字{i})
for i in range(1,6,1):
if i == 2:
break
print(f'数字{i}')
函数
函数是什么
编程中的函数可认为时一段被重复使用的代码片段
在编程过程中,我们会多次使用类似或者相同的代码组合,此时我们可以选择把我们重复使用的代码提取出来作成一个函数
语法格式
创建函数/定义函数
def 函数名字(形参)
函数体
return 返回值
调用函数
函数名(参数)
返回值 = 函数名(参数)
注意:函数的定义并不会执行函数体内容,不许调用了函数体才会执行,调用几次就执行几次
函数必须先定义(声明)再使用
def calcSum(beg,end):
thesum = 0
for i in range(beg,end+1):
thesum += i
print(thesum)
#求1-100的和
calcSum(1,100)注意:python中更支持小写的代码格式,大写代码会警告
再自定义函数下面尽量有两个空行 //遵循的PEP8编程规范 是个软性规则
函数参数
再自定义函数的时候,再自定义函数后面的()中制定"形式参数"(简称形参),然后再调用的时候,有调用者把"实际参数"产地进去.
def calcSum(beg,end):
thesum = 0
for i in range(beg,end+1):
thesum += i
print(thesum)其中的beg and 就是带进去的函数参数
注意:你传入的参数只要符合在自定义函数内的操作,就不会出问题不报错
函数的返回值
自定义函数可以自定义返回什么 用 return返回想要 然后可以赋值类的
def add(x,y):
c = x + y
return c
l = add(1,2)
print(l)
这个代码就是辅助返回了个c的值 然后c的值给了l
有一个通用的编程原则,是一个代码只做一件事,写功能单一的代码,不进行复杂的处理,可以提高代码的可维护性(逻辑与界面分离)
一个函数中可以有多个返回规则
利用条件语句调用return
def onortow(x):
if(x % 2 != 0):
return "奇数"
else:
return "偶数"
注意:一旦执行到return 就会跳出函数了
ptyhon可以返回多个值
def whereareyou():
x = 5
y = 1
return x,y
x,y = whereareyou()
print(x,y)
同时,如果不需要x或者y的某一个返回值,可以用"_"来占位
变量的作用域
例如:
def whereareyou():
x = 5
y = 1
return x,y
x,y = whereareyou()
print(x,y)这个代码中 函数内部有x y 函数外部也有x y 但是他们的作用域不同
变量只能在所在函数内部生效
上面那个代码中,x y只在whereareyou()函数中生效,一旦离开了函数的范围,这两个变量也就不再生效了
# 返回坐标
def whereareyou():
x = 5
y = 1
return x,y
whereareyou()
print(x,y)
会说x未被定义
在不同的作用域中,允许存在同名的变量
def whereareyou():
x = 5
y = 1
return x,y
x,y = whereareyou()
print(x,y)在这个代码中 就允许了x y 在函数内外同时存在 ,它们只是变量名相同,但不是同一个变量
内部的是局部变量 外面的是全局变量
但是函数里也可以使用全局变量
x = 0
def printf():
print(x)
printf()
如果要修改全局变量 需要用到global
x = 0
def printf():
global x
x = 1
printf()
print(x)
函数的执行过程
函数的执行过程是在全局中逐条进行,进入到函数后在函数内逐条进行,结束后回到全局变量跳入函数的位置继续向下进行
def text():
print("执行一下子")
print("第1次执行")
text()
print("第2次执行")
text()
print("第3次执行")
text()
链式调用 与 嵌套调用
其实也就是让代码更集中,减少写代码的行数
def text():
print("执行一下子")
return "0"
print(text())
其中的 print(text())是链式调用 调用print的同时调用了text进入内函数
在text()中又调用print就是嵌套调用,函数内调用函数
提一下函数栈帧,每个自定义函数在调用的时候就会栈帧,结束后会立马消亡不占用内存
函数递归
递归就是在函数中 自己调用自己
例子:计算n的阶乘
def event(n):
if n == 1:
return 1
else:
return n * event(n-1)
x = 5
n = event(x)
print(n)结果是120 在这个代码中 event就调用了event
注意:函数递归要注意
存在递归的结束条件,否则会栈溢出
每次递归都要接近结束条件
反例子
def event(n):
return n * event(n-1)
x = 5
n = event(x)
print(n)
没有而结束条件就报错溢出了
注意:递归代码一般都是可以转换成等价的循环代码的,可以用迭代的方式写代码,来加快运行速度,但是递归在一些本身就是通过递归的方式定义的东西的时候,会更方便和更容易理解,大部分时间建议用迭代而不是递归
参数默认值
python 中的函数,可以给形参制定默认值
带有默认值的参数,可以在调用的时候不传参
def add(x,y,debug=False):
if debug:
print(f'打印x={x} y={y}')
return x+y
print(add(1,1))
print(add(1,1,True))在这个代码中 给debug初始化定义为False 如果不给debug传参,那么debug就是False,如果传了True才会传
注意:如果传值不对依然会报错
其次还要求带有默认值的形参,需要在形参列表的后面~~
而不能在前面或者是中间!,不然依然会报错
关键字参数
一般在带哦用的时候需要给函数制定参数,按照自定义函数的参数定义的顺序来填写,但是我们可以通过关键字参数来调整传参顺序
def add(x,y):
print(f'打印x={x} y={y}')
add(1,2)
add(y=1,x=2)
这样就可以按照自己想给的顺序传参,不必在乎原来的顺序
列表和元组
列表和元组分别是什么
列表是一种在代码中批量表示和保存数据的方法,元组相似于列表,但是列表中存放的元素可以修改调整,元组中存放的元素是创建元组的时候就设定更好的,不能修改调整.
也就是用一个变量来表示多个数据,类似于其他编程语言中的"数组"
创建列表
创建列表主要有两种方式,例如[ ]表示创建一个空的列表
alist = [ ]
alist = list()
print(type(alist))
如果是要往里面设置初始值,可以直接在[ ]中写
alist = [1, 2, 3, 1, 2, 3]
print(alist)
而且在这个列表中可以防止不同类型的玩意
alist = [1, "2", True]
print(alist)访问下标
访问下标的目的是取出列表中的元素 它的下标访问运算符也是[ ](下标初始也是0)
alist = [1, "2", True]
print(alist[0])
通过下标访问来修改列表元素
alist = [1, "2", True]
alist[1] = "啦啦啦"
print(alist[1])
注意 在这种情况下,可以有-1的存在 也就是alist[-1] 这个-1等价len(a)-1 (也可以认为是倒数的第几个元素)
alist = [1, "2", True]
print(alist[-1])
print(alist[len(alist) - 1])
切片操作
通过切片,则是依次取出一组连续的元素,相当于得到了一个子列表
也就是使用[ : ]的方式进行切片
alist = [1, 2, 3, 4,]
print(alist[1:3])
在 [1,3)的范围内打印取不到3
切片操作可以省略前后边界
alist = [1, 2, 3, 4,]
print(alist[:3])
print(alist[1:])
print(alist[:])
切片操作还可以制定步长,每访问一个元素后,下标自增几步
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
print(alist[::2])
步长也可以是负的,是反向打印
遍历列表元素
"遍历"是把元素全取出来,再分别进行处理
例如用for循环
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
for i in alist:
print(i)
也可以利用for按照范围生成下标,按照下标访问
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
for i in range(0,len(alist)):
print(i)
print(alist[i])
也可以用while循环,控制下标
i = 0
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
while i < len(alist):
print(alist[i])
i += 1
新增元素
使用append的方法,向列表的末尾插入一个元素(尾插)
alist = [1, 2, 3, 4]
alist.append('hello')
print(alist)
使用insert向任意一个位置插入一个元素
alist = [1, 2, 3, 4]
alist.insert(1,'hello')
print(alist)
查找元素
首先是使用 in 操作符,判定元素是否在列表中存在,返回是布尔类型
alist = [1, 2, 3, 4]
print(2 in alist)
print(5 in alist)
使用 index 方法,查找元素再列表中的下标,返回值是一个整数,如果不存在就抛出异常
alist = [1, 2, 3, 4]
print(alist.index(1))
print(alist.index(4))
如果报错,比如查找5
删除元素
使用pop方法删除最末尾元素
alist = [1, 2, 3, 4]
alist.pop()
print(alist)
或者按照下标用pop选择性删除
alist = [1, 2, 3, 4]
alist.pop(1)
print(alist)
或者按照remove的方法,按照你好值删除元素
alist = [1, 2, 3, 4]
alist.remove(4)
print(alist)
列表连接
使用+直接连接
arr = [1, 2, 3]
brr = [4, 5, 6]
crr = arr + brr
print(crr)
使用 extend 方法把一个列表拼接在另一个列表的末端
arr = [1, 2, 3]
brr = [4, 5, 6]
arr.extend(brr)
print(arr)
print(brr)
元组
元组与列表来说,在功能上是一致的,元组使用()来表示
arr = (1, 2, 3)
print(arr)元组不能修改内部元素,列表可以修改
其次,元组算一个集合类型
def getpoint():
return 0, 1
event = getpoint()
print(type(event))
元组只是不可更改,大部分操作和列表相同
为什么要有元组?
首先元组内容不可变
元组再字典中有用
字典
字典是什么
字典是一种存储键值对的结构
键值对是 键(key) 和 值(value) 进行一个一对一的映射,然后就可以根据key快速找到value
创建字典
创建一份空字典,用{ }表示字典
a = { }
b = dict()
print(type(a))
print(type(b))
也可以创建字典的同时给初始值
键值对之间使用,分割,键和值之间使用:分割.(冒号后面推荐加一个空格).
使用print打印字典内容
a = {'level': 7, 'name': '芜湖'}
print(a)其中 key是 'level' 对应的value 是 7
查找key
使用 in 可以判定key是否存在 字典 中存在 并返回布尔类型
a = {
'level': 7,
'name': '芜湖'
}
print('level' in a)
print('leve' in a)
使用[ ]通过类似于取下标的方式,获取元素的值,只不过此处的下标是key(各种类型)
a = {
'level': 7,
'name': '芜湖'
}
print(a['level'])
print(a['name'])
如果在字典中没有key 就是出现异常....(我没key 我没key)
a = {
'level': 7,
'name': '芜湖'
}
print(a['leve'])
新增或修改元素
使用[ ]可以根据key来新增或者修改value
如果key不存在,对取下标操作赋值,就是新增键值对
a = {
'level': 7,
'name': '芜湖'
}
print(a)
a['age'] = 88
print(a['age'])
如果key已经存在了,对取下标操作赋值,即为修改键值对的值
a = {
'level': 7,
'name': '芜湖'
}
print(a)
a['level'] = 88
print(a['level'])
删除元素
使用pop方法根据key删除对应键位
a = {
'level': 7,
'name': '芜湖'
}
print(a)
a.pop('level')
print(a)
遍历字典元素
直接使用for 循环能够获取到字典中所有的key,进一步取出每个值
a = {
'level': 7,
'name': '芜湖'
}
for key in a:
print(key, a[key])
取出所有的key和value
取key 用keys
a = {
'level': 7,
'name': '芜湖'
}
print(a.keys())
取valeu用values
a = {
'level': 7,
'name': '芜湖'
}
print(a.values())
items可以获取所有的key和value
a = {
'level': 7,
'name': '芜湖'
}
print(a.items())
合法的key类型
不是所有类型都可以作为字典的key
字典本质上是哈希表,也就是只有符合哈希表规则的东西才可以作为key
可以使用hash对象计算某个对象的哈希值
但凡能计算出哈希值的类型,都可以作为字典的key.
print(hash(0))
print(hash(77.5))
print(hash('age'))
print(hash(True))
列表 元组 字典 都无法计算哈希值
print(hash({}))
print(hash([]))
print(hash(()))
文件
文件是什么
变量是数据在内存中,重启关机就会消失
文件存储在硬盘中,即使关机重启也不会小时
文件有很多类型,例如txt exe mov mp4等
文件路径
经常用电脑的都知道,在硬盘中,为了找到想要的文件,往往需要按照一定的顺序打开(目录)文件夹查找,为了确定文件的位置,我们用路径来形容
这就算一个路径
而且每个文件的路径是唯一的
而且目录名之间用 \ 或者 / 来分隔的
打开文件
使用内建函数open来打开
f = open("F:/1.txt", 'w')注意
第一个参数是第一个字符串,也就是要打开的文件路径
第二个参数是一个字符串,表示打开方式,其中 r表示读 w表示写 a表示追加写
如果打开文件成功,返回一个文件对象,后宣布的读写文件曹祖都是围绕这个文件对象展开
如果没有就会报错 说 FileNotFoundError
关闭文件
使用close的方法关闭已经打开的文件
f.close()使用完文件要及时关闭 而且一个程序能打开的文件个数是存在上线的
f = open('F:/1.txt', 'w')
f.close()
flist = []
count = 0
while True:
f = open('F:/1.txt', 'w')
flist.append(f)
count += 1
print(count)
当打开8189(其实是8192个文件)个文件的时候 ,说打开了太多文件了
所以要及时关闭文件
写文件
文件打开之后就可以写文件了
要写文件就需要open.w
使用write方法写入文件
f = open('F:/1.txt', 'w')
f.write('hello')
f.close()
但如果打开方式有错误,就会报错
f = open('F:/1.txt', 'r')
f.write('hello')
f.close()
但是每次使用w都会清空原有数据
可以使用'a'实现追加写 此时会存在文件中
f = open('F:/1.txt', 'a')
f.write('hello')
f.close()
读文件
读文件需要用r的方式打开文件
使用read的方式万层操作
f = open('F:/1.txt', 'r')
whatread = f.read(9)
print(whatread)
f.close() 
如果是多行代码也可以循环读取
f = open('F:/1.txt', 'r')
for line in f:
print(f'line={line}')
f.close()
注意,如果想使用中文,要加额外的东西
f = open('F:/1.txt', 'r',encoding='utf8')想让每次打印没有空行要加
print(f'line={line}', end='')还可以通过readlines之间打印全部内容
f = open('F:/1.txt', 'r', encoding='utf8')
lines = f.readlines()
print(lines)
f.close() 
上下文管理器
是防止文件忘记关闭的东西
def func():
with open('f:/1.txt', 'r', encoding='utf8') as f:
if True:
return 0这个是当with执行的代码块结束 就会自动执行f文件的关闭
63万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
