各个数据类型的内置方法（字符串和列表）

李巨城

各个数据类型的内置方法

整形和浮点型的内置方法

1. # 1、定义：
2. # 1.1 整型int的定义
3. age=10  # 本质age = int(10)
5. # 1.2 浮点型float的定义
6. salary=3000.3  # 本质salary=float(3000.3)
8. # 注意：名字+括号的意思就是调用某个功能，比如
9. # print(...)调用打印功能
10. # int(...)调用创建整型数据的功能
11. # float(...)调用创建浮点型数据的功能

复制代码

1. # 1、数据类型转换
2. # 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
3. >>> s = '123'
4. >>> res = int(s)
5. >>> res,type(res)
6. (123, <class 'int'>)
8. >>> int('12.3') # 错误演示：字符串内包含了非整数符号.
9. Traceback (most recent call last):
10.   File "<stdin>", line 1, in <module>
11. ValueError: invalid literal for int() with base 10: '12.3'
12.      
13. # 1.2 进制转换
14. # 十进制转其他进制
15. >>> bin(3)
16. '0b11'
17. >>> oct(9)
18. '0o11'
19. >>> hex(17)
20. '0x11'
21. # 其他进制转十进制
22. >>> int('0b11',2)
23. 3
24. >>> int('0o11',8)
25. 9
26. >>> int('0x11',16)
27. 17
29. # 1.3 float同样可以用来做数据类型的转换
30. >>> s = '12.3'
31. >>> res=float(s)
32. >>> res,type(res)
33. (12.3, <class 'float'>)

复制代码

数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法
字符串

1. # 定义：在单引号\双引号\三引号内包含一串字符
2. name1 = 'jason'                  # 本质:name = str('任意形式内容')
3. name2 = "lili"                   # 本质:name = str("任意形式内容")
4. name3 = """ricky"""           # 本质:name = str("""任意形式内容""")

复制代码

1. 数据类型转换：str()可以将任何数据类型转换为字符串类型，例如：
2. python(str([1,2,3]))#list->str
3. <<class 'str'>>
4. python(type(str({'name':'jaswe','age':18})))
5. <class 'str'># dict->str
6. print(type(str({1,2,3,4})))
8. print(type(str((1,2,3))))
9. <class 'str'>
10. <class 'str'>

复制代码

1. 基础
2. >>> str1 = 'hello python!'
5. # 1.按索引取值(正向取，反向取)：
6. # 1.1 正向取(从左往右)
7. >>> str1[6]
8. p
9. # 1.2 反向取(负号表示从右往左)
10. >>> str1[-4]
11. h
12. # 1.3 对于str来说，只能按照索引取值，不能改
13. >>> str1[0]='H' # 报错TypeError
16. # 2.切片(顾头不顾尾，步长)
17. # 2.1 顾头不顾尾：取出索引为0到8的所有字符
18. >>> str1[0:9]  
19. hello pyt
20. # 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符
21. >>> str1[0:9:2]  
22. hlopt
23. # 2.3 反向切片
24. >>> str1[::-1]  # -1表示从右往左依次取值
25. !nohtyp olleh
27. # 3.长度len
28. # 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
29. >>> len(str1) # 空格也算字符
30. 13
32. # 4.成员运算 in 和 not in       
33. # 4.1 int:判断hello 是否在 str1里面
34. >>> 'hello' in str1  
35. True
36. # 4.2 not in:判断tony 是否不在 str1里面
37. >>> 'tony' not in str1
38. True
40. # 5.strip移除字符串首尾指定的字符(默认移除空格)
41. # 5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
42. >>> str1 = '  life is short!  '
43. >>> str1.strip()  
44. life is short!
46. # 5.2 括号内指定字符，移除首尾指定的字符
47. >>> str2 = '**tony**'  
48. >>> str2.strip('*')  
49. tony
51. # 6.切分split
52. # 6.1 括号内不指定字符，默认以空格作为切分符号
53. >>> str3='hello world'
54. >>> str3.split()
55. ['hello', 'world']
56. # 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
57. >>> str4 = '127.0.0.1'
58. >>> str4.split('.')  
59. ['127', '0', '0', '1']  # 注意:split切割得到的结果是列表数据类型
62. # 7.循环
63. >>> str5 = '今天你好吗？'
64. >>> for line in str5:  # 依次取出字符串中每一个字符
65. ...     print(line)
66. ...
67. 今
68. 天
69. 你
70. 好
71. 吗
72. ？

复制代码

重点掌握

• strip, lstrip, rstrip
  
• lower(), upper()
  
• startswith, endswith
  
• 格式化输出之format
  
• format的其他使用方式
  
• split,rsplit
  
• join
  
• replace
  
• isdigit
  

1. 1.strip,lstrip,rstrip
2. str1='###Erfd###'
3. print(str1.strip('#'))左右两边
4. print(str1.lstrip('#'))左边
5. print(str1.rstrip('#'))右边
6. Erfd
7. Erfd###
8. ###Erfd

复制代码

1. 2.lower(),upper()
2. str2='saEFDfef'
3. print(str2.lower())#小写
4. print(str2.upper())#大写
6. saefdfef
7. SAEFDFEF

复制代码

1. 3.startswith,endswith
2. # startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
3. # endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
4. str3 = 'tony jam'
5. print(str3.startswith('t'))
6. print(str3.endswith('t'))
7. True
8. False

复制代码

1. 4.格式化输出format
2. 之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式
3. str4='name:{name},age:{age}'.format(age=18,name='sfv')
4. print(str4)
5. name:sfv,age:18
7. str4='name:{name},age:{age},age:{age},age:{age},age:{age}'.format(age=18,name='sfv')
8. print(str4)
9. name:sfv,age:18,age:18,age:18,age:18

复制代码

1. 其他方式
2. # 类似于%s的用法，传入的值会按照位置与{}一一对应
3. str4='name:{},age:{}'.format('asdf',12)
4. print(str4)
5. name:asdf,age:12
6. # 把format传入的多个值当作一个列表，然后用{索引}取值
7. str4='name:{0},age:{1}'.format('asdf',12)
8. print(str4)
9. str4='name:{1},age:{0}'.format(12,'dsdf')
10. print(str4)
11. name:dsdf,age:12

复制代码

1. 5.split,rsplit
2. # split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
4. str5='c:/sdw/ds/dw/ac/sd.txt'
5. print(str5.split('/',1))
6. ['c:', 'sdw/ds/dw/ac/sd.txt']
7. # rsplit刚好与split相反，从右往左切割，可以指定切割次数
8. str5='c:/sdw/ds/dw/ac/sd.txt'
9. print(str5.rsplit('/',1))
10. ['c:/sdw/ds/dw/ac', 'sd.txt']

复制代码

1. 6.join
2. # 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
3. print('#'.join('sefdgs'))
4. # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
5. s#e#f#d#g#s
6. print('|'.join(['tony','18','read']))
7. # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
8. tony|18|read

复制代码

1. 7.replace
2. # 用新的字符替换字符串中旧的字符
3. str7 = 'my name is tony, my age is 18!'
4. print(str7.replace('18','34'))
5. my name is tony, my age is 34!
6. # 只把一个my改为MY
7. str7 = 'my name is tony, my age is 18!'
8. print(str7.replace('my','MY',1))
9. MY name is tony, my age is 18!

复制代码

1. 8.isdigit
2. # 判断字符串是否是纯数字组成，返回结果为True或False
3. str8='235235'
4. print(str8.isdigit())
5. True
6. str8='235223sf35'
7. print(str8.isdigit())
8. False

复制代码

了解部分

1. 1.find rfind
2. find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
3. fate='tonr asr dfeei sccof'
4. print(fate.find('o',0,13))
5. 1
6. 2.index:同find,但在找不到时会报错

复制代码

1. 3.count
2. count:统计字符串在大字符串中出现的次数
3. fate='tonr asr dfeei sccof'
4. # print(fate.find('o',0,13))
5. print(fate.count('o'))
6. 2

复制代码

1. 4.center,ljust,rjust,zfill
2. name='sdacd'
3. print(name.center(30,'-'))#居中
4. print(name.rjust(30,'@'))#右对齐
5. print(name.ljust(30,'#'))#左对齐
6. print(name.zfill(50))#右对齐0补充
10. ------------sdacd-------------
11. @@@@@@@@@@@@@@@@@@@@@@@@@sdacd
12. sdacd#########################
13. 000000000000000000000000000000000000000000000sdacd

复制代码

1. 5.expandtabs
2. name = 'tony\thello'  # \t表示制表符(tab键)
3. print(name)
5. tony        hello

复制代码

1. 6.captalize,swapcase,title
2. buxiangxei='hello xIanG mo yu'
3. print(buxiangxei.capitalize())#首字母大写
4. print(buxiangxei.swapcase())#大小写反转
5. print((buxiangxei.title()))#每个首字母大写
9. Hello xiang mo yu
10. HELLO XiANg MO YU
11. Hello Xiang Mo Yu

复制代码

1. 7.is数字类型
2. #isdigit() 方法检测字符串是否只由数字组成，只对 0 和 正数有效。
3. # isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
4. #IsNumeric 函数返回一个布尔值，指示指定的表达式是否可作为数字来计算。如果表达式作为数字来计算则返回 True ，否则返回 False
6. num1 = b'4' #bytes
7. num2 = u'4' #unicode,python3中无需加u就是unicode
8. num3 = '四' #中文数字
9. num4 = 'Ⅳ' #罗马数
10. print(num1.isdigit())
11. print(num2.isdigit())
12. print(num3.isdigit())
13. print(num4.isdigit())
14. #isdecimal:uncicode(bytes类型无isdecimal方法)
15. print(num2.isdecimal())
16. print(num3.isdecimal())
17. print(num4.isdecimal())
18. #isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
19. print(num2.isnumeric())
20. print(num3.isnumeric())
21. print(num4.isnumeric())
22. # 三者不能判断浮点数
23. num5='4.5'
24. print(num5.isdecimal())
25. print(num5.isdigit())
26. print(num5.isnumeric())
29. True
30. True
31. False
32. False
33. True
34. False
35. False
36. True
37. True
38. True
39. False
40. False
41. False
43. 总结:
44.         最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
45.         如果要判断中文数字或罗马数字,则需要用到isnumeric。

复制代码

列表

1. # 定义：在[]内,用逗号分隔开多个任意数据类型的值
2. l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])
3. # 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
4. >>> list('wdad')                                          # 结果：['w', 'd', 'a', 'd']
5. >>> list([1,2,3])                                         # 结果：[1, 2, 3]
6. >>> list({"name":"jason","age":18}) #结果：['name', 'age']
7. >>> list((1,2,3))                                         # 结果：[1, 2, 3]
8. >>> list({1,2,3,4})                                 # 结果：[1, 2, 3, 4]
9. 使用
10. # 1.按索引存取值(正向存取+反向存取)：即可存也可以取  
11. # 1.1 正向取(从左往右)
12. my_friends=['tony','jason','tom',4,5]
13. print(my_friends[0])
14. tony
15. # 1.2 反向取(负号表示从右往左)
16. print( my_friends[-1])
17. # 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
18. my_friends[1] = 'martthow'
19. print(my_friends)
20. ['tony', 'martthow', 'jason', 4, 5]

复制代码

1. # 2.切片(顾头不顾尾，步长)
2. # 2.1 顾头不顾尾：取出索引为0到3的元素
3. print(my_friends[0:4])
4. ['tony', 'jason', 'tom', 4]
5. # 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
6. print(my_friends[0:4:2])
7. ['tony', 'tom']
8. #3.长度
9. print(len(my_friends))
10. 5

复制代码

1. # 4.成员运算in和not in
2. print('tony' in my_friends)
3. True
4. print('xxx' not in my_friends)
5. True

复制代码

1. #5.添加
2. #5.1 append()列表尾部追加元素
3. l1 = ['a','b','c']
4. l1.append('d')
5. print(l1)
6. ['a', 'b', 'c', 'd']
7. # 5.2 extend()一次性在列表尾部添加多个元素
8. l1.extend(['a','b','c'])
9. print(l1)
10. # 5.3 insert()在指定位置插入元素
11. l1.insert(0,"first")  # 0表示按索引位置插值
12. print(l1)
13. ['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

复制代码

1. # 6.删除
2. # 6.1 del
3. l = [11,22,33,44]
4. del l[2]  # 删除索引为2的元素
5. print(l)
6. # 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
7. l = [11,22,33,22,44]
8. res=l.pop()
9. print(res)
10. 44
11. res=l.pop(1)
12. print(res)
13. 22
14. # 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
15. l = [11,22,33,22,44]
16. res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
17. print(res)
18. None

复制代码

1. 7.reverse()颠倒列表内元素顺序
2. l = [11,22,33,44]
3. l.reverse()
4. print(l)
5. [44,33,22,11]

复制代码

1. # 8.sort()给列表内所有元素排序
2. # 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
3. l = [11,22,3,42,7,55]
4. l.sort()
5. print(l)
6. [3, 7, 11, 22, 42, 55]  # 默认从小到大排序
7. l = [11,22,3,42,7,55]
8. l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
9. print(l)
10. [55, 42, 22, 11, 7, 3]
11. # 8.2 了解知识
12. # 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
13. l1=[1,2,3]
14. l2=[2,]
15. print(l2>l1)
16. # 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
17. s1='abc'
18. s2='az'
19. print(s2>s1)
20. # 所以我们也可以对下面这个列表排序
21. l = ['A','z','adjk','hello','hea']
22. l.sort()
23. print(l)

复制代码

1. # 9.循环
2. # 循环遍历my_friends列表里面的值
3. my_friends=['tony','jack','jason',4,5]
4. for line in my_friends:
5.         print(line)
6. 'tony'
7. 'jack'
8. 'jason'
9. 4
10. 5

复制代码

来源:https://www.cnblogs.com/zhangfanshixiaobai/p/17668190.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！