python字符串、列表、元组、字典、集合

一、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()  去掉左边（包括 、 ）、右边、左右两边的空格

（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() 判断是否全部为可见字符（即不包含 、 等转义字符）

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,'
','s转换为列表:',list(s))
li=['1','q','a','45','x']
print(li,'
','li转换为字符串:',''.join(li))
li1=[1,'q','a',45,'x']
print(li)
v=''
for item in li1 :
    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=lambda x: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]# cat range.py 
v1=range(10)
for item in v1:
    print(item,end='  ')
print('')
v2=range(0,10,2)
for item in v2:
    print(item,end='  ')
print('')
[root@oldboy test]# python range.py 
0  1  2  3  4  5  6  7  8  9  
0  2  4  6  8