第一个·复习

a = 10
print('你好','世界',a)

if a == 10:
    print('条件成立')

if a == 10:
    print('条件成立')
else:
    print('条件不成立')

if a < 10:
    print('条件成立')
elif a > 10:
    print('条件成立')
else:
    print('else成立')


# while a == 10:
#     number = input('输入数字：')
#     if number == '0':
#         a = 20
#
# while True:
#
#     while True:
#
#         for x in range(10):
#             number = input('请输入内容，输0结束：')
#             if number == 0:
#                 break

# 列表，是一个容器，可以用存储数据
# 列表存储的数据： 1.有序，第一个存储的数据，索引为0，第二个索引为1，以此类推。。。。  2.存储的数据类型广泛
list_1 = [1,2,3,'hello','world',False,3.14,1,2,3,1,1,1,1,2,2,3,3]

# 向列表中添加数据
# 1.append(object) object就是要添加的数据,这个数据时放在列表的末尾
list_1.append('你好')
print(list_1)
# 2.insert(index,object)
# index: 索引，会在这个索引之前插入一条数据
list_1.insert(3,'广告')
print(list_1)
# 3.extend(iterable) 可以将一个可迭代对象的所有数据追加到该列表中
# 列表 字符串 字典  元组
list_2 = [1,2,3,4,5]
list_1.extend('hello')
print(list_1)

# 获取在列表中的索引
# object:要查找索引的数据   start:查找的起始位置 stop：查找的结束位置
# 如果指定查找位置：包含start起始位置，不包含stop结束位置
# 'hello' is not in list 原因1：列表中确实没有该元素 原因2：指定的范围没有该元素
index = list_1.index('hello',4,5)
print(index)

# 修改列表中的数据
list_1[3] = '广而告之'
print(list_1)

# 删除列表中的数据
# 1.根据索引删除数据
del list_1[3]
print(list_1)
# 2.pop(index) 从列表中将数据移出，移出之后列表中就不存在数据了
# index 可以指定取出数据的索引，如果不指定的话，默认取出最后一条数据
string = list_1.pop(3)
print(string)
print(list_1)
# 3.remove(object) 根据数据内容 从列表中移除数据
# object 要删除的数据
# list.remove(x): x not in list  要删除的数据不在列表中
# 4.判断数据是否在列表
# object in list 如果object在列表中，返回True，不在 返回False
# object not in list  如果object不在列表中 返回True  在 返回False
if 'ssss'  in list_1:
    list_1.remove('ssss')
else:
    print('ssss不在列表中，无法执行删除操作！')

# 5.删除列表中所有的元素
# list_1.clear()
# print(list_1)

# 取出列表中的数据
# 1.根据索引取出列表中数据，取出之后列表中还有数据
number = list_1[5]
print(number)
# 2.使用pop()函数，取出列表中数据，取出之后列表中的数据就会移除
number = list_1.pop(5)
print(number)
print(list_1)
# 3.列表切片，切片之后会得到一个新列表
# start:stop   包含start 不包含stop
# start开始位置，一定要小于stop结束位置，否则截取出来就是一个空列表
result = list_1[3:6]
print(result)
# 从第一个元素位置开始截取，截取到指定位置
result = list_1[:6]
print(result)
# 从指定位置开始截取，截取到列表的最后一个元素
result = list_1[5:]
print(result)

# 使用len()函数，获取列表中存数据的个数
count = len(list_1)
print('列表中有%s个元素'%count)
# 4.取出列表中的所有数据
# 使用for循环，遍历列表
# range(start,stop,step)
# start 范围的开始位置  stop 范围结束的位置  step x的增量 默认为1
# range范围 包含start 不包含stop
for x in range(0, count):
    # 把x的值作为索引，从列表中取出数据
    content = list_1[x]
    print(content)

# 5.for循环直接遍历列表
for content in list_1:
    print(content)


# count(object)函数，统计某个元素在列表中出现的次数
count = list_1.count(1)
print('出现的次数：',count)

# sort() 排序函数 默认使用升序
# reverse = True 使用降序排序
numbers = [1,41,2,33,24,55,124,24,54,3453,3423,63,332,6234,6]
numbers.sort(reverse=True)
print(numbers)

# reverse() 反向排序
numbers.reverse()
print(numbers)


# count() 自己实现一个count函数
def COUNT(list_1,object):

    # 声明变量记录出现的次数
    count = 0
    for obj in list_1:
        if object == obj:
            count += 1

    return count
    # 如果有返回object在list_1中出现的次数
    # 如果没有 返回0

list_1 = [1,2,4,1,2,5,2,4,1,4,5,2,1]
count = COUNT(list_1,1)
print(count)
# index() 自己实现一个index函数
def INDEX(list_1,object):

    index_list = []
    # enumerate 枚举 # 拿到之后 一个一个的小元组，小元组中放的是数据索引和数据
    for item in enumerate(list_1):
        # item[1] 取出小元组中的数据
        if item[1] == object:
            # item[0] 数据对应的索引
            index_list.append(item[0])
    # 如果有元素返回object在list_1中的索引
    # 如果没有返回-1
    return index_list

index_list = INDEX(list_1,1)
print(index_list)
####################################
# 1.tuple元组的用法
# 元组也是python内置一个容器类，元组中的数据一旦确定就不可更改，不能进行添加、删除、修改的操作
# 可以认为元组就是一个不可变的列表(list)

# 声明元组
# 如果元组中只有一个元素，在python2中必须在元素后添加一个,逗号,python3中可以不用加
tuple_1 = (3.14, 'hello', 'world',2,3,5,1,2)
print(tuple_1)
# 声明元组时，可以省略小括号，这种方式也可以生成一个元组
tuple_2 = 1,2,3,4,5,6,7,8
print(type(tuple_2))

# 根据索引取出元组中的数据
num = tuple_1[0]
print(num)

# 元组也支持切片操作,切片之后返回一个新的元组
result= tuple_1[1:3]
print(result)

# 元组支持for循环遍历
for x in range(0,len(tuple_1)):
    # 把x的值作为索引，取出数据
    content = tuple_1[x]
    print(content)
# for循环遍历
for content in tuple_1:
    print(content)

# 使用枚举
rs = enumerate(tuple_1)
# for循环遍历枚举对象
for index,value in rs:
    # index就是小元组中的索引,value就是小元组中的数据
    print(index,value)

# 列表元组嵌套：
list1 = [['张三',22,110],['李四',23,120],(1,2,3),(3,2,1)]
# 元组嵌套列表,元组不可修改，但是元组中的列表可以进行修改
tuple1 = (1,2,['张三',22,110],(3,2,1))

tuple1[2].append('hello')

print(tuple1)

# 列表和元组中间可以互相转换
list2 = [1,2,3,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
# 把列表转换为元组
tuple2 = tuple(list2)
print(type(tuple2))
# 把元组转换为列表
list2 = list(tuple2)

print(type(list2))

# index(x,start,end) 查找某个元素在元组中的位置
# x 指要查找索引的元素  start开始查找的位置 end结束查找的位置
# 查找位置 如果不指定 从开始位置到末尾查找  指定位置从start开始到end之前，不包含end
index = tuple2.index(3,0,3)
print(index)

# count(x) 统计某个元素在元组中出现的次数
# x 要查找出现次数的元素
count = tuple2.count(1)
print(count)
##################################
# 字典用法

# 字典：python中的一个内置的容器类，具有增删改查的操作
# 字典存储数据特点：
# 1.字典存储数据，遵循key:value(键:值)形式进行数据存储，一个key(键)对应一个值(value),使用键来替代列表中的索引，所有的增删改都是通过key(键)完成的。
# 2.字典中存储的数据是无序的
# 3.key(键)必须是唯一的，必须是不可变的,一般推荐使用数字或者字符串
# PEP8编码规范 标点后跟个空白符(空格)
dict1 = {'name': '张三', 'age': 22, 'phone': 110}

# 添加数据，如果字典中没有这个key，做添加数据的操作
dict1['sex'] = '男'
print(dict1)
# 如果字典中有这个key，做修改数据的操作
dict1['sex'] = '女'
print(dict1)

# 删除字典中的数据
# 1.根据key删除字典中的数据
# del dict1['sex']
# print(dict1)
# 2.使用pop(key) 移出字典中对应key的元素，取出的是值
# name = dict1.pop('name')
# print(name)
# 3.随机从字典取出一对键值对，取出的是小元组
# rs = dict1.popitem()
# print(rs)
# 4.清空字典中的所有键值对
# dict1.clear()

# 字典中的常用函数

# 1.获取字典中所有的key
keys = dict1.keys()
# for循环遍历key，根据key取出对应的value
for key in keys:
    value = dict1[key]

# 2.获取字典中所有的value值
values = dict1.values()
for value in values:
    print(value)
# 3.获取字典中所有的key和值(key,value)元组
items = dict1.items()
# for 循环遍历items
for key,value in items:

    print(key,value)

# 4.判断字典中是否拥有某个key
# python2 直接使用 dict1.has_key(key)  如果key存在，返回True 不存在 返回False
# python3 使用 key in  dict1.keys 如果存在返回True 不存在 返回False
# key not in dict1.keys()  如果存在返回False  不存在返回True
if 'name' in dict1.keys():
    print('字典中有name这个key')
else:
    print('字典中没有name这个key')