day7__基础(python基础数据类型补充以及编码的进阶)

一、基础数据类型补充内容

1、字符串

s1 = 'taobao jD shopping'
print(s1.capitalize())   #首字母大写,其余小写

print(s1.swapcase())    #大小写翻转

print(s1.title())  #每个单词的首字毒大写

ret2 = s1.center(30,"*")  # 内同居中,总长度,空白处填充
print(ret2)

s1 = 'taobao jD shopping'
ret3 = s1.find('D')  #find:通过元素找索引,找到第一个就返回,找不到返回-1
print(ret3)

ret4 = s1.index('d')
print(ret4)   ## 返回的找到的元素的索引,找不到报错。

2、元组

​ python中元组有一个特性,元组中如果只含有一个元素且没有逗号,则该元组不是元组,与改元素数据类型一致,如果有逗号,那么它是元组。

tu = (1)
print(tu,type(tu))  # 1 <class 'int'>
tu1 = ('alex')
print(tu1,type(tu1))  # 'alex' <class 'str'>
tu2 = ([1, 2, 3])
print(tu2,type(tu2))  # [1, 2, 3] <class 'list'>

tu = (1,)
print(tu,type(tu))  # (1,) <class 'tuple'>
tu1 = ('alex',)
print(tu1,type(tu1))  # ('alex',) <class 'tuple'>
tu2 = ([1, 2, 3],)
print(tu2,type(tu2))  # ([1, 2, 3],) <class 'tuple'>

元组也有一些其他的方法:

index:通过元素找索引(可切片),找到第一个元素就返回,找不到该元素即报错。

tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白'))   #0
print(tu.index('aaa'))	  #ValueError: tuple.index(x): x not in tuple

count: 获取某元素在列表中出现的次数

tu = ('太白', [1, 2, 3, ], '太白','WuSir', '太白','女神')
print(tu.count('太白'))

3、列表

列表的其他操作方法:

count(数)(方法统计某个元素在列表中出现的次数)

a = ["q","w","q","r","t","y"]
print(a.count("q"))

index(方法用于从列表中找出某个值第一个匹配项的索引位置)

a = ["q","w","r","t","y"]
print(a.index("r"))

sort (方法用于在原位置对列表进行排序)。

reverse (方法将列表中的元素反向存放)。

a = [2,1,3,4,5]
a.sort()# 他没有返回值,所以只能打印a
print(a)
a.reverse()#他也没有返回值,所以只能打印a
print(a)

列表也可以相加与整数相乘

l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1 + l2)  # [1, 2, 3, 4, 5, 6]
print(l1 * 3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

循环列表,改变列表大小的问题

​ 有列表l1, l1 = [11, 22, 33, 44, 55],请把索引为奇数对应的元素删除(不能一个一个删除,此l1只是举个例子,里面的元素不定)。

l1 = [11,22,33,44,55,66,77,88,99]
del l1[1::2]
print(l1)
l1 = [11,22,33,44,55,66,77,88,99]
for i in range(len(l1)-1,-1,-1):
    if i %2 == 1:
        l1.pop(i)
print(l1)
l1 = [11,22,33,44,55,66,77,88,99]
new_l1 = []
for i in range(len(l1)):
    if i %2 == 0 :
        new_l1.append(l1[i])
print(new_l1)

4、dict字典

#popitem 3.5版本之前,popitem为随机删除,3.6之后为删除最后一个,有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}
# update
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}
dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75} 

fromkeys:创建一个字典:字典的所有键来自一个可迭代对象,字典的值使用同一个值。

dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}

# 这里有一个坑,就是如果通过fromkeys得到的字典的值为可变的数据类型,那么你的小心了。
dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(id(dic[1]),id(dic[2]),id(dic[3]))  # {1: [666], 2: [666], 3: [666]}
print(dic)  # {1: [666], 2: [666], 3: [666]}

循环字典,改变字典大小的问题

dic = {'k1':'太白','k2':'barry','k3': '白白', 'age': 18} 请将字典中所有键带k元素的键值对删除。

dic = {'k1':'太白','k2':'barry','k3': '白白', 'age': 18}
dic2= dic.keys()
dic3 = list(dic2)
for i in dic3:
    if i.find('k') != -1:
        del dic[i]
print(dic)
输出结果:
{'age': 18}
dic = {'k1': '太白', 'k2': 'barry', 'k3': '白白', 'age': 18}
for i in list(dic.keys()):
    if 'k' in i:
        del dic[i]
print(dic)
输出结果:
{'age': 18}

二. 数据类型间的转换问题

int bool str 三者转换

# int ---> bool
i = 100
print(bool(i))  # True  # 非零即True
i1 = 0
print(bool(i1))  # False 零即False

# bool ---> int
t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0

# int ---> str
i1 = 100
print(str(i1))  # '100'

# str ---> int  # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1))  # 90

# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'

str list 两者转换

# str ---> list
s1 = 'alex 太白 武大'
print(s1.split())  # ['alex', '太白', '武大']

# list ---> str  # 前提 list 里面所有的元素必须是字符串类型才可以
l1 = ['alex', '太白', '武大']
print(' '.join(l1))  # 'alex 太白 武大'

list set 两者转换

# list ---> set
s1 = [1, 2, 3]
print(set(s1))

# set ---> list
set1 = {1, 2, 3, 3,}
print(list(set1))  # [1, 2, 3]

str bytes 两者转换

# str ---> bytes
s1 = '太白'
print(s1.encode('utf-8'))  # b'\xe5\xa4\xaa\xe7\x99\xbd'

# bytes ---> str
b = b'\xe5\xa4\xaa\xe7\x99\xbd'
print(b.decode('utf-8'))  # '太白'

所有数据都可以转化成bool值

转化成bool值为False的数据类型有:
'', 0, (), {}, [], set(), None

三.基础数据类型的总结

按存储空间的占用分(从低到高)

  • 数字
  • 字符串
  • 集合:无序,即无序存索引相关信息
  • 元组:有序,需要存索引相关信息,不可变
  • 列表:有序,需要存索引相关信息,可变,需要处理数据的增删改
  • 字典:有序,需要存key与value映射的相关信息,可变,需要处理数据的增删改(3.6之后有序)

按存值个数区分

标量/原子类型 数字,字符串
容器类型 列表,元组,字典

按可变不可变区分

可变 列表,字典
不可变 数字,字符串,元组,布尔值

按访问顺序区分

直接访问 数字
顺序访问(序列类型) 字符串,列表,元组
key值访问(映射类型) 字典

四. 编码的进阶

编码即是密码本,编码记录的就是二进制与文字之间的对应关系,现存的编码本有:

ASCII码:包含英文字母,数字,特殊字符与01010101对应关系。

  a 01000001 一个字符一个字节表示。

GBK:只包含本国文字(以及英文字母,数字,特殊字符)与0101010对应关系。

  a 01000001 ascii码中的字符:一个字符一个字节表示。

  中 01001001 01000010 中文:一个字符两个字节表示。

Unicode包含全世界所有的文字与二进制0101001的对应关系。

  a 01000001 01000010 01000011 00000001

  b 01000001 01000010 01100011 00000001

  中 01001001 01000010 01100011 00000001

UTF-8:包含全世界所有的文字与二进制0101001的对应关系(最少用8位一个字节表示一个字符)。

  a 01000001 ascii码中的字符:一个字符一个字节表示。

  To 01000001 01000010 (欧洲文字:葡萄牙,西班牙等)一个字符两个字节表示。

  中 01001001 01000010 01100011 亚洲文字;一个字符三个字节表示。

1、不同的密码本之间不能互相识别

2、数据在内存中全是以Unicode编码的,但是当你的数据用于网络传输或者存储到硬盘中,必须以非Unicode编码(utf-8,gbk等等)

img

3、bytes数据类型

英文

  • ​ str :'hello'

​ 内存中的编码方式:Unicode

​ 表现形式:'hello'

  • ​ bytes:

​ 内存中的编码方式:非Unicode

​ 表现形式; b'hello'

b = b'hello'  #如果在字符串前加b,它就变为一个bytes类型的数据
print(b,type(b))  #b'hello' <class 'bytes'>
b = b'hello'
print(b.upper(),type(b))  #b'HELLO' <class 'bytes'>

中文

  • str :'中国'

​ 内存中的编码方式:Unicode

​ 表现形式:'中国'

  • bytes:

​ 内存中的编码方式:非Unicode

​ 表现形式; b'\xe4\xb8\xad\xe5\x9b\xbd'

转换

  • str -------> bytes
# encode称作编码:将 str 转化成 bytes类型
s1 = '中国'
b1 = s1.encode('utf-8')  # 转化成utf-8的bytes类型
print(s1)  # 中国
print(b1)  # b'\xe4\xb8\xad\xe5\x9b\xbd'
s1 = '中国'
b1 = s1.encode('gbk')  # 转化成gbk的bytes类型
print(s1)  # 中国
print(b1)  # b'\xd6\xd0\xb9\xfa'
  • bytes ----->str
# decode称作解码, 将 bytes 转化成 str类型
b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
s1 = b1.decode('utf-8')
print(s1)  # 中国
# decode称作解码, 将 bytes 转化成 str类型
b1 = b'\xd6\xd0\xb9\xfa'
s1 = b1.decode('gbk')
print(s1)  # 中国

注:用什么编码(gbk,utf-8等)转过来的,必须要用相同的编码转回去。

  • gbk ------>utf-8

​ gbk编码的bytes如何转化成utf-8编码的bytes

不同编码之间,不能直接互相识别。

​ Unicode是万码之源,先用gbk转为Unicode,转从Unicode转换为utf-8

b1 =  b'\xe4\xb8\xad\xe5\x9b\xbd'  # 这是utf-8编码bytes类型的中国
b2 =  b'\xd6\xd0\xb9\xfa'   # 这是gbk编码bytes类型的中国
b2 =  b'\xd6\xd0\xb9\xfa'  # 这是gbk编码bytes类型的中国
s = b2.decode('gbk')
print(s)
s1 = s.encode('utf-8')
print(s1)
输出结果:b'\xe4\xb8\xad\xe5\x9b\xbd'
posted @ 2020-06-23 00:17  MrXiong  阅读(42)  评论(0编辑  收藏