Python基础语法入门篇(二)

旧城等待， 2023-09-28 12:45 32阅读 0赞

[Python基础语法入门篇(一)][Python]

## 1. **数据类型高级** ##

### 1.1 **字符串高级** ###

字符串的常见操作包括：

*  获取长度：`len`         len函数可以获取字符串的长度。
 *  查找内容：`find`         查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中**第一次出现**的开始位置索引值(从0开始计算)，如果不存在，则返回-1.
 *  判断：`startswith`,`endswith`   判断字符串是不是以谁谁谁开头/结尾
 *  计算出现次数：`count`      返回 str在start和end之间 ，在字符串中出现的次数
 *  替换内容：`replace`       替换字符串中指定的内容，如果指定次数count，则替换不会超过count次。
 *  切割字符串：`split`       通过参数的内容切割字符串
 *  修改大小写：`upper`,`lower`    将字符串转为大写或小写
 *  空格处理：`strip`        去空格
 *  字符串拼接：`join`        字符串拼接

str = "a"
    print(str.join('hello'))
    #haealalao
    
    #重点解释一下join，会把指定字符串添加到字符串的每个字符的中间(第一个字符和最后一个字符不加)。一般用的不多

### 1.2 **列表高级** ###

列表的增删改查

**添加元素**

添加元素有一下几个方法:

*  `append` 在末尾添加元素
 *  `insert` 在指定位置插入元素
 *  `extend` 合并两个列表

**append**

`append`会把新元素添加到列表末尾

name_list = ['张三', '李四']
    name_list.append('王五')
    print(name_list)
    
    #['张三', '李四', '王五']

**insert**

`insert(index, object)`在指定位置index前插入元素object

name_list = ['张三', '李四']
    name_list.insert(1, '小明')
    print(name_list)
    
    #['张三', '小明', '李四']

**extend**

通过`extend`可以将另一个列表中的元素逐一添加到列表中

name_list = ['张三', '李四']
    name_list2 = ['小丽', '小王']
    name_list.extend(name_list2)
    print(name_list)
    
    #['张三', '李四', '小丽', '小王']

**修改元素**

我们是通过指定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可。

name_list = ['张三', '李四']
    print("修改前：%s" % name_list)
    
    name_list[1] = '小丽'
    print("修改后：%s" % name_list)
    
    #修改前：['张三', '李四']
    #修改后：['张三', '小丽']

**查找元素**

所谓的查找，就是看看指定的元素是否存在，主要包含一下几个方法：

*  `in` 和 `not in`

python中查找的常用方法为：

*  `in`（存在）,如果存在那么结果为true，否则为false
 *  `not in`（不存在），如果不存在那么结果为true，否则false

name_list = ['张三', '李四']
    
    if '王五' in name_list:
        print('存在')
    else:
        print('不存在')
    
    #不存在

not类似，只不过取反

**删除元素**

列表元素的常用删除方法有：

*  `del`：根据下标进行删除
 *  `pop`：删除最后一个元素
 *  `remove`：根据元素的值进行删除

**del**

name_list = ['张三', '李四', '小丽']
    del name_list[1]
    print(name_list)
    
    #['张三', '小丽']

**pop**

name_list = ['张三', '李四', '小丽']
    name_list.pop()
    print(name_list)
    
    #['张三', '李四']

**remove**

name_list = ['张三', '李四', '小丽']
    name_list.remove('张三')
    print(name_list)
    
    #['李四', '小丽']

### 1.3 **元组高级** ###

Python的元组与列表类似，不同之处在于**元组的元素不能修改**。元组使用小括号，列表使用方括号。

#### 1.3.1 访问元组 ####

tuple1 = (1, 2, 3)
    print(tuple1[1])  #2

python中不允许修改元组的数据，包括不能删除其中的元素。

#### 1.3.2 **定义只有一个数据的元组** ####

定义只有一个元素的元组，需要**在唯一的元素后写一个逗号**

tuple1 = (1)
    print(type(tuple1))  #int
    
    tuple2 = (1,)
    print(type(tuple2)) #tuple

### 1.4 切片 ###

切片是指对操作的对象截取其中一部分的操作。**字符串、列表、元组**都支持切片操作。

切片的语法：\[起始:结束:步长\]，也可以简化使用 \[起始:结束\]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

# 索引是通过下标取某一个元素 
    # 切片是通过下标去某一段元素
    
    s = 'Hello World!'
    print(s)
    
    print(s[4])  # o 字符串里的第4个元素
    print(s[3:7])  # lo W 包含下标 3，不含下标 7
    print(s[1:])  # ello World! 从下标为1开始，取出 后面所有的元素（没有结束位）
    print(s[:4])  # Hell 从起始位置开始，取到 下标为4的前一个元素（不包括结束位本身）
    print(s[1:5:2])  # el 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）

### 1.5 **字典高级** ###

#### 1.5.1 **查看元素** ####

除了使用key查找数据，还可以使用get来获取数据

person = {
        'name': '张三', 'age': 18}
    
    # 不可以通过 .属性，获取值
    print(person['name'])
    # print(person['email'])  # 获取不存在的key，会发生异常
    
    print(person.get('name'))
    print(person.get('email'))  # 获取不存在的key，会获取到None值，不会出现异常
    print(person.get('email', '123@126.com'))  # 获取不存在的key, 可以提供一个默认值。

#### 1.5.2 **修改元素** ####

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

person = {
        'name': '张三', 'age': 18}
    
    person['name'] = '小丽'
    print('修改后的值是：%s' % person)  #修改后的值是：{'name': '小丽', 'age': 18}

#### 1.5.3 **添加元素** ####

如果在使用 **变量名\[‘键’\] = 数据** 时，这个“键”在字典中，不存在，那么就会新增这个元素

person = {
        'name': '张三', 'age': 18}
    
    person['email'] = '123.@126.com'
    print('添加后的值是：%s' % person)  #添加后的值是：{'name': '张三', 'age': 18, 'email': '123.@126.com'}

#### 1.5.4 **删除元素** ####

对字典进行删除操作，有一下几种：

*  `del`
 *  `clear()`

**del删除指定的元素**

person = {
        'name': '张三', 'age': 18}
    
    del person['age']
    print(person)  #{'name': '张三'}

**del删除整个字典**

person = {
        'name': '张三', 'age': 18}
    
    del person
    print(person)  #报错：NameError: name 'person' is not defined

**clear清空整个字典，但保留字典的结构**

person = {
        'name': '张三', 'age': 18}
    
    person.clear()
    print(person)  #{}

#### 1.5.5 **字典的遍历** ####

**遍历字典的key（键）**

person = {
        'name': '张三', 'age': 18, 'email': '123@126.com'}
    
    for s in person.keys():
        print(s)
        
    #name
    #age
    #email

**遍历字典的value（值）**

person = {
        'name': '张三', 'age': 18, 'email': '123@126.com'}
    
    for s in person.values():
        print(s)
        
    #张三
    #18
    #123@126.com

**遍历字典的项（元素）**

person = {
        'name': '张三', 'age': 18, 'email': '123@126.com'}
    
    for i in person.items():
        print(i)
        
    #('name', '张三')
    #('age', 18)
    #('email', '123@126.com')

**遍历字典的key-value（键值对）**

person = {
        'name': '张三', 'age': 18, 'email': '123@126.com'}
    
    for k, v in person.items():
        print('key是：%s，value是：%s' % (k, v))
        
    #key是：name，value是：张三
    #key是：age，value是：18
    #key是：email，value是：123@126.com

## 2. **函数** ##

### 2.1 **定义函数** ###

**定义函数的格式如下：**

def 函数名(): 
        代码

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它

调用函数很简单的，通过 **函数名()** 即可完成调用

**示例：**

#定义函数
    def f1():
        print('hello ')
        print('world')
    
    f1() #定义完函数后，函数是不会自动执行的，需要调用它才可以

**结果：**

hello 
    world

> 函数定义好以后，函数体里的代码并不会执行，如果想要执行函数体里的内容，需要手动的调用函数。
> 
> 每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了。

### 2.2 函数参数 ###

为了让一个函数更通用，例如想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接 收数据，就解决了这个问题，这就是函数的参数

**定义、调用带有参数的函数**来计算任意两个数字之和:

def sum(a, b):
        print('a的值是：%s，b的值是：%s，计算和为：%s' % (a, b, a + b))
    
    sum(9, 1)  # 位置参数	
    sum(b = 1,a = 9) # 关键字参数

**结果：**

a的值是：9，b的值是：1，计算和为：10
    a的值是：9，b的值是：1，计算和为：10

**注意点：**

*  在定义函数的时候，小括号里写等待赋值的变量名
 *  在调用函数的时候，小括号里写真正要进行运算的数据

**调用函数时参数的顺序**

*  定义时小括号中的参数，用来接收参数用的，称为 “形参” (形式参数)
 *  调用时小括号中的参数，用来传递给函数用的，称为 “实参” (实际参数)

### 2.3 函数返回值 ###

**所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果**

**带有返回值的函数**

想要在函数中把结果返回给调用者，需要在函数中使用return

**示例：**

def sum(a, b):
        return a + b
    
    #使用一个变量接受函数的返回值
    a = sum(9, 1)
    
    print(a)  #10

### 2.4 局部变量和全局变量 ###

**1）全局变量**：如果一个变量定义在函数外部，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

**2）局部变量**，就是在函数内部定义的变量，其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的

**局部变量：**

def f1():
        #定义局部变量a
        a = 1
        print(a)
    
    
    f1()

**全局变量：**

#定义全局变量a
    a = 1
    
    
    def f1():
        print(a)
    
    
    f1()

**注意**：从上边看我们在程序中所有的变量**都定义为全局变量就可以替代局部变量**，实际上不可以这么做。在满足条件的情况下，**要使用作用域最小的那个变量**。就好像50码的鞋，谁都能穿，但是我们只穿适合自己大小的鞋。

## 3. **文件** ##

### 3.1 **文件的打开与关闭** ###

**打开文件/创建文件**

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件。

**open(文件路径，访问模式)**

#这里使用相对路径，就是在当前目录下
    
    f = open("test.txt", 'w')

**文件路径**

*  绝对路径：指的是绝对位置，完整地描述了目标的所在地，所有目录层级关系是一目了然的。
    
     *  例如： E:\\python ，从电脑的盘符开始，表示的就是一个绝对路径。
 *  相对路径：是从当前文件所在的文件夹开始的路径。
    
     *  test.txt ，是在当前文件夹查找 test.txt 文件
     *  ./test.txt ，也是在当前文件夹里查找 test.txt 文件， ./ 表示的是当前文件夹。
     *  …/test.txt ，从当前文件夹的上一级文件夹里查找 test.txt 文件。 …/ 表示的是上一级文件夹
     *  demo/test.txt ，在当前文件夹里查找 demo 这个文件夹，并在这个文件夹里查找 test.txt 文件。

**关闭文件：**

#这里需要手动创建file文件夹，变量通常命名f或fp
    f = open("file/test.txt", 'w')
    
    # 关闭这个文件
    f.close()

**访问模式：**

<table> 
 <thead> 
  <tr> 
   <th>访问模式</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>r</td> 
   <td>以只读方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，则报错。<strong>这是默认模式。</strong></td> 
  </tr> 
  <tr> 
   <td>w</td> 
   <td>打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td>a</td> 
   <td>打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将 会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td> 
  </tr> 
  <tr> 
   <td>r+</td> 
   <td>打开一个文件用于读写。文件指针将会放在文件的开头。</td> 
  </tr> 
  <tr> 
   <td>w+</td> 
   <td>打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td>a+</td> 
   <td>打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模 式。如果该文件不存在，创建新文件用于读写。</td> 
  </tr> 
  <tr> 
   <td>rb</td> 
   <td>以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。</td> 
  </tr> 
  <tr> 
   <td>wb</td> 
   <td>以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新 文件。</td> 
  </tr> 
  <tr> 
   <td>ab</td> 
   <td>以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是 说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td> 
  </tr> 
  <tr> 
   <td>rb+</td> 
   <td>以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头</td> 
  </tr> 
  <tr> 
   <td>wb+</td> 
   <td>以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文 件。</td> 
  </tr> 
  <tr> 
   <td>ab+</td> 
   <td>以二进制格式打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。如果该文 件不存在，创建新文件用于读写。</td> 
  </tr> 
 </tbody> 
</table>

### 3.2 **文件的读写** ###

**写数据(write)**

使用`write()`可以完成向文件写入数据

# w模式如果文件存在，会先清空文件内容，然后再写。如果模式变为a,就会执行追加操作
    f = open("test.txt", 'w')
    f.write('hello world\n' * 3)
    
    f.close()

**读数据(read)**

使用`read(num)`可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入

num，那么就表示读取文件中所有的数据

f = open("test.txt", 'r')
    content = f.read(2) # 最多读取2个数据
    print(content)
    content = f.read() # 从上次读取的位置继续读取剩下的所有的数据
    print(content)
    
    f.close()

**注意：**

*  如果用open打开文件时，如果使用的`"r"`，那么可以省略 `open('test.txt')`

**读数据（readline）**

readline只用来读取一行数据。

f = open("test.txt")
    content = f.readline()
    print(content)
    content = f.readline()
    print(content)
    
    f.close()

**读数据（readlines）**

`readlines`可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个**列表**，其中每一行为列表的

一个元素。

f = open("test.txt")
    content = f.readlines()
    print(content)
    
    f.close()

### 3.3 **序列化和反序列化** ###

通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果是一个对象(例如列表、字典、元组等)，就无

法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。

通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果是一个对象(例如列表、字典、元组等)，就无

法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。

设计一套协议，按照某种规则，把内存中的数据转换为字节序列，保存到文件，这就是序列化，反之，从文件的字

节序列恢复到内存中，就是反序列化。

对象—》字节序列 就是 序列化

字节序列–》对象 就是 反序列化

Python中提供了JSON这个模块用来实现数据的序列化和反序列化。

**JSON模块**

`JSON(JavaScriptObjectNotation`, JS对象简谱)是一种轻量级的数据交换标准。JSON的本质是字符串。

**使用JSON实现序列化**

JSON提供了dump和dumps方法，将一个对象进行序列化。

**dumps方法**的作用是把对象转换成为字符串，它本身不具备将数据写入到文件的功能。

f = open("test.txt", 'w')
    person = ['zs', 'ls']
    
    # 导入json模块到该文件中
    import json
    
    # 序列化，将python对象变成json字符串
    names = json.dumps(person)
    f.write(names)
    
    f.close()

**dump方法**可以在将对象转换成为字符串的同时，指定一个文件对象，把转换后的字符串写入到这个文件里

f = open("test.txt", 'w')
    person = ['zs', 'ls']
    
    # 导入json模块到该文件中
    import json
    
    names = json.dump(person, f)
    
    f.close()

**使用JSON实现反序列化**

使用`loads`和`load`方法，可以将一个JSON字符串反序列化成为一个Python对象。

`loads`方法需要一个字符串参数，用来将一个字符串加载成为Python对象。

f = open("test.txt", 'r')
    
    # 导入json模块到该文件中
    import json
    
    # 调用loads方法,将文件中的字符串转换成python对象
    names = json.loads(f.read())
    print(names)   # ['zs', 'ls']
    print(type(names)) # <class 'list'>
    
    f.close()

`load`方法可以传入一个文件对象，用来将一个文件对象里的数据加载成为Python对象。

f = open("test.txt", 'r')
    
    # 导入json模块到该文件中
    import json
    
    names = json.load(f)
    print(names)
    print(type(names))
    
    f.close()

## 4. 异常 ##

程序在运行过程中，由于我们的编码不规范，或者其他原因一些客观原因，导致我们的程序无法继续运行，此时，

程序就会出现异常。如果我们不对异常进行处理，程序可能会由于异常直接中断掉。为了保证程序的健壮性，我们

在程序设计里提出了异常处理这个概念。

### 4.1 **读取文件异常** ###

在读取一个文件时，如果这个文件不存在，则会报出 `FileNotFoundError` 错误。

![在这里插入图片描述][3bf62c1b2fdb4cc988a3ea375525597d.png]

### 4.2 try…except语句 ###

`try...except`语句可以对代码运行过程中可能出现的异常进行处理。 语法结构:

try: 
        可能会出现异常的代码块 
    except 异常的类型: 
        出现异常以后的处理语句

**示例：**

try:
        f = open("test.txt", 'r')
        print(f.read())
    except FileNotFoundError:
        print('文件没有找到,请检查文件名称是否正确')

[Python基础语法入门篇(一)][Python]

[Python]: https://blog.csdn.net/weixin_43847283/article/details/125493963?spm=1001.2014.3001.5501
[3bf62c1b2fdb4cc988a3ea375525597d.png]: https://img-blog.csdnimg.cn/3bf62c1b2fdb4cc988a3ea375525597d.png