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 = 0while 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] = tmpcol += 1row += 1print(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 + 1while col < len(l):# 对比当前元素和实际最小值角标元素if l[col]<l[index]:# 修改indexindex = colcol += 1# 一轮结束 如果假定的最小值角标和实际的最小值角标不一致,交换数据if row!=index:# 交换数据tmp = l[row]l[row] = l[index]l[index] = tmprow += 1print(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 35: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)breakelse: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 += 1elif (ele in lowerStr):# 小写字母lowerCount += 1elif (ele in upperStr):# 大写字母upperCount += 1elif ele == '_':passelse:# 不合法字符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-20if not (len(name) >= 6 and len(name) <= 20):print('用户名必须6到20位')continue# 3.必须字母开头 ab A-Z# 获取第一个字母  是否是a-z A-Z aele = 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('密码不能有空格')continueprint('密码合法')breakprint('开始登录')

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 = Truebreakif 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)# 随机获取boxbox = 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:1safljdsfl  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 将元素个数+1if ele not in resultDict:resultDict[ele] = 1else: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)

Python基础-高级变量类型相关推荐

1. Python 之 高级变量类型

   高级变量类型 目标 列表 元组 字典 字符串 公共方法 变量高级 知识点回顾 Python 中数据类型可以分为 数字型 和 非数字型 数字型 整型 (int) 浮点型(float) 布尔型(bool) ...

2. python基础之变量类型list

   变量类型-List list 列表的数据项不需要具有相同的类型 List(列表) 是 Python 中使用最频繁的数据类型. 列表可以完成大多数集合类的数据结构实现.它支持字符,数字,字符串甚至可以包 ...

3. 8_python基础—高级变量类型(字符串、列表、元组、字典、集合)

   文章目录 一.字符串 str,有序序列(支持下标)不可变 1.1 字符串的定义 1.2 字符串的常用操作 1) 判断类型 - 9 2) 查找和替换 - 7 3) 大小写转换 - 5 4) 文本对齐 - ...

4. Python 高级变量类型 —— 列表、元组、字典、字符串、公共方法

   文章目录 写在开头的话 高级变量类型 00. 目标 知识点 01. 列表 1.1 列表的定义 1.2 列表常用操作 关于del关键字 02. 元组 2.1 元组的定义 创建含有多种数据类型的元组 创建 ...

5. Python中的高级变量类型

   高级变量类型 目标 列表 元组 字典 字符串 公共方法 变量高级 知识点回顾 Python 中数据类型可以分为 数字型 和 非数字型 数字型 整型 (int) 浮点型(float) 布尔型(bool) ...

6. bool类型返回值_Python语法基础：高级变量类型

   高级变量类型 目标 列表 元组 字典 字符串 公共方法 变量高级 知识点回顾 Python 中数据类型可以分为 数字型 和 非数字型 数字型 整型 (int) 浮点型(float) 布尔型(bool) ...

7. Python数据结构与算法（1.2）——Python基础之变量与内置数据类型

   Python数据结构与算法(1.2)--Python基础之变量与内置数据类型 0. 学习目标 1. Python 程序的运行 1.1 Python 交互式解释器 1.2 Python 程序脚本 2. ...

8. python#高级变量类型1

   一.高级变量类型 1. 列表 1.1 列表的定义 List(列表) 是 Python 中使用 最频繁 的数据类型,在其他语言中通常叫做 数组 专门用于存储 一串 信息 列表用 [] 定义,数据 之间使 ...

9. Python高级变量类型【列表、元组、字典、字符串】

   这里写目录标题 高级变量类型 知识点回顾 1. 列表 1.1 列表的定义 1.2 列表常用操作 1.3 循环遍历 1.4 应用场景 2. 元组 2.1 元组的定义 2.2 元组常用操作 2.3 循环遍 ...

最新文章

1. linux m4a 转换成 mp3
2. 【问题】最近遇到的不大不小的arduino库使用问题
3. Vagrant 手册之多个虚拟机 multi-machine
4. redis源码阅读(1)
5. Web前端面试指导(六)：面试后需要总结和交流
6. php mysql完全自学手册 smarty_PHPSmarty完全开发手册.pdf
7. 关闭appleid双重认证_如何查看并移除登陆过Apple ID的设备
8. 「游戏建模」如何使用zbrush为模型制作衣服上的褶皱
9. 【阿里云·云原生架构·白皮书】保姆级解读 一、 云原生架构定义
10. python3 TypeError: 'map' object is not subscriptable
11. bzoj5148:[BeiJing2018]Kakuro
12. 【Airpods Pro】无法通过蓝牙连接电脑
13. k8s+Jenkins+GitLab-自动化部署tomcat项目
14. Windows7下安装Docker、下载镜像和运行OpenTsdb容器
15. 毕达哥拉斯素数的王伟猜想
16. 【10位时间戳转换日期公式】
17. Js中的作用域和作用域链
18. com.neenbedankt.android-apt
19. 2019年燕山大学大学生程序设计大赛（一）
20. Thinking in Java 中闪耀的星星(一)

热门文章

1. hdu 2255+hdu 3395
2. 中兴3G模块 MU301
3. 高性能网站建设之减少Http连接数
4. Struts的文件上传与下载
5. TensorFlow之激活函数(8)
6. 【Java】synchronized与lock的区别
7. yii　操作数据库的三种方法
8. 1 Linux挂载光盘与U盘
9. 计算机网络原理应用题/计算题
10. 查看unix和linux的HBA卡的WWN地址