python

标签：pyc   比较运算符   猜数字   string类   操作   model   注意   最大   帮助   

python：

一：编程语言：

1，跨平台的（windows/安卓androld/苹果ios）

2，面向对象的

3，解释性的

4，全栈的（app，桌面端软 件，网页）

5，易集成c/c++语言模块

二：学习python的用处：

GUI（界面），服务端，网络爬虫，深度学习，app，网页，数据分析...

三：py源代码翻译过程：

py——pyc——pvm

python源代码——python byte code（python字节码）——python虚拟机

四：APL文档：

APL应用程序接口，类似于说明书

python学习：

1，一共分为四个类型：

整形（int），字符串（str），浮点型（float），布尔型（True或false），复数类型（不常用）

input(输入)

print(输出)

2，python控制台：REPL

Read eval print loop

翻译为：

读 执行 输出 循环

3，IDLE： python自带的运行环境

4，取整：向上取整 向下取整

round相当于四舍五不入

使用math库的话： math.ceil(向上取整) math.floor(向下取整)

5，导入模块：

三个导入方法：(例如导入math模块)

（1），import math

（2），from math import （加入具体的模块名称）

（3），from math import *

在math模块中pi相当于数学中的 Π

6，python中调用cmd命令：

首先导入os模块：import os

可以查看函数：dir（os）

找到执行cmd命令的system：help（system）

os.system("cls") 清空控制台的当前窗体返回数值0

7，常用：

type（）查看什么类型

len（）查看长度

dir（）获取模块名称

help（）获取帮助

help（模块名称，模块名称）更详细

8，运算符：

**（几的几次方） *（乘法） //（取整） /（除法） %（取余） +（加法） —（减法）

    >(大于)   >=（大于等于）    <（小于）   <=（小于等于）    ==（双等于） !=(不等于)
    >
    >

9，运算符优先级：从大到小，从高到低

通用优先级：从左到右顺序
优先级从高到低：
1，圆括号（）
2，幂运算**
3，负号-
4，乘* 除/ 整除// 取余%
5，加+ 减-

10，进制：

二进制（bin） B表示 0b

八进制（oct） O表示 0o

十进制（dec） D表示 默认就是十进制

十六进制（hex） H表示 0x

11，format函数：

python中格式化是指：把所有语言翻译成一种标准语言

format（参数1，参数2）

（1），参数1为格式化数字 参数2为格式化字符串

例如： format(x,"<n.2f")

x为数据，<表示左对齐，n表示加多少为0，2f为保留两位小数

（2）， 千分号表示法：“，”（用逗号）

例如： x=1357.45667

print（format（x，“，”）,111)

1，357，45667 111

（3）， 千分号+小数保留：format（x，“，.2f”）

（4）， 科学计数法：format（x,"e"）

（5）， 科学计数法+小数保留：format（x,"0.2e"）

12，print中的sep和end：

（1），sep用于修改分割符，默认为空格

例如：结尾时print（x，sep=“|”）

x为值，后把默认的空格改为|

（2），end为不空格，在一行中输出完

13，序列解包特性：

例：

值互换

x，y=333，555   #分别将x，y进行赋值
x，y=y，x       #将x和y的值进行互换

python中简写的方法

1，连续赋值
    a=b=c=666
2,数学运算运用中，增量写法：
    j=j+1 对应一个增量赋值的写法 j+=1
    j=j-1 对应j-=1
    j*=2
    j/=2

14，ascii码：

字母对应数字，以此类推

大写字母A对应ascii码是65
大写字母B对应ascii码是66
小写字母a对应ascii码是97
小写字母b对应ascii码是98
回车键对应 13
数字0 对应的是 48

15，布尔类型：

BOOlean  简写  bool
主要用途：
  1，判断，值的大小，文本是否一致等
  2，结合更多的判断逻辑
判断常用的符号：
    双等号==  大于>  大于等于>=  小于等于<=
    小于<     不等于！=
判断后，返回的结果，就是 true 或者 false

布尔类型的特别之处

True代表1
>>>int(True)
1
>>> bool(1)
True
False代表0
>>>int(False)
0
>>>bool(0)
false

false 来说的特别转换

认为是false的几种情况：
none  0  ""  ()  []  {}
例如：
x=None
输出x
bool(x)
结果就是false

16，新的比较运算符：（布尔类型）

是 is             不是 not is
?
在里面 in    不在里面 not in
?
比较只会返回 True（正确） 或 false（错误）  
?
例如：
?
x=(1,2,3,4,5,6,7,8,9)
?
y=(22,333,44)
?
会输出false
?
?

17，if判断语句跟else语句：

if 格式：遵从python中的模块格式，一个模块从冒号开头，

以缩进tab作为标准 作为模块内容

举例：

if条件判断：
    满足条件为true时会执行的代码
    第二行代码
    ...

本行，当前对齐上面 if 条件，不在作为模块内容

例子：

x=555
?
    if x ==555：
    print（"要输出的内容"）

else语句：只能跟if语句连用

if条件判断true/false:
    条件为true要执行的代码
    这里是属于 if 为 true时的模块内容
else：
    这里是属于else的模块内容，
    是属于 if 为false时的模块内容
这里是独立的其他代码

注意：if...else语句，这个连用，要么执行if语句里的内容，要么执行else里 的内容，最后的结果只能其中之一

例子：

x=input("请输入暗号：")
y=x=="老七"
print(y)
if y:
    print("开始交易")
else:
    print("有刺客，交易结束")
输入老七的话就会运行"开始交易"
输入其他的话就会运行"有刺客，交易结束"

18, elif条件判断：

elif语句使用前提，必须要与if语句连用

格式：

if条件判断：
    执行代码1
elif条件判断：
    执行代码2
elif条件判断：
    执行代码3
...这里可以出现多次 elif 语句

结论：if+elif语句的连用，判断结果至少时一次

注意：如果if...elif...elif...多次判断...else...一起连用

他们如果有n次判断，那么这个语句，至少执行n多次判断，如果所有条件 都不满足，那么久会执行else语句模块

if语句也可以嵌套if语句：

if 条件判断：
    print("判断内容1")
    if("判断内容2")：
        print(‘‘判断内容3")
        if条件判断：     
            print("判断内容4")

单纯的多条if语句：

同一级别，如果有几条if语句，就判断几次

elif例子：

x=input("条件1：")
if x=="111":
    print("编程")
elif x=="222":
    print("编程创造城市1")
elif x=="333":
    print("欢迎走进我的心")
elif x=="444":
    print("让我们摇摆起来")
elif x=="555":
    print("艾瑞巴蒂")

多条if例子：

x=input("条件1:")
y=input("条件2:")
z=input("条件3:")
if x=="111":
    print("编程")
    if y=="222":
        print("编程创造城市")
        if z=="333":
            print("跟我一起")
出现几条if语句就会判断几次

19，while循环语句：

格式：

 while条件判断：
    满足判断(True)的条件下，
    多条语句执行

注意：while后面必须要跟上冒号：

冒号后要缩进三格，用tab键，每行都要缩进，

条件判断结果为True或False

如果为true，执行while内部代码

如果为false，不会进入while代码内部

注意： 布尔值首字母大写，因为python语言大小敏感。

例如：

输出1-100之间的所有数：
x=1
while x<101:
    print(x)
    x+=1

countinue：

含义：跳出本次循环，进入下次循环

x=1
while x<11:
    if x==5:
        x+=1
        continue
    print(x)
    x+=1
经过4的时候会跳过4继续执行

break：

含义：跳出循环，后面的不会在继续执行

while x<11:
    if x==5:
        x+=1
        continue
    if x==8:
        break
    print(x)
    x+=1
到7的时候直接停止

20，for循环：

虽然说python是由c语言编写而来，但是ta的for循环跟c语言的for循环不一 样，python的for循环显得更为人工智能和强大！

格式：

for  目标  in  表达式：
    循环体

举例：

break和continue都可以在循环语句中使用：

举例：

输出1-10之间所有的整数
for x in range(1,11):
    if x==6:
        break:
    print(x,end=" ")
 输出到5就会停止

输出到5会自动停止

range函数的作用是返回一个数值，使用的时候传入一个开头跟结尾，输出结果包含开头不包含结尾

传入一个字符串也可以：

favourite="fishc"
for i in favourite:
    print(i,end=" ")
输出结果为：f i s h c

传入一个序列输出：

member =["小甲鱼"，"小布丁"，"黑夜"，“迷途”，“怡静”]
for each in member:
    print(each,len(member))
输出结果为：
小甲鱼 5
小布丁 5
黑夜  5
迷途  5
怡静  5
>>>for each in member:
    print(each,len(each))
输出结果为：
小甲鱼 3
小布丁 3
黑夜 2
迷途 2
怡静 2
,,,
?
?

21，range 函数：

作用是返回一个数组，使用时转入一个数组开始，和传入一个数值为结尾，

range 是一个半开半闭区间，包含开头的值，不包含结尾的值，ta有三个参数：

for i in range(5):
    print(i)
输出结果为：
0
1
2
3
4
>>>for i in range(2,9):
    print(i)
输出结果为：
2
3
4
5
6
7
8
>>>for i in range(1,10,2):
    print(i)
输出结果为：
1
3
5
7
9
>>>

22，循环中的else语句：

（1）循环内部的else语句，如果与if语句连用，那么就是正常走if流程

（2）在循环外部的else语句，直接与循环语句while或者for连用，那么， 就代表：循环语句中没有被跳出break过的情况，就会执行循环外部连 用的else语句

例如：

x=9
while x<20:
    if x<15:
        print("第一段x:"+str(x))
    else:
        print("第二段x:"+str(x))
    x+=1
else:
    print("我的循环全部被执行了")

23，多维列表：

for循环跟while循环的嵌套使用：

多维列表：

一维列表：
list1=["110001","戚鹏博","男","18"]
list2=["110002","张换龙","男","19"]
list3=["110003","马超杰","男","18"]
list4=["110004","张高洋","男","18"]
二维列表：
listA=[list1,list2]
listB=[list3,list4]
三维列表：
listC=[listA,listB]

输出一维数组：

print("输出一维数组")
for x in list1:
    print(x,end=" ")
print()
for x in list2:
    print(x,end=" ")
print()
for x in list3:
    print(x,end=" ")
print()
for x in list4:
    print(x,end=" ")
print()
print("------------------------------")

输出二维数组：

print("输出二维数组")
listA=[list1,list2]
print("输出listA")
#使用双重for循环
for x in range(0,len(listA)):
    t=listA[x]
    for y in t:
        print(y,end=" ")
    print()
?
listB=[list3,list4]
使用while加for语句输出listB：
i=0
while i<len(listB):
    t=listB[i]
    for x in t:
        print(x,end=" ")
    print()
    i+=1

结果：

三维数组：自己可以去实验一下

24：random随机数：

使用随机整数，需要导入form random import randint

(1)，随机整数的函数：

randint（开始数值，结束数值），返回一个在开始数值与结束数值之

间的随机整数

举例：

x=randint（1，100） x就是在1-100中产生随机数

(2),补充多条件 比较：

t<1 or t>100 t的值小于1或者t大于100，那么结果为True

如果t=50，那么50<1为false，50>100为false

false or false 结果为false

Or的结论： or的前后判断，只要一个为真ture，结果就为真true

And的结论：and的前后判断，只要有一个为false，结果就为false

(3),猜数字游戏：

随机生成一个随机整数x

while死循环，作用为了不断进行猜解

注意input函数输入的值返回的是字符串类型

例如：

from random import randint
x=randint(1,100)
print("系统生成一个数字")
while True：     #while True代表死循环
    a=input("")
    t=int(a)
    if t<1 or t>100:
        print("请输入1-100的数")
        continue
    if t>x:
        print("猜大了，请重新猜")
    elif t<x:
        print("猜小了，请重新猜")
    elif t==x:
        print("恭喜你，猜对了，正确数字是"+str(x))
        break

25，统计学生分数的一个小例子：

比如说把全班分数分成A,B,C,D四个，A为90分以上，B为80分以上，C为60分以上，D为60分以下：

例如：

scort=int(input("请输入一个分数"))
if 100>=score >=90:
    print("A")
elif  90 >score >=80:
    print("B")
elif   80 > score >=60:
    print("C")
elif   60 > score >=0:
    print("D")
else:
    print("输入错误!")

26，列表：

列表，元组和字符串有一个共同点：

——都可以通过索引得到每一个元素

——默认索引都是0开始的

——可以通过分片技术得到一个范围内的元素的集合

——有很多共同的操作符（重复，拼接，成员关系操作符）

[ ]就是列表

（1），列表中常用的操作符：

比较操作符：

逻辑操作符

链接操作符

重复操作符

成员关系操作符

(2),向列表里添加元素:

append()加入一个元素：

例如：

member=["小甲鱼","小布丁","黑夜","迷途"]
member.append("怡静")
输出member就会变成：
["小甲鱼","小布丁","黑夜","黑夜","迷途","怡静"]

extend()加入多个元素：

例如：

member=["小甲鱼","小布丁","黑夜","迷途"]
member.extend(["竹林小溪"，"crazy迷恋"])
输出member就会变为：
["小甲鱼","小布丁","黑夜","黑夜","迷途","竹林小溪"，"crazy迷恋"]

insert()加入一个元素可以选择加入位置：

例如：

member=["小甲鱼","小布丁","黑夜","迷途"]
member.insert(1,"crazy迷恋")
因为索引是从0开始的，所以1对应的是"小布丁"
输出结果为：
["小甲鱼","crazy迷恋"，"小布丁","黑夜","迷途"]

（3），从列表删除元素：

remove()删除一个元素：

member=["小甲鱼","小布丁","黑夜","迷途"]
member.remove("迷途")
输出结果就为：
["小甲鱼","小布丁","黑夜"]

del()重索引删除元素：

member=["小甲鱼","小布丁","黑夜","迷途"]
del member[0]
输出结果为：
["小布丁","黑夜","迷途"]

pop()默认删除最后一个元素:

member=["小甲鱼","小布丁","黑夜","迷途"]
member.pop()
输出结果为：
"迷途"
默认把最后一个删除了

（4），将第一个元素跟第二个互换位置运用赋值：

member=["小甲鱼","小布丁","黑夜","迷途"]
member[0]
"小甲鱼"
member[1]
"小布丁"
temp=member[0]
member[0]=member[1]
member[1]=temp
输出结果为：
["小布丁","小甲鱼","黑夜","迷途"]

（5），list 的两个参数：

第一个参数：
>>>a=list（）
>>>a
>>>[]
第二个参数：-字符串
>>>b=‘i love you‘
>>>b
>>>[‘i‘,‘l‘,‘o‘,‘v‘,‘e‘,‘y‘,‘o‘,‘u‘]
?

（6），max 返回列表中最大的值 min返回列表中最小的值：（列表，字符串，元 组都可以用）

numbers=[1,18,13,0,-98,34,54,76,32]
max(numbers)
76
min(numbers)
-98
字符串中：
chars="1234567890"
min(chars)
‘0‘
元组中：
tuple1=（1，2，3，4，5，6，7，8，9，0）
max（tuple1）
9

（7），sum 是把组中所有的数相加，如果有两个参数，也会加上第二个：(字符串 不能使用)

numbers=[1,18,13,0,-98,34,54,76,32]
sum(numbers)
130
sum(numbers,8)
138

（8），sorted 将数组重大到小排序，reversed 将组反转：

numbers=[1,18,13,0,-98,34,54,76,32]
sorted（numbers）
[-98,0,1,13,18,32,34,54,76]
?
使用reversed：
输入： reversed(numbers)
会弹出：<list_reverseiterator object at ...>
再输入：list(reversed(numbers))
结果为：[32,76,54,34,-98,0,13,18,1]

（9），enumerate 跟组索引上序号：

numbers=[1,18,13,0,-98,34,54,76,32]
输入：enumerate(numbers)
会弹出：<enumerate object at ...>
再输入：list(enumerate(numbers))
结果为：[(0,1),(1,18),(2,13),(3,0),(4,-98),(5,34),(6,54),...]

(10), zip 将两个序列合成一个，多余的会舍弃：

a=[1,2,3,4,5,6,7,8]
b=[4,5,6,7,8]
输入：zip(a,b)
会弹出：<zip object at ...>
再输入：list(zip(a,b))
结果为：[(1,4),(2,5),(3,6),(4,7),(5,8)]
?

(11),

50, 模板字符串来解决重复性问题：

用 Template来解决重复性问题：

这个类型位于 string类型下面，所以要用必须要导入string模块

在使用 Template 的时候，这里要被代替的文字需要用 $ 和名称来标注：

举例：

    import string
    s=string.Template("世人慌 $a 张 不过图 $b 几两，偏偏这 $b 几两，却能解世人 $a ")
    x=s.substitute(a="慌张",b="碎银")
    print(x)
    最后结果为：
    世人慌慌张张 不过图碎银几两，偏偏这碎银几两，却能解世人慌张
    

①： 使用模板的步骤：

（1），导入string模块库；

（2）, 将Template类进行实例化，实例化的时候传入一个字符串，字符串中需要被替换的文字用 $ 来标注，实例化后会返回对象 s=string.Template("世人慌 $a 张 不过图 $b 几两，偏偏这 $b 几两，却能解世人$a ")

（3），开始调用对象的 substitute 方法来替换实例化的时候传入的模块值x=s.substitute(a="慌张",b="碎银")

②： 如果要替换多个值：

就需要用到多次 $ 来标注需要替换的值

③： 使用注意点：

规定使用英文字母开头，后面可以用字母和数字的混合，不要使用中文，（老外看不懂）

④： 可能会产生歧义：

例如用英文的情况：

注释: programming to create a city 翻译为： 创造城市

    import sstring
    s=string.Template("program${a}ming to create a city,我们赚$$")
    x=s.substitute(a="编程")
    print(x)
    最后结果为：
    program编程ming to create a city,我们赚$
    
    
    注意点：
    1，如果使用大括号{}来明确要被替换的范围
    2，如果要输出钱符号“$”，那么必须要写两次$$

52, Format 的方法：

一共有六种方法：

这个方法是字符串自带的方法；

使用的 format 方法的时候的格式：必须使用大括号{}

注意：

使用 format 方法后会返回一个格式化后的新的字符串

（1），format使用的简单案例：

        s="陌上人{}，{}世无双"
        x=s.format("如玉","公子")
        print（x）
        
        最后输出结果为：
       "陌上人如玉，公子世无双"
    
    #注意：这里的 format 参数，按照顺序排列进行替换

（2），forrmat使用关键字方式来替换：

不必依次顺序，将会只按照关键字的对应地方替换

例如：

        s="一念不{b}，芊芊成{a}"
        x=s.format(a="灭"，b="结")
        print(x)
        
        结果为：
        "一念不结,芊芊成灭"

（3）， 还可以直接使用数字方式来替换：

        s="一念不{0},芊芊成{1}"
        x=s.format("灭","结")
        print(x)
        
        结果为：
        "一念不灭，芊芊成结"

（4）， 关键字还可以跟数字方式混用：

注意：

混用时，在format 函数中必须要先写数字顺序对应的内容，然后再写关键字的替换，不然会报错！

举例：

        s="一念不{a},芊芊成{1},告诉{0}，你因何所困"
        x=s.format("我","结",a="灭")
        print(x)
        
        结果为：
        "一念不灭,芊芊成结,告诉我，你因何所困"

(5) , 还可以字符串替换对应列表的值：

注意：

这里的列表 q 为别名，这个别名在 format 替换的时候一定要对应到真正的列表

举例：

            q=["慌张","碎银"]
            s="世人慌{q[0]}张 不过图{q[1]}几两，偏偏这{q[1]}几两 能解世人{q[0]}"
            s1=s.format(q=q)
            print(s1)
                
            结果为：
            "世人慌慌张张 不过图碎银几两，偏偏这碎银几两 能解世人慌张"

（6）， 采用对象的方式格式化输出：

注意：

这里的对象 a 为别名，这个别名在 format 替换的时候一定要对应到真正的对象

运用math函数中的pi来举例：

            import math
            s="q={a.pi}"
            x=s.format(a=math)
            print(x)
            
            最后结果为：
            "q=3.141592653589793"

53， Format 的方法二：

（1），特殊字符的运用： 使用 ! 的方式

使用 a 可以转换为 unico 的编码格式

使用 s 可以直接将值转换为字符串

使用 r 可以表示使用原配函数来输出（原配函数就是不变）

举例：

        转换编码格式：
        
        >>> s="{q!a}"
        >>> print(s.format(q="戚鹏博"))
        输出结果为：
        ‘\u621a\u9e4f\u535a‘
?

（2），使用冒号： 的方式：

进制转换：

    >>> s="二进制：{q:b}  八进制：{q:o}  十进制：{q:d} 十六进制：{q:x}  "
    >>> print(s.format(q=10))
    输出结果为：
    ‘二进制：1010  八进制：12  十进制：10 十六进制：a‘

(3), 科学计数法 e ：

    >>>x="n:e"
    >>>print(x.format(n=5100))
    输出结果为：
    ‘5.100000e+03‘

(4), 百分号 % ：

   >>>x="{n:%}"
   >>>print(x.format(n=0.05))
   输出结果为：
   ‘5.000000%‘

(5), 转为浮点型：

    >>>x="{n:f}"
    >>>print(x.format(n=8))
    输出结果为：
    ‘8.000000‘

注意：python中的特殊符号：

Inf : +inf 表示无穷大 -inf 表示无穷小

nan： 表示非数字类型

总结强调：

使用符号！：适用 r（不变） a（编码格式） s（字符串格式）

使用符号： ：适用 f（浮点类型格式） e（科学计数法格式） b（二进制） o（八进制） x（十六进 制） d（十进制） %（后面加上百分号）

54，两种 format 方法的使用：

第一种：

print的时候，直接使用format函数
format（字符串，格式化）

第二种：

字符串自带的format方法

(1), Pk 格式化精度，保留小数位：

第一种：

from math import pi
x=pi
format(x,".2f")
结果为：
?
‘3.14’

第二种：

import math
y="pi保留两位小数{:.2f}"
print(y.format(math.pi))
结果为：
?
3.14

区别：第一种直接 format 将某个数值进行格式化，第二种方式可以将某个字符串中的某个部分进行格式化

（2），Pk 千分位

第一种：

import math
print(format(math.pi*1000000,",.2f"))
结果为：
?
3,141,592.65

第二种：

import math
print("开始输出第二种：")
"{:,.2f}".format(math.pi*1000000)
结果为：
?
‘3,141,592.65‘

区别：跟 pk 格式化精度一样

（3），字段宽度 Pk：

第一种：

import math
print(format(math.pi*1000,"0>2.2f"))
结果为：
?
3141.59     

第二种：

import math
print("第二种字段控制：")
"{w:2.2f}".format(w=math.pi*1000)
结果为：
?
‘3141.59‘

区别：第一种有对齐方式，第二种没有补0功能

总结强调：掌握直接使用 format你函数对某个数值进行格式化

掌握字符串中的某个部分的格式化方案，采用 format 方案，使用冒号：

55，Format方法的嵌套及其补充：

（1），补充一：

format 中的一对多形式：

import math
x="pi={0},pi2={0}"
print(x.format(pi))
结果为：
?
pi=3.141592653589793,pi2=3.141592653589793

（2），补充二：

字符串的 format 方法来进行补0： 实际上就是在长度的前面是否加0，默认情况下补充的是空格， 如果加0，那么就补充o

如果值的长度小于所给格式化的长度，那么默认右对齐

import math
x="pi={0:15}\npi2={0:015.2f}"
print(x.format(pi))
结果为：
?
pi=3.141592653589793
pi2=000000000003.14

（3），补充三：

在进制符号前面加上 # 号表示可以显示进制的形式

y="{:#x}"           #x表示十六进制
print(y.format(7))
结果为：
?
0x7                 #0x表示十六进制

（4），补充四：

字符串的对齐以及空白区域代替方案

s="{:&^30}"
print(s.format("七七"))
结果为：
?
&&&&&&&&&&&&&&七七&&&&&&&&&&&&&&

注意：填充字符串必须鱼对齐符号一起连用，并且要写在对齐符号的左边

（5），对齐：

单独使用对齐符号： < ^ >

对齐符号与0一起连用

x="pi={0:15}\npi2={0:<015.2f}"
print(x.format(pi))
结果为：
?
pi=3.141592653589793
pi2=3.1400000000000

（6），嵌套使用：

import math
s="{a:.{b}f}"
print(s.format(a=pi,b=2))
结果为：
?
3.14

总结强调：

掌握嵌套使用，多用{}来表示

字符串的空白填空

补0操作

对齐操作

进制转换

56， center 的使用，比format居中更轻巧：

center参数的使用：

他是字符串自带的方法

center 含义就是居中，在指定长度内居中

两个参数（1，自定义字符串总宽度，默认情况下用空格填充 2，自定义字符串总宽度，需要填充替换 的字符）

用法：参数1

s="{她说}"
print(s.center(30))
结果为：
?
             {她说}

用法：参数2

s="{他说}"
print(s.center(30,"*"))         #30表示居中为0格，*代表空格的填充
结果为：
?
*************{他说}*************

总结强调：掌握字符串的 center 的使用，对比 format 方法来实现 center 方法的效果

57，重点： 字符串分割 Split 与组合 Join

（1），字符串的分割：

使用 split 进行分割：

格式：

字符串.split（分割符号）.会返回一个值

分割案例：分割一段话

s="我是!你爸爸!我也是V8"
a=s.split("!")                   #把s新得到的值赋值给a
print(a)
print("第3个列表为："+a[2])
结果为：
?
[‘我是‘, ‘你爸爸‘, ‘我也是V8‘]
>>> print("第3个列表为："+a[2])
第3个列表为：我也是V8

（2），将列表元素组合成一个字符串：

运用 join 函数，他是一个字符串函数，使用 join 的格式前面必须是字符串：

组合符号字符串.join(某个列表) 会返回一个新组成的字符串

字符串组合案例：运用上个，把他再组成一个新的列表：

#这为分割：
s="我是!你爸爸!我也是V8"
a=s.split("!")                   #把s新得到的值赋值给a
print(a)
print("第3个列表为："+a[2])
结果为：
?
[‘我是‘, ‘你爸爸‘, ‘我也是V8‘]
>>> print("第3个列表为："+a[2])
第3个列表为：我也是V8
?
?
?
?
?
?
#下面为组合：
print("下面运用组合：".center(50,"="))               #运用上节所学的写成一条分界线
a[0]="V8是"
print("*".join(a))                   #这个字符串可以随便赋值，赋值什么输出的就是什么
print(a)
结果为：
?
=====================下面运用组合：======================
>>> a[0]="V8是"
>>> print(a)
[‘V8是‘, ‘你爸爸‘, ‘我也是V8‘]
>>> print("*".join(a))
V8是*你爸爸*我也是V8
>>>

python

标签：pyc   比较运算符   猜数字   string类   操作   model   注意   最大   帮助   

原文地址：https://www.cnblogs.com/qpb77/p/qpb77.html