多个类型对象共有方法

1.方括号切片

语法：[start:end:step]   #step默认为1

适用所有可下标操作的对象，如：str , list，tuple等

例：

print([1,2,3,4,5,6][2:4:1])
print("123456"[4:2:-1])

1.1 复制数组

a = b[:]   #效果等同于浅拷贝

场景：切取片段，翻转

2.reversed()与reverse()

reversed() -- python自带的一个方法，准确说，应该是一个类

作用：反转迭代器的序列值，返回反向迭代器（需要使用类型转换成list/str等）

1.列表的反转：

>>> bb = [1,3,5,7]          
>>> print(list(reversed(bb)))
[7, 5, 3, 1]

2.元组的反转：

>>> aa = (1, 2, 3)           
>>> print(tuple(reversed(aa)))         
(3, 2, 1)

3.字符串的反转

>>> aa = 'asbdamfgh'          
>>> ''.join(reversed(aa)) 不可套用str(reversed(aa))
'hgfmadbsa'

reverse()  -- 列表的内置方法

作用：翻转列表

lista = [1, 2, 3, 4]
lista.reverse()

3.join与split

str.join(sequence)  #方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

注：sequence可为list,tuple,set等，元素必须为str类型

print('-'.join(('1','2','3','4')))  #
str.split(str="", num=string.count(str))  #对字符串进行分割，返回列表
  • str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
  • num -- 分割次数。默认为 -1, 即分隔所有。

4.count() 

适用于list,tuple,str

#统计某个元素在序列中出现的次数  

print([1,2,3,4,4,4,5].count(4))   #3
print('1,2,222,3'.count('2'))     #4

5.remove()

适用于list，set

删除序列中第一个匹配项，无返回值，会改动原对象

aa = [1,2,3,4,5]
aa.remove(4)
print(aa)   #【1,2,3,5】

6.pop()

适用于：list ，dict

会改变原对象

list.pop([index=-1])  #移除指定index的值，默认为末尾值
字典的pop方法：pop(key[,default])  #如果没有key则返回default
ee = {"nn":11,"use":22}
print(ee.pop("nn"))    #返回11
print(ee)              #{'use': 22}

7.index()

适用于 list,tuple,str

#获取序列中匹配到的第一个元素的下标

print([1,2,4,3,4,5].index(4)) #2

print('1,2,3,34'.index('4')) #6

8.len()

适用于list，tuple，str，dict，set

print(len([1,2,4,3,4,5]))   #6

9.max()  min()

适用于str，list，tuple，set，dict

print(max({"nn":11,"use":22,"zd":33}))    #zd 比较key值，返回key值

print(max('1,2,3,34a'))       #a

10.clear()

适用于 list，dict，set

ee = {"nn":11,"use":22,"zd":33}

ee.clear()

print(ee)   #{}

11.sorted()与sort()

sort() 只能对list排序

L.sort(cmp=None, key=None, reverse=False)

aa = [1,3,6,5,8,3,4]
print(aa)  >  [1, 3, 3, 4, 5, 6, 8]

sorted() 对可迭代对象排序
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
 

aa = [1,3,6,5,8,3,4]

bb=sorted(aa)

print(aa)   #保留原对象  [1,3,6,5,8,3,4]  

print(bb)   #[1, 3, 3, 4, 5, 6, 8]

1.比较函数经常会用到lambda。(list子项的某个属性进行排序)

lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。比如对元组组成的列表中某一项进行排序：

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),]  
sorted(students, key=lambda student : student[2])   # sort by age  
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

2.可迭代元素经常会用到items

items是字典中的一个方法，返回由元组组成的列表。

dict={'a':1,'b':2}
ans = sorted(dict.items(), key = lambda x:x[1], reverse = True)

sort,sorted区别与联系

1.sort只对list排序，sorted对list和可迭代对象都能排序

2.sort与sorted都能指定key值排序

3.sort改变原数值；sorted不改变原数值，会生成新数值

list独有方法

list1.append(x)  #list后追加x

list.extend(seq) #list后面追加一个序列，seq可为list,set,tuple,str

list.insert(index, obj)  #列表指定位置插入数据

list.copy()   #复制列表

list.reverse()  #反向排序

list.sort()   #对列表排序

str独有方法

name = "my name \tis {name} and {age} years old"
print(name.capitalize())  #第一个字母大写
print(name.title()) #字符串中每个单词的首字母均大写
print(name.center(50, "-"))#字符串长度为50，不够两边补‘-’
print(name.ljust(50,"*")) #字符串长度为50，不够最右边补‘-’
print(name.rjust(50,"*"))#字符串长度为50，不够最左边补‘-’
print(name.endswith("ex"))#检查字符串是否以传入参数为结尾
print(name.startswith("my"))#检查字符串是否以传入参数为开头
print(name.expandtabs(tabsize=30))#更改tab所占空格
print(name.find("name"))  #返回传入的参数在该字符串中的索引值
print(name.rfind("a")) #找到最右边值为a的下标并返回
print(name.format(name = "alex", age = 23))  #字符串格式化
print(name.format_map({"name":"alex", "age":23})) #字符串格式化，传入的为字典
print("ab23".isalnum())  #检查字符串是否在所有英文字母及阿拉伯数字中
print("abA".isalpha())  #检查字符串是否为纯英文字符
print("0".isdigit()) #判断是否为非负整数，类似于isnumeric()函数
print("a1".isidentifier())  #判断是否为合法的标识符
print(" ".isspace())  #判断是否为空格
print("loA".islower()) #是否小写
print(name.lower())  #字母变为小写
print("ABC".isupper())  #是否大写
print(name.upper())  #字母变为大写
print("I am L".istitle()) #字符串中每个单词首字母是否大写
print("ab".isprintable())#是否可打印（tty文件与drive文件不可打印）
print("+".join(["1","3","3"]))#最好用于字符串分割列表（列表中的元素必须为字符串）
print("\nab c  \n".strip())  #去除两边的空格或回车
print("\nab c  \n".lstrip()) #去除最左边的空格或回车
print("\nab c  \n".rstrip()) #去除最右边的空格或回车

p = str.maketrans("abcdefg", "1234567") #将第一个参数的值替换为第二个参数的值，配合translate使用
print("alex".translate(p))

print("alex li".replace("l", "a", 1))#将字符串中值为第一个参数的替换为第二个参数，数值1表示替换一个，不写替换全部
print("1+2+3+4".split("+")) #以传入的参数为值分割该字符串，返回的是一个列表，若无参数默认以空格分割
print("ajkdj\ndjfkdjf".splitlines())#相当于split("\n"),即换行.注：某些操作系统的换行符为\r\n
print("lex li".swapcase()) #大写变小写，小写变大写

dict独有方法

del d['key']

d.setdefault('key',value)

print(d['key']) #如果写了不存在的值会报错
print(d.get('key')) #如果写了不存在的值，返回None
print(d.get('key','not find ')) #如果找不到存在的值，返回 “not find”
print(d.keys()) #获取所有的key 值
print(d.values()) #获取所有的value 值
print('key' in dict1.keys()) #判断key是否存在

tuple独有方法

2 a=[1,2,3,4,1,5,'q','g']
3 print(tuple(a))    #将列表转为tuple

set独有方法

1：add     #s1.add("alex")

2：s1.difference(s2)   #判断s1与s2的不同，并返回s1中多的部分

3：differnce_update:是将原来的set跟新，set.difference_update(['eric',blare'])把与原来相同的剔除，不返回一个新的set，只是跟新了原有的set(集
4：discard ：移除元素
5：intersection 取交集，新建一个set
6：intersection_update() 跟新有原有的set，不返回
7:issubset：是否是有子集
8:isdisjoint :如果没有交集，返回True
9：issuperset:是否有父集
10:symmetric_difference_update:是将a-b 和b-a 得到的重新组合成一个set#并不能和差集一样（对称差）