记录我的 python 学习历程-Day07 基础数据类型进阶 / 数据类型之间的转换 / 基础数据类型总结 / 编码的进阶

基础数据类型

str(字符串)

str：补充方法练习一遍就行

s.capitalize() 首字母大写,其余变小写
```
s = 'dyLAn'

print(s.capitalize())	# Dylan
```

s.swapcase() 大小写翻转

s = 'dYLAN'

print(s.swapcase())		# Dylan

s.title() 每个单词首字母大写(单词之间可以是特殊字符或者空格或者数字)
```
s = 'dylan is good man'

print(s.title()) 	# Dylan Is Good Man
```

s.center() 居中

s = 'dylan'

print(s.center(20))			#        dylan        (默认是空格填充)

print(s.center(20, '@'))	# @@@@@@@dylan@@@@@@@@

s.find() 通过元素找索引，如果有重复的，找到第一个就返回，找不到返回 ‘-1’
```
s = 'dylan'

print(s.find('a'))	# 3

print(s.find('b')) 	# -1
```

s.index() 通过元素找索引，如果有重复的，找到第一个就返回，找不到报错

s = 'dylan'

print(s.index('a'))	# 3

print(s.index('b'))	# 报错

# 报错如下:

Traceback (most recent call last):

  File "/Users/yaoyaoba/Full_stack_22/day07/练习.py", line 8, in <module>

    print(s.index('b'))

ValueError: substring not found

tuple(元组)

元组中如果只有一个元素，并且没有逗号，那么它不是元组，它与该元素的数据类型一致。

tu = (2, 3, 4)

print(tu, type(tu))	# (2, 3, 4) <class 'tuple'>

tu = (2)

print(tu, type(tu))	# 2 <class 'int'>

tu = ('Dylan')

print(tu, type(tu))	# Dylan <class 'str'>

tu = ([1, 2, 3])

print(tu, type(tu))	# [1, 2, 3] <class 'list'>

tu.count() 统计某个元素在元组中出现的次数

tu = (1, 2, 3, 3, 3, 2, 2, 3,)

print(tu.count(3))  # 3

tu.index() 通过元素找索引，如果有重复的，找到第一个就返回
```
tu = (1, 2, 3, 3, 3, 2, 2, 3,)

print(tu.index(3))  # 2
```

list(列表)

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

li = ['q', 'w', 'e', 'w', 'e', 'r', 't', 'y']

print(li.count('w'))    # 2

li.index() 从列表中找出某个值第一个匹配项的索引位置(找不到会报错)

li = ['Dylan', 'yaoyao', 'man', 'girl', 'man']

print(li.index('Dylan'))    # 0

print(li.index('aa'))    # 报错

li.sort() 在原位置对列表进行排序

li = [3, 4, 2, 5, 7, 9, 8, 1]

li.sort()  # 它没有反回值,所以只能打印 li

print(li)  # [1, 2, 3, 4, 5, 7, 8, 9]

li.sort(reverse=True)  # 加个参数 就变成从大到小排序了.

print(li)  # [9, 8, 7, 5, 4, 3, 2, 1]

li.reverse() 将列表中的元素反转排序

li = [3, 4, 2, 5, 7, 9, 8, 1]

li.reverse()  # 它没有反回值,所以只能打印 li

print(li)  # [1, 8, 9, 7, 5, 2, 4, 3]

列表相加

l1 = [3, 4, 2, 5, 7, 9, 8, 1]

l2 = ['Dylan', 'yaoyao', 'man', 'girl', 'man']

print(l1 + l2)  # [3, 4, 2, 5, 7, 9, 8, 1, 'Dylan', 'yaoyao', 'man', 'girl', 'man']

列表与数字相乘

l1 = [3, 4, 2, 5, 7, 9, 8, 1]

l2 = l1 * 3

print(l2)	# [3, 4, 2, 5, 7, 9, 8, 1, 3, 4, 2, 5, 7, 9, 8, 1, 3, 4, 2, 5, 7, 9, 8, 1]

相关练习

li = [3, 4, 2, 5, 7, 9, 8, 1]

# 索引为奇数对应的元素删除（不能一个一个删除，此l1只是举个例子，里面的元素不定）。

# 正常思路:

# 先将整个列表的索引整出来。

for index in range(len(li)):

    if index % 2 == 1:

        li.pop(index)

print(li)   # 会报错,因为超出了索引范围

# 最简单的方法

li = [3, 4, 2, 5, 7, 9, 8, 1]

del li[1: :2]	# 通过切片删

print(li)   # [3, 2, 7, 8]

# 倒着删

for index in range(len(li)-1,-1,-1):

    if index % 2 == 1:

        li.pop(index)

print(li) 	# [3, 2, 7, 8]

# 思维置换

li = [3, 4, 2, 5, 7, 9, 8, 1]

new_li = []

for index in range(len(li)):

    if index % 2 = 0:

        new_li.append(l1[index])

l1 = new_li

print(li)	# [3, 2, 7, 8]

# 总结:

# 循环一个列表时，最好不要改变原列表的大小，这样会影响你的最终结果。

dict(字典)

dic.popitem() 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值

dic = {'name': 'Dylan', 'age': 16}

ret = dic.popitem()

print(ret,dic)	# ('age', 16) {'name': 'Dylan'}

dic.update() 更新或增加 (非常重要)

# 直接增加键值对

dic = {'name': 'Dylan', 'age': 16}

dic.update(sex = '男', height = 178)

print(dic)	# {'name': 'Dylan', 'age': 16, 'sex': '男', 'height': 178}

# 更新己有键值对

dic = {'name': 'Dylan', 'age': 16}

dic.update(age=33)

print(dic)	# {'name': 'Dylan', 'age': 33}

# 元组拆包增加键值对 (面试会考)

dic = {'name': 'Dylan', 'age': 16}

dic.update([(1, 'a'), (2, 'b'), (3, 'c')])

print(dic)	# {'name': 'Dylan', 'age': 16, 1: 'a', 2: 'b', 3: 'c'}

# 更新，有则覆盖，无则添加

dic = {'name': 'Dylan', 'age': 16}

dic1 = {'age': 33, 'sex': 'man'}

dic.update(dic1)

print(dic)	# {'name': 'Dylan', 'age': 33, 'sex': 'man'}

dic.fromkeys() 键来自一个可迭代对象且值共用

dic = dict.fromkeys('abc', 100)

print(dic) 	# {'a': 100, 'b': 100, 'c': 100}  注意这里的值是共用的一个 id

dic = dict.fromkeys([1, 2, 3], 'Dylan')

print(dic)	# {1: 'Dylan', 2: 'Dylan', 3: 'Dylan'}

# 这有个坑,注意,面试题

dic = dict.fromkeys([1, 2, 3], [])

print(dic)	# {1: [], 2: [], 3: []}

dic[1].append(123)	# 因为是共用的值,所以改变一个,其它的也都会变

print(dic)	# {1: [123], 2: [123], 3: [123]}

练习题

# 将字典中键含有'k'元素的键值对删除。

dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}

# 入坑思路:

dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}

for key in dic:

    if 'k' in key:

        dic.pop(key)

print(dic)	# 报错了

# 注意:循环一个字典时，如果改变这个字典的大小，就会报错，这是坑。

# 换个思路，我们把循环出来带有'k'的键放到一个列表中,再用列表循环删字典里的键

dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}

li = []

for key in dic:

    if 'k' in key:

        li.append(key)

for  i in li:

    dic.pop(i)

print(dic)	# {'age': 14}

# 再来个简单的

dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}

for key in list(dic.keys()):	# {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}

    if 'k' in key:

        dic.pop(key)

print(dic)	# {'age': 14}

数据类型之间的转换

目前学到的数据类型有：int / bool / str / list / tuple / dict / set ，这些数据类型之间都可以互相转换，而有些转换是非常重要的，有些则基本不用。

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

f = False

print(int(f))	# 0  False = 0

# int ----> str

i = 100

print(str(i))	# '100'

# str ----> int	全部由数字组成的字符串才可以转化成数字

s = '90'

print(int(s))	# 90

# str ----> bool

s1 = 'Dylan'

s2 = ''

print(bool(s1))	# True 非空即 Treu

print(bool(s2)) # False

# bool ----> str	# 没有什么实际意义

t1 = True

t2 = False

print(str(t1))	# True

print(str(t2))	# False

str / list 两者转换

# str ----> list

s = 'Dylan is good man'

print(s.split())	# ['Dylan', 'is', 'good', 'man']

# list ----> str

li = ['Dylan', 'is', 'good', 'man']

print(' '.join(li))	# Dylan is good man

list / set 两者转换

# list ----> set

li = ['Dylan', 'is', 'good', 'man']

print(set(li))	# {'is', 'Dylan', 'good', 'man'}

# set ----> list

set1 = {'is', 'Dylan', 'good', 'man'}

print(list(set1))	# ['Dylan', 'good', 'man', 'is'] 注意转换过来的是无序的

str / bytes 两者转换

# str ----> bytes

s = '海洋'

print(s.encode('utf-8'))	# b'\xe6\xb5\xb7\xe6\xb4\x8b'

# bytes ----> str

b = b'\xe6\xb5\xb7\xe6\xb4\x8b'

print(b.decode('utf-8'))	# 海洋

所有数据都可以转化成bool值
```
'', 0, (), {}, [], set(), None
```

基础数据类型总结

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

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：有序，需要存key与value映射的相关信息，可变，需要处理数据的增删改(3.6之后有序)

按存值个数区分

标量／原子类型 数字，字符串

容器类型 列表，元组，字典
按可变不可变区分

可变 列表，字典

不可变 数字，字符串，元组，布尔值
按访问顺序区分

直接访问 数字

顺序访问（序列类型） 字符串，列表，元组

key值访问（映射类型） 字典

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

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

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
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 亚洲文字；一个字符三个字节表示。

不同的密码本之间不能互相识别。
数据在内存中全部是以Unicode编码的，但是当你的数据用于网络传输或者存储到硬盘中，必须是以非Unicode编码（utf-8,gbk等等）。
- 英文：
  
  str： 'hello '
  
  内存中的编码方式： Unicode
  
  表现形式： 'hello'
  
  bytes ：
  
  内存中的编码方式：非Unicode
  
  表现形式：b'hello'
- 中文：
  
  str：
  
  内存中的编码方式： Unicode
  
  表现形式：'中国'
  
  bytes ：
  
  内存中的编码方式：非Unicode # Utf-8
  
  表现形式：b'\xe4\xb8\xad\xe5\x9b\xbd'
```
# str ---> bytes

s1 = '中国'

b1 = s1.encode('utf-8')  # 编码

print(b1,type(b1))  # b'\xe4\xb8\xad\xe5\x9b\xbd'

#b1 = s1.encode('gbk')  # 编码  # b'\xd6\xd0\xb9\xfa' <class 'bytes'>

# bytes---->str

b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'

s2 = b1.decode('utf-8')  # 解码

print(s2)
```
```
# gbk ---> utf-8

b1 = b'\xd6\xd0\xb9\xfa'

s = b1.decode('gbk')

# print(s)

b2 = s.encode('utf-8')

print(b2)  # b'\xe4\xb8\xad\xe5\x9b\xbd'
```