【Python-数据类型】

■ 类型简介

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。

#!/usr/bin/python3

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

输出如下
100
1000.0
runoob

■ Number（数字）

支持 int、float、bool、complex（复数）。
内置的 type() 函数可以用来查询变量所指的对象类型。
Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

■ int（整数）

■ float（浮点数）

■ complex（复数）

■ bool（布尔）

>>> 17 / 3 	 # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 7 // 2
3
>>> 7.0 // 2
3.0 
>>> 7 // 2.0
3.0
>>> 17 % 3    # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17

操作来进行幂运算：
>>> 5 ** 2   #5 的平方
25
>>> 2 ** 7   #2的7次方
128

不同类型的数混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

■ 变量作用域

■ 局部变量出了函数体不能使用

#演示局部变量
def test_a():
    num = 100
    print(num)

test_a()
# 出了函数体，局部变量就无法使用了
print(num)
    

■ 全局变量和局部变量为同名

# 在函数内修改全局变量
num = 200

def test_a():
    print(f"test_a: {num}")

def test_b():
    num = 500       # 局部变量
    print(f"test_b: {num}")

test_a()
test_b()
print(num)

结果：
test_a: 200    # 全局的num 变量
test_b: 500    # 局部的num 变量
200			   # 全局的num 变量

■ global关键字，在函数内声明变量为全局变量

# global关键字，在函数内声明变量为全局变量
def test_b():
    global num      # 设置内部定义的变量为全局变量
    num = 500
    print(f"test_b: {num}")

test_b()
print(num)

结果：
test_b: 500
500

■ global关键字 ，设置内部定义的变量为全局变量（和外部重名）

# global关键字，在函数内声明变量为全局变量
num = 200
def test_a():
    print(f"test_a: {num}")
    
def test_b():
    global num      # 设置内部定义的变量为全局变量
    num = 500
    print(f"test_b: {num}")

test_a()
test_b()
print(num)

结果：
test_a: 200
test_b: 500
500

■ String（字符串）

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
变量[头下标:尾下标]

#!/usr/bin/python3

str = 'Runoob'  # 定义一个字符串变量
print(str)         	 # Runoob  			# 打印整个字符串 
print(str[0:-1])   	 # Runoo  			# 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])      	 # R  				# 打印字符串的第一个字符
print(str[2:5])    	 # noo  			# 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])    	 # noob  			# 打印字符串从第三个字符开始到末尾
print(str * 2)     	 # RunoobRunoob  	# 打印字符串两次
print(str + "TEST")  # RunoobTEST  		# 打印字符串和"TEST"拼接在一起

■ 字符串-下标索引取值

my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}")

从字符串itheima and itcast取下标为2的元素，。值是：h,取下标为-16的元素。值是：h

■ 字符串-下标 index（）

my_str = "itheima and itcast"
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")

■ 字符串-替换 replace（）

my_str = "itheima and itcast"
new_my_str = my_str.replace("it", "程序")
print(f"3将字符串{my_str}，进行替换后得到：{new_my_str}")

3将字符串itheima and itcast，进行替换后得到：程序heima and 程序cast

■ 字符串-切分 split（）

# split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"4将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")

# strip方法
my_str = "  itheima and itcast  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"5字符串{my_str}被strip后，结果：{new_my_str}")

my_str = "12itheima and itcast21"
new_my_str = my_str.strip("12")
print(f"6字符串{my_str}被strip('12')后，结果：{new_my_str}")


4将字符串hello python itheima itcast进行split切分后得到：['hello', 'python', 'itheima', 'itcast'], 类型是：<class 'list'>
5字符串  itheima and itcast  被strip后，结果：itheima and itcast
6字符串12itheima and itcast21被strip('12')后，结果：itheima and itcast

■ 字符串-去除空格\n \t等 strip（）

str = '\n   \t two tigers two'
str1 = str.strip()
print(str1)
结果为：
two tigers two

■ 字符串-统计 count（）

# 统计字符串中某字符串的出现次数, count
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"7字符串{my_str}中it出现的次数是：{count}")

print(f"7字符串{my_str}中it出现的次数是：{count}")

■ 字符串-长度 len()

# 统计字符串的长度, len()
num = len(my_str)
print(f"8字符串{my_str}的长度是：{num}")

8字符串itheima and itcast的长度是：18

■ 字符串- 转义字符

runoob

■字符串-运算符

runoob

■ 字符串-格式化

runoob

■ 字符串- f"{占位}"

name = "shine"
set_up_year = 2006
stock_price = 19.99
# f: format
print(f"我是{name}，我成立于：{set_up_year}年，我今天的股价是：{stock_price}")

结果：
我是shine，我成立于：2006年，我今天的股价是：19.99

■ 字符串-表达式进行字符串格式化 %d, %s，%f, {}

"""
演示对表达式进行字符串格式化
"""
print("1 * 1 的结果是：%d" % (1 * 1))
print(f"1 * 2的结果是：{1 * 2}")
print("字符串在Python中的类型名是：%s" % type("字符串"))

输出结果：
1 * 1 的结果是：1
1 * 2的结果是：2
字符串在Python中的类型名是：<class 'str'>

%.1f

# 定义需要的变量
name = "裕景技术"
stock_price = 19.99
stock_code = "003032"
# 股票 价格 每日 增长 因子
stock_price_daily_growth_factor = 1.2
growth_days = 7

finally_stock_price = stock_price * stock_price_daily_growth_factor ** growth_days

print(f"公司：{name}，股票代码：{stock_code}，当前股价：{stock_price}")
print("每日增长系数: %.1f，经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor, growth_days, finally_stock_price))

结果：
公司：裕景技术，股票代码：004032，当前股价：19.99
每日增长系数: 1.2，经过7天的增长后，股价达到了：71.63

■ 字符串- \t

print("Hello\tWorld")
print("itheima\tbest")

结果：
Hello	World
itheima	best

■ 字符串-三引号

runoob

■ 字符串- f-string

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去

name1 = "shine"
name2 = '喜欢'
print(f'name1={name1},name2={name2}')

name1=shine,name2=喜欢

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2

>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2

■ 字符串-大小比较

# abc 比较 abd
print(f"abd大于abc，结果：{'abd' > 'abc'}")
# a 比较 ab
print(f"ab大于a，结果：{'ab' > 'a'}")
# a 比较 A
print(f"a 大于 A，结果：{'a' > 'A'}")
# key1 比较 key2
print(f"key2 > key1，结果：{'key2' > 'key1'}")

abd大于abc，结果：True
ab大于a，结果：True
a 大于 A，结果：True
key2 > key1，结果：True

■ 字符串-三种定义方式

"""
演示字符串的三种定义方式：
- 单引号定义法
- 双引号定义法
- 三引号定义法
"""

# 单引号定义法，使用单引号进行包围
name = 'shine'
print(type(name))
# 双引号定义法
name = "shine"
print(type(name))
# 三引号定义法，写法和多行注释是一样的
name = """
我是
黑马
程序员
"""
print(type(name))


# 在字符串内 包含双引号
name = '"shine"'
print(name)
# 在字符串内 包含单引号
name = "'shine'"
print(name)
# 使用转义字符 \ 解除引号的效用
name = "\"shine\""
print(name)
name = '\'shine\''
print(name)

输入结果：
<class 'str'>
<class 'str'>
<class 'str'>
"shine"
'shine'
"shine"
'shine'

■ 字符串-三种拼接方式（+ ， %s，{}）

■ 字符串-示例一：

#!/usr/bin/python3 

str='123456789' 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第六个的字符（不包含）
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

以上实例输出结果：

123456789
12345678
1
345
3456789
24
123456789123456789
123456789你好
------------------------------
hello
runoob
hello\nrunoob

■ List（列表）[元素，元素，…]

■ 列表-索引从 0 开始，第二个索引是 1

list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

print( list[0] )
print( list[1] )
print( list[2] )

实例输出结果：
red
green
blue

■ 列表-从尾部开始，最后一个元素的索引为 -1，往前一位为 -2

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

实例输出结果：
black
white
yellow

■ 列表-通过下标索引取出数据（倒序取出）

# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
my_list = ["Tom", "Lily", "Rose"]
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

输出：
Rose
Lily
Tom

■ 列表-方括号 [] 的形式截取字符

#!/usr/bin/python3

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

以上实例输出结果：
[10, 20, 30, 40]

负数索引值截取：

#!/usr/bin/python3

list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]

# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])

以上实例输出结果：
list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

■ 列表-添加列表项（append() ）

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

例输出结果：
第三个元素为 :  1997
更新后的第三个元素为 :  2001

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

例输出结果：
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

■ 列表-删除列表元素（del 语句）

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000] 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

实例输出结果：
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

■列表-脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

■ 列表-截取与拼接

■ 列表-嵌套

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

输出：
5

my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

输出：
<class 'list'>

■ 列表-比较

# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
以上代码输出结果为：

operator.eq(a,b):  False
operator.eq(c,b):  True

■ 列表-查找某元素在列表内的下标索引- index（）

mylist = ["itcast", "itheima", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

输出：
itheima在列表中的下标索引值是：1
    index = mylist.index("hello")
            ^^^^^^^^^^^^^^^^^^^^^
ValueError: 'hello' is not in list

[Done] exited with code=1 in 0.186 seconds

■ 列表-修改特定下标索引的值

mylist[0] = "传智教育"
print(f"列表被修改元素值后，结果是：{mylist}")

■ 列表-在指定下标位置前插入新元素 insert()

mylist = ["itcast", "itheima", "python"]
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")

列表插入元素后，结果是：['itcast', 'best', 'itheima', 'python']

■ 列表-在列表的尾部追加单个新元素 append()

mylist = ["itcast", "itheima", "python"]
mylist.append("程序员")
print(f"列表在追加了元素后，结果是：{mylist}")

列表在追加了元素后，结果是：['itcast', 'itheima', 'python', '程序员']

■ 列表-在列表的尾部追加一批新元素 extend（）

mylist = ["itcast", "itheima", "python"]
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")

列表在追加了一个新的列表后，结果是：['itcast', 'itheima', 'python', 1, 2, 3]

■ 列表-删除指定下标索引的元素 del

mylist = ["itcast", "itheima", "python"]

# # 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")

列表删除元素后结果是：['itcast', 'itheima']

■ 列表-删除指定下标索引的元素 pop（）

mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")

通过pop方法取出元素后列表内容：['itcast', 'itheima'], 取出的元素是：python

■ 列表-删除某元素在列表中的第一个匹配项 remove（）

mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

通过remove方法移除元素后，列表的结果是：['itcast', 'itcast', 'itheima', 'python']

■ 列表-清空列表 clear()

mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")

列表被清空了，结果是：[]

■ 列表-统计列表内某元素的数量count（）

mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")

列表中itheima的数量是：2

■ 列表-统计列表中全部的元素数量 len（）

# # 10. 统计列表中全部的元素数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

列表的元素数量总共有：5个

■ 列表-while循环遍历列表

mylist = ["传智教育", "黑马程序员", "Python"]
# 定义一个变量，用来标记列表的下标
index = 0       # 初始下标为0
while index < len(mylist):
    # 通过index变量取出对应下标的元素
    element = mylist[index]
    print(f"列表的元素：{element}")

    # 至关重要：将循环变量（index）每一次循环都+1
    index += 1
    
if __name__ == '__main__':
   list_while_func()

■ 列表-for循环遍历列表

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    mylist = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器:
    for element in mylist:
        print(f"列表的元素有：{element}")

if __name__ == '__main__':
    list_for_func()

■ 列表函数&方法

■ tuple（元组）（）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

■ 元组-定义

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
t4 = "a", "b", "c", "d"   #  不需要括号也可以

print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")
print(f"t4的类型是：{type(t4)}, 内容是：{t4}")

t1的类型是：<class 'tuple'>, 内容是：(1, 'Hello', True)
t2的类型是：<class 'tuple'>, 内容是：()
t3的类型是：<class 'tuple'>, 内容是：()
t4的类型是：<class 'tuple'>, 内容是：("a", "b", "c"，"d")

■ 元组-定义单个元素的元素

t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")

■ 元组-元组的嵌套

t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")
t5的类型是：<class 'tuple'>, 内容是：((1, 2, 3), (4, 5, 6))

■ 元组-下标索引去取出内容

t5 = ( (1, 2, 3), (4, 5, 6) )
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

从嵌套元组中取出的数据是：6

■ 元组-index（）查找方法

t6 = ("裕景教育", "程序员", "Python")
index = t6.index("程序员")
print(f"在元组t6中查找程序员，的下标是：{index}")

在元组t6中查找程序员，的下标是：1

■ 元组-count统计方法

# 元组的操作：count统计方法
t7 = ("裕景教育", "程序员", "程序员", "程序员", "Python")
num = t7.count("程序员")
print(f"在元组t7中统计程序员的数量有：{num}个")

在元组t7中统计程序员的数量有：3个

■ 元组-len函数统计元组元素数量

t8 = ("裕景教育", "程序员", "程序员", "程序员", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")

t8元组中的元素有：5个

■ 元组-元组的遍历：while

# 元组的遍历：while
t8 = ("裕景教育", "程序员", "程序员", "程序员", "Python")
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    # 至关重要
    index += 1

■ 元组-元组的遍历：for

t8 = ("裕景教育", "程序员", "程序员", "程序员", "Python")
for element in t8:
    print(f"2元组的元素有：{element}")

■ 元组-修改元组内容（不可修改）

在这里插入代码片

■ 元组-元祖嵌套列表，列表可修改

t9 = (1, 2, ["itheima", "itcast"])
print(f"t9的内容是：{t9}")
t9[2][0] = "程序员"
t9[2][1] = "裕景教育"
print(f"t9的内容是：{t9}")

t9的内容是：(1, 2, ['itheima', 'itcast'])
t9的内容是：(1, 2, ['程序员', '裕景教育'])

■ 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

■ 元组下标索引

■ 访问元组

#!/usr/bin/python3
 
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

■ 修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，

#!/usr/bin/python3
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

实例输出结果：
(12, 34.56, 'abc', 'xyz')

■ 删除元组

#!/usr/bin/python3
 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

输出如下所示：
删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

■ 元组运算符

■ 元组索引，截取

Python表达式	结果	描述
tup[1]	‘Runoob’	读取第二个元素
tup[-2]	‘Weibo’	反向读取，读取倒数第二个元素
tup[1:]	(‘Runoob’, ‘Taobao’, ‘Wiki’, ‘Weibo’, ‘Weixin’)	截取元素，从第二个开始后的所有元素。
tup[1:4]	(‘Runoob’, ‘Taobao’, ‘Wiki’)	截取元素，从第二个开始到第四个元素（索引为 3）。

>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>

■ 元组内置函数

关于元组是不可变的

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

■ Set（集合）{元素一，元素二，}

集合（set）是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

创建格式：
parame = {value01,value02,...}
或者
set(value)
以下是一个简单实例：

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

■ 集合-定义集合

my_set = {"走遍天下", "程序员", "itheima", "走遍天下", "程序员", "itheima", "走遍天下", "程序员", "itheima"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")

my_set的内容是：{'程序员', '走遍天下', 'itheima'}, 类型是：<class 'set'>
my_set_empty的内容是：set(), 类型是：<class 'set'>

■ 集合-添加新元素 add（）

my_set = {"走遍天下", "程序员", "itheima", "走遍天下", "程序员", "itheima", "走遍天下", "程序员", "itheima"}
my_set.add("Python")
my_set.add("走遍天下")      #
print(f"my_set添加元素后结果是：{my_set}")

my_set添加元素后结果是：{'程序员', 'Python', '走遍天下', 'itheima'}

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

■ 集合-添加元素 s.update( x ) 添加元素，且参数可以是列表，元组，字典

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

■ 集合-移除元素remove（）（元素不存在，会发生错误）

my_set.remove("程序员")
print(f"my_set移除程序员后，结果是：{my_set}")

my_set移除程序员后，结果是：{'Python', '走遍天下', 'itheima'}

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

■ 集合-移除元素s.discard( x ) （元素不存在，不会发生错误）

s.discard( x )是移除集合中的元素且如果元素不存在，不会发生错误.

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

■ 集合-随机删除集合中的一个元素

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)

输出结果：
Runoob

■ 集合-随机取出一个元素 pop（）

my_set = {"走遍天下", "程序员", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")

集合被取出元素是：程序员, 取出元素后：{'走遍天下', 'itheima'}

■ 集合-清空集合, clear（）

my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")

集合被清空啦，结果是：set()

清空集合 s。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

■ 集合-取2个集合的差集

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")

取出差集后的结果是：{2, 3}
取差集后，原有set1的内容：{1, 2, 3}
取差集后，原有set2的内容：{1, 5, 6}

■ 集合-取2个集合的差集并更新

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")

消除差集后，集合1结果：{2, 3}
消除差集后，集合2结果：{1, 5, 6}

■ 集合-集合合并

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

2集合合并结果：{1, 2, 3, 5, 6}
合并后集合1：{1, 2, 3}
合并后集合2：{1, 5, 6}

■ 集合-统计集合元素数量 len(set)

set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

集合内的元素数量有：5个

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset) 
3

■ 集合-集合的遍历

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")

集合的元素有：1
集合的元素有：2
集合的元素有：3
集合的元素有：4
集合的元素有：5

■ 集合-实例演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

■ 集合-判断元素是否在集合中存在 （x in s）

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>

■ 集合-集合内置方法完整列表

■ dict （字典）Dictionary

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

■ 字典-示例 键值 key

d = {key1 : value1, key2 : value2, key3 : value3 }

■ 字典-键值可以是数字，数据可以取任何数据类型加粗样式

tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

■ 字典-空字典

emptyDict = {} # 使用大括号 {} 来创建空字典
emptyDict = dict() # 使用内建函数 dict() 创建字典

emptyDict = {}  # 使用大括号 {} 来创建空字典
# emptyDict = dict() # 使用内建函数 dict() 创建字典

# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))
以上实例输出结果：

{}
Length: 0
<class 'dict'>

■ 字典-重复Key的字典

my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")

重复key的字典的内容是：{'王力鸿': 88, '林俊节': 77}

■ 字典-基于Key获取Value

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

以上实例输出结果：
tinydict['Name']:  Runoob
tinydict['Age']:  7

■ 字典-新增元素

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")

字典经过新增元素后，结果：{'周杰轮': 99, '林俊节': 88, '张学油': 77, '张信哲': 66}

■ 字典- 更新元素

my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")

字典经过更新后，结果：{'周杰轮': 33, '林俊节': 88, '张学油': 77, '张信哲': 66}

■ 字典-删除元素

score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")

字典中被移除了一个元素，结果：{'林俊节': 88, '张学油': 77, '张信哲': 66}, 周杰轮的考试分数是：33

■ 字典-获取全部的key keys()

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")

字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])

■ 字典-遍历字典 for 获取到全部的key来完成遍历

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])
字典的key是:周杰轮
	字典的value是：99
字典的key是:林俊节
	字典的value是：88
字典的key是:张学油
	字典的value是：77

■ 字典-遍历字典 for 直接对字典

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是：{my_dict[key]}")

2字典的key是:周杰轮
2字典的value是：99
2字典的key是:林俊节
2字典的value是：88
2字典的key是:张学油
2字典的value是：77

■ 字典-len()函数

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

字典中的元素数量有：3个

■ 字典-嵌套字典

# 定义嵌套字典
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")

学生的考试信息是：{'王力鸿': {'语文': 77, '数学': 66, '英语': 33}, '周杰轮': {'语文': 88, '数学': 86, '英语': 55}, '林俊节': {'语文': 99, '数学': 96, '英语': 66}}
周杰轮的语文分数是：88
林俊节的英语分数是：66

■ 字典-修改字典

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"    # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

实例输出结果：
tinydict['Age']:  8
tinydict['School']:  菜鸟教程

■ 字典-删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。
显式删除一个字典用del命令，如下实例：

#!/usr/bin/python3
 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
但这会引发一个异常，因为用执行 del 操作后字典不再存在：

Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

■ 字典-键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

#!/usr/bin/python3
 
tinydict = {['Name']: 'Runoob', 'Age': 7}
 
print ("tinydict['Name']: ", tinydict['Name'])
以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    tinydict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

■ 字典-内置函数&方法

■ JSON

■ 准备列表，列表内每一个元素都是字典，将其转换为JSON

import json
# 准备列表，列表内每一个元素都是字典，将其转换为JSON
data = [{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]
json_str = json.dumps(data, ensure_ascii=False)
print(type(json_str))
print(json_str)

<class 'str'>
[{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]

■ 准备字典，将字典转换为JSON

d = {"name":"周杰轮", "addr":"台北"}
json_str = json.dumps(d, ensure_ascii=False)
print(type(json_str))
print(json_str)
--------------------------------------------------------------
<class 'str'>
{"name": "周杰轮", "addr": "台北"}

■ 将JSON字符串转换为Python数据类型[{k: v, k: v}, {k: v, k: v}]

# 将JSON字符串转换为Python数据类型[{k: v, k: v}, {k: v, k: v}]
s = '[{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]'
l = json.loads(s)
print(type(l))
print(l)

----------------------------------------
<class 'list'>
[{'name': '张大山', 'age': 11}, {'name': '王大锤', 'age': 13}, {'name': '赵小虎', 'age': 16}]

■ 将JSON字符串转换为Python数据类型{k: v, k: v}

# 将JSON字符串转换为Python数据类型{k: v, k: v}
s = '{"name": "周杰轮", "addr": "台北"}'
d = json.loads(s)
print(type(d))
print(d)

<class 'dict'>
{'name': '周杰轮', 'addr': '台北'}

■ 容器通用功能

■ len元素个数

"""
演示数据容器的通用功能
"""
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

len 列表 元素个数有：5
len 元组 元素个数有：5
len 字符串元素个数有：7
len 集合 元素个数有：5
len 字典 元素个数有：5

■ max最大元素

# max最大元素
print(f"max 列表 最大的元素是：{max(my_list)}")
print(f"max 元组 最大的元素是：{max(my_tuple)}")
print(f"max 字符串最大的元素是：{max(my_str)}")
print(f"max 集合 最大的元素是：{max(my_set)}")
print(f"max 字典 最大的元素是：{max(my_dict)}")

max 列表 最大的元素是：5
max 元组 最大的元素是：5
max 字符串最大的元素是：g
max 集合 最大的元素是：5
max 字典 最大的元素是：key5

■ min最小元素

# min最小元素
print(f"min 列表 最小的元素是：{min(my_list)}")
print(f"min 元组 最小的元素是：{min(my_tuple)}")
print(f"min 字符串最小的元素是：{min(my_str)}")
print(f"min 集合 最小的元素是：{min(my_set)}")
print(f"min 字典 最小的元素是：{min(my_dict)}")

min 列表 最小的元素是：1
min 元组 最小的元素是：1
min 字符串最小的元素是：a
min 集合 最小的元素是：1
min 字典 最小的元素是：key1

■ 类型转换: 容器转列表

# 类型转换: 容器转列表
print(f"容器转列表：列表转列表的结果是：{list(my_list)}")
print(f"容器转列表：元组转列表的结果是：{list(my_tuple)}")
print(f"容器转列表：字符串转列表结果是：{list(my_str)}")
print(f"容器转列表：集合转列表的结果是：{list(my_set)}")
print(f"容器转列表：字典转列表的结果是：{list(my_dict)}")

容器转列表：列表转列表的结果是：[1, 2, 3, 4, 5]
容器转列表：元组转列表的结果是：[1, 2, 3, 4, 5]
容器转列表：字符串转列表结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
容器转列表：集合转列表的结果是：[1, 2, 3, 4, 5]
容器转列表：字典转列表的结果是：['key1', 'key2', 'key3', 'key4', 'key5']

■ 类型转换: 容器转元组

# 类型转换: 容器转元组
print(f"容器转元组：列表转元组的结果是：{tuple(my_list)}")
print(f"容器转元组：元组转元组的结果是：{tuple(my_tuple)}")
print(f"容器转元组：字符串转元组结果是：{tuple(my_str)}")
print(f"容器转元组：集合转元组的结果是：{tuple(my_set)}")
print(f"容器转元组：字典转元组的结果是：{tuple(my_dict)}")

容器转元组：列表转元组的结果是：(1, 2, 3, 4, 5)
容器转元组：元组转元组的结果是：(1, 2, 3, 4, 5)
容器转元组：字符串转元组结果是：('a', 'b', 'c', 'd', 'e', 'f', 'g')
容器转元组：集合转元组的结果是：(1, 2, 3, 4, 5)
容器转元组：字典转元组的结果是：('key1', 'key2', 'key3', 'key4', 'key5')

■ 类型转换: 容器转字符串 （不成功）

# 类型转换: 容器转字符串
print(f"容器转字符串: 列表转字符串的结果是：{str(my_list)}")
print(f"容器转字符串: 元组转字符串的结果是：{str(my_tuple)}")
print(f"容器转字符串: 字符串转字符串结果是：{str(my_str)}")
print(f"容器转字符串: 集合转字符串的结果是：{str(my_set)}")
print(f"容器转字符串: 字典转字符串的结果是：{str(my_dict)}")

容器转字符串: 列表转字符串的结果是：[1, 2, 3, 4, 5]
容器转字符串: 元组转字符串的结果是：(1, 2, 3, 4, 5)
容器转字符串: 字符串转字符串结果是：abcdefg
容器转字符串: 集合转字符串的结果是：{1, 2, 3, 4, 5}
容器转字符串: 字典转字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

■ 类型转换: 容器转集合

# 类型转换: 容器转集合
print(f"容器转集合：列表转集合的结果是：{set(my_list)}")
print(f"容器转集合：元组转集合的结果是：{set(my_tuple)}")
print(f"容器转集合：字符串转集合结果是：{set(my_str)}")
print(f"容器转集合：集合转集合的结果是：{set(my_set)}")
print(f"容器转集合：字典转集合的结果是：{set(my_dict)}")

容器转集合：列表转集合的结果是：{1, 2, 3, 4, 5}
容器转集合：元组转集合的结果是：{1, 2, 3, 4, 5}
容器转集合：字符串转集合结果是：{'g', 'd', 'e', 'b', 'f', 'a', 'c'}
容器转集合：集合转集合的结果是：{1, 2, 3, 4, 5}
容器转集合：字典转集合的结果是：{'key1', 'key3', 'key5', 'key4', 'key2'}

■ 进行容器的排序 sorted()

# 进行容器的排序
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}

print(f"容器的排序：列表对象的排序结果：{sorted(my_list)}")
print(f"容器的排序：元组对象的排序结果：{sorted(my_tuple)}")
print(f"容器的排序：字符串对象的排序结果：{sorted(my_str)}")
print(f"容器的排序：集合对象的排序结果：{sorted(my_set)}")
print(f"容器的排序：字典对象的排序结果：{sorted(my_dict)}")

print(f"容器的排序：列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"容器的排序：元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"容器的排序：字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
print(f"容器的排序：集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"容器的排序：字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")

容器的排序：列表对象的排序结果：[1, 2, 3, 4, 5]
容器的排序：元组对象的排序结果：[1, 2, 3, 4, 5]
容器的排序：字符串对象的排序结果：['a', 'b', 'c', 'd', 'e', 'f', 'g']
容器的排序：集合对象的排序结果：[1, 2, 3, 4, 5]
容器的排序：字典对象的排序结果：['key1', 'key2', 'key3', 'key4', 'key5']

容器的排序：列表对象的反向排序结果：[5, 4, 3, 2, 1]
容器的排序：元组对象的反向排序结果：[5, 4, 3, 2, 1]
容器的排序：字符串对象反向的排序结果：['g', 'f', 'e', 'd', 'c', 'b', 'a']
容器的排序：集合对象的反向排序结果：[5, 4, 3, 2, 1]
容器的排序：字典对象的反向排序结果：['key5', 'key4', 'key3', 'key2', 'key1']

■ 数据类型转换

■ int（）

# 输入数字类型
num = input("请告诉我你的银行卡密码：")
# 数据类型转换
num = int(num)

■ 容器转换

参考： 数据容器通用功能

■ 对序列进行切片操作

■ 对list进行切片，从1开始，4结束，步长1

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

结果1：[1, 2, 3]

■ 对list进行切片，从3开始，到1结束，步长-1

my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")

结果5：[3, 2]

■ 对tuple进行切片，从头开始，到最后结束，步长1

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

结果2：(0, 1, 2, 3, 4, 5, 6)

■ 对tuple进行切片，从头开始，到尾结束，步长-2

my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

结果6：(6, 4, 2, 0)

■ 对str进行切片，从头开始，到最后结束，步长2

my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

结果3：0246

■ 对str进行切片，从头开始，到最后结束，步长-1

my_str = "01234567"
result4 = my_str[::-1]          # 等同于将序列反转了
print(f"结果4：{result4}")

结果4：76543210

■ 综合示例

"""
演示序列的切片的课后练习
"走遍天下，员序程马黑来，nohtyP学"
"""
my_str = "走遍天下，员序程WH来，nohtyP学"
# 倒序字符串，切片取出
result1 = my_str[::-1][9:14]
print(f"方式1结果：{result1}")
# 切片取出，然后倒序
result2 = my_str[5:10][::-1]
print(f"方式2结果：{result2}")

# split分隔"，"  replace替换"来"为空，倒序字符串
result3 = my_str.split("，")[1].replace("来", "")[::-1]
print(f"方式3结果：{result3}")

方式1结果：HW程序员
方式2结果：HW程序员
方式3结果：HW程序员

■ 数据类型函数

■ 数学函数

■ 随机数函数

■ 三角函数

■ 数学常量

■ type() 查询变量所指的对象类型

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

■ isinstance（）判断类型

>>> a = 111
>>> isinstance(a, int)
True
>>>

■ isinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

■ 数字运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余 
2

使用 ** 操作来进行幂运算：
>>> 2 ** 5 # 乘方
32
>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128
混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

■ 数学函数

■ 随机数函数

■ 三角函数

■ 数学常量