八、基本数据类型内置方法

一、数据类型

1.1定义

# 1、定义：
# 1.1 整型int的定义
age=10  # 本质age = int(10)

# 1.2 浮点型float的定义
salary=3000.3  # 本质salary=float(3000.3)

# 注意：名字+括号的意思就是调用某个功能，比如
# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能

1.2类型转换

# 1、数据类型转换
# 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
>>> s = '123'
>>> res = int(s)
>>> res,type(res)
(123, <class 'int'>)

>>> int('12.3') # 错误演示：字符串内包含了非整数符号.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '12.3'

# 1.2 进制转换
# 十进制转其他进制
>>> bin(3)
'0b11'
>>> oct(9)
'0o11'
>>> hex(17)
'0x11'
# 其他进制转十进制
>>> int('0b11',2)
3
>>> int('0o11',8)
9
>>> int('0x11',16)
17

# 1.3 float同样可以用来做数据类型的转换
>>> s = '12.3'
>>> res=float(s)
>>> res,type(res)
(12.3, <class 'float'>)

1.3 使用

数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法

’

二、字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。

var1 = 'Hello World!'
var2 = "Kevin"

注: 字符串不可修改

3.1访问字符串中的值

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

# 变量[头下标:尾下标]
# 字符串[开始索引：结束索引：步长]  注意:
# 切取字符串为开始索引到结束索引-1内的字符串
# 步长不指定时步长为1 字符串[开始索引:结束索引]

>>> str1 = 'hello python!'

# 1.按索引取值(正向取，反向取)：
# 1.1 正向取(从左往右)
>>> str1[6]
p
# 1.2 反向取(负号表示从右往左)
>>> str1[-4]
h
# 1.3 对于str来说，只能按照索引取值，不能改
>>> str1[0]='H' # 报错TypeError

# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到8的所有字符
>>> str1[0:9]  
hello pyt
# 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符
>>> str1[0:9:2]  
hlopt 
# 2.3 反向切片
>>> str1[::-1]  # -1表示从右往左依次取值
!nohtyp olleh

内置方法

1.判断字符串是否以XX开头

startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

# 语法
str.startswith(substr, beg=0,end=len(string));

#str -- 检测的字符串。
#substr -- 指定的子字符串。
#strbeg -- 可选参数用于设置字符串检测的起始位置。
#strend -- 可选参数用于设置字符串检测的结束位置。

str = "this is string example....wow!!!"
print (str.startswith( 'this' ))   # 字符串是否以 this 开头
print (str.startswith( 'string', 8 ))  # 从第九个字符开始的字符串是否以 string 开头
print (str.startswith( 'this', 2, 4 )) # 从第2个字符开始到第四个字符结束的字符串是否以 this 开头

2.判断字符串是否以 XX 结尾？得到一个布尔值

v1 = "叨逼叨的一天，烦死了"
result = v1.endswith("烦死了")
print(result) # 值为True

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

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

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

v1 = "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("请正确输入数字")
 
v1 = "123"
print(v1.isdecimal()) # True
v2 = "①"
print(v2.isdecimal()) # False
v3 = "123"
print(v3.isdigit()) # True
v4 = "①"
print(v4.isdigit()) # True

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

# 案例
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啊，树哥"

补充

# 案例
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啊，树"

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

msg = "my name is oliver queen"
data = msg.upper()

print(msg) # my name is oliver queen
print(data) # 输出为：MY NAME IS OLIVER QUEEN

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

msg = "My Name Is Oliver Queen"
data = msg.lower()

print(data) # 输出为：my name is oliver queen

7.字符串内容替换，得到一个新的字符串

data = "你是个好人，但是好人不合适我"
value = data.replace("好人","贱人")
print(data)  # "你是个好人，但是好人不合适我"
print(value) # "你是个贱人，但是贱人不合适我"

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

split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。

data = "kevin|root|kevin@163.com"
result = data.split('|')  
print(data)  #kevin|root|kevin@163.com
print(result) # ['kevin', 'root', 'kevin@163.com']

data = "kevin|root|kevin@163.com"
result = data.split('|', 1)  # 1为切割次数
print(data)
print(result) # ['kevin', 'root|kevin@163.com']

9.字符串拼接

data_list = ["Kevin","age","address"]
v1 = "_".join(data_list) 
print(v1)  # Kevin_age_address

10.字符串转换为字节类型

data = "嫂子"  # unicode，字符串类型

v1 = data.encode("utf-8")  # utf-8，字节类型
v2 = data.encode("gbk")  # gbk，字节类型

print(v1)  # b'\xe5\xab\x82 \xe5\xad\x90'
print(v2)  # b'\xc9\xa9 \xd7\xd3'

s1 = v1.decode("utf-8") # 嫂子
s2 = v2.decode("gbk") # 嫂子
print(s1)
print(s2)

11.将字符串内容居中、居左、居右展示

v1 = "王老汉"
# data = v1.center(21, "-")
# print(data) #---------王老汉---------

# data = v1.ljust(21, "-")
# print(data) # 王老汉------------------

# data = v1.rjust(21, "-")
# print(data) # ------------------王老汉

12.帮助你填充0

data = "Kevin"
v1 = data.zfill(10)
print(v1) # 000000Kevin

三、列表

列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

3.1 定义

user_list =  ["妲己","王昭君","甄姬"]
number_list = [98,88,666,12,-1]
data_list = [1,True,"Kevin","亚瑟","安其拉"]
user_list = []
user_list.append("夏侯惇")
user_list.append(123)
user_list.append(True)
print(user_list) # ["夏侯惇",123,True]

不可变类型：字符串、布尔、整型（已最小，内部数据无法进行修改）

可变类型：列表（内部数据元素可以修改）

3.2内置方法

3.2.1 追加(append)

data_list = []
v1 = input("请输入姓名")
data_list.append(v1)

v2 = input("请输入姓名")
data_list.append(v2)
print(data_list) # ["Kevin","name"]

# 案例2
welcome = "欢迎使用NB游戏".center(30, '*')
print(welcome)

welcome = "欢迎来玩游戏".center(30, '*')
print(welcome)
user_count = 0
while True:
    count = input("请输入参加游戏人数:")
    if count.isdecimal():
        user_count = count
        break
    else:
        print("你输入的不是数字, 请重新输入")

message = "参加游戏人数为{}".format(user_count)

user_name_list = []
for item in range(1, int(user_count)+1):
    tips = "请输入第{}个玩家的姓名".format(item)
    name = input(tips)
    user_name_list.append(name)
print(user_name_list)

3.2.2批量追加(extend)

tools = ["搬砖", "菜刀", "榔头"]
tools.extend([123, 23, 123])
print(tools)

3.2.3插入值

user_list = ["夏洛特", "李信", "吕布", "二师兄"]
user_list.insert(0, "孙策")
print(user_list)


name_list = []

while True:
    name = input("请选择位置和姓名（Q/q退出）:")
    if name.upper() == "Q":
        break
    elif name.startswith("上单"):
        name_list.insert(0, name)
    else:
        name_list.append(name)

print(name_list)

3.2.4在原列表中根据值删除(revom)

#注（从左到右找到第一个删除）【慎用，里面没有会报错】
name_list = ['上单赵云', '打野刘备', '中单诸葛亮', '射手孙尚香', '辅助张飞']
name_list.remove("辅助张飞")
print(name_list)


import random

data_list = ["iphone12", "华为P50", "1+9Pro", "小米12", "100块"]

while data_list:
    name = input("自动抽奖程序，请输入自己的姓名：")
    # 随机从data_list抽取一个值出来
    value = random.choice(data_list)
    print("恭喜{}，抽中{}.".format(name, value))
    data_list.remove(value)

3.2.5在原列表中根据索引踢出某个元素（根据索引位置删除）

user_list = ['上单赵云', '打野刘备', '中单诸葛亮', '射手孙尚香', '辅助张飞']
#               0            1        2            3         4
user_list.pop(1)
print(user_list)  # ['上单赵云', '中单诸葛亮', '射手孙尚香', '辅助张飞']


user_queue = []

while True:
    name = input("长沙~上海火车票，购买请输入姓名排队(Q退出)：")
    if name == "Q":
        break
    user_queue.append(name)

ticket_count = 3
for i in range(ticket_count):
    username = user_queue.pop(0)
    message = "恭喜{},购买火车票成功。".format(username)
    print(message)

faild_user = "、".join(user_queue)
faild_message = "非常抱歉，票已售完，以下几位用户请选择其他出行方式，名单：{}。".format(faild_user)
print(faild_message)

3.2.6清空列表

data_list = ['上单赵云', '打野刘备', '中单诸葛亮', '射手孙尚香', '辅助张飞']
data_list.clear()
print(data_list)  # []

3.2.7 根据值获取索引

# 从左到右找到第一个删除【慎用，找不到报错】

data_list = ['上单赵云', '打野刘备', '中单诸葛亮', '射手孙尚香', '辅助张飞']
if "上单赵云" in data_list:
    index = data_list.index("上单赵云")
    print(index)
else:
    print("不存在")

3.2.8列表元素排序

num_list = ["Kevin", "夏洛特", "b", "a"]
num_list.sort()
print(num_list)
# 注: 排序的列表中不能存在不同类型的数据, 不能是嵌套列表, 不然会报错

3.2.9列表反转

data_list = ['三毛', '矛盾', '路遥', '余华', '莫言']
data_1 = data_list[::-1]
print(data_1)  # ['莫言', '余华', '路遥', '矛盾', '三毛']
print(data_list)  # ['三毛', '矛盾', '路遥', '余华', '莫言']
data_list.reverse()
print(data_list)  # ['莫言', '余华', '路遥', '矛盾', '三毛']

四、字典

字典是 无序、键不重复 且 元素只能是键值对的可变的 个 容器。

data = { "k1":1,  "k2":2 }

字典中对键值得要求：

• 键：必须可哈希。 目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。
• 值：任意类型。

data_dict = {
    "Kevin": 29,
    True: 5,
    123: 5,
    (11, 22, 33) : ["Kevin","age"]
}

# 不合法
v1 = {
    [1, 2, 3]: '周杰伦',
    "age" : 18
} 
v2 = {
    {1,2,3}: "哈哈哈",
    'name':"Kevin"
} 

v3 = {
    {"k1":123,"k2":456}: '呵呵呵',
    "age":999
}

4.1获取值(get)

info = { 
    "马尔克斯":"百年孤独", 
    "村上春树":"那威的森林", 
    "海明威":"老人与海"
}
info.get("name")  # Kevin

data = info.get("email") # 键不存在，默认返回 None

4.2获取所有的键(keys)

info = { 
    "巴金": "随想录", 
    "林语堂": "生活的艺术", 
    "张爱玲": None,
    "沈从文": "边城(编程)",
    "钱钟书": "围城",
}
data = info.keys()  # dict_keys(['巴金', '林语堂', '张爱玲', '沈从文', '钱钟书'])
data_list = list(data)
print(data_list)

# Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。
for item in info.keys():
    print(item)

4.3所有的值(value)

info = {
    "老舍":"骆驼祥子",
    "冰心":"往事知多少",
    "郭沫若":"女神"
}

data = info.values()
print(data)  # dict_values(['骆驼祥子', '往事知多少', '女神'])


for item in info.values():
    print(item)

4.4所有的键值(items)

info = {
    "矛盾": "子夜",
    "金庸": "鹿鼎记",
    "莫言": "红高粱"
}
data = info.items()  
print(data)  # dict_items([('矛盾', '子夜'), ('金庸', '鹿鼎记'), ('莫言', '红高粱')])

for item in data:
    print(item)
    
>>>('矛盾', '子夜')
>>>('金庸', '鹿鼎记')
>>>('莫言', '红高粱')

5.添加值(setdefault)

data = {
    "李白": "将进酒",
    "苏轼": '定风坡',
    "马致远": "天津沙秋思"
}
data.setdefault("柳宗元", "江雪")
print(data)

6.更新字典键值对(update)

data = {
    "曹操": "短歌行",
    "阮籍": '咏怀八十二首',
    "曹植": "洛神赋"
}
data.update({"阮籍": "咏怀"})
print(data) # {'曹操': '短歌行', '阮籍': '咏怀', '曹植': '洛神赋'}

7.移除指定的键值对(pop)

data = {
    "王羲之": "兰亭序",
    "苏轼": '赤壁赋',
    "王安石": "游褒禅山记",
    "王勃": "滕王阁序"
}
data.pop("王安石")
print(data) # {'王羲之': '兰亭序', '苏轼': '赤壁赋', '王勃': '滕王阁序'}

for key, value in items.data:
    print(key, value)

8.按循序移除(popitem)

# 如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
data = {
    "王羲之": "兰亭序",
    "苏轼": '赤壁赋',
    "王安石": "游褒禅山记",
    "王勃": "滕王阁序"
}
data.popitem()
print(data)  # {'王羲之': '兰亭序', '苏轼': '赤壁赋', '王安石': '游褒禅山记'}

data.popitem()
print(data){'王羲之': '兰亭序', '苏轼': '赤壁赋'}

5.集合

集合是一个 无序 、可变、不允许数据重复的容器。

• 无序，无法通过索引取值。
• 可变，可以添加和删除元素。

set_1 = { 11, 22, 33, "Kevin"}

• 不允许数据重复。

v1 = {11,22,33,44}
v1.add(22)
print(v1) # {11,22,33,44}

注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。

5.1添加元素(add)

data = {"杜甫", "白居易", "李白"}
data.add("王维")
print(data)  # {"杜甫", "白居易", "李白","王维"}

5.2删除元素(discard)

data = {"杜甫", "白居易", "李白","王维"}
data.discard("王维")
print(data)  # {"杜甫", "白居易", "李白"}

5.3交集(intersection)

data = {"杜甫", "白居易", "李白", "王维"}
data_set = {"李白", "杜甫", "苏轼", "陶渊明"}
set_data = data.intersection(data_set)
print(set_data)

5.4并集(union)

set_data = {"欧阳修", "王安石", "苏轼","苏洵", "韩愈", "柳宗元"}
data = {"杜甫", "白居易", "李白","柳宗元", "苏轼",}
data_set = set_data.union(data)  
print(data_set)  # {'韩愈', '柳宗元', '杜甫', '白居易', '李白', '欧阳修', '苏洵', '苏轼', '王安石'}

5.5差集(difference)

data = {"杜甫", "白居易", "李白","柳宗元", "苏轼",}
data_set = {"柳宗元", "苏轼"}  
set_data = data.difference(data_set)
print(set_data)  #{'李白', '杜甫', '白居易'}