• python之字符串,列表,字典,元组,集合内置方法总结

    目录

    数字类型的内置方法

    整型/浮点型

    加 +
    减 -
    乘 *
    除 /
    取余 %
    余数取整 //

    字符串类型的内置方法

    掌握 熟悉 了解
    按索引取值 ,strs[0] lstrip,rstrip find,rfind
    切片,str[::-1] lower,upper index,rindex
    长度,len[strs] startswith,endswith count
    成员运算,print{" 'llo' in strs"} rsplit center,ljust,rjust,zfill
    移除空白, strs.strip() join expandtabs
    切割,strs.split() replace captalize,swapcase,title
    循环,for i in strs: isdigit is

    掌握

    a = "Hello World"

    1. 按索引取值:

      print{a[0]}

# H

'''
	总结:
		1. 索引取值可以根据索引随时拿到字符串中任意一个字符.在工作中经常使用
'''

    2. 切片

      print{a[::-1]}
print(a[-1:-6:-1])

# dlroW olleH
# dlroW

'''
	总结:
		1. 切片不仅可以截取字符串中的任意一部分,同时也可以将字符串进行反转操作.
'''

    3. 长度,len()

      print(len(a))

# 11

'''
	总结:
		1. 经常会根据字符串的长度 获取对应索引.在工作中经常使用.
'''

    4. 成员运算,in/ not in

      print("ello" in a)

# True

    5. 移除空白,strip,lstrip,rstrip

      b = "  dajiahao!wo jiao panlifu "
print(b.strip())

# dajiahao!wo jiao panlifu    默认直接删除字符串两端的空白

print(b.strip(" adwuflinp"))
# jiahao!wo jiao      直接从两端进行删除,只要传参的字符串中包含b字符串两端的字符,即可删除,没有则停止

# lstrip 左移除
print(b.lstrip())
print(b.lstrip(" jadu"))

# dajiahao!wo jiao panlifu
# iahao!wo jiao panlifu 



# rstrip 右移除
print(b.rstrip())
print(b.rstrip(" aflui"))

#   dajiahao!wo jiao panlifu
#   dajiahao!wo jiao pan

    6. 切割, split,rsplit

      print(a.split(" ",1))
# ['Hello', 'World']

print(a.split("o",2))
print(a.split("o"))

# ['Hell', ' W', 'rld']
# ['Hell', ' W', 'rld']

# rsplit   右切割
print(a.rsplit())
# ['Hel', 'o Wor', 'd']

    7. for循环

      for i in a:
    print(i)

'''
H
e
l
l
o
 
W
o
r
l
d
'''

    熟悉

    1. 大小写, lower/upper

      print(a.lower())

# hello world

print(a.upper())

# HELLO WORLD

'''
	总结:
		1. 通常在输入验证码的时候,不区分大小写.可能就是将对应的字符串统一变成了大写或小写
'''

    2. 判断区间内的首字母是否相同, startswith,endswith

    print(a.startswith('r',0,len(a)))

# False

print(a.startswith('H',0,len(a)))

# True

print(a.endswith('e',0,len(a)))

# False


print(a.endswith('d',0,len(a)))

# True


'''
	总结:
		1. startswith,它可以判断区间内(顾头不顾尾)首字母是否为指定字符,返回bool值
		2. endswith,它可以判断区间内(顾头不顾尾)尾字母是否为指定字符,返回bool值
'''

    1. 连接,join

      test_list = ["etc","plf","lt","xs","cd"]
print("/".join(test_list))

# etc/plf/lt/xs/cd


print('/'.join(a))

# h/e/l/l/o/ /w/o/r/l/d


'''
	总结:
		1. 用来连接各个元素,一般用于路径的拼接
'''

    2. 替换replace

      print(a.replace("o","P"))

# HellP WPrld

'''
	总结:
		1. 将字符串中的字符替换成指定字符
'''

    3. 判断是否为数字isdigit

      print(a.isdigit())

# False

test_str = "123"
print(test_str.isdigit())

# True

'''
	总结:
		1. 判断字符串中是否全是数字
		2. 注意:
			当数字字符串中含有空格时,isdigit依然会返回True,因此我们使用数字时,一定要记得将空格替换掉!
'''

    了解

    1. 查找 find,rfind

      print(a.find("H"))

# 0

print(a.find("d"))

# 10

print(a.find("p"))

# -1

print(a.find("ell"))

# 1


'''
总结:
	1. 当传入对应字符时,返回对应字符的下标.如果没有对应字符,则返回-1
	2. 当传入字符串时,返回对应字符串第一个字符的下标.如果没有,则返回-1
'''

    2. index,rindex

      print(a.index("H"))

# 0

print(a.index("d"))

# 10

print(a.index("p"))

# 抛异常,程序中断

print(a.index("ell"))

# 1

'''
总结:
	1. 当传入对应字符时,返回对应字符的下标.如果没有对应字符,则抛异常
	2. 当传入字符串时,返回对应字符串第一个字符的下标.如果没有,则抛异常
	3. 与find相比,find的方式更加友好
'''

    3. count,字符串出现的次数

      print(a.count("o"))

# 2

    4. center,ljust,rjust,zfill

      # center 居中
print(a.center(30,"*"))

# *********Hello World**********


# ljust  居左
print(a.ljust(30,"*"))

# Hello World*******************


# rjust  居右
print(a.rjust(30,"*"))

# *******************Hello World


# zfill  默认以0填充
print(a.zfill(30))
# 0000000000000000000Hello World

    5. expandtabs, 设置制表符距离,默认为8

      print("aaa	bbb".expandtabs())

# aaa     bbb

print("aaa	bbb".expandtabs(4))

# aaa bbb

    6. capitalize,swapcase,title

      print(a.capitalize())

# Hello world

print(a.swapcase())

# hELLO wORLD


a = "hello world"
print(a.title())
# Hello World

    列表的内置方法

    作用：多个装备、多个爱好、多门课程、甚至是多个女朋友

    定义：[]内可以有多个任意类型的值，逗号分隔元素

    plf = ["name","age","sex","tank"]
print(plf)

    方法：

    增 删 改 查
    append(元素) del 列表 my_list[下标]="修改内容" in/not in
    extend(列表) pop() count(元素)
    insert(位置,"元素") remove("元素") index("元素")
    clear()

    存一个值or多个值： 多个值

    有序or无序： 有序

    可变or不可变：可变

    可变or不可变： 可变

    增

    1. 追加 , append

      a = ["plf","lt","xs","cd"]
a.append('www')
print(a)

# ['plf', 'lt', 'xs', 'cd', 'www']

    2. 增加列表

      a = ["plf","lt","xs","cd"]
b = ["ls","ww","zhy"]
a.extend(b)
print(a)

# ['plf', 'lt', 'xs', 'cd', 'ls', 'ww', 'zhy']

    3. 插入数据

      a = ["plf","lt","xs","cd"]
a.insert(1,"www")
print(a)

# ['plf', 'www', 'lt', 'xs', 'cd']

    删

    1. 删除列表

      a = ["plf","lt","xs","cd"]
a.insert(1,"www")
del a
print(a)


'''
NameError                                 Traceback (most recent call last)
<ipython-input-16-71b7731a4ef0> in <module>
      2 a.insert(1,"www")
      3 del a
----> 4 print(a)

NameError: name 'a' is not defined
'''

    2. pop()

      a = ["plf","lt","xs","cd"]
b = a.pop()
print("a的值%s
%s"%(a,b))


'''
a的值:['plf', 'lt', 'xs']
b的值:cd
'''

    3. remove("元素")

      a = ["lt","plf","lt","xs","cd","cd"]
a.remove("cd")
a.remove("lt")
print("a的值:%s"%(a))

'''
a的值:['plf', 'lt', 'xs', 'cd']
'''

    改

    1. 根据下标更改

      a = ["lt","plf","lt","xs","cd","cd"]
a[0] = "gunkai"
print("a的值:%s"%(a))

'''
a的值:['gunkai', 'plf', 'lt', 'xs', 'cd', 'cd']
'''

    查

    1. in/not in 是否在

      a = ["lt","plf","lt","xs","cd","cd"]
print(bool("xxxx" in  a))
print(bool("xxxx" not in  a))

'''
False
True
'''

    2. count(元素)，元素出现个数

      a = ["lt","plf","lt","xs","cd","cd"]
print(a.count("lt"))

'''
2
'''

    3. index("元素") ，索引

      a = ["lt","plf","lt","xs","cd","cd"]
print(a.index("lt"))

'''
0
'''

    列表的函数

    1. len()，长度

      a = ["lt","plf","lt","xs","cd","cd"]
print(len(a))

'''
6
'''

    2. max(list) ，返回列表元素最大值

      a = ["lt","plf","lt","xs","cd","cd"]
b = ["plf","zj","xn","lt"]
c = [1,200,3,4,5,6,7,8,9,100,111]
print(max(a))
print(max(b))
print(max(c))

'''
xs
zj
200
'''


# min(list)   同理,返回列表元素最小值

    3. list(seq)，强制类型转化

      a = "hello,world"
b = (1,2,3,4,5,6)
print(list(a))
print(list(b))


'''
['h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd']
[1, 2, 3, 4, 5, 6]
'''

'''
	总结：
		1. 可以强制类型转化

'''

    其他

    1. clear，清除

      name_list = ['nick', 'jason', 'tank', 'sean']
name_list.clear()

print(f"name_list: {name_list}")

'''
name_list: []
'''

    2. copy，拷贝/深拷贝

      name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list.copy(): {name_list.copy()}")


'''
name_list.copy(): ['nick', 'jason', 'tank', 'sean']
'''


'''
	总结：
		1. 复制一个与原列表相同的列表

'''

    3. reverse， 反转

      name_list = ['nick', 'jason', 'tank', 'sean']
name_list.reverse()

print(f"name_list: {name_list}")


'''
name_list: ['sean', 'tank', 'jason', 'nick']
'''


'''
	总结：
		1. 翻转排序 

'''

    4. sort，排序

      a = [2113,3123,4,31,115,17,82,123,55,21]
a.sort()
print(a)
a.sort(reverse=True)
print(a)
'''
[4, 17, 21, 31, 55, 82, 115, 123, 2113, 3123]
[3123, 2113, 123, 115, 82, 55, 31, 21, 17, 4]
'''



'''

		总结：
			1. sort()排序后，没有返回值。因此不能这样打印：print(info.sort())
			2. sort()方法中，可以添加翻转等操作

'''

    字典的内置方法

    作用：当列表存很多元素时，列表会显示很乱，所有有了字典

    定义方式：{} 内以逗号分隔开多个键值对 key:value的值，key一般为字符串,value可以为任意对象

    a_dict = {
    	'name':'PLF',
    	'age':20，
    	'height':165,
    	'hobby_list':["ch","pd",'watch']
         }

    方法：

    增 删 改 查
    info['键'] = 数据 del info["键"] = 要修改的元素 print(info["键"])
    update() pop() print(info.get("不存在的键"))
    fromkeys() popitem() for key,value in info.itmes()
    setdefault() keys(),values(),items()

    存一个值or多个值：多个值，且值为不可变类型

    有序or无序：无序

    增

    1. info['键'] = 数据

      a =  {"name":"plf","age":"20","sex":"nan"}
a["address"] = "Chinese"
print(a)

'''
{'name': 'plf', 'age': '20', 'sex': 'nan', 'address': 'Chinese'}
'''

    2. update()

      a =  {"name":"plf","age":"20","sex":"nan"}
b = {"address":"Chinese"}
a.update(b)
print(a)


'''
{'name': 'plf', 'age': '20', 'sex': 'nan', 'address': 'Chinese'}

'''

    3. fromkeys()

      c_dic = dict.fromkeys(['name','age','sex'],None)
print(c_dic)


'''
{'name': None, 'age': None, 'sex': None}
'''

    4. setdefault()

      # dic之setdefault()，有指定key不会改变值；无指定key则改变值
dic = {'a': 1, 'b': 2}

print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
print(f"dic: {dic}")
print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
print(f"dic: {dic}")

'''
dic.setdefault('a'): 1
dic: {'a': 1, 'b': 2}
dic.setdefault('c'): 3
dic: {'a': 1, 'b': 2, 'c': 3}
'''

    删

    1. del

      dic = {'a': 1, 'b': 2}
del dic['a']

print(dic)


del dic
print(dic)


'''
{'b': 2}

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-69-aded9265c051> in <module>
      4 print(dic)
      5 del dic
----> 6 print(dic)

NameError: name 'dic' is not defined


'''

    2. pop()

      # dic之删除pop()
dic = {'a': 1, 'b': 2}
dic.pop('a')  # 指定元素删除

print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")



'''
dic.pop('b'): 2
dic.get('a'): None

'''

    3. popitem()

      dic = {'a': 1, 'b': 2}

print(f"dic.popitem(): {dic.popitem()}")   # 随机删除一个元素，无法指定


'''
dic.popitem(): ('b', 2)

'''

    改

    1. 根据key修改value

      a = {"name":"plf","age":"24","sex":"boy"}
a["name"] = "cd"
print(a)

'''
{'name': 'cd', 'age': '24', 'sex': 'boy'}
'''

    元组的内置方法

    作用：类似于列表，只不过元祖只能取不能更改

    定义方式：() 内用逗号隔开任意数据类型的元素

    a = ("plf","lt","xs","cd")
print(a)


'''
('plf', 'lt', 'xs', 'cd')
'''

    方法：

    索引取值 info["key"]
    切片 info["key"]
    长度 len(info)
    成员运算 in 和 not in
    循环
    count
    index

    存储一个值 or 多个值：多个值

    有序 or 无序：有序

    可变 or 不可变：无

    集合类型内置方法

    1. 作用：存多个值，为了集合之间做运算

    2. 定义方式：

      s = set()
s = {1,2,3,4,5,1}

    3. 方法

      1. 优先掌握

        • 去重

          a = [5, 2, 5, 1, 4, 3, 4,1,0,2,3,8,9,9,9]
print(list(set(a))) #将去掉重复的项后，再重新转成list

'''
[0, 1, 2, 3, 4, 5, 8, 9]

'''

        • 并集

          a = {1,2,3}
b = {2,3,4}
c = a|b
print(c)

'''
{1, 2, 3, 4}
'''

        • 交集

          a = {1,2,3}
b = {2,3,4}
c = a&b
print(c)

'''
{2, 3}
'''

        • 差集

          a = {1,2,3}
b = {2,3,4}
print(a-b)
print(b-a)

'''
{1}
{4}
'''

        • 对称差集

          a = {1,2,3}
b = {2,3,4}
print(a^b)

'''
{1, 4}
'''

        • 父集 ( 判断 )

          a = {1,2,3}
b = {2,3,4}
print(a > b)
a = {1,2,3,4}
print(a > b)

'''
False
True
'''

        • 子集

          a = {1,2,3}
b = {2,3,4}
print(a < b)
a = {2,3}
print(a < b)


'''
False
True
'''

        • ==

          a = {1,2,3,4}
b = {1,2,3,4}
print(a == b)

a = {1,2,3}
print(a == b)

'''
True
False
'''

      2. 需要掌握

        • add 添加元素

          s = {1, 2, 'a'}
s.add(3)

print(s)


'''
{1, 2, 3, 'a'}

'''

        • difference_update 去除原集合中重复的元素

          pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)

print(f"pythoners.difference_update(linuxers): {pythoners}")


'''
pythoners.difference_update(linuxers): {'jason', 'sean', 'tank'}
'''

        • isdisjoint 集合没有共同的部分返回True，否则返回False

          pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)

print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")



'''
pythoners.isdisjoint(linuxers): False
'''

        • remove 值不存在会报错

          b = {1,2,3,4}
b.remove(4)
print(b)

b.remove(5)
print(b)

'''
{1, 2, 3}



KeyError                                  Traceback (most recent call last)
<ipython-input-84-af6d44ebcdf4> in <module>
      1 a = {1,2,3}
      2 b = {1,2,3,4}
----> 3 b.remove(5)
      4 print(b)

KeyError: 5

'''

        • discard # 不会报错

          s = {1, 2, 'a'}
# s.remove(3)  # 报错
s.discard(3)

print(s)


'''
{1, 2, 'a'}

'''

    4. 多个值 or 一个值：多个值

    5. 有序 or 无序：无序

    6. 可变 or 不可变：可变

    布尔类型

    作用：一般用于判断，除了0/None/空/False自带布尔值为False,其他的数据类型自带布尔值为True

    数据类型总结

    定律：

    id不变，值变，为可变类型。 id变，值变，为不可变类型

    一个值 多个值
    整型/浮点型/字符串 列表/元组/字典/集合
    有序 无序
    字符串/列表/元组 集合/字典
    可变 不可变
    列表/字典/集合 整型/浮点型/字符串
  • 相关阅读:
    SQL Server, Timeout expired.all pooled connections were in use and max pool size was reached
    javascript 事件调用顺序
    Best Practices for Speeding Up Your Web Site
    C语言程序设计 使用VC6绿色版
    破解SQL Prompt 3.9的几步操作
    Master page Path (MasterPage 路径)
    几个小型数据库的比较
    CSS+DIV 完美实现垂直居中的方法
    由Response.Redirect引发的"Thread was being aborted. "异常的处理方法
    Adsutil.vbs 在脚本攻击中的妙用
  • 原文地址：https://www.cnblogs.com/plf-Jack/p/10914294.html
Copyright © 2020-2023  润新知