python内建数据类型_python数据类型内置方法

目录

一 字符串内置方法

二 列表内置方法

三 元组内置方法

四 字典内置方法

五 集合内置方法

六 补充了解的知识

一 字符串内置方法

一 常用的内置方法

1.1 strip,lstrip,rstrip

name = '**nick_xm**'

name.strip('*') # 去除左右两边指定的字符

name.lstrip('*') # 去除左边指定的字符

name.rstrip('*') # 去除右边指定的字符

1.2 lower,upper

name = 'hello'

name.lower() # 把name的值中的英文全部改成小写

name.upper() # 把name的值中的英文全部改成大写

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

1.4 format

# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}

>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')

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

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

1.6 join

# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串

>>> '%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接

'h%e%l%l%o'

>>> '|'.join(['tony','18','read']) # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接

'tony|18|read'

1.7 replace

# 用新的字符替换字符串中旧的字符

>>> str7 = 'my name is tony, my age is 18!' # 将tony的年龄由18岁改成73岁

>>> str7 = str7.replace('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!'

1.8 isdigit

# 判断字符串是否是纯数字组成，返回结果为True或False

>>> str8 = '5201314'

>>> str8.isdigit()

True

>>> str8 = '123g123'

>>> str8.isdigit()

False

二 列表内置方法

二 列表常用的内置方法

# 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 = ['tony','jack','jason',4,5]

>>> my_friends[1] = 'martthow'

>>> my_friends

['tony', 'martthow', 'jason', 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()列表尾部追加元素

>>> l1 = ['a','b','c']

>>> l1.append('d')

>>> l1

['a', 'b', 'c', 'd']

# 5.2 extend()一次性在列表尾部添加多个元素

>>> l1.extend(['a','b','c'])

>>> l1

['a', 'b', 'c', 'd', 'a', 'b', 'c']

# 5.3 insert()在指定位置插入元素

>>> l1.insert(0,"first") # 0表示按索引位置插值

>>> l1

['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

# 6.删除

# 6.1 del

>>> l = [11,22,33,44]

>>> del l[2] # 删除索引为2的元素

>>> l

[11,22,44]

# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素

>>> l = [11,22,33,22,44]

>>> res=l.pop()

>>> res

44

>>> res=l.pop(1)

>>> res

22

# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值

>>> l = [11,22,33,22,44]

>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素

>>> print(res)

None

# 7.reverse()颠倒列表内元素顺序

>>> l = [11,22,33,44]

>>> l.reverse()

>>> l

[44,33,22,11]

# 8.sort()给列表内所有元素排序

# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错

>>> l = [11,22,3,42,7,55]

>>> l.sort()

>>> l

[3, 7, 11, 22, 42, 55] # 默认从小到大排序

>>> l = [11,22,3,42,7,55]

>>> l.sort(reverse=True) # reverse用来指定是否跌倒排序，默认为False

>>> l

[55, 42, 22, 11, 7, 3]

# 8.2 了解知识：

# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如

>>> l1=[1,2,3]

>>> l2=[2,]

>>> l2 > l1

True

# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大

>>> s1='abc'

>>> s2='az'

>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立

True

# 所以我们也可以对下面这个列表排序

>>> l = ['A','z','adjk','hello','hea']

>>> l.sort()

>>> l

['A', 'adjk', 'hea', 'hello','z']

# 9.循环

# 循环遍历my_friends列表里面的值

for line in my_friends:

print(line)

'tony'

'jack'

'jason'

4

5

三 元组内置方法

三 元组常用的内置方法

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)

# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！

>>> tuple1[0]

1

>>> tuple1[-2]

22

>>> tuple1[0] = 'hehe' # 报错：TypeError:

# 2、切片(顾头不顾尾，步长)

>>> tuple1[0:6:2]

(1, 15000.0, 22)

# 3、长度

>>> len(tuple1)

6

# 4、成员运算 in 和 not in

>>> 'hhaha' in tuple1

True

>>> 'hhaha' not in tuple1

False

# 5、循环

>>> for line in tuple1:

... print(line)

1

hhaha

15000.0

11

22

33

四 字典内置方法

4.1 常用的内置方法

# 1、按key存取值：可存可取

# 1.1 取

>>> dic = {

... 'name': 'xxx',

... 'age': 18,

... 'hobbies': ['play game', 'basketball']

... }

>>> dic['name']

'xxx'

>>> dic['hobbies'][1]

'basketball'

# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value

>>> dic['gender'] = 'male'

>>> dic

{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}

# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值

>>> dic['name'] = 'tony'

>>> dic

{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}

# 2、长度len

>>> len(dic)

3

# 3、成员运算in和not in

>>> 'name' in dic # 判断某个值是否是字典的key

True

# 4、删除

>>> dic.pop('name') # 通过指定字典的key来删除字典的键值对

>>> dic

{'age': 18, 'hobbies': ['play game', 'basketball']}

# 5、键keys()，值values()，键值对items()

>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}

# 获取字典所有的key

>>> dic.keys()

dict_keys(['name', 'age', 'hobbies'])

# 获取字典所有的value

>>> dic.values()

dict_values(['xxx', 18, ['play game', 'basketball']])

# 获取字典所有的键值对

>>> dic.items()

dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

# 6、循环

# 6.1 默认遍历的是字典的key

>>> for key in dic:

... print(key)

...

age

hobbies

name

# 6.2 只遍历key

>>> for key in dic.keys():

... print(key)

...

age

hobbies

name

# 6.3 只遍历value

>>> for key in dic.values():

... print(key)

...

18

['play game', 'basketball']

xxx

# 6.4 遍历key与value

>>> for key in dic.items():

... print(key)

...

('age', 18)

('hobbies', ['play game', 'basketball'])

('name', 'xxx')

4.2 字典重要的内置方法

1.get()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> dic.get('k1')

'jason' # key存在，则获取key对应的value值

>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None

>>> print(res)

None

>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值

>>> print(res)

666

# ps:字典取值建议使用get方法

2.pop()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值

>>> dic

{'k1': 'jason', 'kk2': 'JY'}

>>> v

'Tony'

3.popitem()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回

>>> dic

{'k3': 'JY', 'k2': 'Tony'}

>>> item

('k1', 'jason')

4.update()

# 用新字典更新旧字典，有则修改，无则添加

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}

>>> dic.update({'k1':'JN','k4':'xxx'})

>>> dic

{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

5.fromkeys()

>>> dic = dict.fromkeys(['k1','k2','k3'],[])

>>> dic

{'k1': [], 'k2': [], 'k3': []}

6.setdefault()

# key不存在则新增键值对，并将新增的value返回

>>> dic={'k1':111,'k2':222}

>>> res=dic.setdefault('k3',333)

>>> res

333

>>> dic # 字典中新增了键值对

{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值

>>> dic={'k1':111,'k2':222}

>>> res=dic.setdefault('k1',666)

>>> res

111

>>> dic # 字典不变

{'k1': 111, 'k2': 222}

五 集合的内置方法

5.1 集合常用的内置方法

# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）

>>> friends1 | friends2

{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友

>>> friends1 & friends2

{'jason', 'egon'}

# 3.差集(-)：

>>> friends1 - friends2 # 求用户1独有的好友

{'kevin', 'zero'}

>>> friends2 - friends1 # 求用户2独有的好友

{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）

>>> friends1 ^ friends2

{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)

>>> friends1 == friends2

False

# 6.父集：一个集合是否包含另外一个集合

# 6.1 包含则返回True

>>> {1,2,3} > {1,2}

True

>>> {1,2,3} >= {1,2}

True

# 6.2 不存在包含关系，则返回False

>>> {1,2,3} > {1,3,4,5}

False

>>> {1,2,3} >= {1,3,4,5}

False

# 7.子集

>>> {1,2} < {1,2,3}

True

>>> {1,2} <= {1,2,3}

True

5.2 集合常用方法 去重

集合去重复有局限性

# 1. 只能针对不可变类型

# 2. 集合本身是无序的，去重之后无法保留原来的顺序

示例如下

>>> l=['a','b',1,'a','a']

>>> s=set(l)

>>> s # 将列表转成了集合

{'b', 'a', 1}

>>> l_new=list(s) # 再将集合转回列表

>>> l_new

['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

l=[

{'name':'lili','age':18,'sex':'male'},

{'name':'jack','age':73,'sex':'male'},

{'name':'tom','age':20,'sex':'female'},

{'name':'lili','age':18,'sex':'male'},

{'name':'lili','age':18,'sex':'male'},

]

new_l=[]

for dic in l:

if dic not in new_l:

new_l.append(dic)

print(new_l)

# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重

[

{'age': 18, 'sex': 'male', 'name': 'lili'},

{'age': 73, 'sex': 'male', 'name': 'jack'},

{'age': 20, 'sex': 'female', 'name': 'tom'}]

六 补充了解的知识

6.1 字符串用的少的内置方法

# 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.islower() # 字符串是否是纯小写

True

>>> name.isupper() # 字符串是否是纯大写

False

>>> name.isspace() # 字符串是否全是空格

False

>>> name.istitle() # 字符串中的单词首字母是否都是大写

False

6.2 列表需要了解的内置方法

>>> l[0:3:1]

[1, 2, 3] # 正向步长

>>> l[2::-1]

[3, 2, 1] # 反向步长

# 通过索引取值实现列表翻转

>>> l[::-1]

[6, 5, 4, 3, 2, 1]

6.3 集合需要了解的方法

# 1.长度

>>> s={'a','b','c'}

>>> len(s)

3

# 2.成员运算

>>> 'c' in s

True

# 3.循环

>>> for item in s:

... print(item)

...

c

a

b