数据类型 - 服务器托管|北京服务器租用|机房托管租用|IDC托管租用|机房机柜带宽租用-价格及费用咨询

常见的数据类型：

int，整数类型（整形）
bool，布尔类型
str，字符串类型
list，列表类型
tuple，元组类型
dict，字典类型
set，集合类型
float，浮点类型（浮点型）

一、整形（int）

1.定义

十进制整数的统称。

2. 独有功能

无

3.公共功能

加减乘除

4.类型转换

在项目开发和面试题中经常会出现一些 “字符串” 和布尔值转换为整型的情况。

# 布尔值转整型
n1 = int(True)  # True转换为整数 1
n2 = int(False) # False转换为整数 0

# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8)  # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16)  # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）

# 浮点型（小数）
v1 = int(8.7) # 8   浮点数转换为整形会将小数点后去掉

二进制、八进制、十进制、十六进制规则存储的字符串时，可以轻松的通过int转换为十进制的整数。

5. 其他

【1】整形、长整形

Python3：整型（无限制）
Python2：整型、长整形

在python2中跟整数相关的数据类型有两种：int(整型)、long（长整型），他们都是整数只不过能表示的值范围不同。

int，可表示的范围：-9223372036854775808～9223372036854775807
long，整数值超出int范围之后自动会转换为long类型（无限制）。

在python3中去除了long只剩下：int（整型），并且 int 长度不在限制。

【2】地板除

Py3：

  v1 = 9/2 
  print(v1) # 4.5   py3做除法可以保留整数位

py2:

  v1 = 9/2 
  print(v1) # 4   py2做除法只能保留整数位

解决方法：

  from __future__ import division 
  
  v1 = 9/2 
  print(v1) # 4.5     通过此方法py2做除法也可以保留小数未

二、布尔类型（bool）

真、假

1.定义

True
False

2. 独有功能

无

3.公共功能

无

4.类型转换

在以后的项目开发中，会经常使用其他类型转换为布尔值的情景，此处只要记住一个规律即可。

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

# 练习题：查看一些变量为True还是False
v1 = bool(0)       F
v2 = bool(-10)      T
v3 = bool(10)      T
v4 = bool("张三")    T
v5 = bool("")      F
v6 = bool(" ")     T
v7 = bool([]) # [] 表示空列表     F
v8 = bool([11，22，33]) # [11，22，33] 表示非空列表     T
v9 = bool({}) # {} 表示空字典     F
v10 = bool({"name":"张三","age":18}) # {"name":"张三","age":18} 表示非空字典    T

5.其他

做条件自动转换

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

if 0:
	print("太六了")
else:
  print(999)

if "张三":
	print("你好")

while 1>9:
  pass

if 值:
  pass

while 值:
  pass

三、字符串（str）

1.定义

我们平时会用他来表示文本信息。例如：姓名、地址、自我介绍等。

2. 独有功能（18/48）

独有功能执行方法：

"xxxxx".功能(...)

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

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

v1 = "你好，世界"

# True
result = v1.startswith("你好")

print(result) # 值为True

# 案例
v1 = input("请输入住址：")

if v1.startswith("北京市"):
	print("北京人口")
else:
	print("非北京人口")

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

v1 = "你好，世界"

result = v1.endswith("世界")

print(result) # 值为True

# 案例
address = input("请输入地址：")

if address.endswith('村'):
	print("农业户口")
else:
	print("非农户口")

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

v1 = "1238871"
result = v1.isdecimal()
print(result) # True

# 案例,两个数相加。

v1 = input("请输入值：") # ”666“
v2 = input("请输入值：") # ”999“
if v1.isdecimal() and v2.isdecimal():
	data = int(v1) + int(v2)
	print(data)
else:
	print("请正确输入数字")

v1 = "123"
print(v1.isdecimal()) # True

v2 = "①"
print(v2.isdecimal()) # False

v3 = "123"
print(v3.isdigit()) # True    

v4 = "①"
print(v4.isdigit()) # True    判断是否为整数，不建议使用isdigit

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

data = input("请输入内容：") #张三，张三   （此战三后存在三个空格）
print(data)

msg = " H e ll o啊 ，树哥 "
data = msg.strip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥"

msg = " H e ll o啊，树哥 "
data = msg.lstrip()
print(data) # 将msg左边的空白去掉，得到"H e ll o啊，树哥 "

msg = " H e ll o啊，树哥 "
data = msg.rstrip()
print(data) # 将msg右边的空白去掉，得到" H e ll o啊，树哥"

补充：去除空格、换行符、制表符

# 案例
code = input("请输入4位验证码：") #  FB87 
data = code.strip()
if data == "FB87":
	print('验证码正确')
else:
	print("验证码错误")

【4】去除字符串两边指定的内容

msg = "哥H e ll o啊，树哥"
data = msg.strip("哥")
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树"

msg = "哥H e ll o啊，树哥"
data = msg.lstrip("哥")
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥"

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

msg = "hello world"
data = msg.upper()

print(msg) # hello world
print(data) # 输出为：HELLO WORLD

# 案例
code = input("请输入4位验证码：") #  FB88   fb88 
value = code.upper() #  FB88  
data = value.strip() # FB88

if data == "FB87":
	print('验证码正确')
else:
	print("验证码错误")
  
# 注意事项
"""
code的值"fb88 "
value的值"FB88 "
data的值"FB88"
"""

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

msg = "HELLO WORLD"
data = msg.lower()

print(data) # 输出为：hello world

# 案例
code = input("请输入4位验证码：")
value = code.strip().lower()
if value == "fb87":
	print('验证码正确')
else:
	print("验证码错误")

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

data = "你是个好人，但是好人不合适我"
value = data.replace("好人","善良的人")
print(data)  # "你是个好人，但是好人不合适我"
print(value) # "你是个善良的人，但是善良的人不合适我"

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

data = "张三|root|zhangsan@qq.com"
result = data.split('|') # ["张三","root","zhangsan@qq.com"]
print(data) # "张三|root|zhangsan@qq.com"
print(result) # 输出 ["张三","root","zhangsan@qq.com"] 根据特定字符切开之后保存在列表中，方便以后的操作

# 案例：判断用户名密码是否正确
info = "张三,root"   # 备注：字符串中存储了用户名和密码
user_list = info.split(',')    # 得到一个包含了2个元素的列表 [ "张三" , "root" ]

# user_list[0]
# user_list[1]

user = input("请输入用户名：")
pwd = input("请输入密码：")

if user == user_list[0] and pwd == user_list[1]:
	print("登录成功")
else:
	print("用户名或密码错误")

扩展

# 案例：判断用户名密码是否正确
data = "张三|root|zhangsan@qq.com"
v1 = data.split("|")   # ['张三', 'root', 'zhangsan@qq.com']
print(v1)

v2 = data.split("|", 2) # ['张三', 'root|zhangsan@qq.com']
print(v2)

扩展2

data = "张三,root,zhangsan@qq.com"

v1 = data.rsplit(',')
print(v1) # ['张三', 'root', 'zhangsan@qq.com']

v2 = data.rsplit(',',1)
print(v2) # ['张三,root', 'zhangsan@qq.com']

应用场景：

file_path = "xxx/xxxx/xx.xx/xxx.mp4"

data_list = file_path.rsplit(".",1) # ["xxx/xxxx/xx.xx/xxx","mp4"]
data_list[0]
data_list[1]

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

data_list = ["张三","是","法外狂徒"]
v1 = "_".join(data_list) # 张三_是_法外狂徒
print(v1)

【10】格式化字符串，得到新的字符串

name = "{0}的喜欢很多运动，例如有：{1}、{2} 等"
data = name.format("张三","跑步","游泳")
print(data) # 张三的喜欢很多运动，例如有：跑步、游泳 等
print(name) # "{0}的喜欢很多运动，例如有：{1}、{2} 等"

【11】字符串转换为字节类型

ata = "张三"  # unicode，字符串类型

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

print(v1)  # b'xe5xbcxa0xe4xb8x89'
print(v2)  # b'xd5xc5xc8xfd'

s1 = v1.decode("utf-8") # 张三
s2 = v2.decode("gbk") # 张三
print(s1)
print(s2)

【12】将字符串内容居中、居左、居右展示

v1 = "张三"
# data = v1.center(21, "-")
# print(data) #---------张三---------

# data = v1.ljust(21, "-")
# print(data) # 张三------------------

# data = v1.rjust(21, "-")
# print(data) # ------------------张三

【13】帮助填充0

data = "alex"
v1 = data.zfill(10)
print(v1) # 000000alex

# 应用场景：处理二进制数据
data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"

3.公共功能

【1】相加：字符串 + 字符串

v1 = "世界" + "world"
print(v1)

【2】相乘：字符串 * 整数

data = "你好" * 3
print(data) # 你还你好你好

【3】长度

data = "你好世界"
value = len(data) 
print(value) # 4

【4】获取字符串中的字符，索引

计算机中的索引都是从0开始：

message = "你好世界xy"
#          012 -1-2-3
#           ... -3 -2 -1

#可正取
print(message[0]) # "你"
print(message[1]) # "好"
print(message[2]) # "世"
#可倒着取
print(message[-1]) # y
print(message[-2]) # x
print(message[-3]) # 界

注意：字符串中是能通过索引取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】

message = "你好世界xy"
index = 0
while index  len(message):
	value = message[index]
    print(value)
    index += 1

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

message = "世界是多么的美好"

print(message[0:2]) # "世界"  [0:2]的含义是取字符串的0-2个，包含第0个，不包含第二个
print(message[3:7]) # "多么的美"
print( message[3:] ) # "多么的美好"
print( message[:5] ) # "世界是多么"

print(message[4:-1]) # "么的美"
print(message[4:-2]) # "么的"

print( message[4:len(message)] ) # "么的美好"

注意：字符串中的切片只能读取数据，无法修改数据。【字符串在内部存储时不允许对内部元素修改，想要修改只能重新创建】

生成新的字符串：
message = "你好世界hello"

value = message[:3] + "Python" + message[5:]
print(value) # 你好世Pythonello

【5】步长：跳着去字符串的内容

name = "生活不是电影，生活比电影苦"

print( name[ 0:5:2 ] )   # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】
print( name[ :8:2 ] )    # 输出：生不电，  【区间范围的前面不写则表示起始范围为0开始】、

# print( name[ 2::2 ] )    # 输出：不电，活电苦
# print( name[ 2::3 ] )    # 输出：不影活影

print( name[ 2::3 ] )    # 输出：不电，活电苦 【区间范围的后面不写则表示结束范围为最后】
print( name[ ::2 ] )     # 输出：生不电，活电苦 【区间范围不写表示整个字符串】
print( name[ 8:1:-1 ] )  # 输出：活生，影电是不 【倒序】，此处范围为1-8倒着取

name = "生活不是电影，生活比电影苦"

print(name[8:1:-1])  # 输出：活生，影电是不 【倒序】
print(name[-1:1:-1])  # 输出：苦影电比活生，影电是不 【倒序】

# 面试题：给你一个字符串，请将这个字符串翻转。
value = name[-1::-1]
print(value)  # 苦影电比活生，影电是不活生

# 通过对s切片形成字符串 "ba2"
s ="123a4b5c"
print(s[-3: :-2])

【7】循环

while循环

essage = "伤情最是晚凉天，憔悴厮人不堪言"
index = 0
while index  len(message):
    value = message[index]
    print(value)
    index += 1

for循环

message = "你好世界"
for char in message:
    print(char)
输出：
你
好
世
界

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

range(10) # [0,1,2,3,4,5,6,7,8,9]
range(1,10) # [1,2,3,4,5,6,7,8,9]
range(1,10,2) # [1,3,5,7,9]
range(10,1,-1) # [10,9,8,7,6,5,4,3,2]

for + range

for i in range(10):
    print(i)

message = "你好世界hello"

for i in range(5): # [0,1,2,3,4]
    print(message[i])

输出：
你
好
世
界
h

message = "伤情最是晚凉天，憔悴厮人不堪言"
for i in range(14,-1,-1):
    print(message[i])

#使用for循环实现输出倒计时效果，例如：输出内容依次是："倒计时3秒"，"倒计时2秒"，"倒计时1秒"。
for i in range(3,0,-1):
    text = "倒计时{}秒".format(i)
    print(text)
 
输出：
倒计时3秒
倒计时2秒
倒计时1秒

# 计数，请用户输入一段文本，计算其中“你”出现的次数
text = input("请输入：")
num = 0
for itme in text:
    if itme == "你":
        num += 1
print(num)

应用中，while循环多用于无限制（未知）次数的循环使用
fot循环一般用于一直的循环数量的场景。
两种循环均可使用break和continue关键字

4.类型转换

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

一般情况下，只有整型转字符串才有意义。

5.其他

字符串不可被修改

字符串不可以被修改，但是列表中的元素可以被修改

name = "李小四"

name[1]     # 均为新创建的字符串
name[1:2]

num_list = [11,22,33]

num_list[0]      #取列表中的第0个值
num_list[0] = 666    #列表中的元素可以修改，将列表中的第0个值修改为666

四、列表（list）

1.定义

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

不可变类型：字符串、布尔、整型（已最小，内部数据无法进行修改）
可变类型：列表（内部数据元素可以修改）

2. 独有功能

字符串，不可变，即：创建好之后内部就无法修改。【独有功能都是新创建一份数据】

 
  name = "张三"
  data = name.upper()
  print(name)
  print(data)
输出结果：
张三
张三

列表，可变，即：创建好之后内部元素可以修改。【独有功能基本上都是直接操作列表内部，不会创建新的一份数据】

  user_list = ["游泳","跑步"]
  user_list.append("跳绳")
  
  print(user_list) # ["游泳","跑步","跳绳"]
改：
 user_list = ["游泳", "跑步"]
user_list[1] = "跳绳"
print(user_list)

输出：['游泳', '跳绳']

列表中的常见独有功能如下：

【1】追加，在原列表中尾部追加值

data_list = []

v1 = input("请输入姓名")
data_list.append(v1)

v2 = input("请输入姓名")
data_list.append(v2)

print(data_list) # ["张三","李四"]

# 案例1
user_list = []

while True:
    user = input("请输入用户名(Q退出)：")
    if user == "Q":
        break
    user_list.append(user)
    
print(user_list)

【2】批量追加，将一个列表中的元素逐一添加另外一个列表。

tools = ["搬砖","菜刀","榔头"]
weapon = ["AK47","M6"]
#tools.extend(weapon) # weapon中的值逐一追加到tools中
#print(tools) # ["搬砖","菜刀","榔头","AK47","M6"]

weapon.extend(tools)
print(tools) # ["搬砖","菜刀","榔头"]
print(weapon) # ["AK47","M6","搬砖","菜刀","榔头"]

# 等价于(扩展)
weapon = ["AK47","M6"]
for item in weapon:
    print(item)

# 输出：
#  AK47
#  M6
tools = ["搬砖","菜刀","榔头"]
weapon = ["AK47","M6"]
for item in weapon:
    tools.append(item)  
print(tools) # ["搬砖","菜刀","榔头","AK47","M6"]

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

user_list = ["跑步","游泳","跳绳"]
user_list.insert(0,"打球")
user_list.insert(2,"跳舞")
print(user_list)
输出：
['打球', '跑步', '跳舞', '游泳', '跳绳']

# 案例
name_list = []
while True:
    name = input("请输入购买火车票用户姓名（Q/q退出）：")
    if name.upper() == "Q":
        break
    if name.startswith("刁"):
        name_list.insert(0, name)
    else:
        name_list.append(name)
print(name_list)

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

user_list = ["跑步","游泳","跳绳"]
user_list.remove("跳绳")
print(user_list)

#输出：['跑步', '游泳']

# 案例：自动抽奖程序
import random

data_list = ["手机", "电脑", "奖金", "键盘", "鼠标"]

while data_list:
    name = input("自动抽奖程序，请输入自己的姓名：")

    # 随机从data_list抽取一个值出来
    value = random.choice(data_list) # "电脑"
    print( "恭喜{}，抽中{}.".format(name, value) )
    
    data_list.remove(value) # "电脑"

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

user_list = ["手机", "电脑", "奖金", "键盘", "鼠标"]
#               0       1      2      3       4
user_list.pop(1)
print(user_list) #  [""手机", "奖金", "键盘", "鼠标"]

user_list.pop()
print(user_list) # ['手机', '奖金', '键盘']

item = user_list.pop(1)
print(item) #奖金
print(user_list) # ['手机', '键盘']

【6】清空原列表

user_list = ["手机", "电脑", "奖金", "键盘", "鼠标"]
user_list.clear()
print(user_list) # []

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

user_list = ["手机", "电脑", "奖金", "键盘", "鼠标"]
#               0       1      2       3      4
if "鼠标" in user_list:
	index = user_list.index( "鼠标")
	print(index) # 4
else:
    print("不存在")

【8】列表元素排序

# 数字排序
num_list = [11, 22, 4, 5, 11, 99, 88]
print(num_list)
num_list.sort()  # 让num_list从小到大排序
num_list.sort(reverse=True)  # # 让num_list从大到小排序
print(num_list)

# 字符串排序
user_list = ["手机", "1","电脑", "奖金", "键盘", "鼠标" ]
print(user_list)
user_list.sort()
print(user_list)
# 输出：
#['手机', '1', '电脑', '奖金', '键盘', '鼠标']
#['1', '奖金', '手机', '电脑', '键盘', '鼠标']

注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）。

【9】反转原列表

user_list = ["手机", "电脑", "奖金", "键盘", "鼠标"]
user_list.reverse()
print(user_list)

# 输出：['鼠标', '键盘', '奖金', '电脑', '手机']

3.公共功能

【1】相加，两个列表相加获取生成一个新的列表。

data = ["赵四","刘能"] + ["宋晓峰","范德彪"]
print(data) # ["赵四","刘能","宋晓峰","范德彪"]

v1 = ["赵四","刘能"]
v2 = ["宋晓峰","范德彪"]
v3 = v1 + v2
print(v3) # ["赵四","刘能","宋晓峰","范德彪"]

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

data = ["赵四","刘能"] * 2
print(data) # ["赵四","刘能","赵四","刘能"]

v1 = ["赵四","刘能"]
v2 = v1 * 2
print(v1) # ["赵四","刘能"]
print(v2) # ["赵四","刘能","赵四","刘能"]

【3】运算符in包含，也可使用not in

由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。

user_list = ["手机", "电脑", "奖金", "键盘"] 
result = "奖金" in user_list
# result = "奖金" not in user_list
print(result) #  True

if "奖金" in user_list:
    print("在，把他删除")
    user_list.remove("奖金")
else:
    print("不在")

注意：列表检查元素是否存在时，是采用逐一比较的方式，效率会比较低。

【4】获取长度

user_list = ["手机", "电脑", "奖金"] 
print( len(user_list) )

# 输出：3

【5】索引，一个元素的操作

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
               0         1        2                          
print( user_list[0] )
print( user_list[2] )
print( user_list[3] ) # 报错

user_list = ["范德彪","刘华强",'尼古拉斯赵四']
user_list[0] = "武沛齐"
print(user_list) # ["武沛齐","刘华强",'尼古拉斯赵四']

# 删
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
del user_list[1]      #根据索引删除，拿不到删除的值

user_list.remove("刘华强")     #通过值去删除
ele = user_list.pop(“1”)     
ele = user_list.pop(1)     #也是根据索引删除，但是可以拿到删除的值

注意：超出索引范围会报错。
提示：由于字符串是不可变类型，所以他只有索引读的功能，而列表可以进行读、改、删

【6】切片，多个元素的操作（很少用）

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']

print( user_list[0:2] ) # ["范德彪","刘华强"]   前取后不取
print( user_list[1:] )
print( user_list[:-1] )

# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]


user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]  使用超过文本长度的修改，不会报错，会添加在文本的最后。

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']
使用负数修改，不会报错，修改内容会添加到前边。

# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:] 
print(user_list)  # 输出   ["范德彪"]  也可通过切片的形式删除

【7】步长

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
#              0        1        2          3       4
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

输出：
['刘华强', '宋小宝']
['范德彪', '尼古拉斯赵四', '刘能']
['刘华强', '宋小宝']
['刘能', '宋小宝', '尼古拉斯赵四']

# 案例：实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]    #会形成一个新的数据
print(new_data)


data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()      # 是将原数据进行翻转 
print(data_list)

注意：reverse是列表的独有功能，不能将字符串翻转，且字符串是不可变的，字符串的翻转只能通过切片或者for循环

【8】for循环

列表循环的两种方式

# 【1】
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
	print(item)

# 【2】
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for index in range( len(user_list) ):
    item = user_list[index]
    print(item)

输出：
范德彪
刘华强
尼古拉斯赵四
宋小宝
刘能

切记，循环的过程中对数据进行删除会踩坑【面试题】。

# 错误方式， 有坑，结果不是你想要的。
# 判断列表中的元素是不是以刘开头，若是，删除该元素
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)
        
print(user_list)

#输出结果：“['范德彪', '刘尼古拉斯赵四', '宋小宝']”    还是存在刘开头的元素，列表第一次开头拿取的是第0个元素，第二次拿取的是第1个元素，若是一边拿取一遍删除，第二次就会跳过列表中新的第0个元素

千万不要再循环过程中，边循环获取列表中的数据，边删除列表中的数据，会导致列表循环中拿乱元素

# 正确方式，倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
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.类型转换

int、bool无法转换成列表
str，可以转换为列表，但是意义不大

  name = "李小四"
  
  data = list(name)  # ['李', '小', '四']
  print(data)

其他，元组、集合可转换为列表

  v1 = (11,22,33,44) # 元组
  vv1 = list(v1)     # 列表 [11,22,33,44]   转换原因：元组中的元素是不能被修改
  
  v2 = {"张三","李四","王五"} # 集合
  vv2 = list(v2) # 列表 ["张三","李四","王五"]

5.嵌套

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

data = [ "谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝" ]

对于嵌套的值，可以根据之前学习的索引知识点来进行学习，例如：

data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]

print( data[0] ) # "谢广坤"
print( data[1] ) # ["海燕","赵本山"]
print( data[0][2] ) # "坤"
print( data[1][-1] ) # "赵本山"

data.append(666)
print(data) # [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝",666]

data[1].append("谢大脚")
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],"宋小宝",666 ]


del data[-2]
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],666 ]


data[-2][1] = "alex"
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,"alex",33,44],666 ]


data[1][0:2] = [999,666]
print(data) # [ "谢广坤",[999,666,"谢大脚"],True,[11,"alex",33,44],666 ]

# 创建用户列表
#    用户列表应该长： [ ["alex","123"],["eric","666"] ]

#方法一：
# user_list = [["alex","123"],["eric","666"],]
# user_list.append(["alex","123"])
# user_list.append(["eric","666"])

# 方法二：
user_list = []
while True:
    user = input("请输入用户名：")
    pwd = input("请输入密码：")

    data = []
    data.append(user)
    data.append(pwd)
    
    user_list.append(data)


# 方法三：简化版
user_list = []
while True:
    user = input("请输入用户名(Q退出)：")
    if user == "Q":
        break
    pwd = input("请输入密码：")
    data = [user,pwd]
    user_list.append(data)

print(user_list)

五、元组类型（tuple）

1.定义

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

v1 = (11,22,33)
v2 = ("李杰","Alex")
v3 = (True,123,"Alex",[11,22,33,44])    元组不可变，但是元组内部的列表可以增加、减少

建议：若元组中只有一个元素，建议在元组的最后多加一个逗 v3 = (“李杰”,“Alex”,)

d1 = (1)  # 1    不加逗号，若该元祖只有一个数字，会被当成一个整形处理，而不是一个元组
d2 = (1,) # (1,)   加上逗号，会当成一个元组处理，故建议，在元组结尾添加一个逗号

d3 = (1,2)
d4 = (1,2)

注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。

# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别？
v1和v2都相当于一个整形，都等于1，v3是一个元组
2. 比较值 v1 = ( (1),(2),(3) ) 和 v2 = ( (1,) , (2,) , (3,),) 有什么区别？
             v1= (1,2,3)，v2是一个大元组套了三个小元组

2. 独有功能

无

3.公共功能

【1】相加，两个列表相加获取生成一个新的列表。元组也可以。

data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) # ("赵四","刘能","宋晓峰","范德彪")

v1 = ("赵四","刘能")
v2 = ("宋晓峰","范德彪")
v3 = v1 + v2
print(v3) # ("赵四","刘能","宋晓峰","范德彪")

【2】相乘，列表*整型将列表中的元素再创建N份并生成一个新的列表。元组也可。

data = ("赵四","刘能") * 2
print(data) # ("赵四","刘能","赵四","刘能")

v1 = ("赵四","刘能")
v2 = v1 * 2
print(v1) # ("赵四","刘能")
print(v2) # ("赵四","刘能","赵四","刘能")

【3】获取长度

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( len(user_list) )

【4】索引

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )   索引超出长度，会报错

【5】切片

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )

【6】步长

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

# 字符串 & 元组。
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
data = user_list[::-1]

# 列表
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data = user_list[::-1]

user_list.reverse()

注意：不论是元组还是列表，步长、切片等功能均是会生成一个新的

【7】For循环

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
	print(item)

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
 if item == '刘华强':
	 continue
 print(name)

目前：只有 str、list、tuple 可以被for循环。 “xxx” [11,22,33] (111,22,33)

# len + range + for + 索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for index in range(len(user_list)):
    item = user_list[index]
    print(item)

4.类型转换

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

data = tuple(其他)

# str / list

name = "张三三"
data = tuple(name)
print(data) # 输出 ("张","三","三")

练习：

name = ["武沛齐",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("武沛齐",18,"pythonav")

5.其他

【1】嵌套

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

tu = ( '你好', '世界', ('hello world','HELLO WORLD') )
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
tu5 = tu[2][1][3]

print(tu1)   # 你好
print(tu2)   # 世界
print(tu3)   # hello world
print(tu4)   # HELLO WORLD
print(tu5)   # L

练习题2：

data = ("123",666,[11,22,33], ("alex","李杰",[999,666,(5,6,7)]) )

# 1.将 “123” 替换成 9   报错

# 2.将 [11,22,33] 换成 "武沛齐"    报错

# 3.将 11 换成 99
data[2][0] = 99
print(data)  # ("123",666,[99,22,33], ("alex","李杰",[999,666,(5,6,7)]) )

# 4.在列表 [11,22,33] 追加一个44
data[2].append(44)
print(data) # ("123",666,[11,22,33,44], ("alex","李杰",[999,666,(5,6,7)]) )

练习题3：动态的创建用户并添加到用户列表中。

# 创建用户 5个
# user_list = [] # 用户信息
user_list = [ ("alex","132"),("admin","123"),("eric","123") ]

while True:
    user = input("请输入用户名：")
    if user == "Q":
        brek
    pwd = input("请输入密码：")
    item = (user,pwd,)
    user_list.append(item)
    
# 实现：用户登录案例
print("登录程序")
username = input("请输入用户名：")
password = input("请输入密码：")

is_success = False

for item in user_list:
    # item = ("alex","132")   ("admin","123")    ("eric","123")
    if username == item[0] and password == item[1]:
        is_success = True
        break

if is_success:
    print("登录成功")
else:
    print("登录失败")

# 花色列表
color_list = ["红桃", "黑桃", "方片", "梅花"]

# 牌值
num_list = []
for num in range(1, 14):
    num_list.append(num)

result = []
# 请根据以上的花色和牌值创建一副扑克牌（排除大小王）
# 最终result的结果格式为： [ ("红桃",1), ("红桃",2) ... ]
for color in color_list:
    for num in num_list:
        text = color,num
        result.append(text)
print(result)

六、字典类型（dict）

1.定义

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

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

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

无序（在Python3.6+字典就是有序了，之前的字典都是无序。）

创建字典的方式：

v1 = {}
v2 = dict()

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

info = { 
    "age":12, 
    "status":True,  
    "name":"wupeiqi",   
    "hobby":['篮球','足球']  
}

字典中对键值得要求：

键：必须可哈希。目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。（集合也一样）
值：任意类型。
当我们想要表示一组固定信息时，用字典可以更加的直观，例如：

# 没问题的字典：
data_dict = {
	"武沛齐":29,
	 True:5,
	123:5,
    (11,22,33):["alex","eric"]
}

# 不合法
v1 = {
    [1, 2, 3]: '周杰伦',
    "age" : 18
} 
v2 = {
    {1,2,3}: "哈哈哈",
    'name':"alex"
} 

v3 = {
    {"k1":123,"k2":456}: '呵呵呵',
    "age":999
}

data_dict = {
    1: 29,
    True: 5
}
print(data_dict) # {1: 5}   在字典中1和true是一样的

字典使用厂家爱给你：

# 用户列表
user_list = [ ("alex","123"), ("admin","666") ]

# 用户列表
user_list = [ {"name":"alex","pwd":"123"}, {"name":"eric","pwd":"123"} ]   #定义用户列表采用字典的方式更加的清晰、规范、直观

2. 独有功能

【1】获取值

info = { 
    "age":12, 
    "status":True, 
    "name":"张三",
    "data":None
}

data1 = info.get("name")
print(data1) # 输出：张三

data2 = info.get("age")
print(data2) # 输出：12

data = info.get("email") # 键不存在，默认返回 None

"""
if data == None:
    print("此键不存在")
else:
    print(data)

if data:
    print(data)
else:
    print("键不存在")
"""

"""
# 字典的键中是否存在 email
if "email" in info:
    data = info.get("email")
    print(data)
else:
	print("不存在")
"""

data = info.get("hobby",123)
print(data) # 输出：123    如果这个健不存在，不返回None,返回123

# 案例：
user_list = {
    "wupeiqi": "123",
    "alex": "uk87",
}

username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)

if pwd:
    if password == pwd:
        print("登录成功")
	else:
        print("密码错误")
else:
    print("用户名不存在")

# 上述案例另外一种写法（建议使用此种方法）：
user_list = {
    "wupeiqi": "123",
    "alex": "uk87",
}

username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)

if not pwd:
    print("用户名不存在")
else:
    if password == pwd:
        print("登录成功")
	else:
        print("密码错误")

写代码的准则：简单的逻辑处理放在前面；复杂的逻辑放在后面。

【2】所有的健

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.keys()
print(data) # 输出：dict_keys(['age', 'status', 'name', 'email'])    py2 -> ['age', 'status', 'name', 'email']     有点像列表但是并不是

result = list(data)    可直接转换为列表，但是一般情况下不会做这样的转换
print(result) # ['age', 'status', 'name', 'email']

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

# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():
    print(ele)

# 也可判断该元素是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
# info.keys() # dict_keys(['age', 'status', 'name', 'email'])
if "age" in info.keys():
    print("age是字典的键")
else:
    print("age不是")

【3】所有的值

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.values()

print(data) # 输出：dict_values([12, True, 'wupeiqi', 'xx@live.com'])

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

xxxxxxxxxx # 循环info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}for val in info.values():    print(val)

# 也可以是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
if 12 in info.values():
    print("12是字典的值")
else:
    print("12不是")

【4】所有的键值

info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()

print(data) # 输出 dict_items([ ('age', 12),  ('status', True),  ('name', 'wupeiqi'),  ('email', 'xx@live.com')  ])    高仿列表中放的是一个一个的元组

for item in info.items():
    print(item[0],item[1]) # item是一个元组 (键，值)

for key,value in info.items():
    print(key,value) # key代表键，value代表值，将键值从元组中直接拆分出来了。

# 也可判断某一个值是否在这个键值中：
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()

if ('age', 12) in data:
    print("在")
else:
    print("不在")

以下四个功能使用较少：

【4】设置值

data = {
    "name": "张三",
    "email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data)  # {'name': '张三', 'email': 'xxx@live.com', 'age': 18}

data.setdefault("name", "alex")
print(data)  # {'name': '张三', 'email': 'xxx@live.com', 'age': 18}

【6】更新字典键值对

info = {"age":12, "status":True}
info.update( {"age":14,"name":"张三"} )   # info中没有的键直接添加；有的键则更新值
print(info) # 输出：{"age":14, "status":True,"name":"张三"}

【7】移除指定键值对

info = {"age":12, "status":True,"name":"武沛齐"}

data = info.pop("age")

print(info) # {"status":True,"name":"武沛齐"}
print(data) # 12

【8】按照顺序移除（后进先出）

info = {"age":12, "status":True,"name":"张三"}
data = info.popitem() # ("name","张三" )

print(info) # {"age":12, "status":True}
print(data) # ("name","张三")

py3.6后，popitem移除最后的值。
py3.6之前，popitem随机删除。

# 练习题
""" 
结合下面的两个变量 header 和 stock_dict实现注意输出股票信息，格式如下：
	SH601778，股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。
    SH688566，股票名称:吉贝尔、当前价:...               。
	...
"""
header = ['股票名称', '当前价', '涨跌额']

stock_dict = {
    'SH601778': ['中国晶科', '6.29', '+1.92'], 
    'SH688566': ['吉贝尔', '52.66', '+6.96'], 
    'SH688268': ['华特气体', '88.80', '+11.72'], 
    'SH600734': ['实达集团', '2.60', '+0.24']

3.公共功能

【1】求`并集`（Python3.9新加入）

v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}

v3 = v1 | v2
print(v3) # {'k1': 1, 'k2': 22, 'k3': 33}

【2】长度

info = {"age":12, "status":True,"name":"张三三"}
data = len(info)
print(data) # 输出：3

【3】是否包含

info = { "age":12,  "status":True,"name":"张三" }
v1 = "age" in info    # 判断一个键是否在字典当中
print(v1)

# 上述判断等同于：
v2 = "age" in info.keys()
print(v2)

if "age" in info:
    pass
else:
    pass

info = {"age":12, "status":True,"name":"张三"}
v1 = "李四" in info.values()
print(v1)

【4】索引（键）

字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值 。

info = { "age":12,  "status":True, "name":"张三"}

print( info["age"] )  	    # 输出：12
print( info["name"] )		# 输出：zgns按
print( info["status"] )	    # 输出：True
print( info["xxxx"] )   	# 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）

value = info.get("xxxxx") # None   get也可以用来取值，推荐使用该方法取值，用此方法，若是该键不存在，不会报错，只会返回一个None
print(value)

【5】根据键修改值和添加值和删除键值对

上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作

添加值：

info = {"age":12, "status":True,"name":"张三"}

info["gender"] = "男"

print(info) # 输出： {"age":12, "status":True,"name":"张三","gender":"男"}

修改值：

info = {"age":12, "status":True,"name":"张三"}

info["age"] = "18" 

print(info) # 输出： {"age":"18", "status":True,"name":"张三"}

删除值:

info = {"age":12, "status":True,"name":"张三"}
del info["age"]  # 删除info字典中键为age的那个键值对（键不存在则报错）

print(info) # 输出： {"status":True,"name":"张三"}

info = {"age": 12, "status": True, "name": "张三"}
if "agea" in info:

    # del info["age"]
    data = info.pop("age")
    print(info)
    print(data)
else:
    print("键不存在")

【6】for循环

由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；

info = {"age":12, "status":True,"name":"武沛齐"}
for item in info:
	print(item)  # 所有键

info = {"age":12, "status":True,"name":"武沛齐"}
for item in info.key():
	print(item)

info = {"age":12, "status":True,"name":"武沛齐"}
for key,value in info.items():
	print(key,value)

4.类型转换

想要转换为字典.

v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )

print(v) # { "k1":"v1", "k2":"v2" }

info = { "age":12, "status":True, "name":"张三" }

v1 = list(info)        # ["age","status","name"]

v2 = list(info.keys()) # ["age","status","name"]

v3 = list(info.values()) # [12,True,"张三"]

v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","z") ]

5.其他

【1】速度快

info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
for "alex" in info:
    print("在"）

info = {
    "alex":["肝胆","铁锤"], 
	"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")

【6】嵌套

字典的键必须可哈希（list/set/dict不可哈希）。

info = {
    (11,22):123
}

# 错误
info = {
    (11,[11,22,],22):"alex"
}

字典的值可以是任意类型。

info = {
    "k1":{12,3,5},
	"k2":{"xx":"x1"}
}

字典的键和集合的元素在遇到布尔值和 1、0 时，需注意重复的情况。
元组的元素不可以被替换。

七、集合类型（set）

1.定义

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

集合的特性：

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

v1 = {11,22,33,44}
v1.add(55)
print(v1) # {11,22,33,44,55}

不允许数据重复。

v1 = {11,22,33,44}
v1.add(22)
print(v1) # {11,22,33,44}

使用场景：想要维护一大堆不重复的数据时，就可以用它。比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。
注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。

# 定义列表
v1 = []
v11 = list()

# 定义元组
v2 = ()
v22 = tuple()    

 # 定义空集合
v3 = set() 

# 定义空字典
v4 = {} 
v44 = dict()

2. 独有功能

【1】添加元素

若集合中已经有该元素，则不会再次添加进去：

data = {"张三", '李四', "王五"}
data.add("刘六")
print(data)

输出：
{'王五', '李四', '刘六', '张三'}

data = set()
data.add("张三")
data.add("李四")
print(data)

输出：
{'张三', '李四'}

【2】删除元素

data = {"张三", '李四', "王五","刘六"}
data.discard("刘六")
print(data)

输出：
{'张三', '李四', '王五'}

【3】交集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}

s4 = s1.intersection(s2) # 取两个集合的交集 ，方法一
print(s4) # {"⽪⻓⼭"}

s3 = s1 & s2   			  # 取两个集合的交集 ，方法二
print(s3)

【4】并集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s4 = s1.union(s2) 		# 取两个集合的并集  {"刘能", "赵四", "⽪⻓⼭","刘科⻓", "冯乡⻓", }
print(s4)
s3 = s1 | s2   			# 取两个集合的并集
print(s3)

【5】差集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s4 = s1.difference(s2) 		# 差集，s1中有且s2中没有的值 {"刘能", "赵四"}
s6 = s2.difference(s1)   	# 差集，s2中有且s1中没有的值 {"刘科⻓", "冯乡⻓"}

s3 = s1 - s2   			   # 差集，s1中有且s2中没有的值
s5 = s2 - s1   			   # 差集，s2中有且s1中没有的值

print(s5,s6)

3.公共功能

【1】减，计算差集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}

s3 = s1 - s2 
s4 = s2 - s1
print(s3)
print(s4)

【2】&，计算交集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 & s2
print(s3)

【3】，计算并集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 | s2
print(s3)

【4】长度

v = {"刘能", "赵四", "尼古拉斯"}
data = len(v)
print(data)

【5】for循环

集合无序，所以要通过for循环展示该集合中的元素

v = {"刘能", "赵四", "尼古拉斯"}
for item in v:
	print(item)

4.类型转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。

提示：int/list/tuple/dict都可以转换为集合。

字符串转换为集合（不常用）


v1 = "武沛齐"
v2 = set(v1)
print(v2) # {"武","沛","齐"}

列表转换为集合

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}

提示：这其实也是去重的一个手段。

元组转换为集合

data = {11,22,33,3,99}

v1 = list(data) # [11,22,33,3,99]

v2 = tuple(data) # (11,22,33,3,99)

也可以去重

5.其他

【1】元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。
目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。
总结：集合的元素只能是 int、bool、str、tuple 。

注意：

转换成功

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}

转换失败
集合当中存储了一个列表，不可哈希，所以转换会出现报错，注意此坑

v1 = [11,22,["alex","eric"],33]
v2 = set(v1) # 报错 
print(v2)

【2】查找速度特别快

因存储原理特殊，集合的查找效率非常高（数据量大了才明显）。

低，列表、元组一个一个比对，比较慢

user_list = ["武沛齐","alex","李璐"]
if "alex" in user_list:
    print("在")
else:
    print("不在")
    
    
user_tuple = ("武沛齐","alex","李璐")
if "alex" in user_tuple:
    print("在")
else:
    print("不在")

效率高，集合效率高

user_set = {"武沛齐","alex","李璐"}
if "alex" in user_set:
    print("在")
else:
    print("不在")

【3】对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	`v=[]或v=list()`
tuple	否	是	无	是	tuple(其他)	`v=()或v=tuple()`
set	是	否	可哈希	否	set(其他)	`v=set()`

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # 最终都会是{True}

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

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}

练习题：

写代码实现

 v1 = {'alex','武sir','肖大'}
   v2 = []


   # 循环提示用户输入，如果输入值在v1中存在，则追加到v2中，如果v1中不存在，则添加到v1中。（如果输入N或n则停止循环）
   while True:
       name = input("请输入姓名(N/n退出)：")
       if name.upper() == "Q":
           break
       if name in v1:
           v2.append(name)
   	else:
           v1.add(name)

下面那些值不能做集合的元素

   ""
   0
   [11,22,33]   # 不能
   []           # 不能
   (123)
   {1,2,3}      # 不能

模拟用户信息录入程序，已录入则不再创建。

   user_info_set = set()
   
   while True:
       name = input("请输入姓名：")
       age = input("请输入年龄：")
   	item = (name,age,)
       if item in user_info_set:
           print("该用户已录入")
   	else:
       	user_info_set.add(item)

给你个列表去重。

   v = [11,22,11,22,44455]
   data = set(v) # {11,22,44455}
   result = list(data) # [11,22,44455]

None类型

Python的数据类型中有一个特殊的值None，意味着这个值啥都不是或表示空。相当于其他语言中 null作用一样。

在一定程度上可以帮助我们去节省内存。例如：

v1 = None
v2 = None
..
v1 = [11,22,33,44]
v2 = [111,22,43]

注意：暂不要考虑Python内部的缓存和驻留机制。
目前所有转换为布尔值为False的值有：

0
""
[] or list()
() or tuple()
set()
None

if None:     #代表if False 
    pass

八、浮点类型（float）

1.定义

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

v1 = 3.14
v2 = 9.89

2.其他

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

v1 = 3.14 
data = int(v1)
print(data) # 3

想要保留小数点后N位

v1 = 3.1415926
result = round(v1,3)   可进行四舍五入
print(result) # 3.142

浮点型的坑（所有语言中）

底层原理视频：https://www.bilibili.com/video/BV1354y1B7o1/

在项目中如果遇到精确的小数计算应该怎么办？
可使用decimal模块

import decimal

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

作业：

循环提示用户输入，并将输入内容添加到字典中（如果输入N或n则停止循环）

info = {}
while True:
    text = input("请输入内容：")
    if text.upper() == "N":
        break
    date_list = text.split("|")
    info[date_list[0]] = date_list[1]

print(info)

将字典的键和值分别追加到 key_list 和 value_list 两个列表中

key_list = []
value_list = []
info = {'k1':'v1','k2':'v2','k3':'v3'}
for key,value in info.items():
    key_list = info.keys()
    value_list = info.values()

key_list = list(key_list)
value_list = list(value_list)
print(key_list)
print(value_list)


输出：
['k1', 'k2', 'k3']
['v1', 'v2', 'v3']

有字符串”k: 1|k1:2|k2:3 |k3 :4″ 处理成字典 {‘k’:1,‘k1’:2…}

str = "k: 1|k1:2|k2:3  |k3 :4"
result = {}
list = str.split('|')
for item in list:
    list1 = item.split(":")
    result[list1[0]] = int(list1[1])
print(result)

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: 机器人控制系统学习和研究中数学的重要性

其实具备科学思维的方式非常非常难，很多情况下脑海中并非客观事实，而是充满了幻觉。如果在各种AI工具中问及这样的问题，会得到类似如下回复：机器人控制系统学习和研究中数学的重要性主要体现在以下几个方面：机器人运动学：机器人控制系统需要处理机器人的运动…

一、整形（int）

1.定义

2. 独有功能

3.公共功能

4.类型转换

5. 其他

【1】整形、长整形

【2】地板除

二、布尔类型（bool）

1.定义

2. 独有功能

3.公共功能

4.类型转换

5.其他

做条件自动转换

三、字符串（str）

1.定义

2. 独有功能（18/48）

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

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

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

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

补充：去除 空格、换行符、制表符

【4】去除字符串两边指定的内容

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

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

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

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

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

【10】格式化字符串，得到新的字符串

【11】字符串转换为字节类型

【12】将字符串内容居中、居左、居右展示

【13】帮助填充0

3.公共功能

【1】相加：字符串 + 字符串

【2】相乘：字符串 * 整数

【3】长度

【4】获取字符串中的字符，索引

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

【5】步长：跳着去字符串的内容

【7】循环

4.类型转换

5.其他

字符串不可被修改

四、列表（list）

1.定义

2. 独有功能

【1】追加，在原列表中尾部追加值

【2】批量追加，将一个列表中的元素逐一添加另外一个列表。

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

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

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

【6】清空原列表

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

【8】列表元素排序

【9】反转原列表

3.公共功能

【1】相加，两个列表相加获取生成一个新的列表。

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

【3】运算符in包含，也可使用not in

【4】获取长度

【5】索引，一个元素的操作

【6】切片，多个元素的操作（很少用）

【7】步长

【8】for循环

4.类型转换

5.嵌套

五、元组类型（tuple）

1.定义

2. 独有功能

3.公共功能

【1】相加，两个列表相加获取生成一个新的列表。元组也可以。

【2】相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。元组也可。

【3】获取长度

【4】索引

【5】切片

【6】步长

【7】For循环

4.类型转换

5.其他

补充：去除空格、换行符、制表符

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

【2】相乘，列表*整型将列表中的元素再创建N份并生成一个新的列表。元组也可。

【1】求`并集`（Python3.9新加入）

【5】根据键修改值和添加值和删除键值对

【2】查找速度特别快