Python零基础入门

Python简介

简介： Python，是一种广泛使用的解释型、高级编程、通用型编程语言，由吉多·范罗苏姆于1991年创造。 Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或者关键词）。 相比于C++或Java，Python让开发者能够用更少的代码表达想法。

基础语法

代码风格

• Python用缩进来区分程序的作用域

if __name__ == '__main__':
    print("hello python")

数据类型

• 整型： Python3的整形类似于Java的BigInteger类型，它的长度不受限制
• 浮点型： Python区分整型和浮点型的唯一方式，就是看有没有小数点
• 布尔类型只有两个值：True和False，就是真与假。布尔类型可以当作整数来对待，True相当于整型值1，False相当于整型值0（但是不建议与整型混合使用）
• 字符串：与Java的字符串类似，简单理解为一串字符
• 类型转换函数：int()、float()和str()
• 浮点数转换为整数，Python会采取“截断”处理

变量定义

• Python定义变量的时候，变量名没有类型的概念，所以定义变量的时候直接用变量名 = 值
• 变量名可以包括字母、数字、下划线，但变量名不能以数字开头。变量名是大小写敏感的。
• 变量没有默认值，在使用变量之前，需要先对变量进行赋值（否则报错NameError: name 'xx变量' is not defined）
• 多次对变量进行赋值，后面的值会覆盖前面所赋的值

>>> name = "python"
>>> print("hello, " + name)
hello, python

字符串

• 创建一个字符串，要在字符两边加上引号，可以是单引号或者双引号，引号必须成对
• Python中的字符串与Java中的字符串一样，定义之后都是不可变的
• 字符串中可以用转义符号（）对字符串中的引号进行转义
• 定义字符串时，如果值以“r”开头，那么后面引号中的内容为“原始字符串”，其中的转义符号（）将不再有用
• 无论是否原始字符串，都不能以反斜杠作为结尾
• 定义长字符串时，可以用三重引号字符串（＂＂＂内容＂＂＂）

>>> var = """
... 从明天起，做一个幸福的人
... 喂马，劈柴，周游世界
... 从明天起，关心粮食和蔬菜
... 我有一所房子，面朝大海，春暖花开
... """
>>> print(var)

从明天起，做一个幸福的人
喂马，劈柴，周游世界
从明天起，关心粮食和蔬菜
我有一所房子，面朝大海，春暖花开

>>> 

• count(sub[, start[, end]])： 查找sub子字符串出现的次数
• find(sub[, start[, end]]) 和 index(sub[, start[, end]])：查找某个子字符串在该字符串中的位置，区别是找不到时，前者返回“-1”，后者抛错
• replace(old, new[, count])：方法如其名，就是替换指定的字符串
• "_".join("python") 会将字符串变为： 'p_y_t_h_o_n'
• split(sep = None, maxsplit = G1) 跟join()正好相反，split()用于拆分字符串：
• 格式化操作符：%，示例： '%5.2f' % 234.321 输出 '234.32'
• 关于字符串的更多方法：

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

常用操作符

• 算数操作符：加减乘除（+、-、*、/），取余（%），幂运算（ **）
• 比较操作符： >、<、>=、<=、 ==、 !=
• 逻辑操作符： and、or、not

代码注释

• Python的单行注释以 # 号开头
• Python的多行注释包含在 ''' ''' 或者 """ """ 之间

分支和循环

条件分支

• if 条件: 条件为真(True)执行的操作 else: 条件为假(False)执行的操作
• if、else 后面的条件不用写在括号()中（这是与Java不一样的地方）
• if - else 可以嵌套使用

    var = input("请输入一个数字： ")
    if int(var) < 5:
        print("输入的小于5")
    else:
        print("输入的大于等于5")

条件表达式

• 语法： a = x if条件 else y
• 示例：small = x if x < y else y

while循环

• while 条件: 条件为真(True)执行的操作

    a = 1
    while a < 5:
        print(a)
        a += 1

for循环

• 语法： "for" target_list "in" expression_list ":" suite
• for 经常与 range([start, ]stop[, step = 1]) 内建函数搭配使用

    for char in var:
        print(char)

    for i in range(1, 10, 2):
        print(i)</code></pre>

break和continue

• break 语句的作用是终止当前循环，跳出循环体
• continue 语句的作用是终止本轮循环并开始下一轮循环

列表(list)与元组(tuple)

列表的概念

• Python中的列表类似Java中的数组，但是又不完全一致。数组要求数组的元素为同一种类型，但是列表没有这样的要求

定义列表

• 定义一个空列表： number = []
• 定义列表并初始化： number = [1, 2, 3, 4, 5]

向列表增加元素

• 在列表末尾增加单个元素： number.append(6)
• 在列表末尾增加多个元素： number.extend([7, 8])
• 在列表的任意位置插入元素： number.insert(0, 0)

获取列表中的元素

• 用类似数组下标的形式获取元素（元素下标计数从0开始）： number[1]

从列表删除元素

• 根据列表下标删除： del number[0]
• 根据元素删除： number.remove(3) # 这里删除的是值为3的元素，不是下标为3的元素
• 删除整个列表： del number # del 列表变量名，删除列表中的所有元素
• 弹出一个元素：number.pop() # 默认弹出最后一个元素，也可以带索引参数弹出指定位置的元素

列表分片

• 获取第0~3个元素： number[0:4] # index为索引开始和结束位置，注意：结束位置不包含
• 上面的索引还可以加一个步长参数：number[0:4:2]
• 列表的分片是对原列表做的一个拷贝，原列表不会被改变（深拷贝）
• 与列表的分片相反，如果是将一个列表变量赋值给另外一个变量，则是浅拷贝 （即改变其中一个列表，另外一个列表也会跟着改变）

列表与操作符

• 两个列表相加（+）：表示对两个列表进行连接，即做合并，相当于 extend方法
• 列表乘以（*）一个整数N：将列表中的元素重复N次
• 成员操作符（in、not in）：判断元素是否为列表的成员（in和not in 只能判断一个层次的成员关系，即一维的判断）

其他关于列表的方法

• len() 方法查看列表长度，如：有列表 a，执行 len(a) 可以得到列表a的长度
• count() 这个方法的作用是计算它的参数在列表中出现的次数
• index() 这个方法会返回它的参数在列表中的位置
• sort() 这个方法是用指定的方式对列表的成员进行排序，默认不需要参数，从小到大排队
• reverse()方法的作用是将整个列表原地翻转
• 更多方法可以执行 dir(list) 方法查看

'__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

元组(tuple)

• 列表与元祖比较类似，区别是列表中的元素可变，但是元组不可以。所以元组不能插入、删除、排序和翻转
• 定义元组： tuple = (1, 2, 3, 4)，定义元组的关键是逗号（,），即使定义的元组只有一个元素也要加逗号： tuple1 = (1,)
• 访问元组的方式与列表无异
• 可以使用分片的方式来复制一个元组

序列

• list([iterable]) 方法用于把一个可迭代对象转换为列表，如：将字符串转换为列表，l = list('python') 那么 l 值为 ['p', 'y', 't', 'h', 'o', 'n']
• tuple([iterable]) 方法用于把一个可迭代对象转换为元组，例子与上面的列表转换类似
• str(obj) 方法用于把obj对象转换为字符串
• len(sub) 方法用于返回sub参数的长度
• max(...) 和 min(...) 返回序列或者参数集合中的最大值、最小值
• sum(iterable[, start]) 方法用于返回序列iterable的总和，用法跟max()和min()一样。
• sorted(iterable, key=None, reverse=False) 方法用于返回一个排序的列表，列表的内建方法sort()是实现列表原地排序；而sorted()是返回一个排序后的新列表
• reversed(sequence) 方法用于返回逆向迭代序列的值。道理与sorted()方法一样。
• zip(iter1[, iter2[...]]) 方法用于返回由各个可迭代参数共同组成的元组（有点像文本编辑器中的列操作，这里可以同时操作多列）

函数

函数基础

• 一个程序可以按照不同功能的实现，分割成许许多多的代码块，每一个代码块就可以封装成一个函数。
• 定义函数的方式： def functionName():，定义函数时，一定要在函数后面加()，一个函数定义的示例如下：

def myFirstFunction():
    print("this is my first python function!")

• 调用函数： myFirstFunction()

函数参数

• 函数的参数： 定义函数时，可以在函数名称后面的括号中定义参数，多个参数之间用逗号隔开，如 def add(a, b)
• 参数从调用的角度来说，分为形式参数（parameter）和实际参数（argument），即形参和实参，在函数定义时的参数是形参，在函数调用时的参数是实参
• 关键字参数： 就是在传入实参时指定形参的变量名，例： 函数的定义为 def sayHi(hi, name): ，那么调用的时候可以这样 sayHi(name = 'python', hi = 'hello'，这样就不用关心参数定义的位置
• 默认参数： 在定义的时候赋予了默认值的参数，使用默认参数的话，就可以不带参数去调用函数
• 可变参数： 在参数前边加上星号（*）即可，表示参数的个数不固定

函数返回值

• 函数返回值： 定义函数时，可以在函数实现体中增加返回值。如果在定义函数时没有显示定义返回语句，那么Python会默认返回一个None。拥有返回值的函数示例：

def add(num1, num2):
    return num1 + num2

• Python中的函数返回值没有类型概念，由Python动态确定函数返回类型
• 在Python可以利用列表打包多种类型的值一次性返回

全局变量与局部变量

• 在函数里边定义的参数以及变量，都称为 局部变量，出了这个函数，这些变量都是无效的
• 全局变量 的作用域是整个模块，但是不要试图在函数内部去修改全局变量的值，因为那样Python会自动在函数内部新建一个名字一样的局部变量代替。
• global关键字： 在全局变量前加 global 关键字之后，就可以在函数中对全局变量进行修改了

lambda表达式

• 基本语法是在冒号（:）左边放原函数的参数，可以有多个参数，用逗号（，）隔开即可；冒号右边是返回值。示例： lambda x : 2 * x + 1
• lambda 表达式与内建函数 filter() 一起使用： list(filter(lambda x : x % 2, range(10))) 可以列出 1~10 的奇数

字典

字典的概念

• Python中的字典就是“键-值对”映射的集合，和Java中的Map类似
• 字典的键必须独一无二，而值可以取任何数据类型，但必须是不可变的（如字符串、数或元组）
• 字典由多个键及其对应的值共同构成，每一对键值组合称为项
• 字典是Python中唯一的映射类型
• 字典类型区别于序列类型，序列类型以数组的形式存储，通过索引的方式来获取相应位置的值
• 字典跟序列不同，序列讲究顺序，字典讲究映射，不讲顺序。

创建字典

• 字典的使用非常简单，它有自己的标志性符号，就是用大括号（）定义。
• 定义字典方法一： dict1 = {'first': 1, "second": 2}
• 定义字典方法二： dict2 = dict(first = 1, second = 2)，注意 使用这种方式时，键不加引号
• 定义字典方法三： dict3 = dict({'first': 1, 'second': 2})
• 定义一个空字典： dict = {}

字典的内置方法

• fromkeys(): fromkeys()方法用于创建并返回一个新的字典，它有两个参数：第一个参数是字典的键；第二个参数是可选的，是传入键对应的值。如果不提供，那么默认是None。
• keys(): 用于返回字典中的键
• values(): 用于返回字典中所有的值
• items(): 返回字典中所有的键值对
• get(): 方法提供了更宽松的方式去访问字典项，当键不存在的时候，get()方法并不会报错，只是默返回一个None。希望找不到数据时返回指定的值，那么可以在第二个参数设置对应的默认返回值，如 dict1.get('third', 3)
• 可以用 'second' in dict1 的方式判断字典中是否包含这个键
• clear(): 清空字典
• copy(): 方法是复制字典
• pop(): 是给定键弹出对应的值（弹出之后就从原字典删除）
• popitem(): 是弹出一个项（弹出之后就从原字典删除）
• update(): 可以利用它来更新字典，如 dict1.update(first = 0)，注意 这里键不加引号

集合

集合的概念

• 集合类似于Java中的 set
• 集合是无序的
• 集合中没有重复的元素

创建集合

• 创建集合有两种方法：一种是直接把一堆元素用大括号（）括起来；另一种是用 set()
• 示例1： set1 = {'first', 'second', 'third'}
• 示例2： set2 = set(['first', 'second', 'third'])

访问集合

• 可以使用 in和not in 判断一个元素是否在集合中已经存在
• add() 方法可以为集合添加元素
• remove() 方法可以删除集合中已知的元素
• 由于集合中的元素是无序的，所以并不能像序列那样用下标来进行访问，但是可以使用迭代把集合中的数据一个个读取出来

    set1 = {"first", "second", "third"}
    for element in set1:
        print(element)

文件

打开文件

• 在Python中，使用open()这个函数来打开文件并返回文件对象： open(file, mode = 'r', buffering = -1, encoding = None, errors = None, newline = None, closefd = True, opener = None)
• open() 函数关注第一个和第二个参数即可，第一个参数是传入的文件名，第二个参数指定文件打开模式（’r’ – 以只读方式打开文件； ‘w’ – 以写入的方式打开文件，会覆盖已有内容； ‘a’ – 以写入模式打开，如果文件有内容，则追加； ‘t’ – 以文本模式打开文件； ‘b’ – 以二进制方式打开文件； ‘+’ – 可读写模式）

文件对象的方法

打开文件并取得文件对象之后，就可以利用文件对象的一些方法对文件进行读取或修改等操作

• read(size): 从文件中读取size个字符，size未指定或为负值时，读取剩余的所有字符，并作为字符串返回
• readline(): 从文件中读取一整行字符串
• write(str): 将字符串str写入文件
• writelines(seq): 向文件中写入seq，seq应该是一个返回字符串的可迭代对象
• tell(): 返回当前在文件中的位置
• seek(offset, from): 在文件中移动offset个字节，从from开始移动（from为0表示文件起始位置，1表示当前位置，2表示文件末尾）
• close(): 关闭文件
• 也可以直接list(f)或者直接使用迭代来读取。read()是按字节为单位读取

文件系统方法

• getcwd(): 获得应用程序当前的工作目录
• chdir(path): 可以改变当前工作目录
• listdir(path='.'): 列举当前目录下有哪些文件和子目录
• mkdir(): 用于创建文件夹，如果该文件夹存在，则抛出FileExistsError异常
• makedirs(): 可以用于创建多层目录
• remove(path)、rmdir(path)和removedirs(path): remove()函数用于删除指定的文件，rmdir()用于删除目录，removedirs()用于删除多层目录
• rename(): 用于重命名文件或文件夹
• walk(top): 作用是遍历top参数指定路径下的所有子目录，并将结果返回一个三元组（路径，［包含目录］，［包含文件］）
• getsize() 函数用于获取文件的尺寸，返回值是以字节为单位
• getatime()、getctime()和getmtime() 分别用于获得文件的最近访问时间、创建时间和修改时间（返回值是浮点型秒数，可用time模块的gmtime()或localtime()函数换算）

pickle模块

• 作用： 可以把所有Python的对象都转化为二进制的形式存放，这个过程称为pickling，那么从二进制形式转换回对象的过程称为unpickling。
• 使用示例：

import pickle

if __name__ == '__main__':
    aList = {'first', 'second'}
    file = open("test.pkl", "wb")
    # 保存文件
    pickle.dump(aList, file)
    file.close()

    # 提取文件
    file = open("test.pkl", "rb")
    bList = pickle.load(file)
    print(bList)

异常处理

try-except语句

• 语句格式： try: 检测范围 except Exception[as reason]: 出现异常(Exception)后的处理代码
• 一个try语句还可以和多个except语句搭配
• except后边还可以跟多个异常，然后对这些异常进行统一的处理
• try语句检测范围内一旦出现异常，剩下的语句将不会被执行
• try-except 示例：

    try:
        f = open('hello.txt')
        print(f.read())
        f.close()
    except FileNotFoundError as reason:
        print("文件不存在: " + str(reason))
    except (OSError, TypeError) as reason:
        print('打开文件出错！原因是： ' + str(reason))

try-finally语句

• 如果try语句块中没有出现任何运行时错误，会跳过except语句块执行finally语句块的内容
• 如果出现异常，则会先执行except语句块的内容再执行finally语句块的内容

    try:
        f = open('test.txt')
        print(f.read())
    except (OSError, TypeError) as reason:
        print('打开文件出错！原因是： ' + str(reason))
    finally:
        f.close()

raise语句

• 可以使用raise语句抛出一个异常，如： raise ZeroDivisionError("除数不能为0！")

with语句

• Python提供了一个with语句，利用这个语句抽象出文件操作中频繁使用的try/except/finally相关的细节

    try:
        with(open('test.txt')) as file:
            print(file.read())
    except OSError as reason:
        print("错误： " + str(reason))

常见错误类型

• AssertionError：断言语句（assert）失败
• AttributeError：尝试访问未知的对象属性
• IndexError：索引超出序列的范围
• KeyError：字典中查找一个不存在的关键字
• NameError：尝试访问一个不存在的变量
• OSError：操作系统产生的异常
• SyntaxError：Python的语法错误
• TypeError：不同类型间的无效操作
• ZeroDivisionError：除数为零

类和对象

基础概念

• 类是一种封装，使用类来创建一个真正的对象（即实例）
• 一个对象的特征称为“属性”，一个对象的行为称为“方法”
• 对象的方法都会有一个self参数，当一个对象的方法被调用的时候，对象会将自身的引用作为第一个参数传给该方法
• __init__() 方法称为构造方法，这个方法会在对象被创建时自动调用
• 类中定义的属性是静态变量，类的属性是与类对象进行绑定，并不会依赖任何它的实例对象
• 在Python中定义私有属性或方法，只需要在变量名或函数名前加上__ (两个下划线)

继承

• 被继承的类称为基类、父类或超类；继承者称为子类，一个子类可以继承它的父类的任何属性和方法
• 如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性
• 可以在子类中使用super()函数，super函数能够自动找到基类的方法
• Python还支持多继承，就是可以同时继承多个父类的属性和方法

class Animal:
    # 这是一个Python类示例
    name = ''

    def __init__(self, name):
        self.name = name

    def sayHello(self):
        print("Hi，" + self.name + "(from: " + self.__class__.__name__ + ")")

class Dog(Animal):
    def sayHello(self):
        print("Hi，" + self.name + "(from: " + self.__class__.__name__ + ")")

if __name__ == "__main__":
    animal = Animal("python")
    animal.sayHello()
    dog = Dog("python")
    dog.sayHello()

一些内置方法

• issubclass(class, classinfo): 如果第一个参数（class）是第二个参数（classinfo）的一个子类，则返回True，否则返回False
• isinstance(object, classinfo): 如果第一个参数（object）是第二个参数（classinfo）的实例对象，则返回True，否则返回False
• hasattr(object, name): 测试一个对象里是否有指定的属性。
• getattr(object, name[, default]): 返回对象指定的属性值，如果指定的属性不存在，则返回default（可选参数）的值；若没有设置default参数，则抛出ArttributeError异常。
• setattr(object, name, value): setattr()可以设置对象中指定属性的值，如果指定的属性不存在，则会新建属性并赋值
• delattr(object, name): 用于删除对象中指定的属性，如果属性不存在，则抛出AttributeError异常

模块

基础概念

• 容器（列表、元组和字典等）是对数据的封装
• 函数是对语句的封装
• 类是对方法和属性的封装
• 模块是对Python文件（xx.py）的封装
• 在Python中，每个模块都会维护一个独立的命名空间，我们应该将模块名加上，才能够正常使用模块中的函数

包

• 创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字；
• 在文件夹中创建一个__init__.py的模块文件，内容可以为空；（用来告诉Python将该目录当成一个包来处理）
• 将相关的模块放入文件夹中
• 包可以包含多个模块，模块可以包含多个类（以及方法），类可以包含多个属性和方法

导入模块

• from [包名.]模块名 import 类名/函数名 [as 别名]，如下，从test包的hello模块导入Animal类：

from test.hello import Animal

if __name__ == '__main__':
    animal = Animal("Tiger")
    animal.sayHello()

if __name == ‘__main‘

• 在作为程序运行的时候，__name__属性的值是'__main__'
• 作为模块导入的时候，这个值就是该模块的名字

常用技巧

• Python文档中心： https://docs.python.org/3/
• Python所有的内置函数和标准库的各个模块的用法: https://docs.python.org/3/library/index.html
• 要快速学习一个模块的用法，可以先import这个模块
• 然后调用__doc__属性，查看这个模块的简介，可以用print把它带格式的打印出来，如 print(http.__doc__)
• 可以使用dir()函数查询到该模块定义了哪些变量、函数和类，如 dir(http)
• 可以使用__all__属性过滤出能够供外部调用的变量、函数和类，如 http.__all__
• 最后可以使用 help(模块名) 函数查看更详细一些的帮助，如 help(http)