字符串:数据类型的学习

#======================================基本使用======================================
#1、用途 #2、定义方式 #3、常用操作+内置的方法 #======================================该类型总结====================================
#存一个值or存多个值 #有序or无序 #可变or不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)
  • 一、字符串索引
s2 = 'abc123嘿嘿'

# 正向索引,从0开始编号
print(s2[3])
# 反向索引,从-1开始编号
print(s2[-3])
  •  二、字符串切片
切片:(获取子字符串):
语法[开始索引:结束索引:步长]
i) 步长省略,默认为1
ii) 起始索引省略,默认为从头开始
iii) 结束索引省略,默认到最后结束
# 顾头不顾尾[6:8],从索引6截取到索引8之前
ss2 = 'hello world'
new_ss2 = ss2[6:8:]
print(new_ss2)
>wo
# 结束索引:-1代表截取到最后一位之前,省略代表截取到最后
# 开始索引省略代表从头开始截取
print(ss2[6:-1:])
>worl
# 截取一次只截取一个字符,但是截取后迈2步截取下一个hlowrd
print(ss2[::2])
>hlowrd
# 打印'dlrow olleh',翻转字符串
# 步长为负数时,从后往前截取(开始索引建议使用负值)
print(ss2[-1::-1])
>dlrow olleh
#作用:名字,性别,国籍,地址等描述信息

#定义:在单引号\双引号\三引号内,由一串字符组成
name='egon' #优先掌握的操作:
#1、按索引取值(正向取+反向取) :只能取
#2、切片(顾头不顾尾,步长)
#3、长度len
#4、成员运算in和not in
#5、移除空白strip
#6、切分split
#7、循环

需要掌握:

#1、strip,lstrip,rstrip
#2、lower,upper
#3、startswith,endswith
#4、format的三种玩法
#5、split,rsplit
#6、join
#7、replace
#8、isdigit
# 1.获取字符串长度
s3 = 'abcdef'
print(len(s3)) # len(s) 获取s的字符长度
>6 # 2.成员运算
#语法:in | not in:子字符串是否在父字符串中
s5 = 'abc123嘿嘿'
# in | not in: 子字符串 in 父字符串
print('abcd' in s5)
print('abc' not in s5)
print('呵呵' not in s5)
>False
>False
>True
# not in要同步出现
# print('>>>', '呵呵' not in s5)
# 3.首尾去白 #语法:strip()
print(' hello wolrd '.strip())
>hello wolrd
print('===login success==='.strip('='))
>login success
# 4.拆分
#语法:split(拆分规则, 拆分次数) print('D:\\python36\\python3.exe'.split('\\', 1))
>['D:', 'python36\\python3.exe']
s4 = "D:\\pathon36\\python3.exe"
# 需求:1.获取python的安装盘符;2.获取python的执行文件
s4_list = s4.split('\\') # 拆分:就是将字符串转化为列表
print(s4_list)
>['D:', 'pathon36', 'python3.exe']
print(s4_list[0])
>D:
print(s4_list[-1])
>python3.exe
# 完成以上需求还要保证拆分得到的结果尽可能短
## 注:拆分的依据,拆分的次数
s4_list = s4.split('\\', 1)
print(s4_list[0])
#strip,lstrip,rstrip
name='*egon**'
print(name.strip('*')) # *全部去掉
print(name.lstrip('*')) # 去掉左边的* leftstrip=lstrip
print(name.rstrip('*')) # 去掉右边的* rightstrip=rstrip #lower,upper
name='simoN'
print(name.lower()) # name内容全部小写
print(name.upper()) # name内容全部大写 #startswith,endswith
name='alex_SB'
print(name.endswith('SB')) #以SB结尾为真:True
print(name.startswith('alex')) #以alex开头为真:True #format的三种玩法
res='{} {} {}'.format('egon',18,'male')
>egon 18 male
res='{1} {0} {1}'.format('egon',18,'male')
>18 egon 18
res='{name} {age}{sex}'.format(sex='male',name='egon',age=18)
>egon 18 male #split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1)) name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分
>['a|b', 'c'] #join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串
>egon say hello world #replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
>SB say :i have one tesla,my name is alex #isdigit:可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())

各类参数例子

参数

#  rsplit:从右开始拆分
s4 = "D:\\pathon36\\python3.exe"
s4_list = s4.rsplit('\\', 1)
print(s4_list) # startswith | endswith:以某某开头 | 结尾:返回值为bool类型
print("http://www.baidu.com".startswith('https://'))
print("http://www.baidu.com".endswith('com')) # 思考:自学正则:re # format:格式化
print('name:%s,age:%s' % ('owen', 18))
# 占位与实际数据要进行个数与位置的匹配
print('name:{},age:{}'.format('Liuxx', 8))
# 指定位置要数据:{0}要0号位数据
print('name:{0},age:{1}, name:{0}'.format('Linoo', 58))
# 指定名字要数据
print('name:{usr},age:{age}, name:{usr}'.format(age=58, usr='Linoo')) # replace:替换
# 语法:replace(oldS, newS, count)
s6 = 'abcabcabc'
newS6 = s6.replace('a', 'A', 2)
print(newS6)

补充

参数补充

# 1. find | rfind:查找子字符串索引,无结果返回-1
s1 = 'abcabc'
print(s1.rfind('ab')) # 返回第一次查询到的(目标字符串首位)正向索引 # 2. index | rindex:查找子字符串索引,无结果抛出异常
print(s1.index('cb')) # 崩溃 # # 3. count:计算子字符串个数
print(s1.count('abc'))
#
# 4. center | ljust | rjust | zfill:按位填充,一般在进制时使用,不足填0
# 语法:center(所占位数, '填充符号')
# 使用: 调用者.center(参数)
print("华丽分割线".center(30, '-'))
print("华丽分割线".ljust(30, '-'))
print("".zfill(5))
print("".zfill(5))
print("".zfill(5))
#
# # 5. expandtabs:规定\t所占空格数
print('hello\tworld'.expandtabs(8))
#
# # 6. captialize | title | swapcase:首字母大写 | 单词首字母大写 | 大小写反转
print("hello world".capitalize())
print("hello world".title())
print("hello WORLD".swapcase())
#
# # 7. isdigit | isdecimal | isnumeric:数字判断
s7 = b'' # isdigit来判断是否可以转换为数字
print(b''.isdigit())
# 三个方法均有
print(u''.isdigit())
print(u''.isdecimal())
print(u''.isnumeric()) print('肆'.isdigit())
print('肆'.isdecimal())
print('肆'.isnumeric()) # 可以判断中文数字
print('Ⅳ'.isdigit())
print('Ⅳ'.isdecimal()) # 不用管
print('Ⅳ'.isnumeric()) # 可以判断罗马数字
#
# # 8. isalnum | isalpha:是否由字母数字组成 | 由字母组成
print('abc123_'.isalnum())
print('abc'.isalpha())
#
# # 9. isidentifier:是否为合法变量名
print('>>>', 'a_123'.isidentifier())
#
# # 10. islower | isupper:是否全小 | 大写
print("aBc".islower())
print("ABC".isupper())
#
# # 11. isspace:是否是空白字符
print(" ".isspace())
#
# 12. istitle:是否为单词首字母大写格式
print("Hello World".istitle())

  • 三、字符串循环
s = 'hello world'

# 字符串循环(遍历)
i = 0
while i < len(s):
print(s[i])
i += 1 # 迭代
for c in s:
print(c)
# 总结:
# 1.循环迭代s,一次在s中取出一个字符,存放到c中
# 2.下一次取出会覆盖上一次c
# 3.当s中所有字符取出后,循环自动停止 # 哪些变量是可以被迭代的:str、list、dict、tuple、set、range生产的对象
print(range(5))
# 从什么数字开始,到什么数字前结束,步长是多少
for i in range(1, 5, 2):
print(i) for i in range(10, 16):
print(i)
# 写代码,有如下变量,请按照要求实现每个功能 (共6分,每小题各0.5分)
name = " aleX"
# 1) 移除 name 变量对应的值两边的空格,并输出处理结果
# 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果

# 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果

# 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6) 将 name 变量对应的值变大写,并输出结果

# 7) 将 name 变量对应的值变小写,并输出结果

# 8) 请输出 name 变量对应的值的第 2 个字符
# 9) 请输出 name 变量对应的值的前 3 个字符
# 10) 请输出 name 变量对应的值的后 2 个字符
# 11) 请输出 name 变量对应的值中 “e” 所在索引位置?

# 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。

练习题目

name = " aleX"

# 1)
print(name.strip()) # >aleX
# 2)
print(name.startswith("al")) # >False
# 3)
print(name.endswith("X")) # >True
# 4)
print(name.replace('l','p')) #> apeX
#5)
print(name.split("l")) # >[' a', 'eX']
# 6)
print(name.lower()) # > alex
# 7)
print(name.upper()) # > ALEX
# 8)
print(name[2]) #> l
# 9)
print(name[:3]) # > al
# 10)
print(name[3:]) # >eX
print(name[-2:]) #步长为正数时从前往后取值,为负数时从后往前取值
#11)
print(name.index("e")) # >3
#12)
print(name[:4]) #> ale
print(name[:-1]) #> ale

练习结果

  • 四、可变和不可变类型
# 数字
# 1.只能存放一个值
# 2.数字为不可变类型: 值改变了id一定改变(值一旦确定,就不能再修改) a = 10
print(id(a))
# a = 11
a += 1
print(id(a)) # 字符串
# 1.只能存放一个值
# 2.字符串为不可变类型
s = ''
print(id(s))
s = s * 2
print(id(s)) # 列表: 为可变类型,在id不改变的情况下,还可以修改内部数据
l = [1, 2, 3]
print(id(l))
# print(l[0])
l[0] = 10
print(id(l))
l.append(20)
print(id(l))
  • 五、列表
介绍:
#作用:多个装备,多个爱好,多门课程,多个女朋友等 #定义:[]内可以有多个任意类型的值,逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])

l=list('abc')
l1 = [1, 3.14, 5 + 4j, True, 'abc', [[1]]]
print(l1) l2 = list([1, 3.14, 5 + 4j, True, 'abc', [[1]]])
print(l2)
#优先掌握的操作: #1、按索引存取值(正向存取+反向存取):即可存也可以取  #2、切片(顾头不顾尾,步长) #3、长度 #4、成员运算in和not in #5、追加 #6、删除 #7、循环
#ps:反向步长
l=[1,2,3,4,5,6] #正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]

1.字符串转换为列表

# 将字符串转换为列表: 字符串方法
l3 = 'hello world'.split(' ')
print(l3) # 将列表转换为字符串: 字符串方法,调用方法的字符串为拼接字符串的依据
# 将列表中的所有数据,从前往后,安装拼接符进行拼接
newStr = '@'.join(l3) # hello@world
print(newStr) 列表转换为字符串:
l = ["hi","hello","world"]
print(" ".join(l))

2.列表切片

list3 = [1, 2, 3, 4, 5]
print(list3[1:-1:2]) # [2, 4]

3.列表的增删改查

#1. 删除普通变量
a = 10
del a
print(a) #2. 增:append(obj) 在末尾添加对象
list4 = []
print(id(list4)) #id:35656200
list4.append(1)
list4.append(5)
list4.append(2)
print(list4) #[1, 5, 2]
print(id(list4)) # id:35656200 #3. 插入(对应位置插入数据)
list4.insert(0, 10)
print(list4) #[10, 1, 5, 2]
print(id(list4)) # #4. 删
# 删除指定索引
del list4[0]
print(list4) # [1, 5, 2]
# 删除指定对象
list4.remove(5)
print(list4) #[1, 2] #5. 改:
list4[0] = 10000
print(list4) #[10000, 2] #6. 查
print(list4[1]) # #7.长度
print(list4)
list4.append(88888)
print(len(list4)) # list4: [10000, 2, 88888] 共3个值 #8. 成员运算
print(2 in list4) #True # 9. 循环:迭代
list7 = [1, 3, 5, 7, 0] for obj in list7:
print(obj, end=',')
# 1,3,5,7,0, # 需求:打印1,3,5,7,0
sss = ""
for obj in list7:
sss += str(obj) + ',' # obj是int类型,不能直接做字符串拼接,转化成字符串
print('>>>', sss[:-1])
# >>> 1,3,5,7,0

增删改查

# 翻转
a = [1, 3, 2]
a.reverse()
print(a) # [2, 3, 1] # 排序:
# 前提:1.数据之间全部具有可比性;2:数据要统一类型
b = [1, 3, 2, 5, 4]
b.sort()
print(b) # [1, 2, 3, 4, 5]
# 倒序
b.reverse()
print(b) # [4, 5, 2, 3, 1]
b.sort(reverse=True)
print(b) # [5, 4, 3, 2, 1]
''' ***
1. copy:复制
2. clear:清空
3. count:计算成员个数
4. extend:添加多个值(参数为可迭代对象)
5. index:查找索引
'''
x = [1, 3, 5, 3]
y = x
print(x, id(x)) # [1, 3, 5, 3] 32117256
print(y, id(y)) # [1, 3, 5, 3] 32117256 z = x.copy()
print(z, id(z)) # [1, 3, 5, 3] 32091976
#copy复制,id会变,x值被修改,但copy出来的z却不会
x[0] = 10000
print(x[0]) #
print(y[0]) #
print(z[0]) #
#清空列表
z.clear()
print(z) # []
#统计成员个数
# # [10000, 3, 5, 3]
print(x.count(3)) # 2 3在列表中的总数量
#extend添加多个值
list1 = []
list1.extend('abc')
print(list1) # ['a', 'b', 'c']
#
list2 = ['abc', 'xyz']
list1.extend(list2)
print(list1) # ['a', 'b', 'c', 'abc', 'xyz']

参数补充

max(list):返回列表元素最大值
min(list):返回列表元素最小值
list(seq):将元组转换为列表

总结:
1. 列表中可以存放多个值
2. 列表为可变类型:id不变的情况下,可以发生值变化
3. 列表为有序存储结构:可以通过索引取值
"""
#zip dict index list enumerate(取下标) len
s为字符串
s.isalnum() 所有字符都是数字或者字母
s.isalpha() 所有字符都是字母
s.isdigit() 所有字符都是数字
s.islower() 所有字符都是小写
s.isupper() 所有字符都是大写
s.istitle() 所有单词都是首字母大写,像标题
s.isspace() 所有字符都是空白字符、\t、\n、\r
"""
"""
name = "my \tname is {name} and I am {year} yearold"
print(name.capitalize()) #首字母大写
print(name.count("o")) #统计出现o的次数
print(name.center(10,"-"))
print(name.endswith("on")) #判断以什么结尾,True
print(name.expandtabs(tabsize=10)) #转换空格,很少用
print(name.find("name")) #列表中以什么开头
print(name[name.find("name"):]) #字符串切片
print(name.format(name='alex',year=23))
print(name.format_map( {'name':'alex','year':12} ))
print(name.isalnum()) #isalnum判断是不是阿拉伯数字,不能有特殊字符
print(name.isalpha()) #纯因为字符
print('1'.isdecimal()) #
print('11'.isdigit()) #是不是整数
print('_1A'.isidentifier()) #判断是不是一个合法的标识符或合法的变量名
print('11'.isnumeric()) #是不是一个整数字
print(' '.isspace()) #是不是空格
print('My Name Is'.istitle()) #每个首字母是否大写
print('My Name Is'.isprintable()) #pty、drive文件
print('MY'.isupper()) #是不是都是大写
print('+'.join(['1','2','3'])) #列表转换为字符串
print(name.ljust(50,'*')) #末尾补齐50个字符
print(name.rjust(50,'*')) #开头补齐
print('Simon'.lower()) #转换为小写
print('Simon'.upper()) #转换为大写
print('\nSimon'.lstrip()) #从左边去掉空格和回车
print('\nSimon\n'.rstrip()) #从右边去掉空格和回车
print(' Simon\n'.strip()) #2变空格和换行都去掉
p = str.maketrans("abcdefmn",'1234567$')
print("simon xiong".translate(p)) #将内容进行对应转换,感觉加密的时候也许可以使用
print('simon'.replace('s','S')) #小写s替换为大写
print('simons'.replace('s','S',1)) #只替换1个
print("simon xiong".rfind('n')) #找到最后边值的下标
print("simon".rsplit())
print("simon".split('m')) #将字符串按空格进行分隔
print('1=2\n+3+4'.splitlines()) #识别不同系统的换行
print('Simon Xiong'.swapcase()) #大小写转换
print('Simon Xiong'.title()) #首字母大写
print("Simon xiong".zfill(50)) #16进制补位

参数详细解释

练习:

# 1. 有列表data=['alex',49,[1970,3,18]],分别取出列表中的名字,年龄,出生的年,月,日赋值给不同的变量
data=['alex',49,[1970,3,18]]
name = data[0]
age = data[1]
born1 = [str(i) for i in data[2]]
born = '-'.join(born1) print(name,age,born) # 2. 用列表模拟队列
#队列的特点:先进先出、后进后出 #用列表insert、pop模拟进队出队:
>>> l = []
>>> l.insert(0,'s1')
>>> l.insert(0,'s2')
>>> l.insert(0,'s3')
>>> l
['s3', 's2', 's1']
>>> l.pop()
's1'
>>> l
['s3', 's2']
>>> l.pop()
's2'
>>> l
['s3']
>>> l.pop()
's3'
>>> l
[] # 用列表append、pop模拟进队出队
>>> l
[]
>>> l.append('s4')
>>> l.append('s5')
>>> l.append('s6')
>>> l
['s4', 's5', 's6']
>>> l.pop(0)
's4'
>>> l
['s5', 's6']
>>> l.pop(0)
's5'
>>> l
['s6']
>>> l.pop(0)
's6'
>>> l
[] # 3. 用列表模拟堆栈
# 堆栈特点:先进后出、后进先出
# 用列表insert、pop方法模拟进栈出栈:
>>> l = []
>>> l.insert(0,'a1')
>>> l.insert(0,'a2')
>>> l.insert(0,'a3')
>>> l
['a3', 'a2', 'a1']
>>> l.pop()
'a1'
>>> l
['a3', 'a2']
>>> l.pop()
'a2'
>>> l
['a3']
>>> l.pop()
'a3'
>>> l
[] # 用列表append、pop方法模式进栈出栈:
>>> l = []
>>> l.append('a1')
>>> l.append('a2')
>>> l.append('a3')
>>> l
['a1', 'a2', 'a3']
>>> l.pop()
'a3'
>>> l
['a1', 'a2']
>>> l.pop()
'a2'
>>> l
['a1']
>>> l.pop()
'a1'
>>> l
[] # 4. 有如下列表,请按照年龄排序(涉及到匿名函数)
l=[
{'name':'alex','age':84},
{'name':'oldboy','age':73},
{'name':'egon','age':18},
]
# 答案:
l.sort(key=lambda item:item['age'])
print(l)

练习

  • 六、元组
# 元组:可以理解为,不可变的列表
# 1.元组的长度不可以变化
# 2.元组中的值可以变化,但是变化其实是存放了可变的数据类型,元组本质没有改变
#作用:存多个值,对比列表来说,元组不可变(是可以当做字典的key的),主要是用来读

#定义:与列表类型比,只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55)) #优先掌握的操作:
#1、按索引取值(正向取+反向取):只能取
#2、切片(顾头不顾尾,步长)
#3、长度
#4、成员运算in和not in
#5、循环
# 一、定义
t1 = (1, 2, 3, 4, 5)
print(t1) # (1, 2, 3, 4, 5) t2 = tuple((1, 2, 3, 4, 5))
print(t2) # (1, 2, 3, 4, 5) # 空元组
t3 = ()
print(t3) #() t4 = tuple()
print(t4) # () # 含义一个值的元组
t5 = (1, )
print(t5) # 元组取值
t7 = (5, 3, 2, 1, 6)
print(t7[0])
print(t7[-1])
# 不可改变: 但一个列表需要对其进行限制,让其无法发生改变,可以将其转化为元组
list1 = [1, 2, 3]
tuple1 = tuple(list1)
print(tuple1) # (1, 2, 3)
# 如果重新想更改,可以转化回去
list2 = list(tuple1)
print(list2) # [1, 2, 3] # 注:元组中存放了可变类型数据,可以发生形式上的值改变,本质值未发生改变
t1 = (1, 'abc', [10, 'xyz'])
print(t1, id(t1))
>(1, 'abc', [10, 'xyz']) 41766776 # 成立:元组中列表值发生改变,列表自身id不变,所以元组中的中未发生改变
t1[2][1] = 'XYZ'
print(t1, id(t1))
>(1, 'abc', [10, 'XYZ']) 41766776
总结:
1. 可以存放多个值:t = (1, 2, 3)
2. 为不可变类型
3. 有序存储:按索引取值

练习:

#简单购物车,要求如下:
# 实现打印商品详细信息,用户输入商品名和购买个数,则将商品名,价格,购买个数加入购物列表,如果输入为空或其他非法输入则要求用户重新输入   msg_dic={
'appale':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
} shop_cart=[] while True:
for item, value in msg_dic.items():
print(item, value)
#print('name:{name} price:{price}'.format(price=item,name=key))
product_name = input('please input product name:').strip()
if not product_name or product_name not in msg_dic:continue
count = input('please input amount:').strip()
if not count.isdigit():continue
shop_cart.append((product_name,msg_dic[product_name],count))
print(shop_cart)
#break

练习

  • 七、字典
# 一、声明
dic1 = {'name': 'Owen', 'age': 18}
dic1 = {'name': None, 'age': None}
print(dic1)
>{'name': None, 'age': None} dic2 = dict([('name', 'Egon'), ('age', 58)])
print(dic2)
>{'name': 'Egon', 'age': 58} dic3 = dict(name='Zero', age=18)
print(dic3)
>{'name': 'Zero', 'age': 18} dic4 = {}.fromkeys(['name', 'age'], None)
print(dic4)
>{'name': None, 'age': None} # 二、get:有默认值的取值
dic = {'name': 'Owen', 'age': 18}
print(dic.get('name', "该key不存在")) # 存在就会打印实际的值
>Owen
print(dic.get('name123', "该key不存在")) # 不存在,未规定默认值,打印None,规定就打印规定的默认值
>该key不存在 # 三、字典的key可以为唯一不可变类型,value可以为任意类型
# 原因:字典的key是取值的唯一途径,所以一定要保证唯一性(一旦确定值,就不会再更改)
d1 = {}.fromkeys([1, 3.14, (1,), '', True], None)
print(d1)
>{1: None, 3.14: None, (1,): None, '': None} # 四、增删改查
dic = {'name': 'Hou', 'age': 3}
print(dic)
# 增
dic['gender'] = '哇塞'
print(dic)
# 删
del dic['age']
print(dic)
# 改
dic['name'] = 'DaHou'
print(dic)
# 查
print(dic['name']) #字典的循环
# 多值更新
dic = {'name': 'Engo', 'salary': 100}
dic.update({'name': "Egon", 'age': 58, 'gender': '未知'})
print(dic) # 类列表类型,不能直接通过index取值,但可以被for循环迭代取值
print(dic.keys())
print(dic.values())
print(dic.items()) for k in dic.keys():
print(k, ":", dic[k])
print('------------------------------------')
for v in dic.values():
print(v) print('------------------------------------')
for k, v in dic.items(): # *****
print(k, v) a, b, c = [1, 2, 3]
print(c)
a, b, _ = (1, 2, 3)
print(a) # 嵌套: JSON
dic = {
'students': [
{
'name': 'Bob',
'id': 1,
'gender': '男'
},
{
'name': 'Tom',
'id': 2,
'gender': '女'
}
],
'teachers': []
} stus = dic['students'] # list
tom_stu = stus[1] # dic
name = tom_stu['name']
print(name)
print(dic['students'][1]['name'])
print('======================')
for k, v in dic.items():
# 只遍历学生
if k == 'students':
for stu in v:
for s_k, s_v in stu.items():
print(s_k, ":", s_v)
print('--------------')
if k == 'teachers':
pass

字典循环

# 总结:
# 1. 字典可以存放多个值
# 2. 字典为可变类型
# 3. 字典是无序存储,用key进行取值
练习1

# 1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中

# 即: {'k1': 大于66的所有值, 'k2': 小于66的所有值}

a={'k1':[],'k2':[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
if i>66:
a['k1'].append(i)
else:
a['k2'].append(i)
print(a)

# 2 统计s='hello alex alex say hello sb sb'中每个单词的个数
#结果如:{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2} s='hello alex alex say hello sb sb'
s1 = s.split()
dic = {} for i in s1:
if i in dic:
dic[i] += 1
else:
dic[i]=1
print(dic)

练习2

s='hello alex alex say hello sb sb'
dic={}
words=s.split()
print(words)
for word in words: #word='alex'
dic[word]=s.count(word)
print(dic) #利用setdefault解决重复赋值
'''
setdefault的功能
1:key存在,则不赋值,key不存在则设置默认值
2:key存在,返回的是key对应的已有的值,key不存在,返回的则是要设置的默认值
d={}
print(d.setdefault('a',1)) #返回1 d={'a':2222}
print(d.setdefault('a',1)) #返回2222
'''
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
for word in words: #word='alex'
dic.setdefault(word,s.count(word))
print(dic) #利用集合,去掉重复,减少循环次数
s='hello alex alex say hello sb sb'
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
dic[word]=s.count(word)
print(dic) 其他做法(重点看setdefault的用法)

练习2的其他解法

  •  八、集合
#作用:去重,关系运算,

#定义:
知识点回顾
可变类型是不可hash类型
不可变类型是可hash类型 #定义集合:
集合:可以包含多个元素,用逗号分割,
集合的元素遵循三个原则:
1:每个元素必须是不可变类型(可hash,可作为字典的key)
2:没有重复的元素
3:无序 注意集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值 #优先掌握的操作:
#1、长度len
#2、成员运算in和not in #3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集:>,>=
#9、子集:<,<=
# 有如下两个集合,pythons是报名python课程的学员名字集合,linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
# 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 求出所有报名的学生名字集合
print(pythons | linuxs)
# 求出只报名python课程的学员名字
print(pythons - linuxs)
# 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)

练习

作业

#作业一: 三级菜单
#要求:
打印省、市、县三级菜单
可返回上一级
可随时退出程序
menue = {
'湖北省':{
'黄冈市':{
'罗田县':{
'大别山':'板栗',
'薄刀峰':'风景区',
'錾字石村':'柿子',
},
'錾字石':{
'杨梅冲':'渡桥',
'夏家铺':'水库',
'雷家塆':'道观',
},
},
'黄梅':{},
'黄石':{},
},
'上海市':{
'徐汇区':{
'徐家汇':{
'徐家汇': '美罗城',
'漕河泾': '开发区',
'华山路': '交通大学',
},
'浦东区':{
'陆家嘴':'金融区',
'淮海中路':'酒吧',
'人民广场':'南京东路步行街',
},
},
},
'山东省':{
'青岛市':{
'崂山区':{
'风景':'崂山风景区',
'道观':'崂山太清宫',
'海边':'海边浴场',
},
},
},
} tag = True
while tag:
for key in menue:
print(key)
choice = input("请输入省份,退出输入q>>").strip()
if choice == "q": break
if not choice or choice not in menue:continue #二级菜单
while tag:
menue2 = menue[choice]
for key2 in menue2:
print(key2)
choice_2 = input("请输入市,退出输入q,返回上级菜单输入b>>").strip()
if choice_2 == "b":
# print("返回上一层")
break
if choice_2 == "q":
tag = False
#continue
if choice_2 not in menue2:continue #三级菜单
while tag:
menue3 =menue2[choice_2]
for key3 in menue3:
print(key3)
choice_3 = input("请输入县,退出输入q,返回上级菜单输入b>>").strip()
if choice_3 == "b":
# print("返回上一层")
break
if choice_3 == "q":
tag = False
if not choice_3 or choice_3 not in menue3:continue #四级详细菜单
while tag:
menue4 = menue3[choice_3]
for key4,value in menue4.items():
print(key4,value)
choice_4 = input("请看列出风景,退出输入q,返回上级菜单输入b>>").strip()
if choice_4 == "b":
break
if choice_4 == "q":
tag = False
if not choice_4 or choice_4 not in menue4: continue

作业一

# 作业一优化答案

#part1(初步实现):能够一层一层进入
layers = [menue, ] while True:
current_layer = layers[-1]
for key in current_layer:
print(key) choice = input('>>: ').strip() if choice not in current_layer: continue layers.append(current_layer[choice])
#part2(改进):加上退出机制
layers=[menue,] while True:
if len(layers) == 0: break
current_layer=layers[-1]
for key in current_layer:
print(key) choice=input('>>: ').strip() if choice == 'b':
layers.pop(-1)
continue
if choice == 'q':break if choice not in current_layer:continue layers.append(current_layer[choice])

作业一改进

  •  九、数据类型总结

按存储空间的占用分(从低到高)

数字
字符串
集合:无序,即无序存索引相关信息
元组:有序,需要存索引相关信息,不可变
列表:有序,需要存索引相关信息,可变,需要处理数据的增删改
字典:无序,需要存key与value映射的相关信息,可变,需要处理数据的增删改

按存值个数区分:

标量/原子类型 数字,字符串
容器类型 列表,元组,字典

按可变不可变区分:

可变 列表,字典
不可变 数字,字符串,元组

按访问顺序区分:

直接访问 数字
顺序访问(序列类型) 字符串,列表,元组
key值访问(映射类型) 字典
# 1.统计元组中所有数据属于字符串串的个数,提示:isinstance()
# 数据:t1 = (1, 2, '3', '4', 5, '6')
# 结果:3
# 2.将以下数据存储为字典类型
# 数据:info = "name:Owen|age:18|gender:男"
# 结果:{'name': 'Owen', 'age': 18, 'gender': '男'}
# 注:年年龄存储为数字类型
# 3.完成数据的去重
# 数据:t3 = (1, 2, 1, 2, 3, 5, 9)
# 结果:t3 = (1, 2, 3, 5, 9)
# 注:从不不考虑顺序、考虑顺序两⽅方⾯面完成
# 4.计算元组中所有可以转换为数字的数据的总和
# 数据:t4 = (10, 'abc', '100', '3')
# 运算结果:113
# 5.将数据转换类型存储
# 原数据:dic = {'name': 'Owen', 'age': 18, 'gender': '男'}
# 处理理后:info = [('name', 'Owen'), ('age', 18), ('gender', '男')]
# 拓拓展:选做
# 1.计算元组中所有可以转换为数字的数据的总和
# 数据:t4 = (10, 'abc', '100', '3', '壹', '肆', [1000], (10000,))
# 运算结果:11118
# 提示:
# -- 利利⽤用字符串串isnumeric()判断汉字
# -- 利利⽤用字典{'壹': 1 ...}将汉字转换为数字
# -- 利利⽤用isinstance()将list和tuple中数据取出来
# -- 先将所有转化为数字的数据存放在⼀一个单列列集合中,在做运算
# 2.完成录⼊入电话本
# 需求:
'''
-- 从键盘中录⼊入姓名(不不区分⼤大⼩小写):
-- 姓名必须是全英⽂文组成,不不是则重新录⼊入姓名,如果是q,代表退出
-- 从键盘中再录⼊入电话:
-- 电话必须为数字且⻓长度必须是11位(不不能转换为数字)
-- 如果出现姓名相同,则保留留最后⼀一次电话号码
-- 形成的数据是有电话分组的,如:第⼀一次录⼊入Owen,13355667788,则会形成
-- {
'O': {
'Owen': '13355667788'
}
}
最终数据,分组名⼀一定⼤大写:
{
'E': {
'egon': '17788990000',
'engo': '16633445566'
},
'O': {
'Owen': '13355667788'
}
}

作业2

# 作业3:
#需求:
用户名和密码存放于文件中,格式为:egon|egon123
启动程序后,先登录,登录成功则让用户输入工资,然后打印商品列表,失败则重新登录,超过三次则退出程序
允许用户根据商品编号购买商品
用户选择商品后,检测余额是否够,够就直接扣款,不够就提醒
可随时退出,退出时,打印已购买商品和余额

python入门day02数据类型的更多相关文章

  1. Python 入门之数据类型之间的相互转换 以及 在编程中会遇到的数据类型的坑

    Python 入门之数据类型之间的相互转换 以及 在编程中会遇到的数据类型的坑 1.数据类型总结: 可变,不可变,有序,无序 (1)可变的数据类型:list dict set (2)不可变的数据类型: ...

  2. python入门之数据类型及内置方法

    目录 一.题记 二.整形int 2.1 用途 2.2 定义方式 2.3 常用方法 2.3.1 进制之间的转换 2.3.2 数据类型转换 3 类型总结 三.浮点型float 3.1 用途 3.2 定义方 ...

  3. python入门之数据类型之列表、元组、字典

    list 格式: test_list = ["a",123,[1,"b"]] 索引: >>>print(test_list[0]) " ...

  4. python入门之数据类型之字符串

    str方法 name.capitalize() 将name的首字母大写 name.center(20,'*') 将name居中,长度变为20,其余用*填充 name.count('chy') 返回na ...

  5. python入门(8)数据类型和变量

    python入门(8)数据类型和变量 数据类型 在Python中,能够直接处理的数据类型有以下几种: 整数 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样 ...

  6. Python入门学习:1.变量和简单的数据类型

    python入门学习:1.变量和简单的数据类型 关键点:变量.字符串.数字 1.1 变量的命名和使用1.2 字符串1.3 数字1.4 注释 1.1 变量的命名和使用   变量,顾名思义是一个可变的量, ...

  7. Python 入门之基本数据类型

    为什么我要学习Python这门语言呢?其实很简单,我想拓展技术面的同时,尝试更多的方向,可能最后会不了了之,谁知道呢?有可能的话,我会向爬虫和数据分析这个方向走.所以也就开始了我的Python学习之旅 ...

  8. Python入门 常量 注释 基础数据类型 用户输入 流程控制

    Python入门 一.常量 在Python中,不像其他语言有绝对的常量,修改会报错,在Python中有个约定俗成的规定--常量就是将变量名大写. 尽量保持不更改的一种量 , 这个常量有是干什么的呢 其 ...

  9. Python入门篇-封装与解构和高级数据类型集合(set)和字典(dict)

    Python入门篇-封装与解构和高级数据类型集合(set)和字典(dict) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.封装和结构 #!/usr/bin/env pytho ...

随机推荐

  1. hadoop生态圈介绍

    原文地址:大数据技术Hadoop入门理论系列之一----hadoop生态圈介绍   1. hadoop 生态概况 Hadoop是一个由Apache基金会所开发的分布式系统基础架构. 用户可以在不了解分 ...

  2. 【GoLang】golang 面向对象编程 &amp; 面向接口编程

    005.面向对象&接口编程 1 面向函数编程 1.1 将数据作为参数传递到函数入参 1.2 对象与函数是分离的 2 面向对象编程 2.1 使用者看起来函数作为对象的属性而非参数 2.2 函数属 ...

  3. FW:: ehcache memcache redis 三大缓存男高音

    最近项目组有用到这三个缓存,去各自的官方看了下,觉得还真的各有千秋!今天特意归纳下各个缓存的优缺点,仅供参考!  Ehcache 在java项目广泛的使用.它是一个开源的.设计于提高在数据从RDBMS ...

  4. TableView--通讯录--开篇

    一,需求图:

  5. [UWP小白日记-3]记账项目-1

    学了一段时间的UWP,来个项目试试手. 本来是想边做边学MVVMLight的结果感觉MVVM对于萌新来说太高难,以后再把这个项目改造成MVVMLight框架的项目. 下面进入正题. 中间那快空白打算放 ...

  6. delphi 中COPY()函数的意思

    Trim(copy(m,11,5)):copy里面的3个参数(m,11,5)分别是什么意思?COPY还有其他的参数吗? m :就是copy源,就是一个字符串,表示你将要从m里copy一些东西11 : ...

  7. PL/SQL Developer

    下载 一.Oracle 客户端(两种) 1.免安装轻量版(以这个为例) https://www.oracle.com/technetwork/database/database-technologie ...

  8. PHP中call user func()和call_user_func_array()调用自定义函数小结

    call_user_func() 和 call_user_func_array(),通过传入字符串函数,可以调用自定义函数,并且支持引用,都允许用户调用自定义函数并传入一定的参数: 1.mixed c ...

  9. Java中模拟POST上传文件

    /** * * @param url 请求URL * @param filePath 本地文件地址 * @return */ public static String upload(String ur ...

  10. 网站漏洞扫描并自动化工具-XAttacker

    注:该脚本根据网站的cms类型来扫描,所以推荐用来扫外国的站 运行脚本 ┌─[root@sch01ar]─[/sch01ar/XAttacker] └──╼ #perl XAttacker.pl 询问 ...