Python全栈开发教程笔记_python全栈学习笔记

本文档基于B站Python教程

一、print()函数

1. 可以输出数字

print(520)
print(98.5)
1
2

2. 可以输出字符串

print('hello world')
print("hello world")
1
2

3. 可以输出含有运算符的表达式

print(3+1)
1

4. 可以输出到文件

fp = open('D:/text.txt','a+')
print('hello world',file=fp)
fp.close
1
2
3

**注意：**1.所指定的盘符必须存在；2.使用 file=fp；3.a+表示文件不存在就创建，存在的话就在内容上继续追加。

不进行换行输出：

print('hello','world','Python')
1

二、转义字符

1. 转义字符

print('hello \n world') #\ +转义功能的首字母 n--newline的首字母表示换行
print('hello \t world')  #\t 水平制表符，一组4个空格的位置
print('helloooo \t world') 
print('hello \r world') #\r 回车把hello覆盖
print('hello \b world') #\b 退一个格将o退没了
print('http:\\\\www.baidu.com') #\\输出一个\，\\\\输出2个\
print('  老师说：\’大家好\‘  ')
1
2
3
4
5
6
7

2. 原字符

不希望字符串中的转义字符起作用，字符串前加上r或者R

print(r'hello \n world')
1

**注意事项：**最后一个字符不能是反斜杠\，但是是两个\\可以。

三、七十二变

1. 二进制与字符编码

计算机只认识0和1。ASCII表来表示符号和数字。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p6AbmkF7-1625580399562)(https://static01.imgkr.com/temp/d141123ef9d94013a8e0c3f6a025a7c9.png)]

‘A’ 使用了8个位（bit）才能表示出来，在计算机他们叫一个字节（byte）。
$$01000001$$

1024 byte = 1 kB ； 1024 kB = 1 MB ；

1024 MB = 1 GB ； 1024 GB = 1 TB.

二进制0，1 → ASCII → GB2312 → GB18030 → Unicode → UTF-8

# 汉字“乘”与进制数的转换
print(chr(0b100111001011000)) #0b代表二进制
print(ord('乘'))   #得到'乘'所代表的十进制数
1
2
3

2. 标识符和保留字

有一些单词被赋予了特定的意义，这些单词在用户给任何对象起名字的时候不允许使用。

import keyword
print(keyword.kwlist)   #查看所有的保留字
1
2

标识符是指变量、函数、类、模块和其他对象的名字。

其规则是：

• 字母、数字、下划线
• 不能以数字开头
• 不能是Python的保留字
• 严格区分大小写

3. 变量的定义和使用

变量是内存中一个带标签的盒子。下例中，name表示变量名，=是复制运算符，玛丽亚是值。

name = '玛丽亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
1
2
3
4
5

变量由三部分组成：

• **标识：**表示对象所存储的内存地址，使用内置函数id(obj)来获取；
• **类型：**表示对象的数据类型，使用内置函数type(obj)来获取；
• **值：**表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出；

当多次复制后，变量名会指向新的空间，旧的空间称为内存垃圾。

name = '玛丽亚'
print(name)
name = '楚留冰'
print(name)
1
2
3
4

4. 常用的数据类型

常用的数据类型：

• 整数类型（int）：98
• 浮点数类型（float）：3.14159
• 布尔类型（bool）：True False
• 字符串类型（str）：‘人生苦短，我用Python’

（1）整数类型integer

整数的不同进制表示方法：

• 十进制：默认的进制；
• 二进制：以0b开头；
• 八进制：以0o开头；
• 十六进制：以0x开头。

n1 = 90
n2 = -76
n3 = 0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))

#整数可以表示为二进制，十进制，八进制，十六进制
print('十进制',118) 
print('二进制',0b10101111) #二进制以0b开头，0，1
print('八进制',0o176) #八进制以0o开头，0-7
print('十六进制',0x1EAF) #十六进制以0x开头，0-9，A-F
1
2
3
4
5
6
7
8
9
10
11
12

（2）浮点数类型float

a = 3.14159
print(a,type(a))

n1 = 1.1
n2 = 2.2
n3 = 2.1
print(n1+n2)   #结果出现很多0，计算不准确，二进制的底层问题，会有误差
print(n1+n3)

from decimal import Decimal  #导入模块decimal解决不准确的问题
print(Decimal('1.1')+Decimal('2.2'))
1
2
3
4
5
6
7
8
9
10
11

（3）布尔类型boolean

• 用来表示真或假的值；
• True表示真，False表示假；
• 布尔值可以转化为整数，True->1，False->0。

f1 = True
f2 = False
print(f1,type(f1))
print(f2,type(f2))
#布尔值转化为整数计算
print(f1+1)  #2   1+1的结果为2，True表示1
print(f2+1)  #1   0+1的结果为1，False表示0
1
2
3
4
5
6
7

（4）字符串类型

• 字符串类型又被称为不可变的字符序列；
• 可以使用单引号，双引号，三引号来定义；
• 单引号和双引号定义的字符串必须在一行；
• 三引号定义的字符串可以分布在连续的多行。

str1 = '人生苦短，我用Python'
print(str1,type(str1))
str2 = "人生苦短，我用Python"
print(str2,type(str2))
str3 = '''人生苦短，
  我用Python'''
print(str3,type(str3))
str4 = """人生苦短，
  我用Python"""
1
2
3
4
5
6
7
8
9

（5）数据类型的转换

为什么需要数据类型的转换？将不同类型的数据拼接到一起。

name = '张三'
age = 20
print(type(name),type(age)) #说明name和age的数据类型不同
print('我叫' +name+ '今年' +str(age)+ '岁' ) #将int类型通过str()转换为str类型

print('---str()将其他类型转换成str类型---')
a = 10
b = 198.8
c = False
print(typr(a),type(b),type(c))
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))

print('---int()将其他类型转换成int类型---')
s1 = '128'
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1)))  #str转换成int类型，字符串为数字串
print(int(f1),type(int(f1)))  #float转换成int类型，只截取整数部分，舍去小数部分
#print(int(s2),type(int(s2)))  #str转换成int类型报错，因为字符串为小数串
print(int(ff),type(int(ff)))  #bool转换成int类型
#print(int(s3),type(int(s3)))  #str转换成int类型报错，字符串必须是数字串且是整数，非数字串不允许转换

print('---float()函数，将其他数据类型转换成float类型---')
s4 = '128.96'
s5 = '76'
ff1 = True
s6 = 'hello'
i = 98
print(type(s4),type(s5),type(s6),type(ff1),type(i))
print(float(s4),type(float(s4)))
print(float(s5),type(float(s5)))
print(float(ff1),type(float(ff1)))
#print(float(s6),type(float(s6)))  #字符串中数据为非数字串，不允许转换
print(float(i),type(float(i)))
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

5. Python中的注释

注释是在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性，注释的内容会被Python解释器忽略。通常包含三种类型的注释：

• 单行注释：以’#'开头，直至换行结束；
• 多行注释：并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释；
• 中文编码声明注释：在文件开头加上中文声明注释，用以指定源码文件的编码格式。（Python3基本用不到）

#输入功能（单行注释）
print('hello')

'''嘿嘿，
我是多行注释'''
1
2
3
4
5

四、算你赢

1. Python的输入函数input()

input()函数的基本使用：present=input(‘大圣想要什么礼物呢？’)

其中present是变量，=是赋值运算符，将输入函数的结果赋值给变量present，input函数是一个输入函数，需要输入回答。

#输入函数input
present = input('大圣想要什么礼物呢？')
print(present,type(present))

#要求从键盘录入两个整数，计算两个整数的和
a = input('请输入一个加数：')
a = int(a)
b = input('请输入另一个加数：')
b = int(b)
print(type(a),type(b))
print(a+b)   #对str类型的两个量进行连接,对int类型的两个量进行计算
1
2
3
4
5
6
7
8
9
10
11

2. Python中的运算符

算术运算符（标准算术运算符，取余运算符，幂运算符）

print(1+1)     #加法运算
print(1-1)     #减法运算
print(2*4)     #乘法运算
print(11/2)    #除法运算
print(11//2)   #整除运算
print(11%2)    #取余运算
print(2**3)    #幂运算，2的3次方
#一正一负整除运算  向下取整
print(9//4)     #2
print(-9//-4)   #2
print(9//-4)    #-3
print(-9//4)    #-3
#一正一负取余运算  公式:余数=被除数-除数*商
print(9%-4)     #9-(-4)*(-3)=-3
print(-9%4)     #-9-4*(-3)=3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

赋值运算符=

• 执行顺序：从右到左
• 支持链式赋值，a = b = c = 20
• 支持参数赋值， += -= *= /= //= %=
• 支持系列解包赋值，a,b,c = 20,30,40

#赋值运算符
i = 3+4
print(i)  #运算顺序从右到左
a = b = c = 20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('---支持参数赋值---')
a = 20
a += 30  #相当于a=a+30
print(a)
a -= 10
print(a)
a *= 2
print(a)   #int类型
print(type(a))
a /= 3
print(a)
print(type(a))  #float
a //= 2
print(a)
print(type(a))
a %= 3
print(a)
print('---解包赋值---')
a,b,c = 20,30,40
print(a,b,c)
print('---交换两个变量的值---'')
a,b = 10,20
print('交换之前：',a,b)
a,b = b,a #交换
print('交换之后：',a,b)
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

3. 比较运算符

比较运算符对变量或表达式的结果进行大小、真假等比较。

a,b = 10,20
print('a>b吗？',a>b)   #False
print('a<b吗？',a<b)   #True
print('a<=b吗？',a<=b)  #True
print('a>=b吗？',a>=b)  #False
print('a==b吗？',a==b)
print('a!=b吗？',a!=b)
'''一个 = 称为赋值运算符， == 称为比较运算符
  一个变量由三部分组成，标识(id)，类型(type)，值(value)
  == 比较的是值还是标识呢？  答案是比较的是值
  比较对象的标识使用 is
'''
a = 10
b = 10
print(a==b)   #True  说明a与b的value相等
print(a is b) #True  说明a与b的id标识相等

lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1 == lst2)  #value   --True
print(lst1 is lst2)  #id      --False
print(id(lst1))
print(id(lst2))

print(a is not b)        #False
print(lst1 is not lst2)  #True
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

4. 布尔运算符

布尔运算符对于布尔值之间的运算。and,or,not,in,not in

#布尔运算符
a,b = 1,2
print('----and----')
print(a==1 and b==2)  #True and True  -->True
print(a==1 and b<2)   #True and False  -->False
print(a!=1 and b==2)  #False and True  -->False
print(a!=1 and b!=2)  #False and False -->False
print('----or----')
print(a==1 or b==2)
print(a==1 or b<2)
print(a!=1 or b==2)
print(a!=1 or b!=2)
print('----not-----')
f = True
f2 = False
print(not f)
print(not f2)
print('----in与not in------')
s = 'helloworld'
print('w' in s)
print('k' in s)
print('w' not in s)
print('k' not in s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5. 位运算符

位运算符将数据转换成二进制进行计算。

• 位与&：对应数位都是1，结果数位才是1，否则为0
• 位或|：对应数位都是0，结果数位才是0，否则为1
  
• 左移位<<：高位溢出舍弃，低位补0
• 右移位>>：低位溢出舍弃，高位补0
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TJDA9fQx-1625580399565)(Typora_image/5559907f0eb84e15931f9dacbfa0c9a0.png)]

print(4 & 8)  #按位与
print(4 | 8)  #按位或
print(4 << 1) #向左移动1位置
print(4 << 2)
print(4 >> 1)
print(4 >> 2)
1
2
3
4
5
6

6. Python中的运算符优先级

** *,/,//,% +,- <<,>> & | >,<,>=,<=,==,!= and or =

算术 → 位 → 比较（True False）→ 布尔 → 赋值=

五、往哪走

1. 程序的组织结构

任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。

2. 顺序结构

程序从上到下顺序地执行代码，中间没有任何地判断和跳转，直到程序结束。

程序开始 → 代码1 → 代码2 → … → 代码N → 程序结果

'''把大象装冰箱一共分几步'''
print('-------程序开始--------')
print('1.把冰箱门打开')
print('2.把大象放到冰箱里')
print('3.把冰箱门关上')
print('------程序结束---------')
1
2
3
4
5
6

3. 对象的布尔值

Python一切皆对象，所有对象都有一个布尔值，获取对象地布尔值使用内置函数bool()

以下对象地布尔值为False

• False
• 数值0
• None
• 空字符串
• 空列表
• 空元组
• 空字典
• 空集合

#测试对象地布尔值
print('----------布尔值均为False---------')
print(bool(False))
print(bool(0))
print(bool(0,0))
print(bool(None))
print(bool(''))
print(bool(""))  
print(bool([]))      #空列表
print(bool(list()))  #空列表
print(bool(()))      #空元组
print(bool(tuple())) #空元组
print(bool({}))      #空字典
print(bool(dict()))  #空字典
print(bool(set()))   #空集合
print('------------布尔值为True-------------')
print(bool(18))
print(bool(True))
print(bool('helloworld'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. 选择结构

程序根据判断条件地布尔值选择性地执行部分代码，明确地让计算机知道在什么条件下该去做什么。

（1）单分支if结构

money = 1000    #余额
s = int(input('请输入取款金额：'))  #取款金额
#判断余额是否充足
if money >= s:
  money = money - s
  print('取款成功，余额为：',money)
1
2
3
4
5
6

（2）双分支if…else结构

'''从键盘录入一个整数，编写程序使计算机判断奇偶 '''
num = int(input('请输入一个整数：'))
if num % 2 == 0:
  print(num,'是偶数')
else:
  print(num,'是奇数')
1
2
3
4
5
6

（3）多分支if…elif…else结构

'''多分支结构，多选一执行
  从键盘录入一个整数成绩
    90-100  A
    80-89   B
    70-79  C
    60-69  D
    0-59  E
    小于0或大于100 为非法数据（不是成绩的有效范围）
'''
score = int(input('请输入一个成绩：'))
#判断
if score >= 90 and score <= 100:    #Python语句独有特点也可写作 if 90 <= score <= 100: 
  print('A级')
elif score >= 80 and score <= 89:
  print('B级')
elif score >= 70 and score <= 79:
  print('C级')
elif score >= 60 and score <= 69:
  print('D级')
elif score >= 50 and score <= 59:
  print('E级')
else:
  print('对不起，成绩有误，不在成绩的有效范围')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（4）if语句的嵌套

'''会员    >= 200   8折
          >= 100    9折
          不打折
  非会员   >=200     9.5折
          不打折'''
answer = input('您是会员吗？y/n \n')
money = float(input('请输入您的购物金额：'))
#外层判断是否是会员
if answer == 'y':   #会员
  if money >= 200:
    print('打8折，付款金额为：',money*0.8,'元')
  elif money >= 100:
    print('打9折，付款金额为：',money*0.9,'元')
  else:
    print('不打折，付款金额为：',money,'元')
else:              #非会员
  if money >= 200:
    print('打9.5折，付款金额为：',money*0.95,'元')
  else:
    print('不打折，付款金额为：',money,'元')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（5）条件表达式

条件表达式是if…else的简写，语法结构为：x if 判断条件 else y

运算规则：如果判断条件的布尔值为True，条件表达式的返回值为x，否则条件表达式的返回值为False。

'''从键盘录入两个整数，比较两个整数的大小'''
num_a = int(input('请输入第一个整数：'))
num_b = int(input('请输入第二个整数：'))
#比较大小
if num_a >= num_b:
  print(num_a,'大于等于',num_b)
else:
  print(num_a,'小于',num_b)
print('---------使用条件表达式进行比较-------------')
print(( str(num_a) + '大于等于' + str(num_b))  if num_a>=num_b else str(num_a)+'小于'+str(num_b))
1
2
3
4
5
6
7
8
9
10

5. pass空语句

语句什么都不做，只是一个占位符，用在语法上需要语句的地方。

#pass语句
answer = input(‘您是会员吗？y/n’)
if answer == 'y':
  pass
else:
  pass
1
2
3
4
5
6

六、转圈圈

1. range()函数的使用

range()函数用于生成一个整数序列，其返回值是一个迭代器对象。

创建range对象的三种方式：

• range(stop):创建一个[0,stop]之间的整数序列，步长为1
• range(start,stop):创建一个[start,stop]之间的整数序列，步长为1
• range(start,stop,step):创建一个[start,stop]之间的整数序列，步长为step
  range类型的优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start,stop和step，只有当用到range对象时，才会去计算序列中的相关元素。用in和not in来判断整数序列中是否存在指定的整数。

#range的三种创建方式
''' 第一种创建方式，只有一个参数'''
r = range(10)     #[0 1 2 3 4 5 6 7 8 9]  默认从0开始，步长为1 
print(r)    
print(list(r))    #用于查看range对象中的整数序列  --list是列表函数
''' 第二种创建方式，括号里给了两个参数'''
r = range(1,10)   #指定了起始值和终止值，区间左闭右开[1,10)
print(list(r))
''' 第三种创建方式，括号里给出三个参数'''
r = range(1,10,2)
print(list(r))
''' 判断指定的整数在序列中是否存在in，not in'''
print(10 in r)
print(9 in r)
print(10 not in r)
print(9 not in r)

print(range(1,20,1))
print(range(1,101,1))   #未使用时，上下两个所占内存一样
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 循环结构

循环时反复作同一件事情的情况，用于次数不固定的循环，初始条件不成立，一次都不执行。

（1）while循环

a = 1
#判断条件表达式
if a < 10:     #if改为while重新运行，结果是1 2 3 4 5 6 7 8 9
  print(a)
  a += 1
#if与while的区别是：if判断一次，条件True执行一行；while是判断N+1次，条件是True执行N次
1
2
3
4
5
6

四步循环法：

• 初始化变量
• 条件判断
• 条件执行体（循环体）
• 改变变量
  初始化的变量和条件判断的变量与改变的变量为同一个

#计算0到4的累加和
sum = 0            #用于存储累加和
'''初始化变量为0'''
a = 0
'''条件判断'''
while a < 5:
  '''条件执行体（循环体）'''
  sum += a
  '''改变变量'''
  a += 1
print('和为',sum)
1
2
3
4
5
6
7
8
9
10
11

'''计算1到100之间的偶数和'''
sum = 0   #用于存储偶数和
a = 1             #初始化变量
while a <= 100    #条件判断
  #条件执行体（求和）
  if a%2 == 0:    # if not bool(a%2):   意味着0的布尔值为False 
    sum += a
  a += 1
print('1到100的偶数和',sum)
1
2
3
4
5
6
7
8
9

（2）for-in循环

语法结构为：for 自定义的变量 in 可迭代对象
循环体

• in表示从（字符串、序列等）中依次取值，又称为遍历
• for-in遍历的对象必须是可迭代对象
• 循环体内不需要访问自定义变量，可以将自定义变量替代为下划线

for item in 'Python'  #第一次取出来的是P，赋值给item，输出
  print(item)
  
#range()产生一个整数序列，也是一个可迭代对象
for i in range(10)
  print(i)
  
#如果在循环体中不需要使用自定义变量，可将自定义变量写为_
for _ in range(5)
  print('人生苦短，我用Python')
  
'''使用for循环计算1到100之间的偶数和'''
sum = 0
for item in range(1,101):
  if item % 2 == 0:
    sum += item
print('1到100之间的偶数和为：',sum)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

'''输出100到999之间的水仙花数
  举例 153 =3*3*3+5*5*5
  1*1*1'''
for item in range(100,1000):
  ge = item %10
  shi = item // 10 % 10
  bai = item // 100
  print(bai,shi,ge)
  if ge**3+shi**3+bai**3 == item:
    print(item)
1
2
3
4
5
6
7
8
9
10

（3）break、continue与else语句

break语句用于结束循环结构，通常与分支结构if一起使用

'''从键盘录入密码，最多录入三次，如果正确就结束循环'''
for item in range(3):
  pwd = input('请输入四位数密码：')
  if pwd == '8888'；
    print('密码正确')
    break
  else:
    print('密码不正确')  
1
2
3
4
5
6
7
8

a = 0
while a < 3:
  pwd = input('请输入四位数密码：')   #条件执行体
  if pwd == '8888':
    print('密码正确')
    break
  else:
    print('密码不正确')
  a += 1                           #改变变量
1
2
3
4
5
6
7
8
9

continue语句用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用

'''要求输出1到50之间所有5的倍数：和5的余数为0的数
  什么样的数不是5的倍数？与5的余数不是0的数'''
for item in range(1,51):
  if item % 5 == 0:
    print(item)
print('----------使用continue----------')
for item in range(1,51):
  if item % 5 != 0:
    continue
  print(item)
1
2
3
4
5
6
7
8
9
10

else语句与其他语句配合使用。
与if配合使用，if条件表达式不成立时执行else；与for和while配合使用时，没有碰到break时执行else。

for item in range(3):
  pwd = input('请输入密码：')
  if pwd == '8888':
    print('密码正确')
    break
  else:
    print('密码不正确')
else:
  print('对不起，三次密码均输入错误。')
1
2
3
4
5
6
7
8
9

a = 0 
while a < 3；
  if pwd == '8888':
    print('密码正确')
    break
  else:
    print('密码不正确')
  '''改变变量'''
  a += 1
else:
  print('对不起，三次密码均输入错误')
1
2
3
4
5
6
7
8
9
10
11

3. 嵌套循环

嵌套循环时循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行。

'''输出一个三行四列的矩形'''
for i in range(1,4):       #行表，执行三次，一次是一行
  for j in range(1,5)；  
    print('*',end = '\t')  #不执行输出
  print()                  #打行
1
2
3
4
5

'''九九乘法表'''
for i in range(10):
  for j in range(1,i+1):
    print(i,'*',j,'=',i*j,end = '\t')
  print()
1
2
3
4
5

二重循环中的break和continue用于控制本层循环。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dr4rq51B-1625580399567)(…/PythonProjects/Typora_image/30103d82496e45068a9c2b6347526c65.png)]

'''流程控制语句break与continue在二重循环中的使用'''
for i in range(5):     #外层循环执行5次
  for j in range(1，11):
    if j%2 == 0:
      break
      #continue
    print(j)
    #print(j,end = '\t')
  #print()
1
2
3
4
5
6
7
8
9

七、一字排开

为什么需要列表？

• 变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体操作
• 列表相当于其它语言中地数组
• 列表示意图
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J5uTyIK1-1625580399570)(Typora_image/7fb49d3b2d7a4405b2870675f2daa035.png)]

a = 10           #变量存储地是一个对象的引用
lst = ['hello','world',98]
print(id(lst))
print(type(lst))
print(lst)
1
2
3
4
5

1. 列表的创建与删除

创建方式：1.使用中括号；2.调用内置函数list()

lst = ['hello','world',98]         #使用中括号创建列表
print(lst)
lst2 = list(['hello','world',97])  #使用内置函数list()创建列表
1
2
3

列表的特点：

• 列表元素按顺序有序排序
• 索引映射唯一数据
• 列表可以存储重复数据
• 任意数据类型混存
• 根据需要动态分配和回收内存

2. 列表的查询操作

• 获取列表中指定元素的索引

lst = ['hello','world',98,'hello']
print(lst,index('hello'))    #列表存在多个相同元素，只返回列表第一个索引
#print(lst,index('Python'))   #查询元素不存在ValueError:'Python' is not in list
#print(lst,index('hello',1,3)) ValueError
print(lst,index('hello',1,4))  #指定在start到stop之间进行查找
1
2
3
4
5

• 获取列表中的单个元素

lst = ['hello','world',98,'hello','world',234]
print(lst[2])   #获取索引为2的元素
print(lst[-3])  #获取索引为-3的元素
#print(lst[10]) #IndexError:list index out of range超出索引范围，真想从0到N-1，逆向从-N到-1
1
2
3
4

• 获取列表中的多个元素：列表名[start:stop:step]

lst = [10,20,30,40,50,60,70,80]
print(lst[1:6:1])    #start=1 stop=6 step=1切片切出一个新列表
print('原列表'，id(lst))
lst2 = lst[1:6:1]
print('切的片段:',id(lst2))
print(lst[1:6])
print(lst[1:6:])    #step不写默认从1开始
print(lst[1:6:2])
print(lst[:6:2])    #start不写默认从0开始
print(lst[1::2])    #stop不写默认最后一个元素
print('--------------step为负数的情况-------------')
print('原列表：',lst)
print(lst[::-1])
print(lst[7::-1])
print(lst[6:0:-2])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 判断指定元素在列表中是否存在

print('p' in 'python') 
print('k' not in 'python')
lst = [10,20,'python','hello']
print(10 in lst)
print(100 in lst)
print(10 not in lst)
print(100 not in lst)
1
2
3
4
5
6
7

• 列表元素的遍历
  可迭代对象：字符串和列表

lst = [10,20,'python','hello']
for item in lst:
  print(item)
1
2
3

3. 列表元素的增、删、改操作

（1）列表元素的增加操作

• append()：在列表的末尾添加一个元素
• extend()：在列表的末尾至少添加一个元素
• insert()：在列表的任意位置添加一个元素
• 切片：在列表的任意位置添加至少一个元素

#向列表的末尾添加一个元素
lst = [10,20,30]
print('添加元素之前'，lst)
lst.append(100)
print('添加元素之后',lst,id(lst))
lst2 = ['hello','world']
lst.append(lst2)        #将lst2作为一个元素添加到列表的末尾
print(lst)
lst.extend(lst2)        #向列表的末尾一次性添加多个元素  
print(lst)
lst.insert(1,90)        #在任意位置添加一个元素
print(lst)
lst3 = [True,False,'hello']
lst[1:] = lst3          #切片替换
print(lst)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（2）列表的删除操作

• remove()：一次删除一个元素；重复元素只删除第一个；元素不存在抛出ValueError
• pop()：删除一个指定索引位置上的元素；指定索引不存在抛出IndexError；不指定索引，删除列表最后一个元素
• 切片：一次至少删除一个元素
• clear()：清空列表
• del()：删除列表

lst = [10,20,30,40,50,60,30]
lst.remove(30)          #重复元素只删除第一个
print(lst)
#lst.remove(100)         #移除元素不存在ValueError
#pop根据索引移除元素
lst.pop(1)
print(lst)
#lst.pop(8)              #IndexError
lst.pop()                #默认删除最后一个元素
print(lst)
print('-------切片操作删除至少一个元素，将产生一个新的列表对象-----------')
new_lst = lst[1:3]
print('原列表',lst)
print('新列表',new_lst)
'''不产生新的列表对象，而是删除原列表的内容'''
lst[1:3] = []
print(lst)
'''清除列表中的所有元素'''
lst.clear()
print(lst)
'''del语句将列表对象删除'''
del lst
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

（3）列表元素的修改操作

• 为指定索引的元素赋予一个新值
• 为指定的切片赋予一个新值

lst = [10,20,30,40]
#一次修改一个值
lst[2] = 100      
print(lst)
lst[1:3] = [300,400,500,600]
print(lst)
1
2
3
4
5
6

4. 列表元素的排序

• 调用sort()方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True进行降序排序
• 调用内置函数sorted()，可以指定reverse=True进行降序排序，原列表不发生改变

lst = [20,40,10,98,54]
print('排序前的列表',lst,id(lst))
#调用列表对象的sort方法，默认升序
lst.sort()
print('排序后的列表',lst,id(lst))
#指定参数进行降序
lst.sort(reverse = True)
print(lst)
lst.sort(reverse = False)
print(lst)
print('-------调用内置函数sorted()对列表对象进行排序，产生一个新的列表对象----')
lst = [20,40,10,98,54]
print('原列表',lst)
new_lst = sorted(lst)
print(lst)
print(new_lst)
desc_lst = sorted(lst,reverse =True
print(desc_lst)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5. 列表推导式

列表生成式简称生成列表的公式。
语法格式：
[i*i for i in range(1,10)]

lst = [i for i in range(1,10)]
lst1 = [i*i for i in range(1,10)]
print(lst)
print(lst1)
'''列表中的元素的值为2 4 6 8 10 '''
lst2 = [i*2 for i in range(1,6)]
print(lst2)
1
2
3
4
5
6
7

八、夫妻站

什么是字典？Python内置的数据结构之一，与列表一样是一个可变序列；以键值对的方式存储数据，字典是一个无序的序列。

scores = {‘张三’:100,‘李四’:98,‘王五’:45}

字典的实现原理：字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，Python中的字典是根据key查找Value所在的位置。

1. 创建字典

• 使用花括号：scores={‘张三’:100,‘李四’:98,‘王五’:45}
• 使用dict内置函数：dict(name=‘jack’,age =20)

'''使用{}创建字典'''
scores = {'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))
'''使用内置函数dict'''
student = dict(name='jack',age=20)
print(student)
'''空字典'''
d = {}
print(d)
1
2
3
4
5
6
7
8
9
10

2. 字典中元素的获取

[]取值与使用get()取值的区别：

• []如果字典中不存在指定的key，抛出keyError异常
• get()方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的Value，以便指定的key不存在时返回

'''获取字典中的值'''
scores = {'张三':100,'李四':98,'王五':45}
''' 第一种方式，使用[]'''
print(scores['张三'])
print(scores['陈六'])         #KeyError
'''第二种方式 使用get'''
print(scores,get('张三'))
print(scores,get('陈六'))     #None
print(scores,get('麻七',99))  #99是在查找麻七对应的value不存在时，提供的一个返回值
1
2
3
4
5
6
7
8
9

3. 字典的常用操作

• key的判断：in和not in
• 字典元素的删除del
• 字典元素的新增

'''key的判断'''
scores = {'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三']    # 删除指定的key-value对
#scores.clear()      #清空字典元素
print(scores)
scores['陈六'] = 98   #新增元素
print(scores)
scores['陈六'] = 100  #修改元素
print(scores)
1
2
3
4
5
6
7
8
9
10
11
12

获取字典视图的三个方法：keys、values、items

scores = {'张三':100,'李四':98,'王五':45}
#获取所有的key
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))  #将所有的key组成的视图转成列表
#获取所有的Value
values = scores.values()
print(values)
print(type(values))
print(list(values))
#获取所有的key-value对
items = scores.items()
print(items)
print(list(items))   #转换之后的列表元素为元组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#字典元素的遍历
scores = {'张三':100,'李四':98,'王五':45}
for item in scores:
  print(item,scores[item],scores.get(item))
1
2
3
4

4. 字典的特点

• 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
• 字典中的元素是无序的
• 字典中的key必须是不可变对象
• 字典也可以根据需要动态地伸缩
• 字典会浪费较大地内存，是一个使用空间换时间地数据结构

d = {'name':'张三','name':'李四'}
print(d)

d = {'name':'张三','nikename':'张三'}
print(d)
1
2
3
4
5

5. 字典生成式

内置函数zip():用于将可迭代对象作为参数，将对象中对应地元素打包成一个元组，然后返回由这些元组组成的列表

items = ['Fruits','Books','Others']
prices = [96,78,85,100,120]
d = {item.upper():prices  for item,prices in zip(items,prices)}
print(d)
1
2
3
4

九、是排还是散

1. 元组

元组是Python内置的数据结构之一，属于不可变序列。t=(‘Python’,‘hello’,90)

不可变序列与可变序列:

• 不可变序列（没有增删改操作）：字符串、元组
• 可变序列（可进行增删改操作，对象地址不发生更改）：列表、字典

'''可变序列   列表、字典'''
lst = [10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))
'''不可变序列   字符串、元组'''
s = 'hello'
print(id(s))
s = s+'world'
print(id(s))
print(s)
1
2
3
4
5
6
7
8
9
10
11

（1）元组的创建方式

• 使用小括号 t=(‘Python’,‘hello’,90)
• 使用内置函数tuple() t=tuple((‘Python’,‘hello’,90))
• 只包含一个元组的元素需要使用逗号和小括号 t=(10,)

'''元组的创建方式'''
#第一种使用小括号
t = ('Python','hello',98)
print(type(t))

t0 = 'Python','hello',98
print(t0)
print(type(t0))

t3 = ('Python',)     #如果元组中只有一个元素，逗号不能省略
print(t3)
print(type(t3))


#第二种使用内置函数tuple
t1 = tuple(('Python','hello',98))
print(t1)
print(type(t1))

'''空元组的创建方式'''
lst =[]
lst1= list()

d={}
d2=dict()

t4=()
t5=tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)
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

（2）为什么将元组设计成不可变序列

• 在多任务环境下，同时操作对象时不需要加锁
• 因此，在程序中尽量使用不可变序列
• 注意：元组中存储的是对象的引用
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vsRGl48y-1625580399572)(…/PythonProjects/Typora_image/610d82ae09cd4fbdad7c15b055a853cf.png)]

t = (10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
print(id(100))
#t[1]=100    #元组是不允许修改元素的
'''由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变'''
t[1].append(100)   #向列表中添加元素
print(t,id(t[1])
1
2
3
4
5
6
7
8
9
10
11
12

（3）元组的遍历

'''元组的遍历'''
t = ('Python'，'world',98)
'''第一种获取元组元素的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3])   #IndexError
'''遍历元组'''
for item in t:
  print(item)
1
2
3
4
5
6
7
8
9
10

2. 集合

集合是Python语言提供的内置数据结构；与列表、字典一样都属于可变类型的序列；是没有Value的字典，只有key。

（1）集合的创建方式

'''第一种创建方式使用{}'''
s = {2,3,4,5,5,6,7,7}	#集合中的元素不允许重复
print(s)
'''第二种创建方式使用set{}'''
s1 = set(range(6))
print(s1,type(s1))

s2 = set([1,2,4,5,5,5,6,6])
print(s2,type(s2))

s3 = set((1,2,4,4,5,65))   #集合中的元素是无序的
print(s3,type(s3))

s4 = set('Python')
print(s4,type(s4))

s5 = set({12,4,34,55,66,44,4})
print(s5,type(s5))

#定义一个空集合
s6 = {}
print(type(s6))

s7 = set()
print(type(s7))
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

（2）集合的相关操作

s = {10,20,30,405,60}

#集合元素的判断操作
print(10 in s)
print(100 in s)
print(10 not in s)
print(100 not in s)

#集合元素的新增操作
s.add(80)        #一次添加一个元素
print(s)
s.update({200,400,300})   #一次至少添加一个元素
print(s)
s.update([100,99,8])
print(s)
s.update((78,64,56))
print(s)

#集合元素的删除操作
s.remove(100)	 #一次删除一个指定元素，元素不存在抛出KeyError
print(s)
#s.remove(500)   #KeyError
s.discard(500)   #删除一个指定元素，元素不存在不报异常
s.discard(300)
print(s)
s.pop()          #一次只能删除一个任意元素
s.pop()
#s.pop(400)      #TypeError 不能够添加参数
print(s)
s.clear()        #清空集合
print(s)
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

（3）集合间的关系

'''集合是否相等？元素相同即相等，与顺序无关'''
s = {10,20,30,40}
s2 = {30,40,20,10}
print(s == s2)    #True
print(s != s2)    #False

'''一个集合是否是另一个集合的子集'''
s1 = {10,20,30,40,50,60}
s2 = {10,20,30,40}
s3 = {10,20,90}
print(s2.issubset(s1))
print(s3.issubset(s1))

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))
print(s1.issuperset(s3))

'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))   #False   有交集为False
s4 = {100,200,300}
print(s2.isdisjoint(s4))   #True   无交集为True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

（4）集合的数学操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xZBtcPBX-1625580399573)(…/PythonProjects/Typora_image/e48eb7510aa743a2bb1064f51352a19d.png)]

'''集合的数学操作'''
#交集
s1 = {10,20,30,40}
s2 = {20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)
print(s1)
print(s2)

#并集
print(s1.union(s2))
print(s1 | s2)
print(s1)
print(s2)

#差集
print(s1.difference(s2))
print(s1 - s2)
print(s1)
print(s2)

#对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

（4）集合生成式

'''列表生成式'''
lst = [i*i for i in range(10)]
print(lst)

'''集合生成式'''
s = {i*i for i in range(10)}
print(s)
1
2
3
4
5
6
7

3. 列表、字典、元组、集合总结

十、一串连一串

1. 字符串的驻留机制

**字符串：**在Python中是基本数据类型，是一个不可变的字符序列。

**字符串的驻留机制：**仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同的字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

'''字符串的驻留机制'''
a = 'Python'
b = "Python"
c = '''Python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))
1
2
3
4
5
6
7

驻留机制的几种情况（交互模式）：

• 字符串的长度为0或1时
• 符合标识符的字符串
• 字符串只在编译时进行驻留，而非运行时
• [-5,256]之间的整数数字

s1 = ''
s2 = ''
s1 is s2

s1 = '%'
s2 = '%'
s1 is s2

s1 = 'abc%'
s2 = 'abc%'
s1 == s2

s1 is s2

id(s1)
id(s2)

s1 = 'abcx'
s2 = 'abcx'
s1 is s2

id(s1)
id(s2)

a = 'abc'
b = 'ab'+'c'
c = ''.join(['ab','c'])
a is b
a is c 
c
type(c)
a
type(a)

a = -5
b = -5
a is b

a = -6
b = -6
a is b

import sys
a = 'abc%'
b = 'abc%'
a is b

a = sys.intern(b)
a is b
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

sys中的intern方法强制2个字符串指向同一个对象

PyCharm对字符串进行了优化处理

字符串驻留机制的优缺点：

• 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能呢的
• 在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join（）方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比“+”高。

2. 字符串的常用操作

（1）字符串的查询操作

index rindex find rfind

s = 'hello,hello'
#index查找子串第一次出现的位置，如果查找子串不存在，抛出ValueError
print(s,index('lo'))	#3
#查找子串第一次出现的位置，如果查找子串不存在，则返回-1
print(s,find('lo'))		#3
#查找子串最后一次出现的位置，如果查找子串不存在，抛出ValueError
print(s,rindex('lo'))	#9
#查找子串最后一次出现的位置，如果查找子串不存在，则返回-1
print(s,rfind('lo'))	#9

#print(s,index('k'))   	#ValueError
print(s,find('k'))    	#-1
#print(s,rindex('k'))
print(s,rfind('k'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（2）字符串的大小写转换操作

upper lower swapcase caplitalize title

'''字符串中的转换'''
s = 'hello,python'
a = s.upper()		#全部转换大写，产生一个新的字符串对象
print(a,id(a))
print(s,id(s))
b = s.lower()		#全部转换小写，产生一个新的字符串对象
print(b,id(b)) 
print(s,id(s))
print(b == s)
print(b is s)		#False

s2 = 'hello,Python'
print(s2,swapcase())	#字符串所有大写转换为小写，所有小写转换为大写
print(s2,capitalize())  #把第一个字母转换为大写，其余字母转换为小写
print(s2,title())		#把每个单词的第一个字母转换为大写，把每个单词的剩余字母转换为小写
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（3）字符串内容对齐操作

center ljust rjust zfill

s = 'hello,Python'

#居中对齐，第一个参数指定宽度，第二个参数指定填充符，默认空格。若设置宽度小于实际宽度，返回原字符串
print(s,center(20,'*'))

#左对齐，第一个参数指定宽度，第二个参数指定填充符
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))

#右对齐
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))

#右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串宽度
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))  #减号后开始添0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（4）字符串的劈分操作

split rsplit

s = 'hello world Python'
'''split从字符串的左边开始劈分，默认的劈分字符是空格字符，返回的值都是一个列表'''
lst = s.split()
print(lst)
s1 = 'hello|world|Python'
print(s1.split(sep = '|'))		#通过参数sep指定劈分符
print(s1.split(sep = '|',maxsplit = 1))		#通过maxsplit指定劈分字符串时最大劈分次数，经过最大次劈分后，剩余子串会单独作为一部分

'''rsplit从字符串的右边开始劈分，默认的劈分符是空格字符串，返回的值都是一个列表'''
print(s.rsplit())
print(s.resplit(sep = '|'))
print(s.rsplit(sep = '|',maxsplit = 1))
1
2
3
4
5
6
7
8
9
10
11
12

（5）判断字符串的操作

isidentifier isspace isalpha isdecimal isnumeric isalnum

#判断指定的字符串是不是合法的标识符
s = 'hello,python'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4.','张三_123'.isidentifier())

#判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
print('5.','\t'.isspace())

#判断指定的字符串是否全部由字母组成
print('6.','abc'.isalpha())
print('7.','张三'.isalpha())
print('8.','张三1'.isalpha())

#判断指定的字符串是否全部由十进制数字组成
print('9.','123'.isdecimal())
print('10.','123四'.isdecimal())
print('11.','ⅠⅡⅢ'.isdecimal())

#判断指定的字符串是否全部由数字组成
print('12.','123'.isnumeric())
print('13.','123四'.isnumeric())
print('14.','ⅠⅡⅢ'.isnumeric())

#判断指定的字符串是否全部由字母和数字组成
print('15.','abc1'.isalnum())
print('16.','张三123'.isalnum())
print('17.','abc!'.isalnum())
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

（6）字符串操作的其他方法

repalce join

#replace第一个参数指定被替换子串，第二个参数指定替换子串，第三个参数指定最大替换次数
s = 'hello,Python'
print(s.replace('Python','Java'))
s1 = 'hello,Python,Python,Python'
print(s1.replace('Python','Java',2))

#join将列表或元组中的字符串合并为一个字符串
lst = ['hello','java','Python']
print('|'.join(lst))
print(''.join(lst))

t = ('hello','java','Python')
print(''.join(t))

print('*'.join('Python'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. 字符串的比较

< > = < < = = = ! =

**比较规则：**首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。

**比较原理：**两个字符进行比较时，比较的是其ordinal value（原始值），调用内置函数ord就可以得到指定字符的ordinal value。与内置函数对应的是内置函数chr，调用内置函数chr时可以使指定的ordinal value得到其对应的字符。

print('apple' > 'apple')	#True
print('apple' > 'banana')   #97>98,Flase
print(ord('a'),ord('b'))
print(ord('杨'))

print(chr(97),chr(98))
print(chr(26472))

'''is与 == 的区别
==比较的是value
is 比较的是id'''
a = b = 'Python'
c = 'Python'
print(a == b)
print(b == c)
print(a is b)
print(a is c)
print(id(a))
print(id(b))
print(id(c))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4. 字符串的切片操作

• 字符串是不可变类型，不具备增删改等操作，切片操作将产生新的对象。

s = 'hello,Python'
s1 = s[:5]		#没有指定起始位置，从0开始
s2 = s[6:]		#没有指定结束位置，直到最后一个为止
s3 = '!'
newstr = s1 + s3 + s2
print(s1)
print(s2)
print(newstr)
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))

print('---------切片[start:end:step]------')
print(s[1:5:1])		#从1开始截到5，不包括5，步长为1
print(s[::2])		#默认从0开始，直到最后一个元素，索引间隔为2
print(s[::-1])		#默认从最后一个元素开始，直到第一个元素结束，因为步长为-1
print(s[-6::1])		#截取Python字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5. 格式化字符串

**为什么需要格式化字符串？**按照一定格式输出字符串。

两种方式：%作占位符；{}作占位符。

'''格式化字符串'''
#使用 % 占位符
name = '张三'
age = 20
print('我叫%s，今年%d岁' % (name,age))

#使用 {} 占位符
print('我叫{0}，今年{1}岁'.format(name,age))

#f-string（Python 3.x以上版本）
print(f'我叫{name}，今年{age}岁')

#宽度和精度
print('%d' % 99)
print('%10d' % 99)			#10代表宽度
print('%.3f' % 3.1415926)	#.3保留三位小数
print('%10.3f' % 3.1415926)	#宽度为10，小数点后三位

print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.1415926))	#.3表示一共是3位数
print('{0:.3f}'.format(3.1415926))	#.3f表示3位小数
print('{:10.3f}'.format(3.1415926))	#同时设置宽度和精度，一共是10位数，3位小数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6. 字符串的编码转换

编码与解码的方式：

• 编码：将字符串转换成二进制数据（bytes）
• 解码：将bytes类型的数据转换成字符串类型

s = '天涯共此时'
#编码
print(s.encode(encoding = 'GBK'))	#GBK编码格式中，一个中文占两个字节
print(s.encode(encoding = 'UTF-8'))	#UTF-8中，一个中文占三个字节

#解码
byte = s.encode(encoding = 'GBK')		#编码
print(byte.decode(encoding = 'GBK'))	#解码   byte代表的就是一个二进制数据（字节类型的数据）

byte = s.encode(encoding = 'UTF-8')		#编码
print(byte.decode(encoding = 'UTF-8'))
1
2
3
4
5
6
7
8
9
10
11

十一、水晶球不调不动

1. 函数的创建和调用

**什么是函数？**函数就是执行特定任务和完成特定功能的一段代码。

**为什么需要函数？**复用代码；隐藏实现细节；提高可维护性；提高可读性便于调试。

函数的创建 def 函数名（[输入参数]）：函数体 [return xxx]

函数的调用 函数名([实际参数])

def calc(a,b):		#a,b称为形式参数，简称形参，形参位置在函数的定义处
	c = a + b		
    return c
'''位置实参传递'''
result = calc(10,20) 	#10，20实际参数，简称实参，位置在函数的调用处
print(result)
'''关键字实参传递'''
res = calc(b = 10,a = 20)
print(res)
1
2
3
4
5
6
7
8
9

2. 函数调用的参数传递

• 位置实参：根据形参对应的位置进行实参传递
• 关键字实参：根据形参名称进行实参传递

def fun(arg1,arg2):
    print('arg1',arg1)
    print('arg2',arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1',arg1)
    print('arg2',arg2)
    #return
n1 = 11
n2 = [22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2)

print('n1',n1)
print('n2',n2)
'''在函数的调用过程中，进行参数的传递，
如果是不可变对象，在函数体的修改不会影响实参的值，arg1修改为100，不会影响n1的值
如果是可变对象，在函数体内的修改会影响实参的值，arg2的修改.append(10)，会影响到n2的值'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

**函数的返回值：**函数返回多个值时，结果为元组。

print(bool(0))	#False 零的布尔值为False
print(bool(1))	#True 非零整数布尔值为True

def fun(num):
    odd = []	#村奇数
    even = []	#存偶数
    for i in num:
        if i % 2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
#函数的调用
lst = [10,29,34,23,44,53,55]
print(fun(lst))
'''函数的返回值
1.如果函数没有返回值（函数执行完毕后，不需要给调用处提供数据） return可以不写
2.函数的返回值，如果是1个，直接返回类型
3.函数的返回值，如果是多个，返回结果为元组'''

def fun1():
    print('hello')
    #return    
fun1()

def fun2():
   return 'hello'
res = fun2()
print(res)
    
def fun3():
    return 'hello','world'
print(fun3())
    
'''函数在定义时，是否需要返回值，视情况而定'''
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

3. 函数的参数定义

（1）函数定义默认值参数

函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参。

def fun(a,b = 10):    #b默认值参数
    print(a,b)
#函数的调用
fun(100)
fun(20,30)

# def print(self, *args, sep='', end='\n',file=None):
print('hello')
print('world')
print('hello',end = '\t')
print('world')
1
2
3
4
5
6
7
8
9
10
11

（2）个数可变的位置参数

定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数；使用*定义个数可变的位置形参；结果为一个元组。

def fun(*args):		#函数定义时 可变的位置参数
    print(args)
    print(args[0])
    
fun(10)
fun(10,30)
fun(30,405,50)
1
2
3
4
5
6
7

（3）个数可变的关键字形参

定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参；使用**定义个数可变的关键字形参；结果为一个字典。

def fun1(**args):
    print(args)
    
fun1(a = 10)
fun1(a = 20,b=30,c=40)

'''def fun2(*args,*a):
	pass
	代码运行，程序报错，个数可变的位置参数，只能是一个
	def fun3(**args,**args):
		pass
	代码运行，程序报错，个数可变的关键字参数，只能是一个'''

def fun2(*args1,**args2):
    pass
'''def fun3(**args1,*args2):
	pass
	在一个函数的定义过程中，既有个数可变的位置形参，也有个数可变的关键字形参，要求，个数可变的位置形参放在个数可变的关键字形参之前'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

（4）函数的参数总结

def fun(a,b,c):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)

#函数的调用
fun(10,20,30)	#函数调用时的参数传递，称为位置传参
lst = [11,22,33]
fun(*lst)		#在函数调用时，将列表中的每个元素都转换成位置实参传入
print('----------------')
fun(a=100,c=300,b=200)	#函数的调用，关键字实参
dic = {'a':111,'b':222,'c':333}
fun(**dic)		#函数调用时，将字典中的键值对都转换成关键字实参传入
1
2
3
4
5
6
7
8
9
10
11
12
13

def fun(a,b=10):		#b是在函数的定义处，所以是形参，而且进行了赋值，所以是默认值形参
    print('a=',a)
    print('b=',b)
    
def fun2(*args):	#个数可变的位置形参
	print(args)
def fun3(**args2):	#个数可变的关键字形参
    print(args2)
   
fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)

def fun4(a,b,c,d):	
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

#调用fun4函数
fun4(10,20,30,40)			#位置实参传递
fun4(a=10,b=20,c=30,d=40)	#关键字实参传递
fun4(10,20,c=30,d=40)		#前两个参数，采用位置实参传递，后两个参数采用关键字实参传递

'''需求：c，d只能采用关键字实参传递'''
#def fun4(a,b,*,c,d):	从*之后的参数，在函数调用时，只能采用关键字参数传递	
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

'''函数定义时的形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args2):
    pass
def fun7(a,b=10,*args,**args2):
    pass
1
2
3
4
5
6
7

4. 变量的作用域

变量的作用域：程序代码能访问该变量的区域。根据变量的有效范围可以分为局部变量、全局变量。

def fun(a,b):
    c = a+b		#c是局部变量，因为是在函数体内进行定义的；a，b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)
#print(c)	，因为a，c超出了起作用的范围（超出了作用域）
#print(a)

name ='杨老师'		#name作用范围为函数的内部和外部都可以使用，全局变量
print(name)
def fun2():
    print(name)
#调用函数
fun2()

def fun3():
    global age		#函数内部定义的变量，局部变量；局部变量使用global声明之后，这个变量实际上就变成了全局变量
    age = 20
    print(age)
fun3()
print(age)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5. 递归函数

什么是递归函数？

如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数.

递归函数的组成部分：

递归调用条件与递归终止条件.

递归的调用过程：

每递归调用一次函数，都会在栈内存分配一个栈帧；每执行完一次函数，都会释放相应的空间.

递归的优缺点：

优点是思路和代码简单；缺点是占用内存多，效率低下.

'''使用递归计算阶乘'''
def fac(n):
    if n == 1:
        return 1
    else:
        res = n*fac(n-1)
        return res
    
print(fac(6))
1
2
3
4
5
6
7
8
9

6. 斐波那契数列

$$F_n=F_{n-1}+F_{n-2}$$

def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)
    
#斐波那契数列第六位
print(fib(6))
#斐波那契数列前六位(循环操作用列表)
for i in range(1,7):
    print(fib(i))
1
2
3
4
5
6
7
8
9
10
11
12
13

十二、全民来找茬

1. Bug的由来及分类

**Bug的由来：**世界上第一部万用计算机的进化版-马克2号（Mark Ⅱ）

**Debug：**排除程序bug

Bug的常见类型：

• 粗心导致的语法错误 SyntaxError

  age = input('请输入你的年龄：')
  print(type(age))
  if age >= 18 :  #if int(age) >= 18:
      print('成年人...')
      
  while i < 10:			#i没有初始值，括号为中文状态的，缺少i += 1使程序进入循环状态	
      print（i）
      
  for i in range(3):
      uname = input('请输入用户名：')
      pwd = input('请输入密码：')
      if uname = 'admin' and pwd = 'admin': 		#一个 = 是赋值，两个 = 是比较
          print('登录成功！')
          break
      else
          print('输入有误')
  else 
      print('对不起，三次均输入错误')
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

  • 漏了末尾的冒号，如if语句，循环语句，else子句等
  • 缩进错误
  • 把英文符号写成中文符号，比如：冒号，引号，括号
  • 字符串拼接时候，把字符串和数字拼在一起
  • 没有定义变量，比如说while的循环条件的变量
  • == 比较运算符和 = 赋值运算符的混用

• 知识点不熟练导致的错误

  • 索引越界问题 IndexError
  • append( )方法的使用掌握不熟练

  lst = [11,22,33,44]
  print(lst[4]) 		#IndexError lst索引从0开始
  
  lst = []
  lst = append('A','B','C')
  print(lst)			#lst.append 且每次只能添加一个
  1
  2
  3
  4
  5
  6

• 思路不清导致的问题

  • 使用print()函数
  • 使用“#”暂时注释部分代码

  '''豆瓣电影Top250排行,使用列表存储电影信息,要求输入名字在屏幕上娴熟xxx出演了哪部电影'''
  lst = [{'rating':[9.7,2062397],'id':'1292052','type':['犯罪','剧情'],'title':'肖申克的救赎','actors':['蒂姆·罗宾斯','摩根·弗里曼']}
        {'rating':[9.6,1528760],'id':'1291546','type':['爱情','剧情','同性'],'title':'霸王别姬','actors':['张国荣','张丰毅','巩俐','葛优']}
        {'rating':[9.5,1559181],'id':'1292720','type':['剧情','爱情'],'title':'阿甘正传','actors':['汤姆·汉克斯','罗宾·怀特']}
        ]
  
  name = input('请输入你要查询的演员:')
  for item in lst:			#遍历列表,得到一个{},item是一个又一个的字典
      act_lst = item['actors']
      for actor in act_lst:
          if name in actor:
              print(name,'出演了：',item['title'])
              
      '''for movie in item:		#遍历字典,得到movie	是一个字典中的key
          actors = movie['actors']       
          if name in actors:
              print(name + '出演了:' + movie)'''
              
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

  第一层for循环遍历列表可以得到每一部电影，而每一部电影又是一个字典，只需要根据key在字典中取值即可。根据演员的键actors取出学员的列表，使用判断name在列表中是否存在，最后根据电影名称的键title取出电影的名称，进行输出。

• 被动掉坑：程序代码逻辑没有错，只是因为用户错误操作或者一些“例外情况”而导致的程序崩溃。

  '''输入两个整数并进行除法运算'''
  a = input('请输入第一个整数：')
  a = int(a)
  b = input('请输入第二个整数：')
  b = int(b)
  result = a/b
  print('结果为：',result)
  1
  2
  3
  4
  5
  6
  7

2. 异常处理机制

（1）try…except结构、try…except…except结构

try:
    n1 = int(input('请输入第一个整数：'))
    n2 = int('请输入第二个整数：')
    result = n1/n2
    print('结果为：',result)
except ZeroDivisionError:
    print('对不起，除数不允许为0')
except ValueError:
    print('只能输入数字串')
except BaseException as e:		#except从子类到父类，最后可以增加BaseException
    print(e)
print('程序结束')
    
1
2
3
4
5
6
7
8
9
10
11
12
13

（2）try…except…else结构

如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块。

try:
    a = int(input('请输入第一个整数：'))
	b = int(input('请输入第二个整数：'))
	result = a / b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
1
2
3
4
5
6
7
8

（3）try…except…else…finally结构

finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源。

try:
    a = int(input('请输入第一个整数：'))
	b = int(input('请输入第二个整数：'))
	result = a / b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
finally:
    print('谢谢您的使用')
1
2
3
4
5
6
7
8
9
10

（4）traceback模块

使用traceback模块打印异常处理信息，存储log日志。

#print(10/0)

import traceback
try:
    print('------------------')
    print(1/0)
except:
    traceback.print_exc()
1
2
3
4
5
6
7
8

3. Python常见的异常类型

'''ZeroDivisionError'''
print(10/0)
'''IndexError'''
lst = [11,22,33,44]
print(lst[4])
'''KeyError'''
dic = {'name':'张三','age':20}
print(dic['gender'])
'''NameError'''
print(num)
'''SyntaxError'''
int a = 20
'''ValueError'''
a = int('hello')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4. PyCharm的调试模式

i = 1
while i <= 10:		#设置断点进行调试
    print(i)	
    i += 1
1
2
3
4

十三、找对象不积极，思想有问题

1. 两大编程思想

2. 类和对象的创建

类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质。

**对象：**不同数据类型属于不同的类，像100、99、520都是int类之下包含的相似的不同个例，这些个例专业术语称为实例或者对象。

（1）类的创建

class Student:
    pass

'''Student类名由一个或多个单词组成，每个单词的首字母大写，其余小写'''
#Python中一切皆对象，Student是对象吗？内存由开空间吗？
print(id(Student))
print(type(Student))
print(Student)
1
2
3
4
5
6
7
8

类的组成：

• 类属性
• 实例方法
• 静态方法
• 类方法

class Student:
    native_pace = '吉林'		#直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name = name	#self,name称为实体属性，进行了一个赋值的操作，将局部变量name的值赋给实体属性
        self.age = age
   
	#实例方法
    def eat(self):
        print('学生在吃饭...')
    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
        
'''在类之外定义的称为函数，在类之内定义的称为方法
def drink();		#函数
	print('喝水')
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

（2）对象的创建

对象的创建又称为类的实例化：实例名 = 类名（）

class Student:
    native_pace = '吉林'		#直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name = name	#self,name称为实体属性，进行了一个赋值的操作，将局部变量name的值赋给实体属性
        self.age = age
   
	#实例方法
    def eat(self):
        print('学生在吃饭...')
    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
        
'''在类之外定义的称为函数，在类之内定义的称为方法
def drink();		#函数
	print('喝水')
'''

#创建Student类的对象
stu1 = Student('张三'，20)
stu1.eat()			#对象名.方法名()
print(stu1.name)
print(stu1.age)
print('---------------------------')
print(id(stu1))
print(type(stu1))
print(stu1)
print('---------------------------')
print(id(Student))
print(type(Student))
print(Student)
print('--------------------------')
Student.eat(stu1)		#类名.方法名(类的对象)		与stu1.eat()一样，都是调用Student中的eat方法
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

3. 类属性、类方法、静态方法

• **类属性：**类中方法外的变量称为类属性，被该类的所有对象所共享。
• **类方法：**使用@classmethod修饰的方法，使用类名直接访问的方法。
• **静态方法：**使用@staticmethod修饰的方法，使用类名直接访问的方法。

class Student:
    native_pace = '吉林'		#直接写在类里的变量，称为类属性
    def __init__(self,name,age):		#初始化方法
        self.name = name	#self,name称为实体属性，进行了一个赋值的操作，将局部变量name的值赋给实体属性
        self.age = age
   
	#实例方法
    def eat(self):
        print('学生在吃饭...')
        
    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
        
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')

        
print('------------类属性的使用方法---------------')      
print(Student.native_pace)
stu1 = Student('张三',20)
stu2 = Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'
print(stu1.native_pace)
print(stu2.native_pace)
print('------------类方法的使用方式--------------')
Student.cm()
print('-----------静态方法的使用方式----------------')
Student.method()
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

4. 动态绑定属性和方法

Python是动态语言，在创建对象后，可以动态地绑定属性和方法。

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print(self.name + '在吃饭')
        
stu1 = Student('张三',20)
stu2 = Student('李四',30)
print(id(stu1))
print(id(stu2))
print('---------只给李四添加一个性别---------------')
stu2.gender = '女'
print(stu1.name,stu1.age)		#如果添加stu1.gender会抛出AttributeError
print(stu2.name,stu2.age,stu2.gender)

print('-------------------------')
stu1.eat()
stu2.eat()

def show():
    print('定义在类之外地，称为函数')
stu1.show = show
stu1.show
#stu2.show		因为stu2并没有绑定show方法
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

十四 、接着找对象

面向对象的三大特征：

• 封装：提高程序的安全性。（1）将数据（属性）和行为（方法）包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度；（2）在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“__”；
• 继承：提高代码的复用性；
• 多态：提高程序的可扩展性和可维护性。

1. 封装

class Car:
    def __init__(self,brand):
        self.brand = brand
    def start(self):
        print('汽车已启动...')
        
car = Car('宝马X5')
car.start()
print(car,brand)
1
2
3
4
5
6
7
8
9

class Student:
    def __init__(self,name,age):
        self.name = name	
        self.__age = age 	#年龄age不希望在类的外部被使用，所以加了两个“_”
    def show(self):
        print(self.name,self.__age)

stu = Student('张三',20)
stu.show()
#在类的外部使用name与age
print(stu.name)
#print(stu.__age)
print(dir(stu))
print(stu._Student__age)	#在类的外部可以通过	_Student__age	进行访问
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 继承

**继承的特点：**如果一个类没有继承任何类，则默认继承object；Python支持多继承；定义子类时，必须在其构造函数中调用父类的构造函数。

#语法结构
class 子类类名(父类1，父类2...):
    pass
1
2
3

class Person(object):		#Person继承object类
    def __init__(self,anme,age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name,self.age)

class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no = stu_no
        
class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear = teachofyear
       
stu = Student('张三',20,'1001')
teacher = Teacher('李四'，34，10)

stu.info()
teacher.info()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class A(object):
    pass
class B(object):
    pass
class C(A,B):		#Python支持多继承
    pass
1
2
3
4
5
6

3. 方法重写

• 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写。
• 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法。

class Person(object):		#Person继承object类
    def __init__(self,anme,age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name,self.age)

class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no = stu_no
    def info(self):
        super().info()
        print(self.stu_no)
        
class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear = teachofyear
    def info(self):
        super().info()
        print('教龄',self.teachofyear)
       
stu = Student('张三',20,'1001')
teacher = Teacher('李四'，34，10)

stu.info()
teacher.info()
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

4. object类

• object类是所有类的父类，因此所有类都有object类的属性和方法。
• 内置函数dir()可以查看指定对象所有属性。
• Object有一个_str_()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮助我们查看对象的信息，所以我们经常会对_str_()进行重写。

class Student:
   def __init__(self,name,age):
    self.name = name
    self.age = age
   def __str__(self):
    return '我的名字是{0}，今年{1}岁。'.format(self.name,self,age)
stu = Student('张三',20)
print(dir(stu))
print(stu)		#默认调用__str__()方法
print(type(stu))
1
2
3
4
5
6
7
8
9
10

5. 多态

简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用地对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所用对象的类型，动态决定调用哪个对象中的方法。

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')
        
class Person:
    def eat(self):
        print('人吃五谷杂粮')
        
#定义一个函数
def fun(obj):
    obj.eat()
#开始调用函数
fun(Cat())
fun(Dog())
fun(Animal())
print('-----------------------')
fun(Person())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

静态语言和动态语言关于多态的区别：

• 静态语言实现多态的三个必要条件：继承，方法重写，父类引用指向子类对象，例如Java。
• 动态语言的多态崇尚“鸭子类型”。当看到一只鸟走起来像鸭子、游泳起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

6. 特殊方法和特殊属性

'''特殊属性'''
print(dir(object))
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name = name
        self.age = age
class D(A):
    pass
#创建C类的对象
x = C('Jack',20)			#x是C类型的一个实例对象
print(x.__dict__)			#实例对象的属性字典
print(C.__dict__)
print('-------------------------')
print(x.__class__)			#输出对象所属的类
print(C.__bases__)			#输出C类的父类类型的元素
print(C.__base__)			#输出类的基类
print(C.__mro__)			#类的层次结构
print(A.__subclasses__())	#输出A的子类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

'''特殊方法'''
a = 20
b = 100
c = a+b			#两个int类型的对象相加操作
d = a.__add__(b)
print(c)
print(d)

class Student:
    def __init__(self,name):
        self.name = name
    def __add__(self,other):
        return self.name + other.name
    def __len__(self):
        return len(self.name)
stu1 = Student('Jack')
stu2 = Student('李四')

s = stu1 + stu2			#实现了两个对象的加法运算（因为在Student类中，编写了__add__(）特殊的方法
print(s)
s = stu1.__add__(stu2)
print(s)

print('----------------------------')
lst = [11,22,33,44]
print(len(lst))
print(lst.__len__())
print(len(stu1))
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

'''__new__()和__init__()'''
class Person(object):
    
    def __new__(cls,*args,**kwargs):			#9360
        print('__new__()被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj = super().__new__(cls)
        print('创建的对象的id值为{0}'.format(id(obj)))				#7104
        return obj
	def __init__(self,name,age):
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))			#7104
        self.name = name
        self.age = age
        
print('object这个类对象的id为：{0}'.format(id(object)))		#3232
print('Person这个类对象的id为：{0}'.format(id(Person)))		#9360

#创建Person类的实例对象
p1 = Person('张三',20)
print('p1这个Person类的实例对象的id为：{0}'.format(id(p1)))		#7104
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7. 类的浅拷贝与深拷贝

**变量的赋值操作：**只是形成两个变量，实际上还是指向同一个对象。

**浅拷贝：**Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝。因此，源对象与拷贝对象会引用同一个子对象。

**深拷贝：**使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk
        
#(1)变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))
#(2)类的浅拷贝
print('-------------------')
disk = Disk()		#创建一个硬盘类的对象
computer = Computer(cpu1,disk)	#创建一个计算机类的对象
#浅拷贝
import copy
computer2 = copy.copy(computer)
print(disk)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
print('---------------------')
#深拷贝
computer3 = copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ByigLYR2-1625580399575)(…/PythonProjects/Typora_image/image-20210210175002816.png)]

十五、百宝箱

1. 什么叫模块？

模块（modules）：

• 一个模块中可以包含N多个函数
• 在Python中一个扩展名为 .py 的文件就是一个模块
• 使用模块的好处
  • 方便其他程序和脚本的导入并使用
  • 避免函数名和变量名的冲突
  • 提高代码的可维护性
  • 提高代码的可重用性

def fun():
    pass
def fun2():
    pass
class Student:
    native_place = '吉林'		#类属性
    def eat(self):
        pass
    @classmethod
    def cm(cls):
        pass
    @staticmethod
    def sm():
        pass
    

a = 10 
b = 20 
print(a,b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 自定义模块

导入模块

import 模块名称 [as 别名]

from 模块名称 import 函数/变量/类

import math
print(id(math))
print(type(math))
print(dir(math))

from math import pi
from math import pow
print(pi)
print(pow(2,3))
1
2
3
4
5
6
7
8
9

#自定义模块
def add(a,b):
    return a+b
def div(a,b):
    return a/b
#如何导入自定义模块
'''pycharm右键MarkDirectory as SourcesRoot'''
1
2
3
4
5
6
7

3. 以主程序的形式执行

在每个模块的定义中都包括一个记录模块名称的变量_name_，程序可以检查该变量，以确定他们在哪个模块执行，如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶端模块中执行。顶端模块的_name_变量的值为_main_

def add(a,b):
    return a+b

if __name__ == '__main__':
    print(add(10,20))		#只有当点击运行calc2模块时才会执行运算
1
2
3
4
5

import calc2
print(calc2.add(100,200))
1
2

4. Python中的包

包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下。

**作用：**代码规范；避免模块名称冲突

**包与目录的区别：**包含__int__.py文件的目录叫作包；目录里通常不包含__int__.py文件

#单击右键，创建-Python Package

import package
import calc
#使用import导入时只能跟包名和模块名

from package import modelA
from package.modelA import a
#使用from...import可以导入包，模块，函数变量等
1
2
3
4
5
6
7
8
9

5. Python中常见的内置模块

import sys
import time
import urllib.request
import math

print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))

print(time.time())
print(time.localtime(time.time()))

print(urllib.request.urlopen('http://www.baidu.com').read())

print(math.pi)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6. 第三方模块的安装及使用

#DOS
pip install schedule
python
import schedule
1
2
3
4

import schedule
import time

def job():
    print('哈哈-----')
    
schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)
1
2
3
4
5
6
7
8
9
10

十六、大宝藏

1. 编码格式介绍

常见的字符编码格式：

• Python的解释器使用的是Unicode（内存）
• .py文件咋磁盘上使用UTF-8存储（外存）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MlYuCssv-1625580399577)(…/PythonProjects/Typora_image/image-20210215103231516.png)]

2. 文件的读写原理

• 文件的读写俗称“IO操作”

Python操作文件 → 打开或新建文件夹 → 读写文件 → 关闭资源

3. 文件读写操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XLkqlfnq-1625580399578)(…/PythonProjects/Typora_image/image-20210216142431378.png)]

file = open('a.txt','r')
print(file.readlines())		#结果是一个list
file.close()
1
2
3

file = open('b.txt','w')
file.write('Python')
file.close()

file = open('b.txt','a')
file.write('Python')
file.close()
1
2
3
4
5
6
7

src_file = open('logo.png','rb')
target_file = open('copylogo.png','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()
1
2
3
4
5

4. 文件对象常用的方法

file = open('a.txt','r')
print(file.read(2))
print(file.readline())
print(file.readlines())
file.close()

file = open('c.txt','a')
file.write('hello')
lst = ['java','go','python']
file.writelines(lst)
file.close()

file = open('c.txt','r')
file.seek(2)	#一个中文两个字节
print(file.read())
print(file.tell())
file.close()

file = open('c.txt','a')
file.write('hello')
file.flush()
file.write('world')
file.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5. with语句（上下文管理器）

• with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正确的关闭，以此来达到释放资源的目的。

print(type(open('a.txt','r')))
with open('a.txt','r') as file:
    print(file.read())

'''MyContentMgr实现了特殊方法__enter__(),__exit__()称为该类对象遵守了上下文管理器协议。
该类对象的实例对象，称为上下文管理器

MyContentMgr()'''
class MyContentMgr(object):
    def __enter__(self):
        print('enter方法被调用执行了')
        return self
    
    def __exit__(self,exc_type,exc_val,exc_tb):
        print('exit方法被调用执行了')
        
    def show(self):
        print('show方法被调用执行了')
with MyContentMgr() as file:
    file.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#文件的复制
with open('logo.png','rb') as src_file:
    with open('copy2logo.png','wb') as target_file:
        target_file.write(src_file.read())
1
2
3
4

6. 目录操作

（1）os模块

• os模块是Python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。

• os模块与os.path模块用于对目录或文件进行操作。

#os模块与操作系统相关的一个模块
import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用可执行文件
os.startfile('D:\\YesPlayMusic\\YesPlayMusic.exe')
1
2
3
4
5
6

import os
print(os.getcwd())

os.listdir('../chap15')			#办公自动化经常使用
print(lst)

os.mkdir('newdir2')
os.makedirs('A/B/C')
os.rmdir('newdir2')
os.removedirs('A/B/C')

os.chdir('F:\\desktop\\chap14')
print(os.getcwd())
1
2
3
4
5
6
7
8
9
10
11
12
13

（2）os.path模块

import os.path
print(os.path.abspath('demo13.py'))
print(os.path.exists('demo13.py'),os.path.exists('demo18.py'))
print(os.path.join('E:\\Python','demo13.py'))
print(os.path.split('E:\\vippython\\chap15\\demo13.py'))
print(os.path.splitext('demo13.py'))
print(os.path.basename('E:\\vippython\\chap15\\demo13.py'))
print(os.path.dirname('E:\\vippython\\chap15\\demo13.py'))
print(os.path.isdir('E:\\vippython\\chap15\\demo13.py'))
1
2
3
4
5
6
7
8
9

'''列出指定目录下的所有py文件'''
import os
path = os.getcwd()
lst = os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)
1
2
3
4
5
6
7

#chap15-->newdir-->sub-->遍历所有文件walk
import os
path = os.getcwd()
lst_files = os.walk(path)
for dirpath,dirname,filename in lst_files:
    print(dirname)
    print(dirpath)
    print(filename)
    print('--------------------------')
    for dir in dirname:
        print(os.path.join(dirpath,dir))
        
    for file in filename:
        print(os.path.join(dirpath,file))
    print('+++++++++++++++++++++++++')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tnvegEqR-1625580399579)(…/PythonProjects/Typora_image/image-20210216174510594.png)]

十七、学生信息管理系统

1. 需求分析

学生管理系统应具备的功能：

• 添加学生及成绩信息
• 将学生信息保存到文件中
• 修改和删除学生信息
• 查询学生信息
• 根据学生成绩进行排序
• 统计学生的总分

2. 系统设计

七大模块：

• 录入学生信息模块
• 查找学生信息模块
• 删除学生信息模块
• 修改学生信息模块
• 学生成绩排名模块
• 统计学生总人数模块
• 显示全部学生信息模块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EGXb14Py-1625580399582)(…/PythonProjects/Typora_image/image-20210216180215185.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pdqZVtCp-1625580399583)(…/PythonProjects/Typora_image/image-20210219105757447.png)]

3. 系统开发必备

• 系统开发环境

  • 操作环境：Win10
  • Python解释器版本：Python3
  • 开发环境：PyCharm
  • Python内置模块：os，re

• 项目目录结构

  studentsys --> students.txt & stusystem.py

4. 主函数设计

• 系统主界面运行效果图
• 主函数的业务流程

filename = 'student.txt'
import os
def main():
    while True:
        menu()
        choice = int(input('请选择：\n'))
        if choice in [0,1,2,3,4,5,6,7]:
            if choice == 0:
                answer = input('您确定退出系统吗？y/n \n')
                if answer == 'y' or if answer == 'Y':
                    print('谢谢您的使用！')
                    break
                else:
                    continue
            if choice == 1:
                insert()
            elif choice == 2:
                search()
            elif choice == 3:
                delete()
            elif choice == 4:
                modify()
            elif choice == 5:
                sort()
            elif choice == 6:
                total()
            elif choice == 7:
                show()
def menu():
    print('======================学生信息管理系统===================')
    print('-----------------------功能菜单-----------------------')
    print('\t\t\t\t\t\t 1.录入学生信息')
    print('\t\t\t\t\t\t 2.查找学生信息')
    print('\t\t\t\t\t\t 3.删除学生信息')
    print('\t\t\t\t\t\t 4.修改学生信息')
    print('\t\t\t\t\t\t 5.排序')
    print('\t\t\t\t\t\t 6.统计学生总人数')
    print('\t\t\t\t\t\t 7.显示所有学生信息')
    print('\t\t\t\t\t\t 0.退出系统')
    print('------------------------------------------------------')
    
def insert():	#(1)
    pass
def search():	#(4)
    pass
def delete():	#(2)
    pass
def modify():	#(3)
    pass
def sort():		#(7)
    pass
def total():	#(5)
    pass
def show():		#(6)
    pass

if __name__ == '__main__':
    main()
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

5. 学生信息维护模块设计

（1）录入学生信息

• **实现录入学生信息模块：**从控制台录入学生信息，并保存到磁盘文件中。
• save(student)函数，用于将学生信息保存到文件
• insert()函数，用于录入学生信息

#(1)
def insert():
    student_list = []
    while True:
        id = input('请输入ID（如1001）：')
        if not id:
            break
        name = input('请输入姓名：')
        if not name:
            break
        try:
            English = int(input('请输入英语成绩：'))
            Python = int(input('请输入Python成绩：'))
            Java = int(input('请输入Java成绩'))
        except:
            print('输入无效，不是整数类型，请重新输入。')
            continue
        #将录入的学生信息保存到字典中
        student = {'id':id,'name':name,'English':English,'Python':Python,'Java':Java}
        #将学生信息添加到列表中
        student_list.append(student)
        answer = input('是否继续添加？y/n \n')
        if answer == 'y':
            continue
        else:
            break
    #调用save()函数
    save(student_list)
    print('学生信息录入完毕！')

def save(lst):
    try:
        stu_txt = open(filename,'a',encoding = 'utf-8')
    except:
        stu_txt = open(filename,'w',encoding = 'utf-8')
        for item in lst:
            stu_txt.write(str(item) + '\n')
        stu_txt.close()
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

（2）删除学生信息

• **实现删除学生信息功能：**从控制台录入学生ID，到磁盘文件中找到对应的学生信息，并将其删除。

#(2)
def delete():
    while True:
        student_id = input('请输入要删除的学生的ID：')
        if student_id != '':
            if os.path.exists(filename):
                with open(filename,'r',encoding = 'utf-8') as file:
                    student_old = file.readlines()
            else:
                student_old =[]
            flag = Fasle		#标记是否删除
            if student_old:
                with open(filename,'w',encoding = 'utf-8') as wfile:
                    d={}
                    for item in student_old:
                        d = dict(eval(item))	#将字符串转成字典
                        if d['id'] != student_id:
                            wfile.write(str(d) + '\n')
                        else:
                            flag = True
                    if flag:
                        print(f'id为{student_id}的学生信息已被删除')
                    else:
                        print(f'没有找到ID为{student_id}的学生信息')
                else:
                    print('无学生信息')
                    break
                show()		#删除之后要重新显示所有学生信息
                answer = input('是否继续删除？y/n \n')
                if answer == 'y':
                    continue
                else:
                    break
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

（3）修改学生信息

• **实现修改学生信息功能：**从控制台录入学生ID，到磁盘文件中找到对应的学生信息，将其进行修改。

def modify():
    show()
    if os.path.exists(filename):
        with open(filename,'r',encoding = 'utf-8') as rfile:
            student_old = rfile.readlines()
    else:
        return
    student_id = input('请输入要修改的学生的ID：\n')
    with open(filename,'w',encoding = 'utf-8') as wfile:
        for item in student_old:
            d = dict(eval(item))
            if d['id'] == student_id:
                print('找到学生信息，可以修改他（她）的相关信息了！')
                while True:
                    try:
                        d['name'] = input('请输入姓名：\n')
                        d['English'] = input('请输入英语成绩：\n')
                        d['Python'] = input('请输入Python成绩：\n')
                        d['Java'] = input('请输入Java成绩：\n')
                    except:
                        print('您的输入有误，请重新输入！')
                    else:
                        break
                wfile.write(str(d) + '\n')
                print('修改成功！')
            else:
                wfile.write(str(d) + '\n')
        answer = input('是否继续修改其他学生信息？y/n \n')
        if answer == 'y':
            modify()
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

（4）查找学生信息

• **实现查询学生信息功能：**从控制台录入学生ID或姓名，到磁盘文件中找到对应的学生信息。

def search():
    student_query = []
    while True:
        id = ''
        name = ''
        if os.path.exists(filename):
            mode = input('按ID查找请输入1，按姓名查找请输入2：\n')
            if mode = '1':
                id = input('请输入学生ID:\n')
            elif mode = '2':
                name = input('请输入学生姓名:\n')
            else:
                print('您的输入有误，请重新输入：\n')
                search()
            with open(filename,'r',encoding = 'utf-8') as  rfile:
                student = rfile.readlines()
                for item in student:
                    d = dict(eval(item))
                    if id != '':
                        if d['id'] == id:
                            student_query.append(d)
                    elif name != '':
                        if d['name'] == name:
                            student_query.append(d)
             #显示查询结果
            show_student(student_query)
            #清空列表
            student_query.clear()
            answer = input('是否要继续查询？y/n \n')
            if answer == 'y':
                continue
            else:
                break
        else:
            print('暂未保存学生信息！')
            return
def show_student(lst):
    if len(lst) == 0:
        print('没有查询到学生信息，无数据显示！')
        return
    #定义标题的显示格式
    format_title = '{:^6 \t {:^12} \t {:^8} \t {:^10} \t {:^10} \t {:^8}}'
    print(format_title.format('ID','姓名','英语成绩','Python成绩','Java成绩','总成绩'))
    #定义内容的显示格式
    format_data = '{:^6 \t {:^12} \t {:^8} \t {:^8} \t {:^8} \t {:^8}}'
    for item in lst:
        print(format_data.format(item.get('id')),item.get('name'),item.get('English'),item.get('Python'),item.get('Java'),int(item.get('English'))+int(item.get('Python'))+int(item.get('Java'))  )
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

（5）统计学生总人数

• **实现统计学生总人数：**统计学生信息文件中保存的学生信息个数。

def total():
    if os.path.exists(filename):
        with open(filename.'r',encoding = 'utf-8') as rfile:
            students = rfile.readlines()
            if students:
                print(f'一共有{len(students)}名学生。')
    else:
        print('还没有录入学生信息。')
1
2
3
4
5
6
7
8

（6）显示所有学生信息

• **实现显示所有学生信息功能：**将学生信息文件中保存的全部学生信息获取并显示。

def show():
    student_lst =[]
    if os.path.exists(filename):		#判断文件是否存在
        with open(filename,'r',encoding ='utf-8') as rfile:		#打开文件
            students = rfile.readlines()		#读取全部数据
            for item in students:
                student_lst,append(eval(item))
            if student_lst:
                show_student(student_lst)		#调用显示学生信息的方法
    else:
        print('暂未保存数据')  
1
2
3
4
5
6
7
8
9
10
11

（7）排序学生成绩

• **实现按学生成绩排序功能：**主要对学生信息按英语成绩，Python成绩，Java成绩，总成绩进行升序或者降序排序。

def sort():
    show()
    if os.path.exists(filename):
        with open(filename,'r',encoding ='utf-8') as rfile:
            student_list = rfile.readlines()
        student_new = []
        for item in stuednt_list:
            d = dict(eval(item))
            student_new,append(d)
    else:
        return
    asc_or_desc = input('请选择 \n (0.升序；\n (1.降序')
    if asc_or_desc == '0':
        asc_or_desc_bool = False
    elif asc_or_desc == '1':
        asc_or_desc_bool = True
    else:
        print('您的输入有误，请重新输入。')
        sort()
    mode = input('请选择排序方式 \n (1.按英语成绩排序; \n (2.按Python成绩排序; \n (3.按Java语言成绩排序; \n (0.按总成绩排序.')
    if mode == '1':
        student_new.sort(key = lambda x:int(x['English']),reverse = asc_or_desc_bool)
    elif mode == '2':
        student_new.sort(key = lambda x:int(x['Python']),reverse = asc_or_desc_bool)
    elif mode == '3':
        student_new.sort(key = lambda x:int(x['Java']),reverse = asc_or_desc_bool)
    elif mode == '0':
        student_new.sort(key = lambda x: int(x['English']) + int(x['Python']) + int(x['Java']),reverse = asc_or_desc_bool)
    else:
        print('您的输入有误，请重新输入！')
        sort()
    show_student(student_new)		#显示排序结果
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

6. 项目打包

• 安装第三方模块：（1）在线安装方式 pip install PyInstaller；（2）执行打包操作

十八、案例实操

1. 案例一

（1）向文件输出“奋斗成就更好的你”

# Task1 使用print方式进行输出
fp = open('F:/test.txt','w')
print('奋斗成就更好的你',file = fp)
fp.close()

# Task1 使用文件读写操作
with open('F:/test1.txt','w') as file:
    file.write('奋斗成就更好的你')
1
2
3
4
5
6
7
8

（2）输出北京的天气预报

print('星期日','今天')
print('--------------------')
print('08时','11时','14时','17时','20时','23时')
print('0℃ ','6℃ ','10℃','4℃ ','1℃ ','0℃ ')
print('--------------------')
print('明 天 ','2/23','2/11℃')
print('星期二','2/24','0/9℃')
print('星期三','2/25','-2/8℃')
print('星期四','2/26','-3/6℃')
print('星期五','2/27','-2/7℃')
print('星期六','2/28','-1/11℃')
1
2
3
4
5
6
7
8
9
10
11

（3）机票购买界面

print('✈国内 \t ♜国际.港澳台 \t ↘发现低价')
print('------------------------')
print('航班类型：⊙单程	⊙往返	⊙多程（含缺口城）')
print('出发城市：北京')
print('到达城市：长春')
print('出发日期：2020-3-8')
print('返回日期：yyyy-MM-dd')
print('------------------------')
print('\t\t ☐带儿童  ☐带婴儿')
print('\t\t\t__________')
print('\t\t\t___搜索___')
1
2
3
4
5
6
7
8
9
10
11

（4）北京地铁1号线运行图

print('地铁1\t\t\t四惠东→苹果园')
print('\t\t首车：05:05')
print('\t\t末车：23:30\t\t票价：起步价：2元')
print('------------------------------------')
print('  1\t\t  3\t  5\t  7\t\t  9\t\t  11\t\t  12\t\t 14\t\t 16\t\t 18\t\t 20\t\t')
print('   ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t ⇌\t\t')
print('四惠东\t大望路\t永安里\t东单\t天安门东\t西单\t复兴门\t木樨地\t公主坟\t五棵松\t八宝山')
1
2
3
4
5
6
7

2. 案例二

（1）输出杨老师出版的图书信息

#1
print('►→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→◄')
print('▷       《Java程序设计教程》   ◁')
print('► 出版社：西安电子科技大学出版社 ◄')
print('▷     出版时间：2019-02-02     ◁')
print('►        定  价：56.8          ◄')
print('▷→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→◁')

#2
book_name = 'Java程序设计教程'
publish = '西安电子科技大学出版社'
pub_date = '2019-02-02'
price = 56.8
print('▶➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝◀')
print('▷\t\t 《',book_name,'》 \t\t ◁')
print('▷\t出版社：',publish,'\t ◁')
print('▷\t出版时间：',pub_date,'\t\t\t ◁')
print('▷\t定 价：',price,'\t\t\t\t ◁')
print('▷➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝➝◁')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（2）输出《红楼梦》中的金陵十二钗前五位

#1 变量的赋值
name1 = '林黛玉'
name2 = '薛宝钗'
name3 = '贾元春'
name4 = '贾探春'
name5 = '史湘云'
print('①\t' + name1)
print('②\t' + name2)
print('③\t' + name3)
print('④\t' + name4)
print('⑤\t' + name5)
#2 列表
lst_name = ['林黛玉','薛宝钗','贾元春','贾探春','史湘云']
lst_sig = ['①','②','③','④','⑤']
for i in range(5):
    print(lst_sig[i],lst_name[i])

#3字典
d = {'①':'林黛玉','②':'薛宝钗','③':'贾元春','④':'贾探春','⑤':'史湘云'}
for key in d:
    print('key,d[key]')
print('zip-----------------')
for s,name in zip(lst_sig,lst_name):
    print(s,name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

（3）输出图书音像勋章

print('\033[0;35m\t\t图书音像勋章\033[m')
print('\033[0;35m-----------------------\033[m')
print('\033[0;32m❀图书音像勋章\t\t✪专享活动 \033[m')
print('\033[0;34m❤专属优惠\t\t\t☎优惠提醒 \033[m')
print('\033[0;35m-----------------------\033[m')
1
2
3
4
5

（4）输出你的身体指标

height = 170
weight = 50.5
bmi = weight / (height+weight)
print('您的身高是：',height)
#print('您的身高是：' + str(height))
print('您的体重是：' + str(weight))
print('您的BMI是：' + str(bmi))
print('您的BMI的指数是：' '{:0.2f}'.format(bmi)
1
2
3
4
5
6
7
8

3. 案例三

（1）将指定的十进制数转换二进制、八进制、十六进制

def fun():
	num = int(input('请输入一个十进制的整数：'))		#str转换成int类型
#使用个数可变的位置参数
	print(num,'的二进制数为：',bin(num))
#使用+作为连接符，注意符号左右均为str类型
	print(str(num) + '的二进制数为：' + 	bin(num))
#格式化字符串
	print('%s的二进制数为：%s' %  (num,bin(num)))
#格式化字符串
	print('{0}的二进制数为：{1}'.format(num,bin(num)))
#格式化字符串
	print(f'{num}的二进制数为：{bin(num)}')
	print('---------------------------')
	print(f'{num}的八进制数为：{oct(num)}')
	print(f'{num}的十六进制数为：{hex(num)}')

if __name__ == '__main__':
    while True:
    	try:
        	fun()
        	break
    	except:
        	print('只能输入整数！程序出错，请重新输入')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（2）为自己手机充值

print('用户手机账户原有话费金额为：\033[0;35m 8元 \033[m')
money = int(input('请输入用户的充值金额：'))
money += 8
print('当前的余额为：\033[0;32m ',money,'元 \033[m')
1
2
3
4

（3）计算能量的消耗

num = int(input('请输入您当天行走的步数：'))
calorie = num *28
print(f'您今天一共消耗了卡路里{calorie}，即{calorie/1000}千卡')
1
2
3

（4）预测未来子女的身高

father_height = float(input('请输入父亲的身高：'))
mother_height = float(input('请输入母亲的身高：'))
son_height = (father_height + mother_height)*0.54
print('预测子女的身高为：{}cm'.format(son_height))
1
2
3
4

4. 案例四

（1）支付密码的验证

pwd = input('支付宝支付密码：')
if pwd.isdigit():
    print('支付数据合法')
else:
    print('支付数字不合法，支付密码只能是数字')

print('---------------------------')
s = '支付数据合法' if pwd.isdigit() else '支付数字不合法，支付密码只能是数字'
1
2
3
4
5
6
7
8

（2）模拟QQ账号登录

qq = input('请输入您的QQ号：')
pwd = input('请输入您的密码：')
if qq == '296626472'  and pwd == '123':
    print('登陆成功')
else:
    print('账号或者密码不正确')
1
2
3
4
5
6

（3）商品价格大竞猜

import random
price = random.randint(1000,1500)
print('今日竞猜的商品为小米扫地机器人，价格在[1000-1500]之间：')
guess = int(input())
if guess > price:
    print('大了')
elif guess < price:
    print('小了')
else:
    print('猜对了')
print('真实价格为：',price)
1
2
3
4
5
6
7
8
9
10
11

（4）根据星座查看运势

d = {'白羊座':'1','金牛座':'2','双子座':'3','巨蟹座':'4','狮子座':'5'}
star = input('请输入您的星座查看近来的运势：')
#print(d[star])
print(d.get(star))
1
2
3
4

5. 案例五

（1）循环输出26个字母对应的ASCII码值

x = 97    #a的ASCII为97
for _ in range(1,27):
    print(chr(x),'--->',x)
    x += 1
    
print('---------------')
x = 97
while x < 123:
    print(chr(x),'---->',x)
    x += 1
1
2
3
4
5
6
7
8
9
10

（2）模拟用户登录

for i in range(1,4):
    user_name = input('请输入用户名：')
    user_pwd = input('请输入密码：')
    if user_name == 'admin' and user_pwd == '8888':
        print('登陆成功')
        break
    else:
        print('用户名或密码不正确！')
        if i < 3:
            print(f'您还有{3-i}次机会！')
else:
    print('对不起，三次均输入错误，请联系后台管理员！')
1
2
3
4
5
6
7
8
9
10
11
12

（3）猜数游戏

import random
rand = random.randint(1,100)
for i in range(1,11):
    num = int(input('在我心中有个数1-100，请你猜一猜。'))
    if num < rand:
        print('小了')
    elif num > rand:
        print('大了')
    else:
        print('恭喜你猜对了')
        break
print(f'您一共猜了{i}次')
if i < 3:
    print('真聪明')
elif i <= 7:
    print('还凑合')
else:
    print('天哪，找杨老师学习二分算法')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

（4）计算100-999之间的水仙花数

import math
for i in range(100,1000):
    if math.pow((i % 10),3) + math.pow((i//10%10),3) + math.pow(i // 100,3) == i:
        print(i)
1
2
3
4

6. 案例六

（1）“千年虫”我来了

year = [82,89,88,86,85,00,99]
print('原列表：',year)
for index,value in enumerate(year):
    #print(index,value)
    if str(value) != '0':
        year[index] = int('19' + str(value))
    else:
        year[index] = int('200' + str(value))

print('修改之后的列表为：',year)
year.sort()
print('排序之后的列表为：',year)
1
2
3
4
5
6
7
8
9
10
11
12

（2）京东购物流程

lst = []
for i in range(0,5):
    goods = input('请输入商品的名称进入商品的入库，每次只能输入一个商品：\n')
    lst.append(goods)
for item in lst:
    print(item)
    
cart = []
while True:
    num = input('请输入要购买的商品编号：')
    for item in lst:
        if item.find(num) != -1:
            cart.append(item)
            break		#退出for循环
        if num == 'q':
            break		#退出while循环
print('您购物车里已经选好的商品为：')
'''for m in cart:
    print(m)'''
for j in range(len(cart)-1,-1,-1):
    print(cart[j])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7. 案例七

（1）根据星座测试性格特点

constellation = ['白羊座','金牛座','双子座','巨蟹座','狮子座','处女座','天秤座','天蝎座','射手座','摩羯座','水瓶座','双鱼座']
nature = ['积极乐观','固执内向','圆滑世故','多愁善感','迷之自信','精明计较','犹豫不决','阴暗消极','放荡不羁','务实本分','作天作地','安于现状']

#将两个列表转成集合
a = zip(constellation,nature)
d = dict(zip(constellation,nature))
for item in a:
    print(item)
print(d)
key = input('请输入您的星座名称：')
flag = True
for item in d:
    if key == item:
        flag = True
        print(key,'的性格特点为：',d.get(key))
        break
    else:
        #print('您输入的星座有误')
        flag = False

if not flag:
    print('您输入的星座有误')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

（2）模拟12306火车票订票下单

dict_ticket = {
    'G1569':['北京南-天津南','18:05','18:39','00:34'],
    'G1567':['北京南-天津南','18:15','18:49','00:34'],
    'G8917':['北京南-天津西','18:20','19:19','00:59'],
    'G203 ':['北京南-天津南','18:35','19:09','00:34']
}
print('车次\t\t出发站\t\t到达站\t\t出发时间\t\t\t到达时间\t\t\t历时时长')
for item in dict_ticket:
    print(item,end = '   ')
    for i in dict_ticket[item]:
        print(i,end='\t\t\t')
    print()		#换行
#输入要购买的车次    
train_no = input('请输入购买的车次：')
persons = input('请输入乘车人。如果是多人请使用逗号分隔')
s = f'您已购买了{train_no}次列车，'
s_info = dict_ticket[train_no]		#获取车次详细信息
s += s_info[0] + ' ' + s_info[1] + ' 开。'
print(f'{s}请{persons}尽快取走纸质车票。【铁路客服】')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

8. 案例八

（1）我的咖啡馆你做主

coffee_name = ('蓝山','卡布奇诺','拿铁','皇家咖啡','女王咖啡','美丽与哀愁')
print('您好！欢迎光临小喵咖啡屋。')
print('本店经营的咖啡有：')
for index,item in enumerate(coffee_name):
    print(index+ +1 ,'.',item,end=' ')
    
index = int(input('\n请输入您喜欢的咖啡编号：'))
if 0 <= index <= len(coffee_name):
    print(f'您的咖啡[{coffee_name[index -1]}]好了，请您慢用')
1
2
3
4
5
6
7
8
9

（2）显示2019年中超联赛前五名排行

socres = (('广州恒大',72),('北京国安',70),('上海上港',66),('江苏苏宁',53),('山东鲁能',51))
for index,item in enumerate(scores):
    print(index +1,'.',end=' ')
    for score in item:
        print(score,end =' ')
    print()
1
2
3
4
5
6

（3）模拟手机通讯录

phones = set()		#创建一个空集合，集合元素没有顺序
for i in range(5):
    info = input(f'请输入第{i+1}个朋友的姓名和手机号码：')
    phones.add(info)
for item in phones:
    print(item)
1
2
3
4
5
6

9. 案例九

（1）统计字符串中出现指定字符的次数

def get_count(s,ch):
    count = 0
    for item in s:
        if ch.upper() == item or ch.lower() == item:
            count += 1
    return count

if __name__ == '__main__':
    s = 'hellopython,hellojava,hellogo'
    ch = input('请输入要统计的字符：')
    count = get_count(s,ch)
    print(f'{ch}在{s}中出现的次数为：{count}')
1
2
3
4
5
6
7
8
9
10
11
12

（2）格式化输出商品的名称和单价

def show(lst):
    for item in lst:
    	for i in item:
       	 print(i,end ='\t\t')
    print()
lst = [
    ['01','电风扇','美的',500],
    ['02','洗衣机','TCL',1000],
    ['03','微波炉','老板',400],
]
print('编号\t\t\t名称\t\t\t品牌\t\t\t单价')
show(lst)
print('----------格式化---------------')
for item in lst:
    item[0] = '0000' + item[0]
    item[3] = '￥{:.2f}'.format(item[3])
show(lst)    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

10. 案例十

（1）Mini计算器

def calc(a,b,op):
    if op == '+':
        return add(a,b)
    elif op == '-':
        return sub(a,b)
    elif op == '*':
        return mul(a,b)
    elif op == '/':
        if b != 0:
            return div(a,b)
        else:
            return '除数不能为0'
        
def add(a,b):
    return a + b
def sub(a,b):
    return a - b
def mul(a,b):
    return a * b
def div(a,b):
    return a/b

if __name__ == '__main__':
    a = int(input('请输入第一个整数：'))
    b = int(input('请输入第二个整数：'))
    op = input('请输入运算符：')
    print(calc(a,b,op))
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

（2）猜数游戏

import random
def guess(num,guess_num):
    if num = guess_num:
        return 0
    elif guess_num > num:
        return 1
    else:
        return -1
    
num = random.randint(1,100)
for i in range(10):
    guess_num = int(input('我心里有个1-100的整数，请你猜一猜：'))
    result = guess(num,guess_num)
    if result == 0:
        print('猜对了')
        break
    elif result > 0:
        print('大了')
    else:
        print('小了')
else:
    print('真笨，10次都没猜中！') 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

11. 案例十一

（1）编写程序输入学员成绩

try:
	score = int(input('请输入分数：'))
	if 0 <= score <= 100:
   	 	print('分数为：',score)
	else:
   	 	raise Exception('分数不正确')
except Exception as e:
    print(e)
1
2
3
4
5
6
7
8

（2）编写程序，判断三个参数能否构成三角形

def is_triangle(a,b,c):
    if a<0 or b<0 or c<0:
        raise Exception('三条边不能有负数')				#手动抛出异常对象
    
    #判断是否构成三角形
    if a+b>c and a+c>b and b+c>a:
        print(f'三角形的边长为a={a},b={b},c={c}')
    else:
        raise Exception(f'a={a},b={b},c={c}，不能构成三角形')
        
if __name__ == '__main__':
    try:
        a = int(input('请输入第一条边：'))
        b = int(input('请输入第二条边：'))
        c = int(input('请输入第三条边：'))
        is_triangle(a,b,c)
    except Exception as e:
        print(e)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

12. 案例十二

（1）定义一个圆的类来计算面积和周长

import math
class Circle(object):
    def __init__(self,r):
        self.r = r
        
    def get_area(self):
        return math.pi * math.pow(self.r,2)
    def get_perimeter(self):
        return 2*math.pi*self.r
    
if __name__ == '__main__':
    r = int(input('请输入圆的半径：'))
    c = Circle(r)
    print(f'圆的面积为：{c.get_area()}')
    print(f'圆的周长为：{c.get_perimeter()})
          
  	print('圆的面积为：{:.2f}'.format(c.get_area()))
  	print('圆的周长为：{:.2f}'.format(c.get_perimeter())) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

（2）定义学生类录入5个学生信息存储到列表中

class Student(object):
    def __init__(self,stu_name,stu_age_,stu_gender,stu_score):
        self.stu_name = stu_name
        self.stu_age = stu_age
        self.stu_gender = stu_gender
        self.stu_score = stu_score
        
    def show(self):
        print(self.stu_name,self.stu_age,self.stu_gender,self.stu_score)
        
if __name__ == '__main__':
    print('请输入五位学员的信息：(姓名#年龄#性别#成绩)')
    lst = []
    for i in range(0,5):
        s = input(f'请输入第{i+1}位学员的信息和成绩：')
        s_lst = s.split('#')
        #print(s_lst)
        #创建学生对象
        stu = Student(s_lst[0],int(s_lst[1]),s_lst[2],float(s_lst[3]))
        lst.append(stu)
    #遍历列表
    for item in lst:
        item.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

13. 案例十三

（1）编写程序实现乐手弹奏乐器

class Instrument():
    def make_sound(self):
        pass
    
class Erhu(Instrument):
    def make_sound(self):
        print('二胡在演奏')
class Piano(Instrument):
    def make_sound(self):
        print('钢琴在演奏')
class Violin(Instrument):
    def make_sound(self):
        print('小提琴在演奏')

def play(instrument):
    instrument.make_sound()

class Bird():
    def make_sound(self):
        print('小鸟在唱歌')
        
if __name__ == '__main__':
    play(Erhu())
    play(Piano())
    play(Violin())
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

（2）请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息

class Car(object):
    def __init__(self,type,no):
        self.type = type
        self.no = no
    def start(self):
        pass
    def stop(self):
        pass
    
class Taxi(Car):
    def __init__(self,type,no,company):
        super().__init__(type,no)
        self.company = company
    def start(self):
        print(’乘客您好！)
        print(f'我是{self.company}出租车公司的，我的车牌是{self.no}，请问您要去哪里？')
    def stop(self):
        print('目的地到了，请您付款下车，欢迎再次乘坐。')
        
class FamilyCar(Car):
    def __init__(self,type,no,name):
        super().__init__(type,no)
        self.name = name
    def stop(self):
        print('目的地到了，我们去玩吧')
    def start(self):
        print(f'我是{self.name}，我的汽车我做主')
        
if __name__ == '__main__':
    taxi = Taxi('上海大众','京A9765','长城')
    taxi.start()
    taxi.stop()
    print('-'* 30)
    familycar = FamilyCar('广汽丰田','京B88888','武大郎')
    familycar.start()
    familycar.stop()
    
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

14. 案例十四

（1）模拟高铁售票系统

import prettytable as pt

#显示座席
def show_ticket(row_num):
    tb = pt.PrettyTable()
    tb.field_names = ['行号','座位1','座位2','座位3','座位4','座位5']
    for i in range(row_num):
        lst = [f'第{i+1}行','有票','有票','有票','有票','有票']
        tb.add_row(lst)
    print(tb)
#订票
def order_ticket(row_num,row,column):
    tb = pt.PrettyTable()
    tb.field_names = ['行号','座位1','座位2','座位3','座位4','座位5']
    for i in range(row_num):
        if int(row) == i+1:
            lst = [f'第{i+1}行','有票','有票','有票','有票','有票']
            lst[int(column)] = '已售'
            tb.add_row(lst)
        else:
            lst = [f'第{i+1}行','有票','有票','有票','有票','有票']
            tb.add_row(lst)

if __name__ == '__main__':
    row_num = 13
    show_ticket(row_num)
    choose_num = input('请输入选择的座位，如13,5表示13排5号座位')
    #英文逗号处分隔行与列
    try:
       row,column = choose_num.split(',') 
    except:
        print('输入格式有误，如13排5号座位，应该位13,5')
    order_ticket(row_num,row,column)
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

（2）推算几天后的日期

import datetime
def inputdate():    
    indate = input('请输入开始日期：{20200202}后按回车')
    indate = indate.strip()
    datestr = indate[0:4] + '-' + indate[4:6] + '-' +indate[6:]
    return datetime.datetime.strptime(datestr,'%Y-%m-%d')

if __name__ == '__main__':
    print('--------------推算几天后的日期---------------------')
    sdate = inputdate()
    in_num = int(input('请输入间隔天数：'))
    fdate = sdate + datetime.timedelta(days = in_num)
    print('您推算的日期是：' + str(fdate))
    print('您推算的日期是：' + str(fdate).split(' ')[0])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

15. 案例十五

（1）记录用户的登录日志

import time
def show_info():
    print('输入提示数字，执行相应的操作：0.退出  1.查看登录日志')
    
#记录日志
def write_logininfo(username):
    with open('log.txt','a') as file:
        s = f'用户名{username}，登录时间：{time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))}'
        file.write(s)
        file.write('\n')

#读取日志
def read_logininfo():
    with open('log.txt','r') as file:
        while True:
            line = file.readlin()
            if line == '':
                break
            else:
               print(line,end = '') 
                        
if __name__ == '__main__':
    username = input('请输入用户名：')
    pwd = input('请输入密码：')
    if 'admin' == username and 'admin' == pwd:
        print('登录成功！')
        write_logininfo(username)
        show_info()
        num = int(input('请输入操作数字'))
        while True:
            if num == 0:
                print('退出成功')
                break
            elif num == 1:
                print('查看登录日志')
                read_logininfo()
                num = int(input('输入操作数字：'))
            else:
                print('您输入的数字有误')
                show_info()
                num = int(input('输入操作数字：'))
    else:
        print('对不起，用户名和密码不正确！')
    
    print(time.time())
    print(time.localtime(time.time()))
    print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
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

（2）模拟淘宝客服的自动回复

'''replay.txt文档
订单|如果您有任何订单问题，可以登录淘宝账号，点击“我的订单”，查看订单详情
物流|如果您有任何物流问题，可以登录淘宝账号，点击“我的订单”，查看商品系统
账户|如果您有任何账号问题，可以联系淘宝客服，电话：XXXX-XXXXXX
支付|如果您有任何支付问题，可以联系支付宝客服，QQ：XXXXXXXXX
'''
def find_answer(question):
    with open('replay.txt','r',encoding = 'gbk') as file:
        while True:
            line = file.readline()
            if not line:		#if line ==''到文件末尾退出
                break
            #字符串的分隔
            keyword = line.split('|')[0]
            reply = line.split('|')[1]
            if keyword in question:
                return reply
    return False

if __name__ == '__main__':
    question = input('Hi，您好，小蜜在此等主任很久了，有什么烦恼快和小蜜说吧')
    while True:
        if question == 'bye':
            break
        #开始在文件中查找
        replay = find_answer(question)
        if not replay:		#如果回复的是False，not False则为True
            question = input('小蜜不知道你在说什么，您可以问一些关于订单、物流、账户、支付等问题（退出请输入bye）')
        else:
            print(replay)
            question = input('小主，您还可以问一些关于订单、物流、账户、支付等问题（退出请输入bye')
    print('小主再见')
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