[Python知识库]零基础学python day05数据类型

1. int 整数类型

1.1 定义

number = 10
age = 99

1.2 独有功能

v1 = 5 

#调用v1（int）的独有功能，获取v1的二进制由多少位组成
result = v1.bit_length()
print(result) #  3

1.3 公共功能

加减乘除

1.4 转换

布尔型转整型，字符串转整型浮点型转整型

# 布尔型转整型
n1 = int(True)  # 1
n2 = int(False)  # 2

# 字符型转整型
v1 = int("186", base=10) #186
print(v1)
v2 = int("0b1001", base=2) #9
print(v2)
v3 = int("0o1001", base=8)#513
print(v3)
v4 = int("0x1001", base=16)#4097
print(v4)
# 浮点型转整型
f1 = int(8.7)  # 8

1.5 其他

1.5.1 长整型

• python 3:只有整型（无限制）
• python2：分为整型（有范围）和长整型（无限制）

1.5.2 地板除

• py3

v1 = 9/2 
print(v1) #4.5

• py2

v1 = 9/2 
print(v1) #4

from __future__ import  division
v1 = 9/2 
print(v1) #4.5

2. bool 布尔类型

2.1 定义

data = False
d1 = True

2.2 独有功能

无

2.3 公共功能

无

2.4 转换

整数0、空字符串、空列表、空元组、空字典转换为布尔值时为False，其他均为True

2.5 其他

2.5.1 做条件自动转换

如果在if、while条件后面写一个值当作条件时，他会默认转换为布尔类型，然后再做判断

3. str 字符串类型

表示文本信息

3.1 定义

s1 = "shuijiao"

3.2 独有功能(48个)

"xxx".功能(...)

1. 判断字符串是否以XX开头？得到一个布尔值

s1 = "人生得意须尽欢"

result = s1.startswith("人生")
print(result) #值为True

2. 判断字符串是否以XX结尾？得到一个布尔值

s1 = "人生得意须尽欢"

result = endswith("人生")
print(result) #值为False

3. 判断字符串是否为十进制数，得到一个布尔值

s1 = "12345"
result1 = s1.isdecimal()
print(result1) #True

s2 = "123455a"
result2 = s2.isdecimal()
print(result2) #False

4. 去除字符串两边的空格、换行符、制表符，得到一个新字符串

s1 = " 人生得意须 尽欢  "

s2 = s1.strip() #将s1两边的空格去掉，得到”人生得意须 尽欢“
s2 = s1.lstrip() #将s1左边的空格去掉，得到”人生得意须 尽欢 “
s2 = s1.strip() #将s1右边的空格去掉，得到” 人生得意须 尽欢“

补充：去除空格、换行符、制表符 strip都能使用
再补充：去除字符串两边指定的内容

s1 = "人生得意须 尽欢  人"
s5 = s1.strip("人")

print(s5) #"生得意须 尽欢"  

5. 字符串变大写，得到一个新字符串

msg = "will you still love me"
data = msg.upper()
print(data) #"WILL YOU STILL LOVE ME"

6. 字符串变小写，得到一个新字符串

msg = "WILL YOU STILL love me"
data = msg.lower()
print(data) # "will you still love me"

7. 字符串内容替换，得到一个新的字符串

data = "你是个好人"
value = data.replace("好人","贱人")
print("data="+data)
print("value="+value)

运行结果

8. 字符串切割，得到一个列表

data = "水饺|用户名|密码"
result1 = data.split('|')
result2 = data.split('|',1)
result3 = data.rsplit('|',1)
print("data="+data)
print("result1=",result1)
print("result2=",result2)
print("result3=",result3)

运行结果

9. 字符串拼接，得到一个新的字符串

data_list = ['水饺', '用户名', '密码']
v1 = "_".join(data_list)
print(v1)

运行结果

10. 格式化字符串，得到新的字符串
11. 字符串转换为字节类型

data = "水饺"  # unicode
v1 = data.encode("utf-8")  # utf-8,字节类型
v2 = data.encode("gbk")  # gbk，字节类型

print(v1)  # b'\xe6\xb0\xb4\xe9\xa5\xba'
print(v2)  # b'\xcb\xae\xbd\xc8'

s1 = v1.decode("utf-8")
s2 = v2.decode("gbk")
print("s1=",s1)
print("s2=",s2)

运行结果

12. 将字符串内容居中、居左、居右显示

v1 = "水饺"
data1 = v1.center(20,"*") #总共20个字符，v1在中间
data2 = v1.ljust(20,"*") #总共20个字符，v1在左边
data3 = v1.rjust(20,"*") #总共20个字符，v1在右边
print("data1=",data1)
print("data2=",data2)
print("data3=",data3)

13. 帮助你填充0

v1 = "水饺"
data1 = v1.zfill(8)

print("data1=",data1)

运行结果

应用场景，处理二进制数据，补齐位数

3.3 公共功能

1. 相加（字符串+字符串）

2. 相乘（字符串*数字）

3. 长度

data = "水饺"
value = len(data)
print("value=",value)#2

4. 获取字符串中的字符，索引

data = "水饺"
#       0 1
#       -2 -1
print(data[0]) #水
print(data[1]) #饺

print(data[-2]) #水
print(data[-1]) #饺

字符串可以通过索引取值，不能修改，想修改只能重新创建

5. 获取字符串中的子序列，切片

msg = "人生得意需尽欢"
print(msg[0:2]) #人生
print(msg[3:]) # 意需尽欢
print(msg[:2])#人生
print(msg[4:-1]) #需尽
print(msg[4:-2]) #需
print(msg[4:len(msg)]) #需尽欢

6. 步长，跳着去读字符串的内容

msg = "人生得意需尽欢,莫使金樽空对月"
print(msg[0:8:2]) # 前两个值表示范围，最后一个值代表字长 结果：人得需欢

7. 循环

• for 循环

msg = "人生得意需尽欢,莫使金樽空对月"
for char in msg:
    print(char)

• range ，帮我们创建一系列数字

一般应用场景

• while 一般用在做无限制循环时使用
• for 一般用于已知循环数量的

3.4 转换

一般整型转字符串才有意义

data = 999
v1 = str(data)
print(v1) #"999"

3.5 其他

3.5.1 字符串不可被修改

4.list 列表类型

4.1 定义

有序，可修改
列表，是一个有序且可变的容器，在里面可以存放多种不同类型的元素

data_list = ["水饺",True,123]
data_list.append(False)

4.2 独有功能

1. 追加，在原列表尾部追加值
2. 批量追加，将一个列表中的元素逐一添加到另外一个列表中

number = [1,2,3]
text = ["水饺","花朵"]
text.extend(number)
print(text)

运行结果

3. 插入，在原列表的指定索引位置插入值

number.insert(3,3)
number.insert(5,5)
number.insert(0,0)
print(number) #[0, 1, 2, 4, 3, 6, 5]

4. 在原列表中根据值删除（从左到右找到第一个删除）里面没有会报错

number = [0, 1, 2, 4, 3, 6, 5]

number.remove(1)
print(number) #[0, 2, 4, 3, 6, 5]

number = [0, 1, 2, 4, 3, 6, 5]
if 3 in number:
    number.remove(3)
print(number)  #[0, 1, 2, 4, 6, 5]

5. 在原列表中根据索引踢出某个元素（根据索引位置删除）

number = [0, 1, 2, 4, 3, 6, 5]
number.pop(2) #踢出第二个位置的元素
print(number) #[0, 1, 4, 3, 6, 5]
item = number.pop() #默认踢出最后一个元素
print(number) #[0, 1, 4, 3, 6]
print(item) #5

6. 清空原列表

number = [0, 1, 2, 4, 3, 6, 5]
number.clear()
print(number) #[]

7. 根据值获取索引（从左到右找到第一个）（找不到报错

number = [0, 1, 2, 4, 3, 6, 5]
index = number.index(6)
print(index) # 5

number = [0, 1, 2, 4, 3, 6, 5]
if 6 in number:
    index = number.index(6)
print(index) # 5

8. 列表元素排序

number = [0, 1, 2, 4, 3, 6, 5]
number.sort() #从小到大排序
print(number) #[0, 1, 2, 3, 4, 5, 6]

number.sort(reverse=True) #从大到小排序
print(number) #[6, 5, 4, 3, 2, 1, 0]

text = ["aa","bbb","c","dde","e"]
#将每一个字符都转换为对应的unicode值，之后进行比较
text.sort(reverse=True)
print(text) # ['e', 'dde', 'c', 'bbb', 'aa']

data = "shuijiao"
data_code = []
for char in data:
    data_code.append(ord(char)) #ord 获得unicode的十进制值
print(data_code) #[115, 104, 117, 105, 106, 105, 97, 111]

**注意：**排序时内部元素无法进行比较时，程序会报错（进行数据类型统一）
9. 反转原列表

num = [115, 104, 117, 105, 106, 105, 97, 111]
num.reverse()
print(num) #[111, 97, 105, 106, 105, 117, 104, 115]

4.3 公共功能

1. 相加 两个列表相加生成一个新的列表

num1 = [115, 104, 117]
num2 = [1,2,3]
num3 = num1+num2

print(num3) #[115, 104, 117, 1, 2, 3]

2. 相乘，列表×整型，将列表中的元素再创建N份并生成一个新的列表

num1 = [115, 104, 117]
num2 = [1,2,3]
num4 = 3*num1

print(num4) #[115, 104, 117, 115, 104, 117, 115, 104, 117]

3. 运算符 in包含，由于列表内部时由个元素组成，可以通过in来判断元素是否在列表中

num = [1,2,3]
flag1 = 1 in num
flag2 = 1 not in num
print(flag1) #True
print(flag2) #False

注意： 列表检查元素是否存在时，效率特别低

4. 获取长度

num = [1,2,3]
print(len(num)) #3

5. 索引

num = [1,2,3]
print(num[0]) #1
print(num[1])#2
print(num[2]) #3
num[0] =1234
print(num) #[1234, 2, 3]
#删除
del num[0] 
print(num)#[2, 3]

注意：超出索引范围会报错

6. 切片
   与字符串类似
7. 步长
8. for循环
   循环时进行删除操作，倒着删除

4.4 转换

• int、bool无法转换成列表
• str

name = "水饺"
data = list(name)
print(data) #['水', '饺']

• 元组、集合

v1 = (1,2,3,4) #元组
vv1 = list(v1)
print(vv1) #[1, 2, 3, 4]
v2 = {1,2,34} #集合
vv2 = list(v2)
print(vv2) #[1, 2, 34]

4.5 其他

4.5.1 嵌套

列表属于容器，内部可以存放各种数据，所以他也支持列表的嵌套

5. tuple 元组类型

5.1 定义

元组，是一个有序且不可变的容器，里面可以存放多个不同类型的元素。

v1 = (11,22,33,44)

建议：在元组的最后多加一个逗号
一个元素时
v1 = (1) #1
v2 = (1,) #(1,)

5.2 独有功能

无

5.3 公共功能

1. 相加，两个元组相加生成一个新的元组
2. 相乘，整型*元组，将元组中的元素再创建N份并生成一个新的元组
3. 获取长度
4. 索引只能读
5. 切片只能读
6. 步长只能读
7. for循环只能读

5.4 转换

其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组

name = "shuijiao"
data = tuple(name)
print(data)  # ('s', 'h', 'u', 'i', 'j', 'i', 'a', 'o')

5.5 嵌套

由于元组和列表都可以充当容器，他们内部可以存放很多元素，并且也支持元素内的各种嵌套

6.dict 字典类型

6.1 定义

字典是无序、键不重复且元素只能是键值对的可变的容器

data = {"k1": 1, "k2": 2}

• 容器
• 元素必须键值对
• 键不重复，重复则会被重复

data = {"k1": 1, "k1": 2}
print(data) #{'k1': 2}

• 无序（python3.6+字典就是有序了，之前的字典都是无序）

字典中对键值的要求：

• 键必须可哈希，目前为止可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict
• 值：任意类型

一般在什么情况下使用字典？
当我们想要表示一组固定信息时，用字典更加直观。

6.2 独有功能

1. 获取值

info = {
    "age": 12,
    "status": True,
    "name": "水饺"
}
data = info.get("name")
print(data) #水饺

data = info.get("email")
print(data) # None

data = info.get("hobby",123)
print(data) # 123

2. 所有的键

info = {
    "age": 12,
    "status": True,
    "name": "水饺"
}
data = info.keys()
print(data) #dict_keys(['age', 'status', 'name']) 高仿的列表

result = list(data)
print(result) #['age', 'status', 'name']

注意：在python2中，字典keys()直接获取的是列表，而python3中返回的是高仿列表，这个高仿列表可以被循环显示。

3. 所有的值

info = {
    "age": 12,
    "status": True,
    "name": "水饺"
}
data = info.values()
print(data) #dict_values([12, True, '水饺'])

result = list(data)
print(result) #[12, True, '水饺']

4. 所有的键值

6.3 公共功能

6.4 转换

6.5 其他

7.set 集合类型

7.1 定义

无序可变不允许数据重复的容器

v1 = {11,22,33,"shuijiao"}

• 无序，无法通过索引取值，
• 可变，可以添加和删除元素

一般什么时候使用集合
想要维护一大堆不重复的数据时，就可以使用它
注意：
定义空集合时，只能使用v1 = set(), 而不能使用{}
v1 = {} 这是定义空字典

7.2 独有功能

1. 添加元素

data = set()
data.add("水饺")
print(data) #{'水饺'}

2. 删除元素

data = set()
data.add("水饺")
data.discard("水饺")
print(data) #set()

3. 交集

data1 = {11,22,33,44}
data2 = {33,44,55}
data3 = data1.intersection(data2)
data4 = data1&data2

print(data3)  #{33, 44}
print(data4)  #{33, 44}

4. 并集

data1 = {11,22,33,44}
data2 = {33,44,55}
data3 = data1.union(data2)
data4 = data1 | data2

print(data3)  #{33, 22, 55, 11, 44}
print(data4)  #{33, 22, 55, 11, 44}

5. 差集

data1 = {11, 22, 33, 44}
data2 = {33, 44, 55}
data3 = data1.difference(data2)  # data1中有而data2中没有的数据
data4 = data1 - data2  # data1中有而data2中没有的数据

data5 = data2.difference(data1)  # data2中有而data1中没有的数据
data6 = data2 - data1  # data2中有而data1中没有的数据

print(data3)  # {11, 22}
print(data4)  # {11, 22}

print(data5)  # {55}
print(data6)  # {55}

7.3 公共功能

1. 减，计算差集
2. &，计算交集
3. |，计算并集
4. 长度，len
5. for循环

data1 = {11, 22, 33, 44}
for item in data1 :
    print(item)

7.4 转换

其他类型如果想要转换成集合类型，可以通过set进行转换，并且如果有数据重复自动删除
提示：int/list/tuple/dict都可以转换成集合
这也是去重的一种手段

7.5 其他

7.5.1 集合的存储原理

哈希表实现

7.5.2 元素必须可哈希

因存储原理，集合元素必须是可哈希的值，即：内部可以通过哈希函数把值转换成一个数字

7.5.3 查找速度特别快

##None类型
python的数据类型中有一个特殊的值None，意味着这个值啥都不是，或者表示空，相当于其他语言null作用一样
在一定程度上可以帮助我们去节省内存。例如：
v1 = None
v2 = None
v3 = []
v4 = []

注意：暂不要考虑python内部的缓存和驻留机制

目前所有转换为布尔值为false的值为
0
“”
[]
()
set()
None

8. float 浮点类型

8.1 定义

8.2 独有功能

8.3 公共功能

8.4 转换

8.5 其他