python之基本数据类型的内置方法

前言

• 观看之前本篇博客建议先了解python基本数据类型定义
• 如何查看数据类型都有哪些内置方法： 句点符(.)

数据类型的内置方法

整型int

# 类型转换
使用方法: int()  
用途1 : 将其他类型(str类型和float类型)的纯数字转化为整型  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
 用途2 : 做进制数转换   # 了解即可
	 print(bin(100))  # 将十进制的100转换成二进制  0b1100100
	 print(oct(100))  # 将十进制的100转换成八进制  0o144
	 print(hex(100))  # 将十进制的100转换成十六进制  0x64
	 # 0b开头为二进制数  0o开头为八进制数  0x开头为十六进制数
	 print(int('0b1100100', 2))  # 100
	 print(int('0o144', 8))  # 100
	 print(int('0x64', 16))  # 100

浮点型float

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

字符串str

1. str之类型转换

使用方法: str()  
用途: 将其他"任意类型"转换为str类型
	print(str(123))
	print(str(123.21))
    print(str([1, 2, 3, 4]))
    print(str({'name': 'jason', 'pwd': 123}))
    print(str((1, 2, 3, 4)))
    print(str(True))
    print(str({1, 2, 3, 4}))

1. str之索引取值与切片

# 1. 索引取值
res = 'hello world'
print(res[1])  # e
# 2.切片操作  顾头不顾尾
print(res[1:4]) # ell
# 3.步长操作
print(res[1:10:3])  # eood  
# 4.反向索引
print(res[-1])  #  d  最后一位
print(res[-5:-1])  # orld 顾头不顾尾
print(res[-5:-1:-1])  # 方向冲突 无输出
print(res[::-1])  # dlrow olleh  反向输出 

2. str之字符串长度统计 len()

print(len(res))  # 12

3. 移除字符串首尾指定的字符 strip()

# 默认空格
name = '    tony   '
print(name.strip())  # tony
name1 = '$$tony$$$' 
print(name1.strip('$'))  # tony
# lstrip() 只移除左边  rstrip() 只移除右边的
print(name1.lstrip('$'))  # tony$$$
print(name1.strip('$'))  # $$tony

4.按照指定字符切割字符串 split()

# 默认空格  返回的结果是一个列表
res2 = 'jason|123|18'
print(res2.split('|'))  # ['jason', '123', '18']
print(res2.split('|', maxsplit=1))  # ['jason', '123|18']  maxsplit用于控制切割的次数  默认从左边开始切割
# rsplit  从右边开始切割
print(res2.rsplit('|', maxsplit=1))  # ['jason|123', '18']

5.成员运算

# in 和 not in
res = 'hello world'
print('hello' in res)  #  True
print('xx' not in res)  # False

6.大小写

# 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

7. 指定开头与结尾

# startswith() 和 endswith()
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

8.格式化输出

• 格式化输出的三种方式

9.字符串拼接

方式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' 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接

10.字符串替换

# 用新的字符替换字符串中旧的字符
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!

11.判断是否是纯数字

# 判断字符串是否是纯数字组成，返回结果为True或False
str2 = '5201314'
print(str2.isdigit())  # True
str2 = '123g123'
print(str2.isdigit())  # False

12.字符串循环

str3 = '今天你好吗？'
for line in str3:  # 依次取出字符串中每一个字符
     print(line)
'''
今
天
你
好
吗
？
'''

13.了解操作

# 1.find,rfind,index,rindex,count
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到时会报错
>>> msg.index('e',2,4) # 报错ValueError
# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
>>> msg = "hello everyone"
>>> msg.count('e')  # 统计字符串e出现的次数
4
>>> msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数
1
 
# 2.center,ljust,rjust,zfill
>>> name='tony'
>>> name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
>>> name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
>>> name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
>>> name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony
 
# 3.expandtabs
>>> name = 'tony\thello'  # \t表示制表符(tab键)
>>> name
tony    hello
>>> name.expandtabs(1)  # 修改\t制表符代表的空格数
tony hello
 
# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  
# 4.2 swapcase：大小写翻转
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#4.3 title：每个单词的首字母大写
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much 
 
# 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字
 
#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False
 
#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal() 
True
>>> num3.isdecimal() 
False
>>> num4.isdecimal() 
False
 
#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True
 
# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False
 
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
 
# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

列表list

1.列表之类型转换

# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型
list('wdad') # 结果：['w', 'd', 'a', 'd'] 
list([1,2,3]) # 结果：[1, 2, 3]
list({"name":"jason","age":18}) #结果：['name', 'age']
list((1,2,3)) # 结果：[1, 2, 3] 
list({1,2,3,4}) # 结果：[1, 2, 3, 4]

2.列表之增删查改

1. 取值
1.1. 索引取值
list1 = ['tom', 'jason', 'timor', 4, 5]
print(list1[0])  # tom 
print(list1[-1])  # 5
1.2. 切片(顾头不顾尾，步长)
print(list[0:3])  # ['tom', 'jason', 'timor'] 
print(list[0:4:2)  # ['tom', 'timor']

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

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

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

3.列表之表内顺序

1. reverse()  # 颠倒列表内元素顺序
l2 = [11, 22, 33, 44]
l2.reverse()
print(l2)  # [44, 33, 22, 11]
2. sort()  # 给列表内所有元素排序
'''
强调: 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
'''
l3 = = [11, 22, 3, 42, 7, 55]
l3.sort()
print(l3)  # [3, 7, 11, 22, 42, 55] 默认从小到大排序
l3 = = [11, 22, 3, 42, 7, 55]
l3.sort(reverse=True) #  reverse用来指定是否跌倒排序，默认为False
print(l3)  # [55, 42, 22, 11, 7, 3]

4. 列表循环

list1 = ['tom', 'jason', 'timor', 4, 5]
for line in list1:
	print(line)
'''
tom
jasom
timor
4
5
''' 

5.了解知识

# 8.2 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
l1=[1,2,3]
l2=[2,]
print(l2 > l1)  # True

# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1='abc'
s2='az'
print(s2 > s1)  # True s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立

# 所以我们也可以对下面这个列表排序
l = ['A','z','adjk','hello','hea']
l.sort()
print(l)  # ['A', 'adjk', 'hea', 'hello','z']

l=[1,2,3,4,5,6]
print(l[0:3:1] )  # [1, 2, 3]   正向步长

print(l[2::-1])  # [3, 2, 1]   反向步长
 
# 通过索引取值实现列表翻转
print(l[::-1])  # [6, 5, 4, 3, 2, 1]

元组

1.元组之类型转换

'''
1、元组可以看成是不可变的列表
2、但凡能被for循环遍历的数据类型都可以传给tuple()转换成元组类型
3、tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中
'''
print(tuple('hello'))  # ('h', 'e', 'l', 'l','o') 
print(tuple(1, 2, 3))  # (1, 2, 3)
print(tuple({1, 2, 3})  # (1, 2, 3)

2.基本使用

# 1.索引取值
t1 = (1, 2, 3, 4, 5)
print(t1[0])  # 1
print(t1[3])  # 4

# 2.切片(顾头不顾尾，步长) 
print(t1[1:5:2]  # (2, 4)

# 3.长度
print(len(t1))  # 5

# 4.成员运算
print(0 in t1)  # False
print(4 in t1)  # True
print(6 not in t1)  # True

# 5.循环
for i in t1:
	print(i, end= ' ' )  # 1 2 3 4 5  

字典

1.字典之类型转换

'''
强转成字典时，必须是等长的二级容器，元素个数为2k,外层可以是列表、元组或集合，里面的容器是元组或者列表
	列: 
	[(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': None}

字典基本使用

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'}

3、长度len
print(len(dic))  # 4

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

5、删除
# 方式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()) # {}

6.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,值)  若key存在则返回key对应的value  不存在则返回自定义的值 
print(dic.get('name','timor'))  # tom
print(dic.get('sex','male'))  # male

7、键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

字典之了解操作

dic = {
	'name': 'tom',
	'age': 21,
	'hobbby': ['LOL','basketball']
}
# 1.更新字典  键存在则修改 不存在则创建
dic.update({'name': 'timor', 'pwd': 123})
print(dic)  # {'name': 'timor','age': 21,'hobbby': ['LOL','basketball'],'pwd':123}
2.初始化字典
print(dict.fromkeys(['k1', 'k2', 'k3'], []))
'''笔试题'''
res = dict.fromkeys(['k1', 'k2', 'k3'], [])
res['k1'].append(111)
res['k2'].append(222)
res['k3'].append(333)
print(res)  # {'k1':[111,222,333],'k2':[111,222,333],'k3':[111,222,333]}
res['k1'] = [111,222]
res['k1'].append(444)
print(res)  # {'k1':[111,222,,444],'k2':[111,222,333],'k3':[111,222,333]}
# 3.当键存在的情况下 不修改而是获取该键对应的值
print(dic.setdefault('name', 'jasonNB'))
print(dic)  # timor
# 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
print(dic.setdefault('sex', 'male'))
print(dic)  # {'name': 'timor','age': 21,'hobbby': ['LOL','basketball'],'pwd':123,'sex':'male'}

元组

元组之类型装换

# 类型转换  能够支持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')

# 元组第一道笔试题
t1 = (111)  # 整型
t2 = (11.11)  # 浮点型
t3 = ('hello')  # 字符串
'''元组哪怕内部只有一个元素 也需要加上逗号'''
print(type((111,)))
'''容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
    建议:所有的容器类型在存储数据的时候 如果内部只有一个元素 
        那么也推荐你加上逗号
'''

元组之基本操作

t = (111, 222, 333, 444, 555)
# 1.索引取值
print(t[2])  # 333
print(t[-1])  # 555
# 2.切片操作
print(t[1:5])  # (222, 333, 444, 555)
print(t[1:])  # (222, 333, 444, 555)
print(t[:])  # (111, 222, 333, 444, 555)
# 3.步长
print(t[1:5:2])  # (222, 444)

# 4.统计元组内元素的个数
print(len(t))  # 5

# 5.for循环
for i in t:
	print(i, end = ' ' )  # 111 222 333 444 555
# 6.count计数
print(t.count(111))  # 1
'''笔试题'''
t1 = (111, 222, [11, 22, 33])
t1[2].append(44)
print(t1)  # (111, 222, [11, 22, 33, 44])

集合

集合之类型转换与基本用法

# 类型转换  能够支持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

总结

按存值个数区分
只能存在一个值: 可称为标量/原子类型	数字、字符串
可以存放多个值：可称为容器类型	列表、元组、字典

按访问方式区分
直接访问：只能通过变量名访问整个值	数字
顺序访问：可以通过索引访问指定的值、索引代表顺序，又称为序列类型	字符串、列表、元组
key访问：可以通过key 访问指定的值、又称为映射类型	字典

按可变不可变区分
可变类型	列表、字典
不可变类型	数字、字符串、元组