1.遍历
# 通过for循环来遍历列表
# 语法：
# for 变量 in 序列 :
# 代码块
2.range()
# range()是一个函数，可以用来生成一个自然数的序列
# 这里的range()函数所返回的对象在python3中并不是源list类型的，也不继承list类型。
# python3中的range()等于python2中的xrange()，它其实是百一个生度成器，每次取值后生成下一个值，目的是节约内存知和运算资源。
# 如果想得到list，则需强制道转换。
# r = range(5) # 生成一个这样的序列[0,1,2,3,4]
# print(list(r))
# r = range(0,10,2)
# print(list(r)) [0, 2, 4, 6, 8]
# r = range(10,0,-1)
# print(list(r)) [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
# r = range(10,0,-2)
# print(list(r)) [10, 8, 6, 4, 2]
# 该函数需要三个参数
# 1.起始位置（可以省略，默认是0）
# 2.结束位置
# 3.步长（可以省略，默认是1）
# 通过range()可以创建一个执行指定次数的for循环
# for()循环除了创建方式以外，其余的都和while一样，
# 包括else、包括break continue都可以在for循环中使用
# 并且for循环使用也更加简单
# 将之前使用while循环做的练习，再使用for循环完成一次！
# for i in range(30):
# print(i)
# for s in 'hello':
# print(s)
3.元组
# 元组 tuple
# 元组是一个不可变的序列
# 它的操作的方式基本上和列表是一致的
# 所以你在操作元组时，就把元组当成是一个不可变的列表就ok了
# 一般当我们希望数据不改变时，就使用元组，其余情况都使用列表
# 创建元组
# 使用()来创建元组
# my_tuple = () # 创建了一个空元组 ()
# print(my_tuple,type(my_tuple)) # <class 'tuple'>
# my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组 (1, 2, 3, 4, 5)
# 元组是不可变对象，不能尝试为元组中的元素重新赋值
# my_tuple[3] = 10 TypeError: 'tuple' object does not support item assignment
# print(my_tuple[3])
# 当元组不是空元组时，括号可以省略
# 如果元组不是空元组，它里边至少要有一个,
# my_tuple = 10,20,30,40 (10, 20, 30, 40)
# my_tuple = 40, (40,)
# my_tuple = 10 , 20 , 30 , 40
# 元组的解包（解构）
# 解包指就是将元组当中每一个元素都赋值给一个变量
# a,b,c,d = my_tuple
# print("a =",a) a = 10
# print("b =",b) b = 20
# print("c =",c) c = 30
# print("d =",d) d = 40
# a = 100
# b = 300
# 交互a 和 b的值，这时我们就可以利用元组的解包
# a , b = b , a
# print(a , b) 300 100
# my_tuple = 10 , 20 , 30 , 40
# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
# a , b , *c = my_tuple 10 20 [30, 40]
# a , *b , c = my_tuple 10 [20, 30] 20
# *a , b , c = my_tuple [10, 20] 30 40
# a , b , *c = [1,2,3,4,5,6,7] 1 2 [3, 4, 5, 6, 7]
# a , b , *c = 'hello world'
# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple SyntaxError: two starred expressions in assignment
# print('a =',a) a = h
# print('b =',b) b = e
# print('c =',c) c = ['l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
# 只要是序列就行
4.字典（属于一种新的数据结构，称为映射）
# 使用 {} 来创建字典
d = {} # 创建了一个空字典
# 创建一个保护有数据的字典
# 语法：
# {key:value,key:value,key:value}
# 字典的值可以是任意对象
# 字典的键可以是任意的不可变对象（int、str、bool、tuple ...），但是一般我们都会使用str
# 字典的键是不能重复的，如果出现重复的后边的会替换到前边的
# d = {'name':'孙悟空' , 'age':18 , 'gender':'男' , 'name':'sunwukong'}
d = {
'name':'孙悟空' ,
'age':18 ,
'gender':'男' ,
'name':'sunwukong'
}
# print(d , type(d)) {'name': 'sunwukong', 'age': 18, 'gender': '男'} <class 'dict'>
# 需要根据键来获取值
# print(d['name'],d['age'],d['gender']) sunwukong 18 男
# 如果使用了字典中不存在的键，会报错
# print(d['hello']) KeyError: 'hello'
5.字典操作
# 创建字典
# 使用{}
# 语法：{k1:v1,k2:v2,k3:v3}
# 使用 dict()函数来创建字典
# 每一个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
# d = dict(name='孙悟空',age=18,gender='男') {'name': '孙悟空', 'age': 18, 'gender': '男'} 要注意的是这个会给key加上引号
# 也可以将一个包含有双值子序列的序列转换为字典
# 双值序列，序列中只有两个值，[1,2] ('a',3) 'ab'
# 子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列
# [(1,2),(3,5)]
# d = dict([('name','孙悟饭'),('age',18)]) {'name': '孙悟饭', 'age': 18}
# d = dict((['name','孙悟饭'],['age',18])) {'name': '孙悟饭', 'age': 18}
d = dict(name='孙悟空',age=18,gender='男')
# len() 获取字典中键值对的个数
# print(len(d)) 3
# in 检查字典中是否包含指定的键
# not in 检查字典中是否不包含指定的键 注意是键名
# print('hello' in d)
# 获取字典中的值，根据键来获取值
# 语法：d[key]
# print(d['age']) 18
# n = 'name'
# print(d[n]) 孙悟空
# 通过[]来获取值时，如果键不存在，会抛出异常 KeyError
# get(key[, default]) 该方法用来根据键来获取字典中的值
# 如果获取的键在字典中不存在，会返回None
# 也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值
# print(d.get('name')) 孙悟空
# print(d.get('hello','默认值')) 默认值
# print(d.get('hello')) None
# 修改字典
# d[key] = value 如果key存在则覆盖，不存在则添加
# d['name'] = 'sunwukong' # 修改字典的key-value
# d['address'] = '花果山' # 向字典中添加key-value
# setdefault(key[, default]) 可以用来向字典中添加key-value
# 如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
# 如果key不存在，则向字典中添加这个key，并设置value
# result = d.setdefault('name','猪八戒') result = 孙悟空 {'name': '孙悟空', 'age': 18, 'gender': '男'}
# result = d.setdefault('hello','猪八戒') result = 猪八戒 {'name': '孙悟空', 'age': 18, 'gender': '男', 'hello': '猪八戒'}
# print('result =',result)
# print(d)
# update([other])
# 将其他的字典中的key-value添加到当前字典中
# 如果有重复的key，则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
# d2 = {'d':4,'e':5,'f':6, 'a':7}
# d.update(d2)
# print(d) #{'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
# print(d.update(d2)) None
# 删除，可以使用 del 来删除字典中的 key-value
# del d['a']
# del d['b']
# popitem()
# 随机删除字典中的一个键值对，一般都会删除最后一个键值对
# 删除之后，它会将删除的key-value作为返回值返回
# 返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
# 当使用popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty'
# d.popitem()
# print(d) {'a': 1, 'b': 2}
# print(d.popitem()) ('c', 3)
# pop(key[, default])
# 根据key删除字典中的key-value
# 会将被删除的value返回！
# 如果删除不存在的key，会抛出异常
# 如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
# result = d.pop('c') 3
# result = d.pop('z','这是默认值') 这是默认值
# del d['z'] z不存在，报错
# result = d.popitem()
# result = d.popitem()
# result = d.popitem()
# result = d.popitem() 报错
# clear()用来清空字典
# d.clear() {}
# copy()
# 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
d = {'a':1,'b':2,'c':3}
d2 = d.copy()
print(d2)
d['a'] = 100
d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2 = d.copy() {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2['a']['name'] = '猪八戒'
print('d = ',d , id(d)) d = {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3} 17612504
print('d2 = ',d2 , id(d2)) d2 = {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3} 17611544
6.遍历字典
# d = {'name':'孙悟空','age':18,'gender':'男'}
# keys() 该方法会返回字典的所有的key
# 该方法会返回一个序列，序列中保存有字典的所有的键
# # print(d.keys()) dict_keys(['name', 'age', 'gender'])
# print(type(d.keys())) #<class 'dict_keys'>
# 通过遍历keys()来获取所有的键
# for k in d.keys() :
# print(k , d[k])
# values()
# 该方法会返回一个序列，序列中保存有字典的左右的值
# for v in d.values():
# print(v) 孙悟空 18 男
# print(d.values()) dict_values(['孙悟空', 18, '男'])
# items()
# 该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
# 双值分别是，字典中的key和value
# print(d.items())
# for k,v in d.items() :
# print(k , '=' , v) name = 孙悟空 age = 18 gender = 男
# print(d.items()) dict_items([('name', '孙悟空'), ('age', 18), ('gender', '男')])
327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
