基础数据类型的补充；编码的进阶

str
- capitalize() 首字母（第一个单词）大写，其余变小写
```
s1 = 'I LIVE YOU'
print(s1.capitalize())
>>>I live you
```
- title() 每个单词的首字母大写。(以特殊字符（非字母）隔开的即为一个单词)
```
s1 = 'I LIVE YOU'
print(s1.title())
>>>I Live You
```
- swapcase() 大小写反转
```
s1 = 'I love YOU'
print(s1.swapcase())
>>>i LOVE you
```
- center() 居中，有1个必选参数：宽度，一个非必选参数：填充）
```
s1 = 'I'
print(s1.center(10,'%'))
>>>%%%%I%%%%%
```
- find() 通过元素找索引，找到第一个就返回，找不到返回-1。
```
s1 = 'I love you'
print(s1.find('o'))
>>>3
```
- index() 通过元素找索引，找到第一个就返回，找不到就报错。

tuple

特殊性：元祖中只有一个元素，并且没有’，‘，则它不是元祖，它与括号中的数据类型一致

tu0 = (1,2)
print(tu0,type(tu0))
>>>(1, 2) <class 'tuple'>

tu1 = (1)
print(tu1,type(tu1))
>>>1 <class 'int'>

tu2 = ([1])
print(tu2,type(tu2))
>>>[1] <class 'list'>

tu3 = (1,)
print(tu3,type(tu3))
>>>(1, ) <class 'tuple'>

count() 计数

tu = (1,2,3,3,3,3)
print(tu.count())
>>>4

index() 找索引

tu = ['a','b','a']
print(tu.index('a'))
>>>0

list

index() 通过元素找索引

l1 = ['a','b','a']
print(l1.index('a'))
>>>0

sort() 默认从小到大排序，设置reverse参数则可从小到大

l1 = [3,2,1,4]
l1.sort()
print(l1)
>>>[1,2,3,4]

l1.sort(reverse=True)
print(l1)
>>>[4,3,2,1]

reverse() 反转

l1 = [2,1,3,0]
l1.reverse()
print(l1)
>>>[0,3,1,2]

列表相加 (3.4以上版本)

l1 = [1,2,3]
l2 = [3,4,5]
print(l1+l2)
>>>[1, 2, 3, 3, 4, 5]

列表与数字相乘 (3.4以上版本)

l1 = [2,'a',[1,'b']]
l2 = l1*3
print(l2)
>>>[2, 'a', [1, 'b'], 2, 'a', [1, 'b'], 2, 'a', [1, 'b']]

列表的特殊性：正向循环一个列表时如果删除某个元素，那么这个元素后面的所有元素都会向前进一位，它们的索引相比之前也会前进一位，因此，在循环一个列表时的过程中，如果要改变列表的大小（增加值或者删除值），那么结果很可能会出错或者报错。

l1 = [1,2,3,4,5,6]  #删除列表中索引位为偶数的元素。
for i in range(0,len(l1),2):
    l1.pop(i)
print(l1)
>>>IndexError: pop index out of range

解决此问题有三种方式

1.直接删除（按照元素删除，按照索引删除，切片加步长

#切片加步长
l1 = [1,2,3,4,5,6]
del l1[1::2]
print(l1)

2.倒叙删除

l1 = [1,2,3,4,5,6]
for i in range(len(l1)-1,-1,-2): 
    l1.pop(i)   
print(l1)
>>>[1,3,5]

#不能用以下代码；请自测
l1 = [1,2,3,4,5,6]
for i in range(1,len(l1),2):
    l1.pop(-i)

3.思维转换

l1 = [1,2,3,4,5,6]
l2 = []
for i in range(0,len(l1),2): 
    l2.append(l1[i])
l1 = l2
print(l1)

dict

popitem 3.5版本之前，随机删除，3.6版本之后，删除最后一个，有返回值。请自测。

update

dic0 = {1:'i'}
dic0.update(2='love',hobby='python')  #增加键值对
print(dic0)
>>>{1: 'i', 2: 'love', 'hobby': 'python'}

dic0.update(1 = '太阳') #改键值对
print(dic0)
>>>{1: '太阳', 2: 'love', 'hobby': 'python'}

dic1 = {}
dic1.update([(1,'a'),(2,'b'),(3,'c')])
print(dic1)
>>>{1: 'a', 2: 'b', 3: 'c'}

dic0.update(dic1)
print(dic0)   #有则覆盖，无则增加
>>>{1: 'a', 2: 'b', 'hobby': 'python', 3: 'c'}
print(dic1)
>>>{1: 'a', 2: 'b', 3: 'c'}

fromkeys() 第一个参数必须为可迭代对象，可迭代的对象共用第二个参数(id相同)。

dic = dict.fromkeys('abc',1)     
print(dic)
>>>{'a': 1, 'b': 1, 'c': 1}

dic = dict.fromkeys([1,2,3],[])
print(dic)
>>>{1: [], 2: [], 3: []}
dic[1].append('a')
print(dic)
>>>{1: ['a'], 2: ['a'], 3: ['a']}

小题试做：（循环一个字典时，若果改变字典的大小则或报错。）

#将字典dic中的以‘k’开头的键值对删除
dic = {'k1':'a','k2':'b','k3':'c','a':'d'}
l1 = []
for key in dic:
    if key.startswith('k'):
        l1.append(key)
for i in l1:
    dic.pop(i)
print(dic)
>>>{'a':'d'}


#改进
for key in list(dic.keys()):   #将其转换为一个列表，若不加list则回报错。
    if 'k' in key:
        dic.pop(key)
print(dic)
>>>{'a','d'}

数据之间类型的转换：
- int bool str 三者转换
- str list 两者转换
- list set 两者转换
- str bytes 两者转换
- 所有数据都可以转换成bool值：
  
  转换成bool值为False的数据类型有：
```
'',0,(),{},[],set(),None
```
基础数据结构类型的总结
- 按照储存空间的占用分（从低到高）
  - int
  - str
  - set : 无序
  - tuple: 有序，不可变
  - list: 有序，可变
  - dict: 有序（3.6版本之后），可变

编码的进阶：

不同的编码方式之间不能相互识别
数据在内存中全部是以Unicode编码的，但是当数据用于网络传输或者存储到硬盘中，必须是以非Unicode编码（utf-8、gbk等）

python中的数据从内存（Unicode编码）存储到硬盘或进行网络传输时要经历一个特殊的转化过程,要转化为一个非Unicode编码类型的特殊数据才能进行传输或储存至硬盘，即bytes类型(内存中的编码方式：非Unicode)

bytes与str的操作方式大部分都是一样的
bytes can only contain ASCII literal characters，手动将中文字符串转化为bytes类型会报错，要经过特殊的转化

#str转bytes:
a = b'iloveyou'
print(a,type(a))
>>>b'iloveyou' <class 'bytes'>

#将中文转化为bytes类型：
b = b'山就在那儿'
print(b)
>>>SyntaxError: bytes can only contain ASCII literal characters
#正确方法为：

c = '山就在那儿'
b = c.encode('utf-8')
print(b)   #or print(c.encode('utf-8'))    #一般指定utf-8的编码形式，   (encode:编码)
>>>b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'

bytes可转化为字符串类型（Unicode）（decode，解码）。用什么编码类型转换为bytes数据类型的就用什么解码。

b = b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'
c = b.decode('utf-8')    or print(b.decode('utf-8'))
print(c)
>>>山就在那儿

#用什么编码类型转换为bytes数据类型的就用什么解码。
b = b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'
c = b.decode('gbk')    
print(c)
>>>UnicodeDecodeError: 'gbk' codec can't decode byte 0xbf in position 14: incomplete multibyte sequence

小题试做：gbk转换为utf-8

#分析，所有的编码都与Unicode有关（计算机内存中以Unicode编码），因此可先将gbk转换为Unicode编码，再转换为utf-8编码。

gbk = b'\xc9\xbd\xbe\xcd\xd4\xda\xc4\xc7\xb6\xf9'
decode1 = gbk.decode('gbk')    #解码为Unicode编码的字符串,可print(decode1)查看。
print(decode1.encode('utf-8'))  #以utf-8编码
>>>b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'

python基础学习day7

基础数据类型的补充；编码的进阶

猜你喜欢