pract

# -*- coding:utf-8 -*-
# Author:Sure Feng

# print(-6 or 2 > 1) # -6
# print(6 and 2 > 1) # True
# print(not 9) # False
#
# while -9.8:
#     print("9")
#     break


# print("====练习5、求1-2+3-4+5 ... 99中除88之外的所有数的和====")
# t9 = 0
# count = 0
# while t9 < 99:
#     t9 += 1
#     if t9 == 88:
#         continue
#     elif t9 % 2 == 0:
#         count = count - t9
#     else:
#         count = count + t9
# else:
#     print(count)

# v = 8
# d = v.bit_length()
# print(d)


# if -9:
#     print("ok")
# else:
#     print("NG")


# str = "我爱北京天安门"
# print(str[0])
# print(str[1])
# print(str[2])
# print(str[3])
# print(str[4])
# a1="dqsddsfs"
# ret2 = a1.center(20,"*")
# print(ret2)

# #split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
# ret9 = 'title,Tilte,atre,'.split('t',1)
# print(ret9)
# ret91 = 'title,Tilte,atre,'.rsplit('t',1)
# print(ret91)

# msg="abc DEF ghI"
# print(msg.title())

# #format的三种玩法 格式化输出
# print('{} {} {}'.format('egon',18,'male'))
# print('{1} {0} {1}'.format('egon',18,'male'))
# print('{name} {age} {sex}'.format(sex='male',name='egon',age=18))

# res='{} {} {}'.format('egon',18,'male')
# res='{1} {0} {1}'.format('egon',18,'male')
# res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)


# #strip
# name='*egon**'
# print(name.strip('*'))
# print(name.lstrip('*'))
# print(name.rstrip('*'))


#replace
# name='alex say :i have onealex tesla,my name is alex'
# print(name.replace('alex','SB',2))

# name='abcafjjdaabcjdfajaabcjejiafj'
# print(name.replace('abc','***',2))

# li = [1,'a','b',2,3,'a']
# li.insert(0,55) #按照索引去增加
# print(li)
#
# li.append('aaa') #增加到最后
# li.append([1,2,3]) #增加到最后
# print(li)
#
# li.extend(['q,a,w']) #迭代的去增
# print(li)
# li.extend(['q,a,w','aaa'])
# print(li)
# li.extend('a')
# print(li)
# li.extend('abc')
# print(li)
# li.extend('a,b,c')
# print(li)

li = [1,'m','b',2,3,'a']
# l1 = li.pop(1) #按照位置去删除，返回去除成功的值
# print(l1)
#
# del li[1:3] #按照位置去删除，也可切片删除，没有返回值。
# print(li)

# li.remove(1) #按照元素去删除一个
# print(li)

# li.clear() #清空列表

# # 改
# li = [1,'a','b',2,3,'a']
# li[1] = 'dfasdfas'
# print(li)
# li[1:4] = ['a','b']
# print(li)

# #增
# d = {}
# d['s'] = [1,2,3]  # dic[key] = value ， key一定是不可变对象
# print(d)   #{'s': [1, 2, 3]}
# d.setdefault('o') #在字典中添加键值对，如果只有键那对应的值是none
# print(d) #{'s': [1, 2, 3], 'o': None}
# d.setdefault(4,'s') #在字典中添加键值对
# print(d)  #{'s': [1, 2, 3], 'o': None, 4: 's'}
# d.setdefault(4,'ww')#如果原字典中存在设置的键值对，则他不会更改或者覆盖
# print(d)  #{'s': [1, 2, 3], 'o': None, 4: 's'}


# dic['li'] = ["a","b","c"]
# print(dic)
# # setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
# dic.setdefault('k','v')
# print(dic)  # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# dic.setdefault('k','v1')  # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# print(dic)

# d = {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# dic_pop = d.pop('a','没有时的返回值') # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
# print(dic_pop)
# del d["name"]  # 没有返回值。
# print(d)
#
# dic_pop1 = d.popitem()  # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
# print(dic_pop1)  # ('name','jin')
# print(d)
#
# dic_clear = d.clear()  # 清空字典,返回值为None
# print(d,dic_clear)  # {} None

# d = {}
# d['s'] = [1,2,3]  # dic[key] = value ， key一定是不可变对象
# print(d)
# d['s'][1]='ut'
# print(d)


# dic = {"name":"jin","age":18,"sex":"male", 'k':[1,2,3]}
# dic2 = {"name":"alex","weight":75}
# dic.update(dic2)# 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
# print(dic) #{'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
# dic['name'] = 'sure'
# dic['l'][1] = 'dfa'
# print(dic) #{'name': 'sure', 'age': 18, 'sex': 'male', 'weight': 75}


# item = dic.items()
# print(item,type(item))  # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>
# # 这个类型就是dict_items类型，可迭代的
#
# keys = dic.keys()
# print(keys,type(keys))  # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>
#
# values = dic.values()
# print(values,type(values))  # dict_values(['male', 18, 'jin']) <class 'dict_values'> 同上

# for i in enumerate('fjalfjadlfjla'):
#     print(i) #(0, 'f') (1, 'j') ...
# for i, j in enumerate('fjalfjadlfjla',4):
#     print(i,j) #4 f   5 j  ...

# for i in range(2, 10, 2):
#     print(i) # 2 4 6 8

name = input("name:")
password = int(input("password:"))
dic = {'s':[1, 3]}

while True:
    if name in dic:
        my_password = dic[name][0]
        count = dic[name][1]
        # password = int(input("password:"))
        if password == my_password:
            print("登录成功！")
            dic[name][1] = 3
            break
        else:
            if count >1:
                print(count)
                count -= 1
                dic[name][1] = count # 调了很久的bug，没赋值啊
                print(count)
                print("密码错误，您还可尝试%d次" % count)
                password = int(input("password:"))
            else:
                print("密码错误次数超3次，账户已被锁定")
                break
    else:
        dic[name] = password
        print("登录成功")
        break

# Author:Sure Feng


'''
从新出发，希望这次能一学到底~~
把吸收到的、当时的理解定时输出，不怕失误，持续改进


计算机基础小知识：
CPU：运行机器码文件，相当于人类大脑，用于计算
内存：暂存数据的地方，成本高断电数据即消失。如2G（公司的电脑）、4G（现在的电脑）、8G、16G、32G
硬盘：永久存储数据的地方
操作系统：运行程序时，把相应机器码放入内存，CPU执行
应用程序，就是应用程序


一、Python的初步了解
  Python他爹：
    吉多·范罗苏姆（Guido van Rossum），中文名龟叔。Python这门语言是他在一个无聊的
圣诞节打发时间写出来的。（不禁感叹，天才啊~~自能能在半年学会就感谢上苍了）。

  Python定位：优美、清晰、简单。2017年7月的TIOBE排行榜第四

  Python的主要应用：
    数据爬虫&分析、金融量化（前两项是学习Python的动力，投资的利器）、人工智能&科学运算、WEB开发、
图形GUI、系统运维。全球各大网站的应用（知乎、豆瓣、谷歌等）
  Python发展史中的重要节点2008，同时推出Python2.6和Python3.0。November 2014宣布Python2.7版本将刚在
2020年停止支持。（当初还纠结是学2.7还是3.5。。。）

  为什么推出Python3？
    Python2源码重复率高，不规范，与Python当初定位不相符（优美、清晰、简单），顾创建了Python3。

  Python2和3是不兼容的，体现在很多方面：
  1、默认编码：Python2是ascii码，Python3是utf-8。（解释器在加载 .py 文件中的代码时，会对内容进行编码）
    编码乱码问题：在首行注明：-*- coding:utf-8 -*-
    ASCII码：最早的一套基于拉丁字母的电脑编码，用8位来表示（一个字节），最多能表示2**8 = 256个符号
    Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。最少由16位来表示（2个字节），即：2^16 = 65536
    UTF-8，Unicode的压缩和优化，ascii码（1个字节）、欧洲（2个字节），东亚（3个字节）
  2、（后续补上）

  Python是一种动态的解释型强类型语言。在命令行下运行python就是启动CPython解释器。
    人类与机器间语言不一样，人类的语言（）中文、英文等），机器CPU执行的语言（二进制文件）。
    编译型语言（开发效率低，不能跨平台，运行速度快），c、c++
      人能读懂的代码→编译，获的机器码（如xxx.exe文件）→CPU运行。
    解析型语言（开发效率高，能跨平台，运行速度相对慢，但是对用户而言并没差别），如Python、JavaScript、PHP
      人能读懂的代码→解析器解析.py文件（默认CPython，C语言写的）→获得相应的字节码→通过虚拟机边执行边翻译→CPU运行。
    动态语言：编程时不需要指定数据类型，在运行期间才去做数据类型的检查。
    静态语言：编程时需要指定数据类型，在编译时会做数据类型的检查。
    强类型定义语言：变量被指定了某个数据类型，如果不经过强制转换，就永远是这个数据类型
    弱类型定义语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值
  Python运行：终端→命令行（cmd、PowerShell）→cd切换到目标路径， Python 文件名.py

  注释：
    当行注释：#  ctrl+/
    多行注释：''' ''' """ """
'''

'''
报错收集：
1、TypeError: can only concatenate str (not "list") to str
2、TypeError: not enough arguments for format string ，字符串占位符写少了
3、SyntaxError: invalid syntax , Python3不支持<>,改用!=
4、ValueError: unsupported format character '%' (0x25) at index 2 使用占位符时，若想打印%，需写%%转义

'''


'''
变量：声明变量，数据的门牌号，代指内存里某个地址中保存的内容
命名规则：
允许：有可描述性，由字母、数字、下划线组成
不允许：第一个字符不能是数字、关键字
不好的：变量名过长、带中文、拼音、词不达意
'''
#推荐一：驼峰体
AgeOfOldboy = 56
#推荐二：下划线
age_of_oldboy = 56


# 变量的赋值：
# 实验一，变量名指向数字、字符串时，c通过b找到对象1，随后无论ab怎么变，均不改变c的指向，c=1
a = 1
b = a
a = "hello,python"
c = b
b = 5
print("a=", a, ", b=", b, ", c=", c) #  a= hello,python , b= 5 , c= 1

# 实验二，d通过l找到列表对象，实际为一存储地址，不涉及内部数据，所以仅当内部数据改变时，打印的数据相应改变。
# e指向列表中的字符串1，实际是通过列表l找到对象“1”，之后就与列表没关系了，所以不会随列表而改变
l = ["1", 2, "python"]
d = l
e = l[0]
print("l=", l, ", d=", d, ", e=", e) # l= ['1', 2, 'python'] , d= ['1', 2, 'python'] , e= 1
l[0] = 56
print("l=", l, ", d=", d, ", e=", e) # l= [56, 2, 'python'] , d= [56, 2, 'python'] , e= 1


'''
常量：指不会变或过程中不会改变的量
命名方式：全大写
注意：Python中没有机制强制规定不能改，更改也不会报错
'''
MY_AGE = 18


# 程序交互：用户有参与感的操作，会适当进行一些数据输入
# input接收的所有输入默认都是字符串格式，可适当使用int(str)、str( yourStr )
# age = input("how old are you >>>") # how old are you >>>18
# print("oh,%d is wonderful" % int(age)) # oh,18 is wonderful


# 计算机的运算：算术运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算（后三个以后学）
# 算术运算：+、 -、 *、 /、 %、 //、 **(即^）
print(10%3) # 1
print(10//3) # 3
print(2**2) # 4

# 比较运算：<, <=, >, >=, =, ==, !=或<>
t1 = 'hello'
t2 = 3
print(t1 == "hello") # True
# print(3 <> 3) # SyntaxError: invalid syntax ,不支持
print(3 != "hello") # True

# 赋值运算：=, +=, -=, *=, /=, %=, **=, //=
t3 = 2
t4 = 10
t3 += t4 # t3 = t3 + t4 = 2+10
print(t3) # 12
t3 -= t4 # t3 = t3 - t4 = 12-10
print(t3) # 2
t3 *= t4 # t3 = t3 * t4 = 2*10
print(t3) # 20
t3 /= t4 # t3 = t3 / t4 = 20/10
print(t3) # 2.0
t3 **= t4 # t3 = t3 ** t4 = 2**10
print(t3) # 1024.0
t3 %= t4 # t3 = t3 % t4 = 1024%10
print(t3) # 4.0

# 逻辑运算：and, or, not, 先级关系为( )>not>and>or
print(3>4 or 4<3 and 1==1)  #False
print(1 < 2 and 3 < 4 or 1>2)   #True
print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)  #True
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)  #False
print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)  #False
print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)  #False
# x or y , x为真，值就是x，x为假，值是y；
# x and y, x为真，值是y,x为假，值是x
# 非0数字 == True, 0 == False
print(8 or 4) # 8
print(0 and 3) # 0
print(0 or 4 and 3 or 7 or 9 and 6) # 3
print(-6 or 2 > 1) # -6
print(6 and 2 > 1) # True
print(not 9) # False
# ,not in :判断子元素是否在原字符串（字典，列表，集合）中：
print('喜欢' in 'dkfljadklf喜欢hfjdkas') #True
print('a' in 'bcvd') #False
print('y' not in 'ofkjdslaf') #True


'''
流程控制（if语句、while语句）：在程序中预设判断语句，让程序往满足相应条件的方向执行
强制缩进：让程序知道每段代码依赖的条件，确定相应的代码块区域
缩进原则：
1、顶级代码必须顶行写，即如果一行代码本身不依赖于任何条件，那它必须不能进行任何缩进
2、同一级别的代码，缩进必须一致
3、官方建议缩进用4个空格，当然你也可以用2个（但不规范）
'''

'''
流程控制之if 语句：满足条件，就往下走
练习：匹配成绩的小程序，成绩有ABCDE5个等级，与分数的对应关系如下
A    90-100
B    80-89
C    60-79
D    40-59
E    0-39
要求用户输入0-100的数字后，你能正确打印他的对应成绩
'''
# score_info = input("How many points do you have >>> ")
# # "负数".isdigit 为False
# if score_info.isdigit():
#     score = int(score_info)
#     if score > 100:
#         print("天才了，最高才100分。。。")
#     elif score >= 90:
#         print("A")
#     elif score >= 80:
#         print("B")
#     elif score >= 60:
#         print("C")
#     elif score >= 40:
#         print("D")
#     else:
#         print("E")
# else:
#     print("请输入0~100分")


'''
流程控制之while语句：只要满足条件，就不断循环
无限循环：while True： 或者 while 1：
结束循环：
1、终结当次循环 continue
2、终结while循环 break
'''
# 练习：在0~30间，打印0~20间的能被3整除的数
count = 0
while count <= 30:
    count += 1
    if count % 3 != 0:
        continue # 终结当次循环 continue
    elif count > 20:
        print("已超出范围 0~20，不玩了")
        break # 终结while循环 break
    else:
        print("count:",count)

'''
while else语句:while执行完成后，就执行else的内容。当被break中断，就不执行else内容。
练习：电影后，用户自行选择是否想展示彩蛋
'''
# choice = input("电影结束还有5秒，想看彩蛋吗？（Y/N）>>>")
# date = 5
# while date > 0:
#     print("结束倒数:",date)
#     date -= 1
#     if date == 0:
#         if choice == "N":
#             print("电影结束")
#             break
# else:
#     print("电影结束，彩蛋来啦~")


'''
for循环：按顺序循环遍历可迭代对象(string/tuple/list/dict)
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串）
range(start, end, args)
'''
for i in range(2, 10, 2):
    print(i) # 2 4 6 8
for i in enumerate('fjalfjadlfjla'):
    print(i) #(0, 'f') (1, 'j') ...
for i, j in enumerate('fjalfjadlfjla',4):
    print(i,j) #4 f   5 j  ...

print('''
相关练习题
====练习1、使用while循环输入 1 2 3 4 5 6     8 9 10====''')
t5 = 0
while t5 < 10:
    t5 += 1 # 一定要在（t5 == 7）判断前，否则出现死循环
    if t5 == 7:
        print(" ")
        continue
    print(t5)

print("====练习2、求1-100的所有数的和====")
t6 = 1
count = 0
while t6 <= 100:
    count = count + t6
    t6  += 1
else:
    print(count)

print("====练习3、输出 1-100 内的所有奇数====")
t7 = 0
while t7 <100:
    t7 += 1
    if t7 % 2 == 0:
        continue
    print(t7)

print("====练习4、输出 1-100 内的所有偶数====")
t8 = 0
while t8 < 100:
    t8 += 1
    if t8 % 2 == 0:
        print(t8)

print("====练习5、求1-2+3-4+5 ... 99中除88之外的所有数的和====")
t9 = 0
count = 0
while t9 < 99:
    t9 += 1
    if t9 == 88:
        continue
    elif t9 % 2 == 0:
        count = count - t9
    else:
        count = count + t9
else:
    print(count)

print("====练习6、用户登陆（三次机会重试）====")
name = input("name:")
password = int(input("password:"))
dic = {'s':[1, 3]}

while True:
    if name in dic:
        my_password = dic[name][0]
        count = dic[name][1]
        # password = int(input("password:"))
        if password == my_password:
            print("登录成功！")
            dic[name][1] = 3
            break
        else:
            if count >1:
                print(count)
                count -= 1
                dic[name][1] = count # 调了很久的bug，没赋值啊
                print(count)
                print("密码错误，您还可尝试%d次" % count)
                password = int(input("password:"))
            else:
                print("密码错误次数超3次，账户已被锁定")
                break
    else:
        dic[name] = password
        print("登录成功")
        break

# -*- coding:utf-8 -*-
# Author:Sure Feng

'''
Python的数据类型：
1、整数类型：32位、64位代表的字符数量，bit_length()
2、浮点类型：带小数的
3、字符串类型：单行/多行打印，字符串的加法/乘法，格式化输出（%s/%d）,索引，切片，常用方法
4、布尔类型：正规写法：1 == True， 0 == False   | 实际上，非0数字 == True, 0 == False
5、列表list：类似于其他语言中的数组
6、字典dict
7、元组tuple：只读列表，可被查询，使用切片

总结：
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分
标量／原子类型：数字，字符串
容器类型：列表，元组，字典

按可变不可变区分
可变：列表，字典
不可变：数字，字符串，元组，布尔值

按访问顺序区分
直接访问：数字
顺序访问（序列类型）：字符串，列表，元组
key值访问（映射类型）：字典
'''


'''
1、数据类型--整数类型
在32位机器上，整数的位数为32位（-2**31～2**31-1），
在64位系统上，整数的位数为64位（-2**63～2**63-1），减一是为了减0
'''
v = 8 # 0000 1000
d = v.bit_length() # 十进制用二进制表示时，所需要的最小位数
print(d) # 4
print(type(23)) #<class 'int'>，没有长整型long，均为int


'''
2、数据类型--浮点类型
'''
print(type(23.6)) #<class 'float'>


'''
3、数据类型--字符串类型
主要应用：索引、切片、常用方法、格式化输出
'''
print(type("23")) #<class 'str'>
print("I'm sure，单双号注意")
print("字"+"符"+"拼"+"接") # 字符间可拼接
print("字符" + "~"*2) # 字符数值间可乘积, 字符~~
print('''
多行打印
多行打印
多行打印
''')

# 索引,依据角标，获取相应的字符
str = "我爱北京"
print(str[0]) # 我
print(str[1]) # 爱
print(str[2]) # 北
print(str[3]) # 京

# 切片，字符串[索引：索引：步长]，原则：顾头不顾尾
s2 = "abcdefghijk"
print(s2[:3]) # abc, 开头默认0开始
print(s2[1:]) # bcdefghijk, 默认取到尾部
print(s2[0:-1]) # abcdefghij， -1表示末尾
print(s2[-3:-1]) # ij
print(s2[2:10:3]) # cfi
print(s2[10:0:-3]) # kheb

# 字符串常用方法
s3 = "abc DEF ghI"
# 大小写转换
print(s3.capitalize()) # 首字母大写 Abc def ghi
print(s3.swapcase()) # 大小写翻转 ABC def GHi
print(s3.title()) # 每个单词的首字母大写,其余小写 Abc Def Ghi
# 调整填充格式
print(s3.center(20,"-")) #内容居中，设定总长度，在空白处填充指定字符 ----abc DEF ghI-----
s5 = "dsd a\t"
#默认将一个tab键变成8个空格，如果tab前面的字符8个唯一单位，长度不足则补全8个
print(s5.expandtabs()) # 若指定长度（需要大于字符串长度），则按指定长度补全
#strip 删除指定字符
name='*egon**'
print(name.strip('*')) # 全部
print(name.lstrip('*'))
print(name.rstrip('*'))
#split 分割指定字符。以什么分割，最终形成一个列表此列表不含有这个分割的元素。
ret9 = 'title,Tilte,atre,'.split('t',1) # 从左边开始，替换1个  ['', 'itle,Tilte,atre,']
print(ret9)
ret91 = 'title,Tilte,atre,'.rsplit('t',2)# 从右边开始，替换2个 ['title,Til', 'e,a', 're,']
print(ret91)
#replace 替换指定字符,可选择替换个数
name='abcafjjdaabcjdfajaabcjejiafj'
print(name.replace('abc','***',2)) # ***afjjda***jdfajaabcjejiafj
# 长度统计
s4 = "aaasdfvddradghsa"
print(s4.count("a",0,2)) #数字符串中的元素出现的个数,可切片,也是顾头不顾尾 2
# 逻辑判断类的方法
s6 = "werasdfvddradghpa"
print(s6.startswith("wer",2,9)) #判断是否以...开头 可切片,顾头不顾尾 False
print(s6.endswith("hp", 0,-1)) #判断是否以...结尾 True
print(s6.find("m",2,6)) # 返回的找到的元素的索引，如果找不到返回-1
print(s6.index("r")) #返回的找到的元素的索引，找不到报错 ValueError: substring not found
#format的三种玩法 格式化输出
print('{} {} {}'.format('a',"b","c")) # a b c
print('{2} {0} {1}'.format('a',"b","c")) #c a b
print('{name} {age} {sex}'.format(sex='male',name='egon',age=18)) #egon 18 male
#####is系列
name='jinxin123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成



'''
格式化输出：%s就是代表字符串占位符，除此之外，还有%d,是数字占位符
使用事项：若想输出%，需加%转义，即%%，否则报错
练习:问用户的姓名、年龄、工作、爱好 ，然后打印成以下格式
------------ info of surefeng -----------
Name  : surefeng
Age   : 18
job   : student
Hobbie: cosmic
------------- end -----------------
'''
# name = input("what's your name>>>")
# age = input("what's your age>>>")
# job = input("what's your job>>>")
# hobbie = input("what's your hobbie>>>")
# # 不能直接多行打印print(''' ''')的形式，内部的%s会被当做字符串处理
# info = '''
# ------------ info of %s -----------
# Name  : %s
# Age   : %s
# job   : %s
# Hobbie: %s
# ------------- end -----------------
# ''' % (name, name, age, job, hobbie)
# print(info)


'''
4、数据类型--布尔类型
正规写法：1 == True， 0 == False   | 实际上，非0数字 == True, 0 == False
'''
print(type(2 > 5))  #  <class 'bool'>, True,False


'''
5、列表list:
大量储存数据的地方，同一列表中可存放不同类型的数据，有索引、切片
'''
l = [1, 'e', 't', 1, 'c']
# 增
l.append([1,3,5]) # 末尾添加
print(l)
l.insert(2,'y') # 指定位置增加
print(l)
l.extend('sfjj') #迭代增加
print(l)
# 删
del l[1:3] #切片删除，没有返回值
print(l)
l.pop(7)#删除指定索引的数据
print(l)
l.remove(1)  #删除第一个找到的数据
print(l)
# l.clear() #清除列表，慎用
print(l)
#改
l[2] = [2,'t,5',0]
print(l) #['t', 1, [2, 't,5', 0], [1, 3, 5], 's', 'f', 'j']
l[1:4] = ['s','b']# 赋值不够就默认删除了
print(l) #['t', 's', 'b', 's', 'f', 'j']
# 查
# 切片或遍历去查找
#其他操作
print(l.count('v')) #统计某个元素在列表中出现的次数，没有就返回0
print(l.index('s',1,5)) #从列表中找出某个值第一个匹配项的索引位置，可切片查找，没有就返回0,没有会报错
#正向排序
l.sort()
print(l) # ['b', 'f', 'j', 's', 's', 't']
#反向排序
l.reverse()
print(l) #['t', 's', 's', 'j', 'f', 'b']


'''
6、字典dict:python中唯一的映射类型,键值对（key-value）储存
特点：无序储存、key必须是不可变类型（数字、字符串、元组）、哈希函数计算储存地址
'''
#增
d = {}
d['s'] = [1,2,3]  # dic[key] = value ， key一定是不可变对象
print(d)   #{'s': [1, 2, 3]}
d.setdefault('o') #在字典中添加键值对，如果只有键那对应的值是none
print(d) #{'s': [1, 2, 3], 'o': None}
d.setdefault(4,'s') #在字典中添加键值对
print(d)  #{'s': [1, 2, 3], 'o': None, 4: 's'}
d.setdefault('o','ww')#如果原字典中存在设置的键值对，则他不会更改或者覆盖
print(d)  #{'s': [1, 2, 3], 'o': None, 4: 's'}

#删
print(d.pop('age','没有该数据')) # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
print(d.popitem()) # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回 (4, 's')
del d['s'] # 没有返回值。
print(d, d.clear()) #{} None

# 改
dic = {"name":"jin","age":18,"sex":"male", 'l':[1,2,3]}
dic2 = {"name":"alex","weight":75}
dic.update(dic2)# 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic) #{'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
dic['name'] = 'sure'
dic['l'][1] = 'dfa'
print(dic) #{'name': 'sure', 'age': 18, 'sex': 'male', 'l': [1, 'dfa', 3], 'weight': 75}

# 查
v1 = dic['l'] #没有会报错
v2 = dic.get('s', '没有该数据')
print(v1, v2) # [1, 'dfa', 3] 没有该数据

# 其他操作
item = dic.items()
print(item, type(item))
#dict_items([('name', 'sure'), ('age', 18), ('sex', 'male'), ('l', [1, 'dfa', 3]), ('weight', 75)])
#  <class 'dict_items'> 可迭代的类型
keys = dic.keys()
print(keys, type(keys))
#dict_keys(['name', 'age', 'sex', 'l', 'weight']) <class 'dict_keys'>
values = dic.values()
print(values, type(values))
#dict_values(['sure', 18, 'male', [1, 'dfa', 3], 75]) <class 'dict_values'>

# 字典的循环
print("=========遍历key=========")
for key in dic:
    print(key)
print("=========遍历key-value=========")
for key in dic:
    # print(key)
    print(key, ":", dic[key])
print("=========遍历key-value=========")
for key in dic.keys():
    print(key, ":", dic[key])
print("=========遍历key-value=========")
for key, value in dic.items():
    print(key, ":", value)
print("=========遍历key-value=========")
for item in dic.items():
    print(item)


'''
7、元组tuple：只读列表，可被查询，使用切片
c = (1,2,3)
'''