Python第二周Round2-其他数据类型，列表，元祖，字典

这周太忙了，决算审计整天加班，上级公司年末检查，在加上家中赵女士需要参加考试，真的是没有时间，现在腾出空来，把这周学的知识总结一下。

先谈下感受把，学习真的是一件很辛苦的事，在年轻的时候感觉力量是无穷的，没啥事，干就是了，但是现在感觉有点怂x了，谈什么坚持啊，有时间睡个觉多美滋滋啊~不过python语言还是很友好的，目前还是动力十足的，加油。

---

一、列表list

列表数据类型是一种基本的数据类型，用于存储多个数据，属于可迭代的对象，且可以修改，如li=[11,"小果果",33]

（一）列表的基本操作有下：

• 1.索引，用[n]表示，在前面有过叙述，表示列表中某个位置的元素是啥；
• 2.切片，用[n,n+j]表示；
• 3.相加，add
• 4.删除，del
• 5.长度，len
• 6.循环，for i in li：
• 7.包含，

（二）列表的其他需要注意的地方

1.通过使用list函数可以将字符串转换为一个序列。(注意：list函数适用于所有类型的序列，而不只是字符串)；

2.列表可以使用所有适用于序列的标准操作，如索引、分片、连接和乘法；

（三）基本方法

1.append()

li = [11, 22, 33, "小果果是个笨蛋"]
li.append("，你认为对不对？")
print(li)  # 输出 [11, 22, 33, '小果果是个笨蛋', '，你认为对不对？']

　　

根据输出的结果，以后规定，字符串用单引号' '来表示，虽然用双引号也没有错误，但是要养成良好的习惯，不是吗？

2.count() 

用于统计某个元素在列表中出现的次数

# 字符串的count()函数，我怎么记得没有记呢，是不是老年痴呆来？
li = "小果果是个笨蛋"
print(li.count("果"))  # 输出 2

# 列表的count()函数，
li = [11, 22, 33, "小果果是个笨蛋"]
print(li.count(11))  # 输出 1

　　

3.extend() 

可以在列表末尾一次性追加另一个序列中的多个值，和连接操作不同，extend方法是修改了被扩展的序列(调用extend方法的序列)，而原始的连接操作返回的是一个全新的列表

# 1.语法 L.extend(iterable)‘interable 可迭代对象’;
# 2.该方法没有返回值，但会在原来的列表末尾追加可迭代对象中的元素,例子中，c的输出值为'None'；
# 3.把要拓展的list放到前面，括号里面为添加的数据
a = ['小果果是一只狗', '棕色的', '卷毛的']
b = ['乖巧的', '母的', '没有起床气的']
d = a + b
print(a)  # 输出 ['小果果是一只狗', '棕色的', '卷毛的'] 表明a列表没有被改变，d为一个全新的序列
c = a.extend(b)  # 输出 None
print(a)  # 输出 ['小果果是一只狗', '棕色的', '卷毛的', '乖巧的', '母的', '没有起床气的']

　　

重点：对于append()方法和extend()方法的区别

(1).append()方法是将要添加的对象看作一个整体加到添加对象的末尾，可以是一个int，啥都可以（因为任何数据类型都可以添加到list当中）

(2).extend()方法必须是添加可迭代对象，interable的数据，如果添加int类型，bool类型，对不起，报错。且添加的是对象中的每一个可迭代对象。

4.index()用于从列表中找出某个值第一个匹配项的索引位置

 输出的是int类型

5.insert()

# 1.语法：L.insert(index, object) -- insert object before index
# 2.作为一个整体插入
a = ['小果果是一只狗', '棕色的', '卷毛的']
b = [11, 22, 33, 44]
a.insert(2, b)
print(a) #输出 ['小果果是一只狗', '棕色的', [11, 22, 33, 44], '卷毛的']

　　

6.pop()

移除列表中的一个元素(默认是最后一个)，并且返回该元素的值。通过pop方法可以实现一种常见的数据结构——栈（LIFO，后进先出）。

# 1.语法  L.pop([index]) -> item -- remove and return item at index (default last)；
# 2.超出index的值会报错返回。
a = ['小果果是一只狗', '棕色的', '卷毛的']
a.pop(2)
print(a)  # 输出 ['小果果是一只狗', '棕色的']

　　

其实就是一个定点删除的功能，无切片删除功能。

6.remove()

移除列表中某个值的第一个匹配项

# 1.语法 L.remove(value) -> None -- remove first occurrence of value.
# 2.返回值为None，也就是说无数据返回，直接对list进行了修改，同extend等，列表很多都是这样的，毕竟是可以修改的数据类型，需要记住！
# 3.无数据时，报错返回！
a = ['小果果是一只狗', '棕色的', '卷毛的']
a.remove('棕色的')
print(a)  # 输出 ['小果果是一只狗', '卷毛的']

　　

7.reverse()

将列表中的元素反向存放

# 1.语法 L.reverse() -- reverse *IN PLACE*
a = ['小果果是一只狗', '棕色的', '卷毛的']
a.reverse()
print(a)  # 输出 ['卷毛的', '棕色的', '小果果是一只狗']

　　

8.sort()

对列表进行排序。注意：sort函数时没有返回值的(None),它作用于源list。可以通过sorted函数来获取已排序的列表副本。

# 1.L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
# 2.key-- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# reverse-- 可选参数，是否反向排序，默认为False。
# 3.新函数: sorted() 可对所有可迭代的对象进行排序，返回list数据。
a = ['小果果是一只狗', '棕色的', '卷毛的']
a.sort()
print(a)  # 输出 ['卷毛的', '棕色的', '小果果是一只狗']
print(sorted('hello'))  # 输出 ['e', 'h', 'l', 'l', 'o']

　　

排序规则（list中）：

(1)int数据，默认是升序排列；

(2)str类型中的汉字排序问题：此问题很难，是个非常复杂的问题，后续学景气了，在回来解决，如果对中文排序的问题。（或许有模块，但是现在还没接触，暂且当作一个负责的问题看待）

问题2：函数和方法的区别，后续补充。

---

二、元祖

元组和列表最大的区别在于：元组不能修改。

（一）基本规则

创建元组很简单，只需要将元素用括号括起来，并使用逗号分隔符(即使只有一个元素)来分隔各个元素即可：

在tuple的末尾加个逗号','以示专业，没有任何区别，至于为什么，我也不知道，老炮儿说的。

a = ('阿', '吃', '拔', '阿大', '拔萝卜', '吃饭',)
print(type(a))  # 输出 <class 'tuple'>

　　

（二）基本用法

• 1.索引
• 2.切片
• 3.循环
• 4.长度
• 5.包含

（三）tuple的方法

就俩 count()和index()

---

三、字典

（一）基本规则

字典（dict）中的值没有特定顺序。

键可以是数字、字符串甚至是元组。键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

字典是无序的，每次输出，顺序都会随机发生变化

a = {1: '阿', 2: '吃', 3: '拔', 4: '阿大', 5: '拔萝卜', 6: '吃饭', }
print(type(a))  # 输出 <class 'dict'>

　　

（二）基本方法

• 1.索引
• 2.新增
• 3.删除
• 4.键、值、键值对
• 5.循环——说明也是可迭代对象
• 6.长度　

（三）其他方法

这里在ppycharm中调用使用手册时，出了个小插曲~

敲入 dict()，然后ctrl+单击时，并没有出现字典的方法

而敲入dict{}，然后就出现了~很奇怪，至于是为什么，暂时没有相通，后续学完这段课程整理时候，在回来做解释。

1.clear()

函数会清除字典中所有的项

# 语法 D.clear() -> None.  Remove all items from D
a = {1: '小果果', 2: '棕色的', 3: '卷毛的', }
a.clear()
print(a)  # 输出 {}

　　

2.copy()

函数会返回一个具有相同key-value对的新字典(浅复制)

# 语法 D.copy() -> a shallow copy of D
a = {1: '小果果', 2: '棕色的', 3: '卷毛的', }
b = a.copy()
print(b)  # 输出 {1: '小果果', 2: '棕色的', 3: '卷毛的'}

　　

这里又有一个小插曲，前面也讲到了在元祖的最后加一个逗号，其实，实践证明，在list/元祖/字典的最后加个逗号，都不会改变原来的值

3.fromkeys()

创建一个新字典，fromkeys(*args, **kwargs) 以*args中元素做字典的键，**kwargs为字典所有键对应的初始值

# 语法 Returns a new dict with keys from iterable and values equal to value
# fromkeys(*args, **kwargs)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的', }
b = 'aaaa'
new_a = dict.fromkeys(a)
new_b = dict.fromkeys(b, 2)
print(new_a, a)  # 输出 {1: None, 2: None, 3: None} {1: '小果果', 2: '棕色的', 3: '卷毛的'}
print(new_b, b)  # 输出 {'a': 2} aaaa

　　

需要注意的地方，在python的api文件中，*args和**kwargs是表示可以使用任何数据类型或者值，但是对于fromkeys方法，其实只有元祖和字典是有用的，用其他的，都没啥意思。

且此函数api中标注为  @staticmethod ，为静态方法，后续在细细探究，此地方留个疑问。

4.get()

可以访问字典中的项，如果不存在，返回一个None（或者自定义一个默认值）或者返回给定d的值

# 语法 D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None
# get(self, k, d=None)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的', }
s = a.get(5, '哈哈')
print(s)  # 输出 哈哈

　　

5.items()

循环获取key和value，返回的为列表数据。一般用于for语句迭代

# 语法 D.items() -> a set-like object providing a view on D's items
# items(self)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的', }
s = a.items()
print(s)  # 输出 dict_items([(1, '小果果'), (2, '棕色的'), (3, '卷毛的')])

　　

6.keys()

循环获取字典中所有key，一般用于for循环迭代。

# 语法 D.keys() -> a set-like object providing a view on D's keys
# keys(self)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的', }
s = a.keys()
print(s)  # 输出 dict_keys([1, 2, 3])

　　

7.pop()

删除指定的key，pop(self, k, d=None)  参数： k:待删除的key    d:指定参数，若k存在，则没吊用，如果k不存在，返回d的值

# 语法  D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
# If key is not found, d is returned if given, otherwise KeyError is raised
# pop(self, k, d=None)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的', }
a.pop(1)
print(a)  # 输出 {2: '棕色的', 3: '卷毛的'}

　　

8.popitem()

随机删除一个键值对

# 语法  D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty.
# popitem(self)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的'}
a.popitem()
print(a)  # 输出 {2: '棕色的', 3: '卷毛的'}

　　

9.setdefault()

给字典设置(增加)新的键，存在就不设置(获取当前key对应的值)，不存在就设置并返回当前key对应的值  setdefault(self, k, d=None) 参数：k:待设置(添加)的key 　　d:默认为空，可以指定value值

# 语法  D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
# setdefault(self, k, d=None)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的'}
a.setdefault(4, 'ss')
print(a)  # 输出 {1: '小果果', 2: '棕色的', 3: '卷毛的', 4: 'ss'}

　　

 10.update()

更新字典

# 语法  D.update([E, ]**F) -> None
# update(self, E=None, **F)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的'}
b = {3: '母的', 4: '没有起床气的', 5: None}
a.update(b)
print(a)  # 输出 {1: '小果果', 2: '棕色的', 3: '母的', 4: '没有起床气的', 5: None}

　　

几点需要主义的：

（1）如果E中的keys和D中的keys是重合的，把E中的元素覆盖到D中

（2）E只能是字典，试了试，用其他的数据类型不可以

（3）update()后，会根据keys的值，对字典进行排序

11.values()

将字典中的值以列表的形式返回，一般用于for循环，和keys()取得东西刚刚好相反。

# 语法  D.values() -> an object providing a view on D's values
# update(self, E=None, **F)
a = {1: '小果果', 2: '棕色的', 3: '卷毛的'}
print(a.values())  # 输出 dict_values(['小果果', '棕色的', '卷毛的'])