元组 tuple
1.定义:元组是不可变的序列,同list一样,元组是可以存放任意类型的容器
2.元祖表示方法:
用小括号()括起来,单个元素括起来后加(,)区分单个对象还是元组
创建空元组的字面值:
t = () # t绑定空元组
创建非空元组
t = 200,
t = (20,)
t = (1,2,3)
t = 100,200,300
type(x) 函数用来返回x的类型
3.元组的错误示例:
t = (20) t 绑定整数,不是元组
x,y,z = 100,200,300 #序列赋值
x,y,z = (100,200,300) #序列赋值
x,y,z = [100,200,300] #序列赋值
4.元组的构造(创建)函数 tuple
tuple () 生成一个空的元组,等同于()
tuple (iterable) 用可迭代对象生成一个元组
示例:
t = tuple()
t = tuple([2,3,5,7])
t = tuple(range(10))
5.元组的运算:
+ 加号用于元组的拼接操作
* 乘号 用于用元组生成重复的元组
示例:
t = (1,2,3)+(4,5,6) t = (1,2,3,4,5,6)
t = (1,2) * 3 # t = (1,2,1,2,1,2)
t = (1,2,3)
t += (4,5,6) 等同于字符串规则
6.元组的比较运算:
> >= < <= == !=
规则与列表的比较规则完全相同:
(1,2,3) < (1,3,2) # True
(1,2,3) != (1,3,2) # True
7.in/ not in 运算符:
与列表运的in/not in 规则完全相同
2 in (1,2,3,4) # True
'2' not in (1,2,3,4) # True
8.索引和切片
索引: 元组 [整数]
切片:
元组[整数:整数]
元组[整数:整数:整数]
注意: 1.规则同字符转的切片规则
2.元组不支持索引和切片赋值
+----------------------------------------------------------------------------------------------------------------
|练习:
| 生成一个1-9的平方根的元组,元组如下:
| (1,4,9,16,....81)
+----------------------------------------------------------------------------------------------------------------
"""
t = ()
for i in range(1,10):
y = i ** 2
t += (y,)
i = (t)
print(t)
"""
l = x ** 2 for x in range(1,10)
t = tuple(l)
print(t)
----------------------------------------------------------------------------------------------------------------
9.元组的方法:
T.index(v[,begin(,end)]]) 返回对应元素的索引下标,begi为开始索引,end为结束索引,v不存在时触发valueError错误
T.count(x) 返回元组中的对应元素的个数
序列的种类:
字符串str 列表list 元组tuple 字节串bytes,字节数组bytearray(后面再讲)
能用于序列的函数:
len(x),max(x),min(x),sum(x),any(x),all(x)
str(abj) 将对象转换为字符串
list(iterable) 将可迭代对象转为列表
tuple(iterable) 将可迭代对象转为元组
reversed(seq) 返回反向顺序的可迭代对象
sorted(iterable,reverse = False)
============================================================================
字典 dict
1.字典是一种可变的容器,可以存储任意类型的数据
2.字典中的每个数据都是用'键'(key)进行索引,而不像序列可以用下标来进行索引,
3.字典中的数据没有先后顺序关系,字典的存储是无序的
4.字典中的数据以键(key)-值(value)的形式进行映射存储
5.字典的键不能重复,且只能用不可变类型作为字典的键
字典的字面表示方式:
{}括起来,以冒号(:)分隔键-值对 各键.值对用逗号分隔开
创建空字典:
d = {} #空字典
创建非空字典:
d = {'name':'tarena','age':'15'}
d = {1:"星期一",2:""}
注意:以下写法会出现问题(因为键不能重复)
d = {'a':1 ,'b':2,'a':'一'}
字典的构造(创建)函数:dict
dict() # 创建空字典等同于{}
dict(iterable) 用于可迭代对象初始化一个字典
dict(**kwargs) 关键字传参形式生成一个字典
示例:
d = dict()
d = dict([('name','tarena'),('tarena','15')])
d = dict(name='tarena',age='15')
字典的基本操作:
1.字典的键索引
用[]运算符可以获取和修改键所对应的值
语法: 字典 [键]
示例:
d = {'name':'tarena','age':'15'}
print('姓名:',d['name'],'年龄:',d['age'])
2.添加/修改字典的元素:
字典[键] = 值
示例:
d = {}
d['name'] = 'tarnea'
3.键索引赋值说明:
当键不存在时,创建键并绑定键对应的值
当键存在时,修改键绑定对象
4.删除字典的元素;
del 语句可以用来删除字典的键
语法: del 字典[键]
示例:
d = {1:"星期一",2:"星期二"}
del d[2]
print(d) >>>> {1:"星期一"}
5.in 运算符(成员资格判断运算符)
1.可以用in运算符来判断一个键是否存在于字典中,如果存在则返回True,否则返回False
2.not in 与 in相反:
示例:
d = {1:"one",2:"two",三:"three"}
1 in d >>> True
3 not in d >>> True
""one" in d >>> False
6.字典的迭代访问:
字典是可迭代对象,字典只能对键进行迭代访问
示例:d = {1:"one",2:"two",3:"three"}
for k in d:
print(k,"对应的值为",d[k])
------------------------------------------------------------------------------------------------------------------
练习:
写程序,实现以下功能:
1.将如下数据形成一个字典season
键 值
1 春季1,2,3月
2 夏季4,5,6月
3 秋季7,8,9月
4 冬季10,11,,12月
-------------------------------------------------------------------------------------------------------------------
season = {1:"",2:"",3:"",4:""}
a =int(input("请输入一个季节"))
if a in seasons:
print(seasons[a])
else:
print("信息不存在")
============================================================================
2.让用户输入一个整数代表季度,打印这个季度的信息,如果用户输入的信息不存在字典中,则提示'信息不存在'
可以用于字典的内建(built - in)函数:
len(x) 返回字典的键值对的个数
max(x) 返回字典的键的最大值i
min(x) 返回字典的键的最小值
sum(x) 返回字典的键的和
any(x) 真值测试,如果字典中的一个键为真,则结果为真
all(x) 真值测试,字典中所有键为真,则结果为真
字典的方法:
1.D.clear() 清空字典
2.D.pop(key) 移除键，同时返回此键所对应的值
3.D.copy() 返回字典D的副本,只复制一层(浅拷贝)
4.D.update(D2) 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
5.D.get(key, default) 返回键key所对应的值,如果没有此键，则返回default
6.D.keys() 返回可迭代的 dict_keys 集合对象
7.D.values() 返回可迭代的 dict_values 值对象
8.D.items() 返回可迭代的 dict_items 对象
示例:
d = {1:"one",2:"two",3:"three"}
for k,v in d.items:
print("字典的值是",k,"值是",v)
--------------------------------------------------------------------------------------------------------------------
练习:
输入一段字符串,打印出这个字符串中出现过的字符及字符出现过的次数:
如:输入abcdaanknb
输出:
a = 4次
b = 3次
d = 1次
c = 2次
--------------------------------------------------------------------------------------------------------------------
s = input("请输入一个字符串")
#方法一
#去重复
l = [] #此列表用于存放出现过的次数
for ch in s:
if ch not in l:
l.append(ch)
print(l)
for ch in l:
print(ch,":",s.count(ch),"次")
方法二:
d = {} #定义一个字典
for ch in s:
if ch not in d:
d[ch] = 1
else:
d[ch] += 1
For ch in d:
print(ch,":",d[ch],"次")
============================================================================
字典的推导式:
字典推导式是用可迭代的对象依次生成字典的表达式:
语法:
{键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注意:[]及其中的内容代表可省略
说明:
1.先从可迭代对象中取值
2.用变量绑定
3.用if 进行条件判断,如果为真值则执行下一步
4.执行 键表达式 和 值表达式 然后加入到新字典中
示例:
生成一个字典,键为1-9的整数,值为键的平方
d = {x : x ** 2 for x in range(1,10)}
练习:
有如下字符串:
L = ['tarena','China','beijing']
生成如下字典:
d = ['tarena':7,'China':6,'beijing':5]
-------------------------------------------------------------------------------------------------------------------
d = {chr : len(chr) for chr in ["tarena","china","beijing"]}
print(d)
-------------------------------------------------------------------------------------------------------------------
练习:
No = [1001,1002,1005,1008]
names = ['tom','Jerry','spike','tyke']
用上面No列表的数据作为键,用name中的数据做为止=值,生成相应的字典
d = {1001:'tom',.....}
------------------------------------------------------------------------------------------------------------------
No = [1001,1002,1005,1008]
names = ["Tom","jerry","spike","tyke"]
d = {No[x]:names[x] for x in range(len(No))}
print(d)
-----------------------------------------------------------------------------------------------------------------
No = [1001,1002,1005,1008]
names = ["Tom","jerry","spike","tyke"]
'''
方法一:
d = {No[x]:names[x] for x in range(len(No))}
print(d)
'''
方法二:
d = {number : names[No.index(number)] for number in No}
print(d)
字典推导式可以嵌套,语法同列表推导式
字典 vs 列表:
1.都是可变对象
2.索引方式不同,列表用整数索引,字典用用键索引
3.字典的查找速度可能会快于列表(重要)
4.列表的存储都是有序的,字典的存储都是无序
列表 和字典的内部存储原理:
列表 顺序存储
子弹 映射存储
1.输入一些单词和解释,将单词做为键,将解释作为值,将这些数据输入到字典中,当输入为空的单词的时候结束输入
然后,输入查询的单词,给出单词对应的解释
2.(重要)输入任意个学生的信息:
学生信息有:
姓名(字符串)
年龄(整数int)
成绩(整数int)
当输入学生姓名为空时结束输入
1.将每个人学生的信息形成字典,存于列表中:
如:[{'name': 'xiaoming','age':20,'score':97},{'name':'xiaoli','age':18,'score':95},....]
2.以表格的形式打印所有学生的信息如下:
+----------+--------+-----------+
| name | age | score |
+----------+--------+-----------+
| xiaoming | 20 | 97 |
+---------------------------------+
1.定义:元组是不可变的序列,同list一样,元组是可以存放任意类型的容器
2.元祖表示方法:
用小括号()括起来,单个元素括起来后加(,)区分单个对象还是元组
创建空元组的字面值:
t = () # t绑定空元组
创建非空元组
t = 200,
t = (20,)
t = (1,2,3)
t = 100,200,300
type(x) 函数用来返回x的类型
3.元组的错误示例:
t = (20) t 绑定整数,不是元组
x,y,z = 100,200,300 #序列赋值
x,y,z = (100,200,300) #序列赋值
x,y,z = [100,200,300] #序列赋值
4.元组的构造(创建)函数 tuple
tuple () 生成一个空的元组,等同于()
tuple (iterable) 用可迭代对象生成一个元组
示例:
t = tuple()
t = tuple([2,3,5,7])
t = tuple(range(10))
5.元组的运算:
+ 加号用于元组的拼接操作
* 乘号 用于用元组生成重复的元组
示例:
t = (1,2,3)+(4,5,6) t = (1,2,3,4,5,6)
t = (1,2) * 3 # t = (1,2,1,2,1,2)
t = (1,2,3)
t += (4,5,6) 等同于字符串规则
6.元组的比较运算:
> >= < <= == !=
规则与列表的比较规则完全相同:
(1,2,3) < (1,3,2) # True
(1,2,3) != (1,3,2) # True
7.in/ not in 运算符:
与列表运的in/not in 规则完全相同
2 in (1,2,3,4) # True
'2' not in (1,2,3,4) # True
8.索引和切片
索引: 元组 [整数]
切片:
元组[整数:整数]
元组[整数:整数:整数]
注意: 1.规则同字符转的切片规则
2.元组不支持索引和切片赋值
+----------------------------------------------------------------------------------------------------------------
|练习:
| 生成一个1-9的平方根的元组,元组如下:
| (1,4,9,16,....81)
+----------------------------------------------------------------------------------------------------------------
"""
t = ()
for i in range(1,10):
y = i ** 2
t += (y,)
i = (t)
print(t)
"""
l = x ** 2 for x in range(1,10)
t = tuple(l)
print(t)
----------------------------------------------------------------------------------------------------------------
9.元组的方法:
T.index(v[,begin(,end)]]) 返回对应元素的索引下标,begi为开始索引,end为结束索引,v不存在时触发valueError错误
T.count(x) 返回元组中的对应元素的个数
序列的种类:
字符串str 列表list 元组tuple 字节串bytes,字节数组bytearray(后面再讲)
能用于序列的函数:
len(x),max(x),min(x),sum(x),any(x),all(x)
str(abj) 将对象转换为字符串
list(iterable) 将可迭代对象转为列表
tuple(iterable) 将可迭代对象转为元组
reversed(seq) 返回反向顺序的可迭代对象
sorted(iterable,reverse = False)
============================================================================
字典 dict
1.字典是一种可变的容器,可以存储任意类型的数据
2.字典中的每个数据都是用'键'(key)进行索引,而不像序列可以用下标来进行索引,
3.字典中的数据没有先后顺序关系,字典的存储是无序的
4.字典中的数据以键(key)-值(value)的形式进行映射存储
5.字典的键不能重复,且只能用不可变类型作为字典的键
字典的字面表示方式:
{}括起来,以冒号(:)分隔键-值对 各键.值对用逗号分隔开
创建空字典:
d = {} #空字典
创建非空字典:
d = {'name':'tarena','age':'15'}
d = {1:"星期一",2:""}
注意:以下写法会出现问题(因为键不能重复)
d = {'a':1 ,'b':2,'a':'一'}
字典的构造(创建)函数:dict
dict() # 创建空字典等同于{}
dict(iterable) 用于可迭代对象初始化一个字典
dict(**kwargs) 关键字传参形式生成一个字典
示例:
d = dict()
d = dict([('name','tarena'),('tarena','15')])
d = dict(name='tarena',age='15')
字典的基本操作:
1.字典的键索引
用[]运算符可以获取和修改键所对应的值
语法: 字典 [键]
示例:
d = {'name':'tarena','age':'15'}
print('姓名:',d['name'],'年龄:',d['age'])
2.添加/修改字典的元素:
字典[键] = 值
示例:
d = {}
d['name'] = 'tarnea'
3.键索引赋值说明:
当键不存在时,创建键并绑定键对应的值
当键存在时,修改键绑定对象
4.删除字典的元素;
del 语句可以用来删除字典的键
语法: del 字典[键]
示例:
d = {1:"星期一",2:"星期二"}
del d[2]
print(d) >>>> {1:"星期一"}
5.in 运算符(成员资格判断运算符)
1.可以用in运算符来判断一个键是否存在于字典中,如果存在则返回True,否则返回False
2.not in 与 in相反:
示例:
d = {1:"one",2:"two",三:"three"}
1 in d >>> True
3 not in d >>> True
""one" in d >>> False
6.字典的迭代访问:
字典是可迭代对象,字典只能对键进行迭代访问
示例:d = {1:"one",2:"two",3:"three"}
for k in d:
print(k,"对应的值为",d[k])
------------------------------------------------------------------------------------------------------------------
练习:
写程序,实现以下功能:
1.将如下数据形成一个字典season
键 值
1 春季1,2,3月
2 夏季4,5,6月
3 秋季7,8,9月
4 冬季10,11,,12月
-------------------------------------------------------------------------------------------------------------------
season = {1:"",2:"",3:"",4:""}
a =int(input("请输入一个季节"))
if a in seasons:
print(seasons[a])
else:
print("信息不存在")
============================================================================
2.让用户输入一个整数代表季度,打印这个季度的信息,如果用户输入的信息不存在字典中,则提示'信息不存在'
可以用于字典的内建(built - in)函数:
len(x) 返回字典的键值对的个数
max(x) 返回字典的键的最大值i
min(x) 返回字典的键的最小值
sum(x) 返回字典的键的和
any(x) 真值测试,如果字典中的一个键为真,则结果为真
all(x) 真值测试,字典中所有键为真,则结果为真
字典的方法:
1.D.clear() 清空字典
2.D.pop(key) 移除键，同时返回此键所对应的值
3.D.copy() 返回字典D的副本,只复制一层(浅拷贝)
4.D.update(D2) 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
5.D.get(key, default) 返回键key所对应的值,如果没有此键，则返回default
6.D.keys() 返回可迭代的 dict_keys 集合对象
7.D.values() 返回可迭代的 dict_values 值对象
8.D.items() 返回可迭代的 dict_items 对象
示例:
d = {1:"one",2:"two",3:"three"}
for k,v in d.items:
print("字典的值是",k,"值是",v)
--------------------------------------------------------------------------------------------------------------------
练习:
输入一段字符串,打印出这个字符串中出现过的字符及字符出现过的次数:
如:输入abcdaanknb
输出:
a = 4次
b = 3次
d = 1次
c = 2次
--------------------------------------------------------------------------------------------------------------------
s = input("请输入一个字符串")
#方法一
#去重复
l = [] #此列表用于存放出现过的次数
for ch in s:
if ch not in l:
l.append(ch)
print(l)
for ch in l:
print(ch,":",s.count(ch),"次")
方法二:
d = {} #定义一个字典
for ch in s:
if ch not in d:
d[ch] = 1
else:
d[ch] += 1
For ch in d:
print(ch,":",d[ch],"次")
============================================================================
字典的推导式:
字典推导式是用可迭代的对象依次生成字典的表达式:
语法:
{键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注意:[]及其中的内容代表可省略
说明:
1.先从可迭代对象中取值
2.用变量绑定
3.用if 进行条件判断,如果为真值则执行下一步
4.执行 键表达式 和 值表达式 然后加入到新字典中
示例:
生成一个字典,键为1-9的整数,值为键的平方
d = {x : x ** 2 for x in range(1,10)}
练习:
有如下字符串:
L = ['tarena','China','beijing']
生成如下字典:
d = ['tarena':7,'China':6,'beijing':5]
-------------------------------------------------------------------------------------------------------------------
d = {chr : len(chr) for chr in ["tarena","china","beijing"]}
print(d)
-------------------------------------------------------------------------------------------------------------------
练习:
No = [1001,1002,1005,1008]
names = ['tom','Jerry','spike','tyke']
用上面No列表的数据作为键,用name中的数据做为止=值,生成相应的字典
d = {1001:'tom',.....}
------------------------------------------------------------------------------------------------------------------
No = [1001,1002,1005,1008]
names = ["Tom","jerry","spike","tyke"]
d = {No[x]:names[x] for x in range(len(No))}
print(d)
-----------------------------------------------------------------------------------------------------------------
No = [1001,1002,1005,1008]
names = ["Tom","jerry","spike","tyke"]
'''
方法一:
d = {No[x]:names[x] for x in range(len(No))}
print(d)
'''
方法二:
d = {number : names[No.index(number)] for number in No}
print(d)
字典推导式可以嵌套,语法同列表推导式
字典 vs 列表:
1.都是可变对象
2.索引方式不同,列表用整数索引,字典用用键索引
3.字典的查找速度可能会快于列表(重要)
4.列表的存储都是有序的,字典的存储都是无序
列表 和字典的内部存储原理:
列表 顺序存储
子弹 映射存储
1.输入一些单词和解释,将单词做为键,将解释作为值,将这些数据输入到字典中,当输入为空的单词的时候结束输入
然后,输入查询的单词,给出单词对应的解释
2.(重要)输入任意个学生的信息:
学生信息有:
姓名(字符串)
年龄(整数int)
成绩(整数int)
当输入学生姓名为空时结束输入
1.将每个人学生的信息形成字典,存于列表中:
如:[{'name': 'xiaoming','age':20,'score':97},{'name':'xiaoli','age':18,'score':95},....]
2.以表格的形式打印所有学生的信息如下:
+----------+--------+-----------+
| name | age | score |
+----------+--------+-----------+
| xiaoming | 20 | 97 |
+---------------------------------+