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 <class 'int'>
print(s8_21 ,type(s8_22))     #4 <class 'int'>
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}