python实验二序列_Python学习笔记二：02序列类型的各自方法

最新推荐文章于 2022-10-20 19:54:50 发布

weixin_39990029

最新推荐文章于 2022-10-20 19:54:50 发布

阅读量184

点赞数

文章标签： python实验二序列

本文链接：https://blog.csdn.net/weixin_39990029/article/details/113979520

版权

方法是与对象有紧密联系的函数，对象可能是列表、数字，也可能是字符串或其他类型的对象。

调用语法如下：

对象.方法()

在python中，一切皆对象

1.列表的常用方法

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

>>>dir(li) 　　 #查看方法和属性

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',

'__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',

'__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__',

'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

双下划线的是魔法方法(面向对象才学)，后面的是方法

>>>help(list)　 #查看方法和属性箭头表示返回类型

(1)L.append(obj) 在列表末尾添加新的对象。

>>>help(list.append)

#　　 L.append(object) -> None -- append object to end 添加对象到末尾，无返回值

>>>li.append(3) 　　#添加3到末尾

>>>li 　　#[1, 2, 3]

(2)L.clear() 清空整个列表。

#　　L.clear() -> None -- remove all items from L　　清除所有items(项) 返回None

>>>li.clear()　　#[]

(3)L.copy() 复制列表。

#　　L.copy() -> list -- a shallow copy of L　　复制一个列表，返回一个列表

>>>li2=li.copy() 　　#拿li2接收这两个对象是不一样的，虽然内容一样

>>>id(li)　　　　#1779135890632

>>>id(li2)　　　　#1779135891848

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

#　　 L.count(value) -> integer -- return number of occurrences of value　　记某一元素在列表中出现的次数返回一个整型

>>>li.count(1)　　#1

(5)L.extend(obj) 用obj扩展原来的列表。

#　　L.extend(iterable) -> None -- extend list by appending elements from the iterable　　　　用于在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

#　　序列类型都是可迭代的

>>>li.extend([1])　　#[1, 2, 3, 1]

>>>dir(li) 　　 #__iter__ 有这个就是可迭代的

#extend()和append()的区别就是

>>>li.extend([1]) #[1, 2, 3, 1]

>>>li.append([1,2,3]) #[1, 2, 3, 1, [1, 2, 3]]

#还可以用分片赋值实现相同的结果

>>>a=['hello','world']

>>>b=['python','is','funny']

>>>a[len(a):]=b　　#['hello', 'world', 'python', 'is', 'funny']

(6)L.index(obj) 从列表中找某个值第一个匹配项的索引位置。

#L.index(value, [start, [stop]]) -> integer -- return first index of value.Raises ValueError if the value is not present.　　用于从列表中找出某个值第一个匹配项的索引第一次出现的位置

>>>li2.index(1) #返回这个value第一次出现的位置

#默认是从0开始到末尾，但也可以指定：L.index(value, [start, [stop]]) 　　　　#中括号是可选参数

>>>li2.index(1,2) #从2位置开始找1,默认到末尾

>>>li2.index(1,2,5) #中括号时可选参数

(7)L.insert(index,obj) 插入元素，可以指定位置。

#　　L.insert(index, object) -- insert object before index　　将对象插入列表

>>>li2.insert(3,'lucky')　　#在3的位置插入

#　　也可以和extend()一样用分片赋值实现

>>>li2[2:2]=['ssss']　　#['a', 'b', 'ssss', 'd', 'c']

(8)L.pop(index) 出栈，可以指定位置。index默认是L[-1]

#L.pop([index]) -> item -- remove and return item at index (default last).Raises IndexError if list is empty or index is out of range.

#　　用于移除列表中的一个元素(默认是最后一个元素)，并且返回该元素的值

>>>li2.pop() #有返回值，也改变了列表，把列表中的最后一个元素抛出来，默认删除最后一个元素

>>>li2.pop(2) #也可以指定索引删除

#pop方法是惟一一个既能修改又能返回元素值(除了None)的列表方法。要将若干盘子堆成一堆，只能在一个盘子的上面放另一一个一个wangxiana个盘子；

#要拿盘子时，只能从顶部一个一个往下拿，最后放入的盘子是最先被拿的。栈也是这样，最后放入栈的最先被移除，称为LIFO(last in first out)，即后进先出

#栈中的放入和移除操作有统一的称谓---入栈(push)和出栈(pop)

#使用pop方法可以实现一种常见的数据结构--栈。

#栈的原理就像是堆放一个盘子，(9)L.remove(obj) 移除指定元素从左边开始的第一个。

#L.remove(value) -> None -- remove first occurrence of value.Raises ValueError if the value is not present.　　移除列表中某个值的第一个匹配项

#指定元素删除，没有返回值,只删除了第一次出现重复的元素,第二次之后出现的值没有被移除

#删除没有的元素会报错

>>>li2.remove('ssss')　　#['a', 'b', 'd', 'c']

>>>li2.remove('ss')　　#ValueError: list.remove(x): x not in list

#有一点需要了解的是：remove是一个没有返回值的原位置元素变更方法，它修改了列表却没有返回值，与pop方法正好相反。

(10)L.reverse() 反向列表中元素。

#　　L.reverse() -- reverse *IN PLACE*　　用于反向列表中的元素

>>>li2.reverse()　　#['c', 'd', 'b', 'a']

#该方法改变了列表但不返回值

(11)L.sort() 对原列表进行排序。列表中的元素要类型相同 (key = len)

#　　L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* 　　对原列表进行排序，如果指定参数，就使用参数指定的比较方法进行排序。默认升序排序

>>>li=[2,1,5,6,3]

>>>li.sort()　　 #必须是同种类型的才可以排序

>>>li2=['a','b','d','c'] 　　#默认根据ASCII码排序

>>>li4=['b','ab','a']

>>>li4.sort()　　　　 #['a', 'ab', 'b']

>>>li4.sort(key=len) 　　 #['a', 'b', 'ab']

>>>li4.sort(key=len,reverse=True) 　　#['ab', 'a', 'b']

(11)L.clear() 清空列表，类似于 del a[:]

#　　L.clear() -> None -- remove all items from L

(12)L.copy() 复制列表

#　　L.copy() -> list -- a shallow copy of

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

>>> li1=li.copy()

>>> li1　　#[1, 2, 3]

>>> id(li)　　#2561239466632

>>> id(li1)　　#2561239617672

#复制完后是两个对象，内容一样但是，地址不一样，这叫浅复制

内置函数：

sorted() 和 reversed()

#　　sorted函数可以直接获取列表的副本进行排序

>>>num=[5,8,1,3,6,]

>>>n=sorted(num)　　#[1,3,,5,6,8]

#sorted函数可以用于任何序列，返回结果都是一个列表

>>>sorted('python')　　#['h', 'n', 'o', 'p', 't', 'y']

#　　reversed函数，可以对一个序列进行反向迭代。这个函数并不会返回列表，而是返回一个迭代器对象，可以通过list函数把返回的对象转换为列表。

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

>>> reversed(num)　　　　#

>>>list(reversed(num))　　#[3,2,1]

2.元组的常用方法

(1)count()　　统计某个元素在元组中出现的次数。

#　　T.count(value) -> integer -- return number of occurrences of value　　记某一元素在元组中出现的次数返回一个整型

(2)index()　　从元组中找某个值第一个匹配项的索引位置。

#T.index(value, [start, [stop]]) -> integer -- return first index of value.Raises ValueError if the value is not present.　　用于从元组中找出某个值第一个匹配项的索引第一次出现的位置

内置函数：len(tuple),max(tuple),min(tuple)

3.字符串的常用方法

dir(str)

'''

'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum',

'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle',

'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition',

'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'

'''

(1)s.count(x)：返回字符串 x 在 s 中出现的次数，带可选参数

#　　S.count(sub[, start[, end]]) -> int　　[, start[, end]]代表可选参数，start为开始索引，end为结束索引

>>>s='asdfasdf'

>>>s.count('a')　　#2

(2)s.endswith(x)：如果字符串s以x结尾，返回True

#　　S.endswith(suffix[, start[, end]]) -> bool　　检测是否以某个字符串结束，可以指定范围，返回一个bool值

>>>s.endswith('f') #返回一个bool型，字符串是否以''结束 True

(3)s.startswith(x)：如果字符串s以x开头，返回True

#　　 S.startswith(prefix[, start[, end]]) -> bool　　检测是否以某个字符串开始，可以指定范围，返回一个bool值

>>>s.startswith('ff') #返回一个false

(4)s.find(x) ：返回字符串中出现x的最左端字符的索引值，如果不在则返回-1

#　　S.find(sub[, start[, end]]) -> int　　用于检测字符串中是否包含子字符串str，查找元素的索引位置，第一次出现的索引，找不到的话就返回-1，跟index()(会报错)不一样

>>> field='do it now'

>>> field.find('do')　　#0

>>> field.find(' ')　　#2

>>> field.find('now')　　#6

>>> field.find('python‘)　　#-1

>>> field.index('z') #报错

#如果找到就返回首个字符串的索引，没有找到就返回-1

(5)s.index(x)：返回字符串中出现x的最左端的索引值，如果不在则抛出valueError异常

#　　S.index(sub[, start[, end]]) -> int

>>> field='do it now'

>>> field.index('do')　　#0

>>> field.find('python‘)　　#SyntaxError: EOL while scanning string literal

(6)s.isalpha () ：测试是否全是字母，都是字母则返回 True,否则返回 False.

#　　S.isalpha() -> bool

>>>s.isalpha() 　　#测试是否全是字母

>>>s2='12321654'

>>>s2.isalpha() 　　 #False

>>>s2='aaaaaa我'

>>>s2.isalpha() 　　 #True

(7)s.isdigit () ：测试是否全是数字，都是数字则返回 True 否则返回 False.

#　　S.isdigit() -> bool

>>>s.isdigit()　　 #测试是否为全数字

>>>s3='-123'　　#负数被默认为字符串

>>>s.isdigit()　　 #False

>>>s3='123'

>>>s.isdigit() 　　 #True

(8)s.islower () ：测试是否全是小写

# 　　S.islower() -> bool

(9)s.isupper () ：测试是否全是大写

# 　　S.isupper() -> bool

(10)s.lower () ：将字符串转为小写

#　　S.lower() -> str　　有返回值的原对象没有变

>>> s='ASDASDaa'

>>> s.lower()　　#'asdasdaa'

(11)s.upper () ：将字符串转为大写

#　　S.upper() -> str　　有返回值的原对象没有变

>>> field='do it now'

>>> field.find('It')　　#-1

>>> fild.upper().find('It'.upper())

>>> field.upper().find('It'.upper())　　#3

如果想要在一个字符串中查找某个子字符串并忽略大小写，即字符串全部转换为大写后能找到对应子串

(12)s.replace (x,y) ：子串替换,在字符串s中出现字符串x的任意位置都用y进行替换

#　　S.replace(old, new[, count]) -> str　　把字符串中的old(旧字符串)替换成new(新字符串)，如果指定第3个参数count，替换次数就为max，替换从左到右

>>> field　　'do it now'

>>> field='do it now,do it now'

>>> field.replace('do','Just do')　　#'Just do it now,Just do it now'

>>> field.replace('do','Just do',1)　　#'Just do it now,do it now'

(13)s.split()：返回一系列用空格分割的字符串列表

#　　S.split(sep=None, maxsplit=-1) -> list of strings　　-1为全部切 sep,maxsplit为默认参数，sep是将要分割的字符串，maxsplit是说明最多要分割几个,返回一个列表

>>> field　　#'do it now,do it now'

>>> field.split()　　#['do', 'it', 'now,do', 'it', 'now']

>>>s='aaaa'

>>>s.split() 　　 #['aaaa'] 返回一个列表

>>> field.split('o',1)　　#['d', ' it now,do it now']

>>> field.split('o',2)　　#['d', ' it n', 'w,do it now']

(14)s.join()：将序列中的元素以指定字符连接成一个新字符串

#　　S.join(iterable) -> str

>>> field=['1','2','3','4']

>>> mark='+'

>>> mark.join(field)　　#'1+2+3+4'

>>> field.join(mark)　　#list没有join方法

Traceback (most recent call last):

File "", line 1, in

field.join(mark)

AttributeError: 'list' object has no attribute 'join'

>>> num=[1,2,3,4]

>>> mark.join(num)

Traceback (most recent call last):

File "", line 1, in

mark.join(num)

TypeError: sequence item 0: expected str instance, int found

#进行join操作调用和被调用的对象必须都是字符串，任意一个不是字符串的都会报错

(14)s.swapcase():用于对字符串的大小写字母进行转换，将字符串中大写转换为小写，小写转换成大写

#　　S.swapcase() -> str

>>> s1='adsfASD'

>>> s1.swapcase()　　#'ADSFasd'

(15)s.strip(): 用于移除字符串头尾指定的字符(默认为空格)

#　　S.strip([chars]) -> str

>>> field='----do --it-- now----'

>>> field.strip('-')　　#'do --it-- now'

(16)s.translate(): 根据参数table给出的表转换字符串的字符，将要过滤掉的字符放到del参数中

#　　S.translate(table) -> str

>>> intab='adfas'

>>> outtab='12345'

>>> trantab=str.maketrans(intab,outtab)

>>> st='just do it'

>>> st.translate(trantab)　　#'ju5t 2o it'

Python3字符串方法

1capitalize() 将字符串的第一个字符转换为大写

center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

count(str, beg= 0,end=len(string))返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

bytes.decode(encoding="utf-8", errors="strict")Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

encode(encoding='UTF-8',errors='strict')以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

endswith(suffix, beg=0, end=len(string))检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

find(str, beg=0 end=len(string))检测 str 是否包含在字符串中中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

index(str, beg=0, end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常.

isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

isalpha()如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False

isdigit()如果字符串只包含数字则返回 True 否则返回 False..

islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False

isspace()如果字符串中只包含空格，则返回 True，否则返回 False.

istitle()如果字符串是标题化的(见 title())则返回 True，否则返回 False

isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

join(seq)以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

len(string)返回字符串长度

ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

lower()转换字符串中所有大写字符为小写.

lstrip()截掉字符串左边的空格

maketrans()创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

max(str)返回字符串 str 中最大的字母。

min(str)返回字符串 str 中最小的字母。

replace(old, new[, max])把将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

rfind(str, beg=0,end=len(string))类似于 find()函数，不过是从右边开始查找.

rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始.

rjust(width[,, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串

rstrip()删除字符串字符串末尾的空格.

split(str="", num=string.count(str))num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串

splitlines([keepends])按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

startswith(str, beg=0,end=len(string))检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

strip([chars])在字符串上执行 lstrip()和 rstrip()

swapcase()将字符串中大写转换为小写，小写转换为大写

title()返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

translate(table, deletechars="")根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

upper()转换字符串中的小写字母为大写

zfill (width)返回长度为 width 的字符串，原字符串右对齐，前面填充0

isdecimal()检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

weixin_39990029

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python实验二序列_Python学习笔记二：02序列类型的各自方法

方法是与对象有紧密联系的函数，对象可能是列表、数字，也可能是字符串或其他类型的对象。调用语法如下：对象.方法()在python中，一切皆对象1.列表的常用方法>>>li=[1,2,3]>>>dir(li)　　 #查看方法和属性['__add__', '__class__', '__contains__', '__delattr__', '__delitem__...
复制链接

扫一扫