Python in BJ
环境设置IDLE"""用Pyhon设计第一个游戏"""
temp = input("不妨猜一下小甲鱼想的是哪个数字")
guess = int(temp)
if guess == 8:
print("你是小甲鱼的蛔虫吗")
print("哼，猜中了也没奖励")
else:
print("猜错啦，我想的是8")
print("游戏结束，不玩啦^_^")
print("'I love you,Let\'s go'")
'I love you,Let's go'
print("I love you.\nI love Life")
I love you.
I love Life
print(注意使用英文字符)
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
print(注意使用英文字符)
NameError: name '注意使用英文字符' is not defined
print("注意使用英文字符")
注意使用英文字符
print(attention for the English)
SyntaxError: invalid syntax. Perhaps you forgot a comma?
print(attention the english)
SyntaxError: invalid syntax. Perhaps you forgot a comma?
print("attention the english")
attention the english Day 1 中文也好，英文也罢，都要用引号包裹 wp231957 发表于 2022-9-27 08:04
中文也好，英文也罢，都要用引号包裹
{:10_270:} 本帖最后由 风一样的僧 于 2022-9-27 21:50 编辑
Day 2
1.怎么让\正常显示的两个方法
print("D:\three\two\one\now")
D: hree wo\one
ow
print("D:\\three\\two\\one\\now")
D:\three\two\one\now
print(r"D:\\three\\two\\one\\now")
D:\\three\\two\\one\\now
Alt+P可复制前一段代码到现在这一行
2.“”与''，数字与字符串的区别，字符串是文本
poetry="""
面朝大海，春暖花开
"""
print(poetry)
面朝大海，春暖花开
520+1314
1834
'520'+'1314'
'5201314'
3.乘法口诀与分行符
print("我每天爱你三千遍！"*3000)
print("我每天爱你三千遍！\n"*3000)
4.input和int的应用
temp=input("你是谁：")-----------input的内容会显示在用户的界面上，用于和用户交流
你是谁：我是你爸爸
print(temp)
我是你爸爸
temp=input("请输入一个数字：")
请输入一个数字：
temp=input("请输入一个数字：")
请输入一个数字：8
guess=int(temp)--------------------int 可将用户输入的字符串转换为数字，用于比较，字符串无法和数字作比较
print(guess)
8
5.比较运算符
3<4
True
5,4
(5, 4)
5<4
False
3<=3
True
5<=3
False
3==3
True
1==2
False
1!=2
True
3!=3
False
"改进我们的小游戏"
'改进我们的小游戏'
6.循环while，使用变量counts控制循环次数，break跳出一层循环体
counts=3
while counts>0:
print("iloveyou")
counts=counts-1
iloveyou
iloveyou
iloveyou
counts=3
while counts>0
SyntaxError: expected ':'
while counts>0:
print("iloveyou")
counts=counts-1
break
iloveyou
"""用Pyhon设计第一个游戏"""
counts=3
while counts>0:
temp = input("不妨猜一下小甲鱼想的是哪个数字")
guess = int(temp)
if guess == 8:
print("你是小甲鱼的蛔虫吗")
print("哼，猜中了也没奖励")
break
else:
if guess < 8:
print("小啦!")
else:
print("大啦！")
counts=counts-1--------------------------------------这里注意缩进位置，counts只能控制与之平行的代码
print("游戏结束，不玩啦^_^")
Day3
1.改进小游戏-下
import：导入模块的命令
random：python中的随机模块，生成随机数
randint（a，b）：随机模块中的函数，两个参数代表随机数的范围
"""用Pyhon设计第一个游戏"""
import random
answer=random.randint(1,10)
counts=3
while counts>0:
temp = input("不妨猜一下小甲鱼想的是哪个数字")
guess = int(temp)
if guess == answer:
print("你是小甲鱼的蛔虫吗")
print("哼，猜中了也没奖励")
break
else:
if guess < answer:
print("小啦!")
else:
print("大啦！")
counts=counts-1
print("游戏结束，不玩啦^_^")
2.对随机数的种子数据进行提取，getstate函数，实现对随机数的再现：
x=random.getstate()
random.randint(1,10)
4
random.randint(1,10)
8
random.randint(1,10)
1
random.randint(1,10)
9
random.setstate(x)
random.randint(1,10)
4
random.randint(1,10)
8
random.randint(1,10)
1
random.randint(1,10)
9
3.Python 的数字类型（上）
有整数，浮点数，复数三类
11122222/123123
90.33423487082024
6/2
3.0
0.1+0.2
0.30000000000000004
i=0
while i<1:
i=i+0.1
print(i)
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.0999999999999999
0.3==0.1+0.2
False
0.3<0.1+0.2
True
精准计算浮点数的模块:decimal
import decimal------------------------------import导入模块
a=decimal.Decimal('0.1')
b=decimal.Decimal('0.2')
print(a+b)
0.3
c=decimal.Decimal('0.3')
a+b==c
True
科学计数法：E
0.00005
5e-05-------------------------------------5*10的-5次方
复数：
1+2j-------------------------------1是实部，2j为虚部，均已浮点数的形式存放
(1+2j)
x=1+2j
x.real--------------------------------获取实部数值
1.0
x.imag------------------------------获取虚部数值
2.0
4.数字类型-下
//，地板除，向下取整
%，取余数，x%y=x除以y的余数
divmod（x，y）：返回（x//y,x%y）
abs(x),取x的绝对值，复数没有绝对值，有模，abs反馈的是复数的模
int(x),将X转换为整数
pow(x,y)计算x的y次方
X**Y，计算x的y次方
3/2
1.5
3//2
1
-3//2
-2
3%2
1
6%3
0
divmod(3,2)
(1, 1)
divmod(-3,2)
(-2, 1)
x=-520
abs(x)
520
z=1+2j
abs(z)
2.23606797749979
int("111")
111
int(1.2)
1
int(3.9)
3
pow(2,3)
8
2**3
8
Day 4
1.布尔函数
定义为false 的所有情况：
1.1定义为false的对象：None和False
1.2值为0的数字类型：0,0.0,0j，Decimal（0），Fraction（0,1）
1.3空的序列和集合：“”，（），【】，{}，set（），range（0）
bool(250)
True
bool("假")
True
bool('false')
True
bool(False)
False
bool("")
False
bool(" ")
True
bool(520)
True
bool(0.0)
False
bool(0j)
False
(bool(0))
False
bool(521)
True
if 520>250:------------------------------------------------------------if成立的条件为其后的描述为True
print("520>250!")
else:
print("510<250!")
520>250!
if bool(250):---------------------------------------------if成立的条件是其之后的描述为True
print("250!")
else:
print("520!")
250!
1==True
True
0==False
True
True+False
1
True-False
1
2.逻辑运算符，共三个：and，or，not
and：左右同时为true，结果为true
or：左右其中一个为true，结果为true
not：如果操作数为true，结果为false，反之亦然
3<4 and 4<5
True
3<4 and 4>5
False
3<4 or 4>3
True
3>2 or 3<4
True
3<2 or 4>5
False
not True
False
not 250
False
not 0
True
250
250
bool(250)
True
Python中任何对象都能直接进行真值测试（测试该对象的布尔类型值为True或者False），用于if或者while语句的条件判断，也可以作为布尔逻辑运算符的操作数
3.短路逻辑和运算符优先级
and与or都遵从短路逻辑：从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值。（如果第一个操作值就够用“”能够判断该命令是True还是False“”了，那也就不必往后算了,只显示影响结果的关键值）
3 and 4
4
4 or 5
4
"FishC" and "LOVE"
'LOVE'
"FishC" and 250
250
(not 1)or(0 and 1)or(3 and 4)or(5 and 6)
4
False or 0 or 4 or 5
4
运算符优先级（运算表达式时执行的先后顺序）---有一个表格，规定了运算的先后顺序
以下运算符优先级逐渐增高（or-and-not-比较类-加减-乘除）
not 1 or 0 and 1 or 3
3
0 or 1 and not 2
False
0 or 1 and False
False
0 or False
False 本帖最后由 风一样的僧 于 2022-9-30 21:32 编辑
Day5-1
1.流程图Flowchart与思维导图mind map
流程图绘制工具:Office Visio
流程图的绘制方法
函数在流程图中的绘制
思维导图的绘制思路，一般绘制方法
思维导图的绘制工具：mind manager
2.分支和循环（branch and loop）
分支结构if语句，共5种语法结构
2.1 判断一个条件，如果次条件成立，就执行其包含的某条语句或某个代码块（仅if）
if 2<3:
print("我在里面")
print("我也在里面")-----------------------这俩组成一个代码块（有相同的缩进量）
print("我在外面")
我在里面
我也在里面
我在外面
if 2>3:
print("我在里面")
print("我也在里面")
print("我在外面")
我在外面
2.2 判断一个条件，如果次条件成立，就执行其包含的某条语句或某个代码块；如果条件不成立，就执行另外的某条语句或某个代码块（if+else组合）
if "A"=="B":
print("A")
else:
print("B")
B
2.3 判断多个条件，如果第一个条件不成立，则继续判断第二个条件， 并依次类推（if+elif组合）
score=input("请输入你的分数：")
score=int(score)
if 0<=score<60:
print("D")
if 60<=score<80:
print("C")
if 80<=score<90:
print("B")
if 90<=score<100:
print("A")
if score==100:
print("S")
score=input("请输入你的分数：")
score=int(score)
if 0<=score<60:
print("D")
elif 60<=score<80:
print("C")
elif 80<=score<90:
print("B")
elif 90<=score<100:
print("A")
elif score==100:
print("S")
if+elif组合相比单纯的if叠加更高效，降低无效运算
2.4 在第三种情况均不成立时添加一个else，表示当以上条件均不成立时执行某条语句或某代码块（if+elif+else）
score=input("请输入你的分数：")
score=int(score)
if 0<=score<60:
print("D")
elif 60<=score<80:
print("C")
elif 80<=score<90:
print("B")
elif 90<=score<100:
print("A")
elif score==100:
print("S")
else:
print("请输入0——100之间的数值！")
请输入你的分数：101
请输入0——100之间的数值！
2.5 条件表达式（print A if 条件 else print B）
age=16
if age<18:
print("禁止入内")
else:
print("欢迎光临")
禁止入内
print("禁止入内")if age<18 else print("欢迎光临")----------原本的四行代码变成了一行
禁止入内
同一行代码想分行填写时需要用小括号包起来
3.分支结构的嵌套
age = 18
ismale = True
if age<18:
print("禁止")
else:
if ismale:
print("欢迎")
else:
print("抱歉")
欢迎
4.循环结构（While和for）
4.1 while 循环
love = "yes"
while love == "yes":
love = input("今天你还爱我吗?")
今天你还爱我吗?yes
今天你还爱我吗?yes
今天你还爱我吗?yes
今天你还爱我吗?no
i=1
sum=0
while i<1000:
sum=sum+i
i=i+1
print(sum)
499500
i=1
sum=0
while i<1000:
sum+=i-----------------------------效果和上面一样
i+=1
print(sum)
499500
当While的条件始终为true时，就会进入死循环，需要快捷键Ctrl+C来停止
4.2 当循环体遇到break语句时，会立刻跳出循环
while True:
answer=input("我可以停止了吗?")
if answer=="可以":
break
print("好累！")
我可以停止了吗?的
好累！
我可以停止了吗?的
好累！
我可以停止了吗?的
好累！
我可以停止了吗?可以
4.3 跳出循环体的另一个语句：continue（先出去一下，一会还要回来）
i=1
while i<10:
i+=1
if i%2==0:-------------------------------------------%取余数的运算符
continue-------------------------------------------当条件成立时跳出，跳过了之后的print命令
print(i)
3
5
7
9
4.4 当循环的条件不成立时，执行else语句
i=1
while i<5:
print("循环内，i的值是",i)
i+=1
else:
print("循环外，i的值是",i)
循环内，i的值是 1
循环内，i的值是 2
循环内，i的值是 3
循环内，i的值是 4
循环外，i的值是 5
i=1
while i<5:
print("循环内，i的值是",i)
if i==2:
break--------------------------------------else的主要作用就是能够识别循环中是否存在break语句（在i=2时跳出循环，但因为循环的条件依旧成立，所以未执行else语句）
i+=1
else:
print("循环外，i的值是",i)
循环内，i的值是 1
循环内，i的值是 2
i=1
while i<=7:
answer=input("学习了吗?")
if answer!="嗯":
break-----------------------------------------当i<7时break之后，不会执行else命令
i+=1
else:
print("真棒！")
学习了吗?嗯
学习了吗?嗯
学习了吗?嗯
学习了吗?嗯
学习了吗?嗯
学习了吗?嗯
学习了吗?嗯
真棒！
4.5 循环结构的嵌套
i=1
while i<=9:
j=1
while j<=i:
print(j,"*",i,"=",j*i,end=" ")--------------------------------------end“ ” 意思是在本次print的末尾时不换行，添加一个空格
j+=1
print()--------------------------------------------------------------------print后面默认跟换行符，这里意思是完成换行
i+=1
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
无论是break或continue语句，它们只能作用于一层循环体
day=1
hour=1
while day<=7:
while hour<=8:
print("加油")
hour+=1
if hour>1:
break--------------------------------仅跳出对hour的循环，进入day循环中
day+=1
加油
加油
加油
加油
加油
加油
加油
4.6 for 循环，（支持嵌套并可搭配break语句和continue语句）
for 变量 in 可迭代对象：------------字符串属于可迭代对象，整数不是
statement（s）
for each in "Fishc":
print(each)
F
i
s
h
c
range（）-------------------------------帮你生成一个数字序列，包括range（stop）；range（start，stop）；range（start，stop，step）
for i in range (11):
print(i)
0
1
2
3
4
5
6
7
8
9
10
for i in range(5,10):
print(i)
5
6
7
8
9
for i in range(5,10,2):
print(i)
5
7
9
for i in range(10,5,-2):
print(i)
10
8
6
for n in range(2,10):------------------------------找出10以内的素数（只能被1和自身整除的数）
for x in range(2,n):
if n%x==0:
print(n,"=",x,"*",n//x)
break
else:
print(n,"是一个素数")
2 是一个素数
3 是一个素数
4 = 2 * 2
5 是一个素数
6 = 2 * 3
7 是一个素数
8 = 2 * 4
9 = 3 * 3
sum=0
for i in range(0,10001):--------------计算1-10000的和
sum+=i
print(sum)
50005000
本帖最后由 风一样的僧 于 2022-10-1 23:01 编辑
Day6
1. 列表----列表是可变的，字符串是不可变的
创建列表：
将所有要放入列表中的元素用[]包裹起来，用,分割，不同类型的元素可以放入一个列表
创建列表名称： X=[]
列表的索引：排序索引，下标索引，逆向索引，函数len的灵活运用索引
列表切片：获取列表中的部分元素
x=
print(x)
for each in x:
print(each)
1
2
3
4
5
jjjjj
x
1
x
5
x
'jjjjj'
x[-1]
'jjjjj'
length=len(x)
x
'jjjjj'
x
x
x
x
x
x
x
['jjjjj', 4, 2]
x
['jjjjj', 5, 4, 3, 2]
x[::-1]
['jjjjj', 5, 4, 3, 2, 1]
x[::-2]
['jjjjj', 4, 2]
x[::2]
x[::2]
x
x[:3]
x
2.列表的诸多方法（增、删、改、查）
增：append：在列表最后添加一个元素
heroes=["黑寡妇","美队"]
print(heroes)
['黑寡妇', '美队']
heroes.append("博士")
heroes
['黑寡妇', '美队', '博士']
extend：在列表最后添加一个可迭代对象
heroes.extend(["绿巨人","鹰眼"])
heroes
['黑寡妇', '美队', '博士', '绿巨人', '鹰眼']
使用万能的切片语法，也可以实现列表元素的添加：
>>> s =
>>> # 下面的做法等同于 s.append(6)
>>> s =
>>> s
>>> # 下面的做法等同于 s.extend()
>>> s =
>>> s
insert：在列表的对应位置插入元素
x=
x.insert(3,4)
x
x.insert(0,0,)
x.insert(0,0)
x
x.insert(len(x),6)
x
删：remove----删除列表中的对应元素，如果有多个相同元素，只删除第一个；如果该元素不存在，程序报错；
heroes
['黑寡妇', '灭霸', '美队', '雷神']
heroes.remove("灭霸")
heroes
['黑寡妇', '美队', '雷神']
pop：删除某个下标位置的元素
heroes
['黑寡妇', '美队', '雷神']
heroes.pop(2)
'雷神'
heroes
['黑寡妇', '美队']
clear：清空列表
heroes
['黑寡妇', '美队']
heroes.clear()
heroes
[]
改：利用赋值号‘=’来完成，首先删除=左侧内容，再替换为=右侧内容
heroes=["黑寡妇","灭霸","美队","雷神"]
heroes="钢铁侠"
heroes
['黑寡妇', '灭霸', '美队', '钢铁侠']
heroes=["武松","李逵"]
heroes
['黑寡妇', '武松', '李逵']
nums=
nums
nums.sort()----------------------------------对列表中元素进行排序
nums
nums.reverse()--------------------------------对元素进行反转
nums
heroes
['黑寡妇', '武松', '李逵']
heroes.reverse()------------------------------对元素进行反转
heroes
['李逵', '武松', '黑寡妇']
nums=
nums
nums.sort(reverse=True)-------------------sort() 方法还可以实现排序后翻转（即从大到小的排序）
nums
查：count函数
count：----------------------------------------确认元素的数量
nums=
nums
nums.count(5)
2
heroes=['李逵', '武松', '黑寡妇']
heroes.index("武松")------------------------确认元素的位置
1
nums=
nums.index(1)
0
nums.index(1,1,9)---------------------------确定元素在规定区间内的位置
8
heroes="绿巨人"------------------确认相应元素位置后完成替换
heroes
['李逵', '绿巨人', '黑寡妇']
copy_1=heroes.copy()------------------将元素从列表1复制到列表2
copy_1
['李逵', '绿巨人', '黑寡妇']
copy_2=heroes[:]-----------------------同样实现复制
copy_2
['李逵', '绿巨人', '黑寡妇']
3.列表的运算
加法和乘法
s=
t=
s+t
s*3
嵌套列表
matrix=[,,]
matrix
[, , ]
matrix=[,---------------------------与上面的意思一样，这个更直观，就是矩阵（matrix）
,
]
matrix
[, , ]
访问嵌套列表：
for i in matrix:
for each in i:
print(each)
1
2
3
4
5
6
7
8
9
for i in matrix:
for each in i:
print(each,"")
print()-----------------------------自带换行符
1
2
3
4
5
6
7
8
9
for i in matrix:
for each in i:
print(each,end="")----------------end=“”让参数在一行
print()
123
456
789
for i in matrix:
for each in i:
print(each,end=" ")---------------加空格
print()
1 2 3
4 5 6
7 8 9
通过 for 语句来创建并初始化二维列表
A=*3
A
for i in range(3):-----------------------------range（3）=（0,1，2）
A=*3
A
[, , ]
for i in range(3):
A=*3
print(A)-------------------------------参与循环
[, , ]
[, , ]
[, , ]
for i in range(3):
A=*3
print(A)-----------------------------------不参与循环
[, , ]
is：用于追本溯源，确认列表在Python的存储位置是否一致
A
[, , ]
B=[*3]*3
B
[, , ]
A=1
A
[, , ]---------------只替换了第2行第2列的数
B=1
B
[, , ]----------------同时替换了三行第二列的数
x="FishC"
y="FishC"
x=y
x is y
True
x=
y=
x is y-------------------------------------------由于列表可以随时更新更改，Python会将每个列表单独存储，所以is not
False
A
[, , ]
B
[, , ]
A is A
False
A is A
False
A is A
False
B is B
True
B is B
True
变量不是一个盒子
x=
y=x---------------------y=x指的是y引用了x所引用的【1,2,3】，并未创建新的列表
y
x=1
x
y
深拷贝与浅拷贝
浅拷贝包括copy和切片两种形式，浅拷贝仅拷贝外层对象，如果出现嵌套时，其只能拷贝其引用值，内层的存储地址和copy对象一样
数列copy
x=
y=x.copy()-----------------copy让y有了独立的列表，当原x列表发生改变时不会影响y（copy拷贝的是整个列表，而不仅仅是变量的引用）
y
x=1
x
y
数列切片
x=
y=x[:]--------------------------------x[:]=x=
x
y
x=1
x
y
深拷贝
x=[,,]
y=x.copy()
x=0
x
[, , ]
y
[, , ]-----------------------当copy对象为有嵌套的列表时，copy只能作用于外层，而内部嵌套内容仍是引用的copy对象
copy作为一个python的函数模块使用，包括两个函数：copy和deepcopy
import copy----------------------------------------使用模块时要先用import导入
x=[,,]
y=copy.copy(x)-----------------------------------使用模块中的浅拷贝copy函数
x=0
x
[, , ]
y
[, , ]
x=[,,]
y=copy.deepcopy(x)----------------------------使用模块中的深拷贝deepcopy函数
x=0
x
[, , ]
y
[, , ]
Day7
1. 列表推导式
oho =
for i in range(len(oho)):
oho=oho*2
oho
oho=
oho=----------------这个列表推导式达到了上面一个循环达到的效果
oho
x=
x
x=
x
for i in range(10):------------------------这个循环达到了上面列表达到的效果
x.append(i+1)
x
y=-----------------------推导式同样可作用于字符串中
y
['FF', 'ii', 'ss', 'hh', 'CC']
code=----------------将每一个字符转换成unicode编码并保存为列表，ord为内置函数，作用是将单个字符串转换成编码
code
matrix=[,
,
]
row2= for x in matrix]----------------------选取第二列
row2
row2= for row in matrix]---------------row只是一个变量
row2
diag = for i in range(len(matrix))] ----------------------len（matrix）=2，i=（0,1,2），matrix=matrix,matrix,matrix ,也就是
diag
diag= for i in range(len(matrix))]
diag
利用列表推导式来创建一个二位列表
B=[*3]*3---------------------------------------错误的创建方式
B
[, , ]
B=1
B
[, , ]------------------导致改一个数时其他数也变了
A=*3
A
for i in range(3):
A=A*3-------------------------------可以利用循环创建
A
[, , ]
A=1
A
[, , ]---------------没毛病
S=[*3 for i in range(3)]-------------------利用列表推导式创建二维列表
S
[, , ]
S=1
S
[, , ]---------------没毛病
列表推导式可添加一个用于筛选的if语句（express fortarget in iterable if condition）
even = -----------------------------------------执行for循环后再确认if条件为true才会去给i赋值，%为取余数的运算符
even
even =
even
words=["Great","FishC","Brilliant","Excellent","Fantastic"]
fwords==="F"] -----------------------------------------选取words中以F开头的词
fwords
['FishC', 'Fantastic']
列表推导式的嵌套：
matrix=[,,]
flatten= ----------------------------------推导式的嵌套
flatten
matrix=[,,]
faltten= -------------------------------------------推导式的嵌套
faltten
['fF', 'fi', 'fs', 'fh', 'fC', 'iF', 'ii', 'is', 'ih', 'iC', 'sF', 'si', 'ss', 'sh', 'sC', 'hF', 'hi', 'hs', 'hh', 'hC', 'cF', 'ci', 'cs', 'ch', 'cC']
_=[]
for x in range(10):
if x%2==0:
for y in range(10):
if x%3==0:-----------------------------------------------每层嵌套还可以附带一个用于条件筛选的 if 分句
_.append()
_
[, , , , , , , , , , , , , , , , , , , ]
非常重要的程序设计原则：KISS-----------Keep It Simple&Stupid
Day7-2
1.元组---也是一个序列，既可以像列表一样容纳不同类型的对象，也拥有跟字符串一样不可变的特性
列表-[元素1，元素2]
元组-[元素1，元素2]
rhyme=(1,2,3,4,5,"上山打老虎")
rhyme
(1, 2, 3, 4, 5, '上山打老虎')
rhyme=1,2,3,4,5,"上山打老虎"---------------------------元组的圆括号是可以省略的，但可能出错，最好还是有
rhyme
(1, 2, 3, 4, 5, '上山打老虎')
rhyme
1
rhyme[-1]
'上山打老虎'
rhyme[:3]
(1, 2, 3)
rhyme[:3]
(1, 2, 3)
rhyme
(4, 5, '上山打老虎')
rhyme[::-1]
('上山打老虎', 5, 4, 3, 2, 1)
rhyme[::2]
(1, 3, 5)
nums=(1,3,4,5,6,3,7,4)
nums.count(3)
2
heros=("蜘蛛侠","黑寡妇","绿巨人")
heros.index("黑寡妇")
1
s=(1,2,3)
t=(4,5,6)
s+t
(1, 2, 3, 4, 5, 6)
S
[, , ]
s*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
w=s,t
w
((1, 2, 3), (4, 5, 6))
for each in s:
print (each)
1
2
3
for i in w:
for each in i:
print(each)
1
2
3
4
5
6
s=(1,2,3,4,5)
元组的打包和解包
t=(123,"hello",3.12)
t
(123, 'hello', 3.12)
x,y,z=t
x
123
y
'hello'
z
3.12
t=
x,y,z=t
x
123
y
'hello'
z
3.12
a,b,c,d,e="hello"
a
'h'
b
'e'
c
'l'
d
'l'
e
'o'
x,y=10,20--------------------------------多重赋值
x
10
y
20
_=（10，20）------------------------------（单独一个下划线，表示一个匿名变量）多重赋值的实现逻辑，先通过元组进行打包，然后对元组进行解包
x,y=_
x
10
y
20
s=
t=
w=(s,t)
w
(, )--------------------当元组中的元素是一个可以修改的列表时，依然可以对列表进行修改
w=0
w
(, ) Day8
1. 引入：利用字符串方法轻松解决回文数问题
x="12321"
"是回文数"if x ==x[::-1] else "不是回文数"
'是回文数'
x="12345"
"是回文数" if x==x[::-1] else "不是回文数"
'不是回文数'
2. 字符串方法讲解：大小写字母换来换去
capitalize()、casefold()、title()、swapcase()、upper()、lower()
x="I love FishC"
x.capitalize()
'I love fishc'------------------------仅语句首字母大写
x
'I love FishC'-----------------------这些方法并不会改变字符串本身，而是生成了一个新的字符串
x.casefold()
'i love fishc'------------------------返回一个所有都小写的字符串（能处理更多的语种）
x
'I love FishC'
x.title()-----------------------------所有单词首字母大写，所有其他字母小写
'I Love Fishc'
x
'I love FishC'
x.swapcase()---------------------所有字母大小写反转
'i LOVE fISHc'
x.upper()--------------------------所有字母大写
'I LOVE FISHC'
x.lower()---------------------------所有字母小写（只能处理英文字母）
'i love fishc'
3.字符串方法讲解：左中右对齐
center(width, fillchar=' ')、ljust(width, fillchar=' ')、rjust(width, fillchar=' ')、zfill(width)
x="有内鬼，停止交易！"
x.center(5)------------------------------------width小于字符串本身时显示字符串本身
'有内鬼，停止交易！'
x.ljust(5)
'有内鬼，停止交易！'
x.ljust(15)-------------------------------------左对齐，多出部分用空格填充
'有内鬼，停止交易！ '
x.rjust(15)-------------------------------------右对齐
' 有内鬼，停止交易！'
x.zfill(15)--------------------------------------用零在左侧填充
'000000有内鬼，停止交易！'
"520".zfill(15)
'000000000000520'
"-520".zfill(5)---------------------------------用零填充时会将符号调整到前面
'-0520'
x.center(15,"干")-----------------------------fillchar可以自定义填充的内容
'干干干有内鬼，停止交易！干干干'
x.center(15,"干")
'干干干有内鬼，停止交易！干干干'
x.rjust(15,"干")
'干干干干干干有内鬼，停止交易！' Day8-2
1. 字符串方法讲解：查找
count(sub[, start[, end]])、find(sub[, start[, end]])、rfind(sub[, start[, end]])、index(sub[, start[, end]])、rindex(sub[, start[, end]])
x="上海自来水来自海上"
x.count("海")--------------------------------查找“海”的数量
2
x.count("海",0,5)---------------------------查找区间内海的数量
1
x.find("海")----------------------------------从前往后数第一个海的下标位置
1
x.rfind("海")-----------------------------------从后往前数第一个海的下标位置
7
x.find("福")-----------------------------------用find查不存在的元素时，报-1
-1
x.rfind("福")------------------------------------用rfind查不存在的元素时，报-1
-1
x.index("福")------------------------------------用index查不存在的元素时，报错
Traceback (most recent call last):
File "<pyshell#42>", line 1, in <module>
x.index("福")
ValueError: substring not found
2. 字符串方法讲解：替换
expandtabs()、replace(old, new, count=-1)、translate(table)
首先是 expandtabs() 方法，它的作用是使用空格替换制表符（tab键）并返回新的字符串。（首先要明确：不要tab和空格混用）
code="""
print("I love FishC")-----------------------------行首使用tab
print("I love my wife")"""-----------------------行首使用4个空格
new_code = code.expandtabs(4)----------------“4”指的是用4个空格替换一个tab
print(new_code)
print("I love FishC")
print("I love my wife")
"在吗，我在你家留下，快下来！！" .replace("在吗","想你")-----------------------------------替换字符串中的元素，replace（"旧的","新的",count=-1），count指定的是替换次数，默认是-1，也就是全部替换
'想你，我在你家留下，快下来！！'
translate(table) 方法，这个是返回一个根据 table 参数（用于指定一个转换规则的表格）转换后的新字符串。
需要使用 str.maketrans(x[, y[, z]]) 方法制定一个包含转换规则的表格。
table=str.maketrans("ABCDEFG","1234567")-----------------------------------制作一个表格
"i LOVE LIFE".translate (table)---------------------------------------------------使用表格替代规则
'i LOV5 LI65'
"i LOVE LIFE".translate (str.maketrans("ABCDEFG","1234567"))
'i LOV5 LI65'
"i LOVE LIFE".translate (str.maketrans("ABCDEFG","1234567","LOVE"))----------“LOVE”制定被忽略的字符
'iI6'
3. 字符串方法讲解：判断
startswith(prefix[, start[, end]])、endswith(suffix[, start[, end]])、istitle()、isupper()、islower()、isalpha()、isascii()、isspace()、isprintable()、isdecimal()、isdigit()、isnumeric()、isalnum()、isidentifier()
这 14 个方法都是应对各种情况的判断，所以返回的都是一个布尔类型的值 —— 要么是 True，要么是 False。
startswith(prefix[, start[, end]]) 方法用于判断 prefix 参数指定的子字符串是否出现在字符串的起始位置：
x="I love Python"
x.startswith("I")
True
x.startswith("我")
False
x.endswith("Python")
True
x.startswith("love,1")
False
x.startswith(" ",1)
True
x.endswith("love",0,5)
False
x.endswith("lov",0,5)
True
x="她喜欢Pyhon"
if x.startswith(("你","我","她")):
print("总有人稀罕Pyhon")
总有人稀罕Pyhon
x="I Love Python"
x.istitle()------------------------------------判断首字母大写
True
x.isupper()----------------------------------判断全部是大写
False
x.upper().isupper()-----------------------先大写再判断是否大写
True
x
'I Love Python'
x.lower().islower()
True
x.isalpha()-----------------------------------判断是否只有字母组成，这里有空格，所以错
False
x="IlovePython"
x.isalpha()
True
"IlovePython".isalpha()
True
" \n".isspace()------------------------------判断是否为空白字符串，这里有tab+space+\n，这三类都属于空白字符串
True
x.isprintable()
True
"IlovePython\n".isprintable()--------------判断是否可打印，\n（转义字符，及换行）不可打印
False
x="12345"
x.isdecimal()--------------------------------判断是否数字
True
x.isdigit()--------------------------------判断是否数字
True
x.isnumeric()--------------------------------判断是否数字
True
x="22"
x.isdecimal()--------------------------------判断是否数字
False
x.isdigit()
True
x.isnumeric()--------------------------------判断是否数字，isalnum() 方法则是集大成者，只要 isalpha()、isdecimal()、isdigit() 或者 isnumeric() 任意一个方法返回 True，结果都为 True。
True
x.isidentifier()
False
x="i_ama-goodguy"
x.isidentifier()
False
x="i_am_a_goodguy"
x.isidentifier()-----------------------------判断是否为合法的字符，空格不可以
True
判断一个字符串是否为 Python 的保留标识符，就是像 “if”、“for”、“while” 这些关键字的话，可以使用 keyword 模块的 iskeyword() 函数来实现：
import keyword
keyword.iskeyword("if")
True
Day-9
1. 字符串方法讲解：截取
lstrip(chars=None)、rstrip(chars=None)、strip(chars=None)、removeprefix(prefix)、removesuffix(suffix)
这几个方法都是用来截取字符串的：
" 左侧不要空白".lstrip()
'左侧不要空白'
" 左侧不要空白".strip()------------------------------最好用，不用讲究左边还是右边，（）中默认是删除空格
'左侧不要空白'
"右侧不要空白 ".rstrip()
'右侧不要空白'
" 左右都不要空白 ".strip()
'左右都不要空白'
"www.ilovefishC.com".lstrip("wcom.")------------------------（）中的内容被识别并删除，当遇到与（）中不同的字母时停止
'ilovefishC.com'
"www.ilovefishC.com".lstrip("www.com")
'ilovefishC.com'
"www.ilovefishC.com".rstrip("www.com")
'www.ilovefishC'
"www.ilovefishC.com".strip("www.com")
'ilovefishC'
"www.ilovefishC.com".strip("w.com")
'ilovefishC'
"www.ilovefishC.com".removeprefix("www.")--------------删除前缀，删除一个具体的字符串
'ilovefishC.com'
"www.ilovefishC.com".removesuffix(".com")---------------删除后缀
'www.ilovefishC'
2. 字符串方法讲解：拆分
partition(sep)、rpartition(sep)、split(sep=None, maxsplit=-1)、rsplit(sep=None, maxsplit=-1)、splitlines(keepends=False)
拆分字符串，言下之意就是把字符串给大卸八块，比如 partition(sep) 和 rpartition(sep) 方法，就是将字符串以 sep 参数指定的分隔符为依据进行切割，返回的结果是一个 3 元组（3 个元素的元组）：
"www.ilovefishV.com".partition(".")
('www', '.', 'ilovefishV.com')
"www.ilovefishC.com".rpartition(".")
('www.ilovefishC', '.', 'com')
"www.ilovefishC\ncom".rpartition("\n")
('www.ilovefishC', '\n', 'com')
注意：它俩如果找不到分隔符，返回的仍然是一个 3 元组，只不过将原字符串放在第一个元素，其它两个元素为空字符串。
split(sep=None, maxsplit=-1) 和 rsplit(sep=None, maxsplit=-1) 方法则是可以将字符串切成一块块：
"苟日新，日日新，又日新".split("，")
['苟日新', '日日新', '又日新']
"苟日新，日日新，又日新".rsplit("，")
['苟日新', '日日新', '又日新']
"苟日新，日日新，又日新".split("，",1)------------------------左边一个
['苟日新', '日日新，又日新']
"苟日新，日日新，又日新".rsplit("，",1)-----------------------右边一个
['苟日新，日日新', '又日新']
splitlines(keepends=False) 方法会将字符串进行按行分割，并将结果以列表的形式返回：
"苟日新\n日日新\n又日新".splitlines()
['苟日新', '日日新', '又日新']
"苟日新\r日日新\r又日新".splitlines()
['苟日新', '日日新', '又日新']
"苟日新\r日日新\r\n又日新".splitlines()
['苟日新', '日日新', '又日新']
keepends 参数用于指定结果是否包含换行符，True 是包含，默认 False 则表示是不包含：
"苟日新\r日日新\r\n又日新".splitlines(True)
['苟日新\r', '日日新\r\n', '又日新']
"苟日新\r日日新\r\n又日新".splitlines(False)
['苟日新', '日日新', '又日新']
3. 字符串方法讲解：拼接
join(iterable) 方法是用于实现字符串拼接的。
虽然的它的用法在初学者看来是非常难受的，但是在实际开发中，它却常常是受到大神追捧的一个方法。
字符串是作为分隔符使用，然后 iterable 参数指定插入的子字符串：
".".join(["www","ilovefishc","com"])
'www.ilovefishc.com'
"^".join(("F","ish","C"))
'F^ish^C'
''.join("fishc""fISHc")
'fishcfISHc'
s="fishc"
s+=s
s
'fishcfishc' Day9-2
1. 格式化字符串
在字符串中，格式化字符串的套路就是使用一对花括号（{}）来表示替换字段，就在原字符串中先占一个坑的意思，然后真正的内容被放在了 format() 方法的参数中。
"FishC工作室成立于 year 年"
'FishC工作室成立于 year 年'
"FishC工作室成立于{}年".format(year)
'FishC工作室成立于2010年'
"1+2={},2的平方是{}，3的立方是{}".format("1+2","2*2","3*3*3")
'1+2=1+2,2的平方是2*2，3的立方是3*3*3'
"1+2={},2的平方是{}，3的立方是{}".format(1+2,2*2,3*3*3)
'1+2=3,2的平方是4，3的立方是27'
"{1}看到{0}就很激动".format("小甲鱼","小姐姐") ------------------------------在花括号里面，可以写上数字，表示参数的位置：
'小姐姐看到小甲鱼就很激动'
"{0}看到{1}就很激动".format("小甲鱼","小姐姐")
'小甲鱼看到小姐姐就很激动'
"我叫{name},我爱{lal}".format(name="小甲鱼",lal="Python") --------还可以通过关键字进行索引，比如：
'我叫小甲鱼,我爱Python'
"我叫{name},我爱{0},{0}很好用".format("Python",name="小甲鱼") -------------注意，同一个索引值是可以被多次引用的：位置索引和关键字索引可以组合使用
'我叫小甲鱼,我爱Python,Python很好用'
如果我只是想单纯的输出一个纯洁的花括号，那应该怎么办呢？
有两种办法可以把这个纯洁的花括号安排进去：
"{},{},{}".format(1,"{}",2)
'1,{},2'
"{},{{}},{}".format(1,2)
'1,{},2'
2. 字符串格式化语法参考
"{:^}".format("250")---------------------------------“：”左侧为关键信息，右侧为格式化的要求
'250'
"{:^10}".format("250")------------------“10”指的是填充到10个字符
' 250 '
"{1:>10},{0:<10}".format(250,520)
' 520,250 '
"{1:10},{0:10}".format(250,520)
' 520, 250'
"{left:10},{right:10}".format(left="250",right="520")
'250 ,520 '
"{left:<10},{right:>10}".format(left="250",right="520")
'250 , 520'
"{:010}".format(250)----------------------“010”中的第一个0是指用0填充字符数，只能针对数字使用
'0000000250'
"{:010}".format(-250)---------------------符号自动到最前面
'-000000250'
"{:%>10}{:%<10}".format(250,520)
'%%%%%%%250520%%%%%%%'
"{:0=10}".format(250)----------------------效果等同于"{:010}".format(250)
'0000000250' Day10
1. 字符串格式化语法参考（紧接上一节课）
1.1 符号（）选项
符号（）选项仅对数字类型有效，可以使用下面3个值：
"{:+}{:-}".format(520,-520)
'+520-520'
"{:,}".format(1234)
'1,234'
"{:_}".format(1234)
'1_234'
"{:_}".format(123)
'123'
"{:_}".format(123456789)
'123_456_789'
1.2 精度（[.precision]）选项
精度（[.precision]）选项是一个十进制整数，对于不同类型的参数，它的效果是不一样的：
对于以 'f' 或 'F' 格式化的浮点数值来说，是限定小数点后显示多少个数位
对于以 'g' 或 'G' 格式化的浮点数值来说，是限定小数点前后共显示多少个数位
对于非数字类型来说，限定最大字段的大小（换句话说就是要使用多少个来自字段内容的字符）
对于整数来说，则不允许使用该选项值
"{:2f}".format(3.11415)
'3.114150'
"{:.2f}".format(3.11415)
'3.11'
"{:.2g}".format(3.11415)
'3.1'
"{:.6}".format(3.11415)
'3.11415'
"{:.6}".format("i love you")
'i love'
1.3 类型（）选项
类型（）选项决定了数据应该如何呈现。
"{:{fill}{align}{width}.{prec}{ty}}".format(3.1415,fill='+',align='^',width=10,prec=3,ty='g')------Python 事实上支持通过关键参数来设置选项的值，比如下面代码通过参数来调整输出的精度：
'+++3.14+++'
2. f-字符串
f-string 可以直接看作是 format() 方法的语法糖，它进一步简化了格式化字符串的操作并带来了性能上的提升。
注：语法糖（英语：Syntactic sugar）是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。
使用 f-string 将前面讲解 format() 方法的例子进行替换：
year=2010
"FishC成立于{}年".format(year)
'FishC成立于2010年'
f"FishC 成立于{year}年"
'FishC 成立于2010年'
"1+2={},2的平方是{},3的立方是{}".format(1+2,4,3*3*3)
'1+2=3,2的平方是4,3的立方是27'
f"1+2={1+2},2的平方是{4},3的立方是{3*3*3}"
'1+2=3,2的平方是4,3的立方是27'
"{:010}".format(520)
'0000000520'
f"{520:010}"
'0000000520'
"{:,}".format(123456789)
'123,456,789'
f"{123456789:,}"
'123,456,789'
Day11---序列1
页:
[1]