####  一：注释
#注释：对代码的解释
#注释快捷键：notepod++: ctrl + q / pychorm: ctrl + /  |ctrl + z 撤销 | ctrl + y 反撤销

'''
代码注释原则:
不用给全部代码加注释，只需要在自己觉得重要或不好理解的部分加注释即可
注释可以用中文或英文，但绝对不要拼音噢
注释不光要给自己看，还要给别人看，所以请认真写
'''

#注释的分类 （1）单行注释 （2） 多行注释

# （1）单行注释： #
# python2.7  print '你好'   python3.x  print('你好')
# （2）多行注释： ''' """
'''
print("天天,今年25,计算机,湖北")
print("空空,今年32,网络,北京")
print("飞飞,今年18,电子商务,湖南")
print("小雨,今年24,通信,北京")
'''

"""
print("天天,今年25,计算机,湖北")
print("空空,今年32,网络,北京")
print("飞飞,今年18,电子商务,湖南")
print("小雨,今年24,通信,北京")
"""

# (3) 注释的嵌套
'''
如果外面使用了三个单引号，里面用三个双引号
如果外面使用了三个双引号，里面用三 个单引号
序号把单双引号岔开
'''

# (4) 注释的排错性

'''
包裹一部分代码,执行另外一部分,查看是否报错,
如果没问题,继续在拿出一部分代码运行,查看是否报错
如果有,可以直接找到错误,如果没有,依次推推
'''
'''
print("天天,今年25,计算机,湖北")
print("空空,今年32,网络,北京")
print("飞飞,今年18,电子商务,湖南"
'''
print("小雨,今年24,通信,北京")



####  二：变量
# (1)变量的概念
test1 = "天天"
test1 = "空空"
print(test1)


# (2)变量的声明
# 1
a = 5
b = 6
print(a)
print(b)

# 2
a,b = 10,11
print(a,b) #让两个变量在一行打印出来，用逗号隔开

# 3
a = b = 88
print(a,b)


# (3)变量的命名
"""
变量的命名规范：
字母数字下划线，首字母不能为数字；
严格区分大小写，且不能使用关键字；
变量命名有意义，且不能使用中文哦。
"""
"""
以下关键字不能声明为变量名
[‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
"""

a123 = 1666
# *_1632 = 1111 #error
# 145abc = 2221 #error
abc = 2
ABC = 20
print(abc)
print(ABC)

# import 引入 keyword 系统的模块(文件) 模块.成员 来进行调用 => 打印所有的系统关键字
import keyword
print(keyword.kwlist)

'''
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
'''

# print = 123
# print(print)
mycar = "特斯拉"
ddafafaga = "别摸我bwm" # 名字没有任何意义,不推荐,写名字的时候,要见名知意
print(ddafafaga)

my_dog_food = "香肠"
print(my_dog_food)

中文 = "jacklove"
print(中文)
"""
(1) 容易乱码
      编码集utf-8 (万国码 , 可变长的unicode编码集) , 一个中文按照3个字节存储,英文数字特殊符号一个字节
      编码集gbk   (国标码) ,一个中文按照2个字节存储,英文数字特殊符号一个字节

(2) 占用空间大
      zz = "jacklove"    占用2个字节
      中文 = "jacklove"  占用6个字节
"""


# (4)变量的交换
# 通用
a = 200
b = 200
tmp = a
a = b
b = tmp
print(a,b)

# python特有
a = 200
b = 220
a,b = b,a
print(a,b)

# (5)常量 : 不可改变的量 (约定俗成把都是大写的变量作为常量,意味着不能改变值)
SHENFENZHENG = 210202200010166688
print(SHENFENZHENG)



####  三：数据类型
## 1. int 整型(正整数,0,负整数)

intvar = 66
print(intvar)

#tpye 获取一个值的类型
res = type(intvar)
print(res)

# id 获取一个值的地址
res = id(intvar)
print(res)


# 二进制整型
intvar = 0b101
print(intvar)

intvar = 0o1010
print(intvar)
print(type(intvar))

# 十六进制
intvar = 0xff
print(intvar)
print( type(intvar) )


## 2. float 浮点型（小数）
# 表示方式一
floatvar = 6.99
print(type(floatvar))

# 表示方式二 (科学计数法)
floatvar = 3.14e5
floatvar = 314.12e-5
print(floatvar) # 314000.0
print( type(floatvar)  )


# 3. bool 布尔类型(True -> 真值 False -> 假值) 主要用记逻辑判断
boolvar = True
boolvar = False
print(type(boolvar))
print(boolvar)
a = 3
b = 6
a > b # False

# 4. complex 复数类型
"""
复数 = 实数 + 虚数
complexvar = 4 + 7j
实数: 4
虚数: 7j
j   : 如果有一个数,它的平方等于-1,那么这个数等于j,表达一个高精度的类型(科学家认为有)
"""
# 表达方式一
complexvar = 3 + 7j
complexvar = -30j
print(type(complexvar))
print(complexvar)

# 表达方式二
'''complex(实数,虚数)'''
complexvar = complex(3,7)
print(complexvar)



# 4. 字符串类型 str
'''用引号引起来的就是字符串'''
"""
# 转义字符： \ + 字符
（1）把有意义的字符变得无意义
（2）把无意义的字符变得有意义

\n    :换行
\r\n  :换行
\t    :缩进tab（水平制表符）
\r    :把\r后面的字符串拉到当前行行首
"""

# (1) 单引号字符串
strvar = '今天天气真好啊'
print(strvar,type(strvar))

# (2) 双引号字符串
# 把无意义的字符变得有意义
strvar = "test真帅,\n帅的掉渣"
print( strvar , type(strvar) )

strvar = "test真帅,\r\n帅的掉渣"
print( strvar , type(strvar) )

strvar = "test\t真帅,帅的掉渣"
strvar = "test\n真帅,\r帅的掉渣"
print( strvar , type(strvar) )

# 把有意义的字符变得无意义
strvar = "test真\"帅\""
strvar = 'test真"帅"'
print( strvar , type(strvar) )

# (3) 三引号字符串 (可以换行)
msg = '''
这是一个多行字符串的实例
多行字符串可以使用制表符TAB ( \t )。
也可以使用换行符 \n 。
'''
print(msg)

# (4) 元字符串 r"字符串" 不转义字符,原型化输出字符串
path = r"C:\Users\liucx\Kubernetes"
print(path)

# (5) 字符串的格式化
"""
语法:
   "字符串" % (值1,值2,值3 .... )
    %d 整型占位符
    %f 浮点数占位符
    %s 字符串占位符
"""

# %d 整型占位符
strvar = "今天花费了我%d个小时"%(8)
print(strvar)
# %2d 占两位，不够两位的拿空格来补，原字符串居右
strvar = "今天花费了我%2d个小时"%(8)
print(strvar)
# %-2d 占两位，不够两位的拿空格来补，原字符串居左
strvar = "今天花费了我%2d个小时"%(8)
print(strvar)


# %f 浮点数占位符
strvar = "今天去超市购物消费了%f元"%(99.5)
print(strvar)
# %.2f 浮点数占位符数点保留2位(存在四舍五入)
strvar = "今天去超市购物消费了%.2f元"%(99.566)
print(strvar)


# %s 字符串占位符
name = 'Runoob'
strvar='Hello %s' %name
print(strvar)


# 综合案例
strvar = "%s今天发了%.2f元，准备去买%d个特斯拉" %("小明",20000.8888,5)
print(strvar)

strvar = "%s今天发了%s元，准备去买%s个特斯拉" %("小明",20000.8888,5)
print(strvar)


####  四：列表类型
# 1.定义列表
""" 特点：可获取，可以修改，有序"""
# 空列表
listvar = []
print(listvar,type(listvar))

# 普通列表
list1 = [1, 2, 3, 4, "星空" ]
print(list1)

# 正向索引下标    0    1   2   3   4   5
list2 =        ["a","b","c","d","e","f"]
# 逆向索引下标    -6   -5 -4  -3  -2  -1

# 2.获取列表当中的元素
res = list2[3]
print(res)

# 3.修改列表当中的元素
list2[3] = "liu"
print(list2)

# 4.获取列表中最后一个元素
# python特有
res = list2[-1]
print(res)

# 所有语言通用 (len 获取容器类型数据的所有元素个数)
length = len(list2) #6
print(length)
res = list2[length -2] # 6-2= 4
print(res)

# 删除元素 list.remove(obj)
listvar = ['Jack', 'Rain', '小明', 'Rachel', 'Mack', '小飞']
listvar.remove('小明')
print(listvar)

# 插入元素 list.insert(index, obj)
listvar = ['Jack', 'Rain', '小明', 'Rachel', 'Mack', '小飞']
listvar.insert(3,'小小')
print(listvar)


####  五：元组类型
""" 特点：可获取，不可修改，有序  """
# 所谓元组的不可变指的是元组所指向的内存中的内容不可变。
# (1) 定义元组
# 空元组
tuplevar = ()
print(tuplevar,type(tuplevar))

# 普通元组
# 正向索引下标    0    1   2   3   4   5
tuplevar =     ("a","b","c","d","e","f")
# 逆向索引下标    -6   -5 -4  -3  -2  -1

# (2)可获取元组当中的元素
res = tuplevar[4]
res = tuplevar[-2]
print(res)

# (3) 可修改元组当中的元素么? 不可以

#tuplevar[2] = 123 error

# (4) 元组的注意点:
'''逗号是元组的标识符'''
tup1 = (50)     # 不加逗号，类型为整型
print(tup1,type(tup1))
tup1 = (50,)    # 加上逗号，类型为元组
print(tup1,type(tup1))

tuplevar = (3+90j,)
tuplevar = 3+90j,
print( tuplevar , type(tuplevar) )



####  六：字符串类型
"""特点:可获取,不可修改,有序"""
# 1.定义字符串
#在Python中,加了引号的字符都被认为是字符串！
#         01234
strvar = 'abcde'
#        -5-4-3-2-1

# 定义空字符串
strvar = ''
print(strvar)

# 2.获取字符串当中的元素
strvar = 'abcde'
res = strvar[3]
res = strvar[-2]
print(res)

# 3.可以修改字符串中的元素么? 不行
# strvar[0] = "z" error


# ### 七：set 集合 (作用:交差并补)
'''
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

"""特点: 集合无序,自动去重，可变"""

'''
# 1.定义集合
setvar = {"小明","小浩","小天","小野"}
print(setvar , type(setvar))

# 2.集合的无序性：（既不能获取其中的元素，也不能修改其中的元素）
# 集合不能获取元素
# res = setvar[0] error
setvar = {"小明","小浩","小天","小野"}
print(setvar)  #多次执行，无序


# 3.自动去重
setvar = {"小明","小浩","小天","小野","小天","小强"}
print(setvar)

# 4.集合的注意点  空集合
setvar = set()
print(setvar , type(setvar))


# ### dict 字典
"""
特点：键值对存储的数据,表面上有序,实际上无序. 
dictvar = {键1:值1,键2:值2,......}

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

"""
# 1.定义字典
# 空字典
dictvar = {}
print(dictvar,type(dictvar))

# 普通字典
dictvar = {"zjl":"周杰伦","lyf":"刘亦菲","cl":"成龙","wbq":"王宝强"}

# 2.获取字典当中的值
res = dictvar["lyf"]
print(res)

# 3.修改字典当中的值,可修改
dictvar["lyf"] = "李易峰"
print(dictvar,type(dictvar))

# ### 对于字典的键 和 集合中的值有数据类型上的要求:
'''
# 不可变的数据类型（可哈希），允许
Number（int，bool，float，complex） str tuple
# 可变的数据类型（不可哈希）,不允许
list  set dict

哈希算法: 字典和集合底层在进行存储时,都使用了哈希算法,存储时是无序的散列
作用:更加均匀的把数据分配在内存中进行存储.计算值时必须是Number str tuple
提到哈希算法: 无序散列

3.6版本之后,对字典做了优化,存储时仍然是无序的散列
拿出时按照字面顺序重新排列,表面上有序的,实际上无序,

在做字典的键时: 推荐使用变量命名的字符串

'''
# 字典中键为数字、字符串、元组
dictvar = {1:1,False:"ss",3+2j:5,"中文汉字":6,(1,2,3):9}
res = dictvar["中文汉字"]
print(res,type(dictvar))
# 字典中键为列表、集合
# dictvar = {[1,2,3]:1} error
# dictar = {{1,2,3}:1} error

#集合中为列表
# setvar = {1,2,3,[1,2,3,4]} error
# setvar = {"a", (1, 2, 3, [4, 5, 6])}  #嵌套也不行 error