Python基础-高级变量类型

                                Python基础-高级变量类型

1.高级变量类型

"""
数值型:int float bool compex
非数值型:str list set dict tuple
"""
# 保存所有人的姓名信息?
# str = '秦海根张刚'
# 获取第二个人的姓名
"""------------------ 定义列表 ------------------"""
# 定义列表保存我们班所有人的姓名
# nameList = ['秦海根','张刚','昌子为','易文']
# print(nameList)

# 列表可以保存不同的数据类型吗?
# nameList = ['秦海根','张刚','昌子为','易文',20,1.23,True]
# print(nameList)

"""------------------ 访问列表中某一个元素 ------------------"""
# nameList = ['秦海根','张刚','昌子为','易文']
# 秦海根 张刚 昌子为 易文
# 0     1       2   3
# 访问第三个元素
# 两种方式操作效果都是一样的
# ele = nameList[2]
# ele = nameList.__getitem__(2)
# print(ele)

"""------------------ 遍历列表 ------------------"""
nameList = ['秦海根', '张刚', '昌子为', '易文']
# for ele in nameList:
#     print(ele)
# while循环可不可以遍历nameList中所有的元素?
# 1:可以  2:不可以
index = 0
while index < len(nameList):
    # 获取当前元素
    ele = nameList[index]
    print(ele)
    # 修改循环变量
    index += 1

list列表的增删:

# nameList = ['秦海根', '张刚', '昌子为', '易文']
"""------------------ 列表增加 ------------------"""
# append增加朱烜甫 在末尾追加一条数据
# nameList.append('朱烜甫')
# print(nameList)

# insert添加 在特定的位置添加数据
# nameList.insert(1,'朱烜甫')
# print(nameList)

# nameList = ['秦海根', '张刚', '昌子为', '易文']
# l = ['张三','李四']
# # extend 将另外一个容器中所有的元素添加到当前容器中
# nameList.extend(l)
# print(nameList)


"""------------------ 删除 ------------------"""
nameList = ['秦海根', '张刚', '李四','昌子为','张三', '易文']
# del删除张三 按照索引删除
# del nameList[4]
# print(nameList)

# remove 删除某一个数据
# nameList.remove('李四')
# print(nameList)

# pop(索引)删除 可以返回删除的数据
# deleteEle = nameList.pop(4)
# print(deleteEle)
# print(nameList)

# pop没有参数 删除末尾元素
# deleteEle = nameList.pop()
# print(deleteEle)
# print(nameList)

# 清空列表
nameList.clear()
print(nameList)
nameList.append('凤姐')
print(nameList)

列表其他操作:

"""------------------ 列表修改 ------------------"""
# nameList = ['秦海根', '张刚', '张三','昌子为', '易文']
# 修改张三 为 张四
# nameList[2] = '张四'
# print(nameList)
"""------------------ 列表查询 ------------------"""
# nameList = ['秦海根', '张刚', '张三','昌子为', '易文']
# 查询某一个元素
# print(nameList[2])

# index 查询角标
# 查看张三的角标
# i = nameList.index('张三')
# print(i)
# del nameList[nameList.index('张三')]
# print(nameList)

# 列表中可以存储多个相同的元素
# count
# nameList = ['秦海根', '张刚', '张三','昌子为', '易文','张三']
# # 查看张三在列表中出现多少次
# c = nameList.count('李四')
# print(c)

列表的排序和最值:

"""------------------ 列表的排序 ------------------"""
ageList = [90,10,30,20,50,70]
# 从小到大 升序
# ageList.sort()
# print(ageList)
# 从大到小 降序
# ageList.sort(reverse=True)

# reverse 将列表进行反转
# ageList.reverse()
# print(ageList)

"""------------------ 最值 ------------------"""
# 最大值
maxValue = max(ageList)
print(maxValue)
minValue = min(ageList)
print(minValue)

冒泡排序:

"""
有一个数字集合[9,8,7,6,5,4,3,2,1],请手动对这个集合正序排序(不要使用sort方法)

"""
# l = [9, 8, 7, 6, 5, 4, 3, 2, 1]
l = [9, 68, 17, 6, 45, 4, 133, 2, 121]
# 不借助于sort函数(帮你实现了算法)
# 1.定义双层循环
row = 0
while row < len(l) - 1:
    col = 0
    while col<len(l)-1-row:
        # 当前元素:  l[col]
        # 下一个元素:l[col+1]
        # 如果下一个元素比当前元素小 交换
        if l[col]>l[col+1]:
            # 交换
            tmp = l[col]
            l[col]=l[col+1]
            l[col+1] = tmp

        col += 1
    row += 1

print(l)

选择排序

"""
[9,8,7,6,5,4,3,2,1]
通过选择排序 升序排序
"""

# l = [9, 8, 7, 6, 5, 4, 3, 2, 1]
l = [95, 88, 7, 46, 15, 4, 113, 452, 21]

row = 0
while row < len(l) - 1:
    # 新的一轮
    # 假定最小值角标 row
    # 实际最小值角标
    index = row
    # 里层循环
    col = row + 1
    while col < len(l):
        # 对比当前元素和实际最小值角标元素
        if l[col]<l[index]:
            # 修改index
            index = col
        col += 1
    # 一轮结束 如果假定的最小值角标和实际的最小值角标不一致,交换数据
    if row!=index:
        # 交换数据
        tmp = l[row]
        l[row] = l[index]
        l[index] = tmp
    row += 1

print(l)

嵌套列表:

"""
1班有三位同学:林青霞 狄龙 郑少秋
2班有2位同学:张曼玉  梁朝伟
"""
# nameList = ['林青霞','狄龙','郑少秋' ,'张曼玉','梁朝伟']
nameList = [['林青霞','狄龙','郑少秋'],['张曼玉','梁朝伟']]
# 查询张曼玉
print(nameList[1][0])
# 修改狄龙  史泰龙
nameList[0][1] = '史泰龙'
print(nameList)

# 知道梁朝伟角标
index = nameList.index(['张曼玉','梁朝伟'])
print(index)

.列表嵌套练习:

"""
需求:
一个学校，有3个办公室，现在有8位老师等待工位的分配，
请编写程序:
1. 完成随机的分配
2. 获取办公室信息 (每个办公室中的人数，及分别是谁)

分析:
1.3个办公室(办公室:列表) 列表嵌套
2.8位老师 列表中保存
3.遍历老师的列表

4.随机存放到办公室中
"""
import random
"""------------------ 随机分配办公室 ------------------"""

# # 1.3个办公室(办公室:列表) 列表嵌套
# classroomList = [[], [], []]
# # 2.8位老师 列表中保存
# teachers = ['袁腾飞', '罗永浩', '俞敏洪', '李永乐', '王芳芳', '马云', '李彦宏', '马化腾']
# # 3.遍历老师的列表
# for teacher in teachers:
#     # 随机办公室的角标 Ctrl+P查看提示
#     # Ctrl+Alt+V 提取变量
#     index = random.randint(0, 2)
#     # 4.随机存放到办公室中
#     classroom = classroomList[index]
#
#     classroom.append(teacher)
# print(classroomList)

"""------------------ 每一个办公室至少有一个人 ------------------"""
# TDD开发
# 1.3个办公室(办公室:列表) 列表嵌套
classroomList = [[], [], []]
# 2.8位老师 列表中保存
teachers = ['袁腾飞', '罗永浩', '俞敏洪', '李永乐', '王芳芳', '马云', '李彦宏', '马化腾']
# 3.每一个办公室中添加一名老师,遍历办公室还是老师列表  办公室:1  老师 2
for classroom in classroomList:
    # 随机获取一名老师
    # teacher = teachers[random.randint(0,len(teachers)-1)]
    # 添加到办公室中
    classroom.append(teachers.pop(random.randint(0,len(teachers)-1)))
    # 从老师列表中删除这个元素
    # del teachers[index]
    # teachers.remove(teacher)

# print(classroomList)
# print(teachers)
# 4.把剩下的老师随机分配到办公室中
for teacher in teachers:
    # 随机办公室的角标 Ctrl+P查看提示
    # Ctrl+Alt+V 提取变量
    index = random.randint(0, 2)
    # 4.随机存放到办公室中
    classroom = classroomList[index]

    classroom.append(teacher)

# 清空teachers
teachers.clear()

print(classroomList)
print(teachers)

素数练习:

"""
需求:
列出1~1000内的所有素数

素数:除了1和它本身以外,不能被其它数据整除

2:1 2
3:1 3

5:1 5
7
11
13
17
19

分析:
1.1到1000列举出来 while for
2.6  2..5 7 2 6 11 2..10
    看当前数据是否能被从2到当前数据小1的数据整除,只要有一个可以整除,就不是素数
    如果所有都不能整除,就是素数
"""
# 执行效率
# 11 1 11 2..6  7
# 1.1到1000列举出来 while for
for ele in range(1,1001):
    # 看当前数据是否能被从2到当前数据小1的数据整除,只要有一个可以整除,就不是素数
    # 如果所有都不能整除,就是素数
    # for a in range(2,ele):# 1000 减少循环次数
    for a in range(2,ele//2+1):# 1000 减少循环次数
        if ele %a==0:
            # 能够被当前数据整除
            # print('%d 不是素数'%ele)
            break
    else:
        print(ele)

登录验证练习:

"""
需求:
判断登录用户名是否合法(不能用正则表达式)
用户名是数字字母或者_,需要在3到20位,必须有2个或以上大写字母,2个或以上小写字母,3个或以上数字
hhew2383dW_fkf&E@^

分析:
1.数字字母或者_
2.需要在3到20位
3.必须有2个或以上大写字母
4.2个或以上小写字母
5.3个或以上数字

步骤:
1.定义三个容器分别存放数字 大写字母  小写字母
2.遍历用户名字符串
3.查看元素
    1.是否在三个容器中或者是_ 用户名不满足
    2.统计数字 小写字母 大写字母
4.循环结束之后,判断数字 字母是否满足长度需求

"""
name = 'hhew2383dW_fkfE'
# 1.定义三个容器分别存放数字 大写字母  小写字母
numberStr = '0123456789'
lowerStr = 'abcdefghijklmnopqrstuvwxyz'
upperStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

# 数字个数  小写字母个数  大写字母个数
numberCount = 0
lowerCount = 0
upperCount = 0
# 2.遍历用户名字符串
for ele in name:
    # 1.是否在三个容器中或者是_ 用户名不满足
    # if (ele in numberStr) or (ele in lowerStr) or (ele in upperStr) or ele == '_':
    if (ele in numberStr):
        # 数字
        # 2.统计数字 小写字母 大写字母
        numberCount += 1
    elif (ele in lowerStr):
        # 小写字母
        lowerCount += 1
    elif (ele in upperStr):
        # 大写字母
        upperCount += 1
    elif ele == '_':
        pass
    else:
        # 不合法字符
        print('密码不合法')
        # 跳出循环
        break
else:
    # 需要在3到20位, 必须有2个或以上大写字母, 2
    # 个或以上小写字母, 3
    # 个或以上数字
    if (len(name)>=3 and len(name)<=20) and upperCount>=2 and lowerCount>=2 and numberCount>=3:
        print('密码合法')
    else:
        print('密码不合法')

2.元组的定义和特点

"""------------------ 元组的定义 ------------------"""
# 定义元组 保存同学姓名
# t = ('秦海根','朱烜甫','张刚')
"""------------------ 元组特点 ------------------"""
# 获取某一个元素
# ele = t[0]
# print(ele)
# 不能增加元素
# 不能修改元素
# t[0] = '易文'
# 能不能删除元素
# del t[0]

# print(type(t))

"""------------------ 元组元素可以重复的 ------------------"""

"""------------------ 一个元组元组的定义:需要在元组后面加上, ------------------"""
# 空列表
# l = []
# print(type(l))

# 空元组
# t = ()
# print(type(t))

# 定义一个元素的元组
t = ('张曼玉',)
print(type(t))

元组的操作:

t = ('秦海根', '张刚', '朱烜甫', '张刚')

"""------------------ 查询 ------------------"""
# 查询某一个元素
# ele = t[0]
# print(ele)

# 获取元素的索引
# index = t.index('张刚')
# print(index)

# 张刚出现的次数
# print(t.count('张刚'))

for ele in t:
    print(ele)

列表的作用:

# t = ('秦海根', '张刚', '朱烜甫', '张刚')

"""------------------ 元组的自动组包 ------------------"""
# a = 10
# b = 20
# 同时定义了多个变量
# a,b = 10,20

# 自动组包
# a = 10,20
# print(type(a))

"""------------------ 元组的自动解包 ------------------"""
# t = ('秦海根', '张刚', '朱烜甫')
# name1  =t[0]
# name2  =t[1]
# name3  =t[2]
# print(name1,name2,name3)
# 自动解包 保证接收的变量和元组的元素个数保持一致
# name1,name2,name3 = t
# print(name1,name2,name3)


"""------------------ 数据交换 ------------------"""
a = 10
b = 20
# 交换a和b
# tmp = a
# a = b
# b = tmp
# go语言
a,b = b,a # 组包(20,10) 解包:a:20 b:10

# print(a,b)

"""------------------ 格式化输出 ------------------"""
# t = (10,20)
# print('第一个数据:%d,第二个数据:%d'%(t[0],t[1]))
# print('第一个数据:%d,第二个数据:%d'%t)

"""------------------ 让列表不可变 ------------------"""
l = ['秦海根', '张刚', '朱烜甫']
# 可以把列表变成元组 让它不可修改
t = tuple(l)
print(t)

3.集合

"""
python数据类型:
数值型:int  float bool compex
高级变量类型: list tuple set dict str
list:容器  可以增删改查 有序 元素不唯一
"""
# l = ['张三','李四','王五','张三']
# print(l)
# t = ('张三','李四','王五','张三')
# print(t)

"""------------------ 创建集合 ------------------"""
# 集合特点:元素唯一的
# s = {'张三','李四','王五','张三'}
# 容器中元素是无序的
# s = {'张三','李四','王五'}

# print(s)
"""------------------ 数据类型 ------------------"""
# s = {'张三','李四','王五'}
# print(type(s))

"""------------------ 集合的遍历 ------------------"""
# s = {'张三','李四','王五'}
# for ele in s:
#     print(ele)

"""------------------ 获取集合中第二个元素 ------------------"""
# 能  1  不能 2
# ele = s[1]
# print(ele)

"""------------------ 集合中添加元素 ------------------"""
# s = {'张三','李四','王五'}
# l = ['张曼玉','林青霞','赵六']
# # 添加赵六 add
# # s.add('赵六')
# # print(s)
#
# # update添加
# s.update(l)
# print(s)

"""------------------ 删除元素 ------------------"""
s = {'张三','李四','王五'}
# 删除张三 remove 删除元素,如果元素不存在,删除失败
# s.remove('张三')
# print(s)
# s.remove('林青霞')

# pop 随机删除
# s.pop()
# print(s)

# discard 删除元素 如果元素不存在,不做任何处理
s.discard('林青霞')
print(s)

集合的其它操作:

"""------------------ 子集和超集 ------------------"""
# s1 = {1,2,3}
# s2 = {1,2,3}
# result = s2.issubset(s1)
# print(result)
# result = s1.issuperset(s2)
# print(result)

"""------------------ 并集 ------------------"""
# s1 = {1,2,3}
# s2 = {3,4,5}
# result = s1.union(s2)
# print(result)

"""------------------ 交集 ------------------"""
# s1 = {1,2,3}
# s2 = {3,4,5}
# result = s1.intersection(s2)
# print(result)

"""------------------ 抑或 ------------------"""
s1 = {1,2,3}
s2 = {3,4,5}
# result = s1.symmetric_difference(s2)
# print(result)
s1.symmetric_difference_update(s2) # 更新s1为抑或的结果
print(s1)
# s1.symmetric_difference(s2)
# s1.symmetric_difference_update(s2)  更新s1为异或的结果

集合的作用:

l = ['张三','李四','王五','张三']
# newL = []
# for ele in l:
#     if ele not in newL:
#         newL.append(ele)
#
# print(newL)
# 通过集合对列表去重
# s = set(l)
# print(s)
# l = list(s)
# print(l)

"""------------------ list tuple set相互转换 ------------------"""
# list转换成set
# s = set(l)
# print(s)

# list转换成tuple
t = tuple(l)
# print(t)

# tuple转换成set
s = set(t)
# print(s)

l = list(s)
print(l)

4.字符串:

"""------------------ 字符串的定义 ------------------"""
# 字符:a b c d e f 中  过  华
# str = 'hello'
# str = "hello"
# str = 'hel'你好'lo'
# str = 'hel\'你好\'lo'
# # print(str)
#
# str = "hel\"你好\"lo"
# # print(str)
#
# str = "hel'你好'lo"

"""------------------ 获取某一个元素 ------------------"""
# str = 'hello'
# 获取第三个元素
# ele = str[2]
# print(ele)

"""------------------ 遍历字符串中每一个元素 ------------------"""
# for ele in str:
#     print(ele)

"""------------------ 原样输出字符串 ------------------"""
# str = 'hello'
# str = "hello"
# 省
# 市
# 区
# str = '广东省\n深圳市\n宝安区'
# kotlin
str = '''广东省
深圳市
宝安区'''
print(str)

字符串判断:

# str = 'a'
"""------------------ isalpha  ------------------"""
# result = str.isalpha()
# print(result)

"""------------------ isdecimal ------------------"""
# 字符串非空  并且都是数字  返回True
# str = ''
# result = str.isdecimal()
# print(result)

"""------------------ islower ------------------"""
# str = '123123a'
# result = str.islower()
# print(result)

"""------------------ isupper ------------------"""
# str = '1203123A'
# result = str.isupper()
# print(result)
"""------------------ startwith ------------------"""
# str = 'helloworld'
# result = str.startswith('w',5)
# print(result)

"""------------------ endwith ------------------"""
# str = 'helloworld'
# result = str.endswith('o',2,5)
# print(result)

查找和替换:

# str = 'helloworld'
"""------------------ find ------------------"""
# find返回在字符串中的角标  如果不存在返回-1
# result = str.find('z')
# print(result)
# 首字母对应的角标
# result = str.find('loww')
# 返回的角标 3 4 5
# print(result)

# 默认找到第一个当前元素 返回它的角标
# 可以通过start以及end指定查找范围
# result = str.find('l',5)
# print(result)

"""------------------ rfind:从右边开始找到第一个结束 ------------------"""
# str = 'helloworld'
# print(str.find('l'))
# print(str.rfind('l',1,5))

"""------------------ index ------------------"""
# 如果不存在 就报错  存在返回索引
# str = 'helloworld'
# print(str.index('o'))
# print(str.index('z'))
"""------------------ rindex ------------------"""
# 从右边开始  如果存在返回索引  不存在就报错

"""------------------ replace ------------------"""
str = 'helloworld'
# 如果替换的字符串不存在  不做任何处理
# newStr = str.replace("loww",'up')
# 默认 只要遇到字符串就替换 可以通过第三个参数指定替换的个数
newStr = str.replace("l",'up',2)
print(str)
print(newStr)

字符串拆分和连接:

# str = 'helloworld'
"""------------------ partition ------------------"""
# 根据str将字符串拆分 返回元组 (str前 str  str后)
# result = str.partition('low')
# print(result)

"""------------------ rpartition ------------------"""
# str = 'helloworldhelloworld'
# result = str.partition('low')
# result = str.rpartition('low')
# print(result)

"""------------------ split ------------------"""
# 对字符串进行分割  返回列表  不会保存分割字符串
# str = '张三hello李四hello王五hello赵六'
# result = str.split('hello')
# print(result)

"""------------------ splitlines ------------------"""
# 按\n换行符分割
# str = '广东省\n深圳市\n宝安区'
# str = '''广东省
# 深圳市
# 宝安区'''
# result= str.splitlines()
# print(result)

"""------------------ + ------------------"""
# str1 = 'hello'
# str2 = 'world'
# newStr = str1 +str2
# print(newStr)

"""------------------ join ------------------"""
l = ['张三','李四','王五']
str = 'hello'
# 将容器中所有的元素加上当前字符串分割输出
result = str.join(l)
print(result)

大小写转换:

"""------------------ lower ------------------"""
# str = 'HELLOw12312'
# 字符串转换小写
# result = str.lower()
# print(result)
"""------------------ upper ------------------"""
str = 'helloA1231中国'
result = str.upper()
print(result)

文本对齐:

"""------------------ ljust ------------------"""
# str = 'hello'
# result = str.ljust(10,'-')
# print(str)
# print(result)
"""------------------ rjust ------------------"""
# str = 'hello'
# result = str.rjust(10,'*')
# print(result)
"""------------------ center ------------------"""
# str = 'hello'
# result = str.center(10,"&")
# print(result)

去空白:

"""------------------ lstrip ------------------"""
# 去除左边的空白
# str = '   hello   '
# result = str.lstrip()
# print(result)

# str = '----hello   '
# result = str.lstrip('-')
# print(result)

"""------------------ rstrip ------------------"""
# str = '   he**llo****'
# result = str.rstrip('*')
# print(result)

"""------------------ strip ------------------"""
str = '  hello  '
result = str.strip()
print(result)

字符串练习-判断用户名和密码.:

"""
需求:
用户名和密码格式校验程序
要求从键盘输入用户名和密码，校验格式是否符合规则，如果不符合，打印出不符合的原因，并提示重新输入
用户名长度6-20，用户名必须以字母开头
密码长度至少6位，不能为纯数字，不能有空格

分析:
1.从键盘输入用户名(需要while循环)
2.长度6-20
3.必须字母开头

4.输入密码(while循环)
5.密码长度至少6位
6.不能为纯数字
7.不能有空格
"""
while True:
    # 1.从键盘输入用户名(需要while循环)
    name = input('请输入用户名:')
    # 2.长度6-20
    if not (len(name) >= 6 and len(name) <= 20):
        print('用户名必须6到20位')
        continue
    # 3.必须字母开头 ab A-Z
    # 获取第一个字母  是否是a-z A-Z a
    ele = name[0]
    if not ele.isalpha():
        print('用户名第一个必须为字母')
        continue

    # 用户名满足
    print('用户名合法')
    break

# 4.输入密码(while循环)
while True:
    pwd = input('请输入密码')
    # 5.密码长度至少6位
    if len(pwd) < 6:
        print('密码长度至少为6位')
        continue
    # 6.不能为纯数字
    if pwd.isdecimal():
        print('密码不能为纯数字')
        continue
    # 7.不能有空格
    # ' 张 三  '
    if ' ' in pwd:
        print('密码不能有空格')
        continue
    print('密码合法')
    break

print('开始登录')

5.字典

"""------------------ 字典的定义 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America',30:'sadf',(10,20,30):'afdsf'}
# key只能是数字 字符串 元组类型
# d = {'中国':'China','英国':'England','美国':'America',30:'sadf',(10,20,30):'afdsf',1.2323:12,True:243234}

# vlaue可以是任意类型
# d = {'中国':'China','英国':'England','美国':'America',30:[1,2,3],40:{1,2,3}}
# print(d)

"""------------------ key必须是唯一的 ------------------"""
# key必须要唯一  如果出现多个相同的key  后面的会覆盖前面的内容
# key相当于字典的索引
d = {'中国':'China','英国':'England','美国':'America','美国':'USA'}
print(d)

字典的增删改:

"""------------------ 增加 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 添加 法国
# 字典[key] = value
# d['法国'] = 'France'
# print(d)

# d.setdefault('法国','France')
# print(d)

"""------------------ 删除 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 删除美国 如果键不在字典中,会报错
# del d['法国']
# print(d)

# pop 删除元素 并且返回删除元素的值 如果删除不存在会报错
# result = d.pop('法国')

# print(d)
# print(result)


# del d
# del d # 销毁当前容器  不能再继续使用
# print(d)

# 清空容器中的数据  还可以继续使用
# d.clear()
# print(d)
# d['中国'] = 'China'
# print(d)

"""------------------ 修改 ------------------"""
d = {'中国':'China','英国':'England','美国':'America'}
# 修改美国
# d['美国'] = 'USA'
# d.setdefault('美国','USA')
# d['法国'] = 'France'
# print(d)

字典的查询和遍历:

"""------------------ 字典查询键对应的值 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 根据键获取值  如果键值对不存在,就会报KeyError
# ele = d['法国']
# print(ele)

# get 获取键对应的值 如果键值对不存在,不会报错 返回的结果是None
# ele = d.get('英国')
# if ele:
#     print('成功',ele)
# else:
#     print('失败')
"""------------------ 查询所有的键值对 ------------------"""
# d = {'中国':'China','英国':'England','美国':'America'}
# 查询所有的键 视图对象
# result = d.keys()
# 视图转换成列表
# keyList = list(result)
# print(keyList)

# 获取所有的values 返回视图
# result = d.values()
# 视图转换成list
# valuesList = list(result)
# print(valuesList)

# items获取所有的键值对 返回列表  列表中每一个元素是键值对的元组
# result = d.items()
# 视图转换成list
# itemsList = list(result)
# print(itemsList)

"""------------------ 遍历 ------------------"""
d = {'中国':'China','英国':'England','美国':'America'}
print(len(d))
# for ele in 遍历 ele代表键
# for ele in d:
#     print(ele,d[ele])

# 获取所有的键
# for key in d.keys():
#     print(key)

# 打印所有的values
# for value in d.values():
#     print(value)

# items打印所有的键值对
# for ele in d.items():
#     print(ele)

for key,value in d.items():
    print(key,value)

字典的应用场景:

# 描述人 姓名 电话  年纪  性别  动态行为 吃饭 开车 学习
# l = ['张三','12321',40,'男']
# 字典
d = {'name':'张三','phone':'12332','age':40,'性别':'男'}

l = []
l.append(d)
d = {'name':'李四','phone':'12332','age':40,'性别':'男'}
l.append(d)
print(l)

空字典:

# 空列表
l = []
# 空元组
# d = ()
# d = (10,)

# 空字典 {}
# d = {}
# print(type(d))

# 空集合 不能通过{}定义  需要通过set定义
s = set()
print(s)

字典练习:

students = [
    {"name": "阿土",
     "age": 20,
     "gender": True,
     "height": 1.7,
     "weight": 75.0},
    {"name": "小美",
     "age": 19,
     "gender": False,
     "height": 1.6,
     "weight": 45.0},
]
"""------------------ 判断如下列表中是否存在name为'阿土'的元素 ------------------"""
mark = False
# 遍历列表
for ele in students:
    # 遍历每一个字典的数据
    for key,value in ele.items():
        # name=='阿土'是否存在
        if key=='name' and value=='阿土图':
            print('找到了数据')
            mark = True
            break

    if mark:
        break
else:
    print('没有这个数据')

高级变量练习:

"""
需求:
有10个球分别3红、3蓝、4白，现需要将这10个球放入这3个盒子，要求每个盒子至少有一个白球，请用程序实现

一个容器保存所有的球
分析:
1.定义容器保存所有的球
2.定义三个盒子 嵌套列表
3.遍历三个盒子,每个盒子添加一个白球

三个容器保存三种球
1.定义三个容器保存三种球
2.定义三个盒子 嵌套列表
3.白球分配到三个盒子中
4.三个容器合并,再进行分配

"""
"""------------------ 一个容器保存所有的球 ------------------"""
# import random
# # 1.定义容器保存所有的球
# balls = ['白','蓝','白','白','红','白','蓝','蓝','红','红']
# # 2.定义三个盒子 嵌套列表
# boxes = [[],[],[]]
# # 3.遍历三个盒子,每个盒子添加一个白球
# for box in boxes:
#     # 找到白球
#     # 添加白球
#     box.append(balls.pop(balls.index('白')))
#     # 从balls容器把添加的白球删除掉
# # for box in boxes:
# #     # 找到白球
# #     index = balls.index('白')
# #     ball = balls[index]
# #     # 添加白球
# #     box.append(ball)
# #     # 从balls容器把添加的白球删除掉
# #     balls.remove(ball)
#
# # print(balls)
# # print(boxes)
#
# # 4.剩下的球再进行分配
# # 球 1  盒子 2
# for ball in balls:
#     index = random.randint(0,2)
#     # 随机获取box
#     box = boxes[index]
#     # 添加球到盒子中
#     box.append(ball)
#
# balls.clear()
# print(balls)
# print(boxes)
"""------------------ 三个容器保存三种球 ------------------"""
import random
# 1.定义三个容器保存三种球
whiteBalls = ['白','白','白','白']
redBalls = ['红','红','红']
blueBalls = ['蓝','蓝','蓝']

# 2.定义三个盒子 嵌套列表
boxes = [[],[],[]]
# 3.白球分配到三个盒子中
for box in boxes:
    # 找到白球
    # 添加白球
    box.append(whiteBalls.pop(whiteBalls.index('白')))
# print(boxes)
# print(whiteBalls)
# 4.三个容器合并,再进行分配
l = []
l.extend(whiteBalls)
l.extend(redBalls)
l.extend(blueBalls)

whiteBalls.clear()
redBalls.clear()
blueBalls.clear()

for ball in l:
    index = random.randint(0,2)
    # 随机获取box
    box = boxes[index]
    # 添加球到盒子中
    box.append(ball)

print(boxes)

6.内置函数:

# d = {'name':'张三','age':40}
# del d
# print(len(d))
# print(d)

s = {20,50,100}
# print(max(s))
d = {20:60,90:40}
print(max(d))

运算符:

"""------------------ + ------------------"""
str1 = 'hello'
str2 = 'world'
newStr = str1+str2
# result = str1+10
# print(newStr)

# 列表+
# l1 = [1,2,3]
# l2 = [4,5,6]
# newL = l1+l2
# print(newL)

# 元组+
# t1 = (1,2,3)
# t2 = (4,5,6)
# newT = t1+t2
# print(newT)

"""------------------ * ------------------"""
str = 'hello'
# print(str * 5)

# l = [1,2,3]
# print(l * 5)

# t = (1,2,3)
# print(t * 5)


"""------------------ in 和not in ------------------"""
# 字典中in和not in判断的是key是否在字典中

"""------------------ 比较 ------------------"""
# str1 = 'hemlo'
# str2 = 'hfllo'
# print(str1 < str2)

l1 = [1,2,3]
l2 = [1]
print(l1 > l2)

切片:

"""
切片:字符串 列表  元组
"""

# str = '中华人民共和国欢迎您'
"""------------------ 切片的简单使用 ------------------"""
# 获取前三个文字
# newStr = str[0:3:1]
# print(newStr)

# 步长:默认1 省略默认步长
# newStr = str[0:3:]
# 不写步长 可以省略步长前面的:
# newStr = str[0:3]
# 索引从0开始 可以省略开始索引,不能省略:
# newStr = str[:3]

#  后5个元素
# newStr = str[5:10]
# 结束索引是在最后 可以省略结束索引
# newStr = str[5:]
# print(newStr)


"""------------------ 步长 ------------------"""
# str = '中华人民共和国欢迎您'
# newStr = str[0:8:3]
# print(newStr)

倒序索引:

"""
需求:
str = "中华人名共和国欢迎您"
把字符串中从第一个到倒数第二个(不包含)打印出来

"""
str = "中华人名共和国欢迎您"
# 把字符串中从第一个到倒数第二个(不包含)打印出来
# newStr = str[:8]
# 开始位置 正序  结束位置:倒序
newStr = str[:-2]
print(newStr)

负数步长:

"""
需求:
str = "中华人名共和国欢迎您"
把从角标为2到7(包含)倒序打印出来

"""
str = "中华人名共和国欢迎您"
# 把从角标为2到7(包含)倒序打印出来
# 欢国和共名人
# newStr = str[2:8:-1]
# 步长为负  索引也应该逆序索引
newStr = str[7:1:-1]

print(newStr)

高级变量练习:

"""

需求:
完成字符串的逆序以及统计
设计一个程序，要求只能输入长度低于31的字符串，否则提示用户重新输入
打印如下内容:
您输入的字符串: ...
长度: ...
逆序后为: ...
字符统计结果: ...(afsfdsf)  a:1  f:3 s:2 d:1
zhangsanlisi

分析
1.输入字符串(while循环)
2.字符串长度小于31位,否则提示重新输入
3.您输入的字符串: ...
4.长度: ...
5.逆序后为: ...  (切片)
6.字符统计结果: ...(afsfdsf)  a:1  f:3 s:2 d:1
 safljdsfl  s:2 a:1 f:2 l:2 j:1 d:1
"""
while True:
    # 1.输入字符串(while循环)
    str = input('请输入字符串')
    # 2.字符串长度小于31位,否则提示重新输入
    if len(str)>=31:
        print('不能超过31位,请重新输入')
        continue
    # 跳出循环
    break
print('输入正确')
# 3.您输入的字符串: ...
print('您输入的字符串:%s'%str)
# 4.长度: ...
print('长度:%d'%len(str))
# 5.逆序后为: ...  (切片)
# hello  olleh
newStr = str[::-1]
# print('逆序后为:%s'%newStr)
# 6.字符统计结果: ...(afsfadsf)  a:1  f:3 s:2 d:1
# 1.字典 保存结果  {}
resultDict = {}
# 2. 如果字典中没有这个a  a添加进去 {'a':1}
for ele in str:
    # 3.字典中有a 将元素个数+1
    if ele not in resultDict:
        resultDict[ele] = 1
    else:
        resultDict[ele] += 1
print('字符统计结果:{}'.format(resultDict))

7.列表推导式

# l = []
# for ele in range(1,10001):
#     if ele % 2 ==0:
#         l.append(ele)
#
# print(l)
"""------------------ 推导式 ------------------"""
# 需要定义列表保存从1到10000的数据,怎么做?
# l = [ele for ele in range(1,10001)]
# print(l)

"""------------------ 2.创建包含1到10000中所有偶数的列表 ------------------"""
# l = [ele for ele in range(1, 10001) if ele % 2 == 0]
# print(l)

"""------------------ 3.创建嵌套列表(列表每个元素是两个元素的元组) ------------------"""
# l = [(1,2),(2,4),(3,6)..,(100,200)]
# l = [(ele,ele*2)for ele in range(1,101)]
# print(l)

"""------------------ 4.创建嵌套列表(列表每个元素是三个元素的元组) ------------------"""
# l = [(1,2,3),(2,4,6),(3,6,9)..,(100,200,300)]
# l = [(ele,ele*2,ele*3)for ele in range(1,101)]
# print(l)

推导式练习:

"""
需求:
请写出一段 Python 代码实现分组一个 list 里面的元素
比如 [1,2,3,...100]变成 [[1,2,3],[4,5,6]....[100]]

"""
l = [ele for ele in range(1,101)]
# print(l)
# [[1,2,3],[4,5,6]....[100]]
# [[ele,ele+1,ele+2]for ele in l if ]
# 切片 0:3  3:6 6:9
newL = [l[ele:ele+3]for ele in range(0,len(l)) if ele %3==0]
print(newL)
# str = 'hello'
# print(str[3:10])

集合和字典推导式:

"""------------------ 集合推导式 ------------------"""
# s = {ele for ele in range(1,101)}
# print(s)

"""------------------ 字典的推导式 ------------------"""
# 需求:
# 定义{"1":1,"2":4,'3':9,..,'10':100}这样的字典
# d = {str(ele):ele**2 for ele in range(1,11)}
# print(d)

l1 = [ele for ele in range(1,11)]
l2 = [ele for ele in range(21,31)]
# {1:21,2:22,3:23}
# 错误写法
# d = {key:value for key in l1 for value in l2}
# 正确写法 l1和l2打包一起 一起遍历 zip
d = {key:value for key,value in zip(l1,l2)}
print(d)

 

来源：CSDN

作者：苏凯勇往直前

链接：https://blog.csdn.net/qq_15204179/article/details/104593008