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
python基础（基本数据类型三）
集合
- set：集合，是无序的，不重复的数据集合，主要作用是：去重，把一个列表变成集合就完成去重（集合里不可储存列表和字典）
- 创建集合
通过{}创建
set1={1,2,3}
通过set()创建
set1=set({1,2,3,3})
- 增
add()方法：增加一条数据或者是元祖(无返回值)
set1={'lisir','height','name','school'}
set1.add('sex')
print(set1)#{'school', 'lisir', 'name', 'height', 'sex'}
#集合中可以添加元组，数字，字符串，但不可以添加列表和字典
set1={'lisir','height'}
set1.add((1,2,3))
print(set1)#{'height', 'lisir', (1, 2, 3)}
update()方法：迭代着增加
set1={'lisir','height'}
set1.update('abc')
print(set1)#{'c', 'lisir', 'height', 'b', 'a'
set1={'lisir','height'}
set1.update([1,2,3])
print(set1)#{1, 2, 3, 'lisir', 'height'}
#每次输出的集合中元素的顺序不一样，说明集合是无序的
- 删
remove()方法：删除一个指定的元素
set1={'tony','alex','tom'}
set1.remove('alex')
print(set1)#{'tom', 'tony'}
pop()方法：随机删除一个元素,有返回值，返回删除掉的数据
set1={'tony','alex','tom'}
ret=set1.pop()
print(set1,ret)#{'alex', 'tony'} tom
clear()方法： 清空集合(无返回值)
set1={'tony','alex','tom'}
ret=set1.clear()
print(set1,ret)#set() None
del属性： 删除集合
set1={'tony','alex','tom'}
del set1
print(set1)#报错 NameError: name 'set1' is not defined
- 查
#set是无序的，不能按索引去查
set1={'tony','alex','tom'}
for i in set1:
print(i)
#输出：
tony
tom
alex
补充
- enumerate：枚举（不是基本数据类型，可配合上述基本数据类型使用）
#通常我们需要输出一个字符串，列表，集合的索引及其对应的索引值时，一般这样做（以列表为例）
li=[1,2,'name',[2,3,4]]
for i in range(len(li)):
print(i,':',li[i])
#输出：
0 : 1
1 : 2
2 : name
3 : [2, 3, 4]
#其实我们也可以这样做
li=[1,2,'name',[2,3,4]]
for i in enumerate(li):
print(i)#输出的是元组
#print(i[0],":",i[1])#这样输出的结果和用range(len(li))一样
#输出：
(0, 1)
(1, 2)
(2, 'name')
(3, [2, 3, 4])
li=[1,2,'name',[2,3,4]]
for index,value in enumerate(li):
print(index,':',value)
#输出：
0 : 1
1 : 2
2 : name
3 : [2, 3, 4]
enumerate还可以传第二个参数，表示起始位置，默认为0
li=[1,2,'name']
for index,value in enumerate(li,10):#从10开始
print(index,':',value)
#输出：
10 : 1
11 : 2
12 : name
基本数据类型之间的转换
- 字典
dic = {"name": "易烊千玺", "age": 7, "class": "First"}
print(str(dic),type(str(dic)))
#{'name': '易烊千玺', 'age': 7, 'class': 'First'} <class 'str'>
print(tuple(dic))
#('name', 'age', 'class')
print(tuple(dic.values()))
#('易烊千玺', 7, 'First')
#字典可以通过list转换成列表，返回的列表为字典的键，同tuple几乎一样
- 元组
tup=(1,2,3)
print(str(tup))#('a', 'b', 'c')
print(list(tup))#['a', 'b', 'c']
#转字典(通过zip()转)
tup=('a','b','c')
tup1=(1,2,3)
dic=dict(zip(tup,tup1))
print(dic)#{'a': 1, 'b': 2, 'c': 3}
- 列表
#列表转字符串通过str转，转元组，通过tuple转
#转字典(和tuple几乎相同)
#通过zip()，li1和li2中数据长度必须等长
li1=['a','b']
li2=[1,2]
dic=dict(zip(li1,li2))
print(dic)#{'a': 1, 'b': 2}
#使用嵌套列表转换为字典(li1,li2中的数据只能有两个)
li1=['a','b']
li2=[1,2]
li=[li1,li2]
print(dict(li))#{'a': 'b', 1: 2}
- 字符串
str1='abc'
#转为list和tuple相同
print(list(str1))#['a', 'b', 'c']
#转为字典
#eval() 函数用来执行一个字符串表达式，并返回表达式的值
str1="{'name':'Tom', 'age':18}"
print(type(eval(str1)),eval(str1))
#<class 'dict'> {'name': 'Tom', 'age': 18}
基本数据类型---bytes（字节)
一、字节串类型概述
-
什么是bytes：代表字节串，bytes保存的就是原始的字节（二进制格式）数据。常用于在网络上传输数据，也可用于存储各种二进制格式的文件，比如图片、音乐等文件
-
bytes和字符串之间的区别：除操作的数据单元不同之外，它们支持的所有方法都基本相同，bytes 也是不可变序列。
- 字符串由多个字符组成，以字符为单位进行操作
- 字节串由字节组成，以字节为单位进行操作
-
字节概述
要明白什么是字节，首先得明白计算机中的位（bit）和字节（byte），bit代表一位二进制数，也就是1或0，8个二进制数就组成了一字节，也就是8bit=1byte
-
字节和字节串
字节是字节串的数据单元，可以用16进制表示字节
'\xe6\x88\x91\' \xe6 就表示 1 字节，其中 \x 表示十六进制，e6 就是两位的十六进制数 -
编码（文中编码不与实际编码对应，仅方便讲解）
- ASCII码：只包含：英文字母，数字，特殊字符；一个字符用一字节表示，如：00000001--- a
- gbk: 包含英文字母，数字，特殊字符和中文（简称国标）
- Unicode: 万国码：世界上所有的文字都进行编码，起初一个字符用两个字节表示，如：00000001 00000011----a ；00000001 01000001 --- 中。后来为涵盖所有文字，一个字符用四个字节表示如：00000001 00000011 00000001 00000011--- a，但这样极大的浪费了空间，浪费了资源
- utf-8：是Unicode的升级版，最少用8bit1个字节表示，英文字符用一个字节表示，大部分中文字符用三字节表示。节省了空间。
二、字符串和字符之间的转换
- 创建一个bytes类型
创建一个空的bytes类型
byt=bytes()
创建一个带参数的bytes类型
byt=bytes('中国',encoding='utf-8')#此处指定用utf-8对字符串进行编码，必须要用encoding指定编码
print(byt)#b'\xe4\xb8\xad\xe5\x9b\xbd'
byt=b'hello'
print(byt)#b'hello'
byt=b'中国'
print(byt)#SyntaxError: bytes can only contain ASCII literal characters.
#通过前缀b指定后面的字符串是bytes类型，用ASCII码编码，ASCII码中没有对中文进行编码，因此报错
- 将str类型转换为bytes
str1='中国'
b1=bytes(str1,encoding='utf-8')
print(b1)#b'\xe4\xb8\xad\xe5\x9b\xbd'
#utf-8中三个字节表示一个中文字符，\xe4\xb8\xad 代表’中‘字
- bytes类型转str
#bytes类型转str是直接用str进行强制转换吗？
byt=b'\xe4\xb8\xad'
str1=str(byt)
print(str1,type(str1))#b'\xe4\xb8\xad' <class 'str'> 显然不能这样
#bytes类型转换为编码前的字符需要调用bytes对象中的decode()解码，原来用什么编码，就要用什么解码
byt=b'\xe4\xb8\xad'
str1=byt.decode('utf-8')
print(str1)# 中
- encode()和 decode()
encode()是编码,decode()是解码，都是bytes的方法
byt=b'\xe4\xb8\xad\xe5\x9b\xbd'
print(byt.decode(encoding='utf-8'))#中国
#或print(byt.decode('utf-8'))
str1='中国'
print(str1.encode(encoding='utf-8'))#b'\xe4\xb8\xad\xe5\x9b\xbd'
#或print(str1.encode('utf-8'))
#或
print(bytes(str1,encoding='utf-8'))
浙公网安备 33010602011771号