计算机二级——Python-学习笔记

计算机二级——Python

第一章 基础语法入门

Python源文件扩展名为 ： .py

在IDLE中创建新文件的快捷键：CTRL+N

一、标识符

在Python程序中用来起名字的字符序列，如：变量名、类名、模块名等

标识符命名规则：

1. 由大写字母、小写字母、数字、下划线、汉字组成

2. 对大小写敏感，不能以数字开头

3. 中间不能出现空格，长度没有限制

从编程角度看：见名知意即可

Python共35个保留字

二、变量与常量

变量：Python编程中用来存储数据的最小单元，它有类型、名字、值

常量：类似数学中的常数，通常情况下，变量的值就是常量

三、代码注释

# 注释内容
  """
  注释内容
  """
  '''
  注释内容
  '''
  ​
  # 下面是将10的值赋值给变量a
  a = 10
  name = "Kite" # 左边是将字符串”Kite“赋值给变量name
  pi = 3.14
  print(a)
  print(pi)
  print(name)
  """
  上面是关于变量与常量
  的例子
  """
  '''
  上面是关于变量与常量
  的例子
  '''

第二章 数据类型

一、基本数据类型-数值型-整数类型

1.整数类型

进制种类	引导符号	描述
十进制	无	默认情况，例：1100，-1100
二进制	0b或0B	由字符0和1组成，例：0b1010，0B1010
八进制	0o或0O	由字符0到7组成，例：0o010，0o1010
十六进制	0x或0X	由字符0~9、a~f或A~F组成，例：0x1010，0X1010

  print(123) # 十进制
  print(0b1011) # 二进制
  print(0o123) # 八进制
  print(0x123) # 十六进制

2.任何进制数据转换成十进制——按权展开式

二进制——>十进制

1010=1x2的三次方+0x2的二次方+1x2的1次方+0x2的0次方=8+0+2+0=10

八进制——>十进制

167=1x8的二次方+6x8的1次方+7x8的0次方=64+48+7=119

十六进制——>十进制

24B=2x16的二次方+4x16的1次方+11x16的0次方=512+64+11=587

二、基本数据类型-数值型-浮点类型

普通浮点类型：带小数点的数字

1.23 3.14

科学计数法浮点数：有e或E组成

规定：e或E的左右两边都有数字且e或E的右边必须是整数

三、基本数据类型-数值型-复数类型

复数a+bj，其中a是实数部分，简称实部，b是虚数部分，简称虚部，虚数部分通过后缀”J“或”j“来表示

j=根号下-1，j为虚数单位

注意：当b为1时，1不能省略，即1j

对于复数z，可以使用z.real和z.imag 分别获得它的实数部分和虚数部分

a = 12 + 5j
print(a.real)   # 获取变量a的实数部分
print(a.imag)   # 获取变量a的虚数部分

三、基本数据类型-字符串

# 双引号括起来的字符串：

  
"Hello World"
# 单引号括起来的字符串

  
'Hello World'
# 一对三个双引号括起来的字符串

  
"""Hello,大家好
  这里可以换行
"""
# 一对三个单引号括起来的字符串

  
'''Hello,大家好
  这里可以换行
'''

四、基本数据类型-布尔类型

通常用来做逻辑判断

True——真

False——假

五、type()函数

可以用来识别某个变量或常量的数据类型

整数：int

浮点数：float

复数：complex

字符串：str

布尔类型：bool

a = 123
b = 3.14
c = 5 + 2j
d = "大家好"
e = True
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))
  
age = "16"
age_new = int(age)  # 将变量age转换成整数类型并赋值给变量age_new
print(type(age_new))

第三章 运算符

一、算数运算符和字符串连接符

1.运算符-算数运算符（数值运算操作符）

运算符	举例	描述
+	x+y	x与y的和
-	x-y	x与y的差
*	x*y	x与y的积
/	x/y	x与y的商
//	x//y	x与y的商
%	x%y	x与y取商后的余数，也成为模运算
**	x**y	x的y次幂
+	+x	x的本身
-x	-x	x的负值，即x*（-1）

  x = 10
  y = 4
  z = 3
  c = 2
  print(x + y)    # 加
  print(x - y)    # 减
  print(x * y)    # 乘
  print(x / y)    # 除
  print(x // y)    # 整除
  print(x % y)    # 取余数
  print(x % z)    # 取余数
  print(c ** z)    # 幂运算

  

  ​

2.运算符-字符串运算符

运算符	举例	描述
+	x+y	字符串x与字符串y连接
*	x*y	复制y次字符串x

  s1 = "how"
  s2 = " are you!"
  a = 10
  print(s1 + s2)
  print(s1 * a)

3.运算符-赋值运算符、增强赋值运算符

运算符	举例	描述
=	x = 1	将1赋值给变量x
+=	x += 1	与x = x+1相同
-=	x -= 1	与x = x-1相同
*=	x *= 1	与x = x*1相同
/=	x /=1	与x = x/1相同
//=	x //= 1	与x = x//1相同
%=	x %=1	与x = x%1相同
**=	x **= 1	与x = x**1相同

  a = 3
  b = 5
  a , b = b , a   # 将变量a和变量b中的值进行调换
  print(a , b)
  print("a的值为："+ str(a))
  print("b的值为："+ str(b))

4.运算符-关系运算符

运算符	举例	描述
<	x < y	判断x是否小于y
>	x > y	判断x是否大于y
<=	x <= y	判断x是否小于等于y
>=	x >= y	判断x是否大于等于y
==	x == y	判断x是否等于y
!=	x != y	判断x是否不等于y

  a = 5 # 将5的值赋值给变量a
  print(a == 5)   # 判断变量a的值等于5么
  print(a != 5)   # 判断变量a的值不等于5么
  print(a >= 5)   # 判断变量a的值大于等于5么
  print(a <= 5)   # 判断变量a的值小于等于5么

计算后的结果值为布尔数据类型

5.运算符-逻辑运算符

运算符	举例	描述
not	not x	如果x的值为True，结果为False，如果x的值为False，结果为True
and	x and y	x或y任意一个为False，结果为False，否则结果为True
or	x or y	x 或 y 任意一个围殴True，结果为True，否则结果为False

二、input()函数

用来接收键盘输入的内容，接收的内容默认为字符串类型

  # 由键盘接收一个年龄
  age = input("请输入您的年龄：") # 接收键盘输入的内容并赋值给变量age
  print("年龄为：" + age)
  print(type(age))
  # 将接收到的年龄进行加10计算，并赋值给变量age_new
  age_new = int(age) + 10
  print("计算的年龄为："+ str(age_new))

第四章 程序控制结构-分支结构

程序控制的三种结构

• 顺序结构

•   print("hello")
    print(123)

• 分支结构

• 循环结构

一、分支结构-单分支结构：if

  
  if <条件>:
      <语句块>

  # 判断一个成绩是否及格
  score = float(input("请输入一个成绩"))
  if score >= 60:
      print("恭喜你，成绩及格")
      print("成绩大于等于60分")

二、分支结构-二分支结构：if-else

  
  if <条件>:
      <语句块1>
  else:
      <语句块2>

  # 判断一个成绩是否及格，及格或不及格都要有对应的提示信息
  if score >= 60:
      print("恭喜你，及格了")
  else:
      print("不及格")

三、分支结构-多分支结构：if-elif-else

  
  if <条件1>:
      <语句块1>
  elif <条件2>:
      <语句块2>
  ···
  else:
      <语句块n>

  # 输入一个成绩，判断这个成绩是及格？优秀？不及格？
  score = float(input("请输入你的成绩"))
  if score >= 80:
      print("成绩优秀")
  elif score >= 60 and score < 80:
      print("成绩及格")
  else:
      print("不及格")

第五章 程序控制结构-循环结构

循环结构

• 遍历循环：for

• 无限循环：while

一、while循环

  
  while <条件>:
      <语句块>

  # 输出10次HelloWorld
  i = 0
  while i < 10:
      print("HelloWorld")
      i = i + 1
      
  # 输出1-100所有的值
  i = 1
  while i <= 100:
      print(i)
      i = i + 1
  ​
  # 计算1-100的和
  sum = 0 # 用来累计和
  i = 1
  while i <= 100:
      sum = sum + i
      i = i + 1
  print(sum)

  
  while <条件>:
      <语句块1>
  else:
      <语句块2>

二、循环控制-continue

continue 用来结束当前本次循环，continue 后面的内容不会执行，然后继续执行下一次循环

  # 输出1-100之间的所有偶数
  i = 0
  while i <= 100:
      i = i + 1
      if i % 2 == 0:
      print(i)
  ​
  ​
  i = 0
  while i <= 100:
      i = i + 1
      if i % 2 == 1:
          continue
      print(i)

三、循环控制：break

break 用来终止所在的循环

  # 输出1-100之间的前三个偶数
  i = 0
  count = 0 # 用来计数
  while i <= 100:
      i = i + 1
      if i % 2 == 0:
          print(i)
          count = count + 1
      if count == 3:
          break

第六章 程序控制结构-异常处理

异常处理

try-except

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

  score = float(input("请输入你的成绩："))
  print(score)
  ​
  try:
      score = float(input("请输入你的成绩："))
      print(score)
  except:
      print("程序出错了，请稍后···")

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

  try:
      a = 5
      b = 0
      print(a/b)
  except ZeroDivisionError:
      print("这里不能除以零···")
  except:
      print("出错了")

  

  ​

第七章 函数基础

一、函数的定义（声明）

• 降低编程难度

• 增加代码复用

函数的定义（声明）

  
  def <函数名>)(<参数列表>)：
      <函数体>
      return <返回值>

  def fun():
      sum = 0
      i = 1
      while i <= 100:
          sum += i
          i += 1
      print(sum)
      
  fun()

二、函数的使用

<函数名>(<实际赋值参数列表>)

三、函数参数与返回值

1.参数的传递

• 形式参数：简称形参，函数定义（声明）时使用的参数

• 实际参数：简称实参，函数被调用时实际传入的参数

  # a和b是形参
  def fun(a , b):
      print(a + b)
  ​
  fun(5 , 6) # 5,6是实参
  ​
  m = 7
  n = 8
  fun(m,n) # m和n是实参

2.不同场景如何使用参数与返回值

• 无参数、无返回值

• 有参数、无返回值

• 无参数、有返回值

• 有参数、有返回值

  # 输出1-100之间的和
  #无参数、无返回值
  def fun1():
      sum = 0
      i = 1
      while i <= 100:
          sum += i
          i += 1
      print(sum)
  ​
  # 输出1-100之间的和
  # 无参数，有返回值
  def fun2():
      sum = 0
      i = 1
      while i <= 100:
          sum += i
          i += 1
      return sum
  print(fun2())
  ​
  # 实现传入一个成绩，判断该成绩是否及格，并输出及格或不及格
  ​
  def fun3(s):
      if s >= 60:
          print("及格")
      else:
          print("不及格")
  fun3(60)
  ​
  # 实现传入一个成绩，判断该成绩是否及格，如果及格返回True，否则返回False
  def fun4(s):
      if s >= 60:
          return True
      else:
          return False
  print(fun4(70))

3.可选参数

  
  def <函数名>(<非可选参数列表>,<可先参数>=<默认值>):
      <函数体>
      return <返回值列表>

  # 声明一个函数，可以计算两个数相加的和，默认第二个数的值为5，也可以传入参数改变
  def fun(a , b=5):
      print(a + b)
  ​
  fun(10) # 15
  fun(10 , 20)    # 30

四、函数变量的作用域

1.局部变量

在函数内部定义的变量，仅在函数内部有效，当函数退出时变量将不在存在

2.全局变量

• 在函数之外定义的变量，在程序执行过程有效

• 全局变量在函数内部使用时，需要提前使用保留字global声明

  语法：global <全局变量>

  # 全局变量
  n = 5
  def fun(a):
      # a和b是局部变量，因为是在函数内部声明的
      a = 10
      b = 15
      print(a , b)
      print(n)
  fun(1)
  
  n = 2
  def fun(a , b):
      global n
      n = a * b
      print(n)
  fun(5 , 6)
  print(n)

五、print()函数

输出不换行的办法

  # print(<待输出的内容>,end = "<增加的输出结尾>")
  a = 26
  print(a, end='')
  print(a)
  def fun(a , b = 5):
      print(a , b)
  fun(a = 10 , b = 20)
  fun(10 , 20)
  fun(b = 15 , a = 20)

第八章 字符串操作

一、字符串操作符

运算符	举例	描述
+	x + y	字符串x与字符串y连接
*	x * y	复制y次字符串x
in	x in y	如果x是y的子串，返回True，否则返回False

  s1 = "Hello"
  s2 = "World"
  print(s1 + s2)
  print(s1 * 5)
  
  s1 = "How are you doing?"
  print("are" in s1)
  print("aa" in s1)
  s2 = "yo"
  print(s2 in s1)

二、字符串索引、切片

1.字符串索引

• 索引用来表示字符串中字符所在位置

• 基于位置，可以快速找到对应的字符

• 如果一个字符串中有n个字符，那么索引的取值范围是0~n-1

<字符串或字符串变量>[索引]

  s = "How are you doing?"
  print(s[0])

2.字符串切片

• 使用切片可以获取字符串指定索引区间的字符，不包含结束索引位置，左开右闭

<字符串或字符串变量>[开始索引:结束索引:步长]

  s = "How are you?"
  print(s[1:6])   # 从字符串s中取第一个位置到第6个位置的字符串，不包含第6个位置的字符
  print(s[1 :])   # 从字符串s中取第一个位置到最后的字符
  print(s(:8))    # 从字符串s中取第0个位置到第8个位置的字符，不包含第8个位置的字符
  print(s[0:8])   
  print(s[:])     # 取全部
  print(s[0:11])
  print(s[0:11:1])
  print(s[0:11:2])    # 隔一个取一个
  print(s[::-1])      # 逆序排列
  print(s[-1])        # 取最后一位

3.for循环

可迭代对象：如字符串、列表、元组、字典等可以用来遍历循环的数据

  
  for <循环变量> in <可迭代对象>:
      <循环体>

  s = "How are you doing?"
  for i in s:
      print(i)

三、字符串函数

1.字符串常用函数

函数	描述
len(x)	返回字符串x的长度，也可返回其他组合数据类型的元素个数
str(x)	返回任意类型x所对应的字符串形式
chr(x)	返回Unicode编码x对应的单个字符
ord(x)	返回单字符x表示的Unicode编码
hex(x)	返回整数x对应十六进制数的小写形式字符串
oct(x)	返回整数x对应八进制数的小写形式字符串

  # len()函数
  s = "Hello"
  print(len(s))
  # str()函数
  a = 123
  a = str(a)
  print(type(a))
  # chr()函数\ord()函数
  print(chr(97))  # 输出a
  print(ord(a))   # 输出97
  # hex()函数
  print(hex(20))
  # oct()函数
  print(oct(30))

2.字符串常用处理方法

方法	描述
str.lower()	返回字符串str的副本，全部字符小写
str.upper()	返回字符串str的副本，全部字符大写
str.split(sep=None)	返回一个列表，由str根据sep被分割的部分构成，省略sep默认以空格分隔
str.count(sub)	返回sub子串出现的次数
str.replace(old,new)	返回字符串str的副本，所有old子串被替换为new
str.center(width,fillchar)	字符串居中函数，fillchar参数可选，当width小于字符串时原样输出
str.strip(chars)	从字符串str中去掉在其左侧和右侧chars中列出的字符
str.join(iter)	将iter变量的每一个元素后增加一个str字符串

  s1 = "HOW ARE YOU DOING?"
  s2 = "how are you doing?"
  ​
  print(s1.lower())
  print(s2.upper())
  ​
  s = "asd-f-ew-we-d-23-sf"
  a = s.split("-")
  print(a)
  names = "张三-李四-王五"
  print(names.split("-"))
  ​
  q = "abc123456abc54abc"
  print(q.count("abc"))
  ​
  s3 = "HelloWorld"
  s4 = s3.replace("o","O")
  print(s4)
  print(s3)
  ​
  # str.center(width,fillchar)
  s5 = "Hello"
  print(s5.center(10,"="))
  print(s5.center(10))
  print(s5.center(2))
  ​
  s6 = "  python   "
  print(s6.strip())
  print(s6.strip(" "))
  ​
  print(",".join("python"))
  
  # capitalize()  将字符串的首字母大写
  s = "hello world"
  print(s.capitalize())
  # index(sub,begin,end) 返回sub在当前字符串中第一次出现的位置，如果没有找到报错
  # find(sub,begin,end) 返回sub在当前字符串中第一次出现的位置，如果没有找到返回-1
  s = "I was thinking of taking you somewhere special for dinner tonight!"
  print(s.index("o"))
  print(s.find("o"))
  print(s.index("o",16))
  print(s.find("o",16))

四、格式化输出

1.format()方法的基本使用

  
  <模板字符串>.format(<参数列表>)
  模板字符串是一个由字符串和槽组成的字符串，用来控制字符串和变量的显示效果
  槽用{}表示，与format（）中的参数列表对应

  print("{}说：今天天气不错！".format("小明"))
  print("{}说：今天天气{}".format("小明","不好"))
  print("{0}说：今天天气{1}".format("小明","不好"))
  # print("{}说：今天天气{}".format("小明"))  报错
  print("{0}说：今天天气{0}".format("小明"))  # 不报错两个都是小明

2.format()方法的格式控制

  
  {<参数序号>:<格式控制标记>}

：	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引号符号	用于填充的单个字符	<左对齐；>右对齐；^居中对齐	槽的设定输出宽度	数字的千位分隔符适用于整数和浮点数	浮点数小数部分的精度或字符串的最大输出长度	整数类型b,c,d,o,x,X；浮点数类型e,E,f,%

  s = "二级考试"
  print("{:25}".format(s))    # 指定宽度大于变量本身时，补充空格
  print("{:1}".format(s)) # 指定宽度小于变量本身时，原样输出
  print("{:^25}".format(s))
  print("{:>25}".format(s))
  print("{:*^25}".format(s))
  print("{:+^25}".format(s))
  ​
  s2 = "二级考试"
  y = "+"
  print("{0:{1}^25}".format(s2,y))
  print("{0:{1}^{2}}".format(s2,y,28))
  print("{0:{1}{3}{2}}".format(s2,y,25,"^"))
  ​
  print("{:-^25,}".format(2128596465132))
  print("{:.2f}".format(3.1415926))   # 对其下一位进行四舍五入
  print("{:>25.2f}".format(3.1415926))
  print("{:.5}".format("全国二级计算机"))    # 截取字符串
  """
  b:整数二进制形式
  c：输出整数对应的Unicode字符
  d：整数十进制形式
  o：整数八进制形式
  x：整数小写十六进制形式
  X：整数大写十六进制形式
  """
  print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(276))
  # 输出结果100010100,Ĕ,276,424,114,114
  """
  e:浮点数对应的小写字母e的指数形式
  E：浮点数对应的大写字母e的指数形式
  f：标准浮点数
  %：输出浮点数百分比的形式
  """
  print("{0:e},{0:E},{0:f},{0:%}".format(3.14))
  # 输出结果3.140000e+00,3.140000E+00,3.140000,314.000000%

第九章 集合数据类型

一、集合类型-set

• Python语言中的集合类型与数学中的集合概念一致

• 集合用来存储无序并且不重复的数据

• 集合中元素的类型只能是不可变数据类型，如：整数、浮点数、字符串、元组等

• 相比较而言，列表、字典、集合类型本身都是可变数据类型

  s = {123,123,3.14,"abc","abc"}
  print(s)
  print(type(s))

1.集合类型的操作符

操作符	描述
s - t	返回一个新集合，包括在集合s中但不在集合t中的元素
s & t	返回一个新集合，包括同时在集合s和t的元素
s ^ t	返回一个新集合，包括集合s和t中非共同元素
s | t	返回一个新集合，包括集合s和t中所有元素

  s = {123,43,12,45,34,21}
  t = {123,43,12,76,453,346}
  # 差集 -
  print(s - t)
  # 交集 &
  print(s & t)
  # 补集 ^
  print(s ^ t)
  # 并集 |
  print(s | t)

2.集合类型常用的操作函数与方法

函数或方法	描述
s.add(x)	如果数据项x不在集合s中，将x添加到s
s.remove(x)	如果x在集合s中，移除该元素，不在则产生KeyError异常
s.clear()	移除s中所有的元素
len(s)	返回集合s的元素个数
x in s	如果x是s的元素，返回True，否则返回False
x not in s	如果x不是s的元素，返回True，否则返回False

  s = {123,345,3.14,5.25}
  ​
  print(len(s))
  ​
  print(123 in s)
  ​
  print(123 not in s)
  ​
  s.add(124)
  print(s)
  ​
  s.remove(123)
  print(s)
  ​
  s.clear()
  print(s)
  ​
  # 创建空集合
  s = set()
  print(s)

二、序列类型

序列类型用来存储有序并且可以重复的数据，分别为以下两种类型

• 列表（list）

• 元组（tuple）

1.列表类型

列表类型使用[]来表示——ls = [123,3.14,123,"abc"]

列表索引

• 索引用来表示列表中元素的所在位置

• 基于位置，可以快速找到其对应的列表元素

• 如果一个列表中有n个元素，那么索引的取值范围是 0~n-1

• <列表或列表变量>[索引]

列表的切片

• 使用切片可以获取列表指定索引区间的元素

  
  <列表或列表变量>[开始索引:结束索引]
  <列表或列表变量>[开始索引:结束索引:步长]

  ls = [123,234,[12,1,45],[14,16]]
  print(l2[2])    # [12,1,45]
  print(l2[2][2]) # 45

常用的操作符与函数

函数或方法	描述
x in s	如果x是s的元素，返回True，否则返回False
x not in s	如果x不是s的元素，返回True，否则返回False
len(s)	返回列表s的元素个数
min(s)	返回列表s中的最小元素
max(s)	返回列表s中的最大元素

  ls = [123 , 321 , 456 , 3.14]
  print(len(ls))
  print(123 in ls)
  print(123 not in ls)
  print(min(ls))
  print(max(ls))

注：min()/max()进行使用不能把数字和字符串进行比较会报错，对都是字符串的进行比较按26个英文字母进行比较，首字母相同看下一个

常用操作方法

描述	函数或方法
ls.append(x)	在列表ls末尾处理添加一个新元素
ls.insert(i,x)	在列表ls第i位增加元素x
ls.clear()	清空列表ls中所有元素
ls.pop(i)	将列表ls中第i个元素删除
ls.remove(x)	将列表中出现的第一个元素x删除
ls.reverse()	将列表ls中的元素反转
ls.index(x)	列表ls中第一次出现元素x的位置
ls.count(x)	列表ls中出现x的总次数
ls.copy()	返回一个新列表，复制ls中所有元素

  # 创建空列表
  """
  ls = []
  ls = list()
  ls = list([])
  """
  ls = []
  ls.append(123)
  ls.append("Hello")
  print(ls)
  ​
  ls.insert(1,"world")
  print(ls)
  ​
  """
  ls.pop(2)   # 不加参数默认删除末尾的
  print(ls)
  """
  ​
  ls.remove(123)
  print(ls)
  ​
  ls1 = [123,123,3.14,65,"abc","helloWorld"]
  # ls1.reverse()
  # ls1 = ls1[::-1]
  print(ls1)
  print(ls1.index(123))
  print(ls1.count(123))
  ls1.clear()
  print(ls1)
  ​
  a = [123,234,567]
  b = a.copy()
  b[1] = 3.14
  print(a)
  print(b)

2.元组类型

元组的定义

• 元组一旦定义就不能修改

• 元组类型使用()来表示——t = (123,3.14,123,"abc")

元组的索引与切片与列表完全一致

常用的操作符与函数

函数或方法	描述
x in s	如果x是s的元素，返回True，否则返回False
x not in s	如果x不是s的元素，返回True，否则返回False
len(s)	返回元组s的元素个数
min(s)	返回元组s中的最小元素
max(s)	返回元组s中的最大元素
ls.index(x)	元组ls中第一次出现元素x的位置
ls.count(x)	元组ls中出现x的总次数

  ls = [123 , 234 , "abc"]
  for i in ls:
      print(i)
      
  t = (123 , 234 , "abc")
  for i in t:
      print(i)

三、字典类型

字典的定义

• 字典类型数据主要以“键值对”的形式存储，类似汉语字典的目录形式

• 具体格式：{<键1>:<值1>,<键2>:<值2>,······,<键n>:<值n>}

  d = {"20010101":"刘备","20010102":"关羽","20010103":"张飞","20010104":"赵云"}
  print(d)
  print(type(d))

字典索引

通过键来寻找字典中对应的值，类似查汉语字典的过程

<字典变量>[键]

  d = {"20010101":"刘备","20010102":"关羽","20010103":"张飞","20010104":"赵云"}
  print(d["20010102"])
  d["20010102"] = "马超"
  print(d)
  d["20010105"] = "张辽"
  print(d) # 给字典中加入新的键值对

函数或方法	描述
len(d)	返回字典d的元素个数
min(d)	返回字典d中键的最小值
max(d)	返回字典d中键的最大值

  d = {"20010101":"刘备","20010102":"关羽","20010103":"张飞","20010104":"赵云"}
  print(len(d))
  print(min(d))
  print(max(d))

常用操作方法

函数或方法	描述
d.keys()	返回所有的键信息
d.values()	返回所有的值信息
d.items()	返回所有的键值对
d.get(key,default)	键存在则返回相应值，否则返回默认值default
d.pop(key,default)	键存在则删除相应键值对，并返回相应值，否则返回默认值default
d.popitem()	随机从字典中取出一个键值对，以元组（key,value）形式返回，同时将该键值对从字典中删除
d.clear()	清空字典d中所有键值对

  d = {"20010101":"刘备","20010102":"关羽","20010103":"张飞","20010104":"赵云"}
  print(d.keys())
  print(type(d.keys()))
  print(d.values())
  print(d.items())
  
  d = {"20010101":"刘备","20010102":"关羽","20010103":"张飞","20010104":"赵云"}
  for i in d:
      print(i)
  for i in d.values():
      print(i)
  for i in d.items():
      print(i)
  for k,v in d.items():
      print(k,v)

第十章 文件

一、文件的基本操作

1.文件的类型

• 文本文件

  • 一般由单一特定编码的字符组成，如Unicode编码，内容容易统一展示和阅读，由于文本文件存在编码，可以看作是存储在磁盘上的长字符串，如一个txt格式的文本文件

• 二进制文件

  • 直接由0和1组成，没有统一的字符编码，文件内部数据的组织格式与文件用途有关，如png格式的图片文件、mkv格式的视频文件

区别：是否有统一的字符编码

2.文件的操作

打开文件（open()）-->读、写-->关闭文件（close()）

打开文件

<变量名> = open(<文件路径及文件名>,<打开模式>)

打开模式	描述
'r'	只读模式，如果文件不存在，返回异常FileNotFoundError，默认值
'w'	覆盖写模式，文件不存在则创建，存在则完全覆盖原文件
'x'	创建写模式，文件不存在则创建，存在则返回异常FileExistsError
'a'	追加写模式，文件不存在则创建，存在则在源文件最后追加内容
'b'	二进制文件模式
't'	文本文件模式，默认值
'+'	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

文件的操作-常用组合

• 以文本方式只读打开一个文件，读入后不能对文件进行修改：r

• 以文本方式可读可写的打开一个文件，可以读入并修改文件：r+

• 以文本方式打开一个空文件，准备写入一批内容，并保存为新文件：w

• 以文本方式打开一个空文件或已有文件，追加形式写入一批内容，更新原文件：a+

• 以二进制方式只读打开一个文件，读入后不能对文件进行修改：rb

读文件

方法	描述
f.read(size)	从文件中读入整个文件内容，参数可选，如果给出，读入前size长度的字符串或字节流
f.readline(size)	从文件中读入一行内容，参数可选，如果给出，读入该行前size长度的字符串或字节流
f.readlines(hint)	从文件中读入所有行，以每行元素形成一个列表，参数可选，如果给出，读入hint行
f.seek(offset)	改变当前文件操作指针的位置，offset的值，0为文件开头，1为从当前位置开始，2为文件结尾

  f = open("test.txt" , encoding = "UTF-8")
  s = f.read()
  f.close()
  print(s)

相对路径和绝对路径

绝对路径：从盘符开始写

转义字符

  
  \n  换行 
  \t  tab
  \\  \

二、数据读取与存储

1.一维数据

• 一维数据在Python中的表示方式

• 一维数据在文件中的存储方式

• 一维数据的处理