Python基础

一、语言特点

1 解释型语言

Python是解释型语言，代码直接解释执行。

2 语法

Python语句的结尾可以使用分号 ; ，也可以不使用。
Python对换行敏感，代码中使用反斜杠 \ 换行。
Python对缩进敏感，代码中使用缩进来控制标识符的作用域。

3 命名规范

变量：一般使用下划线命名法，如girl_friend。
类：一般使用大驼峰命名法，如GirlFriend。

4 注释

注释：使用井号 # 加注释内容。
文档注释：使用成对的三个双引号 """ """ 或成对的三个单引号 ''' '''。

二、数据类型

1 基本数据类型

整数int：大小无限制，当长度较大时，可以使用下划线作为分隔符，如1_000_000_000。
浮点数float。
布尔值bool：Python中的两个布尔值保留字为 True 和 False。
空值NoneType：Python中的空值保留字为 None。

2 运算符

算术运算符：加 +、减 -、乘 *、除 /、模 %、幂 **。
关系运算符：大于 >、小于 <、等于 ==、大于等于 >=、小于等于 <=、不等于 !=。
逻辑运算符：与 and、或 or、非 not。
三元运算符：xxx1 if bool else xxx2。

3 序列

3.1 字符串str

● 字符串是一个不可变的序列。
● 使用成对的双引号 " " 或成对的单引号 ' ' 来创建字符串，如 my_str = 'apple'。
● 可以使用 in 或 not in 关键字来判断某个字符串是否是另一个字符串的子串。
● 字符串拼接：
    字符串与字符串可以直接使用 + 运算符进行拼接。
    字符串与其他类型的数据不能直接使用 + 运算符进行拼接，可以使用占位符拼接法，如 'Hello %s' % 'World'。Python中常用的占位符有字符串占位符 %s、整数占位符 %d、浮点数占位符 %f。
● 字符串复制：
    可以使用 * 运算符进行字符串复制，如 s = '3flip' * 2，s被赋值为 '3flip3flip'。

3.2 列表list

● 列表中的元素可以是任何对象。
● 使用中括号 [ ] 来创建列表，如 my_list = [1, 2, 3, 4, 5]。
● 可以使用 in 或 not in 关键字来判断某个值是否在列表中。
● 列表查询：
    可以使用 列表名[索引] 来取列表中的元素，如 my_list[0]。
    索引(index)可以为负数，此时列表会从右向左取第 |index| 个元素。
● 列表遍历：
    可以使用foreach循环来对列表进行遍历：

for i in my_list:
    print(i)

● 列表切片：(包头不包尾)
    如 cut_list = my_list[1: 3]，cut_list 被赋值为 [2, 3]。
● 列表查询、列表遍历、列表切片同样适用于字符串。
● 常用方法：
    append()、extend()、insert()
    remove()、pop()、clear()
    sort()、reverse()
● 常用函数：
    max()、min()

3.3 集合set

● 集合是一个无序、去重的序列，其中的元素可以是任何对象。
● 使用大括号 { } 来创建集合，如 my_set = {1, 2, 3}。
● 集合运算：
    求交集 &
    求并集 |
    求差集 -
    求异或集 ^
    判断是否为子集 <=
● 常用方法：
    add()、update()、remove()、clear()

3.4 元组tuple

● 元组是一个不可变的序列，其中的元素可以是任何对象。
● 使用小括号 ( ) 来创建元组，如 my_tuple = (1, 2, 3)。
小括号可以省略。
● 元组可以解构赋值，如 a, b, c = my_tuple，相当于：
    a = 1
    b = 2
    c = 3
解构赋值时，可以在其中最多一个变量前加 *，这个变量的类型将会是一个列表。如 *a, b = my_tuple，相当于：
    a = [1, 2]
    b = 3

3.5 字典dict

● 字典中的元素为键值对 key-value，其中 value 可以是任何对象，key 必须是不可变对象。
● 使用大括号 { } 来创建字典，如 my_dict = {1: 'first', 2: 'second', 3: 'third'}。
    若大括号内为空，创建出来的是一个字典而不是集合。
● 可以使用 in 或 not in 关键字来判断某个值是否是字典中的 key。
● 推荐使用 my_dict.get(key) 的方式来取 value (而不是 my_dict[key] 方式)，当 key 在字典中不存在时，会返回 None 或设置的默认值 (而不是抛出 KeyError)。
● 常用方法：
    setdefault()、update()、pop()、popitem()
    keys()、values()、items()
    copy()

4 函数

4.1 函数function

● 定义函数示例：

def my_function(param1, param2, param3='param3默认值'):
    pass

● 函数的参数传递方式有两种：位置参数和关键字参数。
    位置参数： my_function(1, 2, 3)
    关键字参数： my_function(param1=1, param2=2, param3=3)
    在定义函数时，可以在参数列表的任意位置添加一个 * 参数，如

def my_function(param1, *, param2, param3='param3默认值'):
    pass

    在 * 参数后面的所有参数必须以关键字参数来传值。
● 不定长参数：
    在定义函数时，可以在其中最多一个参数前加 * ，这个参数的类型将会是一个元组，可以接收多个位置参数，这个参数后面的所有参数只能通过关键字参数来传值。
    在定义函数时，可以在最后一个参数前加 **，这个参数的类型将会是一个字典，这个参数可以接收多个关键字参数。
● 参数解包：
    传递实参时，可以在有序序列类型的参数前加 * ，会自动将序列中的元素依次作为参数传递。
    传递实参时，可以在字典类型的参数前加 ** ，会自动将字典中的键值对作为关键字参数传递。
● Python不支持重载，出现同名函数时，后定义的函数会覆盖前面的同名函数。

4.2 常用的函数

range()：返回一个自然数序列。
str()：将其他类型的数据转换成 str 类型。
len()：返回序列中元素的数目。
id()：返回对象的内存地址。
type()：返回对象的数据类型。

4.3 函数式编程

● 函数也是对象。一个函数可以接收一个或多个函数作为参数，或将一个函数作为函数的返回值返回。
● 使用 lambda 关键字可以创建匿名函数。
    常用函数：filter()、map()

my_list = [1, 2, 3, 4, 5]

f = filter(lambda i: i > 3, my_list)
print(list(f))      # 打印结果: [4, 5]

m = map(lambda i: i ** 2, my_list)
print(list(m))      # 打印结果: [1, 4, 9, 16, 25]

● 闭包：在一个内部函数中，对外部函数的变量进行引用，(并且一般外部函数的返回值为内部函数)，那么内部函数就被认为是闭包。

5 类

5.1 类type

● 一个类就是一种数据类型，类的数据类型是 type。
● 使用 class 关键字来创建类，如

class MyClass:
    pass

创建该类的实例：obj = MyClass()
实例 obj 中包含着类 MyClass 中定义的所有变量和函数。

5.2 方法method

● 当一个函数被任何一个类的实例调用时，它的数据类型就成了方法 method。

class MyClass:
    def my_function(self):
        pass


my_obj = MyClass()

print(type(MyClass.my_function))  # 打印结果: <class 'function'>
print(type(my_obj.my_function))  # 打印结果: <class 'method'>

● 习惯上来讲，我们直接将类中的函数称作方法。
● 在定义方法时，至少要定义一个参数 self。这是因为方法被类的实例调用时，Python解释器会自动将该实例作为方法的第一个参数传进去。
● 每个类被创建时，都会自动生成一些魔术方法。魔术方法可以被重写，经常被重写的魔术方法有：
    __init__：初始化方法，使用类创建实例时，会先调用魔术方法__new__创建一个对象，然后调用__init__方法对对象进行初始化。
    __str__：定义该类的对象作为参数传入str()函数时的行为，必须返回一个字符串。

6 模块化

6.1 模块module

● 在Python中一个py文件就是一个模块，模块的数据类型是 module。
我们直接执行的模块被称为主模块，程序运行时只会有一个主模块。
● 在一个模块中引入另一个模块：

    import 模块名 as 模块别名

    或者只引入模块中的部分内容：

    from 模块名 import 标识符1, 标识符2 ...

● import 语句可以写在程序的任何位置，但通常写到模块的开头。

6.2 包

在Python中一个文件夹也是一个模块，数据类型为 module，我们通常把文件夹称作包。

三、流程控制

1 分支结构(if-elif-else)

if 1 + 1 != 2:
    print('1加1不等于2')
elif 1 + 1 == 2:
    print('1加1等于2')
else:
    print('很难')

2 循环结构

2.1 while循环

i = 0
while i < 5:
    print(i)
    i += 1
else:
    print('循环结束')

2.2 foreach循环

for i in range(5):
    print(i)

3 异常处理

try:
    可能发生异常的代码块
except 异常名(若异常名为空则捕获所有异常):
    异常处理逻辑
else:
    未发生异常时执行的代码块
finally:
    无论是否发生异常都会执行的代码块

四、面向对象

Python是一门面向对象的语言。

1 对象

● Python中一切数据类型的实例都是对象。
● 每个对象中存储的数据包括 id、type 和 value。
id 是对象的唯一标识符，实际上就是给对象分配的内存地址。
type 是对象的数据类型。
value 是对象的值。在Python中，使用 == 比较两个对象的 value 是否相等，使用 is 关键字判断两个引用是否引用的是同一个对象。

2 封装

● 使用双下划线作为属性名的开头，如 __xxx ，可以对外隐藏对象的 __xxx属性，使其不可被从外部访问。
● 通常，使用 getter/setter方法获取/修改对象的某个属性。
● 封装示例：

class Person:
    def __init__(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

3 继承

● 在定义类时，可以在类名后跟一对小括号，在其中指定要继承的基类。如

class Friend(Person):
     pass

Python支持多继承，但应尽量避免。
● Python支持方法重写。当对象要调用某个方法时，会先到当前对象所属类中寻找该方法，如果找不到就到父类中继续寻找。多继承时，会按照继承父类的顺序在各个父类中依次寻找，找到即止。

4 多态

Python是动态类型语言，天生支持多态。

五、文件处理

● 读文件

file_name = 'xxx.txt'
file_stream = open(file_name) # 打开文件流
content = file_stream.read()  # 读文件 xxx.txt 中的内容
file_stream.close()    # 关闭文件流

● with...as

# 使用 with...as 的好处是无需手动关闭文件流
file_name = 'xxx.txt'
with open(file_name) as file_stream:
    content = file_stream.read(10) # read()方法可以接收一个参数，指定每次读的字符数目

● 写文件

# 文件操作类型：r: 可读(默认)  w: 可写  a: 追加
#            t: 文本文件(默认)  b: 二进制文件
file_name = 'xxx.txt'
with open(file_name, 'w', encoding='utf-8') as file_stream:
    file_stream.write('Hello World\n')
    content = input()    # 手动输入内容
    file_stream.write(content)

● 常用方法：
    tell()：返回当前读取的位置。
    seek()：要求传入一个整数，修改当前读取的位置。

六、高级应用

1 装饰器

● @property
将一个getter方法转换为对象的属性。

class Person:
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

● @classmethod 和 @staticmethod
类方法和静态方法既可以使用类的实例来调用，也可以使用类来直接调用。
两者的区别在于，调用类方法时，Python解释器会自动将该类作为第一个参数传进去，因此在定义类方法时，至少要定义一个参数 cls。
定义类的过程中，无法生成正在定义的类的实例，因此该类中的普通方法无法被调用，这时就可以使用类方法或静态方法。

2 标准库

https://docs.python.org/zh-cn/3/library/index.html