Python简单学习笔记

基础语法

1. 注释
   使用 # 标识

2. 字面常量
   是一个常量，值不能被改变

3. 数字
   主要分为两种类型：整数(Integers)和浮点数(Floats)。Python中没有long类型，int类型可以表示任意大小的整数。

4. 字符串
   用单引号和双引号表示单行字符串，用三引号表示多行字符串，字符串不可改变。

格式化

age = 20
name = 'aaa'
print('{0} is {1} years old'.format(name, age))

# 输出0.333
print('{0: .3f}'.format(1.0/3))

# 输出ab
print('a', end='')
print('b', end='')

5. 变量
   用来存储任意对象，在Python中任意内容均被称为对象，包括数字、字符串和函数。
   变量只需要被赋值，不需要声明数据类型

6. 逻辑行与物理行
   物理行：编写的代码中的一行语句
   逻辑行：解释器解释后的一条语句
   默认，一行物理行语句表示一条独立语句(逻辑行)，因此不需要分号区分。
   如果一行写多条独立语句，则需要用分号分隔。

i = 3; print(i)

# 也可写作：
i = 3
print(i)

用\可以将两个物理行连接成一个逻辑行

# 等价于i = 3
i = \
3

7. 缩进
   Python对缩进非常敏感，需要特别注意。
   缩进的功能类似于JAVA的{ }

运算符

• 加(+)
• 减(-)
• 乘(*)
• 乘方(**)：2**3为8
• 除(/)
• 整除(//)：对结果向下取整-13//3为-5
• 取模(%)
• 左移(<<)
• 右移(>>)
• 按位与(&)
• 按位或(|)
• 按位异或(^)
• 按位取反(~)
• 小于(<)、小于等于(<=)
• 大于(>)、大于等于(>=)
• 等于(==) 不等于(!=)
• 布尔与(and)
• 布尔或(or)
• 布尔非(not)

控制流

1. if语句

# 获取用户输入
num = 23
guess = int(input('Enter an integer: '))

# 注意冒号和缩进
if guess == num:
    print('correct')
elif guess < num:
    print('lower')
else:
    print('higher')

# if语句结束
print('Done')

2. while语句

num = 23
running = True

#注意冒号和缩进
while running:
    #获取用户输入
    guess=int(input('Enteraninteger:'))

    if guess == num:
        print('correct')
        running = False
    elif guess < num:
        print('lower')
    else:
        print('higher')

# while可以有else从句
else:
    print('loop is over')

# if语句结束
print('Done')

3. for循环

# 类似于JAVA中的foreach
for i in range(1, 5):
    print(i)
# 可以有else从句
else:
    print('loop is over')

4. break语句
   用于中断循环语句，同时else分支也不会被执行。

5. continue语句
   用于跳出循环的当前迭代，并继续下一次迭代。

函数

全局变量

x = 2
# 参数可设置默认值
def func(a, b=1):
    print('a=', a, 'b=', b)

    # 将x定义为全局变量
    global x

    # x=2
    print('x=', x)

    x = 4

    # x=4
    print('x=', x)

# a=6 b=1
func(6)

# x=4
print('x=', x)

关键字参数

def func(a, b=2, c=3):
    print('a=', a, 'b=', b, 'c=', c)

# a=1 b=4 c=3
func(1, 4)

# a=1 b=2 c=6
func(c=6, a=1)

可变参数

def func(a=5, *tuple, **dictionary):
    print('a', a)

    # 遍历元组中所有项目
    for item in tuple:
        print('item', item)

    # 遍历字典中所有项目
    for firstPart, secondPart in dictionary.items():
        print(firstPart, secondPart)

func(3, 1,2,3, a=1,b=2,c=3)

# a 3
# item 1
# item 2
# item 3
# a 1
# b 2
# c 3

DocStrings
文档字符串，相当于JAVA中函数/类的功能说明

def func():
    '''Demo func.

    Function detail description.'''

    print('haha')

print(func.__doc__)
# 输出：
# Demofunc.
#
#     Function detail description.

模块

编写模块的方法：

1. 创建一个包含函数、变量，以.py为后缀的文件
2. 利用其它语言(例如C语言)来编写Python模块，然后通过标准Python解释器在Python代码中使用该模块

使用标准库模块

# demo.py

import sys
for i in sys.argv:
    print(i)

# 执行：python demo.py this is arg
# 输出：
# this
# is
# arg

自定义模块

# myModule.py
__aaa__ ='1'
def func():
    print('haha')

# 另一模块 demo.py
import myModule
myModule.func()
print(myModule.__aaa__)

注意：myModule模块应放到demo模块同目录下，或者放到sys.path列出的一个目录下

更高效的导入模块方法：导入按字节码编译的.pyc文件

类和对象

类(Class)是利用class创建出来的一种类型，例如自带的int类型、自定义类等。
对象(Object)是属于某种类型下的一个实例。

字段
字段有两种类型：类变量和对象变量。
和JAVA中类似。

• 类变量是共享的，所有该类的对象都可以访问，类变量只有一个副本。
• 对象变量不共享，由每个对象独自拥有，各对象保存各自的变量副本。

class Demo:
    # 定义类变量
    count = 0

    def __init__(self, name):
        # 对象变量
        self.name = name

        # 调用类变量，输出0
        print(Demo.count)

方法
类方法与普通函数的区别：类方法需要在参数列表中的起始位置加入参数self，类似于JAVA中的this

class Person:
    # 构造方法
    def __init__(self, name):
        self.name = name

    # 自定义方法
    def say(self):
        print('my name is', self.name)

p = Person('aaa')
p.say()

继承

class Base:
    def __init__(self, name):
        self.name = name
    def say(self):
        print('name=', self.name, end=' ')

# 继承Base类
class Child(Base):
    def __init__(self, name, age):
        # 调用父类构造方法
        Base.__init__(self, name)
        self.age = age

    def say(self):
        # 调用父类自定义方法
        Base.tell(self)
        print('age=', self.age)

child = Child('aaa', 24)
child.tell()

# 输出：name= aaa age= 24

数据结构

Python中有四种内置数据结构：列表(list)、元组(tuple)、字典(dictionary)和集合(set)。

1. 列表
   用于保存一系列有序项目的集合，类似于JAVA中的数组，列表用[ ]括起来。

list = ['aaa', 'bbb']

# 输出aaa
print(list[0])

list.append('ccc')
del list[0]

# 输出['bbb', 'ccc']
print(list)

2. 元组
   用于将多个对象有序的保存到一起，类似于列表，但是列表可以修改，元组不能修改。元组推荐使用( )括起来，不用也可以。

tuple1 = ('aaa', 'bbb')

tuple2 = tuple1, 'ccc'

# 输出：('aaa', 'bbb')
print(tuple2[0])

# 输出：bbb
print(tuple2[0][1])

空元组：emptyTuple = ()
包含一个项目的元组：oneTuple = ('aaa', )

3. 字典
   将多个键值对保存到一起，且不保证顺序，类似于JAVA中的map。字典用{ }括起来。

dict = {
    'a': 'aaa',
    'b': 'bbb'
}

# aaa
print(dict['a'])

del dict['b']
dict['c'] = 'ccc'

# a aaa
# c ccc
for first,second in dict.items():
    print(first, second)

4. 集合
   将简单对象保存到一起，无序，且对象不重复，类似于JAVA中的set。

myset = set(['aaa', 'aaa', 'bbb'])

# {'bbb', 'aaa'}
print(myset)

# True
print('aaa' in myset)

序列

序列即有序的“列表”，主要功能有：

• 资格测试，查看是否存在
• 索引操作，获取特定索引的元素
  列表、元组和字符串都是序列的某种表现形式，因此有切片运算。

str = 'abc'
list = ['aaa', 'bbb', 'ccc']

# aaa
print(list[0])

# ccc  倒数第一位的索引是-1
print(list[-1])

# bbb  倒数第二位的索引是-2
print(list[-2])

# ['bbb']
print(list[1: -1])

# ['aaa', 'bbb', 'ccc']
print(list[ : ])

# 以2为步长，从左往右截取新的序列
# 输出['aaa', 'ccc']
print(list[::2])

# 以2为步长，从右往左截取新的序列
# 输出['ccc', 'aaa']
print(list[::-2])

# b
print(str[1: -1])

对于list[1: -1]这样的切片操作，理解如下：
正数索引从左至右为： 0 1 2 ......
负数索引从右至左为：-1 -2 -3 ......
两种索引是等价的，都可用于表示序列元素的位置。
根据切片操作:左右两边的数字，分别找到原始序列中的位置，然后截取得到新的序列。
切片操作是左闭右开的

如果需要创建一份诸如序列等复杂对象(而非整数、字符串这种简单对象)的拷贝时，必须使用切片操作来制作拷贝。如果直接用=来拷贝，拷贝的是引用(地址)

输入输出与文件IO

用户输入内容

something = input("Please enter text: ")
print(something)

文件IO

content = '''\
aaaaa
bbbbb
ccccc
'''
# 以写模式打开文件
f = open('demo.txt', 'w')
# 内容写入
f.write(content)
# 关闭文件
f.close()

# 以读模式(默认)打开文件
f.open('demo.txt')
while True:
    # 读取一行
    line = f.readline()
    if len(line) == 0:
        break
    print(line, end='')
f.close()

使用标准模块pickle

import pickle

name = 'demo2.data'
content = ['aaa', 'bbb', 'ccc']

# 以二进制写文件
f = open(name, 'wb')
# 写入内容
pickle.dump(content, f)
f.close()

del content

# 以二进制读文件
f = open(name, 'rb')
# 读取内容
content = pickle.load(f)
f.close()

print(content)

编码
在程序的顶端加入# encoding=utf-8，来指定该代码文件的编码格式为UTF-8

# encoding=utf-8
import io

# 以UTF-8来写文件
f = io.open('demo.txt', 'wt', encoding='utf-8')
# 指定写入的字符串使用unicode
f.write(u"中文内容")
f.close()

# 以UTF-8来读文件
text = io.open('demo.txt', encoding='utf-8').read()
print(text)

异常处理

捕获异常

import sys

f = None
try:
    f = open('demo.txt')
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print(line, end='')
        sys.stdout.flush()
except IOError:
    print('find no file')
except KeyboardInterrupt:
    print('Interrupt')
finally:
    if f:
        f.close()

抛出异常

# 自定义异常
class MyException(Exception):
    def __init__(self, length)
        Exception.__init__(self)
        self.length = length

try:
    text = input('Enter something: ')
    if len(text) < 3:
        # 抛出异常
        raise MyException(3)
except MyException as ex:
    print('MyException: I input length less than {0}'.format(ex.length))
else:
    print('no exception raised')

Python标准库

1. 系统模块：sys
2. 日志模块：logging
   等

矩阵运算

Python中，矩阵支持+ - * /等运算，原理是对矩阵中对应位置的元素运算，得到新的矩阵，因此参与运算的矩阵尺寸必须匹配。

注意：若矩阵尺寸不匹配，Python会自动对矩阵扩展，如果扩展后矩阵尺寸匹配了则不会报错。但是应尽量避免该情况发生（除非确定矩阵扩展规则），否则出现预期之外的结果后不容易排查定位问题。

import numpy as np

a = np.array([[1, 1, 1], [2, 3, 4]])
b = np.array([[1, 2]]).T

# 此时Python将矩阵b扩展为[[1, 1, 1], [2, 2, 2]]
print(a + b)
print(a - b)
print(a * b)
print(a / b)

# 输出：
[[2 2 2]
 [4 5 6]]

[[0 0 0]
 [0 1 2]]

[[1 1 1]
 [4 6 8]]

[[ 1.   1.   1. ]
 [ 1.   1.5  2. ]]

对于线性代数中的矩阵乘法，不能用*计算，应使用numpy中的方法计算。

import numpy as np

c = np.array([[1, 1, 1], [2, 3, 4]])
d = np.array([[1, 2, 3]]).T
# 矩阵乘
print(np.dot(c, d))

# 输出
[[ 6]
 [20]]

----------------------
欢迎补充修正