四、学习py：数据类型

1.整型

1.1定义

1 2	number = 10 age = 123

1.2独有功能

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

1.3公共功能

加减乘除

1
2
3

v1 = 2
v2 = 3
v3 = v1 + v2

1.4转换

2.布尔类型

2.1定义

1 2	dhk_is_a_joker = True yj_is_wired = False

2.2独有功能

无

2.3公共功能

无

2.4转换

使用函数bool() 任何的数据类型都能够转换成布尔类型

注：只有整数0、空字符、空元组、空列表、空字典转换为布尔值的时候均为False

2.5其他

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

3.字符串类型

用来表示文本信息。

3.1定义

v1 = "dhk小丑"
v5 = """"
dhk
他就是一个小丑
"""
print(v5)

3.2独有功能（13/48）

1
2
3

"xxx".功能(...)
v1 = "xxx"
v1.功能(...)

3.2.1判断字符串是否是以xx开头？得到一个布尔值

1 2	v1 = "xx is joker" result = v1.startswith("xx")

3.2.2判断字符串是否以xx结尾？得到一个布尔值

1 2	v1 = "xx is joker" result = v1.endswith("joker")

3.2.3判断一个字符串是否为十进制数？得到一个布尔值

1 2	v1 = "123" result = v1.isdecimal()

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

在我的第一篇py博客里面有

额但是方便查阅的话我还是在这里写一下

去两边空格：str.strip()

去左空格：str.lstrip()

去右空格：str.rstrip()

去两边字符串：str.strip(‘d’)，相应的也有lstrip，rstrip。

补充:strip可以去除空格、换行符、制表符，不仅仅是空格。

3.2.5字符串变成大写，得到一个新字符串

1 2	msg = "dhk is a joker" data = msg.upper()

3.2.6字符串变成小写，得到一个新字符串

1 2	msg = "dhk is a joker" data = msg.lower()

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

1 2	data = "動感是一個小丑" value = data.replace("動感","dhk")

#案例
char_list = ["尼瑪","sb"]
content = input("請輸入評論")
for item in char_list:
    content = content.replac(item,"*")
print(content)

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

data = "dhk|joker|小丑"
result = data.split('|')
print(result)
#输出
#['dhk', 'joker', '小丑']
#也不一定非要用|你也可以用其他的比如逗号之类的。
#同时也可以用变量来接受每一个列表中的元素，但是变量的数量必须要等于元素的数量。

注：1.也可以指定切几个，data.split(‘|’,1),这个就是只切一个。

2.rsplit()就是从右边开始切。

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

data_list = ["dhk","is","joker"]
result = "*".join(data_list)
print(result)
#输出
#dhk*is*joker
#当然也可以什么都不加

3.2.10字符串格式化，得到新的字符串

也在第二篇出现过

name = "越江"

age = 123

text = "我叫%s ，今年%s岁." %(name,age)

text = "我叫{0},今年{1}岁,真正的名字叫做{0}".format("越江","99")
text = "我叫{n1}".format(n1 = "越江")
#data = text.format(n1="越江")
#模板复用

dhk = "動感"
age = 12
text = f"{dhk}是一個小丑，今年{age:#b}岁了"
#将数字转换成二进制进行显示（一个扩展罢了，其中进制的代表符号和数电里面一样。）

3.2.11字符串转换为字节类型

1 2	data = "动感"#unicode,字符串类型 v1 = data.encode("utf-8")#字节类型

3.2.12将字符串内容居中，居左，居右

v1 = "动感"
data = v1.center(20,"*")#将动感放在中间，左边放*右边放*，凑成20个字符
print(data)
#输出
#*********动感*********

还有ljust()和rljust,就不多赘述。

3.2.13 填充0

data = "dhk"
data = data.zfill(10)
print(data)
#输出
#0000000dhk
#虽然和rjust差不多，但是zill更多的适用于处理二进制数据。

3.2.14补充函数random(后面会写random模块)

1
2
3

import random
code = random.randrange(1,123)#随机生成一个1-123的数字
print(code)

3.3公共功能

3.3.1相加(str+str)

1	v1 = "dhk" + "joker"

3.3.2相乘（str*int）

1 2	data = "dhk" * 3 print(data)#dhkdhkdhk

3.3.3长度

1 2	data = "dhk" v1 = len(data)

3.3.4获取字符串中的字符，基于索引

msg = "dhk is a jocker"
print(msg[0])
print(msg[2])
#d
#k
print(msg[-1])#r，就是倒着取

注：字符串中只能通过索引取值，不能修改值【字符串在内部存储时是不允许对内部元素进行修改的。】

ex:

message = "dhk is a joker"
index = 0
while index<len(message)：
    value = message[index]
    print(value)
    index += 1
#展示message里面的所有字符，感觉有点像php中的变量覆盖。

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

message = "动感是小丑"
message[0:2]#动感（前取后不取，记得是从0开始）
message[3:5]#小丑
message[3:-1]#小
message[0:len(message)]#动感是个小丑
message[0:]#动感是个小丑

注：同样也只能读取数据

3.3.6步长

1
2
3

message = "动感是小丑"
message[0:2]#动感（前取后不取，记得是从0开始）
message[0:5:2]#隔一个取一个

3.3.7循环

while循环

message = "dhk is a joker"
index = 0
while index<len(message)：
    value = message[index]
    print(value)
    index += 1

for循环

message = "动感是小丑"
for char in message:
    print(char)#char在这里是一个变量
#显示结果和上面的while循环一样

range，帮助我们创建一些列的数字。

1
2
3

range(10)#[0,1,2,3,4,5,6,7,8,9]
range(1,10)#[1,2,3,4,5,6,7,8,9]
#同样也可以加入步长。步长为-1则为倒叙。

1
2
3

message = "动感是小丑"
for i in range( len(message) ):
    print(message[i])

扩充：一般的循环运用场景

while:一般在做无限制（未知）循环此处时使用#比如说让用户输入整数，不是整数就不结束，是整数就直接结束。

for：已知循环循环数量的时候使用。

3.4类型转换

str()

3.5字符串不可被修改

4.列表（list）

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

4.1定义

1
2
3

user_list = ["dhk","小丑","动感"]
number_list = [1,2,1123,-1]
data_list = [1,True,"动感"]

user_list = []
user_list.append("动感")
user_list.append("joker")
print(user_list)
#输出
#['动感', 'joker']

4.2独有功能

python中为所有的列表类型的数据提供了一批独有的功能。

这里之介绍常用的功能

4.2.1追加，在原列表中尾部追加值

user_list = []
user_list.append("动感")
user_list.append("joker")
print(user_list)
#输出
#['动感', 'joker']

#案例
user_list = []
while True:
    user = input("请输入用户名（q或Q退出）")
    if user.upper() == "Q":
        break
    user_list.append(user)
    print(user_list)

#案例2
user_list = []
hello = "欢迎来到越江的第一个游戏"
print(hello.center(30, "*"))
h = 1
f = True
while f:
    user_number = input("请输入要参加游戏的玩家数量: ")
    if  not user_number.isdecimal():
        print ("请输入一个数字！fuck u !")

    else:
        f = False

number = int(user_number)
while h<= number:
    username = input(f"请输入玩家姓名({h}/{number})")
    user_list.append(username)
    h = h +1
print(user_list)

4.2.2批量追加

1 2	name = [] name.extend([11,22,33])

4.2.3插入，在原列表的指定位置插入值

1 2	name = ["dhk","xiaochou"] name.insert(1,"动感")

4.2.4在原列表中根据值删除（从左到右找到第一个删除）【如果里面找不到那个值就会报错】

1 2	name = ["xiaochou","dhk"] name.remove("dhk")

4.2.5在原列表中根据索引删除某个元素

1
2
3

name = ["小丑","动感","joker"]
name.pop()#删除最后一个
name(1)#删除动感

注：用了pop之后数据类型变为str

4.2.6清空原列表

1 2	user_list = ["xiaohcou","dongan"] user_list.clear()

4.2.7根据值获取索引（从左到右找到第一个删除）【慎用，找不到报错】

user_list = ["xiaohcou","dongan"]
if "dongan" in user_list:
    index = user_list.index("dongan")
    print(index)
else:
    print("不存在")

4.2.8列表元素排序

#数字排序
num_list = [1,2,3,5,4]
num_list.sort()#从小到大排序
num_list.sort(reverse=True)#从大到小排序
print(num_list)

#字符串排序
name = ["动感"，"jocker"，"dhk是一个小丑"]
#sort原理：转换成unicode然后再进行比较
name.sort()

注意：请数据类型统一的时候进行比较，不然会报错。

4.2.9反转原列表

1 2	name = ["xiaochou","dhk","jocker"] name.reverse()

4.3公共功能

4.3.1相加

4.3.2相乘

列表*整型将列表中的元素再创建n份拼接在列表后面并生成一个新的列表。

4.3.3运算符in包含

用来判断元素是否在列表中，返回一个布尔值。

注意：in关键字判断元素是否在列表中是一个一个判断的，效率低下。

在后面会介绍高效率的方法。

4.3.4获取长度

1 2	name = ["xiaochou","dhk","jocker"] print(len(name))

4.3.5索引

name = ["xiaochou","dhk","jocker"]
print(name[2])
#扩展基于索引的删除
del name[0]
print(name)

4.3.6切片

1 2	name = ["xiaochou","dhk","jocker"] print(name[0:2])

4.3.7步长

1 2	name = ["xiaochou","dhk","jocker"] print(name[0:2：1])

4.3.8思维拓展（实现一个删除姓董的功能）

首先补充一个函数range

1 2	range(stop) range(start, stop[, step])

user_list = ["董小丑","董动感","joker","董礼仪","嘿嘿我不姓董"]
for index in range(len(user_list)-1,-1,-1):#这里记住是前取后不取
    item = user_list[index]
    if item.startswith("董"):
        user_list.remove(item)
print(user_list)
#这里是从后面开始删除用户的，这样做的好处就是不会打乱前面的用户在列表中的顺序。

4.4类型的转换

很少会用到列表的数据转换。但是为了凑齐这个目录我还是把这个写上。

(๑╹◡╹)ﾉ”

4.5嵌套

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

data = ["小丑",["dhk","joker"],True,[11,22,33],"动感"]
print(data[0])#小丑
print(data[1][1])#joker
#当然除了索引还有增加，删除都是可以这样操作的，感觉有点像二维数组又不是那么像。

5.元组

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

5.1定义

1	v1 = (11,22,33)

建议：在元组最后加一个逗号，用于表示他是一个元组。

1 2	d1 = (1)#python在处理的时候会把他当作整型1 d2 = (1,)#元组

5.2独有功能

没有哦！

(*´▽｀)ノノ

5.3公共功能

其实也和列表差球不多，相加相乘获取长度索引切片步长 for循环

5.4转换

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

name = "dhk"
data = tuple(name)
print(data)#('d', 'h', 'k')

5.5嵌套

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

注意：元组中的列表可以修改内容但是不能对这个列表整个进行修改，因为这个列表属于元组的一个元素。

ex：

1	data = ([1,2],(1,2,3),)

5.5.1应用扩展，实现用户登陆

#首先是原来的数据里面就有两个用户
user_list = [("dhk","joker"),("hi","nihao")]
#先让用户创建一个账户
i = 0
while i<1:
    a = input("请输入你的账户：")
    if not a.isdecimal():
        print("请输入纯数字账户！")
        continue
    else:i += 1
while i<2:
    b = input("请输入您要的密码： ")
    if not b.isdecimal():
        print("请输入纯数字密码！")
        continue
    i += 1
item = (f"{a}",f"{b}")#这里还是用列表比较好，因为方便修改密码，但是因为学到元组了就用这个。
user_list.append(item)
#然后这里假设这个用户要登陆了，来调取账户进行比对。
a = True
b = True
username = user_list[2][0]
userpwd = user_list[2][1]

while b:
    name = input("请输入您的账户: ")
    if name == username:
        b= False
    else:print("请输入正确的账户")
while a:
    paswod = input("请输入您的密码: ")
    if paswod == userpwd:
        print("登录成功")
        a= False
    else :
        print("密码错误")

6.集合（set）

集合是一个无序，可变，不允许数据重复容器。

6.1定义

1	v1 = {11,22,33,"dhk"}

注意：

1.因为是无序（虽然这里看着有顺序但是在系统处理中是没有顺序的）的，所以无法通过索引取值。

2.但是可以添加和删除数据。

3.也不允许数据重复

4.一般在维护一大堆不重复的数据时，就可以用它。比如说：做爬虫去网上找图片链接，为了避免链接重复，就可以用集合来存储图片的地址

5.定义空集合的时候只能使用

1 2	v = set()#定义集合 v = {}#定义的是空字典

6.2独有功能

6.2.1添加元素

1 2	data = {"dhk","xiaochou","joker"} data.add("动感")

6.2.2删除元素

1 2	data = {"dhk","xiaochou","joker"} data.discard("dhk")

6.2.3交集

s1 = {"dhk","joker"}
s2 = {"动感","dhk"}
s3 = s1 & s2 #方式一
s4 = s1.intersection(s2)#方式2

6.2.4并集

s1 = {"dhk","joker"}
s2 = {"动感","dhk"}
s3 = s1 | s2#方式1
s4 = s1.union(s2)#方式2

6.2.5差集

s1 = {"dhk","joker"}
s2 = {"动感","dhk"}
s3 = s1 - s2#方式1 s1中有且s2没有的值
s4 = s1.difference(s2)#方式2 s1中有且s2没有的值

6.3公共功能

6.3.1减，就是计算差集

6.3.2加，就是计算交集

6.3.3|，计算并集

6.3.4长度

1 2	s1 = {"dhk","joker"} data = len(s1)

6.3.5for循环

1
2
3

s1 = {"dhk","joker"}
for item in s1:
    print(item)

6.4转换

使用set()进行转换，如果数据有重复的话会自动剔除。

注：int\list\tuple\dict都可以转化成集合

6.5其他

6.5.1集合的储存原理

6.5.2元素必须可哈希(所以会存在hash碰撞后面会说)

根据储存原理，集合的元素必须是可哈希的值。

1 2	data = hash("动感") print(data)#6995344959373892725

目前可哈希的数据类型：int\bool\str\tuple,而list、set是不可哈希的

总结：集合的元素只能是：整型，布尔，字符串，元组

(27条消息) 哈希表冲突及处理冲突的方法_Hello_GY 的博客-CSDN博客_哈希表冲突

6.5.3查找的速度特别快

因为储存原理的特殊，集合的查找效率特别快

user_name = {"xiaochou","动感","dhk"}
if "dhk" in user_name:
    print("在")
else:
    print("不在")

6.5.4对比和嵌套

在嵌套的时候注意，由于true和false本质上是1和0，所以在集合里面不能同时出现true和1

v1 = {True,1}
print(v1)#{True}

v1 = {1,True}
print(v1)#{1}

7.字典（dict）

字典是无序（py3.6之后就是有序的），键不重复且元素只能是键值对的可变的容器

键不重复，重复就会被覆盖

1 2	data = {"k1":1,"k1":2} print(data)#{'k1': 2}后面覆盖前面的

7.1定义(键必须是可哈希的)

1 2	v1 = {} v2 = dict()#都是定义空字典

#案例
data = {"age":99,
        "status":True,
        "name":"dhk",
        "hobby":["马戏团","小丑"],
        }
print(data)

注意：在嵌套的时候注意，由于键必须是可哈希的，所以键的嵌套中不能使用字典。

7.1.1一般什么时候使用字典

当我们像表示一组固定信息的时候，用字典可以更加的直观。

7.2独有功能

7.2.1获取值

info = {"age":99,
        "status":True,
        "name":"dhk",
        "hobby":["马戏团","小丑"],
       }
data = info.get("age")
print(data)#99
data1 = info.get("joker")
if data1 == None:#键不存在，默认返回None
    print("键不存在")

7.2.2所有的键

info = {"age":99,
        "status":True,
        "name":"dhk",
        "hobby":["马戏团","小丑"],
       }
data = info.keys()
print(data)#dict_keys(['age', 'status', 'name', 'hobby'])
#这个输出的东西是可以被for循环的

7.2.3所有的值

info = {"age":99,
        "status":True,
        "name":"dhk",
        "hobby":["马戏团","小丑"],
       }
data = info.values()
print(data)#dict_values([99, True, 'dhk', ['马戏团', '小丑']])

7.2.4所有的键值

info = {"age":99,
        "status":True,
        "name":"dhk",
        "hobby":["马戏团","小丑"],
       }
data = info.items()
print(data)dict_items([('age', 99), ('status', True), ('name', 'dhk'), ('hobby', ['马戏团', '小丑'])])

7.2.5更新字典键值对

info = {"age":99,
        "status":True,
        "name":"dhk",
        "hobby":["马戏团","小丑"],
       }
info.update({"sex":"男","name":"joker"})
print(info)#info中没有的键直接添加，有的键则更新值

7.2.6一处指定键值对

info = {"age":99,
        "status":True,
        "name":"dhk",
        "hobby":["马戏团","小丑"],
       }
data = info.pop("age")
print(info)#{'status': True, 'name': 'dhk', 'hobby': ['马戏团', '小丑']}
print(data)#99

7.2.6案例扩展

'''
实现输出一个人的个人信息格式如下
name = ['名字',"性别","年龄"]
'''
info_stock = {"动感":["动感","男","99"],
              "小丑":["小丑","男","13"],
              "董小丑":["董小丑","男","123"]
              }
num = input("请输入您要查询的人物： ")
if  not num in info_stock.keys():
    print("请输入正确的人名！")
else:
    data = info_stock.get(num)
    print(f"{num} = {data}")

7.3公共功能

也差不多啦，并集，长度，是否包含，索引（键），根据键修改值和删除值，for循环

7.4转换和嵌套

先要转换为字典使用dict()

在嵌套的时候，注意键值必须可hash（list,set,dict不可hash）

这里总结一下，集合元组必须可hash，字典的键必须可hash。

8.浮点型（float）

浮点型，一般在开发中用于表示小数。

注意三点，

1.在类型转换时，浮点型转换为整型，将会把小数部分去掉。

2.想保留小数后n位

1 2	v1 = 3.1415926 result = round(v1,3)#会自动的给你四舍五入

3.想要遇到精准的小数计算，需要使用decimal模块

import decimal
v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3)#0.3