请选择 进入手机版 | 继续访问电脑版
 找回密码
 立即注册
  • 便民服务
  • 关注我们
  • 社区新手

python索引、切片、列表、元组、字典、集合

[复制链接]
索引:
正向索引    0 1 2 3 4 5 6
反向索引   -7-6-5-4-3-2-1
切片:[起始索引位:结束索引位:步长值]
切片语法中:包含起始不包含结束位,步长值不能为0,可以为1(默认为1),1表示不隔位
st ="abcdefghjkl"
#print(st)
print(st[3])#d 截取当前索引值为3对应的值
print(st[-3])#j 截取当前索引值为-3对应的值
print(st[1:4])#bcd 从索引值为1开始取,到结束索引4,1-3有值
print(st[0:3])#abc 从索引值为0开始取,到结束索引3,0-2有值
print(st[2:-1])#cdefghjk
print(st[:-1])#abcdefghjk
print(st[2:])#cdefghjkl
print(st[1:6])#bcdef
print(st[1:6:3])#be
print(st[1:6:2])#bdf
print(st[::1])#abcdefghjkl 为空则取所有
print(st[::-1])#lkjhgfedcba 把字符串的值进行反向输出
print(st[-2:-5:-1])#kjh
print(st[-3:-6:-2])#jg
起始索引位和结束索引位控制取值范围,步长值控制取值的方向及隔位取值
字符串
字符串的定义用:单引号或者双引号
字符串的类型:str
a = 'sdfdsfdsf' #通过单引号定义一个字符串
print(type(a))#打印类型
对字符串中首字母改为大写
a = "helloword" #定义一个字符串
a1 = a.capitalize()#通过变量来接收参数,对当前字符串中首字母小写改变为大写
print(a1)#Helloword
或直接使用print(a.capitalize())#Helloword
统计字符串中具体元素出现的次数
a = "helloword" #定义一个字符串
a1= a.count("l")#通过变量来接收值
print(a1)#2
或直接使用print(a.count("l"))#2
join 拼接(把列表或一个字符串中的多个字符串拼接成一个)
a = "helloword" #定义一个字符串
print("".join(a))#helloword
l=['h','e','l','l','o','w','o','r','d']#定义一个列表
print(''.join(l))#helloword
split 分割
a = "hell,oword" #定义一个字符串
s=a.split(',')#把a字符串中的多余的元素分割,输出会变成一个列表,然后再使用join拼接
print(s)#['hell', 'oword']
print(type(s))#打印类型
print(''.join(s))#helloword
print(type(''.join(s)))#打印类型
删除字符
strip:删除字符串开头和结尾的元素
lstrip:删除字符开头的元素,不能删除结尾的
rstrip:删除字符串结尾的元素,不能删除开头的
a = "helloword" #定义一个字符串
print(a.strip('he'))#lloword
print(a.strip("rd"))#hellowo
print(a.lstrip('h'))#elloword
print(a.rstrip('d'))#hellow
判断字符以什么开头或结尾,返回的是布尔值
a = "helloword" #定义一个字符串
#startswith 判断是否以某某开头,是返回true 反之false
#endswith 判断是否以某某结尾,是返回true 反之false
print(a.startswith('he'))#True
print(a.startswith('e'))#False
print(a.endswith('rd'))#True
print(a.endswith('r'))#False
find: 获取指定值的索引值,从左开始
rfind:获取指定值的索引值,从右开始
a = "helloword" #定义一个字符串
print(a.find("o"))#4
print(a.rfind("o"))#6
replace 替换函数
a = "helloword" #定义一个字符串
print(a.replace('l','2'))#he22oword 默认替换指定值,所有
print(a.replace('l','3',1))#he3loword 把l换成3 数字1表示替换次数
print(a.replace("helloword",'小刘'))#把小刘 替换所有
print(a.replace(a,'xiaoliu'))#xiaoliu
把大写字母转换为小写
st='HELLOword'#定义一个字符串
print(st.lower())#helloword
把小写字母转换为大写
st='HELLOword'#定义一个字符串
print(st.upper())#HELLOWORD
判断是否全部为数字,返回布尔值 是返回true 反之false
st1='h123llo'#定义字符串
st2='12345'#定义字符串
print(st1.isdigit())#False
print(st2.isdigit())#True
判断是否全部为字母,返回布尔值 是返回true 反之false
st1='h12ee'
st2='12345'
st3='abAB'
print(st1.isalpha())#False
print(st2.isalpha())#False
print(st3.isalpha())#True
判断是否为全数字或全字母或数字加字母是返回true 反之false
st1='h12ee'
st2='12345'
st3='abAB'
st4='ab12@'
print(st1.isalnum())#True
print(st2.isalnum())#True
print(st3.isalnum())#True
print(st4.isalnum())#False
判断首字母是否为大写,其他无大写(注意:若字符串中有数字或特殊字符,则下一个大写字母默认当成一个新的字符串开始判断。例如:st7='Aasf123*A'   print(st7.istitle())#True
st1='A'
st2='AA'
st3='A123'
st4='Aasff'
st5='asd'
st6='A@33'
print(st1.istitle())#True
print(st2.istitle())#False
print(st3.istitle())#True
print(st4.istitle())#True
print(st5.istitle())#False
print(st6.istitle())#True
判断字符串全部为大写或者小写
isupper 判断全部为大写
islower 判断全部为小写
st1='sfsgfdj'#定义字符串
print(st1.isupper())#False 判断全部为大写
print(st1.islower())#True  判断全部为小写
st2 ='asaDEDE'#定义字符串
print(st2.isupper())#False 判断全部为大写
print(st2.islower())#False 判断全部为小写
st3='SDSFDFD'#定义字符串
print(st3.isupper())#True
print(st3.islower())#False
列表:[]中括号来定义,类型:list
list = ['123']#定义列表
print(type(list))#打印类型
print(list)#['123']
list1=list('123')#用函数定义一个列表
print(list1)#['1', '2', '3']
print(type(list1))#
st='hello'#定义字符串
print(type(st))#
c =list(st)#通过list函数把字符串变为列表
print(c)#['h', 'e', 'l', 'l', 'o']
print(type(c))#打印类型
list2=['hello',1,2,3,4,5,6]#定义列表
#列表中的每个元素都有一个索引
print(list2[0])#hello
print(list2[4])#4
python3中可以直接打印中文,python2中不可以直接打印
往列表中添加元素
list2=['hello',1,2,3,4,5,6]#定义列表
list2.append('xiaoliu')#添加元素
print(list2)#['hello', 1, 2, 3, 4, 5, 6, 'xiaoliu']
往列表指定索引位添加元素(.insert(索引值,插入值))
list2=['hello',1,2,3,4,5,6]#定义列表
list2.insert(4,'xiaoliu)
print(list2)#['hello', 1, 2, 3, 'xiaoliu', 4, 5, 6]
列表的拼接
list1=[1,2,3]#定义列表
list2=[4,5,6]#定义列表
list1.extend(list2)#
print(list1)#[1, 2, 3, 4, 5, 6]
获取列表中指定元素对应的索引值
list2=['hello',1,2,3,4,5,6]#定义列表
print(list2.index(4))#4
移除元素
list2=['hello',1,2,3,4,5,6,1]#定义列表
list2.remove(1)
print(list2)#['hello', 2, 3, 4, 5, 6, 1]
注:列表中有相同元素时,删除前面的元素
删除元素(索引值)
list2=['hello',1,2,3,4,5,6,1]#定义列表
del list2[7]#通过 del来删除索引值对应的数据
print(list2)#['hello', 1, 2, 3, 4, 5, 6]
排序(默认升序)
list =[5,3,2,4,1]
list.sort()#对当前这个列表进行升序排序
print(list)#[1, 2, 3, 4, 5]
降序排序:reverse=True,反之,reverse=False
print(sorted(list,reverse=True))#[5, 4, 3, 2, 1]
print(sorted(list,reverse=False))#[1, 2, 3, 4, 5]
列表元素反转输出
list =[5,3,2,4,1]#定义列表
list.reverse()#对列表进行反转
print(list)#[1, 4, 2, 3, 5]
st ='12345'#定义字符串
print(st[::-1])#对字符串的反转
pop 删除元素
list = [1,2,3,4,5]#定义列表
list.pop()#默认删除末尾的元素
print(list)#[1, 2, 3, 4]
查看删除的值
list2 = [1,2,3,4,5]#定义列表
print(list2.pop())#5 直接打印被删除的值
list3 = [1,2,3,4,5]#定义列表
list3.pop(0)#通过索引值删除对应的数据
print(list3)#[2, 3, 4, 5]

元组:()定义,类型tuple
元组是不可变的,定义好元组之后不能直接增删改元组中的元素,只能间接转化成其他数据类型,再进行修改。
如果元组中只有一个元素,一定要在后面加上一个逗号,如果不加,原始元素是什么类型它就打印成什么类型
列表和元组的区别:
1.类型不同 list tuple
2.定义不同 列表通过[]定义,元组通过()定义
3.列表定义是可以随意的增删改(元素不受保护)
4.元组定义是不可以随意的增删改(元素受保护)
元组也是支持切片操作的

对元组进行修改
t =(1,2,3,4,5,6)#定义元组
往元组中添加元素(通过list把元组转换为列表,再添加元素,再通过tuple转换成元组)
print(type(t))#
t1=list(t)#通过list把元组转换为列表
print(type(t1))#
t1.append(7)#往列表中插入元素
print(t1)#[1, 2, 3, 4, 5, 6, 7]
t2=tuple(t1)#把列表转换为元组
print(type(t2))#
print(t2)#(1, 2, 3, 4, 5, 6, 7)
#字符串转元组
s="hello"#定义字符串
print(type(s))#
print(tuple(s))#('h', 'e', 'l', 'l', 'o')
#元组转换字符串
t =(1,2,3,4,5,6)#定义元组
s1=t.str()
print(type(s1))#
print(s1)#(1, 2, 3, 4, 5, 6)

字典:定义{},类型:dict
字典中:键值对形式存储,键是唯一的,值可以不唯一
键值对用冒号分割,如:“name”:"zhangsan"。 多个键值对之间用逗号分割,如果键后面没值,则需要加‘’“
d ={}#定义空字典
print(type(d))#


d ={'name':"zhangsan"}#定义字典,里面有一个键值对
print(type(d))#
print(d)#{'name': 'zhangsan'}

d1 ={'name':''}#如果字典中没有值一定要加引号,
print(d1)#{'name': ''}

d={'name':'zhangsan','age':18}#定义字典,有多个键值对用逗号分隔
print(d)


t =('a',1)#定义元组
print(type(t))#
d=dict(t)#转换为字典
print(type(d))
print(d)#在单个元组的情况转换字典失败

t1 =[('a',1)]#定义列表
print(type(t1))#
d1=dict(t1)#转换为字典
print(type(d1))#
print(d1)#{'a': 1}

添加键值对
原字典中没有相同的键,则会把键值添加到字典中
d={'name':'zhangsan','age':18}#定义字典
d['score']=100#添加键值对
print(d)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d={'name':'zhangsan','age':18,'score':90}#定义字典
原字典中存有此键,执行替换
d['score']=100#设置键值对
print(d)


设置键值对
注:此方法执行后会进行判断,如果发现字典中没有此键则会把键值对设置到字典中,
如果原字典中有此键则不会执行替换
d1={'name':'zhangsan','age':18}#定义字典
d1.setdefault('score',100)#设置键值对
print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d2 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
d2.setdefault('score',98)#设置键值对
print(d2)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d2 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
key=d2.keys()#取出当前字典中所有键
print(key)#dict_keys(['name', 'age', 'score'])

#取值values
d3 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
value=d3.values()#取出当前字典中所有的值
print(value)#ict_values(['zhangsan', 18, 100])

#取指定键的值
d4 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
value1=d4['name']#获取name这个键对应的值
print(value1)#zhangsan


# d4 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
# del d4#删除整个字典
# print(d4)#抛异常,因为字典已被删除

#删除指定键和值
d5 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
del d5['score']#删除键和对应的值,返回剩余的键值对
print(d5)#{'name': 'zhangsan', 'age': 18}


字典遍历:for 变量名 in 字典名称
当前变量获取到的值为键,值不显示
d5 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for i in d5:
    #print(i)#name\age\score
    print(i,d5)#键和值一起显示

通过items函数获取键值对
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for k,v in d6.items(): #k代表键,v代表值
   print(k,v)#键和值一起显示

删除键返回对应键的值
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
# a=d6.pop('score')#删除score这个键并返回键对应的值
# print(a)#100
print(d6.pop('score'))

清空
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
d6.clear()#把这个字典中的所有键值清空掉
print(d6)#{}  返回空字典


获取指定键的值
#如果没有指定的键则返回none
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
a=d6.get("name")#获取name这个键对应的值
print(a)#zhangsan
print(d6.get("name"))#zhangsan
print(d6.get('a'))#None

给键指定值
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
#不指定值
print({}.fromkeys(['name','age',"score"]))#{'name': None, 'age': None, 'score': None}
#指定值
print({}.fromkeys(['name','age',"score"],'dcs16')) #{'name': 'dcs16', 'age': 'dcs16', 'score': 'dcs16'}

python2:has_key 函数检查字典是否有指定的键存在
python3:__contains__ 函数检查字典是否有指定的键存在
有存在返回true,反之返回false
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
print(d6.__contains__('name'))#True
print(d6.__contains__('a'))#False

删除字典中的键值对,并返回删除的数据(默认删除末尾)
d6 ={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
print(d6.popitem())#('score', 100)
print(d6.popitem())#('age', 18)

更新把两个字典拼接形成新的字典
d1={'name': 'zhangsan', 'age': 18}#定义字典
d2={'score': 100}#定义字典
d1.update(d2)
print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}
#存在相同的键,则执行替换
d3={'name': 'zhangsan', 'age': 18,'score': 98}#定义字典
d4={'score': 100}#定义字典
d3.update(d4)
print(d3)#{'name': 'zhangsan', 'age': 18, 'score': 100}

把两个列表设置为字典
a = ['a','b','c']#定义列表
c = [1,2,3]#定义列表
l=zip(a,c)#把两个列表拼接形成多个元组,索引值相同的为一个整体('a',1)
d=dict(l)#转换为字典
print(d)#{'a': 1, 'b': 2, 'c': 3}
print(type(d))#

集合
没有切片操作

可变集合 set
不可变集合 frozenset

区别:
相同点都能够进行去重
不同点:
可变集合去重后可以实现增删改
不可变集合去重后不可以进行增删改

分享至 : QQ空间
收藏

0 个回复

您需要登录后才可以回帖 登录 | 立即注册