每日一课 | 小白必备基础对象练习

朱雀 2022-10-15 15:51 229阅读 0赞

![718e88b2cbefdefb275753337b0b4ae7.png][]

Python大本营每日一课

大家好，我是营长，上期营长分享了“小白必备基础语法练习”：，不清楚的小伙伴可戳这????[**小白必备基础语法练习**][Link 1]

本期营长将为大家分享如何快速入门Python开发。

这期分享营长邀请的是**zglg**（算法工程师）分享Python 全栈 450 道常见问题全解析。

**小白必备基础对象练习**

DAY01

####  ####

**list 内元素类型要求一致吗？**

**list 不要求元素类型一致，如下列表 lst 内元素类型有3种：**

lst = [1,'xiaoming',29.5,'17312662388']
    for _ in lst:
        print(f'{_}的类型为{type(_)}')

打印结果如下，列表 lst 内元素类型有3种：

1的类型为<class 'int'>
    xiaoming的类型为<class 'str'>
    29.5的类型为<class 'float'>
    17312662388的类型为<class 'str'>

#### **list 对象怎样实现增加、删除元素？** ####

使用 append 方法增加一个元素到列表最后：

lst2 = ['001','2019-11-11',['三文鱼','电烤箱']]
    sku = lst2[2] # sku又是一个列表
    sku.append('烤鸭')
    print(sku)

结果：\[‘三文鱼’, ‘电烤箱’, ‘烤鸭’\]

使用 insert 方法插入指定元素到指定索引处。

使用 remove 方法删除元素：

sku.remove('三文鱼')
    sku

结果：\[‘电烤箱’, ‘烤鸭’\]

pop 方法默认删除列表最后一个元素：

sku.pop()
    sku

结果：\[‘电烤箱’\]

**a 为 list, 使用 a\[:-1\] 返回哪些元素？**

使用 `a[:-1]` 获取到除最后一个元素的切片

#### **a 为 list, 使用 `a[1:5:2]` 返回哪些元素？** ####

使用 `a[1``:``5:2]` 生成索引 \[1,5) 且步长为 2 的切片

如 a 等于 \[1, 4, 7, 10, 13, 16, 19\]

返回的元素为：\[4,10\]

#### **a 为 list, 使用 `a[::-3]` 返回哪些元素？** ####

生成逆向索引 \[-1，-len(a))且步长为 3 的切片。

如 a 等于 \[1, 4, 7, 10, 13, 16, 19\]

返回的元素为：\[19,10,1\]

#### **如何去掉最值求平均？** ####

去掉列表中的一个最小值和一个最大值后，计算剩余元素的平均值。

def score_mean(lst):
        lst.sort()
        lst2=lst[1:-1]
        return round((sum(lst2)/len(lst2)),1)
    
    lst=[9.1, 9.0,8.1, 9.7, 19,8.2, 8.6,9.8]
    score_mean(lst) # 9.1

代码执行过程，动画演示：

**如何打印出 99 乘法表？**

for i in range(1,10):
        for j in range(1,i+1):
            print('%d*%d=%d'%(j,i,j*i),end='\t')
        print()

打印结果：

1*1=1
    1*2=2 2*2=4
    1*3=3 2*3=6 3*3=9
    1*4=4 2*4=8 3*4=12 4*4=16
    1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
    1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
    1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
    1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
    1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

#### 判断 list 内有无重复元素 ####

`is_duplicated`，使用 list 封装的 count 方法，依次判断每个元素 `x` 在 list 内的出现次数。

如果大于 1，则立即返回 `True`，表示有重复。

如果完成遍历后，函数没返回，表明 list 内没有重复元素，返回 False

def is_duplicated(lst):
        for x in lst:
            if lst.count(x) > 1:
                return True
        return False

调用 is\_duplicated 方法：

a = [1, -2, 3, 4, 1, 2]
    print(is_duplicated(a)) # True

以上方法实现不简洁，借助 set 判断更方便：

def is_duplicated(lst):
        return len(lst) != len(set(lst))

列表反转

一行代码实现列表反转，非常简洁。

\[::-1\]，这是切片的操作。

\[::-1\] 生成逆向索引（负号表示逆向），步长为 1 的切片。

所以，最后一个元素一直数到第一个元素。这样，不正好实现列表反转吗。

def reverse(lst):
        return lst[::-1]

调用 reverse:

r = reverse([1, -2, 3, 4, 1, 2])
    print(r)

结果：\[2, 1, 4, 3, -2, 1\]

#### **求表头** ####

返回列表的第一个元素

注意，列表为空时，返回 `None`

通过此例，学会使用`if` 和 `el``s``e`的这种简洁表达。

In [18]: def head(lst):
        ...: return lst[0] if len(lst) > 0 else None

调用`h``ea``d`:

In [19]: print(head([]))
        ...: print(head([3, 4, 1]))
    None
    3

** 求表尾**

求列表的最后一个元素，同样列表为空时，返回 `N``on``e`.

In [20]: def tail(lst):
        ...: return lst[-1] if len(lst) > 0 else None

调用 `tail`:

In [21]: print(tail([]))
        ...: print(tail([3, 4, 1]))
    None
    1

元素对

`t``[:-``1``]` , 原列表切掉最后一个元素；

`t``[1:]`, 原列表切掉第一个元素；

`zip(i``t``e``r1``,````i``t``e``r2``)`，实现 `iter1` 和 `i``t``e``r2` 的对应索引处的元素拼接。

In [32]: list(zip([1,2],[2,3]))
    Out[32]: [(1, 2), (2, 3)]

理解上面，元素组对的实现就不难理解：

In [28]: def pair(t):
        ...: return list(zip(t[:-1],t[1:]))

调用 pair:

In [29]: pair([1,2,3])
    Out[29]: [(1, 2), (2, 3)]
    
    In [30]: pair(range(10))
    Out[30]: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9)]

#### 一行代码生成 \[1, 3, 5, 7, 9, 11, 13, 15, 17, 19\] ####

使用列表生成式，创建列表，观察元素出现规律，可得出如下代码：

In [97]: a = [2*i+1 for i in range(10)]
    
    In [98]: a
    Out[98]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

写一个等差数列

产生一个首项为 10，公差为 12 ，末项不大于 100 的列表

使用列表生成式创建：

In [1]: a = list(range(10,100, 12))
    
    In [2]: a
    Out[2]: [10, 22, 34, 46, 58, 70, 82, 94]

#### 一行代码求 1到10000内整数和 ####

提供两种方法

使用 Python 内置函数 `s``um` 求和：

In [99]: s = sum(range(10000))
    
    In [100]: s
    Out[100]: 49995000

使用 functools 模块中的 reduce求和：

In [101]: s = reduce(lambda x,y: x+y, range(10000))
    
    In [102]: s
    Out[102]: 49995000

####  tuple 对象可以增加、删除元素吗？为什么？ ####

不能增加、删除元素，因为元组 tuple 是不可变对象，不可变的英文：immutable.

只有不可变对象才能作为字典的键，因此 \{\[\]:‘this is an expection’\} 会抛出异常。

#### **如何创建一个字典？** ####

使用一对花括号 `{}` 另使用冒号 `:`，创建一个 dict 对象

dic = {'a':1, 'b':3, 'c':5} # dict变量

**五种创建字典的方法**

1 手动创建

empty = {}
    dic = {'a':1,'c':3,'e':5}

2 使用 `di``ct``()` 构造函数

In [10]: dict(a=1,b=2,c=3)
    Out[10]: {'a': 1, 'b': 2, 'c': 3}

3 键值对+关键字参数

第一个参数为字典，后面是一系列关键字参数，如 c=3

In [9]: dict({'a':1,'b':2},c=3,d=4)
    Out[9]: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

**可迭代对象**

列表，元素又为一个元组，后面再加一系列关键字参数。

In [8]: dict([('a',1),('b',2)],c=3)
    Out[8]: {'a': 1, 'b': 2, 'c': 3}

5 fromkeys() 方法

已知键集合( keys )， values 为初始值：

In [7]: {}.fromkeys(['k1','k2','k3'],[1,2,3])
    Out[7]: {'k1': [1, 2, 3], 'k2': [1, 2, 3], 'k3': [1, 2, 3]}
    
    In [14]: {'a':1,'b':2}.fromkeys(['c','d'],[1,2])
    Out[14]: {'c': [1, 2], 'd': [1, 2]}

**下期预告：****小白必备基础对象练习（完结）**

以上内容均来自CSDN GitChat《Python 全栈 450 道常见问题全解析（配套教学）》，作者zglg， 某大厂算法工程师，识别二维码查看专栏更多详情。

**专栏限时特价**

**仅限5月4日-6月1日**

**仅需69元**

**识别二维码查看详情**

????????

![234048c228f097968b2ad55846e6ab0b.png][]

**点击阅读原文**

[718e88b2cbefdefb275753337b0b4ae7.png]: /images/20221014/ffd428dd5e1348c69b184c8382295b61.png
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzU5MjEwMTE2OQ%3D%3D&chksm=fe266cd4c951e5c21aa3403802ebf626299f575bc95206000fc3952f59df4861b21eb31367ad&idx=2&mid=2247501450&scene=21&sn=884e36aeb1df8b892cde5ed407593296#wechat_redirect
[234048c228f097968b2ad55846e6ab0b.png]: /images/20221014/6ee8335677374f59b8013aca86e1d6b9.png