python第二次作业

一.list和tuple的区别

list中的元素可以改变，也可以对list进行增删操作，如在list末尾增加元素、在list中插入元素、删除某个元素。

tuple，也叫元组，可以简单的理解为不可变的列表（list）。一旦定义后，tuple中的元素不能再被改变，也不能增删。

如果tuple中的list改变了，tuple会发生改变，不过这并不是tuple中的元素变了，因为tuple中存的是list的引用，也可以理解为地址。令list中内容改变的两个操作均不改变list的地址，因此也就没有改变tuple中的元素。

二.学到的序列有哪几种

字符串string  字节bytes   元组tuple  列表list

三list中所有方法的使用

1.append(self, object, /) 

 Append object to the end of the list.

将对象追加到列表的末尾。直接将元素追加到列表

eg:   list_data = list('123')

list_data.append(52)

print(list_data)

2.clear(self, /) 

Remove all items from list.  从列表中删除所有项目。

eg:  list_data = list('123')

list_data.append(52)

print(list_data)

list_data.clear()

print(list_data)

3.copy(self, /) 

Return a shallow copy of the list. 返回列表的浅层副本。

4.count(self, value, /)

 Return number of occurrences of value.  返回值的出现次数。

list_data = [1, 1, 2, 4]

list_data.count(1)

print(list_data.count(1))

5.extend(self, iterable, /)

Extend list by appending elements from the iterable.  通过从可迭代对象追加元素来扩展列表。

6.index(self, value, start=0, stop=9223372036854775807, /) 

Return first index of value. | 返回值的第一个索引。 |

Raises ValueError if the value is not present.如果值不存在，则报错。

name_list = ["zhangsan", "lisi", "wangwu"]

print(name_list[2])

print(name_list.index("zhangsan"))

7.insert(self, index, object, /) 

Insert object before index. 在指定的位置插入值

list_data = [1, 2, 4]

list_data.insert(2, 3)

print(list_data)

8.pop(self, index=-1, /) 弹出

Remove and return item at index (default last).

删除并返回索引处的项目（默认在后面）。 Raises IndexError if list is empty or index is out of range.

list_data2 = [1, 2, 3]

list_data2.pop(1)

print(list_data2)

9.remove(self, value, /) 

 Remove first occurrence of value. | 删除第一个出现的值。

Raises ValueError if the value is not present. 如果值不存在，则会报错

list_data2 = [1, 2, 1]

list_data2.remove(1)

print(list_data2)

10.reverse(self, /) 

Reverse IN PLACE. 倒置

list_data2 = [1, 3, 2]

list_data2.reverse()

print(list_data2)

11.sort(self, /, *, key=None, reverse=False) 

Sort the list in ascending order and return None. |按升序对列表进行排序，并返回 None。

num_list  = ["banana", "durian", "pineapple","cherry", "strawberry", "kiwifruit", "peach", "grape"]

 num_list.sort() # 升序排序，如果是字符，按照首字母顺序

num_list.sort(reverse=True) # 降序排列

这里面key指的是排序的规则（可以自己定义规则）

四.将元组和列表转换成字典

五.dict中所有方法的使用

clea方法：删除字典中的所有项目(清空字典)

dict_var = {'Name': 'Haha', 'Addr': 'Mars'}
dict_var.clear()

copy方法：返回一个字典的拷贝，也即返回一个具有相同键值对的新字典

dict_data = {'老大': '15岁', '老二': '14岁', '老三': '2岁'}
print(dict_data.items())
for key, values in dict_data.items():
    print(key + '已经' + values + '了')

​​get(self, key, default=None, /)

 Return the value for key if key is in the dictionary, else default. 如果 key 在字典中，则返回 key 的值，否则返回默认值。

如果输入的key 在dict中，会返回其对应的key值，否则会返回一个定义的参数d

dict = {'1':'one','2':'two','3':'three'}
return_var = dict.get('2', 0)
print(return_var)
return_var = dict.get('4', 0)

print(return_var)
return_var = dict.get('4', 'false')

print(return_var)

items(...)函数以列表返回可遍历的(键, 值) 元组数组。

 D.items() -> a set-like object providing a view on D's items D.items（） ->一个类似集合的对象，提供 D 项的视图

 keys(...)

 D.keys() -> a set-like object providing a view on D's keys  D.keys（） ->一个类似集合的对象，提供 D 键的视图

dict = {'姓名': '张三', '年龄': '20'}
print(dict.items())
for key,values in dict.items():
    print(key, values)
dict.items()这个函数的返回值是列表套着元组，元组里面是该字典的键和值。（其实最好呢是加上一个list内置函数。）从这个方法遍历的时候会打印出key和value的值。

pop和 popitem (...)

pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对，它们的语法格式如下：

dictname.pop(key)
dictname.popitem()

其中，dictname 表示字典名称，key 表示键。
D.pop(k[,d]) -> v, remove specified key and return the corresponding value. 删除指定的键并返回相应的值。

a = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}

print(a)a.pop('化学')

print(a)a.popitem()

print(a)

运行结果：

{'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98}

setdefault() 方法

setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：

dictname.setdefault(key, defaultvalue)
1
说明，dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，不写的话是 None）。

当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。

也就是说，setdefault() 方法总能返回指定 key 对应的 value：

如果该 key 存在，那么直接返回该 key 对应的 value；
如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。

dict_var = {'数学': 95, '语文': 89, '英语': 90}
print(dict_var)
#key不存在，指定默认值
dict_var.setdefault('物理', 94)
print(dict_var)
#key不存在，不指定默认值
dict_var.setdefault('化学')
print(dict_var)
#key存在，指定默认值
dict_var.setdefault('数学', 100)
print(dict_var)

update() 方法 

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。

在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

dict_var = {'one': 1, 'two': 2, 'three': 3}
dict_var.update({'one': 4.5, 'four': 9.3})
print(dict_var)

values(...)  获取当前字典中所有键值对中的值(value)

 D.values() -> an object providing a view on D's values  一个对象，提供 D 值的视图

dict_data = {'id':1,'name':'ipad','price':2200,'count':50}
keys = list(dict_data.keys())
values = list(dict_data.values())
print(keys)
print(values)

六.list或dict浅拷贝画图加代码解释

 

a = 1
b = 1
c = b
print(id(1))
print(id(a))
print(id(b))
print(id(c))

此时所有的id都相等，

a = {1: [1, 2, 3]}
c = a.copy()

print(id(a))
# print(id(b))
print(id(c))
print(id(a[1]))
print(id(c[1]))

输出的结果为：

2308344400064
2308344210560
2308343581184
2308343581184

由这段代码可以得出list_data1和list_data2两个列表是完全独立的两个列表，但他们的子对象还是指向统一对象（是引用），列表外层改变时另一个也改变