'''
@Author: llody
@Date: 2020-07-06 09:16:26
@LastEditTime: 2020-07-06 16:52:13
@LastEditors: Please set LastEditors
@Description: In User Settings Edit
@FilePath: \web\数据类型.py
'''
"""
python数据类型：
Python 可以处理 7 种类型的数据：
数值，字符串，布尔值，列表，元组，字典，集合
"""
print("数值类型的数据表示整数、浮点数、复数，例如：整数 123,浮点数 123.456,复数 1 + 2j")
print("\033[5;31;40mPython 数据类型：数值\033[0m")
"""
Python 的数值可以表示三种类型的数据：
整数 ：可以表示正数，例如 123；可以表示负数，例如 123；使用 0 表示零。
浮点数：浮点数由整数部分与小数部分组成，例如 123.456。
复数：复数由实数部分和虚数部分构成，例如 1 + 2j，实数部分是 1，虚数部分是 2。
主要有：加减乘除，求模，幂运算，比较运算
Python 提供了 6 种比较运算用于比较数值大小
运算符 功能描述
> 大于
>= 大于或者等于
== 等于
!= 不等于
< 小于
<= 小于等于
"""
print("\033[5;31;40mPython 数据类型：字符串\033[0m")
a,b,c,d = (123,123.456,1+2j,True)
print(type(a),type(b),type(c),type(d))
print("字符串类型的数据表示一段文本，使用单引号、双引号创建，例如：单引号字符串 ‘hello’,双引号字符串 “hello”")
tinty = "python"
tinty1 = "hello world"
print(tinty)
print(tinty[2:])
print(tinty[1:3])
print(tinty * 2)
print(tinty + " mysql")
print("统计字符串长度",len(tinty))
print("判断字符串是否包含p","p" in tinty)
print("常用字符串方法:")
print("字符串第一个字母大写：",tinty.capitalize())
print("统计字符串出现的次数：",tinty.count(tinty))
print("startswith(target) 方法检查字符串是否是以字符串 target 开头:",tinty.startswith(tinty))
print("endswith(target) 方法检查字符串是否是以字符串 target 结尾:",tinty.endswith(tinty))
print("lower() 方法将字符串中所有大写字符转换为小写:",tinty.lower(),"判断所有字符串为小写为真",tinty.islower())
print("upper() 方法将字符串中所有小写字符转换为大写:",tinty.upper(),"判断所有字符串为大写为真",tinty.isupper())
print("find(target) 检查指定字符串target，包含返回指定字符串索引，不包含返回-1",tinty.find('y'))
print("split() 方法,使用空格将字符串分割为多个单词，返回一个列表",tinty1.split())
"""
在 Python 中使用反斜杠 \ 加字母的组合来表示一些特殊字符，例如：\n 表示换行，\ 之后的字符 n 的含义已经不再是原来 ASCII 字符的含义了，所以被称为转义字符。
常用的转义字符如下所示：
转义字符 描述
\t 制表
\n 换行
\’ ’
\" "
\\ \
占位符：
% 是一个特殊的符号，后面跟着一个字符用于说明参数的类型：
%s 表示字符串
%d 表示整数
%f 表示浮点数
有多种类型的占位符，初学时需要掌握如下常用的占位符：
符号 描述
%% 用于表示 %
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%f 格式化浮点数
字符串和数值一样，同样有基本的运算方式，但是最终得到的结果形式和数值却略有不同，大家在使用的时候要注意这一点。
"""
print("\033[5;31;40mPython 数据类型：布尔值\033[0m")
print("布尔值类型的数据表示逻辑运算结果，有两种取值：真，使用 True 关键字表示。假，使用 False 关键字表示。")
"""
1. 比较运算
Python 提供了 6 种比较运算用于比较数值大小
运算符 功能描述
> 大于
>= 大于或者等于
== 等于
!= 不等于
< 小于
<= 小于等于
2. 与或非逻辑运算
Python 提供了与、或、非三种基本逻辑运算
逻辑运算 表达式 功能描述
与 x and y x 和 y 都为真，则结果为真；x 为假或者 y 为假，则结果为假
或 x or y x 为真或者 y 为真，则结果为真; x 和 y 都为假，则结果为假
非 not x x 为真，则结果为假；x 为假，则结果为真
布尔值是一个非常简单的数据类型，只有简单的真和假两种表现形式。
"""
print("\033[5;31;40mPython 数据类型：列表\033[0m")
print("列表是一个有序的序列，列表中所有的元素放在 [] 中间，并用逗号分开")
print("[1, 2, 3]，一个包含 3 个整数的列表")
print("[‘a’, ‘b’, ‘c’]，一个包含 3 个字符串的列表")
print("\033[5;36;40m常见运算操作\033[0m")
print("\033[5;35;40m2.1 运算符 +\033[0m")
a = [1.2]
b = [3,4]
c = a + b
print(c)
print("\033[5;35;40m2.2 运算符 *\033[0m")
c = a * 2
print(c)
print("\033[5;35;40m2.4 索引 []\033[0m")
a = ["python","go","java","php"]
print(a)
print(a[0])
print(a[1:])
print(len(a))
print("\033[5;35;40m使用函数 max 获取列表中最大的元素\033[0m")
print(max(a))
print("\033[5;35;40m使用函数 min 获取列表中最小的元素\033[0m")
print(min(a))
print("\033[5;35;40m4. 常见方法\033[0m")
print("\033[5;35;40mappend(item) 方法向列表中新增一个元素 item\033[0m")
print(a)
a.append("docker")
print(a)
print("\033[5;35;40minsert(index, item) 方法用于将元素 item 插入列表的指定位置\033[0m")
print(a)
a.insert(5,"redis")
print(a)
print("\033[5;35;40mpop() 方法从列表的尾部取走一个元素\033[0m")
print(a)
a.pop() #取走最后一个
a.pop(4) #取走第四个
print(a)
print("\033[5;35;40mremove(item) 方法从列表中删除指定元素 item\033[0m")
print(a)
a.remove("java")
print(a)
print("\033[5;35;40mindex(item) 方法在列表中查找指定元素 item，如果找到元素 item，则返回元素 item 的索引；如果找不到，则抛出异常。\033[0m")
print(a)
a.index('go')
print("\033[5;35;40mreverse() 方法将列表中元素倒序排列\033[0m")
print(a)
a.reverse()
print(a)
print("\033[5;35;40msort() 方法对列表中元素进行排序\033[0m")
print("\033[5;35;40m缺省情况下，sort 方法对列表中的元素按递增进行排序\033[0m")
print(a)
a.sort()
print(a)
print("\033[5;35;40m通过使用选项 reverse = True 让列表按递减排序\033[0m")
print(a)
a.sort(reverse= True)
print(a)
print("\033[5;31;40mPython 数据类型：元祖\033[0m")
"""
元组是一个和列表和相似的数据类型，两者拥有着基本相同的特性，但是也有很多不同的地方，这节课我们来详细的介绍下元组这个数据类型
"""
print("\033[5;33;40m元组是一个有序的只读序列，元组中所有的元素放在 () 中间，并用逗号分开\033[0m")
print("(1, 2, 3)，一个包含 3 个整数的元组")
print("(‘a’, ‘b’, ‘c’)，一个包含 3 个字符串的元组")
print("\033[5;33;40m1.2 元组与列表的区别\033[0m")
print("元组与列表很相似，都是有序的只读序列，两者有相同的方法和操作运算，它们的区别在于：\n列表创建后，可以进行修改\n元组创建后，不能进行修改")
print("修改列表")
x = [1,2,3]
x[0] = 11
print(x)
print("修改元祖")
y = (1,2,3)
#y[0] = 11 #修改元祖会报错故注释掉了
print(y)
print("\033[5;33;40m1.3 特殊的元组\033[0m")
print("\033[5;33;40m如果一个元组没有包含任何元素，使用 () 表示一个空元组\033[0m")
t = ()
print(t)
print("\033[5;33;40m如果一个元组只包含了一个元素 item，需要在元素后加一个逗号，使用 (item, ) 表示该元组\033[0m")
t = (123,)
i = (123)
print(t)
print("注意，(123, ) 和 (123) 两者表示不同的含义：\n(123, ) 表示的是一个元组，元组中包含一个整数 123\n\033[5;32;40m(123) 表示的是一个带括号的表达式，整数 123 嵌入括号中\033[0m")
print("i == 123整数，为真：",i == 123)
print("t == 123整数，为假：",t == 123)
print("\033[5;31;40m元祖也支持与列表相同的常见的运算操作，函数，方法，\033[0m")
print("\033[5;31;40m一定要注意元组和列表的不同之处。一定要注意元组和列表的不同之处。一定要注意元组和列表的不同之处。重要的事情说三遍。元组一般适合用来存储不变的数据，例如学生的基本信息，例如地图坐标信息等等。\033[0m")
print("=============================华丽丽的分割线==================================")
print("\033[5;31;40mPython 数据类型：字典\033[0m")
"""
字典由键和对应值成对组成，字典中所有的键值对放在 {} 中间，每一对键值之间用逗号分开，例如：
{‘a’:‘A’, ‘b’: ‘B’, ‘c’:‘C’}
字典中包含3个键值对
键 ‘a’ 的值是 ‘A’
键 ‘b’ 的值是 ‘B’
键 ‘c’ 的值是 ‘C’
{1:100, 2: 200, 3:300}
字典中包含3个键值对
键 1 的值是 100
键 2 的值是 200
键 3 的值是 300
"""
book = {'title': 'Python 入门基础', 'author': '张三', 'press': '机械工业出版社'}
print("\033[5;35;40m2. 常见操作\033[0m")
print("\033[5;35;40m2.1 读取字典\033[0m")
print(book)
a = book['title']
print(a)
print("\033[5;35;40m2.2 修改字典\033[0m")
print(book)
a = book['title'] = "python 进阶教程"
print(a)
print(book)
print("\033[5;35;40m2.3 在字典中增加键值对\033[0m")
print(book)
book['time'] = '2020年7月6日'
print(book)
print("\033[5;35;40m2.4 在字典中删除键值对\033[0m")
print(book)
del book['time']
print(book)
print("\033[5;35;40m2.5 查询字典\033[0m")
print("\033[5;35;40m通过关键字 in 检查字典中是否包含指定元素\033[0m")
print(book)
print("字典中的KEY是否有time：",'time' in book)
print(book)
print("\033[5;35;40m3. 常见函数\033[0m")
print("\033[5;35;40m使用函数 len 获取字典中键值对的数量\033[0m")
print(book)
print(len(book))
print("\033[5;35;40mpop(key) 方法删除字典给定键 key 所对应的键值对，返回被删除的值\033[0m")
print(book)
a = book.pop('press')
print(a)
print(book)
print("\033[5;35;40mclear() 方法删除字典中所有的键值对\033[0m")
print(book)
print(book.clear())
print(book)
print("\033[5;35;40m5. 遍历字典\033[0m")
print("\033[5;35;40m可以使用 for key in dict 遍历字典中所有的键\033[0m")
x = {'a':'A', 'b':'B'}
print(x)
for key in x:
print(key)
print("\033[5;35;40m5字典提供了 keys() 方法返回字典中所有的键，可以使用 for key in dict.keys() 遍历字典中所有的键\033[0m")
print(x)
for key in x.keys():
print(key)
print("\033[5;35;40m字典提供了 values() 方法返回字典中所有的值，可以使用 for key in dict.values() 遍历字典中所有的值\033[0m")
print(x)
for value in x.values():
print(value)
print("\033[5;35;40m可以使用 for item in dict.items() 遍历字典中所有的键值对\033[0m")
print(x)
for item in x.items():
key = item[0]
value = item[1]
print('%s:%s' %(key,value))
print(x)
for key,value in x.items():
print('%s:%s' % (key, value))
print("=============================华丽丽的分割线==================================")
print("\033[5;31;40mPython 数据类型：集合\033[0m")
print("\033[5;35;40m集合是一个无序、不重复的序列，集合中所有的元素放在 {} 中间，并用逗号分开\n{1, 2, 3}，一个包含 3 个整数的列表\n{‘a’, ‘b’, ‘c’}，一个包含 3 个字符串的列表033[0m")
print("\033[5;33;40m1.2 集合与列表的区别\n列表中的元素允许重复，集合中的元素不允许重复\n列表是有序的，提供了索引操作，集合是无序的，没有索引操作\033[0m")
print("\033[5;31;40m2. 常见函数\033[0m")
a = {1,2,3,4,5,6,7,8}
print(a)
print("集合长度",len(a))
print("集合中最大的",max(a))
print("集合中最小的",min(a))
print("\033[5;33;40madd(item) 方法向集合中新增一个元素 item\033[0m")
print(a)
a.add(9)
print(a)
print("\033[5;33;40mclear() 方法移除集合中的所有元素\033[0m")
print(a)
a.remove(9)
print(a)
print("\033[5;33;40mclear() 方法移除集合中的所有元素\033[0m")
print(a)
a.clear()
print(a)
print("\033[5;33;40munion() 方法返回两个集合的并集\033[0m")
x = {1, 2, 3}
y = {4, 5, 6}
z = x.union(y)
print("集合X",x)
print("集合y",y)
print("合并后",z)
print("\033[5;33;40mintersection() 方法返回两个集合的交集\033[0m")
print(x)
print(z)
i = z.intersection(x)
print("X,Z交集",i)
print("\033[5;33;40missubset() 方法判断指定集合是否为子集\033[0m")
print(x)
print(z)
i = x.issubset(z)
print("x是z的子集",i)
print("\033[5;33;40missuperset() 方法判断指定集合是否为超集\033[0m")
print(x)
print(z)
i = x.issuperset(z)
print("x是z的超集",i)
print("集合不存在重复元素这一特性能用来干的事情非常多。比如说一个学校要把全校所有学生的信息录入到系统中，为了避免某一学生的信息重复录入只需要把信息存入集合就可以避免这一错误。")
