python数据类型内置方法

python数据类型内置方法

数据类型内置方法理论

在我们平时接触到的数据类型中，都有着多种多样的使用方法，而在python的大多数数据类型中，都有其自带的一些实用方法，这些方法就被称为内置方法

而在python中想要使用这些内置方法时，就需要用到调用统一句式：句点符

'字符串'.字符串内置方法
绑定字符串的变量名.字符串内置方法
str.字符串内置方法

以上三种就是句点符常用的三种方法

整型的内置方法相关操作

• 类型转换——int(纯数字字符串/浮点型)

 ps: str类型只能转换整数(纯数字)、float类型可以用来取整
res = '123'
res1 = 123.9
print(type(res))  # str
print(type(res1))  # float
res = int(res)
res1 = int(res1)  
print(type(res))  # int
print(res1, type(res1))  # 输出结果为123,可见浮点型的转换采取的是一刀切的策略 int

• 进制数转换

做进制数转换
将十进制数转换为其他进制数
print(bin(100))  # 将十进制的100转换成二进制 
print(oct(100))  # 将十进制的100转换成八进制  0o144
print(hex(100))  # 将十进制的100转换成十六进制  0x64
# 0b开头为二进制数  0o开头为八进制数  0x开头为十六进制数
2.将其他进制数转换为十进制数
print(int('0b1100100', 2))  # 100
print(int('0o144', 8))  # 100
print(int('0x64', 16))  # 100

浮点型的内置方法相关操作

• 类型转换——float(数字类字符串/整型)

用途: 将其他类型(str类型和int类型)转换为float类型
res = '123.12'
print(type(res))  # str
res = float(res)  
print(type(res))  # float
print(float('123'))  # 123.0

字符串的内置方法相关操作

• 类型转换——str(需要转换的数据类型)

用途: 将其他"任意类型"转换为str类型
print(str(123))
print(str(123.21))
print(str([1, 2, 3, 4]))
print(str({'name': '李帆', 'age': 25}))
print(str((1, 2, 3, 4)))
print(str(True))
print(str({1, 2, 3, 4}))

• 索引取值——被索引数据/其变量名[索引值]

(起始位置0开始 超出范围直接报错)
A='hello world'
print(A[0])  # 索引第一位h
print(A[-1])  # 索引倒数第一位d

• 切片操作——[y:y]

默认切片顺序是从左到右  
s1 = 'hello world'
print(s1[1:5])  # ello，从索引值起始位置切到结束位置，顾头不顾尾
print(s1[-1:-5])  # 因为默认从左到右的顺序，所以不会执行，但是不会报错
print(s1[-5:-1])  # worl，这样从倒数第五切到倒数第一，符合从左往右的顺序

• 改变切片方向（间隔）——[y:y:y]

s1 = 'hello world'
print(s1[1:5:1])  # ello，默认间隔是1
print(s1[1:5:2])  # el，间隔为2
print(s1[-1:-5:-1])  # dlro当间隔为-1，按照从后向前，逆序切取
print(s1[:])  # hello world，不写数字就默认切取所有数据值
print(s1[2:])  # llo world，从索引2开始往后都要切取
print(s1[:5])  # hello，从索引0切取到索引值4
print(s1[::2])  # hlowrd，按照间隔为2的规律切取

• 统计字符串中字符个数—len

A = 'hello world'
print(len(s1))  # 输出结果为11

• 移除字符串首尾指定的字符——strip()

当括号内不填写任何东西时，默认为移除两端的空格
name = '    tony   '
print(name.strip())  # tony
name1 = '$$tony$$$' 
print(name1.strip('$'))  # tony
# lstrip() 只移除左边  rstrip() 只移除右边的
print(name1.lstrip('$'))  # tony$$$
print(name1.strip('$'))  # $$tony

• 切割字符串中指定的字符——split()

括号内不填写任何东西是默认为空格，输出结果为列表
res = 'lifan|123|18'
print(res.split('|'))  # ['lifan', '123', '18']
print(res.split('|', maxsplit=1))  # ['lifan','123|18']  maxsplit用于控制切割的次数
#默认从左边开始切割
# rsplit  从右边开始切割
print(res.rsplit('|', maxsplit=1))  # ['lifan|123', '18']

• 字符串格式化输出——format

format用法:等价于占位符
 res = 'my name is {} my age is {}'.format('李帆', 25)
 print(res)
 format用法2:索引取值并支持反复使用
 res = 'my name is {0} my age is {1} {0} {0} {1}'.format('李帆', 25)
 print(res)
format用法3:占位符见名知意
res = 'my name is {name1} my age is {age1} {name1} {age1} {name1} '.format(name1='李帆', age1=25)
print(res)
format用法4:
    name = input('username>>>:')
    age = input('age>>>:')
    res = f'my name is {name} my age is {age}'
    print(res)

• 字符串中需要了解的内置方法

1.大小写相关
upper()、lower()
res = 'my NAME IS tom'
print(res.upper())  # MY NAME IS TOM   将英文字符串全部转变为大写
print(res.lower())  # my name is tom   将英文字符串全部转变为小写
# isupper() 和 islower()
res1 = res.upper()
res2 = res.lower()
print(res1.isupper())  # True 判断是否是纯大写
print(res2.isupper())  # False
print(res1.islower())  # False 判断是否是纯小写
print(res2.islower())  # Tru
2.判断字符串中是否是纯数字
res = ''
print(res.isdigit())
guess_age = input('guess_age>>>:').strip()
if guess_age.isdigit():
    guess_age = int(guess_age)
else:
    print('年龄都不知道怎么输吗???')
3.替换字符串中指定的内容
# 用新的字符替换字符串中旧的字符
str1 = 'my name is tom, my age is 18!'  # 将tom的年龄由18岁改成28岁
str1 = str1.replace('18', '28')  # 语法:replace('旧内容', '新内容')
print(str)  # my name is tom, my age is 28!
# 可以指定修改的个数
str1 = 'my name is tom, my age is 18!'
str1 = str1.replace('my', 'MY',1)  # 只把一个my改为MY
print(str1)  # MY name is tom, my age is 18!
4.字符串的拼接
方式1: +
print('hello' + 'world')  # helloworld
方式2: join
# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
# 能被for循环的就是可迭代对象
print('%'.join('hello')) # 'h%e%l%l%o' 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
print('|'.join(['tom','18','read']))  # 'tom|18|read' 从列表中取出多个字符串，然后按照|作为分隔符号进行拼接
5.统计指定字符出现的次数
count:统计字符串在大字符串中出现的次数
msg = "hello everyone"
msg.count('e')  # 统计字符串e出现的次数
6.判断字符串的开头或者结尾
res = 'my name is tom'
# startswith() 判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
print(res.startswith('m'))  # True
print(res.startswith('my'))  # True
# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
print(res.endswith('m'))  # True
print(res.endswith('tom'))  # True
7.其他方法补充
*find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
msg='tony say hello'
msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
*index:同find,但在找不到时会报错
msg.index('e',2,4) # 报错ValueError
*captalize：首字母大写
message = 'hello everyone nice to meet you!'
message.capitalize()
Hello everyone nice to meet you!  
*swapcase：大小写翻转
message1 = 'Hi girl, I want make friends with you!'
message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
*title：每个单词的首字母大写
msg = 'dear my friend i miss you very much'
msg.title()
Dear My Friend I Miss You Very Much

列表的内置方法相关操作

• 类型转换——list(其他数据类型)

能够被for循环的数据类型都可以转成列表
print(list('hello'))
print(list({'name': 'jason', 'pwd': 123}))
print(list((1, 2, 3, 4)))
print(list({1, 2, 3, 4, 5}))

• 索引取值

list1 = ['tom', 'jerry', 'timor', 4, 5]
print(list1[0])  # tom 
print(list1[-1])  # 5

• 切片操作

list1 = ['tom', 'jerry', 'timor', 4, 5]
print(list[0:3])  # ['tom', 'jerry', 'timor'] 
print(list[0:4:2]  # ['tom', 'timor']
统计列表中数据值的个数

• 数据值修改

按照索引修改指定位置的值，但如果索引不存在则报错
list1 = ['tom', 'jerry', 'timor', 4, 5]
list1[0] = 'cat'
print(list1)  # ['cat', 'jerry', 'timor', 4, 5]

• 列表添加数据值方式

append() 列表尾部追加元素
l1 = ['a', 'b', 'c']
print(l1.append('d'))  # ['a', 'b', 'c', 'd']
extend() 一次性在列表尾部添加多个元素
print(l1.extend(['a', 'b', 'c']))   # ['a', 'b', 'c', 'd', 'a', 'b', 'c']
insert() 在指定位置插入元素
print(l1.insert(0,'tom')  # ['tom', 'a', 'b', 'c', 'd', 'a', 'b', 'c']

• 扩展列表\合并列表

ll1 = [11, 22, 33]
ll2 = [44, 55, 66]
print(ll1 + ll2)  # [11, 22, 33, 44, 55, 66]
ll1.extend(ll2) 
print(ll1)  # [11, 22, 33, 44, 55, 66]

• 删除列表数据

*del()  # 按索引删除列表中的值
print(del l1[2])  # ['a', 'b']  删除索引为2的元素
pop()  # 默认删除列表最后一个元素并将删除的值返回 可以通过加入索引来指定删除元素
l1 = ['a', 'b', 'c']
*res = l1.pop()
print(l1)  # ['a', 'b']
print(res)  # c  
*remove()  # 括号内指名道姓表示要删除哪个元素，没有返回值
l1 = ['a', 'b', 'c']
res = l1.remove('b')
print(l1)  # ['a', 'c']
print(res)  # None

• 排序

ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
ss.sort()  # 默认是升序
print(ss)
ss.sort(reverse=True)
print(ss)  # 改为降序

• 统计列表中某个数据值出现的次数

print(列表名.count(数据值))

• 颠倒列表顺序

列表名.reverse()
print(列表名)

可变类型与不可变类型

不可变数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型

可变数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型

# int
int_a = 1
print("整数a的地址{:}；整数a的类型{:}".format(id(int_a), type(int_a)))
int_a = 2
print("整数a的地址{:}；整数a的类型{:}".format(id(int_a), type(int_a)))
# 运行结果：
# 整数a的地址4542888688；整数a的类型<class 'int'>
# 整数a的地址4542888720；整数a的类型<class 'int'>

# 字符串
str_a = 1
print("字符串a的地址{:}；字符串a的类型{:}".format(id(str_a), type(str_a)))
str_a = 2
print("字符串a的地址{:}；字符串a的类型{:}".format(id(str_a), type(str_a)))
# 运行结果：
# 字符串a的地址4451588848；字符串a的类型<class 'int'>
# 字符串a的地址4451588880；字符串a的类型<class 'int'>

# tuple
list_c = [1,2,4]
# 元组中加入列表，验证元组是否地址会发生改变
tuple_c = (1,3,list_c)
print("未修改前元组的值{:},未修改前元组的地址{:}，数据类型：{:}".format(tuple_c, id(tuple_c), type(tuple_c)))
#修改列表的值
list_c[1]='hello'
print("修改后元组的值{:}, 修改后元组的地址{:}，数据类型：{:}".format(tuple_c,id(tuple_c), type(tuple_c)))
# 运行结果：
# 未修改前元组的值(1, 3, [1, 2, 4]),未修改前元组的地址4490637824，数据类型：<class 'tuple'>
# 修改后元组的值(1, 3, [1, 'hello', 4]), 修改后元组的地址4490637824，数据类型：<class 'tuple'>
# 元组定义值是不可更改的，嵌套的列表值虽然发生改变但是地址并未发生变化，表明修改只是在嵌套列表内部产生的效果，并未影响到元组本身，故元组前后值等于没有发生变化，
# 因此说明元组是不可变类型

# 列表
list_b = [1,2,3,4]
print("未修改前列表的值{:},未修改前列表的地址{:},数据类型{:}".format(list_b,id(list_b), type(list_b)))
list_b[1] = 'test'
print("修改后列表的值{:},修改后列表的地址{:},数据类型{:}".format(list_b,id(list_b), type(list_b)))
# 运行结果：
# 未修改前列表的值[1, 2, 3, 4],未修改前列表的地址4495392640,数据类型<class 'list'>
# 修改后列表的值[1, 'test', 3, 4],修改后列表的地址4495392640,数据类型<class 'list'>

# 集合
set_a = {1, 'a', 'bn', 3, 5}
print("未修改前集合的值{:},未修改前集合的地址{:},数据类型{:}".format(set_a,id(set_a), type(set_a)))
set_a.add('test')
print("修改后集合的值{:},修改后集合的地址{:},数据类型{:}".format(set_a,id(set_a), type(set_a)))
# 运行结果：
# 未修改前集合的值{1, 3, 5, 'a', 'bn'},未修改前集合的地址4513094784,数据类型<class 'set'>
# 修改后集合的值{1, 3, 'test', 5, 'a', 'bn'},修改后集合的地址4513094784,数据类型<class 'set'>


# 字典
dict_a = {"test1":1, "test2":2,"test3":3}
print("未修改前字典的值{:},未修改前字典的地址{:},数据类型{:}".format(dict_a,id(dict_a), type(dict_a)))

dict_a['test4'] = 'hello'
print("修改后字典的值{:},修改后字典的地址{:},数据类型{:}".format(dict_a,id(dict_a), type(dict_a)))
# 运行结果：
# 未修改前字典的值{'test1': 1, 'test2': 2, 'test3': 3},未修改前字典的地址4402480192,数据类型<class 'dict'>
# 修改后字典的值{'test1': 1, 'test2': 2, 'test3': 3, 'test4': 'hello'},修改后字典的地址4402480192,数据类型<class 'dict'>

不可变类型:值改变,内存地址肯定变

可变类型:值改变,内存地址不变

通过以上结果验证：

属于可变类型：字典、列表、集合；

属于不可变类型：字符串、整数、元组

练习

# 2.基于字符串充当数据库完成用户登录(基础练习)
#    data_source = 'jason|123'  # 一个用户数据
#    获取用户用户名和密码 将上述数据拆分校验用户信息是否正确
data_source = 'jason|123'
data_source.split('|')
while True:
    username = input('请输入用户名:')
    password = input('请输入用户密码:')
    if username == (data_source.split('|')[0]) and password == (data_source.split('|')[1]):
        print('登陆成功')
        break
    else:
        print('用户名或密码错误')

# 3.基于列表充当数据库完成用户登录(拔高练习)  # 多个用户数据
#    data_source = ['jason|123', 'kevin|321','oscar|222']
# data_source = ['jason|123', 'kevin|321', 'oscar|222']
name = data_source[0]
name1 = data_source[1]
name2 = data_source[2]
name.split('|')
name1.split('|')
name2.split('|')
a = (name.split('|')[0])
b = (name2.split('|')[0])
c = (name2.split('|')[0])
a1 = (name.split('|')[1])
b1 = (name2.split('|')[1])
c1 = (name2.split('|')[1])
while True:
    user_name = input('请输入您的用户名:')
    pass_word = input('请输入您的密码:')
    if user_name == a and pass_word == a1:
        print('登陆成功')
        break
    elif user_name == b and pass_word == b1:
        print('登陆成功')
        break
    elif user_name == c and pass_word == c1:
        print('登陆成功')
        break
    else:
        print('用户名或密码错误')
# 4.利用列表编写一个员工姓名管理系统
#     输入1执行添加用户名功能
#     输入2执行查看所有用户名功能
#     输入3执行删除指定用户名功能
#     '''分析 用户输入的不同 可以执行不同的代码'''
#     ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
#     提示: 循环结构 + 分支结构
user_list = []
A = True
while A:
    menu = (
        '------------------------\n'
        '员工信息管理系统1.0\n '
        '1.添加用户名\n '
        '2.查看所有用户名\n '  # 定义指令菜单
        '3.删除指定用户名\n'
        '4.退出系统'
        '------------------------')
    print(menu)  # 输出指令菜单
    while A:
        order = input('请输入您需要执行的指令>>>:').strip()  # 获取用户指令
        if int(order) == 1:  # 判定用户输入指令为1
            user_name = input('请输入您需要添加的用户名:').strip()  # 获取用户输入的用户名
            user_list.append(str(user_name))
            print('用户名保存成功')
        elif int(order) == 2:
            for i in user_list:
                print(i)
        elif int(order) == 3:
            del_name = input('请输入您需要删除的用户名:')
            user_list.index(del_name)
            del user_list[user_list.index(del_name)]
            print('删除成功')
        elif int(order) == 4:
            print('感谢使用')
            A = False
        else:
            print('请输入有效指令！！')

字典的内置方法相关操作

• 类型转换

'''
强转成字典时，必须是等长的二级容器，元素个数为2,外层可以是列表、元组或集合，里面的容器是元组或者列表
	列: 
	[(1,2,),[1,2]]
	((1,2,),[1,2])
	{(1,2,),[1,2]}
如果里面出现集合（外层不是set集合{}），语法上是允许的，但有局限性  列: ([1,2],{1,2})
如果里面出现字符串，语法上是允许的，但有局限性，字符串的长度只能是2  列: ([1,2],'as')
'''
# 方式1:
d1 = dict([['name', 'tom'],('age', 21)]) 
print(d2)  # {'name':'tom', 'age':21}
# 方式2: fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
d2 = {}
d2.formkeys(('name','age','sex'),None)  # {'name': None, 'age': None, 'sex': 

• 按k键操作

dic = {
	'name': 'tom',
	'age': 21,
	'hobbby': ['LOL','basketball']
}
1、按key取值
print(dic['name'])  # tom
print(dic['age'])  # 21
2、按key修改值、存值
'''对于赋值操作，如果key原先存在于字典，就会更改value值'''
dic['name']  = 'timor'
print(dic)  # {'name': 'timor','age': 21，'hobbby': ['LOL','basketball']}
'''如果key原先不存在于字典，则会新增key:value'''
dic['sex'] = 'male'
print(dic)  # {'name': 'timor','age': 21，'hobbby': ['LOL','basketball'],'sex':'male'}

• 计算数据个数

长度len
print(len(dic))  # 计算字典中键值对的个数

• 成员运算

print('name' in dic)  # True
print('timor' in dic)  # False
'''
字典暴露在外面的只有他的key，没有value 值
'''

• 删除

# 方式1.
del dic['name']
print(dic)  # {'age': 21，'hobbby': ['LOL','basketball'],'sex':'male'}
# 方式2  pop通过指定字典的key来删除字典的键值对 并返回value值
print(dic.pop('sex'))  # male
print(dic)  # {'age': 21，'hobbby': ['LOL','basketball']}
# 方式3  popitem 弹出键值对 组织成元组的形式 第一个元素是key第二个元素是value(了解)
print(dic.popitem())  # ('hobbby': ['LOL','basketball'])
print(dic)  # {'age': 21}
# 方式4 clear() 清除字典中所有元素
print(dic.clear()) # {}

• get取值

dic = {
	'name': 'tom',
	'age': 21,
	'hobbby': ['LOL','basketball']
}
# 方法1. get(key)  若key存在则返回key对应的value  不存在则返回None
dic.get('name')  # 'tom'
print(dic.get('sex'))  # None  
 # 方式2. get(key,值)     
print(dic.get('name','timor'))  # tom  若key存在则返回key对应的value
print(dic.get('sex','male'))  # male  若key不存在则返回自定义的值

• 字典三键客

键keys()，值values()，键值对items()
print(dic.keys())  # dict_keys(['name', 'age', 'hobby'])  获取字典所有的键
print(dic.values())  # dict_values(['tom', 21, ['LOL', 'basketball']])  获取字典所有的值
print(dic.items())  # dict_items([('name', 'tom'), ('age', 21), ('hobby', ['LOL', 'basketball'])])
# 获取字典里面所有的键值对,组织成列表套元组的形式,元组内有两个元素,第一个是key第二个是value

• 补充

print(dict.fromkeys(['name', 'pwd', 'hobby'], 123))  # 快速生成值相同的字典
res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
print(res)  # {'name': [], 'pwd': [], 'hobby': []}
res['name'].append('jason')
res['pwd'].append(123)
res['hobby'].append('study')
print(res)
    '''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''
res = user_dict.setdefault('username','tony')
print(user_dict, res)  # 键存在则不修改 结果是键对应的值
res = user_dict.setdefault('age',123)
print(user_dict, res)  # 存不存在则新增键值对 结果是新增的值
user_dict.popitem()  # 弹出键值对 后进先出

元组的内置方法的相关操作

• 类型转换

tuple()
ps:支持for循环的数据类型都可以转成元组
print(tuple(111))  # 报错
print(tuple(11.11))  # 报错
print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
print(tuple([11,22,33]))  # (11, 22, 33)
print(tuple({'name':'tom','pwd':123}))  # ('name', 'pwd')

• 索引取值

t = (111, 222, 333, 444, 555)
print(t[2])  # 333
print(t[-1])  # 555

• 切片

t = (111, 222, 333, 444, 555)
print(t[1:5])  # (222, 333, 444, 555)
print(t[1:])  # (222, 333, 444, 555)
print(t[:])  # (111, 222, 333, 444, 555)

• 间隔

t = (111, 222, 333, 444, 555)
print(t[1:5:2])  # (222, 444)

• 计算元组内数据个数

t = (111, 222, 333, 444, 555)
print(len(t))  # 5

• for循环

t = (111, 222, 333, 444, 555)
for i in t:
	print(i, end = ' ' )  # 111 222 333 444 555

• count计数

t = (111, 222, 333, 444, 555)
print(t.count(111))  # 1

• 元组内如果只有一个数据值那么逗号不能少
• 元组内索引绑定的内存地址不能被修改(注意区分 可变与不可变)
• 元组不能新增或删除数据

集合的内置方法相关操作

• 类型转换

能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
'''集合内元素是无序的'''

• 去重

集合自带去重属性
s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
print(s1)  # {1, 2, 3, 4}  去重
示列：
name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
# 1.先将列表转换成集合
s1 = set(name_list)
# 2.再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)  # ['kevin', 'jason']

• 成员运算

"""两个群体之间做差异比较    共同好友 共同关注..."""
friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们
1.求两个用户的共同好友  交集
print(friends1 & friends2)  # {'jason', 'eg'}
2.求两个用户所有的好友  并集
print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
3.求用户1独有的好友  差集
print(friends1 - friends2)  # {'zero', 'kevin'}
4.求用户2独有的好友  差集
print(friends2 - friends1)  # {'ricky', 'Jy'}
5.求用户1和用户2各自的好友  对称差集  
print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}
6.父集与子集  父集包含子集
s1 = {11, 22, 33, 44}
s2 = {11, 33}
print(s1 > s2)  # 判断s1是否是s2的父集   True
print(s2 < s1)  # 判断s2是否是s1的子集   True