文章目录

  • 部分基础语法
  • 字符串
  • 列表类型
  • 分支语句
  • 函数
  • 注释
  • 输入输出
  • 函数的命名与使用
  • 基本数据类型
  • 整数类型
  • 浮点数类型
  • 复数类型
  • 数值运算操作符
  • 数值运算函数
  • 字符串类型及操作
  • 字符串切片的高级用法：
  • 字符串操作符
  • 字符串处理函数
  • 字符串处理方法
  • 字符串类型的格式化
  • 程序的分支结构
  • 条件组合
  • 异常处理
  • 遍历循环
  • 计数循环
  • 字符串中的遍历循环
  • 列表遍历循环
  • 文件遍历循环
  • 无限循环
  • 循环控制保留字
  • 循环的高级用法
  • random库的使用
  • 基本随机数函数
  • 扩展随机数函数
  • 函数
  • 可选参数
  • 可变参数
  • 局部变量与全局变量
  • lambda函数
  • 代码复用与函数递归
  • 递归
  • 递归的实现执行
  • 字符串反转的小例子（代码实现）
  • 斐波那契数列的例子
  • 递归实现汉诺塔的例子
  • 组合数据类型
  • 集合类型
  • 集合间的操作
  • 集合的处理方法（方法调用都是：变量.方法）
  • 集合的应用场景
  • 序列类型
  • 序列类型的操作
  • 元组类型（序列类型的扩展）
  • 列表类型（序列类型的扩展）
  • 序列类型应用场景
  • 字典类型
  • 字典类型操作函数和方法
  • 字典类型的应用场景
  • 文件的使用
  • 文件的类型
  • 文件的打开和关闭
  • 文件内容的读取
  • 数据的文件写入
  • 一维数据的格式化和处理
  • 一维数据的表示
  • 一维数据的存储
  • 一维数据的格式化及处理
  • 二维数据
  • 二维数据的表示
  • csv格式与二维数据存储
  • CSV
  • 二维数据的存储
  • 二维数据的处理


部分基础语法

字符串
  • 字符串类型：两侧有’单引号‘或“双引号”的有序字符序列，且使用单引号和使用双引号对于表达字符串没有区别。
  • 对字符串中字符检索索引，对于字符串的序号python提供正向递增序号（从0递增）和反向递减序号（从-1递减）。
  • 使用[ ]来获取字符串中一个或多个字符
  • 索引：返回字符串中单个字符   <字符串>[M]（M为序号位置）

eg.“请输入数字”[0]（获得该字符串中第0个字符“请”）

  或TempStr[-1] (其中TempStr是变量字符串,在这表示索引这个字符串中倒数第一个字符即最后一个字符)

  • 切片：返回字符串中的一段字符串  <字符串>[M:N]

eg.“请输入数字”[1:3]（获得该字符串中第1个字符和第2个字符但不包括第3个字符）

或 TempStr[0:-1] (其中TempStr是变量字符串,在这表示从0开始但不到字符串的最后一个字符即去掉最后一个字符)

TempStr[1:]表示除第一个取剩下部分的字符串

列表类型

由0个或多个数组组成的有序序列

  • 列表使用[ ]表示，采用逗号，分隔各元素。 eg.[‘F’,‘f’]表示两个字符串F和f。
  • 可以使用保留字in判断一个元素是否在列表中

eg. TempStr[-1] in [‘C’,‘c’]判断前者是否与列表中某个元素相同，如果有相同将返回true

分支语句

使用保留字if elif else构成（冒号及缩进空格都是语法的一部分，不可省略）
if  判断条件的代码：条件为true执行冒号后的语句

函数

根据输入参数不同可产生不同输出的功能过程<函数名>(<参数>）
如：input(),print(),eval（)等处理括号内部的信息。

  • eval（)，评估函数。 可去掉参数最外侧引号并执行余下语句的函数。将括号中参数的字符串最外层引号（无论单双）去掉。如eval（“1”)运行后可得到数字1，eval（“1+2”)运行结果为3。因此也可将输入得到的字符串去掉引号得到数字。
  • map(,)函数是将第一个参数的功能作用与第二个参数(列表或集合)的每个元素
注释

单行注释用#号
多行注释用三个引号（无论三个单引号还是双引号效果相同）括起来""“注释”""

输入输出
  • 输入格式：变量=input（）
    如：TempStr=input(”请输入“)# TempStr保存用户输入的信息字符串格式
  • 输出格式 print(“这是输出”)
  • 若输出各种信息间用逗号隔离，则最终运行结果会以空格隔离，如print(“Hello:”,0)输出结果为Hello: 0
  • 输出格式化
    如：print（”温度是{:.2f}C“.format( C)）,其中{ }表示槽，后续变量填充到槽中，如本例中{:.2f}表示将变量C填充到这个位置时取小数点后2位。
  • print函数的使用中，可用使用end的一个参数来决定每一个print输出后之后是否要换行，若end=" "(空)，则输出之后不换行，所i有的输出在一行表示。如：
for i in range(12):
     print(char(9800+i),end=" ")#输出为不换号的十二星座表示符
函数的命名与使用
def 函数名(参数)
    函数体
    可return

基本数据类型

整数类型
  • 可正可负，没有取值范围限制
  • pow(x,y):计算X^y^,想算多大算多大
  • 四种进制表示形式：十进制、二进制（以0B或0b开头）、八进制（以0O或0o开头）、十六进制（以0X或0x开头）
浮点数类型
  • 浮点数运算存在不确定尾数，不确定尾数一般发生在10-16位左右。如计算0.1+0.2==0.3会输出false
  • 为避免这种情况，需要用round（ x，d）函数。通过round函数判断浮点数运算与浮点数之间的比较关系。如：round(0.1+0.2,1)==0.3此时会输出true.
  • round(x,d):对x四舍五入，d是小数截取位数。
  • 浮点数可采用科学计数法表示，使用字母e或E作为幂的符号，以10为基数，格式如下：<a>e<b> 表示a*10b如4.3e-3表示0.0043。
复数类型
  • 与数学概念中的复数一致。
数值运算操作符
  • 注意python中x与y的除，即x/y产生的是浮点数结果。
  • x//y表示整数除，x与y整数商，如10//3结果是3。
  • x%y余数，模运算
  • x**y:幂运算，x的y次幂。且当y是小数时为开方运算。
  • 且支持该格式：x+=y即x=x+y
  • 类型之间可进行混合运算，生成结果为”最宽“的类型（整数->浮点数->复数）如整数+浮点数结果=浮点数。
数值运算函数
  • abs(x):对x求绝对值
  • divmod(x,y)：商余，同时输出商和余数。如divmod（10，3）结果为（3，1）
  • pow(x,y[,z])：幂余，（x**y)%z，z两侧有方括号表示参数z可省略。如计算3的3的99次方的最后四位可如此操作：pow(3,pow(3,99),10000)结果为4587。
  • round(x,[d])：四舍五入，d是保留小数位数，默认值为0.
  • max(x1,x2,…,xn):最大值，返回其中的最大值，n不限
  • min(x1,x2,…,xn):最小值，返回其中的最小值，n不限
  • int(x)将x变为整数，舍去小数部分，也可将字符串变为整数，如int(“123”)结果为123这样。
  • float(x)：将x变为浮点数，增加小数部分，也同样可将字符串变为浮点数
  • complex:将x变为复数，增加虚数部分。

字符串类型及操作

  • 字符串有2类共四种表示方法
  • 由一对单或双引号表示，仅表示单行字符串
  • 由一对三单或三双引号表示，可表示多行字符串，字符串文本有单引号，则最外层用双引号，若文本中既有单引号又有双引号，可用三个单引号来表示。
  • 字符串的索引和切片，上文已讲
字符串切片的高级用法：
  • <字符串>[M:N],M缺失表示至最开头起，N缺失表示至结尾
  • <字符串>[M:N:k],根据步长k对字符串切片。如：“零一二三四五六七八九十”[1:8:2]结果是“一三五七”
  • 若为[::-1]表示将字符串逆序
  • \为转义符，转义符之后的字符为其本意（常用意义：\b表示光标回退，\n光标换行，\r回车光标到本行）
字符串操作符

操作符及使用

描述

x+y

连接两个字符串x和y

n*x或x*n

复制n次字符串x

x in s

若x是s的子串，返回True,否则返回False

#获取星期字符串
weekStr="星期一星期二星期三星期四星期五星期六星期日"
weekId=eval（input("请输入星期数字（1-7）:"))
pos=(weekId-1)*3
print(weekStr[pos:pos+3])
'''
也可以这样写：
weekStr="一二三四五六日"
weekId=eval（input("请输入星期数字（1-7）:"))
print("星期"+weekStr[weekId-1])
'''

结果如下图

Python语法练习心得体会 python基础语法总结_字符串

字符串处理函数

函数及使用

描述

len(x)

返回字符串x的长度

str(x)

任意类型x转换为所对应的字符串形式

hex(x)或oct(x)

将整数x形成它的十六进制或八进制小写形式字符串

chr(u)

u为Unicode编码，返回其对应的字符

ord(x)

x为字符，返回其对应的Unicode编码

字符串处理方法
  • “方法”特指<a>.<b>()风格中的函数<b>()
  • 方法本身也是函数，但与<a>有关，<a>.<b>()风格使用
  • 字符串及变量也是<a>，存在一些方法
  • 方法必须以这种<a>.<b>()风格使用

方法及使用

描述

str.lower()或str.upper()

可将字符串中的字符变成全大小或全小写，如“AbcdEf”.lower()结果为“abcdef”

str.split(sep=None)

返回一个列表，由str根据sep被分隔的部分组成。如：“A，B，C”.split(",")结果为[‘A’,‘B’,‘C’]

str.count(sub)

返回子串sub在str中出现的次数

str.replace(old,new)

将字符串中旧子串替换为新的部分后返回。如"write".replace(“e”,“ing”)结果为"writing"

str.center(width[,fillchar])

字符串str可根据宽度width居中，fillchar可选，如"python".center(20,"=")结果为‘=======python=======’

str.strip(chars)

从str中去掉在其左侧和右侧chars中列出的字符。如"=python=".strip("  =np")结果为"ytho"

str.join(iter)

在iter变量除最后元素外每个元素后增加一个str",".join(“12345”)结果为"1,2,3,4,5"#主要用于字符串分隔等

字符串类型的格式化

格式化是对字符串进行格式表达的方式

  • 字符串格式化使用.format()方法，用法如下：
    <模板字符串>.format(<逗号分隔的参数>)
    槽{ }，如：
  • “{ }：计算机{ }的cpu占用率为{ }%”.format(“2018-10-10”,“C”,10)按顺序对应填入前面的槽内。
  • 但也可以指定要填入槽的位置如：
    “{1 }：计算机{0 }的cpu占用率为{ 2}%”.format(“2018-10-10”,“C”,10)将"2018-10-10"填入前面指定写0的槽内，以此类推。
  • 槽内部对格式化的配置方式{<参数序号>：<格式控制标记>}

:

<填充>

<对齐>

<宽度>

< ，>

<.精度>

<类型>

引导符号

用于填充的单个字符

<左对齐，>右对齐，^居中对齐

槽设定的输出宽度

数字的千位分隔符

浮点数小数精度或字符串最大输出长度

整数类型b,c,d,o,x,X浮点数类型e,E,f,%

  • 如："{0:=^20}".format(“PYTHON”) , 结果为’=======PYTHON=======’
    其中{0:=^20}的冒号为引导符号，第一个等号为要填充符号，^表面要居中对齐，指的是所放入槽中的format方法的第0个参数以居中对齐的方式来显示，第三个20为输出宽度。
  • 如"{0:*>20}".format(“BIT”)结果为‘******************BIT’省略要填充的字符，则默认为填充为空格
  • 如”{0:,.2f}“.format(12345.6789)结果为’12,345.68’
  • “{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}”.format(425)
    结果为’110101001,Python语法练习心得体会 python基础语法总结_浮点数_02,425,651,1a9,1A9
  • 其中:b为二进制形式输出，:c为Unicode字符形式输出，:d为十进制形式，:o为八进制形式，:x为16进制形式，:X为大写16进制形式输出。:e为用科学记数法e形式表示浮点数，:E为用科学记数法E（大写的E)形式表示浮点数，:f为以通常的非科学计数法表示形式，:%指以%形式表示浮点数。

程序的分支结构

二分支结构的紧凑形式
<表达式1> if <条件> else <表达式2>
例如

guess =eval（input())
print("猜{}了".format("对" if guess==99 else"错"))

条件组合

用于条件组合的三个保留字

操作符及使用

描述

x and y

两个条件x与y的逻辑与

x or y

两个条件x与y的逻辑或

not x

条件x的逻辑非

异常处理

try:
    <语句块1>
except:
    <语句块2>

或表明异常类型，但标明后仅响应此类异常

try:
    <语句块1>
except <异常类型>:
    <语句块2>

异常处理的高级用法

try:
    <语句块1>
except:
    <语句块2>#有异常时执行
else:
    <语句块3>#当语句块1无异常，则执行
finally:
    <语句块4>#该处语句无论是否有异常一定执行

遍历循环

for  <循环变量>  in  <遍历结构>：
      <语句块>
  • 每次循环，从遍历结构中逐一提取元素，所获得元素放入循环变量，并执行一次语句块，直到所有元素都遍历过了。
计数循环
#计数循环
for i in range(N):
    <语句块>

range(M,N,K)，产生数字序列，从M开始到N之前的整数，k是步长。如range(1,6,2)产生的是1，3，5.

字符串中的遍历循环
#字符串中的遍历循环
for c in s:#s是字符串，c代表字符串中的每个字符
    <语句块>
---------------------------------------
   如for c in"python123"
         print(c,end=",")
         打印结果是p,y,t,h,o,n,1,2,3
列表遍历循环
for item in Ls:#Ls是一个列表，遍历其每个元素，产生循环
     <语句块>
---------------------------------------
如：for item in [123,"PY",456]:
        print(item,end=",")
        打印结果是123,PY,456
文件遍历循环
for line in fi:#fi是文件标识符，遍历其每行，产生循环
    <语句块>
无限循环
while <条件>：
      <语句块>
循环控制保留字

break：跳出循环体
continue：跳出当次循环，继续下一次循环

循环的高级用法

循环可与else搭配，当循环没有被break退出时，执行else语句块。

for  <循环遍量>  in  <遍历结构>：
      <语句块1>
else:
      <语句块2>
-------------------------------
或while <条件>:
        <语句块1>
  else:
        <语句块2>

random库的使用

  • 基本随机数函数：seed(),random()
  • 扩展随机数函数：randint(),getrandbits(),uniform(),randrange(),
    choice(),shuffle()。
基本随机数函数

函数

描述

seed(a=None)

初始化给定随机数种子，默认为当前系统时间，要利用随机数种子产生随机数。

random()

生成一个[0.0,1.0)之间的随机小数，这个随机数的产生与所选取的种子有关，种子相同产生的随机数相同，若没有种子默认种子为系统时间无法复现这个随机数。

扩展随机数函数

函数

描述

randint(a,b)

产生一个[a,b]之间的整数

randrange(m,n,[k])

生成一个[m,n)之间以k为步长的随机整数

getrandbits(k)

生成一个k比特步长的随机整数

uniform(a,b)

生成一个[a,b]之间的随机小数

choice(seq)

从序列seq中随机选择一个元素。例random.choice([1,2,3,4,5,6,7,8,9])

shuffle(seq)

将序列seq中元素随机排列，返回打乱后的顺序。

函数

def 函数名(形式参数，可选参数（0个或多个））：#无论是否有参数都要有括号
    函数体
    return 返回值（可以有也可以没有，返回多个值用逗号分隔）
--------------------------------- 
调用方法： 函数名（实际参数）
a,b,c=fact(10,5)#指将函数数的三个返回值分别赋给a,b,c
可选参数
  • 函数定义时，可以为某些参数指定默认值构成可选参数（可以提供参数也可以不提供参数的叫可选参数）如
例
def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
     return s//m
-------------------------------
调用直接为fact(10)这样m为1;也可fact(10,5)（按位传递参数）这样调用m则为5 ，或fact(m=5,n=10） （按名称传递参数）
可变参数
  • 函数定义时可以设计可变数量参数，即不确定参数总数量 
def <函数名>(<参数>，*b):（前面的是确定的参数，*b表示不确定的参数）
    <函数体>
    return <返回值>
例
def fact(n,*b):
    s=1
    for i in range(1,n+1):
        s*=i
    for item in b# 依次提取可变参数的值作为item
        s*=item
     return s
-------------------------------
调用fact(10,3)或fact(10,3,5,8)
局部变量与全局变量
  • 局部变量可能与全局变量重名，但不相同
  • 可以使用保留字globle在函数内部使用全局变量（用来在函数内部声明这个变量为全局变量）
  • 局部变量为组合数据类型且未创建，等同于全局变量
ls=["F","f"]#通过使用[]真实创建了一个全局变量列表ls
def func(a)
    ls.append(a)#此处ls是列表类型，未在函数内部真实创建，则等同于全局变量
    return
func("C")# 全局变量ls被修改
print(ls)#运行结果为['F','f','C']

lambda函数

  • lambda函数返回函数名作为结果
  • lambda函数是一种匿名函数，即没有名字的函数
  • 使用lambda保留字定义，函数名是返回结果
  • lambda函数用于简单的、能够在一行内表示的函数
  • 定义形式：<函数名>=lambda <参数>：<表达式>等价于def定义的函数，但不能用函数体只能用表达式。
  • 也可无参：<函数名>=lambda: <表达式>如f=lambda:"hello"调用f()
  • 如：f=lambda x,y:x+y(定义了一个函数参数为x和y，内容是x+y,名字就是通过函数定义后要赋值给的变量即f,调用f(10,15)
  • 谨慎用lambda函数，主要用于特定的函数或方法的参数，有些复杂的函数，它的某个参数就是一个函数作为一个参数来使用，这样用lambda函数。
  • 一般都用def形式定义的函数

代码复用与函数递归

紧耦合：两个部分之间交流较多，无法独立存在
松耦合：两个部分之间交流较少，可以独立存在
模块内部紧耦合，模块直接松耦合

递归

自身调用自身
两个关键特征：链条和基例

  • 链条：计算过程存在递归链条
  • 基例：存在一个或多个不需要再次递归的基例
递归的实现执行

函数+分支语句

  • 递归本身是一个函数，需要函数定义方式描述
  • 函数内部，采用分支语句对输入参数进行判断
  • 基例和链条，分别编写对应代码
字符串反转的小例子（代码实现）
def rvs(s):
    if s=="":
        return s
    else:
        return rvs(s[1:]+s[0]
斐波那契数列的例子

Python语法练习心得体会 python基础语法总结_Python语法练习心得体会_03

def f(n):
	if n==1 or n==2:
		return 1
	else:
		return f(n-1)+f(n-2)
递归实现汉诺塔的例子

假设三根柱子A，B，C，初始圆盘都在柱子A上，n个圆盘要移动

count =0
def hanoi(n,src,dst,mid):#圆盘数量，原柱子，目标柱子，中间过渡柱子
globle count#每次移动盘子时，加1
if n==1:
	print("{}:{}->{}".format(1,src,dst))
	count+=1
else:
	hanoi(n-1,src,mid,dst)
	print("{}:{}->{}".format(n,src,dst))
	count+=1
	hanoi(n-1,mid,dst,src)
hanoi(3,"A","B","C")
print(count)

组合数据类型

集合类型

  • 与数学中定义类似，无序，不重复
  • 集合元素不可更改，不能是可变数据类型
  • 集合用大括号{}表示，元素间用逗号分隔
  • 建立集合类型用{}或set()
  • 建立空集合类型，必须使用set()如B=set(“pypy123”)#生成有五个元素的集合
集合间的操作

交、并、差、补、差

操作符及其应用

描述

S|T

返回一个新集合，包含在集合S和T中的所有元素

S-T

返回一个新集合，包括在集合S但不在T中的元素

S&T

返回一个新集合，包括同时在S和T中的元素

S^T

返回一个新集合，包括S和T中的非相同元素

S<=T或S<T

返回True或False,判断S和T的子集关系

S>=T或S>T

返回True或False,判断S和T的包含关系

操作符及其应用

描述

S|=T

更新集合S，包括在S和T中的所有集合

S-=T

更新集合S，包括在S和T中的所有集合

S&=T

更新一个新集合，包括同时在S和T中的元素

S^=T

更新一个新集合，包括S和T中的非相同元素

集合的处理方法（方法调用都是：变量.方法）

操作函数或方法

描述

S.add(x)

如果x不在集合S中，将X增加到S

S.discard(X)

移除S中元素X，若X不在其中不报错

S.remove(X)

移除S中元素X，若X不在集合S中，产生KeyError异常

S.clear()

移除S中的所有元素

S.pop()

随机返回S的一个元素，更新S（返回给用户，同时删除这个元素），若S为空产生KeyError异常

S.copy()

返回集合S的一个副本

len(S)

返回集合S的元素个数

x in S

判断S中元素X，X在集合S中，返回True，否则Flase

x not in S

判断S中元素X，X不在集合S中，返回True，否则Flase

set(X)

将其他类型变量X转变为集合类型

从A中不断的取出元素打印，while的巧妙实现(for in也可实现)

#从A中不断的取出元素打印，while的巧妙实现
A=set("pypy123")
try:
    while True:
        print(A.pop(),end="")
except:
    pass
集合的应用场景
  • 数据去重：集合类型元素无重复
去重例如：
ls=["p","p","y","y",123]
s=set(ls)#利用了集合无重复的特点
lt=list(s)#将集合转换为列表

序列类型

  • 序列是具有先后关系的一组元素
  • 序列是一维元素向量，元素类型可以不同
  • 元素间由序号引导，通过下标访问序列的特定元素
  • 序列类型是一个基本数据类型（字符串类型、元组类型、列表类型都是衍生）
  • 存在正向递增与反向递减序号
序列类型的操作

操作符及应用

描述

x in S

若X是序列S的元素，返回True，否则Flase

x not in S

若X是序列S的元素，返回False，否则True

s+t

连接两个序列s和t

sn或ns

将序列s复制n次

s[i]

索引，返回s中的第i个元素，i是序列的序号

s[i:j]或s[i:j:k]

切片，返回序列s中第i到j以k为步长的元素子序列

函数和方法

描述

len(s)

返回序列s的长度

min(s)

返回序列s的最小元素，s中元素需要可比较

max(s)

返回序列s的最大元素，s中元素需要可比较

s.index(x)或s.index(x,i,j)

返回序列s从i开始到j位置中第一次出现元素x的位置

s.count(x)

返回序列s中出现x的总次数

元组类型（序列类型的扩展）
  • 元组是一种序列类型，一旦创建就不能被修改
  • 使用小括号（）或tuple()创建，元素间用逗号分隔
  • 可以使用或不使用小括号
  • 元组类型继承序列类型的全部通用操作
  • 元组因为创建后不能修改，因此没有特殊操作
  • 使用creature切片操作时，生成的是新的元组，不是修改原来的。

列表类型（序列类型的扩展）

  • 列表是一种序列类型，创建后可随意被修改
  • 列表类型用方括号[]或list()创建，元素间用逗号分隔
  • 列表中各元素类型可以不同，无长度限制
  • 若通过=将一个列表变量给另外一个列表变量，并没有真正生成一个列表，而是将同一个列表赋给不同的名字。

函数和方法

描述

ls[i]=x

替换列表ls第i个元素为x

ls[i:j:k]=lt

用列表lt替换ls切片后所对应元素子列表

del ls[i]

删除列表ls中第i个元素

del ls[i:j:k]

删除列表ls中第i到第j以k为步长的元素

ls+=lt

更新列表ls,将lt元素增加到列表ls中

ls*=n

更新列表ls,其元素重复n次

函数和方法

描述

ls.append(x)

在列表ls最后增加一个元素x

ls.clear()

删除列表ls中的所有元素

ls.copy()

生成一个新列表，赋值ls中所有元素

ls.insert(i,x)

在列表ls的第i位置增加元素x

ls.pop(i)

将列表ls中第i位置元素取出并删除该元素

ls.remove(x)

将列表ls中出现的第一个元素x删除

ls.reverse()

将列表ls中元素反转

序列类型应用场景
  • 元组用于元素不改变的应用场景，更多用于固定搭配的场景
  • 列表更加灵活，它是最常用的序列类型。
  • 最主要作用：表示一组有序数据，进而操作它们
  • 数据保护：若不希望数据被程序修改，转换成元组类型

字典类型

  • 映射是一种键(索引)和值(数据)的对应
  • 字典中元素无序
  • 字典类型是映射的体现，键是数据索引的扩展
  • 字典是键值对的集合，键值对之间无序
  • 采用大括号{}和dict()创建，键值对用冒号：表示
  • 在字典变量中，通过键获得值
  • [ ]用来向字典变量中索引或增加元素，如d={“中国“：”北京”，“英国”：“伦敦”}，d[“中国”]返回‘北京’
  • de={}生成空的字典;type(de)返回变量de的类型
  • d中新增键值对元素d[“a”]=1
字典类型操作函数和方法

函数和方法

描述

del d[k]

删除字典d中键k对应的数据值

k in d

判断键k是否在字典d中，如果在返回True否则返回False,

d.keys()

返回字典d中所有的键信息

d.values()

返回字典d中所有的值信息

d.items()

返回字典d中所有键值信息

d.get(k,<default>)

键k存在，则返回相应值，不在则返回<default>值

d.pop(k,<default>)

键k存在，则取出相应值，不在则返回<default>值

d.popitem()

随机从字典d中取出一个键值对。以元组形式返回

d.clear()

删除所有键值对

len(d)

返回字典d中元素的个数

字典类型的应用场景
  • 映射的表达，表达键值对数据，进而操作它们
  • 元素遍历：for k in d:由键来逐一的索引字典中对应的值

文件的使用

文件的类型
  • 文件的展现形态：文本文件和二进制文件
  • 文本文件由单一特定编码组成的文件，如UTF-8编码
  • 二进制文件直接由0和1组成，没有统一字符编码如(.png文件)
文件的打开和关闭
  • 打开文件:<变量名>=open(<文件名(路径(同目录可省路径)和名称)>，<打开模式(rb等)>)，路径中的\用/代替或用两个\，因为python中\代表转义字符。
  • 相对路径：打开的文件与当前程序路径的关系。如当前程序在d盘根目录下，要打开D中PYE目录下的f文件则"./PYE/f.txt"

文件的打开模式

描述

‘r’

只读模式，默认值，如果文件不存在，返回FileNotFound

‘w’

覆盖写模式，文件不存在则创建

‘x’

创建写模式，文件不存在则创建，存在则完全覆盖

‘a’

追加写模式，文件不存在则创建，存在则在文件最后面追加内容

‘b’

二进制文件模式

‘t’

文本文件模式，默认值

‘+’

与r/w/x/a一同使用，在原功能基础上增加同时读写功能

文件关闭：<变量名>.close

文件内容的读取

操作方法

描述

.read(size=-1)

读入全部内容，如果给出参数，读入前size的长度

.readline(size=-1)

读入一行内容，如果给出参数，读入该行前size长度

.readlines(hint=-1)

读入所有行，以每行为元素形成列表，如果给出参数，读入该行前hint行bian

遍历全文本：方法一用f.read全部读入可能内存占用大
方法二：一部分一部分读入

# 分次读入
fname=input("要打开的文件名称")
fo=open(fname,"r")
txt=fo.read(2)
while txt!="":
	txt=fo.read(2)#两个两个读入，直到空
fo.close()

逐行遍历的方法

#逐行遍历的方法,一次读入，分行处理
fname=input("要打开的文件名称")
fo=open(fname,"r")
for line in fo.readlines():
	print(line)
fo.close()
--------------------------------
#分行读入，逐行处理
fname=input("要打开的文件名称")
fo=open(fname,"r")
for line in fo:
	print(line)
fo.close()
数据的文件写入

操作方法

描述

.write(s)

向文件写入一个字符串或字节流

.writelines(lines)

将一个元素全为字符串的列表写入文件

.seek(offset)

改变当前文件操作的位置，offset的含义如下：o-文件开头；1-当前位置；2-文件结尾

fo=open("output.txt","w+")
ls=["中国","法国","美国"]
fo.writelines(ls)
fo.seek(0)#类似改变指针的操作位置至文件初始位置，才能打印前面的信息
for line in fo:
	print(line)
fo.close()

一维数据的格式化和处理

  • 数据的组织方式：一维或二维
  • 一维：由对等关系的有序或无序数据构成，采用线性组织方式
  • 二维数据：由多个一维数据构成，一维数据的组合形式
  • 多维数据：由一维或二维在新维度上的扩展
  • 数据的操作周期：数据存储，数据表示，数据操作
一维数据的表示
  • 若数据间有序：使用列表类型，用for循环进而对每个数据进行处理
  • 若数据间无序：使用集合类型，用for循环进而对每个数据进行处理
一维数据的存储
  • 方式一：使用一个或多个空格进行存储，不换行（缺点：数据中不能存在空格）
  • 方式二:英文半角逗号分隔，不换行（缺点：数据中不能有英文逗号）
  • 方式三:其他方式,建议用特殊符号。
一维数据的格式化及处理
  • 将存储的数据读入程序
  • 将程序表示的数据写入文件
    如：从空格分隔的文件中读入数据
txt=open(fname).read()
ls=txt.split()#用空格分隔变为列表
f.close()

用空格分隔方式将数据写入文件

#用空格分隔方式将数据写入文件
ls=['中国','美国','日本']
f.open(fname,'w')
f.write(' '.join(ls))
f.close()

二维数据

二维数据的表示
  • 使用二维列表类型（本身是列表，列表中的元素又是列表）表达。
  • 用两层for循环遍历每个元素，外层中的每个元素可以对应一行也可以对应一列
csv格式与二维数据存储
CSV
  • csv:由逗号分隔的值
  • 国际通用的一二维数据存储格式，一般.csv扩展名
  • 每行一个一维数据，采用逗号分隔，无空行。不同行就构成了另一个维度
  • Excel和一般编辑软件都可以读入或另存为csv文件
  • 若某个元素缺失，逗号要保留
  • 表头可以作为数据存储，也可以另行存储
  • 逗号为英文半角逗号，逗号与数据之间无额外空格
二维数据的存储
  • 按行存或按列存都可以，具体由程序决定
  • 一般索引习惯：Is[row][column],先行后列
  • 根据一般习惯，外层列表每个元素是一行，按行存
二维数据的处理

从csv格式的文件中读入数据

fo=open(fname)
	ls=[]#二维空列表ls
	for line in fo#读入文件的每一行
		line=line.replace("\n"," ")#将最后的回车替换为空字符串
		ls.append(line.split(","))#将每行按逗号分隔形成列表，并将这个列表增加到ls中，作为其中的一个元素。
	fo.close()

将数据写入CSV格式的文件

ls=[[],[],[]]#二维列表
f=open(fname,'w')#将ls中的每一个元素作为一行写入
for item in ls:
f.write(','.join(item)+'\n')#每一行中间增加逗号，每一行结束处换行

二维数据的逐一处理：采用二层循环

ls=[[1,2],[3,4],[5,6]]
for row in ls;
	for row in ls:
		print(colum)