元组
"""
目录:
1.创建元组
2.元组的拼接
3.元组的解压赋值
4.元组的切片
5.元组的元素的索引
6.元组的嵌套
7.统计某个元素的个数
"""
"""创建元组(元组不可变)"""
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.拷贝
"""
"""创建列表"""
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])
print(list_3[::])
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]
list_7.sort()
print(list_7)
list_7.reverse()
print(list_7)
"""统计某个元素的个数"""
res = list_7.count(1)
"""拷贝"""
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)
import copy
res_3 = copy.deepcopy(list_8)
字典
"""
目录:
1.创建字典
2.字典的get函数
3.字典的拼接
4.字典的嵌套
5.统计字典有多少个‘键值对’
6.字典推导式
7.字典元素的添加
8.字典元素的修改
9.字典元素的删除
10.拷贝
11.字典的 items()函数
"""
"""创建字典"""
dict_0 = {}
dict_1 = {"key": 150}
dict_2 = {
"name": "小明",
"age": 18,
"hobby": "打篮球"
}
"""字典的get函数"""
res = dict_2.get("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
"""拷贝"""
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)
import copy
res_3 = copy.deepcopy(dict_8)
"""字典的 items()函数"""
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_0_0 = set()
set_0_1 = set(())
set_0_2 = set([])
set_0_3 = set({})
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)
"""枚举(列举)"""
s = {1, 2, 3, 4, 5}
for i, v in enumerate(s, 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))
"""并集"""
print(s1.union(s2, s3))
"""差集"""
print(s1 - s2)
"""对称差集"""
print(s1 ^ s2)
"""父子集"""
print(s1 > s2)
字符串
"""
目录:
1.创建字符串
2.访问字符串中的值
3.字符串拼接
4.转义字符
5.成员运算符
6.字符串的切片
7.字符串常用函数
"""
"""创建字符串"""
name = "Xiao_Ming"
"""访问字符串中的值"""
str_1 = "abcdfg"
print(str_1[0])
"""字符串拼接"""
str_2 = "i love "
str_3 = "you"
str_4 = str_2 + str_3
"""转义字符"""
"""成员运算符"""
str_5 = "abc"
print("userDate.txt" in str_5)
"""字符串的切片"""
str_6 = "abcdefg"
print(str_6[:5:])
"""
字符串常用函数
1.join()
2.replace()
"""
""" 1.join()函数（返回值是"字符串类型"）"""
res_1 = ":".join("快遍历并插入进来")
res_2 = "".join(["我", "是", "一", "个", "数", "组"])
""" 2.replace() """
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')
print(a)
b = '{:02}:{:02}:{:02}'.format(13, 4, 57)
'13:04:57'
print(b)
""" 1.整数的输出 """
""" 2.浮点数输出 """
""" 3.字符串输出 """
'''
\ 续行符
\\ 反斜杆符号
\' 单引号
\" 双引号
\a 响铃
\b 退格（Backspace）
\000 空
\n 换行
\r 回车
\v 纵向制表符
\t 横向制表符
\f 换页
'''
b = '{num:.2f}'.format(num=3.1415926)
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
''' 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)
