数据类型内置方法

1. 整型（int）

1.1 独有功能

v1 = 5
print(bin(v1))  # 0b101
# 调用v1（int）的独有功能，获取v1的二进制有多少个位组成。
result1 = v1.bit_length()
print(result1)  # 3

v2 = 10
print(bin(10))  # 0b1010
# 调用v2（int）的独有功能，获取v2的二进制有多少个位组成。
result2 = v2.bit_length()
print(result2)  # 4

1.2 转换

# 10 --> 2, 8，16
v1 = 100
print(bin(v1))  # 通过bin函数将v1转换为二进制字符串
print(oct(v1))  # 通过bin函数将v1转换为八进制字符串
print(hex(v1))  # 通过hex函数将v1转换为十六进制字符串

# 2，8，16  --> 10
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表示十六进制）

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

# 浮点型（小数）
v1 = int(8.7) # 8

2.浮点型

2.1 转换

# 在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉。
v1 = 3.14 
data = int(v1)
print(data) # 3

2.2 四舍五入（保留n位小数）

python可通过round对浮点型数据做四舍六入，对于距相同，即0.5或者0.05这样的舍入round函数在python3.5以后的文档中表示为 “values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice.” 如果距离两边一样远，会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2。
示例如下：

print(round(1.5))  # 2
print(round(2.3))  # 2

但是，受浮点数精度影响，round经常会出现与Python官方文档不同的结果，
如下：

>>> round(2.675, 2)
2.67

上述示例中，如果按照官方文档中去计算，结果必然是2.68，但是结果却是2.67。

2.3 浮点数的坑，精度问题（所有语言）

我们知道在机器中浮点数不一定能精确表达，因为换算成一串1和0后可能是无限位数的，机器已经做出了截断处理。所以上述问题中在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离2.67要更近一点点，所以保留两位小数时就近似到了2.67。
浮点精度问题示例如下：

v1 = 0.1
v2 = 0.2
print(v1 + v2)
# 0.30000000000000004

所以除非对精确度没什么要求，否则尽量避开用round()函数。近似计算我们还有其他的选择：
使用math模块中的一些函数，比如math.ceiling（天花板除法）。
python自带整除，python2中是/，3中是//，还有div函数。
字符串格式化可以做截断使用，例如 “%.2f” % value（保留两位小数并变成字符串……如果还想用浮点数请披上float()的外衣）。
当然，对浮点数精度要求如果很高的话，请用嘚瑟馍，不对不对，请用decimal模块。

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

3. 字符（str）

方法	功能	用法
startswitch	判断字符是否以XX开头	str.startswith(‘XX’)
endswith	判断字符是否以XX结尾	str.startswith(‘XX’)
isdecimal	判断字符是否为十进制数	str.isdecimal( )
isdigit	判断字符是否为纯数字(有小问题)	str.isdigit( )
strip	去除字符串两边的空字符（指定字符）	str.strip( 指定字符 )
lstrip	去除字符串左边的空字符（指定字符）	str.strip( 指定字符 )
rstrip	去除字符串右边的空字符（指定字符）	str.strip( 指定字符 )
lower	字符串大写转小写	str.lower( )
upper	字符串小写转大写	str.upper( )
replace	字符串中内容替换	str.replace(“旧内容”，“新内容”)
split	字符串切割	str.split( ‘切割字符’)
rsplit	字符串切割,从右向左	str.rsplit( ‘切割字符’)
join	字符串拼接	拼接字符.join(列表)
format	字符串格式化	带{}占位的串.format(内容)
encode	字符串转字节	str.encode( )
decode	字节转字符串	str.decode( )
center	字符串内容居中	str.center(位数，位数不足的补充字符)
ljust	字符串内容居左	str.ljust(位数，位数不足的补充字符)
rjust	字符串内容居右	str.rjust(位数，位数不足的补充字符)
zfill	0填充	str.zfill(位数)
len	统计字符个数	len(str)
str	转换为字符串	str( 数字/列表等)

3.1 独有功能

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

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

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

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

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

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

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

# 案例,两个数相加。

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

ps:isdigit()也具有类似功能，但是会有不同，如下：

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

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

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

v4 = "①"
print(v4.isdigit()) # True

4. 去除字符串两边的 空格、换行符、制表符，得到一个新字符串
   strip方法，（）中写字符串即去掉指定字符串

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啊，树先生"

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

msg = "my name is oliver queen"
data = msg.upper()

print(msg) # my name is oliver queen
print(data) # 输出为：MY NAME IS OLIVER QUEEN

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

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

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

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

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

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

拓展：

data = "antony|root|antony@qq.com"
v1 = data.split("|")   # ['antony', 'root', 'antony@qq.com']
print(v1)

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

data = "antony,root,antony@qq.com"

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

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

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

字符串拼接，得到一个新的字符串
data_list = ["apple","是","banana"]
v1 = "_".join(data_list) # apple_是_banana
print(v1)

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

name = "{0}喜欢很多行业，例如有：{1}、{2} 等"
data = name.format("老王","保安","保洁")
print(data) # 老王喜欢很多行业，例如有：保安、保洁 等
print(name) # "{0}喜欢很多行业，例如有：{1}、{2} 等"

name = "{}喜欢干很多行业，例如有：{}、{} 等"
data = name.format("老王","保安","保洁")
print(data) # 老王喜欢很多行业，例如有：保安、保洁 等

name = "{name}喜欢很多行业，例如有：{h1}、{h2} 等"
data = name.format(name="老王",h1="保安",h2="保洁")
print(data) # 老王喜欢很多行业，例如有：保安、保洁 等

11. 字符串转换为字节类型

data = "嫂子"  # unicode，字符串类型

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

print(v1)  # b'\xe5\xab\x82 \xe5\xad\x90'
print(v2)  # b'\xc9\xa9 \xd7\xd3'

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 = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"

14. 根据值找首次出现位置

# 1.find,rfind,index,rindex,count
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到时会报错
>>> msg.index('e',2,4) # 报错ValueError
# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
>>> msg = "hello everyone"
>>> msg.count('e')  # 统计字符串e出现的次数
4
>>> msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数
1




# 2.expandtabs
>>> name = 'tony\thello'  # \t表示制表符(tab键)
>>> name
tony    hello
>>> name.expandtabs(1)  # 修改\t制表符代表的空格数
tony hello


# 3.captalize,swapcase,title
# 3.1 captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  
# 3.2 swapcase：大小写翻转
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#3.3 title：每个单词的首字母大写
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much 


# 4.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字


#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False

#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True

# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False

'''


# 5.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower()  # 字符串是否是纯小写
True
>>> name.isupper()  # 字符串是否是纯大写
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

3.2 共有功能

1. 统计长度

print(len("abcdef"))  # 6

2. 索引取值

message = "来做点ab交易呀"
#          0 1 2345 6 7
#           ... -3 -2 -1
print(message[0]) # "来"
print(message[1]) # "做"
print(message[2]) # "点"

print(message[-1]) # 呀
print(message[-2]) # 呀
print(message[-3]) # 呀

Ps:：字符串中是能通过索引取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】
3. 获取子串（切片）(切片可以倒着切，可以有步长）

message = "来做点py交易呀"

print(message[0:2]) # "来做"
print(message[3:7]) # "py交易"
print( message[3:] ) # "py交易呀"
print( message[:5] ) # "来做点py"

print(message[4:-1]) # "y交易"
print(message[4:-2]) # "y交"

print( message[4:len(message)] ) # "y交易呀"

3.3 转换

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

data_list = ["alex","eric",999]
data = str(data_list)
print(data) # '["alex","eric",999]'

4. 列表

方法	功能	用法
append	列表尾部追加值	列表.append(值)
extend	批量追加	列表.append(追加的列表)
insert	列表项插入	列表.insert(index，内容)
remove	移除列表项	列表.remove(内容)
pop	删除列表项	列表.pop(index)
del	删除列表项	del 列表(index)
clear	清空列表	list.clear( )
index	根据内容找位置	list.index(内容)
sort	列表元素排序	list.sort()
reverse	反转列表	list.reverse()
len	列表项长度	len(list)

4.1 独有功能

1. 在原列表尾部追加值

data_list = ["alex","eric",999]
data = str(data_list)
print(data) # '["alex","eric",999]'

# 案例
welcome = "欢迎使用NB游戏".center(30, '*')
print(welcome)

user_count = 0
while True:
    count = input("请输入游戏人数：")
    if count.isdecimal():
        user_count = int(count)
        break
    else:
        print("输入格式错误，人数必须是数字。")


message = "{}人参加游戏NB游戏。".format(user_count)
print(message)


user_name_list = []

for i in range(1, user_count + 1):
    tips = "请输入玩家姓名（{}/{}）：".format(i, user_count)
    name = input(tips)
    user_name_list.append(name)

print(user_name_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 = ["a","b","c"]
user_list.insert(0,"d")
user_list.insert(2,"e")
print(user_list)

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

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.remove("Alex")
print(user_list)


user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:
	user_list.remove("Alex")
print(user_list)


user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
while True:
    if "Alex" in user_list:
        user_list.remove("Alex")
	else:
        break
print(user_list)

5. 在原列表中根据索引踢出某个元素（根据索引位置删除），返回被删除内容

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1      2      3       4
user_list.pop(1)
print(user_list) #  ["王宝强","Alex","贾乃亮","Alex"]

user_list.pop()
print(user_list) # ["王宝强","Alex","贾乃亮"]

item = user_list.pop(1)
print(item) # "Alex"
print(user_list) # ["王宝强","贾乃亮"]

6. 删除列表项

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
del user_list[0]  # ["陈羽凡","Alex","贾乃亮","Alex"]

7. 清空原列表

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.clear()
print(user_list) # []

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

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1      2       3      4
if "Alex" in user_list:
	index = user_list.index("Alex")
	print(index) # 2
else:
    print("不存在")

9. 列表元素排序
   list.sort(cmp=None, key=None, reverse=False)

cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

# 数字排序
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 = ["王宝强", "Ab陈羽凡", "Alex", "贾乃亮", "贾乃", "1"]
#       [29579, 23453, 24378]
#       [65, 98, 38472, 32701, 20961]
#       [65, 108, 101, 120]
#       [49]
print(user_list)
"""
sort的排序原理
    [ "x x x" ," x x x x x " ]
"""
user_list.sort()
print(user_list)

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

10. 反转列表

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.reverse()

print(user_list)

4.2 公共功能

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包含
   由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。

 user_list = ["狗子","二蛋","沙雕","alex"] 
 result = "alex" in user_list
 # result = "alex" not in user_list
 print(result) #  True
 
 if "alex" in user_list:
     print("在，把他删除")
     user_list.remove("alex")
 else:
     print("不在")

user_list = ["狗子","二蛋","沙雕","alex"] 
if "alex" in user_list:
    print("在，把他删除")
    user_list.remove("alex")
else:
    print("不在")

text = "打倒小日本"
data = "日" in text

# 案例
user_list = ["狗子","二蛋","沙雕","alex"] 
if "alex" in user_list:
    print("在，把他删除")
    user_list.remove("alex")
else:
    print("不在")

# 案例
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:
	index = user_list.index("Alex")
	user_list.pop(index)

# 案例：敏感词替换
text = input("请输入文本内容：") # 按时打发第三方科技爱普生豆腐啊；了深刻的房价破阿偶打飞机
forbidden_list = ["草","欧美","日韩"]
for item in forbidden_list:
    text = text.replace(item,"**")
print(text)

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

4. 获取长度

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

5. 索引，一个元素的操作

 # 读
 user_list = ["范德彪","刘华强",'尼古拉斯赵四']
 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)

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

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)

5. 元组

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

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

如何体现不可变呢？
记住一句话：《“我儿子永远不能换成是别人，但我儿子可以长大”》

5.1 公共功能

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()
   print(user_list)
   

5.2 转换

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

name = "池铁城"
data = tuple(name)
print(data) # 输出 ("池","铁","成")

name = ["池铁城",18,"python"]
data = tuple(name)
print(data) # 输出 ("池铁城",18,"python")

6. 字典（dict）

方法	功能	用法
get	根据key获取value	dict.get( key [,value] )
keys	获取所有key(高仿列表，不是列表)	dict.keys( )
value	获取所有value(高仿列表，不是列表)	dict.values( )
items	获取所有键对值	dict.items( )
setdefault	设置值（新增）	dict.setdefalut(key，value)
update	更新字典键值对	dict.update(dict)
pop	移除指定键值对	dict.pop(key)
popitem	按照顺序移除 (先进后出）	dict.popitem( )
len	键值对个数	len(dict)
fromkeys	初始化字典	dict.fromkeys(key列表，值列表（同时赋予所有key）

6.1 独有功能

1. 获取值

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

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

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

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

与dict[key]的区别，若key不存在，get返回None或者指定value，dict[value]会报错

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

2. 所有的键

info = {"age":12, "status":True, "name":"antony","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']

3. 所有的值

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

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

4. 所有的键对值

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

print(data) # 输出 dict_items([ ('age', 12),  ('status', True),  ('name', 'antony'),  ('email', 'xx@live.com')])

5. 设置值

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

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

6. 更新字典键值对

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

7. 移除指定键值对

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

data = info.pop("age")

print(info) # {"status":True,"name":"antony"}
print(data) # 12

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

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

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

Ps:python3.6之前为随机删除。

9. 求并集（python3.9新功能）

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

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

10. 字典键值对个数

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

11. 初始化字典

>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}

Ps:初始化字典用的是同一个内存地址的列表，所以无论哪个value变化都会导致字典所有的value值同时变化。

6.2 转换

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

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

7. 集合（set）

方法	功能	用法
add	添加元素	set.add(value)
discard	删除元素	set.discard(value)
intersection / &	交集	set1.intersection(set2) /set1 & set2
union / |	并集	set1.union(set2) / set1 | set 2
difference / -	差集	set1.difference(set2) / set1 - set2
> >=	判断父集	set1 > set2
< <=	判断子集	set1 < set2

7.1 独有功能

1. 添加元素

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)

6. 父集：一个集合是否包含另外一个集合

# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False

7. 子集

>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

7.2 元素要求（集合元素必须可哈希）

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

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

总结：集合的元素只能是 int、bool、str、tuple 。

7.3 转换

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

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

提示：int/list/tuple/dict都可以转换为集合。
tiips: 集合可作为一种去重手段。

8. 可变与不可变类型

在Python中，数据类型可以分为可变类型和不可变类型。

不可变类型：

• 数字类型（int、float、complex）
• 布尔类型（bool）
• 字符串类型（str）
• 元组类型（tuple）
  以上类型的数据一旦创建，就无法直接修改其内容，如果需要修改，需要重新创建一个新的对象。

可变类型：

• 列表类型（list）
• 字典类型（dict）
• 集合类型（set）
  以上类型的数据可以修改其内容，而不必重新创建一个新的对象。

例如，我们来看一下下面的代码：

a = [1, 2, 3]
b = a
a.append(4)
print(b)  # 输出 [1, 2, 3, 4]

从代码中可以看出，列表类型是可变类型，当我们修改a的值时，b的值也同时被修改了，因为b和a指向同一个内存地址。而如果我们将a改为一个不可变类型，那么b不会被修改：

a = 1
b = a
a = 2
print(b)  # 输出 1

从代码中可以看出，数字类型是不可变类型，当我们修改a的值时，b的值不会被修改，因为a和b指向的是不同的内存地址。