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
3
4
5

1.2 列表高级

列表的增删改查

添加元素

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

• append 在末尾添加元素

• insert 在指定位置插入元素

• extend 合并两个列表

append

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

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

#['张三', '李四', '王五']
1
2
3
4
5

insert

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

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

#['张三', '小明', '李四']
1
2
3
4
5

extend

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

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

#['张三', '李四', '小丽', '小王']
1
2
3
4
5
6

修改元素

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

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

name_list[1] = '小丽'
print("修改后：%s" % name_list)

#修改前：['张三', '李四']
#修改后：['张三', '小丽']
1
2
3
4
5
6
7
8

查找元素

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

• in 和 not in

python中查找的常用方法为：

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

name_list = ['张三', '李四']

if '王五' in name_list:
    print('存在')
else:
    print('不存在')

#不存在
1
2
3
4
5
6
7
8

not类似，只不过取反

删除元素

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

• del：根据下标进行删除

• pop：删除最后一个元素

• remove：根据元素的值进行删除

del

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

#['张三', '小丽']
1
2
3
4
5

pop

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

#['张三', '李四']
1
2
3
4
5

remove

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

#['李四', '小丽']
1
2
3
4
5

1.3 元组高级

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

1.3.1 访问元组

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

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

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

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

tuple1 = (1)
print(type(tuple1))  #int

tuple2 = (1,)
print(type(tuple2)) #tuple
1
2
3
4
5

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
2
3
4
5
6
7
8
9
10
11

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
2
3
4
5
6
7
8
9

1.5.2 修改元素

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

person = {'name': '张三', 'age': 18}

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

1.5.3 添加元素

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

person = {'name': '张三', 'age': 18}

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

1.5.4 删除元素

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

• del

• clear()

del删除指定的元素

person = {'name': '张三', 'age': 18}

del person['age']
print(person)  #{'name': '张三'}
1
2
3
4

del删除整个字典

person = {'name': '张三', 'age': 18}

del person
print(person)  #报错：NameError: name 'person' is not defined
1
2
3
4

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

person = {'name': '张三', 'age': 18}

person.clear()
print(person)  #{}
1
2
3
4

1.5.5 字典的遍历

遍历字典的key（键）

person = {'name': '张三', 'age': 18, 'email': '123@126.com'}

for s in person.keys():
    print(s)
    
#name
#age
#email
1
2
3
4
5
6
7
8

遍历字典的value（值）

person = {'name': '张三', 'age': 18, 'email': '123@126.com'}

for s in person.values():
    print(s)
    
#张三
#18
#123@126.com
1
2
3
4
5
6
7
8

遍历字典的项（元素）

person = {'name': '张三', 'age': 18, 'email': '123@126.com'}

for i in person.items():
    print(i)
    
#('name', '张三')
#('age', 18)
#('email', '123@126.com')
1
2
3
4
5
6
7
8

遍历字典的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
1
2
3
4
5
6
7
8

2. 函数

2.1 定义函数

定义函数的格式如下：

def 函数名(): 
    代码
1
2

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

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

示例：

#定义函数
def f1():
    print('hello ')
    print('world')

f1() #定义完函数后，函数是不会自动执行的，需要调用它才可以
1
2
3
4
5
6

结果：

hello 
world
1
2

函数定义好以后，函数体里的代码并不会执行，如果想要执行函数体里的内容，需要手动的调用函数。

每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了。

2.2 函数参数

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

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

def sum(a, b):
    print('a的值是：%s，b的值是：%s，计算和为：%s' % (a, b, a + b))

sum(9, 1)  # 位置参数	
sum(b = 1,a = 9) # 关键字参数
1
2
3
4
5

结果：

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

注意点：

• 在定义函数的时候，小括号里写等待赋值的变量名

• 在调用函数的时候，小括号里写真正要进行运算的数据

调用函数时参数的顺序

• 定义时小括号中的参数，用来接收参数用的，称为 “形参” (形式参数)

• 调用时小括号中的参数，用来传递给函数用的，称为 “实参” (实际参数)

2.3 函数返回值

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

带有返回值的函数

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

示例：

def sum(a, b):
    return a + b

#使用一个变量接受函数的返回值
a = sum(9, 1)

print(a)  #10
1
2
3
4
5
6
7

2.4 局部变量和全局变量

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

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

局部变量：

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


f1()
1
2
3
4
5
6
7

全局变量：

#定义全局变量a
a = 1


def f1():
    print(a)


f1()
1
2
3
4
5
6
7
8
9

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

3. 文件

3.1 文件的打开与关闭

打开文件/创建文件

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

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

#这里使用相对路径，就是在当前目录下

f = open("test.txt", 'w')
1
2
3

文件路径

• 绝对路径：指的是绝对位置，完整地描述了目标的所在地，所有目录层级关系是一目了然的。

  • 例如： 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()
1
2
3
4
5

访问模式：

3.2 文件的读写

写数据(write)

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

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

f.close()
1
2
3
4
5

读数据(read)

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

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

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

f.close()
1
2
3
4
5
6
7

注意：

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

读数据（readline）

readline只用来读取一行数据。

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

f.close()
1
2
3
4
5
6
7

读数据（readlines）

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

一个元素。

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

f.close()
1
2
3
4
5

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()
1
2
3
4
5
6
7
8
9
10
11

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

f = open("test.txt", 'w')
person = ['zs', 'ls']

# 导入json模块到该文件中
import json

names = json.dump(person, f)

f.close()
1
2
3
4
5
6
7
8
9

使用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()
1
2
3
4
5
6
7
8
9
10
11

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

f = open("test.txt", 'r')

# 导入json模块到该文件中
import json

names = json.load(f)
print(names)
print(type(names))

f.close()
1
2
3
4
5
6
7
8
9
10

4. 异常

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

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

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

4.1 读取文件异常

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

4.2 try…except语句

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

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

示例：

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

Python基础语法入门篇(一)