Python基本数据类型及内置方法（一）
目录
数据类型
数据类型是用来记录事物状态的，而事物的状态是不断变化的（如：一个人年龄的增长（操作int类型），单个人名的修改（操作str类型），学生列表中增加学生（操作list类型）等），这意味着我们在开发程序时需要频繁对数据进行操作，为了提升我们的开发效率，Python针对这些常用的操作，为每一种数据类型内置了一系列方法。本篇的主题就是详细介绍下它们，以及每种数据类型的详细定义、类型转换。
1.数字类型int与float
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 使用
数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法。
2.字符串类型str
2.1 定义
# 定义：在单引号\双引号\三引号内包含一串字符
# 作用：主要用于记录描述性性质的数据，eg：姓名 地址 邮箱
name1 = 'jason' # 本质:name = str('任意形式内容')
name2 = "lili" # 本质:name = str("任意形式内容")
name3 = '''tony''' # 本质:name = str("""任意形式内容""")
name4 = """ricky""" # 本质:name = str("""任意形式内容""")
2.2 类型转换
# 数据类型转换：str()可以将任意数据类型转换成字符串类型，例如:
>>> type(str([1,2,3])) # list -> str
<class 'str'>
>>> type(str({"name":"jason","age":18})) # dict -> str
<class 'str'>
>>> type(str((1,2,3))) # tuple -> str
<class 'str'>
>>> type(str({1,2,3,4})) # set -> str
<class 'str'>
2.3 使用
2.3.1 优先掌握的操作
# 以str1为例进行相关方法的演示
>>> 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] # 负数表示从右往左取值,
!nohtyP olleH
# 3.长度len()
# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符
>>> len(str1) # 空格也算字符
13
# 4.成员运算 in 和 not in
# 4.1 in:判断Hello 是否在 str1里面
>>> 'Hello' in str1
True
# 4.2 not in:判断tony 是否不在 str1里面
>>> 'tony' not in str1
True
# 5.strip()移除字符串首尾指定的字符
# 5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
>>> str1 = ' life is short! '
>>> str1.strip()
life is short!
# 5.2 括号内指定字符，移除首尾指定的字符
>>> str2 = '**tony**'
>>> str2.strip('*')
tony
# 6.切割split()
# 6.1 括号内不指定字符，默认以空格作为切割符号
>>> str3 = 'Hello World'
>>> str3.split()
['Hello', 'World']
# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
>>> str4 = '127.0.0.1'
>>> str4.split('.')
['127', '0', '0', '1'] # 注意:split()切割得到的结果是列表数据类型
# 7.循环
>>> str5 = '今天你好吗？'
>>> for line in str5: # 依次取出字符串中每一个字符
... print(line)
...
今
天
你
好
吗
？
2.3.2 需要掌握的操作
-
strip(),lstrip(),rstrip()
>>> str1 = '***tony***' >>> str1.strip('*') # 移除左右两边的指定字符 'tony' >>> str1.lstrip('*') # 只移除左边的指定字符 tony*** >>> str1.rstrip('*') # 只移除右边的指定字符 ***tony -
lower(),upper()
>>> str2 = 'My nAme is tonY！' >>> str2.lower() # 将英文字符串全部变小写 my name is tony！ >>> str2.upper() # 将英文字符串全部变大写 MY NAME IS TONY！ -
startswith(),endswith()
>>> str3 = 'tony jam' # startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False >>> str3.startswith('t') True >>> str3.startswith('j') False # endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False >>> str3.endswith('jam') True >>> str3.endswith('tony') False -
格式化输出format()
之前学过使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format()则提供了一种不依赖位置的传值方式.
# format()括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值 >>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony') # name=‘tony’就是传给{name} >>> str4 my name is tony, my age is 18! >>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18) # 可以反复使用相同位置的数据 >>> str4 my name is tonytonytony, my age is tony!format()的其他使用方式
# 类似于%s的用法，传入的值会按照位置与{}一一对应 >>> str4 = 'my name is {}, my age is {}!'.format('tony', 18) >>> str4 my name is tony, my age is 18! # 把format()传入的多个值当作一个列表，然后用{索引}取值 >>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18) >>> str4 my name is tony, my age is 18! >>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18) >>> str4 my name is 18, my age is tony! >>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18) >>> str4 my name is 18, my age is 18! -
split(),rsplit()
# split()会按照从左到右的顺序对字符串进行切割，第二个参数可以指定切割次数 >>> str5 = 'C:/a/b/c/d.txt' >>> str5.split('/', 1) ['C:', 'a/b/c/d.txt'] # rsplit()刚好与split()相反，从右往左切割，可以指定切割次数 >>> str5 = 'a|b|c' >>> str5.rsplit('|',1) ['a|b', 'c'] -
join()
# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串 >>> '%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接 'h%e%l%l%o' >>> '|'.join(['tony','18','read']) # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接 'tony|18|read' >>> list1 = ['jason', 123, 'tony'] >>> '$'.join(list1) >>> Traceback (most recent call last): TypeError: sequence item 1: expected str instance, int found """必须是字符串类型 (在Python不同数据类型之间无法直接操作)""" -
replace()
# 用新的字符替换字符串中旧的字符 >>> str7 = 'my name is tony, my age is 18!' >>> str7 = str7.replace('18', '73') # 将tony的年龄由18岁改成73岁,语法:replace('旧内容', '新内容') >>> str7 my name is tony, my age is 73! # 可以指定修改的个数 >>> str7 = 'my name is tony, my age is 18!' >>> str7 = str7.replace('my', 'MY', 1) # 只把一个my改为MY >>> str7 MY name is tony, my age is 18! -
isdigit()
# 判断字符串是否是纯数字组成，返回结果为True或False >>> str8 = '5201314' >>> str8.isdigit() True >>> str8 = '123g123' >>> str8.isdigit() False
2.3.3 了解操作
# 1.find(), rfind(), index(), rindex(), count()
# 1.1 find():从指定范围内查找子字符串的起始索引，找得到则返回开始的索引值，找不到则返回-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 \t hello' # \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() # 判断字符串是否是有效的 Python 标识符，可用来判断变量名是否合法。
True
>>> name.islower() # 字符串是否是纯小写
True
>>> name.isupper() # 字符串是否是纯大写
False
>>> name.isspace() # 字符串是否全是空格
False
>>> name.istitle() # 字符串中的单词首字母是否都是大写
False
3.列表类型list
3.1 定义
# 定义：在[]内,用逗号分隔开多个任意数据类型的值
list1 = [1,'a',[1,2]] # 本质:list1 = list([1,'a',[1,2]])
3.2 类型转换
# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
>>> list(123) # 报错
>>> list(123.21) # 报错
>>> 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]
3.3 使用
3.3.1 优先掌握的操作
# 1.按索引存取值(正向存取+反向存取)：即可存也可以取
# 1.1 正向取(从左往右)
>>> my_friends = ['tony', 'jason', 'tom', 4, 5]
>>> my_friends[0]
tony
# 1.2 反向取(负号表示从右往左)
>>> my_friends[-1]
5
# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'tom', 4, 5]
# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
>>> my_friends[0:4]
['tony', 'jason', 'tom', 4]
# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
>>> my_friends[0:4:2]
['tony', 'tom']
# 3.长度
>>> len(my_friends)
5
# 4.成员运算in和not in
>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True
# 5.添加
# 5.1 append():列表尾部追加元素(将括号内的数据当成一个整体追加到列表末尾)
>>> list1 = ['a','b','c']
>>> list1.append('d')
>>> list1
['a', 'b', 'c', 'd']
# 5.2 extend():一次性在列表尾部添加多个元素
>>> list1.extend(['a','b','c'])
>>> list1
['a', 'b', 'c', 'd', 'a', 'b', 'c']
# 5.3 insert():在指定位置插入元素(将括号内的数据当成一个整体插入到索引指定位置)
>>> list1.insert(0,"first") # 0表示按索引位置插入数据
>>> list1
['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']
# 6.删除
# 6.1 del关键字
>>> list2 = [11, 22, 33, 44]
>>> del list2[2] # 删除索引为2的元素
>>> list2
[11, 22, 44]
# 6.2 pop():默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
>>> list3 = [11, 22, 33, 22, 44]
>>> res = list3.pop()
>>> res
44
>>> res = list3.pop(1)
>>> res
22
>>> list3
[11, 33, 22]
# 6.3 remove():括号内指定需要删除的元素值，没有返回值
>>> list4 = [11, 22, 33, 22, 44]
>>> res = list4.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None
>>> list4
[11, 33, 22, 44]
# 7.reverse():颠倒列表内元素顺序
>>> list5 = [11, 22, 33, 44]
>>> list5.reverse()
>>> list5
[44, 33, 22, 11]
# 8.sort()给列表内所有元素排序
# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> list6 = [11, 22, 3,42, 7, 55]
>>> list6.sort()
>>> list6
[3, 7, 11, 22, 42, 55] # 默认从小到大排序
>>> list7 = [11, 22, 3, 42, 7, 55]
>>> list7.sort(reverse=True) # reverse用来指定是否跌倒排序，默认为False
>>> list7
[55, 42, 22, 11, 7, 3]
# 8.2 了解知识:
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
>>> list8 = [1, 2, 3]
>>> list9 = [2, ]
>>> list9 > list8
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
>>> s1 = 'abc'
>>> s2 = 'az'
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
# 因此也可以对下面这个列表排序
>>> v = ['A', 'z', 'adjk', 'hello', 'hea']
>>> v.sort()
>>> v
['A', 'adjk', 'hea', 'hello','z']
# 9.循环
# 循环遍历my_friends列表里面的值
for line in my_friends: # my_friends = ['tony', 'jason', 'tom', 4, 5]
print(line)
tony
jack
jason
4
5
3.3.2 了解操作
# clear():清空列表里的所有元素
>>> lis = [1, 3, 5, 7]
>>> lis.clear()
>>> lis
[]
>>> L = [1, 2, 3, 4, 5, 6]
>>> L[0:3:1] # 正向步长
[1, 2, 3]
>>> L[2::-1] # 反向步长
[3, 2, 1]
# 通过索引取值实现列表翻转
>>> L[::-1]
[6, 5, 4, 3, 2, 1]
浙公网安备 33010602011771号