列表

添加元素

  • append() 只能添加一个元素

    1
    2
    3
    >>> a.append([1,2])
    >>> a
    [[1, 2]]

    一次添加多个元素会报错

    1
    2
    3
    4
    5
    >>> a.append([1,2],[3,4])
    Traceback (most recent call last):
      File "<pyshell#7>", line 1, in <module>
        a.append([1,2],[3,4])
    TypeError: append() takes exactly one argument (2 given)

  • extend() ：可以添加多个元素，元素可以是列表、字典字符串等，不能添加

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    >>> a.extend(1)
    Traceback (most recent call last):
      File "<pyshell#9>", line 1, in <module>
        a.extend(1)
    TypeError: 'int' object is not iterable
    >>> a.extend([1])
    >>> a
    [1]
    >>> a.extend({1})
    >>> a
    [1, 1]

  • 插入元素 insert（下标位置，插入的内容）

    1
    2
    3
    4
    5
    >>> a
    [0, 1, 2, 3, 4, 5, 6, 7, 8]
    >>> a.insert(0,"insert插入")
    >>> a
    ['insert插入', 0, 1, 2, 3, 4, 5, 6, 7, 8]

迭代

打开列表的帮助文档，我们可以看到这么一个

迭代器

迭代器：重复反馈过程的活动

删除元素

  • remove(元素)，注意：这里不是下标，而是元素内容
1
2
3
4
5
>>> a
['insert插入', 0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> a.remove("insert插入")
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8]

当然你也可以这样删除

1
2
3
4
5
>>> a
[0, 'insert', 2, 3, 4, 5, 6, 7, 8]
>>> a.remove(a[1])
>>> a
[0, 2, 3, 4, 5, 6, 7, 8]
  • del member[下标]，这里的 member 是列表的名字
1
2
3
4
5
6
>>> a
[1, 2, 3, 4, 5]
>>> del a[0]
>>> a
[2, 3, 4, 5]
>>>
  • member.pop() 不加参数的话就是删除后面的元素，加上角标后就是删除角标元素
1
2
3
4
5
6
7
8
9
10
11
12
>>> a = [0,1,2,3,4]
# 没填参数，删除末尾的4
>>> a.pop()
4
>>> a
[0, 1, 2, 3]

#填了角标参数，删除角标元素a[0]
>>> a.pop(0)
0
>>> a
[1, 2, 3]

列表运算

1
2
3
4
5
6
7
8
9
10
11
12
13
# 加法
>>> list1 = [1,2]
>>> list2 = [3,4]
>>> list3 = ["nihao"]
>>> list1 + list2
[1, 2, 3, 4]
>>> list1 + list3
[1, 2, 'nihao']

# 乘法
>>> list1 = [0,1,2,3,4]
>>> list1 * 3
[0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]

列表的其他用法

  • list.count(要找的元素) 返回要找的元素在 list 中出现的次数

  • list.index(123,范围起点,范围结束) 返回 123 元素所在的位置，默认第一个

  • list.reverse() 原地翻转列表

  • list.sort(func,key，reverse = False) 排序，默认归并排序，从小到大，会改变原来的 list

  • 复制一个列表 用 list = list[:]
    list = list1(这个是地址拷贝),就是多了一个指向它的标签
    如果是深拷贝的话就是 list = list[:]

  • zip 打包

    1
    2
    3
    4
    5
    >>> a
    [1, 2, 3, 4, 5]
    >>> b = [6,7,8,9,10]
    >>> list(zip(a,b))
    [(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]

  • sum(list) 求和

元组

类似带上了枷锁的列表，元组跟列表是近亲关系，所以用法相似

  • 区别：元组不能改变

就算加上了小括号他也不一定是元组

1
2
3
4
5
6
7
8
9
10
11
>>> temp = (1)
>>> temp
1
>>> type(temp)
<class 'int'>

>>> temp = (1,2)
>>> temp
(1, 2)
>>> type(temp)
<class 'tuple'>
1
2
3
4
5
>>> temp2 = 1,2,3
>>> temp2
(1, 2, 3)
>>> type(temp2)
<class 'tuple'>

所以逗号是元组的关键，小括号并不是关键

1
2
>>> temp = ()		#空元组
>>> temp = 1,		#默认创建元组
1
2
3
# 可以试试这个就知道了
>>> 8 * （8）
>>> 8 * （8，）

元组的插入

1
2
3
4
5
#插入
>>> temp = (0,1)
>>> temp = temp[:1] + ("2",) + temp[1:]
>>> temp 	# 更新完之后原来的(0,1)仍然在，只不过没有标签指向它了，所以py会过会把他回收掉
(0, '2', 1)

删除

1
2
>>> del temp
#删除整个元素

字符串

字符串的格式化

1
2
3
#位置参数
>>> "{0} love {1}".format("i","you")
'i love you'
1
2
3
#关键字参数
>>> "{a} love {b}".format(a = "i",b ="you")
'i love you'

如果想要混用，位置参数必须在关键字参数之前

1
2
3
4
5
>>> "{{0}}".format("0")
'{0}'

>>> "{0:.1f}{1}".format(32.666,"GB")
'32.7GB'

转义

1
2
3
4
>>> '%c' % 97
'a'
>>> '%c %c %c' % (97,98,99)
'a b c'

切片

切片顾名思义，就是切下来一片东西，比方说我要把[0,1,2,3,4]切成[1,2]，就是这样
切片的原则是 左闭右开，举几个栗子就好理解了
切片的写法是：要切的对象[左下标:右下标]
切片不会影响原来的对象的

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> a = [0,1,2,3,4]
>>> a[1:3]
[1, 2]
# 好好理解左闭右开

# 左下标不写的话默认0
>>> a[:1]
[0]
# 右下标默认不写的话就是取到元素末尾
>>> a[2:]
[2, 3, 4]
>>>

数及运算

Python 中的数分 整数，浮点数，和复数

整数

整数取整是直接截断小数部分，这样效率更高，而不是四舍五入

1
2
3
>>> a = 5.99
>>> print(int(a))
5

浮点数

浮点数符合 IEEE754 的标准

1
2
>>> 0.1 + 0.2
0.30000000000000004

为了精准计算，引入 import decimal 模块

1
2
3
4
5
>>> import decimal
>>> a = decimal.Decimal("0.1")
>>> b = decimal.Decimal("0.2")
>>> print(a + b)
0.3

复数

获取复数的实部和虚部

1
2
3
4
5
>>> x = 1 + 2j
>>> x.real
1.0
>>> x.imag
2.0

地板除 //

地板除的原则是，向比结果小的整数取

1
2
3
4
5
6
>>> 5 //2
2
# 结果是2.5 向比结果小的整数取，就是2
>>> -5 // 2
-3
# 结果是-2.5，比结果小的是 -3

一个数学公式

1
2
3
4
x = (x // y) * y + (x % y)

#举例
5 = (5 // 2) * 2 + (5 % 2)

获得类型

  • type() 返回变量类型
  • isinstance(变量，变量种类) 返回布尔值
1
2
3
4
5
6
>>> a = 5.99
>>> type(a)
<class 'float'>

>>> isinstance(a,float)
True

运算符的优先级

| 优先级（值越大，优先级越高） | 运算符 | 描述 |
| —————————- | ——————————————————————- | ——————————————– | — |
| 1 | lambda | Lambda 表达式 |
| 2 | if - else | 条件表达式 |
| 3 | or | 布尔 “或” |
| 4 | and | 布尔“与” | |
| 5 | not | 布尔“非” |
| 6 | in,not in,is,is not,<,<=,>,>=,!=,== | 成员测试，同一性测试，比较 |
| 7 | | | 按位或 |
| 8 | ^ | 按位异或 |
| 9 | & | 按位与 |
| 10 | <<,>> | 移位 |
| 11 | +,- | 加减法 |
| 12 | * ，@，/，//，% | 乘法，矩阵乘法，除法，地板除。取余数 |
| 13 | +x，-x，~x | 正负号，按位翻转 |
| 14 | ** | 指数 |
| 15 | await x | Await 表达式 |
| 16 | x[index]，x[index,index]，x(arguments…)，x.attribute | 下标，切片，函数调用，属性引用 |
| 17 | (expressions…)，[expressions…]，{key:value…}，{expressions..} | 绑定或元组显示，列表显示，字典显示，集合显示 |

1
>>> ((not 1) or ( 0 and 1) or (3 and 4) or (5 and 6) or (7 and 8 and 9)) == 4
1
2
3
4
5
>>> not 1 or 0 and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9
4
# 优先级是 not > and > or，所以会优先计算not 1 ，为0
# 0 or (0 and 1) or (3 and 4) or (5 and 6) or (7 and 8 and 9)
# 跟上一道题一样了