python-基础数据类型

数值类型

整数类型（int）

• 整数通常被称为整型，数值为正或者负，不带小数点。表示数字的时候，通常
  使用十进制(decimal) 来表示。

进制	描述	函数
十六进制	用0x前缀和0-9，a-f表示	hex() -->10进制转16进制
八进制	用0o前缀和0-7表示	oct() -->10进制转8进制
二进制	用0b前缀和0-1表示	bin() -->10进制转2进制

• 整数长度32位
• 连续分配内存地址
• 小整数对象池，范围-5~256 （节省开销，增快运行速度）
• 整数缓冲区

浮点数（float）

• 浮点数也就是小数，较大的数一般用科学计数法进行表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等
• 浮点数与整数之间转换

复数（complex）

• 复数由 实数部分 和 虚数部分 构成，可以用 a + bj, 或者 complex(a,b) 表示，
  复数的 实部a 和 虚部b 都是浮点。

数学计算

• 需要导入math模块的科学计算函数有

项目	描述
math.ceil(x)	向上取整
math.floor(x)	向下取整
math.pow(x，y)	x**y（幂次）

import math             # 导入标准库math

print(math.ceil(4.1))   # 5：向上取整

print(math.floor(4.5))  # 4：向下取整

print(math.pow(2, 3))   # x**y  2**3

• 不需要导入math模块：

项目	描述
abs(x)	取绝对值
round(x)	四舍六入五成偶

a = -10                 # 初始化变量a
print(abs(a))           # 10 打印取绝对值后的值


# python3进行改良，不再是四舍五入，而是四舍六入五成偶
print(round(4.1))       # 舍去为4

print(round(4.5))       # 舍去为4

print(round(4.6))       # 进1为5

print(round(3.5))       # 4

注意：五成偶具体解释是：看这个5后面还有没有非0数字，如果没有，就是奇进偶不进，如果有非0数字，不管5前面是奇数还是偶数，都进1，如果这个5后面没有非0数字，这个5前面是奇数就进1，偶数就不进1

布尔值和空值

布尔值

布尔类型就两个值，True和False 注意：首字母必须大写

• 数值类型：0、0.0的bool 值都为False ，其它的都为 True
• 字符串：空字符串的 bool 值为 False，其它的都为 True。注意空格字符串为 True
• 列表：空列表的 bool 值为False，其它的都为 True。
• None 的 bool 值永远为 False
  我们可以通过 python 内置的 bool()函数来测试一个表达式的布尔值的结果

print(bool(True))     # True
print(bool(False))    # False

# 数值：0 0.0的bool值为False,其余的全为True
print(bool(1))        # True
print(bool(-1))       # True
print(bool(0))        # False
print(bool(0.0))      # False

# 字符串：只有空字符串的bool值为False，其余均为True。注意：含有空格的字符串也是非空字符串
print(bool("yes"))    # True
print(bool(""))       # False
print(bool("  "))     # True
print(bool("0"))      # True

# 列表
print(bool([]))              # False
print(bool([1, 2, 3]))       # True

# None
print(bool(None))               # False  None的布尔值永远为False

布尔类型运算

• and 运算
• or 运算
• not 运算
• 算术 运算，注意：把 True 看作1，而 False 看作 0

"""
布尔算数运算
"""
print(True + 1)    # 2
print(False + 1)   # 1

空值

• 空值不是布尔类型，是 Python 里一个特殊的值，用 None 表示（首字母大写）。None 不能理解为0，因为0是整数类型，而 None 是一个特殊的值。None 也不是布尔类型，而是 NoneType

字符串

使用单引号或双引号来创建字符串，使用三引号创建多行字符串

• 字符串的单引号与双引号都是 成对 出现的，不能一边单一边双。
• 字符串是 不可变 的 序列数据类型，不能直接修改字符串本身，和数值类型一样。

字符串的储存

• 整数 在内存中占 一个字节
• 字符串 不管中间多少内容都要 单独存储
  

字符串的下标

• 由于字符串是 序列数据结构 ，所以我们可以通过 下标 将字符串中某个字母取出来。下标也可称为 索引，默认从0开始

字符串的切片

切片模式：a[start:stop:step]
注意：

• 索引默认从0开始
• 切片时左闭右开
• 当是取单个字符的时候,索引超出范围会报错。而切片时不会报错。
• 步长不能为0，也不允许为浮点数

字符串类型转换

字符串组成方式

• 字符串相加

"""
字符串拼接
"""
print('1'+'2')    # 字符串用+做拼接 '12'

• 字符串格式化
  • %s %d %f
  • str.format()
  • python3.6.4 引入 f”

"""
字符串格式化
"""
name = "hansen"
age = 20

# %号格式需要考虑数据类型
# %s --> str
# %d --> decimal
# %f --> float
print("%s年龄为%d" % (name, age))


# str.format() 好处1：不用考虑数据类型 好处2：可以切换位置
# {
     } --> 占坑
print("{1}年龄为{0}".format(age, name))


# f''  python3.6.4以上的版本
# {
     } --> 占坑
print(f"{name}年龄为{age}")

字符串常见操作

• 语句: S.find(sub[, start[, end]])
  返回该元素最小的索引
  • sub–> 查找值（字符串子串）
  • start–> 从该索引位置开始查找
  • end–> 在该索引位置结束查找，如果查找值刚好在该索引位置，不会返回索引位置
  • 返回值类型：整型
  • 查找值不在该字符串之内，程序不会报错返回值-1

# 初始化变量name
name = 'Michael Jackson'

print(type(name.find('c')))     # 返回值类型--> <class 'int'>

print(name.find('c'))           # 返回字符串中第一个字符'c'索引位置--> 2

print(name.find('c', 10, 11))   # 在字符串索引7<= index < 11查找并返回'c'最小索引位置--> 10

print(name.rfind('c'))          # 返回字符串中倒数第一个'c'位置--> 10

print(name.find('A'))         # 查找值'A'明显不在该字符串之内，但程序不会报错,返回值---> -1

• 语句 S.index(sub[, start[, end]])
  返回该元素最小的索引，与s.find()使用方法一样
  区别：

  • 查找值不在该字符串之内，程序报错.（与s.find()的区别点）

• 语句： S.replace(old, new[, count])
  替换

  • old–> 目标值
  • new–> 替换值
  • count–> 替换次数，默认全部替换
  • 返回值类型：字符串类型

# 初始化变量name
name = 'Michael Jackson'

print(name.replace('c', 'C'))     # 将字符串中c 全部替换为C --> 'MiChael JaCkson'

print(name.replace('c', 'C', 1))  # 将字符串中c 替换为C ,仅替换一次--> 'MiChael Jackson'

print(name)                       # 以上操作只是创建副本，不会对原字符串进行修改 -->'Michael Jackson'

• 语句 S.split(sep=None, maxsplit=-1)
  以sep来分割字符串,并返回列表。sep默认为None,分割默认为空格
  • sep–> 使用sep作为分隔符字符串，并在返回值中删除sep （如果未指定sep，则sep=None 任何空白字符串都是分隔符，并从返回值中删除空白字符串。）
  • maxsplit–> 切片次数，默认全部切片
  • 返回值类型：字符串列表类型

# 初始化变量name
name = 'Michael Jackson'

print(name.split("c"))     # 以’c'作为分割符，来分割字符串 -->['Mi', 'hael Ja', 'kson']

print(name.split("c", 1))  # 以’c'作为分割符，来分割字符串.仅进行1次切片 -->['Mi', 'hael Jackson']

print(name.split())        # 未指定分隔符，则视为空白字符串作为分隔符--> ['Michael', 'Jackson']

print(name.split('5'))     # 指定分隔符不在字符串内，则输出整个字符串列表 --> ['Michael Jackson']

• 语句：S.startswith(prefix[, start[, end]])
  判断字符串是否以前缀开始，返回为bool值。如果s以指定的前缀开始，则返回True，否则False
  • prefix–> 前缀值
  • start–> 开始比较位置
  • end–> 结束比较位置
  • 返回值类型：布尔

# 初始化变量name
name = 'Michael Jackson'

print(name.startswith('M'))      # 字符串以‘M’开头 -->True

print(name.startswith('J'))      # 字符串不以‘J’开头 -->False

print(name.startswith('J', 8))   # 字符串在比较起始位置8处以‘J’开头 -->True

• 语句：S.endswith(suffix[, start[, end]])
  判断字符串是否以尾缀结束，返回为bool值。如果字符串以指定的后缀缀结束，则返回True，否则False
  • prefix–> 前缀值
  • start–> 开始比较位置
  • end–> 结束比较位置
  • 返回值类型：布尔

# 初始化变量name
name = 'Michael Jackson'

print(name.endswith('son'))        # 字符串以‘son’结尾 -->True

print(name.endswith('el'))       # 字符串不以‘el’结尾 -->False

print(name.endswith('el', 0, 7))   # 字符串在索引位置0~7内（即字符串'Michael')以‘el’结尾 -->True

• 语句：S.lower()
  将字符串全部转为小写，返回一个转换成全小写字母的字符串副本
  • 返回值类型：字符串

# 初始化变量name
name = 'Michael Jackson'

print(name.lower())  # 将字符串全部转换为全小写字母'michael jackson'

print(name)          # S.lower()不会改变原字符串，只是创建了副本并进行修改 -->'Michael Jackson'

• 语句：S.upper()
  将字符串全部转为大写，返回一个转换成全大写字母的字符串副本
  • 返回值类型：字符串

# 初始化变量name
name = 'Michael Jackson'

print(name.upper())  # 将字符串全部转换为大写字母'MICHAEL JACKSON'

print(name)          # S.upper()不会改变原字符串，只是创建了副本并进行修改 -->'Michael Jackson'

• 语句：S.strip([chars])
  默认去掉字符串左右的空格
  • 返回一个去除掉指定字符的字符串副本
  • 如果chars没有指定值则返回一个去除掉字符串首位空白字符的字符串副本
  • 返回值类型：字符串

# 初始化变量name
name = '-Michael Jackson-   '

print(name.strip())      # 返回一个去除掉字符串首位空白字符的字符串副本-->'-Michael Jackson-'

print(name.strip('-'))   # 返回一个去除掉首尾字符'-'的字符串副本-->'Michael Jackson-   '

• 语句：S.isalpha()
  判断字符串是否全为字母，如果字符串全为字母则返回True 否则False
  • 如果字符串为空，则返回False
  • 返回值类型：布尔

# 初始化变量name,name1,name2
name = 'MichaelJackson'
name1 = 'Michael Jackson'
name2 = ''

print(name.isalpha())   # 字符串全为字母-->True

print(name1.isalpha())  # 字符串不全为字母，存在空白字符-->False

print(name2.isalpha())  # 空字符串-->False

• 语句：S.isdigit()
  判断字符串是否全为数字，如果字符串全为数字则返回True 否则False
  • 如果字符串为空，则返回False
  • 返回值类型：布尔

# 初始化变量name,name1,name2
name = '123456789'
name1 = '1234 5678 9'
name2 = ''

print(name.isdigit())   # 字符串全为字母-->True

print(name1.isdigit())  # 字符串不全为数字，存在空白字符-->False

print(name2.isdigit())  # 空字符串-->False

• S.isalnum()
  判断字符串是否全为数字或者字母，不存在特殊字符，如果字符串全为数字和字母组成则返回True 否则False
  • 如果字符串为空，则返回False
  • 返回值类型：布尔

# 初始化变量name,name1,name2
name = 'ABC123'
name1 = 'ABC 123'
name2 = ''

print(name.isalnum())   # 字符串全为字母和数字-->True

print(name1.isalnum())  # 字符串不全为数字和字母，存在空白字符-->False

print(name2.isalnum())  # 空字符串-->False

• S.join(iterable)
  将序列中的元素以指定的字符连接生成一个新的字符串
• 返回值类型：字符串

# 初始化name，name1
name = 'Michael Jackson'
name1 = list("abcdefg")  # 列表

print(','.join(name))    # 输出打印以字符','连接迭代而成的新字符串-->'M,i,c,h,a,e,l, ,J,a,c,k,s,o,n'

print(','.join(name1))   # 输出打印以字符','连接迭代而成的新字符串-->'a,b,c,d,e,f,g'

作业一

• 当输入y或Y打印进入卸载，
  当输入n或N打印退出程序，
  输入其它则打印输入不在选项范围之内

# 初始化变量option
option = input("卸载程序请输入y/Y，退出程序请输入n/N：")

# 对option进行判断
if option in ['y', 'Y']:    # 输入字符是"y" 或"Y"
    print("进入卸载")               # 输出打印“进入卸载”
elif option in ['n', 'N']:       # 输入字符是"n" 或"N"
    print("退出程序")               # 输出打印“退出程序”
else:                             # 否则
    print("不在选项范围之内")        # 打印输出"不在选项范围之内"

作业三

• 完成字符串的逆序以及统计
  设计一个程序，要求只能输入长度低于20的字符串，
  当满足需求时，则打印出字符串长度
  以及使用切片逆序打印出字符串
  当不满足需求时，打印用户重新输入

# 初始化列表变量str_input
str_input = input("请输入：")

# 判断输入字符长度
if len(str_input) < 20:                                                  # 长度<20
    print(f"该字符长度：{len(str_input)} \n字符逆序：{str_input[::-1]}")   # 输出字符长度和字符逆序
else:                                                                    # 否则
    print("请重新输入")                                                   # 输出“请重新输入”

作业四

• ’3’+’4’的结果是什么？
  结果是： ‘34’
  原因： + 可使两字符串首尾拼接