数据的内置方法

数据类型的内置方法简介

内置方法即是每个数据类型自带的功能

数据类型总类：
1.整型 2.浮点型 3.列表型 4.字典型
5.字符型 6.布尔值 7.元组 8.集合

使用数据类型的内置方法统一采用句点符（.）

整型相关方法

关键字
int()
整型就是整数，主要用于计算，没有内置方法
类型转换
int('代转换的数据')
字符串中转换的必须是纯数字，出现其他形式立即报错。
进制转换

print(bin(100))  #bin()将十进制转换为二进制    0b 是二进制的标识  0b1100100
print(oct(100))  #oct()将十进制转换为八进制    0o 是八进制的标识  0o144
print(hex(100))  #hex()将十进制转换为十六进制  0x是十六进制的标识  0x64
#若前面没有标识符 则默认为十进制
#转换为十进制：
print(int(需转换的数值))

浮点型相关方法

关键字
folat()
类型转换
浮点型类型转换仅可以转换一个小数点的数据，若为多个小数点，那么直接报错。
（python 对数字不敏感，很容易出错，但可以借助于python开发的模块来抵消）
针对布尔值的特殊情况

print(folat(True)) # 1.0
print(folat(False)) # 0.0
print(int(True))   # 1
print(int(Flase))  # 0

当转换值为布尔值时，所转换的是该布尔值所对应的数值（True-1；Flase-0)

字符串相关方法

关键字：
str()
类型转换
字符串可转换所有数据值
转换的方法
1.索引取值：单个字符（支持负数）

s1 = 'hello world'
print(s1[0]) #h
print(s1[-1]) #d
"""所提取的为负数时，所打印的内容是由右往左依此读取所打印数的内容"""

2.切片取值：
多个字符，支持负数，切片的顺序默认为从左往右

s1 = 'hello world'
print(s1[0:3]) #hel 从索引0的位置一直到索引2的位置（顾头不顾尾）
print(s1[-1:-4]) #由于切片的顺序是默认为从左往右，则打印不出所实现的值
print(s1[-1:-4:-1]) # dlr 可以通过第三个参数的正负1来控制方向
print(-4:-1) # lro 顾头不顾尾

切片取值时，顺序默认从左往右，当第三个参数赋值为-1时，循序变为从右往左打印，若没有给第三个参数赋值则默认为1。取值的时候是遵循顾头不顾尾的原则，第二个参数数默认减一

3.间隔/方向

s1 = 'hello world'
print(s1[:])   # 输出所有
print(s1[::2]) # 针对整个字符串 各一个去一个
print(s1[0:5:1]) # hello 默认1可以不写
print(s1[0:5:2]) # hlo  建个一个取一个

间隔方向默认为从左往右

4.统计字符串中字符的个数

print(len(s1))  #print(len('hello world'))

在使用len()统计字符个数时，其中的空格也在统计范围内。

5.移除字符首尾指导的字符

username = input('username>>>:')
if username == 'back':
    print('登陆成功')
else:
    print('你是谁，一边玩去！')
name = '   back   '
print(len(name))     # 10
print(name.strip(), len(name.strip()))  # back 4
res = name.strip()
'''字符串调用内置方法 不是改变原数据 而是产生了新的数据'''
print(name, len(name))  # back 10
print(res, len(res))   # back 4

运用字符串用内置的方法消除字符时，所表示的不是改变原始数据，而是产生了新的数据，随后输出来调用改变后的数据
还可以进行左消除或者右消除操作：
即在strip前加l或者r
l即left 即左消除
r即right 即右消除

6.按照指定的字符切割字符串

info = 'back|111|run'
'''当字符串中出现了连续的特征符号 应该考虑使用切割操作'''
res = info.strip('|')  # 切割字符串的结果是一个列表
print(res, type(res))  #  back|111|run   <class 'str'>
name, paw, hobby = info.split('|')  #把info的值分别赋值给name, paw, hobby
print(info.split('|', maxsplit=1))  # 从左往右 只切一次
print(info.rsplit('|', maxsplit=1))   # 从右往左 只切一次

若出现连续的特征符号，考虑用切割操作。
使用切割字符串时，默认为从左往右切割，若split前由r时，则为从右往左切割
当需要切割次数时，使用maxsplit ，当后面的数值为多少就是需要切割多少次。

7.字符串大小写相关

l1 = 'Hello World 123 你会吗？'
print(l1.lower())  # 把字符串中所有的字母置换成全小写形式其他不变
print(l1.upper())  # 把字符串中所有的字母置换成全大写形式其他不变

print(l1.islower())  # 判断字符串中所有的字母是否是全小写
print(l1.isupper())  # 判断字符串中所有的字母是否是全大写

code = 'BackJia123'
print('随机验证码')
confirm_code = input('随入验证码>>>:')
code_upper = code.upper()  # 将网页返回的验证码转大写
confirm_code_upper = confirm_code.upper()  # 将用户填写的验证码转大写
if code_upper == confirm_code_upper:  # 统一转大写 或者小写 再做比对
    if confirm_code.upper() == code.upper():  # 统一转大写 或者小写 再做比对
        print('验证码正确')
else:
    print('验证码错误')

进行大小写的相关操作时，使用lower()或者upper()操作可将字符串中所由字母进行大小写转换，进而使大小写穿插输入达到一致的结果。
若其前加is 则为判断该字符串是否是全大写，或者全是小写。

8.字符串的格式化输出

# 1.等价于%s占位
res1 ='my name is {} my age is {}'
print(res1.format('back',18))
"""相当于使用{}替代了%s的占位符"""

# 2. 支持索引取值 并且支持重复使用
res2 = 'my name is {0} my age is {1} {0} {1} {1} {1}'
print(res2.format('back', 18))
"""当列表中的数据需要多次调用时采用此方法可适当的减少输入，0，1为列表中的位置"""
# 3: 支持关键字取值(按k取值) 并且支持重复使用
res3 = '{name} {name} {age} my name is {name} my age is {age}'
print(res3.format(name='back', age=18))
""" 于方式2相似，用字典中的K值来调取信息进而填写输出 """

# 4.常用操作
name ='back'
age = 18
print(f'my name is {name} my age is {age} {name} {age}')
"""在格式化输出前加f方法直接获取上述字符内容并进行填写操作，更加简洁"""

用字符串替换格式化输出，有四种方式，与前三种相比较，在输出结果前加f操作更加方便快捷

9.统计字符串中指定字符出现的次数

 # res = 'sdashdjasdwjjkashdjasdjjqwhasjjahdjjwqhdjjkasdhws'
    # print(res.count('s'))
    # print(res.count('jj'))

相比于循环操作，采用.count（）方法能够更加快捷的找到字符串中所需要的数据

10.判断字符串的开头或者结尾

res = 'back say ha ha ha heiheihei'
print(res.startswith('back')) # True
print(res.startswith('b')) # True
print(res.startswith('s')) # False
print(res.endswith('heiheihei'))# True
### print(res.endswith('hei'))  # True
print(res.endswith('h')) # False

采用swith()方法判断字符串的开头或者结尾
swith前为start时是判断开头是否正确可以是首字母，也可是前面的连续字母
swith前为end 时，则是判断结尾是否正确。可以是尾字母，也可以是最后的连续字母（这里是从左往右）

11.字符串替换

res = 'abcd abcd abcd SB SB SB'
print(res.replace('abcd', 'tony'))  # 从左往右全部替换
print(res.replace('abcd', 'tony', 1))  # 从左往右替换指定个数

采用replace（）方法可以将字符串中的代码进行替换（遵循从左往右的原则）
在原数据，替换数据之后填写一个数据值则为替换间隔数（没有填写则默认为0）

12.字符串的拼接

res1 = 'hello'
res2 = 'world'
print(res1 + res2)  # 字符串支持加号拼接
print(res1 * 10)  # 字符串支持乘号重复
print(''.join(['hello', 'world', 'hahaha']))  # join方法拼接
print('|'.join(['hello', 'world', 'hahaha']))  # join方法拼接
# print('$'.join(['jason', 'say', 666]))  # 列表中的数据都必须是字符串类型  报错!!!

字符串的拼接支持+ * 形式的拼接，拼接的结果为没有间隔的数据。
当使用join()方法进行拼接时，join前的单引号中若为|则使用|来将其拼接结果进行分割。若为空则视为没有间隔
列表中的数据都必须是字符串类型否则报错。

13.判断字符串中是否为纯数字

print('123'.isdigit())  # True
print('123a'.isdigit())  # False
print(''.isdigit())  # False

采用isdigit()方法对整型进行判断处理

14.查找某个字符对应的索引值

res = 'hello world jason'
print(res.index('o'))  # 10
print(res.find('j'))  # 10
'''index查找索引 如果没有则报错'''
# print(res.index('d',0,5))
'''find查找索引 如果没有则返回-1'''
# print(res.find('d',0,5))  # -1

使用index()时，如果在字符串中没有找到对应字符，则返回一个报错
使用find()时，如果在字符串中没有找到对应字符，则返回-1，不抛出报错。

15.正文相关操作

res = 'my name is back'
print(res.title())  # My Name Is Back
print(res.capitalize())  # My name is back

capitalize(): 字符串第一个字母大写
title(): 字符串内的所有单词的首字母大写

列表的内置方法

关键字：
lost():
类型转换：
但凡能被for循环的数据类型都可以传给list()转换为列表类型，list（）会跟 for 循环一样把数据逐个放入列表中
print(type(list(数据 )))
使用方法

按索引取值

1.正向取（从左往右）
l1 = ['jack', 'tony', 1, 2, 3]
print(l1 [0])   # jack
2.反向取（负号代表从右往左）
print(l1[-1])   # 3
3.对于list来讲，可以按照索引取值，同样也可以按照索引修改指定位置，但如果索引不存在，则会做报错处理
l1 = ['jack', 'tony', 1, 2, 3]
l1 = [1] = 'break'
print (l1)  # 'jack', 'break', 1, 2, 3

可通过索引取值的方式直接取值（可以正存取，也可以反向存取），如果索引不存在则不能使用。

切片

1.顾头不顾尾 : 取出索引0到2 的元素
    l1 = ['back', 'kevin', 'oscar', 'tony']
    print(l1[0:2])  # 'back', 'kevin', 'oscar'
2. 步长
[0:4:2],第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
 print(l1[0:4:2])  # 'back', 'oscar'

切片可以是正切，也可以倒着切（为负值时倒切）
第三个参数为多少，就是间隔多少取值

统计列表中的数据值的个数

 l1 = ['back', 'kevin', 'oscar', 'tony']
    print(len(l1))   # 4

用 len ()方法来统计列表中数据值的个数

增加列表的数据

1.尾部追加数据值使用append() 方法。括号中无论写什么数据类型，都当成一个数据值追加
l1 = ['back', 'kevin', 'oscar', 'tony']
res = l1.append('owen')
print(res) # None 空
print(l1)  #  ['back', 'kevin', 'oscar', 'tony', 'owen']

s1 = '$hello$'
res1 = s1.strip('$')
print(res1)  # hello
print(s1)   #$hello$

l1.append([1, 2, 3, 4, 5])
print(l1)   # ['back', 'kevin', 'oscar', 'tony', [1, 2, 3, 4, 5]]
2.任意位置插入数据值insert()  括号内无论写什么数据类型 都是当成一个数据值插入
l1.insert(0, '插队')
print(l1)   # ['插队', 'back', 'kevin', 'oscar', 'tony']
l1.insert(0, [1, 2, 3])
print(l1)  # [[1, 2, 3], '插队', 'back', 'kevin', 'oscar', 'tony']
3.扩展列表
new_l1 = [11, 22, 33, 44, 55]
new_l2 = [1, 2, 3]
(1)for i in new_l1:
new_l2.append(i)
print(new_l2)
(2) print(new_l1 + new_l2)
(3)new_l1.extend(new_l2)  # 括号里面必须是支持for循环的数据类型  ， for循环+append()
   print(new_l1)   # [1, 2, 3, 11, 22, 33, 44, 55]

可以使用append（）方法在末位添加数据
可以使用insert ()方法插入数据值（插入数据值前使用索引，插到什么位置，索引值就写那里）
扩展列表时，可通过extend( )方法来扩展列表，括号里面必须是支持for循环的数据类型，相当于for循环+append()

查询数据与修改数据

l1 = ['back', 'kevin', 'oscar', 'tony']
print(l1)  #['back', 'kevin', 'oscar', 'tony']
print(l1[0]) # back
print(l1[1:4]) # 'kevin', 'oscar', 'tony'

修改数据:
l1[2] = 'jack'
print(l1)  # 'back', 'kevin', 'jack', 'tony'

列表的内置方法可直接查询数据
利用索引来修改数据

删除数据

l1 = ['back', 'kevin', 'oscar', 'tony']
1. 通用删除策略
del l1[0]  # 通过索引即可
print（l1） # 'kevin', 'oscar', 'tony'

2. 指名道姓的删除
res = l1.remove('back')  # 括号内必须填写明确的数据值      就地正法
print(l1, res)  # 'kevin', 'oscar', 'tony'

3.使用pop()方法 先去除数据值，然后再做删除处理
res = l1.pop()  # 默认取出列表尾部数据值 然后再删
print(l1, res)  # ['back', 'kevin', 'oscar'] tony 
res = l1.pop(0)
print(res, l1)  #back ['kevin', 'oscar']  通过索引调出数据再做删除处理

删除数据时，使用pop( ) 方法时，pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
remove()括号内指名道姓表示要删除哪个元素，没有返回值
使用del（）直接对数据进行删除处理，也可通过索引进行删除

查看数据值对对应的索引

l1 = ['back', 'kevin', 'oscar', 'tony']
print(l1.index('back'))  # 0

可通过使用 index( ) 方法，对数据值直接进行索引值的查看

统计某个数据出现的次数

l1 = ['back', 'kevin', 'oscar', 'tony','back']
print(l1.count('back'))  # 2

使用 count（）方法可快速统计出某个数值出现的次数

排序

l1 = [5, 4, 55, 78, 54]
l1.sort()
print(l1) # [4, 5, 54, 55, 78]
l1.sort(reverse=True)
print(l1) # [78, 55, 54, 5, 4]

当使用sort( ) 方法时，默认为升序，默认从小到大排序
当sort() 中的括号有 reverse=True 时，则为降序排列
排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
10. 翻转

l1 = ['back', 'kevin', 'oscar', 'tony']
l1.reverse()  # 前后跌倒
print(l1)  # ['tony', 'oscar', 'kevin', 'back']

使用reverse( ) 方法，将数据进行倒置（前后颠倒位置）

11.比较运算

1.数字之间进行比较
new_1 = [99, 11]
new_2 = [11, 22, 33, 44]
print(new_1 > new_2)  # True   是按照位置顺序一一比较
2. 字母之间进行比较
new_1 = ['a', 11]           # a 97
new_2 = ['A', 22, 33, 44]   # A 65
print(new_1 > new_2)  # True

字符串、列表等比较大小时，都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素
字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大

元组的内置方法

关键字：
tuple()
类型转换
支持for循环的数据类型都可以传给tuple( ) 转换成元组
tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

当元组内只有一个数据值的时候逗号不能省略
如果省略了那么括号里面是什么数据类型就是什么数据类型

类型转换的相关方法
1.索引取值

t1 = (11, 22, 33, 44, 55, 66)
print(t1[1])  # 22

可通过索引取值的方式，取出要取出的数据

2.统计元组内数据值的个数

t1 = (11, 22, 33, 44, 55, 66)
print(len(t1))    # 6

通过len()方法，计算出数据的个数。

3.查与改

 print(t1[0])  # 可以查
 t1[0] = 222  # 不可以改
''' 元组的索引不能改变绑定的地址 '''
t1 = (11, 22, 33, [11, 22])
 t1[-1].append(33)
 print(t1)  # (11, 22, 33, [11, 22, 33])
''' 添加的是列表而不是元组'''

元组可以查数据，但不可改变其绑定的地址（不可改）但元组内存在可改数据时（如：列表）可将其修改，但并不改变元组所绑定的地址。

字典的内置方法

取值

info = { 'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']}
print(info['username'])  # 不推荐使用 键不存在会直接报错
 print(info['xxx'])  # 不推荐使用 键不存在会直接报错
 print(info.get('username'))  # back
 print(info.get('xxx'))  # None
 print(info.get('username', '键不存在返回的值 默认返回None'))  # back
 print(info.get('xxx', '键不存在返回的值 默认返回None'))  # 键不存在返回的值 默认返回None
 print(info.get('xxx', 123))  # 123
 print(info.get('xxx'))  # None

字典中的K：V键值对是无序的，所以不能使用索引取值
当直接取K值或者V值时，若是字典中不存在，则直接报错，若使用get()方法，存在则输出该值，不存在，则直接返回空值，不会出现报错情况。

统计字典中的键值对的个数

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
print(len(info)) # 3

使用len( ) 方法，可直接统计出个数

增，删，改，查

增：
info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
info['salary'] = 10        键不存在则为新增
print(info)  # {'username': 'back', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 10}
删：
(1) del info['username']
print (info )  # {'pwd': 123, 'hobby': ['read', 'run'], 'salary': 10}
(2) res = info.pop('username')
print (info,res) # 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 10   先取出再删除
(3) info.popitem() # 随机删除
print (info)
改：
info['username'] = 'abcd'          键存在则是修改
print(info)
查：
print（info）   直接查看

当给过字典后，若是键存在的情况下为改，不存在的情况下为增
删除可通过 del()直接删除（利用索引）也可通过pop()方法进行定向删除。popitem（）方法为随机删除。

快速获取键，值，键值对的数据

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
print(info.keys())  # 获取字典所有的K值，结果当成列表
dict_keys(['username', 'pwd', 'hobby'])
print(info.values())  # 获取字典所有的v值 结果当成是列表
dict_values(['jason', 123, ['read', 'run']])
 print(info.items())  # 获取字典kv键值对数据 组织成列表套元组dict_items([('username', 'jason'), ('pwd', 123), ('hobby', ['read', 'run'])])

可通过keys(),vakues(),items()来获取相应的K值，V值，kv键值对。都将其组成列表的形式。

update()
修改字典数据， K键存在则是修改，不存在则是新增

9.fromkeys( )

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
res = dict.fromkeys([1, 2, 3], None)
print(res)    # {'name': None, 'pwd': None, 'hobby': None}
new_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}

快速构造字典，给的值默认情况下所有键值对都用一个

setdefault( )

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
dic = {'k1':123, 'k2':321}
res = dic.setdefault('k3':456 )
print (res)  #  {'k1':123, 'k2':321, 'k3':456}

键存在则获取键对应的值键不存在则设置并返回设置的新值
key存在则不做任何修改，并返回已存在key对应的value值

集合的内置方法

关键字：
set()
类型转换
key存在则不做任何修改，并返回已存在key对应的value值
1.定义空集合需要使用关键字才可以
2.集合内数据必须是不可变类型(整型浮点型字符串元组布尔值)
类型转换的相关方法

去重

s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
print(s1)  # {1, 2, 3, 4, 5, 12}

去重时，可直接利用集合的来输出，相同的地方直接剔除

关系运算

f1 = {'jason', 'tony', 'oscar', 'jerry'}
f2 = {'kevin', 'jerry', 'jason', 'lili'}
(1)合集（|） :两者所有数据
   print(f1 | f2)  # {'jason', 'kevin', 'lili', 'oscar', 'jerry', 'tony'}
(2)交集（&） :两者共同数据
   print(f1 & f2)  # {'jason', 'jerry'}
(3)差集（-） :两者分别的独有数据
   print(f1 - f2)  # {'oscar', 'tony'}
   print(f2 - f1)  # {'lili', 'kevin'}
(4)对称差集（^） : 两者的共同独有数据
   print(f1 ^ f2)  # {'kevin', 'lili', 'tony', 'oscar'} 
(5)父级，子集
   s1 = {1, 2, 3, 4, 5, 6, 7}
   s2 = {3, 2, 1}
   print(s1 > s2)  # s1是否是s2的父集  s2是不是s1的子集
   print(s1 < s2)

可变可不变

可变
值发生改变时，内存地址不变，即id不变，证明在改变原值
list()
不可变
值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值
str() , int(), float()

今日作业

1.利用列表编写一个员工姓名管理系统
输入1执行添加用户名功能
输入2执行查看所有用户名功能
输入3执行删除指定用户名功能
ps:思考如何让程序循环起来并且可以根据不同指令执行不同操作
提示: 循环结构 + 分支结构
拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写不会没有关系)

flag = True
info = []
while flag:
    print("""
     1. 添加用户
     2. 查看用户
     3. 删除用户
     4. 退出程序
    """)
    option = input('请输入所要使用的功能（1-4）: ')
    if not option.isdigit():    # 判断是否为数字
        print('请输入数字:')
    elif int(option) == 1:
        print('请添加新用户')
        name = input('输入用户名>>>:')
        paw = input('输入密码>>>:')
        info_list = {'username': name, 'password': paw}   # 将用户名和密码保存在列表
        info.append(info_list)
    elif int(option) == 2:
        print('查看用户：')
        for i in info:
            print(i['username'])   # 循环用户字典的键值对

    elif int(option) == 3:
        print('删除用户')
        name1 = input('请输入将要删除的名字:')
        del_info = 0
        for i in info:
            if i['username'] == del_info:
                info.pop(del_info)
                break
        print('该用户以删除')
    elif int(option) == 4:
        flag = False
    else:
        print('请输入正确的选项')

2.去重下列列表并保留数据值原来的顺序
eg: [1,2,3,2,1] 去重之后 [1,2,3]
l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]

l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]
l2 = []
for i in l1:
    if not i in l2:
        l2.append(i)
print(l2)

3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合

pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}

print(pythons & linuxs)

print(pythons | linuxs)

print(pythons - linuxs)

print(pythons ^ linuxs)

posted @ 2022-06-27 23:29 Nirvana* 阅读(45) 评论(0) 收藏举报

刷新页面返回顶部

nirvana001