元组

"""
目录:
1.创建元组
2.元组的拼接
3.元组的解压赋值
4.元组的切片
5.元组的元素的索引
6.元组的嵌套
7.统计某个元素的个数
"""

"""创建元组(元组不可变)"""
# 1.强制:tuple()
# 2.普通
tuple_0 = (1,)
tuple_1 = 1, 2, 3, "apple", "red"
tuple_2 = (1, 2, 3, "banana", "blue")
print(type(tuple_1), type(tuple_2))

"""元组的拼接"""
tuple_new = tuple_1 + tuple_2

"""元组的解压赋值"""
tuple_3 = (1, 2, 3)
a, b, c = tuple_3

"""元组的切片(并非修改其内容)"""
print(tuple_3[::-1])

"""知道‘元组的元素’查看其‘索引’"""
print(tuple_1.index("apple"))

"""元组的嵌套"""
tuple_4 = ((1, 8, 3), (5, 1))

"""统计某个元素的个数"""
tuple_5 = (5, 6, 1, 3, 1, 2, 1, 8)
res = tuple_5.count(1)
print("有%d个数字‘1’" % res)

列表

"""
目录:
1.创建列表
2.列表的拼接
3.列表的解压赋值
4.列表的切片
5.列表的元素的索引
6.列表的嵌套
7.统计某个元素的个数
8.列表的元素添加
9.列表的元素删除
10.替换元素
11.元素排序
12.列表推导式
13.拷贝
"""

"""创建列表"""
# 1.强制:使用list()
# 2.普通:
list_0 = []
list_1 = [1]
list_2 = [2, 3, 4, 5]

"""列表的拼接"""
list_new_1 = list_1 + list_2
list_new_2 = list_1 * 3

"""列表的解压赋值"""
list_3 = [1, 2, 3]
a, b, c = list_3

"""列表的切片"""
print(list_3[0:3:2])
# 从第零个开始拿,直到3-1为止.每走两步向下拿个东西

print(list_3[::])
# 全部‘顺序’切片,等价于list_3[::1]

print(list_3[::-1])
# 全部‘倒序’切片

"""知道‘列表的元素’查看其‘索引’"""
print(list_3.index(1))

"""列表的嵌套"""
list_3 = [[1, 2], [1, 2, 3, 4], [0]]

"""列表推导式"""
list_4 = [i for i in range(9) if i < 5]
list_5 = [i for i in "hello_world"]

"""列表的元素添加"""
list_6 = [66, 77, 88, 99]

str_1 = "每次只能添加一个元素"
list_6.append(str_1)

list_new_3 = [211, "extend是并入一个列表", 985]
list_6.extend(list_new_3)

"""列表的元素删除"""
str_2 = "remove() 函数用于移除列表中某个值的第一个匹配项,没有返回值"
list_6.remove(str_2)

str_3 = "pop() 函数用于移除列表中的一个元素(默认最后一个元素)并且返回该元素的值"
list_6.pop()

list_6.clear()  # 清空列表

"""替换元素"""
list_6[0] = 233
list_6[:3:] = 1, 2, 3

"""元素排序"""
list_7 = [5, 9, 1, 7, 3]
# 顺序:sort()
list_7.sort()
print(list_7)
# 逆序:reverse() or sort(reverse=True)
list_7.reverse()
print(list_7)

"""统计某个元素的个数"""
res = list_7.count(1)

"""拷贝"""
# 1.浅拷贝:copy()---仅拷贝父对象，不会拷贝对象的内部的子对象
list_8 = [[1, 2], 3, 4, 5]
print("原来的>>>", list_8)

res_1 = list_8.copy()
res_1[3] = 55
print(res_1)
print(list_8)

list_8 = [[1, 2], 3, 4, 5]
print("原来的>>>", list_8)

res_2 = list_8.copy()
res_2[0][0] = 22
print(res_2)
print(list_8)

# 2.深拷贝:---完全拷贝了父对象及其子对象
import copy

res_3 = copy.deepcopy(list_8)

字典

"""
目录:
1.创建字典
2.字典的get函数
3.字典的拼接
4.字典的嵌套
5.统计字典有多少个‘键值对’
6.字典推导式
7.字典元素的添加
8.字典元素的修改
9.字典元素的删除
10.拷贝
11.字典的 items()函数
"""

"""创建字典"""
# 1.强制:dict()
# 2.普通:
dict_0 = {}
dict_1 = {"key": 150}
dict_2 = {
    "name": "小明",
    "age": 18,
    "hobby": "打篮球"
}

"""字典的get函数"""
res = dict_2.get("name", "查无此人")  # res:小明 若"name"键不存在 则返回后面的"查无此人"

"""字典的拼接"""
dict_3 = {**dict_1, **dict_2}
print(dict_3)

"""字典的嵌套"""
dict_4 = {
    "叶寻": {"age": 20, "height": 180},
    "小明": {"age": 15, "height": 165}
}

"""统计字典有多少个‘键值对’"""
print(len(dict_3))
print(len(dict_4))

"""字典推导式"""
dict_5 = {i: i ** 2 for i in range(5)}

"""字典元素的添加(直接添加即可)"""
dict_6 = {}
dict_6["age"] = 15
dict_6["name"] = 8

"""字典元素的修改"""
dict_7 = {"age": 18}
dict_7["age"] = 50

"""字典元素的删除"""
del dict_7["age"]
dict_7.clear()  # 清空字典
del dict_7  # 删除字典

"""拷贝"""
# 1.浅拷贝:copy()---仅拷贝父对象，不会拷贝对象的内部的子对象
dict_8 = {"color": {"red": "红色", "yellow": "黄色"}, "weight": 50}
print("原来的>>>", dict_8)

res_1 = dict_8.copy()
res_1["weight"] = 999
print(res_1)
print(dict_8)

dict_8 = {"color": {"red": "红色", "yellow": "黄色"}, "weight": 50}
print("原来的>>>", dict_8)

res_2 = dict_8.copy()
res_2["color"]["red"] = "玫瑰红"
print(res_2)
print(dict_8)

# 2.深拷贝:---完全拷贝了父对象及其子对象
import copy

res_3 = copy.deepcopy(dict_8)

"""字典的 items()函数"""
# items()的作用是把字典中的每对key和value组成一个元组 并把这些元祖放在列表中返回
d = {"red": 1, "blue": 2, "green": 3}
for i, v in d.items():
    print(i, v)

集合

"""
目录:
1.创建集合
2.去重
3.成员操作符(in_or_not_int)
4.枚举(列举)
5.增、删
6.交集
7.并集
"""

""" 创建集合"""
# 创建空集合(必须使用 set() 而不是 {} 因为 s = {} 默认创造出的是空‘字典’):
set_0_0 = set()  # 强转‘虚无’为集合
set_0_1 = set(())  # 强转‘空元组’为集合
set_0_2 = set([])  # 强转‘空列表’为集合
set_0_3 = set({})  # 强转‘空字典’为集合

# 创建非空集合(可以直接使用 s = {} 创建非空集合，但内容必须填上，且不能填‘键值对’):
set_1 = {4, 5, 6}

list_temp = [55, 66, 77]
set_2 = set(list_temp)

"""去重"""
list_new = [1, 1, 1, 1, 1, 2, 3, 4, 5]
set_3 = set(list_new)  # 自动去除重复内容

"""成员操作符(in_or_not_int)"""
print(5 in set_3)  # True or False

"""枚举(列举)"""
s = {1, 2, 3, 4, 5}
for i, v in enumerate(s, start=0):
    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
    # 同时列出数据和数据下标，一般用在 for 循环当中
    # 索引默认从0开始(即:start = 0)
    print('index: %s,value: %s' % (i, v))

"""增、删"""
s.add(10)  # 增加一个元素
s.update([5, 2, 3, 6])  # 添加多个元素

s.pop()  # 删除最前面的元素【第一个】
s.remove(5)  # 指定删除某个元素

"""交集"""
s1 = {1, 2, 99, 88}
s2 = {1, 2, 55, 66}
s3 = {1, 2, 10, 20}
print(s1.intersection(s2, s3))  # intersection()方法用于返回两个或更多集合的‘交集’
# 符号方法更简单 --->>>  print(s1 & s2 & s3)

"""并集"""
print(s1.union(s2, s3))  # union()方法用于返回两个或更多集合的‘并集’
# 符号方法更简单 --->>>  print(s1 | s2 | s3)


"""差集"""
print(s1 - s2)

"""对称差集"""
print(s1 ^ s2)
# 上面的一行等价于 --->>>  print((s1 - s2) | (s2 - s1))

"""父子集"""
print(s1 > s2)

字符串

"""
目录:
1.创建字符串
2.访问字符串中的值
3.字符串拼接
4.转义字符
5.成员运算符
6.字符串的切片
7.字符串常用函数
"""

"""创建字符串"""
# 1.强制转换str()
# 2.普通
name = "Xiao_Ming"

"""访问字符串中的值"""
str_1 = "abcdfg"
print(str_1[0])

"""字符串拼接"""
str_2 = "i love "
str_3 = "you"
str_4 = str_2 + str_3

"""转义字符"""
# 响铃 \userDate.txt
# 换行 \n
# 横向制表符 \t
# 纵向制表符 \v


"""成员运算符"""
str_5 = "abc"
print("userDate.txt" in str_5)

"""字符串的切片"""
str_6 = "abcdefg"
print(str_6[:5:])
# 结果展示:userDate.txt b.txt c d e
# 索引展示:0 1 2 3 4

"""
字符串常用函数
1.join()
2.replace()
"""

""" 1.join()函数（返回值是"字符串类型"）"""
res_1 = ":".join("快遍历并插入进来")
res_2 = "".join(["我", "是", "一", "个", "数", "组"])  # 列表转换为字符串的方法

""" 2.replace() """
# replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，
# 如果指定第三个参数max，则替换不超过 max 次
str_n = "我是他朋友"
print(str_n.replace("他", "你"))

格式化输出

# (一)占位符
'''
%s 字符串
%c 字符
%d 十进制（整数）
%o 八进制整数
%x 十六进制整数
'''
print("我的年龄为%d" % 28)
print("我是%s,它是%s" % ("小明", "金刚"))
print("你看看它们，一个是%(male)s,一个是%(female)s" % {"female": 1, "male": 2})

# (二)字符串的拼接
a = "你好呀!"
b = "我是XXX"
c = a + b
print(c)

# (三)格式化填充


a = '{0:🤭^10}'.format('567')
# 符号:后面是填充符
# 符号^表示居中，
# 如果为符号<则是居左
# 10表示总长度
print(a)

b = '{:02}:{:02}:{:02}'.format(13, 4, 57)
# 0是填充符，2是width，表示位数为2
# 结果：
'13:04:57'
print(b)

"""  1.整数的输出  """
# print('%o' % 20)  # 八进制
# print('%d' % 20)  # 十进制
# print('%x' % 20)  # 十六进制

"""  2.浮点数输出  """
# print('%f' % 1.11)  # 默认保留6位小数
# print('%0.1f' % 1.11)  # 取1位小数
# print('%e' % 1.11)  # 默认取6位小数，用科学计数法
# print('%0.3e' % 1.11)  # 取3位小数，用科学计数法
# print('%g' % 1111.1111)  # 默认取6位有效数字
# print('%.7g' % 1111.1111)  # 取7位有效数字
# print('%.2g' % 1111.1111)  # 取2位有效数字，自动转换为科学计数法

"""  3.字符串输出  """
# print('%s' % 'hello world')  # 字符串输出
# print('%+20s' % 'hello world')  # 右对齐，取20位，不够则补位
# print('%-20s' % 'hello world')  # 左对齐，取20位，不够则补位
# print('%.2s' % 'hello world')  # 取2位
# print('%10.2s' % 'hello world')  # 右对齐，取2位
# print('%-10.2s' % 'hello world')  # 左对齐，取2位

# 常用转义字符
'''
\   续行符
\\  反斜杆符号
\'  单引号
\"  双引号
\a  响铃
\b  退格（Backspace）
\000 空
\n  换行
\r  回车
\v  纵向制表符
\t  横向制表符
\f  换页
'''

# 综合练习

b = '{num:.2f}'.format(num=3.1415926)
# 2f的意思是以四舍五入的方式保留2位小数。
print(b)

print('%-8s' % '{}x{}={}'.format(1, 2, 3))

循环语句

""" for循环实例 """
# 九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print("%-7s" % "{}x{}={}".format(j, i, j * i), end=" ")
    print()

""" while循环实例 """
# 符号楼梯
while True:

    # 信息录入
    height = int(input("请输入楼梯高度>>>"))
    symbol = input("请输入符号>>>")
    if height <= 0:
        continue

    # 生成符号楼梯
    i = 0
    while i <= height:
        print(symbol * i)
        i += 1

    # 是否退出
    if input("按Q键退出,否则继续").upper() == 'Q':
        break

生成式

"""元组生成式 由于元组不可变 所以不能往元组里面‘添加新的值’ 即不可‘生成’"""

"""列表生成式"""

# 基本操作:
list_basic = ["神兽金刚", "百变金刚", "雷神风暴"]
list_1 = []
for name in list_basic:
    if name.endswith("金刚"):
        list_1.append(name)

# 生成式操作:
list_1 = [name for name in list_basic if name.endswith("金刚")]

"""字典生成式"""
list_basic = ["神兽金刚", "百变金刚", "神兽金刚", "金刚雷神风暴"]
dict_1 = {list_basic.index(i): i for i in (list_basic)}

"""集合生成式"""
list_basic = ["神兽金刚", "百变金刚", "金刚雷神风暴", "神兽金刚"]
set_1 = {name for name in list_basic if name.endswith("金刚")}

"""生成器表达式"""
list_basic = ["神兽金刚", "百变金刚", "金刚雷神风暴", "神兽金刚"]
res = (name for name in list_basic)

"""
知识补充:
———————————————————————————————————————————————————————————
1.
Python中生成器能做到迭代器能做的所有事，
而且因为自动创建了__iter__()和next()方法，
生成器显得特别简洁。
而且生成器也是高效的，
使用生成器表达式取代列表解析，同时节省内存。
除了创建和保持程序状态的自动生成，当发生器终结时
还会自动抛出StopIterration异常。
———————————————————————————————————————————————————————————
2.
列表、元组、字典、字符串都是可迭代对象。
数字、布尔值都是不可迭代的。
———————————————————————————————————————————————————————————
3.
什么是迭代器？
迭代器对象要求支持迭代器协议的对象。
在Python中，支持迭代器协议
就是实现对象的__iter__()和next()方法。
其中__iter__()方法返回迭代器对象本身，
next()方法返回容器的下一个元素，在结尾时引发StopIteration异常。

例子:
list = [1,2,3,4] # list是可迭代对象
lterator = iter(list) # 通过iter()方法取得list的迭代器
print(next(lterator)) # 1 通过next()获取下一个位置的值
print(next(lterator)) # 2
print(next(lterator)) # 3
print(next(lterator)) # 4

输出：
1
2
3
4

———————————————————————————————————————————————————————————
4.
什么是生成器？
生成器(generator)就是一个函数，
它提供了一种实现迭代器协议的便捷方式。
生成器与普通函数的区别在于它包含 yield 表达式，
并且不需要定义 __iter__()和__next__()。
生成器是一种惰性的序列，
如果我们需要创建一个 0～1000000000 的序列，
这样大的序列创建出来会占用比较多的内存，
生成器就是为了解决这样的问题。

例子:

# 普通序列
g = []
for x in range(5):
    g.append(x)
    
# g ----> [0, 1, 2, 3, 4]


# 生成器
def f():
    for x in range(5):
        yield x # 返回并记录函数状态
        
# next
f = f()
>>> next(f) # 每调用一次next，就执行一次yield | 依靠这种需要才生产的工作机制，大大的节省资源
0
>>> next(f)
1
>>> next(f)
2
>>> next(f)
3
>>> next(f)
4

# for next
>>> for x in range(5):
>>>  print(next(f))
0
1
2
3
4
———————————————————————————————————————————————————————————

"""

异常处理

"""

try:
    子代码块

except (异常类型A, 异常类型B, 异常类型C)
    子代码块
    
except 异常类型2 as 别名
    子代码块
    
except 异常类型3 as bbb  # bbb 拿到的是捕获异常所拿到的提示信息
    子代码块
    
except 异常类型4 as eee
    子代码块

except Exception as 别名:
    它是最后的防线，可以捕捉所有的异常！但它根据需求，可写也可不写

else:
    子代码块: 会在
    try的子代码块
    没有异常的时候执行


finally:
    子代码块
    无论如何都执行

"""

序列化和反序列化

'''

1 什么是序列化和反序列化？
    内存中的数据类型 ---(序列化)---> 特定的格式 ( json格式 或者 pickle格式 )
    内存中的数据类型 <---(反序列化)--- 特定的格式 ( json格式 或者 pickle格式 )

2 为何要序列化？
    序列化得到的结果 -> 特定的格式内容有两种用途
    2.1 可用于储存（如：游戏存档）
    2.2 传输给其他平台使用（如：跨平台数据交互）
        Python ------------------------Java
        列表 -------- 特定格式 --------- 数组
         .                              .
         .                              .
         .                              .
        集合(Python特色，无法转换)

3 强调！！！
    针对用途1的特定格式：应该用一种专门的格式比较好，pickle只有Python可以识别，但它可以很好的保留Python的特色
    针对用提2的特定格式：应该用一种通用的，能被所有语言识别的格式 -> json

4 补充~~~(了解)
    l = json.loads('[1, "abc", true, false]') ----- A1
    l = json.loads(b'[1, 'abc', True, False]') ----- A2
    上面两式子都能成功转换！！【Python版本（2.7~3.4）&（3.6~now）】
    注意！Python 3.5 中，A2式子会报错
    A1中的内容是json格式，它是str类型
    A2中的内容是 bytes类型


'''

# 实例！！！


''' 1  json的实例 '''

import json

# # 1 如何序列化和反序列化
# # 1.1 序列化
# res = json.dumps([1, 'abc', True, False])
# print(res, type(res))
#
# # 1.2 反序列化
# l = json.loads(res)
# print(l, type(l))

# 2 在文件中以json格式写入信息和读取信息

# # 2.1.1 写入信息(复杂方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'wt', encoding='utf-8') as f:
#     res1 = json.dumps([1, 'abc', True, False])
#     f.write(res1)
#
# # 2.1.2 读取信息(复杂方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'rt', encoding='utf-8') as f:
#     res2 = f.read()
#     l = json.loads(res2)
#     print(l, type(l))

# # 2.2.1 写入信息(简单方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'wt', encoding='utf-8') as f:
#     res1 = json.dump([1, 'abc', True, False], f)
#
# # 2.2.2 读取信息(简单方法)
# with open(r'C:\Users\叶寻\Desktop\Python\new_course\test.txt', 'rt', encoding='utf-8') as f:
#     l = json.load(f)
#     print(l, type(l))


''' 2  pickle的实例 '''

import pickle

res = pickle.dumps({1, 2, 3, 4, 5})
print(res, type(res))

s = pickle.loads(res)
print(s, type(s))

猴子补丁

'''

当使用别人的模块不是很顺利的时候
我们可以在执行文件的入口处加上一个自己的补丁
当我们想要反悔的时候
删掉入口文件中的补丁即可

'''

# 例如：假设当前文件为执行的入口，ujson是比json更强的模块，
# 但是我们已经用json写了很多功能了！！又不想牵一发而动全身
# 这时，我们可以在入口文件（即本文件）加入补丁

import json
import ujson


def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads


# 在入口文件中运行
monkey_patch_json()

知识补充

# coding:utf-8

# 交叉赋值
m = 10
n = 20
n, m = m, n

# 解压赋值
# 取前面部分的值
l = [1, 2, 3, 4, 5, 6, 7]
x, y, z, *aaa = l
a, b, c, *_ = l
print(aaa)
print(_)

# 取后面部分的值
ll = [1, 2, 3, 4, 5, 6, 7]
*_, a1, b1, c1 = ll
print(_)

# 百分之78
print("百分率>>> %s  %%" % 78)