Python 基础(二)

🍦 Python面向对象，易于阅读维护，丰富的库可用于Web开发、爬虫、自动化运维、自动化测试和数据分析等，功能十分强大。

1 函数

  • 函数
    • 只有在被调用时才会运行，可以将参数传递给函数，函数返回数据作为结果。
    • 通过def关键字定义函数，调用函数时，需要使用函数名称，后跟括号()。
1
2
3
4
5
def myfunc():                                    # def定义函数
    print("Function")


myfunc()                                         # 调用函数

1-1 参数

  • 参数
    • 信息可以作为参数传递给函数，缩写为args，任意参数缩写为*args。
    • 参数在函数名之后的括号内指定，可添加任意数量的参数，用逗号分隔。
    • 默认情况下须使用正确数量的参数调用函数，函数需几个参数就必须使用几个参数调用该函数。
    • 若不知道传递给函数的参数数量，则在函数定义的参数名称前使用星号*，接收一个参数元组。
    • 函数定义不能为空，若函数内部没有定义内容，使用pass关键字可以避免语句报错。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def myfunc(name):                               # 带有一个参数name的函数
    print(name + " Refsnes.")


myfunc("Emil")


def myfunc(f_name, l_name):                     # 该函数带有两个参数，调用时就使用两个参数
    print(f_name + " " + l_name + ".")


myfunc("Lily", "Refsnes")


def my_func(*kids):                             # 任意参数
    print("The youngest child is " + kids[2] + ".")


my_func("Emil", "Lydia", "Linus")


def my_func():
    pass                                        # pass关键字避免出错

1-2 关键字

  • 关键字
    • 使用key = value语法进行参数发送，这样就不用考虑参数的顺序了。
    • 关键字参数通常缩写为kwargs，任意关键字参数则缩写为**kwargs。
    • 若不知道传递给函数的关键字参数数量，则在函数定义的参数名称前使用两个星号**，接收参数字典。
1
2
3
4
5
6
7
8
9
10
11
12
def myfunc(child3, child2, child1):             # key = value
    print("The youngest child is " + child3 + ".")


myfunc(child1="Emil", child2="Lily", child3="Linus")


def my_func(**kid):                             # 任意关键字参数
    print("The youngest child's last name is " + kid["l_name"] + ".")


my_func(f_name="Lily", l_name="Refsnes")

1-3 函数调用

  • 函数调用
    • 调用不带参数的函数，可使用默认值参数，return语句可让函数返回值。
    • 将任何数据类型的参数发送给函数，会在函数内部被视为相同的数据类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def myfunc(country="Fujian"):
    print("I am from " + country + ".")


myfunc()                                        # 使用默认值参数


def myfunc(x):
    return 3 * x                                # 让函数返回值


print(myfunc(3))


def my_func(food):
    for y in food:
        print(y)


fruits = ["Apple", "Grape", "Peach"]
my_func(fruits)                                 # 使用列表作为参数

1-4 函数递归

  • 函数递归
    • 函数递归意味着自定义的函数可以调用自身，递归是一个常见的数学和编程概念。
    • 编写时易陷入一个永无止境或使用过多内存的函数中，递归也是有效的编程方法。
1
2
3
4
5
6
7
8
9
10
11
def my_recursion(i):                            # 自定义my_recursion函数，使用变量i作为参数
    if i > 0:
        result = i + my_recursion(i - 1)        # 每次递归时递减1
        print(result)
    else:                                       # 当条件小于等于0时，递归结束
        result = 0
    return result


print("Recursion Example Results.")
my_recursion(3)

1-5 匿名函数

  • 匿名函数
    • 匿名函数lambda(关键字)，可接受任意数量的参数，但只能有一个表达式。
    • 在另一函数中将一个函数用作匿名函数时，可以很好地展示lambda的作用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
x = lambda i: i+10                              # 将10添加到参数i中，并返回结果
print(x(5))
x = lambda a, b: a*b                            # 将参数a与参数b相乘，并返回结果
print(x(5, 6))
x = lambda a, b, c: a+b+c                       # 汇总参数a、b、c，并返回结果
print(x(10, 2, 3))


def myfunc(y):                                  # 定义一个带有一个参数的函数，并将该参数乘以一个未知数
    return lambda i: i*y


my_doubler = myfunc(2)                          # 创建一个始终发送数字加倍的函数
print(my_doubler(11))
my_tripler = myfunc(3)                          # 创建一个始终发送数字三倍的函数
print(my_tripler(11))

2 对象

  • 对象
    • Python是一种面向对象的编程语言，Python中一切皆对象，都有其属性和方法。
    • 使用class关键字创建一个类，一个类就如同一个对象构造器，用于创建对象。
    • 所有类都有一个名为__init()的函数，__init__()函数总是在类启动时执行。
    • class定义不能为空，若class没有定义内容，使用pass关键字可以避免语句报错。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class MyClass:                                  # 创建一个名为MyClass的类，并带有一个名为x的属性
    x = "Lydia"


p = MyClass()                                   # 创建一个名为p的对象，并打印x的值
print(p.x)                                      # 这是最为简单的类和对象，但在实际应用中没有真正用处


class Person:                                   # 创建名为Person的类，__init__()函数为name和age赋值
    def __init__(self, name, age):
        self.name = name
        self.age = age


q = Person("Lydia", 26)
print(q.name)
print(q.age)

q.age = 25                                      # 修改对象属性
print(q.age)
del q.age                                       # 删除q对象中的age属性
del q                                           # 删除q对象


class Person:
    pass                                        # pass关键字避免出错

2-1 对象方法

  • 对象方法
    • 对象也可以包含方法，对象中的方法属于该对象的函数。
    • 参数self是对当前类实例的引用，用于访问属于该类的变量。
1
2
3
4
5
6
7
8
9
10
11
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def myfunc(self):                           # 创建对象方法，插入一个打印函数，并在q对象上执行
        print("My name is " + self.name + ".")


q = Person("Lydia", 26)
q.myfunc()

2-2 self参数

  • self参数
    • 参数self是对当前类实例的引用，用于访问属于该类的变量。
    • 不必命名为self，可随意调用，但必须是类中任何函数的第一个参数。
1
2
3
4
5
6
7
8
9
10
11
class Person:
    def __init__(object, name, age):
        object.name = name
        object.age = age

    def myfunc(abc):                            # object和abc代替self
        print("My name is " + abc.name + ".")


q = Person("Lydia", 26)
q.myfunc()

3 继承

  • 继承
    • 让类与类之间产生父子关系，即获取另一个类的静态属性或方法。
    • 父类也叫基类或超类，子类是从另一个类继承的类，也叫派生类。
    • 任何类都可以是父类，语法与创建类相同，创建子类时需将父类作为参数发送。
    • __init__()函数每次使用类创建新对象时都会自动调用该函数，将其添加到子类中。
      • 子类不再继承父类的__init__()函数，会覆盖父类__init__()函数的继承。
      • 为保持父类的__init__()函数继承，需添加对父类__init__()函数的调用。
    • 还可以使用super()函数，让子类继承父类的所有方法和属性。
    • 若在子类中添加与父类中函数同名的方法，会覆盖父方法的继承。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class Person:                                   # 创建Person父类，具有f_name和l_name属性
    def __init__(self, f_name, l_name):
        self.f_name = f_name
        self.l_name = l_name

    def printname(self):                        # 创建printname方法
        print(self.f_name, self.l_name)


x = Person("Lily", "Doe")
x.printname()


class Student1(Person):                         # 创建Student1子类，继承Person类的属性和方法
    # pass                                      # 将__init__()函数添加到Student1子类中
    def __init__(self, f_name, l_name):
        Person.__init__(self, f_name, l_name)   # 添加对父类函数的调用，保留父类的继承


y = Student1("Lucy", "Doe")
y.printname()


class Student2(Person):
    def __init__(self, f_name, l_name, year):
        super().__init__(f_name, l_name)        # super函数不必使用父类名称，自动继承
        self.graduation = year                  # 添加一个Student2子类的graduation属性


z = Student2("Liki", "Doe", 2019)
print(z.f_name, z.l_name, z.graduation)


class Student3(Person):
    def __init__(self, f_name, l_name, year):
        super().__init__(f_name, l_name)
        self.graduation = year

    def welcome(self):                          # 添加一个调用类welcome方法
        print("Welcome", self.f_name, self.l_name, "to the class of", self.graduation, ".")


x = Student3("Liki", "Doe", 2019)
x.welcome()

4 迭代器

  • 迭代器
    • 一个实现迭代器协议的对象，由方法__iter__()和__next__()组成。
    • 列表、元组、字典和集合等都是可迭代对象，都有iter()属性，用于获取迭代器。
    • for循环遍历可迭代对象，实际上for循环即创建一个迭代器并循环执行next()方法。
1
2
3
4
5
6
7
8
9
10
11
12
my_tuple = ("Apple", "Grape", "Mango")
my_fruit = iter(my_tuple)                       # 元组返回一个迭代器，并打印每个值
print(next(my_fruit))
print(next(my_fruit))
print(next(my_fruit))

mystring = "apple"                              # 字符串也是可迭代对象
alphabet = iter(mystring)
print(next(alphabet))

for x in my_tuple:                              # for循环即一个迭代器
    print(x)
  • 类和对象迭代器
    • 要将类和对象创建为一个迭代器，必须使用__iter__()和__next__()方法。
      • __iter__()方法进行初始化等操作，始终返回迭代器对象本身。
      • __next__()方法允许执行操作，并且必须返回序列中的下一项。
      • 如果有足够的next()语句或在for循环中使用，迭代将永远进行。
    • __next__()中添加StopIteration终止条件，以在迭代完成指定次数时引发错误，防止迭代永远进行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class MyNum1:                                   # 创建一个返回数字的迭代器
    def __iter__(self):
        self.a = 1                              # 从1开始
        return self

    def __next__(self):
        x = self.a
        self.a += 1                             # 每个序列递增1
        return x


my_class = MyNum1()
my_iters = iter(my_class)
print(next(my_iters))
print("-")


class MyNum2:                                   # 创建一个返回数字的迭代器
    def __iter__(self):
        self.a = 1                              # 从1开始
        return self

    def __next__(self):
        x = self.a
        self.a += 1                             # 每个序列递增1
        return x


my_class = MyNum2()
my_iters = iter(my_class)
print(next(my_iters))
print("-")


class MyNum3:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= 9:                         # 9次迭代后停止
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration


my_class = MyNum3()
my_iters = iter(my_class)

for x in my_iters:
    print(x)

5 变量范围

  • 局部范围
    • 在函数内部创建的变量属于该函数的局部范围，并且只能在该函数内部使用。
    • 函数内部创建的局部变量，对函数内部的任何函数都可用(嵌套函数都可用)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def myfunc():
    x = 30                                      # 在myfunc函数内部创建的变量，在该函数内部可用
    print(x)


myfunc()


def myfunc():
    y = 26

    def inner_func():
        print(y)                                # 可以从函数内的函数访问局部变量y
    inner_func()


myfunc()
  • 全局范围
    • 在代码的主体中创建的变量是全局变量，属于全局范围，可以在任何范围内使用。
    • 若函数内外都使用相同变量名，将视为两个单独的变量，分别作用于函数内外部。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
x = 30


def myfunc():
    print(x)                                    # 可以在函数内部使用


myfunc()
print(x)                                        # 也可以在主体代码中使用

y = 30


def myfunc():
    y = 26
    print(y)                                    # 局部变量作用于函数内部


myfunc()
print(y)                                        # 全局变量作用于函数外部
  • 全局关键字
    • 使用global关键字，在函数内部创建全局变量。
    • 若要更改函数内的全局变量，需使用关键字引用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def myfunc():
    global x                                    # global关键字创建全局变量
    x = 30


myfunc()
print(x)

y = 30


def myfunc():
    global y                                    # 修改函数内的全局变量y
    y = 26


myfunc()
print(y)

6 模块使用

  • 模块使用
    • 模块可以看成一个代码库，包含了一组要包含在应用程序中的函数文件。
    • 创建一个模块，只需要将所需的代码保存在文件扩展名为.py的文件中。
    • 使用模块则通过import语句导入：import module_name.function_name。
    • 模块中可包含函数，也可包含所有类型的变量，例如：数组、字典、对象等。

6-1 创建模块

1
2
3
4
5
6
7
8
9
def greeting(name):                              # 将该函数保存在名为greeting目录的greeting.py文件中
    print("Hello, " + name + ".")


person = {                                       # 该字典也存在于greeting.py文件中
    "name": "Lydia",
    "age": "30",
    "country": "China"
}

6-2 导入模块

1
2
3
4
5
6
7
8
9
10
11
from greeting import greeting                   # 使用import语句导入创建的greeting模块

greeting.greeting("Lydia")
x = greeting.person["age"]                      # 访问person字典
print(x)


from greeting import greeting as x              # 将greeting模块重命名为x

y = x.person["age"]
print(y)

6-3 内置模块

  • 内置模块
    • 导入模块时可以使用as关键字创建别名，dir()函数可以列出模块中的所有函数名称。
    • 使用from关键字从模块中导入部分元素，导入时引用模块中的元素不要使用模块名称。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import platform

z = dir(platform)                               # dir()函数可用于所有模块，包括自定义模块
print(z)


from greeting.greeting import person

print(person["name"])                           # 仅从模块中导入person字典


from greeting import greeting

print(greeting.person["name"])                  # 不使用模块名称，例如greeting.person["name"]

(1) Math

  • 内置函数
    • min()和max()可用于查找可迭代对象中的最小值和最大值。
    • abs()返回指定数字的绝对值，pow(x, y)则返回x的y次幂。
  • 使用时需要导入math模块，导入后就可以使用模块的方法和常量了。
    • math.sqrt()：返回一个数字的平方根。
    • math.ceil()：将一个数字向上舍入取整。
    • math.floor()：将一个数字向下舍入取整。
    • math.pi：常数，返回PI，即圆周率3.14159265...的值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
a = min(5, 7, 9)                                # 5
b = max(5, 7, 9)                                # 9
c = abs(-2)                                     # 2
d = pow(2, 3)                                   # 2*2*2
print(a)
print(b)
print(c)
print(d)
print("-")


import math

x = math.sqrt(64)                               # 返回一个数字的平方根
y = math.ceil(1.45)                             # 向上取整，返回2
z = math.floor(1.45)                            # 向下取整，返回1
print(x)
print(y)
print(z)
print(math.pi)                                  # 返回圆周率PI

(2) Json

  • 一种用于存储和交换数据的语法，是文本，使用JavaScript对象表示法编写。
  • Python中有内置包json，用于处理json数据，使用前需要import导入json模块。
  • json.loads()方法可以用来解析json字符串，结果将会返回一个Python字典。
  • json.dumps()方法可以将Python对象直接转换为json字符串。
    • json.dumps()方法具有参数，用indent参数定义缩进数。
    • 使用separators参数定义分隔符，默认值为(", ", ": ")。
    • 即：使用逗号和空格分隔每个对象，使用冒号和空格分隔键和值。
    • 该方法还可用于对结果中的键进行排序，使用sort_keys参数指定。
  • Python对象与等效的json(JavaScript)，转换如下。
    • 对象(json)、dict(Object)、list(Array)、tuple(Array)、string(String)。
    • int(Number)、float(Number)、True(true)、False(false)、None(null)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import json

x = {"name": "Lydia", "age": "26", "city": "XiaMen"}
y = json.dumps(x)                               # 从Python字典转换为json字符串
print(type(y))

x = '{"name": "Lydia", "age": "26", "city": "XiaMen"}'
y = json.loads(x)                               # 从json字符串转换为python字典
print(type(y))
print(y)

print(json.dumps("Hi"))
print(json.dumps(1357))
print(json.dumps(31.7))
print(json.dumps(None))                         # 将Python对象转换为json字符串并打印
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(["apple", "grape"]))
print(json.dumps(("apple", "grape")))
print(json.dumps({"name": "Lydia", "age": "30", "city": "XiaMen"}))

z = {
    "name": "Lydia",
    "age": 26,
    "married": True,
    "divorced": False,
    "children": ("Ann", "Billy"),
    "pets": None,
    "cars": [
        {"model": "BMW 230", "mpg": 27.5},
        {"model": "Ford Edge", "mpg": 24.1}
    ]
}
print(json.dumps(z))                            # 转换一个包含所有合法数据类型的Python对象
print(json.dumps(z, indent=4))
print(json.dumps(z, indent=4, separators=(". ", " = ")))
print(json.dumps(z, indent=4, sort_keys=True))

(3) Datetime

  • 导入该模块可以显示当前日期，包含年、月、日、时、分、秒和微秒。
  • 创建日期使用模块的构造函数datetime()，需年、月、日这三个参数。
    • 该函数接受时间参数和时区参数(例如：时、分、秒、微秒、tzone)。
    • 该函数的时间和时区参数都可选，且具默认值0，时区默认值为None。
  • strftime()方法将日期对象格式化为可读字符串，接受参数，使用format指定返回字符串的格式。
  • 时间日期格式化符号，示例如下。
    • %a·····················Wed(简化星期)
    • %A·····················Wednesday(完整星期)
    • %b·····················Dec(简化月份)
    • %B·····················December(完整月份)
    • %c·····················Mon Dec 29 17:17:00 2019
    • %C·····················20(世纪)
    • %d·····················31(日，0-31)
    • %f·····················548513(微秒)
    • %G·····················2019(年份，ISO 8601)
    • %H·····················20(时，00-23，24小时制)
    • %I·····················07(时，01-12，12小时制)
    • %j·····················365(年中的第n天，001-366)
    • %m·····················06(月份，01-12)
    • %M·····················15(分钟，00-59)
    • %p·····················A.M.或P.M.
    • %S·····················15(秒，00-59)
    • %u·····················1(星期，1-7，ISO 8601)
    • %U·····················52(一年中的星期数，00-53，星期天开始)
    • %V·····················01(一年中的星期数，01-53，ISO 8601)
    • %w·····················0(星期，0-6，星期天开始)
    • %W·····················52(一年中的星期数，00-53，星期一开始)
    • %x·····················01/01/19
    • %X·····················17:15:00
    • %y·····················19(年份，00-99)
    • %Y·····················2019(年份，0000-9999)
    • %z·····················+0100(UTC offset，标准时间偏移)
    • %Z·····················CST(当前时区的名称)
    • %%·····················%(本身)
1
2
3
4
5
6
7
8
9
10
import datetime

x = datetime.datetime.now()
print(x.month)                                  # 显示月份
print(x.strftime("%a"))                         # 显示英文星期

y = datetime.datetime(2019, 1, 1)               # 创建一个日期对象
print(y.strftime("%B"))                         # 显示英文月份
print(y)
print(x)                                        # 显示当前日期

(4) 正则表达式

  • 形成搜索模式的字符序列，用于检查字符串是否包含指定的搜索模式。
  • Python有一个re内置包，用于处理正则表达式，使用前需导入re模块。
    • findall()：返回一个包含所有匹配项的列表。
    • sub()：将匹配项替换为选择的文本，可以通过count参数来控制替换次数。
    • search()：在字符串中搜索匹配项，若有，返回一个Match对象，若多个，返回匹配项的第一个。
    • split()：返回一个列表，其中字符串在每次匹配时都被拆分，可通过maxsplit参数控制出现次数。
  • 元字符：代表在正则表达式中具有特殊意义的专用字符，用来规定其前导字符在目标对象中的出现模式。
    • []·····················一组字符，例如"[a-m]"
    • \······················特殊序列，也可用于转义字符，例如"\d"
    • .······················除换行符之外的任何字符，例如"he..o"
    • ^······················以“hello”开头，例如"^hello"
    • $······················以“world”结尾，例如"world$"
    • *······················零次或多次出现，例如"he.*o"
    • +······················一次或多次出现，例如"he.+o"
    • ?······················零次或一次出现，例如"he.?o"
    • {}·····················指定出现的次数，例如"he.{2}o"
    • \|·····················或，例如"falls | stays"
    • ()·····················捕获和分组
  • 集合类特殊字符
    • [arn]··················返回指定字符“a、r或n”之一的任意匹配项
    • [a-n]··················返回任意小写字符的匹配项
    • [0-9]··················返回0到9之间任意数字的匹配项
    • [^arn]·················返回除“a、r和n”之外的任意字符匹配项
    • [0123]·················返回指定数字“0、1、2或3”之一的任意匹配项
    • [a-zA-Z]···············返回a到z、A到Z之间任意字母的匹配项
    • [0-5][0-9]·············返回从00到59之间任意两位数字的匹配项
    • [+]····················集合中“+*.|()${} ”都无特殊含义，返回匹配字符串中任意“+”字符
  • 特殊序列类字符
    • \A·····················如果指定字符位于字符串“The”的开头，则返回匹配项，例如"\AThe"
    • \b·····················返回位于单词“ain”的开头或结尾的指定字符匹配项，例如r"\bain"
    • \B·····················返回不位于单词“ain”的开头或结尾的指定字符匹配项，例如r"ain\B"
    • \d·····················返回字符串包含0到9数字的匹配项，例如"\d"
    • \D·····················返回字符串不包含数字0到9的匹配项，例如"\D"
    • \s·····················用于匹配单个空格符，包括tab键和换行符，例如"\s"
    • \S·····················用于匹配除单个空格符之外的所有字符，例如"\S"
    • \w·····················用于匹配a到z的字符、0到9的数字和下划线(_)字符，例如"\w"
    • \W·····················用于匹配所有与\w不匹配的字符，例如"\W"
    • \Z·····················如果指定字符位于字符串“Spain”的末尾，则返回匹配项，例如"Spain\Z"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import re

txt = "The rain in Spain."

x = re.search("\s", txt)                        # 搜索字符串中的第一个空格字符的位置
print(x.start())
y = re.findall("Portugal", txt)                 # 没找到匹配项，返回一个空列表
print(y)

x = re.search("Portugal", txt)                  # 没找到匹配项，返回None
print(x)
y = re.findall("ai", txt)                       # 按找到的顺序包含匹配项
print(y)

x = re.sub("\s", "9", txt, 2)                   # 替换前两次出现的空白字符
print(x)
y = re.sub("\s", "9", txt)                      # 用9替换每个空白字符
print(y)

x = re.split("\s", txt, 1)                      # 仅在第一次出现时拆分字符串
print(x)
y = re.split("\s", txt)                         # 在每个空白字符处进行拆分
print(y)

x = re.search("^The.*Spain.$", txt)             # 查看是否以The开头，并以Spain.结尾
print(x)
  • 匹配对象
    • 指包含有关搜索和结果信息的对象，若无匹配，将返回None。
    • Match对象具有用于检索有关搜索的信息和结果的属性与方法。
      • span()：返回一个包含匹配“开始和结束位置”的元组。
      • string：返回传递给函数的字符串。
      • group()：返回字符串中匹配的部分。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import re

txt = "The rain in Spain."

a = re.search(r"\bS\w+", txt)                   # 打印匹配的字符串部分
print(a.group())

b = re.search(r"\bS\w+", txt)                   # 查找以大写S开头的任何单词，并打印第一个匹配项的位置
print(b.span())

c = re.search(r"\bS\w+", txt)                   # 打印传入函数的字符串
print(c.string)

d = re.search("ai", txt)                        # 执行将返回匹配对象的搜索
print(d)

7 用户输入

  • 用户输入
    • Python3.6版本使用input()方法进行用户输入。
    • Python2.7版本使用raw_input()进行用户输入。
    • 涉及到input()函数时停止执行，并在用户给出输入后继续执行。
1
2
3
4
5
userName = input("Enter username: ")             # Python3.6
print("The name entered is " + userName + ".")

# userName = raw_input("Enter username: ")       # Python2.7，已停止维护
# print("The name entered is " + userName + ".")

8 异常处理

  • 异常处理
    • try允许测试代码块的错误，except允许处理代码块的错误，else代码块允许在没有错误时执行代码。
    • finally代码块不管try和except代码块的结果如何，都允许执行代码，可以用于关闭对象和清理资源。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
try:                                            # 发生错误或异常时，停止并生成错误信息，使用try处理异常
    print(a)
except:                                         # try引发异常，执行except语句，若无try代码块，则程序崩溃
    print("出现了异常")


try:
    print(b)
except NameError:                               # try异常，若为NameError，打印该信息，否则打印except语句
    print("未定义变量")
except:
    print("出现了异常")


try:
    print("你好呀朋友")
except:                                         # try若异常，只执行except中的内容
    print("出现了异常")
else:                                           # try若没有异常，使用else定义要执行的代码块将被执行
    print("未发生异常")


try:
    print(c)
except:
    print("出现了异常")
finally:                                        # 指定finally，无论try是否异常，都将执行该代码块
    print("执行完成啦")


try:                                            # 尝试打开并写入一个不可写(不存在)的文件
    f = open("file.txt")
    try:
        f.write("内容的写入")
    except:
        print("写入时异常")
    finally:
        f.close()                               # 用于关闭对象和清理资源
except:
    print("打开时异常")
  • 引发异常
    • 使用raise关键字可以选择在条件发生时抛出异常。
    • 可定义要引发的错误类型，及抛出异常时要打印给用户查看到的文本内容。
1
2
3
4
5
6
7
x = -1
if x < 0:                                        # 如果x小于0，引发异常并停止程序
    raise Exception("不允许小于零")

y = "Hi~"
if not type(y) is int:                           # 如果y不是整数，引发TypeError异常
    raise TypeError("只能输入整数")

9 命名规范

  • 命名规范
    • Python的命名规范需要遵循PEP8标准，使用良好的编码风格会让代码更具备可读性。
    • 命名尽量使用全拼写单词，部分常用缩写则使用约定俗成的缩写方式，如num、ID等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
类：大驼峰命名，ClassName
异常：大驼峰命名，ExceptionName

文件：蛇形命名，file_name
模块：蛇形命名，module_name
包名：蛇形命名，package_name
项目：大驼峰命名，ProjectName

方法：蛇形命名，method_name
函数：蛇形命名，function_name
实例：蛇形命名，instance_variable_name

局部变量：蛇形命名，local_variable_name
全局变量：蛇形命名，global_variable_name
函数参数：蛇形命名，function_parameter_name
全局常量：蛇形命名 + 全大写，GLOBAL_CONSTANT_NAME
  • 下划线
    • 一个前缀下划线表示私有，一个后缀下划线可避免关键字冲突。
    • 以单下划线开头
      • 以单下划线开头的是弱内部使用标识，引包时不会导入该对象。
      • 通常用于指示一个私有的变量或函数，但是不会真正变为私有。
      • 而是被视为非公开的，即不该被直接访问或调用的变量或函数。
    • 以双下划线开头：指示一个特殊的变量或函数，会被解释器重命名，避免与子类中的同名变量或函数发生冲突。
    • 以双下划线开头和结尾：通常用于指示一个特殊的变量，会被解释器重命名，避免与用户定义的变量发生冲突。
Python
#函数 #对象 #模块 #异常处理
Python 基础(二)
https://stitch-top.github.io/2021/01/15/python/python02-python-ji-chu-er/
作者
Dr.626
发布于
2021年1月15日 23:15:27
许可协议