知识点

  • 整型
  • 布尔类型
  • 字符串

前提概要

  • 每种数据类型都有自己的特点及应用场景，以后的开发中需要根据实际的开发情况选择合适的数据类型。
  • 结构相似的一些数据，有一些共同特征的数据的集合就是数据类型
  • 每种数据类型按照以下4个维度
    1. 定义（怎么样的数据），叫哪一类数据类型
    2. 独有功能（这些数据类型具有的独有功能）
    3. 公共功能（这些数据类型共同具有的功能）
    4. 类型转换（怎样把一个数据类型，转换成另一个数据类型）
    5. 其他

整型

整型其实就是十进制整数的统称，比如：1、68、999都属于整型。它一般都用于表示年龄、序号等。

定义

1
2
number = 10
age = 99

独有功能

  • 获取一个整型变量的二进制表示有多少位组成
1
result1 = v1.bit_length()

例如：

1
2
3
4
5
6
7
8
9
10
11
v1 = 5
print(bin(v1))  # 0b101 3位
# 调用v1 （int）独有功能，获取v1的二进制表示有多少个位组成。
result1 = v1.bit_length()
print(result1)   # 3   这就意味着v1有3个二进制位

v2 = 10
print(bin(10))  # 0b1010
# 调用v2 （int）独有功能，获取v2的二进制表示有多少个位组成。
result2 = v2.bit_length()
print(result2)   # 4   这就意味着v1有4个二进制位
  • 注：该独有功能看看就行，实际运用的意义并不大

公共功能

  • 加减乘除
1
2
3
v2 = 8
v3 = v1 + v2
print(v3)  # 12

类型转换

  • 在项目开发和面试题中经常会出现一些“字符串”和布尔值转换为整型的情况。
  1. 布尔值转换为整型
1
2
n1 = int(True)  # True转换为整数 1
n2 = int（False）# False转换为整数 0
  1. 字符串转整型
1
2
3
4
5
6
7
8
9
10
11
12
v1 = int("186",base=10)
# 把字符串看成十进制的值，然后再转换为十进制整数，结果：v1 = 186
# 这里的base=10可以省略，base=其他数就不能省略

v2 = int("0b1001",base=2)
# 把字符串看成二进制的值，然后再转换为十进制整数，结果：v2 = 9（0b表示二进制）

v3 = int("0o144",base=8)
# 把字符串看成八进制的值，然后转换为十进制整数，结果：v3 = 100（0o表示八进制）

v4 = int("0x59",base=16)
# 把字符串看成十六进制的值，然后转换为十进制整数，结果：v4 = 89（0x表示十六进制）
  1. 浮点型转整型
1
v1 = int(8.7)#8

注：这里浮点型转整型的取整规则是趋0取整

其他

长整型

python3：整型（无限制）

python2：整型、长整型

在python2中跟整数相关的数据类型有两种：int（整型）、long（长整型），能表示的值范围不同。

1
2
3
4
5
6
v1 = 9223372036854775807
#9223372036854775807

v2 = 9223372036854775808
#9223372036854775808L
#long类型都以L结尾

  • 注：

    int,可表示的范围：-9223372036854775808~9223372036854775807

​ long，整数值超出int范围之后自动会转换为long类型（无限制）。

​ 在python3中去除了long只剩下：int（整型），并且int长度不再限制。

地板除

1
2
3
4
5
6
7
#py3：
v1 = 9/2
print(v1) #4.5

#py2：
v1 = 9/2
print(v1) #4

python2中两个值相除时，默认进行地板除，只保留整数位。（python3中默认会保留小数）。

布尔类型

布尔值，其实就是“真”，“假”

定义

1
2
data = False
alex_is_sb = True

独有功能

无

公共功能

加减乘除

1
2
v1 = True + True
print(v1) #2

注：没有实际意义看看就行

转换

  • 任何的数据类型都能转换成bool类型
  • 在以后的项目开发中，会经常使用其他类型转换为布尔值的情景，此处只要记住一个规律即可
  • 整数0、空字符串、空列表、空字典、转换为布尔值时均为False，其他均为True

其他

做条件自动转换

  • 如果在if 、while条件后面写一个值当做条件时，它会默认转换为布尔类型，然后再做条件判断。
1
2
3
4
5
6
7
8
9
10
11
if  0:
    print("太六了")
else:
    print(999)
if "武沛齐":
    print("你好")

if "alex":
    print("你是傻逼？")
else:
    print("你是逗比？")
  • 注：计算机会将if后面的语句转换为bool类型，如果为True就执行if冒号下面的语句，如果为False就执行else下面的语句
1
2
3
4
5
6
7
while 1 > 9:
    pass
if 值:
    pass

while 值:
    pass

字符串类型

字符串，我们平时会用它来表示文本信息。例如：姓名、地址、自我介绍等。

定义

1
2
3
4
5
6
7
8
9
10
v1 = "包治百病"
v2 = '包治百病'
v3 = "'包‘治百病"
v4 = '"包"治百病'
v5 = """
吵架都是我的错
因为大家打不过
"""

# 三个引号，可以支持多行/换行表示一个字符串，其他的都是只能在一行中表示一个字符串

独有功能（18/48）

基本格式：

1
2
3
4
5
6
7
# 格式一：
"xxxxx".功能(...)
# 括号里可以有东西，也可以没有东西

#格式二：
v1 = "xxxxx"
v1.功能(...)

判断字符串开头

判断一个字符串是否以xx开头，得到一个布尔值。

1
2
3
4
5
6
7
8
9
10
11
12
13
v1 = "叨逼叨的一天，烦死了"

result = v1.startswith("叨逼")

print(result)  # 值为True

# 案例
v1 = input("请输入住址：")

if v1.startswith("北京市"):
    print("北京人口")
else:
    print("非北京人口")

判断字符串结尾

判断一个字符串是否以xx结尾，得到一个布尔值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
v1 = "叨逼叨的一天，烦死了"

result1 = v1.endswith("烦死")
result2 = v1.endswith("烦死了")

print(result1)  # 值为False
print(result2)  # 值为True

# 案例
address = input("请输入地址：")

if address.endswith('村'):
    print("农业户口")
else:
    print("非农户口")

判断字符串为十进制数

判断字符串是否为一个十进制数，得到一个布尔值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1 = "1238871"
result = v1.isdecimal()
print(result)  # True

# 案例，两个数相加

v1 = input("请输入值：")   # "666"
v2 = input("请输入值：")   # "999"

if v1.isdecimal() and v2.isdecimal():
    data = int(v1) + int(v2)
    print(data)
else:
    print("请正确输入数字")


#.isdecimal()  与  .isdigit() 的区别
v1 = "123"
print(v1.isdecimal()) #True

v2 = "①"
print(v2.isdecimal()) #False

v1 = "123"
print(v1.isdigit()) #True

v2 = "①"
print(v2.isdigit()) #True

去除字符串两边字符

去除字符串两边的 空格、换行符、制表符，得到一个新的字符串。

1
2
data = input("请输入内容：")#   武沛齐   ，武沛齐
print(data)

去除两边空格：

1
2
3
4
msg = " H e ll o啊，树哥 "
data = msg.strip()

print(data)# 将msg两边的空白去掉，得到“H e ll o啊，树哥”

去除左边空格：

1
2
3
4
msg = " H e ll o啊，树哥 "
data = msg.lstrip()

print(data)# 将msg左边的空白去掉，得到“H e ll o啊，树哥 ”

去除右边空格：

1
2
3
4
msg = " H e ll o啊，树哥 "
data = msg.rstrip()

print(data)# 将msg右边的空白去掉，得到“  H e ll o啊，树哥”
  • 补充：strip也可以去除 空格、换行符、制表符。

换行符（\n）：该符号输入进程序，会自动换行。

制表符（Tap键，\t）：输入之后会默认加入一个制表符

1
2
3
4
5
6
7
# 案例
code = input("请输入4位验证码：") #  FB87
data = code.strip()
if data == "FB87":
    print('验证码正确')
else:
    print('验证码错误')
  • 再补充：strip还可以去除字符串两边指定的内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
msg = "哥H e ll o啊，树哥"
data = msg.strip("哥")

print(data)# 将msg两边的哥去掉，得到“H e ll o啊，树”

msg = "哥H e ll o啊，树哥"
data = msg.lstrip("哥")

print(data)# 将msg左边的哥去掉，得到“H e ll o啊，树哥”

msg = "哥H e ll o啊，树哥"
data = msg.rstrip("哥")

print(data)# 将msg右边的哥去掉，得到“哥H e ll o啊，树”

字符串变大写

字符串变大写，得到一个新字符串

1
2
3
4
msg = "my name is oliver queen"
data = msg.upper()
print(msg)  # my name is oliver queen
print(data)  # 输出为：MY NAME IS OLIVER QUEEN
  • 注意：.upper()只是创建新的变量把大写后的值赋给新变量，而原变量不变
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 案例
code = input("请输入4位验证码：")  # FB88  fb88
value = code.upper()  # FB88
data = value.strip()  #FB88
if data == "FB87":
    print('验证码正确')
else:
    print("验证码错误")

# 注意事项
'''
code的值”fb88 “
value的值”FB88 “
data的值”FB88“
'''

字符串变小写

字符串变小写，得到一个新字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
data = "你是个好人，但是好人不合适我"
value = data.replace("好人","贱人")
print(data)  # "你是个好人，但是好人不合适我"
print(value)  # "你是个贱人，但是贱人不合适我”

# 案例
video_file_name = "高清无码爱情动作片.mp4"

new_file_name = video_file_name.replace("mp4","avi")  #  "高清无码爱情动作片.avi"

final_file_name = new_file_name.replace("无码","步兵") # "高清步兵爱情动作片.avi"

print(final_file_name)

# 案例
video_file_name = "高清无码爱情动作片.mp4"

new_file_name = video_file_name.replace("mp4","avi")  #  "高清无码爱情动作片.avi"

final_file_name = video_file_name.replace("无码","步兵")  #  "高清步兵爱情动作片.mp4"

print(final_file_name)

# 案例
content = input("请输入评论信息") # alex是个草包

content = content.replace("草","**")  # alex是一个**包
content = content.replace("泥马","***")  # alex是一个**包
print(content)  #  alex是一个**包
  • 注：每次都赋值给content变量，是为了节省变量的使用
1
2
3
4
5
6
7
8
 案例
char_list = ["草拟吗","逗逼","二蛋","钢球"]

content = input("请输入评论信息")
for item in char_list:
    # item="草泥吗"
    content = content.replace(item,"**")
print(content)

字符串切割

字符串切割，得到一个列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
data = "武沛齐|root|wupeiqi@qq.com"
result = data.split('|')   #  切割完之后是列表类型的数据
print(data) # "武沛齐|root|wupeiqi@qq.com"
print(result) 
# 输出['武沛齐', 'root', 'wupeiqi@qq.com']
# 根据特定字符切开之后保存至列表中,方便以后的操作




# 案例:判断用户名密码是否正确
info = "武沛齐,root"
# 备注：字符串中存储了一个用户名和密码
user_list = info.split(',')
# 得到一个包含了2个元素的列表["武沛齐","root"]

#user_list[0]  获取列表的第一个元素
#user_list[1]  获取列表的第二个元素

user = input("请输入用户名：")
pwd = input("请输入密码")

# 比较输入的用户名和密码是否与列表中的相同
if user == user_list[0] and pwd == user_list[1]:
    print("登录成功")
else:
    print("用户名或密码错误")

控制切割次数

1
2
3
4
5
6
7
8
data = "武沛齐|root|wupeiqi@qq.com"
v1 = data.split("|")
print(v1)
#  ['武沛齐', 'root', 'wupeiqi@qq.com']

v2 = data.split("|",1)  # 1表示从左到右切几个
print(v2)
#  ['武沛齐', 'root|wupeiqi@qq.com']

再拓展：

切割的方向从右往左切割

1
2
3
4
5
6
7
8
9
data = "武沛齐,root,wupeiqi@qq.com"

v1 = data.rsplit(',')
print(v1)
#  ['武沛齐', 'root', 'wupeiqi@qq.com']

v2 = data.rsplit(',',1)
print(v2)
#  ['武沛齐,root', 'wupeiqi@qq.com']

应用场景：

1
2
3
4
5
6
7
file_path = "xxx/xxxx/xx.xx/xxx.mp4"
#  要求找到该文件的后缀名
#  这时就可以通过
data_list = file_path.rsplit(".",1)
# ["xxx/xxxx/xx.xx/xxx","mp4"]
data_list[0]
data_list[1]

字符串拼接

字符串拼接，得到一个新的字符串

1
2
3
4
data_list = ["alex","是","大烧饼"]
# 将字符串拼接起来，形成一个整体的大字符串
v1 = "*".join(data_list) #  alex*是*大烧饼
print(v1)

字符串格式化

格式化字符串，得到新的字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
name = "{0}的喜欢干很多行业，例如有：{1}、{2}等"
data = name.format("老王","护士","嫩模")
print(data)  # "老王的喜欢干很多行业，例如有：护士、嫩模等"
print(name)  # "{0}的喜欢干很多行业，例如有：{1}、{2}等"


name = "{}的喜欢干很多行业，例如有：{}、{}等"
data = name.format("老王","护士","嫩模")
print(data)  # 老王的喜欢干很多行业，例如有：护士、嫩模等


name = "{name}的喜欢干很多行业，例如有：{h1}、{h2}等"
data = name.format(name="老王",h1="护士",h2="嫩模")
print(data)  # 老王的喜欢干很多行业，例如有：护士、嫩模 等

字符串转字节类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
data = "嫂子"  # Unicode，字符串类型
# 如果你想将这个字符串写入文件，或者通过网络进行传输
# 一般要转换成gbk的编码或者utf-8的编码
v1 = data.encode("utf-8")  # utf-8，字节类型
# 相当于把字符串“嫂子”内部的编码方式
# 压缩或者转换成utf-8的编码格式
v2 = data.encode("gbk")  # gbk,字节类型
# 可以去打印v1和v2
# 输出v1和v2时
# 是按照每个字节并且是十六进制的方式输出的
print(v1)  # b'\xe5\xab\x82 \xe5\xad\x90'
print(v2)  # b'\xc9\xa9 \xd7\xd3'
# v1输出的前三字节表示“嫂”，后三个表示“子”
# 每个字节用斜杠隔开
# v2输出的前二字节表示“嫂”，后二个表示“子”

延伸：字节类型转换回字符串类型

1
2
3
4
5
s1 = v1.decode("utf-8")  # 嫂子
s2 = v2.decode("gbk")  # 嫂子
# 用什么字节类型的编码方式，就在括号内输入什么
print(s1)
print(s2)

字符串居左、中、右

居中：

1
2
3
4
5
6
7
v1 = "王老汉"

data = v1.center(20,"*")
# 让王老汗放在输出的中间
# 并让其前面用*号占位，后面用*号占位
print(data)
# 输出结果：********王老汉*********

居左：

1
2
3
4
5
6
7
v1 = "王老汉"

data = v1.ljust(21,"-")
# 让王老汗放在输出的左边
# 并让后面用-号占位
print(data)
# 输出结果：王老汉------------------

居右：

1
2
3
4
5
6
7
v1 = "王老汉"

data = v1.rjust(21,"-")
# 让王老汗放在输出的右边
# 并让前面用-号占位
print(data)
# 输出结果：------------------王老汉

字符串输出填充

Zfill （帮助你填充0）类似于居左、中、右，但居左、中、右这更灵活

1
2
3
4
5
6
7
8
9
data = "alex"
v1 = data.zfill(10)
print(v1)  # 000000alex

# 应用场景：处理二进制数据

data = "101"
v1 = data.zfill(8)
print(v1)  # ”00000101“

了解更多独有功能

更多的字符穿独有功能，可以通过pycharm中python的源码区了解

打开pycharm中python源码的操作步骤

  1. 在pycharm中输入str
  2. 按住键盘的一个按键

​ Windows用户按：ctrl键

​ Mac用户按：cmd键

  1. 之后把鼠标放在str上（此时鼠标会变成一个小手）
  2. 点击鼠标左键（此时就跳转到了python的源码中）

公共功能

相加

字符串+字符串

1
2
v1 = "alex" + "大sb"
print(v1)  # alex大sb

相乘

字符串*整数

1
2
data = "嫂子" * 3
print(data)  # 嫂子嫂子嫂子

求长度

1
2
3
4
5
6
7
8
data = "嫂子满身大汉"

value = len(data)  # 计算字符串"嫂子满身大汉"的长度
print(value)  # 6

data = "dasdasd"
value = len(data)
print(value)  # 7

获取字符、索引

1
2
3
4
5
6
7
8
9
10
message = "来做点py交易呀"
# 正着取    0 1 2345 6 7
# 倒着取       ...-3-2 -1
print(message[0])  # '来'  # 在计算机中，第一个字的序号是0
print(message[1])  # '做'
print(message[2])  # '点'

print(message[-1])  # 呀
print(message[-2])  # 易
print(message[-3])  # 交

注意：字符串只能通过索引来取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
message[0] = "去"  # 这是不可以的


# 索引的应用
message = "来做点py交易呀"
index = 0

while index < len(message):
    value = message[index]
    print(value)
    index += 1
# 如果索引的数字大于字符串的长度，那么程序就会直接报错
# 并不会跳出循环


# 倒序的索引
message = "来做点py交易呀"
index = len(message) - 1
# 索引是从零开始，而字符串的长度是从1开始
# 所以算出长度后要减去1
while index >= 0:
    value = message[index]
    print(value)
    index -= 1

获取字符串中的子序列、切片

获取字符串中的子序列、切片（与索引相似，只不过索引是获取里面的某个字符，切片获取的是这里面的某些字符）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
message = "来做点py交易呀"

text = message[0:2]
# 把从第零个位置（包含第零个）到第二个序号的位置（不包含第二个）
# 类似于数学上的左闭又开区间
print(text)  # 来做
print(message[3:7])  # py交易
print(message[3:])  # py交易呀
# 后面不加：从三开始取到最后
print(message[:5])  # 来做点py
# 前面不加：从头开始取到后面数字的前一位序号
# 右边依然是开区间
print(message[4:-1])  # y交易
# 右边依然不包含，顺序是从第四位取到第六位的序号
print(message[4:-2])  # y交
# 与len结合使用
print(message[4:len(message)])  # y交易呀
# 注意message的长度是8
  • 注：字符串中的切片只能读取数据，无法修改数据。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】
1
2
3
4
message[0:2] = "去搞"  # 程序会报错
message = "来做点py交易呀"
value = message[:3] + "python" + message[5:]
print(value)  # 来做点python交易呀

跳跃取字符串内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
name = "生活不是电影，生活比电影苦"

print(name[0:5:2])  # 输出：生不电
# 前两个值表示区间范围，最后一个值表示步长
# 如个最后一个值不写那么就会逐一依次从小到大的序号取
print(name[:8:2])  # 输出：生不电，
# 区间范围的前面不写则表示起始范围为0开始
print(name[2::3])  # 输出：不影活影
# 区间范围的后面不写则表示结束范围为最后
print(name[::2])  # 输出：生不电，活电苦
# 区间范围不写表示整个字符串
print(name[8:1:-1])  # 输出：活生，影电是不
# 倒序
# 依然还是前取后不取
# 面试题：给你一个字符串，请将这个字符串翻转。
value = name[::-1]
value = name[-1::-1]
print(value)  # 苦影电比活生，影电是不活生

循环

  • while循环
1
2
3
4
5
6
message = "来做点py交易呀"
index = 0
while index < len(message):
    value = message[index]
    print(value)
    index += 1
  • for循环
1
2
3
message = "来做点py交易呀"
for char in message:
    print(char)
  • range：帮助我们创建一系列的数字
1
2
3
4
5
range(10)  # [0,1,2,3,4,5,6,7,8,9]
range(1,10)  # [1,2,3,4,5,6,7,8,9]
# 依旧遵循”前取后不取“原则
range(1,10,2)  # [1,3,5,7,9]
range(10,1,-1)  # [10,9,8,7,6,5,4,3,2]
  • for+range
1
2
3
4
5
6
7
8
message = "来做点py交易呀"

for i in range(5):  # [0,1,2,3,4]
    message[i]


for i in range(len(message)):  # [0,1,2,3,4,5,6,7]
    print(message[i])

索引除了以上两种还可以：

1
2
3
message = "来做点py交易呀"
for char in message:
    print(char)

  • 注：与while循环相比，for循环更简洁，但并不意味着for循环可以代替while循环

    以下是while循环的应用场景

  • while，一般在做无限制（未知）循环次数时使用

1
2
3
4
5
6
7
8
9
10
11
while True:
    ...

# 用户输入一个值，如果不是整数则一直输入，直到是整数了才结束
num = 0
while True:
    data = input("请输入内容：")
    if data.isdecimal():
        num = int(data)
    else:
        print("输入错误，请重新输入！")
  • for循环，一般应用在已知的循环数量的场景
1
2
3
4
5
6
message = "来做点py交易呀"
for char in message:
    print(char)

for i in range(30):
    print(message[i])
  • break和continue关键字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
message = "来做点py交易呀"
for char in message:
    if char == "p":
        continue
    print(char)
# 输出：
来
做
点
y
交
易
呀


message = "来做点py交易呀"
for char in message:
    if char == "p":
        break
    print(char)
# 输出：
来
做
点
  • 嵌套
1
2
3
4
for i in range(5):
    print(i)  # 0 1 2 3 4
    for j in range(3):
        print(j) # 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2

如果在内循环出现了break 和 continue只影响当前循环，不影响外面循环

1
2
3
4
5
for i in range(5):
    print(i)  # 0 1 2 3 4
    for j in range(3):
        break
        print(j) # 该输出函数不会输出

转换

1
2
3
4
5
6
7
8
num = 999
data = str(num)
print(data)  # "999"

data_list = ["alex","eric",999]

data = str(data_list)
print(data)  # "["alex","eric",999]"

一般情况下，只有整型转字符串才常用

其他

字符串不可被修改

字符串在创建之后不能被修改，我们所见到的是：修改好的字符串，去创建一个新的内存。

1
2
3
4
name = "武沛齐" 

name[1]
name[1:2]

索引或者切片并不是从字符串里面拿字符串，而是新创建了一个字符串，可以认为与原字符串没有关系

  • 而列表的元素是允许被修改的：

num_list = [11,22,33]

num_list[0] # 把11取出来
num_list[0] = 666
# 把列表里此位置的元素即11修改成666

总结

  1. 整型在Python2和Python3中的区别？
  2. 进制之间的转换。
  3. 其他类型转换为布尔类型时，空和0为False，其他均为Tr
  4. 条件语句中可自动化转换布尔类型来做判断
1
2
3
4
if "武沛齐":
    print(666)
else:
    print(999)
  1. 字符串中常见的独有功能
  2. 字符串中常见的公共功能
  3. 字符串创建之后是不可以被修改的

补充

eval函数

  • 该函数可以自动识别数据类型