Python的基本类型(list,tuple)

Python的基本类型(list,tuple)

一列表:

　　1.列表是Python基础的数据类型之一,其他语言也有类似的数据类型,比如js中的数组,java中的数组等,它是以[]括起来

,每个元素用','隔开而且可以存各种数据类型.

name = [1,"哈哈",[1,8,0],("我","叫","元","组"),{"我","叫","字","典"}]

　　1.1列表相比于字符串,不仅可以存放不同的数据类型,而且可以存放大量数据,

　　　　32位python可以存放:536870912个元素

　　　　64位可以存放1152921504606846975个元素,而且列表是有序的(按照你保存的顺序),有索引,可以切片方便取值

　　1.2列表的索引和切片

　　　　列表和字符串一样也拥有索引:

name = ["麻花藤", "王剑林", "马芸", "周鸿医", "向华强"]
print (name[0])    #结果:麻花藤
print (name[1])    #结果:王剑林
print (name[2])    #结果:马芸

name[3] = "小强"  #列表是可发生改变的,和字符串不一样
print(name)          #结果:['麻花藤', '王剑林', '马芸', '小强', '向华强']


s[0]  = "小红花"
s[0]  = "玫瑰花" #TypeError: 'str' object does not support item assignment: 
    TypeError: 'str'对象不支持项分配
print (s0)

　　　　列表的切片:

name =  ["麻花藤", "王剑林", "马芸", "周鸿医", "向华强"]
print (name[1:3])    #王剑林,马芸
print (name[:4])    #"麻花藤", "王剑林", "马芸", "周鸿医"

添加步长:
print (name[3:5:2])   #结果: "周鸿医"
print (name[-5::-2])   #结果  "麻花藤"

倒着带步长
print (name[-1:-3:-2])  #结果: "向华强"

二.列表的增删改查

　　1.增,注意list和str不一样,list可以放生改变,所以可以直接在原来的进行操作

name =  ["麻花藤", "王剑林", "马芸", "周鸿医", "向华强"]
print (name)  #结果: ["麻花藤", "王剑林", "马芸", "周鸿医", "向华强"]
name.append("sb")
print(name)   #结果 ["麻花藤", "王剑林", "马芸", "周鸿医", "向华强","sb"]

lst = []
while True:
    content = input("请输入你要录入的员工信息, 输入Q退出:")
    if content.upper() == 'Q':
        break
    lst.append(content)
    print(lst)

time = ["麻花藤", "张德忠", "孔德福"]
time.inster(1,刘德华)  #在xxx之前插入
print (time)              #结果: ["麻花藤", "刘德华","张德忠", "孔德福"]

#迭代添加
man = ["小红","小吕","小花",苦海无涯]
man.extend(["麻花藤", "麻花不疼"])
print (man)   #结果:["小红","小吕","小花",苦海无涯,"麻花藤", "麻花不疼"]
man.extend("小花")  #结果:['小红', '小吕', '小花', '苦海无涯', '小', '蓝']

　　2.删除

　　pop,remove,clear,del

name =  ["麻花藤", "王剑林", "李嘉诚", "王富贵"]
print(name)   #结果:["麻花藤", "王剑林", "李嘉诚", "王富贵"]
n1 = name.pop()    #删除最后一个
print ("被删除的",n1) #结果:别删除的 王富贵
print (name)

name =  ["麻花藤", "王剑林", "李嘉诚", "王富贵"]

el = name.pop(2) # 删除2号元素
print(el)
print(nme)
lst.remove("麻花藤") # 删除指定元素
print(name)
# lst.remove("哈哈") # 删除不存在的元素会报错
# print(name)
lst.clear() # 清空列表
print(name)
# 切片删除
del lst[1:3]
print(name)

循环删除列表中的每一个元素:

li = [11, 22, 33, 44]
for e in li:
    li.remove(e)
print(li)
结果:
[22, 44]

分析原因是:

for的循环过程会有一个指针来记录当前循环的元素是哪一个,开始指针指的是索引0,然后取值到了第0个索引,紧接着删除第0个,这时候原来第一个成了第0个,然后指针向后移动一次,指向了第一个,这时候原来第一个索引的元素已变成0,也就不会被删除

使用del删除:

li = [11, 22, 33, 44]
for i in range(0, len(li)):
    del li[i]
print(li)

结果: 报错 # i= 0, 1, 2 删除的时候li[0] 被删除之后. 后面一个就变成了第0个. 
# 以此类推. 当i = 2的时候. list中只有一个元素. 但是这个时候删除的是第2个 肯定报错啊

发现循环删除都不行,不论是用del还是用remove都实现不了.

pop删除

for el in li:
li.pop() # pop也不⾏
    print(li)
结果:
[11, 22]

使用pop也是不行

只有这种方法可以删除内容

for i in range(0, len(li)): # 循环len(li)次, 然后从后往前删除
    li.pop()
print(li)

或者,用另一条记录来删除你要删除的内容

li = [11, 22, 33, 44]
del_li = []
for e in li:
    del_li.append(e)
for e in del_li:
    li.remove(e)
print(li)

注意:由于删除元素会导致的索引改变,所以容易出现问题,尽量不要在循环中直接删除元素,可以把要删除的元素添加到另一个集合中然后在批量删除.

dict中的fromkey(),可以帮我们通过list来创建dict

dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])
print(dic)
结果:
{'jay': ['周杰伦', '麻花藤'], 'JJ': ['周杰伦', '麻花藤']}

前面列表中的每一项都会作为key,后面列表中的内容作为value生成dict

dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])
print(dic)
dic.get("jay").append("胡大")
print(dic)
结果:
{'jay': ['周杰伦', '麻花藤', '胡⼤'], 'JJ': ['周杰伦', '麻花藤', '胡大']}

代码只是改了jay那个列表,但是由于jay和jj是同一个列表,所以前面的那个修改了,后面的也会修改

dict中的元素在迭代过程中上部允许删除的

dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
# 删除key中带有'k'的元素
for k in dic:
    if 'k' in k:
    del dic[k] # dictionary changed size during iteration, 在循环迭
代的时候不允许进⾏删除操作
print(dic)

需要把删除的元素先保存到一个list列表中,然后循环list,在删除

dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
dic_del_list = []
# 删除key中带有'k'的元素
for k in dic:
    if 'k' in k:
        dic_del_list.append(k)
for el in dic_del_list:
    del dic[el]
print(dic)

　　3.修改

　　索引切片修改

#修改
                 0    1     2    3     4    
name =  ["a", "b", "c", "d", "e"]
name[1] = "f" #把第一位b修改为f
print(name)
#切片修改
name[1:4:3] = ["我","爱"] #切片也是可以的的如果步长不是1那么修改的元素必须相等.
print (name)
lst[1:4] = ["小"] # 如果切片没有步长或者步长是1. 则不用关心个数
print(name)

　　4.查询,列表是一个可迭代对象,所以可以进行for循环

name =  ["a", "b", "c", "d", "e"]
for i in name:
    print(name)

　　5.其他操作

name =  ["a", "b", "c", "d", "e","e"]
n1 = name.count("e") #查询e出现的次数
print (n1)

name = [1, 11, 22, 2]
name.sort() # 排序. 默认升序
print(name)
想要一个新列表排序原列表不变:
name = [2,1,5,4,6,]
nametxt = sorted(name)
print(name)        #结果:[2,1,5,4,6]
print(nametxt)     #结果:[1,2,4,5,6]     
name.sort(reverse=True) # 降序
print(name)
name = ["太白", "太黑", "五色", "银王", "日天", "太白"]
print(name)
name.reverse()
print(name)
you = len(name) # 列表的长度
print(you)

三.列表的嵌套

　　采用降维操作,一层一层的看的看比较好

name = lst = [1, "太白", "wusir", ["马虎疼", ["可口可乐"], "王剑林"]]
# 找到wusir
print (name[2])
# 找到太白和wusir
print(name[1:3])
# 找到太白的白字
print(name[1][1])
# 将wusir拿到. 然后首字母大写. 再扔回去
s = name[2]
s = s.capitalize()
name[2] = s
print(name)
# 简写
name[2] = name[2].capitalize()
print(name)
# 把太白换成太黑
name[1] = name[1].replace("白", "黑")
print(name)
# 把马虎疼换成马化疼
name[3][0] = name[3][0].replace("虎", "化")
print(name[3][0])
name[3][1].append("雪碧")
print(name)

四.元祖和元祖的嵌套

　　元素:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据之一,用小括号包起来,里面可以放任何类型的数据,查询可以循环也可以切片也可以,但是不可以更改.

tu = (1, "太白", "李白", "太黑", "怎么黑")
print(tu)
print(tu[0])
print(tu[2])
print(tu[2:5]) # 切片之后还是元组
# for循环遍历元组
for el in tu:
 print(el)
# 尝试修改元组
# tu[1] = "马虎疼" # 报错 'tuple' object does not support item assignment
tu = (1, "哈哈", [], "呵呵")
# tu[2] = ["fdsaf"] # 这么改不行
tu[2].append("麻花藤") # 可以改了. 没报错
tu[2].append("王剑林")
print(tu)
关于不可变的:注意:这里元祖的不可变的意思是子元素不可变,而子元素的子元素是可变的,这取决于子元素是否是可变对象
元祖中如果只有一个元素,一定要加一个逗号,否则就不是元祖
tu = (1,) 
print(type(tu))
元祖也有count(),index(),len()等方法,可以测试使用
五.rang
rang可以帮我们获取一组数据,通过for循环能够获取到这些数据

for num in range(10):
    print(num)
for num in range(1, 10, 2):
    print(num)
for num in range(10, 1, -2): # 反着来, 和切片一样
    print(num)