Task 1 学习笔记

最新推荐文章于 2020-09-08 22:35:55 发布

Lemonade_YoYo

最新推荐文章于 2020-09-08 22:35:55 发布

阅读量291

点赞数

文章标签： python

本文链接：https://blog.csdn.net/weixin_44923046/article/details/107476415

版权

群内编号：129-木铎铎
本笔记记录之前学习Python时不熟悉或未接触的知识点以及一些个人认为能帮助理解的例子。

PART 1 位运算与位运算符

位运算符

在这里插入图片描述
输入下面位运算符命令并查看结果（每行注释为结果）

print(bin(4))  # 0b100
print(bin(5))  # 0b101
print(bin(~4), ~4)  # -0b101 -5
print(bin(4 & 5), 4 & 5)  # 0b100 4
print(bin(4 | 5), 4 | 5)  # 0b101 5
print(bin(4 ^ 5), 4 ^ 5)  # 0b1 1
print(bin(4 << 2), 4 << 2)  # 0b10000 16
print(bin(4 >> 2), 4 >> 2)  # 0b1 1

为理解上面的结果，将位运算内容直接补充到此处。

位运算

1. 原码、反码和补码

表示二进制的三种形式，计算机内部使用补码来表示。
符号位
二进制码的最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。

原码
某值的二进制表示，其最高位是符号位。

00 00 00 11 -> 3
11 11 11 00 -> -3

反码
正数的反码就是原码，负数的反码是符号位不变，其余的位取反（即符号不变，对应正数按位取反）。

00 00 00 11 -> 3
11 11 11 00 -> -3

补码：正数的补码就是原码，负数的补码是反码+1。
注意反码是二进制码，不是在其十进制数上+1

00 00 00 11 -> 3
11 11 11 01 -> -3

2. 按位非操作 ~

~ 1 = 0
~ 0 = 1

~ 把某二进制码的补码中的 0 和 1 全部取反（0 变为 1，1 变为 0）有符号整数的符号位在 ~ 运算中同样会取反。

00 00 01 01 -> 5
~
---
11 11 10 10 -> -6

11 11 10 11 -> -5
~
---
00 00 01 00 -> 4

3. 按位与操作

与门，二值必须同为真其与值才为真。

1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0

当两个二进制码做按位与运算时，只有两个对应位都为 1 时，结果的相应位才为 1。

00 00 01 01 -> 5
&
00 00 01 10 -> 6
---
00 00 01 00 -> 4

4. 按位或操作 |

或门，二值只要有一为真其或值就为真。

1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0

当两个二进制码做按位或运算时，只要两个对应位中有一个为 1 时，结果的相应位就为 1。

00 00 01 01 -> 5
|
00 00 01 10 -> 6
---
00 00 01 11 -> 7

5. 按位异或操作 ^

异或，只有当二值不相等时异或的值才为1.

1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0

当两个二进制码做按位或运算时，只要当两个对应位的值不同时，结果的相应位才为 1。

异或操作满足交换律和结合律

A: 00 00 11 00
B: 00 00 01 11

A^B: 00 00 10 11
B^A: 00 00 10 11

A^A: 00 00 00 00
A^0: 00 00 11 00

A^B^A: = A^A^B = B = 00 00 01 11

6. 按位左移操作 <<

把二进制数向左移动，右边补0

00 00 10 11 -> 11
11 << 3
---
01 01 10 00 -> 88

7. 按位右移操作 >>

把二进制数向右移动，左边补0

00 00 10 11 -> 11
11 >> 2
---
00 00 00 10 -> 2

8. 利用位运算实现快速计算

1）通过 <<，>> 快速计算2的倍数问题。

注：下面结论都是由二进制表示法的定义得到的。

n << 1 -> 计算 n*2
n >> 1 -> 计算 n/2，负奇数的运算不可用
n << m -> 计算 n*(2^m)，即乘以 2 的 m 次方
n >> m -> 计算 n/(2^m)，即除以 2 的 m 次方
1 << n -> 2^n

2）通过 ^ 快速交换两个整数

a ^= b
b ^= a
a ^= b

3）通过 a & (-a) 快速获取a的最后为 1 位置的整数

00 00 01 01 -> 5
&
11 11 10 11 -> -5
---
00 00 00 01 -> 1

00 00 11 10 -> 14
&
11 11 00 10 -> -14
---
00 00 00 10 -> 2

9. 利用位运算实现整数集合

一个数的二进制表示可以看作是一个集合（0 表示不在集合中，1 表示在集合中）。

如集合 {1, 3, 4, 8}可表示成 01 00 01 10 10，其对应的位运算也就可以看作是对集合进行的操作。

1）元素与集合的操作

a | (1<<i)  -> 把 i 插入到集合中
a & ~(1<<i) -> 把 i 从集合中删除
a & (1<<i)  -> 判断 i 是否属于该集合（零不属于，非零属于）

2）集合之间的操作

a 补   -> ~a
a 交 b -> a & b
a 并 b -> a | b
a 差 b -> a & (~b)

注：整数在内存中以补码的形式存在，输出也按补码输出。
例 Python 的bin() 输出。

print(bin(3))  # 0b11
print(bin(-3))  # -0b11

print(bin(-3 & 0xffffffff))  
# 0b11111111111111111111111111111101

print(bin(0xfffffffd))       
# 0b11111111111111111111111111111101

print(0xfffffffd)  # 4294967293

由结果可见：
1）Python中向bin中传入一个十进制负数，输出的是它原码的二进制前面加上个负号。
2）Python中的整型是补码形式存储的。
3）Python中整型是不限制长度的不会超范围溢出。

故为获得十进制负数的补码，需先将其和十六进制数0xffffffff进行按位与操作，再传入bin()，得到的才是该负数的补码表示。

位运算练习题

leetcode 习题 136 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

尝试使用位运算解决此题。

"""
Input file
example1: [2,2,1]
example2: [4,1,2,1,2]

Output file
result1: 1
result2: 4
"""
# 注意到，一个二进制数和自己做异或操作的结果总为其本身为0
# 而某个数和0做异或操作的结果为它本身
# 故可对所有数据做异或运算，所得的结果就是那个孤零零的数
class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        target = 0
        for i in range(len(nums)):
            target ^= nums[i]
        return target

PART 2 其他内容

三元运算符

例

x, y = 4, 5
if x < y:
    small = x
else:
    small = y

print(small)  # 4

# 使用三元运算符
x, y = 4, 5
small = x if x < y else y
print(small)  # 4

使用is和not is比较同时指向可变或不可变类型的两个变量

例比较的两个变量均指向不可变类型。

a = "hello"
b = "hello"
print(a is b, a == b)  # True True
print(a is not b, a != b)  # False False

例比较的两个变量均指向可变类型。

a = ["hello"]
b = ["hello"]
print(a is b, a == b)  # False True
print(a is not b, a != b)  # True False

注
1）is, is not 对比的是两个变量的内存地址；
2）== , != 对比的是两个变量的值；
3）如果比较的两个变量指向的都是地址不可变的类型（str等），则is，is not 和 ==，!= 是完全等价的；
4）如果比较的两个变量指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。

数据类型与转换

Python 里面万物皆对象（object），整型也不例外，只要是对象，就有相应的属性（attributes）和方法（methods）。

有时候我们想保留浮点型的小数点后 n 位。可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现。

import decimal
from decimal import Decimal

例 getcontext() 显示了 Decimal 对象的默认精度值是28 位(prec=28)。

a = decimal.getcontext()
print(a)

# Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
# capitals=1, clamp=0, flags=[], 
# traps=[InvalidOperation, DivisionByZero, Overflow])

b = Decimal(1) / Decimal(3)
print(b)

# 0.3333333333333333333333333333

例使 1/3 保留 4 位，用 getcontext().prec 来调整精度。

decimal.getcontext().prec = 4
c = Decimal(1) / Decimal(3)
print(c)

# 0.3333

布尔型

布尔 (boolean) 型变量只能取两个值，True 和 False。当把布尔型变量用在数字运算中，用 1 和 0 代表 True 和 False。

print(True + True)  # 2
print(True + False)  # 1
print(True * False)  # 0

除了直接给变量赋值 True 和 False，还可以用 bool(X) 来创建变量，其中 X 可以是

1）基本类型：整型、浮点型、布尔型
2）容器类型：字符串、元组、列表、字典和集合
例 bool 作用在基本类型变量：X 只要不是整型 0、浮点型 0.0，bool(X) 就是 True，其余就是 False。

print(type(0), bool(0), bool(1))
# <class 'int'> False True

print(type(10.31), bool(0.00), bool(10.31))
# <class 'float'> False True

print(type(True), bool(False), bool(True))
# <class 'bool'> False True

例 bool 作用在容器类型变量：X 只要不是空的变量，bool(X) 就是 True，其余就是 False。

print(type(''), bool(''), bool('python'))
# <class 'str'> False True

print(type(()), bool(()), bool((10,)))
# <class 'tuple'> False True

print(type([]), bool([]), bool([1, 2]))
# <class 'list'> False True

print(type({}), bool({}), bool({'a': 1, 'b': 2}))
# <class 'dict'> False True

print(type(set()), bool(set()), bool({1, 2}))
# <class 'set'> False True

确定bool(X) 的值是 True 还是 False，就看 X 是不是空，空的话就是 False，不空的话就是 True。

1）对于数值变量，0, 0.0 都可认为是空的。
2）对于容器变量，里面没元素就是空的。

isinstance(object, classinfo) 判断一个对象是否是一个已知的类型。

print(isinstance(1, int))  # True
print(isinstance(5.2, float))  # True
print(isinstance(True, bool))  # True
print(isinstance('5.2', str))  # True

注：
1）type() 不会认为子类是一种父类类型，不考虑继承关系。
2）isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

print()函数

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

1）将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按str()方式进行转换为字符串输出；
2）关键字参数sep是实现分隔符，比如多个参数输出时想要输出中间的分隔字符；
3）关键字参数end是输出结束时的字符，默认是换行符\n；
4）关键字参数file是定义流输出的文件，可以是标准的系统输出sys.stdout，也可以重定义为别的文件；
5）关键字参数flush是立即把内容输出到流文件，不作缓存。

shoplist = ['apple', 'mango', 'carrot', 'banana']

# 用end设置的参数&结尾，并未默认换行

print("This is printed with 'end='&''.")
for item in shoplist:
    print(item, end='&')
print('hello world')

# This is printed with 'end='&''.
# apple&mango&carrot&banana&hello world
_______________________________________

# 两个值之间用sep设置的参数&分割
# end参数的默认值为\n

print("This is printed with 'sep='&''.")
for item in shoplist:
    print(item, 'another string', sep='&')

# This is printed with 'sep='&''.
# apple&another string
# mango&another string
# carrot&another string
# banana&another string

练习题

1. 怎样对python中的代码进行注释？

在需要注释的代码前加一个#即可。特别地，在PyCharm中可以鼠标选中需要注释的代码后ctrl+/来完成。

2. python有哪些运算符，这些运算符的优先级是怎样的？

1）从运算符作用的角度讲，分为一元运算符和二元运算符，其中一元运算符优先于二元运算符，例如3 ** -2等价于3 ** (-2)；
2）从运算内容的角度讲，分为算术运算符和位运算符，其中算数运算符优先于移位运算符，移位运算符优先于位运算符，例如 1 << 3 + 2 & 7等价于 (1 << (3 + 2)) & 7；
3）最后还有一类逻辑运算符，它的优先级排在另外其他运算符之后，例如3 < 4 and 4 < 5等价于(3 < 4) and (4 < 5)。
实际中不确定或忘记了优先级的时候可以直接使用括号解决。

3. python 中 is, is not 与 ==, != 的区别是什么？

is和is not比较的是两个变量的内存地址，而 == 和 != 比较的是两个变量的值。也就是说，当两个变量的值相等，但是内存地址不相等时，使用 is 连接他们会得到False输出。

4. python 中包含哪些数据类型？这些数据类型之间如何转换？

Python中包括整型（int）、浮点型（float）、字符串（string）以及布尔类型（bool），部分转换方法如下：

1）转换为整型 int(x, base=10)
2）转换为字符串 str(object=’’)
3）转换为浮点型 float(x)
4）转换为布尔类型bool(x)，此时，只要x不为零或空则会输出True，否则为False

注：位运算练习题完成在位运算及位运算符知识点的后方，请向上查看。

Lemonade_YoYo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Task 1 学习笔记

本笔记记录之前学习Python是不熟悉或未接触的知识点已经一些个人认为能有效帮助理解的例子。位运算符输入下面位运算符命令并查看结果（每行注释为结果）print(bin(4)) # 0b100print(bin(5)) # 0b101print(bin(~4), ~4) # -0b101 -5print(bin(4 & 5), 4 & 5) # 0b100 4print(bin(4 | 5), 4 | 5) # 0b101 5print(bin(4 ^ 5), 4
复制链接

扫一扫