Python学习笔记

第一章.

1.print（数字直接数据，字符要加引号）

#注意：1.所指定的文件路径存在 2.file=fp fp=open('D:/text.txt','a+') print('hello',file=fp) fp.close() #a+代表若不存在即创建，若存在即添加。

2.转义字符：

1）什么是转义字符呢？

就是反斜杠+想要实现的转义功能首字母。

2）为什么需要转义字符？

当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义）

反斜杠:\

单引号:\

双引号：\"

3）当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符当字符串中包含换行回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符

换行:\n

回车:\r

水平制表符:\t(4个空格为一个制表位)

退格:\b

print('hello\nworld')换行 print('hello\tworld')制表位空格 print('hello\rworld')回车 print('hello\bworld')退格 print('https:\\\\www.baidu.com') print('我说\'在干嘛\'') print(r'hello\nworld') #原字符r或R，当加了原字符则转义字符不生效 #输出结果为 hello world 换行 hello world 制表位空格 world 回车 hellworld 退格 https:\\www.baidu.com 两个\只能输出一个，所以想输出两个的话需要输入四个\ 我说'在干嘛' 仅用引号无法分别是使用引号还是当做字符串的开头或结尾，所以需要再引号前加上\'\' hello\nworld 当加入原字符，转义字符不生效

注意：最后一个字符不能为\，如果要输出\需要以\\的形式进行输入。

第二章.

1.二进制与字符编码：

print(ord('乘')) #将字符转换输出为10进制数ord print(chr(0b0100111001011000)) #将二进制转换为字符，二进制前需要加0b 20056 乘

2.标识符和保留字

1）保留字：

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

import keyword print(keyword.kwlist) 查看保留字 ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2）标识符：

变量、函数、类、模块和其它对象的起的名字就叫标识符

规则：

字母、数字、下划线

不能以数宇开头

不能是保留宇

严格区分大小写

3.变量

变量是内存中一个带标签的盒子

变量由三部分组成

1）标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取

2）类型：表示的是对象的数据类型，使用内置函数type(obj)来获取

3）值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出

变量赋值相当于指向函数的id地址

name='玛利亚'

name 变量名

=赋值运算符

玛利亚 值

4.数据类型

1）整数类型

→int→98

integer：可表示正数、负数、0

证书的不同进制表示方式

十进制：默认

二进制：以0b开头

八进制：以0o开头

十六进制：以0x开头

1=90 n2=-70 n3=0 print(n1,type(n1)) print(n2,type(n2)) print(n3,type(n3)) print('十进制',175) print('二进制',0b10101111)

2）浮点数类型

→float→3.14159

浮点数整数部分和小数部分组成

浮点数存储不精确性

使用浮点数进行计算时，可能会出现小数位数不确定的情况

例：

n1=1.1 n2=2.2 print(n1+n2) #由于最终以二进制进行计算，导致结果有误 3.3000000000000003

解决方案：

导入模块decimal

from decimal import Decimal print(Decimal('1.1')+Decimal('2.2')) 3.3

3）布尔类型

→bool→True,False

boolean

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

f1=True f2=False print(f1,type(f1)) print(f2,type(f2)) True <class 'bool'> False <class 'bool'> print(f1+1) print(f2+3) 2 3 布尔值可以当做整数进行计算 t=1 f=0

4）字符串类型

→str→'人生苦短，我用Python'

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

str1='大家好' str2="大家好" str3='''大家 好''' str4="""大 家好""" print(str1,type(str1)) print(str2,type(str2)) print(str3,type(str3)) print(str4,type(str4)) #单双引号的情况下，用换行显示多行会报错，三引号不会报错

5.数据类型转换

为什么需要数据类型转换：将不同数据类型的数据拼接在一起

name='张三' age=20 print(type(name),type(age)) print('我叫'+name+'今年'+str(age)+'岁') 需要将age前加str转换为字符类型

6.注释

• 注释的内容会被Python解释器忽略
• 通常包括三种类型的注释

1. 单行注释→以”#”开头，直到换行结束
2. 多行注释→并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
3. 中文编码声 释→在文件开头加上中文声明注释，用以指定源码文件的编码格式

#conding:gbk 为python文件的存储类型，默认为utf-8 改为gbk后为ansi

day2

第三章.

1.输入函数input：

present=input('你在干什么') print(present,type(present)) aa <class 'str'> #默认情况输入值类型为str，无法用于运算 a=int(input('请输入第一个数')) 或 a=input('请输入第一个数') a=int(a) b=int(input('请输入另一个数')) print(a+b)

2.运算符：

1）算数运算符

print(1+1)#加法 print(2-1)#减法 print(3*3)#乘法 print(1/2)#除法 print(11//2)#整除 print(11%2)#取余/模运算 print(2**3)#幂运算，2的3次方 2 1 9 0.5 5 1 8 特殊情况： print(9//4) print(-9//-4) print(-9//4) #整除的情况下，若除数与被除数为一正一负，则向下取整 print(9//-4) #9/-4=-2.2 向下取整为-3 print(9%4) print(9%-4) #取余的情况下，若除数和被除数为一正一负，则代入公式 print(-9%4) #被除数-除数*商 9-（-4）*-3=-3 -9-4*-3=3

2）赋值运算符

1）链式赋值 a=b=c=20 #链式赋值 print(a,id(a)) print(b,id(b)) print(c,id(c)) 2）参数赋值 print('支持参数赋值') a=30 a+=20 #相当于a=a+20 print(a) a-=10 #相当于a=a-10 print(a) a*=2 #相当于a=a*2 print(a,type(a)) a/=3 print(a,type(a)) a//=2 print(a,type(a)) a%=3 print(a,type(a)) 3）解包赋值 a,b,c=20,30,40 print(a,b,c) a,b=10,20 print('交换之前：',a,b) a,b=b,a print('交换之后：',a,b) 20 30 40 交换之前： 10 20 交换之后： 20 10

3）比较运算符

对变量或表达式的结果进行大小，真假等比较

a,b=10,20 print("a>b吗",a>b) #F print('a<b吗',a<b) #T print('a<=b?',a<=b) #T print('a>=b?',a>=b) #F print('a=b?',a==b) #F print('a!=b?',a!=b) #T """=表示赋值 ==表示比较运算 ==比较的是value，若要比较id，要用is""" a=10 b=10 print(a==b) #T 说明a与b的value相同 print(a is b,id(a),id(b)) #T 说明a与b的id也相同 print(a is not b) #F a与b id相同 用is not 相当于id是否不同 a>b吗 False a<b吗 True a<=b? True a>=b? False a=b? False a!=b? True True True 140716469209816 140716469209816 False l1=[11,22,33,44] l2=[11,22,33,44] print(l1==l2) #对比value T print(l1 is l2) #对比id F True False

4）布尔运算符

对于布尔值之间的运算

a,b=1,2 print('and并且') print(a==1 and b==2) #a与b都为ture 结果为ture print(a==1 and b<2) #a为t b为f 结果为false print('or或者') print(a==1 or b==2) #a与b都为t 结果为t print(a==1 or b<2) #a为t，b为f 结果为t print(a!=1 or b==2) #a为f，b为t 结果为t print(a!=1 or b!=2) #a与b都为f 结果为f print("not取反") f1=True f2=False print(not f1) #结果为t的情况下为f print(not f2) #结果为f的情况下为t print("in与not in") s="hello world" print('w' in s) print('k' in s) print('w' not in s) print('k'not in s) and并且 True False or或者 True True True False not取反 False True in与not in True False False True

5）位运算符

将数据转成2进制去计算

print(4&8) #按位与，将4与8转换为二进制，同为1的为1，否则为0 print(4|8) #按位或，将4与8转换为二进制，两者其中之一为1的即为1 print(4<<1) #左移位，将二进制整体向左移1位，相当于乘2，高位截断，低位补0 print(4>>1) #右移位，将二进制整体向右移1位,相当于除2，低位截断，高位补0 0 12 8 2

6）运算符的优先级

1. 算数运算：先次方再乘除后加减
2. 位运算：先移位在按位或后按位与
3. 比较运算：
4. 布尔运算：先与后或
5. 赋值运算：

第四章.

1.程序的组织结构

1996年，计算机科学家证明了这样的事实：任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。

1）顺序结构

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

小技巧：可以通过设置断点和调试代码 #顺序结构 """把大象装冰箱需要几步""" print('---------程序开始-------------') print('1.打开冰箱门') print('2.把大象放进冰箱里') print('3.把冰箱门关上') print("----------程序结束--------------") ---------程序开始------------- 1.打开冰箱门 2.把大象放进冰箱里 3.把冰箱门关上 ----------程序结束--------------

2）对象的布尔值

Python一切皆对象，所有对象都有一个布尔值

获取对象的布尔值：使用内置函数bool()

以下对象的布尔值为False

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

#测试对象的布尔值 print('以下对象的布尔值为False,除此之外所有对象的布尔值均为Ture') 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()))#空集合 以下对象的布尔值为False,除此之外所有对象的布尔值均为Ture False False False False False False False False False False False False False

3）选择结构

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

（1）单分支结构

中文语义：如果........就........

如果下雨，就带伞

语法结构：

if 条件表达式：

条件执行体

money=1000 #余额 s=int(input('请输入取款金额')) #待取的数额 if money>=s: #如果余额足够的话 money=money-s print('取款成功，余额为：', money) #这里注意输出的空格位置 请输入取款金额100 取款成功，余额为： 900 #余额足够的情况下输出剩余的余额 请输入取款金额1200 #余额不足的情况下无返回数据

（2）双分支结构

中文语义：如果…不满足.…就…

如果中奖就领奖，没中奖就不领

如果是妖怪就打，不是就不打

语法结构：

if条件表达式：

条件执行体1

else:

条件执行体2

"""双分支结构if else，二选一执行 从键盘录入一个整数，编写程序让计算机判断奇偶""" n=int(input('请输入一个整数')) #条件判断 if n%2==0: print(n,'是偶数') else: print(n,'是奇数') 请输入一个整数10 10 是偶数 请输入一个整数5 5 是奇数

（3）多分支结构

中文语义：

• 成绩是在90分以上吗？不是
• 成绩是80到90分之间吗？不是
• 成绩是70到80分之间吗？不是
• 成绩是60到70分之间吗？不是
• 成绩是60分以下吗？是

语法结构：

if条件表达式1：

条件执行体1

elif条件表达式2：

条件执行体2

elif条件表达式N:

条件执行体N

[else:]

条件执行体N+1

以判断成绩级别为例 写法一： """要求从键盘录入一个整数 成绩 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: 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>=0 and score<=59: print('你的成绩为E') else: print('你的成绩有误') 写法二： #仅支持python语言这样写 if 90<=score<=100: print('你的成绩为A')

（4）嵌套if

语法结构：

if条件表达式1：

if内层条件表达式：

内层条件执行体1

else:

内层条件执行体2

else:

条件执行体

"""会员消费金额>=200时，8折 >=100时，9折 非会员>=200时，9.5折""" answer=input('您是会员吗？y/n') money=float(input('请输入您的购物金额')) #外层判断是否为会员 if answer=='y' :#表示为会员 if money>=200: print('八折，付款金额为',money*0.8) elif money>=100: print('九折，付款金额为',money*0.9) else: print('不打折，付款金额为',money) else: if money>=200: print('95折，付款金额为',money*0.95) else: print('不打折，付款金额为',money)

（5）条件表达式

条件表达式是if else的简写

语法结构：

x if 判断条件 else y

运算规则

如果判断条件的布尔值为Ture,条件表达式的返回值为x,否则条件表达式的返回值为y

#从键盘录入两个整数，比较两个整数的大小 num_a=int(input('请输入整数a')) num_b=int(input('请输入整数b')) #比较大小 """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)))

（6）PASS语句

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

用法：先搭建语法结构，还没想好代码怎么写的时候

那些语句一起使用：

• if语句的条件执行体
• for-in语句的循环体
• 定义函数时的函数体

第五章.

1.内置函数range（）

概念：用于生成一个整数序列

创建range对象的三种方式：

返回值是一个迭代器对象

range类型的优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start,stop和step,只有当用到range.对象时，才会去计算序列中的相关元素。

in与not in判断整数序列中是否存在（不存在）指定的整数

"""1.只有一个参数(小括号中只给了一个数)""" r=range(10) #[0,1,2,3,4,5,6,7,8,9]，10代表到10结束，未定义从几开始，默认为0开始，两个数相差1（步长） print(r) #range(0,10) print(list(r)) #用于查看range对象中的整数序列 ---list意为列表 """2.有两个参数，表示开始和结束""" r1=range(2,10) print(list(r1))#[2, 3, 4, 5, 6, 7, 8, 9],2代表开始，10代表结束，步长为默认1 """3.有三个参数，表示开始和结束和步长""" r2=range(1,10,3) print(list(r2)) #[1, 4, 7],从一开始，到10结束，步长为3 """判定指定的整数是否在序列之中""" print(10 in r) print(10 not in r)

2.循环结构

1.概念：

反复做同一件事的情况，称为循环

循环结构流程图：

语法结构：

while 条件表达式：

条件执行体（循环体）

选择结构的if与循环结构while的区别

if是判断一次，条件为ture执行1次

while是判断n+1次，条件为ture执行n次

2.while循环的执行流程：

四步循环法：

• 初始化变量
• 条件判断
• 条件执行体（循环体）
• 改变变量

while循环的执行流程：

#计算0-4之间的累加和 """四步循环法 1.初始化变量 2.条件判断 3.条件执行体 4.改变变量 总结：初始化的变量与条件判断的变量与改变的变量为同一个""" """初始化变量""" sum=0 a=0 """条件判断""" while a<5: """条件执行体（循环体）""" sum+=a a+=1 print(sum) 练习题： #计算0-100之间的偶数和 sum=0 a=0 """条件判断""" while a<101: #"""条件执行体（求和）""" #判断是否为偶数 #if a%2==0: #sum+=a if not bool(a%2): #if not bool表示当布尔值为F时执行 sum+=a #改变变量 a+=1 print(sum)

3.for-in循环

概念：

• in表达从（字符串、序列等）中依次取值，又称遍历
• for-in遍历的对象必须是可迭代对象

for-in的语法结构

for 自定义的变量in可迭代对象：

循环体

for-in的执行图

循环体内不需要访问自定义变量，可以将自定义变量替代为下划线。

#for in循环 for kk in '你在干什么':#从字符串遍历给kk print(kk) for ww in range(15):#从range序列遍历给ww print(ww) #若循环体不需要自定义变量，可用_代替 for _ in range(5): print('hello') print('使用for循环，计算1-100之间的偶数和') sum=0 for oo in range(1,101): if oo%2==0: sum+=oo print(sum)

4.流程控制语句break

概念：用于结束循环结构，通常与分支结构if一起使用。

"""从键盘录入密码，最多三次，正确就结束循环""" 方法1：for循环 for _ in range(3): pwd=input('请输入密码') if pwd=='888': print('登录成功') break else: print('密码错误，登陆失败') """从键盘录入密码，最多三次，正确就结束循环""" 方法2：while循环 a=0 while a<3: pwd=input('请输入密码') if pwd=='888': print('登录成功') break else: print('密码错误') a+=1

4.流程控制语句continue

概念：用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用。

"""要求输入1到50之间所有5的倍数， 要求使用continue实现""" for item in range(1,51): if item%5==0: print(item) #使用continue for ite in range(1,51): if ite%5!=0: continue print(ite)

5.else语句

#else与for的搭配使用 for _ in range(3): pwd=input('请输入密码') if pwd==('888'): print('登录成功') break else: print('密码错误') else: print('密码输入机会用尽') #else与while的搭配使用 a=0 while a<3: pwd = input('请输入密码') if pwd=='888': print('登录成功') break else: print('密码错误') a+=1 else: print('登录失败，机会用尽')

6.嵌套循环

概念：循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行。

#"输出一个三行四列的矩形" for h in range(3): #行数，0,1,2共三次 for l in range(4): #列数，共四次 print('*',end='\t') #\t表示不换行输出 print() #换行后下一轮输出 #"输出九九乘法表" for h in range(1,10): for l in range(1,h+1): print(h,'*',l,'=',h*l,end='\t') print() #换行后下一轮输出

6.二重循环中的break和continue

for h in range(1,5): for i in range(1,11): if i%2==0: continue #break print(i,end='\t') print() #二重循环中的break和continue用于控制本层循环

第六章.

1.列表的创建与删除

1）列表

为什么需要列表：

• 变量可以存储一个元素，而列表是一个“大容器”可以存储N多元素，程序可以方便地对这些数据进行整体操作
• 列表相当于其它语言中的数组
• 列表示意图

2）列表的创建

列表需要使用中括号，元素之间使用英文的逗号进行分隔

列表的创建方式

1. 使用中括号
2. 调用内置数Iist()

3）列表的特点

• 列表元素按顺序有序排序

lis=['hello','world',998] lis1=list(['hello','world',998]) print(lis[0],lis1[1],lis[-3])#有正序和逆序两种索引 hello world hello

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

2.列表的查询操作

概念：获取列表中指定元素的索引。

#列表中有两个hello，使用索引，只会返回元素中第一个元素的索引，所以返回为0 lis=['hello','world',998,'hello'] print(lis.index('hello')) print(lis.(9989)) #查询的元素不存在，返回ValueError print(lis.index('hello',1,3)) #指定索引的start和stop 0 ValueError: 9989 is not in list 3

1)获取列表中的单个元素：

正向索引2为998，逆向索引-4也是998 lis=['hello','world',998,'hello',"whatthis","manbaout"] print(lis[2]) print(lis[-4]) print(lis[10]) #列表中没有10，所以报错超出范围 998 998 IndexError: list index out of range

2)获取列表中多个元素

语法格式：

列表名[start:stop:step]

lis=[10,20,30,40,50,60,70,80] #start=1,stop=6,step=1 print(id(lis)) print(lis[1:6:1]) print(lis[1:6])#结果一致，默认步长为1 lis2=lis[1:6:1] print(id(lis2)) #切片后的id不等于原id，说明切片创建了新的列表 print(lis2) #语法也可写为 print(lis[:1:1]) #start为空，默认值为0 print(lis[1::1]) #stop为空，默认为列表结尾 print(lis[1:1:]) #step为空，默认为1 #若步长step为负 （以负1为例） print(lis[::-1]) #输出结果为列表的逆序 2422968734080 [20, 30, 40, 50, 60] [20, 30, 40, 50, 60] 2422968735936 [20, 30, 40, 50, 60]

3)列表元素的查询操作

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

• 元素 in 列表名
• 元素 not in 列表名

lis=[10,20,30,40,50,60,70,80] print(10 in lis) print(100 in lis) print(100 not in lis) True False True

列表元素的遍历

• for 变量名 in 列表名

lis=[10,20,30,40,50,60,70,80] for kk in lis: print(kk) 10 20 30 40 50 60 70 80

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

1)列表元素的增加操作

lis=[10,20,30] print('添加前',lis,id(lis)) lis.append(100) #列表末尾添加一个元素 print('添加后',lis,id(lis)) #id未变化，说明还是原列表 lis2=['hello','world'] #lis.append(lis2) #将lis2作为一个元素添加到列表的末尾 lis.extend(lis2) #向列表末尾一次性添加多个元素 print(lis) lis.insert(1,'kkk') #在指定位置添加元素 print(lis) 添加前 [10, 20, 30] 2209642172800 添加后 [10, 20, 30, 100] 2209642172800 [10, 20, 30, ['hello', 'world']]#append [10, 20, 30, 'hello', 'world'] #extend [10, 'kkk', 20, 30]

#切片 原本的元素会被切掉 lis3=[True,False,'hello'] lis[1:]=lis3 print(lis) [10, True, False, 'hello']

2)列表元素的删除操作

lis=[10,20,30,30,40,50,60,70] lis.remove(30) #从列表中删除一个元素，如果有重复的，只删除第一个 print(lis) #pop()根据索引移除元素 lis.pop(0) lis.pop() #如果不写参数，会自动删除列表中最后一个元素 print(lis) #切片删除，至少删除一个元素，会产生一个新的列表对象 new=lis[1:3] print('原列表',lis) print('新列表',new) #不产生新的列表，删除原列表内容 lis[1:3]=[] print(lis) #清除列表中的所有元素 lis.clear() print(lis) #del 直接删除列表 del lis print(lis)

3)列表元素的修改操作

（1）为指定索引的元素赋予一个新值

（2）为指定的切片赋予一个新值

lis=[10,20,30,30,40,50,60,70] #一次修改一个值 lis[2]=100 print(lis) #使用切片修改列表中的元素 lis[1:3]=[300,400,500,600] print(lis) [10, 20, 100, 30, 40, 50, 60, 70] [10, 300, 400, 500, 600, 30, 40, 50, 60, 70]

4.列表元素的排序

（1）sort方法

概念：调用sort（）方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=Ture，进行降序排序

lis=[10,30,50,80,70,12] print('排序前',lis) #sort函数使用后，在原列表基础上进行排序，不改变原列表id lis.sort() #默认是升序,FLASE 也是默认 lis.sort(reverse=True) #加了参数reverse 变为降序 print('排序后',lis) 排序前 [10, 30, 50, 80, 70, 12] 排序后 [80, 70, 50, 30, 12, 10]

（2）sorted方法

概念：调用内置函数sorted（），可以制定reverse=Ture，进行降序排序，原列表不发生改变。

lis=[10,30,50,80,70,12] print('原列表',lis) #sorted new=sorted(lis) print(lis,id(lis)) print(new,id(new)) jx=sorted(lis,reverse=True) print(jx,id(jx)) 原列表 [10, 30, 50, 80, 70, 12] [10, 30, 50, 80, 70, 12] 1667588149632 [10, 12, 30, 50, 70, 80] 1667588469952 [80, 70, 50, 30, 12, 10] 2246924805504

5.列表推导式（生成式）

生成列表的公式：

语法结构：

[i*i for i in range(1,10)]

i*i表示列表元素的表达式

i表示自定义变量

range 表示可迭代对象

注意：“表示列表元素的表达式”中通常包含自定义变量

lis=[i*i for i in range(1,10)] print(lis) """要求列表中的元素为2,4,6,8,10""" lis2=[i*2 for i in range(1,6)] print(lis2) [1, 4, 9, 16, 25, 36, 49, 64, 81] [2, 4, 6, 8, 10]

第七章.

1.什么是字典

• python内置的数据结构之一、与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列

字典示意图：

2.字典的原理

字典的实现原理：

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

3.字典的创建与删除

1）字典的创建

最常用的方式：使用花括号

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

使用内置函数

scores=dict（name='jack',age=20）

#'方式一' soc={'张三':100,'李四':98,'王五':45} print(soc) #'方式二' soc2=dict(name='张三',age=18) print(soc2) #'创建空字典' d={} print(d) {'张三': 100, '李四': 98, '王五': 45} {'name': '张三', 'age': 18} {}

4.字典的查询操作

字典的常用操作

字典中元素的获取

[]取值与使用get（）取值的区别

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

soc={'张三':100,'李四':98,'王五':45} #方式一，使用[] print(soc['张三']) print(soc['乘']) #若字典中不存在，用这种方式会报错 #方式二，使用get() print(soc.get('张三')) #print(soc.get('乘')) #若字典中不存在，这种方式为提示NOne print(soc.get('乘',99)) #也可通过设置参数，提示设置好的参数 KeyError: '乘' #方法一报错 100 100 None #方法二提示None 99

5.字典元素的增、删、改、查

1）key的判断

#判断元素是否存在字典之中 soc={'张三':100,'李四':98,'王五':45} print('张三'in soc) print('张三'not in soc)

2）字典元素的删除

soc={'张三':100,'李四':98,'王五':45} del soc['张三'] #删除指定键值对 soc.clear() #清空字典的所有元素 print(soc) soc['陈8']=66 #新增元素 soc['陈8']=100 #修改值

3）字典视图

soc={'张三':100,'李四':98,'王五':45} #获取key a=soc.keys() print(a,type(a)) print(list(a)) #将所有key组成的视图转成列表 #获取value b=soc.values() print(b,type(b)) print(list(b)) #将value转成列表 #获取k-v对 c=soc.items() print(c,type(c)) print(list(c)) # （元组） dict_keys(['张三', '李四', '王五']) <class 'dict_keys'> ['张三', '李四', '王五'] dict_values([100, 98, 45]) <class 'dict_values'> [100, 98, 45] dict_items([('张三', 100), ('李四', 98), ('王五', 45)]) <class 'dict_items'> [('张三', 100), ('李四', 98), ('王五', 45)]

4）字典遍历

soc={'张三':100,'李四':98,'王五':45} for i in soc: print(i,soc[i],soc.get(i)) #直接输出会输出key以及输出vlaue的两种方式 张三 100 100 李四 98 98 王五 45 45

5）字典的特点

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

d={'name':'张三','name':'李四'} #key相同会导致value覆盖 print(d) d1={'name':'张三','name1':'张三'} #value可重复 print(d1) {'name': '李四'} {'name': '张三', 'name1': '张三'}

6）字典生成式

内置函数zip（）

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

字典生成式

item=['fruite','book','other'] pricer=[96,88,74] d={item.upper():pricer for item,pricer in zip(item,pricer)} #upper 代表使用大写 print(d) {'FRUITE': 96, 'BOOK': 88, 'OTHER': 74}

第八章.

1.什么是元组

概念：元组是python内置的数据结构之一，是一个不可变序列

不可变序列与可变序列

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

lis=[10,20,35] """可变序列：列表、字典""" print(id(lis),lis) lis.append(300) print(id(lis),lis) """不可变序列：字符串、元组""" s='hello' print(s,id(s)) s=s+'world' print(s,id(s)) 3011124646272 [10, 20, 35] 3011124646272 [10, 20, 35, 300] hello 3011127115424 helloworld 3011127295856

2.元组的创建方式

• 直接小括号：t=('py','hello',90)
• 使用内置函数tuple():t=tuple(('py','hello',90))
• 只包含一个元组的元素需要使用逗号和小括号：t=（10,）

#创建元组方式1：直接使用()或省略括号 p=('hello',11,'world') print(p,type(p)) p2='hello',12,'world' print(p2,type(p2)) #这种方式如果只有一个元素，就会被识别为其他格式，所以需要再元组后加入, p3=11 print(p3,type(p3)) p4=11, print(p4,type(p4)) #创建元组方式2：内置函数tuple(()) p1=tuple(('v','me',50)) print(p1,type(p1)) #空元组创建方式 kongyuanzu=() kongyuanzu1=tuple() print(kongyuanzu,type(kongyuanzu),kongyuanzu1,type(kongyuanzu1)) ('hello', 11, 'world') <class 'tuple'> ('hello', 12, 'world') <class 'tuple'> 11 <class 'int'> (11,) <class 'tuple'> ('v', 'me', 50) <class 'tuple'> () <class 'tuple'> () <class 'tuple'>

为什么要将元组设计成不可变序列

• 在多任务环境下，同时操作对象时不需要加锁
• 因此，在程序中尽量使用不可变序列

注意：

• 元组中存储的是对象的引用

a）如果元组中对象本身不可对象，则不能再引用其他对象

b）如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

p=(10,[20,30],9) print(p,type(p)) print(p[0],type(p[0]),id(p[0])) print(p[1],type(p[1]),id(p[1])) print(p[2],type(p[2]),id(p[2])) #尝试将p1修改为100 #p[1]=100 print(p[1]) #提示失败 无法修改 #由于[20,30]是列表，列表为可变序列，所以可以向列中添加元素，而列表的内存地址不变 p[1].append(100) #向列表中添加元素，添加后内存地址id不会修改 print(p[1]) (10, [20, 30], 9) <class 'tuple'> 10 <class 'int'> 140704339020504 [20, 30] <class 'list'> 1207918973312 9 <class 'int'> 140704339020472 [20, 30] [20, 30, 100]

3.元组的遍历

元组是可迭代对象，所以可以使用for in 进行遍历

t=('python','world',98) #第一种获取元组元素的方式，使用索引 print(t[0],t[1],t[2]) #print(t[3]) #IndexError: tuple index out of range 未知有多少元素的情况下 就会报错 for tt in t: print(tt) python world 98 python world 98

4.什么是集合

概念：

• python语言提供的内置数据结构
• 与列表、字典一样都属于可变类型的序列
• 集合是没有value的字典

5.集合的创建

1）直接{}

s={'python','hello',90}

2）使用内置函数set()

#集合的创建方式1：{} s={2,3,4,5,6,7,7} #集合与字典类似，不能重复，若有重复，只会出现一次 print(s,type(s)) #集合的创建方式2：内置函数set() r=set(range(9)) print(r,type(r)) r1=set([1,2,3,4,5,6,7,8,9,10]) #列表转集合 print(r1,type(r1)) r2=set(('python','world')) #元组转集合 print(r2,type(r2)) r3=set({14,56,78,99,23}) #集合中的数是无序的 print(r3) #定义一个空集合 r4={} print(r4,type(r4)) #无法直接使用花括号定义集合，会被定义为字典形式 r5=set() print(r5,type(r5)) #这样才是空集合 {2, 3, 4, 5, 6, 7} <class 'set'> {0, 1, 2, 3, 4, 5, 6, 7, 8} <class 'set'> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} <class 'set'> {'python', 'world'} <class 'set'> {99, 23, 14, 56, 78} {} <class 'dict'> set() <class 'set'>

6.集合的增、删、改、查

1）集合元素的判断

in或not in

s={10,12,14,22,56,77,89} #判断操作 print(10 in s) #T print(11 in s) #F print(11 not in s) #T

2）集合元素的新增操作

• 调用add()方法，一次添加一个元素
• 调用update()方法至少添加一个元素

#新增操作 s.add('kk') #添加一个元素用add print(s) s.update({200,400,300}) #添加至少一个元素/元组/集合/列表用update print(s) s.update([11,17,89]) print(s) s.update(('zaiganma')) print(s) {22, 56, 89, 10, 'kk', 12, 77, 14} {200, 10, 12, 77, 14, 300, 400, 22, 56, 89, 'kk'} {200, 10, 11, 12, 77, 14, 300, 400, 17, 22, 56, 89, 'kk'} {10, 11, 12, 14, 400, 17, 22, 'z', 'a', 'm', 300, 'g', 56, 'i', 200, 77, 89, 'n', 'kk'}

3）集合元素的删除操作

• 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在，报错KeyError
• 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不报错
• 调用pop（）方法，一次删除一个任意元素
• 调用clear（）方法，清空集合

s={10,12,14,22,56,77,89} #删除操作 s.remove(89) print(s) #s.remove(5000) #若不存在 无法删除并报错 print(s) #discard s.discard(123123) #若有就删 若没有也无所谓 print(s) s.discard(22) print(s) #pop s.pop() #随机删除一个元素 print(s) s.clear() #清空全部元素 print(s) {22, 56, 10, 12, 77, 14} {22, 56, 10, 12, 77, 14} {22, 56, 10, 12, 77, 14} {56, 10, 12, 77, 14} {10, 12, 77, 14} set()

7.集合生成式

1)集合之间的关系：

两个集合是否相等：

• 可以使用运算符==或！=进行判断

一个集合是否是另一个集合的子集

• 可以调用方法is sub set进行判断
• B是A的子集

一个集合是否是另一个集合的超集

• 可以使用方法issuperset进行判断
• A是B的超集

两个集合是否没有交集

• 可以应用isdisjoint进行判断

s={10,20,30,40} s1={20,10,40,30} #判断集合是否相等 print(s==s1) #T print(s!=s1) #F #判断子集 a={10,20,30,40,50,60} b={10,20,30,40} c={10,20,90} print(b.issubset(a)) #T print(c.issubset(a)) #F #判断超集 print(a.issuperset(b)) #T print(a.issuperset(c)) #F #判断交集 print(b.isdisjoint(c)) #F print(b.isdisjoint(a)) #F print(a.issuperset(b)) #T

2)集合的数学操作

#集合的数学操作 #1）交集 s1={10,20,30,40} s2={20,30,40,50,60} print(s1.intersection(s2)) print(s1 & s2) #&等价于intersection 求交集 #2）并集 print(s1.union(s2)) print(s1|s2) #|符号等于.union 求并集 #3）差集 print(s1.difference(s2)) print(s2.difference(s1)) print(s1-s2) #符号-等于.difference 求差集 #4)对称差集，意思就是去掉双方相同的，留下双方不同的 print(s1.symmetric_difference(s2)) print(s1^s2) #符号^等同于函数symm {40, 20, 30} {40, 20, 30} {40, 10, 50, 20, 60, 30} {40, 10, 50, 20, 60, 30} {10} {50, 60} {10} {50, 10, 60} {50, 10, 60}

3）集合生成式

{i*i for i in range（1,10）}

• 类似于列表生成式
• 元组无生成式

k=[i*i for i in range(10)] print(k) #集合生成式 k1={i*i for i in range(10)} print(k1) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

六、七、八章数据结构总结

第九章

1.字符串的驻留机制

1）概念

字符串是python中基本数据类型，是一个不可变的字符序列

2）驻留机制

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

a='python' b="python" c='''python''' d="""python""" print(a,b,c,d) print(id(a),id(b),id(c),id(d)) #地址相同 python python python python 2766699740208 2766699740208 2766699740208 2766699740208

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

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

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

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

6）驻留机制的优缺点

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

2.字符串的常用操作

1）字符串的检索

更建议用find或rfind 因为不会报错

s=('hello,hello') print(s.index('lo'))#3 print(s.find('lo'))#3 print(s.rindex('lo'))#9 加r代表搜索该字符最后一次出现的位置 print(s.rfind('lo'))#9 #print(s.index('k')) #若被查的字符不存在，index会报错，但find会返回-1 print(s.find('k')) 3 3 9 9 -1

2）字符串的大小写转换

s=('hello,python') k=s.upper() #将大写的s赋值给k，s本身不变 a=s.lower() print(k,id(k)) print(s,id(s)) print(a,id(a)) #即使s本身都为小写，使用lower转变小写之后，仍然会创建一个新的内存地址 s1=('Hello,Python') k1=s1.swapcase() #原字符的大小写互换 print(k1) s2=('hello,python') k2=s2.title() #每个单词的首字母大写 print(k2) s3=('hello,python') #字符串首字母大写 k3=s3.capitalize() print(k3) HELLO,PYTHON 2607885139888 hello,python 2607884804912 hello,python 2607885139824 hELLO,pYTHON Hello,Python Hello,python

3）字符串内容对齐操作

s='hello,python' print(s.center(30,'*')) #居中对齐 print(s.ljust(30,'!')) #左对齐 print(s.rjust(30,"@")) #右对齐 print(s.zfill(15)) #右对齐，自动用0填充 *********hello,python********* hello,python!!!!!!!!!!!!!!!!!! @@@@@@@@@@@@@@@@@@hello,python 000hello,python

4）字符串劈分操作的方法

s='hello hi iam fine thank and u' ls=s.split() #默认分隔符为空格，会将空格转为， print(ls) s1='hello|world|hi|ok' print(s1.split(sep='|')) #使用sep参数自主调整分隔符，将设定的分隔符转为, print(s1.split(sep='|',maxsplit=1)) #将第一个设定的|作为一段，剩下的作为一段 #从右侧劈分 print(s.rsplit()) print(s1.rsplit(sep='|',maxsplit=1)) ['hello', 'hi', 'iam', 'fine', 'thank', 'and', 'u'] ['hello', 'world', 'hi', 'ok'] ['hello', 'world|hi|ok'] ['hello', 'hi', 'iam', 'fine', 'thank', 'and', 'u'] ['hello|world|hi', 'ok']

5）字符串的判断

1.合法标识符：

数字、字母、下划线、汉字

#判断字符串是否为合法的标识符 s='hello,python' print(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,'1231231'.isdecimal()) #判断是否由十进制数组成 print(9,'12123p'.isdecimal()) print(10,'123'.isnumeric()) print(11,'123四'.isnumeric()) #判断是否由数字组成，大小写，罗马数字等 print(12,'abc1'.isalnum()) #判断是否由数字和字母组成 False 2 True 3 True 4 True 5 True 6 True 7 False 8 True 9 False 10 True 11 True 12 True

6）字符串的其他操作

s='hello,python,python,python' #print(s.replace('pytho','javakkk')) print(s.replace('python','java',2)) #原字符，新字符，替换次数 lis=['heelo','world'] print(''.join(lis)) #用空将列表连接成字符串 print('a'.join(lis))#用指定字符将列表连接成字符串 lis=['heelo','world'] print(''.join(lis)) #用空将列表连接成字符串 print('a'.join(lis))#用指定字符将列表连接成字符串 lis1=('hello','hi','ok') #将元组连接为字符串 print(''.join(lis1)) print('*'.join(lis1)) print('|'.join('hello')) #将字符串用指定符号连接 heeloworld heeloaworld hellohiok hello*hi*ok h|e|l|l|o

7）字符串的比较

运算符：>,>=,

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

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

print('apple'>'app') #Ture print('apple'>'banana') # False print(ord('a'),ord('b')) print(chr(97),chr(98)) #ord与chr相对应，类似于编码，比较实际就是比ord值 #==与is区别：==比的是value，is比的是id a=b='py' c='py' print(a==b) print(a is b) print(a==c) print(a is c) print(id(a),id(b),id(c)) True False 97 98 a b True True True True 140712392190984 140712392190984 140712392190984

4.字符串的切片操作

字符串是不可变类型：

• 不具备增删改等操作
• 切片将创建新的对象

s='hello,python' s1=s[:5] #默认起始位置为0 print(s1) s2=s[6:] #默认结束位置为字符串结尾 print(s2) s3='!' new=s1+s3+s2 print(new) print(id(s)) print(id(s1)) print(id(s2)) print(id(s3)) print(id(new)) #每个ID都不一样 print(new[1:10:2]) #start:stop:step hello python hello!python 3125103043376 3125103351712 3125103351760 140713650173144 3125103377072 el!yh

5.格式化字符串

1）字符格式化的用途：

2）格式化字符串的方式

• %作占位符

• {}做占位符

#格式化字符串 #方法一：%作占位符 name='张三' age=(20) print('我叫%s，今年%d岁' % (name,age)) #方法二：{}作占位符 print('我叫{0},今年{1}岁'.format(name,age)) print(f'我叫{name}，今年{age}岁') 我叫张三，今年20岁 我叫张三,今年20岁 我叫张三，今年20岁

#%d表示占位一个整数 print('%d' % 99) print('%10d' % 99) #10d表示空十个宽度 #%f表示占位一个浮点数 print('%f' % 3.1415926) print('%.3f' % 3.1415926) #.n表示保留n位小数 print('%10.3f' % 3.1415926) #整数位表示宽度，小数位表示保留位数 #{}方式 print('{0}'.format(3.1415926)) print('{0:.3}'.format(3.1415926)) #:.3表示总长度为3 print('{0:.3f}'.format(3.1415926)) #:.nf，表示保留n位小数 print('{0:10.3f}'.format(3.1415926)) #整数位表示宽度 99 99 3.141593 3.142 3.142 3.1415926 3.14 3.142 3.142

6.字符串的编解码操作

1）字符串为什么需要编解码

2）编解码方式

• 编码：将字符串转为二进制数据
• 解码：将二进制转为字符串

s='天涯共此时' #编码 print(s.encode(encoding='GBK'))#GBK格式一个中文占两个字节 print(s.encode(encoding='UTF-8'))#UTF-8格式一个中文占三个字节 #解码 #byte表示一个二进制数据/字节类型的数据 byte=s.encode(encoding='GBK') #编码 print(byte.decode(encoding='GBK')) #解码 byte=s.encode(encoding='UTF-8') #编码 print(byte.decode(encoding='UTF-8')) #解码 b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1' b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6' 天涯共此时 天涯共此时

第十章

1.函数的创建和调用

1）什么是函数

函数式执行特定任务以完成特定功能的一段代码

2）为什么需要函数

• 复用代码
• 隐藏实现细节
• 提高可维护性
• 提高可读性便于调试

3）函数的创建

#函数的创建 def calc(a,b): c=a+b return c #函数的调用（{实际参数}） return=calc(10,20) print(result) def calc(a,b): c = a + b return c re=calc(10,20) print(re) 30

2.函数的参数传递

1）位置实参

根据形参对应的位置进行实参传递

2）关键字实参

根据形参名称进行实参传递

def calc(a,b): #a,b称为形式参数，简称形参，形参的位置在函数的定义处 c = a + b return c #依据位置传输参数，a在前，b在后 re=calc(10,20) #10,20称为实参，实参的位置是函数的调用处 print(re) #依据名称传递参数，a=20，b=10 res=calc(b=10,a=20) print(res)

3）函数调用的参数传递内存分析图

def fun(arg1,arg2): arg1=100 arg2.append(10) print('arg1=',arg1) print('arg2=',arg2) n1=11 n2=[20,30,40] fun(n1,n2) print(n1) print(n2) """在函数调用过程中，进行参数的传递 如果是不可变对象，在函数体的修改不会影响实参的值：arg1修改为100，不影响n1的值 如果是可变对象，在函数体的修改会影响实参的值：arg2列表中增加了10，n2也增加了""" arg1= 100 arg2= [20, 30, 40, 10] 11 [20, 30, 40, 10]

3.函数的返回值

def fun(num): odd=[] #存奇数 even=[]#存偶数 for i in num: if i%2: odd.append(i) else: even.append(i) return odd,even lis=[10,29,34,23,44,53,55] print(fun(lis)) """函数的返回值 1）若函数无返回值（函数执行完成后，不需要给调用处提供数据）,可以省略 2）若函数的返回值，如果为1个，直接返回相应类型 3）若函数返回值，如果为多个，返回的结果为元组""" #1） def fun1(): print('hello') return '123' print(fun1()) #2) def fun2(): return 'hello' ress=fun2() print(ress) #3) def fun3(): return 'hello','world' print(fun3()) """函数在定义时，是否需要返回值，需视情况而定""" ([29, 23, 53, 55], [10, 34, 44]) hello 123 hello ('hello', 'world')

4.函数的参数定义

1）函数定义默认值参数

函数定义时，给形参设置默认值，只有与默认值不符时才需调用实参

def fun(a,b=10): #b称为默认值参数 print(a,b) fun(100) #若仅给a赋值，b未收到赋值，就输出默认参数 fun(20,30) #a与b都收到赋值的情况下，则输出实参 #print的默认值 print('hello',end='\t') #def print(self, *args, sep=' ', end='\n', file=None) #end默认值为'\n'作用是换行，但将end定义为\t之后，实际参数为空格，实际输出就不会换行 print('world') 100 10 20 30 hello world

2）个数可变的位置参数

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

def fun(*args): #函数定义时的可变的位置参数 print(args) fun(10) fun(20,30) fun(10,20,30,40) (10,) (20, 30) (10, 20, 30, 40)

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

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

def fun1(**args): #个数可变的关键字形参，输出结果为字典 print(args) fun1(a=10) fun1(b=11,c=12,d=13) #def fun2(*args,*a) #可变位置参数只能定义一个 #def fun2(**args,**qwer) #个数可变的关键字参数，只能定义一个 #def fun2(*args,**kwargs): #不报错 # pass #def fun3(**kwargs,*args) #报错 #在一个函数定义的过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求位置形参放在关键字形参之前，否则报错

4）函数总结

def fun(a,b,c): print('a=',a) print('b=',b) print('c=',c) fun(10,20,30) #函数调用时的参数传递，称为位置传参 lis=[11,22,33] fun(*lis) #函数调用时，将列表中的每个元素都转换为位置实参传入，没有*就会报错，将整个列表看做一个对象 print('-----------------------') fun(a=100,c=300,b=200) #函数调用为关键字传参 dic={'a':100,'b':200,'c':300} fun(**dic) #函数调用时，将字典中的键值对都转换为关键字实参，没有**就会报错 a= 10 b= 20 c= 30 a= 11 b= 22 c= 33 ----------------------- a= 100 b= 200 c= 300 a= 100 b= 200 c= 300

def fun(a,b,*,c,d): #这个*代表*之后的参数必须使用关键字形式传参，否则报错 print(a,b,c,d) def fun1(*,a,b,c,d): print(a,b,c,d) fun1(a=1,b=2,c=3,d=4) fun(1,2,c=2,d=9) print('----------函数定义时形参的顺序问题-----') def fun3(a,b,*,c,d,**args): pass def fun4(*args,**args2): pass def fun5(a,b=10,*args,**args2): pass #以上情形均可使用 1 2 3 4 1 2 2 9

5.变量的作用域

1）变量的作用域

• 程序代码能访问该变量的区域
• 根据变量的有效范围可分为

局部变量：在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会变成全局变量

全局变量：函数体外定义的变量，可作用于函数内外

def fun(a,b): c=a+b #c就称为局部变量，因为c是在函数体内定义的变量 print(c) #print(c) #报错，因为c超出了起作用的范围（作用域） name='杨老' #name作用范围为全局都可以使用，称为全局变量 def fun2(): print(name) #可以直接调用全局变量 fun2() def fun3(): global age age=20 #若仅在函数体内定义的变量，无法直接使用，但可以使用global函数改变为全局变量 print(age) fun3() print(age) 杨老 20 20

6.递归函数

1）什么是递归函数

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

使用递归计算阶乘：

2）递归的组成部分

递归调用与递归终止条件

3）递归的调用过程

每递归调用一次函数，都会在栈内存分配一个栈帧

每执行完一次函数，都会释放相应的空间

4）递归的优缺点

缺点：占用内存多，效率低

优点：思路和代码简单

#斐波那契数列 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)) 8 1 1 2 3 5 8

第十一章

1.Bug的由来及分类

1）Bug的由来

世界上第一部万用计算机的进化版 马克2号（MarkⅡ）

2）Bug的常见类型

• 粗心导致的语法错误SyntaError

age=input('请输入你的年龄')

if age>=18

print('成年人，做事需要负法律责任了')

解决方案

age=input(('请输入你的年龄')) if int(age)>=18: print('成年人，需负法律责任')

while i

print(i)

解决方式：

i=8 while i<10: print(i) i+=1

for i in range(3): user=input('请输入用户名') pwd=input('请输入密码') if user=='admin' and pwd=='admin': print('登录成功') break else: print('密码错误') else: print('登录失败，三次机会已用尽')

粗心导致错误的自查宝典

1.漏了末尾的冒号，如if语句、循环语句、else子句等

2.缩进错误，该缩进的没缩进，不该缩进的瞎缩进

3.误把英文符号写成中文符号

4.字符串拼接的时候，误把字符串和数字拼在一起

5.没有定义变量，比如说while的循环条件的变量

6.“==”比较运算符和“=”赋值运算符的混用

• 知识不熟练导致的错误

（1）索引越界问题 IndexError

lst=[11,22,33,44]

print(lst[4])

(2)append()方法使用不熟练

lst=[]

lst=append('a','b','c')

print(lst)

解决方法：

lis=[] #lis.append(['a','b','c','d']) #或 lis.append('a') lis.append('b') lis.append('c') print(lis)

• 思路不清晰导致的问题解决方案

（1）使用print()函数

（2）使用“#”暂时注释部分代码

题目要求：豆瓣电影top250排名，使用列表存储电影信息，要求输入名字在屏幕上显示xxx出演了那部电影。

lis=({'rating':[9.7,50],'id':'1292052','type':['犯罪','剧情',],'title':'肖申克的救赎','actors':['蒂姆','摩根']}, {'rating':[9.6,50],'id':'1291546','type':['剧情','爱情','同性'],'title':'霸王别姬','actors':['张国荣','张丰毅','巩俐','葛优']}, {'rating':[9.6,50],'id':'1296141','type':['剧情','犯罪','悬疑'],'title':'控方证人','actors':['泰隆','马琳']}) name=input('请输入你要查询的演员') for i in lis: #遍历列表，i是许多字典 act_lis=i['actors'] for actor in act_lis: if name in actor: print(name,'出演了',i['title'])

• 用户误操作导致程序出现崩溃：

示例：输入两个整数并进行除法运算

try: a = int(input('请输入第一个整数')) b = int(input('请输入第二个整数')) result = a / b print('结果是', result) except ZeroDivisionError: print('除数不能为0') except ValueError: print('请输入整数')

2.异常处理机制

1）try except else结构

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

try: a = int(input('请输入第一个整数')) b = int(input('请输入第二个整数')) result = a / b except BaseException as e: print('出错了') print(e) else: print(result)

2）try except else finally结构

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

3）常见的异常类型

4）traceback模块

使用traceback模块打印异常信息

import traceback try: print('-----------') print(1/0) except: traceback.print_exc()

3.PyCharm的调试模式

1）断点

程序运行到此处，暂时挂起，停止执行。此时可以详细观察程序的运行情况，方便做出进一步判断

2）进入调试视图

（1）单机工具栏上的按钮

（2）右键单机编辑区：点击：debug'模块名‘

（3）快捷键：shift +f9

第十二章

1.两大编程思想

2.类和对象的创建

1）类

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

数据类型：

• 不同的数据类型属于不同的类
• 使用内置函数type查看数据类型

对象：

100/99/520都是int类下包含的相似的不同个例，这个个例专业术语称为实例或对象

2）类的创建

创建类的语法：

class Student: #类名一般由一个或多个单词组成，规范写法是首字母大写，其余小写 pass print(id(Student),type(Student),Student) 2685730062432 <class 'type'> <class '__main__.Student'>

3）类的组成

• 类属性

类中方法外的变量称为类属性，被该类的所有对象共享

• 实例方法（类方法）

使用@classmethod修饰的方法，使用类名直接访问的方法

• 静态方法

使用@classmethod修饰的方法，使用类名直接访问的方法

• 类方法

class Student:#类名一般由一个或多个单词组成，规范写法是首字母大写，其余小写 native_place='东北' #类属性 def __init__(self,name,age): self.name=name #self.name称为实体属性，进行了一个赋值操作 self.age=age def eat(self): #实例方法，类之外定义的成为函数，类之内的称为方法 print('吃饭') #静态方法 @staticmethod def method(): print('使用了static进行修饰，所以我是静态方法') #类方法 @classmethod def cm(cls): print('使用class进行修饰，是类方法')

4）对象的创建

对象的创建又称类的实例化

语法：

实例名=类名（）

class Student:#类名一般由一个或多个单词组成，规范写法是首字母大写，其余小写 native_place='东北' #类属性 def __init__(self,name,age): self.name=name #self.name称为实体属性，进行了一个赋值操作 self.age=age def eat(self): #实例方法，类之外定义的成为函数，类之内的称为方法 print('吃饭') #静态方法 @staticmethod def method(): print('使用了static进行修饰，所以我是静态方法') #类方法 @classmethod def cm(cls): print('使用class进行修饰，是类方法') stu1=Student('张三',20) stu1.eat() print(stu1.name) print(stu1.age) print('----------') Student.eat(stu1) #24行和19行功能相同

类方法的使用方式：

class Student:#类名一般由一个或多个单词组成，规范写法是首字母大写，其余小写 native_place='东北' #类属性 def __init__(self,name,age): self.name=name #self.name称为实体属性，进行了一个赋值操作 self.age=age def eat(self): #实例方法，类之外定义的成为函数，类之内的称为方法 print('吃饭') #静态方法 @staticmethod def method(): print('使用了static进行修饰，所以我是静态方法') #类方法 @classmethod def cm(cls): print('使用class进行修饰，是类方法') #类属性的使用方式 print(Student.native_place) stu1=Student('张三',20) stu2=Student('李四',18) print(stu1.native_place) print(stu2.native_place) Student.native_place='日本' print(stu1.native_place) print(stu2.native_place) Student.cm() Student.method() #实例方法默认参数是self，类方法默认参数是cls，静态方法无默认参数

5）动态绑定属性和方法

python是动态语言，在创建对象之后，可以动态的绑定属性和方法

class Student: def __init__(self,name,age): Student.name=name Student.age=age def eat(self): print(self.name+'在吃饭') stu1=Student('张三',20) stu2=Student('李四',30) print('------为实例动态绑定性别属性-------') stu2.gender='男' print(stu1.name,stu1.age) print(stu2.name,stu2.age,stu2.gender) def show(): print('定义在类之外的称为函数') stu1.show=show() stu1.show

第十三章

1.面向对象的三大特征：

1）封装：

提高程序的安全性

将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。

在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“_”

#在类对象中封装完成后，由实例对象调用 class Car: def __init__(self,brand): self.brand=brand def start(self): print('汽车已启动') car=Car("BMW-X5") print(car.brand) car.start() #如果类对象中的属性不希望被外部调用，使用__

2)继承：提高代码的复用性

语法格式：

如果一个类没有继承任何类，则默认继承object

python支持多继承

定义子类时，必须在其构造函数中调用父类的构造函数

class Person(object): #person继承了object类 def __init__(self,name,age): self.name=name self.age=age def info(self): print('姓名:{0},年龄{1}'.format(self.name,self.age)) #定义子类 class Student(Person): def __init__(self,name,age,stu_nu): super().__init__(name,age) #将父类的name和age进行传入 self.stu_nu=stu_nu class Teach(Person): def __init__(self,name,age,tea_nu): super().__init__(name,age) self.tea_nu=tea_nu stu=Student('jack',20,'1001') tea=Teach('李四',40,'1003') stu.info() tea.info()

3)方法重写

如果子类对继承父类的某个属性或方法不满意，可以在子类中对其(方法体)进行重新编写

子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

class Person(object): #person继承了object类 def __init__(self,name,age): self.name=name self.age=age def info(self): print('姓名:{0},年龄{1}'.format(self.name,self.age)) #定义子类 class Student(Person): def __init__(self,name,age,stu_nu): super().__init__(name,age) #将父类的name和age进行传入 self.stu_nu=stu_nu def info(self): #重写父类的info方法 super().info() #重新调用 print(self.stu_nu) #添加新的方法 class Teach(Person): def __init__(self,name,age,tea_nu): super().__init__(name,age) self.tea_nu=tea_nu def info(self): super().info() print(self.tea_nu) stu=Student('jack',20,'1001') tea=Teach('李四',40,'1003') stu.info() tea.info()

2.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): #当重写了str方法后，直接输出实例，会改变为预设的值 return '我叫{0},今年{1}岁'.format(self.name,self.age) stu=Student('张三',20) print(dir(stu)) print(stu) #直接输入就会默认调用str方法

3.多态

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

class Animal(): def eat(self): print('动物会吃') class Cat(Animal): def eat(self): print('猫吃鱼') class Dog(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())

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

静态语言实现多态的三个必要条件

• 继承
• 方法重写
• 父类引用指向子类对象

动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子、游泳起来也像鸭子，收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

4.特殊方法和特殊属性

1）特殊方法

class A(): pass class B(): pass class C(A,B): def __init__(self,name,age): self.name=name self.age=age x=C('jack',33) print(x.__dict__) #查看实例对象的属性字典 print(C.__dict__) print('------------------') print(x.__class__) #查看实例对象所属的类 print(C.__bases__) #查看类的全部父类 print(C.__base__) #查看类的第一个父类 print(C.__mro__) #查看类的层次结构 print(A.__subclasses__())#查看类的子类

2）特殊属性

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=('张三') stu2=('李四') s=stu1+stu2 print(s) #add函数实现了两个对象的加法运算（特殊的操作） s=stu1.__add__(stu2) print(s) print('-----------') lis=[11,22,33,44] print(len(lis)) #内置函数len可以计算出列表的长度 print(lis.__len__()) print(len(stu1)) 张三李四 张三李四 ----------- 4 4 2

3）__new__和__init方法

5.类的浅拷贝与深拷贝

1）变量的赋值操作

只是形成两个变量，实际上还是指向同一个对象

2）浅拷贝

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

3）深拷贝

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

class Cpu: pass class Disk: pass class Computer: def __init__(self,cpu,disk): self.cpu=cpu self.disk=disk cpu1=Cpu() cpu2=cpu1 print(cpu1,id(cpu1)) print(cpu2,id(cpu2)) #内存地址相同，不同的变量指向同一个实例 <__main__.Cpu object at 0x0000025B7259D910> 2591783770384 <__main__.Cpu object at 0x0000025B7259D910> 2591783770384 #类的浅拷贝 #只会拷贝源对象computer，指向的cpu与disk对象不进行拷贝，还是指向原对象 print('------------') disk=Disk()#创建一个硬盘类对象 computer=Computer(cpu1,disk) import copy computer2=copy.copy(computer) print(computer,computer.cpu,computer.disk) print(computer2,computer2.cpu,computer2.disk) #类的深拷贝

第十四章

1.什么叫模块（Modules）

1）函数与模块的关系

一个模块中可以包含多个函数

2）在python中一个扩展名为.py的文件就是一个模块

3）使用模块的好处

• 方便其他程序和脚本导入并使用
• 避免函数名和变量名冲突
• 提高代码的可维护性
• 提高代码的可重用性

2.自定义模块

1）创建模块

新建一个.py文件，名称尽量不要与python自带的标准模块名称相同

2）导入模块

import 模块名称 [as 别名] ---这种方式会导入模块中所有内容

from 模块名称 import 函数/变量/类 ---这种方式只会导入指定内容

#导入方法1：数学运算模块 import math print(math) print(id(math)) print(type(math)) print(math.pi) print('----------------') print(dir(math)) print(math.pow(2,3)) #次方运算 2的3次方 print(math.ceil(9.001)) #向上取整运算 print(math.floor(9.99999)) #向下取整 #仅导入math中的pi from math import pi print(pi)

自定义模块无法直接导入，需要将目录标记为测试源代码根目录

自定义模块 def add(a,b): return a+b def div(a,b): return a/b

调用自定义模块

import calc print(calc.add(10,50))

3.以主程序的形式执行

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

if _name_ ='_main_':

pass

def add(a,b): return a+b #当被引用的模块中有输出的数值时，引用者也会输出这些内容 #为了解决这个问题 #if __name_=='_main_' 输入方法为 main if __name__ == '__main__': print(add(10,20)) #这样 只有运行calc模块时，才会运行该步骤

4.python中的包

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

1）包的作用

代码规范

避免模块名称冲突

2）包与目录的区别

包含_init_.py文件的目录称为包

目录里通常不包含_init.py文件

3）包的导入

import 包名.模块名

使用import方式进行导入时，只能跟包名或模块名

使用from方式可以导入包、模块、函数、变量等

from pacp import modA

from pacp.modA import a

包的创建

#包的导入 import pacp.moduleA as ma #这种方法输入的内容太多可以使用as起个别名a #print(pacp.moduleA.a) print(ma.a)

5.python中常用的内置模块

import sys import time import urllib.request print(sys.getsizeof(23)) 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())

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

1）第三方模块的安装：

pip install 模块名

2）第三方模块的使用：

import 模块名

import schedule import time def job(): print('hhhhhh') schedule.every(3).seconds.do(job) while True: schedule.run_pending() time.sleep(1) #每隔三秒输出一次hhhh

第十五章

1.编码格式介绍

1）常见的字符编码格式

python的解释器使用的是Unicode（内存）

.py文件在磁盘上使用UTF-8存储（外存）

默认文件是utf-8编码

可以使用#conding=gbk转为asn1（GBK）

2.文件读写原理

文件的读写俗称"IO操作"

文件读写操作流程

3.文件读写操作

1）内置函数open（）创建文件对象

2）语法规则：

file=open(filename[,mode,encoding])

4.常用的文件打开模式

文件的类型

按文件中数据的组织形式，文件分为以下两类

文本文件

存储的是普通‘字符’文本，默认为unicode字符集，可以使用记事本程序打开

二进制文件：把数据内容用‘字节’进行存储，无法用记事本打开，必须使用专用的软件，比如说：音频mp3，图片jpj，文档doc等

1）r

file = open('a1.txt', 'r') #默认读的文件是gbk格式 print(file.readlines()) file.close()

2）w

file = open('b.txt', 'w') file.write('hello1313213') file.close() #w是创建文件，若有同名文件，会执行覆盖

3）a

file = open('b.txt', 'a') file.write('hello1313213') file.close() #a是添加文件，若不存在会创建，若已存在会在文件后追加

4）b

scr=open('b.txt',"rb") target=open('b.txt', 'wb') print(target.write(scr.read())) target.close() scr.close()

+）

5.文件对象的常用方法

#read() fi=open('a1.txt','r') print(fi.read(1)) #read()参数设置后，仅读取参数长度的内容 #readline file = open('a1.txt', 'r') print(file.readline()) #该参数设置后，仅读取文件中的一行内容 #readlines fi=open('a1.txt','r') print(fi.readlines()) fi.close() ['你好\n', '我号\n', '大家好\n'] #将文本中的每一行都做为独立的字符串，并在列表中返回 #write&writelines fi=open('a1.txt','a') fi.write('hello world') #将字符串写入文件 lis=['java','go','py'] fi.writelines(lis) #将列表写入文件 fi.close() #文件指针位置 file = open('a.txt') file.seek(2) #跳过两个字节开始读取，因为一个所以读出来是第二个汉字（一个汉字等于两个字节） print(file.read()) print(file.tell()) #tell是显示目前指针的位置，从0开始计算 file.close() #flush和close的区别 file = open('a.txt','a') file.write('Hello') file.flush()#写入文件后不关闭文件，可以继续对文件执行操作 file.write('world') file.close()#执行完成直接关闭

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

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

""" Conway实现了特殊方法__enter__(),__exit__()称为该类对象遵守了上下文管理协议 该类对象的示例对象，称为上下文管理器 Conway() =上下文管理器 """ class Conway: def __enter__(self): print('enter方法被执行了') return self def __exit__(self, type, value, traceback): print('exit方法被执行了') def show(self): print('show方法被执行了',1/0) with Conway() as file: #相当于file=Conway() file.show() #当代码运行异常时，仍然会自动执行退出结束语句

#案例，用with写一段复制文件的代码,不需要手动关闭 with open('logo.png','rb')as beifuizhiwenjian: with open('copyfile.png','wb')as fuzhi: fuzhi.write(beifuizhiwenjian.read())

7.目录操作

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

#os模块是与操作系统相关的模块 import os #os.system("notepad.exe") #相当于cmd执行 #os.system("calc.exe") #还可以直接调用可执行文件 os.startfile('C:\\wechat\\wechat.exe') #直接执行os中的文件\程序

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

import os #显示当前工作的目录 print(os.getcwd()) #返回指定路径下的文件和目录信息 lis=os.listdir('../pythonProject') print(lis) #创建目录(文件夹) #os.mkdir('new2') #创建多级目录,套娃创建目录 #os.makedirs('A/B/C') #删除目录 #os.rmdir('new2') #删除多级目录 #os.removedirs('A/B/C') #修改工作目录 #os.chdir('../pythonProject')

os.path模块操作目录相关函数

import os.path #获取文件或目录的绝对路径 print(os.path.abspath('Conway.py')) #用于判断文件是否存在，T存在F不存在 print(os.path.exists('Conway.py'),os.path.exists('qqwqeqwe')) #将目录或文件拼接起来 print(os.path.join('E:\\','a.txt')) #分离目录与文件 print(os.path.split('C:\\Users\\14036\\Desktop\\py\\pythonProject\\a.txt')) #分离文件和扩展名 print(os.path.splitext('C:\\Users\\14036\\Desktop\\py\\pythonProject\\a.txt')) #从一个目录中提取文件名 print(os.path.basename('C:\\Users\\14036\\Desktop\\py\\pythonProject\\a.txt')) #从一个路径中提取文件路径，不包括文件名 print(os.path.dirname('C:\\Users\\14036\\Desktop\\py\\pythonProject\\a.txt')) #判断是否为路径 print(os.path.isdir('C:\\Users\\14036\\Desktop\\py\\pythonProject\\a.txt'))

#案例1，列出指定目录下的所以.py文件 import os path=os.getcwd() #获取当前目录 lis=os.listdir(path)#获取目录中的所有文件 for i in lis: if i.endswith('.py'): print(i) #案例2，遍历目录下的所有文件 import os path=os.getcwd() lis=os.walk(path) #i=dirpath dirname filename for dirpath,diename,filename in lis: print(dirpath) print(diename) print(filename)

第十六章综合案例-学生信息管理系统

1.需求分析

2.系统设计

1）功能设计

• 系统功能结构
• 录入信息模块
• 查找信息模块
• 修改信息模块
• 成绩排名模块
• 统计人数模块
• 显示全部信息模块

2）业务流程

3.系统开发必备

1）系统开发环境

• 操作系统
• python解释器
• 开发工具
• python内置模块

2）项目目录结构

4.主函数设计

1）主函数设计

系统主界面运行效果图

def menm(): print('-----------------学生信息管理系统----------------------') print('-------------------功能菜单----------------------') print('\t\t\t\t\t\t1.录入学生信息') print('\t\t\t\t\t\t2.查找学生信息') print('\t\t\t\t\t\t3.删除学生信息') print('\t\t\t\t\t\t4.修改学生信息') print('\t\t\t\t\t\t5.排序') print('\t\t\t\t\t\t6.统计学生总数') print('\t\t\t\t\t\t7.显示全部信息') print('\t\t\t\t\t\t0.退出系统')

实现主函数

def main(): while True: menm() choice = int(input('请选择')) if choice in [0, 1, 2, 3, 4, 5, 6, 7]: if choice == 0: answer = input('确定退出？y/n') if answer == 'y' or answer == 'Y': print('谢谢使用') break else: continue elif 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()

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

录入功能的实现：

1）save(student)函数，用于将学生信息保存到文件

2）insert()函数，用于录入学生信息

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') 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()

删除功能的实现

从控制台录入学生ID，到磁盘中找到对应的学生信息，并将其删除

1）业务流程

2）具体实现

• 编写主函数调用的删除学生信息的函数delete()
• 调用show()函数显示学生信息

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_oid=file.readlines() else: student_oid=[] flag=False #标识是否删除 if student_oid: with open(filename,'w',encoding='utf-8') as wfile: d={} for item in student_oid: 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') if answer == 'y': continue else: break

修改学生信息功能

1）修改功能

从控制台录入学生ID，到磁盘文件中找到对应的学生信息，将其进行修改

• 编写主函数中调用的修改学生信息的函数modify
• 调用了show（）函数显示学生的信息

2）业务流程

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') 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('请输入姓名') d['english'] = input('请输入英语成绩') d['python'] = input('请输入python成绩') d['java'] = input('请输入java成绩') except: print('你的输入有误，请重新输入') else: break wfile.write(str(d)+'\n') print('修改成功') else: wfile.write(str(d)+'\n') answer=input('是否继续修改y/n') if answer == 'y': modify()

查询学生信息功能

1）功能实现

从控制台录入学生ID或姓名，到磁盘文件中找到对应的学生信息

2）业务流程

def search(): student_query=[] while True: id='' name='' if os.path.exists(filename): mode=input('按ID查找请按1，按姓名查找请按2') if mode=='1': id=input('请输入学生ID') elif mode=='2': name=input('请输入学生姓名') else: print('输入有误，请重新输入') 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() anser=input('是否继续查询y/n') if anser == 'y': continue else: break else: print('暂未保存学生信息') 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{:^10}\t{:^10}\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）代码实现

编写主函数中调用的统计学生总人数的函数total（）

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('暂未录入学生信息') else: print('暂未保存数据')

显示所有学生信息功能

1）功能实现

将学生信息文件中保存的所有学生信息获取并显示

2）业务流程

编写主函数中调用的查询学生信息函数show()

def show(): student_list=[] if os.path.exists(filename): with open(filename,'r',encoding='utf-8')as rfile: students=rfile.readlines() for item in students: student_list.append(eval(item)) if student_list: show_student(student_list) else: print('暂未保存数据')

排序模块设计

1）功能实现

主要对学生信息按成绩进行升序或降序进行排序

2）业务流程

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 student_list: d=dict(eval(item)) student_new.append(d) else: return asc_or_desc=input('请选择（0.升序 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('请选择排序方式（1.按英语排2.按python排3.按java成绩排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)

全部代码

#coding=gbk import os.path import os filename='student.txt' def main(): while True: menm() choice = int(input('请选择')) if choice in [0, 1, 2, 3, 4, 5, 6, 7]: if choice == 0: answer = input('确定退出？y/n') if answer == 'y' or answer == 'Y': print('谢谢使用') break else: continue elif 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 menm(): print('-----------------学生信息管理系统----------------------') print('-------------------功能菜单----------------------') print('\t\t\t\t\t\t1.录入学生信息') print('\t\t\t\t\t\t2.查找学生信息') print('\t\t\t\t\t\t3.删除学生信息') print('\t\t\t\t\t\t4.修改学生信息') print('\t\t\t\t\t\t5.排序') print('\t\t\t\t\t\t6.统计学生总数') print('\t\t\t\t\t\t7.显示全部信息') print('\t\t\t\t\t\t0.退出系统') 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') 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() def search(): student_query=[] while True: id='' name='' if os.path.exists(filename): mode=input('按ID查找请按1，按姓名查找请按2') if mode=='1': id=input('请输入学生ID') elif mode=='2': name=input('请输入学生姓名') else: print('输入有误，请重新输入') 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() anser=input('是否继续查询y/n') if anser == 'y': continue else: break else: print('暂未保存学生信息') 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{:^10}\t{:^10}\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')) 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_oid=file.readlines() else: student_oid=[] flag=False #标识是否删除 if student_oid: with open(filename,'w',encoding='utf-8') as wfile: d={} for item in student_oid: 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') if answer == 'y': continue else: break 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') 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('请输入姓名') d['english'] = input('请输入英语成绩') d['python'] = input('请输入python成绩') d['java'] = input('请输入java成绩') except: print('你的输入有误，请重新输入') else: break wfile.write(str(d)+'\n') print('修改成功') else: wfile.write(str(d)+'\n') answer=input('是否继续修改y/n') if answer == 'y': modify() 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 student_list: d=dict(eval(item)) student_new.append(d) else: return asc_or_desc=input('请选择（0.升序 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('请选择排序方式（1.按英语排2.按python排3.按java成绩排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) 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('暂未录入学生信息') else: print('暂未保存数据') def show(): student_list=[] if os.path.exists(filename): with open(filename,'r',encoding='utf-8')as rfile: students=rfile.readlines() for item in students: student_list.append(eval(item)) if student_list: show_student(student_list) else: print('暂未保存数据') if __name__ == '__main__': main()

项目打包

安装第三方模块

在线安装方式

pip install Pyinstaller

执行打包操作

第十七章 实操案例

第一章任务：

任务1

向文件输出‘奋斗成就更好的你’

#方式1,使用print方式向文件输出 fp=open('d:/test.txt','a+') print('奋斗成就更好的你',file=fp) fp.close() #方式2，使用文件读写操作 with open('d:/test1.txt','w') as file: file.write('奋斗成就更好的你2')

任务2

输出某地的天气预报

#输出天气预报 print('星期日','今天') print('-------------------------------------') print('08时','11时','14时','17时','20时','23时') print('0°C',' 6°C','10°C','4°C',' 6°C','30°C') print('--------------------------------------') print('明天 ','2/23','2°C/11°C') print('星期二','2/24','2°C/11°C') print('星期三','2/25','2°C/11°C') print('星期四','2/26','2°C/11°C') print('星期五','2/27','2°C/11°C')

第二章任务：

任务1

输出杨老师出版的图书信息

book_name='Java程序设计教程' publish='西安电子科技大学出版社' pub_date='2019-02-02' price=56.8 print('▶→→→→→→→→→→→→→→→→→→→→→→→→→◀') print('▷\t《',book_name,'》\t◁') print('▷\t出版社：',publish,'》◁') print('▷\t出版时间:',pub_date,'\t◁') print('▷\t定价：',price,'\t◁') print('▶→→→→→→→→→→→→→→→→→→→→→→→→→◀')

任务2

输出《红楼梦》中金陵12钗中的前五位

#方法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])

任务3

输出身体指标

h=170 w=50.5 bmi=w/(h+w) print('身高：'+str(h)) print('体重：'+str(w)) print('bmi:'+'{:0.2f}'.format(bmi))

第三章任务：

任务1：

将指定的十进制数转换成二进制、八进制、十六进制

def fun(): a=int(input('Enter a number')) print(a,'二进制为',bin(a)) #使用了个数可变的位置参数 print(str(a)+'的二进制为'+bin(a)) #使用+作为连接符 print('%s的二进制为%s'%(a,bin(a)))#格式化字符串 print('{0}的二进制为：{1}'.format(a,bin(a))) print(f'{a}的二进制为{bin(a)}') print(f'{a}的八进制为{oct(a)}') print(f'{a}的十六进制为{hex(a)}') if __name__=='__main__': while True: try: fun() break except: print('请输入整数') fun()

任务2：

充话费：

a=int(8) print('花费余额',a) b=int(input("请输入充值金额")) print('当前余额',a+b)

任务3：

计算能量消耗

bushu=int(input("请输入您当天的步数")) calo=bushu*28 print(f'今天您共消耗了{calo},即{calo/1000}千卡')

任务4

预测子女身高

father=float(input("请输入父亲身高")) mother=float(input("请输入母亲身高")) son=(father+mother)*0.54 print('预测孩子的身高为',son)

第四章任务：

任务1

支付密码的验证

pwd=input("请输入密码") if pwd.isdigit(): #代表仅为数字 print('合法') else: print('不合法，仅支持数字') print('------------------------------') s='合法' if pwd.isdigit() else '不合法' print(s)

任务2

模拟QQ号登录

qq=int(input("输入你的账号 ")) qpwd=input('请输入密码') if qq==1403691170 and qpwd=='123456': print('登录成功') else: print('账户\密码错误')

任务3

商品价格竞猜

import random pr=random.randint(1000,1500) print('今日竞猜产品为机器人：价格在[1000-1500]之间') guess=int(input()) if guess>pr: print('大了') elif guess<pr: print('小了') else: print('对了') print('真实价格：',pr)

第五章任务：

任务1

循环输出26个字母对应的ASCII值

x=97 #代表a的ASCII值 for i in range(1,27): print(chr(x),'------',x) x+=1 print('------------') x=97 while x<=123: print(chr(x),'------',x) x+=1

任务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('您还有%s次机会'%(3-i)) else: print('对不起 错误过多 已被锁定')

任务3

猜数游戏

import random ran=random.randint(1,100) for i in range(1,11): num=int(input("Enter a number between 1 and 100: ")) if num==ran: print("Congratulations!") break elif num>ran: print("Too high!") elif num<ran: print("Too low!") print('你一共猜了%s'%i) if i<3: print('猜的厉害') elif i<7: print('猜的还行') else: print('猜的不行')

第六章任务：

任务1

千年虫

由于计算机会把00识别为0，所以2000年后的身份证号由15位转变为了18位

year=[84,87,91,90,00,99,98] 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)