python基本数据类型

运算符

（1）“+”，两个对象相加

（2）“-”，两个对象相减

（3）“*”、两个对象相乘

（4）“/”，两个对象相除

（5）“%”，相除返回商的余数

（6）“//”,返回商的整数部分

（7）“**”，返回x的y次方幂结果

比较运算

(1)"="，等于，用于比较两个对象是否相等

（2）“>”,大于，用于比较大于号左边的对象是否大于右边的对象

（3）“<”,小于，用于比较小于号左边的对象是否小于右边的对象

（4）“！=”，不等于，用于比较两个对象是否不相等

（5）“<>”,不等于，同！=

（6）“>=”,大于等于，用于比较左边对象是否大于等于右边对象

（7）“<=”小于等于，用于比较左边对象是否小于等于右边对象

布尔值>>>>bool

（1）True：表示结果成立，为真,用“1”表示

（2）False:表示结果不成立，为假，用“0”表示

     注意：以下（None ，""，  () ，[] ，{} ，0 ）用bool判定都为False

逻辑运算

（1）“和”》》》》》用"and"表示，and两边条件都成立则返回true,只有一个成立或两个都不成立则返回False

（2）“或”》》》》》用“or”表示,or两边两件至少有一边条件成立则返回True

      注意：and 与or运算没有先后顺序，在python中遵循从左往右的顺序做判断，如果有括号，括号里的运算优先

（3）“in”》》》》表示在，  a in b,表示a在b里

（4）"not in">>>>>表示不在，a not in b,表示a不在b里

 

基本数据类型

（1）数字>>>>int类型

      注意：数字不可进行迭代

1.int(x, base=10)表示将X字符串转换为十进制数字表示

     

?
1
2
3
num=a
v=int(num,base=16)#int(x, base=10)表示将X字符串转换为十进制数字表示
print(v)#>>>>>11

　　

2.bit_length(self)表示当前数字用二进制表示需要多少位数

?
1
2
3
num=11
v=num.bit_length()   #bit_length(self)表示当前数字用二进制表示需要多少位数
print(v)>>>>#4

（2）字符串》》》》》str类型

#######字符串一旦创建，不可修改

#######可以迭代，有序

字符串用法：

 1.capitalize(self)表示将字符串首字母变大写

?
1
2
3
4
n1="aaabbbccc"
n2="apple"
v=n1.capitalize()#capitalize(self)表示将字符串首字母变大写
print(v)>>>>>>#Aaabbbccc

 2.casefold(self)表示将字符串中的大写字母全部转换为小写

?
1
2
3
4
n1 = "aaabBBccc"
n2 = "apple"
v=n1.casefold()#casefold(self)表示将字符串中的大写字母全部转换为小写
print(v)#》》》》》aaabbbccc

3.center表示设置宽度，并将内容居中

?
1
2
3
4
n1 = "aaabBBccc"
n2 = "apple"
v=n1.center(20,"*")#center表示设置宽度，并将内容居中,20代表字符串总位数，*表示空位用它表示
print(v)#>>>>>>*****aaabBBccc******

4.　count表示统计字符串中有多少子序列

?
1
2
3
4
n1 = "aaabBBccc"
n2 = "apple"
v=n1.count("a",1,7)#count表示统计字符串中有多少子序列，后面参数表示起始位置与结束位置
print(v)#>>>>>2

5.endswith表示以什么结尾，参数表示起始位置与结束位置，若存在,返回true,否则返回false

  同理，startswith表示以什么开始

?
1
2
3
4
n1 = "aaabBBccc"
n2 = "apple"
v=n1.endswith("c",1,8)#endswith表示以什么结尾，参数表示起始位置与结束位置,若存在,返回true,否则返回false
print(v)#>>>>True

6.find表示字符串从开始往后找，找到第一个之后，获取其位置，参数表示起始位置与结束位置，若没找到返回“-1”

?
1
2
3
4
n1 = "aaabBBccc"
n2 = "apple"
v=n1.find("b",1,7)#find表示字符串从开始往后找，找到第一个之后，获取其位置，参数表示起始位置与结束位置，若没找到返回“-1”
print(v)#>>>>>>3

7.index表示字符串从开始往后找，找到第一个之后，获取其位置，参数表示起始位置与结束位置，若没找到会报错

?
1
2
3
4
n1 = "aaabBBccc"
n2 = "apple"
v=n1.index("b",1,8)#index表示字符串从开始往后找，找到第一个之后，获取其位置，参数表示起始位置与结束位置，若没找到会报错
print(v)#>>>>>>3

8.format表示格式化，将将一个字符串中的占位符替换为指定的值

?
1
2
3
test = 'i am {name}, age {a}'
v = test.format(name='alex',a=19)#format表示格式化，将将一个字符串中的占位符替换为指定的值
print(v)#>>>>>i am alex, age 19
?
1
2
3
test = 'i am {0}, age {1}'
v = test.format('alex',19)#用下标也可替换为指定的值
print(v)#>>>>>>>i am alex, age 19

9.format_map表示格式化，将指定的值替换为字符串中的占位符

?
1
2
3
test = 'i am {name}, age {a}'
v2 = test.format_map({"name": 'alex', "a": 19})#format_map表示格式化，将指定的值替换为字符串中的占位符
print(v2)#>>>>>>i am alex, age 19

10.isalnum表示字符串中是否只含有字母和数字或汉字，若结果为真则返回True,否则False

?
1
2
3
test = "123"
v = test.isalnum()#isalnum表示字符串中是否只含有字母和数字或汉字，若结果为真则返回True,否则False
print(v)#>>>>>>True

11.isalpha判断字符串中是否只含有字母

?
1
2
3
n1="aaa"
v=n1.isalpha()#isalpha判断字符串中是否只含有字母
print(v)#>>>>>>>True

12.isdecimal判断当前输入字符串是否是数字

    isdigit判断字符串是否为二进制数字及特殊符号表示的数字，但不能识别文字形式数字

    isnumeric判断字符串是否为数字，可以识别各种形式表示的数字

?
1
2
3
4
5
6
7
8
9
n1="二"
n2="2②"
n3="2②二"
v1=n1.isdecimal()#isdecimal判断当前输入字符串是否是数字,只能判断是否是十进制形式数字
v2=n2.isdigit()#isdigit判断字符串是否为二进制数字及特殊符号表示的数字，但不能识别文字形式数字
v3=n3.isnumeric()#isnumeric判断字符串是否为数字，可以识别各种形式表示的数字
print(v1)#>>>>>>>>False
print(v2)#>>>>>>>True
print(v3)#>>>>>>>>True

　　

13.isprintable判断是否存在不可显示的字符，若存在返回False,否则True,("\n"为换行符，“\t”为制表，都为不可显示字符）

?
1
2
3
n1="fjkajfk\nafkfj"
v1=n1.isprintable()#isprintable判断是否存在不可显示的字符，若存在返回False,否则True
print(v1)#》》》》False

14.isspace判断是否全是空格

?
1
2
3
n1="   "
v1=n1.isspace()#isspace判断是否全是空格
print(v1)#>>>>>>>True

15.istitle判断是否是标题，即每个子序列是否是大写字母开头

    title将字符串转换成标题，即每个子序列都是大写字母开头 

?
1
2
3
4
5
n1="Afjkdjf ejfiejf mkejfkejfk"
v1=n1.istitle()#istitle判断是否是标题，即每个子序列是否是大写字母开头
v2=n1.title()#title将字符串转换成标题，即每个子序列都是大写字母开头
print(v1)#》》》》False
print(v2)#》》》》Afjkdjf Ejfiejf Mkejfkejfk

16.join将字符串中的每一个元素按照指定分隔符进行拼接

?
1
2
3
n1="今天是星期几"
v1="*".join(n1)#join将字符串中的每一个元素按照指定分隔符进行拼接
print(v1)#>>>>>>今*天*是*星*期*几

17.islower判断字符串是否都是小写

    lower将字符串全转换成小写

    isupper判断字符串是否全为大写

    upper将字符串全部转换成大写

?
1
2
3
4
5
6
7
test = "Apple"
v1 = test.islower()#islower判断字符串是否都是小写
v2 = test.lower()#lower将字符串全转换成小写
print(v1, v2)#>>>>>>>>>False apple
v1 = test.isupper()#isupper判断字符串是否全为大写
v2 = test.upper()#upper将字符串全部转换成大写
print(v1,v2)#》》》False APPLE

　　

18.lstrip从左边移除指定字符串，有限最多匹配,可以移除空白

    rstrip从右边移除指定字符串，有限最多匹配

    strip从两边边移除指定字符串，有限最多匹配

?
1
2
3
4
5
6
7
test = "aexxxxaxa"
v1= test.lstrip('xa')#lstrip从左边移除指定字符串，有限最多匹配
v2 = test.rstrip('axx')#lstrip从右边移除指定字符串，有限最多匹配
v3 = test.strip('xa')#lstrip从两边边移除指定字符串，有限最多匹配
print(v1)#》》》》》exxxxaxa
print(v2)#>>>>ae
print(v3)#》》》》》e

19.maketrans创建对应关系　　

?
1
2
3
4
v = "asidufkasd;fiuadkf;adfkjalsdjf"
m = str.maketrans("aeiou", "12345")#maketrans创建对应关系
new_v = v.translate(m)
print(new_v)

20.partition从左边以指定字符将字符串分割三部分

    rpartition从右边以指定字符将字符串分割三部分

?
1
2
3
4
5
test = "testasdsddfg"
v = test.partition('s')#partition从左边以指定字符将字符串分割三部分
print(v)#》》》》》('te', 's', 'tasdsddfg')
v = test.rpartition('s')#rpartition从右边以指定字符将字符串分割三部分
print(v)#》》》》》('testasd', 's', 'ddfg')

21.split以指定字符将字符串从左往右分割为几部分，输出结果不包含分割字符，为列表形式

    rsplit以指定字符将整个字符串分割，不包含分割字符

?
1
2
3
4
5
test = "testasdsddfg"
v = test.split('s',2)#split以指定字符将字符串从左往右分割为几部分，输出结果不包含分割字符，为列表形式
print(v)#>>>>>['te', 'ta', 'dsddfg']
v2=test.rsplit("s")#rsplit以指定字符将整个字符串分割，不包含分割字符
print(v2)#》》》》》['te', 'ta', 'd', 'ddfg']

22.splitlines分割，只能根据，true，false：是否保留换行

?
1
2
3
test = "asdfadfasdf\nasdfasdf\nadfasdf"
v = test.splitlines(False)#splitlines分割，只能根据，true，false：是否保留换行
print(v)#>>>>>['asdfadfasdf', 'asdfasdf', 'adfasdf']

23.swapcase大小写转换

?
1
2
3
test = "appLE"
v = test.swapcase()#swapcase大小写转换
print(v)#>>>>>APPle

24.isidentifier判断字符串是否以字母、下划线开头

?
1
2
3
a = "a_ajajf"
v = a.isidentifier()#isidentifier判断字符串是否以字母、下划线开头
print(v)#>>>>True

25.replace表示将指定字符串替换，参数表示要替换的数量，默认从左往右全部替换，参数表示需要替换的数量

?
1
2
3
test = "appleppal"
v = test.replace("pp",'www')#replace表示将指定字符串替换，参数表示要替换的数量，默认从左往右全部替换，参数表示需要替换的数量
print(v)#>>>>>awwwlewwwal

26.expandtabs表示断句，以参数为宽度从头到尾开始断句，遇到"\t"则空格补全一段宽度，没有出现"\t"则继续开始下一段

?
1
2
3
n1="ajkajkajk\tjkjqiqjijqi"
v=n1.expandtabs(13)#expandtabs表示断句，以参数为宽度从头到尾开始断句，遇到"\t"则空格补全一段宽度，没有出现"\t"则继续开始下一段
print(v)#》》》》》》ajkajkajk    jkjqiqjijqi，结果说明后一段j前面一段长度为13，k后用空格补全

(3)列表》》》》》list

######列表用[]表示，里面的每个元素用",'隔开,列表创建完可以进行修改，列表元素在内存中以链表形式存在

######列表中的元素可以是 数字，字符串,列表，布尔值..所有的都能放进去

######列表有序，元素可以被修改，删除，增加

列表用法：

（1）循环  for

?
1
2
3
4
li = ["a","faaaa",11132,["jfakjfkalj","jfkjfk",454545],44444]
for i in li:
    print(i)#循环输出列表中每一个元素
print(li[2:3] )#切片输出的结果是列表

（2)　索引取值，对象.[下标]

（3）索引修改，对象.[下标]=新值

(3)索引删除  del.对象[下标]

(4)切片取值，对象.[下标：下标]

（5）切片删除，对象.[下标：下标]

（6）切片修改，对象.[下标：下标]=[新值，新值]

  in用法v="a" in li#判断元素在不在列表里面，注意元素指用逗号隔开的整个元素

列表内置方法

（1）append追加，表示将值作为一个元素追加到列表最后一个元素后面

?
1
2
3
li = [11, 22, 33, 44, 55]
li.append(33)#append追加，表示将值作为一个元素追加到列表最后一个元素后面
print(li)#》》》》》[11, 22, 33, 44, 55, 33]

（2）clear清空列表

?
1
2
3
li = [11, 22, 33, 44, 55]
li.clear()#clear清空列表
print(li)#》》》》》[]

（3）copy拷贝（浅拷贝）

?
1
2
3
li = [11, 22, 33, 44, 55]
v=li.copy()#copy拷贝（浅拷贝）
print(v)#>>>>>[11, 22, 33, 44, 55]

（4）count计算元素出现的次数

?
1
2
3
li = [11, 22, 33, 44,33,.55]
v=li.count(33)#count计算元素出现的次数
print(v)#>>>>>>>2

（5）extend拓展原列表，拓展元素必须可以迭代，且对象会以元素形式添加到原列表后面

?
1
2
3
li = [11, 22, 33, 44,33,.55]
li.extend("abcd")#extend拓展原列表，拓展元素必须可以迭代，且对象会以元素形式添加到原列表后面
print(li)#>>>>>>>>.[11, 22, 33, 44, 33, 0.55, 'a', 'b', 'c', 'd']

（6）index查找对象并输出对象在列表中的下标,从左边开始，参数代表起始位置与结束位置

?
1
2
3
li = [11, 22, 33, 44,33,.55]
v=li.index(33)#index查找对象并输出对象在列表中的下标,从左边开始，参数代表起始位置与结束位置
print(v)#>>>>>>>2

（7）insert在指定位置插入元素

?
1
2
3
li = [11, 22, 33, 44,33,.55]
li.insert(2,123)#insert在指定位置插入元素
print(li)#>>>>>>>>>[11, 22, 123, 33, 44, 33, 0.55]

（8）pop删除指定下标对应的元素，默认删除最后一个元素

?
1
2
3
li = [11, 22, 33, 44,33,.55]
li.pop(3)#pop删除指定下标对应的元素，默认删除最后一个元素
print(li)#>>>>>>>>>>[11, 22, 33, 44, 33]

（9）remove删除指定元素，从左边开始

?
1
2
3
li = [11, 22, 33, 44, 33, .55]
li.remove(33)#remove删除指定元素，从左边开始
print(li)#》》》》》》》[11, 22, 44, 33, 0.55]

（10）reverse反转列表

?
1
2
3
li = [11, 22, 33, 44, 33,55]
li.reverse()#reverse反转列表
print(li)#>>>>>>>>>>[55, 33, 44, 33, 22, 11]

（11）sort将列表排序，默认从小往大排，在参数位置加入reverse=True，列表将从大往小排

       注意，列表中各元素为同一类型时候才可以排序

?
1
2
3
li = [11, 22, 33, 44, 33,55]
li.sort()#sort将列表排序，默认从小往大排，在参数位置加入reverse=True，列表将从大往小排
print(li)#>>>>>>>>[11, 22, 33, 33, 44, 55]

(4)元组》》》》》tuple

#########元组由（）组成，各元素由“，”隔开，元素可以是数字，字符串，列表等

#########元组一经创建，一级元素不可修改，增加，删除

#########元组有序，可以迭代

#########元组也可通过索引查找其元素位置，，可切片

?
1
2
3
4
5
6
7
8
9
tu=(11,22,33,44,["aa",(11,"bb")],123,23)
tu[2]=12
print(tu)
tu[4][0]=11
print(tu)#>>>>>>>>>(11, 22, 33, 44, [11, (11, 'bb')], 123, 23)
tu[4][1]="abc"#元组中一级元素不可被修改、删除、添加
print(tu)#>>>>>>>(11, 22, 33, 44, ['aa', 'abc'], 123, 23)
tu[4][1][0]=123
print(tu)#元组中一级元素不可被修改、删除、添加

元组内置方法：

（1）count统计元组中指定元素的个数

?
1
2
3
tu=(11,22,33,44,["aa",(11,"bb")],22,123,23)
v=tu.count(22)#count统计元组中指定元素的个数
print(v)#>>>>>>>2

（2）index寻找指定元素的下标，参数表示起始位置与结束位置

?
1
2
3
tu=(11,22,33,44,["aa",(11,"bb")],22,123,23)
v=tu.index(22,0,-1)#index寻找指定元素的下标，参数表示起始位置与结束位置
print(v)#>>>>>>>>1

(5)字典》》》》》》dict

#########字典是无序的，支持增删改查，key:value一一对应，value可以是任意值，不能用列表,字典做key

#########字典可以迭代

字典内置方法：

（1）clear清空字典

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
dic.clear()#clear清空字典
print(dic)#>>>>{}

（2）copy浅拷贝字典

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
v=dic.copy()#copy浅拷贝字典
print(v)#>>>>{10: 'aaa', 3: '123', 6: {123: [], 222: (), 'abcd': {'a': 123}}}

（3）dict.fromkeys根据序列，创建指定的字典

?
1
2
v=dict.fromkeys([1111,22222])#dict.fromkeys根据序列，创建指定的字典
print(v)#>>>>{22222: None, 1111: None}

（4）get根据key找到对应的value

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
v=dic.get(3)#get根据key找到对应的value
print(v)#>>>>123

（5）keys通过for循环输出所有的key，根据Key获取值，key不存在时，可以指定默认值（None）

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
for i in dic.keys():#>>>>keys通过for循环输出所有的key
    print(i)#>>>>>10
3
6

（6）values通过for循环输出所有的values

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
for i in dic.values():#>>>>values通过for循环输出所有的values
    print(i)#>>>>>aaa
123
{123: [], 'abcd': {'a': 123}, 222: ()}

（7）items通过循环表示输出所有的key及其对应values

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
for i,v in dic.items():#>>>>items通过循环表示输出所有的key及其对应values
    print(i,v)#>>>>>10 aaa
3 123
6 {'abcd': {'a': 123}, 123: [], 222: ()}

（8）pop根据key删除指定的values，若字典中没有，则返回参数值

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
v=dic.pop(15,1111)#pop根据key删除指定的values，若字典中没有，则返回参数值
print(v)#>>>>>1111

（9）popitem随机删除字典中的一组值

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
v=dic.popitem()#popitem随机删除字典中的一组值
print(v)#>>>>>(10, 'aaa')

（10）设置值，已存在，不设置，获取当前key对应的值，不存在，设置，获取当前key对应的值

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
v=dic.setdefault(10,5555)#setdefault设置值，已存在，不设置，获取当前key对应的值，不存在，设置，获取当前key对应的值
print(v)#>>>>>aaa

（11）update,更新，若key已存在，则将values更换，若不存在，则将新组添加到字典中

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dic={
    3:"123",
    10:"aaa",
    6:{
        123:[],
        222:(),
        "abcd":{
            "a":123
        }
    }
}
dic.update({10:5555})#update,更新，若key已存在，则将values更换，若不存在，则将新组添加到字典中
print(dic)#>>>>>{10: 5555, 3: '123', 6: {123: [], 222: (), 'abcd': {'a': 123}}}

（6）集合》》》》set.

集合特点：是一个无序且不重复的元素集合，元素不可变

通过内置函数set可将对象转换为集合，会自动去重

1 s = {1,2,3,4,5,5,6,2,2,23}
2 s = set(s)#set将元素转换成集合，会自动去重
3 print(s)#{1, 2, 3, 4, 5, 6, 23}

集合内置函数

复制代码
s = {1,2,3,4,5,5,6,2,2,23}
s.add("abc")#添加元素到随机位置
print(s)#{1, 2, 3, 4, 5, 6, 23, 'abc'}
s.clear()#清空集合
print(s)#set()
s1 = s.copy()#拷贝集合
print(s1)#{1, 2, 3, 4, 5, 6, 'abc', 23}
s.pop()#随机删除元素
print(s)#{1, 2, 3, 4, 5, 6, 23}
s.remove(8)#指定元素删除，若不存在，会报错
print(s)
s.discard(8)#指定元素删除，若不存在不会报错
print(s)
复制代码
复制代码
print(s.union(s2))#union求两个集合并集，用“|"表示,即两个集合相加去重
print(s.intersection(s2))#intersection求两个集合交集，用“&”表示，即求两个集合共有部分
print(s.difference(s2))#difference求两个集合差集，用“-”表示，即求s中有的元素而s2中没有
print(s.symmetric_difference(s2))#symmetric_difference求交叉补集，即减去两个集合共有的元素，剩下的即为交叉补集
s.difference_update(s2)#difference_update差集更新
print(s.isdisjoint(s2))#isdisjoint判断是否有交集，如果没有交集，返回True，否则返回False"
print(s.issubset(s2))#issubset判断是否是子序列
print(s.issuperset(s2))#issuperset判断是否是父序列
s.symmetric_difference_update(s2)#对称差集，并更新到a中
复制代码

 

数据转换

字符串（str）、列表(list)、元组(tuple)、字典（dict）可通过for循环或者join等方法相互转换

(1)字符串与列表的转换

?
1
2
3
4
# 字符串转换列表   li =  list("asdfasdfasdf"), 内部使用for循环
s = "pouaskdfauspdfiajsdkfj"
new_li = list(s)
print(new_li)#>>>>>>>>>>['p', 'o', 'u', 'a', 's', 'k', 'd', 'f', 'a', 'u', 's', 'p', 'd', 'f', 'i', 'a', 'j', 's', 'd', 'k', 'f', 'j']

　列表转换成字符串

?
1
2
3
4
5
6
7
8
9
10
# 列表转换成字符串，
# 既有数字又有字符串,需要自己写for循环一个一个处理
li = [11,22,33,"123","alex"]
r = str(li)#如果列表中含数字元素，不能直接转换，会报错，因为数字不可迭代
print(r)#》》》》》》》报错<br>#############################################
li = [11,22,33,"123","alex"]
s = ""
for i in li:#通过for循环，先将列表中一个个元素单个转换成字符串，再进行字符串的叠加
    s = s + str(i)
print(s)#112233123alex<br>################################################## 列表中的元素只有字符串，直接使用字符串join方法<br>li = ["123","alex"]<br>v = "".join(li)<br>print(v)#》》》》》》》123alex

（2）字符串、元组、列表间的相互转换

字符串转换元组

?
1
2
3
4
字符串转换为元组
s = "asdfasdf0"
v = tuple(s)
print(v)#》》》》》》('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0')

　列表转换元组

?
1
2
3
li = ["asdf","asdfasdf"]
v = tuple(li)
print(v)#》》》》》》('asdf', 'asdfasdf')

　元组转换列表

?
1
2
3
tu = ("asdf","asdf")
v = list(tu)
print(v)#》》》》》》['asdf', 'asdf']

元组转换字符串

?
1
2
3
tu = ("asdf","asdf")
v = "_".join(tu)
print(v)#》》》》》》asdf_asdf

　　

　　

　

　



　　


　


　　


　　


　　


 


　　


　　


　　


　　


　　


　　


　


　　


　　


 


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


 


 


 


 


 


 


　


 


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


　　


 


　　


 






            

            
posted @ 
 
amchen 
阅读(357) 
评论(0) 
编辑 
收藏 
举报


        

	    
	    
    









    
    

    
    



    

        
    

        

            
                
                
            
        

    

编辑推荐：



· dotnet 源代码生成器分析器入门
    

· ASP.NET Core 模型验证消息的本地化新姿势
    

· 对象命名为何需要避免'-er'和'-or'后缀
    

· SQL Server如何跟踪自动统计信息更新?
    

· AI与.NET技术实操系列：使用Catalyst进行自然语言处理
    



    

    阅读排行：
    

 ·          dotnet 源代码生成器分析器入门
        

 ·          官方的 MCP C# SDK：csharp-sdk
        

 ·          一款 .NET 开源、功能强大的远程连接管理工具，支持 RDP、VNC、SSH 等多种主流协议！
        

 ·          一文搞懂MCP协议与Function Call的区别
        

 ·          一次Java后端服务间歇性响应慢的问题排查记录
        



    

    



	

	

	
	

	

	

	





    

    
    








  

  
点击右上角即可分享

  微信分享提示