python基础day07笔记

最新推荐文章于 2023-11-23 23:45:10 发布

CSDN时光

最新推荐文章于 2023-11-23 23:45:10 发布

阅读量984

点赞数 2

分类专栏： python基础20课时文章标签： python

本文链接：https://blog.csdn.net/qq_42584444/article/details/81057767

版权

python基础20课时专栏收录该内容

20 篇文章 12 订阅

订阅专栏

2018.7.10
day06回顾
列表：

是可变的序列
是容器
索引和切片操作，可以索引切片赋值

del语句
用于删除列表中的元素

del 列表[整数表达式]
del 列表[切表]

序列相关的函数

len(x) max(x) min(x) sum(x) any(x) all(x)

列表中的方法：

L.index(x)
L.insert(index,obj)
L.count(x)
L.remove(x)
L.copy() 浅拷贝
L.append(x)
L.extend(lst) #L+=lst
L.clear()
L.sort()
L.pop(索引)
L.reverse() 列表的反转
深拷贝deep copy，浅拷贝shallow copy

字符串的方法：

str.split() 分割
str.join() 连接

列表推导式
day 07笔记
元组tuple

元组是不可变的序列，同list一样，元组可以存放任意类型数据的容器

元组的表示方法：

用小括号()括起来，单个元素括起来后加逗号(,) 区分单个对象还是元组

创建空元组的字面值：

t = () 空元组

创建非空元组的字面值表示：

t = 200,
t = (20,)
t = (1,2,3)
t = 100,200,300

函数type（x）用来返回x对应的类型

元组的错误示例：

t = (20) #绑定20这个对象，不是元组
x, y, z = 100, 200, 300 # 序列赋值
x, y, z = (100, 200, 300) # 序列赋值
x, y, z = [100, 200, 300] # 序列赋值
x, y, z = "ABC" # 序列赋值

元组的构造(创建)函数 tuple
tuple（）生成一个空元组，等同于()
tuple(iterable),用可迭代对象生成一个元组

示例：

t = tuple() #等同于 t = ()
t = tuple(range(1,10,3)) #t = (1,4,7)
t = tuple('ABC') #t = ('A','B','C')
t = tuple([1,2,3]) #t = (1,2,3)

元组的运算：
算术运算:

+ += * *=

比较运算

< <= > >= == !=
in / not in 运算
索引[] 和切片[:]或[::]

+加号用于拼接元组
*用于生成重复的元组

元组的比较运算：

规则与列表的比较规则完全相同

in / not in 运算符

规则与列表的规则完全相同

索引和切片

索引取值和切片取值的规则与列表完全相同
元组不支持索引赋值和切片赋值（因为元组不可被改变）

元组的方法：

T.index(v[,begin[,end]]) 返回对应元素的索引下标
T.count(x) 返回元组中的元素个数

序列相关的函数：

len(x) max(x) min(x) sum(x) any(x) all(x)

构造函数：

str(x) 创建字符串
list(iterable) 创建列表
tuple(iterable) 创建元组

序列的相关函数：

reversed（可迭代对象）返回反向顺序的可迭代对象
sorted(iterable,key=None,reverse=false)

返回已排序的列表

示例：

t = (4, 8, 6, 2, 7)
L = [x for x in reversed(t)]
L = [7, 2, 6, 8, 4]  # 原来先后顺序的反向
for x in reversed(t):
    print(x)  #  打印: 7  2  6  8  4

L2 = sorted(t)  # L2 = [2, 4, 6, 7, 8]
L3 = sorted(t, reverse=True)  # L3 = [8, 7, 6, 4, 2]

容器小结：

字符串str （不可变序列，只能存字符）
列表 list （可变序列，可以存任意数据）
元组 tuple （不可变序列，可以存任意数据）

字典dict

字典是一种可变的容器，可以存储任意类型的数据，
字典中的每个数据都是用'键'(key) 进行索引，而不像序列可以用整数下标来进行索引
字典中数据没有先后关系，字典中的存储是无序的
字典中的数据以键(key)-值(value) 对形式进行映射存储
字典的键不能重复，且只能用”不可变类型”作为字典的键

字典的字面值表示方法：

字典的表示方式是以{} 括起来，以冒号（：）分隔键-值对, 各键-值对之间用逗号(,)分割开

创建空字典的字面值：

d = {} #d 绑定空字典

创建非空字典的字面值：

d = {name: 'wesdasd','age':35}
d = {1:'one',2:'two',3:'three'}
d = {1:[1,2,3],'abc':(1.1,1.2,1.3)}
d ={'a':{'b':200,'c':[1,2,3]}}
d = {(1970,1,1):'computer year'}

字典的构造函数dict

dict() 生成一个字的字典等同于{}
dict(iterable) 用可迭代对象初始化一个字典
dict(**kwargs) 用关键字传参形式创建一个字典

键是变量名规则

示例：

d = dict()
d = dict([('name','tarena'),['age','15']])
d = dict(name='tarena', age=15)

字典的键(key) 必须为不可变类型

bool,int,float,complex,str,tuple,frozenset,bytes(后面讲)

字典的值(value) 可以是任意类型

可变的数据类型有四种：

list 列表
dict 字典
set 集合
bytearray 字节数组

字典的基本操作：
字典的键索引

用[] 运算符可以获取字典内‘键’对应的值
也可以用[]运算符来修改‘键’对应的值

键索引的语法：
字典[键]
示例：
获取值：

d = {'name': 'tarena','age':35}
print(d['name'],'的年龄',d['age'])
# tarena 的年龄 35

添加修改字典的元素
语法：
字典[键]=值
说明：
键不存在时，创建键，并绑定对应的值
当键存在时，修改键绑定的值
示例：

d = {}
d['name'] = 'tarena' #创建新的键值对
d['age'] = 15
d['age'] = 16 #修改'age'所对应的值
d['age']+=1 #17,数值同样修改

删除字典元素
del 字典[键]
示例：

d = {'name': 'tarena','age':15}
del d['name']
print(d) #{'age': 35}

字典的成员资格判断 in 运算符
可以用 in 运算符判断一个键是否存在于字典中，如果'键'存在则返回True
否则返回false
not in 与 in 结果相反

示例：

d = {'name': 'tarena','age':15}
if 'name' in d:
print('name 在字典中')

print(15 in d)#False,只判断键，不判断值

练习：
1，写程序，实现以下要求：
将如下数据形成一个字典seasons：
'键' '值'
1 '春季有1,2,3月'
2 '春季有4,5,6月'
3 '春季有7,8,9月'
4 '春季有10,11,12月'

2，让用户输入一个整数，代表一个季度，打印这个季度对应的信息，
如果用户输入的信息不在字典内，则打印信息不存在

# 1) 将如下数据形成一个字典seasons:
seasons = {1: '春季有1, 2, 3月',
           2: '夏季有4, 5, 6月',
           3: '秋季有7, 8, 9月',
           4: '冬季有10,11,12月'
           }

# 2) 让用户输入一个整数，代表一个季度，打印这个季度对应的信息，如果用户输入的信息不在字典内，则打印信息不存在
n = int(input("请输入一个整数:"))
if n in seasons:
    print(seasons[n])
else:
    print("信息不存在")

字典的迭代访问
字典是可迭代对象，字典只能对键进行迭代访问
示例：
d = {'name': 'tarena','age':15}
for k in d:
print(k,'对应的值是：',d[k])

可以用于字典的内建函数

len(x) 返回字典的键值对个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典中所有键的和
any(x) 真值测试，只要有一个键为True，返回True
all(x) 真值测试，当全部键为真值是，返回True

示例：
d = {0:'零',5:'伍',8:'捌',3:'叁'}

print(len(d)) #4
print(max(d)) #8
print(min(d)) #0
print(sum(d)) #16
print(any(d)) #True
print(all(d)) #False

字典的方法
函数说明

D代表字典对象
D.clear() 清空字典
D.pop(key) 移除键，同时返回此键所对应的值
D.copy() 返回字典D的副本,只复制一层(浅拷贝)
D.update(D2) 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default) 返回键key所对应的值,如果没有此键，则返回default
D.keys() 返回可迭代的 dict_keys 集合对象
D.values() 返回可迭代的 dict_values 值对象
D.items() 返回可迭代的 dict_items 对象这个可以看下下面

D = {0:'零',5:'伍',8:'捌',3:'叁'}
for k,v in D.items():
    print(k,v)


#0 零
#8 捌
#3 叁
#5 伍


D = {0:'零',5:'伍',8:'捌',3:'叁'}
for v in D.items():
    print(v)


#(0, '零')
#(8, '捌')
#(3, '叁')
#(5, '伍')

练习：
输入一段字符串，打印出这个字符串中出现过的字符的出现次数
输入：
abcdabcaba
打印：
a：4次
b：3次
c：2次
d：1次
注：不要求打印顺序

s = input("请输入: ")  # abcdabcaba

# 创建一个字典用来保存字符的个数
d = {}
for ch in s:
    # 先判断这个字符以前是否出现过
    if ch not in d:  # 第一次出现
        d[ch] = 1  # 将次数设置为1
    else:  # 不是第一次出现
        d[ch] += 1

# 打印字符和出现过的次数
for k in d:
    print(k, ':', d[k], '次')

字典推导式：
字典推导式是用可迭代对象的创建字典的表达式
语法：

{键表达式：值表达式 for 变量 in 可迭代对象 if 真值表达式}

说明：
if子句可以省略
示例：
生成一个字典，键为数字（10以内），值为键的平方

d = {x:x**2 for x in range(10)}

练习：
有字符串的列表如下：
L = ['tarena','xiaozhang','tyke']
用上述列表生成如下字典：
d = {'tarena':6,'xiaozhang':9,'tyke':4}
注：字典的值为键的长度

L = ['tarena', 'xiaozhang', 'tyke']
# d = {}
# for s in L:
#     d[s] = len(s)

d = {s: len(s) for s in L}

print(d)

# d = {'tarena': 6, 'xiaozhang': 9, 'tyke':4}

字典 vs 列表

都是可变对象
索引方式不同，列表用整数索引，字典用键索引
字典的插入，删除，修改数据的速度可能会快于列表（重要）
列表的存储是有序的，字典的存储是无序的

练习：
1.已知有俩个等长的列表list1 和list2，以list1中的元素为键，
以list2中的元素为值，生成相应的字典
list1 = [1001,1002,1003,1004]
list2 = ['Tom','Jerry','Spike','Tyke']
生成的字典为：
{1001；'Tom',1002:'Jerry',...}

list1 = [1001, 1002, 1003, 1004]
list2 = ['Tom', 'Jerry', 'Spike', 'Tyke']

# 方法1
# d = {}
# for i in range(len(list1)):  # i代表索引
#     k = list1[i]
#     d[k] = list2[i]

# 方法2
d = {list1[i]: list2[i] for i in range(len(list1))}

print(d)

2.输入任意个学生的姓名，年龄，成绩，每个学生的信息存入字典中，然后放入至列表中，
每个学生的信息需要手动输入，当输入姓名为空时结束输入：
如：
请输入姓名：xiaozhang
请输入年龄：20
请输入成绩：100
请输入姓名：xiaoli
请输入年龄：18
请输入成绩：98
请输入姓名：<回车> 结束输入
要求内部储蓄格式如下：
[{'name':'xiaozhang','age':20,'score':100,
'name':'xiaoli','age':18,'score':98}]
打印所有学生的信息如下：

#如:
#     请输入姓名:  xiaozhang
#     请输入年龄:  20
#     请输入成绩:  100
#     请输入姓名:  xiaoli
#     请输入年龄:  18
#     请输入成绩:  98
#     请输入姓名:  <回车> 结束输入
#   要求内部存储格式如下:
#   [{'name':'xiaozhang', 'age':20, 'score':100}, 
#    {'name':'xiaoli', 'age':18, 'score':98}]
#   打印所有学生的信息如下:
#   +---------------+----------+----------+
#   |     name      |   age    |   score  |
#   +---------------+----------+----------+
#   |   xiaozhang   |    20    |   100    |
#   |     xiaoli    |    18    |    98    |
#   +---------------+----------+----------+

L = []  # 创建一个容器准备放入
while True:
    name = input('请输入姓名: ')
    if not name:  # 如果名字为空,结束输入操作
        break
    age = int(input("请输入年龄: "))
    score = int(input("请输入成绩: "))
    d = {}  # 每次都会执行{} 来创建新的字典
    d['name'] = name
    d['age'] = age
    d['score'] = score
    L.append(d)

print(L)

# 打印表格
print("+---------------+----------+----------+")
print("|     name      |   age    |   score  |")
print("+---------------+----------+----------+")
for d in L:
    n = d['name'].center(15)
    a = str(d['age']).center(10)
    s = str(d['score']).center(10)
    print("|%s|%s|%s|" % (n, a, s))

# print("|   xiaozhang   |    20    |   100    |")
# print("|     xiaoli    |    18    |    98    |")
print("+---------------+----------+----------+")

CSDN时光

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
python基础day07笔记

2018.7.10 day06回顾列表：是可变的序列是容器索引和切片操作，可以索引切片赋值 del语句用于删除列表中的元素 del 列表[整数表达式] del 列表[切表] 序列相关的函数 len(x) max(x) min(x) sum(x) any(x) all(x) 列表中的方法： ...
复制链接

扫一扫