Python 基本数据类型程序设计题 python基本数据类型包括

第3章 Python的基本数据类型

• 1. 数值数据类型

• 1.1 整数与浮点数的运算
• 1.2 强制数据类型的转换
• 1.3 数值运算常用的函数

• 2. 布尔值数据类型
• 3. 字符串数据类型

• 3.1 字符串的连接
• 3.2 处理多于一行的字符串
• 3.3 逸出字符
• 3.4 强制转换为字符串str()
• 3.5 字符数据的转换
• 3.6 使用字符串加法和换行字符\n
• 3.7 格式化输出
• 3.8 字符串切片
• 3.9 字符串常用操作之查找
• 3.10 字符串常用操作之修改
• 3.11 字符串常用操作之判断

Python的基本数据类型有下列几种：

1. 数值数据类型（numeric type）。常见的数值数据可分为整数（int）类型、浮点数（float）类型，不论是整数或浮点数都可以是任意大小。
2. 布尔值（boolean）数据类型。也可归为数值数据类型。
3. 文字序列类型（text sequence type）。即字符串（string）数据类型。
4. 序列类型（sequence type）。list、tuple。
5. 对映类型（mapping type）。dict。
6. 集合类型（set type）。集合set。

由于变量在使用前不需要声明，同时程序设计过程中，变量的数据类型会改变，通常需要使用type()函数判断目前的变量数据类型。type()函数可列出变量的数据类型类别。

列出数值变量的数据类型：

>>> x = 10
>>> y = x / 3
>>> print(x)
10
>>> print(type(x))
<class 'int'>
>>> print(y)
3.3333333333333335
>>> print(type(y))
<class 'float'>
>>>

1. 数值数据类型

Python在声明变量时可以不用设置这个变量的数据类型，未来如果这个变量内容是存放整数，这个变量就是整数（int）数据类型；如果这个变量内容是存放浮点数，这个变量就是浮点数数据类型。整数与浮点数最大的区别是：整数不含小数点，浮点数含小数点。

1.1 整数与浮点数的运算

Python程序设计时不相同数据类型也可以执行运算，程序设计时，常会发生整数与浮点数之间的数据运算。Python具有简单的自动转换能力，在计算时会将整数转换为浮点数再执行运算。

不同数据类型的运算实例：

>>> x = 10
>>> y = x + 5.5
>>> print(x, type(x), y, type(y))
10 <class 'int'> 15.5 <class 'float'>

此外，如果某一个变量是整数，如果最后所存储的值是浮点数，Python也会将此变量转换成浮点数。

>>> x = 10
>>> print(x, type(x))
10 <class 'int'>
>>> x += 5.5
>>> print(x, type(x))
15.5 <class 'float'>
>>>

1.2 强制数据类型的转换

有时设计程序时，可自行强制使用下列函数，转换变量的数据类型。

• int()：将数据类型强制转换成整数。
• float()：将数据类型强制转换为浮点数。

将浮点数强制转换为整数的运算。

# ch3_4.py
x = 10.5
print(x, type(x)) # 加法前列出x数据类型
y = int(x) + 5
print(y, type(y)) # 加法后列出y数据类型
z = float(y) + 5
print(z, type(z)) # 加法后列出z数据类型

执行结果：

============================== RESTART: E:/Python-Files/ch3/ch3_4.py =============================
10.5 <class 'float'>
15 <class 'int'>
20.0 <class 'float'>
>>>

1.3 数值运算常用的函数

下列是数值运算时常用的函数：

1. abs()：计算绝对值。
2. pow(x,y)：返回x的y次方。
3. round(x,n)：x为要处理的数字，n是小数字数。如果省略n，则表示取整数忽略小数字数；若n不为空，则表示需保留n位小数。*处理整数时，如果处理位数左边是奇数，则四舍五入；如果处理位数左边是偶数，则五舍六入。*例如：round(1.5)=2,round(2.5)=2。

>>> x, y = round(1.5), round(2.5)
>>> print(x, y)
2 2
>>>

处理小数时，采用下一小数字数采用“5”以下舍去，“51”以上进位的处理方式。例如：

>>> round(2.15,1)
2.1
>>> round(2.25,1)
2.2
>>> round(2.151,1)
2.2
>>> round(2.251,1)
2.3
>>> round(2.152,2)
2.15
>>> round(2.155,2)
2.15
>>> round(2.156,2)
2.16
>>> round(2.149,2)
2.15
>>>

abs()、pow()、round()函数的应用。

# ch3_5.py
x = -10
print("以下输出abs()函数的应用")
print(x) # 输出变量x
print(abs(x)) # 输出abs(x)
x, y = 5, 3
print("以下输出pow()函数的应用")
print(pow(x, y))
x = 47.5
print(round(x))
x = 48.5
print(round(x))
x = 49.5
print(round(x))
print("以下输出round(x,n)函数的应用")
x = 2.15
print(round(x,1))
x = 2.25
print(round(x,1))
x = 2.151
print(round(x,1))
x = 2.251
print(round(x,1))

============================== RESTART: E:/Python-Files/ch3/ch3_5.py =============================
以下输出abs()函数的应用
-10
10
以下输出pow()函数的应用
125
48
48
50
以下输出round(x,n)函数的应用
2.1
2.2
2.2
2.3
>>>

2. 布尔值数据类型

Python的布尔值（boolean）数据类型有两种，True（真）或False（伪），它的数据类型代号为bool。一般应用于程序流程的控制中，特别是条件语句中，程序可根据该布尔值判断应该如何执行工作。

>>> x = True
>>> print(x,type(x))
True <class 'bool'>
>>> y = False
>>> print(y,type(y))
False <class 'bool'>
>>>

3. 字符串数据类型

字符串（string）数据是指两个单引号（‘’）或双引号（“”）之间任意个数符号的数据，其数据类型代号为str。在英文字符串的使用中，通常会出现字符串中间出现单引号（单引号也属于字符串中的一部分），这种情况下，可以使用双引号或转义字符处理。

>>> x = 'This is Tom's book!'
SyntaxError: invalid syntax
>>> x = "This is Tom's book!"
>>> print(x)
This is Tom's book!
>>> x = 'This is Tom\'s book!'
>>> print(x)
This is Tom's book!
>>>

# 1.一对引号字符串
name1 = 'Tom'
name2 = "David"
# 字符串跨行
str1 = 'hello'\
        'world'
print(str1)

# 2.三引号字符串
name3 = 'Judy'
# 三引号形式的字符串支持换行
name4 = """Lily"""
a = '''I am Jacky,
        nice to meet you!'''
print(a)
b = """I am Jacky,
        nice to meet you!"""
print(b)

# 转义字符
c = 'I\'m Lihua, coming from Shanghai'
print(c)

3.1 字符串的连接

数学的运算符“+”，可以执行两个字符串相加，产生新的字符串。

x = 123
y = 456
z = x + y
print("数值相加：",z)
str1 = "123"
str2 = "456"
str3 = str1 + str2
print("由数值组成的字符串相加：",str3)
str4 = str1 + " " + str2
print("由数值组成的字符串相加，同时中间加上一个空格：",str4)
str5 = "Hello"
str6 = "World!"
str7 = str5 + str6
print("一般字符串相加：",str7)

数值相加： 579
由数值组成的字符串相加： 123456
由数值组成的字符串相加，同时中间加上一个空格： 123 456
一般字符串相加： HelloWorld!

3.2 处理多于一行的字符串

如果字符串长度多于一行，可以使用3个单引号（或3个双引号）将字符串包括即可。（与注释的处理方式类似）

str1 = '''天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为，
所以动心忍性，增益其所不能。'''
print(str1)
str2 = """北冥有鱼，其名为鲲。鲲之大，不知其几千里也；化而为鸟，其名为鹏。鹏之背，不知其几千里也；怒而飞，其翼若垂天之云。
是鸟也，海运则将徙于南冥。南冥者，天池也。"""
print(str2)

天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为，
所以动心忍性，增益其所不能。
北冥有鱼，其名为鲲。鲲之大，不知其几千里也；化而为鸟，其名为鹏。鹏之背，不知其几千里也；怒而飞，其翼若垂天之云。
是鸟也，海运则将徙于南冥。南冥者，天池也。

3.3 逸出字符

在字符串使用中，如果字符串内有一些特殊字符，例如：单引号、双引号等，必须在特殊符号前加上反斜杠（“\”）进行转义，才能正常使用，这种含有“\”符号的字符叫做逸出字符。

逸出字符	Hex值	意义
\’	27	单引号
\"	22	双引号
\\	5C	反斜杠
\a	07	响铃
\b	08	BackSapce键
\f	0C	换页
\n	0A	换行
\o		8进制表示
\r	0D	光标移至最左位置
\x		16进制表示
\t	09	Tab键效果
\v	0B	垂直定位

字符串使用过程中，尤其是碰到字符串含有单引号时，如果是使用单引号定义这个字符串，必须使用逸出字符；如果使用的是双引号定义该字符串，则可以不使用逸出字符。

# 以下输出使用单引号设置的字符串，需使用\'
str1 = 'I can\'t stop loving you.'
print(str1)
# 以下输出使用双引号设置的字符串，不需使用\'
str2 = "I can't stop loving you."
print(str2)
# 以下输出有\t和\n字符
str3 = "I \tcan't stop \nloving you."
print(str3)

I can't stop loving you.
I can't stop loving you.
I 	can't stop 
loving you.

3.4 强制转换为字符串str()

str()函数可以强制将数值数据转换为字符串数据。

x = 123
y = 456
z = x + y
print("数值相加：",z,type(z))
str1 = str(x) + str(y)
print("强制转换为字符串相加：",str1,type(str1))

数值相加： 579 <class 'int'>
强制转换为字符串相加： 123456 <class 'str'>

3.5 字符数据的转换

如果字符串含一个字符或一个文字时，可以使用下列函数执行数据的转换。

• chr(x)：可以返回函数x值的字符，x是ASCII码值。
• ord(x)：可以返回函数字符参数x的Unicode码值（返回值是对应的十进制整数），如果是中文字也可返回Unicode码值。如果是英文字符，Unicode码值与ASCII码值是一样的。

ch1 = 97
ch2 = chr(ch1)
print(ch2) # 输出数值97的字符
ch3 = ord(ch2)
print(ch3) # 输出字符ch3的Unicode码值
ch4 = '中'
print(ord(ch4)) # 输出字符‘中’的Unicode码值

a
97
20013

3.6 使用字符串加法和换行字符\n

设计程序时，若想将字符串分行输出，可以使用字符串加法功能，在加法过程中加上换行字符“\n”，即可产生字符串分行输出的结果。

str1 = "天行健，君子以自强不息"
str2 = "地势坤，君子以厚德载物"
str3 = str1 + "\n" + str2 + "\n"
print(str3)

天行健，君子以自强不息
地势坤，君子以厚德载物

3.7 格式化输出

# 格式化输出
"""
1.准备数据
2.格式化符号输出数据
"""
age = 19
name = 'Monkey D. Luffy'
gender = 'male'
weight = 80.5
height = 174
reward = 30
occupation = '海贼'
tag = "我是要成为海贼王的男人！海贼王，我当定了！"

# 1.我今年x岁 -- 整数 %d
print('我今年%d岁' % age)  # 我今年19岁

# 2.我叫x -- 字符串 %s
print('我叫%s' % name)  # 我叫Monkey D. Luffy

# 3.我的体重是x公斤 -- 浮点型 %f
print('我的体重是%.1f公斤' % weight)  # 我的体重是80.5公斤

# 4.我的身高是x厘米 -- 整数 %d
print('我的身高是%d' % height)  # 我的身高是174

# 5.目前我的赏金是x亿贝利 -- 整数 %d
print('目前我的赏金是%d亿贝利' % reward)  # 目前我的赏金是30亿贝利

# 6.我的职业是x -- 字符串 %s
print('我的职业是%s' % occupation)  # 我的职业是海贼

# 7.我的口头禅是x -- 字符串 %s
print('我的口头禅是：%s' % tag)  # 我的口头禅是：我是要成为海贼王的男人！海贼王，我当定了！

# 8.我叫x，性别是x，今年x岁，身高x，体重x公斤，职业是x，目前的赏金是x亿贝利。我的口头禅是x
print("我叫%s，性别是%s，今年%d岁，身高%d，体重%.2f公斤，职业是%s，目前的赏金是%d亿贝利。我的口头禅是：%s" % (
    name, gender, age, height, weight, occupation, reward, tag))
# 我叫Monkey D. Luffy，性别是male，今年19岁，身高174，体重80.50公斤，职业是海贼，目前的赏金是30亿贝利。我的口头禅是：我是要成为海贼王的男人！海贼王，我当定了！

# 语法 f'{表达式}'
print(f'我叫{name}，性别是{gender}，今年{age}岁，身高{height}，体重{weight}公斤，职业是{occupation}，目前的赏金是{reward}亿贝利。我的口头禅是：{tag}')
# 我叫Monkey D. Luffy，性别是male，今年19岁，身高174，体重80.5公斤，职业是海贼，目前的赏金是30亿贝利。我的口头禅是：我是要成为海贼王的男人！海贼王，我当定了！

# format()
print("我叫{}，性别是{}，今年{}岁，身高{}，体重{}公斤，职业是{}，目前的赏金是{}亿贝利。我的口头禅是：{}".format(
    name, gender, age, height, weight, occupation, reward, tag))
# 我叫Monkey D. Luffy，性别是male，今年19岁，身高174，体重80.5公斤，职业是海贼，目前的赏金是30亿贝利。我的口头禅是：我是要成为海贼王的男人！海贼王，我当定了！

3.8 字符串切片

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

"""
语法：
序列[开始位置下标:结束位置下标:步长]
注意：
1.不包含结束位置下标对应的数据，正负整数均可；
2.步长是选取间隔，正负整数均可，默认步长为1
"""
str1 = '生活就像海洋，只有意志坚强的人才能到达彼岸'
print(str1[4:6])  # 海洋
# 不写结束，表示选取到最后
print(str1[4:])  # 海洋，只有意志坚强的人才能到达彼岸
# 不写开始，默认从0开始
print(str1[:4])  # 生活就像
# 不写开始和结束，表示选取所有
print(str1[:])  # 生活就像海洋，只有意志坚强的人才能到达彼岸
print(str1[::2])  # 生就海，有志强人能达岸
# 步长默认为1
print(str1[::1])  # 生活就像海洋，只有意志坚强的人才能到达彼岸
print(str1[1:8:3])  # 活海只

# 负数测试
# 步长为负数，表示倒序选取
print(str1[::-2])  # 岸达能人强志有，海就生
print(str1[-4:-1])  # 到达彼
# 不能选取数据：从-4开始到-1结束，选取方向为从左到右，但是步长为-1，从右向左选取
print(str1[-4:-1:-1])  # 如果选取方向（下标开始到结束的方向）和步长的方向冲突，则无法选取数据
print(str1[-4:-1:1])  # 到达彼
print(str1[-1:-4:-1])  # 岸彼达

3.9 字符串常用操作之查找

字符串查找方法即查找子串在字符串中的位置或出现的次数

• find()：检测某个子串是否包含在这个字符串中，包含则返回该子串开始的位置下标，否则返回-1
  语法：字符串序列.find(子串,开始位置下标,结束位置下标)
• index()：检测某个子串是否包含在这个字符串中，存在则返回该子串开始的位置下标，否则报异常
  语法：字符串序列.index(子串,开始位置下标,结束位置下标)
• rfind()：和find()功能相同，但查找方向从右侧开始
• rindex()：和index()功能相同，但查找方向从右侧开始
• count()：返回某个子串在字符串中出现的次数
  语法：字符串序列.count(子串,开始位置下标,结束位置下标)

"""
字符串常用的操作方法有查找、修改和判断三大类
"""
"""
1.查找
字符串查找方法即查找子串在字符串中的位置或出现的次数
- find()：检测某个子串是否包含在这个字符串中，包含则返回该子串开始的位置下标，否则返回-1
语法：字符串序列.find(子串,开始位置下标,结束位置下标)
- index()：检测某个子串是否包含在这个字符串中，存在则返回该子串开始的位置下标，否则报异常
语法：字符串序列.index(子串,开始位置下标,结束位置下标)
- rfind()：和find()功能相同，但查找方向从右侧开始
- rindex()：和index()功能相同，但查找方向从右侧开始
- count()：返回某个子串在字符串中出现的次数
语法：字符串序列.count(子串,开始位置下标,结束位置下标)
"""

str1 = 'In some fields, such as music and art, ' \
       'it is necessary for a person to have som natural ability.'

print(str1.find('n'))  # 1
print(str1.find('s', 1, 16))  # 3
print(str1.find('person'))  # 61
print(str1.find('music'))  # 24
print(str1.find('flow'))  # -1

print(str1.index('music'))  # 24
print(str1.index('m', 1, 16))  # 5

print(str1.rfind('person'))  # 61
print(str1.rfind('music'))  # 24
print(str1.rfind('n'))  # 80

print(str1.rindex('music'))  # 24
print(str1.rindex('n'))  # 80

print(str1.count('s'))  # 10
print(str1.count('s', 4, 24))  # 3
print(str1.count('sas', 4, 24))  # 0
print(str1.count('sa'))  # 1

3.10 字符串常用操作之修改

• replace()：替换
  语法：
  字符串序列.replace(旧子串,新子串,替换次数)
  返回值为修改后的字符串，不会修改原字符串
• split()：按照指定字符分割字符串，返回一个列表
  语法：字符串序列.split(分割字符,num)
  num表示分割字符出现的次数，返回数据个数为num+1个
• capitalize()：将字符串第一个字符转换成大写，其他字符全为小写
• title()：将字符串每个单词首字母转换成大写
• lower()：将字符串中大写转小写
• upper()：将字符串中小写转大写
• strip()：删除字符串两侧空白字符
• lstrip()：删除字符串左侧空白字符
• rstrip()：删除字符串右侧空白字符
• ljust()：返回一个原字符串左对齐，并使用指定字符（默认空格）填充至对应长度的新字符串
• rjust()：返回一个原字符串右对齐，并使用指定字符（默认空格）填充至对应长度的字符串，语法和ljust()相同
• center()：返回一个原字符串居中对齐，并使用指定字符（默认空格）填充至指定长度的新字符串，语法和ljust()相同

"""
2.修改
修改字符串指的是通过函数的形式修改字符串中的数据
- replace()：替换
语法：
    字符串序列.replace(旧子串,新子串,替换次数)
返回值为修改后的字符串，不会修改原字符串
"""

str2 = 'qfeqrjfodfjaosdflsfjsd'

new_str = str2.replace('s', 'k')
print(new_str)  # qfeqrjfodfjaokdflkfjkd
print(str2)  # qfeqrjfodfjaosdflsfjsd

"""
字符串是不可变数据类型
"""

""" 
split()：按照指定字符分割字符串，返回一个列表
语法：字符串序列.split(分割字符,num)
num表示分割字符出现的次数，返回数据个数为num+1个
"""
list1 = str2.split('s')
print(list1)  # ['qfeqrjfodfjao', 'dfl', 'fj', 'd']

list2 = str2.split('f', 3)
print(list2)  # ['q', 'eqrj', 'od', 'jaosdflsfjsd']

# join()：合并列表里面的字符串数据为一个大字符串
mylist = ['a', 'p', 'p', 'l', 'e']
mystr = '...'.join(mylist)
print(mystr)  # a...p...p...l...e

str3 = 'i am Jackson, a singer from Japan'
# capitalize()：将字符串第一个字符转换成大写，其他字符全为小写
print(str3.capitalize())  # I am jackson, a singer from japan

# title()：将字符串每个单词首字母转换成大写
print(str3.title())  # I Am Jackson, A Singer From Japan

# lower()：将字符串中大写转小写
print(str3.lower())  # i am jackson, a singer from japan

# upper()：将字符串中小写转大写
print(str3.upper())  # I AM JACKSON, A SINGER FROM JAPAN

# lstrip()：删除字符串左侧空白字符
mystr = '   shadow in my face happy new year  '
print(mystr.lstrip())  # shadow in my face happy new year
# rstrip()：删除字符串右侧空白字符
print(mystr.rstrip())  #    shadow in my face happy new year

# strip()：删除字符串两侧空白字符
print(mystr.strip())  # shadow in my face happy new year

# ljust()：返回一个原字符串左对齐，并使用指定字符（默认空格）填充至对应长度的新字符串
# 语法：字符串序列.ljust(长度,填充字符)
str_1 = 'loading'
print(str_1.ljust(13, '.'))  # loading......

# rjust()：返回一个原字符串右对齐，并使用指定字符（默认空格）填充至对应长度的字符串，语法和ljust()相同
print(str_1.rjust(13, '.'))  # ......loading

# center()：返回一个原字符串居中对齐，并使用指定字符（默认空格）填充至指定长度的新字符串，语法和ljust()相同
print(str_1.center(13, '.'))  # ...loading...

3.11 字符串常用操作之判断

所谓判断即判断真假，返回的结果为布尔型数据类型True/False

• startswith()：检查字符串是否以指定子串开头，是则返回True，否则返回False。若设置了开始和结束位置下标，则在指定范围内检查。
  语法：字符串序列.startswith(子串,开始位置下标,结束位置下标)
• endswith()：判断字符串是否以某个子串结尾
• isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回False
• isdigit()：如果字符串只包含数字则返回True，否则返回False
• isspace()：如果字符串中只包含空格，则返回True，否则返回False
• isalnum()：数字或字母或组合

"""
所谓判断即判断真假，返回的结果为布尔型数据类型True/False
- startswith()：检查字符串是否以指定子串开头，是则返回True，否则返回False。若设置了开始和结束位置下标，则在指定范围内检查。
语法：字符串序列.startswith(子串,开始位置下标,结束位置下标)
"""

mystr = "hello everybody i am fine thank you what the hell happy new year"

# startswith()：判断字符串是否以某个子串开头
print(mystr.startswith('he'))  # True
print(mystr.startswith('hel'))  # True
print(mystr.startswith('help'))  # False

# endswith()：判断字符串是否以某个子串结尾
print(mystr.endswith('ye'))  # False
print(mystr.endswith('year'))  # True


# isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回False
str_1 = 'pine'
str_2 = '14343'
str_3 = '    '
str_4 = '143af43 a  afds'
str_5 = '143af43afds'

print(str_1.isalpha())  # True
print(str_2.isalpha())  # False
print(str_3.isalpha())  # False
print(str_4.isalpha())  # True

# isdigit()：如果字符串只包含数字则返回True，否则返回False
print(str_1.isdigit())  # False
print(str_2.isdigit())  # True
print(str_3.isdigit())  # False
print(str_4.isdigit())  # False

# isspace()：如果字符串中只包含空格，则返回True，否则返回False
print(str_1.isspace())  # False
print(str_2.isspace())  # False
print(str_3.isspace())  # True
print(str_4.isspace())  # False

# isalnum()：数字或字母或组合
print(str_1.isalnum())  # True
print(str_2.isalnum())  # True
print(str_3.isalnum())  # False
print(str_4.isalnum())  # False
print(str_5.isalnum())  # True

---