精华内容
下载资源
问答
  • None在列表末尾添加单个元素,任何类型都可以,包括列表或元组等2、L.extend(iterable) -> None以序列的形式,在列表末尾添加多个元素3、L.insert(index, object) -> None在index位置处添加一个元素4、L....

    列表list

    1、L.append(object) -> None

    在列表末尾添加单个元素,任何类型都可以,包括列表或元组等

    2、L.extend(iterable) -> None

    以序列的形式,在列表末尾添加多个元素

    3、L.insert(index, object) -> None

    在index位置处添加一个元素

    4、L.clear() -> None

    清除列表所有元素,成为空列表

    5、L.copy() -> list

    获得一个列表副本

    6、L.count(A) -> integer

    返回A在列表中出现的次数

    7、L.index(A, [start, [stop]])

    返回A在列表中第一次出现的位置,可以指定开始和结束位置  注意:[start,end)

    8、L.pop([index]) -> integer

    弹出对应位置的元素,不填参数,默认弹出最后一个元素

    9、L.remove(A) -> None

    删除第一个元素A,其余元素A不擅长

    10、L.sort(key=None, reverse=False) -> None

    对列表进行排序,默认是升序。如果reverse=True,则改为降序。可以给key参数传递一个函数,如lambda或事先定义好的。然后按照这个函数定义以什么为排序基础,      例如以最后一个数字为排序基础,或以下划线后的数字为排序基础等。

    此方法会改变列表排序

    11、L.reverse() -> None

    对列表进行降序

    此方法会改变列表排序

    元组tuple

    1、T.count(A) -> integer

    返回A在元祖中出现的次数

    2、T.index(A, [start, [stop]]) -> integer

    返回A在元祖中第一次出现的位置,可以指定开始和结束范围  注意:[start,end)

    集合set

    1、S.add(element) -> None

    添加一个元素到集合里

    2、S.clear() -> None

    清除集合所有元素

    3、S.copy() -> set

    返回原集合的副本

    4、S.remove(element) -> None

    移除集合中的一个元素,如果该元素不在集合中则报错

    5、S.discard(element) -> None

    同上,但如果该元素不在集合中不报错

    6、S.pop() -> element

    随机弹出一个原集合的元素

    7、S.isdisjoint(S2) -> bool

    如果两个集合没有交集,则返回True

    8、S.issubset(S2) -> bool

    如果S2(序列或者集合)集合包含S集合,则返回True

    9、S.issuperset(S2) -> bool

    如果S集合包含S2(序列或者集合)集合,则返回True

    10、S.difference_update(S2) -> None

    S减去S和S2(序列或者集合)的交集,不返回任何值,

    此方法会改变原集合S

    11、S.intersection_update(S2) -> None

    S和S2(序列或者集合)的交集,不返回任何值,

    此方法会改变原集合S

    12、S.symmetric_difference_update(S2) -> None

    S和S2的并集减去S和S2的交集,不返回任何值

    此方法会改变原集合S

    13、S.update(S2) -> None

    S和S2(序列或者集合)的并集,不返回任何值,

    此方法会改变原集合S

    14、S.intersection(S2) -> set

    返回S和S2(序列或者集合)的交集

    15、S.difference(S2) -> set

    返回S减去S和S2(序列或者集合)的交集

    16、S.symmetric_difference(S2) -> set

    返回S和S2的并集减去S和S2的交集,S2可以是序列或集合

    17、S.union(S2) -> set

    返回S和S2(序列或者集合)的并集

    字典dict

    1、D.clear() -> None

    清除字典中所有键值

    2、D.copy() -> D

    返回一个字典的副本

    3、D.pop(k[,d]) -> value

    弹出k键对应的值,并移除键值。如果k键没有被找到,但设置了d的值,则返回d的值。如果没设置的d值的话,又没找到k键,则报错。

    4、D.popitem() -> (k, v)

    以元祖的形式,弹出一个键值(弹出的一般是堆栈的第一个键值)

    5、D.keys() -> a set-like object

    已类似列表的形式返回所有键(其实返回的更像是类列表的对象,并不会对重复的值进行处理)

    6、D.values() -> a set-like object

    已类似列表的形式返回所有值(其实返回的更像是类列表的对象,并不会对重复的值进行处理)

    7、D.items() -> a set-like object

    已类似列表的形式返回所有键值,每个键值以元祖的形式返回(其实返回的更像是类列表的对象,并不会对重复的值进行处理)

    8、D.get(k[,d]) -> D[k] if k in D, else d.

    如果字典存在k键则返回对应的值,如果不存在,但填了d值则返回d值,否则返回空值

    9、D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

    如果字典存在k键则返回对应的值,如果不存在,但填了d值则在原字典中建立新的键值,并返回该值。但没有填d值的话,则设在k键对应为空值。

    10、D.update(D2) -> None

    D2也是字典。将D2的键值合并到D中,如果存在相同的键,则D2覆盖D

    此方法会改变原字典D

    11、D.fromkeys(iterable, value=None) -> dict

    此方法用于创建字典。以可迭代的对象的所有元素作为键,value作为唯一的值。返回一个多键对单一值的字典(不论D是不是空字典结果都是一样的)

    字符串str

    1、S.capitalize() -> str

    将首字母转换成大写,需要注意的是如果首字没有大写形式,则返回原字符串

    2、S.upper() -> str

    将原字符串中所有的字母大写

    3、S.lower() -> str

    将原字符串中所有的字母小写(只能完成ASCII码中的A-Z)

    4、S.casefold() -> str

    将原字符串中所有的字母小写(能识别更多的对象将其输出位小写)

    5、S.swapcase() -> str

    将原字符串中存在的字母大小写互换

    6、S.replace(old, new[, count]) -> str

    替换字符。count参数代表替换几次old字符。如果不填count参数,默认替换所有的old字符

    7、S.expandtabs(tabsize=8) -> str

    将字符串中所有制表符(\t)替换为空格,替换空格数默认为7(8-1,其中tabsize=0表示去掉\t,tabsize=1或2都表示一个空格,其余为n-1个空格)

    8、S.rjust(width[, fillchar]) -> str

    如果原字符长度不足width,则剩余部分,在左边补齐空格。如果有填充单字符,则用字符代替空格。(注意:只能是单字符)

    9、S.ljust(width[, fillchar]) -> str

    同上。不过是在右边填充。

    10、S.center(width[, fillchar]) -> str

    同上。不过左右两边同时填。多出的部分填在右边

    11、S.zfill(width) -> str

    如果原字符长度不足width,则剩余部分,在左边补齐0

    12、S.find(sub[, start[, end]]) -> int

    返回子字符串在原字符串中第一次出现的位置,可以指定开始和结束位置。如果子字符串不在原字符串中则返回-1  注意:[start,end)

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

    同上,不过如果子字符串不在原字符串中则报错    注意:[start,end)

    14、S.rindex(sub[, start[, end]]) -> int

    同index,不过是从字符串右到左,不过返回的是子字符串最左边的第一个字符位置

    15、S.rfind(sub[, start[, end]]) -> int

    同find,不过是从字符串右到左,不过返回的是子字符串最左边的第一个字符位置

    16、S.split(sep=None, maxsplit=-1) -> list of strings

    返回一个以sep作为分隔符得到的列表。maxsplit代表分隔几次,默认为全分隔

    17、S.rsplit(sep=None, maxsplit=-1) -> list of strings

    同上。不过是从右至左

    18、S.splitlines([keepends]) -> list of strings

    返回一个按换行符作为分隔符得到的列表。默认keepends为False,表示得到的列表,列表的元素都去掉了换行符。如果改为True则保留换行符

    19、S.partition(sep) -> (head, sep, tail)

    此方法用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符,则返回一个3元的元组。第一个为分隔符左边的子串,第二个为分隔符本身,第三个为分隔符右边的子串。

    如果不包含指定的分隔符,则第一个为原字符串,第二三个为空字符

    20、S.rpartition(sep) -> (head, sep, tail)

    同上,但是从右至左,且如果不包含指定的分隔符,则第一二个为空字符,第二个为原字符串

    21、strip([chars]) -> str

    默认返回一个去掉左右两边空格的字符串。如果参数写了子字符,则去掉左右两边所有的子字符

    22、S.rstrip([chars]) -> str

    同上,但是只去掉右边的字符

    23、S.lstrip([chars]) -> str

    同上,但是只去掉左边的字符

    24、S.startswith(prefix[, start[, end]]) -> bool

    判断字符串是否以某字符串开头,如果是,则True。可以指定开始和结束位置

    25、S.endswith(suffix[, start[, end]]) -> bool

    同上,不过判断的是结尾

    26、S.count(sub[, start[, end]]) -> int

    返回子字符串在原字符串中出现的次数。可以指定开始和结束位置

    27、S.join(iterable) -> str

    将原字符填充到序列的元素之间

    28、S.encode(encoding='utf-8', errors='strict') -> bytes

    编码,errors参数可选很多,其中有’ignore’

    29、S.isidentifier() -> bool

    是否为Python的关键字等,如果是为True

    30、S.isalnum() -> bool

    是否字符串全是由数字、英文或汉字组成(包括罗马数字等),如果是为True

    31、S.isdecimal() -> bool

    是否字符串只含有10进制数字

    True:Unicode数字,全角数字(双字节)

    False:罗马数字,汉字数字

    Error:byte数字(单字节)

    32、S.isnumeric() -> bool

    是否字符串只含有数字

    True:Unicode数字,全角数字(双字节),罗马数字,汉字数字

    False:无

    Error:byte数字(单字节)

    33、S.isdigit() -> bool

    是否字符串只含有数字

    True:Unicode数字,byte数字(单字节),全角数字(双字节),罗马数字

    False:汉字数字

    Error:无

    34、S.isspace() -> bool

    是否字符串只含有空格(空格,制表符,换行符),如果是为True

    35、S.isalpha() -> bool

    是否字符串只含有字母,如果是为True

    36、S.islower() -> bool

    是否字符串中所有的字母都是小写(可以含非字母的字符),如果是为True

    37、S.isupper() -> bool

    如果原字符串中的字母(可以包含其他内容,如数字)全为大写,返回True

    38、S.isprintable() -> bool

    是否字符串中所有字符是可见状态(例如\n不可见),如果是为True

    39、S.istitle() -> bool

    是否字符中每个单词的首写字母都大写了(字符中除字母外,只允许有空格和正常的标点符号),如果是为True

    40、S.maketrans(x, y=None, z=None) -> dict

    41、S.translate(table) -> str

    参考上面语句(这里的table指的是字典映射表)

    42、S.format_map(mapping) -> str

    注意:键不能为纯数字

    43、S.title() -> str

    字符中每个单词的首写字母都大写(允许各种字符在中间隔断)

    展开全文
  • I have a string returnd from a software like "('mono')" from that I needed to convert string to tuple .that I was thinking using ast.literal_eval("('mono')") but it is saying malformed string....

    I have a string returnd from a software like "('mono')" from that I needed to convert string to tuple .

    that I was thinking using ast.literal_eval("('mono')") but it is saying malformed string.

    解决方案

    Since you want tuples, you must expect lists of more than element in some cases. Unfortunately you don't give examples beyond the trivial (mono), so we have to guess. Here's my guess:

    "(mono)"

    "(two,elements)"

    "(even,more,elements)"

    If all your data looks like this, turn it into a list by splitting the string (minus the surrounding parens), then call the tuple constructor. Works even in the single-element case:

    assert data[0] == "(" and data[-1] == ")"

    elements = data[1:-1].split(",")

    mytuple = tuple(elements)

    Or in one step: elements = tuple(data[1:-1].split(",")).

    If your data doesn't look like my examples, edit your question to provide more details.

    展开全文
  • #-*-coding:utf-8-*-#1、字典dict = {'name': 'Zara','age': 7,'class': 'First'}#字典转为字符串,返回: {'age': 7,'name': 'Zara','class': 'First'}print type(str(dict)),str(dict)#字典可以转为元组...

    废话不多说了,直接给大家贴代码了,代码写的不好还去各位大侠见谅。

    #-*-coding:utf-8-*-

    #1、字典

    dict = {'name': 'Zara','age': 7,'class': 'First'}

    #字典转为字符串,返回: {'age': 7,'name': 'Zara','class': 'First'}

    print type(str(dict)),str(dict)

    #字典可以转为元组,返回:('age','name','class')

    print tuple(dict)

    #字典可以转为元组,返回:(7,'Zara','First')

    print tuple(dict.values())

    #字典转为列表,返回:['age','class']

    print list(dict)

    #字典转为列表

    print dict.values

    #2、元组

    tup=(1,2,3,4,5)

    #元组转为字符串,返回:(1,5)

    print tup.__str__()

    #元组转为列表,返回:[1,5]

    print list(tup)

    #元组不可以转为字典

    #3、列表

    nums=[1,5,7,8,13,20];

    #列表转为字符串,返回:[1,20]

    print str(nums)

    #列表转为元组,返回:(1,20)

    print tuple(nums)

    #列表不可以转为字典

    #4、字符串

    #字符串转为元组,返回:(1,3)

    print tuple(eval("(1,3)"))

    #字符串转为列表,返回:[1,3]

    print list(eval("(1,3)"))

    #字符串转为字典,返回:

    print type(eval("{'name':'ljq','age':24}"))

    总结

    如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给程序员好友。

    本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。

    如您喜欢交流学习经验,点击链接加入交流1群:1065694478(已满)交流2群:163560250

    展开全文
  • 一、python数据类型介绍python基本数据类型:数字、字符...可变不可变分类可变:列表、字典不可变:数字、字符串元组、布尔2.访问顺序分类直接访问:数字、布尔顺序访问:字符串、列表、元组映射方式:字典,...

    一、python数据类型介绍

    python基本数据类型:数字、字符串、布尔、列表、元组、字典,可通过type(变量名)来查看变量的类型

    可变和不可变数据类型:修改变量的值后,变量在内存中存放的位置是否发生变化,可通过id(变量名)查看变量指向内存中的位置

    1.按可变不可变分类

    可变:列表、字典

    不可变:数字、字符串、元组、布尔

    2.按访问顺序分类

    直接访问:数字、布尔

    顺序访问:字符串、列表、元组

    映射方式:字典,字典的查找速度比列表快但占的内存比列表多

    3.按存放元素数分类

    容器类型:列表、元组、字典

    原子类型:数字、字符串、布尔

    二、字符串

    1.用单引号或双引号括起来,也可以单引号和双引号组合使用;

    2.字符串支持与字符串的加法,即两个字符串的拼接;字符串支持与数字的乘法,表示字符串共出现次数;

    3.字符串可通过下标索引的方式取子串,下标从0开始,v[m:n]表示取字符串下标为m到n-1的子串。

    [root@oldboy test]#cat str.py

    v1='abc'v2="def"v3='"ghi"'v4="'jkl'"

    print(v1,v2,v3,v4)print(v2+v3+v4,v1*5)print(v3[0:3])

    [root@oldboy test]#python str.py

    abc def "ghi" 'jkl'

    def"ghi"'jkl'abcabcabcabcabc"gh

    4.字符串在内存中一旦创建就不会被修改,如果要修改字符串的内容,则修改后的字符串存放在另外一个新的空间。

    5.字符串的函数

    假设a=’ aLex’

    (1)v1=a.casefole()  将字符串变小写,能转换除字母之外的对应关系

    (2)v2=a.lower()/a.upper()  将字符串变小写、大写

    (3)v3=a.center(n[,’*’])  设置宽度为n,a居中,空白处用*(限一个字符)填充

    (4)v3=a.ljust(n,’str’)  左对齐填充,一共n位,不足的从右使用str进行填充

    (5)v3=a.rjust(n,’str’)  右对齐填充,一共n位,不足的从左使用str进行填充

    (6)v3=a.zfill(n)  右对齐填充,使用0从左填充至n位

    (7)v4=a.count(‘str’,[n[,m]])  计算在第n和m个字符之间str出现的次数 (包含n但不包含m,以下都是)

    (8)v5=a.endswith(‘str’,[,n[,m]])  判断是否以str结束

    (9)v6=a.startswith(‘str’ [,n[,m]])  判断是否以str开始

    (10)v7=a.find(‘str’ [,n[,m]]),返回第一次找到str的位置,未找到返回-1

    (11)v8=a.index('str'),返回第一次找到str的位置,未找到报错

    (12)v9=a.lstrip()、a.rstrip()、a.strip()  去掉左边(包括\t、\n)、右边、左右两边的空格

    (13)v9=a.lstrip(‘str’)、a.rstrip(str’)、a.strip(str’)   移除指定字符,优先最多匹配

    (14)v10=a.partition(‘str’)、 rpartition(‘str’)  以第一个出现的str为分隔符分为三份,前面一份、str一份,余下一份---结果为元组

    (15)v11=a.split(‘str’[,n])、rsplit(‘str’[,n])  以str进行分割,分割后str不出现,n表示分割n次,无表示一直分割---结果为列表

    (16)v12=a.aplitlines(true/false)   以换行符分割,true/false表示保留、去除换行符

    (17)v13=a.swapcase()   将大写变小写、小写变大写

    (18)len(a)  求字符长度,python2中一个汉字长度为3,python3中一个汉字长度为1

    (19)v14=a.replace(‘str1’,’str2’[,n]), 将要处理字符串中的str1替换为str2,n表示替换前n个,无n全部替换

    a.isalnum() 判断是否是字母(含汉字)和数字

    a.isalpha() 判断是否是字母(含汉字)

    a.isdecimal() 判断是否是整数数字(不能识别类似③之类的特殊表示)

    a.isdigit() 判断是否是整数数字(能识别类似③之类的特殊表示)

    a.isnumeric()判断是否是整数数字(能识别汉字)

    a.isidentifier() 判断是否是标识符(即包含字母、数字和下划线且不以数字开头)

    a.islower() 、isupper()判断是否全部小写、大写

    a.ipprintable() 判断是否全部为可见字符(即不包含\t、\n等转义字符)

    a.isspace() 判断是否全部为空格

    a.title() 将字符串转换为标题,即每个单词的首字母大写

    a.capitalize()首字母大写

    a.istitle() 判断是否为标题

    format

    test=’I am {name},age {age}’

    v=test.format(name=’alex’,age=23)

    (或者test=’I am {0},age {1}’,v=test.format(’alex’,23) )

    则test=’I am alex,age 23’

    format_map

    v=test.format_map(‘name’:’alex’,’age’:23)

    test=’1234/t567890’

    v=test.expandtabs(n),每n个字符进行分割,在n个之中遇到tab(/t),则用空格补全到n位,单独遇到tab则显示n个空格

    join 将指定的字符与要处理的字符串的每个字符进行拼接

    test=’abcdefg’

    t=’#’

    v=t.join(test)

    三、列表

    1.通过中括号[ ]括起来,用逗号分隔每个元素,元素可以是数字、字符串、布尔值、列表、元组、字典、集合

    2.列表有序(体现在每次打印结果都一样),因此可通过下标索引的方式取元素,下标从0开始(如果从最后开始取下表从-1开始)。

    li[m:n]表示取字符串下标为m到n-1(m,n>0)的子列表,如果m为负数,n省略,如li[-3:]表示取列表最后3个元素

    t = a[1::3]表示从第一个元素开始,步长为3即隔2个取一个,例如a = 'abcdefg23456789hijkmn',a[1::3],结果为be258im

    3.列表可增加、删除和修改元素

    4.要获取列表通过函数处理后的值,需要先调用函数再获取新的值,例如定义了li,不能直接print(li.sort()),会返回None,应该是li.sort(),print(li)

    5.列表的函数

    例如定义列表li=[2,’hello’,’hi’,10,[8,9],False]

    通过索引删除 del li[3],表示删除元素10

    通过切片修改 li[1:3]=[‘HELLO’,’HI’]

    通过in判断是否存在某一元素 ‘False’ in li表示真

    以上取子列表中的9,方法为li[4][1]

    li.append(元素)  表示在原list最后追加一个元素

    li.extend(元素)  在原list最后追加一个元素,与append的区别是,append将参数元素作为整体追加,extend会将参数元素迭代追加

    li.insert(位置,元素)  在指定索引位置插入元素

    li.remove(元素)  删除列表中第一次出现的指定元素

    li.reverse()  将列表反转

    li.sort([reverse=True])  排序,默认升序排序,元素全部为数字或者字母时可排序,python3中字母和数字都存在时无法排序

    li.clear()  清空列表

    v=li.copy()  浅拷贝

    v=li.count(元素)  统计指定元素在列表中出现的次数

    v=li.index(元素[,m[,n]])  查找参数元素在列表出现的位置

    v=li.pop([位置])  删除指定位置的元素(默认最后一个),v获取被删除的元素

    s=str(list[]),将列表转换为字符串

    li=list(‘hihiugtfit’),将字符串转化为列表,会将字符串的每个字符拆作为列表的一个元素

    将列表转化为字符串,如果列表都是字符串,可直接通过空字符join,既有数字又有字符串则需要循环去每个元素再强制转化和字符串相加

    [root@oldboy list]#cat change.py

    s='1qa45x'

    print(s,'\n','s转换为列表:',list(s))

    li=['1','q','a','45','x']print(li,'\n','li转换为字符串:',''.join(li))

    li1=[1,'q','a',45,'x']print(li)

    v=''

    for item inli1 :

    v=v+str(item)print('li1转换为字符串为:',v)

    [root@oldboy list]#python change.py

    1qa45x

    s转换为列表: ['1', 'q', 'a', '4', '5', 'x']

    ['1', 'q', 'a', '45', 'x']

    li转换为字符串: 1qa45x

    ['1', 'q', 'a', '45', 'x']

    li1转换为字符串为: 1qa45x

    对于列表,如果定义了li2=li1,那么li2与li1指向了同一块内存地址,修改li2与li1修改的是相同地址块中的内容;而如果li2=li1[:],通过切片后li2就会重新开辟一块内存地址。

    四、元组

    元组tuple,有序,一级元素不可增加、删除或修改元素,如果嵌套列表再嵌套,可修改列表嵌套的元素

    通过括号括起来,逗号分隔每个元素,建议在最后一个元素后面也加一个逗号,便于与函数的参数区分

    可通过索引、切片查看

    v=tu.count(元素)统计指定元素在列表中出现的次数

    v=tu.index(元素[,m[,n]])查找参数元素在列表出现的位置

    五、字典

    字典dict,无序,通过key获取值如果key不存在会报错

    通过大括号括起来,逗号分隔键值对

    dic={‘k1’:12,’k2’:’hello’ ,k3:[1,’hi’] }

    列表、字典不能作为字典的key

    如果定义的key有重复,则print时只显示一个键值对

    v=dic[‘k2’]=hello

    对字典的循环,默认循环所有key,也可指定循环key、value或键值对

    循环key:for item in dic、for k in dic.keys()

    循环value:for v in dic.values()

    循环key和value:for k,v in dic.items()

    dic.clear()表示清空列表

    dic.copy()浅拷贝

    静态函数dict.fromkeys(列表或元组[,值]),根据序列创建字典,给定的序列为key,不指定值则value为none,指定值则所有key都为这个值

    dic.get(key[,’str’])通过key获取对应value,key不存在默认返回none,或者返回指定的字符串

    v=dic.pop(key),print(dic,v)删除指定key对应的键值对,v获取删除的value

    v=dic.popitem(key),print(dic,v)随机删除一个键值对,v获取删除的键值对

    v=dic.default(key,value)如果指定key存在,不设置并获取当前key对应的value,不存在则设置该key的value为指定value,并获取该value

    dic.update({k1:v2,k2:v2})或者dic.update(k1=v1,k2=v2),更新字典,如果指定的key在原字典中存在,则更新value为对应的指定value,不存在则将该键值对加入

    对字典按照key排序:dic=sorted(dic.items(),key=lambda x:x[0])

    对字典按照值排序:dic=sorted(dic.items(),key=lambda x:x[1])

    >>> dic = {'a': 5, 'c': 3, 'b': 4}>>> sorted(dic.items(),key=lambdax:x[0])

    [('a', 5), ('b', 4), ('c', 3)]>>> sorted(dic.items(),key=lambda x:x[1])

    [('c', 3), ('b', 4), ('a', 5)]

    六、集合

    通过大括号括起来,用逗号分隔元素,特点

    1.由不同元素组成,如果定义时存在相同元素,处理时会自动去重

    2.无序

    3.元素只能是不可变类型,即数字、字符串、布尔和元组,但集合本身可变

    4.可直接定义集合s={不同元素},或者s=set(可迭代对象),通过这两种方式定义的集合是可变类型

    也可以通过s=frozenset(可迭代对象)定义集合,通过这种方法定义的集合不可变,即不可增加、删除和修改元素

    >>> s={1,'a','b','a',5,1}>>>s

    {1, 'b', 'a', 5}>>> s=set((1,8,2,'r',2))>>>s

    {8, 1, 2, 'r'}

    5.集合的交、并、差、交叉补集

    交集,取两个集合相同的元素:s1.intersection(s2),或者s1&s2

    并集,将两个集合的所有元素合并并去重:s1.union(s2),或者s1|s2

    差集,其中一个集合减去两个集合的交集:s1.defference(s2),或者s1-s2

    交叉补集,两个集合的并集,减去两个集合的交集:s1.symmetric.difference(s2),或者s1^s2

    [root@oldboy set]#cat set.py

    p={'hello','nice'}

    s={'hi','nice'}print('p',p)print('s',s)print('p&s',p.intersection(s))print('p|s',p.union(s))print('p-s',p.difference(s))print('s-p',s.difference(p))print('p^s',p.symmetric_difference(s))

    [root@oldboy set]#python set.py

    p {'hello', 'nice'}

    s {'nice', 'hi'}

    p&s {'nice'}

    p|s {'hi', 'hello', 'nice'}

    p-s {'hello'}

    s-p {'hi'}

    p^s {'hello', 'hi'}

    6.集合的函数

    s.add('元素')  添加一个元素,将元素作为一个整体添加,添加已经存在的元素不会报错

    s.update(多个元素/可迭代对象),添加多个元素,将可迭代对象迭代添加

    s.clear( )  清空集合

    s.copy( )  拷贝集合

    s.pop( )  随机删除一个元素(列表默认是删除最后一个元素)

    s.remove('元素')  删除指定元素,如果集合中不存在该元素会报错

    s.discard('元素')   删除指定元素,如果集合中不存在该元素不会报错

    s.intersection_update(s1),求集合s与集合s1的交集并将结果再赋值给集合s

    s.difference_update(s1),求集合s与集合s1的差集并将结果再赋值给集合s

    s.symmetric_difference_update(s1),求集合s与集合s1的交叉补集并将结果再赋值给集合s

    s.isdisjoint(s1),判断两个集合是否有交集,有交集则返回False,无交集则返回True

    s.issubset(s1),判断是否是子集,如果集合s是集合s1的子集则返回True,否则返回False

    s.issuperset(s1),判断是否是父集,如果集合s是集合s1的父集则返回True,否则返回False

    python range()函数

    v=range(n),表示创建的范围是0-(n-1)

    v=range(m,n,a),表示创建的范围为m-(n-1),步长为a

    在python3中,序列刚创建时,每一个单个的值并没有在内存中存在,进行循环时才会在内存中一个一个创建,而在python2中,序列刚创建时就在内存中存在

    [root@oldboy test]# catrange.py

    v1=range(10)for item inv1:

    print(item,end=' ')

    print('')

    v2=range(0,10,2)for item inv2:

    print(item,end=' ')

    print('')

    [root@oldboy test]# python range.py0 1 2 3 4 5 6 7 8 9

    0 2 4 6 8

    展开全文
  • 字符串:双引号或者单引号中的数据就是 字符串 下标:python中下标从0开始 切片:[起始:结束:步长] 如name = “abcdef” print(name[0:3])# 取下标0~2的字符 结束(取结束值的前一位)结果为(abc) print(name...
  • 3,split 由字符串分割成列表,默认空格。4,captalize 首字母大写,其他字母小写。5,upper 全大写。6,lower 全小写。7,title,每个单词的首字母大写。8,startswith 判断以什么为开头,可以切片,整体概念。9...
  • 序列:字符串、列表、元组。有一些Python的类型,它的成员是有序排列的,且可以通过下标偏移量访问它的一个或几个成员,这类Python类型统称为序列。
  • # 字符串的格式化 tool='Python' Version=3.7 Str1="学习 %s,版本:%s"%(tool,Version)+",{}年{}月{}日".format(datetime.date.today().year,datetime.date.today().month,datetime.date.today().day) Str2="From ...
  • 字符串 python中双引号或者单引号中的数据,就是字符串 字符串输出 name='kenny' profession='engineer' address='guangzhou' print('姓名:%s'%name) print('职业:%s'%profession) print('地址:%s'%address) 字符串...
  • 字符串1.1 创建和赋值1.2 字符串的基本特性1.2.1 连接操作符和重复操作符1.2.2 成员操作符1.2.3 正向索引和反向索引1.2.4 切片1.2.5 可迭代对象/for循环1.2.6 练习- - -回文字符串1.3 字符串的内建方法1.3.1 字符串...
  • #是否存在不可显示的字符 #\t 制表符 #\n 换行 test6="wertwet\twe" v6=test6.isprintable() print(v6) 》》False isspace()#判断字符串内是否全是空格 istitle()#判断字符串是否是标题(所有单词首字母大写) title...
  • Python字符串在Python中,万物皆对象,显然字符串是对象类型,用str表示。字符串类型通常用单引号或者双引号包裹起来。>>> "Hello,world"'Hello,world'>>> 'Hello,world''Hello,world'>>>...
  • 文章目录一、字符串 str,有序序列(支持下标)不可变1.1 字符串的定义1.2 字符串的常用操作1) 判断类型 - 92) 查找和替换 - 73) 大小写转换 - 54) 文本对齐 - 35) 去除空白字符 - 36) 拆分和连接 - 51.3 字符串的...
  • 字符串、列表、元组、字典、集合 字符串字符串的本质是:字符序列 特点:Python 的字符串是不可变的,且Python 不支持单字符类型,单字符也是作为一个字符串使用的 字符串的编码: Unicode 编码; 使用内置函数...
  • 字符串以常量的形式存储在内存中,在向变量赋值时仅将字符串常量的地址赋给相应变量,当用此变量赋值给其他变量时,仅将地址赋值给新变量(使用三引号声明的字符串会单独的常量池中开辟空间,因此若同一字符串使用三引号...
  • python字符串,列表,元组,字典的基本操作 字符串 1.1字符串的输出 name = 'qxt' position = 'student' qq="110120119" wx="qxtzmr" school="清华北大" address = '江西赣州' print('----------------------------...
  • 字符串,列表,元组,range对象 序列对象可迭代:能遍历该对象内部元素 共性内容 1.索引: 序列由多个成员构成,每个成员称为元素,每个元素可以通过索引(index)进行访问 [] 对于有N 个元素的序列来说,...
  • 获得字符串每个单词首字母大写的拷贝 print(str1.title()) # Hello, World! 获得字符串变大写后的拷贝 print(str1.upper()) # HELLO, WORLD! 从字符串中查找子串所在位置 print(str1.find('or')) # 8 print(str1....
  • input(“输入:”):用户输入自己内容的入口 变量保存 的是字符串 二、数据类型 python的数据类型 列表(list) 元组(tuple)字典(dict)集合(set)复数(complex) 三、进制及进制转换 a=98 b=0b10110100 #0b...
  • 壹、字符串 一、字符串的基本操作 可用双引号和单引号将字符写在里面,并且将其赋值给某个值 Q=‘么么哒’ Python中的转义字符 二、字符串格式化 字符串格式化使用操作符百分号(%)实现 >>>print...
  • 三引号字符串 三引号形式的字符串⽀持换⾏。 a = ''' i am Tom, nice to meet you! ''' b = """ i am Rose, nice to meet you! """ 下标 从0开始 name = "abcdef" print(name[1]) #b print(name[0]) #a print...
  • 字符串str:单引号,双引号,三引号引起来的字符信息。 数组array:存储同种数据类型的数据结构。[1, 2, 3], [1.1, 2.2, 3.3] 列表list:增强了的数组, 可以存储不同数据类型的数据结构。 [1, 1.1, 2.1, 'hello'] ...
  • 文章目录字符串字符串类型使用%占位符格式化字符串使用format()函数格式化字符串使用f-string来格式化字符串字符串操作list和tuplelistlist操作函数tuple字典类型字典类型操作方法集合类型集合操作集合运算 字符串 ...
  • 至于为什么你的代码不能工作,主要的问题是你在字符串上循环,这会给你字符,而不是单词。不过,这不是解决问题的好办法。 还值得一提的是,当循环遍历值并希望索引与它们一起使用时,应该使用the ^{} builtin,而...
  • 本节要介绍的是Python里面常用的几种数据结构。通常情况下,声明一个变量只保存一个值...2.3.1字符串字符串是Python中最常用的数据类型。我们可以使用引号('或")来创建字符串。创建字符串很简单,只要为变量分配一个...
  • Python基础之day03-字符串,列表,元组,字典 文章目录Python基础之day03-字符串,列表,元组,字典一、字符串二、下标与字符串切片三、列表四、元祖五、字典六、公用方法 代码仓库地址: ...
  • 字符串%s的常见操作,str 1.find( ) 查找 例:print(name.find(“w”)) 返回元素下标 4 如果存在,返回元素下标,否则返回-1,从左往右查找 2.rfind( ) 从右往左查找 3.index( ) 注:列表里查找只能使用它 也...
  • 1.字符串的操作与方法 1.1字符串取值 根据索引取值(下标) 语法格式:字符串名[索引值] 使用场景:取单个字符时使用 # 案例:分别获取字符串runoob的第一个字符和最后一个字符 # 正序最大的索引值是:[0,len...
  • python高级数据类型(python可以处理类型有数字、字符串、列表、元组、字典等) Contents 字符串及常用方法 列表及常用方法 元组 字典及常用方法 共有操作 序列:在python中,序列是一组按照顺序排列的值...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,268
精华内容 9,707
关键字:

字符串按单词转元组