python基础之 列表，元组，字典

other

help(str.strip) #查看是否有返回值以及返回值类型
[] :称为索引操做符

1.列表

列表相比字符串来讲能存储大量数据的python的基本数据类型，而且也拥有字符串的一些方法(索引，切片等等)

列表是以[]中括号组成，每一个元素以,逗号隔开的，容器型数据类型。

列表中的常见的方法
　　l1 =['kobe','james','t-mac','123',789,[123,'admin']]

　　索引
  　　  print(l1[1])
  　　  print(ret1,type(ret1))
   　　 print(l1[-1])

　　切片  顾头不顾腚
  　　  print(l1[:4])
   　　 print(l1[:5:2])

　　倒叙取值
  　　  print(l1[-1:-4:-1])

　　增长
   　　 l1.append('123')  #追加增长
    　　l1.insert(1,'123')  #在索引为1的位置插入
    　　l1.extend([123,'ab']) #迭代的而加入是：根据要添加的类型进行一次迭代以后，在添加到列表中。若是添加的时字符串，就分割以后，添加到列表。
　　　　　　　　　　　　　　　　　 #若是添加的是列表，就循环列表，在分别添加到要添加的列表中。和切片修改是同一个意思，说白了迭代增长的必须是可迭代的元素


　　删除
   　　 l1.pop(0)  #按照索引删除，会将删除的元素做为返回值返回
   　　 l1.remove('kobe')  #按照元素删除，不会返回被删数据
   　　 l1.clear()  #清空列表

　　del 删除
   　　 del l1[0]  #1.按照索引删除，默认删除最后一个
    　　del l1[2:5:2] #按照切片(能够加步长)删除
   　　 del l1[:]   或者del l1#删除整个列表

　　改   
  　　  l1[0] = "男神"  #按索引修改,l1[0]指的时位置，修改l1[0]这个位置的元素的值为男神，本意指的li[0]这个元素，可是放在等号左边就是表明位置，要接受新值
   　　 l1[:3] = [123,"1234565"]或者l1[:3] ="123456" #按切片范围修改，要添加的内容必须是可迭代元素，和迭代增长同样
    　　l1[1:4:2] = "12" #切片(加步长)：必须一一对应，改了几个就得写几个修改的值，不能多或少

　　查
   　　 按照索引(index)，按照切片（步长查询），列表没有find方法
    　　使用for循环

　　其余操做
   　　 len()：去长度 index():经过元素找索引，找到第一个就返回，找不到就报错
  　　  l1.sort() 从小到大排序#不会生成新的字符串 l1.sort(reverse=True) #从大到小
   　　 l1.reverse()翻转  #不会生成新的字符串
   other：
　　　　pop()：执行后惟一有返回值的

　　

 

 2.元组

python中基础数据类型之一，容器型数据类型，存储大量的数据。只读列表。
元组是()里面的元素以,隔开的数据类型。
其余语言中，没有元组的概念。元组是不能够进行修改的，只能查询。元组中存储的都是重要的数据，我的信息等等。 
元组练习
　　tu1 = (1,'kobe','123',[1,2,'mac',True])
　　print(tu1[0])    #能够索引
　　print(tu1[:3])   #能够切片
　　print(tu1[:4:2]) #能够根据步长切片

查：注意：元组只能查不能改， #根据索引和切片等进行查询或者#根据for循环
　　for item in tu1:
    　　print(item)

other
    del tul  print(tu1)  #删除元组
    print(len(tu1))  #查看元组长度
    print(tu1.count("123")) #查看包含字符个数
    print(tu1.index("kobe") #和列表，字符串中使用同样，查找元素的索引
 元组真的不能修改么？
    tul = ('123', True, 456, [123, 'jordan', '中文'])
    tul[3].append('123')
    print(tul)
    #:在元组中的元素的是可迭代对象的话，就能够改：儿子不能改，孙子可能改。

有意思的一个问题：
　　tu = (123,1,'123',True)
　　print(tu.index(True))  
　　#这个索引不该该是3么？ 由于True和false在内存中存储的是1和0，因此tu.index(True) =tu.index(1),打印这个至关于打印print(tu.index(1))的索引，元组中正好有1这个元素，因此打印1这个元素的索引

#坑
　(22) --->int类型，不加，都是元素自己
　(s)  --->字符串类型
 

3.range

range函数练习
    内置函数，python给你提供的一个功能。
    将range视为：可控制范围的数字列表。

#打印1-100
    for item in range(1,101):
        print(item)

#打印1-100奇数
    for item in range(1,100,2):
        print(item)

#打印1-100偶数
    for item in range(2,102,2):
        print(item)    

#打印10-1
for item in  range(10,0,-1):
    print(item, '', end='')

注意：
　　1.range()的起始位置默认为0 
　　2.python2中是一块儿所有生成，不用迭代出来，直接打印，python3中是先放在内存里面，等使用了再生成。(这也是python3比python2性能上高的一点)

 做业

# 使用循环查找一个字符串中指定字符的全部索引值， 保存在一个列表中,找出全部a的索引值
　　s = 'abcabcabc'
　　count = 0
　　l1=[]
　　for item in s:
    　　if item == 'a':
        　　l1.append(s.index('a',count,))  #主要是字符串索引能够经过起始位置和结束位置来查找
    　　else:
        　　pass
    　　count += 1
　　print (l1)

4.字典

为何要使用元组？
　　1.列表若是存储的数据较多的话，查询速度会比较慢
　　2.列表存储数据的关联性不强
　　字典的查找是根据键值的hash来对应的内存地址进行查找的，比二分法还会快一些

字典介绍:
　　python中惟一的映射类的数据，花括号{}括起来，他是以键值对形式存储，每一对键值对以,逗号分开！
　　dic = {'name': 'kobe', 'age': 18, 'sex': 'man'}

字典的特色:
　　1.字典是以键值对形式存储的，
　　　　键：不重复的,惟一的，键的数据类型必须是不可变的数据类型。(键惟一;指的是不管添加多少个相同的键，只有最后一个起做用，起到了覆盖的做用)
　　　　值：任意数据类型，对象。
　　2.字典能够存储大量的键值对数据，
　　3.python3.6以前：字典是无序的。python3.6以后，字典变成有序的。3.7之后确实从语法层面上变得有序了。(3.6中的有序是解释器的做用，不是python的源码特色)

字典的优势：
    1，字典存储大量的关系型数据。
    2，字典的查询速度很是快。
字典的缺点：
　　占用空间大

　　dic ={
　　　　　　'name':'kobe',
　　　　　　'age':40,
　　　　　　'hobby':'wife'
　　}

　　增长操做
　　　　1.有就修改，没有就添加,根据键值,不会报错
　　　　　　dic['agesdas1']=20

　　　　2.有就不变，没有就添加，根据键值，不会报错
　　　　　　dic.setdefault('h') #默认添加None，默认返回键h的值，有返回值
　　　　　　dic.setdefault('name','123') 

　　删除操做
　　　　pop() 删除，按照键删除
　　　　　　dic.pop('name') #按照键值删除，默认删除的键值不存在的话会报错
　　　　　　dic.pop('name','没有此键')#第二个参数为提示语，通常设置成None
　　　　clear() 清空
　　　　　 dic.clear()
　　　　popitem()： 3.6以前版本随机删除，可是3.6版本删除最后一个键值对,由于python3.6版本以前，dict类型是无序的，在3.6版本以后变成有序的了
　　　　　　ref = dic.popitem() 有返回值，是被删除的键值对组成的元组
　　　　del删除
　　　　　　del dic['name'] 按照键删除，若是键值不存在会报错
　　　　　　del dic 删除字典

　　修改操做
　　　　1.dic['age']=73 根据键值来修改，没有键值的话就添加
　　　　2.update
　　　　　　a.dic.update(abc="123",bcd="456")  #有就覆盖，没有键值就增长
　　　　　　b.dic.update(dic2) #将一个字典添加到另外一个字典中,dic1里面有和dic2相同的键值，就将dic1中键所对应值修改为dic2中(将dic2中的键值对覆盖追加到dic中)
　　　　　　update里面的键值不能是数字

　　查操做
　　　　print(dic['age']) 若是不存在键，则报错
　　　　print(dic.get('ag')) 若是不存在键，返回nono
　　　　print(dic.get('ag',"没有此键")) 可设置返回值

　　　　print（setdefault.('1')）

　　formkeys:  用于建立一个新的字典，并以可迭代对象中的元素分别做为字典中的键，且全部键对应同一个值，默认为None
　　　　iterable=[1,2] value='a'
　　　　v1 = dict.fromkeys(iterable,value)
　　　　　　iterable： 用于建立新的字典的键的可迭代对象（字符串、列表、元祖、字典）。
　　　　　　value:     可选参数, 字典全部键对应同一个值的初始值，默认为None。
　　　　print(v) {'1': 'a', '2': 'a'}

　　other 其余三个相似列表的类型,均可以转化成list,是高仿list，没有索引
　　　　print(dic.keys(),type(dic.keys()))
　　　　print(dic.values(),type(dic.values()))
　　　　print(dic.items()) #可使用for循环
　　　　for k,y in dic.items():
　　　　　　print(k,y)

　　分别赋值：a =18,b=32,使用一句代码将其调转
　　　　a,b=32,18
　　　　　　print(a,b) #a=32,b=18
　　　　a,b={'name':'alex','age':73}
　　　　　　print(a,b) #a=name b=age
　　　　a,b =[123,2345]
　　　　　　print(a,b) #a=123 b=2345

　　　　原理就是将a和b指向的内存地址的标签调换

 5.数据类型的比较

 数据类型的划分：
    容器非容器划分：
           容器型数据类型：list，tuple，dict，set。
           非容器型数据类型：int str bool
　　可变与不可变划分：
           可变（不可哈希hash）的数据类型：list dict，set
           不可变（可哈希hash的）的数据类型： int bool str tuple
                                        
序列类型：

 6.字典里习题

#将a和b组合成c的样式，并支持扩展
a = [
'a,1',
'b,3,22',
'c,3,4',
'f,5'
]

b=[
'a,2',
'b,4',
'd,2',
'e,12'
]

c = [
'a,1,2',
'b,3,22,4',
'c,3,4',
'd,2',
'e,12',
'f,5'
]

dic ={i[0]:i for i in a}
print(dic)
for ite in b:
    if ite[0] in dic:
    # if dic.get(ite[0]):
        dic[ite[0]] += ite[1:]
    else:
        dic[ite[0]] = ite
print(list(dic.values()))

View Code

 

 

 

 

 返回系列