python基础（基本数据类型二）

python基础之基本数据类型二

元组

一、元组创建

• 元组被称为只读列表，即数据可以被查询，但不能被修改(即不能 增删改)

tup = (11, 22, 33, 44, 55)
tup = tuple((11, 22, 33, 44, 55))

二、基本操作

• 元组的索引切片

tu1=('a','b', '张三', 3, 666)
print(tu1[0])#a
print(tu1[-1])#666
print(tu1[1:3])#('b', '张三')
print(tu1[:-1])#('a', 'b', '张三', 3)
print(tu1[::2])#('a', '张三', 666)
print(tu1[::-1])#(666, 3, '张三', 'b', 'a')

• 元组其他操作方法

#查询元组中的元素
tup = ('a', 'b', '张三', 3, 666)
for i in tup:
    print(i)
#输出：
a
b
张三
3
666

#index():读取指定元素所在位置，tup没有find方法
tup = ('a', 'b', '张三', 3, 666)
print(tup.index('a'))#0

#len（）:得到元祖的长度
tup = ('a', 'b', '张三', 3, 666)
print(len(tup))#5

#count():得到指定元素在元祖中出现的次数
tup = ('a', 'b', '张三', 3, 666,'a')
print(tup.count('a'))#2
#元组中count只能传一个参数，不同于字符串
print(tup.count('a',2,5))#报错
#字符串中
str3="this is a teather"
print(str3.count('i'))#2
print(str3.count('i',2,5))#1

列表

• 列表相比于字符串，不仅可以储存不同的数据类型而且列表是有序的，有索引值，可切片，方便取值,列表可以存储任意数据类型

一、列表的操作

• 1.增

insert(索引值，增加的数据)方法： 在指定索引值处去增加数据(无返回值)
li = [11,'a','b',22,33,'a']
print(li.insert(0,5))#因为无返回值，所以输出为None
li1=li.insert(0,5)
print(li1)#因为无返回值，所以输出为None
li.insert(0,5)#在索引值为0处添加5
print(li)#[5, 11, 'a', 'b', 22, 33, 'a']

append()方法：是往列表的尾部追加一条数据,可以是字符串，列表，元组，集合或者字典(无返回值)
li=[11,'a','b',22,33,'a']
print(li.append('c'))#None
li=[11,'a','b',22,33,'a']
li.append('c')
print(li)#[11, 'a', 'b', 22, 33, 'a', 'c']
li=[11,'a','b',22,33,'a']
li.append(['c',1,2])
print(li)#[11, 'a', 'b', 22, 33, 'a', ['c', 1, 2]]
li=[11,'a','b',22,33,'a']
li.append({'key':'value','key1':'value1'})
print(li)#[11, 'a', 'b', 22, 33, 'a', {'key': 'value', 'key1': 'value1'}]

extend()方法: 迭代的去增加
li=[11,'a','b',22,33,'a']
li.extend(['b','c','d'])
print(li)#[11, 'a', 'b', 22, 33, 'a', 'b', 'c', 'd']
li=[11,'a','b',22,33,'a']
li.extend('a')
print(li)#[11, 'a', 'b', 22, 33, 'a', 'a']
li=[11,'a','b',22,33,'a']
li.extend('bcd')#[11, 'a', 'b', 22, 33, 'a', 'b', 'c', 'd']

• 2.删

pop()方法：默认删除列表的尾部，也可按照索引值删除，有返回值,返回删除的数据
li = ['a','b','c','d','e','f']
ret=li.pop()
print(ret,li.pop,li)#f <built-in method pop of list object at 0x033017C8> ['a', 'b', 'c', 'd', 'e'] 返回ret=‘f’,li.pop为中间的一串
#按索引值删除
li = ['a','b','c','d','e','f']
ret=li.pop(2)
print(ret,li)#c ['a', 'b', 'd', 'e', 'f']

del ：按照索引去删除，也可切片删除没有返回值。
#切片删除
li = ['a','b','c','d','e','f']
del li[1:3]
print(li)#['a', 'd', 'e', 'f']
#按索引删除
li = ['a','b','c','d','e','f']
del li[4]
print(li)#['a', 'b', 'c', 'd', 'f']

remove()方法：按照元素去删除
li = ['a','b','c','d','e','f']
li.remove('b')
print(li)#['a', 'c', 'd', 'e', 'f']

clear()方法：清空列表
li = ['a','b','c','d','e','f']
li.clear()
print(li)#[]

• 3.改

按索引去改
li = [1,'a','b',2,3,'b']
li[2]='new'
print(li)#[1, 'a', 'new', 2, 3, 'b']

按切片去改实质是按迭代增加到列表
li = [1,2,3,4,5,6]
li[1:4]=['a','b']
print(li)#[1, 'a', 'b', 5, 6]
li = [1,2,3,4,5,6]
li[1:3]=['a','b','c','d','e']
print(li)#[1, 'a', 'b', 'c', 'd', 'e', 4, 5, 6]

• 4.查

通过切片查
li = [1,'a','b',2,3,'c']
print(li[2])#b
print(li[2:5])#['b', 2, 3]

按循环去查
li = [1,'a','b',2,3,'c']
for i in range(len(li)):
    print(i,li[i])
#输出
0 1
1 a
2 b
3 2
4 3
5 c

• 其他操作

count（数据）方法：统计某个元素在列表中出现的次数
li=["j","u","j","i","a","o"]
print(li.count('j'))#2
print(li.count('j',2,5))#报错

str3="this is a teather"
print(str3.count('i'))#2
print(str3.count('i',0,5))#1  字符串中可以传三个参数

index()方法：方法用于从列表中找出某个值第一个匹配项的索引位置
li=["j","u","j","i","a","o"]
print(li.index('i'))#3
#无find方法

sort()方法:用于在原位置对列表进行排序,没有返回值
a = [2,1,3,4,5]
a.sort()#默认从小到大排序
print(a)#[1, 2, 3, 4, 5]
a = [2,1,3,4,5]
a.sort(reverse=True)#从大到小排序（降序排序）
print(a)#[5, 4, 3, 2, 1]
#列表中有字符串和数字，不能排序，会报错
li=['a','b','c','c',1,2,90,100]
li.sort()
print(li)#报错
li=['aq','eb','c','c','a','d']
li.sort()
print(li)#['a', 'aq', 'c', 'c', 'd', 'eb']

# 按照元组中第一个元素排序
li=[(1,"a"),(2,"v"),(5,"w"),(0,"c")] 
li.sort(key=lambda x:x[0])
print(li)#[(0, 'c'), (1, 'a'), (2, 'v'), (5, 'w')]
#按照元组中第三个元素排序
li=[(1,"a",5),(2,"v",6),(5,"w",4),(0,"c",2)] 
li.sort(key=lambda x:x[2])
print(li)#[(0, 'c', 2), (5, 'w', 4), (1, 'a', 5), (2, 'v', 6)]

reverse()方法:将列表中的元素反向存放
a = [2,1,3,4,5]
a.reverse()
print(a)#[5, 4, 3, 1, 2]
a=['a','b','f','c']
a.reverse()
print(a)#['c', 'f', 'b', 'a']

copy()方法：用于复制列表元素
li=[1,2,3,4]
li2=li.copy()
print(li,'---',li2)#[1, 2, 3, 4] --- [1, 2, 3, 4]
#修改了其中一项元素，不会影响复制体
li=[1,2,3,4]
li2=li.copy()
print(li,'---',li2)#[1, 2, 3, 4] --- [1, 2, 3, 4]
li[0]='change'
print(li,'---',li2)#['change', 2, 3, 4] --- [1, 2, 3, 4]
#列表嵌套时不适用
li=[1,2,3,4，[1,2]]
li2=li.copy()
print(li,'---',li2)#[1, 2, 3, 4, [1, 2]] --- [1, 2, 3, 4, [1, 2]]
li[-1][0]='change'
print(li,'---',li2)#[1, 2, 3, 4, ['change', 2]] --- [1, 2, 3, 4, ['change', 2]]
#解释：主列表只是存储了嵌套列表在内存中的地址，而不是所看到的数据，copy的也只是嵌套列表的地址，但两个地址指向的是内存中同一块区域，所以在对嵌套列表进行修改时，只是通过了两个复制地址而修改了真实数据，所以两个列表的元素都被改掉了。

• 列表生成式

#不使用列表生成式
lis=[]
for i in range(4):
    print(lis.append(i))
print(lis)#[0, 1, 2, 3]
# 使用列表生成式
li=[i for i in range(4)]
print(li)#[0, 1, 2, 3]
li=[i*i for i in range(4)]
print(li)#[0, 1, 4, 9]

字典

• 列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

一、创建字典

创建一个空字典
dict={}

传入可迭代对象
b=dict(zip(['one','two','three'],[1,2,3]))
print(b)#{'one': 1, 'two': 2, 'three': 3}
#对比列表
b=list(zip(['one','two','three'],[1,2,3]))
print(b)#[('one', 1), ('two', 2), ('three', 3)]

传入可迭代对象
dic=dict([('one',1),['two',2],['three',3]])
print(dic)#{'one': 1, 'two': 2, 'three': 3}
#如果键有重复，其值为最后重复项的值
dic=dict([('one',1),('two',2),('one',3)])#{'one': 3, 'two': 2}

传入映射对象，字典创建字典
dic=dict({'one':1,'two':2,"three":3})
print(dic)#{'one': 1, 'two': 2, 'three': 3}

二、字典的操作方法

• 增

通过键值增加
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['address']='海南'
dic['country']='中国'
print(dic)#{'age': 18, 'name': 'tan', 'sex': 'girle', 'address': '海南', 'country': '中国'}
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['li']=['a','b','c']
print(dic)#{'age': 18, 'name': 'tan', 'sex': 'girle', 'li': ['a', 'b', 'c']}

setdefault()方法： 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.setdefault('address','河北')
print(dic)#{'age': 18, 'name': 'tan', 'sex': 'girle', 'address': '河北'}
dic.setdefault('address','北京')
print(dic)#{'age': 18, 'name': 'tan', 'sex': 'girle', 'address': '河北'}
#键值对存在，就不会被更改

• 删

pop(要删除的键，设置返回值)方法：根据key删除键值对，并返回对应的值，如果没有key则课设置返回默认返回值
#没设置返回值，当字典里没有改键的话就会报错
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
ret=dic.pop('address')#报错
print(dic)
print(ret)
#设置返回值，没有找到就返回’没有此键‘
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
ret=dic.pop("address",'没有此键')
print(ret)#没有此键
#字典里有该键
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
ret=dic.pop('age')
print(dic)#{'name': 'tan', 'sex': 'girle'}
print(ret)#18

clear()方法：清空字典
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.clear
print(dic)#{}
（注：字典里没有remove方法）

• 改

通过键去改
#键存在，改之，不存在，加之
dic = {"name":"tom","age":18}
dic['name']='jim'
print(dic)

update(keys='value')方法：将所有的键值对覆盖添加(相同覆盖，没有的添加），没有返回值
#setdefault('keys','value')方法：如果键存在，就不会覆盖，不存在就添加,其与update在书写格式上也有不同
dic = {"name":"tom","age":18}
dic.update(name='jhon')
print(dic)#{'name': 'jhon', 'age': 18}
dic = {"name":"tom","age":18}
dic.update(address='河北')
#dic.setdefault('address','河北') 
print(dic)#{'name': 'tom', 'age': 18, 'address': '河北'}

dic = {"name":"tom","age":18,"sex":"male"}
dic2 = {"name":"wu","weight":75}
dic.update(dic2)#将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic)
#{'name': 'wu', 'age': 18, 'sex': 'male', 'weight': 75}

• 查

通过键名查
dic={'name':'jack','weight':60,'height':180}
print(dic['name'])#jack

通过get（）方法查，有返回值，也可以设置返回值
dic={'name':'jack','weight':60,'height':180}
#没有要搜索的键，默认返回None
print(dic.get('key'))#None
#没有找到，返回设置的值
print(dic.get('key','没有此键'))#没有此键
print(dic.get('height'))#180

• 其他操作方法

items()方法是可迭代的，返回列表
dic={'name':'jack','weight':60,'height':180}
item=dic.items()
print(item)#dict_items([('name', 'jack'), ('weight', 60), ('height', 180)])
#dict_items类型是可迭代的
print(list(item))#[('name', 'jack'), ('weight', 60), ('height', 180)]

dic={'name':'jack','weight':60}
for i in dic.items():
    print(i)
#输出：
('name', 'jack')
('weight', 60)

#获得字典中的键和值
dic={'name':'jack','weight':60}
for i in dic.items():
    print(i[0],":",i[1])
#输出：
name : jack
weight : 60
    
keys()方法:得到字典的键，返回列表，可迭代
dic={'name':'jack','weight':60}
print(dic.keys())#dict_keys(['name', 'weight'])
for key in dic.keys():
    print(key,"+",dic[key])

#输出：
name
weight

#获取字典中的键值对
dic={'name':'jack','weight':60}
for key in dic.keys():
    print(key,"：",dic[key])
#输出
name : jack
weight : 60
    
values()方法：得到字典的值，返回列表 ，可迭代 
dic={'name':'jack','weight':60}
print(dic.values())#dict_values(['jack', 60])

字典的循环
dic={'name':'jack','weight':60}
for (key,value) in dic.items():
    print(key,":",value)
#输出：
name : jack
weight : 60