Python学习笔记（持续更新）

前言

本蒻苟已粗略学习过c++基础，略去大部分相似且熟悉部分。

关于Python

Python由荷兰数学和计算机科学研究学会的Guido van Rossum 于1990 年代初，出于打发时间的目的设计（这就是dalao吧），就连Python的名字也是源于当时他正在看的电视剧“Monty Python’s Flying Circus”。

（就是这位帅哥）

Python之禅
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!
（翻译自行百度）

Python与c++区别

Python是一种脚本语言，是解释执行的，不需要经过编译，所以很方便快捷，且能够很好地跨平台，写一些小工具小程序特别合适。

而C++则是一种需要编译后运行语言，在特定的机器上编译后在特定的机上运行，运行效率高，安全稳定。但编译后的程序一般是不跨平台的。

小方面：

1. 在Python中没有switch语句。你可以使用if…elif…else语句来完成同样的工作（在某些场合，使用字典会更加快捷。）
2. 在Python中没有专门的char数据类型。
3. 单引号和双引号字符串是完全相同的——它们没有在任何方面有不同
4. 在C/C++中，如果你想要写for (int i = 0; i < 5; i++)，那么用Python，你写 成for i in range(0,5)。Python的for循环更加简单、明白、不易出错。
5. Python中是没有&&及||这两个运算符的，取而代之的是英文and和or。
6. Python中单独使用!无特殊含义，非为not，但是有!=运算符
7. Python 里面万物皆对象（object），整型也不例外，只要是对象，就有相应的属性 （attributes） 和方法（methods）。

小操作

• 注释:
  在 Python 中，# 表示注释，作用于整行。或者一对三个单引号/三个双引号表示区间注释，在三引号之间的所有内容被注释。
• 单双引号：
  单引号跟双引号的普通用法相同, 与C++中用双引号表示字符串的用法一样，区别主要体现在当用单引号包起来的字符串里包含"的时候, 不需要使用转义符(), 反过来也是一样,如：

print( "let's go" )
print( 'lalala"lalala"lala' ) #没想到例子瞎写一个吧

• 三引号:
  一对连续的单引号或者双引号,允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

 print('''abc
 xyz
 ghi''')
#输出结果：
abc
xyz
ghi

 person = """name  # 姓名
 age   # 年龄
 sex   # 性别
 """
 print（person）
#输出结果
name  # 姓名
age   # 年龄
sex   # 性别
'''
多行注释
可用三引号
'''

Day1：变量、运算符、数据类型及位运算

运算符

-运算符优先级和结合性

算术运算符

操作符	名称
//	整除（地板除，向下取整）
**	乘方

例：

print(3 // 4)  # 0
print(2 ** 3)  # 8
print(3**2**3) # 6561

逻辑运算符

操作符	名称
and	与
or	或
not	非

例：

print((3 > 2) and (3 < 5))  # True
print((1 > 3) or (9 < 2))   # False
print(not (2 > 1))          # False

位运算符

操作符	名称
~	按位取反
&	按位与 4 & 5
|	按位或
^	按位异或 4 ^ 5
<<	左移 4 << 2
>>	右移

例：

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

三元运算符

例：

x, y = 4, 5
small = x if x < y else y
print(small)  # 4

其他

操作符	名称
in	存在
not in	不存在
is	是
is not	不是

例：

letters = ['A', 'B', 'C']
if 'A' in letters:
    print('A' + ' exists')
if 'h' not in letters:
    print('h' + ' not exists')

# A exists
# h not exists

注：

• is, is not 对比的是两个变量的地址，而 ==，!= 比较的是两个变量的值
  具体参考Python中is和==的区别

数据类型

获取数据类型

• type(object) 获取类型信息
• 不会认为子类是一种父类类型，不考虑继承关系。
  例：

print(type(1))       # 
print(type(5.2))     # 
print(type(True))    # 
print(type('5.2'))   # 

• isinstance(object, classinfo) 判断一个对象是否是一个已知的类型。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。
  例：

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

类型转换

• 转换为整型 int(x, base=10)
• 转换为字符串 str(object=’’)
• 转换为浮点型 float(x)

print()函数

位运算

原码、反码、补码

• 原码：数字绝对值的二进制，最高位为符号位（0表示正，1表示负）
• 反码：正数的反码与其原码相同；负数的反码是对正数逐位取反，符号位保持为1。
• 补码：正数的补码与其原码相同；负数的补码是在其反码的末位加1。

运算符对应操作

参考

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

例：

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0

c = a & b;        # 12 = 0000 1100
print "1 - c 的值为：", c
 
c = a | b;        # 61 = 0011 1101 
print "2 - c 的值为：", c
 
c = a ^ b;        # 49 = 0011 0001
print "3 - c 的值为：", c
 
c = ~a;           # -61 = 1100 0011
print "4 - c 的值为：", c
 
c = a << 2;       # 240 = 1111 0000
print "5 - c 的值为：", c
 
c = a >> 2;       # 15 = 0000 1111
print "6 - c 的值为：", c

练习题：

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

• 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。尝试使用位运算解决此题。
• 注意到：一个数如果连续异或了两个相同的数，他将保持不变。（开整！）
  例：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        i = 0
        for num in nums:
            i ^= num
        return i

Day2:条件、循环结构

条件结构

if - elif - else 语句

• 相当于 else if

assert 关键词

• assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常,程序自动崩溃并抛出AssertionError的异常。
• assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。

循环结构

• Python 提供了 for 循环和 while 循环（在 Python 中没有 do…while 循环）。

while - else 循环

• 当while循环正常执行完的情况下，执行else输出，，如果while循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容。

for 循环

• for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如str、list、tuple等，也可以遍历任何可迭代对象，如dict(字典)。
• 每次循环，迭代变量被设置为可迭代对象的当前元素，提供给代码块使用。
  例：

'''
for 迭代变量 in 可迭代对象:
    代码块
'''
for i in 'ILoveRM':
    print(i, end=' ')  # 不换行输出
#输出结果
# I L o v e R M


dic = {
     'a': 1, 'b': 2, 'c': 3, 'd': 4}

for key, value in dic.items():
    print(key, value, sep=':', end=' ')
#输出结果    
# a:1 b:2 c:3 d:4

for - else 循环

• 当for循环正常执行完的情况下，执行else输出，，如果for循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容，与while - else语句一样。

range() 函数

• 这个BIF（Built-in functions）有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。
• step 步长，默认为1。
• range 这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列，该序列包含start的值但不包含stop的值。
  例：

range([start,] stop[, step=1])


for i in range(1, 10, 2):
    print(i)
#输出结果
# 1
# 3
# 5
# 7
# 9

enumerate()函数

• sequence – 一个序列、迭代器或其他支持迭代对象。
• start – 下标起始位置。
• 返回 enumerate(枚举) 对象
• 用 enumerate(A) 不仅返回了 A 中的元素，还顺便给该元素一个索引值 (默认从 0 开始)。此外，用 enumerate(A, j) 还可以确定索引起始值为 j。

enumerate(sequence, [start=0])


seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]


#与for结合
seq = ['one', 'two', 'three']
for i, element in enumerate(seq, start = 1):  #下标从 1 开始
     print i, element
 
#1 one
#2 two
#3 three