凡是过往，皆为序章

0%

Python_2(选择循环字符串)

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 2.5k 阅读时长 ≈ 8 分钟

基于上篇博客介绍了一些很基本的Python语法，如数据类型，输入输出，运算符等等，此篇博客继续总结选择、循环等结构，和最重要的 字符串 类型介绍。

一、if-else选择

1、if-else语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if 条件:
	条件成立执行的代码1
    条件成立执行的代码2
    ...
    if 条件:
        此为嵌套
    ...
elif 条件2:
    代码
elif 条件3:
    代码
...
else:
    代码3
    代码4
代码5

注意：if条件成立，执行后面带缩进的代码，而代码5则不属于if-else的语句块，与条件成立与否无关。

案例：猜拳

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import random

# 1、出拳
# 玩家
player = int(input('请出拳(0--石头，1--剪刀，2--布):'))
#电脑
computer = random.randint(0,2)
print(computer)

#2、判断输赢
#获胜
if((player == 0) and (computer == 1)) or ((player == 1) and (computer == 2)) or ((player == 2) and (computer == 0)):
    print('玩家获胜')
#平局
elif player == computer:
    print('平局')
#失败
else:
    print('失败')

2、三目运算符

语法：

1
2
条件成立执行的表达式 if 条件 else 条件不成立的表达式
c = a if a>b else b

案例：计算三角形面积

1
2
3
4
5
6
7
8
9
10
a = float(input('a = '))
b = float(input('b = '))
c = float(input('c = '))
if a + b > c and a + c > b and b + c > a:
    print('周长: %f' % (a + b + c))
    p = (a + b + c) / 2
    area = (p * (p - a) * (p - b) * (p - c)) ** 0.5
    print('面积: %f' % (area))
else:
    print('不能构成三角形')

说明： 上面使用的通过边长计算三角形面积的公式叫做海伦公式。

二、循环

包括while和for循环。

1、while循环

语法

1
2
3
while 条件:
    条件成立执行的代码
    ...

2、for循环

语法

1
2
3
for 临时变量 in 序列:
    重复执行的代码
    ...

例如：循环输出字符串中的每个字符。

1
2
3
str = 'hello world'
for i in str:
    print(i)

3、while…else/for…else

语法

1
2
3
4
while 条件:
    条件成立执行的代码
else:
    循环正常结束执行的代码

只有在循环正常结束时才会执行else里的内容，如果while里用break中止循环，则不会执行else里的语句。反之，continue可以执行else里的内容。

for…else语法类似。

案例：求两个数的最大公约数和最小公倍数

1
2
3
4
5
6
7
8
9
10
11
12
x = int(input('x = '))
y = int(input('y = '))
# 如果x大于y就交换x和y的值
if x > y:
    # 通过下面的操作将y的值赋给x, 将x的值赋给y
    x, y = y, x
# 从两个数中较的数开始做递减的循环
for factor in range(x, 0, -1):
    if x % factor == 0 and y % factor == 0:
        print('%d和%d的最大公约数是%d' % (x, y, factor))
        print('%d和%d的最小公倍数是%d' % (x, y, x * y // factor))
        break

三、字符串

1、定义

有三种方法，单引、双引和三引。 在三引号里回车换行会原样显示。

注意：注释也有三引号的写法，完全一致。

2、下标

在python中，可以用下标查询字符串中的相应字符。

1
2
3
4
5
6
str = 'hello world'
print(str[0])

# 注意：字符串不可通过下标修改
# str[1] = 'w' 报错
# str[:1] = 'Splat' 报错

3、切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表和元组都支持切片操作。

语法

1
序列[开始位置下标:结束位置下标:步长]

注意：

  • 不包含结束位置下标对应的数据，正负整数均可。
  • 步长是选取间隔，正负整数均可，默认步长为1。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
str = '01234567'
print(str[2:5:1])   #234
print(str[2:5:2])   #24
print(str[2:5])     #234
print(str[:5])      #01234
print(str[2:])      #234567
print(str[:])       #01234567

#负数测试
print(str[::-1])    #76543210 如果步长为负数，表示倒叙选取
print(str[-4:-1])   #456 表示从-4到-1位置输出，即倒数第四个到倒数第1个

print(str[-4:-1:-1])#不能选取出数据：从-4开始到-1结束，选取方向为从左到右，但步长为-1，代表从右向左选取
#如果选取方向（下标开始到结束的方向）和 步长的方向冲突，则无法选取数据。

4、字符串的常用操作方法

主要包括查找、修改和判断三大类。

1）查找

查找子串在字符串中的位置或者出现的次数。

  • find()：检查某个子串是否包含在这个字符串中，如果存在返回这个子串开始的位置下标，否则则返回-1。

    语法

    1
    字符串序列.find(子串,开始位置下标,结束位置下标)

    注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找

  • index()：和find()用法几乎一致。唯一不同：如果字串不存在，则系统报错。

  • count()：返回对应子串出现的次数

    语法

    1
    字符串序列.count(子串,开始位置下标,结束位置下标)

  • rfind()，rindex()：用法一致，查找顺序从右边开始。

2）修改

  • replace：替换

    1
    字符串序列.replace(旧子串,新子串,替换次数)

    原有字符串不会做出修改，函数返回修改后的结果。

  • split()：分割，返回一个列表，丢失分割字符。

    1
    字符串序列.split(分割字符,num)

    • num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。

    • 不写参数，默认以空格为分隔符，包括\n \t。

  • join()：合并列表里的字符串数据为一个大字符串。

    1
    字符或子串.join(多字符串组成的序列)

    举例

    1
    2
    list = ['11','22','33','44']
    print('_'.join(list)) 	#结果 11_22_33_44

    以上三个函数重点掌握。

  • 转换

    capitalize()：讲字符串第一个字符转换成大写。

    title()：将字符串每个单词首字母转换成大写。

    lower()：将字符串中大写转小写。

    upper()：小写转大写。

  • 删除空白

    lstrip()：删除字符串左侧空白字符。

    rstrip()：删除字符串右侧空白字符。

    strip()：删除字符串两侧空白字符。

3）判断

判断真假，返回布尔的真假。

  • startswith()：检查字符串是否以指定子串开头，是则返回True。

    1
    字符串序列.startswith(子串,开始位置下标,结束位置下标)

  • endswith()：检查字符串是否以指定子串结尾，是则返回True。

  • 其他函数：

    • isalpha()：如果字符串至少有一个字符并且所有字符都是字母返回True。
    • isdigit()：如果字符串只包含数字则返回True。
    • isalnum()：如果字符串至少有一个字符并且所有字符串都是字母或数字。

  • isspace()：如果字符串只包含空白。

其他

可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串（成员运算）

1
2
3
4
5
s1 = 'hello ' * 3
print(s1) # hello hello hello

print('ll' in s1) # True
print('good' in s1) # False

示例

1
2
3
4
5
6
7
8
9
10
str1 = 'hello, world!'
print('字符串的长度是:', len(str1))
print('单词首字母大写: ', str1.title())
print('字符串变大写: ', str1.upper())
# str1 = str1.upper()
print('字符串是不是大写: ', str1.isupper())
print('字符串是不是以hello开头: ', str1.startswith('hello'))
print('字符串是不是以hello结尾: ', str1.endswith('hello'))
print('字符串是不是以感叹号开头: ', str1.startswith('!'))
print('字符串是不是一感叹号结尾: ', str1.endswith('!'))

结果

1
2
3
4
5
6
7
8
字符串的长度是: 13
单词首字母大写:  Hello, World!
字符串变大写:  HELLO, WORLD!
字符串是不是大写:  False
字符串是不是以hello开头:  True
字符串是不是以hello结尾:  False
字符串是不是以感叹号开头:  False
字符串是不是一感叹号结尾:  True

迅速去掉字符串的空格符、制表符和换行符

1
2
aStr = 'hello  wel\rcome \t   to   \t  zy \n  oYeah'
print(''.join(aStr.split()))

补充

字符串的编码解码：用到方法：encode() 和 decode()。编码解码主要针对中文

1
2
3
4
5
6
7
str = '董奥250,a good man'

a = str.encode() # 函数可以写参数，utf-8 或 gbk，表示以相应的编码格式编码

print(a) # b'\xe8\x91\xa3\xe5\xa5\xa5250,a good man' 以b开头，表示字节流

b = a.decode('utf-8') # 表示以相应的解码格式解码

总结：

  • str 使用 encode() 方法转换为 bytes
  • bytes 通过 decode() 方法转换为 str

四、字符串的format格式化

一、简单运用

字符串类型格式化采用format()方法，基本使用格式是：

<模板字符串>.format(<逗号分隔的参数>)

调用format()方法后会返回一个新的字符串，参数从0开始编号。

1
2
3
4
5
6
7
8
9
10
11
12
13
"{}{}{}".format("圆周率是",3.1415926,"...")
>>>  '圆周率是3.1415926...'
 
"圆周率{{{1}{2}}}是{0}".format("无理数",3.1415926,"...") # 输出大括号
>>>  '圆周率{3.1415926...}是无理数'
 
s="圆周率{{{1}{2}}}是{0}" #大括号本身是字符串的一部分
 
s
>>>  '圆周率{{{1}{2}}}是{0}'	 # 格式化模板
 
s.format("无理数",3.1415926,"...")	 # 当调用format()时解析大括号
>>>  '圆周率{3.1415926...}是无理数'

二、格式控制信息 format()方法中 <模板字符串> 的槽除了包括参数序号，还可以包括格式控制信息。此时，槽的内部样式如下：
{<参数序号>: <格式控制标记>}

  • <参数序号>：指定的位置，从0开始。

  • <格式控制标记> **：用来控制参数显示时的格式。包括：<填充>,<对齐>,<宽度>,<.精度>,<类型>** 6 个字段，这些字段都是可选的，可以组合使用，逐一介绍如下。

<宽度>

指当前槽的设定输出字符宽度，如果该槽对应的format()参数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则位数将被默认以空格字符补充。

<对齐>

指参数在<宽度>内输出时的对齐方式，分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐。

<填充>

指<宽度>内除了参数外的字符采用什么方式表示，默认采用空格，可以通过<填充>更换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
s = "PYTHON"
 
"{0:30}".format(s)
Out[17]: 'PYTHON                        '
 
"{0:>30}".format(s)
Out[18]: '                        PYTHON'
 
"{0:*^30}".format(s)
Out[19]: '************PYTHON************'
 
"{0:-^30}".format(s)
Out[20]: '------------PYTHON------------'
 
"{0:3}".format(s)
Out[21]: 'PYTHON'

逗号（，）

<格式控制标记>中逗号（，）用于显示数字的千位分隔符，例如:

1
2
3
4
5
6
7
8
"{0:-^20,}".format(1234567890)
Out[24]: '---1,234,567,890----'
 
"{0:-^20}".format(1234567890) # 对比输出
Out[25]: '-----1234567890-----'
 
"{0:-^20,}".format(12345.67890)
Out[26]: '----12,345.6789-----'

<.精度>

表示两个含义，由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。

1
2
3
4
5
6
7
8
"{0:.2f}".format(12345.67890)
Out[29]: '12345.68'
 
"{0:H^20.3f}".format(12345.67890)
Out[30]: 'HHHHH12345.679HHHHHH'
 
"{0:.4}".format("PYTHON")
Out[31]: 'PYTH'

<类型>

表示输出整数和浮点数类型的格式规则。对于整数类型，输出格式包括6 种：

  • b: 输出整数的二进制方式；
  • c: 输出整数对应的 Unicode 字符；
  • d: 输出整数的十进制方式；
  • o: 输出整数的八进制方式；
  • x: 输出整数的小写十六进制方式；
  • X: 输出整数的大写十六进制方式
1
2
"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
Out[32]: '110101001,Ʃ,425,651,1a9,1A9'

对于浮点数类型，输出格式包括4 种：

  • e: 输出浮点数对应的小写字母 e 的指数形式；
  • E: 输出浮点数对应的大写字母 E 的指数形式；
  • f: 输出浮点数的标准浮点形式；
  • %: 输出浮点数的百分形式。

浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好控制输出格式。

1
2
3
4
5
"{0:e},{0:E},{0:f},{0:%}".format(3.14)
Out[33]: '3.140000e+00,3.140000E+00,3.140000,314.000000%'
 
"{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14)
Out[34]: '3.14e+00,3.14E+00,3.14,314.00%'
~感谢你请我吃糖果~
-------------本文结束，感谢您的阅读，欢迎评论留言！-------------