Python基本数据类型及内置方法（一）

目录

• 数据类型
• 1.数字类型int与float
  • • 1.1 定义
    • 1.2 类型转换
    • 1.3 使用
• 2.字符串类型str
  • • 2.1 定义
    • 2.2 类型转换
    • 2.3 使用
      • 2.3.1 优先掌握的操作
      • 2.3.2 需要掌握的操作
      • 2.3.3 了解操作
• 3.列表类型list
  • • 3.1 定义
    • 3.2 类型转换
    • 3.3 使用
      • 3.3.1 优先掌握的操作
      • 3.3.2 了解操作

数据类型

数据类型是用来记录事物状态的，而事物的状态是不断变化的（如：一个人年龄的增长（操作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 需要掌握的操作

1. strip(),lstrip(),rstrip()

   >>> str1 = '***tony***'
    
   >>> str1.strip('*')  # 移除左右两边的指定字符
   'tony'
   >>> str1.lstrip('*')  # 只移除左边的指定字符
   tony***
   >>> str1.rstrip('*')  # 只移除右边的指定字符
   ***tony
   

2. lower(),upper()

   >>> str2 = 'My nAme is tonY！'
    
   >>> str2.lower()  # 将英文字符串全部变小写
   my name is tony！
   >>> str2.upper()  # 将英文字符串全部变大写
   MY NAME IS TONY！
   

3. 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
   

4. 格式化输出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!
   

5. 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']
   

6. 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不同数据类型之间无法直接操作)"""
   

7. 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!
   

8. 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]