Day7-总结

1.列表赋值

a.直接使用一个列表变量给另一个列表变量赋值,赋的是地址。

赋完值之后,对其中一个列表进行增删改,会影响另一个表。

b.如果赋值的时候赋的列表的切脾或者拷贝,会产生新的地址,然后使用新的地址赋值。

赋完值之后,两个列表相相互之间不影响

list1 = [1,2,3]
list2 = list1[:]
list2.append(100)
print(list1)
print(list2)

2.列表中的方法

a.列表.count(元素) - 获取指定元素在列表中出现的次数

b.列表.extend(序列) - 将列表中所有的元素添加到列表中

c. 列表.index(元素) - 获取指定元素在列表中的下标

注意:
1.如果元素有多个,只取第一个的下标
2.如果这个元素不存在,会报错

d.列表.reverse() -反向列表(将列表元素倒序)

e.列表.sort() - 对列表进行升序排序(从小到大)

列表.sort(reverse = True) - 对列表进行降序排序(从大到小)
注意:列表的要求:
1.列表的元素类型必须一样
2.元素支持比较元算符

f.列表.clear() - 清空列表

注意:清空列表尽量用clear()

g.列表.copy() - 将列表中元素直接复制一份产生一个新的列表。和 列表[:] 效果一样

注意:这儿的拷贝是浅拷贝

numbers = [100,100,100,1,2,3]
print(numbers.count(100))
numbers.extend(['abc','hello'])
print(numbers)
numbers.extend('reus')
print(numbers)
numbers.reverse()
print(numbers)
numbers = [1,4, 7,2,5,8,9]
numbers.sort()
print(numbers)
numbers.sort(reverse=True)
print(numbers)
list1 = [1,2,3]
list2 = list1.copy()
print(list2)
print(list1 is list2)

3.深拷贝和浅拷贝

import copy

copy.copy(对象) - 浅拷贝 : 直接拷贝元素的值产生一个新的地址
copy.deepcopy(对象) - 深拷贝 : 不会直接复制地址,而是将地址对应的值拷贝一份产生新的地址

numbers1 = [1,2,3]
numbers2 = [10,20,30]
list1 = [numbers1,numbers2]
print('浅拷贝:')
list2 = list1.copy() # 浅拷贝
print('修改前list1:',list1)
print('修改前list2:',list2)
list1.append(111)
list1[0].append(100)
print('修改后list1:',list1)
print('修改后list2:',list2)
numbers1 = [1,2,3]
numbers2 = [10,20,30]
list1 = [numbers1,numbers2]
print('深拷贝:')
list2 = copy.deepcopy(list1)
print('修改前list1:',list1)
print('修改前list2:',list2)
list1.append(88)
list1[0].append(99)
print('修改后list1:',list1)
print('修改后list2:',list2)

1.什么事元祖(tuple)

元祖就是不可变的列表。(有序,不可变)
有序 - 可以通过下标获取元素
不可变 - 不支持增删改

2.元祖的字面量:通过小括号将多个元素括起来,多个元素之间用逗号隔开

注意:
a.只有一个元素的元祖:元素后面必须加逗号
b.直接将多个数据用逗号隔开,不用括号括起来,还是元祖
c.获取元祖元素:
1.下标
2.可以通过变量个数和元祖个数保持一致来获取元祖中的每个元素
3.通过在变量名前加* , 获取没有*的变量获取到的元素的剩下部分,以列表形式返回

3.获取元祖的元素和获取列表元素一模一样

4. 相关运算和列表一样:+ , * ,in/not in , len() , tuple(), max() ,min()

5.元祖相关方法:只有列表中的count和index

tuple1 = (1,True,'abc',[1,2])
print(tuple1)

tuple2 = (10,)
print(tuple2)

tuple3 = 1,2,3,'abc'
print(tuple3,type(tuple3))

tuple4 =(10,20)
print(tuple4[0])
x,y =tuple4
print(x,y)

tuple5 = ('张程',98,90,99)
name , *scores = tuple5
print(name , scores)

了解

tuple6 = 1,2,3
print(*tuple6)

list1 = ['a','b','c']
print(*list1)

1.什么事字典(dict)

字典是python中内置的容器类的数据类型,可变,无序的。字典的元素是键值对

2.字典的字面量:使用大括号括起来,大括号里是键值对,多个键值对之间用逗号隔开.

键值对 - 键:值
键(key) - 不可变的;唯一的(列表和字典不能为key),一般使用字符串作为key
值(value) - 任何类型的数据

3.什么时候用字典:

如果一个容器里面存储的数据是不同意义的数据(数据之间需要区分),就使用字典

dict1 ={'aa':10,1:'abc',(19,20):'hello'}
# dict2 ={[1,2]:10,1:'abc',(19,20):'hello'}  # TypeError: unhashable type: 'list'
# dict3 ={'aa':1,'aa':2,'bb':3}   # {'aa': 2, 'bb': 3}
print(dict1)

# 用一个变量来存储一个学生的信息:姓名、年龄、电话、成绩、学号
student = {'name':'小明','age':28,'tel':13800000000,'score':30,'学号':123}
print(student['name'])

1.查(获取字典的值)

a.获取单个值

字典[key] — 获取字典中对应的值(注意:如果key不存在,会报错keyerror)
字典.get(key) - 获取字典中key对应的值(注意:如果key不存在,不会报错,并会返回一个默认值None)
None是python 中的关键值,表示一个特殊值(空,没有的意思)

dog1 = {'name':'旺财','age':3,'color':'黄色','type':'土狗'}
print(dog1['color'])
print(dog1.get('type'))
print(dog1.get('sex'))

b.遍历

# 直接遍历字典拿到的是字典中所有的key
for x in dog1:
    print(x,dog1[x])

# 同时获取key和value(看着方便但是性能差,内存消耗多)
for key,value in dog1.items():
    print(key,value)

2.增(添加键值对)

a.字典[key] = 值 - 当key不存在的时候,就是在字典中添加键值对

b.字典1.update(序列) - 将序列中的元素转换成键值对,然后再添加到字典1中

注意:
当key值有重名的时候,互用序列中键值对对应的值,更新字典的key对应的值在这儿的序列要求是能够转换成字典的序列。序列中的元素是只能有两个元素的小序列

dict1 = {'a':100}
dict1['b'] = 10
print(dict1)

dict1 = {'a': 100, 'b': 10}
dict1.update({'aa':10,'bb':100,'a':'abc'})
print(dict1)

3.改(修改key对应的值)

字典[key] = 值 - 当key存在的时候,就是修改key对应的值

4.删(删除键值对)

a.del 字典[key] - 删除字典中key对应的键值对

b.字典.pop(key)- 取出字典中key对应的值(删除整个键值对)

person = {'name':'张三','age':30,'sex':'男'}
del person['sex']
print(person)

person = {'name':'张三','age':30,'sex':'男'}
age = person.pop('age')
print(person,age)

# 随机删除一个键值对(取出键值对,以元祖的形式返回)
person = {'name':'张三','age':30,'sex':'男'}
value = person.popitem()
print(person,value)

1.字典不支持+ 和 *

2.in 和 not in

key in 字典 - 判断字典中是否存在指定的key

dict1 = {'a':12,'b':20,'c':30}
print('a' in dict1)

推荐阅读更多精彩内容