数据类型中的内置方法

1. 字符串的内置方法

　　1.1 len

　　　　len():Python len() 方法返回对象（字符、列表、元组等）长度或项目个数

　　　　语法： len(s) s--对象　　

1 str = "runoob"
2 print( len(str) )          # 字符串长度
3  
4 l = [1,2,3,4,5]
5 print( len(l) )            # 列表元素个数

　　1.2 strip

　　　　strip：Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

　　　　　　　　注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

　　　　语法：str.strip([chars]) chars -- 移除字符串头尾指定的字符序列

1 str = "00000003210Runoob01230000000"; 
2 print str.strip( '0' );  # 去除首尾字符 0
3  
4  
5 str2 = "   Runoob      ";   # 去除首尾空格
6 print str2.strip();

　　1.3 split

　　　　split:split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串

　　　　语法：str.split(str="", num=string.count(str))

　　　　str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等

　　　　num -- 分割次数。默认为 -1, 即分隔所有

1 txt = "Google#Runoob#Taobao#Facebook"
2  
3 # 第二个参数为 1，返回两个参数列表
4 x = txt.split("#", 1)
5  
6 print(x)

　　1.4 upper、lower、isupper、islower

　　　　upper: Python upper() 方法将字符串中的小写字母转为大写字母

　　　　lower: Python lower() 方法转换字符串中所有大写字符为小写

　　　　isupper: isupper() 方法检测字符串中所有的字母是否都为大写

　　　　islower: islower() 方法检测字符串是否由小写字母组成

　　　　语法：字符串对象直接.使用方法没有参数

 1 str = "this is string example from runoob....wow!!!";
 2 print ("str.upper() : ", str.upper())
 3 str = "THIS IS STRING EXAMPLE....WOW!!!";
 4 print str.lower();
 5 str = "THIS IS STRING EXAMPLE....WOW!!!"
 6 print (str.isupper())
 7 str = "THIS is string example....wow!!!"
 8 print (str.isupper())
 9 str = "RUNOOB example....wow!!!"
10 print (str.islower())
11 str = "runoob example....wow!!!"
12 print (str.islower())

　　1.5 startswith

　　　　startswith： startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查

　　　　语法： str.startswith(substr, beg=0,end=len(string));

　　　　str -- 检测的字符串　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　substr -- 指定的子字符串　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　strbeg -- 可选参数用于设置字符串检测的起始位置　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　strend -- 可选参数用于设置字符串检测的结束位置

1 str = "this is string example....wow!!!"
2 print (str.startswith( 'this' ))   # 字符串是否以 this 开头
3 print (str.startswith( 'string', 8 ))  # 从第九个字符开始的字符串是否以 string 开头
4 print (str.startswith( 'this', 2, 4 )) # 从第2个字符开始到第四个字符结束的字符串是否以 this 开头

　　1.6 endswith

　　　　endswith: endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 "start" 与 "end" 为检索字符串的开始与结束位置

　　　　语法：str.endswith(suffix[, start[, end]])

　　　　suffix -- 该参数可以是一个字符串或者是一个元素

　　　　start -- 字符串中的开始位置

　　　　end -- 字符中结束位置。

1 Str='Runoob example....wow!!!'
2 suffix='!!'
3 print (Str.endswith(suffix))
4 print (Str.endswith(suffix,20))
5 suffix='run'
6 print (Str.endswith(suffix))
7 print (Str.endswith(suffix, 0, 19))

　　1.7 format

　　　　format： str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。

 1 "{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
 2 "{0} {1}".format("hello", "world")  # 设置指定位置
 3 "{1} {0} {1}".format("hello", "world")  # 设置指定位置
 4 print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 5 # 通过字典设置参数
 6 site = {"name": "菜鸟教程", "url": "www.runoob.com"}
 7 print("网站名：{name}, 地址 {url}".format(**site))
 8 # 通过列表索引设置参数
 9 my_list = ['菜鸟教程', 'www.runoob.com']
10 print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

　　1.8 join

　　　　join：Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串

　　　　语法：str.join(sequence)

　　　　sequence -- 要连接的元素序列

s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))

　　1.9 replace

　　　　replace：replace() 方法把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

　　　　语法：str.replace(old, new[, max])

　　　　old -- 将被替换的子字符串。

　　　　new -- 新字符串，用于替换old子字符串。

　　　　max -- 可选字符串, 替换不超过 max 次

1 str = "www.w3cschool.cc"
2 print ("菜鸟教程旧地址：", str)
3 print ("菜鸟教程新地址：", str.replace("w3cschool.cc", "runoob.com"))
4  
5 str = "this is string example....wow!!!"
6 print (str.replace("is", "was", 3))

　　1.10 isdigit

　　　　isdigit：Python isdigit() 方法检测字符串是否只由数字组成

　　　　语法：str.isdigit()

1 str = "123456";
2 print (str.isdigit())
3 
4 str = "Runoob example....wow!!!"
5 print (str.isdigit())

　　1.11 了解

 1 1.字体格式相关
 2 # s5 = 'my name is jason my age is 18'
 3 # print(s5.title())  # My Name Is Jason My Age Is 18  所有单词首字母大写
 4 # print(s5.capitalize())  # My name is jason my age is 18  开头的单词首字母大写
 5 s6 = 'JaSOn iS Sb'
 6 print(s6.swapcase())  # jAsoN Is sB  大小写互换
 7 
 8 s7 = 'my name is jason sb sb sb somebody sb sb sb sb sone sb sone'
 9  print(s7.find('s'))  # 查看指定字符对应的起始索引值  从左往右找到一个就结束
10  print(s7.find('sb'))  # 查看指定字符对应的起始索引值  从左往右找到一个就结束
11  print(s7.find('w'))  # 找不到返回-1
12  print(s7.index('w'))  # 找不到直接报错
13  统计某个字符出现的次数(记忆)
14  print(s7.count('sb'))
15 
16 
17  s8 = 'jason'
18  print(s8.center(15, '$'))  # 居中展示
19  print(s8.ljust(15, '&'))  # 左对齐   jason&&&&&&&&&&
20  print(s8.rjust(15, '*'))  # 右对齐   **********jason
21 
22  name = 'tony123'
23  name.isalnum()  # 字符串中既可以包含数字也可以包含字母
24  name.isalpha()  # 字符串中只包含字母

2. 列表的内置方法

　　2.1 列表添加值

　　　　2.1.1 append

　　　　　　　　append：append() 方法用于在列表末尾添加新的对象

　　　　　　　　语法： list.append(obj)

1 list1 = ['Google', 'Runoob', 'Taobao']
2 list1.append('Baidu')
3 print ("更新后的列表 : ", list1)

　　　　2.1.2 insert

　　　　　　insert：insert() 函数用于将指定对象插入列表的指定位置

　　　　　　语法：list.insert(index, obj)

　　　　　　　　index -- 对象obj需要插入的索引位置。

　　　　　　　　obj -- 要插入列表中的对象

1 list1 = ['Google', 'Runoob', 'Taobao']
2 list1.insert(1, 'Baidu')
3 print ('列表插入元素后为 : ', list1)

　　　　2.1.3 extend

　　　　　　extend：extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

　　　　　　语法：list.extend(seq)

　　　　　　seq -- 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾

1 list1 = ['Google', 'Runoob', 'Taobao']
2 list2=list(range(5)) # 创建 0-4 的列表
3 list1.extend(list2)  # 扩展列表
4 print ("扩展后的列表：", list1)

　　2.2 列表的删除

　　　　2.2.1 del

通用删除方式
del name_list[1]  # 根据索引直接删除  del是关键字delete缩写
print(name_list)  # ['jason', 'tony', 'jack']

　　　　2.2.2 remove

　　　　　　remove：remove() 函数用于移除列表中某个值的第一个匹配项

　　　　　　语法：list.remove(obj)

　　　　　　　　obj -- 列表中要移除的对象

1 aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
2 
3 aList.remove('xyz');
4 print ("List : ", aList;)
5 aList.remove('abc');
6 print( "List : ", aList;)

　　　　2.2.3 pop

　　　　　　pop: pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

　　　　　　语法：list.pop([index=-1])

　　　　　　　　obj -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值

1  list1 = ['Google', 'Runoob', 'Taobao']
2 list_pop=list1.pop(1)
3 print "删除的项为 :", list_pop
4 print "列表现在为 : ", list1

　　2.3 列表的其他操作

 1 sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
 2 list.sort( key=None, reverse=False)
 3 key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
 4 reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）
 5 aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
 6  
 7 aList.sort()
 8 print ( "List : ", aList)
 9 # 列表
10 vowels = ['e', 'a', 'u', 'o', 'i']
11  
12 # 降序
13 vowels.sort(reverse=True)
14  
15 # 输出结果
16 print ( '降序输出:', vowels )

1 reverse() 函数用于反向列表中元素
2 list.reverse()
3 list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
4 list1.reverse()
5 print ("列表反转后: ", list1)

3. 字典的内置方法

  1 dic = {
  2     'name': 'jason',
  3     'age': 18,
  4     'hobbies': ['play game', 'basketball']
  5 }
  6 # 1.按k取值  k不存在会直接报错
  7 # print(dic['name'])
  8 # print(dic['pwd'])
  9 # 2.按k修改值 新增键值对(使用频率最高)
 10 # dic['name'] = 'jasonNB'  # 键存在为修改值
 11 # print(dic)
 12 # dic['hobbies'].append('read')
 13 # print(dic)
 14 # dic['pwd'] = 123  # 键不存在为新增键值对
 15 # print(dic)
 16 # 3.统计字典内部键值对的个数
 17 # print(len(dic))  # 3
 18 # 4.成员运算  默认只暴露k
 19 # print('jason' in dic)
 20 # print('name' in dic)
 21 # 5.删除元素
 22 # 方式1
 23 # del dic['name']
 24 # print(dic)
 25 # 方式2  指定k弹出键值对 给出v
 26 # print(dic.pop('age'))
 27 # print(dic)
 28 # 方式3  弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
 29 # print(dic.popitem())
 30 # print(dic)
 31 # 6.获取v值
 32 # print(dic['name'])  # jason  键不存在直接报错  按k取值不太推荐使用该方式
 33 # print(dic['xxx'])  #  键不存在直接报错  按k取值不太推荐使用该方式
 34 # print(dic.get('name'))  # jason
 35 # print(dic.get('xxx'))  # None  键不存在 不会报错返回None
 36 # print(dic.get('name', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息
 37 # print(dic.get('xxx', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息
 38 # 7.keys() values()  items()  在python2中是列表 在python3中是迭代器(老母猪)
 39 # print(dic.keys())  # dict_keys(['name', 'age', 'hobbies'])  获取字典所有的键 看成列表即可
 40 # print(dic.values())  # dict_values(['jason', 18, ['play game', 'basketball']])  获取字典所有的值 看成列表即可
 41 # print(dic.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
 42 # 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v
 43 
 44 
 45 dic = {
 46     'name': 'jason',
 47     'age': 18,
 48     'hobbies': ['play game', 'basketball']
 49 }
 50 # 1.按k取值  k不存在会直接报错
 51 # print(dic['name'])
 52 # print(dic['pwd'])
 53 # 2.按k修改值 新增键值对(使用频率最高)
 54 # dic['name'] = 'jasonNB'  # 键存在为修改值
 55 # print(dic)
 56 # dic['hobbies'].append('read')
 57 # print(dic)
 58 # dic['pwd'] = 123  # 键不存在为新增键值对
 59 # print(dic)
 60 # 3.统计字典内部键值对的个数
 61 # print(len(dic))  # 3
 62 # 4.成员运算  默认只暴露k
 63 # print('jason' in dic)
 64 # print('name' in dic)
 65 # 5.删除元素
 66 # 方式1
 67 # del dic['name']
 68 # print(dic)
 69 # 方式2  指定k弹出键值对 给出v
 70 # print(dic.pop('age'))
 71 # print(dic)
 72 # 方式3  弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
 73 # print(dic.popitem())
 74 # print(dic)
 75 # 6.获取v值
 76 # print(dic['name'])  # jason  键不存在直接报错  按k取值不太推荐使用该方式
 77 # print(dic['xxx'])  #  键不存在直接报错  按k取值不太推荐使用该方式
 78 # print(dic.get('name'))  # jason
 79 # print(dic.get('xxx'))  # None  键不存在 不会报错返回None
 80 # print(dic.get('name', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息
 81 # print(dic.get('xxx', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息
 82 # 7.keys() values()  items()  在python2中是列表 在python3中是迭代器(老母猪)
 83 # print(dic.keys())  # dict_keys(['name', 'age', 'hobbies'])  获取字典所有的键 看成列表即可
 84 # print(dic.values())  # dict_values(['jason', 18, ['play game', 'basketball']])  获取字典所有的值 看成列表即可
 85 # print(dic.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
 86 # 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v
 87 # 1.更新字典  键存在则修改 不存在则创建
 88 # dic.update({'name': 'jasonNB', 'pwd': 123})
 89 # print(dic)
 90 # 2.初始化字典
 91 # print(dict.fromkeys(['k1', 'k2', 'k3'], []))
 92 '''笔试题'''
 93 # res = dict.fromkeys(['k1', 'k2', 'k3'], [])
 94 # # res['k1'].append(111)
 95 # # res['k2'].append(222)
 96 # # res['k3'].append(333)
 97 # res['k1'] = [111,222,333]
 98 # res['k1'].append(444)
 99 # print(res)
100 # 3.当键存在的情况下 不修改而是获取该键对应的值
101 # print(dic.setdefault('name', 'jasonNB'))
102 # print(dic)
103 # 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
104 print(dic.setdefault('pwd', '123'))
105 print(dic)

4. 集合的内置方法

 1 # 1.定义空集合需要使用关键字set
 2 # s1 = set()
 3 # 2.类型转换  能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
 4 '''集合内元素是无序的'''
 5 # 去重
 6 # s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
 7 # print(s1)  # {1, 2, 3, 4}
 8 # name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
 9 # 1.先将列表转换成集合
10 # s1 = set(name_list)
11 # 2.再将去重之后的集合转换成列表
12 # l1 = list(s1)
13 # print(l1)
14 
15 # 关系运算
16 """两个群体之间做差异比较    共同好友 共同关注..."""
17 friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
18 friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们
19 # 1.求两个用户的共同好友
20 # print(friends1 & friends2)  # {'jason', 'eg'}
21 # 2.求两个用户所有的好友
22 # print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
23 # 3.求用户1独有的好友
24 # print(friends1 - friends2)  # {'zero', 'kevin'}
25 # 4.求用户2独有的好友
26 # print(friends2 - friends1)  # {'ricky', 'Jy'}
27 # 5.求用户1和用户2各自的好友
28 # print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}
29 # 6.父集与子集
30 # s1 = {11, 22, 33, 44}
31 # s2 = {11, 33}
32 # print(s1 > s2)  # 判断s1是否是s2的父集   True
33 # print(s2 < s1)  # 判断s2是否是s1的子集   True

5. 元组的内置方法

 1 """
 2 小括号括起来 内部存放多个元素 元素与元素逗号隔开
 3 元素可以是任意数据 但是元组内元素不支持‘修改’(索引指向的元素的内存地址不能改变)
 4     也可以简单的认为它是一个不可变的列表
 5 """
 6 # 类型转换  能够支持for循环的数据都可以转换成元组
 7 # print(tuple(111))
 8 # print(tuple(11.11))
 9 # print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
10 # print(tuple([11,22,33]))  # (11, 22, 33)
11 # print(tuple({'name':'jason','pwd':123}))  # ('name', 'pwd')
12 
13 # 元组第一道笔试题
14 # t1 = (111)  # 整型
15 # t2 = (11.11)  # 浮点型
16 # t3 = ('hello')  # 字符串
17 '''元组哪怕内部只有一个元素 也需要加上逗号'''
18 # print(type((111,)))
19 '''容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
20     建议:所有的容器类型在存储数据的时候 如果内部只有一个元素 
21         那么也推荐你加上逗号
22 '''
23 # t = (111, 222, 333, 444, 555)
24 # 1.索引取值
25 # print(t[2])
26 # print(t[-1])
27 # 2.切片操作
28 # print(t[1:5])
29 # print(t[1:])
30 # print(t[:])
31 # 3.步长
32 # print(t[1:5:2])
33 # 4.统计元组内元素的个数
34 # print(len(t))  # 5
35 # 5.for循环
36 # for i in t:
37 #     print(i)
38 # 6.count计数
39 # print(t.count(111))  # 1
40 '''笔试题'''
41 t1 = (111, 222, [11, 22, 33])
42 t1[2].append(44)
43 print(t1)

6. 可变数据类型和不可变数据类型

 1 # s5 = 'my name is jason my age is 18'
 2 # print(s5.title())  # 打印出来的是操作之后的结果  # My Name Is Jason My Age Is 18
 3 # print(s5)  # my name is jason my age is 18
 6 # name_list = ['jason', 'kevin', 'tony', 'jack']
 7 # print(id(name_list))
 8 # print(name_list.remove('jason'))  # 打印出来的是None
 9 # print(name_list)  # ['kevin', 'tony', 'jack']
10 # print(id(name_list))
11 # 可变类型与不可变类型
12 """
13 可变类型 >>> 列表
14     值改变 内存地址不变 修改的是原值   
15 不可变类型 >>> 整型 浮点型 字符串
16     值改变 内存地址肯定变 其实是产生了新值
17 """
18 name_list = ['jason', 'kevin', 'tony', 'jack']
19 print(id(name_list))
20 name_list.append(123)
21 print(id(name_list))

不可变数据类型

可变数据类型

posted @ 2021-11-08 16:43 XX_Bb 阅读(64) 评论(0) 编辑收藏举报

XX_Bb

数据类型中的内置方法

数据类型中的内置方法

1. 字符串的内置方法

1.1 len

1.2 strip

1.3 split

1.4 upper、lower、isupper、islower

1.5 startswith

1.6 endswith

1.7 format

1.8 join

1.9 replace

1.10 isdigit

1.11 了解

2. 列表的内置方法

2.1 列表添加值

2.2 列表的删除

2.2.1 del

2.2.2 remove

2.2.3 pop

2.3 列表的其他操作

3. 字典的内置方法

4. 集合的内置方法

5. 元组的内置方法

6. 可变数据类型和不可变数据类型

公告

　　1.1 len

　　1.2 strip

　　1.3 split

　　1.4 upper、lower、isupper、islower

　　1.5 startswith

　　1.6 endswith

　　1.7 format

　　1.8 join

　　1.9 replace

　　1.10 isdigit

　　1.11 了解

　　2.1 列表添加值

　　2.2 列表的删除

　　　　2.2.1 del

　　　　2.2.2 remove

　　　　2.2.3 pop

　　2.3 列表的其他操作