【Python学习】01-一篇文章帮你搞定Python基础
发表于：2024-03-27 |

前言

我想到我之前学过半吊子的python爬虫课，我给重新回顾一下，学个几天速成一下。写这一篇文章主要是为了记录一下python的基础语法，方便以后重温,当然我这一篇文章只能是抛砖引玉，python的基础知识绝对不止这么些，很多用法我都没有列举出来，这篇文章就是带人快速入个门。

print()函数与变量

在python中,print()函数是最常用的输出函数，可以输出字符串、数字、变量等内容。

无引号

1
print(1+1)

这里的输出结果是2

单引号

如果是要输出字符串，就需要用引号括起来

1
print('hello world')

这里的输出结果是hello world

双引号

如果这个字符串内部就带了引号，那么就需要用双引号括起来

1
print("I'm a student")

这里的输出结果是I’m a student

三引号

如果是多行字符串，就需要用三引号括起来

1
2
print('''hello
world''')

这里的输出结果是

1
2
hello
world

多个print()函数不换行

如果想要多个print()函数不换行，可以在print()函数中加一个end参数

1
2
print('hello',end='')
print('world')

这里的输出结果是helloworld,如果要俩个print()函数之间有空格，就可以这样写

1
2
print('hello',end=' ')
print('world')

同理，其他间隔符也可以通过end参数来控制

注释

在python中，注释有两种方式，一种是单行注释，一种是多行注释。

单行注释

单行注释用#号

1
# 这是一个单行注释

多行注释

多行注释用三个单引号或者三个双引号

1
2
3
4
5
6
'''
这是一个多行注释一
'''
"""
这是一个多行注释二
"""

转义符号

这里就简单贴一张图，大家了解一下就行
转义符号

变量与赋值

1
2
3
name='fake'
name='codesigner'
print(name)

这里的输出结果是codesigner

变量命名规范

这里我也贴一张图，大家可以自己看看，和其他语法是差不多的
变量命名规范

数据类型与转换

数据类型

在python中，数据类型也非常简单，就三种，分别是整数(int)、浮点数(float)、字符串(str)

字符串

字符串就是用引号包裹起来的，可以是单引号、双引号、三引号
比如’hello’、”world”、’’’hello world’’’这种

整数

整数就是没有小数点的数字
比如数字0，1，2这种

浮点数

浮点数就是有小数点的数字
比如1.1，2.2这种

数据的应用

四则运算

这里我简单贴一张图，大家看一下就行
四则运算

字符串的拼接

在python中，字符串的拼接使用+号

1
2
3
a='hello'
b='world'
print(a+b)

这里的输出结果是helloworld

占位符号打印

在python中，可以使用占位符号打印

1
2
3
age=24
name='codesigner'
print('我的名字是%s，我的年龄是%d'%(name,age))

我们看到格式符%后面有一个字母s，这是一个类型码，用来控制数据显示的类型。%s就表示先占一个字符串类型的位置。%d就表示先占一个整数类型的位置。
占位符号打印
也可以使用format()函数
format()函数用来占位的是大括号{}，不用区分类型码（%+类型码）。
具体的语法是：’str.format()’，而不是课堂上提到的’str % ()’。
而且，它对后面数据的引用更灵活，不限次数，也可指定对应关系。

1
2
3
age=24
name='codesigner'
print('我的名字是{}，我的年龄是{}'.format(name,age))

数据类型的查询——type()函数

在python中，可以使用type()函数查询数据的类型

1
2
a=1
print(type(a))

这里的输出结果是<class ‘int’>
同理，如果是字符串类型的输出结果就会是<class ‘str’>，如果是浮点数类型的输出结果就会是<class ‘float’>

数据转换

str()函数

str()函数可以将其他类型的数据转换为字符串类型

1
2
3
4
a=1
b=1.1
print(str(a))
print(str(b))

这里的输出结果是字符串的’1’和’1.1’

int()函数

int()函数可以将其他类型的数据转换为整数类型，但是只能转换浮点型的或者满足整数数字的字符串

1
2
a='1'
print(int(a))

这里的输出结果是1
小数形式的字符串，由于Python的语法规则，也不能使用int()函数强制转换。
比如我们这里的代码：

1
2
a='3.8'
print(int(a))

这里的输出结果是报错ValueError：invalid literal for int() with base 10: '3.8'

如果这里是浮点型的3.8

1
2
a=3.8
print(int(a))

这里的输出结果是3，int()函数处理浮点型的数字会自动取整，没有四舍五入，直接丢掉小数部分。

float()函数

float()函数也可以将整数和字符串转换为浮点类型。但同时，如果括号里面的数据是字符串类型，那这个数据一定得是数字形式。

1
2
3
4
5
6
height = 188.0
weight = 180.0
age = '89'
print(float(height))
print(float(weight))
print(float(age))

这里的输出结果是188.0、180.0、89.0

类型转换总结

这里我贴一张图，大家看一下就行
类型转换总结

条件判断与条件嵌套

条件判断

单向判断

单向判断：if代表什么呢？相传六颗宝石是宇宙中最强大的东西。如果一个人同时拥有六颗宝石，ta就可以实现包括毁灭宇宙在内的所有事情。

1
2
3
4
5
6
7
8
# 为宝石数量赋值
stonenumber=6

# 条件：如果你拥有的宝石数量大于等于6个
if stonenumber>=6:
    
    # 结果：显示‘你拥有了毁灭宇宙的力量’的结果
    print('你拥有了毁灭宇宙的力量')

这里唯一一个需要注意的点，需要缩进和冒号
对于Python而言，冒号和缩进是一种语法。它会帮助Python区分代码之间的层次，理解条件执行的逻辑及先后顺序。【注：缩进是四个空格或一个Tab键】
如果没有缩进，就会有这样的一个报错IndentationError: expected an indented block（缩进错误：期望一个缩进块）

双向判断

在Python，我们可以利用if的双向判断形式：if…else…去实现这个行动：当宝石数量还没达到6颗的时候，就需要继续找。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 赋值语句：为宝石数量赋值
stonenumber=3

# 条件：如果你拥有的宝石数量大于等于6个
if stonenumber>=6:
    
    # 结果：显示‘你拥有了毁灭宇宙的力量’的结果
    print('你拥有了毁灭宇宙的力量')
    
# 条件：当赋值不满足if条件时，执行else下的命令
else:
    
    # 结果：显示‘继续寻找宝石’的结果
    print('继续寻找宝石')

这个也很好理解

多向判断

在Python中，我们可以利用if的多向判断形式：if…elif…else…去实现这个行动：当宝石数量还没达到5颗的时候，就需要继续找,到达5颗还没6颗就提示还差一颗。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 为宝石数量赋值
stonenumber=5

# 条件：如果你拥有的宝石数量大于等于6个
if stonenumber>=6:
    
    # 结果：显示‘就拥有了毁灭宇宙的力量’的结果
    print('你拥有了毁灭宇宙的力量')
    
# 条件：如果想让宝石数量停留在5个以下
elif 0<=stonenumber<5:

    # 结果：显示‘需要继续找’的结果
    print('需要继续找')

# 条件：当赋值不满足if和elif条件时，执行else下的命令，宝石数量为5个
else:

    # 结果：显示‘还差一颗’的结果
    print('还差一颗')

if嵌套

比如我们有这样一个例子

1
2
3
4
5
6
7
8
9
考试成绩评价规则：

1. 如果成绩大于等于60分，就是及格，在此前提下：
(1)如果成绩大于等于80分，属于优秀范围；
(2)否则（即大于等于60分而小于80分），属于一般范围。

2. 如果成绩小于60分，就是不及格，在此前提下：
(1)如果成绩小于30分，平时太不认真，属于学渣了；
(2)如果成绩（小于60分而大于等于30分），那么，至少还能抢救一下。

我们给出一个分数，然后进行判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
historyscore=26

if historyscore>=60:
    print('你已经及格')

    if historyscore>=80:
        print('你很优秀')

    else:
        print('你只是一般般')

else:
    print('不及格')

    if historyscore<30:
        print('学渣')

    else:
        print('还能抢救一下')

print('程序结束')

此时会依次打印出不及格，学渣，程序结束

嵌套逻辑图

嵌套的逻辑就如下图
if嵌套

条件判断总结

这里我贴一张图，大家看一下就行
条件判断总结

input()函数

input()函数

input()函数的使用

input()函数是Python内置的函数，用于接收用户输入的内容。在Python中，input()函数的返回值是字符串类型。

1
2
# 为变量name赋值
name=input('请输入你的名字：')

此时在控制台输入你的名字，然后回车，name就会接收到你输入的名字,此时你可以print(name)看看你输入的是什么,答案显而易见，就是你输入的名字。

input()函数的类型转换

比如以下这段代码,无论你输入了什么，他都会走到else里面去，包括你在控制台输入了1，这是为什么呢?

1
2
3
4
5
6
7
8
9
10
11
choice = input('请输入您的选择：')
#变量赋值

if choice == 1:
#条件判断:条件1
    print('霍格沃茨欢迎您的到来。')
#条件1的结果

else:
#条件判断：其他条件
    print('您可是被梅林选中的孩子，我们不接受这个选项。')

这是因为，input()函数的返回值是字符串类型，而我们在if条件判断中，使用的是整数类型。因此，如果我们想要正常进行判断，那么就需要我们把choice==1改成choice==’1’，这样就可以正常判断了。

input()函数的类型强制转换

如果你确定输入的值肯定是整数数字，那么可以使用int()函数强制转换

1
choice = int(input('请输入您的选择：'))

input()函数的总结

这里我贴一张图，大家看一下就行
input()函数的总结

练习题

需求

这里有个练习题，大家可以自己试试看

1
2
3
4
5
6
7
8
9
10
11
12
13
将下面的对话，用代码表现出来。
小精灵：您好，欢迎来到古灵阁，请问您需要帮助吗？需要or不需要？
你：需要
小精灵：请问您需要什么帮助呢？1 存取款；2 货币兑换；3 咨询
你：2
小精灵：金加隆和人民币的兑换率为1:51.3，即一金加隆=51.3人民币
小精灵：请问您需要兑换多少金加隆呢？
（你说了一个数字N）
小精灵：好的，我知道了，您需要兑换（你说的数字N）金加隆。
小精灵：那么，您需要付给我（你说的数字N*51.3）人民币。

注1：如果选择不需要帮助，小精灵会礼貌地说'好的，再见。'
注2: 如果选择帮助【1 存取款】，小精灵会推荐你去存取款窗口；如果选择帮助【3 咨询】，小精灵会推荐你去咨询窗口。

代码

这里我给了我的代码，大家可以参考一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
req1=input('您好，欢迎来到古灵阁，请问您需要帮助吗？需要or不需要？')
if(req1=='需要'):
    req2=int(input('请问您需要什么帮助呢？1 存取款；2 货币兑换；3 咨询'))
    if(req2==1):
        print('推荐你去存取款窗口')
    elif(req2==2):
        print('金加隆和人民币的兑换率为1:51.3，即一金加隆=51.3人民币')
        req3=int(input('请问您需要兑换多少金加隆呢？'))
        print('好的，我知道了，您需要兑换'+str(req3)+'金加隆。')
        print('那么，您需要付给我'+str(req3*51.3)+'人民币。')
    else:
        print('推荐你去咨询窗口')
else:
    print('好的，再见。')

列表和字典

列表

什么是列表

简单来说，就和我们前端理解的数组差不多，就是一个有序的集合，可以存储任意类型的数据。
比如我们这样定义一个列表

1
list=['小明','小红','小刚']

列表提取单个值

这个我们的常见的是一样的，通过索引来取值，比如我们要取小明，那就是list[0]

列表提取多个值

这里，和我们平时接触的稍微有点不太一样

1
2
3
4
5
6
7
8
9
10
11
12
list2 = [5,6,7,8,9]

print(list2[:])
# 打印出[5,6,7,8,9]
print(list2[2:])
# 打印出[7,8,9]
print(list2[:2])
# 打印出[5,6]
print(list2[1:3])
#打印出[6,7]
print(list2[2:4])    
#打印出[7,8]

这里的冒号就是切片的意思，前面的数字是开始的索引，后面的数字是结束的索引，但是不包括结束的索引,和我们的slice和substring很像，这里有个口诀
左右空，取到头；左要取，右不取

给列表增加删除元素

增加元素

错误的写法

1
2
list=[1,2,3]
list.append(4,5)

此时会报错append() takes exactly one argument(2 given)
append后的括号里只能接受一个参数，但却给了两个，也就是4和5。所以，用append()给列表增加元素，每次只能增加一个元素。
正确的写法

1
2
3
list=[1,2,3]
list.append(4)
list.append(5)

这样就不会报错了
同时，append还可以直接加入一个列表

1
2
list=[1,2,3]
list.append([4,5])

此时list的值就是[1,2,3,[4,5]]

删除元素

del list[索引] # 删除索引位置的元素
这个和我们的splice非常的像

1
2
3
list=[1,2,3,4,5]
del list[2]
print(list)

这里的输出结果就是[1,2,4,5]

字典

什么是字典

字典是一种无序的数据集合，使用键-值（key-value）存储，和我们的Object对象差不多
比如我们这样定义一个字典

1
scores = {'小明':95,'小红':90,'小刚':90}

获取字典的长度

python有一个len()函数，可以获取列表、元组、字典等数据类型的长度。

1
len(scores)

获取字典的值

这个和我们的数组差不多，通过键来获取值

1
2
scores = {'小明':95,'小红':90,'小刚':90}
print(scores['小明'])

这时候得到的值是95

新增删除字典中的值

使用del关键字删除字典中的元素，然后使用键值对的形式新增元素

1
2
3
4
5
6
album = {'周杰伦':'七里香','王力宏':'心中的日月'}
del album['周杰伦']
print(album)

album['周杰伦'] = '十一月的萧邦'
print(album)

这里简单拓展一下元组，元组和列表差不多，只是元组是不可变的，不能增加删除元素

1
tuple1 = ('A','B')

获取元组中的值和列表一样，通过索引来获取

1
print(tuple1[0])

这里的输出结果就是A

for与while循环

for…in…循环

循环列表

这里给大家一个例子，注意细节，for循环后面的冒号和缩进

1
2
for item in [1,2,3,4,5]:
    print(item*2)

循环字典

此时，如果我们for循环的是一个字典

1
2
3
scores = {'小明':95,'小红':90,'小刚':90}
for key in scores:
    print(key)

这里打印出来的是字典的键
如果想打印出来的值，只需要如下执行即可

1
2
3
scores = {'小明':95,'小红':90,'小刚':90}
for key in scores:
    print(scores[key])

循环字符串

1
2
for char in 'hello':
    print(char)

这里打印出来的是h e l l o

这里需要注意的是，for in循环不能用于整数和浮点数。

range()函数

对应次数

如果你是想执行对应次数，完全可以使用range()函数

1
2
for i in range(3):
    print('我很棒')

这时候就会打印三次，我很棒，这个i如果你想用，他对应的值是0,1,2

指定范围

当然你也可以指定范围

1
2
for i in range(13,17):
    print(i)

此时的i就是13,14,15,16

限制步长

这里我限制了步长为2

1
2
for i in range(1,10,2):
    print(i)

这里的i就是1,3,5,7,9

我给大家整理出来一张图
range()函数

while循环

举例

1
2
3
4
a = 0
while a < 5:
    a = a + 1
    print(a)

相信大家都可以理解，这里的输出结果就是1,2,3,4,5，主要是注意格式，while后面的冒号和缩进

while和for循环的区别

这里给大家贴一个图
while和for循环的区别

小案例

需求

小明、小红、小刚是同班同学，且坐在同一排，分别坐在第一位、第二位、第三位。
由于他们的身高都差不多，所以，老师计划让他们三个轮流坐在第一位。
每次换座位的时候，第一位变第三位，后面两位都往前一位。

代码

1
2
3
4
5
students = ['小明','小红','小刚']
for i in range(3):
    student1 = students.pop(0)  # 运用pop()函数，同时完成提取和删除。
    students.append(student1)  # 将移除的student1安排到最后一个座位。
    print(students)

需求

小美想要用今天学到的循环打印数字1-7，不过，她不喜欢4这个数字……
但是，今天的课堂她没有认真看，导致现在有点晕，不知道怎么写代码。
所以，请你运用课堂中出现的两种循环方式，为她展示下什么叫融会贯通。

这个练习呢，其实就一件事：打印数字。
在这件事的基础上加循环（控制打印范围）和条件判断（跳过4）。
下面，请你用不同的循环方式来帮小美实现“打印1-7，但是不要4”这个愿望。

代码

1
2
3
4
5
6
7
8
9
10
11
# while 循环
n = 0
while n < 7:
    n = n+1
    if n != 4:  # 当num != 4，执行打印语句；等于4时不打印。
        print(n)

# for 循环
for num in range(1,8):  # 为同时能运行两个循环，新取参数 num。
    if num != 4:  # 当num != 4，执行打印语句；等于4时不打印。
        print(num)

布尔值和四种语句

用数据做判断:布尔值

两个数值做比较

1
print(1>2)

这里的输出结果就是False
我给大家看一下其他的比较运算符
比较运算符

直接数值做运算

1
2
if 1:
    print('True')

这里的输出结果就是True
这里我给大家看一下其他的数值判断是否为真假，这里有些可能和我们的预期不一样，比如空列表，空字典，这种在我们前端都是true，但是在python中是false
数值判断是否为真假

bool()函数

bool()函数可以将其他类型的数据转换为布尔类型

1
print(bool(1))

这里的输出结果就是True,和我们前端的Boolean()函数差不多

布尔值之间的计算

在python中，有以下的布尔运算，and、or、not、in、not in

and和or

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = 1
b = -1

print('以下是and运算')
if a==1 and b==1:    # 【b实际上是-1】
    print('True')
else:
    print('False')

print('以下是or运算')
if a==1 or b==1:  # 【b实际上是-1】
    print('True')
else:
    print('False')

比如这里的输出结果就是False、True，因为and就相当于我们的&&，or就相当于我们的||
逻辑关系就是这样
逻辑关系
逻辑关系

not

接下来我们看看【not】运算。这个运算很简单，表示翻转的意思。not True就等于False，not False就等于True。
not运算

in和not in

这俩个运算符是用来判断一个元素是否在列表、元组、字典等数据类型中的。

1
2
3
list = [1,2,3,4,5]
print(bool(1 in list))
print(bool(6 not in list))

这里的输出结果就是True、True

如果是用在字典就可以用来判断字典中是否存在某个【键】：

1
2
dict = {'小明':95,'小红':90,'小刚':90}
print(bool('小明' in dict))

这里的输出结果就是True

四种语句

break语句

我们先来看看break语句。break的意思是“打破”，是用来结束循环的，一般写作if…break。它的写法长这样：

1
2
3
4
5
6
7
8
9
10
11
# break语句搭配for循环
for...in...:
    ...
    if ...:
        break

# break语句搭配while循环
while...(条件):
    ...
    if ...:
        break

在这里，if…break的意思是如果满足了某一个条件，就提前结束循环。记住，这个只能在循环内部使用。
举个例子

1
2
3
4
for i in range(10):
    if i == 5:
        break
    print(i)

这里的输出结果就是0,1,2,3,4,因为当i等于5的时候，就会提前结束循环

continue语句

continue的意思是“继续”。这个子句也是在循环内部使用的。当某个条件被满足的时候，触发continue语句，将跳过之后的代码，直接回到循环的开始。
它的写法是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
# continue语句搭配for循环
for...in...:
    ...
    if ...:
        continue
    ...

# continue语句搭配while循环
while...(条件):
    ...
    if ...:
        continue
    ...

举个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 观察代码，然后运行代码看看是什么结果

# continue语句搭配for循环
for i in range(5):
    print('明日复明日')
    if i==3:  # 当i等于3的时候触发
        continue # 回到循环开头
    print('这句话在i等于3的时候打印不出来')

# continue语句搭配while循环
i = 0
while i<5:
    print('明日复明日')
    i = i+1
    if i==3:  # 当i等于3的时候触发
        continue # 回到循环开头
    print('这句话在i等于3的时候打印不出来')

pass语句

pass语句就非常简单了，它的英文意思是“跳过”。

1
2
3
4
5
6
a = int(input('请输入一个整数:'))
if a >= 100:
    pass
else:
    print('你输入了一个小于100的数字')

这里的意思就是，当输入的数字大于等于100的时候，就跳过，不做任何操作,否则就打印出来,如果不加pass，那么就会报错

else语句

最后一种else语句，我们在条件判断语句见过【else】，其实，else不但可以和if配合使用，它还能跟for循环和while循环配合使用。

1
2
3
4
5
6
7
for i in range(5):
    a = int(input('请输入0来结束循环，你有5次机会:'))
    if a == 0:
        print('你触发了break语句，循环结束，导致else语句不会生效。')    
        break
else:
    print('5次循环你都错过了，else语句生效了。')

所以，用一句话总结，当循环中没有碰到break语句，就会执行循环后面的else语句，否则就不会执行。

总结四种语句

这里我给大家整理了一张图
四种语句

练习

需求

假设有两名囚徒A和B因为合伙犯罪被抓捕，因没有确凿可以指认罪行的证据，审判者准备单独审判两位囚徒。
若两人都认罪，则两人各判10年；若一个认罪一个抵赖，则认罪的人判1年，抵赖的人判20年；若两人都抵赖，则各判3年。
现在，请写个代码：当两人都抵赖时，打印判决，代码结束；若为其他结果，则在打印判决后继续循环。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while True:
   a=int(input("a囚犯做出选择(1认罪，0不认罪):"))
   b=int(input("b囚犯做出选择(1认罪，0不认罪):"))
   if a==0 and b==0:
       print("都判刑3年")
       break
       #避免死循环
   elif a==1 and b==1:
       print("都判刑10年")
   else:
       if a==1:
            print("a判刑1年，b判刑20年")
       else:
            print("b判刑1年，a判刑20年")

需求

上一个练习，我们将“囚徒困境”写成了代码，让程序收集两名囚犯的认罪情况，进而决定他们的判决：
两人都认罪，则各判10年；一个认罪一个抵赖，则前者判1年，后者判20年；两人都抵赖，各判3年。只有两人都不认罪，程序才会停止。
现在有一个社会学家，在不同的人群中做这个实验，一旦遇到都不认罪的情况，就停止该人群中的实验。
同时，他希望程序能记录每一对实验者的选择，以及记录第几对实验者都选择不认罪。请你帮帮他吧。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
n = 0
list_answer = []

while True:
    n += 1
    a = input('A，你认罪吗？请回答认罪或者不认：')
    b = input('B，你认罪吗？请回答认罪或者不认：')
    list_answer.append([a,b])  # 用列表嵌套的方式来存放实验者的选择，也可用元组或字典。
    if a == '认罪' and b == '认罪':
        print('两人都得判10年，唉')
    elif a == '不认' and b == '认罪':
        print('A判20年，B判1年，唉')
    elif a == '认罪' and b == '不认':
        print('A判1年，B判20年')
    else:
        print('都判3年，太棒了')
        break

print('第' + str(n) + '对实验者选了最优解。')

for i in range(n):
    # 注意数据类型的转换，以及计数起点的不同（0和1）
    print('第' + str(i+1) + '对实验者的选择是：' + str(list_answer[i]))

需求

我很喜欢看电影，我回忆了一下，这两年我觉得还不错的国产电影。
下面，会将电影的影片名和主演放在字典里，如movie = {‘妖猫传’:[‘黄轩’,’染谷将太’]}。
需要你补充一些代码，让其他人只要输入演员名，就打印出：××出演了电影××。

代码

1
2
3
4
5
6
7
8
9
10
11
12
movies = {
'妖猫传':['黄轩','染谷将太'],
'无问西东':['章子怡','王力宏','祖峰'],
'超时空同居':['雷佳音','佟丽娅'],
}

actor = input('你想查询哪个演员？')
for  movie in movies:
    # 用 for 遍历字典
    actors = movies[movie]  # 读取各个字典的主演表
    if actor in actors:
        print(actor + '出演了电影' + movie)

函数

定义函数

1
2
3
4
5
6
7
8
9
# 函数名：1. 名字最好能体现函数的功能，一般用小写字母和单下划线、数字等组合
#      2. 不可与内置函数重名（内置函数不需要定义即可直接使用）
def math(x):
# 参数：根据函数功能，括号里可以有多个参数，也可以不带参数，命名规则与函数名相同
# 规范：括号是英文括号，后面的冒号不能丢
    y = 3*x + 5
# 函数体：函数的执行过程，体现函数功能的语句，要缩进，一般是四个空格
    return y
# return语句：后面可以接多种数据类型，如果函数不需要返回值的话，可以省略

调用函数

1
2
a = math(10)
print(a)

此时的输出结果就是35

函数参数默认值

1
2
3
4
5
6
7
8
def menu(appetizer, course, dessert = '绿豆沙'):
    print('一份开胃菜：' + appetizer)
    print('一份主食：' + course)
    print('一份甜品：' + dessert)


menu('话梅花生','牛肉拉面')
menu('话梅花生','牛肉拉面','银耳羹')

此时的结果是

1
2
3
4
5
6
一份开胃菜：话梅花生
一份主食：牛肉拉面
一份甜品：绿豆沙
一份开胃菜：话梅花生
一份主食：牛肉拉面
一份甜品：银耳羹

不定长参数

它的格式比较特殊，是一个星号*加上参数名，它的返回值也比较特殊，我们来看看下面的例子。

1
2
3
4
5
6
7
8
def menu(*barbeque):
    return barbeque

order = menu('烤鸡翅','烤茄子','烤玉米')
#括号里的这几个值都会传递给参数barbeque

print(order)
print(type(order))

我们可以看到，这里的输出结果是一个元组

1
2
('烤鸡翅', '烤茄子', '烤玉米')
<class 'tuple'>

print函数

比如说我们最熟悉的print()函数，它完整的参数其实是长这样的：

1
print(*objects, sep = ' ', end = '\n', file = sys.stdout, flush = False)

可以看到第一个参数objects带了*号，为不定长参数——这也是为什么print()函数可以传递任意数量的参数。其余四个为默认参数，我们可以通过修改默认值来改变参数，对比一下下列代码的输出结果。

1
2
3
4
5
print('金枪鱼', '三文鱼', '鲷鱼')
print('金枪鱼', '三文鱼', '鲷鱼', sep = '+')
# sep控制多个值之间的分隔符，默认是空格
print('金枪鱼', '三文鱼', '鲷鱼', sep = '+', end = '=?')
# end控制打印结果的结尾，默认是换行)

结果是这样的

1
2
3
金枪鱼 三文鱼 鲷鱼
金枪鱼+三文鱼+鲷鱼
金枪鱼+三文鱼+鲷鱼=?

返回多个参数

这里引入了一个random模块，使用了random.choice()函数，它的作用是从一个列表中随机选择一个元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import random 
#引入random模块

appetizer = ['话梅花生','拍黄瓜','凉拌三丝']
def coupon(money):
    if money < 5:
        a = random.choice(appetizer)
        return a
    elif 5 <= money < 10:
        b = random.choice (appetizer)
        return b, '溏心蛋'

print(coupon(3))
print(coupon(6))

这里当我们执行coupon(3)的时候，输出结果是拍黄瓜，当我们执行coupon(6)的时候，输出结果是(‘拍黄瓜’, ‘溏心蛋’)，他是一个元组

当然我们返回的时候赋值的时候也可以分开接受参数，比如

1
dish,egg=coupon(6)

此时我们的dish就是拍黄瓜，egg就是溏心蛋

函数的嵌套

我们这里写了一个函数，然后sum_cost()函数需要使用cost()函数的变量，但其实这个函数是错误的，因为variable_cost是一个局部变量，而不是像rent一样的全局变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rent = 3000

def cost():
    utilities = int(input('请输入本月的水电费用'))
    food_cost = int(input('请输入本月的食材费用'))
    variable_cost = utilities + food_cost
    print('本月的变动成本费用是' + str(variable_cost))

def sum_cost():
    sum = rent + variable_cost
    print('本月的总成本是' + str(sum))

cost()
sum_cost()

此时，如果我们想要是哟个cost中的variable_cost变量，我们可以这样写,添加一个global语句,让这个局部变量变成全局的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
rent = 3000

def cost():
    global variable_cost
    utilities = int(input('请输入本月的水电费用'))
    food_cost = int(input('请输入本月的食材费用'))
    variable_cost = utilities + food_cost
    print('本月的变动成本费用是' + str(variable_cost))

def sum_cost():
    sum = rent + variable_cost
    print('本月的总成本是' + str(sum))

cost()
sum_cost()

或者我们可以直接把cost()函数的返回值赋值给variable_cost

1
2
3
4
5
6
7
8
9
10
11
12
13
rent = 3000
def cost():
    utilities = int(input('请输入本月的水电费用'))
    food_cost = int(input('请输入本月的食材费用'))
    variable_cost = utilities + food_cost
    print('本月的变动成本费用是' + str(variable_cost))
    return variable_cost

def sum_cost():
    sum = rent + cost()
    print('本月的总成本是' + str(sum))

sum_cost()

try…except…语句排除异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
while True:
    try:
        x = input('请你输入被除数：')
        y = input('请你输入除数：')
        z = float(x)/float(y)
        print(x,'/',y,'=',z)
        break  # 默认每次只计算一次，所以在这里写了 break。
    except ZeroDivisionError:  # 当除数为0时，跳出提示，重新输入。
        print('0是不能做除数的！')
    except ValueError:  # 当除数或被除数中有一个无法转换成浮点数时，跳出提示，重新输入。
        print('除数和被除数都应该是整值或浮点数！')
    
    # 方式2：将两个（或多个）异常放在一起，只要触发其中一个，就执行所包含的代码。
    # except(ZeroDivisionError,ValueError):
    #     print('你的输入有误，请重新输入！')
    
    # 方式3：常规错误的基类，假设不想提供很精细的提示，可以用这个语句响应常规错误。
    # except Exception:
    #     print('你的输入有误，请重新输入！')

类与对象

创建类

1
2
3
4
5
6
7
8
# 类名首字母大写
class Chinese:
    # 用赋值语句，创建类的属性
    eye = 'black'

    # 创建实例方法时，不要漏了 self
    def eat(self):
        print('吃饭，选择用筷子。')

类的调用

1
2
3
4
5
6
# 创建实例
person = Chinese()
# 调用实例方法
person.eat()
# 调用类属性
print(person.eye)

类的创建与调用

类传参

1
2
3
4
5
6
7
8
9
10
11
class Chinese:

    name = '吴枫'  # 类属性name

    def say(self, someone):  # 带有两个参数的方法
        print(someone + '是中国人')

person = Chinese()
print(person.name)
person.say('吴枫') 
# self调用时要忽略，'吴枫'传给参数someone

那你可能会产生疑问了，这个self是干什么用的，其实self是指向类本身的，也就是说，self就是Chinese这个类，比如我们要获取name这个属性，我们可以这样写

1
2
3
4
5
6
class Chinese:

    name = '吴枫'  # 类属性name

    def say(self, someone):  # 带有两个参数的方法
        print(self.name + '是中国人')

特殊方法-初始化方法

定义初始化方法的格式是def __init__(self)，是由init加左右两边的【双】下划线组成（ initialize “初始化”的缩写）。

初始化方法的作用在于：当每个实例对象创建时，该方法内的代码无须调用就会自动运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Chinese:

    def __init__(self, name, birth, region):
        self.name = name   # self.name = '吴枫' 
        self.birth = birth  # self.birth = '广东'
        self.region = region  # self.region = '深圳'

    def born(self):
        print(self.name + '出生在' + self.birth)

    def live(self):
        print(self.name + '居住在' + self.region)    

person = Chinese('吴枫','广东','深圳') # 传入初始化方法的参数
person.born()
person.live()

类的继承

python中的继承是通过在类名后面的括号中写上父类的名字来实现的,下面这个例子就是子类Cantonese继承了父类Chinese

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Chinese:
    eye = 'black'

    def eat(self):
        print('吃饭，选择用筷子。')

class Cantonese(Chinese):  
# 通过继承，Chinese类有的，Cantonese类也有
    pass

# 验证子类可以继承父类的属性和方法，进而传递给子类创建的实例
yewen = Cantonese()  
# 子类创建的实例，从子类那间接得到了父类的所有属性和方法
print(yewen.eye)  
# 子类创建的实例，可调用父类的属性
yewen.eat()  
# 子类创建的实例，可调用父类的方法

isinstance()

具体用法是输入两个参数（第一个是实例，第二个是类或类组成的元组），输出是布尔值（True 或 False）可以用来判断某个实例是否属于某个类。

1
2
3
4
5
6
print(isinstance(1,int))
# 判断1是否为整数类的实例
print(isinstance(1,str))

print(isinstance(1,(int,str)))
# 判断实例是否属于元组里几个类中的一个

答案是True、False、True

ok，我们用来判断一下类的继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Chinese:
    pass

class Cantonese(Chinese):
    pass

gonger = Chinese()
# 宫二，电影《一代宗师》女主，生于东北
yewen = Cantonese()
# 叶问，电影《一代宗师》男主，生于广东

print('\n验证1：子类创建的实例同时也属于父类')
print(isinstance(gonger,Chinese))  
print(isinstance(yewen,Chinese))  

print('\n验证2：父类创建的实例不属于子类。')
print(isinstance(gonger,Cantonese))

print('\n验证3：类创建的实例都属于根类。')
print(isinstance(gonger,object))  
print(isinstance(yewen,object))

答案是

1
2
3
4
5
6
7
8
9
10
验证1：子类创建的实例同时也属于父类
True
True

验证2：父类创建的实例不属于子类。
False

验证3：类创建的实例都属于根类。
True
True

整理关系图

类的继承关系

类的多层继承和多重继承

类的多层继承和多重继承

多层继承例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Earthman:
    eye_number = 2

# 中国人继承了地球人
class Chinese(Earthman):
    eye_color = 'black'

# 广东人继承了中国人，同时也继承了地球人。
class Cantonese(Chinese):
    pass

yewen = Cantonese()
print(yewen.eye_number)
print(yewen.eye_color)

多重继承例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Su:
    born_city = 'Jiangsu'
    wearing = 'thick'  # 穿得较厚

    def diet(self):
        print('我们爱吃甜。')

class Yue:
    settle_city = 'Guangdong'
    wearing = 'thin'  # 穿得较薄

    def diet(self):
        print('我们吃得清淡。')

class Yuesu(Yue,Su):
    pass

xiaoming = Yuesu()
print(xiaoming.wearing)
print(xiaoming.born_city)
xiaoming.diet()

类的定制

就是我们常见的子类继承父类，然后在子类中添加一些属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Chinese:
    eye = 'black'

    def eat(self):
        print('吃饭，选择用筷子。')

class Cantonese(Chinese):  # 类的继承
    native_place = 'guangdong'  # 类的定制

    def dialect(self):  # 类的定制
        print('我们会讲广东话。')

yewen = Cantonese()
print(yewen.eye)
# 父类的属性能用
print(yewen.native_place)
# 子类的定制属性也能用
yewen.eat()
# 父类的方法能用
yewen.dialect()
# 子类的定制方法也能用

类的重写

子类继承父类，然后对父类的方法进行重写

1
2
3
4
5
6
7
8
class Chinese:
    def land_area(self,area):
        print('我们居住的地方，陆地面积是%d万平方公里左右。'% area)

class Cantonese(Chinese):
    # 直接对方法进行重写
    def land_area(self,area):
        print('我们居住的地方，陆地面积是%d万平方公里左右。'% int(area * 0.0188))

这里一般都有优雅一点的写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Chinese:

    def land_area(self,area):
        print('我们居住的地方，陆地面积是%d万平方公里左右。'% area)

class Cantonese(Chinese):
    # 间接对方法进行重写
    def land_area(self, area, rate = 0.0188):
        Chinese.land_area(self, area * rate)
        # 直接继承父类方法，再调整参数。

gonger = Chinese()
yewen = Cantonese()
gonger.land_area(960)
yewen.land_area(960)

案例

需求

下面，请你通过参数默认值的改变，完成子类的定制，让程序的运行结果为“雷猴！欢迎来到广东。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Chinese:
    def __init__(self, greeting='你好', place='中国'):
        self.greeting = greeting
        self.place = place

    def greet(self):
        print('%s！欢迎来到%s。' % (self.greeting, self.place))

# 请为子类完成定制，代码量：两行。
class Cantonese(Chinese):
    
yewen = Cantonese()
yewen.greet()

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Chinese:

    def __init__(self, greeting = '你好', place = '中国'):
        self.greeting = greeting
        self.place = place

    def greet(self):
        print('%s！欢迎来到%s。' % (self.greeting, self.place))

class Cantonese(Chinese):

    def __init__(self, greeting = '雷猴', place = '广东'):
        Chinese.__init__(self, greeting, place)
    
yewen = Cantonese()
yewen.greet()

到这里，我们就简单了解了python的一些基础语法。

结语

本篇文章主要是对python的一些基础语法的简单介绍，相对而言还是比较简单的，希望对大家学习或工作有所帮助。

Python学习
上一篇:
【JAVA学习】07-跟着黑马程序员课程敲全栈项目(四)
下一篇:
文件展开-webkitRelativePath

    • blog of codesigner