python基础--元组，字典介绍（六）

# range() 是一个函数，可以用来生成一个自然数的序列
r = range(5)
#r = range(10)
# 该函数需要三个参数，
# 	起始位置
# 	结束位置
# 	步长
r = range(10,4,-2)
r = range(1,9,3)
print(list(r))

# 通过range()可以创建一个执行指定次数的for循环
# for循环的使用除了创建方式不同on，其余都和while一样
# 包括if-elif-else,break,continue在for循环中都可以使用
# 相对来说for使用比while更加简单
for  i in range(1,10,2):
	print(i)
for i in range(10):
	print(i)

# 元组 tuple,元组是一个不可变的序列，操作方式基本和列表一致
# 如果希望在使用过程中不改变数据，就使用元组
# 元组的创建
my_tuple = ()
my_tuple = (1,2,3,4,5)
# 查看元组类型
print(my_tuple,type(my_tuple))
print(my_tuple[1])

# 元组不为空时，括号可以省略不写
my_tuple = 10,20,30,40
# 注意，如果不为空，元组中必须至少包含一个,
# my_tuple = 40,


# 元组的解包
a,b,c,d = my_tuple
print('a=',a)
print('b=',b)
print('c=',c)
print('d=',d)

# 交互a 和 b的值，就可以使用元组的解包
a = 100
b = 200
print(f'a={a},b={b}')
a,b = b,a
print(f'a={a},b={b}')

# 在对一个元组进行解包是，变量的数量和元组中的数量必须一致
# 可以在变量前添加*号，表示将获取元组中剩余的元素
a,b,*c = my_tuple # 此处a,b分别匹配的是元组中的第一个和第二个数据
print(f'a={a},b={b},c=  {c}')
a,*b,c = my_tuple # 此处a,c匹配的是元组中第一个和最后一个数据
print(f'a={a},b={b},c={c}')
*a,b,c = my_tuple # 此处b,c匹配的是元组中最后两个数据
print(f'a={a},b={b},c={c}')

# 在列表中也是相同的匹配方式
*a,b,c = [1,2,3,4,5,6,8,7,9]
print(f'a={a},b={b},c={c}')

a,*b,c = 'hello world'
print(f'a={a},b={b},c={c}')

# 注意包含*的变量只能有一个




# 可变对象
#   
a = [1,2,3]
print(a,id(a))

# 通过索引司改列表
a[0] = 10
print(a,id(a))

# 给a重新赋值，新创建一个对象
a = [4,5,6]
print(a,id(a))

b = a
b[0] = 1
print(a,id(a))
print(b,id(b))




# == 和 ！=  is 和 is not
# == , != 比较的是对象的值是否相等
# is,is not 比较的是对象的id是否相等
a = [1,2,3]
b = [1,2,3]
print(a == b)
print(a is b)




# 字典dict
#  新的数据结构，称为映射
#  字典的作用和列表相似，都市用来存储对象的容器
#  列表存储数据的性能很好，但是查询数据的性能很差
#  在字典中每一个元素都有唯一的名称，通过这个唯一的名字可以快速定位指定的元素
#  查询元素时字典的效率很快
#  在字典中可以保存多个对象，每个对象都会有一个唯一的名字
#		字典中唯一的名称就是key，可以通过这个key快速查找对应的value
#		字典中的对象就是value
#		字典就是以键值对的结构存在，每个字典中可以保存多个键值对。

# 字典的创建
d = {}
print(d,type(d))

# 字典中的key是唯一的，如果有多个相同的key存在，最新的key会将之前的key对应的value值覆盖
# 语法{key:value}
# 字典中的值可以是任意的对象
# 字典的键是任意的不可变对象，正常使用str
d = {'name':'jason',
'age':12,
'gender':'male',
'name':'jack',
'address':['city1','city2'],
'ismarry':False}
print(d)

# 需要使用键来获取对应的值
# 如果键在字典中不存在则会报错
print(d['name'])
# print(d['a'])

# 使用dict()函数来创建字典,键都会字符串
d = dict(name='jason',age=14,gender='男')
print(d)

# 也可以将一个包含双值子序列转换为字典
# 双值序列中只能包含两个值，表示键值对
# 如果序列中的元素也是序列，这个元素就是子序列
d = dict([['name','aa'],['age',12]])
d = dict([('name','bb'),('age',15)])
print(d)

# len()获取字典中键值对的数量
print(len(d))

# in 检查字典中是否包含指定的键
print('name' in d)
print('hello' in d)

# 获取字典中的值
print(d['name'])

# 使用d['key']来获取字典中的值，如果键不存在则会报错
#  get(key) 也可以获取字典中的值。
#  如果键不存在则会返回None,
#  也可以通过添加参数，设置获取不到值时的返回默认值
print(d.get('name'))
print(d.get('hello'))
print(d.get('hello','default'))

# d[key] = value,如果字典中key存在则会覆盖原有的值，不存在就会添加会新的键值对
d['name'] = 'FF'
d['hight'] = 180
print(d)

# setdefault(key,value) 也可以用来给字典添加值
# 如果添加的键在字典中已经存在则不会进行操作，并返回当前值
# 如果不存在则添加这个键值对
result = d.setdefault('name','adas')
result = d.setdefault('hello','adas')
print(result)
print(d)

# update()将其他字典中的键值对添加到当前字典中
# 如果有重复的键，就会替换为最新的
d1 = {'name':'LL','weight':150}
d.update(d1)
print(d)

# del删除字典中的键值对，删除不存在的Key会报错
del d['weight']
del d['hello']
print(d)

# popitem() 随机删除字典中的一个键值对，一般是删除最后一个，并会返回删除的键值对
result = d.popitem()
print(result)

# pop(key[,defalut]) 删除字典中的键值对
#   根据key删除字典中的键值对
#   如果key存在直接删除并返回删除的value，如果key不存在则会报错
#   可以在pop()中指定默认值，删除不存在的key就不会报错，将会返回默认的值
result = d.pop('name')
#result = d.pop('hello')
result = d.pop('hello','hello')
print(result)

# clear()清空字典中的数据
#d.clear()
#print(d)

# copy() 对字典的浅copy
# 复制后的对象和原对象是独立的，不会相互影响
# 浅copy只会简单复制对象内部的值，如果这个值也是一个可变对象，这个可变对象不会被复制
d = {'a':1,'b':2,'c':3}
d1 = d.copy()
d['a'] = 11
print(d,id(d))
print(d1,id(d1))


d = {'a':{'d':4},'b':['aa','dd'],'c':3}
d1 = d.copy()
d['a']['d'] = 44
d['b'][0] = 'aaa'
print(d,id(d))
print(d1,id(d1))

# 字典的遍历
# keys() 返回字典的所有key
for key in d.keys():
	print(key)

# values() 返回字典中所有的value
for val in d.values():
	print(val)

# items() 返回字典中所有的键值对
# 返回的是一个序列，序列包含了双值子序列
print(d.items())
for k,v in d.items():
	print(k,' = ',v)