Python学习笔记-基础篇
目录
一、Python简介与工具安装(pass)
1.Python简介
2.Python解释器安装
3.PyCharm开发工具安装
4.Python前篇-计算机基本组成
5.Python前篇-互联网软件思想解读
6.Python前篇-程序语言与基础补课
二、Python函数与变量引用
7.第一个函数print
8.转义字符的使用
9.标识符与保留字
10.Python中的变量
11.变量的多次赋值
三.Python的数据类型使用
12.Python中的常用数据类型
13.Python的进制运算
14.Python的浮点类型
15.Python的布尔类型
16.Python的字符串类型
17.数据类型的转换
18.其他类型数据转为float
19.Python中的注解
20.input函数的简单使用
21.input函数的高级使用
四.Python的运算符实战
22.Python的算术运算符
23.赋值运算符
24.比较运算符
25.布尔运算符
26.位运算符
27.运算符的优先级
28.程序的组织结构-顺序结构
编辑
29.对象的布尔值
五.程序的组织结构
30.选择结构-单分支
31.选择结构-双分支
32.选择结构-多分支
33.嵌套if的使用
34.条件表达式
六.Python的循环控制语句
35.Python的pass语句
36.Python的range()函数
37.Python中的while循环结构
38.while循环练习
39.Python中的for-in循环结构
40.break流程控制语句
41.coutinue流程控制语句
42.else的使用
43.嵌套循环的使用
44.二重循环的break和continue使用
七.循环练习
1.输入一个数，求这个数的阶乘：
2.折纸上月球：地球和月球最短距离为363300公里，一张A4纸0.088mm，问需要折多少下才能到达月球？
3.求和 求s= a + aa + aaa + … + aa…a 的值（最后一个数中 a 的个数为 n ），其中 a 是一个1~9的数字，例如： 2 + 22 + 222 + 2222 + 22222 （此时 a=2 n=5 ）
4. 如果篮球从某一高度落下，每次落地后反弹回原来高度的一半再落下。那么球在第10次落地时，共经过多少米呢? 第10次反弹多高？
5.我国现有13亿人口，设每年增长0.8%，编写程序，计算多少年后达到26亿？
6.打印99乘法表
7.求1！+2！+3！+4！+5！的和
8、星号三角形：输入一个奇数N，输出由星号字符组成的等边三角形，要求：第1行1个星号，第2行3个星号，第3行5个星号，依次类推，最后一行共N的星号。
9.求1~100之间能被7整除，但不能同时被5整除的所有整数 。
10.输出“水仙花数”。所谓水仙花数是指1个3位的十进制数，其各位数字的立方和等于该数本身。例如：153是水仙花数，因为153=1+125+27。
11.求平均分
12.百元买百鸡。假定小鸡每只5角，公鸡每只2元，母鸡每只3元，编程求解购鸡方案。
13.输出100以内的所有素数
14.输入一个数，判断是否为素数
15.给用户9次机会，猜1-10个数字随机猜数字，如果随机的数字和用户的数字一致则表示正确，如果不一致则表示错误.
16.要求从键盘输入用户名和密码，校验格式是否符合规则，如果不符合规则，打印出不符合的原因，并提示从新输入~
八.Python的列表操作
45.列表的概念理解
46.列表的创建
47.列表的特点
48.列表获取指定元素的索引
49.获取列表中单个元素
50.获取列表中多个元素
51.列表元素的查询操作
52.添加列表元素
53.列表元素的删除操作
54.列表元素的排序操作
55.列表生成式
八-1.字符串练习
1. 判断单词great是否在这个字符串中，如果在，则将每一个great后面加一个s， 如果不在则输出 great不在该字符串中；将整个字符串的每一个单词都变成小写，并使每一个单词的首字母变成大写；去除首尾的空白，并输出处理过后的字符串
2.切片的用法：现有字符串如下：words = “abcdefghi” 请使用切片提取出ceg
3.做一个简单的用户信息管理系统：提示用户依次输入姓名，年龄和爱好，并且在输入完成之后，一次性将用户输入的数据展示出来。
4.整除和取余
八-2.列表练习
1.将一些朋友姓名存储在一个列表中，并命名为names。依次访问该列表中的每个元素，将每个朋友的姓名都打印出来
2.继续使用上一个的列表，为每人打印一条消息。每条消息都包含相同的问候语，但抬头为相应朋友的姓名
3.想想你喜欢的通勤方式，如骑摩托车或开汽车，并创建一个包含多种通勤方式的列表。根据该列表打印一系列 有关这些通勤方式的宣言，如“I would like to own a Honda motorcycle”。
4.请创建一个列表，其中包含至少3个你想邀请的人；然后，使用这个列表打印消息，邀请这些人来与你共进晚餐
5.你刚得知有位嘉宾无法赴约，因此需要另外邀请一位嘉宾。
6.你刚找到了一个更大的餐桌，可容纳更多的嘉宾。
7.以完成练习6时编写的程序为基础，在程序末尾添加一行代码，打印一条你只能邀请两位嘉宾共进晚餐的消息。
8.想出至少5个你渴望去旅游的地方。 将这些地方存储在一个列表中，并确保其中的元素不是按字母顺序排列的。 按原始排列顺序打印该列表。
9.使用len()打印一条消息，指出你邀请了多少位嘉宾来与你共进晚餐。
10.给定一个列表，首先删除以s开头的元素，删除后，修改第一个元素为"joke"，并且把最后一个元素复制一份，放在joke的后边 list = ['spring', 'look', “strange' “curious', “black', “hope']
11.有一个列表，判断列表中的每一个元素是否以s或e结尾，如果是，则将其放入一个新的列表中，最后输出这个新的列表
12.现有a=[1，2，3，4，5，6]，用多种方式实现列表的反转，并写出推导过程
13.有两个列表lst1=[11,22,33],lst2=[22,33,44],获取内容相同的元素
14.现在有8位老师，3个办公室，要求8位老师随机分配到三个办公室中
15.已知一个列表 lst = [1,2,3,4,5]
16.修改列表：lst = [1, [4, 6], True] 请将列表里所有数字修改为原来的两倍
17.列表lst内容如下：lst = [2,5,6,7,8,9,2,9,9]
18.列表lst内容如下： lst = [2,5,6,7,8,9,2,9,9]
19.在一行输入多个好友的名字，空格隔开，然后把他们转为列表，接着输入要删除的好友名字，删除这个好友
20.按分数排名从高到低输入3个以上学生名字，空格隔开，将他们转为列表，并淘汰分数最低的3个，输出新列表
21.二维列表
22.密码游戏
23.用列表实现栈
24.禁止重复注册
25.求平均绩点
九.Python的字典操作
56.字典的定义
57.获取字典元素
58.字典的key判断
59.字典的视图
60.字典元素的遍历
61.字典的特点
62.字典生成式
十.python的元组操作
63.元组的定义
64.元组的创建
65.元组-不可变序列
66.元组的遍历
十一.python的集合操作
67.集合的定义
68.集合的相关操作
69.集合间的运算关系
70.集合的数据操作
71.集合的生成式
十二.Python的字符串操作
72.字符串的驻留机制
73.字符串的查询操作
74.字符串的大小写转换操作
75.字符串的对齐操作
76.字符串的分割操作
77.字符串的判断操作
78.字符串的替换操作
79.字符串的比较操作
80.字符串的切片操作
81.格式化字符串
82.字符串的编码和解码
十三.Python的函数应用
83.函数的创建和调用
84.函数的参数传递
85.函数的参数传递内存分析
86.函数的返回值
87.函数的默认参数值
88.函数的参数定义
89.变量的作用域
90.递归函数
十三-1.函数练习
1.求30000以内的“的士数”：存在两组不同的a**3+b**3等于其本身的数
十四.Python的bug定位与调试
93.bug的常见类型
94.Python的异常处理机制
95.python的常见异常类型
96.python的traceback模块
97.如何在pycharm中调试代码
综合练习-学员管理系统
十五.Python中的类与对象
98.软件编程思想
99.类与对象
100.python中的类定义
101.给对象单独增加方法或属性
102.使用self在类封装的方法中输出对象的属性
103.创建对象时自动调用初始化方法
104.初始化方法改进——使用参数设置属性初始值
105. del方法和对象的生命周期
106.__str__方法定制变量输出信息
十六.面向对象封装案例
107.封装特性和需求分析
108.需求分析——被使用的类应该先开发
109.类的属性可以是另一个类创建的对象
110.私有属性和私有方法
111.单继承
112.方法的重写
113.私有方法属性子类不能直接访问
114.多继承
115.面向对象的多态性
116.类属性
117.类方法和静态方法
118.方法综合
119.动态绑定属性和方法
120.类的赋值与拷贝
类的组合
类相关的一些内置函数（BIF）
魔法方法案例1
魔法方法案例2
描述符
定制序列
十七.python的模块应用
121.模块基础概念
122.模块的导入
123.python中的包（python package）
十八.Python中的文件操作
1.文件的基本操作
2.导入OS模块，执行文件和目录的管理操作
十九.一闭三器
1.迭代器
2.生成器
3.闭包
4.装饰器
一、Python简介与工具安装(pass)
1.Python简介
2.Python解释器安装
3.PyCharm开发工具安装
4.Python前篇-计算机基本组成
5.Python前篇-互联网软件思想解读
6.Python前篇-程序语言与基础补课
二、Python函数与变量引用
7.第一个函数print
print(520)
print(11.2)
print('hello')
print("hello")
print(1-3)
print('my', 'name', 'is caiyin')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
520
11.2
hello
hello
-2
my name is caiyin8.转义字符的使用
print('hello\nword') #\n表示换行显示后面的内容
print('hello\tword') #\t相当于tab
print('hello\rword') #覆盖\r前的所有内容
print('hello\bword') #\b相当于按一次删除键
#字符串中存在\ '等字符，前面加\输出原字符
print('http:\\\\www.baidu.com')
print('小明说：\'大家好，我是小明\'')
print(r'hello\nword') #开头加r，让转义字符失效，输出原字符串
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
hello
word
hello word
word
hellword
http:\\www.baidu.com
小明说：'大家好，我是小明'
hello\nword
9.标识符与保留字
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']10.Python中的变量
变量是内存中一个带标签的盒子，把我们需要的数据放进去。
格式：变量名 数值运算符 值
变量由三部分组成：
标识符：表示对象所存储的内存地址，使用内置函数id(obj)来获取
类型 ：表示对象的数据类型，使用内置函数type(obj)来获取
值：表示对象所存储的具体数据，使用print(obj)对值进行打印输出
name = 'caiyin'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
x,y = 1,2
print(x-y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
caiyin
标识 2819537975792
类型
值 caiyin
-1 11.变量的多次赋值
每一次赋值后，变量会指向一个新的内存空间。
name = 'james'
print(name)
name = 'Peter'
print(name)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
james
Peter三.Python的数据类型使用
12.Python中的常用数据类型
int 整型 例：100
float 浮点型 例：2.33
bool 布尔型 True, False
str 字符串 '让学习成为一种享受'
a = 99
b = 1.33
c = True
d = 'hello'
print(a, type(a))
print(b, type(b))
print(c, type(c))
print(d, type(d))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
99
1.33
True
hello 13.Python的进制运算
print('十进制', 114)
print('二进制', 0b10011101) #0b表示后面的数是二进制,print函数将其转为十进制输出
print('八进制', 0o145) #0o表示后面数字是八进制
print('十六进制', 0x1EF54656) #0x表示后面数字为十六进制
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
十进制 114
二进制 157
八进制 101
十六进制 51939080614.Python的浮点类型
a = 1.07678
print(a,type(a))
c = 1.1
d = 2.2
print(c+d)
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
1.07678
3.3000000000000003
3.3 15.Python的布尔类型
a = True
b = False
print(a, type(a))
print(b, type(b))
print(a+1) #True=1
print(b+1) #False=0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
True
False
2
1 16.Python的字符串类型
字符串或串(string)是由数字、字母、下划线组成的一串字符。
字符串被称为不可变的字符序列，可以使用单引号、双引号、三引号来定义' ' " " ''' ''' “”“ ”“”
单引号和双引号定义的字符串必须在同一行
三引号定义的字符串可以连续分布在多行中
s1 = '跟james学Python,月薪过万'
s2 = "跟james学Python,月薪过万"
s3 = '''跟james学Python,
月薪过万'''
s4 = """跟james学Python,
月薪过万"""
print(s1, type(s1))
print(s2, type(s2))
print(s3, type(s3))
print(s4, type(s4))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
跟james学Python,月薪过万
跟james学Python,月薪过万
跟james学Python,
月薪过万
跟james学Python,
月薪过万 17.数据类型的转换
函数名 作用 注意事项 案例
str() 将其他数据类型转换为字符串 也可用引号转换 str(123) '123'
int() 将其他数据类型转换为整数 文字类和小数无法转换 int(123)
浮点数转换为整数，抹零取整 int(9.8)
float() 将其他数据类型转换为浮点数 文字类无法转浮点型 float('9.9')
整数转浮点数，末尾为.0 float(9)
name = 'caiyin'
age = 35
print(type(name), type(age), type(str(age)))
print('我是'+name+'，今年'+str(age)+'岁') #+号起连接符作用
#将其他数据类型转换为字符串
a = 9
b = 18.8
c = False
print(type(a), type(b), type(c))
print(str(a), str(b), str(c))
#将其他数据类型转换为整型
a1 = '145'
f1 = 76.8
a2 = '77.8'
ff = True
a3 = 'caiyin'
print(int(a1), type(int(a1)))
print(int(f1), type(int(f1)))
# print(int(a2), type(a2)) #会报错，字符串里的数是浮点数不能转为整型
print(int(ff), type(int(ff)))
# print(int(a3), type(int(a3))) #会报错，文本类无法转为整型
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
我是caiyin，今年35岁
9 18.8 False
145
76
1 18.其他类型数据转为float
s1 = '13.3'
s2 = '45'
ff = True
s3 = 'caiyin'
i = 67
print(type(s1), type(s2), type(ff), type(s3), type(i))
print(float(s1), type(float(s1)))
print(float(s2), type(float(s2)))
print(float(ff), type(float(ff)))
#print(float(s3), type(float(s3))) #会报错，字符串是非数字无法转为浮点型
print(float(i), type(float(i)))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
13.3
45.0
1.0
67.0 19.Python中的注解
单行注释：以#开头，换行结束
多行注释：并没有单独的多行注释标记，将一对三引号之间的代码作为多行注释
中文编码声明注释：#coding:gbk
x = 1
y = 2
# 打印x与y相加的结果
'''
这是一个注释
你好
打印x+y的结果
'''
print(x+y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
3
20.input函数的简单使用
input函数 作用：接收来自用户的输入
返回值类型：输入值的类型为str
值的存储：使用等号=对输入的值进行存储
str = input('请输入你的名字:')
print(str)
#
'''
1.打印(请输入你的名字：)
2.接收键盘输入内容
3.将内容传递给变量str
'''
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
请输入你的名字:caiyin
caiyin21.input函数的高级使用
# 从键盘输入两个整数，并计算它们的和
x = int(input('请输入一个整数：'))
# x = int(x)
y = int(input('请输入另一个整数：'))
# y = int(y)
print(type(x), type(y))
print(x+y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个整数：33
请输入另一个整数：66
99 四.Python的运算符实战
22.Python的算术运算符
Python中的常用运算符有：算术运算符、赋值运算符、比较运算符、布尔运算符
其中算术运算符分为：标准算术运算符、取余运算符、幂运算符
print(1+3) # 加法运算
print(2-3) # 减法运算
print(3*3) # 乘法运算
print(4/8) # 除法运算
print(11//2) # 整除运算
print(11%2) # 取余运算
print(6**6) # 次方运算
print(9//4)
print(-9//4) # 整除结果为负数时，向下取整
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
4
-1
9
0.5
5
1
46656
2
-3
23.赋值运算符
# 运算顺序从右到左
i = 3+4
print(i)
a=b=c=33
print(a, id(a))
print(b, id(b))
print(c, id(c))
a = 35
a += 50
print(a)
a -= 66
print(a)
a *= 6
print(a)
a /= 2
print(a, type(a))
#解包赋值
a,b,c = 12,33,66
print(a,b,c)
a,b = 33,66
print(a,b)
a,b = b,a
print(a,b)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
7
33 3120762848496
33 3120762848496
33 3120762848496
85
19
114
57.0
12 33 66
33 66
66 33
24.比较运算符
> < >= <= !=
== : 对象value值的比较
is, is not：对象ID的比较
a,b = 33,66
print('a大于b吗：', a>b)
print('a小于b吗：', a=b)
print('a小于等于b吗：', a<=b)
print('a等于b吗：', a==b)
print('a不等于b吗：', a!=b)
a = 12
b = 12
print(a is b) #比较value值
a = [1,2,3,4]
b = [1,2,3,4]
print(a is b) #比较地址ID
print(a is not b)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
a大于b吗： False
a小于b吗： True
a大于等于b吗： False
a小于等于b吗： True
a等于b吗： False
a不等于b吗： True
True
False
True 25.布尔运算符
''' （1）and的返回结果：从左到右，如果结果为真，返回最后一个真；如果结果为假，返回第一个假
（2）or的返回结果：从左到右，如果结果为真，返回遇到的第一个真值；如果结果为假，返回最后一个假值'''
a,b = 15,20
print('--------and--------')
print(a==15 and b==20)
print(a==19 and b==20)
print(a==15 and b==23)
print(a==22 and b==23)
print(a and b)
print('--------or--------')
print(a==15 or b==20)
print(a==19 or b==20)
print(a==15 or b==23)
print(a==22 or b==23)
print(a or b)
print('--------in与not in--------')
ks = 'my name is caiyin'
print('m' in ks)
print('k' in ks)
print('--------not--------')
ff = True
ss = False
print(not ff)
print(not ss)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
--------and--------
True
False
False
False
20
--------or--------
True
True
True
False
15
--------in与not in--------
True
False
--------not--------
False
True26.位运算符
与运算：两个二进制数对应的位都为1，结果为1，反之结果为0
或运算：两个二进制数对应的位都为0，结果为0，反之结果为1
左位移：高位溢出，低位补0
右位移：高位补0，低位截断
print(4&8) # 按位与&，只有同时为1结果才为1
print(4|8) # 按位或|。只有同时为0结果才为0
print(4<<1) # 左移1位，相当于乘2
print(4>>1) # 右移1位，相当于除以2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
0
12
8
227.运算符的优先级
算术运算符>赋值运算符>布尔运算符>比较运算符>位运算符
28.程序的组织结构-顺序结构
29.对象的布尔值
Python中一切皆对象，所有对象都有一个布尔值，获取对象的布尔值用内置函数 bool()
以下对象布尔值为False：False、数值0、None、空字符串、空列表、空元组、、空字典、空集合
其它对象布尔值均为True
五.程序的组织结构
30.选择结构-单分支
money = 10000
draw = int(input('请输入您要取的金额：'))
if money >= draw:
money = money-draw
print('取款成功，您的余额为：', money)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入您要取的金额：8000
取款成功，您的余额为： 200031.选择结构-双分支
两个选择必然会执行一个
number = int(input('请输入一个整数：'))
if number%2 == 0:
print(number, '是一个偶数')
else:
print(number, '是一个奇数')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个整数：15
15 是一个奇数32.选择结构-多分支
mystar = int(input('当前用户的星数：'))
if mystar>=0 and mystar<10:
print('当前段位是青铜')
elif mystar>=10 and mystar<30:
print('当前段位是白银')
elif mystar>=30 and mystar<50:
print('当前段位是黄金')
elif mystar>=50 and mystar<70:
print('当前段位是铂金')
elif mystar>=70 and mystar<80:
print('当前段位是钻石')
elif mystar>=80 and mystar<90:
print('当前段位是星耀')
elif mystar>=90 and mystar<=100:
print('当前段位是王者')
else:
print('错误的信息')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
当前用户的星数：93
当前段位是王者33.嵌套if的使用
mystar = int(input('当前用户的星数：'))
sex = input('请输入你的性别：')
if mystar>=0 and mystar<10:
print('当前段位是青铜')
if sex == '男':
mystar += 1
else:
mystar += 2
print('当前星数为：', mystar)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
当前用户的星数：9
请输入你的性别：女
当前段位是青铜
当前星数为： 1134.条件表达式
a = int(input('请输入一个整数：'))
b = int(input('请输入另一个整数：'))
if a >= b:
print('a大于等于b')
else:
print('a小于b')
# 条件表达式：
print(str(a)+'大于等于'+str(b) if a>=b else str(a)+'小于'+str(b))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个整数：13
请输入另一个整数：14
a小于b
13小于14六.Python的循环控制语句
35.Python的pass语句
VIP = input('你是我们的VIP客户吗? Y/N: ')
if VIP == 'Y':
pass
else:
pass
high = int(input('请输入您的身高：'))
if high: # 相当于进行布尔运算，判断变量值为True还是False
print(high)
else:
print('身高为'+str(high))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
你是我们的VIP客户吗? Y/N: Y
请输入您的身高：0
身高为036.Python的range()函数
x = [1,2,3,4,5]
print(list(x)) # 打印列表时要加list
r = range(10) # 定义一个从0开始，9结束，间隔为1的列表
print(list(r))
r = range(2,10) # 定义一个从2开始，9结束，间隔为1的列表
print(list(r))
r = range(1,10,2) # 定义一个从1开始，9结束，间隔为2的列表
print(list(r))
print(3 in r)
print(2 in r)
print(3 not in r)
print(2 not in r)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
[1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
True
False
False
True37.Python中的while循环结构
判断N+1次，条件为True执行1次
x = 7
while x < 10:
print(x, type(x))
x += 1
print('循环结束')
# 计算1+2+3+4+5+6+7+8+9
x = 0
sum = 0
while x < 10:
sum = sum+x
x += 1
print('结果为：'+str(sum))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果:
7
8
9
循环结束
结果为：45 38.while循环练习
# 计算0-10所有偶数的和
x = 0
sum = 0
while x <= 10:
if x%2 ==0: # if not bool(x%2):
sum = sum+x
x += 1
print('0-10所有偶数的和为：', sum)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
0-10所有偶数的和为： 3039.Python中的for-in循环结构
for a in 'hello':
print(a)
# 循环体中没有变量时，可用_代替自定义变量
for _ in range(3):
print('hello')
# 计算0-10中所有偶数的和
sum = 0
for i in range(11):
if i%2 ==0:
sum = sum+i
i += 1
print('0-10所有偶数的和为：', sum)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
h
e
l
l
o
hello
hello
hello
0-10所有偶数的和为： 3040.break流程控制语句
# 模拟ATM取钱输入密码，输入正确直接退出循环，错误不能超过3次
for i in range(3):
password = input('请输入密码：')
if password == '666666':
print('密码正确。')
break
else:
print('密码错误。')
times = 0
while times < 3:
password = input('请输入密码：')
if password == '666666':
print('密码正确。')
break
else:
print('密码错误。')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入密码：123456
密码错误。
请输入密码：333333
密码错误。
请输入密码：111
密码错误。
请输入密码：666666
密码正确。41.coutinue流程控制语句
# 输出1-20中5的倍数
for i in range(1,21):
if i%5 != 0:
continue
print(i)
'''相当于
for i in range(1,21):
if i%5 == 0:
print(i)
'''
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
5
10
15
2042.else的使用
# 模拟ATM机取款输入密码，错误次数不能超过3次
for i in range(3):
pwd = input('请输入密码：')
if pwd == '666666':
print('密码正确。')
break
else:
print('密码错误。')
else:
print('错误次数达到上限。')
ii = 0
while ii < 3:
pwd = input('请输入密码：')
if pwd == '666666':
print('密码正确。')
break
else:
print('密码错误。')
ii += 1
else:
print('错误次数达到上限。')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入密码：123
密码错误。
请输入密码：222
密码错误。
请输入密码：333
密码错误。
错误次数达到上限。
请输入密码：666666
密码正确。43.嵌套循环的使用
# 打印一个3行4列的星号矩阵
for i in range(3):
for j in range(4):
print('*', end='\t')
print()
# 打印99乘法表
for i in range(1,10):
for j in range(1,i+1):
print(i,'*',j,'=',i*j,end=' ')
print()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
* * * *
* * * *
* * * *
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 44.二重循环的break和continue使用
for i in range(5):
for j in range(1,11):
if j%2 ==0:
continue
print(j,end='\t')
print()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9 七.循环练习
1.输入一个数，求这个数的阶乘：
# 1.输入一个数，求这个数的阶乘：
s = 1
n = int(input('请输入一个整数：'))
for i in range(1,n+1):
s = s*i
print(n,'的阶乘为：',s)
s = 1
n = int(input('请输入一个整数：'))
i = 1
while i <= n:
s = s*i
i += 1
print(n,'的阶乘为：',s)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个整数：7
7 的阶乘为： 5040
请输入一个整数：7
7 的阶乘为： 50402.折纸上月球：地球和月球最短距离为363300公里，一张A4纸0.088mm，问需要折多少下才能到达月球？
'''
2.折纸上月球：地球和月球最短距离为363300公里，一张A4纸0.088mm，问需要折多少下才能到达月球？
'''
s = 0.088
n = 0
while 1:
if s >= 363300*1000*1000:
break
s *= 2
n += 1
print('需要折',n,'次')
from itertools import repeat
s = 0.088
n = 0
for _ in repeat(None):
if s >= 363300*1000*1000:
break
s = s*2
n = n+1
print('需要折',n,'次')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
需要折 42 次
需要折 42 次
3.求和 求s= a + aa + aaa + … + aa…a 的值（最后一个数中 a 的个数为 n ），其中 a 是一个1~9的数字，例如： 2 + 22 + 222 + 2222 + 22222 （此时 a=2 n=5 ）
输入：一行，包括两个整数，第1个为a，第2个为n(1 ≤ a ≤ 9,1 ≤ n ≤ 9)，以英文逗号分隔。
输出：一行，s的值。
1.eval函数的语法及用法
（1）语法：eval(expression)
（2）作用：接收运行一个字符串表达式，返回表达式的结果值。
2.实例
（1）简单的计算用法
（2）与其它函数结合使用，比如结合input函数使用
（3）与while语句、input函数结合使用。
（4）与input函数以及if条件语句、while语句一起结合使用。
'''
3.求和 求s= a + aa + aaa + … + aa…a 的值（最后一个数中 a 的个数为 n ），其中 a 是一个1~9的数字，例如： 2 + 22 + 222 + 2222 + 22222 （此时 a=2 n=5 ）
输入：一行，包括两个整数，第1个为a，第2个为n（1 ≤ a ≤ 9，1 ≤ n ≤ 9），以英文逗号分隔。
输出：一行，s的值。
'''
a,n = eval(input('请依次输入两个1-9的整数，用逗号分隔：'))
sum = a
s = 0
total = 0
for i in range(n):
sum = s*10+a
s = sum
total += sum
print('结果为：',total)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请依次输入两个1-9的整数，用逗号分隔：5,9
结果为： 6172839454. 如果篮球从某一高度落下，每次落地后反弹回原来高度的一半再落下。那么球在第10次落地时，共经过多少米呢? 第10次反弹多高？
输入：输入一个整数h，单位是米，表示球的初始高度。
输出：输出包含两行：
第1行：到球第10次落地时，一共经过的距离。
第2行：第10次弹跳的高度。
'''
4.如果篮球从某一高度落下，每次落地后反弹回原来高度的一半再落下。那么球在第10次落地时，共经过多少米呢? 第10次反弹多高？
输入：输入一个整数h，单位是米，表示球的初始高度。
输出：输出包含两行：
第1行：到球第10次落地时，一共经过的距离。
第2行：第10次弹跳的高度。
'''
s = 0
h = float(input('请输入篮球的初始高度(单位:米)：'))
for i in range(10):
s += h
h /= 2
print('第10次落地时，共经过',s,'米')
print('第10次弹跳高度为：',h,'米')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入篮球的初始高度(单位:米)：9.3
第10次落地时，共经过 18.581835937500003 米
第10次弹跳高度为： 0.00908203125 米5.我国现有13亿人口，设每年增长0.8%，编写程序，计算多少年后达到26亿？
'''
5.我国现有13亿人口，设每年增长0.8%，编写程序，计算多少年后达到26亿？
'''
s = 13
n = 0
from itertools import repeat
for _ in repeat(None):
if s >= 26:
break
s = s*(1+0.008)
n += 1
print(n,'年后人口达到26亿。')
s = 13
n = 0
while 1:
if s >= 26:
break
s = s*(1+0.008)
n += 1
print(n,'年后人口达到26亿。')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
87 年后人口达到26亿。
87 年后人口达到26亿。6.打印99乘法表
# 6.打印99乘法表
for i in range(1,10):
for j in range(1,i+1):
print(f'{i}*{j}={i*j}',end=' ')
print()
print('-'*70)
'''使用列表推导式'''
print('\n'.join([' '.join([f'{i}*{j}={i*j}' for j in range(1,i+1)]) for i in range(1,10)]))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
----------------------------------------------------------------------
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=817.求1！+2！+3！+4！+5！的和
'''
7.求1！+2！+3！+4！+5！的和
'''
sum = 0
n = 1
for i in range(1,6):
sum = sum+n*i
n *= i
print('5个数的阶乘之和为：',sum)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
5个数的阶乘之和为： 1538、星号三角形：输入一个奇数N，输出由星号字符组成的等边三角形，要求：第1行1个星号，第2行3个星号，第3行5个星号，依次类推，最后一行共N的星号。
'''
8、星号三角形：输入一个奇数N，输出由星号字符组成的等边三角形，要求：第1行1个星号，第2行3个星号，第3行5个星号，依次类推，
最后一行共N的星号。
'''
N = int(input('请输入一个奇数：'))
for i in range(N-N//2+1):
for j in range(1,N-i):
print(end=' ')
for k in range(N-i,N+i-1):
print('*',end=' ')
print('')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个奇数：9
*
* * *
* * * * *
* * * * * * *
* * * * * * * * * 9.求1~100之间能被7整除，但不能同时被5整除的所有整数 。
'''
9.求1~100之间能被7整除，但不能同时被5整除的所有整数 。
'''
for i in range(1,101):
if i%7 == 0 and i%5 != 0:
print(i,end='\t')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
7 14 21 28 42 49 56 63 77 84 91 98 10.输出“水仙花数”。所谓水仙花数是指1个3位的十进制数，其各位数字的立方和等于该数本身。例如：153是水仙花数，因为153=1+125+27。
'''
10.输出“水仙花数”。所谓水仙花数是指1个3位的十进制数，其各位数字的立方和等于该数本身。例如：153是水仙花数，因为153=1+125+27。
'''
for i in range(100,1000):
ge = i%10
shi = i//10%10
bai = i//100
if ge**3+shi**3+bai**3 == i:
print(i,end='\t')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
153 370 371 40711.求平均分
'''求平均分'''
score = [66,92,89,78,95,83]
s = 0
for i in score:
s += i
print('平均分为：',int(s/len(score)))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
平均分为： 8312.百元买百鸡。假定小鸡每只5角，公鸡每只2元，母鸡每只3元，编程求解购鸡方案。
'''
12.百元买百鸡。假定小鸡每只5角，公鸡每只2元，母鸡每只3元，编程求解购鸡方案。
'''
# 三种鸡的价格
for i in range(34):
for j in range(51):
for k in range(101):
if i + j + k == 100 and i*3+j*2+k*0.5 == 100:
print('购鸡方案：',k,'只小鸡，',j,'\t只公鸡，',i,'\t只母鸡。')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
购鸡方案： 68 只小鸡， 30 只公鸡， 2 只母鸡。
购鸡方案： 70 只小鸡， 25 只公鸡， 5 只母鸡。
购鸡方案： 72 只小鸡， 20 只公鸡， 8 只母鸡。
购鸡方案： 74 只小鸡， 15 只公鸡， 11 只母鸡。
购鸡方案： 76 只小鸡， 10 只公鸡， 14 只母鸡。
购鸡方案： 78 只小鸡， 5 只公鸡， 17 只母鸡。
购鸡方案： 80 只小鸡， 0 只公鸡， 20 只母鸡。13.输出100以内的所有素数
'''
13.输出100以内的所有素数
'''
for i in range(2,101):
for j in range(2,i//2+1):
if i%j == 0:
break
else:
print(i,end=' ')
print()
for n in range(100,1,-1):
for i in range(2,n//2+1):
if n%i == 0:
break
else:
print(n,end=' ')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
97 89 83 79 73 71 67 61 59 53 47 43 41 37 31 29 23 19 17 13 11 7 5 3 2 14.输入一个数，判断是否为素数
'''
14.输入一个数，判断是否为素数
'''
n = int(input('请输入一个整数：'))
for i in range(2,n//2+1):
if n%i == 0:
print(n,'不是素数')
break
else:
print(n,'是素数')
print('-'*30)
n = int(input('请输入一个整数：'))
i = 2
while i <= n/2:
if n%i == 0:
print(n,'不是素数')
break
else:
i += 1
else:
print(n,'是素数')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个整数：13
13 是素数
------------------------------
请输入一个整数：11
11 是素数15.给用户9次机会，猜1-10个数字随机猜数字，如果随机的数字和用户的数字一致则表示正确，如果不一致则表示错误.
import random
temp = random.randint(0,11)
for i in range(1,10):
num = int(input('请输入你猜的数：'))
if num == temp:
print('恭喜你，猜对了！')
break
else:
print('猜错了，请再次尝试：')
else:
print('很遗憾，你没猜对，次数已用完。')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入你猜的数：1
猜错了，请再次尝试：
请输入你猜的数：2
猜错了，请再次尝试：
请输入你猜的数：3
猜错了，请再次尝试：
请输入你猜的数：4
猜错了，请再次尝试：
请输入你猜的数：5
恭喜你，猜对了！16.要求从键盘输入用户名和密码，校验格式是否符合规则，如果不符合规则，打印出不符合的原因，并提示从新输入~
要求：1、用户名长度6-20，用户名必须以字母开头
2、密码长度至少6位，不能为纯数字，不能有空格
username = input('请输入你的用户名：')
while 1:
if 6 <= len(username) <= 20:
if username[0].isalpha():
password = input('请输入你的密码:')
if len(password) >= 6:
if password.isdigit() == False:
if ' ' not in password:
print('登录成功！')
break
else:
print('格式错误！密码不能包含空格，请重新输入：')
else:
print('格式错误！密码不能为纯数字，请重新输入：')
else:
username = input('格式错误！用户名必须以字母开头，请重新输入：')
else:
username = input('格式错误！用户名长度为6-20位，请重新输入:')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入你的用户名：5asder
格式错误！用户名必须以字母开头，请重新输入：asdqw
格式错误！用户名长度为6-20位，请重新输入:cy2lyf
请输入你的密码:555666
格式错误！密码不能为纯数字，请重新输入：
请输入你的密码:55 sd66
格式错误！密码不能包含空格，请重新输入：
请输入你的密码:55as66八.Python的列表操作
45.列表的概念理解
变量可以存储一个元素，而列表是一个大“容器”，可以存储N多个元素，程序可以方便地对这些数据进行整体操作，列表相当于其它语言中的数组。
46.列表的创建
1.列表需要使用中括号[],元素之间使用英文的逗号进行分隔
2.调用内置函数list()
x = ['abc','ccc',25]
y = list(['abc','ccc',25])47.列表的特点
1.列表元素按顺序有序排列
2.索引映射唯一一个数据
3.列表可以存储重复数据
4.任意数据类型混合
3.根据需要动态分配和回收内存
x = ['hello','小明',355,True]
print(x)
print(x[2],x[-2],x[3],x[-3]) '''索引从左往右是0开始，从右往左是-1开始'''
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
['hello', '小明', 355, True]
355 355 True 小明
48.列表获取指定元素的索引
x = ['abc','hello',123,False,'hello']
'''查找列表中元素的索引'''
print(x.index('abc'))
print('-'*30)
'''print(x.index('333')) 查找的元素列表中没有会报错'''
print(x.index('hello',2,5))
'''list.index('xxx',m,n)表示查找列表list中'xxx'元素，索引范围为m开始，n结尾(不包含n)'''
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
0
------------------------------
449.获取列表中单个元素
x = ['abc','hello',123,False,'hello']
'''0开始'''
print(x[3])
print('-'*30)
'''-1开始'''
print(x[-2])
print(x[-5])
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
False
------------------------------
False
abc50.获取列表中多个元素
语法格式：列表名[start:stop:step]
lst = [10,20,30,40,50,60,70,80,90]
print('-----------原列表-------------')
print(lst)
print('-----从1开始,4结尾,步长为2------')
lst2 = lst[1:5:2]
print(lst2)
print('----------步长默认为1----------')
print(lst[1:5:])
print('--end位置不写,默认到列表最后1个元素--')
print(lst[1::2])
print('-start不写,当步长为正数，默认从0开始正序-')
print(lst[:5:1])
print('-start不写,当步长为负数数，默认从最后个元素开始倒序-')
print(lst[:2:-2])
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
-----------原列表-------------
[10, 20, 30, 40, 50, 60, 70, 80, 90]
-----从1开始,4结尾,步长为2------
[20, 40]
----------步长默认为1----------
[20, 30, 40, 50]
--end位置不写,默认到列表最后1个元素--
[20, 40, 60, 80]
-start不写,当步长为正数，默认从0开始正序-
[10, 20, 30, 40, 50]
-start不写,当步长为负数，默认从最后个元素开始倒序-
[90, 70, 50]51.列表元素的查询操作
lst = [10,20,30,40,'hello']
print(10 in lst)
print(50 in lst)
print(50 not in lst)
for str in lst:
print(str,end='\t')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
True
False
True
10 20 30 40 hello 52.添加列表元素
append: 在列表的末尾添加一个元素或子列表
extend: 在列表的末尾至少添加一个元素（若添加子列表，会变为新增元素）
insert: 在列表的任意位置添加一个元素或子列表
切片: 在列表的任意位置添加至少一个元素
lst = [10,20,30]
'''在列表末尾添加元素'''
lst.append(50)
print(lst)
'''在列表末尾添加子列表'''
lst2 = ['hello','word']
lst.append(lst2)
print(lst)
'''将子列表作为元素添加到列表末尾'''
lst.extend(lst2)
print(lst)
'''在列表任意位置添加元素'''
lst.insert(2,90)
print(lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
[10, 20, 30, 50]
[10, 20, 30, 50, ['hello', 'word']]
[10, 20, 30, 50, ['hello', 'word'], 'hello', 'word']
[10, 20, 90, 30, 50, ['hello', 'word'], 'hello', 'word']53.列表元素的删除操作
lst = [10,20,30,40,30,60]
'''删除列表中某个元素(从左到右第1次出现的那个)'''
lst.remove(30)
print(lst)
'''删除索引位置的第一个元素，不填索引默认删除末尾元素'''
lst.pop(1)
print(lst)
'''切片删除'''
lst[1:3] = []
print(lst)
'''删除指定索引的元素'''
del lst[1]
print(lst)
'''清空列表中所有元素'''
lst.clear()
print(lst)
'''删除列表对象'''
del lst
# print(lst) 会报错，因为lst对象已不存在
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
[10, 20, 40, 30, 60]
[10, 40, 30, 60]
[10, 60]
[10]
[]54.列表元素的排序操作
常用的两种方法：
1.调用sort()：列表中所有元素按从小到大顺序排列，可以指定reverse=True，进行降序排列
2.调用内置函数sorted()：创建新列表，默认升序排列，可以指定reverse=True，进行降序排列
lst = [10,80,30,60,70,50]
print('-------原列表-------','\n',lst,id(lst))
'''对原列表进行排序'''
lst.sort()
print('-------升序排列-------','\n',lst,id(lst))
lst.sort(reverse=True)
print('-------降序排列-------','\n',lst)
lst.reverse()
print('-------反转列表--------','\n',lst)
'''创建新列表,默认升序'''
new_lst = sorted(lst)
print('-------新列表-------','\n',new_lst,id(new_lst))
'''对新列表降序排列'''
new_lst = sorted(lst,reverse=True)
print('-------新列表降序-------','\n',new_lst,id(new_lst))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
-------原列表-------
[10, 80, 30, 60, 70, 50] 2186902153536
-------升序排列-------
[10, 30, 50, 60, 70, 80] 2186902153536
-------降序排列-------
[80, 70, 60, 50, 30, 10]
-------反转列表--------
[10, 30, 50, 60, 70, 80]
-------新列表-------
[10, 30, 50, 60, 70, 80] 2186905218304
-------新列表降序-------
[80, 70, 60, 50, 30, 10] 218690287200055.列表生成式
lst = [i for i in range(1,10)]
print('-----生成1-9的列表-----','\n',lst)
lst = [i*i for i in range(1,10)]
print('-----生成1-9平方的列表-----','\n',lst)
lst = [i*2 for i in range(1,6)]
print('-----生成1-10偶数的列表-----','\n',lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
-----生成1-9的列表-----
[1, 2, 3, 4, 5, 6, 7, 8, 9]
-----生成1-9平方的列表-----
[1, 4, 9, 16, 25, 36, 49, 64, 81]
-----生成1-10偶数的列表-----
[2, 4, 6, 8, 10]八-1.字符串练习
1. 判断单词great是否在这个字符串中，如果在，则将每一个great后面加一个s， 如果不在则输出 great不在该字符串中；将整个字符串的每一个单词都变成小写，并使每一个单词的首字母变成大写；去除首尾的空白，并输出处理过后的字符串
str = ' Wow!sounds great!She sHowed great courAge duRing the war '
print('-'*20,'原字符串','-'*20)
print(str)
print('-'*20,'给great加s','-'*20)
if 'great' in str:
result = str.replace('great','greats')
print(result)
else:
print('great不在该字符串中')
print('-'*20,'改为小写','-'*20)
result = result.lower()
print(result)
print('-'*20,'首字母大写','-'*20)
result = result.title()
print(result)
print('-'*20,'删除首尾空字符','-'*20)
result = result.strip()
print(result)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
-------------------- 原字符串 --------------------
Wow!sounds great!She sHowed great courAge duRing the war
-------------------- 给great加s --------------------
Wow!sounds greats!She sHowed greats courAge duRing the war
-------------------- 改为小写 --------------------
wow!sounds greats!she showed greats courage during the war
-------------------- 首字母大写 --------------------
Wow!Sounds Greats!She Showed Greats Courage During The War
-------------------- 删除首尾空字符 --------------------
Wow!Sounds Greats!She Showed Greats Courage During The War2.切片的用法：现有字符串如下：words = “abcdefghi” 请使用切片提取出ceg
words = 'abcdefghi'
s_words = words[2:7:2]
print(s_words)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
ceg3.做一个简单的用户信息管理系统：提示用户依次输入姓名，年龄和爱好，并且在输入完成之后，一次性将用户输入的数据展示出来。
name = input('请输入你的姓名：')
age = input('请输入你的年龄：')
hobby = input('请输入你的爱好：')
print('{}你好，你的年龄是{}，你的爱好是{}。'.format(name,age,hobby))
print('{1}你好，你的年龄是{0}，你的爱好是{2}。'.format(age,name,hobby))
print('{a}你好，你的年龄是{b}，你的爱好是{c}。'.format(a=name,b=age,c=hobby))
print(f'{name}你好，你的年龄是{age}，你的爱好是{hobby}。')
print('%s你好，你的年龄是%d，你的爱好是%s。'%(name,int(age),hobby))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入你的姓名：小明
请输入你的年龄：21
请输入你的爱好：打篮球
小明你好，你的年龄是21，你的爱好是打篮球。
小明你好，你的年龄是21，你的爱好是打篮球。
小明你好，你的年龄是21，你的爱好是打篮球。
小明你好，你的年龄是21，你的爱好是打篮球。
小明你好，你的年龄是21，你的爱好是打篮球。4.整除和取余
'''输入两个整数x和y，第一行输出x除以y的商和余数，第二行输出x除以y的非整除结果，保留2位小数'''
x = int(input('请输入第1个整数：'))
y = int(input('请输入第2个整数：'))
a = x//y
b = x%y
c = x/y
print('x除以y的商为{}，余数为{}\nx除以y的结果为{:.2f}'.format(a,b,c))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入第1个整数：99
请输入第2个整数：15
x除以y的商为6，余数为9
x除以y的结果为6.60八-2.列表练习
1.将一些朋友姓名存储在一个列表中，并命名为names。依次访问该列表中的每个元素，将每个朋友的姓名都打印出来
names = ['老邓','老范','小飞','老肖']
for name in names:
print(name,end='\t')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
老邓 老范 小飞 老肖 2.继续使用上一个的列表，为每人打印一条消息。每条消息都包含相同的问候语，但抬头为相应朋友的姓名
names = ['老邓','老范','小飞','老肖']
for greet in names:
print(greet,': 朋友，你好啊')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果:
老邓 : 朋友，你好啊
老范 : 朋友，你好啊
小飞 : 朋友，你好啊
老肖 : 朋友，你好啊3.想想你喜欢的通勤方式，如骑摩托车或开汽车，并创建一个包含多种通勤方式的列表。根据该列表打印一系列 有关这些通勤方式的宣言，如“I would like to own a Honda motorcycle”。
commuting = ['car','bicycle','motorcycle']
brands = ['Benz','GIANT','Honda']
for manner in range(3):
print('I would like to own a',brands[manner],commuting[manner])
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
I would like to own a Benz car
I would like to own a GIANT bicycle
I would like to own a Honda motorcycle4.请创建一个列表，其中包含至少3个你想邀请的人；然后，使用这个列表打印消息，邀请这些人来与你共进晚餐
guests = ['James','Tom','jack','Green']
for guset in guests:
print(guset,',我可以和你一起共进晚餐吗？')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果:
James ,我可以和你一起共进晚餐吗？
Tom ,我可以和你一起共进晚餐吗？
jack ,我可以和你一起共进晚餐吗？
Green ,我可以和你一起共进晚餐吗？5.你刚得知有位嘉宾无法赴约，因此需要另外邀请一位嘉宾。
以完成练习4时编写的程序为基础，在程序末尾添加一条print语句，指出哪位嘉宾无法赴约。 修改嘉宾名单，将无法赴约的嘉宾的姓名替换为新邀请的嘉宾的姓名。 再次打印一系列消息，向名单中的每位嘉宾发出邀请。
guests = ['James','Tom','jack','Green']
guests[2] = 'Bob'
print(guests[2],'不能来吃饭。')
for guset in guests:
print(guset,',我可以邀请你一起共进晚餐吗？')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
Bob 不能来吃饭。
James ,我可以邀请你一起共进晚餐吗？
Tom ,我可以邀请你一起共进晚餐吗？
Bob ,我可以邀请你一起共进晚餐吗？
Green ,我可以邀请你一起共进晚餐吗？6.你刚找到了一个更大的餐桌，可容纳更多的嘉宾。
请想想你还想邀请哪三位嘉宾。 以完成练习4或练习5时编写的程序为基础，在程序末尾添加一条print语句，指出你找到了一个更大的餐桌。 使用insert()将一位新嘉宾添加到名单开头。 使用insert()将另一位新嘉宾添加到名单中间。 使用append()将最后一位新嘉宾添加到名单末尾。 打印一系列消息，向名单中的每位嘉宾发出邀请。
guests = ['James','Tom','jack','Green']
guests[2] = 'Bob'
guests.insert(0,'Jerry')
guests.insert(2,'Peter')
guests.append('Sam')
print('我找到了一个更大的餐桌!')
for guset in guests:
print(guset,',我可以邀请你一起共进晚餐吗？')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
我找到了一个更大的餐桌!
Jerry ,我可以邀请你一起共进晚餐吗？
James ,我可以邀请你一起共进晚餐吗？
Peter ,我可以邀请你一起共进晚餐吗？
Tom ,我可以邀请你一起共进晚餐吗？
Bob ,我可以邀请你一起共进晚餐吗？
Green ,我可以邀请你一起共进晚餐吗？
Sam ,我可以邀请你一起共进晚餐吗？7.以完成练习6时编写的程序为基础，在程序末尾添加一行代码，打印一条你只能邀请两位嘉宾共进晚餐的消息。
使用 pop()不断地删除名单中的嘉宾，直到只有两位嘉宾为止。每次从名单中弹出一位嘉宾时，都打印一条消息， 让该嘉宾知悉你很抱歉，无法邀请他来共进晚餐。对于余下的两位嘉宾中的每一位，都打印一条消息，指出他依然在受邀人之列。 使用del()将最后两位嘉宾从名单中删除，让名单变成空的。打印该名单，核实程序结束时名单确实是空的。
guests = ['Jerry','James','Peter','Bob','jack','Green','Sam']
print('非常抱歉，我只能邀请两位嘉宾与我共进晚餐。')
while len(guests) > 2:
honored = guests.pop()
print(honored,'很抱歉，我不能邀请你一起共进晚餐。')
print('-'*30)
for guest in guests:
print(guest,'我仍然希望你能和我一起共进晚餐。')
del guests[0]
del guests[0]
print(guests)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
非常抱歉，我只能邀请两位嘉宾与我共进晚餐。
Sam 很抱歉，我不能邀请你一起共进晚餐。
Green 很抱歉，我不能邀请你一起共进晚餐。
jack 很抱歉，我不能邀请你一起共进晚餐。
Bob 很抱歉，我不能邀请你一起共进晚餐。
Peter 很抱歉，我不能邀请你一起共进晚餐。
------------------------------
Jerry 我仍然希望你能和我一起共进晚餐。
James 我仍然希望你能和我一起共进晚餐。
[]8.想出至少5个你渴望去旅游的地方。 将这些地方存储在一个列表中，并确保其中的元素不是按字母顺序排列的。 按原始排列顺序打印该列表。
不要考虑输出是否整洁的问题，只管打印原始Python列表。 使用sorted()按字母顺序打印这个列表，同时不要修改它。 再次打印该列表，核实排列顺序未变。 使用sorted()按与字母顺序相反的顺序打印这个列表， 同时不要修改它。 再次打印该列表，核实排列顺序未变。 使用reverse()修改列表元素的排列顺序。打印该列表，核实排列顺序确实变了。 使用reverse()再次修改列表元素的排列顺序。打印该列表，核实已恢复到原来的排列顺序。 使用sort()修改该列表，使其元素按字母顺序排列。打印该列表，核实排列顺序确实变了。 使用sort()修改该列表，使其元素按与字母顺序相反的顺序排列。打印该列表，核实排列顺序确实变了。
resort = ['Santorini','Aegean Sea','Pink Sands','Rose Lake','The blue hole']
print(resort)
print('-'*80)
resort1 = sorted(resort)
print(resort)
print('-'*80)
print(resort1)
print('-'*80)
resort2 = sorted(resort,reverse=True)
print(resort2)
print('-'*80)
print(resort)
print('-'*80)
resort.reverse()
print(resort)
print('-'*80)
resort.reverse()
print(resort)
print('-'*80)
resort.sort()
print(resort)
print('-'*80)
resort.sort(reverse=True)
print(resort)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
['Santorini', 'Aegean Sea', 'Pink Sands', 'Rose Lake', 'The blue hole']
--------------------------------------------------------------------------------
['Santorini', 'Aegean Sea', 'Pink Sands', 'Rose Lake', 'The blue hole']
--------------------------------------------------------------------------------
['Aegean Sea', 'Pink Sands', 'Rose Lake', 'Santorini', 'The blue hole']
--------------------------------------------------------------------------------
['The blue hole', 'Santorini', 'Rose Lake', 'Pink Sands', 'Aegean Sea']
--------------------------------------------------------------------------------
['Santorini', 'Aegean Sea', 'Pink Sands', 'Rose Lake', 'The blue hole']
--------------------------------------------------------------------------------
['The blue hole', 'Rose Lake', 'Pink Sands', 'Aegean Sea', 'Santorini']
--------------------------------------------------------------------------------
['Santorini', 'Aegean Sea', 'Pink Sands', 'Rose Lake', 'The blue hole']
--------------------------------------------------------------------------------
['Aegean Sea', 'Pink Sands', 'Rose Lake', 'Santorini', 'The blue hole']
--------------------------------------------------------------------------------
['The blue hole', 'Santorini', 'Rose Lake', 'Pink Sands', 'Aegean Sea']9.使用len()打印一条消息，指出你邀请了多少位嘉宾来与你共进晚餐。
guests = ['James','Tom','jack','Green']
print('我邀请了',len(guests),'位嘉宾与我共进晚餐。')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
我邀请了 4 位嘉宾与我共进晚餐。10.给定一个列表，首先删除以s开头的元素，删除后，修改第一个元素为"joke"，并且把最后一个元素复制一份，放在joke的后边 list = ['spring', 'look', “strange' “curious', “black', “hope']
函数：startswith()
作用：判断字符串是否以指定字符或子字符串开头
函数说明
语法：string.startswith(str, beg=0,end=len(string)) 或string[beg:end].startswith(str)
参数说明：
string： 被检测的字符串
str： 指定的字符或者子字符串。（可以使用元组，会逐一匹配）
beg： 设置字符串检测的起始位置（可选）
end： 设置字符串检测的结束位置（可选）
如果存在参数 beg 和 end，则在指定范围内检查，否则在整个字符串中检查
返回值
如果检测到字符串，则返回True，否则返回False。默认空字符为True
函数解析：如果字符串string是以str开始，则返回True，否则返回False
list = ['spring','look','strange','curious','black','hope']
'''删除s开头的元素'''
for str in list:
if str.startswith('s'):
list.remove(str)
print(list)
print('-'*50)
'''修改第1个元素'''
list[0] = 'joke'
print(list)
print('-'*50)
'''获取最后一个元素'''
value = list[-1]
print(value)
print('-'*50)
'''插入复制的元素'''
list.insert(1,value)
print(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
['look', 'curious', 'black', 'hope']
--------------------------------------------------
['joke', 'curious', 'black', 'hope']
--------------------------------------------------
hope
--------------------------------------------------
['joke', 'hope', 'curious', 'black', 'hope']11.有一个列表，判断列表中的每一个元素是否以s或e结尾，如果是，则将其放入一个新的列表中，最后输出这个新的列表
list = [“red”, “apples”, “orange”, “pink”, “bananas”, “blue”, “black”, “white”]
函数：endswith()
作用：判断字符串是否以指定字符或子字符串结尾，常用于判断文件类型
函数说明
语法：string.endswith(str, beg=[0,end=len(string)])
string[beg:end].endswith(str)
参数说明：
string： 被检测的字符串
str： 指定的字符或者子字符串（可以使用元组，会逐一匹配）
beg： 设置字符串检测的起始位置（可选，从左数起）
end： 设置字符串检测的结束位置（可选，从左数起）
如果存在参数 beg 和 end，则在指定范围内检查，否则在整个字符串中检查
返回值：
如果检测到字符串，则返回True，否则返回False。
解析：如果字符串string是以str结束，则返回True，否则返回False
list = ['red','apples','orange','pink','bananas','blue','black','white']
new_list = []
for str in list:
if str.endswith('s') or str.endswith('e'):
new_list.append(str)
print(new_list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
['apples', 'orange', 'bananas', 'blue', 'white']12.现有a=[1，2，3，4，5，6]，用多种方式实现列表的反转，并写出推导过程
a = [1,2,3,4,5,6]
'''直接使用reverse()'''
a.reverse()
print(a)
print('-'*30)
'''使用sort(reverse=True),a的顺序发生改变'''
a1 = a
a1.sort(reverse=True)
print(a1)
print('-'*30)
'''使用sorted(list.reverse=True)'''
a2 = sorted(a,reverse=True)
print(a2)
print('-'*30)
'''重置a的顺序'''
a.sort()
'''使用切片方式'''
a3 = a[::-1]
print(a3)
运行结果：
[6, 5, 4, 3, 2, 1]
------------------------------
[6, 5, 4, 3, 2, 1]
------------------------------
[6, 5, 4, 3, 2, 1]
------------------------------
[6, 5, 4, 3, 2, 1]13.有两个列表lst1=[11,22,33],lst2=[22,33,44],获取内容相同的元素
lst1 = [11,22,33]
lst2 = [22,33,44]
for i in range(3):
for j in range(3):
if lst1[i] == lst2[j]:
print(lst1[i],end='\t')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
22 33 14.现在有8位老师，3个办公室，要求8位老师随机分配到三个办公室中
import random
teachers = ['教师1','教师2','教师3','教师4','教师5','教师6','教师7','教师8']
office1 = []
office2 = []
office3 = []
num = 7
for i in range(3):
n = random.randint(0,num)
office1.append(teachers[n])
teachers.remove(teachers[n])
num -= 1
for i in range(3):
n = random.randint(0,num)
office2.append(teachers[n])
teachers.remove(teachers[n])
num -= 1
for i in range(2):
n = random.randint(0,num)
office3.append(teachers[n])
print(office1)
print(office2)
print(office3)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
['教师6', '教师3', '教师1']
['教师8', '教师7', '教师4']
['教师5', '教师2']15.已知一个列表 lst = [1,2,3,4,5]
1. 求列表的长度
2. 判断6 是否在列表中
3. lst + [6, 7, 8] 的结果是什么？
4. lst*2 的结果是什么
5. 列表里元素的最大值是多少
6. 列表里元素的最小值是多少
7. 列表里所有元素的和是多少
8. 在索引1的位置新增一个的元素10
9. 在列表的末尾新增一个元素20
lst = [1,2,3,4,5]
print('------------列表长度------------')
print(len(lst))
print('---------6是否在列表中-----------')
print(6 in lst)
print('---------lst+[6,7,8]-----------')
lst2 = [6,7,8]
print(lst+lst2)
print('---------lst*2-----------')
print(lst*2)
print('---------列表元素最大值-----------')
print(max(lst))
print('---------列表元素最小值-----------')
print(min(lst))
print('---------列表所有元素之和-----------')
print(sum(lst))
print('---------在索引1处添加元素10-----------')
lst.insert(1,10)
print(lst)
print('---------在列表末尾添加元素20-----------')
lst.append(20)
print(lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
------------列表长度------------
5
---------6是否在列表中-----------
False
---------lst+[6,7,8]-----------
[1, 2, 3, 4, 5, 6, 7, 8]
---------lst*2-----------
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
---------列表元素最大值-----------
5
---------列表元素最小值-----------
1
---------列表所有元素之和-----------
15
---------在索引1处添加元素10-----------
[1, 10, 2, 3, 4, 5]
---------在列表末尾添加元素20-----------
[1, 10, 2, 3, 4, 5, 20]
16.修改列表：lst = [1, [4, 6], True] 请将列表里所有数字修改为原来的两倍
lst = [1,[4,6],True]
lst[0] *= 2
lst[1][0] *= 2
lst[1][1] *= 2
print(lst)
'''另一种方法：使用自定义函数解决'''
'''enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，
一般用在 for 循环当中。
例子： >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
>>> [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1)) # 下标从 1 开始
>>> [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
for循环当中使用： >>> seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, element)
>>> 0 one
1 two
2 three'''
def double_list(lst):
for index,item in enumerate(lst):
if isinstance(item,bool): # isinstance()判断列表元素类型
continue
if isinstance(item,(int,float)):
lst[index] *= 2
if isinstance(item,list):
double_list(item)
if __name__ == '__main__': # 程序入口
lst = [1,[4,6],True]
double_list(lst)
print(lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
[2, [8, 12], True]
[2, [8, 12], True]17.列表lst内容如下：lst = [2,5,6,7,8,9,2,9,9]
1.找出列表里的最大值
2.找出列表里的最小值
3.找出列表里最大值的个数
4.计算列表里所有元素的和
5.计算列表里元素的平均值
6.计算列表的长度
7.找出元素6在列表中的索引
lst = [2,5,6,7,8,9,2,9,9]
print('最大值：',max(lst))
print('最小值：',min(lst))
print('最大值个数：',lst.count(max(lst)))
print('所有元素之和：',sum(lst))
ave = sum(lst)/len(lst)
print('平均值：%.2f'%ave)
print('列表长度：',len(lst))
print('元素6所在的索引：',lst.index(6))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
最大值： 9
最小值： 2
最大值个数： 3
所有元素之和： 57
平均值：6.33
列表长度： 9
元素6所在的索引： 218.列表lst内容如下： lst = [2,5,6,7,8,9,2,9,9]
1.在列表的末尾增加元素15
2.在列表的中间位置插入元素20
3.将列表[2, 5, 6]合并到lst中
4.移除列表中索引为3的元素
5.翻转列表里的所有元素
6.对列表里的元素进行排序，从小到大一次，从大到小一次
lst = [2,5,6,7,8,9,2,9,9]
lst.append(15)
print('末尾增加元素：',lst)
lst.insert(5,20)
print('中间插入元素：',lst)
lst2 = [2,5,6]
lst.extend(lst2)
print('插入子列表：',lst)
lst.pop(3)
print('删除索引位置元素：',lst)
lst = lst[::-1]
print('反转列表所有元素：',lst)
lst.sort()
print('从小到大排序：',lst)
lst.sort(reverse=True)
print('从大到小排序：',lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
末尾增加元素： [2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
中间插入元素： [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
插入子列表： [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
删除索引位置元素： [2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
反转列表所有元素： [6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
从小到大排序： [2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
从大到小排序： [20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]19.在一行输入多个好友的名字，空格隔开，然后把他们转为列表，接着输入要删除的好友名字，删除这个好友
'''在一行输入多个好友的名字，空格隔开，然后把他们转为列表，接着输入要删除的好友名字，删除这个好友'''
lst = input('请输入你的好友名字，用空格隔开：').split()
print(lst)
name = input('请输入你想要删除的好友名字：')
lst.remove(name)
'''lst.pop(lst.index(name))
lst = (i for i in lst if i != name)'''
print(lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入你的好友名字，用空格隔开：小明 小张 小王
['小明', '小张', '小王']
请输入你想要删除的好友名字：小王
['小明', '小张']20.按分数排名从高到低输入3个以上学生名字，空格隔开，将他们转为列表，并淘汰分数最低的3个，输出新列表
lst = input('请按分数从高到低顺序输入学生名字：').split()
for i in range(3):
lst.pop()
print(lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请按分数从高到低顺序输入学生名字：Allen Jerry Bob Peter Jack
['Allen', 'Jerry']21.二维列表
小明，小张，小王，小丽4个学生，他们的数学成绩分别为90，85，92，95，语文成绩分别为75,90,83,86 建立3个列表，再建立一个二维列表lst，用append将3组列表添加进lst
name = ['小明', '小张', '小王', '小丽']
shuxue = [90, 85, 92, 95]
yuwen = [75, 90, 83, 86]
lst = []
lst.append(name)
lst.append(shuxue)
lst.append(yuwen)
print(lst)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
[['小明', '小张', '小王', '小丽'], [90, 85, 92, 95], [75, 90, 83, 86]]22.密码游戏
小明和小王玩密码游戏，小明发送一个4位整数，小王需要按以下规则进行破解：每位数字都加3再对9取余，替换原来的数，然后第1位和第3位交换，第2位和第4位交换
num = int(input('请输入一个4位整数：'))
ge = num%10
shi = num%100//10
bai = num%1000//100
qian = num//1000
lst = [qian, bai , shi, ge]
for i in range(len(lst)):
lst[i] = str((lst[i]+3)%9)
lst[0],lst[1],lst[2],lst[3] = lst[2],lst[3],lst[0],lst[1]
print('破解后的数字为：', lst[0],lst[1],lst[2],lst[3],sep='')
'''方法二：
str = ''.join(lst)
print(str)'''
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个4位整数：3567
破解后的数字为：016823.用列表实现栈
用pop()函数弹出两个元素，再输入两个数用append添加进列表，要求每次进栈出栈都输出整个列
stack = [1, 2, 3, 4, 5]
stack.pop()
print(stack)
stack.pop()
print(stack)
stack.append(int(input()))
print(stack)
stack.append(int(input()))
print(stack)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
[1, 2, 3, 4]
[1, 2, 3]
8
[1, 2, 3, 8]
9
[1, 2, 3, 8, 9]24.禁止重复注册
创建一个当前用户列表，再创建一个新用户列表,用for判断新用户是否在当前用户列表中，判断时不区分大小写。
若在，输出The user name {} has already been registered! Please change it and try again!
若不在输出Congratulations, the user name {} is available!
current_users = ['BoB', 'ALlen', 'Peter', 'Jerry']
new_users = ['Bob', 'Allen', 'Tom', 'Jack']
for i in new_users:
for j in current_users:
if i.lower() == j.lower():
print('The user name {} has already been registered! Please change it and try again!'.format(i))
break
else:
print('Congratulations, the user name {} is available!'.format(i))
'''方法二：'''
current_users = ['BoB', 'ALlen', 'Peter', 'Jerry']
new_users = ['Bob', 'Allen', 'Tom', 'Jack']
current_users_L = [i.lower() for i in current_users]
for i in new_users:
if i.lower() in current_users_L:
print('The user name {} has already been registered! Please change it and try again!'.format(i))
else:
print('Congratulations, the user name {} is available!'.format(i))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
The user name Bob has already been registered! Please change it and try again!
The user name Allen has already been registered! Please change it and try again!
Congratulations, the user name Tom is available!
Congratulations, the user name Jack is available!
The user name Bob has already been registered! Please change it and try again!
The user name Allen has already been registered! Please change it and try again!
Congratulations, the user name Tom is available!
Congratulations, the user name Jack is available!25.求平均绩点
根据成绩计算平均绩点，绩点与等级的对应关系为A-4.0, B-3.0, C-2.0, D-1.0, F-0, 一行输入等级一行输入学分，遇到等级为False结束输入，计算平均绩点（每门学分乘单门绩点，求和后对学分求均值）
grade_dict = {'A':4.0, 'B':3.0, 'C':2.0, 'D':1.0, 'F':0}
grade_list = []
score_list = []
while True:
grade = input()
if grade == 'False':
break
else:
score = eval(input())
grade_list.append(grade_dict[grade]*score)
score_list.append(score)
avg_score = sum(grade_list)/sum(score_list)
print('%.2f'%(avg_score))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
B
2
C
2
A
1
False
2.80九.Python的字典操作
56.字典的定义
字典是python内置的数据结构之一，与列表一样是一个可变序列。
以键值对的方式存储数据，字典是一个无序的序列。
字典的实现原理与查字典类似，查字典是先根据部首或拼音查找汉字对应的页码，python中的字典是根据key查找value所在的位置。
'''第一种方式创建字典'''
score = {'小明':90, '小张':95, '小王':100}
print(score,type(score))
order = {'订单号':'E100882', '时间':'20220810', '价格':298}
print(order)
'''第二种方式创建'''
order = dict(订单号='E100882',时间='20220810',价格=298)
print(order)
'''空字典'''
a = {}
print(a,type(a))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
{'小明': 90, '小张': 95, '小王': 100}
{'订单号': 'E100882', '时间': '20220810', '价格': 298}
{'订单号': 'E100882', '时间': '20220810', '价格': 298}
{} 57.获取字典元素
'''直接获取'''
score = {'小明':90, '小张':95, '小王':100}
print(score)
print(score['小张'])
'''使用内置函数get()'''
print(score.get('小张'))
'''print(score['xxx']) 直接获取不存在的元素会报错'''
print(score.get('xxx'))
print(score.get('xxx',60))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
{'小明': 90, '小张': 95, '小王': 100}
95
95
None
6058.字典的key判断
'''判断key是否在字典中'''
score = {'小明':90, '小张':95, '小王':100}
print('小王' in score)
print('小张' not in score)
'''添加字典元素'''
score['小李'] = 93
print(score)
'''修改字典元素'''
score['小明'] = 91
print(score)
'''删除字典元素'''
del score['小张']
print(score)
'''清空字典元素'''
score.clear()
print(score)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
True
False
{'小明': 90, '小张': 95, '小王': 100, '小李': 93}
{'小明': 91, '小张': 95, '小王': 100, '小李': 93}
{'小明': 91, '小王': 100, '小李': 93}
{}59.字典的视图
'''获取字典里所有key'''
score = {'小明':91, '小张':95, '小王':100}
keys = score.keys()
print(keys, type(keys))
'''把keys转换为列表'''
print(list(keys))
'''获取所有value值'''
values = score.values()
print(values, type(values))
'''把values转换为列表'''
print(list(values))
'''获取所有键值对'''
items = score.items()
print(items,type(items))
'''把itemns转换为列表(中间为元组)'''
print(list(items))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
dict_keys(['小明', '小张', '小王'])
['小明', '小张', '小王']
dict_values([91, 95, 100])
[91, 95, 100]
dict_items([('小明', 91), ('小张', 95), ('小王', 100)])
[('小明', 91), ('小张', 95), ('小王', 100)] 60.字典元素的遍历
'''item获取Key,score[item]获取value'''
score = {'小明':91, '小张':95, '小王':100}
for Key in score.keys():
print(Key)
for Value in score.values():
print(Value)
for Key,Value in score.items():
print(Key,Value)
for item in score:
print(item,score[item],score.get(item))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小明
小张
小王
91
95
100
小明 91
小张 95
小王 100
小明 91 91
小张 95 95
小王 100 10061.字典的特点
1.字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
2.字典中的元素是无序的
3.字典中的key必须是不可变对象
4.字典也可以根据需要动态的伸缩
5.字典会浪费较大的内存，是一种使用空间换时间的数据结构
'''key重复时，只保留最后一个元素'''
score = {'小明':91, '小明':95, '小王':100}
print(score)
'''value可以重复'''
score = {'小明':91, '小王':91}
print(score)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
{'小明': 95, '小王': 100}
{'小明': 91, '小王': 91}62.字典生成式
内置函数zip()：用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元素组成的列表。
names = ['小明', '小张', '小王']
scores = [91, 95, 100, 99]
dic = {name:score for name,score in zip(names,scores)}
print(dic)
'''fromkeys()函数：用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
写法为：dict.fromkeys(seq[, value])
'''
a = ['name', 'age']
d = {}.fromkeys(a,10)
print(d)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
{'小明': 91, '小张': 95, '小王': 100}
{'name': 10, 'age': 10}十.python的元组操作
63.元组的定义
python的内置数据结构之一，是一个不可变序列
不可变序列：字符串、元组——不能在同一个内存地址中进行增、删、改的操作
可变序列：列表、字典——可以对序列执行增、删、改操作，对象地址不变
'''可变序列'''
lst = [1,2,3,4]
dct = {1:10, 2:100, 3:1000}
print(id(lst), id(dct))
lst.append(5)
dct[4] = 10000
print(lst, id(lst))
print(dct, id(dct))
'''不可变序列'''
str = 'hello'
print(str, id(str))
str = str + ' word'
print(str, id(str))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
1918585252160 1918585191040
[1, 2, 3, 4, 5] 1918585252160
{1: 10, 2: 100, 3: 1000, 4: 10000} 1918585191040
1918585218672
hello word 191858545444864.元组的创建
'''3种方式创建元组'''
t1 = (1,2,3,4,5)
'''单个变量赋值时，自动将右边多个值打包成元祖'''
t2 = 1,2,3,4,5
t3 = tuple((1,2,3,4,5))
print(t1, id(t1))
print(t2, id(t2))
print(t3, id(t3))
'''元组中只有一个元素时，要加逗号'''
t4 = ('hello')
t5 = ('hello',)
print(t4, type(t4))
print(t5, type(t5))
'''创建空元组'''
t6 = ()
t7 = tuple()
print(t6)
print(t7)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
(1, 2, 3, 4, 5) 2086856127040
(1, 2, 3, 4, 5) 2086856127040
(1, 2, 3, 4, 5) 2086856127040
hello
('hello',)
()
() 65.元组-不可变序列
为何要将元组设计成不可变序列？
在多任务环境下，同时操作对象时不需要枷锁，因此，在程序中尽量使用不可变序列。
注意事项：元组中存储的是对象的引用。
1.如果元组中的对象本身为不可变对象，则不能再引用其他对象。
2.如果元组中的对象本身为可变对象，则可变对象的引用不允许改变，但数据可以改变。
t1 = (10,[20,30],'hello')
print(t1, id(t1))
print(t1[0], type(t1[0]),id(t1[0]))
print(t1[1], type(t1[1]),id(t1[1]))
print(t1[2], type(t1[2]),id(t1[2]))
'''t1[1] = 100 会报错，不能修改其特性， 因为t1[1]为列表，列表是可变序列，
所以可以在不改变数据类型的基础上对t1[1]进行增删改操作'''
t1[1].append(100)
print(t1, id(t1))
print(t1[1], id(t1[1]))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
(10, [20, 30], 'hello') 2765533547072
10 2765531906576
[20, 30] 2765533260096
hello 2765533199088
(10, [20, 30, 100], 'hello') 2765533547072
[20, 30, 100] 2765533260096 66.元组的遍历
'''遍历元组元素'''
t1 = (10,20,30,40,50)
for i in range(5):
print(t1[i], end='\t')
print('\n','-'*30)
t2 = ('小明','小张','hello')
for j in t2:
print(j, end='\t')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
10 20 30 40 50
------------------------------
小明 小张 hello十一.python的集合操作
67.集合的定义
python内置数据结构之一，与列表、字典一样属于可变序列类型，集合是没有value的字典。
1.集合中的元素不允许重复。
2.集合中的元素是不可变的（不能修改），但整个集合是可变的。
3.没有索引附加到python集中的任何元素。因此，它们不支持任何索引或切片操作。
可变类型：修改之后，内存地址不会发生变化
列表 字典 集合
不可变类型： 修改之后，内存地址会发生变化
数值类型(int、floot、bool)，string(字符串)，tuple(元组)
'''创建集合'''
s1 = {2,1,6,3,7,5,4,0}
print(s1, type(s1), id(s1))
s2 = set(range(8))
print(s2, type(s2), id(s2))
s3 = {0,1,2,2,3,3,4,5,6,6,7}
print(s3, type(s3), id(s3))
s4 = {'hello'}
print(s4, type(s4))
s5 = set('hello')
print(s5, type(s5))
s6 = set()
s7 = {}
print(s6, type(s6))
print(s7, type(s7))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
{0, 1, 2, 3, 4, 5, 6, 7} 2094831737696
{0, 1, 2, 3, 4, 5, 6, 7} 2094831735008
{0, 1, 2, 3, 4, 5, 6, 7} 2094831736128
{'hello'}
{'e', 'o', 'l', 'h'}
set()
{} 68.集合的相关操作
1.集合元素的判断操作：in或not in
2.集合元素的新增操作：
(1).调用add()方法：一次添加一个元素
(2).调用update()方法：至少添加一个元素
3.集合元素的删除操作：
(1).调用remove()方法：一次删除一个指定元素，如果指定元素不存在，抛出KeyError
(2).调用discard()方法：一次删除一个指定元素，如果指定元素不存在，不抛出异常
(3).调用pop()方法 ：一次只删除一个任意元素
(4).调用clear()方法：清空集合
'''判断集合元素是否存在'''
s1 = {1,5,9,12,18,21}
print(s1)
print(5 in s1)
print(5 not in s1)
print(4 in s1)
print(4 not in s1)
'''添加集合元素'''
s1.add(88)
print(s1)
s1.update({33,55,66})
print(s1)
s1.update([50,90,120])
print(s1)
s1.update((111,333))
print(s1)
lst = [555,666]
s1.update(lst)
print(s1)
'''删除集合元素'''
s1.remove(120)
print(s1)
s1.discard(32)
s1.discard(333)
print(s1)
s1.pop()
s1.pop()
print(s1)
s1.clear()
print(s1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
{1, 18, 5, 21, 9, 12}
True
False
False
True
{1, 18, 5, 21, 88, 9, 12}
{1, 33, 66, 5, 9, 12, 18, 21, 55, 88}
{1, 33, 66, 5, 9, 12, 18, 50, 21, 55, 88, 90, 120}
{1, 33, 66, 5, 9, 12, 333, 111, 18, 50, 21, 55, 88, 90, 120}
{1, 33, 66, 5, 9, 555, 12, 333, 111, 18, 50, 666, 21, 55, 88, 90, 120}
{1, 33, 66, 5, 9, 555, 12, 333, 111, 18, 50, 666, 21, 55, 88, 90}
{1, 33, 66, 5, 9, 555, 12, 111, 18, 50, 666, 21, 55, 88, 90}
{66, 5, 9, 555, 12, 111, 18, 50, 666, 21, 55, 88, 90}
set()69.集合间的运算关系
'''判断集合是否相等'''
s1 = {1,2,3,4,5}
s2 = {2,4,1,5,3}
print(s1 == s2)
print(s1, id(s1))
print(s2, id(s2))
'''判断一个集合是否另一个集合的子集'''
s3 = {2,5,1}
s4 = {3,4,6}
print(s3.issubset(s1))
print(s4.issubset(s1))
'''判断一个集合是否另一个集合的超集'''
print(s1.issuperset(s3))
print(s1.issuperset(s4))
'''判断两个集合是否相交(相交返回False，不相交返回True'''
print(s1.isdisjoint(s4))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
True
{1, 2, 3, 4, 5} 2102235244448
{1, 2, 3, 4, 5} 2102237698688
True
False
True
False
False70.集合的数据操作
s1 = {1,2,3,4,5}
s2 = {2,3,4,5,6}
'''求交集'''
ss1 = s1.intersection(s2)
ss2 = s1 & s2
print(ss1, id(ss1))
print(ss2, id(ss2))
'''求并集'''
print(s1.union(s2))
print(s1 | s2)
'''求差集'''
print(s1.difference(s2))
print(s1 - s2)
print(s2 - s1)
'''求平方差集'''
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
{2, 3, 4, 5} 2754993953632
{2, 3, 4, 5} 2754993950944
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
{1}
{1}
{6}
{1, 6}
{1, 6}71.集合的生成式
'''列表生成式和集合生成式对比'''
lst = [i*i for i in range(10)]
print(lst)
s = {i*i for i in range(10)}
print(s)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}十二.Python的字符串操作
72.字符串的驻留机制
字符串驻留机制是一种在内存中仅保存一份相同且不可变字符串的方法。
PS：以下内容来源于网络，经测试，只有运行时不驻留这条符合，其他不驻留的情况均与文章不符合（和版本有关）
python的驻留机制对相同的短字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新的内存空间，而是把该对象的地址赋给新创建的变量；长字符串不遵守驻留机制。
python的引用计数机制，只对“ [0-9] [a-z] [A-Z]和"_"(下划线) ”有效，当字符串中由其他字符比如“！ @ # ￥ % -”时，字符驻留机制是不起作用的。
驻留机制的特点：
1.字符串长度为0或1：默认采用驻留机制
2.字符串长度大于1：字符串只包含大小写字母、数字、下划线_时，采用驻留机制
3.对于[-5,256]之间的整数，python默认驻留
4.字符串只在编译时进行驻留，而非运行时
5.用乘法得到的字符串，结果长度 <=20且字符串只包含大小写字母、数字、下划线，支持驻留。长度>20，不支持驻留。这样的设计目的是为了保护.pcy文件不会被错误代码搞的过大。
驻留机制的优缺点：
python标识符的不可变性导致了字符串的改动不是采用replace，而是重新创建对象。 为了节省内存，设计字符串的改动通常用join()而非+，因为+会多次创建对象，而join()只创建一次对象。
驻留机制会提升一些时间和空间上的性能，但驻留对象也有所损耗
'''带数字、字母、下划线'''
str1 = '123hello_word'
str2 = '123hello_word'
print('-----数字、字母、下划线-----')
print(str1 is str2)
print(id(str1), id(str2))
'''带空格'''
print('-----带空格及其他特殊字符-----')
str3 = '123hello\!@#$ %(*^word'
str4 = '123hello\!@#$ %(*^word'
print(str3 is str4)
print(id(str3), id(str4))
'''运行时不驻留'''
print('-----运行时不驻留-----')
str5 = 'hello'
str6 = str5+'word'
str7 = 'helloword'
print(str6 is str7)
print(id(str6), id(str7))
'''整数-5-255默认驻留（此版本不同）'''
print('-----整数的驻留机制-----')
a = 2147483648123456789123456789123456789
b = 2147483648123456789123456789123456789
print(a is b)
print('-----带乘法的字符串<=4096位-----')
s1 = 'a'*4096
s2 = 'a'*4096
print(s1 is s2)
print('-----带乘法的字符串>4096位-----')
s3 = 'a'*4097
s4 = 'a'*4097
print(s3 is s4)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
-----数字、字母、下划线-----
True
2648114641648 2648114641648
-----带空格及其他特殊字符-----
True
2648114947104 2648114947104
-----运行时不驻留-----
False
2648116820592 2648116818416
-----整数的驻留机制-----
True
-----带乘法的字符串<=4096位-----
True
-----带乘法的字符串>4096位-----
False73.字符串的查询操作
index(): 查找子串substr第一次出现的位置，如果查找的子串不存在，则抛出valueerror
rindex(): 查找子串substr最后一次出现的位置，如果查找的子串不存在，则抛出valueerror
find(): 查找子串substr第一次出现的位置，如果查找的子串不存在，则返回-1
rfind(): 查找子串substr最后一次出现的位置，如果查找的子串不存在，则返回-1
'''查找子串第一次出现的位置'''
s = 'hello wordhello'
print(s.index('llo'))
print(s.find('llo'))
'''查找子串最后一次出现的位置'''
print(s.rindex('llo'))
print(s.rfind('llo'))
'''查找的内容不存在时，index和rindex会报错，find和rfind返回-1'''
# print(s.index('ab'))
# print(s.rindex('ab'))
print(s.find('ab'))
print(s.rfind('ab'))
'''查找子串在字符串中出现的次数'''
print(s.count('l'))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
2
2
12
12
-1
-1
674.字符串的大小写转换操作
upper：把字符串中所有字母都转换为大写字母
lower：把字符串中所有字母都转换为小写字母
swapcase：把字符串中所有大写字母转小写字母，所有小写字母转大写字母
capitalize：把第一个字母转换为大写（第一个为数字时不转换），其余字母转换为小写
title：把每个单词的第一个字母转换为大写，每个单词的剩余字母转换为小写
s = '123Hello wOrd789'
'''所有字母变大写'''
print(s.upper())
'''所有字母变小写'''
print(s.lower())
'''大写变小写，小写变大写（此函数不能直接放在print里）'''
a = s.swapcase()
print(a)
'''第一个字母变大写，其余变小写（如果第一个是数字则不变，后面的字母都变为小写）'''
print(s.capitalize())
'''每个单词的首字母大写，其余字母小写'''
print(s.title())
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
123HELLO WORD789
123hello word789
123hELLO WoRD789
123hello word789
123Hello Word78975.字符串的对齐操作
s = 'How are you?'
print(s, id(s))
print(s.center(12),id(s.ljust))
'''居中对齐(第1个参数是宽度，第2个参数是填充符)'''
s1 = s.center(20,'*')
print(s1, id(s1))
'''左对齐'''
s2 = s.ljust(20,'*')
print(s2, id(s2))
'''右对齐(填充符默认为空格)'''
s3 = s.rjust(20,'*')
print(s3, id(s3))
print(s.rjust(20))
'''右对齐，参数为宽度，填充符为0'''
print(s.zfill(20))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
How are you? 1983846267632
How are you? 1983846573744
****How are you?**** 1983846573728
How are you?******** 1983846573088
********How are you? 1983846823968
How are you?
00000000How are you?76.字符串的分割操作
s1 = 'Today is Sunday'
'''从左到右分割，默认以空格为分割标记'''
lst1 = s1.split()
print(lst1, type(lst1))
'''sep指定分割标记，maxsplit指定分割次数'''
s2 = 'Hello&Word&China'
lst2 = s2.split(sep='&',maxsplit=1)
print(lst2)
'''从右到左分割'''
lst3 = s2.rsplit(sep='&',maxsplit=1)
print(lst3)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
['Today', 'is', 'Sunday']
['Hello', 'Word&China']
['Hello&Word', 'China'] 77.字符串的判断操作
isidentifier()：判断指定的字符串是不是合法标识符
isspace()：判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
isalpha()：判断指定的字符串是否全部由字母组成
isnumeric()：判断指定的字符串是否全部由数字组成
isdecimal()：判断指定的字符串是否全部由十进制数字组成
isalnum()：判断指定的字符串是否全部由字母和数字组成
s = 'hello_word123'
'''判断字符串是否为合法标识符'''
print('1.', s.isidentifier())
print('2.', '123hello'.isidentifier())
'''判断字符串是否为空白字符'''
print('3.', ' \n\t'.isspace())
'''判断字符串是否为纯字母'''
print('4.', 'hello'.isalpha())
'''判断字符串是否为纯数字'''
print('5.', '12356b'.isnumeric())
'''判断字符串是否为十进制数字'''
print('6.', '8999'.isdecimal())
'''判断字符串是否只有字母和数字'''
print('7.', '999hello'.isalnum())
print('8.', '123 hello'.isalnum())
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
1. True
2. False
3. True
4. True
5. False
6. True
7. True
8. False78.字符串的替换操作
s = 'I love Python,Python,Python'
'''replace替换操作，最后加数字代表替换次数'''
print(s.replace('Python','Java'))
print(s.replace('Python','Java',2))
'''join连接操作'''
print('*'.join(s))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
I love Java,Java,Java
I love Java,Java,Python
I* *l*o*v*e* *P*y*t*h*o*n*,*P*y*t*h*o*n*,*P*y*t*h*o*n79.字符串的比较操作
运算符：>,>=,<,<=,==,!=
比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中字符不相等时，其结果就是比较结果，两个字符串的后续字符将不再被比较
比较原理：两个字符进行比较时，比较的是其ordinal value（原始值）,调用内置函数ord()可得到指定字符的ordinal value，调用内置函数chr()指定ordinal value可得到其对应的字符
print('hello' > 'he')
print('hello' > 'we')
print(ord('h'), ord('w'))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
True
False
104 11980.字符串的切片操作
s = 'hello,python'
'''默认从0开始，左闭右开'''
s1 = s[:6]
print(s1)
'''默认最后个元素结尾'''
s2 = s[6:]
print(s2)
'''0开始，末尾结束，步长为2'''
s3 = s[::2]
print(s3)
'''倒序'''
s4 = s[7:2:-2]
print(s4)
s5 = s[-2:-7:-1]
print(s5)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
hello,
python
hlopto
y,l
ohtyp81.格式化字符串
%作占位符：%s-字符串 %i或%d-十进制整数 %f-浮点数
{}作占位符：大括号中可指定索引顺序，不填默认为顺序，格式为:{0}...{1}.format(name1,name2)
name = '小明'
age = 18
height = 180.3
hobby = 'python'
numid = 350
'''%作占位符：%.nf表示保留小数点后n位，%nd表示输出n位整数，右对齐，不足的空格补全
%0nd表示输出n位整数右对齐，不足的0补全，%.nd表示最少输出n位整数，不足的0补全
%-nd表示输入n位整数左对齐，不足的0补全'''
print('我叫%s，今年%d岁，身高%.2f，爱好是%s，学号为%04d' % (name,age,height,hobby,numid))
print('我的学号是%.4d'%(numid))
print('我的学号是%-4d'%(numid))
'''{}作占位符,括号内可填索引顺序，不填默认为顺序'''
print('我叫{2},今年{1}岁，身高{0}，爱好是{4}，学号为{3}'.format(height,age,name,numid,hobby))
'''直接填充方式，适用于python3以上版本'''
print(f'我叫{name},今年{age}岁，身高{height}，爱好是{hobby}，学号为{numid}')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
我叫小明，今年18岁，身高180.30，爱好是python，学号为0350
我的学号是0350
我的学号是350
我叫小明,今年18岁，身高180.3，爱好是python，学号为350
我叫小明,今年18岁，身高180.3，爱好是python，学号为35082.字符串的编码和解码
# -*- encoding=utf-8 -*-
s = '我叫小明，我爱python'
byte = s.encode(encoding='UTF-8')
print(byte)
print(byte.decode(encoding='UTF-8'))
'''报错解决方法1：# -*- encoding=utf-8 -*-
解决方法2：修改文档—设置文件编码—unicode—uTF-8
方法3：# vim: set fileencoding='''
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
b'\xe6\x88\x91\xe5\x8f\xab\xe5\xb0\x8f\xe6\x98\x8e\xef\xbc\x8c\xe6\x88\x91\xe7\x88\xb1python'
我叫小明，我爱python 十三.Python的函数应用
83.函数的创建和调用
函数：执行特定任务以完成特定功能的的一段代码
作用：1.复用代码-隐藏实现细节
2.提高可维护性
3.提高可读性便于调试
创建函数： def 函数名([输入参数])
函数体
[return xxx]
中括号部分可以使用也可以省略
注意事项：创建函数有多少个形参，那么调用时就需要传入多少个值，且顺序必须和创建函数时一致。即便该函数没有参数，函数名后的小括号也不能省略。
'''定义求两数之和的函数'''
def calc(a, b): # a,b为函数入口参数
c = a+b
return(c) # c为出口参数
result = calc(12,15)
print(result)
'''定义获取字符串长度的函数'''
def my_len(str):
n = 0
for i in str:
n += 1
length = n
return(length)
s = input()
print(my_len(s))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
27
hello world!
1284.函数的参数传递
def calc(a, b): # 形式参数
c = a-b
return(c)
result = calc(12,15) # 实际参数
print(result)
'''指定参数传递顺序'''
result = calc(b=12,a=15)
print(result)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
-3
385.函数的参数传递内存分析
def fun(arg1,arg2):
print('arg1=',arg1)
print('arg2=',arg2)
arg1 = 100
arg2.append(10)
print('arg1=',arg1,id(arg1))
print('arg2=',arg2,id(arg2))
'''函数中arg1变化对n1值无影响，arg2与n2指向同一内存，arg2变化时n2也随之变化'''
n1 = 11
n2 = [11,22,33]
print(n1)
print(n2)
print('-'*30)
fun(n1,n2)
print(n1, id(n1))
print(n2, id(n2))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
11
[11, 22, 33]
------------------------------
arg1= 11
arg2= [11, 22, 33]
arg1= 100 2118100979024
arg2= [11, 22, 33, 10] 2118106261824
11 2118100976176
[11, 22, 33, 10] 211810626182486.函数的返回值
num_lst = [1,2,3,4,5,6,7,8,9,10]
'''把列表中的奇数放一个新列表，偶数放另一个新列表'''
def fun(lst):
old = []
even = []
for i in lst:
if i%2:
old.append(i)
else:
even.append(i)
return old, even
'''返回多个值的时候以元组方式返回'''
result = fun(num_lst)
print(result, type(result))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
([1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) 87.函数的默认参数值
'''提取字符串中指定位置元素，开始位置默认为0,步长默认为1'''
def split_str(str,star=0,step=1):
lst = []
for i in range(star,len(str),step):
lst.append(str[i])
return ''.join(lst)
s1 = 'hello,python!'
s2 = split_str(s1)
s3 = split_str(s1,2)
s4 = split_str(s1,2,2)
print(s1,s2,s3,s4, sep='\n')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
hello,python!
hello,python!
llo,python!
lopto!88.函数的参数定义
个数可变的位置形参：
定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
使用*定义个数可变的位置形参，结果为一个元组
个数可变的关键字形参：
定义函数时，无法确定传递的关键字实参的个数时，使用可变的关键字形参
使用**定义个数可变的关键字形参，结果为一个字典
'''个数可变的位置形参（实参为元组）'''
def fun1(*arg):
arg *= 3
print(arg)
fun1(10,20,30)
'''个数可变的关键字形参（实参为字典）'''
def fun2(**arg):
print(arg)
fun2(age=10,name='小明',height=183.5)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
(10, 20, 30, 10, 20, 30, 10, 20, 30)
{'age': 10, 'name': '小明', 'height': 183.5}89.变量的作用域
变量的作用域：程序代码能访问该变量的区域
根据变量的有效范围可分为：
局部变量：在函数内定义并使用的变量，只在函数内部有效，并且与函数外部具有相同名称的其他变量没有任何关系，局部变量使用global声明就会变成全局变量
全局变量：函数体外定义的变量，可作用于函数内外
'''函数内定义的变量为局部变量，如果要在外部使用，需用global声明'''
def fun1(x):
print(x)
x = 0
print(f'局部变量x变为：{x}')
x = 10
fun1(x)
print(f'外部变量x的值:{x}')
print('------使用global声明------')
def fun2():
global x
print(x)
x = 0
print(f'局部变量x变为：{x}')
x = 10
fun2()
print(f'外部变量x的值：{x}')
'''变量不能同时作为global变量和函数之间传递的变量,如下会报错'''
'''def fun3(y):
global y
y = 10
print(y)'''
90.递归函数
'''输入一个数，求这个数的阶乘'''
def fun(n):
if n == 1:
return 1
else:
result = n*fun(n-1)
return result
num = int(input('请输入一个整数：'))
fact = fun(num)
print('{}的阶乘为：{}'.format(num,fact))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入一个整数：6
6的阶乘为：720十三-1.函数练习
1.求30000以内的“的士数”：存在两组不同的a**3+b**3等于其本身的数
def fun(a,b):
result = a**3+b**3
return result
for i in range(1,100):
for j in range(i,100):
num = fun(i,j)
for k in range(i,100):
for l in range(k,100):
if k*l != i*j and num == fun(k,l) and num <= 30000:
print('{}是的士数：{}**3+{}**3={}\t{}**3+{}**3={}'.format(num,i,j,num,k,l,num))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
1729是的士数：1**3+12**3=1729 9**3+10**3=1729
4104是的士数：2**3+16**3=4104 9**3+15**3=4104
13832是的士数：2**3+24**3=13832 18**3+20**3=13832
20683是的士数：10**3+27**3=20683 19**3+24**3=20683十四.Python的bug定位与调试
93.bug的常见类型
粗心导致的语法错误：
1.漏了末尾的冒号: 如if语句，循环语句，else语句，def语句等
2.缩进错误：该缩进的没缩进，不该缩进的瞎缩进
3.把英文符号写成中文符号，比如逗号、引号、冒号、括号
4.字符串拼接的时候，把字符串和数字拼在一起
5.使用了没有定义的变量，如while循环条件中的变量
6."=="比较运算符和"="赋值运算符的混用
知识不熟练导致的错误：
1.索引越界问题：如lst=[1,2,3,4] print(lst[4])
2.方法使用不熟练：如lst=[] lst=append('A','B','C'] print(lst)
被动掉坑：
程序代码逻辑没错，只是因为用户错误操作或者一些意外情况而导致的程序崩溃
如：输入两个整数做除法，用户输入分母为0
'''对于可能会出现问题的代码，需要把这段代码提前封装起来'''
'''输入两个整数a和b，计算a除以b的结果'''
while True:
try:
a = int(input('请输入第一个整数：'))
b = int(input('请输入第二个整数：'))
print('计算结果为：{:.0f}'.format(a/b))
break
except ValueError: # 输入格式不符的错误代码
print('只能输入整数,请重新输入')
except ZeroDivisionError: # 第2个数输入0的错误代码
print('除数不可为0,请重新输入')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入第一个整数：3.5
只能输入整数,请重新输入
请输入第一个整数：6
请输入第二个整数：0
除数不可为0,请重新输入
请输入第一个整数：8
请输入第二个整数：2
计算结果为：494.Python的异常处理机制
多个except结构：捕获异常的顺序按说先子类后父类的顺序，为了避免可能出现的异常，可以在最后增加exception
try-except-else结构：若try块中没有抛出异常，则执行else块，如果try中抛出异常，执行except快
try-except-else-finally结构：不论前面的步骤是否执行，都会执行finally块
'''调用BaseException（所有内置异常的基类）'''
'''输入两个整数a和b，计算a除以b的结果'''
while True:
try:
a = int(input('请输入第一个整数：'))
b = int(input('请输入第二个整数：'))
result = a/b
except BaseException as e:
print('输入格式错误，错误信息:', e)
else:
print('计算结果为：{:.0f}'.format(result))
break
finally:
print('感谢使用！')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入第一个整数：12
请输入第二个整数：0
输入格式错误，错误信息: division by zero
感谢使用！
请输入第一个整数：q
输入格式错误，错误信息: invalid literal for int() with base 10: 'q'
感谢使用！
请输入第一个整数：15
请输入第二个整数：3
计算结果为：5
感谢使用！''' BaseException # 所有异常的基类
+-- SystemExit # 解释器请求退出
+-- KeyboardInterrupt # 用户中断执行(通常是输入^C)
+-- GeneratorExit # 生成器(generator)发生异常来通知退出
+-- Exception # 常规异常的基类
+-- StopIteration # 迭代器没有更多的值
+-- StopAsyncIteration # 必须通过异步迭代器对象的__anext__()方法引发以停止迭代
+-- ArithmeticError # 各种算术错误引发的内置异常的基类
| +-- FloatingPointError # 浮点计算错误
| +-- OverflowError # 数值运算结果太大无法表示
| +-- ZeroDivisionError # 除(或取模)零 (所有数据类型)
+-- AssertionError # 当assert语句失败时引发
+-- AttributeError # 属性引用或赋值失败
+-- BufferError # 无法执行与缓冲区相关的操作时引发
+-- EOFError # 当input()函数在没有读取任何数据的情况下达到文件结束条件(EOF)时引发
+-- ImportError # 导入模块/对象失败
| +-- ModuleNotFoundError # 无法找到模块或在在sys.modules中找到None
+-- LookupError # 映射或序列上使用的键或索引无效时引发的异常的基类
| +-- IndexError # 序列中没有此索引(index)
| +-- KeyError # 映射中没有这个键
+-- MemoryError # 内存溢出错误(对于Python 解释器不是致命的)
+-- NameError # 未声明/初始化对象 (没有属性)
| +-- UnboundLocalError # 访问未初始化的本地变量
+-- OSError # 操作系统错误，EnvironmentError，IOError，WindowsError，socket.error，select.error和mmap.error已合并到OSError中，构造函数可能返回子类
| +-- BlockingIOError # 操作将阻塞对象(e.g. socket)设置为非阻塞操作
| +-- ChildProcessError # 在子进程上的操作失败
| +-- ConnectionError # 与连接相关的异常的基类
| | +-- BrokenPipeError # 另一端关闭时尝试写入管道或试图在已关闭写入的套接字上写入
| | +-- ConnectionAbortedError # 连接尝试被对等方中止
| | +-- ConnectionRefusedError # 连接尝试被对等方拒绝
| | +-- ConnectionResetError # 连接由对等方重置
| +-- FileExistsError # 创建已存在的文件或目录
| +-- FileNotFoundError # 请求不存在的文件或目录
| +-- InterruptedError # 系统调用被输入信号中断
| +-- IsADirectoryError # 在目录上请求文件操作(例如 os.remove())
| +-- NotADirectoryError # 在不是目录的事物上请求目录操作(例如 os.listdir())
| +-- PermissionError # 尝试在没有足够访问权限的情况下运行操作
| +-- ProcessLookupError # 给定进程不存在
| +-- TimeoutError # 系统函数在系统级别超时
+-- ReferenceError # weakref.proxy()函数创建的弱引用试图访问已经垃圾回收了的对象
+-- RuntimeError # 在检测到不属于任何其他类别的错误时触发
| +-- NotImplementedError # 在用户定义的基类中，抽象方法要求派生类重写该方法或者 正在开发的类指示仍然需要添加实际实现
| +-- RecursionError # 解释器检测到超出最大递归深度
+-- SyntaxError # Python 语法错误
| +-- IndentationError # 缩进错误
| +-- TabError # Tab和空格混用
+-- SystemError # 解释器发现内部错误
+-- TypeError # 操作或函数应用于不适当类型的对象
+-- ValueError # 操作或函数接收到具有正确类型但值不合适的参数
| +-- UnicodeError # 发生与Unicode相关的编码或解码错误
| +-- UnicodeDecodeError # Unicode解码错误
| +-- UnicodeEncodeError # Unicode编码错误
| +-- UnicodeTranslateError # Unicode转码错误
+-- Warning # 警告的基类
+-- DeprecationWarning # 有关已弃用功能的警告的基类
+-- PendingDeprecationWarning # 有关不推荐使用功能的警告的基类
+-- RuntimeWarning # 有关可疑的运行时行为的警告的基类
+-- SyntaxWarning # 关于可疑语法警告的基类
+-- UserWarning # 用户代码生成警告的基类
+-- FutureWarning # 有关已弃用功能的警告的基类
+-- ImportWarning # 关于模块导入时可能出错的警告的基类
+-- UnicodeWarning # 与Unicode相关的警告的基类
+-- BytesWarning # 与bytes和bytearray相关的警告的基类
+-- ResourceWarning # 与资源使用相关的警告的基类。被默认警告过滤器忽略。'''95.python的常见异常类型
ZeroDivisionError：除（或取模）零（所有数据类型）
IndexError：序列中没有此索引（index）
KeyError：映射中没有这个键
NameError：未声明、初始化对象（没有属性）
SyntaxError：Python语法错误
ValueError：传入无效的参数
96.python的traceback模块
'''输入两个整数a和b，计算a除以b的结果'''
while True:
try:
a = int(input('请输入第一个整数：'))
b = int(input('请输入第二个整数：'))
result = a/b
except:
traceback.print_exc()
print('输入格式错误，错误信息:', e)
else:
print('计算结果为：{:.0f}'.format(result))
break
finally:
print('感谢使用！')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
请输入第一个整数：15
请输入第二个整数：0
感谢使用！
Traceback (most recent call last):
File "C:\PythonBases\Python基础课程\12.python的bug定位与调试\95.python的traceback模块.py", line 6, in
result = a/b
ZeroDivisionError: division by zero
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "C:\PythonBases\Python基础课程\12.python的bug定位与调试\95.python的traceback模块.py", line 8, in
traceback.print_exc()
NameError: name 'traceback' is not defined 97.如何在pycharm中调试代码
断点：程序运行到此处，暂时挂起，停止运行。此时可以详细观察程序的运行情况，方便做出进一步判断
进入调试视图：
1.单击右上角工具栏的Debug按钮
2.右键单击编辑区，点击Debug
3.快捷键：shift+F9
综合练习-学员管理系统
def show_menu():
'''显示菜单'''
print(' 学员信息管理系统 '.center(24, '='))
print(' 1.管理员登录\t\t2.新增学员信息\n 3.修改学员信息\t'
'4.删除学员信息\n 5.查询学员信息\t6.退出系统')
print('-'*29)
def admin_login():
"""管理员登录"""
global check_login
if check_login == 0:
while True:
user_str = input('请输入用户名：')
if user_str == admin_user:
while True:
user_pwd = input('请输入密码：')
if user_pwd == admin_pwd:
check_login = 1 # 表示已登录
print('登录成功！')
return
else:
print('密码错误！请重新输入')
else:
print('用户名不存在！请重新输入')
else:
print('请勿重复登录！')
def add_student():
"""新增学员信息"""
global stu_list, stu_dict
add_stop = 1
if check_login == 1: # 判断是否登录
print('-'*29)
print('新增学员信息')
while add_stop != 0:
id_str = input('请输入学员ID：')
for stu_dict in stu_list:
if id_str == stu_dict['id']:
add_stop = input('此ID已存在！ 1.修改此学员信息\t'
'2.重新添加\t3.返回主界面\t')
if add_stop == '2':
break
elif add_stop == '3':
return
else:
name_str = input('请输入学员姓名：')
tel_str = input('请输入学员电话：')
stu_dict = {'id':id_str, 'name':name_str, 'tel':tel_str}
stu_list.append(stu_dict)
print(f'添加成功！ ID：{id_str}\t姓名：{name_str}\t 电话：{tel_str}')
add_stop = deal_input_info('1.继续添加\t2.返回主界面\t')
else:
print('请先登录！')
def deal_student():
"""修改学员信息"""
global stu_list, stu_dict
deal_stop = 1
if check_login == 1:
print('-'*29)
print('修改学员信息')
while deal_stop != 0:
deal_str = input('请输入要修改的学员姓名或ID：')
for stu_dict in stu_list:
if deal_str in [stu_dict['id'], stu_dict['name']]:
print(f"学员信息： ID：{stu_dict['id']}\t姓名："
f"{stu_dict['name']}\t\t电话：{stu_dict['tel']}")
stu_dict['id'] = deal_input_info('ID（回车不修改）：',
2, stu_dict['id'])
stu_dict['name'] = deal_input_info('姓名（回车不修改）：',
2, stu_dict['name'])
stu_dict['tel'] = deal_input_info('电话（回车不修改）：',
2, stu_dict['tel'])
print(f"修改成功！ ID：{stu_dict['id']}\t姓名："
f"{stu_dict['name']}\t 电话：{stu_dict['tel']}")
deal_stop = deal_input_info('1.继续修改\t2.返回主界面\t')
if deal_stop == 1:
break
else:
return
else:
deal_stop = deal_input_info('抱歉，未找到此学员信息。 '
'1.重新输入\t2.返回主界面\t')
else:
print('请先登录！')
def del_student():
"""删除学员信息"""
global stu_list, stu_dict
del_stop = 1
if check_login == 1:
print('-'*29)
print('删除学员信息')
while del_stop != 0:
del_str = input('请输入要删除的学员ID或姓名：')
for stu_dict in stu_list:
if del_str in [stu_dict['id'], stu_dict['name']]:
print(f"学员信息：学号：{stu_dict['id']}\t姓名：{stu_dict['name']}"
f"\t 电话：{stu_dict['tel']}")
del_stop = deal_input_info('1.确认删除\t2.返回主界面\t')
if del_stop == 1:
stu_list.remove(stu_dict)
del_stop = deal_input_info('操作成功！\t1.继续删除\t2.返回主界面\t')
if del_stop == 1:
break
else:
return
else:
return
else:
del_stop = deal_input_info('抱歉，未找到此学员信息。1.重新输入\t'
'2.返回主界面\t')
else:
print('请先登录！')
def find_student():
"""查看学员信息"""
global stu_list, stu_dict
find_stop = 1
if check_login == 1:
print('-'*29)
print('查找学员信息')
choice = deal_input_info('1.查找学员信息\t2.查看所有学员信息\t')
if choice == 1:
while find_stop != 0:
find_list = []
find_str = input('请输入学员的姓名或ID：')
for stu_dict in stu_list:
if find_str in [stu_dict['id'], stu_dict['name']]:
find_list.append(stu_dict)
if len(find_list) != 0:
for data_dict in find_list:
print(f"学号：{data_dict['id']}\t姓名：{data_dict['name']}"
f"\t 电话：{data_dict['tel']}")
find_list.clear()
find_stop = deal_input_info('1.继续查找\t2.返回主界面\t')
if find_stop == 1:
continue
else:
return
else:
find_stop = deal_input_info('抱歉，未找到此学员信息。'
'1.继续查找\t2.返回主界面\t')
else:
print('-'*29)
for stu_dict in stu_list:
print(f"学号：{stu_dict['id']}\t姓名：{stu_dict['name']}"
f"\t 电话：{stu_dict['tel']}")
find_stop = deal_input_info('1.修改学员信息\t2.返回主界面\t')
if find_stop == 1:
deal_student()
else:
return
else:
print('请先登录！')
def deal_input_info(user_input, tip_message=1, result_str='0'):
"""处理输入信息"""
input_str = input(user_input)
if tip_message == 1:
if input_str == '1':
return 1
else:
return 0
elif tip_message == 2:
if len(input_str) == 0:
return result_str
else:
return input_str
def main():
while True:
show_menu()
action_str = input('请选择希望执行的操作：')
if action_str in ['1', '2', '3', '4', '5', '6']:
if action_str == '1': # 管理员登录
admin_login()
elif action_str == '2': # 新增学员信息
add_student()
elif action_str == '3': # 修改学员信息
deal_student()
elif action_str == '4': # 删除学员信息
del_student()
elif action_str == '5': # 查询学员信息
find_student()
elif action_str == '6': # 退出系统
print('感谢使用！')
return
else:
print('输入信息错误，请重新输入！')
if __name__ == '__main__':
stu_list = [] # 存放所有学员信息
stu_dict = {} # 存放学员的详细信息
check_login = 0 # 判断管理员是否登录
admin_user, admin_pwd = 'admin', '123456' # 管理员账号密码
main()十五.Python中的类与对象
98.软件编程思想
面向过程：事物比较简单，可以用线性的思维去解决，是一种以事件为中心的编程思想，把任务划分为一个一个步骤，按步骤顺序执行
例如：下象棋程序，面向过程的方式为：1.开始游戏-2.红方先手-3.绘制棋盘-4.判断输赢-5.轮到黑方-6.绘制棋盘-7.判断输赢-8.返回步骤2-9.输出最终结果
面向对象：事物比较复杂，用简单的线性思维无法解决，是一种以对象为中心的编程思想，把问题分解成各个对象，建立对象的目的不是为完成步骤，是描述某个对象在问题的步骤中的属性和行为
例如：同样的下象棋程序，面向对象的方式为：首先将整个下象棋游戏分为3个对象：
1.红黑双方：双方行为属性一致
2.棋盘绘制系统：负责绘制棋盘
3.裁判系统：负责判断输赢
两者优缺点分析：
面向过程 优点：流程明确，开发前基本考虑了实现方式和最终结果，步骤清楚，便于节点分析；效率高，面向过程注重代码精简，善于结合数据结构开发高效率程序
缺点：需要深入思考，耗费精力，代码重用性低，扩展能力差，后期维护难度较大
面向对象 优点：结构清晰，程序模块化和结构化，更加符合人类的思维方式；易扩展，代码重用率高，可继承，可覆盖，可以设计出低耦合的系统；易维护，系统低耦合的特点有利于减少程序的后期维护工作量
缺点：开销大，当要修改对象内部时，对象的属性不允许外部直接存取，所以要增加许多没有其他意义、只负责读或写的行为。这会为编程工作增加负担，增加运行开销，并且使程序显得臃肿；性能低，由于面向更高的逻辑抽象层，使得面向对象在实现的时候，不得不做出性能上面的牺牲，计算时间和空间存储大小都开销很大
99.类与对象
类：类是对具有相同属性（字段或者成员变量）和行为（法）的一组对象的抽象，对一类对象的统称。
对象：对象就是每个类的具体化的实例，是现实世界客观存在的。
100.python中的类定义
在面向对象开发前，应首先分析需求，明确程序中应包含哪些类
类通常包含三个要素：
1.类名：需满足大驼峰命名法：首字母大写，多个单词直接相连，不加_
2.属性：这类事物具有什么样的特征
3.方法：这类事物具有什么样的行为
使用dir(object)可以查看对象包含的所有属性和方法
常用的内置方法：
1.__new__：创建对象时，会被自动调用
2.__init__：对象被初始化时，会被自动调用
3.__del__：对象被从内存中销毁前，会被自动调用
4.__str__：返回对象的描述信息，print函数输出使用
'''需求：小猫爱吃鱼，小猫爱喝水'''
class Cat:
def eat(self):
print('小猫爱吃鱼')
def drink(self):
print('小猫爱喝水')
'''创建属于Cat类的对象，并调用其中的方法
等号右侧创建变量，等号左侧的变量负责对这个对象进行引用'''
Tom = Cat()
Tom.eat()
Tom.drink()
print(Tom)
print('%x'%id(Tom))
'''同一个类可以创建多个不同对象，内存地址各不相同'''
Bob = Cat()
Bob.eat()
Bob.drink()
print(Bob)
Bob2 = Bob
print(Bob2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小猫爱吃鱼
小猫爱喝水
<__main__.Cat object at 0x000001D15C620B20>
1d15c620b20
小猫爱吃鱼
小猫爱喝水
<__main__.Cat object at 0x000001D15C5E6920>
<__main__.Cat object at 0x000001D15C5E6920>101.给对象单独增加方法或属性
'''在不改变类的情况下给对象增加方法属性（不推荐使用）'''
class Cat:
def eat(self):
print('小猫爱吃鱼')
def drink(self):
print('小猫爱喝水')
Tom = Cat()
'''给Tom对象增加name属性'''
Tom.name = '汤姆'
Tom.eat()
Tom.drink()
print(Tom.name)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小猫爱吃鱼
小猫爱喝水
汤姆102.使用self在类封装的方法中输出对象的属性
'''对象在引用类的方法时，self表示对象自身'''
class Cat:
def eat(self):
print('%s爱吃鱼'%self.name)
def drink(self):
print('%s爱喝水'%self.name)
Tom = Cat()
Jerry = Cat()
Tom.name = '汤姆'
Jerry.name = '杰瑞'
Tom.eat()
Jerry.eat()
Tom.drink()
Jerry.drink()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
汤姆爱吃鱼
杰瑞爱吃鱼
汤姆爱喝水
杰瑞爱喝水103.创建对象时自动调用初始化方法
当使用类创建对象时，会自动执行以下操作：
1.为列表在内存中分配空间——创建对象
2.为对象的属性设置初始值——初始化方法（init）
__init__方法是专门用来定义一个类具有哪些属性的方法
在__init__方法内部使用self.属性名=属性的初始值，就可以定义属性，定义属性后，再使用类创建的对象都会拥有该属性
'''创建对象时会自动调用初始化方法'''
class Cat:
def __init__(self):
print('这是一个初始化方法：')
self.name = '汤姆'
def eat(self):
print('%s爱吃鱼'%self.name)
def drink(self):
print('%s爱喝水'%self.name)
Tom = Cat()
Tom.eat()
Tom.drink()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
这是一个初始化方法：
汤姆爱吃鱼
汤姆爱喝水104.初始化方法改进——使用参数设置属性初始值
class Cat:
def __init__(self,new_name,new_age,new_height):
self.name = new_name
self.age = new_age
self.height = new_height
def eat(self):
print('%s今年%d岁，身高%.2f，爱吃鱼'%(self.name,self.age,self.height))
def drink(self):
print('%s爱喝水'%self.name)
Tom = Cat('汤姆',3,30.5)
Tom.eat()
Tom.drink()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
汤姆今年3岁，身高30.50，爱吃鱼
汤姆爱喝水105. del方法和对象的生命周期
.__del__：对象被从内存中销毁前，会被自动调用
一个对象从调用类名()开始被创建，生命周期开始
一个对象的__del__方法一旦被调用，生命周期结束
在对象的生命周期内，可以访问对象属性，或者让对象调用方法
class Cat:
def __init__(self, new_name):
self.name = new_name
def come(self):
print('%s来了'%self.name)
def __del__(self):
print('{}走了'.format(self.name))
'''因为Tom是个全局变量，所以在程序完成后才会自动调用__del__方法'''
Tom = Cat('汤姆')
Tom.come()
print('-'*30)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
汤姆来了
------------------------------
汤姆走了106.__str__方法定制变量输出信息
使用print输出对象变量时，默认情况会输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址（16进制）
使用__str__方法可以自定义print输出对象变量时的内容（__str__方法必须返回一个字符串）
class Cat:
def __init__(self,new_name):
self.name = new_name
def come(self):
print('%s来了'%self.name)
def __del__(self):
print('%s走了'%self.name)
'''__str__方法必须返回一个字符串'''
def __str__(self):
return '这是一只小猫[%s]'%self.name
Tom = Cat('汤姆')
Tom.come()
print(Tom)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
汤姆来了
这是一只小猫[汤姆]
汤姆走了十六.面向对象封装案例
107.封装特性和需求分析
需求： 1.小明体重80kg，小美50kg
2.每次跑步减肥1.5kg
3.每次吃东西体重增加1kg
分析：类名——Person
属性——name weight
行为——run eat
同一个类创建的多个对象之间，属性互不干扰
class Person:
def __init__(self, n_name, n_weight):
self.name = n_name
self.weight = n_weight
def run(self):
self.weight -= 1.5
def eat(self):
self.weight += 1
def __del__(self):
print('%s现在的体重为%.2f'%(self.name, self.weight))
def __str__(self):
return '%s正在跑步减肥'%self.name
name1 = Person('小明', 80)
name2 = Person('小美', 50)
for i in range(1,4):
name1.run()
name2.run()
print('%s跑第%d次步，体重减了%.1f斤'%(name1.name, i, i*1.5))
for i in range(1,3):
name1.eat()
name2.eat()
print('%s吃第%d顿饭，体重增加了%.1f斤'%(name1.name, i, i*1))
print(name1)
print(name2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小明跑第1次步，体重减了1.5斤
小明跑第2次步，体重减了3.0斤
小明跑第3次步，体重减了4.5斤
小明吃第1顿饭，体重增加了1.0斤
小明吃第2顿饭，体重增加了2.0斤
小明正在跑步减肥
小美正在跑步减肥
小明现在的体重为77.50
小美现在的体重为47.50108.需求分析——被使用的类应该先开发
需求：1.房子有 户型、总面积、家具名称列表（新房子没有任何家具）
2.家具有名字、占地面积，其中席梦思占地4平米,衣柜占地2平米，餐桌占地1.5平米
3.将以上3件家具添加到房子中
4.要求输出房子的户型、总面积、剩余面积、家具名称列表
'''分析：需要创建一个房子类，包含属性：户型、总面积、剩余面积、家具列表,包含添加家具的方法
再需要创建一个家具类，包含属性：名字、占地面积
由于家具类会在房子类中被使用，所以应优先创建'''
'''创建家具类'''
class Items:
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '%s,占地面积为%.1f平方米'%(self.name, self.area)
'''创建房子类'''
class House:
def __init__(self,house_type,area):
self.house_type = house_type
self.area = area
self.free_area = area
self.item_list = []
def add_item(self,item):
if item.area > self.free_area:
print('%s太大了，无法添加'%item.name)
return
self.item_list.append(item.name)
print(f'添加了{item.name}')
self.free_area -= item.area
def __str__(self):
item_list = '、'.join(self.item_list)
return ('房子的户型是{}，总面积为{:.1f}平方米，房子里的家具有{}，剩余面积为{:.1f}平方米'
.format(self.house_type, self.area, item_list, self.free_area))
bed = Items('席梦思', 4)
big_bed = Items('大席梦思', 20)
big_table = Items('大餐桌', 40)
chest = Items('衣柜', 2)
table = Items('餐桌', 1.5)
print(bed,chest,table,sep='\n')
my_house = House('两室一厅', 60)
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
my_house.add_item(big_bed)
my_house.add_item(big_table)
print(my_house)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
席梦思,占地面积为4.0平方米
衣柜,占地面积为2.0平方米
餐桌,占地面积为1.5平方米
添加了席梦思
添加了衣柜
添加了餐桌
添加了大席梦思
大餐桌太大了，无法添加
房子的户型是两室一厅，总面积为60.0平方米，房子里的家具有席梦思、衣柜、餐桌、大席梦思，剩余面积为32.5平方米109.类的属性可以是另一个类创建的对象
需求：1.士兵小强有一把枪
2.不同型号的枪初始子弹数量不一样
3.士兵可以开火
4.枪可以发射子弹
5.枪可以装填子弹——增加子弹数量
'''分析：创建一个枪类(会被使用的类先创建)：1.枪的型号 2.子弹数量 3.装填子弹 4.发射子弹
创建一个士兵类：1.姓名、年龄、拥有枪型号(没有可设置为None) 2.有枪才能发起冲锋 3.射击'''
class Gun:
def __init__(self,model): # 初始化枪型号
self.model = model
if self.model == 'AK47': # 不同型号初始子弹数不一样
self.bullet_count = 30
elif self.model == 'M4':
self.bullet_count = 35
elif self.model == 'AMG':
self.bullet_count = 10
else:
self.bullet_count = 0
def add_bullet(self,count):
self.count = count # 装填子弹
self.bullet_count += count
print('[%s]装填了[%d]发子弹...现在有[%d]发子弹'%(self.model, self.count, self.bullet_count))
def shoot(self):
if self.bullet_count <= 0:
print('%s没有子弹了...'%self.model)
return
self.bullet_count -= 1
print('[%s]哒哒哒...[%d]'%(self.model, self.bullet_count))
def __str__(self):
return '枪型号：[%s] 剩余子弹数：[%d]'%(self.model, self.bullet_count)
class Soldier:
def __init__(self,name,age):
self.name = name
self.age = age
self.gun = None # 在士兵类中创建枪属性（新兵没有枪）
def fire(self):
if self.gun is None: # 这里用is比==更严谨，判断是否为对同一对象的引用
print('%s是新兵，还没有枪，无法冲锋'%self.name)
return
print('[%s]发起了冲锋...'%self.name)
self.gun.add_bullet(30) # 通过枪对象调用枪类里的装填子弹属性
self.gun.shoot() # 调用枪类里的射击属性
def __str__(self):
return '士兵姓名：%s，年龄：%d，持有枪型号：%s'%(self.name, self.age, self.gun.model)
ak47 = Gun('AK47')
m4 = Gun('M4')
amg = Gun('AMG')
xiaoqiang = Soldier('小强',21)
xiaoqiang.fire()
xiaoqiang.gun = ak47 # 将一个枪对象赋给士兵类的枪属性（发枪）
xiaoqiang.fire()
print(ak47)
print(xiaoqiang)
xiaoming = Soldier('小明',19)
xiaoming.gun = amg
xiaoming.fire()
print(xiaoming)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小强是新兵，还没有枪，无法冲锋
[小强]发起了冲锋...
[AK47]装填了[30]发子弹...现在有[60]发子弹
[AK47]哒哒哒...[59]
枪型号：[AK47] 剩余子弹数：[59]
士兵姓名：小强，年龄：21，持有枪型号：AK47
[小明]发起了冲锋...
[AMG]装填了[30]发子弹...现在有[40]发子弹
[AMG]哒哒哒...[39]
士兵姓名：小明，年龄：19，持有枪型号：AMG110.私有属性和私有方法
在开发中，对象的某些属性或方法可能只希望在对象内部被调用，而不被外部访问
私有属性就是对象不希望公开的属性，私有方法就是对象不希望公开的方法
定义私有属性或方法：在属性或方法名前面增加两个下划线
使用_类名__私有属性名 可以强行访问私有属性，但不推荐使用
class Women:
def __init__(self,name):
self.name = name
self.__age = 18
def secret(self):
print('%s的年龄是%d'%(self.name, self.__age)) # 在对象的方法内部可以访问私有属性
xiaofang = Women('小芳')
# print(xiaofang.__age) 外部无法直接访问私有属性
xiaofang.secret()
print(xiaofang._Women__age) # 使用_类名__私有属性名 可以强行访问私有属性，但不推荐使用
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小芳的年龄是18
18111.单继承
面向对象三大特点：封装、继承、多态，其中继承实现代码的重用，相同的代码不需要重复的编写
子类拥有父类的所有方法和属性，继承具有传递性，即父类（基类）的所有方法和属性被其子类及子类的子类...共同继承
class Animal:
def eat(self):
print('吃')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
'''括号中是父类，子类拥有父类所有属性和方法'''
class Dog(Animal):
def bark(self):
print('汪汪汪')
wang = Dog()
wang.eat()
wang.drink()
wang.run()
wang.sleep()
wang.bark()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
吃
喝
跑
睡
汪汪汪112.方法的重写
在开发中，如果父类的方法实现与子类的完全不同，或需要进行扩展，可以在子类中直接编写与父类同名的方法，对父类方法进行覆盖，子类运行时只会调用子类重写的方法，不会调用父类封装的方法。如果同时又需要继续使用父类方法，可事先定义super().父类方法来调用父类方法执行，或者用父类名.父类方法来调用（不推荐 ，如果将父类名写成子类名会出现递归调用，进入死循环）
class Animal:
def eat(self):
print('吃')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
'''括号中是父类或称为基类，子类（派生类）拥有父类所有属性和方法'''
class Dog(Animal):
def bark(self):
print('汪汪汪')
'''子类的子类同样继承基类的所有属性方法，同时继承其父类的所有属性方法'''
class xiaotianquan(Dog):
def fly(self):
print('我会飞')
def bark(self):
print('叫的跟神一样...')
super().bark() # 使用super().父类方法继续调用父类方法
xtq = xiaotianquan()
xtq.bark()
xtq.fly()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
叫的跟神一样...
汪汪汪
我会飞113.私有方法属性子类不能直接访问
子类对象不能在自己的方法内部，直接访问父类的私有方法属性，但可以通过父类的公有方法间接访问其私有属性方法
class A:
def __init__(self):
self.__name = 'James'
def text(self):
self.__age = 21
print('父类的公有方法下间接访问私有方法%s %d'%(self.__name, self.__age))
class B(A):
pass
b = B()
b.text()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
父类的公有方法下间接访问私有方法James 21114.多继承
子类可以拥有多个父类，并且具有所有父类的属性和方法，语法：class 子类(父类1,父类2...)
注意事项；避免多个父类之间出现同名方法或属性
class A:
def test1(self):
print('这是第一个父类的方法')
class B:
def test2(self):
print('这是第二个父类的方法')
class C(A, B):
pass
c = C()
c.test1()
c.test2()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
这是第一个父类的方法
这是第二个父类的方法115.面向对象的多态性
多态指的是不同的子类对象，调用相同的父类方法时，产生不同的执行结果
多态可以增加代码的灵活度
以继承和重写父类方法为前提
是调用方法的技巧，不会影响到类的内部设计
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print('%s蹦蹦跳跳玩耍'%self.name)
class Xiaotianquan(Dog):
def game(self):
print('%s飞到天上玩耍'%self.name)
'''在Person类中，只需要让狗对象调用game方法，而不需要关心是什么狗
程序执行时，传入不同的狗对象实参，就会产生不同的运行效果'''
class Person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print('%s带着%s一起玩耍'%(self.name, dog.name))
dog.game()
xiaoming = Person('小明')
wangcai = Dog('旺财')
xtq = Xiaotianquan('哮天犬')
xiaoming.game_with_dog(wangcai)
xiaoming.game_with_dog(xtq)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小明带着旺财一起玩耍
旺财蹦蹦跳跳玩耍
小明带着哮天犬一起玩耍
哮天犬飞到天上玩耍116.类属性
创建出来的对象叫做类的实例
创建对象的动作叫做实例
对象的属性叫实例属性
对象调用的方法叫做实例方法(self)
每个对象都有自己独立的内存空间，保存各自不同的属性
多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用传入方法内部
类是一种特殊的对象，类对象在内存中只有一份，使用一个类可以创建除很多个对象实例
除了封装实例的属性和方法外，类对象还可以拥有自己的属性和方法
类属性通常用来记录与这个类相关的特征，不会记录具体对象的特征
'''需求：创建一个工具类，统计这个类创建了多少个对象'''
class Tool(object):
count = 0 # 定义一个变量作为类属性，用来累加计数
def __init__(self,name): # 每次创建对象，都会调用初始化方法
Tool.count += 1 # 每次调用初始化方法都会使得count+1
t1 = Tool('螺丝刀')
t2 = Tool('扳手')
t3 = Tool('榔头')
print(Tool.count)
print(t1.count) # 利用属性获取的向上查找机制（不推荐）
t1.count = 99 # 并不会改变Tool.count的值，而是会给t1对象创建一个实例属性count,再赋值99
print('t1工具的属性值',t1.count)
print('类属性的值',Tool.count)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
3
3
t1工具的属性值 99
类属性的值 3117.类方法和静态方法
类方法需要用修饰器@clssmethod来标识，告诉解释器这是一个类方法
类方法的第一个参数一般是Cls ，也可使用其他名称，但普遍使用Cls
由哪一个类调用的方法，方法内的cls就是哪一个类的引用(和实例方法第1参数是self相似)
通过类名.调用类方法，调用时，不需要传递cls参数
在方法内部，可以通过cls.访问类的属性，也可以通过cls.调用其他的类方法
在开发时，如果需要在类中封装一个方法，而这个方法既不需要访问实例属性和实例方法，也不需要访问类属性或者调用类方法，就可以把这个方法封装成静态方法：上方用@staticmethod标识，调用时直接使用类名.静态方法，无需创建对象
118.方法综合
案例分析： 需求：设计一个Game类，要求显示游戏帮助信息，显示历史最高分，并且记录当前玩家的姓名，以及开始游戏
分析： 属性： 1.定义一个类属性top_score 记录游戏最高分
2.定义一个实例属性player_name记录当前游戏的玩家姓名
方法： 1.静态方法show_help显示游戏帮助信息
2.类方法show_top_score显示历史最高分
3.实例方法start_game开始当前玩家的游戏
'''需求：设计一个Game类，要求显示游戏帮助信息，显示历史最高分，并且记录当前玩家的姓名，以及开始游戏'''
class Game(object):
top_score = 0
@staticmethod
def show_help():
print('帮助信息：阻止僵尸进攻')
@classmethod
def show_top_score(cls):
print('当前游戏最高分：%d'%cls.top_score)
def __init__(self, player_name):
self.player_name = player_name
print('当前玩家：%s'%self.player_name)
def start_game(self):
print('%s开始游戏...'%self.player_name)
# 查看游戏帮助信息
Game.show_help()
# 查看历史最高分
Game.show_top_score()
# 创建游戏对象
player1 = Game('小明')
player1.start_game()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
帮助信息：阻止僵尸进攻
当前游戏最高分：0
当前玩家：小明
小明开始游戏...119.动态绑定属性和方法
python是动态语言，在创建对象之后，可以动态地绑定属性和方法
class Student(object):
def __init__(self, name):
self.name = name
stu1 = Student('小明')
stu2 = Student('小美')
'''给两个对象分别绑定动态属性'''
stu1.address = 'chongqing'
stu2.age = 18
print(stu1.name, stu1.address)
print(stu2.name, stu2.age)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
小明 chongqing
小美 18120.类的赋值与拷贝
class Father(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return '%s, %d岁, %s\t'%(self.name, self.age, id(self))
class Mother(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return '%s, %d岁, %s\t'%(self.name, self.age, id(self))
class Family(object):
def __init__(self, father, mother):
self.father = father
self.mother = mother
def __str__(self):
return '爸爸是%s，妈妈是%s\t%s'%(self.father, self.mother, id(self))
f1 = Father('张三', 30)
f2 = f1
print(f1, f2)
m1 = Mother('小美', 22)
fa1 = Family(f1, m1)
print(fa1)
'''浅拷贝'''
import copy
fa2 = copy.copy(fa1)
print(fa2)
'''深拷贝'''
fa3 = copy.deepcopy(fa1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
张三, 30岁, 2041995149264 张三, 30岁, 2041995149264
爸爸是张三, 30岁, 2041995149264 ，妈妈是小美, 22岁, 2041995148976 2041995148880
爸爸是张三, 30岁, 2041995149264 ，妈妈是小美, 22岁, 2041995148976 2041995148688类的组合
不要试图在一个类里定义出所有能想到的特性和方法，应该利用继承和组合机制进行扩展。
用不同的词性命名，如属性名用名词，方法名用动词。
class Fish(object):
def __init__(self, x):
self.num = x
class Turtle(object):
def __init__(self, y):
self.num = y
class Pool(object):
def __init__(self, x, y): # 将实例化的鱼类和乌龟类组合到水池类中
self.fish = Fish(x)
self.turtle = Turtle(y)
def print_num(self):
print("水池里共有%d只鱼，%d只乌龟"%(self.fish.num, self.turtle.num))
p = Pool(3, 12)
p.print_num()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
水池里共有3只鱼，12只乌龟类相关的一些内置函数（BIF）
issubclass(class, classinfo)：判断class是否classinfo的子类，classinfo可以是元组，class是元组中任何候选类的子类，返回True
isinstance(object, classinfo)：检查实例对象object是否属于类classinfo,classinfo可以是元组
hasattr(object, name)：判断对象是否具有某属性，属性名name加''
getattr(object, name, default)：返回对象指定的属性name的值，如果name不存在报错（若指定了default，则返回default的内容）
setattr(object, name, value)：给对象的name属性设置值，若属性不存在，会新建一个name属性并设置值
delattr(object, name)：删除对象的某个属性name
priperty(fget=None, fset=None, fdef=None, doc=None)：通过属性设置属性
class C(object):
def __init__(self, size=10):
self.size = size
def get_size(self):
return self.size
def set_size(self, value):
self.size = value
def del_size(self):
del self.size
x = property(get_size, set_size, del_size)
a = C()
print(a.get_size())
print(a.x)
a.x = 18 # 相当于a.set_size(18)
print(a.x)
del a.x # 相当于a.del_size()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
10
10
18魔法方法案例1
class Capstr(str):
def __new__(cls, string): # 重写str的__new__方法，将传入的字母变为大写
string = super().__new__(cls, string).upper()
# string = string.upper()
# return str.__new__(cls, string)
return string
s = Capstr('hello')
print(s)
class A(object):
def __init__(self):
print('我是__init__方法，我被调用了...')
def __del__(self):
print('我是__del__方法，我被调用了...')
a1 = A()
a2 = a1
del a2 # 这里a2不会执行，因为__del__方法只有当对象的所有引用被执行后才会生效
del a1
'''重写int类的__add__和__sub__方法'''
class New_int(int):
def __add__(self, other):
return int.__sub__(self, other)
def __sub__(self, other):
return int.__add__(self, other)
a = New_int(8)
b = New_int(9)
print(a + b)
print(a - b)
'''需求：定制一个计时器的类，start和stop方法代表启动计时和停止计时；假设计时器对象t1,print(t1)和
直接调用t1均显示结果；当计时器未启动或已经停止计时，调用stop方法会给与温馨提示；两个计时器
对象可以进行相加：t1+t2；只能使用提供的有限资源完成'''
import time as t
class My_Timer(object):
def __init__(self):
self.unit = ['年', '月', '天', '小时', '分钟', '秒']
self.prompt = '未开始计时！'
self.lasted = []
self.begin = 0 # 此处应注意避免与方法名start等重名，重名后属性会覆盖方法
self.end = 0
def __str__(self):
return self.prompt
__repr__ = __str__
# 开始计时
def start(self):
self.begin = t.localtime()
print('计时开始...')
# 停止计时
def stop(self):
self.end = t.localtime()
self._calc()
print('计时结束!')
# 内部方法：计算运行时间
def _calc(self):
self.lasted = []
self.prompt = '总共运行了'
for index in range(6): # localtime获取的时间信息为列表，前6个元素为年月日时分秒
self.lasted.append(self.end[index] - self.begin[index])
if self.lasted[index]:
self.prompt += (str(self.lasted[index])+self.unit[index])
t1 = My_Timer()
t1.start()
t.sleep(3)
t1.stop()
print(t1)魔法方法案例2
'''__getattr__(self,name,default)：定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self,name)：定义当该类的属性被访问时的行为
__setattr__(self,name,value)：定义当一个属性被设置时的行为
__delattr__(self,name)：定义当一个属性被删除时的行为'''
class A():
def __getattribute__(self, name):
print('getattribute')
return super().__getattribute__(name)
def __getattr__(self, name):
print('getattr')
def __setattr__(self, name, value):
print('setattr')
super().__setattr__(name, value)
def __delattr__(self, name):
print('delattr')
a = A()
a.x
a.x = 1
del a.x
'''需求：定义一个矩形类，默认有宽和高两个属性，如果为一个名为square的属性赋值，则说明是一个正方形，
square的值就是正方形边长，此时宽和高应该都等于边长'''
class Rectangle(object):
def __init__(self, width, height):
self.width = width
self.height = height
def __setattr__(self, name, value):
if name == 'square':
self.width = value
self.height = value
else:
# self.__dict__[name] = value
super().__setattr__(name, value)
def getArea(self):
return self.width * self.height
r1 = Rectangle(4, 5)
print(r1.getArea())
r1.square = 10
print(r1.getArea())
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>..
运行结果：
getattribute
getattr
setattr
delattr
20
100描述符
描述符：将某种特殊类型的类的实例指派给另一个类的属性
特殊方法：__get__(self, instance, owner)：用于访问属性，返回属性的值
__set__(self, instance, value)：将在属性分配中调用，不返回任何内容
__delete__(self, instance)：控制删除操作，不返回任何内容
'''描述符：将某种特殊类型的类的实例指派给另一个类的属性
特殊方法：__get__(self, instance, owner)：用于访问属性，返回属性的值
__set__(self, instance, value)：将在属性分配中调用，不返回任何内容
__delete__(self, instance)：控制删除操作，不返回任何内容'''
class MyDecriptor():
def __get__(self, instance, owner):
print('getting...', self, instance, owner)
def __set__(self, instance, value):
print('setting...', self, instance, value)
def __delete__(self, instance):
print('deleting...', self, instance)
class Test():
x = MyDecriptor() # 将MyDecriptor类的实例指派给Test类的x属性
test = Test()
test.x
test.x = 'x.man'
del test.x
'''property是一个描述符类'''
class MyProperty():
def __init__(self, fget=None, fset=None, fdel=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
def __get__(self, instance, owner):
return self.fget(instance)
def __set__(self, instance, value):
self.fset(instance, value)
def __delete__(self, instance):
self.fdel(instance)
class A():
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = MyProperty(getx, setx, delx)
a = A()
a.x = 'x-man'
print(a.x)
print(a._x)
del a.x
'''需求：1.定义一个温度类，然后定义两个描述符类，用于描述摄氏度和华氏度
2.要求两个属性会自动转换，比如给摄氏度赋值，打印出来华氏度的属性是自动转换后的结果'''
class Celslus():
def __init__(self, value=26.0):
self.value = float(value)
def __get__(self, instance, owner):
return self.value
def __set__(self, instance, value):
self.value = float(value)
class Fahrenheit():
def __get__(self, instance, owner):
return instance.cel*1.8+32
def __set__(self, instance, value):
instance.cel = (float(value) - 32)/1.8
class Temerature():
cel = Celslus()
fah = Fahrenheit()
t1 = Temerature()
print(t1.cel)
t1.cel = 32
print(t1.cel)
print(t1.fah)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
getting... <__main__.MyDecriptor object at 0x000001FF65E6FFD0> <__main__.Test object at 0x000001FF65E6F880>
setting... <__main__.MyDecriptor object at 0x000001FF65E6FFD0> <__main__.Test object at 0x000001FF65E6F880> x.man
deleting... <__main__.MyDecriptor object at 0x000001FF65E6FFD0> <__main__.Test object at 0x000001FF65E6F880>
x-man
x-man
26.0
32.0
89.6 定制序列
'''协议：与其他编程语言的接口类似，它规定哪些方法必须要定义，在python中，协议更像是一种指南
容器类型的协议：如果希望定制的容器是不可变的，只需要定义__len__和__getitem__方法
如果希望定制的容器是可变的，则除了__len__和__getitem__，还需要
__setitem__和__delitem__两个方法'''
'''容器类型的魔法方法：__len__(self)：定义当被len()调用时的行为（返回容器中元素的个数）
__getitem__(self,key)：定义获取容器中指定元素的行为，相当于self[key]
__setitem__(self,key,value)：定义设置容器中指定元素的行为，相当于self[key] = value
__delitem__(self,key)：定义删除容器中指定元素的行为，相当于del self[key]
__iter__(self)：定义当迭代容器中的元素的行为
__reversed__(self)：定义当被reversed调用时的行为
__contains__(self)：定义当使用成员测试运算符（in 或 not in）时的行为'''
'''需求：定制一个可变列表，要求记录列表中每个元素被访问的次数'''
class Mylist():
def __init__(self, *args):
self.values = [x for x in args]
self.count = {}.fromkeys(range(len(self.values)), 0)
def __len__(self):
return len(self.values)
def __getitem__(self, key):
self.count[key] += 1
return self.values[key]
def __setitem__(self, key, values):
self.values[key] = values
def __delitem__(self, key):
del self.values[key]
for i in range(key, len(self.values)):
self.count[i] = self.count[i + 1]
del self.count[len(self.values)]
l1 = Mylist(1,2,3,4,5)
print(l1[3], l1[4], l1[3])
print(l1.count)
l1[2] = 100
print(l1[2])
del l1[2]
print(l1.count)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
4 5 4
{0: 0, 1: 0, 2: 0, 3: 2, 4: 1}
100
{0: 0, 1: 0, 2: 2, 3: 1}十七.python的模块应用
121.模块基础概念
容器：数据的封装
函数：语句的封装
类：方法和属性的封装
模块：模块就是程序
122.模块的导入
import math
# 同from math import pi,pow,ceil,floor
print(id(math), type(math), math)
'''圆周率'''
print(math.pi) # 如果使用from math import pi，调用时前面不用加math.
'''math.pow(x,y) 求x的y次幂'''
print(math.pow(2, 5))
'''向上取整'''
print(math.ceil(9.001))
'''向下取整'''
print(math.floor(9.99))
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
1673987122704
3.141592653589793
32.0
10
9 123.python中的包（python package）
包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
作用：代码规范、避免模块冲突
包和目录的区别：包是带有特殊文件__init__.py的目录，可以是空文件，但必须存在，否则它就不能被导入或者包含其它的模块和嵌套包。 导入方式：import 包名.模块名
1.创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字
2.在文件夹中创建一个__init__.py的模块文件，内容可以为空
3.将相关的模块放入文件夹中
十八.Python中的文件操作
1.文件的基本操作
打开文件 读写文件（读:将文件内容读入内存，写:将内存内容写入文件） 关闭文件
操作文件的函数/方法：
open：打开文件，并且返回文件操作对象
read(size)：从文件指针处读取size个字符到内存,不填默认为指针后全部内容
readline：
write(str)：将字符串写入文件
writelines(seq)：向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象
close：关闭文件
tell：返回当前在文件中的位置
seek：移动文件指针，seek(偏移量, 起始位置)
起始位置：0：文件开头， 1：当前位置， 2.文件结尾
open函数：第1参数是要操作的文件名（区分大小写），如果文件存在，返回文件操作对象，如果文件不存在则抛出异常
第2参数是打开方式：
r：（默认模式）以只读方式打开文件，文件指针放在文件开头，如果文件不存在抛出异常
w：以只写方式打开文件，如果文件存在会被覆盖，如果文件不存在，创建新文件
a：以追加方式打开文件，如果文件存在，文件指针会放在文件末尾，如果文件不存在，创建新文件进行写入
b：以二进制模式打开文件
t：以文本模式打开（默认模式）
+：可读写模式（可添加到其他模式中使用）
u：通用换行符支持
第3参数是字符编码，如：encoding='utf-8'
第4参数是错误处理方式，一般为忽略：errors=‘ignore’
文件指针：文件指针标记从哪个位置开始提取数据
第一次打开文件时，通常文件指针会指向文件的开始位置
当执行了read方法后，文件指针会移动到读取内容的末尾
readline方法：一次读取一行内容，执行后，会把文件指针移动到下一行，准备再次读取
file = open('test1', 'w')
for i in range(10):
text1 = file.write('hello python\n')
file.close()
file = open('test1', 'r')
# text2 = file.read()
# print(text2)
while True:
# 读取一行内容
text3 = file.readline()
# 判断是否还有内容
if not text3:
break
# 因为每读取一行的末尾已经有了一个'\n'
print(text3, end='')
file.close() # 关闭文件
'''小文件复制'''
file_read = open('test1')
file_copy = open('test1_复件', 'w')
text4 = file_read.read()
text5 = file_copy.write(text4)
file_read.close()
file_copy.close()
'''大文件复制'''
file_read = open('test1')
file_copy = open('test1_复件2', 'w')
while True:
text6 = file_read.readline()
if not text6:
break
text7 = file_copy.write(text6)
file_read.close()
file_copy.close()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
hello python
hello python
hello python
hello python
hello python
hello python
hello python
hello python
hello python
hello python2.导入OS模块，执行文件和目录的管理操作
文件操作：
rename：重命名文件， os.rename(原文件名, 目标文件名)
remove：删除文件，os.remove(源文(原文件名)
目录操作：
listdir：获取目录列表，os.listdir(目录名)，目录名'.'表示当前目录，'..'表示上层目录
mkdir：创建目录，os.mkdir(目录名)，如果目录存在抛出异常
makedirs：递归创建多层目录，如果目录存在抛出异常
rmdir：删除目录，os.rmdir(目录名)
remuvedirs：递归删除多层目录，从子目录到父目录逐层删除，遇到非空目录抛出异常
getcwd：获取当前目录，os.getcwd()
chdir：修改工作目录，os.chdir(目标目录)
支持路径操作中常用到的一些定义：
os.curdir：指代当前目录(相当于'.')
os.pardir：指代上层目录(相当于'..')
os.sep：输出操作系统特定的路径分隔符（Win下为'\\', Linux下为'/'）
os.linesep：当前平台使用的行终止符（Win下为'\r\n', Linux下为'\n')
os.name：指代当前使用的操作系统（包括：'posix', 'nt', 'mac', 'os2', 'ce', 'java'）
os.path模块中关于路径常用的函数使用方法：
basename(path)：去掉目录路径，单独返回文件名
dirname(path)：去掉文件名，单独返回目录路径
join(path1, path2, ..])：将path1, path2各部分组成一个路径名
split(path)：分割文件名与路径，返回(f_path, f_name)的元组，如果完全使用目录，它也会将最后一个目录作为文件名分离，且不会判断文件或目录是否存在
splitext(path)：分离文件名与扩展名，返回(f_name, f_extension)的元组
getsize(file)：返回指定文件的尺寸，单位是字节
getatime(file)：返回指定文件最近的访问时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
getctime(file)：返回指定文件的创建时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
getmtime(file)：返回指定文件最新修改时间（浮点型秒数，可用time模块的gmtime()或localtime()函数换算）
以下函数返回值为True或False：
exists(path)：判断指定路径（目录或文件）是否存在
isabs(path)：判断指定路径是否为绝对路径
isdir(path)：判断指定路径是否存在且是一个目录
isfile(path)：判断指定路径是否存在且是一个文件
islink(path)：判断指定路径是否存在且是一个符号链接
ismount(path)：判断指定路径是否存在且是一个挂载点
samefile(path1,path2)：判断path1和path2两个路径是否指向同一个文件
# -*- encoding=gbk -*-
'''需求：文本内容为两人对话，将两人的对话内容(：后内容)分别保存在两个新文件中，并将====分割的部分分不同文件保存
如：boy_1,boy_2,boy_3 girl_1,girl_2,girl_3'''
import os
def save_file(boy, girl, count):
file_name_boy = 'boy_' + str(count) + '.txt'
file_name_girl = 'girl_' + str(count) + '.txt'
boy_file = open(file_name_boy, 'w', encoding='gbk')
girl_file = open(file_name_girl, 'w', encoding='gbk')
boy_file.writelines(boy)
girl_file.writelines(girl)
boy_file.close()
girl_file.close()
def split_file(filename):
address = os.getcwd() # 获取文件目录
os.mkdir(str(address) + '\\test0')
os.chdir(str(address) + '\\test0')
file = open(filename, 'r', encoding='gbk')
boy = []
girl = []
count = 1
for each_line in file:
if each_line[:6] != '======':
(role, line_spoken) = each_line.split('：', 1)
if role == '男':
boy.append(line_spoken)
elif role == '女':
girl.append(line_spoken)
else:
save_file(boy, girl, count)
boy = []
girl = []
count += 1
save_file(boy, girl, count)
file.close()
if __name__ == '__main__':
split_file(r'C:\Users\Administrator\Documents\python练习\test1.txt')十九.一闭三器
1.迭代器
'''迭代器是可迭代的对象，该对象包含值的可计数数字，可以遍历所有值，包含方法iter()和next()'''
# 列表、元组、集合、字典都是可迭代对象，是可迭代的容器，可以通过iter()方法获取迭代器
# 获取迭代器
str1 = iter('hello')
print(str1)
str1 = 'hello'.__iter__()
print(str1)
# 从迭代器中拿到数据：next()方法
print(next(str1))
print(next(str1))
print(next(str1))
print('-'*20)
li = [1,2,3,4,5]
li_iter = iter(li)
while True:
try:
print(li_iter.__next__())
except StopIteration:
break
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
h
e
l
--------------------
1
2
3
4
5
# 自定义迭代器
class Fibs():
def __init__(self, n=10):
self.a = 0
self.b = 1
self.n = n
def __iter__(self):
return self
def __next__(self):
self.a, self.b = self.b, self.a+self.b
if self.a > self.n:
raise StopIteration
return self.a
fib = Fibs(100)
for each in fib:
print(each)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.
运行结果：
1 1 2 3 5 8 13 21 34 55 892.生成器
'''生成器的本质就是迭代器，函数中创建生成器用关键词yield，生成器函数执行时，并不会执行函数，得到的是生成器
只要函数中出现了yield，这个函数就一定是生成器，可以返回数据，并且分段执行函数内容，通过next，执行到下一
个yield的位置'''
def func1():
print('12345')
yield 'hello'
res = func1()
print(res)
def func2():
print('这是第一段')
yield '暂停一下'
print('这是第二段')
yield '表演结束'
res = func2()
print(res.__next__())
print(res.__next__())
'''分段运行，节约内存'''
def demo():
li = []
for i in range(1,11):
li.append('香菇包')
yield li
a = demo()
print(a.__next__())
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
这是第一段
暂停一下
这是第二段
表演结束
['香菇包', '香菇包', '香菇包', '香菇包', '香菇包', '香菇包', '香菇包', '香菇包', '香菇包', '香菇包'] '''协同程序：可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始
生成器即是模仿协同程序的产物'''
def libs():
a = 0
b = 1
while True:
a, b = b, a+b
yield a
for each in libs():
if each > 100:
break
print(each, end=' ')
print()
'''列表、字典、集合推导式'''
a = [i for i in range(100) if not (i % 2) and i % 3]
print(a)
b = {i:i % 2 == 0 for i in range(10)}
print(b)
c = {i for i in [1,1,3,5,6,4,3,2,1]}
print(c)
'''生成器推导式'''
g = (i for i in range(10))
print(next(g), next(g), next(g))
for each in g:
print(each, end=' ')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
1 1 2 3 5 8 13 21 34 55 89
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}
{1, 2, 3, 4, 5, 6}
0 1 2
3 4 5 6 7 8 9 3.闭包
'''闭包的作用：保证数据安全
闭包的结构：内层函数对外层函数的局部变量的引用，内层函数被称为闭包'''
def outside():
print('我是外部函数')
def inside():
print('我是内部函数')
return inside
str = outside()
str()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果；
我是外部函数
我是内部函数4.装饰器
'''装饰器是闭包的一种应用，在更改原函数的前提下，给原函数增加功能'''
def extra(func):
print('开启外挂')
def inside(*args, **kwargs):
res = func(*args, **kwargs)
print('关闭外挂')
return res
return inside
@ extra
def play_cq(id, pwd, name):
print(f"{name}开始打boss")
return f'{name}获得了裁决之杖'
p1 = play_cq(123, 123, '小明')
print(p1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
运行结果：
开启外挂
小明开始打boss
关闭外挂
小明获得了裁决之杖