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

中文也好，英文也罢，都要用引号包裹

风一样的僧

wp231957 发表于 2022-9-27 08:04
中文也好，英文也罢，都要用引号包裹

风一样的僧

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

风一样的僧

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

风一样的僧

Day6

1. 列表----列表是可变的，字符串是不可变的       
创建列表：
将所有要放入列表中的元素用[]包裹起来，用,分割，不同类型的元素可以放入一个列表
创建列表名称：        X=[]
列表的索引：排序索引，下标索引，逆向索引，函数len的灵活运用索引
列表切片：获取列表中的部分元素

x=[1,2,3,4,5,"jjjjj"]
print(x)
[1, 2, 3, 4, 5, 'jjjjj']

for each in x:
    print(each)

   
1
2
3
4
5
jjjjj

x[0]
1
x[4]
5
x[5]
'jjjjj'
x[-1]
'jjjjj'
length=len(x)
x[length-1]
'jjjjj'

x[0:3]
[1, 2, 3]
x[4:6]
[5, 'jjjjj']
x[3,6]
x[3:6]
[4, 5, 'jjjjj']
x[0:3:1]
[1, 2, 3]
x[0:6:2]
[1, 3, 5]
x[6:0:-2]
['jjjjj', 4, 2]
x[6:0:-1]
['jjjjj', 5, 4, 3, 2]
x[::-1]
['jjjjj', 5, 4, 3, 2, 1]
x[::-2]
['jjjjj', 4, 2]
x[::2]
[1, 3, 5]
x[::2]
[1, 3, 5]
x[0:3]
[1, 2, 3]
x[:3]
[1, 2, 3]
x[3:]
[4, 5, 'jjjjj']

2.列表的诸多方法（增、删、改、查）

增：append：在列表最后添加一个元素

heroes=["黑寡妇","美队"]
print(heroes)
['黑寡妇', '美队']
heroes.append("博士")
heroes
['黑寡妇', '美队', '博士']

extend：在列表最后添加一个可迭代对象

heroes.extend(["绿巨人","鹰眼"])
heroes
['黑寡妇', '美队', '博士', '绿巨人', '鹰眼']

使用万能的切片语法，也可以实现列表元素的添加：
>>> s = [1, 2, 3, 4, 5]
>>> # 下面的做法等同于 s.append(6)
>>> s[len(s):] = [6]
>>> s
[1, 2, 3, 4, 5, 6]
>>> # 下面的做法等同于 s.extend([7, 8, 9])
>>> s[len(s):] = [7, 8, 9]
>>> s
[1, 2, 3, 4, 5, 6, 7, 8, 9]

insert：在列表的对应位置插入元素

x=[1,2,3,5]
x.insert(3,4)
x
[1, 2, 3, 4, 5]
x.insert(0,0,)
x.insert(0,0)
x
[0, 0, 1, 2, 3, 4, 5]

x.insert(len(x),6)

x
[0, 0, 1, 2, 3, 4, 5, 6]

删：remove----删除列表中的对应元素，如果有多个相同元素，只删除第一个；如果该元素不存在，程序报错；

heroes
['黑寡妇', '灭霸', '美队', '雷神']
heroes.remove("灭霸")
heroes
['黑寡妇', '美队', '雷神']

pop：删除某个下标位置的元素

heroes
['黑寡妇', '美队', '雷神']
heroes.pop(2)
'雷神'
heroes
['黑寡妇', '美队']

clear：清空列表

heroes
['黑寡妇', '美队']
heroes.clear()
heroes
[]

改：利用赋值号‘=’来完成，首先删除=左侧内容，再替换为=右侧内容

heroes=["黑寡妇","灭霸","美队","雷神"]
heroes[3]="钢铁侠"
heroes
['黑寡妇', '灭霸', '美队', '钢铁侠']
heroes[1:]=["武松","李逵"]
heroes
['黑寡妇', '武松', '李逵']

nums=[1,2,6,4,3,7,5]
nums
[1, 2, 6, 4, 3, 7, 5]
nums.sort()----------------------------------对列表中元素进行排序
nums
[1, 2, 3, 4, 5, 6, 7]
nums.reverse()--------------------------------对元素进行反转
nums
[7, 6, 5, 4, 3, 2, 1]
heroes
['黑寡妇', '武松', '李逵']
heroes.reverse()------------------------------对元素进行反转
heroes
['李逵', '武松', '黑寡妇']

nums=[1, 2, 6, 4, 3, 7, 5]
nums
[1, 2, 6, 4, 3, 7, 5]
nums.sort(reverse=True)-------------------sort() 方法还可以实现排序后翻转（即从大到小的排序）
nums
[7, 6, 5, 4, 3, 2, 1]

查：count函数

count：----------------------------------------确认元素的数量
nums=[1, 2, 6, 4, 3, 7, 5,5]
nums
[1, 2, 6, 4, 3, 7, 5, 5]
nums.count(5)
2

heroes=['李逵', '武松', '黑寡妇']
heroes.index("武松")------------------------确认元素的位置
1
nums=[1, 2, 6, 4, 3, 7, 5,5,1,2]
nums.index(1)
0
nums.index(1,1,9)---------------------------确定元素在规定区间内的位置
8
heroes[heroes.index("武松")]="绿巨人"------------------确认相应元素位置后完成替换
heroes
['李逵', '绿巨人', '黑寡妇']

copy_1=heroes.copy()------------------将元素从列表1复制到列表2
copy_1
['李逵', '绿巨人', '黑寡妇']
copy_2=heroes[:]-----------------------同样实现复制
copy_2
['李逵', '绿巨人', '黑寡妇']

3.列表的运算

加法和乘法
s=[1,2,3]
t=[4,5,6]
s+t
[1, 2, 3, 4, 5, 6]
s*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

嵌套列表
matrix=[[1,2,3],[4,5,6],[7,8,9]]
matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix=[[1,2,3],---------------------------与上面的意思一样，这个更直观，就是矩阵（matrix）
             [4,5,6],
             [7,8,9]]
matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

访问嵌套列表：

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=[0]*3
A
[0, 0, 0]
for i in range(3):-----------------------------range（3）=（0,1，2）
    A[i]=[0]*3   
A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

for i in range(3):
    A[i]=[0]*3
    print(A)-------------------------------参与循环   
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

for i in range(3):
    A[i]=[0]*3
print(A)-----------------------------------不参与循环
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

is：用于追本溯源，确认列表在Python的存储位置是否一致

A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
B=[[0]*3]*3
B
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
A[1][1]=1
A
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]---------------只替换了第2行第2列的数
B[1][1]=1
B
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]----------------同时替换了三行第二列的数

x="FishC"
y="FishC"
x=y
x is y
True
x=[1,2,3]
y=[1,2,3]

x is y-------------------------------------------由于列表可以随时更新更改，Python会将每个列表单独存储，所以is not
False
A
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
B
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]
A[0] is A
False
A[0] is A[1]
False
A[1] is A[2]
False
B[0] is B[1]
True
B[1] is B[2]
True

变量不是一个盒子

x=[1,2,3]
y=x---------------------y=x指的是y引用了x所引用的【1,2,3】，并未创建新的列表
y
[1, 2, 3]
x[1]=1
x
[1, 1, 3]
y
[1, 1, 3]

深拷贝与浅拷贝

浅拷贝包括copy和切片两种形式，浅拷贝仅拷贝外层对象，如果出现嵌套时，其只能拷贝其引用值，内层的存储地址和copy对象一样
数列copy
x=[1,2,3]
y=x.copy()-----------------copy让y有了独立的列表，当原x列表发生改变时不会影响y（copy拷贝的是整个列表，而不仅仅是变量的引用）
y
[1, 2, 3]
x[1]=1
x
[1, 1, 3]
y
[1, 2, 3]

数列切片
x=[1,2,3]
y=x[:]--------------------------------x[:]=x[0:2]=[1,2,3]
x
[1, 2, 3]
y
[1, 2, 3]
x[1]=1
x
[1, 1, 3]
y
[1, 2, 3]

深拷贝

x=[[1,2,3],[4,5,6],[7,8,9]]
y=x.copy()
x[1][1]=0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]-----------------------当copy对象为有嵌套的列表时，copy只能作用于外层，而内部嵌套内容仍是引用的copy对象

copy作为一个python的函数模块使用，包括两个函数：copy和deepcopy

import copy----------------------------------------使用模块时要先用import导入
x=[[1,2,3],[4,5,6],[7,8,9]]
y=copy.copy(x)-----------------------------------使用模块中的浅拷贝copy函数
x[1][1]=0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]

x=[[1,2,3],[4,5,6],[7,8,9]]
y=copy.deepcopy(x)----------------------------使用模块中的深拷贝deepcopy函数
x[1][1]=0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

风一样的僧

Day7

1. 列表推导式[express for target  in interable]

oho = [1,2,3,4]
for i in range(len(oho)):
    oho[i]=oho[i]*2
oho
[2, 4, 6, 8]

oho=[1,2,3,4]
oho=[i*2 for i in oho]----------------这个列表推导式达到了上面一个循环达到的效果
oho
[2, 4, 6, 8]

x=[i for  i in range (10)]
x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x=[i+1 for  i in range (10)]
x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i in range(10):------------------------这个循环达到了上面列表达到的效果
    x.append(i+1)  
x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

y=[c*2 for c in "FishC"]-----------------------推导式同样可作用于字符串中
y
['FF', 'ii', 'ss', 'hh', 'CC']
code=[ord(c) for c in  "FishC"]----------------将每一个字符转换成unicode编码并保存为列表，ord为内置函数，作用是将单个字符串转换成编码
code
[70, 105, 115, 104, 67]

matrix=[[1,2,3],
            [4,5,6],
            [7,8,9]]

row2=[x[1] for x in matrix]----------------------选取第二列
row2
[2, 5, 8]
row2=[row[1] for row in matrix]---------------row只是一个变量
row2
[2, 5, 8]

diag = [matrix[i][i] for i in range(len(matrix))]   ----------------------len（matrix）=2，i=（0,1,2），matrix[i][i]=matrix[0][0],matrix[1][1],matrix[2][2] ,也就是[1,5,9]
diag        
[1, 5, 9]

diag=[matrix[i][2-i] for i in range(len(matrix))]        
diag      
[3, 5, 7]

利用列表推导式来创建一个二位列表

B=[[0]*3]*3---------------------------------------错误的创建方式      
B        
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
B[0][1]=1        
B      
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]------------------导致改一个数时其他数也变了

A=[0]*3        
A      
[0, 0, 0]
for i in range(3):
        A[i]=A[0]*3-------------------------------可以利用循环创建
A        
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
A[1][1]=1      
A        
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]---------------没毛病

S=[[0]*3 for i in range(3)]-------------------利用列表推导式创建二维列表
S      
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
S[1][1]=1        
S        
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]---------------没毛病

列表推导式可添加一个用于筛选的if语句（express for  target in iterable if condition）

even = [i for i in range(10) if i%2==0]  -----------------------------------------执行for循环后再确认if条件为true才会去给i赋值，%为取余数的运算符     
even        
[0, 2, 4, 6, 8]

even = [i+1 for i in range(10) if i%2==0]        
even        
[1, 3, 5, 7, 9]

words=["Great","FishC","Brilliant","Excellent","Fantastic"]      
fwords=[w for w in words if w[0]=="F"] -----------------------------------------选取words中以F开头的词      
fwords        
['FishC', 'Fantastic']

列表推导式的嵌套：

matrix=[[1,2,3],[4,5,6],[7,8,9]]      
flatten=[col for row in matrix for col in row]   ----------------------------------推导式的嵌套   
flatten
        
[1, 2, 3, 4, 5, 6, 7, 8, 9]

matrix=[[1,2,3],[4,5,6],[7,8,9]]        
faltten=[x for y in matrix for x in y]     -------------------------------------------推导式的嵌套                    
faltten        

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[x+y for x in "fishc" for y in "FishC"]
        
['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([x,y])

_
        
[[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [0, 8], [0, 9], [6, 0], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [6, 8], [6, 9]]

非常重要的程序设计原则：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[0]
        
1
rhyme[-1]
        
'上山打老虎'
rhyme[:3]
        
(1, 2, 3)

rhyme[:3]
        
(1, 2, 3)
rhyme[3:]
        
(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
        
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
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)
        
[each*2 for each in s]
        
[2, 4, 6, 8, 10]

元组的打包和解包

t=(123,"hello",3.12)
        
t
        
(123, 'hello', 3.12)
x,y,z=t
        
x
        
123
y
        
'hello'
z
        
3.12
t=[123,'hello',3.12]
        
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=[1,2,3]
        
t=[4,5,6]
        
w=(s,t)
        
w
        
([1, 2, 3], [4, 5, 6])--------------------当元组中的元素是一个可以修改的列表时，依然可以对列表进行修改
w[0][0]=0
        
w
        
([0, 2, 3], [4, 5, 6])

风一样的僧

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([tabsize=8])、replace(old, new, count=-1)、translate(table)

首先是 expandtabs([tabsize=8]) 方法，它的作用是使用空格替换制表符（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”制定被忽略的字符
'i  I6'

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 符号（[sign]）选项

符号（[sign]）选项仅对数字类型有效，可以使用下面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 类型（[type]）选项

类型（[type]）选项决定了数据应该如何呈现。


"{:{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