python中常用的数据类型有哪些_python中常见的数据类型

str 常用方法

1. 索引(下标)

s = 'ABCDEFGHIJKLMN'

s1 = s[0]

print('s[0] = ' + s1) #s[0] = A

2. 切片：顾头不顾尾

s = 'ABCDEFGHIJKLMN'

s2 = s[0:3]

print('s[0:3] = ' + s2) #s[0:3] = ABC

3. 跳取 s[首:尾:步长]

s3 = 'ABCDEFGHIJKLMN'

print(s3[0:6:2]) #ACE

4. 首字母大写 capitalize

s = 'alexWUsir'

s4_1 = s.capitalize() #首字母大写

print(s4_1) #Alexwusir

5.全部大写 upper

s = 'alexWUsir'

s4_2 = s.upper() #全部大写

print(s4_2) #ALEXWUSIR

6.全部小写 lower

s = 'alexWUsir'

s4_3 = s.lower() #全部小写

print(s4_3) #alexwusir

7. 大小写互换 swapcase

s = 'alexWUsir'

s4_4 = s.swapcase() #大小写互换

print(s4_4) #ALEXwuSIR

8. 每个用特殊字符或数字隔开的单词首字母大写 title

s = 'xc——gx*zs_shy+hihn9bbklv yiu'

s7 = s.title()

print(s7) #Xc——Gx*Zs_Shy+Hihn9Bbklv Yiu

9. 查找 find

#s.find通过元素找索引，找到返回索引，找不到返回-1

#s.index通过元素找索引，找到返回索引，找不到返回error

s = 'alexWUsir'

s8_11 = s.find('W')

s8_12 = s.index('W')

s8_21 = s.find('WU')

s8_22 = s.index('WU')

s8_31 = s.find('A')

s8_32 = s.index('A')

print(s8_11,type(s8_12)) #4

print(s8_21 ,type(s8_22)) #4

print(s8_31 ,type(s8_32)) #报错：ValueError: substring not found----未找到子字符串

10. 删除字符串前后的空格/字符 strip

s = ' alexW%Usir %2% '

s9_1 = s.strip() #删除字符串前后的空格

print(s9_1) #alexW%Usir %2%

ss = '% alexW%Usir %2% %'

s9_2 = ss.strip('%') #删除字符串前后的%

print(s9_2) # alexW%Usir %2%

应用实例

username = input('张三 ').strip()

if username == '张三':

print('你好呀 主人')

11. 计算字符串中某字符/字符串的个数 count

s = 'alexaa wusirl'

s10 = s.count('a')

print('此字符串中有' + s10 + '个a') #报错：TypeError: must be str, not int

print('此字符串中有' + str(s10) + '个a') #此字符串中有3个a

12. 分割 split (默认按空格分割)

s = 'alex wusir taibai'

s1 = 'ale:x wus:ir :taibai'

s11_1 = s.split()

print(s11_1) #['alex', 'wusir', 'taibai']

s11_2 = s1.split(':')

print(s11_2) #['ale', 'x wus', 'ir ', 'taibai']

13. 三种格式化输出 format

s12_1 = '我叫{},今年{}岁，爱好{},再说一下我叫{}'.format('张三',23,'学习','张三')

print(s12_1) #我叫张三,今年23岁，爱好学习,再说一下我叫张三

s12_2 = '我叫{0},今年{1}岁，爱好{2},再说一下我叫{0}'.format('张三',23,'学习')

print(s12_2) #我叫张三,今年23岁，爱好学习,再说一下我叫张三

s12_3 = s1 = '我叫{name},今年{age}岁，爱好{hobby},再说一下我叫{name}'.format(name = '张三',age = 23,hobby = '学习')

print(s12_3) #我叫张三,今年23岁，爱好学习,再说一下我叫张三

14. 替换 replace

s13_1 = '张三，哈喽你好，我是张三'

s13_2 = s13_1.replace('张三','李四')

s13_3 = s13_1.replace('张三','李四',1)

print(s13_1) #张三，哈喽你好，我是张三----原来文本

print(s13_2) #李四，哈喽你好，我是李四----全都替换

print(s13_3) #李四，哈喽你好，我是张三----只替换第一个

15. 有限循环for(while是无限循环)

s = 'zhangsan'

for i in s:

print(i)

list 常用方法

1. 追加 append (在末尾进行添加)

a = [1,2,3]

a.append(4) #the result ： [1, 2, 3, 4]

2. 插入 insert (将对象插入到列表中)

a = [1,2,3]

a.insert(0,'aa') #the result : ['aa', 1, 2, 3]

3. 合并 extend (列表的末尾一次性追加另一个序列中的多个值)

a = [1,2,3]

b = [4,5,6]

a.extend(b) #the result ：[1, 2, 3, 4, 5, 6]

4. 统计 count (统计某个元素在列表中出现的次数)

a = ['aa','bb','cc','aa','aa']

print(a.count('aa')) #the result ： 3

5. 删除 pop (移除列表中的一个元素，默认是最后一个，并且返回该元素的值)

a = [1,2,3]

a.pop() #the result ： [1, 2]

a.pop(0)

6. 删除对象 remove (移除列表中某个值的第一个匹配项)

a = ['aa','bb','cc','aa']

a.remove('aa') #the result ： ['bb', 'cc', 'aa']

7. 反转 reverse (将列表中的元素反向存放)

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

a.reverse() #the result ： ['c', 'b', 'a']

8. 排序 sort (在原位置对列表进行排序，意味着改变原来的列表，让其中的元素按一定顺序排列)

a = ['a','b','c',1,2,3]

a.sort() #the result ：[1, 2, 3, 'a', 'b', 'c']

9. 索引 index (从列表中找出某个值第一个匹配项的索引位置)

a = [1,2,3,1]

print(a.index(1)) #the result ： 0

10. enumerate 用法（打印元素对应的下标）

li = [11,22,33]

for k,v in enumerate(li, 1):

print(k,v) #the result ： 1 11 2 22 3 33

tuple 常用方法

1. 元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义

tup1=(50,)

2. 元组中的元素值使不允许修改的，但可以对元组进行连接组合

tup1=(12,34.56)

tup2=('abc','xyz')

tup1[0]=100 #非法操作，元组中的元素是不允许被修改的

tup3=tup1+tup2 #python运行元组进行连接组合

print(tup3)# 输出:(12,34.56,'abc','xyz')

3. 元组之间可以使用+和*，即允许元组进行组合连接和重复复制，运算后会生成一个新的元组

tup1=(1,2,3)

tup2=(3,4,5)

​

tup3=tup1+tup2 #输出：tup3=(1,2,3,3,4,5)

tup4=tup1*3 #输出： tup4=(1,2,3,1,2,3,1,2,3)

4. 任意无符号的对象，以逗号隔开，默认为元组

a=1,2,3,'hello'

print(a) #输出：(1,2,3,'hello')

5. 对元组进行操作的内建函数

——cmp(tup1,tup2): 比较两个元组元素

——len(tup): 返回元组中元素的个数

——max(tup): 返回元组中元素最大的值

——min(tup): 返回元组中元素最小的值

——tuple(seq): 将列表转化为元组

6. 元组的方法（元组没有列表中的增、删、改的操作，只有查的操作）

——tuple.index(obj)：从元组中找出某个值第一个匹配项的索引值

——tuple.count(obj)： 统计某个元素在元组中出现的次数

dict 常用方法

1. 清空 clear （用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典）

d = {'name':"tom"}

d.clear()

print(d) #the result : {}

2. 获取 get （根据 key 来获取 value，如果key不存在，返回None）

d = {'Tom':8777,'Jack':8888,'Fly':6666}

print(d.get('Tom')) #the result ： 8777

print(d.get('not_exist')) #the result ： None

3. 更新 update （利用一个字典项更新另一个字典，提供的字典中的项会被添加到旧的字典中，如有相同的键则会被覆盖）

d = {'Tom':8777,'Jack':8888,'Fly':6666}

a = {'Tom':110,'Test':119}

d.update(a)

print(d) #the result ：{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}

4. setdefault （在某种程度上类似于get方法，能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值）

d = {'Tom':8777,'Jack':8888,'Fly':6666}

d.setdefault('Tom') #the result ： 8777

print(d.setdefault('Test')) #the result ： None

print(d) #{'Fly': 6666, 'Jack': 8888, 'Tom': 8777, 'Test': None}

5. 删除 pop （用于获取指定 key 对应的 value，并删除这个 key-value 对）

d = {'Tom':8777,'Jack':8888,'Fly':6666}

v = d.pop('Tom')

print(v) #8777

6. fromkeys （使用给定的键建立新的字典，每个键都对应一个默认的值None）

print({}.fromkeys(['name','age'])) #the result　：　{'age': None, 'name': None}

7. for循环字典的三种方法

d = {'Tom':8777,'Jack':8888,'Fly':6666}

for k,v in d.items():

print(k,v)

for k in d.values():

print(k)

for k in d.keys():

print(k)

8. 将两个列表组合成字典

keys = ['a', 'b']

values = [1, 2]

print(dict(zip(keys,values))) # {'a': 1, 'b': 2}